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