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