1 /* ***** BEGIN LICENSE BLOCK *****

     2  * Version: MPL 1.1/GPL 2.0/LGPL 2.1

     3  *

     4  * The contents of this file are subject to the Mozilla Public License Version

     5  * 1.1 (the "License"); you may not use this file except in compliance with

     6  * the License. You may obtain a copy of the License at

     7  * http://www.mozilla.org/MPL/

     8  *

     9  * Software distributed under the License is distributed on an "AS IS" basis,

    10  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License

    11  * for the specific language governing rights and limitations under the

    12  * License.

    13  *

    14  * The Original Code is the Java Runtime Interface.

    15  *

    16  * The Initial Developer of the Original Code is

    17  * Netscape Communications Corporation and Sun Microsystems, Inc.

    18  * Portions created by the Initial Developer are Copyright (C) 1993-1996

    19  * the Initial Developer. All Rights Reserved.

    20  *

    21  * Contributor(s):

    22  *

    23  * Alternatively, the contents of this file may be used under the terms of

    24  * either the GNU General Public License Version 2 or later (the "GPL"), or

    25  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),

    26  * in which case the provisions of the GPL or the LGPL are applicable instead

    27  * of those above. If you wish to allow use of your version of this file only

    28  * under the terms of either the GPL or the LGPL, and not to allow others to

    29  * use your version of this file under the terms of the MPL, indicate your

    30  * decision by deleting the provisions above and replace them with the notice

    31  * and other provisions required by the GPL or the LGPL. If you do not delete

    32  * the provisions above, a recipient may use your version of this file under

    33  * the terms of any one of the MPL, the GPL or the LGPL.

    34  *

    35  * ***** END LICENSE BLOCK ***** */

    36 

    37 #ifndef JNI_H

    38 #define JNI_H

    39 

    40 #include <stdio.h>

    41 #include <stdarg.h>

    42 

    43 /* jni_md.h contains the machine-dependent typedefs for jbyte, jint 

    44    and jlong */ 

    45 

    46 #include "jni_md.h"

    47 

    48 #ifdef __cplusplus

    49 extern "C" {

    50 #endif

    51 

    52 /*

    53  * JNI Types

    54  */

    55 

    56 typedef unsigned char	jboolean;

    57 typedef unsigned short	jchar;

    58 typedef short		jshort;

    59 typedef float		jfloat;

    60 typedef double		jdouble;

    61 

    62 typedef jint            jsize;

    63 

    64 #ifdef __cplusplus

    65 

    66 class _jobject {};

    67 class _jclass : public _jobject {};

    68 class _jthrowable : public _jobject {};

    69 class _jstring : public _jobject {};

    70 class _jarray : public _jobject {};

    71 class _jbooleanArray : public _jarray {};

    72 class _jbyteArray : public _jarray {};

    73 class _jcharArray : public _jarray {};

    74 class _jshortArray : public _jarray {};

    75 class _jintArray : public _jarray {};

    76 class _jlongArray : public _jarray {};

    77 class _jfloatArray : public _jarray {};

    78 class _jdoubleArray : public _jarray {};

    79 class _jobjectArray : public _jarray {};

    80 

    81 typedef _jobject *jobject;

    82 typedef _jclass *jclass;

    83 typedef _jthrowable *jthrowable;

    84 typedef _jstring *jstring;

    85 typedef _jarray *jarray;

    86 typedef _jbooleanArray *jbooleanArray;

    87 typedef _jbyteArray *jbyteArray;

    88 typedef _jcharArray *jcharArray;

    89 typedef _jshortArray *jshortArray;

    90 typedef _jintArray *jintArray;

    91 typedef _jlongArray *jlongArray;

    92 typedef _jfloatArray *jfloatArray;

    93 typedef _jdoubleArray *jdoubleArray;

    94 typedef _jobjectArray *jobjectArray;

    95 

    96 #else

    97 

    98 struct _jobject;

    99 

   100 typedef struct _jobject *jobject;

   101 typedef jobject jclass;

   102 typedef jobject jthrowable;

   103 typedef jobject jstring;

   104 typedef jobject jarray;

   105 typedef jarray jbooleanArray;

   106 typedef jarray jbyteArray;

   107 typedef jarray jcharArray;

   108 typedef jarray jshortArray;

   109 typedef jarray jintArray;

   110 typedef jarray jlongArray;

   111 typedef jarray jfloatArray;

   112 typedef jarray jdoubleArray;

   113 typedef jarray jobjectArray;

   114 

   115 #endif

   116 

   117 typedef jobject jweak;

   118 

   119 #if 0	/* moved to jri_md.h */

   120 typedef jobject jref; /* For transition---not meant to be part of public 

   121 			 API anymore.*/

   122 #endif

   123 

   124 typedef union jvalue {

   125     jboolean z;

   126     jbyte    b;

   127     jchar    c;

   128     jshort   s;

   129     jint     i;

   130     jlong    j;

   131     jfloat   f;

   132     jdouble  d;

   133     jobject  l;

   134 } jvalue;

   135 

   136 struct _jfieldID;

   137 typedef struct _jfieldID *jfieldID;

   138 

   139 struct _jmethodID;

   140 typedef struct _jmethodID *jmethodID;

   141 

   142 /*

   143  * jboolean constants

   144  */

   145 

   146 #define JNI_FALSE 0

   147 #define JNI_TRUE 1

   148 

   149 /*

   150  * possible return values for JNI functions.

   151  */

   152 

   153 #define JNI_OK           0                 /* success */

   154 #define JNI_ERR          (-1)              /* unknown error */

   155 #define JNI_EDETACHED    (-2)              /* thread detached from the VM */

   156 #define JNI_EVERSION     (-3)              /* JNI version error */

   157 #define JNI_ENOMEM       (-4)              /* not enough memory */

   158 #define JNI_EEXIST       (-5)              /* VM already created */

   159 #define JNI_EINVAL       (-6)              /* invalid arguments */

   160 

   161 /*

   162  * used in ReleaseScalarArrayElements

   163  */

   164   

   165 #define JNI_COMMIT 1

   166 #define JNI_ABORT 2

   167 

   168 /*

   169  * used in RegisterNatives to describe native method name, signature,

   170  * and function pointer.

   171  */

   172 

   173 typedef struct {

   174     char *name;

   175     char *signature;

   176     void *fnPtr;

   177 } JNINativeMethod;

   178 

   179 /*

   180  * JNI Native Method Interface.

   181  */

   182 

   183 struct JNINativeInterface_;

   184 

   185 struct JNIEnv_;

   186 

   187 #ifdef __cplusplus

   188 typedef JNIEnv_ JNIEnv;

   189 #else

   190 typedef const struct JNINativeInterface_ *JNIEnv;

   191 #endif

   192 

   193 /*

   194  * JNI Invocation Interface.

   195  */

   196 

   197 struct JNIInvokeInterface_;

   198 

   199 struct JavaVM_;

   200 

   201 #ifdef __cplusplus

   202 typedef JavaVM_ JavaVM;

   203 #else

   204 typedef const struct JNIInvokeInterface_ *JavaVM;

   205 #endif

   206 

   207 struct JNINativeInterface_ {

   208     void *reserved0;

   209     void *reserved1;

   210     void *reserved2;

   211 

   212     void *reserved3;

   213     jint (JNICALL *GetVersion)(JNIEnv *env);

   214 

   215     jclass (JNICALL *DefineClass)

   216       (JNIEnv *env, const char *name, jobject loader, const jbyte *buf, 

   217        jsize len);

   218     jclass (JNICALL *FindClass)

   219       (JNIEnv *env, const char *name);

   220 

   221     jmethodID (JNICALL *FromReflectedMethod)

   222       (JNIEnv *env, jobject method);

   223     jfieldID (JNICALL *FromReflectedField)

   224       (JNIEnv *env, jobject field);

   225 

   226     jobject (JNICALL *ToReflectedMethod)

   227       (JNIEnv *env, jclass cls, jmethodID methodID, jboolean isStatic);

   228 

   229     jclass (JNICALL *GetSuperclass)

   230       (JNIEnv *env, jclass sub);

   231     jboolean (JNICALL *IsAssignableFrom)

   232       (JNIEnv *env, jclass sub, jclass sup);

   233 

   234     jobject (JNICALL *ToReflectedField)

   235       (JNIEnv *env, jclass cls, jfieldID fieldID, jboolean isStatic);

   236 

   237     jint (JNICALL *Throw)

   238       (JNIEnv *env, jthrowable obj);

   239     jint (JNICALL *ThrowNew)

   240       (JNIEnv *env, jclass clazz, const char *msg);

   241     jthrowable (JNICALL *ExceptionOccurred)

   242       (JNIEnv *env);

   243     void (JNICALL *ExceptionDescribe)

   244       (JNIEnv *env);

   245     void (JNICALL *ExceptionClear)

   246       (JNIEnv *env);

   247     void (JNICALL *FatalError)

   248       (JNIEnv *env, const char *msg);

   249 

   250     jint (JNICALL *PushLocalFrame)

   251       (JNIEnv *env, jint capacity);

   252     jobject (JNICALL *PopLocalFrame)

   253       (JNIEnv *env, jobject result);

   254 

   255     jobject (JNICALL *NewGlobalRef)

   256       (JNIEnv *env, jobject lobj);

   257     void (JNICALL *DeleteGlobalRef)

   258       (JNIEnv *env, jobject gref);

   259     void (JNICALL *DeleteLocalRef)

   260       (JNIEnv *env, jobject obj);

   261     jboolean (JNICALL *IsSameObject)

   262       (JNIEnv *env, jobject obj1, jobject obj2);

   263     jobject (JNICALL *NewLocalRef)

   264       (JNIEnv *env, jobject ref);

   265     jint (JNICALL *EnsureLocalCapacity)

   266       (JNIEnv *env, jint capacity);

   267 

   268     jobject (JNICALL *AllocObject)

   269       (JNIEnv *env, jclass clazz);

   270     jobject (JNICALL *NewObject)

   271       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);

   272     jobject (JNICALL *NewObjectV)

   273       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);

   274     jobject (JNICALL *NewObjectA)

   275       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);

   276 

   277     jclass (JNICALL *GetObjectClass)

   278       (JNIEnv *env, jobject obj);

   279     jboolean (JNICALL *IsInstanceOf)

   280       (JNIEnv *env, jobject obj, jclass clazz);

   281 

   282     jmethodID (JNICALL *GetMethodID)

   283       (JNIEnv *env, jclass clazz, const char *name, const char *sig);

   284 

   285     jobject (JNICALL *CallObjectMethod)

   286       (JNIEnv *env, jobject obj, jmethodID methodID, ...);

   287     jobject (JNICALL *CallObjectMethodV)

   288       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);

   289     jobject (JNICALL *CallObjectMethodA)

   290       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args);

   291 

   292     jboolean (JNICALL *CallBooleanMethod)

   293       (JNIEnv *env, jobject obj, jmethodID methodID, ...);

   294     jboolean (JNICALL *CallBooleanMethodV)

   295       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);

   296     jboolean (JNICALL *CallBooleanMethodA)

   297       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args);

   298 

   299     jbyte (JNICALL *CallByteMethod)

   300       (JNIEnv *env, jobject obj, jmethodID methodID, ...);

   301     jbyte (JNICALL *CallByteMethodV)

   302       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);

   303     jbyte (JNICALL *CallByteMethodA)

   304       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);

   305 

   306     jchar (JNICALL *CallCharMethod)

   307       (JNIEnv *env, jobject obj, jmethodID methodID, ...);

   308     jchar (JNICALL *CallCharMethodV)

   309       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);

   310     jchar (JNICALL *CallCharMethodA)

   311       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);

   312 

   313     jshort (JNICALL *CallShortMethod)

   314       (JNIEnv *env, jobject obj, jmethodID methodID, ...);

   315     jshort (JNICALL *CallShortMethodV)

   316       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);

   317     jshort (JNICALL *CallShortMethodA)

   318       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);

   319 

   320     jint (JNICALL *CallIntMethod)

   321       (JNIEnv *env, jobject obj, jmethodID methodID, ...);

   322     jint (JNICALL *CallIntMethodV)

   323       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);

   324     jint (JNICALL *CallIntMethodA)

   325       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);

   326 

   327     jlong (JNICALL *CallLongMethod)

   328       (JNIEnv *env, jobject obj, jmethodID methodID, ...);

   329     jlong (JNICALL *CallLongMethodV)

   330       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);

   331     jlong (JNICALL *CallLongMethodA)

   332       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);

   333 

   334     jfloat (JNICALL *CallFloatMethod)

   335       (JNIEnv *env, jobject obj, jmethodID methodID, ...);

   336     jfloat (JNICALL *CallFloatMethodV)

   337       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);

   338     jfloat (JNICALL *CallFloatMethodA)

   339       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);

   340 

   341     jdouble (JNICALL *CallDoubleMethod)

   342       (JNIEnv *env, jobject obj, jmethodID methodID, ...);

   343     jdouble (JNICALL *CallDoubleMethodV)

   344       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);

   345     jdouble (JNICALL *CallDoubleMethodA)

   346       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);

   347 

   348     void (JNICALL *CallVoidMethod)

   349       (JNIEnv *env, jobject obj, jmethodID methodID, ...);

   350     void (JNICALL *CallVoidMethodV)

   351       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);

   352     void (JNICALL *CallVoidMethodA)

   353       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args);

   354 

   355     jobject (JNICALL *CallNonvirtualObjectMethod)

   356       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);

   357     jobject (JNICALL *CallNonvirtualObjectMethodV)

   358       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, 

   359        va_list args);

   360     jobject (JNICALL *CallNonvirtualObjectMethodA)

   361       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, 

   362        jvalue * args);

   363 

   364     jboolean (JNICALL *CallNonvirtualBooleanMethod)

   365       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);

   366     jboolean (JNICALL *CallNonvirtualBooleanMethodV)

   367       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,

   368        va_list args);

   369     jboolean (JNICALL *CallNonvirtualBooleanMethodA)

   370       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,

   371        jvalue * args);

   372 

   373     jbyte (JNICALL *CallNonvirtualByteMethod)

   374       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);

   375     jbyte (JNICALL *CallNonvirtualByteMethodV)

   376       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,

   377        va_list args);

   378     jbyte (JNICALL *CallNonvirtualByteMethodA)

   379       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, 

   380        jvalue *args);

   381 

   382     jchar (JNICALL *CallNonvirtualCharMethod)

   383       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);

   384     jchar (JNICALL *CallNonvirtualCharMethodV)

   385       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,

   386        va_list args);

   387     jchar (JNICALL *CallNonvirtualCharMethodA)

   388       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,

   389        jvalue *args);

   390 

   391     jshort (JNICALL *CallNonvirtualShortMethod)

   392       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);

   393     jshort (JNICALL *CallNonvirtualShortMethodV)

   394       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,

   395        va_list args);

   396     jshort (JNICALL *CallNonvirtualShortMethodA)

   397       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,

   398        jvalue *args);

   399 

   400     jint (JNICALL *CallNonvirtualIntMethod)

   401       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);

   402     jint (JNICALL *CallNonvirtualIntMethodV)

   403       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,

   404        va_list args);

   405     jint (JNICALL *CallNonvirtualIntMethodA)

   406       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,

   407        jvalue *args);

   408 

   409     jlong (JNICALL *CallNonvirtualLongMethod)

   410       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);

   411     jlong (JNICALL *CallNonvirtualLongMethodV)

   412       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,

   413        va_list args);

   414     jlong (JNICALL *CallNonvirtualLongMethodA)

   415       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, 

   416        jvalue *args);

   417 

   418     jfloat (JNICALL *CallNonvirtualFloatMethod)

   419       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);

   420     jfloat (JNICALL *CallNonvirtualFloatMethodV)

   421       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,

   422        va_list args);

   423     jfloat (JNICALL *CallNonvirtualFloatMethodA)

   424       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,

   425        jvalue *args);

   426 

   427     jdouble (JNICALL *CallNonvirtualDoubleMethod)

   428       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);

   429     jdouble (JNICALL *CallNonvirtualDoubleMethodV)

   430       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,

   431        va_list args);

   432     jdouble (JNICALL *CallNonvirtualDoubleMethodA)

   433       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,

   434        jvalue *args);

   435 

   436     void (JNICALL *CallNonvirtualVoidMethod)

   437       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);

   438     void (JNICALL *CallNonvirtualVoidMethodV)

   439       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,

   440        va_list args);

   441     void (JNICALL *CallNonvirtualVoidMethodA)

   442       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,

   443        jvalue * args);

   444 

   445     jfieldID (JNICALL *GetFieldID)

   446       (JNIEnv *env, jclass clazz, const char *name, const char *sig);

   447 

   448     jobject (JNICALL *GetObjectField)

   449       (JNIEnv *env, jobject obj, jfieldID fieldID);

   450     jboolean (JNICALL *GetBooleanField)

   451       (JNIEnv *env, jobject obj, jfieldID fieldID);

   452     jbyte (JNICALL *GetByteField)

   453       (JNIEnv *env, jobject obj, jfieldID fieldID);

   454     jchar (JNICALL *GetCharField)

   455       (JNIEnv *env, jobject obj, jfieldID fieldID);

   456     jshort (JNICALL *GetShortField)

   457       (JNIEnv *env, jobject obj, jfieldID fieldID);

   458     jint (JNICALL *GetIntField)

   459       (JNIEnv *env, jobject obj, jfieldID fieldID);

   460     jlong (JNICALL *GetLongField)

   461       (JNIEnv *env, jobject obj, jfieldID fieldID);

   462     jfloat (JNICALL *GetFloatField)

   463       (JNIEnv *env, jobject obj, jfieldID fieldID);

   464     jdouble (JNICALL *GetDoubleField)

   465       (JNIEnv *env, jobject obj, jfieldID fieldID);

   466 

   467     void (JNICALL *SetObjectField)

   468       (JNIEnv *env, jobject obj, jfieldID fieldID, jobject val);

   469     void (JNICALL *SetBooleanField)

   470       (JNIEnv *env, jobject obj, jfieldID fieldID, jboolean val);

   471     void (JNICALL *SetByteField)

   472       (JNIEnv *env, jobject obj, jfieldID fieldID, jbyte val);

   473     void (JNICALL *SetCharField)

   474       (JNIEnv *env, jobject obj, jfieldID fieldID, jchar val);

   475     void (JNICALL *SetShortField)

   476       (JNIEnv *env, jobject obj, jfieldID fieldID, jshort val);

   477     void (JNICALL *SetIntField)

   478       (JNIEnv *env, jobject obj, jfieldID fieldID, jint val);

   479     void (JNICALL *SetLongField)

   480       (JNIEnv *env, jobject obj, jfieldID fieldID, jlong val);

   481     void (JNICALL *SetFloatField)

   482       (JNIEnv *env, jobject obj, jfieldID fieldID, jfloat val);

   483     void (JNICALL *SetDoubleField)

   484       (JNIEnv *env, jobject obj, jfieldID fieldID, jdouble val);

   485 

   486     jmethodID (JNICALL *GetStaticMethodID)

   487       (JNIEnv *env, jclass clazz, const char *name, const char *sig);

   488 

   489     jobject (JNICALL *CallStaticObjectMethod)

   490       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);

   491     jobject (JNICALL *CallStaticObjectMethodV)

   492       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);

   493     jobject (JNICALL *CallStaticObjectMethodA)

   494       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);

   495 

   496     jboolean (JNICALL *CallStaticBooleanMethod)

   497       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);

   498     jboolean (JNICALL *CallStaticBooleanMethodV)

   499       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);

   500     jboolean (JNICALL *CallStaticBooleanMethodA)

   501       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);

   502 

   503     jbyte (JNICALL *CallStaticByteMethod)

   504       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);

   505     jbyte (JNICALL *CallStaticByteMethodV)

   506       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);

   507     jbyte (JNICALL *CallStaticByteMethodA)

   508       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);

   509 

   510     jchar (JNICALL *CallStaticCharMethod)

   511       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);

   512     jchar (JNICALL *CallStaticCharMethodV)

   513       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);

   514     jchar (JNICALL *CallStaticCharMethodA)

   515       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);

   516 

   517     jshort (JNICALL *CallStaticShortMethod)

   518       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);

   519     jshort (JNICALL *CallStaticShortMethodV)

   520       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);

   521     jshort (JNICALL *CallStaticShortMethodA)

   522       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);

   523 

   524     jint (JNICALL *CallStaticIntMethod)

   525       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);

   526     jint (JNICALL *CallStaticIntMethodV)

   527       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);

   528     jint (JNICALL *CallStaticIntMethodA)

   529       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);

   530 

   531     jlong (JNICALL *CallStaticLongMethod)

   532       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);

   533     jlong (JNICALL *CallStaticLongMethodV)

   534       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);

   535     jlong (JNICALL *CallStaticLongMethodA)

   536       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);

   537 

   538     jfloat (JNICALL *CallStaticFloatMethod)

   539       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);

   540     jfloat (JNICALL *CallStaticFloatMethodV)

   541       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);

   542     jfloat (JNICALL *CallStaticFloatMethodA)

   543       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);

   544 

   545     jdouble (JNICALL *CallStaticDoubleMethod)

   546       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);

   547     jdouble (JNICALL *CallStaticDoubleMethodV)

   548       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);

   549     jdouble (JNICALL *CallStaticDoubleMethodA)       

   550       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);

   551 

   552     void (JNICALL *CallStaticVoidMethod)

   553       (JNIEnv *env, jclass cls, jmethodID methodID, ...);

   554     void (JNICALL *CallStaticVoidMethodV)

   555       (JNIEnv *env, jclass cls, jmethodID methodID, va_list args);

   556     void (JNICALL *CallStaticVoidMethodA)

   557       (JNIEnv *env, jclass cls, jmethodID methodID, jvalue * args);

   558 

   559     jfieldID (JNICALL *GetStaticFieldID)

   560       (JNIEnv *env, jclass clazz, const char *name, const char *sig);

   561     jobject (JNICALL *GetStaticObjectField)

   562       (JNIEnv *env, jclass clazz, jfieldID fieldID);

   563     jboolean (JNICALL *GetStaticBooleanField)

   564       (JNIEnv *env, jclass clazz, jfieldID fieldID);

   565     jbyte (JNICALL *GetStaticByteField)

   566       (JNIEnv *env, jclass clazz, jfieldID fieldID);

   567     jchar (JNICALL *GetStaticCharField)

   568       (JNIEnv *env, jclass clazz, jfieldID fieldID);

   569     jshort (JNICALL *GetStaticShortField)

   570       (JNIEnv *env, jclass clazz, jfieldID fieldID);

   571     jint (JNICALL *GetStaticIntField)

   572       (JNIEnv *env, jclass clazz, jfieldID fieldID);

   573     jlong (JNICALL *GetStaticLongField)

   574       (JNIEnv *env, jclass clazz, jfieldID fieldID);

   575     jfloat (JNICALL *GetStaticFloatField)

   576       (JNIEnv *env, jclass clazz, jfieldID fieldID);

   577     jdouble (JNICALL *GetStaticDoubleField)

   578       (JNIEnv *env, jclass clazz, jfieldID fieldID);

   579 

   580     void (JNICALL *SetStaticObjectField)

   581       (JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value);

   582     void (JNICALL *SetStaticBooleanField)

   583       (JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value);

   584     void (JNICALL *SetStaticByteField)

   585       (JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value);

   586     void (JNICALL *SetStaticCharField)

   587       (JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value);

   588     void (JNICALL *SetStaticShortField)

   589       (JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value);

   590     void (JNICALL *SetStaticIntField)

   591       (JNIEnv *env, jclass clazz, jfieldID fieldID, jint value);

   592     void (JNICALL *SetStaticLongField)

   593       (JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value);

   594     void (JNICALL *SetStaticFloatField)

   595       (JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value);

   596     void (JNICALL *SetStaticDoubleField)

   597       (JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value);

   598 

   599     jstring (JNICALL *NewString)

   600       (JNIEnv *env, const jchar *unicode, jsize len);

   601     jsize (JNICALL *GetStringLength)

   602       (JNIEnv *env, jstring str);

   603     const jchar *(JNICALL *GetStringChars)

   604       (JNIEnv *env, jstring str, jboolean *isCopy);

   605     void (JNICALL *ReleaseStringChars)

   606       (JNIEnv *env, jstring str, const jchar *chars);

   607   

   608     jstring (JNICALL *NewStringUTF)

   609       (JNIEnv *env, const char *utf);

   610     jsize (JNICALL *GetStringUTFLength)

   611       (JNIEnv *env, jstring str);

   612     const char* (JNICALL *GetStringUTFChars)

   613       (JNIEnv *env, jstring str, jboolean *isCopy);

   614     void (JNICALL *ReleaseStringUTFChars)

   615       (JNIEnv *env, jstring str, const char* chars);

   616   

   617 

   618     jsize (JNICALL *GetArrayLength)

   619       (JNIEnv *env, jarray array);

   620 

   621     jobjectArray (JNICALL *NewObjectArray)

   622       (JNIEnv *env, jsize len, jclass clazz, jobject init);

   623     jobject (JNICALL *GetObjectArrayElement)

   624       (JNIEnv *env, jobjectArray array, jsize index);

   625     void (JNICALL *SetObjectArrayElement)

   626       (JNIEnv *env, jobjectArray array, jsize index, jobject val);

   627 

   628     jbooleanArray (JNICALL *NewBooleanArray)

   629       (JNIEnv *env, jsize len);

   630     jbyteArray (JNICALL *NewByteArray)

   631       (JNIEnv *env, jsize len);

   632     jcharArray (JNICALL *NewCharArray)

   633       (JNIEnv *env, jsize len);

   634     jshortArray (JNICALL *NewShortArray)

   635       (JNIEnv *env, jsize len);

   636     jintArray (JNICALL *NewIntArray)

   637       (JNIEnv *env, jsize len);

   638     jlongArray (JNICALL *NewLongArray)

   639       (JNIEnv *env, jsize len);

   640     jfloatArray (JNICALL *NewFloatArray)

   641       (JNIEnv *env, jsize len);

   642     jdoubleArray (JNICALL *NewDoubleArray)

   643       (JNIEnv *env, jsize len);

   644 

   645     jboolean * (JNICALL *GetBooleanArrayElements)

   646       (JNIEnv *env, jbooleanArray array, jboolean *isCopy);

   647     jbyte * (JNICALL *GetByteArrayElements)

   648       (JNIEnv *env, jbyteArray array, jboolean *isCopy);

   649     jchar * (JNICALL *GetCharArrayElements)

   650       (JNIEnv *env, jcharArray array, jboolean *isCopy);

   651     jshort * (JNICALL *GetShortArrayElements)

   652       (JNIEnv *env, jshortArray array, jboolean *isCopy);

   653     jint * (JNICALL *GetIntArrayElements)

   654       (JNIEnv *env, jintArray array, jboolean *isCopy);

   655     jlong * (JNICALL *GetLongArrayElements)

   656       (JNIEnv *env, jlongArray array, jboolean *isCopy);

   657     jfloat * (JNICALL *GetFloatArrayElements)

   658       (JNIEnv *env, jfloatArray array, jboolean *isCopy);

   659     jdouble * (JNICALL *GetDoubleArrayElements)

   660       (JNIEnv *env, jdoubleArray array, jboolean *isCopy);

   661 

   662     void (JNICALL *ReleaseBooleanArrayElements)

   663       (JNIEnv *env, jbooleanArray array, jboolean *elems, jint mode);

   664     void (JNICALL *ReleaseByteArrayElements)

   665       (JNIEnv *env, jbyteArray array, jbyte *elems, jint mode);

   666     void (JNICALL *ReleaseCharArrayElements)

   667       (JNIEnv *env, jcharArray array, jchar *elems, jint mode);

   668     void (JNICALL *ReleaseShortArrayElements)

   669       (JNIEnv *env, jshortArray array, jshort *elems, jint mode);

   670     void (JNICALL *ReleaseIntArrayElements)

   671       (JNIEnv *env, jintArray array, jint *elems, jint mode);

   672     void (JNICALL *ReleaseLongArrayElements)

   673       (JNIEnv *env, jlongArray array, jlong *elems, jint mode);

   674     void (JNICALL *ReleaseFloatArrayElements)

   675       (JNIEnv *env, jfloatArray array, jfloat *elems, jint mode);

   676     void (JNICALL *ReleaseDoubleArrayElements)

   677       (JNIEnv *env, jdoubleArray array, jdouble *elems, jint mode);

   678 

   679     void (JNICALL *GetBooleanArrayRegion)

   680       (JNIEnv *env, jbooleanArray array, jsize start, jsize l, jboolean *buf);

   681     void (JNICALL *GetByteArrayRegion)

   682       (JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf);

   683     void (JNICALL *GetCharArrayRegion)

   684       (JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf);

   685     void (JNICALL *GetShortArrayRegion)

   686       (JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf);

   687     void (JNICALL *GetIntArrayRegion)

   688       (JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf);

   689     void (JNICALL *GetLongArrayRegion)

   690       (JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf);

   691     void (JNICALL *GetFloatArrayRegion)

   692       (JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf);

   693     void (JNICALL *GetDoubleArrayRegion)

   694       (JNIEnv *env, jdoubleArray array, jsize start, jsize len, jdouble *buf);

   695 

   696     void (JNICALL *SetBooleanArrayRegion)

   697       (JNIEnv *env, jbooleanArray array, jsize start, jsize l, jboolean *buf);

   698     void (JNICALL *SetByteArrayRegion)

   699       (JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf);

   700     void (JNICALL *SetCharArrayRegion)

   701       (JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf);

   702     void (JNICALL *SetShortArrayRegion)

   703       (JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf);

   704     void (JNICALL *SetIntArrayRegion)

   705       (JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf);

   706     void (JNICALL *SetLongArrayRegion)

   707       (JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf);

   708     void (JNICALL *SetFloatArrayRegion)

   709       (JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf);

   710     void (JNICALL *SetDoubleArrayRegion)

   711       (JNIEnv *env, jdoubleArray array, jsize start, jsize len, jdouble *buf);

   712 

   713     jint (JNICALL *RegisterNatives)

   714       (JNIEnv *env, jclass clazz, const JNINativeMethod *methods, 

   715        jint nMethods);

   716     jint (JNICALL *UnregisterNatives)

   717       (JNIEnv *env, jclass clazz);

   718 

   719     jint (JNICALL *MonitorEnter)

   720       (JNIEnv *env, jobject obj);

   721     jint (JNICALL *MonitorExit)

   722       (JNIEnv *env, jobject obj);

   723  

   724     jint (JNICALL *GetJavaVM)

   725       (JNIEnv *env, JavaVM **vm);

   726 

   727     void (JNICALL *GetStringRegion)

   728       (JNIEnv *env, jstring str, jsize start, jsize len, jchar *buf);

   729     void (JNICALL *GetStringUTFRegion)

   730       (JNIEnv *env, jstring str, jsize start, jsize len, char *buf);

   731 

   732     void * (JNICALL *GetPrimitiveArrayCritical)

   733       (JNIEnv *env, jarray array, jboolean *isCopy);

   734     void (JNICALL *ReleasePrimitiveArrayCritical)

   735       (JNIEnv *env, jarray array, void *carray, jint mode);

   736 

   737     const jchar * (JNICALL *GetStringCritical)

   738       (JNIEnv *env, jstring string, jboolean *isCopy);

   739     void (JNICALL *ReleaseStringCritical)

   740       (JNIEnv *env, jstring string, const jchar *cstring);

   741 

   742     jweak (JNICALL *NewWeakGlobalRef)

   743        (JNIEnv *env, jobject obj);

   744     void (JNICALL *DeleteWeakGlobalRef)

   745        (JNIEnv *env, jweak ref);

   746 

   747     jboolean (JNICALL *ExceptionCheck)

   748        (JNIEnv *env);

   749 

   750     jobject (JNICALL *NewDirectByteBuffer)

   751        (JNIEnv* env, void* address, jlong capacity);

   752     void* (JNICALL *GetDirectBufferAddress)

   753        (JNIEnv* env, jobject buf);

   754     jlong (JNICALL *GetDirectBufferCapacity)

   755        (JNIEnv* env, jobject buf);

   756 };

   757 

   758 /*

   759  * We use inlined functions for C++ so that programmers can write:

   760  * 

   761  *    env->FindClass("java/lang/String")

   762  *

   763  * in C++ rather than:

   764  *

   765  *    (*env)->FindClass(env, "java/lang/String")

   766  *

   767  * in C.

   768  */

   769 

   770 struct JNIEnv_ {

   771     const struct JNINativeInterface_ *functions;

   772 #ifdef __cplusplus

   773 

   774     jint GetVersion() {

   775         return functions->GetVersion(this);

   776     }

   777     jclass DefineClass(const char *name, jobject loader, const jbyte *buf,

   778 		       jsize len) {

   779         return functions->DefineClass(this, name, loader, buf, len);

   780     }

   781     jclass FindClass(const char *name) {

   782         return functions->FindClass(this, name);

   783     }

   784     jmethodID FromReflectedMethod(jobject method) {

   785         return functions->FromReflectedMethod(this,method);

   786     }

   787     jfieldID FromReflectedField(jobject field) {

   788         return functions->FromReflectedField(this,field);

   789     }

   790 

   791     jobject ToReflectedMethod(jclass cls, jmethodID methodID, jboolean isStatic) {

   792         return functions->ToReflectedMethod(this, cls, methodID, isStatic);

   793     }

   794 

   795     jclass GetSuperclass(jclass sub) {

   796         return functions->GetSuperclass(this, sub);

   797     }

   798     jboolean IsAssignableFrom(jclass sub, jclass sup) {

   799         return functions->IsAssignableFrom(this, sub, sup);

   800     }

   801 

   802     jobject ToReflectedField(jclass cls, jfieldID fieldID, jboolean isStatic) {

   803         return functions->ToReflectedField(this,cls,fieldID,isStatic);

   804     }

   805 

   806     jint Throw(jthrowable obj) {

   807         return functions->Throw(this, obj);

   808     }    

   809     jint ThrowNew(jclass clazz, const char *msg) {

   810         return functions->ThrowNew(this, clazz, msg);

   811     }

   812     jthrowable ExceptionOccurred() {

   813         return functions->ExceptionOccurred(this);

   814     }

   815     void ExceptionDescribe() {

   816         functions->ExceptionDescribe(this);

   817     }

   818     void ExceptionClear() {

   819         functions->ExceptionClear(this);

   820     }

   821     void FatalError(const char *msg) {

   822         functions->FatalError(this, msg);

   823     }

   824 

   825     jint PushLocalFrame(jint capacity) {

   826         return functions->PushLocalFrame(this,capacity);

   827     }

   828     jobject PopLocalFrame(jobject result) {

   829         return functions->PopLocalFrame(this,result);

   830     }

   831 

   832     jobject NewGlobalRef(jobject lobj) {

   833         return functions->NewGlobalRef(this,lobj);

   834     }

   835     void DeleteGlobalRef(jobject gref) {

   836         functions->DeleteGlobalRef(this,gref);

   837     }

   838     void DeleteLocalRef(jobject obj) {

   839         functions->DeleteLocalRef(this, obj);

   840     }

   841 

   842     jboolean IsSameObject(jobject obj1, jobject obj2) {

   843         return functions->IsSameObject(this,obj1,obj2);

   844     }

   845 

   846     jobject NewLocalRef(jobject ref) {

   847         return functions->NewLocalRef(this,ref);

   848     }

   849     jint EnsureLocalCapacity(jint capacity) {

   850         return functions->EnsureLocalCapacity(this,capacity);

   851     }

   852 

   853     jobject AllocObject(jclass clazz) {

   854         return functions->AllocObject(this,clazz);

   855     }

   856     jobject NewObject(jclass clazz, jmethodID methodID, ...) {

   857         va_list args;

   858 	jobject result;

   859 	va_start(args, methodID);

   860         result = functions->NewObjectV(this,clazz,methodID,args);

   861 	va_end(args);

   862 	return result;

   863     }

   864     jobject NewObjectV(jclass clazz, jmethodID methodID, 

   865 		       va_list args) {

   866         return functions->NewObjectV(this,clazz,methodID,args);

   867     }

   868     jobject NewObjectA(jclass clazz, jmethodID methodID, 

   869 		       jvalue *args) {

   870         return functions->NewObjectA(this,clazz,methodID,args);

   871     }

   872 

   873     jclass GetObjectClass(jobject obj) {

   874         return functions->GetObjectClass(this,obj);

   875     }

   876     jboolean IsInstanceOf(jobject obj, jclass clazz) {

   877         return functions->IsInstanceOf(this,obj,clazz);

   878     }

   879 

   880     jmethodID GetMethodID(jclass clazz, const char *name, 

   881 			  const char *sig) {

   882         return functions->GetMethodID(this,clazz,name,sig);

   883     }

   884 

   885     jobject CallObjectMethod(jobject obj, jmethodID methodID, ...) {

   886         va_list args;

   887 	jobject result;

   888 	va_start(args,methodID);

   889 	result = functions->CallObjectMethodV(this,obj,methodID,args);

   890 	va_end(args);

   891 	return result;

   892     }

   893     jobject CallObjectMethodV(jobject obj, jmethodID methodID, 

   894 			va_list args) {

   895         return functions->CallObjectMethodV(this,obj,methodID,args);

   896     }

   897     jobject CallObjectMethodA(jobject obj, jmethodID methodID, 

   898 			jvalue * args) {

   899         return functions->CallObjectMethodA(this,obj,methodID,args);

   900     }

   901 

   902     jboolean CallBooleanMethod(jobject obj, 

   903 			       jmethodID methodID, ...) {

   904         va_list args;

   905 	jboolean result;

   906 	va_start(args,methodID);

   907 	result = functions->CallBooleanMethodV(this,obj,methodID,args);

   908 	va_end(args);

   909 	return result;

   910     }

   911     jboolean CallBooleanMethodV(jobject obj, jmethodID methodID, 

   912 				va_list args) {

   913         return functions->CallBooleanMethodV(this,obj,methodID,args);

   914     }

   915     jboolean CallBooleanMethodA(jobject obj, jmethodID methodID, 

   916 				jvalue * args) {

   917         return functions->CallBooleanMethodA(this,obj,methodID, args);

   918     }

   919 

   920     jbyte CallByteMethod(jobject obj, jmethodID methodID, ...) {

   921         va_list args;

   922 	jbyte result;

   923 	va_start(args,methodID);

   924 	result = functions->CallByteMethodV(this,obj,methodID,args);

   925 	va_end(args);

   926 	return result;

   927     }

   928     jbyte CallByteMethodV(jobject obj, jmethodID methodID, 

   929 			  va_list args) {

   930         return functions->CallByteMethodV(this,obj,methodID,args);

   931     }

   932     jbyte CallByteMethodA(jobject obj, jmethodID methodID, 

   933 			  jvalue * args) {

   934         return functions->CallByteMethodA(this,obj,methodID,args);

   935     }

   936 

   937     jchar CallCharMethod(jobject obj, jmethodID methodID, ...) {

   938         va_list args;

   939 	jchar result;

   940 	va_start(args,methodID);

   941 	result = functions->CallCharMethodV(this,obj,methodID,args);

   942 	va_end(args);

   943 	return result;

   944     }

   945     jchar CallCharMethodV(jobject obj, jmethodID methodID, 

   946 			  va_list args) {

   947         return functions->CallCharMethodV(this,obj,methodID,args);

   948     }

   949     jchar CallCharMethodA(jobject obj, jmethodID methodID, 

   950 			  jvalue * args) {

   951         return functions->CallCharMethodA(this,obj,methodID,args);

   952     }

   953 

   954     jshort CallShortMethod(jobject obj, jmethodID methodID, ...) {

   955         va_list args;

   956 	jshort result;

   957 	va_start(args,methodID);

   958 	result = functions->CallShortMethodV(this,obj,methodID,args);

   959 	va_end(args);

   960 	return result;

   961     }

   962     jshort CallShortMethodV(jobject obj, jmethodID methodID, 

   963 			    va_list args) {

   964         return functions->CallShortMethodV(this,obj,methodID,args);

   965     }

   966     jshort CallShortMethodA(jobject obj, jmethodID methodID, 

   967 			    jvalue * args) {

   968         return functions->CallShortMethodA(this,obj,methodID,args);

   969     }

   970 

   971     jint CallIntMethod(jobject obj, jmethodID methodID, ...) {

   972         va_list args;

   973 	jint result;

   974 	va_start(args,methodID);

   975 	result = functions->CallIntMethodV(this,obj,methodID,args);

   976 	va_end(args);

   977 	return result;

   978     }

   979     jint CallIntMethodV(jobject obj, jmethodID methodID, 

   980 			va_list args) {

   981         return functions->CallIntMethodV(this,obj,methodID,args);

   982     }

   983     jint CallIntMethodA(jobject obj, jmethodID methodID, 

   984 			jvalue * args) {

   985         return functions->CallIntMethodA(this,obj,methodID,args);

   986     }

   987 

   988     jlong CallLongMethod(jobject obj, jmethodID methodID, ...) {

   989         va_list args;

   990 	jlong result;

   991 	va_start(args,methodID);

   992 	result = functions->CallLongMethodV(this,obj,methodID,args);

   993 	va_end(args);

   994 	return result;

   995     }

   996     jlong CallLongMethodV(jobject obj, jmethodID methodID, 

   997 			  va_list args) {

   998         return functions->CallLongMethodV(this,obj,methodID,args);

   999     }

  1000     jlong CallLongMethodA(jobject obj, jmethodID methodID, 

  1001 			  jvalue * args) {

  1002         return functions->CallLongMethodA(this,obj,methodID,args);

  1003     }

  1004 

  1005     jfloat CallFloatMethod(jobject obj, jmethodID methodID, ...) {

  1006         va_list args;

  1007 	jfloat result;

  1008 	va_start(args,methodID);

  1009 	result = functions->CallFloatMethodV(this,obj,methodID,args);

  1010 	va_end(args);

  1011 	return result;

  1012     }

  1013     jfloat CallFloatMethodV(jobject obj, jmethodID methodID, 

  1014 			    va_list args) {

  1015         return functions->CallFloatMethodV(this,obj,methodID,args);

  1016     }

  1017     jfloat CallFloatMethodA(jobject obj, jmethodID methodID, 

  1018 			    jvalue * args) {

  1019         return functions->CallFloatMethodA(this,obj,methodID,args);

  1020     }

  1021 

  1022     jdouble CallDoubleMethod(jobject obj, jmethodID methodID, ...) {

  1023         va_list args;

  1024 	jdouble result;

  1025 	va_start(args,methodID);

  1026 	result = functions->CallDoubleMethodV(this,obj,methodID,args);

  1027 	va_end(args);

  1028 	return result;

  1029     }

  1030     jdouble CallDoubleMethodV(jobject obj, jmethodID methodID, 

  1031 			va_list args) {

  1032         return functions->CallDoubleMethodV(this,obj,methodID,args);

  1033     }

  1034     jdouble CallDoubleMethodA(jobject obj, jmethodID methodID, 

  1035 			jvalue * args) {

  1036         return functions->CallDoubleMethodA(this,obj,methodID,args);

  1037     }

  1038 

  1039     void CallVoidMethod(jobject obj, jmethodID methodID, ...) {

  1040         va_list args;

  1041 	va_start(args,methodID);

  1042 	functions->CallVoidMethodV(this,obj,methodID,args);

  1043 	va_end(args);

  1044     }

  1045     void CallVoidMethodV(jobject obj, jmethodID methodID, 

  1046 			 va_list args) {

  1047         functions->CallVoidMethodV(this,obj,methodID,args);

  1048     }

  1049     void CallVoidMethodA(jobject obj, jmethodID methodID, 

  1050 			 jvalue * args) {

  1051         functions->CallVoidMethodA(this,obj,methodID,args);

  1052     }

  1053 

  1054     jobject CallNonvirtualObjectMethod(jobject obj, jclass clazz, 

  1055 				       jmethodID methodID, ...) {

  1056         va_list args;

  1057 	jobject result;

  1058 	va_start(args,methodID);

  1059 	result = functions->CallNonvirtualObjectMethodV(this,obj,clazz,

  1060 							methodID,args);

  1061 	va_end(args);

  1062 	return result;

  1063     }

  1064     jobject CallNonvirtualObjectMethodV(jobject obj, jclass clazz, 

  1065 					jmethodID methodID, va_list args) {

  1066         return functions->CallNonvirtualObjectMethodV(this,obj,clazz,

  1067 						      methodID,args);

  1068     }

  1069     jobject CallNonvirtualObjectMethodA(jobject obj, jclass clazz, 

  1070 					jmethodID methodID, jvalue * args) {

  1071         return functions->CallNonvirtualObjectMethodA(this,obj,clazz,

  1072 						      methodID,args);

  1073     }

  1074 

  1075     jboolean CallNonvirtualBooleanMethod(jobject obj, jclass clazz, 

  1076 					 jmethodID methodID, ...) {

  1077         va_list args;

  1078 	jboolean result;

  1079 	va_start(args,methodID);

  1080 	result = functions->CallNonvirtualBooleanMethodV(this,obj,clazz,

  1081 							 methodID,args);

  1082 	va_end(args);

  1083 	return result;

  1084     }

  1085     jboolean CallNonvirtualBooleanMethodV(jobject obj, jclass clazz, 

  1086 					  jmethodID methodID, va_list args) {

  1087         return functions->CallNonvirtualBooleanMethodV(this,obj,clazz,

  1088 						       methodID,args);

  1089     }

  1090     jboolean CallNonvirtualBooleanMethodA(jobject obj, jclass clazz, 

  1091 					  jmethodID methodID, jvalue * args) {

  1092         return functions->CallNonvirtualBooleanMethodA(this,obj,clazz,

  1093 						       methodID, args);

  1094     }

  1095 

  1096     jbyte CallNonvirtualByteMethod(jobject obj, jclass clazz, 

  1097 				   jmethodID methodID, ...) {

  1098         va_list args;

  1099 	jbyte result;

  1100 	va_start(args,methodID);

  1101 	result = functions->CallNonvirtualByteMethodV(this,obj,clazz,

  1102 						      methodID,args);

  1103 	va_end(args);

  1104 	return result;

  1105     }

  1106     jbyte CallNonvirtualByteMethodV(jobject obj, jclass clazz, 

  1107 				    jmethodID methodID, va_list args) {

  1108         return functions->CallNonvirtualByteMethodV(this,obj,clazz,

  1109 						    methodID,args);

  1110     }

  1111     jbyte CallNonvirtualByteMethodA(jobject obj, jclass clazz, 

  1112 				    jmethodID methodID, jvalue * args) {

  1113         return functions->CallNonvirtualByteMethodA(this,obj,clazz,

  1114 						    methodID,args);

  1115     }

  1116 

  1117     jchar CallNonvirtualCharMethod(jobject obj, jclass clazz, 

  1118 				   jmethodID methodID, ...) {

  1119         va_list args;

  1120 	jchar result;

  1121 	va_start(args,methodID);

  1122 	result = functions->CallNonvirtualCharMethodV(this,obj,clazz,

  1123 						      methodID,args);

  1124 	va_end(args);

  1125 	return result;

  1126     }

  1127     jchar CallNonvirtualCharMethodV(jobject obj, jclass clazz, 

  1128 				    jmethodID methodID, va_list args) {

  1129         return functions->CallNonvirtualCharMethodV(this,obj,clazz,

  1130 						    methodID,args);

  1131     }

  1132     jchar CallNonvirtualCharMethodA(jobject obj, jclass clazz, 

  1133 				    jmethodID methodID, jvalue * args) {

  1134         return functions->CallNonvirtualCharMethodA(this,obj,clazz,

  1135 						    methodID,args);

  1136     }