2 * Copyright 1997, O'Reilly & Associate, Inc.
4 * This package may be copied under the same terms as Perl itself.
15 extern JNIEnv* jplcurenv;
21 call_my_exit(jint status)
28 makeargs(pTHX_ char *sig, SV** svp, int items)
30 jvalue* jv = (jvalue*)safemalloc(sizeof(jvalue) * items);
33 JNIEnv* env = jplcurenv;
38 fprintf(stderr, "sig = %s, items = %d\n", sig, items);
47 jv[ix++].z = (jboolean)(SvIV(sv) != 0);
50 jv[ix++].b = (jbyte)SvIV(sv);
53 jv[ix++].c = (jchar)SvIV(sv);
56 jv[ix++].s = (jshort)SvIV(sv);
59 jv[ix++].i = (jint)SvIV(sv);
62 jv[ix++].j = (jlong)SvNV(sv);
65 jv[ix++].f = (jfloat)SvNV(sv);
68 jv[ix++].d = (jdouble)SvNV(sv);
74 SV* rv = (SV*)SvRV(sv);
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));
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);
88 jv[ix++].l = (jobject)ja;
91 jv[ix++].l = (jobject)(void*)0;
94 jsize len = sv_len(sv) / sizeof(jboolean);
96 jbooleanArray ja = (*env)->NewBooleanArray(env, len);
97 (*env)->SetBooleanArrayRegion(env, ja, 0, len, (jboolean*)SvPV(sv,n_a));
98 jv[ix++].l = (jobject)ja;
101 jv[ix++].l = (jobject)(void*)0;
105 SV* rv = (SV*)SvRV(sv);
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));
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);
119 jv[ix++].l = (jobject)ja;
122 jv[ix++].l = (jobject)(void*)0;
124 else if (SvPOK(sv)) {
125 jsize len = sv_len(sv) / sizeof(jbyte);
127 jbyteArray ja = (*env)->NewByteArray(env, len);
128 (*env)->SetByteArrayRegion(env, ja, 0, len, (jbyte*)SvPV(sv,n_a));
129 jv[ix++].l = (jobject)ja;
132 jv[ix++].l = (jobject)(void*)0;
136 SV* rv = (SV*)SvRV(sv);
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));
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);
150 jv[ix++].l = (jobject)ja;
153 jv[ix++].l = (jobject)(void*)0;
155 else if (SvPOK(sv)) {
156 jsize len = sv_len(sv) / sizeof(jchar);
158 jcharArray ja = (*env)->NewCharArray(env, len);
159 (*env)->SetCharArrayRegion(env, ja, 0, len, (jchar*)SvPV(sv,n_a));
160 jv[ix++].l = (jobject)ja;
163 jv[ix++].l = (jobject)(void*)0;
167 SV* rv = (SV*)SvRV(sv);
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));
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);
181 jv[ix++].l = (jobject)ja;
184 jv[ix++].l = (jobject)(void*)0;
186 else if (SvPOK(sv)) {
187 jsize len = sv_len(sv) / sizeof(jshort);
189 jshortArray ja = (*env)->NewShortArray(env, len);
190 (*env)->SetShortArrayRegion(env, ja, 0, len, (jshort*)SvPV(sv,n_a));
191 jv[ix++].l = (jobject)ja;
194 jv[ix++].l = (jobject)(void*)0;
198 SV* rv = (SV*)SvRV(sv);
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));
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);
212 jv[ix++].l = (jobject)ja;
215 jv[ix++].l = (jobject)(void*)0;
217 else if (SvPOK(sv)) {
218 jsize len = sv_len(sv) / sizeof(jint);
220 jintArray ja = (*env)->NewIntArray(env, len);
221 (*env)->SetIntArrayRegion(env, ja, 0, len, (jint*)SvPV(sv,n_a));
222 jv[ix++].l = (jobject)ja;
225 jv[ix++].l = (jobject)(void*)0;
229 SV* rv = (SV*)SvRV(sv);
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));
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);
243 jv[ix++].l = (jobject)ja;
246 jv[ix++].l = (jobject)(void*)0;
248 else if (SvPOK(sv)) {
249 jsize len = sv_len(sv) / sizeof(jlong);
251 jlongArray ja = (*env)->NewLongArray(env, len);
252 (*env)->SetLongArrayRegion(env, ja, 0, len, (jlong*)SvPV(sv,n_a));
253 jv[ix++].l = (jobject)ja;
256 jv[ix++].l = (jobject)(void*)0;
260 SV* rv = (SV*)SvRV(sv);
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));
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);
274 jv[ix++].l = (jobject)ja;
277 jv[ix++].l = (jobject)(void*)0;
279 else if (SvPOK(sv)) {
280 jsize len = sv_len(sv) / sizeof(jfloat);
282 jfloatArray ja = (*env)->NewFloatArray(env, len);
283 (*env)->SetFloatArrayRegion(env, ja, 0, len, (jfloat*)SvPV(sv,n_a));
284 jv[ix++].l = (jobject)ja;
287 jv[ix++].l = (jobject)(void*)0;
291 SV* rv = (SV*)SvRV(sv);
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));
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);
305 jv[ix++].l = (jobject)ja;
308 jv[ix++].l = (jobject)(void*)0;
310 else if (SvPOK(sv)) {
311 jsize len = sv_len(sv) / sizeof(jdouble);
313 jdoubleArray ja = (*env)->NewDoubleArray(env, len);
314 (*env)->SetDoubleArrayRegion(env, ja, 0, len, (jdouble*)SvPV(sv,n_a));
315 jv[ix++].l = (jobject)ja;
318 jv[ix++].l = (jobject)(void*)0;
321 while (*s != ';') s++;
323 if (strnEQ(start, "[Ljava/lang/String;", 19)) {
325 SV* rv = (SV*)SvRV(sv);
327 jv[ix++].l = (jobject)(void*)SvIV(rv);
328 else if (SvTYPE(rv) == SVt_PVAV) {
329 jsize len = av_len((AV*)rv) + 1;
332 static jclass jcl = 0;
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++) {
339 jobject str = (jobject)(*env)->NewStringUTF(env, SvPV(*esv,n_a));
340 (*env)->SetObjectArrayElement(env, ja, i, str);
342 jv[ix++].l = (jobject)ja;
345 jv[ix++].l = (jobject)(void*)0;
348 jv[ix++].l = (jobject)(void*)0;
354 SV* rv = (SV*)SvRV(sv);
356 jv[ix++].l = (jobject)(void*)SvIV(rv);
357 else if (SvTYPE(rv) == SVt_PVAV) {
358 jsize len = av_len((AV*)rv) + 1;
361 static jclass jcl = 0;
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));
373 jobject str = (jobject)(*env)->NewStringUTF(env,
375 (*env)->SetObjectArrayElement(env, ja, i, str);
378 jv[ix++].l = (jobject)ja;
381 jv[ix++].l = (jobject)(void*)0;
384 jv[ix++].l = (jobject)(void*)0;
389 if (!SvROK(sv) || strnEQ(s, "java/lang/String;", 17)) {
391 jv[ix++].l = (jobject)(*env)->NewStringUTF(env,
392 (char*) SvPV(sv,n_a));
395 while (*s != ';') s++;
399 jv[ix++].l = (jobject)(void*)SvIV(rv);
403 Perl_croak(aTHX_ "too many arguments, signature: %s", sig);
406 Perl_croak(aTHX_ "panic: malformed signature: %s", s-1);
412 Perl_croak(aTHX_ "not enough arguments, signature: %s", sig);
423 not_here(pTHX_ char *s)
425 Perl_croak(aTHX_ "%s not implemented on this architecture", s);
430 constant(char *name, int arg)
453 if (strEQ(name, "JNI_ABORT"))
459 if (strEQ(name, "JNI_COMMIT"))
465 if (strEQ(name, "JNI_ERR"))
471 if (strEQ(name, "JNI_FALSE"))
477 if (strEQ(name, "JNI_H"))
483 if (strEQ(name, "JNI_OK"))
489 if (strEQ(name, "JNI_TRUE"))
537 #define FETCHENV jplcurenv
538 #define RESTOREENV jplcurenv = env
540 MODULE = JNI PACKAGE = JNI
551 JNIEnv * env = FETCHENV;
554 RETVAL = (*env)->GetVersion(env);
561 DefineClass(name, loader, buf)
562 JNIEnv * env = FETCHENV;
563 STRLEN tmplen = NO_INIT;
564 jsize buf_len_ = NO_INIT;
570 RETVAL = (*env)->DefineClass(env, name, loader, buf, (jsize)buf_len_);
578 JNIEnv * env = FETCHENV;
582 RETVAL = (*env)->FindClass(env, name);
590 JNIEnv * env = FETCHENV;
594 RETVAL = (*env)->GetSuperclass(env, sub);
601 IsAssignableFrom(sub, sup)
602 JNIEnv * env = FETCHENV;
607 RETVAL = (*env)->IsAssignableFrom(env, sub, sup);
615 JNIEnv * env = FETCHENV;
619 RETVAL = (*env)->Throw(env, obj);
627 JNIEnv * env = FETCHENV;
632 RETVAL = (*env)->ThrowNew(env, clazz, msg);
640 JNIEnv * env = FETCHENV;
643 RETVAL = (*env)->ExceptionOccurred(env);
651 JNIEnv * env = FETCHENV;
654 (*env)->ExceptionDescribe(env);
660 JNIEnv * env = FETCHENV;
663 (*env)->ExceptionClear(env);
669 JNIEnv * env = FETCHENV;
673 (*env)->FatalError(env, msg);
679 JNIEnv * env = FETCHENV;
683 RETVAL = (*env)->NewGlobalRef(env, lobj);
690 DeleteGlobalRef(gref)
691 JNIEnv * env = FETCHENV;
695 (*env)->DeleteGlobalRef(env, gref);
701 JNIEnv * env = FETCHENV;
705 (*env)->DeleteLocalRef(env, obj);
710 IsSameObject(obj1,obj2)
711 JNIEnv * env = FETCHENV;
716 RETVAL = (*env)->IsSameObject(env, obj1,obj2);
724 JNIEnv * env = FETCHENV;
728 RETVAL = (*env)->AllocObject(env, clazz);
735 NewObject(clazz,methodID,...)
736 JNIEnv * env = FETCHENV;
740 int argoff = $min_args;
743 jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
744 RETVAL = (*env)->NewObjectA(env, clazz,methodID,args);
751 NewObjectA(clazz,methodID,args)
752 JNIEnv * env = FETCHENV;
759 RETVAL = (*env)->NewObjectA(env, clazz,methodID,args);
767 JNIEnv * env = FETCHENV;
771 RETVAL = (*env)->GetObjectClass(env, obj);
778 IsInstanceOf(obj,clazz)
779 JNIEnv * env = FETCHENV;
784 RETVAL = (*env)->IsInstanceOf(env, obj,clazz);
791 GetMethodID(clazz,name,sig)
792 JNIEnv * env = FETCHENV;
798 RETVAL = (*env)->GetMethodID(env, clazz,name,sig);
805 CallObjectMethod(obj,methodID,...)
806 JNIEnv * env = FETCHENV;
810 int argoff = $min_args;
813 jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
814 RETVAL = (*env)->CallObjectMethodA(env, obj,methodID,args);
821 CallObjectMethodA(obj,methodID,args)
822 JNIEnv * env = FETCHENV;
829 RETVAL = (*env)->CallObjectMethodA(env, obj,methodID,args);
836 CallBooleanMethod(obj,methodID,...)
837 JNIEnv * env = FETCHENV;
841 int argoff = $min_args;
844 jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
845 RETVAL = (*env)->CallBooleanMethodA(env, obj,methodID,args);
852 CallBooleanMethodA(obj,methodID, args)
853 JNIEnv * env = FETCHENV;
860 RETVAL = (*env)->CallBooleanMethodA(env, obj,methodID, args);
867 CallByteMethod(obj,methodID,...)
868 JNIEnv * env = FETCHENV;
872 int argoff = $min_args;
875 jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
876 RETVAL = (*env)->CallByteMethodA(env, obj,methodID,args);
883 CallByteMethodA(obj,methodID,args)
884 JNIEnv * env = FETCHENV;
891 RETVAL = (*env)->CallByteMethodA(env, obj,methodID,args);
898 CallCharMethod(obj,methodID,...)
899 JNIEnv * env = FETCHENV;
903 int argoff = $min_args;
906 jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
907 RETVAL = (*env)->CallCharMethodA(env, obj,methodID,args);
914 CallCharMethodA(obj,methodID,args)
915 JNIEnv * env = FETCHENV;
922 RETVAL = (*env)->CallCharMethodA(env, obj,methodID,args);
929 CallShortMethod(obj,methodID,...)
930 JNIEnv * env = FETCHENV;
934 int argoff = $min_args;
937 jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
938 RETVAL = (*env)->CallShortMethodA(env, obj,methodID,args);
945 CallShortMethodA(obj,methodID,args)
946 JNIEnv * env = FETCHENV;
953 RETVAL = (*env)->CallShortMethodA(env, obj,methodID,args);
960 CallIntMethod(obj,methodID,...)
961 JNIEnv * env = FETCHENV;
965 int argoff = $min_args;
968 jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
969 RETVAL = (*env)->CallIntMethodA(env, obj,methodID,args);
976 CallIntMethodA(obj,methodID,args)
977 JNIEnv * env = FETCHENV;
984 RETVAL = (*env)->CallIntMethodA(env, obj,methodID,args);
991 CallLongMethod(obj,methodID,...)
992 JNIEnv * env = FETCHENV;
996 int argoff = $min_args;
999 jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
1000 RETVAL = (*env)->CallLongMethodA(env, obj,methodID,args);
1007 CallLongMethodA(obj,methodID,args)
1008 JNIEnv * env = FETCHENV;
1015 RETVAL = (*env)->CallLongMethodA(env, obj,methodID,args);
1022 CallFloatMethod(obj,methodID,...)
1023 JNIEnv * env = FETCHENV;
1027 int argoff = $min_args;
1030 jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
1031 RETVAL = (*env)->CallFloatMethodA(env, obj,methodID,args);
1038 CallFloatMethodA(obj,methodID,args)
1039 JNIEnv * env = FETCHENV;
1046 RETVAL = (*env)->CallFloatMethodA(env, obj,methodID,args);
1053 CallDoubleMethod(obj,methodID,...)
1054 JNIEnv * env = FETCHENV;
1058 int argoff = $min_args;
1061 jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
1062 RETVAL = (*env)->CallDoubleMethodA(env, obj,methodID,args);
1069 CallDoubleMethodA(obj,methodID,args)
1070 JNIEnv * env = FETCHENV;
1077 RETVAL = (*env)->CallDoubleMethodA(env, obj,methodID,args);
1084 CallVoidMethod(obj,methodID,...)
1085 JNIEnv * env = FETCHENV;
1089 int argoff = $min_args;
1092 jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
1093 (*env)->CallVoidMethodA(env, obj,methodID,args);
1098 CallVoidMethodA(obj,methodID,args)
1099 JNIEnv * env = FETCHENV;
1106 (*env)->CallVoidMethodA(env, obj,methodID,args);
1111 CallNonvirtualObjectMethod(obj,clazz,methodID,...)
1112 JNIEnv * env = FETCHENV;
1117 int argoff = $min_args;
1120 jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
1121 RETVAL = (*env)->CallNonvirtualObjectMethodA(env, obj,clazz,methodID,args);
1128 CallNonvirtualObjectMethodA(obj,clazz,methodID,args)
1129 JNIEnv * env = FETCHENV;
1137 RETVAL = (*env)->CallNonvirtualObjectMethodA(env, obj,clazz,methodID,args);
1144 CallNonvirtualBooleanMethod(obj,clazz,methodID,...)
1145 JNIEnv * env = FETCHENV;
1150 int argoff = $min_args;
1153 jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
1154 RETVAL = (*env)->CallNonvirtualBooleanMethodA(env, obj,clazz,methodID,args);
1161 CallNonvirtualBooleanMethodA(obj,clazz,methodID, args)
1162 JNIEnv * env = FETCHENV;
1170 RETVAL = (*env)->CallNonvirtualBooleanMethodA(env, obj,clazz,methodID, args);
1177 CallNonvirtualByteMethod(obj,clazz,methodID,...)
1178 JNIEnv * env = FETCHENV;
1183 int argoff = $min_args;
1186 jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
1187 RETVAL = (*env)->CallNonvirtualByteMethodA(env, obj,clazz,methodID,args);
1194 CallNonvirtualByteMethodA(obj,clazz,methodID,args)
1195 JNIEnv * env = FETCHENV;
1203 RETVAL = (*env)->CallNonvirtualByteMethodA(env, obj,clazz,methodID,args);
1210 CallNonvirtualCharMethod(obj,clazz,methodID,...)
1211 JNIEnv * env = FETCHENV;
1216 int argoff = $min_args;
1219 jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
1220 RETVAL = (*env)->CallNonvirtualCharMethodA(env, obj,clazz,methodID,args);
1227 CallNonvirtualCharMethodA(obj,clazz,methodID,args)
1228 JNIEnv * env = FETCHENV;
1236 RETVAL = (*env)->CallNonvirtualCharMethodA(env, obj,clazz,methodID,args);
1243 CallNonvirtualShortMethod(obj,clazz,methodID,...)
1244 JNIEnv * env = FETCHENV;
1249 int argoff = $min_args;
1252 jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
1253 RETVAL = (*env)->CallNonvirtualShortMethodA(env, obj,clazz,methodID,args);
1260 CallNonvirtualShortMethodA(obj,clazz,methodID,args)
1261 JNIEnv * env = FETCHENV;
1269 RETVAL = (*env)->CallNonvirtualShortMethodA(env, obj,clazz,methodID,args);
1276 CallNonvirtualIntMethod(obj,clazz,methodID,...)
1277 JNIEnv * env = FETCHENV;
1282 int argoff = $min_args;
1285 jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
1286 RETVAL = (*env)->CallNonvirtualIntMethodA(env, obj,clazz,methodID,args);
1293 CallNonvirtualIntMethodA(obj,clazz,methodID,args)
1294 JNIEnv * env = FETCHENV;
1302 RETVAL = (*env)->CallNonvirtualIntMethodA(env, obj,clazz,methodID,args);
1309 CallNonvirtualLongMethod(obj,clazz,methodID,...)
1310 JNIEnv * env = FETCHENV;
1315 int argoff = $min_args;
1318 jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
1319 RETVAL = (*env)->CallNonvirtualLongMethodA(env, obj,clazz,methodID,args);
1326 CallNonvirtualLongMethodA(obj,clazz,methodID,args)
1327 JNIEnv * env = FETCHENV;
1335 RETVAL = (*env)->CallNonvirtualLongMethodA(env, obj,clazz,methodID,args);
1342 CallNonvirtualFloatMethod(obj,clazz,methodID,...)
1343 JNIEnv * env = FETCHENV;
1348 int argoff = $min_args;
1351 jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
1352 RETVAL = (*env)->CallNonvirtualFloatMethodA(env, obj,clazz,methodID,args);
1359 CallNonvirtualFloatMethodA(obj,clazz,methodID,args)
1360 JNIEnv * env = FETCHENV;
1368 RETVAL = (*env)->CallNonvirtualFloatMethodA(env, obj,clazz,methodID,args);
1375 CallNonvirtualDoubleMethod(obj,clazz,methodID,...)
1376 JNIEnv * env = FETCHENV;
1381 int argoff = $min_args;
1384 jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
1385 RETVAL = (*env)->CallNonvirtualDoubleMethodA(env, obj,clazz,methodID,args);
1392 CallNonvirtualDoubleMethodA(obj,clazz,methodID,args)
1393 JNIEnv * env = FETCHENV;
1401 RETVAL = (*env)->CallNonvirtualDoubleMethodA(env, obj,clazz,methodID,args);
1408 CallNonvirtualVoidMethod(obj,clazz,methodID,...)
1409 JNIEnv * env = FETCHENV;
1414 int argoff = $min_args;
1417 jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
1418 (*env)->CallNonvirtualVoidMethodA(env, obj,clazz,methodID,args);
1423 CallNonvirtualVoidMethodA(obj,clazz,methodID,args)
1424 JNIEnv * env = FETCHENV;
1432 (*env)->CallNonvirtualVoidMethodA(env, obj,clazz,methodID,args);
1437 GetFieldID(clazz,name,sig)
1438 JNIEnv * env = FETCHENV;
1444 RETVAL = (*env)->GetFieldID(env, clazz,name,sig);
1451 GetObjectField(obj,fieldID)
1452 JNIEnv * env = FETCHENV;
1458 RETVAL = (*env)->GetObjectField(env, obj,fieldID);
1465 GetBooleanField(obj,fieldID)
1466 JNIEnv * env = FETCHENV;
1472 RETVAL = (*env)->GetBooleanField(env, obj,fieldID);
1479 GetByteField(obj,fieldID)
1480 JNIEnv * env = FETCHENV;
1486 RETVAL = (*env)->GetByteField(env, obj,fieldID);
1493 GetCharField(obj,fieldID)
1494 JNIEnv * env = FETCHENV;
1500 RETVAL = (*env)->GetCharField(env, obj,fieldID);
1507 GetShortField(obj,fieldID)
1508 JNIEnv * env = FETCHENV;
1514 RETVAL = (*env)->GetShortField(env, obj,fieldID);
1521 GetIntField(obj,fieldID)
1522 JNIEnv * env = FETCHENV;
1528 RETVAL = (*env)->GetIntField(env, obj,fieldID);
1535 GetLongField(obj,fieldID)
1536 JNIEnv * env = FETCHENV;
1542 RETVAL = (*env)->GetLongField(env, obj,fieldID);
1549 GetFloatField(obj,fieldID)
1550 JNIEnv * env = FETCHENV;
1556 RETVAL = (*env)->GetFloatField(env, obj,fieldID);
1563 GetDoubleField(obj,fieldID)
1564 JNIEnv * env = FETCHENV;
1570 RETVAL = (*env)->GetDoubleField(env, obj,fieldID);
1577 SetObjectField(obj,fieldID,val)
1578 JNIEnv * env = FETCHENV;
1585 (*env)->SetObjectField(env, obj,fieldID,val);
1590 SetBooleanField(obj,fieldID,val)
1591 JNIEnv * env = FETCHENV;
1598 (*env)->SetBooleanField(env, obj,fieldID,val);
1603 SetByteField(obj,fieldID,val)
1604 JNIEnv * env = FETCHENV;
1611 (*env)->SetByteField(env, obj,fieldID,val);
1616 SetCharField(obj,fieldID,val)
1617 JNIEnv * env = FETCHENV;
1624 (*env)->SetCharField(env, obj,fieldID,val);
1629 SetShortField(obj,fieldID,val)
1630 JNIEnv * env = FETCHENV;
1637 (*env)->SetShortField(env, obj,fieldID,val);
1642 SetIntField(obj,fieldID,val)
1643 JNIEnv * env = FETCHENV;
1650 (*env)->SetIntField(env, obj,fieldID,val);
1655 SetLongField(obj,fieldID,val)
1656 JNIEnv * env = FETCHENV;
1663 (*env)->SetLongField(env, obj,fieldID,val);
1668 SetFloatField(obj,fieldID,val)
1669 JNIEnv * env = FETCHENV;
1676 (*env)->SetFloatField(env, obj,fieldID,val);
1681 SetDoubleField(obj,fieldID,val)
1682 JNIEnv * env = FETCHENV;
1689 (*env)->SetDoubleField(env, obj,fieldID,val);
1694 GetStaticMethodID(clazz,name,sig)
1695 JNIEnv * env = FETCHENV;
1701 RETVAL = (*env)->GetStaticMethodID(env, clazz,name,sig);
1708 CallStaticObjectMethod(clazz,methodID,...)
1709 JNIEnv * env = FETCHENV;
1713 int argoff = $min_args;
1716 jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
1717 RETVAL = (*env)->CallStaticObjectMethodA(env, clazz,methodID,args);
1724 CallStaticObjectMethodA(clazz,methodID,args)
1725 JNIEnv * env = FETCHENV;
1732 RETVAL = (*env)->CallStaticObjectMethodA(env, clazz,methodID,args);
1739 CallStaticBooleanMethod(clazz,methodID,...)
1740 JNIEnv * env = FETCHENV;
1744 int argoff = $min_args;
1747 jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
1748 RETVAL = (*env)->CallStaticBooleanMethodA(env, clazz,methodID,args);
1755 CallStaticBooleanMethodA(clazz,methodID,args)
1756 JNIEnv * env = FETCHENV;
1763 RETVAL = (*env)->CallStaticBooleanMethodA(env, clazz,methodID,args);
1770 CallStaticByteMethod(clazz,methodID,...)
1771 JNIEnv * env = FETCHENV;
1775 int argoff = $min_args;
1778 jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
1779 RETVAL = (*env)->CallStaticByteMethodA(env, clazz,methodID,args);
1786 CallStaticByteMethodA(clazz,methodID,args)
1787 JNIEnv * env = FETCHENV;
1794 RETVAL = (*env)->CallStaticByteMethodA(env, clazz,methodID,args);
1801 CallStaticCharMethod(clazz,methodID,...)
1802 JNIEnv * env = FETCHENV;
1806 int argoff = $min_args;
1809 jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
1810 RETVAL = (*env)->CallStaticCharMethodA(env, clazz,methodID,args);
1817 CallStaticCharMethodA(clazz,methodID,args)
1818 JNIEnv * env = FETCHENV;
1825 RETVAL = (*env)->CallStaticCharMethodA(env, clazz,methodID,args);
1832 CallStaticShortMethod(clazz,methodID,...)
1833 JNIEnv * env = FETCHENV;
1837 int argoff = $min_args;
1840 jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
1841 RETVAL = (*env)->CallStaticShortMethodA(env, clazz,methodID,args);
1848 CallStaticShortMethodA(clazz,methodID,args)
1849 JNIEnv * env = FETCHENV;
1856 RETVAL = (*env)->CallStaticShortMethodA(env, clazz,methodID,args);
1863 CallStaticIntMethod(clazz,methodID,...)
1864 JNIEnv * env = FETCHENV;
1868 int argoff = $min_args;
1871 jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
1872 RETVAL = (*env)->CallStaticIntMethodA(env, clazz,methodID,args);
1879 CallStaticIntMethodA(clazz,methodID,args)
1880 JNIEnv * env = FETCHENV;
1887 RETVAL = (*env)->CallStaticIntMethodA(env, clazz,methodID,args);
1894 CallStaticLongMethod(clazz,methodID,...)
1895 JNIEnv * env = FETCHENV;
1899 int argoff = $min_args;
1902 jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
1903 RETVAL = (*env)->CallStaticLongMethodA(env, clazz,methodID,args);
1910 CallStaticLongMethodA(clazz,methodID,args)
1911 JNIEnv * env = FETCHENV;
1918 RETVAL = (*env)->CallStaticLongMethodA(env, clazz,methodID,args);
1925 CallStaticFloatMethod(clazz,methodID,...)
1926 JNIEnv * env = FETCHENV;
1930 int argoff = $min_args;
1933 jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
1934 RETVAL = (*env)->CallStaticFloatMethodA(env, clazz,methodID,args);
1941 CallStaticFloatMethodA(clazz,methodID,args)
1942 JNIEnv * env = FETCHENV;
1949 RETVAL = (*env)->CallStaticFloatMethodA(env, clazz,methodID,args);
1956 CallStaticDoubleMethod(clazz,methodID,...)
1957 JNIEnv * env = FETCHENV;
1961 int argoff = $min_args;
1964 jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
1965 RETVAL = (*env)->CallStaticDoubleMethodA(env, clazz,methodID,args);
1972 CallStaticDoubleMethodA(clazz,methodID,args)
1973 JNIEnv * env = FETCHENV;
1980 RETVAL = (*env)->CallStaticDoubleMethodA(env, clazz,methodID,args);
1987 CallStaticVoidMethod(cls,methodID,...)
1988 JNIEnv * env = FETCHENV;
1992 int argoff = $min_args;
1995 jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
1996 (*env)->CallStaticVoidMethodA(env, cls,methodID,args);
2001 CallStaticVoidMethodA(cls,methodID,args)
2002 JNIEnv * env = FETCHENV;
2009 (*env)->CallStaticVoidMethodA(env, cls,methodID,args);
2014 GetStaticFieldID(clazz,name,sig)
2015 JNIEnv * env = FETCHENV;
2021 RETVAL = (*env)->GetStaticFieldID(env, clazz,name,sig);
2028 GetStaticObjectField(clazz,fieldID)
2029 JNIEnv * env = FETCHENV;
2035 RETVAL = (*env)->GetStaticObjectField(env, clazz,fieldID);
2042 GetStaticBooleanField(clazz,fieldID)
2043 JNIEnv * env = FETCHENV;
2049 RETVAL = (*env)->GetStaticBooleanField(env, clazz,fieldID);
2056 GetStaticByteField(clazz,fieldID)
2057 JNIEnv * env = FETCHENV;
2063 RETVAL = (*env)->GetStaticByteField(env, clazz,fieldID);
2070 GetStaticCharField(clazz,fieldID)
2071 JNIEnv * env = FETCHENV;
2077 RETVAL = (*env)->GetStaticCharField(env, clazz,fieldID);
2084 GetStaticShortField(clazz,fieldID)
2085 JNIEnv * env = FETCHENV;
2091 RETVAL = (*env)->GetStaticShortField(env, clazz,fieldID);
2098 GetStaticIntField(clazz,fieldID)
2099 JNIEnv * env = FETCHENV;
2105 RETVAL = (*env)->GetStaticIntField(env, clazz,fieldID);
2112 GetStaticLongField(clazz,fieldID)
2113 JNIEnv * env = FETCHENV;
2119 RETVAL = (*env)->GetStaticLongField(env, clazz,fieldID);
2126 GetStaticFloatField(clazz,fieldID)
2127 JNIEnv * env = FETCHENV;
2133 RETVAL = (*env)->GetStaticFloatField(env, clazz,fieldID);
2140 GetStaticDoubleField(clazz,fieldID)
2141 JNIEnv * env = FETCHENV;
2147 RETVAL = (*env)->GetStaticDoubleField(env, clazz,fieldID);
2154 SetStaticObjectField(clazz,fieldID,value)
2155 JNIEnv * env = FETCHENV;
2162 (*env)->SetStaticObjectField(env, clazz,fieldID,value);
2167 SetStaticBooleanField(clazz,fieldID,value)
2168 JNIEnv * env = FETCHENV;
2175 (*env)->SetStaticBooleanField(env, clazz,fieldID,value);
2180 SetStaticByteField(clazz,fieldID,value)
2181 JNIEnv * env = FETCHENV;
2188 (*env)->SetStaticByteField(env, clazz,fieldID,value);
2193 SetStaticCharField(clazz,fieldID,value)
2194 JNIEnv * env = FETCHENV;
2201 (*env)->SetStaticCharField(env, clazz,fieldID,value);
2206 SetStaticShortField(clazz,fieldID,value)
2207 JNIEnv * env = FETCHENV;
2214 (*env)->SetStaticShortField(env, clazz,fieldID,value);
2219 SetStaticIntField(clazz,fieldID,value)
2220 JNIEnv * env = FETCHENV;
2227 (*env)->SetStaticIntField(env, clazz,fieldID,value);
2232 SetStaticLongField(clazz,fieldID,value)
2233 JNIEnv * env = FETCHENV;
2240 (*env)->SetStaticLongField(env, clazz,fieldID,value);
2245 SetStaticFloatField(clazz,fieldID,value)
2246 JNIEnv * env = FETCHENV;
2253 (*env)->SetStaticFloatField(env, clazz,fieldID,value);
2258 SetStaticDoubleField(clazz,fieldID,value)
2259 JNIEnv * env = FETCHENV;
2266 (*env)->SetStaticDoubleField(env, clazz,fieldID,value);
2272 JNIEnv * env = FETCHENV;
2273 STRLEN tmplen = NO_INIT;
2274 jsize unicode_len_ = NO_INIT;
2275 const jchar * unicode
2278 RETVAL = (*env)->NewString(env, unicode, unicode_len_);
2285 GetStringLength(str)
2286 JNIEnv * env = FETCHENV;
2290 RETVAL = (*env)->GetStringLength(env, str);
2298 JNIEnv * env = FETCHENV;
2300 jboolean isCopy = NO_INIT;
2301 jsize RETVAL_len_ = NO_INIT;
2304 RETVAL = (*env)->GetStringChars(env, str,&isCopy);
2305 RETVAL_len_ = (*env)->GetStringLength(env, str);
2311 (*env)->ReleaseStringChars(env, str,RETVAL);
2315 JNIEnv * env = FETCHENV;
2319 RETVAL = (*env)->NewStringUTF(env, utf);
2326 GetStringUTFLength(str)
2327 JNIEnv * env = FETCHENV;
2331 RETVAL = (*env)->GetStringUTFLength(env, str);
2338 GetStringUTFChars(str)
2339 JNIEnv * env = FETCHENV;
2341 jboolean isCopy = NO_INIT;
2344 RETVAL = (*env)->GetStringUTFChars(env, str,&isCopy);
2350 (*env)->ReleaseStringUTFChars(env, str, RETVAL);
2354 GetArrayLength(array)
2355 JNIEnv * env = FETCHENV;
2359 RETVAL = (*env)->GetArrayLength(env, array);
2366 NewObjectArray(len,clazz,init)
2367 JNIEnv * env = FETCHENV;
2373 RETVAL = (*env)->NewObjectArray(env, len,clazz,init);
2380 GetObjectArrayElement(array,index)
2381 JNIEnv * env = FETCHENV;
2386 RETVAL = (*env)->GetObjectArrayElement(env, array,index);
2393 SetObjectArrayElement(array,index,val)
2394 JNIEnv * env = FETCHENV;
2400 (*env)->SetObjectArrayElement(env, array,index,val);
2405 NewBooleanArray(len)
2406 JNIEnv * env = FETCHENV;
2410 RETVAL = (*env)->NewBooleanArray(env, len);
2418 JNIEnv * env = FETCHENV;
2422 RETVAL = (*env)->NewByteArray(env, len);
2430 JNIEnv * env = FETCHENV;
2434 RETVAL = (*env)->NewCharArray(env, len);
2442 JNIEnv * env = FETCHENV;
2446 RETVAL = (*env)->NewShortArray(env, len);
2454 JNIEnv * env = FETCHENV;
2458 RETVAL = (*env)->NewIntArray(env, len);
2466 JNIEnv * env = FETCHENV;
2470 RETVAL = (*env)->NewLongArray(env, len);
2478 JNIEnv * env = FETCHENV;
2482 RETVAL = (*env)->NewFloatArray(env, len);
2490 JNIEnv * env = FETCHENV;
2494 RETVAL = (*env)->NewDoubleArray(env, len);
2501 GetBooleanArrayElements(array)
2502 JNIEnv * env = FETCHENV;
2503 jsize RETVAL_len_ = NO_INIT;
2505 jboolean isCopy = NO_INIT;
2508 RETVAL = (*env)->GetBooleanArrayElements(env, array,&isCopy);
2509 RETVAL_len_ = (*env)->GetArrayLength(env, array);
2510 if (GIMME == G_ARRAY) {
2512 jboolean* r = RETVAL;
2513 EXTEND(sp, RETVAL_len_);
2514 for (i = RETVAL_len_; i; --i) {
2515 PUSHs(sv_2mortal(newSViv(*r++)));
2520 PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
2521 (STRLEN)RETVAL_len_ * sizeof(jboolean))));
2526 (*env)->ReleaseBooleanArrayElements(env, array,RETVAL,JNI_ABORT);
2531 GetByteArrayElements(array)
2532 JNIEnv * env = FETCHENV;
2533 jsize RETVAL_len_ = NO_INIT;
2535 jboolean isCopy = NO_INIT;
2538 RETVAL = (*env)->GetByteArrayElements(env, array,&isCopy);
2539 RETVAL_len_ = (*env)->GetArrayLength(env, array);
2540 if (GIMME == G_ARRAY) {
2543 EXTEND(sp, RETVAL_len_);
2544 for (i = RETVAL_len_; i; --i) {
2545 PUSHs(sv_2mortal(newSViv(*r++)));
2550 PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
2551 (STRLEN)RETVAL_len_ * sizeof(jbyte))));
2556 (*env)->ReleaseByteArrayElements(env, array,RETVAL,JNI_ABORT);
2561 GetCharArrayElements(array)
2562 JNIEnv * env = FETCHENV;
2563 jsize RETVAL_len_ = NO_INIT;
2565 jboolean isCopy = NO_INIT;
2568 RETVAL = (*env)->GetCharArrayElements(env, array,&isCopy);
2569 RETVAL_len_ = (*env)->GetArrayLength(env, array);
2570 if (GIMME == G_ARRAY) {
2573 EXTEND(sp, RETVAL_len_);
2574 for (i = RETVAL_len_; i; --i) {
2575 PUSHs(sv_2mortal(newSViv(*r++)));
2580 PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
2581 (STRLEN)RETVAL_len_ * sizeof(jchar))));
2586 (*env)->ReleaseCharArrayElements(env, array,RETVAL,JNI_ABORT);
2591 GetShortArrayElements(array)
2592 JNIEnv * env = FETCHENV;
2593 jsize RETVAL_len_ = NO_INIT;
2595 jboolean isCopy = NO_INIT;
2598 RETVAL = (*env)->GetShortArrayElements(env, array,&isCopy);
2599 RETVAL_len_ = (*env)->GetArrayLength(env, array);
2600 if (GIMME == G_ARRAY) {
2603 EXTEND(sp, RETVAL_len_);
2604 for (i = RETVAL_len_; i; --i) {
2605 PUSHs(sv_2mortal(newSViv(*r++)));
2610 PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
2611 (STRLEN)RETVAL_len_ * sizeof(jshort))));
2616 (*env)->ReleaseShortArrayElements(env, array,RETVAL,JNI_ABORT);
2621 GetIntArrayElements(array)
2622 JNIEnv * env = FETCHENV;
2623 jsize RETVAL_len_ = NO_INIT;
2625 jboolean isCopy = NO_INIT;
2628 RETVAL = (*env)->GetIntArrayElements(env, array,&isCopy);
2629 RETVAL_len_ = (*env)->GetArrayLength(env, array);
2630 if (GIMME == G_ARRAY) {
2633 EXTEND(sp, RETVAL_len_);
2634 for (i = RETVAL_len_; i; --i) {
2635 PUSHs(sv_2mortal(newSViv(*r++)));
2640 PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
2641 (STRLEN)RETVAL_len_ * sizeof(jint))));
2646 (*env)->ReleaseIntArrayElements(env, array,RETVAL,JNI_ABORT);
2651 GetLongArrayElements(array)
2652 JNIEnv * env = FETCHENV;
2653 jsize RETVAL_len_ = NO_INIT;
2655 jboolean isCopy = NO_INIT;
2658 RETVAL = (*env)->GetLongArrayElements(env, array,&isCopy);
2659 RETVAL_len_ = (*env)->GetArrayLength(env, array);
2660 if (GIMME == G_ARRAY) {
2663 EXTEND(sp, RETVAL_len_);
2664 for (i = RETVAL_len_; i; --i) {
2665 PUSHs(sv_2mortal(newSViv(*r++)));
2670 PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
2671 (STRLEN)RETVAL_len_ * sizeof(jlong))));
2676 (*env)->ReleaseLongArrayElements(env, array,RETVAL,JNI_ABORT);
2681 GetFloatArrayElements(array)
2682 JNIEnv * env = FETCHENV;
2683 jsize RETVAL_len_ = NO_INIT;
2685 jboolean isCopy = NO_INIT;
2688 RETVAL = (*env)->GetFloatArrayElements(env, array,&isCopy);
2689 RETVAL_len_ = (*env)->GetArrayLength(env, array);
2690 if (GIMME == G_ARRAY) {
2693 EXTEND(sp, RETVAL_len_);
2694 for (i = RETVAL_len_; i; --i) {
2695 PUSHs(sv_2mortal(newSVnv(*r++)));
2700 PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
2701 (STRLEN)RETVAL_len_ * sizeof(jfloat))));
2706 (*env)->ReleaseFloatArrayElements(env, array,RETVAL,JNI_ABORT);
2711 GetDoubleArrayElements(array)
2712 JNIEnv * env = FETCHENV;
2713 jsize RETVAL_len_ = NO_INIT;
2715 jboolean isCopy = NO_INIT;
2718 RETVAL = (*env)->GetDoubleArrayElements(env, array,&isCopy);
2719 RETVAL_len_ = (*env)->GetArrayLength(env, array);
2720 if (GIMME == G_ARRAY) {
2722 jdouble* r = RETVAL;
2723 EXTEND(sp, RETVAL_len_);
2724 for (i = RETVAL_len_; i; --i) {
2725 PUSHs(sv_2mortal(newSVnv(*r++)));
2730 PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
2731 (STRLEN)RETVAL_len_ * sizeof(jdouble))));
2736 (*env)->ReleaseDoubleArrayElements(env, array,RETVAL,JNI_ABORT);
2741 GetBooleanArrayRegion(array,start,len,buf)
2742 JNIEnv * env = FETCHENV;
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);
2751 (*env)->GetBooleanArrayRegion(env, array,start,len,buf);
2752 SvCUR_set(ST(3), len * sizeof(jboolean));
2753 *SvEND(ST(3)) = '\0';
2758 GetByteArrayRegion(array,start,len,buf)
2759 JNIEnv * env = FETCHENV;
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);
2768 (*env)->GetByteArrayRegion(env, array,start,len,buf);
2769 SvCUR_set(ST(3), len * sizeof(jbyte));
2770 *SvEND(ST(3)) = '\0';
2775 GetCharArrayRegion(array,start,len,buf)
2776 JNIEnv * env = FETCHENV;
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);
2785 (*env)->GetCharArrayRegion(env, array,start,len,buf);
2786 SvCUR_set(ST(3), len * sizeof(jchar));
2787 *SvEND(ST(3)) = '\0';
2792 GetShortArrayRegion(array,start,len,buf)
2793 JNIEnv * env = FETCHENV;
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);
2802 (*env)->GetShortArrayRegion(env, array,start,len,buf);
2803 SvCUR_set(ST(3), len * sizeof(jshort));
2804 *SvEND(ST(3)) = '\0';
2809 GetIntArrayRegion(array,start,len,buf)
2810 JNIEnv * env = FETCHENV;
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);
2819 (*env)->GetIntArrayRegion(env, array,start,len,buf);
2820 SvCUR_set(ST(3), len * sizeof(jint));
2821 *SvEND(ST(3)) = '\0';
2826 GetLongArrayRegion(array,start,len,buf)
2827 JNIEnv * env = FETCHENV;
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);
2836 (*env)->GetLongArrayRegion(env, array,start,len,buf);
2837 SvCUR_set(ST(3), len * sizeof(jlong));
2838 *SvEND(ST(3)) = '\0';
2843 GetFloatArrayRegion(array,start,len,buf)
2844 JNIEnv * env = FETCHENV;
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);
2853 (*env)->GetFloatArrayRegion(env, array,start,len,buf);
2854 SvCUR_set(ST(3), len * sizeof(jfloat));
2855 *SvEND(ST(3)) = '\0';
2860 GetDoubleArrayRegion(array,start,len,buf)
2861 JNIEnv * env = FETCHENV;
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);
2870 (*env)->GetDoubleArrayRegion(env, array,start,len,buf);
2871 SvCUR_set(ST(3), len * sizeof(jdouble));
2872 *SvEND(ST(3)) = '\0';
2877 SetBooleanArrayRegion(array,start,len,buf)
2878 JNIEnv * env = FETCHENV;
2879 STRLEN tmplen = NO_INIT;
2883 jsize buf_len_ = NO_INIT;
2888 Perl_croak(aTHX_ "string is too short");
2889 else if (buf_len_ > len && PL_dowarn)
2890 Perl_warn(aTHX_ "string is too long");
2891 (*env)->SetBooleanArrayRegion(env, array,start,len,buf);
2896 SetByteArrayRegion(array,start,len,buf)
2897 JNIEnv * env = FETCHENV;
2898 STRLEN tmplen = NO_INIT;
2902 jsize buf_len_ = NO_INIT;
2907 Perl_croak(aTHX_ "string is too short");
2908 else if (buf_len_ > len && PL_dowarn)
2909 Perl_warn(aTHX_ "string is too long");
2910 (*env)->SetByteArrayRegion(env, array,start,len,buf);
2915 SetCharArrayRegion(array,start,len,buf)
2916 JNIEnv * env = FETCHENV;
2917 STRLEN tmplen = NO_INIT;
2921 jsize buf_len_ = NO_INIT;
2926 Perl_croak(aTHX_ "string is too short");
2927 else if (buf_len_ > len && PL_dowarn)
2928 Perl_warn(aTHX_ "string is too long");
2929 (*env)->SetCharArrayRegion(env, array,start,len,buf);
2934 SetShortArrayRegion(array,start,len,buf)
2935 JNIEnv * env = FETCHENV;
2936 STRLEN tmplen = NO_INIT;
2940 jsize buf_len_ = NO_INIT;
2945 Perl_croak(aTHX_ "string is too short");
2946 else if (buf_len_ > len && PL_dowarn)
2947 Perl_warn(aTHX_ "string is too long");
2948 (*env)->SetShortArrayRegion(env, array,start,len,buf);
2953 SetIntArrayRegion(array,start,len,buf)
2954 JNIEnv * env = FETCHENV;
2955 STRLEN tmplen = NO_INIT;
2959 jsize buf_len_ = NO_INIT;
2964 Perl_croak(aTHX_ "string is too short");
2965 else if (buf_len_ > len && PL_dowarn)
2966 Perl_warn(aTHX_ "string is too long");
2967 (*env)->SetIntArrayRegion(env, array,start,len,buf);
2972 SetLongArrayRegion(array,start,len,buf)
2973 JNIEnv * env = FETCHENV;
2974 STRLEN tmplen = NO_INIT;
2978 jsize buf_len_ = NO_INIT;
2983 Perl_croak(aTHX_ "string is too short");
2984 else if (buf_len_ > len && PL_dowarn)
2985 Perl_warn(aTHX_ "string is too long");
2986 (*env)->SetLongArrayRegion(env, array,start,len,buf);
2991 SetFloatArrayRegion(array,start,len,buf)
2992 JNIEnv * env = FETCHENV;
2993 STRLEN tmplen = NO_INIT;
2997 jsize buf_len_ = NO_INIT;
3002 Perl_croak(aTHX_ "string is too short");
3003 else if (buf_len_ > len && PL_dowarn)
3004 Perl_warn(aTHX_ "string is too long");
3005 (*env)->SetFloatArrayRegion(env, array,start,len,buf);
3010 SetDoubleArrayRegion(array,start,len,buf)
3011 JNIEnv * env = FETCHENV;
3012 STRLEN tmplen = NO_INIT;
3016 jsize buf_len_ = NO_INIT;
3021 Perl_croak(aTHX_ "string is too short");
3022 else if (buf_len_ > len && PL_dowarn)
3023 Perl_warn(aTHX_ "string is too long");
3024 (*env)->SetDoubleArrayRegion(env, array,start,len,buf);
3029 RegisterNatives(clazz,methods,nMethods)
3030 JNIEnv * env = FETCHENV;
3032 JNINativeMethod * methods
3036 RETVAL = (*env)->RegisterNatives(env, clazz,methods,nMethods);
3040 UnregisterNatives(clazz)
3041 JNIEnv * env = FETCHENV;
3045 RETVAL = (*env)->UnregisterNatives(env, clazz);
3052 JNIEnv * env = FETCHENV;
3056 RETVAL = (*env)->MonitorEnter(env, obj);
3064 JNIEnv * env = FETCHENV;
3068 RETVAL = (*env)->MonitorExit(env, obj);
3076 JNIEnv * env = FETCHENV;
3079 if (env) { /* We're embedded. */
3080 if ((*env)->GetJavaVM(env, &RETVAL) < 0)
3083 else { /* We're embedding. */
3084 JDK1_1InitArgs vm_args;
3089 lib = SvPV(*mark, PL_na);
3094 if (!dlopen("libjava.so", RTLD_LAZY|RTLD_GLOBAL)) {
3095 if (lib && !dlopen(lib, RTLD_LAZY|RTLD_GLOBAL))
3096 Perl_croak(aTHX_ "Can't load libjava.so");
3099 JNI_GetDefaultJavaVMInitArgs(&vm_args);
3100 vm_args.exit = &call_my_exit;
3102 char *s = SvPV(*++mark,PL_na);
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"))
3117 vm_args.classpath = savepv(SvPV(*++mark,PL_na));
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);
3131 Perl_croak(aTHX_ "unrecognized option: %s", s);
3133 JNI_CreateJavaVM(&RETVAL, &jplcurenv, &vm_args);