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!

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

mobile/src/main/java/net/tofvesson/coloursbycontrol/CodeCtx.kt

@@ -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 c = Class.forName(params[0].toString())
-            val callee = if(static) null else caller.operands.pop()
+            if(params[2].toString().toInt() > caller.operands.size) throw exception(stack, "Operand stack underflow! Required parameter count: "+params[2].toString())
-            val v = Array(paramCount, { caller.operands.pop() })
+            val callParams = Array(params[2].toString().toInt(), { caller.operands.pop() })
-            caller.popFlag = m.returnType == Void.TYPE
+            val callMethod = getMethod(callParams, params[1].toString(), c) ?: throw exception(stack, "Cannot find Method named \""+params[1]+"\"")
-            return m.invoke(callee, v)
+            caller.popFlag = callMethod.returnType==Void.TYPE
+            return invoke(callMethod, callParams)
         }
         override fun getPairCount(): Int = 1
     },
@@ -282,4 +320,62 @@ enum class Operations: Operation{
         override fun getPairCount(): Int = 0
     };
     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
 }