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