You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@harmony.apache.org by te...@apache.org on 2006/12/18 12:53:32 UTC
svn commit: r488244 [2/5] - in
/harmony/enhanced/classlib/trunk/modules/luni: ./
src/main/native/include/shared/
Modified: harmony/enhanced/classlib/trunk/modules/luni/src/main/native/include/shared/jni.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/luni/src/main/native/include/shared/jni.h?view=diff&rev=488244&r1=488243&r2=488244
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/luni/src/main/native/include/shared/jni.h (original)
+++ harmony/enhanced/classlib/trunk/modules/luni/src/main/native/include/shared/jni.h Mon Dec 18 03:53:30 2006
@@ -1,4 +1,4 @@
-/*
+/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
@@ -14,2060 +14,1749 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
+/**
+ * @author Intel, Gregory Shimansky
+ * @version $Revision: 1.1.2.1.4.3 $
+ */
-#if !defined(JNI_H)
-#define JNI_H
+/**
+ * @file This file describes the JNI interface as per the JNI
+ * specification 1.5 available from Sun.
+ */
-#include "jniport.h"
-#include <stdio.h> /* For 1.1 version of args (i.e., vfprintf) */
-#include <stdarg.h> /* For va_list */
-#if defined(JNI_JCL_H)
-#include "jni_jcl.h"
-#endif
+#ifndef _JNI_H_
+#define _JNI_H_
-#if defined(__cplusplus)
-extern "C"
-{
-#endif
-/* Boolean values */
-#define JNI_FALSE 0
-#define JNI_TRUE 1
-/* Codes for ReleaseXArrayElements */
-#define JNI_COMMIT 1
-#define JNI_ABORT 2
-/* JNI version numbers */
+#include <stdio.h>
+#include <stdarg.h>
+#include "jni_types.h"
+
+/*
+ * Supported JNI versions
+ */
#define JNI_VERSION_1_1 0x00010001
#define JNI_VERSION_1_2 0x00010002
#define JNI_VERSION_1_4 0x00010004
-#define JVMEXT_VERSION_1_1 0x7E010001
-/* Error codes */
-#define JNI_OK 0
-#define JNI_ERR (-1)
-#define JNI_EDETACHED (-2)
-#define JNI_EVERSION (-3)
-#define JNI_ENOMEM (-4)
-#define JNI_EEXIST (-5)
-#define JNI_EINVAL (-6)
- typedef unsigned char jboolean;
-/* jbyte is platform specific */
- typedef unsigned short jchar;
- typedef short jshort;
-/* jint is platform specific */
-/* jlong is platform specific */
- typedef float jfloat;
- typedef double jdouble;
- typedef jint jsize;
-#if defined(__cplusplus)
- class _jobject
- {
- };
- class _jweak:public _jobject
- {
- };
- class _jclass:public _jobject
- {
- };
- class _jstring:public _jobject
- {
- };
- class _jthrowable:public _jobject
- {
- };
- class _jarray:public _jobject
- {
- };
- class _jobjectArray:public _jarray
- {
- };
- 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
- {
- };
- typedef _jobject *jobject;
- typedef _jweak *jweak;
- typedef _jclass *jclass;
- typedef _jstring *jstring;
- typedef _jthrowable *jthrowable;
- typedef _jarray *jarray;
- typedef _jobjectArray *jobjectArray;
- typedef _jbooleanArray *jbooleanArray;
- typedef _jbyteArray *jbyteArray;
- typedef _jcharArray *jcharArray;
- typedef _jshortArray *jshortArray;
- typedef _jintArray *jintArray;
- typedef _jlongArray *jlongArray;
- typedef _jfloatArray *jfloatArray;
- typedef _jdoubleArray *jdoubleArray;
-#else
- struct _jobject;
- typedef struct _jobject *jobject;
- typedef jobject jweak;
- typedef jobject jclass;
- typedef jobject jstring;
- typedef jobject jthrowable;
- typedef jobject jarray;
- typedef jarray jobjectArray;
- typedef jarray jbooleanArray;
- typedef jarray jbyteArray;
- typedef jarray jcharArray;
- typedef jarray jshortArray;
- typedef jarray jintArray;
- typedef jarray jlongArray;
- typedef jarray jfloatArray;
- typedef jarray jdoubleArray;
-#endif
- struct _jfieldID;
- typedef struct _jfieldID *jfieldID;
- struct _jmethodID;
- typedef struct _jmethodID *jmethodID;
-/** Used for CallXXXMethodA API */
- typedef union jvalue
- {
- jboolean z;
- jbyte b;
- jchar c;
- jshort s;
- jint i;
- jlong j;
- jfloat f;
- jdouble d;
- jobject l;
- } jvalue;
- typedef struct
- {
- char *name;
- char *signature;
- void *fnPtr;
- } JNINativeMethod;
-/**
- * JavaVMQuery structure
- */
- struct JavaVMQuery;
- typedef struct JavaVMQuery JavaVMQuery;
-/**
- * used in QueryGCStatus.
- */
-#define JNI_GCQUERY_NURSERY_HEAP (jint) 0x3
-#define JNI_GCQUERY_MATURE_HEAP (jint) 0x4
-/**
- * GCStatus structure.
+
+/*
+ * JNI Native Method Interface - C
*/
- typedef struct GCStatus
- {
- jint heap;
- jint count;
- jlong freestorage;
- jlong totalstorage;
- } GCStatus;
- struct JNINativeInterface_;
- struct JNIEnv_;
- struct JNIInvokeInterface_;
- struct JavaVM_;
-#if defined(__cplusplus)
- typedef JNIEnv_ JNIEnv;
- typedef JavaVM_ JavaVM;
-#else
- typedef const struct JNINativeInterface_ *JNIEnv;
- typedef const struct JNIInvokeInterface_ *JavaVM;
-#endif
- struct JNINativeInterface_
- {
+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 bufLen);
- 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 clazz);
- jboolean (JNICALL * IsAssignableFrom) (JNIEnv * env, jclass clazz1,
- jclass clazz2);
- 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 *message);
- 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 obj);
- void (JNICALL * DeleteGlobalRef) (JNIEnv * env, jobject gref);
- void (JNICALL * DeleteLocalRef) (JNIEnv * env, jobject localRef);
- jboolean (JNICALL * IsSameObject) (JNIEnv * env, jobject ref1,
- jobject ref2);
- 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, 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,
- 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,
- 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, 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, 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, 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, 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, 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, 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,
- 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, 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,
- 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,
- 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,
- 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,
- 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,
- 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,
- 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,
- 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,
- 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,
- 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,
- 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 value);
- void (JNICALL * SetBooleanField) (JNIEnv * env, jobject obj,
- jfieldID fieldID, jboolean value);
- void (JNICALL * SetByteField) (JNIEnv * env, jobject obj,
- jfieldID fieldID, jbyte value);
- void (JNICALL * SetCharField) (JNIEnv * env, jobject obj,
- jfieldID fieldID, jchar value);
- void (JNICALL * SetShortField) (JNIEnv * env, jobject obj,
- jfieldID fieldID, jshort value);
- void (JNICALL * SetIntField) (JNIEnv * env, jobject obj, jfieldID fieldID,
- jint value);
- void (JNICALL * SetLongField) (JNIEnv * env, jobject obj,
- jfieldID fieldID, jlong value);
- void (JNICALL * SetFloatField) (JNIEnv * env, jobject obj,
- jfieldID fieldID, jfloat value);
- void (JNICALL * SetDoubleField) (JNIEnv * env, jobject obj,
- jfieldID fieldID, jdouble value);
- 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,
- 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,
- 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,
- 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,
- 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,
- 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,
- 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,
- 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,
- 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,
- jvalue * args);
- void (JNICALL * CallStaticVoidMethod) (JNIEnv * env, jclass clazz,
- jmethodID methodID, ...);
- void (JNICALL * CallStaticVoidMethodV) (JNIEnv * env, jclass clazz,
- jmethodID methodID, va_list args);
- void (JNICALL * CallStaticVoidMethodA) (JNIEnv * env, jclass clazz,
- jmethodID methodID,
- 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 * unicodeChars,
- jsize len);
- jsize (JNICALL * GetStringLength) (JNIEnv * env, jstring string);
- const jchar *(JNICALL * GetStringChars) (JNIEnv * env, jstring string,
- jboolean * isCopy);
- void (JNICALL * ReleaseStringChars) (JNIEnv * env, jstring string,
- const jchar * utf);
- jstring (JNICALL * NewStringUTF) (JNIEnv * env, const char *bytes);
- jsize (JNICALL * GetStringUTFLength) (JNIEnv * env, jstring string);
- const char *(JNICALL * GetStringUTFChars) (JNIEnv * env, jstring string,
- jboolean * isCopy);
- void (JNICALL * ReleaseStringUTFChars) (JNIEnv * env, jstring string,
- const char *utf);
- jsize (JNICALL * GetArrayLength) (JNIEnv * env, jarray array);
- jobjectArray (JNICALL * NewObjectArray) (JNIEnv * env, jsize length,
- jclass clazz,
- jobject initialElement);
- jobject (JNICALL * GetObjectArrayElement) (JNIEnv * env,
- jobjectArray array,
- jsize index);
- void (JNICALL * SetObjectArrayElement) (JNIEnv * env, jobjectArray array,
- jsize index, jobject value);
- jbooleanArray (JNICALL * NewBooleanArray) (JNIEnv * env, jsize length);
- jbyteArray (JNICALL * NewByteArray) (JNIEnv * env, jsize length);
- jcharArray (JNICALL * NewCharArray) (JNIEnv * env, jsize length);
- jshortArray (JNICALL * NewShortArray) (JNIEnv * env, jsize length);
- jintArray (JNICALL * NewIntArray) (JNIEnv * env, jsize length);
- jlongArray (JNICALL * NewLongArray) (JNIEnv * env, jsize length);
- jfloatArray (JNICALL * NewFloatArray) (JNIEnv * env, jsize length);
- jdoubleArray (JNICALL * NewDoubleArray) (JNIEnv * env, jsize length);
- 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 len,
- 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 len,
- jboolean * buf);
- void (JNICALL * SetByteArrayRegion) (JNIEnv * env, jbyteArray array,
- jsize start, jsize len, jbyte * buf);
- void (JNICALL * SetCharArrayRegion) (JNIEnv * env, jcharArray array,
- jsize start, jsize len, jchar * buf);
- void (JNICALL * SetShortArrayRegion) (JNIEnv * env, jshortArray array,
- jsize start, jsize len,
- jshort * buf);
- void (JNICALL * SetIntArrayRegion) (JNIEnv * env, jintArray array,
- jsize start, jsize len, jint * buf);
- void (JNICALL * SetLongArrayRegion) (JNIEnv * env, jlongArray array,
- jsize start, jsize len, jlong * buf);
- void (JNICALL * SetFloatArrayRegion) (JNIEnv * env, jfloatArray array,
- jsize start, jsize len,
- jfloat * buf);
- void (JNICALL * SetDoubleArrayRegion) (JNIEnv * env, jdoubleArray array,
- jsize start, jsize len,
- 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);
- jchar *(JNICALL * GetStringCritical) (JNIEnv * env, jstring string,
- jboolean * isCopy);
- void (JNICALL * ReleaseStringCritical) (JNIEnv * env, jstring string,
- const jchar * carray);
- jweak (JNICALL * NewWeakGlobalRef) (JNIEnv * env, jobject obj);
- void (JNICALL * DeleteWeakGlobalRef) (JNIEnv * env, jweak obj);
- 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);
- };
- struct JNIEnv_
- {
+ 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 cap);
+ jobject (JNICALL *PopLocalFrame)
+ (JNIEnv *env, jobject res);
+
+ 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);
+
+ 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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,
+ 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,
+ 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,
+ 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,
+ 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,
+ 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,
+ 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,
+ 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,
+ 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,
+ 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,
+ 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, jboolean *buf);
+ void (JNICALL *SetByteArrayRegion)
+ (JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf);
+ void (JNICALL *SetCharArrayRegion)
+ (JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf);
+ void (JNICALL *SetShortArrayRegion)
+ (JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf);
+ void (JNICALL *SetIntArrayRegion)
+ (JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf);
+ void (JNICALL *SetLongArrayRegion)
+ (JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf);
+ void (JNICALL *SetFloatArrayRegion)
+ (JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf);
+ void (JNICALL *SetDoubleArrayRegion)
+ (JNIEnv *env, jdoubleArray array, jsize start, jsize len, 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, jsize, jsize, jchar*);
+ void (JNICALL *GetStringUTFRegion)
+ (JNIEnv *env, jstring, jsize, jsize, char*);
+
+ 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 s, jboolean* isCopy);
+ void (JNICALL *ReleaseStringCritical)
+ (JNIEnv *env, jstring s, const jchar* cstr);
+
+ jweak (JNICALL *NewWeakGlobalRef)
+ (JNIEnv *env, jobject obj);
+ void (JNICALL *DeleteWeakGlobalRef)
+ (JNIEnv *env, jweak obj);
+
+ 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);
+};
+
+
+/*
+ * JNI Native Interface - C++
+ */
+struct JNIEnv_External {
const struct JNINativeInterface_ *functions;
- void *reserved0;
- void *reserved1[6];
- #if defined(__cplusplus)
- jint GetVersion ()
- {
- return functions->GetVersion (this);
- }
- jclass DefineClass (const char *name, jobject loader, const jbyte * buf,
- jsize bufLen)
- {
- return functions->DefineClass (this, name, loader, buf, bufLen);
- }
- 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 clazz)
- {
- return functions->GetSuperclass (this, clazz);
- }
- jboolean IsAssignableFrom (jclass clazz1, jclass clazz2)
- {
- return functions->IsAssignableFrom (this, clazz1, clazz2);
- }
- 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 *message)
- {
- return functions->ThrowNew (this, clazz, message);
- }
- 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 obj)
- {
- return functions->NewGlobalRef (this, obj);
- }
- void DeleteGlobalRef (jobject gref)
- {
- functions->DeleteGlobalRef (this, gref);
- }
- void DeleteLocalRef (jobject localRef)
- {
- functions->DeleteLocalRef (this, localRef);
- }
- jboolean IsSameObject (jobject ref1, jobject ref2)
- {
- return functions->IsSameObject (this, ref1, ref2);
- }
- 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, ...)
- {
- jobject retval;
- va_list parms;
- va_start (parms, methodID);
- retval = functions->NewObjectV (this, clazz, methodID, parms);
- va_end (parms);
- return retval;
- }
- jobject NewObjectV (jclass clazz, jmethodID methodID, va_list args)
- {
- return functions->NewObjectV (this, clazz, methodID, args);
- }
- jobject NewObjectA (jclass clazz, jmethodID methodID, 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, ...)
- {
- jobject retval;
- va_list parms;
- va_start (parms, methodID);
- retval = functions->CallObjectMethodV (this, obj, methodID, parms);
- va_end (parms);
- return retval;
- }
- jobject CallObjectMethodV (jobject obj, jmethodID methodID, va_list args)
- {
- return functions->CallObjectMethodV (this, obj, methodID, args);
- }
- jobject CallObjectMethodA (jobject obj, jmethodID methodID, jvalue * args)
- {
- return functions->CallObjectMethodA (this, obj, methodID, args);
- }
- jboolean CallBooleanMethod (jobject obj, jmethodID methodID, ...)
- {
- jboolean retval;
- va_list parms;
- va_start (parms, methodID);
- retval = functions->CallBooleanMethodV (this, obj, methodID, parms);
- va_end (parms);
- return retval;
- }
- jboolean CallBooleanMethodV (jobject obj, jmethodID methodID,
- va_list args)
- {
- return functions->CallBooleanMethodV (this, obj, methodID, args);
- }
- jboolean CallBooleanMethodA (jobject obj, jmethodID methodID,
- jvalue * args)
- {
- return functions->CallBooleanMethodA (this, obj, methodID, args);
- }
- jbyte CallByteMethod (jobject obj, jmethodID methodID, ...)
- {
- jbyte retval;
- va_list parms;
- va_start (parms, methodID);
- retval = functions->CallByteMethodV (this, obj, methodID, parms);
- va_end (parms);
- return retval;
- }
- jbyte CallByteMethodV (jobject obj, jmethodID methodID, va_list args)
- {
- return functions->CallByteMethodV (this, obj, methodID, args);
- }
- jbyte CallByteMethodA (jobject obj, jmethodID methodID, jvalue * args)
- {
- return functions->CallByteMethodA (this, obj, methodID, args);
- }
- jchar CallCharMethod (jobject obj, jmethodID methodID, ...)
- {
- jchar retval;
- va_list parms;
- va_start (parms, methodID);
- retval = functions->CallCharMethodV (this, obj, methodID, parms);
- va_end (parms);
- return retval;
- }
- jchar CallCharMethodV (jobject obj, jmethodID methodID, va_list args)
- {
- return functions->CallCharMethodV (this, obj, methodID, args);
- }
- jchar CallCharMethodA (jobject obj, jmethodID methodID, jvalue * args)
- {
- return functions->CallCharMethodA (this, obj, methodID, args);
- }
- jshort CallShortMethod (jobject obj, jmethodID methodID, ...)
- {
- jshort retval;
- va_list parms;
- va_start (parms, methodID);
- retval = functions->CallShortMethodV (this, obj, methodID, parms);
- va_end (parms);
- return retval;
- }
- jshort CallShortMethodV (jobject obj, jmethodID methodID, va_list args)
- {
- return functions->CallShortMethodV (this, obj, methodID, args);
- }
- jshort CallShortMethodA (jobject obj, jmethodID methodID, jvalue * args)
- {
- return functions->CallShortMethodA (this, obj, methodID, args);
- }
- jint CallIntMethod (jobject obj, jmethodID methodID, ...)
- {
- jint retval;
- va_list parms;
- va_start (parms, methodID);
- retval = functions->CallIntMethodV (this, obj, methodID, parms);
- va_end (parms);
- return retval;
- }
- jint CallIntMethodV (jobject obj, jmethodID methodID, va_list args)
- {
- return functions->CallIntMethodV (this, obj, methodID, args);
- }
- jint CallIntMethodA (jobject obj, jmethodID methodID, jvalue * args)
- {
- return functions->CallIntMethodA (this, obj, methodID, args);
- }
- jlong CallLongMethod (jobject obj, jmethodID methodID, ...)
- {
- jlong retval;
- va_list parms;
- va_start (parms, methodID);
- retval = functions->CallLongMethodV (this, obj, methodID, parms);
- va_end (parms);
- return retval;
- }
- jlong CallLongMethodV (jobject obj, jmethodID methodID, va_list args)
- {
- return functions->CallLongMethodV (this, obj, methodID, args);
- }
- jlong CallLongMethodA (jobject obj, jmethodID methodID, jvalue * args)
- {
- return functions->CallLongMethodA (this, obj, methodID, args);
- }
- jfloat CallFloatMethod (jobject obj, jmethodID methodID, ...)
- {
- jfloat retval;
- va_list parms;
- va_start (parms, methodID);
- retval = functions->CallFloatMethodV (this, obj, methodID, parms);
- va_end (parms);
- return retval;
- }
- jfloat CallFloatMethodV (jobject obj, jmethodID methodID, va_list args)
- {
- return functions->CallFloatMethodV (this, obj, methodID, args);
- }
- jfloat CallFloatMethodA (jobject obj, jmethodID methodID, jvalue * args)
- {
- return functions->CallFloatMethodA (this, obj, methodID, args);
- }
- jdouble CallDoubleMethod (jobject obj, jmethodID methodID, ...)
- {
- jdouble retval;
- va_list parms;
- va_start (parms, methodID);
- retval = functions->CallDoubleMethodV (this, obj, methodID, parms);
- va_end (parms);
- return retval;
- }
- jdouble CallDoubleMethodV (jobject obj, jmethodID methodID, va_list args)
- {
- return functions->CallDoubleMethodV (this, obj, methodID, args);
- }
- jdouble CallDoubleMethodA (jobject obj, jmethodID methodID, jvalue * args)
- {
- return functions->CallDoubleMethodA (this, obj, methodID, args);
- }
- void CallVoidMethod (jobject obj, jmethodID methodID, ...)
- {
- va_list parms;
- va_start (parms, methodID);
- functions->CallVoidMethodV (this, obj, methodID, parms);
- va_end (parms);
- }
- void CallVoidMethodV (jobject obj, jmethodID methodID, va_list args)
- {
- functions->CallVoidMethodV (this, obj, methodID, args);
- }
- void CallVoidMethodA (jobject obj, jmethodID methodID, jvalue * args)
- {
- functions->CallVoidMethodA (this, obj, methodID, args);
- }
- jobject CallNonvirtualObjectMethod (jobject obj, jclass clazz,
- jmethodID methodID, ...)
- {
- jobject retval;
- va_list parms;
- va_start (parms, methodID);
- retval =
- functions->CallNonvirtualObjectMethodV (this, obj, clazz, methodID,
- parms);
- va_end (parms);
- return retval;
- }
- 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, jvalue * args)
- {
- return functions->CallNonvirtualObjectMethodA (this, obj, clazz,
- methodID, args);
- }
- jboolean CallNonvirtualBooleanMethod (jobject obj, jclass clazz,
- jmethodID methodID, ...)
- {
- jboolean retval;
- va_list parms;
- va_start (parms, methodID);
- retval =
- functions->CallNonvirtualBooleanMethodV (this, obj, clazz, methodID,
- parms);
- va_end (parms);
- return retval;
- }
- 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, jvalue * args)
- {
- return functions->CallNonvirtualBooleanMethodA (this, obj, clazz,
- methodID, args);
- }
- jbyte CallNonvirtualByteMethod (jobject obj, jclass clazz,
- jmethodID methodID, ...)
- {
- jbyte retval;
- va_list parms;
- va_start (parms, methodID);
- retval =
- functions->CallNonvirtualByteMethodV (this, obj, clazz, methodID,
- parms);
- va_end (parms);
- return retval;
- }
- 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, jvalue * args)
- {
- return functions->CallNonvirtualByteMethodA (this, obj, clazz, methodID,
- args);
- }
- jchar CallNonvirtualCharMethod (jobject obj, jclass clazz,
- jmethodID methodID, ...)
- {
- jchar retval;
- va_list parms;
- va_start (parms, methodID);
- retval =
- functions->CallNonvirtualCharMethodV (this, obj, clazz, methodID,
- parms);
- va_end (parms);
- return retval;
- }
- 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, jvalue * args)
- {
- return functions->CallNonvirtualCharMethodA (this, obj, clazz, methodID,
- args);
- }
- jshort CallNonvirtualShortMethod (jobject obj, jclass clazz,
- jmethodID methodID, ...)
- {
- jshort retval;
- va_list parms;
- va_start (parms, methodID);
- retval =
- functions->CallNonvirtualShortMethodV (this, obj, clazz, methodID,
- parms);
- va_end (parms);
- return retval;
- }
- 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, jvalue * args)
- {
- return functions->CallNonvirtualShortMethodA (this, obj, clazz,
- methodID, args);
- }
- jint CallNonvirtualIntMethod (jobject obj, jclass clazz,
- jmethodID methodID, ...)
- {
- jint retval;
- va_list parms;
- va_start (parms, methodID);
- retval =
- functions->CallNonvirtualIntMethodV (this, obj, clazz, methodID,
- parms);
- va_end (parms);
- return retval;
- }
- 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, jvalue * args)
- {
- return functions->CallNonvirtualIntMethodA (this, obj, clazz, methodID,
- args);
- }
- jlong CallNonvirtualLongMethod (jobject obj, jclass clazz,
- jmethodID methodID, ...)
- {
- jlong retval;
- va_list parms;
- va_start (parms, methodID);
- retval =
- functions->CallNonvirtualLongMethodV (this, obj, clazz, methodID,
- parms);
- va_end (parms);
- return retval;
- }
- 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, jvalue * args)
- {
- return functions->CallNonvirtualLongMethodA (this, obj, clazz, methodID,
- args);
- }
- jfloat CallNonvirtualFloatMethod (jobject obj, jclass clazz,
- jmethodID methodID, ...)
- {
- jfloat retval;
- va_list parms;
- va_start (parms, methodID);
- retval =
- functions->CallNonvirtualFloatMethodV (this, obj, clazz, methodID,
- parms);
- va_end (parms);
- return retval;
- }
- 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, jvalue * args)
- {
- return functions->CallNonvirtualFloatMethodA (this, obj, clazz,
- methodID, args);
- }
- jdouble CallNonvirtualDoubleMethod (jobject obj, jclass clazz,
- jmethodID methodID, ...)
- {
- jdouble retval;
- va_list parms;
- va_start (parms, methodID);
- retval =
- functions->CallNonvirtualDoubleMethodV (this, obj, clazz, methodID,
- parms);
- va_end (parms);
- return retval;
- }
- 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, jvalue * args)
- {
- return functions->CallNonvirtualDoubleMethodA (this, obj, clazz,
- methodID, args);
- }
- void CallNonvirtualVoidMethod (jobject obj, jclass clazz,
- jmethodID methodID, ...)
- {
- va_list parms;
- va_start (parms, methodID);
- functions->CallNonvirtualVoidMethodV (this, obj, clazz, methodID,
- parms);
- va_end (parms);
- }
- 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, 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 value)
- {
- functions->SetObjectField (this, obj, fieldID, value);
- }
- void SetBooleanField (jobject obj, jfieldID fieldID, jboolean value)
- {
- functions->SetBooleanField (this, obj, fieldID, value);
- }
- void SetByteField (jobject obj, jfieldID fieldID, jbyte value)
- {
- functions->SetByteField (this, obj, fieldID, value);
- }
- void SetCharField (jobject obj, jfieldID fieldID, jchar value)
- {
- functions->SetCharField (this, obj, fieldID, value);
- }
- void SetShortField (jobject obj, jfieldID fieldID, jshort value)
- {
- functions->SetShortField (this, obj, fieldID, value);
- }
- void SetIntField (jobject obj, jfieldID fieldID, jint value)
- {
- functions->SetIntField (this, obj, fieldID, value);
- }
- void SetLongField (jobject obj, jfieldID fieldID, jlong value)
- {
- functions->SetLongField (this, obj, fieldID, value);
- }
- void SetFloatField (jobject obj, jfieldID fieldID, jfloat value)
- {
- functions->SetFloatField (this, obj, fieldID, value);
- }
- void SetDoubleField (jobject obj, jfieldID fieldID, jdouble value)
- {
- functions->SetDoubleField (this, obj, fieldID, value);
- }
- jmethodID GetStaticMethodID (jclass clazz, const char *name,
- const char *sig)
- {
- return functions->GetStaticMethodID (this, clazz, name, sig);
- }
- jobject CallStaticObjectMethod (jclass clazz, jmethodID methodID, ...)
- {
- jobject retval;
- va_list parms;
- va_start (parms, methodID);
- retval =
- functions->CallStaticObjectMethodV (this, clazz, methodID, parms);
- va_end (parms);
- return retval;
- }
- jobject CallStaticObjectMethodV (jclass clazz, jmethodID methodID,
- va_list args)
- {
- return functions->CallStaticObjectMethodV (this, clazz, methodID, args);
- }
- jobject CallStaticObjectMethodA (jclass clazz, jmethodID methodID,
- jvalue * args)
- {
- return functions->CallStaticObjectMethodA (this, clazz, methodID, args);
- }
- jboolean CallStaticBooleanMethod (jclass clazz, jmethodID methodID, ...)
- {
- jboolean retval;
- va_list parms;
- va_start (parms, methodID);
- retval =
- functions->CallStaticBooleanMethodV (this, clazz, methodID, parms);
- va_end (parms);
- return retval;
- }
- jboolean CallStaticBooleanMethodV (jclass clazz, jmethodID methodID,
- va_list args)
- {
- return functions->CallStaticBooleanMethodV (this, clazz, methodID,
- args);
- }
- jboolean CallStaticBooleanMethodA (jclass clazz, jmethodID methodID,
- jvalue * args)
- {
- return functions->CallStaticBooleanMethodA (this, clazz, methodID,
- args);
- }
- jbyte CallStaticByteMethod (jclass clazz, jmethodID methodID, ...)
- {
- jbyte retval;
- va_list parms;
- va_start (parms, methodID);
- retval =
- functions->CallStaticByteMethodV (this, clazz, methodID, parms);
- va_end (parms);
- return retval;
- }
- jbyte CallStaticByteMethodV (jclass clazz, jmethodID methodID,
- va_list args)
- {
- return functions->CallStaticByteMethodV (this, clazz, methodID, args);
- }
- jbyte CallStaticByteMethodA (jclass clazz, jmethodID methodID,
- jvalue * args)
- {
- return functions->CallStaticByteMethodA (this, clazz, methodID, args);
- }
- jchar CallStaticCharMethod (jclass clazz, jmethodID methodID, ...)
- {
- jchar retval;
- va_list parms;
- va_start (parms, methodID);
- retval =
- functions->CallStaticCharMethodV (this, clazz, methodID, parms);
- va_end (parms);
- return retval;
- }
- jchar CallStaticCharMethodV (jclass clazz, jmethodID methodID,
- va_list args)
- {
- return functions->CallStaticCharMethodV (this, clazz, methodID, args);
- }
- jchar CallStaticCharMethodA (jclass clazz, jmethodID methodID,
- jvalue * args)
- {
- return functions->CallStaticCharMethodA (this, clazz, methodID, args);
- }
- jshort CallStaticShortMethod (jclass clazz, jmethodID methodID, ...)
- {
- jshort retval;
- va_list parms;
- va_start (parms, methodID);
- retval =
- functions->CallStaticShortMethodV (this, clazz, methodID, parms);
- va_end (parms);
- return retval;
- }
- jshort CallStaticShortMethodV (jclass clazz, jmethodID methodID,
- va_list args)
- {
- return functions->CallStaticShortMethodV (this, clazz, methodID, args);
- }
- jshort CallStaticShortMethodA (jclass clazz, jmethodID methodID,
- jvalue * args)
- {
- return functions->CallStaticShortMethodA (this, clazz, methodID, args);
- }
- jint CallStaticIntMethod (jclass clazz, jmethodID methodID, ...)
- {
- jint retval;
- va_list parms;
- va_start (parms, methodID);
- retval = functions->CallStaticIntMethodV (this, clazz, methodID, parms);
- va_end (parms);
- return retval;
- }
- jint CallStaticIntMethodV (jclass clazz, jmethodID methodID, va_list args)
- {
- return functions->CallStaticIntMethodV (this, clazz, methodID, args);
- }
- jint CallStaticIntMethodA (jclass clazz, jmethodID methodID,
- jvalue * args)
- {
- return functions->CallStaticIntMethodA (this, clazz, methodID, args);
- }
- jlong CallStaticLongMethod (jclass clazz, jmethodID methodID, ...)
- {
- jlong retval;
- va_list parms;
- va_start (parms, methodID);
- retval =
- functions->CallStaticLongMethodV (this, clazz, methodID, parms);
- va_end (parms);
- return retval;
- }
- jlong CallStaticLongMethodV (jclass clazz, jmethodID methodID,
- va_list args)
- {
- return functions->CallStaticLongMethodV (this, clazz, methodID, args);
- }
- jlong CallStaticLongMethodA (jclass clazz, jmethodID methodID,
- jvalue * args)
- {
- return functions->CallStaticLongMethodA (this, clazz, methodID, args);
- }
- jfloat CallStaticFloatMethod (jclass clazz, jmethodID methodID, ...)
- {
- jfloat retval;
- va_list parms;
- va_start (parms, methodID);
- retval =
- functions->CallStaticFloatMethodV (this, clazz, methodID, parms);
- va_end (parms);
- return retval;
- }
- jfloat CallStaticFloatMethodV (jclass clazz, jmethodID methodID,
- va_list args)
- {
- return functions->CallStaticFloatMethodV (this, clazz, methodID, args);
- }
- jfloat CallStaticFloatMethodA (jclass clazz, jmethodID methodID,
- jvalue * args)
- {
- return functions->CallStaticFloatMethodA (this, clazz, methodID, args);
- }
- jdouble CallStaticDoubleMethod (jclass clazz, jmethodID methodID, ...)
- {
- jdouble retval;
- va_list parms;
- va_start (parms, methodID);
- retval =
- functions->CallStaticDoubleMethodV (this, clazz, methodID, parms);
- va_end (parms);
- return retval;
- }
- jdouble CallStaticDoubleMethodV (jclass clazz, jmethodID methodID,
- va_list args)
- {
- return functions->CallStaticDoubleMethodV (this, clazz, methodID, args);
- }
- jdouble CallStaticDoubleMethodA (jclass clazz, jmethodID methodID,
- jvalue * args)
- {
- return functions->CallStaticDoubleMethodA (this, clazz, methodID, args);
- }
- void CallStaticVoidMethod (jclass clazz, jmethodID methodID, ...)
- {
- va_list parms;
- va_start (parms, methodID);
- functions->CallStaticVoidMethodV (this, clazz, methodID, parms);
- va_end (parms);
- }
- void CallStaticVoidMethodV (jclass clazz, jmethodID methodID,
- va_list args)
- {
- functions->CallStaticVoidMethodV (this, clazz, methodID, args);
- }
- void CallStaticVoidMethodA (jclass clazz, jmethodID methodID,
- jvalue * args)
- {
- functions->CallStaticVoidMethodA (this, clazz, 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 * unicodeChars, jsize len)
- {
- return functions->NewString (this, unicodeChars, len);
- }
- jsize GetStringLength (jstring string)
- {
- return functions->GetStringLength (this, string);
- }
- const jchar *GetStringChars (jstring string, jboolean * isCopy)
- {
- return functions->GetStringChars (this, string, isCopy);
- }
- void ReleaseStringChars (jstring string, const jchar * utf)
- {
- functions->ReleaseStringChars (this, string, utf);
- }
- jstring NewStringUTF (const char *bytes)
- {
- return functions->NewStringUTF (this, bytes);
- }
- jsize GetStringUTFLength (jstring string)
- {
- return functions->GetStringUTFLength (this, string);
- }
- const char *GetStringUTFChars (jstring string, jboolean * isCopy)
- {
- return functions->GetStringUTFChars (this, string, isCopy);
- }
- void ReleaseStringUTFChars (jstring string, const char *utf)
- {
- functions->ReleaseStringUTFChars (this, string, utf);
- }
- jsize GetArrayLength (jarray array)
- {
- return functions->GetArrayLength (this, array);
- }
- jobjectArray NewObjectArray (jsize length, jclass clazz,
- jobject initialElement)
- {
- return functions->NewObjectArray (this, length, clazz, initialElement);
- }
- jobject GetObjectArrayElement (jobjectArray array, jsize index)
- {
- return functions->GetObjectArrayElement (this, array, index);
- }
- void SetObjectArrayElement (jobjectArray array, jsize index,
- jobject value)
- {
- functions->SetObjectArrayElement (this, array, index, value);
- }
- jbooleanArray NewBooleanArray (jsize length)
- {
- return functions->NewBooleanArray (this, length);
- }
- jbyteArray NewByteArray (jsize length)
- {
- return functions->NewByteArray (this, length);
- }
- jcharArray NewCharArray (jsize length)
- {
- return functions->NewCharArray (this, length);
- }
- jshortArray NewShortArray (jsize length)
- {
- return functions->NewShortArray (this, length);
- }
- jintArray NewIntArray (jsize length)
- {
- return functions->NewIntArray (this, length);
- }
- jlongArray NewLongArray (jsize length)
- {
- return functions->NewLongArray (this, length);
- }
- jfloatArray NewFloatArray (jsize length)
- {
- return functions->NewFloatArray (this, length);
- }
- jdoubleArray NewDoubleArray (jsize length)
- {
- return functions->NewDoubleArray (this, length);
- }
- 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)
- {
[... 1438 lines stripped ...]