diff options
Diffstat (limited to 'sca-cpp/trunk/modules/java')
| -rw-r--r-- | sca-cpp/trunk/modules/java/Makefile.am | 5 | ||||
| -rw-r--r-- | sca-cpp/trunk/modules/java/driver.hpp | 4 | ||||
| -rw-r--r-- | sca-cpp/trunk/modules/java/eval.hpp | 334 | ||||
| -rw-r--r-- | sca-cpp/trunk/modules/java/java-shell.cpp | 4 | ||||
| -rw-r--r-- | sca-cpp/trunk/modules/java/java-test.cpp | 26 | ||||
| -rw-r--r-- | sca-cpp/trunk/modules/java/jni-test.cpp | 8 | ||||
| -rw-r--r-- | sca-cpp/trunk/modules/java/mod-java.cpp | 27 | ||||
| -rw-r--r-- | sca-cpp/trunk/modules/java/mod-java.hpp | 40 |
8 files changed, 220 insertions, 228 deletions
diff --git a/sca-cpp/trunk/modules/java/Makefile.am b/sca-cpp/trunk/modules/java/Makefile.am index 8b80276d15..a25576537c 100644 --- a/sca-cpp/trunk/modules/java/Makefile.am +++ b/sca-cpp/trunk/modules/java/Makefile.am @@ -36,7 +36,7 @@ EXTRA_DIST = domain-test.composite mod_LTLIBRARIES = libmod_tuscany_java.la libmod_tuscany_java_la_SOURCES = mod-java.cpp -libmod_tuscany_java_la_LDFLAGS = -lxml2 -lcurl -lmozjs ${JAVA_LDFLAGS} +libmod_tuscany_java_la_LDFLAGS = -lxml2 -lcurl -ljansson ${JAVA_LDFLAGS} noinst_DATA = libmod_tuscany_java${libsuffix} libmod_tuscany_java${libsuffix}: ln -s .libs/libmod_tuscany_java${libsuffix} @@ -55,12 +55,13 @@ jardir = ${prefix}/modules/java jarfile = libmod-tuscany-java-${PACKAGE_VERSION}.jar jar_DATA = ${jarfile} ${jarfile}: ${dist_mod_JAVA} + ${JAVAC} ${dist_mod_JAVA} ${JAR} cf $@ org/apache/tuscany/*.class CLEANFILES = *.stamp ${jarfile} org/apache/tuscany/*.class test/*.class client_test_SOURCES = client-test.cpp -client_test_LDFLAGS = -lxml2 -lcurl -lmozjs +client_test_LDFLAGS = -lxml2 -lcurl -ljansson dist_noinst_SCRIPTS = server-test wiring-test noinst_PROGRAMS = jni-test java-test client-test diff --git a/sca-cpp/trunk/modules/java/driver.hpp b/sca-cpp/trunk/modules/java/driver.hpp index ddfc057940..4ffc84f4db 100644 --- a/sca-cpp/trunk/modules/java/driver.hpp +++ b/sca-cpp/trunk/modules/java/driver.hpp @@ -37,7 +37,7 @@ namespace java { const value evalDriverLoop(const JavaRuntime& jr, const JavaClass jc, istream& in, ostream& out) { scheme::promptForInput(scheme::evalInputPrompt, out); - value input = scheme::readValue(in); + const value input = content(scheme::readValue(in)); if (isNil(input)) return input; const failable<value> output = evalClass(jr, input, jc); @@ -46,7 +46,7 @@ const value evalDriverLoop(const JavaRuntime& jr, const JavaClass jc, istream& i return evalDriverLoop(jr, jc, in, out); } -const bool evalDriverRun(const char* name, istream& in, ostream& out) { +const bool evalDriverRun(const char* const name, istream& in, ostream& out) { scheme::setupDisplay(out); JavaRuntime javaRuntime; const failable<JavaClass> jc = readClass(javaRuntime, ".", name); 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); diff --git a/sca-cpp/trunk/modules/java/java-shell.cpp b/sca-cpp/trunk/modules/java/java-shell.cpp index 51df513990..d76fa8b45b 100644 --- a/sca-cpp/trunk/modules/java/java-shell.cpp +++ b/sca-cpp/trunk/modules/java/java-shell.cpp @@ -29,8 +29,8 @@ #include "string.hpp" #include "driver.hpp" -int main(const int argc, char** argv) { - tuscany::gc_scoped_pool pool; +int main(const int argc, const char** const argv) { + const tuscany::gc_scoped_pool pool; if (argc != 2) { tuscany::cerr << "Usage: java-shell <class name>" << tuscany::endl; return 1; diff --git a/sca-cpp/trunk/modules/java/java-test.cpp b/sca-cpp/trunk/modules/java/java-test.cpp index f811a4f58d..7ae170d03f 100644 --- a/sca-cpp/trunk/modules/java/java-test.cpp +++ b/sca-cpp/trunk/modules/java/java-test.cpp @@ -32,8 +32,8 @@ namespace tuscany { namespace java { bool testEvalExpr() { - gc_scoped_pool pool; - JavaRuntime javaRuntime; + const gc_scoped_pool pool; + const JavaRuntime javaRuntime; { const failable<JavaClass> obj = readClass(javaRuntime, ".", "test.CalcImpl"); assert(hasContent(obj)); @@ -48,7 +48,7 @@ bool testEvalExpr() { const value exp = mklist<value>("even", 2); const failable<value> r = evalClass(javaRuntime, exp, content(obj)); assert(hasContent(r)); - assert(content(r) == value(true)); + assert(content(r) == trueValue); } { const failable<JavaClass> obj = readClass(javaRuntime, ".", "test.AdderImpl"); @@ -77,12 +77,12 @@ const value add(const list<value>& args) { } bool testEvalLambda() { - gc_scoped_pool pool; - JavaRuntime javaRuntime; + const gc_scoped_pool pool; + const JavaRuntime javaRuntime; { const failable<JavaClass> obj = readClass(javaRuntime, ".", "test.CalcImpl"); assert(hasContent(obj)); - const value tcel = mklist<value>("add", 3, 4, lambda<value(const list<value>&)>(add)); + const value tcel = mklist<value>("add", 3, 4, lvvlambda(add)); const failable<value> r = evalClass(javaRuntime, tcel, content(obj)); assert(hasContent(r)); assert(content(r) == value(7)); @@ -90,7 +90,7 @@ bool testEvalLambda() { { const failable<JavaClass> obj = readClass(javaRuntime, ".", "test.CalcImpl"); assert(hasContent(obj)); - const value tcel = mklist<value>("addEval", 3, 4, lambda<value(const list<value>&)>(add)); + const value tcel = mklist<value>("addEval", 3, 4, lvvlambda(add)); const failable<value> r = evalClass(javaRuntime, tcel, content(obj)); assert(hasContent(r)); assert(content(r) == value(7)); @@ -99,26 +99,26 @@ bool testEvalLambda() { } bool testClassLoader() { - gc_scoped_pool pool; - JavaRuntime javaRuntime; + const gc_scoped_pool pool; + const JavaRuntime javaRuntime; const failable<JavaClass> obj = readClass(javaRuntime, ".", "org.apache.tuscany.ClassLoader$Test"); assert(hasContent(obj)); const value exp = mklist<value>("testClassLoader"); const failable<value> r = evalClass(javaRuntime, exp, content(obj)); assert(hasContent(r)); - assert(content(r) == value(true)); + assert(content(r) == trueValue); return true; } bool testIterableUtil() { - gc_scoped_pool pool; - JavaRuntime javaRuntime; + const gc_scoped_pool pool; + const JavaRuntime javaRuntime; const failable<JavaClass> obj = readClass(javaRuntime, ".", "org.apache.tuscany.IterableUtil$Test"); assert(hasContent(obj)); const value exp = mklist<value>("testList"); const failable<value> r = evalClass(javaRuntime, exp, content(obj)); assert(hasContent(r)); - assert(content(r) == value(true)); + assert(content(r) == trueValue); return true; } diff --git a/sca-cpp/trunk/modules/java/jni-test.cpp b/sca-cpp/trunk/modules/java/jni-test.cpp index 727af13dc6..f69460f235 100644 --- a/sca-cpp/trunk/modules/java/jni-test.cpp +++ b/sca-cpp/trunk/modules/java/jni-test.cpp @@ -40,7 +40,7 @@ namespace java { #endif bool testJNI() { - gc_scoped_pool pool; + const gc_scoped_pool pool; JavaVM* jvm; JNIEnv* env; @@ -50,7 +50,7 @@ bool testJNI() { JavaVMOption options[3]; args.options = options; args.nOptions = 0; - 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; @@ -60,9 +60,9 @@ bool testJNI() { JNI_CreateJavaVM(&jvm, (void**)&env, &args); #endif - jclass classClass = env->FindClass("java/lang/Class"); + const jclass classClass = env->FindClass("java/lang/Class"); assert(classClass != NULL); - jclass loaderClass = env->FindClass("org/apache/tuscany/ClassLoader"); + const jclass loaderClass = env->FindClass("org/apache/tuscany/ClassLoader"); assert(loaderClass != NULL); return true; } diff --git a/sca-cpp/trunk/modules/java/mod-java.cpp b/sca-cpp/trunk/modules/java/mod-java.cpp index d96861cc6d..61711db9f4 100644 --- a/sca-cpp/trunk/modules/java/mod-java.cpp +++ b/sca-cpp/trunk/modules/java/mod-java.cpp @@ -40,32 +40,25 @@ namespace modeval { /** * Apply a lifecycle start or restart event. */ -struct javaLifecycle { - javaLifecycle(java::JavaRuntime& jr) : jr(jr) { - } - const value operator()(const list<value>& params) const { - const value func = car(params); - if (func == "javaRuntime") - return (gc_ptr<value>)(value*)(void*)&jr; - return lambda<value(const list<value>&)>(); - } - java::JavaRuntime& jr; -}; - const value applyLifecycle(unused const list<value>& params) { // Create a Java runtime - java::JavaRuntime& jr = *(new (gc_new<java::JavaRuntime>()) java::JavaRuntime()); + const java::JavaRuntime& jr = *(new (gc_new<java::JavaRuntime>()) java::JavaRuntime()); // Return the function to invoke on subsequent events - return failable<value>(lambda<value(const list<value>&)>(javaLifecycle(jr))); + return failable<value>(lvvlambda([&jr](const list<value>& params) -> const value { + const value func = car(params); + if (func == "javaRuntime") + return (gc_ptr<value>)(value*)(void*)&jr; + return lvvlambda(); + })); } /** * Evaluate a Java component implementation and convert it to an applicable * lambda function. */ -const failable<lambda<value(const list<value>&)> > evalImplementation(const string& path, const value& impl, const list<value>& px, const lambda<value(const list<value>&)>& lifecycle) { +const failable<lvvlambda > evalImplementation(const string& path, const value& impl, const list<value>& px, const lvvlambda& lifecycle) { const string itype(elementName(impl)); if (contains(itype, ".java")) { const void* p = (gc_ptr<value>)lifecycle(mklist<value>("javaRuntime")); @@ -74,8 +67,8 @@ const failable<lambda<value(const list<value>&)> > evalImplementation(const stri if (contains(itype, ".cpp")) return modcpp::evalImplementation(path, impl, px); if (contains(itype, ".widget")) - return mkfailure<lambda<value(const list<value>&)> >(string("Unsupported implementation type: ") + itype, -1, false); - return mkfailure<lambda<value(const list<value>&)> >(string("Unsupported implementation type: ") + itype); + return mkfailure<lvvlambda >(string("Unsupported implementation type: ") + itype, -1, false); + return mkfailure<lvvlambda >(string("Unsupported implementation type: ") + itype); } } diff --git a/sca-cpp/trunk/modules/java/mod-java.hpp b/sca-cpp/trunk/modules/java/mod-java.hpp index b68f17aa3f..4dd2fe33a2 100644 --- a/sca-cpp/trunk/modules/java/mod-java.hpp +++ b/sca-cpp/trunk/modules/java/mod-java.hpp @@ -40,34 +40,26 @@ namespace server { namespace modjava { /** - * Apply a Java component implementation function. - */ -struct applyImplementation { - java::JavaClass impl; - const list<value> px; - java::JavaRuntime& jr; - applyImplementation(const java::JavaClass& impl, const list<value>& px, java::JavaRuntime& jr) : impl(impl), px(px), jr(jr) { - } - const value operator()(const list<value>& params) const { - const value expr = append<value>(params, px); - debug(expr, "modeval::java::applyImplementation::input"); - const failable<value> res = java::evalClass(jr, expr, impl); - const value val = !hasContent(res)? mklist<value>(value(), reason(res), rcode(res)) : mklist<value>(content(res)); - debug(val, "modeval::java::applyImplementation::result"); - return val; - } -}; - -/** * Evaluate a Java component implementation and convert it to an applicable * lambda function. */ -const failable<lambda<value(const list<value>&)> > evalImplementation(const string& path, const value& impl, const list<value>& px, java::JavaRuntime& jr) { +const failable<lvvlambda > evalImplementation(const string& path, const value& impl, const list<value>& px, const java::JavaRuntime& jr) { const string cn(attributeValue("class", impl)); - const failable<java::JavaClass> jc = java::readClass(jr, path, cn); - if (!hasContent(jc)) - return mkfailure<lambda<value(const list<value>&)> >(jc); - return lambda<value(const list<value>&)>(applyImplementation(content(jc), px, jr)); + const failable<java::JavaClass> fjc = java::readClass(jr, path, cn); + if (!hasContent(fjc)) + return mkfailure<lvvlambda >(fjc); + + // Return Java component implementation lambda function + const java::JavaClass jc = content(fjc); + const lvvlambda applyImplementation = [jc, px, jr](const list<value>& params) -> const value { + const value expr = append<value>(params, px); + debug(expr, "modeval::java::applyImplementation::expr"); + const failable<value> res = java::evalClass(jr, expr, jc); + const value val = !hasContent(res)? mklist<value>(nilValue, reason(res), rcode(res)) : mklist<value>(content(res)); + debug(val, "modeval::java::applyImplementation::result"); + return val; + }; + return applyImplementation; } } |