← Back to branch summary

~ubuntu-branches/ubuntu/precise/kompozer/precise

« back to all changes in this revision

Viewing changes to mozilla/embedding/browser/activex/src/pluginhostctrl/pluginsdk_include/jni.h

  • Committer: Bazaar Package Importer
  • Author(s): Anthony Yarusso
  • Date: 2007-08-27 01:11:03 UTC
  • Revision ID: james.westby@ubuntu.com-20070827011103-2jgf4s6532gqu2ka
Tags: upstream-0.7.10
Import upstream version 0.7.10

Show diffs side-by-side

added added

removed removed

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