Re-integrate mainline

[p5sagit/p5-mst-13.2.git] / jpl / JNI / JNI.xs

diff --git a/jpl/JNI/JNI.xs b/jpl/JNI/JNI.xs
index ee854c1..e5e0af3 100644 (file)
--- a/jpl/JNI/JNI.xs
+++ b/jpl/JNI/JNI.xs
@@ -8,24 +8,64 @@
 #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;
@@ -80,10 +120,18 @@ makeargs(pTHX_ char *sig, SV** svp, int items)
                        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;
                    }
@@ -93,8 +141,16 @@ makeargs(pTHX_ char *sig, SV** svp, int items)
                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
@@ -111,10 +167,18 @@ makeargs(pTHX_ char *sig, SV** svp, int items)
                        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;
                    }
@@ -124,8 +188,16 @@ makeargs(pTHX_ char *sig, SV** svp, int items)
                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
@@ -142,10 +214,18 @@ makeargs(pTHX_ char *sig, SV** svp, int items)
                        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;
                    }
@@ -155,8 +235,16 @@ makeargs(pTHX_ char *sig, SV** svp, int items)
                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
@@ -173,10 +261,18 @@ makeargs(pTHX_ char *sig, SV** svp, int items)
                        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;
                    }
@@ -186,8 +282,16 @@ makeargs(pTHX_ char *sig, SV** svp, int items)
                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
@@ -204,10 +308,18 @@ makeargs(pTHX_ char *sig, SV** svp, int items)
                        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;
                    }
@@ -217,8 +329,16 @@ makeargs(pTHX_ char *sig, SV** svp, int items)
                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
@@ -235,10 +355,18 @@ makeargs(pTHX_ char *sig, SV** svp, int items)
                        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;
                    }
@@ -248,8 +376,16 @@ makeargs(pTHX_ char *sig, SV** svp, int items)
                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
@@ -266,10 +402,18 @@ makeargs(pTHX_ char *sig, SV** svp, int items)
                        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;
                    }
@@ -279,8 +423,16 @@ makeargs(pTHX_ char *sig, SV** svp, int items)
                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
@@ -297,10 +449,18 @@ makeargs(pTHX_ char *sig, SV** svp, int items)
                        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;
                    }
@@ -310,8 +470,16 @@ makeargs(pTHX_ char *sig, SV** svp, int items)
                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
@@ -330,14 +498,30 @@ makeargs(pTHX_ char *sig, SV** svp, int items)
                            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;
                        }
@@ -359,20 +543,38 @@ makeargs(pTHX_ char *sig, SV** svp, int items)
                        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;
@@ -388,8 +590,11 @@ makeargs(pTHX_ char *sig, SV** svp, int items)
        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++;
@@ -400,16 +605,16 @@ makeargs(pTHX_ char *sig, SV** svp, int items)
            }
            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;
@@ -420,9 +625,9 @@ cleanup:
 }
 
 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;
 }
 
@@ -476,7 +681,11 @@ constant(char *name, int arg)
 #endif
        if (strEQ(name, "JNI_H"))
 #ifdef JNI_H
+#ifdef WIN32
+           return 1;
+#else
            return JNI_H;
+#endif
 #else
            goto not_there;
 #endif
@@ -551,7 +760,11 @@ GetVersion()
        JNIEnv *                env = FETCHENV;
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->GetVersion();
+#else
            RETVAL = (*env)->GetVersion(env);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -567,7 +780,19 @@ DefineClass(name, loader, buf)
        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:
@@ -579,7 +804,11 @@ FindClass(name)
        const char *            name
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->FindClass( name);
+#else
            RETVAL = (*env)->FindClass(env,  name);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -591,7 +820,11 @@ GetSuperclass(sub)
        jclass                  sub
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->GetSuperclass( sub);
+#else
            RETVAL = (*env)->GetSuperclass(env,  sub);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -604,7 +837,11 @@ IsAssignableFrom(sub, sup)
        jclass                  sup
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->IsAssignableFrom( sub, sup);
+#else
            RETVAL = (*env)->IsAssignableFrom(env,  sub, sup);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -616,7 +853,11 @@ Throw(obj)
        jthrowable              obj
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->Throw( obj);
+#else
            RETVAL = (*env)->Throw(env,  obj);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -629,7 +870,11 @@ ThrowNew(clazz, msg)
        const char *            msg
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->ThrowNew( clazz, msg);
+#else
            RETVAL = (*env)->ThrowNew(env,  clazz, msg);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -640,7 +885,11 @@ ExceptionOccurred()
        JNIEnv *                env = FETCHENV;
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->ExceptionOccurred();
+#else
            RETVAL = (*env)->ExceptionOccurred(env);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -651,7 +900,11 @@ ExceptionDescribe()
        JNIEnv *                env = FETCHENV;
     CODE:
        {
+#ifdef WIN32
+           env->ExceptionDescribe();
+#else
            (*env)->ExceptionDescribe(env);
+#endif
            RESTOREENV;
        }
 
@@ -660,7 +913,11 @@ ExceptionClear()
        JNIEnv *                env = FETCHENV;
     CODE:
        {
+#ifdef WIN32
+           env->ExceptionClear();
+#else
            (*env)->ExceptionClear(env);
+#endif
            RESTOREENV;
        }
 
@@ -670,7 +927,11 @@ FatalError(msg)
        const char *            msg
     CODE:
        {
+#ifdef WIN32
+           env->FatalError( msg);
+#else
            (*env)->FatalError(env,  msg);
+#endif
            RESTOREENV;
        }
 
@@ -680,7 +941,11 @@ NewGlobalRef(lobj)
        jobject                 lobj
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->NewGlobalRef(lobj);
+#else
            RETVAL = (*env)->NewGlobalRef(env, lobj);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -692,7 +957,11 @@ DeleteGlobalRef(gref)
        jobject                 gref
     CODE:
        {
+#ifdef WIN32
+           env->DeleteGlobalRef(gref);
+#else
            (*env)->DeleteGlobalRef(env, gref);
+#endif
            RESTOREENV;
        }
 
@@ -702,7 +971,11 @@ DeleteLocalRef(obj)
        jobject                 obj
     CODE:
        {
+#ifdef WIN32
+           env->DeleteLocalRef( obj);
+#else
            (*env)->DeleteLocalRef(env,  obj);
+#endif
            RESTOREENV;
        }
 
@@ -713,7 +986,11 @@ IsSameObject(obj1,obj2)
        jobject                 obj2
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->IsSameObject(obj1,obj2);
+#else
            RETVAL = (*env)->IsSameObject(env, obj1,obj2);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -725,7 +1002,11 @@ AllocObject(clazz)
        jclass                  clazz
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->AllocObject(clazz);
+#else
            RETVAL = (*env)->AllocObject(env, clazz);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -740,8 +1021,12 @@ NewObject(clazz,methodID,...)
        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:
@@ -756,7 +1041,11 @@ NewObjectA(clazz,methodID,args)
        jvalue *                args
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->NewObjectA(clazz,methodID,args);
+#else
            RETVAL = (*env)->NewObjectA(env, clazz,methodID,args);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -768,7 +1057,11 @@ GetObjectClass(obj)
        jobject                 obj
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->GetObjectClass(obj);
+#else
            RETVAL = (*env)->GetObjectClass(env, obj);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -781,7 +1074,11 @@ IsInstanceOf(obj,clazz)
        jclass                  clazz
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->IsInstanceOf(obj,clazz);
+#else
            RETVAL = (*env)->IsInstanceOf(env, obj,clazz);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -795,7 +1092,11 @@ GetMethodID(clazz,name,sig)
        const char *            sig
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->GetMethodID(clazz,name,sig);
+#else
            RETVAL = (*env)->GetMethodID(env, clazz,name,sig);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -810,8 +1111,12 @@ CallObjectMethod(obj,methodID,...)
        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:
@@ -826,7 +1131,11 @@ CallObjectMethodA(obj,methodID,args)
        jvalue *                args
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->CallObjectMethodA(obj,methodID,args);
+#else
            RETVAL = (*env)->CallObjectMethodA(env, obj,methodID,args);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -841,8 +1150,12 @@ CallBooleanMethod(obj,methodID,...)
        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:
@@ -857,7 +1170,11 @@ CallBooleanMethodA(obj,methodID, args)
        jvalue *                args
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->CallBooleanMethodA(obj,methodID, args);
+#else
            RETVAL = (*env)->CallBooleanMethodA(env, obj,methodID, args);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -872,8 +1189,12 @@ CallByteMethod(obj,methodID,...)
        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:
@@ -888,7 +1209,11 @@ CallByteMethodA(obj,methodID,args)
        jvalue *                args
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->CallByteMethodA(obj,methodID,args);
+#else
            RETVAL = (*env)->CallByteMethodA(env, obj,methodID,args);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -903,8 +1228,12 @@ CallCharMethod(obj,methodID,...)
        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:
@@ -919,7 +1248,11 @@ CallCharMethodA(obj,methodID,args)
        jvalue *                args
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->CallCharMethodA(obj,methodID,args);
+#else
            RETVAL = (*env)->CallCharMethodA(env, obj,methodID,args);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -934,8 +1267,12 @@ CallShortMethod(obj,methodID,...)
        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:
@@ -950,7 +1287,11 @@ CallShortMethodA(obj,methodID,args)
        jvalue *                args
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->CallShortMethodA(obj,methodID,args);
+#else
            RETVAL = (*env)->CallShortMethodA(env, obj,methodID,args);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -965,8 +1306,12 @@ CallIntMethod(obj,methodID,...)
        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:
@@ -981,7 +1326,11 @@ CallIntMethodA(obj,methodID,args)
        jvalue *                args
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->CallIntMethodA(obj,methodID,args);
+#else
            RETVAL = (*env)->CallIntMethodA(env, obj,methodID,args);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -996,8 +1345,12 @@ CallLongMethod(obj,methodID,...)
        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:
@@ -1012,7 +1365,11 @@ CallLongMethodA(obj,methodID,args)
        jvalue *                args
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->CallLongMethodA(obj,methodID,args);
+#else
            RETVAL = (*env)->CallLongMethodA(env, obj,methodID,args);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -1027,8 +1384,12 @@ CallFloatMethod(obj,methodID,...)
        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:
@@ -1043,7 +1404,11 @@ CallFloatMethodA(obj,methodID,args)
        jvalue *                args
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->CallFloatMethodA(obj,methodID,args);
+#else
            RETVAL = (*env)->CallFloatMethodA(env, obj,methodID,args);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -1058,8 +1423,12 @@ CallDoubleMethod(obj,methodID,...)
        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:
@@ -1074,7 +1443,11 @@ CallDoubleMethodA(obj,methodID,args)
        jvalue *                args
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->CallDoubleMethodA(obj,methodID,args);
+#else
            RETVAL = (*env)->CallDoubleMethodA(env, obj,methodID,args);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -1089,8 +1462,12 @@ CallVoidMethod(obj,methodID,...)
        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;
        }
 
@@ -1103,7 +1480,11 @@ CallVoidMethodA(obj,methodID,args)
        jvalue *                args
     CODE:
        {
+#ifdef WIN32
+           env->CallVoidMethodA(obj,methodID,args);
+#else
            (*env)->CallVoidMethodA(env, obj,methodID,args);
+#endif
            RESTOREENV;
        }
 
@@ -1117,8 +1498,12 @@ CallNonvirtualObjectMethod(obj,clazz,methodID,...)
        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:
@@ -1134,7 +1519,11 @@ CallNonvirtualObjectMethodA(obj,clazz,methodID,args)
        jvalue *                args
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->CallNonvirtualObjectMethodA(obj,clazz,methodID,args);
+#else
            RETVAL = (*env)->CallNonvirtualObjectMethodA(env, obj,clazz,methodID,args);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -1150,8 +1539,12 @@ CallNonvirtualBooleanMethod(obj,clazz,methodID,...)
        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:
@@ -1167,7 +1560,11 @@ CallNonvirtualBooleanMethodA(obj,clazz,methodID, args)
        jvalue *                args
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->CallNonvirtualBooleanMethodA(obj,clazz,methodID, args);
+#else
            RETVAL = (*env)->CallNonvirtualBooleanMethodA(env, obj,clazz,methodID, args);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -1183,8 +1580,12 @@ CallNonvirtualByteMethod(obj,clazz,methodID,...)
        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:
@@ -1200,7 +1601,11 @@ CallNonvirtualByteMethodA(obj,clazz,methodID,args)
        jvalue *                args
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->CallNonvirtualByteMethodA(obj,clazz,methodID,args);
+#else
            RETVAL = (*env)->CallNonvirtualByteMethodA(env, obj,clazz,methodID,args);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -1216,8 +1621,12 @@ CallNonvirtualCharMethod(obj,clazz,methodID,...)
        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:
@@ -1233,7 +1642,11 @@ CallNonvirtualCharMethodA(obj,clazz,methodID,args)
        jvalue *                args
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->CallNonvirtualCharMethodA(obj,clazz,methodID,args);
+#else
            RETVAL = (*env)->CallNonvirtualCharMethodA(env, obj,clazz,methodID,args);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -1249,8 +1662,12 @@ CallNonvirtualShortMethod(obj,clazz,methodID,...)
        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:
@@ -1266,7 +1683,11 @@ CallNonvirtualShortMethodA(obj,clazz,methodID,args)
        jvalue *                args
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->CallNonvirtualShortMethodA(obj,clazz,methodID,args);
+#else
            RETVAL = (*env)->CallNonvirtualShortMethodA(env, obj,clazz,methodID,args);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -1282,8 +1703,12 @@ CallNonvirtualIntMethod(obj,clazz,methodID,...)
        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:
@@ -1299,7 +1724,11 @@ CallNonvirtualIntMethodA(obj,clazz,methodID,args)
        jvalue *                args
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->CallNonvirtualIntMethodA(obj,clazz,methodID,args);
+#else
            RETVAL = (*env)->CallNonvirtualIntMethodA(env, obj,clazz,methodID,args);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -1315,8 +1744,12 @@ CallNonvirtualLongMethod(obj,clazz,methodID,...)
        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:
@@ -1332,7 +1765,11 @@ CallNonvirtualLongMethodA(obj,clazz,methodID,args)
        jvalue *                args
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->CallNonvirtualLongMethodA(obj,clazz,methodID,args);
+#else
            RETVAL = (*env)->CallNonvirtualLongMethodA(env, obj,clazz,methodID,args);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -1348,8 +1785,12 @@ CallNonvirtualFloatMethod(obj,clazz,methodID,...)
        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:
@@ -1365,7 +1806,11 @@ CallNonvirtualFloatMethodA(obj,clazz,methodID,args)
        jvalue *                args
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->CallNonvirtualFloatMethodA(obj,clazz,methodID,args);
+#else
            RETVAL = (*env)->CallNonvirtualFloatMethodA(env, obj,clazz,methodID,args);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -1381,8 +1826,12 @@ CallNonvirtualDoubleMethod(obj,clazz,methodID,...)
        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:
@@ -1398,7 +1847,11 @@ CallNonvirtualDoubleMethodA(obj,clazz,methodID,args)
        jvalue *                args
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->CallNonvirtualDoubleMethodA(obj,clazz,methodID,args);
+#else
            RETVAL = (*env)->CallNonvirtualDoubleMethodA(env, obj,clazz,methodID,args);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -1414,8 +1867,12 @@ CallNonvirtualVoidMethod(obj,clazz,methodID,...)
        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;
        }
 
@@ -1429,7 +1886,11 @@ CallNonvirtualVoidMethodA(obj,clazz,methodID,args)
        jvalue *                args
     CODE:
        {
+#ifdef WIN32
+           env->CallNonvirtualVoidMethodA(obj,clazz,methodID,args);
+#else
            (*env)->CallNonvirtualVoidMethodA(env, obj,clazz,methodID,args);
+#endif
            RESTOREENV;
        }
 
@@ -1441,7 +1902,11 @@ GetFieldID(clazz,name,sig)
        const char *            sig
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->GetFieldID(clazz,name,sig);
+#else
            RETVAL = (*env)->GetFieldID(env, clazz,name,sig);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -1455,7 +1920,11 @@ GetObjectField(obj,fieldID)
        char *                  sig = 0;
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->GetObjectField(obj,fieldID);
+#else
            RETVAL = (*env)->GetObjectField(env, obj,fieldID);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -1469,7 +1938,11 @@ GetBooleanField(obj,fieldID)
        char *                  sig = 0;
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->GetBooleanField(obj,fieldID);
+#else
            RETVAL = (*env)->GetBooleanField(env, obj,fieldID);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -1483,7 +1956,11 @@ GetByteField(obj,fieldID)
        char *                  sig = 0;
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->GetByteField(obj,fieldID);
+#else
            RETVAL = (*env)->GetByteField(env, obj,fieldID);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -1497,7 +1974,11 @@ GetCharField(obj,fieldID)
        char *                  sig = 0;
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->GetCharField(obj,fieldID);
+#else
            RETVAL = (*env)->GetCharField(env, obj,fieldID);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -1511,7 +1992,11 @@ GetShortField(obj,fieldID)
        char *                  sig = 0;
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->GetShortField(obj,fieldID);
+#else
            RETVAL = (*env)->GetShortField(env, obj,fieldID);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -1525,7 +2010,11 @@ GetIntField(obj,fieldID)
        char *                  sig = 0;
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->GetIntField(obj,fieldID);
+#else
            RETVAL = (*env)->GetIntField(env, obj,fieldID);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -1539,7 +2028,11 @@ GetLongField(obj,fieldID)
        char *                  sig = 0;
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->GetLongField(obj,fieldID);
+#else
            RETVAL = (*env)->GetLongField(env, obj,fieldID);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -1553,7 +2046,11 @@ GetFloatField(obj,fieldID)
        char *                  sig = 0;
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->GetFloatField(obj,fieldID);
+#else
            RETVAL = (*env)->GetFloatField(env, obj,fieldID);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -1567,7 +2064,11 @@ GetDoubleField(obj,fieldID)
        char *                  sig = 0;
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->GetDoubleField(obj,fieldID);
+#else
            RETVAL = (*env)->GetDoubleField(env, obj,fieldID);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -1582,7 +2083,11 @@ SetObjectField(obj,fieldID,val)
        jobject                 val
     CODE:
        {
+#ifdef WIN32
+           env->SetObjectField(obj,fieldID,val);
+#else
            (*env)->SetObjectField(env, obj,fieldID,val);
+#endif
            RESTOREENV;
        }
 
@@ -1595,7 +2100,11 @@ SetBooleanField(obj,fieldID,val)
        jboolean                val
     CODE:
        {
+#ifdef WIN32
+           env->SetBooleanField(obj,fieldID,val);
+#else
            (*env)->SetBooleanField(env, obj,fieldID,val);
+#endif
            RESTOREENV;
        }
 
@@ -1608,7 +2117,11 @@ SetByteField(obj,fieldID,val)
        jbyte                   val
     CODE:
        {
+#ifdef WIN32
+           env->SetByteField(obj,fieldID,val);
+#else
            (*env)->SetByteField(env, obj,fieldID,val);
+#endif
            RESTOREENV;
        }
 
@@ -1621,7 +2134,11 @@ SetCharField(obj,fieldID,val)
        jchar                   val
     CODE:
        {
+#ifdef WIN32
+           env->SetCharField(obj,fieldID,val);
+#else
            (*env)->SetCharField(env, obj,fieldID,val);
+#endif
            RESTOREENV;
        }
 
@@ -1634,7 +2151,11 @@ SetShortField(obj,fieldID,val)
        jshort                  val
     CODE:
        {
+#ifdef WIN32
+           env->SetShortField(obj,fieldID,val);
+#else
            (*env)->SetShortField(env, obj,fieldID,val);
+#endif
            RESTOREENV;
        }
 
@@ -1647,7 +2168,11 @@ SetIntField(obj,fieldID,val)
        jint                    val
     CODE:
        {
+#ifdef WIN32
+           env->SetIntField(obj,fieldID,val);
+#else
            (*env)->SetIntField(env, obj,fieldID,val);
+#endif
            RESTOREENV;
        }
 
@@ -1660,7 +2185,11 @@ SetLongField(obj,fieldID,val)
        jlong                   val
     CODE:
        {
+#ifdef WIN32
+           env->SetLongField(obj,fieldID,val);
+#else
            (*env)->SetLongField(env, obj,fieldID,val);
+#endif
            RESTOREENV;
        }
 
@@ -1673,7 +2202,11 @@ SetFloatField(obj,fieldID,val)
        jfloat                  val
     CODE:
        {
+#ifdef WIN32
+           env->SetFloatField(obj,fieldID,val);
+#else
            (*env)->SetFloatField(env, obj,fieldID,val);
+#endif
            RESTOREENV;
        }
 
@@ -1686,7 +2219,11 @@ SetDoubleField(obj,fieldID,val)
        jdouble                 val
     CODE:
        {
+#ifdef WIN32
+           env->SetDoubleField(obj,fieldID,val);
+#else
            (*env)->SetDoubleField(env, obj,fieldID,val);
+#endif
            RESTOREENV;
        }
 
@@ -1698,7 +2235,11 @@ GetStaticMethodID(clazz,name,sig)
        const char *            sig
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->GetStaticMethodID(clazz,name,sig);
+#else
            RETVAL = (*env)->GetStaticMethodID(env, clazz,name,sig);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -1713,8 +2254,12 @@ CallStaticObjectMethod(clazz,methodID,...)
        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:
@@ -1729,7 +2274,11 @@ CallStaticObjectMethodA(clazz,methodID,args)
        jvalue *                args
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->CallStaticObjectMethodA(clazz,methodID,args);
+#else
            RETVAL = (*env)->CallStaticObjectMethodA(env, clazz,methodID,args);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -1744,8 +2293,12 @@ CallStaticBooleanMethod(clazz,methodID,...)
        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:
@@ -1760,7 +2313,11 @@ CallStaticBooleanMethodA(clazz,methodID,args)
        jvalue *                args
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->CallStaticBooleanMethodA(clazz,methodID,args);
+#else
            RETVAL = (*env)->CallStaticBooleanMethodA(env, clazz,methodID,args);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -1775,8 +2332,12 @@ CallStaticByteMethod(clazz,methodID,...)
        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:
@@ -1791,7 +2352,11 @@ CallStaticByteMethodA(clazz,methodID,args)
        jvalue *                args
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->CallStaticByteMethodA(clazz,methodID,args);
+#else
            RETVAL = (*env)->CallStaticByteMethodA(env, clazz,methodID,args);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -1806,8 +2371,12 @@ CallStaticCharMethod(clazz,methodID,...)
        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:
@@ -1822,7 +2391,11 @@ CallStaticCharMethodA(clazz,methodID,args)
        jvalue *                args
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->CallStaticCharMethodA(clazz,methodID,args);
+#else
            RETVAL = (*env)->CallStaticCharMethodA(env, clazz,methodID,args);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -1837,8 +2410,12 @@ CallStaticShortMethod(clazz,methodID,...)
        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:
@@ -1853,7 +2430,11 @@ CallStaticShortMethodA(clazz,methodID,args)
        jvalue *                args
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->CallStaticShortMethodA(clazz,methodID,args);
+#else
            RETVAL = (*env)->CallStaticShortMethodA(env, clazz,methodID,args);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -1868,8 +2449,12 @@ CallStaticIntMethod(clazz,methodID,...)
        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:
@@ -1884,7 +2469,11 @@ CallStaticIntMethodA(clazz,methodID,args)
        jvalue *                args
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->CallStaticIntMethodA(clazz,methodID,args);
+#else
            RETVAL = (*env)->CallStaticIntMethodA(env, clazz,methodID,args);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -1899,8 +2488,12 @@ CallStaticLongMethod(clazz,methodID,...)
        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:
@@ -1915,7 +2508,11 @@ CallStaticLongMethodA(clazz,methodID,args)
        jvalue *                args
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->CallStaticLongMethodA(clazz,methodID,args);
+#else
            RETVAL = (*env)->CallStaticLongMethodA(env, clazz,methodID,args);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -1930,8 +2527,12 @@ CallStaticFloatMethod(clazz,methodID,...)
        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:
@@ -1946,7 +2547,11 @@ CallStaticFloatMethodA(clazz,methodID,args)
        jvalue *                args
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->CallStaticFloatMethodA(clazz,methodID,args);
+#else
            RETVAL = (*env)->CallStaticFloatMethodA(env, clazz,methodID,args);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -1961,8 +2566,12 @@ CallStaticDoubleMethod(clazz,methodID,...)
        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:
@@ -1977,7 +2586,11 @@ CallStaticDoubleMethodA(clazz,methodID,args)
        jvalue *                args
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->CallStaticDoubleMethodA(clazz,methodID,args);
+#else
            RETVAL = (*env)->CallStaticDoubleMethodA(env, clazz,methodID,args);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -1992,8 +2605,12 @@ CallStaticVoidMethod(cls,methodID,...)
        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;
        }
 
@@ -2006,7 +2623,11 @@ CallStaticVoidMethodA(cls,methodID,args)
        jvalue *                args
     CODE:
        {
+#ifdef WIN32
+           env->CallStaticVoidMethodA(cls,methodID,args);
+#else
            (*env)->CallStaticVoidMethodA(env, cls,methodID,args);
+#endif
            RESTOREENV;
        }
 
@@ -2018,7 +2639,11 @@ GetStaticFieldID(clazz,name,sig)
        const char *            sig
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->GetStaticFieldID(clazz,name,sig);
+#else
            RETVAL = (*env)->GetStaticFieldID(env, clazz,name,sig);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -2032,7 +2657,11 @@ GetStaticObjectField(clazz,fieldID)
        char *                  sig = 0;
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->GetStaticObjectField(clazz,fieldID);
+#else
            RETVAL = (*env)->GetStaticObjectField(env, clazz,fieldID);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -2046,7 +2675,11 @@ GetStaticBooleanField(clazz,fieldID)
        char *                  sig = 0;
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->GetStaticBooleanField(clazz,fieldID);
+#else
            RETVAL = (*env)->GetStaticBooleanField(env, clazz,fieldID);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -2060,7 +2693,11 @@ GetStaticByteField(clazz,fieldID)
        char *                  sig = 0;
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->GetStaticByteField(clazz,fieldID);
+#else
            RETVAL = (*env)->GetStaticByteField(env, clazz,fieldID);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -2074,7 +2711,11 @@ GetStaticCharField(clazz,fieldID)
        char *                  sig = 0;
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->GetStaticCharField(clazz,fieldID);
+#else
            RETVAL = (*env)->GetStaticCharField(env, clazz,fieldID);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -2088,7 +2729,11 @@ GetStaticShortField(clazz,fieldID)
        char *                  sig = 0;
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->GetStaticShortField(clazz,fieldID);
+#else
            RETVAL = (*env)->GetStaticShortField(env, clazz,fieldID);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -2102,7 +2747,11 @@ GetStaticIntField(clazz,fieldID)
        char *                  sig = 0;
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->GetStaticIntField(clazz,fieldID);
+#else
            RETVAL = (*env)->GetStaticIntField(env, clazz,fieldID);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -2116,7 +2765,11 @@ GetStaticLongField(clazz,fieldID)
        char *                  sig = 0;
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->GetStaticLongField(clazz,fieldID);
+#else
            RETVAL = (*env)->GetStaticLongField(env, clazz,fieldID);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -2130,7 +2783,11 @@ GetStaticFloatField(clazz,fieldID)
        char *                  sig = 0;
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->GetStaticFloatField(clazz,fieldID);
+#else
            RETVAL = (*env)->GetStaticFloatField(env, clazz,fieldID);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -2144,7 +2801,11 @@ GetStaticDoubleField(clazz,fieldID)
        char *                  sig = 0;
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->GetStaticDoubleField(clazz,fieldID);
+#else
            RETVAL = (*env)->GetStaticDoubleField(env, clazz,fieldID);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -2159,7 +2820,11 @@ SetStaticObjectField(clazz,fieldID,value)
        jobject                 value
     CODE:
        {
+#ifdef WIN32
+         env->SetStaticObjectField(clazz,fieldID,value);
+#else
          (*env)->SetStaticObjectField(env, clazz,fieldID,value);
+#endif
            RESTOREENV;
        }
 
@@ -2172,7 +2837,11 @@ SetStaticBooleanField(clazz,fieldID,value)
        jboolean                value
     CODE:
        {
+#ifdef WIN32
+         env->SetStaticBooleanField(clazz,fieldID,value);
+#else
          (*env)->SetStaticBooleanField(env, clazz,fieldID,value);
+#endif
            RESTOREENV;
        }
 
@@ -2185,7 +2854,11 @@ SetStaticByteField(clazz,fieldID,value)
        jbyte                   value
     CODE:
        {
+#ifdef WIN32
+         env->SetStaticByteField(clazz,fieldID,value);
+#else
          (*env)->SetStaticByteField(env, clazz,fieldID,value);
+#endif
            RESTOREENV;
        }
 
@@ -2198,7 +2871,11 @@ SetStaticCharField(clazz,fieldID,value)
        jchar                   value
     CODE:
        {
+#ifdef WIN32
+         env->SetStaticCharField(clazz,fieldID,value);
+#else
          (*env)->SetStaticCharField(env, clazz,fieldID,value);
+#endif
            RESTOREENV;
        }
 
@@ -2211,7 +2888,11 @@ SetStaticShortField(clazz,fieldID,value)
        jshort                  value
     CODE:
        {
+#ifdef WIN32
+         env->SetStaticShortField(clazz,fieldID,value);
+#else
          (*env)->SetStaticShortField(env, clazz,fieldID,value);
+#endif
            RESTOREENV;
        }
 
@@ -2224,7 +2905,11 @@ SetStaticIntField(clazz,fieldID,value)
        jint                    value
     CODE:
        {
+#ifdef WIN32
+         env->SetStaticIntField(clazz,fieldID,value);
+#else
          (*env)->SetStaticIntField(env, clazz,fieldID,value);
+#endif
            RESTOREENV;
        }
 
@@ -2237,7 +2922,11 @@ SetStaticLongField(clazz,fieldID,value)
        jlong                   value
     CODE:
        {
+#ifdef WIN32
+         env->SetStaticLongField(clazz,fieldID,value);
+#else
          (*env)->SetStaticLongField(env, clazz,fieldID,value);
+#endif
            RESTOREENV;
        }
 
@@ -2250,7 +2939,11 @@ SetStaticFloatField(clazz,fieldID,value)
        jfloat                  value
     CODE:
        {
+#ifdef WIN32
+         env->SetStaticFloatField(clazz,fieldID,value);
+#else
          (*env)->SetStaticFloatField(env, clazz,fieldID,value);
+#endif
            RESTOREENV;
        }
 
@@ -2263,7 +2956,11 @@ SetStaticDoubleField(clazz,fieldID,value)
        jdouble                 value
     CODE:
        {
+#ifdef WIN32
+         env->SetStaticDoubleField(clazz,fieldID,value);
+#else
          (*env)->SetStaticDoubleField(env, clazz,fieldID,value);
+#endif
            RESTOREENV;
        }
 
@@ -2275,7 +2972,11 @@ NewString(unicode)
        const jchar *           unicode
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->NewString(unicode, unicode_len_);
+#else
            RETVAL = (*env)->NewString(env, unicode, unicode_len_);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -2287,7 +2988,11 @@ GetStringLength(str)
        jstring                 str
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->GetStringLength(str);
+#else
            RETVAL = (*env)->GetStringLength(env, str);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -2301,14 +3006,26 @@ GetStringChars(str)
        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)
@@ -2316,7 +3033,11 @@ NewStringUTF(utf)
        const char *            utf
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->NewStringUTF(utf);
+#else
            RETVAL = (*env)->NewStringUTF(env, utf);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -2328,7 +3049,11 @@ GetStringUTFLength(str)
        jstring                 str
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->GetStringUTFLength(str);
+#else
            RETVAL = (*env)->GetStringUTFLength(env, str);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -2341,13 +3066,21 @@ GetStringUTFChars(str)
        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
@@ -2356,7 +3089,11 @@ GetArrayLength(array)
        jarray                  array
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->GetArrayLength(array);
+#else
            RETVAL = (*env)->GetArrayLength(env, array);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -2370,7 +3107,11 @@ NewObjectArray(len,clazz,init)
        jobject                 init
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->NewObjectArray(len,clazz,init);
+#else
            RETVAL = (*env)->NewObjectArray(env, len,clazz,init);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -2383,7 +3124,11 @@ GetObjectArrayElement(array,index)
        jsize                   index
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->GetObjectArrayElement(array,index);
+#else
            RETVAL = (*env)->GetObjectArrayElement(env, array,index);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -2397,7 +3142,11 @@ SetObjectArrayElement(array,index,val)
        jobject                 val
     CODE:
        {
+#ifdef WIN32
+           env->SetObjectArrayElement(array,index,val);
+#else
            (*env)->SetObjectArrayElement(env, array,index,val);
+#endif
            RESTOREENV;
        }
 
@@ -2407,7 +3156,11 @@ NewBooleanArray(len)
        jsize                   len
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->NewBooleanArray(len);
+#else
            RETVAL = (*env)->NewBooleanArray(env, len);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -2419,7 +3172,11 @@ NewByteArray(len)
        jsize                   len
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->NewByteArray(len);
+#else
            RETVAL = (*env)->NewByteArray(env, len);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -2431,7 +3188,11 @@ NewCharArray(len)
        jsize                   len
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->NewCharArray(len);
+#else
            RETVAL = (*env)->NewCharArray(env, len);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -2443,7 +3204,11 @@ NewShortArray(len)
        jsize                   len
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->NewShortArray(len);
+#else
            RETVAL = (*env)->NewShortArray(env, len);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -2455,7 +3220,11 @@ NewIntArray(len)
        jsize                   len
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->NewIntArray(len);
+#else
            RETVAL = (*env)->NewIntArray(env, len);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -2467,7 +3236,11 @@ NewLongArray(len)
        jsize                   len
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->NewLongArray(len);
+#else
            RETVAL = (*env)->NewLongArray(env, len);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -2479,7 +3252,11 @@ NewFloatArray(len)
        jsize                   len
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->NewFloatArray(len);
+#else
            RETVAL = (*env)->NewFloatArray(env, len);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -2491,7 +3268,11 @@ NewDoubleArray(len)
        jsize                   len
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->NewDoubleArray(len);
+#else
            RETVAL = (*env)->NewDoubleArray(env, len);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -2505,8 +3286,16 @@ GetBooleanArrayElements(array)
        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;
@@ -2523,7 +3312,11 @@ GetBooleanArrayElements(array)
                else
                    PUSHs(&PL_sv_no);
            }
+#ifdef WIN32
+           env->ReleaseBooleanArrayElements(array,RETVAL,JNI_ABORT);
+#else
            (*env)->ReleaseBooleanArrayElements(env, array,RETVAL,JNI_ABORT);
+#endif
            RESTOREENV;
        }
 
@@ -2535,8 +3328,16 @@ GetByteArrayElements(array)
        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;
@@ -2553,7 +3354,11 @@ GetByteArrayElements(array)
                else
                    PUSHs(&PL_sv_no);
            }
+#ifdef WIN32
+           env->ReleaseByteArrayElements(array,RETVAL,JNI_ABORT);
+#else
            (*env)->ReleaseByteArrayElements(env, array,RETVAL,JNI_ABORT);
+#endif
            RESTOREENV;
        }
 
@@ -2565,8 +3370,16 @@ GetCharArrayElements(array)
        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;
@@ -2583,7 +3396,11 @@ GetCharArrayElements(array)
                else
                    PUSHs(&PL_sv_no);
            }
+#ifdef WIN32
+           env->ReleaseCharArrayElements(array,RETVAL,JNI_ABORT);
+#else
            (*env)->ReleaseCharArrayElements(env, array,RETVAL,JNI_ABORT);
+#endif
            RESTOREENV;
        }
 
@@ -2595,8 +3412,16 @@ GetShortArrayElements(array)
        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;
@@ -2613,7 +3438,11 @@ GetShortArrayElements(array)
                else
                    PUSHs(&PL_sv_no);
            }
+#ifdef WIN32
+           env->ReleaseShortArrayElements(array,RETVAL,JNI_ABORT);
+#else
            (*env)->ReleaseShortArrayElements(env, array,RETVAL,JNI_ABORT);
+#endif
            RESTOREENV;
        }
 
@@ -2625,8 +3454,16 @@ GetIntArrayElements(array)
        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;
@@ -2643,7 +3480,11 @@ GetIntArrayElements(array)
                else
                    PUSHs(&PL_sv_no);
            }
+#ifdef WIN32
+           env->ReleaseIntArrayElements(array,RETVAL,JNI_ABORT);
+#else
            (*env)->ReleaseIntArrayElements(env, array,RETVAL,JNI_ABORT);
+#endif
            RESTOREENV;
        }
 
@@ -2655,8 +3496,16 @@ GetLongArrayElements(array)
        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;
@@ -2673,7 +3522,11 @@ GetLongArrayElements(array)
                else
                    PUSHs(&PL_sv_no);
            }
+#ifdef WIN32
+           env->ReleaseLongArrayElements(array,RETVAL,JNI_ABORT);
+#else
            (*env)->ReleaseLongArrayElements(env, array,RETVAL,JNI_ABORT);
+#endif
            RESTOREENV;
        }
 
@@ -2685,8 +3538,16 @@ GetFloatArrayElements(array)
        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;
@@ -2703,7 +3564,11 @@ GetFloatArrayElements(array)
                else
                    PUSHs(&PL_sv_no);
            }
+#ifdef WIN32
+           env->ReleaseFloatArrayElements(array,RETVAL,JNI_ABORT);
+#else
            (*env)->ReleaseFloatArrayElements(env, array,RETVAL,JNI_ABORT);
+#endif
            RESTOREENV;
        }
 
@@ -2715,8 +3580,16 @@ GetDoubleArrayElements(array)
        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;
@@ -2733,7 +3606,11 @@ GetDoubleArrayElements(array)
                else
                    PUSHs(&PL_sv_no);
            }
+#ifdef WIN32
+           env->ReleaseDoubleArrayElements(array,RETVAL,JNI_ABORT);
+#else
            (*env)->ReleaseDoubleArrayElements(env, array,RETVAL,JNI_ABORT);
+#endif
            RESTOREENV;
        }
 
@@ -2748,7 +3625,11 @@ GetBooleanArrayRegion(array,start,len,buf)
        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;
@@ -2765,7 +3646,11 @@ GetByteArrayRegion(array,start,len,buf)
        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;
@@ -2782,7 +3667,11 @@ GetCharArrayRegion(array,start,len,buf)
        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;
@@ -2799,7 +3688,11 @@ GetShortArrayRegion(array,start,len,buf)
        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;
@@ -2816,7 +3709,11 @@ GetIntArrayRegion(array,start,len,buf)
        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;
@@ -2833,7 +3730,11 @@ GetLongArrayRegion(array,start,len,buf)
        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;
@@ -2850,7 +3751,11 @@ GetFloatArrayRegion(array,start,len,buf)
        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;
@@ -2867,7 +3772,11 @@ GetDoubleArrayRegion(array,start,len,buf)
        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;
@@ -2885,10 +3794,14 @@ SetBooleanArrayRegion(array,start,len,buf)
     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;
        }
 
@@ -2904,10 +3817,14 @@ SetByteArrayRegion(array,start,len,buf)
     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;
        }
 
@@ -2923,10 +3840,14 @@ SetCharArrayRegion(array,start,len,buf)
     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;
        }
 
@@ -2942,10 +3863,14 @@ SetShortArrayRegion(array,start,len,buf)
     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;
        }
 
@@ -2961,10 +3886,14 @@ SetIntArrayRegion(array,start,len,buf)
     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;
        }
 
@@ -2980,10 +3909,14 @@ SetLongArrayRegion(array,start,len,buf)
     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;
        }
 
@@ -2999,10 +3932,14 @@ SetFloatArrayRegion(array,start,len,buf)
     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;
        }
 
@@ -3018,10 +3955,14 @@ SetDoubleArrayRegion(array,start,len,buf)
     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;
        }
 
@@ -3033,7 +3974,11 @@ RegisterNatives(clazz,methods,nMethods)
        jint                    nMethods
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->RegisterNatives(clazz,methods,nMethods);
+#else
            RETVAL = (*env)->RegisterNatives(env, clazz,methods,nMethods);
+#endif
        }
 
 SysRet
@@ -3042,7 +3987,11 @@ UnregisterNatives(clazz)
        jclass                  clazz
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->UnregisterNatives(clazz);
+#else
            RETVAL = (*env)->UnregisterNatives(env, clazz);
+#endif
        }
     OUTPUT:
        RETVAL  
@@ -3053,7 +4002,11 @@ MonitorEnter(obj)
        jobject                 obj
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->MonitorEnter(obj);
+#else
            RETVAL = (*env)->MonitorEnter(env, obj);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -3065,7 +4018,11 @@ MonitorExit(obj)
        jobject                 obj
     CODE:
        {
+#ifdef WIN32
+           RETVAL = env->MonitorExit(obj);
+#else
            RETVAL = (*env)->MonitorExit(env, obj);
+#endif
            RESTOREENV;
        }
     OUTPUT:
@@ -3077,12 +4034,23 @@ GetJavaVM(...)
     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;
@@ -3090,47 +4058,84 @@ GetJavaVM(...)
                }
                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");
+               }
            }
        }