home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / perl560.zip / jpl / JNI / JNI.xs < prev    next >
Text File  |  1999-09-14  |  83KB  |  4,142 lines
  1. /*
  2.  * Copyright 1997, O'Reilly & Associate, Inc.
  3.  *
  4.  * This package may be copied under the same terms as Perl itself.
  5.  */
  6.  
  7. #include "EXTERN.h"
  8. #include "perl.h"
  9. #include "XSUB.h"
  10.  
  11. #include <stdio.h>
  12. #include <jni.h>
  13.  
  14. #ifndef PERL_VERSION
  15. #  include <patchlevel.h>
  16. #  define PERL_REVISION        5
  17. #  define PERL_VERSION        PATCHLEVEL
  18. #  define PERL_SUBVERSION    SUBVERSION
  19. #endif
  20.  
  21. #if PERL_REVISION == 5 && (PERL_VERSION < 4 || \
  22.                (PERL_VERSION == 4 && PERL_SUBVERSION <= 75))
  23. #  define PL_na        na
  24. #  define PL_sv_no    sv_no
  25. #  define PL_sv_undef    sv_undef
  26. #  define PL_dowarn    dowarn
  27. #endif
  28.  
  29. #ifndef newSVpvn
  30. #  define newSVpvn(a,b)    newSVpv(a,b)
  31. #endif
  32.  
  33. #ifndef pTHX
  34. #  define pTHX        void
  35. #  define pTHX_
  36. #  define aTHX
  37. #  define aTHX_
  38. #  define dTHX        extern int JNI___notused
  39. #endif
  40.  
  41. #ifndef WIN32
  42. #  include <dlfcn.h>
  43. #endif
  44.  
  45. #ifdef EMBEDDEDPERL
  46. extern JNIEnv* jplcurenv;
  47. extern int jpldebug;
  48. #else
  49. JNIEnv* jplcurenv;
  50. int jpldebug = 1;
  51. #endif
  52.  
  53. #define SysRet jint
  54.  
  55. #ifdef WIN32
  56. static void JNICALL call_my_exit(jint status)
  57. {
  58.     my_exit(status);
  59. }
  60. #else
  61. static void call_my_exit(jint status)
  62. {
  63.     my_exit(status);
  64. }
  65. #endif
  66.  
  67. jvalue*
  68. makeargs(char *sig, SV** svp, int items)
  69. {
  70.     jvalue* jv = (jvalue*)safemalloc(sizeof(jvalue) * items);
  71.     int ix = 0;
  72.     char *s = sig;
  73.     JNIEnv* env = jplcurenv;
  74.     char *start;
  75.     STRLEN n_a;
  76.  
  77.     if (jpldebug)
  78.     fprintf(stderr, "sig = %s, items = %d\n", sig, items);
  79.     if (*s++ != '(')
  80.     goto cleanup;
  81.  
  82.     while (items--) {
  83.     SV *sv = *svp++;
  84.     start = s;
  85.     switch (*s++) {
  86.     case 'Z':
  87.         jv[ix++].z = (jboolean)(SvIV(sv) != 0);
  88.         break;
  89.     case 'B':
  90.         jv[ix++].b = (jbyte)SvIV(sv);
  91.         break;
  92.     case 'C':
  93.         jv[ix++].c = (jchar)SvIV(sv);
  94.         break;
  95.     case 'S':
  96.         jv[ix++].s = (jshort)SvIV(sv);
  97.         break;
  98.     case 'I':
  99.         jv[ix++].i = (jint)SvIV(sv);
  100.         break;
  101.     case 'J':
  102.         jv[ix++].j = (jlong)SvNV(sv);
  103.         break;
  104.     case 'F':
  105.         jv[ix++].f = (jfloat)SvNV(sv);
  106.         break;
  107.     case 'D':
  108.         jv[ix++].d = (jdouble)SvNV(sv);
  109.         break;
  110.     case '[':
  111.         switch (*s++) {
  112.         case 'Z':
  113.         if (SvROK(sv)) {
  114.             SV* rv = (SV*)SvRV(sv);
  115.             if (SvOBJECT(rv))
  116.             jv[ix++].l = (jobject)(void*)SvIV(rv);
  117.             else if (SvTYPE(rv) == SVt_PVAV) {
  118.             jsize len = av_len((AV*)rv) + 1;
  119.             jboolean* buf = (jboolean*)malloc(len * sizeof(jboolean));
  120.             int i;
  121.             SV** esv;
  122.  
  123. #ifdef WIN32
  124.             jbooleanArray ja = env->NewBooleanArray(len);
  125. #else
  126.             jbooleanArray ja = (*env)->NewBooleanArray(env, len);
  127. #endif
  128.             for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
  129.                 buf[i] = (jboolean)SvIV(*esv);
  130. #ifdef WIN32
  131.             env->SetBooleanArrayRegion(ja, 0, len, buf);
  132. #else
  133.             (*env)->SetBooleanArrayRegion(env, ja, 0, len, buf);
  134. #endif
  135.             free((void*)buf);
  136.             jv[ix++].l = (jobject)ja;
  137.             }
  138.             else
  139.             jv[ix++].l = (jobject)(void*)0;
  140.         }
  141.         else if (SvPOK(sv)) {
  142.             jsize len = sv_len(sv) / sizeof(jboolean);
  143.  
  144. #ifdef WIN32
  145.             jbooleanArray ja = env->NewBooleanArray(len);
  146. #else
  147.             jbooleanArray ja = (*env)->NewBooleanArray(env, len);
  148. #endif
  149. #ifdef WIN32
  150.             env->SetBooleanArrayRegion(ja, 0, len, (jboolean*)SvPV(sv,n_a));
  151. #else
  152.             (*env)->SetBooleanArrayRegion(env, ja, 0, len, (jboolean*)SvPV(sv,n_a));
  153. #endif
  154.             jv[ix++].l = (jobject)ja;
  155.         }
  156.         else
  157.             jv[ix++].l = (jobject)(void*)0;
  158.         break;
  159.         case 'B':
  160.         if (SvROK(sv)) {
  161.             SV* rv = (SV*)SvRV(sv);
  162.             if (SvOBJECT(rv))
  163.             jv[ix++].l = (jobject)(void*)SvIV(rv);
  164.             else if (SvTYPE(rv) == SVt_PVAV) {
  165.             jsize len = av_len((AV*)rv) + 1;
  166.             jbyte* buf = (jbyte*)malloc(len * sizeof(jbyte));
  167.             int i;
  168.             SV** esv;
  169.  
  170. #ifdef WIN32
  171.             jbyteArray ja = env->NewByteArray(len);
  172. #else
  173.             jbyteArray ja = (*env)->NewByteArray(env, len);
  174. #endif
  175.             for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
  176.                 buf[i] = (jbyte)SvIV(*esv);
  177. #ifdef WIN32
  178.             env->SetByteArrayRegion(ja, 0, len, buf);
  179. #else
  180.             (*env)->SetByteArrayRegion(env, ja, 0, len, buf);
  181. #endif
  182.             free((void*)buf);
  183.             jv[ix++].l = (jobject)ja;
  184.             }
  185.             else
  186.             jv[ix++].l = (jobject)(void*)0;
  187.         }
  188.         else if (SvPOK(sv)) {
  189.             jsize len = sv_len(sv) / sizeof(jbyte);
  190.  
  191. #ifdef WIN32
  192.             jbyteArray ja = env->NewByteArray(len);
  193. #else
  194.             jbyteArray ja = (*env)->NewByteArray(env, len);
  195. #endif
  196. #ifdef WIN32
  197.             env->SetByteArrayRegion(ja, 0, len, (jbyte*)SvPV(sv,n_a));
  198. #else
  199.             (*env)->SetByteArrayRegion(env, ja, 0, len, (jbyte*)SvPV(sv,n_a));
  200. #endif
  201.             jv[ix++].l = (jobject)ja;
  202.         }
  203.         else
  204.             jv[ix++].l = (jobject)(void*)0;
  205.         break;
  206.         case 'C':
  207.         if (SvROK(sv)) {
  208.             SV* rv = (SV*)SvRV(sv);
  209.             if (SvOBJECT(rv))
  210.             jv[ix++].l = (jobject)(void*)SvIV(rv);
  211.             else if (SvTYPE(rv) == SVt_PVAV) {
  212.             jsize len = av_len((AV*)rv) + 1;
  213.             jchar* buf = (jchar*)malloc(len * sizeof(jchar));
  214.             int i;
  215.             SV** esv;
  216.  
  217. #ifdef WIN32
  218.             jcharArray ja = env->NewCharArray(len);
  219. #else
  220.             jcharArray ja = (*env)->NewCharArray(env, len);
  221. #endif
  222.             for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
  223.                 buf[i] = (jchar)SvIV(*esv);
  224. #ifdef WIN32
  225.             env->SetCharArrayRegion(ja, 0, len, buf);
  226. #else
  227.             (*env)->SetCharArrayRegion(env, ja, 0, len, buf);
  228. #endif
  229.             free((void*)buf);
  230.             jv[ix++].l = (jobject)ja;
  231.             }
  232.             else
  233.             jv[ix++].l = (jobject)(void*)0;
  234.         }
  235.         else if (SvPOK(sv)) {
  236.             jsize len = sv_len(sv) / sizeof(jchar);
  237.  
  238. #ifdef WIN32
  239.             jcharArray ja = env->NewCharArray(len);
  240. #else
  241.             jcharArray ja = (*env)->NewCharArray(env, len);
  242. #endif
  243. #ifdef WIN32
  244.             env->SetCharArrayRegion(ja, 0, len, (jchar*)SvPV(sv,n_a));
  245. #else
  246.             (*env)->SetCharArrayRegion(env, ja, 0, len, (jchar*)SvPV(sv,n_a));
  247. #endif
  248.             jv[ix++].l = (jobject)ja;
  249.         }
  250.         else
  251.             jv[ix++].l = (jobject)(void*)0;
  252.         break;
  253.         case 'S':
  254.         if (SvROK(sv)) {
  255.             SV* rv = (SV*)SvRV(sv);
  256.             if (SvOBJECT(rv))
  257.             jv[ix++].l = (jobject)(void*)SvIV(rv);
  258.             else if (SvTYPE(rv) == SVt_PVAV) {
  259.             jsize len = av_len((AV*)rv) + 1;
  260.             jshort* buf = (jshort*)malloc(len * sizeof(jshort));
  261.             int i;
  262.             SV** esv;
  263.  
  264. #ifdef WIN32
  265.             jshortArray ja = env->NewShortArray(len);
  266. #else
  267.             jshortArray ja = (*env)->NewShortArray(env, len);
  268. #endif
  269.             for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
  270.                 buf[i] = (jshort)SvIV(*esv);
  271. #ifdef WIN32
  272.             env->SetShortArrayRegion(ja, 0, len, buf);
  273. #else
  274.             (*env)->SetShortArrayRegion(env, ja, 0, len, buf);
  275. #endif
  276.             free((void*)buf);
  277.             jv[ix++].l = (jobject)ja;
  278.             }
  279.             else
  280.             jv[ix++].l = (jobject)(void*)0;
  281.         }
  282.         else if (SvPOK(sv)) {
  283.             jsize len = sv_len(sv) / sizeof(jshort);
  284.  
  285. #ifdef WIN32
  286.             jshortArray ja = env->NewShortArray(len);
  287. #else
  288.             jshortArray ja = (*env)->NewShortArray(env, len);
  289. #endif
  290. #ifdef WIN32
  291.             env->SetShortArrayRegion(ja, 0, len, (jshort*)SvPV(sv,n_a));
  292. #else
  293.             (*env)->SetShortArrayRegion(env, ja, 0, len, (jshort*)SvPV(sv,n_a));
  294. #endif
  295.             jv[ix++].l = (jobject)ja;
  296.         }
  297.         else
  298.             jv[ix++].l = (jobject)(void*)0;
  299.         break;
  300.         case 'I':
  301.         if (SvROK(sv)) {
  302.             SV* rv = (SV*)SvRV(sv);
  303.             if (SvOBJECT(rv))
  304.             jv[ix++].l = (jobject)(void*)SvIV(rv);
  305.             else if (SvTYPE(rv) == SVt_PVAV) {
  306.             jsize len = av_len((AV*)rv) + 1;
  307.             jint* buf = (jint*)malloc(len * sizeof(jint));
  308.             int i;
  309.             SV** esv;
  310.  
  311. #ifdef WIN32
  312.             jintArray ja = env->NewIntArray(len);
  313. #else
  314.             jintArray ja = (*env)->NewIntArray(env, len);
  315. #endif
  316.             for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
  317.                 buf[i] = (jint)SvIV(*esv);
  318. #ifdef WIN32
  319.             env->SetIntArrayRegion(ja, 0, len, buf);
  320. #else
  321.             (*env)->SetIntArrayRegion(env, ja, 0, len, buf);
  322. #endif
  323.             free((void*)buf);
  324.             jv[ix++].l = (jobject)ja;
  325.             }
  326.             else
  327.             jv[ix++].l = (jobject)(void*)0;
  328.         }
  329.         else if (SvPOK(sv)) {
  330.             jsize len = sv_len(sv) / sizeof(jint);
  331.  
  332. #ifdef WIN32
  333.             jintArray ja = env->NewIntArray(len);
  334. #else
  335.             jintArray ja = (*env)->NewIntArray(env, len);
  336. #endif
  337. #ifdef WIN32
  338.             env->SetIntArrayRegion(ja, 0, len, (jint*)SvPV(sv,n_a));
  339. #else
  340.             (*env)->SetIntArrayRegion(env, ja, 0, len, (jint*)SvPV(sv,n_a));
  341. #endif
  342.             jv[ix++].l = (jobject)ja;
  343.         }
  344.         else
  345.             jv[ix++].l = (jobject)(void*)0;
  346.         break;
  347.         case 'J':
  348.         if (SvROK(sv)) {
  349.             SV* rv = (SV*)SvRV(sv);
  350.             if (SvOBJECT(rv))
  351.             jv[ix++].l = (jobject)(void*)SvIV(rv);
  352.             else if (SvTYPE(rv) == SVt_PVAV) {
  353.             jsize len = av_len((AV*)rv) + 1;
  354.             jlong* buf = (jlong*)malloc(len * sizeof(jlong));
  355.             int i;
  356.             SV** esv;
  357.  
  358. #ifdef WIN32
  359.             jlongArray ja = env->NewLongArray(len);
  360. #else
  361.             jlongArray ja = (*env)->NewLongArray(env, len);
  362. #endif
  363.             for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
  364.                 buf[i] = (jlong)SvNV(*esv);
  365. #ifdef WIN32
  366.             env->SetLongArrayRegion(ja, 0, len, buf);
  367. #else
  368.             (*env)->SetLongArrayRegion(env, ja, 0, len, buf);
  369. #endif
  370.             free((void*)buf);
  371.             jv[ix++].l = (jobject)ja;
  372.             }
  373.             else
  374.             jv[ix++].l = (jobject)(void*)0;
  375.         }
  376.         else if (SvPOK(sv)) {
  377.             jsize len = sv_len(sv) / sizeof(jlong);
  378.  
  379. #ifdef WIN32
  380.             jlongArray ja = env->NewLongArray(len);
  381. #else
  382.             jlongArray ja = (*env)->NewLongArray(env, len);
  383. #endif
  384. #ifdef WIN32
  385.             env->SetLongArrayRegion(ja, 0, len, (jlong*)SvPV(sv,n_a));
  386. #else
  387.             (*env)->SetLongArrayRegion(env, ja, 0, len, (jlong*)SvPV(sv,n_a));
  388. #endif
  389.             jv[ix++].l = (jobject)ja;
  390.         }
  391.         else
  392.             jv[ix++].l = (jobject)(void*)0;
  393.         break;
  394.         case 'F':
  395.         if (SvROK(sv)) {
  396.             SV* rv = (SV*)SvRV(sv);
  397.             if (SvOBJECT(rv))
  398.             jv[ix++].l = (jobject)(void*)SvIV(rv);
  399.             else if (SvTYPE(rv) == SVt_PVAV) {
  400.             jsize len = av_len((AV*)rv) + 1;
  401.             jfloat* buf = (jfloat*)malloc(len * sizeof(jfloat));
  402.             int i;
  403.             SV** esv;
  404.  
  405. #ifdef WIN32
  406.             jfloatArray ja = env->NewFloatArray(len);
  407. #else
  408.             jfloatArray ja = (*env)->NewFloatArray(env, len);
  409. #endif
  410.             for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
  411.                 buf[i] = (jfloat)SvNV(*esv);
  412. #ifdef WIN32
  413.             env->SetFloatArrayRegion(ja, 0, len, buf);
  414. #else
  415.             (*env)->SetFloatArrayRegion(env, ja, 0, len, buf);
  416. #endif
  417.             free((void*)buf);
  418.             jv[ix++].l = (jobject)ja;
  419.             }
  420.             else
  421.             jv[ix++].l = (jobject)(void*)0;
  422.         }
  423.         else if (SvPOK(sv)) {
  424.             jsize len = sv_len(sv) / sizeof(jfloat);
  425.  
  426. #ifdef WIN32
  427.             jfloatArray ja = env->NewFloatArray(len);
  428. #else
  429.             jfloatArray ja = (*env)->NewFloatArray(env, len);
  430. #endif
  431. #ifdef WIN32
  432.             env->SetFloatArrayRegion(ja, 0, len, (jfloat*)SvPV(sv,n_a));
  433. #else
  434.             (*env)->SetFloatArrayRegion(env, ja, 0, len, (jfloat*)SvPV(sv,n_a));
  435. #endif
  436.             jv[ix++].l = (jobject)ja;
  437.         }
  438.         else
  439.             jv[ix++].l = (jobject)(void*)0;
  440.         break;
  441.         case 'D':
  442.         if (SvROK(sv)) {
  443.             SV* rv = (SV*)SvRV(sv);
  444.             if (SvOBJECT(rv))
  445.             jv[ix++].l = (jobject)(void*)SvIV(rv);
  446.             else if (SvTYPE(rv) == SVt_PVAV) {
  447.             jsize len = av_len((AV*)rv) + 1;
  448.             jdouble* buf = (jdouble*)malloc(len * sizeof(jdouble));
  449.             int i;
  450.             SV** esv;
  451.  
  452. #ifdef WIN32
  453.             jdoubleArray ja = env->NewDoubleArray(len);
  454. #else
  455.             jdoubleArray ja = (*env)->NewDoubleArray(env, len);
  456. #endif
  457.             for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
  458.                 buf[i] = (jdouble)SvNV(*esv);
  459. #ifdef WIN32
  460.             env->SetDoubleArrayRegion(ja, 0, len, buf);
  461. #else
  462.             (*env)->SetDoubleArrayRegion(env, ja, 0, len, buf);
  463. #endif
  464.             free((void*)buf);
  465.             jv[ix++].l = (jobject)ja;
  466.             }
  467.             else
  468.             jv[ix++].l = (jobject)(void*)0;
  469.         }
  470.         else if (SvPOK(sv)) {
  471.             jsize len = sv_len(sv) / sizeof(jdouble);
  472.  
  473. #ifdef WIN32
  474.             jdoubleArray ja = env->NewDoubleArray(len);
  475. #else
  476.             jdoubleArray ja = (*env)->NewDoubleArray(env, len);
  477. #endif
  478. #ifdef WIN32
  479.             env->SetDoubleArrayRegion(ja, 0, len, (jdouble*)SvPV(sv,n_a));
  480. #else
  481.             (*env)->SetDoubleArrayRegion(env, ja, 0, len, (jdouble*)SvPV(sv,n_a));
  482. #endif
  483.             jv[ix++].l = (jobject)ja;
  484.         }
  485.         else
  486.             jv[ix++].l = (jobject)(void*)0;
  487.         break;
  488.         case 'L':
  489.         while (*s != ';') s++;
  490.         s++;
  491.         if (strnEQ(start, "[Ljava/lang/String;", 19)) {
  492.             if (SvROK(sv)) {
  493.             SV* rv = (SV*)SvRV(sv);
  494.             if (SvOBJECT(rv))
  495.                 jv[ix++].l = (jobject)(void*)SvIV(rv);
  496.             else if (SvTYPE(rv) == SVt_PVAV) {
  497.                 jsize len = av_len((AV*)rv) + 1;
  498.                 int i;
  499.                 SV** esv;
  500.                 static jclass jcl = 0;
  501.                 jobjectArray ja;
  502.  
  503.                 if (!jcl)
  504. #ifdef WIN32
  505.                 jcl = env->FindClass("java/lang/String");
  506. #else
  507.                 jcl = (*env)->FindClass(env, "java/lang/String");
  508. #endif
  509. #ifdef WIN32
  510.                 ja = env->NewObjectArray(len, jcl, 0);
  511. #else
  512.                 ja = (*env)->NewObjectArray(env, len, jcl, 0);
  513. #endif
  514.                 for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++) {
  515. #ifdef WIN32
  516.                 jobject str = (jobject)env->NewStringUTF(SvPV(*esv,n_a));
  517. #else
  518.                 jobject str = (jobject)(*env)->NewStringUTF(env, SvPV(*esv,n_a));
  519. #endif
  520. #ifdef WIN32
  521.                 env->SetObjectArrayElement(ja, i, str);
  522. #else
  523.                 (*env)->SetObjectArrayElement(env, ja, i, str);
  524. #endif
  525.                 }
  526.                 jv[ix++].l = (jobject)ja;
  527.             }
  528.             else
  529.                 jv[ix++].l = (jobject)(void*)0;
  530.             }
  531.             else
  532.             jv[ix++].l = (jobject)(void*)0;
  533.             break;
  534.         }
  535.         /* FALL THROUGH */
  536.         default:
  537.         if (SvROK(sv)) {
  538.             SV* rv = (SV*)SvRV(sv);
  539.             if (SvOBJECT(rv))
  540.             jv[ix++].l = (jobject)(void*)SvIV(rv);
  541.             else if (SvTYPE(rv) == SVt_PVAV) {
  542.             jsize len = av_len((AV*)rv) + 1;
  543.             int i;
  544.             SV** esv;
  545.                static jclass jcl = 0;
  546.             jobjectArray ja;
  547.  
  548.             if (!jcl)
  549. #ifdef WIN32
  550.                 jcl = env->FindClass("java/lang/Object");
  551. #else
  552.                 jcl = (*env)->FindClass(env, "java/lang/Object");
  553. #endif
  554. #ifdef WIN32
  555.             ja = env->NewObjectArray(len, jcl, 0);
  556. #else
  557.             ja = (*env)->NewObjectArray(env, len, jcl, 0);
  558. #endif
  559.             for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++) {
  560.                 if (SvROK(*esv) && (rv = SvRV(*esv)) && SvOBJECT(rv)) {
  561. #ifdef WIN32
  562.                 env->SetObjectArrayElement(ja, i, (jobject)(void*)SvIV(rv));
  563. #else
  564.                 (*env)->SetObjectArrayElement(env, ja, i, (jobject)(void*)SvIV(rv));
  565. #endif
  566.                 }
  567.                 else {
  568. #ifdef WIN32
  569.                 jobject str = (jobject)env->NewStringUTF(SvPV(*esv,n_a));
  570. #else
  571.                 jobject str = (jobject)(*env)->NewStringUTF(env, SvPV(*esv,n_a));
  572. #endif
  573. #ifdef WIN32
  574.                 env->SetObjectArrayElement(ja, i, str);
  575. #else
  576.                 (*env)->SetObjectArrayElement(env, ja, i, str);
  577. #endif
  578.                 }
  579.             }
  580.             jv[ix++].l = (jobject)ja;
  581.             }
  582.             else
  583.             jv[ix++].l = (jobject)(void*)0;
  584.         }
  585.         else
  586.             jv[ix++].l = (jobject)(void*)0;
  587.         break;
  588.         }
  589.         break;
  590.     case 'L':
  591.         if (!SvROK(sv) || strnEQ(s, "java/lang/String;", 17)) {
  592.         s += 17;
  593. #ifdef WIN32
  594.         jv[ix++].l = (jobject)env->NewStringUTF((char*) SvPV(sv,n_a));
  595. #else
  596.         jv[ix++].l = (jobject)(*env)->NewStringUTF(env, (char*) SvPV(sv,n_a));
  597. #endif
  598.         break;
  599.         }
  600.         while (*s != ';') s++;
  601.         s++;
  602.         if (SvROK(sv)) {
  603.         SV* rv = SvRV(sv);
  604.         jv[ix++].l = (jobject)(void*)SvIV(rv);
  605.         }
  606.         break;
  607.     case ')':
  608.         croak("too many arguments, signature: %s", sig);
  609.         goto cleanup;
  610.     default:
  611.         croak("panic: malformed signature: %s", s-1);
  612.         goto cleanup;
  613.     }
  614.  
  615.     }
  616.     if (*s != ')') {
  617.     croak("not enough arguments, signature: %s", sig);
  618.     goto cleanup;
  619.     }
  620.     return jv;
  621.  
  622. cleanup:
  623.     safefree((char*)jv);
  624.     return 0;
  625. }
  626.  
  627. static int
  628. not_here(char *s)
  629. {
  630.     croak("%s not implemented on this architecture", s);
  631.     return -1;
  632. }
  633.  
  634. static double
  635. constant(char *name, int arg)
  636. {
  637.     errno = 0;
  638.     switch (*name) {
  639.     case 'A':
  640.     break;
  641.     case 'B':
  642.     break;
  643.     case 'C':
  644.     break;
  645.     case 'D':
  646.     break;
  647.     case 'E':
  648.     break;
  649.     case 'F':
  650.     break;
  651.     case 'G':
  652.     break;
  653.     case 'H':
  654.     break;
  655.     case 'I':
  656.     break;
  657.     case 'J':
  658.     if (strEQ(name, "JNI_ABORT"))
  659. #ifdef JNI_ABORT
  660.         return JNI_ABORT;
  661. #else
  662.         goto not_there;
  663. #endif
  664.     if (strEQ(name, "JNI_COMMIT"))
  665. #ifdef JNI_COMMIT
  666.         return JNI_COMMIT;
  667. #else
  668.         goto not_there;
  669. #endif
  670.     if (strEQ(name, "JNI_ERR"))
  671. #ifdef JNI_ERR
  672.         return JNI_ERR;
  673. #else
  674.         goto not_there;
  675. #endif
  676.     if (strEQ(name, "JNI_FALSE"))
  677. #ifdef JNI_FALSE
  678.         return JNI_FALSE;
  679. #else
  680.         goto not_there;
  681. #endif
  682.     if (strEQ(name, "JNI_H"))
  683. #ifdef JNI_H
  684. #ifdef WIN32
  685.         return 1;
  686. #else
  687.         return JNI_H;
  688. #endif
  689. #else
  690.         goto not_there;
  691. #endif
  692.     if (strEQ(name, "JNI_OK"))
  693. #ifdef JNI_OK
  694.         return JNI_OK;
  695. #else
  696.         goto not_there;
  697. #endif
  698.     if (strEQ(name, "JNI_TRUE"))
  699. #ifdef JNI_TRUE
  700.         return JNI_TRUE;
  701. #else
  702.         goto not_there;
  703. #endif
  704.     break;
  705.     case 'K':
  706.     break;
  707.     case 'L':
  708.     break;
  709.     case 'M':
  710.     break;
  711.     case 'N':
  712.     break;
  713.     case 'O':
  714.     break;
  715.     case 'P':
  716.     break;
  717.     case 'Q':
  718.     break;
  719.     case 'R':
  720.     break;
  721.     case 'S':
  722.     break;
  723.     case 'T':
  724.     break;
  725.     case 'U':
  726.     break;
  727.     case 'V':
  728.     break;
  729.     case 'W':
  730.     break;
  731.     case 'X':
  732.     break;
  733.     case 'Y':
  734.     break;
  735.     case 'Z':
  736.     break;
  737.     }
  738.     errno = EINVAL;
  739.     return 0;
  740.  
  741. not_there:
  742.     errno = ENOENT;
  743.     return 0;
  744. }
  745.  
  746. #define FETCHENV jplcurenv
  747. #define RESTOREENV jplcurenv = env
  748.  
  749. MODULE = JNI        PACKAGE = JNI        
  750.  
  751. PROTOTYPES: ENABLE
  752.  
  753. double
  754. constant(name,arg)
  755.     char *        name
  756.     int        arg
  757.  
  758. jint
  759. GetVersion()
  760.     JNIEnv *        env = FETCHENV;
  761.     CODE:
  762.     {
  763. #ifdef WIN32
  764.         RETVAL = env->GetVersion();
  765. #else
  766.         RETVAL = (*env)->GetVersion(env);
  767. #endif
  768.         RESTOREENV;
  769.     }
  770.     OUTPUT:
  771.     RETVAL
  772.  
  773. jclass
  774. DefineClass(name, loader, buf)
  775.     JNIEnv *        env = FETCHENV;
  776.     STRLEN            tmplen = NO_INIT;
  777.     jsize            buf_len_ = NO_INIT;
  778.     const char *        name
  779.     jobject            loader
  780.     const jbyte *        buf
  781.     CODE:
  782.     {
  783. #ifdef KAFFE
  784. #ifdef WIN32
  785.         RETVAL = env->DefineClass( loader, buf, (jsize)buf_len_);
  786. #else
  787.         RETVAL = (*env)->DefineClass(env,  loader, buf, (jsize)buf_len_);
  788. #endif
  789. #else
  790. #ifdef WIN32
  791.         RETVAL = env->DefineClass( name, loader, buf, (jsize)buf_len_); 
  792. #else
  793.         RETVAL = (*env)->DefineClass(env,  name, loader, buf, (jsize)buf_len_); 
  794. #endif
  795. #endif
  796.         RESTOREENV;
  797.     }
  798.     OUTPUT:
  799.     RETVAL
  800.  
  801. jclass
  802. FindClass(name)
  803.     JNIEnv *        env = FETCHENV;
  804.     const char *        name
  805.     CODE:
  806.     {
  807. #ifdef WIN32
  808.         RETVAL = env->FindClass( name);
  809. #else
  810.         RETVAL = (*env)->FindClass(env,  name);
  811. #endif
  812.         RESTOREENV;
  813.     }
  814.     OUTPUT:
  815.     RETVAL
  816.  
  817. jclass
  818. GetSuperclass(sub)
  819.     JNIEnv *        env = FETCHENV;
  820.     jclass            sub
  821.     CODE:
  822.     {
  823. #ifdef WIN32
  824.         RETVAL = env->GetSuperclass( sub);
  825. #else
  826.         RETVAL = (*env)->GetSuperclass(env,  sub);
  827. #endif
  828.         RESTOREENV;
  829.     }
  830.     OUTPUT:
  831.     RETVAL
  832.  
  833. jboolean
  834. IsAssignableFrom(sub, sup)
  835.     JNIEnv *        env = FETCHENV;
  836.     jclass            sub
  837.     jclass            sup
  838.     CODE:
  839.     {
  840. #ifdef WIN32
  841.         RETVAL = env->IsAssignableFrom( sub, sup);
  842. #else
  843.         RETVAL = (*env)->IsAssignableFrom(env,  sub, sup);
  844. #endif
  845.         RESTOREENV;
  846.     }
  847.     OUTPUT:
  848.     RETVAL
  849.  
  850. SysRet
  851. Throw(obj)
  852.     JNIEnv *        env = FETCHENV;
  853.     jthrowable        obj
  854.     CODE:
  855.     {
  856. #ifdef WIN32
  857.         RETVAL = env->Throw( obj);
  858. #else
  859.         RETVAL = (*env)->Throw(env,  obj);
  860. #endif
  861.         RESTOREENV;
  862.     }
  863.     OUTPUT:
  864.     RETVAL    
  865.  
  866. SysRet
  867. ThrowNew(clazz, msg)
  868.     JNIEnv *        env = FETCHENV;
  869.     jclass            clazz
  870.     const char *        msg
  871.     CODE:
  872.     {
  873. #ifdef WIN32
  874.         RETVAL = env->ThrowNew( clazz, msg);
  875. #else
  876.         RETVAL = (*env)->ThrowNew(env,  clazz, msg);
  877. #endif
  878.         RESTOREENV;
  879.     }
  880.     OUTPUT:
  881.     RETVAL
  882.  
  883. jthrowable
  884. ExceptionOccurred()
  885.     JNIEnv *        env = FETCHENV;
  886.     CODE:
  887.     {
  888. #ifdef WIN32
  889.         RETVAL = env->ExceptionOccurred();
  890. #else
  891.         RETVAL = (*env)->ExceptionOccurred(env);
  892. #endif
  893.         RESTOREENV;
  894.     }
  895.     OUTPUT:
  896.     RETVAL
  897.  
  898. void
  899. ExceptionDescribe()
  900.     JNIEnv *        env = FETCHENV;
  901.     CODE:
  902.     {
  903. #ifdef WIN32
  904.         env->ExceptionDescribe();
  905. #else
  906.         (*env)->ExceptionDescribe(env);
  907. #endif
  908.         RESTOREENV;
  909.     }
  910.  
  911. void
  912. ExceptionClear()
  913.     JNIEnv *        env = FETCHENV;
  914.     CODE:
  915.     {
  916. #ifdef WIN32
  917.         env->ExceptionClear();
  918. #else
  919.         (*env)->ExceptionClear(env);
  920. #endif
  921.         RESTOREENV;
  922.     }
  923.  
  924. void
  925. FatalError(msg)
  926.     JNIEnv *        env = FETCHENV;
  927.     const char *        msg
  928.     CODE:
  929.     {
  930. #ifdef WIN32
  931.         env->FatalError( msg);
  932. #else
  933.         (*env)->FatalError(env,  msg);
  934. #endif
  935.         RESTOREENV;
  936.     }
  937.  
  938. jobject
  939. NewGlobalRef(lobj)
  940.     JNIEnv *        env = FETCHENV;
  941.     jobject            lobj
  942.     CODE:
  943.     {
  944. #ifdef WIN32
  945.         RETVAL = env->NewGlobalRef(lobj);
  946. #else
  947.         RETVAL = (*env)->NewGlobalRef(env, lobj);
  948. #endif
  949.         RESTOREENV;
  950.     }
  951.     OUTPUT:
  952.     RETVAL
  953.  
  954. void
  955. DeleteGlobalRef(gref)
  956.     JNIEnv *        env = FETCHENV;
  957.     jobject            gref
  958.     CODE:
  959.     {
  960. #ifdef WIN32
  961.         env->DeleteGlobalRef(gref);
  962. #else
  963.         (*env)->DeleteGlobalRef(env, gref);
  964. #endif
  965.         RESTOREENV;
  966.     }
  967.  
  968. void
  969. DeleteLocalRef(obj)
  970.     JNIEnv *        env = FETCHENV;
  971.     jobject            obj
  972.     CODE:
  973.     {
  974. #ifdef WIN32
  975.         env->DeleteLocalRef( obj);
  976. #else
  977.         (*env)->DeleteLocalRef(env,  obj);
  978. #endif
  979.         RESTOREENV;
  980.     }
  981.  
  982. jboolean
  983. IsSameObject(obj1,obj2)
  984.     JNIEnv *        env = FETCHENV;
  985.     jobject            obj1
  986.     jobject            obj2
  987.     CODE:
  988.     {
  989. #ifdef WIN32
  990.         RETVAL = env->IsSameObject(obj1,obj2);
  991. #else
  992.         RETVAL = (*env)->IsSameObject(env, obj1,obj2);
  993. #endif
  994.         RESTOREENV;
  995.     }
  996.     OUTPUT:
  997.     RETVAL
  998.  
  999. jobject
  1000. AllocObject(clazz)
  1001.     JNIEnv *        env = FETCHENV;
  1002.     jclass            clazz
  1003.     CODE:
  1004.     {
  1005. #ifdef WIN32
  1006.         RETVAL = env->AllocObject(clazz);
  1007. #else
  1008.         RETVAL = (*env)->AllocObject(env, clazz);
  1009. #endif
  1010.         RESTOREENV;
  1011.     }
  1012.     OUTPUT:
  1013.     RETVAL
  1014.  
  1015. jobject
  1016. NewObject(clazz,methodID,...)
  1017.     JNIEnv *        env = FETCHENV;
  1018.     jclass            clazz
  1019.     jmethodID        methodID
  1020.     char *            sig = 0;
  1021.     int            argoff = $min_args;
  1022.     CODE:
  1023.     {
  1024.         jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
  1025. #ifdef WIN32
  1026.         RETVAL = env->NewObjectA(clazz,methodID,args);
  1027. #else
  1028.         RETVAL = (*env)->NewObjectA(env, clazz,methodID,args);
  1029. #endif
  1030.         RESTOREENV;
  1031.     }
  1032.     OUTPUT:
  1033.     RETVAL
  1034.  
  1035. jobject
  1036. NewObjectA(clazz,methodID,args)
  1037.     JNIEnv *        env = FETCHENV;
  1038.     jclass            clazz
  1039.     jmethodID        methodID
  1040.     char *            sig = 0;
  1041.     jvalue *        args
  1042.     CODE:
  1043.     {
  1044. #ifdef WIN32
  1045.         RETVAL = env->NewObjectA(clazz,methodID,args);
  1046. #else
  1047.         RETVAL = (*env)->NewObjectA(env, clazz,methodID,args);
  1048. #endif
  1049.         RESTOREENV;
  1050.     }
  1051.     OUTPUT:
  1052.     RETVAL
  1053.  
  1054. jclass
  1055. GetObjectClass(obj)
  1056.     JNIEnv *        env = FETCHENV;
  1057.     jobject            obj
  1058.     CODE:
  1059.     {
  1060. #ifdef WIN32
  1061.         RETVAL = env->GetObjectClass(obj);
  1062. #else
  1063.         RETVAL = (*env)->GetObjectClass(env, obj);
  1064. #endif
  1065.         RESTOREENV;
  1066.     }
  1067.     OUTPUT:
  1068.     RETVAL
  1069.  
  1070. jboolean
  1071. IsInstanceOf(obj,clazz)
  1072.     JNIEnv *        env = FETCHENV;
  1073.     jobject            obj
  1074.     jclass            clazz
  1075.     CODE:
  1076.     {
  1077. #ifdef WIN32
  1078.         RETVAL = env->IsInstanceOf(obj,clazz);
  1079. #else
  1080.         RETVAL = (*env)->IsInstanceOf(env, obj,clazz);
  1081. #endif
  1082.         RESTOREENV;
  1083.     }
  1084.     OUTPUT:
  1085.     RETVAL
  1086.  
  1087. jmethodID
  1088. GetMethodID(clazz,name,sig)
  1089.     JNIEnv *        env = FETCHENV;
  1090.     jclass            clazz
  1091.     const char *        name
  1092.     const char *        sig
  1093.     CODE:
  1094.     {
  1095. #ifdef WIN32
  1096.         RETVAL = env->GetMethodID(clazz,name,sig);
  1097. #else
  1098.         RETVAL = (*env)->GetMethodID(env, clazz,name,sig);
  1099. #endif
  1100.         RESTOREENV;
  1101.     }
  1102.     OUTPUT:
  1103.     RETVAL
  1104.  
  1105. jobject
  1106. CallObjectMethod(obj,methodID,...)
  1107.     JNIEnv *        env = FETCHENV;
  1108.     jobject            obj
  1109.     jmethodID        methodID
  1110.     char *            sig = 0;
  1111.     int            argoff = $min_args;
  1112.     CODE:
  1113.     {
  1114.         jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
  1115. #ifdef WIN32
  1116.         RETVAL = env->CallObjectMethodA(obj,methodID,args);
  1117. #else
  1118.         RETVAL = (*env)->CallObjectMethodA(env, obj,methodID,args);
  1119. #endif
  1120.         RESTOREENV;
  1121.     }
  1122.     OUTPUT:
  1123.     RETVAL
  1124.  
  1125. jobject
  1126. CallObjectMethodA(obj,methodID,args)
  1127.     JNIEnv *        env = FETCHENV;
  1128.     jobject            obj
  1129.     jmethodID        methodID
  1130.     char *            sig = 0;
  1131.     jvalue *        args
  1132.     CODE:
  1133.     {
  1134. #ifdef WIN32
  1135.         RETVAL = env->CallObjectMethodA(obj,methodID,args);
  1136. #else
  1137.         RETVAL = (*env)->CallObjectMethodA(env, obj,methodID,args);
  1138. #endif
  1139.         RESTOREENV;
  1140.     }
  1141.     OUTPUT:
  1142.     RETVAL
  1143.  
  1144. jboolean
  1145. CallBooleanMethod(obj,methodID,...)
  1146.     JNIEnv *        env = FETCHENV;
  1147.     jobject            obj
  1148.     jmethodID        methodID
  1149.     char *            sig = 0;
  1150.     int            argoff = $min_args;
  1151.     CODE:
  1152.     {
  1153.         jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
  1154. #ifdef WIN32
  1155.         RETVAL = env->CallBooleanMethodA(obj,methodID,args);
  1156. #else
  1157.         RETVAL = (*env)->CallBooleanMethodA(env, obj,methodID,args);
  1158. #endif
  1159.         RESTOREENV;
  1160.     }
  1161.     OUTPUT:
  1162.     RETVAL
  1163.  
  1164. jboolean
  1165. CallBooleanMethodA(obj,methodID, args)
  1166.     JNIEnv *        env = FETCHENV;
  1167.     jobject            obj
  1168.     jmethodID        methodID
  1169.     char *            sig = 0;
  1170.     jvalue *        args
  1171.     CODE:
  1172.     {
  1173. #ifdef WIN32
  1174.         RETVAL = env->CallBooleanMethodA(obj,methodID, args);
  1175. #else
  1176.         RETVAL = (*env)->CallBooleanMethodA(env, obj,methodID, args);
  1177. #endif
  1178.         RESTOREENV;
  1179.     }
  1180.     OUTPUT:
  1181.     RETVAL
  1182.  
  1183. jbyte
  1184. CallByteMethod(obj,methodID,...)
  1185.     JNIEnv *        env = FETCHENV;
  1186.     jobject            obj
  1187.     jmethodID        methodID
  1188.     char *            sig = 0;
  1189.     int            argoff = $min_args;
  1190.     CODE:
  1191.     {
  1192.         jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
  1193. #ifdef WIN32
  1194.         RETVAL = env->CallByteMethodA(obj,methodID,args);
  1195. #else
  1196.         RETVAL = (*env)->CallByteMethodA(env, obj,methodID,args);
  1197. #endif
  1198.         RESTOREENV;
  1199.     }
  1200.     OUTPUT:
  1201.     RETVAL
  1202.  
  1203. jbyte
  1204. CallByteMethodA(obj,methodID,args)
  1205.     JNIEnv *        env = FETCHENV;
  1206.     jobject            obj
  1207.     jmethodID        methodID
  1208.     char *            sig = 0;
  1209.     jvalue *        args
  1210.     CODE:
  1211.     {
  1212. #ifdef WIN32
  1213.         RETVAL = env->CallByteMethodA(obj,methodID,args);
  1214. #else
  1215.         RETVAL = (*env)->CallByteMethodA(env, obj,methodID,args);
  1216. #endif
  1217.         RESTOREENV;
  1218.     }
  1219.     OUTPUT:
  1220.     RETVAL
  1221.  
  1222. jchar
  1223. CallCharMethod(obj,methodID,...)
  1224.     JNIEnv *        env = FETCHENV;
  1225.     jobject            obj
  1226.     jmethodID        methodID
  1227.     char *            sig = 0;
  1228.     int            argoff = $min_args;
  1229.     CODE:
  1230.     {
  1231.         jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
  1232. #ifdef WIN32
  1233.         RETVAL = env->CallCharMethodA(obj,methodID,args);
  1234. #else
  1235.         RETVAL = (*env)->CallCharMethodA(env, obj,methodID,args);
  1236. #endif
  1237.         RESTOREENV;
  1238.     }
  1239.     OUTPUT:
  1240.     RETVAL
  1241.  
  1242. jchar
  1243. CallCharMethodA(obj,methodID,args)
  1244.     JNIEnv *        env = FETCHENV;
  1245.     jobject            obj
  1246.     jmethodID        methodID
  1247.     char *            sig = 0;
  1248.     jvalue *        args
  1249.     CODE:
  1250.     {
  1251. #ifdef WIN32
  1252.         RETVAL = env->CallCharMethodA(obj,methodID,args);
  1253. #else
  1254.         RETVAL = (*env)->CallCharMethodA(env, obj,methodID,args);
  1255. #endif
  1256.         RESTOREENV;
  1257.     }
  1258.     OUTPUT:
  1259.     RETVAL
  1260.  
  1261. jshort
  1262. CallShortMethod(obj,methodID,...)
  1263.     JNIEnv *        env = FETCHENV;
  1264.     jobject            obj
  1265.     jmethodID        methodID
  1266.     char *            sig = 0;
  1267.     int            argoff = $min_args;
  1268.     CODE:
  1269.     {
  1270.         jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
  1271. #ifdef WIN32
  1272.         RETVAL = env->CallShortMethodA(obj,methodID,args);
  1273. #else
  1274.         RETVAL = (*env)->CallShortMethodA(env, obj,methodID,args);
  1275. #endif
  1276.         RESTOREENV;
  1277.     }
  1278.     OUTPUT:
  1279.     RETVAL
  1280.  
  1281. jshort
  1282. CallShortMethodA(obj,methodID,args)
  1283.     JNIEnv *        env = FETCHENV;
  1284.     jobject            obj
  1285.     jmethodID        methodID
  1286.     char *            sig = 0;
  1287.     jvalue *        args
  1288.     CODE:
  1289.     {
  1290. #ifdef WIN32
  1291.         RETVAL = env->CallShortMethodA(obj,methodID,args);
  1292. #else
  1293.         RETVAL = (*env)->CallShortMethodA(env, obj,methodID,args);
  1294. #endif
  1295.         RESTOREENV;
  1296.     }
  1297.     OUTPUT:
  1298.     RETVAL
  1299.  
  1300. jint
  1301. CallIntMethod(obj,methodID,...)
  1302.     JNIEnv *        env = FETCHENV;
  1303.     jobject            obj
  1304.     jmethodID        methodID
  1305.     char *            sig = 0;
  1306.     int            argoff = $min_args;
  1307.     CODE:
  1308.     {
  1309.         jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
  1310. #ifdef WIN32
  1311.         RETVAL = env->CallIntMethodA(obj,methodID,args);
  1312. #else
  1313.         RETVAL = (*env)->CallIntMethodA(env, obj,methodID,args);
  1314. #endif
  1315.         RESTOREENV;
  1316.     }
  1317.     OUTPUT:
  1318.     RETVAL
  1319.  
  1320. jint
  1321. CallIntMethodA(obj,methodID,args)
  1322.     JNIEnv *        env = FETCHENV;
  1323.     jobject            obj
  1324.     jmethodID        methodID
  1325.     char *            sig = 0;
  1326.     jvalue *        args
  1327.     CODE:
  1328.     {
  1329. #ifdef WIN32
  1330.         RETVAL = env->CallIntMethodA(obj,methodID,args);
  1331. #else
  1332.         RETVAL = (*env)->CallIntMethodA(env, obj,methodID,args);
  1333. #endif
  1334.         RESTOREENV;
  1335.     }
  1336.     OUTPUT:
  1337.     RETVAL
  1338.  
  1339. jlong
  1340. CallLongMethod(obj,methodID,...)
  1341.     JNIEnv *        env = FETCHENV;
  1342.     jobject            obj
  1343.     jmethodID        methodID
  1344.     char *            sig = 0;
  1345.     int            argoff = $min_args;
  1346.     CODE:
  1347.     {
  1348.         jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
  1349. #ifdef WIN32
  1350.         RETVAL = env->CallLongMethodA(obj,methodID,args);
  1351. #else
  1352.         RETVAL = (*env)->CallLongMethodA(env, obj,methodID,args);
  1353. #endif
  1354.         RESTOREENV;
  1355.     }
  1356.     OUTPUT:
  1357.     RETVAL
  1358.  
  1359. jlong
  1360. CallLongMethodA(obj,methodID,args)
  1361.     JNIEnv *        env = FETCHENV;
  1362.     jobject            obj
  1363.     jmethodID        methodID
  1364.     char *            sig = 0;
  1365.     jvalue *        args
  1366.     CODE:
  1367.     {
  1368. #ifdef WIN32
  1369.         RETVAL = env->CallLongMethodA(obj,methodID,args);
  1370. #else
  1371.         RETVAL = (*env)->CallLongMethodA(env, obj,methodID,args);
  1372. #endif
  1373.         RESTOREENV;
  1374.     }
  1375.     OUTPUT:
  1376.     RETVAL
  1377.  
  1378. jfloat
  1379. CallFloatMethod(obj,methodID,...)
  1380.     JNIEnv *        env = FETCHENV;
  1381.     jobject            obj
  1382.     jmethodID        methodID
  1383.     char *            sig = 0;
  1384.     int            argoff = $min_args;
  1385.     CODE:
  1386.     {
  1387.         jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
  1388. #ifdef WIN32
  1389.         RETVAL = env->CallFloatMethodA(obj,methodID,args);
  1390. #else
  1391.         RETVAL = (*env)->CallFloatMethodA(env, obj,methodID,args);
  1392. #endif
  1393.         RESTOREENV;
  1394.     }
  1395.     OUTPUT:
  1396.     RETVAL
  1397.  
  1398. jfloat
  1399. CallFloatMethodA(obj,methodID,args)
  1400.     JNIEnv *        env = FETCHENV;
  1401.     jobject            obj
  1402.     jmethodID        methodID
  1403.     char *            sig = 0;
  1404.     jvalue *        args
  1405.     CODE:
  1406.     {
  1407. #ifdef WIN32
  1408.         RETVAL = env->CallFloatMethodA(obj,methodID,args);
  1409. #else
  1410.         RETVAL = (*env)->CallFloatMethodA(env, obj,methodID,args);
  1411. #endif
  1412.         RESTOREENV;
  1413.     }
  1414.     OUTPUT:
  1415.     RETVAL
  1416.  
  1417. jdouble
  1418. CallDoubleMethod(obj,methodID,...)
  1419.     JNIEnv *        env = FETCHENV;
  1420.     jobject            obj
  1421.     jmethodID        methodID
  1422.     char *            sig = 0;
  1423.     int            argoff = $min_args;
  1424.     CODE:
  1425.     {
  1426.         jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
  1427. #ifdef WIN32
  1428.         RETVAL = env->CallDoubleMethodA(obj,methodID,args);
  1429. #else
  1430.         RETVAL = (*env)->CallDoubleMethodA(env, obj,methodID,args);
  1431. #endif
  1432.         RESTOREENV;
  1433.     }
  1434.     OUTPUT:
  1435.     RETVAL
  1436.  
  1437. jdouble
  1438. CallDoubleMethodA(obj,methodID,args)
  1439.     JNIEnv *        env = FETCHENV;
  1440.     jobject            obj
  1441.     jmethodID        methodID
  1442.     char *            sig = 0;
  1443.     jvalue *        args
  1444.     CODE:
  1445.     {
  1446. #ifdef WIN32
  1447.         RETVAL = env->CallDoubleMethodA(obj,methodID,args);
  1448. #else
  1449.         RETVAL = (*env)->CallDoubleMethodA(env, obj,methodID,args);
  1450. #endif
  1451.         RESTOREENV;
  1452.     }
  1453.     OUTPUT:
  1454.     RETVAL
  1455.  
  1456. void
  1457. CallVoidMethod(obj,methodID,...)
  1458.     JNIEnv *        env = FETCHENV;
  1459.     jobject            obj
  1460.     jmethodID        methodID
  1461.     char *            sig = 0;
  1462.     int            argoff = $min_args;
  1463.     CODE:
  1464.     {
  1465.         jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
  1466. #ifdef WIN32
  1467.         env->CallVoidMethodA(obj,methodID,args);
  1468. #else
  1469.         (*env)->CallVoidMethodA(env, obj,methodID,args);
  1470. #endif
  1471.         RESTOREENV;
  1472.     }
  1473.  
  1474. void
  1475. CallVoidMethodA(obj,methodID,args)
  1476.     JNIEnv *        env = FETCHENV;
  1477.     jobject            obj
  1478.     jmethodID        methodID
  1479.     char *            sig = 0;
  1480.     jvalue *        args
  1481.     CODE:
  1482.     {
  1483. #ifdef WIN32
  1484.         env->CallVoidMethodA(obj,methodID,args);
  1485. #else
  1486.         (*env)->CallVoidMethodA(env, obj,methodID,args);
  1487. #endif
  1488.         RESTOREENV;
  1489.     }
  1490.  
  1491. jobject
  1492. CallNonvirtualObjectMethod(obj,clazz,methodID,...)
  1493.     JNIEnv *        env = FETCHENV;
  1494.     jobject            obj
  1495.     jclass            clazz
  1496.     jmethodID        methodID
  1497.     char *            sig = 0;
  1498.     int            argoff = $min_args;
  1499.     CODE:
  1500.     {
  1501.         jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
  1502. #ifdef WIN32
  1503.         RETVAL = env->CallNonvirtualObjectMethodA(obj,clazz,methodID,args);
  1504. #else
  1505.         RETVAL = (*env)->CallNonvirtualObjectMethodA(env, obj,clazz,methodID,args);
  1506. #endif
  1507.         RESTOREENV;
  1508.     }
  1509.     OUTPUT:
  1510.     RETVAL
  1511.  
  1512. jobject
  1513. CallNonvirtualObjectMethodA(obj,clazz,methodID,args)
  1514.     JNIEnv *        env = FETCHENV;
  1515.     jobject            obj
  1516.     jclass            clazz
  1517.     jmethodID        methodID
  1518.     char *            sig = 0;
  1519.     jvalue *        args
  1520.     CODE:
  1521.     {
  1522. #ifdef WIN32
  1523.         RETVAL = env->CallNonvirtualObjectMethodA(obj,clazz,methodID,args);
  1524. #else
  1525.         RETVAL = (*env)->CallNonvirtualObjectMethodA(env, obj,clazz,methodID,args);
  1526. #endif
  1527.         RESTOREENV;
  1528.     }
  1529.     OUTPUT:
  1530.     RETVAL
  1531.  
  1532. jboolean
  1533. CallNonvirtualBooleanMethod(obj,clazz,methodID,...)
  1534.     JNIEnv *        env = FETCHENV;
  1535.     jobject            obj
  1536.     jclass            clazz
  1537.     jmethodID        methodID
  1538.     char *            sig = 0;
  1539.     int            argoff = $min_args;
  1540.     CODE:
  1541.     {
  1542.         jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
  1543. #ifdef WIN32
  1544.         RETVAL = env->CallNonvirtualBooleanMethodA(obj,clazz,methodID,args);
  1545. #else
  1546.         RETVAL = (*env)->CallNonvirtualBooleanMethodA(env, obj,clazz,methodID,args);
  1547. #endif
  1548.         RESTOREENV;
  1549.     }
  1550.     OUTPUT:
  1551.     RETVAL
  1552.  
  1553. jboolean
  1554. CallNonvirtualBooleanMethodA(obj,clazz,methodID, args)
  1555.     JNIEnv *        env = FETCHENV;
  1556.     jobject            obj
  1557.     jclass            clazz
  1558.     jmethodID        methodID
  1559.     char *            sig = 0;
  1560.     jvalue *        args
  1561.     CODE:
  1562.     {
  1563. #ifdef WIN32
  1564.         RETVAL = env->CallNonvirtualBooleanMethodA(obj,clazz,methodID, args);
  1565. #else
  1566.         RETVAL = (*env)->CallNonvirtualBooleanMethodA(env, obj,clazz,methodID, args);
  1567. #endif
  1568.         RESTOREENV;
  1569.     }
  1570.     OUTPUT:
  1571.     RETVAL
  1572.  
  1573. jbyte
  1574. CallNonvirtualByteMethod(obj,clazz,methodID,...)
  1575.     JNIEnv *        env = FETCHENV;
  1576.     jobject            obj
  1577.     jclass            clazz
  1578.     jmethodID        methodID
  1579.     char *            sig = 0;
  1580.     int            argoff = $min_args;
  1581.     CODE:
  1582.     {
  1583.         jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
  1584. #ifdef WIN32
  1585.         RETVAL = env->CallNonvirtualByteMethodA(obj,clazz,methodID,args);
  1586. #else
  1587.         RETVAL = (*env)->CallNonvirtualByteMethodA(env, obj,clazz,methodID,args);
  1588. #endif
  1589.         RESTOREENV;
  1590.     }
  1591.     OUTPUT:
  1592.     RETVAL
  1593.  
  1594. jbyte
  1595. CallNonvirtualByteMethodA(obj,clazz,methodID,args)
  1596.     JNIEnv *        env = FETCHENV;
  1597.     jobject            obj
  1598.     jclass            clazz
  1599.     jmethodID        methodID
  1600.     char *            sig = 0;
  1601.     jvalue *        args
  1602.     CODE:
  1603.     {
  1604. #ifdef WIN32
  1605.         RETVAL = env->CallNonvirtualByteMethodA(obj,clazz,methodID,args);
  1606. #else
  1607.         RETVAL = (*env)->CallNonvirtualByteMethodA(env, obj,clazz,methodID,args);
  1608. #endif
  1609.         RESTOREENV;
  1610.     }
  1611.     OUTPUT:
  1612.     RETVAL
  1613.  
  1614. jchar
  1615. CallNonvirtualCharMethod(obj,clazz,methodID,...)
  1616.     JNIEnv *        env = FETCHENV;
  1617.     jobject            obj
  1618.     jclass            clazz
  1619.     jmethodID        methodID
  1620.     char *            sig = 0;
  1621.     int            argoff = $min_args;
  1622.     CODE:
  1623.     {
  1624.         jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
  1625. #ifdef WIN32
  1626.         RETVAL = env->CallNonvirtualCharMethodA(obj,clazz,methodID,args);
  1627. #else
  1628.         RETVAL = (*env)->CallNonvirtualCharMethodA(env, obj,clazz,methodID,args);
  1629. #endif
  1630.         RESTOREENV;
  1631.     }
  1632.     OUTPUT:
  1633.     RETVAL
  1634.  
  1635. jchar
  1636. CallNonvirtualCharMethodA(obj,clazz,methodID,args)
  1637.     JNIEnv *        env = FETCHENV;
  1638.     jobject            obj
  1639.     jclass            clazz
  1640.     jmethodID        methodID
  1641.     char *            sig = 0;
  1642.     jvalue *        args
  1643.     CODE:
  1644.     {
  1645. #ifdef WIN32
  1646.         RETVAL = env->CallNonvirtualCharMethodA(obj,clazz,methodID,args);
  1647. #else
  1648.         RETVAL = (*env)->CallNonvirtualCharMethodA(env, obj,clazz,methodID,args);
  1649. #endif
  1650.         RESTOREENV;
  1651.     }
  1652.     OUTPUT:
  1653.     RETVAL
  1654.  
  1655. jshort
  1656. CallNonvirtualShortMethod(obj,clazz,methodID,...)
  1657.     JNIEnv *        env = FETCHENV;
  1658.     jobject            obj
  1659.     jclass            clazz
  1660.     jmethodID        methodID
  1661.     char *            sig = 0;
  1662.     int            argoff = $min_args;
  1663.     CODE:
  1664.     {
  1665.         jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
  1666. #ifdef WIN32
  1667.         RETVAL = env->CallNonvirtualShortMethodA(obj,clazz,methodID,args);
  1668. #else
  1669.         RETVAL = (*env)->CallNonvirtualShortMethodA(env, obj,clazz,methodID,args);
  1670. #endif
  1671.         RESTOREENV;
  1672.     }
  1673.     OUTPUT:
  1674.     RETVAL
  1675.  
  1676. jshort
  1677. CallNonvirtualShortMethodA(obj,clazz,methodID,args)
  1678.     JNIEnv *        env = FETCHENV;
  1679.     jobject            obj
  1680.     jclass            clazz
  1681.     jmethodID        methodID
  1682.     char *            sig = 0;
  1683.     jvalue *        args
  1684.     CODE:
  1685.     {
  1686. #ifdef WIN32
  1687.         RETVAL = env->CallNonvirtualShortMethodA(obj,clazz,methodID,args);
  1688. #else
  1689.         RETVAL = (*env)->CallNonvirtualShortMethodA(env, obj,clazz,methodID,args);
  1690. #endif
  1691.         RESTOREENV;
  1692.     }
  1693.     OUTPUT:
  1694.     RETVAL
  1695.  
  1696. jint
  1697. CallNonvirtualIntMethod(obj,clazz,methodID,...)
  1698.     JNIEnv *        env = FETCHENV;
  1699.     jobject            obj
  1700.     jclass            clazz
  1701.     jmethodID        methodID
  1702.     char *            sig = 0;
  1703.     int            argoff = $min_args;
  1704.     CODE:
  1705.     {
  1706.         jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
  1707. #ifdef WIN32
  1708.         RETVAL = env->CallNonvirtualIntMethodA(obj,clazz,methodID,args);
  1709. #else
  1710.         RETVAL = (*env)->CallNonvirtualIntMethodA(env, obj,clazz,methodID,args);
  1711. #endif
  1712.         RESTOREENV;
  1713.     }
  1714.     OUTPUT:
  1715.     RETVAL
  1716.  
  1717. jint
  1718. CallNonvirtualIntMethodA(obj,clazz,methodID,args)
  1719.     JNIEnv *        env = FETCHENV;
  1720.     jobject            obj
  1721.     jclass            clazz
  1722.     jmethodID        methodID
  1723.     char *            sig = 0;
  1724.     jvalue *        args
  1725.     CODE:
  1726.     {
  1727. #ifdef WIN32
  1728.         RETVAL = env->CallNonvirtualIntMethodA(obj,clazz,methodID,args);
  1729. #else
  1730.         RETVAL = (*env)->CallNonvirtualIntMethodA(env, obj,clazz,methodID,args);
  1731. #endif
  1732.         RESTOREENV;
  1733.     }
  1734.     OUTPUT:
  1735.     RETVAL
  1736.  
  1737. jlong
  1738. CallNonvirtualLongMethod(obj,clazz,methodID,...)
  1739.     JNIEnv *        env = FETCHENV;
  1740.     jobject            obj
  1741.     jclass            clazz
  1742.     jmethodID        methodID
  1743.     char *            sig = 0;
  1744.     int            argoff = $min_args;
  1745.     CODE:
  1746.     {
  1747.         jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
  1748. #ifdef WIN32
  1749.         RETVAL = env->CallNonvirtualLongMethodA(obj,clazz,methodID,args);
  1750. #else
  1751.         RETVAL = (*env)->CallNonvirtualLongMethodA(env, obj,clazz,methodID,args);
  1752. #endif
  1753.         RESTOREENV;
  1754.     }
  1755.     OUTPUT:
  1756.     RETVAL
  1757.  
  1758. jlong
  1759. CallNonvirtualLongMethodA(obj,clazz,methodID,args)
  1760.     JNIEnv *        env = FETCHENV;
  1761.     jobject            obj
  1762.     jclass            clazz
  1763.     jmethodID        methodID
  1764.     char *            sig = 0;
  1765.     jvalue *        args
  1766.     CODE:
  1767.     {
  1768. #ifdef WIN32
  1769.         RETVAL = env->CallNonvirtualLongMethodA(obj,clazz,methodID,args);
  1770. #else
  1771.         RETVAL = (*env)->CallNonvirtualLongMethodA(env, obj,clazz,methodID,args);
  1772. #endif
  1773.         RESTOREENV;
  1774.     }
  1775.     OUTPUT:
  1776.     RETVAL
  1777.  
  1778. jfloat
  1779. CallNonvirtualFloatMethod(obj,clazz,methodID,...)
  1780.     JNIEnv *        env = FETCHENV;
  1781.     jobject            obj
  1782.     jclass            clazz
  1783.     jmethodID        methodID
  1784.     char *            sig = 0;
  1785.     int            argoff = $min_args;
  1786.     CODE:
  1787.     {
  1788.         jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
  1789. #ifdef WIN32
  1790.         RETVAL = env->CallNonvirtualFloatMethodA(obj,clazz,methodID,args);
  1791. #else
  1792.         RETVAL = (*env)->CallNonvirtualFloatMethodA(env, obj,clazz,methodID,args);
  1793. #endif
  1794.         RESTOREENV;
  1795.     }
  1796.     OUTPUT:
  1797.     RETVAL
  1798.  
  1799. jfloat
  1800. CallNonvirtualFloatMethodA(obj,clazz,methodID,args)
  1801.     JNIEnv *        env = FETCHENV;
  1802.     jobject            obj
  1803.     jclass            clazz
  1804.     jmethodID        methodID
  1805.     char *            sig = 0;
  1806.     jvalue *        args
  1807.     CODE:
  1808.     {
  1809. #ifdef WIN32
  1810.         RETVAL = env->CallNonvirtualFloatMethodA(obj,clazz,methodID,args);
  1811. #else
  1812.         RETVAL = (*env)->CallNonvirtualFloatMethodA(env, obj,clazz,methodID,args);
  1813. #endif
  1814.         RESTOREENV;
  1815.     }
  1816.     OUTPUT:
  1817.     RETVAL
  1818.  
  1819. jdouble
  1820. CallNonvirtualDoubleMethod(obj,clazz,methodID,...)
  1821.     JNIEnv *        env = FETCHENV;
  1822.     jobject            obj
  1823.     jclass            clazz
  1824.     jmethodID        methodID
  1825.     char *            sig = 0;
  1826.     int            argoff = $min_args;
  1827.     CODE:
  1828.     {
  1829.         jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
  1830. #ifdef WIN32
  1831.         RETVAL = env->CallNonvirtualDoubleMethodA(obj,clazz,methodID,args);
  1832. #else
  1833.         RETVAL = (*env)->CallNonvirtualDoubleMethodA(env, obj,clazz,methodID,args);
  1834. #endif
  1835.         RESTOREENV;
  1836.     }
  1837.     OUTPUT:
  1838.     RETVAL
  1839.  
  1840. jdouble
  1841. CallNonvirtualDoubleMethodA(obj,clazz,methodID,args)
  1842.     JNIEnv *        env = FETCHENV;
  1843.     jobject            obj
  1844.     jclass            clazz
  1845.     jmethodID        methodID
  1846.     char *            sig = 0;
  1847.     jvalue *        args
  1848.     CODE:
  1849.     {
  1850. #ifdef WIN32
  1851.         RETVAL = env->CallNonvirtualDoubleMethodA(obj,clazz,methodID,args);
  1852. #else
  1853.         RETVAL = (*env)->CallNonvirtualDoubleMethodA(env, obj,clazz,methodID,args);
  1854. #endif
  1855.         RESTOREENV;
  1856.     }
  1857.     OUTPUT:
  1858.     RETVAL
  1859.  
  1860. void
  1861. CallNonvirtualVoidMethod(obj,clazz,methodID,...)
  1862.     JNIEnv *        env = FETCHENV;
  1863.     jobject            obj
  1864.     jclass            clazz
  1865.     jmethodID        methodID
  1866.     char *            sig = 0;
  1867.     int            argoff = $min_args;
  1868.     CODE:
  1869.     {
  1870.         jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
  1871. #ifdef WIN32
  1872.         env->CallNonvirtualVoidMethodA(obj,clazz,methodID,args);
  1873. #else
  1874.         (*env)->CallNonvirtualVoidMethodA(env, obj,clazz,methodID,args);
  1875. #endif
  1876.         RESTOREENV;
  1877.     }
  1878.  
  1879. void
  1880. CallNonvirtualVoidMethodA(obj,clazz,methodID,args)
  1881.     JNIEnv *        env = FETCHENV;
  1882.     jobject            obj
  1883.     jclass            clazz
  1884.     jmethodID        methodID
  1885.     char *            sig = 0;
  1886.     jvalue *        args
  1887.     CODE:
  1888.     {
  1889. #ifdef WIN32
  1890.         env->CallNonvirtualVoidMethodA(obj,clazz,methodID,args);
  1891. #else
  1892.         (*env)->CallNonvirtualVoidMethodA(env, obj,clazz,methodID,args);
  1893. #endif
  1894.         RESTOREENV;
  1895.     }
  1896.  
  1897. jfieldID
  1898. GetFieldID(clazz,name,sig)
  1899.     JNIEnv *        env = FETCHENV;
  1900.     jclass            clazz
  1901.     const char *        name
  1902.     const char *        sig
  1903.     CODE:
  1904.     {
  1905. #ifdef WIN32
  1906.         RETVAL = env->GetFieldID(clazz,name,sig);
  1907. #else
  1908.         RETVAL = (*env)->GetFieldID(env, clazz,name,sig);
  1909. #endif
  1910.         RESTOREENV;
  1911.     }
  1912.     OUTPUT:
  1913.     RETVAL
  1914.  
  1915. jobject
  1916. GetObjectField(obj,fieldID)
  1917.     JNIEnv *        env = FETCHENV;
  1918.     jobject            obj
  1919.     jfieldID        fieldID
  1920.     char *            sig = 0;
  1921.     CODE:
  1922.     {
  1923. #ifdef WIN32
  1924.         RETVAL = env->GetObjectField(obj,fieldID);
  1925. #else
  1926.         RETVAL = (*env)->GetObjectField(env, obj,fieldID);
  1927. #endif
  1928.         RESTOREENV;
  1929.     }
  1930.     OUTPUT:
  1931.     RETVAL
  1932.  
  1933. jboolean
  1934. GetBooleanField(obj,fieldID)
  1935.     JNIEnv *        env = FETCHENV;
  1936.     jobject            obj
  1937.     jfieldID        fieldID
  1938.     char *            sig = 0;
  1939.     CODE:
  1940.     {
  1941. #ifdef WIN32
  1942.         RETVAL = env->GetBooleanField(obj,fieldID);
  1943. #else
  1944.         RETVAL = (*env)->GetBooleanField(env, obj,fieldID);
  1945. #endif
  1946.         RESTOREENV;
  1947.     }
  1948.     OUTPUT:
  1949.     RETVAL
  1950.  
  1951. jbyte
  1952. GetByteField(obj,fieldID)
  1953.     JNIEnv *        env = FETCHENV;
  1954.     jobject            obj
  1955.     jfieldID        fieldID
  1956.     char *            sig = 0;
  1957.     CODE:
  1958.     {
  1959. #ifdef WIN32
  1960.         RETVAL = env->GetByteField(obj,fieldID);
  1961. #else
  1962.         RETVAL = (*env)->GetByteField(env, obj,fieldID);
  1963. #endif
  1964.         RESTOREENV;
  1965.     }
  1966.     OUTPUT:
  1967.     RETVAL
  1968.  
  1969. jchar
  1970. GetCharField(obj,fieldID)
  1971.     JNIEnv *        env = FETCHENV;
  1972.     jobject            obj
  1973.     jfieldID        fieldID
  1974.     char *            sig = 0;
  1975.     CODE:
  1976.     {
  1977. #ifdef WIN32
  1978.         RETVAL = env->GetCharField(obj,fieldID);
  1979. #else
  1980.         RETVAL = (*env)->GetCharField(env, obj,fieldID);
  1981. #endif
  1982.         RESTOREENV;
  1983.     }
  1984.     OUTPUT:
  1985.     RETVAL
  1986.  
  1987. jshort
  1988. GetShortField(obj,fieldID)
  1989.     JNIEnv *        env = FETCHENV;
  1990.     jobject            obj
  1991.     jfieldID        fieldID
  1992.     char *            sig = 0;
  1993.     CODE:
  1994.     {
  1995. #ifdef WIN32
  1996.         RETVAL = env->GetShortField(obj,fieldID);
  1997. #else
  1998.         RETVAL = (*env)->GetShortField(env, obj,fieldID);
  1999. #endif
  2000.         RESTOREENV;
  2001.     }
  2002.     OUTPUT:
  2003.     RETVAL
  2004.  
  2005. jint
  2006. GetIntField(obj,fieldID)
  2007.     JNIEnv *        env = FETCHENV;
  2008.     jobject            obj
  2009.     jfieldID        fieldID
  2010.     char *            sig = 0;
  2011.     CODE:
  2012.     {
  2013. #ifdef WIN32
  2014.         RETVAL = env->GetIntField(obj,fieldID);
  2015. #else
  2016.         RETVAL = (*env)->GetIntField(env, obj,fieldID);
  2017. #endif
  2018.         RESTOREENV;
  2019.     }
  2020.     OUTPUT:
  2021.     RETVAL
  2022.  
  2023. jlong
  2024. GetLongField(obj,fieldID)
  2025.     JNIEnv *        env = FETCHENV;
  2026.     jobject            obj
  2027.     jfieldID        fieldID
  2028.     char *            sig = 0;
  2029.     CODE:
  2030.     {
  2031. #ifdef WIN32
  2032.         RETVAL = env->GetLongField(obj,fieldID);
  2033. #else
  2034.         RETVAL = (*env)->GetLongField(env, obj,fieldID);
  2035. #endif
  2036.         RESTOREENV;
  2037.     }
  2038.     OUTPUT:
  2039.     RETVAL
  2040.  
  2041. jfloat
  2042. GetFloatField(obj,fieldID)
  2043.     JNIEnv *        env = FETCHENV;
  2044.     jobject            obj
  2045.     jfieldID        fieldID
  2046.     char *            sig = 0;
  2047.     CODE:
  2048.     {
  2049. #ifdef WIN32
  2050.         RETVAL = env->GetFloatField(obj,fieldID);
  2051. #else
  2052.         RETVAL = (*env)->GetFloatField(env, obj,fieldID);
  2053. #endif
  2054.         RESTOREENV;
  2055.     }
  2056.     OUTPUT:
  2057.     RETVAL
  2058.  
  2059. jdouble
  2060. GetDoubleField(obj,fieldID)
  2061.     JNIEnv *        env = FETCHENV;
  2062.     jobject            obj
  2063.     jfieldID        fieldID
  2064.     char *            sig = 0;
  2065.     CODE:
  2066.     {
  2067. #ifdef WIN32
  2068.         RETVAL = env->GetDoubleField(obj,fieldID);
  2069. #else
  2070.         RETVAL = (*env)->GetDoubleField(env, obj,fieldID);
  2071. #endif
  2072.         RESTOREENV;
  2073.     }
  2074.     OUTPUT:
  2075.     RETVAL
  2076.  
  2077. void
  2078. SetObjectField(obj,fieldID,val)
  2079.     JNIEnv *        env = FETCHENV;
  2080.     jobject            obj
  2081.     jfieldID        fieldID
  2082.     char *            sig = 0;
  2083.     jobject            val
  2084.     CODE:
  2085.     {
  2086. #ifdef WIN32
  2087.         env->SetObjectField(obj,fieldID,val);
  2088. #else
  2089.         (*env)->SetObjectField(env, obj,fieldID,val);
  2090. #endif
  2091.         RESTOREENV;
  2092.     }
  2093.  
  2094. void
  2095. SetBooleanField(obj,fieldID,val)
  2096.     JNIEnv *        env = FETCHENV;
  2097.     jobject            obj
  2098.     jfieldID        fieldID
  2099.     char *            sig = 0;
  2100.     jboolean        val
  2101.     CODE:
  2102.     {
  2103. #ifdef WIN32
  2104.         env->SetBooleanField(obj,fieldID,val);
  2105. #else
  2106.         (*env)->SetBooleanField(env, obj,fieldID,val);
  2107. #endif
  2108.         RESTOREENV;
  2109.     }
  2110.  
  2111. void
  2112. SetByteField(obj,fieldID,val)
  2113.     JNIEnv *        env = FETCHENV;
  2114.     jobject            obj
  2115.     jfieldID        fieldID
  2116.     char *            sig = 0;
  2117.     jbyte            val
  2118.     CODE:
  2119.     {
  2120. #ifdef WIN32
  2121.         env->SetByteField(obj,fieldID,val);
  2122. #else
  2123.         (*env)->SetByteField(env, obj,fieldID,val);
  2124. #endif
  2125.         RESTOREENV;
  2126.     }
  2127.  
  2128. void
  2129. SetCharField(obj,fieldID,val)
  2130.     JNIEnv *        env = FETCHENV;
  2131.     jobject            obj
  2132.     jfieldID        fieldID
  2133.     char *            sig = 0;
  2134.     jchar            val
  2135.     CODE:
  2136.     {
  2137. #ifdef WIN32
  2138.         env->SetCharField(obj,fieldID,val);
  2139. #else
  2140.         (*env)->SetCharField(env, obj,fieldID,val);
  2141. #endif
  2142.         RESTOREENV;
  2143.     }
  2144.  
  2145. void
  2146. SetShortField(obj,fieldID,val)
  2147.     JNIEnv *        env = FETCHENV;
  2148.     jobject            obj
  2149.     jfieldID        fieldID
  2150.     char *            sig = 0;
  2151.     jshort            val
  2152.     CODE:
  2153.     {
  2154. #ifdef WIN32
  2155.         env->SetShortField(obj,fieldID,val);
  2156. #else
  2157.         (*env)->SetShortField(env, obj,fieldID,val);
  2158. #endif
  2159.         RESTOREENV;
  2160.     }
  2161.  
  2162. void
  2163. SetIntField(obj,fieldID,val)
  2164.     JNIEnv *        env = FETCHENV;
  2165.     jobject            obj
  2166.     jfieldID        fieldID
  2167.     char *            sig = 0;
  2168.     jint            val
  2169.     CODE:
  2170.     {
  2171. #ifdef WIN32
  2172.         env->SetIntField(obj,fieldID,val);
  2173. #else
  2174.         (*env)->SetIntField(env, obj,fieldID,val);
  2175. #endif
  2176.         RESTOREENV;
  2177.     }
  2178.  
  2179. void
  2180. SetLongField(obj,fieldID,val)
  2181.     JNIEnv *        env = FETCHENV;
  2182.     jobject            obj
  2183.     jfieldID        fieldID
  2184.     char *            sig = 0;
  2185.     jlong            val
  2186.     CODE:
  2187.     {
  2188. #ifdef WIN32
  2189.         env->SetLongField(obj,fieldID,val);
  2190. #else
  2191.         (*env)->SetLongField(env, obj,fieldID,val);
  2192. #endif
  2193.         RESTOREENV;
  2194.     }
  2195.  
  2196. void
  2197. SetFloatField(obj,fieldID,val)
  2198.     JNIEnv *        env = FETCHENV;
  2199.     jobject            obj
  2200.     jfieldID        fieldID
  2201.     char *            sig = 0;
  2202.     jfloat            val
  2203.     CODE:
  2204.     {
  2205. #ifdef WIN32
  2206.         env->SetFloatField(obj,fieldID,val);
  2207. #else
  2208.         (*env)->SetFloatField(env, obj,fieldID,val);
  2209. #endif
  2210.         RESTOREENV;
  2211.     }
  2212.  
  2213. void
  2214. SetDoubleField(obj,fieldID,val)
  2215.     JNIEnv *        env = FETCHENV;
  2216.     jobject            obj
  2217.     jfieldID        fieldID
  2218.     char *            sig = 0;
  2219.     jdouble            val
  2220.     CODE:
  2221.     {
  2222. #ifdef WIN32
  2223.         env->SetDoubleField(obj,fieldID,val);
  2224. #else
  2225.         (*env)->SetDoubleField(env, obj,fieldID,val);
  2226. #endif
  2227.         RESTOREENV;
  2228.     }
  2229.  
  2230. jmethodID
  2231. GetStaticMethodID(clazz,name,sig)
  2232.     JNIEnv *        env = FETCHENV;
  2233.     jclass            clazz
  2234.     const char *        name
  2235.     const char *        sig
  2236.     CODE:
  2237.     {
  2238. #ifdef WIN32
  2239.         RETVAL = env->GetStaticMethodID(clazz,name,sig);
  2240. #else
  2241.         RETVAL = (*env)->GetStaticMethodID(env, clazz,name,sig);
  2242. #endif
  2243.         RESTOREENV;
  2244.     }
  2245.     OUTPUT:
  2246.     RETVAL
  2247.  
  2248. jobject
  2249. CallStaticObjectMethod(clazz,methodID,...)
  2250.     JNIEnv *        env = FETCHENV;
  2251.     jclass            clazz
  2252.     jmethodID        methodID
  2253.     char *            sig = 0;
  2254.     int            argoff = $min_args;
  2255.     CODE:
  2256.     {
  2257.         jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
  2258. #ifdef WIN32
  2259.         RETVAL = env->CallStaticObjectMethodA(clazz,methodID,args);
  2260. #else
  2261.         RETVAL = (*env)->CallStaticObjectMethodA(env, clazz,methodID,args);
  2262. #endif
  2263.         RESTOREENV;
  2264.     }
  2265.     OUTPUT:
  2266.     RETVAL
  2267.  
  2268. jobject
  2269. CallStaticObjectMethodA(clazz,methodID,args)
  2270.     JNIEnv *        env = FETCHENV;
  2271.     jclass            clazz
  2272.     jmethodID        methodID
  2273.     char *            sig = 0;
  2274.     jvalue *        args
  2275.     CODE:
  2276.     {
  2277. #ifdef WIN32
  2278.         RETVAL = env->CallStaticObjectMethodA(clazz,methodID,args);
  2279. #else
  2280.         RETVAL = (*env)->CallStaticObjectMethodA(env, clazz,methodID,args);
  2281. #endif
  2282.         RESTOREENV;
  2283.     }
  2284.     OUTPUT:
  2285.     RETVAL
  2286.  
  2287. jboolean
  2288. CallStaticBooleanMethod(clazz,methodID,...)
  2289.     JNIEnv *        env = FETCHENV;
  2290.     jclass            clazz
  2291.     jmethodID        methodID
  2292.     char *            sig = 0;
  2293.     int            argoff = $min_args;
  2294.     CODE:
  2295.     {
  2296.         jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
  2297. #ifdef WIN32
  2298.         RETVAL = env->CallStaticBooleanMethodA(clazz,methodID,args);
  2299. #else
  2300.         RETVAL = (*env)->CallStaticBooleanMethodA(env, clazz,methodID,args);
  2301. #endif
  2302.         RESTOREENV;
  2303.     }
  2304.     OUTPUT:
  2305.     RETVAL
  2306.  
  2307. jboolean
  2308. CallStaticBooleanMethodA(clazz,methodID,args)
  2309.     JNIEnv *        env = FETCHENV;
  2310.     jclass            clazz
  2311.     jmethodID        methodID
  2312.     char *            sig = 0;
  2313.     jvalue *        args
  2314.     CODE:
  2315.     {
  2316. #ifdef WIN32
  2317.         RETVAL = env->CallStaticBooleanMethodA(clazz,methodID,args);
  2318. #else
  2319.         RETVAL = (*env)->CallStaticBooleanMethodA(env, clazz,methodID,args);
  2320. #endif
  2321.         RESTOREENV;
  2322.     }
  2323.     OUTPUT:
  2324.     RETVAL
  2325.  
  2326. jbyte
  2327. CallStaticByteMethod(clazz,methodID,...)
  2328.     JNIEnv *        env = FETCHENV;
  2329.     jclass            clazz
  2330.     jmethodID        methodID
  2331.     char *            sig = 0;
  2332.     int            argoff = $min_args;
  2333.     CODE:
  2334.     {
  2335.         jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
  2336. #ifdef WIN32
  2337.         RETVAL = env->CallStaticByteMethodA(clazz,methodID,args);
  2338. #else
  2339.         RETVAL = (*env)->CallStaticByteMethodA(env, clazz,methodID,args);
  2340. #endif
  2341.         RESTOREENV;
  2342.     }
  2343.     OUTPUT:
  2344.     RETVAL
  2345.  
  2346. jbyte
  2347. CallStaticByteMethodA(clazz,methodID,args)
  2348.     JNIEnv *        env = FETCHENV;
  2349.     jclass            clazz
  2350.     jmethodID        methodID
  2351.     char *            sig = 0;
  2352.     jvalue *        args
  2353.     CODE:
  2354.     {
  2355. #ifdef WIN32
  2356.         RETVAL = env->CallStaticByteMethodA(clazz,methodID,args);
  2357. #else
  2358.         RETVAL = (*env)->CallStaticByteMethodA(env, clazz,methodID,args);
  2359. #endif
  2360.         RESTOREENV;
  2361.     }
  2362.     OUTPUT:
  2363.     RETVAL
  2364.  
  2365. jchar
  2366. CallStaticCharMethod(clazz,methodID,...)
  2367.     JNIEnv *        env = FETCHENV;
  2368.     jclass            clazz
  2369.     jmethodID        methodID
  2370.     char *            sig = 0;
  2371.     int            argoff = $min_args;
  2372.     CODE:
  2373.     {
  2374.         jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
  2375. #ifdef WIN32
  2376.         RETVAL = env->CallStaticCharMethodA(clazz,methodID,args);
  2377. #else
  2378.         RETVAL = (*env)->CallStaticCharMethodA(env, clazz,methodID,args);
  2379. #endif
  2380.         RESTOREENV;
  2381.     }
  2382.     OUTPUT:
  2383.     RETVAL
  2384.  
  2385. jchar
  2386. CallStaticCharMethodA(clazz,methodID,args)
  2387.     JNIEnv *        env = FETCHENV;
  2388.     jclass            clazz
  2389.     jmethodID        methodID
  2390.     char *            sig = 0;
  2391.     jvalue *        args
  2392.     CODE:
  2393.     {
  2394. #ifdef WIN32
  2395.         RETVAL = env->CallStaticCharMethodA(clazz,methodID,args);
  2396. #else
  2397.         RETVAL = (*env)->CallStaticCharMethodA(env, clazz,methodID,args);
  2398. #endif
  2399.         RESTOREENV;
  2400.     }
  2401.     OUTPUT:
  2402.     RETVAL
  2403.  
  2404. jshort
  2405. CallStaticShortMethod(clazz,methodID,...)
  2406.     JNIEnv *        env = FETCHENV;
  2407.     jclass            clazz
  2408.     jmethodID        methodID
  2409.     char *            sig = 0;
  2410.     int            argoff = $min_args;
  2411.     CODE:
  2412.     {
  2413.         jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
  2414. #ifdef WIN32
  2415.         RETVAL = env->CallStaticShortMethodA(clazz,methodID,args);
  2416. #else
  2417.         RETVAL = (*env)->CallStaticShortMethodA(env, clazz,methodID,args);
  2418. #endif
  2419.         RESTOREENV;
  2420.     }
  2421.     OUTPUT:
  2422.     RETVAL
  2423.  
  2424. jshort
  2425. CallStaticShortMethodA(clazz,methodID,args)
  2426.     JNIEnv *        env = FETCHENV;
  2427.     jclass            clazz
  2428.     jmethodID        methodID
  2429.     char *            sig = 0;
  2430.     jvalue *        args
  2431.     CODE:
  2432.     {
  2433. #ifdef WIN32
  2434.         RETVAL = env->CallStaticShortMethodA(clazz,methodID,args);
  2435. #else
  2436.         RETVAL = (*env)->CallStaticShortMethodA(env, clazz,methodID,args);
  2437. #endif
  2438.         RESTOREENV;
  2439.     }
  2440.     OUTPUT:
  2441.     RETVAL
  2442.  
  2443. jint
  2444. CallStaticIntMethod(clazz,methodID,...)
  2445.     JNIEnv *        env = FETCHENV;
  2446.     jclass            clazz
  2447.     jmethodID        methodID
  2448.     char *            sig = 0;
  2449.     int            argoff = $min_args;
  2450.     CODE:
  2451.     {
  2452.         jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
  2453. #ifdef WIN32
  2454.         RETVAL = env->CallStaticIntMethodA(clazz,methodID,args);
  2455. #else
  2456.         RETVAL = (*env)->CallStaticIntMethodA(env, clazz,methodID,args);
  2457. #endif
  2458.         RESTOREENV;
  2459.     }
  2460.     OUTPUT:
  2461.     RETVAL
  2462.  
  2463. jint
  2464. CallStaticIntMethodA(clazz,methodID,args)
  2465.     JNIEnv *        env = FETCHENV;
  2466.     jclass            clazz
  2467.     jmethodID        methodID
  2468.     char *            sig = 0;
  2469.     jvalue *        args
  2470.     CODE:
  2471.     {
  2472. #ifdef WIN32
  2473.         RETVAL = env->CallStaticIntMethodA(clazz,methodID,args);
  2474. #else
  2475.         RETVAL = (*env)->CallStaticIntMethodA(env, clazz,methodID,args);
  2476. #endif
  2477.         RESTOREENV;
  2478.     }
  2479.     OUTPUT:
  2480.     RETVAL
  2481.  
  2482. jlong
  2483. CallStaticLongMethod(clazz,methodID,...)
  2484.     JNIEnv *        env = FETCHENV;
  2485.     jclass            clazz
  2486.     jmethodID        methodID
  2487.     char *            sig = 0;
  2488.     int            argoff = $min_args;
  2489.     CODE:
  2490.     {
  2491.         jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
  2492. #ifdef WIN32
  2493.         RETVAL = env->CallStaticLongMethodA(clazz,methodID,args);
  2494. #else
  2495.         RETVAL = (*env)->CallStaticLongMethodA(env, clazz,methodID,args);
  2496. #endif
  2497.         RESTOREENV;
  2498.     }
  2499.     OUTPUT:
  2500.     RETVAL
  2501.  
  2502. jlong
  2503. CallStaticLongMethodA(clazz,methodID,args)
  2504.     JNIEnv *        env = FETCHENV;
  2505.     jclass            clazz
  2506.     jmethodID        methodID
  2507.     char *            sig = 0;
  2508.     jvalue *        args
  2509.     CODE:
  2510.     {
  2511. #ifdef WIN32
  2512.         RETVAL = env->CallStaticLongMethodA(clazz,methodID,args);
  2513. #else
  2514.         RETVAL = (*env)->CallStaticLongMethodA(env, clazz,methodID,args);
  2515. #endif
  2516.         RESTOREENV;
  2517.     }
  2518.     OUTPUT:
  2519.     RETVAL
  2520.  
  2521. jfloat
  2522. CallStaticFloatMethod(clazz,methodID,...)
  2523.     JNIEnv *        env = FETCHENV;
  2524.     jclass            clazz
  2525.     jmethodID        methodID
  2526.     char *            sig = 0;
  2527.     int            argoff = $min_args;
  2528.     CODE:
  2529.     {
  2530.         jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
  2531. #ifdef WIN32
  2532.         RETVAL = env->CallStaticFloatMethodA(clazz,methodID,args);
  2533. #else
  2534.         RETVAL = (*env)->CallStaticFloatMethodA(env, clazz,methodID,args);
  2535. #endif
  2536.         RESTOREENV;
  2537.     }
  2538.     OUTPUT:
  2539.     RETVAL
  2540.  
  2541. jfloat
  2542. CallStaticFloatMethodA(clazz,methodID,args)
  2543.     JNIEnv *        env = FETCHENV;
  2544.     jclass            clazz
  2545.     jmethodID        methodID
  2546.     char *            sig = 0;
  2547.     jvalue *        args
  2548.     CODE:
  2549.     {
  2550. #ifdef WIN32
  2551.         RETVAL = env->CallStaticFloatMethodA(clazz,methodID,args);
  2552. #else
  2553.         RETVAL = (*env)->CallStaticFloatMethodA(env, clazz,methodID,args);
  2554. #endif
  2555.         RESTOREENV;
  2556.     }
  2557.     OUTPUT:
  2558.     RETVAL
  2559.  
  2560. jdouble
  2561. CallStaticDoubleMethod(clazz,methodID,...)
  2562.     JNIEnv *        env = FETCHENV;
  2563.     jclass            clazz
  2564.     jmethodID        methodID
  2565.     char *            sig = 0;
  2566.     int            argoff = $min_args;
  2567.     CODE:
  2568.     {
  2569.         jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
  2570. #ifdef WIN32
  2571.         RETVAL = env->CallStaticDoubleMethodA(clazz,methodID,args);
  2572. #else
  2573.         RETVAL = (*env)->CallStaticDoubleMethodA(env, clazz,methodID,args);
  2574. #endif
  2575.         RESTOREENV;
  2576.     }
  2577.     OUTPUT:
  2578.     RETVAL
  2579.  
  2580. jdouble
  2581. CallStaticDoubleMethodA(clazz,methodID,args)
  2582.     JNIEnv *        env = FETCHENV;
  2583.     jclass            clazz
  2584.     jmethodID        methodID
  2585.     char *            sig = 0;
  2586.     jvalue *        args
  2587.     CODE:
  2588.     {
  2589. #ifdef WIN32
  2590.         RETVAL = env->CallStaticDoubleMethodA(clazz,methodID,args);
  2591. #else
  2592.         RETVAL = (*env)->CallStaticDoubleMethodA(env, clazz,methodID,args);
  2593. #endif
  2594.         RESTOREENV;
  2595.     }
  2596.     OUTPUT:
  2597.     RETVAL
  2598.  
  2599. void
  2600. CallStaticVoidMethod(cls,methodID,...)
  2601.     JNIEnv *        env = FETCHENV;
  2602.     jclass            cls
  2603.     jmethodID        methodID
  2604.     char *            sig = 0;
  2605.     int            argoff = $min_args;
  2606.     CODE:
  2607.     {
  2608.         jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
  2609. #ifdef WIN32
  2610.         env->CallStaticVoidMethodA(cls,methodID,args);
  2611. #else
  2612.         (*env)->CallStaticVoidMethodA(env, cls,methodID,args);
  2613. #endif
  2614.         RESTOREENV;
  2615.     }
  2616.  
  2617. void
  2618. CallStaticVoidMethodA(cls,methodID,args)
  2619.     JNIEnv *        env = FETCHENV;
  2620.     jclass            cls
  2621.     jmethodID        methodID
  2622.     char *            sig = 0;
  2623.     jvalue *        args
  2624.     CODE:
  2625.     {
  2626. #ifdef WIN32
  2627.         env->CallStaticVoidMethodA(cls,methodID,args);
  2628. #else
  2629.         (*env)->CallStaticVoidMethodA(env, cls,methodID,args);
  2630. #endif
  2631.         RESTOREENV;
  2632.     }
  2633.  
  2634. jfieldID
  2635. GetStaticFieldID(clazz,name,sig)
  2636.     JNIEnv *        env = FETCHENV;
  2637.     jclass            clazz
  2638.     const char *        name
  2639.     const char *        sig
  2640.     CODE:
  2641.     {
  2642. #ifdef WIN32
  2643.         RETVAL = env->GetStaticFieldID(clazz,name,sig);
  2644. #else
  2645.         RETVAL = (*env)->GetStaticFieldID(env, clazz,name,sig);
  2646. #endif
  2647.         RESTOREENV;
  2648.     }
  2649.     OUTPUT:
  2650.     RETVAL
  2651.  
  2652. jobject
  2653. GetStaticObjectField(clazz,fieldID)
  2654.     JNIEnv *        env = FETCHENV;
  2655.     jclass            clazz
  2656.     jfieldID        fieldID
  2657.     char *            sig = 0;
  2658.     CODE:
  2659.     {
  2660. #ifdef WIN32
  2661.         RETVAL = env->GetStaticObjectField(clazz,fieldID);
  2662. #else
  2663.         RETVAL = (*env)->GetStaticObjectField(env, clazz,fieldID);
  2664. #endif
  2665.         RESTOREENV;
  2666.     }
  2667.     OUTPUT:
  2668.     RETVAL
  2669.  
  2670. jboolean
  2671. GetStaticBooleanField(clazz,fieldID)
  2672.     JNIEnv *        env = FETCHENV;
  2673.     jclass            clazz
  2674.     jfieldID        fieldID
  2675.     char *            sig = 0;
  2676.     CODE:
  2677.     {
  2678. #ifdef WIN32
  2679.         RETVAL = env->GetStaticBooleanField(clazz,fieldID);
  2680. #else
  2681.         RETVAL = (*env)->GetStaticBooleanField(env, clazz,fieldID);
  2682. #endif
  2683.         RESTOREENV;
  2684.     }
  2685.     OUTPUT:
  2686.     RETVAL
  2687.  
  2688. jbyte
  2689. GetStaticByteField(clazz,fieldID)
  2690.     JNIEnv *        env = FETCHENV;
  2691.     jclass            clazz
  2692.     jfieldID        fieldID
  2693.     char *            sig = 0;
  2694.     CODE:
  2695.     {
  2696. #ifdef WIN32
  2697.         RETVAL = env->GetStaticByteField(clazz,fieldID);
  2698. #else
  2699.         RETVAL = (*env)->GetStaticByteField(env, clazz,fieldID);
  2700. #endif
  2701.         RESTOREENV;
  2702.     }
  2703.     OUTPUT:
  2704.     RETVAL
  2705.  
  2706. jchar
  2707. GetStaticCharField(clazz,fieldID)
  2708.     JNIEnv *        env = FETCHENV;
  2709.     jclass            clazz
  2710.     jfieldID        fieldID
  2711.     char *            sig = 0;
  2712.     CODE:
  2713.     {
  2714. #ifdef WIN32
  2715.         RETVAL = env->GetStaticCharField(clazz,fieldID);
  2716. #else
  2717.         RETVAL = (*env)->GetStaticCharField(env, clazz,fieldID);
  2718. #endif
  2719.         RESTOREENV;
  2720.     }
  2721.     OUTPUT:
  2722.     RETVAL
  2723.  
  2724. jshort
  2725. GetStaticShortField(clazz,fieldID)
  2726.     JNIEnv *        env = FETCHENV;
  2727.     jclass            clazz
  2728.     jfieldID        fieldID
  2729.     char *            sig = 0;
  2730.     CODE:
  2731.     {
  2732. #ifdef WIN32
  2733.         RETVAL = env->GetStaticShortField(clazz,fieldID);
  2734. #else
  2735.         RETVAL = (*env)->GetStaticShortField(env, clazz,fieldID);
  2736. #endif
  2737.         RESTOREENV;
  2738.     }
  2739.     OUTPUT:
  2740.     RETVAL
  2741.  
  2742. jint
  2743. GetStaticIntField(clazz,fieldID)
  2744.     JNIEnv *        env = FETCHENV;
  2745.     jclass            clazz
  2746.     jfieldID        fieldID
  2747.     char *            sig = 0;
  2748.     CODE:
  2749.     {
  2750. #ifdef WIN32
  2751.         RETVAL = env->GetStaticIntField(clazz,fieldID);
  2752. #else
  2753.         RETVAL = (*env)->GetStaticIntField(env, clazz,fieldID);
  2754. #endif
  2755.         RESTOREENV;
  2756.     }
  2757.     OUTPUT:
  2758.     RETVAL
  2759.  
  2760. jlong
  2761. GetStaticLongField(clazz,fieldID)
  2762.     JNIEnv *        env = FETCHENV;
  2763.     jclass            clazz
  2764.     jfieldID        fieldID
  2765.     char *            sig = 0;
  2766.     CODE:
  2767.     {
  2768. #ifdef WIN32
  2769.         RETVAL = env->GetStaticLongField(clazz,fieldID);
  2770. #else
  2771.         RETVAL = (*env)->GetStaticLongField(env, clazz,fieldID);
  2772. #endif
  2773.         RESTOREENV;
  2774.     }
  2775.     OUTPUT:
  2776.     RETVAL
  2777.  
  2778. jfloat
  2779. GetStaticFloatField(clazz,fieldID)
  2780.     JNIEnv *        env = FETCHENV;
  2781.     jclass            clazz
  2782.     jfieldID        fieldID
  2783.     char *            sig = 0;
  2784.     CODE:
  2785.     {
  2786. #ifdef WIN32
  2787.         RETVAL = env->GetStaticFloatField(clazz,fieldID);
  2788. #else
  2789.         RETVAL = (*env)->GetStaticFloatField(env, clazz,fieldID);
  2790. #endif
  2791.         RESTOREENV;
  2792.     }
  2793.     OUTPUT:
  2794.     RETVAL
  2795.  
  2796. jdouble
  2797. GetStaticDoubleField(clazz,fieldID)
  2798.     JNIEnv *        env = FETCHENV;
  2799.     jclass            clazz
  2800.     jfieldID        fieldID
  2801.     char *            sig = 0;
  2802.     CODE:
  2803.     {
  2804. #ifdef WIN32
  2805.         RETVAL = env->GetStaticDoubleField(clazz,fieldID);
  2806. #else
  2807.         RETVAL = (*env)->GetStaticDoubleField(env, clazz,fieldID);
  2808. #endif
  2809.         RESTOREENV;
  2810.     }
  2811.     OUTPUT:
  2812.     RETVAL
  2813.  
  2814. void
  2815. SetStaticObjectField(clazz,fieldID,value)
  2816.     JNIEnv *        env = FETCHENV;
  2817.     jclass            clazz
  2818.     jfieldID        fieldID
  2819.     char *            sig = 0;
  2820.     jobject            value
  2821.     CODE:
  2822.     {
  2823. #ifdef WIN32
  2824.       env->SetStaticObjectField(clazz,fieldID,value);
  2825. #else
  2826.       (*env)->SetStaticObjectField(env, clazz,fieldID,value);
  2827. #endif
  2828.         RESTOREENV;
  2829.     }
  2830.  
  2831. void
  2832. SetStaticBooleanField(clazz,fieldID,value)
  2833.     JNIEnv *        env = FETCHENV;
  2834.     jclass            clazz
  2835.     jfieldID        fieldID
  2836.     char *            sig = 0;
  2837.     jboolean        value
  2838.     CODE:
  2839.     {
  2840. #ifdef WIN32
  2841.       env->SetStaticBooleanField(clazz,fieldID,value);
  2842. #else
  2843.       (*env)->SetStaticBooleanField(env, clazz,fieldID,value);
  2844. #endif
  2845.         RESTOREENV;
  2846.     }
  2847.  
  2848. void
  2849. SetStaticByteField(clazz,fieldID,value)
  2850.     JNIEnv *        env = FETCHENV;
  2851.     jclass            clazz
  2852.     jfieldID        fieldID
  2853.     char *            sig = 0;
  2854.     jbyte            value
  2855.     CODE:
  2856.     {
  2857. #ifdef WIN32
  2858.       env->SetStaticByteField(clazz,fieldID,value);
  2859. #else
  2860.       (*env)->SetStaticByteField(env, clazz,fieldID,value);
  2861. #endif
  2862.         RESTOREENV;
  2863.     }
  2864.  
  2865. void
  2866. SetStaticCharField(clazz,fieldID,value)
  2867.     JNIEnv *        env = FETCHENV;
  2868.     jclass            clazz
  2869.     jfieldID        fieldID
  2870.     char *            sig = 0;
  2871.     jchar            value
  2872.     CODE:
  2873.     {
  2874. #ifdef WIN32
  2875.       env->SetStaticCharField(clazz,fieldID,value);
  2876. #else
  2877.       (*env)->SetStaticCharField(env, clazz,fieldID,value);
  2878. #endif
  2879.         RESTOREENV;
  2880.     }
  2881.  
  2882. void
  2883. SetStaticShortField(clazz,fieldID,value)
  2884.     JNIEnv *        env = FETCHENV;
  2885.     jclass            clazz
  2886.     jfieldID        fieldID
  2887.     char *            sig = 0;
  2888.     jshort            value
  2889.     CODE:
  2890.     {
  2891. #ifdef WIN32
  2892.       env->SetStaticShortField(clazz,fieldID,value);
  2893. #else
  2894.       (*env)->SetStaticShortField(env, clazz,fieldID,value);
  2895. #endif
  2896.         RESTOREENV;
  2897.     }
  2898.  
  2899. void
  2900. SetStaticIntField(clazz,fieldID,value)
  2901.     JNIEnv *        env = FETCHENV;
  2902.     jclass            clazz
  2903.     jfieldID        fieldID
  2904.     char *            sig = 0;
  2905.     jint            value
  2906.     CODE:
  2907.     {
  2908. #ifdef WIN32
  2909.       env->SetStaticIntField(clazz,fieldID,value);
  2910. #else
  2911.       (*env)->SetStaticIntField(env, clazz,fieldID,value);
  2912. #endif
  2913.         RESTOREENV;
  2914.     }
  2915.  
  2916. void
  2917. SetStaticLongField(clazz,fieldID,value)
  2918.     JNIEnv *        env = FETCHENV;
  2919.     jclass            clazz
  2920.     jfieldID        fieldID
  2921.     char *            sig = 0;
  2922.     jlong            value
  2923.     CODE:
  2924.     {
  2925. #ifdef WIN32
  2926.       env->SetStaticLongField(clazz,fieldID,value);
  2927. #else
  2928.       (*env)->SetStaticLongField(env, clazz,fieldID,value);
  2929. #endif
  2930.         RESTOREENV;
  2931.     }
  2932.  
  2933. void
  2934. SetStaticFloatField(clazz,fieldID,value)
  2935.     JNIEnv *        env = FETCHENV;
  2936.     jclass            clazz
  2937.     jfieldID        fieldID
  2938.     char *            sig = 0;
  2939.     jfloat            value
  2940.     CODE:
  2941.     {
  2942. #ifdef WIN32
  2943.       env->SetStaticFloatField(clazz,fieldID,value);
  2944. #else
  2945.       (*env)->SetStaticFloatField(env, clazz,fieldID,value);
  2946. #endif
  2947.         RESTOREENV;
  2948.     }
  2949.  
  2950. void
  2951. SetStaticDoubleField(clazz,fieldID,value)
  2952.     JNIEnv *        env = FETCHENV;
  2953.     jclass            clazz
  2954.     jfieldID        fieldID
  2955.     char *            sig = 0;
  2956.     jdouble            value
  2957.     CODE:
  2958.     {
  2959. #ifdef WIN32
  2960.       env->SetStaticDoubleField(clazz,fieldID,value);
  2961. #else
  2962.       (*env)->SetStaticDoubleField(env, clazz,fieldID,value);
  2963. #endif
  2964.         RESTOREENV;
  2965.     }
  2966.  
  2967. jstring
  2968. NewString(unicode)
  2969.     JNIEnv *        env = FETCHENV;
  2970.     STRLEN            tmplen = NO_INIT;
  2971.     jsize            unicode_len_ = NO_INIT;
  2972.     const jchar *        unicode
  2973.     CODE:
  2974.     {
  2975. #ifdef WIN32
  2976.         RETVAL = env->NewString(unicode, unicode_len_);
  2977. #else
  2978.         RETVAL = (*env)->NewString(env, unicode, unicode_len_);
  2979. #endif
  2980.         RESTOREENV;
  2981.     }
  2982.     OUTPUT:
  2983.     RETVAL
  2984.  
  2985. jsize
  2986. GetStringLength(str)
  2987.     JNIEnv *        env = FETCHENV;
  2988.     jstring            str
  2989.     CODE:
  2990.     {
  2991. #ifdef WIN32
  2992.         RETVAL = env->GetStringLength(str);
  2993. #else
  2994.         RETVAL = (*env)->GetStringLength(env, str);
  2995. #endif
  2996.         RESTOREENV;
  2997.     }
  2998.     OUTPUT:
  2999.     RETVAL
  3000.  
  3001. const jchar *
  3002. GetStringChars(str)
  3003.     JNIEnv *        env = FETCHENV;
  3004.     jstring            str
  3005.     jboolean        isCopy = NO_INIT;
  3006.     jsize             RETVAL_len_ = NO_INIT;
  3007.     CODE:
  3008.     {
  3009. #ifdef WIN32
  3010.         RETVAL = env->GetStringChars(str,&isCopy);
  3011. #else
  3012.         RETVAL = (*env)->GetStringChars(env, str,&isCopy);
  3013. #endif
  3014. #ifdef WIN32
  3015.         RETVAL_len_ = env->GetStringLength(str);
  3016. #else
  3017.         RETVAL_len_ = (*env)->GetStringLength(env, str);
  3018. #endif
  3019.         RESTOREENV;
  3020.     }
  3021.     OUTPUT:
  3022.     RETVAL
  3023.     CLEANUP:
  3024. #ifdef WIN32
  3025.         env->ReleaseStringChars(str,RETVAL);
  3026. #else
  3027.         (*env)->ReleaseStringChars(env, str,RETVAL);
  3028. #endif
  3029.  
  3030. jstring
  3031. NewStringUTF(utf)
  3032.     JNIEnv *        env = FETCHENV;
  3033.     const char *        utf
  3034.     CODE:
  3035.     {
  3036. #ifdef WIN32
  3037.         RETVAL = env->NewStringUTF(utf);
  3038. #else
  3039.         RETVAL = (*env)->NewStringUTF(env, utf);
  3040. #endif
  3041.         RESTOREENV;
  3042.     }
  3043.     OUTPUT:
  3044.     RETVAL
  3045.  
  3046. jsize
  3047. GetStringUTFLength(str)
  3048.     JNIEnv *        env = FETCHENV;
  3049.     jstring            str
  3050.     CODE:
  3051.     {
  3052. #ifdef WIN32
  3053.         RETVAL = env->GetStringUTFLength(str);
  3054. #else
  3055.         RETVAL = (*env)->GetStringUTFLength(env, str);
  3056. #endif
  3057.         RESTOREENV;
  3058.     }
  3059.     OUTPUT:
  3060.     RETVAL
  3061.  
  3062. const char *
  3063. GetStringUTFChars(str)
  3064.     JNIEnv *        env = FETCHENV;
  3065.     jstring            str
  3066.     jboolean        isCopy = NO_INIT;
  3067.     CODE:
  3068.     {
  3069. #ifdef WIN32
  3070.         RETVAL = env->GetStringUTFChars(str,&isCopy);
  3071. #else
  3072.         RETVAL = (*env)->GetStringUTFChars(env, str,&isCopy);
  3073. #endif
  3074.         RESTOREENV;
  3075.     }
  3076.     OUTPUT:
  3077.     RETVAL
  3078.     CLEANUP:
  3079. #ifdef WIN32
  3080.     env->ReleaseStringUTFChars(str, RETVAL);
  3081. #else
  3082.     (*env)->ReleaseStringUTFChars(env, str, RETVAL);
  3083. #endif
  3084.  
  3085.  
  3086. jsize
  3087. GetArrayLength(array)
  3088.     JNIEnv *        env = FETCHENV;
  3089.     jarray            array
  3090.     CODE:
  3091.     {
  3092. #ifdef WIN32
  3093.         RETVAL = env->GetArrayLength(array);
  3094. #else
  3095.         RETVAL = (*env)->GetArrayLength(env, array);
  3096. #endif
  3097.         RESTOREENV;
  3098.     }
  3099.     OUTPUT:
  3100.     RETVAL
  3101.  
  3102. jobjectArray
  3103. NewObjectArray(len,clazz,init)
  3104.     JNIEnv *        env = FETCHENV;
  3105.     jsize            len
  3106.     jclass            clazz
  3107.     jobject            init
  3108.     CODE:
  3109.     {
  3110. #ifdef WIN32
  3111.         RETVAL = env->NewObjectArray(len,clazz,init);
  3112. #else
  3113.         RETVAL = (*env)->NewObjectArray(env, len,clazz,init);
  3114. #endif
  3115.         RESTOREENV;
  3116.     }
  3117.     OUTPUT:
  3118.     RETVAL
  3119.  
  3120. jobject
  3121. GetObjectArrayElement(array,index)
  3122.     JNIEnv *        env = FETCHENV;
  3123.     jobjectArray        array
  3124.     jsize            index
  3125.     CODE:
  3126.     {
  3127. #ifdef WIN32
  3128.         RETVAL = env->GetObjectArrayElement(array,index);
  3129. #else
  3130.         RETVAL = (*env)->GetObjectArrayElement(env, array,index);
  3131. #endif
  3132.         RESTOREENV;
  3133.     }
  3134.     OUTPUT:
  3135.     RETVAL
  3136.  
  3137. void
  3138. SetObjectArrayElement(array,index,val)
  3139.     JNIEnv *        env = FETCHENV;
  3140.     jobjectArray        array
  3141.     jsize            index
  3142.     jobject            val
  3143.     CODE:
  3144.     {
  3145. #ifdef WIN32
  3146.         env->SetObjectArrayElement(array,index,val);
  3147. #else
  3148.         (*env)->SetObjectArrayElement(env, array,index,val);
  3149. #endif
  3150.         RESTOREENV;
  3151.     }
  3152.  
  3153. jbooleanArray
  3154. NewBooleanArray(len)
  3155.     JNIEnv *        env = FETCHENV;
  3156.     jsize            len
  3157.     CODE:
  3158.     {
  3159. #ifdef WIN32
  3160.         RETVAL = env->NewBooleanArray(len);
  3161. #else
  3162.         RETVAL = (*env)->NewBooleanArray(env, len);
  3163. #endif
  3164.         RESTOREENV;
  3165.     }
  3166.     OUTPUT:
  3167.     RETVAL
  3168.  
  3169. jbyteArray
  3170. NewByteArray(len)
  3171.     JNIEnv *        env = FETCHENV;
  3172.     jsize            len
  3173.     CODE:
  3174.     {
  3175. #ifdef WIN32
  3176.         RETVAL = env->NewByteArray(len);
  3177. #else
  3178.         RETVAL = (*env)->NewByteArray(env, len);
  3179. #endif
  3180.         RESTOREENV;
  3181.     }
  3182.     OUTPUT:
  3183.     RETVAL
  3184.  
  3185. jcharArray
  3186. NewCharArray(len)
  3187.     JNIEnv *        env = FETCHENV;
  3188.     jsize            len
  3189.     CODE:
  3190.     {
  3191. #ifdef WIN32
  3192.         RETVAL = env->NewCharArray(len);
  3193. #else
  3194.         RETVAL = (*env)->NewCharArray(env, len);
  3195. #endif
  3196.         RESTOREENV;
  3197.     }
  3198.     OUTPUT:
  3199.     RETVAL
  3200.  
  3201. jshortArray
  3202. NewShortArray(len)
  3203.     JNIEnv *        env = FETCHENV;
  3204.     jsize            len
  3205.     CODE:
  3206.     {
  3207. #ifdef WIN32
  3208.         RETVAL = env->NewShortArray(len);
  3209. #else
  3210.         RETVAL = (*env)->NewShortArray(env, len);
  3211. #endif
  3212.         RESTOREENV;
  3213.     }
  3214.     OUTPUT:
  3215.     RETVAL
  3216.  
  3217. jintArray
  3218. NewIntArray(len)
  3219.     JNIEnv *        env = FETCHENV;
  3220.     jsize            len
  3221.     CODE:
  3222.     {
  3223. #ifdef WIN32
  3224.         RETVAL = env->NewIntArray(len);
  3225. #else
  3226.         RETVAL = (*env)->NewIntArray(env, len);
  3227. #endif
  3228.         RESTOREENV;
  3229.     }
  3230.     OUTPUT:
  3231.     RETVAL
  3232.  
  3233. jlongArray
  3234. NewLongArray(len)
  3235.     JNIEnv *        env = FETCHENV;
  3236.     jsize            len
  3237.     CODE:
  3238.     {
  3239. #ifdef WIN32
  3240.         RETVAL = env->NewLongArray(len);
  3241. #else
  3242.         RETVAL = (*env)->NewLongArray(env, len);
  3243. #endif
  3244.         RESTOREENV;
  3245.     }
  3246.     OUTPUT:
  3247.     RETVAL
  3248.  
  3249. jfloatArray
  3250. NewFloatArray(len)
  3251.     JNIEnv *        env = FETCHENV;
  3252.     jsize            len
  3253.     CODE:
  3254.     {
  3255. #ifdef WIN32
  3256.         RETVAL = env->NewFloatArray(len);
  3257. #else
  3258.         RETVAL = (*env)->NewFloatArray(env, len);
  3259. #endif
  3260.         RESTOREENV;
  3261.     }
  3262.     OUTPUT:
  3263.     RETVAL
  3264.  
  3265. jdoubleArray
  3266. NewDoubleArray(len)
  3267.     JNIEnv *        env = FETCHENV;
  3268.     jsize            len
  3269.     CODE:
  3270.     {
  3271. #ifdef WIN32
  3272.         RETVAL = env->NewDoubleArray(len);
  3273. #else
  3274.         RETVAL = (*env)->NewDoubleArray(env, len);
  3275. #endif
  3276.         RESTOREENV;
  3277.     }
  3278.     OUTPUT:
  3279.     RETVAL
  3280.  
  3281. jboolean *
  3282. GetBooleanArrayElements(array)
  3283.     JNIEnv *        env = FETCHENV;
  3284.     jsize            RETVAL_len_ = NO_INIT;
  3285.     jbooleanArray        array
  3286.     jboolean        isCopy = NO_INIT;
  3287.     PPCODE:
  3288.     {
  3289. #ifdef WIN32
  3290.         RETVAL = env->GetBooleanArrayElements(array,&isCopy);
  3291. #else
  3292.         RETVAL = (*env)->GetBooleanArrayElements(env, array,&isCopy);
  3293. #endif
  3294. #ifdef WIN32
  3295.         RETVAL_len_ = env->GetArrayLength(array);
  3296. #else
  3297.         RETVAL_len_ = (*env)->GetArrayLength(env, array);
  3298. #endif
  3299.         if (GIMME == G_ARRAY) {
  3300.         int i;
  3301.         jboolean* r = RETVAL;
  3302.         EXTEND(sp, RETVAL_len_);
  3303.         for (i = RETVAL_len_; i; --i) {
  3304.             PUSHs(sv_2mortal(newSViv(*r++)));
  3305.         }
  3306.         }
  3307.         else {
  3308.         if (RETVAL_len_) {
  3309.             PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
  3310.             (STRLEN)RETVAL_len_ * sizeof(jboolean))));
  3311.         }
  3312.         else
  3313.             PUSHs(&PL_sv_no);
  3314.         }
  3315. #ifdef WIN32
  3316.         env->ReleaseBooleanArrayElements(array,RETVAL,JNI_ABORT);
  3317. #else
  3318.         (*env)->ReleaseBooleanArrayElements(env, array,RETVAL,JNI_ABORT);
  3319. #endif
  3320.         RESTOREENV;
  3321.     }
  3322.  
  3323. jbyte *
  3324. GetByteArrayElements(array)
  3325.     JNIEnv *        env = FETCHENV;
  3326.     jsize            RETVAL_len_ = NO_INIT;
  3327.     jbyteArray        array
  3328.     jboolean        isCopy = NO_INIT;
  3329.     PPCODE:
  3330.     {
  3331. #ifdef WIN32
  3332.         RETVAL = env->GetByteArrayElements(array,&isCopy);
  3333. #else
  3334.         RETVAL = (*env)->GetByteArrayElements(env, array,&isCopy);
  3335. #endif
  3336. #ifdef WIN32
  3337.         RETVAL_len_ = env->GetArrayLength(array);
  3338. #else
  3339.         RETVAL_len_ = (*env)->GetArrayLength(env, array);
  3340. #endif
  3341.         if (GIMME == G_ARRAY) {
  3342.         int i;
  3343.         jbyte* r = RETVAL;
  3344.         EXTEND(sp, RETVAL_len_);
  3345.         for (i = RETVAL_len_; i; --i) {
  3346.             PUSHs(sv_2mortal(newSViv(*r++)));
  3347.         }
  3348.         }
  3349.         else {
  3350.         if (RETVAL_len_) {
  3351.             PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
  3352.             (STRLEN)RETVAL_len_ * sizeof(jbyte))));
  3353.         }
  3354.         else
  3355.             PUSHs(&PL_sv_no);
  3356.         }
  3357. #ifdef WIN32
  3358.         env->ReleaseByteArrayElements(array,RETVAL,JNI_ABORT);
  3359. #else
  3360.         (*env)->ReleaseByteArrayElements(env, array,RETVAL,JNI_ABORT);
  3361. #endif
  3362.         RESTOREENV;
  3363.     }
  3364.  
  3365. jchar *
  3366. GetCharArrayElements(array)
  3367.     JNIEnv *        env = FETCHENV;
  3368.     jsize            RETVAL_len_ = NO_INIT;
  3369.     jcharArray        array
  3370.     jboolean        isCopy = NO_INIT;
  3371.     PPCODE:
  3372.     {
  3373. #ifdef WIN32
  3374.         RETVAL = env->GetCharArrayElements(array,&isCopy);
  3375. #else
  3376.         RETVAL = (*env)->GetCharArrayElements(env, array,&isCopy);
  3377. #endif
  3378. #ifdef WIN32
  3379.         RETVAL_len_ = env->GetArrayLength(array);
  3380. #else
  3381.         RETVAL_len_ = (*env)->GetArrayLength(env, array);
  3382. #endif
  3383.         if (GIMME == G_ARRAY) {
  3384.         int i;
  3385.         jchar* r = RETVAL;
  3386.         EXTEND(sp, RETVAL_len_);
  3387.         for (i = RETVAL_len_; i; --i) {
  3388.             PUSHs(sv_2mortal(newSViv(*r++)));
  3389.         }
  3390.         }
  3391.         else {
  3392.         if (RETVAL_len_) {
  3393.             PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
  3394.             (STRLEN)RETVAL_len_ * sizeof(jchar))));
  3395.         }
  3396.         else
  3397.             PUSHs(&PL_sv_no);
  3398.         }
  3399. #ifdef WIN32
  3400.         env->ReleaseCharArrayElements(array,RETVAL,JNI_ABORT);
  3401. #else
  3402.         (*env)->ReleaseCharArrayElements(env, array,RETVAL,JNI_ABORT);
  3403. #endif
  3404.         RESTOREENV;
  3405.     }
  3406.  
  3407. jshort *
  3408. GetShortArrayElements(array)
  3409.     JNIEnv *        env = FETCHENV;
  3410.     jsize            RETVAL_len_ = NO_INIT;
  3411.     jshortArray        array
  3412.     jboolean        isCopy = NO_INIT;
  3413.     PPCODE:
  3414.     {
  3415. #ifdef WIN32
  3416.         RETVAL = env->GetShortArrayElements(array,&isCopy);
  3417. #else
  3418.         RETVAL = (*env)->GetShortArrayElements(env, array,&isCopy);
  3419. #endif
  3420. #ifdef WIN32
  3421.         RETVAL_len_ = env->GetArrayLength(array);
  3422. #else
  3423.         RETVAL_len_ = (*env)->GetArrayLength(env, array);
  3424. #endif
  3425.         if (GIMME == G_ARRAY) {
  3426.         int i;
  3427.         jshort* r = RETVAL;
  3428.         EXTEND(sp, RETVAL_len_);
  3429.         for (i = RETVAL_len_; i; --i) {
  3430.             PUSHs(sv_2mortal(newSViv(*r++)));
  3431.         }
  3432.         }
  3433.         else {
  3434.         if (RETVAL_len_) {
  3435.             PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
  3436.             (STRLEN)RETVAL_len_ * sizeof(jshort))));
  3437.         }
  3438.         else
  3439.             PUSHs(&PL_sv_no);
  3440.         }
  3441. #ifdef WIN32
  3442.         env->ReleaseShortArrayElements(array,RETVAL,JNI_ABORT);
  3443. #else
  3444.         (*env)->ReleaseShortArrayElements(env, array,RETVAL,JNI_ABORT);
  3445. #endif
  3446.         RESTOREENV;
  3447.     }
  3448.  
  3449. jint *
  3450. GetIntArrayElements(array)
  3451.     JNIEnv *        env = FETCHENV;
  3452.     jsize            RETVAL_len_ = NO_INIT;
  3453.     jintArray        array
  3454.     jboolean        isCopy = NO_INIT;
  3455.     PPCODE:
  3456.     {
  3457. #ifdef WIN32
  3458.         RETVAL = env->GetIntArrayElements(array,&isCopy);
  3459. #else
  3460.         RETVAL = (*env)->GetIntArrayElements(env, array,&isCopy);
  3461. #endif
  3462. #ifdef WIN32
  3463.         RETVAL_len_ = env->GetArrayLength(array);
  3464. #else
  3465.         RETVAL_len_ = (*env)->GetArrayLength(env, array);
  3466. #endif
  3467.         if (GIMME == G_ARRAY) {
  3468.         int i;
  3469.         jint* r = RETVAL;
  3470.         EXTEND(sp, RETVAL_len_);
  3471.         for (i = RETVAL_len_; i; --i) {
  3472.             PUSHs(sv_2mortal(newSViv(*r++)));
  3473.         }
  3474.         }
  3475.         else {
  3476.         if (RETVAL_len_) {
  3477.             PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
  3478.             (STRLEN)RETVAL_len_ * sizeof(jint))));
  3479.         }
  3480.         else
  3481.             PUSHs(&PL_sv_no);
  3482.         }
  3483. #ifdef WIN32
  3484.         env->ReleaseIntArrayElements(array,RETVAL,JNI_ABORT);
  3485. #else
  3486.         (*env)->ReleaseIntArrayElements(env, array,RETVAL,JNI_ABORT);
  3487. #endif
  3488.         RESTOREENV;
  3489.     }
  3490.  
  3491. jlong *
  3492. GetLongArrayElements(array)
  3493.     JNIEnv *        env = FETCHENV;
  3494.     jsize            RETVAL_len_ = NO_INIT;
  3495.     jlongArray        array
  3496.     jboolean        isCopy = NO_INIT;
  3497.     PPCODE:
  3498.     {
  3499. #ifdef WIN32
  3500.         RETVAL = env->GetLongArrayElements(array,&isCopy);
  3501. #else
  3502.         RETVAL = (*env)->GetLongArrayElements(env, array,&isCopy);
  3503. #endif
  3504. #ifdef WIN32
  3505.         RETVAL_len_ = env->GetArrayLength(array);
  3506. #else
  3507.         RETVAL_len_ = (*env)->GetArrayLength(env, array);
  3508. #endif
  3509.         if (GIMME == G_ARRAY) {
  3510.         int i;
  3511.         jlong* r = RETVAL;
  3512.         EXTEND(sp, RETVAL_len_);
  3513.         for (i = RETVAL_len_; i; --i) {
  3514.             PUSHs(sv_2mortal(newSViv(*r++)));
  3515.         }
  3516.         }
  3517.         else {
  3518.         if (RETVAL_len_) {
  3519.             PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
  3520.             (STRLEN)RETVAL_len_ * sizeof(jlong))));
  3521.         }
  3522.         else
  3523.             PUSHs(&PL_sv_no);
  3524.         }
  3525. #ifdef WIN32
  3526.         env->ReleaseLongArrayElements(array,RETVAL,JNI_ABORT);
  3527. #else
  3528.         (*env)->ReleaseLongArrayElements(env, array,RETVAL,JNI_ABORT);
  3529. #endif
  3530.         RESTOREENV;
  3531.     }
  3532.  
  3533. jfloat *
  3534. GetFloatArrayElements(array)
  3535.     JNIEnv *        env = FETCHENV;
  3536.     jsize            RETVAL_len_ = NO_INIT;
  3537.     jfloatArray        array
  3538.     jboolean        isCopy = NO_INIT;
  3539.     PPCODE:
  3540.     {
  3541. #ifdef WIN32
  3542.         RETVAL = env->GetFloatArrayElements(array,&isCopy);
  3543. #else
  3544.         RETVAL = (*env)->GetFloatArrayElements(env, array,&isCopy);
  3545. #endif
  3546. #ifdef WIN32
  3547.         RETVAL_len_ = env->GetArrayLength(array);
  3548. #else
  3549.         RETVAL_len_ = (*env)->GetArrayLength(env, array);
  3550. #endif
  3551.         if (GIMME == G_ARRAY) {
  3552.         int i;
  3553.         jfloat* r = RETVAL;
  3554.         EXTEND(sp, RETVAL_len_);
  3555.         for (i = RETVAL_len_; i; --i) {
  3556.             PUSHs(sv_2mortal(newSVnv(*r++)));
  3557.         }
  3558.         }
  3559.         else {
  3560.         if (RETVAL_len_) {
  3561.             PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
  3562.             (STRLEN)RETVAL_len_ * sizeof(jfloat))));
  3563.         }
  3564.         else
  3565.             PUSHs(&PL_sv_no);
  3566.         }
  3567. #ifdef WIN32
  3568.         env->ReleaseFloatArrayElements(array,RETVAL,JNI_ABORT);
  3569. #else
  3570.         (*env)->ReleaseFloatArrayElements(env, array,RETVAL,JNI_ABORT);
  3571. #endif
  3572.         RESTOREENV;
  3573.     }
  3574.  
  3575. jdouble *
  3576. GetDoubleArrayElements(array)
  3577.     JNIEnv *        env = FETCHENV;
  3578.     jsize            RETVAL_len_ = NO_INIT;
  3579.     jdoubleArray        array
  3580.     jboolean        isCopy = NO_INIT;
  3581.     PPCODE:
  3582.     {
  3583. #ifdef WIN32
  3584.         RETVAL = env->GetDoubleArrayElements(array,&isCopy);
  3585. #else
  3586.         RETVAL = (*env)->GetDoubleArrayElements(env, array,&isCopy);
  3587. #endif
  3588. #ifdef WIN32
  3589.         RETVAL_len_ = env->GetArrayLength(array);
  3590. #else
  3591.         RETVAL_len_ = (*env)->GetArrayLength(env, array);
  3592. #endif
  3593.         if (GIMME == G_ARRAY) {
  3594.         int i;
  3595.         jdouble* r = RETVAL;
  3596.         EXTEND(sp, RETVAL_len_);
  3597.         for (i = RETVAL_len_; i; --i) {
  3598.             PUSHs(sv_2mortal(newSVnv(*r++)));
  3599.         }
  3600.         }
  3601.         else {
  3602.         if (RETVAL_len_) {
  3603.             PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
  3604.             (STRLEN)RETVAL_len_ * sizeof(jdouble))));
  3605.         }
  3606.         else
  3607.             PUSHs(&PL_sv_no);
  3608.         }
  3609. #ifdef WIN32
  3610.         env->ReleaseDoubleArrayElements(array,RETVAL,JNI_ABORT);
  3611. #else
  3612.         (*env)->ReleaseDoubleArrayElements(env, array,RETVAL,JNI_ABORT);
  3613. #endif
  3614.         RESTOREENV;
  3615.     }
  3616.  
  3617. void
  3618. GetBooleanArrayRegion(array,start,len,buf)
  3619.     JNIEnv *        env = FETCHENV;
  3620.     jbooleanArray        array
  3621.     jsize            start
  3622.     jsize            len
  3623.     STRLEN            tmplen = len * sizeof(jboolean) + 1;
  3624.     char *            tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
  3625.     jboolean *        buf = (jboolean*)sv_grow(ST(3),len * sizeof(jboolean)+1);
  3626.     CODE:
  3627.     {
  3628. #ifdef WIN32
  3629.         env->GetBooleanArrayRegion(array,start,len,buf);
  3630. #else
  3631.         (*env)->GetBooleanArrayRegion(env, array,start,len,buf);
  3632. #endif
  3633.         SvCUR_set(ST(3), len * sizeof(jboolean));
  3634.         *SvEND(ST(3)) = '\0';
  3635.         RESTOREENV;
  3636.     }
  3637.  
  3638. void
  3639. GetByteArrayRegion(array,start,len,buf)
  3640.     JNIEnv *        env = FETCHENV;
  3641.     jbyteArray        array
  3642.     jsize            start
  3643.     jsize            len
  3644.     STRLEN            tmplen = len * sizeof(jboolean) + 1;
  3645.     char *            tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
  3646.     jbyte *            buf = (jbyte*)sv_grow(ST(3),len * sizeof(jbyte)+1);
  3647.     CODE:
  3648.     {
  3649. #ifdef WIN32
  3650.         env->GetByteArrayRegion(array,start,len,buf);
  3651. #else
  3652.         (*env)->GetByteArrayRegion(env, array,start,len,buf);
  3653. #endif
  3654.         SvCUR_set(ST(3), len * sizeof(jbyte));
  3655.         *SvEND(ST(3)) = '\0';
  3656.         RESTOREENV;
  3657.     }
  3658.  
  3659. void
  3660. GetCharArrayRegion(array,start,len,buf)
  3661.     JNIEnv *        env = FETCHENV;
  3662.     jcharArray        array
  3663.     jsize            start
  3664.     jsize            len
  3665.     STRLEN            tmplen = len * sizeof(jboolean) + 1;
  3666.     char *            tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
  3667.     jchar *            buf = (jchar*)sv_grow(ST(3),len * sizeof(jchar)+1);
  3668.     CODE:
  3669.     {
  3670. #ifdef WIN32
  3671.         env->GetCharArrayRegion(array,start,len,buf);
  3672. #else
  3673.         (*env)->GetCharArrayRegion(env, array,start,len,buf);
  3674. #endif
  3675.         SvCUR_set(ST(3), len * sizeof(jchar));
  3676.         *SvEND(ST(3)) = '\0';
  3677.         RESTOREENV;
  3678.     }
  3679.  
  3680. void
  3681. GetShortArrayRegion(array,start,len,buf)
  3682.     JNIEnv *        env = FETCHENV;
  3683.     jshortArray        array
  3684.     jsize            start
  3685.     jsize            len
  3686.     STRLEN            tmplen = len * sizeof(jboolean) + 1;
  3687.     char *            tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
  3688.     jshort *        buf = (jshort*)sv_grow(ST(3),len * sizeof(jshort)+1);
  3689.     CODE:
  3690.     {
  3691. #ifdef WIN32
  3692.         env->GetShortArrayRegion(array,start,len,buf);
  3693. #else
  3694.         (*env)->GetShortArrayRegion(env, array,start,len,buf);
  3695. #endif
  3696.         SvCUR_set(ST(3), len * sizeof(jshort));
  3697.         *SvEND(ST(3)) = '\0';
  3698.         RESTOREENV;
  3699.     }
  3700.  
  3701. void
  3702. GetIntArrayRegion(array,start,len,buf)
  3703.     JNIEnv *        env = FETCHENV;
  3704.     jintArray        array
  3705.     jsize            start
  3706.     jsize            len
  3707.     STRLEN            tmplen = len * sizeof(jboolean) + 1;
  3708.     char *            tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
  3709.     jint *            buf = (jint*)sv_grow(ST(3),len * sizeof(jint)+1);
  3710.     CODE:
  3711.     {
  3712. #ifdef WIN32
  3713.         env->GetIntArrayRegion(array,start,len,buf);
  3714. #else
  3715.         (*env)->GetIntArrayRegion(env, array,start,len,buf);
  3716. #endif
  3717.         SvCUR_set(ST(3), len * sizeof(jint));
  3718.         *SvEND(ST(3)) = '\0';
  3719.         RESTOREENV;
  3720.     }
  3721.  
  3722. void
  3723. GetLongArrayRegion(array,start,len,buf)
  3724.     JNIEnv *        env = FETCHENV;
  3725.     jlongArray        array
  3726.     jsize            start
  3727.     jsize            len
  3728.     STRLEN            tmplen = len * sizeof(jboolean) + 1;
  3729.     char *            tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
  3730.     jlong *            buf = (jlong*)sv_grow(ST(3),len * sizeof(jlong)+1);
  3731.     CODE:
  3732.     {
  3733. #ifdef WIN32
  3734.         env->GetLongArrayRegion(array,start,len,buf);
  3735. #else
  3736.         (*env)->GetLongArrayRegion(env, array,start,len,buf);
  3737. #endif
  3738.         SvCUR_set(ST(3), len * sizeof(jlong));
  3739.         *SvEND(ST(3)) = '\0';
  3740.         RESTOREENV;
  3741.     }
  3742.  
  3743. void
  3744. GetFloatArrayRegion(array,start,len,buf)
  3745.     JNIEnv *        env = FETCHENV;
  3746.     jfloatArray        array
  3747.     jsize            start
  3748.     jsize            len
  3749.     STRLEN            tmplen = len * sizeof(jboolean) + 1;
  3750.     char *            tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
  3751.     jfloat *        buf = (jfloat*)sv_grow(ST(3),len * sizeof(jfloat)+1);
  3752.     CODE:
  3753.     {
  3754. #ifdef WIN32
  3755.         env->GetFloatArrayRegion(array,start,len,buf);
  3756. #else
  3757.         (*env)->GetFloatArrayRegion(env, array,start,len,buf);
  3758. #endif
  3759.         SvCUR_set(ST(3), len * sizeof(jfloat));
  3760.         *SvEND(ST(3)) = '\0';
  3761.         RESTOREENV;
  3762.     }
  3763.  
  3764. void
  3765. GetDoubleArrayRegion(array,start,len,buf)
  3766.     JNIEnv *        env = FETCHENV;
  3767.     jdoubleArray        array
  3768.     jsize            start
  3769.     jsize            len
  3770.     STRLEN            tmplen = len * sizeof(jboolean) + 1;
  3771.     char *            tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
  3772.     jdouble *        buf = (jdouble*)sv_grow(ST(3),len * sizeof(jdouble)+1);
  3773.     CODE:
  3774.     {
  3775. #ifdef WIN32
  3776.         env->GetDoubleArrayRegion(array,start,len,buf);
  3777. #else
  3778.         (*env)->GetDoubleArrayRegion(env, array,start,len,buf);
  3779. #endif
  3780.         SvCUR_set(ST(3), len * sizeof(jdouble));
  3781.         *SvEND(ST(3)) = '\0';
  3782.         RESTOREENV;
  3783.     }
  3784.  
  3785. void
  3786. SetBooleanArrayRegion(array,start,len,buf)
  3787.     JNIEnv *        env = FETCHENV;
  3788.     STRLEN            tmplen = NO_INIT;
  3789.     jbooleanArray        array
  3790.     jsize            start
  3791.     jsize            len
  3792.     jsize            buf_len_ = NO_INIT;
  3793.     jboolean *        buf
  3794.     CODE:
  3795.     {
  3796.         if (buf_len_ < len)
  3797.         croak("string is too short");
  3798.         else if (buf_len_ > len && PL_dowarn)
  3799.         warn("string is too long");
  3800. #ifdef WIN32
  3801.         env->SetBooleanArrayRegion(array,start,len,buf);
  3802. #else
  3803.         (*env)->SetBooleanArrayRegion(env, array,start,len,buf);
  3804. #endif
  3805.         RESTOREENV;
  3806.     }
  3807.  
  3808. void
  3809. SetByteArrayRegion(array,start,len,buf)
  3810.     JNIEnv *        env = FETCHENV;
  3811.     STRLEN            tmplen = NO_INIT;
  3812.     jbyteArray        array
  3813.     jsize            start
  3814.     jsize            len
  3815.     jsize            buf_len_ = NO_INIT;
  3816.     jbyte *            buf
  3817.     CODE:
  3818.     {
  3819.         if (buf_len_ < len)
  3820.         croak("string is too short");
  3821.         else if (buf_len_ > len && PL_dowarn)
  3822.         warn("string is too long");
  3823. #ifdef WIN32
  3824.         env->SetByteArrayRegion(array,start,len,buf);
  3825. #else
  3826.         (*env)->SetByteArrayRegion(env, array,start,len,buf);
  3827. #endif
  3828.         RESTOREENV;
  3829.     }
  3830.  
  3831. void
  3832. SetCharArrayRegion(array,start,len,buf)
  3833.     JNIEnv *        env = FETCHENV;
  3834.     STRLEN            tmplen = NO_INIT;
  3835.     jcharArray        array
  3836.     jsize            start
  3837.     jsize            len
  3838.     jsize            buf_len_ = NO_INIT;
  3839.     jchar *            buf
  3840.     CODE:
  3841.     {
  3842.         if (buf_len_ < len)
  3843.         croak("string is too short");
  3844.         else if (buf_len_ > len && PL_dowarn)
  3845.         warn("string is too long");
  3846. #ifdef WIN32
  3847.         env->SetCharArrayRegion(array,start,len,buf);
  3848. #else
  3849.         (*env)->SetCharArrayRegion(env, array,start,len,buf);
  3850. #endif
  3851.         RESTOREENV;
  3852.     }
  3853.  
  3854. void
  3855. SetShortArrayRegion(array,start,len,buf)
  3856.     JNIEnv *        env = FETCHENV;
  3857.     STRLEN            tmplen = NO_INIT;
  3858.     jshortArray        array
  3859.     jsize            start
  3860.     jsize            len
  3861.     jsize            buf_len_ = NO_INIT;
  3862.     jshort *        buf
  3863.     CODE:
  3864.     {
  3865.         if (buf_len_ < len)
  3866.         croak("string is too short");
  3867.         else if (buf_len_ > len && PL_dowarn)
  3868.         warn("string is too long");
  3869. #ifdef WIN32
  3870.         env->SetShortArrayRegion(array,start,len,buf);
  3871. #else
  3872.         (*env)->SetShortArrayRegion(env, array,start,len,buf);
  3873. #endif
  3874.         RESTOREENV;
  3875.     }
  3876.  
  3877. void
  3878. SetIntArrayRegion(array,start,len,buf)
  3879.     JNIEnv *        env = FETCHENV;
  3880.     STRLEN            tmplen = NO_INIT;
  3881.     jintArray        array
  3882.     jsize            start
  3883.     jsize            len
  3884.     jsize            buf_len_ = NO_INIT;
  3885.     jint *            buf
  3886.     CODE:
  3887.     {
  3888.         if (buf_len_ < len)
  3889.         croak("string is too short");
  3890.         else if (buf_len_ > len && PL_dowarn)
  3891.         warn("string is too long");
  3892. #ifdef WIN32
  3893.         env->SetIntArrayRegion(array,start,len,buf);
  3894. #else
  3895.         (*env)->SetIntArrayRegion(env, array,start,len,buf);
  3896. #endif
  3897.         RESTOREENV;
  3898.     }
  3899.  
  3900. void
  3901. SetLongArrayRegion(array,start,len,buf)
  3902.     JNIEnv *        env = FETCHENV;
  3903.     STRLEN            tmplen = NO_INIT;
  3904.     jlongArray        array
  3905.     jsize            start
  3906.     jsize            len
  3907.     jsize            buf_len_ = NO_INIT;
  3908.     jlong *            buf
  3909.     CODE:
  3910.     {
  3911.         if (buf_len_ < len)
  3912.         croak("string is too short");
  3913.         else if (buf_len_ > len && PL_dowarn)
  3914.         warn("string is too long");
  3915. #ifdef WIN32
  3916.         env->SetLongArrayRegion(array,start,len,buf);
  3917. #else
  3918.         (*env)->SetLongArrayRegion(env, array,start,len,buf);
  3919. #endif
  3920.         RESTOREENV;
  3921.     }
  3922.  
  3923. void
  3924. SetFloatArrayRegion(array,start,len,buf)
  3925.     JNIEnv *        env = FETCHENV;
  3926.     STRLEN            tmplen = NO_INIT;
  3927.     jfloatArray        array
  3928.     jsize            start
  3929.     jsize            len
  3930.     jsize            buf_len_ = NO_INIT;
  3931.     jfloat *        buf
  3932.     CODE:
  3933.     {
  3934.         if (buf_len_ < len)
  3935.         croak("string is too short");
  3936.         else if (buf_len_ > len && PL_dowarn)
  3937.         warn("string is too long");
  3938. #ifdef WIN32
  3939.         env->SetFloatArrayRegion(array,start,len,buf);
  3940. #else
  3941.         (*env)->SetFloatArrayRegion(env, array,start,len,buf);
  3942. #endif
  3943.         RESTOREENV;
  3944.     }
  3945.  
  3946. void
  3947. SetDoubleArrayRegion(array,start,len,buf)
  3948.     JNIEnv *        env = FETCHENV;
  3949.     STRLEN            tmplen = NO_INIT;
  3950.     jdoubleArray        array
  3951.     jsize            start
  3952.     jsize            len
  3953.     jsize            buf_len_ = NO_INIT;
  3954.     jdouble *        buf
  3955.     CODE:
  3956.     {
  3957.         if (buf_len_ < len)
  3958.         croak("string is too short");
  3959.         else if (buf_len_ > len && PL_dowarn)
  3960.         warn("string is too long");
  3961. #ifdef WIN32
  3962.         env->SetDoubleArrayRegion(array,start,len,buf);
  3963. #else
  3964.         (*env)->SetDoubleArrayRegion(env, array,start,len,buf);
  3965. #endif
  3966.         RESTOREENV;
  3967.     }
  3968.  
  3969. SysRet
  3970. RegisterNatives(clazz,methods,nMethods)
  3971.     JNIEnv *        env = FETCHENV;
  3972.     jclass            clazz
  3973.     JNINativeMethod *    methods
  3974.     jint            nMethods
  3975.     CODE:
  3976.     {
  3977. #ifdef WIN32
  3978.         RETVAL = env->RegisterNatives(clazz,methods,nMethods);
  3979. #else
  3980.         RETVAL = (*env)->RegisterNatives(env, clazz,methods,nMethods);
  3981. #endif
  3982.     }
  3983.  
  3984. SysRet
  3985. UnregisterNatives(clazz)
  3986.     JNIEnv *        env = FETCHENV;
  3987.     jclass            clazz
  3988.     CODE:
  3989.     {
  3990. #ifdef WIN32
  3991.         RETVAL = env->UnregisterNatives(clazz);
  3992. #else
  3993.         RETVAL = (*env)->UnregisterNatives(env, clazz);
  3994. #endif
  3995.     }
  3996.     OUTPUT:
  3997.     RETVAL  
  3998.    
  3999. SysRet
  4000. MonitorEnter(obj)
  4001.     JNIEnv *        env = FETCHENV;
  4002.     jobject            obj
  4003.     CODE:
  4004.     {
  4005. #ifdef WIN32
  4006.         RETVAL = env->MonitorEnter(obj);
  4007. #else
  4008.         RETVAL = (*env)->MonitorEnter(env, obj);
  4009. #endif
  4010.         RESTOREENV;
  4011.     }
  4012.     OUTPUT:
  4013.     RETVAL
  4014.  
  4015. SysRet
  4016. MonitorExit(obj)
  4017.     JNIEnv *        env = FETCHENV;
  4018.     jobject            obj
  4019.     CODE:
  4020.     {
  4021. #ifdef WIN32
  4022.         RETVAL = env->MonitorExit(obj);
  4023. #else
  4024.         RETVAL = (*env)->MonitorExit(env, obj);
  4025. #endif
  4026.         RESTOREENV;
  4027.     }
  4028.     OUTPUT:
  4029.     RETVAL
  4030.  
  4031. JavaVM *
  4032. GetJavaVM(...)
  4033.     JNIEnv *        env = FETCHENV;
  4034.     CODE:
  4035.     {
  4036.         if (env) {    /* We're embedded. */
  4037. #ifdef WIN32
  4038.         if (env->GetJavaVM(&RETVAL) < 0)
  4039. #else
  4040.         if ((*env)->GetJavaVM(env, &RETVAL) < 0)
  4041. #endif
  4042.             RETVAL = 0;
  4043.         }
  4044.         else {    /* We're embedding. */
  4045. #ifdef KAFFE
  4046.                 JavaVMInitArgs vm_args;
  4047. #else
  4048.                 JDK1_1InitArgs vm_args;
  4049. #endif
  4050.         char *lib;
  4051.         if (jpldebug) {
  4052.             fprintf(stderr, "We're embedding Java in Perl.\n");
  4053.         }
  4054.  
  4055.         if (items--) {
  4056.             ++mark;
  4057.             lib = SvPV(*mark, PL_na);
  4058.         }
  4059.         else
  4060.             lib = 0;
  4061.         if (jpldebug) {
  4062.             fprintf(stderr, "lib is %s.\n", lib);
  4063.         }
  4064. #ifdef WIN32
  4065.         if (!LoadLibrary("javai.dll")) {
  4066.             if (lib && !LoadLibrary(lib))
  4067.             croak("Can't load javai.dll");
  4068.         }
  4069. #else
  4070.         if (jpldebug) {
  4071.             fprintf(stderr, "Opening Java shared library.\n");
  4072.                 }
  4073. #ifdef KAFFE
  4074.         if (!dlopen("libkaffevm.so", RTLD_LAZY|RTLD_GLOBAL)) {
  4075. #else
  4076.         if (!dlopen("libjava.so", RTLD_LAZY|RTLD_GLOBAL)) {
  4077. #endif
  4078.             if (lib && !dlopen(lib, RTLD_LAZY|RTLD_GLOBAL))
  4079.             croak("Can't load Java shared library.");
  4080.         }
  4081. #endif
  4082.  
  4083.         JNI_GetDefaultJavaVMInitArgs(&vm_args);
  4084.         vm_args.exit = &call_my_exit;
  4085.         if (jpldebug) {
  4086.             fprintf(stderr, "items = %d\n", items);
  4087.             fprintf(stderr, "mark = %s\n", SvPV(*mark, PL_na));
  4088.         }
  4089.         ++mark;
  4090.         while (items > 1) {
  4091.             char *s = SvPV(*mark,PL_na);
  4092.             ++mark;
  4093.             if (jpldebug) {
  4094.                 fprintf(stderr, "*s = %s\n", s);
  4095.                 fprintf(stderr, "val = %s\n", SvPV(*mark, PL_na));
  4096.             }
  4097.             items -= 2;
  4098.             if (strEQ(s, "checkSource"))
  4099.             vm_args.checkSource = (jint)SvIV(*mark);
  4100.             else if (strEQ(s, "nativeStackSize"))
  4101.             vm_args.nativeStackSize = (jint)SvIV(*mark);
  4102.             else if (strEQ(s, "javaStackSize"))
  4103.             vm_args.javaStackSize = (jint)SvIV(*mark);
  4104.             else if (strEQ(s, "minHeapSize"))
  4105.             vm_args.minHeapSize = (jint)SvIV(*mark);
  4106.             else if (strEQ(s, "maxHeapSize"))
  4107.             vm_args.maxHeapSize = (jint)SvIV(*mark);
  4108.             else if (strEQ(s, "verifyMode"))
  4109.             vm_args.verifyMode = (jint)SvIV(*mark);
  4110.             else if (strEQ(s, "classpath"))
  4111.             vm_args.classpath = savepv(SvPV(*mark,PL_na));
  4112.             else if (strEQ(s, "enableClassGC"))
  4113.             vm_args.enableClassGC = (jint)SvIV(*mark);
  4114.             else if (strEQ(s, "enableVerboseGC"))
  4115.             vm_args.enableVerboseGC = (jint)SvIV(*mark);
  4116.             else if (strEQ(s, "disableAsyncGC"))
  4117.             vm_args.disableAsyncGC = (jint)SvIV(*mark);
  4118. #ifndef KAFFE
  4119.             else if (strEQ(s, "verbose"))
  4120.             vm_args.verbose = (jint)SvIV(*mark); 
  4121.             else if (strEQ(s, "debugging"))
  4122.             vm_args.debugging = (jboolean)SvIV(*mark);
  4123.             else if (strEQ(s, "debugPort"))
  4124.             vm_args.debugPort = (jint)SvIV(*mark); 
  4125. #endif
  4126.             else
  4127.             croak("unrecognized option: %s", s);
  4128.         }
  4129.  
  4130.         if (jpldebug) {
  4131.             fprintf(stderr, "Creating Java VM...\n");
  4132.             fprintf(stderr, "Working CLASSPATH: %s\n", 
  4133.             vm_args.classpath);
  4134.         }
  4135.         JNI_CreateJavaVM(&RETVAL, &jplcurenv, &vm_args);
  4136.         if (jpldebug) {
  4137.             fprintf(stderr, "Created Java VM.\n");
  4138.         }
  4139.         }
  4140.     }
  4141.  
  4142.