jclass clazzclazz = env->FindClass("java/lang/Class");

jmethodID clazz_getMethods = env->GetMethodID(clazzclazz, "getMethods", "()[Ljava/lang/reflect/Method;");

jclass methodClazz = env->FindClass("java/lang/reflect/Method");

jmethodID method_getModifiers = env->GetMethodID(methodClazz, "getModifiers", "()I");

jobjectArray methodObjects = (jobjectArray)env->CallObjectMethod(clazz, clazz_getMethods);

assert(!env->ExceptionCheck());

jsize methodCount = env->GetArrayLength(methodObjects);

for(jsize i=0; i<methodCount; i++) {

jobject method = env->GetObjectArrayElement(methodObjects, i);

jint methodModifiers = env->CallIntMethod(method, method_getModifiers);

assert(!env->ExceptionCheck());

if(!includeStatic && (methodModifiers & MODIFIER_STATIC) == MODIFIER_STATIC) {

continue;

}

methods->push_back(method);

}

jclass clazzclazz = env->FindClass("java/lang/Class");

jmethodID clazz_getConstructors = env->GetMethodID(clazzclazz, "getConstructors", "()[Ljava/lang/reflect/Constructor;");

jobjectArray constructorObjects = (jobjectArray)env->CallObjectMethod(clazz, clazz_getConstructors);

assert(!env->ExceptionCheck());

jsize constructorCount = env->GetArrayLength(constructorObjects);

for(jsize i=0; i<constructorCount; i++) {

jobject constructor = env->GetObjectArrayElement(constructorObjects, i);

methods->push_back(constructor);

}

jclass clazzclazz = env->FindClass("java/lang/Class");

jmethodID clazz_getFields = env->GetMethodID(clazzclazz, "getFields", "()[Ljava/lang/reflect/Field;");

jclass fieldClazz = env->FindClass("java/lang/reflect/Field");

jmethodID field_getModifiers = env->GetMethodID(fieldClazz, "getModifiers", "()I");

jobjectArray fieldObjects = (jobjectArray)env->CallObjectMethod(clazz, clazz_getFields);

assert(!env->ExceptionCheck());

jsize fieldCount = env->GetArrayLength(fieldObjects);

for(jsize i=0; i<fieldCount; i++) {

jobject field = env->GetObjectArrayElement(fieldObjects, i);

jint fieldModifiers = env->CallIntMethod(field, field_getModifiers);

assert(!env->ExceptionCheck());

if((fieldModifiers & MODIFIER_STATIC) == MODIFIER_STATIC) {

continue;

}

fields->push_back(field);

}

const char* chars = env->GetStringUTFChars(str, NULL);

std::string results = chars;

env->ReleaseStringUTFChars(str, chars);

return results;

if(arr == NULL) {

return "(null)";

}

std::ostringstream result;

result << "[";

jsize count = env->GetArrayLength(arr);

for(jsize i=0; i<count; i++) {

if(i != 0) {

result << ", ";

}

jobject obj = env->GetObjectArrayElement(arr, i);

result << javaObjectToString(env, obj);

}

result << "]";

return result.str();

if(obj == NULL) {

return "(null)";

}

jclass objClazz = env->GetObjectClass(obj);

jmethodID methodId = env->GetMethodID(objClazz, "toString", "()Ljava/lang/String;");

jstring result = (jstring)env->CallObjectMethod(obj, methodId);

assert(!env->ExceptionCheck());

return javaToString(env, result);

char temp[100];

std::ostringstream result;

sprintf(temp, "%p", env);

result << temp;

result << ": ";

result << javaObjectToString(env, obj);

result << ": ";

sprintf(temp, "%p", methodId);

result << temp;

result << ": (";

jsize arraySize = env->GetArrayLength(args);

for(int i=0; i<arraySize; i++) {

if(i != 0) {

result << ", ";

}

jobject arg = env->GetObjectArrayElement((jobjectArray)args, i);

result << javaObjectToString(env, arg);

}

result << ")";

return result.str();

jclass threadClazz = env->FindClass("java/lang/Thread");

jmethodID thread_currentThread = env->GetStaticMethodID(threadClazz, "currentThread", "()Ljava/lang/Thread;");

jmethodID thread_getContextClassLoader = env->GetMethodID(threadClazz, "getContextClassLoader", "()Ljava/lang/ClassLoader;");

jobject currentThread = env->CallStaticObjectMethod(threadClazz, thread_currentThread);

assert(!env->ExceptionCheck());

jobject result = env->CallObjectMethod(currentThread, thread_getContextClassLoader);

assert(!env->ExceptionCheck());

return result;

jclass clazzClazz = env->FindClass("java/lang/Class");

jmethodID class_isArray = env->GetMethodID(clazzClazz, "isArray", "()Z");

jboolean isArray = env->CallBooleanMethod(type, class_isArray);

assert(!env->ExceptionCheck());

if(isArray) {

return TYPE_ARRAY;

} else {

// TODO: has to be a better way

std::string str = javaObjectToString(env, type);

const char *typeStr = str.c_str();

//printf("javaGetType: %s\n", typeStr);

if(strcmp(typeStr, "void") == 0) {

return TYPE_VOID;

} else if(strcmp(typeStr, "int") == 0 || strcmp(typeStr, "class java.lang.Integer") == 0) {

return TYPE_INT;

} else if(strcmp(typeStr, "double") == 0 || strcmp(typeStr, "class java.lang.Double") == 0) {

return TYPE_DOUBLE;

} else if(strcmp(typeStr, "float") == 0 || strcmp(typeStr, "class java.lang.Float") == 0) {

return TYPE_FLOAT;

} else if(strcmp(typeStr, "long") == 0 || strcmp(typeStr, "class java.lang.Long") == 0) {

return TYPE_LONG;

} else if(strcmp(typeStr, "boolean") == 0 || strcmp(typeStr, "class java.lang.Boolean") == 0) {

return TYPE_BOOLEAN;

} else if(strcmp(typeStr, "short") == 0 || strcmp(typeStr, "class java.lang.Short") == 0) {

return TYPE_SHORT;

} else if(strcmp(typeStr, "byte") == 0 || strcmp(typeStr, "class java.lang.Byte") == 0) {

return TYPE_BYTE;

} else if(strcmp(typeStr, "class java.lang.String") == 0) {

return TYPE_STRING;

}

return TYPE_OBJECT;

}

std::string searchClassName = className;

std::replace(searchClassName.begin(), searchClassName.end(), '.', '/');

jclass clazz = env->FindClass(searchClassName.c_str());

return clazz;

jobject result = NULL;

jclass clazzclazz = env->GetObjectClass(clazz);

jclass fieldClazz = env->FindClass("java/lang/reflect/Field");

jmethodID field_getName = env->GetMethodID(fieldClazz, "getName", "()Ljava/lang/String;");

jmethodID class_getFields = env->GetMethodID(clazzclazz, "getFields", "()[Ljava/lang/reflect/Field;");

jobjectArray fieldObjects = (jobjectArray)env->CallObjectMethod(clazz, class_getFields);

assert(!env->ExceptionCheck());

jsize fieldCount = env->GetArrayLength(fieldObjects);

for(jsize i=0; i<fieldCount; i++) {

jobject field = env->GetObjectArrayElement(fieldObjects, i);

jstring fieldNameJava = (jstring)env->CallObjectMethod(field, field_getName);

assert(!env->ExceptionCheck());

std::string itFieldName = javaToString(env, fieldNameJava);

if(strcmp(itFieldName.c_str(), fieldName.c_str()) == 0) {

result = field;

break;

}

}

return result;

if(arg.IsEmpty() || arg->IsNull() || arg->IsUndefined()) {

return NULL;

}

if(arg->IsArray()) {

v8::Local<v8::Array> array = v8::Array::Cast(*arg);

uint32_t arraySize = array->Length();

jclass objectClazz = env->FindClass("java/lang/Object");

jobjectArray result = env->NewObjectArray(arraySize, objectClazz, NULL);

for(uint32_t i=0; i<arraySize; i++) {

jobject val = v8ToJava(env, array->Get(i));

env->SetObjectArrayElement(result, i, val);

}

return result;

}

if(arg->IsString()) {

v8::String::Utf8Value val(arg->ToString());

return env->NewStringUTF(*val);

}

if(arg->IsInt32() || arg->IsUint32()) {

jint val = arg->ToInt32()->Value();

jclass clazz = env->FindClass("java/lang/Integer");

jmethodID constructor = env->GetMethodID(clazz, "<init>", "(I)V");

return env->NewObject(clazz, constructor, val);

}

if(arg->IsNumber()) {

jdouble val = arg->ToNumber()->Value();

jclass clazz = env->FindClass("java/lang/Double");

jmethodID constructor = env->GetMethodID(clazz, "<init>", "(D)V");

return env->NewObject(clazz, constructor, val);

}

if(arg->IsBoolean()) {

jboolean val = arg->ToBoolean()->Value();

jclass clazz = env->FindClass("java/lang/Boolean");

jmethodID constructor = env->GetMethodID(clazz, "<init>", "(Z)V");

return env->NewObject(clazz, constructor, val);

}

if(arg->IsObject()) {

v8::Local<v8::Object> obj = v8::Object::Cast(*arg);

v8::Local<v8::Value> isJavaObject = obj->GetHiddenValue(v8::String::New(V8_HIDDEN_MARKER_JAVA_OBJECT));

if(!isJavaObject.IsEmpty() && isJavaObject->IsBoolean()) {

return v8ToJava_javaObject(env, obj);

}

v8::Local<v8::Value> isJavaLong = obj->GetHiddenValue(v8::String::New(V8_HIDDEN_MARKER_JAVA_LONG));

if(!isJavaLong.IsEmpty() && isJavaLong->IsBoolean()) {

return v8ToJava_javaLong(env, obj);

}

}

// TODO: handle other arg types. Don't print here, see instanceof-test#non-java object

// v8::String::AsciiValue typeStr(arg);

// printf("v8ToJava: Unhandled type: %s\n", *typeStr);

return NULL;

JavaObject* javaObject = node::ObjectWrap::Unwrap<JavaObject>(obj);

jobject jobj = javaObject->getObject();

jclass nodeDynamicProxyClass = env->FindClass("node/NodeDynamicProxyClass");

if(env->IsInstanceOf(jobj, nodeDynamicProxyClass)) {

jfieldID ptrField = env->GetFieldID(nodeDynamicProxyClass, "ptr", "J");

DynamicProxyData* proxyData = (DynamicProxyData*)(long)env->GetLongField(jobj, ptrField);

if(!dynamicProxyDataVerify(proxyData)) {

return NULL;

}

jclass dynamicInterface = javaFindClass(env, proxyData->interfaceName);

if(dynamicInterface == NULL) {

printf("Could not find interface %s\n", proxyData->interfaceName.c_str());

return NULL;

}

jclass classClazz = env->FindClass("java/lang/Class");

jobjectArray classArray = env->NewObjectArray(1, classClazz, NULL);

env->SetObjectArrayElement(classArray, 0, dynamicInterface);

jmethodID class_getClassLoader = env->GetMethodID(classClazz, "getClassLoader", "()Ljava/lang/ClassLoader;");

jobject classLoader = env->CallObjectMethod(dynamicInterface, class_getClassLoader);

assert(!env->ExceptionCheck());

if(classLoader == NULL) {

jclass objectClazz = env->FindClass("java/lang/Object");

jmethodID object_getClass = env->GetMethodID(objectClazz, "getClass", "()Ljava/lang/Class;");

jobject jobjClass = env->CallObjectMethod(jobj, object_getClass);

assert(!env->ExceptionCheck());

classLoader = env->CallObjectMethod(jobjClass, class_getClassLoader);

assert(!env->ExceptionCheck());

}

jclass proxyClass = env->FindClass("java/lang/reflect/Proxy");

jmethodID proxy_newProxyInstance = env->GetStaticMethodID(proxyClass, "newProxyInstance", "(Ljava/lang/ClassLoader;[Ljava/lang/Class;Ljava/lang/reflect/InvocationHandler;)Ljava/lang/Object;");

if(classLoader == NULL) {

printf("Could not get classloader for Proxy\n");

return NULL;

}

if(classArray == NULL) {

printf("Could not create class array for Proxy\n");

return NULL;

}

if(jobj == NULL) {

printf("Not a valid object to wrap\n");

return NULL;

}

jobj = env->CallStaticObjectMethod(proxyClass, proxy_newProxyInstance, classLoader, classArray, jobj);

assert(!env->ExceptionCheck());

}

return jobj;

jobject longValue = v8ToJava(env, obj->Get(v8::String::New("longValue")));

jclass longClazz = env->FindClass("java/lang/Long");

jmethodID long_constructor = env->GetMethodID(longClazz, "<init>", "(Ljava/lang/String;)V");

jobject jobj = env->NewObject(longClazz, long_constructor, longValue);

return jobj;

jclass clazz = env->FindClass("java/lang/Object");

jobjectArray results = env->NewObjectArray(end-start, clazz, NULL);

for(int i=start; i<end; i++) {

jobject val = v8ToJava(env, args[i]);

env->SetObjectArrayElement(results, i - start, val);

}

return results;

v8::HandleScope scope;

std::ostringstream msg;

msg << alternateMessage;

if(ex) {

jclass stringWriterClazz = env->FindClass("java/io/StringWriter");

jmethodID stringWriter_constructor = env->GetMethodID(stringWriterClazz, "<init>", "()V");

jmethodID stringWriter_toString = env->GetMethodID(stringWriterClazz, "toString", "()Ljava/lang/String;");

jobject stringWriter = env->NewObject(stringWriterClazz, stringWriter_constructor);

jclass printWriterClazz = env->FindClass("java/io/PrintWriter");

jmethodID printWriter_constructor = env->GetMethodID(printWriterClazz, "<init>", "(Ljava/io/Writer;)V");

jobject printWriter = env->NewObject(printWriterClazz, printWriter_constructor, stringWriter);

jclass throwableClazz = env->FindClass("java/lang/Throwable");

jmethodID throwable_printStackTrace = env->GetMethodID(throwableClazz, "printStackTrace", "(Ljava/io/PrintWriter;)V");

env->CallObjectMethod(ex, throwable_printStackTrace, printWriter);

assert(!env->ExceptionCheck());

jstring strObj = (jstring)env->CallObjectMethod(stringWriter, stringWriter_toString);

assert(!env->ExceptionCheck());

std::string stackTrace = javaToString(env, strObj);

msg << "\n" << stackTrace;

v8::Local<v8::Value> v8ex = v8::Exception::Error(v8::String::New(msg.str().c_str()));

((v8::Object*)*v8ex)->Set(v8::String::New("cause"), javaToV8(java, env, ex));

return scope.Close(v8ex);

}

return scope.Close(v8::Exception::Error(v8::String::New(msg.str().c_str())));

v8::HandleScope scope;

jthrowable ex = env->ExceptionOccurred();

env->ExceptionClear();

return scope.Close(javaExceptionToV8(java, env, ex, alternateMessage));

jclass objectClazz = env->FindClass("java/lang/Object");

jclass clazzclazz = env->FindClass("java/lang/Class");

jmethodID object_getClass = env->GetMethodID(objectClazz, "getClass", "()Ljava/lang/Class;");

jobject arrayClass = env->CallObjectMethod(array, object_getClass);

assert(!env->ExceptionCheck());

jmethodID class_getComponentType = env->GetMethodID(clazzclazz, "getComponentType", "()Ljava/lang/Class;");

jobject arrayComponentTypeClass = env->CallObjectMethod(arrayClass, class_getComponentType);

assert(!env->ExceptionCheck());

jvalueType arrayComponentType = javaGetType(env, (jclass)arrayComponentTypeClass);

return arrayComponentType;

v8::HandleScope scope;

if(objArray == NULL) {

return v8::Null();

}

jvalueType arrayComponentType = javaGetArrayComponentType(env, objArray);

//printf("javaArrayToV8: %d %s\n", arrayComponentType, javaObjectToString(env, objArray).c_str());

jsize arraySize = env->GetArrayLength(objArray);

//printf("array size: %d\n", arraySize);

v8::Handle<v8::Array> result = v8::Array::New(arraySize);

switch(arrayComponentType) {

case TYPE_INT:

{

jint* elems = env->GetIntArrayElements((jintArray)objArray, 0);

for(jsize i=0; i<arraySize; i++) {

result->Set(i, v8::Integer::New(elems[i]));

}

env->ReleaseIntArrayElements((jintArray)objArray, elems, 0);

}

break;

case TYPE_BYTE:

{

jbyte* elems = env->GetByteArrayElements((jbyteArray)objArray, 0);

for(jsize i=0; i<arraySize; i++) {

result->Set(i, v8::Number::New(elems[i]));

}

env->ReleaseByteArrayElements((jbyteArray)objArray, elems, 0);

}

break;

case TYPE_BOOLEAN:

{

jboolean* elems = env->GetBooleanArrayElements((jbooleanArray)objArray, 0);

for(jsize i=0; i<arraySize; i++) {

result->Set(i, v8::Boolean::New(elems[i]));

}

env->ReleaseBooleanArrayElements((jbooleanArray)objArray, elems, 0);

}

break;

case TYPE_SHORT:

{

jshort* elems = env->GetShortArrayElements((jshortArray)objArray, 0);

for(jsize i=0; i<arraySize; i++) {

result->Set(i, v8::Number::New(elems[i]));

}

env->ReleaseShortArrayElements((jshortArray)objArray, elems, 0);

}

break;

case TYPE_DOUBLE:

{

jdouble* elems = env->GetDoubleArrayElements((jdoubleArray)objArray, 0);

for(jsize i=0; i<arraySize; i++) {

result->Set(i, v8::Number::New(elems[i]));

}

env->ReleaseDoubleArrayElements((jdoubleArray)objArray, elems, 0);

}

break;

case TYPE_FLOAT:

{

jfloat* elems = env->GetFloatArrayElements((jfloatArray)objArray, 0);

for(jsize i=0; i<arraySize; i++) {

result->Set(i, v8::Number::New(elems[i]));

}

env->ReleaseFloatArrayElements((jfloatArray)objArray, elems, 0);

}

break;

case TYPE_LONG:

{

jlong* elems = env->GetLongArrayElements((jlongArray)objArray, 0);

for(jsize i=0; i<arraySize; i++) {

jobject obj = longToJavaLongObj(env, elems[i]);

result->Set(i, JavaObject::New(java, obj));

}

env->ReleaseLongArrayElements((jlongArray)objArray, elems, 0);

}

break;

default:

for(jsize i=0; i<arraySize; i++) {

jobject obj = env->GetObjectArrayElement(objArray, i);

v8::Handle<v8::Value> item = javaToV8(java, env, obj);

result->Set(i, item);

}

break;

}

return scope.Close(result);

v8::HandleScope scope;

if(obj == NULL) {

return v8::Null();

}

jclass objClazz = env->GetObjectClass(obj);

jvalueType resultType = javaGetType(env, objClazz);

//printf("javaToV8: %d %s\n", resultType, javaObjectToString(env, obj).c_str());

switch(resultType) {

case TYPE_ARRAY:

{

v8::Handle<v8::Value> result = javaArrayToV8(java, env, (jobjectArray)obj);

return scope.Close(result);

}

case TYPE_VOID:

return v8::Undefined();

case TYPE_BOOLEAN:

{

jclass booleanClazz = env->FindClass("java/lang/Boolean");

jmethodID boolean_booleanValue = env->GetMethodID(booleanClazz, "booleanValue", "()Z");

bool result = env->CallBooleanMethod(obj, boolean_booleanValue);

assert(!env->ExceptionCheck());

return scope.Close(v8::Boolean::New(result));

}

case TYPE_BYTE:

{

jclass byteClazz = env->FindClass("java/lang/Byte");

jmethodID byte_byteValue = env->GetMethodID(byteClazz, "byteValue", "()B");

jbyte result = env->CallByteMethod(obj, byte_byteValue);

assert(!env->ExceptionCheck());

return scope.Close(v8::Number::New(result));

}

case TYPE_LONG:

{

jclass longClazz = env->FindClass("java/lang/Long");

jmethodID long_longValue = env->GetMethodID(longClazz, "longValue", "()J");

jlong result = env->CallLongMethod(obj, long_longValue);

assert(!env->ExceptionCheck());

std::string strValue = javaObjectToString(env, obj);

v8::Local<v8::Value> v8Result = v8::NumberObject::New(result);

v8::NumberObject* v8ResultNumberObject = v8::NumberObject::Cast(*v8Result);

v8ResultNumberObject->Set(v8::String::New("longValue"), v8::String::New(strValue.c_str()));

v8ResultNumberObject->SetHiddenValue(v8::String::New(V8_HIDDEN_MARKER_JAVA_LONG), v8::Boolean::New(true));

return scope.Close(v8Result);

}

case TYPE_INT:

{

jclass integerClazz = env->FindClass("java/lang/Integer");

jmethodID integer_intValue = env->GetMethodID(integerClazz, "intValue", "()I");

jint result = env->CallIntMethod(obj, integer_intValue);

assert(!env->ExceptionCheck());

return scope.Close(v8::Integer::New(result));

}

case TYPE_SHORT:

{

jclass shortClazz = env->FindClass("java/lang/Short");

jmethodID short_shortValue = env->GetMethodID(shortClazz, "shortValue", "()S");

jshort result = env->CallShortMethod(obj, short_shortValue);

assert(!env->ExceptionCheck());

return scope.Close(v8::Integer::New(result));

}

case TYPE_DOUBLE:

{

jclass doubleClazz = env->FindClass("java/lang/Double");

jmethodID double_doubleValue = env->GetMethodID(doubleClazz, "doubleValue", "()D");

jdouble result = env->CallDoubleMethod(obj, double_doubleValue);

assert(!env->ExceptionCheck());

return scope.Close(v8::Number::New(result));

}

case TYPE_FLOAT:

{

jclass floatClazz = env->FindClass("java/lang/Float");

jmethodID float_floatValue = env->GetMethodID(floatClazz, "floatValue", "()F");

jfloat result = env->CallFloatMethod(obj, float_floatValue);

assert(!env->ExceptionCheck());

return scope.Close(v8::Number::New(result));

}

case TYPE_STRING:

return scope.Close(v8::String::New(javaObjectToString(env, obj).c_str()));

case TYPE_OBJECT:

return scope.Close(JavaObject::New(java, obj));

default:

printf("javaToV8: unhandled type: 0x%03x\n", resultType);

return scope.Close(JavaObject::New(java, obj));

}

return v8::Undefined();

jclass clazzClazz = env->FindClass("java/lang/Class");

jsize objsLength = env->GetArrayLength(objs);

jobjectArray results = env->NewObjectArray(objsLength, clazzClazz, NULL);

for(jsize i=0; i<objsLength; i++) {

jobject elem = env->GetObjectArrayElement(objs, i);

if(elem == NULL) {

env->SetObjectArrayElement(results, i, NULL);

} else {

jclass objClazz = env->GetObjectClass(elem);

env->SetObjectArrayElement(results, i, objClazz);

}

}

return results;

jclass methodUtilsClazz = env->FindClass("com/nearinfinity/org/apache/commons/lang3/reflect/MethodUtils");

jmethodID methodUtils_getMatchingAccessibleMethod = env->GetStaticMethodID(methodUtilsClazz, "getMatchingAccessibleMethod", "(Ljava/lang/Class;Ljava/lang/String;[Ljava/lang/Class;)Ljava/lang/reflect/Method;");

const char *methodNameCStr = methodName.c_str();

jstring methodNameJavaStr = env->NewStringUTF(methodNameCStr);

jobjectArray methodArgClasses = javaObjectArrayToClasses(env, methodArgs);

jobject method = env->CallStaticObjectMethod(methodUtilsClazz, methodUtils_getMatchingAccessibleMethod, clazz, methodNameJavaStr, methodArgClasses);

assert(!env->ExceptionCheck());

return method;

jclass constructorUtilsClazz = env->FindClass("com/nearinfinity/org/apache/commons/lang3/reflect/ConstructorUtils");

jmethodID constructorUtils_getMatchingAccessibleConstructor = env->GetStaticMethodID(constructorUtilsClazz, "getMatchingAccessibleConstructor", "(Ljava/lang/Class;[Ljava/lang/Class;)Ljava/lang/reflect/Constructor;");

jobjectArray methodArgClasses = javaObjectArrayToClasses(env, methodArgs);

jobject method = env->CallStaticObjectMethod(constructorUtilsClazz, constructorUtils_getMatchingAccessibleConstructor, clazz, methodArgClasses);

assert(!env->ExceptionCheck());

return method;

jclass longClass = env->FindClass("java/lang/Long");

jmethodID constructor = env->GetMethodID(longClass, "<init>", "(J)V");

jobject result = env->NewObject(longClass, constructor, val);

return result;

if(data->markerStart == DYNAMIC_PROXY_DATA_MARKER_START && data->markerEnd == DYNAMIC_PROXY_DATA_MARKER_END) {

return 1;

}

printf("*** ERROR: Lost reference to the dynamic proxy. You must maintain a reference in javascript land using ref() and unref(). ***\n");

return 0;

std::ostringstream startOfMessage;

std::ostringstream msg;

jclass classClazz = env->FindClass("java/lang/Class");

jmethodID class_getName = env->GetMethodID(classClazz, "getName", "()Ljava/lang/String;");

startOfMessage << "Could not find method \"" << methodName.c_str() << "(";

for(int i=argStart; i<argEnd; i++) {

jobject val = v8ToJava(env, args[i]);

if(i != argStart) {

startOfMessage << ", ";

}

if(val == NULL) {

startOfMessage << "(null)";

} else {

jclass argClass = env->GetObjectClass(val);

jstring argClassNameJava = (jstring)env->CallObjectMethod(argClass, class_getName);

assert(!env->ExceptionCheck());

std::string argClassName = javaToString(env, argClassNameJava);

startOfMessage << argClassName;

}

}

startOfMessage << ")\" on class \""<< javaObjectToString(env, clazz).c_str() << "\".";

msg << startOfMessage.str() << " Possible matches:\n";

jclass memberClazz = env->FindClass("java/lang/reflect/Member");

jmethodID member_getName = env->GetMethodID(memberClazz, "getName", "()Ljava/lang/String;");

std::list<jobject> methods;

if(constructor) {

javaReflectionGetConstructors(env, clazz, &methods);

} else {

javaReflectionGetMethods(env, clazz, &methods, true);

}

int count = 0;

for(std::list<jobject>::iterator it = methods.begin(); it != methods.end(); ++it) {

jstring methodNameTestJava = (jstring)env->CallObjectMethod(*it, member_getName);

assert(!env->ExceptionCheck());

std::string methodNameTest = javaToString(env, methodNameTestJava);

if(methodNameTest == methodName) {

msg << " " << javaObjectToString(env, *it).c_str() << "\n";

count++;

}

}

if(count == 0) {

std::ostringstream noMethodsMsg;

noMethodsMsg << startOfMessage.str() << " No methods with that name.";

return noMethodsMsg.str();

}

return msg.str();