libjava/include/jni.h

   1 /* jni.h
   2    Copyright (C) 1998, 1999, 2000, 2001, 2002, 2004, 2005  Free Software Foundation
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 /* Note: this file must be compilable by the C compiler (for now,
  40    assuming GNU C is ok).  This means you must never use `//'
  41    comments, and all C++-specific code must be conditional on
  42    __cplusplus.  */
  43
  44 #ifndef _CLASSPATH_JNI_H
  45 #define _CLASSPATH_JNI_H
  46
  47 /* We include <stdio.h> for compatibility with Sun's <jni.h>.  */
  48 #include <stdio.h>
  49
  50 #include <stdarg.h>
  51
  52 #include "jni_md.h"
  53
  54 /* The VM might define jobject and friends.  */
  55 #ifndef _CLASSPATH_VM_JNI_TYPES_DEFINED
  56
  57 # ifdef __cplusplus
  58
  59 /* Define dummy classes and then define the JNI types as pointers.  */
  60 struct __jobject {};
  61 struct __jclass : __jobject {};
  62 struct __jstring : __jobject {};
  63 struct __jthrowable : __jobject {};
  64 struct __jweak : __jobject {};
  65 struct __jarray : __jobject {};
  66 struct __jobjectArray : __jarray {};
  67 struct __jbyteArray : __jarray {};
  68 struct __jshortArray : __jarray {};
  69 struct __jintArray : __jarray {};
  70 struct __jlongArray : __jarray {};
  71 struct __jbooleanArray : __jarray {};
  72 struct __jcharArray : __jarray {};
  73 struct __jfloatArray : __jarray {};
  74 struct __jdoubleArray : __jarray {};
  75
  76 typedef __jobject *jobject;
  77 typedef __jclass *jclass;
  78 typedef __jstring *jstring;
  79 typedef __jthrowable *jthrowable;
  80 typedef __jweak *jweak;
  81 typedef __jarray *jarray;
  82 typedef __jobjectArray *jobjectArray;
  83 typedef __jbyteArray *jbyteArray;
  84 typedef __jshortArray *jshortArray;
  85 typedef __jintArray *jintArray;
  86 typedef __jlongArray *jlongArray;
  87 typedef __jbooleanArray *jbooleanArray;
  88 typedef __jcharArray *jcharArray;
  89 typedef __jfloatArray *jfloatArray;
  90 typedef __jdoubleArray *jdoubleArray;
  91
  92 #define JNI_TRUE true
  93 #define JNI_FALSE false
  94
  95 typedef struct _Jv_JNIEnv JNIEnv;
  96 typedef struct _Jv_JavaVM JavaVM;
  97
  98 # else /* __cplusplus */
  99
 100 /* For C, simply define the class types as generic pointers.  */
 101 typedef void *jobject;
 102 typedef jobject jclass;
 103 typedef jobject jstring;
 104 typedef jobject jthrowable;
 105 typedef jobject jweak;
 106 typedef jobject jarray;
 107 typedef jobject jobjectArray;
 108 typedef jobject jbyteArray;
 109 typedef jobject jshortArray;
 110 typedef jobject jintArray;
 111 typedef jobject jlongArray;
 112 typedef jobject jbooleanArray;
 113 typedef jobject jcharArray;
 114 typedef jobject jfloatArray;
 115 typedef jobject jdoubleArray;
 116
 117 #define JNI_TRUE  1
 118 #define JNI_FALSE 0
 119
 120 typedef const struct JNINativeInterface *JNIEnv;
 121 typedef const struct JNIInvokeInterface *JavaVM;
 122
 123 # endif /* __cplusplus */
 124
 125 #endif /* _CLASSPATH_VM_JNI_TYPES_DEFINED */
 126
 127 /*
 128  * Before jni.h is #included within a typical JVM, the source code should
 129  * #define _JNI_VM_INTERNAL_TYPES_DEFINED and provide the real declarations
 130  * for 'jobject', 'jfieldID', 'jmethodID' and other implementation types.
 131  * If _JNI_VM_INTERNAL_TYPES_DEFINED is not defined, the following
 132  * declares the old versions of the types.
 133  */
 134 #ifndef _CLASSPATH_VM_INTERNAL_TYPES_DEFINED
 135 struct _jfieldID;
 136 struct _jmethodID;
 137 typedef struct _jfieldID *jfieldID;
 138 typedef struct _jmethodID *jmethodID;
 139 #endif
 140
 141 /* Version numbers.  */
 142 #define JNI_VERSION_1_1 0x00010001
 143 #define JNI_VERSION_1_2 0x00010002
 144 #define JNI_VERSION_1_4 0x00010004
 145
 146 /* Used when releasing array elements.  */
 147 #define JNI_COMMIT 1
 148 #define JNI_ABORT  2
 149
 150 /* Error codes */
 151 #define JNI_OK            0
 152 #define JNI_ERR          (-1)
 153 #define JNI_EDETACHED    (-2)
 154 #define JNI_EVERSION     (-3)
 155
 156
 157 #ifdef __cplusplus
 158 extern "C"
 159 {
 160 #endif /* __cplusplus */
 161
 162 /* These functions might be defined in libraries which we load; the
 163    JNI implementation calls them at the appropriate times.  */
 164 extern JNIEXPORT jint JNICALL JNI_OnLoad (JavaVM *, void *);
 165 extern JNIEXPORT void JNICALL JNI_OnUnload (JavaVM *, void *);
 166
 167 /* This can be defined as JNIIMPORT or JNIEXPORT by the md file,
 168    depending on whether this is the implementation or a user.  */
 169 #ifndef _CLASSPATH_JNIIMPEXP
 170 #define _CLASSPATH_JNIIMPEXP JNIIMPORT
 171 #endif
 172
 173 /* These functions are called by user code to start using the
 174    invocation API.  */
 175 extern _CLASSPATH_JNIIMPEXP jint JNICALL
 176 JNI_GetDefaultJavaVMInitArgs (void *);
 177
 178 extern _CLASSPATH_JNIIMPEXP jint JNICALL
 179 JNI_CreateJavaVM (JavaVM **, void **, void *);
 180
 181 extern _CLASSPATH_JNIIMPEXP jint JNICALL
 182 JNI_GetCreatedJavaVMs (JavaVM **, jsize, jsize *);
 183
 184 #ifdef __cplusplus
 185 }
 186 #endif /* __cplusplus */
 187
 188 typedef union jvalue
 189 {
 190   jboolean z;
 191   jbyte    b;
 192   jchar    c;
 193   jshort   s;
 194   jint     i;
 195   jlong    j;
 196   jfloat   f;
 197   jdouble  d;
 198   jobject  l;
 199 } jvalue;
 200
 201 /* This structure is used when registering native methods.  */
 202 typedef struct
 203 {
 204   char *name;
 205   char *signature;
 206   void *fnPtr;                  /* Sigh.  */
 207 } JNINativeMethod;
 208
 209 struct JNINativeInterface
 210 {
 211   void *reserved0;
 212   void *reserved1;
 213   void *reserved2;
 214   void *reserved3;
 215
 216   jint     (JNICALL *GetVersion)                   (JNIEnv *);
 217   jclass   (JNICALL *DefineClass)                  (JNIEnv *, const char *,
 218                                                     jobject, const jbyte *,
 219                                                     jsize);
 220   jclass   (JNICALL *FindClass)                    (JNIEnv *, const char *);
 221
 222   jmethodID (JNICALL *FromReflectedMethod)         (JNIEnv *, jobject);
 223   jfieldID  (JNICALL *FromReflectedField)          (JNIEnv *, jobject);
 224   jobject   (JNICALL *ToReflectedMethod)           (JNIEnv *, jclass,
 225                                                     jmethodID, jboolean);
 226
 227   jclass   (JNICALL *GetSuperclass)                (JNIEnv *, jclass);
 228   jboolean (JNICALL *IsAssignableFrom)             (JNIEnv *, jclass, jclass);
 229
 230   jobject  (JNICALL *ToReflectedField)             (JNIEnv *, jclass, jfieldID,
 231                                                     jboolean);
 232
 233   jint     (JNICALL *Throw)                        (JNIEnv *, jthrowable);
 234   jint     (JNICALL *ThrowNew)                     (JNIEnv *, jclass,
 235                                                     const char *);
 236   jthrowable (JNICALL *ExceptionOccurred)          (JNIEnv *);
 237   void     (JNICALL *ExceptionDescribe)            (JNIEnv *);
 238   void     (JNICALL *ExceptionClear)               (JNIEnv *);
 239   void     (JNICALL *FatalError)                   (JNIEnv *, const char *);
 240
 241   jint     (JNICALL *PushLocalFrame)               (JNIEnv *, jint);
 242   jobject  (JNICALL *PopLocalFrame)                (JNIEnv *, jobject);
 243
 244   jobject  (JNICALL *NewGlobalRef)                 (JNIEnv *, jobject);
 245   void     (JNICALL *DeleteGlobalRef)              (JNIEnv *, jobject);
 246   void     (JNICALL *DeleteLocalRef)               (JNIEnv *, jobject);
 247   jboolean (JNICALL *IsSameObject)                 (JNIEnv *, jobject,
 248                                                     jobject);
 249
 250   jobject  (JNICALL *NewLocalRef)                  (JNIEnv *, jobject);
 251   jint     (JNICALL *EnsureLocalCapacity)          (JNIEnv *, jint);
 252
 253   jobject  (JNICALL *AllocObject)                  (JNIEnv *, jclass);
 254   jobject (JNICALL *NewObject)                     (JNIEnv *, jclass,
 255                                                     jmethodID, ...);
 256   jobject (JNICALL *NewObjectV)                    (JNIEnv *, jclass,
 257                                                     jmethodID, va_list);
 258   jobject (JNICALL *NewObjectA)                    (JNIEnv *, jclass,
 259                                                     jmethodID, jvalue *);
 260
 261   jclass   (JNICALL *GetObjectClass)               (JNIEnv *, jobject);
 262   jboolean (JNICALL *IsInstanceOf)                 (JNIEnv *, jobject, jclass);
 263   jmethodID (JNICALL *GetMethodID)                 (JNIEnv *, jclass,
 264                                                     const char *, const char *);
 265
 266   jobject (JNICALL *CallObjectMethod)      (JNIEnv *, jobject, jmethodID, ...);
 267   jobject (JNICALL *CallObjectMethodV)     (JNIEnv *, jobject, jmethodID,
 268                                             va_list);
 269   jobject (JNICALL *CallObjectMethodA)     (JNIEnv *, jobject, jmethodID,
 270                                             jvalue *);
 271   jboolean (JNICALL *CallBooleanMethod)    (JNIEnv *, jobject, jmethodID,
 272                                             ...);
 273   jboolean (JNICALL *CallBooleanMethodV)   (JNIEnv *, jobject, jmethodID,
 274                                             va_list);
 275   jboolean (JNICALL *CallBooleanMethodA)   (JNIEnv *, jobject, jmethodID,
 276                                             jvalue *);
 277   jbyte (JNICALL *CallByteMethod)   (JNIEnv *, jobject, jmethodID, ...);
 278   jbyte (JNICALL *CallByteMethodV)         (JNIEnv *, jobject, jmethodID,
 279                                             va_list);
 280   jbyte (JNICALL *CallByteMethodA)         (JNIEnv *, jobject, jmethodID,
 281                                             jvalue *);
 282   jchar (JNICALL *CallCharMethod)          (JNIEnv *, jobject, jmethodID, ...);
 283   jchar (JNICALL *CallCharMethodV)         (JNIEnv *, jobject, jmethodID,
 284                                             va_list);
 285   jchar (JNICALL *CallCharMethodA)         (JNIEnv *, jobject, jmethodID,
 286                                             jvalue *);
 287   jshort (JNICALL *CallShortMethod)        (JNIEnv *, jobject, jmethodID, ...);
 288   jshort (JNICALL *CallShortMethodV)       (JNIEnv *, jobject, jmethodID,
 289                                             va_list);
 290   jshort (JNICALL *CallShortMethodA)       (JNIEnv *, jobject, jmethodID,
 291                                             jvalue *);
 292   jint  (JNICALL *CallIntMethod)           (JNIEnv *, jobject, jmethodID, ...);
 293   jint  (JNICALL *CallIntMethodV)          (JNIEnv *, jobject, jmethodID,
 294                                             va_list);
 295   jint  (JNICALL *CallIntMethodA)          (JNIEnv *, jobject, jmethodID,
 296                                             jvalue *);
 297   jlong (JNICALL *CallLongMethod)          (JNIEnv *, jobject, jmethodID, ...);
 298   jlong (JNICALL *CallLongMethodV)         (JNIEnv *, jobject, jmethodID,
 299                                             va_list);
 300   jlong (JNICALL *CallLongMethodA)         (JNIEnv *, jobject, jmethodID,
 301                                             jvalue *);
 302   jfloat (JNICALL *CallFloatMethod)        (JNIEnv *, jobject, jmethodID, ...);
 303   jfloat (JNICALL *CallFloatMethodV)       (JNIEnv *, jobject, jmethodID,
 304                                             va_list);
 305   jfloat (JNICALL *CallFloatMethodA)       (JNIEnv *, jobject, jmethodID,
 306                                             jvalue *);
 307   jdouble (JNICALL *CallDoubleMethod)      (JNIEnv *, jobject, jmethodID, ...);
 308   jdouble (JNICALL *CallDoubleMethodV)     (JNIEnv *, jobject, jmethodID,
 309                                             va_list);
 310   jdouble (JNICALL *CallDoubleMethodA)     (JNIEnv *, jobject, jmethodID,
 311                                             jvalue *);
 312   void  (JNICALL *CallVoidMethod)          (JNIEnv *, jobject, jmethodID, ...);
 313   void  (JNICALL *CallVoidMethodV)         (JNIEnv *, jobject, jmethodID,
 314                                             va_list);
 315   void  (JNICALL *CallVoidMethodA)         (JNIEnv *, jobject, jmethodID,
 316                                             jvalue *);
 317
 318   jobject   (JNICALL *CallNonvirtualObjectMethod)  (JNIEnv *, jobject, jclass,
 319                                                     jmethodID, ...);
 320   jobject   (JNICALL *CallNonvirtualObjectMethodV) (JNIEnv *, jobject, jclass,
 321                                                     jmethodID, va_list);
 322   jobject   (JNICALL *CallNonvirtualObjectMethodA) (JNIEnv *, jobject, jclass,
 323                                                     jmethodID, jvalue *);
 324   jboolean  (JNICALL *CallNonvirtualBooleanMethod) (JNIEnv *, jobject, jclass,
 325                                                     jmethodID, ...);
 326   jboolean  (JNICALL *CallNonvirtualBooleanMethodV) (JNIEnv *, jobject, jclass,
 327                                                      jmethodID, va_list);
 328   jboolean  (JNICALL *CallNonvirtualBooleanMethodA) (JNIEnv *, jobject, jclass,
 329                                                      jmethodID, jvalue *);
 330   jbyte     (JNICALL *CallNonvirtualByteMethod)    (JNIEnv *, jobject, jclass,
 331                                                     jmethodID, ...);
 332   jbyte     (JNICALL *CallNonvirtualByteMethodV)   (JNIEnv *, jobject, jclass,
 333                                                     jmethodID, va_list);
 334   jbyte     (JNICALL *CallNonvirtualByteMethodA)   (JNIEnv *, jobject, jclass,
 335                                                     jmethodID, jvalue *);
 336   jchar     (JNICALL *CallNonvirtualCharMethod)    (JNIEnv *, jobject, jclass,
 337                                                     jmethodID, ...);
 338   jchar     (JNICALL *CallNonvirtualCharMethodV)   (JNIEnv *, jobject, jclass,
 339                                                     jmethodID, va_list);
 340   jchar     (JNICALL *CallNonvirtualCharMethodA)   (JNIEnv *, jobject, jclass,
 341                                                     jmethodID, jvalue *);
 342   jshort    (JNICALL *CallNonvirtualShortMethod)   (JNIEnv *, jobject, jclass,
 343                                                     jmethodID, ...);
 344   jshort    (JNICALL *CallNonvirtualShortMethodV)  (JNIEnv *, jobject, jclass,
 345                                                     jmethodID, va_list);
 346   jshort    (JNICALL *CallNonvirtualShortMethodA)  (JNIEnv *, jobject, jclass,
 347                                                     jmethodID, jvalue *);
 348   jint      (JNICALL *CallNonvirtualIntMethod)     (JNIEnv *, jobject, jclass,
 349                                                     jmethodID, ...);
 350   jint      (JNICALL *CallNonvirtualIntMethodV)    (JNIEnv *, jobject, jclass,
 351                                                     jmethodID, va_list);
 352   jint      (JNICALL *CallNonvirtualIntMethodA)    (JNIEnv *, jobject, jclass,
 353                                                     jmethodID, jvalue *);
 354   jlong     (JNICALL *CallNonvirtualLongMethod)    (JNIEnv *, jobject, jclass,
 355                                                     jmethodID, ...);
 356   jlong     (JNICALL *CallNonvirtualLongMethodV)   (JNIEnv *, jobject, jclass,
 357                                                     jmethodID, va_list);
 358   jlong     (JNICALL *CallNonvirtualLongMethodA)   (JNIEnv *, jobject, jclass,
 359                                                     jmethodID, jvalue *);
 360   jfloat    (JNICALL *CallNonvirtualFloatMethod)   (JNIEnv *, jobject, jclass,
 361                                                     jmethodID, ...);
 362   jfloat    (JNICALL *CallNonvirtualFloatMethodV)  (JNIEnv *, jobject, jclass,
 363                                                     jmethodID, va_list);
 364   jfloat    (JNICALL *CallNonvirtualFloatMethodA)  (JNIEnv *, jobject, jclass,
 365                                                     jmethodID, jvalue *);
 366   jdouble   (JNICALL *CallNonvirtualDoubleMethod)  (JNIEnv *, jobject, jclass,
 367                                                     jmethodID, ...);
 368   jdouble   (JNICALL *CallNonvirtualDoubleMethodV) (JNIEnv *, jobject, jclass,
 369                                                     jmethodID, va_list);
 370   jdouble   (JNICALL *CallNonvirtualDoubleMethodA) (JNIEnv *, jobject, jclass,
 371                                                     jmethodID, jvalue *);
 372   void      (JNICALL *CallNonvirtualVoidMethod)    (JNIEnv *, jobject, jclass,
 373                                                     jmethodID, ...);
 374   void      (JNICALL *CallNonvirtualVoidMethodV)   (JNIEnv *, jobject, jclass,
 375                                                     jmethodID, va_list);
 376   void      (JNICALL *CallNonvirtualVoidMethodA)   (JNIEnv *, jobject, jclass,
 377                                                     jmethodID, jvalue *);
 378
 379   jfieldID  (JNICALL *GetFieldID)          (JNIEnv *, jclass, const char *,
 380                                             const char *);
 381
 382   jobject  (JNICALL *GetObjectField)       (JNIEnv *, jobject, jfieldID);
 383   jboolean (JNICALL *GetBooleanField)      (JNIEnv *, jobject, jfieldID);
 384   jbyte    (JNICALL *GetByteField)         (JNIEnv *, jobject, jfieldID);
 385   jchar    (JNICALL *GetCharField)         (JNIEnv *, jobject, jfieldID);
 386   jshort   (JNICALL *GetShortField)        (JNIEnv *, jobject, jfieldID);
 387   jint     (JNICALL *GetIntField)          (JNIEnv *, jobject, jfieldID);
 388   jlong    (JNICALL *GetLongField)         (JNIEnv *, jobject, jfieldID);
 389   jfloat   (JNICALL *GetFloatField)        (JNIEnv *, jobject, jfieldID);
 390   jdouble  (JNICALL *GetDoubleField)       (JNIEnv *, jobject, jfieldID);
 391
 392   void  (JNICALL *SetObjectField)          (JNIEnv *, jobject,
 393                                             jfieldID, jobject);
 394   void  (JNICALL *SetBooleanField)         (JNIEnv *, jobject,
 395                                             jfieldID, jboolean);
 396   void  (JNICALL *SetByteField)            (JNIEnv *, jobject,
 397                                             jfieldID, jbyte);
 398   void  (JNICALL *SetCharField)            (JNIEnv *, jobject,
 399                                             jfieldID, jchar);
 400   void  (JNICALL *SetShortField)           (JNIEnv *, jobject,
 401                                             jfieldID, jshort);
 402   void  (JNICALL *SetIntField)             (JNIEnv *, jobject,
 403                                             jfieldID, jint);
 404   void  (JNICALL *SetLongField)            (JNIEnv *, jobject,
 405                                             jfieldID, jlong);
 406   void  (JNICALL *SetFloatField)           (JNIEnv *, jobject,
 407                                             jfieldID, jfloat);
 408   void  (JNICALL *SetDoubleField)          (JNIEnv *, jobject,
 409                                             jfieldID, jdouble);
 410
 411   jmethodID (JNICALL *GetStaticMethodID)   (JNIEnv *, jclass, const char *,
 412                                             const char *);
 413
 414   jobject  (JNICALL *CallStaticObjectMethod)  (JNIEnv *, jclass, jmethodID,
 415                                                ...);
 416   jobject  (JNICALL *CallStaticObjectMethodV) (JNIEnv *, jclass, jmethodID,
 417                                                va_list);
 418   jobject  (JNICALL *CallStaticObjectMethodA) (JNIEnv *, jclass, jmethodID,
 419                                                jvalue *);
 420   jboolean (JNICALL *CallStaticBooleanMethod) (JNIEnv *, jclass, jmethodID,
 421                                                ...);
 422   jboolean (JNICALL *CallStaticBooleanMethodV) (JNIEnv *, jclass, jmethodID,
 423                                                 va_list);
 424   jboolean (JNICALL *CallStaticBooleanMethodA) (JNIEnv *, jclass, jmethodID,
 425                                                 jvalue *);
 426   jbyte    (JNICALL *CallStaticByteMethod)    (JNIEnv *, jclass, jmethodID,
 427                                                ...);
 428   jbyte    (JNICALL *CallStaticByteMethodV)   (JNIEnv *, jclass, jmethodID,
 429                                                va_list);
 430   jbyte    (JNICALL *CallStaticByteMethodA)   (JNIEnv *, jclass, jmethodID,
 431                                                jvalue *);
 432   jchar    (JNICALL *CallStaticCharMethod)    (JNIEnv *, jclass, jmethodID,
 433                                                ...);
 434   jchar    (JNICALL *CallStaticCharMethodV)   (JNIEnv *, jclass, jmethodID,
 435                                                va_list);
 436   jchar    (JNICALL *CallStaticCharMethodA)   (JNIEnv *, jclass, jmethodID,
 437                                                jvalue *);
 438   jshort   (JNICALL *CallStaticShortMethod)   (JNIEnv *, jclass, jmethodID,
 439                                                ...);
 440   jshort   (JNICALL *CallStaticShortMethodV)  (JNIEnv *, jclass, jmethodID,
 441                                                va_list);
 442   jshort   (JNICALL *CallStaticShortMethodA)  (JNIEnv *, jclass, jmethodID,
 443                                                jvalue *);
 444   jint     (JNICALL *CallStaticIntMethod)     (JNIEnv *, jclass, jmethodID,
 445                                                ...);
 446   jint     (JNICALL *CallStaticIntMethodV)    (JNIEnv *, jclass, jmethodID,
 447                                                va_list);
 448   jint     (JNICALL *CallStaticIntMethodA)    (JNIEnv *, jclass, jmethodID,
 449                                                jvalue *);
 450   jlong    (JNICALL *CallStaticLongMethod)    (JNIEnv *, jclass, jmethodID,
 451                                                ...);
 452   jlong    (JNICALL *CallStaticLongMethodV)   (JNIEnv *, jclass, jmethodID,
 453                                                va_list);
 454   jlong    (JNICALL *CallStaticLongMethodA)   (JNIEnv *, jclass, jmethodID,
 455                                                jvalue *);
 456   jfloat   (JNICALL *CallStaticFloatMethod)   (JNIEnv *, jclass, jmethodID,
 457                                                ...);
 458   jfloat   (JNICALL *CallStaticFloatMethodV)  (JNIEnv *, jclass, jmethodID,
 459                                                va_list);
 460   jfloat   (JNICALL *CallStaticFloatMethodA)  (JNIEnv *, jclass, jmethodID,
 461                                                jvalue *);
 462   jdouble  (JNICALL *CallStaticDoubleMethod)  (JNIEnv *, jclass, jmethodID,
 463                                                ...);
 464   jdouble  (JNICALL *CallStaticDoubleMethodV) (JNIEnv *, jclass, jmethodID,
 465                                                va_list);
 466   jdouble  (JNICALL *CallStaticDoubleMethodA) (JNIEnv *, jclass, jmethodID,
 467                                                jvalue *);
 468   void     (JNICALL *CallStaticVoidMethod)    (JNIEnv *, jclass, jmethodID,
 469                                                ...);
 470   void     (JNICALL *CallStaticVoidMethodV)   (JNIEnv *, jclass, jmethodID,
 471                                                va_list);
 472   void     (JNICALL *CallStaticVoidMethodA)   (JNIEnv *, jclass, jmethodID,
 473                                                jvalue *);
 474
 475   jfieldID (JNICALL *GetStaticFieldID)        (JNIEnv *, jclass, const char *,
 476                                                const char *);
 477
 478   jobject  (JNICALL *GetStaticObjectField)    (JNIEnv *, jclass, jfieldID);
 479   jboolean (JNICALL *GetStaticBooleanField)   (JNIEnv *, jclass, jfieldID);
 480   jbyte    (JNICALL *GetStaticByteField)      (JNIEnv *, jclass, jfieldID);
 481   jchar    (JNICALL *GetStaticCharField)      (JNIEnv *, jclass, jfieldID);
 482   jshort   (JNICALL *GetStaticShortField)     (JNIEnv *, jclass, jfieldID);
 483   jint     (JNICALL *GetStaticIntField)       (JNIEnv *, jclass, jfieldID);
 484   jlong    (JNICALL *GetStaticLongField)      (JNIEnv *, jclass, jfieldID);
 485   jfloat   (JNICALL *GetStaticFloatField)     (JNIEnv *, jclass, jfieldID);
 486   jdouble  (JNICALL *GetStaticDoubleField)    (JNIEnv *, jclass, jfieldID);
 487
 488   void  (JNICALL *SetStaticObjectField)    (JNIEnv *, jclass,
 489                                             jfieldID, jobject);
 490   void  (JNICALL *SetStaticBooleanField)   (JNIEnv *, jclass,
 491                                             jfieldID, jboolean);
 492   void  (JNICALL *SetStaticByteField)      (JNIEnv *, jclass,
 493                                             jfieldID, jbyte);
 494   void  (JNICALL *SetStaticCharField)      (JNIEnv *, jclass,
 495                                             jfieldID, jchar);
 496   void  (JNICALL *SetStaticShortField)     (JNIEnv *, jclass,
 497                                             jfieldID, jshort);
 498   void  (JNICALL *SetStaticIntField)       (JNIEnv *, jclass,
 499                                             jfieldID, jint);
 500   void  (JNICALL *SetStaticLongField)      (JNIEnv *, jclass,
 501                                             jfieldID, jlong);
 502   void  (JNICALL *SetStaticFloatField)     (JNIEnv *, jclass,
 503                                             jfieldID, jfloat);
 504   void  (JNICALL *SetStaticDoubleField)    (JNIEnv *, jclass,
 505                                             jfieldID, jdouble);
 506
 507   jstring  (JNICALL *NewString)            (JNIEnv *, const jchar *, jsize);
 508   jsize    (JNICALL *GetStringLength)      (JNIEnv *, jstring);
 509   const jchar * (JNICALL *GetStringChars)  (JNIEnv *, jstring, jboolean *);
 510   void     (JNICALL *ReleaseStringChars)   (JNIEnv *, jstring, const jchar *);
 511   jstring  (JNICALL *NewStringUTF)         (JNIEnv *, const char *);
 512   jsize    (JNICALL *GetStringUTFLength)   (JNIEnv *, jstring);
 513   const char * (JNICALL *GetStringUTFChars) (JNIEnv *, jstring, jboolean *);
 514   void     (JNICALL *ReleaseStringUTFChars) (JNIEnv *, jstring, const char *);
 515   jsize    (JNICALL *GetArrayLength)       (JNIEnv *, jarray);
 516   jobjectArray (JNICALL *NewObjectArray)    (JNIEnv *, jsize, jclass, jobject);
 517   jobject  (JNICALL *GetObjectArrayElement) (JNIEnv *, jobjectArray, jsize);
 518   void     (JNICALL *SetObjectArrayElement) (JNIEnv *, jobjectArray, jsize,
 519                                              jobject);
 520
 521   jbooleanArray (JNICALL *NewBooleanArray)         (JNIEnv *, jsize);
 522   jbyteArray    (JNICALL *NewByteArray)            (JNIEnv *, jsize);
 523   jcharArray    (JNICALL *NewCharArray)            (JNIEnv *, jsize);
 524   jshortArray   (JNICALL *NewShortArray)           (JNIEnv *, jsize);
 525   jintArray     (JNICALL *NewIntArray)             (JNIEnv *, jsize);
 526   jlongArray    (JNICALL *NewLongArray)            (JNIEnv *, jsize);
 527   jfloatArray   (JNICALL *NewFloatArray)           (JNIEnv *, jsize);
 528   jdoubleArray  (JNICALL *NewDoubleArray)          (JNIEnv *, jsize);
 529
 530   jboolean *    (JNICALL *GetBooleanArrayElements) (JNIEnv *, jbooleanArray,
 531                                                     jboolean *);
 532   jbyte *       (JNICALL *GetByteArrayElements)    (JNIEnv *, jbyteArray,
 533                                                     jboolean *);
 534   jchar *       (JNICALL *GetCharArrayElements)    (JNIEnv *, jcharArray,
 535                                                     jboolean *);
 536   jshort *      (JNICALL *GetShortArrayElements)   (JNIEnv *, jshortArray,
 537                                                     jboolean *);
 538   jint *        (JNICALL *GetIntArrayElements)     (JNIEnv *, jintArray,
 539                                                     jboolean *);
 540   jlong *       (JNICALL *GetLongArrayElements)    (JNIEnv *, jlongArray,
 541                                                     jboolean *);
 542   jfloat *      (JNICALL *GetFloatArrayElements)   (JNIEnv *, jfloatArray,
 543                                                     jboolean *);
 544   jdouble *     (JNICALL *GetDoubleArrayElements)  (JNIEnv *, jdoubleArray,
 545                                                     jboolean *);
 546
 547   void          (JNICALL *ReleaseBooleanArrayElements) (JNIEnv *, jbooleanArray,
 548                                                         jboolean *, jint);
 549   void          (JNICALL *ReleaseByteArrayElements)    (JNIEnv *, jbyteArray,
 550                                                         jbyte *, jint);
 551   void          (JNICALL *ReleaseCharArrayElements)    (JNIEnv *, jcharArray,
 552                                                         jchar *, jint);
 553   void          (JNICALL *ReleaseShortArrayElements)   (JNIEnv *, jshortArray,
 554                                                         jshort *, jint);
 555   void          (JNICALL *ReleaseIntArrayElements)     (JNIEnv *, jintArray,
 556                                                         jint *, jint);
 557   void          (JNICALL *ReleaseLongArrayElements)    (JNIEnv *, jlongArray,
 558                                                         jlong *, jint);
 559   void          (JNICALL *ReleaseFloatArrayElements)   (JNIEnv *, jfloatArray,
 560                                                         jfloat *, jint);
 561   void          (JNICALL *ReleaseDoubleArrayElements)  (JNIEnv *, jdoubleArray,
 562                                                         jdouble *, jint);
 563
 564   void          (JNICALL *GetBooleanArrayRegion)   (JNIEnv *, jbooleanArray,
 565                                                     jsize, jsize, jboolean *);
 566   void          (JNICALL *GetByteArrayRegion)      (JNIEnv *, jbyteArray,
 567                                                     jsize, jsize, jbyte *);
 568   void          (JNICALL *GetCharArrayRegion)      (JNIEnv *, jcharArray,
 569                                                     jsize, jsize, jchar *);
 570   void          (JNICALL *GetShortArrayRegion)     (JNIEnv *, jshortArray,
 571                                                     jsize, jsize, jshort *);
 572   void          (JNICALL *GetIntArrayRegion)       (JNIEnv *, jintArray,
 573                                                     jsize, jsize, jint *);
 574   void          (JNICALL *GetLongArrayRegion)      (JNIEnv *, jlongArray,
 575                                                     jsize, jsize, jlong *);
 576   void          (JNICALL *GetFloatArrayRegion)     (JNIEnv *, jfloatArray,
 577                                                     jsize, jsize, jfloat *);
 578   void          (JNICALL *GetDoubleArrayRegion)    (JNIEnv *, jdoubleArray,
 579                                                     jsize, jsize, jdouble *);
 580
 581   void          (JNICALL *SetBooleanArrayRegion)   (JNIEnv *, jbooleanArray,
 582                                                     jsize, jsize, jboolean *);
 583   void          (JNICALL *SetByteArrayRegion)      (JNIEnv *, jbyteArray,
 584                                                     jsize, jsize, jbyte *);
 585   void          (JNICALL *SetCharArrayRegion)      (JNIEnv *, jcharArray,
 586                                                     jsize, jsize, jchar *);
 587   void          (JNICALL *SetShortArrayRegion)     (JNIEnv *, jshortArray,
 588                                                     jsize, jsize, jshort *);
 589   void          (JNICALL *SetIntArrayRegion)       (JNIEnv *, jintArray,
 590                                                     jsize, jsize, jint *);
 591   void          (JNICALL *SetLongArrayRegion)      (JNIEnv *, jlongArray,
 592                                                     jsize, jsize, jlong *);
 593   void          (JNICALL *SetFloatArrayRegion)     (JNIEnv *, jfloatArray,
 594                                                     jsize, jsize, jfloat *);
 595   void          (JNICALL *SetDoubleArrayRegion)    (JNIEnv *, jdoubleArray,
 596                                                     jsize, jsize, jdouble *);
 597
 598   jint     (JNICALL *RegisterNatives)              (JNIEnv *, jclass,
 599                                                     const JNINativeMethod *,
 600                                                     jint);
 601   jint     (JNICALL *UnregisterNatives)            (JNIEnv *, jclass);
 602   jint     (JNICALL *MonitorEnter)                 (JNIEnv *, jobject);
 603   jint     (JNICALL *MonitorExit)                  (JNIEnv *, jobject);
 604   jint     (JNICALL *GetJavaVM)                    (JNIEnv *, JavaVM **);
 605
 606   /* ---- JNI 1.2 functions ---- */
 607   void     (JNICALL *GetStringRegion)              (JNIEnv *, jstring, jsize,
 608                                                     jsize, jchar *);
 609   void     (JNICALL *GetStringUTFRegion)           (JNIEnv *, jstring, jsize,
 610                                                     jsize, char *);
 611
 612   void * (JNICALL *GetPrimitiveArrayCritical)      (JNIEnv *, jarray,
 613                                                     jboolean *);
 614   void   (JNICALL *ReleasePrimitiveArrayCritical)  (JNIEnv *, jarray, void *,
 615                                                     jint);
 616
 617   const jchar * (JNICALL *GetStringCritical)       (JNIEnv *, jstring,
 618                                                     jboolean *);
 619   void          (JNICALL *ReleaseStringCritical)   (JNIEnv *, jstring,
 620                                                     const jchar *);
 621
 622   jweak  (JNICALL *NewWeakGlobalRef)               (JNIEnv *, jobject);
 623   void   (JNICALL *DeleteWeakGlobalRef)            (JNIEnv *, jweak);
 624
 625   jboolean      (JNICALL *ExceptionCheck)          (JNIEnv *);
 626
 627   /* ---- JNI 1.4 functions ---- */
 628   jobject (JNICALL *NewDirectByteBuffer)           (JNIEnv *, void *, jlong);
 629   void *  (JNICALL *GetDirectBufferAddress)        (JNIEnv *, jobject);
 630   jlong   (JNICALL *GetDirectBufferCapacity)       (JNIEnv *, jobject);
 631 };
 632
 633 #ifdef __cplusplus
 634
 635 class _Jv_JNIEnv
 636 {
 637 public:
 638   /* The method table.  */
 639   struct JNINativeInterface *p;
 640
 641 #ifdef _CLASSPATH_JNIENV_CONTENTS
 642   _CLASSPATH_JNIENV_CONTENTS
 643 #endif
 644
 645   jint GetVersion ()
 646   { return p->GetVersion (this); }
 647
 648   jclass DefineClass (const char *name, jobject obj0, const jbyte * val1,
 649                       jsize val2)
 650   { return p->DefineClass (this, name, obj0, val1, val2); }
 651
 652   jclass FindClass (const char * val0)
 653   { return p->FindClass (this, val0); }
 654
 655   jmethodID FromReflectedMethod (jobject obj0)
 656   { return p->FromReflectedMethod (this, obj0); }
 657
 658   jfieldID FromReflectedField (jobject obj0)
 659   { return p->FromReflectedField (this, obj0); }
 660
 661   jobject ToReflectedMethod (jclass cl0, jmethodID meth1, jboolean val2)
 662   { return p->ToReflectedMethod (this, cl0, meth1, val2); }
 663
 664   jclass GetSuperclass (jclass cl0)
 665   { return p->GetSuperclass (this, cl0); }
 666
 667   jboolean IsAssignableFrom (jclass cl0, jclass cl1)
 668   { return p->IsAssignableFrom (this, cl0, cl1); }
 669
 670   jobject ToReflectedField (jclass cl0, jfieldID fld1, jboolean val2)
 671   { return p->ToReflectedField (this, cl0, fld1, val2); }
 672
 673   jint Throw (jthrowable val0)
 674   { return p->Throw (this, val0); }
 675
 676   jint ThrowNew (jclass cl0, const char * val1)
 677   { return p->ThrowNew (this, cl0, val1); }
 678
 679   jthrowable ExceptionOccurred ()
 680   { return p->ExceptionOccurred (this); }
 681
 682   void ExceptionDescribe ()
 683   { p->ExceptionDescribe (this); }
 684
 685   void ExceptionClear ()
 686   { p->ExceptionClear (this); }
 687
 688   void FatalError (const char * val0)
 689   { p->FatalError (this, val0); }
 690
 691   jint PushLocalFrame (jint val0)
 692   { return p->PushLocalFrame (this, val0); }
 693
 694   jobject PopLocalFrame (jobject obj0)
 695   { return p->PopLocalFrame (this, obj0); }
 696
 697   jobject NewGlobalRef (jobject obj0)
 698   { return p->NewGlobalRef (this, obj0); }
 699
 700   void DeleteGlobalRef (jobject obj0)
 701   { p->DeleteGlobalRef (this, obj0); }
 702
 703   void DeleteLocalRef (jobject obj0)
 704   { p->DeleteLocalRef (this, obj0); }
 705
 706   jboolean IsSameObject (jobject obj0, jobject obj1)
 707   { return p->IsSameObject (this, obj0, obj1); }
 708
 709   jobject NewLocalRef (jobject obj0)
 710   { return p->NewLocalRef (this, obj0); }
 711
 712   jint EnsureLocalCapacity (jint val0)
 713   { return p->EnsureLocalCapacity (this, val0); }
 714
 715   jobject AllocObject (jclass cl0)
 716   { return p->AllocObject (this, cl0); }
 717
 718   jobject NewObject (jclass cl0, jmethodID meth1, ...)
 719   {
 720     va_list args;
 721     va_start (args, meth1);
 722     jobject result = p->NewObjectV (this, cl0, meth1, args);
 723     va_end (args);
 724     return result;
 725   }
 726
 727   jobject NewObjectV (jclass cl0, jmethodID meth1, va_list val2)
 728   { return p->NewObjectV (this, cl0, meth1, val2); }
 729
 730   jobject NewObjectA (jclass cl0, jmethodID meth1, jvalue * val2)
 731   { return p->NewObjectA (this, cl0, meth1, val2); }
 732
 733   jclass GetObjectClass (jobject obj0)
 734   { return p->GetObjectClass (this, obj0); }
 735
 736   jboolean IsInstanceOf (jobject obj0, jclass cl1)
 737   { return p->IsInstanceOf (this, obj0, cl1); }
 738
 739   jmethodID GetMethodID (jclass cl0, const char * val1, const char * val2)
 740   { return p->GetMethodID (this, cl0, val1, val2); }
 741
 742   jobject CallObjectMethod (jobject obj0, jmethodID meth1, ...)
 743   {
 744     va_list args;
 745     va_start (args, meth1);
 746     jobject result = p->CallObjectMethodV (this, obj0, meth1, args);
 747     va_end (args);
 748     return result;
 749   }
 750
 751   jobject CallObjectMethodV (jobject obj0, jmethodID meth1, va_list val2)
 752   { return p->CallObjectMethodV (this, obj0, meth1, val2); }
 753
 754   jobject CallObjectMethodA (jobject obj0, jmethodID meth1, jvalue * val2)
 755   { return p->CallObjectMethodA (this, obj0, meth1, val2); }
 756
 757   jboolean CallBooleanMethod (jobject obj0, jmethodID meth1, ...)
 758   {
 759     va_list args;
 760     va_start (args, meth1);
 761     jboolean result = p->CallBooleanMethodV (this, obj0, meth1, args);
 762     va_end (args);
 763     return result;
 764   }
 765
 766   jboolean CallBooleanMethodV (jobject obj0, jmethodID meth1, va_list val2)
 767   { return p->CallBooleanMethodV (this, obj0, meth1, val2); }
 768
 769   jboolean CallBooleanMethodA (jobject obj0, jmethodID meth1, jvalue * val2)
 770   { return p->CallBooleanMethodA (this, obj0, meth1, val2); }
 771
 772   jbyte CallByteMethod (jobject obj0, jmethodID meth1, ...)
 773   {
 774     va_list args;
 775     va_start (args, meth1);
 776     jbyte result = p->CallByteMethodV (this, obj0, meth1, args);
 777     va_end (args);
 778     return result;
 779   }
 780
 781   jbyte CallByteMethodV (jobject obj0, jmethodID meth1, va_list val2)
 782   { return p->CallByteMethodV (this, obj0, meth1, val2); }
 783
 784   jbyte CallByteMethodA (jobject obj0, jmethodID meth1, jvalue * val2)
 785   { return p->CallByteMethodA (this, obj0, meth1, val2); }
 786
 787   jchar CallCharMethod (jobject obj0, jmethodID meth1, ...)
 788   {
 789     va_list args;
 790     va_start (args, meth1);
 791     jchar result = p->CallCharMethodV (this, obj0, meth1, args);
 792     va_end (args);
 793     return result;
 794   }
 795
 796   jchar CallCharMethodV (jobject obj0, jmethodID meth1, va_list val2)
 797   { return p->CallCharMethodV (this, obj0, meth1, val2); }
 798
 799   jchar CallCharMethodA (jobject obj0, jmethodID meth1, jvalue * val2)
 800   { return p->CallCharMethodA (this, obj0, meth1, val2); }
 801
 802   jshort CallShortMethod (jobject obj0, jmethodID meth1, ...)
 803   {
 804     va_list args;
 805     va_start (args, meth1);
 806     jshort result = p->CallShortMethodV (this, obj0, meth1, args);
 807     va_end (args);
 808     return result;
 809   }
 810
 811   jshort CallShortMethodV (jobject obj0, jmethodID meth1, va_list val2)
 812   { return p->CallShortMethodV (this, obj0, meth1, val2); }
 813
 814   jshort CallShortMethodA (jobject obj0, jmethodID meth1, jvalue * val2)
 815   { return p->CallShortMethodA (this, obj0, meth1, val2); }
 816
 817   jint CallIntMethod (jobject obj0, jmethodID meth1, ...)
 818   {
 819     va_list args;
 820     va_start (args, meth1);
 821     jint result = p->CallIntMethodV (this, obj0, meth1, args);
 822     va_end (args);
 823     return result;
 824   }
 825
 826   jint CallIntMethodV (jobject obj0, jmethodID meth1, va_list val2)
 827   { return p->CallIntMethodV (this, obj0, meth1, val2); }
 828
 829   jint CallIntMethodA (jobject obj0, jmethodID meth1, jvalue * val2)
 830   { return p->CallIntMethodA (this, obj0, meth1, val2); }
 831
 832   jlong CallLongMethod (jobject obj0, jmethodID meth1, ...)
 833   {
 834     va_list args;
 835     va_start (args, meth1);
 836     jlong result = p->CallLongMethodV (this, obj0, meth1, args);
 837     va_end (args);
 838     return result;
 839   }
 840
 841   jlong CallLongMethodV (jobject obj0, jmethodID meth1, va_list val2)
 842   { return p->CallLongMethodV (this, obj0, meth1, val2); }
 843
 844   jlong CallLongMethodA (jobject obj0, jmethodID meth1, jvalue * val2)
 845   { return p->CallLongMethodA (this, obj0, meth1, val2); }
 846
 847   jfloat CallFloatMethod (jobject obj0, jmethodID meth1, ...)
 848   {
 849     va_list args;
 850     va_start (args, meth1);
 851     jfloat result = p->CallFloatMethodV (this, obj0, meth1, args);
 852     va_end (args);
 853     return result;
 854   }
 855
 856   jfloat CallFloatMethodV (jobject obj0, jmethodID meth1, va_list val2)
 857   { return p->CallFloatMethodV (this, obj0, meth1, val2); }
 858
 859   jfloat CallFloatMethodA (jobject obj0, jmethodID meth1, jvalue * val2)
 860   { return p->CallFloatMethodA (this, obj0, meth1, val2); }
 861
 862   jdouble CallDoubleMethod (jobject obj0, jmethodID meth1, ...)
 863   {
 864     va_list args;
 865     va_start (args, meth1);
 866     jdouble result = p->CallDoubleMethodV (this, obj0, meth1, args);
 867     va_end (args);
 868     return result;
 869   }
 870
 871   jdouble CallDoubleMethodV (jobject obj0, jmethodID meth1, va_list val2)
 872   { return p->CallDoubleMethodV (this, obj0, meth1, val2); }
 873
 874   jdouble CallDoubleMethodA (jobject obj0, jmethodID meth1, jvalue * val2)
 875   { return p->CallDoubleMethodA (this, obj0, meth1, val2); }
 876
 877   void CallVoidMethod (jobject obj0, jmethodID meth1, ...)
 878   {
 879     va_list args;
 880     va_start (args, meth1);
 881     p->CallVoidMethodV (this, obj0, meth1, args);
 882     va_end (args);
 883   }
 884
 885   void CallVoidMethodV (jobject obj0, jmethodID meth1, va_list val2)
 886   { p->CallVoidMethodV (this, obj0, meth1, val2); }
 887
 888   void CallVoidMethodA (jobject obj0, jmethodID meth1, jvalue * val2)
 889   { p->CallVoidMethodA (this, obj0, meth1, val2); }
 890
 891   jobject CallNonvirtualObjectMethod (jobject obj0, jclass cl1, jmethodID meth2, ...)
 892   {
 893     va_list args;
 894     va_start (args, meth2);
 895     jobject result = p->CallNonvirtualObjectMethodV (this, obj0, cl1, meth2, args);
 896     va_end (args);
 897     return result;
 898   }
 899
 900   jobject CallNonvirtualObjectMethodV (jobject obj0, jclass cl1, jmethodID meth2, va_list val3)
 901   { return p->CallNonvirtualObjectMethodV (this, obj0, cl1, meth2, val3); }
 902
 903   jobject CallNonvirtualObjectMethodA (jobject obj0, jclass cl1, jmethodID meth2, jvalue * val3)
 904   { return p->CallNonvirtualObjectMethodA (this, obj0, cl1, meth2, val3); }
 905
 906   jboolean CallNonvirtualBooleanMethod (jobject obj0, jclass cl1, jmethodID meth2, ...)
 907   {
 908     va_list args;
 909     va_start (args, meth2);
 910     jboolean result = p->CallNonvirtualBooleanMethodV (this, obj0, cl1, meth2, args);
 911     va_end (args);
 912     return result;
 913   }
 914
 915   jboolean CallNonvirtualBooleanMethodV (jobject obj0, jclass cl1, jmethodID meth2, va_list val3)
 916   { return p->CallNonvirtualBooleanMethodV (this, obj0, cl1, meth2, val3); }
 917
 918   jboolean CallNonvirtualBooleanMethodA (jobject obj0, jclass cl1, jmethodID meth2, jvalue * val3)
 919   { return p->CallNonvirtualBooleanMethodA (this, obj0, cl1, meth2, val3); }
 920
 921   jbyte CallNonvirtualByteMethod (jobject obj0, jclass cl1, jmethodID meth2, ...)
 922   {
 923     va_list args;
 924     va_start (args, meth2);
 925     jbyte result = p->CallNonvirtualByteMethodV (this, obj0, cl1, meth2, args);
 926     va_end (args);
 927     return result;
 928   }
 929
 930   jbyte CallNonvirtualByteMethodV (jobject obj0, jclass cl1, jmethodID meth2, va_list val3)
 931   { return p->CallNonvirtualByteMethodV (this, obj0, cl1, meth2, val3); }
 932
 933   jbyte CallNonvirtualByteMethodA (jobject obj0, jclass cl1, jmethodID meth2, jvalue * val3)
 934   { return p->CallNonvirtualByteMethodA (this, obj0, cl1, meth2, val3); }
 935
 936   jchar CallNonvirtualCharMethod (jobject obj0, jclass cl1, jmethodID meth2, ...)
 937   {
 938     va_list args;
 939     va_start (args, meth2);
 940     jchar result = p->CallNonvirtualCharMethodV (this, obj0, cl1, meth2, args);
 941     va_end (args);
 942     return result;
 943   }
 944
 945   jchar CallNonvirtualCharMethodV (jobject obj0, jclass cl1, jmethodID meth2, va_list val3)
 946   { return p->CallNonvirtualCharMethodV (this, obj0, cl1, meth2, val3); }
 947
 948   jchar CallNonvirtualCharMethodA (jobject obj0, jclass cl1, jmethodID meth2, jvalue * val3)
 949   { return p->CallNonvirtualCharMethodA (this, obj0, cl1, meth2, val3); }
 950
 951   jshort CallNonvirtualShortMethod (jobject obj0, jclass cl1, jmethodID meth2, ...)
 952   {
 953     va_list args;
 954     va_start (args, meth2);
 955     jshort result = p->CallNonvirtualShortMethodV (this, obj0, cl1, meth2, args);
 956     va_end (args);
 957     return result;
 958   }
 959
 960   jshort CallNonvirtualShortMethodV (jobject obj0, jclass cl1, jmethodID meth2, va_list val3)
 961   { return p->CallNonvirtualShortMethodV (this, obj0, cl1, meth2, val3); }
 962
 963   jshort CallNonvirtualShortMethodA (jobject obj0, jclass cl1, jmethodID meth2, jvalue * val3)
 964   { return p->CallNonvirtualShortMethodA (this, obj0, cl1, meth2, val3); }
 965
 966   jint CallNonvirtualIntMethod (jobject obj0, jclass cl1, jmethodID meth2, ...)
 967   {
 968     va_list args;
 969     va_start (args, meth2);
 970     jint result = p->CallNonvirtualIntMethodV (this, obj0, cl1, meth2, args);
 971     va_end (args);
 972     return result;
 973   }
 974
 975   jint CallNonvirtualIntMethodV (jobject obj0, jclass cl1, jmethodID meth2, va_list val3)
 976   { return p->CallNonvirtualIntMethodV (this, obj0, cl1, meth2, val3); }
 977
 978   jint CallNonvirtualIntMethodA (jobject obj0, jclass cl1, jmethodID meth2, jvalue * val3)
 979   { return p->CallNonvirtualIntMethodA (this, obj0, cl1, meth2, val3); }
 980
 981   jlong CallNonvirtualLongMethod (jobject obj0, jclass cl1, jmethodID meth2, ...)
 982   {
 983     va_list args;
 984     va_start (args, meth2);
 985     jlong result = p->CallNonvirtualLongMethodV (this, obj0, cl1, meth2, args);
 986     va_end (args);
 987     return result;
 988   }
 989
 990   jlong CallNonvirtualLongMethodV (jobject obj0, jclass cl1, jmethodID meth2, va_list val3)
 991   { return p->CallNonvirtualLongMethodV (this, obj0, cl1, meth2, val3); }
 992
 993   jlong CallNonvirtualLongMethodA (jobject obj0, jclass cl1, jmethodID meth2, jvalue * val3)
 994   { return p->CallNonvirtualLongMethodA (this, obj0, cl1, meth2, val3); }
 995
 996   jfloat CallNonvirtualFloatMethod (jobject obj0, jclass cl1, jmethodID meth2, ...)
 997   {
 998     va_list args;
 999     va_start (args, meth2);
1000     jfloat result = p->CallNonvirtualFloatMethodV (this, obj0, cl1, meth2, args);
1001     va_end (args);
1002     return result;
1003   }
1004
1005   jfloat CallNonvirtualFloatMethodV (jobject obj0, jclass cl1, jmethodID meth2, va_list val3)
1006   { return p->CallNonvirtualFloatMethodV (this, obj0, cl1, meth2, val3); }
1007
1008   jfloat CallNonvirtualFloatMethodA (jobject obj0, jclass cl1, jmethodID meth2, jvalue * val3)
1009   { return p->CallNonvirtualFloatMethodA (this, obj0, cl1, meth2, val3); }
1010
1011   jdouble CallNonvirtualDoubleMethod (jobject obj0, jclass cl1, jmethodID meth2, ...)
1012   {
1013     va_list args;
1014     va_start (args, meth2);
1015     jdouble result = p->CallNonvirtualDoubleMethodV (this, obj0, cl1, meth2, args);
1016     va_end (args);
1017     return result;
1018   }
1019
1020   jdouble CallNonvirtualDoubleMethodV (jobject obj0, jclass cl1, jmethodID meth2, va_list val3)
1021   { return p->CallNonvirtualDoubleMethodV (this, obj0, cl1, meth2, val3); }
1022
1023   jdouble CallNonvirtualDoubleMethodA (jobject obj0, jclass cl1, jmethodID meth2, jvalue * val3)
1024   { return p->CallNonvirtualDoubleMethodA (this, obj0, cl1, meth2, val3); }
1025
1026   void CallNonvirtualVoidMethod (jobject obj0, jclass cl1, jmethodID meth2, ...)
1027   {
1028     va_list args;
1029     va_start (args, meth2);
1030     p->CallNonvirtualVoidMethodV (this, obj0, cl1, meth2, args);
1031     va_end (args);
1032   }
1033
1034   void CallNonvirtualVoidMethodV (jobject obj0, jclass cl1, jmethodID meth2, va_list val3)
1035   { p->CallNonvirtualVoidMethodV (this, obj0, cl1, meth2, val3); }
1036
1037   void CallNonvirtualVoidMethodA (jobject obj0, jclass cl1, jmethodID meth2, jvalue * val3)
1038   { p->CallNonvirtualVoidMethodA (this, obj0, cl1, meth2, val3); }
1039
1040   jfieldID GetFieldID (jclass cl0, const char * val1, const char * val2)
1041   { return p->GetFieldID (this, cl0, val1, val2); }
1042
1043   jobject GetObjectField (jobject obj0, jfieldID fld1)
1044   { return p->GetObjectField (this, obj0, fld1); }
1045
1046   jboolean GetBooleanField (jobject obj0, jfieldID fld1)
1047   { return p->GetBooleanField (this, obj0, fld1); }
1048
1049   jbyte GetByteField (jobject obj0, jfieldID fld1)
1050   { return p->GetByteField (this, obj0, fld1); }
1051
1052   jchar GetCharField (jobject obj0, jfieldID fld1)
1053   { return p->GetCharField (this, obj0, fld1); }
1054
1055   jshort GetShortField (jobject obj0, jfieldID fld1)
1056   { return p->GetShortField (this, obj0, fld1); }
1057
1058   jint GetIntField (jobject obj0, jfieldID fld1)
1059   { return p->GetIntField (this, obj0, fld1); }
1060
1061   jlong GetLongField (jobject obj0, jfieldID fld1)
1062   { return p->GetLongField (this, obj0, fld1); }
1063
1064   jfloat GetFloatField (jobject obj0, jfieldID fld1)
1065   { return p->GetFloatField (this, obj0, fld1); }
1066
1067   jdouble GetDoubleField (jobject obj0, jfieldID fld1)
1068   { return p->GetDoubleField (this, obj0, fld1); }
1069
1070   void SetObjectField (jobject obj0, jfieldID fld1, jobject obj2)
1071   { p->SetObjectField (this, obj0, fld1, obj2); }
1072
1073   void SetBooleanField (jobject obj0, jfieldID fld1, jboolean val2)
1074   { p->SetBooleanField (this, obj0, fld1, val2); }
1075
1076   void SetByteField (jobject obj0, jfieldID fld1, jbyte val2)
1077   { p->SetByteField (this, obj0, fld1, val2); }
1078
1079   void SetCharField (jobject obj0, jfieldID fld1, jchar val2)
1080   { p->SetCharField (this, obj0, fld1, val2); }
1081
1082   void SetShortField (jobject obj0, jfieldID fld1, jshort val2)
1083   { p->SetShortField (this, obj0, fld1, val2); }
1084
1085   void SetIntField (jobject obj0, jfieldID fld1, jint val2)
1086   { p->SetIntField (this, obj0, fld1, val2); }
1087
1088   void SetLongField (jobject obj0, jfieldID fld1, jlong val2)
1089   { p->SetLongField (this, obj0, fld1, val2); }
1090
1091   void SetFloatField (jobject obj0, jfieldID fld1, jfloat val2)
1092   { p->SetFloatField (this, obj0, fld1, val2); }
1093
1094   void SetDoubleField (jobject obj0, jfieldID fld1, jdouble val2)
1095   { p->SetDoubleField (this, obj0, fld1, val2); }
1096
1097   jmethodID GetStaticMethodID (jclass cl0, const char * val1, const char * val2)
1098   { return p->GetStaticMethodID (this, cl0, val1, val2); }
1099
1100   jobject CallStaticObjectMethod (jclass cl0, jmethodID meth1, ...)
1101   {
1102     va_list args;
1103     va_start (args, meth1);
1104     jobject result = p->CallStaticObjectMethodV (this, cl0, meth1, args);
1105     va_end (args);
1106     return result;
1107   }
1108
1109   jobject CallStaticObjectMethodV (jclass cl0, jmethodID meth1, va_list val2)
1110   { return p->CallStaticObjectMethodV (this, cl0, meth1, val2); }
1111
1112   jobject CallStaticObjectMethodA (jclass cl0, jmethodID meth1, jvalue * val2)
1113   { return p->CallStaticObjectMethodA (this, cl0, meth1, val2); }
1114
1115   jboolean CallStaticBooleanMethod (jclass cl0, jmethodID meth1, ...)
1116   {
1117     va_list args;
1118     va_start (args, meth1);
1119     jboolean result = p->CallStaticBooleanMethodV (this, cl0, meth1, args);
1120     va_end (args);
1121     return result;
1122   }
1123
1124   jboolean CallStaticBooleanMethodV (jclass cl0, jmethodID meth1, va_list val2)
1125   { return p->CallStaticBooleanMethodV (this, cl0, meth1, val2); }
1126
1127   jboolean CallStaticBooleanMethodA (jclass cl0, jmethodID meth1, jvalue * val2)
1128   { return p->CallStaticBooleanMethodA (this, cl0, meth1, val2); }
1129
1130   jbyte CallStaticByteMethod (jclass cl0, jmethodID meth1, ...)
1131   {
1132     va_list args;
1133     va_start (args, meth1);
1134     jbyte result = p->CallStaticByteMethodV (this, cl0, meth1, args);
1135     va_end (args);
1136     return result;
1137   }
1138
1139   jbyte CallStaticByteMethodV (jclass cl0, jmethodID meth1, va_list val2)
1140   { return p->CallStaticByteMethodV (this, cl0, meth1, val2); }
1141
1142   jbyte CallStaticByteMethodA (jclass cl0, jmethodID meth1, jvalue * val2)
1143   { return p->CallStaticByteMethodA (this, cl0, meth1, val2); }
1144
1145   jchar CallStaticCharMethod (jclass cl0, jmethodID meth1, ...)
1146   {
1147     va_list args;
1148     va_start (args, meth1);
1149     jchar result = p->CallStaticCharMethodV (this, cl0, meth1, args);
1150     va_end (args);
1151     return result;
1152   }
1153
1154   jchar CallStaticCharMethodV (jclass cl0, jmethodID meth1, va_list val2)
1155   { return p->CallStaticCharMethodV (this, cl0, meth1, val2); }
1156
1157   jchar CallStaticCharMethodA (jclass cl0, jmethodID meth1, jvalue * val2)
1158   { return p->CallStaticCharMethodA (this, cl0, meth1, val2); }
1159
1160   jshort CallStaticShortMethod (jclass cl0, jmethodID meth1, ...)
1161   {
1162     va_list args;
1163     va_start (args, meth1);
1164     jshort result = p->CallStaticShortMethodV (this, cl0, meth1, args);
1165     va_end (args);
1166     return result;
1167   }
1168
1169   jshort CallStaticShortMethodV (jclass cl0, jmethodID meth1, va_list val2)
1170   { return p->CallStaticShortMethodV (this, cl0, meth1, val2); }
1171
1172   jshort CallStaticShortMethodA (jclass cl0, jmethodID meth1, jvalue * val2)
1173   { return p->CallStaticShortMethodA (this, cl0, meth1, val2); }
1174
1175   jint CallStaticIntMethod (jclass cl0, jmethodID meth1, ...)
1176   {
1177     va_list args;
1178     va_start (args, meth1);
1179     jint result = p->CallStaticIntMethodV (this, cl0, meth1, args);
1180     va_end (args);
1181     return result;
1182   }
1183
1184   jint CallStaticIntMethodV (jclass cl0, jmethodID meth1, va_list val2)
1185   { return p->CallStaticIntMethodV (this, cl0, meth1, val2); }
1186
1187   jint CallStaticIntMethodA (jclass cl0, jmethodID meth1, jvalue * val2)
1188   { return p->CallStaticIntMethodA (this, cl0, meth1, val2); }
1189
1190   jlong CallStaticLongMethod (jclass cl0, jmethodID meth1, ...)
1191   {
1192     va_list args;
1193     va_start (args, meth1);
1194     jlong result = p->CallStaticLongMethodV (this, cl0, meth1, args);
1195     va_end (args);
1196     return result;
1197   }
1198
1199   jlong CallStaticLongMethodV (jclass cl0, jmethodID meth1, va_list val2)
1200   { return p->CallStaticLongMethodV (this, cl0, meth1, val2); }
1201
1202   jlong CallStaticLongMethodA (jclass cl0, jmethodID meth1, jvalue * val2)
1203   { return p->CallStaticLongMethodA (this, cl0, meth1, val2); }
1204
1205   jfloat CallStaticFloatMethod (jclass cl0, jmethodID meth1, ...)
1206   {
1207     va_list args;
1208     va_start (args, meth1);
1209     jfloat result = p->CallStaticFloatMethodV (this, cl0, meth1, args);
1210     va_end (args);
1211     return result;
1212   }
1213
1214   jfloat CallStaticFloatMethodV (jclass cl0, jmethodID meth1, va_list val2)
1215   { return p->CallStaticFloatMethodV (this, cl0, meth1, val2); }
1216
1217   jfloat CallStaticFloatMethodA (jclass cl0, jmethodID meth1, jvalue * val2)
1218   { return p->CallStaticFloatMethodA (this, cl0, meth1, val2); }
1219
1220   jdouble CallStaticDoubleMethod (jclass cl0, jmethodID meth1, ...)
1221   {
1222     va_list args;
1223     va_start (args, meth1);
1224     jdouble result = p->CallStaticDoubleMethodV (this, cl0, meth1, args);
1225     va_end (args);
1226     return result;
1227   }
1228
1229   jdouble CallStaticDoubleMethodV (jclass cl0, jmethodID meth1, va_list val2)
1230   { return p->CallStaticDoubleMethodV (this, cl0, meth1, val2); }
1231
1232   jdouble CallStaticDoubleMethodA (jclass cl0, jmethodID meth1, jvalue * val2)
1233   { return p->CallStaticDoubleMethodA (this, cl0, meth1, val2); }
1234
1235   void CallStaticVoidMethod (jclass cl0, jmethodID meth1, ...)
1236   {
1237     va_list args;
1238     va_start (args, meth1);
1239     p->CallStaticVoidMethodV (this, cl0, meth1, args);
1240     va_end (args);
1241   }
1242
1243   void CallStaticVoidMethodV (jclass cl0, jmethodID meth1, va_list val2)
1244   { p->CallStaticVoidMethodV (this, cl0, meth1, val2); }
1245
1246   void CallStaticVoidMethodA (jclass cl0, jmethodID meth1, jvalue * val2)
1247   { p->CallStaticVoidMethodA (this, cl0, meth1, val2); }
1248
1249   jfieldID GetStaticFieldID (jclass cl0, const char * val1, const char * val2)
1250   { return p->GetStaticFieldID (this, cl0, val1, val2); }
1251
1252   jobject GetStaticObjectField (jclass cl0, jfieldID fld1)
1253   { return p->GetStaticObjectField (this, cl0, fld1); }
1254
1255   jboolean GetStaticBooleanField (jclass cl0, jfieldID fld1)
1256   { return p->GetStaticBooleanField (this, cl0, fld1); }
1257
1258   jbyte GetStaticByteField (jclass cl0, jfieldID fld1)
1259   { return p->GetStaticByteField (this, cl0, fld1); }
1260
1261   jchar GetStaticCharField (jclass cl0, jfieldID fld1)
1262   { return p->GetStaticCharField (this, cl0, fld1); }
1263
1264   jshort GetStaticShortField (jclass cl0, jfieldID fld1)
1265   { return p->GetStaticShortField (this, cl0, fld1); }
1266
1267   jint GetStaticIntField (jclass cl0, jfieldID fld1)
1268   { return p->GetStaticIntField (this, cl0, fld1); }
1269
1270   jlong GetStaticLongField (jclass cl0, jfieldID fld1)
1271   { return p->GetStaticLongField (this, cl0, fld1); }
1272
1273   jfloat GetStaticFloatField (jclass cl0, jfieldID fld1)
1274   { return p->GetStaticFloatField (this, cl0, fld1); }
1275
1276   jdouble GetStaticDoubleField (jclass cl0, jfieldID fld1)
1277   { return p->GetStaticDoubleField (this, cl0, fld1); }
1278
1279   void SetStaticObjectField (jclass cl0, jfieldID fld1, jobject obj2)
1280   { p->SetStaticObjectField (this, cl0, fld1, obj2); }
1281
1282   void SetStaticBooleanField (jclass cl0, jfieldID fld1, jboolean val2)
1283   { p->SetStaticBooleanField (this, cl0, fld1, val2); }
1284
1285   void SetStaticByteField (jclass cl0, jfieldID fld1, jbyte val2)
1286   { p->SetStaticByteField (this, cl0, fld1, val2); }
1287
1288   void SetStaticCharField (jclass cl0, jfieldID fld1, jchar val2)
1289   { p->SetStaticCharField (this, cl0, fld1, val2); }
1290
1291   void SetStaticShortField (jclass cl0, jfieldID fld1, jshort val2)
1292   { p->SetStaticShortField (this, cl0, fld1, val2); }
1293
1294   void SetStaticIntField (jclass cl0, jfieldID fld1, jint val2)
1295   { p->SetStaticIntField (this, cl0, fld1, val2); }
1296
1297   void SetStaticLongField (jclass cl0, jfieldID fld1, jlong val2)
1298   { p->SetStaticLongField (this, cl0, fld1, val2); }
1299
1300   void SetStaticFloatField (jclass cl0, jfieldID fld1, jfloat val2)
1301   { p->SetStaticFloatField (this, cl0, fld1, val2); }
1302
1303   void SetStaticDoubleField (jclass cl0, jfieldID fld1, jdouble val2)
1304   { p->SetStaticDoubleField (this, cl0, fld1, val2); }
1305
1306   jstring NewString (const jchar * val0, jsize val1)
1307   { return p->NewString (this, val0, val1); }
1308
1309   jint GetStringLength (jstring val0)
1310   { return p->GetStringLength (this, val0); }
1311
1312   const jchar * GetStringChars (jstring val0, jboolean * val1)
1313   { return p->GetStringChars (this, val0, val1); }
1314
1315   void ReleaseStringChars (jstring val0, const jchar * val1)
1316   { p->ReleaseStringChars (this, val0, val1); }
1317
1318   jstring NewStringUTF (const char * val0)
1319   { return p->NewStringUTF (this, val0); }
1320
1321   jsize GetStringUTFLength (jstring val0)
1322   { return p->GetStringUTFLength (this, val0); }
1323
1324   const char * GetStringUTFChars (jstring val0, jboolean * val1)
1325   { return p->GetStringUTFChars (this, val0, val1); }
1326
1327   void ReleaseStringUTFChars (jstring val0, const char * val1)
1328   { p->ReleaseStringUTFChars (this, val0, val1); }
1329
1330   jsize GetArrayLength (jarray val0)
1331   { return p->GetArrayLength (this, val0); }
1332
1333   jobjectArray NewObjectArray (jsize val0, jclass cl1, jobject obj2)
1334   { return p->NewObjectArray (this, val0, cl1, obj2); }
1335
1336   jobject GetObjectArrayElement (jobjectArray val0, jsize val1)
1337   { return p->GetObjectArrayElement (this, val0, val1); }
1338
1339   void SetObjectArrayElement (jobjectArray val0, jsize val1, jobject obj2)
1340   { p->SetObjectArrayElement (this, val0, val1, obj2); }
1341
1342   jbooleanArray NewBooleanArray (jsize val0)
1343   { return p->NewBooleanArray (this, val0); }
1344
1345   jbyteArray NewByteArray (jsize val0)
1346   { return p->NewByteArray (this, val0); }
1347
1348   jcharArray NewCharArray (jsize val0)
1349   { return p->NewCharArray (this, val0); }
1350
1351   jshortArray NewShortArray (jsize val0)
1352   { return p->NewShortArray (this, val0); }
1353
1354   jintArray NewIntArray (jsize val0)
1355   { return p->NewIntArray (this, val0); }
1356
1357   jlongArray NewLongArray (jsize val0)
1358   { return p->NewLongArray (this, val0); }
1359
1360   jfloatArray NewFloatArray (jsize val0)
1361   { return p->NewFloatArray (this, val0); }
1362
1363   jdoubleArray NewDoubleArray (jsize val0)
1364   { return p->NewDoubleArray (this, val0); }
1365
1366   jboolean * GetBooleanArrayElements (jbooleanArray val0, jboolean * val1)
1367   { return p->GetBooleanArrayElements (this, val0, val1); }
1368
1369   jbyte * GetByteArrayElements (jbyteArray val0, jboolean * val1)
1370   { return p->GetByteArrayElements (this, val0, val1); }
1371
1372   jchar * GetCharArrayElements (jcharArray val0, jboolean * val1)
1373   { return p->GetCharArrayElements (this, val0, val1); }
1374
1375   jshort * GetShortArrayElements (jshortArray val0, jboolean * val1)
1376   { return p->GetShortArrayElements (this, val0, val1); }
1377
1378   jint * GetIntArrayElements (jintArray val0, jboolean * val1)
1379   { return p->GetIntArrayElements (this, val0, val1); }
1380
1381   jlong * GetLongArrayElements (jlongArray val0, jboolean * val1)
1382   { return p->GetLongArrayElements (this, val0, val1); }
1383
1384   jfloat * GetFloatArrayElements (jfloatArray val0, jboolean * val1)
1385   { return p->GetFloatArrayElements (this, val0, val1); }
1386
1387   jdouble * GetDoubleArrayElements (jdoubleArray val0, jboolean * val1)
1388   { return p->GetDoubleArrayElements (this, val0, val1); }
1389
1390   void ReleaseBooleanArrayElements (jbooleanArray val0, jboolean * val1, jint val2)
1391   { p->ReleaseBooleanArrayElements (this, val0, val1, val2); }
1392
1393   void ReleaseByteArrayElements (jbyteArray val0, jbyte * val1, jint val2)
1394   { p->ReleaseByteArrayElements (this, val0, val1, val2); }
1395
1396   void ReleaseCharArrayElements (jcharArray val0, jchar * val1, jint val2)
1397   { p->ReleaseCharArrayElements (this, val0, val1, val2); }
1398
1399   void ReleaseShortArrayElements (jshortArray val0, jshort * val1, jint val2)
1400   { p->ReleaseShortArrayElements (this, val0, val1, val2); }
1401
1402   void ReleaseIntArrayElements (jintArray val0, jint * val1, jint val2)
1403   { p->ReleaseIntArrayElements (this, val0, val1, val2); }
1404
1405   void ReleaseLongArrayElements (jlongArray val0, jlong * val1, jint val2)
1406   { p->ReleaseLongArrayElements (this, val0, val1, val2); }
1407
1408   void ReleaseFloatArrayElements (jfloatArray val0, jfloat * val1, jint val2)
1409   { p->ReleaseFloatArrayElements (this, val0, val1, val2); }
1410
1411   void ReleaseDoubleArrayElements (jdoubleArray val0, jdouble * val1, jint val2)
1412   { p->ReleaseDoubleArrayElements (this, val0, val1, val2); }
1413
1414   void GetBooleanArrayRegion (jbooleanArray val0, jsize val1, jsize val2, jboolean * val3)
1415   { p->GetBooleanArrayRegion (this, val0, val1, val2, val3); }
1416
1417   void GetByteArrayRegion (jbyteArray val0, jsize val1, jsize val2, jbyte * val3)
1418   { p->GetByteArrayRegion (this, val0, val1, val2, val3); }
1419
1420   void GetCharArrayRegion (jcharArray val0, jsize val1, jsize val2, jchar * val3)
1421   { p->GetCharArrayRegion (this, val0, val1, val2, val3); }
1422
1423   void GetShortArrayRegion (jshortArray val0, jsize val1, jsize val2, jshort * val3)
1424   { p->GetShortArrayRegion (this, val0, val1, val2, val3); }
1425
1426   void GetIntArrayRegion (jintArray val0, jsize val1, jsize val2, jint * val3)
1427   { p->GetIntArrayRegion (this, val0, val1, val2, val3); }
1428
1429   void GetLongArrayRegion (jlongArray val0, jsize val1, jsize val2, jlong * val3)
1430   { p->GetLongArrayRegion (this, val0, val1, val2, val3); }
1431
1432   void GetFloatArrayRegion (jfloatArray val0, jsize val1, jsize val2, jfloat * val3)
1433   { p->GetFloatArrayRegion (this, val0, val1, val2, val3); }
1434
1435   void GetDoubleArrayRegion (jdoubleArray val0, jsize val1, jsize val2, jdouble * val3)
1436   { p->GetDoubleArrayRegion (this, val0, val1, val2, val3); }
1437
1438   void SetBooleanArrayRegion (jbooleanArray val0, jsize val1, jsize val2, jboolean * val3)
1439   { p->SetBooleanArrayRegion (this, val0, val1, val2, val3); }
1440
1441   void SetByteArrayRegion (jbyteArray val0, jsize val1, jsize val2, jbyte * val3)
1442   { p->SetByteArrayRegion (this, val0, val1, val2, val3); }
1443
1444   void SetCharArrayRegion (jcharArray val0, jsize val1, jsize val2, jchar * val3)
1445   { p->SetCharArrayRegion (this, val0, val1, val2, val3); }
1446
1447   void SetShortArrayRegion (jshortArray val0, jsize val1, jsize val2, jshort * val3)
1448   { p->SetShortArrayRegion (this, val0, val1, val2, val3); }
1449
1450   void SetIntArrayRegion (jintArray val0, jsize val1, jsize val2, jint * val3)
1451   { p->SetIntArrayRegion (this, val0, val1, val2, val3); }
1452
1453   void SetLongArrayRegion (jlongArray val0, jsize val1, jsize val2, jlong * val3)
1454   { p->SetLongArrayRegion (this, val0, val1, val2, val3); }
1455
1456   void SetFloatArrayRegion (jfloatArray val0, jsize val1, jsize val2, jfloat * val3)
1457   { p->SetFloatArrayRegion (this, val0, val1, val2, val3); }
1458
1459   void SetDoubleArrayRegion (jdoubleArray val0, jsize val1, jsize val2, jdouble * val3)
1460   { p->SetDoubleArrayRegion (this, val0, val1, val2, val3); }
1461
1462   jint RegisterNatives (jclass cl0, const JNINativeMethod * val1, jint val2)
1463   { return p->RegisterNatives (this, cl0, val1, val2); }
1464
1465   jint UnregisterNatives (jclass cl0)
1466   { return p->UnregisterNatives (this, cl0); }
1467
1468   jint MonitorEnter (jobject obj0)
1469   { return p->MonitorEnter (this, obj0); }
1470
1471   jint MonitorExit (jobject obj0)
1472   { return p->MonitorExit (this, obj0); }
1473
1474   jint GetJavaVM (JavaVM ** val0)
1475   { return p->GetJavaVM (this, val0); }
1476
1477   void GetStringRegion (jstring val0, jsize val1, jsize val2, jchar * val3)
1478   { p->GetStringRegion (this, val0, val1, val2, val3); }
1479
1480   void GetStringUTFRegion (jstring val0, jsize val1, jsize val2, char * val3)
1481   { p->GetStringUTFRegion (this, val0, val1, val2, val3); }
1482
1483   void * GetPrimitiveArrayCritical (jarray val0, jboolean * val1)
1484   { return p->GetPrimitiveArrayCritical (this, val0, val1); }
1485
1486   void ReleasePrimitiveArrayCritical (jarray val0, void * val1, jint val2)
1487   { p->ReleasePrimitiveArrayCritical (this, val0, val1, val2); }
1488
1489   const jchar * GetStringCritical (jstring val0, jboolean * val1)
1490   { return p->GetStringCritical (this, val0, val1); }
1491
1492   void ReleaseStringCritical (jstring val0, const jchar * val1)
1493   { p->ReleaseStringCritical (this, val0, val1); }
1494
1495   jweak NewWeakGlobalRef (jobject obj0)
1496   { return p->NewWeakGlobalRef (this, obj0); }
1497
1498   void DeleteWeakGlobalRef (jweak val0)
1499   { p->DeleteWeakGlobalRef (this, val0); }
1500
1501   jboolean ExceptionCheck ()
1502   { return p->ExceptionCheck (this); }
1503
1504   jobject NewDirectByteBuffer (void *addr, jlong capacity)
1505   { return p->NewDirectByteBuffer (this, addr, capacity); }
1506
1507   void *GetDirectBufferAddress (jobject buf)
1508   { return p->GetDirectBufferAddress (this, buf); }
1509
1510   jlong GetDirectBufferCapacity (jobject buf)
1511   { return p->GetDirectBufferCapacity (this, buf); }
1512 };
1513
1514 #endif /* __cplusplus */
1515
1516 /*
1517  * Invocation API.
1518  */
1519
1520 struct JNIInvokeInterface
1521 {
1522   void *reserved0;
1523   void *reserved1;
1524   void *reserved2;
1525
1526   jint (JNICALL *DestroyJavaVM)         (JavaVM *);
1527   jint (JNICALL *AttachCurrentThread)   (JavaVM *, void **, void *);
1528   jint (JNICALL *DetachCurrentThread)   (JavaVM *);
1529   jint (JNICALL *GetEnv)                (JavaVM *, void **, jint);
1530   jint (JNICALL *AttachCurrentThreadAsDaemon) (JavaVM *, void **, void *);
1531 };
1532
1533 #ifdef __cplusplus
1534
1535 class _Jv_JavaVM
1536 {
1537 public:
1538   const struct JNIInvokeInterface *functions;
1539
1540   jint DestroyJavaVM ()
1541   { return functions->DestroyJavaVM (this); }
1542
1543   jint AttachCurrentThread (void **penv, void *args)
1544   { return functions->AttachCurrentThread (this, penv, args); }
1545
1546   jint DetachCurrentThread ()
1547   { return functions->DetachCurrentThread (this); }
1548
1549   jint GetEnv (void **penv, jint version)
1550   { return functions->GetEnv (this, penv, version); }
1551
1552   jint AttachCurrentThreadAsDaemon (void **penv, void *args)
1553   { return functions->AttachCurrentThreadAsDaemon (this, penv, args); }
1554 };
1555
1556 #endif /* __cplusplus */
1557
1558 typedef struct JavaVMAttachArgs
1559 {
1560   jint version;                 /* Must be JNI_VERSION_1_2.  */
1561   char *name;                   /* The name of the thread (or NULL).  */
1562   jobject group;                /* Global ref of a ThreadGroup object
1563                                    (or NULL).  */
1564 } JavaVMAttachArgs;
1565
1566 typedef struct JavaVMOption
1567 {
1568   char *optionString;
1569   void *extraInfo;
1570 } JavaVMOption;
1571
1572 typedef struct JavaVMInitArgs
1573 {
1574   /* Must be JNI_VERSION_1_2.  */
1575   jint version;
1576
1577   /* Number of options.  */
1578   jint nOptions;
1579
1580   /* Options to the VM.  */
1581   JavaVMOption *options;
1582
1583   /* Whether we should ignore unrecognized options.  */
1584   jboolean ignoreUnrecognized;
1585 } JavaVMInitArgs;
1586
1587
1588 \f
1589 /* Keep c-font-lock-extra-types in alphabetical order. */
1590 /* Local Variables: */
1591 /* c-font-lock-extra-types: ("\\sw+_t"
1592    "JNIEnv" "JNINativeMethod" "JavaVM" "JavaVMOption" "jarray"
1593    "jboolean" "jbooleanArray" "jbyte" "jbyteArray" "jchar"  "jcharArray"
1594    "jclass" "jdouble" "jdoubleArray" "jfieldID" "jfloat" "jfloatArray"
1595    "jint" "jintArray" "jlong" "jlongArray" "jmethodID" "jobject" "jstring" "jthrowable"
1596    "jvalue" "jweak") */
1597 /* End: */
1598
1599 #endif /* _CLASSPATH_JNI_H */