org.simantics.fmil.core/native/FMUSimulator/include/jni.h

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