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