source: trunk/projects/slim-curve/src/main/c/jni.h @ 7691

Revision 7691, 73.1 KB checked in by aivar, 9 years ago (diff)

Changes to get JNI working (vs JNA).

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