libjava/include/jni.h

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