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