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