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