JavaScriptCore/bindings/jni/jni_instance.cpp

   1 /*
   2  * Copyright (C) 2003 Apple Computer, Inc.  All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25 #include <jni_class.h>
  26 #include <jni_instance.h>
  27 #include <jni_runtime.h>
  28 #include <jni_utility.h>
  29 #include <runtime_object.h>
  30 #include <runtime_root.h>
  31
  32 #ifdef NDEBUG
  33 #define JS_LOG(formatAndArgs...) ((void)0)
  34 #else
  35 #define JS_LOG(formatAndArgs...) { \
  36     fprintf (stderr, "%s:%d -- %s:  ", __FILE__, __LINE__, __FUNCTION__); \
  37     fprintf(stderr, formatAndArgs); \
  38 }
  39 #endif
  40
  41 using namespace KJS::Bindings;
  42 using namespace KJS;
  43
  44 JavaInstance::JavaInstance (jobject instance, const RootObject *r)
  45 {
  46     _instance = new JObjectWrapper (instance);
  47     _class = 0;
  48     _root = r;
  49 };
  50
  51 JavaInstance::~JavaInstance ()
  52 {
  53     _instance->deref();
  54 }
  55
  56
  57 JavaInstance::JavaInstance (const JavaInstance &other) : Instance()
  58 {
  59     _instance = other._instance;
  60     _instance->ref();
  61     // Classes are kept around forever.
  62     _class = other._class;
  63     _root = other._root;
  64 };
  65
  66 #define NUM_LOCAL_REFS 64
  67
  68 void JavaInstance::begin()
  69 {
  70     getJNIEnv()->PushLocalFrame (NUM_LOCAL_REFS);
  71 }
  72
  73 void JavaInstance::end()
  74 {
  75     getJNIEnv()->PopLocalFrame (NULL);
  76 }
  77
  78 Class *JavaInstance::getClass() const
  79 {
  80     if (_class == 0)
  81         _class = JavaClass::classForInstance (_instance->_instance);
  82     return _class;
  83 }
  84
  85 KJS::Value JavaInstance::stringValue() const
  86 {
  87     jstring stringValue = (jstring)callJNIObjectMethod (_instance->_instance, "toString", "()Ljava/lang/String;");
  88     JNIEnv *env = getJNIEnv();
  89     const UChar *c = (const UChar *)getUCharactersFromJStringInEnv (env, stringValue);
  90     UString u(c, (int)env->GetStringLength(stringValue));
  91     String v(u);
  92     releaseUCharactersForJStringInEnv (env, stringValue, (const jchar *)c);
  93     return v;
  94 }
  95
  96 KJS::Value JavaInstance::numberValue() const
  97 {
  98     jdouble doubleValue = callJNIDoubleMethod (_instance->_instance, "doubleValue", "()D");
  99     KJS::Number v(doubleValue);
 100     return v;
 101 }
 102
 103 KJS::Value JavaInstance::booleanValue() const
 104 {
 105     jboolean booleanValue = callJNIBooleanMethod (_instance->_instance, "booleanValue", "()Z");
 106     KJS::Boolean v(booleanValue);
 107     return v;
 108 }
 109
 110 Value JavaInstance::invokeMethod (KJS::ExecState *exec, const MethodList &methodList, const List &args)
 111 {
 112     int i, count = args.size();
 113     jvalue *jArgs;
 114     Value resultValue;
 115     Method *method = 0;
 116     unsigned int numMethods = methodList.length();
 117
 118     // Try to find a good match for the overloaded method.  The
 119     // fundamental problem is that JavaScript doesn have the
 120     // notion of method overloading and Java does.  We could
 121     // get a bit more sophisticated and attempt to does some
 122     // type checking as we as checking the number of parameters.
 123     unsigned int methodIndex;
 124     Method *aMethod;
 125     for (methodIndex = 0; methodIndex < numMethods; methodIndex++) {
 126         aMethod = methodList.methodAt (methodIndex);
 127         if (aMethod->numParameters() == count) {
 128             method = aMethod;
 129             break;
 130         }
 131     }
 132     if (method == 0) {
 133         JS_LOG ("unable to find an appropiate method\n");
 134         return Undefined();
 135     }
 136
 137     const JavaMethod *jMethod = static_cast<const JavaMethod*>(method);
 138     JS_LOG ("call %s %s on %p\n", method->name(), jMethod->signature(), _instance->_instance);
 139
 140     if (count > 0) {
 141         jArgs = (jvalue *)malloc (count * sizeof(jvalue));
 142     }
 143     else
 144         jArgs = 0;
 145
 146     for (i = 0; i < count; i++) {
 147         JavaParameter *aParameter = static_cast<JavaParameter *>(jMethod->parameterAt(i));
 148         jArgs[i] = convertValueToJValue (exec, args.at(i), aParameter->getJNIType(), aParameter->type());
 149     }
 150
 151
 152     jvalue result;
 153
 154     // Try to use the JNI abstraction first, otherwise fall back to
 155     // nornmal JNI.  The JNI dispatch abstraction allows the Java plugin
 156     // to dispatch the call on the appropriate internal VM thread.
 157     const RootObject *execContext = executionContext();
 158     bool handled = false;
 159     if (execContext && execContext->nativeHandle()) {
 160         jobject obj = _instance->_instance;
 161         handled = dispatchJNICall (execContext->nativeHandle(), obj, jMethod->methodID(obj), jMethod->JNIReturnType(), jArgs, result);
 162     }
 163
 164     // The following code can be conditionally removed once we have a Tiger update that
 165     // contains the new Java plugin.  It is needed for builds prior to Tiger.
 166     if (!handled) {
 167         jobject obj = _instance->_instance;
 168         switch (jMethod->JNIReturnType()){
 169             case void_type: {
 170                 callJNIVoidMethodIDA (obj, jMethod->methodID(obj), jArgs);
 171             }
 172             break;
 173
 174             case object_type: {
 175                 result.l = callJNIObjectMethodIDA (obj, jMethod->methodID(obj), jArgs);
 176             }
 177             break;
 178
 179             case boolean_type: {
 180                 result.z = callJNIBooleanMethodIDA (obj, jMethod->methodID(obj), jArgs);
 181             }
 182             break;
 183
 184             case byte_type: {
 185                 result.b = callJNIByteMethodIDA (obj, jMethod->methodID(obj), jArgs);
 186             }
 187             break;
 188
 189             case char_type: {
 190                 result.c = callJNICharMethodIDA (obj, jMethod->methodID(obj), jArgs);
 191             }
 192             break;
 193
 194             case short_type: {
 195                 result.s = callJNIShortMethodIDA (obj, jMethod->methodID(obj), jArgs);
 196             }
 197             break;
 198
 199             case int_type: {
 200                 result.i = callJNIIntMethodIDA (obj, jMethod->methodID(obj), jArgs);
 201             }
 202             break;
 203
 204             case long_type: {
 205                 result.j = callJNILongMethodIDA (obj, jMethod->methodID(obj), jArgs);
 206             }
 207             break;
 208
 209             case float_type: {
 210                 result.f = callJNIFloatMethodIDA (obj, jMethod->methodID(obj), jArgs);
 211             }
 212             break;
 213
 214             case double_type: {
 215                 result.d = callJNIDoubleMethodIDA (obj, jMethod->methodID(obj), jArgs);
 216             }
 217             break;
 218
 219             case invalid_type:
 220             default: {
 221             }
 222             break;
 223         }
 224     }
 225
 226     switch (jMethod->JNIReturnType()){
 227         case void_type: {
 228             resultValue = Undefined();
 229         }
 230         break;
 231
 232         case object_type: {
 233             if (result.l != 0) {
 234                 const char *arrayType = jMethod->returnType();
 235                 if (arrayType[0] == '[') {
 236                     resultValue = JavaArray::convertJObjectToArray (exec, result.l, arrayType, executionContext());
 237                 }
 238                 else {
 239                     resultValue = Object(new RuntimeObjectImp(new JavaInstance (result.l, executionContext())));
 240                 }
 241             }
 242             else {
 243                 resultValue = Undefined();
 244             }
 245         }
 246         break;
 247
 248         case boolean_type: {
 249             resultValue = KJS::Boolean(result.z);
 250         }
 251         break;
 252
 253         case byte_type: {
 254             resultValue = Number(result.b);
 255         }
 256         break;
 257
 258         case char_type: {
 259             resultValue = Number(result.c);
 260         }
 261         break;
 262
 263         case short_type: {
 264             resultValue = Number(result.s);
 265         }
 266         break;
 267
 268         case int_type: {
 269             resultValue = Number(result.i);
 270         }
 271         break;
 272
 273         case long_type: {
 274             resultValue = Number((long int)result.j);
 275         }
 276         break;
 277
 278         case float_type: {
 279             resultValue = Number(result.f);
 280         }
 281         break;
 282
 283         case double_type: {
 284             resultValue = Number(result.d);
 285         }
 286         break;
 287
 288         case invalid_type:
 289         default: {
 290             resultValue = Undefined();
 291         }
 292         break;
 293     }
 294
 295     free (jArgs);
 296
 297     return resultValue;
 298 }
 299
 300
 301 KJS::Value JavaInstance::defaultValue (KJS::Type hint) const
 302 {
 303     if (hint == StringType) {
 304         return stringValue();
 305     }
 306     else if (hint == NumberType) {
 307         return numberValue();
 308     }
 309     else if (hint == BooleanType) {
 310         return booleanValue();
 311     }
 312     else if (hint == UnspecifiedType) {
 313         JavaClass *aClass = static_cast<JavaClass*>(getClass());
 314         if (aClass->isStringClass()) {
 315             return stringValue();
 316         }
 317         else if (aClass->isNumberClass()) {
 318             return numberValue();
 319         }
 320         else if (aClass->isBooleanClass()) {
 321             return booleanValue();
 322         }
 323     }
 324
 325     return valueOf();
 326 }
 327
 328 KJS::Value JavaInstance::valueOf() const
 329 {
 330     return stringValue();
 331 };
 332
 333 void JavaInstance::setExecutionContext (RootObject *r) { _root = r; }
 334 const RootObject *JavaInstance::executionContext() const { return _root; }
 335
 336 JObjectWrapper::JObjectWrapper(jobject instance)
 337 {
 338     assert (instance != 0);
 339
 340     _ref = 1;
 341     // Cache the JNIEnv used to get the global ref for this java instanace.
 342     // It'll be used to delete the reference.
 343     _env = getJNIEnv();
 344
 345     _instance = _env->NewGlobalRef (instance);
 346
 347         JS_LOG ("new global ref %p for %p\n", _instance, instance);
 348
 349     if  (_instance == NULL) {
 350         fprintf (stderr, "%s:  could not get GlobalRef for %p\n", __PRETTY_FUNCTION__, instance);
 351     }
 352 }
 353
 354 JObjectWrapper::~JObjectWrapper() {
 355         JS_LOG ("deleting global ref %p\n", _instance);
 356         _env->DeleteGlobalRef (_instance);
 357 }