libjava/include/jni.h

   1 /* Copyright (C) 1998, 1999, 2000, 2001, 2002  Free Software Foundation
   2
   3    This file is part of libgcj.
   4
   5 This software is copyrighted work licensed under the terms of the
   6 Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
   7 details.  */
   8
   9 /* Note: this file must be compilable by the C compiler (for now,
  10    assuming GNU C is ok).  This means you must never use `//'
  11    comments, and all C++-specific code must be conditional on
  12    __cplusplus.  */
  13
  14 #ifndef __GCJ_JNI_H__
  15 #define __GCJ_JNI_H__
  16
  17 #include <gcj/libgcj-config.h>
  18
  19 /* We include <stdio.h> for compatibility with Sun's <jni.h>.  */
  20 #include <stdio.h>
  21
  22 #include <stdarg.h>
  23 #define _Jv_va_list va_list
  24
  25 #ifdef __GCJ_JNI_IMPL__
  26
  27 /* If __GCJ_JNI_IMPL__ is defined, then we assume that we're building
  28    libgcj itself, and we include headers which taint the namespace
  29    more than is acceptable for the ordinary JNI user.  */
  30 #include <gcj/javaprims.h>
  31 #include <gcj/array.h>
  32 #include <gnu/gcj/runtime/JNIWeakRef.h>
  33
  34 typedef gnu::gcj::runtime::JNIWeakRef *jweak;
  35
  36 typedef struct _Jv_JNIEnv JNIEnv;
  37 typedef struct _Jv_JavaVM JavaVM;
  38
  39 #define JNI_TRUE true
  40 #define JNI_FALSE false
  41
  42 #else /* __GCJ_JNI_IMPL__ */
  43
  44 # ifdef __GNUC__
  45
  46 /* If we're using gcc, we can use a platform-independent scheme to get
  47    the right integer types.  */
  48 typedef int    jbyte  __attribute__((__mode__(__QI__)));
  49 typedef int    jshort __attribute__((__mode__(__HI__)));
  50 typedef int    jint   __attribute__((__mode__(__SI__)));
  51 typedef int    jlong  __attribute__((__mode__(__DI__)));
  52 typedef int    jboolean __attribute__((__mode__(__QI__)));
  53 typedef unsigned short jchar __attribute__((__mode__(__HI__)));
  54 typedef float  jfloat;
  55 typedef double jdouble;
  56 typedef jint jsize;
  57
  58 # else /* __GNUC__ */
  59
  60 #  ifdef JV_HAVE_INTTYPES_H
  61
  62 /* If <inttypes.h> is available, we use it.  */
  63
  64 #   include <inttypes.h>
  65
  66 typedef int8_t jbyte;
  67 typedef int16_t jshort;
  68 typedef int32_t jint;
  69 typedef int64_t jlong;
  70 typedef float jfloat;
  71 typedef double jdouble;
  72 typedef jint jsize;
  73 typedef int8_t jboolean;
  74 typedef uint16_t jchar;
  75
  76 #  else /* JV_HAVE_INTTYPES_H */
  77
  78 /* For now, we require either gcc or <inttypes.h>.  If we did more
  79    work at configure time we could get around this, but right now it
  80    doesn't seem worth it.  */
  81 #   error jni.h not ported to this platform
  82
  83 #  endif /* JV_HAVE_INTTYPES_H */
  84
  85 # endif /* __GNUC__ */
  86
  87 # ifdef __cplusplus
  88
  89 /* Define dummy classes and then define the JNI types as pointers.  */
  90 struct __jobject {};
  91 struct __jclass : __jobject {};
  92 struct __jstring : __jobject {};
  93 struct __jthrowable : __jobject {};
  94 struct __jweak : __jobject {};
  95 struct __jarray : __jobject {};
  96 struct __jobjectArray : __jarray {};
  97 struct __jbyteArray : __jarray {};
  98 struct __jshortArray : __jarray {};
  99 struct __jintArray : __jarray {};
 100 struct __jlongArray : __jarray {};
 101 struct __jbooleanArray : __jarray {};
 102 struct __jcharArray : __jarray {};
 103 struct __jfloatArray : __jarray {};
 104 struct __jdoubleArray : __jarray {};
 105
 106 typedef __jobject *jobject;
 107 typedef __jclass *jclass;
 108 typedef __jstring *jstring;
 109 typedef __jthrowable *jthrowable;
 110 typedef __jweak *jweak;
 111 typedef __jarray *jarray;
 112 typedef __jobjectArray *jobjectArray;
 113 typedef __jbyteArray *jbyteArray;
 114 typedef __jshortArray *jshortArray;
 115 typedef __jintArray *jintArray;
 116 typedef __jlongArray *jlongArray;
 117 typedef __jbooleanArray *jbooleanArray;
 118 typedef __jcharArray *jcharArray;
 119 typedef __jfloatArray *jfloatArray;
 120 typedef __jdoubleArray *jdoubleArray;
 121
 122 #define JNI_TRUE true
 123 #define JNI_FALSE false
 124
 125 typedef struct _Jv_JNIEnv JNIEnv;
 126 typedef struct _Jv_JavaVM JavaVM;
 127
 128 # else /* __cplusplus */
 129
 130 /* For C, simply define the class types as generic pointers.  */
 131 typedef void *jobject;
 132 typedef jobject jclass;
 133 typedef jobject jstring;
 134 typedef jobject jthrowable;
 135 typedef jobject jweak;
 136 typedef jobject jarray;
 137 typedef jobject jobjectArray;
 138 typedef jobject jbyteArray;
 139 typedef jobject jshortArray;
 140 typedef jobject jintArray;
 141 typedef jobject jlongArray;
 142 typedef jobject jbooleanArray;
 143 typedef jobject jcharArray;
 144 typedef jobject jfloatArray;
 145 typedef jobject jdoubleArray;
 146
 147 #define JNI_TRUE  1
 148 #define JNI_FALSE 0
 149
 150 typedef const struct JNINativeInterface *JNIEnv;
 151 typedef const struct JNIInvokeInterface *JavaVM;
 152
 153 # endif /* __cplusplus */
 154
 155 /* Dummy defines.  */
 156 typedef void *jfieldID;
 157 typedef void *jmethodID;
 158
 159 #endif /* __GCJ_JNI_IMPL__ */
 160
 161 /* Version numbers.  */
 162 #define JNI_VERSION_1_1 0x00010001
 163 #define JNI_VERSION_1_2 0x00010002
 164 #define JNI_VERSION_1_4 0x00010004
 165
 166 /* Used when releasing array elements.  */
 167 #define JNI_COMMIT 1
 168 #define JNI_ABORT  2
 169
 170 /* Error codes */
 171 #define JNI_OK            0
 172 #define JNI_ERR          -1
 173 #define JNI_EDETACHED    -2
 174 #define JNI_EVERSION     -3
 175
 176 /* Linkage and calling conventions. */
 177 #if defined (_WIN32) || defined (__WIN32__) || defined (WIN32)
 178
 179 #define JNIIMPORT        __declspec(dllimport)
 180 #define JNIEXPORT        __declspec(dllexport)
 181
 182 #define JNICALL          __stdcall
 183
 184 /* These defines apply to symbols in libgcj */
 185 #ifdef __GCJ_DLL__
 186 # ifdef __GCJ_JNI_IMPL__
 187 #  define __GCJ_JNIIMPEXP__ JNIEXPORT
 188 # else
 189 #  define __GCJ_JNIIMPEXP__ JNIIMPORT
 190 # endif /* ! __GCJ_JNI_IMPL__ */
 191 #else /* ! __GCJ_DLL__ */
 192 # define __GCJ_JNIIMPEXP__
 193 #endif /*  __GCJ_DLL__ */
 194
 195 #else /* !( _WIN32 || __WIN32__ || WIN32) */
 196
 197 #define JNIIMPORT
 198 #define JNIEXPORT
 199 #define JNICALL
 200 #define __GCJ_JNIIMPEXP__
 201
 202 #endif /* !( _WIN32 || __WIN32__ || WIN32) */
 203
 204
 205 #ifdef __cplusplus
 206 extern "C"
 207 {
 208 #endif /* __cplusplus */
 209
 210 /* These functions might be defined in libraries which we load; the
 211    JNI implementation calls them at the appropriate times.  */
 212 extern JNIEXPORT jint JNICALL JNI_OnLoad (JavaVM *, void *);
 213 extern JNIEXPORT void JNICALL JNI_OnUnload (JavaVM *, void *);
 214
 215 /* These functions are called by user code to start using the
 216    invocation API.  */
 217 extern __GCJ_JNIIMPEXP__ jint JNICALL
 218 JNI_GetDefaultJavaVMInitArgs (void *);
 219
 220 extern __GCJ_JNIIMPEXP__ jint JNICALL
 221 JNI_CreateJavaVM (JavaVM **, void **, void *);
 222
 223 extern __GCJ_JNIIMPEXP__ jint JNICALL
 224 JNI_GetCreatedJavaVMs(JavaVM **, jsize, jsize *);
 225
 226 #ifdef __cplusplus
 227 }
 228 #endif /* __cplusplus */
 229
 230 typedef union jvalue
 231 {
 232   jboolean z;
 233   jbyte    b;
 234   jchar    c;
 235   jshort   s;
 236   jint     i;
 237   jlong    j;
 238   jfloat   f;
 239   jdouble  d;
 240   jobject  l;
 241 } jvalue;
 242
 243 #ifdef __cplusplus
 244 typedef void * (*_Jv_func) (...);
 245 #else
 246 typedef void * (*_Jv_func) ();
 247 #endif
 248
 249 /* This structure is used when registering native methods.  */
 250 typedef struct
 251 {
 252   char *name;
 253   char *signature;
 254   void *fnPtr;                  /* Sigh.  */
 255 } JNINativeMethod;
 256
 257 struct JNINativeInterface
 258 {
 259   _Jv_func reserved0;
 260   _Jv_func reserved1;
 261   _Jv_func reserved2;
 262   _Jv_func reserved3;
 263
 264   jint     (JNICALL *GetVersion)                   (JNIEnv *);
 265   jclass   (JNICALL *DefineClass)                  (JNIEnv *, const char *,
 266                                                     jobject, const jbyte *,
 267                                                     jsize);
 268   jclass   (JNICALL *FindClass)                    (JNIEnv *, const char *);
 269
 270   jmethodID (JNICALL *FromReflectedMethod)         (JNIEnv *, jobject);
 271   jfieldID  (JNICALL *FromReflectedField)          (JNIEnv *, jobject);
 272   jobject   (JNICALL *ToReflectedMethod)           (JNIEnv *, jclass,
 273                                                     jmethodID, jboolean);
 274
 275   jclass   (JNICALL *GetSuperclass)                (JNIEnv *, jclass);
 276   jboolean (JNICALL *IsAssignableFrom)             (JNIEnv *, jclass, jclass);
 277
 278   jobject  (JNICALL *ToReflectedField)             (JNIEnv *, jclass, jfieldID,
 279                                                     jboolean);
 280
 281   jint     (JNICALL *Throw)                        (JNIEnv *, jthrowable);
 282   jint     (JNICALL *ThrowNew)                     (JNIEnv *, jclass,
 283                                                     const char *);
 284   jthrowable (JNICALL *ExceptionOccurred)          (JNIEnv *);
 285   void     (JNICALL *ExceptionDescribe)            (JNIEnv *);
 286   void     (JNICALL *ExceptionClear)               (JNIEnv *);
 287   void     (JNICALL *FatalError)                   (JNIEnv *, const char *);
 288
 289   jint     (JNICALL *PushLocalFrame)               (JNIEnv *, jint);
 290   jobject  (JNICALL *PopLocalFrame)                (JNIEnv *, jobject);
 291
 292   jobject  (JNICALL *NewGlobalRef)                 (JNIEnv *, jobject);
 293   void     (JNICALL *DeleteGlobalRef)              (JNIEnv *, jobject);
 294   void     (JNICALL *DeleteLocalRef)               (JNIEnv *, jobject);
 295   jboolean (JNICALL *IsSameObject)                 (JNIEnv *, jobject,
 296                                                     jobject);
 297
 298   jobject  (JNICALL *NewLocalRef)                  (JNIEnv *, jobject);
 299   jint     (JNICALL *EnsureLocalCapacity)          (JNIEnv *, jint);
 300
 301   jobject  (JNICALL *AllocObject)                  (JNIEnv *, jclass);
 302   jobject (JNICALL *NewObject)                     (JNIEnv *, jclass,
 303                                                     jmethodID, ...);
 304   jobject (JNICALL *NewObjectV)                    (JNIEnv *, jclass,
 305                                                     jmethodID, _Jv_va_list);
 306   jobject (JNICALL *NewObjectA)                    (JNIEnv *, jclass,
 307                                                     jmethodID, jvalue *);
 308
 309   jclass   (JNICALL *GetObjectClass)               (JNIEnv *, jobject);
 310   jboolean (JNICALL *IsInstanceOf)                 (JNIEnv *, jobject, jclass);
 311   jmethodID (JNICALL *GetMethodID)                 (JNIEnv *, jclass,
 312                                                     const char *, const char *);
 313
 314   jobject (JNICALL *CallObjectMethod)      (JNIEnv *, jobject, jmethodID, ...);
 315   jobject (JNICALL *CallObjectMethodV)     (JNIEnv *, jobject, jmethodID,
 316                                             _Jv_va_list);
 317   jobject (JNICALL *CallObjectMethodA)     (JNIEnv *, jobject, jmethodID,
 318                                             jvalue *);
 319   jboolean (JNICALL *CallBooleanMethod)    (JNIEnv *, jobject, jmethodID,
 320                                             ...);
 321   jboolean (JNICALL *CallBooleanMethodV)   (JNIEnv *, jobject, jmethodID,
 322                                             _Jv_va_list);
 323   jboolean (JNICALL *CallBooleanMethodA)   (JNIEnv *, jobject, jmethodID,
 324                                             jvalue *);
 325   jbyte (JNICALL *CallByteMethod)   (JNIEnv *, jobject, jmethodID, ...);
 326   jbyte (JNICALL *CallByteMethodV)         (JNIEnv *, jobject, jmethodID,
 327                                             _Jv_va_list);
 328   jbyte (JNICALL *CallByteMethodA)         (JNIEnv *, jobject, jmethodID,
 329                                             jvalue *);
 330   jchar (JNICALL *CallCharMethod)          (JNIEnv *, jobject, jmethodID, ...);
 331   jchar (JNICALL *CallCharMethodV)         (JNIEnv *, jobject, jmethodID,
 332                                             _Jv_va_list);
 333   jchar (JNICALL *CallCharMethodA)         (JNIEnv *, jobject, jmethodID,
 334                                             jvalue *);
 335   jshort (JNICALL *CallShortMethod)        (JNIEnv *, jobject, jmethodID, ...);
 336   jshort (JNICALL *CallShortMethodV)       (JNIEnv *, jobject, jmethodID,
 337                                             _Jv_va_list);
 338   jshort (JNICALL *CallShortMethodA)       (JNIEnv *, jobject, jmethodID,
 339                                             jvalue *);
 340   jint  (JNICALL *CallIntMethod)           (JNIEnv *, jobject, jmethodID, ...);
 341   jint  (JNICALL *CallIntMethodV)          (JNIEnv *, jobject, jmethodID,
 342                                             _Jv_va_list);
 343   jint  (JNICALL *CallIntMethodA)          (JNIEnv *, jobject, jmethodID,
 344                                             jvalue *);
 345   jlong (JNICALL *CallLongMethod)          (JNIEnv *, jobject, jmethodID, ...);
 346   jlong (JNICALL *CallLongMethodV)         (JNIEnv *, jobject, jmethodID,
 347                                             _Jv_va_list);
 348   jlong (JNICALL *CallLongMethodA)         (JNIEnv *, jobject, jmethodID,
 349                                             jvalue *);
 350   jfloat (JNICALL *CallFloatMethod)        (JNIEnv *, jobject, jmethodID, ...);
 351   jfloat (JNICALL *CallFloatMethodV)       (JNIEnv *, jobject, jmethodID,
 352                                             _Jv_va_list);
 353   jfloat (JNICALL *CallFloatMethodA)       (JNIEnv *, jobject, jmethodID,
 354                                             jvalue *);
 355   jdouble (JNICALL *CallDoubleMethod)      (JNIEnv *, jobject, jmethodID, ...);
 356   jdouble (JNICALL *CallDoubleMethodV)     (JNIEnv *, jobject, jmethodID,
 357                                             _Jv_va_list);
 358   jdouble (JNICALL *CallDoubleMethodA)     (JNIEnv *, jobject, jmethodID,
 359                                             jvalue *);
 360   void  (JNICALL *CallVoidMethod)          (JNIEnv *, jobject, jmethodID, ...);
 361   void  (JNICALL *CallVoidMethodV)         (JNIEnv *, jobject, jmethodID,
 362                                             _Jv_va_list);
 363   void  (JNICALL *CallVoidMethodA)         (JNIEnv *, jobject, jmethodID,
 364                                             jvalue *);
 365
 366   jobject   (JNICALL *CallNonvirtualObjectMethod)  (JNIEnv *, jobject, jclass,
 367                                                     jmethodID, ...);
 368   jobject   (JNICALL *CallNonvirtualObjectMethodV) (JNIEnv *, jobject, jclass,
 369                                                     jmethodID, _Jv_va_list);
 370   jobject   (JNICALL *CallNonvirtualObjectMethodA) (JNIEnv *, jobject, jclass,
 371                                                     jmethodID, jvalue *);
 372   jboolean  (JNICALL *CallNonvirtualBooleanMethod) (JNIEnv *, jobject, jclass,
 373                                                     jmethodID, ...);
 374   jboolean  (JNICALL *CallNonvirtualBooleanMethodV) (JNIEnv *, jobject, jclass,
 375                                                      jmethodID, _Jv_va_list);
 376   jboolean  (JNICALL *CallNonvirtualBooleanMethodA) (JNIEnv *, jobject, jclass,
 377                                                      jmethodID, jvalue *);
 378   jbyte     (JNICALL *CallNonvirtualByteMethod)    (JNIEnv *, jobject, jclass,
 379                                                     jmethodID, ...);
 380   jbyte     (JNICALL *CallNonvirtualByteMethodV)   (JNIEnv *, jobject, jclass,
 381                                                     jmethodID, _Jv_va_list);
 382   jbyte     (JNICALL *CallNonvirtualByteMethodA)   (JNIEnv *, jobject, jclass,
 383                                                     jmethodID, jvalue *);
 384   jchar     (JNICALL *CallNonvirtualCharMethod)    (JNIEnv *, jobject, jclass,
 385                                                     jmethodID, ...);
 386   jchar     (JNICALL *CallNonvirtualCharMethodV)   (JNIEnv *, jobject, jclass,
 387                                                     jmethodID, _Jv_va_list);
 388   jchar     (JNICALL *CallNonvirtualCharMethodA)   (JNIEnv *, jobject, jclass,
 389                                                     jmethodID, jvalue *);
 390   jshort    (JNICALL *CallNonvirtualShortMethod)   (JNIEnv *, jobject, jclass,
 391                                                     jmethodID, ...);
 392   jshort    (JNICALL *CallNonvirtualShortMethodV)  (JNIEnv *, jobject, jclass,
 393                                                     jmethodID, _Jv_va_list);
 394   jshort    (JNICALL *CallNonvirtualShortMethodA)  (JNIEnv *, jobject, jclass,
 395                                                     jmethodID, jvalue *);
 396   jint      (JNICALL *CallNonvirtualIntMethod)     (JNIEnv *, jobject, jclass,
 397                                                     jmethodID, ...);
 398   jint      (JNICALL *CallNonvirtualIntMethodV)    (JNIEnv *, jobject, jclass,
 399                                                     jmethodID, _Jv_va_list);
 400   jint      (JNICALL *CallNonvirtualIntMethodA)    (JNIEnv *, jobject, jclass,
 401                                                     jmethodID, jvalue *);
 402   jlong     (JNICALL *CallNonvirtualLongMethod)    (JNIEnv *, jobject, jclass,
 403                                                     jmethodID, ...);
 404   jlong     (JNICALL *CallNonvirtualLongMethodV)   (JNIEnv *, jobject, jclass,
 405                                                     jmethodID, _Jv_va_list);
 406   jlong     (JNICALL *CallNonvirtualLongMethodA)   (JNIEnv *, jobject, jclass,
 407                                                     jmethodID, jvalue *);
 408   jfloat    (JNICALL *CallNonvirtualFloatMethod)   (JNIEnv *, jobject, jclass,
 409                                                     jmethodID, ...);
 410   jfloat    (JNICALL *CallNonvirtualFloatMethodV)  (JNIEnv *, jobject, jclass,
 411                                                     jmethodID, _Jv_va_list);
 412   jfloat    (JNICALL *CallNonvirtualFloatMethodA)  (JNIEnv *, jobject, jclass,
 413                                                     jmethodID, jvalue *);
 414   jdouble   (JNICALL *CallNonvirtualDoubleMethod)  (JNIEnv *, jobject, jclass,
 415                                                     jmethodID, ...);
 416   jdouble   (JNICALL *CallNonvirtualDoubleMethodV) (JNIEnv *, jobject, jclass,
 417                                                     jmethodID, _Jv_va_list);
 418   jdouble   (JNICALL *CallNonvirtualDoubleMethodA) (JNIEnv *, jobject, jclass,
 419                                                     jmethodID, jvalue *);
 420   void      (JNICALL *CallNonvirtualVoidMethod)    (JNIEnv *, jobject, jclass,
 421                                                     jmethodID, ...);
 422   void      (JNICALL *CallNonvirtualVoidMethodV)   (JNIEnv *, jobject, jclass,
 423                                                     jmethodID, _Jv_va_list);
 424   void      (JNICALL *CallNonvirtualVoidMethodA)   (JNIEnv *, jobject, jclass,
 425                                                     jmethodID, jvalue *);
 426
 427   jfieldID  (JNICALL *GetFieldID)          (JNIEnv *, jclass, const char *,
 428                                             const char *);
 429
 430   jobject  (JNICALL *GetObjectField)       (JNIEnv *, jobject, jfieldID);
 431   jboolean (JNICALL *GetBooleanField)      (JNIEnv *, jobject, jfieldID);
 432   jbyte    (JNICALL *GetByteField)         (JNIEnv *, jobject, jfieldID);
 433   jchar    (JNICALL *GetCharField)         (JNIEnv *, jobject, jfieldID);
 434   jshort   (JNICALL *GetShortField)        (JNIEnv *, jobject, jfieldID);
 435   jint     (JNICALL *GetIntField)          (JNIEnv *, jobject, jfieldID);
 436   jlong    (JNICALL *GetLongField)         (JNIEnv *, jobject, jfieldID);
 437   jfloat   (JNICALL *GetFloatField)        (JNIEnv *, jobject, jfieldID);
 438   jdouble  (JNICALL *GetDoubleField)       (JNIEnv *, jobject, jfieldID);
 439
 440   void  (JNICALL *SetObjectField)          (JNIEnv *, jobject,
 441                                             jfieldID, jobject);
 442   void  (JNICALL *SetBooleanField)         (JNIEnv *, jobject,
 443                                             jfieldID, jboolean);
 444   void  (JNICALL *SetByteField)            (JNIEnv *, jobject,
 445                                             jfieldID, jbyte);
 446   void  (JNICALL *SetCharField)            (JNIEnv *, jobject,
 447                                             jfieldID, jchar);
 448   void  (JNICALL *SetShortField)           (JNIEnv *, jobject,
 449                                             jfieldID, jshort);
 450   void  (JNICALL *SetIntField)             (JNIEnv *, jobject,
 451                                             jfieldID, jint);
 452   void  (JNICALL *SetLongField)            (JNIEnv *, jobject,
 453                                             jfieldID, jlong);
 454   void  (JNICALL *SetFloatField)           (JNIEnv *, jobject,
 455                                             jfieldID, jfloat);
 456   void  (JNICALL *SetDoubleField)          (JNIEnv *, jobject,
 457                                             jfieldID, jdouble);
 458
 459   jmethodID (JNICALL *GetStaticMethodID)   (JNIEnv *, jclass, const char *,
 460                                             const char *);
 461
 462   jobject  (JNICALL *CallStaticObjectMethod)  (JNIEnv *, jclass, jmethodID,
 463                                                ...);
 464   jobject  (JNICALL *CallStaticObjectMethodV) (JNIEnv *, jclass, jmethodID,
 465                                                _Jv_va_list);
 466   jobject  (JNICALL *CallStaticObjectMethodA) (JNIEnv *, jclass, jmethodID,
 467                                                jvalue *);
 468   jboolean (JNICALL *CallStaticBooleanMethod) (JNIEnv *, jclass, jmethodID,
 469                                                ...);
 470   jboolean (JNICALL *CallStaticBooleanMethodV) (JNIEnv *, jclass, jmethodID,
 471                                                 _Jv_va_list);
 472   jboolean (JNICALL *CallStaticBooleanMethodA) (JNIEnv *, jclass, jmethodID,
 473                                                 jvalue *);
 474   jbyte    (JNICALL *CallStaticByteMethod)    (JNIEnv *, jclass, jmethodID,
 475                                                ...);
 476   jbyte    (JNICALL *CallStaticByteMethodV)   (JNIEnv *, jclass, jmethodID,
 477                                                _Jv_va_list);
 478   jbyte    (JNICALL *CallStaticByteMethodA)   (JNIEnv *, jclass, jmethodID,
 479                                                jvalue *);
 480   jchar    (JNICALL *CallStaticCharMethod)    (JNIEnv *, jclass, jmethodID,
 481                                                ...);
 482   jchar    (JNICALL *CallStaticCharMethodV)   (JNIEnv *, jclass, jmethodID,
 483                                                _Jv_va_list);
 484   jchar    (JNICALL *CallStaticCharMethodA)   (JNIEnv *, jclass, jmethodID,
 485                                                jvalue *);
 486   jshort   (JNICALL *CallStaticShortMethod)   (JNIEnv *, jclass, jmethodID,
 487                                                ...);
 488   jshort   (JNICALL *CallStaticShortMethodV)  (JNIEnv *, jclass, jmethodID,
 489                                                _Jv_va_list);
 490   jshort   (JNICALL *CallStaticShortMethodA)  (JNIEnv *, jclass, jmethodID,
 491                                                jvalue *);
 492   jint     (JNICALL *CallStaticIntMethod)     (JNIEnv *, jclass, jmethodID,
 493                                                ...);
 494   jint     (JNICALL *CallStaticIntMethodV)    (JNIEnv *, jclass, jmethodID,
 495                                                _Jv_va_list);
 496   jint     (JNICALL *CallStaticIntMethodA)    (JNIEnv *, jclass, jmethodID,
 497                                                jvalue *);
 498   jlong    (JNICALL *CallStaticLongMethod)    (JNIEnv *, jclass, jmethodID,
 499                                                ...);
 500   jlong    (JNICALL *CallStaticLongMethodV)   (JNIEnv *, jclass, jmethodID,
 501                                                _Jv_va_list);
 502   jlong    (JNICALL *CallStaticLongMethodA)   (JNIEnv *, jclass, jmethodID,
 503                                                jvalue *);
 504   jfloat   (JNICALL *CallStaticFloatMethod)   (JNIEnv *, jclass, jmethodID,
 505                                                ...);
 506   jfloat   (JNICALL *CallStaticFloatMethodV)  (JNIEnv *, jclass, jmethodID,
 507                                                _Jv_va_list);
 508   jfloat   (JNICALL *CallStaticFloatMethodA)  (JNIEnv *, jclass, jmethodID,
 509                                                jvalue *);
 510   jdouble  (JNICALL *CallStaticDoubleMethod)  (JNIEnv *, jclass, jmethodID,
 511                                                ...);
 512   jdouble  (JNICALL *CallStaticDoubleMethodV) (JNIEnv *, jclass, jmethodID,
 513                                                _Jv_va_list);
 514   jdouble  (JNICALL *CallStaticDoubleMethodA) (JNIEnv *, jclass, jmethodID,
 515                                                jvalue *);
 516   void     (JNICALL *CallStaticVoidMethod)    (JNIEnv *, jclass, jmethodID,
 517                                                ...);
 518   void     (JNICALL *CallStaticVoidMethodV)   (JNIEnv *, jclass, jmethodID,
 519                                                _Jv_va_list);
 520   void     (JNICALL *CallStaticVoidMethodA)   (JNIEnv *, jclass, jmethodID,
 521                                                jvalue *);
 522
 523   jfieldID (JNICALL *GetStaticFieldID)        (JNIEnv *, jclass, const char *,
 524                                                const char *);
 525
 526   jobject  (JNICALL *GetStaticObjectField)    (JNIEnv *, jclass, jfieldID);
 527   jboolean (JNICALL *GetStaticBooleanField)   (JNIEnv *, jclass, jfieldID);
 528   jbyte    (JNICALL *GetStaticByteField)      (JNIEnv *, jclass, jfieldID);
 529   jchar    (JNICALL *GetStaticCharField)      (JNIEnv *, jclass, jfieldID);
 530   jshort   (JNICALL *GetStaticShortField)     (JNIEnv *, jclass, jfieldID);
 531   jint     (JNICALL *GetStaticIntField)       (JNIEnv *, jclass, jfieldID);
 532   jlong    (JNICALL *GetStaticLongField)      (JNIEnv *, jclass, jfieldID);
 533   jfloat   (JNICALL *GetStaticFloatField)     (JNIEnv *, jclass, jfieldID);
 534   jdouble  (JNICALL *GetStaticDoubleField)    (JNIEnv *, jclass, jfieldID);
 535
 536   void  (JNICALL *SetStaticObjectField)    (JNIEnv *, jclass,
 537                                             jfieldID, jobject);
 538   void  (JNICALL *SetStaticBooleanField)   (JNIEnv *, jclass,
 539                                             jfieldID, jboolean);
 540   void  (JNICALL *SetStaticByteField)      (JNIEnv *, jclass,
 541                                             jfieldID, jbyte);
 542   void  (JNICALL *SetStaticCharField)      (JNIEnv *, jclass,
 543                                             jfieldID, jchar);
 544   void  (JNICALL *SetStaticShortField)     (JNIEnv *, jclass,
 545                                             jfieldID, jshort);
 546   void  (JNICALL *SetStaticIntField)       (JNIEnv *, jclass,
 547                                             jfieldID, jint);
 548   void  (JNICALL *SetStaticLongField)      (JNIEnv *, jclass,
 549                                             jfieldID, jlong);
 550   void  (JNICALL *SetStaticFloatField)     (JNIEnv *, jclass,
 551                                             jfieldID, jfloat);
 552   void  (JNICALL *SetStaticDoubleField)    (JNIEnv *, jclass,
 553                                             jfieldID, jdouble);
 554
 555   jstring  (JNICALL *NewString)            (JNIEnv *, const jchar *, jsize);
 556   jsize    (JNICALL *GetStringLength)      (JNIEnv *, jstring);
 557   const jchar * (JNICALL *GetStringChars)  (JNIEnv *, jstring, jboolean *);
 558   void     (JNICALL *ReleaseStringChars)   (JNIEnv *, jstring, const jchar *);
 559   jstring  (JNICALL *NewStringUTF)         (JNIEnv *, const char *);
 560   jsize    (JNICALL *GetStringUTFLength)   (JNIEnv *, jstring);
 561   const char * (JNICALL *GetStringUTFChars) (JNIEnv *, jstring, jboolean *);
 562   void     (JNICALL *ReleaseStringUTFChars) (JNIEnv *, jstring, const char *);
 563   jsize    (JNICALL *GetArrayLength)       (JNIEnv *, jarray);
 564   jarray   (JNICALL *NewObjectArray)       (JNIEnv *, jsize, jclass, jobject);
 565   jobject  (JNICALL *GetObjectArrayElement) (JNIEnv *, jobjectArray, jsize);
 566   void     (JNICALL *SetObjectArrayElement) (JNIEnv *, jobjectArray, jsize,
 567                                              jobject);
 568
 569   jbooleanArray (JNICALL *NewBooleanArray)         (JNIEnv *, jsize);
 570   jbyteArray    (JNICALL *NewByteArray)            (JNIEnv *, jsize);
 571   jcharArray    (JNICALL *NewCharArray)            (JNIEnv *, jsize);
 572   jshortArray   (JNICALL *NewShortArray)           (JNIEnv *, jsize);
 573   jintArray     (JNICALL *NewIntArray)             (JNIEnv *, jsize);
 574   jlongArray    (JNICALL *NewLongArray)            (JNIEnv *, jsize);
 575   jfloatArray   (JNICALL *NewFloatArray)           (JNIEnv *, jsize);
 576   jdoubleArray  (JNICALL *NewDoubleArray)          (JNIEnv *, jsize);
 577
 578   jboolean *    (JNICALL *GetBooleanArrayElements) (JNIEnv *, jbooleanArray,
 579                                                     jboolean *);
 580   jbyte *       (JNICALL *GetByteArrayElements)    (JNIEnv *, jbyteArray,
 581                                                     jboolean *);
 582   jchar *       (JNICALL *GetCharArrayElements)    (JNIEnv *, jcharArray,
 583                                                     jboolean *);
 584   jshort *      (JNICALL *GetShortArrayElements)   (JNIEnv *, jshortArray,
 585                                                     jboolean *);
 586   jint *        (JNICALL *GetIntArrayElements)     (JNIEnv *, jintArray,
 587                                                     jboolean *);
 588   jlong *       (JNICALL *GetLongArrayElements)    (JNIEnv *, jlongArray,
 589                                                     jboolean *);
 590   jfloat *      (JNICALL *GetFloatArrayElements)   (JNIEnv *, jfloatArray,
 591                                                     jboolean *);
 592   jdouble *     (JNICALL *GetDoubleArrayElements)  (JNIEnv *, jdoubleArray,
 593                                                     jboolean *);
 594
 595   void          (JNICALL *ReleaseBooleanArrayElements) (JNIEnv *, jbooleanArray,
 596                                                         jboolean *, jint);
 597   void          (JNICALL *ReleaseByteArrayElements)    (JNIEnv *, jbyteArray,
 598                                                         jbyte *, jint);
 599   void          (JNICALL *ReleaseCharArrayElements)    (JNIEnv *, jcharArray,
 600                                                         jchar *, jint);
 601   void          (JNICALL *ReleaseShortArrayElements)   (JNIEnv *, jshortArray,
 602                                                         jshort *, jint);
 603   void          (JNICALL *ReleaseIntArrayElements)     (JNIEnv *, jintArray,
 604                                                         jint *, jint);
 605   void          (JNICALL *ReleaseLongArrayElements)    (JNIEnv *, jlongArray,
 606                                                         jlong *, jint);
 607   void          (JNICALL *ReleaseFloatArrayElements)   (JNIEnv *, jfloatArray,
 608                                                         jfloat *, jint);
 609   void          (JNICALL *ReleaseDoubleArrayElements)  (JNIEnv *, jdoubleArray,
 610                                                         jdouble *, jint);
 611
 612   void          (JNICALL *GetBooleanArrayRegion)   (JNIEnv *, jbooleanArray,
 613                                                     jsize, jsize, jboolean *);
 614   void          (JNICALL *GetByteArrayRegion)      (JNIEnv *, jbyteArray,
 615                                                     jsize, jsize, jbyte *);
 616   void          (JNICALL *GetCharArrayRegion)      (JNIEnv *, jcharArray,
 617                                                     jsize, jsize, jchar *);
 618   void          (JNICALL *GetShortArrayRegion)     (JNIEnv *, jshortArray,
 619                                                     jsize, jsize, jshort *);
 620   void          (JNICALL *GetIntArrayRegion)       (JNIEnv *, jintArray,
 621                                                     jsize, jsize, jint *);
 622   void          (JNICALL *GetLongArrayRegion)      (JNIEnv *, jlongArray,
 623                                                     jsize, jsize, jlong *);
 624   void          (JNICALL *GetFloatArrayRegion)     (JNIEnv *, jfloatArray,
 625                                                     jsize, jsize, jfloat *);
 626   void          (JNICALL *GetDoubleArrayRegion)    (JNIEnv *, jdoubleArray,
 627                                                     jsize, jsize, jdouble *);
 628
 629   void          (JNICALL *SetBooleanArrayRegion)   (JNIEnv *, jbooleanArray,
 630                                                     jsize, jsize, jboolean *);
 631   void          (JNICALL *SetByteArrayRegion)      (JNIEnv *, jbyteArray,
 632                                                     jsize, jsize, jbyte *);
 633   void          (JNICALL *SetCharArrayRegion)      (JNIEnv *, jcharArray,
 634                                                     jsize, jsize, jchar *);
 635   void          (JNICALL *SetShortArrayRegion)     (JNIEnv *, jshortArray,
 636                                                     jsize, jsize, jshort *);
 637   void          (JNICALL *SetIntArrayRegion)       (JNIEnv *, jintArray,
 638                                                     jsize, jsize, jint *);
 639   void          (JNICALL *SetLongArrayRegion)      (JNIEnv *, jlongArray,
 640                                                     jsize, jsize, jlong *);
 641   void          (JNICALL *SetFloatArrayRegion)     (JNIEnv *, jfloatArray,
 642                                                     jsize, jsize, jfloat *);
 643   void          (JNICALL *SetDoubleArrayRegion)    (JNIEnv *, jdoubleArray,
 644                                                     jsize, jsize, jdouble *);
 645
 646   jint     (JNICALL *RegisterNatives)              (JNIEnv *, jclass,
 647                                                     const JNINativeMethod *,
 648                                                     jint);
 649   jint     (JNICALL *UnregisterNatives)            (JNIEnv *, jclass);
 650   jint     (JNICALL *MonitorEnter)                 (JNIEnv *, jobject);
 651   jint     (JNICALL *MonitorExit)                  (JNIEnv *, jobject);
 652   jint     (JNICALL *GetJavaVM)                    (JNIEnv *, JavaVM **);
 653
 654   void     (JNICALL *GetStringRegion)              (JNIEnv *, jstring, jsize,
 655                                                     jsize, jchar *);
 656   void     (JNICALL *GetStringUTFRegion)           (JNIEnv *, jstring, jsize,
 657                                                     jsize, char *);
 658
 659   void * (JNICALL *GetPrimitiveArrayCritical)      (JNIEnv *, jarray,
 660                                                     jboolean *);
 661   void   (JNICALL *ReleasePrimitiveArrayCritical)  (JNIEnv *, jarray, void *,
 662                                                     jint);
 663
 664   const jchar * (JNICALL *GetStringCritical)       (JNIEnv *, jstring,
 665                                                     jboolean *);
 666   void          (JNICALL *ReleaseStringCritical)   (JNIEnv *, jstring,
 667                                                     const jchar *);
 668
 669   jweak  (JNICALL *NewWeakGlobalRef)               (JNIEnv *, jobject);
 670   void   (JNICALL *DeleteWeakGlobalRef)            (JNIEnv *, jweak);
 671
 672   jboolean      (JNICALL *ExceptionCheck)          (JNIEnv *);
 673
 674   jobject (JNICALL *NewDirectByteBuffer)           (JNIEnv *, void *, jlong);
 675   void *  (JNICALL *GetDirectBufferAddress)        (JNIEnv *, jobject);
 676   jlong   (JNICALL *GetDirectBufferCapacity)       (JNIEnv *, jobject);
 677 };
 678
 679 #ifdef __cplusplus
 680
 681 class _Jv_JNIEnv
 682 {
 683 public:
 684   /* The method table.  */
 685   struct JNINativeInterface *p;
 686
 687   /* This is ugly, but we must live with it.  */
 688 #ifndef __GCJ_JNI_IMPL__
 689 private:
 690 #endif
 691   /* The current exception.  */
 692   jthrowable ex;
 693
 694   /* The class of the current native method.  */
 695   jclass klass;
 696
 697   /* The chain of local frames.  */
 698   struct _Jv_JNI_LocalFrame *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   jarray 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   _Jv_func reserved0;
1578   _Jv_func reserved1;
1579   _Jv_func 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__ */