1 /*

     2  * @(#)jni.h	1.56 03/12/19

     3  *

     4  * Copyright 2004 Sun Microsystems, Inc. All rights reserved.

     5  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

     6  */

     7 

     8 /*

     9  * We used part of Netscape's Java Runtime Interface (JRI) as the starting

    10  * point of our design and implementation.

    11  */

    12 

    13 /******************************************************************************

    14  * Java Runtime Interface

    15  * Copyright (c) 1996 Netscape Communications Corporation. All rights reserved.

    16  *****************************************************************************/

    17 

    18 #ifndef _JAVASOFT_JNI_H_

    19 #define _JAVASOFT_JNI_H_

    20 

    21 #include <stdio.h>

    22 #include <stdarg.h>

    23 

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

    25    and jlong */

    26 

    27 #include "jni_md.h"

    28 

    29 #ifdef __cplusplus

    30 extern "C" {

    31 #endif

    32 

    33 /*

    34  * JNI Types

    35  */

    36 

    37 #ifndef JNI_TYPES_ALREADY_DEFINED_IN_JNI_MD_H

    38 

    39 typedef unsigned char	jboolean;

    40 typedef unsigned short	jchar;

    41 typedef short		jshort;

    42 typedef float		jfloat;

    43 typedef double		jdouble;

    44 

    45 typedef jint            jsize;

    46 

    47 #ifdef __cplusplus

    48 

    49 class _jobject {};

    50 class _jclass : public _jobject {};

    51 class _jthrowable : public _jobject {};

    52 class _jstring : public _jobject {};

    53 class _jarray : public _jobject {};

    54 class _jbooleanArray : public _jarray {};

    55 class _jbyteArray : public _jarray {};

    56 class _jcharArray : public _jarray {};

    57 class _jshortArray : public _jarray {};

    58 class _jintArray : public _jarray {};

    59 class _jlongArray : public _jarray {};

    60 class _jfloatArray : public _jarray {};

    61 class _jdoubleArray : public _jarray {};

    62 class _jobjectArray : public _jarray {};

    63 

    64 typedef _jobject *jobject;

    65 typedef _jclass *jclass;

    66 typedef _jthrowable *jthrowable;

    67 typedef _jstring *jstring;

    68 typedef _jarray *jarray;

    69 typedef _jbooleanArray *jbooleanArray;

    70 typedef _jbyteArray *jbyteArray;

    71 typedef _jcharArray *jcharArray;

    72 typedef _jshortArray *jshortArray;

    73 typedef _jintArray *jintArray;

    74 typedef _jlongArray *jlongArray;

    75 typedef _jfloatArray *jfloatArray;

    76 typedef _jdoubleArray *jdoubleArray;

    77 typedef _jobjectArray *jobjectArray;

    78 

    79 #else

    80 

    81 struct _jobject;

    82 

    83 typedef struct _jobject *jobject;

    84 typedef jobject jclass;

    85 typedef jobject jthrowable;

    86 typedef jobject jstring;

    87 typedef jobject jarray;

    88 typedef jarray jbooleanArray;

    89 typedef jarray jbyteArray;

    90 typedef jarray jcharArray;

    91 typedef jarray jshortArray;

    92 typedef jarray jintArray;

    93 typedef jarray jlongArray;

    94 typedef jarray jfloatArray;

    95 typedef jarray jdoubleArray;

    96 typedef jarray jobjectArray;

    97 

    98 #endif

    99 

   100 typedef jobject jweak;

   101 

   102 typedef union jvalue {

   103     jboolean z;

   104     jbyte    b;

   105     jchar    c;

   106     jshort   s;

   107     jint     i;

   108     jlong    j;

   109     jfloat   f;

   110     jdouble  d;

   111     jobject  l;

   112 } jvalue;

   113 

   114 struct _jfieldID;

   115 typedef struct _jfieldID *jfieldID;

   116 

   117 struct _jmethodID;

   118 typedef struct _jmethodID *jmethodID;

   119 

   120 #endif /* JNI_TYPES_ALREADY_DEFINED_IN_JNI_MD_H */

   121 

   122 /*

   123  * jboolean constants

   124  */

   125 

   126 #define JNI_FALSE 0

   127 #define JNI_TRUE 1

   128 

   129 /*

   130  * possible return values for JNI functions.

   131  */

   132 

   133 #define JNI_OK           0                 /* success */

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

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

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

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

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

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

   140 

   141 /*

   142  * used in ReleaseScalarArrayElements

   143  */

   144 

   145 #define JNI_COMMIT 1

   146 #define JNI_ABORT 2

   147 

   148 /*

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

   150  * and function pointer.

   151  */

   152 

   153 typedef struct {

   154     char *name;

   155     char *signature;

   156     void *fnPtr;

   157 } JNINativeMethod;

   158 

   159 /*

   160  * JNI Native Method Interface.

   161  */

   162 

   163 struct JNINativeInterface_;

   164 

   165 struct JNIEnv_;

   166 

   167 #ifdef __cplusplus

   168 typedef JNIEnv_ JNIEnv;

   169 #else

   170 typedef const struct JNINativeInterface_ *JNIEnv;

   171 #endif

   172 

   173 /*

   174  * JNI Invocation Interface.

   175  */

   176 

   177 struct JNIInvokeInterface_;

   178 

   179 struct JavaVM_;

   180 

   181 #ifdef __cplusplus

   182 typedef JavaVM_ JavaVM;

   183 #else

   184 typedef const struct JNIInvokeInterface_ *JavaVM;

   185 #endif

   186 

   187 struct JNINativeInterface_ {

   188     void *reserved0;

   189     void *reserved1;

   190     void *reserved2;

   191 

   192     void *reserved3;

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

   194 

   195     jclass (JNICALL *DefineClass)

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

   197        jsize len);

   198     jclass (JNICALL *FindClass)

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

   200 

   201     jmethodID (JNICALL *FromReflectedMethod)

   202       (JNIEnv *env, jobject method);

   203     jfieldID (JNICALL *FromReflectedField)

   204       (JNIEnv *env, jobject field);

   205 

   206     jobject (JNICALL *ToReflectedMethod)

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

   208 

   209     jclass (JNICALL *GetSuperclass)

   210       (JNIEnv *env, jclass sub);

   211     jboolean (JNICALL *IsAssignableFrom)

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

   213 

   214     jobject (JNICALL *ToReflectedField)

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

   216 

   217     jint (JNICALL *Throw)

   218       (JNIEnv *env, jthrowable obj);

   219     jint (JNICALL *ThrowNew)

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

   221     jthrowable (JNICALL *ExceptionOccurred)

   222       (JNIEnv *env);

   223     void (JNICALL *ExceptionDescribe)

   224       (JNIEnv *env);

   225     void (JNICALL *ExceptionClear)

   226       (JNIEnv *env);

   227     void (JNICALL *FatalError)

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

   229 

   230     jint (JNICALL *PushLocalFrame)

   231       (JNIEnv *env, jint capacity);

   232     jobject (JNICALL *PopLocalFrame)

   233       (JNIEnv *env, jobject result);

   234 

   235     jobject (JNICALL *NewGlobalRef)

   236       (JNIEnv *env, jobject lobj);

   237     void (JNICALL *DeleteGlobalRef)

   238       (JNIEnv *env, jobject gref);

   239     void (JNICALL *DeleteLocalRef)

   240       (JNIEnv *env, jobject obj);

   241     jboolean (JNICALL *IsSameObject)

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

   243     jobject (JNICALL *NewLocalRef)

   244       (JNIEnv *env, jobject ref);

   245     jint (JNICALL *EnsureLocalCapacity)

   246       (JNIEnv *env, jint capacity);

   247 

   248     jobject (JNICALL *AllocObject)

   249       (JNIEnv *env, jclass clazz);

   250     jobject (JNICALL *NewObject)

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

   252     jobject (JNICALL *NewObjectV)

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

   254     jobject (JNICALL *NewObjectA)

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

   256 

   257     jclass (JNICALL *GetObjectClass)

   258       (JNIEnv *env, jobject obj);

   259     jboolean (JNICALL *IsInstanceOf)

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

   261 

   262     jmethodID (JNICALL *GetMethodID)

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

   264 

   265     jobject (JNICALL *CallObjectMethod)

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

   267     jobject (JNICALL *CallObjectMethodV)

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

   269     jobject (JNICALL *CallObjectMethodA)

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

   271 

   272     jboolean (JNICALL *CallBooleanMethod)

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

   274     jboolean (JNICALL *CallBooleanMethodV)

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

   276     jboolean (JNICALL *CallBooleanMethodA)

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

   278 

   279     jbyte (JNICALL *CallByteMethod)

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

   281     jbyte (JNICALL *CallByteMethodV)

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

   283     jbyte (JNICALL *CallByteMethodA)

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

   285 

   286     jchar (JNICALL *CallCharMethod)

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

   288     jchar (JNICALL *CallCharMethodV)

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

   290     jchar (JNICALL *CallCharMethodA)

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

   292 

   293     jshort (JNICALL *CallShortMethod)

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

   295     jshort (JNICALL *CallShortMethodV)

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

   297     jshort (JNICALL *CallShortMethodA)

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

   299 

   300     jint (JNICALL *CallIntMethod)

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

   302     jint (JNICALL *CallIntMethodV)

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

   304     jint (JNICALL *CallIntMethodA)

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

   306 

   307     jlong (JNICALL *CallLongMethod)

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

   309     jlong (JNICALL *CallLongMethodV)

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

   311     jlong (JNICALL *CallLongMethodA)

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

   313 

   314     jfloat (JNICALL *CallFloatMethod)

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

   316     jfloat (JNICALL *CallFloatMethodV)

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

   318     jfloat (JNICALL *CallFloatMethodA)

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

   320 

   321     jdouble (JNICALL *CallDoubleMethod)

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

   323     jdouble (JNICALL *CallDoubleMethodV)

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

   325     jdouble (JNICALL *CallDoubleMethodA)

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

   327 

   328     void (JNICALL *CallVoidMethod)

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

   330     void (JNICALL *CallVoidMethodV)

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

   332     void (JNICALL *CallVoidMethodA)

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

   334 

   335     jobject (JNICALL *CallNonvirtualObjectMethod)

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

   337     jobject (JNICALL *CallNonvirtualObjectMethodV)

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

   339        va_list args);

   340     jobject (JNICALL *CallNonvirtualObjectMethodA)

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

   342        const jvalue * args);

   343 

   344     jboolean (JNICALL *CallNonvirtualBooleanMethod)

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

   346     jboolean (JNICALL *CallNonvirtualBooleanMethodV)

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

   348        va_list args);

   349     jboolean (JNICALL *CallNonvirtualBooleanMethodA)

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

   351        const jvalue * args);

   352 

   353     jbyte (JNICALL *CallNonvirtualByteMethod)

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

   355     jbyte (JNICALL *CallNonvirtualByteMethodV)

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

   357        va_list args);

   358     jbyte (JNICALL *CallNonvirtualByteMethodA)

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

   360        const jvalue *args);

   361 

   362     jchar (JNICALL *CallNonvirtualCharMethod)

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

   364     jchar (JNICALL *CallNonvirtualCharMethodV)

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

   366        va_list args);

   367     jchar (JNICALL *CallNonvirtualCharMethodA)

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

   369        const jvalue *args);

   370 

   371     jshort (JNICALL *CallNonvirtualShortMethod)

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

   373     jshort (JNICALL *CallNonvirtualShortMethodV)

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

   375        va_list args);

   376     jshort (JNICALL *CallNonvirtualShortMethodA)

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

   378        const jvalue *args);

   379 

   380     jint (JNICALL *CallNonvirtualIntMethod)

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

   382     jint (JNICALL *CallNonvirtualIntMethodV)

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

   384        va_list args);

   385     jint (JNICALL *CallNonvirtualIntMethodA)

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

   387        const jvalue *args);

   388 

   389     jlong (JNICALL *CallNonvirtualLongMethod)

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

   391     jlong (JNICALL *CallNonvirtualLongMethodV)

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

   393        va_list args);

   394     jlong (JNICALL *CallNonvirtualLongMethodA)

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

   396        const jvalue *args);

   397 

   398     jfloat (JNICALL *CallNonvirtualFloatMethod)

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

   400     jfloat (JNICALL *CallNonvirtualFloatMethodV)

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

   402        va_list args);

   403     jfloat (JNICALL *CallNonvirtualFloatMethodA)

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

   405        const jvalue *args);

   406 

   407     jdouble (JNICALL *CallNonvirtualDoubleMethod)

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

   409     jdouble (JNICALL *CallNonvirtualDoubleMethodV)

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

   411        va_list args);

   412     jdouble (JNICALL *CallNonvirtualDoubleMethodA)

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

   414        const jvalue *args);

   415 

   416     void (JNICALL *CallNonvirtualVoidMethod)

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

   418     void (JNICALL *CallNonvirtualVoidMethodV)

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

   420        va_list args);

   421     void (JNICALL *CallNonvirtualVoidMethodA)

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

   423        const jvalue * args);

   424 

   425     jfieldID (JNICALL *GetFieldID)

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

   427 

   428     jobject (JNICALL *GetObjectField)

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

   430     jboolean (JNICALL *GetBooleanField)

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

   432     jbyte (JNICALL *GetByteField)

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

   434     jchar (JNICALL *GetCharField)

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

   436     jshort (JNICALL *GetShortField)

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

   438     jint (JNICALL *GetIntField)

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

   440     jlong (JNICALL *GetLongField)

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

   442     jfloat (JNICALL *GetFloatField)

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

   444     jdouble (JNICALL *GetDoubleField)

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

   446 

   447     void (JNICALL *SetObjectField)

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

   449     void (JNICALL *SetBooleanField)

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

   451     void (JNICALL *SetByteField)

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

   453     void (JNICALL *SetCharField)

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

   455     void (JNICALL *SetShortField)

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

   457     void (JNICALL *SetIntField)

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

   459     void (JNICALL *SetLongField)

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

   461     void (JNICALL *SetFloatField)

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

   463     void (JNICALL *SetDoubleField)

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

   465 

   466     jmethodID (JNICALL *GetStaticMethodID)

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

   468 

   469     jobject (JNICALL *CallStaticObjectMethod)

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

   471     jobject (JNICALL *CallStaticObjectMethodV)

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

   473     jobject (JNICALL *CallStaticObjectMethodA)

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

   475 

   476     jboolean (JNICALL *CallStaticBooleanMethod)

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

   478     jboolean (JNICALL *CallStaticBooleanMethodV)

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

   480     jboolean (JNICALL *CallStaticBooleanMethodA)

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

   482 

   483     jbyte (JNICALL *CallStaticByteMethod)

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

   485     jbyte (JNICALL *CallStaticByteMethodV)

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

   487     jbyte (JNICALL *CallStaticByteMethodA)

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

   489 

   490     jchar (JNICALL *CallStaticCharMethod)

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

   492     jchar (JNICALL *CallStaticCharMethodV)

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

   494     jchar (JNICALL *CallStaticCharMethodA)

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

   496 

   497     jshort (JNICALL *CallStaticShortMethod)

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

   499     jshort (JNICALL *CallStaticShortMethodV)

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

   501     jshort (JNICALL *CallStaticShortMethodA)

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

   503 

   504     jint (JNICALL *CallStaticIntMethod)

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

   506     jint (JNICALL *CallStaticIntMethodV)

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

   508     jint (JNICALL *CallStaticIntMethodA)

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

   510 

   511     jlong (JNICALL *CallStaticLongMethod)

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

   513     jlong (JNICALL *CallStaticLongMethodV)

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

   515     jlong (JNICALL *CallStaticLongMethodA)

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

   517 

   518     jfloat (JNICALL *CallStaticFloatMethod)

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

   520     jfloat (JNICALL *CallStaticFloatMethodV)

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

   522     jfloat (JNICALL *CallStaticFloatMethodA)

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

   524 

   525     jdouble (JNICALL *CallStaticDoubleMethod)

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

   527     jdouble (JNICALL *CallStaticDoubleMethodV)

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

   529     jdouble (JNICALL *CallStaticDoubleMethodA)

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

   531 

   532     void (JNICALL *CallStaticVoidMethod)

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

   534     void (JNICALL *CallStaticVoidMethodV)

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

   536     void (JNICALL *CallStaticVoidMethodA)

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

   538 

   539     jfieldID (JNICALL *GetStaticFieldID)

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

   541     jobject (JNICALL *GetStaticObjectField)

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

   543     jboolean (JNICALL *GetStaticBooleanField)

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

   545     jbyte (JNICALL *GetStaticByteField)

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

   547     jchar (JNICALL *GetStaticCharField)

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

   549     jshort (JNICALL *GetStaticShortField)

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

   551     jint (JNICALL *GetStaticIntField)

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

   553     jlong (JNICALL *GetStaticLongField)

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

   555     jfloat (JNICALL *GetStaticFloatField)

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

   557     jdouble (JNICALL *GetStaticDoubleField)

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

   559 

   560     void (JNICALL *SetStaticObjectField)

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

   562     void (JNICALL *SetStaticBooleanField)

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

   564     void (JNICALL *SetStaticByteField)

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

   566     void (JNICALL *SetStaticCharField)

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

   568     void (JNICALL *SetStaticShortField)

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

   570     void (JNICALL *SetStaticIntField)

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

   572     void (JNICALL *SetStaticLongField)

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

   574     void (JNICALL *SetStaticFloatField)

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

   576     void (JNICALL *SetStaticDoubleField)

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

   578 

   579     jstring (JNICALL *NewString)

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

   581     jsize (JNICALL *GetStringLength)

   582       (JNIEnv *env, jstring str);

   583     const jchar *(JNICALL *GetStringChars)

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

   585     void (JNICALL *ReleaseStringChars)

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

   587 

   588     jstring (JNICALL *NewStringUTF)

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

   590     jsize (JNICALL *GetStringUTFLength)

   591       (JNIEnv *env, jstring str);

   592     const char* (JNICALL *GetStringUTFChars)

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

   594     void (JNICALL *ReleaseStringUTFChars)

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

   596 

   597 

   598     jsize (JNICALL *GetArrayLength)

   599       (JNIEnv *env, jarray array);

   600 

   601     jobjectArray (JNICALL *NewObjectArray)

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

   603     jobject (JNICALL *GetObjectArrayElement)

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

   605     void (JNICALL *SetObjectArrayElement)

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

   607 

   608     jbooleanArray (JNICALL *NewBooleanArray)

   609       (JNIEnv *env, jsize len);

   610     jbyteArray (JNICALL *NewByteArray)

   611       (JNIEnv *env, jsize len);

   612     jcharArray (JNICALL *NewCharArray)

   613       (JNIEnv *env, jsize len);

   614     jshortArray (JNICALL *NewShortArray)

   615       (JNIEnv *env, jsize len);

   616     jintArray (JNICALL *NewIntArray)

   617       (JNIEnv *env, jsize len);

   618     jlongArray (JNICALL *NewLongArray)

   619       (JNIEnv *env, jsize len);

   620     jfloatArray (JNICALL *NewFloatArray)

   621       (JNIEnv *env, jsize len);

   622     jdoubleArray (JNICALL *NewDoubleArray)

   623       (JNIEnv *env, jsize len);

   624 

   625     jboolean * (JNICALL *GetBooleanArrayElements)

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

   627     jbyte * (JNICALL *GetByteArrayElements)

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

   629     jchar * (JNICALL *GetCharArrayElements)

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

   631     jshort * (JNICALL *GetShortArrayElements)

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

   633     jint * (JNICALL *GetIntArrayElements)

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

   635     jlong * (JNICALL *GetLongArrayElements)

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

   637     jfloat * (JNICALL *GetFloatArrayElements)

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

   639     jdouble * (JNICALL *GetDoubleArrayElements)

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

   641 

   642     void (JNICALL *ReleaseBooleanArrayElements)

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

   644     void (JNICALL *ReleaseByteArrayElements)

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

   646     void (JNICALL *ReleaseCharArrayElements)

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

   648     void (JNICALL *ReleaseShortArrayElements)

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

   650     void (JNICALL *ReleaseIntArrayElements)

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

   652     void (JNICALL *ReleaseLongArrayElements)

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

   654     void (JNICALL *ReleaseFloatArrayElements)

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

   656     void (JNICALL *ReleaseDoubleArrayElements)

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

   658 

   659     void (JNICALL *GetBooleanArrayRegion)

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

   661     void (JNICALL *GetByteArrayRegion)

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

   663     void (JNICALL *GetCharArrayRegion)

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

   665     void (JNICALL *GetShortArrayRegion)

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

   667     void (JNICALL *GetIntArrayRegion)

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

   669     void (JNICALL *GetLongArrayRegion)

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

   671     void (JNICALL *GetFloatArrayRegion)

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

   673     void (JNICALL *GetDoubleArrayRegion)

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

   675 

   676     void (JNICALL *SetBooleanArrayRegion)

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

   678     void (JNICALL *SetByteArrayRegion)

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

   680     void (JNICALL *SetCharArrayRegion)

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

   682     void (JNICALL *SetShortArrayRegion)

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

   684     void (JNICALL *SetIntArrayRegion)

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

   686     void (JNICALL *SetLongArrayRegion)

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

   688     void (JNICALL *SetFloatArrayRegion)

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

   690     void (JNICALL *SetDoubleArrayRegion)

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

   692 

   693     jint (JNICALL *RegisterNatives)

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

   695        jint nMethods);

   696     jint (JNICALL *UnregisterNatives)

   697       (JNIEnv *env, jclass clazz);

   698 

   699     jint (JNICALL *MonitorEnter)

   700       (JNIEnv *env, jobject obj);

   701     jint (JNICALL *MonitorExit)

   702       (JNIEnv *env, jobject obj);

   703 

   704     jint (JNICALL *GetJavaVM)

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

   706 

   707     void (JNICALL *GetStringRegion)

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

   709     void (JNICALL *GetStringUTFRegion)

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

   711 

   712     void * (JNICALL *GetPrimitiveArrayCritical)

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

   714     void (JNICALL *ReleasePrimitiveArrayCritical)

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

   716 

   717     const jchar * (JNICALL *GetStringCritical)

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

   719     void (JNICALL *ReleaseStringCritical)

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

   721 

   722     jweak (JNICALL *NewWeakGlobalRef)

   723        (JNIEnv *env, jobject obj);

   724     void (JNICALL *DeleteWeakGlobalRef)

   725        (JNIEnv *env, jweak ref);

   726 

   727     jboolean (JNICALL *ExceptionCheck)

   728        (JNIEnv *env);

   729 

   730     jobject (JNICALL *NewDirectByteBuffer)

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

   732     void* (JNICALL *GetDirectBufferAddress)

   733        (JNIEnv* env, jobject buf);

   734     jlong (JNICALL *GetDirectBufferCapacity)

   735        (JNIEnv* env, jobject buf);

   736 };

   737 

   738 /*

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

   740  *

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

   742  *

   743  * in C++ rather than:

   744  *

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

   746  *

   747  * in C.

   748  */

   749 

   750 struct JNIEnv_ {

   751     const struct JNINativeInterface_ *functions;

   752 #ifdef __cplusplus

   753 

   754     jint GetVersion() {

   755         return functions->GetVersion(this);

   756     }

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

   758 		       jsize len) {

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

   760     }

   761     jclass FindClass(const char *name) {

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

   763     }

   764     jmethodID FromReflectedMethod(jobject method) {

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

   766     }

   767     jfieldID FromReflectedField(jobject field) {

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

   769     }

   770 

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

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

   773     }

   774 

   775     jclass GetSuperclass(jclass sub) {

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

   777     }

   778     jboolean IsAssignableFrom(jclass sub, jclass sup) {

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

   780     }

   781 

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

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

   784     }

   785 

   786     jint Throw(jthrowable obj) {

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

   788     }

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

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

   791     }

   792     jthrowable ExceptionOccurred() {

   793         return functions->ExceptionOccurred(this);

   794     }

   795     void ExceptionDescribe() {

   796         functions->ExceptionDescribe(this);

   797     }

   798     void ExceptionClear() {

   799         functions->ExceptionClear(this);

   800     }

   801     void FatalError(const char *msg) {

   802         functions->FatalError(this, msg);

   803     }

   804 

   805     jint PushLocalFrame(jint capacity) {

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

   807     }

   808     jobject PopLocalFrame(jobject result) {

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

   810     }

   811 

   812     jobject NewGlobalRef(jobject lobj) {

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

   814     }

   815     void DeleteGlobalRef(jobject gref) {

   816         functions->DeleteGlobalRef(this,gref);

   817     }

   818     void DeleteLocalRef(jobject obj) {

   819         functions->DeleteLocalRef(this, obj);

   820     }

   821 

   822     jboolean IsSameObject(jobject obj1, jobject obj2) {

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

   824     }

   825 

   826     jobject NewLocalRef(jobject ref) {

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

   828     }

   829     jint EnsureLocalCapacity(jint capacity) {

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

   831     }

   832 

   833     jobject AllocObject(jclass clazz) {

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

   835     }

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

   837         va_list args;

   838 	jobject result;

   839 	va_start(args, methodID);

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

   841 	va_end(args);

   842 	return result;

   843     }

   844     jobject NewObjectV(jclass clazz, jmethodID methodID,

   845 		       va_list args) {

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

   847     }

   848     jobject NewObjectA(jclass clazz, jmethodID methodID,

   849 		       const jvalue *args) {

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

   851     }

   852 

   853     jclass GetObjectClass(jobject obj) {

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

   855     }

   856     jboolean IsInstanceOf(jobject obj, jclass clazz) {

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

   858     }

   859 

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

   861 			  const char *sig) {

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

   863     }

   864 

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

   866         va_list args;

   867 	jobject result;

   868 	va_start(args,methodID);

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

   870 	va_end(args);

   871 	return result;

   872     }

   873     jobject CallObjectMethodV(jobject obj, jmethodID methodID,

   874 			va_list args) {

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

   876     }

   877     jobject CallObjectMethodA(jobject obj, jmethodID methodID,

   878 			const jvalue * args) {

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

   880     }

   881 

   882     jboolean CallBooleanMethod(jobject obj,

   883 			       jmethodID methodID, ...) {

   884         va_list args;

   885 	jboolean result;

   886 	va_start(args,methodID);

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

   888 	va_end(args);

   889 	return result;

   890     }

   891     jboolean CallBooleanMethodV(jobject obj, jmethodID methodID,

   892 				va_list args) {

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

   894     }

   895     jboolean CallBooleanMethodA(jobject obj, jmethodID methodID,

   896 				const jvalue * args) {

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

   898     }

   899 

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

   901         va_list args;

   902 	jbyte result;

   903 	va_start(args,methodID);

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

   905 	va_end(args);

   906 	return result;

   907     }

   908     jbyte CallByteMethodV(jobject obj, jmethodID methodID,

   909 			  va_list args) {

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

   911     }

   912     jbyte CallByteMethodA(jobject obj, jmethodID methodID,

   913 			  const jvalue * args) {

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

   915     }

   916 

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

   918         va_list args;

   919 	jchar result;

   920 	va_start(args,methodID);

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

   922 	va_end(args);

   923 	return result;

   924     }

   925     jchar CallCharMethodV(jobject obj, jmethodID methodID,

   926 			  va_list args) {

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

   928     }

   929     jchar CallCharMethodA(jobject obj, jmethodID methodID,

   930 			  const jvalue * args) {

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

   932     }

   933 

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

   935         va_list args;

   936 	jshort result;

   937 	va_start(args,methodID);

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

   939 	va_end(args);

   940 	return result;

   941     }

   942     jshort CallShortMethodV(jobject obj, jmethodID methodID,

   943 			    va_list args) {

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

   945     }

   946     jshort CallShortMethodA(jobject obj, jmethodID methodID,

   947 			    const jvalue * args) {

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

   949     }

   950 

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

   952         va_list args;

   953 	jint result;

   954 	va_start(args,methodID);

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

   956 	va_end(args);

   957 	return result;

   958     }

   959     jint CallIntMethodV(jobject obj, jmethodID methodID,

   960 			va_list args) {

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

   962     }

   963     jint CallIntMethodA(jobject obj, jmethodID methodID,

   964 			const jvalue * args) {

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

   966     }

   967 

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

   969         va_list args;

   970 	jlong result;

   971 	va_start(args,methodID);

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

   973 	va_end(args);

   974 	return result;

   975     }

   976     jlong CallLongMethodV(jobject obj, jmethodID methodID,

   977 			  va_list args) {

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

   979     }

   980     jlong CallLongMethodA(jobject obj, jmethodID methodID,

   981 			  const jvalue * args) {

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

   983     }

   984 

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

   986         va_list args;

   987 	jfloat result;

   988 	va_start(args,methodID);

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

   990 	va_end(args);

   991 	return result;

   992     }

   993     jfloat CallFloatMethodV(jobject obj, jmethodID methodID,

   994 			    va_list args) {

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

   996     }

   997     jfloat CallFloatMethodA(jobject obj, jmethodID methodID,

   998 			    const jvalue * args) {

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

  1000     }

  1001 

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

  1003         va_list args;

  1004 	jdouble result;

  1005 	va_start(args,methodID);

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

  1007 	va_end(args);

  1008 	return result;

  1009     }

  1010     jdouble CallDoubleMethodV(jobject obj, jmethodID methodID,

  1011 			va_list args) {

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

  1013     }

  1014     jdouble CallDoubleMethodA(jobject obj, jmethodID methodID,

  1015 			const jvalue * args) {

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

  1017     }

  1018 

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

  1020         va_list args;

  1021 	va_start(args,methodID);

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

  1023 	va_end(args);

  1024     }

  1025     void CallVoidMethodV(jobject obj, jmethodID methodID,

  1026 			 va_list args) {

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

  1028     }

  1029     void CallVoidMethodA(jobject obj, jmethodID methodID,

  1030 			 const jvalue * args) {

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

  1032     }

  1033 

  1034     jobject CallNonvirtualObjectMethod(jobject obj, jclass clazz,

  1035 				       jmethodID methodID, ...) {

  1036         va_list args;

  1037 	jobject result;

  1038 	va_start(args,methodID);

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

  1040 							methodID,args);

  1041 	va_end(args);

  1042 	return result;

  1043     }

  1044     jobject CallNonvirtualObjectMethodV(jobject obj, jclass clazz,

  1045 					jmethodID methodID, va_list args) {

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

  1047 						      methodID,args);

  1048     }

  1049     jobject CallNonvirtualObjectMethodA(jobject obj, jclass clazz,

  1050 					jmethodID methodID, const jvalue * args) {

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

  1052 						      methodID,args);

  1053     }

  1054 

  1055     jboolean CallNonvirtualBooleanMethod(jobject obj, jclass clazz,

  1056 					 jmethodID methodID, ...) {

  1057         va_list args;

  1058 	jboolean result;

  1059 	va_start(args,methodID);

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

  1061 							 methodID,args);

  1062 	va_end(args);

  1063 	return result;

  1064     }

  1065     jboolean CallNonvirtualBooleanMethodV(jobject obj, jclass clazz,

  1066 					  jmethodID methodID, va_list args) {

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

  1068 						       methodID,args);

  1069     }

  1070     jboolean CallNonvirtualBooleanMethodA(jobject obj, jclass clazz,

  1071 					  jmethodID methodID, const jvalue * args) {

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

  1073 						       methodID, args);

  1074     }

  1075 

  1076     jbyte CallNonvirtualByteMethod(jobject obj, jclass clazz,

  1077 				   jmethodID methodID, ...) {

  1078         va_list args;

  1079 	jbyte result;

  1080 	va_start(args,methodID);

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

  1082 						      methodID,args);

  1083 	va_end(args);

  1084 	return result;

  1085     }

  1086     jbyte CallNonvirtualByteMethodV(jobject obj, jclass clazz,

  1087 				    jmethodID methodID, va_list args) {

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

  1089 						    methodID,args);

  1090     }

  1091     jbyte CallNonvirtualByteMethodA(jobject obj, jclass clazz,

  1092 				    jmethodID methodID, const jvalue * args) {

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

  1094 						    methodID,args);

  1095     }

  1096 

  1097     jchar CallNonvirtualCharMethod(jobject obj, jclass clazz,

  1098 				   jmethodID methodID, ...) {

  1099         va_list args;

  1100 	jchar result;

  1101 	va_start(args,methodID);

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

  1103 						      methodID,args);

  1104 	va_end(args);

  1105 	return result;

  1106     }

  1107     jchar CallNonvirtualCharMethodV(jobject obj, jclass clazz,

  1108 				    jmethodID methodID, va_list args) {

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

  1110 						    methodID,args);

  1111     }

  1112     jchar CallNonvirtualCharMethodA(jobject obj, jclass clazz,

  1113 				    jmethodID methodID, const jvalue * args) {

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

  1115 						    methodID,args);

  1116     }

  1117 

  1118     jshort CallNonvirtualShortMethod(jobject obj, jclass clazz,

  1119 				     jmethodID methodID, ...) {

  1120         va_list args;

  1121 	jshort result;

  1122 	va_start(args,methodID);

  1123 	result = functions->CallNonvirtualShortMethodV(this,obj,clazz,

  1124 						       methodID,args);

  1125 	va_end(args);

  1126 	return result;

  1127     }

  1128     jshort CallNonvirtualShortMethodV(jobject obj, jclass clazz,

  1129 				      jmethodID methodID, va_list args) {

  1130         return functions->CallNonvirtualShortMethodV(this,obj,clazz,

  1131 						     methodID,args);

  1132     }

  1133     jshort CallNonvirtualShortMethodA(jobject obj, jclass clazz,

  1134 				      jmethodID methodID, const jvalue * args) {

  1135         return functions->CallNonvirtualShortMethodA(this,obj,clazz,