Back to index

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