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