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