Revised EXT call to add better support for dynamic method lookup and parameter matching
- When suitable methods, the algorithm checks if the parameter counts vaguely matches - It also checks if the desired parameter type can be instantiated through constructors or static factory methods if the passed parameter isn't primitive or already of the desired type - An assessment is automatically made as to whether or not the desired method may be static or not - Method searches target superclasses of a supplied type as well as the given type Added support function for easier reflective method invocation Added support functions for easier method lookup and parameter matching Note: Untested code! May not be stable or at all functional!
This commit is contained in:
parent
8241033eba
commit
847911a89d
6
.idea/vcs.xml
generated
Normal file
6
.idea/vcs.xml
generated
Normal file
@ -0,0 +1,6 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project version="4">
|
||||
<component name="VcsDirectoryMappings">
|
||||
<mapping directory="" vcs="Git" />
|
||||
</component>
|
||||
</project>
|
||||
@ -1,5 +1,6 @@
|
||||
package net.tofvesson.coloursbycontrol
|
||||
|
||||
import java.lang.reflect.Method
|
||||
import java.util.*
|
||||
import kotlin.collections.ArrayList
|
||||
import kotlin.collections.HashMap
|
||||
@ -98,14 +99,55 @@ interface Operation{
|
||||
fun eval(stack: Stack<CodeCtx>, params: Array<Any?>): Any?
|
||||
}
|
||||
|
||||
infix fun <K, V> HashMap<K, V>.containsKeyI(key: K) = contains(key)
|
||||
infix fun <K, V> HashMap<K, V>.containsKeyI(key: K) = containsKey(key)
|
||||
fun Any?.asBoolean(): Boolean =
|
||||
if(this==null) false else this as? Boolean ?: if((this.toString() == "true") or (this.toString() == "false")) this.toString().toBoolean() else !((this.toString()=="0") or (this.toString()=="0.0"))
|
||||
fun Any?.asDouble(): Double = if(this==null) 0.0 else (this as? Number ?: try{ this.toString().toDouble() }catch(e: NumberFormatException){ 0.0 }).toDouble()
|
||||
infix fun Any?.matchesClass(other: Class<*>): Boolean =
|
||||
(other.isPrimitive && this!=null && this.javaClass==other) || (this==null && !other.isPrimitive) || (this!=null && other.javaClass.isAssignableFrom(this.javaClass))
|
||||
|
||||
fun exception(stack: Stack<CodeCtx>, reason: String?): RuntimeException =
|
||||
RuntimeException((reason ?: "")+" Trace: "+Arrays.toString(stack.toArray())+
|
||||
(if(stack.size>0) " at "+stack[stack.size-1].operators[stack[stack.size-1].stackPointer].ordinal+" ("+stack[stack.size-1].operators[stack[stack.size-1].stackPointer].name+")" else ""))
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
infix fun <T: Number, K: Number> K.toNumber(type: Class<in T>): T =
|
||||
(if(type==Byte::class) this.toByte()
|
||||
else if(type==Short::class) this.toShort()
|
||||
else if(type==Integer::class) this.toInt()
|
||||
else if(type==Long::class) this.toLong()
|
||||
else if(type==Float::class) this.toFloat()
|
||||
else if(type==Double::class) this.toDouble()
|
||||
else this) as T
|
||||
fun getMatchingMethod(name: String, paramCount: Int, clazz: Class<*>, paramTypes: Array<Any?>): Method? {
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
val methods = ArrayList<Method>()
|
||||
clazz.declaredMethods.forEach { if(it.name == name && it.parameterTypes.size == paramCount) methods.add(it) }
|
||||
OUTER@
|
||||
for(method in methods){
|
||||
var i = -1
|
||||
for(clasz in method.parameterTypes)
|
||||
if(!((paramTypes[++i] matchesClass String::class.java && (
|
||||
(clasz==Double::class.java) ||
|
||||
(clasz==Integer::class.java) ||
|
||||
(clasz==Float::class.java) ||
|
||||
(clasz==Long::class.java) ||
|
||||
(clasz==Short::class.java) ||
|
||||
(clasz==Byte::class.java) ||
|
||||
(clasz==Character::class.java) ||
|
||||
(clasz==Boolean::class.java))) ||
|
||||
((paramTypes[i]!=null && clasz.isAssignableFrom(paramTypes[i]!!.javaClass)) || ((paramTypes[i]==null) && (!clasz.isPrimitive))) || (clasz == String::class)))
|
||||
continue@OUTER
|
||||
return method
|
||||
}
|
||||
return null
|
||||
}
|
||||
|
||||
infix fun Array<Any?>.toRequiredTypes(types: Array<Class<*>>): Array<Any?> = Array(this.size, {
|
||||
index -> run{
|
||||
if(this[index] matchesClass types[index]) this[index]
|
||||
else if(Number::class.java.isAssignableFrom(types[index])) (this[index] as Number) toNumber types[index]
|
||||
else this[index].toString()
|
||||
}})
|
||||
|
||||
enum class Operations: Operation{
|
||||
LDV{ // Load variable
|
||||
@ -149,17 +191,13 @@ enum class Operations: Operation{
|
||||
override fun hasReturnValue(): Boolean = true
|
||||
override fun getParamCount(): Int = 2
|
||||
override fun eval(stack: Stack<CodeCtx>, params: Array<Any?>): Any? {
|
||||
val m = Class.forName(params[0].toString()).getDeclaredMethod(params[1].toString(), Object::class.java)
|
||||
m.isAccessible = true
|
||||
stack[stack.size-1].popFlag = m.returnType==Void::class.java
|
||||
val static = (m.modifiers and 0x8) == 0
|
||||
val paramCount = m.parameterTypes.size + if(static) 0 else 1
|
||||
val caller = stack[stack.size-1]
|
||||
if(paramCount > caller.operands.size) throw exception(stack, "Operand stack underflow! Required parameter count: "+paramCount)
|
||||
val callee = if(static) null else caller.operands.pop()
|
||||
val v = Array(paramCount, { caller.operands.pop() })
|
||||
caller.popFlag = m.returnType == Void.TYPE
|
||||
return m.invoke(callee, v)
|
||||
val c = Class.forName(params[0].toString())
|
||||
if(params[2].toString().toInt() > caller.operands.size) throw exception(stack, "Operand stack underflow! Required parameter count: "+params[2].toString())
|
||||
val callParams = Array(params[2].toString().toInt(), { caller.operands.pop() })
|
||||
val callMethod = getMethod(callParams, params[1].toString(), c) ?: throw exception(stack, "Cannot find Method named \""+params[1]+"\"")
|
||||
caller.popFlag = callMethod.returnType==Void.TYPE
|
||||
return invoke(callMethod, callParams)
|
||||
}
|
||||
override fun getPairCount(): Int = 1
|
||||
},
|
||||
@ -283,3 +321,61 @@ enum class Operations: Operation{
|
||||
};
|
||||
abstract fun getPairCount(): Int
|
||||
}
|
||||
|
||||
/**
|
||||
* Selects the most plausible method that caller is trying to get based on method name, parameters and owning class etc.
|
||||
*/
|
||||
fun getMethod(params: Array<Any?>, name: String, owner: Class<*>): Method? {
|
||||
val allMethods = ArrayList<Method>()
|
||||
var cur = owner
|
||||
while(cur!=Object::javaClass){
|
||||
cur.declaredMethods.filterNot {
|
||||
it.name != name || allMethods.contains(it) || (it.parameterTypes.size<params.size && (it.modifiers and 8==0)) || (it.parameterTypes.size<params.size-1 && (it.modifiers and 8==1))
|
||||
}.forEach { allMethods.add(it) }
|
||||
cur = cur.superclass
|
||||
}
|
||||
|
||||
var match: Method? = null
|
||||
|
||||
outer@
|
||||
for(it in allMethods) {
|
||||
if(match==null) match = it
|
||||
else if(it.parameterTypes.size<match.parameterTypes.size){
|
||||
for(i in match.parameterTypes.indices)
|
||||
if(i<params.size && !(getOrCreate(match.parameterTypes[i], params[i], true, false) as Boolean))
|
||||
continue@outer
|
||||
match = it
|
||||
}
|
||||
}
|
||||
return match
|
||||
}
|
||||
|
||||
fun invoke(call: Method, params: Array<Any?>): Any? {
|
||||
try{
|
||||
call.isAccessible = true
|
||||
return call.invoke(if(call.modifiers and 8 == 0) params[0] else null, Array(call.parameterTypes.size - (((call.modifiers and 8) shr 3) and 0), { if(it + (if((call.modifiers and 8)==1) 0 else 1)>=params.size) null else getOrCreate(call.parameterTypes[0], params[it + (if((call.modifiers and 8)==1) 0 else 1)], true, true) }))
|
||||
}catch(e: Exception){ return null }
|
||||
}
|
||||
|
||||
fun getOrCreate(matchType: Class<*>, param: Any?, ignoreSafety: Boolean, create: Boolean): Any? {
|
||||
if(param==null || matchType.isAssignableFrom(param.javaClass)) { return if(create) param else return true }
|
||||
|
||||
// At this point, we know that "param" MUST be non-null
|
||||
matchType.declaredConstructors
|
||||
.filter { (ignoreSafety || it.isAccessible) && it.parameterTypes.size==1 && (it.parameterTypes[0].isAssignableFrom(param.javaClass) || it.parameterTypes[0].isPrimitive) }
|
||||
.forEach {
|
||||
try{
|
||||
it.isAccessible = true
|
||||
return if(create) it.newInstance(if(it.parameterTypes[0].isPrimitive){ if(it.parameterTypes[0]==Boolean::class.java) param.asBoolean() else param.asDouble().toNumber(it.parameterTypes[0])} else param) else true
|
||||
}catch (e: Exception){}
|
||||
}
|
||||
matchType.declaredMethods
|
||||
.filter { (ignoreSafety || it.isAccessible) && ((it.modifiers and 8)!=0) && it.parameterTypes.size==1 && (it.parameterTypes[0].isAssignableFrom(param.javaClass) || it.parameterTypes[0].isPrimitive) }
|
||||
.forEach {
|
||||
try{
|
||||
it.isAccessible = true
|
||||
return if(create) it.invoke(null, if(it.parameterTypes[0].isPrimitive){ if(it.parameterTypes[0]==Boolean::class.java) param.asBoolean() else param.asDouble().toNumber(it.parameterTypes[0])} else param) else true
|
||||
}catch (e: Exception){}
|
||||
}
|
||||
return if(create) null else false
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user