#include "perl.h"
#include "XSUB.h"
-#include <perl.h>
+#include <stdio.h>
#include <jni.h>
-#include <dlfcn.h>
+#ifndef PERL_VERSION
+# include <patchlevel.h>
+# define PERL_REVISION 5
+# define PERL_VERSION PATCHLEVEL
+# define PERL_SUBVERSION SUBVERSION
+#endif
+
+#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
+# define PL_dowarn dowarn
+#endif
+
+#ifndef newSVpvn
+# define newSVpvn(a,b) newSVpv(a,b)
+#endif
+
+#ifndef pTHX
+# define pTHX void
+# define pTHX_
+# define aTHX
+# define aTHX_
+# define dTHX extern int JNI___notused
+#endif
+
+#ifndef WIN32
+# include <dlfcn.h>
+#endif
+
+#ifdef EMBEDDEDPERL
extern JNIEnv* jplcurenv;
extern int jpldebug;
+#else
+JNIEnv* jplcurenv;
+int jpldebug = 1;
+#endif
#define SysRet jint
-static void
-call_my_exit(jint status)
+#ifdef WIN32
+static void JNICALL call_my_exit(jint status)
+{
+ my_exit(status);
+}
+#else
+static void call_my_exit(jint status)
{
- dTHX;
my_exit(status);
}
+#endif
jvalue*
-makeargs(pTHX_ char *sig, SV** svp, int items)
+makeargs(char *sig, SV** svp, int items)
{
jvalue* jv = (jvalue*)safemalloc(sizeof(jvalue) * items);
int ix = 0;
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
int i;
SV** esv;
static jclass jcl = 0;
- jarray ja;
+ 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;
}
int i;
SV** esv;
static jclass jcl = 0;
- jarray 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)) {
- (*env)->SetObjectArrayElement(env, ja, i,
- (jobject)(void*)SvIV(rv));
+#ifdef WIN32
+ env->SetObjectArrayElement(ja, i, (jobject)(void*)SvIV(rv));
+#else
+ (*env)->SetObjectArrayElement(env, ja, i, (jobject)(void*)SvIV(rv));
+#endif
}
else {
- jobject str = (jobject)(*env)->NewStringUTF(env,
- SvPV(*esv,n_a));
+#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;
- jv[ix++].l = (jobject)(*env)->NewStringUTF(env,
- (char*) SvPV(sv,n_a));
+#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++;
}
break;
case ')':
- Perl_croak(aTHX_ "too many arguments, signature: %s", sig);
+ croak("too many arguments, signature: %s", sig);
goto cleanup;
default:
- Perl_croak(aTHX_ "panic: malformed signature: %s", s-1);
+ croak("panic: malformed signature: %s", s-1);
goto cleanup;
}
}
if (*s != ')') {
- Perl_croak(aTHX_ "not enough arguments, signature: %s", sig);
+ croak("not enough arguments, signature: %s", sig);
goto cleanup;
}
return jv;
}
static int
-not_here(pTHX_ char *s)
+not_here(char *s)
{
- Perl_croak(aTHX_ "%s not implemented on this architecture", s);
+ croak("%s not implemented on this architecture", s);
return -1;
}
#endif
if (strEQ(name, "JNI_H"))
#ifdef JNI_H
+#ifdef WIN32
+ return 1;
+#else
return JNI_H;
+#endif
#else
goto not_there;
#endif
JNIEnv * env = FETCHENV;
CODE:
{
+#ifdef WIN32
+ RETVAL = env->GetVersion();
+#else
RETVAL = (*env)->GetVersion(env);
+#endif
RESTOREENV;
}
OUTPUT:
const jbyte * buf
CODE:
{
- RETVAL = (*env)->DefineClass(env, name, loader, buf, (jsize)buf_len_);
+#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:
int argoff = $min_args;
CODE:
{
- jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
+ 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:
int argoff = $min_args;
CODE:
{
- jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
+ 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:
int argoff = $min_args;
CODE:
{
- jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
+ 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:
int argoff = $min_args;
CODE:
{
- jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
+ 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:
int argoff = $min_args;
CODE:
{
- jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
+ 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:
int argoff = $min_args;
CODE:
{
- jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
+ 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:
int argoff = $min_args;
CODE:
{
- jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
+ 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:
int argoff = $min_args;
CODE:
{
- jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
+ 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:
int argoff = $min_args;
CODE:
{
- jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
+ 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:
int argoff = $min_args;
CODE:
{
- jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
+ 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:
int argoff = $min_args;
CODE:
{
- jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
+ 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;
}
int argoff = $min_args;
CODE:
{
- jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
+ 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:
int argoff = $min_args;
CODE:
{
- jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
+ 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:
int argoff = $min_args;
CODE:
{
- jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
+ 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:
int argoff = $min_args;
CODE:
{
- jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
+ 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:
int argoff = $min_args;
CODE:
{
- jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
+ 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:
int argoff = $min_args;
CODE:
{
- jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
+ 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:
int argoff = $min_args;
CODE:
{
- jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
+ 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:
int argoff = $min_args;
CODE:
{
- jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
+ 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:
int argoff = $min_args;
CODE:
{
- jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
+ 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:
int argoff = $min_args;
CODE:
{
- jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
+ 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:
int argoff = $min_args;
CODE:
{
- jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
+ 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:
int argoff = $min_args;
CODE:
{
- jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
+ 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:
int argoff = $min_args;
CODE:
{
- jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
+ 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:
int argoff = $min_args;
CODE:
{
- jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
+ 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:
int argoff = $min_args;
CODE:
{
- jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
+ 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:
int argoff = $min_args;
CODE:
{
- jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
+ 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:
int argoff = $min_args;
CODE:
{
- jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
+ 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:
int argoff = $min_args;
CODE:
{
- jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
+ 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:
int argoff = $min_args;
CODE:
{
- jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
+ 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:
int argoff = $min_args;
CODE:
{
- jvalue * args = makeargs(aTHX_ sig, &ST(argoff), items - argoff);
+ 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:
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;
CODE:
{
if (buf_len_ < len)
- Perl_croak(aTHX_ "string is too short");
- else if (buf_len_ > len && ckWARN(WARN_UNSAFE))
- Perl_warner(aTHX_ WARN_UNSAFE, "string is too long");
+ 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;
}
CODE:
{
if (buf_len_ < len)
- Perl_croak(aTHX_ "string is too short");
- else if (buf_len_ > len && ckWARN(WARN_UNSAFE))
- Perl_warner(aTHX_ WARN_UNSAFE, "string is too long");
+ 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;
}
CODE:
{
if (buf_len_ < len)
- Perl_croak(aTHX_ "string is too short");
- else if (buf_len_ > len && ckWARN(WARN_UNSAFE))
- Perl_warner(aTHX_ WARN_UNSAFE, "string is too long");
+ 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;
}
CODE:
{
if (buf_len_ < len)
- Perl_croak(aTHX_ "string is too short");
- else if (buf_len_ > len && ckWARN(WARN_UNSAFE))
- Perl_warner(aTHX_ WARN_UNSAFE, "string is too long");
+ 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;
}
CODE:
{
if (buf_len_ < len)
- Perl_croak(aTHX_ "string is too short");
- else if (buf_len_ > len && ckWARN(WARN_UNSAFE))
- Perl_warner(aTHX_ WARN_UNSAFE, "string is too long");
+ 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;
}
CODE:
{
if (buf_len_ < len)
- Perl_croak(aTHX_ "string is too short");
- else if (buf_len_ > len && ckWARN(WARN_UNSAFE))
- Perl_warner(aTHX_ WARN_UNSAFE, "string is too long");
+ 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;
}
CODE:
{
if (buf_len_ < len)
- Perl_croak(aTHX_ "string is too short");
- else if (buf_len_ > len && ckWARN(WARN_UNSAFE))
- Perl_warner(aTHX_ WARN_UNSAFE, "string is too long");
+ 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;
}
CODE:
{
if (buf_len_ < len)
- Perl_croak(aTHX_ "string is too short");
- else if (buf_len_ > len && ckWARN(WARN_UNSAFE))
- Perl_warner(aTHX_ WARN_UNSAFE, "string is too long");
+ 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:
CODE:
{
if (env) { /* We're embedded. */
+#ifdef WIN32
+ if (env->GetJavaVM(&RETVAL) < 0)
+#else
if ((*env)->GetJavaVM(env, &RETVAL) < 0)
+#endif
RETVAL = 0;
}
else { /* We're embedding. */
- JDK1_1InitArgs vm_args;
+#ifdef KAFFE
+ JavaVMInitArgs vm_args;
+#else
+ JDK1_1InitArgs vm_args;
+#endif
char *lib;
+ if (jpldebug) {
+ fprintf(stderr, "We're embedding Java in Perl.\n");
+ }
if (items--) {
++mark;
}
else
lib = 0;
-
+ if (jpldebug) {
+ fprintf(stderr, "lib is %s.\n", lib);
+ }
+#ifdef WIN32
+ if (!LoadLibrary("javai.dll")) {
+ if (lib && !LoadLibrary(lib))
+ croak("Can't load javai.dll");
+ }
+#else
+ if (jpldebug) {
+ fprintf(stderr, "Opening Java shared library.\n");
+ }
+#ifdef KAFFE
+ if (!dlopen("libkaffevm.so", RTLD_LAZY|RTLD_GLOBAL)) {
+#else
if (!dlopen("libjava.so", RTLD_LAZY|RTLD_GLOBAL)) {
+#endif
if (lib && !dlopen(lib, RTLD_LAZY|RTLD_GLOBAL))
- Perl_croak(aTHX_ "Can't load libjava.so");
+ croak("Can't load Java shared library.");
}
+#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 = SvPV(*mark,PL_na);
+ ++mark;
+ if (jpldebug) {
+ fprintf(stderr, "*s = %s\n", s);
+ fprintf(stderr, "val = %s\n", SvPV(*mark, PL_na));
+ }
items -= 2;
if (strEQ(s, "checkSource"))
- vm_args.checkSource = (jint)SvIV(*++mark);
+ vm_args.checkSource = (jint)SvIV(*mark);
else if (strEQ(s, "nativeStackSize"))
- vm_args.nativeStackSize = (jint)SvIV(*++mark);
+ vm_args.nativeStackSize = (jint)SvIV(*mark);
else if (strEQ(s, "javaStackSize"))
- vm_args.javaStackSize = (jint)SvIV(*++mark);
+ vm_args.javaStackSize = (jint)SvIV(*mark);
else if (strEQ(s, "minHeapSize"))
- vm_args.minHeapSize = (jint)SvIV(*++mark);
+ vm_args.minHeapSize = (jint)SvIV(*mark);
else if (strEQ(s, "maxHeapSize"))
- vm_args.maxHeapSize = (jint)SvIV(*++mark);
+ vm_args.maxHeapSize = (jint)SvIV(*mark);
else if (strEQ(s, "verifyMode"))
- vm_args.verifyMode = (jint)SvIV(*++mark);
+ vm_args.verifyMode = (jint)SvIV(*mark);
else if (strEQ(s, "classpath"))
- vm_args.classpath = savepv(SvPV(*++mark,PL_na));
+ vm_args.classpath = savepv(SvPV(*mark,PL_na));
else if (strEQ(s, "enableClassGC"))
- vm_args.enableClassGC = (jint)SvIV(*++mark);
+ vm_args.enableClassGC = (jint)SvIV(*mark);
else if (strEQ(s, "enableVerboseGC"))
- vm_args.enableVerboseGC = (jint)SvIV(*++mark);
+ vm_args.enableVerboseGC = (jint)SvIV(*mark);
else if (strEQ(s, "disableAsyncGC"))
- vm_args.disableAsyncGC = (jint)SvIV(*++mark);
+ vm_args.disableAsyncGC = (jint)SvIV(*mark);
+#ifndef KAFFE
else if (strEQ(s, "verbose"))
- vm_args.verbose = (jint)SvIV(*++mark);
+ vm_args.verbose = (jint)SvIV(*mark);
else if (strEQ(s, "debugging"))
- vm_args.debugging = (jboolean)SvIV(*++mark);
+ vm_args.debugging = (jboolean)SvIV(*mark);
else if (strEQ(s, "debugPort"))
- vm_args.debugPort = (jint)SvIV(*++mark);
+ vm_args.debugPort = (jint)SvIV(*mark);
+#endif
else
- Perl_croak(aTHX_ "unrecognized option: %s", s);
+ croak("unrecognized option: %s", s);
+ }
+
+ if (jpldebug) {
+ fprintf(stderr, "Creating Java VM...\n");
+ fprintf(stderr, "Working CLASSPATH: %s\n",
+ vm_args.classpath);
}
JNI_CreateJavaVM(&RETVAL, &jplcurenv, &vm_args);
+ if (jpldebug) {
+ fprintf(stderr, "Created Java VM.\n");
+ }
}
}
projects / p5sagit/p5-mst-13.2.git / commitdiff