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