| /* |
| * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| /* |
| * We used part of Netscape's Java Runtime Interface (JRI) as the starting |
| * point of our design and implementation. |
| */ |
| |
| /****************************************************************************** |
| * Java Runtime Interface |
| * Copyright (c) 1996 Netscape Communications Corporation. All rights reserved. |
| *****************************************************************************/ |
| |
| #ifndef _JAVASOFT_JNI_H_ |
| #define _JAVASOFT_JNI_H_ |
| |
| #include <stdio.h> |
| #include <stdarg.h> |
| |
| /* jni_md.h contains the machine-dependent typedefs for jbyte, jint |
| and jlong */ |
| |
| #include "jni_md.h" |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| /* |
| * JNI Types |
| */ |
| |
| #ifndef JNI_TYPES_ALREADY_DEFINED_IN_JNI_MD_H |
| |
| typedef unsigned char jboolean; |
| typedef unsigned short jchar; |
| typedef short jshort; |
| typedef float jfloat; |
| typedef double jdouble; |
| |
| typedef jint jsize; |
| |
| #ifdef __cplusplus |
| |
| class _jobject {}; |
| class _jclass : public _jobject {}; |
| class _jthrowable : public _jobject {}; |
| class _jstring : public _jobject {}; |
| class _jarray : public _jobject {}; |
| class _jbooleanArray : public _jarray {}; |
| class _jbyteArray : public _jarray {}; |
| class _jcharArray : public _jarray {}; |
| class _jshortArray : public _jarray {}; |
| class _jintArray : public _jarray {}; |
| class _jlongArray : public _jarray {}; |
| class _jfloatArray : public _jarray {}; |
| class _jdoubleArray : public _jarray {}; |
| class _jobjectArray : public _jarray {}; |
| |
| typedef _jobject *jobject; |
| typedef _jclass *jclass; |
| typedef _jthrowable *jthrowable; |
| typedef _jstring *jstring; |
| typedef _jarray *jarray; |
| typedef _jbooleanArray *jbooleanArray; |
| typedef _jbyteArray *jbyteArray; |
| typedef _jcharArray *jcharArray; |
| typedef _jshortArray *jshortArray; |
| typedef _jintArray *jintArray; |
| typedef _jlongArray *jlongArray; |
| typedef _jfloatArray *jfloatArray; |
| typedef _jdoubleArray *jdoubleArray; |
| typedef _jobjectArray *jobjectArray; |
| |
| #else |
| |
| struct _jobject; |
| |
| typedef struct _jobject *jobject; |
| typedef jobject jclass; |
| typedef jobject jthrowable; |
| typedef jobject jstring; |
| typedef jobject jarray; |
| typedef jarray jbooleanArray; |
| typedef jarray jbyteArray; |
| typedef jarray jcharArray; |
| typedef jarray jshortArray; |
| typedef jarray jintArray; |
| typedef jarray jlongArray; |
| typedef jarray jfloatArray; |
| typedef jarray jdoubleArray; |
| typedef jarray jobjectArray; |
| |
| #endif |
| |
| typedef jobject jweak; |
| |
| typedef union jvalue { |
| jboolean z; |
| jbyte b; |
| jchar c; |
| jshort s; |
| jint i; |
| jlong j; |
| jfloat f; |
| jdouble d; |
| jobject l; |
| } jvalue; |
| |
| struct _jfieldID; |
| typedef struct _jfieldID *jfieldID; |
| |
| struct _jmethodID; |
| typedef struct _jmethodID *jmethodID; |
| |
| /* Return values from jobjectRefType */ |
| typedef enum _jobjectType { |
| JNIInvalidRefType = 0, |
| JNILocalRefType = 1, |
| JNIGlobalRefType = 2, |
| JNIWeakGlobalRefType = 3 |
| } jobjectRefType; |
| |
| |
| #endif /* JNI_TYPES_ALREADY_DEFINED_IN_JNI_MD_H */ |
| |
| /* |
| * jboolean constants |
| */ |
| |
| #define JNI_FALSE 0 |
| #define JNI_TRUE 1 |
| |
| /* |
| * possible return values for JNI functions. |
| */ |
| |
| #define JNI_OK 0 /* success */ |
| #define JNI_ERR (-1) /* unknown error */ |
| #define JNI_EDETACHED (-2) /* thread detached from the VM */ |
| #define JNI_EVERSION (-3) /* JNI version error */ |
| #define JNI_ENOMEM (-4) /* not enough memory */ |
| #define JNI_EEXIST (-5) /* VM already created */ |
| #define JNI_EINVAL (-6) /* invalid arguments */ |
| |
| /* |
| * used in ReleaseScalarArrayElements |
| */ |
| |
| #define JNI_COMMIT 1 |
| #define JNI_ABORT 2 |
| |
| /* |
| * used in RegisterNatives to describe native method name, signature, |
| * and function pointer. |
| */ |
| |
| typedef struct { |
| char *name; |
| char *signature; |
| void *fnPtr; |
| } JNINativeMethod; |
| |
| /* |
| * JNI Native Method Interface. |
| */ |
| |
| struct JNINativeInterface_; |
| |
| struct JNIEnv_; |
| |
| #ifdef __cplusplus |
| typedef JNIEnv_ JNIEnv; |
| #else |
| typedef const struct JNINativeInterface_ *JNIEnv; |
| #endif |
| |
| /* |
| * JNI Invocation Interface. |
| */ |
| |
| struct JNIInvokeInterface_; |
| |
| struct JavaVM_; |
| |
| #ifdef __cplusplus |
| typedef JavaVM_ JavaVM; |
| #else |
| typedef const struct JNIInvokeInterface_ *JavaVM; |
| #endif |
| |
| struct JNINativeInterface_ { |
| void *reserved0; |
| void *reserved1; |
| void *reserved2; |
| |
| void *reserved3; |
| jint (JNICALL *GetVersion)(JNIEnv *env); |
| |
| jclass (JNICALL *DefineClass) |
| (JNIEnv *env, const char *name, jobject loader, const jbyte *buf, |
| jsize len); |
| jclass (JNICALL *FindClass) |
| (JNIEnv *env, const char *name); |
| |
| jmethodID (JNICALL *FromReflectedMethod) |
| (JNIEnv *env, jobject method); |
| jfieldID (JNICALL *FromReflectedField) |
| (JNIEnv *env, jobject field); |
| |
| jobject (JNICALL *ToReflectedMethod) |
| (JNIEnv *env, jclass cls, jmethodID methodID, jboolean isStatic); |
| |
| jclass (JNICALL *GetSuperclass) |
| (JNIEnv *env, jclass sub); |
| jboolean (JNICALL *IsAssignableFrom) |
| (JNIEnv *env, jclass sub, jclass sup); |
| |
| jobject (JNICALL *ToReflectedField) |
| (JNIEnv *env, jclass cls, jfieldID fieldID, jboolean isStatic); |
| |
| jint (JNICALL *Throw) |
| (JNIEnv *env, jthrowable obj); |
| jint (JNICALL *ThrowNew) |
| (JNIEnv *env, jclass clazz, const char *msg); |
| jthrowable (JNICALL *ExceptionOccurred) |
| (JNIEnv *env); |
| void (JNICALL *ExceptionDescribe) |
| (JNIEnv *env); |
| void (JNICALL *ExceptionClear) |
| (JNIEnv *env); |
| void (JNICALL *FatalError) |
| (JNIEnv *env, const char *msg); |
| |
| jint (JNICALL *PushLocalFrame) |
| (JNIEnv *env, jint capacity); |
| jobject (JNICALL *PopLocalFrame) |
| (JNIEnv *env, jobject result); |
| |
| jobject (JNICALL *NewGlobalRef) |
| (JNIEnv *env, jobject lobj); |
| void (JNICALL *DeleteGlobalRef) |
| (JNIEnv *env, jobject gref); |
| void (JNICALL *DeleteLocalRef) |
| (JNIEnv *env, jobject obj); |
| jboolean (JNICALL *IsSameObject) |
| (JNIEnv *env, jobject obj1, jobject obj2); |
| jobject (JNICALL *NewLocalRef) |
| (JNIEnv *env, jobject ref); |
| jint (JNICALL *EnsureLocalCapacity) |
| (JNIEnv *env, jint capacity); |
| |
| jobject (JNICALL *AllocObject) |
| (JNIEnv *env, jclass clazz); |
| jobject (JNICALL *NewObject) |
| (JNIEnv *env, jclass clazz, jmethodID methodID, ...); |
| jobject (JNICALL *NewObjectV) |
| (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); |
| jobject (JNICALL *NewObjectA) |
| (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args); |
| |
| jclass (JNICALL *GetObjectClass) |
| (JNIEnv *env, jobject obj); |
| jboolean (JNICALL *IsInstanceOf) |
| (JNIEnv *env, jobject obj, jclass clazz); |
| |
| jmethodID (JNICALL *GetMethodID) |
| (JNIEnv *env, jclass clazz, const char *name, const char *sig); |
| |
| jobject (JNICALL *CallObjectMethod) |
| (JNIEnv *env, jobject obj, jmethodID methodID, ...); |
| jobject (JNICALL *CallObjectMethodV) |
| (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); |
| jobject (JNICALL *CallObjectMethodA) |
| (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue * args); |
| |
| jboolean (JNICALL *CallBooleanMethod) |
| (JNIEnv *env, jobject obj, jmethodID methodID, ...); |
| jboolean (JNICALL *CallBooleanMethodV) |
| (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); |
| jboolean (JNICALL *CallBooleanMethodA) |
| (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue * args); |
| |
| jbyte (JNICALL *CallByteMethod) |
| (JNIEnv *env, jobject obj, jmethodID methodID, ...); |
| jbyte (JNICALL *CallByteMethodV) |
| (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); |
| jbyte (JNICALL *CallByteMethodA) |
| (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args); |
| |
| jchar (JNICALL *CallCharMethod) |
| (JNIEnv *env, jobject obj, jmethodID methodID, ...); |
| jchar (JNICALL *CallCharMethodV) |
| (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); |
| jchar (JNICALL *CallCharMethodA) |
| (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args); |
| |
| jshort (JNICALL *CallShortMethod) |
| (JNIEnv *env, jobject obj, jmethodID methodID, ...); |
| jshort (JNICALL *CallShortMethodV) |
| (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); |
| jshort (JNICALL *CallShortMethodA) |
| (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args); |
| |
| jint (JNICALL *CallIntMethod) |
| (JNIEnv *env, jobject obj, jmethodID methodID, ...); |
| jint (JNICALL *CallIntMethodV) |
| (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); |
| jint (JNICALL *CallIntMethodA) |
| (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args); |
| |
| jlong (JNICALL *CallLongMethod) |
| (JNIEnv *env, jobject obj, jmethodID methodID, ...); |
| jlong (JNICALL *CallLongMethodV) |
| (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); |
| jlong (JNICALL *CallLongMethodA) |
| (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args); |
| |
| jfloat (JNICALL *CallFloatMethod) |
| (JNIEnv *env, jobject obj, jmethodID methodID, ...); |
| jfloat (JNICALL *CallFloatMethodV) |
| (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); |
| jfloat (JNICALL *CallFloatMethodA) |
| (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args); |
| |
| jdouble (JNICALL *CallDoubleMethod) |
| (JNIEnv *env, jobject obj, jmethodID methodID, ...); |
| jdouble (JNICALL *CallDoubleMethodV) |
| (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); |
| jdouble (JNICALL *CallDoubleMethodA) |
| (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args); |
| |
| void (JNICALL *CallVoidMethod) |
| (JNIEnv *env, jobject obj, jmethodID methodID, ...); |
| void (JNICALL *CallVoidMethodV) |
| (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); |
| void (JNICALL *CallVoidMethodA) |
| (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue * args); |
| |
| jobject (JNICALL *CallNonvirtualObjectMethod) |
| (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); |
| jobject (JNICALL *CallNonvirtualObjectMethodV) |
| (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, |
| va_list args); |
| jobject (JNICALL *CallNonvirtualObjectMethodA) |
| (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, |
| const jvalue * args); |
| |
| jboolean (JNICALL *CallNonvirtualBooleanMethod) |
| (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); |
| jboolean (JNICALL *CallNonvirtualBooleanMethodV) |
| (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, |
| va_list args); |
| jboolean (JNICALL *CallNonvirtualBooleanMethodA) |
| (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, |
| const jvalue * args); |
| |
| jbyte (JNICALL *CallNonvirtualByteMethod) |
| (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); |
| jbyte (JNICALL *CallNonvirtualByteMethodV) |
| (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, |
| va_list args); |
| jbyte (JNICALL *CallNonvirtualByteMethodA) |
| (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, |
| const jvalue *args); |
| |
| jchar (JNICALL *CallNonvirtualCharMethod) |
| (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); |
| jchar (JNICALL *CallNonvirtualCharMethodV) |
| (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, |
| va_list args); |
| jchar (JNICALL *CallNonvirtualCharMethodA) |
| (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, |
| const jvalue *args); |
| |
| jshort (JNICALL *CallNonvirtualShortMethod) |
| (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); |
| jshort (JNICALL *CallNonvirtualShortMethodV) |
| (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, |
| va_list args); |
| jshort (JNICALL *CallNonvirtualShortMethodA) |
| (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, |
| const jvalue *args); |
| |
| jint (JNICALL *CallNonvirtualIntMethod) |
| (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); |
| jint (JNICALL *CallNonvirtualIntMethodV) |
| (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, |
| va_list args); |
| jint (JNICALL *CallNonvirtualIntMethodA) |
| (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, |
| const jvalue *args); |
| |
| jlong (JNICALL *CallNonvirtualLongMethod) |
| (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); |
| jlong (JNICALL *CallNonvirtualLongMethodV) |
| (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, |
| va_list args); |
| jlong (JNICALL *CallNonvirtualLongMethodA) |
| (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, |
| const jvalue *args); |
| |
| jfloat (JNICALL *CallNonvirtualFloatMethod) |
| (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); |
| jfloat (JNICALL *CallNonvirtualFloatMethodV) |
| (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, |
| va_list args); |
| jfloat (JNICALL *CallNonvirtualFloatMethodA) |
| (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, |
| const jvalue *args); |
| |
| jdouble (JNICALL *CallNonvirtualDoubleMethod) |
| (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); |
| jdouble (JNICALL *CallNonvirtualDoubleMethodV) |
| (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, |
| va_list args); |
| jdouble (JNICALL *CallNonvirtualDoubleMethodA) |
| (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, |
| const jvalue *args); |
| |
| void (JNICALL *CallNonvirtualVoidMethod) |
| (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); |
| void (JNICALL *CallNonvirtualVoidMethodV) |
| (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, |
| va_list args); |
| void (JNICALL *CallNonvirtualVoidMethodA) |
| (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, |
| const jvalue * args); |
| |
| jfieldID (JNICALL *GetFieldID) |
| (JNIEnv *env, jclass clazz, const char *name, const char *sig); |
| |
| jobject (JNICALL *GetObjectField) |
| (JNIEnv *env, jobject obj, jfieldID fieldID); |
| jboolean (JNICALL *GetBooleanField) |
| (JNIEnv *env, jobject obj, jfieldID fieldID); |
| jbyte (JNICALL *GetByteField) |
| (JNIEnv *env, jobject obj, jfieldID fieldID); |
| jchar (JNICALL *GetCharField) |
| (JNIEnv *env, jobject obj, jfieldID fieldID); |
| jshort (JNICALL *GetShortField) |
| (JNIEnv *env, jobject obj, jfieldID fieldID); |
| jint (JNICALL *GetIntField) |
| (JNIEnv *env, jobject obj, jfieldID fieldID); |
| jlong (JNICALL *GetLongField) |
| (JNIEnv *env, jobject obj, jfieldID fieldID); |
| jfloat (JNICALL *GetFloatField) |
| (JNIEnv *env, jobject obj, jfieldID fieldID); |
| jdouble (JNICALL *GetDoubleField) |
| (JNIEnv *env, jobject obj, jfieldID fieldID); |
| |
| void (JNICALL *SetObjectField) |
| (JNIEnv *env, jobject obj, jfieldID fieldID, jobject val); |
| void (JNICALL *SetBooleanField) |
| (JNIEnv *env, jobject obj, jfieldID fieldID, jboolean val); |
| void (JNICALL *SetByteField) |
| (JNIEnv *env, jobject obj, jfieldID fieldID, jbyte val); |
| void (JNICALL *SetCharField) |
| (JNIEnv *env, jobject obj, jfieldID fieldID, jchar val); |
| void (JNICALL *SetShortField) |
| (JNIEnv *env, jobject obj, jfieldID fieldID, jshort val); |
| void (JNICALL *SetIntField) |
| (JNIEnv *env, jobject obj, jfieldID fieldID, jint val); |
| void (JNICALL *SetLongField) |
| (JNIEnv *env, jobject obj, jfieldID fieldID, jlong val); |
| void (JNICALL *SetFloatField) |
| (JNIEnv *env, jobject obj, jfieldID fieldID, jfloat val); |
| void (JNICALL *SetDoubleField) |
| (JNIEnv *env, jobject obj, jfieldID fieldID, jdouble val); |
| |
| jmethodID (JNICALL *GetStaticMethodID) |
| (JNIEnv *env, jclass clazz, const char *name, const char *sig); |
| |
| jobject (JNICALL *CallStaticObjectMethod) |
| (JNIEnv *env, jclass clazz, jmethodID methodID, ...); |
| jobject (JNICALL *CallStaticObjectMethodV) |
| (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); |
| jobject (JNICALL *CallStaticObjectMethodA) |
| (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args); |
| |
| jboolean (JNICALL *CallStaticBooleanMethod) |
| (JNIEnv *env, jclass clazz, jmethodID methodID, ...); |
| jboolean (JNICALL *CallStaticBooleanMethodV) |
| (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); |
| jboolean (JNICALL *CallStaticBooleanMethodA) |
| (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args); |
| |
| jbyte (JNICALL *CallStaticByteMethod) |
| (JNIEnv *env, jclass clazz, jmethodID methodID, ...); |
| jbyte (JNICALL *CallStaticByteMethodV) |
| (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); |
| jbyte (JNICALL *CallStaticByteMethodA) |
| (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args); |
| |
| jchar (JNICALL *CallStaticCharMethod) |
| (JNIEnv *env, jclass clazz, jmethodID methodID, ...); |
| jchar (JNICALL *CallStaticCharMethodV) |
| (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); |
| jchar (JNICALL *CallStaticCharMethodA) |
| (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args); |
| |
| jshort (JNICALL *CallStaticShortMethod) |
| (JNIEnv *env, jclass clazz, jmethodID methodID, ...); |
| jshort (JNICALL *CallStaticShortMethodV) |
| (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); |
| jshort (JNICALL *CallStaticShortMethodA) |
| (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args); |
| |
| jint (JNICALL *CallStaticIntMethod) |
| (JNIEnv *env, jclass clazz, jmethodID methodID, ...); |
| jint (JNICALL *CallStaticIntMethodV) |
| (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); |
| jint (JNICALL *CallStaticIntMethodA) |
| (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args); |
| |
| jlong (JNICALL *CallStaticLongMethod) |
| (JNIEnv *env, jclass clazz, jmethodID methodID, ...); |
| jlong (JNICALL *CallStaticLongMethodV) |
| (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); |
| jlong (JNICALL *CallStaticLongMethodA) |
| (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args); |
| |
| jfloat (JNICALL *CallStaticFloatMethod) |
| (JNIEnv *env, jclass clazz, jmethodID methodID, ...); |
| jfloat (JNICALL *CallStaticFloatMethodV) |
| (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); |
| jfloat (JNICALL *CallStaticFloatMethodA) |
| (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args); |
| |
| jdouble (JNICALL *CallStaticDoubleMethod) |
| (JNIEnv *env, jclass clazz, jmethodID methodID, ...); |
| jdouble (JNICALL *CallStaticDoubleMethodV) |
| (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); |
| jdouble (JNICALL *CallStaticDoubleMethodA) |
| (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args); |
| |
| void (JNICALL *CallStaticVoidMethod) |
| (JNIEnv *env, jclass cls, jmethodID methodID, ...); |
| void (JNICALL *CallStaticVoidMethodV) |
| (JNIEnv *env, jclass cls, jmethodID methodID, va_list args); |
| void (JNICALL *CallStaticVoidMethodA) |
| (JNIEnv *env, jclass cls, jmethodID methodID, const jvalue * args); |
| |
| jfieldID (JNICALL *GetStaticFieldID) |
| (JNIEnv *env, jclass clazz, const char *name, const char *sig); |
| jobject (JNICALL *GetStaticObjectField) |
| (JNIEnv *env, jclass clazz, jfieldID fieldID); |
| jboolean (JNICALL *GetStaticBooleanField) |
| (JNIEnv *env, jclass clazz, jfieldID fieldID); |
| jbyte (JNICALL *GetStaticByteField) |
| (JNIEnv *env, jclass clazz, jfieldID fieldID); |
| jchar (JNICALL *GetStaticCharField) |
| (JNIEnv *env, jclass clazz, jfieldID fieldID); |
| jshort (JNICALL *GetStaticShortField) |
| (JNIEnv *env, jclass clazz, jfieldID fieldID); |
| jint (JNICALL *GetStaticIntField) |
| (JNIEnv *env, jclass clazz, jfieldID fieldID); |
| jlong (JNICALL *GetStaticLongField) |
| (JNIEnv *env, jclass clazz, jfieldID fieldID); |
| jfloat (JNICALL *GetStaticFloatField) |
| (JNIEnv *env, jclass clazz, jfieldID fieldID); |
| jdouble (JNICALL *GetStaticDoubleField) |
| (JNIEnv *env, jclass clazz, jfieldID fieldID); |
| |
| void (JNICALL *SetStaticObjectField) |
| (JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value); |
| void (JNICALL *SetStaticBooleanField) |
| (JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value); |
| void (JNICALL *SetStaticByteField) |
| (JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value); |
| void (JNICALL *SetStaticCharField) |
| (JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value); |
| void (JNICALL *SetStaticShortField) |
| (JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value); |
| void (JNICALL *SetStaticIntField) |
| (JNIEnv *env, jclass clazz, jfieldID fieldID, jint value); |
| void (JNICALL *SetStaticLongField) |
| (JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value); |
| void (JNICALL *SetStaticFloatField) |
| (JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value); |
| void (JNICALL *SetStaticDoubleField) |
| (JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value); |
| |
| jstring (JNICALL *NewString) |
| (JNIEnv *env, const jchar *unicode, jsize len); |
| jsize (JNICALL *GetStringLength) |
| (JNIEnv *env, jstring str); |
| const jchar *(JNICALL *GetStringChars) |
| (JNIEnv *env, jstring str, jboolean *isCopy); |
| void (JNICALL *ReleaseStringChars) |
| (JNIEnv *env, jstring str, const jchar *chars); |
| |
| jstring (JNICALL *NewStringUTF) |
| (JNIEnv *env, const char *utf); |
| jsize (JNICALL *GetStringUTFLength) |
| (JNIEnv *env, jstring str); |
| const char* (JNICALL *GetStringUTFChars) |
| (JNIEnv *env, jstring str, jboolean *isCopy); |
| void (JNICALL *ReleaseStringUTFChars) |
| (JNIEnv *env, jstring str, const char* chars); |
| |
| |
| jsize (JNICALL *GetArrayLength) |
| (JNIEnv *env, jarray array); |
| |
| jobjectArray (JNICALL *NewObjectArray) |
| (JNIEnv *env, jsize len, jclass clazz, jobject init); |
| jobject (JNICALL *GetObjectArrayElement) |
| (JNIEnv *env, jobjectArray array, jsize index); |
| void (JNICALL *SetObjectArrayElement) |
| (JNIEnv *env, jobjectArray array, jsize index, jobject val); |
| |
| jbooleanArray (JNICALL *NewBooleanArray) |
| (JNIEnv *env, jsize len); |
| jbyteArray (JNICALL *NewByteArray) |
| (JNIEnv *env, jsize len); |
| jcharArray (JNICALL *NewCharArray) |
| (JNIEnv *env, jsize len); |
| jshortArray (JNICALL *NewShortArray) |
| (JNIEnv *env, jsize len); |
| jintArray (JNICALL *NewIntArray) |
| (JNIEnv *env, jsize len); |
| jlongArray (JNICALL *NewLongArray) |
| (JNIEnv *env, jsize len); |
| jfloatArray (JNICALL *NewFloatArray) |
| (JNIEnv *env, jsize len); |
| jdoubleArray (JNICALL *NewDoubleArray) |
| (JNIEnv *env, jsize len); |
| |
| jboolean * (JNICALL *GetBooleanArrayElements) |
| (JNIEnv *env, jbooleanArray array, jboolean *isCopy); |
| jbyte * (JNICALL *GetByteArrayElements) |
| (JNIEnv *env, jbyteArray array, jboolean *isCopy); |
| jchar * (JNICALL *GetCharArrayElements) |
| (JNIEnv *env, jcharArray array, jboolean *isCopy); |
| jshort * (JNICALL *GetShortArrayElements) |
| (JNIEnv *env, jshortArray array, jboolean *isCopy); |
| jint * (JNICALL *GetIntArrayElements) |
| (JNIEnv *env, jintArray array, jboolean *isCopy); |
| jlong * (JNICALL *GetLongArrayElements) |
| (JNIEnv *env, jlongArray array, jboolean *isCopy); |
| jfloat * (JNICALL *GetFloatArrayElements) |
| (JNIEnv *env, jfloatArray array, jboolean *isCopy); |
| jdouble * (JNICALL *GetDoubleArrayElements) |
| (JNIEnv *env, jdoubleArray array, jboolean *isCopy); |
| |
| void (JNICALL *ReleaseBooleanArrayElements) |
| (JNIEnv *env, jbooleanArray array, jboolean *elems, jint mode); |
| void (JNICALL *ReleaseByteArrayElements) |
| (JNIEnv *env, jbyteArray array, jbyte *elems, jint mode); |
| void (JNICALL *ReleaseCharArrayElements) |
| (JNIEnv *env, jcharArray array, jchar *elems, jint mode); |
| void (JNICALL *ReleaseShortArrayElements) |
| (JNIEnv *env, jshortArray array, jshort *elems, jint mode); |
| void (JNICALL *ReleaseIntArrayElements) |
| (JNIEnv *env, jintArray array, jint *elems, jint mode); |
| void (JNICALL *ReleaseLongArrayElements) |
| (JNIEnv *env, jlongArray array, jlong *elems, jint mode); |
| void (JNICALL *ReleaseFloatArrayElements) |
| (JNIEnv *env, jfloatArray array, jfloat *elems, jint mode); |
| void (JNICALL *ReleaseDoubleArrayElements) |
| (JNIEnv *env, jdoubleArray array, jdouble *elems, jint mode); |
| |
| void (JNICALL *GetBooleanArrayRegion) |
| (JNIEnv *env, jbooleanArray array, jsize start, jsize l, jboolean *buf); |
| void (JNICALL *GetByteArrayRegion) |
| (JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf); |
| void (JNICALL *GetCharArrayRegion) |
| (JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf); |
| void (JNICALL *GetShortArrayRegion) |
| (JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf); |
| void (JNICALL *GetIntArrayRegion) |
| (JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf); |
| void (JNICALL *GetLongArrayRegion) |
| (JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf); |
| void (JNICALL *GetFloatArrayRegion) |
| (JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf); |
| void (JNICALL *GetDoubleArrayRegion) |
| (JNIEnv *env, jdoubleArray array, jsize start, jsize len, jdouble *buf); |
| |
| void (JNICALL *SetBooleanArrayRegion) |
| (JNIEnv *env, jbooleanArray array, jsize start, jsize l, const jboolean *buf); |
| void (JNICALL *SetByteArrayRegion) |
| (JNIEnv *env, jbyteArray array, jsize start, jsize len, const jbyte *buf); |
| void (JNICALL *SetCharArrayRegion) |
| (JNIEnv *env, jcharArray array, jsize start, jsize len, const jchar *buf); |
| void (JNICALL *SetShortArrayRegion) |
| (JNIEnv *env, jshortArray array, jsize start, jsize len, const jshort *buf); |
| void (JNICALL *SetIntArrayRegion) |
| (JNIEnv *env, jintArray array, jsize start, jsize len, const jint *buf); |
| void (JNICALL *SetLongArrayRegion) |
| (JNIEnv *env, jlongArray array, jsize start, jsize len, const jlong *buf); |
| void (JNICALL *SetFloatArrayRegion) |
| (JNIEnv *env, jfloatArray array, jsize start, jsize len, const jfloat *buf); |
| void (JNICALL *SetDoubleArrayRegion) |
| (JNIEnv *env, jdoubleArray array, jsize start, jsize len, const jdouble *buf); |
| |
| jint (JNICALL *RegisterNatives) |
| (JNIEnv *env, jclass clazz, const JNINativeMethod *methods, |
| jint nMethods); |
| jint (JNICALL *UnregisterNatives) |
| (JNIEnv *env, jclass clazz); |
| |
| jint (JNICALL *MonitorEnter) |
| (JNIEnv *env, jobject obj); |
| jint (JNICALL *MonitorExit) |
| (JNIEnv *env, jobject obj); |
| |
| jint (JNICALL *GetJavaVM) |
| (JNIEnv *env, JavaVM **vm); |
| |
| void (JNICALL *GetStringRegion) |
| (JNIEnv *env, jstring str, jsize start, jsize len, jchar *buf); |
| void (JNICALL *GetStringUTFRegion) |
| (JNIEnv *env, jstring str, jsize start, jsize len, char *buf); |
| |
| void * (JNICALL *GetPrimitiveArrayCritical) |
| (JNIEnv *env, jarray array, jboolean *isCopy); |
| void (JNICALL *ReleasePrimitiveArrayCritical) |
| (JNIEnv *env, jarray array, void *carray, jint mode); |
| |
| const jchar * (JNICALL *GetStringCritical) |
| (JNIEnv *env, jstring string, jboolean *isCopy); |
| void (JNICALL *ReleaseStringCritical) |
| (JNIEnv *env, jstring string, const jchar *cstring); |
| |
| jweak (JNICALL *NewWeakGlobalRef) |
| (JNIEnv *env, jobject obj); |
| void (JNICALL *DeleteWeakGlobalRef) |
| (JNIEnv *env, jweak ref); |
| |
| jboolean (JNICALL *ExceptionCheck) |
| (JNIEnv *env); |
| |
| jobject (JNICALL *NewDirectByteBuffer) |
| (JNIEnv* env, void* address, jlong capacity); |
| void* (JNICALL *GetDirectBufferAddress) |
| (JNIEnv* env, jobject buf); |
| jlong (JNICALL *GetDirectBufferCapacity) |
| (JNIEnv* env, jobject buf); |
| |
| /* New JNI 1.6 Features */ |
| |
| jobjectRefType (JNICALL *GetObjectRefType) |
| (JNIEnv* env, jobject obj); |
| }; |
| |
| /* |
| * We use inlined functions for C++ so that programmers can write: |
| * |
| * env->FindClass("java/lang/String") |
| * |
| * in C++ rather than: |
| * |
| * (*env)->FindClass(env, "java/lang/String") |
| * |
| * in C. |
| */ |
| |
| struct JNIEnv_ { |
| const struct JNINativeInterface_ *functions; |
| #ifdef __cplusplus |
| |
| jint GetVersion() { |
| return functions->GetVersion(this); |
| } |
| jclass DefineClass(const char *name, jobject loader, const jbyte *buf, |
| jsize len) { |
| return functions->DefineClass(this, name, loader, buf, len); |
| } |
| jclass FindClass(const char *name) { |
| return functions->FindClass(this, name); |
| } |
| jmethodID FromReflectedMethod(jobject method) { |
| return functions->FromReflectedMethod(this,method); |
| } |
| jfieldID FromReflectedField(jobject field) { |
| return functions->FromReflectedField(this,field); |
| } |
| |
| jobject ToReflectedMethod(jclass cls, jmethodID methodID, jboolean isStatic) { |
| return functions->ToReflectedMethod(this, cls, methodID, isStatic); |
| } |
| |
| jclass GetSuperclass(jclass sub) { |
| return functions->GetSuperclass(this, sub); |
| } |
| jboolean IsAssignableFrom(jclass sub, jclass sup) { |
| return functions->IsAssignableFrom(this, sub, sup); |
| } |
| |
| jobject ToReflectedField(jclass cls, jfieldID fieldID, jboolean isStatic) { |
| return functions->ToReflectedField(this,cls,fieldID,isStatic); |
| } |
| |
| jint Throw(jthrowable obj) { |
| return functions->Throw(this, obj); |
| } |
| jint ThrowNew(jclass clazz, const char *msg) { |
| return functions->ThrowNew(this, clazz, msg); |
| } |
| jthrowable ExceptionOccurred() { |
| return functions->ExceptionOccurred(this); |
| } |
| void ExceptionDescribe() { |
| functions->ExceptionDescribe(this); |
| } |
| void ExceptionClear() { |
| functions->ExceptionClear(this); |
| } |
| void FatalError(const char *msg) { |
| functions->FatalError(this, msg); |
| } |
| |
| jint PushLocalFrame(jint capacity) { |
| return functions->PushLocalFrame(this,capacity); |
| } |
| jobject PopLocalFrame(jobject result) { |
| return functions->PopLocalFrame(this,result); |
| } |
| |
| jobject NewGlobalRef(jobject lobj) { |
| return functions->NewGlobalRef(this,lobj); |
| } |
| void DeleteGlobalRef(jobject gref) { |
| functions->DeleteGlobalRef(this,gref); |
| } |
| void DeleteLocalRef(jobject obj) { |
| functions->DeleteLocalRef(this, obj); |
| } |
| |
| jboolean IsSameObject(jobject obj1, jobject obj2) { |
| return functions->IsSameObject(this,obj1,obj2); |
| } |
| |
| jobject NewLocalRef(jobject ref) { |
| return functions->NewLocalRef(this,ref); |
| } |
| jint EnsureLocalCapacity(jint capacity) { |
| return functions->EnsureLocalCapacity(this,capacity); |
| } |
| |
| jobject AllocObject(jclass clazz) { |
| return functions->AllocObject(this,clazz); |
| } |
| jobject NewObject(jclass clazz, jmethodID methodID, ...) { |
| va_list args; |
| jobject result; |
| va_start(args, methodID); |
| result = functions->NewObjectV(this,clazz,methodID,args); |
| va_end(args); |
| return result; |
| } |
| jobject NewObjectV(jclass clazz, jmethodID methodID, |
| va_list args) { |
| return functions->NewObjectV(this,clazz,methodID,args); |
| } |
| jobject NewObjectA(jclass clazz, jmethodID methodID, |
| const jvalue *args) { |
| return functions->NewObjectA(this,clazz,methodID,args); |
| } |
| |
| jclass GetObjectClass(jobject obj) { |
| return functions->GetObjectClass(this,obj); |
| } |
| jboolean IsInstanceOf(jobject obj, jclass clazz) { |
| return functions->IsInstanceOf(this,obj,clazz); |
| } |
| |
| jmethodID GetMethodID(jclass clazz, const char *name, |
| const char *sig) { |
| return functions->GetMethodID(this,clazz,name,sig); |
| } |
| |
| jobject CallObjectMethod(jobject obj, jmethodID methodID, ...) { |
| va_list args; |
| jobject result; |
| va_start(args,methodID); |
| result = functions->CallObjectMethodV(this,obj,methodID,args); |
| va_end(args); |
| return result; |
| } |
| jobject CallObjectMethodV(jobject obj, jmethodID methodID, |
| va_list args) { |
| return functions->CallObjectMethodV(this,obj,methodID,args); |
| } |
| jobject CallObjectMethodA(jobject obj, jmethodID methodID, |
| const jvalue * args) { |
| return functions->CallObjectMethodA(this,obj,methodID,args); |
| } |
| |
| jboolean CallBooleanMethod(jobject obj, |
| jmethodID methodID, ...) { |
| va_list args; |
| jboolean result; |
| va_start(args,methodID); |
| result = functions->CallBooleanMethodV(this,obj,methodID,args); |
| va_end(args); |
| return result; |
| } |
| jboolean CallBooleanMethodV(jobject obj, jmethodID methodID, |
| va_list args) { |
| return functions->CallBooleanMethodV(this,obj,methodID,args); |
| } |
| jboolean CallBooleanMethodA(jobject obj, jmethodID methodID, |
| const jvalue * args) { |
| return functions->CallBooleanMethodA(this,obj,methodID, args); |
| } |
| |
| jbyte CallByteMethod(jobject obj, jmethodID methodID, ...) { |
| va_list args; |
| jbyte result; |
| va_start(args,methodID); |
| result = functions->CallByteMethodV(this,obj,methodID,args); |
| va_end(args); |
| return result; |
| } |
| jbyte CallByteMethodV(jobject obj, jmethodID methodID, |
| va_list args) { |
| return functions->CallByteMethodV(this,obj,methodID,args); |
| } |
| jbyte CallByteMethodA(jobject obj, jmethodID methodID, |
| const jvalue * args) { |
| return functions->CallByteMethodA(this,obj,methodID,args); |
| } |
| |
| jchar CallCharMethod(jobject obj, jmethodID methodID, ...) { |
| va_list args; |
| jchar result; |
| va_start(args,methodID); |
| result = functions->CallCharMethodV(this,obj,methodID,args); |
| va_end(args); |
| return result; |
| } |
| jchar CallCharMethodV(jobject obj, jmethodID methodID, |
| va_list args) { |
| return functions->CallCharMethodV(this,obj,methodID,args); |
| } |
| jchar CallCharMethodA(jobject obj, jmethodID methodID, |
| const jvalue * args) { |
| return functions->CallCharMethodA(this,obj,methodID,args); |
| } |
| |
| jshort CallShortMethod(jobject obj, jmethodID methodID, ...) { |
| va_list args; |
| jshort result; |
| va_start(args,methodID); |
| result = functions->CallShortMethodV(this,obj,methodID,args); |
| va_end(args); |
| return result; |
| } |
| jshort CallShortMethodV(jobject obj, jmethodID methodID, |
| va_list args) { |
| return functions->CallShortMethodV(this,obj,methodID,args); |
| } |
| jshort CallShortMethodA(jobject obj, jmethodID methodID, |
| const jvalue * args) { |
| return functions->CallShortMethodA(this,obj,methodID,args); |
| } |
| |
| jint CallIntMethod(jobject obj, jmethodID methodID, ...) { |
| va_list args; |
| jint result; |
| va_start(args,methodID); |
| result = functions->CallIntMethodV(this,obj,methodID,args); |
| va_end(args); |
| return result; |
| } |
| jint CallIntMethodV(jobject obj, jmethodID methodID, |
| va_list args) { |
| return functions->CallIntMethodV(this,obj,methodID,args); |
| } |
| jint CallIntMethodA(jobject obj, jmethodID methodID, |
| const jvalue * args) { |
| return functions->CallIntMethodA(this,obj,methodID,args); |
| } |
| |
| jlong CallLongMethod(jobject obj, jmethodID methodID, ...) { |
| va_list args; |
| jlong result; |
| va_start(args,methodID); |
| result = functions->CallLongMethodV(this,obj,methodID,args); |
| va_end(args); |
| return result; |
| } |
| jlong CallLongMethodV(jobject obj, jmethodID methodID, |
| va_list args) { |
| return functions->CallLongMethodV(this,obj,methodID,args); |
| } |
| jlong CallLongMethodA(jobject obj, jmethodID methodID, |
| const jvalue * args) { |
| return functions->CallLongMethodA(this,obj,methodID,args); |
| } |
| |
| jfloat CallFloatMethod(jobject obj, jmethodID methodID, ...) { |
| va_list args; |
| jfloat result; |
| va_start(args,methodID); |
| result = functions->CallFloatMethodV(this,obj,methodID,args); |
| va_end(args); |
| return result; |
| } |
| jfloat CallFloatMethodV(jobject obj, jmethodID methodID, |
| va_list args) { |
| return functions->CallFloatMethodV(this,obj,methodID,args); |
| } |
| jfloat CallFloatMethodA(jobject obj, jmethodID methodID, |
| const jvalue * args) { |
| return functions->CallFloatMethodA(this,obj,methodID,args); |
| } |
| |
| jdouble CallDoubleMethod(jobject obj, jmethodID methodID, ...) { |
| va_list args; |
| jdouble result; |
| va_start(args,methodID); |
| result = functions->CallDoubleMethodV(this,obj,methodID,args); |
| va_end(args); |
| return result; |
| } |
| jdouble CallDoubleMethodV(jobject obj, jmethodID methodID, |
| va_list args) { |
| return functions->CallDoubleMethodV(this,obj,methodID,args); |
| } |
| jdouble CallDoubleMethodA(jobject obj, jmethodID methodID, |
| const jvalue * args) { |
| return functions->CallDoubleMethodA(this,obj,methodID,args); |
| } |
| |
| void CallVoidMethod(jobject obj, jmethodID methodID, ...) { |
| va_list args; |
| va_start(args,methodID); |
| functions->CallVoidMethodV(this,obj,methodID,args); |
| va_end(args); |
| } |
| void CallVoidMethodV(jobject obj, jmethodID methodID, |
| va_list args) { |
| functions->CallVoidMethodV(this,obj,methodID,args); |
| } |
| void CallVoidMethodA(jobject obj, jmethodID methodID, |
| const jvalue * args) { |
| functions->CallVoidMethodA(this,obj,methodID,args); |
| } |
| |
| jobject CallNonvirtualObjectMethod(jobject obj, jclass clazz, |
| jmethodID methodID, ...) { |
| va_list args; |
| jobject result; |
| va_start(args,methodID); |
| result = functions->CallNonvirtualObjectMethodV(this,obj,clazz, |
| methodID,args); |
| va_end(args); |
| return result; |
| } |
| jobject CallNonvirtualObjectMethodV(jobject obj, jclass clazz, |
| jmethodID methodID, va_list args) { |
| return functions->CallNonvirtualObjectMethodV(this,obj,clazz, |
| methodID,args); |
| } |
| jobject CallNonvirtualObjectMethodA(jobject obj, jclass clazz, |
| jmethodID methodID, const jvalue * args) { |
| return functions->CallNonvirtualObjectMethodA(this,obj,clazz, |
| methodID,args); |
| } |
| |
| jboolean CallNonvirtualBooleanMethod(jobject obj, jclass clazz, |
| jmethodID methodID, ...) { |
| va_list args; |
| jboolean result; |
| va_start(args,methodID); |
| result = functions->CallNonvirtualBooleanMethodV(this,obj,clazz, |
| methodID,args); |
| va_end(args); |
| return result; |
| } |
| jboolean CallNonvirtualBooleanMethodV(jobject obj, jclass clazz, |
| jmethodID methodID, va_list args) { |
| return functions->CallNonvirtualBooleanMethodV(this,obj,clazz, |
| methodID,args); |
| } |
| jboolean CallNonvirtualBooleanMethodA(jobject obj, jclass clazz, |
| jmethodID methodID, const jvalue * args) { |
| return functions->CallNonvirtualBooleanMethodA(this,obj,clazz, |
| methodID, args); |
| } |
| |
| jbyte CallNonvirtualByteMethod(jobject obj, jclass clazz, |
| jmethodID methodID, ...) { |
| va_list args; |
| jbyte result; |
| va_start(args,methodID); |
| result = functions->CallNonvirtualByteMethodV(this,obj,clazz, |
| methodID,args); |
| va_end(args); |
| return result; |
| } |
| jbyte CallNonvirtualByteMethodV(jobject obj, jclass clazz, |
| jmethodID methodID, va_list args) { |
| return functions->CallNonvirtualByteMethodV(this,obj,clazz, |
| methodID,args); |
| } |
| jbyte CallNonvirtualByteMethodA(jobject obj, jclass clazz, |
| jmethodID methodID, const jvalue * args) { |
| return functions->CallNonvirtualByteMethodA(this,obj,clazz, |
| methodID,args); |
| } |
| |
| jchar CallNonvirtualCharMethod(jobject obj, jclass clazz, |
| jmethodID methodID, ...) { |
| va_list args; |
| jchar result; |
| va_start(args,methodID); |
| result = functions->CallNonvirtualCharMethodV(this,obj,clazz, |
| methodID,args); |
| va_end(args); |
| return result; |
| } |
| jchar CallNonvirtualCharMethodV(jobject obj, jclass clazz, |
| jmethodID methodID, va_list args) { |
| return functions->CallNonvirtualCharMethodV(this,obj,clazz, |
| methodID,args); |
| } |
| jchar CallNonvirtualCharMethodA(jobject obj, jclass clazz, |
| jmethodID methodID, const jvalue * args) { |
| return functions->CallNonvirtualCharMethodA(this,obj,clazz, |
| methodID,args); |
| } |
| |
| jshort CallNonvirtualShortMethod(jobject obj, jclass clazz, |
| jmethodID methodID, ...) { |
| va_list args; |
| jshort result; |
| va_start(args,methodID); |
| result = functions->CallNonvirtualShortMethodV(this,obj,clazz, |
| methodID,args); |
| va_end(args); |
| return result; |
| } |
| jshort CallNonvirtualShortMethodV(jobject obj, jclass clazz, |
| jmethodID methodID, va_list args) { |
| return functions->CallNonvirtualShortMethodV(this,obj,clazz, |
| methodID,args); |
| } |
| jshort CallNonvirtualShortMethodA(jobject obj, jclass clazz, |
| jmethodID methodID, const jvalue * args) { |
| return functions->CallNonvirtualShortMethodA(this,obj,clazz, |
| methodID,args); |
| } |
| |
| jint CallNonvirtualIntMethod(jobject obj, jclass clazz, |
| jmethodID methodID, ...) { |
| va_list args; |
| jint result; |
| va_start(args,methodID); |
| result = functions->CallNonvirtualIntMethodV(this,obj,clazz, |
| methodID,args); |
| va_end(args); |
| return result; |
| } |
| jint CallNonvirtualIntMethodV(jobject obj, jclass clazz, |
| jmethodID methodID, va_list args) { |
| return functions->CallNonvirtualIntMethodV(this,obj,clazz, |
| methodID,args); |
| } |
| jint CallNonvirtualIntMethodA(jobject obj, jclass clazz, |
| jmethodID methodID, const jvalue * args) { |
| return functions->CallNonvirtualIntMethodA(this,obj,clazz, |
| methodID,args); |
| } |
| |
| jlong CallNonvirtualLongMethod(jobject obj, jclass clazz, |
| jmethodID methodID, ...) { |
| va_list args; |
| jlong result; |
| va_start(args,methodID); |
| result = functions->CallNonvirtualLongMethodV(this,obj,clazz, |
| methodID,args); |
| va_end(args); |
| return result; |
| } |
| jlong CallNonvirtualLongMethodV(jobject obj, jclass clazz, |
| jmethodID methodID, va_list args) { |
| return functions->CallNonvirtualLongMethodV(this,obj,clazz, |
| methodID,args); |
| } |
| jlong CallNonvirtualLongMethodA(jobject obj, jclass clazz, |
| jmethodID methodID, const jvalue * args) { |
| return functions->CallNonvirtualLongMethodA(this,obj,clazz, |
| methodID,args); |
| } |
| |
| jfloat CallNonvirtualFloatMethod(jobject obj, jclass clazz, |
| jmethodID methodID, ...) { |
| va_list args; |
| jfloat result; |
| va_start(args,methodID); |
| result = functions->CallNonvirtualFloatMethodV(this,obj,clazz, |
| methodID,args); |
| va_end(args); |
| return result; |
| } |
| jfloat CallNonvirtualFloatMethodV(jobject obj, jclass clazz, |
| jmethodID methodID, |
| va_list args) { |
| return functions->CallNonvirtualFloatMethodV(this,obj,clazz, |
| methodID,args); |
| } |
| jfloat CallNonvirtualFloatMethodA(jobject obj, jclass clazz, |
| jmethodID methodID, |
| const jvalue * args) { |
| return functions->CallNonvirtualFloatMethodA(this,obj,clazz, |
| methodID,args); |
| } |
| |
| jdouble CallNonvirtualDoubleMethod(jobject obj, jclass clazz, |
| jmethodID methodID, ...) { |
| va_list args; |
| jdouble result; |
| va_start(args,methodID); |
| result = functions->CallNonvirtualDoubleMethodV(this,obj,clazz, |
| methodID,args); |
| va_end(args); |
| return result; |
| } |
| jdouble CallNonvirtualDoubleMethodV(jobject obj, jclass clazz, |
| jmethodID methodID, |
| va_list args) { |
| return functions->CallNonvirtualDoubleMethodV(this,obj,clazz, |
| methodID,args); |
| } |
| jdouble CallNonvirtualDoubleMethodA(jobject obj, jclass clazz, |
| jmethodID methodID, |
| const jvalue * args) { |
| return functions->CallNonvirtualDoubleMethodA(this,obj,clazz, |
| methodID,args); |
| } |
| |
| void CallNonvirtualVoidMethod(jobject obj, jclass clazz, |
| jmethodID methodID, ...) { |
| va_list args; |
| va_start(args,methodID); |
| functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args); |
| va_end(args); |
| } |
| void CallNonvirtualVoidMethodV(jobject obj, jclass clazz, |
| jmethodID methodID, |
| va_list args) { |
| functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args); |
| } |
| void CallNonvirtualVoidMethodA(jobject obj, jclass clazz, |
| jmethodID methodID, |
| const jvalue * args) { |
| functions->CallNonvirtualVoidMethodA(this,obj,clazz,methodID,args); |
| } |
| |
| jfieldID GetFieldID(jclass clazz, const char *name, |
| const char *sig) { |
| return functions->GetFieldID(this,clazz,name,sig); |
| } |
| |
| jobject GetObjectField(jobject obj, jfieldID fieldID) { |
| return functions->GetObjectField(this,obj,fieldID); |
| } |
| jboolean GetBooleanField(jobject obj, jfieldID fieldID) { |
| return functions->GetBooleanField(this,obj,fieldID); |
| } |
| jbyte GetByteField(jobject obj, jfieldID fieldID) { |
| return functions->GetByteField(this,obj,fieldID); |
| } |
| jchar GetCharField(jobject obj, jfieldID fieldID) { |
| return functions->GetCharField(this,obj,fieldID); |
| } |
| jshort GetShortField(jobject obj, jfieldID fieldID) { |
| return functions->GetShortField(this,obj,fieldID); |
| } |
| jint GetIntField(jobject obj, jfieldID fieldID) { |
| return functions->GetIntField(this,obj,fieldID); |
| } |
| jlong GetLongField(jobject obj, jfieldID fieldID) { |
| return functions->GetLongField(this,obj,fieldID); |
| } |
| jfloat GetFloatField(jobject obj, jfieldID fieldID) { |
| return functions->GetFloatField(this,obj,fieldID); |
| } |
| jdouble GetDoubleField(jobject obj, jfieldID fieldID) { |
| return functions->GetDoubleField(this,obj,fieldID); |
| } |
| |
| void SetObjectField(jobject obj, jfieldID fieldID, jobject val) { |
| functions->SetObjectField(this,obj,fieldID,val); |
| } |
| void SetBooleanField(jobject obj, jfieldID fieldID, |
| jboolean val) { |
| functions->SetBooleanField(this,obj,fieldID,val); |
| } |
| void SetByteField(jobject obj, jfieldID fieldID, |
| jbyte val) { |
| functions->SetByteField(this,obj,fieldID,val); |
| } |
| void SetCharField(jobject obj, jfieldID fieldID, |
| jchar val) { |
| functions->SetCharField(this,obj,fieldID,val); |
| } |
| void SetShortField(jobject obj, jfieldID fieldID, |
| jshort val) { |
| functions->SetShortField(this,obj,fieldID,val); |
| } |
| void SetIntField(jobject obj, jfieldID fieldID, |
| jint val) { |
| functions->SetIntField(this,obj,fieldID,val); |
| } |
| void SetLongField(jobject obj, jfieldID fieldID, |
| jlong val) { |
| functions->SetLongField(this,obj,fieldID,val); |
| } |
| void SetFloatField(jobject obj, jfieldID fieldID, |
| jfloat val) { |
| functions->SetFloatField(this,obj,fieldID,val); |
| } |
| void SetDoubleField(jobject obj, jfieldID fieldID, |
| jdouble val) { |
| functions->SetDoubleField(this,obj,fieldID,val); |
| } |
| |
| jmethodID GetStaticMethodID(jclass clazz, const char *name, |
| const char *sig) { |
| return functions->GetStaticMethodID(this,clazz,name,sig); |
| } |
| |
| jobject CallStaticObjectMethod(jclass clazz, jmethodID methodID, |
| ...) { |
| va_list args; |
| jobject result; |
| va_start(args,methodID); |
| result = functions->CallStaticObjectMethodV(this,clazz,methodID,args); |
| va_end(args); |
| return result; |
| } |
| jobject CallStaticObjectMethodV(jclass clazz, jmethodID methodID, |
| va_list args) { |
| return functions->CallStaticObjectMethodV(this,clazz,methodID,args); |
| } |
| jobject CallStaticObjectMethodA(jclass clazz, jmethodID methodID, |
| const jvalue *args) { |
| return functions->CallStaticObjectMethodA(this,clazz,methodID,args); |
| } |
| |
| jboolean CallStaticBooleanMethod(jclass clazz, |
| jmethodID methodID, ...) { |
| va_list args; |
| jboolean result; |
| va_start(args,methodID); |
| result = functions->CallStaticBooleanMethodV(this,clazz,methodID,args); |
| va_end(args); |
| return result; |
| } |
| jboolean CallStaticBooleanMethodV(jclass clazz, |
| jmethodID methodID, va_list args) { |
| return functions->CallStaticBooleanMethodV(this,clazz,methodID,args); |
| } |
| jboolean CallStaticBooleanMethodA(jclass clazz, |
| jmethodID methodID, const jvalue *args) { |
| return functions->CallStaticBooleanMethodA(this,clazz,methodID,args); |
| } |
| |
| jbyte CallStaticByteMethod(jclass clazz, |
| jmethodID methodID, ...) { |
| va_list args; |
| jbyte result; |
| va_start(args,methodID); |
| result = functions->CallStaticByteMethodV(this,clazz,methodID,args); |
| va_end(args); |
| return result; |
| } |
| jbyte CallStaticByteMethodV(jclass clazz, |
| jmethodID methodID, va_list args) { |
| return functions->CallStaticByteMethodV(this,clazz,methodID,args); |
| } |
| jbyte CallStaticByteMethodA(jclass clazz, |
| jmethodID methodID, const jvalue *args) { |
| return functions->CallStaticByteMethodA(this,clazz,methodID,args); |
| } |
| |
| jchar CallStaticCharMethod(jclass clazz, |
| jmethodID methodID, ...) { |
| va_list args; |
| jchar result; |
| va_start(args,methodID); |
| result = functions->CallStaticCharMethodV(this,clazz,methodID,args); |
| va_end(args); |
| return result; |
| } |
| jchar CallStaticCharMethodV(jclass clazz, |
| jmethodID methodID, va_list args) { |
| return functions->CallStaticCharMethodV(this,clazz,methodID,args); |
| } |
| jchar CallStaticCharMethodA(jclass clazz, |
| jmethodID methodID, const jvalue *args) { |
| return functions->CallStaticCharMethodA(this,clazz,methodID,args); |
| } |
| |
| jshort CallStaticShortMethod(jclass clazz, |
| jmethodID methodID, ...) { |
| va_list args; |
| jshort result; |
| va_start(args,methodID); |
| result = functions->CallStaticShortMethodV(this,clazz,methodID,args); |
| va_end(args); |
| return result; |
| } |
| jshort CallStaticShortMethodV(jclass clazz, |
| jmethodID methodID, va_list args) { |
| return functions->CallStaticShortMethodV(this,clazz,methodID,args); |
| } |
| jshort CallStaticShortMethodA(jclass clazz, |
| jmethodID methodID, const jvalue *args) { |
| return functions->CallStaticShortMethodA(this,clazz,methodID,args); |
| } |
| |
| jint CallStaticIntMethod(jclass clazz, |
| jmethodID methodID, ...) { |
| va_list args; |
| jint result; |
| va_start(args,methodID); |
| result = functions->CallStaticIntMethodV(this,clazz,methodID,args); |
| va_end(args); |
| return result; |
| } |
| jint CallStaticIntMethodV(jclass clazz, |
| jmethodID methodID, va_list args) { |
| return functions->CallStaticIntMethodV(this,clazz,methodID,args); |
| } |
| jint CallStaticIntMethodA(jclass clazz, |
| jmethodID methodID, const jvalue *args) { |
| return functions->CallStaticIntMethodA(this,clazz,methodID,args); |
| } |
| |
| jlong CallStaticLongMethod(jclass clazz, |
| jmethodID methodID, ...) { |
| va_list args; |
| jlong result; |
| va_start(args,methodID); |
| result = functions->CallStaticLongMethodV(this,clazz,methodID,args); |
| va_end(args); |
| return result; |
| } |
| jlong CallStaticLongMethodV(jclass clazz, |
| jmethodID methodID, va_list args) { |
| return functions->CallStaticLongMethodV(this,clazz,methodID,args); |
| } |
| jlong CallStaticLongMethodA(jclass clazz, |
| jmethodID methodID, const jvalue *args) { |
| return functions->CallStaticLongMethodA(this,clazz,methodID,args); |
| } |
| |
| jfloat CallStaticFloatMethod(jclass clazz, |
| jmethodID methodID, ...) { |
| va_list args; |
| jfloat result; |
| va_start(args,methodID); |
| result = functions->CallStaticFloatMethodV(this,clazz,methodID,args); |
| va_end(args); |
| return result; |
| } |
| jfloat CallStaticFloatMethodV(jclass clazz, |
| jmethodID methodID, va_list args) { |
| return functions->CallStaticFloatMethodV(this,clazz,methodID,args); |
| } |
| jfloat CallStaticFloatMethodA(jclass clazz, |
| jmethodID methodID, const jvalue *args) { |
| return functions->CallStaticFloatMethodA(this,clazz,methodID,args); |
| } |
| |
| jdouble CallStaticDoubleMethod(jclass clazz, |
| jmethodID methodID, ...) { |
| va_list args; |
| jdouble result; |
| va_start(args,methodID); |
| result = functions->CallStaticDoubleMethodV(this,clazz,methodID,args); |
| va_end(args); |
| return result; |
| } |
| jdouble CallStaticDoubleMethodV(jclass clazz, |
| jmethodID methodID, va_list args) { |
| return functions->CallStaticDoubleMethodV(this,clazz,methodID,args); |
| } |
| jdouble CallStaticDoubleMethodA(jclass clazz, |
| jmethodID methodID, const jvalue *args) { |
| return functions->CallStaticDoubleMethodA(this,clazz,methodID,args); |
| } |
| |
| void CallStaticVoidMethod(jclass cls, jmethodID methodID, ...) { |
| va_list args; |
| va_start(args,methodID); |
| functions->CallStaticVoidMethodV(this,cls,methodID,args); |
| va_end(args); |
| } |
| void CallStaticVoidMethodV(jclass cls, jmethodID methodID, |
| va_list args) { |
| functions->CallStaticVoidMethodV(this,cls,methodID,args); |
| } |
| void CallStaticVoidMethodA(jclass cls, jmethodID methodID, |
| const jvalue * args) { |
| functions->CallStaticVoidMethodA(this,cls,methodID,args); |
| } |
| |
| jfieldID GetStaticFieldID(jclass clazz, const char *name, |
| const char *sig) { |
| return functions->GetStaticFieldID(this,clazz,name,sig); |
| } |
| jobject GetStaticObjectField(jclass clazz, jfieldID fieldID) { |
| return functions->GetStaticObjectField(this,clazz,fieldID); |
| } |
| jboolean GetStaticBooleanField(jclass clazz, jfieldID fieldID) { |
| return functions->GetStaticBooleanField(this,clazz,fieldID); |
| } |
| jbyte GetStaticByteField(jclass clazz, jfieldID fieldID) { |
| return functions->GetStaticByteField(this,clazz,fieldID); |
| } |
| jchar GetStaticCharField(jclass clazz, jfieldID fieldID) { |
| return functions->GetStaticCharField(this,clazz,fieldID); |
| } |
| jshort GetStaticShortField(jclass clazz, jfieldID fieldID) { |
| return functions->GetStaticShortField(this,clazz,fieldID); |
| } |
| jint GetStaticIntField(jclass clazz, jfieldID fieldID) { |
| return functions->GetStaticIntField(this,clazz,fieldID); |
| } |
| jlong GetStaticLongField(jclass clazz, jfieldID fieldID) { |
| return functions->GetStaticLongField(this,clazz,fieldID); |
| } |
| jfloat GetStaticFloatField(jclass clazz, jfieldID fieldID) { |
| return functions->GetStaticFloatField(this,clazz,fieldID); |
| } |
| jdouble GetStaticDoubleField(jclass clazz, jfieldID fieldID) { |
| return functions->GetStaticDoubleField(this,clazz,fieldID); |
| } |
| |
| void SetStaticObjectField(jclass clazz, jfieldID fieldID, |
| jobject value) { |
| functions->SetStaticObjectField(this,clazz,fieldID,value); |
| } |
| void SetStaticBooleanField(jclass clazz, jfieldID fieldID, |
| jboolean value) { |
| functions->SetStaticBooleanField(this,clazz,fieldID,value); |
| } |
| void SetStaticByteField(jclass clazz, jfieldID fieldID, |
| jbyte value) { |
| functions->SetStaticByteField(this,clazz,fieldID,value); |
| } |
| void SetStaticCharField(jclass clazz, jfieldID fieldID, |
| jchar value) { |
| functions->SetStaticCharField(this,clazz,fieldID,value); |
| } |
| void SetStaticShortField(jclass clazz, jfieldID fieldID, |
| jshort value) { |
| functions->SetStaticShortField(this,clazz,fieldID,value); |
| } |
| void SetStaticIntField(jclass clazz, jfieldID fieldID, |
| jint value) { |
| functions->SetStaticIntField(this,clazz,fieldID,value); |
| } |
| void SetStaticLongField(jclass clazz, jfieldID fieldID, |
| jlong value) { |
| functions->SetStaticLongField(this,clazz,fieldID,value); |
| } |
| void SetStaticFloatField(jclass clazz, jfieldID fieldID, |
| jfloat value) { |
| functions->SetStaticFloatField(this,clazz,fieldID,value); |
| } |
| void SetStaticDoubleField(jclass clazz, jfieldID fieldID, |
| jdouble value) { |
| functions->SetStaticDoubleField(this,clazz,fieldID,value); |
| } |
| |
| jstring NewString(const jchar *unicode, jsize len) { |
| return functions->NewString(this,unicode,len); |
| } |
| jsize GetStringLength(jstring str) { |
| return functions->GetStringLength(this,str); |
| } |
| const jchar *GetStringChars(jstring str, jboolean *isCopy) { |
| return functions->GetStringChars(this,str,isCopy); |
| } |
| void ReleaseStringChars(jstring str, const jchar *chars) { |
| functions->ReleaseStringChars(this,str,chars); |
| } |
| |
| jstring NewStringUTF(const char *utf) { |
| return functions->NewStringUTF(this,utf); |
| } |
| jsize GetStringUTFLength(jstring str) { |
| return functions->GetStringUTFLength(this,str); |
| } |
| const char* GetStringUTFChars(jstring str, jboolean *isCopy) { |
| return functions->GetStringUTFChars(this,str,isCopy); |
| } |
| void ReleaseStringUTFChars(jstring str, const char* chars) { |
| functions->ReleaseStringUTFChars(this,str,chars); |
| } |
| |
| jsize GetArrayLength(jarray array) { |
| return functions->GetArrayLength(this,array); |
| } |
| |
| jobjectArray NewObjectArray(jsize len, jclass clazz, |
| jobject init) { |
| return functions->NewObjectArray(this,len,clazz,init); |
| } |
| jobject GetObjectArrayElement(jobjectArray array, jsize index) { |
| return functions->GetObjectArrayElement(this,array,index); |
| } |
| void SetObjectArrayElement(jobjectArray array, jsize index, |
| jobject val) { |
| functions->SetObjectArrayElement(this,array,index,val); |
| } |
| |
| jbooleanArray NewBooleanArray(jsize len) { |
| return functions->NewBooleanArray(this,len); |
| } |
| jbyteArray NewByteArray(jsize len) { |
| return functions->NewByteArray(this,len); |
| } |
| jcharArray NewCharArray(jsize len) { |
| return functions->NewCharArray(this,len); |
| } |
| jshortArray NewShortArray(jsize len) { |
| return functions->NewShortArray(this,len); |
| } |
| jintArray NewIntArray(jsize len) { |
| return functions->NewIntArray(this,len); |
| } |
| jlongArray NewLongArray(jsize len) { |
| return functions->NewLongArray(this,len); |
| } |
| jfloatArray NewFloatArray(jsize len) { |
| return functions->NewFloatArray(this,len); |
| } |
| jdoubleArray NewDoubleArray(jsize len) { |
| return functions->NewDoubleArray(this,len); |
| } |
| |
| jboolean * GetBooleanArrayElements(jbooleanArray array, jboolean *isCopy) { |
| return functions->GetBooleanArrayElements(this,array,isCopy); |
| } |
| jbyte * GetByteArrayElements(jbyteArray array, jboolean *isCopy) { |
| return functions->GetByteArrayElements(this,array,isCopy); |
| } |
| jchar * GetCharArrayElements(jcharArray array, jboolean *isCopy) { |
| return functions->GetCharArrayElements(this,array,isCopy); |
| } |
| jshort * GetShortArrayElements(jshortArray array, jboolean *isCopy) { |
| return functions->GetShortArrayElements(this,array,isCopy); |
| } |
| jint * GetIntArrayElements(jintArray array, jboolean *isCopy) { |
| return functions->GetIntArrayElements(this,array,isCopy); |
| } |
| jlong * GetLongArrayElements(jlongArray array, jboolean *isCopy) { |
| return functions->GetLongArrayElements(this,array,isCopy); |
| } |
| jfloat * GetFloatArrayElements(jfloatArray array, jboolean *isCopy) { |
| return functions->GetFloatArrayElements(this,array,isCopy); |
| } |
| jdouble * GetDoubleArrayElements(jdoubleArray array, jboolean *isCopy) { |
| return functions->GetDoubleArrayElements(this,array,isCopy); |
| } |
| |
| void ReleaseBooleanArrayElements(jbooleanArray array, |
| jboolean *elems, |
| jint mode) { |
| functions->ReleaseBooleanArrayElements(this,array,elems,mode); |
| } |
| void ReleaseByteArrayElements(jbyteArray array, |
| jbyte *elems, |
| jint mode) { |
| functions->ReleaseByteArrayElements(this,array,elems,mode); |
| } |
| void ReleaseCharArrayElements(jcharArray array, |
| jchar *elems, |
| jint mode) { |
| functions->ReleaseCharArrayElements(this,array,elems,mode); |
| } |
| void ReleaseShortArrayElements(jshortArray array, |
| jshort *elems, |
| jint mode) { |
| functions->ReleaseShortArrayElements(this,array,elems,mode); |
| } |
| void ReleaseIntArrayElements(jintArray array, |
| jint *elems, |
| jint mode) { |
| functions->ReleaseIntArrayElements(this,array,elems,mode); |
| } |
| void ReleaseLongArrayElements(jlongArray array, |
| jlong *elems, |
| jint mode) { |
| functions->ReleaseLongArrayElements(this,array,elems,mode); |
| } |
| void ReleaseFloatArrayElements(jfloatArray array, |
| jfloat *elems, |
| jint mode) { |
| functions->ReleaseFloatArrayElements(this,array,elems,mode); |
| } |
| void ReleaseDoubleArrayElements(jdoubleArray array, |
| jdouble *elems, |
| jint mode) { |
| functions->ReleaseDoubleArrayElements(this,array,elems,mode); |
| } |
| |
| void GetBooleanArrayRegion(jbooleanArray array, |
| jsize start, jsize len, jboolean *buf) { |
| functions->GetBooleanArrayRegion(this,array,start,len,buf); |
| } |
| void GetByteArrayRegion(jbyteArray array, |
| jsize start, jsize len, jbyte *buf) { |
| functions->GetByteArrayRegion(this,array,start,len,buf); |
| } |
| void GetCharArrayRegion(jcharArray array, |
| jsize start, jsize len, jchar *buf) { |
| functions->GetCharArrayRegion(this,array,start,len,buf); |
| } |
| void GetShortArrayRegion(jshortArray array, |
| jsize start, jsize len, jshort *buf) { |
| functions->GetShortArrayRegion(this,array,start,len,buf); |
| } |
| void GetIntArrayRegion(jintArray array, |
| jsize start, jsize len, jint *buf) { |
| functions->GetIntArrayRegion(this,array,start,len,buf); |
| } |
| void GetLongArrayRegion(jlongArray array, |
| jsize start, jsize len, jlong *buf) { |
| functions->GetLongArrayRegion(this,array,start,len,buf); |
| } |
| void GetFloatArrayRegion(jfloatArray array, |
| jsize start, jsize len, jfloat *buf) { |
| functions->GetFloatArrayRegion(this,array,start,len,buf); |
| } |
| void GetDoubleArrayRegion(jdoubleArray array, |
| jsize start, jsize len, jdouble *buf) { |
| functions->GetDoubleArrayRegion(this,array,start,len,buf); |
| } |
| |
| void SetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len, |
| const jboolean *buf) { |
| functions->SetBooleanArrayRegion(this,array,start,len,buf); |
| } |
| void SetByteArrayRegion(jbyteArray array, jsize start, jsize len, |
| const jbyte *buf) { |
| functions->SetByteArrayRegion(this,array,start,len,buf); |
| } |
| void SetCharArrayRegion(jcharArray array, jsize start, jsize len, |
| const jchar *buf) { |
| functions->SetCharArrayRegion(this,array,start,len,buf); |
| } |
| void SetShortArrayRegion(jshortArray array, jsize start, jsize len, |
| const jshort *buf) { |
| functions->SetShortArrayRegion(this,array,start,len,buf); |
| } |
| void SetIntArrayRegion(jintArray array, jsize start, jsize len, |
| const jint *buf) { |
| functions->SetIntArrayRegion(this,array,start,len,buf); |
| } |
| void SetLongArrayRegion(jlongArray array, jsize start, jsize len, |
| const jlong *buf) { |
| functions->SetLongArrayRegion(this,array,start,len,buf); |
| } |
| void SetFloatArrayRegion(jfloatArray array, jsize start, jsize len, |
| const jfloat *buf) { |
| functions->SetFloatArrayRegion(this,array,start,len,buf); |
| } |
| void SetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len, |
| const jdouble *buf) { |
| functions->SetDoubleArrayRegion(this,array,start,len,buf); |
| } |
| |
| jint RegisterNatives(jclass clazz, const JNINativeMethod *methods, |
| jint nMethods) { |
| return functions->RegisterNatives(this,clazz,methods,nMethods); |
| } |
| jint UnregisterNatives(jclass clazz) { |
| return functions->UnregisterNatives(this,clazz); |
| } |
| |
| jint MonitorEnter(jobject obj) { |
| return functions->MonitorEnter(this,obj); |
| } |
| jint MonitorExit(jobject obj) { |
| return functions->MonitorExit(this,obj); |
| } |
| |
| jint GetJavaVM(JavaVM **vm) { |
| return functions->GetJavaVM(this,vm); |
| } |
| |
| void GetStringRegion(jstring str, jsize start, jsize len, jchar *buf) { |
| functions->GetStringRegion(this,str,start,len,buf); |
| } |
| void GetStringUTFRegion(jstring str, jsize start, jsize len, char *buf) { |
| functions->GetStringUTFRegion(this,str,start,len,buf); |
| } |
| |
| void * GetPrimitiveArrayCritical(jarray array, jboolean *isCopy) { |
| return functions->GetPrimitiveArrayCritical(this,array,isCopy); |
| } |
| void ReleasePrimitiveArrayCritical(jarray array, void *carray, jint mode) { |
| functions->ReleasePrimitiveArrayCritical(this,array,carray,mode); |
| } |
| |
| const jchar * GetStringCritical(jstring string, jboolean *isCopy) { |
| return functions->GetStringCritical(this,string,isCopy); |
| } |
| void ReleaseStringCritical(jstring string, const jchar *cstring) { |
| functions->ReleaseStringCritical(this,string,cstring); |
| } |
| |
| jweak NewWeakGlobalRef(jobject obj) { |
| return functions->NewWeakGlobalRef(this,obj); |
| } |
| void DeleteWeakGlobalRef(jweak ref) { |
| functions->DeleteWeakGlobalRef(this,ref); |
| } |
| |
| jboolean ExceptionCheck() { |
| return functions->ExceptionCheck(this); |
| } |
| |
| jobject NewDirectByteBuffer(void* address, jlong capacity) { |
| return functions->NewDirectByteBuffer(this, address, capacity); |
| } |
| void* GetDirectBufferAddress(jobject buf) { |
| return functions->GetDirectBufferAddress(this, buf); |
| } |
| jlong GetDirectBufferCapacity(jobject buf) { |
| return functions->GetDirectBufferCapacity(this, buf); |
| } |
| jobjectRefType GetObjectRefType(jobject obj) { |
| return functions->GetObjectRefType(this, obj); |
| } |
| |
| #endif /* __cplusplus */ |
| }; |
| |
| typedef struct JavaVMOption { |
| char *optionString; |
| void *extraInfo; |
| } JavaVMOption; |
| |
| typedef struct JavaVMInitArgs { |
| jint version; |
| |
| jint nOptions; |
| JavaVMOption *options; |
| jboolean ignoreUnrecognized; |
| } JavaVMInitArgs; |
| |
| typedef struct JavaVMAttachArgs { |
| jint version; |
| |
| char *name; |
| jobject group; |
| } JavaVMAttachArgs; |
| |
| /* These will be VM-specific. */ |
| |
| #define JDK1_2 |
| #define JDK1_4 |
| |
| /* End VM-specific. */ |
| |
| struct JNIInvokeInterface_ { |
| void *reserved0; |
| void *reserved1; |
| void *reserved2; |
| |
| jint (JNICALL *DestroyJavaVM)(JavaVM *vm); |
| |
| jint (JNICALL *AttachCurrentThread)(JavaVM *vm, void **penv, void *args); |
| |
| jint (JNICALL *DetachCurrentThread)(JavaVM *vm); |
| |
| jint (JNICALL *GetEnv)(JavaVM *vm, void **penv, jint version); |
| |
| jint (JNICALL *AttachCurrentThreadAsDaemon)(JavaVM *vm, void **penv, void *args); |
| }; |
| |
| struct JavaVM_ { |
| const struct JNIInvokeInterface_ *functions; |
| #ifdef __cplusplus |
| |
| jint DestroyJavaVM() { |
| return functions->DestroyJavaVM(this); |
| } |
| jint AttachCurrentThread(void **penv, void *args) { |
| return functions->AttachCurrentThread(this, penv, args); |
| } |
| jint DetachCurrentThread() { |
| return functions->DetachCurrentThread(this); |
| } |
| |
| jint GetEnv(void **penv, jint version) { |
| return functions->GetEnv(this, penv, version); |
| } |
| jint AttachCurrentThreadAsDaemon(void **penv, void *args) { |
| return functions->AttachCurrentThreadAsDaemon(this, penv, args); |
| } |
| #endif |
| }; |
| |
| #ifdef _JNI_IMPLEMENTATION_ |
| #define _JNI_IMPORT_OR_EXPORT_ JNIEXPORT |
| #else |
| #define _JNI_IMPORT_OR_EXPORT_ JNIIMPORT |
| #endif |
| _JNI_IMPORT_OR_EXPORT_ jint JNICALL |
| JNI_GetDefaultJavaVMInitArgs(void *args); |
| |
| _JNI_IMPORT_OR_EXPORT_ jint JNICALL |
| JNI_CreateJavaVM(JavaVM **pvm, void **penv, void *args); |
| |
| _JNI_IMPORT_OR_EXPORT_ jint JNICALL |
| JNI_GetCreatedJavaVMs(JavaVM **, jsize, jsize *); |
| |
| /* Defined by native libraries. */ |
| JNIEXPORT jint JNICALL |
| JNI_OnLoad(JavaVM *vm, void *reserved); |
| |
| JNIEXPORT void JNICALL |
| JNI_OnUnload(JavaVM *vm, void *reserved); |
| |
| #define JNI_VERSION_1_1 0x00010001 |
| #define JNI_VERSION_1_2 0x00010002 |
| #define JNI_VERSION_1_4 0x00010004 |
| #define JNI_VERSION_1_6 0x00010006 |
| #define JNI_VERSION_1_8 0x00010008 |
| |
| #ifdef __cplusplus |
| } /* extern "C" */ |
| #endif /* __cplusplus */ |
| |
| #endif /* !_JAVASOFT_JNI_H_ */ |
