WebSVN – Kolibri OS – Blame – /contrib/menuetlibc/openjpeg/JavaOpenJPEG/java-jni/include/jni.h

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

Subversion Repositories Kolibri OS

(root)/contrib/menuetlibc/openjpeg/JavaOpenJPEG/java-jni/include/jni.h – Rev 4758