| /* jni.h |
| Copyright (C) 1998, 1999, 2000, 2001, 2002, 2004, 2005, 2006, 2007, 2008 Free Software Foundation |
| |
| This file is part of GNU Classpath. |
| |
| GNU Classpath is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2, or (at your option) |
| any later version. |
| |
| GNU Classpath 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 for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GNU Classpath; see the file COPYING. If not, write to the |
| Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
| 02110-1301 USA. |
| |
| Linking this library statically or dynamically with other modules is |
| making a combined work based on this library. Thus, the terms and |
| conditions of the GNU General Public License cover the whole |
| combination. |
| |
| As a special exception, the copyright holders of this library give you |
| permission to link this library with independent modules to produce an |
| executable, regardless of the license terms of these independent |
| modules, and to copy and distribute the resulting executable under |
| terms of your choice, provided that you also meet, for each linked |
| independent module, the terms and conditions of the license of that |
| module. An independent module is a module which is not derived from |
| or based on this library. If you modify this library, you may extend |
| this exception to your version of the library, but you are not |
| obligated to do so. If you do not wish to do so, delete this |
| exception statement from your version. */ |
| |
| |
| /* Note: this file must be compilable by the C compiler (for now, |
| assuming GNU C is ok). This means you must never use `//' |
| comments, and all C++-specific code must be conditional on |
| __cplusplus. */ |
| |
| #ifndef _CLASSPATH_JNI_H |
| #define _CLASSPATH_JNI_H |
| |
| /* We include <stdio.h> for compatibility with Sun's <jni.h>. */ |
| #include <stdio.h> |
| |
| #include <stdarg.h> |
| |
| #include "jni_md.h" |
| |
| /* The VM might define jobject and friends. */ |
| #ifndef _CLASSPATH_VM_JNI_TYPES_DEFINED |
| |
| # ifdef __cplusplus |
| |
| /* Define dummy classes and then define the JNI types as pointers. */ |
| struct __jobject {}; |
| struct __jclass : __jobject {}; |
| struct __jstring : __jobject {}; |
| struct __jthrowable : __jobject {}; |
| struct __jweak : __jobject {}; |
| struct __jarray : __jobject {}; |
| struct __jobjectArray : __jarray {}; |
| struct __jbyteArray : __jarray {}; |
| struct __jshortArray : __jarray {}; |
| struct __jintArray : __jarray {}; |
| struct __jlongArray : __jarray {}; |
| struct __jbooleanArray : __jarray {}; |
| struct __jcharArray : __jarray {}; |
| struct __jfloatArray : __jarray {}; |
| struct __jdoubleArray : __jarray {}; |
| |
| typedef __jobject *jobject; |
| typedef __jclass *jclass; |
| typedef __jstring *jstring; |
| typedef __jthrowable *jthrowable; |
| typedef __jweak *jweak; |
| typedef __jarray *jarray; |
| typedef __jobjectArray *jobjectArray; |
| typedef __jbyteArray *jbyteArray; |
| typedef __jshortArray *jshortArray; |
| typedef __jintArray *jintArray; |
| typedef __jlongArray *jlongArray; |
| typedef __jbooleanArray *jbooleanArray; |
| typedef __jcharArray *jcharArray; |
| typedef __jfloatArray *jfloatArray; |
| typedef __jdoubleArray *jdoubleArray; |
| |
| #define JNI_TRUE true |
| #define JNI_FALSE false |
| |
| typedef struct _Jv_JNIEnv JNIEnv; |
| typedef struct _Jv_JavaVM JavaVM; |
| |
| # else /* __cplusplus */ |
| |
| /* For C, simply define the class types as generic pointers. */ |
| typedef void *jobject; |
| typedef jobject jclass; |
| typedef jobject jstring; |
| typedef jobject jthrowable; |
| typedef jobject jweak; |
| typedef jobject jarray; |
| typedef jobject jobjectArray; |
| typedef jobject jbyteArray; |
| typedef jobject jshortArray; |
| typedef jobject jintArray; |
| typedef jobject jlongArray; |
| typedef jobject jbooleanArray; |
| typedef jobject jcharArray; |
| typedef jobject jfloatArray; |
| typedef jobject jdoubleArray; |
| |
| #define JNI_TRUE 1 |
| #define JNI_FALSE 0 |
| |
| typedef const struct JNINativeInterface_ *JNIEnv; |
| typedef const struct JNIInvokeInterface_ *JavaVM; |
| |
| # endif /* __cplusplus */ |
| |
| #endif /* _CLASSPATH_VM_JNI_TYPES_DEFINED */ |
| |
| /* |
| * Before jni.h is #included within a typical JVM, the source code should |
| * #define _JNI_VM_INTERNAL_TYPES_DEFINED and provide the real declarations |
| * for 'jobject', 'jfieldID', 'jmethodID' and other implementation types. |
| * If _JNI_VM_INTERNAL_TYPES_DEFINED is not defined, the following |
| * declares the old versions of the types. |
| */ |
| #ifndef _CLASSPATH_VM_INTERNAL_TYPES_DEFINED |
| struct _jfieldID; |
| struct _jmethodID; |
| typedef struct _jfieldID *jfieldID; |
| typedef struct _jmethodID *jmethodID; |
| #endif |
| |
| /* Version numbers. */ |
| #define JNI_VERSION_1_1 0x00010001 |
| #define JNI_VERSION_1_2 0x00010002 |
| #define JNI_VERSION_1_4 0x00010004 |
| #define JNI_VERSION_1_6 0x00010006 |
| |
| /* Used when releasing array elements. */ |
| #define JNI_COMMIT 1 |
| #define JNI_ABORT 2 |
| |
| /* Error codes */ |
| #define JNI_OK 0 |
| #define JNI_ERR (-1) |
| #define JNI_EDETACHED (-2) |
| #define JNI_EVERSION (-3) |
| |
| enum _jobjectRefType |
| { |
| JNIInvalidRefType = 0, |
| JNILocalRefType = 1, |
| JNIGlobalRefType = 2, |
| JNIWeakGlobalRefType = 3 |
| }; |
| |
| typedef enum _jobjectRefType jobjectRefType; |
| |
| #ifdef __cplusplus |
| extern "C" |
| { |
| #endif /* __cplusplus */ |
| |
| /* These functions might be defined in libraries which we load; the |
| JNI implementation calls them at the appropriate times. */ |
| extern JNIEXPORT jint JNICALL JNI_OnLoad (JavaVM *, void *); |
| extern JNIEXPORT void JNICALL JNI_OnUnload (JavaVM *, void *); |
| |
| /* This can be defined as JNIIMPORT or JNIEXPORT by the md file, |
| depending on whether this is the implementation or a user. */ |
| #ifndef _CLASSPATH_JNIIMPEXP |
| #define _CLASSPATH_JNIIMPEXP JNIIMPORT |
| #endif |
| |
| /* These functions are called by user code to start using the |
| invocation API. */ |
| extern _CLASSPATH_JNIIMPEXP jint JNICALL |
| JNI_GetDefaultJavaVMInitArgs (void *); |
| |
| extern _CLASSPATH_JNIIMPEXP jint JNICALL |
| JNI_CreateJavaVM (JavaVM **, void **, void *); |
| |
| extern _CLASSPATH_JNIIMPEXP jint JNICALL |
| JNI_GetCreatedJavaVMs (JavaVM **, jsize, jsize *); |
| |
| #ifdef __cplusplus |
| } |
| #endif /* __cplusplus */ |
| |
| typedef union jvalue |
| { |
| jboolean z; |
| jbyte b; |
| jchar c; |
| jshort s; |
| jint i; |
| jlong j; |
| jfloat f; |
| jdouble d; |
| jobject l; |
| } jvalue; |
| |
| /* This structure is used when registering native methods. */ |
| typedef struct |
| { |
| char *name; |
| char *signature; |
| void *fnPtr; /* Sigh. */ |
| } JNINativeMethod; |
| |
| struct JNINativeInterface_ |
| { |
| void *reserved0; |
| void *reserved1; |
| void *reserved2; |
| void *reserved3; |
| |
| jint (JNICALL *GetVersion) (JNIEnv *); |
| jclass (JNICALL *DefineClass) (JNIEnv *, const char *, |
| jobject, const jbyte *, |
| jsize); |
| jclass (JNICALL *FindClass) (JNIEnv *, const char *); |
| |
| jmethodID (JNICALL *FromReflectedMethod) (JNIEnv *, jobject); |
| jfieldID (JNICALL *FromReflectedField) (JNIEnv *, jobject); |
| jobject (JNICALL *ToReflectedMethod) (JNIEnv *, jclass, |
| jmethodID, jboolean); |
| |
| jclass (JNICALL *GetSuperclass) (JNIEnv *, jclass); |
| jboolean (JNICALL *IsAssignableFrom) (JNIEnv *, jclass, jclass); |
| |
| jobject (JNICALL *ToReflectedField) (JNIEnv *, jclass, jfieldID, |
| jboolean); |
| |
| jint (JNICALL *Throw) (JNIEnv *, jthrowable); |
| jint (JNICALL *ThrowNew) (JNIEnv *, jclass, |
| const char *); |
| jthrowable (JNICALL *ExceptionOccurred) (JNIEnv *); |
| void (JNICALL *ExceptionDescribe) (JNIEnv *); |
| void (JNICALL *ExceptionClear) (JNIEnv *); |
| void (JNICALL *FatalError) (JNIEnv *, const char *); |
| |
| jint (JNICALL *PushLocalFrame) (JNIEnv *, jint); |
| jobject (JNICALL *PopLocalFrame) (JNIEnv *, jobject); |
| |
| jobject (JNICALL *NewGlobalRef) (JNIEnv *, jobject); |
| void (JNICALL *DeleteGlobalRef) (JNIEnv *, jobject); |
| void (JNICALL *DeleteLocalRef) (JNIEnv *, jobject); |
| jboolean (JNICALL *IsSameObject) (JNIEnv *, jobject, |
| jobject); |
| |
| jobject (JNICALL *NewLocalRef) (JNIEnv *, jobject); |
| jint (JNICALL *EnsureLocalCapacity) (JNIEnv *, jint); |
| |
| jobject (JNICALL *AllocObject) (JNIEnv *, jclass); |
| jobject (JNICALL *NewObject) (JNIEnv *, jclass, |
| jmethodID, ...); |
| jobject (JNICALL *NewObjectV) (JNIEnv *, jclass, |
| jmethodID, va_list); |
| jobject (JNICALL *NewObjectA) (JNIEnv *, jclass, |
| jmethodID, const jvalue *); |
| |
| jclass (JNICALL *GetObjectClass) (JNIEnv *, jobject); |
| jboolean (JNICALL *IsInstanceOf) (JNIEnv *, jobject, jclass); |
| jmethodID (JNICALL *GetMethodID) (JNIEnv *, jclass, |
| const char *, const char *); |
| |
| jobject (JNICALL *CallObjectMethod) (JNIEnv *, jobject, jmethodID, ...); |
| jobject (JNICALL *CallObjectMethodV) (JNIEnv *, jobject, jmethodID, |
| va_list); |
| jobject (JNICALL *CallObjectMethodA) (JNIEnv *, jobject, jmethodID, |
| const jvalue *); |
| jboolean (JNICALL *CallBooleanMethod) (JNIEnv *, jobject, jmethodID, |
| ...); |
| jboolean (JNICALL *CallBooleanMethodV) (JNIEnv *, jobject, jmethodID, |
| va_list); |
| jboolean (JNICALL *CallBooleanMethodA) (JNIEnv *, jobject, jmethodID, |
| const jvalue *); |
| jbyte (JNICALL *CallByteMethod) (JNIEnv *, jobject, jmethodID, ...); |
| jbyte (JNICALL *CallByteMethodV) (JNIEnv *, jobject, jmethodID, |
| va_list); |
| jbyte (JNICALL *CallByteMethodA) (JNIEnv *, jobject, jmethodID, |
| const jvalue *); |
| jchar (JNICALL *CallCharMethod) (JNIEnv *, jobject, jmethodID, ...); |
| jchar (JNICALL *CallCharMethodV) (JNIEnv *, jobject, jmethodID, |
| va_list); |
| jchar (JNICALL *CallCharMethodA) (JNIEnv *, jobject, jmethodID, |
| const jvalue *); |
| jshort (JNICALL *CallShortMethod) (JNIEnv *, jobject, jmethodID, ...); |
| jshort (JNICALL *CallShortMethodV) (JNIEnv *, jobject, jmethodID, |
| va_list); |
| jshort (JNICALL *CallShortMethodA) (JNIEnv *, jobject, jmethodID, |
| const jvalue *); |
| jint (JNICALL *CallIntMethod) (JNIEnv *, jobject, jmethodID, ...); |
| jint (JNICALL *CallIntMethodV) (JNIEnv *, jobject, jmethodID, |
| va_list); |
| jint (JNICALL *CallIntMethodA) (JNIEnv *, jobject, jmethodID, |
| const jvalue *); |
| jlong (JNICALL *CallLongMethod) (JNIEnv *, jobject, jmethodID, ...); |
| jlong (JNICALL *CallLongMethodV) (JNIEnv *, jobject, jmethodID, |
| va_list); |
| jlong (JNICALL *CallLongMethodA) (JNIEnv *, jobject, jmethodID, |
| const jvalue *); |
| jfloat (JNICALL *CallFloatMethod) (JNIEnv *, jobject, jmethodID, ...); |
| jfloat (JNICALL *CallFloatMethodV) (JNIEnv *, jobject, jmethodID, |
| va_list); |
| jfloat (JNICALL *CallFloatMethodA) (JNIEnv *, jobject, jmethodID, |
| const jvalue *); |
| jdouble (JNICALL *CallDoubleMethod) (JNIEnv *, jobject, jmethodID, ...); |
| jdouble (JNICALL *CallDoubleMethodV) (JNIEnv *, jobject, jmethodID, |
| va_list); |
| jdouble (JNICALL *CallDoubleMethodA) (JNIEnv *, jobject, jmethodID, |
| const jvalue *); |
| void (JNICALL *CallVoidMethod) (JNIEnv *, jobject, jmethodID, ...); |
| void (JNICALL *CallVoidMethodV) (JNIEnv *, jobject, jmethodID, |
| va_list); |
| void (JNICALL *CallVoidMethodA) (JNIEnv *, jobject, jmethodID, |
| const jvalue *); |
| |
| jobject (JNICALL *CallNonvirtualObjectMethod) (JNIEnv *, jobject, jclass, |
| jmethodID, ...); |
| jobject (JNICALL *CallNonvirtualObjectMethodV) (JNIEnv *, jobject, jclass, |
| jmethodID, va_list); |
| jobject (JNICALL *CallNonvirtualObjectMethodA) (JNIEnv *, jobject, jclass, |
| jmethodID, const jvalue *); |
| jboolean (JNICALL *CallNonvirtualBooleanMethod) (JNIEnv *, jobject, jclass, |
| jmethodID, ...); |
| jboolean (JNICALL *CallNonvirtualBooleanMethodV) (JNIEnv *, jobject, jclass, |
| jmethodID, va_list); |
| jboolean (JNICALL *CallNonvirtualBooleanMethodA) (JNIEnv *, jobject, jclass, |
| jmethodID, const jvalue *); |
| jbyte (JNICALL *CallNonvirtualByteMethod) (JNIEnv *, jobject, jclass, |
| jmethodID, ...); |
| jbyte (JNICALL *CallNonvirtualByteMethodV) (JNIEnv *, jobject, jclass, |
| jmethodID, va_list); |
| jbyte (JNICALL *CallNonvirtualByteMethodA) (JNIEnv *, jobject, jclass, |
| jmethodID, const jvalue *); |
| jchar (JNICALL *CallNonvirtualCharMethod) (JNIEnv *, jobject, jclass, |
| jmethodID, ...); |
| jchar (JNICALL *CallNonvirtualCharMethodV) (JNIEnv *, jobject, jclass, |
| jmethodID, va_list); |
| jchar (JNICALL *CallNonvirtualCharMethodA) (JNIEnv *, jobject, jclass, |
| jmethodID, const jvalue *); |
| jshort (JNICALL *CallNonvirtualShortMethod) (JNIEnv *, jobject, jclass, |
| jmethodID, ...); |
| jshort (JNICALL *CallNonvirtualShortMethodV) (JNIEnv *, jobject, jclass, |
| jmethodID, va_list); |
| jshort (JNICALL *CallNonvirtualShortMethodA) (JNIEnv *, jobject, jclass, |
| jmethodID, const jvalue *); |
| jint (JNICALL *CallNonvirtualIntMethod) (JNIEnv *, jobject, jclass, |
| jmethodID, ...); |
| jint (JNICALL *CallNonvirtualIntMethodV) (JNIEnv *, jobject, jclass, |
| jmethodID, va_list); |
| jint (JNICALL *CallNonvirtualIntMethodA) (JNIEnv *, jobject, jclass, |
| jmethodID, const jvalue *); |
| jlong (JNICALL *CallNonvirtualLongMethod) (JNIEnv *, jobject, jclass, |
| jmethodID, ...); |
| jlong (JNICALL *CallNonvirtualLongMethodV) (JNIEnv *, jobject, jclass, |
| jmethodID, va_list); |
| jlong (JNICALL *CallNonvirtualLongMethodA) (JNIEnv *, jobject, jclass, |
| jmethodID, const jvalue *); |
| jfloat (JNICALL *CallNonvirtualFloatMethod) (JNIEnv *, jobject, jclass, |
| jmethodID, ...); |
| jfloat (JNICALL *CallNonvirtualFloatMethodV) (JNIEnv *, jobject, jclass, |
| jmethodID, va_list); |
| jfloat (JNICALL *CallNonvirtualFloatMethodA) (JNIEnv *, jobject, jclass, |
| jmethodID, const jvalue *); |
| jdouble (JNICALL *CallNonvirtualDoubleMethod) (JNIEnv *, jobject, jclass, |
| jmethodID, ...); |
| jdouble (JNICALL *CallNonvirtualDoubleMethodV) (JNIEnv *, jobject, jclass, |
| jmethodID, va_list); |
| jdouble (JNICALL *CallNonvirtualDoubleMethodA) (JNIEnv *, jobject, jclass, |
| jmethodID, const jvalue *); |
| void (JNICALL *CallNonvirtualVoidMethod) (JNIEnv *, jobject, jclass, |
| jmethodID, ...); |
| void (JNICALL *CallNonvirtualVoidMethodV) (JNIEnv *, jobject, jclass, |
| jmethodID, va_list); |
| void (JNICALL *CallNonvirtualVoidMethodA) (JNIEnv *, jobject, jclass, |
| jmethodID, const jvalue *); |
| |
| jfieldID (JNICALL *GetFieldID) (JNIEnv *, jclass, const char *, |
| const char *); |
| |
| jobject (JNICALL *GetObjectField) (JNIEnv *, jobject, jfieldID); |
| jboolean (JNICALL *GetBooleanField) (JNIEnv *, jobject, jfieldID); |
| jbyte (JNICALL *GetByteField) (JNIEnv *, jobject, jfieldID); |
| jchar (JNICALL *GetCharField) (JNIEnv *, jobject, jfieldID); |
| jshort (JNICALL *GetShortField) (JNIEnv *, jobject, jfieldID); |
| jint (JNICALL *GetIntField) (JNIEnv *, jobject, jfieldID); |
| jlong (JNICALL *GetLongField) (JNIEnv *, jobject, jfieldID); |
| jfloat (JNICALL *GetFloatField) (JNIEnv *, jobject, jfieldID); |
| jdouble (JNICALL *GetDoubleField) (JNIEnv *, jobject, jfieldID); |
| |
| void (JNICALL *SetObjectField) (JNIEnv *, jobject, |
| jfieldID, jobject); |
| void (JNICALL *SetBooleanField) (JNIEnv *, jobject, |
| jfieldID, jboolean); |
| void (JNICALL *SetByteField) (JNIEnv *, jobject, |
| jfieldID, jbyte); |
| void (JNICALL *SetCharField) (JNIEnv *, jobject, |
| jfieldID, jchar); |
| void (JNICALL *SetShortField) (JNIEnv *, jobject, |
| jfieldID, jshort); |
| void (JNICALL *SetIntField) (JNIEnv *, jobject, |
| jfieldID, jint); |
| void (JNICALL *SetLongField) (JNIEnv *, jobject, |
| jfieldID, jlong); |
| void (JNICALL *SetFloatField) (JNIEnv *, jobject, |
| jfieldID, jfloat); |
| void (JNICALL *SetDoubleField) (JNIEnv *, jobject, |
| jfieldID, jdouble); |
| |
| jmethodID (JNICALL *GetStaticMethodID) (JNIEnv *, jclass, const char *, |
| const char *); |
| |
| jobject (JNICALL *CallStaticObjectMethod) (JNIEnv *, jclass, jmethodID, |
| ...); |
| jobject (JNICALL *CallStaticObjectMethodV) (JNIEnv *, jclass, jmethodID, |
| va_list); |
| jobject (JNICALL *CallStaticObjectMethodA) (JNIEnv *, jclass, jmethodID, |
| const jvalue *); |
| jboolean (JNICALL *CallStaticBooleanMethod) (JNIEnv *, jclass, jmethodID, |
| ...); |
| jboolean (JNICALL *CallStaticBooleanMethodV) (JNIEnv *, jclass, jmethodID, |
| va_list); |
| jboolean (JNICALL *CallStaticBooleanMethodA) (JNIEnv *, jclass, jmethodID, |
| const jvalue *); |
| jbyte (JNICALL *CallStaticByteMethod) (JNIEnv *, jclass, jmethodID, |
| ...); |
| jbyte (JNICALL *CallStaticByteMethodV) (JNIEnv *, jclass, jmethodID, |
| va_list); |
| jbyte (JNICALL *CallStaticByteMethodA) (JNIEnv *, jclass, jmethodID, |
| const jvalue *); |
| jchar (JNICALL *CallStaticCharMethod) (JNIEnv *, jclass, jmethodID, |
| ...); |
| jchar (JNICALL *CallStaticCharMethodV) (JNIEnv *, jclass, jmethodID, |
| va_list); |
| jchar (JNICALL *CallStaticCharMethodA) (JNIEnv *, jclass, jmethodID, |
| const jvalue *); |
| jshort (JNICALL *CallStaticShortMethod) (JNIEnv *, jclass, jmethodID, |
| ...); |
| jshort (JNICALL *CallStaticShortMethodV) (JNIEnv *, jclass, jmethodID, |
| va_list); |
| jshort (JNICALL *CallStaticShortMethodA) (JNIEnv *, jclass, jmethodID, |
| const jvalue *); |
| jint (JNICALL *CallStaticIntMethod) (JNIEnv *, jclass, jmethodID, |
| ...); |
| jint (JNICALL *CallStaticIntMethodV) (JNIEnv *, jclass, jmethodID, |
| va_list); |
| jint (JNICALL *CallStaticIntMethodA) (JNIEnv *, jclass, jmethodID, |
| const jvalue *); |
| jlong (JNICALL *CallStaticLongMethod) (JNIEnv *, jclass, jmethodID, |
| ...); |
| jlong (JNICALL *CallStaticLongMethodV) (JNIEnv *, jclass, jmethodID, |
| va_list); |
| jlong (JNICALL *CallStaticLongMethodA) (JNIEnv *, jclass, jmethodID, |
| const jvalue *); |
| jfloat (JNICALL *CallStaticFloatMethod) (JNIEnv *, jclass, jmethodID, |
| ...); |
| jfloat (JNICALL *CallStaticFloatMethodV) (JNIEnv *, jclass, jmethodID, |
| va_list); |
| jfloat (JNICALL *CallStaticFloatMethodA) (JNIEnv *, jclass, jmethodID, |
| const jvalue *); |
| jdouble (JNICALL *CallStaticDoubleMethod) (JNIEnv *, jclass, jmethodID, |
| ...); |
| jdouble (JNICALL *CallStaticDoubleMethodV) (JNIEnv *, jclass, jmethodID, |
| va_list); |
| jdouble (JNICALL *CallStaticDoubleMethodA) (JNIEnv *, jclass, jmethodID, |
| const jvalue *); |
| void (JNICALL *CallStaticVoidMethod) (JNIEnv *, jclass, jmethodID, |
| ...); |
| void (JNICALL *CallStaticVoidMethodV) (JNIEnv *, jclass, jmethodID, |
| va_list); |
| void (JNICALL *CallStaticVoidMethodA) (JNIEnv *, jclass, jmethodID, |
| const jvalue *); |
| |
| jfieldID (JNICALL *GetStaticFieldID) (JNIEnv *, jclass, const char *, |
| const char *); |
| |
| jobject (JNICALL *GetStaticObjectField) (JNIEnv *, jclass, jfieldID); |
| jboolean (JNICALL *GetStaticBooleanField) (JNIEnv *, jclass, jfieldID); |
| jbyte (JNICALL *GetStaticByteField) (JNIEnv *, jclass, jfieldID); |
| jchar (JNICALL *GetStaticCharField) (JNIEnv *, jclass, jfieldID); |
| jshort (JNICALL *GetStaticShortField) (JNIEnv *, jclass, jfieldID); |
| jint (JNICALL *GetStaticIntField) (JNIEnv *, jclass, jfieldID); |
| jlong (JNICALL *GetStaticLongField) (JNIEnv *, jclass, jfieldID); |
| jfloat (JNICALL *GetStaticFloatField) (JNIEnv *, jclass, jfieldID); |
| jdouble (JNICALL *GetStaticDoubleField) (JNIEnv *, jclass, jfieldID); |
| |
| void (JNICALL *SetStaticObjectField) (JNIEnv *, jclass, |
| jfieldID, jobject); |
| void (JNICALL *SetStaticBooleanField) (JNIEnv *, jclass, |
| jfieldID, jboolean); |
| void (JNICALL *SetStaticByteField) (JNIEnv *, jclass, |
| jfieldID, jbyte); |
| void (JNICALL *SetStaticCharField) (JNIEnv *, jclass, |
| jfieldID, jchar); |
| void (JNICALL *SetStaticShortField) (JNIEnv *, jclass, |
| jfieldID, jshort); |
| void (JNICALL *SetStaticIntField) (JNIEnv *, jclass, |
| jfieldID, jint); |
| void (JNICALL *SetStaticLongField) (JNIEnv *, jclass, |
| jfieldID, jlong); |
| void (JNICALL *SetStaticFloatField) (JNIEnv *, jclass, |
| jfieldID, jfloat); |
| void (JNICALL *SetStaticDoubleField) (JNIEnv *, jclass, |
| jfieldID, jdouble); |
| |
| jstring (JNICALL *NewString) (JNIEnv *, const jchar *, jsize); |
| jsize (JNICALL *GetStringLength) (JNIEnv *, jstring); |
| const jchar * (JNICALL *GetStringChars) (JNIEnv *, jstring, jboolean *); |
| void (JNICALL *ReleaseStringChars) (JNIEnv *, jstring, const jchar *); |
| jstring (JNICALL *NewStringUTF) (JNIEnv *, const char *); |
| jsize (JNICALL *GetStringUTFLength) (JNIEnv *, jstring); |
| const char * (JNICALL *GetStringUTFChars) (JNIEnv *, jstring, jboolean *); |
| void (JNICALL *ReleaseStringUTFChars) (JNIEnv *, jstring, const char *); |
| jsize (JNICALL *GetArrayLength) (JNIEnv *, jarray); |
| jobjectArray (JNICALL *NewObjectArray) (JNIEnv *, jsize, jclass, jobject); |
| jobject (JNICALL *GetObjectArrayElement) (JNIEnv *, jobjectArray, jsize); |
| void (JNICALL *SetObjectArrayElement) (JNIEnv *, jobjectArray, jsize, |
| jobject); |
| |
| jbooleanArray (JNICALL *NewBooleanArray) (JNIEnv *, jsize); |
| jbyteArray (JNICALL *NewByteArray) (JNIEnv *, jsize); |
| jcharArray (JNICALL *NewCharArray) (JNIEnv *, jsize); |
| jshortArray (JNICALL *NewShortArray) (JNIEnv *, jsize); |
| jintArray (JNICALL *NewIntArray) (JNIEnv *, jsize); |
| jlongArray (JNICALL *NewLongArray) (JNIEnv *, jsize); |
| jfloatArray (JNICALL *NewFloatArray) (JNIEnv *, jsize); |
| jdoubleArray (JNICALL *NewDoubleArray) (JNIEnv *, jsize); |
| |
| jboolean * (JNICALL *GetBooleanArrayElements) (JNIEnv *, jbooleanArray, |
| jboolean *); |
| jbyte * (JNICALL *GetByteArrayElements) (JNIEnv *, jbyteArray, |
| jboolean *); |
| jchar * (JNICALL *GetCharArrayElements) (JNIEnv *, jcharArray, |
| jboolean *); |
| jshort * (JNICALL *GetShortArrayElements) (JNIEnv *, jshortArray, |
| jboolean *); |
| jint * (JNICALL *GetIntArrayElements) (JNIEnv *, jintArray, |
| jboolean *); |
| jlong * (JNICALL *GetLongArrayElements) (JNIEnv *, jlongArray, |
| jboolean *); |
| jfloat * (JNICALL *GetFloatArrayElements) (JNIEnv *, jfloatArray, |
| jboolean *); |
| jdouble * (JNICALL *GetDoubleArrayElements) (JNIEnv *, jdoubleArray, |
| jboolean *); |
| |
| void (JNICALL *ReleaseBooleanArrayElements) (JNIEnv *, jbooleanArray, |
| jboolean *, jint); |
| void (JNICALL *ReleaseByteArrayElements) (JNIEnv *, jbyteArray, |
| jbyte *, jint); |
| void (JNICALL *ReleaseCharArrayElements) (JNIEnv *, jcharArray, |
| jchar *, jint); |
| void (JNICALL *ReleaseShortArrayElements) (JNIEnv *, jshortArray, |
| jshort *, jint); |
| void (JNICALL *ReleaseIntArrayElements) (JNIEnv *, jintArray, |
| jint *, jint); |
| void (JNICALL *ReleaseLongArrayElements) (JNIEnv *, jlongArray, |
| jlong *, jint); |
| void (JNICALL *ReleaseFloatArrayElements) (JNIEnv *, jfloatArray, |
| jfloat *, jint); |
| void (JNICALL *ReleaseDoubleArrayElements) (JNIEnv *, jdoubleArray, |
| jdouble *, jint); |
| |
| void (JNICALL *GetBooleanArrayRegion) (JNIEnv *, jbooleanArray, |
| jsize, jsize, jboolean *); |
| void (JNICALL *GetByteArrayRegion) (JNIEnv *, jbyteArray, |
| jsize, jsize, jbyte *); |
| void (JNICALL *GetCharArrayRegion) (JNIEnv *, jcharArray, |
| jsize, jsize, jchar *); |
| void (JNICALL *GetShortArrayRegion) (JNIEnv *, jshortArray, |
| jsize, jsize, jshort *); |
| void (JNICALL *GetIntArrayRegion) (JNIEnv *, jintArray, |
| jsize, jsize, jint *); |
| void (JNICALL *GetLongArrayRegion) (JNIEnv *, jlongArray, |
| jsize, jsize, jlong *); |
| void (JNICALL *GetFloatArrayRegion) (JNIEnv *, jfloatArray, |
| jsize, jsize, jfloat *); |
| void (JNICALL *GetDoubleArrayRegion) (JNIEnv *, jdoubleArray, |
| jsize, jsize, jdouble *); |
| |
| void (JNICALL *SetBooleanArrayRegion) (JNIEnv *, jbooleanArray, |
| jsize, jsize, |
| const jboolean *); |
| void (JNICALL *SetByteArrayRegion) (JNIEnv *, jbyteArray, |
| jsize, jsize, |
| const jbyte *); |
| void (JNICALL *SetCharArrayRegion) (JNIEnv *, jcharArray, |
| jsize, jsize, |
| const jchar *); |
| void (JNICALL *SetShortArrayRegion) (JNIEnv *, jshortArray, |
| jsize, jsize, |
| const jshort *); |
| void (JNICALL *SetIntArrayRegion) (JNIEnv *, jintArray, |
| jsize, jsize, |
| const jint *); |
| void (JNICALL *SetLongArrayRegion) (JNIEnv *, jlongArray, |
| jsize, jsize, |
| const jlong *); |
| void (JNICALL *SetFloatArrayRegion) (JNIEnv *, jfloatArray, |
| jsize, jsize, |
| const jfloat *); |
| void (JNICALL *SetDoubleArrayRegion) (JNIEnv *, jdoubleArray, |
| jsize, jsize, |
| const jdouble *); |
| |
| jint (JNICALL *RegisterNatives) (JNIEnv *, jclass, |
| const JNINativeMethod *, |
| jint); |
| jint (JNICALL *UnregisterNatives) (JNIEnv *, jclass); |
| jint (JNICALL *MonitorEnter) (JNIEnv *, jobject); |
| jint (JNICALL *MonitorExit) (JNIEnv *, jobject); |
| jint (JNICALL *GetJavaVM) (JNIEnv *, JavaVM **); |
| |
| /* ---- JNI 1.2 functions ---- */ |
| |
| void (JNICALL *GetStringRegion) (JNIEnv *, jstring, jsize, |
| jsize, jchar *); |
| void (JNICALL *GetStringUTFRegion) (JNIEnv *, jstring, jsize, |
| jsize, char *); |
| |
| void * (JNICALL *GetPrimitiveArrayCritical) (JNIEnv *, jarray, |
| jboolean *); |
| void (JNICALL *ReleasePrimitiveArrayCritical) (JNIEnv *, jarray, void *, |
| jint); |
| |
| const jchar * (JNICALL *GetStringCritical) (JNIEnv *, jstring, |
| jboolean *); |
| void (JNICALL *ReleaseStringCritical) (JNIEnv *, jstring, |
| const jchar *); |
| |
| jweak (JNICALL *NewWeakGlobalRef) (JNIEnv *, jobject); |
| void (JNICALL *DeleteWeakGlobalRef) (JNIEnv *, jweak); |
| |
| jboolean (JNICALL *ExceptionCheck) (JNIEnv *); |
| |
| /* ---- JNI 1.4 functions ---- */ |
| |
| jobject (JNICALL *NewDirectByteBuffer) (JNIEnv *, void *, jlong); |
| void * (JNICALL *GetDirectBufferAddress) (JNIEnv *, jobject); |
| jlong (JNICALL *GetDirectBufferCapacity) (JNIEnv *, jobject); |
| |
| /* ---- JNI 1.6 functions ---- */ |
| |
| jobjectRefType (JNICALL *GetObjectRefType) (JNIEnv *, jobject); |
| }; |
| |
| #ifdef __cplusplus |
| |
| class _Jv_JNIEnv |
| { |
| public: |
| /* The method table. */ |
| struct JNINativeInterface_ *functions; |
| |
| #ifdef _CLASSPATH_JNIENV_CONTENTS |
| _CLASSPATH_JNIENV_CONTENTS |
| #endif |
| |
| jint GetVersion () |
| { return functions->GetVersion (this); } |
| |
| jclass DefineClass (const char *name, jobject obj0, const jbyte * val1, |
| jsize val2) |
| { return functions->DefineClass (this, name, obj0, val1, val2); } |
| |
| jclass FindClass (const char * val0) |
| { return functions->FindClass (this, val0); } |
| |
| jmethodID FromReflectedMethod (jobject obj0) |
| { return functions->FromReflectedMethod (this, obj0); } |
| |
| jfieldID FromReflectedField (jobject obj0) |
| { return functions->FromReflectedField (this, obj0); } |
| |
| jobject ToReflectedMethod (jclass cl0, jmethodID meth1, jboolean val2) |
| { return functions->ToReflectedMethod (this, cl0, meth1, val2); } |
| |
| jclass GetSuperclass (jclass cl0) |
| { return functions->GetSuperclass (this, cl0); } |
| |
| jboolean IsAssignableFrom (jclass cl0, jclass cl1) |
| { return functions->IsAssignableFrom (this, cl0, cl1); } |
| |
| jobject ToReflectedField (jclass cl0, jfieldID fld1, jboolean val2) |
| { return functions->ToReflectedField (this, cl0, fld1, val2); } |
| |
| jint Throw (jthrowable val0) |
| { return functions->Throw (this, val0); } |
| |
| jint ThrowNew (jclass cl0, const char * val1) |
| { return functions->ThrowNew (this, cl0, val1); } |
| |
| jthrowable ExceptionOccurred () |
| { return functions->ExceptionOccurred (this); } |
| |
| void ExceptionDescribe () |
| { functions->ExceptionDescribe (this); } |
| |
| void ExceptionClear () |
| { functions->ExceptionClear (this); } |
| |
| void FatalError (const char * val0) |
| { functions->FatalError (this, val0); } |
| |
| jint PushLocalFrame (jint val0) |
| { return functions->PushLocalFrame (this, val0); } |
| |
| jobject PopLocalFrame (jobject obj0) |
| { return functions->PopLocalFrame (this, obj0); } |
| |
| jobject NewGlobalRef (jobject obj0) |
| { return functions->NewGlobalRef (this, obj0); } |
| |
| void DeleteGlobalRef (jobject obj0) |
| { functions->DeleteGlobalRef (this, obj0); } |
| |
| void DeleteLocalRef (jobject obj0) |
| { functions->DeleteLocalRef (this, obj0); } |
| |
| jboolean IsSameObject (jobject obj0, jobject obj1) |
| { return functions->IsSameObject (this, obj0, obj1); } |
| |
| jobject NewLocalRef (jobject obj0) |
| { return functions->NewLocalRef (this, obj0); } |
| |
| jint EnsureLocalCapacity (jint val0) |
| { return functions->EnsureLocalCapacity (this, val0); } |
| |
| jobject AllocObject (jclass cl0) |
| { return functions->AllocObject (this, cl0); } |
| |
| jobject NewObject (jclass cl0, jmethodID meth1, ...) |
| { |
| va_list args; |
| va_start (args, meth1); |
| jobject result = functions->NewObjectV (this, cl0, meth1, args); |
| va_end (args); |
| return result; |
| } |
| |
| jobject NewObjectV (jclass cl0, jmethodID meth1, va_list val2) |
| { return functions->NewObjectV (this, cl0, meth1, val2); } |
| |
| jobject NewObjectA (jclass cl0, jmethodID meth1, jvalue * val2) |
| { return functions->NewObjectA (this, cl0, meth1, val2); } |
| |
| jclass GetObjectClass (jobject obj0) |
| { return functions->GetObjectClass (this, obj0); } |
| |
| jboolean IsInstanceOf (jobject obj0, jclass cl1) |
| { return functions->IsInstanceOf (this, obj0, cl1); } |
| |
| jmethodID GetMethodID (jclass cl0, const char * val1, const char * val2) |
| { return functions->GetMethodID (this, cl0, val1, val2); } |
| |
| jobject CallObjectMethod (jobject obj0, jmethodID meth1, ...) |
| { |
| va_list args; |
| va_start (args, meth1); |
| jobject result = functions->CallObjectMethodV (this, obj0, meth1, args); |
| va_end (args); |
| return result; |
| } |
| |
| jobject CallObjectMethodV (jobject obj0, jmethodID meth1, va_list val2) |
| { return functions->CallObjectMethodV (this, obj0, meth1, val2); } |
| |
| jobject CallObjectMethodA (jobject obj0, jmethodID meth1, jvalue * val2) |
| { return functions->CallObjectMethodA (this, obj0, meth1, val2); } |
| |
| jboolean CallBooleanMethod (jobject obj0, jmethodID meth1, ...) |
| { |
| va_list args; |
| va_start (args, meth1); |
| jboolean result = functions->CallBooleanMethodV (this, obj0, meth1, args); |
| va_end (args); |
| return result; |
| } |
| |
| jboolean CallBooleanMethodV (jobject obj0, jmethodID meth1, va_list val2) |
| { return functions->CallBooleanMethodV (this, obj0, meth1, val2); } |
| |
| jboolean CallBooleanMethodA (jobject obj0, jmethodID meth1, |
| const jvalue * val2) |
| { return functions->CallBooleanMethodA (this, obj0, meth1, val2); } |
| |
| jbyte CallByteMethod (jobject obj0, jmethodID meth1, ...) |
| { |
| va_list args; |
| va_start (args, meth1); |
| jbyte result = functions->CallByteMethodV (this, obj0, meth1, args); |
| va_end (args); |
| return result; |
| } |
| |
| jbyte CallByteMethodV (jobject obj0, jmethodID meth1, va_list val2) |
| { return functions->CallByteMethodV (this, obj0, meth1, val2); } |
| |
| jbyte CallByteMethodA (jobject obj0, jmethodID meth1, const jvalue * val2) |
| { return functions->CallByteMethodA (this, obj0, meth1, val2); } |
| |
| jchar CallCharMethod (jobject obj0, jmethodID meth1, ...) |
| { |
| va_list args; |
| va_start (args, meth1); |
| jchar result = functions->CallCharMethodV (this, obj0, meth1, args); |
| va_end (args); |
| return result; |
| } |
| |
| jchar CallCharMethodV (jobject obj0, jmethodID meth1, va_list val2) |
| { return functions->CallCharMethodV (this, obj0, meth1, val2); } |
| |
| jchar CallCharMethodA (jobject obj0, jmethodID meth1, const jvalue * val2) |
| { return functions->CallCharMethodA (this, obj0, meth1, val2); } |
| |
| jshort CallShortMethod (jobject obj0, jmethodID meth1, ...) |
| { |
| va_list args; |
| va_start (args, meth1); |
| jshort result = functions->CallShortMethodV (this, obj0, meth1, args); |
| va_end (args); |
| return result; |
| } |
| |
| jshort CallShortMethodV (jobject obj0, jmethodID meth1, va_list val2) |
| { return functions->CallShortMethodV (this, obj0, meth1, val2); } |
| |
| jshort CallShortMethodA (jobject obj0, jmethodID meth1, const jvalue * val2) |
| { return functions->CallShortMethodA (this, obj0, meth1, val2); } |
| |
| jint CallIntMethod (jobject obj0, jmethodID meth1, ...) |
| { |
| va_list args; |
| va_start (args, meth1); |
| jint result = functions->CallIntMethodV (this, obj0, meth1, args); |
| va_end (args); |
| return result; |
| } |
| |
| jint CallIntMethodV (jobject obj0, jmethodID meth1, va_list val2) |
| { return functions->CallIntMethodV (this, obj0, meth1, val2); } |
| |
| jint CallIntMethodA (jobject obj0, jmethodID meth1, jvalue * val2) |
| { return functions->CallIntMethodA (this, obj0, meth1, val2); } |
| |
| jlong CallLongMethod (jobject obj0, jmethodID meth1, ...) |
| { |
| va_list args; |
| va_start (args, meth1); |
| jlong result = functions->CallLongMethodV (this, obj0, meth1, args); |
| va_end (args); |
| return result; |
| } |
| |
| jlong CallLongMethodV (jobject obj0, jmethodID meth1, va_list val2) |
| { return functions->CallLongMethodV (this, obj0, meth1, val2); } |
| |
| jlong CallLongMethodA (jobject obj0, jmethodID meth1, const jvalue * val2) |
| { return functions->CallLongMethodA (this, obj0, meth1, val2); } |
| |
| jfloat CallFloatMethod (jobject obj0, jmethodID meth1, ...) |
| { |
| va_list args; |
| va_start (args, meth1); |
| jfloat result = functions->CallFloatMethodV (this, obj0, meth1, args); |
| va_end (args); |
| return result; |
| } |
| |
| jfloat CallFloatMethodV (jobject obj0, jmethodID meth1, va_list val2) |
| { return functions->CallFloatMethodV (this, obj0, meth1, val2); } |
| |
| jfloat CallFloatMethodA (jobject obj0, jmethodID meth1, const jvalue * val2) |
| { return functions->CallFloatMethodA (this, obj0, meth1, val2); } |
| |
| jdouble CallDoubleMethod (jobject obj0, jmethodID meth1, ...) |
| { |
| va_list args; |
| va_start (args, meth1); |
| jdouble result = functions->CallDoubleMethodV (this, obj0, meth1, args); |
| va_end (args); |
| return result; |
| } |
| |
| jdouble CallDoubleMethodV (jobject obj0, jmethodID meth1, va_list val2) |
| { return functions->CallDoubleMethodV (this, obj0, meth1, val2); } |
| |
| jdouble CallDoubleMethodA (jobject obj0, jmethodID meth1, const jvalue * val2) |
| { return functions->CallDoubleMethodA (this, obj0, meth1, val2); } |
| |
| void CallVoidMethod (jobject obj0, jmethodID meth1, ...) |
| { |
| va_list args; |
| va_start (args, meth1); |
| functions->CallVoidMethodV (this, obj0, meth1, args); |
| va_end (args); |
| } |
| |
| void CallVoidMethodV (jobject obj0, jmethodID meth1, va_list val2) |
| { functions->CallVoidMethodV (this, obj0, meth1, val2); } |
| |
| void CallVoidMethodA (jobject obj0, jmethodID meth1, const jvalue * val2) |
| { functions->CallVoidMethodA (this, obj0, meth1, val2); } |
| |
| jobject CallNonvirtualObjectMethod (jobject obj0, jclass cl1, jmethodID meth2, ...) |
| { |
| va_list args; |
| va_start (args, meth2); |
| jobject result = functions->CallNonvirtualObjectMethodV (this, obj0, cl1, meth2, args); |
| va_end (args); |
| return result; |
| } |
| |
| jobject CallNonvirtualObjectMethodV (jobject obj0, jclass cl1, jmethodID meth2, va_list val3) |
| { return functions->CallNonvirtualObjectMethodV (this, obj0, cl1, meth2, val3); } |
| |
| jobject CallNonvirtualObjectMethodA (jobject obj0, jclass cl1, jmethodID meth2, const jvalue * val3) |
| { return functions->CallNonvirtualObjectMethodA (this, obj0, cl1, meth2, val3); } |
| |
| jboolean CallNonvirtualBooleanMethod (jobject obj0, jclass cl1, jmethodID meth2, ...) |
| { |
| va_list args; |
| va_start (args, meth2); |
| jboolean result = functions->CallNonvirtualBooleanMethodV (this, obj0, cl1, meth2, args); |
| va_end (args); |
| return result; |
| } |
| |
| jboolean CallNonvirtualBooleanMethodV (jobject obj0, jclass cl1, jmethodID meth2, va_list val3) |
| { return functions->CallNonvirtualBooleanMethodV (this, obj0, cl1, meth2, val3); } |
| |
| jboolean CallNonvirtualBooleanMethodA (jobject obj0, jclass cl1, jmethodID meth2, const jvalue * val3) |
| { return functions->CallNonvirtualBooleanMethodA (this, obj0, cl1, meth2, val3); } |
| |
| jbyte CallNonvirtualByteMethod (jobject obj0, jclass cl1, jmethodID meth2, ...) |
| { |
| va_list args; |
| va_start (args, meth2); |
| jbyte result = functions->CallNonvirtualByteMethodV (this, obj0, cl1, meth2, args); |
| va_end (args); |
| return result; |
| } |
| |
| jbyte CallNonvirtualByteMethodV (jobject obj0, jclass cl1, jmethodID meth2, va_list val3) |
| { return functions->CallNonvirtualByteMethodV (this, obj0, cl1, meth2, val3); } |
| |
| jbyte CallNonvirtualByteMethodA (jobject obj0, jclass cl1, jmethodID meth2, const jvalue * val3) |
| { return functions->CallNonvirtualByteMethodA (this, obj0, cl1, meth2, val3); } |
| |
| jchar CallNonvirtualCharMethod (jobject obj0, jclass cl1, jmethodID meth2, ...) |
| { |
| va_list args; |
| va_start (args, meth2); |
| jchar result = functions->CallNonvirtualCharMethodV (this, obj0, cl1, meth2, args); |
| va_end (args); |
| return result; |
| } |
| |
| jchar CallNonvirtualCharMethodV (jobject obj0, jclass cl1, jmethodID meth2, va_list val3) |
| { return functions->CallNonvirtualCharMethodV (this, obj0, cl1, meth2, val3); } |
| |
| jchar CallNonvirtualCharMethodA (jobject obj0, jclass cl1, jmethodID meth2, const jvalue * val3) |
| { return functions->CallNonvirtualCharMethodA (this, obj0, cl1, meth2, val3); } |
| |
| jshort CallNonvirtualShortMethod (jobject obj0, jclass cl1, jmethodID meth2, ...) |
| { |
| va_list args; |
| va_start (args, meth2); |
| jshort result = functions->CallNonvirtualShortMethodV (this, obj0, cl1, meth2, args); |
| va_end (args); |
| return result; |
| } |
| |
| jshort CallNonvirtualShortMethodV (jobject obj0, jclass cl1, jmethodID meth2, va_list val3) |
| { return functions->CallNonvirtualShortMethodV (this, obj0, cl1, meth2, val3); } |
| |
| jshort CallNonvirtualShortMethodA (jobject obj0, jclass cl1, jmethodID meth2, const jvalue * val3) |
| { return functions->CallNonvirtualShortMethodA (this, obj0, cl1, meth2, val3); } |
| |
| jint CallNonvirtualIntMethod (jobject obj0, jclass cl1, jmethodID meth2, ...) |
| { |
| va_list args; |
| va_start (args, meth2); |
| jint result = functions->CallNonvirtualIntMethodV (this, obj0, cl1, meth2, args); |
| va_end (args); |
| return result; |
| } |
| |
| jint CallNonvirtualIntMethodV (jobject obj0, jclass cl1, jmethodID meth2, va_list val3) |
| { return functions->CallNonvirtualIntMethodV (this, obj0, cl1, meth2, val3); } |
| |
| jint CallNonvirtualIntMethodA (jobject obj0, jclass cl1, jmethodID meth2, const jvalue * val3) |
| { return functions->CallNonvirtualIntMethodA (this, obj0, cl1, meth2, val3); } |
| |
| jlong CallNonvirtualLongMethod (jobject obj0, jclass cl1, jmethodID meth2, ...) |
| { |
| va_list args; |
| va_start (args, meth2); |
| jlong result = functions->CallNonvirtualLongMethodV (this, obj0, cl1, meth2, args); |
| va_end (args); |
| return result; |
| } |
| |
| jlong CallNonvirtualLongMethodV (jobject obj0, jclass cl1, jmethodID meth2, va_list val3) |
| { return functions->CallNonvirtualLongMethodV (this, obj0, cl1, meth2, val3); } |
| |
| jlong CallNonvirtualLongMethodA (jobject obj0, jclass cl1, jmethodID meth2, const jvalue * val3) |
| { return functions->CallNonvirtualLongMethodA (this, obj0, cl1, meth2, val3); } |
| |
| jfloat CallNonvirtualFloatMethod (jobject obj0, jclass cl1, jmethodID meth2, ...) |
| { |
| va_list args; |
| va_start (args, meth2); |
| jfloat result = functions->CallNonvirtualFloatMethodV (this, obj0, cl1, meth2, args); |
| va_end (args); |
| return result; |
| } |
| |
| jfloat CallNonvirtualFloatMethodV (jobject obj0, jclass cl1, jmethodID meth2, va_list val3) |
| { return functions->CallNonvirtualFloatMethodV (this, obj0, cl1, meth2, val3); } |
| |
| jfloat CallNonvirtualFloatMethodA (jobject obj0, jclass cl1, jmethodID meth2, const jvalue * val3) |
| { return functions->CallNonvirtualFloatMethodA (this, obj0, cl1, meth2, val3); } |
| |
| jdouble CallNonvirtualDoubleMethod (jobject obj0, jclass cl1, jmethodID meth2, ...) |
| { |
| va_list args; |
| va_start (args, meth2); |
| jdouble result = functions->CallNonvirtualDoubleMethodV (this, obj0, cl1, meth2, args); |
| va_end (args); |
| return result; |
| } |
| |
| jdouble CallNonvirtualDoubleMethodV (jobject obj0, jclass cl1, jmethodID meth2, va_list val3) |
| { return functions->CallNonvirtualDoubleMethodV (this, obj0, cl1, meth2, val3); } |
| |
| jdouble CallNonvirtualDoubleMethodA (jobject obj0, jclass cl1, jmethodID meth2, const jvalue * val3) |
| { return functions->CallNonvirtualDoubleMethodA (this, obj0, cl1, meth2, val3); } |
| |
| void CallNonvirtualVoidMethod (jobject obj0, jclass cl1, jmethodID meth2, ...) |
| { |
| va_list args; |
| va_start (args, meth2); |
| functions->CallNonvirtualVoidMethodV (this, obj0, cl1, meth2, args); |
| va_end (args); |
| } |
| |
| void CallNonvirtualVoidMethodV (jobject obj0, jclass cl1, jmethodID meth2, va_list val3) |
| { functions->CallNonvirtualVoidMethodV (this, obj0, cl1, meth2, val3); } |
| |
| void CallNonvirtualVoidMethodA (jobject obj0, jclass cl1, jmethodID meth2, const jvalue * val3) |
| { functions->CallNonvirtualVoidMethodA (this, obj0, cl1, meth2, val3); } |
| |
| jfieldID GetFieldID (jclass cl0, const char * val1, const char * val2) |
| { return functions->GetFieldID (this, cl0, val1, val2); } |
| |
| jobject GetObjectField (jobject obj0, jfieldID fld1) |
| { return functions->GetObjectField (this, obj0, fld1); } |
| |
| jboolean GetBooleanField (jobject obj0, jfieldID fld1) |
| { return functions->GetBooleanField (this, obj0, fld1); } |
| |
| jbyte GetByteField (jobject obj0, jfieldID fld1) |
| { return functions->GetByteField (this, obj0, fld1); } |
| |
| jchar GetCharField (jobject obj0, jfieldID fld1) |
| { return functions->GetCharField (this, obj0, fld1); } |
| |
| jshort GetShortField (jobject obj0, jfieldID fld1) |
| { return functions->GetShortField (this, obj0, fld1); } |
| |
| jint GetIntField (jobject obj0, jfieldID fld1) |
| { return functions->GetIntField (this, obj0, fld1); } |
| |
| jlong GetLongField (jobject obj0, jfieldID fld1) |
| { return functions->GetLongField (this, obj0, fld1); } |
| |
| jfloat GetFloatField (jobject obj0, jfieldID fld1) |
| { return functions->GetFloatField (this, obj0, fld1); } |
| |
| jdouble GetDoubleField (jobject obj0, jfieldID fld1) |
| { return functions->GetDoubleField (this, obj0, fld1); } |
| |
| void SetObjectField (jobject obj0, jfieldID fld1, jobject obj2) |
| { functions->SetObjectField (this, obj0, fld1, obj2); } |
| |
| void SetBooleanField (jobject obj0, jfieldID fld1, jboolean val2) |
| { functions->SetBooleanField (this, obj0, fld1, val2); } |
| |
| void SetByteField (jobject obj0, jfieldID fld1, jbyte val2) |
| { functions->SetByteField (this, obj0, fld1, val2); } |
| |
| void SetCharField (jobject obj0, jfieldID fld1, jchar val2) |
| { functions->SetCharField (this, obj0, fld1, val2); } |
| |
| void SetShortField (jobject obj0, jfieldID fld1, jshort val2) |
| { functions->SetShortField (this, obj0, fld1, val2); } |
| |
| void SetIntField (jobject obj0, jfieldID fld1, jint val2) |
| { functions->SetIntField (this, obj0, fld1, val2); } |
| |
| void SetLongField (jobject obj0, jfieldID fld1, jlong val2) |
| { functions->SetLongField (this, obj0, fld1, val2); } |
| |
| void SetFloatField (jobject obj0, jfieldID fld1, jfloat val2) |
| { functions->SetFloatField (this, obj0, fld1, val2); } |
| |
| void SetDoubleField (jobject obj0, jfieldID fld1, jdouble val2) |
| { functions->SetDoubleField (this, obj0, fld1, val2); } |
| |
| jmethodID GetStaticMethodID (jclass cl0, const char * val1, const char * val2) |
| { return functions->GetStaticMethodID (this, cl0, val1, val2); } |
| |
| jobject CallStaticObjectMethod (jclass cl0, jmethodID meth1, ...) |
| { |
| va_list args; |
| va_start (args, meth1); |
| jobject result = functions->CallStaticObjectMethodV (this, cl0, meth1, args); |
| va_end (args); |
| return result; |
| } |
| |
| jobject CallStaticObjectMethodV (jclass cl0, jmethodID meth1, va_list val2) |
| { return functions->CallStaticObjectMethodV (this, cl0, meth1, val2); } |
| |
| jobject CallStaticObjectMethodA (jclass cl0, jmethodID meth1, |
| const jvalue * val2) |
| { return functions->CallStaticObjectMethodA (this, cl0, meth1, val2); } |
| |
| jboolean CallStaticBooleanMethod (jclass cl0, jmethodID meth1, ...) |
| { |
| va_list args; |
| va_start (args, meth1); |
| jboolean result = functions->CallStaticBooleanMethodV (this, cl0, meth1, args); |
| va_end (args); |
| return result; |
| } |
| |
| jboolean CallStaticBooleanMethodV (jclass cl0, jmethodID meth1, va_list val2) |
| { return functions->CallStaticBooleanMethodV (this, cl0, meth1, val2); } |
| |
| jboolean CallStaticBooleanMethodA (jclass cl0, jmethodID meth1, |
| const jvalue * val2) |
| { return functions->CallStaticBooleanMethodA (this, cl0, meth1, val2); } |
| |
| jbyte CallStaticByteMethod (jclass cl0, jmethodID meth1, ...) |
| { |
| va_list args; |
| va_start (args, meth1); |
| jbyte result = functions->CallStaticByteMethodV (this, cl0, meth1, args); |
| va_end (args); |
| return result; |
| } |
| |
| jbyte CallStaticByteMethodV (jclass cl0, jmethodID meth1, va_list val2) |
| { return functions->CallStaticByteMethodV (this, cl0, meth1, val2); } |
| |
| jbyte CallStaticByteMethodA (jclass cl0, jmethodID meth1, const jvalue * val2) |
| { return functions->CallStaticByteMethodA (this, cl0, meth1, val2); } |
| |
| jchar CallStaticCharMethod (jclass cl0, jmethodID meth1, ...) |
| { |
| va_list args; |
| va_start (args, meth1); |
| jchar result = functions->CallStaticCharMethodV (this, cl0, meth1, args); |
| va_end (args); |
| return result; |
| } |
| |
| jchar CallStaticCharMethodV (jclass cl0, jmethodID meth1, va_list val2) |
| { return functions->CallStaticCharMethodV (this, cl0, meth1, val2); } |
| |
| jchar CallStaticCharMethodA (jclass cl0, jmethodID meth1, const jvalue * val2) |
| { return functions->CallStaticCharMethodA (this, cl0, meth1, val2); } |
| |
| jshort CallStaticShortMethod (jclass cl0, jmethodID meth1, ...) |
| { |
| va_list args; |
| va_start (args, meth1); |
| jshort result = functions->CallStaticShortMethodV (this, cl0, meth1, args); |
| va_end (args); |
| return result; |
| } |
| |
| jshort CallStaticShortMethodV (jclass cl0, jmethodID meth1, va_list val2) |
| { return functions->CallStaticShortMethodV (this, cl0, meth1, val2); } |
| |
| jshort CallStaticShortMethodA (jclass cl0, jmethodID meth1, |
| const jvalue * val2) |
| { return functions->CallStaticShortMethodA (this, cl0, meth1, val2); } |
| |
| jint CallStaticIntMethod (jclass cl0, jmethodID meth1, ...) |
| { |
| va_list args; |
| va_start (args, meth1); |
| jint result = functions->CallStaticIntMethodV (this, cl0, meth1, args); |
| va_end (args); |
| return result; |
| } |
| |
| jint CallStaticIntMethodV (jclass cl0, jmethodID meth1, va_list val2) |
| { return functions->CallStaticIntMethodV (this, cl0, meth1, val2); } |
| |
| jint CallStaticIntMethodA (jclass cl0, jmethodID meth1, const jvalue * val2) |
| { return functions->CallStaticIntMethodA (this, cl0, meth1, val2); } |
| |
| jlong CallStaticLongMethod (jclass cl0, jmethodID meth1, ...) |
| { |
| va_list args; |
| va_start (args, meth1); |
| jlong result = functions->CallStaticLongMethodV (this, cl0, meth1, args); |
| va_end (args); |
| return result; |
| } |
| |
| jlong CallStaticLongMethodV (jclass cl0, jmethodID meth1, va_list val2) |
| { return functions->CallStaticLongMethodV (this, cl0, meth1, val2); } |
| |
| jlong CallStaticLongMethodA (jclass cl0, jmethodID meth1, const jvalue * val2) |
| { return functions->CallStaticLongMethodA (this, cl0, meth1, val2); } |
| |
| jfloat CallStaticFloatMethod (jclass cl0, jmethodID meth1, ...) |
| { |
| va_list args; |
| va_start (args, meth1); |
| jfloat result = functions->CallStaticFloatMethodV (this, cl0, meth1, args); |
| va_end (args); |
| return result; |
| } |
| |
| jfloat CallStaticFloatMethodV (jclass cl0, jmethodID meth1, va_list val2) |
| { return functions->CallStaticFloatMethodV (this, cl0, meth1, val2); } |
| |
| jfloat CallStaticFloatMethodA (jclass cl0, jmethodID meth1, |
| const jvalue * val2) |
| { return functions->CallStaticFloatMethodA (this, cl0, meth1, val2); } |
| |
| jdouble CallStaticDoubleMethod (jclass cl0, jmethodID meth1, ...) |
| { |
| va_list args; |
| va_start (args, meth1); |
| jdouble result = functions->CallStaticDoubleMethodV (this, cl0, meth1, args); |
| va_end (args); |
| return result; |
| } |
| |
| jdouble CallStaticDoubleMethodV (jclass cl0, jmethodID meth1, va_list val2) |
| { return functions->CallStaticDoubleMethodV (this, cl0, meth1, val2); } |
| |
| jdouble CallStaticDoubleMethodA (jclass cl0, jmethodID meth1, |
| const jvalue * val2) |
| { return functions->CallStaticDoubleMethodA (this, cl0, meth1, val2); } |
| |
| void CallStaticVoidMethod (jclass cl0, jmethodID meth1, ...) |
| { |
| va_list args; |
| va_start (args, meth1); |
| functions->CallStaticVoidMethodV (this, cl0, meth1, args); |
| va_end (args); |
| } |
| |
| void CallStaticVoidMethodV (jclass cl0, jmethodID meth1, va_list val2) |
| { functions->CallStaticVoidMethodV (this, cl0, meth1, val2); } |
| |
| void CallStaticVoidMethodA (jclass cl0, jmethodID meth1, const jvalue * val2) |
| { functions->CallStaticVoidMethodA (this, cl0, meth1, val2); } |
| |
| jfieldID GetStaticFieldID (jclass cl0, const char * val1, const char * val2) |
| { return functions->GetStaticFieldID (this, cl0, val1, val2); } |
| |
| jobject GetStaticObjectField (jclass cl0, jfieldID fld1) |
| { return functions->GetStaticObjectField (this, cl0, fld1); } |
| |
| jboolean GetStaticBooleanField (jclass cl0, jfieldID fld1) |
| { return functions->GetStaticBooleanField (this, cl0, fld1); } |
| |
| jbyte GetStaticByteField (jclass cl0, jfieldID fld1) |
| { return functions->GetStaticByteField (this, cl0, fld1); } |
| |
| jchar GetStaticCharField (jclass cl0, jfieldID fld1) |
| { return functions->GetStaticCharField (this, cl0, fld1); } |
| |
| jshort GetStaticShortField (jclass cl0, jfieldID fld1) |
| { return functions->GetStaticShortField (this, cl0, fld1); } |
| |
| jint GetStaticIntField (jclass cl0, jfieldID fld1) |
| { return functions->GetStaticIntField (this, cl0, fld1); } |
| |
| jlong GetStaticLongField (jclass cl0, jfieldID fld1) |
| { return functions->GetStaticLongField (this, cl0, fld1); } |
| |
| jfloat GetStaticFloatField (jclass cl0, jfieldID fld1) |
| { return functions->GetStaticFloatField (this, cl0, fld1); } |
| |
| jdouble GetStaticDoubleField (jclass cl0, jfieldID fld1) |
| { return functions->GetStaticDoubleField (this, cl0, fld1); } |
| |
| void SetStaticObjectField (jclass cl0, jfieldID fld1, jobject obj2) |
| { functions->SetStaticObjectField (this, cl0, fld1, obj2); } |
| |
| void SetStaticBooleanField (jclass cl0, jfieldID fld1, jboolean val2) |
| { functions->SetStaticBooleanField (this, cl0, fld1, val2); } |
| |
| void SetStaticByteField (jclass cl0, jfieldID fld1, jbyte val2) |
| { functions->SetStaticByteField (this, cl0, fld1, val2); } |
| |
| void SetStaticCharField (jclass cl0, jfieldID fld1, jchar val2) |
| { functions->SetStaticCharField (this, cl0, fld1, val2); } |
| |
| void SetStaticShortField (jclass cl0, jfieldID fld1, jshort val2) |
| { functions->SetStaticShortField (this, cl0, fld1, val2); } |
| |
| void SetStaticIntField (jclass cl0, jfieldID fld1, jint val2) |
| { functions->SetStaticIntField (this, cl0, fld1, val2); } |
| |
| void SetStaticLongField (jclass cl0, jfieldID fld1, jlong val2) |
| { functions->SetStaticLongField (this, cl0, fld1, val2); } |
| |
| void SetStaticFloatField (jclass cl0, jfieldID fld1, jfloat val2) |
| { functions->SetStaticFloatField (this, cl0, fld1, val2); } |
| |
| void SetStaticDoubleField (jclass cl0, jfieldID fld1, jdouble val2) |
| { functions->SetStaticDoubleField (this, cl0, fld1, val2); } |
| |
| jstring NewString (const jchar * val0, jsize val1) |
| { return functions->NewString (this, val0, val1); } |
| |
| jint GetStringLength (jstring val0) |
| { return functions->GetStringLength (this, val0); } |
| |
| const jchar * GetStringChars (jstring val0, jboolean * val1) |
| { return functions->GetStringChars (this, val0, val1); } |
| |
| void ReleaseStringChars (jstring val0, const jchar * val1) |
| { functions->ReleaseStringChars (this, val0, val1); } |
| |
| jstring NewStringUTF (const char * val0) |
| { return functions->NewStringUTF (this, val0); } |
| |
| jsize GetStringUTFLength (jstring val0) |
| { return functions->GetStringUTFLength (this, val0); } |
| |
| const char * GetStringUTFChars (jstring val0, jboolean * val1) |
| { return functions->GetStringUTFChars (this, val0, val1); } |
| |
| void ReleaseStringUTFChars (jstring val0, const char * val1) |
| { functions->ReleaseStringUTFChars (this, val0, val1); } |
| |
| jsize GetArrayLength (jarray val0) |
| { return functions->GetArrayLength (this, val0); } |
| |
| jobjectArray NewObjectArray (jsize val0, jclass cl1, jobject obj2) |
| { return functions->NewObjectArray (this, val0, cl1, obj2); } |
| |
| jobject GetObjectArrayElement (jobjectArray val0, jsize val1) |
| { return functions->GetObjectArrayElement (this, val0, val1); } |
| |
| void SetObjectArrayElement (jobjectArray val0, jsize val1, jobject obj2) |
| { functions->SetObjectArrayElement (this, val0, val1, obj2); } |
| |
| jbooleanArray NewBooleanArray (jsize val0) |
| { return functions->NewBooleanArray (this, val0); } |
| |
| jbyteArray NewByteArray (jsize val0) |
| { return functions->NewByteArray (this, val0); } |
| |
| jcharArray NewCharArray (jsize val0) |
| { return functions->NewCharArray (this, val0); } |
| |
| jshortArray NewShortArray (jsize val0) |
| { return functions->NewShortArray (this, val0); } |
| |
| jintArray NewIntArray (jsize val0) |
| { return functions->NewIntArray (this, val0); } |
| |
| jlongArray NewLongArray (jsize val0) |
| { return functions->NewLongArray (this, val0); } |
| |
| jfloatArray NewFloatArray (jsize val0) |
| { return functions->NewFloatArray (this, val0); } |
| |
| jdoubleArray NewDoubleArray (jsize val0) |
| { return functions->NewDoubleArray (this, val0); } |
| |
| jboolean * GetBooleanArrayElements (jbooleanArray val0, jboolean * val1) |
| { return functions->GetBooleanArrayElements (this, val0, val1); } |
| |
| jbyte * GetByteArrayElements (jbyteArray val0, jboolean * val1) |
| { return functions->GetByteArrayElements (this, val0, val1); } |
| |
| jchar * GetCharArrayElements (jcharArray val0, jboolean * val1) |
| { return functions->GetCharArrayElements (this, val0, val1); } |
| |
| jshort * GetShortArrayElements (jshortArray val0, jboolean * val1) |
| { return functions->GetShortArrayElements (this, val0, val1); } |
| |
| jint * GetIntArrayElements (jintArray val0, jboolean * val1) |
| { return functions->GetIntArrayElements (this, val0, val1); } |
| |
| jlong * GetLongArrayElements (jlongArray val0, jboolean * val1) |
| { return functions->GetLongArrayElements (this, val0, val1); } |
| |
| jfloat * GetFloatArrayElements (jfloatArray val0, jboolean * val1) |
| { return functions->GetFloatArrayElements (this, val0, val1); } |
| |
| jdouble * GetDoubleArrayElements (jdoubleArray val0, jboolean * val1) |
| { return functions->GetDoubleArrayElements (this, val0, val1); } |
| |
| void ReleaseBooleanArrayElements (jbooleanArray val0, jboolean * val1, jint val2) |
| { functions->ReleaseBooleanArrayElements (this, val0, val1, val2); } |
| |
| void ReleaseByteArrayElements (jbyteArray val0, jbyte * val1, jint val2) |
| { functions->ReleaseByteArrayElements (this, val0, val1, val2); } |
| |
| void ReleaseCharArrayElements (jcharArray val0, jchar * val1, jint val2) |
| { functions->ReleaseCharArrayElements (this, val0, val1, val2); } |
| |
| void ReleaseShortArrayElements (jshortArray val0, jshort * val1, jint val2) |
| { functions->ReleaseShortArrayElements (this, val0, val1, val2); } |
| |
| void ReleaseIntArrayElements (jintArray val0, jint * val1, jint val2) |
| { functions->ReleaseIntArrayElements (this, val0, val1, val2); } |
| |
| void ReleaseLongArrayElements (jlongArray val0, jlong * val1, jint val2) |
| { functions->ReleaseLongArrayElements (this, val0, val1, val2); } |
| |
| void ReleaseFloatArrayElements (jfloatArray val0, jfloat * val1, jint val2) |
| { functions->ReleaseFloatArrayElements (this, val0, val1, val2); } |
| |
| void ReleaseDoubleArrayElements (jdoubleArray val0, jdouble * val1, jint val2) |
| { functions->ReleaseDoubleArrayElements (this, val0, val1, val2); } |
| |
| void GetBooleanArrayRegion (jbooleanArray val0, jsize val1, jsize val2, jboolean * val3) |
| { functions->GetBooleanArrayRegion (this, val0, val1, val2, val3); } |
| |
| void GetByteArrayRegion (jbyteArray val0, jsize val1, jsize val2, jbyte * val3) |
| { functions->GetByteArrayRegion (this, val0, val1, val2, val3); } |
| |
| void GetCharArrayRegion (jcharArray val0, jsize val1, jsize val2, jchar * val3) |
| { functions->GetCharArrayRegion (this, val0, val1, val2, val3); } |
| |
| void GetShortArrayRegion (jshortArray val0, jsize val1, jsize val2, jshort * val3) |
| { functions->GetShortArrayRegion (this, val0, val1, val2, val3); } |
| |
| void GetIntArrayRegion (jintArray val0, jsize val1, jsize val2, jint * val3) |
| { functions->GetIntArrayRegion (this, val0, val1, val2, val3); } |
| |
| void GetLongArrayRegion (jlongArray val0, jsize val1, jsize val2, jlong * val3) |
| { functions->GetLongArrayRegion (this, val0, val1, val2, val3); } |
| |
| void GetFloatArrayRegion (jfloatArray val0, jsize val1, jsize val2, jfloat * val3) |
| { functions->GetFloatArrayRegion (this, val0, val1, val2, val3); } |
| |
| void GetDoubleArrayRegion (jdoubleArray val0, jsize val1, jsize val2, jdouble * val3) |
| { functions->GetDoubleArrayRegion (this, val0, val1, val2, val3); } |
| |
| void SetBooleanArrayRegion (jbooleanArray val0, jsize val1, jsize val2, jboolean * val3) |
| { functions->SetBooleanArrayRegion (this, val0, val1, val2, val3); } |
| |
| void SetByteArrayRegion (jbyteArray val0, jsize val1, jsize val2, jbyte * val3) |
| { functions->SetByteArrayRegion (this, val0, val1, val2, val3); } |
| |
| void SetCharArrayRegion (jcharArray val0, jsize val1, jsize val2, jchar * val3) |
| { functions->SetCharArrayRegion (this, val0, val1, val2, val3); } |
| |
| void SetShortArrayRegion (jshortArray val0, jsize val1, jsize val2, jshort * val3) |
| { functions->SetShortArrayRegion (this, val0, val1, val2, val3); } |
| |
| void SetIntArrayRegion (jintArray val0, jsize val1, jsize val2, jint * val3) |
| { functions->SetIntArrayRegion (this, val0, val1, val2, val3); } |
| |
| void SetLongArrayRegion (jlongArray val0, jsize val1, jsize val2, jlong * val3) |
| { functions->SetLongArrayRegion (this, val0, val1, val2, val3); } |
| |
| void SetFloatArrayRegion (jfloatArray val0, jsize val1, jsize val2, jfloat * val3) |
| { functions->SetFloatArrayRegion (this, val0, val1, val2, val3); } |
| |
| void SetDoubleArrayRegion (jdoubleArray val0, jsize val1, jsize val2, jdouble * val3) |
| { functions->SetDoubleArrayRegion (this, val0, val1, val2, val3); } |
| |
| jint RegisterNatives (jclass cl0, const JNINativeMethod * val1, jint val2) |
| { return functions->RegisterNatives (this, cl0, val1, val2); } |
| |
| jint UnregisterNatives (jclass cl0) |
| { return functions->UnregisterNatives (this, cl0); } |
| |
| jint MonitorEnter (jobject obj0) |
| { return functions->MonitorEnter (this, obj0); } |
| |
| jint MonitorExit (jobject obj0) |
| { return functions->MonitorExit (this, obj0); } |
| |
| jint GetJavaVM (JavaVM ** val0) |
| { return functions->GetJavaVM (this, val0); } |
| |
| /* ---- JNI 1.2 functions ---- */ |
| |
| void GetStringRegion (jstring val0, jsize val1, jsize val2, jchar * val3) |
| { functions->GetStringRegion (this, val0, val1, val2, val3); } |
| |
| void GetStringUTFRegion (jstring val0, jsize val1, jsize val2, char * val3) |
| { functions->GetStringUTFRegion (this, val0, val1, val2, val3); } |
| |
| void * GetPrimitiveArrayCritical (jarray val0, jboolean * val1) |
| { return functions->GetPrimitiveArrayCritical (this, val0, val1); } |
| |
| void ReleasePrimitiveArrayCritical (jarray val0, void * val1, jint val2) |
| { functions->ReleasePrimitiveArrayCritical (this, val0, val1, val2); } |
| |
| const jchar * GetStringCritical (jstring val0, jboolean * val1) |
| { return functions->GetStringCritical (this, val0, val1); } |
| |
| void ReleaseStringCritical (jstring val0, const jchar * val1) |
| { functions->ReleaseStringCritical (this, val0, val1); } |
| |
| jweak NewWeakGlobalRef (jobject obj0) |
| { return functions->NewWeakGlobalRef (this, obj0); } |
| |
| void DeleteWeakGlobalRef (jweak val0) |
| { functions->DeleteWeakGlobalRef (this, val0); } |
| |
| jboolean ExceptionCheck () |
| { return functions->ExceptionCheck (this); } |
| |
| /* ---- JNI 1.4 functions ---- */ |
| |
| jobject NewDirectByteBuffer (void *addr, jlong capacity) |
| { return functions->NewDirectByteBuffer (this, addr, capacity); } |
| |
| void *GetDirectBufferAddress (jobject buf) |
| { return functions->GetDirectBufferAddress (this, buf); } |
| |
| jlong GetDirectBufferCapacity (jobject buf) |
| { return functions->GetDirectBufferCapacity (this, buf); } |
| |
| /* ---- JNI 1.6 functions ---- */ |
| |
| jobjectRefType GetObjectRefType (jobject obj) |
| { return functions->GetObjectRefType (this, obj); } |
| }; |
| |
| #endif /* __cplusplus */ |
| |
| /* |
| * Invocation API. |
| */ |
| |
| struct JNIInvokeInterface_ |
| { |
| void *reserved0; |
| void *reserved1; |
| void *reserved2; |
| |
| jint (JNICALL *DestroyJavaVM) (JavaVM *); |
| jint (JNICALL *AttachCurrentThread) (JavaVM *, void **, void *); |
| jint (JNICALL *DetachCurrentThread) (JavaVM *); |
| jint (JNICALL *GetEnv) (JavaVM *, void **, jint); |
| jint (JNICALL *AttachCurrentThreadAsDaemon) (JavaVM *, void **, void *); |
| }; |
| |
| #ifdef __cplusplus |
| |
| class _Jv_JavaVM |
| { |
| public: |
| const struct JNIInvokeInterface_ *functions; |
| |
| 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 /* __cplusplus */ |
| |
| typedef struct JavaVMAttachArgs |
| { |
| jint version; /* Must be JNI_VERSION_1_2. */ |
| char *name; /* The name of the thread (or NULL). */ |
| jobject group; /* Global ref of a ThreadGroup object |
| (or NULL). */ |
| } JavaVMAttachArgs; |
| |
| typedef struct JavaVMOption |
| { |
| char *optionString; |
| void *extraInfo; |
| } JavaVMOption; |
| |
| typedef struct JavaVMInitArgs |
| { |
| /* Must be JNI_VERSION_1_2. */ |
| jint version; |
| |
| /* Number of options. */ |
| jint nOptions; |
| |
| /* Options to the VM. */ |
| JavaVMOption *options; |
| |
| /* Whether we should ignore unrecognized options. */ |
| jboolean ignoreUnrecognized; |
| } JavaVMInitArgs; |
| |
| typedef struct JDK1_1InitArgs |
| { |
| /* VM version. Should be JNI_VERSION_1_1. Note that before JDK |
| 1.1.2, this field was named 'reserved0'. (I don't know what the |
| current 'reserved0' field was named then.) */ |
| jint version; |
| |
| /* A null-terminated array of environment strings, each of the form |
| "KEY=VALUE". This is used to set system properties. Note that |
| before JDK 1.1.2, this field was named 'reserved1'. */ |
| char **properties; |
| |
| jint checkSource; |
| jint nativeStackSize; |
| jint javaStackSize; |
| jint minHeapSize; |
| jint maxHeapSize; |
| jint verifyMode; |
| const char *classpath; |
| |
| jint (JNICALL *vfprintf) (FILE *file, const char *fmt, va_list args); |
| void (JNICALL *exit) (jint value); |
| void (JNICALL *abort) (void); |
| |
| jint enableClassGC; |
| jint enableVerboseGC; |
| jint disableAsyncGC; |
| |
| jint reserved0; |
| jint reserved1; |
| jint reserved2; |
| } JDK1_1InitArgs; |
| |
| typedef struct JDK1_1AttachArgs |
| { |
| /* Dummy field since C cannot have empty structs. The name and type |
| are chosen to comply with the spec. */ |
| void *__padding; |
| } JDK1_1AttachArgs; |
| |
| |
| /* Keep c-font-lock-extra-types in alphabetical order. */ |
| /* |
| Local Variables: |
| c-font-lock-extra-types: ("\\sw+_t" \ |
| "JNIEnv" "JNINativeMethod" "JavaVM" "JavaVMOption" "jarray" \ |
| "jboolean" "jbooleanArray" "jbyte" "jbyteArray" "jchar" "jcharArray" \ |
| "jclass" "jdouble" "jdoubleArray" "jfieldID" "jfloat" "jfloatArray" \ |
| "jint" "jintArray" "jlong" "jlongArray" "jmethodID" "jobject" \ |
| "jstring" "jthrowable" "jvalue" "jweak") |
| End: |
| */ |
| |
| #endif /* _CLASSPATH_JNI_H */ |
