# define PERL_SUBVERSION SUBVERSION
#endif
-#if PERL_REVISION == 5 && (PERL_VERSION < 4 || \
- (PERL_VERSION == 4 && PERL_SUBVERSION <= 75))
+#if PERL_REVISION == 5 && (PERL_VERSION < 4 || (PERL_VERSION == 4 && PERL_SUBVERSION <= 75))
# define PL_na na
# define PL_sv_no sv_no
# define PL_sv_undef sv_undef
int i;
SV** esv;
-#ifdef WIN32
- jbooleanArray ja = env->NewBooleanArray(len);
-#else
jbooleanArray ja = (*env)->NewBooleanArray(env, len);
-#endif
for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
buf[i] = (jboolean)SvIV(*esv);
-#ifdef WIN32
- env->SetBooleanArrayRegion(ja, 0, len, buf);
-#else
(*env)->SetBooleanArrayRegion(env, ja, 0, len, buf);
-#endif
free((void*)buf);
jv[ix++].l = (jobject)ja;
}
else if (SvPOK(sv)) {
jsize len = sv_len(sv) / sizeof(jboolean);
-#ifdef WIN32
- jbooleanArray ja = env->NewBooleanArray(len);
-#else
jbooleanArray ja = (*env)->NewBooleanArray(env, len);
-#endif
-#ifdef WIN32
- env->SetBooleanArrayRegion(ja, 0, len, (jboolean*)SvPV(sv,n_a));
-#else
(*env)->SetBooleanArrayRegion(env, ja, 0, len, (jboolean*)SvPV(sv,n_a));
-#endif
jv[ix++].l = (jobject)ja;
}
else
int i;
SV** esv;
-#ifdef WIN32
- jbyteArray ja = env->NewByteArray(len);
-#else
jbyteArray ja = (*env)->NewByteArray(env, len);
-#endif
for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
buf[i] = (jbyte)SvIV(*esv);
-#ifdef WIN32
- env->SetByteArrayRegion(ja, 0, len, buf);
-#else
(*env)->SetByteArrayRegion(env, ja, 0, len, buf);
-#endif
free((void*)buf);
jv[ix++].l = (jobject)ja;
}
else if (SvPOK(sv)) {
jsize len = sv_len(sv) / sizeof(jbyte);
-#ifdef WIN32
- jbyteArray ja = env->NewByteArray(len);
-#else
jbyteArray ja = (*env)->NewByteArray(env, len);
-#endif
-#ifdef WIN32
- env->SetByteArrayRegion(ja, 0, len, (jbyte*)SvPV(sv,n_a));
-#else
(*env)->SetByteArrayRegion(env, ja, 0, len, (jbyte*)SvPV(sv,n_a));
-#endif
jv[ix++].l = (jobject)ja;
}
else
int i;
SV** esv;
-#ifdef WIN32
- jcharArray ja = env->NewCharArray(len);
-#else
jcharArray ja = (*env)->NewCharArray(env, len);
-#endif
for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
buf[i] = (jchar)SvIV(*esv);
-#ifdef WIN32
- env->SetCharArrayRegion(ja, 0, len, buf);
-#else
(*env)->SetCharArrayRegion(env, ja, 0, len, buf);
-#endif
free((void*)buf);
jv[ix++].l = (jobject)ja;
}
else if (SvPOK(sv)) {
jsize len = sv_len(sv) / sizeof(jchar);
-#ifdef WIN32
- jcharArray ja = env->NewCharArray(len);
-#else
jcharArray ja = (*env)->NewCharArray(env, len);
-#endif
-#ifdef WIN32
- env->SetCharArrayRegion(ja, 0, len, (jchar*)SvPV(sv,n_a));
-#else
(*env)->SetCharArrayRegion(env, ja, 0, len, (jchar*)SvPV(sv,n_a));
-#endif
jv[ix++].l = (jobject)ja;
}
else
int i;
SV** esv;
-#ifdef WIN32
- jshortArray ja = env->NewShortArray(len);
-#else
jshortArray ja = (*env)->NewShortArray(env, len);
-#endif
for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
buf[i] = (jshort)SvIV(*esv);
-#ifdef WIN32
- env->SetShortArrayRegion(ja, 0, len, buf);
-#else
(*env)->SetShortArrayRegion(env, ja, 0, len, buf);
-#endif
free((void*)buf);
jv[ix++].l = (jobject)ja;
}
else if (SvPOK(sv)) {
jsize len = sv_len(sv) / sizeof(jshort);
-#ifdef WIN32
- jshortArray ja = env->NewShortArray(len);
-#else
jshortArray ja = (*env)->NewShortArray(env, len);
-#endif
-#ifdef WIN32
- env->SetShortArrayRegion(ja, 0, len, (jshort*)SvPV(sv,n_a));
-#else
(*env)->SetShortArrayRegion(env, ja, 0, len, (jshort*)SvPV(sv,n_a));
-#endif
jv[ix++].l = (jobject)ja;
}
else
int i;
SV** esv;
-#ifdef WIN32
- jintArray ja = env->NewIntArray(len);
-#else
jintArray ja = (*env)->NewIntArray(env, len);
-#endif
for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
buf[i] = (jint)SvIV(*esv);
-#ifdef WIN32
- env->SetIntArrayRegion(ja, 0, len, buf);
-#else
(*env)->SetIntArrayRegion(env, ja, 0, len, buf);
-#endif
free((void*)buf);
jv[ix++].l = (jobject)ja;
}
else if (SvPOK(sv)) {
jsize len = sv_len(sv) / sizeof(jint);
-#ifdef WIN32
- jintArray ja = env->NewIntArray(len);
-#else
jintArray ja = (*env)->NewIntArray(env, len);
-#endif
-#ifdef WIN32
- env->SetIntArrayRegion(ja, 0, len, (jint*)SvPV(sv,n_a));
-#else
(*env)->SetIntArrayRegion(env, ja, 0, len, (jint*)SvPV(sv,n_a));
-#endif
jv[ix++].l = (jobject)ja;
}
else
int i;
SV** esv;
-#ifdef WIN32
- jlongArray ja = env->NewLongArray(len);
-#else
jlongArray ja = (*env)->NewLongArray(env, len);
-#endif
for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
buf[i] = (jlong)SvNV(*esv);
-#ifdef WIN32
- env->SetLongArrayRegion(ja, 0, len, buf);
-#else
(*env)->SetLongArrayRegion(env, ja, 0, len, buf);
-#endif
free((void*)buf);
jv[ix++].l = (jobject)ja;
}
else if (SvPOK(sv)) {
jsize len = sv_len(sv) / sizeof(jlong);
-#ifdef WIN32
- jlongArray ja = env->NewLongArray(len);
-#else
jlongArray ja = (*env)->NewLongArray(env, len);
-#endif
-#ifdef WIN32
- env->SetLongArrayRegion(ja, 0, len, (jlong*)SvPV(sv,n_a));
-#else
(*env)->SetLongArrayRegion(env, ja, 0, len, (jlong*)SvPV(sv,n_a));
-#endif
jv[ix++].l = (jobject)ja;
}
else
int i;
SV** esv;
-#ifdef WIN32
- jfloatArray ja = env->NewFloatArray(len);
-#else
jfloatArray ja = (*env)->NewFloatArray(env, len);
-#endif
for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
buf[i] = (jfloat)SvNV(*esv);
-#ifdef WIN32
- env->SetFloatArrayRegion(ja, 0, len, buf);
-#else
(*env)->SetFloatArrayRegion(env, ja, 0, len, buf);
-#endif
free((void*)buf);
jv[ix++].l = (jobject)ja;
}
else if (SvPOK(sv)) {
jsize len = sv_len(sv) / sizeof(jfloat);
-#ifdef WIN32
- jfloatArray ja = env->NewFloatArray(len);
-#else
jfloatArray ja = (*env)->NewFloatArray(env, len);
-#endif
-#ifdef WIN32
- env->SetFloatArrayRegion(ja, 0, len, (jfloat*)SvPV(sv,n_a));
-#else
(*env)->SetFloatArrayRegion(env, ja, 0, len, (jfloat*)SvPV(sv,n_a));
-#endif
jv[ix++].l = (jobject)ja;
}
else
int i;
SV** esv;
-#ifdef WIN32
- jdoubleArray ja = env->NewDoubleArray(len);
-#else
jdoubleArray ja = (*env)->NewDoubleArray(env, len);
-#endif
for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
buf[i] = (jdouble)SvNV(*esv);
-#ifdef WIN32
- env->SetDoubleArrayRegion(ja, 0, len, buf);
-#else
(*env)->SetDoubleArrayRegion(env, ja, 0, len, buf);
-#endif
free((void*)buf);
jv[ix++].l = (jobject)ja;
}
else if (SvPOK(sv)) {
jsize len = sv_len(sv) / sizeof(jdouble);
-#ifdef WIN32
- jdoubleArray ja = env->NewDoubleArray(len);
-#else
jdoubleArray ja = (*env)->NewDoubleArray(env, len);
-#endif
-#ifdef WIN32
- env->SetDoubleArrayRegion(ja, 0, len, (jdouble*)SvPV(sv,n_a));
-#else
(*env)->SetDoubleArrayRegion(env, ja, 0, len, (jdouble*)SvPV(sv,n_a));
-#endif
jv[ix++].l = (jobject)ja;
}
else
jobjectArray ja;
if (!jcl)
-#ifdef WIN32
- jcl = env->FindClass("java/lang/String");
-#else
jcl = (*env)->FindClass(env, "java/lang/String");
-#endif
-#ifdef WIN32
- ja = env->NewObjectArray(len, jcl, 0);
-#else
ja = (*env)->NewObjectArray(env, len, jcl, 0);
-#endif
for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++) {
-#ifdef WIN32
- jobject str = (jobject)env->NewStringUTF(SvPV(*esv,n_a));
-#else
jobject str = (jobject)(*env)->NewStringUTF(env, SvPV(*esv,n_a));
-#endif
-#ifdef WIN32
- env->SetObjectArrayElement(ja, i, str);
-#else
(*env)->SetObjectArrayElement(env, ja, i, str);
-#endif
}
jv[ix++].l = (jobject)ja;
}
jobjectArray ja;
if (!jcl)
-#ifdef WIN32
- jcl = env->FindClass("java/lang/Object");
-#else
jcl = (*env)->FindClass(env, "java/lang/Object");
-#endif
-#ifdef WIN32
- ja = env->NewObjectArray(len, jcl, 0);
-#else
ja = (*env)->NewObjectArray(env, len, jcl, 0);
-#endif
for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++) {
if (SvROK(*esv) && (rv = SvRV(*esv)) && SvOBJECT(rv)) {
-#ifdef WIN32
- env->SetObjectArrayElement(ja, i, (jobject)(void*)SvIV(rv));
-#else
(*env)->SetObjectArrayElement(env, ja, i, (jobject)(void*)SvIV(rv));
-#endif
}
else {
-#ifdef WIN32
- jobject str = (jobject)env->NewStringUTF(SvPV(*esv,n_a));
-#else
jobject str = (jobject)(*env)->NewStringUTF(env, SvPV(*esv,n_a));
-#endif
-#ifdef WIN32
- env->SetObjectArrayElement(ja, i, str);
-#else
(*env)->SetObjectArrayElement(env, ja, i, str);
-#endif
}
}
jv[ix++].l = (jobject)ja;
case 'L':
if (!SvROK(sv) || strnEQ(s, "java/lang/String;", 17)) {
s += 17;
-#ifdef WIN32
- jv[ix++].l = (jobject)env->NewStringUTF((char*) SvPV(sv,n_a));
-#else
jv[ix++].l = (jobject)(*env)->NewStringUTF(env, (char*) SvPV(sv,n_a));
-#endif
break;
}
while (*s != ';') s++;
JNIEnv * env = FETCHENV;
CODE:
{
-#ifdef WIN32
- RETVAL = env->GetVersion();
-#else
RETVAL = (*env)->GetVersion(env);
-#endif
RESTOREENV;
}
OUTPUT:
CODE:
{
#ifdef KAFFE
-#ifdef WIN32
- RETVAL = env->DefineClass( loader, buf, (jsize)buf_len_);
-#else
RETVAL = (*env)->DefineClass(env, loader, buf, (jsize)buf_len_);
-#endif
-#else
-#ifdef WIN32
- RETVAL = env->DefineClass( name, loader, buf, (jsize)buf_len_);
#else
RETVAL = (*env)->DefineClass(env, name, loader, buf, (jsize)buf_len_);
#endif
-#endif
RESTOREENV;
}
OUTPUT:
const char * name
CODE:
{
-#ifdef WIN32
- RETVAL = env->FindClass( name);
-#else
RETVAL = (*env)->FindClass(env, name);
-#endif
RESTOREENV;
}
OUTPUT:
jclass sub
CODE:
{
-#ifdef WIN32
- RETVAL = env->GetSuperclass( sub);
-#else
RETVAL = (*env)->GetSuperclass(env, sub);
-#endif
RESTOREENV;
}
OUTPUT:
jclass sup
CODE:
{
-#ifdef WIN32
- RETVAL = env->IsAssignableFrom( sub, sup);
-#else
RETVAL = (*env)->IsAssignableFrom(env, sub, sup);
-#endif
RESTOREENV;
}
OUTPUT:
jthrowable obj
CODE:
{
-#ifdef WIN32
- RETVAL = env->Throw( obj);
-#else
RETVAL = (*env)->Throw(env, obj);
-#endif
RESTOREENV;
}
OUTPUT:
const char * msg
CODE:
{
-#ifdef WIN32
- RETVAL = env->ThrowNew( clazz, msg);
-#else
RETVAL = (*env)->ThrowNew(env, clazz, msg);
-#endif
RESTOREENV;
}
OUTPUT:
JNIEnv * env = FETCHENV;
CODE:
{
-#ifdef WIN32
- RETVAL = env->ExceptionOccurred();
-#else
RETVAL = (*env)->ExceptionOccurred(env);
-#endif
RESTOREENV;
}
OUTPUT:
JNIEnv * env = FETCHENV;
CODE:
{
-#ifdef WIN32
- env->ExceptionDescribe();
-#else
(*env)->ExceptionDescribe(env);
-#endif
RESTOREENV;
}
JNIEnv * env = FETCHENV;
CODE:
{
-#ifdef WIN32
- env->ExceptionClear();
-#else
(*env)->ExceptionClear(env);
-#endif
RESTOREENV;
}
const char * msg
CODE:
{
-#ifdef WIN32
- env->FatalError( msg);
-#else
(*env)->FatalError(env, msg);
-#endif
RESTOREENV;
}
jobject lobj
CODE:
{
-#ifdef WIN32
- RETVAL = env->NewGlobalRef(lobj);
-#else
RETVAL = (*env)->NewGlobalRef(env, lobj);
-#endif
RESTOREENV;
}
OUTPUT:
jobject gref
CODE:
{
-#ifdef WIN32
- env->DeleteGlobalRef(gref);
-#else
(*env)->DeleteGlobalRef(env, gref);
-#endif
RESTOREENV;
}
jobject obj
CODE:
{
-#ifdef WIN32
- env->DeleteLocalRef( obj);
-#else
(*env)->DeleteLocalRef(env, obj);
-#endif
RESTOREENV;
}
jobject obj2
CODE:
{
-#ifdef WIN32
- RETVAL = env->IsSameObject(obj1,obj2);
-#else
RETVAL = (*env)->IsSameObject(env, obj1,obj2);
-#endif
RESTOREENV;
}
OUTPUT:
jclass clazz
CODE:
{
-#ifdef WIN32
- RETVAL = env->AllocObject(clazz);
-#else
RETVAL = (*env)->AllocObject(env, clazz);
-#endif
RESTOREENV;
}
OUTPUT:
CODE:
{
jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
-#ifdef WIN32
- RETVAL = env->NewObjectA(clazz,methodID,args);
-#else
RETVAL = (*env)->NewObjectA(env, clazz,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
jvalue * args
CODE:
{
-#ifdef WIN32
- RETVAL = env->NewObjectA(clazz,methodID,args);
-#else
RETVAL = (*env)->NewObjectA(env, clazz,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
jobject obj
CODE:
{
-#ifdef WIN32
- RETVAL = env->GetObjectClass(obj);
-#else
RETVAL = (*env)->GetObjectClass(env, obj);
-#endif
RESTOREENV;
}
OUTPUT:
jclass clazz
CODE:
{
-#ifdef WIN32
- RETVAL = env->IsInstanceOf(obj,clazz);
-#else
RETVAL = (*env)->IsInstanceOf(env, obj,clazz);
-#endif
RESTOREENV;
}
OUTPUT:
const char * sig
CODE:
{
-#ifdef WIN32
- RETVAL = env->GetMethodID(clazz,name,sig);
-#else
RETVAL = (*env)->GetMethodID(env, clazz,name,sig);
-#endif
RESTOREENV;
}
OUTPUT:
CODE:
{
jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
-#ifdef WIN32
- RETVAL = env->CallObjectMethodA(obj,methodID,args);
-#else
RETVAL = (*env)->CallObjectMethodA(env, obj,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
jvalue * args
CODE:
{
-#ifdef WIN32
- RETVAL = env->CallObjectMethodA(obj,methodID,args);
-#else
RETVAL = (*env)->CallObjectMethodA(env, obj,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
CODE:
{
jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
-#ifdef WIN32
- RETVAL = env->CallBooleanMethodA(obj,methodID,args);
-#else
RETVAL = (*env)->CallBooleanMethodA(env, obj,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
jvalue * args
CODE:
{
-#ifdef WIN32
- RETVAL = env->CallBooleanMethodA(obj,methodID, args);
-#else
RETVAL = (*env)->CallBooleanMethodA(env, obj,methodID, args);
-#endif
RESTOREENV;
}
OUTPUT:
CODE:
{
jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
-#ifdef WIN32
- RETVAL = env->CallByteMethodA(obj,methodID,args);
-#else
RETVAL = (*env)->CallByteMethodA(env, obj,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
jvalue * args
CODE:
{
-#ifdef WIN32
- RETVAL = env->CallByteMethodA(obj,methodID,args);
-#else
RETVAL = (*env)->CallByteMethodA(env, obj,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
CODE:
{
jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
-#ifdef WIN32
- RETVAL = env->CallCharMethodA(obj,methodID,args);
-#else
RETVAL = (*env)->CallCharMethodA(env, obj,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
jvalue * args
CODE:
{
-#ifdef WIN32
- RETVAL = env->CallCharMethodA(obj,methodID,args);
-#else
RETVAL = (*env)->CallCharMethodA(env, obj,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
CODE:
{
jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
-#ifdef WIN32
- RETVAL = env->CallShortMethodA(obj,methodID,args);
-#else
RETVAL = (*env)->CallShortMethodA(env, obj,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
jvalue * args
CODE:
{
-#ifdef WIN32
- RETVAL = env->CallShortMethodA(obj,methodID,args);
-#else
RETVAL = (*env)->CallShortMethodA(env, obj,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
CODE:
{
jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
-#ifdef WIN32
- RETVAL = env->CallIntMethodA(obj,methodID,args);
-#else
RETVAL = (*env)->CallIntMethodA(env, obj,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
jvalue * args
CODE:
{
-#ifdef WIN32
- RETVAL = env->CallIntMethodA(obj,methodID,args);
-#else
RETVAL = (*env)->CallIntMethodA(env, obj,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
CODE:
{
jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
-#ifdef WIN32
- RETVAL = env->CallLongMethodA(obj,methodID,args);
-#else
RETVAL = (*env)->CallLongMethodA(env, obj,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
jvalue * args
CODE:
{
-#ifdef WIN32
- RETVAL = env->CallLongMethodA(obj,methodID,args);
-#else
RETVAL = (*env)->CallLongMethodA(env, obj,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
CODE:
{
jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
-#ifdef WIN32
- RETVAL = env->CallFloatMethodA(obj,methodID,args);
-#else
RETVAL = (*env)->CallFloatMethodA(env, obj,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
jvalue * args
CODE:
{
-#ifdef WIN32
- RETVAL = env->CallFloatMethodA(obj,methodID,args);
-#else
RETVAL = (*env)->CallFloatMethodA(env, obj,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
CODE:
{
jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
-#ifdef WIN32
- RETVAL = env->CallDoubleMethodA(obj,methodID,args);
-#else
RETVAL = (*env)->CallDoubleMethodA(env, obj,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
jvalue * args
CODE:
{
-#ifdef WIN32
- RETVAL = env->CallDoubleMethodA(obj,methodID,args);
-#else
RETVAL = (*env)->CallDoubleMethodA(env, obj,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
CODE:
{
jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
-#ifdef WIN32
- env->CallVoidMethodA(obj,methodID,args);
-#else
(*env)->CallVoidMethodA(env, obj,methodID,args);
-#endif
RESTOREENV;
}
jvalue * args
CODE:
{
-#ifdef WIN32
- env->CallVoidMethodA(obj,methodID,args);
-#else
(*env)->CallVoidMethodA(env, obj,methodID,args);
-#endif
RESTOREENV;
}
CODE:
{
jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
-#ifdef WIN32
- RETVAL = env->CallNonvirtualObjectMethodA(obj,clazz,methodID,args);
-#else
RETVAL = (*env)->CallNonvirtualObjectMethodA(env, obj,clazz,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
jvalue * args
CODE:
{
-#ifdef WIN32
- RETVAL = env->CallNonvirtualObjectMethodA(obj,clazz,methodID,args);
-#else
RETVAL = (*env)->CallNonvirtualObjectMethodA(env, obj,clazz,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
CODE:
{
jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
-#ifdef WIN32
- RETVAL = env->CallNonvirtualBooleanMethodA(obj,clazz,methodID,args);
-#else
RETVAL = (*env)->CallNonvirtualBooleanMethodA(env, obj,clazz,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
jvalue * args
CODE:
{
-#ifdef WIN32
- RETVAL = env->CallNonvirtualBooleanMethodA(obj,clazz,methodID, args);
-#else
RETVAL = (*env)->CallNonvirtualBooleanMethodA(env, obj,clazz,methodID, args);
-#endif
RESTOREENV;
}
OUTPUT:
CODE:
{
jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
-#ifdef WIN32
- RETVAL = env->CallNonvirtualByteMethodA(obj,clazz,methodID,args);
-#else
RETVAL = (*env)->CallNonvirtualByteMethodA(env, obj,clazz,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
jvalue * args
CODE:
{
-#ifdef WIN32
- RETVAL = env->CallNonvirtualByteMethodA(obj,clazz,methodID,args);
-#else
RETVAL = (*env)->CallNonvirtualByteMethodA(env, obj,clazz,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
CODE:
{
jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
-#ifdef WIN32
- RETVAL = env->CallNonvirtualCharMethodA(obj,clazz,methodID,args);
-#else
RETVAL = (*env)->CallNonvirtualCharMethodA(env, obj,clazz,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
jvalue * args
CODE:
{
-#ifdef WIN32
- RETVAL = env->CallNonvirtualCharMethodA(obj,clazz,methodID,args);
-#else
RETVAL = (*env)->CallNonvirtualCharMethodA(env, obj,clazz,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
CODE:
{
jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
-#ifdef WIN32
- RETVAL = env->CallNonvirtualShortMethodA(obj,clazz,methodID,args);
-#else
RETVAL = (*env)->CallNonvirtualShortMethodA(env, obj,clazz,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
jvalue * args
CODE:
{
-#ifdef WIN32
- RETVAL = env->CallNonvirtualShortMethodA(obj,clazz,methodID,args);
-#else
RETVAL = (*env)->CallNonvirtualShortMethodA(env, obj,clazz,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
CODE:
{
jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
-#ifdef WIN32
- RETVAL = env->CallNonvirtualIntMethodA(obj,clazz,methodID,args);
-#else
RETVAL = (*env)->CallNonvirtualIntMethodA(env, obj,clazz,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
jvalue * args
CODE:
{
-#ifdef WIN32
- RETVAL = env->CallNonvirtualIntMethodA(obj,clazz,methodID,args);
-#else
RETVAL = (*env)->CallNonvirtualIntMethodA(env, obj,clazz,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
CODE:
{
jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
-#ifdef WIN32
- RETVAL = env->CallNonvirtualLongMethodA(obj,clazz,methodID,args);
-#else
RETVAL = (*env)->CallNonvirtualLongMethodA(env, obj,clazz,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
jvalue * args
CODE:
{
-#ifdef WIN32
- RETVAL = env->CallNonvirtualLongMethodA(obj,clazz,methodID,args);
-#else
RETVAL = (*env)->CallNonvirtualLongMethodA(env, obj,clazz,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
CODE:
{
jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
-#ifdef WIN32
- RETVAL = env->CallNonvirtualFloatMethodA(obj,clazz,methodID,args);
-#else
RETVAL = (*env)->CallNonvirtualFloatMethodA(env, obj,clazz,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
jvalue * args
CODE:
{
-#ifdef WIN32
- RETVAL = env->CallNonvirtualFloatMethodA(obj,clazz,methodID,args);
-#else
RETVAL = (*env)->CallNonvirtualFloatMethodA(env, obj,clazz,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
CODE:
{
jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
-#ifdef WIN32
- RETVAL = env->CallNonvirtualDoubleMethodA(obj,clazz,methodID,args);
-#else
RETVAL = (*env)->CallNonvirtualDoubleMethodA(env, obj,clazz,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
jvalue * args
CODE:
{
-#ifdef WIN32
- RETVAL = env->CallNonvirtualDoubleMethodA(obj,clazz,methodID,args);
-#else
RETVAL = (*env)->CallNonvirtualDoubleMethodA(env, obj,clazz,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
CODE:
{
jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
-#ifdef WIN32
- env->CallNonvirtualVoidMethodA(obj,clazz,methodID,args);
-#else
(*env)->CallNonvirtualVoidMethodA(env, obj,clazz,methodID,args);
-#endif
RESTOREENV;
}
jvalue * args
CODE:
{
-#ifdef WIN32
- env->CallNonvirtualVoidMethodA(obj,clazz,methodID,args);
-#else
(*env)->CallNonvirtualVoidMethodA(env, obj,clazz,methodID,args);
-#endif
RESTOREENV;
}
const char * sig
CODE:
{
-#ifdef WIN32
- RETVAL = env->GetFieldID(clazz,name,sig);
-#else
RETVAL = (*env)->GetFieldID(env, clazz,name,sig);
-#endif
RESTOREENV;
}
OUTPUT:
char * sig = 0;
CODE:
{
-#ifdef WIN32
- RETVAL = env->GetObjectField(obj,fieldID);
-#else
RETVAL = (*env)->GetObjectField(env, obj,fieldID);
-#endif
RESTOREENV;
}
OUTPUT:
char * sig = 0;
CODE:
{
-#ifdef WIN32
- RETVAL = env->GetBooleanField(obj,fieldID);
-#else
RETVAL = (*env)->GetBooleanField(env, obj,fieldID);
-#endif
RESTOREENV;
}
OUTPUT:
char * sig = 0;
CODE:
{
-#ifdef WIN32
- RETVAL = env->GetByteField(obj,fieldID);
-#else
RETVAL = (*env)->GetByteField(env, obj,fieldID);
-#endif
RESTOREENV;
}
OUTPUT:
char * sig = 0;
CODE:
{
-#ifdef WIN32
- RETVAL = env->GetCharField(obj,fieldID);
-#else
RETVAL = (*env)->GetCharField(env, obj,fieldID);
-#endif
RESTOREENV;
}
OUTPUT:
char * sig = 0;
CODE:
{
-#ifdef WIN32
- RETVAL = env->GetShortField(obj,fieldID);
-#else
RETVAL = (*env)->GetShortField(env, obj,fieldID);
-#endif
RESTOREENV;
}
OUTPUT:
char * sig = 0;
CODE:
{
-#ifdef WIN32
- RETVAL = env->GetIntField(obj,fieldID);
-#else
RETVAL = (*env)->GetIntField(env, obj,fieldID);
-#endif
RESTOREENV;
}
OUTPUT:
char * sig = 0;
CODE:
{
-#ifdef WIN32
- RETVAL = env->GetLongField(obj,fieldID);
-#else
RETVAL = (*env)->GetLongField(env, obj,fieldID);
-#endif
RESTOREENV;
}
OUTPUT:
char * sig = 0;
CODE:
{
-#ifdef WIN32
- RETVAL = env->GetFloatField(obj,fieldID);
-#else
RETVAL = (*env)->GetFloatField(env, obj,fieldID);
-#endif
RESTOREENV;
}
OUTPUT:
char * sig = 0;
CODE:
{
-#ifdef WIN32
- RETVAL = env->GetDoubleField(obj,fieldID);
-#else
RETVAL = (*env)->GetDoubleField(env, obj,fieldID);
-#endif
RESTOREENV;
}
OUTPUT:
jobject val
CODE:
{
-#ifdef WIN32
- env->SetObjectField(obj,fieldID,val);
-#else
(*env)->SetObjectField(env, obj,fieldID,val);
-#endif
RESTOREENV;
}
jboolean val
CODE:
{
-#ifdef WIN32
- env->SetBooleanField(obj,fieldID,val);
-#else
(*env)->SetBooleanField(env, obj,fieldID,val);
-#endif
RESTOREENV;
}
jbyte val
CODE:
{
-#ifdef WIN32
- env->SetByteField(obj,fieldID,val);
-#else
(*env)->SetByteField(env, obj,fieldID,val);
-#endif
RESTOREENV;
}
jchar val
CODE:
{
-#ifdef WIN32
- env->SetCharField(obj,fieldID,val);
-#else
(*env)->SetCharField(env, obj,fieldID,val);
-#endif
RESTOREENV;
}
jshort val
CODE:
{
-#ifdef WIN32
- env->SetShortField(obj,fieldID,val);
-#else
(*env)->SetShortField(env, obj,fieldID,val);
-#endif
RESTOREENV;
}
jint val
CODE:
{
-#ifdef WIN32
- env->SetIntField(obj,fieldID,val);
-#else
(*env)->SetIntField(env, obj,fieldID,val);
-#endif
RESTOREENV;
}
jlong val
CODE:
{
-#ifdef WIN32
- env->SetLongField(obj,fieldID,val);
-#else
(*env)->SetLongField(env, obj,fieldID,val);
-#endif
RESTOREENV;
}
jfloat val
CODE:
{
-#ifdef WIN32
- env->SetFloatField(obj,fieldID,val);
-#else
(*env)->SetFloatField(env, obj,fieldID,val);
-#endif
RESTOREENV;
}
jdouble val
CODE:
{
-#ifdef WIN32
- env->SetDoubleField(obj,fieldID,val);
-#else
(*env)->SetDoubleField(env, obj,fieldID,val);
-#endif
RESTOREENV;
}
const char * sig
CODE:
{
-#ifdef WIN32
- RETVAL = env->GetStaticMethodID(clazz,name,sig);
-#else
RETVAL = (*env)->GetStaticMethodID(env, clazz,name,sig);
-#endif
RESTOREENV;
}
OUTPUT:
CODE:
{
jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
-#ifdef WIN32
- RETVAL = env->CallStaticObjectMethodA(clazz,methodID,args);
-#else
RETVAL = (*env)->CallStaticObjectMethodA(env, clazz,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
jvalue * args
CODE:
{
-#ifdef WIN32
- RETVAL = env->CallStaticObjectMethodA(clazz,methodID,args);
-#else
RETVAL = (*env)->CallStaticObjectMethodA(env, clazz,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
CODE:
{
jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
-#ifdef WIN32
- RETVAL = env->CallStaticBooleanMethodA(clazz,methodID,args);
-#else
RETVAL = (*env)->CallStaticBooleanMethodA(env, clazz,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
jvalue * args
CODE:
{
-#ifdef WIN32
- RETVAL = env->CallStaticBooleanMethodA(clazz,methodID,args);
-#else
RETVAL = (*env)->CallStaticBooleanMethodA(env, clazz,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
CODE:
{
jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
-#ifdef WIN32
- RETVAL = env->CallStaticByteMethodA(clazz,methodID,args);
-#else
RETVAL = (*env)->CallStaticByteMethodA(env, clazz,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
jvalue * args
CODE:
{
-#ifdef WIN32
- RETVAL = env->CallStaticByteMethodA(clazz,methodID,args);
-#else
RETVAL = (*env)->CallStaticByteMethodA(env, clazz,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
CODE:
{
jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
-#ifdef WIN32
- RETVAL = env->CallStaticCharMethodA(clazz,methodID,args);
-#else
RETVAL = (*env)->CallStaticCharMethodA(env, clazz,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
jvalue * args
CODE:
{
-#ifdef WIN32
- RETVAL = env->CallStaticCharMethodA(clazz,methodID,args);
-#else
RETVAL = (*env)->CallStaticCharMethodA(env, clazz,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
CODE:
{
jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
-#ifdef WIN32
- RETVAL = env->CallStaticShortMethodA(clazz,methodID,args);
-#else
RETVAL = (*env)->CallStaticShortMethodA(env, clazz,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
jvalue * args
CODE:
{
-#ifdef WIN32
- RETVAL = env->CallStaticShortMethodA(clazz,methodID,args);
-#else
RETVAL = (*env)->CallStaticShortMethodA(env, clazz,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
CODE:
{
jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
-#ifdef WIN32
- RETVAL = env->CallStaticIntMethodA(clazz,methodID,args);
-#else
RETVAL = (*env)->CallStaticIntMethodA(env, clazz,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
jvalue * args
CODE:
{
-#ifdef WIN32
- RETVAL = env->CallStaticIntMethodA(clazz,methodID,args);
-#else
RETVAL = (*env)->CallStaticIntMethodA(env, clazz,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
CODE:
{
jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
-#ifdef WIN32
- RETVAL = env->CallStaticLongMethodA(clazz,methodID,args);
-#else
RETVAL = (*env)->CallStaticLongMethodA(env, clazz,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
jvalue * args
CODE:
{
-#ifdef WIN32
- RETVAL = env->CallStaticLongMethodA(clazz,methodID,args);
-#else
RETVAL = (*env)->CallStaticLongMethodA(env, clazz,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
CODE:
{
jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
-#ifdef WIN32
- RETVAL = env->CallStaticFloatMethodA(clazz,methodID,args);
-#else
RETVAL = (*env)->CallStaticFloatMethodA(env, clazz,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
jvalue * args
CODE:
{
-#ifdef WIN32
- RETVAL = env->CallStaticFloatMethodA(clazz,methodID,args);
-#else
RETVAL = (*env)->CallStaticFloatMethodA(env, clazz,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
CODE:
{
jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
-#ifdef WIN32
- RETVAL = env->CallStaticDoubleMethodA(clazz,methodID,args);
-#else
RETVAL = (*env)->CallStaticDoubleMethodA(env, clazz,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
jvalue * args
CODE:
{
-#ifdef WIN32
- RETVAL = env->CallStaticDoubleMethodA(clazz,methodID,args);
-#else
RETVAL = (*env)->CallStaticDoubleMethodA(env, clazz,methodID,args);
-#endif
RESTOREENV;
}
OUTPUT:
CODE:
{
jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
-#ifdef WIN32
- env->CallStaticVoidMethodA(cls,methodID,args);
-#else
(*env)->CallStaticVoidMethodA(env, cls,methodID,args);
-#endif
RESTOREENV;
}
jvalue * args
CODE:
{
-#ifdef WIN32
- env->CallStaticVoidMethodA(cls,methodID,args);
-#else
(*env)->CallStaticVoidMethodA(env, cls,methodID,args);
-#endif
RESTOREENV;
}
const char * sig
CODE:
{
-#ifdef WIN32
- RETVAL = env->GetStaticFieldID(clazz,name,sig);
-#else
RETVAL = (*env)->GetStaticFieldID(env, clazz,name,sig);
-#endif
RESTOREENV;
}
OUTPUT:
char * sig = 0;
CODE:
{
-#ifdef WIN32
- RETVAL = env->GetStaticObjectField(clazz,fieldID);
-#else
RETVAL = (*env)->GetStaticObjectField(env, clazz,fieldID);
-#endif
RESTOREENV;
}
OUTPUT:
char * sig = 0;
CODE:
{
-#ifdef WIN32
- RETVAL = env->GetStaticBooleanField(clazz,fieldID);
-#else
RETVAL = (*env)->GetStaticBooleanField(env, clazz,fieldID);
-#endif
RESTOREENV;
}
OUTPUT:
char * sig = 0;
CODE:
{
-#ifdef WIN32
- RETVAL = env->GetStaticByteField(clazz,fieldID);
-#else
RETVAL = (*env)->GetStaticByteField(env, clazz,fieldID);
-#endif
RESTOREENV;
}
OUTPUT:
jfieldID fieldID
char * sig = 0;
CODE:
- {
-#ifdef WIN32
- RETVAL = env->GetStaticCharField(clazz,fieldID);
-#else
+ {
RETVAL = (*env)->GetStaticCharField(env, clazz,fieldID);
-#endif
RESTOREENV;
}
OUTPUT:
char * sig = 0;
CODE:
{
-#ifdef WIN32
- RETVAL = env->GetStaticShortField(clazz,fieldID);
-#else
RETVAL = (*env)->GetStaticShortField(env, clazz,fieldID);
-#endif
RESTOREENV;
}
OUTPUT:
char * sig = 0;
CODE:
{
-#ifdef WIN32
- RETVAL = env->GetStaticIntField(clazz,fieldID);
-#else
RETVAL = (*env)->GetStaticIntField(env, clazz,fieldID);
-#endif
RESTOREENV;
}
OUTPUT:
char * sig = 0;
CODE:
{
-#ifdef WIN32
- RETVAL = env->GetStaticLongField(clazz,fieldID);
-#else
RETVAL = (*env)->GetStaticLongField(env, clazz,fieldID);
-#endif
RESTOREENV;
}
OUTPUT:
char * sig = 0;
CODE:
{
-#ifdef WIN32
- RETVAL = env->GetStaticFloatField(clazz,fieldID);
-#else
RETVAL = (*env)->GetStaticFloatField(env, clazz,fieldID);
-#endif
RESTOREENV;
}
OUTPUT:
char * sig = 0;
CODE:
{
-#ifdef WIN32
- RETVAL = env->GetStaticDoubleField(clazz,fieldID);
-#else
RETVAL = (*env)->GetStaticDoubleField(env, clazz,fieldID);
-#endif
RESTOREENV;
}
OUTPUT:
jobject value
CODE:
{
-#ifdef WIN32
- env->SetStaticObjectField(clazz,fieldID,value);
-#else
(*env)->SetStaticObjectField(env, clazz,fieldID,value);
-#endif
RESTOREENV;
}
jboolean value
CODE:
{
-#ifdef WIN32
- env->SetStaticBooleanField(clazz,fieldID,value);
-#else
(*env)->SetStaticBooleanField(env, clazz,fieldID,value);
-#endif
RESTOREENV;
}
jbyte value
CODE:
{
-#ifdef WIN32
- env->SetStaticByteField(clazz,fieldID,value);
-#else
(*env)->SetStaticByteField(env, clazz,fieldID,value);
-#endif
RESTOREENV;
}
jchar value
CODE:
{
-#ifdef WIN32
- env->SetStaticCharField(clazz,fieldID,value);
-#else
(*env)->SetStaticCharField(env, clazz,fieldID,value);
-#endif
RESTOREENV;
}
jshort value
CODE:
{
-#ifdef WIN32
- env->SetStaticShortField(clazz,fieldID,value);
-#else
(*env)->SetStaticShortField(env, clazz,fieldID,value);
-#endif
RESTOREENV;
}
jint value
CODE:
{
-#ifdef WIN32
- env->SetStaticIntField(clazz,fieldID,value);
-#else
(*env)->SetStaticIntField(env, clazz,fieldID,value);
-#endif
RESTOREENV;
}
jlong value
CODE:
{
-#ifdef WIN32
- env->SetStaticLongField(clazz,fieldID,value);
-#else
(*env)->SetStaticLongField(env, clazz,fieldID,value);
-#endif
RESTOREENV;
}
jfloat value
CODE:
{
-#ifdef WIN32
- env->SetStaticFloatField(clazz,fieldID,value);
-#else
(*env)->SetStaticFloatField(env, clazz,fieldID,value);
-#endif
RESTOREENV;
}
jdouble value
CODE:
{
-#ifdef WIN32
- env->SetStaticDoubleField(clazz,fieldID,value);
-#else
(*env)->SetStaticDoubleField(env, clazz,fieldID,value);
-#endif
RESTOREENV;
}
const jchar * unicode
CODE:
{
-#ifdef WIN32
- RETVAL = env->NewString(unicode, unicode_len_);
-#else
RETVAL = (*env)->NewString(env, unicode, unicode_len_);
-#endif
RESTOREENV;
}
OUTPUT:
jstring str
CODE:
{
-#ifdef WIN32
- RETVAL = env->GetStringLength(str);
-#else
RETVAL = (*env)->GetStringLength(env, str);
-#endif
RESTOREENV;
}
OUTPUT:
jsize RETVAL_len_ = NO_INIT;
CODE:
{
-#ifdef WIN32
- RETVAL = env->GetStringChars(str,&isCopy);
-#else
RETVAL = (*env)->GetStringChars(env, str,&isCopy);
-#endif
-#ifdef WIN32
- RETVAL_len_ = env->GetStringLength(str);
-#else
RETVAL_len_ = (*env)->GetStringLength(env, str);
-#endif
RESTOREENV;
}
OUTPUT:
RETVAL
CLEANUP:
-#ifdef WIN32
- env->ReleaseStringChars(str,RETVAL);
-#else
(*env)->ReleaseStringChars(env, str,RETVAL);
-#endif
jstring
NewStringUTF(utf)
const char * utf
CODE:
{
-#ifdef WIN32
- RETVAL = env->NewStringUTF(utf);
-#else
RETVAL = (*env)->NewStringUTF(env, utf);
-#endif
RESTOREENV;
}
OUTPUT:
jstring str
CODE:
{
-#ifdef WIN32
- RETVAL = env->GetStringUTFLength(str);
-#else
RETVAL = (*env)->GetStringUTFLength(env, str);
-#endif
RESTOREENV;
}
OUTPUT:
jboolean isCopy = NO_INIT;
CODE:
{
-#ifdef WIN32
- RETVAL = env->GetStringUTFChars(str,&isCopy);
-#else
RETVAL = (*env)->GetStringUTFChars(env, str,&isCopy);
-#endif
RESTOREENV;
}
OUTPUT:
RETVAL
CLEANUP:
-#ifdef WIN32
- env->ReleaseStringUTFChars(str, RETVAL);
-#else
(*env)->ReleaseStringUTFChars(env, str, RETVAL);
-#endif
jsize
jarray array
CODE:
{
-#ifdef WIN32
- RETVAL = env->GetArrayLength(array);
-#else
RETVAL = (*env)->GetArrayLength(env, array);
-#endif
RESTOREENV;
}
OUTPUT:
jobject init
CODE:
{
-#ifdef WIN32
- RETVAL = env->NewObjectArray(len,clazz,init);
-#else
RETVAL = (*env)->NewObjectArray(env, len,clazz,init);
-#endif
RESTOREENV;
}
OUTPUT:
jsize index
CODE:
{
-#ifdef WIN32
- RETVAL = env->GetObjectArrayElement(array,index);
-#else
RETVAL = (*env)->GetObjectArrayElement(env, array,index);
-#endif
RESTOREENV;
}
OUTPUT:
jobject val
CODE:
{
-#ifdef WIN32
- env->SetObjectArrayElement(array,index,val);
-#else
(*env)->SetObjectArrayElement(env, array,index,val);
-#endif
RESTOREENV;
}
jsize len
CODE:
{
-#ifdef WIN32
- RETVAL = env->NewBooleanArray(len);
-#else
RETVAL = (*env)->NewBooleanArray(env, len);
-#endif
RESTOREENV;
}
OUTPUT:
jsize len
CODE:
{
-#ifdef WIN32
- RETVAL = env->NewByteArray(len);
-#else
RETVAL = (*env)->NewByteArray(env, len);
-#endif
RESTOREENV;
}
OUTPUT:
jsize len
CODE:
{
-#ifdef WIN32
- RETVAL = env->NewCharArray(len);
-#else
RETVAL = (*env)->NewCharArray(env, len);
-#endif
RESTOREENV;
}
OUTPUT:
jsize len
CODE:
{
-#ifdef WIN32
- RETVAL = env->NewShortArray(len);
-#else
RETVAL = (*env)->NewShortArray(env, len);
-#endif
RESTOREENV;
}
OUTPUT:
jsize len
CODE:
{
-#ifdef WIN32
- RETVAL = env->NewIntArray(len);
-#else
RETVAL = (*env)->NewIntArray(env, len);
-#endif
RESTOREENV;
}
OUTPUT:
jsize len
CODE:
{
-#ifdef WIN32
- RETVAL = env->NewLongArray(len);
-#else
RETVAL = (*env)->NewLongArray(env, len);
-#endif
RESTOREENV;
}
OUTPUT:
jsize len
CODE:
{
-#ifdef WIN32
- RETVAL = env->NewFloatArray(len);
-#else
RETVAL = (*env)->NewFloatArray(env, len);
-#endif
RESTOREENV;
}
OUTPUT:
jsize len
CODE:
{
-#ifdef WIN32
- RETVAL = env->NewDoubleArray(len);
-#else
RETVAL = (*env)->NewDoubleArray(env, len);
-#endif
RESTOREENV;
}
OUTPUT:
jboolean isCopy = NO_INIT;
PPCODE:
{
-#ifdef WIN32
- RETVAL = env->GetBooleanArrayElements(array,&isCopy);
-#else
RETVAL = (*env)->GetBooleanArrayElements(env, array,&isCopy);
-#endif
-#ifdef WIN32
- RETVAL_len_ = env->GetArrayLength(array);
-#else
RETVAL_len_ = (*env)->GetArrayLength(env, array);
-#endif
if (GIMME == G_ARRAY) {
int i;
jboolean* r = RETVAL;
else
PUSHs(&PL_sv_no);
}
-#ifdef WIN32
- env->ReleaseBooleanArrayElements(array,RETVAL,JNI_ABORT);
-#else
(*env)->ReleaseBooleanArrayElements(env, array,RETVAL,JNI_ABORT);
-#endif
RESTOREENV;
}
jboolean isCopy = NO_INIT;
PPCODE:
{
-#ifdef WIN32
- RETVAL = env->GetByteArrayElements(array,&isCopy);
-#else
RETVAL = (*env)->GetByteArrayElements(env, array,&isCopy);
-#endif
-#ifdef WIN32
- RETVAL_len_ = env->GetArrayLength(array);
-#else
RETVAL_len_ = (*env)->GetArrayLength(env, array);
-#endif
if (GIMME == G_ARRAY) {
int i;
jbyte* r = RETVAL;
else
PUSHs(&PL_sv_no);
}
-#ifdef WIN32
- env->ReleaseByteArrayElements(array,RETVAL,JNI_ABORT);
-#else
(*env)->ReleaseByteArrayElements(env, array,RETVAL,JNI_ABORT);
-#endif
RESTOREENV;
}
jboolean isCopy = NO_INIT;
PPCODE:
{
-#ifdef WIN32
- RETVAL = env->GetCharArrayElements(array,&isCopy);
-#else
RETVAL = (*env)->GetCharArrayElements(env, array,&isCopy);
-#endif
-#ifdef WIN32
- RETVAL_len_ = env->GetArrayLength(array);
-#else
RETVAL_len_ = (*env)->GetArrayLength(env, array);
-#endif
if (GIMME == G_ARRAY) {
int i;
jchar* r = RETVAL;
else
PUSHs(&PL_sv_no);
}
-#ifdef WIN32
- env->ReleaseCharArrayElements(array,RETVAL,JNI_ABORT);
-#else
(*env)->ReleaseCharArrayElements(env, array,RETVAL,JNI_ABORT);
-#endif
RESTOREENV;
}
jboolean isCopy = NO_INIT;
PPCODE:
{
-#ifdef WIN32
- RETVAL = env->GetShortArrayElements(array,&isCopy);
-#else
RETVAL = (*env)->GetShortArrayElements(env, array,&isCopy);
-#endif
-#ifdef WIN32
- RETVAL_len_ = env->GetArrayLength(array);
-#else
RETVAL_len_ = (*env)->GetArrayLength(env, array);
-#endif
if (GIMME == G_ARRAY) {
int i;
jshort* r = RETVAL;
else
PUSHs(&PL_sv_no);
}
-#ifdef WIN32
- env->ReleaseShortArrayElements(array,RETVAL,JNI_ABORT);
-#else
(*env)->ReleaseShortArrayElements(env, array,RETVAL,JNI_ABORT);
-#endif
RESTOREENV;
}
jboolean isCopy = NO_INIT;
PPCODE:
{
-#ifdef WIN32
- RETVAL = env->GetIntArrayElements(array,&isCopy);
-#else
RETVAL = (*env)->GetIntArrayElements(env, array,&isCopy);
-#endif
-#ifdef WIN32
- RETVAL_len_ = env->GetArrayLength(array);
-#else
RETVAL_len_ = (*env)->GetArrayLength(env, array);
-#endif
if (GIMME == G_ARRAY) {
int i;
jint* r = RETVAL;
else
PUSHs(&PL_sv_no);
}
-#ifdef WIN32
- env->ReleaseIntArrayElements(array,RETVAL,JNI_ABORT);
-#else
(*env)->ReleaseIntArrayElements(env, array,RETVAL,JNI_ABORT);
-#endif
RESTOREENV;
}
jboolean isCopy = NO_INIT;
PPCODE:
{
-#ifdef WIN32
- RETVAL = env->GetLongArrayElements(array,&isCopy);
-#else
RETVAL = (*env)->GetLongArrayElements(env, array,&isCopy);
-#endif
-#ifdef WIN32
- RETVAL_len_ = env->GetArrayLength(array);
-#else
RETVAL_len_ = (*env)->GetArrayLength(env, array);
-#endif
if (GIMME == G_ARRAY) {
int i;
jlong* r = RETVAL;
else
PUSHs(&PL_sv_no);
}
-#ifdef WIN32
- env->ReleaseLongArrayElements(array,RETVAL,JNI_ABORT);
-#else
(*env)->ReleaseLongArrayElements(env, array,RETVAL,JNI_ABORT);
-#endif
RESTOREENV;
}
jboolean isCopy = NO_INIT;
PPCODE:
{
-#ifdef WIN32
- RETVAL = env->GetFloatArrayElements(array,&isCopy);
-#else
RETVAL = (*env)->GetFloatArrayElements(env, array,&isCopy);
-#endif
-#ifdef WIN32
- RETVAL_len_ = env->GetArrayLength(array);
-#else
RETVAL_len_ = (*env)->GetArrayLength(env, array);
-#endif
if (GIMME == G_ARRAY) {
int i;
jfloat* r = RETVAL;
else
PUSHs(&PL_sv_no);
}
-#ifdef WIN32
- env->ReleaseFloatArrayElements(array,RETVAL,JNI_ABORT);
-#else
(*env)->ReleaseFloatArrayElements(env, array,RETVAL,JNI_ABORT);
-#endif
RESTOREENV;
}
jboolean isCopy = NO_INIT;
PPCODE:
{
-#ifdef WIN32
- RETVAL = env->GetDoubleArrayElements(array,&isCopy);
-#else
RETVAL = (*env)->GetDoubleArrayElements(env, array,&isCopy);
-#endif
-#ifdef WIN32
- RETVAL_len_ = env->GetArrayLength(array);
-#else
RETVAL_len_ = (*env)->GetArrayLength(env, array);
-#endif
if (GIMME == G_ARRAY) {
int i;
jdouble* r = RETVAL;
else
PUSHs(&PL_sv_no);
}
-#ifdef WIN32
- env->ReleaseDoubleArrayElements(array,RETVAL,JNI_ABORT);
-#else
(*env)->ReleaseDoubleArrayElements(env, array,RETVAL,JNI_ABORT);
-#endif
RESTOREENV;
}
jboolean * buf = (jboolean*)sv_grow(ST(3),len * sizeof(jboolean)+1);
CODE:
{
-#ifdef WIN32
- env->GetBooleanArrayRegion(array,start,len,buf);
-#else
(*env)->GetBooleanArrayRegion(env, array,start,len,buf);
-#endif
SvCUR_set(ST(3), len * sizeof(jboolean));
*SvEND(ST(3)) = '\0';
RESTOREENV;
jbyte * buf = (jbyte*)sv_grow(ST(3),len * sizeof(jbyte)+1);
CODE:
{
-#ifdef WIN32
- env->GetByteArrayRegion(array,start,len,buf);
-#else
(*env)->GetByteArrayRegion(env, array,start,len,buf);
-#endif
SvCUR_set(ST(3), len * sizeof(jbyte));
*SvEND(ST(3)) = '\0';
RESTOREENV;
jchar * buf = (jchar*)sv_grow(ST(3),len * sizeof(jchar)+1);
CODE:
{
-#ifdef WIN32
- env->GetCharArrayRegion(array,start,len,buf);
-#else
(*env)->GetCharArrayRegion(env, array,start,len,buf);
-#endif
SvCUR_set(ST(3), len * sizeof(jchar));
*SvEND(ST(3)) = '\0';
RESTOREENV;
jshort * buf = (jshort*)sv_grow(ST(3),len * sizeof(jshort)+1);
CODE:
{
-#ifdef WIN32
- env->GetShortArrayRegion(array,start,len,buf);
-#else
(*env)->GetShortArrayRegion(env, array,start,len,buf);
-#endif
SvCUR_set(ST(3), len * sizeof(jshort));
*SvEND(ST(3)) = '\0';
RESTOREENV;
jint * buf = (jint*)sv_grow(ST(3),len * sizeof(jint)+1);
CODE:
{
-#ifdef WIN32
- env->GetIntArrayRegion(array,start,len,buf);
-#else
(*env)->GetIntArrayRegion(env, array,start,len,buf);
-#endif
SvCUR_set(ST(3), len * sizeof(jint));
*SvEND(ST(3)) = '\0';
RESTOREENV;
jlong * buf = (jlong*)sv_grow(ST(3),len * sizeof(jlong)+1);
CODE:
{
-#ifdef WIN32
- env->GetLongArrayRegion(array,start,len,buf);
-#else
(*env)->GetLongArrayRegion(env, array,start,len,buf);
-#endif
SvCUR_set(ST(3), len * sizeof(jlong));
*SvEND(ST(3)) = '\0';
RESTOREENV;
jfloat * buf = (jfloat*)sv_grow(ST(3),len * sizeof(jfloat)+1);
CODE:
{
-#ifdef WIN32
- env->GetFloatArrayRegion(array,start,len,buf);
-#else
(*env)->GetFloatArrayRegion(env, array,start,len,buf);
-#endif
SvCUR_set(ST(3), len * sizeof(jfloat));
*SvEND(ST(3)) = '\0';
RESTOREENV;
jdouble * buf = (jdouble*)sv_grow(ST(3),len * sizeof(jdouble)+1);
CODE:
{
-#ifdef WIN32
- env->GetDoubleArrayRegion(array,start,len,buf);
-#else
(*env)->GetDoubleArrayRegion(env, array,start,len,buf);
-#endif
SvCUR_set(ST(3), len * sizeof(jdouble));
*SvEND(ST(3)) = '\0';
RESTOREENV;
croak("string is too short");
else if (buf_len_ > len && PL_dowarn)
warn("string is too long");
-#ifdef WIN32
- env->SetBooleanArrayRegion(array,start,len,buf);
-#else
(*env)->SetBooleanArrayRegion(env, array,start,len,buf);
-#endif
RESTOREENV;
}
croak("string is too short");
else if (buf_len_ > len && PL_dowarn)
warn("string is too long");
-#ifdef WIN32
- env->SetByteArrayRegion(array,start,len,buf);
-#else
(*env)->SetByteArrayRegion(env, array,start,len,buf);
-#endif
RESTOREENV;
}
croak("string is too short");
else if (buf_len_ > len && PL_dowarn)
warn("string is too long");
-#ifdef WIN32
- env->SetCharArrayRegion(array,start,len,buf);
-#else
(*env)->SetCharArrayRegion(env, array,start,len,buf);
-#endif
RESTOREENV;
}
croak("string is too short");
else if (buf_len_ > len && PL_dowarn)
warn("string is too long");
-#ifdef WIN32
- env->SetShortArrayRegion(array,start,len,buf);
-#else
(*env)->SetShortArrayRegion(env, array,start,len,buf);
-#endif
RESTOREENV;
}
croak("string is too short");
else if (buf_len_ > len && PL_dowarn)
warn("string is too long");
-#ifdef WIN32
- env->SetIntArrayRegion(array,start,len,buf);
-#else
(*env)->SetIntArrayRegion(env, array,start,len,buf);
-#endif
RESTOREENV;
}
croak("string is too short");
else if (buf_len_ > len && PL_dowarn)
warn("string is too long");
-#ifdef WIN32
- env->SetLongArrayRegion(array,start,len,buf);
-#else
(*env)->SetLongArrayRegion(env, array,start,len,buf);
-#endif
RESTOREENV;
}
croak("string is too short");
else if (buf_len_ > len && PL_dowarn)
warn("string is too long");
-#ifdef WIN32
- env->SetFloatArrayRegion(array,start,len,buf);
-#else
(*env)->SetFloatArrayRegion(env, array,start,len,buf);
-#endif
RESTOREENV;
}
croak("string is too short");
else if (buf_len_ > len && PL_dowarn)
warn("string is too long");
-#ifdef WIN32
- env->SetDoubleArrayRegion(array,start,len,buf);
-#else
(*env)->SetDoubleArrayRegion(env, array,start,len,buf);
-#endif
RESTOREENV;
}
jint nMethods
CODE:
{
-#ifdef WIN32
- RETVAL = env->RegisterNatives(clazz,methods,nMethods);
-#else
RETVAL = (*env)->RegisterNatives(env, clazz,methods,nMethods);
-#endif
}
SysRet
jclass clazz
CODE:
{
-#ifdef WIN32
- RETVAL = env->UnregisterNatives(clazz);
-#else
RETVAL = (*env)->UnregisterNatives(env, clazz);
-#endif
}
OUTPUT:
RETVAL
jobject obj
CODE:
{
-#ifdef WIN32
- RETVAL = env->MonitorEnter(obj);
-#else
RETVAL = (*env)->MonitorEnter(env, obj);
-#endif
RESTOREENV;
}
OUTPUT:
jobject obj
CODE:
{
-#ifdef WIN32
- RETVAL = env->MonitorExit(obj);
-#else
RETVAL = (*env)->MonitorExit(env, obj);
-#endif
RESTOREENV;
}
OUTPUT:
JNIEnv * env = FETCHENV;
CODE:
{
- if (env) { /* We're embedded. */
-#ifdef WIN32
- if (env->GetJavaVM(&RETVAL) < 0)
+#ifdef JPL_DEBUG
+ jpldebug = 1;
#else
- if ((*env)->GetJavaVM(env, &RETVAL) < 0)
+ jpldebug = 0;
#endif
+ if (env) { /* We're embedded. */
+ if ((*env)->GetJavaVM(env, &RETVAL) < 0)
RETVAL = 0;
}
else { /* We're embedding. */
}
if (items--) {
- ++mark;
+ ++mark;
lib = SvPV(*mark, PL_na);
}
else
fprintf(stderr, "lib is %s.\n", lib);
}
#ifdef WIN32
- if (!LoadLibrary("javai.dll")) {
- if (lib && !LoadLibrary(lib))
- croak("Can't load javai.dll");
- }
+ if (LoadLibrary("jvm.dll")) {
+ if (!LoadLibrary("javai.dll")) {
+ warn("Can't load javai.dll");
+ }
+ } else {
+ if (lib && !LoadLibrary(lib))
+ croak("Can't load javai.dll");
+ }
#else
if (jpldebug) {
fprintf(stderr, "Opening Java shared library.\n");
croak("Can't load Java shared library.");
}
#endif
-
+ /* Kaffe seems to get very upset if vm_args.version isn't set */
+#ifdef KAFFE
+ vm_args.version = JNI_VERSION_1_1;
+#endif
JNI_GetDefaultJavaVMInitArgs(&vm_args);
vm_args.exit = &call_my_exit;
if (jpldebug) {
fprintf(stderr, "items = %d\n", items);
fprintf(stderr, "mark = %s\n", SvPV(*mark, PL_na));
}
- ++mark;
while (items > 1) {
- char *s = SvPV(*mark,PL_na);
+ char *s;
+ ++mark;
+ s = SvPV(*mark,PL_na);
++mark;
if (jpldebug) {
fprintf(stderr, "*s = %s\n", s);
vm_args.enableVerboseGC = (jint)SvIV(*mark);
else if (strEQ(s, "disableAsyncGC"))
vm_args.disableAsyncGC = (jint)SvIV(*mark);
-#ifndef KAFFE
+#ifdef KAFFE
+ else if (strEQ(s, "libraryhome"))
+ vm_args.libraryhome = savepv(SvPV(*mark,PL_na));
+ else if (strEQ(s, "classhome"))
+ vm_args.classhome = savepv(SvPV(*mark,PL_na));
+ else if (strEQ(s, "enableVerboseJIT"))
+ vm_args.enableVerboseJIT = (jint)SvIV(*mark);
+ else if (strEQ(s, "enableVerboseClassloading"))
+ vm_args.enableVerboseClassloading = (jint)SvIV(*mark);
+ else if (strEQ(s, "enableVerboseCall"))
+ vm_args.enableVerboseCall = (jint)SvIV(*mark);
+ else if (strEQ(s, "allocHeapSize"))
+ vm_args.allocHeapSize = (jint)SvIV(*mark);
+#else
else if (strEQ(s, "verbose"))
vm_args.verbose = (jint)SvIV(*mark);
else if (strEQ(s, "debugging"))
fprintf(stderr, "Working CLASSPATH: %s\n",
vm_args.classpath);
}
- JNI_CreateJavaVM(&RETVAL, &jplcurenv, &vm_args);
+ if (JNI_CreateJavaVM(&RETVAL, &jplcurenv, &vm_args) < 0) {
+ croak("Unable to create instance of JVM");
+ }
if (jpldebug) {
fprintf(stderr, "Created Java VM.\n");
}
+
}
}
--- /dev/null
+=head1 NAME
+
+Tutorial - Perl and Java
+
+=head1 SYNOPSIS
+
+Java and Perl have different strengths and complement each other well.
+
+You can connect them at runtime with tools such as JPL, PJC, or
+ActiveX. In theory, you can convert Perl to Java bytecode, and
+vice-versa.
+
+=head2 Note:
+
+Not actually a conversion.
+
+At this stage, we are generating Java opcodes by walking Perl's syntax
+tree. This is very different from converting Perl to Java. It's a lot
+easier!
+
+=head1 1.1 Perl and Java, Compared
+
+Perl offers rich text processing features, high-level network APIs,
+excellent database integration, and a centralized repository of
+reusable code:
+
+=over 4
+
+=item *
+
+Regular expression engine is a powerful sub language that can perform
+complex text manipulations and extract data.
+
+=item *
+
+Packages such as libwww-perl (LWP) and libnet are powerful, high-level
+interfaces to network functionality.
+
+=item *
+
+The Perl DBI is an interface to SQL data sources.
+
+=item *
+
+CPAN provides a centralized, organized archive of reusable code.
+
+=back
+
+Java has a powerful graphical API, has numerous embedded
+implementations, excellent database integration, but no single
+recognized repository of reusable code.
+
+=over 4
+
+=item *
+
+The Swing (JFC) toolkit is a powerful toolkit for developing user
+interfaces. Java also boasts 2D and 3D graphics APIs.
+
+=item *
+
+Java comes in embedded flavors, such as:
+
+=over 4
+
+=item *
+
+Kaffe C<http://www.transvirtual.com/> - embedded implementations for
+different platforms
+
+=item *
+
+Waba C<http://www.wabasoft.com/> - a subset of Java for Windows CE and
+PalmOS
+
+=item *
+
+It's embedded into web browsers (Netscape and MS Internet Explorer)
+
+=item *
+
+and more...
+
+=back
+
+=item *
+
+Java's JDBC is similar to Perl's DBI
+
+=item *
+
+Java has many different repositories of code. Efforts such as the
+Giant Java Tree C<http://www.gjt.org/> attempt to create a unified
+repository.
+
+=back
+
+=head1 1.2 Opportunities to Combine Java and Perl
+
+You have a Java program with a lot of data that needs to be parsed,
+filed, briefed, debriefed, and numbered.
+
+You want to build your GUI in Java, but let Perl do the heavy lifting.
+
+You've adopted the "Java is a systems language, Perl is a scripting
+language" paradigm, and it works for you.
+
+You're not sure which regex implementation to use:
+
+C<org.teeth.green.loony.raving.monster.regex.*;>
+
+C<com.zeppelin.regex.*;>
+
+You want the I<B<best of both worlds>>.
+
+=head1 1.3 Important Differences between Java and Perl
+
+=over 4
+
+=item *
+
+C<perl> compiles and executes programs each time you run them (unless you
+use the Perl compiler).
+
+=item *
+
+C<javac> compiles programs in advance, C<java> runs them in the Java
+interpreter.
+
+=item *
+
+The Java interpreter supports method overloading (methods can have the
+same name, but are differentiated on the basis of their argument
+types). Overloaded methods generally perform the same function, but
+methods with a shorter argument list often use defaults:
+
+=back
+
+ // Draw a circle in the center of the screen
+ int drawCircle(int radius);
+
+ // Draw a circle at specified coordinates
+ int drawCircle(int radius, int h, int k);
+
+=over 4
+
+=item *
+
+The Perl interpreter doesn't support method overloading. In JPL, when
+we call Java from Perl, we need to use some tricks to specify the Java
+method we want to invoke. We'll learn about this when we see JPL's
+C<getmeth> function.
+
+=back
+
+=head2 Note:
+
+At the time this presentation was prepared, JPL did not work with Perl
+for Win32. However, JPL is in the core Perl distribution, and there
+are plans to make it work with Perl for Win32.
+
+With that in mind, I'm presenting the JPL material first, because it
+is of interest to both Win32 and Unix Perl people. The Win32-specific
+stuff (alternatives to JPL) will come last. I won't be offended if the
+Unix people leave when I move to this section of the tutorial, since
+there is no Unix material in that section. I'm perfectly happy to take
+questions between JPL and ActiveX sections.
+
+A subset of JPL now works on Win32. You can embed Java in Perl, but
+you cannot embed Perl in Java (yet).
+
+=head1 2.1 JPL Overview
+
+Let's look at an overview of JPL.
+
+=head2 2.1.1 Calling Perl from Java
+
+Well-supported by JPL, but it is a complicated process:
+
+=over 4
+
+=item *
+
+The JPL preprocessor parses the I<.jpl> file and generates C code
+wrappers for Perl methods. It also generates Java and Perl source
+files.
+
+=item *
+
+The C compiler compiles the wrapper and links it to the
+I<libPerlInterpreter.so> shared library, producing a shared library for
+the wrapper.
+
+=item *
+
+The Java compiler compiles the Java source file, which uses native
+methods to load the wrapper.
+
+=item *
+
+The wrapper connects the Java code to the Perl code in the Perl source
+file.
+
+=back
+
+Fortunately, a generic F<Makefile.PL> simplifies the process. This is a
+Perl script that generates a I<Makefile> for you.
+
+=head2 2.1.2 Calling Java from Perl
+
+This works best when Perl is embedded within a Java program.
+
+The JNI Perl module creates and loads a JVM. There is no precompiler,
+nothing extra -- it's just a Perl module and extension.
+
+ B<A Problem, Though>. In theory, you can call Java from standalone
+ Perl programs, but this doesn't work because some implementations
+ of Java use a user-level threads package (green threads) that
+ override some functions in the C library. Perl is comfortable
+ using these functions, but Java is not happy using the standard C
+ library functions.
+
+So, with green threads, you can't reliably embed Java in a standalone
+Perl program.
+
+Many Java implementations now use native threads. JPL has been tested
+on Solaris with JDK 1.1.x and native threads, but not on Linux.
+
+=head2 Note:
+
+Oddly enough, this is the only way it works on Win32.
+
+On Unix, I've still had trouble, even with native threads. I might
+need to recompile perl with -DREENTRANT, but I'm not sure.
+
+
+=head1 2.2 Working with JPL
+
+How to set up a JPL application, compile, and install it.
+
+=head2 2.2.1 Setting up a Project
+
+=over 4
+
+=item 1
+
+The I<install-jpl> script creates the I<setvars> script. Source the
+output of I<setvars> into your shell when you want to develop or run
+JPL applications.
+
+=item 2
+
+Create a directory with the name of your project, such as
+I<Frotz>. (if you want to use the generic F<Makefile.PL>, you need a
+separate directory for each JPL class you create).
+
+=item 3
+
+Copy the generic F<Makefile.PL> into the project directory. The
+I<jpl/Sample> directory in the Perl distribution includes the generic
+F<Makefile.PL>.
+
+=item 4
+
+Write a I<.jpl> program with the same name as the project (such as
+F<Frotz.jpl>)
+
+=back
+
+=head2 2.2.2 Compiling and Installing a Project
+
+Type C<make> to compile the application, and C<make install> to
+install it. This installs the application in the I<jpl> directory you
+created when you installed JPL.
+
+ B<Beware>. The default I<jpl> directory is the same as the
+ directory you install it I<from>. If you go with the default and
+ delete your Perl source, you'll delete your JPL installation!
+
+Type C<java Frotz> (or the name you chose in step 2 of section 2.2.1)
+to run it
+
+=head2 2.2.3 What's in the jpl Directory?
+
+=over 4
+
+=item *
+
+B<libPerlInterpreter.so>: a shared library that loads the Perl
+interpreter.
+
+=item *
+
+Compiled F<.class> files for JPL applications you have written.
+
+=item *
+
+Native code shared library wrappers for JPL applications you have
+written.
+
+=item *
+
+Perl scripts that contain the Perl code to load at runtime.
+
+=back
+
+ Beware. If you issue the C<make> command and then run the examples
+ in your development directory, you might be in for a surprise! If
+ the JPL directories come first in your CLASSPATH and
+ LD_LIBRARY_PATH, you'll keep running the installed, older version,
+ rather than the one you are developing
+
+=head2 Note:
+
+"Source" means to load it into your current shell, with something
+like:
+
+C<eval-backtick-setvars-backtick>
+
+as opposed to just executing it, because then only the subshell gets
+the environment vars.
+
+=head1 2.3 Calling Perl from Java
+
+Now, we'll look at how you can invoke Perl from Java.
+
+=head2 2.3.1 Perl Methods
+
+You can put Perl methods in your F<.jpl> file. Perl methods are
+declared C<perl> and use double curly braces to make life easier on
+the JPL preprocessor:
+
+ perl int perlMultiply(int a, int b) {{
+ my $result = $a * $b;
+ return $result;
+ }}
+
+In your Java code, you can invoke Perl methods like a Java method. The
+native code wrappers take care of running the Perl code:
+
+ public void invokePerlFunction() {
+ int x = 3;
+ int y = 6;
+ int retval = perlMultiply(x, y);
+ System.out.println(x + " * " + y + " = " + retval);
+ }
+
+class MethodDemo
+
+ class MethodDemo {
+ // A Perl method to multiply two numbers and
+ // return the result.
+ //
+ perl int perlMultiply(int a, int b) {{
+ my $result = $a * $b;
+ return $result;
+ }}
+
+ // A Java method to call the Perl function.
+ //
+ public void invokePerlFunction() {
+ int x = 3;
+ int y = 6;
+ int retval = perlMultiply(x, y);
+ System.out.println(x +" * "+ y +" = "+ retval);
+ }
+
+ public static void main(String[] args) {
+ MethodDemo demo = new MethodDemo();
+ demo.invokePerlFunction();
+ }
+ }
+
+=head2 Where did $self go?
+
+Don't worry, C<$self> is still there. JPL takes care of fetching it, as
+well as all the other arguments:
+
+ perl int perlMultiply(int a, int b) {{
+ my $result = $a * $b;
+ return $result;
+ }}
+
+ perl void calculateProduct() {{
+ my $x = 3;
+ my $y = 6;
+ my $retval = $self->perlMultiply($x, $y);
+ print "$x * $y = $retval\n";
+ }}
+
+ B<Note>. JPL takes care of putting all the arguments, including
+ C<$self>, into variables. If you see a variable in the function
+ header, you will get a variable of the same name without having to
+ use C<shift> or C<@_>, guaranteed.
+
+
+
+NOTE: I've added a line that prints the output of "ref dollar sign self"
+You'll see this when I run the demo.
+
+ class SelfDemo {
+
+ // A Perl method to multiply two values.
+ //
+ perl int perlMultiply(int a, int b) {{
+ my $result = $a * $b;
+ return $result;
+ }}
+
+ // A Perl method to invoke another Perl method.
+ //
+ perl void calculateProduct() {{
+ my $x = 3;
+ my $y = 6;
+ # Ahhh. There's our old friend, $self!
+ #
+ my $retval = $self->perlMultiply($x, $y);
+ # Display the results.
+ #
+ print "$x * $y = $retval\n";
+ }}
+
+ public static void main(String[] args) {
+ SelfDemo demo = new SelfDemo();
+ demo.calculateProduct();
+ }
+ }
+
+=head2 Passing Arrays
+
+If you pass an array from Java into a Perl method, it arrives in the
+form of a scalar reference.
+
+Use the GetIntArrayElements() JNI function to convert that scalar into
+an array of integers.
+
+ perl void min_max( int[] data ) {{
+
+ # Get the array elements
+ #
+ my @new_array = GetIntArrayElements( $data );
+
+ # Sort the array numerically
+ #
+ my @sorted = sort {$a <=> $b} @new_array;
+
+ print "Min: $sorted[0], ",
+ "Max: $sorted[$#sorted]\n";
+ }}
+
+ void minMaxDemo() {
+ int[] data = {101, 99, 42, 666, 23};
+ min_max( data );
+ }
+
+Some JNI Array Functions
+
+=over 4
+
+=item GetBooleanArrayElements( scalar)
+
+Converts scalar to an array of booleans.
+
+=item GetByteArrayElements( scalar )
+
+Converts scalar to an array of bytes.
+
+=item GetCharArrayElements( scalar )
+
+Converts scalar to an array of characters.
+
+=item GetShortArrayElements( scalar )
+
+Converts scalar to an array of short integers.
+
+=item GetIntArrayElements( scalar )
+
+Converts scalar to an array of integers.
+
+=item GetLongArrayElements( scalar )
+
+Converts scalar to an array of long integers.
+
+=item GetFloatArrayElements( scalar )
+
+Converts scalar to an array of floating point numbers.
+
+=item GetDoubleArrayElements( scalar )
+
+Converts scalar to an array of double precision numbers.
+
+=item GetArrayLength( scalar )
+
+Returns the length of the array.
+
+=back
+
+PerlTakesArray.jpl
+ // Show how to pass an array from Java to Perl.
+ //
+
+ public class PerlTakesArray {
+
+ perl void min_max( int[] data ) {{
+ # Get the array elements
+ #
+ my @new_array = GetIntArrayElements( $data );
+
+ # Sort the array numerically
+ #
+ my @sorted = sort {$a <=> $b} @new_array;
+ print "Min: $sorted[0], ",
+ "Max: $sorted[$#sorted]\n";
+ }}
+
+ void minMaxDemo() {
+ // Create an array and ask Perl to tell us
+ // the min and max values.
+ int[] data = {101, 99, 42, 666, 23};
+ min_max( data );
+ }
+
+ public static void main(String[] argv) {
+ PerlTakesArray demo = new PerlTakesArray();
+ demo.minMaxDemo();
+ }
+
+ }
+
+=head2 2.3.4 Passing Arrays of Objects
+
+Working with arrays of objects is a little more complicated, because you
+need to work with them one at a time.
+
+Fetch one element at a time with GetObjectArrayElement(), which returns
+an object of type java.lang.Object (the most generic type).
+
+Explicitly cast the Object to its real type with bless().
+
+ perl void sortArray( String[] names ) {{
+ my @new_array;
+ for (my $i = 0; $i < GetArrayLength($names); $i++) {
+ my $string = GetObjectArrayElement($names, $i);
+ bless $string, "java::lang::String";
+ push @new_array, $string;
+ }
+ print join(', ', sort @new_array), "\n";
+ }}
+
+ void arrayDemo() {
+ String[] names = {"Omega", "Gamma", "Beta", "Alpha"};
+ sortArray( names );
+ }
+
+Note. String is not a primitive type: it is a class (java.lang.String).
+So, you need to use this technique for Strings as well. You can't use
+the technique in 2.3.3.
+
+PerlTakesObjectArray.jpl
+
+ public class PerlTakesObjectArray {
+
+ // Perl method to sort an array of strings.
+ //
+ perl void sortArray( String[] names ) {{
+ my @new_array; # an array to copy names[] to
+
+ # Fetch each element from the array.
+ for (my $i = 0; $i < GetArrayLength($names); $i++) {
+
+ # Get the object (it's not a String yet!) at
+ # the current index ($i).
+ my $string = GetObjectArrayElement($names, $i);
+
+ # Cast (bless) it into a String.
+ bless $string, "java::lang::String";
+
+ # Add it to the array.
+ push @new_array, $string;
+ }
+
+ # Print the sorted, comma-delimited array.
+ print join(', ', sort @new_array), "\n";
+
+ }}
+
+ // Create a String array and ask Perl to sort it for us.
+ //
+
+ void arrayDemo() {
+ String[] names = {"Omega", "Gamma", "Beta", "Alpha"};
+ sortArray( names );
+ }
+
+ public static void main(String[] argv) {
+ PerlTakesObjectArray demo = new PerlTakesObjectArray();
+ demo.arrayDemo();
+ }
+ }
+
+=head2 2.3.5 Returning Arrays from Perl to Java
+
+To write a Perl method that returns an array, declare its return value
+as an array type. Make sure you return a reference to the array, not a
+list:
+
+ perl int[] getTime() {{
+ my ($sec, $min, $hour, @unused) = localtime(time);
+ # Return an array with seconds, minutes, hours
+ my @time_array = ($sec, $min, $hour);
+ return \@time_array;
+ }}
+
+ void testArray() {
+ int time[] = getTime();
+ System.out.println(time[2] + ":" + time[1]);
+ }
+
+PerlGivesArray.jpl
+
+ // Simple JPL demo to show how to send an array to Java
+ // from Perl
+
+ class PerlGivesArray {
+ // Call the Perl method to get an array and print
+ // the hour and minute elements.
+
+ void testArray() {
+ int time[] = getTime();
+ System.out.println(time[2] + ":" + time[1]);
+ }
+
+ // Perl method that returns an array reference.
+ //
+ perl int[] getTime() {{
+ # Get the first three arguments from localtime,
+ # discard the rest.
+ my ($sec, $min, $hour, @unused) = localtime(time);
+
+ # Return an array with seconds, minutes, hours
+ my @time_array = ($sec, $min, $hour);
+ return \@time_array;
+ }}
+
+ public static void main(String[] argv) {
+ PerlGivesArray demo = new PerlGivesArray();
+ demo.testArray();
+ }
+ }
+
+=head2 2.3.6 Arrays from Strings
+
+JPL will slice Perl strings up into Java arrays for you. If you declare
+a Perl method as an array type and return a string (instead of an array
+reference), JPL splits up the elements into an array.
+
+Consider this example, where a GIF stored in a string gets turned into
+an array of bytes so Java can make an Image out of it:
+
+ void generateImage() {
+ Toolkit kit = Toolkit.getDefaultToolkit();
+ byte[] image_data = mkImage();
+ img = kit.createImage( image_data );
+ }
+
+ perl byte[] mkImage() {{
+ use GD;
+ my $im = new GD::Image( $self->width, $self->height);
+ my $white = $im->colorAllocate(255, 255, 255);
+ my $blue = $im->colorAllocate(0, 0, 255);
+ $im->fill($white, 0, 0);
+ $im->string(gdLargeFont, 10, 10, "Hello, World", $blue);
+ return $im->gif;
+ }}
+
+GifDemo.jpl
+
+ import java.awt.*;
+ import java.awt.event.*;
+ import java.awt.image.*;
+
+ /*
+ * A JPL program that demonstrates passing byte arrays
+ * between Java and Perl
+ *
+ */
+
+ class GIFDemo extends Canvas {
+ Image img;
+ int width = 200;
+ int height = 30;
+
+ // Constructor for this class.
+ public GIFDemo() {
+ this.setSize(width, height);
+ }
+
+ // Java method to create an image.
+ //
+ void generateImage() {
+ Toolkit kit = Toolkit.getDefaultToolkit();
+
+ // Invoke the mkImage() Perl method to generate an
+ // image.
+
+ byte[] image_data = mkImage();
+
+ // Create the image with the byte array we got
+ // from the Perl method.
+
+ img = kit.createImage( image_data );
+ }
+
+ // A Perl method to generate an image.
+
+ perl byte[] mkImage() {{
+
+ # Use the GD image manipulation extension.
+
+ use GD;
+
+ # Create a new image with the height and width specified
+ # in the enclosing Java class.
+
+ my $im = new GD::Image( $self->width, $self->height);
+
+ # Allocate two colors.
+
+ my $white = $im->colorAllocate(255, 255, 255);
+ my $blue = $im->colorAllocate(0, 0, 255);
+
+ # Fill the image with white and draw a greeting.
+
+ $im->fill($white, 0, 0);
+ $im->string(gdLargeFont, 10, 10,
+ "Hello, World", $blue);
+ return $im->gif;
+ }}
+
+ // Java uses this to repaint the image when necessary.
+
+ public void paint(Graphics g) {
+ g.drawImage(img, 0, 0, this);
+ }
+
+ // The entry point.
+
+ public static void main(String[] argv) {
+
+ // Set up a frame and create an image.
+
+ Frame f = new Frame("GD Example");
+ f.setLayout(new BorderLayout());
+
+ GIFDemo demo = new GIFDemo();
+ demo.generateImage();
+
+ f.add("Center", demo);
+ f.addWindowListener( new Handler() );
+
+ f.pack();
+ f.show();
+
+ }
+ }
+
+ // A handler to process a request to close a window.
+
+ class Handler extends WindowAdapter {
+ public void windowClosing(WindowEvent e) {
+ System.exit(0);
+ }
+ }
+
+=head2 2.3.7 Summary: Calling Perl from Java
+
+=over 4
+
+=item 1
+
+Put your embedded Perl code in methods that are declared C<perl>.
+
+=item 2
+
+Use double, rather than single, curly braces ({{ and }}).
+
+=item 3
+
+Invoke the Perl methods from Java just like any other Java method.
+
+=item 4
+
+No need to pull arguments off of C<@_> with C<shift>: JPL takes care of
+this for you. This includes C<$self>.
+
+=item 5
+
+If you pass a Java array into a Perl method, it comes in as a scalar
+reference.
+
+=item 6
+
+Convert references to arrays of primitives with C<Get*ArrayElements>
+
+=item 7
+
+Use C<GetObjectArrayElement> to get elements from arrays of strings and
+other objects.
+
+=item 8
+
+To return an array from a C<perl> method, declare the method as returning
+an array type, and either:
+
+=item 9
+
+Return an array reference.
+
+=item 10
+
+Return a string: JPL slices it up for you.
+
+=back
+
+=head1 2.4 Calling Java from Perl
+
+Next, let's look at how to invoke Java from Perl.
+
+=head2 2.4.1 Java in Perl in Java
+
+Remember the issues from 2.1.2 - this is unstable unless you are calling Java from Perl methods that are themselves embedded in a Java program.
+
+=head2 2.4.2 Java in Perl: Simple Constructors
+
+Use JPL::Class to load the class:
+
+C<use JPL::Class "java::awt::Frame";>
+
+Invoke the constructor to create an instance of the class:
+
+C<my $f = java::awt::Frame->new;>
+
+You've got a reference to a Java object in $f, a Perl scalar. I think
+this is cool.
+
+=head2 2.4.3 Constructors that Take Parameters
+
+If the constructor has parameters, look up the method signature with
+C<getmeth>:
+
+my $new = getmeth("new", ['java.lang.String'], []);
+
+The first argument to C<getmeth> is the name of the method. The second
+argument is a reference to an array that contains a list of the argument
+types. The final argument to C<getmeth> is a reference to an array
+containing a single element with the return type. Constructors always
+have a null (void) return type, even though they return an instance of
+an object.
+
+Invoke the method through the variable you created:
+
+my $f = java::awt::Frame->$new( "Frame Demo" );
+
+Because Java supports method overloading, the only way Java can
+distinguish between different methods that have the same name is through
+the method signature. The C<getmeth> function simply returns a mangled,
+Perl-friendly version of the signature. JPL's AutoLoader takes care of
+finding the right class.
+
+For example, the method signature for $new is C<(Ljava/lang/String;)V>.
+In Perl, this is translated to C<new__Ljava_lang_String_2__V>. Sure, it
+means something to Java, but thanks to C<getmeth> and JPL's AutoLoader,
+we don't have to worry about it!
+
+=head2 2.4.4 More on getmeth
+
+The C<getmeth> function is not just for constructors. You'll use it to look
+up method signatures for any method that takes arguments.
+
+To use C<getmeth>, just supply the Java names of the types and objects in
+the argument or return value list. Here are a few examples:
+
+=over 4
+
+=item *
+
+Two int arguments, void return type:
+
+ $setSize = getmeth("setSize", ['int', 'int'], []);
+
+=item *
+
+One argument (java.awt.Component), with a return type of the same:
+
+ $add = getmeth("add", ['java.awt.Component'],
+
+ ['java.awt.Component']);
+
+=item *
+
+Two arguments, a String object and a boolean value, and a void return
+type:
+
+ $new = getmeth("new",
+
+ ['java.lang.String', 'boolean'], []);
+
+=item *
+
+A String argument with a java.lang.Class return type:
+
+ $forName = getmeth("forName",
+
+ ['java.lang.String'],
+
+ ['java.lang.Class']);
+
+=item *
+
+No arguments, but a boolean return value:
+
+ $next = getmeth("next", [], ['boolean']);
+
+=back
+
+=head2 2.4.5 Instance Variables
+
+Java instance variables that belong to a class can be reached through
+$self and a method with the same name as the instance variables:
+
+ $frame->$setSize( $self->width, $self->height );
+
+Here is an example:
+
+ class VarDemo {
+
+ int foo = 100;
+
+ perl int perlChange() {{
+ my $current_value = $self->foo;
+
+ # Change foo to ten times itself.
+
+ $self->foo( $current_value * 10 );
+
+ }}
+
+ void executeChange() {
+
+ perlChange();
+ System.out.println(foo);
+
+ }
+
+ public static void main(String[] args) {
+
+ VarDemo demo = new VarDemo();
+ demo.executeChange();
+
+ }
+
+ }
+
+Note. JPL creates these methods with the same name as the variable. You
+can also supply a value to set the variable's value. If you create a
+method with this name, it will collide with the one that JPL defines.
+
+FrameDemo.jpl
+
+ /*
+ * FrameDemo - create and show a Frame in Perl.
+ *
+ */
+
+ public class FrameDemo {
+
+ int height = 50;
+ int width = 200;
+ perl void make_frame () {{
+
+ # Import two Java classes.
+
+ use JPL::Class "java::awt::Frame";
+ use JPL::Class "java::awt::Button";
+
+ # Create a Frame and a Button. The two calls to new()
+ # have the same signature.
+
+ my $new = getmeth("new", ['java.lang.String'], []);
+ my $frame = java::awt::Frame->$new( "Frame Demo" );
+ my $btn = java::awt::Button->$new( "Do Not Press Me" );
+
+ # Add the button to the frame.
+
+ my $add = getmeth("add", ['java.awt.Component'],
+ ['java.awt.Component']);
+ $frame->$add( $btn );
+
+ # Set the size of the frame and show it.
+
+ my $setSize = getmeth("setSize", ['int', 'int'], []);
+ $frame->$setSize($self->width, $self->height);
+ $frame->show;
+
+ }}
+
+ public static void main(String[] argv) {
+
+ FrameDemo demo = new FrameDemo();
+ demo.make_frame();
+
+ }
+
+ }
+
+=head2 2.4.6 Summary: Calling Java from Perl
+
+=over 4
+
+=item 1
+
+Use JPL::Class to specify a Java class to import.
+
+=item 2
+
+You can directly invoke constructors and methods that take no arguments.
+
+=item 3
+
+If the constructor or method takes arguments, use getmeth to look up its
+signature.
+
+=item 4
+
+Use $self to access Java instance variables and methods.
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright (c) 1999, Brian Jepson
+
+You may distribute this file under the same terms as Perl itself.
+
+Converted from FrameMaker by Kevin Falcone.
+
+=cut
projects / p5sagit/p5-mst-13.2.git / commitdiff