Back to index

lightning-sunbird  0.9+nobinonly
jni.h
Go to the documentation of this file.
00001 /* ***** BEGIN LICENSE BLOCK *****
00002  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
00003  *
00004  * The contents of this file are subject to the Mozilla Public License Version
00005  * 1.1 (the "License"); you may not use this file except in compliance with
00006  * the License. You may obtain a copy of the License at
00007  * http://www.mozilla.org/MPL/
00008  *
00009  * Software distributed under the License is distributed on an "AS IS" basis,
00010  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
00011  * for the specific language governing rights and limitations under the
00012  * License.
00013  *
00014  * The Original Code is the Java Runtime Interface.
00015  *
00016  * The Initial Developer of the Original Code is
00017  * Netscape Communications Corporation and Sun Microsystems, Inc.
00018  * Portions created by the Initial Developer are Copyright (C) 1993-1996
00019  * the Initial Developer. All Rights Reserved.
00020  *
00021  * Contributor(s):
00022  *
00023  * Alternatively, the contents of this file may be used under the terms of
00024  * either the GNU General Public License Version 2 or later (the "GPL"), or
00025  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
00026  * in which case the provisions of the GPL or the LGPL are applicable instead
00027  * of those above. If you wish to allow use of your version of this file only
00028  * under the terms of either the GPL or the LGPL, and not to allow others to
00029  * use your version of this file under the terms of the MPL, indicate your
00030  * decision by deleting the provisions above and replace them with the notice
00031  * and other provisions required by the GPL or the LGPL. If you do not delete
00032  * the provisions above, a recipient may use your version of this file under
00033  * the terms of any one of the MPL, the GPL or the LGPL.
00034  *
00035  * ***** END LICENSE BLOCK ***** */
00036 
00037 #ifndef JNI_H
00038 #define JNI_H
00039 
00040 #include <stdio.h>
00041 #include <stdarg.h>
00042 
00043 /* jni_md.h contains the machine-dependent typedefs for jbyte, jint 
00044    and jlong */ 
00045 
00046 #include "jni_md.h"
00047 
00048 #ifdef __cplusplus
00049 extern "C" {
00050 #endif
00051 
00052 /*
00053  * JNI Types
00054  */
00055 
00056 typedef unsigned char       jboolean;
00057 typedef unsigned short      jchar;
00058 typedef short        jshort;
00059 typedef float        jfloat;
00060 typedef double              jdouble;
00061 
00062 typedef jint            jsize;
00063 
00064 #ifdef __cplusplus
00065 
00066 class _jobject {};
00067 class _jclass : public _jobject {};
00068 class _jthrowable : public _jobject {};
00069 class _jstring : public _jobject {};
00070 class _jarray : public _jobject {};
00071 class _jbooleanArray : public _jarray {};
00072 class _jbyteArray : public _jarray {};
00073 class _jcharArray : public _jarray {};
00074 class _jshortArray : public _jarray {};
00075 class _jintArray : public _jarray {};
00076 class _jlongArray : public _jarray {};
00077 class _jfloatArray : public _jarray {};
00078 class _jdoubleArray : public _jarray {};
00079 class _jobjectArray : public _jarray {};
00080 
00081 typedef _jobject *jobject;
00082 typedef _jclass *jclass;
00083 typedef _jthrowable *jthrowable;
00084 typedef _jstring *jstring;
00085 typedef _jarray *jarray;
00086 typedef _jbooleanArray *jbooleanArray;
00087 typedef _jbyteArray *jbyteArray;
00088 typedef _jcharArray *jcharArray;
00089 typedef _jshortArray *jshortArray;
00090 typedef _jintArray *jintArray;
00091 typedef _jlongArray *jlongArray;
00092 typedef _jfloatArray *jfloatArray;
00093 typedef _jdoubleArray *jdoubleArray;
00094 typedef _jobjectArray *jobjectArray;
00095 
00096 #else
00097 
00098 struct _jobject;
00099 
00100 typedef struct _jobject *jobject;
00101 typedef jobject jclass;
00102 typedef jobject jthrowable;
00103 typedef jobject jstring;
00104 typedef jobject jarray;
00105 typedef jarray jbooleanArray;
00106 typedef jarray jbyteArray;
00107 typedef jarray jcharArray;
00108 typedef jarray jshortArray;
00109 typedef jarray jintArray;
00110 typedef jarray jlongArray;
00111 typedef jarray jfloatArray;
00112 typedef jarray jdoubleArray;
00113 typedef jarray jobjectArray;
00114 
00115 #endif
00116 
00117 #if 0  /* moved to jri_md.h */
00118 typedef jobject jref; /* For transition---not meant to be part of public 
00119                       API anymore.*/
00120 #endif
00121 
00122 typedef union jvalue {
00123     jboolean z;
00124     jbyte    b;
00125     jchar    c;
00126     jshort   s;
00127     jint     i;
00128     jlong    j;
00129     jfloat   f;
00130     jdouble  d;
00131     jobject  l;
00132 } jvalue;
00133 
00134 struct _jfieldID;
00135 typedef struct _jfieldID *jfieldID;
00136 
00137 struct _jmethodID;
00138 typedef struct _jmethodID *jmethodID;
00139 
00140 /*
00141  * jboolean constants
00142  */
00143 
00144 #define JNI_FALSE 0
00145 #define JNI_TRUE 1
00146 
00147 /*
00148  * possible return values for JNI functions.
00149  */
00150 
00151 #define JNI_OK 0
00152 #define JNI_ERR (-1)
00153 
00154 /*
00155  * used in ReleaseScalarArrayElements
00156  */
00157   
00158 #define JNI_COMMIT 1
00159 #define JNI_ABORT 2
00160 
00161 /*
00162  * used in RegisterNatives to describe native method name, signature,
00163  * and function pointer.
00164  */
00165 
00166 typedef struct {
00167     char *name;
00168     char *signature;
00169     void *fnPtr;
00170 } JNINativeMethod;
00171 
00172 /*
00173  * JNI Native Method Interface.
00174  */
00175 
00176 struct JNINativeInterface_;
00177 
00178 struct JNIEnv_;
00179 
00180 #ifdef __cplusplus
00181 typedef JNIEnv_ JNIEnv;
00182 #else
00183 typedef const struct JNINativeInterface_ *JNIEnv;
00184 #endif
00185 
00186 /*
00187  * JNI Invocation Interface.
00188  */
00189 
00190 struct JNIInvokeInterface_;
00191 
00192 struct JavaVM_;
00193 
00194 #ifdef __cplusplus
00195 typedef JavaVM_ JavaVM;
00196 #else
00197 typedef const struct JNIInvokeInterface_ *JavaVM;
00198 #endif
00199 
00200 struct JNINativeInterface_ {
00201     void *reserved0;
00202     void *reserved1;
00203     void *reserved2;
00204 
00205     void *reserved3;
00206     jint (JNICALL *GetVersion)(JNIEnv *env);
00207 
00208     jclass (JNICALL *DefineClass)
00209       (JNIEnv *env, const char *name, jobject loader, const jbyte *buf, 
00210        jsize len);
00211     jclass (JNICALL *FindClass)
00212       (JNIEnv *env, const char *name);
00213 
00214     void *reserved4;
00215     void *reserved5;
00216     void *reserved6;
00217 
00218     jclass (JNICALL *GetSuperclass)
00219       (JNIEnv *env, jclass sub);
00220     jboolean (JNICALL *IsAssignableFrom)
00221       (JNIEnv *env, jclass sub, jclass sup);
00222     void *reserved7;
00223 
00224 
00225     jint (JNICALL *Throw)
00226       (JNIEnv *env, jthrowable obj);
00227     jint (JNICALL *ThrowNew)
00228       (JNIEnv *env, jclass clazz, const char *msg);
00229     jthrowable (JNICALL *ExceptionOccurred)
00230       (JNIEnv *env);
00231     void (JNICALL *ExceptionDescribe)
00232       (JNIEnv *env);
00233     void (JNICALL *ExceptionClear)
00234       (JNIEnv *env);
00235     void (JNICALL *FatalError)
00236       (JNIEnv *env, const char *msg);
00237     void *reserved8;
00238     void *reserved9;
00239 
00240     jobject (JNICALL *NewGlobalRef)
00241       (JNIEnv *env, jobject lobj);
00242     void (JNICALL *DeleteGlobalRef)
00243       (JNIEnv *env, jobject gref);
00244     void (JNICALL *DeleteLocalRef)
00245       (JNIEnv *env, jobject obj);
00246     jboolean (JNICALL *IsSameObject)
00247       (JNIEnv *env, jobject obj1, jobject obj2);
00248     void *reserved10;
00249     void *reserved11;
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 
00711 /*
00712  * We use inlined functions for C++ so that programmers can write:
00713  * 
00714  *    env->FindClass("java/lang/String")
00715  *
00716  * in C++ rather than:
00717  *
00718  *    (*env)->FindClass(env, "java/lang/String")
00719  *
00720  * in C.
00721  */
00722 
00723 struct JNIEnv_ {
00724     const struct JNINativeInterface_ *functions;
00725     void *reserved0;
00726     void *reserved1[6];
00727 #ifdef __cplusplus
00728 
00729     jint GetVersion() {
00730         return functions->GetVersion(this);
00731     }
00732     jclass DefineClass(const char *name, jobject loader, const jbyte *buf,
00733                      jsize len) {
00734         return functions->DefineClass(this, name, loader, buf, len);
00735     }
00736     jclass FindClass(const char *name) {
00737         return functions->FindClass(this, name);
00738     }
00739     jclass GetSuperclass(jclass sub) {
00740         return functions->GetSuperclass(this, sub);
00741     }
00742     jboolean IsAssignableFrom(jclass sub, jclass sup) {
00743         return functions->IsAssignableFrom(this, sub, sup);
00744     }
00745 
00746     jint Throw(jthrowable obj) {
00747         return functions->Throw(this, obj);
00748     }    
00749     jint ThrowNew(jclass clazz, const char *msg) {
00750         return functions->ThrowNew(this, clazz, msg);
00751     }
00752     jthrowable ExceptionOccurred() {
00753         return functions->ExceptionOccurred(this);
00754     }
00755     void ExceptionDescribe() {
00756         functions->ExceptionDescribe(this);
00757     }
00758     void ExceptionClear() {
00759         functions->ExceptionClear(this);
00760     }
00761     void FatalError(const char *msg) {
00762         functions->FatalError(this, msg);
00763     }
00764 
00765     jobject NewGlobalRef(jobject lobj) {
00766         return functions->NewGlobalRef(this,lobj);
00767     }
00768     void DeleteGlobalRef(jobject gref) {
00769         functions->DeleteGlobalRef(this,gref);
00770     }
00771     void DeleteLocalRef(jobject obj) {
00772         functions->DeleteLocalRef(this, obj);
00773     }
00774 
00775     jboolean IsSameObject(jobject obj1, jobject obj2) {
00776         return functions->IsSameObject(this,obj1,obj2);
00777     }
00778 
00779     jobject AllocObject(jclass clazz) {
00780         return functions->AllocObject(this,clazz);
00781     }
00782     jobject NewObject(jclass clazz, jmethodID methodID, ...) {
00783         va_list args;
00784        jobject result;
00785        va_start(args, methodID);
00786         result = functions->NewObjectV(this,clazz,methodID,args);
00787        va_end(args);
00788        return result;
00789     }
00790     jobject NewObjectV(jclass clazz, jmethodID methodID, 
00791                      va_list args) {
00792         return functions->NewObjectV(this,clazz,methodID,args);
00793     }
00794     jobject NewObjectA(jclass clazz, jmethodID methodID, 
00795                      jvalue *args) {
00796         return functions->NewObjectA(this,clazz,methodID,args);
00797     }
00798 
00799     jclass GetObjectClass(jobject obj) {
00800         return functions->GetObjectClass(this,obj);
00801     }
00802     jboolean IsInstanceOf(jobject obj, jclass clazz) {
00803         return functions->IsInstanceOf(this,obj,clazz);
00804     }
00805 
00806     jmethodID GetMethodID(jclass clazz, const char *name, 
00807                        const char *sig) {
00808         return functions->GetMethodID(this,clazz,name,sig);
00809     }
00810 
00811     jobject CallObjectMethod(jobject obj, jmethodID methodID, ...) {
00812         va_list args;
00813        jobject result;
00814        va_start(args,methodID);
00815        result = functions->CallObjectMethodV(this,obj,methodID,args);
00816        va_end(args);
00817        return result;
00818     }
00819     jobject CallObjectMethodV(jobject obj, jmethodID methodID, 
00820                      va_list args) {
00821         return functions->CallObjectMethodV(this,obj,methodID,args);
00822     }
00823     jobject CallObjectMethodA(jobject obj, jmethodID methodID, 
00824                      jvalue * args) {
00825         return functions->CallObjectMethodA(this,obj,methodID,args);
00826     }
00827 
00828     jboolean CallBooleanMethod(jobject obj, 
00829                             jmethodID methodID, ...) {
00830         va_list args;
00831        jboolean result;
00832        va_start(args,methodID);
00833        result = functions->CallBooleanMethodV(this,obj,methodID,args);
00834        va_end(args);
00835        return result;
00836     }
00837     jboolean CallBooleanMethodV(jobject obj, jmethodID methodID, 
00838                             va_list args) {
00839         return functions->CallBooleanMethodV(this,obj,methodID,args);
00840     }
00841     jboolean CallBooleanMethodA(jobject obj, jmethodID methodID, 
00842                             jvalue * args) {
00843         return functions->CallBooleanMethodA(this,obj,methodID, args);
00844     }
00845 
00846     jbyte CallByteMethod(jobject obj, jmethodID methodID, ...) {
00847         va_list args;
00848        jbyte result;
00849        va_start(args,methodID);
00850        result = functions->CallByteMethodV(this,obj,methodID,args);
00851        va_end(args);
00852        return result;
00853     }
00854     jbyte CallByteMethodV(jobject obj, jmethodID methodID, 
00855                        va_list args) {
00856         return functions->CallByteMethodV(this,obj,methodID,args);
00857     }
00858     jbyte CallByteMethodA(jobject obj, jmethodID methodID, 
00859                        jvalue * args) {
00860         return functions->CallByteMethodA(this,obj,methodID,args);
00861     }
00862 
00863     jchar CallCharMethod(jobject obj, jmethodID methodID, ...) {
00864         va_list args;
00865        jchar result;
00866        va_start(args,methodID);
00867        result = functions->CallCharMethodV(this,obj,methodID,args);
00868        va_end(args);
00869        return result;
00870     }
00871     jchar CallCharMethodV(jobject obj, jmethodID methodID, 
00872                        va_list args) {
00873         return functions->CallCharMethodV(this,obj,methodID,args);
00874     }
00875     jchar CallCharMethodA(jobject obj, jmethodID methodID, 
00876                        jvalue * args) {
00877         return functions->CallCharMethodA(this,obj,methodID,args);
00878     }
00879 
00880     jshort CallShortMethod(jobject obj, jmethodID methodID, ...) {
00881         va_list args;
00882        jshort result;
00883        va_start(args,methodID);
00884        result = functions->CallShortMethodV(this,obj,methodID,args);
00885        va_end(args);
00886        return result;
00887     }
00888     jshort CallShortMethodV(jobject obj, jmethodID methodID, 
00889                          va_list args) {
00890         return functions->CallShortMethodV(this,obj,methodID,args);
00891     }
00892     jshort CallShortMethodA(jobject obj, jmethodID methodID, 
00893                          jvalue * args) {
00894         return functions->CallShortMethodA(this,obj,methodID,args);
00895     }
00896 
00897     jint CallIntMethod(jobject obj, jmethodID methodID, ...) {
00898         va_list args;
00899        jint result;
00900        va_start(args,methodID);
00901        result = functions->CallIntMethodV(this,obj,methodID,args);
00902        va_end(args);
00903        return result;
00904     }
00905     jint CallIntMethodV(jobject obj, jmethodID methodID, 
00906                      va_list args) {
00907         return functions->CallIntMethodV(this,obj,methodID,args);
00908     }
00909     jint CallIntMethodA(jobject obj, jmethodID methodID, 
00910                      jvalue * args) {
00911         return functions->CallIntMethodA(this,obj,methodID,args);
00912     }
00913 
00914     jlong CallLongMethod(jobject obj, jmethodID methodID, ...) {
00915         va_list args;
00916        jlong result;
00917        va_start(args,methodID);
00918        result = functions->CallLongMethodV(this,obj,methodID,args);
00919        va_end(args);
00920        return result;
00921     }
00922     jlong CallLongMethodV(jobject obj, jmethodID methodID, 
00923                        va_list args) {
00924         return functions->CallLongMethodV(this,obj,methodID,args);
00925     }
00926     jlong CallLongMethodA(jobject obj, jmethodID methodID, 
00927                        jvalue * args) {
00928         return functions->CallLongMethodA(this,obj,methodID,args);
00929     }
00930 
00931     jfloat CallFloatMethod(jobject obj, jmethodID methodID, ...) {
00932         va_list args;
00933        jfloat result;
00934        va_start(args,methodID);
00935        result = functions->CallFloatMethodV(this,obj,methodID,args);
00936        va_end(args);
00937        return result;
00938     }
00939     jfloat CallFloatMethodV(jobject obj, jmethodID methodID, 
00940                          va_list args) {
00941         return functions->CallFloatMethodV(this,obj,methodID,args);
00942     }
00943     jfloat CallFloatMethodA(jobject obj, jmethodID methodID, 
00944                          jvalue * args) {
00945         return functions->CallFloatMethodA(this,obj,methodID,args);
00946     }
00947 
00948     jdouble CallDoubleMethod(jobject obj, jmethodID methodID, ...) {
00949         va_list args;
00950        jdouble result;
00951        va_start(args,methodID);
00952        result = functions->CallDoubleMethodV(this,obj,methodID,args);
00953        va_end(args);
00954        return result;
00955     }
00956     jdouble CallDoubleMethodV(jobject obj, jmethodID methodID, 
00957                      va_list args) {
00958         return functions->CallDoubleMethodV(this,obj,methodID,args);
00959     }
00960     jdouble CallDoubleMethodA(jobject obj, jmethodID methodID, 
00961                      jvalue * args) {
00962         return functions->CallDoubleMethodA(this,obj,methodID,args);
00963     }
00964 
00965     void CallVoidMethod(jobject obj, jmethodID methodID, ...) {
00966         va_list args;
00967        va_start(args,methodID);
00968        functions->CallVoidMethodV(this,obj,methodID,args);
00969        va_end(args);
00970     }
00971     void CallVoidMethodV(jobject obj, jmethodID methodID, 
00972                       va_list args) {
00973         functions->CallVoidMethodV(this,obj,methodID,args);
00974     }
00975     void CallVoidMethodA(jobject obj, jmethodID methodID, 
00976                       jvalue * args) {
00977         functions->CallVoidMethodA(this,obj,methodID,args);
00978     }
00979 
00980     jobject CallNonvirtualObjectMethod(jobject obj, jclass clazz, 
00981                                    jmethodID methodID, ...) {
00982         va_list args;
00983        jobject result;
00984        va_start(args,methodID);
00985        result = functions->CallNonvirtualObjectMethodV(this,obj,clazz,
00986                                                  methodID,args);
00987        va_end(args);
00988        return result;
00989     }
00990     jobject CallNonvirtualObjectMethodV(jobject obj, jclass clazz, 
00991                                    jmethodID methodID, va_list args) {
00992         return functions->CallNonvirtualObjectMethodV(this,obj,clazz,
00993                                                 methodID,args);
00994     }
00995     jobject CallNonvirtualObjectMethodA(jobject obj, jclass clazz, 
00996                                    jmethodID methodID, jvalue * args) {
00997         return functions->CallNonvirtualObjectMethodA(this,obj,clazz,
00998                                                 methodID,args);
00999     }
01000 
01001     jboolean CallNonvirtualBooleanMethod(jobject obj, jclass clazz, 
01002                                     jmethodID methodID, ...) {
01003         va_list args;
01004        jboolean result;
01005        va_start(args,methodID);
01006        result = functions->CallNonvirtualBooleanMethodV(this,obj,clazz,
01007                                                   methodID,args);
01008        va_end(args);
01009        return result;
01010     }
01011     jboolean CallNonvirtualBooleanMethodV(jobject obj, jclass clazz, 
01012                                      jmethodID methodID, va_list args) {
01013         return functions->CallNonvirtualBooleanMethodV(this,obj,clazz,
01014                                                  methodID,args);
01015     }
01016     jboolean CallNonvirtualBooleanMethodA(jobject obj, jclass clazz, 
01017                                      jmethodID methodID, jvalue * args) {
01018         return functions->CallNonvirtualBooleanMethodA(this,obj,clazz,
01019                                                  methodID, args);
01020     }
01021 
01022     jbyte CallNonvirtualByteMethod(jobject obj, jclass clazz, 
01023                                jmethodID methodID, ...) {
01024         va_list args;
01025        jbyte result;
01026        va_start(args,methodID);
01027        result = functions->CallNonvirtualByteMethodV(this,obj,clazz,
01028                                                 methodID,args);
01029        va_end(args);
01030        return result;
01031     }
01032     jbyte CallNonvirtualByteMethodV(jobject obj, jclass clazz, 
01033                                 jmethodID methodID, va_list args) {
01034         return functions->CallNonvirtualByteMethodV(this,obj,clazz,
01035                                               methodID,args);
01036     }
01037     jbyte CallNonvirtualByteMethodA(jobject obj, jclass clazz, 
01038                                 jmethodID methodID, jvalue * args) {
01039         return functions->CallNonvirtualByteMethodA(this,obj,clazz,
01040                                               methodID,args);
01041     }
01042 
01043     jchar CallNonvirtualCharMethod(jobject obj, jclass clazz, 
01044                                jmethodID methodID, ...) {
01045         va_list args;
01046        jchar result;
01047        va_start(args,methodID);
01048        result = functions->CallNonvirtualCharMethodV(this,obj,clazz,
01049                                                 methodID,args);
01050        va_end(args);
01051        return result;
01052     }
01053     jchar CallNonvirtualCharMethodV(jobject obj, jclass clazz, 
01054                                 jmethodID methodID, va_list args) {
01055         return functions->CallNonvirtualCharMethodV(this,obj,clazz,
01056                                               methodID,args);
01057     }
01058     jchar CallNonvirtualCharMethodA(jobject obj, jclass clazz, 
01059                                 jmethodID methodID, jvalue * args) {
01060         return functions->CallNonvirtualCharMethodA(this,obj,clazz,
01061                                               methodID,args);
01062     }
01063 
01064     jshort CallNonvirtualShortMethod(jobject obj, jclass clazz, 
01065                                  jmethodID methodID, ...) {
01066         va_list args;
01067        jshort result;
01068        va_start(args,methodID);
01069        result = functions->CallNonvirtualShortMethodV(this,obj,clazz,
01070                                                  methodID,args);
01071        va_end(args);
01072        return result;
01073     }
01074     jshort CallNonvirtualShortMethodV(jobject obj, jclass clazz, 
01075                                   jmethodID methodID, va_list args) {
01076         return functions->CallNonvirtualShortMethodV(this,obj,clazz,
01077                                                methodID,args);
01078     }
01079     jshort CallNonvirtualShortMethodA(jobject obj, jclass clazz,
01080                                   jmethodID methodID, jvalue * args) {
01081         return functions->CallNonvirtualShortMethodA(this,obj,clazz,
01082                                                methodID,args);
01083     }
01084 
01085     jint CallNonvirtualIntMethod(jobject obj, jclass clazz, 
01086                              jmethodID methodID, ...) {
01087         va_list args;
01088        jint result;
01089        va_start(args,methodID);
01090        result = functions->CallNonvirtualIntMethodV(this,obj,clazz,
01091                                                methodID,args);
01092        va_end(args);
01093        return result;
01094     }
01095     jint CallNonvirtualIntMethodV(jobject obj, jclass clazz, 
01096                               jmethodID methodID, va_list args) {
01097         return functions->CallNonvirtualIntMethodV(this,obj,clazz,
01098                                              methodID,args);
01099     }
01100     jint CallNonvirtualIntMethodA(jobject obj, jclass clazz, 
01101                               jmethodID methodID, jvalue * args) {
01102         return functions->CallNonvirtualIntMethodA(this,obj,clazz,
01103                                              methodID,args);
01104     }
01105 
01106     jlong CallNonvirtualLongMethod(jobject obj, jclass clazz,
01107                                jmethodID methodID, ...) {
01108         va_list args;
01109        jlong result;
01110        va_start(args,methodID);
01111        result = functions->CallNonvirtualLongMethodV(this,obj,clazz,
01112                                                 methodID,args);
01113        va_end(args);
01114        return result;
01115     }
01116     jlong CallNonvirtualLongMethodV(jobject obj, jclass clazz,
01117                                 jmethodID methodID, va_list args) {
01118         return functions->CallNonvirtualLongMethodV(this,obj,clazz,
01119                                               methodID,args);
01120     }
01121     jlong CallNonvirtualLongMethodA(jobject obj, jclass clazz, 
01122                                 jmethodID methodID, jvalue * args) {
01123         return functions->CallNonvirtualLongMethodA(this,obj,clazz,
01124                                               methodID,args);
01125     }
01126 
01127     jfloat CallNonvirtualFloatMethod(jobject obj, jclass clazz, 
01128                                  jmethodID methodID, ...) {
01129         va_list args;
01130        jfloat result;
01131        va_start(args,methodID);
01132        result = functions->CallNonvirtualFloatMethodV(this,obj,clazz,
01133                                                  methodID,args);
01134        va_end(args);
01135        return result;
01136     }
01137     jfloat CallNonvirtualFloatMethodV(jobject obj, jclass clazz,
01138                                   jmethodID methodID, 
01139                                   va_list args) {
01140         return functions->CallNonvirtualFloatMethodV(this,obj,clazz,
01141                                                methodID,args);
01142     }
01143     jfloat CallNonvirtualFloatMethodA(jobject obj, jclass clazz, 
01144                                   jmethodID methodID, 
01145                                   jvalue * args) {
01146         return functions->CallNonvirtualFloatMethodA(this,obj,clazz,
01147                                                methodID,args);
01148     }
01149 
01150     jdouble CallNonvirtualDoubleMethod(jobject obj, jclass clazz,
01151                                    jmethodID methodID, ...) {
01152         va_list args;
01153        jdouble result;
01154        va_start(args,methodID);
01155        result = functions->CallNonvirtualDoubleMethodV(this,obj,clazz,
01156                                                  methodID,args);
01157        va_end(args);
01158        return result;
01159     }
01160     jdouble CallNonvirtualDoubleMethodV(jobject obj, jclass clazz,
01161                                    jmethodID methodID, 
01162                                    va_list args) {
01163         return functions->CallNonvirtualDoubleMethodV(this,obj,clazz,
01164                                                 methodID,args);
01165     }
01166     jdouble CallNonvirtualDoubleMethodA(jobject obj, jclass clazz, 
01167                                    jmethodID methodID, 
01168                                    jvalue * args) {
01169         return functions->CallNonvirtualDoubleMethodA(this,obj,clazz,
01170                                                 methodID,args);
01171     }
01172 
01173     void CallNonvirtualVoidMethod(jobject obj, jclass clazz,
01174                               jmethodID methodID, ...) {
01175         va_list args;
01176        va_start(args,methodID);
01177        functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);
01178        va_end(args);
01179     }
01180     void CallNonvirtualVoidMethodV(jobject obj, jclass clazz,
01181                                jmethodID methodID, 
01182                                va_list args) {
01183         functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);
01184     }
01185     void CallNonvirtualVoidMethodA(jobject obj, jclass clazz,
01186                                jmethodID methodID, 
01187                                jvalue * args) {
01188         functions->CallNonvirtualVoidMethodA(this,obj,clazz,methodID,args);
01189     }
01190 
01191     jfieldID GetFieldID(jclass clazz, const char *name, 
01192                      const char *sig) {
01193         return functions->GetFieldID(this,clazz,name,sig);
01194     }
01195 
01196     jobject GetObjectField(jobject obj, jfieldID fieldID) {
01197         return functions->GetObjectField(this,obj,fieldID);
01198     }
01199     jboolean GetBooleanField(jobject obj, jfieldID fieldID) {
01200         return functions->GetBooleanField(this,obj,fieldID);
01201     }
01202     jbyte GetByteField(jobject obj, jfieldID fieldID) {
01203         return functions->GetByteField(this,obj,fieldID);
01204     }
01205     jchar GetCharField(jobject obj, jfieldID fieldID) {
01206         return functions->GetCharField(this,obj,fieldID);
01207     }
01208     jshort GetShortField(jobject obj, jfieldID fieldID) {
01209         return functions->GetShortField(this,obj,fieldID);
01210     }
01211     jint GetIntField(jobject obj, jfieldID fieldID) {
01212         return functions->GetIntField(this,obj,fieldID);
01213     }
01214     jlong GetLongField(jobject obj, jfieldID fieldID) {
01215         return functions->GetLongField(this,obj,fieldID);
01216     }
01217     jfloat GetFloatField(jobject obj, jfieldID fieldID) {
01218         return functions->GetFloatField(this,obj,fieldID);
01219     }
01220     jdouble GetDoubleField(jobject obj, jfieldID fieldID) {
01221         return functions->GetDoubleField(this,obj,fieldID);
01222     }
01223 
01224     void SetObjectField(jobject obj, jfieldID fieldID, jobject val) {
01225         functions->SetObjectField(this,obj,fieldID,val);
01226     }
01227     void SetBooleanField(jobject obj, jfieldID fieldID, 
01228                       jboolean val) {
01229         functions->SetBooleanField(this,obj,fieldID,val);
01230     }
01231     void SetByteField(jobject obj, jfieldID fieldID, 
01232                     jbyte val) {
01233         functions->SetByteField(this,obj,fieldID,val);
01234     }
01235     void SetCharField(jobject obj, jfieldID fieldID, 
01236                     jchar val) {
01237         functions->SetCharField(this,obj,fieldID,val);
01238     }
01239     void SetShortField(jobject obj, jfieldID fieldID,
01240                      jshort val) {
01241         functions->SetShortField(this,obj,fieldID,val);
01242     }
01243     void SetIntField(jobject obj, jfieldID fieldID, 
01244                    jint val) {
01245         functions->SetIntField(this,obj,fieldID,val);
01246     }
01247     void SetLongField(jobject obj, jfieldID fieldID, 
01248                     jlong val) {
01249         functions->SetLongField(this,obj,fieldID,val);
01250     }
01251     void SetFloatField(jobject obj, jfieldID fieldID, 
01252                      jfloat val) {
01253         functions->SetFloatField(this,obj,fieldID,val);
01254     }
01255     void SetDoubleField(jobject obj, jfieldID fieldID, 
01256                      jdouble val) {
01257         functions->SetDoubleField(this,obj,fieldID,val);
01258     }
01259 
01260     jmethodID GetStaticMethodID(jclass clazz, const char *name, 
01261                             const char *sig) {
01262         return functions->GetStaticMethodID(this,clazz,name,sig);
01263     }
01264 
01265     jobject CallStaticObjectMethod(jclass clazz, jmethodID methodID, 
01266                           ...) {
01267         va_list args;
01268        jobject result;
01269        va_start(args,methodID);
01270        result = functions->CallStaticObjectMethodV(this,clazz,methodID,args);
01271        va_end(args);
01272        return result;
01273     }
01274     jobject CallStaticObjectMethodV(jclass clazz, jmethodID methodID, 
01275                            va_list args) {
01276         return functions->CallStaticObjectMethodV(this,clazz,methodID,args);
01277     }
01278     jobject CallStaticObjectMethodA(jclass clazz, jmethodID methodID, 
01279                            jvalue *args) {
01280         return functions->CallStaticObjectMethodA(this,clazz,methodID,args);
01281     }
01282 
01283     jboolean CallStaticBooleanMethod(jclass clazz, 
01284                                  jmethodID methodID, ...) {
01285         va_list args;
01286        jboolean result;
01287        va_start(args,methodID);
01288        result = functions->CallStaticBooleanMethodV(this,clazz,methodID,args);
01289        va_end(args);
01290        return result;
01291     }
01292     jboolean CallStaticBooleanMethodV(jclass clazz,
01293                                   jmethodID methodID, va_list args) {
01294         return functions->CallStaticBooleanMethodV(this,clazz,methodID,args);
01295     }
01296     jboolean CallStaticBooleanMethodA(jclass clazz,
01297                                   jmethodID methodID, jvalue *args) {
01298         return functions->CallStaticBooleanMethodA(this,clazz,methodID,args);
01299     }
01300 
01301     jbyte CallStaticByteMethod(jclass clazz,
01302                             jmethodID methodID, ...) {
01303         va_list args;
01304        jbyte result;
01305        va_start(args,methodID);
01306        result = functions->CallStaticByteMethodV(this,clazz,methodID,args);
01307        va_end(args);
01308        return result;
01309     }
01310     jbyte CallStaticByteMethodV(jclass clazz,
01311                             jmethodID methodID, va_list args) {
01312         return functions->CallStaticByteMethodV(this,clazz,methodID,args);
01313     }
01314     jbyte CallStaticByteMethodA(jclass clazz, 
01315                             jmethodID methodID, jvalue *args) {
01316         return functions->CallStaticByteMethodA(this,clazz,methodID,args);
01317     }
01318 
01319     jchar CallStaticCharMethod(jclass clazz,
01320                             jmethodID methodID, ...) {
01321         va_list args;
01322        jchar result;
01323        va_start(args,methodID);
01324        result = functions->CallStaticCharMethodV(this,clazz,methodID,args);
01325        va_end(args);
01326        return result;
01327     }
01328     jchar CallStaticCharMethodV(jclass clazz,
01329                             jmethodID methodID, va_list args) {
01330         return functions->CallStaticCharMethodV(this,clazz,methodID,args);
01331     }
01332     jchar CallStaticCharMethodA(jclass clazz,
01333                             jmethodID methodID, jvalue *args) {
01334         return functions->CallStaticCharMethodA(this,clazz,methodID,args);
01335     }
01336 
01337     jshort CallStaticShortMethod(jclass clazz,
01338                              jmethodID methodID, ...) {
01339         va_list args;
01340        jshort result;
01341        va_start(args,methodID);
01342        result = functions->CallStaticShortMethodV(this,clazz,methodID,args);
01343        va_end(args);
01344        return result;
01345     }
01346     jshort CallStaticShortMethodV(jclass clazz,
01347                               jmethodID methodID, va_list args) {
01348         return functions->CallStaticShortMethodV(this,clazz,methodID,args);
01349     }
01350     jshort CallStaticShortMethodA(jclass clazz,
01351                               jmethodID methodID, jvalue *args) {
01352         return functions->CallStaticShortMethodA(this,clazz,methodID,args);
01353     }
01354 
01355     jint CallStaticIntMethod(jclass clazz,
01356                           jmethodID methodID, ...) {
01357         va_list args;
01358        jint result;
01359        va_start(args,methodID);
01360        result = functions->CallStaticIntMethodV(this,clazz,methodID,args);
01361        va_end(args);
01362        return result;
01363     }
01364     jint CallStaticIntMethodV(jclass clazz,
01365                            jmethodID methodID, va_list args) {
01366         return functions->CallStaticIntMethodV(this,clazz,methodID,args);
01367     }
01368     jint CallStaticIntMethodA(jclass clazz, 
01369                            jmethodID methodID, jvalue *args) {
01370         return functions->CallStaticIntMethodA(this,clazz,methodID,args);
01371     }
01372 
01373     jlong CallStaticLongMethod(jclass clazz,
01374                             jmethodID methodID, ...) {
01375         va_list args;
01376        jlong result;
01377        va_start(args,methodID);
01378        result = functions->CallStaticLongMethodV(this,clazz,methodID,args);
01379        va_end(args);
01380        return result;
01381     }
01382     jlong CallStaticLongMethodV(jclass clazz, 
01383                             jmethodID methodID, va_list args) {
01384         return functions->CallStaticLongMethodV(this,clazz,methodID,args);
01385     }
01386     jlong CallStaticLongMethodA(jclass clazz, 
01387                             jmethodID methodID, jvalue *args) {
01388         return functions->CallStaticLongMethodA(this,clazz,methodID,args);
01389     }
01390 
01391     jfloat CallStaticFloatMethod(jclass clazz, 
01392                              jmethodID methodID, ...) {
01393         va_list args;
01394        jfloat result;
01395        va_start(args,methodID);
01396        result = functions->CallStaticFloatMethodV(this,clazz,methodID,args);
01397        va_end(args);
01398        return result;
01399     }
01400     jfloat CallStaticFloatMethodV(jclass clazz, 
01401                               jmethodID methodID, va_list args) {
01402         return functions->CallStaticFloatMethodV(this,clazz,methodID,args);
01403     }
01404     jfloat CallStaticFloatMethodA(jclass clazz, 
01405                               jmethodID methodID, jvalue *args) {
01406         return functions->CallStaticFloatMethodA(this,clazz,methodID,args);
01407     }
01408 
01409     jdouble CallStaticDoubleMethod(jclass clazz, 
01410                                jmethodID methodID, ...) {
01411         va_list args;
01412        jdouble result;
01413        va_start(args,methodID);
01414        result = functions->CallStaticDoubleMethodV(this,clazz,methodID,args);
01415        va_end(args);
01416        return result;
01417     }
01418     jdouble CallStaticDoubleMethodV(jclass clazz, 
01419                                 jmethodID methodID, va_list args) {
01420         return functions->CallStaticDoubleMethodV(this,clazz,methodID,args);
01421     }
01422     jdouble CallStaticDoubleMethodA(jclass clazz, 
01423                                 jmethodID methodID, jvalue *args) {
01424         return functions->CallStaticDoubleMethodA(this,clazz,methodID,args);
01425     }
01426 
01427     void CallStaticVoidMethod(jclass cls, jmethodID methodID, ...) {
01428         va_list args;
01429        va_start(args,methodID);
01430        functions->CallStaticVoidMethodV(this,cls,methodID,args);
01431        va_end(args);
01432     }
01433     void CallStaticVoidMethodV(jclass cls, jmethodID methodID, 
01434                             va_list args) {
01435         functions->CallStaticVoidMethodV(this,cls,methodID,args);
01436     }
01437     void CallStaticVoidMethodA(jclass cls, jmethodID methodID, 
01438                             jvalue * args) {
01439         functions->CallStaticVoidMethodA(this,cls,methodID,args);
01440     }
01441 
01442     jfieldID GetStaticFieldID(jclass clazz, const char *name, 
01443                            const char *sig) {
01444         return functions->GetStaticFieldID(this,clazz,name,sig);
01445     }
01446     jobject GetStaticObjectField(jclass clazz, jfieldID fieldID) {
01447         return functions->GetStaticObjectField(this,clazz,fieldID);
01448     }
01449     jboolean GetStaticBooleanField(jclass clazz, jfieldID fieldID) {
01450         return functions->GetStaticBooleanField(this,clazz,fieldID);
01451     }
01452     jbyte GetStaticByteField(jclass clazz, jfieldID fieldID) {
01453         return functions->GetStaticByteField(this,clazz,fieldID);
01454     }
01455     jchar GetStaticCharField(jclass clazz, jfieldID fieldID) {
01456         return functions->GetStaticCharField(this,clazz,fieldID);
01457     }
01458     jshort GetStaticShortField(jclass clazz, jfieldID fieldID) {
01459         return functions->GetStaticShortField(this,clazz,fieldID);
01460     }
01461     jint GetStaticIntField(jclass clazz, jfieldID fieldID) {
01462         return functions->GetStaticIntField(this,clazz,fieldID);
01463     }
01464     jlong GetStaticLongField(jclass clazz, jfieldID fieldID) {
01465         return functions->GetStaticLongField(this,clazz,fieldID);
01466     }
01467     jfloat GetStaticFloatField(jclass clazz, jfieldID fieldID) {
01468         return functions->GetStaticFloatField(this,clazz,fieldID);
01469     }
01470     jdouble GetStaticDoubleField(jclass clazz, jfieldID fieldID) {
01471         return functions->GetStaticDoubleField(this,clazz,fieldID);
01472     }
01473 
01474     void SetStaticObjectField(jclass clazz, jfieldID fieldID,
01475                      jobject value) {
01476       functions->SetStaticObjectField(this,clazz,fieldID,value);
01477     }
01478     void SetStaticBooleanField(jclass clazz, jfieldID fieldID,
01479                      jboolean value) {
01480       functions->SetStaticBooleanField(this,clazz,fieldID,value);
01481     }
01482     void SetStaticByteField(jclass clazz, jfieldID fieldID,
01483                      jbyte value) {
01484       functions->SetStaticByteField(this,clazz,fieldID,value);
01485     }
01486     void SetStaticCharField(jclass clazz, jfieldID fieldID,
01487                      jchar value) {
01488       functions->SetStaticCharField(this,clazz,fieldID,value);
01489     }
01490     void SetStaticShortField(jclass clazz, jfieldID fieldID,
01491                      jshort value) {
01492       functions->SetStaticShortField(this,clazz,fieldID,value);
01493     }
01494     void SetStaticIntField(jclass clazz, jfieldID fieldID,
01495                      jint value) {
01496       functions->SetStaticIntField(this,clazz,fieldID,value);
01497     }
01498     void SetStaticLongField(jclass clazz, jfieldID fieldID,
01499                      jlong value) {
01500       functions->SetStaticLongField(this,clazz,fieldID,value);
01501     }
01502     void SetStaticFloatField(jclass clazz, jfieldID fieldID,
01503                      jfloat value) {
01504       functions->SetStaticFloatField(this,clazz,fieldID,value);
01505     }
01506     void SetStaticDoubleField(jclass clazz, jfieldID fieldID,
01507                      jdouble value) {
01508       functions->SetStaticDoubleField(this,clazz,fieldID,value);
01509     }
01510 
01511     jstring NewString(const jchar *unicode, jsize len) {
01512         return functions->NewString(this,unicode,len);
01513     }
01514     jsize GetStringLength(jstring str) {
01515         return functions->GetStringLength(this,str);
01516     }
01517     const jchar *GetStringChars(jstring str, jboolean *isCopy) {
01518         return functions->GetStringChars(this,str,isCopy);
01519     }
01520     void ReleaseStringChars(jstring str, const jchar *chars) {
01521         functions->ReleaseStringChars(this,str,chars);
01522     }
01523   
01524     jstring NewStringUTF(const char *utf) {
01525         return functions->NewStringUTF(this,utf);
01526     }
01527     jsize GetStringUTFLength(jstring str) {
01528         return functions->GetStringUTFLength(this,str);
01529     }
01530     const char* GetStringUTFChars(jstring str, jboolean *isCopy) {
01531         return functions->GetStringUTFChars(this,str,isCopy);
01532     }
01533     void ReleaseStringUTFChars(jstring str, const char* chars) {
01534         functions->ReleaseStringUTFChars(this,str,chars);
01535     }
01536 
01537     jsize GetArrayLength(jarray array) {
01538         return functions->GetArrayLength(this,array);
01539     }
01540 
01541     jobjectArray NewObjectArray(jsize len, jclass clazz, 
01542                             jobject init) {
01543         return functions->NewObjectArray(this,len,clazz,init);
01544     }
01545     jobject GetObjectArrayElement(jobjectArray array, jsize index) {
01546         return functions->GetObjectArrayElement(this,array,index);
01547     }
01548     void SetObjectArrayElement(jobjectArray array, jsize index, 
01549                             jobject val) {
01550         functions->SetObjectArrayElement(this,array,index,val);
01551     }
01552 
01553     jbooleanArray NewBooleanArray(jsize len) {
01554         return functions->NewBooleanArray(this,len);
01555     }
01556     jbyteArray NewByteArray(jsize len) {
01557         return functions->NewByteArray(this,len);
01558     }
01559     jcharArray NewCharArray(jsize len) {
01560         return functions->NewCharArray(this,len);
01561     }
01562     jshortArray NewShortArray(jsize len) {
01563         return functions->NewShortArray(this,len);
01564     }
01565     jintArray NewIntArray(jsize len) {
01566         return functions->NewIntArray(this,len);
01567     }
01568     jlongArray NewLongArray(jsize len) {
01569         return functions->NewLongArray(this,len);
01570     }
01571     jfloatArray NewFloatArray(jsize len) {
01572         return functions->NewFloatArray(this,len);
01573     }
01574     jdoubleArray NewDoubleArray(jsize len) {
01575         return functions->NewDoubleArray(this,len);
01576     }
01577 
01578     jboolean * GetBooleanArrayElements(jbooleanArray array, jboolean *isCopy) {
01579         return functions->GetBooleanArrayElements(this,array,isCopy);
01580     }
01581     jbyte * GetByteArrayElements(jbyteArray array, jboolean *isCopy) {
01582         return functions->GetByteArrayElements(this,array,isCopy);
01583     }
01584     jchar * GetCharArrayElements(jcharArray array, jboolean *isCopy) {
01585         return functions->GetCharArrayElements(this,array,isCopy);
01586     }
01587     jshort * GetShortArrayElements(jshortArray array, jboolean *isCopy) {
01588         return functions->GetShortArrayElements(this,array,isCopy);
01589     }
01590     jint * GetIntArrayElements(jintArray array, jboolean *isCopy) {
01591         return functions->GetIntArrayElements(this,array,isCopy);
01592     }
01593     jlong * GetLongArrayElements(jlongArray array, jboolean *isCopy) {
01594         return functions->GetLongArrayElements(this,array,isCopy);
01595     }
01596     jfloat * GetFloatArrayElements(jfloatArray array, jboolean *isCopy) {
01597         return functions->GetFloatArrayElements(this,array,isCopy);
01598     }
01599     jdouble * GetDoubleArrayElements(jdoubleArray array, jboolean *isCopy) {
01600         return functions->GetDoubleArrayElements(this,array,isCopy);
01601     }
01602 
01603     void ReleaseBooleanArrayElements(jbooleanArray array, 
01604                                  jboolean *elems,
01605                                  jint mode) {
01606         functions->ReleaseBooleanArrayElements(this,array,elems,mode);
01607     }
01608     void ReleaseByteArrayElements(jbyteArray array, 
01609                               jbyte *elems,
01610                               jint mode) {
01611         functions->ReleaseByteArrayElements(this,array,elems,mode);
01612     }
01613     void ReleaseCharArrayElements(jcharArray array, 
01614                               jchar *elems,
01615                               jint mode) {
01616         functions->ReleaseCharArrayElements(this,array,elems,mode);
01617     }
01618     void ReleaseShortArrayElements(jshortArray array, 
01619                                jshort *elems,
01620                                jint mode) {
01621         functions->ReleaseShortArrayElements(this,array,elems,mode);
01622     }
01623     void ReleaseIntArrayElements(jintArray array, 
01624                              jint *elems,
01625                              jint mode) {
01626         functions->ReleaseIntArrayElements(this,array,elems,mode);
01627     }
01628     void ReleaseLongArrayElements(jlongArray array, 
01629                               jlong *elems,
01630                               jint mode) {
01631         functions->ReleaseLongArrayElements(this,array,elems,mode);
01632     }
01633     void ReleaseFloatArrayElements(jfloatArray array, 
01634                                jfloat *elems,
01635                                jint mode) {
01636         functions->ReleaseFloatArrayElements(this,array,elems,mode);
01637     }
01638     void ReleaseDoubleArrayElements(jdoubleArray array, 
01639                                 jdouble *elems,
01640                                 jint mode) {
01641         functions->ReleaseDoubleArrayElements(this,array,elems,mode);
01642     }
01643 
01644     void GetBooleanArrayRegion(jbooleanArray array, 
01645                             jsize start, jsize len, jboolean *buf) {
01646         functions->GetBooleanArrayRegion(this,array,start,len,buf);
01647     }
01648     void GetByteArrayRegion(jbyteArray array, 
01649                          jsize start, jsize len, jbyte *buf) {
01650         functions->GetByteArrayRegion(this,array,start,len,buf);
01651     }
01652     void GetCharArrayRegion(jcharArray array, 
01653                          jsize start, jsize len, jchar *buf) {
01654         functions->GetCharArrayRegion(this,array,start,len,buf);
01655     }
01656     void GetShortArrayRegion(jshortArray array, 
01657                           jsize start, jsize len, jshort *buf) {
01658         functions->GetShortArrayRegion(this,array,start,len,buf);
01659     }
01660     void GetIntArrayRegion(jintArray array, 
01661                         jsize start, jsize len, jint *buf) {
01662         functions->GetIntArrayRegion(this,array,start,len,buf);
01663     }
01664     void GetLongArrayRegion(jlongArray array, 
01665                          jsize start, jsize len, jlong *buf) {
01666         functions->GetLongArrayRegion(this,array,start,len,buf);
01667     }
01668     void GetFloatArrayRegion(jfloatArray array, 
01669                           jsize start, jsize len, jfloat *buf) {
01670         functions->GetFloatArrayRegion(this,array,start,len,buf);
01671     }
01672     void GetDoubleArrayRegion(jdoubleArray array, 
01673                            jsize start, jsize len, jdouble *buf) {
01674         functions->GetDoubleArrayRegion(this,array,start,len,buf);
01675     }
01676 
01677     void SetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len, 
01678                             jboolean *buf) {
01679         functions->SetBooleanArrayRegion(this,array,start,len,buf);
01680     }
01681     void SetByteArrayRegion(jbyteArray array, jsize start, jsize len,
01682                          jbyte *buf) {
01683         functions->SetByteArrayRegion(this,array,start,len,buf);
01684     }
01685     void SetCharArrayRegion(jcharArray array, jsize start, jsize len, 
01686                          jchar *buf) {
01687         functions->SetCharArrayRegion(this,array,start,len,buf);
01688     }
01689     void SetShortArrayRegion(jshortArray array, jsize start, jsize len, 
01690                           jshort *buf) {
01691         functions->SetShortArrayRegion(this,array,start,len,buf);
01692     }
01693     void SetIntArrayRegion(jintArray array, jsize start, jsize len,
01694                         jint *buf) {
01695         functions->SetIntArrayRegion(this,array,start,len,buf);
01696     }
01697     void SetLongArrayRegion(jlongArray array, jsize start, jsize len,
01698                          jlong *buf) {
01699         functions->SetLongArrayRegion(this,array,start,len,buf);
01700     }
01701     void SetFloatArrayRegion(jfloatArray array, jsize start, jsize len, 
01702                           jfloat *buf) {
01703         functions->SetFloatArrayRegion(this,array,start,len,buf);
01704     }
01705     void SetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len,
01706                            jdouble *buf) {
01707         functions->SetDoubleArrayRegion(this,array,start,len,buf);
01708     }
01709 
01710     jint RegisterNatives(jclass clazz, const JNINativeMethod *methods,
01711                       jint nMethods) {
01712         return functions->RegisterNatives(this,clazz,methods,nMethods);
01713     }
01714     jint UnregisterNatives(jclass clazz) {
01715         return functions->UnregisterNatives(this,clazz);
01716     }  
01717    
01718     jint MonitorEnter(jobject obj) {
01719         return functions->MonitorEnter(this,obj);
01720     }
01721     jint MonitorExit(jobject obj) {
01722         return functions->MonitorExit(this,obj);
01723     }
01724 
01725     jint GetJavaVM(JavaVM **vm) {
01726         return functions->GetJavaVM(this,vm);
01727     }
01728   
01729 #endif /* __cplusplus */
01730 };
01731 
01732 /* These structures will be VM-specific. */
01733 
01734 typedef struct JDK1_1InitArgs {
01735     jint version;
01736 
01737     char **properties;
01738     jint checkSource; 
01739     jint nativeStackSize;
01740     jint javaStackSize;
01741     jint minHeapSize;
01742     jint maxHeapSize;
01743     jint verifyMode;
01744     char *classpath;
01745 
01746     jint (JNICALL *vfprintf)(FILE *fp, const char *format, va_list args);
01747     void (JNICALL *exit)(jint code);
01748     void (JNICALL *abort)();
01749     
01750     jint enableClassGC;
01751     jint enableVerboseGC;
01752     jint disableAsyncGC;
01753     jint verbose;
01754     jboolean debugging;
01755     jint debugPort;
01756 } JDK1_1InitArgs;
01757 
01758 typedef struct JDK1_1AttachArgs {
01759     void * __padding; /* C compilers don't allow empty structures. */
01760 } JDK1_1AttachArgs;
01761 
01762 /* End VM-specific. */
01763 
01764 struct JNIInvokeInterface_ {
01765     void *reserved0;
01766     void *reserved1;
01767     void *reserved2;
01768 
01769     jint (JNICALL *DestroyJavaVM)(JavaVM *vm);
01770 
01771     jint (JNICALL *AttachCurrentThread)
01772       (JavaVM *vm, JNIEnv **penv, void *args);
01773 
01774     jint (JNICALL *DetachCurrentThread)(JavaVM *vm);
01775 };
01776 
01777 struct JavaVM_ {
01778     const struct JNIInvokeInterface_ *functions;
01779     void *reserved0;
01780     void *reserved1;
01781     void *reserved2;
01782 #ifdef __cplusplus
01783 
01784     jint DestroyJavaVM() {
01785         return functions->DestroyJavaVM(this);
01786     }
01787     jint AttachCurrentThread(JNIEnv **penv, void *args) {
01788         return functions->AttachCurrentThread(this, penv, args);
01789     }
01790     jint DetachCurrentThread() {
01791         return functions->DetachCurrentThread(this);
01792     }
01793 
01794 #endif
01795 };
01796 
01797 JNI_PUBLIC_API(void) JNI_GetDefaultJavaVMInitArgs(void *);
01798 
01799 JNI_PUBLIC_API(jint) JNI_CreateJavaVM(JavaVM **, JNIEnv **, void *);
01800 
01801 JNI_PUBLIC_API(jint) JNI_GetCreatedJavaVMs(JavaVM **, jsize, jsize *);
01802 JNI_PUBLIC_API(jref) JNI_MakeLocalRef(JNIEnv *pJNIEnv, void *pHObject);
01803 
01804 #ifdef __cplusplus
01805 } /* extern "C" */
01806 #endif /* __cplusplus */
01807 
01808 #endif /* JNI_H */
01809 
01810