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