libjava/include/jni.h

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