The latest JPL from the anoncvs.
[p5sagit/p5-mst-13.2.git] / jpl / JNI / JNI.xs
1 /*\r
2  * Copyright 1997, O'Reilly & Associate, Inc.\r
3  *\r
4  * This package may be copied under the same terms as Perl itself.\r
5  */\r
6 \r
7 #include "EXTERN.h"\r
8 #include "perl.h"\r
9 #include "XSUB.h"\r
10 \r
11 #include <stdio.h>\r
12 #include <jni.h>\r
13 \r
14 #ifndef PERL_VERSION\r
15 #  include <patchlevel.h>\r
16 #  define PERL_REVISION         5\r
17 #  define PERL_VERSION          PATCHLEVEL\r
18 #  define PERL_SUBVERSION       SUBVERSION\r
19 #endif\r
20 \r
21 #if PERL_REVISION == 5 && (PERL_VERSION < 4 || (PERL_VERSION == 4 && PERL_SUBVERSION <= 75))\r
22 #  define PL_na         na\r
23 #  define PL_sv_no      sv_no\r
24 #  define PL_sv_undef   sv_undef\r
25 #  define PL_dowarn     dowarn\r
26 #endif\r
27 \r
28 #ifndef newSVpvn\r
29 #  define newSVpvn(a,b) newSVpv(a,b)\r
30 #endif\r
31 \r
32 #ifndef pTHX\r
33 #  define pTHX          void\r
34 #  define pTHX_\r
35 #  define aTHX\r
36 #  define aTHX_\r
37 #  define dTHX          extern int JNI___notused\r
38 #endif\r
39 \r
40 #ifndef WIN32\r
41 #  include <dlfcn.h>\r
42 #endif\r
43 \r
44 #ifdef EMBEDDEDPERL\r
45 extern JNIEnv* jplcurenv;\r
46 extern int jpldebug;\r
47 #else\r
48 JNIEnv* jplcurenv;\r
49 int jpldebug = 1;\r
50 #endif\r
51 \r
52 #define SysRet jint\r
53 \r
54 #ifdef WIN32\r
55 static void JNICALL call_my_exit(jint status)\r
56 {\r
57     my_exit(status);\r
58 }\r
59 #else\r
60 static void call_my_exit(jint status)\r
61 {\r
62     my_exit(status);\r
63 }\r
64 #endif\r
65 \r
66 jvalue*\r
67 makeargs(char *sig, SV** svp, int items)\r
68 {\r
69     jvalue* jv = (jvalue*)safemalloc(sizeof(jvalue) * items);\r
70     int ix = 0;\r
71     char *s = sig;\r
72     JNIEnv* env = jplcurenv;\r
73     char *start;\r
74     STRLEN n_a;\r
75 \r
76     if (jpldebug)\r
77         fprintf(stderr, "sig = %s, items = %d\n", sig, items);\r
78     if (*s++ != '(')\r
79         goto cleanup;\r
80 \r
81     while (items--) {\r
82         SV *sv = *svp++;\r
83         start = s;\r
84         switch (*s++) {\r
85         case 'Z':\r
86             jv[ix++].z = (jboolean)(SvIV(sv) != 0);\r
87             break;\r
88         case 'B':\r
89             jv[ix++].b = (jbyte)SvIV(sv);\r
90             break;\r
91         case 'C':\r
92             jv[ix++].c = (jchar)SvIV(sv);\r
93             break;\r
94         case 'S':\r
95             jv[ix++].s = (jshort)SvIV(sv);\r
96             break;\r
97         case 'I':\r
98             jv[ix++].i = (jint)SvIV(sv);\r
99             break;\r
100         case 'J':\r
101             jv[ix++].j = (jlong)SvNV(sv);\r
102             break;\r
103         case 'F':\r
104             jv[ix++].f = (jfloat)SvNV(sv);\r
105             break;\r
106         case 'D':\r
107             jv[ix++].d = (jdouble)SvNV(sv);\r
108             break;\r
109         case '[':\r
110             switch (*s++) {\r
111             case 'Z':\r
112                 if (SvROK(sv)) {\r
113                     SV* rv = (SV*)SvRV(sv);\r
114                     if (SvOBJECT(rv))\r
115                         jv[ix++].l = (jobject)(void*)SvIV(rv);\r
116                     else if (SvTYPE(rv) == SVt_PVAV) {\r
117                         jsize len = av_len((AV*)rv) + 1;\r
118                         jboolean* buf = (jboolean*)malloc(len * sizeof(jboolean));\r
119                         int i;\r
120                         SV** esv;\r
121 \r
122                         jbooleanArray ja = (*env)->NewBooleanArray(env, len);\r
123                         for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)\r
124                             buf[i] = (jboolean)SvIV(*esv);\r
125                         (*env)->SetBooleanArrayRegion(env, ja, 0, len, buf);\r
126                         free((void*)buf);\r
127                         jv[ix++].l = (jobject)ja;\r
128                     }\r
129                     else\r
130                         jv[ix++].l = (jobject)(void*)0;\r
131                 }\r
132                 else if (SvPOK(sv)) {\r
133                     jsize len = sv_len(sv) / sizeof(jboolean);\r
134 \r
135                     jbooleanArray ja = (*env)->NewBooleanArray(env, len);\r
136                     (*env)->SetBooleanArrayRegion(env, ja, 0, len, (jboolean*)SvPV(sv,n_a));\r
137                     jv[ix++].l = (jobject)ja;\r
138                 }\r
139                 else\r
140                     jv[ix++].l = (jobject)(void*)0;\r
141                 break;\r
142             case 'B':\r
143                 if (SvROK(sv)) {\r
144                     SV* rv = (SV*)SvRV(sv);\r
145                     if (SvOBJECT(rv))\r
146                         jv[ix++].l = (jobject)(void*)SvIV(rv);\r
147                     else if (SvTYPE(rv) == SVt_PVAV) {\r
148                         jsize len = av_len((AV*)rv) + 1;\r
149                         jbyte* buf = (jbyte*)malloc(len * sizeof(jbyte));\r
150                         int i;\r
151                         SV** esv;\r
152 \r
153                         jbyteArray ja = (*env)->NewByteArray(env, len);\r
154                         for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)\r
155                             buf[i] = (jbyte)SvIV(*esv);\r
156                         (*env)->SetByteArrayRegion(env, ja, 0, len, buf);\r
157                         free((void*)buf);\r
158                         jv[ix++].l = (jobject)ja;\r
159                     }\r
160                     else\r
161                         jv[ix++].l = (jobject)(void*)0;\r
162                 }\r
163                 else if (SvPOK(sv)) {\r
164                     jsize len = sv_len(sv) / sizeof(jbyte);\r
165 \r
166                     jbyteArray ja = (*env)->NewByteArray(env, len);\r
167                     (*env)->SetByteArrayRegion(env, ja, 0, len, (jbyte*)SvPV(sv,n_a));\r
168                     jv[ix++].l = (jobject)ja;\r
169                 }\r
170                 else\r
171                     jv[ix++].l = (jobject)(void*)0;\r
172                 break;\r
173             case 'C':\r
174                 if (SvROK(sv)) {\r
175                     SV* rv = (SV*)SvRV(sv);\r
176                     if (SvOBJECT(rv))\r
177                         jv[ix++].l = (jobject)(void*)SvIV(rv);\r
178                     else if (SvTYPE(rv) == SVt_PVAV) {\r
179                         jsize len = av_len((AV*)rv) + 1;\r
180                         jchar* buf = (jchar*)malloc(len * sizeof(jchar));\r
181                         int i;\r
182                         SV** esv;\r
183 \r
184                         jcharArray ja = (*env)->NewCharArray(env, len);\r
185                         for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)\r
186                             buf[i] = (jchar)SvIV(*esv);\r
187                         (*env)->SetCharArrayRegion(env, ja, 0, len, buf);\r
188                         free((void*)buf);\r
189                         jv[ix++].l = (jobject)ja;\r
190                     }\r
191                     else\r
192                         jv[ix++].l = (jobject)(void*)0;\r
193                 }\r
194                 else if (SvPOK(sv)) {\r
195                     jsize len = sv_len(sv) / sizeof(jchar);\r
196 \r
197                     jcharArray ja = (*env)->NewCharArray(env, len);\r
198                     (*env)->SetCharArrayRegion(env, ja, 0, len, (jchar*)SvPV(sv,n_a));\r
199                     jv[ix++].l = (jobject)ja;\r
200                 }\r
201                 else\r
202                     jv[ix++].l = (jobject)(void*)0;\r
203                 break;\r
204             case 'S':\r
205                 if (SvROK(sv)) {\r
206                     SV* rv = (SV*)SvRV(sv);\r
207                     if (SvOBJECT(rv))\r
208                         jv[ix++].l = (jobject)(void*)SvIV(rv);\r
209                     else if (SvTYPE(rv) == SVt_PVAV) {\r
210                         jsize len = av_len((AV*)rv) + 1;\r
211                         jshort* buf = (jshort*)malloc(len * sizeof(jshort));\r
212                         int i;\r
213                         SV** esv;\r
214 \r
215                         jshortArray ja = (*env)->NewShortArray(env, len);\r
216                         for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)\r
217                             buf[i] = (jshort)SvIV(*esv);\r
218                         (*env)->SetShortArrayRegion(env, ja, 0, len, buf);\r
219                         free((void*)buf);\r
220                         jv[ix++].l = (jobject)ja;\r
221                     }\r
222                     else\r
223                         jv[ix++].l = (jobject)(void*)0;\r
224                 }\r
225                 else if (SvPOK(sv)) {\r
226                     jsize len = sv_len(sv) / sizeof(jshort);\r
227 \r
228                     jshortArray ja = (*env)->NewShortArray(env, len);\r
229                     (*env)->SetShortArrayRegion(env, ja, 0, len, (jshort*)SvPV(sv,n_a));\r
230                     jv[ix++].l = (jobject)ja;\r
231                 }\r
232                 else\r
233                     jv[ix++].l = (jobject)(void*)0;\r
234                 break;\r
235             case 'I':\r
236                 if (SvROK(sv)) {\r
237                     SV* rv = (SV*)SvRV(sv);\r
238                     if (SvOBJECT(rv))\r
239                         jv[ix++].l = (jobject)(void*)SvIV(rv);\r
240                     else if (SvTYPE(rv) == SVt_PVAV) {\r
241                         jsize len = av_len((AV*)rv) + 1;\r
242                         jint* buf = (jint*)malloc(len * sizeof(jint));\r
243                         int i;\r
244                         SV** esv;\r
245 \r
246                         jintArray ja = (*env)->NewIntArray(env, len);\r
247                         for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)\r
248                             buf[i] = (jint)SvIV(*esv);\r
249                         (*env)->SetIntArrayRegion(env, ja, 0, len, buf);\r
250                         free((void*)buf);\r
251                         jv[ix++].l = (jobject)ja;\r
252                     }\r
253                     else\r
254                         jv[ix++].l = (jobject)(void*)0;\r
255                 }\r
256                 else if (SvPOK(sv)) {\r
257                     jsize len = sv_len(sv) / sizeof(jint);\r
258 \r
259                     jintArray ja = (*env)->NewIntArray(env, len);\r
260                     (*env)->SetIntArrayRegion(env, ja, 0, len, (jint*)SvPV(sv,n_a));\r
261                     jv[ix++].l = (jobject)ja;\r
262                 }\r
263                 else\r
264                     jv[ix++].l = (jobject)(void*)0;\r
265                 break;\r
266             case 'J':\r
267                 if (SvROK(sv)) {\r
268                     SV* rv = (SV*)SvRV(sv);\r
269                     if (SvOBJECT(rv))\r
270                         jv[ix++].l = (jobject)(void*)SvIV(rv);\r
271                     else if (SvTYPE(rv) == SVt_PVAV) {\r
272                         jsize len = av_len((AV*)rv) + 1;\r
273                         jlong* buf = (jlong*)malloc(len * sizeof(jlong));\r
274                         int i;\r
275                         SV** esv;\r
276 \r
277                         jlongArray ja = (*env)->NewLongArray(env, len);\r
278                         for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)\r
279                             buf[i] = (jlong)SvNV(*esv);\r
280                         (*env)->SetLongArrayRegion(env, ja, 0, len, buf);\r
281                         free((void*)buf);\r
282                         jv[ix++].l = (jobject)ja;\r
283                     }\r
284                     else\r
285                         jv[ix++].l = (jobject)(void*)0;\r
286                 }\r
287                 else if (SvPOK(sv)) {\r
288                     jsize len = sv_len(sv) / sizeof(jlong);\r
289 \r
290                     jlongArray ja = (*env)->NewLongArray(env, len);\r
291                     (*env)->SetLongArrayRegion(env, ja, 0, len, (jlong*)SvPV(sv,n_a));\r
292                     jv[ix++].l = (jobject)ja;\r
293                 }\r
294                 else\r
295                     jv[ix++].l = (jobject)(void*)0;\r
296                 break;\r
297             case 'F':\r
298                 if (SvROK(sv)) {\r
299                     SV* rv = (SV*)SvRV(sv);\r
300                     if (SvOBJECT(rv))\r
301                         jv[ix++].l = (jobject)(void*)SvIV(rv);\r
302                     else if (SvTYPE(rv) == SVt_PVAV) {\r
303                         jsize len = av_len((AV*)rv) + 1;\r
304                         jfloat* buf = (jfloat*)malloc(len * sizeof(jfloat));\r
305                         int i;\r
306                         SV** esv;\r
307 \r
308                         jfloatArray ja = (*env)->NewFloatArray(env, len);\r
309                         for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)\r
310                             buf[i] = (jfloat)SvNV(*esv);\r
311                         (*env)->SetFloatArrayRegion(env, ja, 0, len, buf);\r
312                         free((void*)buf);\r
313                         jv[ix++].l = (jobject)ja;\r
314                     }\r
315                     else\r
316                         jv[ix++].l = (jobject)(void*)0;\r
317                 }\r
318                 else if (SvPOK(sv)) {\r
319                     jsize len = sv_len(sv) / sizeof(jfloat);\r
320 \r
321                     jfloatArray ja = (*env)->NewFloatArray(env, len);\r
322                     (*env)->SetFloatArrayRegion(env, ja, 0, len, (jfloat*)SvPV(sv,n_a));\r
323                     jv[ix++].l = (jobject)ja;\r
324                 }\r
325                 else\r
326                     jv[ix++].l = (jobject)(void*)0;\r
327                 break;\r
328             case 'D':\r
329                 if (SvROK(sv)) {\r
330                     SV* rv = (SV*)SvRV(sv);\r
331                     if (SvOBJECT(rv))\r
332                         jv[ix++].l = (jobject)(void*)SvIV(rv);\r
333                     else if (SvTYPE(rv) == SVt_PVAV) {\r
334                         jsize len = av_len((AV*)rv) + 1;\r
335                         jdouble* buf = (jdouble*)malloc(len * sizeof(jdouble));\r
336                         int i;\r
337                         SV** esv;\r
338 \r
339                         jdoubleArray ja = (*env)->NewDoubleArray(env, len);\r
340                         for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)\r
341                             buf[i] = (jdouble)SvNV(*esv);\r
342                         (*env)->SetDoubleArrayRegion(env, ja, 0, len, buf);\r
343                         free((void*)buf);\r
344                         jv[ix++].l = (jobject)ja;\r
345                     }\r
346                     else\r
347                         jv[ix++].l = (jobject)(void*)0;\r
348                 }\r
349                 else if (SvPOK(sv)) {\r
350                     jsize len = sv_len(sv) / sizeof(jdouble);\r
351 \r
352                     jdoubleArray ja = (*env)->NewDoubleArray(env, len);\r
353                     (*env)->SetDoubleArrayRegion(env, ja, 0, len, (jdouble*)SvPV(sv,n_a));\r
354                     jv[ix++].l = (jobject)ja;\r
355                 }\r
356                 else\r
357                     jv[ix++].l = (jobject)(void*)0;\r
358                 break;\r
359             case 'L':\r
360                 while (*s != ';') s++;\r
361                 s++;\r
362                 if (strnEQ(start, "[Ljava/lang/String;", 19)) {\r
363                     if (SvROK(sv)) {\r
364                         SV* rv = (SV*)SvRV(sv);\r
365                         if (SvOBJECT(rv))\r
366                             jv[ix++].l = (jobject)(void*)SvIV(rv);\r
367                         else if (SvTYPE(rv) == SVt_PVAV) {\r
368                             jsize len = av_len((AV*)rv) + 1;\r
369                             int i;\r
370                             SV** esv;\r
371                             static jclass jcl = 0;\r
372                             jobjectArray ja;\r
373 \r
374                             if (!jcl)\r
375                                 jcl = (*env)->FindClass(env, "java/lang/String");\r
376                             ja = (*env)->NewObjectArray(env, len, jcl, 0);\r
377                             for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++) {\r
378                                 jobject str = (jobject)(*env)->NewStringUTF(env, SvPV(*esv,n_a));\r
379                                 (*env)->SetObjectArrayElement(env, ja, i, str);\r
380                             }\r
381                             jv[ix++].l = (jobject)ja;\r
382                         }\r
383                         else\r
384                             jv[ix++].l = (jobject)(void*)0;\r
385                     }\r
386                     else\r
387                         jv[ix++].l = (jobject)(void*)0;\r
388                     break;\r
389                 }\r
390                 /* FALL THROUGH */\r
391             default:\r
392                 if (SvROK(sv)) {\r
393                     SV* rv = (SV*)SvRV(sv);\r
394                     if (SvOBJECT(rv))\r
395                         jv[ix++].l = (jobject)(void*)SvIV(rv);\r
396                     else if (SvTYPE(rv) == SVt_PVAV) {\r
397                         jsize len = av_len((AV*)rv) + 1;\r
398                         int i;\r
399                         SV** esv;\r
400                        static jclass jcl = 0;\r
401                         jobjectArray ja;\r
402 \r
403                         if (!jcl)\r
404                             jcl = (*env)->FindClass(env, "java/lang/Object");\r
405                         ja = (*env)->NewObjectArray(env, len, jcl, 0);\r
406                         for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++) {\r
407                             if (SvROK(*esv) && (rv = SvRV(*esv)) && SvOBJECT(rv)) {\r
408                                 (*env)->SetObjectArrayElement(env, ja, i, (jobject)(void*)SvIV(rv));\r
409                             }\r
410                             else {\r
411                                 jobject str = (jobject)(*env)->NewStringUTF(env, SvPV(*esv,n_a));\r
412                                 (*env)->SetObjectArrayElement(env, ja, i, str);\r
413                             }\r
414                         }\r
415                         jv[ix++].l = (jobject)ja;\r
416                     }\r
417                     else\r
418                         jv[ix++].l = (jobject)(void*)0;\r
419                 }\r
420                 else\r
421                     jv[ix++].l = (jobject)(void*)0;\r
422                 break;\r
423             }\r
424             break;\r
425         case 'L':\r
426             if (!SvROK(sv) || strnEQ(s, "java/lang/String;", 17)) {\r
427                 s += 17;\r
428                 jv[ix++].l = (jobject)(*env)->NewStringUTF(env, (char*) SvPV(sv,n_a));\r
429                 break;\r
430             }\r
431             while (*s != ';') s++;\r
432             s++;\r
433             if (SvROK(sv)) {\r
434                 SV* rv = SvRV(sv);\r
435                 jv[ix++].l = (jobject)(void*)SvIV(rv);\r
436             }\r
437             break;\r
438         case ')':\r
439             croak("too many arguments, signature: %s", sig);\r
440             goto cleanup;\r
441         default:\r
442             croak("panic: malformed signature: %s", s-1);\r
443             goto cleanup;\r
444         }\r
445 \r
446     }\r
447     if (*s != ')') {\r
448         croak("not enough arguments, signature: %s", sig);\r
449         goto cleanup;\r
450     }\r
451     return jv;\r
452 \r
453 cleanup:\r
454     safefree((char*)jv);\r
455     return 0;\r
456 }\r
457 \r
458 static int\r
459 not_here(char *s)\r
460 {\r
461     croak("%s not implemented on this architecture", s);\r
462     return -1;\r
463 }\r
464 \r
465 static double\r
466 constant(char *name, int arg)\r
467 {\r
468     errno = 0;\r
469     switch (*name) {\r
470     case 'A':\r
471         break;\r
472     case 'B':\r
473         break;\r
474     case 'C':\r
475         break;\r
476     case 'D':\r
477         break;\r
478     case 'E':\r
479         break;\r
480     case 'F':\r
481         break;\r
482     case 'G':\r
483         break;\r
484     case 'H':\r
485         break;\r
486     case 'I':\r
487         break;\r
488     case 'J':\r
489         if (strEQ(name, "JNI_ABORT"))\r
490 #ifdef JNI_ABORT\r
491             return JNI_ABORT;\r
492 #else\r
493             goto not_there;\r
494 #endif\r
495         if (strEQ(name, "JNI_COMMIT"))\r
496 #ifdef JNI_COMMIT\r
497             return JNI_COMMIT;\r
498 #else\r
499             goto not_there;\r
500 #endif\r
501         if (strEQ(name, "JNI_ERR"))\r
502 #ifdef JNI_ERR\r
503             return JNI_ERR;\r
504 #else\r
505             goto not_there;\r
506 #endif\r
507         if (strEQ(name, "JNI_FALSE"))\r
508 #ifdef JNI_FALSE\r
509             return JNI_FALSE;\r
510 #else\r
511             goto not_there;\r
512 #endif\r
513         if (strEQ(name, "JNI_H"))\r
514 #ifdef JNI_H\r
515 #ifdef WIN32\r
516             return 1;\r
517 #else\r
518             return JNI_H;\r
519 #endif\r
520 #else\r
521             goto not_there;\r
522 #endif\r
523         if (strEQ(name, "JNI_OK"))\r
524 #ifdef JNI_OK\r
525             return JNI_OK;\r
526 #else\r
527             goto not_there;\r
528 #endif\r
529         if (strEQ(name, "JNI_TRUE"))\r
530 #ifdef JNI_TRUE\r
531             return JNI_TRUE;\r
532 #else\r
533             goto not_there;\r
534 #endif\r
535         break;\r
536     case 'K':\r
537         break;\r
538     case 'L':\r
539         break;\r
540     case 'M':\r
541         break;\r
542     case 'N':\r
543         break;\r
544     case 'O':\r
545         break;\r
546     case 'P':\r
547         break;\r
548     case 'Q':\r
549         break;\r
550     case 'R':\r
551         break;\r
552     case 'S':\r
553         break;\r
554     case 'T':\r
555         break;\r
556     case 'U':\r
557         break;\r
558     case 'V':\r
559         break;\r
560     case 'W':\r
561         break;\r
562     case 'X':\r
563         break;\r
564     case 'Y':\r
565         break;\r
566     case 'Z':\r
567         break;\r
568     }\r
569     errno = EINVAL;\r
570     return 0;\r
571 \r
572 not_there:\r
573     errno = ENOENT;\r
574     return 0;\r
575 }\r
576 \r
577 #define FETCHENV jplcurenv\r
578 #define RESTOREENV jplcurenv = env\r
579 \r
580 MODULE = JNI            PACKAGE = JNI           \r
581 \r
582 PROTOTYPES: ENABLE\r
583 \r
584 double\r
585 constant(name,arg)\r
586         char *          name\r
587         int             arg\r
588 \r
589 jint\r
590 GetVersion()\r
591         JNIEnv *                env = FETCHENV;\r
592     CODE:\r
593         {\r
594             RETVAL = (*env)->GetVersion(env);\r
595             RESTOREENV;\r
596         }\r
597     OUTPUT:\r
598         RETVAL\r
599 \r
600 jclass\r
601 DefineClass(name, loader, buf)\r
602         JNIEnv *                env = FETCHENV;\r
603         STRLEN                  tmplen = NO_INIT;\r
604         jsize                   buf_len_ = NO_INIT;\r
605         const char *            name\r
606         jobject                 loader\r
607         const jbyte *           buf\r
608     CODE:\r
609         {\r
610 #ifdef KAFFE\r
611             RETVAL = (*env)->DefineClass(env,  loader, buf, (jsize)buf_len_);\r
612 #else\r
613             RETVAL = (*env)->DefineClass(env,  name, loader, buf, (jsize)buf_len_); \r
614 #endif\r
615             RESTOREENV;\r
616         }\r
617     OUTPUT:\r
618         RETVAL\r
619 \r
620 jclass\r
621 FindClass(name)\r
622         JNIEnv *                env = FETCHENV;\r
623         const char *            name\r
624     CODE:\r
625         {\r
626             RETVAL = (*env)->FindClass(env,  name);\r
627             RESTOREENV;\r
628         }\r
629     OUTPUT:\r
630         RETVAL\r
631 \r
632 jclass\r
633 GetSuperclass(sub)\r
634         JNIEnv *                env = FETCHENV;\r
635         jclass                  sub\r
636     CODE:\r
637         {\r
638             RETVAL = (*env)->GetSuperclass(env,  sub);\r
639             RESTOREENV;\r
640         }\r
641     OUTPUT:\r
642         RETVAL\r
643 \r
644 jboolean\r
645 IsAssignableFrom(sub, sup)\r
646         JNIEnv *                env = FETCHENV;\r
647         jclass                  sub\r
648         jclass                  sup\r
649     CODE:\r
650         {\r
651             RETVAL = (*env)->IsAssignableFrom(env,  sub, sup);\r
652             RESTOREENV;\r
653         }\r
654     OUTPUT:\r
655         RETVAL\r
656 \r
657 SysRet\r
658 Throw(obj)\r
659         JNIEnv *                env = FETCHENV;\r
660         jthrowable              obj\r
661     CODE:\r
662         {\r
663             RETVAL = (*env)->Throw(env,  obj);\r
664             RESTOREENV;\r
665         }\r
666     OUTPUT:\r
667         RETVAL    \r
668 \r
669 SysRet\r
670 ThrowNew(clazz, msg)\r
671         JNIEnv *                env = FETCHENV;\r
672         jclass                  clazz\r
673         const char *            msg\r
674     CODE:\r
675         {\r
676             RETVAL = (*env)->ThrowNew(env,  clazz, msg);\r
677             RESTOREENV;\r
678         }\r
679     OUTPUT:\r
680         RETVAL\r
681 \r
682 jthrowable\r
683 ExceptionOccurred()\r
684         JNIEnv *                env = FETCHENV;\r
685     CODE:\r
686         {\r
687             RETVAL = (*env)->ExceptionOccurred(env);\r
688             RESTOREENV;\r
689         }\r
690     OUTPUT:\r
691         RETVAL\r
692 \r
693 void\r
694 ExceptionDescribe()\r
695         JNIEnv *                env = FETCHENV;\r
696     CODE:\r
697         {\r
698             (*env)->ExceptionDescribe(env);\r
699             RESTOREENV;\r
700         }\r
701 \r
702 void\r
703 ExceptionClear()\r
704         JNIEnv *                env = FETCHENV;\r
705     CODE:\r
706         {\r
707             (*env)->ExceptionClear(env);\r
708             RESTOREENV;\r
709         }\r
710 \r
711 void\r
712 FatalError(msg)\r
713         JNIEnv *                env = FETCHENV;\r
714         const char *            msg\r
715     CODE:\r
716         {\r
717             (*env)->FatalError(env,  msg);\r
718             RESTOREENV;\r
719         }\r
720 \r
721 jobject\r
722 NewGlobalRef(lobj)\r
723         JNIEnv *                env = FETCHENV;\r
724         jobject                 lobj\r
725     CODE:\r
726         {\r
727             RETVAL = (*env)->NewGlobalRef(env, lobj);\r
728             RESTOREENV;\r
729         }\r
730     OUTPUT:\r
731         RETVAL\r
732 \r
733 void\r
734 DeleteGlobalRef(gref)\r
735         JNIEnv *                env = FETCHENV;\r
736         jobject                 gref\r
737     CODE:\r
738         {\r
739             (*env)->DeleteGlobalRef(env, gref);\r
740             RESTOREENV;\r
741         }\r
742 \r
743 void\r
744 DeleteLocalRef(obj)\r
745         JNIEnv *                env = FETCHENV;\r
746         jobject                 obj\r
747     CODE:\r
748         {\r
749             (*env)->DeleteLocalRef(env,  obj);\r
750             RESTOREENV;\r
751         }\r
752 \r
753 jboolean\r
754 IsSameObject(obj1,obj2)\r
755         JNIEnv *                env = FETCHENV;\r
756         jobject                 obj1\r
757         jobject                 obj2\r
758     CODE:\r
759         {\r
760             RETVAL = (*env)->IsSameObject(env, obj1,obj2);\r
761             RESTOREENV;\r
762         }\r
763     OUTPUT:\r
764         RETVAL\r
765 \r
766 jobject\r
767 AllocObject(clazz)\r
768         JNIEnv *                env = FETCHENV;\r
769         jclass                  clazz\r
770     CODE:\r
771         {\r
772             RETVAL = (*env)->AllocObject(env, clazz);\r
773             RESTOREENV;\r
774         }\r
775     OUTPUT:\r
776         RETVAL\r
777 \r
778 jobject\r
779 NewObject(clazz,methodID,...)\r
780         JNIEnv *                env = FETCHENV;\r
781         jclass                  clazz\r
782         jmethodID               methodID\r
783         char *                  sig = 0;\r
784         int                     argoff = $min_args;\r
785     CODE:\r
786         {\r
787             jvalue * args = makeargs(sig, &ST(argoff), items - argoff);\r
788             RETVAL = (*env)->NewObjectA(env, clazz,methodID,args);\r
789             RESTOREENV;\r
790         }\r
791     OUTPUT:\r
792         RETVAL\r
793 \r
794 jobject\r
795 NewObjectA(clazz,methodID,args)\r
796         JNIEnv *                env = FETCHENV;\r
797         jclass                  clazz\r
798         jmethodID               methodID\r
799         char *                  sig = 0;\r
800         jvalue *                args\r
801     CODE:\r
802         {\r
803             RETVAL = (*env)->NewObjectA(env, clazz,methodID,args);\r
804             RESTOREENV;\r
805         }\r
806     OUTPUT:\r
807         RETVAL\r
808 \r
809 jclass\r
810 GetObjectClass(obj)\r
811         JNIEnv *                env = FETCHENV;\r
812         jobject                 obj\r
813     CODE:\r
814         {\r
815             RETVAL = (*env)->GetObjectClass(env, obj);\r
816             RESTOREENV;\r
817         }\r
818     OUTPUT:\r
819         RETVAL\r
820 \r
821 jboolean\r
822 IsInstanceOf(obj,clazz)\r
823         JNIEnv *                env = FETCHENV;\r
824         jobject                 obj\r
825         jclass                  clazz\r
826     CODE:\r
827         {\r
828             RETVAL = (*env)->IsInstanceOf(env, obj,clazz);\r
829             RESTOREENV;\r
830         }\r
831     OUTPUT:\r
832         RETVAL\r
833 \r
834 jmethodID\r
835 GetMethodID(clazz,name,sig)\r
836         JNIEnv *                env = FETCHENV;\r
837         jclass                  clazz\r
838         const char *            name\r
839         const char *            sig\r
840     CODE:\r
841         {\r
842             RETVAL = (*env)->GetMethodID(env, clazz,name,sig);\r
843             RESTOREENV;\r
844         }\r
845     OUTPUT:\r
846         RETVAL\r
847 \r
848 jobject\r
849 CallObjectMethod(obj,methodID,...)\r
850         JNIEnv *                env = FETCHENV;\r
851         jobject                 obj\r
852         jmethodID               methodID\r
853         char *                  sig = 0;\r
854         int                     argoff = $min_args;\r
855     CODE:\r
856         {\r
857             jvalue * args = makeargs(sig, &ST(argoff), items - argoff);\r
858             RETVAL = (*env)->CallObjectMethodA(env, obj,methodID,args);\r
859             RESTOREENV;\r
860         }\r
861     OUTPUT:\r
862         RETVAL\r
863 \r
864 jobject\r
865 CallObjectMethodA(obj,methodID,args)\r
866         JNIEnv *                env = FETCHENV;\r
867         jobject                 obj\r
868         jmethodID               methodID\r
869         char *                  sig = 0;\r
870         jvalue *                args\r
871     CODE:\r
872         {\r
873             RETVAL = (*env)->CallObjectMethodA(env, obj,methodID,args);\r
874             RESTOREENV;\r
875         }\r
876     OUTPUT:\r
877         RETVAL\r
878 \r
879 jboolean\r
880 CallBooleanMethod(obj,methodID,...)\r
881         JNIEnv *                env = FETCHENV;\r
882         jobject                 obj\r
883         jmethodID               methodID\r
884         char *                  sig = 0;\r
885         int                     argoff = $min_args;\r
886     CODE:\r
887         {\r
888             jvalue * args = makeargs(sig, &ST(argoff), items - argoff);\r
889             RETVAL = (*env)->CallBooleanMethodA(env, obj,methodID,args);\r
890             RESTOREENV;\r
891         }\r
892     OUTPUT:\r
893         RETVAL\r
894 \r
895 jboolean\r
896 CallBooleanMethodA(obj,methodID, args)\r
897         JNIEnv *                env = FETCHENV;\r
898         jobject                 obj\r
899         jmethodID               methodID\r
900         char *                  sig = 0;\r
901         jvalue *                args\r
902     CODE:\r
903         {\r
904             RETVAL = (*env)->CallBooleanMethodA(env, obj,methodID, args);\r
905             RESTOREENV;\r
906         }\r
907     OUTPUT:\r
908         RETVAL\r
909 \r
910 jbyte\r
911 CallByteMethod(obj,methodID,...)\r
912         JNIEnv *                env = FETCHENV;\r
913         jobject                 obj\r
914         jmethodID               methodID\r
915         char *                  sig = 0;\r
916         int                     argoff = $min_args;\r
917     CODE:\r
918         {\r
919             jvalue * args = makeargs(sig, &ST(argoff), items - argoff);\r
920             RETVAL = (*env)->CallByteMethodA(env, obj,methodID,args);\r
921             RESTOREENV;\r
922         }\r
923     OUTPUT:\r
924         RETVAL\r
925 \r
926 jbyte\r
927 CallByteMethodA(obj,methodID,args)\r
928         JNIEnv *                env = FETCHENV;\r
929         jobject                 obj\r
930         jmethodID               methodID\r
931         char *                  sig = 0;\r
932         jvalue *                args\r
933     CODE:\r
934         {\r
935             RETVAL = (*env)->CallByteMethodA(env, obj,methodID,args);\r
936             RESTOREENV;\r
937         }\r
938     OUTPUT:\r
939         RETVAL\r
940 \r
941 jchar\r
942 CallCharMethod(obj,methodID,...)\r
943         JNIEnv *                env = FETCHENV;\r
944         jobject                 obj\r
945         jmethodID               methodID\r
946         char *                  sig = 0;\r
947         int                     argoff = $min_args;\r
948     CODE:\r
949         {\r
950             jvalue * args = makeargs(sig, &ST(argoff), items - argoff);\r
951             RETVAL = (*env)->CallCharMethodA(env, obj,methodID,args);\r
952             RESTOREENV;\r
953         }\r
954     OUTPUT:\r
955         RETVAL\r
956 \r
957 jchar\r
958 CallCharMethodA(obj,methodID,args)\r
959         JNIEnv *                env = FETCHENV;\r
960         jobject                 obj\r
961         jmethodID               methodID\r
962         char *                  sig = 0;\r
963         jvalue *                args\r
964     CODE:\r
965         {\r
966             RETVAL = (*env)->CallCharMethodA(env, obj,methodID,args);\r
967             RESTOREENV;\r
968         }\r
969     OUTPUT:\r
970         RETVAL\r
971 \r
972 jshort\r
973 CallShortMethod(obj,methodID,...)\r
974         JNIEnv *                env = FETCHENV;\r
975         jobject                 obj\r
976         jmethodID               methodID\r
977         char *                  sig = 0;\r
978         int                     argoff = $min_args;\r
979     CODE:\r
980         {\r
981             jvalue * args = makeargs(sig, &ST(argoff), items - argoff);\r
982             RETVAL = (*env)->CallShortMethodA(env, obj,methodID,args);\r
983             RESTOREENV;\r
984         }\r
985     OUTPUT:\r
986         RETVAL\r
987 \r
988 jshort\r
989 CallShortMethodA(obj,methodID,args)\r
990         JNIEnv *                env = FETCHENV;\r
991         jobject                 obj\r
992         jmethodID               methodID\r
993         char *                  sig = 0;\r
994         jvalue *                args\r
995     CODE:\r
996         {\r
997             RETVAL = (*env)->CallShortMethodA(env, obj,methodID,args);\r
998             RESTOREENV;\r
999         }\r
1000     OUTPUT:\r
1001         RETVAL\r
1002 \r
1003 jint\r
1004 CallIntMethod(obj,methodID,...)\r
1005         JNIEnv *                env = FETCHENV;\r
1006         jobject                 obj\r
1007         jmethodID               methodID\r
1008         char *                  sig = 0;\r
1009         int                     argoff = $min_args;\r
1010     CODE:\r
1011         {\r
1012             jvalue * args = makeargs(sig, &ST(argoff), items - argoff);\r
1013             RETVAL = (*env)->CallIntMethodA(env, obj,methodID,args);\r
1014             RESTOREENV;\r
1015         }\r
1016     OUTPUT:\r
1017         RETVAL\r
1018 \r
1019 jint\r
1020 CallIntMethodA(obj,methodID,args)\r
1021         JNIEnv *                env = FETCHENV;\r
1022         jobject                 obj\r
1023         jmethodID               methodID\r
1024         char *                  sig = 0;\r
1025         jvalue *                args\r
1026     CODE:\r
1027         {\r
1028             RETVAL = (*env)->CallIntMethodA(env, obj,methodID,args);\r
1029             RESTOREENV;\r
1030         }\r
1031     OUTPUT:\r
1032         RETVAL\r
1033 \r
1034 jlong\r
1035 CallLongMethod(obj,methodID,...)\r
1036         JNIEnv *                env = FETCHENV;\r
1037         jobject                 obj\r
1038         jmethodID               methodID\r
1039         char *                  sig = 0;\r
1040         int                     argoff = $min_args;\r
1041     CODE:\r
1042         {\r
1043             jvalue * args = makeargs(sig, &ST(argoff), items - argoff);\r
1044             RETVAL = (*env)->CallLongMethodA(env, obj,methodID,args);\r
1045             RESTOREENV;\r
1046         }\r
1047     OUTPUT:\r
1048         RETVAL\r
1049 \r
1050 jlong\r
1051 CallLongMethodA(obj,methodID,args)\r
1052         JNIEnv *                env = FETCHENV;\r
1053         jobject                 obj\r
1054         jmethodID               methodID\r
1055         char *                  sig = 0;\r
1056         jvalue *                args\r
1057     CODE:\r
1058         {\r
1059             RETVAL = (*env)->CallLongMethodA(env, obj,methodID,args);\r
1060             RESTOREENV;\r
1061         }\r
1062     OUTPUT:\r
1063         RETVAL\r
1064 \r
1065 jfloat\r
1066 CallFloatMethod(obj,methodID,...)\r
1067         JNIEnv *                env = FETCHENV;\r
1068         jobject                 obj\r
1069         jmethodID               methodID\r
1070         char *                  sig = 0;\r
1071         int                     argoff = $min_args;\r
1072     CODE:\r
1073         {\r
1074             jvalue * args = makeargs(sig, &ST(argoff), items - argoff);\r
1075             RETVAL = (*env)->CallFloatMethodA(env, obj,methodID,args);\r
1076             RESTOREENV;\r
1077         }\r
1078     OUTPUT:\r
1079         RETVAL\r
1080 \r
1081 jfloat\r
1082 CallFloatMethodA(obj,methodID,args)\r
1083         JNIEnv *                env = FETCHENV;\r
1084         jobject                 obj\r
1085         jmethodID               methodID\r
1086         char *                  sig = 0;\r
1087         jvalue *                args\r
1088     CODE:\r
1089         {\r
1090             RETVAL = (*env)->CallFloatMethodA(env, obj,methodID,args);\r
1091             RESTOREENV;\r
1092         }\r
1093     OUTPUT:\r
1094         RETVAL\r
1095 \r
1096 jdouble\r
1097 CallDoubleMethod(obj,methodID,...)\r
1098         JNIEnv *                env = FETCHENV;\r
1099         jobject                 obj\r
1100         jmethodID               methodID\r
1101         char *                  sig = 0;\r
1102         int                     argoff = $min_args;\r
1103     CODE:\r
1104         {\r
1105             jvalue * args = makeargs(sig, &ST(argoff), items - argoff);\r
1106             RETVAL = (*env)->CallDoubleMethodA(env, obj,methodID,args);\r
1107             RESTOREENV;\r
1108         }\r
1109     OUTPUT:\r
1110         RETVAL\r
1111 \r
1112 jdouble\r
1113 CallDoubleMethodA(obj,methodID,args)\r
1114         JNIEnv *                env = FETCHENV;\r
1115         jobject                 obj\r
1116         jmethodID               methodID\r
1117         char *                  sig = 0;\r
1118         jvalue *                args\r
1119     CODE:\r
1120         {\r
1121             RETVAL = (*env)->CallDoubleMethodA(env, obj,methodID,args);\r
1122             RESTOREENV;\r
1123         }\r
1124     OUTPUT:\r
1125         RETVAL\r
1126 \r
1127 void\r
1128 CallVoidMethod(obj,methodID,...)\r
1129         JNIEnv *                env = FETCHENV;\r
1130         jobject                 obj\r
1131         jmethodID               methodID\r
1132         char *                  sig = 0;\r
1133         int                     argoff = $min_args;\r
1134     CODE:\r
1135         {\r
1136             jvalue * args = makeargs(sig, &ST(argoff), items - argoff);\r
1137             (*env)->CallVoidMethodA(env, obj,methodID,args);\r
1138             RESTOREENV;\r
1139         }\r
1140 \r
1141 void\r
1142 CallVoidMethodA(obj,methodID,args)\r
1143         JNIEnv *                env = FETCHENV;\r
1144         jobject                 obj\r
1145         jmethodID               methodID\r
1146         char *                  sig = 0;\r
1147         jvalue *                args\r
1148     CODE:\r
1149         {\r
1150             (*env)->CallVoidMethodA(env, obj,methodID,args);\r
1151             RESTOREENV;\r
1152         }\r
1153 \r
1154 jobject\r
1155 CallNonvirtualObjectMethod(obj,clazz,methodID,...)\r
1156         JNIEnv *                env = FETCHENV;\r
1157         jobject                 obj\r
1158         jclass                  clazz\r
1159         jmethodID               methodID\r
1160         char *                  sig = 0;\r
1161         int                     argoff = $min_args;\r
1162     CODE:\r
1163         {\r
1164             jvalue * args = makeargs(sig, &ST(argoff), items - argoff);\r
1165             RETVAL = (*env)->CallNonvirtualObjectMethodA(env, obj,clazz,methodID,args);\r
1166             RESTOREENV;\r
1167         }\r
1168     OUTPUT:\r
1169         RETVAL\r
1170 \r
1171 jobject\r
1172 CallNonvirtualObjectMethodA(obj,clazz,methodID,args)\r
1173         JNIEnv *                env = FETCHENV;\r
1174         jobject                 obj\r
1175         jclass                  clazz\r
1176         jmethodID               methodID\r
1177         char *                  sig = 0;\r
1178         jvalue *                args\r
1179     CODE:\r
1180         {\r
1181             RETVAL = (*env)->CallNonvirtualObjectMethodA(env, obj,clazz,methodID,args);\r
1182             RESTOREENV;\r
1183         }\r
1184     OUTPUT:\r
1185         RETVAL\r
1186 \r
1187 jboolean\r
1188 CallNonvirtualBooleanMethod(obj,clazz,methodID,...)\r
1189         JNIEnv *                env = FETCHENV;\r
1190         jobject                 obj\r
1191         jclass                  clazz\r
1192         jmethodID               methodID\r
1193         char *                  sig = 0;\r
1194         int                     argoff = $min_args;\r
1195     CODE:\r
1196         {\r
1197             jvalue * args = makeargs(sig, &ST(argoff), items - argoff);\r
1198             RETVAL = (*env)->CallNonvirtualBooleanMethodA(env, obj,clazz,methodID,args);\r
1199             RESTOREENV;\r
1200         }\r
1201     OUTPUT:\r
1202         RETVAL\r
1203 \r
1204 jboolean\r
1205 CallNonvirtualBooleanMethodA(obj,clazz,methodID, args)\r
1206         JNIEnv *                env = FETCHENV;\r
1207         jobject                 obj\r
1208         jclass                  clazz\r
1209         jmethodID               methodID\r
1210         char *                  sig = 0;\r
1211         jvalue *                args\r
1212     CODE:\r
1213         {\r
1214             RETVAL = (*env)->CallNonvirtualBooleanMethodA(env, obj,clazz,methodID, args);\r
1215             RESTOREENV;\r
1216         }\r
1217     OUTPUT:\r
1218         RETVAL\r
1219 \r
1220 jbyte\r
1221 CallNonvirtualByteMethod(obj,clazz,methodID,...)\r
1222         JNIEnv *                env = FETCHENV;\r
1223         jobject                 obj\r
1224         jclass                  clazz\r
1225         jmethodID               methodID\r
1226         char *                  sig = 0;\r
1227         int                     argoff = $min_args;\r
1228     CODE:\r
1229         {\r
1230             jvalue * args = makeargs(sig, &ST(argoff), items - argoff);\r
1231             RETVAL = (*env)->CallNonvirtualByteMethodA(env, obj,clazz,methodID,args);\r
1232             RESTOREENV;\r
1233         }\r
1234     OUTPUT:\r
1235         RETVAL\r
1236 \r
1237 jbyte\r
1238 CallNonvirtualByteMethodA(obj,clazz,methodID,args)\r
1239         JNIEnv *                env = FETCHENV;\r
1240         jobject                 obj\r
1241         jclass                  clazz\r
1242         jmethodID               methodID\r
1243         char *                  sig = 0;\r
1244         jvalue *                args\r
1245     CODE:\r
1246         {\r
1247             RETVAL = (*env)->CallNonvirtualByteMethodA(env, obj,clazz,methodID,args);\r
1248             RESTOREENV;\r
1249         }\r
1250     OUTPUT:\r
1251         RETVAL\r
1252 \r
1253 jchar\r
1254 CallNonvirtualCharMethod(obj,clazz,methodID,...)\r
1255         JNIEnv *                env = FETCHENV;\r
1256         jobject                 obj\r
1257         jclass                  clazz\r
1258         jmethodID               methodID\r
1259         char *                  sig = 0;\r
1260         int                     argoff = $min_args;\r
1261     CODE:\r
1262         {\r
1263             jvalue * args = makeargs(sig, &ST(argoff), items - argoff);\r
1264             RETVAL = (*env)->CallNonvirtualCharMethodA(env, obj,clazz,methodID,args);\r
1265             RESTOREENV;\r
1266         }\r
1267     OUTPUT:\r
1268         RETVAL\r
1269 \r
1270 jchar\r
1271 CallNonvirtualCharMethodA(obj,clazz,methodID,args)\r
1272         JNIEnv *                env = FETCHENV;\r
1273         jobject                 obj\r
1274         jclass                  clazz\r
1275         jmethodID               methodID\r
1276         char *                  sig = 0;\r
1277         jvalue *                args\r
1278     CODE:\r
1279         {\r
1280             RETVAL = (*env)->CallNonvirtualCharMethodA(env, obj,clazz,methodID,args);\r
1281             RESTOREENV;\r
1282         }\r
1283     OUTPUT:\r
1284         RETVAL\r
1285 \r
1286 jshort\r
1287 CallNonvirtualShortMethod(obj,clazz,methodID,...)\r
1288         JNIEnv *                env = FETCHENV;\r
1289         jobject                 obj\r
1290         jclass                  clazz\r
1291         jmethodID               methodID\r
1292         char *                  sig = 0;\r
1293         int                     argoff = $min_args;\r
1294     CODE:\r
1295         {\r
1296             jvalue * args = makeargs(sig, &ST(argoff), items - argoff);\r
1297             RETVAL = (*env)->CallNonvirtualShortMethodA(env, obj,clazz,methodID,args);\r
1298             RESTOREENV;\r
1299         }\r
1300     OUTPUT:\r
1301         RETVAL\r
1302 \r
1303 jshort\r
1304 CallNonvirtualShortMethodA(obj,clazz,methodID,args)\r
1305         JNIEnv *                env = FETCHENV;\r
1306         jobject                 obj\r
1307         jclass                  clazz\r
1308         jmethodID               methodID\r
1309         char *                  sig = 0;\r
1310         jvalue *                args\r
1311     CODE:\r
1312         {\r
1313             RETVAL = (*env)->CallNonvirtualShortMethodA(env, obj,clazz,methodID,args);\r
1314             RESTOREENV;\r
1315         }\r
1316     OUTPUT:\r
1317         RETVAL\r
1318 \r
1319 jint\r
1320 CallNonvirtualIntMethod(obj,clazz,methodID,...)\r
1321         JNIEnv *                env = FETCHENV;\r
1322         jobject                 obj\r
1323         jclass                  clazz\r
1324         jmethodID               methodID\r
1325         char *                  sig = 0;\r
1326         int                     argoff = $min_args;\r
1327     CODE:\r
1328         {\r
1329             jvalue * args = makeargs(sig, &ST(argoff), items - argoff);\r
1330             RETVAL = (*env)->CallNonvirtualIntMethodA(env, obj,clazz,methodID,args);\r
1331             RESTOREENV;\r
1332         }\r
1333     OUTPUT:\r
1334         RETVAL\r
1335 \r
1336 jint\r
1337 CallNonvirtualIntMethodA(obj,clazz,methodID,args)\r
1338         JNIEnv *                env = FETCHENV;\r
1339         jobject                 obj\r
1340         jclass                  clazz\r
1341         jmethodID               methodID\r
1342         char *                  sig = 0;\r
1343         jvalue *                args\r
1344     CODE:\r
1345         {\r
1346             RETVAL = (*env)->CallNonvirtualIntMethodA(env, obj,clazz,methodID,args);\r
1347             RESTOREENV;\r
1348         }\r
1349     OUTPUT:\r
1350         RETVAL\r
1351 \r
1352 jlong\r
1353 CallNonvirtualLongMethod(obj,clazz,methodID,...)\r
1354         JNIEnv *                env = FETCHENV;\r
1355         jobject                 obj\r
1356         jclass                  clazz\r
1357         jmethodID               methodID\r
1358         char *                  sig = 0;\r
1359         int                     argoff = $min_args;\r
1360     CODE:\r
1361         {\r
1362             jvalue * args = makeargs(sig, &ST(argoff), items - argoff);\r
1363             RETVAL = (*env)->CallNonvirtualLongMethodA(env, obj,clazz,methodID,args);\r
1364             RESTOREENV;\r
1365         }\r
1366     OUTPUT:\r
1367         RETVAL\r
1368 \r
1369 jlong\r
1370 CallNonvirtualLongMethodA(obj,clazz,methodID,args)\r
1371         JNIEnv *                env = FETCHENV;\r
1372         jobject                 obj\r
1373         jclass                  clazz\r
1374         jmethodID               methodID\r
1375         char *                  sig = 0;\r
1376         jvalue *                args\r
1377     CODE:\r
1378         {\r
1379             RETVAL = (*env)->CallNonvirtualLongMethodA(env, obj,clazz,methodID,args);\r
1380             RESTOREENV;\r
1381         }\r
1382     OUTPUT:\r
1383         RETVAL\r
1384 \r
1385 jfloat\r
1386 CallNonvirtualFloatMethod(obj,clazz,methodID,...)\r
1387         JNIEnv *                env = FETCHENV;\r
1388         jobject                 obj\r
1389         jclass                  clazz\r
1390         jmethodID               methodID\r
1391         char *                  sig = 0;\r
1392         int                     argoff = $min_args;\r
1393     CODE:\r
1394         {\r
1395             jvalue * args = makeargs(sig, &ST(argoff), items - argoff);\r
1396             RETVAL = (*env)->CallNonvirtualFloatMethodA(env, obj,clazz,methodID,args);\r
1397             RESTOREENV;\r
1398         }\r
1399     OUTPUT:\r
1400         RETVAL\r
1401 \r
1402 jfloat\r
1403 CallNonvirtualFloatMethodA(obj,clazz,methodID,args)\r
1404         JNIEnv *                env = FETCHENV;\r
1405         jobject                 obj\r
1406         jclass                  clazz\r
1407         jmethodID               methodID\r
1408         char *                  sig = 0;\r
1409         jvalue *                args\r
1410     CODE:\r
1411         {\r
1412             RETVAL = (*env)->CallNonvirtualFloatMethodA(env, obj,clazz,methodID,args);\r
1413             RESTOREENV;\r
1414         }\r
1415     OUTPUT:\r
1416         RETVAL\r
1417 \r
1418 jdouble\r
1419 CallNonvirtualDoubleMethod(obj,clazz,methodID,...)\r
1420         JNIEnv *                env = FETCHENV;\r
1421         jobject                 obj\r
1422         jclass                  clazz\r
1423         jmethodID               methodID\r
1424         char *                  sig = 0;\r
1425         int                     argoff = $min_args;\r
1426     CODE:\r
1427         {\r
1428             jvalue * args = makeargs(sig, &ST(argoff), items - argoff);\r
1429             RETVAL = (*env)->CallNonvirtualDoubleMethodA(env, obj,clazz,methodID,args);\r
1430             RESTOREENV;\r
1431         }\r
1432     OUTPUT:\r
1433         RETVAL\r
1434 \r
1435 jdouble\r
1436 CallNonvirtualDoubleMethodA(obj,clazz,methodID,args)\r
1437         JNIEnv *                env = FETCHENV;\r
1438         jobject                 obj\r
1439         jclass                  clazz\r
1440         jmethodID               methodID\r
1441         char *                  sig = 0;\r
1442         jvalue *                args\r
1443     CODE:\r
1444         {\r
1445             RETVAL = (*env)->CallNonvirtualDoubleMethodA(env, obj,clazz,methodID,args);\r
1446             RESTOREENV;\r
1447         }\r
1448     OUTPUT:\r
1449         RETVAL\r
1450 \r
1451 void\r
1452 CallNonvirtualVoidMethod(obj,clazz,methodID,...)\r
1453         JNIEnv *                env = FETCHENV;\r
1454         jobject                 obj\r
1455         jclass                  clazz\r
1456         jmethodID               methodID\r
1457         char *                  sig = 0;\r
1458         int                     argoff = $min_args;\r
1459     CODE:\r
1460         {\r
1461             jvalue * args = makeargs(sig, &ST(argoff), items - argoff);\r
1462             (*env)->CallNonvirtualVoidMethodA(env, obj,clazz,methodID,args);\r
1463             RESTOREENV;\r
1464         }\r
1465 \r
1466 void\r
1467 CallNonvirtualVoidMethodA(obj,clazz,methodID,args)\r
1468         JNIEnv *                env = FETCHENV;\r
1469         jobject                 obj\r
1470         jclass                  clazz\r
1471         jmethodID               methodID\r
1472         char *                  sig = 0;\r
1473         jvalue *                args\r
1474     CODE:\r
1475         {\r
1476             (*env)->CallNonvirtualVoidMethodA(env, obj,clazz,methodID,args);\r
1477             RESTOREENV;\r
1478         }\r
1479 \r
1480 jfieldID\r
1481 GetFieldID(clazz,name,sig)\r
1482         JNIEnv *                env = FETCHENV;\r
1483         jclass                  clazz\r
1484         const char *            name\r
1485         const char *            sig\r
1486     CODE:\r
1487         {\r
1488             RETVAL = (*env)->GetFieldID(env, clazz,name,sig);\r
1489             RESTOREENV;\r
1490         }\r
1491     OUTPUT:\r
1492         RETVAL\r
1493 \r
1494 jobject\r
1495 GetObjectField(obj,fieldID)\r
1496         JNIEnv *                env = FETCHENV;\r
1497         jobject                 obj\r
1498         jfieldID                fieldID\r
1499         char *                  sig = 0;\r
1500     CODE:\r
1501         {\r
1502             RETVAL = (*env)->GetObjectField(env, obj,fieldID);\r
1503             RESTOREENV;\r
1504         }\r
1505     OUTPUT:\r
1506         RETVAL\r
1507 \r
1508 jboolean\r
1509 GetBooleanField(obj,fieldID)\r
1510         JNIEnv *                env = FETCHENV;\r
1511         jobject                 obj\r
1512         jfieldID                fieldID\r
1513         char *                  sig = 0;\r
1514     CODE:\r
1515         {\r
1516             RETVAL = (*env)->GetBooleanField(env, obj,fieldID);\r
1517             RESTOREENV;\r
1518         }\r
1519     OUTPUT:\r
1520         RETVAL\r
1521 \r
1522 jbyte\r
1523 GetByteField(obj,fieldID)\r
1524         JNIEnv *                env = FETCHENV;\r
1525         jobject                 obj\r
1526         jfieldID                fieldID\r
1527         char *                  sig = 0;\r
1528     CODE:\r
1529         {\r
1530             RETVAL = (*env)->GetByteField(env, obj,fieldID);\r
1531             RESTOREENV;\r
1532         }\r
1533     OUTPUT:\r
1534         RETVAL\r
1535 \r
1536 jchar\r
1537 GetCharField(obj,fieldID)\r
1538         JNIEnv *                env = FETCHENV;\r
1539         jobject                 obj\r
1540         jfieldID                fieldID\r
1541         char *                  sig = 0;\r
1542     CODE:\r
1543         {\r
1544             RETVAL = (*env)->GetCharField(env, obj,fieldID);\r
1545             RESTOREENV;\r
1546         }\r
1547     OUTPUT:\r
1548         RETVAL\r
1549 \r
1550 jshort\r
1551 GetShortField(obj,fieldID)\r
1552         JNIEnv *                env = FETCHENV;\r
1553         jobject                 obj\r
1554         jfieldID                fieldID\r
1555         char *                  sig = 0;\r
1556     CODE:\r
1557         {\r
1558             RETVAL = (*env)->GetShortField(env, obj,fieldID);\r
1559             RESTOREENV;\r
1560         }\r
1561     OUTPUT:\r
1562         RETVAL\r
1563 \r
1564 jint\r
1565 GetIntField(obj,fieldID)\r
1566         JNIEnv *                env = FETCHENV;\r
1567         jobject                 obj\r
1568         jfieldID                fieldID\r
1569         char *                  sig = 0;\r
1570     CODE:\r
1571         {\r
1572             RETVAL = (*env)->GetIntField(env, obj,fieldID);\r
1573             RESTOREENV;\r
1574         }\r
1575     OUTPUT:\r
1576         RETVAL\r
1577 \r
1578 jlong\r
1579 GetLongField(obj,fieldID)\r
1580         JNIEnv *                env = FETCHENV;\r
1581         jobject                 obj\r
1582         jfieldID                fieldID\r
1583         char *                  sig = 0;\r
1584     CODE:\r
1585         {\r
1586             RETVAL = (*env)->GetLongField(env, obj,fieldID);\r
1587             RESTOREENV;\r
1588         }\r
1589     OUTPUT:\r
1590         RETVAL\r
1591 \r
1592 jfloat\r
1593 GetFloatField(obj,fieldID)\r
1594         JNIEnv *                env = FETCHENV;\r
1595         jobject                 obj\r
1596         jfieldID                fieldID\r
1597         char *                  sig = 0;\r
1598     CODE:\r
1599         {\r
1600             RETVAL = (*env)->GetFloatField(env, obj,fieldID);\r
1601             RESTOREENV;\r
1602         }\r
1603     OUTPUT:\r
1604         RETVAL\r
1605 \r
1606 jdouble\r
1607 GetDoubleField(obj,fieldID)\r
1608         JNIEnv *                env = FETCHENV;\r
1609         jobject                 obj\r
1610         jfieldID                fieldID\r
1611         char *                  sig = 0;\r
1612     CODE:\r
1613         {\r
1614             RETVAL = (*env)->GetDoubleField(env, obj,fieldID);\r
1615             RESTOREENV;\r
1616         }\r
1617     OUTPUT:\r
1618         RETVAL\r
1619 \r
1620 void\r
1621 SetObjectField(obj,fieldID,val)\r
1622         JNIEnv *                env = FETCHENV;\r
1623         jobject                 obj\r
1624         jfieldID                fieldID\r
1625         char *                  sig = 0;\r
1626         jobject                 val\r
1627     CODE:\r
1628         {\r
1629             (*env)->SetObjectField(env, obj,fieldID,val);\r
1630             RESTOREENV;\r
1631         }\r
1632 \r
1633 void\r
1634 SetBooleanField(obj,fieldID,val)\r
1635         JNIEnv *                env = FETCHENV;\r
1636         jobject                 obj\r
1637         jfieldID                fieldID\r
1638         char *                  sig = 0;\r
1639         jboolean                val\r
1640     CODE:\r
1641         {\r
1642             (*env)->SetBooleanField(env, obj,fieldID,val);\r
1643             RESTOREENV;\r
1644         }\r
1645 \r
1646 void\r
1647 SetByteField(obj,fieldID,val)\r
1648         JNIEnv *                env = FETCHENV;\r
1649         jobject                 obj\r
1650         jfieldID                fieldID\r
1651         char *                  sig = 0;\r
1652         jbyte                   val\r
1653     CODE:\r
1654         {\r
1655             (*env)->SetByteField(env, obj,fieldID,val);\r
1656             RESTOREENV;\r
1657         }\r
1658 \r
1659 void\r
1660 SetCharField(obj,fieldID,val)\r
1661         JNIEnv *                env = FETCHENV;\r
1662         jobject                 obj\r
1663         jfieldID                fieldID\r
1664         char *                  sig = 0;\r
1665         jchar                   val\r
1666     CODE:\r
1667         {\r
1668             (*env)->SetCharField(env, obj,fieldID,val);\r
1669             RESTOREENV;\r
1670         }\r
1671 \r
1672 void\r
1673 SetShortField(obj,fieldID,val)\r
1674         JNIEnv *                env = FETCHENV;\r
1675         jobject                 obj\r
1676         jfieldID                fieldID\r
1677         char *                  sig = 0;\r
1678         jshort                  val\r
1679     CODE:\r
1680         {\r
1681             (*env)->SetShortField(env, obj,fieldID,val);\r
1682             RESTOREENV;\r
1683         }\r
1684 \r
1685 void\r
1686 SetIntField(obj,fieldID,val)\r
1687         JNIEnv *                env = FETCHENV;\r
1688         jobject                 obj\r
1689         jfieldID                fieldID\r
1690         char *                  sig = 0;\r
1691         jint                    val\r
1692     CODE:\r
1693         {\r
1694             (*env)->SetIntField(env, obj,fieldID,val);\r
1695             RESTOREENV;\r
1696         }\r
1697 \r
1698 void\r
1699 SetLongField(obj,fieldID,val)\r
1700         JNIEnv *                env = FETCHENV;\r
1701         jobject                 obj\r
1702         jfieldID                fieldID\r
1703         char *                  sig = 0;\r
1704         jlong                   val\r
1705     CODE:\r
1706         {\r
1707             (*env)->SetLongField(env, obj,fieldID,val);\r
1708             RESTOREENV;\r
1709         }\r
1710 \r
1711 void\r
1712 SetFloatField(obj,fieldID,val)\r
1713         JNIEnv *                env = FETCHENV;\r
1714         jobject                 obj\r
1715         jfieldID                fieldID\r
1716         char *                  sig = 0;\r
1717         jfloat                  val\r
1718     CODE:\r
1719         {\r
1720             (*env)->SetFloatField(env, obj,fieldID,val);\r
1721             RESTOREENV;\r
1722         }\r
1723 \r
1724 void\r
1725 SetDoubleField(obj,fieldID,val)\r
1726         JNIEnv *                env = FETCHENV;\r
1727         jobject                 obj\r
1728         jfieldID                fieldID\r
1729         char *                  sig = 0;\r
1730         jdouble                 val\r
1731     CODE:\r
1732         {\r
1733             (*env)->SetDoubleField(env, obj,fieldID,val);\r
1734             RESTOREENV;\r
1735         }\r
1736 \r
1737 jmethodID\r
1738 GetStaticMethodID(clazz,name,sig)\r
1739         JNIEnv *                env = FETCHENV;\r
1740         jclass                  clazz\r
1741         const char *            name\r
1742         const char *            sig\r
1743     CODE:\r
1744         {\r
1745             RETVAL = (*env)->GetStaticMethodID(env, clazz,name,sig);\r
1746             RESTOREENV;\r
1747         }\r
1748     OUTPUT:\r
1749         RETVAL\r
1750 \r
1751 jobject\r
1752 CallStaticObjectMethod(clazz,methodID,...)\r
1753         JNIEnv *                env = FETCHENV;\r
1754         jclass                  clazz\r
1755         jmethodID               methodID\r
1756         char *                  sig = 0;\r
1757         int                     argoff = $min_args;\r
1758     CODE:\r
1759         {\r
1760             jvalue * args = makeargs(sig, &ST(argoff), items - argoff);\r
1761             RETVAL = (*env)->CallStaticObjectMethodA(env, clazz,methodID,args);\r
1762             RESTOREENV;\r
1763         }\r
1764     OUTPUT:\r
1765         RETVAL\r
1766 \r
1767 jobject\r
1768 CallStaticObjectMethodA(clazz,methodID,args)\r
1769         JNIEnv *                env = FETCHENV;\r
1770         jclass                  clazz\r
1771         jmethodID               methodID\r
1772         char *                  sig = 0;\r
1773         jvalue *                args\r
1774     CODE:\r
1775         {\r
1776             RETVAL = (*env)->CallStaticObjectMethodA(env, clazz,methodID,args);\r
1777             RESTOREENV;\r
1778         }\r
1779     OUTPUT:\r
1780         RETVAL\r
1781 \r
1782 jboolean\r
1783 CallStaticBooleanMethod(clazz,methodID,...)\r
1784         JNIEnv *                env = FETCHENV;\r
1785         jclass                  clazz\r
1786         jmethodID               methodID\r
1787         char *                  sig = 0;\r
1788         int                     argoff = $min_args;\r
1789     CODE:\r
1790         {\r
1791             jvalue * args = makeargs(sig, &ST(argoff), items - argoff);\r
1792             RETVAL = (*env)->CallStaticBooleanMethodA(env, clazz,methodID,args);\r
1793             RESTOREENV;\r
1794         }\r
1795     OUTPUT:\r
1796         RETVAL\r
1797 \r
1798 jboolean\r
1799 CallStaticBooleanMethodA(clazz,methodID,args)\r
1800         JNIEnv *                env = FETCHENV;\r
1801         jclass                  clazz\r
1802         jmethodID               methodID\r
1803         char *                  sig = 0;\r
1804         jvalue *                args\r
1805     CODE:\r
1806         {\r
1807             RETVAL = (*env)->CallStaticBooleanMethodA(env, clazz,methodID,args);\r
1808             RESTOREENV;\r
1809         }\r
1810     OUTPUT:\r
1811         RETVAL\r
1812 \r
1813 jbyte\r
1814 CallStaticByteMethod(clazz,methodID,...)\r
1815         JNIEnv *                env = FETCHENV;\r
1816         jclass                  clazz\r
1817         jmethodID               methodID\r
1818         char *                  sig = 0;\r
1819         int                     argoff = $min_args;\r
1820     CODE:\r
1821         {\r
1822             jvalue * args = makeargs(sig, &ST(argoff), items - argoff);\r
1823             RETVAL = (*env)->CallStaticByteMethodA(env, clazz,methodID,args);\r
1824             RESTOREENV;\r
1825         }\r
1826     OUTPUT:\r
1827         RETVAL\r
1828 \r
1829 jbyte\r
1830 CallStaticByteMethodA(clazz,methodID,args)\r
1831         JNIEnv *                env = FETCHENV;\r
1832         jclass                  clazz\r
1833         jmethodID               methodID\r
1834         char *                  sig = 0;\r
1835         jvalue *                args\r
1836     CODE:\r
1837         {\r
1838             RETVAL = (*env)->CallStaticByteMethodA(env, clazz,methodID,args);\r
1839             RESTOREENV;\r
1840         }\r
1841     OUTPUT:\r
1842         RETVAL\r
1843 \r
1844 jchar\r
1845 CallStaticCharMethod(clazz,methodID,...)\r
1846         JNIEnv *                env = FETCHENV;\r
1847         jclass                  clazz\r
1848         jmethodID               methodID\r
1849         char *                  sig = 0;\r
1850         int                     argoff = $min_args;\r
1851     CODE:\r
1852         {\r
1853             jvalue * args = makeargs(sig, &ST(argoff), items - argoff);\r
1854             RETVAL = (*env)->CallStaticCharMethodA(env, clazz,methodID,args);\r
1855             RESTOREENV;\r
1856         }\r
1857     OUTPUT:\r
1858         RETVAL\r
1859 \r
1860 jchar\r
1861 CallStaticCharMethodA(clazz,methodID,args)\r
1862         JNIEnv *                env = FETCHENV;\r
1863         jclass                  clazz\r
1864         jmethodID               methodID\r
1865         char *                  sig = 0;\r
1866         jvalue *                args\r
1867     CODE:\r
1868         {\r
1869             RETVAL = (*env)->CallStaticCharMethodA(env, clazz,methodID,args);\r
1870             RESTOREENV;\r
1871         }\r
1872     OUTPUT:\r
1873         RETVAL\r
1874 \r
1875 jshort\r
1876 CallStaticShortMethod(clazz,methodID,...)\r
1877         JNIEnv *                env = FETCHENV;\r
1878         jclass                  clazz\r
1879         jmethodID               methodID\r
1880         char *                  sig = 0;\r
1881         int                     argoff = $min_args;\r
1882     CODE:\r
1883         {\r
1884             jvalue * args = makeargs(sig, &ST(argoff), items - argoff);\r
1885             RETVAL = (*env)->CallStaticShortMethodA(env, clazz,methodID,args);\r
1886             RESTOREENV;\r
1887         }\r
1888     OUTPUT:\r
1889         RETVAL\r
1890 \r
1891 jshort\r
1892 CallStaticShortMethodA(clazz,methodID,args)\r
1893         JNIEnv *                env = FETCHENV;\r
1894         jclass                  clazz\r
1895         jmethodID               methodID\r
1896         char *                  sig = 0;\r
1897         jvalue *                args\r
1898     CODE:\r
1899         {\r
1900             RETVAL = (*env)->CallStaticShortMethodA(env, clazz,methodID,args);\r
1901             RESTOREENV;\r
1902         }\r
1903     OUTPUT:\r
1904         RETVAL\r
1905 \r
1906 jint\r
1907 CallStaticIntMethod(clazz,methodID,...)\r
1908         JNIEnv *                env = FETCHENV;\r
1909         jclass                  clazz\r
1910         jmethodID               methodID\r
1911         char *                  sig = 0;\r
1912         int                     argoff = $min_args;\r
1913     CODE:\r
1914         {\r
1915             jvalue * args = makeargs(sig, &ST(argoff), items - argoff);\r
1916             RETVAL = (*env)->CallStaticIntMethodA(env, clazz,methodID,args);\r
1917             RESTOREENV;\r
1918         }\r
1919     OUTPUT:\r
1920         RETVAL\r
1921 \r
1922 jint\r
1923 CallStaticIntMethodA(clazz,methodID,args)\r
1924         JNIEnv *                env = FETCHENV;\r
1925         jclass                  clazz\r
1926         jmethodID               methodID\r
1927         char *                  sig = 0;\r
1928         jvalue *                args\r
1929     CODE:\r
1930         {\r
1931             RETVAL = (*env)->CallStaticIntMethodA(env, clazz,methodID,args);\r
1932             RESTOREENV;\r
1933         }\r
1934     OUTPUT:\r
1935         RETVAL\r
1936 \r
1937 jlong\r
1938 CallStaticLongMethod(clazz,methodID,...)\r
1939         JNIEnv *                env = FETCHENV;\r
1940         jclass                  clazz\r
1941         jmethodID               methodID\r
1942         char *                  sig = 0;\r
1943         int                     argoff = $min_args;\r
1944     CODE:\r
1945         {\r
1946             jvalue * args = makeargs(sig, &ST(argoff), items - argoff);\r
1947             RETVAL = (*env)->CallStaticLongMethodA(env, clazz,methodID,args);\r
1948             RESTOREENV;\r
1949         }\r
1950     OUTPUT:\r
1951         RETVAL\r
1952 \r
1953 jlong\r
1954 CallStaticLongMethodA(clazz,methodID,args)\r
1955         JNIEnv *                env = FETCHENV;\r
1956         jclass                  clazz\r
1957         jmethodID               methodID\r
1958         char *                  sig = 0;\r
1959         jvalue *                args\r
1960     CODE:\r
1961         {\r
1962             RETVAL = (*env)->CallStaticLongMethodA(env, clazz,methodID,args);\r
1963             RESTOREENV;\r
1964         }\r
1965     OUTPUT:\r
1966         RETVAL\r
1967 \r
1968 jfloat\r
1969 CallStaticFloatMethod(clazz,methodID,...)\r
1970         JNIEnv *                env = FETCHENV;\r
1971         jclass                  clazz\r
1972         jmethodID               methodID\r
1973         char *                  sig = 0;\r
1974         int                     argoff = $min_args;\r
1975     CODE:\r
1976         {\r
1977             jvalue * args = makeargs(sig, &ST(argoff), items - argoff);\r
1978             RETVAL = (*env)->CallStaticFloatMethodA(env, clazz,methodID,args);\r
1979             RESTOREENV;\r
1980         }\r
1981     OUTPUT:\r
1982         RETVAL\r
1983 \r
1984 jfloat\r
1985 CallStaticFloatMethodA(clazz,methodID,args)\r
1986         JNIEnv *                env = FETCHENV;\r
1987         jclass                  clazz\r
1988         jmethodID               methodID\r
1989         char *                  sig = 0;\r
1990         jvalue *                args\r
1991     CODE:\r
1992         {\r
1993             RETVAL = (*env)->CallStaticFloatMethodA(env, clazz,methodID,args);\r
1994             RESTOREENV;\r
1995         }\r
1996     OUTPUT:\r
1997         RETVAL\r
1998 \r
1999 jdouble\r
2000 CallStaticDoubleMethod(clazz,methodID,...)\r
2001         JNIEnv *                env = FETCHENV;\r
2002         jclass                  clazz\r
2003         jmethodID               methodID\r
2004         char *                  sig = 0;\r
2005         int                     argoff = $min_args;\r
2006     CODE:\r
2007         {\r
2008             jvalue * args = makeargs(sig, &ST(argoff), items - argoff);\r
2009             RETVAL = (*env)->CallStaticDoubleMethodA(env, clazz,methodID,args);\r
2010             RESTOREENV;\r
2011         }\r
2012     OUTPUT:\r
2013         RETVAL\r
2014 \r
2015 jdouble\r
2016 CallStaticDoubleMethodA(clazz,methodID,args)\r
2017         JNIEnv *                env = FETCHENV;\r
2018         jclass                  clazz\r
2019         jmethodID               methodID\r
2020         char *                  sig = 0;\r
2021         jvalue *                args\r
2022     CODE:\r
2023         {\r
2024             RETVAL = (*env)->CallStaticDoubleMethodA(env, clazz,methodID,args);\r
2025             RESTOREENV;\r
2026         }\r
2027     OUTPUT:\r
2028         RETVAL\r
2029 \r
2030 void\r
2031 CallStaticVoidMethod(cls,methodID,...)\r
2032         JNIEnv *                env = FETCHENV;\r
2033         jclass                  cls\r
2034         jmethodID               methodID\r
2035         char *                  sig = 0;\r
2036         int                     argoff = $min_args;\r
2037     CODE:\r
2038         {\r
2039             jvalue * args = makeargs(sig, &ST(argoff), items - argoff);\r
2040             (*env)->CallStaticVoidMethodA(env, cls,methodID,args);\r
2041             RESTOREENV;\r
2042         }\r
2043 \r
2044 void\r
2045 CallStaticVoidMethodA(cls,methodID,args)\r
2046         JNIEnv *                env = FETCHENV;\r
2047         jclass                  cls\r
2048         jmethodID               methodID\r
2049         char *                  sig = 0;\r
2050         jvalue *                args\r
2051     CODE:\r
2052         {\r
2053             (*env)->CallStaticVoidMethodA(env, cls,methodID,args);\r
2054             RESTOREENV;\r
2055         }\r
2056 \r
2057 jfieldID\r
2058 GetStaticFieldID(clazz,name,sig)\r
2059         JNIEnv *                env = FETCHENV;\r
2060         jclass                  clazz\r
2061         const char *            name\r
2062         const char *            sig\r
2063     CODE:\r
2064         {\r
2065             RETVAL = (*env)->GetStaticFieldID(env, clazz,name,sig);\r
2066             RESTOREENV;\r
2067         }\r
2068     OUTPUT:\r
2069         RETVAL\r
2070 \r
2071 jobject\r
2072 GetStaticObjectField(clazz,fieldID)\r
2073         JNIEnv *                env = FETCHENV;\r
2074         jclass                  clazz\r
2075         jfieldID                fieldID\r
2076         char *                  sig = 0;\r
2077     CODE:\r
2078         {\r
2079             RETVAL = (*env)->GetStaticObjectField(env, clazz,fieldID);\r
2080             RESTOREENV;\r
2081         }\r
2082     OUTPUT:\r
2083         RETVAL\r
2084 \r
2085 jboolean\r
2086 GetStaticBooleanField(clazz,fieldID)\r
2087         JNIEnv *                env = FETCHENV;\r
2088         jclass                  clazz\r
2089         jfieldID                fieldID\r
2090         char *                  sig = 0;\r
2091     CODE:\r
2092         {\r
2093             RETVAL = (*env)->GetStaticBooleanField(env, clazz,fieldID);\r
2094             RESTOREENV;\r
2095         }\r
2096     OUTPUT:\r
2097         RETVAL\r
2098 \r
2099 jbyte\r
2100 GetStaticByteField(clazz,fieldID)\r
2101         JNIEnv *                env = FETCHENV;\r
2102         jclass                  clazz\r
2103         jfieldID                fieldID\r
2104         char *                  sig = 0;\r
2105     CODE:\r
2106         {\r
2107             RETVAL = (*env)->GetStaticByteField(env, clazz,fieldID);\r
2108             RESTOREENV;\r
2109         }\r
2110     OUTPUT:\r
2111         RETVAL\r
2112 \r
2113 jchar\r
2114 GetStaticCharField(clazz,fieldID)\r
2115         JNIEnv *                env = FETCHENV;\r
2116         jclass                  clazz\r
2117         jfieldID                fieldID\r
2118         char *                  sig = 0;\r
2119     CODE:\r
2120         {\r
2121             RETVAL = (*env)->GetStaticCharField(env, clazz,fieldID);\r
2122             RESTOREENV;\r
2123         }\r
2124     OUTPUT:\r
2125         RETVAL\r
2126 \r
2127 jshort\r
2128 GetStaticShortField(clazz,fieldID)\r
2129         JNIEnv *                env = FETCHENV;\r
2130         jclass                  clazz\r
2131         jfieldID                fieldID\r
2132         char *                  sig = 0;\r
2133     CODE:\r
2134         {\r
2135             RETVAL = (*env)->GetStaticShortField(env, clazz,fieldID);\r
2136             RESTOREENV;\r
2137         }\r
2138     OUTPUT:\r
2139         RETVAL\r
2140 \r
2141 jint\r
2142 GetStaticIntField(clazz,fieldID)\r
2143         JNIEnv *                env = FETCHENV;\r
2144         jclass                  clazz\r
2145         jfieldID                fieldID\r
2146         char *                  sig = 0;\r
2147     CODE:\r
2148         {\r
2149             RETVAL = (*env)->GetStaticIntField(env, clazz,fieldID);\r
2150             RESTOREENV;\r
2151         }\r
2152     OUTPUT:\r
2153         RETVAL\r
2154 \r
2155 jlong\r
2156 GetStaticLongField(clazz,fieldID)\r
2157         JNIEnv *                env = FETCHENV;\r
2158         jclass                  clazz\r
2159         jfieldID                fieldID\r
2160         char *                  sig = 0;\r
2161     CODE:\r
2162         {\r
2163             RETVAL = (*env)->GetStaticLongField(env, clazz,fieldID);\r
2164             RESTOREENV;\r
2165         }\r
2166     OUTPUT:\r
2167         RETVAL\r
2168 \r
2169 jfloat\r
2170 GetStaticFloatField(clazz,fieldID)\r
2171         JNIEnv *                env = FETCHENV;\r
2172         jclass                  clazz\r
2173         jfieldID                fieldID\r
2174         char *                  sig = 0;\r
2175     CODE:\r
2176         {\r
2177             RETVAL = (*env)->GetStaticFloatField(env, clazz,fieldID);\r
2178             RESTOREENV;\r
2179         }\r
2180     OUTPUT:\r
2181         RETVAL\r
2182 \r
2183 jdouble\r
2184 GetStaticDoubleField(clazz,fieldID)\r
2185         JNIEnv *                env = FETCHENV;\r
2186         jclass                  clazz\r
2187         jfieldID                fieldID\r
2188         char *                  sig = 0;\r
2189     CODE:\r
2190         {\r
2191             RETVAL = (*env)->GetStaticDoubleField(env, clazz,fieldID);\r
2192             RESTOREENV;\r
2193         }\r
2194     OUTPUT:\r
2195         RETVAL\r
2196 \r
2197 void\r
2198 SetStaticObjectField(clazz,fieldID,value)\r
2199         JNIEnv *                env = FETCHENV;\r
2200         jclass                  clazz\r
2201         jfieldID                fieldID\r
2202         char *                  sig = 0;\r
2203         jobject                 value\r
2204     CODE:\r
2205         {\r
2206           (*env)->SetStaticObjectField(env, clazz,fieldID,value);\r
2207             RESTOREENV;\r
2208         }\r
2209 \r
2210 void\r
2211 SetStaticBooleanField(clazz,fieldID,value)\r
2212         JNIEnv *                env = FETCHENV;\r
2213         jclass                  clazz\r
2214         jfieldID                fieldID\r
2215         char *                  sig = 0;\r
2216         jboolean                value\r
2217     CODE:\r
2218         {\r
2219           (*env)->SetStaticBooleanField(env, clazz,fieldID,value);\r
2220             RESTOREENV;\r
2221         }\r
2222 \r
2223 void\r
2224 SetStaticByteField(clazz,fieldID,value)\r
2225         JNIEnv *                env = FETCHENV;\r
2226         jclass                  clazz\r
2227         jfieldID                fieldID\r
2228         char *                  sig = 0;\r
2229         jbyte                   value\r
2230     CODE:\r
2231         {\r
2232           (*env)->SetStaticByteField(env, clazz,fieldID,value);\r
2233             RESTOREENV;\r
2234         }\r
2235 \r
2236 void\r
2237 SetStaticCharField(clazz,fieldID,value)\r
2238         JNIEnv *                env = FETCHENV;\r
2239         jclass                  clazz\r
2240         jfieldID                fieldID\r
2241         char *                  sig = 0;\r
2242         jchar                   value\r
2243     CODE:\r
2244         {\r
2245           (*env)->SetStaticCharField(env, clazz,fieldID,value);\r
2246             RESTOREENV;\r
2247         }\r
2248 \r
2249 void\r
2250 SetStaticShortField(clazz,fieldID,value)\r
2251         JNIEnv *                env = FETCHENV;\r
2252         jclass                  clazz\r
2253         jfieldID                fieldID\r
2254         char *                  sig = 0;\r
2255         jshort                  value\r
2256     CODE:\r
2257         {\r
2258           (*env)->SetStaticShortField(env, clazz,fieldID,value);\r
2259             RESTOREENV;\r
2260         }\r
2261 \r
2262 void\r
2263 SetStaticIntField(clazz,fieldID,value)\r
2264         JNIEnv *                env = FETCHENV;\r
2265         jclass                  clazz\r
2266         jfieldID                fieldID\r
2267         char *                  sig = 0;\r
2268         jint                    value\r
2269     CODE:\r
2270         {\r
2271           (*env)->SetStaticIntField(env, clazz,fieldID,value);\r
2272             RESTOREENV;\r
2273         }\r
2274 \r
2275 void\r
2276 SetStaticLongField(clazz,fieldID,value)\r
2277         JNIEnv *                env = FETCHENV;\r
2278         jclass                  clazz\r
2279         jfieldID                fieldID\r
2280         char *                  sig = 0;\r
2281         jlong                   value\r
2282     CODE:\r
2283         {\r
2284           (*env)->SetStaticLongField(env, clazz,fieldID,value);\r
2285             RESTOREENV;\r
2286         }\r
2287 \r
2288 void\r
2289 SetStaticFloatField(clazz,fieldID,value)\r
2290         JNIEnv *                env = FETCHENV;\r
2291         jclass                  clazz\r
2292         jfieldID                fieldID\r
2293         char *                  sig = 0;\r
2294         jfloat                  value\r
2295     CODE:\r
2296         {\r
2297           (*env)->SetStaticFloatField(env, clazz,fieldID,value);\r
2298             RESTOREENV;\r
2299         }\r
2300 \r
2301 void\r
2302 SetStaticDoubleField(clazz,fieldID,value)\r
2303         JNIEnv *                env = FETCHENV;\r
2304         jclass                  clazz\r
2305         jfieldID                fieldID\r
2306         char *                  sig = 0;\r
2307         jdouble                 value\r
2308     CODE:\r
2309         {\r
2310           (*env)->SetStaticDoubleField(env, clazz,fieldID,value);\r
2311             RESTOREENV;\r
2312         }\r
2313 \r
2314 jstring\r
2315 NewString(unicode)\r
2316         JNIEnv *                env = FETCHENV;\r
2317         STRLEN                  tmplen = NO_INIT;\r
2318         jsize                   unicode_len_ = NO_INIT;\r
2319         const jchar *           unicode\r
2320     CODE:\r
2321         {\r
2322             RETVAL = (*env)->NewString(env, unicode, unicode_len_);\r
2323             RESTOREENV;\r
2324         }\r
2325     OUTPUT:\r
2326         RETVAL\r
2327 \r
2328 jsize\r
2329 GetStringLength(str)\r
2330         JNIEnv *                env = FETCHENV;\r
2331         jstring                 str\r
2332     CODE:\r
2333         {\r
2334             RETVAL = (*env)->GetStringLength(env, str);\r
2335             RESTOREENV;\r
2336         }\r
2337     OUTPUT:\r
2338         RETVAL\r
2339 \r
2340 const jchar *\r
2341 GetStringChars(str)\r
2342         JNIEnv *                env = FETCHENV;\r
2343         jstring                 str\r
2344         jboolean                isCopy = NO_INIT;\r
2345         jsize                   RETVAL_len_ = NO_INIT;\r
2346     CODE:\r
2347         {\r
2348             RETVAL = (*env)->GetStringChars(env, str,&isCopy);\r
2349             RETVAL_len_ = (*env)->GetStringLength(env, str);\r
2350             RESTOREENV;\r
2351         }\r
2352     OUTPUT:\r
2353         RETVAL\r
2354     CLEANUP:\r
2355             (*env)->ReleaseStringChars(env, str,RETVAL);\r
2356 \r
2357 jstring\r
2358 NewStringUTF(utf)\r
2359         JNIEnv *                env = FETCHENV;\r
2360         const char *            utf\r
2361     CODE:\r
2362         {\r
2363             RETVAL = (*env)->NewStringUTF(env, utf);\r
2364             RESTOREENV;\r
2365         }\r
2366     OUTPUT:\r
2367         RETVAL\r
2368 \r
2369 jsize\r
2370 GetStringUTFLength(str)\r
2371         JNIEnv *                env = FETCHENV;\r
2372         jstring                 str\r
2373     CODE:\r
2374         {\r
2375             RETVAL = (*env)->GetStringUTFLength(env, str);\r
2376             RESTOREENV;\r
2377         }\r
2378     OUTPUT:\r
2379         RETVAL\r
2380 \r
2381 const char *\r
2382 GetStringUTFChars(str)\r
2383         JNIEnv *                env = FETCHENV;\r
2384         jstring                 str\r
2385         jboolean                isCopy = NO_INIT;\r
2386     CODE:\r
2387         {\r
2388             RETVAL = (*env)->GetStringUTFChars(env, str,&isCopy);\r
2389             RESTOREENV;\r
2390         }\r
2391     OUTPUT:\r
2392         RETVAL\r
2393     CLEANUP:\r
2394         (*env)->ReleaseStringUTFChars(env, str, RETVAL);\r
2395 \r
2396 \r
2397 jsize\r
2398 GetArrayLength(array)\r
2399         JNIEnv *                env = FETCHENV;\r
2400         jarray                  array\r
2401     CODE:\r
2402         {\r
2403             RETVAL = (*env)->GetArrayLength(env, array);\r
2404             RESTOREENV;\r
2405         }\r
2406     OUTPUT:\r
2407         RETVAL\r
2408 \r
2409 jobjectArray\r
2410 NewObjectArray(len,clazz,init)\r
2411         JNIEnv *                env = FETCHENV;\r
2412         jsize                   len\r
2413         jclass                  clazz\r
2414         jobject                 init\r
2415     CODE:\r
2416         {\r
2417             RETVAL = (*env)->NewObjectArray(env, len,clazz,init);\r
2418             RESTOREENV;\r
2419         }\r
2420     OUTPUT:\r
2421         RETVAL\r
2422 \r
2423 jobject\r
2424 GetObjectArrayElement(array,index)\r
2425         JNIEnv *                env = FETCHENV;\r
2426         jobjectArray            array\r
2427         jsize                   index\r
2428     CODE:\r
2429         {\r
2430             RETVAL = (*env)->GetObjectArrayElement(env, array,index);\r
2431             RESTOREENV;\r
2432         }\r
2433     OUTPUT:\r
2434         RETVAL\r
2435 \r
2436 void\r
2437 SetObjectArrayElement(array,index,val)\r
2438         JNIEnv *                env = FETCHENV;\r
2439         jobjectArray            array\r
2440         jsize                   index\r
2441         jobject                 val\r
2442     CODE:\r
2443         {\r
2444             (*env)->SetObjectArrayElement(env, array,index,val);\r
2445             RESTOREENV;\r
2446         }\r
2447 \r
2448 jbooleanArray\r
2449 NewBooleanArray(len)\r
2450         JNIEnv *                env = FETCHENV;\r
2451         jsize                   len\r
2452     CODE:\r
2453         {\r
2454             RETVAL = (*env)->NewBooleanArray(env, len);\r
2455             RESTOREENV;\r
2456         }\r
2457     OUTPUT:\r
2458         RETVAL\r
2459 \r
2460 jbyteArray\r
2461 NewByteArray(len)\r
2462         JNIEnv *                env = FETCHENV;\r
2463         jsize                   len\r
2464     CODE:\r
2465         {\r
2466             RETVAL = (*env)->NewByteArray(env, len);\r
2467             RESTOREENV;\r
2468         }\r
2469     OUTPUT:\r
2470         RETVAL\r
2471 \r
2472 jcharArray\r
2473 NewCharArray(len)\r
2474         JNIEnv *                env = FETCHENV;\r
2475         jsize                   len\r
2476     CODE:\r
2477         {\r
2478             RETVAL = (*env)->NewCharArray(env, len);\r
2479             RESTOREENV;\r
2480         }\r
2481     OUTPUT:\r
2482         RETVAL\r
2483 \r
2484 jshortArray\r
2485 NewShortArray(len)\r
2486         JNIEnv *                env = FETCHENV;\r
2487         jsize                   len\r
2488     CODE:\r
2489         {\r
2490             RETVAL = (*env)->NewShortArray(env, len);\r
2491             RESTOREENV;\r
2492         }\r
2493     OUTPUT:\r
2494         RETVAL\r
2495 \r
2496 jintArray\r
2497 NewIntArray(len)\r
2498         JNIEnv *                env = FETCHENV;\r
2499         jsize                   len\r
2500     CODE:\r
2501         {\r
2502             RETVAL = (*env)->NewIntArray(env, len);\r
2503             RESTOREENV;\r
2504         }\r
2505     OUTPUT:\r
2506         RETVAL\r
2507 \r
2508 jlongArray\r
2509 NewLongArray(len)\r
2510         JNIEnv *                env = FETCHENV;\r
2511         jsize                   len\r
2512     CODE:\r
2513         {\r
2514             RETVAL = (*env)->NewLongArray(env, len);\r
2515             RESTOREENV;\r
2516         }\r
2517     OUTPUT:\r
2518         RETVAL\r
2519 \r
2520 jfloatArray\r
2521 NewFloatArray(len)\r
2522         JNIEnv *                env = FETCHENV;\r
2523         jsize                   len\r
2524     CODE:\r
2525         {\r
2526             RETVAL = (*env)->NewFloatArray(env, len);\r
2527             RESTOREENV;\r
2528         }\r
2529     OUTPUT:\r
2530         RETVAL\r
2531 \r
2532 jdoubleArray\r
2533 NewDoubleArray(len)\r
2534         JNIEnv *                env = FETCHENV;\r
2535         jsize                   len\r
2536     CODE:\r
2537         {\r
2538             RETVAL = (*env)->NewDoubleArray(env, len);\r
2539             RESTOREENV;\r
2540         }\r
2541     OUTPUT:\r
2542         RETVAL\r
2543 \r
2544 jboolean *\r
2545 GetBooleanArrayElements(array)\r
2546         JNIEnv *                env = FETCHENV;\r
2547         jsize                   RETVAL_len_ = NO_INIT;\r
2548         jbooleanArray           array\r
2549         jboolean                isCopy = NO_INIT;\r
2550     PPCODE:\r
2551         {\r
2552             RETVAL = (*env)->GetBooleanArrayElements(env, array,&isCopy);\r
2553             RETVAL_len_ = (*env)->GetArrayLength(env, array);\r
2554             if (GIMME == G_ARRAY) {\r
2555                 int i;\r
2556                 jboolean* r = RETVAL;\r
2557                 EXTEND(sp, RETVAL_len_);\r
2558                 for (i = RETVAL_len_; i; --i) {\r
2559                     PUSHs(sv_2mortal(newSViv(*r++)));\r
2560                 }\r
2561             }\r
2562             else {\r
2563                 if (RETVAL_len_) {\r
2564                     PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,\r
2565                         (STRLEN)RETVAL_len_ * sizeof(jboolean))));\r
2566                 }\r
2567                 else\r
2568                     PUSHs(&PL_sv_no);\r
2569             }\r
2570             (*env)->ReleaseBooleanArrayElements(env, array,RETVAL,JNI_ABORT);\r
2571             RESTOREENV;\r
2572         }\r
2573 \r
2574 jbyte *\r
2575 GetByteArrayElements(array)\r
2576         JNIEnv *                env = FETCHENV;\r
2577         jsize                   RETVAL_len_ = NO_INIT;\r
2578         jbyteArray              array\r
2579         jboolean                isCopy = NO_INIT;\r
2580     PPCODE:\r
2581         {\r
2582             RETVAL = (*env)->GetByteArrayElements(env, array,&isCopy);\r
2583             RETVAL_len_ = (*env)->GetArrayLength(env, array);\r
2584             if (GIMME == G_ARRAY) {\r
2585                 int i;\r
2586                 jbyte* r = RETVAL;\r
2587                 EXTEND(sp, RETVAL_len_);\r
2588                 for (i = RETVAL_len_; i; --i) {\r
2589                     PUSHs(sv_2mortal(newSViv(*r++)));\r
2590                 }\r
2591             }\r
2592             else {\r
2593                 if (RETVAL_len_) {\r
2594                     PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,\r
2595                         (STRLEN)RETVAL_len_ * sizeof(jbyte))));\r
2596                 }\r
2597                 else\r
2598                     PUSHs(&PL_sv_no);\r
2599             }\r
2600             (*env)->ReleaseByteArrayElements(env, array,RETVAL,JNI_ABORT);\r
2601             RESTOREENV;\r
2602         }\r
2603 \r
2604 jchar *\r
2605 GetCharArrayElements(array)\r
2606         JNIEnv *                env = FETCHENV;\r
2607         jsize                   RETVAL_len_ = NO_INIT;\r
2608         jcharArray              array\r
2609         jboolean                isCopy = NO_INIT;\r
2610     PPCODE:\r
2611         {\r
2612             RETVAL = (*env)->GetCharArrayElements(env, array,&isCopy);\r
2613             RETVAL_len_ = (*env)->GetArrayLength(env, array);\r
2614             if (GIMME == G_ARRAY) {\r
2615                 int i;\r
2616                 jchar* r = RETVAL;\r
2617                 EXTEND(sp, RETVAL_len_);\r
2618                 for (i = RETVAL_len_; i; --i) {\r
2619                     PUSHs(sv_2mortal(newSViv(*r++)));\r
2620                 }\r
2621             }\r
2622             else {\r
2623                 if (RETVAL_len_) {\r
2624                     PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,\r
2625                         (STRLEN)RETVAL_len_ * sizeof(jchar))));\r
2626                 }\r
2627                 else\r
2628                     PUSHs(&PL_sv_no);\r
2629             }\r
2630             (*env)->ReleaseCharArrayElements(env, array,RETVAL,JNI_ABORT);\r
2631             RESTOREENV;\r
2632         }\r
2633 \r
2634 jshort *\r
2635 GetShortArrayElements(array)\r
2636         JNIEnv *                env = FETCHENV;\r
2637         jsize                   RETVAL_len_ = NO_INIT;\r
2638         jshortArray             array\r
2639         jboolean                isCopy = NO_INIT;\r
2640     PPCODE:\r
2641         {\r
2642             RETVAL = (*env)->GetShortArrayElements(env, array,&isCopy);\r
2643             RETVAL_len_ = (*env)->GetArrayLength(env, array);\r
2644             if (GIMME == G_ARRAY) {\r
2645                 int i;\r
2646                 jshort* r = RETVAL;\r
2647                 EXTEND(sp, RETVAL_len_);\r
2648                 for (i = RETVAL_len_; i; --i) {\r
2649                     PUSHs(sv_2mortal(newSViv(*r++)));\r
2650                 }\r
2651             }\r
2652             else {\r
2653                 if (RETVAL_len_) {\r
2654                     PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,\r
2655                         (STRLEN)RETVAL_len_ * sizeof(jshort))));\r
2656                 }\r
2657                 else\r
2658                     PUSHs(&PL_sv_no);\r
2659             }\r
2660             (*env)->ReleaseShortArrayElements(env, array,RETVAL,JNI_ABORT);\r
2661             RESTOREENV;\r
2662         }\r
2663 \r
2664 jint *\r
2665 GetIntArrayElements(array)\r
2666         JNIEnv *                env = FETCHENV;\r
2667         jsize                   RETVAL_len_ = NO_INIT;\r
2668         jintArray               array\r
2669         jboolean                isCopy = NO_INIT;\r
2670     PPCODE:\r
2671         {\r
2672             RETVAL = (*env)->GetIntArrayElements(env, array,&isCopy);\r
2673             RETVAL_len_ = (*env)->GetArrayLength(env, array);\r
2674             if (GIMME == G_ARRAY) {\r
2675                 int i;\r
2676                 jint* r = RETVAL;\r
2677                 EXTEND(sp, RETVAL_len_);\r
2678                 for (i = RETVAL_len_; i; --i) {\r
2679                     PUSHs(sv_2mortal(newSViv(*r++)));\r
2680                 }\r
2681             }\r
2682             else {\r
2683                 if (RETVAL_len_) {\r
2684                     PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,\r
2685                         (STRLEN)RETVAL_len_ * sizeof(jint))));\r
2686                 }\r
2687                 else\r
2688                     PUSHs(&PL_sv_no);\r
2689             }\r
2690             (*env)->ReleaseIntArrayElements(env, array,RETVAL,JNI_ABORT);\r
2691             RESTOREENV;\r
2692         }\r
2693 \r
2694 jlong *\r
2695 GetLongArrayElements(array)\r
2696         JNIEnv *                env = FETCHENV;\r
2697         jsize                   RETVAL_len_ = NO_INIT;\r
2698         jlongArray              array\r
2699         jboolean                isCopy = NO_INIT;\r
2700     PPCODE:\r
2701         {\r
2702             RETVAL = (*env)->GetLongArrayElements(env, array,&isCopy);\r
2703             RETVAL_len_ = (*env)->GetArrayLength(env, array);\r
2704             if (GIMME == G_ARRAY) {\r
2705                 int i;\r
2706                 jlong* r = RETVAL;\r
2707                 EXTEND(sp, RETVAL_len_);\r
2708                 for (i = RETVAL_len_; i; --i) {\r
2709                     PUSHs(sv_2mortal(newSViv(*r++)));\r
2710                 }\r
2711             }\r
2712             else {\r
2713                 if (RETVAL_len_) {\r
2714                     PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,\r
2715                         (STRLEN)RETVAL_len_ * sizeof(jlong))));\r
2716                 }\r
2717                 else\r
2718                     PUSHs(&PL_sv_no);\r
2719             }\r
2720             (*env)->ReleaseLongArrayElements(env, array,RETVAL,JNI_ABORT);\r
2721             RESTOREENV;\r
2722         }\r
2723 \r
2724 jfloat *\r
2725 GetFloatArrayElements(array)\r
2726         JNIEnv *                env = FETCHENV;\r
2727         jsize                   RETVAL_len_ = NO_INIT;\r
2728         jfloatArray             array\r
2729         jboolean                isCopy = NO_INIT;\r
2730     PPCODE:\r
2731         {\r
2732             RETVAL = (*env)->GetFloatArrayElements(env, array,&isCopy);\r
2733             RETVAL_len_ = (*env)->GetArrayLength(env, array);\r
2734             if (GIMME == G_ARRAY) {\r
2735                 int i;\r
2736                 jfloat* r = RETVAL;\r
2737                 EXTEND(sp, RETVAL_len_);\r
2738                 for (i = RETVAL_len_; i; --i) {\r
2739                     PUSHs(sv_2mortal(newSVnv(*r++)));\r
2740                 }\r
2741             }\r
2742             else {\r
2743                 if (RETVAL_len_) {\r
2744                     PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,\r
2745                         (STRLEN)RETVAL_len_ * sizeof(jfloat))));\r
2746                 }\r
2747                 else\r
2748                     PUSHs(&PL_sv_no);\r
2749             }\r
2750             (*env)->ReleaseFloatArrayElements(env, array,RETVAL,JNI_ABORT);\r
2751             RESTOREENV;\r
2752         }\r
2753 \r
2754 jdouble *\r
2755 GetDoubleArrayElements(array)\r
2756         JNIEnv *                env = FETCHENV;\r
2757         jsize                   RETVAL_len_ = NO_INIT;\r
2758         jdoubleArray            array\r
2759         jboolean                isCopy = NO_INIT;\r
2760     PPCODE:\r
2761         {\r
2762             RETVAL = (*env)->GetDoubleArrayElements(env, array,&isCopy);\r
2763             RETVAL_len_ = (*env)->GetArrayLength(env, array);\r
2764             if (GIMME == G_ARRAY) {\r
2765                 int i;\r
2766                 jdouble* r = RETVAL;\r
2767                 EXTEND(sp, RETVAL_len_);\r
2768                 for (i = RETVAL_len_; i; --i) {\r
2769                     PUSHs(sv_2mortal(newSVnv(*r++)));\r
2770                 }\r
2771             }\r
2772             else {\r
2773                 if (RETVAL_len_) {\r
2774                     PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,\r
2775                         (STRLEN)RETVAL_len_ * sizeof(jdouble))));\r
2776                 }\r
2777                 else\r
2778                     PUSHs(&PL_sv_no);\r
2779             }\r
2780             (*env)->ReleaseDoubleArrayElements(env, array,RETVAL,JNI_ABORT);\r
2781             RESTOREENV;\r
2782         }\r
2783 \r
2784 void\r
2785 GetBooleanArrayRegion(array,start,len,buf)\r
2786         JNIEnv *                env = FETCHENV;\r
2787         jbooleanArray           array\r
2788         jsize                   start\r
2789         jsize                   len\r
2790         STRLEN                  tmplen = len * sizeof(jboolean) + 1;\r
2791         char *                  tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);\r
2792         jboolean *              buf = (jboolean*)sv_grow(ST(3),len * sizeof(jboolean)+1);\r
2793     CODE:\r
2794         {\r
2795             (*env)->GetBooleanArrayRegion(env, array,start,len,buf);\r
2796             SvCUR_set(ST(3), len * sizeof(jboolean));\r
2797             *SvEND(ST(3)) = '\0';\r
2798             RESTOREENV;\r
2799         }\r
2800 \r
2801 void\r
2802 GetByteArrayRegion(array,start,len,buf)\r
2803         JNIEnv *                env = FETCHENV;\r
2804         jbyteArray              array\r
2805         jsize                   start\r
2806         jsize                   len\r
2807         STRLEN                  tmplen = len * sizeof(jboolean) + 1;\r
2808         char *                  tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);\r
2809         jbyte *                 buf = (jbyte*)sv_grow(ST(3),len * sizeof(jbyte)+1);\r
2810     CODE:\r
2811         {\r
2812             (*env)->GetByteArrayRegion(env, array,start,len,buf);\r
2813             SvCUR_set(ST(3), len * sizeof(jbyte));\r
2814             *SvEND(ST(3)) = '\0';\r
2815             RESTOREENV;\r
2816         }\r
2817 \r
2818 void\r
2819 GetCharArrayRegion(array,start,len,buf)\r
2820         JNIEnv *                env = FETCHENV;\r
2821         jcharArray              array\r
2822         jsize                   start\r
2823         jsize                   len\r
2824         STRLEN                  tmplen = len * sizeof(jboolean) + 1;\r
2825         char *                  tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);\r
2826         jchar *                 buf = (jchar*)sv_grow(ST(3),len * sizeof(jchar)+1);\r
2827     CODE:\r
2828         {\r
2829             (*env)->GetCharArrayRegion(env, array,start,len,buf);\r
2830             SvCUR_set(ST(3), len * sizeof(jchar));\r
2831             *SvEND(ST(3)) = '\0';\r
2832             RESTOREENV;\r
2833         }\r
2834 \r
2835 void\r
2836 GetShortArrayRegion(array,start,len,buf)\r
2837         JNIEnv *                env = FETCHENV;\r
2838         jshortArray             array\r
2839         jsize                   start\r
2840         jsize                   len\r
2841         STRLEN                  tmplen = len * sizeof(jboolean) + 1;\r
2842         char *                  tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);\r
2843         jshort *                buf = (jshort*)sv_grow(ST(3),len * sizeof(jshort)+1);\r
2844     CODE:\r
2845         {\r
2846             (*env)->GetShortArrayRegion(env, array,start,len,buf);\r
2847             SvCUR_set(ST(3), len * sizeof(jshort));\r
2848             *SvEND(ST(3)) = '\0';\r
2849             RESTOREENV;\r
2850         }\r
2851 \r
2852 void\r
2853 GetIntArrayRegion(array,start,len,buf)\r
2854         JNIEnv *                env = FETCHENV;\r
2855         jintArray               array\r
2856         jsize                   start\r
2857         jsize                   len\r
2858         STRLEN                  tmplen = len * sizeof(jboolean) + 1;\r
2859         char *                  tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);\r
2860         jint *                  buf = (jint*)sv_grow(ST(3),len * sizeof(jint)+1);\r
2861     CODE:\r
2862         {\r
2863             (*env)->GetIntArrayRegion(env, array,start,len,buf);\r
2864             SvCUR_set(ST(3), len * sizeof(jint));\r
2865             *SvEND(ST(3)) = '\0';\r
2866             RESTOREENV;\r
2867         }\r
2868 \r
2869 void\r
2870 GetLongArrayRegion(array,start,len,buf)\r
2871         JNIEnv *                env = FETCHENV;\r
2872         jlongArray              array\r
2873         jsize                   start\r
2874         jsize                   len\r
2875         STRLEN                  tmplen = len * sizeof(jboolean) + 1;\r
2876         char *                  tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);\r
2877         jlong *                 buf = (jlong*)sv_grow(ST(3),len * sizeof(jlong)+1);\r
2878     CODE:\r
2879         {\r
2880             (*env)->GetLongArrayRegion(env, array,start,len,buf);\r
2881             SvCUR_set(ST(3), len * sizeof(jlong));\r
2882             *SvEND(ST(3)) = '\0';\r
2883             RESTOREENV;\r
2884         }\r
2885 \r
2886 void\r
2887 GetFloatArrayRegion(array,start,len,buf)\r
2888         JNIEnv *                env = FETCHENV;\r
2889         jfloatArray             array\r
2890         jsize                   start\r
2891         jsize                   len\r
2892         STRLEN                  tmplen = len * sizeof(jboolean) + 1;\r
2893         char *                  tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);\r
2894         jfloat *                buf = (jfloat*)sv_grow(ST(3),len * sizeof(jfloat)+1);\r
2895     CODE:\r
2896         {\r
2897             (*env)->GetFloatArrayRegion(env, array,start,len,buf);\r
2898             SvCUR_set(ST(3), len * sizeof(jfloat));\r
2899             *SvEND(ST(3)) = '\0';\r
2900             RESTOREENV;\r
2901         }\r
2902 \r
2903 void\r
2904 GetDoubleArrayRegion(array,start,len,buf)\r
2905         JNIEnv *                env = FETCHENV;\r
2906         jdoubleArray            array\r
2907         jsize                   start\r
2908         jsize                   len\r
2909         STRLEN                  tmplen = len * sizeof(jboolean) + 1;\r
2910         char *                  tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);\r
2911         jdouble *               buf = (jdouble*)sv_grow(ST(3),len * sizeof(jdouble)+1);\r
2912     CODE:\r
2913         {\r
2914             (*env)->GetDoubleArrayRegion(env, array,start,len,buf);\r
2915             SvCUR_set(ST(3), len * sizeof(jdouble));\r
2916             *SvEND(ST(3)) = '\0';\r
2917             RESTOREENV;\r
2918         }\r
2919 \r
2920 void\r
2921 SetBooleanArrayRegion(array,start,len,buf)\r
2922         JNIEnv *                env = FETCHENV;\r
2923         STRLEN                  tmplen = NO_INIT;\r
2924         jbooleanArray           array\r
2925         jsize                   start\r
2926         jsize                   len\r
2927         jsize                   buf_len_ = NO_INIT;\r
2928         jboolean *              buf\r
2929     CODE:\r
2930         {\r
2931             if (buf_len_ < len)\r
2932                 croak("string is too short");\r
2933             else if (buf_len_ > len && PL_dowarn)\r
2934                 warn("string is too long");\r
2935             (*env)->SetBooleanArrayRegion(env, array,start,len,buf);\r
2936             RESTOREENV;\r
2937         }\r
2938 \r
2939 void\r
2940 SetByteArrayRegion(array,start,len,buf)\r
2941         JNIEnv *                env = FETCHENV;\r
2942         STRLEN                  tmplen = NO_INIT;\r
2943         jbyteArray              array\r
2944         jsize                   start\r
2945         jsize                   len\r
2946         jsize                   buf_len_ = NO_INIT;\r
2947         jbyte *                 buf\r
2948     CODE:\r
2949         {\r
2950             if (buf_len_ < len)\r
2951                 croak("string is too short");\r
2952             else if (buf_len_ > len && PL_dowarn)\r
2953                 warn("string is too long");\r
2954             (*env)->SetByteArrayRegion(env, array,start,len,buf);\r
2955             RESTOREENV;\r
2956         }\r
2957 \r
2958 void\r
2959 SetCharArrayRegion(array,start,len,buf)\r
2960         JNIEnv *                env = FETCHENV;\r
2961         STRLEN                  tmplen = NO_INIT;\r
2962         jcharArray              array\r
2963         jsize                   start\r
2964         jsize                   len\r
2965         jsize                   buf_len_ = NO_INIT;\r
2966         jchar *                 buf\r
2967     CODE:\r
2968         {\r
2969             if (buf_len_ < len)\r
2970                 croak("string is too short");\r
2971             else if (buf_len_ > len && PL_dowarn)\r
2972                 warn("string is too long");\r
2973             (*env)->SetCharArrayRegion(env, array,start,len,buf);\r
2974             RESTOREENV;\r
2975         }\r
2976 \r
2977 void\r
2978 SetShortArrayRegion(array,start,len,buf)\r
2979         JNIEnv *                env = FETCHENV;\r
2980         STRLEN                  tmplen = NO_INIT;\r
2981         jshortArray             array\r
2982         jsize                   start\r
2983         jsize                   len\r
2984         jsize                   buf_len_ = NO_INIT;\r
2985         jshort *                buf\r
2986     CODE:\r
2987         {\r
2988             if (buf_len_ < len)\r
2989                 croak("string is too short");\r
2990             else if (buf_len_ > len && PL_dowarn)\r
2991                 warn("string is too long");\r
2992             (*env)->SetShortArrayRegion(env, array,start,len,buf);\r
2993             RESTOREENV;\r
2994         }\r
2995 \r
2996 void\r
2997 SetIntArrayRegion(array,start,len,buf)\r
2998         JNIEnv *                env = FETCHENV;\r
2999         STRLEN                  tmplen = NO_INIT;\r
3000         jintArray               array\r
3001         jsize                   start\r
3002         jsize                   len\r
3003         jsize                   buf_len_ = NO_INIT;\r
3004         jint *                  buf\r
3005     CODE:\r
3006         {\r
3007             if (buf_len_ < len)\r
3008                 croak("string is too short");\r
3009             else if (buf_len_ > len && PL_dowarn)\r
3010                 warn("string is too long");\r
3011             (*env)->SetIntArrayRegion(env, array,start,len,buf);\r
3012             RESTOREENV;\r
3013         }\r
3014 \r
3015 void\r
3016 SetLongArrayRegion(array,start,len,buf)\r
3017         JNIEnv *                env = FETCHENV;\r
3018         STRLEN                  tmplen = NO_INIT;\r
3019         jlongArray              array\r
3020         jsize                   start\r
3021         jsize                   len\r
3022         jsize                   buf_len_ = NO_INIT;\r
3023         jlong *                 buf\r
3024     CODE:\r
3025         {\r
3026             if (buf_len_ < len)\r
3027                 croak("string is too short");\r
3028             else if (buf_len_ > len && PL_dowarn)\r
3029                 warn("string is too long");\r
3030             (*env)->SetLongArrayRegion(env, array,start,len,buf);\r
3031             RESTOREENV;\r
3032         }\r
3033 \r
3034 void\r
3035 SetFloatArrayRegion(array,start,len,buf)\r
3036         JNIEnv *                env = FETCHENV;\r
3037         STRLEN                  tmplen = NO_INIT;\r
3038         jfloatArray             array\r
3039         jsize                   start\r
3040         jsize                   len\r
3041         jsize                   buf_len_ = NO_INIT;\r
3042         jfloat *                buf\r
3043     CODE:\r
3044         {\r
3045             if (buf_len_ < len)\r
3046                 croak("string is too short");\r
3047             else if (buf_len_ > len && PL_dowarn)\r
3048                 warn("string is too long");\r
3049             (*env)->SetFloatArrayRegion(env, array,start,len,buf);\r
3050             RESTOREENV;\r
3051         }\r
3052 \r
3053 void\r
3054 SetDoubleArrayRegion(array,start,len,buf)\r
3055         JNIEnv *                env = FETCHENV;\r
3056         STRLEN                  tmplen = NO_INIT;\r
3057         jdoubleArray            array\r
3058         jsize                   start\r
3059         jsize                   len\r
3060         jsize                   buf_len_ = NO_INIT;\r
3061         jdouble *               buf\r
3062     CODE:\r
3063         {\r
3064             if (buf_len_ < len)\r
3065                 croak("string is too short");\r
3066             else if (buf_len_ > len && PL_dowarn)\r
3067                 warn("string is too long");\r
3068             (*env)->SetDoubleArrayRegion(env, array,start,len,buf);\r
3069             RESTOREENV;\r
3070         }\r
3071 \r
3072 SysRet\r
3073 RegisterNatives(clazz,methods,nMethods)\r
3074         JNIEnv *                env = FETCHENV;\r
3075         jclass                  clazz\r
3076         JNINativeMethod *       methods\r
3077         jint                    nMethods\r
3078     CODE:\r
3079         {\r
3080             RETVAL = (*env)->RegisterNatives(env, clazz,methods,nMethods);\r
3081         }\r
3082 \r
3083 SysRet\r
3084 UnregisterNatives(clazz)\r
3085         JNIEnv *                env = FETCHENV;\r
3086         jclass                  clazz\r
3087     CODE:\r
3088         {\r
3089             RETVAL = (*env)->UnregisterNatives(env, clazz);\r
3090         }\r
3091     OUTPUT:\r
3092         RETVAL  \r
3093    \r
3094 SysRet\r
3095 MonitorEnter(obj)\r
3096         JNIEnv *                env = FETCHENV;\r
3097         jobject                 obj\r
3098     CODE:\r
3099         {\r
3100             RETVAL = (*env)->MonitorEnter(env, obj);\r
3101             RESTOREENV;\r
3102         }\r
3103     OUTPUT:\r
3104         RETVAL\r
3105 \r
3106 SysRet\r
3107 MonitorExit(obj)\r
3108         JNIEnv *                env = FETCHENV;\r
3109         jobject                 obj\r
3110     CODE:\r
3111         {\r
3112             RETVAL = (*env)->MonitorExit(env, obj);\r
3113             RESTOREENV;\r
3114         }\r
3115     OUTPUT:\r
3116         RETVAL\r
3117 \r
3118 JavaVM *\r
3119 GetJavaVM(...)\r
3120         JNIEnv *                env = FETCHENV;\r
3121     CODE:\r
3122         {\r
3123 #ifdef JPL_DEBUG\r
3124             jpldebug = 1;\r
3125 #else\r
3126             jpldebug = 0;\r
3127 #endif\r
3128             if (env) {  /* We're embedded. */\r
3129                 if ((*env)->GetJavaVM(env, &RETVAL) < 0)\r
3130                     RETVAL = 0;\r
3131             }\r
3132             else {      /* We're embedding. */\r
3133 #ifdef KAFFE\r
3134                 JavaVMInitArgs vm_args;\r
3135 #else\r
3136                 JDK1_1InitArgs vm_args;\r
3137 #endif\r
3138                 char *lib;\r
3139                 if (jpldebug) {\r
3140                     fprintf(stderr, "We're embedding Java in Perl.\n");\r
3141                 }\r
3142 \r
3143                 if (items--) {\r
3144                     ++mark;\r
3145                     lib = SvPV(*mark, PL_na);\r
3146                 }\r
3147                 else\r
3148                     lib = 0;\r
3149                 if (jpldebug) {\r
3150                     fprintf(stderr, "lib is %s.\n", lib);\r
3151                 }\r
3152 #ifdef WIN32\r
3153         if (LoadLibrary("jvm.dll")) {\r
3154             if (!LoadLibrary("javai.dll")) {\r
3155                 warn("Can't load javai.dll");\r
3156             }\r
3157         } else {\r
3158             if (lib && !LoadLibrary(lib))\r
3159                 croak("Can't load javai.dll"); \r
3160         }\r
3161 #else\r
3162                 if (jpldebug) {\r
3163                     fprintf(stderr, "Opening Java shared library.\n");\r
3164                 }\r
3165 #ifdef KAFFE\r
3166                 if (!dlopen("libkaffevm.so", RTLD_LAZY|RTLD_GLOBAL)) {\r
3167 #else\r
3168                 if (!dlopen("libjava.so", RTLD_LAZY|RTLD_GLOBAL)) {\r
3169 #endif\r
3170                     if (lib && !dlopen(lib, RTLD_LAZY|RTLD_GLOBAL))\r
3171                         croak("Can't load Java shared library.");\r
3172                 }\r
3173 #endif\r
3174                /* Kaffe seems to get very upset if vm_args.version isn't set */\r
3175 #ifdef KAFFE\r
3176                 vm_args.version = JNI_VERSION_1_1;\r
3177 #endif\r
3178                 JNI_GetDefaultJavaVMInitArgs(&vm_args);\r
3179                 vm_args.exit = &call_my_exit;\r
3180                 if (jpldebug) {\r
3181             fprintf(stderr, "items = %d\n", items);\r
3182             fprintf(stderr, "mark = %s\n", SvPV(*mark, PL_na));\r
3183         }\r
3184                 while (items > 1) {\r
3185                   char *s;\r
3186                     ++mark;\r
3187                     s = SvPV(*mark,PL_na);\r
3188                     ++mark;\r
3189                     if (jpldebug) {\r
3190                 fprintf(stderr, "*s = %s\n", s);\r
3191                 fprintf(stderr, "val = %s\n", SvPV(*mark, PL_na));\r
3192             }\r
3193                     items -= 2;\r
3194                     if (strEQ(s, "checkSource"))\r
3195                         vm_args.checkSource = (jint)SvIV(*mark);\r
3196                     else if (strEQ(s, "nativeStackSize"))\r
3197                         vm_args.nativeStackSize = (jint)SvIV(*mark);\r
3198                     else if (strEQ(s, "javaStackSize"))\r
3199                         vm_args.javaStackSize = (jint)SvIV(*mark);\r
3200                     else if (strEQ(s, "minHeapSize"))\r
3201                         vm_args.minHeapSize = (jint)SvIV(*mark);\r
3202                     else if (strEQ(s, "maxHeapSize"))\r
3203                         vm_args.maxHeapSize = (jint)SvIV(*mark);\r
3204                     else if (strEQ(s, "verifyMode"))\r
3205                         vm_args.verifyMode = (jint)SvIV(*mark);\r
3206                     else if (strEQ(s, "classpath"))\r
3207                         vm_args.classpath = savepv(SvPV(*mark,PL_na));\r
3208                     else if (strEQ(s, "enableClassGC"))\r
3209                         vm_args.enableClassGC = (jint)SvIV(*mark);\r
3210                     else if (strEQ(s, "enableVerboseGC"))\r
3211                         vm_args.enableVerboseGC = (jint)SvIV(*mark);\r
3212                     else if (strEQ(s, "disableAsyncGC"))\r
3213                         vm_args.disableAsyncGC = (jint)SvIV(*mark);\r
3214 #ifdef KAFFE\r
3215                     else if (strEQ(s, "libraryhome"))\r
3216                         vm_args.libraryhome = savepv(SvPV(*mark,PL_na));\r
3217                     else if (strEQ(s, "classhome"))\r
3218                         vm_args.classhome = savepv(SvPV(*mark,PL_na));\r
3219                     else if (strEQ(s, "enableVerboseJIT"))\r
3220                         vm_args.enableVerboseJIT = (jint)SvIV(*mark); \r
3221                     else if (strEQ(s, "enableVerboseClassloading"))\r
3222                         vm_args.enableVerboseClassloading = (jint)SvIV(*mark); \r
3223                     else if (strEQ(s, "enableVerboseCall"))\r
3224                         vm_args.enableVerboseCall = (jint)SvIV(*mark); \r
3225                     else if (strEQ(s, "allocHeapSize"))\r
3226                         vm_args.allocHeapSize = (jint)SvIV(*mark); \r
3227 #else\r
3228                     else if (strEQ(s, "verbose"))\r
3229                         vm_args.verbose = (jint)SvIV(*mark); \r
3230                     else if (strEQ(s, "debugging"))\r
3231                         vm_args.debugging = (jboolean)SvIV(*mark);\r
3232                     else if (strEQ(s, "debugPort"))\r
3233                         vm_args.debugPort = (jint)SvIV(*mark); \r
3234 #endif\r
3235                     else\r
3236                         croak("unrecognized option: %s", s);\r
3237                 }\r
3238 \r
3239                 if (jpldebug) {\r
3240                     fprintf(stderr, "Creating Java VM...\n");\r
3241                     fprintf(stderr, "Working CLASSPATH: %s\n", \r
3242                         vm_args.classpath);\r
3243                 }\r
3244                 if (JNI_CreateJavaVM(&RETVAL, &jplcurenv, &vm_args) < 0) {\r
3245                   croak("Unable to create instance of JVM");\r
3246                 }\r
3247                 if (jpldebug) {\r
3248                     fprintf(stderr, "Created Java VM.\n");\r
3249                 }\r
3250 \r
3251             }\r
3252         }\r
3253 \r