LSPlant  LSPosed Developers
jni.h
Go to the documentation of this file.
1 /*
2  * Copyright (c) 1996, 2018, 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;
104 typedef jobject jstring;
105 typedef jobject jarray;
115 
116 #endif
117 
118 typedef jobject jweak;
119 
120 typedef union jvalue {
122  jbyte b;
125  jint i;
126  jlong j;
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 {
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;
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 
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,
225  jclass (JNICALL *FindClass)
226  (JNIEnv *env, const char *name);
227 
228  jmethodID (JNICALL *FromReflectedMethod)
230  jfieldID (JNICALL *FromReflectedField)
232 
233  jobject (JNICALL *ToReflectedMethod)
235 
236  jclass (JNICALL *GetSuperclass)
237  (JNIEnv *env, jclass sub);
238  jboolean (JNICALL *IsAssignableFrom)
240 
241  jobject (JNICALL *ToReflectedField)
243 
244  jint (JNICALL *Throw)
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)
259  jobject (JNICALL *PopLocalFrame)
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)
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)
281  jobject (JNICALL *NewObjectA)
283 
284  jclass (JNICALL *GetObjectClass)
285  (JNIEnv *env, jobject obj);
286  jboolean (JNICALL *IsInstanceOf)
288 
289  jmethodID (JNICALL *GetMethodID)
290  (JNIEnv *env, jclass clazz, const char *name, const char *sig);
291 
292  jobject (JNICALL *CallObjectMethod)
294  jobject (JNICALL *CallObjectMethodV)
296  jobject (JNICALL *CallObjectMethodA)
298 
299  jboolean (JNICALL *CallBooleanMethod)
300  (JNIEnv *env, jobject obj, jmethodID methodID, ...);
301  jboolean (JNICALL *CallBooleanMethodV)
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)
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)
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)
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)
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)
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)
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)
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)
359  void (JNICALL *CallVoidMethodA)
360  (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue * args);
361 
362  jobject (JNICALL *CallNonvirtualObjectMethod)
364  jobject (JNICALL *CallNonvirtualObjectMethodV)
367  jobject (JNICALL *CallNonvirtualObjectMethodA)
369  const jvalue * args);
370 
371  jboolean (JNICALL *CallNonvirtualBooleanMethod)
373  jboolean (JNICALL *CallNonvirtualBooleanMethodV)
375  va_list args);
376  jboolean (JNICALL *CallNonvirtualBooleanMethodA)
378  const jvalue * args);
379 
380  jbyte (JNICALL *CallNonvirtualByteMethod)
382  jbyte (JNICALL *CallNonvirtualByteMethodV)
384  va_list args);
385  jbyte (JNICALL *CallNonvirtualByteMethodA)
387  const jvalue *args);
388 
389  jchar (JNICALL *CallNonvirtualCharMethod)
391  jchar (JNICALL *CallNonvirtualCharMethodV)
393  va_list args);
394  jchar (JNICALL *CallNonvirtualCharMethodA)
396  const jvalue *args);
397 
398  jshort (JNICALL *CallNonvirtualShortMethod)
400  jshort (JNICALL *CallNonvirtualShortMethodV)
402  va_list args);
403  jshort (JNICALL *CallNonvirtualShortMethodA)
405  const jvalue *args);
406 
407  jint (JNICALL *CallNonvirtualIntMethod)
409  jint (JNICALL *CallNonvirtualIntMethodV)
411  va_list args);
412  jint (JNICALL *CallNonvirtualIntMethodA)
414  const jvalue *args);
415 
416  jlong (JNICALL *CallNonvirtualLongMethod)
418  jlong (JNICALL *CallNonvirtualLongMethodV)
420  va_list args);
421  jlong (JNICALL *CallNonvirtualLongMethodA)
423  const jvalue *args);
424 
425  jfloat (JNICALL *CallNonvirtualFloatMethod)
427  jfloat (JNICALL *CallNonvirtualFloatMethodV)
429  va_list args);
430  jfloat (JNICALL *CallNonvirtualFloatMethodA)
432  const jvalue *args);
433 
434  jdouble (JNICALL *CallNonvirtualDoubleMethod)
436  jdouble (JNICALL *CallNonvirtualDoubleMethodV)
438  va_list args);
439  jdouble (JNICALL *CallNonvirtualDoubleMethodA)
441  const jvalue *args);
442 
443  void (JNICALL *CallNonvirtualVoidMethod)
445  void (JNICALL *CallNonvirtualVoidMethodV)
447  va_list args);
448  void (JNICALL *CallNonvirtualVoidMethodA)
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)
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)
476  void (JNICALL *SetBooleanField)
478  void (JNICALL *SetByteField)
480  void (JNICALL *SetCharField)
482  void (JNICALL *SetShortField)
484  void (JNICALL *SetIntField)
486  void (JNICALL *SetLongField)
488  void (JNICALL *SetFloatField)
490  void (JNICALL *SetDoubleField)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
570  jboolean (JNICALL *GetStaticBooleanField)
572  jbyte (JNICALL *GetStaticByteField)
574  jchar (JNICALL *GetStaticCharField)
576  jshort (JNICALL *GetStaticShortField)
578  jint (JNICALL *GetStaticIntField)
580  jlong (JNICALL *GetStaticLongField)
582  jfloat (JNICALL *GetStaticFloatField)
584  jdouble (JNICALL *GetStaticDoubleField)
586 
587  void (JNICALL *SetStaticObjectField)
589  void (JNICALL *SetStaticBooleanField)
591  void (JNICALL *SetStaticByteField)
593  void (JNICALL *SetStaticCharField)
595  void (JNICALL *SetStaticShortField)
597  void (JNICALL *SetStaticIntField)
599  void (JNICALL *SetStaticLongField)
601  void (JNICALL *SetStaticFloatField)
603  void (JNICALL *SetStaticDoubleField)
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)
630  jobject (JNICALL *GetObjectArrayElement)
632  void (JNICALL *SetObjectArrayElement)
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 
653  (JNIEnv *env, jbooleanArray array, jboolean *isCopy);
655  (JNIEnv *env, jbyteArray array, jboolean *isCopy);
657  (JNIEnv *env, jcharArray array, jboolean *isCopy);
659  (JNIEnv *env, jshortArray array, jboolean *isCopy);
661  (JNIEnv *env, jintArray array, jboolean *isCopy);
663  (JNIEnv *env, jlongArray array, jboolean *isCopy);
665  (JNIEnv *env, jfloatArray array, jboolean *isCopy);
667  (JNIEnv *env, jdoubleArray array, jboolean *isCopy);
668 
669  void (JNICALL *ReleaseBooleanArrayElements)
671  void (JNICALL *ReleaseByteArrayElements)
673  void (JNICALL *ReleaseCharArrayElements)
675  void (JNICALL *ReleaseShortArrayElements)
677  void (JNICALL *ReleaseIntArrayElements)
679  void (JNICALL *ReleaseLongArrayElements)
681  void (JNICALL *ReleaseFloatArrayElements)
683  void (JNICALL *ReleaseDoubleArrayElements)
685 
686  void (JNICALL *GetBooleanArrayRegion)
688  void (JNICALL *GetByteArrayRegion)
690  void (JNICALL *GetCharArrayRegion)
692  void (JNICALL *GetShortArrayRegion)
694  void (JNICALL *GetIntArrayRegion)
696  void (JNICALL *GetLongArrayRegion)
698  void (JNICALL *GetFloatArrayRegion)
700  void (JNICALL *GetDoubleArrayRegion)
702 
703  void (JNICALL *SetBooleanArrayRegion)
705  void (JNICALL *SetByteArrayRegion)
707  void (JNICALL *SetCharArrayRegion)
709  void (JNICALL *SetShortArrayRegion)
711  void (JNICALL *SetIntArrayRegion)
713  void (JNICALL *SetLongArrayRegion)
715  void (JNICALL *SetFloatArrayRegion)
717  void (JNICALL *SetDoubleArrayRegion)
719 
720  jint (JNICALL *RegisterNatives)
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)
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_ {
789 #ifdef __cplusplus
790 
791  jint GetVersion() {
792  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  jclass FindClass(const char *name) {
799  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  jthrowable ExceptionOccurred() {
830  return functions->ExceptionOccurred(this);
831  }
832  void ExceptionDescribe() {
833  functions->ExceptionDescribe(this);
834  }
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  jobject NewObject(jclass clazz, jmethodID methodID, ...) {
874  va_list args;
875  jobject result;
876  va_start(args, methodID);
877  result = functions->NewObjectV(this,clazz,methodID,args);
878  va_end(args);
879  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  jmethodID GetMethodID(jclass clazz, const char *name,
898  const char *sig) {
899  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;
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,
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,
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,
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,
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,
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,
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,
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,
1230  va_list args) {
1231  return functions->CallNonvirtualFloatMethodV(this,obj,clazz,
1232  methodID,args);
1233  }
1234  jfloat CallNonvirtualFloatMethodA(jobject obj, jclass clazz,
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,
1253  va_list args) {
1254  return functions->CallNonvirtualDoubleMethodV(this,obj,clazz,
1255  methodID,args);
1256  }
1257  jdouble CallNonvirtualDoubleMethodA(jobject obj, jclass clazz,
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,
1273  va_list args) {
1274  functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);
1275  }
1276  void CallNonvirtualVoidMethodA(jobject obj, jclass clazz,
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  jmethodID GetStaticMethodID(jclass clazz, const char *name,
1352  const char *sig) {
1353  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  jboolean CallStaticBooleanMethod(jclass clazz,
1375  jmethodID methodID, ...) {
1376  va_list args;
1377  jboolean result;
1378  va_start(args,methodID);
1379  result = functions->CallStaticBooleanMethodV(this,clazz,methodID,args);
1380  va_end(args);
1381  return result;
1382  }
1383  jboolean CallStaticBooleanMethodV(jclass clazz,
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,
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,
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,
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,
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,
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,
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,
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  void CallStaticVoidMethod(jclass cls, jmethodID methodID, ...) {
1519  va_list args;
1520  va_start(args,methodID);
1521  functions->CallStaticVoidMethodV(this,cls,methodID,args);
1522  va_end(args);
1523  }
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  jstring NewStringUTF(const char *utf) {
1616  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  jobjectArray NewObjectArray(jsize len, jclass clazz,
1633  jobject init) {
1634  return functions->NewObjectArray(this,len,clazz,init);
1635  }
1636  jobject GetObjectArrayElement(jobjectArray array, jsize index) {
1637  return functions->GetObjectArrayElement(this,array,index);
1638  }
1639  void SetObjectArrayElement(jobjectArray array, jsize index,
1640  jobject val) {
1641  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 
1670  return functions->GetBooleanArrayElements(this,array,isCopy);
1671  }
1673  return functions->GetByteArrayElements(this,array,isCopy);
1674  }
1676  return functions->GetCharArrayElements(this,array,isCopy);
1677  }
1679  return functions->GetShortArrayElements(this,array,isCopy);
1680  }
1682  return functions->GetIntArrayElements(this,array,isCopy);
1683  }
1685  return functions->GetLongArrayElements(this,array,isCopy);
1686  }
1688  return functions->GetFloatArrayElements(this,array,isCopy);
1689  }
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,
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  }
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 /*
1875  * optionString may be any option accepted by the JVM, or one of the
1876  * following:
1877  *
1878  * -D<name>=<value> Set a system property.
1879  * -verbose[:class|gc|jni] Enable verbose output, comma-separated. E.g.
1880  * "-verbose:class" or "-verbose:gc,class"
1881  * Standard names include: gc, class, and jni.
1882  * All nonstandard (VM-specific) names must begin
1883  * with "X".
1884  * vfprintf extraInfo is a pointer to the vfprintf hook.
1885  * exit extraInfo is a pointer to the exit hook.
1886  * abort extraInfo is a pointer to the abort hook.
1887  */
1888 typedef struct JavaVMOption {
1890  void *extraInfo;
1892 
1893 typedef struct JavaVMInitArgs {
1894  jint version;
1895 
1896  jint nOptions;
1900 
1901 typedef struct JavaVMAttachArgs {
1902  jint version;
1903 
1904  char *name;
1907 
1908 /* These will be VM-specific. */
1909 
1910 #define JDK1_2
1911 #define JDK1_4
1912 
1913 /* End VM-specific. */
1914 
1916  void *reserved0;
1917  void *reserved1;
1918  void *reserved2;
1919 
1920  jint (JNICALL *DestroyJavaVM)(JavaVM *vm);
1921 
1922  jint (JNICALL *AttachCurrentThread)(JavaVM *vm, void **penv, void *args);
1923 
1924  jint (JNICALL *DetachCurrentThread)(JavaVM *vm);
1925 
1926  jint (JNICALL *GetEnv)(JavaVM *vm, void **penv, jint version);
1927 
1928  jint (JNICALL *AttachCurrentThreadAsDaemon)(JavaVM *vm, void **penv, void *args);
1929 };
1930 
1931 struct JavaVM_ {
1933 #ifdef __cplusplus
1934 
1935  jint DestroyJavaVM() {
1936  return functions->DestroyJavaVM(this);
1937  }
1938  jint AttachCurrentThread(void **penv, void *args) {
1939  return functions->AttachCurrentThread(this, penv, args);
1940  }
1941  jint DetachCurrentThread() {
1942  return functions->DetachCurrentThread(this);
1943  }
1944 
1945  jint GetEnv(void **penv, jint version) {
1946  return functions->GetEnv(this, penv, version);
1947  }
1948  jint AttachCurrentThreadAsDaemon(void **penv, void *args) {
1949  return functions->AttachCurrentThreadAsDaemon(this, penv, args);
1950  }
1951 #endif
1952 };
1953 
1954 #ifdef _JNI_IMPLEMENTATION_
1955 #define _JNI_IMPORT_OR_EXPORT_ JNIEXPORT
1956 #else
1957 #define _JNI_IMPORT_OR_EXPORT_ JNIIMPORT
1958 #endif
1961 
1963 JNI_CreateJavaVM(JavaVM **pvm, void **penv, void *args);
1964 
1967 
1968 /* Defined by native libraries. */
1969 JNIEXPORT jint JNICALL
1970 JNI_OnLoad(JavaVM *vm, void *reserved);
1971 
1972 JNIEXPORT void JNICALL
1973 JNI_OnUnload(JavaVM *vm, void *reserved);
1974 
1975 #define JNI_VERSION_1_1 0x00010001
1976 #define JNI_VERSION_1_2 0x00010002
1977 #define JNI_VERSION_1_4 0x00010004
1978 #define JNI_VERSION_1_6 0x00010006
1979 #define JNI_VERSION_1_8 0x00010008
1980 #define JNI_VERSION_9 0x00090000
1981 #define JNI_VERSION_10 0x000a0000
1982 
1983 #ifdef __cplusplus
1984 } /* extern "C" */
1985 #endif /* __cplusplus */
1986 
1987 #endif /* !_JAVASOFT_JNI_H_ */
const struct JNINativeInterface_ * JNIEnv
Definition: jni.h:197
struct _jobject * jobject
Definition: jni.h:101
_JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_CreateJavaVM(JavaVM **pvm, void **penv, void *args)
enum _jobjectType jobjectRefType
jarray jlongArray
Definition: jni.h:111
struct JavaVMOption JavaVMOption
#define _JNI_IMPORT_OR_EXPORT_
Definition: jni.h:1957
jobject jweak
Definition: jni.h:118
union jvalue jvalue
jarray jintArray
Definition: jni.h:110
jarray jshortArray
Definition: jni.h:109
unsigned char jboolean
Definition: jni.h:57
jarray jbooleanArray
Definition: jni.h:106
const struct JNIInvokeInterface_ * JavaVM
Definition: jni.h:211
double jdouble
Definition: jni.h:61
jarray jcharArray
Definition: jni.h:108
jarray jobjectArray
Definition: jni.h:114
jobject jclass
Definition: jni.h:102
float jfloat
Definition: jni.h:60
jobject jstring
Definition: jni.h:104
struct _jfieldID * jfieldID
Definition: jni.h:133
JNIEXPORT void JNICALL JNI_OnUnload(JavaVM *vm, void *reserved)
jobject jarray
Definition: jni.h:105
jarray jdoubleArray
Definition: jni.h:113
jobject jthrowable
Definition: jni.h:103
struct _jmethodID * jmethodID
Definition: jni.h:136
struct JavaVMAttachArgs JavaVMAttachArgs
JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved)
jarray jfloatArray
Definition: jni.h:112
_JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_GetDefaultJavaVMInitArgs(void *args)
_jobjectType
Definition: jni.h:139
@ JNIWeakGlobalRefType
Definition: jni.h:143
@ JNIInvalidRefType
Definition: jni.h:140
@ JNIGlobalRefType
Definition: jni.h:142
@ JNILocalRefType
Definition: jni.h:141
jarray jbyteArray
Definition: jni.h:107
_JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_GetCreatedJavaVMs(JavaVM **, jsize, jsize *)
unsigned short jchar
Definition: jni.h:58
short jshort
Definition: jni.h:59
jint jsize
Definition: jni.h:63
struct JavaVMInitArgs JavaVMInitArgs
Definition: jni.h:787
const struct JNINativeInterface_ * functions
Definition: jni.h:788
void ** penv
Definition: jni.h:1922
void jint version
Definition: jni.h:1926
jint(JNICALL *AttachCurrentThreadAsDaemon)(JavaVM *vm
void void * args
Definition: jni.h:1922
void * reserved0
Definition: jni.h:1916
jint(JNICALL *DetachCurrentThread)(JavaVM *vm)
jint(JNICALL *GetEnv)(JavaVM *vm
void * reserved1
Definition: jni.h:1917
void * reserved2
Definition: jni.h:1918
jint(JNICALL *DestroyJavaVM)(JavaVM *vm)
jlong(JNICALL *CallNonvirtualLongMethod)(JNIEnv *env
jclass jmethodID jint(JNICALL *CallStaticIntMethodV)(JNIEnv *env
void(JNICALL *ReleasePrimitiveArrayCritical)(JNIEnv *env
jclass jmethodID jbyte(JNICALL *CallStaticByteMethodV)(JNIEnv *env
jclass jmethodID jlong(JNICALL *CallStaticLongMethodV)(JNIEnv *env
jclass jmethodID jclass jmethodID va_list args
Definition: jni.h:280
jobject(JNICALL *PopLocalFrame)(JNIEnv *env
jfieldID(JNICALL *GetFieldID)(JNIEnv *env
jlong(JNICALL *CallLongMethod)(JNIEnv *env
jfieldID(JNICALL *FromReflectedField)(JNIEnv *env
void(JNICALL *ReleaseStringUTFChars)(JNIEnv *env
jobject jclass jmethodID jdouble(JNICALL *CallNonvirtualDoubleMethodV)(JNIEnv *env
jsize jclass jobject init
Definition: jni.h:629
jobject jclass jmethodID methodID
Definition: jni.h:363
jchar(JNICALL *GetStaticCharField)(JNIEnv *env
jobject jfieldID fieldID
Definition: jni.h:456
jobject(JNICALL *NewGlobalRef)(JNIEnv *env
jstring str
Definition: jni.h:609
jshortArray jsize jsize jshort * buf
Definition: jni.h:693
jboolean(JNICALL *CallBooleanMethodA)(JNIEnv *env
const char * utf
Definition: jni.h:616
void(JNICALL *ReleaseCharArrayElements)(JNIEnv *env
jlong(JNICALL *CallNonvirtualLongMethodA)(JNIEnv *env
jshort(JNICALL *CallShortMethod)(JNIEnv *env
void(JNICALL *GetBooleanArrayRegion)(JNIEnv *env
jchar(JNICALL *CallStaticCharMethod)(JNIEnv *env
jint *JNICALL * GetIntArrayElements(JNIEnv *env, jintArray array, jboolean *isCopy)
jobject(JNICALL *GetModule)(JNIEnv *env
jobject jmethodID jobject(JNICALL *CallObjectMethodV)(JNIEnv *env
jsize(JNICALL *GetStringLength)(JNIEnv *env
jbyte *JNICALL * GetByteArrayElements(JNIEnv *env, jbyteArray array, jboolean *isCopy)
jclass jmethodID jboolean isStatic
Definition: jni.h:234
void(JNICALL *SetStaticByteField)(JNIEnv *env
jclass jfieldID jbyte value
Definition: jni.h:592
jlong(JNICALL *CallStaticLongMethod)(JNIEnv *env
jint(JNICALL *GetStaticIntField)(JNIEnv *env
jbyte(JNICALL *CallByteMethod)(JNIEnv *env
jchar(JNICALL *CallCharMethodA)(JNIEnv *env
void(JNICALL *ReleaseLongArrayElements)(JNIEnv *env
jsize(JNICALL *GetStringUTFLength)(JNIEnv *env
jclass jmethodID jshort(JNICALL *CallStaticShortMethodV)(JNIEnv *env
const char jobject loader
Definition: jni.h:223
jclass jmethodID const jvalue * args
Definition: jni.h:282
jobject jmethodID jboolean(JNICALL *CallBooleanMethodV)(JNIEnv *env
jmethodID(JNICALL *GetStaticMethodID)(JNIEnv *env
void(JNICALL *ReleaseBooleanArrayElements)(JNIEnv *env
jarray array
Definition: jni.h:626
jsize(JNICALL *GetArrayLength)(JNIEnv *env
void(JNICALL *SetFloatField)(JNIEnv *env
jobject(JNICALL *NewObjectA)(JNIEnv *env
jstring(JNICALL *NewString)(JNIEnv *env
jlong(JNICALL *GetStaticLongField)(JNIEnv *env
jobject jclass jmethodID jint(JNICALL *CallNonvirtualIntMethodV)(JNIEnv *env
void(JNICALL *ExceptionDescribe)(JNIEnv *env)
jdoubleArray jsize jsize const jdouble * buf
Definition: jni.h:718
jbyte(JNICALL *CallNonvirtualByteMethod)(JNIEnv *env
void(JNICALL *SetStaticIntField)(JNIEnv *env
void * reserved3
Definition: jni.h:219
jclass jmethodID void(JNICALL *CallStaticVoidMethodV)(JNIEnv *env
jstring jsize jsize jchar * buf
Definition: jni.h:735
jobject jfieldID jfloat val
Definition: jni.h:489
void * reserved0
Definition: jni.h:215
jbooleanArray jboolean * elems
Definition: jni.h:670
void(JNICALL *DeleteGlobalRef)(JNIEnv *env
jarray void * carray
Definition: jni.h:742
jmethodID(JNICALL *GetMethodID)(JNIEnv *env
jstring const char * chars
Definition: jni.h:622
jboolean(JNICALL *IsAssignableFrom)(JNIEnv *env
void(JNICALL *SetShortArrayRegion)(JNIEnv *env
jobjectArray jsize index
Definition: jni.h:631
jclass jmethodID jfloat(JNICALL *CallStaticFloatMethodV)(JNIEnv *env
jcharArray array
Definition: jni.h:674
jobject jclass jmethodID jbyte(JNICALL *CallNonvirtualByteMethodV)(JNIEnv *env
void(JNICALL *GetShortArrayRegion)(JNIEnv *env
jclass jfieldID jchar value
Definition: jni.h:594
const jchar jsize len
Definition: jni.h:607
jfloatArray(JNICALL *NewFloatArray)(JNIEnv *env
void(JNICALL *CallStaticVoidMethod)(JNIEnv *env
jboolean(JNICALL *CallNonvirtualBooleanMethodA)(JNIEnv *env
jcharArray jsize jsize jchar * buf
Definition: jni.h:691
jobject jclass clazz
Definition: jni.h:287
jobject jclass jmethodID jchar(JNICALL *CallNonvirtualCharMethodV)(JNIEnv *env
jdouble(JNICALL *GetDoubleField)(JNIEnv *env
void(JNICALL *CallStaticVoidMethodA)(JNIEnv *env
jint(JNICALL *Throw)(JNIEnv *env
jlongArray jsize jsize jlong * buf
Definition: jni.h:697
void(JNICALL *SetIntField)(JNIEnv *env
jboolean(JNICALL *GetBooleanField)(JNIEnv *env
void * address
Definition: jni.h:758
jclass jfieldID jlong value
Definition: jni.h:600
void(JNICALL *GetFloatArrayRegion)(JNIEnv *env
JavaVM ** vm
Definition: jni.h:732
void(JNICALL *SetBooleanField)(JNIEnv *env
void(JNICALL *SetStaticShortField)(JNIEnv *env
jchar(JNICALL *CallCharMethod)(JNIEnv *env
jobject(JNICALL *GetObjectArrayElement)(JNIEnv *env
jclass const JNINativeMethod * methods
Definition: jni.h:721
jobject jmethodID jlong(JNICALL *CallLongMethodV)(JNIEnv *env
jclass jfieldID jshort value
Definition: jni.h:596
void(JNICALL *SetByteField)(JNIEnv *env
jsize jclass clazz
Definition: jni.h:629
void(JNICALL *SetStaticCharField)(JNIEnv *env
jshortArray jsize jsize const jshort * buf
Definition: jni.h:710
jlong(JNICALL *CallLongMethodA)(JNIEnv *env
jobject(JNICALL *GetStaticObjectField)(JNIEnv *env
jchar(JNICALL *CallStaticCharMethodA)(JNIEnv *env
jobject(JNICALL *CallNonvirtualObjectMethodA)(JNIEnv *env
jboolean(JNICALL *GetStaticBooleanField)(JNIEnv *env
jclass const char * msg
Definition: jni.h:247
jbyteArray jsize jsize const jbyte * buf
Definition: jni.h:706
jthrowable(JNICALL *ExceptionOccurred)(JNIEnv *env)
jstring jsize jsize char * buf
Definition: jni.h:737
jdouble(JNICALL *CallStaticDoubleMethod)(JNIEnv *env
jobject jfieldID jlong val
Definition: jni.h:487
jshort(JNICALL *CallShortMethodA)(JNIEnv *env
jobjectArray(JNICALL *NewObjectArray)(JNIEnv *env
jclass cls
Definition: jni.h:234
const jchar *JNICALL * GetStringCritical(JNIEnv *env, jstring string, jboolean *isCopy)
jobject jfieldID jobject val
Definition: jni.h:475
jobject jmethodID methodID
Definition: jni.h:293
jcharArray jsize jsize const jchar * buf
Definition: jni.h:708
jstring const jchar * cstring
Definition: jni.h:747
jlongArray jsize jsize const jlong * buf
Definition: jni.h:714
jclass jfieldID jdouble value
Definition: jni.h:604
jlong(JNICALL *GetDirectBufferCapacity)(JNIEnv *env
jobject(JNICALL *NewDirectByteBuffer)(JNIEnv *env
jdouble(JNICALL *CallStaticDoubleMethodA)(JNIEnv *env
jobject jfieldID jchar val
Definition: jni.h:481
jlong(JNICALL *CallStaticLongMethodA)(JNIEnv *env
jobject result
Definition: jni.h:260
jclass sub
Definition: jni.h:237
jclass clazz
Definition: jni.h:247
jclass jmethodID jobject(JNICALL *NewObjectV)(JNIEnv *env
jobject jmethodID const jvalue * args
Definition: jni.h:297
jclass jmethodID jobject(JNICALL *CallStaticObjectMethodV)(JNIEnv *env
jfloat(JNICALL *CallStaticFloatMethodA)(JNIEnv *env
void(JNICALL *SetShortField)(JNIEnv *env
jobjectArray array
Definition: jni.h:631
jfloatArray array
Definition: jni.h:682
void(JNICALL *SetIntArrayRegion)(JNIEnv *env
jobject jmethodID void(JNICALL *CallVoidMethodV)(JNIEnv *env
jfloat(JNICALL *CallNonvirtualFloatMethod)(JNIEnv *env
jclass jmethodID jchar(JNICALL *CallStaticCharMethodV)(JNIEnv *env
jclass(JNICALL *GetSuperclass)(JNIEnv *env
jobject jclass jmethodID jobject jclass clazz
Definition: jni.h:365
jshort *JNICALL * GetShortArrayElements(JNIEnv *env, jshortArray array, jboolean *isCopy)
jstring string
Definition: jni.h:747
jobject jclass jmethodID jshort(JNICALL *CallNonvirtualShortMethodV)(JNIEnv *env
jbyte(JNICALL *CallStaticByteMethod)(JNIEnv *env
jbooleanArray jsize start
Definition: jni.h:687
jboolean *JNICALL * GetBooleanArrayElements(JNIEnv *env, jbooleanArray array, jboolean *isCopy)
void(JNICALL *CallNonvirtualVoidMethod)(JNIEnv *env
jobject(JNICALL *ToReflectedField)(JNIEnv *env
jbyte(JNICALL *CallNonvirtualByteMethodA)(JNIEnv *env
jboolean(JNICALL *IsSameObject)(JNIEnv *env
jboolean(JNICALL *CallNonvirtualBooleanMethod)(JNIEnv *env
jdouble(JNICALL *CallNonvirtualDoubleMethod)(JNIEnv *env
jlongArray(JNICALL *NewLongArray)(JNIEnv *env
jfieldID(JNICALL *GetStaticFieldID)(JNIEnv *env
jbooleanArray jsize jsize const jboolean * buf
Definition: jni.h:704
void(JNICALL *CallVoidMethodA)(JNIEnv *env
jboolean(JNICALL *CallStaticBooleanMethodA)(JNIEnv *env
jobject(JNICALL *NewObject)(JNIEnv *env
void(JNICALL *SetObjectField)(JNIEnv *env
jobject jmethodID jobject jmethodID va_list args
Definition: jni.h:295
jobject(JNICALL *ToReflectedMethod)(JNIEnv *env
void(JNICALL *SetDoubleArrayRegion)(JNIEnv *env
jobject(JNICALL *CallStaticObjectMethodA)(JNIEnv *env
jclass(JNICALL *GetObjectClass)(JNIEnv *env
const char * msg
Definition: jni.h:255
void(JNICALL *SetDoubleField)(JNIEnv *env
jint(JNICALL *GetVersion)(JNIEnv *env)
jfloatArray jsize jsize const jfloat * buf
Definition: jni.h:716
void(JNICALL *SetCharField)(JNIEnv *env
jobject jobject obj2
Definition: jni.h:269
jobject jclass jmethodID const jvalue * args
Definition: jni.h:369
jintArray array
Definition: jni.h:678
jdoubleArray(JNICALL *NewDoubleArray)(JNIEnv *env
const char jobject const jbyte * buf
Definition: jni.h:223
void(JNICALL *ReleaseShortArrayElements)(JNIEnv *env
jobject field
Definition: jni.h:231
jbooleanArray jsize jsize l
Definition: jni.h:687
jbyte(JNICALL *CallStaticByteMethodA)(JNIEnv *env
void(JNICALL *ReleaseStringCritical)(JNIEnv *env
jfloat(JNICALL *CallStaticFloatMethod)(JNIEnv *env
jintArray jsize jsize jint * buf
Definition: jni.h:695
jobject jfieldID jshort val
Definition: jni.h:483
void(JNICALL *SetStaticFloatField)(JNIEnv *env
jclass jmethodID jdouble(JNICALL *CallStaticDoubleMethodV)(JNIEnv *env
const jchar *JNICALL * GetStringChars(JNIEnv *env, jstring str, jboolean *isCopy)
jclass jclass sup
Definition: jni.h:239
jlong(JNICALL *GetLongField)(JNIEnv *env
void(JNICALL *ReleaseIntArrayElements)(JNIEnv *env
jobject ref
Definition: jni.h:271
jclass jmethodID jboolean(JNICALL *CallStaticBooleanMethodV)(JNIEnv *env
void(JNICALL *CallNonvirtualVoidMethodA)(JNIEnv *env
jfloat(JNICALL *CallFloatMethod)(JNIEnv *env
jobject method
Definition: jni.h:229
jobjectRefType(JNICALL *GetObjectRefType)(JNIEnv *env
jobject jmethodID jshort(JNICALL *CallShortMethodV)(JNIEnv *env
jobject jclass jmethodID void(JNICALL *CallNonvirtualVoidMethodV)(JNIEnv *env
jobject lobj
Definition: jni.h:263
void(JNICALL *SetStaticDoubleField)(JNIEnv *env
void(JNICALL *SetCharArrayRegion)(JNIEnv *env
jshort(JNICALL *CallNonvirtualShortMethod)(JNIEnv *env
jbyte(JNICALL *GetByteField)(JNIEnv *env
jintArray(JNICALL *NewIntArray)(JNIEnv *env
void *JNICALL * GetPrimitiveArrayCritical(JNIEnv *env, jarray array, jboolean *isCopy)
jbooleanArray jsize jsize jboolean * buf
Definition: jni.h:687
const char *JNICALL * GetStringUTFChars(JNIEnv *env, jstring str, jboolean *isCopy)
jdoubleArray jsize jsize jdouble * buf
Definition: jni.h:701
jobject jmethodID jdouble(JNICALL *CallDoubleMethodV)(JNIEnv *env
jobject jclass jmethodID jfloat(JNICALL *CallNonvirtualFloatMethodV)(JNIEnv *env
void(JNICALL *CallVoidMethod)(JNIEnv *env
void *JNICALL * GetDirectBufferAddress(JNIEnv *env, jobject buf)
jint(JNICALL *CallStaticIntMethodA)(JNIEnv *env
void(JNICALL *GetIntArrayRegion)(JNIEnv *env
jobject(JNICALL *AllocObject)(JNIEnv *env
jclass jfieldID jint value
Definition: jni.h:598
const char jobject const jbyte jsize len
Definition: jni.h:224
jobject(JNICALL *NewLocalRef)(JNIEnv *env
jfloat(JNICALL *GetFloatField)(JNIEnv *env
jclass const JNINativeMethod jint nMethods
Definition: jni.h:722
jdouble(JNICALL *CallNonvirtualDoubleMethodA)(JNIEnv *env
jobject jmethodID jbyte(JNICALL *CallByteMethodV)(JNIEnv *env
jchar(JNICALL *CallNonvirtualCharMethod)(JNIEnv *env
jdoubleArray array
Definition: jni.h:684
jchar(JNICALL *GetCharField)(JNIEnv *env
jint(JNICALL *MonitorExit)(JNIEnv *env
jclass jfieldID jboolean value
Definition: jni.h:590
void * reserved2
Definition: jni.h:217
jobject jmethodID jint(JNICALL *CallIntMethodV)(JNIEnv *env
jshortArray(JNICALL *NewShortArray)(JNIEnv *env
jint(JNICALL *CallNonvirtualIntMethod)(JNIEnv *env
jobject gref
Definition: jni.h:265
void(JNICALL *ReleaseDoubleArrayElements)(JNIEnv *env
jobjectArray jsize jobject val
Definition: jni.h:633
void(JNICALL *SetFloatArrayRegion)(JNIEnv *env
jstring const jchar * chars
Definition: jni.h:613
jbyteArray(JNICALL *NewByteArray)(JNIEnv *env
void(JNICALL *GetDoubleArrayRegion)(JNIEnv *env
jint(JNICALL *GetJavaVM)(JNIEnv *env
jint(JNICALL *CallIntMethodA)(JNIEnv *env
jclass(JNICALL *FindClass)(JNIEnv *env
void(JNICALL *GetCharArrayRegion)(JNIEnv *env
jobject buf
Definition: jni.h:762
jfloat *JNICALL * GetFloatArrayElements(JNIEnv *env, jfloatArray array, jboolean *isCopy)
void(JNICALL *DeleteLocalRef)(JNIEnv *env
jbyte(JNICALL *CallByteMethodA)(JNIEnv *env
jobject jmethodID jchar(JNICALL *CallCharMethodV)(JNIEnv *env
jbyteArray array
Definition: jni.h:672
jobject jfieldID jboolean val
Definition: jni.h:477
void(JNICALL *SetStaticLongField)(JNIEnv *env
void(JNICALL *DeleteWeakGlobalRef)(JNIEnv *env
void(JNICALL *SetLongField)(JNIEnv *env
void(JNICALL *ReleaseByteArrayElements)(JNIEnv *env
jweak(JNICALL *NewWeakGlobalRef)(JNIEnv *env
jshort(JNICALL *GetStaticShortField)(JNIEnv *env
jobject(JNICALL *CallNonvirtualObjectMethod)(JNIEnv *env
jint(JNICALL *CallIntMethod)(JNIEnv *env
jclass const char * name
Definition: jni.h:290
jint(JNICALL *CallNonvirtualIntMethodA)(JNIEnv *env
jint(JNICALL *CallStaticIntMethod)(JNIEnv *env
void(JNICALL *ReleaseFloatArrayElements)(JNIEnv *env
const char * name
Definition: jni.h:223
jshortArray array
Definition: jni.h:676
jdouble *JNICALL * GetDoubleArrayElements(JNIEnv *env, jdoubleArray array, jboolean *isCopy)
void(JNICALL *SetStaticObjectField)(JNIEnv *env
jobject(JNICALL *CallObjectMethodA)(JNIEnv *env
void(JNICALL *GetStringRegion)(JNIEnv *env
jclass jmethodID methodID
Definition: jni.h:234
void(JNICALL *SetBooleanArrayRegion)(JNIEnv *env
void(JNICALL *GetLongArrayRegion)(JNIEnv *env
jshort(JNICALL *GetShortField)(JNIEnv *env
jobject jmethodID jfloat(JNICALL *CallFloatMethodV)(JNIEnv *env
jboolean(JNICALL *CallBooleanMethod)(JNIEnv *env
jfloatArray jsize jsize jfloat * buf
Definition: jni.h:699
void(JNICALL *GetByteArrayRegion)(JNIEnv *env
jobject jfieldID jdouble val
Definition: jni.h:491
void(JNICALL *SetByteArrayRegion)(JNIEnv *env
jobject jclass jmethodID jobject(JNICALL *CallNonvirtualObjectMethodV)(JNIEnv *env
const jchar * unicode
Definition: jni.h:607
jbooleanArray(JNICALL *NewBooleanArray)(JNIEnv *env
jint(JNICALL *RegisterNatives)(JNIEnv *env
void(JNICALL *GetStringUTFRegion)(JNIEnv *env
jshort(JNICALL *CallStaticShortMethodA)(JNIEnv *env
jstring(JNICALL *NewStringUTF)(JNIEnv *env
jthrowable obj
Definition: jni.h:245
jboolean(JNICALL *IsInstanceOf)(JNIEnv *env
jchar(JNICALL *CallNonvirtualCharMethodA)(JNIEnv *env
jint(JNICALL *ThrowNew)(JNIEnv *env
jcharArray(JNICALL *NewCharArray)(JNIEnv *env
void * reserved1
Definition: jni.h:216
jclass(JNICALL *DefineClass)(JNIEnv *env
jobject obj1
Definition: jni.h:269
jobject jfieldID jbyte val
Definition: jni.h:479
jclass jfieldID jobject value
Definition: jni.h:588
jobject(JNICALL *CallStaticObjectMethod)(JNIEnv *env
jint(JNICALL *EnsureLocalCapacity)(JNIEnv *env
jfloat(JNICALL *GetStaticFloatField)(JNIEnv *env
jobject jfieldID jint val
Definition: jni.h:485
jint(JNICALL *UnregisterNatives)(JNIEnv *env
jint(JNICALL *MonitorEnter)(JNIEnv *env
jbyte(JNICALL *GetStaticByteField)(JNIEnv *env
void(JNICALL *ReleaseStringChars)(JNIEnv *env
jlongArray array
Definition: jni.h:680
void(JNICALL *SetObjectArrayElement)(JNIEnv *env
void(JNICALL *FatalError)(JNIEnv *env
jclass jmethodID jclass cls
Definition: jni.h:562
jdouble(JNICALL *GetStaticDoubleField)(JNIEnv *env
jchar *JNICALL * GetCharArrayElements(JNIEnv *env, jcharArray array, jboolean *isCopy)
jobject(JNICALL *CallObjectMethod)(JNIEnv *env
jdouble(JNICALL *CallDoubleMethodA)(JNIEnv *env
jdouble(JNICALL *CallDoubleMethod)(JNIEnv *env
void(JNICALL *SetStaticBooleanField)(JNIEnv *env
jlong *JNICALL * GetLongArrayElements(JNIEnv *env, jlongArray array, jboolean *isCopy)
jfloat(JNICALL *CallFloatMethodA)(JNIEnv *env
jmethodID(JNICALL *FromReflectedMethod)(JNIEnv *env
jint(JNICALL *PushLocalFrame)(JNIEnv *env
jclass jfieldID fieldID
Definition: jni.h:242
jbooleanArray jboolean jint mode
Definition: jni.h:670
jbooleanArray array
Definition: jni.h:670
jshort(JNICALL *CallNonvirtualShortMethodA)(JNIEnv *env
void(JNICALL *SetLongArrayRegion)(JNIEnv *env
jboolean(JNICALL *ExceptionCheck)(JNIEnv *env)
jobject jclass jmethodID jlong(JNICALL *CallNonvirtualLongMethodV)(JNIEnv *env
jbyteArray jsize jsize jbyte * buf
Definition: jni.h:689
jshort(JNICALL *CallStaticShortMethod)(JNIEnv *env
jobject(JNICALL *GetObjectField)(JNIEnv *env
jint(JNICALL *GetIntField)(JNIEnv *env
jboolean(JNICALL *CallStaticBooleanMethod)(JNIEnv *env
jclass const char const char * sig
Definition: jni.h:290
jintArray jsize jsize const jint * buf
Definition: jni.h:712
jclass jfieldID jfloat value
Definition: jni.h:602
void(JNICALL *ExceptionClear)(JNIEnv *env)
jobject jclass jmethodID jboolean(JNICALL *CallNonvirtualBooleanMethodV)(JNIEnv *env
jobject jclass jmethodID jobject jclass jmethodID va_list args
Definition: jni.h:366
jfloat(JNICALL *CallNonvirtualFloatMethodA)(JNIEnv *env
char * signature
Definition: jni.h:182
char * name
Definition: jni.h:181
void * fnPtr
Definition: jni.h:183
jobject group
Definition: jni.h:1905
jint version
Definition: jni.h:1902
char * name
Definition: jni.h:1904
jboolean ignoreUnrecognized
Definition: jni.h:1898
jint version
Definition: jni.h:1894
jint nOptions
Definition: jni.h:1896
JavaVMOption * options
Definition: jni.h:1897
void * extraInfo
Definition: jni.h:1890
char * optionString
Definition: jni.h:1889
Definition: jni.h:1931
const struct JNIInvokeInterface_ * functions
Definition: jni.h:1932
Definition: jni.h:120
jchar c
Definition: jni.h:123
jboolean z
Definition: jni.h:121
jshort s
Definition: jni.h:124
jint i
Definition: jni.h:125
jobject l
Definition: jni.h:129
jdouble d
Definition: jni.h:128
jlong j
Definition: jni.h:126
jfloat f
Definition: jni.h:127
jbyte b
Definition: jni.h:122