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