1 /* -*- Mode: C++; indent-tabs-mode: t; tab-width: 4 -*-
2 * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
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.
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).
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.
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
27 * We used part of Netscape's Java Runtime Interface (JRI) as the starting
28 * point of our design and implementation.
31 /******************************************************************************
32 * Java Runtime Interface
33 * Copyright (c) 1996 Netscape Communications Corporation. All rights reserved.
34 *****************************************************************************/
36 #ifndef _JAVASOFT_JNI_H_
37 #define _JAVASOFT_JNI_H_
42 /* jni_md.h contains the machine-dependent typedefs for jbyte, jint
45 #if defined(__linux__)
46 #include "jni_linux.h"
49 #elif defined(__APPLE__)
63 #ifndef JNI_TYPES_ALREADY_DEFINED_IN_JNI_MD_H
65 typedef unsigned char jboolean
;
66 typedef unsigned short jchar
;
69 typedef double jdouble
;
76 class _jclass
: public _jobject
{};
77 class _jthrowable
: public _jobject
{};
78 class _jstring
: public _jobject
{};
79 class _jarray
: public _jobject
{};
80 class _jbooleanArray
: public _jarray
{};
81 class _jbyteArray
: public _jarray
{};
82 class _jcharArray
: public _jarray
{};
83 class _jshortArray
: public _jarray
{};
84 class _jintArray
: public _jarray
{};
85 class _jlongArray
: public _jarray
{};
86 class _jfloatArray
: public _jarray
{};
87 class _jdoubleArray
: public _jarray
{};
88 class _jobjectArray
: public _jarray
{};
90 typedef _jobject
*jobject
;
91 typedef _jclass
*jclass
;
92 typedef _jthrowable
*jthrowable
;
93 typedef _jstring
*jstring
;
94 typedef _jarray
*jarray
;
95 typedef _jbooleanArray
*jbooleanArray
;
96 typedef _jbyteArray
*jbyteArray
;
97 typedef _jcharArray
*jcharArray
;
98 typedef _jshortArray
*jshortArray
;
99 typedef _jintArray
*jintArray
;
100 typedef _jlongArray
*jlongArray
;
101 typedef _jfloatArray
*jfloatArray
;
102 typedef _jdoubleArray
*jdoubleArray
;
103 typedef _jobjectArray
*jobjectArray
;
109 typedef struct _jobject
*jobject
;
110 typedef jobject jclass
;
111 typedef jobject jthrowable
;
112 typedef jobject jstring
;
113 typedef jobject jarray
;
114 typedef jarray jbooleanArray
;
115 typedef jarray jbyteArray
;
116 typedef jarray jcharArray
;
117 typedef jarray jshortArray
;
118 typedef jarray jintArray
;
119 typedef jarray jlongArray
;
120 typedef jarray jfloatArray
;
121 typedef jarray jdoubleArray
;
122 typedef jarray jobjectArray
;
126 typedef jobject jweak
;
128 typedef union jvalue
{
141 typedef struct _jfieldID
*jfieldID
;
144 typedef struct _jmethodID
*jmethodID
;
146 /* Return values from jobjectRefType */
147 typedef enum _jobjectType
{
148 JNIInvalidRefType
= 0,
150 JNIGlobalRefType
= 2,
151 JNIWeakGlobalRefType
= 3
155 #endif /* JNI_TYPES_ALREADY_DEFINED_IN_JNI_MD_H */
165 * possible return values for JNI functions.
168 #define JNI_OK 0 /* success */
169 #define JNI_ERR (-1) /* unknown error */
170 #define JNI_EDETACHED (-2) /* thread detached from the VM */
171 #define JNI_EVERSION (-3) /* JNI version error */
172 #define JNI_ENOMEM (-4) /* not enough memory */
173 #define JNI_EEXIST (-5) /* VM already created */
174 #define JNI_EINVAL (-6) /* invalid arguments */
177 * used in ReleaseScalarArrayElements
184 * used in RegisterNatives to describe native method name, signature,
185 * and function pointer.
190 const char *signature
;
195 * JNI Native Method Interface.
198 struct JNINativeInterface_
;
203 typedef JNIEnv_ JNIEnv
;
205 typedef const struct JNINativeInterface_
*JNIEnv
;
209 * JNI Invocation Interface.
212 struct JNIInvokeInterface_
;
217 typedef JavaVM_ JavaVM
;
219 typedef const struct JNIInvokeInterface_
*JavaVM
;
222 struct JNINativeInterface_
{
228 jint (JNICALL
*GetVersion
)(JNIEnv
*env
);
230 jclass (JNICALL
*DefineClass
)
231 (JNIEnv
*env
, const char *name
, jobject loader
, const jbyte
*buf
,
233 jclass (JNICALL
*FindClass
)
234 (JNIEnv
*env
, const char *name
);
236 jmethodID (JNICALL
*FromReflectedMethod
)
237 (JNIEnv
*env
, jobject method
);
238 jfieldID (JNICALL
*FromReflectedField
)
239 (JNIEnv
*env
, jobject field
);
241 jobject (JNICALL
*ToReflectedMethod
)
242 (JNIEnv
*env
, jclass cls
, jmethodID methodID
, jboolean isStatic
);
244 jclass (JNICALL
*GetSuperclass
)
245 (JNIEnv
*env
, jclass sub
);
246 jboolean (JNICALL
*IsAssignableFrom
)
247 (JNIEnv
*env
, jclass sub
, jclass sup
);
249 jobject (JNICALL
*ToReflectedField
)
250 (JNIEnv
*env
, jclass cls
, jfieldID fieldID
, jboolean isStatic
);
252 jint (JNICALL
*Throw
)
253 (JNIEnv
*env
, jthrowable obj
);
254 jint (JNICALL
*ThrowNew
)
255 (JNIEnv
*env
, jclass clazz
, const char *msg
);
256 jthrowable (JNICALL
*ExceptionOccurred
)
258 void (JNICALL
*ExceptionDescribe
)
260 void (JNICALL
*ExceptionClear
)
262 void (JNICALL
*FatalError
)
263 (JNIEnv
*env
, const char *msg
);
265 jint (JNICALL
*PushLocalFrame
)
266 (JNIEnv
*env
, jint capacity
);
267 jobject (JNICALL
*PopLocalFrame
)
268 (JNIEnv
*env
, jobject result
);
270 jobject (JNICALL
*NewGlobalRef
)
271 (JNIEnv
*env
, jobject lobj
);
272 void (JNICALL
*DeleteGlobalRef
)
273 (JNIEnv
*env
, jobject gref
);
274 void (JNICALL
*DeleteLocalRef
)
275 (JNIEnv
*env
, jobject obj
);
276 jboolean (JNICALL
*IsSameObject
)
277 (JNIEnv
*env
, jobject obj1
, jobject obj2
);
278 jobject (JNICALL
*NewLocalRef
)
279 (JNIEnv
*env
, jobject ref
);
280 jint (JNICALL
*EnsureLocalCapacity
)
281 (JNIEnv
*env
, jint capacity
);
283 jobject (JNICALL
*AllocObject
)
284 (JNIEnv
*env
, jclass clazz
);
285 jobject (JNICALL
*NewObject
)
286 (JNIEnv
*env
, jclass clazz
, jmethodID methodID
, ...);
287 jobject (JNICALL
*NewObjectV
)
288 (JNIEnv
*env
, jclass clazz
, jmethodID methodID
, va_list args
);
289 jobject (JNICALL
*NewObjectA
)
290 (JNIEnv
*env
, jclass clazz
, jmethodID methodID
, const jvalue
*args
);
292 jclass (JNICALL
*GetObjectClass
)
293 (JNIEnv
*env
, jobject obj
);
294 jboolean (JNICALL
*IsInstanceOf
)
295 (JNIEnv
*env
, jobject obj
, jclass clazz
);
297 jmethodID (JNICALL
*GetMethodID
)
298 (JNIEnv
*env
, jclass clazz
, const char *name
, const char *sig
);
300 jobject (JNICALL
*CallObjectMethod
)
301 (JNIEnv
*env
, jobject obj
, jmethodID methodID
, ...);
302 jobject (JNICALL
*CallObjectMethodV
)
303 (JNIEnv
*env
, jobject obj
, jmethodID methodID
, va_list args
);
304 jobject (JNICALL
*CallObjectMethodA
)
305 (JNIEnv
*env
, jobject obj
, jmethodID methodID
, const jvalue
* args
);
307 jboolean (JNICALL
*CallBooleanMethod
)
308 (JNIEnv
*env
, jobject obj
, jmethodID methodID
, ...);
309 jboolean (JNICALL
*CallBooleanMethodV
)
310 (JNIEnv
*env
, jobject obj
, jmethodID methodID
, va_list args
);
311 jboolean (JNICALL
*CallBooleanMethodA
)
312 (JNIEnv
*env
, jobject obj
, jmethodID methodID
, const jvalue
* args
);
314 jbyte (JNICALL
*CallByteMethod
)
315 (JNIEnv
*env
, jobject obj
, jmethodID methodID
, ...);
316 jbyte (JNICALL
*CallByteMethodV
)
317 (JNIEnv
*env
, jobject obj
, jmethodID methodID
, va_list args
);
318 jbyte (JNICALL
*CallByteMethodA
)
319 (JNIEnv
*env
, jobject obj
, jmethodID methodID
, const jvalue
*args
);
321 jchar (JNICALL
*CallCharMethod
)
322 (JNIEnv
*env
, jobject obj
, jmethodID methodID
, ...);
323 jchar (JNICALL
*CallCharMethodV
)
324 (JNIEnv
*env
, jobject obj
, jmethodID methodID
, va_list args
);
325 jchar (JNICALL
*CallCharMethodA
)
326 (JNIEnv
*env
, jobject obj
, jmethodID methodID
, const jvalue
*args
);
328 jshort (JNICALL
*CallShortMethod
)
329 (JNIEnv
*env
, jobject obj
, jmethodID methodID
, ...);
330 jshort (JNICALL
*CallShortMethodV
)
331 (JNIEnv
*env
, jobject obj
, jmethodID methodID
, va_list args
);
332 jshort (JNICALL
*CallShortMethodA
)
333 (JNIEnv
*env
, jobject obj
, jmethodID methodID
, const jvalue
*args
);
335 jint (JNICALL
*CallIntMethod
)
336 (JNIEnv
*env
, jobject obj
, jmethodID methodID
, ...);
337 jint (JNICALL
*CallIntMethodV
)
338 (JNIEnv
*env
, jobject obj
, jmethodID methodID
, va_list args
);
339 jint (JNICALL
*CallIntMethodA
)
340 (JNIEnv
*env
, jobject obj
, jmethodID methodID
, const jvalue
*args
);
342 jlong (JNICALL
*CallLongMethod
)
343 (JNIEnv
*env
, jobject obj
, jmethodID methodID
, ...);
344 jlong (JNICALL
*CallLongMethodV
)
345 (JNIEnv
*env
, jobject obj
, jmethodID methodID
, va_list args
);
346 jlong (JNICALL
*CallLongMethodA
)
347 (JNIEnv
*env
, jobject obj
, jmethodID methodID
, const jvalue
*args
);
349 jfloat (JNICALL
*CallFloatMethod
)
350 (JNIEnv
*env
, jobject obj
, jmethodID methodID
, ...);
351 jfloat (JNICALL
*CallFloatMethodV
)
352 (JNIEnv
*env
, jobject obj
, jmethodID methodID
, va_list args
);
353 jfloat (JNICALL
*CallFloatMethodA
)
354 (JNIEnv
*env
, jobject obj
, jmethodID methodID
, const jvalue
*args
);
356 jdouble (JNICALL
*CallDoubleMethod
)
357 (JNIEnv
*env
, jobject obj
, jmethodID methodID
, ...);
358 jdouble (JNICALL
*CallDoubleMethodV
)
359 (JNIEnv
*env
, jobject obj
, jmethodID methodID
, va_list args
);
360 jdouble (JNICALL
*CallDoubleMethodA
)
361 (JNIEnv
*env
, jobject obj
, jmethodID methodID
, const jvalue
*args
);
363 void (JNICALL
*CallVoidMethod
)
364 (JNIEnv
*env
, jobject obj
, jmethodID methodID
, ...);
365 void (JNICALL
*CallVoidMethodV
)
366 (JNIEnv
*env
, jobject obj
, jmethodID methodID
, va_list args
);
367 void (JNICALL
*CallVoidMethodA
)
368 (JNIEnv
*env
, jobject obj
, jmethodID methodID
, const jvalue
* args
);
370 jobject (JNICALL
*CallNonvirtualObjectMethod
)
371 (JNIEnv
*env
, jobject obj
, jclass clazz
, jmethodID methodID
, ...);
372 jobject (JNICALL
*CallNonvirtualObjectMethodV
)
373 (JNIEnv
*env
, jobject obj
, jclass clazz
, jmethodID methodID
,
375 jobject (JNICALL
*CallNonvirtualObjectMethodA
)
376 (JNIEnv
*env
, jobject obj
, jclass clazz
, jmethodID methodID
,
377 const jvalue
* args
);
379 jboolean (JNICALL
*CallNonvirtualBooleanMethod
)
380 (JNIEnv
*env
, jobject obj
, jclass clazz
, jmethodID methodID
, ...);
381 jboolean (JNICALL
*CallNonvirtualBooleanMethodV
)
382 (JNIEnv
*env
, jobject obj
, jclass clazz
, jmethodID methodID
,
384 jboolean (JNICALL
*CallNonvirtualBooleanMethodA
)
385 (JNIEnv
*env
, jobject obj
, jclass clazz
, jmethodID methodID
,
386 const jvalue
* args
);
388 jbyte (JNICALL
*CallNonvirtualByteMethod
)
389 (JNIEnv
*env
, jobject obj
, jclass clazz
, jmethodID methodID
, ...);
390 jbyte (JNICALL
*CallNonvirtualByteMethodV
)
391 (JNIEnv
*env
, jobject obj
, jclass clazz
, jmethodID methodID
,
393 jbyte (JNICALL
*CallNonvirtualByteMethodA
)
394 (JNIEnv
*env
, jobject obj
, jclass clazz
, jmethodID methodID
,
397 jchar (JNICALL
*CallNonvirtualCharMethod
)
398 (JNIEnv
*env
, jobject obj
, jclass clazz
, jmethodID methodID
, ...);
399 jchar (JNICALL
*CallNonvirtualCharMethodV
)
400 (JNIEnv
*env
, jobject obj
, jclass clazz
, jmethodID methodID
,
402 jchar (JNICALL
*CallNonvirtualCharMethodA
)
403 (JNIEnv
*env
, jobject obj
, jclass clazz
, jmethodID methodID
,
406 jshort (JNICALL
*CallNonvirtualShortMethod
)
407 (JNIEnv
*env
, jobject obj
, jclass clazz
, jmethodID methodID
, ...);
408 jshort (JNICALL
*CallNonvirtualShortMethodV
)
409 (JNIEnv
*env
, jobject obj
, jclass clazz
, jmethodID methodID
,
411 jshort (JNICALL
*CallNonvirtualShortMethodA
)
412 (JNIEnv
*env
, jobject obj
, jclass clazz
, jmethodID methodID
,
415 jint (JNICALL
*CallNonvirtualIntMethod
)
416 (JNIEnv
*env
, jobject obj
, jclass clazz
, jmethodID methodID
, ...);
417 jint (JNICALL
*CallNonvirtualIntMethodV
)
418 (JNIEnv
*env
, jobject obj
, jclass clazz
, jmethodID methodID
,
420 jint (JNICALL
*CallNonvirtualIntMethodA
)
421 (JNIEnv
*env
, jobject obj
, jclass clazz
, jmethodID methodID
,
424 jlong (JNICALL
*CallNonvirtualLongMethod
)
425 (JNIEnv
*env
, jobject obj
, jclass clazz
, jmethodID methodID
, ...);
426 jlong (JNICALL
*CallNonvirtualLongMethodV
)
427 (JNIEnv
*env
, jobject obj
, jclass clazz
, jmethodID methodID
,
429 jlong (JNICALL
*CallNonvirtualLongMethodA
)
430 (JNIEnv
*env
, jobject obj
, jclass clazz
, jmethodID methodID
,
433 jfloat (JNICALL
*CallNonvirtualFloatMethod
)
434 (JNIEnv
*env
, jobject obj
, jclass clazz
, jmethodID methodID
, ...);
435 jfloat (JNICALL
*CallNonvirtualFloatMethodV
)
436 (JNIEnv
*env
, jobject obj
, jclass clazz
, jmethodID methodID
,
438 jfloat (JNICALL
*CallNonvirtualFloatMethodA
)
439 (JNIEnv
*env
, jobject obj
, jclass clazz
, jmethodID methodID
,
442 jdouble (JNICALL
*CallNonvirtualDoubleMethod
)
443 (JNIEnv
*env
, jobject obj
, jclass clazz
, jmethodID methodID
, ...);
444 jdouble (JNICALL
*CallNonvirtualDoubleMethodV
)
445 (JNIEnv
*env
, jobject obj
, jclass clazz
, jmethodID methodID
,
447 jdouble (JNICALL
*CallNonvirtualDoubleMethodA
)
448 (JNIEnv
*env
, jobject obj
, jclass clazz
, jmethodID methodID
,
451 void (JNICALL
*CallNonvirtualVoidMethod
)
452 (JNIEnv
*env
, jobject obj
, jclass clazz
, jmethodID methodID
, ...);
453 void (JNICALL
*CallNonvirtualVoidMethodV
)
454 (JNIEnv
*env
, jobject obj
, jclass clazz
, jmethodID methodID
,
456 void (JNICALL
*CallNonvirtualVoidMethodA
)
457 (JNIEnv
*env
, jobject obj
, jclass clazz
, jmethodID methodID
,
458 const jvalue
* args
);
460 jfieldID (JNICALL
*GetFieldID
)
461 (JNIEnv
*env
, jclass clazz
, const char *name
, const char *sig
);
463 jobject (JNICALL
*GetObjectField
)
464 (JNIEnv
*env
, jobject obj
, jfieldID fieldID
);
465 jboolean (JNICALL
*GetBooleanField
)
466 (JNIEnv
*env
, jobject obj
, jfieldID fieldID
);
467 jbyte (JNICALL
*GetByteField
)
468 (JNIEnv
*env
, jobject obj
, jfieldID fieldID
);
469 jchar (JNICALL
*GetCharField
)
470 (JNIEnv
*env
, jobject obj
, jfieldID fieldID
);
471 jshort (JNICALL
*GetShortField
)
472 (JNIEnv
*env
, jobject obj
, jfieldID fieldID
);
473 jint (JNICALL
*GetIntField
)
474 (JNIEnv
*env
, jobject obj
, jfieldID fieldID
);
475 jlong (JNICALL
*GetLongField
)
476 (JNIEnv
*env
, jobject obj
, jfieldID fieldID
);
477 jfloat (JNICALL
*GetFloatField
)
478 (JNIEnv
*env
, jobject obj
, jfieldID fieldID
);
479 jdouble (JNICALL
*GetDoubleField
)
480 (JNIEnv
*env
, jobject obj
, jfieldID fieldID
);
482 void (JNICALL
*SetObjectField
)
483 (JNIEnv
*env
, jobject obj
, jfieldID fieldID
, jobject val
);
484 void (JNICALL
*SetBooleanField
)
485 (JNIEnv
*env
, jobject obj
, jfieldID fieldID
, jboolean val
);
486 void (JNICALL
*SetByteField
)
487 (JNIEnv
*env
, jobject obj
, jfieldID fieldID
, jbyte val
);
488 void (JNICALL
*SetCharField
)
489 (JNIEnv
*env
, jobject obj
, jfieldID fieldID
, jchar val
);
490 void (JNICALL
*SetShortField
)
491 (JNIEnv
*env
, jobject obj
, jfieldID fieldID
, jshort val
);
492 void (JNICALL
*SetIntField
)
493 (JNIEnv
*env
, jobject obj
, jfieldID fieldID
, jint val
);
494 void (JNICALL
*SetLongField
)
495 (JNIEnv
*env
, jobject obj
, jfieldID fieldID
, jlong val
);
496 void (JNICALL
*SetFloatField
)
497 (JNIEnv
*env
, jobject obj
, jfieldID fieldID
, jfloat val
);
498 void (JNICALL
*SetDoubleField
)
499 (JNIEnv
*env
, jobject obj
, jfieldID fieldID
, jdouble val
);
501 jmethodID (JNICALL
*GetStaticMethodID
)
502 (JNIEnv
*env
, jclass clazz
, const char *name
, const char *sig
);
504 jobject (JNICALL
*CallStaticObjectMethod
)
505 (JNIEnv
*env
, jclass clazz
, jmethodID methodID
, ...);
506 jobject (JNICALL
*CallStaticObjectMethodV
)
507 (JNIEnv
*env
, jclass clazz
, jmethodID methodID
, va_list args
);
508 jobject (JNICALL
*CallStaticObjectMethodA
)
509 (JNIEnv
*env
, jclass clazz
, jmethodID methodID
, const jvalue
*args
);
511 jboolean (JNICALL
*CallStaticBooleanMethod
)
512 (JNIEnv
*env
, jclass clazz
, jmethodID methodID
, ...);
513 jboolean (JNICALL
*CallStaticBooleanMethodV
)
514 (JNIEnv
*env
, jclass clazz
, jmethodID methodID
, va_list args
);
515 jboolean (JNICALL
*CallStaticBooleanMethodA
)
516 (JNIEnv
*env
, jclass clazz
, jmethodID methodID
, const jvalue
*args
);
518 jbyte (JNICALL
*CallStaticByteMethod
)
519 (JNIEnv
*env
, jclass clazz
, jmethodID methodID
, ...);
520 jbyte (JNICALL
*CallStaticByteMethodV
)
521 (JNIEnv
*env
, jclass clazz
, jmethodID methodID
, va_list args
);
522 jbyte (JNICALL
*CallStaticByteMethodA
)
523 (JNIEnv
*env
, jclass clazz
, jmethodID methodID
, const jvalue
*args
);
525 jchar (JNICALL
*CallStaticCharMethod
)
526 (JNIEnv
*env
, jclass clazz
, jmethodID methodID
, ...);
527 jchar (JNICALL
*CallStaticCharMethodV
)
528 (JNIEnv
*env
, jclass clazz
, jmethodID methodID
, va_list args
);
529 jchar (JNICALL
*CallStaticCharMethodA
)
530 (JNIEnv
*env
, jclass clazz
, jmethodID methodID
, const jvalue
*args
);
532 jshort (JNICALL
*CallStaticShortMethod
)
533 (JNIEnv
*env
, jclass clazz
, jmethodID methodID
, ...);
534 jshort (JNICALL
*CallStaticShortMethodV
)
535 (JNIEnv
*env
, jclass clazz
, jmethodID methodID
, va_list args
);
536 jshort (JNICALL
*CallStaticShortMethodA
)
537 (JNIEnv
*env
, jclass clazz
, jmethodID methodID
, const jvalue
*args
);
539 jint (JNICALL
*CallStaticIntMethod
)
540 (JNIEnv
*env
, jclass clazz
, jmethodID methodID
, ...);
541 jint (JNICALL
*CallStaticIntMethodV
)
542 (JNIEnv
*env
, jclass clazz
, jmethodID methodID
, va_list args
);
543 jint (JNICALL
*CallStaticIntMethodA
)
544 (JNIEnv
*env
, jclass clazz
, jmethodID methodID
, const jvalue
*args
);
546 jlong (JNICALL
*CallStaticLongMethod
)
547 (JNIEnv
*env
, jclass clazz
, jmethodID methodID
, ...);
548 jlong (JNICALL
*CallStaticLongMethodV
)
549 (JNIEnv
*env
, jclass clazz
, jmethodID methodID
, va_list args
);
550 jlong (JNICALL
*CallStaticLongMethodA
)
551 (JNIEnv
*env
, jclass clazz
, jmethodID methodID
, const jvalue
*args
);
553 jfloat (JNICALL
*CallStaticFloatMethod
)
554 (JNIEnv
*env
, jclass clazz
, jmethodID methodID
, ...);
555 jfloat (JNICALL
*CallStaticFloatMethodV
)
556 (JNIEnv
*env
, jclass clazz
, jmethodID methodID
, va_list args
);
557 jfloat (JNICALL
*CallStaticFloatMethodA
)
558 (JNIEnv
*env
, jclass clazz
, jmethodID methodID
, const jvalue
*args
);
560 jdouble (JNICALL
*CallStaticDoubleMethod
)
561 (JNIEnv
*env
, jclass clazz
, jmethodID methodID
, ...);
562 jdouble (JNICALL
*CallStaticDoubleMethodV
)
563 (JNIEnv
*env
, jclass clazz
, jmethodID methodID
, va_list args
);
564 jdouble (JNICALL
*CallStaticDoubleMethodA
)
565 (JNIEnv
*env
, jclass clazz
, jmethodID methodID
, const jvalue
*args
);
567 void (JNICALL
*CallStaticVoidMethod
)
568 (JNIEnv
*env
, jclass cls
, jmethodID methodID
, ...);
569 void (JNICALL
*CallStaticVoidMethodV
)
570 (JNIEnv
*env
, jclass cls
, jmethodID methodID
, va_list args
);
571 void (JNICALL
*CallStaticVoidMethodA
)
572 (JNIEnv
*env
, jclass cls
, jmethodID methodID
, const jvalue
* args
);
574 jfieldID (JNICALL
*GetStaticFieldID
)
575 (JNIEnv
*env
, jclass clazz
, const char *name
, const char *sig
);
576 jobject (JNICALL
*GetStaticObjectField
)
577 (JNIEnv
*env
, jclass clazz
, jfieldID fieldID
);
578 jboolean (JNICALL
*GetStaticBooleanField
)
579 (JNIEnv
*env
, jclass clazz
, jfieldID fieldID
);
580 jbyte (JNICALL
*GetStaticByteField
)
581 (JNIEnv
*env
, jclass clazz
, jfieldID fieldID
);
582 jchar (JNICALL
*GetStaticCharField
)
583 (JNIEnv
*env
, jclass clazz
, jfieldID fieldID
);
584 jshort (JNICALL
*GetStaticShortField
)
585 (JNIEnv
*env
, jclass clazz
, jfieldID fieldID
);
586 jint (JNICALL
*GetStaticIntField
)
587 (JNIEnv
*env
, jclass clazz
, jfieldID fieldID
);
588 jlong (JNICALL
*GetStaticLongField
)
589 (JNIEnv
*env
, jclass clazz
, jfieldID fieldID
);
590 jfloat (JNICALL
*GetStaticFloatField
)
591 (JNIEnv
*env
, jclass clazz
, jfieldID fieldID
);
592 jdouble (JNICALL
*GetStaticDoubleField
)
593 (JNIEnv
*env
, jclass clazz
, jfieldID fieldID
);
595 void (JNICALL
*SetStaticObjectField
)
596 (JNIEnv
*env
, jclass clazz
, jfieldID fieldID
, jobject value
);
597 void (JNICALL
*SetStaticBooleanField
)
598 (JNIEnv
*env
, jclass clazz
, jfieldID fieldID
, jboolean value
);
599 void (JNICALL
*SetStaticByteField
)
600 (JNIEnv
*env
, jclass clazz
, jfieldID fieldID
, jbyte value
);
601 void (JNICALL
*SetStaticCharField
)
602 (JNIEnv
*env
, jclass clazz
, jfieldID fieldID
, jchar value
);
603 void (JNICALL
*SetStaticShortField
)
604 (JNIEnv
*env
, jclass clazz
, jfieldID fieldID
, jshort value
);
605 void (JNICALL
*SetStaticIntField
)
606 (JNIEnv
*env
, jclass clazz
, jfieldID fieldID
, jint value
);
607 void (JNICALL
*SetStaticLongField
)
608 (JNIEnv
*env
, jclass clazz
, jfieldID fieldID
, jlong value
);
609 void (JNICALL
*SetStaticFloatField
)
610 (JNIEnv
*env
, jclass clazz
, jfieldID fieldID
, jfloat value
);
611 void (JNICALL
*SetStaticDoubleField
)
612 (JNIEnv
*env
, jclass clazz
, jfieldID fieldID
, jdouble value
);
614 jstring (JNICALL
*NewString
)
615 (JNIEnv
*env
, const jchar
*unicode
, jsize len
);
616 jsize (JNICALL
*GetStringLength
)
617 (JNIEnv
*env
, jstring str
);
618 const jchar
*(JNICALL
*GetStringChars
)
619 (JNIEnv
*env
, jstring str
, jboolean
*isCopy
);
620 void (JNICALL
*ReleaseStringChars
)
621 (JNIEnv
*env
, jstring str
, const jchar
*chars
);
623 jstring (JNICALL
*NewStringUTF
)
624 (JNIEnv
*env
, const char *utf
);
625 jsize (JNICALL
*GetStringUTFLength
)
626 (JNIEnv
*env
, jstring str
);
627 const char* (JNICALL
*GetStringUTFChars
)
628 (JNIEnv
*env
, jstring str
, jboolean
*isCopy
);
629 void (JNICALL
*ReleaseStringUTFChars
)
630 (JNIEnv
*env
, jstring str
, const char* chars
);
633 jsize (JNICALL
*GetArrayLength
)
634 (JNIEnv
*env
, jarray array
);
636 jobjectArray (JNICALL
*NewObjectArray
)
637 (JNIEnv
*env
, jsize len
, jclass clazz
, jobject init
);
638 jobject (JNICALL
*GetObjectArrayElement
)
639 (JNIEnv
*env
, jobjectArray array
, jsize index
);
640 void (JNICALL
*SetObjectArrayElement
)
641 (JNIEnv
*env
, jobjectArray array
, jsize index
, jobject val
);
643 jbooleanArray (JNICALL
*NewBooleanArray
)
644 (JNIEnv
*env
, jsize len
);
645 jbyteArray (JNICALL
*NewByteArray
)
646 (JNIEnv
*env
, jsize len
);
647 jcharArray (JNICALL
*NewCharArray
)
648 (JNIEnv
*env
, jsize len
);
649 jshortArray (JNICALL
*NewShortArray
)
650 (JNIEnv
*env
, jsize len
);
651 jintArray (JNICALL
*NewIntArray
)
652 (JNIEnv
*env
, jsize len
);
653 jlongArray (JNICALL
*NewLongArray
)
654 (JNIEnv
*env
, jsize len
);
655 jfloatArray (JNICALL
*NewFloatArray
)
656 (JNIEnv
*env
, jsize len
);
657 jdoubleArray (JNICALL
*NewDoubleArray
)
658 (JNIEnv
*env
, jsize len
);
660 jboolean
* (JNICALL
*GetBooleanArrayElements
)
661 (JNIEnv
*env
, jbooleanArray array
, jboolean
*isCopy
);
662 jbyte
* (JNICALL
*GetByteArrayElements
)
663 (JNIEnv
*env
, jbyteArray array
, jboolean
*isCopy
);
664 jchar
* (JNICALL
*GetCharArrayElements
)
665 (JNIEnv
*env
, jcharArray array
, jboolean
*isCopy
);
666 jshort
* (JNICALL
*GetShortArrayElements
)
667 (JNIEnv
*env
, jshortArray array
, jboolean
*isCopy
);
668 jint
* (JNICALL
*GetIntArrayElements
)
669 (JNIEnv
*env
, jintArray array
, jboolean
*isCopy
);
670 jlong
* (JNICALL
*GetLongArrayElements
)
671 (JNIEnv
*env
, jlongArray array
, jboolean
*isCopy
);
672 jfloat
* (JNICALL
*GetFloatArrayElements
)
673 (JNIEnv
*env
, jfloatArray array
, jboolean
*isCopy
);
674 jdouble
* (JNICALL
*GetDoubleArrayElements
)
675 (JNIEnv
*env
, jdoubleArray array
, jboolean
*isCopy
);
677 void (JNICALL
*ReleaseBooleanArrayElements
)
678 (JNIEnv
*env
, jbooleanArray array
, jboolean
*elems
, jint mode
);
679 void (JNICALL
*ReleaseByteArrayElements
)
680 (JNIEnv
*env
, jbyteArray array
, jbyte
*elems
, jint mode
);
681 void (JNICALL
*ReleaseCharArrayElements
)
682 (JNIEnv
*env
, jcharArray array
, jchar
*elems
, jint mode
);
683 void (JNICALL
*ReleaseShortArrayElements
)
684 (JNIEnv
*env
, jshortArray array
, jshort
*elems
, jint mode
);
685 void (JNICALL
*ReleaseIntArrayElements
)
686 (JNIEnv
*env
, jintArray array
, jint
*elems
, jint mode
);
687 void (JNICALL
*ReleaseLongArrayElements
)
688 (JNIEnv
*env
, jlongArray array
, jlong
*elems
, jint mode
);
689 void (JNICALL
*ReleaseFloatArrayElements
)
690 (JNIEnv
*env
, jfloatArray array
, jfloat
*elems
, jint mode
);
691 void (JNICALL
*ReleaseDoubleArrayElements
)
692 (JNIEnv
*env
, jdoubleArray array
, jdouble
*elems
, jint mode
);
694 void (JNICALL
*GetBooleanArrayRegion
)
695 (JNIEnv
*env
, jbooleanArray array
, jsize start
, jsize l
, jboolean
*buf
);
696 void (JNICALL
*GetByteArrayRegion
)
697 (JNIEnv
*env
, jbyteArray array
, jsize start
, jsize len
, jbyte
*buf
);
698 void (JNICALL
*GetCharArrayRegion
)
699 (JNIEnv
*env
, jcharArray array
, jsize start
, jsize len
, jchar
*buf
);
700 void (JNICALL
*GetShortArrayRegion
)
701 (JNIEnv
*env
, jshortArray array
, jsize start
, jsize len
, jshort
*buf
);
702 void (JNICALL
*GetIntArrayRegion
)
703 (JNIEnv
*env
, jintArray array
, jsize start
, jsize len
, jint
*buf
);
704 void (JNICALL
*GetLongArrayRegion
)
705 (JNIEnv
*env
, jlongArray array
, jsize start
, jsize len
, jlong
*buf
);
706 void (JNICALL
*GetFloatArrayRegion
)
707 (JNIEnv
*env
, jfloatArray array
, jsize start
, jsize len
, jfloat
*buf
);
708 void (JNICALL
*GetDoubleArrayRegion
)
709 (JNIEnv
*env
, jdoubleArray array
, jsize start
, jsize len
, jdouble
*buf
);
711 void (JNICALL
*SetBooleanArrayRegion
)
712 (JNIEnv
*env
, jbooleanArray array
, jsize start
, jsize l
, const jboolean
*buf
);
713 void (JNICALL
*SetByteArrayRegion
)
714 (JNIEnv
*env
, jbyteArray array
, jsize start
, jsize len
, const jbyte
*buf
);
715 void (JNICALL
*SetCharArrayRegion
)
716 (JNIEnv
*env
, jcharArray array
, jsize start
, jsize len
, const jchar
*buf
);
717 void (JNICALL
*SetShortArrayRegion
)
718 (JNIEnv
*env
, jshortArray array
, jsize start
, jsize len
, const jshort
*buf
);
719 void (JNICALL
*SetIntArrayRegion
)
720 (JNIEnv
*env
, jintArray array
, jsize start
, jsize len
, const jint
*buf
);
721 void (JNICALL
*SetLongArrayRegion
)
722 (JNIEnv
*env
, jlongArray array
, jsize start
, jsize len
, const jlong
*buf
);
723 void (JNICALL
*SetFloatArrayRegion
)
724 (JNIEnv
*env
, jfloatArray array
, jsize start
, jsize len
, const jfloat
*buf
);
725 void (JNICALL
*SetDoubleArrayRegion
)
726 (JNIEnv
*env
, jdoubleArray array
, jsize start
, jsize len
, const jdouble
*buf
);
728 jint (JNICALL
*RegisterNatives
)
729 (JNIEnv
*env
, jclass clazz
, const JNINativeMethod
*methods
,
731 jint (JNICALL
*UnregisterNatives
)
732 (JNIEnv
*env
, jclass clazz
);
734 jint (JNICALL
*MonitorEnter
)
735 (JNIEnv
*env
, jobject obj
);
736 jint (JNICALL
*MonitorExit
)
737 (JNIEnv
*env
, jobject obj
);
739 jint (JNICALL
*GetJavaVM
)
740 (JNIEnv
*env
, JavaVM
**vm
);
742 void (JNICALL
*GetStringRegion
)
743 (JNIEnv
*env
, jstring str
, jsize start
, jsize len
, jchar
*buf
);
744 void (JNICALL
*GetStringUTFRegion
)
745 (JNIEnv
*env
, jstring str
, jsize start
, jsize len
, char *buf
);
747 void * (JNICALL
*GetPrimitiveArrayCritical
)
748 (JNIEnv
*env
, jarray array
, jboolean
*isCopy
);
749 void (JNICALL
*ReleasePrimitiveArrayCritical
)
750 (JNIEnv
*env
, jarray array
, void *carray
, jint mode
);
752 const jchar
* (JNICALL
*GetStringCritical
)
753 (JNIEnv
*env
, jstring string
, jboolean
*isCopy
);
754 void (JNICALL
*ReleaseStringCritical
)
755 (JNIEnv
*env
, jstring string
, const jchar
*cstring
);
757 jweak (JNICALL
*NewWeakGlobalRef
)
758 (JNIEnv
*env
, jobject obj
);
759 void (JNICALL
*DeleteWeakGlobalRef
)
760 (JNIEnv
*env
, jweak ref
);
762 jboolean (JNICALL
*ExceptionCheck
)
765 jobject (JNICALL
*NewDirectByteBuffer
)
766 (JNIEnv
* env
, void* address
, jlong capacity
);
767 void* (JNICALL
*GetDirectBufferAddress
)
768 (JNIEnv
* env
, jobject buf
);
769 jlong (JNICALL
*GetDirectBufferCapacity
)
770 (JNIEnv
* env
, jobject buf
);
772 /* New JNI 1.6 Features */
774 jobjectRefType (JNICALL
*GetObjectRefType
)
775 (JNIEnv
* env
, jobject obj
);
779 * We use inlined functions for C++ so that programmers can write:
781 * env->FindClass("java/lang/String")
783 * in C++ rather than:
785 * (*env)->FindClass(env, "java/lang/String")
791 const struct JNINativeInterface_
*functions
;
795 return functions
->GetVersion(this);
797 jclass
DefineClass(const char *name
, jobject loader
, const jbyte
*buf
,
799 return functions
->DefineClass(this, name
, loader
, buf
, len
);
801 jclass
FindClass(const char *name
) {
802 return functions
->FindClass(this, name
);
804 jmethodID
FromReflectedMethod(jobject method
) {
805 return functions
->FromReflectedMethod(this,method
);
807 jfieldID
FromReflectedField(jobject field
) {
808 return functions
->FromReflectedField(this,field
);
811 jobject
ToReflectedMethod(jclass cls
, jmethodID methodID
, jboolean isStatic
) {
812 return functions
->ToReflectedMethod(this, cls
, methodID
, isStatic
);
815 jclass
GetSuperclass(jclass sub
) {
816 return functions
->GetSuperclass(this, sub
);
818 jboolean
IsAssignableFrom(jclass sub
, jclass sup
) {
819 return functions
->IsAssignableFrom(this, sub
, sup
);
822 jobject
ToReflectedField(jclass cls
, jfieldID fieldID
, jboolean isStatic
) {
823 return functions
->ToReflectedField(this,cls
,fieldID
,isStatic
);
826 jint
Throw(jthrowable obj
) {
827 return functions
->Throw(this, obj
);
829 jint
ThrowNew(jclass clazz
, const char *msg
) {
830 return functions
->ThrowNew(this, clazz
, msg
);
832 jthrowable
ExceptionOccurred() {
833 return functions
->ExceptionOccurred(this);
835 void ExceptionDescribe() {
836 functions
->ExceptionDescribe(this);
838 void ExceptionClear() {
839 functions
->ExceptionClear(this);
841 void FatalError(const char *msg
) {
842 functions
->FatalError(this, msg
);
845 jint
PushLocalFrame(jint capacity
) {
846 return functions
->PushLocalFrame(this,capacity
);
848 jobject
PopLocalFrame(jobject result
) {
849 return functions
->PopLocalFrame(this,result
);
852 jobject
NewGlobalRef(jobject lobj
) {
853 return functions
->NewGlobalRef(this,lobj
);
855 void DeleteGlobalRef(jobject gref
) {
856 functions
->DeleteGlobalRef(this,gref
);
858 void DeleteLocalRef(jobject obj
) {
859 functions
->DeleteLocalRef(this, obj
);
862 jboolean
IsSameObject(jobject obj1
, jobject obj2
) {
863 return functions
->IsSameObject(this,obj1
,obj2
);
866 jobject
NewLocalRef(jobject ref
) {
867 return functions
->NewLocalRef(this,ref
);
869 jint
EnsureLocalCapacity(jint capacity
) {
870 return functions
->EnsureLocalCapacity(this,capacity
);
873 jobject
AllocObject(jclass clazz
) {
874 return functions
->AllocObject(this,clazz
);
876 jobject
NewObject(jclass clazz
, jmethodID methodID
, ...) {
879 va_start(args
, methodID
);
880 result
= functions
->NewObjectV(this,clazz
,methodID
,args
);
884 jobject
NewObjectV(jclass clazz
, jmethodID methodID
,
886 return functions
->NewObjectV(this,clazz
,methodID
,args
);
888 jobject
NewObjectA(jclass clazz
, jmethodID methodID
,
889 const jvalue
*args
) {
890 return functions
->NewObjectA(this,clazz
,methodID
,args
);
893 jclass
GetObjectClass(jobject obj
) {
894 return functions
->GetObjectClass(this,obj
);
896 jboolean
IsInstanceOf(jobject obj
, jclass clazz
) {
897 return functions
->IsInstanceOf(this,obj
,clazz
);
900 jmethodID
GetMethodID(jclass clazz
, const char *name
,
902 return functions
->GetMethodID(this,clazz
,name
,sig
);
905 jobject
CallObjectMethod(jobject obj
, jmethodID methodID
, ...) {
908 va_start(args
,methodID
);
909 result
= functions
->CallObjectMethodV(this,obj
,methodID
,args
);
913 jobject
CallObjectMethodV(jobject obj
, jmethodID methodID
,
915 return functions
->CallObjectMethodV(this,obj
,methodID
,args
);
917 jobject
CallObjectMethodA(jobject obj
, jmethodID methodID
,
918 const jvalue
* args
) {
919 return functions
->CallObjectMethodA(this,obj
,methodID
,args
);
922 jboolean
CallBooleanMethod(jobject obj
,
923 jmethodID methodID
, ...) {
926 va_start(args
,methodID
);
927 result
= functions
->CallBooleanMethodV(this,obj
,methodID
,args
);
931 jboolean
CallBooleanMethodV(jobject obj
, jmethodID methodID
,
933 return functions
->CallBooleanMethodV(this,obj
,methodID
,args
);
935 jboolean
CallBooleanMethodA(jobject obj
, jmethodID methodID
,
936 const jvalue
* args
) {
937 return functions
->CallBooleanMethodA(this,obj
,methodID
, args
);
940 jbyte
CallByteMethod(jobject obj
, jmethodID methodID
, ...) {
943 va_start(args
,methodID
);
944 result
= functions
->CallByteMethodV(this,obj
,methodID
,args
);
948 jbyte
CallByteMethodV(jobject obj
, jmethodID methodID
,
950 return functions
->CallByteMethodV(this,obj
,methodID
,args
);
952 jbyte
CallByteMethodA(jobject obj
, jmethodID methodID
,
953 const jvalue
* args
) {
954 return functions
->CallByteMethodA(this,obj
,methodID
,args
);
957 jchar
CallCharMethod(jobject obj
, jmethodID methodID
, ...) {
960 va_start(args
,methodID
);
961 result
= functions
->CallCharMethodV(this,obj
,methodID
,args
);
965 jchar
CallCharMethodV(jobject obj
, jmethodID methodID
,
967 return functions
->CallCharMethodV(this,obj
,methodID
,args
);
969 jchar
CallCharMethodA(jobject obj
, jmethodID methodID
,
970 const jvalue
* args
) {
971 return functions
->CallCharMethodA(this,obj
,methodID
,args
);
974 jshort
CallShortMethod(jobject obj
, jmethodID methodID
, ...) {
977 va_start(args
,methodID
);
978 result
= functions
->CallShortMethodV(this,obj
,methodID
,args
);
982 jshort
CallShortMethodV(jobject obj
, jmethodID methodID
,
984 return functions
->CallShortMethodV(this,obj
,methodID
,args
);
986 jshort
CallShortMethodA(jobject obj
, jmethodID methodID
,
987 const jvalue
* args
) {
988 return functions
->CallShortMethodA(this,obj
,methodID
,args
);
991 jint
CallIntMethod(jobject obj
, jmethodID methodID
, ...) {
994 va_start(args
,methodID
);
995 result
= functions
->CallIntMethodV(this,obj
,methodID
,args
);
999 jint
CallIntMethodV(jobject obj
, jmethodID methodID
,
1001 return functions
->CallIntMethodV(this,obj
,methodID
,args
);
1003 jint
CallIntMethodA(jobject obj
, jmethodID methodID
,
1004 const jvalue
* args
) {
1005 return functions
->CallIntMethodA(this,obj
,methodID
,args
);
1008 jlong
CallLongMethod(jobject obj
, jmethodID methodID
, ...) {
1011 va_start(args
,methodID
);
1012 result
= functions
->CallLongMethodV(this,obj
,methodID
,args
);
1016 jlong
CallLongMethodV(jobject obj
, jmethodID methodID
,
1018 return functions
->CallLongMethodV(this,obj
,methodID
,args
);
1020 jlong
CallLongMethodA(jobject obj
, jmethodID methodID
,
1021 const jvalue
* args
) {
1022 return functions
->CallLongMethodA(this,obj
,methodID
,args
);
1025 jfloat
CallFloatMethod(jobject obj
, jmethodID methodID
, ...) {
1028 va_start(args
,methodID
);
1029 result
= functions
->CallFloatMethodV(this,obj
,methodID
,args
);
1033 jfloat
CallFloatMethodV(jobject obj
, jmethodID methodID
,
1035 return functions
->CallFloatMethodV(this,obj
,methodID
,args
);
1037 jfloat
CallFloatMethodA(jobject obj
, jmethodID methodID
,
1038 const jvalue
* args
) {
1039 return functions
->CallFloatMethodA(this,obj
,methodID
,args
);
1042 jdouble
CallDoubleMethod(jobject obj
, jmethodID methodID
, ...) {
1045 va_start(args
,methodID
);
1046 result
= functions
->CallDoubleMethodV(this,obj
,methodID
,args
);
1050 jdouble
CallDoubleMethodV(jobject obj
, jmethodID methodID
,
1052 return functions
->CallDoubleMethodV(this,obj
,methodID
,args
);
1054 jdouble
CallDoubleMethodA(jobject obj
, jmethodID methodID
,
1055 const jvalue
* args
) {
1056 return functions
->CallDoubleMethodA(this,obj
,methodID
,args
);
1059 void CallVoidMethod(jobject obj
, jmethodID methodID
, ...) {
1061 va_start(args
,methodID
);
1062 functions
->CallVoidMethodV(this,obj
,methodID
,args
);
1065 void CallVoidMethodV(jobject obj
, jmethodID methodID
,
1067 functions
->CallVoidMethodV(this,obj
,methodID
,args
);
1069 void CallVoidMethodA(jobject obj
, jmethodID methodID
,
1070 const jvalue
* args
) {
1071 functions
->CallVoidMethodA(this,obj
,methodID
,args
);
1074 jobject
CallNonvirtualObjectMethod(jobject obj
, jclass clazz
,
1075 jmethodID methodID
, ...) {
1078 va_start(args
,methodID
);
1079 result
= functions
->CallNonvirtualObjectMethodV(this,obj
,clazz
,
1084 jobject
CallNonvirtualObjectMethodV(jobject obj
, jclass clazz
,
1085 jmethodID methodID
, va_list args
) {
1086 return functions
->CallNonvirtualObjectMethodV(this,obj
,clazz
,
1089 jobject
CallNonvirtualObjectMethodA(jobject obj
, jclass clazz
,
1090 jmethodID methodID
, const jvalue
* args
) {
1091 return functions
->CallNonvirtualObjectMethodA(this,obj
,clazz
,
1095 jboolean
CallNonvirtualBooleanMethod(jobject obj
, jclass clazz
,
1096 jmethodID methodID
, ...) {
1099 va_start(args
,methodID
);
1100 result
= functions
->CallNonvirtualBooleanMethodV(this,obj
,clazz
,
1105 jboolean
CallNonvirtualBooleanMethodV(jobject obj
, jclass clazz
,
1106 jmethodID methodID
, va_list args
) {
1107 return functions
->CallNonvirtualBooleanMethodV(this,obj
,clazz
,
1110 jboolean
CallNonvirtualBooleanMethodA(jobject obj
, jclass clazz
,
1111 jmethodID methodID
, const jvalue
* args
) {
1112 return functions
->CallNonvirtualBooleanMethodA(this,obj
,clazz
,
1116 jbyte
CallNonvirtualByteMethod(jobject obj
, jclass clazz
,
1117 jmethodID methodID
, ...) {
1120 va_start(args
,methodID
);
1121 result
= functions
->CallNonvirtualByteMethodV(this,obj
,clazz
,
1126 jbyte
CallNonvirtualByteMethodV(jobject obj
, jclass clazz
,
1127 jmethodID methodID
, va_list args
) {
1128 return functions
->CallNonvirtualByteMethodV(this,obj
,clazz
,
1131 jbyte
CallNonvirtualByteMethodA(jobject obj
, jclass clazz
,
1132 jmethodID methodID
, const jvalue
* args
) {
1133 return functions
->CallNonvirtualByteMethodA(this,obj
,clazz
,
1137 jchar
CallNonvirtualCharMethod(jobject obj
, jclass clazz
,
1138 jmethodID methodID
, ...) {
1141 va_start(args
,methodID
);
1142 result
= functions
->CallNonvirtualCharMethodV(this,obj
,clazz
,
1147 jchar
CallNonvirtualCharMethodV(jobject obj
, jclass clazz
,
1148 jmethodID methodID
, va_list args
) {
1149 return functions
->CallNonvirtualCharMethodV(this,obj
,clazz
,
1152 jchar
CallNonvirtualCharMethodA(jobject obj
, jclass clazz
,
1153 jmethodID methodID
, const jvalue
* args
) {
1154 return functions
->CallNonvirtualCharMethodA(this,obj
,clazz
,
1158 jshort
CallNonvirtualShortMethod(jobject obj
, jclass clazz
,
1159 jmethodID methodID
, ...) {
1162 va_start(args
,methodID
);
1163 result
= functions
->CallNonvirtualShortMethodV(this,obj
,clazz
,
1168 jshort
CallNonvirtualShortMethodV(jobject obj
, jclass clazz
,
1169 jmethodID methodID
, va_list args
) {
1170 return functions
->CallNonvirtualShortMethodV(this,obj
,clazz
,
1173 jshort
CallNonvirtualShortMethodA(jobject obj
, jclass clazz
,
1174 jmethodID methodID
, const jvalue
* args
) {
1175 return functions
->CallNonvirtualShortMethodA(this,obj
,clazz
,
1179 jint
CallNonvirtualIntMethod(jobject obj
, jclass clazz
,
1180 jmethodID methodID
, ...) {
1183 va_start(args
,methodID
);
1184 result
= functions
->CallNonvirtualIntMethodV(this,obj
,clazz
,
1189 jint
CallNonvirtualIntMethodV(jobject obj
, jclass clazz
,
1190 jmethodID methodID
, va_list args
) {
1191 return functions
->CallNonvirtualIntMethodV(this,obj
,clazz
,
1194 jint
CallNonvirtualIntMethodA(jobject obj
, jclass clazz
,
1195 jmethodID methodID
, const jvalue
* args
) {
1196 return functions
->CallNonvirtualIntMethodA(this,obj
,clazz
,
1200 jlong
CallNonvirtualLongMethod(jobject obj
, jclass clazz
,
1201 jmethodID methodID
, ...) {
1204 va_start(args
,methodID
);
1205 result
= functions
->CallNonvirtualLongMethodV(this,obj
,clazz
,
1210 jlong
CallNonvirtualLongMethodV(jobject obj
, jclass clazz
,
1211 jmethodID methodID
, va_list args
) {
1212 return functions
->CallNonvirtualLongMethodV(this,obj
,clazz
,
1215 jlong
CallNonvirtualLongMethodA(jobject obj
, jclass clazz
,
1216 jmethodID methodID
, const jvalue
* args
) {
1217 return functions
->CallNonvirtualLongMethodA(this,obj
,clazz
,
1221 jfloat
CallNonvirtualFloatMethod(jobject obj
, jclass clazz
,
1222 jmethodID methodID
, ...) {
1225 va_start(args
,methodID
);
1226 result
= functions
->CallNonvirtualFloatMethodV(this,obj
,clazz
,
1231 jfloat
CallNonvirtualFloatMethodV(jobject obj
, jclass clazz
,
1234 return functions
->CallNonvirtualFloatMethodV(this,obj
,clazz
,
1237 jfloat
CallNonvirtualFloatMethodA(jobject obj
, jclass clazz
,
1239 const jvalue
* args
) {
1240 return functions
->CallNonvirtualFloatMethodA(this,obj
,clazz
,
1244 jdouble
CallNonvirtualDoubleMethod(jobject obj
, jclass clazz
,
1245 jmethodID methodID
, ...) {
1248 va_start(args
,methodID
);
1249 result
= functions
->CallNonvirtualDoubleMethodV(this,obj
,clazz
,
1254 jdouble
CallNonvirtualDoubleMethodV(jobject obj
, jclass clazz
,
1257 return functions
->CallNonvirtualDoubleMethodV(this,obj
,clazz
,
1260 jdouble
CallNonvirtualDoubleMethodA(jobject obj
, jclass clazz
,
1262 const jvalue
* args
) {
1263 return functions
->CallNonvirtualDoubleMethodA(this,obj
,clazz
,
1267 void CallNonvirtualVoidMethod(jobject obj
, jclass clazz
,
1268 jmethodID methodID
, ...) {
1270 va_start(args
,methodID
);
1271 functions
->CallNonvirtualVoidMethodV(this,obj
,clazz
,methodID
,args
);
1274 void CallNonvirtualVoidMethodV(jobject obj
, jclass clazz
,
1277 functions
->CallNonvirtualVoidMethodV(this,obj
,clazz
,methodID
,args
);
1279 void CallNonvirtualVoidMethodA(jobject obj
, jclass clazz
,
1281 const jvalue
* args
) {
1282 functions
->CallNonvirtualVoidMethodA(this,obj
,clazz
,methodID
,args
);
1285 jfieldID
GetFieldID(jclass clazz
, const char *name
,
1287 return functions
->GetFieldID(this,clazz
,name
,sig
);
1290 jobject
GetObjectField(jobject obj
, jfieldID fieldID
) {
1291 return functions
->GetObjectField(this,obj
,fieldID
);
1293 jboolean
GetBooleanField(jobject obj
, jfieldID fieldID
) {
1294 return functions
->GetBooleanField(this,obj
,fieldID
);
1296 jbyte
GetByteField(jobject obj
, jfieldID fieldID
) {
1297 return functions
->GetByteField(this,obj
,fieldID
);
1299 jchar
GetCharField(jobject obj
, jfieldID fieldID
) {
1300 return functions
->GetCharField(this,obj
,fieldID
);
1302 jshort
GetShortField(jobject obj
, jfieldID fieldID
) {
1303 return functions
->GetShortField(this,obj
,fieldID
);
1305 jint
GetIntField(jobject obj
, jfieldID fieldID
) {
1306 return functions
->GetIntField(this,obj
,fieldID
);
1308 jlong
GetLongField(jobject obj
, jfieldID fieldID
) {
1309 return functions
->GetLongField(this,obj
,fieldID
);
1311 jfloat
GetFloatField(jobject obj
, jfieldID fieldID
) {
1312 return functions
->GetFloatField(this,obj
,fieldID
);
1314 jdouble
GetDoubleField(jobject obj
, jfieldID fieldID
) {
1315 return functions
->GetDoubleField(this,obj
,fieldID
);
1318 void SetObjectField(jobject obj
, jfieldID fieldID
, jobject val
) {
1319 functions
->SetObjectField(this,obj
,fieldID
,val
);
1321 void SetBooleanField(jobject obj
, jfieldID fieldID
,
1323 functions
->SetBooleanField(this,obj
,fieldID
,val
);
1325 void SetByteField(jobject obj
, jfieldID fieldID
,
1327 functions
->SetByteField(this,obj
,fieldID
,val
);
1329 void SetCharField(jobject obj
, jfieldID fieldID
,
1331 functions
->SetCharField(this,obj
,fieldID
,val
);
1333 void SetShortField(jobject obj
, jfieldID fieldID
,
1335 functions
->SetShortField(this,obj
,fieldID
,val
);
1337 void SetIntField(jobject obj
, jfieldID fieldID
,
1339 functions
->SetIntField(this,obj
,fieldID
,val
);
1341 void SetLongField(jobject obj
, jfieldID fieldID
,
1343 functions
->SetLongField(this,obj
,fieldID
,val
);
1345 void SetFloatField(jobject obj
, jfieldID fieldID
,
1347 functions
->SetFloatField(this,obj
,fieldID
,val
);
1349 void SetDoubleField(jobject obj
, jfieldID fieldID
,
1351 functions
->SetDoubleField(this,obj
,fieldID
,val
);
1354 jmethodID
GetStaticMethodID(jclass clazz
, const char *name
,
1356 return functions
->GetStaticMethodID(this,clazz
,name
,sig
);
1359 jobject
CallStaticObjectMethod(jclass clazz
, jmethodID methodID
,
1363 va_start(args
,methodID
);
1364 result
= functions
->CallStaticObjectMethodV(this,clazz
,methodID
,args
);
1368 jobject
CallStaticObjectMethodV(jclass clazz
, jmethodID methodID
,
1370 return functions
->CallStaticObjectMethodV(this,clazz
,methodID
,args
);
1372 jobject
CallStaticObjectMethodA(jclass clazz
, jmethodID methodID
,
1373 const jvalue
*args
) {
1374 return functions
->CallStaticObjectMethodA(this,clazz
,methodID
,args
);
1377 jboolean
CallStaticBooleanMethod(jclass clazz
,
1378 jmethodID methodID
, ...) {
1381 va_start(args
,methodID
);
1382 result
= functions
->CallStaticBooleanMethodV(this,clazz
,methodID
,args
);
1386 jboolean
CallStaticBooleanMethodV(jclass clazz
,
1387 jmethodID methodID
, va_list args
) {
1388 return functions
->CallStaticBooleanMethodV(this,clazz
,methodID
,args
);
1390 jboolean
CallStaticBooleanMethodA(jclass clazz
,
1391 jmethodID methodID
, const jvalue
*args
) {
1392 return functions
->CallStaticBooleanMethodA(this,clazz
,methodID
,args
);
1395 jbyte
CallStaticByteMethod(jclass clazz
,
1396 jmethodID methodID
, ...) {
1399 va_start(args
,methodID
);
1400 result
= functions
->CallStaticByteMethodV(this,clazz
,methodID
,args
);
1404 jbyte
CallStaticByteMethodV(jclass clazz
,
1405 jmethodID methodID
, va_list args
) {
1406 return functions
->CallStaticByteMethodV(this,clazz
,methodID
,args
);
1408 jbyte
CallStaticByteMethodA(jclass clazz
,
1409 jmethodID methodID
, const jvalue
*args
) {
1410 return functions
->CallStaticByteMethodA(this,clazz
,methodID
,args
);
1413 jchar
CallStaticCharMethod(jclass clazz
,
1414 jmethodID methodID
, ...) {
1417 va_start(args
,methodID
);
1418 result
= functions
->CallStaticCharMethodV(this,clazz
,methodID
,args
);
1422 jchar
CallStaticCharMethodV(jclass clazz
,
1423 jmethodID methodID
, va_list args
) {
1424 return functions
->CallStaticCharMethodV(this,clazz
,methodID
,args
);
1426 jchar
CallStaticCharMethodA(jclass clazz
,
1427 jmethodID methodID
, const jvalue
*args
) {
1428 return functions
->CallStaticCharMethodA(this,clazz
,methodID
,args
);
1431 jshort
CallStaticShortMethod(jclass clazz
,
1432 jmethodID methodID
, ...) {
1435 va_start(args
,methodID
);
1436 result
= functions
->CallStaticShortMethodV(this,clazz
,methodID
,args
);
1440 jshort
CallStaticShortMethodV(jclass clazz
,
1441 jmethodID methodID
, va_list args
) {
1442 return functions
->CallStaticShortMethodV(this,clazz
,methodID
,args
);
1444 jshort
CallStaticShortMethodA(jclass clazz
,
1445 jmethodID methodID
, const jvalue
*args
) {
1446 return functions
->CallStaticShortMethodA(this,clazz
,methodID
,args
);
1449 jint
CallStaticIntMethod(jclass clazz
,
1450 jmethodID methodID
, ...) {
1453 va_start(args
,methodID
);
1454 result
= functions
->CallStaticIntMethodV(this,clazz
,methodID
,args
);
1458 jint
CallStaticIntMethodV(jclass clazz
,
1459 jmethodID methodID
, va_list args
) {
1460 return functions
->CallStaticIntMethodV(this,clazz
,methodID
,args
);
1462 jint
CallStaticIntMethodA(jclass clazz
,
1463 jmethodID methodID
, const jvalue
*args
) {
1464 return functions
->CallStaticIntMethodA(this,clazz
,methodID
,args
);
1467 jlong
CallStaticLongMethod(jclass clazz
,
1468 jmethodID methodID
, ...) {
1471 va_start(args
,methodID
);
1472 result
= functions
->CallStaticLongMethodV(this,clazz
,methodID
,args
);
1476 jlong
CallStaticLongMethodV(jclass clazz
,
1477 jmethodID methodID
, va_list args
) {
1478 return functions
->CallStaticLongMethodV(this,clazz
,methodID
,args
);
1480 jlong
CallStaticLongMethodA(jclass clazz
,
1481 jmethodID methodID
, const jvalue
*args
) {
1482 return functions
->CallStaticLongMethodA(this,clazz
,methodID
,args
);
1485 jfloat
CallStaticFloatMethod(jclass clazz
,
1486 jmethodID methodID
, ...) {
1489 va_start(args
,methodID
);
1490 result
= functions
->CallStaticFloatMethodV(this,clazz
,methodID
,args
);
1494 jfloat
CallStaticFloatMethodV(jclass clazz
,
1495 jmethodID methodID
, va_list args
) {
1496 return functions
->CallStaticFloatMethodV(this,clazz
,methodID
,args
);
1498 jfloat
CallStaticFloatMethodA(jclass clazz
,
1499 jmethodID methodID
, const jvalue
*args
) {
1500 return functions
->CallStaticFloatMethodA(this,clazz
,methodID
,args
);
1503 jdouble
CallStaticDoubleMethod(jclass clazz
,
1504 jmethodID methodID
, ...) {
1507 va_start(args
,methodID
);
1508 result
= functions
->CallStaticDoubleMethodV(this,clazz
,methodID
,args
);
1512 jdouble
CallStaticDoubleMethodV(jclass clazz
,
1513 jmethodID methodID
, va_list args
) {
1514 return functions
->CallStaticDoubleMethodV(this,clazz
,methodID
,args
);
1516 jdouble
CallStaticDoubleMethodA(jclass clazz
,
1517 jmethodID methodID
, const jvalue
*args
) {
1518 return functions
->CallStaticDoubleMethodA(this,clazz
,methodID
,args
);
1521 void CallStaticVoidMethod(jclass cls
, jmethodID methodID
, ...) {
1523 va_start(args
,methodID
);
1524 functions
->CallStaticVoidMethodV(this,cls
,methodID
,args
);
1527 void CallStaticVoidMethodV(jclass cls
, jmethodID methodID
,
1529 functions
->CallStaticVoidMethodV(this,cls
,methodID
,args
);
1531 void CallStaticVoidMethodA(jclass cls
, jmethodID methodID
,
1532 const jvalue
* args
) {
1533 functions
->CallStaticVoidMethodA(this,cls
,methodID
,args
);
1536 jfieldID
GetStaticFieldID(jclass clazz
, const char *name
,
1538 return functions
->GetStaticFieldID(this,clazz
,name
,sig
);
1540 jobject
GetStaticObjectField(jclass clazz
, jfieldID fieldID
) {
1541 return functions
->GetStaticObjectField(this,clazz
,fieldID
);
1543 jboolean
GetStaticBooleanField(jclass clazz
, jfieldID fieldID
) {
1544 return functions
->GetStaticBooleanField(this,clazz
,fieldID
);
1546 jbyte
GetStaticByteField(jclass clazz
, jfieldID fieldID
) {
1547 return functions
->GetStaticByteField(this,clazz
,fieldID
);
1549 jchar
GetStaticCharField(jclass clazz
, jfieldID fieldID
) {
1550 return functions
->GetStaticCharField(this,clazz
,fieldID
);
1552 jshort
GetStaticShortField(jclass clazz
, jfieldID fieldID
) {
1553 return functions
->GetStaticShortField(this,clazz
,fieldID
);
1555 jint
GetStaticIntField(jclass clazz
, jfieldID fieldID
) {
1556 return functions
->GetStaticIntField(this,clazz
,fieldID
);
1558 jlong
GetStaticLongField(jclass clazz
, jfieldID fieldID
) {
1559 return functions
->GetStaticLongField(this,clazz
,fieldID
);
1561 jfloat
GetStaticFloatField(jclass clazz
, jfieldID fieldID
) {
1562 return functions
->GetStaticFloatField(this,clazz
,fieldID
);
1564 jdouble
GetStaticDoubleField(jclass clazz
, jfieldID fieldID
) {
1565 return functions
->GetStaticDoubleField(this,clazz
,fieldID
);
1568 void SetStaticObjectField(jclass clazz
, jfieldID fieldID
,
1570 functions
->SetStaticObjectField(this,clazz
,fieldID
,value
);
1572 void SetStaticBooleanField(jclass clazz
, jfieldID fieldID
,
1574 functions
->SetStaticBooleanField(this,clazz
,fieldID
,value
);
1576 void SetStaticByteField(jclass clazz
, jfieldID fieldID
,
1578 functions
->SetStaticByteField(this,clazz
,fieldID
,value
);
1580 void SetStaticCharField(jclass clazz
, jfieldID fieldID
,
1582 functions
->SetStaticCharField(this,clazz
,fieldID
,value
);
1584 void SetStaticShortField(jclass clazz
, jfieldID fieldID
,
1586 functions
->SetStaticShortField(this,clazz
,fieldID
,value
);
1588 void SetStaticIntField(jclass clazz
, jfieldID fieldID
,
1590 functions
->SetStaticIntField(this,clazz
,fieldID
,value
);
1592 void SetStaticLongField(jclass clazz
, jfieldID fieldID
,
1594 functions
->SetStaticLongField(this,clazz
,fieldID
,value
);
1596 void SetStaticFloatField(jclass clazz
, jfieldID fieldID
,
1598 functions
->SetStaticFloatField(this,clazz
,fieldID
,value
);
1600 void SetStaticDoubleField(jclass clazz
, jfieldID fieldID
,
1602 functions
->SetStaticDoubleField(this,clazz
,fieldID
,value
);
1605 jstring
NewString(const jchar
*unicode
, jsize len
) {
1606 return functions
->NewString(this,unicode
,len
);
1608 jsize
GetStringLength(jstring str
) {
1609 return functions
->GetStringLength(this,str
);
1611 const jchar
*GetStringChars(jstring str
, jboolean
*isCopy
) {
1612 return functions
->GetStringChars(this,str
,isCopy
);
1614 void ReleaseStringChars(jstring str
, const jchar
*chars
) {
1615 functions
->ReleaseStringChars(this,str
,chars
);
1618 jstring
NewStringUTF(const char *utf
) {
1619 return functions
->NewStringUTF(this,utf
);
1621 jsize
GetStringUTFLength(jstring str
) {
1622 return functions
->GetStringUTFLength(this,str
);
1624 const char* GetStringUTFChars(jstring str
, jboolean
*isCopy
) {
1625 return functions
->GetStringUTFChars(this,str
,isCopy
);
1627 void ReleaseStringUTFChars(jstring str
, const char* chars
) {
1628 functions
->ReleaseStringUTFChars(this,str
,chars
);
1631 jsize
GetArrayLength(jarray array
) {
1632 return functions
->GetArrayLength(this,array
);
1635 jobjectArray
NewObjectArray(jsize len
, jclass clazz
,
1637 return functions
->NewObjectArray(this,len
,clazz
,init
);
1639 jobject
GetObjectArrayElement(jobjectArray array
, jsize index
) {
1640 return functions
->GetObjectArrayElement(this,array
,index
);
1642 void SetObjectArrayElement(jobjectArray array
, jsize index
,
1644 functions
->SetObjectArrayElement(this,array
,index
,val
);
1647 jbooleanArray
NewBooleanArray(jsize len
) {
1648 return functions
->NewBooleanArray(this,len
);
1650 jbyteArray
NewByteArray(jsize len
) {
1651 return functions
->NewByteArray(this,len
);
1653 jcharArray
NewCharArray(jsize len
) {
1654 return functions
->NewCharArray(this,len
);
1656 jshortArray
NewShortArray(jsize len
) {
1657 return functions
->NewShortArray(this,len
);
1659 jintArray
NewIntArray(jsize len
) {
1660 return functions
->NewIntArray(this,len
);
1662 jlongArray
NewLongArray(jsize len
) {
1663 return functions
->NewLongArray(this,len
);
1665 jfloatArray
NewFloatArray(jsize len
) {
1666 return functions
->NewFloatArray(this,len
);
1668 jdoubleArray
NewDoubleArray(jsize len
) {
1669 return functions
->NewDoubleArray(this,len
);
1672 jboolean
* GetBooleanArrayElements(jbooleanArray array
, jboolean
*isCopy
) {
1673 return functions
->GetBooleanArrayElements(this,array
,isCopy
);
1675 jbyte
* GetByteArrayElements(jbyteArray array
, jboolean
*isCopy
) {
1676 return functions
->GetByteArrayElements(this,array
,isCopy
);
1678 jchar
* GetCharArrayElements(jcharArray array
, jboolean
*isCopy
) {
1679 return functions
->GetCharArrayElements(this,array
,isCopy
);
1681 jshort
* GetShortArrayElements(jshortArray array
, jboolean
*isCopy
) {
1682 return functions
->GetShortArrayElements(this,array
,isCopy
);
1684 jint
* GetIntArrayElements(jintArray array
, jboolean
*isCopy
) {
1685 return functions
->GetIntArrayElements(this,array
,isCopy
);
1687 jlong
* GetLongArrayElements(jlongArray array
, jboolean
*isCopy
) {
1688 return functions
->GetLongArrayElements(this,array
,isCopy
);
1690 jfloat
* GetFloatArrayElements(jfloatArray array
, jboolean
*isCopy
) {
1691 return functions
->GetFloatArrayElements(this,array
,isCopy
);
1693 jdouble
* GetDoubleArrayElements(jdoubleArray array
, jboolean
*isCopy
) {
1694 return functions
->GetDoubleArrayElements(this,array
,isCopy
);
1697 void ReleaseBooleanArrayElements(jbooleanArray array
,
1700 functions
->ReleaseBooleanArrayElements(this,array
,elems
,mode
);
1702 void ReleaseByteArrayElements(jbyteArray array
,
1705 functions
->ReleaseByteArrayElements(this,array
,elems
,mode
);
1707 void ReleaseCharArrayElements(jcharArray array
,
1710 functions
->ReleaseCharArrayElements(this,array
,elems
,mode
);
1712 void ReleaseShortArrayElements(jshortArray array
,
1715 functions
->ReleaseShortArrayElements(this,array
,elems
,mode
);
1717 void ReleaseIntArrayElements(jintArray array
,
1720 functions
->ReleaseIntArrayElements(this,array
,elems
,mode
);
1722 void ReleaseLongArrayElements(jlongArray array
,
1725 functions
->ReleaseLongArrayElements(this,array
,elems
,mode
);
1727 void ReleaseFloatArrayElements(jfloatArray array
,
1730 functions
->ReleaseFloatArrayElements(this,array
,elems
,mode
);
1732 void ReleaseDoubleArrayElements(jdoubleArray array
,
1735 functions
->ReleaseDoubleArrayElements(this,array
,elems
,mode
);
1738 void GetBooleanArrayRegion(jbooleanArray array
,
1739 jsize start
, jsize len
, jboolean
*buf
) {
1740 functions
->GetBooleanArrayRegion(this,array
,start
,len
,buf
);
1742 void GetByteArrayRegion(jbyteArray array
,
1743 jsize start
, jsize len
, jbyte
*buf
) {
1744 functions
->GetByteArrayRegion(this,array
,start
,len
,buf
);
1746 void GetCharArrayRegion(jcharArray array
,
1747 jsize start
, jsize len
, jchar
*buf
) {
1748 functions
->GetCharArrayRegion(this,array
,start
,len
,buf
);
1750 void GetShortArrayRegion(jshortArray array
,
1751 jsize start
, jsize len
, jshort
*buf
) {
1752 functions
->GetShortArrayRegion(this,array
,start
,len
,buf
);
1754 void GetIntArrayRegion(jintArray array
,
1755 jsize start
, jsize len
, jint
*buf
) {
1756 functions
->GetIntArrayRegion(this,array
,start
,len
,buf
);
1758 void GetLongArrayRegion(jlongArray array
,
1759 jsize start
, jsize len
, jlong
*buf
) {
1760 functions
->GetLongArrayRegion(this,array
,start
,len
,buf
);
1762 void GetFloatArrayRegion(jfloatArray array
,
1763 jsize start
, jsize len
, jfloat
*buf
) {
1764 functions
->GetFloatArrayRegion(this,array
,start
,len
,buf
);
1766 void GetDoubleArrayRegion(jdoubleArray array
,
1767 jsize start
, jsize len
, jdouble
*buf
) {
1768 functions
->GetDoubleArrayRegion(this,array
,start
,len
,buf
);
1771 void SetBooleanArrayRegion(jbooleanArray array
, jsize start
, jsize len
,
1772 const jboolean
*buf
) {
1773 functions
->SetBooleanArrayRegion(this,array
,start
,len
,buf
);
1775 void SetByteArrayRegion(jbyteArray array
, jsize start
, jsize len
,
1777 functions
->SetByteArrayRegion(this,array
,start
,len
,buf
);
1779 void SetCharArrayRegion(jcharArray array
, jsize start
, jsize len
,
1781 functions
->SetCharArrayRegion(this,array
,start
,len
,buf
);
1783 void SetShortArrayRegion(jshortArray array
, jsize start
, jsize len
,
1784 const jshort
*buf
) {
1785 functions
->SetShortArrayRegion(this,array
,start
,len
,buf
);
1787 void SetIntArrayRegion(jintArray array
, jsize start
, jsize len
,
1789 functions
->SetIntArrayRegion(this,array
,start
,len
,buf
);
1791 void SetLongArrayRegion(jlongArray array
, jsize start
, jsize len
,
1793 functions
->SetLongArrayRegion(this,array
,start
,len
,buf
);
1795 void SetFloatArrayRegion(jfloatArray array
, jsize start
, jsize len
,
1796 const jfloat
*buf
) {
1797 functions
->SetFloatArrayRegion(this,array
,start
,len
,buf
);
1799 void SetDoubleArrayRegion(jdoubleArray array
, jsize start
, jsize len
,
1800 const jdouble
*buf
) {
1801 functions
->SetDoubleArrayRegion(this,array
,start
,len
,buf
);
1804 jint
RegisterNatives(jclass clazz
, const JNINativeMethod
*methods
,
1806 return functions
->RegisterNatives(this,clazz
,methods
,nMethods
);
1808 jint
UnregisterNatives(jclass clazz
) {
1809 return functions
->UnregisterNatives(this,clazz
);
1812 jint
MonitorEnter(jobject obj
) {
1813 return functions
->MonitorEnter(this,obj
);
1815 jint
MonitorExit(jobject obj
) {
1816 return functions
->MonitorExit(this,obj
);
1819 jint
GetJavaVM(JavaVM
**vm
) {
1820 return functions
->GetJavaVM(this,vm
);
1823 void GetStringRegion(jstring str
, jsize start
, jsize len
, jchar
*buf
) {
1824 functions
->GetStringRegion(this,str
,start
,len
,buf
);
1826 void GetStringUTFRegion(jstring str
, jsize start
, jsize len
, char *buf
) {
1827 functions
->GetStringUTFRegion(this,str
,start
,len
,buf
);
1830 void * GetPrimitiveArrayCritical(jarray array
, jboolean
*isCopy
) {
1831 return functions
->GetPrimitiveArrayCritical(this,array
,isCopy
);
1833 void ReleasePrimitiveArrayCritical(jarray array
, void *carray
, jint mode
) {
1834 functions
->ReleasePrimitiveArrayCritical(this,array
,carray
,mode
);
1837 const jchar
* GetStringCritical(jstring string
, jboolean
*isCopy
) {
1838 return functions
->GetStringCritical(this,string
,isCopy
);
1840 void ReleaseStringCritical(jstring string
, const jchar
*cstring
) {
1841 functions
->ReleaseStringCritical(this,string
,cstring
);
1844 jweak
NewWeakGlobalRef(jobject obj
) {
1845 return functions
->NewWeakGlobalRef(this,obj
);
1847 void DeleteWeakGlobalRef(jweak ref
) {
1848 functions
->DeleteWeakGlobalRef(this,ref
);
1851 jboolean
ExceptionCheck() {
1852 return functions
->ExceptionCheck(this);
1855 jobject
NewDirectByteBuffer(void* address
, jlong capacity
) {
1856 return functions
->NewDirectByteBuffer(this, address
, capacity
);
1858 void* GetDirectBufferAddress(jobject buf
) {
1859 return functions
->GetDirectBufferAddress(this, buf
);
1861 jlong
GetDirectBufferCapacity(jobject buf
) {
1862 return functions
->GetDirectBufferCapacity(this, buf
);
1864 jobjectRefType
GetObjectRefType(jobject obj
) {
1865 return functions
->GetObjectRefType(this, obj
);
1868 #endif /* __cplusplus */
1871 typedef struct JavaVMOption
{
1876 typedef struct JavaVMInitArgs
{
1880 JavaVMOption
*options
;
1881 jboolean ignoreUnrecognized
;
1884 typedef struct JavaVMAttachArgs
{
1891 /* These will be VM-specific. */
1896 /* End VM-specific. */
1898 struct JNIInvokeInterface_
{
1903 jint (JNICALL
*DestroyJavaVM
)(JavaVM
*vm
);
1905 jint (JNICALL
*AttachCurrentThread
)(JavaVM
*vm
, void **penv
, void *args
);
1907 jint (JNICALL
*DetachCurrentThread
)(JavaVM
*vm
);
1909 jint (JNICALL
*GetEnv
)(JavaVM
*vm
, void **penv
, jint version
);
1911 jint (JNICALL
*AttachCurrentThreadAsDaemon
)(JavaVM
*vm
, void **penv
, void *args
);
1915 const struct JNIInvokeInterface_
*functions
;
1918 jint
DestroyJavaVM() {
1919 return functions
->DestroyJavaVM(this);
1921 jint
AttachCurrentThread(void **penv
, void *args
) {
1922 return functions
->AttachCurrentThread(this, penv
, args
);
1924 jint
DetachCurrentThread() {
1925 return functions
->DetachCurrentThread(this);
1928 jint
GetEnv(void **penv
, jint version
) {
1929 return functions
->GetEnv(this, penv
, version
);
1931 jint
AttachCurrentThreadAsDaemon(void **penv
, void *args
) {
1932 return functions
->AttachCurrentThreadAsDaemon(this, penv
, args
);
1937 #ifdef _JNI_IMPLEMENTATION_
1938 #define _JNI_IMPORT_OR_EXPORT_ JNIEXPORT
1940 #define _JNI_IMPORT_OR_EXPORT_ JNIIMPORT
1942 _JNI_IMPORT_OR_EXPORT_ jint JNICALL
1943 JNI_GetDefaultJavaVMInitArgs(void *args
);
1945 _JNI_IMPORT_OR_EXPORT_ jint JNICALL
1946 JNI_CreateJavaVM(JavaVM
**pvm
, void **penv
, void *args
);
1948 _JNI_IMPORT_OR_EXPORT_ jint JNICALL
1949 JNI_GetCreatedJavaVMs(JavaVM
**, jsize
, jsize
*);
1951 /* Defined by native libraries. */
1952 JNIEXPORT jint JNICALL
1953 JNI_OnLoad(JavaVM
*vm
, void *reserved
);
1955 JNIEXPORT
void JNICALL
1956 JNI_OnUnload(JavaVM
*vm
, void *reserved
);
1958 #define JNI_VERSION_1_1 0x00010001
1959 #define JNI_VERSION_1_2 0x00010002
1960 #define JNI_VERSION_1_4 0x00010004
1961 #define JNI_VERSION_1_6 0x00010006
1962 #define JNI_VERSION_1_8 0x00010008
1966 #endif /* __cplusplus */
1968 #endif /* !_JAVASOFT_JNI_H_ */