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