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