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