Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

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