home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / jreheadf.zip / jni.h < prev    next >
C/C++ Source or Header  |  2002-08-31  |  77KB  |  2,002 lines
  1. /*
  2.  * @(#)src/contract/jvm/sov/jni.h, core, xsdev, 20010906 1.12
  3.  * ===========================================================================
  4.  * Licensed Materials - Property of IBM
  5.  * "Restricted Materials of IBM"
  6.  *
  7.  * IBM Java(tm)2 SDK, Standard Edition, v 1.3.1
  8.  * (C) Copyright IBM Corp. 1998, 2001. All Rights Reserved
  9.  * US Government Users Restricted Rights - Use, duplication or disclosure
  10.  * restricted by GSA ADP Schedule Contract with IBM Corp.
  11.  * ===========================================================================
  12.  */
  13.  
  14. /*
  15.  *
  16.  * ===========================================================================
  17.  *
  18.  * Copyright 1996-2000 Sun Microsystems, Inc. All Rights Reserved.
  19.  * ===========================================================================
  20.  */
  21.  
  22. /*
  23.  * We used part of Netscape's Java Runtime Interface (JRI) as the starting
  24.  * point of our design and implementation.
  25.  */
  26.  
  27. /******************************************************************************
  28.  * Java Runtime Interface
  29.  * Copyright (c) 1996 Netscape Communications Corporation. All rights reserved.
  30.  *****************************************************************************/
  31.  
  32. /* Change activity:
  33.  *
  34.  * Reason  Date   Origin  Description
  35.  * ------  ----   ------  ----------------------------------------------------
  36.  * 35584.1 100901 kennard Added pragma from 1.30 platform fix to aid CICS build
  37.  *
  38.  * ===========================================================================
  39.  */
  40.  
  41. #if defined(__MVS__)
  42. #pragma nomargins nosequence
  43. #endif 
  44.  
  45. #ifndef _JAVASOFT_JNI_H_
  46. #define _JAVASOFT_JNI_H_
  47.  
  48. #include <stdio.h>
  49. #include <stdarg.h>
  50.  
  51. /* jni_md.h contains the machine-dependent typedefs for jbyte, jint
  52.    and jlong */
  53.  
  54. #include "jni_md.h"
  55.  
  56. #ifdef __cplusplus
  57. extern "C" {
  58. #endif
  59.  
  60. /*
  61.  * JNI Types
  62.  */
  63.  
  64. #ifndef JNI_TYPES_ALREADY_DEFINED_IN_JNI_MD_H
  65.  
  66. typedef unsigned char   jboolean;
  67. typedef unsigned short  jchar;
  68. typedef short           jshort;
  69. typedef float           jfloat;
  70. typedef double          jdouble;
  71.  
  72. #ifdef __cplusplus
  73.  
  74. class _jobject {};
  75. class _jclass : public _jobject {};
  76. class _jthrowable : public _jobject {};
  77. class _jstring : public _jobject {};
  78. class _jarray : public _jobject {};
  79. class _jbooleanArray : public _jarray {};
  80. class _jbyteArray : public _jarray {};
  81. class _jcharArray : public _jarray {};
  82. class _jshortArray : public _jarray {};
  83. class _jintArray : public _jarray {};
  84. class _jlongArray : public _jarray {};
  85. class _jfloatArray : public _jarray {};
  86. class _jdoubleArray : public _jarray {};
  87. class _jobjectArray : public _jarray {};
  88.  
  89. typedef _jobject *jobject;
  90. typedef _jclass *jclass;
  91. typedef _jthrowable *jthrowable;
  92. typedef _jstring *jstring;
  93. typedef _jarray *jarray;
  94. typedef _jbooleanArray *jbooleanArray;
  95. typedef _jbyteArray *jbyteArray;
  96. typedef _jcharArray *jcharArray;
  97. typedef _jshortArray *jshortArray;
  98. typedef _jintArray *jintArray;
  99. typedef _jlongArray *jlongArray;
  100. typedef _jfloatArray *jfloatArray;
  101. typedef _jdoubleArray *jdoubleArray;
  102. typedef _jobjectArray *jobjectArray;
  103.  
  104. #else
  105.  
  106. struct _jobject;
  107.  
  108. typedef struct _jobject *jobject;
  109. typedef jobject jclass;
  110. typedef jobject jthrowable;
  111. typedef jobject jstring;
  112. typedef jobject jarray;
  113. typedef jarray jbooleanArray;
  114. typedef jarray jbyteArray;
  115. typedef jarray jcharArray;
  116. typedef jarray jshortArray;
  117. typedef jarray jintArray;
  118. typedef jarray jlongArray;
  119. typedef jarray jfloatArray;
  120. typedef jarray jdoubleArray;
  121. typedef jarray jobjectArray;
  122.  
  123. #endif
  124.  
  125. typedef jobject jweak;
  126.  
  127. typedef union jvalue {
  128.     jboolean z;
  129.     jbyte    b;
  130.     jchar    c;
  131.     jshort   s;
  132.     jint     i;
  133.     jlong    j;
  134.     jfloat   f;
  135.     jdouble  d;
  136.     jobject  l;
  137. } jvalue;
  138.  
  139. struct _jfieldID;
  140. typedef struct _jfieldID *jfieldID;
  141.  
  142. struct _jmethodID;
  143. typedef struct _jmethodID *jmethodID;
  144.  
  145. #endif /* JNI_TYPES_ALREADY_DEFINED_IN_JNI_MD_H */
  146.  
  147. /*
  148.  * jboolean constants
  149.  */
  150.  
  151. #define JNI_FALSE 0
  152. #define JNI_TRUE 1
  153.  
  154. /*
  155.  * possible return values for JNI functions.
  156.  */
  157.  
  158. #define JNI_OK           0                 /* success */
  159. #define JNI_ERR          (-1)              /* unknown error */
  160. #define JNI_EDETACHED    (-2)              /* thread detached from the VM */
  161. #define JNI_EVERSION     (-3)              /* JNI version error */
  162. #define JNI_ENOMEM       (-4)              /* not enough memory */
  163. #define JNI_EEXIST       (-5)              /* VM already created */
  164. #define JNI_EINVAL       (-6)              /* invalid arguments */
  165.  
  166. /*
  167.  * used in ReleaseScalarArrayElements
  168.  */
  169.  
  170. #define JNI_COMMIT 1
  171. #define JNI_ABORT 2
  172.  
  173.  
  174. /*
  175.  * used in QueryJavaVM
  176.  */
  177. /*ibm@24452*/
  178. #define JNI_JVMQUERY_EXTRA_THREADS  1
  179. #define JNI_JVMQUERY_APP_FINALIZERS 2
  180. /*
  181.  * used in RegisterNatives to describe native method name, signature,
  182.  * and function pointer.
  183.  */
  184.  
  185. typedef struct {
  186.     char *name;
  187.     char *signature;
  188.     void *fnPtr;
  189. } JNINativeMethod;
  190.  
  191. /* GCStatus structure and Heap values */
  192.  
  193. #define JNI_GCQUERY_TRANSIENT_HEAP 1        /*ibm@27744*/
  194. #define JNI_GCQUERY_MIDDLEWARE_HEAP 2       /*ibm@27744*/
  195. #define JNI_GCQUERY_NURSERY_HEAP 3          /*ibm@27744*/
  196. #define JNI_GCQUERY_MATURE_HEAP 4           /*ibm@27744*/
  197. #define JNI_GCQUERY_SHARED_MEM 5            /*ibm@28445*/
  198.  
  199. typedef struct GCStatus {                   /*ibm@27744*/
  200.     jint heap;                              /*ibm@27744*/
  201.     jint count;                             /*ibm@27744*/
  202.     jlong freestorage;                      /*ibm@27744*/
  203.     jlong totalstorage;                     /*ibm@27744*/
  204. } GCStatus;                                 /*ibm@27744*/
  205.  
  206. /*
  207.  * JNI Native Method Interface.
  208.  */
  209.  
  210. struct JNINativeInterface_;
  211.  
  212. struct JNIEnv_;
  213.  
  214. #ifdef __cplusplus
  215. typedef JNIEnv_ JNIEnv;
  216. #else
  217. typedef const struct JNINativeInterface_ *JNIEnv;
  218. #endif
  219.  
  220. /*
  221.  * JNI Invocation Interface.
  222.  */
  223.  
  224. struct JNIInvokeInterface_;
  225.  
  226. struct JavaVM_;
  227.  
  228. #ifdef __cplusplus
  229. typedef JavaVM_ JavaVM;
  230. #else
  231. typedef const struct JNIInvokeInterface_ *JavaVM;
  232. #endif
  233.  
  234. struct JNINativeInterface_ {
  235.     void *reserved0;
  236.     void *reserved1;
  237.     void *reserved2;
  238.  
  239.     void *reserved3;
  240.     jint (JNICALL *GetVersion)(JNIEnv *env);
  241.  
  242.     jclass (JNICALL *DefineClass)
  243.       (JNIEnv *env, const char *name, jobject loader, const jbyte *buf,
  244.        jsize len);
  245.     jclass (JNICALL *FindClass)
  246.       (JNIEnv *env, const char *name);
  247.  
  248.     jmethodID (JNICALL *FromReflectedMethod)
  249.       (JNIEnv *env, jobject method);
  250.     jfieldID (JNICALL *FromReflectedField)
  251.       (JNIEnv *env, jobject field);
  252.  
  253.     jobject (JNICALL *ToReflectedMethod)
  254.       (JNIEnv *env, jclass cls, jmethodID methodID, jboolean isStatic);
  255.  
  256.     jclass (JNICALL *GetSuperclass)
  257.       (JNIEnv *env, jclass sub);
  258.     jboolean (JNICALL *IsAssignableFrom)
  259.       (JNIEnv *env, jclass sub, jclass sup);
  260.  
  261.     jobject (JNICALL *ToReflectedField)
  262.       (JNIEnv *env, jclass cls, jfieldID fieldID, jboolean isStatic);
  263.  
  264.     jint (JNICALL *Throw)
  265.       (JNIEnv *env, jthrowable obj);
  266.     jint (JNICALL *ThrowNew)
  267.       (JNIEnv *env, jclass clazz, const char *msg);
  268.     jthrowable (JNICALL *ExceptionOccurred)
  269.       (JNIEnv *env);
  270.     void (JNICALL *ExceptionDescribe)
  271.       (JNIEnv *env);
  272.     void (JNICALL *ExceptionClear)
  273.       (JNIEnv *env);
  274.     void (JNICALL *FatalError)
  275.       (JNIEnv *env, const char *msg);
  276.  
  277.     jint (JNICALL *PushLocalFrame)
  278.       (JNIEnv *env, jint capacity);
  279.     jobject (JNICALL *PopLocalFrame)
  280.       (JNIEnv *env, jobject result);
  281.  
  282.     jobject (JNICALL *NewGlobalRef)
  283.       (JNIEnv *env, jobject lobj);
  284.     void (JNICALL *DeleteGlobalRef)
  285.       (JNIEnv *env, jobject gref);
  286.     void (JNICALL *DeleteLocalRef)
  287.       (JNIEnv *env, jobject obj);
  288.     jboolean (JNICALL *IsSameObject)
  289.       (JNIEnv *env, jobject obj1, jobject obj2);
  290.     jobject (JNICALL *NewLocalRef)
  291.       (JNIEnv *env, jobject ref);
  292.     jint (JNICALL *EnsureLocalCapacity)
  293.       (JNIEnv *env, jint capacity);
  294.  
  295.     jobject (JNICALL *AllocObject)
  296.       (JNIEnv *env, jclass clazz);
  297.     jobject (JNICALL *NewObject)
  298.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  299.     jobject (JNICALL *NewObjectV)
  300.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  301.     jobject (JNICALL *NewObjectA)
  302.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  303.  
  304.     jclass (JNICALL *GetObjectClass)
  305.       (JNIEnv *env, jobject obj);
  306.     jboolean (JNICALL *IsInstanceOf)
  307.       (JNIEnv *env, jobject obj, jclass clazz);
  308.  
  309.     jmethodID (JNICALL *GetMethodID)
  310.       (JNIEnv *env, jclass clazz, const char *name, const char *sig);
  311.  
  312.     jobject (JNICALL *CallObjectMethod)
  313.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  314.     jobject (JNICALL *CallObjectMethodV)
  315.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  316.     jobject (JNICALL *CallObjectMethodA)
  317.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args);
  318.  
  319.     jboolean (JNICALL *CallBooleanMethod)
  320.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  321.     jboolean (JNICALL *CallBooleanMethodV)
  322.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  323.     jboolean (JNICALL *CallBooleanMethodA)
  324.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args);
  325.  
  326.     jbyte (JNICALL *CallByteMethod)
  327.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  328.     jbyte (JNICALL *CallByteMethodV)
  329.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  330.     jbyte (JNICALL *CallByteMethodA)
  331.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
  332.  
  333.     jchar (JNICALL *CallCharMethod)
  334.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  335.     jchar (JNICALL *CallCharMethodV)
  336.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  337.     jchar (JNICALL *CallCharMethodA)
  338.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
  339.  
  340.     jshort (JNICALL *CallShortMethod)
  341.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  342.     jshort (JNICALL *CallShortMethodV)
  343.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  344.     jshort (JNICALL *CallShortMethodA)
  345.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
  346.  
  347.     jint (JNICALL *CallIntMethod)
  348.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  349.     jint (JNICALL *CallIntMethodV)
  350.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  351.     jint (JNICALL *CallIntMethodA)
  352.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
  353.  
  354.     jlong (JNICALL *CallLongMethod)
  355.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  356.     jlong (JNICALL *CallLongMethodV)
  357.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  358.     jlong (JNICALL *CallLongMethodA)
  359.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
  360.  
  361.     jfloat (JNICALL *CallFloatMethod)
  362.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  363.     jfloat (JNICALL *CallFloatMethodV)
  364.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  365.     jfloat (JNICALL *CallFloatMethodA)
  366.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
  367.  
  368.     jdouble (JNICALL *CallDoubleMethod)
  369.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  370.     jdouble (JNICALL *CallDoubleMethodV)
  371.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  372.     jdouble (JNICALL *CallDoubleMethodA)
  373.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
  374.  
  375.     void (JNICALL *CallVoidMethod)
  376.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  377.     void (JNICALL *CallVoidMethodV)
  378.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  379.     void (JNICALL *CallVoidMethodA)
  380.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args);
  381.  
  382.     jobject (JNICALL *CallNonvirtualObjectMethod)
  383.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  384.     jobject (JNICALL *CallNonvirtualObjectMethodV)
  385.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  386.        va_list args);
  387.     jobject (JNICALL *CallNonvirtualObjectMethodA)
  388.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  389.        jvalue * args);
  390.  
  391.     jboolean (JNICALL *CallNonvirtualBooleanMethod)
  392.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  393.     jboolean (JNICALL *CallNonvirtualBooleanMethodV)
  394.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  395.        va_list args);
  396.     jboolean (JNICALL *CallNonvirtualBooleanMethodA)
  397.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  398.        jvalue * args);
  399.  
  400.     jbyte (JNICALL *CallNonvirtualByteMethod)
  401.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  402.     jbyte (JNICALL *CallNonvirtualByteMethodV)
  403.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  404.        va_list args);
  405.     jbyte (JNICALL *CallNonvirtualByteMethodA)
  406.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  407.        jvalue *args);
  408.  
  409.     jchar (JNICALL *CallNonvirtualCharMethod)
  410.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  411.     jchar (JNICALL *CallNonvirtualCharMethodV)
  412.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  413.        va_list args);
  414.     jchar (JNICALL *CallNonvirtualCharMethodA)
  415.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  416.        jvalue *args);
  417.  
  418.     jshort (JNICALL *CallNonvirtualShortMethod)
  419.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  420.     jshort (JNICALL *CallNonvirtualShortMethodV)
  421.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  422.        va_list args);
  423.     jshort (JNICALL *CallNonvirtualShortMethodA)
  424.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  425.        jvalue *args);
  426.  
  427.     jint (JNICALL *CallNonvirtualIntMethod)
  428.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  429.     jint (JNICALL *CallNonvirtualIntMethodV)
  430.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  431.        va_list args);
  432.     jint (JNICALL *CallNonvirtualIntMethodA)
  433.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  434.        jvalue *args);
  435.  
  436.     jlong (JNICALL *CallNonvirtualLongMethod)
  437.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  438.     jlong (JNICALL *CallNonvirtualLongMethodV)
  439.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  440.        va_list args);
  441.     jlong (JNICALL *CallNonvirtualLongMethodA)
  442.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  443.        jvalue *args);
  444.  
  445.     jfloat (JNICALL *CallNonvirtualFloatMethod)
  446.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  447.     jfloat (JNICALL *CallNonvirtualFloatMethodV)
  448.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  449.        va_list args);
  450.     jfloat (JNICALL *CallNonvirtualFloatMethodA)
  451.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  452.        jvalue *args);
  453.  
  454.     jdouble (JNICALL *CallNonvirtualDoubleMethod)
  455.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  456.     jdouble (JNICALL *CallNonvirtualDoubleMethodV)
  457.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  458.        va_list args);
  459.     jdouble (JNICALL *CallNonvirtualDoubleMethodA)
  460.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  461.        jvalue *args);
  462.  
  463.     void (JNICALL *CallNonvirtualVoidMethod)
  464.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  465.     void (JNICALL *CallNonvirtualVoidMethodV)
  466.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  467.        va_list args);
  468.     void (JNICALL *CallNonvirtualVoidMethodA)
  469.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  470.        jvalue * args);
  471.  
  472.     jfieldID (JNICALL *GetFieldID)
  473.       (JNIEnv *env, jclass clazz, const char *name, const char *sig);
  474.  
  475.     jobject (JNICALL *GetObjectField)
  476.       (JNIEnv *env, jobject obj, jfieldID fieldID);
  477.     jboolean (JNICALL *GetBooleanField)
  478.       (JNIEnv *env, jobject obj, jfieldID fieldID);
  479.     jbyte (JNICALL *GetByteField)
  480.       (JNIEnv *env, jobject obj, jfieldID fieldID);
  481.     jchar (JNICALL *GetCharField)
  482.       (JNIEnv *env, jobject obj, jfieldID fieldID);
  483.     jshort (JNICALL *GetShortField)
  484.       (JNIEnv *env, jobject obj, jfieldID fieldID);
  485.     jint (JNICALL *GetIntField)
  486.       (JNIEnv *env, jobject obj, jfieldID fieldID);
  487.     jlong (JNICALL *GetLongField)
  488.       (JNIEnv *env, jobject obj, jfieldID fieldID);
  489.     jfloat (JNICALL *GetFloatField)
  490.       (JNIEnv *env, jobject obj, jfieldID fieldID);
  491.     jdouble (JNICALL *GetDoubleField)
  492.       (JNIEnv *env, jobject obj, jfieldID fieldID);
  493.  
  494.     void (JNICALL *SetObjectField)
  495.       (JNIEnv *env, jobject obj, jfieldID fieldID, jobject val);
  496.     void (JNICALL *SetBooleanField)
  497.       (JNIEnv *env, jobject obj, jfieldID fieldID, jboolean val);
  498.     void (JNICALL *SetByteField)
  499.       (JNIEnv *env, jobject obj, jfieldID fieldID, jbyte val);
  500.     void (JNICALL *SetCharField)
  501.       (JNIEnv *env, jobject obj, jfieldID fieldID, jchar val);
  502.     void (JNICALL *SetShortField)
  503.       (JNIEnv *env, jobject obj, jfieldID fieldID, jshort val);
  504.     void (JNICALL *SetIntField)
  505.       (JNIEnv *env, jobject obj, jfieldID fieldID, jint val);
  506.     void (JNICALL *SetLongField)
  507.       (JNIEnv *env, jobject obj, jfieldID fieldID, jlong val);
  508.     void (JNICALL *SetFloatField)
  509.       (JNIEnv *env, jobject obj, jfieldID fieldID, jfloat val);
  510.     void (JNICALL *SetDoubleField)
  511.       (JNIEnv *env, jobject obj, jfieldID fieldID, jdouble val);
  512.  
  513.     jmethodID (JNICALL *GetStaticMethodID)
  514.       (JNIEnv *env, jclass clazz, const char *name, const char *sig);
  515.  
  516.     jobject (JNICALL *CallStaticObjectMethod)
  517.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  518.     jobject (JNICALL *CallStaticObjectMethodV)
  519.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  520.     jobject (JNICALL *CallStaticObjectMethodA)
  521.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  522.  
  523.     jboolean (JNICALL *CallStaticBooleanMethod)
  524.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  525.     jboolean (JNICALL *CallStaticBooleanMethodV)
  526.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  527.     jboolean (JNICALL *CallStaticBooleanMethodA)
  528.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  529.  
  530.     jbyte (JNICALL *CallStaticByteMethod)
  531.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  532.     jbyte (JNICALL *CallStaticByteMethodV)
  533.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  534.     jbyte (JNICALL *CallStaticByteMethodA)
  535.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  536.  
  537.     jchar (JNICALL *CallStaticCharMethod)
  538.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  539.     jchar (JNICALL *CallStaticCharMethodV)
  540.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  541.     jchar (JNICALL *CallStaticCharMethodA)
  542.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  543.  
  544.     jshort (JNICALL *CallStaticShortMethod)
  545.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  546.     jshort (JNICALL *CallStaticShortMethodV)
  547.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  548.     jshort (JNICALL *CallStaticShortMethodA)
  549.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  550.  
  551.     jint (JNICALL *CallStaticIntMethod)
  552.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  553.     jint (JNICALL *CallStaticIntMethodV)
  554.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  555.     jint (JNICALL *CallStaticIntMethodA)
  556.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  557.  
  558.     jlong (JNICALL *CallStaticLongMethod)
  559.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  560.     jlong (JNICALL *CallStaticLongMethodV)
  561.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  562.     jlong (JNICALL *CallStaticLongMethodA)
  563.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  564.  
  565.     jfloat (JNICALL *CallStaticFloatMethod)
  566.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  567.     jfloat (JNICALL *CallStaticFloatMethodV)
  568.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  569.     jfloat (JNICALL *CallStaticFloatMethodA)
  570.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  571.  
  572.     jdouble (JNICALL *CallStaticDoubleMethod)
  573.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  574.     jdouble (JNICALL *CallStaticDoubleMethodV)
  575.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  576.     jdouble (JNICALL *CallStaticDoubleMethodA)
  577.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  578.  
  579.     void (JNICALL *CallStaticVoidMethod)
  580.       (JNIEnv *env, jclass cls, jmethodID methodID, ...);
  581.     void (JNICALL *CallStaticVoidMethodV)
  582.       (JNIEnv *env, jclass cls, jmethodID methodID, va_list args);
  583.     void (JNICALL *CallStaticVoidMethodA)
  584.       (JNIEnv *env, jclass cls, jmethodID methodID, jvalue * args);
  585.  
  586.     jfieldID (JNICALL *GetStaticFieldID)
  587.       (JNIEnv *env, jclass clazz, const char *name, const char *sig);
  588.     jobject (JNICALL *GetStaticObjectField)
  589.       (JNIEnv *env, jclass clazz, jfieldID fieldID);
  590.     jboolean (JNICALL *GetStaticBooleanField)
  591.       (JNIEnv *env, jclass clazz, jfieldID fieldID);
  592.     jbyte (JNICALL *GetStaticByteField)
  593.       (JNIEnv *env, jclass clazz, jfieldID fieldID);
  594.     jchar (JNICALL *GetStaticCharField)
  595.       (JNIEnv *env, jclass clazz, jfieldID fieldID);
  596.     jshort (JNICALL *GetStaticShortField)
  597.       (JNIEnv *env, jclass clazz, jfieldID fieldID);
  598.     jint (JNICALL *GetStaticIntField)
  599.       (JNIEnv *env, jclass clazz, jfieldID fieldID);
  600.     jlong (JNICALL *GetStaticLongField)
  601.       (JNIEnv *env, jclass clazz, jfieldID fieldID);
  602.     jfloat (JNICALL *GetStaticFloatField)
  603.       (JNIEnv *env, jclass clazz, jfieldID fieldID);
  604.     jdouble (JNICALL *GetStaticDoubleField)
  605.       (JNIEnv *env, jclass clazz, jfieldID fieldID);
  606.  
  607.     void (JNICALL *SetStaticObjectField)
  608.       (JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value);
  609.     void (JNICALL *SetStaticBooleanField)
  610.       (JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value);
  611.     void (JNICALL *SetStaticByteField)
  612.       (JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value);
  613.     void (JNICALL *SetStaticCharField)
  614.       (JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value);
  615.     void (JNICALL *SetStaticShortField)
  616.       (JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value);
  617.     void (JNICALL *SetStaticIntField)
  618.       (JNIEnv *env, jclass clazz, jfieldID fieldID, jint value);
  619.     void (JNICALL *SetStaticLongField)
  620.       (JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value);
  621.     void (JNICALL *SetStaticFloatField)
  622.       (JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value);
  623.     void (JNICALL *SetStaticDoubleField)
  624.       (JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value);
  625.  
  626.     jstring (JNICALL *NewString)
  627.       (JNIEnv *env, const jchar *unicode, jsize len);
  628.     jsize (JNICALL *GetStringLength)
  629.       (JNIEnv *env, jstring str);
  630.     const jchar *(JNICALL *GetStringChars)
  631.       (JNIEnv *env, jstring str, jboolean *isCopy);
  632.     void (JNICALL *ReleaseStringChars)
  633.       (JNIEnv *env, jstring str, const jchar *chars);
  634.  
  635.     jstring (JNICALL *NewStringUTF)
  636.       (JNIEnv *env, const char *utf);
  637.     jsize (JNICALL *GetStringUTFLength)
  638.       (JNIEnv *env, jstring str);
  639.     const char* (JNICALL *GetStringUTFChars)
  640.       (JNIEnv *env, jstring str, jboolean *isCopy);
  641.     void (JNICALL *ReleaseStringUTFChars)
  642.       (JNIEnv *env, jstring str, const char* chars);
  643.  
  644.  
  645.     jsize (JNICALL *GetArrayLength)
  646.       (JNIEnv *env, jarray array);
  647.  
  648.     jobjectArray (JNICALL *NewObjectArray)
  649.       (JNIEnv *env, jsize len, jclass clazz, jobject init);
  650.     jobject (JNICALL *GetObjectArrayElement)
  651.       (JNIEnv *env, jobjectArray array, jsize index);
  652.     void (JNICALL *SetObjectArrayElement)
  653.       (JNIEnv *env, jobjectArray array, jsize index, jobject val);
  654.  
  655.     jbooleanArray (JNICALL *NewBooleanArray)
  656.       (JNIEnv *env, jsize len);
  657.     jbyteArray (JNICALL *NewByteArray)
  658.       (JNIEnv *env, jsize len);
  659.     jcharArray (JNICALL *NewCharArray)
  660.       (JNIEnv *env, jsize len);
  661.     jshortArray (JNICALL *NewShortArray)
  662.       (JNIEnv *env, jsize len);
  663.     jintArray (JNICALL *NewIntArray)
  664.       (JNIEnv *env, jsize len);
  665.     jlongArray (JNICALL *NewLongArray)
  666.       (JNIEnv *env, jsize len);
  667.     jfloatArray (JNICALL *NewFloatArray)
  668.       (JNIEnv *env, jsize len);
  669.     jdoubleArray (JNICALL *NewDoubleArray)
  670.       (JNIEnv *env, jsize len);
  671.  
  672.     jboolean * (JNICALL *GetBooleanArrayElements)
  673.       (JNIEnv *env, jbooleanArray array, jboolean *isCopy);
  674.     jbyte * (JNICALL *GetByteArrayElements)
  675.       (JNIEnv *env, jbyteArray array, jboolean *isCopy);
  676.     jchar * (JNICALL *GetCharArrayElements)
  677.       (JNIEnv *env, jcharArray array, jboolean *isCopy);
  678.     jshort * (JNICALL *GetShortArrayElements)
  679.       (JNIEnv *env, jshortArray array, jboolean *isCopy);
  680.     jint * (JNICALL *GetIntArrayElements)
  681.       (JNIEnv *env, jintArray array, jboolean *isCopy);
  682.     jlong * (JNICALL *GetLongArrayElements)
  683.       (JNIEnv *env, jlongArray array, jboolean *isCopy);
  684.     jfloat * (JNICALL *GetFloatArrayElements)
  685.       (JNIEnv *env, jfloatArray array, jboolean *isCopy);
  686.     jdouble * (JNICALL *GetDoubleArrayElements)
  687.       (JNIEnv *env, jdoubleArray array, jboolean *isCopy);
  688.  
  689.     void (JNICALL *ReleaseBooleanArrayElements)
  690.       (JNIEnv *env, jbooleanArray array, jboolean *elems, jint mode);
  691.     void (JNICALL *ReleaseByteArrayElements)
  692.       (JNIEnv *env, jbyteArray array, jbyte *elems, jint mode);
  693.     void (JNICALL *ReleaseCharArrayElements)
  694.       (JNIEnv *env, jcharArray array, jchar *elems, jint mode);
  695.     void (JNICALL *ReleaseShortArrayElements)
  696.       (JNIEnv *env, jshortArray array, jshort *elems, jint mode);
  697.     void (JNICALL *ReleaseIntArrayElements)
  698.       (JNIEnv *env, jintArray array, jint *elems, jint mode);
  699.     void (JNICALL *ReleaseLongArrayElements)
  700.       (JNIEnv *env, jlongArray array, jlong *elems, jint mode);
  701.     void (JNICALL *ReleaseFloatArrayElements)
  702.       (JNIEnv *env, jfloatArray array, jfloat *elems, jint mode);
  703.     void (JNICALL *ReleaseDoubleArrayElements)
  704.       (JNIEnv *env, jdoubleArray array, jdouble *elems, jint mode);
  705.  
  706.     void (JNICALL *GetBooleanArrayRegion)
  707.       (JNIEnv *env, jbooleanArray array, jsize start, jsize l, jboolean *buf);
  708.     void (JNICALL *GetByteArrayRegion)
  709.       (JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf);
  710.     void (JNICALL *GetCharArrayRegion)
  711.       (JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf);
  712.     void (JNICALL *GetShortArrayRegion)
  713.       (JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf);
  714.     void (JNICALL *GetIntArrayRegion)
  715.       (JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf);
  716.     void (JNICALL *GetLongArrayRegion)
  717.       (JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf);
  718.     void (JNICALL *GetFloatArrayRegion)
  719.       (JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf);
  720.     void (JNICALL *GetDoubleArrayRegion)
  721.       (JNIEnv *env, jdoubleArray array, jsize start, jsize len, jdouble *buf);
  722.  
  723.     void (JNICALL *SetBooleanArrayRegion)
  724.       (JNIEnv *env, jbooleanArray array, jsize start, jsize l, jboolean *buf);
  725.     void (JNICALL *SetByteArrayRegion)
  726.       (JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf);
  727.     void (JNICALL *SetCharArrayRegion)
  728.       (JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf);
  729.     void (JNICALL *SetShortArrayRegion)
  730.       (JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf);
  731.     void (JNICALL *SetIntArrayRegion)
  732.       (JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf);
  733.     void (JNICALL *SetLongArrayRegion)
  734.       (JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf);
  735.     void (JNICALL *SetFloatArrayRegion)
  736.       (JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf);
  737.     void (JNICALL *SetDoubleArrayRegion)
  738.       (JNIEnv *env, jdoubleArray array, jsize start, jsize len, jdouble *buf);
  739.  
  740.     jint (JNICALL *RegisterNatives)
  741.       (JNIEnv *env, jclass clazz, const JNINativeMethod *methods,
  742.        jint nMethods);
  743.     jint (JNICALL *UnregisterNatives)
  744.       (JNIEnv *env, jclass clazz);
  745.  
  746.     jint (JNICALL *MonitorEnter)
  747.       (JNIEnv *env, jobject obj);
  748.     jint (JNICALL *MonitorExit)
  749.       (JNIEnv *env, jobject obj);
  750.  
  751.     jint (JNICALL *GetJavaVM)
  752.       (JNIEnv *env, JavaVM **vm);
  753.  
  754.     void (JNICALL *GetStringRegion)
  755.       (JNIEnv *env, jstring str, jsize start, jsize len, jchar *buf);
  756.     void (JNICALL *GetStringUTFRegion)
  757.       (JNIEnv *env, jstring str, jsize start, jsize len, char *buf);
  758.  
  759.     void * (JNICALL *GetPrimitiveArrayCritical)
  760.       (JNIEnv *env, jarray array, jboolean *isCopy);
  761.     void (JNICALL *ReleasePrimitiveArrayCritical)
  762.       (JNIEnv *env, jarray array, void *carray, jint mode);
  763.  
  764.     const jchar * (JNICALL *GetStringCritical)
  765.       (JNIEnv *env, jstring string, jboolean *isCopy);
  766.     void (JNICALL *ReleaseStringCritical)
  767.       (JNIEnv *env, jstring string, const jchar *cstring);
  768.  
  769.     jweak (JNICALL *NewWeakGlobalRef)
  770.        (JNIEnv *env, jobject obj);
  771.     void (JNICALL *DeleteWeakGlobalRef)
  772.        (JNIEnv *env, jweak ref);
  773.  
  774.     jboolean (JNICALL *ExceptionCheck)
  775.        (JNIEnv *env);
  776. };
  777.  
  778. /*
  779.  * We use inlined functions for C++ so that programmers can write:
  780.  *
  781.  *    env->FindClass("java/lang/String")
  782.  *
  783.  * in C++ rather than:
  784.  *
  785.  *    (*env)->FindClass(env, "java/lang/String")
  786.  *
  787.  * in C.
  788.  */
  789.  
  790. struct JNIEnv_ {
  791.     const struct JNINativeInterface_ *functions;
  792. #ifdef __cplusplus
  793.  
  794.     jint GetVersion() {
  795.         return functions->GetVersion(this);
  796.     }
  797.     jclass DefineClass(const char *name, jobject loader, const jbyte *buf,
  798.                        jsize len) {
  799.         return functions->DefineClass(this, name, loader, buf, len);
  800.     }
  801.     jclass FindClass(const char *name) {
  802.         return functions->FindClass(this, name);
  803.     }
  804.     jmethodID FromReflectedMethod(jobject method) {
  805.         return functions->FromReflectedMethod(this,method);
  806.     }
  807.     jfieldID FromReflectedField(jobject field) {
  808.         return functions->FromReflectedField(this,field);
  809.     }
  810.  
  811.     jobject ToReflectedMethod(jclass cls, jmethodID methodID, jboolean isStatic) {
  812.         return functions->ToReflectedMethod(this, cls, methodID, isStatic);
  813.     }
  814.  
  815.     jclass GetSuperclass(jclass sub) {
  816.         return functions->GetSuperclass(this, sub);
  817.     }
  818.     jboolean IsAssignableFrom(jclass sub, jclass sup) {
  819.         return functions->IsAssignableFrom(this, sub, sup);
  820.     }
  821.  
  822.     jobject ToReflectedField(jclass cls, jfieldID fieldID, jboolean isStatic) {
  823.         return functions->ToReflectedField(this,cls,fieldID,isStatic);
  824.     }
  825.  
  826.     jint Throw(jthrowable obj) {
  827.         return functions->Throw(this, obj);
  828.     }
  829.     jint ThrowNew(jclass clazz, const char *msg) {
  830.         return functions->ThrowNew(this, clazz, msg);
  831.     }
  832.     jthrowable ExceptionOccurred() {
  833.         return functions->ExceptionOccurred(this);
  834.     }
  835.     void ExceptionDescribe() {
  836.         functions->ExceptionDescribe(this);
  837.     }
  838.     void ExceptionClear() {
  839.         functions->ExceptionClear(this);
  840.     }
  841.     void FatalError(const char *msg) {
  842.         functions->FatalError(this, msg);
  843.     }
  844.  
  845.     jint PushLocalFrame(jint capacity) {
  846.         return functions->PushLocalFrame(this,capacity);
  847.     }
  848.     jobject PopLocalFrame(jobject result) {
  849.         return functions->PopLocalFrame(this,result);
  850.     }
  851.  
  852.     jobject NewGlobalRef(jobject lobj) {
  853.         return functions->NewGlobalRef(this,lobj);
  854.     }
  855.     void DeleteGlobalRef(jobject gref) {
  856.         functions->DeleteGlobalRef(this,gref);
  857.     }
  858.     void DeleteLocalRef(jobject obj) {
  859.         functions->DeleteLocalRef(this, obj);
  860.     }
  861.  
  862.     jboolean IsSameObject(jobject obj1, jobject obj2) {
  863.         return functions->IsSameObject(this,obj1,obj2);
  864.     }
  865.  
  866.     jobject NewLocalRef(jobject ref) {
  867.         return functions->NewLocalRef(this,ref);
  868.     }
  869.     jint EnsureLocalCapacity(jint capacity) {
  870.         return functions->EnsureLocalCapacity(this,capacity);
  871.     }
  872.  
  873.     jobject AllocObject(jclass clazz) {
  874.         return functions->AllocObject(this,clazz);
  875.     }
  876.     jobject NewObject(jclass clazz, jmethodID methodID, ...) {
  877.         va_list args;
  878.         jobject result;
  879.         va_start(args, methodID);
  880.         result = functions->NewObjectV(this,clazz,methodID,args);
  881.         va_end(args);
  882.         return result;
  883.     }
  884.     jobject NewObjectV(jclass clazz, jmethodID methodID,
  885.                        va_list args) {
  886.         return functions->NewObjectV(this,clazz,methodID,args);
  887.     }
  888.     jobject NewObjectA(jclass clazz, jmethodID methodID,
  889.                        jvalue *args) {
  890.         return functions->NewObjectA(this,clazz,methodID,args);
  891.     }
  892.  
  893.     jclass GetObjectClass(jobject obj) {
  894.         return functions->GetObjectClass(this,obj);
  895.     }
  896.     jboolean IsInstanceOf(jobject obj, jclass clazz) {
  897.         return functions->IsInstanceOf(this,obj,clazz);
  898.     }
  899.  
  900.     jmethodID GetMethodID(jclass clazz, const char *name,
  901.                           const char *sig) {
  902.         return functions->GetMethodID(this,clazz,name,sig);
  903.     }
  904.  
  905.     jobject CallObjectMethod(jobject obj, jmethodID methodID, ...) {
  906.         va_list args;
  907.         jobject result;
  908.         va_start(args,methodID);
  909.         result = functions->CallObjectMethodV(this,obj,methodID,args);
  910.         va_end(args);
  911.         return result;
  912.     }
  913.     jobject CallObjectMethodV(jobject obj, jmethodID methodID,
  914.                         va_list args) {
  915.         return functions->CallObjectMethodV(this,obj,methodID,args);
  916.     }
  917.     jobject CallObjectMethodA(jobject obj, jmethodID methodID,
  918.                         jvalue * args) {
  919.         return functions->CallObjectMethodA(this,obj,methodID,args);
  920.     }
  921.  
  922.     jboolean CallBooleanMethod(jobject obj,
  923.                                jmethodID methodID, ...) {
  924.         va_list args;
  925.         jboolean result;
  926.         va_start(args,methodID);
  927.         result = functions->CallBooleanMethodV(this,obj,methodID,args);
  928.         va_end(args);
  929.         return result;
  930.     }
  931.     jboolean CallBooleanMethodV(jobject obj, jmethodID methodID,
  932.                                 va_list args) {
  933.         return functions->CallBooleanMethodV(this,obj,methodID,args);
  934.     }
  935.     jboolean CallBooleanMethodA(jobject obj, jmethodID methodID,
  936.                                 jvalue * args) {
  937.         return functions->CallBooleanMethodA(this,obj,methodID, args);
  938.     }
  939.  
  940.     jbyte CallByteMethod(jobject obj, jmethodID methodID, ...) {
  941.         va_list args;
  942.         jbyte result;
  943.         va_start(args,methodID);
  944.         result = functions->CallByteMethodV(this,obj,methodID,args);
  945.         va_end(args);
  946.         return result;
  947.     }
  948.     jbyte CallByteMethodV(jobject obj, jmethodID methodID,
  949.                           va_list args) {
  950.         return functions->CallByteMethodV(this,obj,methodID,args);
  951.     }
  952.     jbyte CallByteMethodA(jobject obj, jmethodID methodID,
  953.                           jvalue * args) {
  954.         return functions->CallByteMethodA(this,obj,methodID,args);
  955.     }
  956.  
  957.     jchar CallCharMethod(jobject obj, jmethodID methodID, ...) {
  958.         va_list args;
  959.         jchar result;
  960.         va_start(args,methodID);
  961.         result = functions->CallCharMethodV(this,obj,methodID,args);
  962.         va_end(args);
  963.         return result;
  964.     }
  965.     jchar CallCharMethodV(jobject obj, jmethodID methodID,
  966.                           va_list args) {
  967.         return functions->CallCharMethodV(this,obj,methodID,args);
  968.     }
  969.     jchar CallCharMethodA(jobject obj, jmethodID methodID,
  970.                           jvalue * args) {
  971.         return functions->CallCharMethodA(this,obj,methodID,args);
  972.     }
  973.  
  974.     jshort CallShortMethod(jobject obj, jmethodID methodID, ...) {
  975.         va_list args;
  976.         jshort result;
  977.         va_start(args,methodID);
  978.         result = functions->CallShortMethodV(this,obj,methodID,args);
  979.         va_end(args);
  980.         return result;
  981.     }
  982.     jshort CallShortMethodV(jobject obj, jmethodID methodID,
  983.                             va_list args) {
  984.         return functions->CallShortMethodV(this,obj,methodID,args);
  985.     }
  986.     jshort CallShortMethodA(jobject obj, jmethodID methodID,
  987.                             jvalue * args) {
  988.         return functions->CallShortMethodA(this,obj,methodID,args);
  989.     }
  990.  
  991.     jint CallIntMethod(jobject obj, jmethodID methodID, ...) {
  992.         va_list args;
  993.         jint result;
  994.         va_start(args,methodID);
  995.         result = functions->CallIntMethodV(this,obj,methodID,args);
  996.         va_end(args);
  997.         return result;
  998.     }
  999.     jint CallIntMethodV(jobject obj, jmethodID methodID,
  1000.                         va_list args) {
  1001.         return functions->CallIntMethodV(this,obj,methodID,args);
  1002.     }
  1003.     jint CallIntMethodA(jobject obj, jmethodID methodID,
  1004.                         jvalue * args) {
  1005.         return functions->CallIntMethodA(this,obj,methodID,args);
  1006.     }
  1007.  
  1008.     jlong CallLongMethod(jobject obj, jmethodID methodID, ...) {
  1009.         va_list args;
  1010.         jlong result;
  1011.         va_start(args,methodID);
  1012.         result = functions->CallLongMethodV(this,obj,methodID,args);
  1013.         va_end(args);
  1014.         return result;
  1015.     }
  1016.     jlong CallLongMethodV(jobject obj, jmethodID methodID,
  1017.                           va_list args) {
  1018.         return functions->CallLongMethodV(this,obj,methodID,args);
  1019.     }
  1020.     jlong CallLongMethodA(jobject obj, jmethodID methodID,
  1021.                           jvalue * args) {
  1022.         return functions->CallLongMethodA(this,obj,methodID,args);
  1023.     }
  1024.  
  1025.     jfloat CallFloatMethod(jobject obj, jmethodID methodID, ...) {
  1026.         va_list args;
  1027.         jfloat result;
  1028.         va_start(args,methodID);
  1029.         result = functions->CallFloatMethodV(this,obj,methodID,args);
  1030.         va_end(args);
  1031.         return result;
  1032.     }
  1033.     jfloat CallFloatMethodV(jobject obj, jmethodID methodID,
  1034.                             va_list args) {
  1035.         return functions->CallFloatMethodV(this,obj,methodID,args);
  1036.     }
  1037.     jfloat CallFloatMethodA(jobject obj, jmethodID methodID,
  1038.                             jvalue * args) {
  1039.         return functions->CallFloatMethodA(this,obj,methodID,args);
  1040.     }
  1041.  
  1042.     jdouble CallDoubleMethod(jobject obj, jmethodID methodID, ...) {
  1043.         va_list args;
  1044.         jdouble result;
  1045.         va_start(args,methodID);
  1046.         result = functions->CallDoubleMethodV(this,obj,methodID,args);
  1047.         va_end(args);
  1048.         return result;
  1049.     }
  1050.     jdouble CallDoubleMethodV(jobject obj, jmethodID methodID,
  1051.                         va_list args) {
  1052.         return functions->CallDoubleMethodV(this,obj,methodID,args);
  1053.     }
  1054.     jdouble CallDoubleMethodA(jobject obj, jmethodID methodID,
  1055.                         jvalue * args) {
  1056.         return functions->CallDoubleMethodA(this,obj,methodID,args);
  1057.     }
  1058.  
  1059.     void CallVoidMethod(jobject obj, jmethodID methodID, ...) {
  1060.         va_list args;
  1061.         va_start(args,methodID);
  1062.         functions->CallVoidMethodV(this,obj,methodID,args);
  1063.         va_end(args);
  1064.     }
  1065.     void CallVoidMethodV(jobject obj, jmethodID methodID,
  1066.                          va_list args) {
  1067.         functions->CallVoidMethodV(this,obj,methodID,args);
  1068.     }
  1069.     void CallVoidMethodA(jobject obj, jmethodID methodID,
  1070.                          jvalue * args) {
  1071.         functions->CallVoidMethodA(this,obj,methodID,args);
  1072.     }
  1073.  
  1074.     jobject CallNonvirtualObjectMethod(jobject obj, jclass clazz,
  1075.                                        jmethodID methodID, ...) {
  1076.         va_list args;
  1077.         jobject result;
  1078.         va_start(args,methodID);
  1079.         result = functions->CallNonvirtualObjectMethodV(this,obj,clazz,
  1080.                                                         methodID,args);
  1081.         va_end(args);
  1082.         return result;
  1083.     }
  1084.     jobject CallNonvirtualObjectMethodV(jobject obj, jclass clazz,
  1085.                                         jmethodID methodID, va_list args) {
  1086.         return functions->CallNonvirtualObjectMethodV(this,obj,clazz,
  1087.                                                       methodID,args);
  1088.     }
  1089.     jobject CallNonvirtualObjectMethodA(jobject obj, jclass clazz,
  1090.                                         jmethodID methodID, jvalue * args) {
  1091.         return functions->CallNonvirtualObjectMethodA(this,obj,clazz,
  1092.                                                       methodID,args);
  1093.     }
  1094.  
  1095.     jboolean CallNonvirtualBooleanMethod(jobject obj, jclass clazz,
  1096.                                          jmethodID methodID, ...) {
  1097.         va_list args;
  1098.         jboolean result;
  1099.         va_start(args,methodID);
  1100.         result = functions->CallNonvirtualBooleanMethodV(this,obj,clazz,
  1101.                                                          methodID,args);
  1102.         va_end(args);
  1103.         return result;
  1104.     }
  1105.     jboolean CallNonvirtualBooleanMethodV(jobject obj, jclass clazz,
  1106.                                           jmethodID methodID, va_list args) {
  1107.         return functions->CallNonvirtualBooleanMethodV(this,obj,clazz,
  1108.                                                        methodID,args);
  1109.     }
  1110.     jboolean CallNonvirtualBooleanMethodA(jobject obj, jclass clazz,
  1111.                                           jmethodID methodID, jvalue * args) {
  1112.         return functions->CallNonvirtualBooleanMethodA(this,obj,clazz,
  1113.                                                        methodID, args);
  1114.     }
  1115.  
  1116.     jbyte CallNonvirtualByteMethod(jobject obj, jclass clazz,
  1117.                                    jmethodID methodID, ...) {
  1118.         va_list args;
  1119.         jbyte result;
  1120.         va_start(args,methodID);
  1121.         result = functions->CallNonvirtualByteMethodV(this,obj,clazz,
  1122.                                                       methodID,args);
  1123.         va_end(args);
  1124.         return result;
  1125.     }
  1126.     jbyte CallNonvirtualByteMethodV(jobject obj, jclass clazz,
  1127.                                     jmethodID methodID, va_list args) {
  1128.         return functions->CallNonvirtualByteMethodV(this,obj,clazz,
  1129.                                                     methodID,args);
  1130.     }
  1131.     jbyte CallNonvirtualByteMethodA(jobject obj, jclass clazz,
  1132.                                     jmethodID methodID, jvalue * args) {
  1133.         return functions->CallNonvirtualByteMethodA(this,obj,clazz,
  1134.                                                     methodID,args);
  1135.     }
  1136.  
  1137.     jchar CallNonvirtualCharMethod(jobject obj, jclass clazz,
  1138.                                    jmethodID methodID, ...) {
  1139.         va_list args;
  1140.         jchar result;
  1141.         va_start(args,methodID);
  1142.         result = functions->CallNonvirtualCharMethodV(this,obj,clazz,
  1143.                                                       methodID,args);
  1144.         va_end(args);
  1145.         return result;
  1146.     }
  1147.     jchar CallNonvirtualCharMethodV(jobject obj, jclass clazz,
  1148.                                     jmethodID methodID, va_list args) {
  1149.         return functions->CallNonvirtualCharMethodV(this,obj,clazz,
  1150.                                                     methodID,args);
  1151.     }
  1152.     jchar CallNonvirtualCharMethodA(jobject obj, jclass clazz,
  1153.                                     jmethodID methodID, jvalue * args) {
  1154.         return functions->CallNonvirtualCharMethodA(this,obj,clazz,
  1155.                                                     methodID,args);
  1156.     }
  1157.  
  1158.     jshort CallNonvirtualShortMethod(jobject obj, jclass clazz,
  1159.                                      jmethodID methodID, ...) {
  1160.         va_list args;
  1161.         jshort result;
  1162.         va_start(args,methodID);
  1163.         result = functions->CallNonvirtualShortMethodV(this,obj,clazz,
  1164.                                                        methodID,args);
  1165.         va_end(args);
  1166.         return result;
  1167.     }
  1168.     jshort CallNonvirtualShortMethodV(jobject obj, jclass clazz,
  1169.                                       jmethodID methodID, va_list args) {
  1170.         return functions->CallNonvirtualShortMethodV(this,obj,clazz,
  1171.                                                      methodID,args);
  1172.     }
  1173.     jshort CallNonvirtualShortMethodA(jobject obj, jclass clazz,
  1174.                                       jmethodID methodID, jvalue * args) {
  1175.         return functions->CallNonvirtualShortMethodA(this,obj,clazz,
  1176.                                                      methodID,args);
  1177.     }
  1178.  
  1179.     jint CallNonvirtualIntMethod(jobject obj, jclass clazz,
  1180.                                  jmethodID methodID, ...) {
  1181.         va_list args;
  1182.         jint result;
  1183.         va_start(args,methodID);
  1184.         result = functions->CallNonvirtualIntMethodV(this,obj,clazz,
  1185.                                                      methodID,args);
  1186.         va_end(args);
  1187.         return result;
  1188.     }
  1189.     jint CallNonvirtualIntMethodV(jobject obj, jclass clazz,
  1190.                                   jmethodID methodID, va_list args) {
  1191.         return functions->CallNonvirtualIntMethodV(this,obj,clazz,
  1192.                                                    methodID,args);
  1193.     }
  1194.     jint CallNonvirtualIntMethodA(jobject obj, jclass clazz,
  1195.                                   jmethodID methodID, jvalue * args) {
  1196.         return functions->CallNonvirtualIntMethodA(this,obj,clazz,
  1197.                                                    methodID,args);
  1198.     }
  1199.  
  1200.     jlong CallNonvirtualLongMethod(jobject obj, jclass clazz,
  1201.                                    jmethodID methodID, ...) {
  1202.         va_list args;
  1203.         jlong result;
  1204.         va_start(args,methodID);
  1205.         result = functions->CallNonvirtualLongMethodV(this,obj,clazz,
  1206.                                                       methodID,args);
  1207.         va_end(args);
  1208.         return result;
  1209.     }
  1210.     jlong CallNonvirtualLongMethodV(jobject obj, jclass clazz,
  1211.                                     jmethodID methodID, va_list args) {
  1212.         return functions->CallNonvirtualLongMethodV(this,obj,clazz,
  1213.                                                     methodID,args);
  1214.     }
  1215.     jlong CallNonvirtualLongMethodA(jobject obj, jclass clazz,
  1216.                                     jmethodID methodID, jvalue * args) {
  1217.         return functions->CallNonvirtualLongMethodA(this,obj,clazz,
  1218.                                                     methodID,args);
  1219.     }
  1220.  
  1221.     jfloat CallNonvirtualFloatMethod(jobject obj, jclass clazz,
  1222.                                      jmethodID methodID, ...) {
  1223.         va_list args;
  1224.         jfloat result;
  1225.         va_start(args,methodID);
  1226.         result = functions->CallNonvirtualFloatMethodV(this,obj,clazz,
  1227.                                                        methodID,args);
  1228.         va_end(args);
  1229.         return result;
  1230.     }
  1231.     jfloat CallNonvirtualFloatMethodV(jobject obj, jclass clazz,
  1232.                                       jmethodID methodID,
  1233.                                       va_list args) {
  1234.         return functions->CallNonvirtualFloatMethodV(this,obj,clazz,
  1235.                                                      methodID,args);
  1236.     }
  1237.     jfloat CallNonvirtualFloatMethodA(jobject obj, jclass clazz,
  1238.                                       jmethodID methodID,
  1239.                                       jvalue * args) {
  1240.         return functions->CallNonvirtualFloatMethodA(this,obj,clazz,
  1241.                                                      methodID,args);
  1242.     }
  1243.  
  1244.     jdouble CallNonvirtualDoubleMethod(jobject obj, jclass clazz,
  1245.                                        jmethodID methodID, ...) {
  1246.         va_list args;
  1247.         jdouble result;
  1248.         va_start(args,methodID);
  1249.         result = functions->CallNonvirtualDoubleMethodV(this,obj,clazz,
  1250.                                                         methodID,args);
  1251.         va_end(args);
  1252.         return result;
  1253.     }
  1254.     jdouble CallNonvirtualDoubleMethodV(jobject obj, jclass clazz,
  1255.                                         jmethodID methodID,
  1256.                                         va_list args) {
  1257.         return functions->CallNonvirtualDoubleMethodV(this,obj,clazz,
  1258.                                                       methodID,args);
  1259.     }
  1260.     jdouble CallNonvirtualDoubleMethodA(jobject obj, jclass clazz,
  1261.                                         jmethodID methodID,
  1262.                                         jvalue * args) {
  1263.         return functions->CallNonvirtualDoubleMethodA(this,obj,clazz,
  1264.                                                       methodID,args);
  1265.     }
  1266.  
  1267.     void CallNonvirtualVoidMethod(jobject obj, jclass clazz,
  1268.                                   jmethodID methodID, ...) {
  1269.         va_list args;
  1270.         va_start(args,methodID);
  1271.         functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);
  1272.         va_end(args);
  1273.     }
  1274.     void CallNonvirtualVoidMethodV(jobject obj, jclass clazz,
  1275.                                    jmethodID methodID,
  1276.                                    va_list args) {
  1277.         functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);
  1278.     }
  1279.     void CallNonvirtualVoidMethodA(jobject obj, jclass clazz,
  1280.                                    jmethodID methodID,
  1281.                                    jvalue * args) {
  1282.         functions->CallNonvirtualVoidMethodA(this,obj,clazz,methodID,args);
  1283.     }
  1284.  
  1285.     jfieldID GetFieldID(jclass clazz, const char *name,
  1286.                         const char *sig) {
  1287.         return functions->GetFieldID(this,clazz,name,sig);
  1288.     }
  1289.  
  1290.     jobject GetObjectField(jobject obj, jfieldID fieldID) {
  1291.         return functions->GetObjectField(this,obj,fieldID);
  1292.     }
  1293.     jboolean GetBooleanField(jobject obj, jfieldID fieldID) {
  1294.         return functions->GetBooleanField(this,obj,fieldID);
  1295.     }
  1296.     jbyte GetByteField(jobject obj, jfieldID fieldID) {
  1297.         return functions->GetByteField(this,obj,fieldID);
  1298.     }
  1299.     jchar GetCharField(jobject obj, jfieldID fieldID) {
  1300.         return functions->GetCharField(this,obj,fieldID);
  1301.     }
  1302.     jshort GetShortField(jobject obj, jfieldID fieldID) {
  1303.         return functions->GetShortField(this,obj,fieldID);
  1304.     }
  1305.     jint GetIntField(jobject obj, jfieldID fieldID) {
  1306.         return functions->GetIntField(this,obj,fieldID);
  1307.     }
  1308.     jlong GetLongField(jobject obj, jfieldID fieldID) {
  1309.         return functions->GetLongField(this,obj,fieldID);
  1310.     }
  1311.     jfloat GetFloatField(jobject obj, jfieldID fieldID) {
  1312.         return functions->GetFloatField(this,obj,fieldID);
  1313.     }
  1314.     jdouble GetDoubleField(jobject obj, jfieldID fieldID) {
  1315.         return functions->GetDoubleField(this,obj,fieldID);
  1316.     }
  1317.  
  1318.     void SetObjectField(jobject obj, jfieldID fieldID, jobject val) {
  1319.         functions->SetObjectField(this,obj,fieldID,val);
  1320.     }
  1321.     void SetBooleanField(jobject obj, jfieldID fieldID,
  1322.                          jboolean val) {
  1323.         functions->SetBooleanField(this,obj,fieldID,val);
  1324.     }
  1325.     void SetByteField(jobject obj, jfieldID fieldID,
  1326.                       jbyte val) {
  1327.         functions->SetByteField(this,obj,fieldID,val);
  1328.     }
  1329.     void SetCharField(jobject obj, jfieldID fieldID,
  1330.                       jchar val) {
  1331.         functions->SetCharField(this,obj,fieldID,val);
  1332.     }
  1333.     void SetShortField(jobject obj, jfieldID fieldID,
  1334.                        jshort val) {
  1335.         functions->SetShortField(this,obj,fieldID,val);
  1336.     }
  1337.     void SetIntField(jobject obj, jfieldID fieldID,
  1338.                      jint val) {
  1339.         functions->SetIntField(this,obj,fieldID,val);
  1340.     }
  1341.     void SetLongField(jobject obj, jfieldID fieldID,
  1342.                       jlong val) {
  1343.         functions->SetLongField(this,obj,fieldID,val);
  1344.     }
  1345.     void SetFloatField(jobject obj, jfieldID fieldID,
  1346.                        jfloat val) {
  1347.         functions->SetFloatField(this,obj,fieldID,val);
  1348.     }
  1349.     void SetDoubleField(jobject obj, jfieldID fieldID,
  1350.                         jdouble val) {
  1351.         functions->SetDoubleField(this,obj,fieldID,val);
  1352.     }
  1353.  
  1354.     jmethodID GetStaticMethodID(jclass clazz, const char *name,
  1355.                                 const char *sig) {
  1356.         return functions->GetStaticMethodID(this,clazz,name,sig);
  1357.     }
  1358.  
  1359.     jobject CallStaticObjectMethod(jclass clazz, jmethodID methodID,
  1360.                              ...) {
  1361.         va_list args;
  1362.         jobject result;
  1363.         va_start(args,methodID);
  1364.         result = functions->CallStaticObjectMethodV(this,clazz,methodID,args);
  1365.         va_end(args);
  1366.         return result;
  1367.     }
  1368.     jobject CallStaticObjectMethodV(jclass clazz, jmethodID methodID,
  1369.                               va_list args) {
  1370.         return functions->CallStaticObjectMethodV(this,clazz,methodID,args);
  1371.     }
  1372.     jobject CallStaticObjectMethodA(jclass clazz, jmethodID methodID,
  1373.                               jvalue *args) {
  1374.         return functions->CallStaticObjectMethodA(this,clazz,methodID,args);
  1375.     }
  1376.  
  1377.     jboolean CallStaticBooleanMethod(jclass clazz,
  1378.                                      jmethodID methodID, ...) {
  1379.         va_list args;
  1380.         jboolean result;
  1381.         va_start(args,methodID);
  1382.         result = functions->CallStaticBooleanMethodV(this,clazz,methodID,args);
  1383.         va_end(args);
  1384.         return result;
  1385.     }
  1386.     jboolean CallStaticBooleanMethodV(jclass clazz,
  1387.                                       jmethodID methodID, va_list args) {
  1388.         return functions->CallStaticBooleanMethodV(this,clazz,methodID,args);
  1389.     }
  1390.     jboolean CallStaticBooleanMethodA(jclass clazz,
  1391.                                       jmethodID methodID, jvalue *args) {
  1392.         return functions->CallStaticBooleanMethodA(this,clazz,methodID,args);
  1393.     }
  1394.  
  1395.     jbyte CallStaticByteMethod(jclass clazz,
  1396.                                jmethodID methodID, ...) {
  1397.         va_list args;
  1398.         jbyte result;
  1399.         va_start(args,methodID);
  1400.         result = functions->CallStaticByteMethodV(this,clazz,methodID,args);
  1401.         va_end(args);
  1402.         return result;
  1403.     }
  1404.     jbyte CallStaticByteMethodV(jclass clazz,
  1405.                                 jmethodID methodID, va_list args) {
  1406.         return functions->CallStaticByteMethodV(this,clazz,methodID,args);
  1407.     }
  1408.     jbyte CallStaticByteMethodA(jclass clazz,
  1409.                                 jmethodID methodID, jvalue *args) {
  1410.         return functions->CallStaticByteMethodA(this,clazz,methodID,args);
  1411.     }
  1412.  
  1413.     jchar CallStaticCharMethod(jclass clazz,
  1414.                                jmethodID methodID, ...) {
  1415.         va_list args;
  1416.         jchar result;
  1417.         va_start(args,methodID);
  1418.         result = functions->CallStaticCharMethodV(this,clazz,methodID,args);
  1419.         va_end(args);
  1420.         return result;
  1421.     }
  1422.     jchar CallStaticCharMethodV(jclass clazz,
  1423.                                 jmethodID methodID, va_list args) {
  1424.         return functions->CallStaticCharMethodV(this,clazz,methodID,args);
  1425.     }
  1426.     jchar CallStaticCharMethodA(jclass clazz,
  1427.                                 jmethodID methodID, jvalue *args) {
  1428.         return functions->CallStaticCharMethodA(this,clazz,methodID,args);
  1429.     }
  1430.  
  1431.     jshort CallStaticShortMethod(jclass clazz,
  1432.                                  jmethodID methodID, ...) {
  1433.         va_list args;
  1434.         jshort result;
  1435.         va_start(args,methodID);
  1436.         result = functions->CallStaticShortMethodV(this,clazz,methodID,args);
  1437.         va_end(args);
  1438.         return result;
  1439.     }
  1440.     jshort CallStaticShortMethodV(jclass clazz,
  1441.                                   jmethodID methodID, va_list args) {
  1442.         return functions->CallStaticShortMethodV(this,clazz,methodID,args);
  1443.     }
  1444.     jshort CallStaticShortMethodA(jclass clazz,
  1445.                                   jmethodID methodID, jvalue *args) {
  1446.         return functions->CallStaticShortMethodA(this,clazz,methodID,args);
  1447.     }
  1448.  
  1449.     jint CallStaticIntMethod(jclass clazz,
  1450.                              jmethodID methodID, ...) {
  1451.         va_list args;
  1452.         jint result;
  1453.         va_start(args,methodID);
  1454.         result = functions->CallStaticIntMethodV(this,clazz,methodID,args);
  1455.         va_end(args);
  1456.         return result;
  1457.     }
  1458.     jint CallStaticIntMethodV(jclass clazz,
  1459.                               jmethodID methodID, va_list args) {
  1460.         return functions->CallStaticIntMethodV(this,clazz,methodID,args);
  1461.     }
  1462.     jint CallStaticIntMethodA(jclass clazz,
  1463.                               jmethodID methodID, jvalue *args) {
  1464.         return functions->CallStaticIntMethodA(this,clazz,methodID,args);
  1465.     }
  1466.  
  1467.     jlong CallStaticLongMethod(jclass clazz,
  1468.                                jmethodID methodID, ...) {
  1469.         va_list args;
  1470.         jlong result;
  1471.         va_start(args,methodID);
  1472.         result = functions->CallStaticLongMethodV(this,clazz,methodID,args);
  1473.         va_end(args);
  1474.         return result;
  1475.     }
  1476.     jlong CallStaticLongMethodV(jclass clazz,
  1477.                                 jmethodID methodID, va_list args) {
  1478.         return functions->CallStaticLongMethodV(this,clazz,methodID,args);
  1479.     }
  1480.     jlong CallStaticLongMethodA(jclass clazz,
  1481.                                 jmethodID methodID, jvalue *args) {
  1482.         return functions->CallStaticLongMethodA(this,clazz,methodID,args);
  1483.     }
  1484.  
  1485.     jfloat CallStaticFloatMethod(jclass clazz,
  1486.                                  jmethodID methodID, ...) {
  1487.         va_list args;
  1488.         jfloat result;
  1489.         va_start(args,methodID);
  1490.         result = functions->CallStaticFloatMethodV(this,clazz,methodID,args);
  1491.         va_end(args);
  1492.         return result;
  1493.     }
  1494.     jfloat CallStaticFloatMethodV(jclass clazz,
  1495.                                   jmethodID methodID, va_list args) {
  1496.         return functions->CallStaticFloatMethodV(this,clazz,methodID,args);
  1497.     }
  1498.     jfloat CallStaticFloatMethodA(jclass clazz,
  1499.                                   jmethodID methodID, jvalue *args) {
  1500.         return functions->CallStaticFloatMethodA(this,clazz,methodID,args);
  1501.     }
  1502.  
  1503.     jdouble CallStaticDoubleMethod(jclass clazz,
  1504.                                    jmethodID methodID, ...) {
  1505.         va_list args;
  1506.         jdouble result;
  1507.         va_start(args,methodID);
  1508.         result = functions->CallStaticDoubleMethodV(this,clazz,methodID,args);
  1509.         va_end(args);
  1510.         return result;
  1511.     }
  1512.     jdouble CallStaticDoubleMethodV(jclass clazz,
  1513.                                     jmethodID methodID, va_list args) {
  1514.         return functions->CallStaticDoubleMethodV(this,clazz,methodID,args);
  1515.     }
  1516.     jdouble CallStaticDoubleMethodA(jclass clazz,
  1517.                                     jmethodID methodID, jvalue *args) {
  1518.         return functions->CallStaticDoubleMethodA(this,clazz,methodID,args);
  1519.     }
  1520.  
  1521.     void CallStaticVoidMethod(jclass cls, jmethodID methodID, ...) {
  1522.         va_list args;
  1523.         va_start(args,methodID);
  1524.         functions->CallStaticVoidMethodV(this,cls,methodID,args);
  1525.         va_end(args);
  1526.     }
  1527.     void CallStaticVoidMethodV(jclass cls, jmethodID methodID,
  1528.                                va_list args) {
  1529.         functions->CallStaticVoidMethodV(this,cls,methodID,args);
  1530.     }
  1531.     void CallStaticVoidMethodA(jclass cls, jmethodID methodID,
  1532.                                jvalue * args) {
  1533.         functions->CallStaticVoidMethodA(this,cls,methodID,args);
  1534.     }
  1535.  
  1536.     jfieldID GetStaticFieldID(jclass clazz, const char *name,
  1537.                               const char *sig) {
  1538.         return functions->GetStaticFieldID(this,clazz,name,sig);
  1539.     }
  1540.     jobject GetStaticObjectField(jclass clazz, jfieldID fieldID) {
  1541.         return functions->GetStaticObjectField(this,clazz,fieldID);
  1542.     }
  1543.     jboolean GetStaticBooleanField(jclass clazz, jfieldID fieldID) {
  1544.         return functions->GetStaticBooleanField(this,clazz,fieldID);
  1545.     }
  1546.     jbyte GetStaticByteField(jclass clazz, jfieldID fieldID) {
  1547.         return functions->GetStaticByteField(this,clazz,fieldID);
  1548.     }
  1549.     jchar GetStaticCharField(jclass clazz, jfieldID fieldID) {
  1550.         return functions->GetStaticCharField(this,clazz,fieldID);
  1551.     }
  1552.     jshort GetStaticShortField(jclass clazz, jfieldID fieldID) {
  1553.         return functions->GetStaticShortField(this,clazz,fieldID);
  1554.     }
  1555.     jint GetStaticIntField(jclass clazz, jfieldID fieldID) {
  1556.         return functions->GetStaticIntField(this,clazz,fieldID);
  1557.     }
  1558.     jlong GetStaticLongField(jclass clazz, jfieldID fieldID) {
  1559.         return functions->GetStaticLongField(this,clazz,fieldID);
  1560.     }
  1561.     jfloat GetStaticFloatField(jclass clazz, jfieldID fieldID) {
  1562.         return functions->GetStaticFloatField(this,clazz,fieldID);
  1563.     }
  1564.     jdouble GetStaticDoubleField(jclass clazz, jfieldID fieldID) {
  1565.         return functions->GetStaticDoubleField(this,clazz,fieldID);
  1566.     }
  1567.  
  1568.     void SetStaticObjectField(jclass clazz, jfieldID fieldID,
  1569.                         jobject value) {
  1570.       functions->SetStaticObjectField(this,clazz,fieldID,value);
  1571.     }
  1572.     void SetStaticBooleanField(jclass clazz, jfieldID fieldID,
  1573.                         jboolean value) {
  1574.       functions->SetStaticBooleanField(this,clazz,fieldID,value);
  1575.     }
  1576.     void SetStaticByteField(jclass clazz, jfieldID fieldID,
  1577.                         jbyte value) {
  1578.       functions->SetStaticByteField(this,clazz,fieldID,value);
  1579.     }
  1580.     void SetStaticCharField(jclass clazz, jfieldID fieldID,
  1581.                         jchar value) {
  1582.       functions->SetStaticCharField(this,clazz,fieldID,value);
  1583.     }
  1584.     void SetStaticShortField(jclass clazz, jfieldID fieldID,
  1585.                         jshort value) {
  1586.       functions->SetStaticShortField(this,clazz,fieldID,value);
  1587.     }
  1588.     void SetStaticIntField(jclass clazz, jfieldID fieldID,
  1589.                         jint value) {
  1590.       functions->SetStaticIntField(this,clazz,fieldID,value);
  1591.     }
  1592.     void SetStaticLongField(jclass clazz, jfieldID fieldID,
  1593.                         jlong value) {
  1594.       functions->SetStaticLongField(this,clazz,fieldID,value);
  1595.     }
  1596.     void SetStaticFloatField(jclass clazz, jfieldID fieldID,
  1597.                         jfloat value) {
  1598.       functions->SetStaticFloatField(this,clazz,fieldID,value);
  1599.     }
  1600.     void SetStaticDoubleField(jclass clazz, jfieldID fieldID,
  1601.                         jdouble value) {
  1602.       functions->SetStaticDoubleField(this,clazz,fieldID,value);
  1603.     }
  1604.  
  1605.     jstring NewString(const jchar *unicode, jsize len) {
  1606.         return functions->NewString(this,unicode,len);
  1607.     }
  1608.     jsize GetStringLength(jstring str) {
  1609.         return functions->GetStringLength(this,str);
  1610.     }
  1611.     const jchar *GetStringChars(jstring str, jboolean *isCopy) {
  1612.         return functions->GetStringChars(this,str,isCopy);
  1613.     }
  1614.     void ReleaseStringChars(jstring str, const jchar *chars) {
  1615.         functions->ReleaseStringChars(this,str,chars);
  1616.     }
  1617.  
  1618.     jstring NewStringUTF(const char *utf) {
  1619.         return functions->NewStringUTF(this,utf);
  1620.     }
  1621.     jsize GetStringUTFLength(jstring str) {
  1622.         return functions->GetStringUTFLength(this,str);
  1623.     }
  1624.     const char* GetStringUTFChars(jstring str, jboolean *isCopy) {
  1625.         return functions->GetStringUTFChars(this,str,isCopy);
  1626.     }
  1627.     void ReleaseStringUTFChars(jstring str, const char* chars) {
  1628.         functions->ReleaseStringUTFChars(this,str,chars);
  1629.     }
  1630.  
  1631.     jsize GetArrayLength(jarray array) {
  1632.         return functions->GetArrayLength(this,array);
  1633.     }
  1634.  
  1635.     jobjectArray NewObjectArray(jsize len, jclass clazz,
  1636.                                 jobject init) {
  1637.         return functions->NewObjectArray(this,len,clazz,init);
  1638.     }
  1639.     jobject GetObjectArrayElement(jobjectArray array, jsize index) {
  1640.         return functions->GetObjectArrayElement(this,array,index);
  1641.     }
  1642.     void SetObjectArrayElement(jobjectArray array, jsize index,
  1643.                                jobject val) {
  1644.         functions->SetObjectArrayElement(this,array,index,val);
  1645.     }
  1646.  
  1647.     jbooleanArray NewBooleanArray(jsize len) {
  1648.         return functions->NewBooleanArray(this,len);
  1649.     }
  1650.     jbyteArray NewByteArray(jsize len) {
  1651.         return functions->NewByteArray(this,len);
  1652.     }
  1653.     jcharArray NewCharArray(jsize len) {
  1654.         return functions->NewCharArray(this,len);
  1655.     }
  1656.     jshortArray NewShortArray(jsize len) {
  1657.         return functions->NewShortArray(this,len);
  1658.     }
  1659.     jintArray NewIntArray(jsize len) {
  1660.         return functions->NewIntArray(this,len);
  1661.     }
  1662.     jlongArray NewLongArray(jsize len) {
  1663.         return functions->NewLongArray(this,len);
  1664.     }
  1665.     jfloatArray NewFloatArray(jsize len) {
  1666.         return functions->NewFloatArray(this,len);
  1667.     }
  1668.     jdoubleArray NewDoubleArray(jsize len) {
  1669.         return functions->NewDoubleArray(this,len);
  1670.     }
  1671.  
  1672.     jboolean * GetBooleanArrayElements(jbooleanArray array, jboolean *isCopy) {
  1673.         return functions->GetBooleanArrayElements(this,array,isCopy);
  1674.     }
  1675.     jbyte * GetByteArrayElements(jbyteArray array, jboolean *isCopy) {
  1676.         return functions->GetByteArrayElements(this,array,isCopy);
  1677.     }
  1678.     jchar * GetCharArrayElements(jcharArray array, jboolean *isCopy) {
  1679.         return functions->GetCharArrayElements(this,array,isCopy);
  1680.     }
  1681.     jshort * GetShortArrayElements(jshortArray array, jboolean *isCopy) {
  1682.         return functions->GetShortArrayElements(this,array,isCopy);
  1683.     }
  1684.     jint * GetIntArrayElements(jintArray array, jboolean *isCopy) {
  1685.         return functions->GetIntArrayElements(this,array,isCopy);
  1686.     }
  1687.     jlong * GetLongArrayElements(jlongArray array, jboolean *isCopy) {
  1688.         return functions->GetLongArrayElements(this,array,isCopy);
  1689.     }
  1690.     jfloat * GetFloatArrayElements(jfloatArray array, jboolean *isCopy) {
  1691.         return functions->GetFloatArrayElements(this,array,isCopy);
  1692.     }
  1693.     jdouble * GetDoubleArrayElements(jdoubleArray array, jboolean *isCopy) {
  1694.         return functions->GetDoubleArrayElements(this,array,isCopy);
  1695.     }
  1696.  
  1697.     void ReleaseBooleanArrayElements(jbooleanArray array,
  1698.                                      jboolean *elems,
  1699.                                      jint mode) {
  1700.         functions->ReleaseBooleanArrayElements(this,array,elems,mode);
  1701.     }
  1702.     void ReleaseByteArrayElements(jbyteArray array,
  1703.                                   jbyte *elems,
  1704.                                   jint mode) {
  1705.         functions->ReleaseByteArrayElements(this,array,elems,mode);
  1706.     }
  1707.     void ReleaseCharArrayElements(jcharArray array,
  1708.                                   jchar *elems,
  1709.                                   jint mode) {
  1710.         functions->ReleaseCharArrayElements(this,array,elems,mode);
  1711.     }
  1712.     void ReleaseShortArrayElements(jshortArray array,
  1713.                                    jshort *elems,
  1714.                                    jint mode) {
  1715.         functions->ReleaseShortArrayElements(this,array,elems,mode);
  1716.     }
  1717.     void ReleaseIntArrayElements(jintArray array,
  1718.                                  jint *elems,
  1719.                                  jint mode) {
  1720.         functions->ReleaseIntArrayElements(this,array,elems,mode);
  1721.     }
  1722.     void ReleaseLongArrayElements(jlongArray array,
  1723.                                   jlong *elems,
  1724.                                   jint mode) {
  1725.         functions->ReleaseLongArrayElements(this,array,elems,mode);
  1726.     }
  1727.     void ReleaseFloatArrayElements(jfloatArray array,
  1728.                                    jfloat *elems,
  1729.                                    jint mode) {
  1730.         functions->ReleaseFloatArrayElements(this,array,elems,mode);
  1731.     }
  1732.     void ReleaseDoubleArrayElements(jdoubleArray array,
  1733.                                     jdouble *elems,
  1734.                                     jint mode) {
  1735.         functions->ReleaseDoubleArrayElements(this,array,elems,mode);
  1736.     }
  1737.  
  1738.     void GetBooleanArrayRegion(jbooleanArray array,
  1739.                                jsize start, jsize len, jboolean *buf) {
  1740.         functions->GetBooleanArrayRegion(this,array,start,len,buf);
  1741.     }
  1742.     void GetByteArrayRegion(jbyteArray array,
  1743.                             jsize start, jsize len, jbyte *buf) {
  1744.         functions->GetByteArrayRegion(this,array,start,len,buf);
  1745.     }
  1746.     void GetCharArrayRegion(jcharArray array,
  1747.                             jsize start, jsize len, jchar *buf) {
  1748.         functions->GetCharArrayRegion(this,array,start,len,buf);
  1749.     }
  1750.     void GetShortArrayRegion(jshortArray array,
  1751.                              jsize start, jsize len, jshort *buf) {
  1752.         functions->GetShortArrayRegion(this,array,start,len,buf);
  1753.     }
  1754.     void GetIntArrayRegion(jintArray array,
  1755.                            jsize start, jsize len, jint *buf) {
  1756.         functions->GetIntArrayRegion(this,array,start,len,buf);
  1757.     }
  1758.     void GetLongArrayRegion(jlongArray array,
  1759.                             jsize start, jsize len, jlong *buf) {
  1760.         functions->GetLongArrayRegion(this,array,start,len,buf);
  1761.     }
  1762.     void GetFloatArrayRegion(jfloatArray array,
  1763.                              jsize start, jsize len, jfloat *buf) {
  1764.         functions->GetFloatArrayRegion(this,array,start,len,buf);
  1765.     }
  1766.     void GetDoubleArrayRegion(jdoubleArray array,
  1767.                               jsize start, jsize len, jdouble *buf) {
  1768.         functions->GetDoubleArrayRegion(this,array,start,len,buf);
  1769.     }
  1770.  
  1771.     void SetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len,
  1772.                                jboolean *buf) {
  1773.         functions->SetBooleanArrayRegion(this,array,start,len,buf);
  1774.     }
  1775.     void SetByteArrayRegion(jbyteArray array, jsize start, jsize len,
  1776.                             jbyte *buf) {
  1777.         functions->SetByteArrayRegion(this,array,start,len,buf);
  1778.     }
  1779.     void SetCharArrayRegion(jcharArray array, jsize start, jsize len,
  1780.                             jchar *buf) {
  1781.         functions->SetCharArrayRegion(this,array,start,len,buf);
  1782.     }
  1783.     void SetShortArrayRegion(jshortArray array, jsize start, jsize len,
  1784.                              jshort *buf) {
  1785.         functions->SetShortArrayRegion(this,array,start,len,buf);
  1786.     }
  1787.     void SetIntArrayRegion(jintArray array, jsize start, jsize len,
  1788.                            jint *buf) {
  1789.         functions->SetIntArrayRegion(this,array,start,len,buf);
  1790.     }
  1791.     void SetLongArrayRegion(jlongArray array, jsize start, jsize len,
  1792.                             jlong *buf) {
  1793.         functions->SetLongArrayRegion(this,array,start,len,buf);
  1794.     }
  1795.     void SetFloatArrayRegion(jfloatArray array, jsize start, jsize len,
  1796.                              jfloat *buf) {
  1797.         functions->SetFloatArrayRegion(this,array,start,len,buf);
  1798.     }
  1799.     void SetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len,
  1800.                               jdouble *buf) {
  1801.         functions->SetDoubleArrayRegion(this,array,start,len,buf);
  1802.     }
  1803.  
  1804.     jint RegisterNatives(jclass clazz, const JNINativeMethod *methods,
  1805.                          jint nMethods) {
  1806.         return functions->RegisterNatives(this,clazz,methods,nMethods);
  1807.     }
  1808.     jint UnregisterNatives(jclass clazz) {
  1809.         return functions->UnregisterNatives(this,clazz);
  1810.     }
  1811.  
  1812.     jint MonitorEnter(jobject obj) {
  1813.         return functions->MonitorEnter(this,obj);
  1814.     }
  1815.     jint MonitorExit(jobject obj) {
  1816.         return functions->MonitorExit(this,obj);
  1817.     }
  1818.  
  1819.     jint GetJavaVM(JavaVM **vm) {
  1820.         return functions->GetJavaVM(this,vm);
  1821.     }
  1822.  
  1823.     void GetStringRegion(jstring str, jsize start, jsize len, jchar *buf) {
  1824.         functions->GetStringRegion(this,str,start,len,buf);
  1825.     }
  1826.     void GetStringUTFRegion(jstring str, jsize start, jsize len, char *buf) {
  1827.         functions->GetStringUTFRegion(this,str,start,len,buf);
  1828.     }
  1829.  
  1830.     void * GetPrimitiveArrayCritical(jarray array, jboolean *isCopy) {
  1831.         return functions->GetPrimitiveArrayCritical(this,array,isCopy);
  1832.     }
  1833.     void ReleasePrimitiveArrayCritical(jarray array, void *carray, jint mode) {
  1834.         functions->ReleasePrimitiveArrayCritical(this,array,carray,mode);
  1835.     }
  1836.  
  1837.     const jchar * GetStringCritical(jstring string, jboolean *isCopy) {
  1838.         return functions->GetStringCritical(this,string,isCopy);
  1839.     }
  1840.     void ReleaseStringCritical(jstring string, const jchar *cstring) {
  1841.         functions->ReleaseStringCritical(this,string,cstring);
  1842.     }
  1843.  
  1844.     jweak NewWeakGlobalRef(jobject obj) {
  1845.         return functions->NewWeakGlobalRef(this,obj);
  1846.     }
  1847.     void DeleteWeakGlobalRef(jweak ref) {
  1848.         functions->DeleteWeakGlobalRef(this,ref);
  1849.     }
  1850.  
  1851.     jboolean ExceptionCheck() {
  1852.         return functions->ExceptionCheck(this);
  1853.     }
  1854.  
  1855. #endif /* __cplusplus */
  1856. };
  1857.  
  1858. typedef struct JavaVMOption {
  1859.     char *optionString;
  1860.     void *extraInfo;
  1861. } JavaVMOption;
  1862.  
  1863. /*ibm@24452*/
  1864. typedef struct JavaVMQuery {
  1865.     jint name;
  1866.     jvalue value;
  1867. } JavaVMQuery;
  1868.  
  1869. typedef struct JavaVMInitArgs {
  1870.     jint version;
  1871.  
  1872.     jint nOptions;
  1873.     JavaVMOption *options;
  1874.     jboolean ignoreUnrecognized;
  1875. } JavaVMInitArgs;
  1876.  
  1877. typedef struct JavaVMAttachArgs {
  1878.     jint version;
  1879.  
  1880.     char *name;
  1881.     jobject group;
  1882. } JavaVMAttachArgs;
  1883.  
  1884. /* These structures will be VM-specific. */
  1885.  
  1886. typedef struct JDK1_1InitArgs {
  1887.     jint version;
  1888.  
  1889.     char **properties;
  1890.     jint checkSource;
  1891.     jint nativeStackSize;
  1892.     jint javaStackSize;
  1893.     jint minHeapSize;
  1894.     jint maxHeapSize;
  1895.     jint verifyMode;
  1896.     char *classpath;
  1897.  
  1898.     jint (JNICALL *vfprintf)(FILE *fp, const char *format, va_list args);
  1899.     void (JNICALL *exit)(jint code);
  1900.     void (JNICALL *abort)(void);
  1901.  
  1902.     jint enableClassGC;
  1903.     jint enableVerboseGC;
  1904.     jint disableAsyncGC;
  1905.     jint verbose;
  1906.     jboolean debugging;
  1907.     jint debugPort;
  1908. } JDK1_1InitArgs;
  1909.  
  1910. typedef struct JDK1_1AttachArgs {
  1911.     void * __padding; /* C compilers don't allow empty structures. */
  1912. } JDK1_1AttachArgs;
  1913.  
  1914. #define JDK1_2
  1915.  
  1916. /* End VM-specific. */
  1917.  
  1918. struct JNIInvokeInterface_ {
  1919.     void *reserved0;
  1920.     void *reserved1;
  1921.     void *reserved2;
  1922.  
  1923.     jint (JNICALL *DestroyJavaVM)(JavaVM *vm);
  1924.  
  1925.     jint (JNICALL *AttachCurrentThread)(JavaVM *vm, void **penv, void *args);
  1926.  
  1927.     jint (JNICALL *DetachCurrentThread)(JavaVM *vm);
  1928.  
  1929.     jint (JNICALL *GetEnv)(JavaVM *vm, void **penv, jint version);
  1930.  
  1931.     jint (JNICALL *ResetJavaVM)(JavaVM *vm);                        /*ibm@5596*/
  1932.     jint (JNICALL *QueryJavaVM)
  1933.         (JavaVM *vm, jint nQueries, JavaVMQuery *qeries);          /*ibm@24452*/
  1934.  
  1935.     jint (JNICALL *QueryGCStatus)
  1936.         (JavaVM *vm, jint *nheaps, GCStatus *status, jint statusSize);  /*ibm@27744*/
  1937. };
  1938.  
  1939. struct JavaVM_ {
  1940.     const struct JNIInvokeInterface_ *functions;
  1941. #ifdef __cplusplus
  1942.  
  1943.     jint DestroyJavaVM() {
  1944.         return functions->DestroyJavaVM(this);
  1945.     }
  1946.     jint AttachCurrentThread(void **penv, void *args) {
  1947.         return functions->AttachCurrentThread(this, penv, args);
  1948.     }
  1949.     jint DetachCurrentThread() {
  1950.         return functions->DetachCurrentThread(this);
  1951.     }
  1952.  
  1953.     jint GetEnv(void **penv, jint version) {
  1954.         return functions->GetEnv(this, penv, version);
  1955.     }
  1956.  
  1957.     jint ResetJavaVM(){                                             /*ibm@5596*/
  1958.         return functions->ResetJavaVM(this);
  1959.     }
  1960.  
  1961.     jint QueryJavaVM(jint nQueries, JavaVMQuery *queries) {        /*ibm@24452*/
  1962.         return functions->QueryJavaVM(this, nQueries, queries);
  1963.     }
  1964.  
  1965.     jint QueryGCStatus(jint *nheaps, GCStatus *status, jint statusSize){    /*ibm@27744*/
  1966.         return functions->QueryGCStatus(this, nheaps, status, statusSize);  /*ibm@27744*/
  1967.     }                                                                       /*ibm@27744*/
  1968. #endif
  1969. };
  1970.  
  1971. #ifdef _JNI_IMPLEMENTATION_
  1972. #define _JNI_IMPORT_OR_EXPORT_ JNIEXPORT_PROTOTYPE                    /*ibm.54*/
  1973. #else
  1974. #define _JNI_IMPORT_OR_EXPORT_ JNIIMPORT
  1975. #endif
  1976. _JNI_IMPORT_OR_EXPORT_ jint JNICALL
  1977. JNI_GetDefaultJavaVMInitArgs(void *args);
  1978.  
  1979. _JNI_IMPORT_OR_EXPORT_ jint JNICALL
  1980. JNI_CreateJavaVM(JavaVM **pvm, void **penv, void *args);
  1981.  
  1982. _JNI_IMPORT_OR_EXPORT_ jint JNICALL
  1983. JNI_GetCreatedJavaVMs(JavaVM **, jsize, jsize *);
  1984.  
  1985. /* Defined by native libraries. */
  1986. JNIEXPORT_PROTOTYPE jint JNICALL                                      /*ibm.54*/
  1987. JNI_OnLoad(JavaVM *vm, void *reserved);
  1988.  
  1989. JNIEXPORT_PROTOTYPE void JNICALL                                      /*ibm.54*/
  1990. JNI_OnUnload(JavaVM *vm, void *reserved);
  1991.  
  1992. #define JNI_VERSION_1_1 0x00010001
  1993. #define JNI_VERSION_1_2 0x00010002
  1994.  
  1995. #ifdef __cplusplus
  1996. } /* extern "C" */
  1997. #endif /* __cplusplus */
  1998.  
  1999. #endif /* !_JAVASOFT_JNI_H_ */
  2000.  
  2001.  
  2002.