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