2 * Copyright 1997, O'Reilly & Associate, Inc.
4 * This package may be copied under the same terms as Perl itself.
16 extern JNIEnv* jplcurenv;
21 static void call_my_exit(jint status)
27 makeargs(char *sig, SV** svp, int items)
29 jvalue* jv = (jvalue*)safemalloc(sizeof(jvalue) * items);
32 JNIEnv* env = jplcurenv;
37 fprintf(stderr, "sig = %s, items = %d\n", sig, items);
46 jv[ix++].z = (jboolean)(SvIV(sv) != 0);
49 jv[ix++].b = (jbyte)SvIV(sv);
52 jv[ix++].c = (jchar)SvIV(sv);
55 jv[ix++].s = (jshort)SvIV(sv);
58 jv[ix++].i = (jint)SvIV(sv);
61 jv[ix++].j = (jlong)SvNV(sv);
64 jv[ix++].f = (jfloat)SvNV(sv);
67 jv[ix++].d = (jdouble)SvNV(sv);
73 SV* rv = (SV*)SvRV(sv);
75 jv[ix++].l = (jobject)(void*)SvIV(rv);
76 else if (SvTYPE(rv) == SVt_PVAV) {
77 jsize len = av_len((AV*)rv) + 1;
78 jboolean* buf = (jboolean*)malloc(len * sizeof(jboolean));
82 jbooleanArray ja = (*env)->NewBooleanArray(env, len);
83 for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
84 buf[i] = (jboolean)SvIV(*esv);
85 (*env)->SetBooleanArrayRegion(env, ja, 0, len, buf);
87 jv[ix++].l = (jobject)ja;
90 jv[ix++].l = (jobject)(void*)0;
93 jsize len = sv_len(sv) / sizeof(jboolean);
95 jbooleanArray ja = (*env)->NewBooleanArray(env, len);
96 (*env)->SetBooleanArrayRegion(env, ja, 0, len, (jboolean*)SvPV(sv,n_a));
97 jv[ix++].l = (jobject)ja;
100 jv[ix++].l = (jobject)(void*)0;
104 SV* rv = (SV*)SvRV(sv);
106 jv[ix++].l = (jobject)(void*)SvIV(rv);
107 else if (SvTYPE(rv) == SVt_PVAV) {
108 jsize len = av_len((AV*)rv) + 1;
109 jbyte* buf = (jbyte*)malloc(len * sizeof(jbyte));
113 jbyteArray ja = (*env)->NewByteArray(env, len);
114 for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
115 buf[i] = (jbyte)SvIV(*esv);
116 (*env)->SetByteArrayRegion(env, ja, 0, len, buf);
118 jv[ix++].l = (jobject)ja;
121 jv[ix++].l = (jobject)(void*)0;
123 else if (SvPOK(sv)) {
124 jsize len = sv_len(sv) / sizeof(jbyte);
126 jbyteArray ja = (*env)->NewByteArray(env, len);
127 (*env)->SetByteArrayRegion(env, ja, 0, len, (jbyte*)SvPV(sv,n_a));
128 jv[ix++].l = (jobject)ja;
131 jv[ix++].l = (jobject)(void*)0;
135 SV* rv = (SV*)SvRV(sv);
137 jv[ix++].l = (jobject)(void*)SvIV(rv);
138 else if (SvTYPE(rv) == SVt_PVAV) {
139 jsize len = av_len((AV*)rv) + 1;
140 jchar* buf = (jchar*)malloc(len * sizeof(jchar));
144 jcharArray ja = (*env)->NewCharArray(env, len);
145 for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
146 buf[i] = (jchar)SvIV(*esv);
147 (*env)->SetCharArrayRegion(env, ja, 0, len, buf);
149 jv[ix++].l = (jobject)ja;
152 jv[ix++].l = (jobject)(void*)0;
154 else if (SvPOK(sv)) {
155 jsize len = sv_len(sv) / sizeof(jchar);
157 jcharArray ja = (*env)->NewCharArray(env, len);
158 (*env)->SetCharArrayRegion(env, ja, 0, len, (jchar*)SvPV(sv,n_a));
159 jv[ix++].l = (jobject)ja;
162 jv[ix++].l = (jobject)(void*)0;
166 SV* rv = (SV*)SvRV(sv);
168 jv[ix++].l = (jobject)(void*)SvIV(rv);
169 else if (SvTYPE(rv) == SVt_PVAV) {
170 jsize len = av_len((AV*)rv) + 1;
171 jshort* buf = (jshort*)malloc(len * sizeof(jshort));
175 jshortArray ja = (*env)->NewShortArray(env, len);
176 for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
177 buf[i] = (jshort)SvIV(*esv);
178 (*env)->SetShortArrayRegion(env, ja, 0, len, buf);
180 jv[ix++].l = (jobject)ja;
183 jv[ix++].l = (jobject)(void*)0;
185 else if (SvPOK(sv)) {
186 jsize len = sv_len(sv) / sizeof(jshort);
188 jshortArray ja = (*env)->NewShortArray(env, len);
189 (*env)->SetShortArrayRegion(env, ja, 0, len, (jshort*)SvPV(sv,n_a));
190 jv[ix++].l = (jobject)ja;
193 jv[ix++].l = (jobject)(void*)0;
197 SV* rv = (SV*)SvRV(sv);
199 jv[ix++].l = (jobject)(void*)SvIV(rv);
200 else if (SvTYPE(rv) == SVt_PVAV) {
201 jsize len = av_len((AV*)rv) + 1;
202 jint* buf = (jint*)malloc(len * sizeof(jint));
206 jintArray ja = (*env)->NewIntArray(env, len);
207 for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
208 buf[i] = (jint)SvIV(*esv);
209 (*env)->SetIntArrayRegion(env, ja, 0, len, buf);
211 jv[ix++].l = (jobject)ja;
214 jv[ix++].l = (jobject)(void*)0;
216 else if (SvPOK(sv)) {
217 jsize len = sv_len(sv) / sizeof(jint);
219 jintArray ja = (*env)->NewIntArray(env, len);
220 (*env)->SetIntArrayRegion(env, ja, 0, len, (jint*)SvPV(sv,n_a));
221 jv[ix++].l = (jobject)ja;
224 jv[ix++].l = (jobject)(void*)0;
228 SV* rv = (SV*)SvRV(sv);
230 jv[ix++].l = (jobject)(void*)SvIV(rv);
231 else if (SvTYPE(rv) == SVt_PVAV) {
232 jsize len = av_len((AV*)rv) + 1;
233 jlong* buf = (jlong*)malloc(len * sizeof(jlong));
237 jlongArray ja = (*env)->NewLongArray(env, len);
238 for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
239 buf[i] = (jlong)SvNV(*esv);
240 (*env)->SetLongArrayRegion(env, ja, 0, len, buf);
242 jv[ix++].l = (jobject)ja;
245 jv[ix++].l = (jobject)(void*)0;
247 else if (SvPOK(sv)) {
248 jsize len = sv_len(sv) / sizeof(jlong);
250 jlongArray ja = (*env)->NewLongArray(env, len);
251 (*env)->SetLongArrayRegion(env, ja, 0, len, (jlong*)SvPV(sv,n_a));
252 jv[ix++].l = (jobject)ja;
255 jv[ix++].l = (jobject)(void*)0;
259 SV* rv = (SV*)SvRV(sv);
261 jv[ix++].l = (jobject)(void*)SvIV(rv);
262 else if (SvTYPE(rv) == SVt_PVAV) {
263 jsize len = av_len((AV*)rv) + 1;
264 jfloat* buf = (jfloat*)malloc(len * sizeof(jfloat));
268 jfloatArray ja = (*env)->NewFloatArray(env, len);
269 for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
270 buf[i] = (jfloat)SvNV(*esv);
271 (*env)->SetFloatArrayRegion(env, ja, 0, len, buf);
273 jv[ix++].l = (jobject)ja;
276 jv[ix++].l = (jobject)(void*)0;
278 else if (SvPOK(sv)) {
279 jsize len = sv_len(sv) / sizeof(jfloat);
281 jfloatArray ja = (*env)->NewFloatArray(env, len);
282 (*env)->SetFloatArrayRegion(env, ja, 0, len, (jfloat*)SvPV(sv,n_a));
283 jv[ix++].l = (jobject)ja;
286 jv[ix++].l = (jobject)(void*)0;
290 SV* rv = (SV*)SvRV(sv);
292 jv[ix++].l = (jobject)(void*)SvIV(rv);
293 else if (SvTYPE(rv) == SVt_PVAV) {
294 jsize len = av_len((AV*)rv) + 1;
295 jdouble* buf = (jdouble*)malloc(len * sizeof(jdouble));
299 jdoubleArray ja = (*env)->NewDoubleArray(env, len);
300 for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
301 buf[i] = (jdouble)SvNV(*esv);
302 (*env)->SetDoubleArrayRegion(env, ja, 0, len, buf);
304 jv[ix++].l = (jobject)ja;
307 jv[ix++].l = (jobject)(void*)0;
309 else if (SvPOK(sv)) {
310 jsize len = sv_len(sv) / sizeof(jdouble);
312 jdoubleArray ja = (*env)->NewDoubleArray(env, len);
313 (*env)->SetDoubleArrayRegion(env, ja, 0, len, (jdouble*)SvPV(sv,n_a));
314 jv[ix++].l = (jobject)ja;
317 jv[ix++].l = (jobject)(void*)0;
320 while (*s != ';') s++;
322 if (strnEQ(start, "[Ljava/lang/String;", 19)) {
324 SV* rv = (SV*)SvRV(sv);
326 jv[ix++].l = (jobject)(void*)SvIV(rv);
327 else if (SvTYPE(rv) == SVt_PVAV) {
328 jsize len = av_len((AV*)rv) + 1;
331 static jclass jcl = 0;
335 jcl = (*env)->FindClass(env, "java/lang/String");
336 ja = (*env)->NewObjectArray(env, len, jcl, 0);
337 for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++) {
338 jobject str = (jobject)(*env)->NewStringUTF(env, SvPV(*esv,n_a));
339 (*env)->SetObjectArrayElement(env, ja, i, str);
341 jv[ix++].l = (jobject)ja;
344 jv[ix++].l = (jobject)(void*)0;
347 jv[ix++].l = (jobject)(void*)0;
353 SV* rv = (SV*)SvRV(sv);
355 jv[ix++].l = (jobject)(void*)SvIV(rv);
356 else if (SvTYPE(rv) == SVt_PVAV) {
357 jsize len = av_len((AV*)rv) + 1;
360 static jclass jcl = 0;
364 jcl = (*env)->FindClass(env, "java/lang/Object");
365 ja = (*env)->NewObjectArray(env, len, jcl, 0);
366 for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++) {
367 if (SvROK(*esv) && (rv = SvRV(*esv)) && SvOBJECT(rv)) {
368 (*env)->SetObjectArrayElement(env, ja, i,
369 (jobject)(void*)SvIV(rv));
372 jobject str = (jobject)(*env)->NewStringUTF(env,
374 (*env)->SetObjectArrayElement(env, ja, i, str);
377 jv[ix++].l = (jobject)ja;
380 jv[ix++].l = (jobject)(void*)0;
383 jv[ix++].l = (jobject)(void*)0;
388 if (!SvROK(sv) || strnEQ(s, "java/lang/String;", 17)) {
390 jv[ix++].l = (jobject)(*env)->NewStringUTF(env,
391 (char*) SvPV(sv,n_a));
394 while (*s != ';') s++;
398 jv[ix++].l = (jobject)(void*)SvIV(rv);
402 croak("too many arguments, signature: %s", sig);
405 croak("panic: malformed signature: %s", s-1);
411 croak("not enough arguments, signature: %s", sig);
425 croak("%s not implemented on this architecture", s);
455 if (strEQ(name, "JNI_ABORT"))
461 if (strEQ(name, "JNI_COMMIT"))
467 if (strEQ(name, "JNI_ERR"))
473 if (strEQ(name, "JNI_FALSE"))
479 if (strEQ(name, "JNI_H"))
485 if (strEQ(name, "JNI_OK"))
491 if (strEQ(name, "JNI_TRUE"))
539 #define FETCHENV jplcurenv
540 #define RESTOREENV jplcurenv = env
542 MODULE = JNI PACKAGE = JNI
553 JNIEnv * env = FETCHENV;
556 RETVAL = (*env)->GetVersion(env);
563 DefineClass(name, loader, buf)
564 JNIEnv * env = FETCHENV;
565 STRLEN tmplen = NO_INIT;
566 jsize buf_len_ = NO_INIT;
572 RETVAL = (*env)->DefineClass(env, name, loader, buf, (jsize)buf_len_);
580 JNIEnv * env = FETCHENV;
584 RETVAL = (*env)->FindClass(env, name);
592 JNIEnv * env = FETCHENV;
596 RETVAL = (*env)->GetSuperclass(env, sub);
603 IsAssignableFrom(sub, sup)
604 JNIEnv * env = FETCHENV;
609 RETVAL = (*env)->IsAssignableFrom(env, sub, sup);
617 JNIEnv * env = FETCHENV;
621 RETVAL = (*env)->Throw(env, obj);
629 JNIEnv * env = FETCHENV;
634 RETVAL = (*env)->ThrowNew(env, clazz, msg);
642 JNIEnv * env = FETCHENV;
645 RETVAL = (*env)->ExceptionOccurred(env);
653 JNIEnv * env = FETCHENV;
656 (*env)->ExceptionDescribe(env);
662 JNIEnv * env = FETCHENV;
665 (*env)->ExceptionClear(env);
671 JNIEnv * env = FETCHENV;
675 (*env)->FatalError(env, msg);
681 JNIEnv * env = FETCHENV;
685 RETVAL = (*env)->NewGlobalRef(env, lobj);
692 DeleteGlobalRef(gref)
693 JNIEnv * env = FETCHENV;
697 (*env)->DeleteGlobalRef(env, gref);
703 JNIEnv * env = FETCHENV;
707 (*env)->DeleteLocalRef(env, obj);
712 IsSameObject(obj1,obj2)
713 JNIEnv * env = FETCHENV;
718 RETVAL = (*env)->IsSameObject(env, obj1,obj2);
726 JNIEnv * env = FETCHENV;
730 RETVAL = (*env)->AllocObject(env, clazz);
737 NewObject(clazz,methodID,...)
738 JNIEnv * env = FETCHENV;
742 int argoff = $min_args;
745 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
746 RETVAL = (*env)->NewObjectA(env, clazz,methodID,args);
753 NewObjectA(clazz,methodID,args)
754 JNIEnv * env = FETCHENV;
761 RETVAL = (*env)->NewObjectA(env, clazz,methodID,args);
769 JNIEnv * env = FETCHENV;
773 RETVAL = (*env)->GetObjectClass(env, obj);
780 IsInstanceOf(obj,clazz)
781 JNIEnv * env = FETCHENV;
786 RETVAL = (*env)->IsInstanceOf(env, obj,clazz);
793 GetMethodID(clazz,name,sig)
794 JNIEnv * env = FETCHENV;
800 RETVAL = (*env)->GetMethodID(env, clazz,name,sig);
807 CallObjectMethod(obj,methodID,...)
808 JNIEnv * env = FETCHENV;
812 int argoff = $min_args;
815 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
816 RETVAL = (*env)->CallObjectMethodA(env, obj,methodID,args);
823 CallObjectMethodA(obj,methodID,args)
824 JNIEnv * env = FETCHENV;
831 RETVAL = (*env)->CallObjectMethodA(env, obj,methodID,args);
838 CallBooleanMethod(obj,methodID,...)
839 JNIEnv * env = FETCHENV;
843 int argoff = $min_args;
846 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
847 RETVAL = (*env)->CallBooleanMethodA(env, obj,methodID,args);
854 CallBooleanMethodA(obj,methodID, args)
855 JNIEnv * env = FETCHENV;
862 RETVAL = (*env)->CallBooleanMethodA(env, obj,methodID, args);
869 CallByteMethod(obj,methodID,...)
870 JNIEnv * env = FETCHENV;
874 int argoff = $min_args;
877 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
878 RETVAL = (*env)->CallByteMethodA(env, obj,methodID,args);
885 CallByteMethodA(obj,methodID,args)
886 JNIEnv * env = FETCHENV;
893 RETVAL = (*env)->CallByteMethodA(env, obj,methodID,args);
900 CallCharMethod(obj,methodID,...)
901 JNIEnv * env = FETCHENV;
905 int argoff = $min_args;
908 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
909 RETVAL = (*env)->CallCharMethodA(env, obj,methodID,args);
916 CallCharMethodA(obj,methodID,args)
917 JNIEnv * env = FETCHENV;
924 RETVAL = (*env)->CallCharMethodA(env, obj,methodID,args);
931 CallShortMethod(obj,methodID,...)
932 JNIEnv * env = FETCHENV;
936 int argoff = $min_args;
939 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
940 RETVAL = (*env)->CallShortMethodA(env, obj,methodID,args);
947 CallShortMethodA(obj,methodID,args)
948 JNIEnv * env = FETCHENV;
955 RETVAL = (*env)->CallShortMethodA(env, obj,methodID,args);
962 CallIntMethod(obj,methodID,...)
963 JNIEnv * env = FETCHENV;
967 int argoff = $min_args;
970 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
971 RETVAL = (*env)->CallIntMethodA(env, obj,methodID,args);
978 CallIntMethodA(obj,methodID,args)
979 JNIEnv * env = FETCHENV;
986 RETVAL = (*env)->CallIntMethodA(env, obj,methodID,args);
993 CallLongMethod(obj,methodID,...)
994 JNIEnv * env = FETCHENV;
998 int argoff = $min_args;
1001 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1002 RETVAL = (*env)->CallLongMethodA(env, obj,methodID,args);
1009 CallLongMethodA(obj,methodID,args)
1010 JNIEnv * env = FETCHENV;
1017 RETVAL = (*env)->CallLongMethodA(env, obj,methodID,args);
1024 CallFloatMethod(obj,methodID,...)
1025 JNIEnv * env = FETCHENV;
1029 int argoff = $min_args;
1032 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1033 RETVAL = (*env)->CallFloatMethodA(env, obj,methodID,args);
1040 CallFloatMethodA(obj,methodID,args)
1041 JNIEnv * env = FETCHENV;
1048 RETVAL = (*env)->CallFloatMethodA(env, obj,methodID,args);
1055 CallDoubleMethod(obj,methodID,...)
1056 JNIEnv * env = FETCHENV;
1060 int argoff = $min_args;
1063 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1064 RETVAL = (*env)->CallDoubleMethodA(env, obj,methodID,args);
1071 CallDoubleMethodA(obj,methodID,args)
1072 JNIEnv * env = FETCHENV;
1079 RETVAL = (*env)->CallDoubleMethodA(env, obj,methodID,args);
1086 CallVoidMethod(obj,methodID,...)
1087 JNIEnv * env = FETCHENV;
1091 int argoff = $min_args;
1094 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1095 (*env)->CallVoidMethodA(env, obj,methodID,args);
1100 CallVoidMethodA(obj,methodID,args)
1101 JNIEnv * env = FETCHENV;
1108 (*env)->CallVoidMethodA(env, obj,methodID,args);
1113 CallNonvirtualObjectMethod(obj,clazz,methodID,...)
1114 JNIEnv * env = FETCHENV;
1119 int argoff = $min_args;
1122 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1123 RETVAL = (*env)->CallNonvirtualObjectMethodA(env, obj,clazz,methodID,args);
1130 CallNonvirtualObjectMethodA(obj,clazz,methodID,args)
1131 JNIEnv * env = FETCHENV;
1139 RETVAL = (*env)->CallNonvirtualObjectMethodA(env, obj,clazz,methodID,args);
1146 CallNonvirtualBooleanMethod(obj,clazz,methodID,...)
1147 JNIEnv * env = FETCHENV;
1152 int argoff = $min_args;
1155 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1156 RETVAL = (*env)->CallNonvirtualBooleanMethodA(env, obj,clazz,methodID,args);
1163 CallNonvirtualBooleanMethodA(obj,clazz,methodID, args)
1164 JNIEnv * env = FETCHENV;
1172 RETVAL = (*env)->CallNonvirtualBooleanMethodA(env, obj,clazz,methodID, args);
1179 CallNonvirtualByteMethod(obj,clazz,methodID,...)
1180 JNIEnv * env = FETCHENV;
1185 int argoff = $min_args;
1188 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1189 RETVAL = (*env)->CallNonvirtualByteMethodA(env, obj,clazz,methodID,args);
1196 CallNonvirtualByteMethodA(obj,clazz,methodID,args)
1197 JNIEnv * env = FETCHENV;
1205 RETVAL = (*env)->CallNonvirtualByteMethodA(env, obj,clazz,methodID,args);
1212 CallNonvirtualCharMethod(obj,clazz,methodID,...)
1213 JNIEnv * env = FETCHENV;
1218 int argoff = $min_args;
1221 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1222 RETVAL = (*env)->CallNonvirtualCharMethodA(env, obj,clazz,methodID,args);
1229 CallNonvirtualCharMethodA(obj,clazz,methodID,args)
1230 JNIEnv * env = FETCHENV;
1238 RETVAL = (*env)->CallNonvirtualCharMethodA(env, obj,clazz,methodID,args);
1245 CallNonvirtualShortMethod(obj,clazz,methodID,...)
1246 JNIEnv * env = FETCHENV;
1251 int argoff = $min_args;
1254 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1255 RETVAL = (*env)->CallNonvirtualShortMethodA(env, obj,clazz,methodID,args);
1262 CallNonvirtualShortMethodA(obj,clazz,methodID,args)
1263 JNIEnv * env = FETCHENV;
1271 RETVAL = (*env)->CallNonvirtualShortMethodA(env, obj,clazz,methodID,args);
1278 CallNonvirtualIntMethod(obj,clazz,methodID,...)
1279 JNIEnv * env = FETCHENV;
1284 int argoff = $min_args;
1287 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1288 RETVAL = (*env)->CallNonvirtualIntMethodA(env, obj,clazz,methodID,args);
1295 CallNonvirtualIntMethodA(obj,clazz,methodID,args)
1296 JNIEnv * env = FETCHENV;
1304 RETVAL = (*env)->CallNonvirtualIntMethodA(env, obj,clazz,methodID,args);
1311 CallNonvirtualLongMethod(obj,clazz,methodID,...)
1312 JNIEnv * env = FETCHENV;
1317 int argoff = $min_args;
1320 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1321 RETVAL = (*env)->CallNonvirtualLongMethodA(env, obj,clazz,methodID,args);
1328 CallNonvirtualLongMethodA(obj,clazz,methodID,args)
1329 JNIEnv * env = FETCHENV;
1337 RETVAL = (*env)->CallNonvirtualLongMethodA(env, obj,clazz,methodID,args);
1344 CallNonvirtualFloatMethod(obj,clazz,methodID,...)
1345 JNIEnv * env = FETCHENV;
1350 int argoff = $min_args;
1353 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1354 RETVAL = (*env)->CallNonvirtualFloatMethodA(env, obj,clazz,methodID,args);
1361 CallNonvirtualFloatMethodA(obj,clazz,methodID,args)
1362 JNIEnv * env = FETCHENV;
1370 RETVAL = (*env)->CallNonvirtualFloatMethodA(env, obj,clazz,methodID,args);
1377 CallNonvirtualDoubleMethod(obj,clazz,methodID,...)
1378 JNIEnv * env = FETCHENV;
1383 int argoff = $min_args;
1386 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1387 RETVAL = (*env)->CallNonvirtualDoubleMethodA(env, obj,clazz,methodID,args);
1394 CallNonvirtualDoubleMethodA(obj,clazz,methodID,args)
1395 JNIEnv * env = FETCHENV;
1403 RETVAL = (*env)->CallNonvirtualDoubleMethodA(env, obj,clazz,methodID,args);
1410 CallNonvirtualVoidMethod(obj,clazz,methodID,...)
1411 JNIEnv * env = FETCHENV;
1416 int argoff = $min_args;
1419 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1420 (*env)->CallNonvirtualVoidMethodA(env, obj,clazz,methodID,args);
1425 CallNonvirtualVoidMethodA(obj,clazz,methodID,args)
1426 JNIEnv * env = FETCHENV;
1434 (*env)->CallNonvirtualVoidMethodA(env, obj,clazz,methodID,args);
1439 GetFieldID(clazz,name,sig)
1440 JNIEnv * env = FETCHENV;
1446 RETVAL = (*env)->GetFieldID(env, clazz,name,sig);
1453 GetObjectField(obj,fieldID)
1454 JNIEnv * env = FETCHENV;
1460 RETVAL = (*env)->GetObjectField(env, obj,fieldID);
1467 GetBooleanField(obj,fieldID)
1468 JNIEnv * env = FETCHENV;
1474 RETVAL = (*env)->GetBooleanField(env, obj,fieldID);
1481 GetByteField(obj,fieldID)
1482 JNIEnv * env = FETCHENV;
1488 RETVAL = (*env)->GetByteField(env, obj,fieldID);
1495 GetCharField(obj,fieldID)
1496 JNIEnv * env = FETCHENV;
1502 RETVAL = (*env)->GetCharField(env, obj,fieldID);
1509 GetShortField(obj,fieldID)
1510 JNIEnv * env = FETCHENV;
1516 RETVAL = (*env)->GetShortField(env, obj,fieldID);
1523 GetIntField(obj,fieldID)
1524 JNIEnv * env = FETCHENV;
1530 RETVAL = (*env)->GetIntField(env, obj,fieldID);
1537 GetLongField(obj,fieldID)
1538 JNIEnv * env = FETCHENV;
1544 RETVAL = (*env)->GetLongField(env, obj,fieldID);
1551 GetFloatField(obj,fieldID)
1552 JNIEnv * env = FETCHENV;
1558 RETVAL = (*env)->GetFloatField(env, obj,fieldID);
1565 GetDoubleField(obj,fieldID)
1566 JNIEnv * env = FETCHENV;
1572 RETVAL = (*env)->GetDoubleField(env, obj,fieldID);
1579 SetObjectField(obj,fieldID,val)
1580 JNIEnv * env = FETCHENV;
1587 (*env)->SetObjectField(env, obj,fieldID,val);
1592 SetBooleanField(obj,fieldID,val)
1593 JNIEnv * env = FETCHENV;
1600 (*env)->SetBooleanField(env, obj,fieldID,val);
1605 SetByteField(obj,fieldID,val)
1606 JNIEnv * env = FETCHENV;
1613 (*env)->SetByteField(env, obj,fieldID,val);
1618 SetCharField(obj,fieldID,val)
1619 JNIEnv * env = FETCHENV;
1626 (*env)->SetCharField(env, obj,fieldID,val);
1631 SetShortField(obj,fieldID,val)
1632 JNIEnv * env = FETCHENV;
1639 (*env)->SetShortField(env, obj,fieldID,val);
1644 SetIntField(obj,fieldID,val)
1645 JNIEnv * env = FETCHENV;
1652 (*env)->SetIntField(env, obj,fieldID,val);
1657 SetLongField(obj,fieldID,val)
1658 JNIEnv * env = FETCHENV;
1665 (*env)->SetLongField(env, obj,fieldID,val);
1670 SetFloatField(obj,fieldID,val)
1671 JNIEnv * env = FETCHENV;
1678 (*env)->SetFloatField(env, obj,fieldID,val);
1683 SetDoubleField(obj,fieldID,val)
1684 JNIEnv * env = FETCHENV;
1691 (*env)->SetDoubleField(env, obj,fieldID,val);
1696 GetStaticMethodID(clazz,name,sig)
1697 JNIEnv * env = FETCHENV;
1703 RETVAL = (*env)->GetStaticMethodID(env, clazz,name,sig);
1710 CallStaticObjectMethod(clazz,methodID,...)
1711 JNIEnv * env = FETCHENV;
1715 int argoff = $min_args;
1718 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1719 RETVAL = (*env)->CallStaticObjectMethodA(env, clazz,methodID,args);
1726 CallStaticObjectMethodA(clazz,methodID,args)
1727 JNIEnv * env = FETCHENV;
1734 RETVAL = (*env)->CallStaticObjectMethodA(env, clazz,methodID,args);
1741 CallStaticBooleanMethod(clazz,methodID,...)
1742 JNIEnv * env = FETCHENV;
1746 int argoff = $min_args;
1749 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1750 RETVAL = (*env)->CallStaticBooleanMethodA(env, clazz,methodID,args);
1757 CallStaticBooleanMethodA(clazz,methodID,args)
1758 JNIEnv * env = FETCHENV;
1765 RETVAL = (*env)->CallStaticBooleanMethodA(env, clazz,methodID,args);
1772 CallStaticByteMethod(clazz,methodID,...)
1773 JNIEnv * env = FETCHENV;
1777 int argoff = $min_args;
1780 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1781 RETVAL = (*env)->CallStaticByteMethodA(env, clazz,methodID,args);
1788 CallStaticByteMethodA(clazz,methodID,args)
1789 JNIEnv * env = FETCHENV;
1796 RETVAL = (*env)->CallStaticByteMethodA(env, clazz,methodID,args);
1803 CallStaticCharMethod(clazz,methodID,...)
1804 JNIEnv * env = FETCHENV;
1808 int argoff = $min_args;
1811 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1812 RETVAL = (*env)->CallStaticCharMethodA(env, clazz,methodID,args);
1819 CallStaticCharMethodA(clazz,methodID,args)
1820 JNIEnv * env = FETCHENV;
1827 RETVAL = (*env)->CallStaticCharMethodA(env, clazz,methodID,args);
1834 CallStaticShortMethod(clazz,methodID,...)
1835 JNIEnv * env = FETCHENV;
1839 int argoff = $min_args;
1842 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1843 RETVAL = (*env)->CallStaticShortMethodA(env, clazz,methodID,args);
1850 CallStaticShortMethodA(clazz,methodID,args)
1851 JNIEnv * env = FETCHENV;
1858 RETVAL = (*env)->CallStaticShortMethodA(env, clazz,methodID,args);
1865 CallStaticIntMethod(clazz,methodID,...)
1866 JNIEnv * env = FETCHENV;
1870 int argoff = $min_args;
1873 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1874 RETVAL = (*env)->CallStaticIntMethodA(env, clazz,methodID,args);
1881 CallStaticIntMethodA(clazz,methodID,args)
1882 JNIEnv * env = FETCHENV;
1889 RETVAL = (*env)->CallStaticIntMethodA(env, clazz,methodID,args);
1896 CallStaticLongMethod(clazz,methodID,...)
1897 JNIEnv * env = FETCHENV;
1901 int argoff = $min_args;
1904 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1905 RETVAL = (*env)->CallStaticLongMethodA(env, clazz,methodID,args);
1912 CallStaticLongMethodA(clazz,methodID,args)
1913 JNIEnv * env = FETCHENV;
1920 RETVAL = (*env)->CallStaticLongMethodA(env, clazz,methodID,args);
1927 CallStaticFloatMethod(clazz,methodID,...)
1928 JNIEnv * env = FETCHENV;
1932 int argoff = $min_args;
1935 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1936 RETVAL = (*env)->CallStaticFloatMethodA(env, clazz,methodID,args);
1943 CallStaticFloatMethodA(clazz,methodID,args)
1944 JNIEnv * env = FETCHENV;
1951 RETVAL = (*env)->CallStaticFloatMethodA(env, clazz,methodID,args);
1958 CallStaticDoubleMethod(clazz,methodID,...)
1959 JNIEnv * env = FETCHENV;
1963 int argoff = $min_args;
1966 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1967 RETVAL = (*env)->CallStaticDoubleMethodA(env, clazz,methodID,args);
1974 CallStaticDoubleMethodA(clazz,methodID,args)
1975 JNIEnv * env = FETCHENV;
1982 RETVAL = (*env)->CallStaticDoubleMethodA(env, clazz,methodID,args);
1989 CallStaticVoidMethod(cls,methodID,...)
1990 JNIEnv * env = FETCHENV;
1994 int argoff = $min_args;
1997 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1998 (*env)->CallStaticVoidMethodA(env, cls,methodID,args);
2003 CallStaticVoidMethodA(cls,methodID,args)
2004 JNIEnv * env = FETCHENV;
2011 (*env)->CallStaticVoidMethodA(env, cls,methodID,args);
2016 GetStaticFieldID(clazz,name,sig)
2017 JNIEnv * env = FETCHENV;
2023 RETVAL = (*env)->GetStaticFieldID(env, clazz,name,sig);
2030 GetStaticObjectField(clazz,fieldID)
2031 JNIEnv * env = FETCHENV;
2037 RETVAL = (*env)->GetStaticObjectField(env, clazz,fieldID);
2044 GetStaticBooleanField(clazz,fieldID)
2045 JNIEnv * env = FETCHENV;
2051 RETVAL = (*env)->GetStaticBooleanField(env, clazz,fieldID);
2058 GetStaticByteField(clazz,fieldID)
2059 JNIEnv * env = FETCHENV;
2065 RETVAL = (*env)->GetStaticByteField(env, clazz,fieldID);
2072 GetStaticCharField(clazz,fieldID)
2073 JNIEnv * env = FETCHENV;
2079 RETVAL = (*env)->GetStaticCharField(env, clazz,fieldID);
2086 GetStaticShortField(clazz,fieldID)
2087 JNIEnv * env = FETCHENV;
2093 RETVAL = (*env)->GetStaticShortField(env, clazz,fieldID);
2100 GetStaticIntField(clazz,fieldID)
2101 JNIEnv * env = FETCHENV;
2107 RETVAL = (*env)->GetStaticIntField(env, clazz,fieldID);
2114 GetStaticLongField(clazz,fieldID)
2115 JNIEnv * env = FETCHENV;
2121 RETVAL = (*env)->GetStaticLongField(env, clazz,fieldID);
2128 GetStaticFloatField(clazz,fieldID)
2129 JNIEnv * env = FETCHENV;
2135 RETVAL = (*env)->GetStaticFloatField(env, clazz,fieldID);
2142 GetStaticDoubleField(clazz,fieldID)
2143 JNIEnv * env = FETCHENV;
2149 RETVAL = (*env)->GetStaticDoubleField(env, clazz,fieldID);
2156 SetStaticObjectField(clazz,fieldID,value)
2157 JNIEnv * env = FETCHENV;
2164 (*env)->SetStaticObjectField(env, clazz,fieldID,value);
2169 SetStaticBooleanField(clazz,fieldID,value)
2170 JNIEnv * env = FETCHENV;
2177 (*env)->SetStaticBooleanField(env, clazz,fieldID,value);
2182 SetStaticByteField(clazz,fieldID,value)
2183 JNIEnv * env = FETCHENV;
2190 (*env)->SetStaticByteField(env, clazz,fieldID,value);
2195 SetStaticCharField(clazz,fieldID,value)
2196 JNIEnv * env = FETCHENV;
2203 (*env)->SetStaticCharField(env, clazz,fieldID,value);
2208 SetStaticShortField(clazz,fieldID,value)
2209 JNIEnv * env = FETCHENV;
2216 (*env)->SetStaticShortField(env, clazz,fieldID,value);
2221 SetStaticIntField(clazz,fieldID,value)
2222 JNIEnv * env = FETCHENV;
2229 (*env)->SetStaticIntField(env, clazz,fieldID,value);
2234 SetStaticLongField(clazz,fieldID,value)
2235 JNIEnv * env = FETCHENV;
2242 (*env)->SetStaticLongField(env, clazz,fieldID,value);
2247 SetStaticFloatField(clazz,fieldID,value)
2248 JNIEnv * env = FETCHENV;
2255 (*env)->SetStaticFloatField(env, clazz,fieldID,value);
2260 SetStaticDoubleField(clazz,fieldID,value)
2261 JNIEnv * env = FETCHENV;
2268 (*env)->SetStaticDoubleField(env, clazz,fieldID,value);
2274 JNIEnv * env = FETCHENV;
2275 STRLEN tmplen = NO_INIT;
2276 jsize unicode_len_ = NO_INIT;
2277 const jchar * unicode
2280 RETVAL = (*env)->NewString(env, unicode, unicode_len_);
2287 GetStringLength(str)
2288 JNIEnv * env = FETCHENV;
2292 RETVAL = (*env)->GetStringLength(env, str);
2300 JNIEnv * env = FETCHENV;
2302 jboolean isCopy = NO_INIT;
2303 jsize RETVAL_len_ = NO_INIT;
2306 RETVAL = (*env)->GetStringChars(env, str,&isCopy);
2307 RETVAL_len_ = (*env)->GetStringLength(env, str);
2313 (*env)->ReleaseStringChars(env, str,RETVAL);
2317 JNIEnv * env = FETCHENV;
2321 RETVAL = (*env)->NewStringUTF(env, utf);
2328 GetStringUTFLength(str)
2329 JNIEnv * env = FETCHENV;
2333 RETVAL = (*env)->GetStringUTFLength(env, str);
2340 GetStringUTFChars(str)
2341 JNIEnv * env = FETCHENV;
2343 jboolean isCopy = NO_INIT;
2346 RETVAL = (*env)->GetStringUTFChars(env, str,&isCopy);
2352 (*env)->ReleaseStringUTFChars(env, str, RETVAL);
2356 GetArrayLength(array)
2357 JNIEnv * env = FETCHENV;
2361 RETVAL = (*env)->GetArrayLength(env, array);
2368 NewObjectArray(len,clazz,init)
2369 JNIEnv * env = FETCHENV;
2375 RETVAL = (*env)->NewObjectArray(env, len,clazz,init);
2382 GetObjectArrayElement(array,index)
2383 JNIEnv * env = FETCHENV;
2388 RETVAL = (*env)->GetObjectArrayElement(env, array,index);
2395 SetObjectArrayElement(array,index,val)
2396 JNIEnv * env = FETCHENV;
2402 (*env)->SetObjectArrayElement(env, array,index,val);
2407 NewBooleanArray(len)
2408 JNIEnv * env = FETCHENV;
2412 RETVAL = (*env)->NewBooleanArray(env, len);
2420 JNIEnv * env = FETCHENV;
2424 RETVAL = (*env)->NewByteArray(env, len);
2432 JNIEnv * env = FETCHENV;
2436 RETVAL = (*env)->NewCharArray(env, len);
2444 JNIEnv * env = FETCHENV;
2448 RETVAL = (*env)->NewShortArray(env, len);
2456 JNIEnv * env = FETCHENV;
2460 RETVAL = (*env)->NewIntArray(env, len);
2468 JNIEnv * env = FETCHENV;
2472 RETVAL = (*env)->NewLongArray(env, len);
2480 JNIEnv * env = FETCHENV;
2484 RETVAL = (*env)->NewFloatArray(env, len);
2492 JNIEnv * env = FETCHENV;
2496 RETVAL = (*env)->NewDoubleArray(env, len);
2503 GetBooleanArrayElements(array)
2504 JNIEnv * env = FETCHENV;
2505 jsize RETVAL_len_ = NO_INIT;
2507 jboolean isCopy = NO_INIT;
2510 RETVAL = (*env)->GetBooleanArrayElements(env, array,&isCopy);
2511 RETVAL_len_ = (*env)->GetArrayLength(env, array);
2512 if (GIMME == G_ARRAY) {
2514 jboolean* r = RETVAL;
2515 EXTEND(sp, RETVAL_len_);
2516 for (i = RETVAL_len_; i; --i) {
2517 PUSHs(sv_2mortal(newSViv(*r++)));
2522 PUSHs(sv_2mortal(newSVpv((char*)RETVAL,
2523 (STRLEN)RETVAL_len_ * sizeof(jboolean))));
2528 (*env)->ReleaseBooleanArrayElements(env, array,RETVAL,JNI_ABORT);
2533 GetByteArrayElements(array)
2534 JNIEnv * env = FETCHENV;
2535 jsize RETVAL_len_ = NO_INIT;
2537 jboolean isCopy = NO_INIT;
2540 RETVAL = (*env)->GetByteArrayElements(env, array,&isCopy);
2541 RETVAL_len_ = (*env)->GetArrayLength(env, array);
2542 if (GIMME == G_ARRAY) {
2545 EXTEND(sp, RETVAL_len_);
2546 for (i = RETVAL_len_; i; --i) {
2547 PUSHs(sv_2mortal(newSViv(*r++)));
2552 PUSHs(sv_2mortal(newSVpv((char*)RETVAL,
2553 (STRLEN)RETVAL_len_ * sizeof(jbyte))));
2558 (*env)->ReleaseByteArrayElements(env, array,RETVAL,JNI_ABORT);
2563 GetCharArrayElements(array)
2564 JNIEnv * env = FETCHENV;
2565 jsize RETVAL_len_ = NO_INIT;
2567 jboolean isCopy = NO_INIT;
2570 RETVAL = (*env)->GetCharArrayElements(env, array,&isCopy);
2571 RETVAL_len_ = (*env)->GetArrayLength(env, array);
2572 if (GIMME == G_ARRAY) {
2575 EXTEND(sp, RETVAL_len_);
2576 for (i = RETVAL_len_; i; --i) {
2577 PUSHs(sv_2mortal(newSViv(*r++)));
2582 PUSHs(sv_2mortal(newSVpv((char*)RETVAL,
2583 (STRLEN)RETVAL_len_ * sizeof(jchar))));
2588 (*env)->ReleaseCharArrayElements(env, array,RETVAL,JNI_ABORT);
2593 GetShortArrayElements(array)
2594 JNIEnv * env = FETCHENV;
2595 jsize RETVAL_len_ = NO_INIT;
2597 jboolean isCopy = NO_INIT;
2600 RETVAL = (*env)->GetShortArrayElements(env, array,&isCopy);
2601 RETVAL_len_ = (*env)->GetArrayLength(env, array);
2602 if (GIMME == G_ARRAY) {
2605 EXTEND(sp, RETVAL_len_);
2606 for (i = RETVAL_len_; i; --i) {
2607 PUSHs(sv_2mortal(newSViv(*r++)));
2612 PUSHs(sv_2mortal(newSVpv((char*)RETVAL,
2613 (STRLEN)RETVAL_len_ * sizeof(jshort))));
2618 (*env)->ReleaseShortArrayElements(env, array,RETVAL,JNI_ABORT);
2623 GetIntArrayElements(array)
2624 JNIEnv * env = FETCHENV;
2625 jsize RETVAL_len_ = NO_INIT;
2627 jboolean isCopy = NO_INIT;
2630 RETVAL = (*env)->GetIntArrayElements(env, array,&isCopy);
2631 RETVAL_len_ = (*env)->GetArrayLength(env, array);
2632 if (GIMME == G_ARRAY) {
2635 EXTEND(sp, RETVAL_len_);
2636 for (i = RETVAL_len_; i; --i) {
2637 PUSHs(sv_2mortal(newSViv(*r++)));
2642 PUSHs(sv_2mortal(newSVpv((char*)RETVAL,
2643 (STRLEN)RETVAL_len_ * sizeof(jint))));
2648 (*env)->ReleaseIntArrayElements(env, array,RETVAL,JNI_ABORT);
2653 GetLongArrayElements(array)
2654 JNIEnv * env = FETCHENV;
2655 jsize RETVAL_len_ = NO_INIT;
2657 jboolean isCopy = NO_INIT;
2660 RETVAL = (*env)->GetLongArrayElements(env, array,&isCopy);
2661 RETVAL_len_ = (*env)->GetArrayLength(env, array);
2662 if (GIMME == G_ARRAY) {
2665 EXTEND(sp, RETVAL_len_);
2666 for (i = RETVAL_len_; i; --i) {
2667 PUSHs(sv_2mortal(newSViv(*r++)));
2672 PUSHs(sv_2mortal(newSVpv((char*)RETVAL,
2673 (STRLEN)RETVAL_len_ * sizeof(jlong))));
2678 (*env)->ReleaseLongArrayElements(env, array,RETVAL,JNI_ABORT);
2683 GetFloatArrayElements(array)
2684 JNIEnv * env = FETCHENV;
2685 jsize RETVAL_len_ = NO_INIT;
2687 jboolean isCopy = NO_INIT;
2690 RETVAL = (*env)->GetFloatArrayElements(env, array,&isCopy);
2691 RETVAL_len_ = (*env)->GetArrayLength(env, array);
2692 if (GIMME == G_ARRAY) {
2695 EXTEND(sp, RETVAL_len_);
2696 for (i = RETVAL_len_; i; --i) {
2697 PUSHs(sv_2mortal(newSVnv(*r++)));
2702 PUSHs(sv_2mortal(newSVpv((char*)RETVAL,
2703 (STRLEN)RETVAL_len_ * sizeof(jfloat))));
2708 (*env)->ReleaseFloatArrayElements(env, array,RETVAL,JNI_ABORT);
2713 GetDoubleArrayElements(array)
2714 JNIEnv * env = FETCHENV;
2715 jsize RETVAL_len_ = NO_INIT;
2717 jboolean isCopy = NO_INIT;
2720 RETVAL = (*env)->GetDoubleArrayElements(env, array,&isCopy);
2721 RETVAL_len_ = (*env)->GetArrayLength(env, array);
2722 if (GIMME == G_ARRAY) {
2724 jdouble* r = RETVAL;
2725 EXTEND(sp, RETVAL_len_);
2726 for (i = RETVAL_len_; i; --i) {
2727 PUSHs(sv_2mortal(newSVnv(*r++)));
2732 PUSHs(sv_2mortal(newSVpv((char*)RETVAL,
2733 (STRLEN)RETVAL_len_ * sizeof(jdouble))));
2738 (*env)->ReleaseDoubleArrayElements(env, array,RETVAL,JNI_ABORT);
2743 GetBooleanArrayRegion(array,start,len,buf)
2744 JNIEnv * env = FETCHENV;
2748 STRLEN tmplen = len * sizeof(jboolean) + 1;
2749 char * tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
2750 jboolean * buf = (jboolean*)sv_grow(ST(3),len * sizeof(jboolean)+1);
2753 (*env)->GetBooleanArrayRegion(env, array,start,len,buf);
2754 SvCUR_set(ST(3), len * sizeof(jboolean));
2755 *SvEND(ST(3)) = '\0';
2760 GetByteArrayRegion(array,start,len,buf)
2761 JNIEnv * env = FETCHENV;
2765 STRLEN tmplen = len * sizeof(jboolean) + 1;
2766 char * tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
2767 jbyte * buf = (jbyte*)sv_grow(ST(3),len * sizeof(jbyte)+1);
2770 (*env)->GetByteArrayRegion(env, array,start,len,buf);
2771 SvCUR_set(ST(3), len * sizeof(jbyte));
2772 *SvEND(ST(3)) = '\0';
2777 GetCharArrayRegion(array,start,len,buf)
2778 JNIEnv * env = FETCHENV;
2782 STRLEN tmplen = len * sizeof(jboolean) + 1;
2783 char * tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
2784 jchar * buf = (jchar*)sv_grow(ST(3),len * sizeof(jchar)+1);
2787 (*env)->GetCharArrayRegion(env, array,start,len,buf);
2788 SvCUR_set(ST(3), len * sizeof(jchar));
2789 *SvEND(ST(3)) = '\0';
2794 GetShortArrayRegion(array,start,len,buf)
2795 JNIEnv * env = FETCHENV;
2799 STRLEN tmplen = len * sizeof(jboolean) + 1;
2800 char * tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
2801 jshort * buf = (jshort*)sv_grow(ST(3),len * sizeof(jshort)+1);
2804 (*env)->GetShortArrayRegion(env, array,start,len,buf);
2805 SvCUR_set(ST(3), len * sizeof(jshort));
2806 *SvEND(ST(3)) = '\0';
2811 GetIntArrayRegion(array,start,len,buf)
2812 JNIEnv * env = FETCHENV;
2816 STRLEN tmplen = len * sizeof(jboolean) + 1;
2817 char * tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
2818 jint * buf = (jint*)sv_grow(ST(3),len * sizeof(jint)+1);
2821 (*env)->GetIntArrayRegion(env, array,start,len,buf);
2822 SvCUR_set(ST(3), len * sizeof(jint));
2823 *SvEND(ST(3)) = '\0';
2828 GetLongArrayRegion(array,start,len,buf)
2829 JNIEnv * env = FETCHENV;
2833 STRLEN tmplen = len * sizeof(jboolean) + 1;
2834 char * tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
2835 jlong * buf = (jlong*)sv_grow(ST(3),len * sizeof(jlong)+1);
2838 (*env)->GetLongArrayRegion(env, array,start,len,buf);
2839 SvCUR_set(ST(3), len * sizeof(jlong));
2840 *SvEND(ST(3)) = '\0';
2845 GetFloatArrayRegion(array,start,len,buf)
2846 JNIEnv * env = FETCHENV;
2850 STRLEN tmplen = len * sizeof(jboolean) + 1;
2851 char * tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
2852 jfloat * buf = (jfloat*)sv_grow(ST(3),len * sizeof(jfloat)+1);
2855 (*env)->GetFloatArrayRegion(env, array,start,len,buf);
2856 SvCUR_set(ST(3), len * sizeof(jfloat));
2857 *SvEND(ST(3)) = '\0';
2862 GetDoubleArrayRegion(array,start,len,buf)
2863 JNIEnv * env = FETCHENV;
2867 STRLEN tmplen = len * sizeof(jboolean) + 1;
2868 char * tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
2869 jdouble * buf = (jdouble*)sv_grow(ST(3),len * sizeof(jdouble)+1);
2872 (*env)->GetDoubleArrayRegion(env, array,start,len,buf);
2873 SvCUR_set(ST(3), len * sizeof(jdouble));
2874 *SvEND(ST(3)) = '\0';
2879 SetBooleanArrayRegion(array,start,len,buf)
2880 JNIEnv * env = FETCHENV;
2881 STRLEN tmplen = NO_INIT;
2885 jsize buf_len_ = NO_INIT;
2890 croak("string is too short");
2891 else if (buf_len_ > len && PL_dowarn)
2892 warn("string is too long");
2893 (*env)->SetBooleanArrayRegion(env, array,start,len,buf);
2898 SetByteArrayRegion(array,start,len,buf)
2899 JNIEnv * env = FETCHENV;
2900 STRLEN tmplen = NO_INIT;
2904 jsize buf_len_ = NO_INIT;
2909 croak("string is too short");
2910 else if (buf_len_ > len && PL_dowarn)
2911 warn("string is too long");
2912 (*env)->SetByteArrayRegion(env, array,start,len,buf);
2917 SetCharArrayRegion(array,start,len,buf)
2918 JNIEnv * env = FETCHENV;
2919 STRLEN tmplen = NO_INIT;
2923 jsize buf_len_ = NO_INIT;
2928 croak("string is too short");
2929 else if (buf_len_ > len && PL_dowarn)
2930 warn("string is too long");
2931 (*env)->SetCharArrayRegion(env, array,start,len,buf);
2936 SetShortArrayRegion(array,start,len,buf)
2937 JNIEnv * env = FETCHENV;
2938 STRLEN tmplen = NO_INIT;
2942 jsize buf_len_ = NO_INIT;
2947 croak("string is too short");
2948 else if (buf_len_ > len && PL_dowarn)
2949 warn("string is too long");
2950 (*env)->SetShortArrayRegion(env, array,start,len,buf);
2955 SetIntArrayRegion(array,start,len,buf)
2956 JNIEnv * env = FETCHENV;
2957 STRLEN tmplen = NO_INIT;
2961 jsize buf_len_ = NO_INIT;
2966 croak("string is too short");
2967 else if (buf_len_ > len && PL_dowarn)
2968 warn("string is too long");
2969 (*env)->SetIntArrayRegion(env, array,start,len,buf);
2974 SetLongArrayRegion(array,start,len,buf)
2975 JNIEnv * env = FETCHENV;
2976 STRLEN tmplen = NO_INIT;
2980 jsize buf_len_ = NO_INIT;
2985 croak("string is too short");
2986 else if (buf_len_ > len && PL_dowarn)
2987 warn("string is too long");
2988 (*env)->SetLongArrayRegion(env, array,start,len,buf);
2993 SetFloatArrayRegion(array,start,len,buf)
2994 JNIEnv * env = FETCHENV;
2995 STRLEN tmplen = NO_INIT;
2999 jsize buf_len_ = NO_INIT;
3004 croak("string is too short");
3005 else if (buf_len_ > len && PL_dowarn)
3006 warn("string is too long");
3007 (*env)->SetFloatArrayRegion(env, array,start,len,buf);
3012 SetDoubleArrayRegion(array,start,len,buf)
3013 JNIEnv * env = FETCHENV;
3014 STRLEN tmplen = NO_INIT;
3018 jsize buf_len_ = NO_INIT;
3023 croak("string is too short");
3024 else if (buf_len_ > len && PL_dowarn)
3025 warn("string is too long");
3026 (*env)->SetDoubleArrayRegion(env, array,start,len,buf);
3031 RegisterNatives(clazz,methods,nMethods)
3032 JNIEnv * env = FETCHENV;
3034 JNINativeMethod * methods
3038 RETVAL = (*env)->RegisterNatives(env, clazz,methods,nMethods);
3042 UnregisterNatives(clazz)
3043 JNIEnv * env = FETCHENV;
3047 RETVAL = (*env)->UnregisterNatives(env, clazz);
3054 JNIEnv * env = FETCHENV;
3058 RETVAL = (*env)->MonitorEnter(env, obj);
3066 JNIEnv * env = FETCHENV;
3070 RETVAL = (*env)->MonitorExit(env, obj);
3078 JNIEnv * env = FETCHENV;
3081 if (env) { /* We're embedded. */
3082 if ((*env)->GetJavaVM(env, &RETVAL) < 0)
3085 else { /* We're embedding. */
3086 JDK1_1InitArgs vm_args;
3091 lib = SvPV(*mark, PL_na);
3096 if (!dlopen("libjava.so", RTLD_LAZY|RTLD_GLOBAL)) {
3097 if (lib && !dlopen(lib, RTLD_LAZY|RTLD_GLOBAL))
3098 croak("Can't load libjava.so");
3101 JNI_GetDefaultJavaVMInitArgs(&vm_args);
3102 vm_args.exit = &call_my_exit;
3104 char *s = SvPV(*++mark,PL_na);
3106 if (strEQ(s, "checkSource"))
3107 vm_args.checkSource = (jint)SvIV(*++mark);
3108 else if (strEQ(s, "nativeStackSize"))
3109 vm_args.nativeStackSize = (jint)SvIV(*++mark);
3110 else if (strEQ(s, "javaStackSize"))
3111 vm_args.javaStackSize = (jint)SvIV(*++mark);
3112 else if (strEQ(s, "minHeapSize"))
3113 vm_args.minHeapSize = (jint)SvIV(*++mark);
3114 else if (strEQ(s, "maxHeapSize"))
3115 vm_args.maxHeapSize = (jint)SvIV(*++mark);
3116 else if (strEQ(s, "verifyMode"))
3117 vm_args.verifyMode = (jint)SvIV(*++mark);
3118 else if (strEQ(s, "classpath"))
3119 vm_args.classpath = savepv(SvPV(*++mark,PL_na));
3120 else if (strEQ(s, "enableClassGC"))
3121 vm_args.enableClassGC = (jint)SvIV(*++mark);
3122 else if (strEQ(s, "enableVerboseGC"))
3123 vm_args.enableVerboseGC = (jint)SvIV(*++mark);
3124 else if (strEQ(s, "disableAsyncGC"))
3125 vm_args.disableAsyncGC = (jint)SvIV(*++mark);
3126 else if (strEQ(s, "verbose"))
3127 vm_args.verbose = (jint)SvIV(*++mark);
3128 else if (strEQ(s, "debugging"))
3129 vm_args.debugging = (jboolean)SvIV(*++mark);
3130 else if (strEQ(s, "debugPort"))
3131 vm_args.debugPort = (jint)SvIV(*++mark);
3133 croak("unrecognized option: %s", s);
3135 JNI_CreateJavaVM(&RETVAL, &jplcurenv, &vm_args);