diff options
Diffstat (limited to 'src/bind')
| -rw-r--r-- | src/bind/AutoBinder.kt | 124 | ||||
| -rw-r--r-- | src/bind/LispBinding.kt | 7 |
2 files changed, 131 insertions, 0 deletions
diff --git a/src/bind/AutoBinder.kt b/src/bind/AutoBinder.kt new file mode 100644 index 0000000..83d5d86 --- /dev/null +++ b/src/bind/AutoBinder.kt @@ -0,0 +1,124 @@ +package moe.nea.lisp.bind + +import moe.nea.lisp.* +import java.lang.invoke.MethodHandles +import java.lang.reflect.Method +import java.lang.reflect.Modifier +import java.lang.reflect.Parameter + +class AutoBinder { + + private fun mapLispData(parameter: Parameter): ((Iterator<LispData>, ErrorReporter) -> Any)? { + if (LispData::class.java.isAssignableFrom(parameter.type)) return { a, b -> parameter.type.cast(a.next()) } + return null + } + + private fun mapErrorReporter(parameter: Parameter): ((Iterator<LispData>, ErrorReporter) -> Any)? { + if (ErrorReporter::class.java.isAssignableFrom(parameter.type)) return { a, b -> b } + return null + } + + private fun mapString(parameter: Parameter): ((Iterator<LispData>, ErrorReporter) -> Any?)? { + if (String::class.java == parameter.type) return { a, b -> + when (val x = a.next()) { + is LispData.LispString -> x.string + is LispData.Atom -> x.label + else -> null.also { b.reportError("Could not coerce $x to string") } + } + } + return null + } + + private fun mapBoolean(parameter: Parameter): ((Iterator<LispData>, ErrorReporter) -> Any?)? { + if (Boolean::class.java.isAssignableFrom(parameter.type)) return { a, b -> + val x = a.next() + val y = CoreBindings.isTruthy(x) + if (y == null) { + b.reportError("Could not coerce $x to a boolean") + } + y + } + return null + } + + private fun mapNumber(parameter: Parameter): ((Iterator<LispData>, ErrorReporter) -> Any?)? { + if (Double::class.java.isAssignableFrom(parameter.type)) return { a, b -> + when (val x = a.next()) { + is LispData.LispNumber -> x.value + else -> null.also { b.reportError("Could not coerce $x to number") } + } + } + if (Float::class.java.isAssignableFrom(parameter.type)) return { a, b -> + when (val x = a.next()) { + is LispData.LispNumber -> x.value.toFloat() + else -> null.also { b.reportError("Could not coerce $x to number") } + } + } + if (Int::class.java.isAssignableFrom(parameter.type)) return { a, b -> + when (val x = a.next()) { + is LispData.LispNumber -> x.value.toInt() + else -> null.also { b.reportError("Could not coerce $x to number") } + } + } + if (Long::class.java.isAssignableFrom(parameter.type)) return { a, b -> + when (val x = a.next()) { + is LispData.LispNumber -> x.value.toLong() + else -> null.also { b.reportError("Could not coerce $x to number") } + } + } + return null + } + + + val objectMappers = mutableListOf<((Parameter) -> (((Iterator<LispData>, ErrorReporter) -> Any?)?))>( + ::mapLispData, + ::mapErrorReporter, + ::mapNumber, + ::mapString, + ::mapBoolean, + ) + + + fun generateInstanceBindings(obj: Any): Map<String, LispData> { + val bindings = mutableMapOf<String, LispData>() + for (method in obj.javaClass.methods) { + val annotation = method.getAnnotation(LispBinding::class.java) + if (annotation == null) continue + require(LispParser.isValidIdentifier(annotation.name)) + bindings[annotation.name] = wrapMethod(obj, annotation.name, method) + } + // TODO: field bindings + return bindings + } + + private val lookup = MethodHandles.publicLookup() + fun wrapMethod(obj: Any, name: String, method: Method): LispData.LispExecutable { + var mh = lookup.unreflect(method) + if (method.modifiers and Modifier.STATIC == 0) { + mh = mh.bindTo(obj) + } + val objectMappers = method.parameters.map { param -> + objectMappers.firstNotNullOfOrNull { it.invoke(param) } + ?: error("Could not find object mapper for parameter $param") + } + return LispData.externalCall(name) { args, fReportError -> + try { + val iterator = args.iterator() + val e = object : ErrorReporter { + override fun reportError(string: String): LispData { + return fReportError(string) + } + } + val p = objectMappers.map { it.invoke(iterator, e) ?: return@externalCall LispData.LispNil } + if (iterator.hasNext()) return@externalCall fReportError("Too many arguments") + mh.invokeWithArguments(p) as LispData + } catch (e: Exception) { + fReportError("$name threw an exception: $e") + } + } + } + + fun bindTo(obj: Any, frame: StackFrame) { + frame.variables.putAll(generateInstanceBindings(obj)) + } +}
\ No newline at end of file diff --git a/src/bind/LispBinding.kt b/src/bind/LispBinding.kt new file mode 100644 index 0000000..7af0e67 --- /dev/null +++ b/src/bind/LispBinding.kt @@ -0,0 +1,7 @@ +package moe.nea.lisp.bind + +@Retention(AnnotationRetention.RUNTIME) +@Target(AnnotationTarget.FIELD, AnnotationTarget.FUNCTION) +annotation class LispBinding( + val name: String, +) |