Reviewed by Jon.
authorandersca@apple.com <andersca@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 7 Mar 2008 01:55:18 +0000 (01:55 +0000)
committerandersca@apple.com <andersca@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 7 Mar 2008 01:55:18 +0000 (01:55 +0000)
        Templatize the JNI call code to reduce the amount of code that has
        to be duplicated.

        * bridge/jni/jni_class.cpp:
        (JavaClass::JavaClass):
        * bridge/jni/jni_instance.cpp:
        (JavaInstance::stringValue):
        (JavaInstance::numberValue):
        (JavaInstance::booleanValue):
        (JavaInstance::invokeMethod):
        * bridge/jni/jni_jsobject.cpp:
        (JavaJSObject::convertJObjectToValue):
        * bridge/jni/jni_runtime.cpp:
        (JavaField::JavaField):
        (JavaMethod::JavaMethod):
        * bridge/jni/jni_utility.cpp:
        * bridge/jni/jni_utility.h:
        (KJS::Bindings::):
        (KJS::Bindings::callJNIMethodIDA):
        (KJS::Bindings::callJNIMethodV):
        (KJS::Bindings::callJNIMethod):
        (KJS::Bindings::callJNIStaticMethod):

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@30868 268f45cc-cd09-0410-ab3c-d52691b4dbfc

WebCore/ChangeLog
WebCore/bridge/jni/jni_class.cpp
WebCore/bridge/jni/jni_instance.cpp
WebCore/bridge/jni/jni_jsobject.cpp
WebCore/bridge/jni/jni_runtime.cpp
WebCore/bridge/jni/jni_utility.cpp
WebCore/bridge/jni/jni_utility.h

index d1c984812b16a8590e01a7f54865e2877e72d844..3d4d4c8e7fe98b370d00c2dbfe672f8f64be7b38 100644 (file)
@@ -1,3 +1,30 @@
+2008-03-06  Anders Carlsson  <andersca@apple.com>
+
+        Reviewed by Jon.
+
+        Templatize the JNI call code to reduce the amount of code that has
+        to be duplicated.
+
+        * bridge/jni/jni_class.cpp:
+        (JavaClass::JavaClass):
+        * bridge/jni/jni_instance.cpp:
+        (JavaInstance::stringValue):
+        (JavaInstance::numberValue):
+        (JavaInstance::booleanValue):
+        (JavaInstance::invokeMethod):
+        * bridge/jni/jni_jsobject.cpp:
+        (JavaJSObject::convertJObjectToValue):
+        * bridge/jni/jni_runtime.cpp:
+        (JavaField::JavaField):
+        (JavaMethod::JavaMethod):
+        * bridge/jni/jni_utility.cpp:
+        * bridge/jni/jni_utility.h:
+        (KJS::Bindings::):
+        (KJS::Bindings::callJNIMethodIDA):
+        (KJS::Bindings::callJNIMethodV):
+        (KJS::Bindings::callJNIMethod):
+        (KJS::Bindings::callJNIStaticMethod):
+
 2008-03-06  Darin Adler  <darin@apple.com>
 
         Reviewed by Mitz.
index 9a7f27457c3b5c5300ec1f9f54b669baf2626607..23750e79fdcaf272c747ee949797f42fdffbbb36 100644 (file)
@@ -33,14 +33,14 @@ using namespace KJS::Bindings;
 
 JavaClass::JavaClass(jobject anInstance)
 {
-    jobject aClass = callJNIObjectMethod(anInstance, "getClass", "()Ljava/lang/Class;");
+    jobject aClass = callJNIMethod<jobject>(anInstance, "getClass", "()Ljava/lang/Class;");
     
     if (!aClass) {
         fprintf(stderr, "%s:  unable to call getClass on instance %p\n", __PRETTY_FUNCTION__, anInstance);
         return;
     }
     
-    jstring className = (jstring)callJNIObjectMethod(aClass, "getName", "()Ljava/lang/String;");
+    jstring className = (jstring)callJNIMethod<jobject>(aClass, "getName", "()Ljava/lang/String;");
     const char *classNameC = getCharactersFromJString(className);
     _name = strdup(classNameC);
     releaseCharactersForJString(className, classNameC);
@@ -49,7 +49,7 @@ JavaClass::JavaClass(jobject anInstance)
     JNIEnv *env = getJNIEnv();
     
     // Get the fields
-    jarray fields = (jarray)callJNIObjectMethod(aClass, "getFields", "()[Ljava/lang/reflect/Field;");
+    jarray fields = (jarray)callJNIMethod<jobject>(aClass, "getFields", "()[Ljava/lang/reflect/Field;");
     int numFields = env->GetArrayLength(fields);    
     for (i = 0; i < numFields; i++) {
         jobject aJField = env->GetObjectArrayElement((jobjectArray)fields, i);
@@ -62,7 +62,7 @@ JavaClass::JavaClass(jobject anInstance)
     }
     
     // Get the methods
-    jarray methods = (jarray)callJNIObjectMethod(aClass, "getMethods", "()[Ljava/lang/reflect/Method;");
+    jarray methods = (jarray)callJNIMethod<jobject>(aClass, "getMethods", "()[Ljava/lang/reflect/Method;");
     int numMethods = env->GetArrayLength(methods);
     for (i = 0; i < numMethods; i++) {
         jobject aJMethod = env->GetObjectArrayElement((jobjectArray)methods, i);
index d5d89aa687f3c8d6bc4e699643fa9876ad485262..bdfb6ecdf0c56c67887dcbba39e20f3e8f96856f 100644 (file)
@@ -78,7 +78,7 @@ JSValue *JavaInstance::stringValue() const
 {
     JSLock lock;
     
-    jstring stringValue = (jstring)callJNIObjectMethod (_instance->_instance, "toString", "()Ljava/lang/String;");
+    jstring stringValue = (jstring)callJNIMethod<jobject>(_instance->_instance, "toString", "()Ljava/lang/String;");
     JNIEnv *env = getJNIEnv();
     const jchar *c = getUCharactersFromJStringInEnv(env, stringValue);
     UString u((const UChar *)c, (int)env->GetStringLength(stringValue));
@@ -88,13 +88,13 @@ JSValue *JavaInstance::stringValue() const
 
 JSValue *JavaInstance::numberValue() const
 {
-    jdouble doubleValue = callJNIDoubleMethod (_instance->_instance, "doubleValue", "()D");
+    jdouble doubleValue = callJNIMethod<jdouble>(_instance->_instance, "doubleValue", "()D");
     return jsNumber(doubleValue);
 }
 
 JSValue *JavaInstance::booleanValue() const
 {
-    jboolean booleanValue = callJNIBooleanMethod (_instance->_instance, "booleanValue", "()Z");
+    jboolean booleanValue = callJNIMethod<jboolean>(_instance->_instance, "booleanValue", "()Z");
     return jsBoolean(booleanValue);
 }
 
@@ -166,60 +166,40 @@ JSValue *JavaInstance::invokeMethod (ExecState *exec, const MethodList &methodLi
     if (!handled) {    
         jobject obj = _instance->_instance;
         switch (jMethod->JNIReturnType()){
-            case void_type: {
-                callJNIVoidMethodIDA (obj, jMethod->methodID(obj), jArgs);
-            }
-            break;
-            
-            case object_type: {
-                result.l = callJNIObjectMethodIDA (obj, jMethod->methodID(obj), jArgs);
-            }
-            break;
-            
-            case boolean_type: {
-                result.z = callJNIBooleanMethodIDA (obj, jMethod->methodID(obj), jArgs);
-            }
-            break;
+            case void_type:
+                callJNIMethodIDA<void>(obj, jMethod->methodID(obj), jArgs);
+                break;            
+            case object_type:
+                result.l = callJNIMethodIDA<jobject>(obj, jMethod->methodID(obj), jArgs);
+                break;
+            case boolean_type:
+                result.z = callJNIMethodIDA<jboolean>(obj, jMethod->methodID(obj), jArgs);
+                break;
+            case byte_type:
+                result.b = callJNIMethodIDA<jbyte>(obj, jMethod->methodID(obj), jArgs);
+                break;
+            case char_type:
+                result.c = callJNIMethodIDA<jchar>(obj, jMethod->methodID(obj), jArgs);
+                break;            
+            case short_type:
+                result.s = callJNIMethodIDA<jshort>(obj, jMethod->methodID(obj), jArgs);
+                break;
+            case int_type:
+                result.i = callJNIMethodIDA<jint>(obj, jMethod->methodID(obj), jArgs);
+                break;
             
-            case byte_type: {
-                result.b = callJNIByteMethodIDA (obj, jMethod->methodID(obj), jArgs);
-            }
-            break;
-            
-            case char_type: {
-                result.c = callJNICharMethodIDA (obj, jMethod->methodID(obj), jArgs);
-            }
-            break;
-            
-            case short_type: {
-                result.s = callJNIShortMethodIDA (obj, jMethod->methodID(obj), jArgs);
-            }
-            break;
-            
-            case int_type: {
-                result.i = callJNIIntMethodIDA (obj, jMethod->methodID(obj), jArgs);
-            }
-            break;
-            
-            case long_type: {
-                result.j = callJNILongMethodIDA (obj, jMethod->methodID(obj), jArgs);
-            }
-            break;
-            
-            case float_type: {
-                result.f = callJNIFloatMethodIDA (obj, jMethod->methodID(obj), jArgs);
-            }
-            break;
-            
-            case double_type: {
-                result.d = callJNIDoubleMethodIDA (obj, jMethod->methodID(obj), jArgs);
-            }
-            break;
-
+            case long_type:
+                result.j = callJNIMethodIDA<jlong>(obj, jMethod->methodID(obj), jArgs);
+                break;
+            case float_type:
+                result.f = callJNIMethodIDA<jfloat>(obj, jMethod->methodID(obj), jArgs);
+                break;
+            case double_type:
+                result.d = callJNIMethodIDA<jdouble>(obj, jMethod->methodID(obj), jArgs);
+                break;
             case invalid_type:
-            default: {
-            }
-            break;
+            default:
+                break;
         }
     }
         
index 3f19aad83db82e58386f7379f3a0da36d03df80a..3ced4a7c5c2f10f1c6f9d57ec002483157c6b01b 100644 (file)
@@ -572,8 +572,8 @@ JSValue *JavaJSObject::convertJObjectToValue (jobject theObject) const
     // possible to pass primitive types from the Java to JavaScript.
     // See section 22.7 of 'JavaScript:  The Definitive Guide, 4th Edition',
     // figure 22-4.
-    jobject classOfInstance = callJNIObjectMethod(theObject, "getClass", "()Ljava/lang/Class;");
-    jstring className = (jstring)callJNIObjectMethod(classOfInstance, "getName", "()Ljava/lang/String;");
+    jobject classOfInstance = callJNIMethod<jobject>(theObject, "getClass", "()Ljava/lang/Class;");
+    jstring className = (jstring)callJNIMethod<jobject>(classOfInstance, "getName", "()Ljava/lang/String;");
     
     // Only the sun.plugin.javascript.webkit.JSObject has a member called nativeJSObject. This class is
     // created above to wrap internal browser objects. The constructor of this class takes the native
index d7c8659cadaf92fb11199b900078b60b8ce4e754..671fd35ab288f5404c704f50814f5cc1492427b3 100644 (file)
@@ -53,13 +53,13 @@ JavaParameter::JavaParameter (JNIEnv *env, jstring type)
 JavaField::JavaField (JNIEnv *env, jobject aField)
 {
     // Get field type
-    jobject fieldType = callJNIObjectMethod (aField, "getType", "()Ljava/lang/Class;");
-    jstring fieldTypeName = (jstring)callJNIObjectMethod (fieldType, "getName", "()Ljava/lang/String;");
+    jobject fieldType = callJNIMethod<jobject>(aField, "getType", "()Ljava/lang/Class;");
+    jstring fieldTypeName = (jstring)callJNIMethod<jobject>(fieldType, "getName", "()Ljava/lang/String;");
     _type = JavaString(env, fieldTypeName);
     _JNIType = JNITypeFromClassName (_type.UTF8String());
 
     // Get field name
-    jstring fieldName = (jstring)callJNIObjectMethod (aField, "getName", "()Ljava/lang/String;");
+    jstring fieldName = (jstring)callJNIMethod<jobject>(aField, "getName", "()Ljava/lang/String;");
     _name = JavaString(env, fieldName);
 
     _field = new JObjectWrapper(aField);
@@ -245,27 +245,27 @@ void JavaField::setValueToInstance(ExecState *exec, const Instance *i, JSValue *
 JavaMethod::JavaMethod (JNIEnv *env, jobject aMethod)
 {
     // Get return type
-    jobject returnType = callJNIObjectMethod (aMethod, "getReturnType", "()Ljava/lang/Class;");
-    jstring returnTypeName = (jstring)callJNIObjectMethod (returnType, "getName", "()Ljava/lang/String;");
+    jobject returnType = callJNIMethod<jobject>(aMethod, "getReturnType", "()Ljava/lang/Class;");
+    jstring returnTypeName = (jstring)callJNIMethod<jobject>(returnType, "getName", "()Ljava/lang/String;");
     _returnType =JavaString (env, returnTypeName);
     _JNIReturnType = JNITypeFromClassName (_returnType.UTF8String());
     env->DeleteLocalRef (returnType);
     env->DeleteLocalRef (returnTypeName);
 
     // Get method name
-    jstring methodName = (jstring)callJNIObjectMethod (aMethod, "getName", "()Ljava/lang/String;");
+    jstring methodName = (jstring)callJNIMethod<jobject>(aMethod, "getName", "()Ljava/lang/String;");
     _name = JavaString (env, methodName);
     env->DeleteLocalRef (methodName);
 
     // Get parameters
-    jarray jparameters = (jarray)callJNIObjectMethod (aMethod, "getParameterTypes", "()[Ljava/lang/Class;");
+    jarray jparameters = (jarray)callJNIMethod<jobject>(aMethod, "getParameterTypes", "()[Ljava/lang/Class;");
     _numParameters = env->GetArrayLength (jparameters);
     _parameters = new JavaParameter[_numParameters];
     
     int i;
     for (i = 0; i < _numParameters; i++) {
         jobject aParameter = env->GetObjectArrayElement ((jobjectArray)jparameters, i);
-        jstring parameterName = (jstring)callJNIObjectMethod (aParameter, "getName", "()Ljava/lang/String;");
+        jstring parameterName = (jstring)callJNIMethod<jobject>(aParameter, "getName", "()Ljava/lang/String;");
         _parameters[i] = JavaParameter(env, parameterName);
         env->DeleteLocalRef (aParameter);
         env->DeleteLocalRef (parameterName);
@@ -277,8 +277,8 @@ JavaMethod::JavaMethod (JNIEnv *env, jobject aMethod)
     _methodID = 0;
     
     jclass modifierClass = env->FindClass("java/lang/reflect/Modifier");
-    int modifiers = callJNIIntMethod (aMethod, "getModifiers", "()I");
-    _isStatic = (bool)callJNIStaticBooleanMethod (modifierClass, "isStatic", "(I)Z", modifiers);
+    int modifiers = callJNIMethod<jint>(aMethod, "getModifiers", "()I");
+    _isStatic = (bool)callJNIStaticMethod<jboolean>(modifierClass, "isStatic", "(I)Z", modifiers);
 }
 
 JavaMethod::~JavaMethod() 
index 1898a931628ec06ea826f94fa788626786fdc4a7..e8d599b411f10406b710441eaa4d0ae19bf6b839 100644 (file)
@@ -100,211 +100,6 @@ JNIEnv* getJNIEnv()
     return NULL;
 }
 
-static jvalue callJNIMethod (JNIType type, jobject obj, const char *name, const char *sig, va_list args)
-{
-    JavaVM *jvm = getJavaVM();
-    JNIEnv *env = getJNIEnv();
-    jvalue result;
-
-    bzero (&result, sizeof(jvalue));
-    if ( obj != NULL && jvm != NULL && env != NULL) {
-        jclass cls = env->GetObjectClass(obj);
-        if ( cls != NULL ) {
-            jmethodID mid = env->GetMethodID(cls, name, sig);
-            if ( mid != NULL )
-            {
-                switch (type) {
-                case void_type:
-                    env->functions->CallVoidMethodV(env, obj, mid, args);
-                    break;
-                case array_type:
-                case object_type:
-                    result.l = env->functions->CallObjectMethodV(env, obj, mid, args);
-                    break;
-                case boolean_type:
-                    result.z = env->functions->CallBooleanMethodV(env, obj, mid, args);
-                    break;
-                case byte_type:
-                    result.b = env->functions->CallByteMethodV(env, obj, mid, args);
-                    break;
-                case char_type:
-                    result.c = env->functions->CallCharMethodV(env, obj, mid, args);
-                    break;
-                case short_type:
-                    result.s = env->functions->CallShortMethodV(env, obj, mid, args);
-                    break;
-                case int_type:
-                    result.i = env->functions->CallIntMethodV(env, obj, mid, args);
-                    break;
-                case long_type:
-                    result.j = env->functions->CallLongMethodV(env, obj, mid, args);
-                    break;
-                case float_type:
-                    result.f = env->functions->CallFloatMethodV(env, obj, mid, args);
-                    break;
-                case double_type:
-                    result.d = env->functions->CallDoubleMethodV(env, obj, mid, args);
-                    break;
-                default:
-                    fprintf(stderr, "%s: invalid function type (%d)\n", __PRETTY_FUNCTION__, (int)type);
-                }
-            }
-            else
-            {
-                fprintf(stderr, "%s: Could not find method: %s for %p\n", __PRETTY_FUNCTION__, name, obj);
-                env->ExceptionDescribe();
-                env->ExceptionClear();
-                fprintf (stderr, "\n");
-            }
-
-            env->DeleteLocalRef(cls);
-        }
-        else {
-            fprintf(stderr, "%s: Could not find class for %p\n", __PRETTY_FUNCTION__, obj);
-        }
-    }
-
-    return result;
-}
-
-static jvalue callJNIStaticMethod (JNIType type, jclass cls, const char *name, const char *sig, va_list args)
-{
-    JavaVM *jvm = getJavaVM();
-    JNIEnv *env = getJNIEnv();
-    jvalue result;
-
-    bzero (&result, sizeof(jvalue));
-    if ( cls != NULL && jvm != NULL && env != NULL) {
-        jmethodID mid = env->GetStaticMethodID(cls, name, sig);
-        if ( mid != NULL )
-        {
-            switch (type) {
-            case void_type:
-                env->functions->CallStaticVoidMethodV(env, cls, mid, args);
-                break;
-            case array_type:
-            case object_type:
-                result.l = env->functions->CallStaticObjectMethodV(env, cls, mid, args);
-                break;
-            case boolean_type:
-                result.z = env->functions->CallStaticBooleanMethodV(env, cls, mid, args);
-                break;
-            case byte_type:
-                result.b = env->functions->CallStaticByteMethodV(env, cls, mid, args);
-                break;
-            case char_type:
-                result.c = env->functions->CallStaticCharMethodV(env, cls, mid, args);
-                break;
-            case short_type:
-                result.s = env->functions->CallStaticShortMethodV(env, cls, mid, args);
-                break;
-            case int_type:
-                result.i = env->functions->CallStaticIntMethodV(env, cls, mid, args);
-                break;
-            case long_type:
-                result.j = env->functions->CallStaticLongMethodV(env, cls, mid, args);
-                break;
-            case float_type:
-                result.f = env->functions->CallStaticFloatMethodV(env, cls, mid, args);
-                break;
-            case double_type:
-                result.d = env->functions->CallStaticDoubleMethodV(env, cls, mid, args);
-                break;
-            default:
-                fprintf(stderr, "%s: invalid function type (%d)\n", __PRETTY_FUNCTION__, (int)type);
-            }
-        }
-        else
-        {
-            fprintf(stderr, "%s: Could not find method: %s for %p\n", __PRETTY_FUNCTION__, name, cls);
-            env->ExceptionDescribe();
-            env->ExceptionClear();
-            fprintf (stderr, "\n");
-        }
-    }
-
-    return result;
-}
-
-static jvalue callJNIMethodIDA (JNIType type, jobject obj, jmethodID mid, jvalue *args)
-{
-    JNIEnv *env = getJNIEnv();
-    jvalue result;
-    
-    bzero (&result, sizeof(jvalue));
-    if ( obj != NULL && mid != NULL )
-    {
-        switch (type) {
-        case void_type:
-            env->functions->CallVoidMethodA(env, obj, mid, args);
-            break;
-        case array_type:
-        case object_type:
-            result.l = env->functions->CallObjectMethodA(env, obj, mid, args);
-            break;
-        case boolean_type:
-            result.z = env->functions->CallBooleanMethodA(env, obj, mid, args);
-            break;
-        case byte_type:
-            result.b = env->functions->CallByteMethodA(env, obj, mid, args);
-            break;
-        case char_type:
-            result.c = env->functions->CallCharMethodA(env, obj, mid, args);
-            break;
-        case short_type:
-            result.s = env->functions->CallShortMethodA(env, obj, mid, args);
-            break;
-        case int_type:
-            result.i = env->functions->CallIntMethodA(env, obj, mid, args);
-            break;
-        case long_type:
-            result.j = env->functions->CallLongMethodA(env, obj, mid, args);
-            break;
-        case float_type:
-            result.f = env->functions->CallFloatMethodA(env, obj, mid, args);
-            break;
-        case double_type:
-            result.d = env->functions->CallDoubleMethodA(env, obj, mid, args);
-            break;
-        default:
-            fprintf(stderr, "%s: invalid function type (%d)\n", __PRETTY_FUNCTION__, (int)type);
-        }
-    }
-
-    return result;
-}
-
-static jvalue callJNIMethodA (JNIType type, jobject obj, const char *name, const char *sig, jvalue *args)
-{
-    JavaVM *jvm = getJavaVM();
-    JNIEnv *env = getJNIEnv();
-    jvalue result;
-    
-    bzero (&result, sizeof(jvalue));
-    if ( obj != NULL && jvm != NULL && env != NULL) {
-        jclass cls = env->GetObjectClass(obj);
-        if ( cls != NULL ) {
-            jmethodID mid = env->GetMethodID(cls, name, sig);
-            if ( mid != NULL ) {
-                result = callJNIMethodIDA (type, obj, mid, args);
-            }
-            else {
-                fprintf(stderr, "%s: Could not find method: %s\n", __PRETTY_FUNCTION__, name);
-                env->ExceptionDescribe();
-                env->ExceptionClear();
-                fprintf (stderr, "\n");
-            }
-
-            env->DeleteLocalRef(cls);
-        }
-        else {
-            fprintf(stderr, "%s: Could not find class for object\n", __PRETTY_FUNCTION__);
-        }
-    }
-
-    return result;
-}
-
 jmethodID getMethodID (jobject obj, const char *name, const char *sig)
 {
     JNIEnv *env = getJNIEnv();
@@ -327,206 +122,6 @@ jmethodID getMethodID (jobject obj, const char *name, const char *sig)
     return mid;
 }
 
-
-#define CALL_JNI_METHOD(function_type,obj,name,sig) \
-    va_list args;\
-    va_start (args, sig);\
-    \
-    jvalue result = callJNIMethod(function_type, obj, name, sig, args);\
-    \
-    va_end (args);
-
-#define CALL_JNI_STATIC_METHOD(function_type,cls,name,sig) \
-    va_list args;\
-    va_start (args, sig);\
-    \
-    jvalue result = callJNIStaticMethod(function_type, cls, name, sig, args);\
-    \
-    va_end (args);
-
-void callJNIVoidMethod (jobject obj, const char *name, const char *sig, ... )
-{
-    CALL_JNI_METHOD (void_type, obj, name, sig);
-}
-
-jobject callJNIObjectMethod (jobject obj, const char *name, const char *sig, ... )
-{
-    CALL_JNI_METHOD (object_type, obj, name, sig);
-    return result.l;
-}
-
-jboolean callJNIBooleanMethod( jobject obj, const char *name, const char *sig, ... )
-{
-    CALL_JNI_METHOD (boolean_type, obj, name, sig);
-    return result.z;
-}
-
-jboolean callJNIStaticBooleanMethod (jclass cls, const char *name, const char *sig, ... )
-{
-    CALL_JNI_STATIC_METHOD (boolean_type, cls, name, sig);
-    return result.z;
-}
-
-jbyte callJNIByteMethod( jobject obj, const char *name, const char *sig, ... )
-{
-    CALL_JNI_METHOD (byte_type, obj, name, sig);
-    return result.b;
-}
-
-jchar callJNICharMethod (jobject obj, const char *name, const char *sig, ... )
-{
-    CALL_JNI_METHOD (char_type, obj, name, sig);
-    return result.c;
-}
-
-jshort callJNIShortMethod (jobject obj, const char *name, const char *sig, ... )
-{
-    CALL_JNI_METHOD (short_type, obj, name, sig);
-    return result.s;
-}
-
-jint callJNIIntMethod (jobject obj, const char *name, const char *sig, ... )
-{
-    CALL_JNI_METHOD (int_type, obj, name, sig);
-    return result.i;
-}
-
-jlong callJNILongMethod (jobject obj, const char *name, const char *sig, ... )
-{
-    CALL_JNI_METHOD (long_type, obj, name, sig);
-    return result.j;
-}
-
-jfloat callJNIFloatMethod (jobject obj, const char *name, const char *sig, ... )
-{
-    CALL_JNI_METHOD (float_type, obj, name, sig);
-    return result.f;
-}
-
-jdouble callJNIDoubleMethod (jobject obj, const char *name, const char *sig, ... )
-{
-    CALL_JNI_METHOD (double_type, obj, name, sig);
-    return result.d;
-}
-
-void callJNIVoidMethodA (jobject obj, const char *name, const char *sig, jvalue *args)
-{
-    jvalue result = callJNIMethodA (void_type, obj, name, sig, args);
-}
-
-jobject callJNIObjectMethodA (jobject obj, const char *name, const char *sig, jvalue *args)
-{
-    jvalue result = callJNIMethodA (object_type, obj, name, sig, args);
-    return result.l;
-}
-
-jbyte callJNIByteMethodA ( jobject obj, const char *name, const char *sig, jvalue *args)
-{
-    jvalue result = callJNIMethodA (byte_type, obj, name, sig, args);
-    return result.b;
-}
-
-jchar callJNICharMethodA (jobject obj, const char *name, const char *sig, jvalue *args)
-{
-    jvalue result = callJNIMethodA (char_type, obj, name, sig, args);
-    return result.c;
-}
-
-jshort callJNIShortMethodA (jobject obj, const char *name, const char *sig, jvalue *args)
-{
-    jvalue result = callJNIMethodA (short_type, obj, name, sig, args);
-    return result.s;
-}
-
-jint callJNIIntMethodA (jobject obj, const char *name, const char *sig, jvalue *args)
-{
-    jvalue result = callJNIMethodA (int_type, obj, name, sig, args);
-    return result.i;
-}
-
-jlong callJNILongMethodA (jobject obj, const char *name, const char *sig, jvalue *args)
-{
-    jvalue result = callJNIMethodA (long_type, obj, name, sig, args);
-    return result.j;
-}
-
-jfloat callJNIFloatMethodA (jobject obj, const char *name, const char *sig, jvalue *args)
-{
-    jvalue result = callJNIMethodA  (float_type, obj, name, sig, args);
-    return result.f;
-}
-
-jdouble callJNIDoubleMethodA (jobject obj, const char *name, const char *sig, jvalue *args)
-{
-    jvalue result = callJNIMethodA (double_type, obj, name, sig, args);
-    return result.d;
-}
-
-jboolean callJNIBooleanMethodA (jobject obj, const char *name, const char *sig, jvalue *args)
-{
-    jvalue result = callJNIMethodA (boolean_type, obj, name, sig, args);
-    return result.z;
-}
-
-void callJNIVoidMethodIDA (jobject obj, jmethodID methodID, jvalue *args)
-{
-    jvalue result = callJNIMethodIDA (void_type, obj, methodID, args);
-}
-
-jobject callJNIObjectMethodIDA (jobject obj, jmethodID methodID, jvalue *args)
-{
-    jvalue result = callJNIMethodIDA (object_type, obj, methodID, args);
-    return result.l;
-}
-
-jbyte callJNIByteMethodIDA ( jobject obj, jmethodID methodID, jvalue *args)
-{
-    jvalue result = callJNIMethodIDA (byte_type, obj, methodID, args);
-    return result.b;
-}
-
-jchar callJNICharMethodIDA (jobject obj, jmethodID methodID, jvalue *args)
-{
-    jvalue result = callJNIMethodIDA (char_type, obj, methodID, args);
-    return result.c;
-}
-
-jshort callJNIShortMethodIDA (jobject obj, jmethodID methodID, jvalue *args)
-{
-    jvalue result = callJNIMethodIDA (short_type, obj, methodID, args);
-    return result.s;
-}
-
-jint callJNIIntMethodIDA (jobject obj, jmethodID methodID, jvalue *args)
-{
-    jvalue result = callJNIMethodIDA (int_type, obj, methodID, args);
-    return result.i;
-}
-
-jlong callJNILongMethodIDA (jobject obj, jmethodID methodID, jvalue *args)
-{
-    jvalue result = callJNIMethodIDA (long_type, obj, methodID, args);
-    return result.j;
-}
-
-jfloat callJNIFloatMethodIDA (jobject obj, jmethodID methodID, jvalue *args)
-{
-    jvalue result = callJNIMethodIDA  (float_type, obj, methodID, args);
-    return result.f;
-}
-
-jdouble callJNIDoubleMethodIDA (jobject obj, jmethodID methodID, jvalue *args)
-{
-    jvalue result = callJNIMethodIDA (double_type, obj, methodID, args);
-    return result.d;
-}
-
-jboolean callJNIBooleanMethodIDA (jobject obj, jmethodID methodID, jvalue *args)
-{
-    jvalue result = callJNIMethodIDA (boolean_type, obj, methodID, args);
-    return result.z;
-}
-
 const char *getCharactersFromJString (jstring aJString)
 {
     return getCharactersFromJStringInEnv (getJNIEnv(), aJString);
index 3eb9282eb15407a3f48d65090724f7ae393d08db..6807e3f7144c6fccb6db20674592c489740c9487 100644 (file)
@@ -74,45 +74,206 @@ jvalue convertValueToJValue(ExecState *exec, JSValue *value, JNIType _JNIType, c
 jvalue getJNIField(jobject obj, JNIType type, const char *name, const char *signature);
 
 jmethodID getMethodID(jobject obj, const char *name, const char *sig);
+JNIEnv* getJNIEnv();
+JavaVM* getJavaVM();
+void setJavaVM(JavaVM*);
+    
+    
+template <typename T> struct JNICaller;
 
-jobject callJNIObjectMethod(jobject obj, const char *name, const char *sig, ... );
-void callJNIVoidMethod(jobject obj, const char *name, const char *sig, ... );
-jboolean callJNIBooleanMethod(jobject obj, const char *name, const char *sig, ... );
-jboolean callJNIStaticBooleanMethod(jclass cls, const char *name, const char *sig, ... );
-jbyte callJNIByteMethod(jobject obj, const char *name, const char *sig, ... );
-jchar callJNICharMethod(jobject obj, const char *name, const char *sig, ... );
-jshort callJNIShortMethod(jobject obj, const char *name, const char *sig, ... );
-jint callJNIIntMethod(jobject obj, const char *name, const char *sig, ... );
-jlong callJNILongMethod(jobject obj, const char *name, const char *sig, ... );
-jfloat callJNIFloatMethod(jobject obj, const char *name, const char *sig, ... );
-jdouble callJNIDoubleMethod(jobject obj, const char *name, const char *sig, ... );
-
-jobject callJNIObjectMethodA(jobject obj, const char *name, const char *sig, jvalue *args);
-void callJNIVoidMethodA(jobject obj, const char *name, const char *sig, jvalue *args);
-jboolean callJNIBooleanMethodA(jobject obj, const char *name, const char *sig, jvalue *args);
-jbyte callJNIByteMethodA(jobject obj, const char *name, const char *sig, jvalue *args);
-jchar callJNICharMethodA(jobject obj, const char *name, const char *sig, jvalue *args);
-jshort callJNIShortMethodA(jobject obj, const char *name, const char *sig, jvalue *args);
-jint callJNIIntMethodA(jobject obj, const char *name, const char *sig, jvalue *args);
-jlong callJNILongMethodA(jobject obj, const char *name, const char *sig, jvalue *args);
-jfloat callJNIFloatMethodA(jobject obj, const char *name, const char *sig, jvalue *args);
-jdouble callJNIDoubleMethodA(jobject obj, const char *name, const char *sig, jvalue *args);
-
-jobject callJNIObjectMethodIDA(jobject obj, jmethodID methodID, jvalue *args);
-void callJNIVoidMethodIDA(jobject obj, jmethodID methodID, jvalue *args);
-jboolean callJNIBooleanMethodIDA(jobject obj, jmethodID methodID, jvalue *args);
-jbyte callJNIByteMethodIDA(jobject obj, jmethodID methodID, jvalue *args);
-jchar callJNICharMethodIDA(jobject obj, jmethodID methodID, jvalue *args);
-jshort callJNIShortMethodIDA(jobject obj, jmethodID methodID, jvalue *args);
-jint callJNIIntMethodIDA(jobject obj, jmethodID methodID, jvalue *args);
-jlong callJNILongMethodIDA(jobject obj, jmethodID methodID, jvalue *args);
-jfloat callJNIFloatMethodIDA(jobject obj, jmethodID methodID, jvalue *args);
-jdouble callJNIDoubleMethodIDA(jobject obj, jmethodID methodID, jvalue *args);
-
-JavaVM *getJavaVM();
-void    setJavaVM(JavaVM *javaVM);
-JNIEnv *getJNIEnv();
+template<> struct JNICaller<void> {
+    static void callA(jobject obj, jmethodID mid, jvalue* args)
+    {
+        return getJNIEnv()->CallVoidMethodA(obj, mid, args);
+    }
+    static void callV(jobject obj, jmethodID mid, va_list args)
+    {
+        return getJNIEnv()->CallVoidMethodV(obj, mid, args);
+    }
+};
 
+template<> struct JNICaller<jobject> {
+    static jobject callA(jobject obj, jmethodID mid, jvalue* args)
+    {
+        return getJNIEnv()->CallObjectMethodA(obj, mid, args);
+    }
+    static jobject callV(jobject obj, jmethodID mid, va_list args)
+    {
+        return getJNIEnv()->CallObjectMethodV(obj, mid, args);
+    }    
+};
+
+template<> struct JNICaller<jboolean> {
+    static jboolean callA(jobject obj, jmethodID mid, jvalue* args)
+    {
+        return getJNIEnv()->CallBooleanMethodA(obj, mid, args);
+    }
+    static jboolean callV(jobject obj, jmethodID mid, va_list args)
+    {
+        return getJNIEnv()->CallBooleanMethodV(obj, mid, args);
+    }
+    static jboolean callStaticV(jclass cls, jmethodID mid, va_list args)
+    {
+        return getJNIEnv()->CallStaticBooleanMethod(cls, mid, args);
+    }
+    
+};
+
+template<> struct JNICaller<jbyte> {
+    static jbyte callA(jobject obj, jmethodID mid, jvalue* args)
+    {
+        return getJNIEnv()->CallByteMethodA(obj, mid, args);
+    }
+    static jbyte callV(jobject obj, jmethodID mid, va_list args)
+    {
+        return getJNIEnv()->CallByteMethodV(obj, mid, args);
+    }
+};
+
+template<> struct JNICaller<jchar> {
+    static jchar callA(jobject obj, jmethodID mid, jvalue* args)
+    {
+        return getJNIEnv()->CallCharMethodA(obj, mid, args);
+    }
+    static jchar callV(jobject obj, jmethodID mid, va_list args)
+    {
+        return getJNIEnv()->CallCharMethodV(obj, mid, args);
+    }    
+};
+
+template<> struct JNICaller<jshort> {
+    static jshort callA(jobject obj, jmethodID mid, jvalue* args)
+    {
+        return getJNIEnv()->CallShortMethodA(obj, mid, args);
+    }
+    static jshort callV(jobject obj, jmethodID mid, va_list args)
+    {
+        return getJNIEnv()->CallShortMethodV(obj, mid, args);
+    }
+};
+
+template<> struct JNICaller<jint> {
+    static jint callA(jobject obj, jmethodID mid, jvalue* args)
+    {
+        return getJNIEnv()->CallIntMethodA(obj, mid, args);
+    }
+    static jint callV(jobject obj, jmethodID mid, va_list args)
+    {
+        return getJNIEnv()->CallIntMethodV(obj, mid, args);
+    }
+};
+
+template<> struct JNICaller<jlong> {
+    static jlong callA(jobject obj, jmethodID mid, jvalue* args)
+    {
+        return getJNIEnv()->CallLongMethodA(obj, mid, args);
+    }
+    static jlong callV(jobject obj, jmethodID mid, va_list args)
+    {
+        return getJNIEnv()->CallLongMethodV(obj, mid, args);
+    }
+};
+
+template<> struct JNICaller<jfloat> {
+    static jfloat callA(jobject obj, jmethodID mid, jvalue* args)
+    {
+        return getJNIEnv()->CallFloatMethodA(obj, mid, args);
+    }
+    static jfloat callV(jobject obj, jmethodID mid, va_list args)
+    {
+        return getJNIEnv()->CallFloatMethodV(obj, mid, args);
+    }
+};
+
+template<> struct JNICaller<jdouble> {
+    static jdouble callA(jobject obj, jmethodID mid, jvalue* args)
+    {
+        return getJNIEnv()->CallDoubleMethodA(obj, mid, args);
+    }
+    static jdouble callV(jobject obj, jmethodID mid, va_list args)
+    {
+        return getJNIEnv()->CallDoubleMethodV(obj, mid, args);
+    }
+};
+
+template<typename T> T callJNIMethodIDA(jobject obj, jmethodID mid, jvalue *args)
+{
+    return JNICaller<T>::callA(obj, mid, args);
+}
+    
+template<typename T>
+static T callJNIMethodV(jobject obj, const char *name, const char *sig, va_list args)
+{
+    JavaVM *jvm = getJavaVM();
+    JNIEnv *env = getJNIEnv();
+    
+    if ( obj != NULL && jvm != NULL && env != NULL) {
+        jclass cls = env->GetObjectClass(obj);
+        if ( cls != NULL ) {
+            jmethodID mid = env->GetMethodID(cls, name, sig);
+            if ( mid != NULL )
+            {
+                return JNICaller<T>::callV(obj, mid, args);
+            }
+            else
+            {
+                fprintf(stderr, "%s: Could not find method: %s for %p\n", __PRETTY_FUNCTION__, name, obj);
+                env->ExceptionDescribe();
+                env->ExceptionClear();
+                fprintf (stderr, "\n");
+            }
+
+            env->DeleteLocalRef(cls);
+        }
+        else {
+            fprintf(stderr, "%s: Could not find class for %p\n", __PRETTY_FUNCTION__, obj);
+        }
+    }
+
+    return 0;
+}
+
+template<typename T>
+T callJNIMethod(jobject obj, const char* methodName, const char* methodSignature, ...)
+{
+    va_list args;
+    va_start(args, methodSignature);
+    
+    T result= callJNIMethodV<T>(obj, methodName, methodSignature, args);
+    
+    va_end(args);
+    
+    return result;
+}
+    
+template<typename T>
+T callJNIStaticMethod(jclass cls, const char* methodName, const char* methodSignature, ...)
+{
+    JavaVM *jvm = getJavaVM();
+    JNIEnv *env = getJNIEnv();
+    va_list args;
+    
+    va_start(args, methodSignature);
+    
+    T result = 0;
+    
+    if (cls != NULL && jvm != NULL && env != NULL) {
+        jmethodID mid = env->GetStaticMethodID(cls, methodName, methodSignature);
+        if (mid != NULL) 
+            result = JNICaller<T>::callStaticV(cls, mid, args);
+        else {
+            fprintf(stderr, "%s: Could not find method: %s for %p\n", __PRETTY_FUNCTION__, methodName, cls);
+            env->ExceptionDescribe();
+            env->ExceptionClear();
+            fprintf (stderr, "\n");
+        }
+    }
+    
+    va_end(args);
+    
+    return result;
+}
+    
 bool dispatchJNICall(const void *targetAppletView, jobject obj, bool isStatic, JNIType returnType, jmethodID methodID, jvalue *args, jvalue &result, const char *callingURL, JSValue *&exceptionDescription);
 
 } // namespace Bindings