Reviewed by Sam.
[WebKit-https.git] / WebCore / bridge / jni / jni_utility.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
26 #include "config.h"
27 #include "jni_utility.h"
28
29 #include "list.h"
30 #include "jni_runtime.h"
31 #include "runtime_array.h"
32 #include "runtime_object.h"
33 #include <dlfcn.h>
34
35 namespace KJS {
36
37 namespace Bindings {
38
39 static jint KJS_GetCreatedJavaVMs(JavaVM** vmBuf, jsize bufLen, jsize* nVMs)
40 {
41     static void* javaVMFramework = 0;
42     if (!javaVMFramework)
43         javaVMFramework = dlopen("/System/Library/Frameworks/JavaVM.framework/JavaVM", RTLD_LAZY);
44     if (!javaVMFramework)
45         return JNI_ERR;
46
47     static jint(*functionPointer)(JavaVM**, jsize, jsize *) = 0;
48     if (!functionPointer)
49         functionPointer = (jint(*)(JavaVM**, jsize, jsize *))dlsym(javaVMFramework, "JNI_GetCreatedJavaVMs");
50     if (!functionPointer)
51         return JNI_ERR;
52     return functionPointer(vmBuf, bufLen, nVMs);
53 }
54
55 static JavaVM *jvm = 0;
56
57 // Provide the ability for an outside component to specify the JavaVM to use
58 // If the jvm value is set, the getJavaVM function below will just return. 
59 // In getJNIEnv(), if AttachCurrentThread is called to a VM that is already
60 // attached, the result is a no-op.
61 void setJavaVM(JavaVM *javaVM)
62 {
63     jvm = javaVM;
64 }
65
66 JavaVM *getJavaVM()
67 {
68     if (jvm)
69         return jvm;
70
71     JavaVM *jvmArray[1];
72     jsize bufLen = 1;
73     jsize nJVMs = 0;
74     jint jniError = 0;
75
76     // Assumes JVM is already running ..., one per process
77     jniError = KJS_GetCreatedJavaVMs(jvmArray, bufLen, &nJVMs);
78     if ( jniError == JNI_OK && nJVMs > 0 ) {
79         jvm = jvmArray[0];
80     }
81     else 
82         fprintf(stderr, "%s: JNI_GetCreatedJavaVMs failed, returned %ld\n", __PRETTY_FUNCTION__, (long)jniError);
83         
84     return jvm;
85 }
86
87 JNIEnv* getJNIEnv()
88 {
89     union {
90         JNIEnv* env;
91         void* dummy;
92     } u;
93     jint jniError = 0;
94
95     jniError = (getJavaVM())->AttachCurrentThread(&u.dummy, NULL);
96     if (jniError == JNI_OK)
97         return u.env;
98     else
99         fprintf(stderr, "%s: AttachCurrentThread failed, returned %ld\n", __PRETTY_FUNCTION__, (long)jniError);
100     return NULL;
101 }
102
103 static jvalue callJNIMethod (JNIType type, jobject obj, const char *name, const char *sig, va_list args)
104 {
105     JavaVM *jvm = getJavaVM();
106     JNIEnv *env = getJNIEnv();
107     jvalue result;
108
109     bzero (&result, sizeof(jvalue));
110     if ( obj != NULL && jvm != NULL && env != NULL) {
111         jclass cls = env->GetObjectClass(obj);
112         if ( cls != NULL ) {
113             jmethodID mid = env->GetMethodID(cls, name, sig);
114             if ( mid != NULL )
115             {
116                 switch (type) {
117                 case void_type:
118                     env->functions->CallVoidMethodV(env, obj, mid, args);
119                     break;
120                 case array_type:
121                 case object_type:
122                     result.l = env->functions->CallObjectMethodV(env, obj, mid, args);
123                     break;
124                 case boolean_type:
125                     result.z = env->functions->CallBooleanMethodV(env, obj, mid, args);
126                     break;
127                 case byte_type:
128                     result.b = env->functions->CallByteMethodV(env, obj, mid, args);
129                     break;
130                 case char_type:
131                     result.c = env->functions->CallCharMethodV(env, obj, mid, args);
132                     break;
133                 case short_type:
134                     result.s = env->functions->CallShortMethodV(env, obj, mid, args);
135                     break;
136                 case int_type:
137                     result.i = env->functions->CallIntMethodV(env, obj, mid, args);
138                     break;
139                 case long_type:
140                     result.j = env->functions->CallLongMethodV(env, obj, mid, args);
141                     break;
142                 case float_type:
143                     result.f = env->functions->CallFloatMethodV(env, obj, mid, args);
144                     break;
145                 case double_type:
146                     result.d = env->functions->CallDoubleMethodV(env, obj, mid, args);
147                     break;
148                 default:
149                     fprintf(stderr, "%s: invalid function type (%d)\n", __PRETTY_FUNCTION__, (int)type);
150                 }
151             }
152             else
153             {
154                 fprintf(stderr, "%s: Could not find method: %s for %p\n", __PRETTY_FUNCTION__, name, obj);
155                 env->ExceptionDescribe();
156                 env->ExceptionClear();
157                 fprintf (stderr, "\n");
158             }
159
160             env->DeleteLocalRef(cls);
161         }
162         else {
163             fprintf(stderr, "%s: Could not find class for %p\n", __PRETTY_FUNCTION__, obj);
164         }
165     }
166
167     return result;
168 }
169
170 static jvalue callJNIStaticMethod (JNIType type, jclass cls, const char *name, const char *sig, va_list args)
171 {
172     JavaVM *jvm = getJavaVM();
173     JNIEnv *env = getJNIEnv();
174     jvalue result;
175
176     bzero (&result, sizeof(jvalue));
177     if ( cls != NULL && jvm != NULL && env != NULL) {
178         jmethodID mid = env->GetStaticMethodID(cls, name, sig);
179         if ( mid != NULL )
180         {
181             switch (type) {
182             case void_type:
183                 env->functions->CallStaticVoidMethodV(env, cls, mid, args);
184                 break;
185             case array_type:
186             case object_type:
187                 result.l = env->functions->CallStaticObjectMethodV(env, cls, mid, args);
188                 break;
189             case boolean_type:
190                 result.z = env->functions->CallStaticBooleanMethodV(env, cls, mid, args);
191                 break;
192             case byte_type:
193                 result.b = env->functions->CallStaticByteMethodV(env, cls, mid, args);
194                 break;
195             case char_type:
196                 result.c = env->functions->CallStaticCharMethodV(env, cls, mid, args);
197                 break;
198             case short_type:
199                 result.s = env->functions->CallStaticShortMethodV(env, cls, mid, args);
200                 break;
201             case int_type:
202                 result.i = env->functions->CallStaticIntMethodV(env, cls, mid, args);
203                 break;
204             case long_type:
205                 result.j = env->functions->CallStaticLongMethodV(env, cls, mid, args);
206                 break;
207             case float_type:
208                 result.f = env->functions->CallStaticFloatMethodV(env, cls, mid, args);
209                 break;
210             case double_type:
211                 result.d = env->functions->CallStaticDoubleMethodV(env, cls, mid, args);
212                 break;
213             default:
214                 fprintf(stderr, "%s: invalid function type (%d)\n", __PRETTY_FUNCTION__, (int)type);
215             }
216         }
217         else
218         {
219             fprintf(stderr, "%s: Could not find method: %s for %p\n", __PRETTY_FUNCTION__, name, cls);
220             env->ExceptionDescribe();
221             env->ExceptionClear();
222             fprintf (stderr, "\n");
223         }
224     }
225
226     return result;
227 }
228
229 static jvalue callJNIMethodIDA (JNIType type, jobject obj, jmethodID mid, jvalue *args)
230 {
231     JNIEnv *env = getJNIEnv();
232     jvalue result;
233     
234     bzero (&result, sizeof(jvalue));
235     if ( obj != NULL && mid != NULL )
236     {
237         switch (type) {
238         case void_type:
239             env->functions->CallVoidMethodA(env, obj, mid, args);
240             break;
241         case array_type:
242         case object_type:
243             result.l = env->functions->CallObjectMethodA(env, obj, mid, args);
244             break;
245         case boolean_type:
246             result.z = env->functions->CallBooleanMethodA(env, obj, mid, args);
247             break;
248         case byte_type:
249             result.b = env->functions->CallByteMethodA(env, obj, mid, args);
250             break;
251         case char_type:
252             result.c = env->functions->CallCharMethodA(env, obj, mid, args);
253             break;
254         case short_type:
255             result.s = env->functions->CallShortMethodA(env, obj, mid, args);
256             break;
257         case int_type:
258             result.i = env->functions->CallIntMethodA(env, obj, mid, args);
259             break;
260         case long_type:
261             result.j = env->functions->CallLongMethodA(env, obj, mid, args);
262             break;
263         case float_type:
264             result.f = env->functions->CallFloatMethodA(env, obj, mid, args);
265             break;
266         case double_type:
267             result.d = env->functions->CallDoubleMethodA(env, obj, mid, args);
268             break;
269         default:
270             fprintf(stderr, "%s: invalid function type (%d)\n", __PRETTY_FUNCTION__, (int)type);
271         }
272     }
273
274     return result;
275 }
276
277 static jvalue callJNIMethodA (JNIType type, jobject obj, const char *name, const char *sig, jvalue *args)
278 {
279     JavaVM *jvm = getJavaVM();
280     JNIEnv *env = getJNIEnv();
281     jvalue result;
282     
283     bzero (&result, sizeof(jvalue));
284     if ( obj != NULL && jvm != NULL && env != NULL) {
285         jclass cls = env->GetObjectClass(obj);
286         if ( cls != NULL ) {
287             jmethodID mid = env->GetMethodID(cls, name, sig);
288             if ( mid != NULL ) {
289                 result = callJNIMethodIDA (type, obj, mid, args);
290             }
291             else {
292                 fprintf(stderr, "%s: Could not find method: %s\n", __PRETTY_FUNCTION__, name);
293                 env->ExceptionDescribe();
294                 env->ExceptionClear();
295                 fprintf (stderr, "\n");
296             }
297
298             env->DeleteLocalRef(cls);
299         }
300         else {
301             fprintf(stderr, "%s: Could not find class for object\n", __PRETTY_FUNCTION__);
302         }
303     }
304
305     return result;
306 }
307
308 jmethodID getMethodID (jobject obj, const char *name, const char *sig)
309 {
310     JNIEnv *env = getJNIEnv();
311     jmethodID mid = 0;
312         
313     if ( env != NULL) {
314     jclass cls = env->GetObjectClass(obj);
315     if ( cls != NULL ) {
316             mid = env->GetMethodID(cls, name, sig);
317             if (!mid) {
318                 env->ExceptionClear();
319                 mid = env->GetStaticMethodID(cls, name, sig);
320                 if (!mid) {
321                     env->ExceptionClear();
322                 }
323             }
324         }
325         env->DeleteLocalRef(cls);
326     }
327     return mid;
328 }
329
330
331 #define CALL_JNI_METHOD(function_type,obj,name,sig) \
332     va_list args;\
333     va_start (args, sig);\
334     \
335     jvalue result = callJNIMethod(function_type, obj, name, sig, args);\
336     \
337     va_end (args);
338
339 #define CALL_JNI_STATIC_METHOD(function_type,cls,name,sig) \
340     va_list args;\
341     va_start (args, sig);\
342     \
343     jvalue result = callJNIStaticMethod(function_type, cls, name, sig, args);\
344     \
345     va_end (args);
346
347 void callJNIVoidMethod (jobject obj, const char *name, const char *sig, ... )
348 {
349     CALL_JNI_METHOD (void_type, obj, name, sig);
350 }
351
352 jobject callJNIObjectMethod (jobject obj, const char *name, const char *sig, ... )
353 {
354     CALL_JNI_METHOD (object_type, obj, name, sig);
355     return result.l;
356 }
357
358 jboolean callJNIBooleanMethod( jobject obj, const char *name, const char *sig, ... )
359 {
360     CALL_JNI_METHOD (boolean_type, obj, name, sig);
361     return result.z;
362 }
363
364 jboolean callJNIStaticBooleanMethod (jclass cls, const char *name, const char *sig, ... )
365 {
366     CALL_JNI_STATIC_METHOD (boolean_type, cls, name, sig);
367     return result.z;
368 }
369
370 jbyte callJNIByteMethod( jobject obj, const char *name, const char *sig, ... )
371 {
372     CALL_JNI_METHOD (byte_type, obj, name, sig);
373     return result.b;
374 }
375
376 jchar callJNICharMethod (jobject obj, const char *name, const char *sig, ... )
377 {
378     CALL_JNI_METHOD (char_type, obj, name, sig);
379     return result.c;
380 }
381
382 jshort callJNIShortMethod (jobject obj, const char *name, const char *sig, ... )
383 {
384     CALL_JNI_METHOD (short_type, obj, name, sig);
385     return result.s;
386 }
387
388 jint callJNIIntMethod (jobject obj, const char *name, const char *sig, ... )
389 {
390     CALL_JNI_METHOD (int_type, obj, name, sig);
391     return result.i;
392 }
393
394 jlong callJNILongMethod (jobject obj, const char *name, const char *sig, ... )
395 {
396     CALL_JNI_METHOD (long_type, obj, name, sig);
397     return result.j;
398 }
399
400 jfloat callJNIFloatMethod (jobject obj, const char *name, const char *sig, ... )
401 {
402     CALL_JNI_METHOD (float_type, obj, name, sig);
403     return result.f;
404 }
405
406 jdouble callJNIDoubleMethod (jobject obj, const char *name, const char *sig, ... )
407 {
408     CALL_JNI_METHOD (double_type, obj, name, sig);
409     return result.d;
410 }
411
412 void callJNIVoidMethodA (jobject obj, const char *name, const char *sig, jvalue *args)
413 {
414     jvalue result = callJNIMethodA (void_type, obj, name, sig, args);
415 }
416
417 jobject callJNIObjectMethodA (jobject obj, const char *name, const char *sig, jvalue *args)
418 {
419     jvalue result = callJNIMethodA (object_type, obj, name, sig, args);
420     return result.l;
421 }
422
423 jbyte callJNIByteMethodA ( jobject obj, const char *name, const char *sig, jvalue *args)
424 {
425     jvalue result = callJNIMethodA (byte_type, obj, name, sig, args);
426     return result.b;
427 }
428
429 jchar callJNICharMethodA (jobject obj, const char *name, const char *sig, jvalue *args)
430 {
431     jvalue result = callJNIMethodA (char_type, obj, name, sig, args);
432     return result.c;
433 }
434
435 jshort callJNIShortMethodA (jobject obj, const char *name, const char *sig, jvalue *args)
436 {
437     jvalue result = callJNIMethodA (short_type, obj, name, sig, args);
438     return result.s;
439 }
440
441 jint callJNIIntMethodA (jobject obj, const char *name, const char *sig, jvalue *args)
442 {
443     jvalue result = callJNIMethodA (int_type, obj, name, sig, args);
444     return result.i;
445 }
446
447 jlong callJNILongMethodA (jobject obj, const char *name, const char *sig, jvalue *args)
448 {
449     jvalue result = callJNIMethodA (long_type, obj, name, sig, args);
450     return result.j;
451 }
452
453 jfloat callJNIFloatMethodA (jobject obj, const char *name, const char *sig, jvalue *args)
454 {
455     jvalue result = callJNIMethodA  (float_type, obj, name, sig, args);
456     return result.f;
457 }
458
459 jdouble callJNIDoubleMethodA (jobject obj, const char *name, const char *sig, jvalue *args)
460 {
461     jvalue result = callJNIMethodA (double_type, obj, name, sig, args);
462     return result.d;
463 }
464
465 jboolean callJNIBooleanMethodA (jobject obj, const char *name, const char *sig, jvalue *args)
466 {
467     jvalue result = callJNIMethodA (boolean_type, obj, name, sig, args);
468     return result.z;
469 }
470
471 void callJNIVoidMethodIDA (jobject obj, jmethodID methodID, jvalue *args)
472 {
473     jvalue result = callJNIMethodIDA (void_type, obj, methodID, args);
474 }
475
476 jobject callJNIObjectMethodIDA (jobject obj, jmethodID methodID, jvalue *args)
477 {
478     jvalue result = callJNIMethodIDA (object_type, obj, methodID, args);
479     return result.l;
480 }
481
482 jbyte callJNIByteMethodIDA ( jobject obj, jmethodID methodID, jvalue *args)
483 {
484     jvalue result = callJNIMethodIDA (byte_type, obj, methodID, args);
485     return result.b;
486 }
487
488 jchar callJNICharMethodIDA (jobject obj, jmethodID methodID, jvalue *args)
489 {
490     jvalue result = callJNIMethodIDA (char_type, obj, methodID, args);
491     return result.c;
492 }
493
494 jshort callJNIShortMethodIDA (jobject obj, jmethodID methodID, jvalue *args)
495 {
496     jvalue result = callJNIMethodIDA (short_type, obj, methodID, args);
497     return result.s;
498 }
499
500 jint callJNIIntMethodIDA (jobject obj, jmethodID methodID, jvalue *args)
501 {
502     jvalue result = callJNIMethodIDA (int_type, obj, methodID, args);
503     return result.i;
504 }
505
506 jlong callJNILongMethodIDA (jobject obj, jmethodID methodID, jvalue *args)
507 {
508     jvalue result = callJNIMethodIDA (long_type, obj, methodID, args);
509     return result.j;
510 }
511
512 jfloat callJNIFloatMethodIDA (jobject obj, jmethodID methodID, jvalue *args)
513 {
514     jvalue result = callJNIMethodIDA  (float_type, obj, methodID, args);
515     return result.f;
516 }
517
518 jdouble callJNIDoubleMethodIDA (jobject obj, jmethodID methodID, jvalue *args)
519 {
520     jvalue result = callJNIMethodIDA (double_type, obj, methodID, args);
521     return result.d;
522 }
523
524 jboolean callJNIBooleanMethodIDA (jobject obj, jmethodID methodID, jvalue *args)
525 {
526     jvalue result = callJNIMethodIDA (boolean_type, obj, methodID, args);
527     return result.z;
528 }
529
530 const char *getCharactersFromJString (jstring aJString)
531 {
532     return getCharactersFromJStringInEnv (getJNIEnv(), aJString);
533 }
534
535 void releaseCharactersForJString (jstring aJString, const char *s)
536 {
537     releaseCharactersForJStringInEnv (getJNIEnv(), aJString, s);
538 }
539
540 const char *getCharactersFromJStringInEnv (JNIEnv *env, jstring aJString)
541 {
542     jboolean isCopy;
543     const char *s = env->GetStringUTFChars((jstring)aJString, &isCopy);
544     if (!s) {
545         env->ExceptionDescribe();
546         env->ExceptionClear();
547                 fprintf (stderr, "\n");
548     }
549     return s;
550 }
551
552 void releaseCharactersForJStringInEnv (JNIEnv *env, jstring aJString, const char *s)
553 {
554     env->ReleaseStringUTFChars (aJString, s);
555 }
556
557 const jchar *getUCharactersFromJStringInEnv (JNIEnv *env, jstring aJString)
558 {
559     jboolean isCopy;
560     const jchar *s = env->GetStringChars((jstring)aJString, &isCopy);
561     if (!s) {
562         env->ExceptionDescribe();
563         env->ExceptionClear();
564                 fprintf (stderr, "\n");
565     }
566     return s;
567 }
568
569 void releaseUCharactersForJStringInEnv (JNIEnv *env, jstring aJString, const jchar *s)
570 {
571     env->ReleaseStringChars (aJString, s);
572 }
573
574 JNIType JNITypeFromClassName(const char *name)
575 {
576     JNIType type;
577     
578     if (strcmp("byte",name) == 0)
579         type = byte_type;
580     else if (strcmp("short",name) == 0)
581         type = short_type;
582     else if (strcmp("int",name) == 0)
583         type = int_type;
584     else if (strcmp("long",name) == 0)
585         type = long_type;
586     else if (strcmp("float",name) == 0)
587         type = float_type;
588     else if (strcmp("double",name) == 0)
589         type = double_type;
590     else if (strcmp("char",name) == 0)
591         type = char_type;
592     else if (strcmp("boolean",name) == 0)
593         type = boolean_type;
594     else if (strcmp("void",name) == 0)
595         type = void_type;
596     else if ('[' == name[0]) 
597         type = array_type;
598     else
599         type = object_type;
600         
601     return type;
602 }
603
604 const char *signatureFromPrimitiveType(JNIType type)
605 {
606     switch (type){
607         case void_type: 
608             return "V";
609         
610         case array_type:
611             return "[";
612         
613         case object_type:
614             return "L";
615         
616         case boolean_type:
617             return "Z";
618         
619         case byte_type:
620             return "B";
621             
622         case char_type:
623             return "C";
624         
625         case short_type:
626             return "S";
627         
628         case int_type:
629             return "I";
630         
631         case long_type:
632             return "J";
633         
634         case float_type:
635             return "F";
636         
637         case double_type:
638             return "D";
639
640         case invalid_type:
641         default:
642         break;
643     }
644     return "";
645 }
646
647 JNIType JNITypeFromPrimitiveType(char type)
648 {
649     switch (type){
650         case 'V': 
651             return void_type;
652         
653         case 'L':
654             return object_type;
655             
656         case '[':
657             return array_type;
658         
659         case 'Z':
660             return boolean_type;
661         
662         case 'B':
663             return byte_type;
664             
665         case 'C':
666             return char_type;
667         
668         case 'S':
669             return short_type;
670         
671         case 'I':
672             return int_type;
673         
674         case 'J':
675             return long_type;
676         
677         case 'F':
678             return float_type;
679         
680         case 'D':
681             return double_type;
682
683         default:
684         break;
685     }
686     return invalid_type;
687 }
688
689 jvalue getJNIField( jobject obj, JNIType type, const char *name, const char *signature)
690 {
691     JavaVM *jvm = getJavaVM();
692     JNIEnv *env = getJNIEnv();
693     jvalue result;
694
695     bzero (&result, sizeof(jvalue));
696     if ( obj != NULL && jvm != NULL && env != NULL) {
697         jclass cls = env->GetObjectClass(obj);
698         if ( cls != NULL ) {
699             jfieldID field = env->GetFieldID(cls, name, signature);
700             if ( field != NULL ) {
701                 switch (type) {
702                 case array_type:
703                 case object_type:
704                     result.l = env->functions->GetObjectField(env, obj, field);
705                     break;
706                 case boolean_type:
707                     result.z = env->functions->GetBooleanField(env, obj, field);
708                     break;
709                 case byte_type:
710                     result.b = env->functions->GetByteField(env, obj, field);
711                     break;
712                 case char_type:
713                     result.c = env->functions->GetCharField(env, obj, field);
714                     break;
715                 case short_type:
716                     result.s = env->functions->GetShortField(env, obj, field);
717                     break;
718                 case int_type:
719                     result.i = env->functions->GetIntField(env, obj, field);
720                     break;
721                 case long_type:
722                     result.j = env->functions->GetLongField(env, obj, field);
723                     break;
724                 case float_type:
725                     result.f = env->functions->GetFloatField(env, obj, field);
726                     break;
727                 case double_type:
728                     result.d = env->functions->GetDoubleField(env, obj, field);
729                     break;
730                 default:
731                     fprintf(stderr, "%s: invalid field type (%d)\n", __PRETTY_FUNCTION__, (int)type);
732                 }
733             }
734             else
735             {
736                 fprintf(stderr, "%s: Could not find field: %s\n", __PRETTY_FUNCTION__, name);
737                 env->ExceptionDescribe();
738                 env->ExceptionClear();
739                 fprintf (stderr, "\n");
740             }
741
742             env->DeleteLocalRef(cls);
743         }
744         else {
745             fprintf(stderr, "%s: Could not find class for object\n", __PRETTY_FUNCTION__);
746         }
747     }
748
749     return result;
750 }
751
752 static jobject convertArrayInstanceToJavaArray(ExecState *exec, JSValue *value, const char *javaClassName) {
753
754     ASSERT(JSLock::lockCount() > 0);
755     
756     JNIEnv *env = getJNIEnv();
757     // As JS Arrays can contain a mixture of objects, assume we can convert to
758     // the requested Java Array type requested, unless the array type is some object array
759     // other than a string.
760     ArrayInstance *jsArray = static_cast<ArrayInstance *>(value);
761     unsigned length = jsArray->getLength();
762     jobjectArray jarray = 0;
763     
764     // Build the correct array type
765     switch (JNITypeFromPrimitiveType(javaClassName[1])) { 
766         case object_type: {
767         // Only support string object types
768         if (0 == strcmp("[Ljava.lang.String;", javaClassName)) {
769             jarray = (jobjectArray)env->NewObjectArray(length,
770                 env->FindClass("java/lang/String"),
771                 env->NewStringUTF(""));
772             for(unsigned i = 0; i < length; i++) {
773                 JSValue* item = jsArray->getItem(i);
774                 UString stringValue = item->toString(exec);
775                 env->SetObjectArrayElement(jarray,i,
776                     env->functions->NewString(env, (const jchar *)stringValue.data(), stringValue.size()));
777                 }
778             }
779             break;
780         }
781         
782         case boolean_type: {
783             jarray = (jobjectArray)env->NewBooleanArray(length);
784             for(unsigned i = 0; i < length; i++) {
785                 JSValue* item = jsArray->getItem(i);
786                 jboolean value = (jboolean)item->toNumber(exec);
787                 env->SetBooleanArrayRegion((jbooleanArray)jarray, (jsize)i, (jsize)1, &value);
788             }
789             break;
790         }
791         
792         case byte_type: {
793             jarray = (jobjectArray)env->NewByteArray(length);
794             for(unsigned i = 0; i < length; i++) {
795                 JSValue* item = jsArray->getItem(i);
796                 jbyte value = (jbyte)item->toNumber(exec);
797                 env->SetByteArrayRegion((jbyteArray)jarray, (jsize)i, (jsize)1, &value);
798             }
799             break;
800         }
801
802         case char_type: {
803             jarray = (jobjectArray)env->NewCharArray(length);
804             for(unsigned i = 0; i < length; i++) {
805                 JSValue* item = jsArray->getItem(i);
806                 UString stringValue = item->toString(exec);
807                 jchar value = 0;
808                 if (stringValue.size() > 0)
809                     value = ((const jchar*)stringValue.data())[0];
810                 env->SetCharArrayRegion((jcharArray)jarray, (jsize)i, (jsize)1, &value);
811             }
812             break;
813         }
814
815         case short_type: {
816             jarray = (jobjectArray)env->NewShortArray(length);
817             for(unsigned i = 0; i < length; i++) {
818                 JSValue* item = jsArray->getItem(i);
819                 jshort value = (jshort)item->toNumber(exec);
820                 env->SetShortArrayRegion((jshortArray)jarray, (jsize)i, (jsize)1, &value);
821             }
822             break;
823         }
824
825         case int_type: {
826             jarray = (jobjectArray)env->NewIntArray(length);
827             for(unsigned i = 0; i < length; i++) {
828                 JSValue* item = jsArray->getItem(i);
829                 jint value = (jint)item->toNumber(exec);
830                 env->SetIntArrayRegion((jintArray)jarray, (jsize)i, (jsize)1, &value);
831             }
832             break;
833         }
834
835         case long_type: {
836             jarray = (jobjectArray)env->NewLongArray(length);
837             for(unsigned i = 0; i < length; i++) {
838                 JSValue* item = jsArray->getItem(i);
839                 jlong value = (jlong)item->toNumber(exec);
840                 env->SetLongArrayRegion((jlongArray)jarray, (jsize)i, (jsize)1, &value);
841             }
842             break;
843         }
844
845         case float_type: {
846             jarray = (jobjectArray)env->NewFloatArray(length);
847             for(unsigned i = 0; i < length; i++) {
848                 JSValue* item = jsArray->getItem(i);
849                 jfloat value = (jfloat)item->toNumber(exec);
850                 env->SetFloatArrayRegion((jfloatArray)jarray, (jsize)i, (jsize)1, &value);
851             }
852             break;
853         }
854     
855         case double_type: {
856             jarray = (jobjectArray)env->NewDoubleArray(length);
857             for(unsigned i = 0; i < length; i++) {
858                 JSValue* item = jsArray->getItem(i);
859                 jdouble value = (jdouble)item->toNumber(exec);
860                 env->SetDoubleArrayRegion((jdoubleArray)jarray, (jsize)i, (jsize)1, &value);
861             }
862             break;
863         }
864         
865         case array_type: // don't handle embedded arrays
866         case void_type: // Don't expect arrays of void objects
867         case invalid_type: // Array of unknown objects
868             break;
869     }
870     
871     // if it was not one of the cases handled, then null is returned
872     return jarray;
873 }
874
875
876 jvalue convertValueToJValue (ExecState *exec, JSValue *value, JNIType _JNIType, const char *javaClassName)
877 {
878     JSLock lock;
879     
880     jvalue result;
881    
882     switch (_JNIType){
883         case array_type:
884         case object_type: {
885             result.l = (jobject)0;
886             
887             // First see if we have a Java instance.
888             if (value->isObject()){
889                 JSObject *objectImp = static_cast<JSObject*>(value);
890                 if (objectImp->classInfo() == &RuntimeObjectImp::info) {
891                     RuntimeObjectImp *imp = static_cast<RuntimeObjectImp *>(value);
892                     JavaInstance *instance = static_cast<JavaInstance*>(imp->getInternalInstance());
893                     if (instance)
894                         result.l = instance->javaInstance();
895                 }
896                 else if (objectImp->classInfo() == &RuntimeArray::info) {
897                 // Input is a JavaScript Array that was originally created from a Java Array
898                     RuntimeArray *imp = static_cast<RuntimeArray *>(value);
899                     JavaArray *array = static_cast<JavaArray*>(imp->getConcreteArray());
900                     result.l = array->javaArray();
901                 } 
902                 else if (objectImp->classInfo() == &ArrayInstance::info) {
903                     // Input is a Javascript Array. We need to create it to a Java Array.
904                     result.l = convertArrayInstanceToJavaArray(exec, value, javaClassName);
905                 }
906             }
907             
908             // Now convert value to a string if the target type is a java.lang.string, and we're not
909             // converting from a Null.
910             if (result.l == 0 && strcmp(javaClassName, "java.lang.String") == 0) {
911 #ifdef CONVERT_NULL_TO_EMPTY_STRING
912                 if (value->isNull()) {
913                     JNIEnv *env = getJNIEnv();
914                     jchar buf[2];
915                     jobject javaString = env->functions->NewString (env, buf, 0);
916                     result.l = javaString;
917                 }
918                 else 
919 #else
920                 if (!value->isNull())
921 #endif
922                 {
923                     UString stringValue = value->toString(exec);
924                     JNIEnv *env = getJNIEnv();
925                     jobject javaString = env->functions->NewString (env, (const jchar *)stringValue.data(), stringValue.size());
926                     result.l = javaString;
927                 }
928             } else if (result.l == 0) 
929                 bzero (&result, sizeof(jvalue)); // Handle it the same as a void case
930         }
931         break;
932         
933         case boolean_type: {
934             result.z = (jboolean)value->toNumber(exec);
935         }
936         break;
937             
938         case byte_type: {
939             result.b = (jbyte)value->toNumber(exec);
940         }
941         break;
942         
943         case char_type: {
944             result.c = (jchar)value->toNumber(exec);
945         }
946         break;
947
948         case short_type: {
949             result.s = (jshort)value->toNumber(exec);
950         }
951         break;
952
953         case int_type: {
954             result.i = (jint)value->toNumber(exec);
955         }
956         break;
957
958         case long_type: {
959             result.j = (jlong)value->toNumber(exec);
960         }
961         break;
962
963         case float_type: {
964             result.f = (jfloat)value->toNumber(exec);
965         }
966         break;
967
968         case double_type: {
969             result.d = (jdouble)value->toNumber(exec);
970         }
971         break;
972             
973         break;
974
975         case invalid_type:
976         default:
977         case void_type: {
978             bzero (&result, sizeof(jvalue));
979         }
980         break;
981     }
982     return result;
983 }
984
985 }  // end of namespace Bindings
986
987 } // end of namespace KJS