src/third_party/npapi/npspy/extern/java/jni.h

   1 /* ***** BEGIN LICENSE BLOCK *****
   2  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   3  *
   4  * The contents of this file are subject to the Mozilla Public License Version
   5  * 1.1 (the "License"); you may not use this file except in compliance with
   6  * the License. You may obtain a copy of the License at
   7  * http://www.mozilla.org/MPL/
   8  *
   9  * Software distributed under the License is distributed on an "AS IS" basis,
  10  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  11  * for the specific language governing rights and limitations under the
  12  * License.
  13  *
  14  * The Original Code is the Java Runtime Interface.
  15  *
  16  * The Initial Developer of the Original Code is
  17  * Netscape Communications Corporation and Sun Microsystems, Inc.
  18  * Portions created by the Initial Developer are Copyright (C) 1993-1996
  19  * the Initial Developer. All Rights Reserved.
  20  *
  21  * Contributor(s):
  22  *
  23  * Alternatively, the contents of this file may be used under the terms of
  24  * either the GNU General Public License Version 2 or later (the "GPL"), or
  25  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  26  * in which case the provisions of the GPL or the LGPL are applicable instead
  27  * of those above. If you wish to allow use of your version of this file only
  28  * under the terms of either the GPL or the LGPL, and not to allow others to
  29  * use your version of this file under the terms of the MPL, indicate your
  30  * decision by deleting the provisions above and replace them with the notice
  31  * and other provisions required by the GPL or the LGPL. If you do not delete
  32  * the provisions above, a recipient may use your version of this file under
  33  * the terms of any one of the MPL, the GPL or the LGPL.
  34  *
  35  * ***** END LICENSE BLOCK ***** */
  36
  37 #ifndef JNI_H
  38 #define JNI_H
  39
  40 #include <stdio.h>
  41 #include <stdarg.h>
  42
  43 /* jni_md.h contains the machine-dependent typedefs for jbyte, jint
  44    and jlong */
  45
  46 #include "jni_md.h"
  47
  48 #ifdef __cplusplus
  49 extern "C" {
  50 #endif
  51
  52 /*
  53  * JNI Types
  54  */
  55
  56 typedef unsigned char   jboolean;
  57 typedef unsigned short  jchar;
  58 typedef short           jshort;
  59 typedef float           jfloat;
  60 typedef double          jdouble;
  61
  62 typedef jint            jsize;
  63
  64 #ifdef __cplusplus
  65
  66 class _jobject {};
  67 class _jclass : public _jobject {};
  68 class _jthrowable : public _jobject {};
  69 class _jstring : public _jobject {};
  70 class _jarray : public _jobject {};
  71 class _jbooleanArray : public _jarray {};
  72 class _jbyteArray : public _jarray {};
  73 class _jcharArray : public _jarray {};
  74 class _jshortArray : public _jarray {};
  75 class _jintArray : public _jarray {};
  76 class _jlongArray : public _jarray {};
  77 class _jfloatArray : public _jarray {};
  78 class _jdoubleArray : public _jarray {};
  79 class _jobjectArray : public _jarray {};
  80
  81 typedef _jobject *jobject;
  82 typedef _jclass *jclass;
  83 typedef _jthrowable *jthrowable;
  84 typedef _jstring *jstring;
  85 typedef _jarray *jarray;
  86 typedef _jbooleanArray *jbooleanArray;
  87 typedef _jbyteArray *jbyteArray;
  88 typedef _jcharArray *jcharArray;
  89 typedef _jshortArray *jshortArray;
  90 typedef _jintArray *jintArray;
  91 typedef _jlongArray *jlongArray;
  92 typedef _jfloatArray *jfloatArray;
  93 typedef _jdoubleArray *jdoubleArray;
  94 typedef _jobjectArray *jobjectArray;
  95
  96 #else
  97
  98 struct _jobject;
  99
 100 typedef struct _jobject *jobject;
 101 typedef jobject jclass;
 102 typedef jobject jthrowable;
 103 typedef jobject jstring;
 104 typedef jobject jarray;
 105 typedef jarray jbooleanArray;
 106 typedef jarray jbyteArray;
 107 typedef jarray jcharArray;
 108 typedef jarray jshortArray;
 109 typedef jarray jintArray;
 110 typedef jarray jlongArray;
 111 typedef jarray jfloatArray;
 112 typedef jarray jdoubleArray;
 113 typedef jarray jobjectArray;
 114
 115 #endif
 116
 117 #if 0   /* moved to jri_md.h */
 118 typedef jobject jref; /* For transition---not meant to be part of public
 119                          API anymore.*/
 120 #endif
 121
 122 typedef union jvalue {
 123     jboolean z;
 124     jbyte    b;
 125     jchar    c;
 126     jshort   s;
 127     jint     i;
 128     jlong    j;
 129     jfloat   f;
 130     jdouble  d;
 131     jobject  l;
 132 } jvalue;
 133
 134 struct _jfieldID;
 135 typedef struct _jfieldID *jfieldID;
 136
 137 struct _jmethodID;
 138 typedef struct _jmethodID *jmethodID;
 139
 140 /*
 141  * jboolean constants
 142  */
 143
 144 #define JNI_FALSE 0
 145 #define JNI_TRUE 1
 146
 147 /*
 148  * possible return values for JNI functions.
 149  */
 150
 151 #define JNI_OK 0
 152 #define JNI_ERR (-1)
 153
 154 /*
 155  * used in ReleaseScalarArrayElements
 156  */
 157
 158 #define JNI_COMMIT 1
 159 #define JNI_ABORT 2
 160
 161 /*
 162  * used in RegisterNatives to describe native method name, signature,
 163  * and function pointer.
 164  */
 165
 166 typedef struct {
 167     char *name;
 168     char *signature;
 169     void *fnPtr;
 170 } JNINativeMethod;
 171
 172 /*
 173  * JNI Native Method Interface.
 174  */
 175
 176 struct JNINativeInterface_;
 177
 178 struct JNIEnv_;
 179
 180 #ifdef __cplusplus
 181 typedef JNIEnv_ JNIEnv;
 182 #else
 183 typedef const struct JNINativeInterface_ *JNIEnv;
 184 #endif
 185
 186 /*
 187  * JNI Invocation Interface.
 188  */
 189
 190 struct JNIInvokeInterface_;
 191
 192 struct JavaVM_;
 193
 194 #ifdef __cplusplus
 195 typedef JavaVM_ JavaVM;
 196 #else
 197 typedef const struct JNIInvokeInterface_ *JavaVM;
 198 #endif
 199
 200 struct JNINativeInterface_ {
 201     void *reserved0;
 202     void *reserved1;
 203     void *reserved2;
 204
 205     void *reserved3;
 206     jint (JNICALL *GetVersion)(JNIEnv *env);
 207
 208     jclass (JNICALL *DefineClass)
 209       (JNIEnv *env, const char *name, jobject loader, const jbyte *buf,
 210        jsize len);
 211     jclass (JNICALL *FindClass)
 212       (JNIEnv *env, const char *name);
 213
 214     void *reserved4;
 215     void *reserved5;
 216     void *reserved6;
 217
 218     jclass (JNICALL *GetSuperclass)
 219       (JNIEnv *env, jclass sub);
 220     jboolean (JNICALL *IsAssignableFrom)
 221       (JNIEnv *env, jclass sub, jclass sup);
 222     void *reserved7;
 223
 224
 225     jint (JNICALL *Throw)
 226       (JNIEnv *env, jthrowable obj);
 227     jint (JNICALL *ThrowNew)
 228       (JNIEnv *env, jclass clazz, const char *msg);
 229     jthrowable (JNICALL *ExceptionOccurred)
 230       (JNIEnv *env);
 231     void (JNICALL *ExceptionDescribe)
 232       (JNIEnv *env);
 233     void (JNICALL *ExceptionClear)
 234       (JNIEnv *env);
 235     void (JNICALL *FatalError)
 236       (JNIEnv *env, const char *msg);
 237     void *reserved8;
 238     void *reserved9;
 239
 240     jobject (JNICALL *NewGlobalRef)
 241       (JNIEnv *env, jobject lobj);
 242     void (JNICALL *DeleteGlobalRef)
 243       (JNIEnv *env, jobject gref);
 244     void (JNICALL *DeleteLocalRef)
 245       (JNIEnv *env, jobject obj);
 246     jboolean (JNICALL *IsSameObject)
 247       (JNIEnv *env, jobject obj1, jobject obj2);
 248     void *reserved10;
 249     void *reserved11;
 250
 251     jobject (JNICALL *AllocObject)
 252       (JNIEnv *env, jclass clazz);
 253     jobject (JNICALL *NewObject)
 254       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
 255     jobject (JNICALL *NewObjectV)
 256       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
 257     jobject (JNICALL *NewObjectA)
 258       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
 259
 260     jclass (JNICALL *GetObjectClass)
 261       (JNIEnv *env, jobject obj);
 262     jboolean (JNICALL *IsInstanceOf)
 263       (JNIEnv *env, jobject obj, jclass clazz);
 264
 265     jmethodID (JNICALL *GetMethodID)
 266       (JNIEnv *env, jclass clazz, const char *name, const char *sig);
 267
 268     jobject (JNICALL *CallObjectMethod)
 269       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
 270     jobject (JNICALL *CallObjectMethodV)
 271       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
 272     jobject (JNICALL *CallObjectMethodA)
 273       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args);
 274
 275     jboolean (JNICALL *CallBooleanMethod)
 276       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
 277     jboolean (JNICALL *CallBooleanMethodV)
 278       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
 279     jboolean (JNICALL *CallBooleanMethodA)
 280       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args);
 281
 282     jbyte (JNICALL *CallByteMethod)
 283       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
 284     jbyte (JNICALL *CallByteMethodV)
 285       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
 286     jbyte (JNICALL *CallByteMethodA)
 287       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
 288
 289     jchar (JNICALL *CallCharMethod)
 290       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
 291     jchar (JNICALL *CallCharMethodV)
 292       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
 293     jchar (JNICALL *CallCharMethodA)
 294       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
 295
 296     jshort (JNICALL *CallShortMethod)
 297       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
 298     jshort (JNICALL *CallShortMethodV)
 299       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
 300     jshort (JNICALL *CallShortMethodA)
 301       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
 302
 303     jint (JNICALL *CallIntMethod)
 304       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
 305     jint (JNICALL *CallIntMethodV)
 306       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
 307     jint (JNICALL *CallIntMethodA)
 308       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
 309
 310     jlong (JNICALL *CallLongMethod)
 311       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
 312     jlong (JNICALL *CallLongMethodV)
 313       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
 314     jlong (JNICALL *CallLongMethodA)
 315       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
 316
 317     jfloat (JNICALL *CallFloatMethod)
 318       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
 319     jfloat (JNICALL *CallFloatMethodV)
 320       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
 321     jfloat (JNICALL *CallFloatMethodA)
 322       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
 323
 324     jdouble (JNICALL *CallDoubleMethod)
 325       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
 326     jdouble (JNICALL *CallDoubleMethodV)
 327       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
 328     jdouble (JNICALL *CallDoubleMethodA)
 329       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
 330
 331     void (JNICALL *CallVoidMethod)
 332       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
 333     void (JNICALL *CallVoidMethodV)
 334       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
 335     void (JNICALL *CallVoidMethodA)
 336       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args);
 337
 338     jobject (JNICALL *CallNonvirtualObjectMethod)
 339       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
 340     jobject (JNICALL *CallNonvirtualObjectMethodV)
 341       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 342        va_list args);
 343     jobject (JNICALL *CallNonvirtualObjectMethodA)
 344       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 345        jvalue * args);
 346
 347     jboolean (JNICALL *CallNonvirtualBooleanMethod)
 348       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
 349     jboolean (JNICALL *CallNonvirtualBooleanMethodV)
 350       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 351        va_list args);
 352     jboolean (JNICALL *CallNonvirtualBooleanMethodA)
 353       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 354        jvalue * args);
 355
 356     jbyte (JNICALL *CallNonvirtualByteMethod)
 357       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
 358     jbyte (JNICALL *CallNonvirtualByteMethodV)
 359       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 360        va_list args);
 361     jbyte (JNICALL *CallNonvirtualByteMethodA)
 362       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 363        jvalue *args);
 364
 365     jchar (JNICALL *CallNonvirtualCharMethod)
 366       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
 367     jchar (JNICALL *CallNonvirtualCharMethodV)
 368       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 369        va_list args);
 370     jchar (JNICALL *CallNonvirtualCharMethodA)
 371       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 372        jvalue *args);
 373
 374     jshort (JNICALL *CallNonvirtualShortMethod)
 375       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
 376     jshort (JNICALL *CallNonvirtualShortMethodV)
 377       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 378        va_list args);
 379     jshort (JNICALL *CallNonvirtualShortMethodA)
 380       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 381        jvalue *args);
 382
 383     jint (JNICALL *CallNonvirtualIntMethod)
 384       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
 385     jint (JNICALL *CallNonvirtualIntMethodV)
 386       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 387        va_list args);
 388     jint (JNICALL *CallNonvirtualIntMethodA)
 389       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 390        jvalue *args);
 391
 392     jlong (JNICALL *CallNonvirtualLongMethod)
 393       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
 394     jlong (JNICALL *CallNonvirtualLongMethodV)
 395       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 396        va_list args);
 397     jlong (JNICALL *CallNonvirtualLongMethodA)
 398       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 399        jvalue *args);
 400
 401     jfloat (JNICALL *CallNonvirtualFloatMethod)
 402       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
 403     jfloat (JNICALL *CallNonvirtualFloatMethodV)
 404       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 405        va_list args);
 406     jfloat (JNICALL *CallNonvirtualFloatMethodA)
 407       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 408        jvalue *args);
 409
 410     jdouble (JNICALL *CallNonvirtualDoubleMethod)
 411       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
 412     jdouble (JNICALL *CallNonvirtualDoubleMethodV)
 413       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 414        va_list args);
 415     jdouble (JNICALL *CallNonvirtualDoubleMethodA)
 416       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 417        jvalue *args);
 418
 419     void (JNICALL *CallNonvirtualVoidMethod)
 420       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
 421     void (JNICALL *CallNonvirtualVoidMethodV)
 422       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 423        va_list args);
 424     void (JNICALL *CallNonvirtualVoidMethodA)
 425       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
 426        jvalue * args);
 427
 428     jfieldID (JNICALL *GetFieldID)
 429       (JNIEnv *env, jclass clazz, const char *name, const char *sig);
 430
 431     jobject (JNICALL *GetObjectField)
 432       (JNIEnv *env, jobject obj, jfieldID fieldID);
 433     jboolean (JNICALL *GetBooleanField)
 434       (JNIEnv *env, jobject obj, jfieldID fieldID);
 435     jbyte (JNICALL *GetByteField)
 436       (JNIEnv *env, jobject obj, jfieldID fieldID);
 437     jchar (JNICALL *GetCharField)
 438       (JNIEnv *env, jobject obj, jfieldID fieldID);
 439     jshort (JNICALL *GetShortField)
 440       (JNIEnv *env, jobject obj, jfieldID fieldID);
 441     jint (JNICALL *GetIntField)
 442       (JNIEnv *env, jobject obj, jfieldID fieldID);
 443     jlong (JNICALL *GetLongField)
 444       (JNIEnv *env, jobject obj, jfieldID fieldID);
 445     jfloat (JNICALL *GetFloatField)
 446       (JNIEnv *env, jobject obj, jfieldID fieldID);
 447     jdouble (JNICALL *GetDoubleField)
 448       (JNIEnv *env, jobject obj, jfieldID fieldID);
 449
 450     void (JNICALL *SetObjectField)
 451       (JNIEnv *env, jobject obj, jfieldID fieldID, jobject val);
 452     void (JNICALL *SetBooleanField)
 453       (JNIEnv *env, jobject obj, jfieldID fieldID, jboolean val);
 454     void (JNICALL *SetByteField)
 455       (JNIEnv *env, jobject obj, jfieldID fieldID, jbyte val);
 456     void (JNICALL *SetCharField)
 457       (JNIEnv *env, jobject obj, jfieldID fieldID, jchar val);
 458     void (JNICALL *SetShortField)
 459       (JNIEnv *env, jobject obj, jfieldID fieldID, jshort val);
 460     void (JNICALL *SetIntField)
 461       (JNIEnv *env, jobject obj, jfieldID fieldID, jint val);
 462     void (JNICALL *SetLongField)
 463       (JNIEnv *env, jobject obj, jfieldID fieldID, jlong val);
 464     void (JNICALL *SetFloatField)
 465       (JNIEnv *env, jobject obj, jfieldID fieldID, jfloat val);
 466     void (JNICALL *SetDoubleField)
 467       (JNIEnv *env, jobject obj, jfieldID fieldID, jdouble val);
 468
 469     jmethodID (JNICALL *GetStaticMethodID)
 470       (JNIEnv *env, jclass clazz, const char *name, const char *sig);
 471
 472     jobject (JNICALL *CallStaticObjectMethod)
 473       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
 474     jobject (JNICALL *CallStaticObjectMethodV)
 475       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
 476     jobject (JNICALL *CallStaticObjectMethodA)
 477       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
 478
 479     jboolean (JNICALL *CallStaticBooleanMethod)
 480       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
 481     jboolean (JNICALL *CallStaticBooleanMethodV)
 482       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
 483     jboolean (JNICALL *CallStaticBooleanMethodA)
 484       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
 485
 486     jbyte (JNICALL *CallStaticByteMethod)
 487       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
 488     jbyte (JNICALL *CallStaticByteMethodV)
 489       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
 490     jbyte (JNICALL *CallStaticByteMethodA)
 491       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
 492
 493     jchar (JNICALL *CallStaticCharMethod)
 494       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
 495     jchar (JNICALL *CallStaticCharMethodV)
 496       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
 497     jchar (JNICALL *CallStaticCharMethodA)
 498       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
 499
 500     jshort (JNICALL *CallStaticShortMethod)
 501       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
 502     jshort (JNICALL *CallStaticShortMethodV)
 503       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
 504     jshort (JNICALL *CallStaticShortMethodA)
 505       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
 506
 507     jint (JNICALL *CallStaticIntMethod)
 508       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
 509     jint (JNICALL *CallStaticIntMethodV)
 510       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
 511     jint (JNICALL *CallStaticIntMethodA)
 512       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
 513
 514     jlong (JNICALL *CallStaticLongMethod)
 515       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
 516     jlong (JNICALL *CallStaticLongMethodV)
 517       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
 518     jlong (JNICALL *CallStaticLongMethodA)
 519       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
 520
 521     jfloat (JNICALL *CallStaticFloatMethod)
 522       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
 523     jfloat (JNICALL *CallStaticFloatMethodV)
 524       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
 525     jfloat (JNICALL *CallStaticFloatMethodA)
 526       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
 527
 528     jdouble (JNICALL *CallStaticDoubleMethod)
 529       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
 530     jdouble (JNICALL *CallStaticDoubleMethodV)
 531       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
 532     jdouble (JNICALL *CallStaticDoubleMethodA)
 533       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
 534
 535     void (JNICALL *CallStaticVoidMethod)
 536       (JNIEnv *env, jclass cls, jmethodID methodID, ...);
 537     void (JNICALL *CallStaticVoidMethodV)
 538       (JNIEnv *env, jclass cls, jmethodID methodID, va_list args);
 539     void (JNICALL *CallStaticVoidMethodA)
 540       (JNIEnv *env, jclass cls, jmethodID methodID, jvalue * args);
 541
 542     jfieldID (JNICALL *GetStaticFieldID)
 543       (JNIEnv *env, jclass clazz, const char *name, const char *sig);
 544     jobject (JNICALL *GetStaticObjectField)
 545       (JNIEnv *env, jclass clazz, jfieldID fieldID);
 546     jboolean (JNICALL *GetStaticBooleanField)
 547       (JNIEnv *env, jclass clazz, jfieldID fieldID);
 548     jbyte (JNICALL *GetStaticByteField)
 549       (JNIEnv *env, jclass clazz, jfieldID fieldID);
 550     jchar (JNICALL *GetStaticCharField)
 551       (JNIEnv *env, jclass clazz, jfieldID fieldID);
 552     jshort (JNICALL *GetStaticShortField)
 553       (JNIEnv *env, jclass clazz, jfieldID fieldID);
 554     jint (JNICALL *GetStaticIntField)
 555       (JNIEnv *env, jclass clazz, jfieldID fieldID);
 556     jlong (JNICALL *GetStaticLongField)
 557       (JNIEnv *env, jclass clazz, jfieldID fieldID);
 558     jfloat (JNICALL *GetStaticFloatField)
 559       (JNIEnv *env, jclass clazz, jfieldID fieldID);
 560     jdouble (JNICALL *GetStaticDoubleField)
 561       (JNIEnv *env, jclass clazz, jfieldID fieldID);
 562
 563     void (JNICALL *SetStaticObjectField)
 564       (JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value);
 565     void (JNICALL *SetStaticBooleanField)
 566       (JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value);
 567     void (JNICALL *SetStaticByteField)
 568       (JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value);
 569     void (JNICALL *SetStaticCharField)
 570       (JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value);
 571     void (JNICALL *SetStaticShortField)
 572       (JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value);
 573     void (JNICALL *SetStaticIntField)
 574       (JNIEnv *env, jclass clazz, jfieldID fieldID, jint value);
 575     void (JNICALL *SetStaticLongField)
 576       (JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value);
 577     void (JNICALL *SetStaticFloatField)
 578       (JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value);
 579     void (JNICALL *SetStaticDoubleField)
 580       (JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value);
 581
 582     jstring (JNICALL *NewString)
 583       (JNIEnv *env, const jchar *unicode, jsize len);
 584     jsize (JNICALL *GetStringLength)
 585       (JNIEnv *env, jstring str);
 586     const jchar *(JNICALL *GetStringChars)
 587       (JNIEnv *env, jstring str, jboolean *isCopy);
 588     void (JNICALL *ReleaseStringChars)
 589       (JNIEnv *env, jstring str, const jchar *chars);
 590
 591     jstring (JNICALL *NewStringUTF)
 592       (JNIEnv *env, const char *utf);
 593     jsize (JNICALL *GetStringUTFLength)
 594       (JNIEnv *env, jstring str);
 595     const char* (JNICALL *GetStringUTFChars)
 596       (JNIEnv *env, jstring str, jboolean *isCopy);
 597     void (JNICALL *ReleaseStringUTFChars)
 598       (JNIEnv *env, jstring str, const char* chars);
 599
 600
 601     jsize (JNICALL *GetArrayLength)
 602       (JNIEnv *env, jarray array);
 603
 604     jobjectArray (JNICALL *NewObjectArray)
 605       (JNIEnv *env, jsize len, jclass clazz, jobject init);
 606     jobject (JNICALL *GetObjectArrayElement)
 607       (JNIEnv *env, jobjectArray array, jsize index);
 608     void (JNICALL *SetObjectArrayElement)
 609       (JNIEnv *env, jobjectArray array, jsize index, jobject val);
 610
 611     jbooleanArray (JNICALL *NewBooleanArray)
 612       (JNIEnv *env, jsize len);
 613     jbyteArray (JNICALL *NewByteArray)
 614       (JNIEnv *env, jsize len);
 615     jcharArray (JNICALL *NewCharArray)
 616       (JNIEnv *env, jsize len);
 617     jshortArray (JNICALL *NewShortArray)
 618       (JNIEnv *env, jsize len);
 619     jintArray (JNICALL *NewIntArray)
 620       (JNIEnv *env, jsize len);
 621     jlongArray (JNICALL *NewLongArray)
 622       (JNIEnv *env, jsize len);
 623     jfloatArray (JNICALL *NewFloatArray)
 624       (JNIEnv *env, jsize len);
 625     jdoubleArray (JNICALL *NewDoubleArray)
 626       (JNIEnv *env, jsize len);
 627
 628     jboolean * (JNICALL *GetBooleanArrayElements)
 629       (JNIEnv *env, jbooleanArray array, jboolean *isCopy);
 630     jbyte * (JNICALL *GetByteArrayElements)
 631       (JNIEnv *env, jbyteArray array, jboolean *isCopy);
 632     jchar * (JNICALL *GetCharArrayElements)
 633       (JNIEnv *env, jcharArray array, jboolean *isCopy);
 634     jshort * (JNICALL *GetShortArrayElements)
 635       (JNIEnv *env, jshortArray array, jboolean *isCopy);
 636     jint * (JNICALL *GetIntArrayElements)
 637       (JNIEnv *env, jintArray array, jboolean *isCopy);
 638     jlong * (JNICALL *GetLongArrayElements)
 639       (JNIEnv *env, jlongArray array, jboolean *isCopy);
 640     jfloat * (JNICALL *GetFloatArrayElements)
 641       (JNIEnv *env, jfloatArray array, jboolean *isCopy);
 642     jdouble * (JNICALL *GetDoubleArrayElements)
 643       (JNIEnv *env, jdoubleArray array, jboolean *isCopy);
 644
 645     void (JNICALL *ReleaseBooleanArrayElements)
 646       (JNIEnv *env, jbooleanArray array, jboolean *elems, jint mode);
 647     void (JNICALL *ReleaseByteArrayElements)
 648       (JNIEnv *env, jbyteArray array, jbyte *elems, jint mode);
 649     void (JNICALL *ReleaseCharArrayElements)
 650       (JNIEnv *env, jcharArray array, jchar *elems, jint mode);
 651     void (JNICALL *ReleaseShortArrayElements)
 652       (JNIEnv *env, jshortArray array, jshort *elems, jint mode);
 653     void (JNICALL *ReleaseIntArrayElements)
 654       (JNIEnv *env, jintArray array, jint *elems, jint mode);
 655     void (JNICALL *ReleaseLongArrayElements)
 656       (JNIEnv *env, jlongArray array, jlong *elems, jint mode);
 657     void (JNICALL *ReleaseFloatArrayElements)
 658       (JNIEnv *env, jfloatArray array, jfloat *elems, jint mode);
 659     void (JNICALL *ReleaseDoubleArrayElements)
 660       (JNIEnv *env, jdoubleArray array, jdouble *elems, jint mode);
 661
 662     void (JNICALL *GetBooleanArrayRegion)
 663       (JNIEnv *env, jbooleanArray array, jsize start, jsize l, jboolean *buf);
 664     void (JNICALL *GetByteArrayRegion)
 665       (JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf);
 666     void (JNICALL *GetCharArrayRegion)
 667       (JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf);
 668     void (JNICALL *GetShortArrayRegion)
 669       (JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf);
 670     void (JNICALL *GetIntArrayRegion)
 671       (JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf);
 672     void (JNICALL *GetLongArrayRegion)
 673       (JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf);
 674     void (JNICALL *GetFloatArrayRegion)
 675       (JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf);
 676     void (JNICALL *GetDoubleArrayRegion)
 677       (JNIEnv *env, jdoubleArray array, jsize start, jsize len, jdouble *buf);
 678
 679     void (JNICALL *SetBooleanArrayRegion)
 680       (JNIEnv *env, jbooleanArray array, jsize start, jsize l, jboolean *buf);
 681     void (JNICALL *SetByteArrayRegion)
 682       (JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf);
 683     void (JNICALL *SetCharArrayRegion)
 684       (JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf);
 685     void (JNICALL *SetShortArrayRegion)
 686       (JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf);
 687     void (JNICALL *SetIntArrayRegion)
 688       (JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf);
 689     void (JNICALL *SetLongArrayRegion)
 690       (JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf);
 691     void (JNICALL *SetFloatArrayRegion)
 692       (JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf);
 693     void (JNICALL *SetDoubleArrayRegion)
 694       (JNIEnv *env, jdoubleArray array, jsize start, jsize len, jdouble *buf);
 695
 696     jint (JNICALL *RegisterNatives)
 697       (JNIEnv *env, jclass clazz, const JNINativeMethod *methods,
 698        jint nMethods);
 699     jint (JNICALL *UnregisterNatives)
 700       (JNIEnv *env, jclass clazz);
 701
 702     jint (JNICALL *MonitorEnter)
 703       (JNIEnv *env, jobject obj);
 704     jint (JNICALL *MonitorExit)
 705       (JNIEnv *env, jobject obj);
 706
 707     jint (JNICALL *GetJavaVM)
 708       (JNIEnv *env, JavaVM **vm);
 709 };
 710
 711 /*
 712  * We use inlined functions for C++ so that programmers can write:
 713  *
 714  *    env->FindClass("java/lang/String")
 715  *
 716  * in C++ rather than:
 717  *
 718  *    (*env)->FindClass(env, "java/lang/String")
 719  *
 720  * in C.
 721  */
 722
 723 struct JNIEnv_ {
 724     const struct JNINativeInterface_ *functions;
 725     void *reserved0;
 726     void *reserved1[6];
 727 #ifdef __cplusplus
 728
 729     jint GetVersion() {
 730         return functions->GetVersion(this);
 731     }
 732     jclass DefineClass(const char *name, jobject loader, const jbyte *buf,
 733                        jsize len) {
 734         return functions->DefineClass(this, name, loader, buf, len);
 735     }
 736     jclass FindClass(const char *name) {
 737         return functions->FindClass(this, name);
 738     }
 739     jclass GetSuperclass(jclass sub) {
 740         return functions->GetSuperclass(this, sub);
 741     }
 742     jboolean IsAssignableFrom(jclass sub, jclass sup) {
 743         return functions->IsAssignableFrom(this, sub, sup);
 744     }
 745
 746     jint Throw(jthrowable obj) {
 747         return functions->Throw(this, obj);
 748     }
 749     jint ThrowNew(jclass clazz, const char *msg) {
 750         return functions->ThrowNew(this, clazz, msg);
 751     }
 752     jthrowable ExceptionOccurred() {
 753         return functions->ExceptionOccurred(this);
 754     }
 755     void ExceptionDescribe() {
 756         functions->ExceptionDescribe(this);
 757     }
 758     void ExceptionClear() {
 759         functions->ExceptionClear(this);
 760     }
 761     void FatalError(const char *msg) {
 762         functions->FatalError(this, msg);
 763     }
 764
 765     jobject NewGlobalRef(jobject lobj) {
 766         return functions->NewGlobalRef(this,lobj);
 767     }
 768     void DeleteGlobalRef(jobject gref) {
 769         functions->DeleteGlobalRef(this,gref);
 770     }
 771     void DeleteLocalRef(jobject obj) {
 772         functions->DeleteLocalRef(this, obj);
 773     }
 774
 775     jboolean IsSameObject(jobject obj1, jobject obj2) {
 776         return functions->IsSameObject(this,obj1,obj2);
 777     }
 778
 779     jobject AllocObject(jclass clazz) {
 780         return functions->AllocObject(this,clazz);
 781     }
 782     jobject NewObject(jclass clazz, jmethodID methodID, ...) {
 783         va_list args;
 784         jobject result;
 785         va_start(args, methodID);
 786         result = functions->NewObjectV(this,clazz,methodID,args);
 787         va_end(args);
 788         return result;
 789     }
 790     jobject NewObjectV(jclass clazz, jmethodID methodID,
 791                        va_list args) {
 792         return functions->NewObjectV(this,clazz,methodID,args);
 793     }
 794     jobject NewObjectA(jclass clazz, jmethodID methodID,
 795                        jvalue *args) {
 796         return functions->NewObjectA(this,clazz,methodID,args);
 797     }
 798
 799     jclass GetObjectClass(jobject obj) {
 800         return functions->GetObjectClass(this,obj);
 801     }
 802     jboolean IsInstanceOf(jobject obj, jclass clazz) {
 803         return functions->IsInstanceOf(this,obj,clazz);
 804     }
 805
 806     jmethodID GetMethodID(jclass clazz, const char *name,
 807                           const char *sig) {
 808         return functions->GetMethodID(this,clazz,name,sig);
 809     }
 810
 811     jobject CallObjectMethod(jobject obj, jmethodID methodID, ...) {
 812         va_list args;
 813         jobject result;
 814         va_start(args,methodID);
 815         result = functions->CallObjectMethodV(this,obj,methodID,args);
 816         va_end(args);
 817         return result;
 818     }
 819     jobject CallObjectMethodV(jobject obj, jmethodID methodID,
 820                         va_list args) {
 821         return functions->CallObjectMethodV(this,obj,methodID,args);
 822     }
 823     jobject CallObjectMethodA(jobject obj, jmethodID methodID,
 824                         jvalue * args) {
 825         return functions->CallObjectMethodA(this,obj,methodID,args);
 826     }
 827
 828     jboolean CallBooleanMethod(jobject obj,
 829                                jmethodID methodID, ...) {
 830         va_list args;
 831         jboolean result;
 832         va_start(args,methodID);
 833         result = functions->CallBooleanMethodV(this,obj,methodID,args);
 834         va_end(args);
 835         return result;
 836     }
 837     jboolean CallBooleanMethodV(jobject obj, jmethodID methodID,
 838                                 va_list args) {
 839         return functions->CallBooleanMethodV(this,obj,methodID,args);
 840     }
 841     jboolean CallBooleanMethodA(jobject obj, jmethodID methodID,
 842                                 jvalue * args) {
 843         return functions->CallBooleanMethodA(this,obj,methodID, args);
 844     }
 845
 846     jbyte CallByteMethod(jobject obj, jmethodID methodID, ...) {
 847         va_list args;
 848         jbyte result;
 849         va_start(args,methodID);
 850         result = functions->CallByteMethodV(this,obj,methodID,args);
 851         va_end(args);
 852         return result;
 853     }
 854     jbyte CallByteMethodV(jobject obj, jmethodID methodID,
 855                           va_list args) {
 856         return functions->CallByteMethodV(this,obj,methodID,args);
 857     }
 858     jbyte CallByteMethodA(jobject obj, jmethodID methodID,
 859                           jvalue * args) {
 860         return functions->CallByteMethodA(this,obj,methodID,args);
 861     }
 862
 863     jchar CallCharMethod(jobject obj, jmethodID methodID, ...) {
 864         va_list args;
 865         jchar result;
 866         va_start(args,methodID);
 867         result = functions->CallCharMethodV(this,obj,methodID,args);
 868         va_end(args);
 869         return result;
 870     }
 871     jchar CallCharMethodV(jobject obj, jmethodID methodID,
 872                           va_list args) {
 873         return functions->CallCharMethodV(this,obj,methodID,args);
 874     }
 875     jchar CallCharMethodA(jobject obj, jmethodID methodID,
 876                           jvalue * args) {
 877         return functions->CallCharMethodA(this,obj,methodID,args);
 878     }
 879
 880     jshort CallShortMethod(jobject obj, jmethodID methodID, ...) {
 881         va_list args;
 882         jshort result;
 883         va_start(args,methodID);
 884         result = functions->CallShortMethodV(this,obj,methodID,args);
 885         va_end(args);
 886         return result;
 887     }
 888     jshort CallShortMethodV(jobject obj, jmethodID methodID,
 889                             va_list args) {
 890         return functions->CallShortMethodV(this,obj,methodID,args);
 891     }
 892     jshort CallShortMethodA(jobject obj, jmethodID methodID,
 893                             jvalue * args) {
 894         return functions->CallShortMethodA(this,obj,methodID,args);
 895     }
 896
 897     jint CallIntMethod(jobject obj, jmethodID methodID, ...) {
 898         va_list args;
 899         jint result;
 900         va_start(args,methodID);
 901         result = functions->CallIntMethodV(this,obj,methodID,args);
 902         va_end(args);
 903         return result;
 904     }
 905     jint CallIntMethodV(jobject obj, jmethodID methodID,
 906                         va_list args) {
 907         return functions->CallIntMethodV(this,obj,methodID,args);
 908     }
 909     jint CallIntMethodA(jobject obj, jmethodID methodID,
 910                         jvalue * args) {
 911         return functions->CallIntMethodA(this,obj,methodID,args);
 912     }
 913
 914     jlong CallLongMethod(jobject obj, jmethodID methodID, ...) {
 915         va_list args;
 916         jlong result;
 917         va_start(args,methodID);
 918         result = functions->CallLongMethodV(this,obj,methodID,args);
 919         va_end(args);
 920         return result;
 921     }
 922     jlong CallLongMethodV(jobject obj, jmethodID methodID,
 923                           va_list args) {
 924         return functions->CallLongMethodV(this,obj,methodID,args);
 925     }
 926     jlong CallLongMethodA(jobject obj, jmethodID methodID,
 927                           jvalue * args) {
 928         return functions->CallLongMethodA(this,obj,methodID,args);
 929     }
 930
 931     jfloat CallFloatMethod(jobject obj, jmethodID methodID, ...) {
 932         va_list args;
 933         jfloat result;
 934         va_start(args,methodID);
 935         result = functions->CallFloatMethodV(this,obj,methodID,args);
 936         va_end(args);
 937         return result;
 938     }
 939     jfloat CallFloatMethodV(jobject obj, jmethodID methodID,
 940                             va_list args) {
 941         return functions->CallFloatMethodV(this,obj,methodID,args);
 942     }
 943     jfloat CallFloatMethodA(jobject obj, jmethodID methodID,
 944                             jvalue * args) {
 945         return functions->CallFloatMethodA(this,obj,methodID,args);
 946     }
 947
 948     jdouble CallDoubleMethod(jobject obj, jmethodID methodID, ...) {
 949         va_list args;
 950         jdouble result;
 951         va_start(args,methodID);
 952         result = functions->CallDoubleMethodV(this,obj,methodID,args);
 953         va_end(args);
 954         return result;
 955     }
 956     jdouble CallDoubleMethodV(jobject obj, jmethodID methodID,
 957                         va_list args) {
 958         return functions->CallDoubleMethodV(this,obj,methodID,args);
 959     }
 960     jdouble CallDoubleMethodA(jobject obj, jmethodID methodID,
 961                         jvalue * args) {
 962         return functions->CallDoubleMethodA(this,obj,methodID,args);
 963     }
 964
 965     void CallVoidMethod(jobject obj, jmethodID methodID, ...) {
 966         va_list args;
 967         va_start(args,methodID);
 968         functions->CallVoidMethodV(this,obj,methodID,args);
 969         va_end(args);
 970     }
 971     void CallVoidMethodV(jobject obj, jmethodID methodID,
 972                          va_list args) {
 973         functions->CallVoidMethodV(this,obj,methodID,args);
 974     }
 975     void CallVoidMethodA(jobject obj, jmethodID methodID,
 976                          jvalue * args) {
 977         functions->CallVoidMethodA(this,obj,methodID,args);
 978     }
 979
 980     jobject CallNonvirtualObjectMethod(jobject obj, jclass clazz,
 981                                        jmethodID methodID, ...) {
 982         va_list args;
 983         jobject result;
 984         va_start(args,methodID);
 985         result = functions->CallNonvirtualObjectMethodV(this,obj,clazz,
 986                                                         methodID,args);
 987         va_end(args);
 988         return result;
 989     }
 990     jobject CallNonvirtualObjectMethodV(jobject obj, jclass clazz,
 991                                         jmethodID methodID, va_list args) {
 992         return functions->CallNonvirtualObjectMethodV(this,obj,clazz,
 993                                                       methodID,args);
 994     }
 995     jobject CallNonvirtualObjectMethodA(jobject obj, jclass clazz,
 996                                         jmethodID methodID, jvalue * args) {
 997         return functions->CallNonvirtualObjectMethodA(this,obj,clazz,
 998                                                       methodID,args);
 999     }
1000
1001     jboolean CallNonvirtualBooleanMethod(jobject obj, jclass clazz,
1002                                          jmethodID methodID, ...) {
1003         va_list args;
1004         jboolean result;
1005         va_start(args,methodID);
1006         result = functions->CallNonvirtualBooleanMethodV(this,obj,clazz,
1007                                                          methodID,args);
1008         va_end(args);
1009         return result;
1010     }
1011     jboolean CallNonvirtualBooleanMethodV(jobject obj, jclass clazz,
1012                                           jmethodID methodID, va_list args) {
1013         return functions->CallNonvirtualBooleanMethodV(this,obj,clazz,
1014                                                        methodID,args);
1015     }
1016     jboolean CallNonvirtualBooleanMethodA(jobject obj, jclass clazz,
1017                                           jmethodID methodID, jvalue * args) {
1018         return functions->CallNonvirtualBooleanMethodA(this,obj,clazz,
1019                                                        methodID, args);
1020     }
1021
1022     jbyte CallNonvirtualByteMethod(jobject obj, jclass clazz,
1023                                    jmethodID methodID, ...) {
1024         va_list args;
1025         jbyte result;
1026         va_start(args,methodID);
1027         result = functions->CallNonvirtualByteMethodV(this,obj,clazz,
1028                                                       methodID,args);
1029         va_end(args);
1030         return result;
1031     }
1032     jbyte CallNonvirtualByteMethodV(jobject obj, jclass clazz,
1033                                     jmethodID methodID, va_list args) {
1034         return functions->CallNonvirtualByteMethodV(this,obj,clazz,
1035                                                     methodID,args);
1036     }
1037     jbyte CallNonvirtualByteMethodA(jobject obj, jclass clazz,
1038                                     jmethodID methodID, jvalue * args) {
1039         return functions->CallNonvirtualByteMethodA(this,obj,clazz,
1040                                                     methodID,args);
1041     }
1042
1043     jchar CallNonvirtualCharMethod(jobject obj, jclass clazz,
1044                                    jmethodID methodID, ...) {
1045         va_list args;
1046         jchar result;
1047         va_start(args,methodID);
1048         result = functions->CallNonvirtualCharMethodV(this,obj,clazz,
1049                                                       methodID,args);
1050         va_end(args);
1051         return result;
1052     }
1053     jchar CallNonvirtualCharMethodV(jobject obj, jclass clazz,
1054                                     jmethodID methodID, va_list args) {
1055         return functions->CallNonvirtualCharMethodV(this,obj,clazz,
1056                                                     methodID,args);
1057     }
1058     jchar CallNonvirtualCharMethodA(jobject obj, jclass clazz,
1059                                     jmethodID methodID, jvalue * args) {
1060         return functions->CallNonvirtualCharMethodA(this,obj,clazz,
1061                                                     methodID,args);
1062     }
1063
1064     jshort CallNonvirtualShortMethod(jobject obj, jclass clazz,
1065                                      jmethodID methodID, ...) {
1066         va_list args;
1067         jshort result;
1068         va_start(args,methodID);
1069         result = functions->CallNonvirtualShortMethodV(this,obj,clazz,
1070                                                        methodID,args);
1071         va_end(args);
1072         return result;
1073     }
1074     jshort CallNonvirtualShortMethodV(jobject obj, jclass clazz,
1075                                       jmethodID methodID, va_list args) {
1076         return functions->CallNonvirtualShortMethodV(this,obj,clazz,
1077                                                      methodID,args);
1078     }
1079     jshort CallNonvirtualShortMethodA(jobject obj, jclass clazz,
1080                                       jmethodID methodID, jvalue * args) {
1081         return functions->CallNonvirtualShortMethodA(this,obj,clazz,
1082                                                      methodID,args);
1083     }
1084
1085     jint CallNonvirtualIntMethod(jobject obj, jclass clazz,
1086                                  jmethodID methodID, ...) {
1087         va_list args;
1088         jint result;
1089         va_start(args,methodID);
1090         result = functions->CallNonvirtualIntMethodV(this,obj,clazz,
1091                                                      methodID,args);
1092         va_end(args);
1093         return result;
1094     }
1095     jint CallNonvirtualIntMethodV(jobject obj, jclass clazz,
1096                                   jmethodID methodID, va_list args) {
1097         return functions->CallNonvirtualIntMethodV(this,obj,clazz,
1098                                                    methodID,args);
1099     }
1100     jint CallNonvirtualIntMethodA(jobject obj, jclass clazz,
1101                                   jmethodID methodID, jvalue * args) {
1102         return functions->CallNonvirtualIntMethodA(this,obj,clazz,
1103                                                    methodID,args);
1104     }
1105
1106     jlong CallNonvirtualLongMethod(jobject obj, jclass clazz,
1107                                    jmethodID methodID, ...) {
1108         va_list args;
1109         jlong result;
1110         va_start(args,methodID);
1111         result = functions->CallNonvirtualLongMethodV(this,obj,clazz,
1112                                                       methodID,args);
1113         va_end(args);
1114         return result;
1115     }
1116     jlong CallNonvirtualLongMethodV(jobject obj, jclass clazz,
1117                                     jmethodID methodID, va_list args) {
1118         return functions->CallNonvirtualLongMethodV(this,obj,clazz,
1119                                                     methodID,args);
1120     }
1121     jlong CallNonvirtualLongMethodA(jobject obj, jclass clazz,
1122                                     jmethodID methodID, jvalue * args) {
1123         return functions->CallNonvirtualLongMethodA(this,obj,clazz,
1124                                                     methodID,args);
1125     }
1126
1127     jfloat CallNonvirtualFloatMethod(jobject obj, jclass clazz,
1128                                      jmethodID methodID, ...) {
1129         va_list args;
1130         jfloat result;
1131         va_start(args,methodID);
1132         result = functions->CallNonvirtualFloatMethodV(this,obj,clazz,
1133                                                        methodID,args);
1134         va_end(args);
1135         return result;
1136     }
1137     jfloat CallNonvirtualFloatMethodV(jobject obj, jclass clazz,
1138                                       jmethodID methodID,
1139                                       va_list args) {
1140         return functions->CallNonvirtualFloatMethodV(this,obj,clazz,
1141                                                      methodID,args);
1142     }
1143     jfloat CallNonvirtualFloatMethodA(jobject obj, jclass clazz,
1144                                       jmethodID methodID,
1145                                       jvalue * args) {
1146         return functions->CallNonvirtualFloatMethodA(this,obj,clazz,
1147                                                      methodID,args);
1148     }
1149
1150     jdouble CallNonvirtualDoubleMethod(jobject obj, jclass clazz,
1151                                        jmethodID methodID, ...) {
1152         va_list args;
1153         jdouble result;
1154         va_start(args,methodID);
1155         result = functions->CallNonvirtualDoubleMethodV(this,obj,clazz,
1156                                                         methodID,args);
1157         va_end(args);
1158         return result;
1159     }
1160     jdouble CallNonvirtualDoubleMethodV(jobject obj, jclass clazz,
1161                                         jmethodID methodID,
1162                                         va_list args) {
1163         return functions->CallNonvirtualDoubleMethodV(this,obj,clazz,
1164                                                       methodID,args);
1165     }
1166     jdouble CallNonvirtualDoubleMethodA(jobject obj, jclass clazz,
1167                                         jmethodID methodID,
1168                                         jvalue * args) {
1169         return functions->CallNonvirtualDoubleMethodA(this,obj,clazz,
1170                                                       methodID,args);
1171     }
1172
1173     void CallNonvirtualVoidMethod(jobject obj, jclass clazz,
1174                                   jmethodID methodID, ...) {
1175         va_list args;
1176         va_start(args,methodID);
1177         functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);
1178         va_end(args);
1179     }
1180     void CallNonvirtualVoidMethodV(jobject obj, jclass clazz,
1181                                    jmethodID methodID,
1182                                    va_list args) {
1183         functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);
1184     }
1185     void CallNonvirtualVoidMethodA(jobject obj, jclass clazz,
1186                                    jmethodID methodID,
1187                                    jvalue * args) {
1188         functions->CallNonvirtualVoidMethodA(this,obj,clazz,methodID,args);
1189     }
1190
1191     jfieldID GetFieldID(jclass clazz, const char *name,
1192                         const char *sig) {
1193         return functions->GetFieldID(this,clazz,name,sig);
1194     }
1195
1196     jobject GetObjectField(jobject obj, jfieldID fieldID) {
1197         return functions->GetObjectField(this,obj,fieldID);
1198     }
1199     jboolean GetBooleanField(jobject obj, jfieldID fieldID) {
1200         return functions->GetBooleanField(this,obj,fieldID);
1201     }
1202     jbyte GetByteField(jobject obj, jfieldID fieldID) {
1203         return functions->GetByteField(this,obj,fieldID);
1204     }
1205     jchar GetCharField(jobject obj, jfieldID fieldID) {
1206         return functions->GetCharField(this,obj,fieldID);
1207     }
1208     jshort GetShortField(jobject obj, jfieldID fieldID) {
1209         return functions->GetShortField(this,obj,fieldID);
1210     }
1211     jint GetIntField(jobject obj, jfieldID fieldID) {
1212         return functions->GetIntField(this,obj,fieldID);
1213     }
1214     jlong GetLongField(jobject obj, jfieldID fieldID) {
1215         return functions->GetLongField(this,obj,fieldID);
1216     }
1217     jfloat GetFloatField(jobject obj, jfieldID fieldID) {
1218         return functions->GetFloatField(this,obj,fieldID);
1219     }
1220     jdouble GetDoubleField(jobject obj, jfieldID fieldID) {
1221         return functions->GetDoubleField(this,obj,fieldID);
1222     }
1223
1224     void SetObjectField(jobject obj, jfieldID fieldID, jobject val) {
1225         functions->SetObjectField(this,obj,fieldID,val);
1226     }
1227     void SetBooleanField(jobject obj, jfieldID fieldID,
1228                          jboolean val) {
1229         functions->SetBooleanField(this,obj,fieldID,val);
1230     }
1231     void SetByteField(jobject obj, jfieldID fieldID,
1232                       jbyte val) {
1233         functions->SetByteField(this,obj,fieldID,val);
1234     }
1235     void SetCharField(jobject obj, jfieldID fieldID,
1236                       jchar val) {
1237         functions->SetCharField(this,obj,fieldID,val);
1238     }
1239     void SetShortField(jobject obj, jfieldID fieldID,
1240                        jshort val) {
1241         functions->SetShortField(this,obj,fieldID,val);
1242     }
1243     void SetIntField(jobject obj, jfieldID fieldID,
1244                      jint val) {
1245         functions->SetIntField(this,obj,fieldID,val);
1246     }
1247     void SetLongField(jobject obj, jfieldID fieldID,
1248                       jlong val) {
1249         functions->SetLongField(this,obj,fieldID,val);
1250     }
1251     void SetFloatField(jobject obj, jfieldID fieldID,
1252                        jfloat val) {
1253         functions->SetFloatField(this,obj,fieldID,val);
1254     }
1255     void SetDoubleField(jobject obj, jfieldID fieldID,
1256                         jdouble val) {
1257         functions->SetDoubleField(this,obj,fieldID,val);
1258     }
1259
1260     jmethodID GetStaticMethodID(jclass clazz, const char *name,
1261                                 const char *sig) {
1262         return functions->GetStaticMethodID(this,clazz,name,sig);
1263     }
1264
1265     jobject CallStaticObjectMethod(jclass clazz, jmethodID methodID,
1266                              ...) {
1267         va_list args;
1268         jobject result;
1269         va_start(args,methodID);
1270         result = functions->CallStaticObjectMethodV(this,clazz,methodID,args);
1271         va_end(args);
1272         return result;
1273     }
1274     jobject CallStaticObjectMethodV(jclass clazz, jmethodID methodID,
1275                               va_list args) {
1276         return functions->CallStaticObjectMethodV(this,clazz,methodID,args);
1277     }
1278     jobject CallStaticObjectMethodA(jclass clazz, jmethodID methodID,
1279                               jvalue *args) {
1280         return functions->CallStaticObjectMethodA(this,clazz,methodID,args);
1281     }
1282
1283     jboolean CallStaticBooleanMethod(jclass clazz,
1284                                      jmethodID methodID, ...) {
1285         va_list args;
1286         jboolean result;
1287         va_start(args,methodID);
1288         result = functions->CallStaticBooleanMethodV(this,clazz,methodID,args);
1289         va_end(args);
1290         return result;
1291     }
1292     jboolean CallStaticBooleanMethodV(jclass clazz,
1293                                       jmethodID methodID, va_list args) {
1294         return functions->CallStaticBooleanMethodV(this,clazz,methodID,args);
1295     }
1296     jboolean CallStaticBooleanMethodA(jclass clazz,
1297                                       jmethodID methodID, jvalue *args) {
1298         return functions->CallStaticBooleanMethodA(this,clazz,methodID,args);
1299     }
1300
1301     jbyte CallStaticByteMethod(jclass clazz,
1302                                jmethodID methodID, ...) {
1303         va_list args;
1304         jbyte result;
1305         va_start(args,methodID);
1306         result = functions->CallStaticByteMethodV(this,clazz,methodID,args);
1307         va_end(args);
1308         return result;
1309     }
1310     jbyte CallStaticByteMethodV(jclass clazz,
1311                                 jmethodID methodID, va_list args) {
1312         return functions->CallStaticByteMethodV(this,clazz,methodID,args);
1313     }
1314     jbyte CallStaticByteMethodA(jclass clazz,
1315                                 jmethodID methodID, jvalue *args) {
1316         return functions->CallStaticByteMethodA(this,clazz,methodID,args);
1317     }
1318
1319     jchar CallStaticCharMethod(jclass clazz,
1320                                jmethodID methodID, ...) {
1321         va_list args;
1322         jchar result;
1323         va_start(args,methodID);
1324         result = functions->CallStaticCharMethodV(this,clazz,methodID,args);
1325         va_end(args);
1326         return result;
1327     }
1328     jchar CallStaticCharMethodV(jclass clazz,
1329                                 jmethodID methodID, va_list args) {
1330         return functions->CallStaticCharMethodV(this,clazz,methodID,args);
1331     }
1332     jchar CallStaticCharMethodA(jclass clazz,
1333                                 jmethodID methodID, jvalue *args) {
1334         return functions->CallStaticCharMethodA(this,clazz,methodID,args);
1335     }
1336
1337     jshort CallStaticShortMethod(jclass clazz,
1338                                  jmethodID methodID, ...) {
1339         va_list args;
1340         jshort result;
1341         va_start(args,methodID);
1342         result = functions->CallStaticShortMethodV(this,clazz,methodID,args);
1343         va_end(args);
1344         return result;
1345     }
1346     jshort CallStaticShortMethodV(jclass clazz,
1347                                   jmethodID methodID, va_list args) {
1348         return functions->CallStaticShortMethodV(this,clazz,methodID,args);
1349     }
1350     jshort CallStaticShortMethodA(jclass clazz,
1351                                   jmethodID methodID, jvalue *args) {
1352         return functions->CallStaticShortMethodA(this,clazz,methodID,args);
1353     }
1354
1355     jint CallStaticIntMethod(jclass clazz,
1356                              jmethodID methodID, ...) {
1357         va_list args;
1358         jint result;
1359         va_start(args,methodID);
1360         result = functions->CallStaticIntMethodV(this,clazz,methodID,args);
1361         va_end(args);
1362         return result;
1363     }
1364     jint CallStaticIntMethodV(jclass clazz,
1365                               jmethodID methodID, va_list args) {
1366         return functions->CallStaticIntMethodV(this,clazz,methodID,args);
1367     }
1368     jint CallStaticIntMethodA(jclass clazz,
1369                               jmethodID methodID, jvalue *args) {
1370         return functions->CallStaticIntMethodA(this,clazz,methodID,args);
1371     }
1372
1373     jlong CallStaticLongMethod(jclass clazz,
1374                                jmethodID methodID, ...) {
1375         va_list args;
1376         jlong result;
1377         va_start(args,methodID);
1378         result = functions->CallStaticLongMethodV(this,clazz,methodID,args);
1379         va_end(args);
1380         return result;
1381     }
1382     jlong CallStaticLongMethodV(jclass clazz,
1383                                 jmethodID methodID, va_list args) {
1384         return functions->CallStaticLongMethodV(this,clazz,methodID,args);
1385     }
1386     jlong CallStaticLongMethodA(jclass clazz,
1387                                 jmethodID methodID, jvalue *args) {
1388         return functions->CallStaticLongMethodA(this,clazz,methodID,args);
1389     }
1390
1391     jfloat CallStaticFloatMethod(jclass clazz,
1392                                  jmethodID methodID, ...) {
1393         va_list args;
1394         jfloat result;
1395         va_start(args,methodID);
1396         result = functions->CallStaticFloatMethodV(this,clazz,methodID,args);
1397         va_end(args);
1398         return result;
1399     }
1400     jfloat CallStaticFloatMethodV(jclass clazz,
1401                                   jmethodID methodID, va_list args) {
1402         return functions->CallStaticFloatMethodV(this,clazz,methodID,args);
1403     }
1404     jfloat CallStaticFloatMethodA(jclass clazz,
1405                                   jmethodID methodID, jvalue *args) {
1406         return functions->CallStaticFloatMethodA(this,clazz,methodID,args);
1407     }
1408
1409     jdouble CallStaticDoubleMethod(jclass clazz,
1410                                    jmethodID methodID, ...) {
1411         va_list args;
1412         jdouble result;
1413         va_start(args,methodID);
1414         result = functions->CallStaticDoubleMethodV(this,clazz,methodID,args);
1415         va_end(args);
1416         return result;
1417     }
1418     jdouble CallStaticDoubleMethodV(jclass clazz,
1419                                     jmethodID methodID, va_list args) {
1420         return functions->CallStaticDoubleMethodV(this,clazz,methodID,args);
1421     }
1422     jdouble CallStaticDoubleMethodA(jclass clazz,
1423                                     jmethodID methodID, jvalue *args) {
1424         return functions->CallStaticDoubleMethodA(this,clazz,methodID,args);
1425     }
1426
1427     void CallStaticVoidMethod(jclass cls, jmethodID methodID, ...) {
1428         va_list args;
1429         va_start(args,methodID);
1430         functions->CallStaticVoidMethodV(this,cls,methodID,args);
1431         va_end(args);
1432     }
1433     void CallStaticVoidMethodV(jclass cls, jmethodID methodID,
1434                                va_list args) {
1435         functions->CallStaticVoidMethodV(this,cls,methodID,args);
1436     }
1437     void CallStaticVoidMethodA(jclass cls, jmethodID methodID,
1438                                jvalue * args) {
1439         functions->CallStaticVoidMethodA(this,cls,methodID,args);
1440     }
1441
1442     jfieldID GetStaticFieldID(jclass clazz, const char *name,
1443                               const char *sig) {
1444         return functions->GetStaticFieldID(this,clazz,name,sig);
1445     }
1446     jobject GetStaticObjectField(jclass clazz, jfieldID fieldID) {
1447         return functions->GetStaticObjectField(this,clazz,fieldID);
1448     }
1449     jboolean GetStaticBooleanField(jclass clazz, jfieldID fieldID) {
1450         return functions->GetStaticBooleanField(this,clazz,fieldID);
1451     }
1452     jbyte GetStaticByteField(jclass clazz, jfieldID fieldID) {
1453         return functions->GetStaticByteField(this,clazz,fieldID);
1454     }
1455     jchar GetStaticCharField(jclass clazz, jfieldID fieldID) {
1456         return functions->GetStaticCharField(this,clazz,fieldID);
1457     }
1458     jshort GetStaticShortField(jclass clazz, jfieldID fieldID) {
1459         return functions->GetStaticShortField(this,clazz,fieldID);
1460     }
1461     jint GetStaticIntField(jclass clazz, jfieldID fieldID) {
1462         return functions->GetStaticIntField(this,clazz,fieldID);
1463     }
1464     jlong GetStaticLongField(jclass clazz, jfieldID fieldID) {
1465         return functions->GetStaticLongField(this,clazz,fieldID);
1466     }
1467     jfloat GetStaticFloatField(jclass clazz, jfieldID fieldID) {
1468         return functions->GetStaticFloatField(this,clazz,fieldID);
1469     }
1470     jdouble GetStaticDoubleField(jclass clazz, jfieldID fieldID) {
1471         return functions->GetStaticDoubleField(this,clazz,fieldID);
1472     }
1473
1474     void SetStaticObjectField(jclass clazz, jfieldID fieldID,
1475                         jobject value) {
1476       functions->SetStaticObjectField(this,clazz,fieldID,value);
1477     }
1478     void SetStaticBooleanField(jclass clazz, jfieldID fieldID,
1479                         jboolean value) {
1480       functions->SetStaticBooleanField(this,clazz,fieldID,value);
1481     }
1482     void SetStaticByteField(jclass clazz, jfieldID fieldID,
1483                         jbyte value) {
1484       functions->SetStaticByteField(this,clazz,fieldID,value);
1485     }
1486     void SetStaticCharField(jclass clazz, jfieldID fieldID,
1487                         jchar value) {
1488       functions->SetStaticCharField(this,clazz,fieldID,value);
1489     }
1490     void SetStaticShortField(jclass clazz, jfieldID fieldID,
1491                         jshort value) {
1492       functions->SetStaticShortField(this,clazz,fieldID,value);
1493     }
1494     void SetStaticIntField(jclass clazz, jfieldID fieldID,
1495                         jint value) {
1496       functions->SetStaticIntField(this,clazz,fieldID,value);
1497     }
1498     void SetStaticLongField(jclass clazz, jfieldID fieldID,
1499                         jlong value) {
1500       functions->SetStaticLongField(this,clazz,fieldID,value);
1501     }
1502     void SetStaticFloatField(jclass clazz, jfieldID fieldID,
1503                         jfloat value) {
1504       functions->SetStaticFloatField(this,clazz,fieldID,value);
1505     }
1506     void SetStaticDoubleField(jclass clazz, jfieldID fieldID,
1507                         jdouble value) {
1508       functions->SetStaticDoubleField(this,clazz,fieldID,value);
1509     }
1510
1511     jstring NewString(const jchar *unicode, jsize len) {
1512         return functions->NewString(this,unicode,len);
1513     }
1514     jsize GetStringLength(jstring str) {
1515         return functions->GetStringLength(this,str);
1516     }
1517     const jchar *GetStringChars(jstring str, jboolean *isCopy) {
1518         return functions->GetStringChars(this,str,isCopy);
1519     }
1520     void ReleaseStringChars(jstring str, const jchar *chars) {
1521         functions->ReleaseStringChars(this,str,chars);
1522     }
1523
1524     jstring NewStringUTF(const char *utf) {
1525         return functions->NewStringUTF(this,utf);
1526     }
1527     jsize GetStringUTFLength(jstring str) {
1528         return functions->GetStringUTFLength(this,str);
1529     }
1530     const char* GetStringUTFChars(jstring str, jboolean *isCopy) {
1531         return functions->GetStringUTFChars(this,str,isCopy);
1532     }
1533     void ReleaseStringUTFChars(jstring str, const char* chars) {
1534         functions->ReleaseStringUTFChars(this,str,chars);
1535     }
1536
1537     jsize GetArrayLength(jarray array) {
1538         return functions->GetArrayLength(this,array);
1539     }
1540
1541     jobjectArray NewObjectArray(jsize len, jclass clazz,
1542                                 jobject init) {
1543         return functions->NewObjectArray(this,len,clazz,init);
1544     }
1545     jobject GetObjectArrayElement(jobjectArray array, jsize index) {
1546         return functions->GetObjectArrayElement(this,array,index);
1547     }
1548     void SetObjectArrayElement(jobjectArray array, jsize index,
1549                                jobject val) {
1550         functions->SetObjectArrayElement(this,array,index,val);
1551     }
1552
1553     jbooleanArray NewBooleanArray(jsize len) {
1554         return functions->NewBooleanArray(this,len);
1555     }
1556     jbyteArray NewByteArray(jsize len) {
1557         return functions->NewByteArray(this,len);
1558     }
1559     jcharArray NewCharArray(jsize len) {
1560         return functions->NewCharArray(this,len);
1561     }
1562     jshortArray NewShortArray(jsize len) {
1563         return functions->NewShortArray(this,len);
1564     }
1565     jintArray NewIntArray(jsize len) {
1566         return functions->NewIntArray(this,len);
1567     }
1568     jlongArray NewLongArray(jsize len) {
1569         return functions->NewLongArray(this,len);
1570     }
1571     jfloatArray NewFloatArray(jsize len) {
1572         return functions->NewFloatArray(this,len);
1573     }
1574     jdoubleArray NewDoubleArray(jsize len) {
1575         return functions->NewDoubleArray(this,len);
1576     }
1577
1578     jboolean * GetBooleanArrayElements(jbooleanArray array, jboolean *isCopy) {
1579         return functions->GetBooleanArrayElements(this,array,isCopy);
1580     }
1581     jbyte * GetByteArrayElements(jbyteArray array, jboolean *isCopy) {
1582         return functions->GetByteArrayElements(this,array,isCopy);
1583     }
1584     jchar * GetCharArrayElements(jcharArray array, jboolean *isCopy) {
1585         return functions->GetCharArrayElements(this,array,isCopy);
1586     }
1587     jshort * GetShortArrayElements(jshortArray array, jboolean *isCopy) {
1588         return functions->GetShortArrayElements(this,array,isCopy);
1589     }
1590     jint * GetIntArrayElements(jintArray array, jboolean *isCopy) {
1591         return functions->GetIntArrayElements(this,array,isCopy);
1592     }
1593     jlong * GetLongArrayElements(jlongArray array, jboolean *isCopy) {
1594         return functions->GetLongArrayElements(this,array,isCopy);
1595     }
1596     jfloat * GetFloatArrayElements(jfloatArray array, jboolean *isCopy) {
1597         return functions->GetFloatArrayElements(this,array,isCopy);
1598     }
1599     jdouble * GetDoubleArrayElements(jdoubleArray array, jboolean *isCopy) {
1600         return functions->GetDoubleArrayElements(this,array,isCopy);
1601     }
1602
1603     void ReleaseBooleanArrayElements(jbooleanArray array,
1604                                      jboolean *elems,
1605                                      jint mode) {
1606         functions->ReleaseBooleanArrayElements(this,array,elems,mode);
1607     }
1608     void ReleaseByteArrayElements(jbyteArray array,
1609                                   jbyte *elems,
1610                                   jint mode) {
1611         functions->ReleaseByteArrayElements(this,array,elems,mode);
1612     }
1613     void ReleaseCharArrayElements(jcharArray array,
1614                                   jchar *elems,
1615                                   jint mode) {
1616         functions->ReleaseCharArrayElements(this,array,elems,mode);
1617     }
1618     void ReleaseShortArrayElements(jshortArray array,
1619                                    jshort *elems,
1620                                    jint mode) {
1621         functions->ReleaseShortArrayElements(this,array,elems,mode);
1622     }
1623     void ReleaseIntArrayElements(jintArray array,
1624                                  jint *elems,
1625                                  jint mode) {
1626         functions->ReleaseIntArrayElements(this,array,elems,mode);
1627     }
1628     void ReleaseLongArrayElements(jlongArray array,
1629                                   jlong *elems,
1630                                   jint mode) {
1631         functions->ReleaseLongArrayElements(this,array,elems,mode);
1632     }
1633     void ReleaseFloatArrayElements(jfloatArray array,
1634                                    jfloat *elems,
1635                                    jint mode) {
1636         functions->ReleaseFloatArrayElements(this,array,elems,mode);
1637     }
1638     void ReleaseDoubleArrayElements(jdoubleArray array,
1639                                     jdouble *elems,
1640                                     jint mode) {
1641         functions->ReleaseDoubleArrayElements(this,array,elems,mode);
1642     }
1643
1644     void GetBooleanArrayRegion(jbooleanArray array,
1645                                jsize start, jsize len, jboolean *buf) {
1646         functions->GetBooleanArrayRegion(this,array,start,len,buf);
1647     }
1648     void GetByteArrayRegion(jbyteArray array,
1649                             jsize start, jsize len, jbyte *buf) {
1650         functions->GetByteArrayRegion(this,array,start,len,buf);
1651     }
1652     void GetCharArrayRegion(jcharArray array,
1653                             jsize start, jsize len, jchar *buf) {
1654         functions->GetCharArrayRegion(this,array,start,len,buf);
1655     }
1656     void GetShortArrayRegion(jshortArray array,
1657                              jsize start, jsize len, jshort *buf) {
1658         functions->GetShortArrayRegion(this,array,start,len,buf);
1659     }
1660     void GetIntArrayRegion(jintArray array,
1661                            jsize start, jsize len, jint *buf) {
1662         functions->GetIntArrayRegion(this,array,start,len,buf);
1663     }
1664     void GetLongArrayRegion(jlongArray array,
1665                             jsize start, jsize len, jlong *buf) {
1666         functions->GetLongArrayRegion(this,array,start,len,buf);
1667     }
1668     void GetFloatArrayRegion(jfloatArray array,
1669                              jsize start, jsize len, jfloat *buf) {
1670         functions->GetFloatArrayRegion(this,array,start,len,buf);
1671     }
1672     void GetDoubleArrayRegion(jdoubleArray array,
1673                               jsize start, jsize len, jdouble *buf) {
1674         functions->GetDoubleArrayRegion(this,array,start,len,buf);
1675     }
1676
1677     void SetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len,
1678                                jboolean *buf) {
1679         functions->SetBooleanArrayRegion(this,array,start,len,buf);
1680     }
1681     void SetByteArrayRegion(jbyteArray array, jsize start, jsize len,
1682                             jbyte *buf) {
1683         functions->SetByteArrayRegion(this,array,start,len,buf);
1684     }
1685     void SetCharArrayRegion(jcharArray array, jsize start, jsize len,
1686                             jchar *buf) {
1687         functions->SetCharArrayRegion(this,array,start,len,buf);
1688     }
1689     void SetShortArrayRegion(jshortArray array, jsize start, jsize len,
1690                              jshort *buf) {
1691         functions->SetShortArrayRegion(this,array,start,len,buf);
1692     }
1693     void SetIntArrayRegion(jintArray array, jsize start, jsize len,
1694                            jint *buf) {
1695         functions->SetIntArrayRegion(this,array,start,len,buf);
1696     }
1697     void SetLongArrayRegion(jlongArray array, jsize start, jsize len,
1698                             jlong *buf) {
1699         functions->SetLongArrayRegion(this,array,start,len,buf);
1700     }
1701     void SetFloatArrayRegion(jfloatArray array, jsize start, jsize len,
1702                              jfloat *buf) {
1703         functions->SetFloatArrayRegion(this,array,start,len,buf);
1704     }
1705     void SetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len,
1706                               jdouble *buf) {
1707         functions->SetDoubleArrayRegion(this,array,start,len,buf);
1708     }
1709
1710     jint RegisterNatives(jclass clazz, const JNINativeMethod *methods,
1711                          jint nMethods) {
1712         return functions->RegisterNatives(this,clazz,methods,nMethods);
1713     }
1714     jint UnregisterNatives(jclass clazz) {
1715         return functions->UnregisterNatives(this,clazz);
1716     }
1717
1718     jint MonitorEnter(jobject obj) {
1719         return functions->MonitorEnter(this,obj);
1720     }
1721     jint MonitorExit(jobject obj) {
1722         return functions->MonitorExit(this,obj);
1723     }
1724
1725     jint GetJavaVM(JavaVM **vm) {
1726         return functions->GetJavaVM(this,vm);
1727     }
1728
1729 #endif /* __cplusplus */
1730 };
1731
1732 /* These structures will be VM-specific. */
1733
1734 typedef struct JDK1_1InitArgs {
1735     jint version;
1736
1737     char **properties;
1738     jint checkSource;
1739     jint nativeStackSize;
1740     jint javaStackSize;
1741     jint minHeapSize;
1742     jint maxHeapSize;
1743     jint verifyMode;
1744     char *classpath;
1745
1746     jint (JNICALL *vfprintf)(FILE *fp, const char *format, va_list args);
1747     void (JNICALL *exit)(jint code);
1748     void (JNICALL *abort)();
1749
1750     jint enableClassGC;
1751     jint enableVerboseGC;
1752     jint disableAsyncGC;
1753     jint verbose;
1754     jboolean debugging;
1755     jint debugPort;
1756 } JDK1_1InitArgs;
1757
1758 typedef struct JDK1_1AttachArgs {
1759     void * __padding; /* C compilers don't allow empty structures. */
1760 } JDK1_1AttachArgs;
1761
1762 /* End VM-specific. */
1763
1764 struct JNIInvokeInterface_ {
1765     void *reserved0;
1766     void *reserved1;
1767     void *reserved2;
1768
1769     jint (JNICALL *DestroyJavaVM)(JavaVM *vm);
1770
1771     jint (JNICALL *AttachCurrentThread)
1772       (JavaVM *vm, JNIEnv **penv, void *args);
1773
1774     jint (JNICALL *DetachCurrentThread)(JavaVM *vm);
1775 };
1776
1777 struct JavaVM_ {
1778     const struct JNIInvokeInterface_ *functions;
1779     void *reserved0;
1780     void *reserved1;
1781     void *reserved2;
1782 #ifdef __cplusplus
1783
1784     jint DestroyJavaVM() {
1785         return functions->DestroyJavaVM(this);
1786     }
1787     jint AttachCurrentThread(JNIEnv **penv, void *args) {
1788         return functions->AttachCurrentThread(this, penv, args);
1789     }
1790     jint DetachCurrentThread() {
1791         return functions->DetachCurrentThread(this);
1792     }
1793
1794 #endif
1795 };
1796
1797 JNI_PUBLIC_API(void) JNI_GetDefaultJavaVMInitArgs(void *);
1798
1799 JNI_PUBLIC_API(jint) JNI_CreateJavaVM(JavaVM **, JNIEnv **, void *);
1800
1801 JNI_PUBLIC_API(jint) JNI_GetCreatedJavaVMs(JavaVM **, jsize, jsize *);
1802 JNI_PUBLIC_API(jref) JNI_MakeLocalRef(JNIEnv *pJNIEnv, void *pHObject);
1803
1804 #ifdef __cplusplus
1805 } /* extern "C" */
1806 #endif /* __cplusplus */
1807
1808 #endif /* JNI_H */
1809
1810