jpl/JNI/JNI.xs

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