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