Line data Source code
1 : /*
2 : * Copyright (c) 1996, 2016, Oracle and/or its affiliates. All rights reserved.
3 : * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 : *
5 : * This code is free software; you can redistribute it and/or modify it
6 : * under the terms of the GNU General Public License version 2 only, as
7 : * published by the Free Software Foundation. Oracle designates this
8 : * particular file as subject to the "Classpath" exception as provided
9 : * by Oracle in the LICENSE file that accompanied this code.
10 : *
11 : * This code is distributed in the hope that it will be useful, but WITHOUT
12 : * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 : * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 : * version 2 for more details (a copy is included in the LICENSE file that
15 : * accompanied this code).
16 : *
17 : * You should have received a copy of the GNU General Public License version
18 : * 2 along with this work; if not, write to the Free Software Foundation,
19 : * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 : *
21 : * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 : * or visit www.oracle.com if you need additional information or have any
23 : * questions.
24 : */
25 :
26 : /*
27 : * We used part of Netscape's Java Runtime Interface (JRI) as the starting
28 : * point of our design and implementation.
29 : */
30 :
31 : /******************************************************************************
32 : * Java Runtime Interface
33 : * Copyright (c) 1996 Netscape Communications Corporation. All rights reserved.
34 : *****************************************************************************/
35 :
36 : #ifndef _JAVASOFT_JNI_H_
37 : #define _JAVASOFT_JNI_H_
38 :
39 : #include <stdio.h>
40 : #include <stdarg.h>
41 :
42 : /* jni_md.h contains the machine-dependent typedefs for jbyte, jint
43 : and jlong */
44 :
45 : #include "jni_md.h"
46 :
47 : #ifdef __cplusplus
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 : /* Module Features */
770 :
771 : jobject (JNICALL *GetModule)
772 : (JNIEnv* env, jclass clazz);
773 : };
774 :
775 : /*
776 : * We use inlined functions for C++ so that programmers can write:
777 : *
778 : * env->FindClass("java/lang/String")
779 : *
780 : * in C++ rather than:
781 : *
782 : * (*env)->FindClass(env, "java/lang/String")
783 : *
784 : * in C.
785 : */
786 :
787 : struct JNIEnv_ {
788 : const struct JNINativeInterface_ *functions;
789 : #ifdef __cplusplus
790 :
791 37 : jint GetVersion() {
792 37 : return functions->GetVersion(this);
793 : }
794 : jclass DefineClass(const char *name, jobject loader, const jbyte *buf,
795 : jsize len) {
796 : return functions->DefineClass(this, name, loader, buf, len);
797 : }
798 74 : jclass FindClass(const char *name) {
799 74 : return functions->FindClass(this, name);
800 : }
801 : jmethodID FromReflectedMethod(jobject method) {
802 : return functions->FromReflectedMethod(this,method);
803 : }
804 : jfieldID FromReflectedField(jobject field) {
805 : return functions->FromReflectedField(this,field);
806 : }
807 :
808 : jobject ToReflectedMethod(jclass cls, jmethodID methodID, jboolean isStatic) {
809 : return functions->ToReflectedMethod(this, cls, methodID, isStatic);
810 : }
811 :
812 : jclass GetSuperclass(jclass sub) {
813 : return functions->GetSuperclass(this, sub);
814 : }
815 : jboolean IsAssignableFrom(jclass sub, jclass sup) {
816 : return functions->IsAssignableFrom(this, sub, sup);
817 : }
818 :
819 : jobject ToReflectedField(jclass cls, jfieldID fieldID, jboolean isStatic) {
820 : return functions->ToReflectedField(this,cls,fieldID,isStatic);
821 : }
822 :
823 : jint Throw(jthrowable obj) {
824 : return functions->Throw(this, obj);
825 : }
826 : jint ThrowNew(jclass clazz, const char *msg) {
827 : return functions->ThrowNew(this, clazz, msg);
828 : }
829 0 : jthrowable ExceptionOccurred() {
830 0 : return functions->ExceptionOccurred(this);
831 : }
832 0 : void ExceptionDescribe() {
833 0 : functions->ExceptionDescribe(this);
834 0 : }
835 : void ExceptionClear() {
836 : functions->ExceptionClear(this);
837 : }
838 : void FatalError(const char *msg) {
839 : functions->FatalError(this, msg);
840 : }
841 :
842 : jint PushLocalFrame(jint capacity) {
843 : return functions->PushLocalFrame(this,capacity);
844 : }
845 : jobject PopLocalFrame(jobject result) {
846 : return functions->PopLocalFrame(this,result);
847 : }
848 :
849 : jobject NewGlobalRef(jobject lobj) {
850 : return functions->NewGlobalRef(this,lobj);
851 : }
852 : void DeleteGlobalRef(jobject gref) {
853 : functions->DeleteGlobalRef(this,gref);
854 : }
855 : void DeleteLocalRef(jobject obj) {
856 : functions->DeleteLocalRef(this, obj);
857 : }
858 :
859 : jboolean IsSameObject(jobject obj1, jobject obj2) {
860 : return functions->IsSameObject(this,obj1,obj2);
861 : }
862 :
863 : jobject NewLocalRef(jobject ref) {
864 : return functions->NewLocalRef(this,ref);
865 : }
866 : jint EnsureLocalCapacity(jint capacity) {
867 : return functions->EnsureLocalCapacity(this,capacity);
868 : }
869 :
870 : jobject AllocObject(jclass clazz) {
871 : return functions->AllocObject(this,clazz);
872 : }
873 0 : jobject NewObject(jclass clazz, jmethodID methodID, ...) {
874 0 : va_list args;
875 0 : jobject result;
876 0 : va_start(args, methodID);
877 0 : result = functions->NewObjectV(this,clazz,methodID,args);
878 0 : va_end(args);
879 0 : return result;
880 : }
881 : jobject NewObjectV(jclass clazz, jmethodID methodID,
882 : va_list args) {
883 : return functions->NewObjectV(this,clazz,methodID,args);
884 : }
885 : jobject NewObjectA(jclass clazz, jmethodID methodID,
886 : const jvalue *args) {
887 : return functions->NewObjectA(this,clazz,methodID,args);
888 : }
889 :
890 : jclass GetObjectClass(jobject obj) {
891 : return functions->GetObjectClass(this,obj);
892 : }
893 : jboolean IsInstanceOf(jobject obj, jclass clazz) {
894 : return functions->IsInstanceOf(this,obj,clazz);
895 : }
896 :
897 0 : jmethodID GetMethodID(jclass clazz, const char *name,
898 : const char *sig) {
899 0 : return functions->GetMethodID(this,clazz,name,sig);
900 : }
901 :
902 : jobject CallObjectMethod(jobject obj, jmethodID methodID, ...) {
903 : va_list args;
904 : jobject result;
905 : va_start(args,methodID);
906 : result = functions->CallObjectMethodV(this,obj,methodID,args);
907 : va_end(args);
908 : return result;
909 : }
910 : jobject CallObjectMethodV(jobject obj, jmethodID methodID,
911 : va_list args) {
912 : return functions->CallObjectMethodV(this,obj,methodID,args);
913 : }
914 : jobject CallObjectMethodA(jobject obj, jmethodID methodID,
915 : const jvalue * args) {
916 : return functions->CallObjectMethodA(this,obj,methodID,args);
917 : }
918 :
919 : jboolean CallBooleanMethod(jobject obj,
920 : jmethodID methodID, ...) {
921 : va_list args;
922 : jboolean result;
923 : va_start(args,methodID);
924 : result = functions->CallBooleanMethodV(this,obj,methodID,args);
925 : va_end(args);
926 : return result;
927 : }
928 : jboolean CallBooleanMethodV(jobject obj, jmethodID methodID,
929 : va_list args) {
930 : return functions->CallBooleanMethodV(this,obj,methodID,args);
931 : }
932 : jboolean CallBooleanMethodA(jobject obj, jmethodID methodID,
933 : const jvalue * args) {
934 : return functions->CallBooleanMethodA(this,obj,methodID, args);
935 : }
936 :
937 : jbyte CallByteMethod(jobject obj, jmethodID methodID, ...) {
938 : va_list args;
939 : jbyte result;
940 : va_start(args,methodID);
941 : result = functions->CallByteMethodV(this,obj,methodID,args);
942 : va_end(args);
943 : return result;
944 : }
945 : jbyte CallByteMethodV(jobject obj, jmethodID methodID,
946 : va_list args) {
947 : return functions->CallByteMethodV(this,obj,methodID,args);
948 : }
949 : jbyte CallByteMethodA(jobject obj, jmethodID methodID,
950 : const jvalue * args) {
951 : return functions->CallByteMethodA(this,obj,methodID,args);
952 : }
953 :
954 : jchar CallCharMethod(jobject obj, jmethodID methodID, ...) {
955 : va_list args;
956 : jchar result;
957 : va_start(args,methodID);
958 : result = functions->CallCharMethodV(this,obj,methodID,args);
959 : va_end(args);
960 : return result;
961 : }
962 : jchar CallCharMethodV(jobject obj, jmethodID methodID,
963 : va_list args) {
964 : return functions->CallCharMethodV(this,obj,methodID,args);
965 : }
966 : jchar CallCharMethodA(jobject obj, jmethodID methodID,
967 : const jvalue * args) {
968 : return functions->CallCharMethodA(this,obj,methodID,args);
969 : }
970 :
971 : jshort CallShortMethod(jobject obj, jmethodID methodID, ...) {
972 : va_list args;
973 : jshort result;
974 : va_start(args,methodID);
975 : result = functions->CallShortMethodV(this,obj,methodID,args);
976 : va_end(args);
977 : return result;
978 : }
979 : jshort CallShortMethodV(jobject obj, jmethodID methodID,
980 : va_list args) {
981 : return functions->CallShortMethodV(this,obj,methodID,args);
982 : }
983 : jshort CallShortMethodA(jobject obj, jmethodID methodID,
984 : const jvalue * args) {
985 : return functions->CallShortMethodA(this,obj,methodID,args);
986 : }
987 :
988 : jint CallIntMethod(jobject obj, jmethodID methodID, ...) {
989 : va_list args;
990 : jint result;
991 : va_start(args,methodID);
992 : result = functions->CallIntMethodV(this,obj,methodID,args);
993 : va_end(args);
994 : return result;
995 : }
996 : jint CallIntMethodV(jobject obj, jmethodID methodID,
997 : va_list args) {
998 : return functions->CallIntMethodV(this,obj,methodID,args);
999 : }
1000 : jint CallIntMethodA(jobject obj, jmethodID methodID,
1001 : const jvalue * args) {
1002 : return functions->CallIntMethodA(this,obj,methodID,args);
1003 : }
1004 :
1005 : jlong CallLongMethod(jobject obj, jmethodID methodID, ...) {
1006 : va_list args;
1007 : jlong result;
1008 : va_start(args,methodID);
1009 : result = functions->CallLongMethodV(this,obj,methodID,args);
1010 : va_end(args);
1011 : return result;
1012 : }
1013 : jlong CallLongMethodV(jobject obj, jmethodID methodID,
1014 : va_list args) {
1015 : return functions->CallLongMethodV(this,obj,methodID,args);
1016 : }
1017 : jlong CallLongMethodA(jobject obj, jmethodID methodID,
1018 : const jvalue * args) {
1019 : return functions->CallLongMethodA(this,obj,methodID,args);
1020 : }
1021 :
1022 : jfloat CallFloatMethod(jobject obj, jmethodID methodID, ...) {
1023 : va_list args;
1024 : jfloat result;
1025 : va_start(args,methodID);
1026 : result = functions->CallFloatMethodV(this,obj,methodID,args);
1027 : va_end(args);
1028 : return result;
1029 : }
1030 : jfloat CallFloatMethodV(jobject obj, jmethodID methodID,
1031 : va_list args) {
1032 : return functions->CallFloatMethodV(this,obj,methodID,args);
1033 : }
1034 : jfloat CallFloatMethodA(jobject obj, jmethodID methodID,
1035 : const jvalue * args) {
1036 : return functions->CallFloatMethodA(this,obj,methodID,args);
1037 : }
1038 :
1039 : jdouble CallDoubleMethod(jobject obj, jmethodID methodID, ...) {
1040 : va_list args;
1041 : jdouble result;
1042 : va_start(args,methodID);
1043 : result = functions->CallDoubleMethodV(this,obj,methodID,args);
1044 : va_end(args);
1045 : return result;
1046 : }
1047 : jdouble CallDoubleMethodV(jobject obj, jmethodID methodID,
1048 : va_list args) {
1049 : return functions->CallDoubleMethodV(this,obj,methodID,args);
1050 : }
1051 : jdouble CallDoubleMethodA(jobject obj, jmethodID methodID,
1052 : const jvalue * args) {
1053 : return functions->CallDoubleMethodA(this,obj,methodID,args);
1054 : }
1055 :
1056 : void CallVoidMethod(jobject obj, jmethodID methodID, ...) {
1057 : va_list args;
1058 : va_start(args,methodID);
1059 : functions->CallVoidMethodV(this,obj,methodID,args);
1060 : va_end(args);
1061 : }
1062 : void CallVoidMethodV(jobject obj, jmethodID methodID,
1063 : va_list args) {
1064 : functions->CallVoidMethodV(this,obj,methodID,args);
1065 : }
1066 : void CallVoidMethodA(jobject obj, jmethodID methodID,
1067 : const jvalue * args) {
1068 : functions->CallVoidMethodA(this,obj,methodID,args);
1069 : }
1070 :
1071 : jobject CallNonvirtualObjectMethod(jobject obj, jclass clazz,
1072 : jmethodID methodID, ...) {
1073 : va_list args;
1074 : jobject result;
1075 : va_start(args,methodID);
1076 : result = functions->CallNonvirtualObjectMethodV(this,obj,clazz,
1077 : methodID,args);
1078 : va_end(args);
1079 : return result;
1080 : }
1081 : jobject CallNonvirtualObjectMethodV(jobject obj, jclass clazz,
1082 : jmethodID methodID, va_list args) {
1083 : return functions->CallNonvirtualObjectMethodV(this,obj,clazz,
1084 : methodID,args);
1085 : }
1086 : jobject CallNonvirtualObjectMethodA(jobject obj, jclass clazz,
1087 : jmethodID methodID, const jvalue * args) {
1088 : return functions->CallNonvirtualObjectMethodA(this,obj,clazz,
1089 : methodID,args);
1090 : }
1091 :
1092 : jboolean CallNonvirtualBooleanMethod(jobject obj, jclass clazz,
1093 : jmethodID methodID, ...) {
1094 : va_list args;
1095 : jboolean result;
1096 : va_start(args,methodID);
1097 : result = functions->CallNonvirtualBooleanMethodV(this,obj,clazz,
1098 : methodID,args);
1099 : va_end(args);
1100 : return result;
1101 : }
1102 : jboolean CallNonvirtualBooleanMethodV(jobject obj, jclass clazz,
1103 : jmethodID methodID, va_list args) {
1104 : return functions->CallNonvirtualBooleanMethodV(this,obj,clazz,
1105 : methodID,args);
1106 : }
1107 : jboolean CallNonvirtualBooleanMethodA(jobject obj, jclass clazz,
1108 : jmethodID methodID, const jvalue * args) {
1109 : return functions->CallNonvirtualBooleanMethodA(this,obj,clazz,
1110 : methodID, args);
1111 : }
1112 :
1113 : jbyte CallNonvirtualByteMethod(jobject obj, jclass clazz,
1114 : jmethodID methodID, ...) {
1115 : va_list args;
1116 : jbyte result;
1117 : va_start(args,methodID);
1118 : result = functions->CallNonvirtualByteMethodV(this,obj,clazz,
1119 : methodID,args);
1120 : va_end(args);
1121 : return result;
1122 : }
1123 : jbyte CallNonvirtualByteMethodV(jobject obj, jclass clazz,
1124 : jmethodID methodID, va_list args) {
1125 : return functions->CallNonvirtualByteMethodV(this,obj,clazz,
1126 : methodID,args);
1127 : }
1128 : jbyte CallNonvirtualByteMethodA(jobject obj, jclass clazz,
1129 : jmethodID methodID, const jvalue * args) {
1130 : return functions->CallNonvirtualByteMethodA(this,obj,clazz,
1131 : methodID,args);
1132 : }
1133 :
1134 : jchar CallNonvirtualCharMethod(jobject obj, jclass clazz,
1135 : jmethodID methodID, ...) {
1136 : va_list args;
1137 : jchar result;
1138 : va_start(args,methodID);
1139 : result = functions->CallNonvirtualCharMethodV(this,obj,clazz,
1140 : methodID,args);
1141 : va_end(args);
1142 : return result;
1143 : }
1144 : jchar CallNonvirtualCharMethodV(jobject obj, jclass clazz,
1145 : jmethodID methodID, va_list args) {
1146 : return functions->CallNonvirtualCharMethodV(this,obj,clazz,
1147 : methodID,args);
1148 : }
1149 : jchar CallNonvirtualCharMethodA(jobject obj, jclass clazz,
1150 : jmethodID methodID, const jvalue * args) {
1151 : return functions->CallNonvirtualCharMethodA(this,obj,clazz,
1152 : methodID,args);
1153 : }
1154 :
1155 : jshort CallNonvirtualShortMethod(jobject obj, jclass clazz,
1156 : jmethodID methodID, ...) {
1157 : va_list args;
1158 : jshort result;
1159 : va_start(args,methodID);
1160 : result = functions->CallNonvirtualShortMethodV(this,obj,clazz,
1161 : methodID,args);
1162 : va_end(args);
1163 : return result;
1164 : }
1165 : jshort CallNonvirtualShortMethodV(jobject obj, jclass clazz,
1166 : jmethodID methodID, va_list args) {
1167 : return functions->CallNonvirtualShortMethodV(this,obj,clazz,
1168 : methodID,args);
1169 : }
1170 : jshort CallNonvirtualShortMethodA(jobject obj, jclass clazz,
1171 : jmethodID methodID, const jvalue * args) {
1172 : return functions->CallNonvirtualShortMethodA(this,obj,clazz,
1173 : methodID,args);
1174 : }
1175 :
1176 : jint CallNonvirtualIntMethod(jobject obj, jclass clazz,
1177 : jmethodID methodID, ...) {
1178 : va_list args;
1179 : jint result;
1180 : va_start(args,methodID);
1181 : result = functions->CallNonvirtualIntMethodV(this,obj,clazz,
1182 : methodID,args);
1183 : va_end(args);
1184 : return result;
1185 : }
1186 : jint CallNonvirtualIntMethodV(jobject obj, jclass clazz,
1187 : jmethodID methodID, va_list args) {
1188 : return functions->CallNonvirtualIntMethodV(this,obj,clazz,
1189 : methodID,args);
1190 : }
1191 : jint CallNonvirtualIntMethodA(jobject obj, jclass clazz,
1192 : jmethodID methodID, const jvalue * args) {
1193 : return functions->CallNonvirtualIntMethodA(this,obj,clazz,
1194 : methodID,args);
1195 : }
1196 :
1197 : jlong CallNonvirtualLongMethod(jobject obj, jclass clazz,
1198 : jmethodID methodID, ...) {
1199 : va_list args;
1200 : jlong result;
1201 : va_start(args,methodID);
1202 : result = functions->CallNonvirtualLongMethodV(this,obj,clazz,
1203 : methodID,args);
1204 : va_end(args);
1205 : return result;
1206 : }
1207 : jlong CallNonvirtualLongMethodV(jobject obj, jclass clazz,
1208 : jmethodID methodID, va_list args) {
1209 : return functions->CallNonvirtualLongMethodV(this,obj,clazz,
1210 : methodID,args);
1211 : }
1212 : jlong CallNonvirtualLongMethodA(jobject obj, jclass clazz,
1213 : jmethodID methodID, const jvalue * args) {
1214 : return functions->CallNonvirtualLongMethodA(this,obj,clazz,
1215 : methodID,args);
1216 : }
1217 :
1218 : jfloat CallNonvirtualFloatMethod(jobject obj, jclass clazz,
1219 : jmethodID methodID, ...) {
1220 : va_list args;
1221 : jfloat result;
1222 : va_start(args,methodID);
1223 : result = functions->CallNonvirtualFloatMethodV(this,obj,clazz,
1224 : methodID,args);
1225 : va_end(args);
1226 : return result;
1227 : }
1228 : jfloat CallNonvirtualFloatMethodV(jobject obj, jclass clazz,
1229 : jmethodID methodID,
1230 : va_list args) {
1231 : return functions->CallNonvirtualFloatMethodV(this,obj,clazz,
1232 : methodID,args);
1233 : }
1234 : jfloat CallNonvirtualFloatMethodA(jobject obj, jclass clazz,
1235 : jmethodID methodID,
1236 : const jvalue * args) {
1237 : return functions->CallNonvirtualFloatMethodA(this,obj,clazz,
1238 : methodID,args);
1239 : }
1240 :
1241 : jdouble CallNonvirtualDoubleMethod(jobject obj, jclass clazz,
1242 : jmethodID methodID, ...) {
1243 : va_list args;
1244 : jdouble result;
1245 : va_start(args,methodID);
1246 : result = functions->CallNonvirtualDoubleMethodV(this,obj,clazz,
1247 : methodID,args);
1248 : va_end(args);
1249 : return result;
1250 : }
1251 : jdouble CallNonvirtualDoubleMethodV(jobject obj, jclass clazz,
1252 : jmethodID methodID,
1253 : va_list args) {
1254 : return functions->CallNonvirtualDoubleMethodV(this,obj,clazz,
1255 : methodID,args);
1256 : }
1257 : jdouble CallNonvirtualDoubleMethodA(jobject obj, jclass clazz,
1258 : jmethodID methodID,
1259 : const jvalue * args) {
1260 : return functions->CallNonvirtualDoubleMethodA(this,obj,clazz,
1261 : methodID,args);
1262 : }
1263 :
1264 : void CallNonvirtualVoidMethod(jobject obj, jclass clazz,
1265 : jmethodID methodID, ...) {
1266 : va_list args;
1267 : va_start(args,methodID);
1268 : functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);
1269 : va_end(args);
1270 : }
1271 : void CallNonvirtualVoidMethodV(jobject obj, jclass clazz,
1272 : jmethodID methodID,
1273 : va_list args) {
1274 : functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);
1275 : }
1276 : void CallNonvirtualVoidMethodA(jobject obj, jclass clazz,
1277 : jmethodID methodID,
1278 : const jvalue * args) {
1279 : functions->CallNonvirtualVoidMethodA(this,obj,clazz,methodID,args);
1280 : }
1281 :
1282 : jfieldID GetFieldID(jclass clazz, const char *name,
1283 : const char *sig) {
1284 : return functions->GetFieldID(this,clazz,name,sig);
1285 : }
1286 :
1287 : jobject GetObjectField(jobject obj, jfieldID fieldID) {
1288 : return functions->GetObjectField(this,obj,fieldID);
1289 : }
1290 : jboolean GetBooleanField(jobject obj, jfieldID fieldID) {
1291 : return functions->GetBooleanField(this,obj,fieldID);
1292 : }
1293 : jbyte GetByteField(jobject obj, jfieldID fieldID) {
1294 : return functions->GetByteField(this,obj,fieldID);
1295 : }
1296 : jchar GetCharField(jobject obj, jfieldID fieldID) {
1297 : return functions->GetCharField(this,obj,fieldID);
1298 : }
1299 : jshort GetShortField(jobject obj, jfieldID fieldID) {
1300 : return functions->GetShortField(this,obj,fieldID);
1301 : }
1302 : jint GetIntField(jobject obj, jfieldID fieldID) {
1303 : return functions->GetIntField(this,obj,fieldID);
1304 : }
1305 : jlong GetLongField(jobject obj, jfieldID fieldID) {
1306 : return functions->GetLongField(this,obj,fieldID);
1307 : }
1308 : jfloat GetFloatField(jobject obj, jfieldID fieldID) {
1309 : return functions->GetFloatField(this,obj,fieldID);
1310 : }
1311 : jdouble GetDoubleField(jobject obj, jfieldID fieldID) {
1312 : return functions->GetDoubleField(this,obj,fieldID);
1313 : }
1314 :
1315 : void SetObjectField(jobject obj, jfieldID fieldID, jobject val) {
1316 : functions->SetObjectField(this,obj,fieldID,val);
1317 : }
1318 : void SetBooleanField(jobject obj, jfieldID fieldID,
1319 : jboolean val) {
1320 : functions->SetBooleanField(this,obj,fieldID,val);
1321 : }
1322 : void SetByteField(jobject obj, jfieldID fieldID,
1323 : jbyte val) {
1324 : functions->SetByteField(this,obj,fieldID,val);
1325 : }
1326 : void SetCharField(jobject obj, jfieldID fieldID,
1327 : jchar val) {
1328 : functions->SetCharField(this,obj,fieldID,val);
1329 : }
1330 : void SetShortField(jobject obj, jfieldID fieldID,
1331 : jshort val) {
1332 : functions->SetShortField(this,obj,fieldID,val);
1333 : }
1334 : void SetIntField(jobject obj, jfieldID fieldID,
1335 : jint val) {
1336 : functions->SetIntField(this,obj,fieldID,val);
1337 : }
1338 : void SetLongField(jobject obj, jfieldID fieldID,
1339 : jlong val) {
1340 : functions->SetLongField(this,obj,fieldID,val);
1341 : }
1342 : void SetFloatField(jobject obj, jfieldID fieldID,
1343 : jfloat val) {
1344 : functions->SetFloatField(this,obj,fieldID,val);
1345 : }
1346 : void SetDoubleField(jobject obj, jfieldID fieldID,
1347 : jdouble val) {
1348 : functions->SetDoubleField(this,obj,fieldID,val);
1349 : }
1350 :
1351 74 : jmethodID GetStaticMethodID(jclass clazz, const char *name,
1352 : const char *sig) {
1353 74 : return functions->GetStaticMethodID(this,clazz,name,sig);
1354 : }
1355 :
1356 : jobject CallStaticObjectMethod(jclass clazz, jmethodID methodID,
1357 : ...) {
1358 : va_list args;
1359 : jobject result;
1360 : va_start(args,methodID);
1361 : result = functions->CallStaticObjectMethodV(this,clazz,methodID,args);
1362 : va_end(args);
1363 : return result;
1364 : }
1365 : jobject CallStaticObjectMethodV(jclass clazz, jmethodID methodID,
1366 : va_list args) {
1367 : return functions->CallStaticObjectMethodV(this,clazz,methodID,args);
1368 : }
1369 : jobject CallStaticObjectMethodA(jclass clazz, jmethodID methodID,
1370 : const jvalue *args) {
1371 : return functions->CallStaticObjectMethodA(this,clazz,methodID,args);
1372 : }
1373 :
1374 37 : jboolean CallStaticBooleanMethod(jclass clazz,
1375 : jmethodID methodID, ...) {
1376 37 : va_list args;
1377 37 : jboolean result;
1378 37 : va_start(args,methodID);
1379 37 : result = functions->CallStaticBooleanMethodV(this,clazz,methodID,args);
1380 37 : va_end(args);
1381 37 : return result;
1382 : }
1383 : jboolean CallStaticBooleanMethodV(jclass clazz,
1384 : jmethodID methodID, va_list args) {
1385 : return functions->CallStaticBooleanMethodV(this,clazz,methodID,args);
1386 : }
1387 : jboolean CallStaticBooleanMethodA(jclass clazz,
1388 : jmethodID methodID, const jvalue *args) {
1389 : return functions->CallStaticBooleanMethodA(this,clazz,methodID,args);
1390 : }
1391 :
1392 : jbyte CallStaticByteMethod(jclass clazz,
1393 : jmethodID methodID, ...) {
1394 : va_list args;
1395 : jbyte result;
1396 : va_start(args,methodID);
1397 : result = functions->CallStaticByteMethodV(this,clazz,methodID,args);
1398 : va_end(args);
1399 : return result;
1400 : }
1401 : jbyte CallStaticByteMethodV(jclass clazz,
1402 : jmethodID methodID, va_list args) {
1403 : return functions->CallStaticByteMethodV(this,clazz,methodID,args);
1404 : }
1405 : jbyte CallStaticByteMethodA(jclass clazz,
1406 : jmethodID methodID, const jvalue *args) {
1407 : return functions->CallStaticByteMethodA(this,clazz,methodID,args);
1408 : }
1409 :
1410 : jchar CallStaticCharMethod(jclass clazz,
1411 : jmethodID methodID, ...) {
1412 : va_list args;
1413 : jchar result;
1414 : va_start(args,methodID);
1415 : result = functions->CallStaticCharMethodV(this,clazz,methodID,args);
1416 : va_end(args);
1417 : return result;
1418 : }
1419 : jchar CallStaticCharMethodV(jclass clazz,
1420 : jmethodID methodID, va_list args) {
1421 : return functions->CallStaticCharMethodV(this,clazz,methodID,args);
1422 : }
1423 : jchar CallStaticCharMethodA(jclass clazz,
1424 : jmethodID methodID, const jvalue *args) {
1425 : return functions->CallStaticCharMethodA(this,clazz,methodID,args);
1426 : }
1427 :
1428 : jshort CallStaticShortMethod(jclass clazz,
1429 : jmethodID methodID, ...) {
1430 : va_list args;
1431 : jshort result;
1432 : va_start(args,methodID);
1433 : result = functions->CallStaticShortMethodV(this,clazz,methodID,args);
1434 : va_end(args);
1435 : return result;
1436 : }
1437 : jshort CallStaticShortMethodV(jclass clazz,
1438 : jmethodID methodID, va_list args) {
1439 : return functions->CallStaticShortMethodV(this,clazz,methodID,args);
1440 : }
1441 : jshort CallStaticShortMethodA(jclass clazz,
1442 : jmethodID methodID, const jvalue *args) {
1443 : return functions->CallStaticShortMethodA(this,clazz,methodID,args);
1444 : }
1445 :
1446 : jint CallStaticIntMethod(jclass clazz,
1447 : jmethodID methodID, ...) {
1448 : va_list args;
1449 : jint result;
1450 : va_start(args,methodID);
1451 : result = functions->CallStaticIntMethodV(this,clazz,methodID,args);
1452 : va_end(args);
1453 : return result;
1454 : }
1455 : jint CallStaticIntMethodV(jclass clazz,
1456 : jmethodID methodID, va_list args) {
1457 : return functions->CallStaticIntMethodV(this,clazz,methodID,args);
1458 : }
1459 : jint CallStaticIntMethodA(jclass clazz,
1460 : jmethodID methodID, const jvalue *args) {
1461 : return functions->CallStaticIntMethodA(this,clazz,methodID,args);
1462 : }
1463 :
1464 : jlong CallStaticLongMethod(jclass clazz,
1465 : jmethodID methodID, ...) {
1466 : va_list args;
1467 : jlong result;
1468 : va_start(args,methodID);
1469 : result = functions->CallStaticLongMethodV(this,clazz,methodID,args);
1470 : va_end(args);
1471 : return result;
1472 : }
1473 : jlong CallStaticLongMethodV(jclass clazz,
1474 : jmethodID methodID, va_list args) {
1475 : return functions->CallStaticLongMethodV(this,clazz,methodID,args);
1476 : }
1477 : jlong CallStaticLongMethodA(jclass clazz,
1478 : jmethodID methodID, const jvalue *args) {
1479 : return functions->CallStaticLongMethodA(this,clazz,methodID,args);
1480 : }
1481 :
1482 : jfloat CallStaticFloatMethod(jclass clazz,
1483 : jmethodID methodID, ...) {
1484 : va_list args;
1485 : jfloat result;
1486 : va_start(args,methodID);
1487 : result = functions->CallStaticFloatMethodV(this,clazz,methodID,args);
1488 : va_end(args);
1489 : return result;
1490 : }
1491 : jfloat CallStaticFloatMethodV(jclass clazz,
1492 : jmethodID methodID, va_list args) {
1493 : return functions->CallStaticFloatMethodV(this,clazz,methodID,args);
1494 : }
1495 : jfloat CallStaticFloatMethodA(jclass clazz,
1496 : jmethodID methodID, const jvalue *args) {
1497 : return functions->CallStaticFloatMethodA(this,clazz,methodID,args);
1498 : }
1499 :
1500 : jdouble CallStaticDoubleMethod(jclass clazz,
1501 : jmethodID methodID, ...) {
1502 : va_list args;
1503 : jdouble result;
1504 : va_start(args,methodID);
1505 : result = functions->CallStaticDoubleMethodV(this,clazz,methodID,args);
1506 : va_end(args);
1507 : return result;
1508 : }
1509 : jdouble CallStaticDoubleMethodV(jclass clazz,
1510 : jmethodID methodID, va_list args) {
1511 : return functions->CallStaticDoubleMethodV(this,clazz,methodID,args);
1512 : }
1513 : jdouble CallStaticDoubleMethodA(jclass clazz,
1514 : jmethodID methodID, const jvalue *args) {
1515 : return functions->CallStaticDoubleMethodA(this,clazz,methodID,args);
1516 : }
1517 :
1518 37 : void CallStaticVoidMethod(jclass cls, jmethodID methodID, ...) {
1519 37 : va_list args;
1520 37 : va_start(args,methodID);
1521 37 : functions->CallStaticVoidMethodV(this,cls,methodID,args);
1522 37 : va_end(args);
1523 37 : }
1524 : void CallStaticVoidMethodV(jclass cls, jmethodID methodID,
1525 : va_list args) {
1526 : functions->CallStaticVoidMethodV(this,cls,methodID,args);
1527 : }
1528 : void CallStaticVoidMethodA(jclass cls, jmethodID methodID,
1529 : const jvalue * args) {
1530 : functions->CallStaticVoidMethodA(this,cls,methodID,args);
1531 : }
1532 :
1533 : jfieldID GetStaticFieldID(jclass clazz, const char *name,
1534 : const char *sig) {
1535 : return functions->GetStaticFieldID(this,clazz,name,sig);
1536 : }
1537 : jobject GetStaticObjectField(jclass clazz, jfieldID fieldID) {
1538 : return functions->GetStaticObjectField(this,clazz,fieldID);
1539 : }
1540 : jboolean GetStaticBooleanField(jclass clazz, jfieldID fieldID) {
1541 : return functions->GetStaticBooleanField(this,clazz,fieldID);
1542 : }
1543 : jbyte GetStaticByteField(jclass clazz, jfieldID fieldID) {
1544 : return functions->GetStaticByteField(this,clazz,fieldID);
1545 : }
1546 : jchar GetStaticCharField(jclass clazz, jfieldID fieldID) {
1547 : return functions->GetStaticCharField(this,clazz,fieldID);
1548 : }
1549 : jshort GetStaticShortField(jclass clazz, jfieldID fieldID) {
1550 : return functions->GetStaticShortField(this,clazz,fieldID);
1551 : }
1552 : jint GetStaticIntField(jclass clazz, jfieldID fieldID) {
1553 : return functions->GetStaticIntField(this,clazz,fieldID);
1554 : }
1555 : jlong GetStaticLongField(jclass clazz, jfieldID fieldID) {
1556 : return functions->GetStaticLongField(this,clazz,fieldID);
1557 : }
1558 : jfloat GetStaticFloatField(jclass clazz, jfieldID fieldID) {
1559 : return functions->GetStaticFloatField(this,clazz,fieldID);
1560 : }
1561 : jdouble GetStaticDoubleField(jclass clazz, jfieldID fieldID) {
1562 : return functions->GetStaticDoubleField(this,clazz,fieldID);
1563 : }
1564 :
1565 : void SetStaticObjectField(jclass clazz, jfieldID fieldID,
1566 : jobject value) {
1567 : functions->SetStaticObjectField(this,clazz,fieldID,value);
1568 : }
1569 : void SetStaticBooleanField(jclass clazz, jfieldID fieldID,
1570 : jboolean value) {
1571 : functions->SetStaticBooleanField(this,clazz,fieldID,value);
1572 : }
1573 : void SetStaticByteField(jclass clazz, jfieldID fieldID,
1574 : jbyte value) {
1575 : functions->SetStaticByteField(this,clazz,fieldID,value);
1576 : }
1577 : void SetStaticCharField(jclass clazz, jfieldID fieldID,
1578 : jchar value) {
1579 : functions->SetStaticCharField(this,clazz,fieldID,value);
1580 : }
1581 : void SetStaticShortField(jclass clazz, jfieldID fieldID,
1582 : jshort value) {
1583 : functions->SetStaticShortField(this,clazz,fieldID,value);
1584 : }
1585 : void SetStaticIntField(jclass clazz, jfieldID fieldID,
1586 : jint value) {
1587 : functions->SetStaticIntField(this,clazz,fieldID,value);
1588 : }
1589 : void SetStaticLongField(jclass clazz, jfieldID fieldID,
1590 : jlong value) {
1591 : functions->SetStaticLongField(this,clazz,fieldID,value);
1592 : }
1593 : void SetStaticFloatField(jclass clazz, jfieldID fieldID,
1594 : jfloat value) {
1595 : functions->SetStaticFloatField(this,clazz,fieldID,value);
1596 : }
1597 : void SetStaticDoubleField(jclass clazz, jfieldID fieldID,
1598 : jdouble value) {
1599 : functions->SetStaticDoubleField(this,clazz,fieldID,value);
1600 : }
1601 :
1602 : jstring NewString(const jchar *unicode, jsize len) {
1603 : return functions->NewString(this,unicode,len);
1604 : }
1605 : jsize GetStringLength(jstring str) {
1606 : return functions->GetStringLength(this,str);
1607 : }
1608 : const jchar *GetStringChars(jstring str, jboolean *isCopy) {
1609 : return functions->GetStringChars(this,str,isCopy);
1610 : }
1611 : void ReleaseStringChars(jstring str, const jchar *chars) {
1612 : functions->ReleaseStringChars(this,str,chars);
1613 : }
1614 :
1615 179 : jstring NewStringUTF(const char *utf) {
1616 179 : return functions->NewStringUTF(this,utf);
1617 : }
1618 : jsize GetStringUTFLength(jstring str) {
1619 : return functions->GetStringUTFLength(this,str);
1620 : }
1621 : const char* GetStringUTFChars(jstring str, jboolean *isCopy) {
1622 : return functions->GetStringUTFChars(this,str,isCopy);
1623 : }
1624 : void ReleaseStringUTFChars(jstring str, const char* chars) {
1625 : functions->ReleaseStringUTFChars(this,str,chars);
1626 : }
1627 :
1628 : jsize GetArrayLength(jarray array) {
1629 : return functions->GetArrayLength(this,array);
1630 : }
1631 :
1632 37 : jobjectArray NewObjectArray(jsize len, jclass clazz,
1633 : jobject init) {
1634 37 : return functions->NewObjectArray(this,len,clazz,init);
1635 : }
1636 : jobject GetObjectArrayElement(jobjectArray array, jsize index) {
1637 : return functions->GetObjectArrayElement(this,array,index);
1638 : }
1639 179 : void SetObjectArrayElement(jobjectArray array, jsize index,
1640 : jobject val) {
1641 179 : functions->SetObjectArrayElement(this,array,index,val);
1642 : }
1643 :
1644 : jbooleanArray NewBooleanArray(jsize len) {
1645 : return functions->NewBooleanArray(this,len);
1646 : }
1647 : jbyteArray NewByteArray(jsize len) {
1648 : return functions->NewByteArray(this,len);
1649 : }
1650 : jcharArray NewCharArray(jsize len) {
1651 : return functions->NewCharArray(this,len);
1652 : }
1653 : jshortArray NewShortArray(jsize len) {
1654 : return functions->NewShortArray(this,len);
1655 : }
1656 : jintArray NewIntArray(jsize len) {
1657 : return functions->NewIntArray(this,len);
1658 : }
1659 : jlongArray NewLongArray(jsize len) {
1660 : return functions->NewLongArray(this,len);
1661 : }
1662 : jfloatArray NewFloatArray(jsize len) {
1663 : return functions->NewFloatArray(this,len);
1664 : }
1665 : jdoubleArray NewDoubleArray(jsize len) {
1666 : return functions->NewDoubleArray(this,len);
1667 : }
1668 :
1669 : jboolean * GetBooleanArrayElements(jbooleanArray array, jboolean *isCopy) {
1670 : return functions->GetBooleanArrayElements(this,array,isCopy);
1671 : }
1672 : jbyte * GetByteArrayElements(jbyteArray array, jboolean *isCopy) {
1673 : return functions->GetByteArrayElements(this,array,isCopy);
1674 : }
1675 : jchar * GetCharArrayElements(jcharArray array, jboolean *isCopy) {
1676 : return functions->GetCharArrayElements(this,array,isCopy);
1677 : }
1678 : jshort * GetShortArrayElements(jshortArray array, jboolean *isCopy) {
1679 : return functions->GetShortArrayElements(this,array,isCopy);
1680 : }
1681 : jint * GetIntArrayElements(jintArray array, jboolean *isCopy) {
1682 : return functions->GetIntArrayElements(this,array,isCopy);
1683 : }
1684 : jlong * GetLongArrayElements(jlongArray array, jboolean *isCopy) {
1685 : return functions->GetLongArrayElements(this,array,isCopy);
1686 : }
1687 : jfloat * GetFloatArrayElements(jfloatArray array, jboolean *isCopy) {
1688 : return functions->GetFloatArrayElements(this,array,isCopy);
1689 : }
1690 : jdouble * GetDoubleArrayElements(jdoubleArray array, jboolean *isCopy) {
1691 : return functions->GetDoubleArrayElements(this,array,isCopy);
1692 : }
1693 :
1694 : void ReleaseBooleanArrayElements(jbooleanArray array,
1695 : jboolean *elems,
1696 : jint mode) {
1697 : functions->ReleaseBooleanArrayElements(this,array,elems,mode);
1698 : }
1699 : void ReleaseByteArrayElements(jbyteArray array,
1700 : jbyte *elems,
1701 : jint mode) {
1702 : functions->ReleaseByteArrayElements(this,array,elems,mode);
1703 : }
1704 : void ReleaseCharArrayElements(jcharArray array,
1705 : jchar *elems,
1706 : jint mode) {
1707 : functions->ReleaseCharArrayElements(this,array,elems,mode);
1708 : }
1709 : void ReleaseShortArrayElements(jshortArray array,
1710 : jshort *elems,
1711 : jint mode) {
1712 : functions->ReleaseShortArrayElements(this,array,elems,mode);
1713 : }
1714 : void ReleaseIntArrayElements(jintArray array,
1715 : jint *elems,
1716 : jint mode) {
1717 : functions->ReleaseIntArrayElements(this,array,elems,mode);
1718 : }
1719 : void ReleaseLongArrayElements(jlongArray array,
1720 : jlong *elems,
1721 : jint mode) {
1722 : functions->ReleaseLongArrayElements(this,array,elems,mode);
1723 : }
1724 : void ReleaseFloatArrayElements(jfloatArray array,
1725 : jfloat *elems,
1726 : jint mode) {
1727 : functions->ReleaseFloatArrayElements(this,array,elems,mode);
1728 : }
1729 : void ReleaseDoubleArrayElements(jdoubleArray array,
1730 : jdouble *elems,
1731 : jint mode) {
1732 : functions->ReleaseDoubleArrayElements(this,array,elems,mode);
1733 : }
1734 :
1735 : void GetBooleanArrayRegion(jbooleanArray array,
1736 : jsize start, jsize len, jboolean *buf) {
1737 : functions->GetBooleanArrayRegion(this,array,start,len,buf);
1738 : }
1739 : void GetByteArrayRegion(jbyteArray array,
1740 : jsize start, jsize len, jbyte *buf) {
1741 : functions->GetByteArrayRegion(this,array,start,len,buf);
1742 : }
1743 : void GetCharArrayRegion(jcharArray array,
1744 : jsize start, jsize len, jchar *buf) {
1745 : functions->GetCharArrayRegion(this,array,start,len,buf);
1746 : }
1747 : void GetShortArrayRegion(jshortArray array,
1748 : jsize start, jsize len, jshort *buf) {
1749 : functions->GetShortArrayRegion(this,array,start,len,buf);
1750 : }
1751 : void GetIntArrayRegion(jintArray array,
1752 : jsize start, jsize len, jint *buf) {
1753 : functions->GetIntArrayRegion(this,array,start,len,buf);
1754 : }
1755 : void GetLongArrayRegion(jlongArray array,
1756 : jsize start, jsize len, jlong *buf) {
1757 : functions->GetLongArrayRegion(this,array,start,len,buf);
1758 : }
1759 : void GetFloatArrayRegion(jfloatArray array,
1760 : jsize start, jsize len, jfloat *buf) {
1761 : functions->GetFloatArrayRegion(this,array,start,len,buf);
1762 : }
1763 : void GetDoubleArrayRegion(jdoubleArray array,
1764 : jsize start, jsize len, jdouble *buf) {
1765 : functions->GetDoubleArrayRegion(this,array,start,len,buf);
1766 : }
1767 :
1768 : void SetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len,
1769 : const jboolean *buf) {
1770 : functions->SetBooleanArrayRegion(this,array,start,len,buf);
1771 : }
1772 : void SetByteArrayRegion(jbyteArray array, jsize start, jsize len,
1773 : const jbyte *buf) {
1774 : functions->SetByteArrayRegion(this,array,start,len,buf);
1775 : }
1776 : void SetCharArrayRegion(jcharArray array, jsize start, jsize len,
1777 : const jchar *buf) {
1778 : functions->SetCharArrayRegion(this,array,start,len,buf);
1779 : }
1780 : void SetShortArrayRegion(jshortArray array, jsize start, jsize len,
1781 : const jshort *buf) {
1782 : functions->SetShortArrayRegion(this,array,start,len,buf);
1783 : }
1784 : void SetIntArrayRegion(jintArray array, jsize start, jsize len,
1785 : const jint *buf) {
1786 : functions->SetIntArrayRegion(this,array,start,len,buf);
1787 : }
1788 : void SetLongArrayRegion(jlongArray array, jsize start, jsize len,
1789 : const jlong *buf) {
1790 : functions->SetLongArrayRegion(this,array,start,len,buf);
1791 : }
1792 : void SetFloatArrayRegion(jfloatArray array, jsize start, jsize len,
1793 : const jfloat *buf) {
1794 : functions->SetFloatArrayRegion(this,array,start,len,buf);
1795 : }
1796 : void SetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len,
1797 : const jdouble *buf) {
1798 : functions->SetDoubleArrayRegion(this,array,start,len,buf);
1799 : }
1800 :
1801 : jint RegisterNatives(jclass clazz, const JNINativeMethod *methods,
1802 : jint nMethods) {
1803 : return functions->RegisterNatives(this,clazz,methods,nMethods);
1804 : }
1805 : jint UnregisterNatives(jclass clazz) {
1806 : return functions->UnregisterNatives(this,clazz);
1807 : }
1808 :
1809 : jint MonitorEnter(jobject obj) {
1810 : return functions->MonitorEnter(this,obj);
1811 : }
1812 : jint MonitorExit(jobject obj) {
1813 : return functions->MonitorExit(this,obj);
1814 : }
1815 :
1816 : jint GetJavaVM(JavaVM **vm) {
1817 : return functions->GetJavaVM(this,vm);
1818 : }
1819 :
1820 : void GetStringRegion(jstring str, jsize start, jsize len, jchar *buf) {
1821 : functions->GetStringRegion(this,str,start,len,buf);
1822 : }
1823 : void GetStringUTFRegion(jstring str, jsize start, jsize len, char *buf) {
1824 : functions->GetStringUTFRegion(this,str,start,len,buf);
1825 : }
1826 :
1827 : void * GetPrimitiveArrayCritical(jarray array, jboolean *isCopy) {
1828 : return functions->GetPrimitiveArrayCritical(this,array,isCopy);
1829 : }
1830 : void ReleasePrimitiveArrayCritical(jarray array, void *carray, jint mode) {
1831 : functions->ReleasePrimitiveArrayCritical(this,array,carray,mode);
1832 : }
1833 :
1834 : const jchar * GetStringCritical(jstring string, jboolean *isCopy) {
1835 : return functions->GetStringCritical(this,string,isCopy);
1836 : }
1837 : void ReleaseStringCritical(jstring string, const jchar *cstring) {
1838 : functions->ReleaseStringCritical(this,string,cstring);
1839 : }
1840 :
1841 : jweak NewWeakGlobalRef(jobject obj) {
1842 : return functions->NewWeakGlobalRef(this,obj);
1843 : }
1844 : void DeleteWeakGlobalRef(jweak ref) {
1845 : functions->DeleteWeakGlobalRef(this,ref);
1846 : }
1847 :
1848 : jboolean ExceptionCheck() {
1849 : return functions->ExceptionCheck(this);
1850 : }
1851 :
1852 : jobject NewDirectByteBuffer(void* address, jlong capacity) {
1853 : return functions->NewDirectByteBuffer(this, address, capacity);
1854 : }
1855 : void* GetDirectBufferAddress(jobject buf) {
1856 : return functions->GetDirectBufferAddress(this, buf);
1857 : }
1858 : jlong GetDirectBufferCapacity(jobject buf) {
1859 : return functions->GetDirectBufferCapacity(this, buf);
1860 : }
1861 : jobjectRefType GetObjectRefType(jobject obj) {
1862 : return functions->GetObjectRefType(this, obj);
1863 : }
1864 :
1865 : /* Module Features */
1866 :
1867 : jobject GetModule(jclass clazz) {
1868 : return functions->GetModule(this, clazz);
1869 : }
1870 :
1871 : #endif /* __cplusplus */
1872 : };
1873 :
1874 : typedef struct JavaVMOption {
1875 : char *optionString;
1876 : void *extraInfo;
1877 : } JavaVMOption;
1878 :
1879 : typedef struct JavaVMInitArgs {
1880 : jint version;
1881 :
1882 : jint nOptions;
1883 : JavaVMOption *options;
1884 : jboolean ignoreUnrecognized;
1885 : } JavaVMInitArgs;
1886 :
1887 : typedef struct JavaVMAttachArgs {
1888 : jint version;
1889 :
1890 : char *name;
1891 : jobject group;
1892 : } JavaVMAttachArgs;
1893 :
1894 : /* These will be VM-specific. */
1895 :
1896 : #define JDK1_2
1897 : #define JDK1_4
1898 :
1899 : /* End VM-specific. */
1900 :
1901 : struct JNIInvokeInterface_ {
1902 : void *reserved0;
1903 : void *reserved1;
1904 : void *reserved2;
1905 :
1906 : jint (JNICALL *DestroyJavaVM)(JavaVM *vm);
1907 :
1908 : jint (JNICALL *AttachCurrentThread)(JavaVM *vm, void **penv, void *args);
1909 :
1910 : jint (JNICALL *DetachCurrentThread)(JavaVM *vm);
1911 :
1912 : jint (JNICALL *GetEnv)(JavaVM *vm, void **penv, jint version);
1913 :
1914 : jint (JNICALL *AttachCurrentThreadAsDaemon)(JavaVM *vm, void **penv, void *args);
1915 : };
1916 :
1917 : struct JavaVM_ {
1918 : const struct JNIInvokeInterface_ *functions;
1919 : #ifdef __cplusplus
1920 :
1921 0 : jint DestroyJavaVM() {
1922 0 : return functions->DestroyJavaVM(this);
1923 : }
1924 : jint AttachCurrentThread(void **penv, void *args) {
1925 : return functions->AttachCurrentThread(this, penv, args);
1926 : }
1927 : jint DetachCurrentThread() {
1928 : return functions->DetachCurrentThread(this);
1929 : }
1930 :
1931 : jint GetEnv(void **penv, jint version) {
1932 : return functions->GetEnv(this, penv, version);
1933 : }
1934 : jint AttachCurrentThreadAsDaemon(void **penv, void *args) {
1935 : return functions->AttachCurrentThreadAsDaemon(this, penv, args);
1936 : }
1937 : #endif
1938 : };
1939 :
1940 : #ifdef _JNI_IMPLEMENTATION_
1941 : #define _JNI_IMPORT_OR_EXPORT_ JNIEXPORT
1942 : #else
1943 : #define _JNI_IMPORT_OR_EXPORT_ JNIIMPORT
1944 : #endif
1945 : _JNI_IMPORT_OR_EXPORT_ jint JNICALL
1946 : JNI_GetDefaultJavaVMInitArgs(void *args);
1947 :
1948 : _JNI_IMPORT_OR_EXPORT_ jint JNICALL
1949 : JNI_CreateJavaVM(JavaVM **pvm, void **penv, void *args);
1950 :
1951 : _JNI_IMPORT_OR_EXPORT_ jint JNICALL
1952 : JNI_GetCreatedJavaVMs(JavaVM **, jsize, jsize *);
1953 :
1954 : /* Defined by native libraries. */
1955 : JNIEXPORT jint JNICALL
1956 : JNI_OnLoad(JavaVM *vm, void *reserved);
1957 :
1958 : JNIEXPORT void JNICALL
1959 : JNI_OnUnload(JavaVM *vm, void *reserved);
1960 :
1961 : #define JNI_VERSION_1_1 0x00010001
1962 : #define JNI_VERSION_1_2 0x00010002
1963 : #define JNI_VERSION_1_4 0x00010004
1964 : #define JNI_VERSION_1_6 0x00010006
1965 : #define JNI_VERSION_1_8 0x00010008
1966 : #define JNI_VERSION_9 0x00090000
1967 : #define JNI_VERSION_10 0x000a0000
1968 :
1969 : #ifdef __cplusplus
1970 : } /* extern "C" */
1971 : #endif /* __cplusplus */
1972 :
1973 : #endif /* !_JAVASOFT_JNI_H_ */
|
