diff options
Diffstat (limited to 'sca-cpp/trunk/modules/java/eval.hpp')
| -rw-r--r-- | sca-cpp/trunk/modules/java/eval.hpp | 334 |
1 files changed, 170 insertions, 164 deletions
diff --git a/sca-cpp/trunk/modules/java/eval.hpp b/sca-cpp/trunk/modules/java/eval.hpp index 31fb09f741..2c76b764fa 100644 --- a/sca-cpp/trunk/modules/java/eval.hpp +++ b/sca-cpp/trunk/modules/java/eval.hpp @@ -50,12 +50,12 @@ jobject JNICALL nativeUUID(JNIEnv *env); class JavaRuntime { public: - JavaRuntime() { + JavaRuntime() : h(*(new (gc_new<handles>()) handles())) { debug("java::javaruntime"); // Get existing JVM jsize nvms = 0; - JNI_GetCreatedJavaVMs(&jvm, 1, &nvms); + JNI_GetCreatedJavaVMs(&h.jvm, 1, &nvms); if (nvms == 0) { // Create a new JVM @@ -67,7 +67,7 @@ public: args.nOptions = 0; // Configure classpath - const char* envcp = getenv("CLASSPATH"); + const char* const envcp = getenv("CLASSPATH"); const string cp = string("-Djava.class.path=") + (envcp == NULL? "." : envcp); options[args.nOptions].optionString = const_cast<char*>(c_str(cp)); options[args.nOptions++].extraInfo = NULL; @@ -78,12 +78,12 @@ public: #endif // Configure Java debugging - const char* jpdaopts = getenv("JPDA_OPTS"); + const char* const jpdaopts = getenv("JPDA_OPTS"); if (jpdaopts != NULL) { options[args.nOptions].optionString = const_cast<char*>(jpdaopts); options[args.nOptions++].extraInfo = NULL; } else { - const char* jpdaaddr = getenv("JPDA_ADDRESS"); + const char* const jpdaaddr = getenv("JPDA_ADDRESS"); if (jpdaaddr != NULL) { const string jpda = string("-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=") + jpdaaddr; options[args.nOptions].optionString = const_cast<char*>(c_str(jpda)); @@ -93,114 +93,131 @@ public: // Create the JVM #ifdef JAVA_HARMONY_VM - JNI_CreateJavaVM(&jvm, &env, &args); + JNI_CreateJavaVM(&h.jvm, &h.env, &args); #else - JNI_CreateJavaVM(&jvm, (void**)&env, &args); + JNI_CreateJavaVM(&h.jvm, (void**)&h.env, &args); #endif } else { // Just point to existing JVM - jvm->GetEnv((void**)&env, JNI_VERSION); + h.jvm->GetEnv((void**)&h.env, JNI_VERSION); } // Lookup System classes and methods - classClass = env->FindClass("java/lang/Class"); - methodClass = env->FindClass("java/lang/reflect/Method"); - objectClass = env->FindClass("java/lang/Object"); - doubleClass = env->FindClass("java/lang/Double"); - booleanClass = env->FindClass("java/lang/Boolean"); - stringClass = env->FindClass("java/lang/String"); - objectArrayClass = env->FindClass("[Ljava/lang/Object;"); - iterableClass = env->FindClass("java/lang/Iterable"); - classForName = env->GetStaticMethodID(classClass, "forName", "(Ljava/lang/String;ZLjava/lang/ClassLoader;)Ljava/lang/Class;"); - doubleValueOf = env->GetStaticMethodID(doubleClass, "valueOf", "(D)Ljava/lang/Double;"); - doubleValue = env->GetMethodID(doubleClass, "doubleValue", "()D"); - booleanValueOf = env->GetStaticMethodID(booleanClass, "valueOf", "(Z)Ljava/lang/Boolean;"); - booleanValue = env->GetMethodID(booleanClass, "booleanValue", "()Z"); - declaredMethods = env->GetMethodID(classClass, "getDeclaredMethods", "()[Ljava/lang/reflect/Method;"); - methodName = env->GetMethodID(methodClass, "getName", "()Ljava/lang/String;"); - parameterTypes = env->GetMethodID(methodClass, "getParameterTypes", "()[Ljava/lang/Class;"); + h.classClass = h.env->FindClass("java/lang/Class"); + h.methodClass = h.env->FindClass("java/lang/reflect/Method"); + h.objectClass = h.env->FindClass("java/lang/Object"); + h.doubleClass = h.env->FindClass("java/lang/Double"); + h.booleanClass = h.env->FindClass("java/lang/Boolean"); + h.stringClass = h.env->FindClass("java/lang/String"); + h.objectArrayClass = h.env->FindClass("[Ljava/lang/Object;"); + h.iterableClass = h.env->FindClass("java/lang/Iterable"); + h.classForName = h.env->GetStaticMethodID(h.classClass, "forName", "(Ljava/lang/String;ZLjava/lang/ClassLoader;)Ljava/lang/Class;"); + h.doubleValueOf = h.env->GetStaticMethodID(h.doubleClass, "valueOf", "(D)Ljava/lang/Double;"); + h.doubleValue = h.env->GetMethodID(h.doubleClass, "doubleValue", "()D"); + h.booleanValueOf = h.env->GetStaticMethodID(h.booleanClass, "valueOf", "(Z)Ljava/lang/Boolean;"); + h.booleanValue = h.env->GetMethodID(h.booleanClass, "booleanValue", "()Z"); + h.declaredMethods = h.env->GetMethodID(h.classClass, "getDeclaredMethods", "()[Ljava/lang/reflect/Method;"); + h.methodName = h.env->GetMethodID(h.methodClass, "getName", "()Ljava/lang/String;"); + h.parameterTypes = h.env->GetMethodID(h.methodClass, "getParameterTypes", "()[Ljava/lang/Class;"); // Lookup Tuscany classes and methods - loaderClass = env->FindClass("org/apache/tuscany/ClassLoader"); - loaderValueOf = env->GetStaticMethodID(loaderClass, "valueOf", "(Ljava/lang/String;)Ljava/lang/ClassLoader;"); - loaderForName = env->GetStaticMethodID(loaderClass, "forName", "(Ljava/lang/String;ZLjava/lang/ClassLoader;)Ljava/lang/Class;"); - invokerClass = env->FindClass("org/apache/tuscany/InvocationHandler"); - invokerValueOf = env->GetStaticMethodID(invokerClass, "valueOf", "(Ljava/lang/Class;J)Ljava/lang/Object;"); - invokerStackTrace = env->GetStaticMethodID(invokerClass, "stackTrace", "(Ljava/lang/Throwable;)Ljava/lang/String;"); - invokerLambda = env->GetFieldID(invokerClass, "lambda", "J"); - iterableUtilClass = env->FindClass("org/apache/tuscany/IterableUtil"); - iterableValueOf = env->GetStaticMethodID(iterableUtilClass, "list", "([Ljava/lang/Object;)Ljava/lang/Iterable;"); - iterableIsNil = env->GetStaticMethodID(iterableUtilClass, "isNil", "(Ljava/lang/Object;)Z"); - iterableCar = env->GetStaticMethodID(iterableUtilClass, "car", "(Ljava/lang/Object;)Ljava/lang/Object;"); - iterableCdr = env->GetStaticMethodID(iterableUtilClass, "cdr", "(Ljava/lang/Object;)Ljava/lang/Iterable;"); - uuidClass = env->FindClass("org/apache/tuscany/UUIDUtil"); + h.loaderClass = h.env->FindClass("org/apache/tuscany/ClassLoader"); + h.loaderValueOf = h.env->GetStaticMethodID(h.loaderClass, "valueOf", "(Ljava/lang/String;)Ljava/lang/ClassLoader;"); + h.loaderForName = h.env->GetStaticMethodID(h.loaderClass, "forName", "(Ljava/lang/String;ZLjava/lang/ClassLoader;)Ljava/lang/Class;"); + h.invokerClass = h.env->FindClass("org/apache/tuscany/InvocationHandler"); + h.invokerValueOf = h.env->GetStaticMethodID(h.invokerClass, "valueOf", "(Ljava/lang/Class;J)Ljava/lang/Object;"); + h.invokerStackTrace = h.env->GetStaticMethodID(h.invokerClass, "stackTrace", "(Ljava/lang/Throwable;)Ljava/lang/String;"); + h.invokerLambda = h.env->GetFieldID(h.invokerClass, "lambda", "J"); + h.iterableUtilClass = h.env->FindClass("org/apache/tuscany/IterableUtil"); + h.iterableValueOf = h.env->GetStaticMethodID(h.iterableUtilClass, "list", "([Ljava/lang/Object;)Ljava/lang/Iterable;"); + h.iterableIsNil = h.env->GetStaticMethodID(h.iterableUtilClass, "isNil", "(Ljava/lang/Object;)Z"); + h.iterableCar = h.env->GetStaticMethodID(h.iterableUtilClass, "car", "(Ljava/lang/Object;)Ljava/lang/Object;"); + h.iterableCdr = h.env->GetStaticMethodID(h.iterableUtilClass, "cdr", "(Ljava/lang/Object;)Ljava/lang/Iterable;"); + h.uuidClass = h.env->FindClass("org/apache/tuscany/UUIDUtil"); // Register our native invocation handler function JNINativeMethod invokenm; invokenm.name = const_cast<char*>("invoke"); invokenm.signature = const_cast<char*>("(Ljava/lang/Object;Ljava/lang/reflect/Method;[Ljava/lang/Object;)Ljava/lang/Object;"); invokenm.fnPtr = (void*)nativeInvoke; - env->RegisterNatives(invokerClass, &invokenm, 1); + h.env->RegisterNatives(h.invokerClass, &invokenm, 1); // Register our native UUID function JNINativeMethod uuidnm; uuidnm.name = const_cast<char*>("uuid"); uuidnm.signature = const_cast<char*>("()Ljava/lang/String;"); uuidnm.fnPtr = (void*)nativeUUID; - env->RegisterNatives(uuidClass, &uuidnm, 1); + h.env->RegisterNatives(h.uuidClass, &uuidnm, 1); } + JavaRuntime(const JavaRuntime& c) : h(c.h) { + } + + JavaRuntime& operator=(const JavaRuntime&) = delete; + ~JavaRuntime() { } - JavaVM* jvm; - JNIEnv* env; - - jclass classClass; - jclass methodClass; - jclass objectClass; - jclass doubleClass; - jclass booleanClass; - jclass stringClass; - jclass objectArrayClass; - jclass iterableClass; - jmethodID doubleValueOf; - jmethodID doubleValue; - jmethodID booleanValueOf; - jmethodID booleanValue; - jmethodID declaredMethods; - jmethodID methodName; - jmethodID parameterTypes; - jmethodID classForName; - jclass loaderClass; - jmethodID loaderValueOf; - jmethodID loaderForName; - jclass invokerClass; - jmethodID invokerValueOf; - jmethodID invokerStackTrace; - jfieldID invokerLambda; - jclass iterableUtilClass; - jmethodID iterableValueOf; - jmethodID iterableCar; - jmethodID iterableCdr; - jmethodID iterableIsNil; - jclass uuidClass; +public: + class handles { + public: + handles() { + } + + public: + friend class JavaRuntime; + + JavaVM* jvm; + JNIEnv* env; + + jclass classClass; + jclass methodClass; + jclass objectClass; + jclass doubleClass; + jclass booleanClass; + jclass stringClass; + jclass objectArrayClass; + jclass iterableClass; + jmethodID doubleValueOf; + jmethodID doubleValue; + jmethodID booleanValueOf; + jmethodID booleanValue; + jmethodID declaredMethods; + jmethodID methodName; + jmethodID parameterTypes; + jmethodID classForName; + jclass loaderClass; + jmethodID loaderValueOf; + jmethodID loaderForName; + jclass invokerClass; + jmethodID invokerValueOf; + jmethodID invokerStackTrace; + jfieldID invokerLambda; + jclass iterableUtilClass; + jmethodID iterableValueOf; + jmethodID iterableCar; + jmethodID iterableCdr; + jmethodID iterableIsNil; + jclass uuidClass; + }; + + handles& h; }; /** * Return the last exception that occurred in a JVM. */ -string lastException(const JavaRuntime& jr) { - if (!jr.env->ExceptionCheck()) +const string lastException(const JavaRuntime& jr) { + if (!jr.h.env->ExceptionCheck()) return "No Exception"; - const jthrowable ex = jr.env->ExceptionOccurred(); - const jstring trace = (jstring)jr.env->CallStaticObjectMethod(jr.invokerClass, jr.invokerStackTrace, ex); - const char* c = jr.env->GetStringUTFChars(trace, NULL); + const jthrowable ex = jr.h.env->ExceptionOccurred(); + const jstring trace = (jstring)jr.h.env->CallStaticObjectMethod(jr.h.invokerClass, jr.h.invokerStackTrace, ex); + const char* const c = jr.h.env->GetStringUTFChars(trace, NULL); const string msg(c); - jr.env->ReleaseStringUTFChars(trace, c); - jr.env->ExceptionClear(); + jr.h.env->ReleaseStringUTFChars(trace, c); + jr.h.env->ExceptionClear(); return msg; } @@ -216,7 +233,7 @@ const list<value> jiterableToValues(const JavaRuntime& jr, const jobject o); /** * Convert a Java class name to a JNI class name. */ -const bool jniClassNameHelper(char* to, const char* from) { +const bool jniClassNameHelper(char* const to, const char* const from) { if (*from == '\0') { *to = '\0'; return true; @@ -236,7 +253,7 @@ const string jniClassName(const string& from) { */ class javaLambda { public: - javaLambda(const JavaRuntime& jr, const value& iface, const lambda<value(const list<value>&)>& func) : jr(jr), iface(iface), func(func) { + javaLambda(const JavaRuntime& jr, const value& iface, const lvvlambda& func) : jr(jr), iface(iface), func(func) { } const value operator()(const list<value>& expr) const { @@ -255,9 +272,10 @@ public: return func(expr); } - const JavaRuntime& jr; +public: + const JavaRuntime jr; const value iface; - const lambda<value(const list<value>&)> func; + const lvvlambda func; }; /** @@ -267,12 +285,12 @@ public: jobject JNICALL nativeInvoke(JNIEnv* env, jobject self, unused jobject proxy, jobject method, jobjectArray args) { // Retrieve the lambda function from the invocation handler - jclass clazz = env->GetObjectClass(self); - jfieldID f = env->GetFieldID(clazz, "lambda", "J"); + const jclass clazz = env->GetObjectClass(self); + const jfieldID f = env->GetFieldID(clazz, "lambda", "J"); const javaLambda& jl = *(javaLambda*)(long)env->GetLongField(self, f); // Retrieve the function name - const jstring s = (jstring)env->CallObjectMethod(method, jl.jr.methodName); + const jstring s = (jstring)env->CallObjectMethod(method, jl.jr.h.methodName); const char* c = env->GetStringUTFChars(s, NULL); const value func(c); env->ReleaseStringUTFChars(s, c); @@ -287,7 +305,7 @@ jobject JNICALL nativeInvoke(JNIEnv* env, jobject self, unused jobject proxy, jo debug(result, "java::nativeInvoke::result"); // Convert result to a jobject - return valueToJobject(jl.jr, value(), result); + return valueToJobject(jl.jr, nilValue, result); } /** @@ -302,10 +320,10 @@ jobject JNICALL nativeUUID(JNIEnv* env) { /** * Convert a lambda function to Java proxy. */ -const jobject mkJavaLambda(const JavaRuntime& jr, unused const value& iface, const lambda<value(const list<value>&)>& l) { +const jobject mkJavaLambda(const JavaRuntime& jr, unused const value& iface, const lvvlambda& l) { const gc_ptr<javaLambda> jl = new (gc_new<javaLambda>()) javaLambda(jr, iface, l); jclass jc = (jclass)(long)(double)iface; - const jobject obj = jr.env->CallStaticObjectMethod(jr.invokerClass, jr.invokerValueOf, jc, (long)(javaLambda*)jl); + const jobject obj = jr.h.env->CallStaticObjectMethod(jr.h.invokerClass, jr.h.invokerValueOf, jc, (long)(javaLambda*)jl); return obj; } @@ -315,20 +333,20 @@ const jobject mkJavaLambda(const JavaRuntime& jr, unused const value& iface, con const jobjectArray valuesToJarrayHelper(const JavaRuntime& jr, jobjectArray a, const list<value>& v, const int i) { if (isNil(v)) return a; - jr.env->SetObjectArrayElement(a, i, valueToJobject(jr, value(), car(v))); + jr.h.env->SetObjectArrayElement(a, i, valueToJobject(jr, nilValue, car(v))); return valuesToJarrayHelper(jr, a, cdr(v), i + 1); } const jobjectArray valuesToJarray(const JavaRuntime& jr, const list<value>& v) { - jobjectArray a = jr.env->NewObjectArray((jsize)length(v), jr.objectClass, NULL); + jobjectArray a = jr.h.env->NewObjectArray((jsize)length(v), jr.h.objectClass, NULL); return valuesToJarrayHelper(jr, a, v, 0); } /** * Convert a Java jobjectArray to a Java iterable. */ -const jobject jarrayToJiterable(const JavaRuntime& jr, jobjectArray a) { - return jr.env->CallStaticObjectMethod(jr.iterableClass, jr.iterableValueOf, a); +const jobject jarrayToJiterable(const JavaRuntime& jr, const jobjectArray a) { + return jr.h.env->CallStaticObjectMethod(jr.h.iterableClass, jr.h.iterableValueOf, a); } /** @@ -341,13 +359,13 @@ const jobject valueToJobject(const JavaRuntime& jr, const value& jtype, const va case value::Lambda: return mkJavaLambda(jr, jtype, v); case value::Symbol: - return jr.env->NewStringUTF(c_str(string("'") + v)); + return jr.h.env->NewStringUTF(c_str(string("'") + (string)v)); case value::String: - return jr.env->NewStringUTF(c_str(v)); + return jr.h.env->NewStringUTF(c_str(v)); case value::Number: - return jr.env->CallStaticObjectMethod(jr.doubleClass, jr.doubleValueOf, (double)v); + return jr.h.env->CallStaticObjectMethod(jr.h.doubleClass, jr.h.doubleValueOf, (double)v); case value::Bool: - return jr.env->CallStaticObjectMethod(jr.booleanClass, jr.booleanValueOf, (bool)v); + return jr.h.env->CallStaticObjectMethod(jr.h.booleanClass, jr.h.booleanValueOf, (bool)v); default: return NULL; } @@ -356,7 +374,7 @@ const jobject valueToJobject(const JavaRuntime& jr, const value& jtype, const va /** * Convert a list of values to an array of jvalues. */ -const jvalue* valuesToJvaluesHelper(const JavaRuntime& jr, jvalue* a, const list<value>& types, const list<value>& v) { +const jvalue* valuesToJvaluesHelper(const JavaRuntime& jr, jvalue* const a, const list<value>& types, const list<value>& v) { if (isNil(v)) return a; a->l = valueToJobject(jr, car(types), car(v)); @@ -365,7 +383,7 @@ const jvalue* valuesToJvaluesHelper(const JavaRuntime& jr, jvalue* a, const list const jvalue* valuesToJvalues(const JavaRuntime& jr, const list<value>& types, const list<value>& v) { const size_t n = length(v); - jvalue* a = new (gc_anew<jvalue>(n)) jvalue[n]; + jvalue* const a = new (gc_anew<jvalue>(n)) jvalue[n]; valuesToJvaluesHelper(jr, a, types, v); return a; } @@ -373,79 +391,67 @@ const jvalue* valuesToJvalues(const JavaRuntime& jr, const list<value>& types, c /** * Convert a Java jobjectArray to a list of values. */ -const list<value> jarrayToValuesHelper(const JavaRuntime& jr, jobjectArray a, const int i, const int size) { +const list<value> jarrayToValuesHelper(const JavaRuntime& jr, const jobjectArray a, const int i, const int size) { if (i == size) - return list<value>(); - return cons(jobjectToValue(jr, jr.env->GetObjectArrayElement(a, i)), jarrayToValuesHelper(jr, a, i + 1, size)); + return nilListValue; + return cons(jobjectToValue(jr, jr.h.env->GetObjectArrayElement(a, i)), jarrayToValuesHelper(jr, a, i + 1, size)); } -const list<value> jarrayToValues(const JavaRuntime& jr, jobjectArray o) { +const list<value> jarrayToValues(const JavaRuntime& jr, const jobjectArray o) { if (o == NULL) - return list<value>(); - return jarrayToValuesHelper(jr, o, 0, jr.env->GetArrayLength(o)); + return nilListValue; + return jarrayToValuesHelper(jr, o, 0, jr.h.env->GetArrayLength(o)); } /** * Convert a Java Iterable to a list of values. */ -const list<value> jiterableToValuesHelper(const JavaRuntime& jr, jobject o) { - if ((bool)jr.env->CallStaticBooleanMethod(jr.iterableUtilClass, jr.iterableIsNil, o)) - return list<value>(); - jobject car = jr.env->CallStaticObjectMethod(jr.iterableUtilClass, jr.iterableCar, o); - jobject cdr = jr.env->CallStaticObjectMethod(jr.iterableUtilClass, jr.iterableCdr, o); +const list<value> jiterableToValuesHelper(const JavaRuntime& jr, const jobject o) { + if ((bool)jr.h.env->CallStaticBooleanMethod(jr.h.iterableUtilClass, jr.h.iterableIsNil, o)) + return nilListValue; + const jobject car = jr.h.env->CallStaticObjectMethod(jr.h.iterableUtilClass, jr.h.iterableCar, o); + const jobject cdr = jr.h.env->CallStaticObjectMethod(jr.h.iterableUtilClass, jr.h.iterableCdr, o); return cons(jobjectToValue(jr, car), jiterableToValuesHelper(jr, cdr)); } -const list<value> jiterableToValues(const JavaRuntime& jr, jobject o) { +const list<value> jiterableToValues(const JavaRuntime& jr, const jobject o) { if (o == NULL) - return list<value>(); + return nilListValue; return jiterableToValuesHelper(jr, o); } /** - * Lambda function used to represent a Java callable object. - */ -struct javaCallable { - const JavaRuntime& jr; - const jobject obj; - - javaCallable(const JavaRuntime& jr, const jobject obj) : jr(jr), obj(obj) { - } - - const value operator()(const list<value>& args) const { - jobjectArray jargs = valuesToJarray(jr, args); - jobject result = jargs; //CallObject(func, jargs); - return jobjectToValue(jr, result); - } -}; - -/** * Convert a Java jobject to a value. */ const value jobjectToValue(const JavaRuntime& jr, const jobject o) { if (o == NULL) - return value(); - const jclass clazz = jr.env->GetObjectClass(o); - if ((jr.env->IsSameObject(clazz, jr.stringClass))) { - const char* s = jr.env->GetStringUTFChars((jstring)o, NULL); + return nilValue; + const jclass clazz = jr.h.env->GetObjectClass(o); + if ((jr.h.env->IsSameObject(clazz, jr.h.stringClass))) { + const char* const s = jr.h.env->GetStringUTFChars((jstring)o, NULL); if (*s == '\'') { const value v(s + 1); - jr.env->ReleaseStringUTFChars((jstring)o, s); + jr.h.env->ReleaseStringUTFChars((jstring)o, s); return v; } const value v = string(s); - jr.env->ReleaseStringUTFChars((jstring)o, s); + jr.h.env->ReleaseStringUTFChars((jstring)o, s); return v; } - if (jr.env->IsSameObject(clazz, jr.booleanClass)) - return value((bool)jr.env->CallBooleanMethod(o, jr.booleanValue)); - if (jr.env->IsSameObject(clazz, jr.doubleClass)) - return value((double)jr.env->CallDoubleMethod(o, jr.doubleValue)); - if (jr.env->IsAssignableFrom(clazz, jr.iterableClass)) + if (jr.h.env->IsSameObject(clazz, jr.h.booleanClass)) + return value((bool)jr.h.env->CallBooleanMethod(o, jr.h.booleanValue)); + if (jr.h.env->IsSameObject(clazz, jr.h.doubleClass)) + return value((double)jr.h.env->CallDoubleMethod(o, jr.h.doubleValue)); + if (jr.h.env->IsAssignableFrom(clazz, jr.h.iterableClass)) return jiterableToValues(jr, o); - if (jr.env->IsAssignableFrom(clazz, jr.objectArrayClass)) + if (jr.h.env->IsAssignableFrom(clazz, jr.h.objectArrayClass)) return jarrayToValues(jr, (jobjectArray)o); - return lambda<value(const list<value>&)>(javaCallable(jr, o)); + const lvvlambda javaCallable = [jr](const list<value>& params) -> const value { + jobjectArray jargs = valuesToJarray(jr, params); + jobject result = jargs; //CallObject(func, jargs); + return jobjectToValue(jr, result); + }; + return value(javaCallable); } /** @@ -457,33 +463,33 @@ const value parameterTypeToValue(const jobject t) { const list<value> parameterTypesToValues(const JavaRuntime& jr, const jobjectArray t, const int i) { if (i == 0) - return list<value>(); - return cons<value>(parameterTypeToValue(jr.env->GetObjectArrayElement(t, i - 1)), parameterTypesToValues(jr, t, i - 1)); + return nilListValue; + return cons<value>(parameterTypeToValue(jr.h.env->GetObjectArrayElement(t, i - 1)), parameterTypesToValues(jr, t, i - 1)); } const value methodToValue(const JavaRuntime& jr, const jobject m) { - const jobject s = jr.env->CallObjectMethod(m, jr.methodName); - const char* c = jr.env->GetStringUTFChars((jstring)s, NULL); + const jobject s = jr.h.env->CallObjectMethod(m, jr.h.methodName); + const char* const c = jr.h.env->GetStringUTFChars((jstring)s, NULL); const string& name = string(c); - jr.env->ReleaseStringUTFChars((jstring)s, c); + jr.h.env->ReleaseStringUTFChars((jstring)s, c); - const jmethodID mid = jr.env->FromReflectedMethod(m); + const jmethodID mid = jr.h.env->FromReflectedMethod(m); - const jobjectArray t = (jobjectArray)jr.env->CallObjectMethod(m, jr.parameterTypes); - const list<value> types = reverse(parameterTypesToValues(jr, t, jr.env->GetArrayLength(t))); + const jobjectArray t = (jobjectArray)jr.h.env->CallObjectMethod(m, jr.h.parameterTypes); + const list<value> types = reverse(parameterTypesToValues(jr, t, jr.h.env->GetArrayLength(t))); return cons<value>(c_str(name), cons<value>((double)(long)mid, types)); } const list<value> methodsToValues(const JavaRuntime& jr, const jobjectArray m, const int i) { if (i == 0) - return list<value>(); - return cons<value>(methodToValue(jr, jr.env->GetObjectArrayElement(m, i - 1)), methodsToValues(jr, m, i - 1)); + return nilListValue; + return cons<value>(methodToValue(jr, jr.h.env->GetObjectArrayElement(m, i - 1)), methodsToValues(jr, m, i - 1)); } const list<value> methodsToValues(const JavaRuntime& jr, const jclass clazz) { - const jobjectArray m = (jobjectArray)jr.env->CallObjectMethod(clazz, jr.declaredMethods); - return methodsToValues(jr, m, jr.env->GetArrayLength(m)); + const jobjectArray m = (jobjectArray)jr.h.env->CallObjectMethod(clazz, jr.h.declaredMethods); + return methodsToValues(jr, m, jr.h.env->GetArrayLength(m)); } /** @@ -508,20 +514,20 @@ public: const failable<JavaClass> readClass(const JavaRuntime& jr, const string& path, const string& name) { // Create a class loader from the given path - const jobject jpath = jr.env->NewStringUTF(c_str(path)); - jobject loader = jr.env->CallStaticObjectMethod(jr.loaderClass, jr.loaderValueOf, jpath); + const jobject jpath = jr.h.env->NewStringUTF(c_str(path)); + const jobject loader = jr.h.env->CallStaticObjectMethod(jr.h.loaderClass, jr.h.loaderValueOf, jpath); // Load the class - const jobject jname = jr.env->NewStringUTF(c_str(name)); - const jclass clazz = (jclass)jr.env->CallStaticObjectMethod(jr.loaderClass, jr.loaderForName, jname, JNI_TRUE, loader); + const jobject jname = jr.h.env->NewStringUTF(c_str(name)); + const jclass clazz = (jclass)jr.h.env->CallStaticObjectMethod(jr.h.loaderClass, jr.h.loaderForName, jname, JNI_TRUE, loader); if (clazz == NULL) return mkfailure<JavaClass>(string("Couldn't load class: ") + name + " : " + lastException(jr)); // Create an instance - const jmethodID constr = jr.env->GetMethodID(clazz, "<init>", "()V"); + const jmethodID constr = jr.h.env->GetMethodID(clazz, "<init>", "()V"); if (constr == NULL) return mkfailure<JavaClass>(string("Couldn't find constructor: ") + name + " : " + lastException(jr)); - const jobject obj = jr.env->NewObject(clazz, constr); + const jobject obj = jr.h.env->NewObject(clazz, constr); if (obj == NULL) return mkfailure<JavaClass>(string("Couldn't construct object: ") + name + " : " + lastException(jr)); @@ -541,19 +547,19 @@ const failable<value> evalClass(const JavaRuntime& jr, const value& expr, const // The start, stop, and restart functions are optional const value fn = car<value>(expr); if (fn == "start" || fn == "stop") - return value(lambda<value(const list<value>&)>()); + return value(lvvlambda()); - return mkfailure<value>(string("Couldn't find function: ") + car<value>(expr) + " : " + lastException(jr)); + return mkfailure<value>(string("Couldn't find function: ") + (string)car<value>(expr) + " : " + lastException(jr)); } const jmethodID fid = (jmethodID)(long)(double)cadr(func); // Convert args to Java jvalues - const jvalue* args = valuesToJvalues(jr, cddr(func), cdr<value>(expr)); + const jvalue* const args = valuesToJvalues(jr, cddr(func), cdr<value>(expr)); // Call the Java function - const jobject result = jr.env->CallObjectMethodA(jc.obj, fid, const_cast<jvalue*>(args)); + const jobject result = jr.h.env->CallObjectMethodA(jc.obj, fid, const_cast<jvalue*>(args)); if (result == NULL) - return mkfailure<value>(string("Function call failed: ") + car<value>(expr) + " : " + lastException(jr)); + return mkfailure<value>(string("Function call failed: ") + (string)car<value>(expr) + " : " + lastException(jr)); // Convert Java result to a value const value v = jobjectToValue(jr, result); |