jni.h revision 10420:c558850fac57 
1/*
2 * Copyright (c) 1997, 2016, 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
48extern "C" {
49#endif
50
51/*
52 * JNI Types
53 */
54
55#ifndef JNI_TYPES_ALREADY_DEFINED_IN_JNI_MD_H
56
57typedef unsigned char   jboolean;
58typedef unsigned short  jchar;
59typedef short           jshort;
60typedef float           jfloat;
61typedef double          jdouble;
62
63typedef jint            jsize;
64
65#ifdef __cplusplus
66
67class _jobject {};
68class _jclass : public _jobject {};
69class _jthrowable : public _jobject {};
70class _jstring : public _jobject {};
71class _jarray : public _jobject {};
72class _jbooleanArray : public _jarray {};
73class _jbyteArray : public _jarray {};
74class _jcharArray : public _jarray {};
75class _jshortArray : public _jarray {};
76class _jintArray : public _jarray {};
77class _jlongArray : public _jarray {};
78class _jfloatArray : public _jarray {};
79class _jdoubleArray : public _jarray {};
80class _jobjectArray : public _jarray {};
81
82typedef _jobject *jobject;
83typedef _jclass *jclass;
84typedef _jthrowable *jthrowable;
85typedef _jstring *jstring;
86typedef _jarray *jarray;
87typedef _jbooleanArray *jbooleanArray;
88typedef _jbyteArray *jbyteArray;
89typedef _jcharArray *jcharArray;
90typedef _jshortArray *jshortArray;
91typedef _jintArray *jintArray;
92typedef _jlongArray *jlongArray;
93typedef _jfloatArray *jfloatArray;
94typedef _jdoubleArray *jdoubleArray;
95typedef _jobjectArray *jobjectArray;
96
97#else
98
99struct _jobject;
100
101typedef struct _jobject *jobject;
102typedef jobject jclass;
103typedef jobject jthrowable;
104typedef jobject jstring;
105typedef jobject jarray;
106typedef jarray jbooleanArray;
107typedef jarray jbyteArray;
108typedef jarray jcharArray;
109typedef jarray jshortArray;
110typedef jarray jintArray;
111typedef jarray jlongArray;
112typedef jarray jfloatArray;
113typedef jarray jdoubleArray;
114typedef jarray jobjectArray;
115
116#endif
117
118typedef jobject jweak;
119
120typedef 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
132struct _jfieldID;
133typedef struct _jfieldID *jfieldID;
134
135struct _jmethodID;
136typedef struct _jmethodID *jmethodID;
137
138/* Return values from jobjectRefType */
139typedef 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
180typedef struct {
181    char *name;
182    char *signature;
183    void *fnPtr;
184} JNINativeMethod;
185
186/*
187 * JNI Native Method Interface.
188 */
189
190struct JNINativeInterface_;
191
192struct JNIEnv_;
193
194#ifdef __cplusplus
195typedef JNIEnv_ JNIEnv;
196#else
197typedef const struct JNINativeInterface_ *JNIEnv;
198#endif
199
200/*
201 * JNI Invocation Interface.
202 */
203
204struct JNIInvokeInterface_;
205
206struct JavaVM_;
207
208#ifdef __cplusplus
209typedef JavaVM_ JavaVM;
210#else
211typedef const struct JNIInvokeInterface_ *JavaVM;
212#endif
213
214struct JNINativeInterface_ {
215    void *reserved0;
216    void *reserved1;
217    void *reserved2;
218
219    void *reserved3;
220    jint (JNICALL *GetVersion)(JNIEnv *env);
221
222    jclass (JNICALL *DefineClass)
223      (JNIEnv *env, const char *name, jobject loader, const jbyte *buf,
224       jsize len);
225    jclass (JNICALL *FindClass)
226      (JNIEnv *env, const char *name);
227
228    jmethodID (JNICALL *FromReflectedMethod)
229      (JNIEnv *env, jobject method);
230    jfieldID (JNICALL *FromReflectedField)
231      (JNIEnv *env, jobject field);
232
233    jobject (JNICALL *ToReflectedMethod)
234      (JNIEnv *env, jclass cls, jmethodID methodID, jboolean isStatic);
235
236    jclass (JNICALL *GetSuperclass)
237      (JNIEnv *env, jclass sub);
238    jboolean (JNICALL *IsAssignableFrom)
239      (JNIEnv *env, jclass sub, jclass sup);
240
241    jobject (JNICALL *ToReflectedField)
242      (JNIEnv *env, jclass cls, jfieldID fieldID, jboolean isStatic);
243
244    jint (JNICALL *Throw)
245      (JNIEnv *env, jthrowable obj);
246    jint (JNICALL *ThrowNew)
247      (JNIEnv *env, jclass clazz, const char *msg);
248    jthrowable (JNICALL *ExceptionOccurred)
249      (JNIEnv *env);
250    void (JNICALL *ExceptionDescribe)
251      (JNIEnv *env);
252    void (JNICALL *ExceptionClear)
253      (JNIEnv *env);
254    void (JNICALL *FatalError)
255      (JNIEnv *env, const char *msg);
256
257    jint (JNICALL *PushLocalFrame)
258      (JNIEnv *env, jint capacity);
259    jobject (JNICALL *PopLocalFrame)
260      (JNIEnv *env, jobject result);
261
262    jobject (JNICALL *NewGlobalRef)
263      (JNIEnv *env, jobject lobj);
264    void (JNICALL *DeleteGlobalRef)
265      (JNIEnv *env, jobject gref);
266    void (JNICALL *DeleteLocalRef)
267      (JNIEnv *env, jobject obj);
268    jboolean (JNICALL *IsSameObject)
269      (JNIEnv *env, jobject obj1, jobject obj2);
270    jobject (JNICALL *NewLocalRef)
271      (JNIEnv *env, jobject ref);
272    jint (JNICALL *EnsureLocalCapacity)
273      (JNIEnv *env, jint capacity);
274
275    jobject (JNICALL *AllocObject)
276      (JNIEnv *env, jclass clazz);
277    jobject (JNICALL *NewObject)
278      (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
279    jobject (JNICALL *NewObjectV)
280      (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
281    jobject (JNICALL *NewObjectA)
282      (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
283
284    jclass (JNICALL *GetObjectClass)
285      (JNIEnv *env, jobject obj);
286    jboolean (JNICALL *IsInstanceOf)
287      (JNIEnv *env, jobject obj, jclass clazz);
288
289    jmethodID (JNICALL *GetMethodID)
290      (JNIEnv *env, jclass clazz, const char *name, const char *sig);
291
292    jobject (JNICALL *CallObjectMethod)
293      (JNIEnv *env, jobject obj, jmethodID methodID, ...);
294    jobject (JNICALL *CallObjectMethodV)
295      (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
296    jobject (JNICALL *CallObjectMethodA)
297      (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue * args);
298
299    jboolean (JNICALL *CallBooleanMethod)
300      (JNIEnv *env, jobject obj, jmethodID methodID, ...);
301    jboolean (JNICALL *CallBooleanMethodV)
302      (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
303    jboolean (JNICALL *CallBooleanMethodA)
304      (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue * args);
305
306    jbyte (JNICALL *CallByteMethod)
307      (JNIEnv *env, jobject obj, jmethodID methodID, ...);
308    jbyte (JNICALL *CallByteMethodV)
309      (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
310    jbyte (JNICALL *CallByteMethodA)
311      (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);
312
313    jchar (JNICALL *CallCharMethod)
314      (JNIEnv *env, jobject obj, jmethodID methodID, ...);
315    jchar (JNICALL *CallCharMethodV)
316      (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
317    jchar (JNICALL *CallCharMethodA)
318      (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);
319
320    jshort (JNICALL *CallShortMethod)
321      (JNIEnv *env, jobject obj, jmethodID methodID, ...);
322    jshort (JNICALL *CallShortMethodV)
323      (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
324    jshort (JNICALL *CallShortMethodA)
325      (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);
326
327    jint (JNICALL *CallIntMethod)
328      (JNIEnv *env, jobject obj, jmethodID methodID, ...);
329    jint (JNICALL *CallIntMethodV)
330      (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
331    jint (JNICALL *CallIntMethodA)
332      (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);
333
334    jlong (JNICALL *CallLongMethod)
335      (JNIEnv *env, jobject obj, jmethodID methodID, ...);
336    jlong (JNICALL *CallLongMethodV)
337      (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
338    jlong (JNICALL *CallLongMethodA)
339      (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);
340
341    jfloat (JNICALL *CallFloatMethod)
342      (JNIEnv *env, jobject obj, jmethodID methodID, ...);
343    jfloat (JNICALL *CallFloatMethodV)
344      (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
345    jfloat (JNICALL *CallFloatMethodA)
346      (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);
347
348    jdouble (JNICALL *CallDoubleMethod)
349      (JNIEnv *env, jobject obj, jmethodID methodID, ...);
350    jdouble (JNICALL *CallDoubleMethodV)
351      (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
352    jdouble (JNICALL *CallDoubleMethodA)
353      (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);
354
355    void (JNICALL *CallVoidMethod)
356      (JNIEnv *env, jobject obj, jmethodID methodID, ...);
357    void (JNICALL *CallVoidMethodV)
358      (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
359    void (JNICALL *CallVoidMethodA)
360      (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue * args);
361
362    jobject (JNICALL *CallNonvirtualObjectMethod)
363      (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
364    jobject (JNICALL *CallNonvirtualObjectMethodV)
365      (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
366       va_list args);
367    jobject (JNICALL *CallNonvirtualObjectMethodA)
368      (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
369       const jvalue * args);
370
371    jboolean (JNICALL *CallNonvirtualBooleanMethod)
372      (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
373    jboolean (JNICALL *CallNonvirtualBooleanMethodV)
374      (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
375       va_list args);
376    jboolean (JNICALL *CallNonvirtualBooleanMethodA)
377      (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
378       const jvalue * args);
379
380    jbyte (JNICALL *CallNonvirtualByteMethod)
381      (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
382    jbyte (JNICALL *CallNonvirtualByteMethodV)
383      (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
384       va_list args);
385    jbyte (JNICALL *CallNonvirtualByteMethodA)
386      (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
387       const jvalue *args);
388
389    jchar (JNICALL *CallNonvirtualCharMethod)
390      (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
391    jchar (JNICALL *CallNonvirtualCharMethodV)
392      (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
393       va_list args);
394    jchar (JNICALL *CallNonvirtualCharMethodA)
395      (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
396       const jvalue *args);
397
398    jshort (JNICALL *CallNonvirtualShortMethod)
399      (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
400    jshort (JNICALL *CallNonvirtualShortMethodV)
401      (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
402       va_list args);
403    jshort (JNICALL *CallNonvirtualShortMethodA)
404      (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
405       const jvalue *args);
406
407    jint (JNICALL *CallNonvirtualIntMethod)
408      (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
409    jint (JNICALL *CallNonvirtualIntMethodV)
410      (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
411       va_list args);
412    jint (JNICALL *CallNonvirtualIntMethodA)
413      (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
414       const jvalue *args);
415
416    jlong (JNICALL *CallNonvirtualLongMethod)
417      (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
418    jlong (JNICALL *CallNonvirtualLongMethodV)
419      (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
420       va_list args);
421    jlong (JNICALL *CallNonvirtualLongMethodA)
422      (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
423       const jvalue *args);
424
425    jfloat (JNICALL *CallNonvirtualFloatMethod)
426      (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
427    jfloat (JNICALL *CallNonvirtualFloatMethodV)
428      (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
429       va_list args);
430    jfloat (JNICALL *CallNonvirtualFloatMethodA)
431      (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
432       const jvalue *args);
433
434    jdouble (JNICALL *CallNonvirtualDoubleMethod)
435      (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
436    jdouble (JNICALL *CallNonvirtualDoubleMethodV)
437      (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
438       va_list args);
439    jdouble (JNICALL *CallNonvirtualDoubleMethodA)
440      (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
441       const jvalue *args);
442
443    void (JNICALL *CallNonvirtualVoidMethod)
444      (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
445    void (JNICALL *CallNonvirtualVoidMethodV)
446      (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
447       va_list args);
448    void (JNICALL *CallNonvirtualVoidMethodA)
449      (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
450       const jvalue * args);
451
452    jfieldID (JNICALL *GetFieldID)
453      (JNIEnv *env, jclass clazz, const char *name, const char *sig);
454
455    jobject (JNICALL *GetObjectField)
456      (JNIEnv *env, jobject obj, jfieldID fieldID);
457    jboolean (JNICALL *GetBooleanField)
458      (JNIEnv *env, jobject obj, jfieldID fieldID);
459    jbyte (JNICALL *GetByteField)
460      (JNIEnv *env, jobject obj, jfieldID fieldID);
461    jchar (JNICALL *GetCharField)
462      (JNIEnv *env, jobject obj, jfieldID fieldID);
463    jshort (JNICALL *GetShortField)
464      (JNIEnv *env, jobject obj, jfieldID fieldID);
465    jint (JNICALL *GetIntField)
466      (JNIEnv *env, jobject obj, jfieldID fieldID);
467    jlong (JNICALL *GetLongField)
468      (JNIEnv *env, jobject obj, jfieldID fieldID);
469    jfloat (JNICALL *GetFloatField)
470      (JNIEnv *env, jobject obj, jfieldID fieldID);
471    jdouble (JNICALL *GetDoubleField)
472      (JNIEnv *env, jobject obj, jfieldID fieldID);
473
474    void (JNICALL *SetObjectField)
475      (JNIEnv *env, jobject obj, jfieldID fieldID, jobject val);
476    void (JNICALL *SetBooleanField)
477      (JNIEnv *env, jobject obj, jfieldID fieldID, jboolean val);
478    void (JNICALL *SetByteField)
479      (JNIEnv *env, jobject obj, jfieldID fieldID, jbyte val);
480    void (JNICALL *SetCharField)
481      (JNIEnv *env, jobject obj, jfieldID fieldID, jchar val);
482    void (JNICALL *SetShortField)
483      (JNIEnv *env, jobject obj, jfieldID fieldID, jshort val);
484    void (JNICALL *SetIntField)
485      (JNIEnv *env, jobject obj, jfieldID fieldID, jint val);
486    void (JNICALL *SetLongField)
487      (JNIEnv *env, jobject obj, jfieldID fieldID, jlong val);
488    void (JNICALL *SetFloatField)
489      (JNIEnv *env, jobject obj, jfieldID fieldID, jfloat val);
490    void (JNICALL *SetDoubleField)
491      (JNIEnv *env, jobject obj, jfieldID fieldID, jdouble val);
492
493    jmethodID (JNICALL *GetStaticMethodID)
494      (JNIEnv *env, jclass clazz, const char *name, const char *sig);
495
496    jobject (JNICALL *CallStaticObjectMethod)
497      (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
498    jobject (JNICALL *CallStaticObjectMethodV)
499      (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
500    jobject (JNICALL *CallStaticObjectMethodA)
501      (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
502
503    jboolean (JNICALL *CallStaticBooleanMethod)
504      (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
505    jboolean (JNICALL *CallStaticBooleanMethodV)
506      (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
507    jboolean (JNICALL *CallStaticBooleanMethodA)
508      (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
509
510    jbyte (JNICALL *CallStaticByteMethod)
511      (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
512    jbyte (JNICALL *CallStaticByteMethodV)
513      (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
514    jbyte (JNICALL *CallStaticByteMethodA)
515      (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
516
517    jchar (JNICALL *CallStaticCharMethod)
518      (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
519    jchar (JNICALL *CallStaticCharMethodV)
520      (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
521    jchar (JNICALL *CallStaticCharMethodA)
522      (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
523
524    jshort (JNICALL *CallStaticShortMethod)
525      (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
526    jshort (JNICALL *CallStaticShortMethodV)
527      (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
528    jshort (JNICALL *CallStaticShortMethodA)
529      (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
530
531    jint (JNICALL *CallStaticIntMethod)
532      (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
533    jint (JNICALL *CallStaticIntMethodV)
534      (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
535    jint (JNICALL *CallStaticIntMethodA)
536      (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
537
538    jlong (JNICALL *CallStaticLongMethod)
539      (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
540    jlong (JNICALL *CallStaticLongMethodV)
541      (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
542    jlong (JNICALL *CallStaticLongMethodA)
543      (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
544
545    jfloat (JNICALL *CallStaticFloatMethod)
546      (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
547    jfloat (JNICALL *CallStaticFloatMethodV)
548      (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
549    jfloat (JNICALL *CallStaticFloatMethodA)
550      (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
551
552    jdouble (JNICALL *CallStaticDoubleMethod)
553      (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
554    jdouble (JNICALL *CallStaticDoubleMethodV)
555      (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
556    jdouble (JNICALL *CallStaticDoubleMethodA)
557      (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
558
559    void (JNICALL *CallStaticVoidMethod)
560      (JNIEnv *env, jclass cls, jmethodID methodID, ...);
561    void (JNICALL *CallStaticVoidMethodV)
562      (JNIEnv *env, jclass cls, jmethodID methodID, va_list args);
563    void (JNICALL *CallStaticVoidMethodA)
564      (JNIEnv *env, jclass cls, jmethodID methodID, const jvalue * args);
565
566    jfieldID (JNICALL *GetStaticFieldID)
567      (JNIEnv *env, jclass clazz, const char *name, const char *sig);
568    jobject (JNICALL *GetStaticObjectField)
569      (JNIEnv *env, jclass clazz, jfieldID fieldID);
570    jboolean (JNICALL *GetStaticBooleanField)
571      (JNIEnv *env, jclass clazz, jfieldID fieldID);
572    jbyte (JNICALL *GetStaticByteField)
573      (JNIEnv *env, jclass clazz, jfieldID fieldID);
574    jchar (JNICALL *GetStaticCharField)
575      (JNIEnv *env, jclass clazz, jfieldID fieldID);
576    jshort (JNICALL *GetStaticShortField)
577      (JNIEnv *env, jclass clazz, jfieldID fieldID);
578    jint (JNICALL *GetStaticIntField)
579      (JNIEnv *env, jclass clazz, jfieldID fieldID);
580    jlong (JNICALL *GetStaticLongField)
581      (JNIEnv *env, jclass clazz, jfieldID fieldID);
582    jfloat (JNICALL *GetStaticFloatField)
583      (JNIEnv *env, jclass clazz, jfieldID fieldID);
584    jdouble (JNICALL *GetStaticDoubleField)
585      (JNIEnv *env, jclass clazz, jfieldID fieldID);
586
587    void (JNICALL *SetStaticObjectField)
588      (JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value);
589    void (JNICALL *SetStaticBooleanField)
590      (JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value);
591    void (JNICALL *SetStaticByteField)
592      (JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value);
593    void (JNICALL *SetStaticCharField)
594      (JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value);
595    void (JNICALL *SetStaticShortField)
596      (JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value);
597    void (JNICALL *SetStaticIntField)
598      (JNIEnv *env, jclass clazz, jfieldID fieldID, jint value);
599    void (JNICALL *SetStaticLongField)
600      (JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value);
601    void (JNICALL *SetStaticFloatField)
602      (JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value);
603    void (JNICALL *SetStaticDoubleField)
604      (JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value);
605
606    jstring (JNICALL *NewString)
607      (JNIEnv *env, const jchar *unicode, jsize len);
608    jsize (JNICALL *GetStringLength)
609      (JNIEnv *env, jstring str);
610    const jchar *(JNICALL *GetStringChars)
611      (JNIEnv *env, jstring str, jboolean *isCopy);
612    void (JNICALL *ReleaseStringChars)
613      (JNIEnv *env, jstring str, const jchar *chars);
614
615    jstring (JNICALL *NewStringUTF)
616      (JNIEnv *env, const char *utf);
617    jsize (JNICALL *GetStringUTFLength)
618      (JNIEnv *env, jstring str);
619    const char* (JNICALL *GetStringUTFChars)
620      (JNIEnv *env, jstring str, jboolean *isCopy);
621    void (JNICALL *ReleaseStringUTFChars)
622      (JNIEnv *env, jstring str, const char* chars);
623
624
625    jsize (JNICALL *GetArrayLength)
626      (JNIEnv *env, jarray array);
627
628    jobjectArray (JNICALL *NewObjectArray)
629      (JNIEnv *env, jsize len, jclass clazz, jobject init);
630    jobject (JNICALL *GetObjectArrayElement)
631      (JNIEnv *env, jobjectArray array, jsize index);
632    void (JNICALL *SetObjectArrayElement)
633      (JNIEnv *env, jobjectArray array, jsize index, jobject val);
634
635    jbooleanArray (JNICALL *NewBooleanArray)
636      (JNIEnv *env, jsize len);
637    jbyteArray (JNICALL *NewByteArray)
638      (JNIEnv *env, jsize len);
639    jcharArray (JNICALL *NewCharArray)
640      (JNIEnv *env, jsize len);
641    jshortArray (JNICALL *NewShortArray)
642      (JNIEnv *env, jsize len);
643    jintArray (JNICALL *NewIntArray)
644      (JNIEnv *env, jsize len);
645    jlongArray (JNICALL *NewLongArray)
646      (JNIEnv *env, jsize len);
647    jfloatArray (JNICALL *NewFloatArray)
648      (JNIEnv *env, jsize len);
649    jdoubleArray (JNICALL *NewDoubleArray)
650      (JNIEnv *env, jsize len);
651
652    jboolean * (JNICALL *GetBooleanArrayElements)
653      (JNIEnv *env, jbooleanArray array, jboolean *isCopy);
654    jbyte * (JNICALL *GetByteArrayElements)
655      (JNIEnv *env, jbyteArray array, jboolean *isCopy);
656    jchar * (JNICALL *GetCharArrayElements)
657      (JNIEnv *env, jcharArray array, jboolean *isCopy);
658    jshort * (JNICALL *GetShortArrayElements)
659      (JNIEnv *env, jshortArray array, jboolean *isCopy);
660    jint * (JNICALL *GetIntArrayElements)
661      (JNIEnv *env, jintArray array, jboolean *isCopy);
662    jlong * (JNICALL *GetLongArrayElements)
663      (JNIEnv *env, jlongArray array, jboolean *isCopy);
664    jfloat * (JNICALL *GetFloatArrayElements)
665      (JNIEnv *env, jfloatArray array, jboolean *isCopy);
666    jdouble * (JNICALL *GetDoubleArrayElements)
667      (JNIEnv *env, jdoubleArray array, jboolean *isCopy);
668
669    void (JNICALL *ReleaseBooleanArrayElements)
670      (JNIEnv *env, jbooleanArray array, jboolean *elems, jint mode);
671    void (JNICALL *ReleaseByteArrayElements)
672      (JNIEnv *env, jbyteArray array, jbyte *elems, jint mode);
673    void (JNICALL *ReleaseCharArrayElements)
674      (JNIEnv *env, jcharArray array, jchar *elems, jint mode);
675    void (JNICALL *ReleaseShortArrayElements)
676      (JNIEnv *env, jshortArray array, jshort *elems, jint mode);
677    void (JNICALL *ReleaseIntArrayElements)
678      (JNIEnv *env, jintArray array, jint *elems, jint mode);
679    void (JNICALL *ReleaseLongArrayElements)
680      (JNIEnv *env, jlongArray array, jlong *elems, jint mode);
681    void (JNICALL *ReleaseFloatArrayElements)
682      (JNIEnv *env, jfloatArray array, jfloat *elems, jint mode);
683    void (JNICALL *ReleaseDoubleArrayElements)
684      (JNIEnv *env, jdoubleArray array, jdouble *elems, jint mode);
685
686    void (JNICALL *GetBooleanArrayRegion)
687      (JNIEnv *env, jbooleanArray array, jsize start, jsize l, jboolean *buf);
688    void (JNICALL *GetByteArrayRegion)
689      (JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf);
690    void (JNICALL *GetCharArrayRegion)
691      (JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf);
692    void (JNICALL *GetShortArrayRegion)
693      (JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf);
694    void (JNICALL *GetIntArrayRegion)
695      (JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf);
696    void (JNICALL *GetLongArrayRegion)
697      (JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf);
698    void (JNICALL *GetFloatArrayRegion)
699      (JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf);
700    void (JNICALL *GetDoubleArrayRegion)
701      (JNIEnv *env, jdoubleArray array, jsize start, jsize len, jdouble *buf);
702
703    void (JNICALL *SetBooleanArrayRegion)
704      (JNIEnv *env, jbooleanArray array, jsize start, jsize l, const jboolean *buf);
705    void (JNICALL *SetByteArrayRegion)
706      (JNIEnv *env, jbyteArray array, jsize start, jsize len, const jbyte *buf);
707    void (JNICALL *SetCharArrayRegion)
708      (JNIEnv *env, jcharArray array, jsize start, jsize len, const jchar *buf);
709    void (JNICALL *SetShortArrayRegion)
710      (JNIEnv *env, jshortArray array, jsize start, jsize len, const jshort *buf);
711    void (JNICALL *SetIntArrayRegion)
712      (JNIEnv *env, jintArray array, jsize start, jsize len, const jint *buf);
713    void (JNICALL *SetLongArrayRegion)
714      (JNIEnv *env, jlongArray array, jsize start, jsize len, const jlong *buf);
715    void (JNICALL *SetFloatArrayRegion)
716      (JNIEnv *env, jfloatArray array, jsize start, jsize len, const jfloat *buf);
717    void (JNICALL *SetDoubleArrayRegion)
718      (JNIEnv *env, jdoubleArray array, jsize start, jsize len, const jdouble *buf);
719
720    jint (JNICALL *RegisterNatives)
721      (JNIEnv *env, jclass clazz, const JNINativeMethod *methods,
722       jint nMethods);
723    jint (JNICALL *UnregisterNatives)
724      (JNIEnv *env, jclass clazz);
725
726    jint (JNICALL *MonitorEnter)
727      (JNIEnv *env, jobject obj);
728    jint (JNICALL *MonitorExit)
729      (JNIEnv *env, jobject obj);
730
731    jint (JNICALL *GetJavaVM)
732      (JNIEnv *env, JavaVM **vm);
733
734    void (JNICALL *GetStringRegion)
735      (JNIEnv *env, jstring str, jsize start, jsize len, jchar *buf);
736    void (JNICALL *GetStringUTFRegion)
737      (JNIEnv *env, jstring str, jsize start, jsize len, char *buf);
738
739    void * (JNICALL *GetPrimitiveArrayCritical)
740      (JNIEnv *env, jarray array, jboolean *isCopy);
741    void (JNICALL *ReleasePrimitiveArrayCritical)
742      (JNIEnv *env, jarray array, void *carray, jint mode);
743
744    const jchar * (JNICALL *GetStringCritical)
745      (JNIEnv *env, jstring string, jboolean *isCopy);
746    void (JNICALL *ReleaseStringCritical)
747      (JNIEnv *env, jstring string, const jchar *cstring);
748
749    jweak (JNICALL *NewWeakGlobalRef)
750       (JNIEnv *env, jobject obj);
751    void (JNICALL *DeleteWeakGlobalRef)
752       (JNIEnv *env, jweak ref);
753
754    jboolean (JNICALL *ExceptionCheck)
755       (JNIEnv *env);
756
757    jobject (JNICALL *NewDirectByteBuffer)
758       (JNIEnv* env, void* address, jlong capacity);
759    void* (JNICALL *GetDirectBufferAddress)
760       (JNIEnv* env, jobject buf);
761    jlong (JNICALL *GetDirectBufferCapacity)
762       (JNIEnv* env, jobject buf);
763
764    /* New JNI 1.6 Features */
765
766    jobjectRefType (JNICALL *GetObjectRefType)
767        (JNIEnv* env, jobject obj);
768
769    /* Module Features */
770
771    jobject (JNICALL *GetModule)
772       (JNIEnv* env, jclass clazz);
773
774    void (JNICALL *AddModuleReads)
775       (JNIEnv* env, jobject m1, jobject m2);
776
777    jboolean (JNICALL *CanReadModule)
778       (JNIEnv* env, jobject m1, jobject m2);
779};
780
781/*
782 * We use inlined functions for C++ so that programmers can write:
783 *
784 *    env->FindClass("java/lang/String")
785 *
786 * in C++ rather than:
787 *
788 *    (*env)->FindClass(env, "java/lang/String")
789 *
790 * in C.
791 */
792
793struct JNIEnv_ {
794    const struct JNINativeInterface_ *functions;
795#ifdef __cplusplus
796
797    jint GetVersion() {
798        return functions->GetVersion(this);
799    }
800    jclass DefineClass(const char *name, jobject loader, const jbyte *buf,
801                       jsize len) {
802        return functions->DefineClass(this, name, loader, buf, len);
803    }
804    jclass FindClass(const char *name) {
805        return functions->FindClass(this, name);
806    }
807    jmethodID FromReflectedMethod(jobject method) {
808        return functions->FromReflectedMethod(this,method);
809    }
810    jfieldID FromReflectedField(jobject field) {
811        return functions->FromReflectedField(this,field);
812    }
813
814    jobject ToReflectedMethod(jclass cls, jmethodID methodID, jboolean isStatic) {
815        return functions->ToReflectedMethod(this, cls, methodID, isStatic);
816    }
817
818    jclass GetSuperclass(jclass sub) {
819        return functions->GetSuperclass(this, sub);
820    }
821    jboolean IsAssignableFrom(jclass sub, jclass sup) {
822        return functions->IsAssignableFrom(this, sub, sup);
823    }
824
825    jobject ToReflectedField(jclass cls, jfieldID fieldID, jboolean isStatic) {
826        return functions->ToReflectedField(this,cls,fieldID,isStatic);
827    }
828
829    jint Throw(jthrowable obj) {
830        return functions->Throw(this, obj);
831    }
832    jint ThrowNew(jclass clazz, const char *msg) {
833        return functions->ThrowNew(this, clazz, msg);
834    }
835    jthrowable ExceptionOccurred() {
836        return functions->ExceptionOccurred(this);
837    }
838    void ExceptionDescribe() {
839        functions->ExceptionDescribe(this);
840    }
841    void ExceptionClear() {
842        functions->ExceptionClear(this);
843    }
844    void FatalError(const char *msg) {
845        functions->FatalError(this, msg);
846    }
847
848    jint PushLocalFrame(jint capacity) {
849        return functions->PushLocalFrame(this,capacity);
850    }
851    jobject PopLocalFrame(jobject result) {
852        return functions->PopLocalFrame(this,result);
853    }
854
855    jobject NewGlobalRef(jobject lobj) {
856        return functions->NewGlobalRef(this,lobj);
857    }
858    void DeleteGlobalRef(jobject gref) {
859        functions->DeleteGlobalRef(this,gref);
860    }
861    void DeleteLocalRef(jobject obj) {
862        functions->DeleteLocalRef(this, obj);
863    }
864
865    jboolean IsSameObject(jobject obj1, jobject obj2) {
866        return functions->IsSameObject(this,obj1,obj2);
867    }
868
869    jobject NewLocalRef(jobject ref) {
870        return functions->NewLocalRef(this,ref);
871    }
872    jint EnsureLocalCapacity(jint capacity) {
873        return functions->EnsureLocalCapacity(this,capacity);
874    }
875
876    jobject AllocObject(jclass clazz) {
877        return functions->AllocObject(this,clazz);
878    }
879    jobject NewObject(jclass clazz, jmethodID methodID, ...) {
880        va_list args;
881        jobject result;
882        va_start(args, methodID);
883        result = functions->NewObjectV(this,clazz,methodID,args);
884        va_end(args);
885        return result;
886    }
887    jobject NewObjectV(jclass clazz, jmethodID methodID,
888                       va_list args) {
889        return functions->NewObjectV(this,clazz,methodID,args);
890    }
891    jobject NewObjectA(jclass clazz, jmethodID methodID,
892                       const jvalue *args) {
893        return functions->NewObjectA(this,clazz,methodID,args);
894    }
895
896    jclass GetObjectClass(jobject obj) {
897        return functions->GetObjectClass(this,obj);
898    }
899    jboolean IsInstanceOf(jobject obj, jclass clazz) {
900        return functions->IsInstanceOf(this,obj,clazz);
901    }
902
903    jmethodID GetMethodID(jclass clazz, const char *name,
904                          const char *sig) {
905        return functions->GetMethodID(this,clazz,name,sig);
906    }
907
908    jobject CallObjectMethod(jobject obj, jmethodID methodID, ...) {
909        va_list args;
910        jobject result;
911        va_start(args,methodID);
912        result = functions->CallObjectMethodV(this,obj,methodID,args);
913        va_end(args);
914        return result;
915    }
916    jobject CallObjectMethodV(jobject obj, jmethodID methodID,
917                        va_list args) {
918        return functions->CallObjectMethodV(this,obj,methodID,args);
919    }
920    jobject CallObjectMethodA(jobject obj, jmethodID methodID,
921                        const jvalue * args) {
922        return functions->CallObjectMethodA(this,obj,methodID,args);
923    }
924
925    jboolean CallBooleanMethod(jobject obj,
926                               jmethodID methodID, ...) {
927        va_list args;
928        jboolean result;
929        va_start(args,methodID);
930        result = functions->CallBooleanMethodV(this,obj,methodID,args);
931        va_end(args);
932        return result;
933    }
934    jboolean CallBooleanMethodV(jobject obj, jmethodID methodID,
935                                va_list args) {
936        return functions->CallBooleanMethodV(this,obj,methodID,args);
937    }
938    jboolean CallBooleanMethodA(jobject obj, jmethodID methodID,
939                                const jvalue * args) {
940        return functions->CallBooleanMethodA(this,obj,methodID, args);
941    }
942
943    jbyte CallByteMethod(jobject obj, jmethodID methodID, ...) {
944        va_list args;
945        jbyte result;
946        va_start(args,methodID);
947        result = functions->CallByteMethodV(this,obj,methodID,args);
948        va_end(args);
949        return result;
950    }
951    jbyte CallByteMethodV(jobject obj, jmethodID methodID,
952                          va_list args) {
953        return functions->CallByteMethodV(this,obj,methodID,args);
954    }
955    jbyte CallByteMethodA(jobject obj, jmethodID methodID,
956                          const jvalue * args) {
957        return functions->CallByteMethodA(this,obj,methodID,args);
958    }
959
960    jchar CallCharMethod(jobject obj, jmethodID methodID, ...) {
961        va_list args;
962        jchar result;
963        va_start(args,methodID);
964        result = functions->CallCharMethodV(this,obj,methodID,args);
965        va_end(args);
966        return result;
967    }
968    jchar CallCharMethodV(jobject obj, jmethodID methodID,
969                          va_list args) {
970        return functions->CallCharMethodV(this,obj,methodID,args);
971    }
972    jchar CallCharMethodA(jobject obj, jmethodID methodID,
973                          const jvalue * args) {
974        return functions->CallCharMethodA(this,obj,methodID,args);
975    }
976
977    jshort CallShortMethod(jobject obj, jmethodID methodID, ...) {
978        va_list args;
979        jshort result;
980        va_start(args,methodID);
981        result = functions->CallShortMethodV(this,obj,methodID,args);
982        va_end(args);
983        return result;
984    }
985    jshort CallShortMethodV(jobject obj, jmethodID methodID,
986                            va_list args) {
987        return functions->CallShortMethodV(this,obj,methodID,args);
988    }
989    jshort CallShortMethodA(jobject obj, jmethodID methodID,
990                            const jvalue * args) {
991        return functions->CallShortMethodA(this,obj,methodID,args);
992    }
993
994    jint CallIntMethod(jobject obj, jmethodID methodID, ...) {
995        va_list args;
996        jint result;
997        va_start(args,methodID);
998        result = functions->CallIntMethodV(this,obj,methodID,args);
999        va_end(args);
1000        return result;
1001    }
1002    jint CallIntMethodV(jobject obj, jmethodID methodID,
1003                        va_list args) {
1004        return functions->CallIntMethodV(this,obj,methodID,args);
1005    }
1006    jint CallIntMethodA(jobject obj, jmethodID methodID,
1007                        const jvalue * args) {
1008        return functions->CallIntMethodA(this,obj,methodID,args);
1009    }
1010
1011    jlong CallLongMethod(jobject obj, jmethodID methodID, ...) {
1012        va_list args;
1013        jlong result;
1014        va_start(args,methodID);
1015        result = functions->CallLongMethodV(this,obj,methodID,args);
1016        va_end(args);
1017        return result;
1018    }
1019    jlong CallLongMethodV(jobject obj, jmethodID methodID,
1020                          va_list args) {
1021        return functions->CallLongMethodV(this,obj,methodID,args);
1022    }
1023    jlong CallLongMethodA(jobject obj, jmethodID methodID,
1024                          const jvalue * args) {
1025        return functions->CallLongMethodA(this,obj,methodID,args);
1026    }
1027
1028    jfloat CallFloatMethod(jobject obj, jmethodID methodID, ...) {
1029        va_list args;
1030        jfloat result;
1031        va_start(args,methodID);
1032        result = functions->CallFloatMethodV(this,obj,methodID,args);
1033        va_end(args);
1034        return result;
1035    }
1036    jfloat CallFloatMethodV(jobject obj, jmethodID methodID,
1037                            va_list args) {
1038        return functions->CallFloatMethodV(this,obj,methodID,args);
1039    }
1040    jfloat CallFloatMethodA(jobject obj, jmethodID methodID,
1041                            const jvalue * args) {
1042        return functions->CallFloatMethodA(this,obj,methodID,args);
1043    }
1044
1045    jdouble CallDoubleMethod(jobject obj, jmethodID methodID, ...) {
1046        va_list args;
1047        jdouble result;
1048        va_start(args,methodID);
1049        result = functions->CallDoubleMethodV(this,obj,methodID,args);
1050        va_end(args);
1051        return result;
1052    }
1053    jdouble CallDoubleMethodV(jobject obj, jmethodID methodID,
1054                        va_list args) {
1055        return functions->CallDoubleMethodV(this,obj,methodID,args);
1056    }
1057    jdouble CallDoubleMethodA(jobject obj, jmethodID methodID,
1058                        const jvalue * args) {
1059        return functions->CallDoubleMethodA(this,obj,methodID,args);
1060    }
1061
1062    void CallVoidMethod(jobject obj, jmethodID methodID, ...) {
1063        va_list args;
1064        va_start(args,methodID);
1065        functions->CallVoidMethodV(this,obj,methodID,args);
1066        va_end(args);
1067    }
1068    void CallVoidMethodV(jobject obj, jmethodID methodID,
1069                         va_list args) {
1070        functions->CallVoidMethodV(this,obj,methodID,args);
1071    }
1072    void CallVoidMethodA(jobject obj, jmethodID methodID,
1073                         const jvalue * args) {
1074        functions->CallVoidMethodA(this,obj,methodID,args);
1075    }
1076
1077    jobject CallNonvirtualObjectMethod(jobject obj, jclass clazz,
1078                                       jmethodID methodID, ...) {
1079        va_list args;
1080        jobject result;
1081        va_start(args,methodID);
1082        result = functions->CallNonvirtualObjectMethodV(this,obj,clazz,
1083                                                        methodID,args);
1084        va_end(args);
1085        return result;
1086    }
1087    jobject CallNonvirtualObjectMethodV(jobject obj, jclass clazz,
1088                                        jmethodID methodID, va_list args) {
1089        return functions->CallNonvirtualObjectMethodV(this,obj,clazz,
1090                                                      methodID,args);
1091    }
1092    jobject CallNonvirtualObjectMethodA(jobject obj, jclass clazz,
1093                                        jmethodID methodID, const jvalue * args) {
1094        return functions->CallNonvirtualObjectMethodA(this,obj,clazz,
1095                                                      methodID,args);
1096    }
1097
1098    jboolean CallNonvirtualBooleanMethod(jobject obj, jclass clazz,
1099                                         jmethodID methodID, ...) {
1100        va_list args;
1101        jboolean result;
1102        va_start(args,methodID);
1103        result = functions->CallNonvirtualBooleanMethodV(this,obj,clazz,
1104                                                         methodID,args);
1105        va_end(args);
1106        return result;
1107    }
1108    jboolean CallNonvirtualBooleanMethodV(jobject obj, jclass clazz,
1109                                          jmethodID methodID, va_list args) {
1110        return functions->CallNonvirtualBooleanMethodV(this,obj,clazz,
1111                                                       methodID,args);
1112    }
1113    jboolean CallNonvirtualBooleanMethodA(jobject obj, jclass clazz,
1114                                          jmethodID methodID, const jvalue * args) {
1115        return functions->CallNonvirtualBooleanMethodA(this,obj,clazz,
1116                                                       methodID, args);
1117    }
1118
1119    jbyte CallNonvirtualByteMethod(jobject obj, jclass clazz,
1120                                   jmethodID methodID, ...) {
1121        va_list args;
1122        jbyte result;
1123        va_start(args,methodID);
1124        result = functions->CallNonvirtualByteMethodV(this,obj,clazz,
1125                                                      methodID,args);
1126        va_end(args);
1127        return result;
1128    }
1129    jbyte CallNonvirtualByteMethodV(jobject obj, jclass clazz,
1130                                    jmethodID methodID, va_list args) {
1131        return functions->CallNonvirtualByteMethodV(this,obj,clazz,
1132                                                    methodID,args);
1133    }
1134    jbyte CallNonvirtualByteMethodA(jobject obj, jclass clazz,
1135                                    jmethodID methodID, const jvalue * args) {
1136        return functions->CallNonvirtualByteMethodA(this,obj,clazz,
1137                                                    methodID,args);
1138    }
1139
1140    jchar CallNonvirtualCharMethod(jobject obj, jclass clazz,
1141                                   jmethodID methodID, ...) {
1142        va_list args;
1143        jchar result;
1144        va_start(args,methodID);
1145        result = functions->CallNonvirtualCharMethodV(this,obj,clazz,
1146                                                      methodID,args);
1147        va_end(args);
1148        return result;
1149    }
1150    jchar CallNonvirtualCharMethodV(jobject obj, jclass clazz,
1151                                    jmethodID methodID, va_list args) {
1152        return functions->CallNonvirtualCharMethodV(this,obj,clazz,
1153                                                    methodID,args);
1154    }
1155    jchar CallNonvirtualCharMethodA(jobject obj, jclass clazz,
1156                                    jmethodID methodID, const jvalue * args) {
1157        return functions->CallNonvirtualCharMethodA(this,obj,clazz,
1158                                                    methodID,args);
1159    }
1160
1161    jshort CallNonvirtualShortMethod(jobject obj, jclass clazz,
1162                                     jmethodID methodID, ...) {
1163        va_list args;
1164        jshort result;
1165        va_start(args,methodID);
1166        result = functions->CallNonvirtualShortMethodV(this,obj,clazz,
1167                                                       methodID,args);
1168        va_end(args);
1169        return result;
1170    }
1171    jshort CallNonvirtualShortMethodV(jobject obj, jclass clazz,
1172                                      jmethodID methodID, va_list args) {
1173        return functions->CallNonvirtualShortMethodV(this,obj,clazz,
1174                                                     methodID,args);
1175    }
1176    jshort CallNonvirtualShortMethodA(jobject obj, jclass clazz,
1177                                      jmethodID methodID, const jvalue * args) {
1178        return functions->CallNonvirtualShortMethodA(this,obj,clazz,
1179                                                     methodID,args);
1180    }
1181
1182    jint CallNonvirtualIntMethod(jobject obj, jclass clazz,
1183                                 jmethodID methodID, ...) {
1184        va_list args;
1185        jint result;
1186        va_start(args,methodID);
1187        result = functions->CallNonvirtualIntMethodV(this,obj,clazz,
1188                                                     methodID,args);
1189        va_end(args);
1190        return result;
1191    }
1192    jint CallNonvirtualIntMethodV(jobject obj, jclass clazz,
1193                                  jmethodID methodID, va_list args) {
1194        return functions->CallNonvirtualIntMethodV(this,obj,clazz,
1195                                                   methodID,args);
1196    }
1197    jint CallNonvirtualIntMethodA(jobject obj, jclass clazz,
1198                                  jmethodID methodID, const jvalue * args) {
1199        return functions->CallNonvirtualIntMethodA(this,obj,clazz,
1200                                                   methodID,args);
1201    }
1202
1203    jlong CallNonvirtualLongMethod(jobject obj, jclass clazz,
1204                                   jmethodID methodID, ...) {
1205        va_list args;
1206        jlong result;
1207        va_start(args,methodID);
1208        result = functions->CallNonvirtualLongMethodV(this,obj,clazz,
1209                                                      methodID,args);
1210        va_end(args);
1211        return result;
1212    }
1213    jlong CallNonvirtualLongMethodV(jobject obj, jclass clazz,
1214                                    jmethodID methodID, va_list args) {
1215        return functions->CallNonvirtualLongMethodV(this,obj,clazz,
1216                                                    methodID,args);
1217    }
1218    jlong CallNonvirtualLongMethodA(jobject obj, jclass clazz,
1219                                    jmethodID methodID, const jvalue * args) {
1220        return functions->CallNonvirtualLongMethodA(this,obj,clazz,
1221                                                    methodID,args);
1222    }
1223
1224    jfloat CallNonvirtualFloatMethod(jobject obj, jclass clazz,
1225                                     jmethodID methodID, ...) {
1226        va_list args;
1227        jfloat result;
1228        va_start(args,methodID);
1229        result = functions->CallNonvirtualFloatMethodV(this,obj,clazz,
1230                                                       methodID,args);
1231        va_end(args);
1232        return result;
1233    }
1234    jfloat CallNonvirtualFloatMethodV(jobject obj, jclass clazz,
1235                                      jmethodID methodID,
1236                                      va_list args) {
1237        return functions->CallNonvirtualFloatMethodV(this,obj,clazz,
1238                                                     methodID,args);
1239    }
1240    jfloat CallNonvirtualFloatMethodA(jobject obj, jclass clazz,
1241                                      jmethodID methodID,
1242                                      const jvalue * args) {
1243        return functions->CallNonvirtualFloatMethodA(this,obj,clazz,
1244                                                     methodID,args);
1245    }
1246
1247    jdouble CallNonvirtualDoubleMethod(jobject obj, jclass clazz,
1248                                       jmethodID methodID, ...) {
1249        va_list args;
1250        jdouble result;
1251        va_start(args,methodID);
1252        result = functions->CallNonvirtualDoubleMethodV(this,obj,clazz,
1253                                                        methodID,args);
1254        va_end(args);
1255        return result;
1256    }
1257    jdouble CallNonvirtualDoubleMethodV(jobject obj, jclass clazz,
1258                                        jmethodID methodID,
1259                                        va_list args) {
1260        return functions->CallNonvirtualDoubleMethodV(this,obj,clazz,
1261                                                      methodID,args);
1262    }
1263    jdouble CallNonvirtualDoubleMethodA(jobject obj, jclass clazz,
1264                                        jmethodID methodID,
1265                                        const jvalue * args) {
1266        return functions->CallNonvirtualDoubleMethodA(this,obj,clazz,
1267                                                      methodID,args);
1268    }
1269
1270    void CallNonvirtualVoidMethod(jobject obj, jclass clazz,
1271                                  jmethodID methodID, ...) {
1272        va_list args;
1273        va_start(args,methodID);
1274        functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);
1275        va_end(args);
1276    }
1277    void CallNonvirtualVoidMethodV(jobject obj, jclass clazz,
1278                                   jmethodID methodID,
1279                                   va_list args) {
1280        functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);
1281    }
1282    void CallNonvirtualVoidMethodA(jobject obj, jclass clazz,
1283                                   jmethodID methodID,
1284                                   const jvalue * args) {
1285        functions->CallNonvirtualVoidMethodA(this,obj,clazz,methodID,args);
1286    }
1287
1288    jfieldID GetFieldID(jclass clazz, const char *name,
1289                        const char *sig) {
1290        return functions->GetFieldID(this,clazz,name,sig);
1291    }
1292
1293    jobject GetObjectField(jobject obj, jfieldID fieldID) {
1294        return functions->GetObjectField(this,obj,fieldID);
1295    }
1296    jboolean GetBooleanField(jobject obj, jfieldID fieldID) {
1297        return functions->GetBooleanField(this,obj,fieldID);
1298    }
1299    jbyte GetByteField(jobject obj, jfieldID fieldID) {
1300        return functions->GetByteField(this,obj,fieldID);
1301    }
1302    jchar GetCharField(jobject obj, jfieldID fieldID) {
1303        return functions->GetCharField(this,obj,fieldID);
1304    }
1305    jshort GetShortField(jobject obj, jfieldID fieldID) {
1306        return functions->GetShortField(this,obj,fieldID);
1307    }
1308    jint GetIntField(jobject obj, jfieldID fieldID) {
1309        return functions->GetIntField(this,obj,fieldID);
1310    }
1311    jlong GetLongField(jobject obj, jfieldID fieldID) {
1312        return functions->GetLongField(this,obj,fieldID);
1313    }
1314    jfloat GetFloatField(jobject obj, jfieldID fieldID) {
1315        return functions->GetFloatField(this,obj,fieldID);
1316    }
1317    jdouble GetDoubleField(jobject obj, jfieldID fieldID) {
1318        return functions->GetDoubleField(this,obj,fieldID);
1319    }
1320
1321    void SetObjectField(jobject obj, jfieldID fieldID, jobject val) {
1322        functions->SetObjectField(this,obj,fieldID,val);
1323    }
1324    void SetBooleanField(jobject obj, jfieldID fieldID,
1325                         jboolean val) {
1326        functions->SetBooleanField(this,obj,fieldID,val);
1327    }
1328    void SetByteField(jobject obj, jfieldID fieldID,
1329                      jbyte val) {
1330        functions->SetByteField(this,obj,fieldID,val);
1331    }
1332    void SetCharField(jobject obj, jfieldID fieldID,
1333                      jchar val) {
1334        functions->SetCharField(this,obj,fieldID,val);
1335    }
1336    void SetShortField(jobject obj, jfieldID fieldID,
1337                       jshort val) {
1338        functions->SetShortField(this,obj,fieldID,val);
1339    }
1340    void SetIntField(jobject obj, jfieldID fieldID,
1341                     jint val) {
1342        functions->SetIntField(this,obj,fieldID,val);
1343    }
1344    void SetLongField(jobject obj, jfieldID fieldID,
1345                      jlong val) {
1346        functions->SetLongField(this,obj,fieldID,val);
1347    }
1348    void SetFloatField(jobject obj, jfieldID fieldID,
1349                       jfloat val) {
1350        functions->SetFloatField(this,obj,fieldID,val);
1351    }
1352    void SetDoubleField(jobject obj, jfieldID fieldID,
1353                        jdouble val) {
1354        functions->SetDoubleField(this,obj,fieldID,val);
1355    }
1356
1357    jmethodID GetStaticMethodID(jclass clazz, const char *name,
1358                                const char *sig) {
1359        return functions->GetStaticMethodID(this,clazz,name,sig);
1360    }
1361
1362    jobject CallStaticObjectMethod(jclass clazz, jmethodID methodID,
1363                             ...) {
1364        va_list args;
1365        jobject result;
1366        va_start(args,methodID);
1367        result = functions->CallStaticObjectMethodV(this,clazz,methodID,args);
1368        va_end(args);
1369        return result;
1370    }
1371    jobject CallStaticObjectMethodV(jclass clazz, jmethodID methodID,
1372                              va_list args) {
1373        return functions->CallStaticObjectMethodV(this,clazz,methodID,args);
1374    }
1375    jobject CallStaticObjectMethodA(jclass clazz, jmethodID methodID,
1376                              const jvalue *args) {
1377        return functions->CallStaticObjectMethodA(this,clazz,methodID,args);
1378    }
1379
1380    jboolean CallStaticBooleanMethod(jclass clazz,
1381                                     jmethodID methodID, ...) {
1382        va_list args;
1383        jboolean result;
1384        va_start(args,methodID);
1385        result = functions->CallStaticBooleanMethodV(this,clazz,methodID,args);
1386        va_end(args);
1387        return result;
1388    }
1389    jboolean CallStaticBooleanMethodV(jclass clazz,
1390                                      jmethodID methodID, va_list args) {
1391        return functions->CallStaticBooleanMethodV(this,clazz,methodID,args);
1392    }
1393    jboolean CallStaticBooleanMethodA(jclass clazz,
1394                                      jmethodID methodID, const jvalue *args) {
1395        return functions->CallStaticBooleanMethodA(this,clazz,methodID,args);
1396    }
1397
1398    jbyte CallStaticByteMethod(jclass clazz,
1399                               jmethodID methodID, ...) {
1400        va_list args;
1401        jbyte result;
1402        va_start(args,methodID);
1403        result = functions->CallStaticByteMethodV(this,clazz,methodID,args);
1404        va_end(args);
1405        return result;
1406    }
1407    jbyte CallStaticByteMethodV(jclass clazz,
1408                                jmethodID methodID, va_list args) {
1409        return functions->CallStaticByteMethodV(this,clazz,methodID,args);
1410    }
1411    jbyte CallStaticByteMethodA(jclass clazz,
1412                                jmethodID methodID, const jvalue *args) {
1413        return functions->CallStaticByteMethodA(this,clazz,methodID,args);
1414    }
1415
1416    jchar CallStaticCharMethod(jclass clazz,
1417                               jmethodID methodID, ...) {
1418        va_list args;
1419        jchar result;
1420        va_start(args,methodID);
1421        result = functions->CallStaticCharMethodV(this,clazz,methodID,args);
1422        va_end(args);
1423        return result;
1424    }
1425    jchar CallStaticCharMethodV(jclass clazz,
1426                                jmethodID methodID, va_list args) {
1427        return functions->CallStaticCharMethodV(this,clazz,methodID,args);
1428    }
1429    jchar CallStaticCharMethodA(jclass clazz,
1430                                jmethodID methodID, const jvalue *args) {
1431        return functions->CallStaticCharMethodA(this,clazz,methodID,args);
1432    }
1433
1434    jshort CallStaticShortMethod(jclass clazz,
1435                                 jmethodID methodID, ...) {
1436        va_list args;
1437        jshort result;
1438        va_start(args,methodID);
1439        result = functions->CallStaticShortMethodV(this,clazz,methodID,args);
1440        va_end(args);
1441        return result;
1442    }
1443    jshort CallStaticShortMethodV(jclass clazz,
1444                                  jmethodID methodID, va_list args) {
1445        return functions->CallStaticShortMethodV(this,clazz,methodID,args);
1446    }
1447    jshort CallStaticShortMethodA(jclass clazz,
1448                                  jmethodID methodID, const jvalue *args) {
1449        return functions->CallStaticShortMethodA(this,clazz,methodID,args);
1450    }
1451
1452    jint CallStaticIntMethod(jclass clazz,
1453                             jmethodID methodID, ...) {
1454        va_list args;
1455        jint result;
1456        va_start(args,methodID);
1457        result = functions->CallStaticIntMethodV(this,clazz,methodID,args);
1458        va_end(args);
1459        return result;
1460    }
1461    jint CallStaticIntMethodV(jclass clazz,
1462                              jmethodID methodID, va_list args) {
1463        return functions->CallStaticIntMethodV(this,clazz,methodID,args);
1464    }
1465    jint CallStaticIntMethodA(jclass clazz,
1466                              jmethodID methodID, const jvalue *args) {
1467        return functions->CallStaticIntMethodA(this,clazz,methodID,args);
1468    }
1469
1470    jlong CallStaticLongMethod(jclass clazz,
1471                               jmethodID methodID, ...) {
1472        va_list args;
1473        jlong result;
1474        va_start(args,methodID);
1475        result = functions->CallStaticLongMethodV(this,clazz,methodID,args);
1476        va_end(args);
1477        return result;
1478    }
1479    jlong CallStaticLongMethodV(jclass clazz,
1480                                jmethodID methodID, va_list args) {
1481        return functions->CallStaticLongMethodV(this,clazz,methodID,args);
1482    }
1483    jlong CallStaticLongMethodA(jclass clazz,
1484                                jmethodID methodID, const jvalue *args) {
1485        return functions->CallStaticLongMethodA(this,clazz,methodID,args);
1486    }
1487
1488    jfloat CallStaticFloatMethod(jclass clazz,
1489                                 jmethodID methodID, ...) {
1490        va_list args;
1491        jfloat result;
1492        va_start(args,methodID);
1493        result = functions->CallStaticFloatMethodV(this,clazz,methodID,args);
1494        va_end(args);
1495        return result;
1496    }
1497    jfloat CallStaticFloatMethodV(jclass clazz,
1498                                  jmethodID methodID, va_list args) {
1499        return functions->CallStaticFloatMethodV(this,clazz,methodID,args);
1500    }
1501    jfloat CallStaticFloatMethodA(jclass clazz,
1502                                  jmethodID methodID, const jvalue *args) {
1503        return functions->CallStaticFloatMethodA(this,clazz,methodID,args);
1504    }
1505
1506    jdouble CallStaticDoubleMethod(jclass clazz,
1507                                   jmethodID methodID, ...) {
1508        va_list args;
1509        jdouble result;
1510        va_start(args,methodID);
1511        result = functions->CallStaticDoubleMethodV(this,clazz,methodID,args);
1512        va_end(args);
1513        return result;
1514    }
1515    jdouble CallStaticDoubleMethodV(jclass clazz,
1516                                    jmethodID methodID, va_list args) {
1517        return functions->CallStaticDoubleMethodV(this,clazz,methodID,args);
1518    }
1519    jdouble CallStaticDoubleMethodA(jclass clazz,
1520                                    jmethodID methodID, const jvalue *args) {
1521        return functions->CallStaticDoubleMethodA(this,clazz,methodID,args);
1522    }
1523
1524    void CallStaticVoidMethod(jclass cls, jmethodID methodID, ...) {
1525        va_list args;
1526        va_start(args,methodID);
1527        functions->CallStaticVoidMethodV(this,cls,methodID,args);
1528        va_end(args);
1529    }
1530    void CallStaticVoidMethodV(jclass cls, jmethodID methodID,
1531                               va_list args) {
1532        functions->CallStaticVoidMethodV(this,cls,methodID,args);
1533    }
1534    void CallStaticVoidMethodA(jclass cls, jmethodID methodID,
1535                               const jvalue * args) {
1536        functions->CallStaticVoidMethodA(this,cls,methodID,args);
1537    }
1538
1539    jfieldID GetStaticFieldID(jclass clazz, const char *name,
1540                              const char *sig) {
1541        return functions->GetStaticFieldID(this,clazz,name,sig);
1542    }
1543    jobject GetStaticObjectField(jclass clazz, jfieldID fieldID) {
1544        return functions->GetStaticObjectField(this,clazz,fieldID);
1545    }
1546    jboolean GetStaticBooleanField(jclass clazz, jfieldID fieldID) {
1547        return functions->GetStaticBooleanField(this,clazz,fieldID);
1548    }
1549    jbyte GetStaticByteField(jclass clazz, jfieldID fieldID) {
1550        return functions->GetStaticByteField(this,clazz,fieldID);
1551    }
1552    jchar GetStaticCharField(jclass clazz, jfieldID fieldID) {
1553        return functions->GetStaticCharField(this,clazz,fieldID);
1554    }
1555    jshort GetStaticShortField(jclass clazz, jfieldID fieldID) {
1556        return functions->GetStaticShortField(this,clazz,fieldID);
1557    }
1558    jint GetStaticIntField(jclass clazz, jfieldID fieldID) {
1559        return functions->GetStaticIntField(this,clazz,fieldID);
1560    }
1561    jlong GetStaticLongField(jclass clazz, jfieldID fieldID) {
1562        return functions->GetStaticLongField(this,clazz,fieldID);
1563    }
1564    jfloat GetStaticFloatField(jclass clazz, jfieldID fieldID) {
1565        return functions->GetStaticFloatField(this,clazz,fieldID);
1566    }
1567    jdouble GetStaticDoubleField(jclass clazz, jfieldID fieldID) {
1568        return functions->GetStaticDoubleField(this,clazz,fieldID);
1569    }
1570
1571    void SetStaticObjectField(jclass clazz, jfieldID fieldID,
1572                        jobject value) {
1573      functions->SetStaticObjectField(this,clazz,fieldID,value);
1574    }
1575    void SetStaticBooleanField(jclass clazz, jfieldID fieldID,
1576                        jboolean value) {
1577      functions->SetStaticBooleanField(this,clazz,fieldID,value);
1578    }
1579    void SetStaticByteField(jclass clazz, jfieldID fieldID,
1580                        jbyte value) {
1581      functions->SetStaticByteField(this,clazz,fieldID,value);
1582    }
1583    void SetStaticCharField(jclass clazz, jfieldID fieldID,
1584                        jchar value) {
1585      functions->SetStaticCharField(this,clazz,fieldID,value);
1586    }
1587    void SetStaticShortField(jclass clazz, jfieldID fieldID,
1588                        jshort value) {
1589      functions->SetStaticShortField(this,clazz,fieldID,value);
1590    }
1591    void SetStaticIntField(jclass clazz, jfieldID fieldID,
1592                        jint value) {
1593      functions->SetStaticIntField(this,clazz,fieldID,value);
1594    }
1595    void SetStaticLongField(jclass clazz, jfieldID fieldID,
1596                        jlong value) {
1597      functions->SetStaticLongField(this,clazz,fieldID,value);
1598    }
1599    void SetStaticFloatField(jclass clazz, jfieldID fieldID,
1600                        jfloat value) {
1601      functions->SetStaticFloatField(this,clazz,fieldID,value);
1602    }
1603    void SetStaticDoubleField(jclass clazz, jfieldID fieldID,
1604                        jdouble value) {
1605      functions->SetStaticDoubleField(this,clazz,fieldID,value);
1606    }
1607
1608    jstring NewString(const jchar *unicode, jsize len) {
1609        return functions->NewString(this,unicode,len);
1610    }
1611    jsize GetStringLength(jstring str) {
1612        return functions->GetStringLength(this,str);
1613    }
1614    const jchar *GetStringChars(jstring str, jboolean *isCopy) {
1615        return functions->GetStringChars(this,str,isCopy);
1616    }
1617    void ReleaseStringChars(jstring str, const jchar *chars) {
1618        functions->ReleaseStringChars(this,str,chars);
1619    }
1620
1621    jstring NewStringUTF(const char *utf) {
1622        return functions->NewStringUTF(this,utf);
1623    }
1624    jsize GetStringUTFLength(jstring str) {
1625        return functions->GetStringUTFLength(this,str);
1626    }
1627    const char* GetStringUTFChars(jstring str, jboolean *isCopy) {
1628        return functions->GetStringUTFChars(this,str,isCopy);
1629    }
1630    void ReleaseStringUTFChars(jstring str, const char* chars) {
1631        functions->ReleaseStringUTFChars(this,str,chars);
1632    }
1633
1634    jsize GetArrayLength(jarray array) {
1635        return functions->GetArrayLength(this,array);
1636    }
1637
1638    jobjectArray NewObjectArray(jsize len, jclass clazz,
1639                                jobject init) {
1640        return functions->NewObjectArray(this,len,clazz,init);
1641    }
1642    jobject GetObjectArrayElement(jobjectArray array, jsize index) {
1643        return functions->GetObjectArrayElement(this,array,index);
1644    }
1645    void SetObjectArrayElement(jobjectArray array, jsize index,
1646                               jobject val) {
1647        functions->SetObjectArrayElement(this,array,index,val);
1648    }
1649
1650    jbooleanArray NewBooleanArray(jsize len) {
1651        return functions->NewBooleanArray(this,len);
1652    }
1653    jbyteArray NewByteArray(jsize len) {
1654        return functions->NewByteArray(this,len);
1655    }
1656    jcharArray NewCharArray(jsize len) {
1657        return functions->NewCharArray(this,len);
1658    }
1659    jshortArray NewShortArray(jsize len) {
1660        return functions->NewShortArray(this,len);
1661    }
1662    jintArray NewIntArray(jsize len) {
1663        return functions->NewIntArray(this,len);
1664    }
1665    jlongArray NewLongArray(jsize len) {
1666        return functions->NewLongArray(this,len);
1667    }
1668    jfloatArray NewFloatArray(jsize len) {
1669        return functions->NewFloatArray(this,len);
1670    }
1671    jdoubleArray NewDoubleArray(jsize len) {
1672        return functions->NewDoubleArray(this,len);
1673    }
1674
1675    jboolean * GetBooleanArrayElements(jbooleanArray array, jboolean *isCopy) {
1676        return functions->GetBooleanArrayElements(this,array,isCopy);
1677    }
1678    jbyte * GetByteArrayElements(jbyteArray array, jboolean *isCopy) {
1679        return functions->GetByteArrayElements(this,array,isCopy);
1680    }
1681    jchar * GetCharArrayElements(jcharArray array, jboolean *isCopy) {
1682        return functions->GetCharArrayElements(this,array,isCopy);
1683    }
1684    jshort * GetShortArrayElements(jshortArray array, jboolean *isCopy) {
1685        return functions->GetShortArrayElements(this,array,isCopy);
1686    }
1687    jint * GetIntArrayElements(jintArray array, jboolean *isCopy) {
1688        return functions->GetIntArrayElements(this,array,isCopy);
1689    }
1690    jlong * GetLongArrayElements(jlongArray array, jboolean *isCopy) {
1691        return functions->GetLongArrayElements(this,array,isCopy);
1692    }
1693    jfloat * GetFloatArrayElements(jfloatArray array, jboolean *isCopy) {
1694        return functions->GetFloatArrayElements(this,array,isCopy);
1695    }
1696    jdouble * GetDoubleArrayElements(jdoubleArray array, jboolean *isCopy) {
1697        return functions->GetDoubleArrayElements(this,array,isCopy);
1698    }
1699
1700    void ReleaseBooleanArrayElements(jbooleanArray array,
1701                                     jboolean *elems,
1702                                     jint mode) {
1703        functions->ReleaseBooleanArrayElements(this,array,elems,mode);
1704    }
1705    void ReleaseByteArrayElements(jbyteArray array,
1706                                  jbyte *elems,
1707                                  jint mode) {
1708        functions->ReleaseByteArrayElements(this,array,elems,mode);
1709    }
1710    void ReleaseCharArrayElements(jcharArray array,
1711                                  jchar *elems,
1712                                  jint mode) {
1713        functions->ReleaseCharArrayElements(this,array,elems,mode);
1714    }
1715    void ReleaseShortArrayElements(jshortArray array,
1716                                   jshort *elems,
1717                                   jint mode) {
1718        functions->ReleaseShortArrayElements(this,array,elems,mode);
1719    }
1720    void ReleaseIntArrayElements(jintArray array,
1721                                 jint *elems,
1722                                 jint mode) {
1723        functions->ReleaseIntArrayElements(this,array,elems,mode);
1724    }
1725    void ReleaseLongArrayElements(jlongArray array,
1726                                  jlong *elems,
1727                                  jint mode) {
1728        functions->ReleaseLongArrayElements(this,array,elems,mode);
1729    }
1730    void ReleaseFloatArrayElements(jfloatArray array,
1731                                   jfloat *elems,
1732                                   jint mode) {
1733        functions->ReleaseFloatArrayElements(this,array,elems,mode);
1734    }
1735    void ReleaseDoubleArrayElements(jdoubleArray array,
1736                                    jdouble *elems,
1737                                    jint mode) {
1738        functions->ReleaseDoubleArrayElements(this,array,elems,mode);
1739    }
1740
1741    void GetBooleanArrayRegion(jbooleanArray array,
1742                               jsize start, jsize len, jboolean *buf) {
1743        functions->GetBooleanArrayRegion(this,array,start,len,buf);
1744    }
1745    void GetByteArrayRegion(jbyteArray array,
1746                            jsize start, jsize len, jbyte *buf) {
1747        functions->GetByteArrayRegion(this,array,start,len,buf);
1748    }
1749    void GetCharArrayRegion(jcharArray array,
1750                            jsize start, jsize len, jchar *buf) {
1751        functions->GetCharArrayRegion(this,array,start,len,buf);
1752    }
1753    void GetShortArrayRegion(jshortArray array,
1754                             jsize start, jsize len, jshort *buf) {
1755        functions->GetShortArrayRegion(this,array,start,len,buf);
1756    }
1757    void GetIntArrayRegion(jintArray array,
1758                           jsize start, jsize len, jint *buf) {
1759        functions->GetIntArrayRegion(this,array,start,len,buf);
1760    }
1761    void GetLongArrayRegion(jlongArray array,
1762                            jsize start, jsize len, jlong *buf) {
1763        functions->GetLongArrayRegion(this,array,start,len,buf);
1764    }
1765    void GetFloatArrayRegion(jfloatArray array,
1766                             jsize start, jsize len, jfloat *buf) {
1767        functions->GetFloatArrayRegion(this,array,start,len,buf);
1768    }
1769    void GetDoubleArrayRegion(jdoubleArray array,
1770                              jsize start, jsize len, jdouble *buf) {
1771        functions->GetDoubleArrayRegion(this,array,start,len,buf);
1772    }
1773
1774    void SetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len,
1775                               const jboolean *buf) {
1776        functions->SetBooleanArrayRegion(this,array,start,len,buf);
1777    }
1778    void SetByteArrayRegion(jbyteArray array, jsize start, jsize len,
1779                            const jbyte *buf) {
1780        functions->SetByteArrayRegion(this,array,start,len,buf);
1781    }
1782    void SetCharArrayRegion(jcharArray array, jsize start, jsize len,
1783                            const jchar *buf) {
1784        functions->SetCharArrayRegion(this,array,start,len,buf);
1785    }
1786    void SetShortArrayRegion(jshortArray array, jsize start, jsize len,
1787                             const jshort *buf) {
1788        functions->SetShortArrayRegion(this,array,start,len,buf);
1789    }
1790    void SetIntArrayRegion(jintArray array, jsize start, jsize len,
1791                           const jint *buf) {
1792        functions->SetIntArrayRegion(this,array,start,len,buf);
1793    }
1794    void SetLongArrayRegion(jlongArray array, jsize start, jsize len,
1795                            const jlong *buf) {
1796        functions->SetLongArrayRegion(this,array,start,len,buf);
1797    }
1798    void SetFloatArrayRegion(jfloatArray array, jsize start, jsize len,
1799                             const jfloat *buf) {
1800        functions->SetFloatArrayRegion(this,array,start,len,buf);
1801    }
1802    void SetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len,
1803                              const jdouble *buf) {
1804        functions->SetDoubleArrayRegion(this,array,start,len,buf);
1805    }
1806
1807    jint RegisterNatives(jclass clazz, const JNINativeMethod *methods,
1808                         jint nMethods) {
1809        return functions->RegisterNatives(this,clazz,methods,nMethods);
1810    }
1811    jint UnregisterNatives(jclass clazz) {
1812        return functions->UnregisterNatives(this,clazz);
1813    }
1814
1815    jint MonitorEnter(jobject obj) {
1816        return functions->MonitorEnter(this,obj);
1817    }
1818    jint MonitorExit(jobject obj) {
1819        return functions->MonitorExit(this,obj);
1820    }
1821
1822    jint GetJavaVM(JavaVM **vm) {
1823        return functions->GetJavaVM(this,vm);
1824    }
1825
1826    void GetStringRegion(jstring str, jsize start, jsize len, jchar *buf) {
1827        functions->GetStringRegion(this,str,start,len,buf);
1828    }
1829    void GetStringUTFRegion(jstring str, jsize start, jsize len, char *buf) {
1830        functions->GetStringUTFRegion(this,str,start,len,buf);
1831    }
1832
1833    void * GetPrimitiveArrayCritical(jarray array, jboolean *isCopy) {
1834        return functions->GetPrimitiveArrayCritical(this,array,isCopy);
1835    }
1836    void ReleasePrimitiveArrayCritical(jarray array, void *carray, jint mode) {
1837        functions->ReleasePrimitiveArrayCritical(this,array,carray,mode);
1838    }
1839
1840    const jchar * GetStringCritical(jstring string, jboolean *isCopy) {
1841        return functions->GetStringCritical(this,string,isCopy);
1842    }
1843    void ReleaseStringCritical(jstring string, const jchar *cstring) {
1844        functions->ReleaseStringCritical(this,string,cstring);
1845    }
1846
1847    jweak NewWeakGlobalRef(jobject obj) {
1848        return functions->NewWeakGlobalRef(this,obj);
1849    }
1850    void DeleteWeakGlobalRef(jweak ref) {
1851        functions->DeleteWeakGlobalRef(this,ref);
1852    }
1853
1854    jboolean ExceptionCheck() {
1855        return functions->ExceptionCheck(this);
1856    }
1857
1858    jobject NewDirectByteBuffer(void* address, jlong capacity) {
1859        return functions->NewDirectByteBuffer(this, address, capacity);
1860    }
1861    void* GetDirectBufferAddress(jobject buf) {
1862        return functions->GetDirectBufferAddress(this, buf);
1863    }
1864    jlong GetDirectBufferCapacity(jobject buf) {
1865        return functions->GetDirectBufferCapacity(this, buf);
1866    }
1867    jobjectRefType GetObjectRefType(jobject obj) {
1868        return functions->GetObjectRefType(this, obj);
1869    }
1870
1871    /* Module Features */
1872
1873    jobject GetModule(jclass clazz) {
1874        return functions->GetModule(this, clazz);
1875    }
1876
1877    void AddModuleReads(jobject fromModule, jobject sourceModule) {
1878        functions->AddModuleReads(this, fromModule, sourceModule);
1879    }
1880
1881    jboolean CanReadModule(jobject askingModule, jobject sourceModule) {
1882        return functions->CanReadModule(this, askingModule, sourceModule);
1883    }
1884
1885#endif /* __cplusplus */
1886};
1887
1888typedef struct JavaVMOption {
1889    char *optionString;
1890    void *extraInfo;
1891} JavaVMOption;
1892
1893typedef struct JavaVMInitArgs {
1894    jint version;
1895
1896    jint nOptions;
1897    JavaVMOption *options;
1898    jboolean ignoreUnrecognized;
1899} JavaVMInitArgs;
1900
1901typedef struct JavaVMAttachArgs {
1902    jint version;
1903
1904    char *name;
1905    jobject group;
1906} JavaVMAttachArgs;
1907
1908/* These will be VM-specific. */
1909
1910#define JDK1_2
1911#define JDK1_4
1912
1913/* End VM-specific. */
1914
1915struct JNIInvokeInterface_ {
1916    void *reserved0;
1917    void *reserved1;
1918    void *reserved2;
1919
1920    jint (JNICALL *DestroyJavaVM)(JavaVM *vm);
1921
1922    jint (JNICALL *AttachCurrentThread)(JavaVM *vm, void **penv, void *args);
1923
1924    jint (JNICALL *DetachCurrentThread)(JavaVM *vm);
1925
1926    jint (JNICALL *GetEnv)(JavaVM *vm, void **penv, jint version);
1927
1928    jint (JNICALL *AttachCurrentThreadAsDaemon)(JavaVM *vm, void **penv, void *args);
1929};
1930
1931struct JavaVM_ {
1932    const struct JNIInvokeInterface_ *functions;
1933#ifdef __cplusplus
1934
1935    jint DestroyJavaVM() {
1936        return functions->DestroyJavaVM(this);
1937    }
1938    jint AttachCurrentThread(void **penv, void *args) {
1939        return functions->AttachCurrentThread(this, penv, args);
1940    }
1941    jint DetachCurrentThread() {
1942        return functions->DetachCurrentThread(this);
1943    }
1944
1945    jint GetEnv(void **penv, jint version) {
1946        return functions->GetEnv(this, penv, version);
1947    }
1948    jint AttachCurrentThreadAsDaemon(void **penv, void *args) {
1949        return functions->AttachCurrentThreadAsDaemon(this, penv, args);
1950    }
1951#endif
1952};
1953
1954#ifdef _JNI_IMPLEMENTATION_
1955#define _JNI_IMPORT_OR_EXPORT_ JNIEXPORT
1956#else
1957#define _JNI_IMPORT_OR_EXPORT_ JNIIMPORT
1958#endif
1959_JNI_IMPORT_OR_EXPORT_ jint JNICALL
1960JNI_GetDefaultJavaVMInitArgs(void *args);
1961
1962_JNI_IMPORT_OR_EXPORT_ jint JNICALL
1963JNI_CreateJavaVM(JavaVM **pvm, void **penv, void *args);
1964
1965_JNI_IMPORT_OR_EXPORT_ jint JNICALL
1966JNI_GetCreatedJavaVMs(JavaVM **, jsize, jsize *);
1967
1968/* Defined by native libraries. */
1969JNIEXPORT jint JNICALL
1970JNI_OnLoad(JavaVM *vm, void *reserved);
1971
1972JNIEXPORT void JNICALL
1973JNI_OnUnload(JavaVM *vm, void *reserved);
1974
1975#define JNI_VERSION_1_1 0x00010001
1976#define JNI_VERSION_1_2 0x00010002
1977#define JNI_VERSION_1_4 0x00010004
1978#define JNI_VERSION_1_6 0x00010006
1979#define JNI_VERSION_1_8 0x00010008
1980#define JNI_VERSION_9   0x00090000
1981
1982#ifdef __cplusplus
1983} /* extern "C" */
1984#endif /* __cplusplus */
1985
1986#endif /* !_JAVASOFT_JNI_H_ */
1987