1 /*
2  * Copyright (c) 1996, 2013, 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 
770 /*
771  * We use inlined functions for C++ so that programmers can write:
772  *
773  *    env->FindClass("java/lang/String")
774  *
775  * in C++ rather than:
776  *
777  *    (*env)->FindClass(env, "java/lang/String")
778  *
779  * in C.
780  */
781 
782 struct JNIEnv_ {
783     const struct JNINativeInterface_ *functions;
784 #ifdef __cplusplus
785 
GetVersionJNIEnv_786     jint GetVersion() {
787         return functions->GetVersion(this);
788     }
DefineClassJNIEnv_789     jclass DefineClass(const char *name, jobject loader, const jbyte *buf,
790                        jsize len) {
791         return functions->DefineClass(this, name, loader, buf, len);
792     }
FindClassJNIEnv_793     jclass FindClass(const char *name) {
794         return functions->FindClass(this, name);
795     }
FromReflectedMethodJNIEnv_796     jmethodID FromReflectedMethod(jobject method) {
797         return functions->FromReflectedMethod(this,method);
798     }
FromReflectedFieldJNIEnv_799     jfieldID FromReflectedField(jobject field) {
800         return functions->FromReflectedField(this,field);
801     }
802 
ToReflectedMethodJNIEnv_803     jobject ToReflectedMethod(jclass cls, jmethodID methodID, jboolean isStatic) {
804         return functions->ToReflectedMethod(this, cls, methodID, isStatic);
805     }
806 
GetSuperclassJNIEnv_807     jclass GetSuperclass(jclass sub) {
808         return functions->GetSuperclass(this, sub);
809     }
IsAssignableFromJNIEnv_810     jboolean IsAssignableFrom(jclass sub, jclass sup) {
811         return functions->IsAssignableFrom(this, sub, sup);
812     }
813 
ToReflectedFieldJNIEnv_814     jobject ToReflectedField(jclass cls, jfieldID fieldID, jboolean isStatic) {
815         return functions->ToReflectedField(this,cls,fieldID,isStatic);
816     }
817 
ThrowJNIEnv_818     jint Throw(jthrowable obj) {
819         return functions->Throw(this, obj);
820     }
ThrowNewJNIEnv_821     jint ThrowNew(jclass clazz, const char *msg) {
822         return functions->ThrowNew(this, clazz, msg);
823     }
ExceptionOccurredJNIEnv_824     jthrowable ExceptionOccurred() {
825         return functions->ExceptionOccurred(this);
826     }
ExceptionDescribeJNIEnv_827     void ExceptionDescribe() {
828         functions->ExceptionDescribe(this);
829     }
ExceptionClearJNIEnv_830     void ExceptionClear() {
831         functions->ExceptionClear(this);
832     }
FatalErrorJNIEnv_833     void FatalError(const char *msg) {
834         functions->FatalError(this, msg);
835     }
836 
PushLocalFrameJNIEnv_837     jint PushLocalFrame(jint capacity) {
838         return functions->PushLocalFrame(this,capacity);
839     }
PopLocalFrameJNIEnv_840     jobject PopLocalFrame(jobject result) {
841         return functions->PopLocalFrame(this,result);
842     }
843 
NewGlobalRefJNIEnv_844     jobject NewGlobalRef(jobject lobj) {
845         return functions->NewGlobalRef(this,lobj);
846     }
DeleteGlobalRefJNIEnv_847     void DeleteGlobalRef(jobject gref) {
848         functions->DeleteGlobalRef(this,gref);
849     }
DeleteLocalRefJNIEnv_850     void DeleteLocalRef(jobject obj) {
851         functions->DeleteLocalRef(this, obj);
852     }
853 
IsSameObjectJNIEnv_854     jboolean IsSameObject(jobject obj1, jobject obj2) {
855         return functions->IsSameObject(this,obj1,obj2);
856     }
857 
NewLocalRefJNIEnv_858     jobject NewLocalRef(jobject ref) {
859         return functions->NewLocalRef(this,ref);
860     }
EnsureLocalCapacityJNIEnv_861     jint EnsureLocalCapacity(jint capacity) {
862         return functions->EnsureLocalCapacity(this,capacity);
863     }
864 
AllocObjectJNIEnv_865     jobject AllocObject(jclass clazz) {
866         return functions->AllocObject(this,clazz);
867     }
NewObjectJNIEnv_868     jobject NewObject(jclass clazz, jmethodID methodID, ...) {
869         va_list args;
870         jobject result;
871         va_start(args, methodID);
872         result = functions->NewObjectV(this,clazz,methodID,args);
873         va_end(args);
874         return result;
875     }
NewObjectVJNIEnv_876     jobject NewObjectV(jclass clazz, jmethodID methodID,
877                        va_list args) {
878         return functions->NewObjectV(this,clazz,methodID,args);
879     }
NewObjectAJNIEnv_880     jobject NewObjectA(jclass clazz, jmethodID methodID,
881                        const jvalue *args) {
882         return functions->NewObjectA(this,clazz,methodID,args);
883     }
884 
GetObjectClassJNIEnv_885     jclass GetObjectClass(jobject obj) {
886         return functions->GetObjectClass(this,obj);
887     }
IsInstanceOfJNIEnv_888     jboolean IsInstanceOf(jobject obj, jclass clazz) {
889         return functions->IsInstanceOf(this,obj,clazz);
890     }
891 
GetMethodIDJNIEnv_892     jmethodID GetMethodID(jclass clazz, const char *name,
893                           const char *sig) {
894         return functions->GetMethodID(this,clazz,name,sig);
895     }
896 
CallObjectMethodJNIEnv_897     jobject CallObjectMethod(jobject obj, jmethodID methodID, ...) {
898         va_list args;
899         jobject result;
900         va_start(args,methodID);
901         result = functions->CallObjectMethodV(this,obj,methodID,args);
902         va_end(args);
903         return result;
904     }
CallObjectMethodVJNIEnv_905     jobject CallObjectMethodV(jobject obj, jmethodID methodID,
906                         va_list args) {
907         return functions->CallObjectMethodV(this,obj,methodID,args);
908     }
CallObjectMethodAJNIEnv_909     jobject CallObjectMethodA(jobject obj, jmethodID methodID,
910                         const jvalue * args) {
911         return functions->CallObjectMethodA(this,obj,methodID,args);
912     }
913 
CallBooleanMethodJNIEnv_914     jboolean CallBooleanMethod(jobject obj,
915                                jmethodID methodID, ...) {
916         va_list args;
917         jboolean result;
918         va_start(args,methodID);
919         result = functions->CallBooleanMethodV(this,obj,methodID,args);
920         va_end(args);
921         return result;
922     }
CallBooleanMethodVJNIEnv_923     jboolean CallBooleanMethodV(jobject obj, jmethodID methodID,
924                                 va_list args) {
925         return functions->CallBooleanMethodV(this,obj,methodID,args);
926     }
CallBooleanMethodAJNIEnv_927     jboolean CallBooleanMethodA(jobject obj, jmethodID methodID,
928                                 const jvalue * args) {
929         return functions->CallBooleanMethodA(this,obj,methodID, args);
930     }
931 
CallByteMethodJNIEnv_932     jbyte CallByteMethod(jobject obj, jmethodID methodID, ...) {
933         va_list args;
934         jbyte result;
935         va_start(args,methodID);
936         result = functions->CallByteMethodV(this,obj,methodID,args);
937         va_end(args);
938         return result;
939     }
CallByteMethodVJNIEnv_940     jbyte CallByteMethodV(jobject obj, jmethodID methodID,
941                           va_list args) {
942         return functions->CallByteMethodV(this,obj,methodID,args);
943     }
CallByteMethodAJNIEnv_944     jbyte CallByteMethodA(jobject obj, jmethodID methodID,
945                           const jvalue * args) {
946         return functions->CallByteMethodA(this,obj,methodID,args);
947     }
948 
CallCharMethodJNIEnv_949     jchar CallCharMethod(jobject obj, jmethodID methodID, ...) {
950         va_list args;
951         jchar result;
952         va_start(args,methodID);
953         result = functions->CallCharMethodV(this,obj,methodID,args);
954         va_end(args);
955         return result;
956     }
CallCharMethodVJNIEnv_957     jchar CallCharMethodV(jobject obj, jmethodID methodID,
958                           va_list args) {
959         return functions->CallCharMethodV(this,obj,methodID,args);
960     }
CallCharMethodAJNIEnv_961     jchar CallCharMethodA(jobject obj, jmethodID methodID,
962                           const jvalue * args) {
963         return functions->CallCharMethodA(this,obj,methodID,args);
964     }
965 
CallShortMethodJNIEnv_966     jshort CallShortMethod(jobject obj, jmethodID methodID, ...) {
967         va_list args;
968         jshort result;
969         va_start(args,methodID);
970         result = functions->CallShortMethodV(this,obj,methodID,args);
971         va_end(args);
972         return result;
973     }
CallShortMethodVJNIEnv_974     jshort CallShortMethodV(jobject obj, jmethodID methodID,
975                             va_list args) {
976         return functions->CallShortMethodV(this,obj,methodID,args);
977     }
CallShortMethodAJNIEnv_978     jshort CallShortMethodA(jobject obj, jmethodID methodID,
979                             const jvalue * args) {
980         return functions->CallShortMethodA(this,obj,methodID,args);
981     }
982 
CallIntMethodJNIEnv_983     jint CallIntMethod(jobject obj, jmethodID methodID, ...) {
984         va_list args;
985         jint result;
986         va_start(args,methodID);
987         result = functions->CallIntMethodV(this,obj,methodID,args);
988         va_end(args);
989         return result;
990     }
CallIntMethodVJNIEnv_991     jint CallIntMethodV(jobject obj, jmethodID methodID,
992                         va_list args) {
993         return functions->CallIntMethodV(this,obj,methodID,args);
994     }
CallIntMethodAJNIEnv_995     jint CallIntMethodA(jobject obj, jmethodID methodID,
996                         const jvalue * args) {
997         return functions->CallIntMethodA(this,obj,methodID,args);
998     }
999 
CallLongMethodJNIEnv_1000     jlong CallLongMethod(jobject obj, jmethodID methodID, ...) {
1001         va_list args;
1002         jlong result;
1003         va_start(args,methodID);
1004         result = functions->CallLongMethodV(this,obj,methodID,args);
1005         va_end(args);
1006         return result;
1007     }
CallLongMethodVJNIEnv_1008     jlong CallLongMethodV(jobject obj, jmethodID methodID,
1009                           va_list args) {
1010         return functions->CallLongMethodV(this,obj,methodID,args);
1011     }
CallLongMethodAJNIEnv_1012     jlong CallLongMethodA(jobject obj, jmethodID methodID,
1013                           const jvalue * args) {
1014         return functions->CallLongMethodA(this,obj,methodID,args);
1015     }
1016 
CallFloatMethodJNIEnv_1017     jfloat CallFloatMethod(jobject obj, jmethodID methodID, ...) {
1018         va_list args;
1019         jfloat result;
1020         va_start(args,methodID);
1021         result = functions->CallFloatMethodV(this,obj,methodID,args);
1022         va_end(args);
1023         return result;
1024     }
CallFloatMethodVJNIEnv_1025     jfloat CallFloatMethodV(jobject obj, jmethodID methodID,
1026                             va_list args) {
1027         return functions->CallFloatMethodV(this,obj,methodID,args);
1028     }
CallFloatMethodAJNIEnv_1029     jfloat CallFloatMethodA(jobject obj, jmethodID methodID,
1030                             const jvalue * args) {
1031         return functions->CallFloatMethodA(this,obj,methodID,args);
1032     }
1033 
CallDoubleMethodJNIEnv_1034     jdouble CallDoubleMethod(jobject obj, jmethodID methodID, ...) {
1035         va_list args;
1036         jdouble result;
1037         va_start(args,methodID);
1038         result = functions->CallDoubleMethodV(this,obj,methodID,args);
1039         va_end(args);
1040         return result;
1041     }
CallDoubleMethodVJNIEnv_1042     jdouble CallDoubleMethodV(jobject obj, jmethodID methodID,
1043                         va_list args) {
1044         return functions->CallDoubleMethodV(this,obj,methodID,args);
1045     }
CallDoubleMethodAJNIEnv_1046     jdouble CallDoubleMethodA(jobject obj, jmethodID methodID,
1047                         const jvalue * args) {
1048         return functions->CallDoubleMethodA(this,obj,methodID,args);
1049     }
1050 
CallVoidMethodJNIEnv_1051     void CallVoidMethod(jobject obj, jmethodID methodID, ...) {
1052         va_list args;
1053         va_start(args,methodID);
1054         functions->CallVoidMethodV(this,obj,methodID,args);
1055         va_end(args);
1056     }
CallVoidMethodVJNIEnv_1057     void CallVoidMethodV(jobject obj, jmethodID methodID,
1058                          va_list args) {
1059         functions->CallVoidMethodV(this,obj,methodID,args);
1060     }
CallVoidMethodAJNIEnv_1061     void CallVoidMethodA(jobject obj, jmethodID methodID,
1062                          const jvalue * args) {
1063         functions->CallVoidMethodA(this,obj,methodID,args);
1064     }
1065 
CallNonvirtualObjectMethodJNIEnv_1066     jobject CallNonvirtualObjectMethod(jobject obj, jclass clazz,
1067                                        jmethodID methodID, ...) {
1068         va_list args;
1069         jobject result;
1070         va_start(args,methodID);
1071         result = functions->CallNonvirtualObjectMethodV(this,obj,clazz,
1072                                                         methodID,args);
1073         va_end(args);
1074         return result;
1075     }
CallNonvirtualObjectMethodVJNIEnv_1076     jobject CallNonvirtualObjectMethodV(jobject obj, jclass clazz,
1077                                         jmethodID methodID, va_list args) {
1078         return functions->CallNonvirtualObjectMethodV(this,obj,clazz,
1079                                                       methodID,args);
1080     }
CallNonvirtualObjectMethodAJNIEnv_1081     jobject CallNonvirtualObjectMethodA(jobject obj, jclass clazz,
1082                                         jmethodID methodID, const jvalue * args) {
1083         return functions->CallNonvirtualObjectMethodA(this,obj,clazz,
1084                                                       methodID,args);
1085     }
1086 
CallNonvirtualBooleanMethodJNIEnv_1087     jboolean CallNonvirtualBooleanMethod(jobject obj, jclass clazz,
1088                                          jmethodID methodID, ...) {
1089         va_list args;
1090         jboolean result;
1091         va_start(args,methodID);
1092         result = functions->CallNonvirtualBooleanMethodV(this,obj,clazz,
1093                                                          methodID,args);
1094         va_end(args);
1095         return result;
1096     }
CallNonvirtualBooleanMethodVJNIEnv_1097     jboolean CallNonvirtualBooleanMethodV(jobject obj, jclass clazz,
1098                                           jmethodID methodID, va_list args) {
1099         return functions->CallNonvirtualBooleanMethodV(this,obj,clazz,
1100                                                        methodID,args);
1101     }
CallNonvirtualBooleanMethodAJNIEnv_1102     jboolean CallNonvirtualBooleanMethodA(jobject obj, jclass clazz,
1103                                           jmethodID methodID, const jvalue * args) {
1104         return functions->CallNonvirtualBooleanMethodA(this,obj,clazz,
1105                                                        methodID, args);
1106     }
1107 
CallNonvirtualByteMethodJNIEnv_1108     jbyte CallNonvirtualByteMethod(jobject obj, jclass clazz,
1109                                    jmethodID methodID, ...) {
1110         va_list args;
1111         jbyte result;
1112         va_start(args,methodID);
1113         result = functions->CallNonvirtualByteMethodV(this,obj,clazz,
1114                                                       methodID,args);
1115         va_end(args);
1116         return result;
1117     }
CallNonvirtualByteMethodVJNIEnv_1118     jbyte CallNonvirtualByteMethodV(jobject obj, jclass clazz,
1119                                     jmethodID methodID, va_list args) {
1120         return functions->CallNonvirtualByteMethodV(this,obj,clazz,
1121                                                     methodID,args);
1122     }
CallNonvirtualByteMethodAJNIEnv_1123     jbyte CallNonvirtualByteMethodA(jobject obj, jclass clazz,
1124                                     jmethodID methodID, const jvalue * args) {
1125         return functions->CallNonvirtualByteMethodA(this,obj,clazz,
1126                                                     methodID,args);
1127     }
1128 
CallNonvirtualCharMethodJNIEnv_1129     jchar CallNonvirtualCharMethod(jobject obj, jclass clazz,
1130                                    jmethodID methodID, ...) {
1131         va_list args;
1132         jchar result;
1133         va_start(args,methodID);
1134         result = functions->CallNonvirtualCharMethodV(this,obj,clazz,
1135                                                       methodID,args);
1136         va_end(args);
1137         return result;
1138     }
CallNonvirtualCharMethodVJNIEnv_1139     jchar CallNonvirtualCharMethodV(jobject obj, jclass clazz,
1140                                     jmethodID methodID, va_list args) {
1141         return functions->CallNonvirtualCharMethodV(this,obj,clazz,
1142                                                     methodID,args);
1143     }
CallNonvirtualCharMethodAJNIEnv_1144     jchar CallNonvirtualCharMethodA(jobject obj, jclass clazz,
1145                                     jmethodID methodID, const jvalue * args) {
1146         return functions->CallNonvirtualCharMethodA(this,obj,clazz,
1147                                                     methodID,args);
1148     }
1149 
CallNonvirtualShortMethodJNIEnv_1150     jshort CallNonvirtualShortMethod(jobject obj, jclass clazz,
1151                                      jmethodID methodID, ...) {
1152         va_list args;
1153         jshort result;
1154         va_start(args,methodID);
1155         result = functions->CallNonvirtualShortMethodV(this,obj,clazz,
1156                                                        methodID,args);
1157         va_end(args);
1158         return result;
1159     }
CallNonvirtualShortMethodVJNIEnv_1160     jshort CallNonvirtualShortMethodV(jobject obj, jclass clazz,
1161                                       jmethodID methodID, va_list args) {
1162         return functions->CallNonvirtualShortMethodV(this,obj,clazz,
1163                                                      methodID,args);
1164     }
CallNonvirtualShortMethodAJNIEnv_1165     jshort CallNonvirtualShortMethodA(jobject obj, jclass clazz,
1166                                       jmethodID methodID, const jvalue * args) {
1167         return functions->CallNonvirtualShortMethodA(this,obj,clazz,
1168                                                      methodID,args);
1169     }
1170 
CallNonvirtualIntMethodJNIEnv_1171     jint CallNonvirtualIntMethod(jobject obj, jclass clazz,
1172                                  jmethodID methodID, ...) {
1173         va_list args;
1174         jint result;
1175         va_start(args,methodID);
1176         result = functions->CallNonvirtualIntMethodV(this,obj,clazz,
1177                                                      methodID,args);
1178         va_end(args);
1179         return result;
1180     }
CallNonvirtualIntMethodVJNIEnv_1181     jint CallNonvirtualIntMethodV(jobject obj, jclass clazz,
1182                                   jmethodID methodID, va_list args) {
1183         return functions->CallNonvirtualIntMethodV(this,obj,clazz,
1184                                                    methodID,args);
1185     }
CallNonvirtualIntMethodAJNIEnv_1186     jint CallNonvirtualIntMethodA(jobject obj, jclass clazz,
1187                                   jmethodID methodID, const jvalue * args) {
1188         return functions->CallNonvirtualIntMethodA(this,obj,clazz,
1189                                                    methodID,args);
1190     }
1191 
CallNonvirtualLongMethodJNIEnv_1192     jlong CallNonvirtualLongMethod(jobject obj, jclass clazz,
1193                                    jmethodID methodID, ...) {
1194         va_list args;
1195         jlong result;
1196         va_start(args,methodID);
1197         result = functions->CallNonvirtualLongMethodV(this,obj,clazz,
1198                                                       methodID,args);
1199         va_end(args);
1200         return result;
1201     }
CallNonvirtualLongMethodVJNIEnv_1202     jlong CallNonvirtualLongMethodV(jobject obj, jclass clazz,
1203                                     jmethodID methodID, va_list args) {
1204         return functions->CallNonvirtualLongMethodV(this,obj,clazz,
1205                                                     methodID,args);
1206     }
CallNonvirtualLongMethodAJNIEnv_1207     jlong CallNonvirtualLongMethodA(jobject obj, jclass clazz,
1208                                     jmethodID methodID, const jvalue * args) {
1209         return functions->CallNonvirtualLongMethodA(this,obj,clazz,
1210                                                     methodID,args);
1211     }
1212 
CallNonvirtualFloatMethodJNIEnv_1213     jfloat CallNonvirtualFloatMethod(jobject obj, jclass clazz,
1214                                      jmethodID methodID, ...) {
1215         va_list args;
1216         jfloat result;
1217         va_start(args,methodID);
1218         result = functions->CallNonvirtualFloatMethodV(this,obj,clazz,
1219                                                        methodID,args);
1220         va_end(args);
1221         return result;
1222     }
CallNonvirtualFloatMethodVJNIEnv_1223     jfloat CallNonvirtualFloatMethodV(jobject obj, jclass clazz,
1224                                       jmethodID methodID,
1225                                       va_list args) {
1226         return functions->CallNonvirtualFloatMethodV(this,obj,clazz,
1227                                                      methodID,args);
1228     }
CallNonvirtualFloatMethodAJNIEnv_1229     jfloat CallNonvirtualFloatMethodA(jobject obj, jclass clazz,
1230                                       jmethodID methodID,
1231                                       const jvalue * args) {
1232         return functions->CallNonvirtualFloatMethodA(this,obj,clazz,
1233                                                      methodID,args);
1234     }
1235 
CallNonvirtualDoubleMethodJNIEnv_1236     jdouble CallNonvirtualDoubleMethod(jobject obj, jclass clazz,
1237                                        jmethodID methodID, ...) {
1238         va_list args;
1239         jdouble result;
1240         va_start(args,methodID);
1241         result = functions->CallNonvirtualDoubleMethodV(this,obj,clazz,
1242                                                         methodID,args);
1243         va_end(args);
1244         return result;
1245     }
CallNonvirtualDoubleMethodVJNIEnv_1246     jdouble CallNonvirtualDoubleMethodV(jobject obj, jclass clazz,
1247                                         jmethodID methodID,
1248                                         va_list args) {
1249         return functions->CallNonvirtualDoubleMethodV(this,obj,clazz,
1250                                                       methodID,args);
1251     }
CallNonvirtualDoubleMethodAJNIEnv_1252     jdouble CallNonvirtualDoubleMethodA(jobject obj, jclass clazz,
1253                                         jmethodID methodID,
1254                                         const jvalue * args) {
1255         return functions->CallNonvirtualDoubleMethodA(this,obj,clazz,
1256                                                       methodID,args);
1257     }
1258 
CallNonvirtualVoidMethodJNIEnv_1259     void CallNonvirtualVoidMethod(jobject obj, jclass clazz,
1260                                   jmethodID methodID, ...) {
1261         va_list args;
1262         va_start(args,methodID);
1263         functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);
1264         va_end(args);
1265     }
CallNonvirtualVoidMethodVJNIEnv_1266     void CallNonvirtualVoidMethodV(jobject obj, jclass clazz,
1267                                    jmethodID methodID,
1268                                    va_list args) {
1269         functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);
1270     }
CallNonvirtualVoidMethodAJNIEnv_1271     void CallNonvirtualVoidMethodA(jobject obj, jclass clazz,
1272                                    jmethodID methodID,
1273                                    const jvalue * args) {
1274         functions->CallNonvirtualVoidMethodA(this,obj,clazz,methodID,args);
1275     }
1276 
GetFieldIDJNIEnv_1277     jfieldID GetFieldID(jclass clazz, const char *name,
1278                         const char *sig) {
1279         return functions->GetFieldID(this,clazz,name,sig);
1280     }
1281 
GetObjectFieldJNIEnv_1282     jobject GetObjectField(jobject obj, jfieldID fieldID) {
1283         return functions->GetObjectField(this,obj,fieldID);
1284     }
GetBooleanFieldJNIEnv_1285     jboolean GetBooleanField(jobject obj, jfieldID fieldID) {
1286         return functions->GetBooleanField(this,obj,fieldID);
1287     }
GetByteFieldJNIEnv_1288     jbyte GetByteField(jobject obj, jfieldID fieldID) {
1289         return functions->GetByteField(this,obj,fieldID);
1290     }
GetCharFieldJNIEnv_1291     jchar GetCharField(jobject obj, jfieldID fieldID) {
1292         return functions->GetCharField(this,obj,fieldID);
1293     }
GetShortFieldJNIEnv_1294     jshort GetShortField(jobject obj, jfieldID fieldID) {
1295         return functions->GetShortField(this,obj,fieldID);
1296     }
GetIntFieldJNIEnv_1297     jint GetIntField(jobject obj, jfieldID fieldID) {
1298         return functions->GetIntField(this,obj,fieldID);
1299     }
GetLongFieldJNIEnv_1300     jlong GetLongField(jobject obj, jfieldID fieldID) {
1301         return functions->GetLongField(this,obj,fieldID);
1302     }
GetFloatFieldJNIEnv_1303     jfloat GetFloatField(jobject obj, jfieldID fieldID) {
1304         return functions->GetFloatField(this,obj,fieldID);
1305     }
GetDoubleFieldJNIEnv_1306     jdouble GetDoubleField(jobject obj, jfieldID fieldID) {
1307         return functions->GetDoubleField(this,obj,fieldID);
1308     }
1309 
SetObjectFieldJNIEnv_1310     void SetObjectField(jobject obj, jfieldID fieldID, jobject val) {
1311         functions->SetObjectField(this,obj,fieldID,val);
1312     }
SetBooleanFieldJNIEnv_1313     void SetBooleanField(jobject obj, jfieldID fieldID,
1314                          jboolean val) {
1315         functions->SetBooleanField(this,obj,fieldID,val);
1316     }
SetByteFieldJNIEnv_1317     void SetByteField(jobject obj, jfieldID fieldID,
1318                       jbyte val) {
1319         functions->SetByteField(this,obj,fieldID,val);
1320     }
SetCharFieldJNIEnv_1321     void SetCharField(jobject obj, jfieldID fieldID,
1322                       jchar val) {
1323         functions->SetCharField(this,obj,fieldID,val);
1324     }
SetShortFieldJNIEnv_1325     void SetShortField(jobject obj, jfieldID fieldID,
1326                        jshort val) {
1327         functions->SetShortField(this,obj,fieldID,val);
1328     }
SetIntFieldJNIEnv_1329     void SetIntField(jobject obj, jfieldID fieldID,
1330                      jint val) {
1331         functions->SetIntField(this,obj,fieldID,val);
1332     }
SetLongFieldJNIEnv_1333     void SetLongField(jobject obj, jfieldID fieldID,
1334                       jlong val) {
1335         functions->SetLongField(this,obj,fieldID,val);
1336     }
SetFloatFieldJNIEnv_1337     void SetFloatField(jobject obj, jfieldID fieldID,
1338                        jfloat val) {
1339         functions->SetFloatField(this,obj,fieldID,val);
1340     }
SetDoubleFieldJNIEnv_1341     void SetDoubleField(jobject obj, jfieldID fieldID,
1342                         jdouble val) {
1343         functions->SetDoubleField(this,obj,fieldID,val);
1344     }
1345 
GetStaticMethodIDJNIEnv_1346     jmethodID GetStaticMethodID(jclass clazz, const char *name,
1347                                 const char *sig) {
1348         return functions->GetStaticMethodID(this,clazz,name,sig);
1349     }
1350 
CallStaticObjectMethodJNIEnv_1351     jobject CallStaticObjectMethod(jclass clazz, jmethodID methodID,
1352                              ...) {
1353         va_list args;
1354         jobject result;
1355         va_start(args,methodID);
1356         result = functions->CallStaticObjectMethodV(this,clazz,methodID,args);
1357         va_end(args);
1358         return result;
1359     }
CallStaticObjectMethodVJNIEnv_1360     jobject CallStaticObjectMethodV(jclass clazz, jmethodID methodID,
1361                               va_list args) {
1362         return functions->CallStaticObjectMethodV(this,clazz,methodID,args);
1363     }
CallStaticObjectMethodAJNIEnv_1364     jobject CallStaticObjectMethodA(jclass clazz, jmethodID methodID,
1365                               const jvalue *args) {
1366         return functions->CallStaticObjectMethodA(this,clazz,methodID,args);
1367     }
1368 
CallStaticBooleanMethodJNIEnv_1369     jboolean CallStaticBooleanMethod(jclass clazz,
1370                                      jmethodID methodID, ...) {
1371         va_list args;
1372         jboolean result;
1373         va_start(args,methodID);
1374         result = functions->CallStaticBooleanMethodV(this,clazz,methodID,args);
1375         va_end(args);
1376         return result;
1377     }
CallStaticBooleanMethodVJNIEnv_1378     jboolean CallStaticBooleanMethodV(jclass clazz,
1379                                       jmethodID methodID, va_list args) {
1380         return functions->CallStaticBooleanMethodV(this,clazz,methodID,args);
1381     }
CallStaticBooleanMethodAJNIEnv_1382     jboolean CallStaticBooleanMethodA(jclass clazz,
1383                                       jmethodID methodID, const jvalue *args) {
1384         return functions->CallStaticBooleanMethodA(this,clazz,methodID,args);
1385     }
1386 
CallStaticByteMethodJNIEnv_1387     jbyte CallStaticByteMethod(jclass clazz,
1388                                jmethodID methodID, ...) {
1389         va_list args;
1390         jbyte result;
1391         va_start(args,methodID);
1392         result = functions->CallStaticByteMethodV(this,clazz,methodID,args);
1393         va_end(args);
1394         return result;
1395     }
CallStaticByteMethodVJNIEnv_1396     jbyte CallStaticByteMethodV(jclass clazz,
1397                                 jmethodID methodID, va_list args) {
1398         return functions->CallStaticByteMethodV(this,clazz,methodID,args);
1399     }
CallStaticByteMethodAJNIEnv_1400     jbyte CallStaticByteMethodA(jclass clazz,
1401                                 jmethodID methodID, const jvalue *args) {
1402         return functions->CallStaticByteMethodA(this,clazz,methodID,args);
1403     }
1404 
CallStaticCharMethodJNIEnv_1405     jchar CallStaticCharMethod(jclass clazz,
1406                                jmethodID methodID, ...) {
1407         va_list args;
1408         jchar result;
1409         va_start(args,methodID);
1410         result = functions->CallStaticCharMethodV(this,clazz,methodID,args);
1411         va_end(args);
1412         return result;
1413     }
CallStaticCharMethodVJNIEnv_1414     jchar CallStaticCharMethodV(jclass clazz,
1415                                 jmethodID methodID, va_list args) {
1416         return functions->CallStaticCharMethodV(this,clazz,methodID,args);
1417     }
CallStaticCharMethodAJNIEnv_1418     jchar CallStaticCharMethodA(jclass clazz,
1419                                 jmethodID methodID, const jvalue *args) {
1420         return functions->CallStaticCharMethodA(this,clazz,methodID,args);
1421     }
1422 
CallStaticShortMethodJNIEnv_1423     jshort CallStaticShortMethod(jclass clazz,
1424                                  jmethodID methodID, ...) {
1425         va_list args;
1426         jshort result;
1427         va_start(args,methodID);
1428         result = functions->CallStaticShortMethodV(this,clazz,methodID,args);
1429         va_end(args);
1430         return result;
1431     }
CallStaticShortMethodVJNIEnv_1432     jshort CallStaticShortMethodV(jclass clazz,
1433                                   jmethodID methodID, va_list args) {
1434         return functions->CallStaticShortMethodV(this,clazz,methodID,args);
1435     }
CallStaticShortMethodAJNIEnv_1436     jshort CallStaticShortMethodA(jclass clazz,
1437                                   jmethodID methodID, const jvalue *args) {
1438         return functions->CallStaticShortMethodA(this,clazz,methodID,args);
1439     }
1440 
CallStaticIntMethodJNIEnv_1441     jint CallStaticIntMethod(jclass clazz,
1442                              jmethodID methodID, ...) {
1443         va_list args;
1444         jint result;
1445         va_start(args,methodID);
1446         result = functions->CallStaticIntMethodV(this,clazz,methodID,args);
1447         va_end(args);
1448         return result;
1449     }
CallStaticIntMethodVJNIEnv_1450     jint CallStaticIntMethodV(jclass clazz,
1451                               jmethodID methodID, va_list args) {
1452         return functions->CallStaticIntMethodV(this,clazz,methodID,args);
1453     }
CallStaticIntMethodAJNIEnv_1454     jint CallStaticIntMethodA(jclass clazz,
1455                               jmethodID methodID, const jvalue *args) {
1456         return functions->CallStaticIntMethodA(this,clazz,methodID,args);
1457     }
1458 
CallStaticLongMethodJNIEnv_1459     jlong CallStaticLongMethod(jclass clazz,
1460                                jmethodID methodID, ...) {
1461         va_list args;
1462         jlong result;
1463         va_start(args,methodID);
1464         result = functions->CallStaticLongMethodV(this,clazz,methodID,args);
1465         va_end(args);
1466         return result;
1467     }
CallStaticLongMethodVJNIEnv_1468     jlong CallStaticLongMethodV(jclass clazz,
1469                                 jmethodID methodID, va_list args) {
1470         return functions->CallStaticLongMethodV(this,clazz,methodID,args);
1471     }
CallStaticLongMethodAJNIEnv_1472     jlong CallStaticLongMethodA(jclass clazz,
1473                                 jmethodID methodID, const jvalue *args) {
1474         return functions->CallStaticLongMethodA(this,clazz,methodID,args);
1475     }
1476 
CallStaticFloatMethodJNIEnv_1477     jfloat CallStaticFloatMethod(jclass clazz,
1478                                  jmethodID methodID, ...) {
1479         va_list args;
1480         jfloat result;
1481         va_start(args,methodID);
1482         result = functions->CallStaticFloatMethodV(this,clazz,methodID,args);
1483         va_end(args);
1484         return result;
1485     }
CallStaticFloatMethodVJNIEnv_1486     jfloat CallStaticFloatMethodV(jclass clazz,
1487                                   jmethodID methodID, va_list args) {
1488         return functions->CallStaticFloatMethodV(this,clazz,methodID,args);
1489     }
CallStaticFloatMethodAJNIEnv_1490     jfloat CallStaticFloatMethodA(jclass clazz,
1491                                   jmethodID methodID, const jvalue *args) {
1492         return functions->CallStaticFloatMethodA(this,clazz,methodID,args);
1493     }
1494 
CallStaticDoubleMethodJNIEnv_1495     jdouble CallStaticDoubleMethod(jclass clazz,
1496                                    jmethodID methodID, ...) {
1497         va_list args;
1498         jdouble result;
1499         va_start(args,methodID);
1500         result = functions->CallStaticDoubleMethodV(this,clazz,methodID,args);
1501         va_end(args);
1502         return result;
1503     }
CallStaticDoubleMethodVJNIEnv_1504     jdouble CallStaticDoubleMethodV(jclass clazz,
1505                                     jmethodID methodID, va_list args) {
1506         return functions->CallStaticDoubleMethodV(this,clazz,methodID,args);
1507     }
CallStaticDoubleMethodAJNIEnv_1508     jdouble CallStaticDoubleMethodA(jclass clazz,
1509                                     jmethodID methodID, const jvalue *args) {
1510         return functions->CallStaticDoubleMethodA(this,clazz,methodID,args);
1511     }
1512 
CallStaticVoidMethodJNIEnv_1513     void CallStaticVoidMethod(jclass cls, jmethodID methodID, ...) {
1514         va_list args;
1515         va_start(args,methodID);
1516         functions->CallStaticVoidMethodV(this,cls,methodID,args);
1517         va_end(args);
1518     }
CallStaticVoidMethodVJNIEnv_1519     void CallStaticVoidMethodV(jclass cls, jmethodID methodID,
1520                                va_list args) {
1521         functions->CallStaticVoidMethodV(this,cls,methodID,args);
1522     }
CallStaticVoidMethodAJNIEnv_1523     void CallStaticVoidMethodA(jclass cls, jmethodID methodID,
1524                                const jvalue * args) {
1525         functions->CallStaticVoidMethodA(this,cls,methodID,args);
1526     }
1527 
GetStaticFieldIDJNIEnv_1528     jfieldID GetStaticFieldID(jclass clazz, const char *name,
1529                               const char *sig) {
1530         return functions->GetStaticFieldID(this,clazz,name,sig);
1531     }
GetStaticObjectFieldJNIEnv_1532     jobject GetStaticObjectField(jclass clazz, jfieldID fieldID) {
1533         return functions->GetStaticObjectField(this,clazz,fieldID);
1534     }
GetStaticBooleanFieldJNIEnv_1535     jboolean GetStaticBooleanField(jclass clazz, jfieldID fieldID) {
1536         return functions->GetStaticBooleanField(this,clazz,fieldID);
1537     }
GetStaticByteFieldJNIEnv_1538     jbyte GetStaticByteField(jclass clazz, jfieldID fieldID) {
1539         return functions->GetStaticByteField(this,clazz,fieldID);
1540     }
GetStaticCharFieldJNIEnv_1541     jchar GetStaticCharField(jclass clazz, jfieldID fieldID) {
1542         return functions->GetStaticCharField(this,clazz,fieldID);
1543     }
GetStaticShortFieldJNIEnv_1544     jshort GetStaticShortField(jclass clazz, jfieldID fieldID) {
1545         return functions->GetStaticShortField(this,clazz,fieldID);
1546     }
GetStaticIntFieldJNIEnv_1547     jint GetStaticIntField(jclass clazz, jfieldID fieldID) {
1548         return functions->GetStaticIntField(this,clazz,fieldID);
1549     }
GetStaticLongFieldJNIEnv_1550     jlong GetStaticLongField(jclass clazz, jfieldID fieldID) {
1551         return functions->GetStaticLongField(this,clazz,fieldID);
1552     }
GetStaticFloatFieldJNIEnv_1553     jfloat GetStaticFloatField(jclass clazz, jfieldID fieldID) {
1554         return functions->GetStaticFloatField(this,clazz,fieldID);
1555     }
GetStaticDoubleFieldJNIEnv_1556     jdouble GetStaticDoubleField(jclass clazz, jfieldID fieldID) {
1557         return functions->GetStaticDoubleField(this,clazz,fieldID);
1558     }
1559 
SetStaticObjectFieldJNIEnv_1560     void SetStaticObjectField(jclass clazz, jfieldID fieldID,
1561                         jobject value) {
1562       functions->SetStaticObjectField(this,clazz,fieldID,value);
1563     }
SetStaticBooleanFieldJNIEnv_1564     void SetStaticBooleanField(jclass clazz, jfieldID fieldID,
1565                         jboolean value) {
1566       functions->SetStaticBooleanField(this,clazz,fieldID,value);
1567     }
SetStaticByteFieldJNIEnv_1568     void SetStaticByteField(jclass clazz, jfieldID fieldID,
1569                         jbyte value) {
1570       functions->SetStaticByteField(this,clazz,fieldID,value);
1571     }
SetStaticCharFieldJNIEnv_1572     void SetStaticCharField(jclass clazz, jfieldID fieldID,
1573                         jchar value) {
1574       functions->SetStaticCharField(this,clazz,fieldID,value);
1575     }
SetStaticShortFieldJNIEnv_1576     void SetStaticShortField(jclass clazz, jfieldID fieldID,
1577                         jshort value) {
1578       functions->SetStaticShortField(this,clazz,fieldID,value);
1579     }
SetStaticIntFieldJNIEnv_1580     void SetStaticIntField(jclass clazz, jfieldID fieldID,
1581                         jint value) {
1582       functions->SetStaticIntField(this,clazz,fieldID,value);
1583     }
SetStaticLongFieldJNIEnv_1584     void SetStaticLongField(jclass clazz, jfieldID fieldID,
1585                         jlong value) {
1586       functions->SetStaticLongField(this,clazz,fieldID,value);
1587     }
SetStaticFloatFieldJNIEnv_1588     void SetStaticFloatField(jclass clazz, jfieldID fieldID,
1589                         jfloat value) {
1590       functions->SetStaticFloatField(this,clazz,fieldID,value);
1591     }
SetStaticDoubleFieldJNIEnv_1592     void SetStaticDoubleField(jclass clazz, jfieldID fieldID,
1593                         jdouble value) {
1594       functions->SetStaticDoubleField(this,clazz,fieldID,value);
1595     }
1596 
NewStringJNIEnv_1597     jstring NewString(const jchar *unicode, jsize len) {
1598         return functions->NewString(this,unicode,len);
1599     }
GetStringLengthJNIEnv_1600     jsize GetStringLength(jstring str) {
1601         return functions->GetStringLength(this,str);
1602     }
GetStringCharsJNIEnv_1603     const jchar *GetStringChars(jstring str, jboolean *isCopy) {
1604         return functions->GetStringChars(this,str,isCopy);
1605     }
ReleaseStringCharsJNIEnv_1606     void ReleaseStringChars(jstring str, const jchar *chars) {
1607         functions->ReleaseStringChars(this,str,chars);
1608     }
1609 
NewStringUTFJNIEnv_1610     jstring NewStringUTF(const char *utf) {
1611         return functions->NewStringUTF(this,utf);
1612     }
GetStringUTFLengthJNIEnv_1613     jsize GetStringUTFLength(jstring str) {
1614         return functions->GetStringUTFLength(this,str);
1615     }
GetStringUTFCharsJNIEnv_1616     const char* GetStringUTFChars(jstring str, jboolean *isCopy) {
1617         return functions->GetStringUTFChars(this,str,isCopy);
1618     }
ReleaseStringUTFCharsJNIEnv_1619     void ReleaseStringUTFChars(jstring str, const char* chars) {
1620         functions->ReleaseStringUTFChars(this,str,chars);
1621     }
1622 
GetArrayLengthJNIEnv_1623     jsize GetArrayLength(jarray array) {
1624         return functions->GetArrayLength(this,array);
1625     }
1626 
NewObjectArrayJNIEnv_1627     jobjectArray NewObjectArray(jsize len, jclass clazz,
1628                                 jobject init) {
1629         return functions->NewObjectArray(this,len,clazz,init);
1630     }
GetObjectArrayElementJNIEnv_1631     jobject GetObjectArrayElement(jobjectArray array, jsize index) {
1632         return functions->GetObjectArrayElement(this,array,index);
1633     }
SetObjectArrayElementJNIEnv_1634     void SetObjectArrayElement(jobjectArray array, jsize index,
1635                                jobject val) {
1636         functions->SetObjectArrayElement(this,array,index,val);
1637     }
1638 
NewBooleanArrayJNIEnv_1639     jbooleanArray NewBooleanArray(jsize len) {
1640         return functions->NewBooleanArray(this,len);
1641     }
NewByteArrayJNIEnv_1642     jbyteArray NewByteArray(jsize len) {
1643         return functions->NewByteArray(this,len);
1644     }
NewCharArrayJNIEnv_1645     jcharArray NewCharArray(jsize len) {
1646         return functions->NewCharArray(this,len);
1647     }
NewShortArrayJNIEnv_1648     jshortArray NewShortArray(jsize len) {
1649         return functions->NewShortArray(this,len);
1650     }
NewIntArrayJNIEnv_1651     jintArray NewIntArray(jsize len) {
1652         return functions->NewIntArray(this,len);
1653     }
NewLongArrayJNIEnv_1654     jlongArray NewLongArray(jsize len) {
1655         return functions->NewLongArray(this,len);
1656     }
NewFloatArrayJNIEnv_1657     jfloatArray NewFloatArray(jsize len) {
1658         return functions->NewFloatArray(this,len);
1659     }
NewDoubleArrayJNIEnv_1660     jdoubleArray NewDoubleArray(jsize len) {
1661         return functions->NewDoubleArray(this,len);
1662     }
1663 
GetBooleanArrayElementsJNIEnv_1664     jboolean * GetBooleanArrayElements(jbooleanArray array, jboolean *isCopy) {
1665         return functions->GetBooleanArrayElements(this,array,isCopy);
1666     }
GetByteArrayElementsJNIEnv_1667     jbyte * GetByteArrayElements(jbyteArray array, jboolean *isCopy) {
1668         return functions->GetByteArrayElements(this,array,isCopy);
1669     }
GetCharArrayElementsJNIEnv_1670     jchar * GetCharArrayElements(jcharArray array, jboolean *isCopy) {
1671         return functions->GetCharArrayElements(this,array,isCopy);
1672     }
GetShortArrayElementsJNIEnv_1673     jshort * GetShortArrayElements(jshortArray array, jboolean *isCopy) {
1674         return functions->GetShortArrayElements(this,array,isCopy);
1675     }
GetIntArrayElementsJNIEnv_1676     jint * GetIntArrayElements(jintArray array, jboolean *isCopy) {
1677         return functions->GetIntArrayElements(this,array,isCopy);
1678     }
GetLongArrayElementsJNIEnv_1679     jlong * GetLongArrayElements(jlongArray array, jboolean *isCopy) {
1680         return functions->GetLongArrayElements(this,array,isCopy);
1681     }
GetFloatArrayElementsJNIEnv_1682     jfloat * GetFloatArrayElements(jfloatArray array, jboolean *isCopy) {
1683         return functions->GetFloatArrayElements(this,array,isCopy);
1684     }
GetDoubleArrayElementsJNIEnv_1685     jdouble * GetDoubleArrayElements(jdoubleArray array, jboolean *isCopy) {
1686         return functions->GetDoubleArrayElements(this,array,isCopy);
1687     }
1688 
ReleaseBooleanArrayElementsJNIEnv_1689     void ReleaseBooleanArrayElements(jbooleanArray array,
1690                                      jboolean *elems,
1691                                      jint mode) {
1692         functions->ReleaseBooleanArrayElements(this,array,elems,mode);
1693     }
ReleaseByteArrayElementsJNIEnv_1694     void ReleaseByteArrayElements(jbyteArray array,
1695                                   jbyte *elems,
1696                                   jint mode) {
1697         functions->ReleaseByteArrayElements(this,array,elems,mode);
1698     }
ReleaseCharArrayElementsJNIEnv_1699     void ReleaseCharArrayElements(jcharArray array,
1700                                   jchar *elems,
1701                                   jint mode) {
1702         functions->ReleaseCharArrayElements(this,array,elems,mode);
1703     }
ReleaseShortArrayElementsJNIEnv_1704     void ReleaseShortArrayElements(jshortArray array,
1705                                    jshort *elems,
1706                                    jint mode) {
1707         functions->ReleaseShortArrayElements(this,array,elems,mode);
1708     }
ReleaseIntArrayElementsJNIEnv_1709     void ReleaseIntArrayElements(jintArray array,
1710                                  jint *elems,
1711                                  jint mode) {
1712         functions->ReleaseIntArrayElements(this,array,elems,mode);
1713     }
ReleaseLongArrayElementsJNIEnv_1714     void ReleaseLongArrayElements(jlongArray array,
1715                                   jlong *elems,
1716                                   jint mode) {
1717         functions->ReleaseLongArrayElements(this,array,elems,mode);
1718     }
ReleaseFloatArrayElementsJNIEnv_1719     void ReleaseFloatArrayElements(jfloatArray array,
1720                                    jfloat *elems,
1721                                    jint mode) {
1722         functions->ReleaseFloatArrayElements(this,array,elems,mode);
1723     }
ReleaseDoubleArrayElementsJNIEnv_1724     void ReleaseDoubleArrayElements(jdoubleArray array,
1725                                     jdouble *elems,
1726                                     jint mode) {
1727         functions->ReleaseDoubleArrayElements(this,array,elems,mode);
1728     }
1729 
GetBooleanArrayRegionJNIEnv_1730     void GetBooleanArrayRegion(jbooleanArray array,
1731                                jsize start, jsize len, jboolean *buf) {
1732         functions->GetBooleanArrayRegion(this,array,start,len,buf);
1733     }
GetByteArrayRegionJNIEnv_1734     void GetByteArrayRegion(jbyteArray array,
1735                             jsize start, jsize len, jbyte *buf) {
1736         functions->GetByteArrayRegion(this,array,start,len,buf);
1737     }
GetCharArrayRegionJNIEnv_1738     void GetCharArrayRegion(jcharArray array,
1739                             jsize start, jsize len, jchar *buf) {
1740         functions->GetCharArrayRegion(this,array,start,len,buf);
1741     }
GetShortArrayRegionJNIEnv_1742     void GetShortArrayRegion(jshortArray array,
1743                              jsize start, jsize len, jshort *buf) {
1744         functions->GetShortArrayRegion(this,array,start,len,buf);
1745     }
GetIntArrayRegionJNIEnv_1746     void GetIntArrayRegion(jintArray array,
1747                            jsize start, jsize len, jint *buf) {
1748         functions->GetIntArrayRegion(this,array,start,len,buf);
1749     }
GetLongArrayRegionJNIEnv_1750     void GetLongArrayRegion(jlongArray array,
1751                             jsize start, jsize len, jlong *buf) {
1752         functions->GetLongArrayRegion(this,array,start,len,buf);
1753     }
GetFloatArrayRegionJNIEnv_1754     void GetFloatArrayRegion(jfloatArray array,
1755                              jsize start, jsize len, jfloat *buf) {
1756         functions->GetFloatArrayRegion(this,array,start,len,buf);
1757     }
GetDoubleArrayRegionJNIEnv_1758     void GetDoubleArrayRegion(jdoubleArray array,
1759                               jsize start, jsize len, jdouble *buf) {
1760         functions->GetDoubleArrayRegion(this,array,start,len,buf);
1761     }
1762 
SetBooleanArrayRegionJNIEnv_1763     void SetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len,
1764                                const jboolean *buf) {
1765         functions->SetBooleanArrayRegion(this,array,start,len,buf);
1766     }
SetByteArrayRegionJNIEnv_1767     void SetByteArrayRegion(jbyteArray array, jsize start, jsize len,
1768                             const jbyte *buf) {
1769         functions->SetByteArrayRegion(this,array,start,len,buf);
1770     }
SetCharArrayRegionJNIEnv_1771     void SetCharArrayRegion(jcharArray array, jsize start, jsize len,
1772                             const jchar *buf) {
1773         functions->SetCharArrayRegion(this,array,start,len,buf);
1774     }
SetShortArrayRegionJNIEnv_1775     void SetShortArrayRegion(jshortArray array, jsize start, jsize len,
1776                              const jshort *buf) {
1777         functions->SetShortArrayRegion(this,array,start,len,buf);
1778     }
SetIntArrayRegionJNIEnv_1779     void SetIntArrayRegion(jintArray array, jsize start, jsize len,
1780                            const jint *buf) {
1781         functions->SetIntArrayRegion(this,array,start,len,buf);
1782     }
SetLongArrayRegionJNIEnv_1783     void SetLongArrayRegion(jlongArray array, jsize start, jsize len,
1784                             const jlong *buf) {
1785         functions->SetLongArrayRegion(this,array,start,len,buf);
1786     }
SetFloatArrayRegionJNIEnv_1787     void SetFloatArrayRegion(jfloatArray array, jsize start, jsize len,
1788                              const jfloat *buf) {
1789         functions->SetFloatArrayRegion(this,array,start,len,buf);
1790     }
SetDoubleArrayRegionJNIEnv_1791     void SetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len,
1792                               const jdouble *buf) {
1793         functions->SetDoubleArrayRegion(this,array,start,len,buf);
1794     }
1795 
RegisterNativesJNIEnv_1796     jint RegisterNatives(jclass clazz, const JNINativeMethod *methods,
1797                          jint nMethods) {
1798         return functions->RegisterNatives(this,clazz,methods,nMethods);
1799     }
UnregisterNativesJNIEnv_1800     jint UnregisterNatives(jclass clazz) {
1801         return functions->UnregisterNatives(this,clazz);
1802     }
1803 
MonitorEnterJNIEnv_1804     jint MonitorEnter(jobject obj) {
1805         return functions->MonitorEnter(this,obj);
1806     }
MonitorExitJNIEnv_1807     jint MonitorExit(jobject obj) {
1808         return functions->MonitorExit(this,obj);
1809     }
1810 
GetJavaVMJNIEnv_1811     jint GetJavaVM(JavaVM **vm) {
1812         return functions->GetJavaVM(this,vm);
1813     }
1814 
GetStringRegionJNIEnv_1815     void GetStringRegion(jstring str, jsize start, jsize len, jchar *buf) {
1816         functions->GetStringRegion(this,str,start,len,buf);
1817     }
GetStringUTFRegionJNIEnv_1818     void GetStringUTFRegion(jstring str, jsize start, jsize len, char *buf) {
1819         functions->GetStringUTFRegion(this,str,start,len,buf);
1820     }
1821 
GetPrimitiveArrayCriticalJNIEnv_1822     void * GetPrimitiveArrayCritical(jarray array, jboolean *isCopy) {
1823         return functions->GetPrimitiveArrayCritical(this,array,isCopy);
1824     }
ReleasePrimitiveArrayCriticalJNIEnv_1825     void ReleasePrimitiveArrayCritical(jarray array, void *carray, jint mode) {
1826         functions->ReleasePrimitiveArrayCritical(this,array,carray,mode);
1827     }
1828 
GetStringCriticalJNIEnv_1829     const jchar * GetStringCritical(jstring string, jboolean *isCopy) {
1830         return functions->GetStringCritical(this,string,isCopy);
1831     }
ReleaseStringCriticalJNIEnv_1832     void ReleaseStringCritical(jstring string, const jchar *cstring) {
1833         functions->ReleaseStringCritical(this,string,cstring);
1834     }
1835 
NewWeakGlobalRefJNIEnv_1836     jweak NewWeakGlobalRef(jobject obj) {
1837         return functions->NewWeakGlobalRef(this,obj);
1838     }
DeleteWeakGlobalRefJNIEnv_1839     void DeleteWeakGlobalRef(jweak ref) {
1840         functions->DeleteWeakGlobalRef(this,ref);
1841     }
1842 
ExceptionCheckJNIEnv_1843     jboolean ExceptionCheck() {
1844         return functions->ExceptionCheck(this);
1845     }
1846 
NewDirectByteBufferJNIEnv_1847     jobject NewDirectByteBuffer(void* address, jlong capacity) {
1848         return functions->NewDirectByteBuffer(this, address, capacity);
1849     }
GetDirectBufferAddressJNIEnv_1850     void* GetDirectBufferAddress(jobject buf) {
1851         return functions->GetDirectBufferAddress(this, buf);
1852     }
GetDirectBufferCapacityJNIEnv_1853     jlong GetDirectBufferCapacity(jobject buf) {
1854         return functions->GetDirectBufferCapacity(this, buf);
1855     }
GetObjectRefTypeJNIEnv_1856     jobjectRefType GetObjectRefType(jobject obj) {
1857         return functions->GetObjectRefType(this, obj);
1858     }
1859 
1860 #endif /* __cplusplus */
1861 };
1862 
1863 typedef struct JavaVMOption {
1864     char *optionString;
1865     void *extraInfo;
1866 } JavaVMOption;
1867 
1868 typedef struct JavaVMInitArgs {
1869     jint version;
1870 
1871     jint nOptions;
1872     JavaVMOption *options;
1873     jboolean ignoreUnrecognized;
1874 } JavaVMInitArgs;
1875 
1876 typedef struct JavaVMAttachArgs {
1877     jint version;
1878 
1879     char *name;
1880     jobject group;
1881 } JavaVMAttachArgs;
1882 
1883 /* These will be VM-specific. */
1884 
1885 #define JDK1_2
1886 #define JDK1_4
1887 
1888 /* End VM-specific. */
1889 
1890 struct JNIInvokeInterface_ {
1891     void *reserved0;
1892     void *reserved1;
1893     void *reserved2;
1894 
1895     jint (JNICALL *DestroyJavaVM)(JavaVM *vm);
1896 
1897     jint (JNICALL *AttachCurrentThread)(JavaVM *vm, void **penv, void *args);
1898 
1899     jint (JNICALL *DetachCurrentThread)(JavaVM *vm);
1900 
1901     jint (JNICALL *GetEnv)(JavaVM *vm, void **penv, jint version);
1902 
1903     jint (JNICALL *AttachCurrentThreadAsDaemon)(JavaVM *vm, void **penv, void *args);
1904 };
1905 
1906 struct JavaVM_ {
1907     const struct JNIInvokeInterface_ *functions;
1908 #ifdef __cplusplus
1909 
DestroyJavaVMJavaVM_1910     jint DestroyJavaVM() {
1911         return functions->DestroyJavaVM(this);
1912     }
AttachCurrentThreadJavaVM_1913     jint AttachCurrentThread(void **penv, void *args) {
1914         return functions->AttachCurrentThread(this, penv, args);
1915     }
DetachCurrentThreadJavaVM_1916     jint DetachCurrentThread() {
1917         return functions->DetachCurrentThread(this);
1918     }
1919 
GetEnvJavaVM_1920     jint GetEnv(void **penv, jint version) {
1921         return functions->GetEnv(this, penv, version);
1922     }
AttachCurrentThreadAsDaemonJavaVM_1923     jint AttachCurrentThreadAsDaemon(void **penv, void *args) {
1924         return functions->AttachCurrentThreadAsDaemon(this, penv, args);
1925     }
1926 #endif
1927 };
1928 
1929 #ifdef _JNI_IMPLEMENTATION_
1930 #define _JNI_IMPORT_OR_EXPORT_ JNIEXPORT
1931 #else
1932 #define _JNI_IMPORT_OR_EXPORT_ JNIIMPORT
1933 #endif
1934 _JNI_IMPORT_OR_EXPORT_ jint JNICALL
1935 JNI_GetDefaultJavaVMInitArgs(void *args);
1936 
1937 _JNI_IMPORT_OR_EXPORT_ jint JNICALL
1938 JNI_CreateJavaVM(JavaVM **pvm, void **penv, void *args);
1939 
1940 _JNI_IMPORT_OR_EXPORT_ jint JNICALL
1941 JNI_GetCreatedJavaVMs(JavaVM **, jsize, jsize *);
1942 
1943 /* Defined by native libraries. */
1944 JNIEXPORT jint JNICALL
1945 JNI_OnLoad(JavaVM *vm, void *reserved);
1946 
1947 JNIEXPORT void JNICALL
1948 JNI_OnUnload(JavaVM *vm, void *reserved);
1949 
1950 #define JNI_VERSION_1_1 0x00010001
1951 #define JNI_VERSION_1_2 0x00010002
1952 #define JNI_VERSION_1_4 0x00010004
1953 #define JNI_VERSION_1_6 0x00010006
1954 #define JNI_VERSION_1_8 0x00010008
1955 
1956 #ifdef __cplusplus
1957 } /* extern "C" */
1958 #endif /* __cplusplus */
1959 
1960 #endif /* !_JAVASOFT_JNI_H_ */
1961