1 /*
   2  * Copyright (c) 1996, 2018, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  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     /* Module Features */
 770 
 771     jobject (JNICALL *GetModule)
 772        (JNIEnv* env, jclass clazz);
 773 };
 774 
 775 /*
 776  * We use inlined functions for C++ so that programmers can write:
 777  *
 778  *    env->FindClass("java/lang/String")
 779  *
 780  * in C++ rather than:
 781  *
 782  *    (*env)->FindClass(env, "java/lang/String")
 783  *
 784  * in C.
 785  */
 786 
 787 struct JNIEnv_ {
 788     const struct JNINativeInterface_ *functions;
 789 #ifdef __cplusplus
 790 
 791     jint GetVersion() {
 792         return functions->GetVersion(this);
 793     }
 794     jclass DefineClass(const char *name, jobject loader, const jbyte *buf,
 795                        jsize len) {
 796         return functions->DefineClass(this, name, loader, buf, len);
 797     }
 798     jclass FindClass(const char *name) {
 799         return functions->FindClass(this, name);
 800     }
 801     jmethodID FromReflectedMethod(jobject method) {
 802         return functions->FromReflectedMethod(this,method);
 803     }
 804     jfieldID FromReflectedField(jobject field) {
 805         return functions->FromReflectedField(this,field);
 806     }
 807 
 808     jobject ToReflectedMethod(jclass cls, jmethodID methodID, jboolean isStatic) {
 809         return functions->ToReflectedMethod(this, cls, methodID, isStatic);
 810     }
 811 
 812     jclass GetSuperclass(jclass sub) {
 813         return functions->GetSuperclass(this, sub);
 814     }
 815     jboolean IsAssignableFrom(jclass sub, jclass sup) {
 816         return functions->IsAssignableFrom(this, sub, sup);
 817     }
 818 
 819     jobject ToReflectedField(jclass cls, jfieldID fieldID, jboolean isStatic) {
 820         return functions->ToReflectedField(this,cls,fieldID,isStatic);
 821     }
 822 
 823     jint Throw(jthrowable obj) {
 824         return functions->Throw(this, obj);
 825     }
 826     jint ThrowNew(jclass clazz, const char *msg) {
 827         return functions->ThrowNew(this, clazz, msg);
 828     }
 829     jthrowable ExceptionOccurred() {
 830         return functions->ExceptionOccurred(this);
 831     }
 832     void ExceptionDescribe() {
 833         functions->ExceptionDescribe(this);
 834     }
 835     void ExceptionClear() {
 836         functions->ExceptionClear(this);
 837     }
 838     void FatalError(const char *msg) {
 839         functions->FatalError(this, msg);
 840     }
 841 
 842     jint PushLocalFrame(jint capacity) {
 843         return functions->PushLocalFrame(this,capacity);
 844     }
 845     jobject PopLocalFrame(jobject result) {
 846         return functions->PopLocalFrame(this,result);
 847     }
 848 
 849     jobject NewGlobalRef(jobject lobj) {
 850         return functions->NewGlobalRef(this,lobj);
 851     }
 852     void DeleteGlobalRef(jobject gref) {
 853         functions->DeleteGlobalRef(this,gref);
 854     }
 855     void DeleteLocalRef(jobject obj) {
 856         functions->DeleteLocalRef(this, obj);
 857     }
 858 
 859     jboolean IsSameObject(jobject obj1, jobject obj2) {
 860         return functions->IsSameObject(this,obj1,obj2);
 861     }
 862 
 863     jobject NewLocalRef(jobject ref) {
 864         return functions->NewLocalRef(this,ref);
 865     }
 866     jint EnsureLocalCapacity(jint capacity) {
 867         return functions->EnsureLocalCapacity(this,capacity);
 868     }
 869 
 870     jobject AllocObject(jclass clazz) {
 871         return functions->AllocObject(this,clazz);
 872     }
 873     jobject NewObject(jclass clazz, jmethodID methodID, ...) {
 874         va_list args;
 875         jobject result;
 876         va_start(args, methodID);
 877         result = functions->NewObjectV(this,clazz,methodID,args);
 878         va_end(args);
 879         return result;
 880     }
 881     jobject NewObjectV(jclass clazz, jmethodID methodID,
 882                        va_list args) {
 883         return functions->NewObjectV(this,clazz,methodID,args);
 884     }
 885     jobject NewObjectA(jclass clazz, jmethodID methodID,
 886                        const jvalue *args) {
 887         return functions->NewObjectA(this,clazz,methodID,args);
 888     }
 889 
 890     jclass GetObjectClass(jobject obj) {
 891         return functions->GetObjectClass(this,obj);
 892     }
 893     jboolean IsInstanceOf(jobject obj, jclass clazz) {
 894         return functions->IsInstanceOf(this,obj,clazz);
 895     }
 896 
 897     jmethodID GetMethodID(jclass clazz, const char *name,
 898                           const char *sig) {
 899         return functions->GetMethodID(this,clazz,name,sig);
 900     }
 901 
 902     jobject CallObjectMethod(jobject obj, jmethodID methodID, ...) {
 903         va_list args;
 904         jobject result;
 905         va_start(args,methodID);
 906         result = functions->CallObjectMethodV(this,obj,methodID,args);
 907         va_end(args);
 908         return result;
 909     }
 910     jobject CallObjectMethodV(jobject obj, jmethodID methodID,
 911                         va_list args) {
 912         return functions->CallObjectMethodV(this,obj,methodID,args);
 913     }
 914     jobject CallObjectMethodA(jobject obj, jmethodID methodID,
 915                         const jvalue * args) {
 916         return functions->CallObjectMethodA(this,obj,methodID,args);
 917     }
 918 
 919     jboolean CallBooleanMethod(jobject obj,
 920                                jmethodID methodID, ...) {
 921         va_list args;
 922         jboolean result;
 923         va_start(args,methodID);
 924         result = functions->CallBooleanMethodV(this,obj,methodID,args);
 925         va_end(args);
 926         return result;
 927     }
 928     jboolean CallBooleanMethodV(jobject obj, jmethodID methodID,
 929                                 va_list args) {
 930         return functions->CallBooleanMethodV(this,obj,methodID,args);
 931     }
 932     jboolean CallBooleanMethodA(jobject obj, jmethodID methodID,
 933                                 const jvalue * args) {
 934         return functions->CallBooleanMethodA(this,obj,methodID, args);
 935     }
 936 
 937     jbyte CallByteMethod(jobject obj, jmethodID methodID, ...) {
 938         va_list args;
 939         jbyte result;
 940         va_start(args,methodID);
 941         result = functions->CallByteMethodV(this,obj,methodID,args);
 942         va_end(args);
 943         return result;
 944     }
 945     jbyte CallByteMethodV(jobject obj, jmethodID methodID,
 946                           va_list args) {
 947         return functions->CallByteMethodV(this,obj,methodID,args);
 948     }
 949     jbyte CallByteMethodA(jobject obj, jmethodID methodID,
 950                           const jvalue * args) {
 951         return functions->CallByteMethodA(this,obj,methodID,args);
 952     }
 953 
 954     jchar CallCharMethod(jobject obj, jmethodID methodID, ...) {
 955         va_list args;
 956         jchar result;
 957         va_start(args,methodID);
 958         result = functions->CallCharMethodV(this,obj,methodID,args);
 959         va_end(args);
 960         return result;
 961     }
 962     jchar CallCharMethodV(jobject obj, jmethodID methodID,
 963                           va_list args) {
 964         return functions->CallCharMethodV(this,obj,methodID,args);
 965     }
 966     jchar CallCharMethodA(jobject obj, jmethodID methodID,
 967                           const jvalue * args) {
 968         return functions->CallCharMethodA(this,obj,methodID,args);
 969     }
 970 
 971     jshort CallShortMethod(jobject obj, jmethodID methodID, ...) {
 972         va_list args;
 973         jshort result;
 974         va_start(args,methodID);
 975         result = functions->CallShortMethodV(this,obj,methodID,args);
 976         va_end(args);
 977         return result;
 978     }
 979     jshort CallShortMethodV(jobject obj, jmethodID methodID,
 980                             va_list args) {
 981         return functions->CallShortMethodV(this,obj,methodID,args);
 982     }
 983     jshort CallShortMethodA(jobject obj, jmethodID methodID,
 984                             const jvalue * args) {
 985         return functions->CallShortMethodA(this,obj,methodID,args);
 986     }
 987 
 988     jint CallIntMethod(jobject obj, jmethodID methodID, ...) {
 989         va_list args;
 990         jint result;
 991         va_start(args,methodID);
 992         result = functions->CallIntMethodV(this,obj,methodID,args);
 993         va_end(args);
 994         return result;
 995     }
 996     jint CallIntMethodV(jobject obj, jmethodID methodID,
 997                         va_list args) {
 998         return functions->CallIntMethodV(this,obj,methodID,args);
 999     }
1000     jint CallIntMethodA(jobject obj, jmethodID methodID,
1001                         const jvalue * args) {
1002         return functions->CallIntMethodA(this,obj,methodID,args);
1003     }
1004 
1005     jlong CallLongMethod(jobject obj, jmethodID methodID, ...) {
1006         va_list args;
1007         jlong result;
1008         va_start(args,methodID);
1009         result = functions->CallLongMethodV(this,obj,methodID,args);
1010         va_end(args);
1011         return result;
1012     }
1013     jlong CallLongMethodV(jobject obj, jmethodID methodID,
1014                           va_list args) {
1015         return functions->CallLongMethodV(this,obj,methodID,args);
1016     }
1017     jlong CallLongMethodA(jobject obj, jmethodID methodID,
1018                           const jvalue * args) {
1019         return functions->CallLongMethodA(this,obj,methodID,args);
1020     }
1021 
1022     jfloat CallFloatMethod(jobject obj, jmethodID methodID, ...) {
1023         va_list args;
1024         jfloat result;
1025         va_start(args,methodID);
1026         result = functions->CallFloatMethodV(this,obj,methodID,args);
1027         va_end(args);
1028         return result;
1029     }
1030     jfloat CallFloatMethodV(jobject obj, jmethodID methodID,
1031                             va_list args) {
1032         return functions->CallFloatMethodV(this,obj,methodID,args);
1033     }
1034     jfloat CallFloatMethodA(jobject obj, jmethodID methodID,
1035                             const jvalue * args) {
1036         return functions->CallFloatMethodA(this,obj,methodID,args);
1037     }
1038 
1039     jdouble CallDoubleMethod(jobject obj, jmethodID methodID, ...) {
1040         va_list args;
1041         jdouble result;
1042         va_start(args,methodID);
1043         result = functions->CallDoubleMethodV(this,obj,methodID,args);
1044         va_end(args);
1045         return result;
1046     }
1047     jdouble CallDoubleMethodV(jobject obj, jmethodID methodID,
1048                         va_list args) {
1049         return functions->CallDoubleMethodV(this,obj,methodID,args);
1050     }
1051     jdouble CallDoubleMethodA(jobject obj, jmethodID methodID,
1052                         const jvalue * args) {
1053         return functions->CallDoubleMethodA(this,obj,methodID,args);
1054     }
1055 
1056     void CallVoidMethod(jobject obj, jmethodID methodID, ...) {
1057         va_list args;
1058         va_start(args,methodID);
1059         functions->CallVoidMethodV(this,obj,methodID,args);
1060         va_end(args);
1061     }
1062     void CallVoidMethodV(jobject obj, jmethodID methodID,
1063                          va_list args) {
1064         functions->CallVoidMethodV(this,obj,methodID,args);
1065     }
1066     void CallVoidMethodA(jobject obj, jmethodID methodID,
1067                          const jvalue * args) {
1068         functions->CallVoidMethodA(this,obj,methodID,args);
1069     }
1070 
1071     jobject CallNonvirtualObjectMethod(jobject obj, jclass clazz,
1072                                        jmethodID methodID, ...) {
1073         va_list args;
1074         jobject result;
1075         va_start(args,methodID);
1076         result = functions->CallNonvirtualObjectMethodV(this,obj,clazz,
1077                                                         methodID,args);
1078         va_end(args);
1079         return result;
1080     }
1081     jobject CallNonvirtualObjectMethodV(jobject obj, jclass clazz,
1082                                         jmethodID methodID, va_list args) {
1083         return functions->CallNonvirtualObjectMethodV(this,obj,clazz,
1084                                                       methodID,args);
1085     }
1086     jobject CallNonvirtualObjectMethodA(jobject obj, jclass clazz,
1087                                         jmethodID methodID, const jvalue * args) {
1088         return functions->CallNonvirtualObjectMethodA(this,obj,clazz,
1089                                                       methodID,args);
1090     }
1091 
1092     jboolean CallNonvirtualBooleanMethod(jobject obj, jclass clazz,
1093                                          jmethodID methodID, ...) {
1094         va_list args;
1095         jboolean result;
1096         va_start(args,methodID);
1097         result = functions->CallNonvirtualBooleanMethodV(this,obj,clazz,
1098                                                          methodID,args);
1099         va_end(args);
1100         return result;
1101     }
1102     jboolean CallNonvirtualBooleanMethodV(jobject obj, jclass clazz,
1103                                           jmethodID methodID, va_list args) {
1104         return functions->CallNonvirtualBooleanMethodV(this,obj,clazz,
1105                                                        methodID,args);
1106     }
1107     jboolean CallNonvirtualBooleanMethodA(jobject obj, jclass clazz,
1108                                           jmethodID methodID, const jvalue * args) {
1109         return functions->CallNonvirtualBooleanMethodA(this,obj,clazz,
1110                                                        methodID, args);
1111     }
1112 
1113     jbyte CallNonvirtualByteMethod(jobject obj, jclass clazz,
1114                                    jmethodID methodID, ...) {
1115         va_list args;
1116         jbyte result;
1117         va_start(args,methodID);
1118         result = functions->CallNonvirtualByteMethodV(this,obj,clazz,
1119                                                       methodID,args);
1120         va_end(args);
1121         return result;
1122     }
1123     jbyte CallNonvirtualByteMethodV(jobject obj, jclass clazz,
1124                                     jmethodID methodID, va_list args) {
1125         return functions->CallNonvirtualByteMethodV(this,obj,clazz,
1126                                                     methodID,args);
1127     }
1128     jbyte CallNonvirtualByteMethodA(jobject obj, jclass clazz,
1129                                     jmethodID methodID, const jvalue * args) {
1130         return functions->CallNonvirtualByteMethodA(this,obj,clazz,
1131                                                     methodID,args);
1132     }
1133 
1134     jchar CallNonvirtualCharMethod(jobject obj, jclass clazz,
1135                                    jmethodID methodID, ...) {
1136         va_list args;
1137         jchar result;
1138         va_start(args,methodID);
1139         result = functions->CallNonvirtualCharMethodV(this,obj,clazz,
1140                                                       methodID,args);
1141         va_end(args);
1142         return result;
1143     }
1144     jchar CallNonvirtualCharMethodV(jobject obj, jclass clazz,
1145                                     jmethodID methodID, va_list args) {
1146         return functions->CallNonvirtualCharMethodV(this,obj,clazz,
1147                                                     methodID,args);
1148     }
1149     jchar CallNonvirtualCharMethodA(jobject obj, jclass clazz,
1150                                     jmethodID methodID, const jvalue * args) {
1151         return functions->CallNonvirtualCharMethodA(this,obj,clazz,
1152                                                     methodID,args);
1153     }
1154 
1155     jshort CallNonvirtualShortMethod(jobject obj, jclass clazz,
1156                                      jmethodID methodID, ...) {
1157         va_list args;
1158         jshort result;
1159         va_start(args,methodID);
1160         result = functions->CallNonvirtualShortMethodV(this,obj,clazz,
1161                                                        methodID,args);
1162         va_end(args);
1163         return result;
1164     }
1165     jshort CallNonvirtualShortMethodV(jobject obj, jclass clazz,
1166                                       jmethodID methodID, va_list args) {
1167         return functions->CallNonvirtualShortMethodV(this,obj,clazz,
1168                                                      methodID,args);
1169     }
1170     jshort CallNonvirtualShortMethodA(jobject obj, jclass clazz,
1171                                       jmethodID methodID, const jvalue * args) {
1172         return functions->CallNonvirtualShortMethodA(this,obj,clazz,
1173                                                      methodID,args);
1174     }
1175 
1176     jint CallNonvirtualIntMethod(jobject obj, jclass clazz,
1177                                  jmethodID methodID, ...) {
1178         va_list args;
1179         jint result;
1180         va_start(args,methodID);
1181         result = functions->CallNonvirtualIntMethodV(this,obj,clazz,
1182                                                      methodID,args);
1183         va_end(args);
1184         return result;
1185     }
1186     jint CallNonvirtualIntMethodV(jobject obj, jclass clazz,
1187                                   jmethodID methodID, va_list args) {
1188         return functions->CallNonvirtualIntMethodV(this,obj,clazz,
1189                                                    methodID,args);
1190     }
1191     jint CallNonvirtualIntMethodA(jobject obj, jclass clazz,
1192                                   jmethodID methodID, const jvalue * args) {
1193         return functions->CallNonvirtualIntMethodA(this,obj,clazz,
1194                                                    methodID,args);
1195     }
1196 
1197     jlong CallNonvirtualLongMethod(jobject obj, jclass clazz,
1198                                    jmethodID methodID, ...) {
1199         va_list args;
1200         jlong result;
1201         va_start(args,methodID);
1202         result = functions->CallNonvirtualLongMethodV(this,obj,clazz,
1203                                                       methodID,args);
1204         va_end(args);
1205         return result;
1206     }
1207     jlong CallNonvirtualLongMethodV(jobject obj, jclass clazz,
1208                                     jmethodID methodID, va_list args) {
1209         return functions->CallNonvirtualLongMethodV(this,obj,clazz,
1210                                                     methodID,args);
1211     }
1212     jlong CallNonvirtualLongMethodA(jobject obj, jclass clazz,
1213                                     jmethodID methodID, const jvalue * args) {
1214         return functions->CallNonvirtualLongMethodA(this,obj,clazz,
1215                                                     methodID,args);
1216     }
1217 
1218     jfloat CallNonvirtualFloatMethod(jobject obj, jclass clazz,
1219                                      jmethodID methodID, ...) {
1220         va_list args;
1221         jfloat result;
1222         va_start(args,methodID);
1223         result = functions->CallNonvirtualFloatMethodV(this,obj,clazz,
1224                                                        methodID,args);
1225         va_end(args);
1226         return result;
1227     }
1228     jfloat CallNonvirtualFloatMethodV(jobject obj, jclass clazz,
1229                                       jmethodID methodID,
1230                                       va_list args) {
1231         return functions->CallNonvirtualFloatMethodV(this,obj,clazz,
1232                                                      methodID,args);
1233     }
1234     jfloat CallNonvirtualFloatMethodA(jobject obj, jclass clazz,
1235                                       jmethodID methodID,
1236                                       const jvalue * args) {
1237         return functions->CallNonvirtualFloatMethodA(this,obj,clazz,
1238                                                      methodID,args);
1239     }
1240 
1241     jdouble CallNonvirtualDoubleMethod(jobject obj, jclass clazz,
1242                                        jmethodID methodID, ...) {
1243         va_list args;
1244         jdouble result;
1245         va_start(args,methodID);
1246         result = functions->CallNonvirtualDoubleMethodV(this,obj,clazz,
1247                                                         methodID,args);
1248         va_end(args);
1249         return result;
1250     }
1251     jdouble CallNonvirtualDoubleMethodV(jobject obj, jclass clazz,
1252                                         jmethodID methodID,
1253                                         va_list args) {
1254         return functions->CallNonvirtualDoubleMethodV(this,obj,clazz,
1255                                                       methodID,args);
1256     }
1257     jdouble CallNonvirtualDoubleMethodA(jobject obj, jclass clazz,
1258                                         jmethodID methodID,
1259                                         const jvalue * args) {
1260         return functions->CallNonvirtualDoubleMethodA(this,obj,clazz,
1261                                                       methodID,args);
1262     }
1263 
1264     void CallNonvirtualVoidMethod(jobject obj, jclass clazz,
1265                                   jmethodID methodID, ...) {
1266         va_list args;
1267         va_start(args,methodID);
1268         functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);
1269         va_end(args);
1270     }
1271     void CallNonvirtualVoidMethodV(jobject obj, jclass clazz,
1272                                    jmethodID methodID,
1273                                    va_list args) {
1274         functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);
1275     }
1276     void CallNonvirtualVoidMethodA(jobject obj, jclass clazz,
1277                                    jmethodID methodID,
1278                                    const jvalue * args) {
1279         functions->CallNonvirtualVoidMethodA(this,obj,clazz,methodID,args);
1280     }
1281 
1282     jfieldID GetFieldID(jclass clazz, const char *name,
1283                         const char *sig) {
1284         return functions->GetFieldID(this,clazz,name,sig);
1285     }
1286 
1287     jobject GetObjectField(jobject obj, jfieldID fieldID) {
1288         return functions->GetObjectField(this,obj,fieldID);
1289     }
1290     jboolean GetBooleanField(jobject obj, jfieldID fieldID) {
1291         return functions->GetBooleanField(this,obj,fieldID);
1292     }
1293     jbyte GetByteField(jobject obj, jfieldID fieldID) {
1294         return functions->GetByteField(this,obj,fieldID);
1295     }
1296     jchar GetCharField(jobject obj, jfieldID fieldID) {
1297         return functions->GetCharField(this,obj,fieldID);
1298     }
1299     jshort GetShortField(jobject obj, jfieldID fieldID) {
1300         return functions->GetShortField(this,obj,fieldID);
1301     }
1302     jint GetIntField(jobject obj, jfieldID fieldID) {
1303         return functions->GetIntField(this,obj,fieldID);
1304     }
1305     jlong GetLongField(jobject obj, jfieldID fieldID) {
1306         return functions->GetLongField(this,obj,fieldID);
1307     }
1308     jfloat GetFloatField(jobject obj, jfieldID fieldID) {
1309         return functions->GetFloatField(this,obj,fieldID);
1310     }
1311     jdouble GetDoubleField(jobject obj, jfieldID fieldID) {
1312         return functions->GetDoubleField(this,obj,fieldID);
1313     }
1314 
1315     void SetObjectField(jobject obj, jfieldID fieldID, jobject val) {
1316         functions->SetObjectField(this,obj,fieldID,val);
1317     }
1318     void SetBooleanField(jobject obj, jfieldID fieldID,
1319                          jboolean val) {
1320         functions->SetBooleanField(this,obj,fieldID,val);
1321     }
1322     void SetByteField(jobject obj, jfieldID fieldID,
1323                       jbyte val) {
1324         functions->SetByteField(this,obj,fieldID,val);
1325     }
1326     void SetCharField(jobject obj, jfieldID fieldID,
1327                       jchar val) {
1328         functions->SetCharField(this,obj,fieldID,val);
1329     }
1330     void SetShortField(jobject obj, jfieldID fieldID,
1331                        jshort val) {
1332         functions->SetShortField(this,obj,fieldID,val);
1333     }
1334     void SetIntField(jobject obj, jfieldID fieldID,
1335                      jint val) {
1336         functions->SetIntField(this,obj,fieldID,val);
1337     }
1338     void SetLongField(jobject obj, jfieldID fieldID,
1339                       jlong val) {
1340         functions->SetLongField(this,obj,fieldID,val);
1341     }
1342     void SetFloatField(jobject obj, jfieldID fieldID,
1343                        jfloat val) {
1344         functions->SetFloatField(this,obj,fieldID,val);
1345     }
1346     void SetDoubleField(jobject obj, jfieldID fieldID,
1347                         jdouble val) {
1348         functions->SetDoubleField(this,obj,fieldID,val);
1349     }
1350 
1351     jmethodID GetStaticMethodID(jclass clazz, const char *name,
1352                                 const char *sig) {
1353         return functions->GetStaticMethodID(this,clazz,name,sig);
1354     }
1355 
1356     jobject CallStaticObjectMethod(jclass clazz, jmethodID methodID,
1357                              ...) {
1358         va_list args;
1359         jobject result;
1360         va_start(args,methodID);
1361         result = functions->CallStaticObjectMethodV(this,clazz,methodID,args);
1362         va_end(args);
1363         return result;
1364     }
1365     jobject CallStaticObjectMethodV(jclass clazz, jmethodID methodID,
1366                               va_list args) {
1367         return functions->CallStaticObjectMethodV(this,clazz,methodID,args);
1368     }
1369     jobject CallStaticObjectMethodA(jclass clazz, jmethodID methodID,
1370                               const jvalue *args) {
1371         return functions->CallStaticObjectMethodA(this,clazz,methodID,args);
1372     }
1373 
1374     jboolean CallStaticBooleanMethod(jclass clazz,
1375                                      jmethodID methodID, ...) {
1376         va_list args;
1377         jboolean result;
1378         va_start(args,methodID);
1379         result = functions->CallStaticBooleanMethodV(this,clazz,methodID,args);
1380         va_end(args);
1381         return result;
1382     }
1383     jboolean CallStaticBooleanMethodV(jclass clazz,
1384                                       jmethodID methodID, va_list args) {
1385         return functions->CallStaticBooleanMethodV(this,clazz,methodID,args);
1386     }
1387     jboolean CallStaticBooleanMethodA(jclass clazz,
1388                                       jmethodID methodID, const jvalue *args) {
1389         return functions->CallStaticBooleanMethodA(this,clazz,methodID,args);
1390     }
1391 
1392     jbyte CallStaticByteMethod(jclass clazz,
1393                                jmethodID methodID, ...) {
1394         va_list args;
1395         jbyte result;
1396         va_start(args,methodID);
1397         result = functions->CallStaticByteMethodV(this,clazz,methodID,args);
1398         va_end(args);
1399         return result;
1400     }
1401     jbyte CallStaticByteMethodV(jclass clazz,
1402                                 jmethodID methodID, va_list args) {
1403         return functions->CallStaticByteMethodV(this,clazz,methodID,args);
1404     }
1405     jbyte CallStaticByteMethodA(jclass clazz,
1406                                 jmethodID methodID, const jvalue *args) {
1407         return functions->CallStaticByteMethodA(this,clazz,methodID,args);
1408     }
1409 
1410     jchar CallStaticCharMethod(jclass clazz,
1411                                jmethodID methodID, ...) {
1412         va_list args;
1413         jchar result;
1414         va_start(args,methodID);
1415         result = functions->CallStaticCharMethodV(this,clazz,methodID,args);
1416         va_end(args);
1417         return result;
1418     }
1419     jchar CallStaticCharMethodV(jclass clazz,
1420                                 jmethodID methodID, va_list args) {
1421         return functions->CallStaticCharMethodV(this,clazz,methodID,args);
1422     }
1423     jchar CallStaticCharMethodA(jclass clazz,
1424                                 jmethodID methodID, const jvalue *args) {
1425         return functions->CallStaticCharMethodA(this,clazz,methodID,args);
1426     }
1427 
1428     jshort CallStaticShortMethod(jclass clazz,
1429                                  jmethodID methodID, ...) {
1430         va_list args;
1431         jshort result;
1432         va_start(args,methodID);
1433         result = functions->CallStaticShortMethodV(this,clazz,methodID,args);
1434         va_end(args);
1435         return result;
1436     }
1437     jshort CallStaticShortMethodV(jclass clazz,
1438                                   jmethodID methodID, va_list args) {
1439         return functions->CallStaticShortMethodV(this,clazz,methodID,args);
1440     }
1441     jshort CallStaticShortMethodA(jclass clazz,
1442                                   jmethodID methodID, const jvalue *args) {
1443         return functions->CallStaticShortMethodA(this,clazz,methodID,args);
1444     }
1445 
1446     jint CallStaticIntMethod(jclass clazz,
1447                              jmethodID methodID, ...) {
1448         va_list args;
1449         jint result;
1450         va_start(args,methodID);
1451         result = functions->CallStaticIntMethodV(this,clazz,methodID,args);
1452         va_end(args);
1453         return result;
1454     }
1455     jint CallStaticIntMethodV(jclass clazz,
1456                               jmethodID methodID, va_list args) {
1457         return functions->CallStaticIntMethodV(this,clazz,methodID,args);
1458     }
1459     jint CallStaticIntMethodA(jclass clazz,
1460                               jmethodID methodID, const jvalue *args) {
1461         return functions->CallStaticIntMethodA(this,clazz,methodID,args);
1462     }
1463 
1464     jlong CallStaticLongMethod(jclass clazz,
1465                                jmethodID methodID, ...) {
1466         va_list args;
1467         jlong result;
1468         va_start(args,methodID);
1469         result = functions->CallStaticLongMethodV(this,clazz,methodID,args);
1470         va_end(args);
1471         return result;
1472     }
1473     jlong CallStaticLongMethodV(jclass clazz,
1474                                 jmethodID methodID, va_list args) {
1475         return functions->CallStaticLongMethodV(this,clazz,methodID,args);
1476     }
1477     jlong CallStaticLongMethodA(jclass clazz,
1478                                 jmethodID methodID, const jvalue *args) {
1479         return functions->CallStaticLongMethodA(this,clazz,methodID,args);
1480     }
1481 
1482     jfloat CallStaticFloatMethod(jclass clazz,
1483                                  jmethodID methodID, ...) {
1484         va_list args;
1485         jfloat result;
1486         va_start(args,methodID);
1487         result = functions->CallStaticFloatMethodV(this,clazz,methodID,args);
1488         va_end(args);
1489         return result;
1490     }
1491     jfloat CallStaticFloatMethodV(jclass clazz,
1492                                   jmethodID methodID, va_list args) {
1493         return functions->CallStaticFloatMethodV(this,clazz,methodID,args);
1494     }
1495     jfloat CallStaticFloatMethodA(jclass clazz,
1496                                   jmethodID methodID, const jvalue *args) {
1497         return functions->CallStaticFloatMethodA(this,clazz,methodID,args);
1498     }
1499 
1500     jdouble CallStaticDoubleMethod(jclass clazz,
1501                                    jmethodID methodID, ...) {
1502         va_list args;
1503         jdouble result;
1504         va_start(args,methodID);
1505         result = functions->CallStaticDoubleMethodV(this,clazz,methodID,args);
1506         va_end(args);
1507         return result;
1508     }
1509     jdouble CallStaticDoubleMethodV(jclass clazz,
1510                                     jmethodID methodID, va_list args) {
1511         return functions->CallStaticDoubleMethodV(this,clazz,methodID,args);
1512     }
1513     jdouble CallStaticDoubleMethodA(jclass clazz,
1514                                     jmethodID methodID, const jvalue *args) {
1515         return functions->CallStaticDoubleMethodA(this,clazz,methodID,args);
1516     }
1517 
1518     void CallStaticVoidMethod(jclass cls, jmethodID methodID, ...) {
1519         va_list args;
1520         va_start(args,methodID);
1521         functions->CallStaticVoidMethodV(this,cls,methodID,args);
1522         va_end(args);
1523     }
1524     void CallStaticVoidMethodV(jclass cls, jmethodID methodID,
1525                                va_list args) {
1526         functions->CallStaticVoidMethodV(this,cls,methodID,args);
1527     }
1528     void CallStaticVoidMethodA(jclass cls, jmethodID methodID,
1529                                const jvalue * args) {
1530         functions->CallStaticVoidMethodA(this,cls,methodID,args);
1531     }
1532 
1533     jfieldID GetStaticFieldID(jclass clazz, const char *name,
1534                               const char *sig) {
1535         return functions->GetStaticFieldID(this,clazz,name,sig);
1536     }
1537     jobject GetStaticObjectField(jclass clazz, jfieldID fieldID) {
1538         return functions->GetStaticObjectField(this,clazz,fieldID);
1539     }
1540     jboolean GetStaticBooleanField(jclass clazz, jfieldID fieldID) {
1541         return functions->GetStaticBooleanField(this,clazz,fieldID);
1542     }
1543     jbyte GetStaticByteField(jclass clazz, jfieldID fieldID) {
1544         return functions->GetStaticByteField(this,clazz,fieldID);
1545     }
1546     jchar GetStaticCharField(jclass clazz, jfieldID fieldID) {
1547         return functions->GetStaticCharField(this,clazz,fieldID);
1548     }
1549     jshort GetStaticShortField(jclass clazz, jfieldID fieldID) {
1550         return functions->GetStaticShortField(this,clazz,fieldID);
1551     }
1552     jint GetStaticIntField(jclass clazz, jfieldID fieldID) {
1553         return functions->GetStaticIntField(this,clazz,fieldID);
1554     }
1555     jlong GetStaticLongField(jclass clazz, jfieldID fieldID) {
1556         return functions->GetStaticLongField(this,clazz,fieldID);
1557     }
1558     jfloat GetStaticFloatField(jclass clazz, jfieldID fieldID) {
1559         return functions->GetStaticFloatField(this,clazz,fieldID);
1560     }
1561     jdouble GetStaticDoubleField(jclass clazz, jfieldID fieldID) {
1562         return functions->GetStaticDoubleField(this,clazz,fieldID);
1563     }
1564 
1565     void SetStaticObjectField(jclass clazz, jfieldID fieldID,
1566                         jobject value) {
1567       functions->SetStaticObjectField(this,clazz,fieldID,value);
1568     }
1569     void SetStaticBooleanField(jclass clazz, jfieldID fieldID,
1570                         jboolean value) {
1571       functions->SetStaticBooleanField(this,clazz,fieldID,value);
1572     }
1573     void SetStaticByteField(jclass clazz, jfieldID fieldID,
1574                         jbyte value) {
1575       functions->SetStaticByteField(this,clazz,fieldID,value);
1576     }
1577     void SetStaticCharField(jclass clazz, jfieldID fieldID,
1578                         jchar value) {
1579       functions->SetStaticCharField(this,clazz,fieldID,value);
1580     }
1581     void SetStaticShortField(jclass clazz, jfieldID fieldID,
1582                         jshort value) {
1583       functions->SetStaticShortField(this,clazz,fieldID,value);
1584     }
1585     void SetStaticIntField(jclass clazz, jfieldID fieldID,
1586                         jint value) {
1587       functions->SetStaticIntField(this,clazz,fieldID,value);
1588     }
1589     void SetStaticLongField(jclass clazz, jfieldID fieldID,
1590                         jlong value) {
1591       functions->SetStaticLongField(this,clazz,fieldID,value);
1592     }
1593     void SetStaticFloatField(jclass clazz, jfieldID fieldID,
1594                         jfloat value) {
1595       functions->SetStaticFloatField(this,clazz,fieldID,value);
1596     }
1597     void SetStaticDoubleField(jclass clazz, jfieldID fieldID,
1598                         jdouble value) {
1599       functions->SetStaticDoubleField(this,clazz,fieldID,value);
1600     }
1601 
1602     jstring NewString(const jchar *unicode, jsize len) {
1603         return functions->NewString(this,unicode,len);
1604     }
1605     jsize GetStringLength(jstring str) {
1606         return functions->GetStringLength(this,str);
1607     }
1608     const jchar *GetStringChars(jstring str, jboolean *isCopy) {
1609         return functions->GetStringChars(this,str,isCopy);
1610     }
1611     void ReleaseStringChars(jstring str, const jchar *chars) {
1612         functions->ReleaseStringChars(this,str,chars);
1613     }
1614 
1615     jstring NewStringUTF(const char *utf) {
1616         return functions->NewStringUTF(this,utf);
1617     }
1618     jsize GetStringUTFLength(jstring str) {
1619         return functions->GetStringUTFLength(this,str);
1620     }
1621     const char* GetStringUTFChars(jstring str, jboolean *isCopy) {
1622         return functions->GetStringUTFChars(this,str,isCopy);
1623     }
1624     void ReleaseStringUTFChars(jstring str, const char* chars) {
1625         functions->ReleaseStringUTFChars(this,str,chars);
1626     }
1627 
1628     jsize GetArrayLength(jarray array) {
1629         return functions->GetArrayLength(this,array);
1630     }
1631 
1632     jobjectArray NewObjectArray(jsize len, jclass clazz,
1633                                 jobject init) {
1634         return functions->NewObjectArray(this,len,clazz,init);
1635     }
1636     jobject GetObjectArrayElement(jobjectArray array, jsize index) {
1637         return functions->GetObjectArrayElement(this,array,index);
1638     }
1639     void SetObjectArrayElement(jobjectArray array, jsize index,
1640                                jobject val) {
1641         functions->SetObjectArrayElement(this,array,index,val);
1642     }
1643 
1644     jbooleanArray NewBooleanArray(jsize len) {
1645         return functions->NewBooleanArray(this,len);
1646     }
1647     jbyteArray NewByteArray(jsize len) {
1648         return functions->NewByteArray(this,len);
1649     }
1650     jcharArray NewCharArray(jsize len) {
1651         return functions->NewCharArray(this,len);
1652     }
1653     jshortArray NewShortArray(jsize len) {
1654         return functions->NewShortArray(this,len);
1655     }
1656     jintArray NewIntArray(jsize len) {
1657         return functions->NewIntArray(this,len);
1658     }
1659     jlongArray NewLongArray(jsize len) {
1660         return functions->NewLongArray(this,len);
1661     }
1662     jfloatArray NewFloatArray(jsize len) {
1663         return functions->NewFloatArray(this,len);
1664     }
1665     jdoubleArray NewDoubleArray(jsize len) {
1666         return functions->NewDoubleArray(this,len);
1667     }
1668 
1669     jboolean * GetBooleanArrayElements(jbooleanArray array, jboolean *isCopy) {
1670         return functions->GetBooleanArrayElements(this,array,isCopy);
1671     }
1672     jbyte * GetByteArrayElements(jbyteArray array, jboolean *isCopy) {
1673         return functions->GetByteArrayElements(this,array,isCopy);
1674     }
1675     jchar * GetCharArrayElements(jcharArray array, jboolean *isCopy) {
1676         return functions->GetCharArrayElements(this,array,isCopy);
1677     }
1678     jshort * GetShortArrayElements(jshortArray array, jboolean *isCopy) {
1679         return functions->GetShortArrayElements(this,array,isCopy);
1680     }
1681     jint * GetIntArrayElements(jintArray array, jboolean *isCopy) {
1682         return functions->GetIntArrayElements(this,array,isCopy);
1683     }
1684     jlong * GetLongArrayElements(jlongArray array, jboolean *isCopy) {
1685         return functions->GetLongArrayElements(this,array,isCopy);
1686     }
1687     jfloat * GetFloatArrayElements(jfloatArray array, jboolean *isCopy) {
1688         return functions->GetFloatArrayElements(this,array,isCopy);
1689     }
1690     jdouble * GetDoubleArrayElements(jdoubleArray array, jboolean *isCopy) {
1691         return functions->GetDoubleArrayElements(this,array,isCopy);
1692     }
1693 
1694     void ReleaseBooleanArrayElements(jbooleanArray array,
1695                                      jboolean *elems,
1696                                      jint mode) {
1697         functions->ReleaseBooleanArrayElements(this,array,elems,mode);
1698     }
1699     void ReleaseByteArrayElements(jbyteArray array,
1700                                   jbyte *elems,
1701                                   jint mode) {
1702         functions->ReleaseByteArrayElements(this,array,elems,mode);
1703     }
1704     void ReleaseCharArrayElements(jcharArray array,
1705                                   jchar *elems,
1706                                   jint mode) {
1707         functions->ReleaseCharArrayElements(this,array,elems,mode);
1708     }
1709     void ReleaseShortArrayElements(jshortArray array,
1710                                    jshort *elems,
1711                                    jint mode) {
1712         functions->ReleaseShortArrayElements(this,array,elems,mode);
1713     }
1714     void ReleaseIntArrayElements(jintArray array,
1715                                  jint *elems,
1716                                  jint mode) {
1717         functions->ReleaseIntArrayElements(this,array,elems,mode);
1718     }
1719     void ReleaseLongArrayElements(jlongArray array,
1720                                   jlong *elems,
1721                                   jint mode) {
1722         functions->ReleaseLongArrayElements(this,array,elems,mode);
1723     }
1724     void ReleaseFloatArrayElements(jfloatArray array,
1725                                    jfloat *elems,
1726                                    jint mode) {
1727         functions->ReleaseFloatArrayElements(this,array,elems,mode);
1728     }
1729     void ReleaseDoubleArrayElements(jdoubleArray array,
1730                                     jdouble *elems,
1731                                     jint mode) {
1732         functions->ReleaseDoubleArrayElements(this,array,elems,mode);
1733     }
1734 
1735     void GetBooleanArrayRegion(jbooleanArray array,
1736                                jsize start, jsize len, jboolean *buf) {
1737         functions->GetBooleanArrayRegion(this,array,start,len,buf);
1738     }
1739     void GetByteArrayRegion(jbyteArray array,
1740                             jsize start, jsize len, jbyte *buf) {
1741         functions->GetByteArrayRegion(this,array,start,len,buf);
1742     }
1743     void GetCharArrayRegion(jcharArray array,
1744                             jsize start, jsize len, jchar *buf) {
1745         functions->GetCharArrayRegion(this,array,start,len,buf);
1746     }
1747     void GetShortArrayRegion(jshortArray array,
1748                              jsize start, jsize len, jshort *buf) {
1749         functions->GetShortArrayRegion(this,array,start,len,buf);
1750     }
1751     void GetIntArrayRegion(jintArray array,
1752                            jsize start, jsize len, jint *buf) {
1753         functions->GetIntArrayRegion(this,array,start,len,buf);
1754     }
1755     void GetLongArrayRegion(jlongArray array,
1756                             jsize start, jsize len, jlong *buf) {
1757         functions->GetLongArrayRegion(this,array,start,len,buf);
1758     }
1759     void GetFloatArrayRegion(jfloatArray array,
1760                              jsize start, jsize len, jfloat *buf) {
1761         functions->GetFloatArrayRegion(this,array,start,len,buf);
1762     }
1763     void GetDoubleArrayRegion(jdoubleArray array,
1764                               jsize start, jsize len, jdouble *buf) {
1765         functions->GetDoubleArrayRegion(this,array,start,len,buf);
1766     }
1767 
1768     void SetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len,
1769                                const jboolean *buf) {
1770         functions->SetBooleanArrayRegion(this,array,start,len,buf);
1771     }
1772     void SetByteArrayRegion(jbyteArray array, jsize start, jsize len,
1773                             const jbyte *buf) {
1774         functions->SetByteArrayRegion(this,array,start,len,buf);
1775     }
1776     void SetCharArrayRegion(jcharArray array, jsize start, jsize len,
1777                             const jchar *buf) {
1778         functions->SetCharArrayRegion(this,array,start,len,buf);
1779     }
1780     void SetShortArrayRegion(jshortArray array, jsize start, jsize len,
1781                              const jshort *buf) {
1782         functions->SetShortArrayRegion(this,array,start,len,buf);
1783     }
1784     void SetIntArrayRegion(jintArray array, jsize start, jsize len,
1785                            const jint *buf) {
1786         functions->SetIntArrayRegion(this,array,start,len,buf);
1787     }
1788     void SetLongArrayRegion(jlongArray array, jsize start, jsize len,
1789                             const jlong *buf) {
1790         functions->SetLongArrayRegion(this,array,start,len,buf);
1791     }
1792     void SetFloatArrayRegion(jfloatArray array, jsize start, jsize len,
1793                              const jfloat *buf) {
1794         functions->SetFloatArrayRegion(this,array,start,len,buf);
1795     }
1796     void SetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len,
1797                               const jdouble *buf) {
1798         functions->SetDoubleArrayRegion(this,array,start,len,buf);
1799     }
1800 
1801     jint RegisterNatives(jclass clazz, const JNINativeMethod *methods,
1802                          jint nMethods) {
1803         return functions->RegisterNatives(this,clazz,methods,nMethods);
1804     }
1805     jint UnregisterNatives(jclass clazz) {
1806         return functions->UnregisterNatives(this,clazz);
1807     }
1808 
1809     jint MonitorEnter(jobject obj) {
1810         return functions->MonitorEnter(this,obj);
1811     }
1812     jint MonitorExit(jobject obj) {
1813         return functions->MonitorExit(this,obj);
1814     }
1815 
1816     jint GetJavaVM(JavaVM **vm) {
1817         return functions->GetJavaVM(this,vm);
1818     }
1819 
1820     void GetStringRegion(jstring str, jsize start, jsize len, jchar *buf) {
1821         functions->GetStringRegion(this,str,start,len,buf);
1822     }
1823     void GetStringUTFRegion(jstring str, jsize start, jsize len, char *buf) {
1824         functions->GetStringUTFRegion(this,str,start,len,buf);
1825     }
1826 
1827     void * GetPrimitiveArrayCritical(jarray array, jboolean *isCopy) {
1828         return functions->GetPrimitiveArrayCritical(this,array,isCopy);
1829     }
1830     void ReleasePrimitiveArrayCritical(jarray array, void *carray, jint mode) {
1831         functions->ReleasePrimitiveArrayCritical(this,array,carray,mode);
1832     }
1833 
1834     const jchar * GetStringCritical(jstring string, jboolean *isCopy) {
1835         return functions->GetStringCritical(this,string,isCopy);
1836     }
1837     void ReleaseStringCritical(jstring string, const jchar *cstring) {
1838         functions->ReleaseStringCritical(this,string,cstring);
1839     }
1840 
1841     jweak NewWeakGlobalRef(jobject obj) {
1842         return functions->NewWeakGlobalRef(this,obj);
1843     }
1844     void DeleteWeakGlobalRef(jweak ref) {
1845         functions->DeleteWeakGlobalRef(this,ref);
1846     }
1847 
1848     jboolean ExceptionCheck() {
1849         return functions->ExceptionCheck(this);
1850     }
1851 
1852     jobject NewDirectByteBuffer(void* address, jlong capacity) {
1853         return functions->NewDirectByteBuffer(this, address, capacity);
1854     }
1855     void* GetDirectBufferAddress(jobject buf) {
1856         return functions->GetDirectBufferAddress(this, buf);
1857     }
1858     jlong GetDirectBufferCapacity(jobject buf) {
1859         return functions->GetDirectBufferCapacity(this, buf);
1860     }
1861     jobjectRefType GetObjectRefType(jobject obj) {
1862         return functions->GetObjectRefType(this, obj);
1863     }
1864 
1865     /* Module Features */
1866 
1867     jobject GetModule(jclass clazz) {
1868         return functions->GetModule(this, clazz);
1869     }
1870 
1871 #endif /* __cplusplus */
1872 };
1873 
1874 /*
1875  * optionString may be any option accepted by the JVM, or one of the
1876  * following:
1877  *
1878  * -D<name>=<value>          Set a system property.
1879  * -verbose[:class|gc|jni]   Enable verbose output, comma-separated. E.g.
1880  *                           "-verbose:class" or "-verbose:gc,class"
1881  *                           Standard names include: gc, class, and jni.
1882  *                           All nonstandard (VM-specific) names must begin
1883  *                           with "X".
1884  * vfprintf                  extraInfo is a pointer to the vfprintf hook.
1885  * exit                      extraInfo is a pointer to the exit hook.
1886  * abort                     extraInfo is a pointer to the abort hook.
1887  */
1888 typedef struct JavaVMOption {
1889     char *optionString;
1890     void *extraInfo;
1891 } JavaVMOption;
1892 
1893 typedef struct JavaVMInitArgs {
1894     jint version;
1895 
1896     jint nOptions;
1897     JavaVMOption *options;
1898     jboolean ignoreUnrecognized;
1899 } JavaVMInitArgs;
1900 
1901 typedef struct JavaVMAttachArgs {
1902     jint version;
1903 
1904     char *name;
1905     jobject group;
1906 } JavaVMAttachArgs;
1907 
1908 /* These will be VM-specific. */
1909 
1910 #define JDK1_2
1911 #define JDK1_4
1912 
1913 /* End VM-specific. */
1914 
1915 struct JNIInvokeInterface_ {
1916     void *reserved0;
1917     void *reserved1;
1918     void *reserved2;
1919 
1920     jint (JNICALL *DestroyJavaVM)(JavaVM *vm);
1921 
1922     jint (JNICALL *AttachCurrentThread)(JavaVM *vm, void **penv, void *args);
1923 
1924     jint (JNICALL *DetachCurrentThread)(JavaVM *vm);
1925 
1926     jint (JNICALL *GetEnv)(JavaVM *vm, void **penv, jint version);
1927 
1928     jint (JNICALL *AttachCurrentThreadAsDaemon)(JavaVM *vm, void **penv, void *args);
1929 };
1930 
1931 struct JavaVM_ {
1932     const struct JNIInvokeInterface_ *functions;
1933 #ifdef __cplusplus
1934 
1935     jint DestroyJavaVM() {
1936         return functions->DestroyJavaVM(this);
1937     }
1938     jint AttachCurrentThread(void **penv, void *args) {
1939         return functions->AttachCurrentThread(this, penv, args);
1940     }
1941     jint DetachCurrentThread() {
1942         return functions->DetachCurrentThread(this);
1943     }
1944 
1945     jint GetEnv(void **penv, jint version) {
1946         return functions->GetEnv(this, penv, version);
1947     }
1948     jint AttachCurrentThreadAsDaemon(void **penv, void *args) {
1949         return functions->AttachCurrentThreadAsDaemon(this, penv, args);
1950     }
1951 #endif
1952 };
1953 
1954 #ifdef _JNI_IMPLEMENTATION_
1955 #define _JNI_IMPORT_OR_EXPORT_ JNIEXPORT
1956 #else
1957 #define _JNI_IMPORT_OR_EXPORT_ JNIIMPORT
1958 #endif
1959 _JNI_IMPORT_OR_EXPORT_ jint JNICALL
1960 JNI_GetDefaultJavaVMInitArgs(void *args);
1961 
1962 _JNI_IMPORT_OR_EXPORT_ jint JNICALL
1963 JNI_CreateJavaVM(JavaVM **pvm, void **penv, void *args);
1964 
1965 _JNI_IMPORT_OR_EXPORT_ jint JNICALL
1966 JNI_GetCreatedJavaVMs(JavaVM **, jsize, jsize *);
1967 
1968 /* Defined by native libraries. */
1969 JNIEXPORT jint JNICALL
1970 JNI_OnLoad(JavaVM *vm, void *reserved);
1971 
1972 JNIEXPORT void JNICALL
1973 JNI_OnUnload(JavaVM *vm, void *reserved);
1974 
1975 #define JNI_VERSION_1_1 0x00010001
1976 #define JNI_VERSION_1_2 0x00010002
1977 #define JNI_VERSION_1_4 0x00010004
1978 #define JNI_VERSION_1_6 0x00010006
1979 #define JNI_VERSION_1_8 0x00010008
1980 #define JNI_VERSION_9   0x00090000
1981 #define JNI_VERSION_10  0x000a0000
1982 
1983 #ifdef __cplusplus
1984 } /* extern "C" */
1985 #endif /* __cplusplus */
1986 
1987 #endif /* !_JAVASOFT_JNI_H_ */