Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members  

jni.h

Go to the documentation of this file.
00001 /*
00002  * @(#)jni.h    1.48 00/02/02
00003  *
00004  * Copyright 1996-2000 Sun Microsystems, Inc. All Rights Reserved.
00005  * 
00006  * This software is the proprietary information of Sun Microsystems, Inc.  
00007  * Use is subject to license terms.
00008  * 
00009  */
00010 
00011 /*
00012  * We used part of Netscape's Java Runtime Interface (JRI) as the starting
00013  * point of our design and implementation.
00014  */
00015 
00016 /******************************************************************************
00017  * Java Runtime Interface
00018  * Copyright (c) 1996 Netscape Communications Corporation. All rights reserved.
00019  *****************************************************************************/
00020 
00021 #ifndef _JAVASOFT_JNI_H_
00022 #define _JAVASOFT_JNI_H_
00023 
00024 #include <stdio.h>
00025 #include <stdarg.h>
00026 
00027 /* jni_md.h contains the machine-dependent typedefs for jbyte, jint
00028    and jlong */
00029 
00030 #include "jni_md.h"
00031 
00032 #ifdef __cplusplus
00033 extern "C" {
00034 #endif
00035 
00036 /*
00037  * JNI Types
00038  */
00039 
00040 #ifndef JNI_TYPES_ALREADY_DEFINED_IN_JNI_MD_H
00041 
00042 typedef unsigned char   jboolean;
00043 typedef unsigned short  jchar;
00044 typedef short       jshort;
00045 typedef float       jfloat;
00046 typedef double      jdouble;
00047 
00048 typedef jint            jsize;
00049 
00050 #ifdef __cplusplus
00051 
00052 class _jobject {};
00053 class _jclass : public _jobject {};
00054 class _jthrowable : public _jobject {};
00055 class _jstring : public _jobject {};
00056 class _jarray : public _jobject {};
00057 class _jbooleanArray : public _jarray {};
00058 class _jbyteArray : public _jarray {};
00059 class _jcharArray : public _jarray {};
00060 class _jshortArray : public _jarray {};
00061 class _jintArray : public _jarray {};
00062 class _jlongArray : public _jarray {};
00063 class _jfloatArray : public _jarray {};
00064 class _jdoubleArray : public _jarray {};
00065 class _jobjectArray : public _jarray {};
00066 
00067 typedef _jobject *jobject;
00068 typedef _jclass *jclass;
00069 typedef _jthrowable *jthrowable;
00070 typedef _jstring *jstring;
00071 typedef _jarray *jarray;
00072 typedef _jbooleanArray *jbooleanArray;
00073 typedef _jbyteArray *jbyteArray;
00074 typedef _jcharArray *jcharArray;
00075 typedef _jshortArray *jshortArray;
00076 typedef _jintArray *jintArray;
00077 typedef _jlongArray *jlongArray;
00078 typedef _jfloatArray *jfloatArray;
00079 typedef _jdoubleArray *jdoubleArray;
00080 typedef _jobjectArray *jobjectArray;
00081 
00082 #else
00083 
00084 struct _jobject;
00085 
00086 typedef struct _jobject *jobject;
00087 typedef jobject jclass;
00088 typedef jobject jthrowable;
00089 typedef jobject jstring;
00090 typedef jobject jarray;
00091 typedef jarray jbooleanArray;
00092 typedef jarray jbyteArray;
00093 typedef jarray jcharArray;
00094 typedef jarray jshortArray;
00095 typedef jarray jintArray;
00096 typedef jarray jlongArray;
00097 typedef jarray jfloatArray;
00098 typedef jarray jdoubleArray;
00099 typedef jarray jobjectArray;
00100 
00101 #endif
00102 
00103 typedef jobject jweak;
00104 
00105 typedef union jvalue {
00106     jboolean z;
00107     jbyte    b;
00108     jchar    c;
00109     jshort   s;
00110     jint     i;
00111     jlong    j;
00112     jfloat   f;
00113     jdouble  d;
00114     jobject  l;
00115 } jvalue;
00116 
00117 struct _jfieldID;
00118 typedef struct _jfieldID *jfieldID;
00119 
00120 struct _jmethodID;
00121 typedef struct _jmethodID *jmethodID;
00122 
00123 #endif /* JNI_TYPES_ALREADY_DEFINED_IN_JNI_MD_H */
00124 
00125 /*
00126  * jboolean constants
00127  */
00128 
00129 #define JNI_FALSE 0
00130 #define JNI_TRUE 1
00131 
00132 /*
00133  * possible return values for JNI functions.
00134  */
00135 
00136 #define JNI_OK           0                 /* success */
00137 #define JNI_ERR          (-1)              /* unknown error */
00138 #define JNI_EDETACHED    (-2)              /* thread detached from the VM */
00139 #define JNI_EVERSION     (-3)              /* JNI version error */
00140 #define JNI_ENOMEM       (-4)              /* not enough memory */
00141 #define JNI_EEXIST       (-5)              /* VM already created */
00142 #define JNI_EINVAL       (-6)              /* invalid arguments */
00143 
00144 /*
00145  * used in ReleaseScalarArrayElements
00146  */
00147 
00148 #define JNI_COMMIT 1
00149 #define JNI_ABORT 2
00150 
00151 /*
00152  * used in RegisterNatives to describe native method name, signature,
00153  * and function pointer.
00154  */
00155 
00156 typedef struct {
00157     char *name;
00158     char *signature;
00159     void *fnPtr;
00160 } JNINativeMethod;
00161 
00162 /*
00163  * JNI Native Method Interface.
00164  */
00165 
00166 struct JNINativeInterface_;
00167 
00168 struct JNIEnv_;
00169 
00170 #ifdef __cplusplus
00171 typedef JNIEnv_ JNIEnv;
00172 #else
00173 typedef const struct JNINativeInterface_ *JNIEnv;
00174 #endif
00175 
00176 /*
00177  * JNI Invocation Interface.
00178  */
00179 
00180 struct JNIInvokeInterface_;
00181 
00182 struct JavaVM_;
00183 
00184 #ifdef __cplusplus
00185 typedef JavaVM_ JavaVM;
00186 #else
00187 typedef const struct JNIInvokeInterface_ *JavaVM;
00188 #endif
00189 
00190 struct JNINativeInterface_ {
00191     void *reserved0;
00192     void *reserved1;
00193     void *reserved2;
00194 
00195     void *reserved3;
00196     jint (JNICALL *GetVersion)(JNIEnv *env);
00197 
00198     jclass (JNICALL *DefineClass)
00199       (JNIEnv *env, const char *name, jobject loader, const jbyte *buf,
00200        jsize len);
00201     jclass (JNICALL *FindClass)
00202       (JNIEnv *env, const char *name);
00203 
00204     jmethodID (JNICALL *FromReflectedMethod)
00205       (JNIEnv *env, jobject method);
00206     jfieldID (JNICALL *FromReflectedField)
00207       (JNIEnv *env, jobject field);
00208 
00209     jobject (JNICALL *ToReflectedMethod)
00210       (JNIEnv *env, jclass cls, jmethodID methodID, jboolean isStatic);
00211 
00212     jclass (JNICALL *GetSuperclass)
00213       (JNIEnv *env, jclass sub);
00214     jboolean (JNICALL *IsAssignableFrom)
00215       (JNIEnv *env, jclass sub, jclass sup);
00216 
00217     jobject (JNICALL *ToReflectedField)
00218       (JNIEnv *env, jclass cls, jfieldID fieldID, jboolean isStatic);
00219 
00220     jint (JNICALL *Throw)
00221       (JNIEnv *env, jthrowable obj);
00222     jint (JNICALL *ThrowNew)
00223       (JNIEnv *env, jclass clazz, const char *msg);
00224     jthrowable (JNICALL *ExceptionOccurred)
00225       (JNIEnv *env);
00226     void (JNICALL *ExceptionDescribe)
00227       (JNIEnv *env);
00228     void (JNICALL *ExceptionClear)
00229       (JNIEnv *env);
00230     void (JNICALL *FatalError)
00231       (JNIEnv *env, const char *msg);
00232 
00233     jint (JNICALL *PushLocalFrame)
00234       (JNIEnv *env, jint capacity);
00235     jobject (JNICALL *PopLocalFrame)
00236       (JNIEnv *env, jobject result);
00237 
00238     jobject (JNICALL *NewGlobalRef)
00239       (JNIEnv *env, jobject lobj);
00240     void (JNICALL *DeleteGlobalRef)
00241       (JNIEnv *env, jobject gref);
00242     void (JNICALL *DeleteLocalRef)
00243       (JNIEnv *env, jobject obj);
00244     jboolean (JNICALL *IsSameObject)
00245       (JNIEnv *env, jobject obj1, jobject obj2);
00246     jobject (JNICALL *NewLocalRef)
00247       (JNIEnv *env, jobject ref);
00248     jint (JNICALL *EnsureLocalCapacity)
00249       (JNIEnv *env, jint capacity);
00250 
00251     jobject (JNICALL *AllocObject)
00252       (JNIEnv *env, jclass clazz);
00253     jobject (JNICALL *NewObject)
00254       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
00255     jobject (JNICALL *NewObjectV)
00256       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
00257     jobject (JNICALL *NewObjectA)
00258       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
00259 
00260     jclass (JNICALL *GetObjectClass)
00261       (JNIEnv *env, jobject obj);
00262     jboolean (JNICALL *IsInstanceOf)
00263       (JNIEnv *env, jobject obj, jclass clazz);
00264 
00265     jmethodID (JNICALL *GetMethodID)
00266       (JNIEnv *env, jclass clazz, const char *name, const char *sig);
00267 
00268     jobject (JNICALL *CallObjectMethod)
00269       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
00270     jobject (JNICALL *CallObjectMethodV)
00271       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
00272     jobject (JNICALL *CallObjectMethodA)
00273       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args);
00274 
00275     jboolean (JNICALL *CallBooleanMethod)
00276       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
00277     jboolean (JNICALL *CallBooleanMethodV)
00278       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
00279     jboolean (JNICALL *CallBooleanMethodA)
00280       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args);
00281 
00282     jbyte (JNICALL *CallByteMethod)
00283       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
00284     jbyte (JNICALL *CallByteMethodV)
00285       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
00286     jbyte (JNICALL *CallByteMethodA)
00287       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
00288 
00289     jchar (JNICALL *CallCharMethod)
00290       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
00291     jchar (JNICALL *CallCharMethodV)
00292       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
00293     jchar (JNICALL *CallCharMethodA)
00294       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
00295 
00296     jshort (JNICALL *CallShortMethod)
00297       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
00298     jshort (JNICALL *CallShortMethodV)
00299       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
00300     jshort (JNICALL *CallShortMethodA)
00301       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
00302 
00303     jint (JNICALL *CallIntMethod)
00304       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
00305     jint (JNICALL *CallIntMethodV)
00306       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
00307     jint (JNICALL *CallIntMethodA)
00308       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
00309 
00310     jlong (JNICALL *CallLongMethod)
00311       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
00312     jlong (JNICALL *CallLongMethodV)
00313       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
00314     jlong (JNICALL *CallLongMethodA)
00315       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
00316 
00317     jfloat (JNICALL *CallFloatMethod)
00318       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
00319     jfloat (JNICALL *CallFloatMethodV)
00320       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
00321     jfloat (JNICALL *CallFloatMethodA)
00322       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
00323 
00324     jdouble (JNICALL *CallDoubleMethod)
00325       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
00326     jdouble (JNICALL *CallDoubleMethodV)
00327       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
00328     jdouble (JNICALL *CallDoubleMethodA)
00329       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
00330 
00331     void (JNICALL *CallVoidMethod)
00332       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
00333     void (JNICALL *CallVoidMethodV)
00334       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
00335     void (JNICALL *CallVoidMethodA)
00336       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args);
00337 
00338     jobject (JNICALL *CallNonvirtualObjectMethod)
00339       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
00340     jobject (JNICALL *CallNonvirtualObjectMethodV)
00341       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00342        va_list args);
00343     jobject (JNICALL *CallNonvirtualObjectMethodA)
00344       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00345        jvalue * args);
00346 
00347     jboolean (JNICALL *CallNonvirtualBooleanMethod)
00348       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
00349     jboolean (JNICALL *CallNonvirtualBooleanMethodV)
00350       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00351        va_list args);
00352     jboolean (JNICALL *CallNonvirtualBooleanMethodA)
00353       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00354        jvalue * args);
00355 
00356     jbyte (JNICALL *CallNonvirtualByteMethod)
00357       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
00358     jbyte (JNICALL *CallNonvirtualByteMethodV)
00359       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00360        va_list args);
00361     jbyte (JNICALL *CallNonvirtualByteMethodA)
00362       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00363        jvalue *args);
00364 
00365     jchar (JNICALL *CallNonvirtualCharMethod)
00366       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
00367     jchar (JNICALL *CallNonvirtualCharMethodV)
00368       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00369        va_list args);
00370     jchar (JNICALL *CallNonvirtualCharMethodA)
00371       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00372        jvalue *args);
00373 
00374     jshort (JNICALL *CallNonvirtualShortMethod)
00375       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
00376     jshort (JNICALL *CallNonvirtualShortMethodV)
00377       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00378        va_list args);
00379     jshort (JNICALL *CallNonvirtualShortMethodA)
00380       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00381        jvalue *args);
00382 
00383     jint (JNICALL *CallNonvirtualIntMethod)
00384       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
00385     jint (JNICALL *CallNonvirtualIntMethodV)
00386       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00387        va_list args);
00388     jint (JNICALL *CallNonvirtualIntMethodA)
00389       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00390        jvalue *args);
00391 
00392     jlong (JNICALL *CallNonvirtualLongMethod)
00393       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
00394     jlong (JNICALL *CallNonvirtualLongMethodV)
00395       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00396        va_list args);
00397     jlong (JNICALL *CallNonvirtualLongMethodA)
00398       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00399        jvalue *args);
00400 
00401     jfloat (JNICALL *CallNonvirtualFloatMethod)
00402       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
00403     jfloat (JNICALL *CallNonvirtualFloatMethodV)
00404       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00405        va_list args);
00406     jfloat (JNICALL *CallNonvirtualFloatMethodA)
00407       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00408        jvalue *args);
00409 
00410     jdouble (JNICALL *CallNonvirtualDoubleMethod)
00411       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
00412     jdouble (JNICALL *CallNonvirtualDoubleMethodV)
00413       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00414        va_list args);
00415     jdouble (JNICALL *CallNonvirtualDoubleMethodA)
00416       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00417        jvalue *args);
00418 
00419     void (JNICALL *CallNonvirtualVoidMethod)
00420       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
00421     void (JNICALL *CallNonvirtualVoidMethodV)
00422       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00423        va_list args);
00424     void (JNICALL *CallNonvirtualVoidMethodA)
00425       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00426        jvalue * args);
00427 
00428     jfieldID (JNICALL *GetFieldID)
00429       (JNIEnv *env, jclass clazz, const char *name, const char *sig);
00430 
00431     jobject (JNICALL *GetObjectField)
00432       (JNIEnv *env, jobject obj, jfieldID fieldID);
00433     jboolean (JNICALL *GetBooleanField)
00434       (JNIEnv *env, jobject obj, jfieldID fieldID);
00435     jbyte (JNICALL *GetByteField)
00436       (JNIEnv *env, jobject obj, jfieldID fieldID);
00437     jchar (JNICALL *GetCharField)
00438       (JNIEnv *env, jobject obj, jfieldID fieldID);
00439     jshort (JNICALL *GetShortField)
00440       (JNIEnv *env, jobject obj, jfieldID fieldID);
00441     jint (JNICALL *GetIntField)
00442       (JNIEnv *env, jobject obj, jfieldID fieldID);
00443     jlong (JNICALL *GetLongField)
00444       (JNIEnv *env, jobject obj, jfieldID fieldID);
00445     jfloat (JNICALL *GetFloatField)
00446       (JNIEnv *env, jobject obj, jfieldID fieldID);
00447     jdouble (JNICALL *GetDoubleField)
00448       (JNIEnv *env, jobject obj, jfieldID fieldID);
00449 
00450     void (JNICALL *SetObjectField)
00451       (JNIEnv *env, jobject obj, jfieldID fieldID, jobject val);
00452     void (JNICALL *SetBooleanField)
00453       (JNIEnv *env, jobject obj, jfieldID fieldID, jboolean val);
00454     void (JNICALL *SetByteField)
00455       (JNIEnv *env, jobject obj, jfieldID fieldID, jbyte val);
00456     void (JNICALL *SetCharField)
00457       (JNIEnv *env, jobject obj, jfieldID fieldID, jchar val);
00458     void (JNICALL *SetShortField)
00459       (JNIEnv *env, jobject obj, jfieldID fieldID, jshort val);
00460     void (JNICALL *SetIntField)
00461       (JNIEnv *env, jobject obj, jfieldID fieldID, jint val);
00462     void (JNICALL *SetLongField)
00463       (JNIEnv *env, jobject obj, jfieldID fieldID, jlong val);
00464     void (JNICALL *SetFloatField)
00465       (JNIEnv *env, jobject obj, jfieldID fieldID, jfloat val);
00466     void (JNICALL *SetDoubleField)
00467       (JNIEnv *env, jobject obj, jfieldID fieldID, jdouble val);
00468 
00469     jmethodID (JNICALL *GetStaticMethodID)
00470       (JNIEnv *env, jclass clazz, const char *name, const char *sig);
00471 
00472     jobject (JNICALL *CallStaticObjectMethod)
00473       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
00474     jobject (JNICALL *CallStaticObjectMethodV)
00475       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
00476     jobject (JNICALL *CallStaticObjectMethodA)
00477       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
00478 
00479     jboolean (JNICALL *CallStaticBooleanMethod)
00480       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
00481     jboolean (JNICALL *CallStaticBooleanMethodV)
00482       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
00483     jboolean (JNICALL *CallStaticBooleanMethodA)
00484       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
00485 
00486     jbyte (JNICALL *CallStaticByteMethod)
00487       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
00488     jbyte (JNICALL *CallStaticByteMethodV)
00489       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
00490     jbyte (JNICALL *CallStaticByteMethodA)
00491       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
00492 
00493     jchar (JNICALL *CallStaticCharMethod)
00494       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
00495     jchar (JNICALL *CallStaticCharMethodV)
00496       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
00497     jchar (JNICALL *CallStaticCharMethodA)
00498       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
00499 
00500     jshort (JNICALL *CallStaticShortMethod)
00501       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
00502     jshort (JNICALL *CallStaticShortMethodV)
00503       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
00504     jshort (JNICALL *CallStaticShortMethodA)
00505       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
00506 
00507     jint (JNICALL *CallStaticIntMethod)
00508       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
00509     jint (JNICALL *CallStaticIntMethodV)
00510       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
00511     jint (JNICALL *CallStaticIntMethodA)
00512       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
00513 
00514     jlong (JNICALL *CallStaticLongMethod)
00515       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
00516     jlong (JNICALL *CallStaticLongMethodV)
00517       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
00518     jlong (JNICALL *CallStaticLongMethodA)
00519       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
00520 
00521     jfloat (JNICALL *CallStaticFloatMethod)
00522       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
00523     jfloat (JNICALL *CallStaticFloatMethodV)
00524       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
00525     jfloat (JNICALL *CallStaticFloatMethodA)
00526       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
00527 
00528     jdouble (JNICALL *CallStaticDoubleMethod)
00529       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
00530     jdouble (JNICALL *CallStaticDoubleMethodV)
00531       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
00532     jdouble (JNICALL *CallStaticDoubleMethodA)
00533       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
00534 
00535     void (JNICALL *CallStaticVoidMethod)
00536       (JNIEnv *env, jclass cls, jmethodID methodID, ...);
00537     void (JNICALL *CallStaticVoidMethodV)
00538       (JNIEnv *env, jclass cls, jmethodID methodID, va_list args);
00539     void (JNICALL *CallStaticVoidMethodA)
00540       (JNIEnv *env, jclass cls, jmethodID methodID, jvalue * args);
00541 
00542     jfieldID (JNICALL *GetStaticFieldID)
00543       (JNIEnv *env, jclass clazz, const char *name, const char *sig);
00544     jobject (JNICALL *GetStaticObjectField)
00545       (JNIEnv *env, jclass clazz, jfieldID fieldID);
00546     jboolean (JNICALL *GetStaticBooleanField)
00547       (JNIEnv *env, jclass clazz, jfieldID fieldID);
00548     jbyte (JNICALL *GetStaticByteField)
00549       (JNIEnv *env, jclass clazz, jfieldID fieldID);
00550     jchar (JNICALL *GetStaticCharField)
00551       (JNIEnv *env, jclass clazz, jfieldID fieldID);
00552     jshort (JNICALL *GetStaticShortField)
00553       (JNIEnv *env, jclass clazz, jfieldID fieldID);
00554     jint (JNICALL *GetStaticIntField)
00555       (JNIEnv *env, jclass clazz, jfieldID fieldID);
00556     jlong (JNICALL *GetStaticLongField)
00557       (JNIEnv *env, jclass clazz, jfieldID fieldID);
00558     jfloat (JNICALL *GetStaticFloatField)
00559       (JNIEnv *env, jclass clazz, jfieldID fieldID);
00560     jdouble (JNICALL *GetStaticDoubleField)
00561       (JNIEnv *env, jclass clazz, jfieldID fieldID);
00562 
00563     void (JNICALL *SetStaticObjectField)
00564       (JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value);
00565     void (JNICALL *SetStaticBooleanField)
00566       (JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value);
00567     void (JNICALL *SetStaticByteField)
00568       (JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value);
00569     void (JNICALL *SetStaticCharField)
00570       (JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value);
00571     void (JNICALL *SetStaticShortField)
00572       (JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value);
00573     void (JNICALL *SetStaticIntField)
00574       (JNIEnv *env, jclass clazz, jfieldID fieldID, jint value);
00575     void (JNICALL *SetStaticLongField)
00576       (JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value);
00577     void (JNICALL *SetStaticFloatField)
00578       (JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value);
00579     void (JNICALL *SetStaticDoubleField)
00580       (JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value);
00581 
00582     jstring (JNICALL *NewString)
00583       (JNIEnv *env, const jchar *unicode, jsize len);
00584     jsize (JNICALL *GetStringLength)
00585       (JNIEnv *env, jstring str);
00586     const jchar *(JNICALL *GetStringChars)
00587       (JNIEnv *env, jstring str, jboolean *isCopy);
00588     void (JNICALL *ReleaseStringChars)
00589       (JNIEnv *env, jstring str, const jchar *chars);
00590 
00591     jstring (JNICALL *NewStringUTF)
00592       (JNIEnv *env, const char *utf);
00593     jsize (JNICALL *GetStringUTFLength)
00594       (JNIEnv *env, jstring str);
00595     const char* (JNICALL *GetStringUTFChars)
00596       (JNIEnv *env, jstring str, jboolean *isCopy);
00597     void (JNICALL *ReleaseStringUTFChars)
00598       (JNIEnv *env, jstring str, const char* chars);
00599 
00600 
00601     jsize (JNICALL *GetArrayLength)
00602       (JNIEnv *env, jarray array);
00603 
00604     jobjectArray (JNICALL *NewObjectArray)
00605       (JNIEnv *env, jsize len, jclass clazz, jobject init);
00606     jobject (JNICALL *GetObjectArrayElement)
00607       (JNIEnv *env, jobjectArray array, jsize index);
00608     void (JNICALL *SetObjectArrayElement)
00609       (JNIEnv *env, jobjectArray array, jsize index, jobject val);
00610 
00611     jbooleanArray (JNICALL *NewBooleanArray)
00612       (JNIEnv *env, jsize len);
00613     jbyteArray (JNICALL *NewByteArray)
00614       (JNIEnv *env, jsize len);
00615     jcharArray (JNICALL *NewCharArray)
00616       (JNIEnv *env, jsize len);
00617     jshortArray (JNICALL *NewShortArray)
00618       (JNIEnv *env, jsize len);
00619     jintArray (JNICALL *NewIntArray)
00620       (JNIEnv *env, jsize len);
00621     jlongArray (JNICALL *NewLongArray)
00622       (JNIEnv *env, jsize len);
00623     jfloatArray (JNICALL *NewFloatArray)
00624       (JNIEnv *env, jsize len);
00625     jdoubleArray (JNICALL *NewDoubleArray)
00626       (JNIEnv *env, jsize len);
00627 
00628     jboolean * (JNICALL *GetBooleanArrayElements)
00629       (JNIEnv *env, jbooleanArray array, jboolean *isCopy);
00630     jbyte * (JNICALL *GetByteArrayElements)
00631       (JNIEnv *env, jbyteArray array, jboolean *isCopy);
00632     jchar * (JNICALL *GetCharArrayElements)
00633       (JNIEnv *env, jcharArray array, jboolean *isCopy);
00634     jshort * (JNICALL *GetShortArrayElements)
00635       (JNIEnv *env, jshortArray array, jboolean *isCopy);
00636     jint * (JNICALL *GetIntArrayElements)
00637       (JNIEnv *env, jintArray array, jboolean *isCopy);
00638     jlong * (JNICALL *GetLongArrayElements)
00639       (JNIEnv *env, jlongArray array, jboolean *isCopy);
00640     jfloat * (JNICALL *GetFloatArrayElements)
00641       (JNIEnv *env, jfloatArray array, jboolean *isCopy);
00642     jdouble * (JNICALL *GetDoubleArrayElements)
00643       (JNIEnv *env, jdoubleArray array, jboolean *isCopy);
00644 
00645     void (JNICALL *ReleaseBooleanArrayElements)
00646       (JNIEnv *env, jbooleanArray array, jboolean *elems, jint mode);
00647     void (JNICALL *ReleaseByteArrayElements)
00648       (JNIEnv *env, jbyteArray array, jbyte *elems, jint mode);
00649     void (JNICALL *ReleaseCharArrayElements)
00650       (JNIEnv *env, jcharArray array, jchar *elems, jint mode);
00651     void (JNICALL *ReleaseShortArrayElements)
00652       (JNIEnv *env, jshortArray array, jshort *elems, jint mode);
00653     void (JNICALL *ReleaseIntArrayElements)
00654       (JNIEnv *env, jintArray array, jint *elems, jint mode);
00655     void (JNICALL *ReleaseLongArrayElements)
00656       (JNIEnv *env, jlongArray array, jlong *elems, jint mode);
00657     void (JNICALL *ReleaseFloatArrayElements)
00658       (JNIEnv *env, jfloatArray array, jfloat *elems, jint mode);
00659     void (JNICALL *ReleaseDoubleArrayElements)
00660       (JNIEnv *env, jdoubleArray array, jdouble *elems, jint mode);
00661 
00662     void (JNICALL *GetBooleanArrayRegion)
00663       (JNIEnv *env, jbooleanArray array, jsize start, jsize l, jboolean *buf);
00664     void (JNICALL *GetByteArrayRegion)
00665       (JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf);
00666     void (JNICALL *GetCharArrayRegion)
00667       (JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf);
00668     void (JNICALL *GetShortArrayRegion)
00669       (JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf);
00670     void (JNICALL *GetIntArrayRegion)
00671       (JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf);
00672     void (JNICALL *GetLongArrayRegion)
00673       (JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf);
00674     void (JNICALL *GetFloatArrayRegion)
00675       (JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf);
00676     void (JNICALL *GetDoubleArrayRegion)
00677       (JNIEnv *env, jdoubleArray array, jsize start, jsize len, jdouble *buf);
00678 
00679     void (JNICALL *SetBooleanArrayRegion)
00680       (JNIEnv *env, jbooleanArray array, jsize start, jsize l, jboolean *buf);
00681     void (JNICALL *SetByteArrayRegion)
00682       (JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf);
00683     void (JNICALL *SetCharArrayRegion)
00684       (JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf);
00685     void (JNICALL *SetShortArrayRegion)
00686       (JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf);
00687     void (JNICALL *SetIntArrayRegion)
00688       (JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf);
00689     void (JNICALL *SetLongArrayRegion)
00690       (JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf);
00691     void (JNICALL *SetFloatArrayRegion)
00692       (JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf);
00693     void (JNICALL *SetDoubleArrayRegion)
00694       (JNIEnv *env, jdoubleArray array, jsize start, jsize len, jdouble *buf);
00695 
00696     jint (JNICALL *RegisterNatives)
00697       (JNIEnv *env, jclass clazz, const JNINativeMethod *methods,
00698        jint nMethods);
00699     jint (JNICALL *UnregisterNatives)
00700       (JNIEnv *env, jclass clazz);
00701 
00702     jint (JNICALL *MonitorEnter)
00703       (JNIEnv *env, jobject obj);
00704     jint (JNICALL *MonitorExit)
00705       (JNIEnv *env, jobject obj);
00706 
00707     jint (JNICALL *GetJavaVM)
00708       (JNIEnv *env, JavaVM **vm);
00709 
00710     void (JNICALL *GetStringRegion)
00711       (JNIEnv *env, jstring str, jsize start, jsize len, jchar *buf);
00712     void (JNICALL *GetStringUTFRegion)
00713       (JNIEnv *env, jstring str, jsize start, jsize len, char *buf);
00714 
00715     void * (JNICALL *GetPrimitiveArrayCritical)
00716       (JNIEnv *env, jarray array, jboolean *isCopy);
00717     void (JNICALL *ReleasePrimitiveArrayCritical)
00718       (JNIEnv *env, jarray array, void *carray, jint mode);
00719 
00720     const jchar * (JNICALL *GetStringCritical)
00721       (JNIEnv *env, jstring string, jboolean *isCopy);
00722     void (JNICALL *ReleaseStringCritical)
00723       (JNIEnv *env, jstring string, const jchar *cstring);
00724 
00725     jweak (JNICALL *NewWeakGlobalRef)
00726        (JNIEnv *env, jobject obj);
00727     void (JNICALL *DeleteWeakGlobalRef)
00728        (JNIEnv *env, jweak ref);
00729 
00730     jboolean (JNICALL *ExceptionCheck)
00731        (JNIEnv *env);
00732 };
00733 
00734 /*
00735  * We use inlined functions for C++ so that programmers can write:
00736  *
00737  *    env->FindClass("java/lang/String")
00738  *
00739  * in C++ rather than:
00740  *
00741  *    (*env)->FindClass(env, "java/lang/String")
00742  *
00743  * in C.
00744  */
00745 
00746 struct JNIEnv_ {
00747     const struct JNINativeInterface_ *functions;
00748 #ifdef __cplusplus
00749 
00750     jint GetVersion() {
00751         return functions->GetVersion(this);
00752     }
00753     jclass DefineClass(const char *name, jobject loader, const jbyte *buf,
00754                jsize len) {
00755         return functions->DefineClass(this, name, loader, buf, len);
00756     }
00757     jclass FindClass(const char *name) {
00758         return functions->FindClass(this, name);
00759     }
00760     jmethodID FromReflectedMethod(jobject method) {
00761         return functions->FromReflectedMethod(this,method);
00762     }
00763     jfieldID FromReflectedField(jobject field) {
00764         return functions->FromReflectedField(this,field);
00765     }
00766 
00767     jobject ToReflectedMethod(jclass cls, jmethodID methodID, jboolean isStatic) {
00768         return functions->ToReflectedMethod(this, cls, methodID, isStatic);
00769     }
00770 
00771     jclass GetSuperclass(jclass sub) {
00772         return functions->GetSuperclass(this, sub);
00773     }
00774     jboolean IsAssignableFrom(jclass sub, jclass sup) {
00775         return functions->IsAssignableFrom(this, sub, sup);
00776     }
00777 
00778     jobject ToReflectedField(jclass cls, jfieldID fieldID, jboolean isStatic) {
00779         return functions->ToReflectedField(this,cls,fieldID,isStatic);
00780     }
00781 
00782     jint Throw(jthrowable obj) {
00783         return functions->Throw(this, obj);
00784     }
00785     jint ThrowNew(jclass clazz, const char *msg) {
00786         return functions->ThrowNew(this, clazz, msg);
00787     }
00788     jthrowable ExceptionOccurred() {
00789         return functions->ExceptionOccurred(this);
00790     }
00791     void ExceptionDescribe() {
00792         functions->ExceptionDescribe(this);
00793     }
00794     void ExceptionClear() {
00795         functions->ExceptionClear(this);
00796     }
00797     void FatalError(const char *msg) {
00798         functions->FatalError(this, msg);
00799     }
00800 
00801     jint PushLocalFrame(jint capacity) {
00802         return functions->PushLocalFrame(this,capacity);
00803     }
00804     jobject PopLocalFrame(jobject result) {
00805         return functions->PopLocalFrame(this,result);
00806     }
00807 
00808     jobject NewGlobalRef(jobject lobj) {
00809         return functions->NewGlobalRef(this,lobj);
00810     }
00811     void DeleteGlobalRef(jobject gref) {
00812         functions->DeleteGlobalRef(this,gref);
00813     }
00814     void DeleteLocalRef(jobject obj) {
00815         functions->DeleteLocalRef(this, obj);
00816     }
00817 
00818     jboolean IsSameObject(jobject obj1, jobject obj2) {
00819         return functions->IsSameObject(this,obj1,obj2);
00820     }
00821 
00822     jobject NewLocalRef(jobject ref) {
00823         return functions->NewLocalRef(this,ref);
00824     }
00825     jint EnsureLocalCapacity(jint capacity) {
00826         return functions->EnsureLocalCapacity(this,capacity);
00827     }
00828 
00829     jobject AllocObject(jclass clazz) {
00830         return functions->AllocObject(this,clazz);
00831     }
00832     jobject NewObject(jclass clazz, jmethodID methodID, ...) {
00833         va_list args;
00834     jobject result;
00835     va_start(args, methodID);
00836         result = functions->NewObjectV(this,clazz,methodID,args);
00837     va_end(args);
00838     return result;
00839     }
00840     jobject NewObjectV(jclass clazz, jmethodID methodID,
00841                va_list args) {
00842         return functions->NewObjectV(this,clazz,methodID,args);
00843     }
00844     jobject NewObjectA(jclass clazz, jmethodID methodID,
00845                jvalue *args) {
00846         return functions->NewObjectA(this,clazz,methodID,args);
00847     }
00848 
00849     jclass GetObjectClass(jobject obj) {
00850         return functions->GetObjectClass(this,obj);
00851     }
00852     jboolean IsInstanceOf(jobject obj, jclass clazz) {
00853         return functions->IsInstanceOf(this,obj,clazz);
00854     }
00855 
00856     jmethodID GetMethodID(jclass clazz, const char *name,
00857               const char *sig) {
00858         return functions->GetMethodID(this,clazz,name,sig);
00859     }
00860 
00861     jobject CallObjectMethod(jobject obj, jmethodID methodID, ...) {
00862         va_list args;
00863     jobject result;
00864     va_start(args,methodID);
00865     result = functions->CallObjectMethodV(this,obj,methodID,args);
00866     va_end(args);
00867     return result;
00868     }
00869     jobject CallObjectMethodV(jobject obj, jmethodID methodID,
00870             va_list args) {
00871         return functions->CallObjectMethodV(this,obj,methodID,args);
00872     }
00873     jobject CallObjectMethodA(jobject obj, jmethodID methodID,
00874             jvalue * args) {
00875         return functions->CallObjectMethodA(this,obj,methodID,args);
00876     }
00877 
00878     jboolean CallBooleanMethod(jobject obj,
00879                    jmethodID methodID, ...) {
00880         va_list args;
00881     jboolean result;
00882     va_start(args,methodID);
00883     result = functions->CallBooleanMethodV(this,obj,methodID,args);
00884     va_end(args);
00885     return result;
00886     }
00887     jboolean CallBooleanMethodV(jobject obj, jmethodID methodID,
00888                 va_list args) {
00889         return functions->CallBooleanMethodV(this,obj,methodID,args);
00890     }
00891     jboolean CallBooleanMethodA(jobject obj, jmethodID methodID,
00892                 jvalue * args) {
00893         return functions->CallBooleanMethodA(this,obj,methodID, args);
00894     }
00895 
00896     jbyte CallByteMethod(jobject obj, jmethodID methodID, ...) {
00897         va_list args;
00898     jbyte result;
00899     va_start(args,methodID);
00900     result = functions->CallByteMethodV(this,obj,methodID,args);
00901     va_end(args);
00902     return result;
00903     }
00904     jbyte CallByteMethodV(jobject obj, jmethodID methodID,
00905               va_list args) {
00906         return functions->CallByteMethodV(this,obj,methodID,args);
00907     }
00908     jbyte CallByteMethodA(jobject obj, jmethodID methodID,
00909               jvalue * args) {
00910         return functions->CallByteMethodA(this,obj,methodID,args);
00911     }
00912 
00913     jchar CallCharMethod(jobject obj, jmethodID methodID, ...) {
00914         va_list args;
00915     jchar result;
00916     va_start(args,methodID);
00917     result = functions->CallCharMethodV(this,obj,methodID,args);
00918     va_end(args);
00919     return result;
00920     }
00921     jchar CallCharMethodV(jobject obj, jmethodID methodID,
00922               va_list args) {
00923         return functions->CallCharMethodV(this,obj,methodID,args);
00924     }
00925     jchar CallCharMethodA(jobject obj, jmethodID methodID,
00926               jvalue * args) {
00927         return functions->CallCharMethodA(this,obj,methodID,args);
00928     }
00929 
00930     jshort CallShortMethod(jobject obj, jmethodID methodID, ...) {
00931         va_list args;
00932     jshort result;
00933     va_start(args,methodID);
00934     result = functions->CallShortMethodV(this,obj,methodID,args);
00935     va_end(args);
00936     return result;
00937     }
00938     jshort CallShortMethodV(jobject obj, jmethodID methodID,
00939                 va_list args) {
00940         return functions->CallShortMethodV(this,obj,methodID,args);
00941     }
00942     jshort CallShortMethodA(jobject obj, jmethodID methodID,
00943                 jvalue * args) {
00944         return functions->CallShortMethodA(this,obj,methodID,args);
00945     }
00946 
00947     jint CallIntMethod(jobject obj, jmethodID methodID, ...) {
00948         va_list args;
00949     jint result;
00950     va_start(args,methodID);
00951     result = functions->CallIntMethodV(this,obj,methodID,args);
00952     va_end(args);
00953     return result;
00954     }
00955     jint CallIntMethodV(jobject obj, jmethodID methodID,
00956             va_list args) {
00957         return functions->CallIntMethodV(this,obj,methodID,args);
00958     }
00959     jint CallIntMethodA(jobject obj, jmethodID methodID,
00960             jvalue * args) {
00961         return functions->CallIntMethodA(this,obj,methodID,args);
00962     }
00963 
00964     jlong CallLongMethod(jobject obj, jmethodID methodID, ...) {
00965         va_list args;
00966     jlong result;
00967     va_start(args,methodID);
00968     result = functions->CallLongMethodV(this,obj,methodID,args);
00969     va_end(args);
00970     return result;
00971     }
00972     jlong CallLongMethodV(jobject obj, jmethodID methodID,
00973               va_list args) {
00974         return functions->CallLongMethodV(this,obj,methodID,args);
00975     }
00976     jlong CallLongMethodA(jobject obj, jmethodID methodID,
00977               jvalue * args) {
00978         return functions->CallLongMethodA(this,obj,methodID,args);
00979     }
00980 
00981     jfloat CallFloatMethod(jobject obj, jmethodID methodID, ...) {
00982         va_list args;
00983     jfloat result;
00984     va_start(args,methodID);
00985     result = functions->CallFloatMethodV(this,obj,methodID,args);
00986     va_end(args);
00987     return result;
00988     }
00989     jfloat CallFloatMethodV(jobject obj, jmethodID methodID,
00990                 va_list args) {
00991         return functions->CallFloatMethodV(this,obj,methodID,args);
00992     }
00993     jfloat CallFloatMethodA(jobject obj, jmethodID methodID,
00994                 jvalue * args) {
00995         return functions->CallFloatMethodA(this,obj,methodID,args);
00996     }
00997 
00998     jdouble CallDoubleMethod(jobject obj, jmethodID methodID, ...) {
00999         va_list args;
01000     jdouble result;
01001     va_start(args,methodID);
01002     result = functions->CallDoubleMethodV(this,obj,methodID,args);
01003     va_end(args);
01004     return result;
01005     }
01006     jdouble CallDoubleMethodV(jobject obj, jmethodID methodID,
01007             va_list args) {
01008         return functions->CallDoubleMethodV(this,obj,methodID,args);
01009     }
01010     jdouble CallDoubleMethodA(jobject obj, jmethodID methodID,
01011             jvalue * args) {
01012         return functions->CallDoubleMethodA(this,obj,methodID,args);
01013     }
01014 
01015     void CallVoidMethod(jobject obj, jmethodID methodID, ...) {
01016         va_list args;
01017     va_start(args,methodID);
01018     functions->CallVoidMethodV(this,obj,methodID,args);
01019     va_end(args);
01020     }
01021     void CallVoidMethodV(jobject obj, jmethodID methodID,
01022              va_list args) {
01023         functions->CallVoidMethodV(this,obj,methodID,args);
01024     }
01025     void CallVoidMethodA(jobject obj, jmethodID methodID,
01026              jvalue * args) {
01027         functions->CallVoidMethodA(this,obj,methodID,args);
01028     }
01029 
01030     jobject CallNonvirtualObjectMethod(jobject obj, jclass clazz,
01031                        jmethodID methodID, ...) {
01032         va_list args;
01033     jobject result;
01034     va_start(args,methodID);
01035     result = functions->CallNonvirtualObjectMethodV(this,obj,clazz,
01036                             methodID,args);
01037     va_end(args);
01038     return result;
01039     }
01040     jobject CallNonvirtualObjectMethodV(jobject obj, jclass clazz,
01041                     jmethodID methodID, va_list args) {
01042         return functions->CallNonvirtualObjectMethodV(this,obj,clazz,
01043                               methodID,args);
01044     }
01045     jobject CallNonvirtualObjectMethodA(jobject obj, jclass clazz,
01046                     jmethodID methodID, jvalue * args) {
01047         return functions->CallNonvirtualObjectMethodA(this,obj,clazz,
01048                               methodID,args);
01049     }
01050 
01051     jboolean CallNonvirtualBooleanMethod(jobject obj, jclass clazz,
01052                      jmethodID methodID, ...) {
01053         va_list args;
01054     jboolean result;
01055     va_start(args,methodID);
01056     result = functions->CallNonvirtualBooleanMethodV(this,obj,clazz,
01057                              methodID,args);
01058     va_end(args);
01059     return result;
01060     }
01061     jboolean CallNonvirtualBooleanMethodV(jobject obj, jclass clazz,
01062                       jmethodID methodID, va_list args) {
01063         return functions->CallNonvirtualBooleanMethodV(this,obj,clazz,
01064                                methodID,args);
01065     }
01066     jboolean CallNonvirtualBooleanMethodA(jobject obj, jclass clazz,
01067                       jmethodID methodID, jvalue * args) {
01068         return functions->CallNonvirtualBooleanMethodA(this,obj,clazz,
01069                                methodID, args);
01070     }
01071 
01072     jbyte CallNonvirtualByteMethod(jobject obj, jclass clazz,
01073                    jmethodID methodID, ...) {
01074         va_list args;
01075     jbyte result;
01076     va_start(args,methodID);
01077     result = functions->CallNonvirtualByteMethodV(this,obj,clazz,
01078                               methodID,args);
01079     va_end(args);
01080     return result;
01081     }
01082     jbyte CallNonvirtualByteMethodV(jobject obj, jclass clazz,
01083                     jmethodID methodID, va_list args) {
01084         return functions->CallNonvirtualByteMethodV(this,obj,clazz,
01085                             methodID,args);
01086     }
01087     jbyte CallNonvirtualByteMethodA(jobject obj, jclass clazz,
01088                     jmethodID methodID, jvalue * args) {
01089         return functions->CallNonvirtualByteMethodA(this,obj,clazz,
01090                             methodID,args);
01091     }
01092 
01093     jchar CallNonvirtualCharMethod(jobject obj, jclass clazz,
01094                    jmethodID methodID, ...) {
01095         va_list args;
01096     jchar result;
01097     va_start(args,methodID);
01098     result = functions->CallNonvirtualCharMethodV(this,obj,clazz,
01099                               methodID,args);
01100     va_end(args);
01101     return result;
01102     }
01103     jchar CallNonvirtualCharMethodV(jobject obj, jclass clazz,
01104                     jmethodID methodID, va_list args) {
01105         return functions->CallNonvirtualCharMethodV(this,obj,clazz,
01106                             methodID,args);
01107     }
01108     jchar CallNonvirtualCharMethodA(jobject obj, jclass clazz,
01109                     jmethodID methodID, jvalue * args) {
01110         return functions->CallNonvirtualCharMethodA(this,obj,clazz,
01111                             methodID,args);
01112     }
01113 
01114     jshort CallNonvirtualShortMethod(jobject obj, jclass clazz,
01115                      jmethodID methodID, ...) {
01116         va_list args;
01117     jshort result;
01118     va_start(args,methodID);
01119     result = functions->CallNonvirtualShortMethodV(this,obj,clazz,
01120                                methodID,args);
01121     va_end(args);
01122     return result;
01123     }
01124     jshort CallNonvirtualShortMethodV(jobject obj, jclass clazz,
01125                       jmethodID methodID, va_list args) {
01126         return functions->CallNonvirtualShortMethodV(this,obj,clazz,
01127                              methodID,args);
01128     }
01129     jshort CallNonvirtualShortMethodA(jobject obj, jclass clazz,
01130                       jmethodID methodID, jvalue * args) {
01131         return functions->CallNonvirtualShortMethodA(this,obj,clazz,
01132                              methodID,args);
01133     }
01134 
01135     jint CallNonvirtualIntMethod(jobject obj, jclass clazz,
01136                  jmethodID methodID, ...) {
01137         va_list args;
01138     jint result;
01139     va_start(args,methodID);
01140     result = functions->CallNonvirtualIntMethodV(this,obj,clazz,
01141                              methodID,args);
01142     va_end(args);
01143     return result;
01144     }
01145     jint CallNonvirtualIntMethodV(jobject obj, jclass clazz,
01146                   jmethodID methodID, va_list args) {
01147         return functions->CallNonvirtualIntMethodV(this,obj,clazz,
01148                            methodID,args);
01149     }
01150     jint CallNonvirtualIntMethodA(jobject obj, jclass clazz,
01151                   jmethodID methodID, jvalue * args) {
01152         return functions->CallNonvirtualIntMethodA(this,obj,clazz,
01153                            methodID,args);
01154     }
01155 
01156     jlong CallNonvirtualLongMethod(jobject obj, jclass clazz,
01157                    jmethodID methodID, ...) {
01158         va_list args;
01159     jlong result;
01160     va_start(args,methodID);
01161     result = functions->CallNonvirtualLongMethodV(this,obj,clazz,
01162                               methodID,args);
01163     va_end(args);
01164     return result;
01165     }
01166     jlong CallNonvirtualLongMethodV(jobject obj, jclass clazz,
01167                     jmethodID methodID, va_list args) {
01168         return functions->CallNonvirtualLongMethodV(this,obj,clazz,
01169                             methodID,args);
01170     }
01171     jlong CallNonvirtualLongMethodA(jobject obj, jclass clazz,
01172                     jmethodID methodID, jvalue * args) {
01173         return functions->CallNonvirtualLongMethodA(this,obj,clazz,
01174                             methodID,args);
01175     }
01176 
01177     jfloat CallNonvirtualFloatMethod(jobject obj, jclass clazz,
01178                      jmethodID methodID, ...) {
01179         va_list args;
01180     jfloat result;
01181     va_start(args,methodID);
01182     result = functions->CallNonvirtualFloatMethodV(this,obj,clazz,
01183                                methodID,args);
01184     va_end(args);
01185     return result;
01186     }
01187     jfloat CallNonvirtualFloatMethodV(jobject obj, jclass clazz,
01188                       jmethodID methodID,
01189                       va_list args) {
01190         return functions->CallNonvirtualFloatMethodV(this,obj,clazz,
01191                              methodID,args);
01192     }
01193     jfloat CallNonvirtualFloatMethodA(jobject obj, jclass clazz,
01194                       jmethodID methodID,
01195                       jvalue * args) {
01196         return functions->CallNonvirtualFloatMethodA(this,obj,clazz,
01197                              methodID,args);
01198     }
01199 
01200     jdouble CallNonvirtualDoubleMethod(jobject obj, jclass clazz,
01201                        jmethodID methodID, ...) {
01202         va_list args;
01203     jdouble result;
01204     va_start(args,methodID);
01205     result = functions->CallNonvirtualDoubleMethodV(this,obj,clazz,
01206                             methodID,args);
01207     va_end(args);
01208     return result;
01209     }
01210     jdouble CallNonvirtualDoubleMethodV(jobject obj, jclass clazz,
01211                     jmethodID methodID,
01212                     va_list args) {
01213         return functions->CallNonvirtualDoubleMethodV(this,obj,clazz,
01214                               methodID,args);
01215     }
01216     jdouble CallNonvirtualDoubleMethodA(jobject obj, jclass clazz,
01217                     jmethodID methodID,
01218                     jvalue * args) {
01219         return functions->CallNonvirtualDoubleMethodA(this,obj,clazz,
01220                               methodID,args);
01221     }
01222 
01223     void CallNonvirtualVoidMethod(jobject obj, jclass clazz,
01224                   jmethodID methodID, ...) {
01225         va_list args;
01226     va_start(args,methodID);
01227     functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);
01228     va_end(args);
01229     }
01230     void CallNonvirtualVoidMethodV(jobject obj, jclass clazz,
01231                    jmethodID methodID,
01232                    va_list args) {
01233         functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);
01234     }
01235     void CallNonvirtualVoidMethodA(jobject obj, jclass clazz,
01236                    jmethodID methodID,
01237                    jvalue * args) {
01238         functions->CallNonvirtualVoidMethodA(this,obj,clazz,methodID,args);
01239     }
01240 
01241     jfieldID GetFieldID(jclass clazz, const char *name,
01242             const char *sig) {
01243         return functions->GetFieldID(this,clazz,name,sig);
01244     }
01245 
01246     jobject GetObjectField(jobject obj, jfieldID fieldID) {
01247         return functions->GetObjectField(this,obj,fieldID);
01248     }
01249     jboolean GetBooleanField(jobject obj, jfieldID fieldID) {
01250         return functions->GetBooleanField(this,obj,fieldID);
01251     }
01252     jbyte GetByteField(jobject obj, jfieldID fieldID) {
01253         return functions->GetByteField(this,obj,fieldID);
01254     }
01255     jchar GetCharField(jobject obj, jfieldID fieldID) {
01256         return functions->GetCharField(this,obj,fieldID);
01257     }
01258     jshort GetShortField(jobject obj, jfieldID fieldID) {
01259         return functions->GetShortField(this,obj,fieldID);
01260     }
01261     jint GetIntField(jobject obj, jfieldID fieldID) {
01262         return functions->GetIntField(this,obj,fieldID);
01263     }
01264     jlong GetLongField(jobject obj, jfieldID fieldID) {
01265         return functions->GetLongField(this,obj,fieldID);
01266     }
01267     jfloat GetFloatField(jobject obj, jfieldID fieldID) {
01268         return functions->GetFloatField(this,obj,fieldID);
01269     }
01270     jdouble GetDoubleField(jobject obj, jfieldID fieldID) {
01271         return functions->GetDoubleField(this,obj,fieldID);
01272     }
01273 
01274     void SetObjectField(jobject obj, jfieldID fieldID, jobject val) {
01275         functions->SetObjectField(this,obj,fieldID,val);
01276     }
01277     void SetBooleanField(jobject obj, jfieldID fieldID,
01278              jboolean val) {
01279         functions->SetBooleanField(this,obj,fieldID,val);
01280     }
01281     void SetByteField(jobject obj, jfieldID fieldID,
01282               jbyte val) {
01283         functions->SetByteField(this,obj,fieldID,val);
01284     }
01285     void SetCharField(jobject obj, jfieldID fieldID,
01286               jchar val) {
01287         functions->SetCharField(this,obj,fieldID,val);
01288     }
01289     void SetShortField(jobject obj, jfieldID fieldID,
01290                jshort val) {
01291         functions->SetShortField(this,obj,fieldID,val);
01292     }
01293     void SetIntField(jobject obj, jfieldID fieldID,
01294              jint val) {
01295         functions->SetIntField(this,obj,fieldID,val);
01296     }
01297     void SetLongField(jobject obj, jfieldID fieldID,
01298               jlong val) {
01299         functions->SetLongField(this,obj,fieldID,val);
01300     }
01301     void SetFloatField(jobject obj, jfieldID fieldID,
01302                jfloat val) {
01303         functions->SetFloatField(this,obj,fieldID,val);
01304     }
01305     void SetDoubleField(jobject obj, jfieldID fieldID,
01306             jdouble val) {
01307         functions->SetDoubleField(this,obj,fieldID,val);
01308     }
01309 
01310     jmethodID GetStaticMethodID(jclass clazz, const char *name,
01311                 const char *sig) {
01312         return functions->GetStaticMethodID(this,clazz,name,sig);
01313     }
01314 
01315     jobject CallStaticObjectMethod(jclass clazz, jmethodID methodID,
01316                  ...) {
01317         va_list args;
01318     jobject result;
01319     va_start(args,methodID);
01320     result = functions->CallStaticObjectMethodV(this,clazz,methodID,args);
01321     va_end(args);
01322     return result;
01323     }
01324     jobject CallStaticObjectMethodV(jclass clazz, jmethodID methodID,
01325                   va_list args) {
01326         return functions->CallStaticObjectMethodV(this,clazz,methodID,args);
01327     }
01328     jobject CallStaticObjectMethodA(jclass clazz, jmethodID methodID,
01329                   jvalue *args) {
01330         return functions->CallStaticObjectMethodA(this,clazz,methodID,args);
01331     }
01332 
01333     jboolean CallStaticBooleanMethod(jclass clazz,
01334                      jmethodID methodID, ...) {
01335         va_list args;
01336     jboolean result;
01337     va_start(args,methodID);
01338     result = functions->CallStaticBooleanMethodV(this,clazz,methodID,args);
01339     va_end(args);
01340     return result;
01341     }
01342     jboolean CallStaticBooleanMethodV(jclass clazz,
01343                       jmethodID methodID, va_list args) {
01344         return functions->CallStaticBooleanMethodV(this,clazz,methodID,args);
01345     }
01346     jboolean CallStaticBooleanMethodA(jclass clazz,
01347                       jmethodID methodID, jvalue *args) {
01348         return functions->CallStaticBooleanMethodA(this,clazz,methodID,args);
01349     }
01350 
01351     jbyte CallStaticByteMethod(jclass clazz,
01352                    jmethodID methodID, ...) {
01353         va_list args;
01354     jbyte result;
01355     va_start(args,methodID);
01356     result = functions->CallStaticByteMethodV(this,clazz,methodID,args);
01357     va_end(args);
01358     return result;
01359     }
01360     jbyte CallStaticByteMethodV(jclass clazz,
01361                 jmethodID methodID, va_list args) {
01362         return functions->CallStaticByteMethodV(this,clazz,methodID,args);
01363     }
01364     jbyte CallStaticByteMethodA(jclass clazz,
01365                 jmethodID methodID, jvalue *args) {
01366         return functions->CallStaticByteMethodA(this,clazz,methodID,args);
01367     }
01368 
01369     jchar CallStaticCharMethod(jclass clazz,
01370                    jmethodID methodID, ...) {
01371         va_list args;
01372     jchar result;
01373     va_start(args,methodID);
01374     result = functions->CallStaticCharMethodV(this,clazz,methodID,args);
01375     va_end(args);
01376     return result;
01377     }
01378     jchar CallStaticCharMethodV(jclass clazz,
01379                 jmethodID methodID, va_list args) {
01380         return functions->CallStaticCharMethodV(this,clazz,methodID,args);
01381     }
01382     jchar CallStaticCharMethodA(jclass clazz,
01383                 jmethodID methodID, jvalue *args) {
01384         return functions->CallStaticCharMethodA(this,clazz,methodID,args);
01385     }
01386 
01387     jshort CallStaticShortMethod(jclass clazz,
01388                  jmethodID methodID, ...) {
01389         va_list args;
01390     jshort result;
01391     va_start(args,methodID);
01392     result = functions->CallStaticShortMethodV(this,clazz,methodID,args);
01393     va_end(args);
01394     return result;
01395     }
01396     jshort CallStaticShortMethodV(jclass clazz,
01397                   jmethodID methodID, va_list args) {
01398         return functions->CallStaticShortMethodV(this,clazz,methodID,args);
01399     }
01400     jshort CallStaticShortMethodA(jclass clazz,
01401                   jmethodID methodID, jvalue *args) {
01402         return functions->CallStaticShortMethodA(this,clazz,methodID,args);
01403     }
01404 
01405     jint CallStaticIntMethod(jclass clazz,
01406                  jmethodID methodID, ...) {
01407         va_list args;
01408     jint result;
01409     va_start(args,methodID);
01410     result = functions->CallStaticIntMethodV(this,clazz,methodID,args);
01411     va_end(args);
01412     return result;
01413     }
01414     jint CallStaticIntMethodV(jclass clazz,
01415                   jmethodID methodID, va_list args) {
01416         return functions->CallStaticIntMethodV(this,clazz,methodID,args);
01417     }
01418     jint CallStaticIntMethodA(jclass clazz,
01419                   jmethodID methodID, jvalue *args) {
01420         return functions->CallStaticIntMethodA(this,clazz,methodID,args);
01421     }
01422 
01423     jlong CallStaticLongMethod(jclass clazz,
01424                    jmethodID methodID, ...) {
01425         va_list args;
01426     jlong result;
01427     va_start(args,methodID);
01428     result = functions->CallStaticLongMethodV(this,clazz,methodID,args);
01429     va_end(args);
01430     return result;
01431     }
01432     jlong CallStaticLongMethodV(jclass clazz,
01433                 jmethodID methodID, va_list args) {
01434         return functions->CallStaticLongMethodV(this,clazz,methodID,args);
01435     }
01436     jlong CallStaticLongMethodA(jclass clazz,
01437                 jmethodID methodID, jvalue *args) {
01438         return functions->CallStaticLongMethodA(this,clazz,methodID,args);
01439     }
01440 
01441     jfloat CallStaticFloatMethod(jclass clazz,
01442                  jmethodID methodID, ...) {
01443         va_list args;
01444     jfloat result;
01445     va_start(args,methodID);
01446     result = functions->CallStaticFloatMethodV(this,clazz,methodID,args);
01447     va_end(args);
01448     return result;
01449     }
01450     jfloat CallStaticFloatMethodV(jclass clazz,
01451                   jmethodID methodID, va_list args) {
01452         return functions->CallStaticFloatMethodV(this,clazz,methodID,args);
01453     }
01454     jfloat CallStaticFloatMethodA(jclass clazz,
01455                   jmethodID methodID, jvalue *args) {
01456         return functions->CallStaticFloatMethodA(this,clazz,methodID,args);
01457     }
01458 
01459     jdouble CallStaticDoubleMethod(jclass clazz,
01460                    jmethodID methodID, ...) {
01461         va_list args;
01462     jdouble result;
01463     va_start(args,methodID);
01464     result = functions->CallStaticDoubleMethodV(this,clazz,methodID,args);
01465     va_end(args);
01466     return result;
01467     }
01468     jdouble CallStaticDoubleMethodV(jclass clazz,
01469                     jmethodID methodID, va_list args) {
01470         return functions->CallStaticDoubleMethodV(this,clazz,methodID,args);
01471     }
01472     jdouble CallStaticDoubleMethodA(jclass clazz,
01473                     jmethodID methodID, jvalue *args) {
01474         return functions->CallStaticDoubleMethodA(this,clazz,methodID,args);
01475     }
01476 
01477     void CallStaticVoidMethod(jclass cls, jmethodID methodID, ...) {
01478         va_list args;
01479     va_start(args,methodID);
01480     functions->CallStaticVoidMethodV(this,cls,methodID,args);
01481     va_end(args);
01482     }
01483     void CallStaticVoidMethodV(jclass cls, jmethodID methodID,
01484                    va_list args) {
01485         functions->CallStaticVoidMethodV(this,cls,methodID,args);
01486     }
01487     void CallStaticVoidMethodA(jclass cls, jmethodID methodID,
01488                    jvalue * args) {
01489         functions->CallStaticVoidMethodA(this,cls,methodID,args);
01490     }
01491 
01492     jfieldID GetStaticFieldID(jclass clazz, const char *name,
01493                   const char *sig) {
01494         return functions->GetStaticFieldID(this,clazz,name,sig);
01495     }
01496     jobject GetStaticObjectField(jclass clazz, jfieldID fieldID) {
01497         return functions->GetStaticObjectField(this,clazz,fieldID);
01498     }
01499     jboolean GetStaticBooleanField(jclass clazz, jfieldID fieldID) {
01500         return functions->GetStaticBooleanField(this,clazz,fieldID);
01501     }
01502     jbyte GetStaticByteField(jclass clazz, jfieldID fieldID) {
01503         return functions->GetStaticByteField(this,clazz,fieldID);
01504     }
01505     jchar GetStaticCharField(jclass clazz, jfieldID fieldID) {
01506         return functions->GetStaticCharField(this,clazz,fieldID);
01507     }
01508     jshort GetStaticShortField(jclass clazz, jfieldID fieldID) {
01509         return functions->GetStaticShortField(this,clazz,fieldID);
01510     }
01511     jint GetStaticIntField(jclass clazz, jfieldID fieldID) {
01512         return functions->GetStaticIntField(this,clazz,fieldID);
01513     }
01514     jlong GetStaticLongField(jclass clazz, jfieldID fieldID) {
01515         return functions->GetStaticLongField(this,clazz,fieldID);
01516     }
01517     jfloat GetStaticFloatField(jclass clazz, jfieldID fieldID) {
01518         return functions->GetStaticFloatField(this,clazz,fieldID);
01519     }
01520     jdouble GetStaticDoubleField(jclass clazz, jfieldID fieldID) {
01521         return functions->GetStaticDoubleField(this,clazz,fieldID);
01522     }
01523 
01524     void SetStaticObjectField(jclass clazz, jfieldID fieldID,
01525             jobject value) {
01526       functions->SetStaticObjectField(this,clazz,fieldID,value);
01527     }
01528     void SetStaticBooleanField(jclass clazz, jfieldID fieldID,
01529             jboolean value) {
01530       functions->SetStaticBooleanField(this,clazz,fieldID,value);
01531     }
01532     void SetStaticByteField(jclass clazz, jfieldID fieldID,
01533             jbyte value) {
01534       functions->SetStaticByteField(this,clazz,fieldID,value);
01535     }
01536     void SetStaticCharField(jclass clazz, jfieldID fieldID,
01537             jchar value) {
01538       functions->SetStaticCharField(this,clazz,fieldID,value);
01539     }
01540     void SetStaticShortField(jclass clazz, jfieldID fieldID,
01541             jshort value) {
01542       functions->SetStaticShortField(this,clazz,fieldID,value);
01543     }
01544     void SetStaticIntField(jclass clazz, jfieldID fieldID,
01545             jint value) {
01546       functions->SetStaticIntField(this,clazz,fieldID,value);
01547     }
01548     void SetStaticLongField(jclass clazz, jfieldID fieldID,
01549             jlong value) {
01550       functions->SetStaticLongField(this,clazz,fieldID,value);
01551     }
01552     void SetStaticFloatField(jclass clazz, jfieldID fieldID,
01553             jfloat value) {
01554       functions->SetStaticFloatField(this,clazz,fieldID,value);
01555     }
01556     void SetStaticDoubleField(jclass clazz, jfieldID fieldID,
01557             jdouble value) {
01558       functions->SetStaticDoubleField(this,clazz,fieldID,value);
01559     }
01560 
01561     jstring NewString(const jchar *unicode, jsize len) {
01562         return functions->NewString(this,unicode,len);
01563     }
01564     jsize GetStringLength(jstring str) {
01565         return functions->GetStringLength(this,str);
01566     }
01567     const jchar *GetStringChars(jstring str, jboolean *isCopy) {
01568         return functions->GetStringChars(this,str,isCopy);
01569     }
01570     void ReleaseStringChars(jstring str, const jchar *chars) {
01571         functions->ReleaseStringChars(this,str,chars);
01572     }
01573 
01574     jstring NewStringUTF(const char *utf) {
01575         return functions->NewStringUTF(this,utf);
01576     }
01577     jsize GetStringUTFLength(jstring str) {
01578         return functions->GetStringUTFLength(this,str);
01579     }
01580     const char* GetStringUTFChars(jstring str, jboolean *isCopy) {
01581         return functions->GetStringUTFChars(this,str,isCopy);
01582     }
01583     void ReleaseStringUTFChars(jstring str, const char* chars) {
01584         functions->ReleaseStringUTFChars(this,str,chars);
01585     }
01586 
01587     jsize GetArrayLength(jarray array) {
01588         return functions->GetArrayLength(this,array);
01589     }
01590 
01591     jobjectArray NewObjectArray(jsize len, jclass clazz,
01592                 jobject init) {
01593         return functions->NewObjectArray(this,len,clazz,init);
01594     }
01595     jobject GetObjectArrayElement(jobjectArray array, jsize index) {
01596         return functions->GetObjectArrayElement(this,array,index);
01597     }
01598     void SetObjectArrayElement(jobjectArray array, jsize index,
01599                    jobject val) {
01600         functions->SetObjectArrayElement(this,array,index,val);
01601     }
01602 
01603     jbooleanArray NewBooleanArray(jsize len) {
01604         return functions->NewBooleanArray(this,len);
01605     }
01606     jbyteArray NewByteArray(jsize len) {
01607         return functions->NewByteArray(this,len);
01608     }
01609     jcharArray NewCharArray(jsize len) {
01610         return functions->NewCharArray(this,len);
01611     }
01612     jshortArray NewShortArray(jsize len) {
01613         return functions->NewShortArray(this,len);
01614     }
01615     jintArray NewIntArray(jsize len) {
01616         return functions->NewIntArray(this,len);
01617     }
01618     jlongArray NewLongArray(jsize len) {
01619         return functions->NewLongArray(this,len);
01620     }
01621     jfloatArray NewFloatArray(jsize len) {
01622         return functions->NewFloatArray(this,len);
01623     }
01624     jdoubleArray NewDoubleArray(jsize len) {
01625         return functions->NewDoubleArray(this,len);
01626     }
01627 
01628     jboolean * GetBooleanArrayElements(jbooleanArray array, jboolean *isCopy) {
01629         return functions->GetBooleanArrayElements(this,array,isCopy);
01630     }
01631     jbyte * GetByteArrayElements(jbyteArray array, jboolean *isCopy) {
01632         return functions->GetByteArrayElements(this,array,isCopy);
01633     }
01634     jchar * GetCharArrayElements(jcharArray array, jboolean *isCopy) {
01635         return functions->GetCharArrayElements(this,array,isCopy);
01636     }
01637     jshort * GetShortArrayElements(jshortArray array, jboolean *isCopy) {
01638         return functions->GetShortArrayElements(this,array,isCopy);
01639     }
01640     jint * GetIntArrayElements(jintArray array, jboolean *isCopy) {
01641         return functions->GetIntArrayElements(this,array,isCopy);
01642     }
01643     jlong * GetLongArrayElements(jlongArray array, jboolean *isCopy) {
01644         return functions->GetLongArrayElements(this,array,isCopy);
01645     }
01646     jfloat * GetFloatArrayElements(jfloatArray array, jboolean *isCopy) {
01647         return functions->GetFloatArrayElements(this,array,isCopy);
01648     }
01649     jdouble * GetDoubleArrayElements(jdoubleArray array, jboolean *isCopy) {
01650         return functions->GetDoubleArrayElements(this,array,isCopy);
01651     }
01652 
01653     void ReleaseBooleanArrayElements(jbooleanArray array,
01654                      jboolean *elems,
01655                      jint mode) {
01656         functions->ReleaseBooleanArrayElements(this,array,elems,mode);
01657     }
01658     void ReleaseByteArrayElements(jbyteArray array,
01659                   jbyte *elems,
01660                   jint mode) {
01661         functions->ReleaseByteArrayElements(this,array,elems,mode);
01662     }
01663     void ReleaseCharArrayElements(jcharArray array,
01664                   jchar *elems,
01665                   jint mode) {
01666         functions->ReleaseCharArrayElements(this,array,elems,mode);
01667     }
01668     void ReleaseShortArrayElements(jshortArray array,
01669                    jshort *elems,
01670                    jint mode) {
01671         functions->ReleaseShortArrayElements(this,array,elems,mode);
01672     }
01673     void ReleaseIntArrayElements(jintArray array,
01674                  jint *elems,
01675                  jint mode) {
01676         functions->ReleaseIntArrayElements(this,array,elems,mode);
01677     }
01678     void ReleaseLongArrayElements(jlongArray array,
01679                   jlong *elems,
01680                   jint mode) {
01681         functions->ReleaseLongArrayElements(this,array,elems,mode);
01682     }
01683     void ReleaseFloatArrayElements(jfloatArray array,
01684                    jfloat *elems,
01685                    jint mode) {
01686         functions->ReleaseFloatArrayElements(this,array,elems,mode);
01687     }
01688     void ReleaseDoubleArrayElements(jdoubleArray array,
01689                     jdouble *elems,
01690                     jint mode) {
01691         functions->ReleaseDoubleArrayElements(this,array,elems,mode);
01692     }
01693 
01694     void GetBooleanArrayRegion(jbooleanArray array,
01695                    jsize start, jsize len, jboolean *buf) {
01696         functions->GetBooleanArrayRegion(this,array,start,len,buf);
01697     }
01698     void GetByteArrayRegion(jbyteArray array,
01699                 jsize start, jsize len, jbyte *buf) {
01700         functions->GetByteArrayRegion(this,array,start,len,buf);
01701     }
01702     void GetCharArrayRegion(jcharArray array,
01703                 jsize start, jsize len, jchar *buf) {
01704         functions->GetCharArrayRegion(this,array,start,len,buf);
01705     }
01706     void GetShortArrayRegion(jshortArray array,
01707                  jsize start, jsize len, jshort *buf) {
01708         functions->GetShortArrayRegion(this,array,start,len,buf);
01709     }
01710     void GetIntArrayRegion(jintArray array,
01711                jsize start, jsize len, jint *buf) {
01712         functions->GetIntArrayRegion(this,array,start,len,buf);
01713     }
01714     void GetLongArrayRegion(jlongArray array,
01715                 jsize start, jsize len, jlong *buf) {
01716         functions->GetLongArrayRegion(this,array,start,len,buf);
01717     }
01718     void GetFloatArrayRegion(jfloatArray array,
01719                  jsize start, jsize len, jfloat *buf) {
01720         functions->GetFloatArrayRegion(this,array,start,len,buf);
01721     }
01722     void GetDoubleArrayRegion(jdoubleArray array,
01723                   jsize start, jsize len, jdouble *buf) {
01724         functions->GetDoubleArrayRegion(this,array,start,len,buf);
01725     }
01726 
01727     void SetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len,
01728                    jboolean *buf) {
01729         functions->SetBooleanArrayRegion(this,array,start,len,buf);
01730     }
01731     void SetByteArrayRegion(jbyteArray array, jsize start, jsize len,
01732                 jbyte *buf) {
01733         functions->SetByteArrayRegion(this,array,start,len,buf);
01734     }
01735     void SetCharArrayRegion(jcharArray array, jsize start, jsize len,
01736                 jchar *buf) {
01737         functions->SetCharArrayRegion(this,array,start,len,buf);
01738     }
01739     void SetShortArrayRegion(jshortArray array, jsize start, jsize len,
01740                  jshort *buf) {
01741         functions->SetShortArrayRegion(this,array,start,len,buf);
01742     }
01743     void SetIntArrayRegion(jintArray array, jsize start, jsize len,
01744                jint *buf) {
01745         functions->SetIntArrayRegion(this,array,start,len,buf);
01746     }
01747     void SetLongArrayRegion(jlongArray array, jsize start, jsize len,
01748                 jlong *buf) {
01749         functions->SetLongArrayRegion(this,array,start,len,buf);
01750     }
01751     void SetFloatArrayRegion(jfloatArray array, jsize start, jsize len,
01752                  jfloat *buf) {
01753         functions->SetFloatArrayRegion(this,array,start,len,buf);
01754     }
01755     void SetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len,
01756                   jdouble *buf) {
01757         functions->SetDoubleArrayRegion(this,array,start,len,buf);
01758     }
01759 
01760     jint RegisterNatives(jclass clazz, const JNINativeMethod *methods,
01761              jint nMethods) {
01762         return functions->RegisterNatives(this,clazz,methods,nMethods);
01763     }
01764     jint UnregisterNatives(jclass clazz) {
01765         return functions->UnregisterNatives(this,clazz);
01766     }
01767 
01768     jint MonitorEnter(jobject obj) {
01769         return functions->MonitorEnter(this,obj);
01770     }
01771     jint MonitorExit(jobject obj) {
01772         return functions->MonitorExit(this,obj);
01773     }
01774 
01775     jint GetJavaVM(JavaVM **vm) {
01776         return functions->GetJavaVM(this,vm);
01777     }
01778 
01779     void GetStringRegion(jstring str, jsize start, jsize len, jchar *buf) {
01780         functions->GetStringRegion(this,str,start,len,buf);
01781     }
01782     void GetStringUTFRegion(jstring str, jsize start, jsize len, char *buf) {
01783         functions->GetStringUTFRegion(this,str,start,len,buf);
01784     }
01785 
01786     void * GetPrimitiveArrayCritical(jarray array, jboolean *isCopy) {
01787         return functions->GetPrimitiveArrayCritical(this,array,isCopy);
01788     }
01789     void ReleasePrimitiveArrayCritical(jarray array, void *carray, jint mode) {
01790         functions->ReleasePrimitiveArrayCritical(this,array,carray,mode);
01791     }
01792 
01793     const jchar * GetStringCritical(jstring string, jboolean *isCopy) {
01794         return functions->GetStringCritical(this,string,isCopy);
01795     }
01796     void ReleaseStringCritical(jstring string, const jchar *cstring) {
01797         functions->ReleaseStringCritical(this,string,cstring);
01798     }
01799 
01800     jweak NewWeakGlobalRef(jobject obj) {
01801         return functions->NewWeakGlobalRef(this,obj);
01802     }
01803     void DeleteWeakGlobalRef(jweak ref) {
01804         functions->DeleteWeakGlobalRef(this,ref);
01805     }
01806 
01807     jboolean ExceptionCheck() {
01808     return functions->ExceptionCheck(this);
01809     }
01810 
01811 #endif /* __cplusplus */
01812 };
01813 
01814 typedef struct JavaVMOption {
01815     char *optionString;
01816     void *extraInfo;
01817 } JavaVMOption;
01818 
01819 typedef struct JavaVMInitArgs {
01820     jint version;
01821 
01822     jint nOptions;
01823     JavaVMOption *options;
01824     jboolean ignoreUnrecognized;
01825 } JavaVMInitArgs;
01826 
01827 typedef struct JavaVMAttachArgs {
01828     jint version;
01829 
01830     char *name;
01831     jobject group;
01832 } JavaVMAttachArgs;
01833 
01834 /* These structures will be VM-specific. */
01835 
01836 typedef struct JDK1_1InitArgs {
01837     jint version;
01838 
01839     char **properties;
01840     jint checkSource;
01841     jint nativeStackSize;
01842     jint javaStackSize;
01843     jint minHeapSize;
01844     jint maxHeapSize;
01845     jint verifyMode;
01846     char *classpath;
01847 
01848     jint (JNICALL *vfprintf)(FILE *fp, const char *format, va_list args);
01849     void (JNICALL *exit)(jint code);
01850     void (JNICALL *abort)(void);
01851 
01852     jint enableClassGC;
01853     jint enableVerboseGC;
01854     jint disableAsyncGC;
01855     jint verbose;
01856     jboolean debugging;
01857     jint debugPort;
01858 } JDK1_1InitArgs;
01859 
01860 typedef struct JDK1_1AttachArgs {
01861     void * __padding; /* C compilers don't allow empty structures. */
01862 } JDK1_1AttachArgs;
01863 
01864 #define JDK1_2
01865 
01866 /* End VM-specific. */
01867 
01868 struct JNIInvokeInterface_ {
01869     void *reserved0;
01870     void *reserved1;
01871     void *reserved2;
01872 
01873     jint (JNICALL *DestroyJavaVM)(JavaVM *vm);
01874 
01875     jint (JNICALL *AttachCurrentThread)(JavaVM *vm, void **penv, void *args);
01876 
01877     jint (JNICALL *DetachCurrentThread)(JavaVM *vm);
01878 
01879     jint (JNICALL *GetEnv)(JavaVM *vm, void **penv, jint version);
01880 };
01881 
01882 struct JavaVM_ {
01883     const struct JNIInvokeInterface_ *functions;
01884 #ifdef __cplusplus
01885 
01886     jint DestroyJavaVM() {
01887         return functions->DestroyJavaVM(this);
01888     }
01889     jint AttachCurrentThread(void **penv, void *args) {
01890         return functions->AttachCurrentThread(this, penv, args);
01891     }
01892     jint DetachCurrentThread() {
01893         return functions->DetachCurrentThread(this);
01894     }
01895 
01896     jint GetEnv(void **penv, jint version) {
01897         return functions->GetEnv(this, penv, version);
01898     }
01899 #endif
01900 };
01901 
01902 #ifdef _JNI_IMPLEMENTATION_
01903 #define _JNI_IMPORT_OR_EXPORT_ JNIEXPORT
01904 #else
01905 #define _JNI_IMPORT_OR_EXPORT_ JNIIMPORT
01906 #endif
01907 _JNI_IMPORT_OR_EXPORT_ jint JNICALL
01908 JNI_GetDefaultJavaVMInitArgs(void *args);
01909 
01910 _JNI_IMPORT_OR_EXPORT_ jint JNICALL
01911 JNI_CreateJavaVM(JavaVM **pvm, void **penv, void *args);
01912 
01913 _JNI_IMPORT_OR_EXPORT_ jint JNICALL
01914 JNI_GetCreatedJavaVMs(JavaVM **, jsize, jsize *);
01915 
01916 /* Defined by native libraries. */
01917 JNIEXPORT jint JNICALL
01918 JNI_OnLoad(JavaVM *vm, void *reserved);
01919 
01920 JNIEXPORT void JNICALL
01921 JNI_OnUnload(JavaVM *vm, void *reserved);
01922 
01923 #define JNI_VERSION_1_1 0x00010001
01924 #define JNI_VERSION_1_2 0x00010002
01925 
01926 #ifdef __cplusplus
01927 } /* extern "C" */
01928 #endif /* __cplusplus */
01929 
01930 #endif /* !_JAVASOFT_JNI_H_ */
01931 
01932 

Generated at Sun Jun 24 20:57:15 2001 for xdprof by doxygen1.2.8.1 written by Dimitri van Heesch, © 1997-2001