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