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