emulators/emulator-base/src/main/headers/jni/jni.h

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