Project

Profile

Help

How to connect?
Download (63.1 KB) Statistics
| Branch: | Revision:

he / src / main / c / Saxon.C.API / jni / jni.h @ a69dd173

1
/*
2
* Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
3
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
4
*
5
*
6
*
7
*
8
*
9
*
10
*
11
*
12
*
13
*
14
*
15
*
16
*
17
*
18
*
19
*
20
*
21
*
22
*
23
*
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 "unix/jni_md.h"
46

    
47
#ifdef __cplusplus
48
extern "C" {
49
#endif
50

    
51
        /*
52
        * JNI Types
53
        */
54

    
55
#ifndef JNI_TYPES_ALREADY_DEFINED_IN_JNI_MD_H
56

    
57
        typedef unsigned char   jboolean;
58
        typedef unsigned short  jchar;
59
        typedef short           jshort;
60
        typedef float           jfloat;
61
        typedef double          jdouble;
62

    
63
        typedef jint            jsize;
64

    
65
#ifdef __cplusplus
66

    
67
        class _jobject {};
68
        class _jclass : public _jobject {};
69
        class _jthrowable : public _jobject {};
70
        class _jstring : public _jobject {};
71
        class _jarray : public _jobject {};
72
        class _jbooleanArray : public _jarray {};
73
        class _jbyteArray : public _jarray {};
74
        class _jcharArray : public _jarray {};
75
        class _jshortArray : public _jarray {};
76
        class _jintArray : public _jarray {};
77
        class _jlongArray : public _jarray {};
78
        class _jfloatArray : public _jarray {};
79
        class _jdoubleArray : public _jarray {};
80
        class _jobjectArray : public _jarray {};
81

    
82
        typedef _jobject *jobject;
83
        typedef _jclass *jclass;
84
        typedef _jthrowable *jthrowable;
85
        typedef _jstring *jstring;
86
        typedef _jarray *jarray;
87
        typedef _jbooleanArray *jbooleanArray;
88
        typedef _jbyteArray *jbyteArray;
89
        typedef _jcharArray *jcharArray;
90
        typedef _jshortArray *jshortArray;
91
        typedef _jintArray *jintArray;
92
        typedef _jlongArray *jlongArray;
93
        typedef _jfloatArray *jfloatArray;
94
        typedef _jdoubleArray *jdoubleArray;
95
        typedef _jobjectArray *jobjectArray;
96

    
97
#else
98

    
99
        struct _jobject;
100

    
101
        typedef struct _jobject *jobject;
102
        typedef jobject jclass;
103
        typedef jobject jthrowable;
104
        typedef jobject jstring;
105
        typedef jobject jarray;
106
        typedef jarray jbooleanArray;
107
        typedef jarray jbyteArray;
108
        typedef jarray jcharArray;
109
        typedef jarray jshortArray;
110
        typedef jarray jintArray;
111
        typedef jarray jlongArray;
112
        typedef jarray jfloatArray;
113
        typedef jarray jdoubleArray;
114
        typedef jarray jobjectArray;
115

    
116
#endif
117

    
118
        typedef jobject jweak;
119

    
120
        typedef 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

    
132
        struct _jfieldID;
133
        typedef struct _jfieldID *jfieldID;
134

    
135
        struct _jmethodID;
136
        typedef struct _jmethodID *jmethodID;
137

    
138
        /* Return values from jobjectRefType */
139
        typedef 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

    
180
        typedef struct {
181
                char *name;
182
                char *signature;
183
                void *fnPtr;
184
        } JNINativeMethod;
185

    
186
        /*
187
        * JNI Native Method Interface.
188
        */
189

    
190
        struct JNINativeInterface_;
191

    
192
        struct JNIEnv_;
193

    
194
#ifdef __cplusplus
195
        typedef JNIEnv_ JNIEnv;
196
#else
197
        typedef const struct JNINativeInterface_ *JNIEnv;
198
#endif
199

    
200
        /*
201
        * JNI Invocation Interface.
202
        */
203

    
204
        struct JNIInvokeInterface_;
205

    
206
        struct JavaVM_;
207

    
208
#ifdef __cplusplus
209
        typedef JavaVM_ JavaVM;
210
#else
211
        typedef const struct JNIInvokeInterface_ *JavaVM;
212
#endif
213

    
214
        struct JNINativeInterface_ {
215
                void *reserved0;
216
                void *reserved1;
217
                void *reserved2;
218

    
219
                void *reserved3;
220
                jint(JNICALL *GetVersion)(JNIEnv *env);
221

    
222
                jclass(JNICALL *DefineClass)
223
                        (JNIEnv *env, const char *name, jobject loader, const jbyte *buf,
224
                                jsize len);
225
                jclass(JNICALL *FindClass)
226
                        (JNIEnv *env, const char *name);
227

    
228
                jmethodID(JNICALL *FromReflectedMethod)
229
                        (JNIEnv *env, jobject method);
230
                jfieldID(JNICALL *FromReflectedField)
231
                        (JNIEnv *env, jobject field);
232

    
233
                jobject(JNICALL *ToReflectedMethod)
234
                        (JNIEnv *env, jclass cls, jmethodID methodID, jboolean isStatic);
235

    
236
                jclass(JNICALL *GetSuperclass)
237
                        (JNIEnv *env, jclass sub);
238
                jboolean(JNICALL *IsAssignableFrom)
239
                        (JNIEnv *env, jclass sub, jclass sup);
240

    
241
                jobject(JNICALL *ToReflectedField)
242
                        (JNIEnv *env, jclass cls, jfieldID fieldID, jboolean isStatic);
243

    
244
                jint(JNICALL *Throw)
245
                        (JNIEnv *env, jthrowable obj);
246
                jint(JNICALL *ThrowNew)
247
                        (JNIEnv *env, jclass clazz, const char *msg);
248
                jthrowable(JNICALL *ExceptionOccurred)
249
                        (JNIEnv *env);
250
                void (JNICALL *ExceptionDescribe)
251
                        (JNIEnv *env);
252
                void (JNICALL *ExceptionClear)
253
                        (JNIEnv *env);
254
                void (JNICALL *FatalError)
255
                        (JNIEnv *env, const char *msg);
256

    
257
                jint(JNICALL *PushLocalFrame)
258
                        (JNIEnv *env, jint capacity);
259
                jobject(JNICALL *PopLocalFrame)
260
                        (JNIEnv *env, jobject result);
261

    
262
                jobject(JNICALL *NewGlobalRef)
263
                        (JNIEnv *env, jobject lobj);
264
                void (JNICALL *DeleteGlobalRef)
265
                        (JNIEnv *env, jobject gref);
266
                void (JNICALL *DeleteLocalRef)
267
                        (JNIEnv *env, jobject obj);
268
                jboolean(JNICALL *IsSameObject)
269
                        (JNIEnv *env, jobject obj1, jobject obj2);
270
                jobject(JNICALL *NewLocalRef)
271
                        (JNIEnv *env, jobject ref);
272
                jint(JNICALL *EnsureLocalCapacity)
273
                        (JNIEnv *env, jint capacity);
274

    
275
                jobject(JNICALL *AllocObject)
276
                        (JNIEnv *env, jclass clazz);
277
                jobject(JNICALL *NewObject)
278
                        (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
279
                jobject(JNICALL *NewObjectV)
280
                        (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
281
                jobject(JNICALL *NewObjectA)
282
                        (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
283

    
284
                jclass(JNICALL *GetObjectClass)
285
                        (JNIEnv *env, jobject obj);
286
                jboolean(JNICALL *IsInstanceOf)
287
                        (JNIEnv *env, jobject obj, jclass clazz);
288

    
289
                jmethodID(JNICALL *GetMethodID)
290
                        (JNIEnv *env, jclass clazz, const char *name, const char *sig);
291

    
292
                jobject(JNICALL *CallObjectMethod)
293
                        (JNIEnv *env, jobject obj, jmethodID methodID, ...);
294
                jobject(JNICALL *CallObjectMethodV)
295
                        (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
296
                jobject(JNICALL *CallObjectMethodA)
297
                        (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue * args);
298

    
299
                jboolean(JNICALL *CallBooleanMethod)
300
                        (JNIEnv *env, jobject obj, jmethodID methodID, ...);
301
                jboolean(JNICALL *CallBooleanMethodV)
302
                        (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
303
                jboolean(JNICALL *CallBooleanMethodA)
304
                        (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue * args);
305

    
306
                jbyte(JNICALL *CallByteMethod)
307
                        (JNIEnv *env, jobject obj, jmethodID methodID, ...);
308
                jbyte(JNICALL *CallByteMethodV)
309
                        (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
310
                jbyte(JNICALL *CallByteMethodA)
311
                        (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);
312

    
313
                jchar(JNICALL *CallCharMethod)
314
                        (JNIEnv *env, jobject obj, jmethodID methodID, ...);
315
                jchar(JNICALL *CallCharMethodV)
316
                        (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
317
                jchar(JNICALL *CallCharMethodA)
318
                        (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);
319

    
320
                jshort(JNICALL *CallShortMethod)
321
                        (JNIEnv *env, jobject obj, jmethodID methodID, ...);
322
                jshort(JNICALL *CallShortMethodV)
323
                        (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
324
                jshort(JNICALL *CallShortMethodA)
325
                        (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);
326

    
327
                jint(JNICALL *CallIntMethod)
328
                        (JNIEnv *env, jobject obj, jmethodID methodID, ...);
329
                jint(JNICALL *CallIntMethodV)
330
                        (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
331
                jint(JNICALL *CallIntMethodA)
332
                        (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);
333

    
334
                jlong(JNICALL *CallLongMethod)
335
                        (JNIEnv *env, jobject obj, jmethodID methodID, ...);
336
                jlong(JNICALL *CallLongMethodV)
337
                        (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
338
                jlong(JNICALL *CallLongMethodA)
339
                        (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);
340

    
341
                jfloat(JNICALL *CallFloatMethod)
342
                        (JNIEnv *env, jobject obj, jmethodID methodID, ...);
343
                jfloat(JNICALL *CallFloatMethodV)
344
                        (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
345
                jfloat(JNICALL *CallFloatMethodA)
346
                        (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);
347

    
348
                jdouble(JNICALL *CallDoubleMethod)
349
                        (JNIEnv *env, jobject obj, jmethodID methodID, ...);
350
                jdouble(JNICALL *CallDoubleMethodV)
351
                        (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
352
                jdouble(JNICALL *CallDoubleMethodA)
353
                        (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);
354

    
355
                void (JNICALL *CallVoidMethod)
356
                        (JNIEnv *env, jobject obj, jmethodID methodID, ...);
357
                void (JNICALL *CallVoidMethodV)
358
                        (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
359
                void (JNICALL *CallVoidMethodA)
360
                        (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue * args);
361

    
362
                jobject(JNICALL *CallNonvirtualObjectMethod)
363
                        (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
364
                jobject(JNICALL *CallNonvirtualObjectMethodV)
365
                        (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
366
                                va_list args);
367
                jobject(JNICALL *CallNonvirtualObjectMethodA)
368
                        (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
369
                                const jvalue * args);
370

    
371
                jboolean(JNICALL *CallNonvirtualBooleanMethod)
372
                        (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
373
                jboolean(JNICALL *CallNonvirtualBooleanMethodV)
374
                        (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
375
                                va_list args);
376
                jboolean(JNICALL *CallNonvirtualBooleanMethodA)
377
                        (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
378
                                const jvalue * args);
379

    
380
                jbyte(JNICALL *CallNonvirtualByteMethod)
381
                        (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
382
                jbyte(JNICALL *CallNonvirtualByteMethodV)
383
                        (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
384
                                va_list args);
385
                jbyte(JNICALL *CallNonvirtualByteMethodA)
386
                        (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
387
                                const jvalue *args);
388

    
389
                jchar(JNICALL *CallNonvirtualCharMethod)
390
                        (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
391
                jchar(JNICALL *CallNonvirtualCharMethodV)
392
                        (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
393
                                va_list args);
394
                jchar(JNICALL *CallNonvirtualCharMethodA)
395
                        (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
396
                                const jvalue *args);
397

    
398
                jshort(JNICALL *CallNonvirtualShortMethod)
399
                        (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
400
                jshort(JNICALL *CallNonvirtualShortMethodV)
401
                        (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
402
                                va_list args);
403
                jshort(JNICALL *CallNonvirtualShortMethodA)
404
                        (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
405
                                const jvalue *args);
406

    
407
                jint(JNICALL *CallNonvirtualIntMethod)
408
                        (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
409
                jint(JNICALL *CallNonvirtualIntMethodV)
410
                        (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
411
                                va_list args);
412
                jint(JNICALL *CallNonvirtualIntMethodA)
413
                        (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
414
                                const jvalue *args);
415

    
416
                jlong(JNICALL *CallNonvirtualLongMethod)
417
                        (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
418
                jlong(JNICALL *CallNonvirtualLongMethodV)
419
                        (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
420
                                va_list args);
421
                jlong(JNICALL *CallNonvirtualLongMethodA)
422
                        (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
423
                                const jvalue *args);
424

    
425
                jfloat(JNICALL *CallNonvirtualFloatMethod)
426
                        (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
427
                jfloat(JNICALL *CallNonvirtualFloatMethodV)
428
                        (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
429
                                va_list args);
430
                jfloat(JNICALL *CallNonvirtualFloatMethodA)
431
                        (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
432
                                const jvalue *args);
433

    
434
                jdouble(JNICALL *CallNonvirtualDoubleMethod)
435
                        (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
436
                jdouble(JNICALL *CallNonvirtualDoubleMethodV)
437
                        (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
438
                                va_list args);
439
                jdouble(JNICALL *CallNonvirtualDoubleMethodA)
440
                        (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
441
                                const jvalue *args);
442

    
443
                void (JNICALL *CallNonvirtualVoidMethod)
444
                        (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
445
                void (JNICALL *CallNonvirtualVoidMethodV)
446
                        (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
447
                                va_list args);
448
                void (JNICALL *CallNonvirtualVoidMethodA)
449
                        (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
450
                                const jvalue * args);
451

    
452
                jfieldID(JNICALL *GetFieldID)
453
                        (JNIEnv *env, jclass clazz, const char *name, const char *sig);
454

    
455
                jobject(JNICALL *GetObjectField)
456
                        (JNIEnv *env, jobject obj, jfieldID fieldID);
457
                jboolean(JNICALL *GetBooleanField)
458
                        (JNIEnv *env, jobject obj, jfieldID fieldID);
459
                jbyte(JNICALL *GetByteField)
460
                        (JNIEnv *env, jobject obj, jfieldID fieldID);
461
                jchar(JNICALL *GetCharField)
462
                        (JNIEnv *env, jobject obj, jfieldID fieldID);
463
                jshort(JNICALL *GetShortField)
464
                        (JNIEnv *env, jobject obj, jfieldID fieldID);
465
                jint(JNICALL *GetIntField)
466
                        (JNIEnv *env, jobject obj, jfieldID fieldID);
467
                jlong(JNICALL *GetLongField)
468
                        (JNIEnv *env, jobject obj, jfieldID fieldID);
469
                jfloat(JNICALL *GetFloatField)
470
                        (JNIEnv *env, jobject obj, jfieldID fieldID);
471
                jdouble(JNICALL *GetDoubleField)
472
                        (JNIEnv *env, jobject obj, jfieldID fieldID);
473

    
474
                void (JNICALL *SetObjectField)
475
                        (JNIEnv *env, jobject obj, jfieldID fieldID, jobject val);
476
                void (JNICALL *SetBooleanField)
477
                        (JNIEnv *env, jobject obj, jfieldID fieldID, jboolean val);
478
                void (JNICALL *SetByteField)
479
                        (JNIEnv *env, jobject obj, jfieldID fieldID, jbyte val);
480
                void (JNICALL *SetCharField)
481
                        (JNIEnv *env, jobject obj, jfieldID fieldID, jchar val);
482
                void (JNICALL *SetShortField)
483
                        (JNIEnv *env, jobject obj, jfieldID fieldID, jshort val);
484
                void (JNICALL *SetIntField)
485
                        (JNIEnv *env, jobject obj, jfieldID fieldID, jint val);
486
                void (JNICALL *SetLongField)
487
                        (JNIEnv *env, jobject obj, jfieldID fieldID, jlong val);
488
                void (JNICALL *SetFloatField)
489
                        (JNIEnv *env, jobject obj, jfieldID fieldID, jfloat val);
490
                void (JNICALL *SetDoubleField)
491
                        (JNIEnv *env, jobject obj, jfieldID fieldID, jdouble val);
492

    
493
                jmethodID(JNICALL *GetStaticMethodID)
494
                        (JNIEnv *env, jclass clazz, const char *name, const char *sig);
495

    
496
                jobject(JNICALL *CallStaticObjectMethod)
497
                        (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
498
                jobject(JNICALL *CallStaticObjectMethodV)
499
                        (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
500
                jobject(JNICALL *CallStaticObjectMethodA)
501
                        (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
502

    
503
                jboolean(JNICALL *CallStaticBooleanMethod)
504
                        (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
505
                jboolean(JNICALL *CallStaticBooleanMethodV)
506
                        (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
507
                jboolean(JNICALL *CallStaticBooleanMethodA)
508
                        (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
509

    
510
                jbyte(JNICALL *CallStaticByteMethod)
511
                        (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
512
                jbyte(JNICALL *CallStaticByteMethodV)
513
                        (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
514
                jbyte(JNICALL *CallStaticByteMethodA)
515
                        (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
516

    
517
                jchar(JNICALL *CallStaticCharMethod)
518
                        (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
519
                jchar(JNICALL *CallStaticCharMethodV)
520
                        (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
521
                jchar(JNICALL *CallStaticCharMethodA)
522
                        (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
523

    
524
                jshort(JNICALL *CallStaticShortMethod)
525
                        (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
526
                jshort(JNICALL *CallStaticShortMethodV)
527
                        (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
528
                jshort(JNICALL *CallStaticShortMethodA)
529
                        (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
530

    
531
                jint(JNICALL *CallStaticIntMethod)
532
                        (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
533
                jint(JNICALL *CallStaticIntMethodV)
534
                        (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
535
                jint(JNICALL *CallStaticIntMethodA)
536
                        (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
537

    
538
                jlong(JNICALL *CallStaticLongMethod)
539
                        (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
540
                jlong(JNICALL *CallStaticLongMethodV)
541
                        (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
542
                jlong(JNICALL *CallStaticLongMethodA)
543
                        (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
544

    
545
                jfloat(JNICALL *CallStaticFloatMethod)
546
                        (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
547
                jfloat(JNICALL *CallStaticFloatMethodV)
548
                        (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
549
                jfloat(JNICALL *CallStaticFloatMethodA)
550
                        (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
551

    
552
                jdouble(JNICALL *CallStaticDoubleMethod)
553
                        (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
554
                jdouble(JNICALL *CallStaticDoubleMethodV)
555
                        (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
556
                jdouble(JNICALL *CallStaticDoubleMethodA)
557
                        (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
558

    
559
                void (JNICALL *CallStaticVoidMethod)
560
                        (JNIEnv *env, jclass cls, jmethodID methodID, ...);
561
                void (JNICALL *CallStaticVoidMethodV)
562
                        (JNIEnv *env, jclass cls, jmethodID methodID, va_list args);
563
                void (JNICALL *CallStaticVoidMethodA)
564
                        (JNIEnv *env, jclass cls, jmethodID methodID, const jvalue * args);
565

    
566
                jfieldID(JNICALL *GetStaticFieldID)
567
                        (JNIEnv *env, jclass clazz, const char *name, const char *sig);
568
                jobject(JNICALL *GetStaticObjectField)
569
                        (JNIEnv *env, jclass clazz, jfieldID fieldID);
570
                jboolean(JNICALL *GetStaticBooleanField)
571
                        (JNIEnv *env, jclass clazz, jfieldID fieldID);
572
                jbyte(JNICALL *GetStaticByteField)
573
                        (JNIEnv *env, jclass clazz, jfieldID fieldID);
574
                jchar(JNICALL *GetStaticCharField)
575
                        (JNIEnv *env, jclass clazz, jfieldID fieldID);
576
                jshort(JNICALL *GetStaticShortField)
577
                        (JNIEnv *env, jclass clazz, jfieldID fieldID);
578
                jint(JNICALL *GetStaticIntField)
579
                        (JNIEnv *env, jclass clazz, jfieldID fieldID);
580
                jlong(JNICALL *GetStaticLongField)
581
                        (JNIEnv *env, jclass clazz, jfieldID fieldID);
582
                jfloat(JNICALL *GetStaticFloatField)
583
                        (JNIEnv *env, jclass clazz, jfieldID fieldID);
584
                jdouble(JNICALL *GetStaticDoubleField)
585
                        (JNIEnv *env, jclass clazz, jfieldID fieldID);
586

    
587
                void (JNICALL *SetStaticObjectField)
588
                        (JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value);
589
                void (JNICALL *SetStaticBooleanField)
590
                        (JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value);
591
                void (JNICALL *SetStaticByteField)
592
                        (JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value);
593
                void (JNICALL *SetStaticCharField)
594
                        (JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value);
595
                void (JNICALL *SetStaticShortField)
596
                        (JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value);
597
                void (JNICALL *SetStaticIntField)
598
                        (JNIEnv *env, jclass clazz, jfieldID fieldID, jint value);
599
                void (JNICALL *SetStaticLongField)
600
                        (JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value);
601
                void (JNICALL *SetStaticFloatField)
602
                        (JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value);
603
                void (JNICALL *SetStaticDoubleField)
604
                        (JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value);
605

    
606
                jstring(JNICALL *NewString)
607
                        (JNIEnv *env, const jchar *unicode, jsize len);
608
                jsize(JNICALL *GetStringLength)
609
                        (JNIEnv *env, jstring str);
610
                const jchar *(JNICALL *GetStringChars)
611
                        (JNIEnv *env, jstring str, jboolean *isCopy);
612
                void (JNICALL *ReleaseStringChars)
613
                        (JNIEnv *env, jstring str, const jchar *chars);
614

    
615
                jstring(JNICALL *NewStringUTF)
616
                        (JNIEnv *env, const char *utf);
617
                jsize(JNICALL *GetStringUTFLength)
618
                        (JNIEnv *env, jstring str);
619
                const char* (JNICALL *GetStringUTFChars)
620
                        (JNIEnv *env, jstring str, jboolean *isCopy);
621
                void (JNICALL *ReleaseStringUTFChars)
622
                        (JNIEnv *env, jstring str, const char* chars);
623

    
624

    
625
                jsize(JNICALL *GetArrayLength)
626
                        (JNIEnv *env, jarray array);
627

    
628
                jobjectArray(JNICALL *NewObjectArray)
629
                        (JNIEnv *env, jsize len, jclass clazz, jobject init);
630
                jobject(JNICALL *GetObjectArrayElement)
631
                        (JNIEnv *env, jobjectArray array, jsize index);
632
                void (JNICALL *SetObjectArrayElement)
633
                        (JNIEnv *env, jobjectArray array, jsize index, jobject val);
634

    
635
                jbooleanArray(JNICALL *NewBooleanArray)
636
                        (JNIEnv *env, jsize len);
637
                jbyteArray(JNICALL *NewByteArray)
638
                        (JNIEnv *env, jsize len);
639
                jcharArray(JNICALL *NewCharArray)
640
                        (JNIEnv *env, jsize len);
641
                jshortArray(JNICALL *NewShortArray)
642
                        (JNIEnv *env, jsize len);
643
                jintArray(JNICALL *NewIntArray)
644
                        (JNIEnv *env, jsize len);
645
                jlongArray(JNICALL *NewLongArray)
646
                        (JNIEnv *env, jsize len);
647
                jfloatArray(JNICALL *NewFloatArray)
648
                        (JNIEnv *env, jsize len);
649
                jdoubleArray(JNICALL *NewDoubleArray)
650
                        (JNIEnv *env, jsize len);
651

    
652
                jboolean * (JNICALL *GetBooleanArrayElements)
653
                        (JNIEnv *env, jbooleanArray array, jboolean *isCopy);
654
                jbyte * (JNICALL *GetByteArrayElements)
655
                        (JNIEnv *env, jbyteArray array, jboolean *isCopy);
656
                jchar * (JNICALL *GetCharArrayElements)
657
                        (JNIEnv *env, jcharArray array, jboolean *isCopy);
658
                jshort * (JNICALL *GetShortArrayElements)
659
                        (JNIEnv *env, jshortArray array, jboolean *isCopy);
660
                jint * (JNICALL *GetIntArrayElements)
661
                        (JNIEnv *env, jintArray array, jboolean *isCopy);
662
                jlong * (JNICALL *GetLongArrayElements)
663
                        (JNIEnv *env, jlongArray array, jboolean *isCopy);
664
                jfloat * (JNICALL *GetFloatArrayElements)
665
                        (JNIEnv *env, jfloatArray array, jboolean *isCopy);
666
                jdouble * (JNICALL *GetDoubleArrayElements)
667
                        (JNIEnv *env, jdoubleArray array, jboolean *isCopy);
668

    
669
                void (JNICALL *ReleaseBooleanArrayElements)
670
                        (JNIEnv *env, jbooleanArray array, jboolean *elems, jint mode);
671
                void (JNICALL *ReleaseByteArrayElements)
672
                        (JNIEnv *env, jbyteArray array, jbyte *elems, jint mode);
673
                void (JNICALL *ReleaseCharArrayElements)
674
                        (JNIEnv *env, jcharArray array, jchar *elems, jint mode);
675
                void (JNICALL *ReleaseShortArrayElements)
676
                        (JNIEnv *env, jshortArray array, jshort *elems, jint mode);
677
                void (JNICALL *ReleaseIntArrayElements)
678
                        (JNIEnv *env, jintArray array, jint *elems, jint mode);
679
                void (JNICALL *ReleaseLongArrayElements)
680
                        (JNIEnv *env, jlongArray array, jlong *elems, jint mode);
681
                void (JNICALL *ReleaseFloatArrayElements)
682
                        (JNIEnv *env, jfloatArray array, jfloat *elems, jint mode);
683
                void (JNICALL *ReleaseDoubleArrayElements)
684
                        (JNIEnv *env, jdoubleArray array, jdouble *elems, jint mode);
685

    
686
                void (JNICALL *GetBooleanArrayRegion)
687
                        (JNIEnv *env, jbooleanArray array, jsize start, jsize l, jboolean *buf);
688
                void (JNICALL *GetByteArrayRegion)
689
                        (JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf);
690
                void (JNICALL *GetCharArrayRegion)
691
                        (JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf);
692
                void (JNICALL *GetShortArrayRegion)
693
                        (JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf);
694
                void (JNICALL *GetIntArrayRegion)
695
                        (JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf);
696
                void (JNICALL *GetLongArrayRegion)
697
                        (JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf);
698
                void (JNICALL *GetFloatArrayRegion)
699
                        (JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf);
700
                void (JNICALL *GetDoubleArrayRegion)
701
                        (JNIEnv *env, jdoubleArray array, jsize start, jsize len, jdouble *buf);
702

    
703
                void (JNICALL *SetBooleanArrayRegion)
704
                        (JNIEnv *env, jbooleanArray array, jsize start, jsize l, const jboolean *buf);
705
                void (JNICALL *SetByteArrayRegion)
706
                        (JNIEnv *env, jbyteArray array, jsize start, jsize len, const jbyte *buf);
707
                void (JNICALL *SetCharArrayRegion)
708
                        (JNIEnv *env, jcharArray array, jsize start, jsize len, const jchar *buf);
709
                void (JNICALL *SetShortArrayRegion)
710
                        (JNIEnv *env, jshortArray array, jsize start, jsize len, const jshort *buf);
711
                void (JNICALL *SetIntArrayRegion)
712
                        (JNIEnv *env, jintArray array, jsize start, jsize len, const jint *buf);
713
                void (JNICALL *SetLongArrayRegion)
714
                        (JNIEnv *env, jlongArray array, jsize start, jsize len, const jlong *buf);
715
                void (JNICALL *SetFloatArrayRegion)
716
                        (JNIEnv *env, jfloatArray array, jsize start, jsize len, const jfloat *buf);
717
                void (JNICALL *SetDoubleArrayRegion)
718
                        (JNIEnv *env, jdoubleArray array, jsize start, jsize len, const jdouble *buf);
719

    
720
                jint(JNICALL *RegisterNatives)
721
                        (JNIEnv *env, jclass clazz, const JNINativeMethod *methods,
722
                                jint nMethods);
723
                jint(JNICALL *UnregisterNatives)
724
                        (JNIEnv *env, jclass clazz);
725

    
726
                jint(JNICALL *MonitorEnter)
727
                        (JNIEnv *env, jobject obj);
728
                jint(JNICALL *MonitorExit)
729
                        (JNIEnv *env, jobject obj);
730

    
731
                jint(JNICALL *GetJavaVM)
732
                        (JNIEnv *env, JavaVM **vm);
733

    
734
                void (JNICALL *GetStringRegion)
735
                        (JNIEnv *env, jstring str, jsize start, jsize len, jchar *buf);
736
                void (JNICALL *GetStringUTFRegion)
737
                        (JNIEnv *env, jstring str, jsize start, jsize len, char *buf);
738

    
739
                void * (JNICALL *GetPrimitiveArrayCritical)
740
                        (JNIEnv *env, jarray array, jboolean *isCopy);
741
                void (JNICALL *ReleasePrimitiveArrayCritical)
742
                        (JNIEnv *env, jarray array, void *carray, jint mode);
743

    
744
                const jchar * (JNICALL *GetStringCritical)
745
                        (JNIEnv *env, jstring string, jboolean *isCopy);
746
                void (JNICALL *ReleaseStringCritical)
747
                        (JNIEnv *env, jstring string, const jchar *cstring);
748

    
749
                jweak(JNICALL *NewWeakGlobalRef)
750
                        (JNIEnv *env, jobject obj);
751
                void (JNICALL *DeleteWeakGlobalRef)
752
                        (JNIEnv *env, jweak ref);
753

    
754
                jboolean(JNICALL *ExceptionCheck)
755
                        (JNIEnv *env);
756

    
757
                jobject(JNICALL *NewDirectByteBuffer)
758
                        (JNIEnv* env, void* address, jlong capacity);
759
                void* (JNICALL *GetDirectBufferAddress)
760
                        (JNIEnv* env, jobject buf);
761
                jlong(JNICALL *GetDirectBufferCapacity)
762
                        (JNIEnv* env, jobject buf);
763

    
764
                /* New JNI 1.6 Features */
765

    
766
                jobjectRefType(JNICALL *GetObjectRefType)
767
                        (JNIEnv* env, jobject obj);
768
        };
769

    
770
        /*
771
        * We use inlined functions for C++ so that programmers can write:
772
        *
773
        *    env->FindClass("java/lang/String")
774
        *
775
        * in C++ rather than:
776
        *
777
        *    (*env)->FindClass(env, "java/lang/String")
778
        *
779
        * in C.
780
        */
781

    
782
        struct JNIEnv_ {
783
                const struct JNINativeInterface_ *functions;
784
#ifdef __cplusplus
785

    
786
                jint GetVersion() {
787
                        return functions->GetVersion(this);
788
                }
789
                jclass DefineClass(const char *name, jobject loader, const jbyte *buf,
790
                        jsize len) {
791
                        return functions->DefineClass(this, name, loader, buf, len);
792
                }
793
                jclass FindClass(const char *name) {
794
                        return functions->FindClass(this, name);
795
                }
796
                jmethodID FromReflectedMethod(jobject method) {
797
                        return functions->FromReflectedMethod(this, method);
798
                }
799
                jfieldID FromReflectedField(jobject field) {
800
                        return functions->FromReflectedField(this, field);
801
                }
802

    
803
                jobject ToReflectedMethod(jclass cls, jmethodID methodID, jboolean isStatic) {
804
                        return functions->ToReflectedMethod(this, cls, methodID, isStatic);
805
                }
806

    
807
                jclass GetSuperclass(jclass sub) {
808
                        return functions->GetSuperclass(this, sub);
809
                }
810
                jboolean IsAssignableFrom(jclass sub, jclass sup) {
811
                        return functions->IsAssignableFrom(this, sub, sup);
812
                }
813

    
814
                jobject ToReflectedField(jclass cls, jfieldID fieldID, jboolean isStatic) {
815
                        return functions->ToReflectedField(this, cls, fieldID, isStatic);
816
                }
817

    
818
                jint Throw(jthrowable obj) {
819
                        return functions->Throw(this, obj);
820
                }
821
                jint ThrowNew(jclass clazz, const char *msg) {
822
                        return functions->ThrowNew(this, clazz, msg);
823
                }
824
                jthrowable ExceptionOccurred() {
825
                        return functions->ExceptionOccurred(this);
826
                }
827
                void ExceptionDescribe() {
828
                        functions->ExceptionDescribe(this);
829
                }
830
                void ExceptionClear() {
831
                        functions->ExceptionClear(this);
832
                }
833
                void FatalError(const char *msg) {
834
                        functions->FatalError(this, msg);
835
                }
836

    
837
                jint PushLocalFrame(jint capacity) {
838
                        return functions->PushLocalFrame(this, capacity);
839
                }
840
                jobject PopLocalFrame(jobject result) {
841
                        return functions->PopLocalFrame(this, result);
842
                }
843

    
844
                jobject NewGlobalRef(jobject lobj) {
845
                        return functions->NewGlobalRef(this, lobj);
846
                }
847
                void DeleteGlobalRef(jobject gref) {
848
                        functions->DeleteGlobalRef(this, gref);
849
                }
850
                void DeleteLocalRef(jobject obj) {
851
                        functions->DeleteLocalRef(this, obj);
852
                }
853

    
854
                jboolean IsSameObject(jobject obj1, jobject obj2) {
855
                        return functions->IsSameObject(this, obj1, obj2);
856
                }
857

    
858
                jobject NewLocalRef(jobject ref) {
859
                        return functions->NewLocalRef(this, ref);
860
                }
861
                jint EnsureLocalCapacity(jint capacity) {
862
                        return functions->EnsureLocalCapacity(this, capacity);
863
                }
864

    
865
                jobject AllocObject(jclass clazz) {
866
                        return functions->AllocObject(this, clazz);
867
                }
868
                jobject NewObject(jclass clazz, jmethodID methodID, ...) {
869
                        va_list args;
870
                        jobject result;
871
                        va_start(args, methodID);
872
                        result = functions->NewObjectV(this, clazz, methodID, args);
873
                        va_end(args);
874
                        return result;
875
                }
876
                jobject NewObjectV(jclass clazz, jmethodID methodID,
877
                        va_list args) {
878
                        return functions->NewObjectV(this, clazz, methodID, args);
879
                }
880
                jobject NewObjectA(jclass clazz, jmethodID methodID,
881
                        const jvalue *args) {
882
                        return functions->NewObjectA(this, clazz, methodID, args);
883
                }
884

    
885
                jclass GetObjectClass(jobject obj) {
886
                        return functions->GetObjectClass(this, obj);
887
                }
888
                jboolean IsInstanceOf(jobject obj, jclass clazz) {
889
                        return functions->IsInstanceOf(this, obj, clazz);
890
                }
891

    
892
                jmethodID GetMethodID(jclass clazz, const char *name,
893
                        const char *sig) {
894
                        return functions->GetMethodID(this, clazz, name, sig);
895
                }
896

    
897
                jobject CallObjectMethod(jobject obj, jmethodID methodID, ...) {
898
                        va_list args;
899
                        jobject result;
900
                        va_start(args, methodID);
901
                        result = functions->CallObjectMethodV(this, obj, methodID, args);
902
                        va_end(args);
903
                        return result;
904
                }
905
                jobject CallObjectMethodV(jobject obj, jmethodID methodID,
906
                        va_list args) {
907
                        return functions->CallObjectMethodV(this, obj, methodID, args);
908
                }
909
                jobject CallObjectMethodA(jobject obj, jmethodID methodID,
910
                        const jvalue * args) {
911
                        return functions->CallObjectMethodA(this, obj, methodID, args);
912
                }
913

    
914
                jboolean CallBooleanMethod(jobject obj,
915
                        jmethodID methodID, ...) {
916
                        va_list args;
917
                        jboolean result;
918
                        va_start(args, methodID);
919
                        result = functions->CallBooleanMethodV(this, obj, methodID, args);
920
                        va_end(args);
921
                        return result;
922
                }
923
                jboolean CallBooleanMethodV(jobject obj, jmethodID methodID,
924
                        va_list args) {
925
                        return functions->CallBooleanMethodV(this, obj, methodID, args);
926
                }
927
                jboolean CallBooleanMethodA(jobject obj, jmethodID methodID,
928
                        const jvalue * args) {
929
                        return functions->CallBooleanMethodA(this, obj, methodID, args);
930
                }
931

    
932
                jbyte CallByteMethod(jobject obj, jmethodID methodID, ...) {
933
                        va_list args;
934
                        jbyte result;
935
                        va_start(args, methodID);
936
                        result = functions->CallByteMethodV(this, obj, methodID, args);
937
                        va_end(args);
938
                        return result;
939
                }
940
                jbyte CallByteMethodV(jobject obj, jmethodID methodID,
941
                        va_list args) {
942
                        return functions->CallByteMethodV(this, obj, methodID, args);
943
                }
944
                jbyte CallByteMethodA(jobject obj, jmethodID methodID,
945
                        const jvalue * args) {
946
                        return functions->CallByteMethodA(this, obj, methodID, args);
947
                }
948

    
949
                jchar CallCharMethod(jobject obj, jmethodID methodID, ...) {
950
                        va_list args;
951
                        jchar result;
952
                        va_start(args, methodID);
953
                        result = functions->CallCharMethodV(this, obj, methodID, args);
954
                        va_end(args);
955
                        return result;
956
                }
957
                jchar CallCharMethodV(jobject obj, jmethodID methodID,
958
                        va_list args) {
959
                        return functions->CallCharMethodV(this, obj, methodID, args);
960
                }
961
                jchar CallCharMethodA(jobject obj, jmethodID methodID,
962
                        const jvalue * args) {
963
                        return functions->CallCharMethodA(this, obj, methodID, args);
964
                }
965

    
966
                jshort CallShortMethod(jobject obj, jmethodID methodID, ...) {
967
                        va_list args;
968
                        jshort result;
969
                        va_start(args, methodID);
970
                        result = functions->CallShortMethodV(this, obj, methodID, args);
971
                        va_end(args);
972
                        return result;
973
                }
974
                jshort CallShortMethodV(jobject obj, jmethodID methodID,
975
                        va_list args) {
976
                        return functions->CallShortMethodV(this, obj, methodID, args);
977
                }
978
                jshort CallShortMethodA(jobject obj, jmethodID methodID,
979
                        const jvalue * args) {
980
                        return functions->CallShortMethodA(this, obj, methodID, args);
981
                }
982

    
983
                jint CallIntMethod(jobject obj, jmethodID methodID, ...) {
984
                        va_list args;
985
                        jint result;
986
                        va_start(args, methodID);
987
                        result = functions->CallIntMethodV(this, obj, methodID, args);
988
                        va_end(args);
989
                        return result;
990
                }
991
                jint CallIntMethodV(jobject obj, jmethodID methodID,
992
                        va_list args) {
993
                        return functions->CallIntMethodV(this, obj, methodID, args);
994
                }
995
                jint CallIntMethodA(jobject obj, jmethodID methodID,
996
                        const jvalue * args) {
997
                        return functions->CallIntMethodA(this, obj, methodID, args);
998
                }
999

    
1000
                jlong CallLongMethod(jobject obj, jmethodID methodID, ...) {
1001
                        va_list args;
1002
                        jlong result;
1003
                        va_start(args, methodID);
1004
                        result = functions->CallLongMethodV(this, obj, methodID, args);
1005
                        va_end(args);
1006
                        return result;
1007
                }
1008
                jlong CallLongMethodV(jobject obj, jmethodID methodID,
1009
                        va_list args) {
1010
                        return functions->CallLongMethodV(this, obj, methodID, args);
1011
                }
1012
                jlong CallLongMethodA(jobject obj, jmethodID methodID,
1013
                        const jvalue * args) {
1014
                        return functions->CallLongMethodA(this, obj, methodID, args);
1015
                }
1016

    
1017
                jfloat CallFloatMethod(jobject obj, jmethodID methodID, ...) {
1018
                        va_list args;
1019
                        jfloat result;
1020
                        va_start(args, methodID);
1021
                        result = functions->CallFloatMethodV(this, obj, methodID, args);
1022
                        va_end(args);
1023
                        return result;
1024
                }
1025
                jfloat CallFloatMethodV(jobject obj, jmethodID methodID,
1026
                        va_list args) {
1027
                        return functions->CallFloatMethodV(this, obj, methodID, args);
1028
                }
1029
                jfloat CallFloatMethodA(jobject obj, jmethodID methodID,
1030
                        const jvalue * args) {
1031
                        return functions->CallFloatMethodA(this, obj, methodID, args);
1032
                }
1033

    
1034
                jdouble CallDoubleMethod(jobject obj, jmethodID methodID, ...) {
1035
                        va_list args;
1036
                        jdouble result;
1037
                        va_start(args, methodID);
1038
                        result = functions->CallDoubleMethodV(this, obj, methodID, args);
1039
                        va_end(args);
1040
                        return result;
1041
                }
1042
                jdouble CallDoubleMethodV(jobject obj, jmethodID methodID,
1043
                        va_list args) {
1044
                        return functions->CallDoubleMethodV(this, obj, methodID, args);
1045
                }
1046
                jdouble CallDoubleMethodA(jobject obj, jmethodID methodID,
1047
                        const jvalue * args) {
1048
                        return functions->CallDoubleMethodA(this, obj, methodID, args);
1049
                }
1050

    
1051
                void CallVoidMethod(jobject obj, jmethodID methodID, ...) {
1052
                        va_list args;
1053
                        va_start(args, methodID);
1054
                        functions->CallVoidMethodV(this, obj, methodID, args);
1055
                        va_end(args);
1056
                }
1057
                void CallVoidMethodV(jobject obj, jmethodID methodID,
1058
                        va_list args) {
1059
                        functions->CallVoidMethodV(this, obj, methodID, args);
1060
                }
1061
                void CallVoidMethodA(jobject obj, jmethodID methodID,
1062
                        const jvalue * args) {
1063
                        functions->CallVoidMethodA(this, obj, methodID, args);
1064
                }
1065

    
1066
                jobject CallNonvirtualObjectMethod(jobject obj, jclass clazz,
1067
                        jmethodID methodID, ...) {
1068
                        va_list args;
1069
                        jobject result;
1070
                        va_start(args, methodID);
1071
                        result = functions->CallNonvirtualObjectMethodV(this, obj, clazz,
1072
                                methodID, args);
1073
                        va_end(args);
1074
                        return result;
1075
                }
1076
                jobject CallNonvirtualObjectMethodV(jobject obj, jclass clazz,
1077
                        jmethodID methodID, va_list args) {
1078
                        return functions->CallNonvirtualObjectMethodV(this, obj, clazz,
1079
                                methodID, args);
1080
                }
1081
                jobject CallNonvirtualObjectMethodA(jobject obj, jclass clazz,
1082
                        jmethodID methodID, const jvalue * args) {
1083
                        return functions->CallNonvirtualObjectMethodA(this, obj, clazz,
1084
                                methodID, args);
1085
                }
1086

    
1087
                jboolean CallNonvirtualBooleanMethod(jobject obj, jclass clazz,
1088
                        jmethodID methodID, ...) {
1089
                        va_list args;
1090
                        jboolean result;
1091
                        va_start(args, methodID);
1092
                        result = functions->CallNonvirtualBooleanMethodV(this, obj, clazz,
1093
                                methodID, args);
1094
                        va_end(args);
1095
                        return result;
1096
                }
1097
                jboolean CallNonvirtualBooleanMethodV(jobject obj, jclass clazz,
1098
                        jmethodID methodID, va_list args) {
1099
                        return functions->CallNonvirtualBooleanMethodV(this, obj, clazz,
1100
                                methodID, args);
1101
                }
1102
                jboolean CallNonvirtualBooleanMethodA(jobject obj, jclass clazz,
1103
                        jmethodID methodID, const jvalue * args) {
1104
                        return functions->CallNonvirtualBooleanMethodA(this, obj, clazz,
1105
                                methodID, args);
1106
                }
1107

    
1108
                jbyte CallNonvirtualByteMethod(jobject obj, jclass clazz,
1109
                        jmethodID methodID, ...) {
1110
                        va_list args;
1111
                        jbyte result;
1112
                        va_start(args, methodID);
1113
                        result = functions->CallNonvirtualByteMethodV(this, obj, clazz,
1114
                                methodID, args);
1115
                        va_end(args);
1116
                        return result;
1117
                }
1118
                jbyte CallNonvirtualByteMethodV(jobject obj, jclass clazz,
1119
                        jmethodID methodID, va_list args) {
1120
                        return functions->CallNonvirtualByteMethodV(this, obj, clazz,
1121
                                methodID, args);
1122
                }
1123
                jbyte CallNonvirtualByteMethodA(jobject obj, jclass clazz,
1124
                        jmethodID methodID, const jvalue * args) {
1125
                        return functions->CallNonvirtualByteMethodA(this, obj, clazz,
1126
                                methodID, args);
1127
                }
1128

    
1129
                jchar CallNonvirtualCharMethod(jobject obj, jclass clazz,
1130
                        jmethodID methodID, ...) {
1131
                        va_list args;
1132
                        jchar result;
1133
                        va_start(args, methodID);
1134
                        result = functions->CallNonvirtualCharMethodV(this, obj, clazz,
1135
                                methodID, args);
1136
                        va_end(args);
1137
                        return result;
1138
                }
1139
                jchar CallNonvirtualCharMethodV(jobject obj, jclass clazz,
1140
                        jmethodID methodID, va_list args) {
1141
                        return functions->CallNonvirtualCharMethodV(this, obj, clazz,
1142
                                methodID, args);
1143
                }
1144
                jchar CallNonvirtualCharMethodA(jobject obj, jclass clazz,
1145
                        jmethodID methodID, const jvalue * args) {
1146
                        return functions->CallNonvirtualCharMethodA(this, obj, clazz,
1147
                                methodID, args);
1148
                }
1149

    
1150
                jshort CallNonvirtualShortMethod(jobject obj, jclass clazz,
1151
                        jmethodID methodID, ...) {
1152
                        va_list args;
1153
                        jshort result;
1154
                        va_start(args, methodID);
1155
                        result = functions->CallNonvirtualShortMethodV(this, obj, clazz,
1156
                                methodID, args);
1157
                        va_end(args);
1158
                        return result;
1159
                }
1160
                jshort CallNonvirtualShortMethodV(jobject obj, jclass clazz,
1161
                        jmethodID methodID, va_list args) {
1162
                        return functions->CallNonvirtualShortMethodV(this, obj, clazz,
1163
                                methodID, args);
1164
                }
1165
                jshort CallNonvirtualShortMethodA(jobject obj, jclass clazz,
1166
                        jmethodID methodID, const jvalue * args) {
1167
                        return functions->CallNonvirtualShortMethodA(this, obj, clazz,
1168
                                methodID, args);
1169
                }
1170

    
1171
                jint CallNonvirtualIntMethod(jobject obj, jclass clazz,
1172
                        jmethodID methodID, ...) {
1173
                        va_list args;
1174
                        jint result;
1175
                        va_start(args, methodID);
1176
                        result = functions->CallNonvirtualIntMethodV(this, obj, clazz,
1177
                                methodID, args);
1178
                        va_end(args);
1179
                        return result;
1180
                }
1181
                jint CallNonvirtualIntMethodV(jobject obj, jclass clazz,
1182
                        jmethodID methodID, va_list args) {
1183
                        return functions->CallNonvirtualIntMethodV(this, obj, clazz,
1184
                                methodID, args);
1185
                }
1186
                jint CallNonvirtualIntMethodA(jobject obj, jclass clazz,
1187
                        jmethodID methodID, const jvalue * args) {
1188
                        return functions->CallNonvirtualIntMethodA(this, obj, clazz,
1189
                                methodID, args);
1190
                }
1191

    
1192
                jlong CallNonvirtualLongMethod(jobject obj, jclass clazz,
1193
                        jmethodID methodID, ...) {
1194
                        va_list args;
1195
                        jlong result;
1196
                        va_start(args, methodID);
1197
                        result = functions->CallNonvirtualLongMethodV(this, obj, clazz,
1198
                                methodID, args);
1199
                        va_end(args);
1200
                        return result;
1201
                }
1202
                jlong CallNonvirtualLongMethodV(jobject obj, jclass clazz,
1203
                        jmethodID methodID, va_list args) {
1204
                        return functions->CallNonvirtualLongMethodV(this, obj, clazz,
1205
                                methodID, args);
1206
                }
1207
                jlong CallNonvirtualLongMethodA(jobject obj, jclass clazz,
1208
                        jmethodID methodID, const jvalue * args) {
1209
                        return functions->CallNonvirtualLongMethodA(this, obj, clazz,
1210
                                methodID, args);
1211
                }
1212

    
1213
                jfloat CallNonvirtualFloatMethod(jobject obj, jclass clazz,
1214
                        jmethodID methodID, ...) {
1215
                        va_list args;
1216
                        jfloat result;
1217
                        va_start(args, methodID);
1218
                        result = functions->CallNonvirtualFloatMethodV(this, obj, clazz,
1219
                                methodID, args);
1220
                        va_end(args);
1221
                        return result;
1222
                }
1223
                jfloat CallNonvirtualFloatMethodV(jobject obj, jclass clazz,
1224
                        jmethodID methodID,
1225
                        va_list args) {
1226
                        return functions->CallNonvirtualFloatMethodV(this, obj, clazz,
1227
                                methodID, args);
1228
                }
1229
                jfloat CallNonvirtualFloatMethodA(jobject obj, jclass clazz,
1230
                        jmethodID methodID,
1231
                        const jvalue * args) {
1232
                        return functions->CallNonvirtualFloatMethodA(this, obj, clazz,
1233
                                methodID, args);
1234
                }
1235

    
1236
                jdouble CallNonvirtualDoubleMethod(jobject obj, jclass clazz,
1237
                        jmethodID methodID, ...) {
1238
                        va_list args;
1239
                        jdouble result;
1240
                        va_start(args, methodID);
1241
                        result = functions->CallNonvirtualDoubleMethodV(this, obj, clazz,
1242
                                methodID, args);
1243
                        va_end(args);
1244
                        return result;
1245
                }
1246
                jdouble CallNonvirtualDoubleMethodV(jobject obj, jclass clazz,
1247
                        jmethodID methodID,
1248
                        va_list args) {
1249
                        return functions->CallNonvirtualDoubleMethodV(this, obj, clazz,
1250
                                methodID, args);
1251
                }
1252
                jdouble CallNonvirtualDoubleMethodA(jobject obj, jclass clazz,
1253
                        jmethodID methodID,
1254
                        const jvalue * args) {
1255
                        return functions->CallNonvirtualDoubleMethodA(this, obj, clazz,
1256
                                methodID, args);
1257
                }
1258

    
1259
                void CallNonvirtualVoidMethod(jobject obj, jclass clazz,
1260
                        jmethodID methodID, ...) {
1261
                        va_list args;
1262
                        va_start(args, methodID);
1263
                        functions->CallNonvirtualVoidMethodV(this, obj, clazz, methodID, args);
1264
                        va_end(args);
1265
                }
1266
                void CallNonvirtualVoidMethodV(jobject obj, jclass clazz,
1267
                        jmethodID methodID,
1268
                        va_list args) {
1269
                        functions->CallNonvirtualVoidMethodV(this, obj, clazz, methodID, args);
1270
                }
1271
                void CallNonvirtualVoidMethodA(jobject obj, jclass clazz,
1272
                        jmethodID methodID,
1273
                        const jvalue * args) {
1274
                        functions->CallNonvirtualVoidMethodA(this, obj, clazz, methodID, args);
1275
                }
1276

    
1277
                jfieldID GetFieldID(jclass clazz, const char *name,
1278
                        const char *sig) {
1279
                        return functions->GetFieldID(this, clazz, name, sig);
1280
                }
1281

    
1282
                jobject GetObjectField(jobject obj, jfieldID fieldID) {
1283
                        return functions->GetObjectField(this, obj, fieldID);
1284
                }
1285
                jboolean GetBooleanField(jobject obj, jfieldID fieldID) {
1286
                        return functions->GetBooleanField(this, obj, fieldID);
1287
                }
1288
                jbyte GetByteField(jobject obj, jfieldID fieldID) {
1289
                        return functions->GetByteField(this, obj, fieldID);
1290
                }
1291
                jchar GetCharField(jobject obj, jfieldID fieldID) {
1292
                        return functions->GetCharField(this, obj, fieldID);
1293
                }
1294
                jshort GetShortField(jobject obj, jfieldID fieldID) {
1295
                        return functions->GetShortField(this, obj, fieldID);
1296
                }
1297
                jint GetIntField(jobject obj, jfieldID fieldID) {
1298
                        return functions->GetIntField(this, obj, fieldID);
1299
                }
1300
                jlong GetLongField(jobject obj, jfieldID fieldID) {
1301
                        return functions->GetLongField(this, obj, fieldID);
1302
                }
1303
                jfloat GetFloatField(jobject obj, jfieldID fieldID) {
1304
                        return functions->GetFloatField(this, obj, fieldID);
1305
                }
1306
                jdouble GetDoubleField(jobject obj, jfieldID fieldID) {
1307
                        return functions->GetDoubleField(this, obj, fieldID);
1308
                }
1309

    
1310
                void SetObjectField(jobject obj, jfieldID fieldID, jobject val) {
1311
                        functions->SetObjectField(this, obj, fieldID, val);
1312
                }
1313
                void SetBooleanField(jobject obj, jfieldID fieldID,
1314
                        jboolean val) {
1315
                        functions->SetBooleanField(this, obj, fieldID, val);
1316
                }
1317
                void SetByteField(jobject obj, jfieldID fieldID,
1318
                        jbyte val) {
1319
                        functions->SetByteField(this, obj, fieldID, val);
1320
                }
1321
                void SetCharField(jobject obj, jfieldID fieldID,
1322
                        jchar val) {
1323
                        functions->SetCharField(this, obj, fieldID, val);
1324
                }
1325
                void SetShortField(jobject obj, jfieldID fieldID,
1326
                        jshort val) {
1327
                        functions->SetShortField(this, obj, fieldID, val);
1328
                }
1329
                void SetIntField(jobject obj, jfieldID fieldID,
1330
                        jint val) {
1331
                        functions->SetIntField(this, obj, fieldID, val);
1332
                }
1333
                void SetLongField(jobject obj, jfieldID fieldID,
1334
                        jlong val) {
1335
                        functions->SetLongField(this, obj, fieldID, val);
1336
                }
1337
                void SetFloatField(jobject obj, jfieldID fieldID,
1338
                        jfloat val) {
1339
                        functions->SetFloatField(this, obj, fieldID, val);
1340
                }
1341
                void SetDoubleField(jobject obj, jfieldID fieldID,
1342
                        jdouble val) {
1343
                        functions->SetDoubleField(this, obj, fieldID, val);
1344
                }
1345

    
1346
                jmethodID GetStaticMethodID(jclass clazz, const char *name,
1347
                        const char *sig) {
1348
                        return functions->GetStaticMethodID(this, clazz, name, sig);
1349
                }
1350

    
1351
                jobject CallStaticObjectMethod(jclass clazz, jmethodID methodID,
1352
                        ...) {
1353
                        va_list args;
1354
                        jobject result;
1355
                        va_start(args, methodID);
1356
                        result = functions->CallStaticObjectMethodV(this, clazz, methodID, args);
1357
                        va_end(args);
1358
                        return result;
1359
                }
1360
                jobject CallStaticObjectMethodV(jclass clazz, jmethodID methodID,
1361
                        va_list args) {
1362
                        return functions->CallStaticObjectMethodV(this, clazz, methodID, args);
1363
                }
1364
                jobject CallStaticObjectMethodA(jclass clazz, jmethodID methodID,
1365
                        const jvalue *args) {
1366
                        return functions->CallStaticObjectMethodA(this, clazz, methodID, args);
1367
                }
1368

    
1369
                jboolean CallStaticBooleanMethod(jclass clazz,
1370
                        jmethodID methodID, ...) {
1371
                        va_list args;
1372
                        jboolean result;
1373
                        va_start(args, methodID);
1374
                        result = functions->CallStaticBooleanMethodV(this, clazz, methodID, args);
1375
                        va_end(args);
1376
                        return result;
1377
                }
1378
                jboolean CallStaticBooleanMethodV(jclass clazz,
1379
                        jmethodID methodID, va_list args) {
1380
                        return functions->CallStaticBooleanMethodV(this, clazz, methodID, args);
1381
                }
1382
                jboolean CallStaticBooleanMethodA(jclass clazz,
1383
                        jmethodID methodID, const jvalue *args) {
1384
                        return functions->CallStaticBooleanMethodA(this, clazz, methodID, args);
1385
                }
1386

    
1387
                jbyte CallStaticByteMethod(jclass clazz,
1388
                        jmethodID methodID, ...) {
1389
                        va_list args;
1390
                        jbyte result;
1391
                        va_start(args, methodID);
1392
                        result = functions->CallStaticByteMethodV(this, clazz, methodID, args);
1393
                        va_end(args);
1394
                        return result;
1395
                }
1396
                jbyte CallStaticByteMethodV(jclass clazz,
1397
                        jmethodID methodID, va_list args) {
1398
                        return functions->CallStaticByteMethodV(this, clazz, methodID, args);
1399
                }
1400
                jbyte CallStaticByteMethodA(jclass clazz,
1401
                        jmethodID methodID, const jvalue *args) {
1402
                        return functions->CallStaticByteMethodA(this, clazz, methodID, args);
1403
                }
1404

    
1405
                jchar CallStaticCharMethod(jclass clazz,
1406
                        jmethodID methodID, ...) {
1407
                        va_list args;
1408
                        jchar result;
1409
                        va_start(args, methodID);
1410
                        result = functions->CallStaticCharMethodV(this, clazz, methodID, args);
1411
                        va_end(args);
1412
                        return result;
1413
                }
1414
                jchar CallStaticCharMethodV(jclass clazz,
1415
                        jmethodID methodID, va_list args) {
1416
                        return functions->CallStaticCharMethodV(this, clazz, methodID, args);
1417
                }
1418
                jchar CallStaticCharMethodA(jclass clazz,
1419
                        jmethodID methodID, const jvalue *args) {
1420
                        return functions->CallStaticCharMethodA(this, clazz, methodID, args);
1421
                }
1422

    
1423
                jshort CallStaticShortMethod(jclass clazz,
1424
                        jmethodID methodID, ...) {
1425
                        va_list args;
1426
                        jshort result;
1427
                        va_start(args, methodID);
1428
                        result = functions->CallStaticShortMethodV(this, clazz, methodID, args);
1429
                        va_end(args);
1430
                        return result;
1431
                }
1432
                jshort CallStaticShortMethodV(jclass clazz,
1433
                        jmethodID methodID, va_list args) {
1434
                        return functions->CallStaticShortMethodV(this, clazz, methodID, args);
1435
                }
1436
                jshort CallStaticShortMethodA(jclass clazz,
1437
                        jmethodID methodID, const jvalue *args) {
1438
                        return functions->CallStaticShortMethodA(this, clazz, methodID, args);
1439
                }
1440

    
1441
                jint CallStaticIntMethod(jclass clazz,
1442
                        jmethodID methodID, ...) {
1443
                        va_list args;
1444
                        jint result;
1445
                        va_start(args, methodID);
1446
                        result = functions->CallStaticIntMethodV(this, clazz, methodID, args);
1447
                        va_end(args);
1448
                        return result;
1449
                }
1450
                jint CallStaticIntMethodV(jclass clazz,
1451
                        jmethodID methodID, va_list args) {
1452
                        return functions->CallStaticIntMethodV(this, clazz, methodID, args);
1453
                }
1454
                jint CallStaticIntMethodA(jclass clazz,
1455
                        jmethodID methodID, const jvalue *args) {
1456
                        return functions->CallStaticIntMethodA(this, clazz, methodID, args);
1457
                }
1458

    
1459
                jlong CallStaticLongMethod(jclass clazz,
1460
                        jmethodID methodID, ...) {
1461
                        va_list args;
1462
                        jlong result;
1463
                        va_start(args, methodID);
1464
                        result = functions->CallStaticLongMethodV(this, clazz, methodID, args);
1465
                        va_end(args);
1466
                        return result;
1467
                }
1468
                jlong CallStaticLongMethodV(jclass clazz,
1469
                        jmethodID methodID, va_list args) {
1470
                        return functions->CallStaticLongMethodV(this, clazz, methodID, args);
1471
                }
1472
                jlong CallStaticLongMethodA(jclass clazz,
1473
                        jmethodID methodID, const jvalue *args) {
1474
                        return functions->CallStaticLongMethodA(this, clazz, methodID, args);
1475
                }
1476

    
1477
                jfloat CallStaticFloatMethod(jclass clazz,
1478
                        jmethodID methodID, ...) {
1479
                        va_list args;
1480
                        jfloat result;
1481
                        va_start(args, methodID);
1482
                        result = functions->CallStaticFloatMethodV(this, clazz, methodID, args);
1483
                        va_end(args);
1484
                        return result;
1485
                }
1486
                jfloat CallStaticFloatMethodV(jclass clazz,
1487
                        jmethodID methodID, va_list args) {
1488
                        return functions->CallStaticFloatMethodV(this, clazz, methodID, args);
1489
                }
1490
                jfloat CallStaticFloatMethodA(jclass clazz,
1491
                        jmethodID methodID, const jvalue *args) {
1492
                        return functions->CallStaticFloatMethodA(this, clazz, methodID, args);
1493
                }
1494

    
1495
                jdouble CallStaticDoubleMethod(jclass clazz,
1496
                        jmethodID methodID, ...) {
1497
                        va_list args;
1498
                        jdouble result;
1499
                        va_start(args, methodID);
1500
                        result = functions->CallStaticDoubleMethodV(this, clazz, methodID, args);
1501
                        va_end(args);
1502
                        return result;
1503
                }
1504
                jdouble CallStaticDoubleMethodV(jclass clazz,
1505
                        jmethodID methodID, va_list args) {
1506
                        return functions->CallStaticDoubleMethodV(this, clazz, methodID, args);
1507
                }
1508
                jdouble CallStaticDoubleMethodA(jclass clazz,
1509
                        jmethodID methodID, const jvalue *args) {
1510
                        return functions->CallStaticDoubleMethodA(this, clazz, methodID, args);
1511
                }
1512

    
1513
                void CallStaticVoidMethod(jclass cls, jmethodID methodID, ...) {
1514
                        va_list args;
1515
                        va_start(args, methodID);
1516
                        functions->CallStaticVoidMethodV(this, cls, methodID, args);
1517
                        va_end(args);
1518
                }
1519
                void CallStaticVoidMethodV(jclass cls, jmethodID methodID,
1520
                        va_list args) {
1521
                        functions->CallStaticVoidMethodV(this, cls, methodID, args);
1522
                }
1523
                void CallStaticVoidMethodA(jclass cls, jmethodID methodID,
1524
                        const jvalue * args) {
1525
                        functions->CallStaticVoidMethodA(this, cls, methodID, args);
1526
                }
1527

    
1528
                jfieldID GetStaticFieldID(jclass clazz, const char *name,
1529
                        const char *sig) {
1530
                        return functions->GetStaticFieldID(this, clazz, name, sig);
1531
                }
1532
                jobject GetStaticObjectField(jclass clazz, jfieldID fieldID) {
1533
                        return functions->GetStaticObjectField(this, clazz, fieldID);
1534
                }
1535
                jboolean GetStaticBooleanField(jclass clazz, jfieldID fieldID) {
1536
                        return functions->GetStaticBooleanField(this, clazz, fieldID);
1537
                }
1538
                jbyte GetStaticByteField(jclass clazz, jfieldID fieldID) {
1539
                        return functions->GetStaticByteField(this, clazz, fieldID);
1540
                }
1541
                jchar GetStaticCharField(jclass clazz, jfieldID fieldID) {
1542
                        return functions->GetStaticCharField(this, clazz, fieldID);
1543
                }
1544
                jshort GetStaticShortField(jclass clazz, jfieldID fieldID) {
1545
                        return functions->GetStaticShortField(this, clazz, fieldID);
1546
                }
1547
                jint GetStaticIntField(jclass clazz, jfieldID fieldID) {
1548
                        return functions->GetStaticIntField(this, clazz, fieldID);
1549
                }
1550
                jlong GetStaticLongField(jclass clazz, jfieldID fieldID) {
1551
                        return functions->GetStaticLongField(this, clazz, fieldID);
1552
                }
1553
                jfloat GetStaticFloatField(jclass clazz, jfieldID fieldID) {
1554
                        return functions->GetStaticFloatField(this, clazz, fieldID);
1555
                }
1556
                jdouble GetStaticDoubleField(jclass clazz, jfieldID fieldID) {
1557
                        return functions->GetStaticDoubleField(this, clazz, fieldID);
1558
                }
1559

    
1560
                void SetStaticObjectField(jclass clazz, jfieldID fieldID,
1561
                        jobject value) {
1562
                        functions->SetStaticObjectField(this, clazz, fieldID, value);
1563
                }
1564
                void SetStaticBooleanField(jclass clazz, jfieldID fieldID,
1565
                        jboolean value) {
1566
                        functions->SetStaticBooleanField(this, clazz, fieldID, value);
1567
                }
1568
                void SetStaticByteField(jclass clazz, jfieldID fieldID,
1569
                        jbyte value) {
1570
                        functions->SetStaticByteField(this, clazz, fieldID, value);
1571
                }
1572
                void SetStaticCharField(jclass clazz, jfieldID fieldID,
1573
                        jchar value) {
1574
                        functions->SetStaticCharField(this, clazz, fieldID, value);
1575
                }
1576
                void SetStaticShortField(jclass clazz, jfieldID fieldID,
1577
                        jshort value) {
1578
                        functions->SetStaticShortField(this, clazz, fieldID, value);
1579
                }
1580
                void SetStaticIntField(jclass clazz, jfieldID fieldID,
1581
                        jint value) {
1582
                        functions->SetStaticIntField(this, clazz, fieldID, value);
1583
                }
1584
                void SetStaticLongField(jclass clazz, jfieldID fieldID,
1585
                        jlong value) {
1586
                        functions->SetStaticLongField(this, clazz, fieldID, value);
1587
                }
1588
                void SetStaticFloatField(jclass clazz, jfieldID fieldID,
1589
                        jfloat value) {
1590
                        functions->SetStaticFloatField(this, clazz, fieldID, value);
1591
                }
1592
                void SetStaticDoubleField(jclass clazz, jfieldID fieldID,
1593
                        jdouble value) {
1594
                        functions->SetStaticDoubleField(this, clazz, fieldID, value);
1595
                }
1596

    
1597
                jstring NewString(const jchar *unicode, jsize len) {
1598
                        return functions->NewString(this, unicode, len);
1599
                }
1600
                jsize GetStringLength(jstring str) {
1601
                        return functions->GetStringLength(this, str);
1602
                }
1603
                const jchar *GetStringChars(jstring str, jboolean *isCopy) {
1604
                        return functions->GetStringChars(this, str, isCopy);
1605
                }
1606
                void ReleaseStringChars(jstring str, const jchar *chars) {
1607
                        functions->ReleaseStringChars(this, str, chars);
1608
                }
1609

    
1610
                jstring NewStringUTF(const char *utf) {
1611
                        return functions->NewStringUTF(this, utf);
1612
                }
1613
                jsize GetStringUTFLength(jstring str) {
1614
                        return functions->GetStringUTFLength(this, str);
1615
                }
1616
                const char* GetStringUTFChars(jstring str, jboolean *isCopy) {
1617
                        return functions->GetStringUTFChars(this, str, isCopy);
1618
                }
1619
                void ReleaseStringUTFChars(jstring str, const char* chars) {
1620
                        functions->ReleaseStringUTFChars(this, str, chars);
1621
                }
1622

    
1623
                jsize GetArrayLength(jarray array) {
1624
                        return functions->GetArrayLength(this, array);
1625
                }
1626

    
1627
                jobjectArray NewObjectArray(jsize len, jclass clazz,
1628
                        jobject init) {
1629
                        return functions->NewObjectArray(this, len, clazz, init);
1630
                }
1631
                jobject GetObjectArrayElement(jobjectArray array, jsize index) {
1632
                        return functions->GetObjectArrayElement(this, array, index);
1633
                }
1634
                void SetObjectArrayElement(jobjectArray array, jsize index,
1635
                        jobject val) {
1636
                        functions->SetObjectArrayElement(this, array, index, val);
1637
                }
1638

    
1639
                jbooleanArray NewBooleanArray(jsize len) {
1640
                        return functions->NewBooleanArray(this, len);
1641
                }
1642
                jbyteArray NewByteArray(jsize len) {
1643
                        return functions->NewByteArray(this, len);
1644
                }
1645
                jcharArray NewCharArray(jsize len) {
1646
                        return functions->NewCharArray(this, len);
1647
                }
1648
                jshortArray NewShortArray(jsize len) {
1649
                        return functions->NewShortArray(this, len);
1650
                }
1651
                jintArray NewIntArray(jsize len) {
1652
                        return functions->NewIntArray(this, len);
1653
                }
1654
                jlongArray NewLongArray(jsize len) {
1655
                        return functions->NewLongArray(this, len);
1656
                }
1657
                jfloatArray NewFloatArray(jsize len) {
1658
                        return functions->NewFloatArray(this, len);
1659
                }
1660
                jdoubleArray NewDoubleArray(jsize len) {
1661
                        return functions->NewDoubleArray(this, len);
1662
                }
1663

    
1664
                jboolean * GetBooleanArrayElements(jbooleanArray array, jboolean *isCopy) {
1665
                        return functions->GetBooleanArrayElements(this, array, isCopy);
1666
                }
1667
                jbyte * GetByteArrayElements(jbyteArray array, jboolean *isCopy) {
1668
                        return functions->GetByteArrayElements(this, array, isCopy);
1669
                }
1670
                jchar * GetCharArrayElements(jcharArray array, jboolean *isCopy) {
1671
                        return functions->GetCharArrayElements(this, array, isCopy);
1672
                }
1673
                jshort * GetShortArrayElements(jshortArray array, jboolean *isCopy) {
1674
                        return functions->GetShortArrayElements(this, array, isCopy);
1675
                }
1676
                jint * GetIntArrayElements(jintArray array, jboolean *isCopy) {
1677
                        return functions->GetIntArrayElements(this, array, isCopy);
1678
                }
1679
                jlong * GetLongArrayElements(jlongArray array, jboolean *isCopy) {
1680
                        return functions->GetLongArrayElements(this, array, isCopy);
1681
                }
1682
                jfloat * GetFloatArrayElements(jfloatArray array, jboolean *isCopy) {
1683
                        return functions->GetFloatArrayElements(this, array, isCopy);
1684
                }
1685
                jdouble * GetDoubleArrayElements(jdoubleArray array, jboolean *isCopy) {
1686
                        return functions->GetDoubleArrayElements(this, array, isCopy);
1687
                }
1688

    
1689
                void ReleaseBooleanArrayElements(jbooleanArray array,
1690
                        jboolean *elems,
1691
                        jint mode) {
1692
                        functions->ReleaseBooleanArrayElements(this, array, elems, mode);
1693
                }
1694
                void ReleaseByteArrayElements(jbyteArray array,
1695
                        jbyte *elems,
1696
                        jint mode) {
1697
                        functions->ReleaseByteArrayElements(this, array, elems, mode);
1698
                }
1699
                void ReleaseCharArrayElements(jcharArray array,
1700
                        jchar *elems,
1701
                        jint mode) {
1702
                        functions->ReleaseCharArrayElements(this, array, elems, mode);
1703
                }
1704
                void ReleaseShortArrayElements(jshortArray array,
1705
                        jshort *elems,
1706
                        jint mode) {
1707
                        functions->ReleaseShortArrayElements(this, array, elems, mode);
1708
                }
1709
                void ReleaseIntArrayElements(jintArray array,
1710
                        jint *elems,
1711
                        jint mode) {
1712
                        functions->ReleaseIntArrayElements(this, array, elems, mode);
1713
                }
1714
                void ReleaseLongArrayElements(jlongArray array,
1715
                        jlong *elems,
1716
                        jint mode) {
1717
                        functions->ReleaseLongArrayElements(this, array, elems, mode);
1718
                }
1719
                void ReleaseFloatArrayElements(jfloatArray array,
1720
                        jfloat *elems,
1721
                        jint mode) {
1722
                        functions->ReleaseFloatArrayElements(this, array, elems, mode);
1723
                }
1724
                void ReleaseDoubleArrayElements(jdoubleArray array,
1725
                        jdouble *elems,
1726
                        jint mode) {
1727
                        functions->ReleaseDoubleArrayElements(this, array, elems, mode);
1728
                }
1729

    
1730
                void GetBooleanArrayRegion(jbooleanArray array,
1731
                        jsize start, jsize len, jboolean *buf) {
1732
                        functions->GetBooleanArrayRegion(this, array, start, len, buf);
1733
                }
1734
                void GetByteArrayRegion(jbyteArray array,
1735
                        jsize start, jsize len, jbyte *buf) {
1736
                        functions->GetByteArrayRegion(this, array, start, len, buf);
1737
                }
1738
                void GetCharArrayRegion(jcharArray array,
1739
                        jsize start, jsize len, jchar *buf) {
1740
                        functions->GetCharArrayRegion(this, array, start, len, buf);
1741
                }
1742
                void GetShortArrayRegion(jshortArray array,
1743
                        jsize start, jsize len, jshort *buf) {
1744
                        functions->GetShortArrayRegion(this, array, start, len, buf);
1745
                }
1746
                void GetIntArrayRegion(jintArray array,
1747
                        jsize start, jsize len, jint *buf) {
1748
                        functions->GetIntArrayRegion(this, array, start, len, buf);
1749
                }
1750
                void GetLongArrayRegion(jlongArray array,
1751
                        jsize start, jsize len, jlong *buf) {
1752
                        functions->GetLongArrayRegion(this, array, start, len, buf);
1753
                }
1754
                void GetFloatArrayRegion(jfloatArray array,
1755
                        jsize start, jsize len, jfloat *buf) {
1756
                        functions->GetFloatArrayRegion(this, array, start, len, buf);
1757
                }
1758
                void GetDoubleArrayRegion(jdoubleArray array,
1759
                        jsize start, jsize len, jdouble *buf) {
1760
                        functions->GetDoubleArrayRegion(this, array, start, len, buf);
1761
                }
1762

    
1763
                void SetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len,
1764
                        const jboolean *buf) {
1765
                        functions->SetBooleanArrayRegion(this, array, start, len, buf);
1766
                }
1767
                void SetByteArrayRegion(jbyteArray array, jsize start, jsize len,
1768
                        const jbyte *buf) {
1769
                        functions->SetByteArrayRegion(this, array, start, len, buf);
1770
                }
1771
                void SetCharArrayRegion(jcharArray array, jsize start, jsize len,
1772
                        const jchar *buf) {
1773
                        functions->SetCharArrayRegion(this, array, start, len, buf);
1774
                }
1775
                void SetShortArrayRegion(jshortArray array, jsize start, jsize len,
1776
                        const jshort *buf) {
1777
                        functions->SetShortArrayRegion(this, array, start, len, buf);
1778
                }
1779
                void SetIntArrayRegion(jintArray array, jsize start, jsize len,
1780
                        const jint *buf) {
1781
                        functions->SetIntArrayRegion(this, array, start, len, buf);
1782
                }
1783
                void SetLongArrayRegion(jlongArray array, jsize start, jsize len,
1784
                        const jlong *buf) {
1785
                        functions->SetLongArrayRegion(this, array, start, len, buf);
1786
                }
1787
                void SetFloatArrayRegion(jfloatArray array, jsize start, jsize len,
1788
                        const jfloat *buf) {
1789
                        functions->SetFloatArrayRegion(this, array, start, len, buf);
1790
                }
1791
                void SetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len,
1792
                        const jdouble *buf) {
1793
                        functions->SetDoubleArrayRegion(this, array, start, len, buf);
1794
                }
1795

    
1796
                jint RegisterNatives(jclass clazz, const JNINativeMethod *methods,
1797
                        jint nMethods) {
1798
                        return functions->RegisterNatives(this, clazz, methods, nMethods);
1799
                }
1800
                jint UnregisterNatives(jclass clazz) {
1801
                        return functions->UnregisterNatives(this, clazz);
1802
                }
1803

    
1804
                jint MonitorEnter(jobject obj) {
1805
                        return functions->MonitorEnter(this, obj);
1806
                }
1807
                jint MonitorExit(jobject obj) {
1808
                        return functions->MonitorExit(this, obj);
1809
                }
1810

    
1811
                jint GetJavaVM(JavaVM **vm) {
1812
                        return functions->GetJavaVM(this, vm);
1813
                }
1814

    
1815
                void GetStringRegion(jstring str, jsize start, jsize len, jchar *buf) {
1816
                        functions->GetStringRegion(this, str, start, len, buf);
1817
                }
1818
                void GetStringUTFRegion(jstring str, jsize start, jsize len, char *buf) {
1819
                        functions->GetStringUTFRegion(this, str, start, len, buf);
1820
                }
1821

    
1822
                void * GetPrimitiveArrayCritical(jarray array, jboolean *isCopy) {
1823
                        return functions->GetPrimitiveArrayCritical(this, array, isCopy);
1824
                }
1825
                void ReleasePrimitiveArrayCritical(jarray array, void *carray, jint mode) {
1826
                        functions->ReleasePrimitiveArrayCritical(this, array, carray, mode);
1827
                }
1828

    
1829
                const jchar * GetStringCritical(jstring string, jboolean *isCopy) {
1830
                        return functions->GetStringCritical(this, string, isCopy);
1831
                }
1832
                void ReleaseStringCritical(jstring string, const jchar *cstring) {
1833
                        functions->ReleaseStringCritical(this, string, cstring);
1834
                }
1835

    
1836
                jweak NewWeakGlobalRef(jobject obj) {
1837
                        return functions->NewWeakGlobalRef(this, obj);
1838
                }
1839
                void DeleteWeakGlobalRef(jweak ref) {
1840
                        functions->DeleteWeakGlobalRef(this, ref);
1841
                }
1842

    
1843
                jboolean ExceptionCheck() {
1844
                        return functions->ExceptionCheck(this);
1845
                }
1846

    
1847
                jobject NewDirectByteBuffer(void* address, jlong capacity) {
1848
                        return functions->NewDirectByteBuffer(this, address, capacity);
1849
                }
1850
                void* GetDirectBufferAddress(jobject buf) {
1851
                        return functions->GetDirectBufferAddress(this, buf);
1852
                }
1853
                jlong GetDirectBufferCapacity(jobject buf) {
1854
                        return functions->GetDirectBufferCapacity(this, buf);
1855
                }
1856
                jobjectRefType GetObjectRefType(jobject obj) {
1857
                        return functions->GetObjectRefType(this, obj);
1858
                }
1859

    
1860
#endif /* __cplusplus */
1861
        };
1862

    
1863
        typedef struct JavaVMOption {
1864
                char *optionString;
1865
                void *extraInfo;
1866
        } JavaVMOption;
1867

    
1868
        typedef struct JavaVMInitArgs {
1869
                jint version;
1870

    
1871
                jint nOptions;
1872
                JavaVMOption *options;
1873
                jboolean ignoreUnrecognized;
1874
        } JavaVMInitArgs;
1875

    
1876
        typedef struct JavaVMAttachArgs {
1877
                jint version;
1878

    
1879
                char *name;
1880
                jobject group;
1881
        } JavaVMAttachArgs;
1882

    
1883
        /* These will be VM-specific. */
1884

    
1885
#define JDK1_2
1886
#define JDK1_4
1887

    
1888
        /* End VM-specific. */
1889

    
1890
        struct JNIInvokeInterface_ {
1891
                void *reserved0;
1892
                void *reserved1;
1893
                void *reserved2;
1894

    
1895
                jint(JNICALL *DestroyJavaVM)(JavaVM *vm);
1896

    
1897
                jint(JNICALL *AttachCurrentThread)(JavaVM *vm, void **penv, void *args);
1898

    
1899
                jint(JNICALL *DetachCurrentThread)(JavaVM *vm);
1900

    
1901
                jint(JNICALL *GetEnv)(JavaVM *vm, void **penv, jint version);
1902

    
1903
                jint(JNICALL *AttachCurrentThreadAsDaemon)(JavaVM *vm, void **penv, void *args);
1904
        };
1905

    
1906
        struct JavaVM_ {
1907
                const struct JNIInvokeInterface_ *functions;
1908
#ifdef __cplusplus
1909

    
1910
                jint DestroyJavaVM() {
1911
                        return functions->DestroyJavaVM(this);
1912
                }
1913
                jint AttachCurrentThread(void **penv, void *args) {
1914
                        return functions->AttachCurrentThread(this, penv, args);
1915
                }
1916
                jint DetachCurrentThread() {
1917
                        return functions->DetachCurrentThread(this);
1918
                }
1919

    
1920
                jint GetEnv(void **penv, jint version) {
1921
                        return functions->GetEnv(this, penv, version);
1922
                }
1923
                jint AttachCurrentThreadAsDaemon(void **penv, void *args) {
1924
                        return functions->AttachCurrentThreadAsDaemon(this, penv, args);
1925
                }
1926
#endif
1927
        };
1928

    
1929
#ifdef _JNI_IMPLEMENTATION_
1930
#define _JNI_IMPORT_OR_EXPORT_ JNIEXPORT
1931
#else
1932
#define _JNI_IMPORT_OR_EXPORT_ JNIIMPORT
1933
#endif
1934
        _JNI_IMPORT_OR_EXPORT_ jint JNICALL
1935
                JNI_GetDefaultJavaVMInitArgs(void *args);
1936

    
1937
        _JNI_IMPORT_OR_EXPORT_ jint JNICALL
1938
                JNI_CreateJavaVM(JavaVM **pvm, void **penv, void *args);
1939

    
1940
        _JNI_IMPORT_OR_EXPORT_ jint JNICALL
1941
                JNI_GetCreatedJavaVMs(JavaVM **, jsize, jsize *);
1942

    
1943
        /* Defined by native libraries. */
1944
        JNIEXPORT jint JNICALL
1945
                JNI_OnLoad(JavaVM *vm, void *reserved);
1946

    
1947
        JNIEXPORT void JNICALL
1948
                JNI_OnUnload(JavaVM *vm, void *reserved);
1949

    
1950
#define JNI_VERSION_1_1 0x00010001
1951
#define JNI_VERSION_1_2 0x00010002
1952
#define JNI_VERSION_1_4 0x00010004
1953
#define JNI_VERSION_1_6 0x00010006
1954
#define JNI_VERSION_1_8 0x00010008
1955

    
1956
#ifdef __cplusplus
1957
} /* extern "C" */
1958
#endif /* __cplusplus */
1959

    
1960
#endif /* !_JAVASOFT_JNI_H_ */
    (1-1/1)