jpl/JNI/JNI.xs

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