a544226893524b4427f3e651ee8b64151e58823f
[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
31 #ifdef NDEBUG
32 #define JS_LOG(formatAndArgs...) ((void)0)
33 #else
34 #define JS_LOG(formatAndArgs...) { \
35     fprintf (stderr, "%s:%d -- %s:  ", __FILE__, __LINE__, __FUNCTION__); \
36     fprintf(stderr, formatAndArgs); \
37 }
38 #endif
39
40 using namespace KJS::Bindings;
41 using namespace KJS;
42
43 JavaInstance::JavaInstance (jobject instance) 
44 {
45     _instance = new JObjectWrapper (instance);
46     _class = 0;
47 };
48
49 JavaInstance::~JavaInstance () 
50 {
51     _instance->deref();
52 }
53
54
55 JavaInstance::JavaInstance (const JavaInstance &other) : Instance() 
56 {
57     _instance = other._instance;
58     _instance->ref();
59     // Classes are kept around forever.
60     _class = other._class;
61 };
62
63 #define NUM_LOCAL_REFS 64
64
65 void JavaInstance::begin()
66 {
67     getJNIEnv()->PushLocalFrame (NUM_LOCAL_REFS);
68 }
69
70 void JavaInstance::end()
71 {
72     getJNIEnv()->PopLocalFrame (NULL);
73 }
74
75 Class *JavaInstance::getClass() const 
76 {
77     if (_class == 0)
78         _class = JavaClass::classForInstance (_instance->_instance);
79     return _class;
80 }
81
82 KJS::Value JavaInstance::stringValue() const
83 {
84     jstring stringValue = (jstring)callJNIObjectMethod (_instance->_instance, "toString", "()Ljava/lang/String;");
85     JNIEnv *env = getJNIEnv();
86     const UChar *c = (const UChar *)getUCharactersFromJStringInEnv (env, stringValue);
87     UString u(c, (int)env->GetStringLength(stringValue));
88     String v(u);
89     releaseUCharactersForJStringInEnv (env, stringValue, (const jchar *)c);
90     return v;
91 }
92
93 KJS::Value JavaInstance::numberValue() const
94 {
95     jdouble doubleValue = callJNIDoubleMethod (_instance->_instance, "doubleValue", "()D");
96     KJS::Number v(doubleValue);
97     return v;
98 }
99
100 KJS::Value JavaInstance::booleanValue() const
101 {
102     jboolean booleanValue = callJNIBooleanMethod (_instance->_instance, "booleanValue", "()Z");
103     KJS::Boolean v(booleanValue);
104     return v;
105 }
106
107 Value JavaInstance::invokeMethod (KJS::ExecState *exec, const MethodList &methodList, const List &args)
108 {
109     int i, count = args.size();
110     jvalue *jArgs;
111     Value resultValue;
112     Method *method = 0;
113     unsigned int numMethods = methodList.length();
114     
115     // Try to find a good match for the overloaded method.  The 
116     // fundamental problem is that JavaScript doesn have the
117     // notion of method overloading and Java does.  We could 
118     // get a bit more sophisticated and attempt to does some
119     // type checking as we as checking the number of parameters.
120     unsigned int methodIndex;
121     Method *aMethod;
122     for (methodIndex = 0; methodIndex < numMethods; methodIndex++) {
123         aMethod = methodList.methodAt (methodIndex);
124         if (aMethod->numParameters() == count) {
125             method = aMethod;
126             break;
127         }
128     }
129     if (method == 0) {
130         JS_LOG ("unable to find an appropiate method\n");
131         return Undefined();
132     }
133     
134     const JavaMethod *jMethod = static_cast<const JavaMethod*>(method);
135     JS_LOG ("call %s %s on %p\n", method->name(), jMethod->signature(), _instance->_instance);
136     
137     if (count > 0) {
138         jArgs = (jvalue *)malloc (count * sizeof(jvalue));
139     }
140     else
141         jArgs = 0;
142         
143     for (i = 0; i < count; i++) {
144         JavaParameter *aParameter = static_cast<JavaParameter *>(jMethod->parameterAt(i));
145         jArgs[i] = convertValueToJValue (exec, args.at(i), aParameter->getJNIType(), aParameter->type());
146     }
147     
148     jvalue result;
149     jobject obj = _instance->_instance;
150     switch (jMethod->JNIReturnType()){
151         case void_type: {
152             callJNIVoidMethodIDA (obj, jMethod->methodID(obj), jArgs);
153             resultValue = Undefined();
154         }
155         break;
156         
157         case object_type: {
158             result.l = callJNIObjectMethodIDA (obj, jMethod->methodID(obj), jArgs);
159             if (result.l != 0) {
160                 const char *arrayType = jMethod->returnType();
161                 if (arrayType[0] == '[') {
162                     resultValue = JavaArray::convertJObjectToArray (exec, result.l, arrayType);
163                 }
164                 else {
165                     resultValue = Object(new RuntimeObjectImp(new JavaInstance (result.l)));
166                 }
167             }
168             else {
169                 resultValue = Undefined();
170             }
171         }
172         break;
173         
174         case boolean_type: {
175             result.z = callJNIBooleanMethodIDA (obj, jMethod->methodID(obj), jArgs);
176             resultValue = KJS::Boolean(result.z);
177         }
178         break;
179         
180         case byte_type: {
181             result.b = callJNIByteMethodIDA (obj, jMethod->methodID(obj), jArgs);
182             resultValue = Number(result.b);
183         }
184         break;
185         
186         case char_type: {
187             result.c = callJNICharMethodIDA (obj, jMethod->methodID(obj), jArgs);
188             resultValue = Number(result.c);
189         }
190         break;
191         
192         case short_type: {
193             result.s = callJNIShortMethodIDA (obj, jMethod->methodID(obj), jArgs);
194             resultValue = Number(result.s);
195         }
196         break;
197         
198         case int_type: {
199             result.i = callJNIIntMethodIDA (obj, jMethod->methodID(obj), jArgs);
200             resultValue = Number(result.i);
201         }
202         break;
203         
204         case long_type: {
205             result.j = callJNILongMethodIDA (obj, jMethod->methodID(obj), jArgs);
206             resultValue = Number((long int)result.j);
207         }
208         break;
209         
210         case float_type: {
211             result.f = callJNIFloatMethodIDA (obj, jMethod->methodID(obj), jArgs);
212             resultValue = Number(result.f);
213         }
214         break;
215         
216         case double_type: {
217             result.d = callJNIDoubleMethodIDA (obj, jMethod->methodID(obj), jArgs);
218             resultValue = Number(result.d);
219         }
220         break;
221
222         case invalid_type:
223         default: {
224             resultValue = Undefined();
225         }
226         break;
227     }
228         
229     free (jArgs);
230
231     return resultValue;
232 }
233
234
235 KJS::Value JavaInstance::defaultValue (KJS::Type hint) const
236 {
237     if (hint == StringType) {
238         return stringValue();
239     }
240     else if (hint == NumberType) {
241         return numberValue();
242     }
243     else if (hint == BooleanType) {
244         return booleanValue();
245     }
246     else if (hint == UnspecifiedType) {
247         JavaClass *aClass = static_cast<JavaClass*>(getClass());
248         if (aClass->isStringClass()) {
249             return stringValue();
250         }
251         else if (aClass->isNumberClass()) {
252             return numberValue();
253         }
254         else if (aClass->isBooleanClass()) {
255             return booleanValue();
256         }
257     }
258     
259     return valueOf();
260 }
261
262 KJS::Value JavaInstance::valueOf() const 
263 {
264     return stringValue();
265 };
266
267 JObjectWrapper::JObjectWrapper(jobject instance)
268 {
269     assert (instance != 0);
270
271     _ref = 1;
272     // Cache the JNIEnv used to get the global ref for this java instanace.
273     // It'll be used to delete the reference.
274     _env = getJNIEnv();
275         
276     _instance = _env->NewGlobalRef (instance);
277     
278         JS_LOG ("new global ref %p for %p\n", _instance, instance);
279         
280     if  (_instance == NULL) {
281         fprintf (stderr, "%s:  could not get GlobalRef for %p\n", __PRETTY_FUNCTION__, instance);
282     }
283 }
284
285 JObjectWrapper::~JObjectWrapper() {
286         JS_LOG ("deleting global ref %p\n", _instance);
287         _env->DeleteGlobalRef (_instance);
288 }