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