native/IdeaWin32/jni.h

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