apps/nsplugins/sdk/jni.h

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