Refactored, optimised and generified multipart class generation

This commit is contained in:
Chicken-Bones committed 2015-05-06 22:13:53 +10:00
1 parent 49131ba94a
commit c2e7bce54b
7 files changed
+342 -610

No files matched your search

@@ -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)
@@ -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)
}
}
+10 -12
View File
@@ -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))
@@ -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)
}
}
@@ -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, "<init>", "()V", null, null)
minit.visitVarInsn(ALOAD, 0)
minit.visitMethodInsn(INVOKESPECIAL, cnode.superName, "<init>", "()V")
minit.visitMethodInsn(INVOKESPECIAL, cnode.superName, "<init>", "()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("<clinit>"))
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("<init>")) {
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, "<init>", "()V"))
insns.add(new MethodInsnNode(INVOKESPECIAL, cnode.superName, "<init>", "()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
}
}
@@ -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, "<init>", "()V", null, null)
mv.visitCode()
mv.visitVarInsn(ALOAD, 0)
mv.visitMethodInsn(INVOKESPECIAL, superName, "<init>", "()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, "<init>", "()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, "<init>", "()V", null, null)
mv.visitCode()
mv.visitVarInsn(ALOAD, 0)
mv.visitMethodInsn(INVOKESPECIAL, "codechicken/multipart/TileMultipart", "<init>", "()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
}
}
@@ -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
}