diff --git a/src/codechicken/microblock/MicroMaterialRegistry.scala b/src/codechicken/microblock/MicroMaterialRegistry.scala index 5d4c199..680d1b5 100644 --- a/src/codechicken/microblock/MicroMaterialRegistry.scala +++ b/src/codechicken/microblock/MicroMaterialRegistry.scala @@ -145,7 +145,7 @@ object MicroMaterialRegistry throw new IllegalStateException("You must register your materials in the init methods.") if (typeMap.remove(name).isEmpty) - logger.error("Material with id " + name + " is was not registered.") + logger.error("Material with id " + name + " was not registered.") logger.debug("Replaced micro material: " + name) diff --git a/src/codechicken/multipart/MultipartGenerator.scala b/src/codechicken/multipart/MultipartGenerator.scala index cedeedb..babdfec 100644 --- a/src/codechicken/multipart/MultipartGenerator.scala +++ b/src/codechicken/multipart/MultipartGenerator.scala @@ -1,14 +1,15 @@ package codechicken.multipart import net.minecraft.tileentity.TileEntity -import scala.collection.immutable.Map import net.minecraft.world.World import codechicken.lib.vec.BlockCoord import codechicken.multipart.handler.MultipartProxy import codechicken.lib.packet.PacketCustom -import codechicken.multipart.asm.IMultipartFactory -import codechicken.multipart.asm.ASMMixinFactory import net.minecraft.network.play.server.S23PacketBlockChange +import java.util.BitSet +import scala.collection.mutable.Map +import codechicken.multipart.asm.MultipartMixinFactory +import codechicken.multipart.asm.ASMImplicits._ /** * This class manages the dynamic construction and allocation of container TileMultipart instances. @@ -22,23 +23,21 @@ import net.minecraft.network.play.server.S23PacketBlockChange */ object MultipartGenerator { - private var tileTraitMap:Map[Class[_], Set[String]] = Map() - private var interfaceTraitMap_c:Map[String, String] = Map() - private var interfaceTraitMap_s:Map[String, String] = Map() - private var partTraitMap_c:Map[Class[_], Seq[String]] = Map() - private var partTraitMap_s:Map[Class[_], Seq[String]] = Map() + private val tileTraitMap = Map[Class[_], BitSet]() + private val interfaceTraitMap_c = Map[String, String]() + private val interfaceTraitMap_s = Map[String, String]() + private val partTraitMap_c = Map[Class[_], BitSet]() + private val partTraitMap_s = Map[Class[_], BitSet]() + private val clientTraitId = MultipartMixinFactory.registerTrait(classOf[TileMultipartClient]) - var factory:IMultipartFactory = ASMMixinFactory - - def partTraitMap(client:Boolean) = if(client) partTraitMap_c else partTraitMap_s - - def interfaceTraitMap(client:Boolean) = if(client) partTraitMap_c else interfaceTraitMap_s - - def traitsForPart(part:TMultiPart, client:Boolean):Seq[String] = - { - var ret = partTraitMap(client).getOrElse(part.getClass, null) - if(ret == null) - { + //scratch bitset + private val bitset = new BitSet() + + private def partTraitMap(client:Boolean) = if(client) partTraitMap_c else partTraitMap_s + private def interfaceTraitMap(client:Boolean) = if(client) interfaceTraitMap_c else interfaceTraitMap_s + + private def traitsForPart(part:TMultiPart, client:Boolean) = + partTraitMap(client).getOrElseUpdate(part.getClass, { def heirachy(clazz:Class[_]):Seq[Class[_]] = { var superClasses:Seq[Class[_]] = clazz.getInterfaces.flatMap(c => heirachy(c)):+clazz @@ -46,17 +45,23 @@ object MultipartGenerator superClasses = superClasses++heirachy(clazz.getSuperclass) return superClasses } - - val interfaceTraitMap = if(client) interfaceTraitMap_c else interfaceTraitMap_s - ret = heirachy(part.getClass).flatMap(c => interfaceTraitMap.get(c.getName)).distinct - if(client) - partTraitMap_c = partTraitMap_c+(part.getClass -> ret) - else - partTraitMap_s = partTraitMap_s+(part.getClass -> ret) - } - return ret + + val map = interfaceTraitMap(client) + val traits = heirachy(part.getClass).flatMap(c => map.get(c.nodeName)).distinct + + val bitset = new BitSet + traits.map(MultipartMixinFactory.getId).foreach(bitset.set) + bitset + }) + + private def setTraits(part:TMultiPart, client:Boolean):Unit = setTraits(Seq(part), client) + + private def setTraits(parts:Iterable[TMultiPart], client:Boolean) { + bitset.clear() + parts.foreach(p => bitset.or(traitsForPart(p, client))) + if(client) bitset.set(clientTraitId) } - + /** * Check if part adds any new interfaces to tile, if so, replace tile with a new copy and call tile.addPart(part) * returns true if tile was replaced @@ -64,12 +69,11 @@ object MultipartGenerator private[multipart] def addPart(world:World, pos:BlockCoord, part:TMultiPart):TileMultipart = { val (tile, converted) = TileMultipart.getOrConvertTile2(world, pos) - var partTraits = traitsForPart(part, world.isRemote) + setTraits(part, world.isRemote) + var ntile = tile - if(ntile != null) - { - if(converted)//perform client conversion - { + if(ntile != null) { + if(converted) {//perform client conversion ntile.partList(0).invalidateConvertedTile() world.setBlock(pos.x, pos.y, pos.z, MultipartProxy.block, 0, 0) silentAddTile(world, pos, ntile) @@ -77,21 +81,20 @@ object MultipartGenerator ntile.partList(0).onConverted() ntile.writeAddPart(ntile.partList(0)) } - + val tileTraits = tileTraitMap(tile.getClass) - partTraits = partTraits.filter(!tileTraits(_)) - if(!partTraits.isEmpty) - { - ntile = factory.generateTile(partTraits++tileTraits, world.isRemote) + bitset.andNot(tileTraits) + if(!bitset.isEmpty) { + bitset.or(tileTraits) + ntile = MultipartMixinFactory.construct(bitset) tile.setValid(false) silentAddTile(world, pos, ntile) ntile.from(tile) } } - else - { + else { world.setBlock(pos.x, pos.y, pos.z, MultipartProxy.block, 0, 0) - ntile = factory.generateTile(partTraits, world.isRemote) + ntile = MultipartMixinFactory.construct(bitset) silentAddTile(world, pos, ntile) } ntile.addPart_impl(part) @@ -101,8 +104,7 @@ object MultipartGenerator /** * Adds a tile entity to the world without notifying neighbor blocks or adding it to the tick list */ - def silentAddTile(world:World, pos:BlockCoord, tile:TileEntity) - { + def silentAddTile(world:World, pos:BlockCoord, tile:TileEntity) { val chunk = world.getChunkFromBlockCoords(pos.x, pos.z) if(chunk != null) chunk.func_150812_a(pos.x & 15, pos.y, pos.z & 15, tile) @@ -111,37 +113,26 @@ object MultipartGenerator /** * Check if tile satisfies all the interfaces required by parts. If not, return a new generated copy of tile */ - private[multipart] def generateCompositeTile(tile:TileEntity, parts:Iterable[TMultiPart], client:Boolean):TileMultipart = - { - val partTraits = parts.toSeq.flatMap(traitsForPart(_, client)).distinct - if(tile != null && tile.isInstanceOf[TileMultipart]) - { - val tileTraits = tileTraitMap(tile.getClass) - if(partTraits.forall(tileTraits(_)) && partTraits.size == tileTraits.size)//equal contents - return tile.asInstanceOf[TileMultipart] - - } - return factory.generateTile(partTraits, client) + private[multipart] def generateCompositeTile(tile:TileEntity, parts:Iterable[TMultiPart], client:Boolean) = { + setTraits(parts, client) + if(tile != null && tile.isInstanceOf[TileMultipart] && bitset == tileTraitMap(tile.getClass)) + tile.asInstanceOf[TileMultipart] + else + MultipartMixinFactory.construct(bitset) } /** * Check if there are any redundant interfaces on tile, if so, replace tile with new copy */ - private[multipart] def partRemoved(tile:TileMultipart, part:TMultiPart):TileMultipart = - { - val client = tile.getWorldObj.isRemote - val partTraits = tile.partList.flatMap(traitsForPart(_, client)) - val testSet = partTraits.toSet - if(!traitsForPart(part, client).forall(testSet(_))) - { - val ntile = factory.generateTile(testSet.toSeq, client) + private[multipart] def partRemoved(tile:TileMultipart) = { + val ntile = generateCompositeTile(tile, tile.partList, tile.getWorldObj.isRemote) + if(ntile != tile) { tile.setValid(false) silentAddTile(tile.getWorldObj, new BlockCoord(tile), ntile) ntile.from(tile) ntile.notifyTileChange() - return ntile } - return tile + ntile } /** @@ -151,31 +142,24 @@ object MultipartGenerator /** * register traits to be applied to tiles containing parts implementing s_interface - * s_trait for server worlds (may be null) * c_trait for client worlds (may be null) + * s_trait for server worlds (may be null) */ - def registerTrait(s_interface:String, c_trait:String, s_trait:String) - { - if(c_trait != null) - { - if(interfaceTraitMap_c.contains(s_interface)) + def registerTrait(s_interface$:String, c_trait$:String, s_trait$:String) { + val s_interface = nodeName(s_interface$) + val c_trait = nodeName(c_trait$) + val s_trait = nodeName(s_trait$) + + def registerSide(map:Map[String, String], traitName:String) = if(traitName != null) { + if(map.contains(s_interface)) logger.error("Trait already registered for "+s_interface) - else - { - interfaceTraitMap_c = interfaceTraitMap_c+(s_interface->c_trait) - factory.registerTrait(s_interface, c_trait, true) - } - } - if(s_trait != null) - { - if(interfaceTraitMap_s.contains(s_interface)) - logger.error("Trait already registered for "+s_interface) - else - { - interfaceTraitMap_s = interfaceTraitMap_s+(s_interface->s_trait) - factory.registerTrait(s_interface, s_trait, false) + else { + map.put(s_interface, traitName) + MultipartMixinFactory.registerTrait(traitName) } } + registerSide(interfaceTraitMap_c, c_trait) + registerSide(interfaceTraitMap_s, s_trait) } def registerPassThroughInterface(s_interface:String):Unit = registerPassThroughInterface(s_interface, true, true) @@ -189,31 +173,16 @@ object MultipartGenerator * * This allows compatibility with APIs that expect interfaces on the tile entity. */ - def registerPassThroughInterface(s_interface:String, client:Boolean, server:Boolean) - { - val tType = factory.generatePassThroughTrait(s_interface) + def registerPassThroughInterface(s_interface:String, client:Boolean, server:Boolean) { + val tType = MultipartMixinFactory.generatePassThroughTrait(s_interface) if(tType == null) return - - if(client) - { - if(interfaceTraitMap_c.contains(s_interface)) - logger.error("Trait already registered for "+s_interface) - else - interfaceTraitMap_c = interfaceTraitMap_c+(s_interface->tType) - } - if(server) - { - if(interfaceTraitMap_s.contains(s_interface)) - logger.error("Trait already registered for "+s_interface) - else - interfaceTraitMap_s = interfaceTraitMap_s+(s_interface->tType) - } + + registerTrait(s_interface, if(client) tType else null, if(server) tType else null) } - private[multipart] def registerTileClass(clazz:Class[_ <: TileEntity], traits:Set[String]) - { - tileTraitMap=tileTraitMap+(clazz->traits) + private[multipart] def registerTileClass(clazz:Class[_ <: TileMultipart], traits:BitSet) { + tileTraitMap.put(clazz, traits.copy) MultipartProxy.onTileClassBuilt(clazz) } } \ No newline at end of file diff --git a/src/codechicken/multipart/TileMultipart.scala b/src/codechicken/multipart/TileMultipart.scala index 7d75626..bb540d7 100644 --- a/src/codechicken/multipart/TileMultipart.scala +++ b/src/codechicken/multipart/TileMultipart.scala @@ -329,7 +329,7 @@ class TileMultipart extends TileEntity with IChunkLoadTile if(!isInvalid) { - val tile = MultipartGenerator.partRemoved(this, part) + val tile = MultipartGenerator.partRemoved(this) tile.notifyPartChange(part) tile.markDirty() tile.markRender() @@ -486,24 +486,22 @@ class TileMultipart extends TileEntity with IChunkLoadTile def canConnectRedstone(side:Int) = false } -class TileMultipartClient extends TileMultipart +trait TileMultipartClient extends TileMultipart { - def renderStatic(pos:Vector3, pass:Int) = + def renderStatic(pos: Vector3, pass: Int) = partList.foldLeft(false)((r, part) => part.renderStatic(pos, pass) || r) - def renderDynamic(pos:Vector3, frame:Float, pass:Int) - { - partList.foreach(part => part.renderDynamic(pos, frame, pass:Int)) + def renderDynamic(pos: Vector3, frame: Float, pass: Int) { + partList.foreach(part => part.renderDynamic(pos, frame, pass: Int)) } - - def randomDisplayTick(random:Random){} - - override def shouldRenderInPass(pass:Int) = - { + + def randomDisplayTick(random: Random) {} + + override def shouldRenderInPass(pass: Int) = { MultipartRenderer.pass = pass true } - + override def getRenderBoundingBox = { val c = Cuboid6.full.copy partList.foreach(part => c.enclose(part.getRenderBounds)) diff --git a/src/codechicken/multipart/asm/ASMImplicits.scala b/src/codechicken/multipart/asm/ASMImplicits.scala new file mode 100644 index 0000000..7c3a23f --- /dev/null +++ b/src/codechicken/multipart/asm/ASMImplicits.scala @@ -0,0 +1,24 @@ +package codechicken.multipart.asm + +import java.util.BitSet + +object ASMImplicits +{ + implicit class ExtBitSet(val bitset:BitSet) extends AnyVal + { + def set(b:BitSet) = { + bitset.clear() + bitset.or(b) + bitset + } + + def copy = new BitSet().set(bitset) + } + + def nodeName(name:String) = if(name == null) null else name.replace('.', '/') + + implicit class ExtClass(val clazz:Class[_]) extends AnyVal + { + def nodeName = ASMImplicits.nodeName(clazz.getName) + } +} diff --git a/src/codechicken/multipart/asm/ASMMixinCompiler.scala b/src/codechicken/multipart/asm/ASMMixinCompiler.scala index bd8bfbe..6fe139a 100644 --- a/src/codechicken/multipart/asm/ASMMixinCompiler.scala +++ b/src/codechicken/multipart/asm/ASMMixinCompiler.scala @@ -19,6 +19,7 @@ import net.minecraft.launchwrapper.LaunchClassLoader import codechicken.multipart.handler.MultipartProxy import cpw.mods.fml.common.asm.transformers.deobf.FMLDeobfuscatingRemapper import org.apache.logging.log4j.LogManager +import ASMImplicits._ object DebugPrinter { @@ -70,7 +71,7 @@ object ASMMixinCompiler m_defineClass.invoke(cl, bytes, 0: Integer, bytes.length: Integer).asInstanceOf[Class[_]] } catch { case link: LinkageError if link.getMessage.contains("duplicate") => - throw new IllegalStateException("class with name: " + name + " already loaded. Do not reference your mixin classes before registering them with MultipartGenerator", link) + throw new IllegalStateException("class with name: " + name + " already loaded. Do not reference your java mixin classes before registering", link) } } @@ -92,15 +93,19 @@ object ASMMixinCompiler return bytes } - def internalDefine(name: String, bytes: Array[Byte]) { - traitByteMap.put(name.replace('.', '/'), bytes) - BaseNodeInfo.clear(name) + def internalDefine(name$: String, bytes: Array[Byte]) { + val name = nodeName(name$) + traitByteMap.put(name, bytes) + remClassInfo(name) DebugPrinter.dump(name, bytes) } - def classNode(name: String) = traitByteMap.getOrElseUpdate(name.replace('.', '/'), getBytes(name.replace('.', '/'))) match { - case null => null - case v => createClassNode(v, ClassReader.EXPAND_FRAMES) + def classNode(name$: String) = { + val name = nodeName(name$) + traitByteMap.getOrElseUpdate(name, getBytes(name)) match { + case null => null + case v => createClassNode(v, ClassReader.EXPAND_FRAMES) + } } def isScala(cnode: ClassNode) = ScalaSigReader.ann(cnode).isDefined @@ -120,73 +125,70 @@ object ASMMixinCompiler name } - case class MixinInfo(name: String, parent: String, fields: Seq[FieldMixin], - methods: Seq[MethodNode], supers: Map[String, String]) + case class MixinInfo(name: String, parent: String, parentTraits:Seq[MixinInfo], + fields: Seq[FieldMixin], methods: Seq[MethodNode], supers: Seq[String]) { + def linearise:Seq[MixinInfo] = parentTraits.flatMap(_.linearise) :+ this def tname = name + "$class" } - object BaseNodeInfo + abstract class MethodInfo { - private val baseNodeMap = MMap[String, BaseNodeInfo]() + def owner: ClassInfo + def name: String + def desc: String + def isPrivate: Boolean + def isAbstract: Boolean - def clear(name: String) = baseNodeMap.remove(name) + override def toString = owner.name+"."+name+desc + } - def getNodeInfo(name: String) = baseNodeMap.getOrElseUpdate(name, new BaseNodeInfo(name)) + abstract class ClassInfo + { + def name: String + def superClass: Option[ClassInfo] + def interfaces: Seq[ClassInfo] + def methods: Seq[MethodInfo] - private def getNodeInfo(clazz: ClassInfoSource) = clazz match { - case null => null - case v => baseNodeMap.getOrElseUpdate(v.name, new BaseNodeInfo(v)) - } + override def toString = getClass.getSimpleName+"("+name+")" - case class MethodNodeInfo(owner: String, m: MethodInfoSource) + def getMethod(name:String, desc:String) = methods.find(m => m.name == name && m.desc == desc) + def findMethod(name:String, desc:String, f:(MethodInfo)=>Boolean):Option[MethodInfo] = + getMethod(name, desc).filter(f) orElse (superClass ++ interfaces).view.flatMap(_.findMethod(name, desc, f)).headOption + def findPublicImpl(name:String, desc:String) = findMethod(name, desc, m => !m.isAbstract && !m.isPrivate) + } + + private val infoCache = MMap[String, ClassInfo]() + + def remClassInfo(name: String) = infoCache.remove(name) + implicit def getClassInfo(name: String) = infoCache.getOrElseUpdate(name, ClassInfo.obtainInfo(name)) + implicit def getClassInfo(cnode: ClassNode):ClassInfo = getClassInfo(cnode.name) + implicit def getClassInfo(clazz: Class[_]):ClassInfo = if(clazz == null) null else getClassInfo(clazz.nodeName) + + object ClassInfo + { + class ReflectionClassInfo(clazz: Class[_]) extends ClassInfo { - def name = m.name - def desc = m.desc - } - - trait MethodInfoSource - { - def name: String - def desc: String - def isPrivate: Boolean - def isAbstract: Boolean - } - - trait ClassInfoSource - { - def name: String - def superClass: Option[BaseNodeInfo] - def interfaces: Seq[BaseNodeInfo] - def methods: Seq[MethodInfoSource] - } - - implicit def JClassInfoSource(clazz: Class[_]) = if (clazz == null) null else new JClassInfoSource(clazz) - - class JClassInfoSource(clazz: Class[_]) extends ClassInfoSource - { - - case class JMethodInfoSource(method: Method) extends MethodInfoSource + case class ReflectionMethodInfo(method: Method) extends MethodInfo { + def owner = ReflectionClassInfo.this def name = method.getName def desc = getType(method).getDescriptor def isPrivate = Modifier.isPrivate(method.getModifiers) def isAbstract = Modifier.isAbstract(method.getModifiers) } - def name = clazz.getName.replace('.', '/') - def superClass = Option(getNodeInfo(clazz.getSuperclass)) - def interfaces = clazz.getInterfaces.map(getNodeInfo(_)) - def methods = clazz.getMethods.map(JMethodInfoSource(_)) + def name = clazz.nodeName + def superClass = Option(clazz.getSuperclass) + def interfaces = clazz.getInterfaces.map(getClassInfo) + def methods = clazz.getMethods.map(ReflectionMethodInfo(_)) } - implicit def ClassNodeInfoSource(cnode: ClassNode) = if (cnode == null) null else new ClassNodeInfoSource(cnode) - - class ClassNodeInfoSource(cnode: ClassNode) extends ClassInfoSource + class ClassNodeInfo(cnode: ClassNode) extends ClassInfo { - - case class MethodNodeInfoSource(mnode: MethodNode) extends MethodInfoSource + case class MethodNodeInfoSource(mnode: MethodNode) extends MethodInfo { + def owner = ClassNodeInfo.this def name = mnode.name def desc = mnode.desc def isPrivate = (mnode.access & ACC_PRIVATE) != 0 @@ -194,49 +196,33 @@ object ASMMixinCompiler } def name = cnode.name - def superClass = Option(getNodeInfo(cnode.superName)) - def interfaces = cnode.interfaces match { - case null => Seq() - case v => v.map(getNodeInfo) - } - def methods = cnode.methods.map(MethodNodeInfoSource(_)) + def superClass = Some(cnode.superName) + def interfaces:Seq[ClassInfo] = cnode.interfaces.map(getClassInfo) + def methods = cnode.methods.map(MethodNodeInfoSource) } - class ScalaNodeInfoSource(cnode: ClassNode) extends ClassNodeInfoSource(cnode) + class ScalaClassInfo(cnode: ClassNode) extends ClassNodeInfo(cnode) { val sig = ScalaSigReader.read(ScalaSigReader.ann(cnode).get) val csym = sig.evalT(0): ClassSymbol - override def superClass = Option(getNodeInfo(csym.jParent(sig))) - override def interfaces = csym.jInterfaces(sig).map(getNodeInfo) + override def superClass = Some(csym.jParent(sig)) + override def interfaces = csym.jInterfaces(sig).map(getClassInfo) } - def classInfo(name: String): ClassInfoSource = name match { + private[ASMMixinCompiler] def obtainInfo(name: String): ClassInfo = name match { case null => null case s => classNode(s) match { - case null => cl.findClass(s.replace('/', '.')) - case v if isScala(v) => new ScalaNodeInfoSource(v) - case v => v + case null => cl.findClass(s.replace('/', '.')) match { + case null => null + case c => new ReflectionClassInfo(c) + } + case v if isScala(v) => new ScalaClassInfo(v) + case v => new ClassNodeInfo(v) } } } - import BaseNodeInfo._ - - class BaseNodeInfo(val clazz: ClassInfoSource) - { - def this(name: String) = this(classInfo(name)) - - val publicmethods = exportedMethods(clazz) //map of nameDesc to owner+method - - def exportedMethods(o: ClassInfoSource): Map[String, MethodNodeInfo] = { - val eMethods = o.methods.filter(!_.isPrivate) //defined accessible methods - .map(m => (m.name + m.desc, MethodNodeInfo(o.name, m))).toMap - - eMethods ++ (o.superClass ++ o.interfaces).flatMap(_.publicmethods) - } - } - def finishBridgeCall(mv: MethodVisitor, mvdesc: String, opcode: Int, owner: String, name: String, desc: String) { val args = getArgumentTypes(mvdesc) val ret = getReturnType(mvdesc) @@ -246,7 +232,7 @@ object ASMMixinCompiler mv.visitVarInsn(arg.getOpcode(ILOAD), localIndex) localIndex += width(arg) } - mv.visitMethodInsn(opcode, owner, name, desc) + mv.visitMethodInsn(opcode, owner, name, desc, opcode == INVOKEINTERFACE) mv.visitInsn(ret.getOpcode(IRETURN)) mv.visitMaxs(Math.max(width(args) + 1, width(ret)), width(args) + 1) } @@ -260,73 +246,76 @@ object ASMMixinCompiler writeBridge(mv, mv.desc, INVOKESTATIC, t.tname, mname, staticDesc(t.name, mv.desc)) def mixinClasses(name: String, superClass: String, traits: Seq[String]) = { - val traitInfos = traits.map(t => mixinMap(t.replace('.', '/'))) + val startTime = System.currentTimeMillis + + val baseTraits = traits.map(mixinMap) + val traitInfos = baseTraits.flatMap(_.linearise).distinct + val parentInfo = getClassInfo(superClass) val cnode = new ClassNode() - cnode.visit(V1_6, ACC_PUBLIC, name, null, superClass.replace('.', '/'), traitInfos.map(_.name).toArray[String]) + //implements list + cnode.visit(V1_6, ACC_PUBLIC, name, null, superClass, baseTraits.map(_.name).toArray[String]) val minit = cnode.visitMethod(ACC_PUBLIC, "", "()V", null, null) minit.visitVarInsn(ALOAD, 0) - minit.visitMethodInsn(INVOKESPECIAL, cnode.superName, "", "()V") + minit.visitMethodInsn(INVOKESPECIAL, cnode.superName, "", "()V", false) val prevInfos = MList[MixinInfo]() - traitInfos.foreach { - t => - minit.visitVarInsn(ALOAD, 0) - minit.visitMethodInsn(INVOKESTATIC, t.tname, "$init$", "(L" + t.name + ";)V") + traitInfos.foreach { t => + minit.visitVarInsn(ALOAD, 0) + minit.visitMethodInsn(INVOKESTATIC, t.tname, "$init$", "(L" + t.name + ";)V", false) - t.fields.foreach { - f => - val fv = cnode.visitField(ACC_PRIVATE, f.accessName(t.name), f.desc, null, null).asInstanceOf[FieldNode] + t.fields.foreach { f => + val fv = cnode.visitField(ACC_PRIVATE, f.accessName(t.name), f.desc, null, null).asInstanceOf[FieldNode] - val ftype = getType(fv.desc) - var mv = cnode.visitMethod(ACC_PUBLIC, fv.name, "()" + f.desc, null, null) - mv.visitVarInsn(ALOAD, 0) - mv.visitFieldInsn(GETFIELD, name, fv.name, fv.desc) - mv.visitInsn(ftype.getOpcode(IRETURN)) - mv.visitMaxs(1, 1) + val ftype = getType(fv.desc) + var mv = cnode.visitMethod(ACC_PUBLIC, fv.name, "()" + f.desc, null, null) + mv.visitVarInsn(ALOAD, 0) + mv.visitFieldInsn(GETFIELD, name, fv.name, fv.desc) + mv.visitInsn(ftype.getOpcode(IRETURN)) + mv.visitMaxs(1, 1) - mv = cnode.visitMethod(ACC_PUBLIC, fv.name + "_$eq", "(" + f.desc + ")V", null, null) - mv.visitVarInsn(ALOAD, 0) - mv.visitVarInsn(ftype.getOpcode(ILOAD), 1) - mv.visitFieldInsn(PUTFIELD, name, fv.name, fv.desc) - mv.visitInsn(RETURN) - mv.visitMaxs(width(ftype) + 1, width(ftype) + 1) + mv = cnode.visitMethod(ACC_PUBLIC, fv.name + "_$eq", "(" + f.desc + ")V", null, null) + mv.visitVarInsn(ALOAD, 0) + mv.visitVarInsn(ftype.getOpcode(ILOAD), 1) + mv.visitFieldInsn(PUTFIELD, name, fv.name, fv.desc) + mv.visitInsn(RETURN) + mv.visitMaxs(width(ftype) + 1, width(ftype) + 1) + } + + t.supers.foreach { s => + val (name, desc) = seperateDesc(s) + val mv = cnode.visitMethod(ACC_PUBLIC, t.name.replace('/', '$') + "$$super$" + name, desc, null, null).asInstanceOf[MethodNode] + + prevInfos.reverse.find(t => t.supers.contains(s)) match { + //each super goes to the one before + case Some(st) => writeStaticBridge(mv, name, st) + case None => writeBridge(mv, desc, INVOKESPECIAL, parentInfo.findPublicImpl(name, desc).get.owner.name, name, desc) } + } - t.supers.foreach { - s => - val (name, desc) = seperateDesc(s._1) - val mv = cnode.visitMethod(ACC_PUBLIC, t.name.replace('/', '$') + "$$super$" + name, desc, null, null).asInstanceOf[MethodNode] - - prevInfos.reverse.find(t => t.supers.contains(s._1)) match { - //each super goes to the one before - case Some(st) => writeStaticBridge(mv, name, st) - case None => writeBridge(mv, desc, INVOKESPECIAL, s._2, name, desc) - } - } - - prevInfos += t + prevInfos += t } val methodSigs = MSet[String]() - traitInfos.reverse.foreach { - t => //last trait gets first pick on methods - t.methods.foreach { - m => - if (!methodSigs(m.name + m.desc)) { - val mv = cnode.visitMethod(ACC_PUBLIC, m.name, m.desc, null, Array(m.exceptions: _*)).asInstanceOf[MethodNode] - writeStaticBridge(mv, m.name, t) - methodSigs += m.name + m.desc - } + traitInfos.reverse.foreach { t => //last trait gets first pick on methods + t.methods.foreach { m => + if (!methodSigs(m.name + m.desc)) { + val mv = cnode.visitMethod(ACC_PUBLIC, m.name, m.desc, null, Array(m.exceptions: _*)).asInstanceOf[MethodNode] + writeStaticBridge(mv, m.name, t) + methodSigs += m.name + m.desc } + } } minit.visitInsn(RETURN) minit.visitMaxs(1, 1) - define(cnode.name, createBytes(cnode, 0)) + val c = define(cnode.name, createBytes(cnode, 0)) + + DebugPrinter.logger.debug("Generation ["+superClass+" with "+traits.mkString(", ")+"] took: "+(System.currentTimeMillis-startTime)) + c } def seperateDesc(nameDesc: String) = { @@ -339,69 +328,69 @@ object ASMMixinCompiler getMethodDescriptor(descT.getReturnType, getType("L" + owner + ";") +: descT.getArgumentTypes: _*) } - def getSuper(minsn: MethodInsnNode, stack: StackAnalyser): Option[String] = { + def getSuper(minsn: MethodInsnNode, stack: StackAnalyser): Option[MethodInfo] = { import StackAnalyser._ - if (minsn.getOpcode != INVOKESPECIAL) return None - val oname = stack.owner.getInternalName + if(minsn.owner == stack.owner.getInternalName) + return None //not a super call - if (minsn.owner.equals(oname)) return None //private this + //super calls are either to methods with the same name or contain a pattern 'target$$super$name' from the scala compiler + val methodName = stack.m.name.replaceAll(".+\\Q$$super$\\E", "") + if(minsn.name != methodName) + return None stack.peek(Type.getType(minsn.desc).getArgumentTypes.length) match { case Load(This(o)) => case _ => return None //have to be invoked on this } - getSuper(minsn.name + minsn.desc, oname) + getClassInfo(stack.owner.getInternalName).superClass.flatMap(_.findPublicImpl(methodName, minsn.desc)) } - def getSuper(nameDesc: String, cname: String) = - getNodeInfo(cname).clazz.superClass match { - case None => None //no super class - case Some(o) => o.publicmethods.get(nameDesc) match { - case None => None //no method with sig in super - case Some(m) => if (m.m.isAbstract) - None //abstract can't be called for supers - else - Some(m.owner) //congrats, that's a super - } - } + def getAndRegisterParentTraits(cnode: ClassNode) = cnode.interfaces.map(classNode).filter(i => isScala(i) && isTrait(i)).map(registerScalaTrait) def registerJavaTrait(cnode: ClassNode) { if ((cnode.access & ACC_INTERFACE) != 0) - throw new IllegalArgumentException("Cannot register java interface " + cnode.name + " as a multipart trait. Try register passThroughInterface") - if ((cnode.access & ACC_ABSTRACT) != 0) - throw new IllegalArgumentException("Cannot register abstract class " + cnode.name + " as a multipart trait") + throw new IllegalArgumentException("Cannot register java interface " + cnode.name + " as a mixin trait. Try register passThroughInterface") if (!cnode.innerClasses.isEmpty) - throw new IllegalArgumentException("Inner classes are not permitted for " + cnode.name + " as a multipart trait. Use scala") + throw new IllegalArgumentException("Inner classes are not permitted for " + cnode.name + " as a java mixin trait. Use scala") + + val parentTraits = getAndRegisterParentTraits(cnode) + val fields = cnode.fields.map(f => (f.name, FieldMixin(f.name, f.desc, f.access))).toMap + val supers = MList[String]() //nameDesc to super owner + val methods = MList[MethodNode]() + val methodSigs = cnode.methods.map(m => m.name + m.desc).toSet + + if ((cnode.access & ACC_ABSTRACT) != 0) {//verify all methods are implemented + def getInterfaces(cnode:ClassNode):Seq[ClassNode] = cnode.interfaces.map(classNode).flatMap(i => getInterfaces(i) :+ i) + val interfaces = getInterfaces(cnode).distinct + val implementedSigs = (cnode.methods.filter(m => (m.access & ACC_ABSTRACT) == 0)++parentTraits.flatMap(_.methods)).map(m => m.name + m.desc).toSet + val missing = interfaces.flatMap(_.methods).map(m => m.name + m.desc).filterNot(implementedSigs) + if(!missing.isEmpty) + throw new IllegalArgumentException("Abstract java trait "+cnode.name+" needs to implement "+missing.mkString(", ")) + } val inode = new ClassNode() //impl node inode.visit(V1_6, ACC_ABSTRACT | ACC_PUBLIC, cnode.name + "$class", null, "java/lang/Object", null) inode.sourceFile = cnode.sourceFile - val fields = cnode.fields.map(f => (f.name, FieldMixin(f.name, f.desc, f.access))).toMap - val supers = MMap[String, String]() //nameDesc to super owner - val methods = MList[MethodNode]() - val methodSigs = cnode.methods.map(m => m.name + m.desc).toSet - val tnode = new ClassNode() //trait node (interface) tnode.visit(V1_6, ACC_INTERFACE | ACC_ABSTRACT | ACC_PUBLIC, cnode.name, null, "java/lang/Object", Array(cnode.interfaces: _*)) def fname(name: String) = fields(name).accessName(cnode.name) - fields.values.foreach { - fnode => - tnode.visitMethod(ACC_PUBLIC | ACC_ABSTRACT, fname(fnode.name), "()" + fnode.desc, null, null) - tnode.visitMethod(ACC_PUBLIC | ACC_ABSTRACT, fname(fnode.name) + "_$eq", "(" + fnode.desc + ")V", null, null) + fields.values.foreach { fnode => + tnode.visitMethod(ACC_PUBLIC | ACC_ABSTRACT, fname(fnode.name), "()" + fnode.desc, null, null) + tnode.visitMethod(ACC_PUBLIC | ACC_ABSTRACT, fname(fnode.name) + "_$eq", "(" + fnode.desc + ")V", null, null) } def superInsn(minsn: MethodInsnNode) = { val bridgeName = cnode.name.replace('/', '$') + "$$super$" + minsn.name if (!supers.contains(minsn.name + minsn.desc)) { tnode.visitMethod(ACC_PUBLIC | ACC_ABSTRACT, bridgeName, minsn.desc, null, null) - supers.put(minsn.name + minsn.desc, minsn.owner) + supers += minsn.name + minsn.desc } - new MethodInsnNode(INVOKEINTERFACE, cnode.name, bridgeName, minsn.desc) + new MethodInsnNode(INVOKEINTERFACE, cnode.name, bridgeName, minsn.desc, true) } def staticClone(mnode: MethodNode, name: String, access: Int) = { @@ -428,9 +417,9 @@ object ASMMixinCompiler insn match { case finsn: FieldInsnNode => insn.getOpcode match { case GETFIELD => replace(new MethodInsnNode(INVOKEINTERFACE, cnode.name, - fname(finsn.name), "()" + finsn.desc)) + fname(finsn.name), "()" + finsn.desc, true)) case PUTFIELD => replace(new MethodInsnNode(INVOKEINTERFACE, cnode.name, - fname(finsn.name) + "_$eq", "(" + finsn.desc + ")V")) + fname(finsn.name) + "_$eq", "(" + finsn.desc + ")V", true)) case _ => } case minsn: MethodInsnNode => insn.getOpcode match { @@ -440,7 +429,7 @@ object ASMMixinCompiler case INVOKEVIRTUAL => if (minsn.owner.equals(cnode.name)) { if (methodSigs.contains(minsn.name + minsn.desc)) {//call the interface method - replace(new MethodInsnNode(INVOKEINTERFACE, minsn.owner, minsn.name, minsn.desc)) + replace(new MethodInsnNode(INVOKEINTERFACE, minsn.owner, minsn.name, minsn.desc, true)) } else { //cast to parent class and call val mType = Type.getMethodType(minsn.desc) @@ -460,17 +449,17 @@ object ASMMixinCompiler def convertMethod(mnode: MethodNode) { if (mnode.name.equals("")) - throw new IllegalArgumentException("Static initialisers are not permitted " + cnode.name + " as a multipart trait") + throw new IllegalArgumentException("Static initialisers are not permitted " + cnode.name + " as a mixin trait") if (mnode.name.equals("")) { if (!mnode.desc.equals("()V")) - throw new IllegalArgumentException("Constructor arguments are not permitted " + cnode.name + " as a multipart trait") + throw new IllegalArgumentException("Constructor arguments are not permitted " + cnode.name + " as a mixin trait") val mv = staticClone(mnode, "$init$", ACC_PUBLIC) def removeSuperConstructor() { val insns = new InsnListSection insns.add(new VarInsnNode(ALOAD, 0)) - insns.add(new MethodInsnNode(INVOKESPECIAL, cnode.superName, "", "()V")) + insns.add(new MethodInsnNode(INVOKESPECIAL, cnode.superName, "", "()V", false)) val minsns = new InsnListSection(mv.instructions) val found = InsnComparator.matches(minsns, insns, Set[LabelNode]()) @@ -499,22 +488,21 @@ object ASMMixinCompiler define(inode.name, createBytes(inode, 0)) define(tnode.name, createBytes(tnode, 0)) - mixinMap.put(tnode.name, MixinInfo(tnode.name, cnode.superName, - fields.values.toSeq, - methods.toSeq, supers.toMap)) + mixinMap.put(tnode.name, MixinInfo(tnode.name, cnode.superName, parentTraits, + fields.values.toSeq, methods, supers)) } - def registerScalaTrait(cnode: ClassNode) { - for (i <- cnode.interfaces) { - val inode = classNode(i) - if (isScala(inode) && isTrait(inode)) - throw new IllegalArgumentException("Multipart trait " + cnode.name + " cannot extend other traits") + def registerScalaTrait(cnode: ClassNode):MixinInfo = { + getMixinInfo(cnode.name) match { + case Some(info) => return info + case None => } + val parentTraits = getAndRegisterParentTraits(cnode) val fieldAccessors = MMap[String, MethodSymbol]() - val fields = MList[MethodSymbol]() + val fields = MList[FieldMixin]() val methods = MList[MethodNode]() - val supers = MMap[String, String]() + val supers = MList[String]() val sig = ScalaSigReader.read(ScalaSigReader.ann(cnode).get) val csym: ClassSymbol = sig.evalT(0) @@ -531,28 +519,25 @@ object ASMMixinCompiler else if (sym.isMethod) { val desc = sym.jDesc(sig) if (sym.name.contains("super$")) { - val name = sym.name.substring(6) - supers.put(name + desc, getSuper(name + desc, cnode.name).get) + supers += sym.name.substring(6) + desc } else if (!sym.name.equals("$init$") && !sym.isPrivate) { val map = new ObfMapping(cnode.name, sym.name, desc) val method = findMethod(map, cnode) if (method == null) - throw new RuntimeException("Unable to add multipart trait: " + map + " found in scala signature but not in class file. Most likely an obfuscation issue.") + throw new RuntimeException("Unable to add mixin trait: " + map + " found in scala signature but not in class file. Most likely an obfuscation issue.") methods += method } } else { - fields += sym + fields += FieldMixin(sym.name.trim, getReturnType(sym.jDesc(sig)).getDescriptor, + if (fieldAccessors(sym.name.trim).isPrivate) ACC_PRIVATE else ACC_PUBLIC) } } } - mixinMap.put(cnode.name, MixinInfo(cnode.name, csym.jParent(sig), - fields.map(sym => FieldMixin(sym.name.trim, getReturnType(sym.jDesc(sig)).getDescriptor, - if (fieldAccessors(sym.name.trim).isPrivate) ACC_PRIVATE else ACC_PUBLIC)), - methods, supers.toMap)) + val info = MixinInfo(cnode.name, csym.jParent(sig), parentTraits, fields, methods, supers) + mixinMap.put(cnode.name, info) + info } - - } \ No newline at end of file diff --git a/src/codechicken/multipart/asm/ASMMixinFactory.scala b/src/codechicken/multipart/asm/ASMMixinFactory.scala index 506246a..01a37a4 100644 --- a/src/codechicken/multipart/asm/ASMMixinFactory.scala +++ b/src/codechicken/multipart/asm/ASMMixinFactory.scala @@ -1,311 +1,79 @@ package codechicken.multipart.asm -import scala.collection.Seq -import codechicken.multipart.TileMultipart -import codechicken.multipart.TileMultipartClient -import scala.collection.JavaConversions._ -import org.objectweb.asm.Opcodes._ -import codechicken.lib.asm.CC_ClassWriter -import org.objectweb.asm.MethodVisitor -import org.objectweb.asm.FieldVisitor -import org.objectweb.asm.Label -import org.objectweb.asm.tree._ -import codechicken.lib.asm.ASMHelper._ -import codechicken.lib.asm.ObfMapping -import codechicken.multipart.MultipartGenerator +import java.lang.reflect.Constructor +import scala.collection.mutable +import org.objectweb.asm.tree.ClassNode +import java.util.BitSet +import scala.collection.mutable.ArrayBuffer import ASMMixinCompiler._ +import ASMImplicits._ -object ASMMixinFactory extends IMultipartFactory +class ASMMixinFactory[T](val baseType:Class[T], private val paramTypes:Class[_]*) { - type TMClass = Class[_ <: TileMultipart] - - private var ugenid = 0 - private var generatorMap = Map[SuperSet, Constructor]() - - def uniqueName(prefix:String):String = { - val ret = prefix+"$$"+ugenid - ugenid += 1 - return ret - } - - def simpleName(name:String) = name.substring(name.replace('/', '.').lastIndexOf('.')+1) - - abstract class Constructor - { - def generate():TileMultipart - } - - object SuperSet - { - val TileMultipartType = classOf[TileMultipart].getName - val TileMultipartClientType = classOf[TileMultipartClient].getName - def apply(types:Seq[String], client:Boolean) = new SuperSet(types, client) - } - - class SuperSet(types:Seq[String], client:Boolean) - { - import SuperSet._ - val set = baseType+:types.sorted - - def baseType = if(client) TileMultipartClientType else TileMultipartType - - override def equals(obj:Any) = obj match - { - case x:SuperSet => set == x.set - case _ => false - } - - override def hashCode = set.hashCode() - - def generate:TileMultipart = get.generate() - - def get = generatorMap.getOrElse(this, gen_sync()) - - def gen_sync():Constructor = ASMMixinFactory.synchronized - { - return generatorMap.getOrElse(this, { - val gen = generator() - generatorMap = generatorMap+(this->gen) - gen - }) - } - - def generator():Constructor = - { - val startTime = System.currentTimeMillis - - val cmpClass = if(!types.isEmpty) - mixinClasses(uniqueName("TileMultipart_cmp"), set.head, set.drop(1)) - else - cl.loadClass(baseType) - - MultipartGenerator.registerTileClass(cmpClass.asInstanceOf[TMClass], types.toSet) - val c = constructor(cmpClass) - DebugPrinter.logger.debug("Generation ["+types.mkString(", ")+"] took: "+(System.currentTimeMillis-startTime)) - return c - } - } - - def constructor(clazz:Class[_]):Constructor = - { - val name = uniqueName("TileMultipart_gen") - val cw = new CC_ClassWriter(0) - val superName = classOf[Constructor].getName.replace('.', '/') - val className = clazz.getName.replace('.', '/') - var mv:MethodVisitor = null - - cw.visit(V1_6, ACC_PUBLIC|ACC_SUPER, name, null, superName, null) - - mv = cw.visitMethod(ACC_PUBLIC, "", "()V", null, null) - mv.visitCode() - mv.visitVarInsn(ALOAD, 0) - mv.visitMethodInsn(INVOKESPECIAL, superName, "", "()V") - mv.visitInsn(RETURN) - mv.visitMaxs(1, 1) - mv.visitEnd() - - mv = cw.visitMethod(ACC_PUBLIC, "generate", "()Lcodechicken/multipart/TileMultipart;", null, null) - mv.visitCode() - mv.visitTypeInsn(NEW, className) - mv.visitInsn(DUP) - mv.visitMethodInsn(INVOKESPECIAL, className, "", "()V") - mv.visitInsn(ARETURN) - mv.visitMaxs(2, 1) - mv.visitEnd() - - cw.visitEnd() - - return define(name, cw.toByteArray).newInstance.asInstanceOf[Constructor] - } - - private def autoCompleteJavaTrait(cnode:ClassNode) - { - if(!cnode.fields.isEmpty && findMethod(new ObfMapping(cnode.name, "copyFrom", "(Lcodechicken/multipart/TileMultipart;)V"), cnode) == null) - { - val mv = cnode.visitMethod(ACC_PUBLIC, "copyFrom", "(Lcodechicken/multipart/TileMultipart;)V", null, null) - mv.visitVarInsn(ALOAD, 0) - mv.visitVarInsn(ALOAD, 1) - mv.visitMethodInsn(INVOKESPECIAL, "codechicken/multipart/TileMultipart", "copyFrom", "(Lcodechicken/multipart/TileMultipart;)V") + private val traitMap = mutable.Map[String, Int]() + private val traits = ArrayBuffer[String]() + private val classMap = mutable.Map[BitSet, Constructor[_ <: T]]() + classMap.put(new BitSet, baseType.getDeclaredConstructor(paramTypes:_*)) - mv.visitVarInsn(ALOAD, 1) - mv.visitTypeInsn(INSTANCEOF, cnode.name) - val end = new Label() - mv.visitJumpInsn(IFEQ, end) - - cnode.fields.foreach{ f => - mv.visitVarInsn(ALOAD, 0) - mv.visitVarInsn(ALOAD, 1) - mv.visitFieldInsn(GETFIELD, cnode.name, f.name, f.desc) - mv.visitFieldInsn(PUTFIELD, cnode.name, f.name, f.desc) - } - - mv.visitLabel(end) - mv.visitInsn(RETURN) - mv.visitMaxs(2, 2) - } + private var ugenid = 0 + + private def nextName() = { + val ret = baseType.getSimpleName+"_cmp$$"+ugenid + ugenid += 1 + ret } - - def registerTrait(s_interface:String, s_trait:String, client:Boolean) - { + + private def compile(traitSet:BitSet) = { + val seq = Seq.newBuilder[String] + var i = -1 + while({i = traitSet.nextSetBit(i+1); i >= 0}) + seq += traits(i) + + val c = ASMMixinCompiler.mixinClasses(nextName(), baseType.nodeName, seq.result()).asInstanceOf[Class[_ <: T]] + onCompiled(c, traitSet) + c.getDeclaredConstructor(paramTypes:_*) + } + + protected def onCompiled(clazz:Class[_ <: T], traitSet:BitSet){} + protected def autoCompleteJavaTrait(cnode:ClassNode){} + + def construct(traitSet:BitSet, args:Object*) = (classMap.get(traitSet) match { + case Some(c) => c + case None => + val c = compile(traitSet) + classMap.put(traitSet.copy, c) + c + }).newInstance(args:_*) + + def getId(s_trait:String) = traitMap(s_trait) + + def registerTrait(traitClass:Class[_]):Int = registerTrait(traitClass.nodeName) + + def registerTrait(s_trait:String):Int = { val cnode = classNode(s_trait) if(cnode == null) throw new ClassNotFoundException(s_trait) - - def superClass = getMixinInfo(cnode.name) match { - case Some(m) => m.parent - case None => BaseNodeInfo.getNodeInfo(cnode.name).clazz.superClass.get.clazz.name + + traitMap.get(cnode.name) match { + case Some(id) => return id + case None => } - - superClass match { - case "codechicken/multipart/TileMultipartClient" => if(!client) - throw new IllegalArgumentException("Multipart trait "+s_trait+" cannot implement TileMultipartClient on the server") - case "codechicken/multipart/TileMultipart" => - case _ => throw new IllegalArgumentException("Multipart trait "+s_trait+" must implement TileMultipart or TileMultipartClient") - } - - if(getMixinInfo(cnode.name).isDefined) - return - - if(isScala(cnode) && isTrait(cnode)) - { + + def getParents(info:ClassInfo):Seq[ClassInfo] = info.superClass.toSeq.flatMap(i => i +: getParents(i)) + if(!getParents(cnode).map(_.name).contains(baseType.nodeName)) + throw new IllegalArgumentException("Mixin trait "+s_trait+" must extend "+baseType.nodeName) + + if(isScala(cnode) && isTrait(cnode)) { registerScalaTrait(cnode) } - else - { + else { autoCompleteJavaTrait(cnode) registerJavaTrait(cnode) } + + val id = traits.size + traits += cnode.name + traitMap.put(cnode.name, id) + id } - - def generatePassThroughTrait(s_interface:String):String = - { - def passThroughTraitName(iName:String) = - "T" + (if(iName.startsWith("I")) iName.substring(1) else iName) - - val tname = uniqueName(passThroughTraitName(simpleName(s_interface))) - val vname = "impl" - val iname = s_interface.replace('.', '/') - val idesc = "L"+iname+";" - - val inode = classNode(s_interface) - if(inode == null) { - logger.error("Unable to generate pass through trait for: "+s_interface+" class not found.") - return null - } - if((inode.access&ACC_INTERFACE) == 0) throw new IllegalArgumentException(s_interface+" is not an interface.") - - val cw = new CC_ClassWriter(0) - var mv:MethodVisitor = null - var fv:FieldVisitor = null - - cw.visit(V1_6, ACC_PUBLIC|ACC_SUPER, tname, null, "codechicken/multipart/TileMultipart", Array(iname)) - - { - fv = cw.visitField(ACC_PRIVATE, vname, idesc, null, null) - fv.visitEnd() - } - { - mv = cw.visitMethod(ACC_PUBLIC, "", "()V", null, null) - mv.visitCode() - mv.visitVarInsn(ALOAD, 0) - mv.visitMethodInsn(INVOKESPECIAL, "codechicken/multipart/TileMultipart", "", "()V") - mv.visitInsn(RETURN) - mv.visitMaxs(1, 1) - mv.visitEnd() - } - { - mv = cw.visitMethod(ACC_PUBLIC, "bindPart", "(Lcodechicken/multipart/TMultiPart;)V", null, null) - mv.visitCode() - mv.visitVarInsn(ALOAD, 0) - mv.visitVarInsn(ALOAD, 1) - mv.visitMethodInsn(INVOKESPECIAL, "codechicken/multipart/TileMultipart", "bindPart", "(Lcodechicken/multipart/TMultiPart;)V") - mv.visitVarInsn(ALOAD, 1) - mv.visitTypeInsn(INSTANCEOF, iname) - val l2 = new Label() - mv.visitJumpInsn(IFEQ, l2) - val l3 = new Label() - mv.visitLabel(l3) - mv.visitVarInsn(ALOAD, 0) - mv.visitVarInsn(ALOAD, 1) - mv.visitTypeInsn(CHECKCAST, iname) - mv.visitFieldInsn(PUTFIELD, tname, vname, idesc) - mv.visitLabel(l2) - mv.visitFrame(F_SAME, 0, null, 0, null) - mv.visitInsn(RETURN) - mv.visitMaxs(2, 2) - mv.visitEnd() - } - { - mv = cw.visitMethod(ACC_PUBLIC, "partRemoved", "(Lcodechicken/multipart/TMultiPart;I)V", null, null) - mv.visitCode() - mv.visitVarInsn(ALOAD, 0) - mv.visitVarInsn(ALOAD, 1) - mv.visitVarInsn(ILOAD, 2) - mv.visitMethodInsn(INVOKESPECIAL, "codechicken/multipart/TileMultipart", "partRemoved", "(Lcodechicken/multipart/TMultiPart;I)V") - mv.visitVarInsn(ALOAD, 1) - mv.visitVarInsn(ALOAD, 0) - mv.visitFieldInsn(GETFIELD, tname, vname, idesc) - val l2 = new Label() - mv.visitJumpInsn(IF_ACMPNE, l2) - val l3 = new Label() - mv.visitLabel(l3) - mv.visitVarInsn(ALOAD, 0) - mv.visitInsn(ACONST_NULL) - mv.visitFieldInsn(PUTFIELD, tname, vname, idesc) - mv.visitLabel(l2) - mv.visitFrame(F_SAME, 0, null, 0, null) - mv.visitInsn(RETURN) - mv.visitMaxs(3, 3) - mv.visitEnd() - } - { - mv = cw.visitMethod(ACC_PUBLIC, "canAddPart", "(Lcodechicken/multipart/TMultiPart;)Z", null, null) - mv.visitCode() - mv.visitVarInsn(ALOAD, 0) - mv.visitFieldInsn(GETFIELD, tname, vname, idesc) - val l1 = new Label() - mv.visitJumpInsn(IFNULL, l1) - mv.visitVarInsn(ALOAD, 1) - mv.visitTypeInsn(INSTANCEOF, iname) - mv.visitJumpInsn(IFEQ, l1) - val l2 = new Label() - mv.visitLabel(l2) - mv.visitInsn(ICONST_0) - mv.visitInsn(IRETURN) - mv.visitLabel(l1) - mv.visitFrame(F_SAME, 0, null, 0, null) - mv.visitVarInsn(ALOAD, 0) - mv.visitVarInsn(ALOAD, 1) - mv.visitMethodInsn(INVOKESPECIAL, "codechicken/multipart/TileMultipart", "canAddPart", "(Lcodechicken/multipart/TMultiPart;)Z") - mv.visitInsn(IRETURN) - mv.visitMaxs(2, 2) - mv.visitEnd() - } - - def methods(cnode:ClassNode):Map[String, MethodNode] = - { - val m = cnode.methods.map(m => (m.name+m.desc, m)).toMap - if(cnode.interfaces != null) - m++cnode.interfaces.flatMap(i => methods(classNode(i))) - else - m - } - - def generatePassThroughMethod(m:MethodNode) - { - mv = cw.visitMethod(ACC_PUBLIC, m.name, m.desc, m.signature, Array(m.exceptions:_*)) - mv.visitVarInsn(ALOAD, 0) - mv.visitFieldInsn(GETFIELD, tname, vname, idesc) - finishBridgeCall(mv, m.desc, INVOKEINTERFACE, iname, m.name, m.desc) - } - - methods(inode).values.foreach(generatePassThroughMethod) - - cw.visitEnd() - internalDefine(tname, cw.toByteArray) - registerTrait(s_interface, tname, false) - return tname - } - - def generateTile(types:Seq[String], client:Boolean) = SuperSet(types, client).generate -} \ No newline at end of file +} diff --git a/src/codechicken/multipart/asm/IMultipartFactory.scala b/src/codechicken/multipart/asm/IMultipartFactory.scala deleted file mode 100644 index 11a0c3c..0000000 --- a/src/codechicken/multipart/asm/IMultipartFactory.scala +++ /dev/null @@ -1,12 +0,0 @@ -package codechicken.multipart.asm - -import codechicken.multipart.TileMultipart - -trait IMultipartFactory -{ - def registerTrait(s_interface:String, s_trait:String, client:Boolean) - - def generatePassThroughTrait(s_interface:String):String - - def generateTile(types:Seq[String], client:Boolean):TileMultipart -} \ No newline at end of file