applications/JavaOpenJPEG/java-jni/include/jni.h

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