WebKit:
[WebKit-https.git] / 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 }