2 * Copyright 1997, O'Reilly & Associate, Inc.
4 * This package may be copied under the same terms as Perl itself.
15 # include <patchlevel.h>
16 # define PERL_REVISION 5
17 # define PERL_VERSION PATCHLEVEL
18 # define PERL_SUBVERSION SUBVERSION
21 #if PERL_REVISION == 5 && (PERL_VERSION < 4 || \
22 (PERL_VERSION == 4 && PERL_SUBVERSION <= 75))
24 # define PL_sv_no sv_no
25 # define PL_sv_undef sv_undef
26 # define PL_dowarn dowarn
30 # define newSVpvn(a,b) newSVpv(a,b)
38 # define dTHX extern int JNI___notused
46 extern JNIEnv* jplcurenv;
56 static void JNICALL call_my_exit(jint status)
61 static void call_my_exit(jint status)
68 makeargs(char *sig, SV** svp, int items)
70 jvalue* jv = (jvalue*)safemalloc(sizeof(jvalue) * items);
73 JNIEnv* env = jplcurenv;
78 fprintf(stderr, "sig = %s, items = %d\n", sig, items);
87 jv[ix++].z = (jboolean)(SvIV(sv) != 0);
90 jv[ix++].b = (jbyte)SvIV(sv);
93 jv[ix++].c = (jchar)SvIV(sv);
96 jv[ix++].s = (jshort)SvIV(sv);
99 jv[ix++].i = (jint)SvIV(sv);
102 jv[ix++].j = (jlong)SvNV(sv);
105 jv[ix++].f = (jfloat)SvNV(sv);
108 jv[ix++].d = (jdouble)SvNV(sv);
114 SV* rv = (SV*)SvRV(sv);
116 jv[ix++].l = (jobject)(void*)SvIV(rv);
117 else if (SvTYPE(rv) == SVt_PVAV) {
118 jsize len = av_len((AV*)rv) + 1;
119 jboolean* buf = (jboolean*)malloc(len * sizeof(jboolean));
124 jbooleanArray ja = env->NewBooleanArray(len);
126 jbooleanArray ja = (*env)->NewBooleanArray(env, len);
128 for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
129 buf[i] = (jboolean)SvIV(*esv);
131 env->SetBooleanArrayRegion(ja, 0, len, buf);
133 (*env)->SetBooleanArrayRegion(env, ja, 0, len, buf);
136 jv[ix++].l = (jobject)ja;
139 jv[ix++].l = (jobject)(void*)0;
141 else if (SvPOK(sv)) {
142 jsize len = sv_len(sv) / sizeof(jboolean);
145 jbooleanArray ja = env->NewBooleanArray(len);
147 jbooleanArray ja = (*env)->NewBooleanArray(env, len);
150 env->SetBooleanArrayRegion(ja, 0, len, (jboolean*)SvPV(sv,n_a));
152 (*env)->SetBooleanArrayRegion(env, ja, 0, len, (jboolean*)SvPV(sv,n_a));
154 jv[ix++].l = (jobject)ja;
157 jv[ix++].l = (jobject)(void*)0;
161 SV* rv = (SV*)SvRV(sv);
163 jv[ix++].l = (jobject)(void*)SvIV(rv);
164 else if (SvTYPE(rv) == SVt_PVAV) {
165 jsize len = av_len((AV*)rv) + 1;
166 jbyte* buf = (jbyte*)malloc(len * sizeof(jbyte));
171 jbyteArray ja = env->NewByteArray(len);
173 jbyteArray ja = (*env)->NewByteArray(env, len);
175 for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
176 buf[i] = (jbyte)SvIV(*esv);
178 env->SetByteArrayRegion(ja, 0, len, buf);
180 (*env)->SetByteArrayRegion(env, ja, 0, len, buf);
183 jv[ix++].l = (jobject)ja;
186 jv[ix++].l = (jobject)(void*)0;
188 else if (SvPOK(sv)) {
189 jsize len = sv_len(sv) / sizeof(jbyte);
192 jbyteArray ja = env->NewByteArray(len);
194 jbyteArray ja = (*env)->NewByteArray(env, len);
197 env->SetByteArrayRegion(ja, 0, len, (jbyte*)SvPV(sv,n_a));
199 (*env)->SetByteArrayRegion(env, ja, 0, len, (jbyte*)SvPV(sv,n_a));
201 jv[ix++].l = (jobject)ja;
204 jv[ix++].l = (jobject)(void*)0;
208 SV* rv = (SV*)SvRV(sv);
210 jv[ix++].l = (jobject)(void*)SvIV(rv);
211 else if (SvTYPE(rv) == SVt_PVAV) {
212 jsize len = av_len((AV*)rv) + 1;
213 jchar* buf = (jchar*)malloc(len * sizeof(jchar));
218 jcharArray ja = env->NewCharArray(len);
220 jcharArray ja = (*env)->NewCharArray(env, len);
222 for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
223 buf[i] = (jchar)SvIV(*esv);
225 env->SetCharArrayRegion(ja, 0, len, buf);
227 (*env)->SetCharArrayRegion(env, ja, 0, len, buf);
230 jv[ix++].l = (jobject)ja;
233 jv[ix++].l = (jobject)(void*)0;
235 else if (SvPOK(sv)) {
236 jsize len = sv_len(sv) / sizeof(jchar);
239 jcharArray ja = env->NewCharArray(len);
241 jcharArray ja = (*env)->NewCharArray(env, len);
244 env->SetCharArrayRegion(ja, 0, len, (jchar*)SvPV(sv,n_a));
246 (*env)->SetCharArrayRegion(env, ja, 0, len, (jchar*)SvPV(sv,n_a));
248 jv[ix++].l = (jobject)ja;
251 jv[ix++].l = (jobject)(void*)0;
255 SV* rv = (SV*)SvRV(sv);
257 jv[ix++].l = (jobject)(void*)SvIV(rv);
258 else if (SvTYPE(rv) == SVt_PVAV) {
259 jsize len = av_len((AV*)rv) + 1;
260 jshort* buf = (jshort*)malloc(len * sizeof(jshort));
265 jshortArray ja = env->NewShortArray(len);
267 jshortArray ja = (*env)->NewShortArray(env, len);
269 for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
270 buf[i] = (jshort)SvIV(*esv);
272 env->SetShortArrayRegion(ja, 0, len, buf);
274 (*env)->SetShortArrayRegion(env, ja, 0, len, buf);
277 jv[ix++].l = (jobject)ja;
280 jv[ix++].l = (jobject)(void*)0;
282 else if (SvPOK(sv)) {
283 jsize len = sv_len(sv) / sizeof(jshort);
286 jshortArray ja = env->NewShortArray(len);
288 jshortArray ja = (*env)->NewShortArray(env, len);
291 env->SetShortArrayRegion(ja, 0, len, (jshort*)SvPV(sv,n_a));
293 (*env)->SetShortArrayRegion(env, ja, 0, len, (jshort*)SvPV(sv,n_a));
295 jv[ix++].l = (jobject)ja;
298 jv[ix++].l = (jobject)(void*)0;
302 SV* rv = (SV*)SvRV(sv);
304 jv[ix++].l = (jobject)(void*)SvIV(rv);
305 else if (SvTYPE(rv) == SVt_PVAV) {
306 jsize len = av_len((AV*)rv) + 1;
307 jint* buf = (jint*)malloc(len * sizeof(jint));
312 jintArray ja = env->NewIntArray(len);
314 jintArray ja = (*env)->NewIntArray(env, len);
316 for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
317 buf[i] = (jint)SvIV(*esv);
319 env->SetIntArrayRegion(ja, 0, len, buf);
321 (*env)->SetIntArrayRegion(env, ja, 0, len, buf);
324 jv[ix++].l = (jobject)ja;
327 jv[ix++].l = (jobject)(void*)0;
329 else if (SvPOK(sv)) {
330 jsize len = sv_len(sv) / sizeof(jint);
333 jintArray ja = env->NewIntArray(len);
335 jintArray ja = (*env)->NewIntArray(env, len);
338 env->SetIntArrayRegion(ja, 0, len, (jint*)SvPV(sv,n_a));
340 (*env)->SetIntArrayRegion(env, ja, 0, len, (jint*)SvPV(sv,n_a));
342 jv[ix++].l = (jobject)ja;
345 jv[ix++].l = (jobject)(void*)0;
349 SV* rv = (SV*)SvRV(sv);
351 jv[ix++].l = (jobject)(void*)SvIV(rv);
352 else if (SvTYPE(rv) == SVt_PVAV) {
353 jsize len = av_len((AV*)rv) + 1;
354 jlong* buf = (jlong*)malloc(len * sizeof(jlong));
359 jlongArray ja = env->NewLongArray(len);
361 jlongArray ja = (*env)->NewLongArray(env, len);
363 for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
364 buf[i] = (jlong)SvNV(*esv);
366 env->SetLongArrayRegion(ja, 0, len, buf);
368 (*env)->SetLongArrayRegion(env, ja, 0, len, buf);
371 jv[ix++].l = (jobject)ja;
374 jv[ix++].l = (jobject)(void*)0;
376 else if (SvPOK(sv)) {
377 jsize len = sv_len(sv) / sizeof(jlong);
380 jlongArray ja = env->NewLongArray(len);
382 jlongArray ja = (*env)->NewLongArray(env, len);
385 env->SetLongArrayRegion(ja, 0, len, (jlong*)SvPV(sv,n_a));
387 (*env)->SetLongArrayRegion(env, ja, 0, len, (jlong*)SvPV(sv,n_a));
389 jv[ix++].l = (jobject)ja;
392 jv[ix++].l = (jobject)(void*)0;
396 SV* rv = (SV*)SvRV(sv);
398 jv[ix++].l = (jobject)(void*)SvIV(rv);
399 else if (SvTYPE(rv) == SVt_PVAV) {
400 jsize len = av_len((AV*)rv) + 1;
401 jfloat* buf = (jfloat*)malloc(len * sizeof(jfloat));
406 jfloatArray ja = env->NewFloatArray(len);
408 jfloatArray ja = (*env)->NewFloatArray(env, len);
410 for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
411 buf[i] = (jfloat)SvNV(*esv);
413 env->SetFloatArrayRegion(ja, 0, len, buf);
415 (*env)->SetFloatArrayRegion(env, ja, 0, len, buf);
418 jv[ix++].l = (jobject)ja;
421 jv[ix++].l = (jobject)(void*)0;
423 else if (SvPOK(sv)) {
424 jsize len = sv_len(sv) / sizeof(jfloat);
427 jfloatArray ja = env->NewFloatArray(len);
429 jfloatArray ja = (*env)->NewFloatArray(env, len);
432 env->SetFloatArrayRegion(ja, 0, len, (jfloat*)SvPV(sv,n_a));
434 (*env)->SetFloatArrayRegion(env, ja, 0, len, (jfloat*)SvPV(sv,n_a));
436 jv[ix++].l = (jobject)ja;
439 jv[ix++].l = (jobject)(void*)0;
443 SV* rv = (SV*)SvRV(sv);
445 jv[ix++].l = (jobject)(void*)SvIV(rv);
446 else if (SvTYPE(rv) == SVt_PVAV) {
447 jsize len = av_len((AV*)rv) + 1;
448 jdouble* buf = (jdouble*)malloc(len * sizeof(jdouble));
453 jdoubleArray ja = env->NewDoubleArray(len);
455 jdoubleArray ja = (*env)->NewDoubleArray(env, len);
457 for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
458 buf[i] = (jdouble)SvNV(*esv);
460 env->SetDoubleArrayRegion(ja, 0, len, buf);
462 (*env)->SetDoubleArrayRegion(env, ja, 0, len, buf);
465 jv[ix++].l = (jobject)ja;
468 jv[ix++].l = (jobject)(void*)0;
470 else if (SvPOK(sv)) {
471 jsize len = sv_len(sv) / sizeof(jdouble);
474 jdoubleArray ja = env->NewDoubleArray(len);
476 jdoubleArray ja = (*env)->NewDoubleArray(env, len);
479 env->SetDoubleArrayRegion(ja, 0, len, (jdouble*)SvPV(sv,n_a));
481 (*env)->SetDoubleArrayRegion(env, ja, 0, len, (jdouble*)SvPV(sv,n_a));
483 jv[ix++].l = (jobject)ja;
486 jv[ix++].l = (jobject)(void*)0;
489 while (*s != ';') s++;
491 if (strnEQ(start, "[Ljava/lang/String;", 19)) {
493 SV* rv = (SV*)SvRV(sv);
495 jv[ix++].l = (jobject)(void*)SvIV(rv);
496 else if (SvTYPE(rv) == SVt_PVAV) {
497 jsize len = av_len((AV*)rv) + 1;
500 static jclass jcl = 0;
505 jcl = env->FindClass("java/lang/String");
507 jcl = (*env)->FindClass(env, "java/lang/String");
510 ja = env->NewObjectArray(len, jcl, 0);
512 ja = (*env)->NewObjectArray(env, len, jcl, 0);
514 for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++) {
516 jobject str = (jobject)env->NewStringUTF(SvPV(*esv,n_a));
518 jobject str = (jobject)(*env)->NewStringUTF(env, SvPV(*esv,n_a));
521 env->SetObjectArrayElement(ja, i, str);
523 (*env)->SetObjectArrayElement(env, ja, i, str);
526 jv[ix++].l = (jobject)ja;
529 jv[ix++].l = (jobject)(void*)0;
532 jv[ix++].l = (jobject)(void*)0;
538 SV* rv = (SV*)SvRV(sv);
540 jv[ix++].l = (jobject)(void*)SvIV(rv);
541 else if (SvTYPE(rv) == SVt_PVAV) {
542 jsize len = av_len((AV*)rv) + 1;
545 static jclass jcl = 0;
550 jcl = env->FindClass("java/lang/Object");
552 jcl = (*env)->FindClass(env, "java/lang/Object");
555 ja = env->NewObjectArray(len, jcl, 0);
557 ja = (*env)->NewObjectArray(env, len, jcl, 0);
559 for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++) {
560 if (SvROK(*esv) && (rv = SvRV(*esv)) && SvOBJECT(rv)) {
562 env->SetObjectArrayElement(ja, i, (jobject)(void*)SvIV(rv));
564 (*env)->SetObjectArrayElement(env, ja, i, (jobject)(void*)SvIV(rv));
569 jobject str = (jobject)env->NewStringUTF(SvPV(*esv,n_a));
571 jobject str = (jobject)(*env)->NewStringUTF(env, SvPV(*esv,n_a));
574 env->SetObjectArrayElement(ja, i, str);
576 (*env)->SetObjectArrayElement(env, ja, i, str);
580 jv[ix++].l = (jobject)ja;
583 jv[ix++].l = (jobject)(void*)0;
586 jv[ix++].l = (jobject)(void*)0;
591 if (!SvROK(sv) || strnEQ(s, "java/lang/String;", 17)) {
594 jv[ix++].l = (jobject)env->NewStringUTF((char*) SvPV(sv,n_a));
596 jv[ix++].l = (jobject)(*env)->NewStringUTF(env, (char*) SvPV(sv,n_a));
600 while (*s != ';') s++;
604 jv[ix++].l = (jobject)(void*)SvIV(rv);
608 croak("too many arguments, signature: %s", sig);
611 croak("panic: malformed signature: %s", s-1);
617 croak("not enough arguments, signature: %s", sig);
630 croak("%s not implemented on this architecture", s);
635 constant(char *name, int arg)
658 if (strEQ(name, "JNI_ABORT"))
664 if (strEQ(name, "JNI_COMMIT"))
670 if (strEQ(name, "JNI_ERR"))
676 if (strEQ(name, "JNI_FALSE"))
682 if (strEQ(name, "JNI_H"))
692 if (strEQ(name, "JNI_OK"))
698 if (strEQ(name, "JNI_TRUE"))
746 #define FETCHENV jplcurenv
747 #define RESTOREENV jplcurenv = env
749 MODULE = JNI PACKAGE = JNI
760 JNIEnv * env = FETCHENV;
764 RETVAL = env->GetVersion();
766 RETVAL = (*env)->GetVersion(env);
774 DefineClass(name, loader, buf)
775 JNIEnv * env = FETCHENV;
776 STRLEN tmplen = NO_INIT;
777 jsize buf_len_ = NO_INIT;
785 RETVAL = env->DefineClass( loader, buf, (jsize)buf_len_);
787 RETVAL = (*env)->DefineClass(env, loader, buf, (jsize)buf_len_);
791 RETVAL = env->DefineClass( name, loader, buf, (jsize)buf_len_);
793 RETVAL = (*env)->DefineClass(env, name, loader, buf, (jsize)buf_len_);
803 JNIEnv * env = FETCHENV;
808 RETVAL = env->FindClass( name);
810 RETVAL = (*env)->FindClass(env, name);
819 JNIEnv * env = FETCHENV;
824 RETVAL = env->GetSuperclass( sub);
826 RETVAL = (*env)->GetSuperclass(env, sub);
834 IsAssignableFrom(sub, sup)
835 JNIEnv * env = FETCHENV;
841 RETVAL = env->IsAssignableFrom( sub, sup);
843 RETVAL = (*env)->IsAssignableFrom(env, sub, sup);
852 JNIEnv * env = FETCHENV;
857 RETVAL = env->Throw( obj);
859 RETVAL = (*env)->Throw(env, obj);
868 JNIEnv * env = FETCHENV;
874 RETVAL = env->ThrowNew( clazz, msg);
876 RETVAL = (*env)->ThrowNew(env, clazz, msg);
885 JNIEnv * env = FETCHENV;
889 RETVAL = env->ExceptionOccurred();
891 RETVAL = (*env)->ExceptionOccurred(env);
900 JNIEnv * env = FETCHENV;
904 env->ExceptionDescribe();
906 (*env)->ExceptionDescribe(env);
913 JNIEnv * env = FETCHENV;
917 env->ExceptionClear();
919 (*env)->ExceptionClear(env);
926 JNIEnv * env = FETCHENV;
931 env->FatalError( msg);
933 (*env)->FatalError(env, msg);
940 JNIEnv * env = FETCHENV;
945 RETVAL = env->NewGlobalRef(lobj);
947 RETVAL = (*env)->NewGlobalRef(env, lobj);
955 DeleteGlobalRef(gref)
956 JNIEnv * env = FETCHENV;
961 env->DeleteGlobalRef(gref);
963 (*env)->DeleteGlobalRef(env, gref);
970 JNIEnv * env = FETCHENV;
975 env->DeleteLocalRef( obj);
977 (*env)->DeleteLocalRef(env, obj);
983 IsSameObject(obj1,obj2)
984 JNIEnv * env = FETCHENV;
990 RETVAL = env->IsSameObject(obj1,obj2);
992 RETVAL = (*env)->IsSameObject(env, obj1,obj2);
1001 JNIEnv * env = FETCHENV;
1006 RETVAL = env->AllocObject(clazz);
1008 RETVAL = (*env)->AllocObject(env, clazz);
1016 NewObject(clazz,methodID,...)
1017 JNIEnv * env = FETCHENV;
1021 int argoff = $min_args;
1024 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1026 RETVAL = env->NewObjectA(clazz,methodID,args);
1028 RETVAL = (*env)->NewObjectA(env, clazz,methodID,args);
1036 NewObjectA(clazz,methodID,args)
1037 JNIEnv * env = FETCHENV;
1045 RETVAL = env->NewObjectA(clazz,methodID,args);
1047 RETVAL = (*env)->NewObjectA(env, clazz,methodID,args);
1056 JNIEnv * env = FETCHENV;
1061 RETVAL = env->GetObjectClass(obj);
1063 RETVAL = (*env)->GetObjectClass(env, obj);
1071 IsInstanceOf(obj,clazz)
1072 JNIEnv * env = FETCHENV;
1078 RETVAL = env->IsInstanceOf(obj,clazz);
1080 RETVAL = (*env)->IsInstanceOf(env, obj,clazz);
1088 GetMethodID(clazz,name,sig)
1089 JNIEnv * env = FETCHENV;
1096 RETVAL = env->GetMethodID(clazz,name,sig);
1098 RETVAL = (*env)->GetMethodID(env, clazz,name,sig);
1106 CallObjectMethod(obj,methodID,...)
1107 JNIEnv * env = FETCHENV;
1111 int argoff = $min_args;
1114 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1116 RETVAL = env->CallObjectMethodA(obj,methodID,args);
1118 RETVAL = (*env)->CallObjectMethodA(env, obj,methodID,args);
1126 CallObjectMethodA(obj,methodID,args)
1127 JNIEnv * env = FETCHENV;
1135 RETVAL = env->CallObjectMethodA(obj,methodID,args);
1137 RETVAL = (*env)->CallObjectMethodA(env, obj,methodID,args);
1145 CallBooleanMethod(obj,methodID,...)
1146 JNIEnv * env = FETCHENV;
1150 int argoff = $min_args;
1153 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1155 RETVAL = env->CallBooleanMethodA(obj,methodID,args);
1157 RETVAL = (*env)->CallBooleanMethodA(env, obj,methodID,args);
1165 CallBooleanMethodA(obj,methodID, args)
1166 JNIEnv * env = FETCHENV;
1174 RETVAL = env->CallBooleanMethodA(obj,methodID, args);
1176 RETVAL = (*env)->CallBooleanMethodA(env, obj,methodID, args);
1184 CallByteMethod(obj,methodID,...)
1185 JNIEnv * env = FETCHENV;
1189 int argoff = $min_args;
1192 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1194 RETVAL = env->CallByteMethodA(obj,methodID,args);
1196 RETVAL = (*env)->CallByteMethodA(env, obj,methodID,args);
1204 CallByteMethodA(obj,methodID,args)
1205 JNIEnv * env = FETCHENV;
1213 RETVAL = env->CallByteMethodA(obj,methodID,args);
1215 RETVAL = (*env)->CallByteMethodA(env, obj,methodID,args);
1223 CallCharMethod(obj,methodID,...)
1224 JNIEnv * env = FETCHENV;
1228 int argoff = $min_args;
1231 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1233 RETVAL = env->CallCharMethodA(obj,methodID,args);
1235 RETVAL = (*env)->CallCharMethodA(env, obj,methodID,args);
1243 CallCharMethodA(obj,methodID,args)
1244 JNIEnv * env = FETCHENV;
1252 RETVAL = env->CallCharMethodA(obj,methodID,args);
1254 RETVAL = (*env)->CallCharMethodA(env, obj,methodID,args);
1262 CallShortMethod(obj,methodID,...)
1263 JNIEnv * env = FETCHENV;
1267 int argoff = $min_args;
1270 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1272 RETVAL = env->CallShortMethodA(obj,methodID,args);
1274 RETVAL = (*env)->CallShortMethodA(env, obj,methodID,args);
1282 CallShortMethodA(obj,methodID,args)
1283 JNIEnv * env = FETCHENV;
1291 RETVAL = env->CallShortMethodA(obj,methodID,args);
1293 RETVAL = (*env)->CallShortMethodA(env, obj,methodID,args);
1301 CallIntMethod(obj,methodID,...)
1302 JNIEnv * env = FETCHENV;
1306 int argoff = $min_args;
1309 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1311 RETVAL = env->CallIntMethodA(obj,methodID,args);
1313 RETVAL = (*env)->CallIntMethodA(env, obj,methodID,args);
1321 CallIntMethodA(obj,methodID,args)
1322 JNIEnv * env = FETCHENV;
1330 RETVAL = env->CallIntMethodA(obj,methodID,args);
1332 RETVAL = (*env)->CallIntMethodA(env, obj,methodID,args);
1340 CallLongMethod(obj,methodID,...)
1341 JNIEnv * env = FETCHENV;
1345 int argoff = $min_args;
1348 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1350 RETVAL = env->CallLongMethodA(obj,methodID,args);
1352 RETVAL = (*env)->CallLongMethodA(env, obj,methodID,args);
1360 CallLongMethodA(obj,methodID,args)
1361 JNIEnv * env = FETCHENV;
1369 RETVAL = env->CallLongMethodA(obj,methodID,args);
1371 RETVAL = (*env)->CallLongMethodA(env, obj,methodID,args);
1379 CallFloatMethod(obj,methodID,...)
1380 JNIEnv * env = FETCHENV;
1384 int argoff = $min_args;
1387 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1389 RETVAL = env->CallFloatMethodA(obj,methodID,args);
1391 RETVAL = (*env)->CallFloatMethodA(env, obj,methodID,args);
1399 CallFloatMethodA(obj,methodID,args)
1400 JNIEnv * env = FETCHENV;
1408 RETVAL = env->CallFloatMethodA(obj,methodID,args);
1410 RETVAL = (*env)->CallFloatMethodA(env, obj,methodID,args);
1418 CallDoubleMethod(obj,methodID,...)
1419 JNIEnv * env = FETCHENV;
1423 int argoff = $min_args;
1426 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1428 RETVAL = env->CallDoubleMethodA(obj,methodID,args);
1430 RETVAL = (*env)->CallDoubleMethodA(env, obj,methodID,args);
1438 CallDoubleMethodA(obj,methodID,args)
1439 JNIEnv * env = FETCHENV;
1447 RETVAL = env->CallDoubleMethodA(obj,methodID,args);
1449 RETVAL = (*env)->CallDoubleMethodA(env, obj,methodID,args);
1457 CallVoidMethod(obj,methodID,...)
1458 JNIEnv * env = FETCHENV;
1462 int argoff = $min_args;
1465 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1467 env->CallVoidMethodA(obj,methodID,args);
1469 (*env)->CallVoidMethodA(env, obj,methodID,args);
1475 CallVoidMethodA(obj,methodID,args)
1476 JNIEnv * env = FETCHENV;
1484 env->CallVoidMethodA(obj,methodID,args);
1486 (*env)->CallVoidMethodA(env, obj,methodID,args);
1492 CallNonvirtualObjectMethod(obj,clazz,methodID,...)
1493 JNIEnv * env = FETCHENV;
1498 int argoff = $min_args;
1501 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1503 RETVAL = env->CallNonvirtualObjectMethodA(obj,clazz,methodID,args);
1505 RETVAL = (*env)->CallNonvirtualObjectMethodA(env, obj,clazz,methodID,args);
1513 CallNonvirtualObjectMethodA(obj,clazz,methodID,args)
1514 JNIEnv * env = FETCHENV;
1523 RETVAL = env->CallNonvirtualObjectMethodA(obj,clazz,methodID,args);
1525 RETVAL = (*env)->CallNonvirtualObjectMethodA(env, obj,clazz,methodID,args);
1533 CallNonvirtualBooleanMethod(obj,clazz,methodID,...)
1534 JNIEnv * env = FETCHENV;
1539 int argoff = $min_args;
1542 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1544 RETVAL = env->CallNonvirtualBooleanMethodA(obj,clazz,methodID,args);
1546 RETVAL = (*env)->CallNonvirtualBooleanMethodA(env, obj,clazz,methodID,args);
1554 CallNonvirtualBooleanMethodA(obj,clazz,methodID, args)
1555 JNIEnv * env = FETCHENV;
1564 RETVAL = env->CallNonvirtualBooleanMethodA(obj,clazz,methodID, args);
1566 RETVAL = (*env)->CallNonvirtualBooleanMethodA(env, obj,clazz,methodID, args);
1574 CallNonvirtualByteMethod(obj,clazz,methodID,...)
1575 JNIEnv * env = FETCHENV;
1580 int argoff = $min_args;
1583 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1585 RETVAL = env->CallNonvirtualByteMethodA(obj,clazz,methodID,args);
1587 RETVAL = (*env)->CallNonvirtualByteMethodA(env, obj,clazz,methodID,args);
1595 CallNonvirtualByteMethodA(obj,clazz,methodID,args)
1596 JNIEnv * env = FETCHENV;
1605 RETVAL = env->CallNonvirtualByteMethodA(obj,clazz,methodID,args);
1607 RETVAL = (*env)->CallNonvirtualByteMethodA(env, obj,clazz,methodID,args);
1615 CallNonvirtualCharMethod(obj,clazz,methodID,...)
1616 JNIEnv * env = FETCHENV;
1621 int argoff = $min_args;
1624 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1626 RETVAL = env->CallNonvirtualCharMethodA(obj,clazz,methodID,args);
1628 RETVAL = (*env)->CallNonvirtualCharMethodA(env, obj,clazz,methodID,args);
1636 CallNonvirtualCharMethodA(obj,clazz,methodID,args)
1637 JNIEnv * env = FETCHENV;
1646 RETVAL = env->CallNonvirtualCharMethodA(obj,clazz,methodID,args);
1648 RETVAL = (*env)->CallNonvirtualCharMethodA(env, obj,clazz,methodID,args);
1656 CallNonvirtualShortMethod(obj,clazz,methodID,...)
1657 JNIEnv * env = FETCHENV;
1662 int argoff = $min_args;
1665 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1667 RETVAL = env->CallNonvirtualShortMethodA(obj,clazz,methodID,args);
1669 RETVAL = (*env)->CallNonvirtualShortMethodA(env, obj,clazz,methodID,args);
1677 CallNonvirtualShortMethodA(obj,clazz,methodID,args)
1678 JNIEnv * env = FETCHENV;
1687 RETVAL = env->CallNonvirtualShortMethodA(obj,clazz,methodID,args);
1689 RETVAL = (*env)->CallNonvirtualShortMethodA(env, obj,clazz,methodID,args);
1697 CallNonvirtualIntMethod(obj,clazz,methodID,...)
1698 JNIEnv * env = FETCHENV;
1703 int argoff = $min_args;
1706 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1708 RETVAL = env->CallNonvirtualIntMethodA(obj,clazz,methodID,args);
1710 RETVAL = (*env)->CallNonvirtualIntMethodA(env, obj,clazz,methodID,args);
1718 CallNonvirtualIntMethodA(obj,clazz,methodID,args)
1719 JNIEnv * env = FETCHENV;
1728 RETVAL = env->CallNonvirtualIntMethodA(obj,clazz,methodID,args);
1730 RETVAL = (*env)->CallNonvirtualIntMethodA(env, obj,clazz,methodID,args);
1738 CallNonvirtualLongMethod(obj,clazz,methodID,...)
1739 JNIEnv * env = FETCHENV;
1744 int argoff = $min_args;
1747 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1749 RETVAL = env->CallNonvirtualLongMethodA(obj,clazz,methodID,args);
1751 RETVAL = (*env)->CallNonvirtualLongMethodA(env, obj,clazz,methodID,args);
1759 CallNonvirtualLongMethodA(obj,clazz,methodID,args)
1760 JNIEnv * env = FETCHENV;
1769 RETVAL = env->CallNonvirtualLongMethodA(obj,clazz,methodID,args);
1771 RETVAL = (*env)->CallNonvirtualLongMethodA(env, obj,clazz,methodID,args);
1779 CallNonvirtualFloatMethod(obj,clazz,methodID,...)
1780 JNIEnv * env = FETCHENV;
1785 int argoff = $min_args;
1788 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1790 RETVAL = env->CallNonvirtualFloatMethodA(obj,clazz,methodID,args);
1792 RETVAL = (*env)->CallNonvirtualFloatMethodA(env, obj,clazz,methodID,args);
1800 CallNonvirtualFloatMethodA(obj,clazz,methodID,args)
1801 JNIEnv * env = FETCHENV;
1810 RETVAL = env->CallNonvirtualFloatMethodA(obj,clazz,methodID,args);
1812 RETVAL = (*env)->CallNonvirtualFloatMethodA(env, obj,clazz,methodID,args);
1820 CallNonvirtualDoubleMethod(obj,clazz,methodID,...)
1821 JNIEnv * env = FETCHENV;
1826 int argoff = $min_args;
1829 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1831 RETVAL = env->CallNonvirtualDoubleMethodA(obj,clazz,methodID,args);
1833 RETVAL = (*env)->CallNonvirtualDoubleMethodA(env, obj,clazz,methodID,args);
1841 CallNonvirtualDoubleMethodA(obj,clazz,methodID,args)
1842 JNIEnv * env = FETCHENV;
1851 RETVAL = env->CallNonvirtualDoubleMethodA(obj,clazz,methodID,args);
1853 RETVAL = (*env)->CallNonvirtualDoubleMethodA(env, obj,clazz,methodID,args);
1861 CallNonvirtualVoidMethod(obj,clazz,methodID,...)
1862 JNIEnv * env = FETCHENV;
1867 int argoff = $min_args;
1870 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1872 env->CallNonvirtualVoidMethodA(obj,clazz,methodID,args);
1874 (*env)->CallNonvirtualVoidMethodA(env, obj,clazz,methodID,args);
1880 CallNonvirtualVoidMethodA(obj,clazz,methodID,args)
1881 JNIEnv * env = FETCHENV;
1890 env->CallNonvirtualVoidMethodA(obj,clazz,methodID,args);
1892 (*env)->CallNonvirtualVoidMethodA(env, obj,clazz,methodID,args);
1898 GetFieldID(clazz,name,sig)
1899 JNIEnv * env = FETCHENV;
1906 RETVAL = env->GetFieldID(clazz,name,sig);
1908 RETVAL = (*env)->GetFieldID(env, clazz,name,sig);
1916 GetObjectField(obj,fieldID)
1917 JNIEnv * env = FETCHENV;
1924 RETVAL = env->GetObjectField(obj,fieldID);
1926 RETVAL = (*env)->GetObjectField(env, obj,fieldID);
1934 GetBooleanField(obj,fieldID)
1935 JNIEnv * env = FETCHENV;
1942 RETVAL = env->GetBooleanField(obj,fieldID);
1944 RETVAL = (*env)->GetBooleanField(env, obj,fieldID);
1952 GetByteField(obj,fieldID)
1953 JNIEnv * env = FETCHENV;
1960 RETVAL = env->GetByteField(obj,fieldID);
1962 RETVAL = (*env)->GetByteField(env, obj,fieldID);
1970 GetCharField(obj,fieldID)
1971 JNIEnv * env = FETCHENV;
1978 RETVAL = env->GetCharField(obj,fieldID);
1980 RETVAL = (*env)->GetCharField(env, obj,fieldID);
1988 GetShortField(obj,fieldID)
1989 JNIEnv * env = FETCHENV;
1996 RETVAL = env->GetShortField(obj,fieldID);
1998 RETVAL = (*env)->GetShortField(env, obj,fieldID);
2006 GetIntField(obj,fieldID)
2007 JNIEnv * env = FETCHENV;
2014 RETVAL = env->GetIntField(obj,fieldID);
2016 RETVAL = (*env)->GetIntField(env, obj,fieldID);
2024 GetLongField(obj,fieldID)
2025 JNIEnv * env = FETCHENV;
2032 RETVAL = env->GetLongField(obj,fieldID);
2034 RETVAL = (*env)->GetLongField(env, obj,fieldID);
2042 GetFloatField(obj,fieldID)
2043 JNIEnv * env = FETCHENV;
2050 RETVAL = env->GetFloatField(obj,fieldID);
2052 RETVAL = (*env)->GetFloatField(env, obj,fieldID);
2060 GetDoubleField(obj,fieldID)
2061 JNIEnv * env = FETCHENV;
2068 RETVAL = env->GetDoubleField(obj,fieldID);
2070 RETVAL = (*env)->GetDoubleField(env, obj,fieldID);
2078 SetObjectField(obj,fieldID,val)
2079 JNIEnv * env = FETCHENV;
2087 env->SetObjectField(obj,fieldID,val);
2089 (*env)->SetObjectField(env, obj,fieldID,val);
2095 SetBooleanField(obj,fieldID,val)
2096 JNIEnv * env = FETCHENV;
2104 env->SetBooleanField(obj,fieldID,val);
2106 (*env)->SetBooleanField(env, obj,fieldID,val);
2112 SetByteField(obj,fieldID,val)
2113 JNIEnv * env = FETCHENV;
2121 env->SetByteField(obj,fieldID,val);
2123 (*env)->SetByteField(env, obj,fieldID,val);
2129 SetCharField(obj,fieldID,val)
2130 JNIEnv * env = FETCHENV;
2138 env->SetCharField(obj,fieldID,val);
2140 (*env)->SetCharField(env, obj,fieldID,val);
2146 SetShortField(obj,fieldID,val)
2147 JNIEnv * env = FETCHENV;
2155 env->SetShortField(obj,fieldID,val);
2157 (*env)->SetShortField(env, obj,fieldID,val);
2163 SetIntField(obj,fieldID,val)
2164 JNIEnv * env = FETCHENV;
2172 env->SetIntField(obj,fieldID,val);
2174 (*env)->SetIntField(env, obj,fieldID,val);
2180 SetLongField(obj,fieldID,val)
2181 JNIEnv * env = FETCHENV;
2189 env->SetLongField(obj,fieldID,val);
2191 (*env)->SetLongField(env, obj,fieldID,val);
2197 SetFloatField(obj,fieldID,val)
2198 JNIEnv * env = FETCHENV;
2206 env->SetFloatField(obj,fieldID,val);
2208 (*env)->SetFloatField(env, obj,fieldID,val);
2214 SetDoubleField(obj,fieldID,val)
2215 JNIEnv * env = FETCHENV;
2223 env->SetDoubleField(obj,fieldID,val);
2225 (*env)->SetDoubleField(env, obj,fieldID,val);
2231 GetStaticMethodID(clazz,name,sig)
2232 JNIEnv * env = FETCHENV;
2239 RETVAL = env->GetStaticMethodID(clazz,name,sig);
2241 RETVAL = (*env)->GetStaticMethodID(env, clazz,name,sig);
2249 CallStaticObjectMethod(clazz,methodID,...)
2250 JNIEnv * env = FETCHENV;
2254 int argoff = $min_args;
2257 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
2259 RETVAL = env->CallStaticObjectMethodA(clazz,methodID,args);
2261 RETVAL = (*env)->CallStaticObjectMethodA(env, clazz,methodID,args);
2269 CallStaticObjectMethodA(clazz,methodID,args)
2270 JNIEnv * env = FETCHENV;
2278 RETVAL = env->CallStaticObjectMethodA(clazz,methodID,args);
2280 RETVAL = (*env)->CallStaticObjectMethodA(env, clazz,methodID,args);
2288 CallStaticBooleanMethod(clazz,methodID,...)
2289 JNIEnv * env = FETCHENV;
2293 int argoff = $min_args;
2296 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
2298 RETVAL = env->CallStaticBooleanMethodA(clazz,methodID,args);
2300 RETVAL = (*env)->CallStaticBooleanMethodA(env, clazz,methodID,args);
2308 CallStaticBooleanMethodA(clazz,methodID,args)
2309 JNIEnv * env = FETCHENV;
2317 RETVAL = env->CallStaticBooleanMethodA(clazz,methodID,args);
2319 RETVAL = (*env)->CallStaticBooleanMethodA(env, clazz,methodID,args);
2327 CallStaticByteMethod(clazz,methodID,...)
2328 JNIEnv * env = FETCHENV;
2332 int argoff = $min_args;
2335 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
2337 RETVAL = env->CallStaticByteMethodA(clazz,methodID,args);
2339 RETVAL = (*env)->CallStaticByteMethodA(env, clazz,methodID,args);
2347 CallStaticByteMethodA(clazz,methodID,args)
2348 JNIEnv * env = FETCHENV;
2356 RETVAL = env->CallStaticByteMethodA(clazz,methodID,args);
2358 RETVAL = (*env)->CallStaticByteMethodA(env, clazz,methodID,args);
2366 CallStaticCharMethod(clazz,methodID,...)
2367 JNIEnv * env = FETCHENV;
2371 int argoff = $min_args;
2374 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
2376 RETVAL = env->CallStaticCharMethodA(clazz,methodID,args);
2378 RETVAL = (*env)->CallStaticCharMethodA(env, clazz,methodID,args);
2386 CallStaticCharMethodA(clazz,methodID,args)
2387 JNIEnv * env = FETCHENV;
2395 RETVAL = env->CallStaticCharMethodA(clazz,methodID,args);
2397 RETVAL = (*env)->CallStaticCharMethodA(env, clazz,methodID,args);
2405 CallStaticShortMethod(clazz,methodID,...)
2406 JNIEnv * env = FETCHENV;
2410 int argoff = $min_args;
2413 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
2415 RETVAL = env->CallStaticShortMethodA(clazz,methodID,args);
2417 RETVAL = (*env)->CallStaticShortMethodA(env, clazz,methodID,args);
2425 CallStaticShortMethodA(clazz,methodID,args)
2426 JNIEnv * env = FETCHENV;
2434 RETVAL = env->CallStaticShortMethodA(clazz,methodID,args);
2436 RETVAL = (*env)->CallStaticShortMethodA(env, clazz,methodID,args);
2444 CallStaticIntMethod(clazz,methodID,...)
2445 JNIEnv * env = FETCHENV;
2449 int argoff = $min_args;
2452 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
2454 RETVAL = env->CallStaticIntMethodA(clazz,methodID,args);
2456 RETVAL = (*env)->CallStaticIntMethodA(env, clazz,methodID,args);
2464 CallStaticIntMethodA(clazz,methodID,args)
2465 JNIEnv * env = FETCHENV;
2473 RETVAL = env->CallStaticIntMethodA(clazz,methodID,args);
2475 RETVAL = (*env)->CallStaticIntMethodA(env, clazz,methodID,args);
2483 CallStaticLongMethod(clazz,methodID,...)
2484 JNIEnv * env = FETCHENV;
2488 int argoff = $min_args;
2491 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
2493 RETVAL = env->CallStaticLongMethodA(clazz,methodID,args);
2495 RETVAL = (*env)->CallStaticLongMethodA(env, clazz,methodID,args);
2503 CallStaticLongMethodA(clazz,methodID,args)
2504 JNIEnv * env = FETCHENV;
2512 RETVAL = env->CallStaticLongMethodA(clazz,methodID,args);
2514 RETVAL = (*env)->CallStaticLongMethodA(env, clazz,methodID,args);
2522 CallStaticFloatMethod(clazz,methodID,...)
2523 JNIEnv * env = FETCHENV;
2527 int argoff = $min_args;
2530 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
2532 RETVAL = env->CallStaticFloatMethodA(clazz,methodID,args);
2534 RETVAL = (*env)->CallStaticFloatMethodA(env, clazz,methodID,args);
2542 CallStaticFloatMethodA(clazz,methodID,args)
2543 JNIEnv * env = FETCHENV;
2551 RETVAL = env->CallStaticFloatMethodA(clazz,methodID,args);
2553 RETVAL = (*env)->CallStaticFloatMethodA(env, clazz,methodID,args);
2561 CallStaticDoubleMethod(clazz,methodID,...)
2562 JNIEnv * env = FETCHENV;
2566 int argoff = $min_args;
2569 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
2571 RETVAL = env->CallStaticDoubleMethodA(clazz,methodID,args);
2573 RETVAL = (*env)->CallStaticDoubleMethodA(env, clazz,methodID,args);
2581 CallStaticDoubleMethodA(clazz,methodID,args)
2582 JNIEnv * env = FETCHENV;
2590 RETVAL = env->CallStaticDoubleMethodA(clazz,methodID,args);
2592 RETVAL = (*env)->CallStaticDoubleMethodA(env, clazz,methodID,args);
2600 CallStaticVoidMethod(cls,methodID,...)
2601 JNIEnv * env = FETCHENV;
2605 int argoff = $min_args;
2608 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
2610 env->CallStaticVoidMethodA(cls,methodID,args);
2612 (*env)->CallStaticVoidMethodA(env, cls,methodID,args);
2618 CallStaticVoidMethodA(cls,methodID,args)
2619 JNIEnv * env = FETCHENV;
2627 env->CallStaticVoidMethodA(cls,methodID,args);
2629 (*env)->CallStaticVoidMethodA(env, cls,methodID,args);
2635 GetStaticFieldID(clazz,name,sig)
2636 JNIEnv * env = FETCHENV;
2643 RETVAL = env->GetStaticFieldID(clazz,name,sig);
2645 RETVAL = (*env)->GetStaticFieldID(env, clazz,name,sig);
2653 GetStaticObjectField(clazz,fieldID)
2654 JNIEnv * env = FETCHENV;
2661 RETVAL = env->GetStaticObjectField(clazz,fieldID);
2663 RETVAL = (*env)->GetStaticObjectField(env, clazz,fieldID);
2671 GetStaticBooleanField(clazz,fieldID)
2672 JNIEnv * env = FETCHENV;
2679 RETVAL = env->GetStaticBooleanField(clazz,fieldID);
2681 RETVAL = (*env)->GetStaticBooleanField(env, clazz,fieldID);
2689 GetStaticByteField(clazz,fieldID)
2690 JNIEnv * env = FETCHENV;
2697 RETVAL = env->GetStaticByteField(clazz,fieldID);
2699 RETVAL = (*env)->GetStaticByteField(env, clazz,fieldID);
2707 GetStaticCharField(clazz,fieldID)
2708 JNIEnv * env = FETCHENV;
2715 RETVAL = env->GetStaticCharField(clazz,fieldID);
2717 RETVAL = (*env)->GetStaticCharField(env, clazz,fieldID);
2725 GetStaticShortField(clazz,fieldID)
2726 JNIEnv * env = FETCHENV;
2733 RETVAL = env->GetStaticShortField(clazz,fieldID);
2735 RETVAL = (*env)->GetStaticShortField(env, clazz,fieldID);
2743 GetStaticIntField(clazz,fieldID)
2744 JNIEnv * env = FETCHENV;
2751 RETVAL = env->GetStaticIntField(clazz,fieldID);
2753 RETVAL = (*env)->GetStaticIntField(env, clazz,fieldID);
2761 GetStaticLongField(clazz,fieldID)
2762 JNIEnv * env = FETCHENV;
2769 RETVAL = env->GetStaticLongField(clazz,fieldID);
2771 RETVAL = (*env)->GetStaticLongField(env, clazz,fieldID);
2779 GetStaticFloatField(clazz,fieldID)
2780 JNIEnv * env = FETCHENV;
2787 RETVAL = env->GetStaticFloatField(clazz,fieldID);
2789 RETVAL = (*env)->GetStaticFloatField(env, clazz,fieldID);
2797 GetStaticDoubleField(clazz,fieldID)
2798 JNIEnv * env = FETCHENV;
2805 RETVAL = env->GetStaticDoubleField(clazz,fieldID);
2807 RETVAL = (*env)->GetStaticDoubleField(env, clazz,fieldID);
2815 SetStaticObjectField(clazz,fieldID,value)
2816 JNIEnv * env = FETCHENV;
2824 env->SetStaticObjectField(clazz,fieldID,value);
2826 (*env)->SetStaticObjectField(env, clazz,fieldID,value);
2832 SetStaticBooleanField(clazz,fieldID,value)
2833 JNIEnv * env = FETCHENV;
2841 env->SetStaticBooleanField(clazz,fieldID,value);
2843 (*env)->SetStaticBooleanField(env, clazz,fieldID,value);
2849 SetStaticByteField(clazz,fieldID,value)
2850 JNIEnv * env = FETCHENV;
2858 env->SetStaticByteField(clazz,fieldID,value);
2860 (*env)->SetStaticByteField(env, clazz,fieldID,value);
2866 SetStaticCharField(clazz,fieldID,value)
2867 JNIEnv * env = FETCHENV;
2875 env->SetStaticCharField(clazz,fieldID,value);
2877 (*env)->SetStaticCharField(env, clazz,fieldID,value);
2883 SetStaticShortField(clazz,fieldID,value)
2884 JNIEnv * env = FETCHENV;
2892 env->SetStaticShortField(clazz,fieldID,value);
2894 (*env)->SetStaticShortField(env, clazz,fieldID,value);
2900 SetStaticIntField(clazz,fieldID,value)
2901 JNIEnv * env = FETCHENV;
2909 env->SetStaticIntField(clazz,fieldID,value);
2911 (*env)->SetStaticIntField(env, clazz,fieldID,value);
2917 SetStaticLongField(clazz,fieldID,value)
2918 JNIEnv * env = FETCHENV;
2926 env->SetStaticLongField(clazz,fieldID,value);
2928 (*env)->SetStaticLongField(env, clazz,fieldID,value);
2934 SetStaticFloatField(clazz,fieldID,value)
2935 JNIEnv * env = FETCHENV;
2943 env->SetStaticFloatField(clazz,fieldID,value);
2945 (*env)->SetStaticFloatField(env, clazz,fieldID,value);
2951 SetStaticDoubleField(clazz,fieldID,value)
2952 JNIEnv * env = FETCHENV;
2960 env->SetStaticDoubleField(clazz,fieldID,value);
2962 (*env)->SetStaticDoubleField(env, clazz,fieldID,value);
2969 JNIEnv * env = FETCHENV;
2970 STRLEN tmplen = NO_INIT;
2971 jsize unicode_len_ = NO_INIT;
2972 const jchar * unicode
2976 RETVAL = env->NewString(unicode, unicode_len_);
2978 RETVAL = (*env)->NewString(env, unicode, unicode_len_);
2986 GetStringLength(str)
2987 JNIEnv * env = FETCHENV;
2992 RETVAL = env->GetStringLength(str);
2994 RETVAL = (*env)->GetStringLength(env, str);
3003 JNIEnv * env = FETCHENV;
3005 jboolean isCopy = NO_INIT;
3006 jsize RETVAL_len_ = NO_INIT;
3010 RETVAL = env->GetStringChars(str,&isCopy);
3012 RETVAL = (*env)->GetStringChars(env, str,&isCopy);
3015 RETVAL_len_ = env->GetStringLength(str);
3017 RETVAL_len_ = (*env)->GetStringLength(env, str);
3025 env->ReleaseStringChars(str,RETVAL);
3027 (*env)->ReleaseStringChars(env, str,RETVAL);
3032 JNIEnv * env = FETCHENV;
3037 RETVAL = env->NewStringUTF(utf);
3039 RETVAL = (*env)->NewStringUTF(env, utf);
3047 GetStringUTFLength(str)
3048 JNIEnv * env = FETCHENV;
3053 RETVAL = env->GetStringUTFLength(str);
3055 RETVAL = (*env)->GetStringUTFLength(env, str);
3063 GetStringUTFChars(str)
3064 JNIEnv * env = FETCHENV;
3066 jboolean isCopy = NO_INIT;
3070 RETVAL = env->GetStringUTFChars(str,&isCopy);
3072 RETVAL = (*env)->GetStringUTFChars(env, str,&isCopy);
3080 env->ReleaseStringUTFChars(str, RETVAL);
3082 (*env)->ReleaseStringUTFChars(env, str, RETVAL);
3087 GetArrayLength(array)
3088 JNIEnv * env = FETCHENV;
3093 RETVAL = env->GetArrayLength(array);
3095 RETVAL = (*env)->GetArrayLength(env, array);
3103 NewObjectArray(len,clazz,init)
3104 JNIEnv * env = FETCHENV;
3111 RETVAL = env->NewObjectArray(len,clazz,init);
3113 RETVAL = (*env)->NewObjectArray(env, len,clazz,init);
3121 GetObjectArrayElement(array,index)
3122 JNIEnv * env = FETCHENV;
3128 RETVAL = env->GetObjectArrayElement(array,index);
3130 RETVAL = (*env)->GetObjectArrayElement(env, array,index);
3138 SetObjectArrayElement(array,index,val)
3139 JNIEnv * env = FETCHENV;
3146 env->SetObjectArrayElement(array,index,val);
3148 (*env)->SetObjectArrayElement(env, array,index,val);
3154 NewBooleanArray(len)
3155 JNIEnv * env = FETCHENV;
3160 RETVAL = env->NewBooleanArray(len);
3162 RETVAL = (*env)->NewBooleanArray(env, len);
3171 JNIEnv * env = FETCHENV;
3176 RETVAL = env->NewByteArray(len);
3178 RETVAL = (*env)->NewByteArray(env, len);
3187 JNIEnv * env = FETCHENV;
3192 RETVAL = env->NewCharArray(len);
3194 RETVAL = (*env)->NewCharArray(env, len);
3203 JNIEnv * env = FETCHENV;
3208 RETVAL = env->NewShortArray(len);
3210 RETVAL = (*env)->NewShortArray(env, len);
3219 JNIEnv * env = FETCHENV;
3224 RETVAL = env->NewIntArray(len);
3226 RETVAL = (*env)->NewIntArray(env, len);
3235 JNIEnv * env = FETCHENV;
3240 RETVAL = env->NewLongArray(len);
3242 RETVAL = (*env)->NewLongArray(env, len);
3251 JNIEnv * env = FETCHENV;
3256 RETVAL = env->NewFloatArray(len);
3258 RETVAL = (*env)->NewFloatArray(env, len);
3267 JNIEnv * env = FETCHENV;
3272 RETVAL = env->NewDoubleArray(len);
3274 RETVAL = (*env)->NewDoubleArray(env, len);
3282 GetBooleanArrayElements(array)
3283 JNIEnv * env = FETCHENV;
3284 jsize RETVAL_len_ = NO_INIT;
3286 jboolean isCopy = NO_INIT;
3290 RETVAL = env->GetBooleanArrayElements(array,&isCopy);
3292 RETVAL = (*env)->GetBooleanArrayElements(env, array,&isCopy);
3295 RETVAL_len_ = env->GetArrayLength(array);
3297 RETVAL_len_ = (*env)->GetArrayLength(env, array);
3299 if (GIMME == G_ARRAY) {
3301 jboolean* r = RETVAL;
3302 EXTEND(sp, RETVAL_len_);
3303 for (i = RETVAL_len_; i; --i) {
3304 PUSHs(sv_2mortal(newSViv(*r++)));
3309 PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
3310 (STRLEN)RETVAL_len_ * sizeof(jboolean))));
3316 env->ReleaseBooleanArrayElements(array,RETVAL,JNI_ABORT);
3318 (*env)->ReleaseBooleanArrayElements(env, array,RETVAL,JNI_ABORT);
3324 GetByteArrayElements(array)
3325 JNIEnv * env = FETCHENV;
3326 jsize RETVAL_len_ = NO_INIT;
3328 jboolean isCopy = NO_INIT;
3332 RETVAL = env->GetByteArrayElements(array,&isCopy);
3334 RETVAL = (*env)->GetByteArrayElements(env, array,&isCopy);
3337 RETVAL_len_ = env->GetArrayLength(array);
3339 RETVAL_len_ = (*env)->GetArrayLength(env, array);
3341 if (GIMME == G_ARRAY) {
3344 EXTEND(sp, RETVAL_len_);
3345 for (i = RETVAL_len_; i; --i) {
3346 PUSHs(sv_2mortal(newSViv(*r++)));
3351 PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
3352 (STRLEN)RETVAL_len_ * sizeof(jbyte))));
3358 env->ReleaseByteArrayElements(array,RETVAL,JNI_ABORT);
3360 (*env)->ReleaseByteArrayElements(env, array,RETVAL,JNI_ABORT);
3366 GetCharArrayElements(array)
3367 JNIEnv * env = FETCHENV;
3368 jsize RETVAL_len_ = NO_INIT;
3370 jboolean isCopy = NO_INIT;
3374 RETVAL = env->GetCharArrayElements(array,&isCopy);
3376 RETVAL = (*env)->GetCharArrayElements(env, array,&isCopy);
3379 RETVAL_len_ = env->GetArrayLength(array);
3381 RETVAL_len_ = (*env)->GetArrayLength(env, array);
3383 if (GIMME == G_ARRAY) {
3386 EXTEND(sp, RETVAL_len_);
3387 for (i = RETVAL_len_; i; --i) {
3388 PUSHs(sv_2mortal(newSViv(*r++)));
3393 PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
3394 (STRLEN)RETVAL_len_ * sizeof(jchar))));
3400 env->ReleaseCharArrayElements(array,RETVAL,JNI_ABORT);
3402 (*env)->ReleaseCharArrayElements(env, array,RETVAL,JNI_ABORT);
3408 GetShortArrayElements(array)
3409 JNIEnv * env = FETCHENV;
3410 jsize RETVAL_len_ = NO_INIT;
3412 jboolean isCopy = NO_INIT;
3416 RETVAL = env->GetShortArrayElements(array,&isCopy);
3418 RETVAL = (*env)->GetShortArrayElements(env, array,&isCopy);
3421 RETVAL_len_ = env->GetArrayLength(array);
3423 RETVAL_len_ = (*env)->GetArrayLength(env, array);
3425 if (GIMME == G_ARRAY) {
3428 EXTEND(sp, RETVAL_len_);
3429 for (i = RETVAL_len_; i; --i) {
3430 PUSHs(sv_2mortal(newSViv(*r++)));
3435 PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
3436 (STRLEN)RETVAL_len_ * sizeof(jshort))));
3442 env->ReleaseShortArrayElements(array,RETVAL,JNI_ABORT);
3444 (*env)->ReleaseShortArrayElements(env, array,RETVAL,JNI_ABORT);
3450 GetIntArrayElements(array)
3451 JNIEnv * env = FETCHENV;
3452 jsize RETVAL_len_ = NO_INIT;
3454 jboolean isCopy = NO_INIT;
3458 RETVAL = env->GetIntArrayElements(array,&isCopy);
3460 RETVAL = (*env)->GetIntArrayElements(env, array,&isCopy);
3463 RETVAL_len_ = env->GetArrayLength(array);
3465 RETVAL_len_ = (*env)->GetArrayLength(env, array);
3467 if (GIMME == G_ARRAY) {
3470 EXTEND(sp, RETVAL_len_);
3471 for (i = RETVAL_len_; i; --i) {
3472 PUSHs(sv_2mortal(newSViv(*r++)));
3477 PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
3478 (STRLEN)RETVAL_len_ * sizeof(jint))));
3484 env->ReleaseIntArrayElements(array,RETVAL,JNI_ABORT);
3486 (*env)->ReleaseIntArrayElements(env, array,RETVAL,JNI_ABORT);
3492 GetLongArrayElements(array)
3493 JNIEnv * env = FETCHENV;
3494 jsize RETVAL_len_ = NO_INIT;
3496 jboolean isCopy = NO_INIT;
3500 RETVAL = env->GetLongArrayElements(array,&isCopy);
3502 RETVAL = (*env)->GetLongArrayElements(env, array,&isCopy);
3505 RETVAL_len_ = env->GetArrayLength(array);
3507 RETVAL_len_ = (*env)->GetArrayLength(env, array);
3509 if (GIMME == G_ARRAY) {
3512 EXTEND(sp, RETVAL_len_);
3513 for (i = RETVAL_len_; i; --i) {
3514 PUSHs(sv_2mortal(newSViv(*r++)));
3519 PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
3520 (STRLEN)RETVAL_len_ * sizeof(jlong))));
3526 env->ReleaseLongArrayElements(array,RETVAL,JNI_ABORT);
3528 (*env)->ReleaseLongArrayElements(env, array,RETVAL,JNI_ABORT);
3534 GetFloatArrayElements(array)
3535 JNIEnv * env = FETCHENV;
3536 jsize RETVAL_len_ = NO_INIT;
3538 jboolean isCopy = NO_INIT;
3542 RETVAL = env->GetFloatArrayElements(array,&isCopy);
3544 RETVAL = (*env)->GetFloatArrayElements(env, array,&isCopy);
3547 RETVAL_len_ = env->GetArrayLength(array);
3549 RETVAL_len_ = (*env)->GetArrayLength(env, array);
3551 if (GIMME == G_ARRAY) {
3554 EXTEND(sp, RETVAL_len_);
3555 for (i = RETVAL_len_; i; --i) {
3556 PUSHs(sv_2mortal(newSVnv(*r++)));
3561 PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
3562 (STRLEN)RETVAL_len_ * sizeof(jfloat))));
3568 env->ReleaseFloatArrayElements(array,RETVAL,JNI_ABORT);
3570 (*env)->ReleaseFloatArrayElements(env, array,RETVAL,JNI_ABORT);
3576 GetDoubleArrayElements(array)
3577 JNIEnv * env = FETCHENV;
3578 jsize RETVAL_len_ = NO_INIT;
3580 jboolean isCopy = NO_INIT;
3584 RETVAL = env->GetDoubleArrayElements(array,&isCopy);
3586 RETVAL = (*env)->GetDoubleArrayElements(env, array,&isCopy);
3589 RETVAL_len_ = env->GetArrayLength(array);
3591 RETVAL_len_ = (*env)->GetArrayLength(env, array);
3593 if (GIMME == G_ARRAY) {
3595 jdouble* r = RETVAL;
3596 EXTEND(sp, RETVAL_len_);
3597 for (i = RETVAL_len_; i; --i) {
3598 PUSHs(sv_2mortal(newSVnv(*r++)));
3603 PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
3604 (STRLEN)RETVAL_len_ * sizeof(jdouble))));
3610 env->ReleaseDoubleArrayElements(array,RETVAL,JNI_ABORT);
3612 (*env)->ReleaseDoubleArrayElements(env, array,RETVAL,JNI_ABORT);
3618 GetBooleanArrayRegion(array,start,len,buf)
3619 JNIEnv * env = FETCHENV;
3623 STRLEN tmplen = len * sizeof(jboolean) + 1;
3624 char * tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
3625 jboolean * buf = (jboolean*)sv_grow(ST(3),len * sizeof(jboolean)+1);
3629 env->GetBooleanArrayRegion(array,start,len,buf);
3631 (*env)->GetBooleanArrayRegion(env, array,start,len,buf);
3633 SvCUR_set(ST(3), len * sizeof(jboolean));
3634 *SvEND(ST(3)) = '\0';
3639 GetByteArrayRegion(array,start,len,buf)
3640 JNIEnv * env = FETCHENV;
3644 STRLEN tmplen = len * sizeof(jboolean) + 1;
3645 char * tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
3646 jbyte * buf = (jbyte*)sv_grow(ST(3),len * sizeof(jbyte)+1);
3650 env->GetByteArrayRegion(array,start,len,buf);
3652 (*env)->GetByteArrayRegion(env, array,start,len,buf);
3654 SvCUR_set(ST(3), len * sizeof(jbyte));
3655 *SvEND(ST(3)) = '\0';
3660 GetCharArrayRegion(array,start,len,buf)
3661 JNIEnv * env = FETCHENV;
3665 STRLEN tmplen = len * sizeof(jboolean) + 1;
3666 char * tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
3667 jchar * buf = (jchar*)sv_grow(ST(3),len * sizeof(jchar)+1);
3671 env->GetCharArrayRegion(array,start,len,buf);
3673 (*env)->GetCharArrayRegion(env, array,start,len,buf);
3675 SvCUR_set(ST(3), len * sizeof(jchar));
3676 *SvEND(ST(3)) = '\0';
3681 GetShortArrayRegion(array,start,len,buf)
3682 JNIEnv * env = FETCHENV;
3686 STRLEN tmplen = len * sizeof(jboolean) + 1;
3687 char * tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
3688 jshort * buf = (jshort*)sv_grow(ST(3),len * sizeof(jshort)+1);
3692 env->GetShortArrayRegion(array,start,len,buf);
3694 (*env)->GetShortArrayRegion(env, array,start,len,buf);
3696 SvCUR_set(ST(3), len * sizeof(jshort));
3697 *SvEND(ST(3)) = '\0';
3702 GetIntArrayRegion(array,start,len,buf)
3703 JNIEnv * env = FETCHENV;
3707 STRLEN tmplen = len * sizeof(jboolean) + 1;
3708 char * tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
3709 jint * buf = (jint*)sv_grow(ST(3),len * sizeof(jint)+1);
3713 env->GetIntArrayRegion(array,start,len,buf);
3715 (*env)->GetIntArrayRegion(env, array,start,len,buf);
3717 SvCUR_set(ST(3), len * sizeof(jint));
3718 *SvEND(ST(3)) = '\0';
3723 GetLongArrayRegion(array,start,len,buf)
3724 JNIEnv * env = FETCHENV;
3728 STRLEN tmplen = len * sizeof(jboolean) + 1;
3729 char * tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
3730 jlong * buf = (jlong*)sv_grow(ST(3),len * sizeof(jlong)+1);
3734 env->GetLongArrayRegion(array,start,len,buf);
3736 (*env)->GetLongArrayRegion(env, array,start,len,buf);
3738 SvCUR_set(ST(3), len * sizeof(jlong));
3739 *SvEND(ST(3)) = '\0';
3744 GetFloatArrayRegion(array,start,len,buf)
3745 JNIEnv * env = FETCHENV;
3749 STRLEN tmplen = len * sizeof(jboolean) + 1;
3750 char * tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
3751 jfloat * buf = (jfloat*)sv_grow(ST(3),len * sizeof(jfloat)+1);
3755 env->GetFloatArrayRegion(array,start,len,buf);
3757 (*env)->GetFloatArrayRegion(env, array,start,len,buf);
3759 SvCUR_set(ST(3), len * sizeof(jfloat));
3760 *SvEND(ST(3)) = '\0';
3765 GetDoubleArrayRegion(array,start,len,buf)
3766 JNIEnv * env = FETCHENV;
3770 STRLEN tmplen = len * sizeof(jboolean) + 1;
3771 char * tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
3772 jdouble * buf = (jdouble*)sv_grow(ST(3),len * sizeof(jdouble)+1);
3776 env->GetDoubleArrayRegion(array,start,len,buf);
3778 (*env)->GetDoubleArrayRegion(env, array,start,len,buf);
3780 SvCUR_set(ST(3), len * sizeof(jdouble));
3781 *SvEND(ST(3)) = '\0';
3786 SetBooleanArrayRegion(array,start,len,buf)
3787 JNIEnv * env = FETCHENV;
3788 STRLEN tmplen = NO_INIT;
3792 jsize buf_len_ = NO_INIT;
3797 croak("string is too short");
3798 else if (buf_len_ > len && PL_dowarn)
3799 warn("string is too long");
3801 env->SetBooleanArrayRegion(array,start,len,buf);
3803 (*env)->SetBooleanArrayRegion(env, array,start,len,buf);
3809 SetByteArrayRegion(array,start,len,buf)
3810 JNIEnv * env = FETCHENV;
3811 STRLEN tmplen = NO_INIT;
3815 jsize buf_len_ = NO_INIT;
3820 croak("string is too short");
3821 else if (buf_len_ > len && PL_dowarn)
3822 warn("string is too long");
3824 env->SetByteArrayRegion(array,start,len,buf);
3826 (*env)->SetByteArrayRegion(env, array,start,len,buf);
3832 SetCharArrayRegion(array,start,len,buf)
3833 JNIEnv * env = FETCHENV;
3834 STRLEN tmplen = NO_INIT;
3838 jsize buf_len_ = NO_INIT;
3843 croak("string is too short");
3844 else if (buf_len_ > len && PL_dowarn)
3845 warn("string is too long");
3847 env->SetCharArrayRegion(array,start,len,buf);
3849 (*env)->SetCharArrayRegion(env, array,start,len,buf);
3855 SetShortArrayRegion(array,start,len,buf)
3856 JNIEnv * env = FETCHENV;
3857 STRLEN tmplen = NO_INIT;
3861 jsize buf_len_ = NO_INIT;
3866 croak("string is too short");
3867 else if (buf_len_ > len && PL_dowarn)
3868 warn("string is too long");
3870 env->SetShortArrayRegion(array,start,len,buf);
3872 (*env)->SetShortArrayRegion(env, array,start,len,buf);
3878 SetIntArrayRegion(array,start,len,buf)
3879 JNIEnv * env = FETCHENV;
3880 STRLEN tmplen = NO_INIT;
3884 jsize buf_len_ = NO_INIT;
3889 croak("string is too short");
3890 else if (buf_len_ > len && PL_dowarn)
3891 warn("string is too long");
3893 env->SetIntArrayRegion(array,start,len,buf);
3895 (*env)->SetIntArrayRegion(env, array,start,len,buf);
3901 SetLongArrayRegion(array,start,len,buf)
3902 JNIEnv * env = FETCHENV;
3903 STRLEN tmplen = NO_INIT;
3907 jsize buf_len_ = NO_INIT;
3912 croak("string is too short");
3913 else if (buf_len_ > len && PL_dowarn)
3914 warn("string is too long");
3916 env->SetLongArrayRegion(array,start,len,buf);
3918 (*env)->SetLongArrayRegion(env, array,start,len,buf);
3924 SetFloatArrayRegion(array,start,len,buf)
3925 JNIEnv * env = FETCHENV;
3926 STRLEN tmplen = NO_INIT;
3930 jsize buf_len_ = NO_INIT;
3935 croak("string is too short");
3936 else if (buf_len_ > len && PL_dowarn)
3937 warn("string is too long");
3939 env->SetFloatArrayRegion(array,start,len,buf);
3941 (*env)->SetFloatArrayRegion(env, array,start,len,buf);
3947 SetDoubleArrayRegion(array,start,len,buf)
3948 JNIEnv * env = FETCHENV;
3949 STRLEN tmplen = NO_INIT;
3953 jsize buf_len_ = NO_INIT;
3958 croak("string is too short");
3959 else if (buf_len_ > len && PL_dowarn)
3960 warn("string is too long");
3962 env->SetDoubleArrayRegion(array,start,len,buf);
3964 (*env)->SetDoubleArrayRegion(env, array,start,len,buf);
3970 RegisterNatives(clazz,methods,nMethods)
3971 JNIEnv * env = FETCHENV;
3973 JNINativeMethod * methods
3978 RETVAL = env->RegisterNatives(clazz,methods,nMethods);
3980 RETVAL = (*env)->RegisterNatives(env, clazz,methods,nMethods);
3985 UnregisterNatives(clazz)
3986 JNIEnv * env = FETCHENV;
3991 RETVAL = env->UnregisterNatives(clazz);
3993 RETVAL = (*env)->UnregisterNatives(env, clazz);
4001 JNIEnv * env = FETCHENV;
4006 RETVAL = env->MonitorEnter(obj);
4008 RETVAL = (*env)->MonitorEnter(env, obj);
4017 JNIEnv * env = FETCHENV;
4022 RETVAL = env->MonitorExit(obj);
4024 RETVAL = (*env)->MonitorExit(env, obj);
4033 JNIEnv * env = FETCHENV;
4036 if (env) { /* We're embedded. */
4038 if (env->GetJavaVM(&RETVAL) < 0)
4040 if ((*env)->GetJavaVM(env, &RETVAL) < 0)
4044 else { /* We're embedding. */
4046 JavaVMInitArgs vm_args;
4048 JDK1_1InitArgs vm_args;
4052 fprintf(stderr, "We're embedding Java in Perl.\n");
4057 lib = SvPV(*mark, PL_na);
4062 fprintf(stderr, "lib is %s.\n", lib);
4065 if (!LoadLibrary("javai.dll")) {
4066 if (lib && !LoadLibrary(lib))
4067 croak("Can't load javai.dll");
4071 fprintf(stderr, "Opening Java shared library.\n");
4074 if (!dlopen("libkaffevm.so", RTLD_LAZY|RTLD_GLOBAL)) {
4076 if (!dlopen("libjava.so", RTLD_LAZY|RTLD_GLOBAL)) {
4078 if (lib && !dlopen(lib, RTLD_LAZY|RTLD_GLOBAL))
4079 croak("Can't load Java shared library.");
4083 JNI_GetDefaultJavaVMInitArgs(&vm_args);
4084 vm_args.exit = &call_my_exit;
4086 fprintf(stderr, "items = %d\n", items);
4087 fprintf(stderr, "mark = %s\n", SvPV(*mark, PL_na));
4091 char *s = SvPV(*mark,PL_na);
4094 fprintf(stderr, "*s = %s\n", s);
4095 fprintf(stderr, "val = %s\n", SvPV(*mark, PL_na));
4098 if (strEQ(s, "checkSource"))
4099 vm_args.checkSource = (jint)SvIV(*mark);
4100 else if (strEQ(s, "nativeStackSize"))
4101 vm_args.nativeStackSize = (jint)SvIV(*mark);
4102 else if (strEQ(s, "javaStackSize"))
4103 vm_args.javaStackSize = (jint)SvIV(*mark);
4104 else if (strEQ(s, "minHeapSize"))
4105 vm_args.minHeapSize = (jint)SvIV(*mark);
4106 else if (strEQ(s, "maxHeapSize"))
4107 vm_args.maxHeapSize = (jint)SvIV(*mark);
4108 else if (strEQ(s, "verifyMode"))
4109 vm_args.verifyMode = (jint)SvIV(*mark);
4110 else if (strEQ(s, "classpath"))
4111 vm_args.classpath = savepv(SvPV(*mark,PL_na));
4112 else if (strEQ(s, "enableClassGC"))
4113 vm_args.enableClassGC = (jint)SvIV(*mark);
4114 else if (strEQ(s, "enableVerboseGC"))
4115 vm_args.enableVerboseGC = (jint)SvIV(*mark);
4116 else if (strEQ(s, "disableAsyncGC"))
4117 vm_args.disableAsyncGC = (jint)SvIV(*mark);
4119 else if (strEQ(s, "verbose"))
4120 vm_args.verbose = (jint)SvIV(*mark);
4121 else if (strEQ(s, "debugging"))
4122 vm_args.debugging = (jboolean)SvIV(*mark);
4123 else if (strEQ(s, "debugPort"))
4124 vm_args.debugPort = (jint)SvIV(*mark);
4127 croak("unrecognized option: %s", s);
4131 fprintf(stderr, "Creating Java VM...\n");
4132 fprintf(stderr, "Working CLASSPATH: %s\n",
4135 JNI_CreateJavaVM(&RETVAL, &jplcurenv, &vm_args);
4137 fprintf(stderr, "Created Java VM.\n");