开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > PlugIns编程 > 查看源码
jni.h
资源名称：XPCOMPluginDemo.zip　[点击查看]
上传用户：goldcmy89
上传日期：2017-12-03
资源大小：2246k
文件大小：62k
源码类别：

PlugIns编程

开发平台：

Visual C++

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