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