mirror of
https://github.com/GTNewHorizons/ForgeMultipart.git
synced 2026-11-21 20:52:21 +00:00
Refactored, optimised and generified multipart class generation
This commit is contained in:
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)
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
Reference in new issue
Block a user