jpl/JNI/JNI.xs

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