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 || (PERL_VERSION == 4 && PERL_SUBVERSION <= 75))
23 # define PL_sv_no sv_no
24 # define PL_sv_undef sv_undef
25 # define PL_dowarn dowarn
29 # define newSVpvn(a,b) newSVpv(a,b)
37 # define dTHX extern int JNI___notused
45 extern JNIEnv* jplcurenv;
55 static void JNICALL call_my_exit(jint status)
60 static void call_my_exit(jint status)
67 makeargs(char *sig, SV** svp, int items)
69 jvalue* jv = (jvalue*)safemalloc(sizeof(jvalue) * items);
72 JNIEnv* env = jplcurenv;
77 fprintf(stderr, "sig = %s, items = %d\n", sig, items);
86 jv[ix++].z = (jboolean)(SvIV(sv) != 0);
89 jv[ix++].b = (jbyte)SvIV(sv);
92 jv[ix++].c = (jchar)SvIV(sv);
95 jv[ix++].s = (jshort)SvIV(sv);
98 jv[ix++].i = (jint)SvIV(sv);
101 jv[ix++].j = (jlong)SvNV(sv);
104 jv[ix++].f = (jfloat)SvNV(sv);
107 jv[ix++].d = (jdouble)SvNV(sv);
113 SV* rv = (SV*)SvRV(sv);
115 jv[ix++].l = (jobject)(void*)SvIV(rv);
116 else if (SvTYPE(rv) == SVt_PVAV) {
117 jsize len = av_len((AV*)rv) + 1;
118 jboolean* buf = (jboolean*)malloc(len * sizeof(jboolean));
122 jbooleanArray ja = (*env)->NewBooleanArray(env, len);
123 for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
124 buf[i] = (jboolean)SvIV(*esv);
125 (*env)->SetBooleanArrayRegion(env, ja, 0, len, buf);
127 jv[ix++].l = (jobject)ja;
130 jv[ix++].l = (jobject)(void*)0;
132 else if (SvPOK(sv)) {
133 jsize len = sv_len(sv) / sizeof(jboolean);
135 jbooleanArray ja = (*env)->NewBooleanArray(env, len);
136 (*env)->SetBooleanArrayRegion(env, ja, 0, len, (jboolean*)SvPV(sv,n_a));
137 jv[ix++].l = (jobject)ja;
140 jv[ix++].l = (jobject)(void*)0;
144 SV* rv = (SV*)SvRV(sv);
146 jv[ix++].l = (jobject)(void*)SvIV(rv);
147 else if (SvTYPE(rv) == SVt_PVAV) {
148 jsize len = av_len((AV*)rv) + 1;
149 jbyte* buf = (jbyte*)malloc(len * sizeof(jbyte));
153 jbyteArray ja = (*env)->NewByteArray(env, len);
154 for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
155 buf[i] = (jbyte)SvIV(*esv);
156 (*env)->SetByteArrayRegion(env, ja, 0, len, buf);
158 jv[ix++].l = (jobject)ja;
161 jv[ix++].l = (jobject)(void*)0;
163 else if (SvPOK(sv)) {
164 jsize len = sv_len(sv) / sizeof(jbyte);
166 jbyteArray ja = (*env)->NewByteArray(env, len);
167 (*env)->SetByteArrayRegion(env, ja, 0, len, (jbyte*)SvPV(sv,n_a));
168 jv[ix++].l = (jobject)ja;
171 jv[ix++].l = (jobject)(void*)0;
175 SV* rv = (SV*)SvRV(sv);
177 jv[ix++].l = (jobject)(void*)SvIV(rv);
178 else if (SvTYPE(rv) == SVt_PVAV) {
179 jsize len = av_len((AV*)rv) + 1;
180 jchar* buf = (jchar*)malloc(len * sizeof(jchar));
184 jcharArray ja = (*env)->NewCharArray(env, len);
185 for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
186 buf[i] = (jchar)SvIV(*esv);
187 (*env)->SetCharArrayRegion(env, ja, 0, len, buf);
189 jv[ix++].l = (jobject)ja;
192 jv[ix++].l = (jobject)(void*)0;
194 else if (SvPOK(sv)) {
195 jsize len = sv_len(sv) / sizeof(jchar);
197 jcharArray ja = (*env)->NewCharArray(env, len);
198 (*env)->SetCharArrayRegion(env, ja, 0, len, (jchar*)SvPV(sv,n_a));
199 jv[ix++].l = (jobject)ja;
202 jv[ix++].l = (jobject)(void*)0;
206 SV* rv = (SV*)SvRV(sv);
208 jv[ix++].l = (jobject)(void*)SvIV(rv);
209 else if (SvTYPE(rv) == SVt_PVAV) {
210 jsize len = av_len((AV*)rv) + 1;
211 jshort* buf = (jshort*)malloc(len * sizeof(jshort));
215 jshortArray ja = (*env)->NewShortArray(env, len);
216 for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
217 buf[i] = (jshort)SvIV(*esv);
218 (*env)->SetShortArrayRegion(env, ja, 0, len, buf);
220 jv[ix++].l = (jobject)ja;
223 jv[ix++].l = (jobject)(void*)0;
225 else if (SvPOK(sv)) {
226 jsize len = sv_len(sv) / sizeof(jshort);
228 jshortArray ja = (*env)->NewShortArray(env, len);
229 (*env)->SetShortArrayRegion(env, ja, 0, len, (jshort*)SvPV(sv,n_a));
230 jv[ix++].l = (jobject)ja;
233 jv[ix++].l = (jobject)(void*)0;
237 SV* rv = (SV*)SvRV(sv);
239 jv[ix++].l = (jobject)(void*)SvIV(rv);
240 else if (SvTYPE(rv) == SVt_PVAV) {
241 jsize len = av_len((AV*)rv) + 1;
242 jint* buf = (jint*)malloc(len * sizeof(jint));
246 jintArray ja = (*env)->NewIntArray(env, len);
247 for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
248 buf[i] = (jint)SvIV(*esv);
249 (*env)->SetIntArrayRegion(env, ja, 0, len, buf);
251 jv[ix++].l = (jobject)ja;
254 jv[ix++].l = (jobject)(void*)0;
256 else if (SvPOK(sv)) {
257 jsize len = sv_len(sv) / sizeof(jint);
259 jintArray ja = (*env)->NewIntArray(env, len);
260 (*env)->SetIntArrayRegion(env, ja, 0, len, (jint*)SvPV(sv,n_a));
261 jv[ix++].l = (jobject)ja;
264 jv[ix++].l = (jobject)(void*)0;
268 SV* rv = (SV*)SvRV(sv);
270 jv[ix++].l = (jobject)(void*)SvIV(rv);
271 else if (SvTYPE(rv) == SVt_PVAV) {
272 jsize len = av_len((AV*)rv) + 1;
273 jlong* buf = (jlong*)malloc(len * sizeof(jlong));
277 jlongArray ja = (*env)->NewLongArray(env, len);
278 for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
279 buf[i] = (jlong)SvNV(*esv);
280 (*env)->SetLongArrayRegion(env, ja, 0, len, buf);
282 jv[ix++].l = (jobject)ja;
285 jv[ix++].l = (jobject)(void*)0;
287 else if (SvPOK(sv)) {
288 jsize len = sv_len(sv) / sizeof(jlong);
290 jlongArray ja = (*env)->NewLongArray(env, len);
291 (*env)->SetLongArrayRegion(env, ja, 0, len, (jlong*)SvPV(sv,n_a));
292 jv[ix++].l = (jobject)ja;
295 jv[ix++].l = (jobject)(void*)0;
299 SV* rv = (SV*)SvRV(sv);
301 jv[ix++].l = (jobject)(void*)SvIV(rv);
302 else if (SvTYPE(rv) == SVt_PVAV) {
303 jsize len = av_len((AV*)rv) + 1;
304 jfloat* buf = (jfloat*)malloc(len * sizeof(jfloat));
308 jfloatArray ja = (*env)->NewFloatArray(env, len);
309 for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
310 buf[i] = (jfloat)SvNV(*esv);
311 (*env)->SetFloatArrayRegion(env, ja, 0, len, buf);
313 jv[ix++].l = (jobject)ja;
316 jv[ix++].l = (jobject)(void*)0;
318 else if (SvPOK(sv)) {
319 jsize len = sv_len(sv) / sizeof(jfloat);
321 jfloatArray ja = (*env)->NewFloatArray(env, len);
322 (*env)->SetFloatArrayRegion(env, ja, 0, len, (jfloat*)SvPV(sv,n_a));
323 jv[ix++].l = (jobject)ja;
326 jv[ix++].l = (jobject)(void*)0;
330 SV* rv = (SV*)SvRV(sv);
332 jv[ix++].l = (jobject)(void*)SvIV(rv);
333 else if (SvTYPE(rv) == SVt_PVAV) {
334 jsize len = av_len((AV*)rv) + 1;
335 jdouble* buf = (jdouble*)malloc(len * sizeof(jdouble));
339 jdoubleArray ja = (*env)->NewDoubleArray(env, len);
340 for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
341 buf[i] = (jdouble)SvNV(*esv);
342 (*env)->SetDoubleArrayRegion(env, ja, 0, len, buf);
344 jv[ix++].l = (jobject)ja;
347 jv[ix++].l = (jobject)(void*)0;
349 else if (SvPOK(sv)) {
350 jsize len = sv_len(sv) / sizeof(jdouble);
352 jdoubleArray ja = (*env)->NewDoubleArray(env, len);
353 (*env)->SetDoubleArrayRegion(env, ja, 0, len, (jdouble*)SvPV(sv,n_a));
354 jv[ix++].l = (jobject)ja;
357 jv[ix++].l = (jobject)(void*)0;
360 while (*s != ';') s++;
362 if (strnEQ(start, "[Ljava/lang/String;", 19)) {
364 SV* rv = (SV*)SvRV(sv);
366 jv[ix++].l = (jobject)(void*)SvIV(rv);
367 else if (SvTYPE(rv) == SVt_PVAV) {
368 jsize len = av_len((AV*)rv) + 1;
371 static jclass jcl = 0;
375 jcl = (*env)->FindClass(env, "java/lang/String");
376 ja = (*env)->NewObjectArray(env, len, jcl, 0);
377 for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++) {
378 jobject str = (jobject)(*env)->NewStringUTF(env, SvPV(*esv,n_a));
379 (*env)->SetObjectArrayElement(env, ja, i, str);
381 jv[ix++].l = (jobject)ja;
384 jv[ix++].l = (jobject)(void*)0;
387 jv[ix++].l = (jobject)(void*)0;
393 SV* rv = (SV*)SvRV(sv);
395 jv[ix++].l = (jobject)(void*)SvIV(rv);
396 else if (SvTYPE(rv) == SVt_PVAV) {
397 jsize len = av_len((AV*)rv) + 1;
400 static jclass jcl = 0;
404 jcl = (*env)->FindClass(env, "java/lang/Object");
405 ja = (*env)->NewObjectArray(env, len, jcl, 0);
406 for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++) {
407 if (SvROK(*esv) && (rv = SvRV(*esv)) && SvOBJECT(rv)) {
408 (*env)->SetObjectArrayElement(env, ja, i, (jobject)(void*)SvIV(rv));
411 jobject str = (jobject)(*env)->NewStringUTF(env, SvPV(*esv,n_a));
412 (*env)->SetObjectArrayElement(env, ja, i, str);
415 jv[ix++].l = (jobject)ja;
418 jv[ix++].l = (jobject)(void*)0;
421 jv[ix++].l = (jobject)(void*)0;
426 if (!SvROK(sv) || strnEQ(s, "java/lang/String;", 17)) {
428 jv[ix++].l = (jobject)(*env)->NewStringUTF(env, (char*) SvPV(sv,n_a));
431 while (*s != ';') s++;
435 jv[ix++].l = (jobject)(void*)SvIV(rv);
439 croak("too many arguments, signature: %s", sig);
442 croak("panic: malformed signature: %s", s-1);
448 croak("not enough arguments, signature: %s", sig);
461 croak("%s not implemented on this architecture", s);
466 constant(char *name, int arg)
489 if (strEQ(name, "JNI_ABORT"))
495 if (strEQ(name, "JNI_COMMIT"))
501 if (strEQ(name, "JNI_ERR"))
507 if (strEQ(name, "JNI_FALSE"))
513 if (strEQ(name, "JNI_H"))
523 if (strEQ(name, "JNI_OK"))
529 if (strEQ(name, "JNI_TRUE"))
577 #define FETCHENV jplcurenv
578 #define RESTOREENV jplcurenv = env
580 MODULE = JNI PACKAGE = JNI
591 JNIEnv * env = FETCHENV;
594 RETVAL = (*env)->GetVersion(env);
601 DefineClass(name, loader, buf)
602 JNIEnv * env = FETCHENV;
603 STRLEN tmplen = NO_INIT;
604 jsize buf_len_ = NO_INIT;
611 RETVAL = (*env)->DefineClass(env, loader, buf, (jsize)buf_len_);
613 RETVAL = (*env)->DefineClass(env, name, loader, buf, (jsize)buf_len_);
622 JNIEnv * env = FETCHENV;
626 RETVAL = (*env)->FindClass(env, name);
634 JNIEnv * env = FETCHENV;
638 RETVAL = (*env)->GetSuperclass(env, sub);
645 IsAssignableFrom(sub, sup)
646 JNIEnv * env = FETCHENV;
651 RETVAL = (*env)->IsAssignableFrom(env, sub, sup);
659 JNIEnv * env = FETCHENV;
663 RETVAL = (*env)->Throw(env, obj);
671 JNIEnv * env = FETCHENV;
676 RETVAL = (*env)->ThrowNew(env, clazz, msg);
684 JNIEnv * env = FETCHENV;
687 RETVAL = (*env)->ExceptionOccurred(env);
695 JNIEnv * env = FETCHENV;
698 (*env)->ExceptionDescribe(env);
704 JNIEnv * env = FETCHENV;
707 (*env)->ExceptionClear(env);
713 JNIEnv * env = FETCHENV;
717 (*env)->FatalError(env, msg);
723 JNIEnv * env = FETCHENV;
727 RETVAL = (*env)->NewGlobalRef(env, lobj);
734 DeleteGlobalRef(gref)
735 JNIEnv * env = FETCHENV;
739 (*env)->DeleteGlobalRef(env, gref);
745 JNIEnv * env = FETCHENV;
749 (*env)->DeleteLocalRef(env, obj);
754 IsSameObject(obj1,obj2)
755 JNIEnv * env = FETCHENV;
760 RETVAL = (*env)->IsSameObject(env, obj1,obj2);
768 JNIEnv * env = FETCHENV;
772 RETVAL = (*env)->AllocObject(env, clazz);
779 NewObject(clazz,methodID,...)
780 JNIEnv * env = FETCHENV;
784 int argoff = $min_args;
787 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
788 RETVAL = (*env)->NewObjectA(env, clazz,methodID,args);
795 NewObjectA(clazz,methodID,args)
796 JNIEnv * env = FETCHENV;
803 RETVAL = (*env)->NewObjectA(env, clazz,methodID,args);
811 JNIEnv * env = FETCHENV;
815 RETVAL = (*env)->GetObjectClass(env, obj);
822 IsInstanceOf(obj,clazz)
823 JNIEnv * env = FETCHENV;
828 RETVAL = (*env)->IsInstanceOf(env, obj,clazz);
835 GetMethodID(clazz,name,sig)
836 JNIEnv * env = FETCHENV;
842 RETVAL = (*env)->GetMethodID(env, clazz,name,sig);
849 CallObjectMethod(obj,methodID,...)
850 JNIEnv * env = FETCHENV;
854 int argoff = $min_args;
857 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
858 RETVAL = (*env)->CallObjectMethodA(env, obj,methodID,args);
865 CallObjectMethodA(obj,methodID,args)
866 JNIEnv * env = FETCHENV;
873 RETVAL = (*env)->CallObjectMethodA(env, obj,methodID,args);
880 CallBooleanMethod(obj,methodID,...)
881 JNIEnv * env = FETCHENV;
885 int argoff = $min_args;
888 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
889 RETVAL = (*env)->CallBooleanMethodA(env, obj,methodID,args);
896 CallBooleanMethodA(obj,methodID, args)
897 JNIEnv * env = FETCHENV;
904 RETVAL = (*env)->CallBooleanMethodA(env, obj,methodID, args);
911 CallByteMethod(obj,methodID,...)
912 JNIEnv * env = FETCHENV;
916 int argoff = $min_args;
919 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
920 RETVAL = (*env)->CallByteMethodA(env, obj,methodID,args);
927 CallByteMethodA(obj,methodID,args)
928 JNIEnv * env = FETCHENV;
935 RETVAL = (*env)->CallByteMethodA(env, obj,methodID,args);
942 CallCharMethod(obj,methodID,...)
943 JNIEnv * env = FETCHENV;
947 int argoff = $min_args;
950 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
951 RETVAL = (*env)->CallCharMethodA(env, obj,methodID,args);
958 CallCharMethodA(obj,methodID,args)
959 JNIEnv * env = FETCHENV;
966 RETVAL = (*env)->CallCharMethodA(env, obj,methodID,args);
973 CallShortMethod(obj,methodID,...)
974 JNIEnv * env = FETCHENV;
978 int argoff = $min_args;
981 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
982 RETVAL = (*env)->CallShortMethodA(env, obj,methodID,args);
989 CallShortMethodA(obj,methodID,args)
990 JNIEnv * env = FETCHENV;
997 RETVAL = (*env)->CallShortMethodA(env, obj,methodID,args);
1004 CallIntMethod(obj,methodID,...)
1005 JNIEnv * env = FETCHENV;
1009 int argoff = $min_args;
1012 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1013 RETVAL = (*env)->CallIntMethodA(env, obj,methodID,args);
1020 CallIntMethodA(obj,methodID,args)
1021 JNIEnv * env = FETCHENV;
1028 RETVAL = (*env)->CallIntMethodA(env, obj,methodID,args);
1035 CallLongMethod(obj,methodID,...)
1036 JNIEnv * env = FETCHENV;
1040 int argoff = $min_args;
1043 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1044 RETVAL = (*env)->CallLongMethodA(env, obj,methodID,args);
1051 CallLongMethodA(obj,methodID,args)
1052 JNIEnv * env = FETCHENV;
1059 RETVAL = (*env)->CallLongMethodA(env, obj,methodID,args);
1066 CallFloatMethod(obj,methodID,...)
1067 JNIEnv * env = FETCHENV;
1071 int argoff = $min_args;
1074 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1075 RETVAL = (*env)->CallFloatMethodA(env, obj,methodID,args);
1082 CallFloatMethodA(obj,methodID,args)
1083 JNIEnv * env = FETCHENV;
1090 RETVAL = (*env)->CallFloatMethodA(env, obj,methodID,args);
1097 CallDoubleMethod(obj,methodID,...)
1098 JNIEnv * env = FETCHENV;
1102 int argoff = $min_args;
1105 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1106 RETVAL = (*env)->CallDoubleMethodA(env, obj,methodID,args);
1113 CallDoubleMethodA(obj,methodID,args)
1114 JNIEnv * env = FETCHENV;
1121 RETVAL = (*env)->CallDoubleMethodA(env, obj,methodID,args);
1128 CallVoidMethod(obj,methodID,...)
1129 JNIEnv * env = FETCHENV;
1133 int argoff = $min_args;
1136 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1137 (*env)->CallVoidMethodA(env, obj,methodID,args);
1142 CallVoidMethodA(obj,methodID,args)
1143 JNIEnv * env = FETCHENV;
1150 (*env)->CallVoidMethodA(env, obj,methodID,args);
1155 CallNonvirtualObjectMethod(obj,clazz,methodID,...)
1156 JNIEnv * env = FETCHENV;
1161 int argoff = $min_args;
1164 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1165 RETVAL = (*env)->CallNonvirtualObjectMethodA(env, obj,clazz,methodID,args);
1172 CallNonvirtualObjectMethodA(obj,clazz,methodID,args)
1173 JNIEnv * env = FETCHENV;
1181 RETVAL = (*env)->CallNonvirtualObjectMethodA(env, obj,clazz,methodID,args);
1188 CallNonvirtualBooleanMethod(obj,clazz,methodID,...)
1189 JNIEnv * env = FETCHENV;
1194 int argoff = $min_args;
1197 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1198 RETVAL = (*env)->CallNonvirtualBooleanMethodA(env, obj,clazz,methodID,args);
1205 CallNonvirtualBooleanMethodA(obj,clazz,methodID, args)
1206 JNIEnv * env = FETCHENV;
1214 RETVAL = (*env)->CallNonvirtualBooleanMethodA(env, obj,clazz,methodID, args);
1221 CallNonvirtualByteMethod(obj,clazz,methodID,...)
1222 JNIEnv * env = FETCHENV;
1227 int argoff = $min_args;
1230 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1231 RETVAL = (*env)->CallNonvirtualByteMethodA(env, obj,clazz,methodID,args);
1238 CallNonvirtualByteMethodA(obj,clazz,methodID,args)
1239 JNIEnv * env = FETCHENV;
1247 RETVAL = (*env)->CallNonvirtualByteMethodA(env, obj,clazz,methodID,args);
1254 CallNonvirtualCharMethod(obj,clazz,methodID,...)
1255 JNIEnv * env = FETCHENV;
1260 int argoff = $min_args;
1263 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1264 RETVAL = (*env)->CallNonvirtualCharMethodA(env, obj,clazz,methodID,args);
1271 CallNonvirtualCharMethodA(obj,clazz,methodID,args)
1272 JNIEnv * env = FETCHENV;
1280 RETVAL = (*env)->CallNonvirtualCharMethodA(env, obj,clazz,methodID,args);
1287 CallNonvirtualShortMethod(obj,clazz,methodID,...)
1288 JNIEnv * env = FETCHENV;
1293 int argoff = $min_args;
1296 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1297 RETVAL = (*env)->CallNonvirtualShortMethodA(env, obj,clazz,methodID,args);
1304 CallNonvirtualShortMethodA(obj,clazz,methodID,args)
1305 JNIEnv * env = FETCHENV;
1313 RETVAL = (*env)->CallNonvirtualShortMethodA(env, obj,clazz,methodID,args);
1320 CallNonvirtualIntMethod(obj,clazz,methodID,...)
1321 JNIEnv * env = FETCHENV;
1326 int argoff = $min_args;
1329 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1330 RETVAL = (*env)->CallNonvirtualIntMethodA(env, obj,clazz,methodID,args);
1337 CallNonvirtualIntMethodA(obj,clazz,methodID,args)
1338 JNIEnv * env = FETCHENV;
1346 RETVAL = (*env)->CallNonvirtualIntMethodA(env, obj,clazz,methodID,args);
1353 CallNonvirtualLongMethod(obj,clazz,methodID,...)
1354 JNIEnv * env = FETCHENV;
1359 int argoff = $min_args;
1362 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1363 RETVAL = (*env)->CallNonvirtualLongMethodA(env, obj,clazz,methodID,args);
1370 CallNonvirtualLongMethodA(obj,clazz,methodID,args)
1371 JNIEnv * env = FETCHENV;
1379 RETVAL = (*env)->CallNonvirtualLongMethodA(env, obj,clazz,methodID,args);
1386 CallNonvirtualFloatMethod(obj,clazz,methodID,...)
1387 JNIEnv * env = FETCHENV;
1392 int argoff = $min_args;
1395 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1396 RETVAL = (*env)->CallNonvirtualFloatMethodA(env, obj,clazz,methodID,args);
1403 CallNonvirtualFloatMethodA(obj,clazz,methodID,args)
1404 JNIEnv * env = FETCHENV;
1412 RETVAL = (*env)->CallNonvirtualFloatMethodA(env, obj,clazz,methodID,args);
1419 CallNonvirtualDoubleMethod(obj,clazz,methodID,...)
1420 JNIEnv * env = FETCHENV;
1425 int argoff = $min_args;
1428 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1429 RETVAL = (*env)->CallNonvirtualDoubleMethodA(env, obj,clazz,methodID,args);
1436 CallNonvirtualDoubleMethodA(obj,clazz,methodID,args)
1437 JNIEnv * env = FETCHENV;
1445 RETVAL = (*env)->CallNonvirtualDoubleMethodA(env, obj,clazz,methodID,args);
1452 CallNonvirtualVoidMethod(obj,clazz,methodID,...)
1453 JNIEnv * env = FETCHENV;
1458 int argoff = $min_args;
1461 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1462 (*env)->CallNonvirtualVoidMethodA(env, obj,clazz,methodID,args);
1467 CallNonvirtualVoidMethodA(obj,clazz,methodID,args)
1468 JNIEnv * env = FETCHENV;
1476 (*env)->CallNonvirtualVoidMethodA(env, obj,clazz,methodID,args);
1481 GetFieldID(clazz,name,sig)
1482 JNIEnv * env = FETCHENV;
1488 RETVAL = (*env)->GetFieldID(env, clazz,name,sig);
1495 GetObjectField(obj,fieldID)
1496 JNIEnv * env = FETCHENV;
1502 RETVAL = (*env)->GetObjectField(env, obj,fieldID);
1509 GetBooleanField(obj,fieldID)
1510 JNIEnv * env = FETCHENV;
1516 RETVAL = (*env)->GetBooleanField(env, obj,fieldID);
1523 GetByteField(obj,fieldID)
1524 JNIEnv * env = FETCHENV;
1530 RETVAL = (*env)->GetByteField(env, obj,fieldID);
1537 GetCharField(obj,fieldID)
1538 JNIEnv * env = FETCHENV;
1544 RETVAL = (*env)->GetCharField(env, obj,fieldID);
1551 GetShortField(obj,fieldID)
1552 JNIEnv * env = FETCHENV;
1558 RETVAL = (*env)->GetShortField(env, obj,fieldID);
1565 GetIntField(obj,fieldID)
1566 JNIEnv * env = FETCHENV;
1572 RETVAL = (*env)->GetIntField(env, obj,fieldID);
1579 GetLongField(obj,fieldID)
1580 JNIEnv * env = FETCHENV;
1586 RETVAL = (*env)->GetLongField(env, obj,fieldID);
1593 GetFloatField(obj,fieldID)
1594 JNIEnv * env = FETCHENV;
1600 RETVAL = (*env)->GetFloatField(env, obj,fieldID);
1607 GetDoubleField(obj,fieldID)
1608 JNIEnv * env = FETCHENV;
1614 RETVAL = (*env)->GetDoubleField(env, obj,fieldID);
1621 SetObjectField(obj,fieldID,val)
1622 JNIEnv * env = FETCHENV;
1629 (*env)->SetObjectField(env, obj,fieldID,val);
1634 SetBooleanField(obj,fieldID,val)
1635 JNIEnv * env = FETCHENV;
1642 (*env)->SetBooleanField(env, obj,fieldID,val);
1647 SetByteField(obj,fieldID,val)
1648 JNIEnv * env = FETCHENV;
1655 (*env)->SetByteField(env, obj,fieldID,val);
1660 SetCharField(obj,fieldID,val)
1661 JNIEnv * env = FETCHENV;
1668 (*env)->SetCharField(env, obj,fieldID,val);
1673 SetShortField(obj,fieldID,val)
1674 JNIEnv * env = FETCHENV;
1681 (*env)->SetShortField(env, obj,fieldID,val);
1686 SetIntField(obj,fieldID,val)
1687 JNIEnv * env = FETCHENV;
1694 (*env)->SetIntField(env, obj,fieldID,val);
1699 SetLongField(obj,fieldID,val)
1700 JNIEnv * env = FETCHENV;
1707 (*env)->SetLongField(env, obj,fieldID,val);
1712 SetFloatField(obj,fieldID,val)
1713 JNIEnv * env = FETCHENV;
1720 (*env)->SetFloatField(env, obj,fieldID,val);
1725 SetDoubleField(obj,fieldID,val)
1726 JNIEnv * env = FETCHENV;
1733 (*env)->SetDoubleField(env, obj,fieldID,val);
1738 GetStaticMethodID(clazz,name,sig)
1739 JNIEnv * env = FETCHENV;
1745 RETVAL = (*env)->GetStaticMethodID(env, clazz,name,sig);
1752 CallStaticObjectMethod(clazz,methodID,...)
1753 JNIEnv * env = FETCHENV;
1757 int argoff = $min_args;
1760 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1761 RETVAL = (*env)->CallStaticObjectMethodA(env, clazz,methodID,args);
1768 CallStaticObjectMethodA(clazz,methodID,args)
1769 JNIEnv * env = FETCHENV;
1776 RETVAL = (*env)->CallStaticObjectMethodA(env, clazz,methodID,args);
1783 CallStaticBooleanMethod(clazz,methodID,...)
1784 JNIEnv * env = FETCHENV;
1788 int argoff = $min_args;
1791 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1792 RETVAL = (*env)->CallStaticBooleanMethodA(env, clazz,methodID,args);
1799 CallStaticBooleanMethodA(clazz,methodID,args)
1800 JNIEnv * env = FETCHENV;
1807 RETVAL = (*env)->CallStaticBooleanMethodA(env, clazz,methodID,args);
1814 CallStaticByteMethod(clazz,methodID,...)
1815 JNIEnv * env = FETCHENV;
1819 int argoff = $min_args;
1822 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1823 RETVAL = (*env)->CallStaticByteMethodA(env, clazz,methodID,args);
1830 CallStaticByteMethodA(clazz,methodID,args)
1831 JNIEnv * env = FETCHENV;
1838 RETVAL = (*env)->CallStaticByteMethodA(env, clazz,methodID,args);
1845 CallStaticCharMethod(clazz,methodID,...)
1846 JNIEnv * env = FETCHENV;
1850 int argoff = $min_args;
1853 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1854 RETVAL = (*env)->CallStaticCharMethodA(env, clazz,methodID,args);
1861 CallStaticCharMethodA(clazz,methodID,args)
1862 JNIEnv * env = FETCHENV;
1869 RETVAL = (*env)->CallStaticCharMethodA(env, clazz,methodID,args);
1876 CallStaticShortMethod(clazz,methodID,...)
1877 JNIEnv * env = FETCHENV;
1881 int argoff = $min_args;
1884 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1885 RETVAL = (*env)->CallStaticShortMethodA(env, clazz,methodID,args);
1892 CallStaticShortMethodA(clazz,methodID,args)
1893 JNIEnv * env = FETCHENV;
1900 RETVAL = (*env)->CallStaticShortMethodA(env, clazz,methodID,args);
1907 CallStaticIntMethod(clazz,methodID,...)
1908 JNIEnv * env = FETCHENV;
1912 int argoff = $min_args;
1915 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1916 RETVAL = (*env)->CallStaticIntMethodA(env, clazz,methodID,args);
1923 CallStaticIntMethodA(clazz,methodID,args)
1924 JNIEnv * env = FETCHENV;
1931 RETVAL = (*env)->CallStaticIntMethodA(env, clazz,methodID,args);
1938 CallStaticLongMethod(clazz,methodID,...)
1939 JNIEnv * env = FETCHENV;
1943 int argoff = $min_args;
1946 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1947 RETVAL = (*env)->CallStaticLongMethodA(env, clazz,methodID,args);
1954 CallStaticLongMethodA(clazz,methodID,args)
1955 JNIEnv * env = FETCHENV;
1962 RETVAL = (*env)->CallStaticLongMethodA(env, clazz,methodID,args);
1969 CallStaticFloatMethod(clazz,methodID,...)
1970 JNIEnv * env = FETCHENV;
1974 int argoff = $min_args;
1977 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1978 RETVAL = (*env)->CallStaticFloatMethodA(env, clazz,methodID,args);
1985 CallStaticFloatMethodA(clazz,methodID,args)
1986 JNIEnv * env = FETCHENV;
1993 RETVAL = (*env)->CallStaticFloatMethodA(env, clazz,methodID,args);
2000 CallStaticDoubleMethod(clazz,methodID,...)
2001 JNIEnv * env = FETCHENV;
2005 int argoff = $min_args;
2008 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
2009 RETVAL = (*env)->CallStaticDoubleMethodA(env, clazz,methodID,args);
2016 CallStaticDoubleMethodA(clazz,methodID,args)
2017 JNIEnv * env = FETCHENV;
2024 RETVAL = (*env)->CallStaticDoubleMethodA(env, clazz,methodID,args);
2031 CallStaticVoidMethod(cls,methodID,...)
2032 JNIEnv * env = FETCHENV;
2036 int argoff = $min_args;
2039 jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
2040 (*env)->CallStaticVoidMethodA(env, cls,methodID,args);
2045 CallStaticVoidMethodA(cls,methodID,args)
2046 JNIEnv * env = FETCHENV;
2053 (*env)->CallStaticVoidMethodA(env, cls,methodID,args);
2058 GetStaticFieldID(clazz,name,sig)
2059 JNIEnv * env = FETCHENV;
2065 RETVAL = (*env)->GetStaticFieldID(env, clazz,name,sig);
2072 GetStaticObjectField(clazz,fieldID)
2073 JNIEnv * env = FETCHENV;
2079 RETVAL = (*env)->GetStaticObjectField(env, clazz,fieldID);
2086 GetStaticBooleanField(clazz,fieldID)
2087 JNIEnv * env = FETCHENV;
2093 RETVAL = (*env)->GetStaticBooleanField(env, clazz,fieldID);
2100 GetStaticByteField(clazz,fieldID)
2101 JNIEnv * env = FETCHENV;
2107 RETVAL = (*env)->GetStaticByteField(env, clazz,fieldID);
2114 GetStaticCharField(clazz,fieldID)
2115 JNIEnv * env = FETCHENV;
2121 RETVAL = (*env)->GetStaticCharField(env, clazz,fieldID);
2128 GetStaticShortField(clazz,fieldID)
2129 JNIEnv * env = FETCHENV;
2135 RETVAL = (*env)->GetStaticShortField(env, clazz,fieldID);
2142 GetStaticIntField(clazz,fieldID)
2143 JNIEnv * env = FETCHENV;
2149 RETVAL = (*env)->GetStaticIntField(env, clazz,fieldID);
2156 GetStaticLongField(clazz,fieldID)
2157 JNIEnv * env = FETCHENV;
2163 RETVAL = (*env)->GetStaticLongField(env, clazz,fieldID);
2170 GetStaticFloatField(clazz,fieldID)
2171 JNIEnv * env = FETCHENV;
2177 RETVAL = (*env)->GetStaticFloatField(env, clazz,fieldID);
2184 GetStaticDoubleField(clazz,fieldID)
2185 JNIEnv * env = FETCHENV;
2191 RETVAL = (*env)->GetStaticDoubleField(env, clazz,fieldID);
2198 SetStaticObjectField(clazz,fieldID,value)
2199 JNIEnv * env = FETCHENV;
2206 (*env)->SetStaticObjectField(env, clazz,fieldID,value);
2211 SetStaticBooleanField(clazz,fieldID,value)
2212 JNIEnv * env = FETCHENV;
2219 (*env)->SetStaticBooleanField(env, clazz,fieldID,value);
2224 SetStaticByteField(clazz,fieldID,value)
2225 JNIEnv * env = FETCHENV;
2232 (*env)->SetStaticByteField(env, clazz,fieldID,value);
2237 SetStaticCharField(clazz,fieldID,value)
2238 JNIEnv * env = FETCHENV;
2245 (*env)->SetStaticCharField(env, clazz,fieldID,value);
2250 SetStaticShortField(clazz,fieldID,value)
2251 JNIEnv * env = FETCHENV;
2258 (*env)->SetStaticShortField(env, clazz,fieldID,value);
2263 SetStaticIntField(clazz,fieldID,value)
2264 JNIEnv * env = FETCHENV;
2271 (*env)->SetStaticIntField(env, clazz,fieldID,value);
2276 SetStaticLongField(clazz,fieldID,value)
2277 JNIEnv * env = FETCHENV;
2284 (*env)->SetStaticLongField(env, clazz,fieldID,value);
2289 SetStaticFloatField(clazz,fieldID,value)
2290 JNIEnv * env = FETCHENV;
2297 (*env)->SetStaticFloatField(env, clazz,fieldID,value);
2302 SetStaticDoubleField(clazz,fieldID,value)
2303 JNIEnv * env = FETCHENV;
2310 (*env)->SetStaticDoubleField(env, clazz,fieldID,value);
2316 JNIEnv * env = FETCHENV;
2317 STRLEN tmplen = NO_INIT;
2318 jsize unicode_len_ = NO_INIT;
2319 const jchar * unicode
2322 RETVAL = (*env)->NewString(env, unicode, unicode_len_);
2329 GetStringLength(str)
2330 JNIEnv * env = FETCHENV;
2334 RETVAL = (*env)->GetStringLength(env, str);
2342 JNIEnv * env = FETCHENV;
2344 jboolean isCopy = NO_INIT;
2345 jsize RETVAL_len_ = NO_INIT;
2348 RETVAL = (*env)->GetStringChars(env, str,&isCopy);
2349 RETVAL_len_ = (*env)->GetStringLength(env, str);
2355 (*env)->ReleaseStringChars(env, str,RETVAL);
2359 JNIEnv * env = FETCHENV;
2363 RETVAL = (*env)->NewStringUTF(env, utf);
2370 GetStringUTFLength(str)
2371 JNIEnv * env = FETCHENV;
2375 RETVAL = (*env)->GetStringUTFLength(env, str);
2382 GetStringUTFChars(str)
2383 JNIEnv * env = FETCHENV;
2385 jboolean isCopy = NO_INIT;
2388 RETVAL = (*env)->GetStringUTFChars(env, str,&isCopy);
2394 (*env)->ReleaseStringUTFChars(env, str, RETVAL);
2398 GetArrayLength(array)
2399 JNIEnv * env = FETCHENV;
2403 RETVAL = (*env)->GetArrayLength(env, array);
2410 NewObjectArray(len,clazz,init)
2411 JNIEnv * env = FETCHENV;
2417 RETVAL = (*env)->NewObjectArray(env, len,clazz,init);
2424 GetObjectArrayElement(array,index)
2425 JNIEnv * env = FETCHENV;
2430 RETVAL = (*env)->GetObjectArrayElement(env, array,index);
2437 SetObjectArrayElement(array,index,val)
2438 JNIEnv * env = FETCHENV;
2444 (*env)->SetObjectArrayElement(env, array,index,val);
2449 NewBooleanArray(len)
2450 JNIEnv * env = FETCHENV;
2454 RETVAL = (*env)->NewBooleanArray(env, len);
2462 JNIEnv * env = FETCHENV;
2466 RETVAL = (*env)->NewByteArray(env, len);
2474 JNIEnv * env = FETCHENV;
2478 RETVAL = (*env)->NewCharArray(env, len);
2486 JNIEnv * env = FETCHENV;
2490 RETVAL = (*env)->NewShortArray(env, len);
2498 JNIEnv * env = FETCHENV;
2502 RETVAL = (*env)->NewIntArray(env, len);
2510 JNIEnv * env = FETCHENV;
2514 RETVAL = (*env)->NewLongArray(env, len);
2522 JNIEnv * env = FETCHENV;
2526 RETVAL = (*env)->NewFloatArray(env, len);
2534 JNIEnv * env = FETCHENV;
2538 RETVAL = (*env)->NewDoubleArray(env, len);
2545 GetBooleanArrayElements(array)
2546 JNIEnv * env = FETCHENV;
2547 jsize RETVAL_len_ = NO_INIT;
2549 jboolean isCopy = NO_INIT;
2552 RETVAL = (*env)->GetBooleanArrayElements(env, array,&isCopy);
2553 RETVAL_len_ = (*env)->GetArrayLength(env, array);
2554 if (GIMME == G_ARRAY) {
2556 jboolean* r = RETVAL;
2557 EXTEND(sp, RETVAL_len_);
2558 for (i = RETVAL_len_; i; --i) {
2559 PUSHs(sv_2mortal(newSViv(*r++)));
2564 PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
2565 (STRLEN)RETVAL_len_ * sizeof(jboolean))));
2570 (*env)->ReleaseBooleanArrayElements(env, array,RETVAL,JNI_ABORT);
2575 GetByteArrayElements(array)
2576 JNIEnv * env = FETCHENV;
2577 jsize RETVAL_len_ = NO_INIT;
2579 jboolean isCopy = NO_INIT;
2582 RETVAL = (*env)->GetByteArrayElements(env, array,&isCopy);
2583 RETVAL_len_ = (*env)->GetArrayLength(env, array);
2584 if (GIMME == G_ARRAY) {
2587 EXTEND(sp, RETVAL_len_);
2588 for (i = RETVAL_len_; i; --i) {
2589 PUSHs(sv_2mortal(newSViv(*r++)));
2594 PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
2595 (STRLEN)RETVAL_len_ * sizeof(jbyte))));
2600 (*env)->ReleaseByteArrayElements(env, array,RETVAL,JNI_ABORT);
2605 GetCharArrayElements(array)
2606 JNIEnv * env = FETCHENV;
2607 jsize RETVAL_len_ = NO_INIT;
2609 jboolean isCopy = NO_INIT;
2612 RETVAL = (*env)->GetCharArrayElements(env, array,&isCopy);
2613 RETVAL_len_ = (*env)->GetArrayLength(env, array);
2614 if (GIMME == G_ARRAY) {
2617 EXTEND(sp, RETVAL_len_);
2618 for (i = RETVAL_len_; i; --i) {
2619 PUSHs(sv_2mortal(newSViv(*r++)));
2624 PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
2625 (STRLEN)RETVAL_len_ * sizeof(jchar))));
2630 (*env)->ReleaseCharArrayElements(env, array,RETVAL,JNI_ABORT);
2635 GetShortArrayElements(array)
2636 JNIEnv * env = FETCHENV;
2637 jsize RETVAL_len_ = NO_INIT;
2639 jboolean isCopy = NO_INIT;
2642 RETVAL = (*env)->GetShortArrayElements(env, array,&isCopy);
2643 RETVAL_len_ = (*env)->GetArrayLength(env, array);
2644 if (GIMME == G_ARRAY) {
2647 EXTEND(sp, RETVAL_len_);
2648 for (i = RETVAL_len_; i; --i) {
2649 PUSHs(sv_2mortal(newSViv(*r++)));
2654 PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
2655 (STRLEN)RETVAL_len_ * sizeof(jshort))));
2660 (*env)->ReleaseShortArrayElements(env, array,RETVAL,JNI_ABORT);
2665 GetIntArrayElements(array)
2666 JNIEnv * env = FETCHENV;
2667 jsize RETVAL_len_ = NO_INIT;
2669 jboolean isCopy = NO_INIT;
2672 RETVAL = (*env)->GetIntArrayElements(env, array,&isCopy);
2673 RETVAL_len_ = (*env)->GetArrayLength(env, array);
2674 if (GIMME == G_ARRAY) {
2677 EXTEND(sp, RETVAL_len_);
2678 for (i = RETVAL_len_; i; --i) {
2679 PUSHs(sv_2mortal(newSViv(*r++)));
2684 PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
2685 (STRLEN)RETVAL_len_ * sizeof(jint))));
2690 (*env)->ReleaseIntArrayElements(env, array,RETVAL,JNI_ABORT);
2695 GetLongArrayElements(array)
2696 JNIEnv * env = FETCHENV;
2697 jsize RETVAL_len_ = NO_INIT;
2699 jboolean isCopy = NO_INIT;
2702 RETVAL = (*env)->GetLongArrayElements(env, array,&isCopy);
2703 RETVAL_len_ = (*env)->GetArrayLength(env, array);
2704 if (GIMME == G_ARRAY) {
2707 EXTEND(sp, RETVAL_len_);
2708 for (i = RETVAL_len_; i; --i) {
2709 PUSHs(sv_2mortal(newSViv(*r++)));
2714 PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
2715 (STRLEN)RETVAL_len_ * sizeof(jlong))));
2720 (*env)->ReleaseLongArrayElements(env, array,RETVAL,JNI_ABORT);
2725 GetFloatArrayElements(array)
2726 JNIEnv * env = FETCHENV;
2727 jsize RETVAL_len_ = NO_INIT;
2729 jboolean isCopy = NO_INIT;
2732 RETVAL = (*env)->GetFloatArrayElements(env, array,&isCopy);
2733 RETVAL_len_ = (*env)->GetArrayLength(env, array);
2734 if (GIMME == G_ARRAY) {
2737 EXTEND(sp, RETVAL_len_);
2738 for (i = RETVAL_len_; i; --i) {
2739 PUSHs(sv_2mortal(newSVnv(*r++)));
2744 PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
2745 (STRLEN)RETVAL_len_ * sizeof(jfloat))));
2750 (*env)->ReleaseFloatArrayElements(env, array,RETVAL,JNI_ABORT);
2755 GetDoubleArrayElements(array)
2756 JNIEnv * env = FETCHENV;
2757 jsize RETVAL_len_ = NO_INIT;
2759 jboolean isCopy = NO_INIT;
2762 RETVAL = (*env)->GetDoubleArrayElements(env, array,&isCopy);
2763 RETVAL_len_ = (*env)->GetArrayLength(env, array);
2764 if (GIMME == G_ARRAY) {
2766 jdouble* r = RETVAL;
2767 EXTEND(sp, RETVAL_len_);
2768 for (i = RETVAL_len_; i; --i) {
2769 PUSHs(sv_2mortal(newSVnv(*r++)));
2774 PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
2775 (STRLEN)RETVAL_len_ * sizeof(jdouble))));
2780 (*env)->ReleaseDoubleArrayElements(env, array,RETVAL,JNI_ABORT);
2785 GetBooleanArrayRegion(array,start,len,buf)
2786 JNIEnv * env = FETCHENV;
2790 STRLEN tmplen = len * sizeof(jboolean) + 1;
2791 char * tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
2792 jboolean * buf = (jboolean*)sv_grow(ST(3),len * sizeof(jboolean)+1);
2795 (*env)->GetBooleanArrayRegion(env, array,start,len,buf);
2796 SvCUR_set(ST(3), len * sizeof(jboolean));
2797 *SvEND(ST(3)) = '\0';
2802 GetByteArrayRegion(array,start,len,buf)
2803 JNIEnv * env = FETCHENV;
2807 STRLEN tmplen = len * sizeof(jboolean) + 1;
2808 char * tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
2809 jbyte * buf = (jbyte*)sv_grow(ST(3),len * sizeof(jbyte)+1);
2812 (*env)->GetByteArrayRegion(env, array,start,len,buf);
2813 SvCUR_set(ST(3), len * sizeof(jbyte));
2814 *SvEND(ST(3)) = '\0';
2819 GetCharArrayRegion(array,start,len,buf)
2820 JNIEnv * env = FETCHENV;
2824 STRLEN tmplen = len * sizeof(jboolean) + 1;
2825 char * tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
2826 jchar * buf = (jchar*)sv_grow(ST(3),len * sizeof(jchar)+1);
2829 (*env)->GetCharArrayRegion(env, array,start,len,buf);
2830 SvCUR_set(ST(3), len * sizeof(jchar));
2831 *SvEND(ST(3)) = '\0';
2836 GetShortArrayRegion(array,start,len,buf)
2837 JNIEnv * env = FETCHENV;
2841 STRLEN tmplen = len * sizeof(jboolean) + 1;
2842 char * tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
2843 jshort * buf = (jshort*)sv_grow(ST(3),len * sizeof(jshort)+1);
2846 (*env)->GetShortArrayRegion(env, array,start,len,buf);
2847 SvCUR_set(ST(3), len * sizeof(jshort));
2848 *SvEND(ST(3)) = '\0';
2853 GetIntArrayRegion(array,start,len,buf)
2854 JNIEnv * env = FETCHENV;
2858 STRLEN tmplen = len * sizeof(jboolean) + 1;
2859 char * tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
2860 jint * buf = (jint*)sv_grow(ST(3),len * sizeof(jint)+1);
2863 (*env)->GetIntArrayRegion(env, array,start,len,buf);
2864 SvCUR_set(ST(3), len * sizeof(jint));
2865 *SvEND(ST(3)) = '\0';
2870 GetLongArrayRegion(array,start,len,buf)
2871 JNIEnv * env = FETCHENV;
2875 STRLEN tmplen = len * sizeof(jboolean) + 1;
2876 char * tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
2877 jlong * buf = (jlong*)sv_grow(ST(3),len * sizeof(jlong)+1);
2880 (*env)->GetLongArrayRegion(env, array,start,len,buf);
2881 SvCUR_set(ST(3), len * sizeof(jlong));
2882 *SvEND(ST(3)) = '\0';
2887 GetFloatArrayRegion(array,start,len,buf)
2888 JNIEnv * env = FETCHENV;
2892 STRLEN tmplen = len * sizeof(jboolean) + 1;
2893 char * tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
2894 jfloat * buf = (jfloat*)sv_grow(ST(3),len * sizeof(jfloat)+1);
2897 (*env)->GetFloatArrayRegion(env, array,start,len,buf);
2898 SvCUR_set(ST(3), len * sizeof(jfloat));
2899 *SvEND(ST(3)) = '\0';
2904 GetDoubleArrayRegion(array,start,len,buf)
2905 JNIEnv * env = FETCHENV;
2909 STRLEN tmplen = len * sizeof(jboolean) + 1;
2910 char * tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
2911 jdouble * buf = (jdouble*)sv_grow(ST(3),len * sizeof(jdouble)+1);
2914 (*env)->GetDoubleArrayRegion(env, array,start,len,buf);
2915 SvCUR_set(ST(3), len * sizeof(jdouble));
2916 *SvEND(ST(3)) = '\0';
2921 SetBooleanArrayRegion(array,start,len,buf)
2922 JNIEnv * env = FETCHENV;
2923 STRLEN tmplen = NO_INIT;
2927 jsize buf_len_ = NO_INIT;
2932 croak("string is too short");
2933 else if (buf_len_ > len && PL_dowarn)
2934 warn("string is too long");
2935 (*env)->SetBooleanArrayRegion(env, array,start,len,buf);
2940 SetByteArrayRegion(array,start,len,buf)
2941 JNIEnv * env = FETCHENV;
2942 STRLEN tmplen = NO_INIT;
2946 jsize buf_len_ = NO_INIT;
2951 croak("string is too short");
2952 else if (buf_len_ > len && PL_dowarn)
2953 warn("string is too long");
2954 (*env)->SetByteArrayRegion(env, array,start,len,buf);
2959 SetCharArrayRegion(array,start,len,buf)
2960 JNIEnv * env = FETCHENV;
2961 STRLEN tmplen = NO_INIT;
2965 jsize buf_len_ = NO_INIT;
2970 croak("string is too short");
2971 else if (buf_len_ > len && PL_dowarn)
2972 warn("string is too long");
2973 (*env)->SetCharArrayRegion(env, array,start,len,buf);
2978 SetShortArrayRegion(array,start,len,buf)
2979 JNIEnv * env = FETCHENV;
2980 STRLEN tmplen = NO_INIT;
2984 jsize buf_len_ = NO_INIT;
2989 croak("string is too short");
2990 else if (buf_len_ > len && PL_dowarn)
2991 warn("string is too long");
2992 (*env)->SetShortArrayRegion(env, array,start,len,buf);
2997 SetIntArrayRegion(array,start,len,buf)
2998 JNIEnv * env = FETCHENV;
2999 STRLEN tmplen = NO_INIT;
3003 jsize buf_len_ = NO_INIT;
3008 croak("string is too short");
3009 else if (buf_len_ > len && PL_dowarn)
3010 warn("string is too long");
3011 (*env)->SetIntArrayRegion(env, array,start,len,buf);
3016 SetLongArrayRegion(array,start,len,buf)
3017 JNIEnv * env = FETCHENV;
3018 STRLEN tmplen = NO_INIT;
3022 jsize buf_len_ = NO_INIT;
3027 croak("string is too short");
3028 else if (buf_len_ > len && PL_dowarn)
3029 warn("string is too long");
3030 (*env)->SetLongArrayRegion(env, array,start,len,buf);
3035 SetFloatArrayRegion(array,start,len,buf)
3036 JNIEnv * env = FETCHENV;
3037 STRLEN tmplen = NO_INIT;
3041 jsize buf_len_ = NO_INIT;
3046 croak("string is too short");
3047 else if (buf_len_ > len && PL_dowarn)
3048 warn("string is too long");
3049 (*env)->SetFloatArrayRegion(env, array,start,len,buf);
3054 SetDoubleArrayRegion(array,start,len,buf)
3055 JNIEnv * env = FETCHENV;
3056 STRLEN tmplen = NO_INIT;
3060 jsize buf_len_ = NO_INIT;
3065 croak("string is too short");
3066 else if (buf_len_ > len && PL_dowarn)
3067 warn("string is too long");
3068 (*env)->SetDoubleArrayRegion(env, array,start,len,buf);
3073 RegisterNatives(clazz,methods,nMethods)
3074 JNIEnv * env = FETCHENV;
3076 JNINativeMethod * methods
3080 RETVAL = (*env)->RegisterNatives(env, clazz,methods,nMethods);
3084 UnregisterNatives(clazz)
3085 JNIEnv * env = FETCHENV;
3089 RETVAL = (*env)->UnregisterNatives(env, clazz);
3096 JNIEnv * env = FETCHENV;
3100 RETVAL = (*env)->MonitorEnter(env, obj);
3108 JNIEnv * env = FETCHENV;
3112 RETVAL = (*env)->MonitorExit(env, obj);
3120 JNIEnv * env = FETCHENV;
3128 if (env) { /* We're embedded. */
3129 if ((*env)->GetJavaVM(env, &RETVAL) < 0)
3132 else { /* We're embedding. */
3134 JavaVMInitArgs vm_args;
3136 JDK1_1InitArgs vm_args;
3140 fprintf(stderr, "We're embedding Java in Perl.\n");
3145 lib = SvPV(*mark, PL_na);
3150 fprintf(stderr, "lib is %s.\n", lib);
3153 if (LoadLibrary("jvm.dll")) {
3154 if (!LoadLibrary("javai.dll")) {
3155 warn("Can't load javai.dll");
3158 if (lib && !LoadLibrary(lib))
3159 croak("Can't load javai.dll");
3163 fprintf(stderr, "Opening Java shared library.\n");
3166 if (!dlopen("libkaffevm.so", RTLD_LAZY|RTLD_GLOBAL)) {
3168 if (!dlopen("libjava.so", RTLD_LAZY|RTLD_GLOBAL)) {
3170 if (lib && !dlopen(lib, RTLD_LAZY|RTLD_GLOBAL))
3171 croak("Can't load Java shared library.");
3174 /* Kaffe seems to get very upset if vm_args.version isn't set */
3176 vm_args.version = JNI_VERSION_1_1;
3178 JNI_GetDefaultJavaVMInitArgs(&vm_args);
3179 vm_args.exit = &call_my_exit;
3181 fprintf(stderr, "items = %d\n", items);
3182 fprintf(stderr, "mark = %s\n", SvPV(*mark, PL_na));
3187 s = SvPV(*mark,PL_na);
3190 fprintf(stderr, "*s = %s\n", s);
3191 fprintf(stderr, "val = %s\n", SvPV(*mark, PL_na));
3194 if (strEQ(s, "checkSource"))
3195 vm_args.checkSource = (jint)SvIV(*mark);
3196 else if (strEQ(s, "nativeStackSize"))
3197 vm_args.nativeStackSize = (jint)SvIV(*mark);
3198 else if (strEQ(s, "javaStackSize"))
3199 vm_args.javaStackSize = (jint)SvIV(*mark);
3200 else if (strEQ(s, "minHeapSize"))
3201 vm_args.minHeapSize = (jint)SvIV(*mark);
3202 else if (strEQ(s, "maxHeapSize"))
3203 vm_args.maxHeapSize = (jint)SvIV(*mark);
3204 else if (strEQ(s, "verifyMode"))
3205 vm_args.verifyMode = (jint)SvIV(*mark);
3206 else if (strEQ(s, "classpath"))
3207 vm_args.classpath = savepv(SvPV(*mark,PL_na));
3208 else if (strEQ(s, "enableClassGC"))
3209 vm_args.enableClassGC = (jint)SvIV(*mark);
3210 else if (strEQ(s, "enableVerboseGC"))
3211 vm_args.enableVerboseGC = (jint)SvIV(*mark);
3212 else if (strEQ(s, "disableAsyncGC"))
3213 vm_args.disableAsyncGC = (jint)SvIV(*mark);
3215 else if (strEQ(s, "libraryhome"))
3216 vm_args.libraryhome = savepv(SvPV(*mark,PL_na));
3217 else if (strEQ(s, "classhome"))
3218 vm_args.classhome = savepv(SvPV(*mark,PL_na));
3219 else if (strEQ(s, "enableVerboseJIT"))
3220 vm_args.enableVerboseJIT = (jint)SvIV(*mark);
3221 else if (strEQ(s, "enableVerboseClassloading"))
3222 vm_args.enableVerboseClassloading = (jint)SvIV(*mark);
3223 else if (strEQ(s, "enableVerboseCall"))
3224 vm_args.enableVerboseCall = (jint)SvIV(*mark);
3225 else if (strEQ(s, "allocHeapSize"))
3226 vm_args.allocHeapSize = (jint)SvIV(*mark);
3228 else if (strEQ(s, "verbose"))
3229 vm_args.verbose = (jint)SvIV(*mark);
3230 else if (strEQ(s, "debugging"))
3231 vm_args.debugging = (jboolean)SvIV(*mark);
3232 else if (strEQ(s, "debugPort"))
3233 vm_args.debugPort = (jint)SvIV(*mark);
3236 croak("unrecognized option: %s", s);
3240 fprintf(stderr, "Creating Java VM...\n");
3241 fprintf(stderr, "Working CLASSPATH: %s\n",
3244 if (JNI_CreateJavaVM(&RETVAL, &jplcurenv, &vm_args) < 0) {
3245 croak("Unable to create instance of JVM");
3248 fprintf(stderr, "Created Java VM.\n");