jdk8-mips64-public/hotspot: src/share/vm/prims/jni.h@710a3c8b516e

     1 /*

     2  * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    26 /*

    27  * We used part of Netscape's Java Runtime Interface (JRI) as the starting

    28  * point of our design and implementation.

    29  */

    31 /******************************************************************************

    32  * Java Runtime Interface

    33  * Copyright (c) 1996 Netscape Communications Corporation. All rights reserved.

    34  *****************************************************************************/

    36 #ifndef _JAVASOFT_JNI_H_

    37 #define _JAVASOFT_JNI_H_

    39 #include <stdio.h>

    40 #include <stdarg.h>

    42 /* jni_md.h contains the machine-dependent typedefs for jbyte, jint

    43    and jlong */

    45 #include "jni_md.h"

    47 #ifdef __cplusplus

    48 extern "C" {

    49 #endif

    51 /*

    52  * JNI Types

    53  */

    55 #ifndef JNI_TYPES_ALREADY_DEFINED_IN_JNI_MD_H

    57 typedef unsigned char   jboolean;

    58 typedef unsigned short  jchar;

    59 typedef short           jshort;

    60 typedef float           jfloat;

    61 typedef double          jdouble;

    63 typedef jint            jsize;

    65 #ifdef __cplusplus

    67 class _jobject {};

    68 class _jclass : public _jobject {};

    69 class _jthrowable : public _jobject {};

    70 class _jstring : public _jobject {};

    71 class _jarray : public _jobject {};

    72 class _jbooleanArray : public _jarray {};

    73 class _jbyteArray : public _jarray {};

    74 class _jcharArray : public _jarray {};

    75 class _jshortArray : public _jarray {};

    76 class _jintArray : public _jarray {};

    77 class _jlongArray : public _jarray {};

    78 class _jfloatArray : public _jarray {};

    79 class _jdoubleArray : public _jarray {};

    80 class _jobjectArray : public _jarray {};

    82 typedef _jobject *jobject;

    83 typedef _jclass *jclass;

    84 typedef _jthrowable *jthrowable;

    85 typedef _jstring *jstring;

    86 typedef _jarray *jarray;

    87 typedef _jbooleanArray *jbooleanArray;

    88 typedef _jbyteArray *jbyteArray;

    89 typedef _jcharArray *jcharArray;

    90 typedef _jshortArray *jshortArray;

    91 typedef _jintArray *jintArray;

    92 typedef _jlongArray *jlongArray;

    93 typedef _jfloatArray *jfloatArray;

    94 typedef _jdoubleArray *jdoubleArray;

    95 typedef _jobjectArray *jobjectArray;

    97 #else

    99 struct _jobject;

   101 typedef struct _jobject *jobject;

   102 typedef jobject jclass;

   103 typedef jobject jthrowable;

   104 typedef jobject jstring;

   105 typedef jobject jarray;

   106 typedef jarray jbooleanArray;

   107 typedef jarray jbyteArray;

   108 typedef jarray jcharArray;

   109 typedef jarray jshortArray;

   110 typedef jarray jintArray;

   111 typedef jarray jlongArray;

   112 typedef jarray jfloatArray;

   113 typedef jarray jdoubleArray;

   114 typedef jarray jobjectArray;

   116 #endif

   118 typedef jobject jweak;

   120 typedef union jvalue {

   121     jboolean z;

   122     jbyte    b;

   123     jchar    c;

   124     jshort   s;

   125     jint     i;

   126     jlong    j;

   127     jfloat   f;

   128     jdouble  d;

   129     jobject  l;

   130 } jvalue;

   132 struct _jfieldID;

   133 typedef struct _jfieldID *jfieldID;

   135 struct _jmethodID;

   136 typedef struct _jmethodID *jmethodID;

   138 /* Return values from jobjectRefType */

   139 typedef enum _jobjectType {

   140      JNIInvalidRefType    = 0,

   141      JNILocalRefType      = 1,

   142      JNIGlobalRefType     = 2,

   143      JNIWeakGlobalRefType = 3

   144 } jobjectRefType;

   147 #endif /* JNI_TYPES_ALREADY_DEFINED_IN_JNI_MD_H */

   149 /*

   150  * jboolean constants

   151  */

   153 #define JNI_FALSE 0

   154 #define JNI_TRUE 1

   156 /*

   157  * possible return values for JNI functions.

   158  */

   160 #define JNI_OK           0                 /* success */

   161 #define JNI_ERR          (-1)              /* unknown error */

   162 #define JNI_EDETACHED    (-2)              /* thread detached from the VM */

   163 #define JNI_EVERSION     (-3)              /* JNI version error */

   164 #define JNI_ENOMEM       (-4)              /* not enough memory */

   165 #define JNI_EEXIST       (-5)              /* VM already created */

   166 #define JNI_EINVAL       (-6)              /* invalid arguments */

   168 /*

   169  * used in ReleaseScalarArrayElements

   170  */

   172 #define JNI_COMMIT 1

   173 #define JNI_ABORT 2

   175 /*

   176  * used in RegisterNatives to describe native method name, signature,

   177  * and function pointer.

   178  */

   180 typedef struct {

   181     char *name;

   182     char *signature;

   183     void *fnPtr;

   184 } JNINativeMethod;

   186 /*

   187  * JNI Native Method Interface.

   188  */

   190 struct JNINativeInterface_;

   192 struct JNIEnv_;

   194 #ifdef __cplusplus

   195 typedef JNIEnv_ JNIEnv;

   196 #else

   197 typedef const struct JNINativeInterface_ *JNIEnv;

   198 #endif

   200 /*

   201  * JNI Invocation Interface.

   202  */

   204 struct JNIInvokeInterface_;

   206 struct JavaVM_;

   208 #ifdef __cplusplus

   209 typedef JavaVM_ JavaVM;

   210 #else

   211 typedef const struct JNIInvokeInterface_ *JavaVM;

   212 #endif

   214 struct JNINativeInterface_ {

   215     void *reserved0;

   216     void *reserved1;

   217     void *reserved2;

   219     void *reserved3;

   220     jint (JNICALL *GetVersion)(JNIEnv *env);

   222     jclass (JNICALL *DefineClass)

   223       (JNIEnv *env, const char *name, jobject loader, const jbyte *buf,

   224        jsize len);

   225     jclass (JNICALL *FindClass)

   226       (JNIEnv *env, const char *name);

   228     jmethodID (JNICALL *FromReflectedMethod)

   229       (JNIEnv *env, jobject method);

   230     jfieldID (JNICALL *FromReflectedField)

   231       (JNIEnv *env, jobject field);

   233     jobject (JNICALL *ToReflectedMethod)

   234       (JNIEnv *env, jclass cls, jmethodID methodID, jboolean isStatic);

   236     jclass (JNICALL *GetSuperclass)

   237       (JNIEnv *env, jclass sub);

   238     jboolean (JNICALL *IsAssignableFrom)

   239       (JNIEnv *env, jclass sub, jclass sup);

   241     jobject (JNICALL *ToReflectedField)

   242       (JNIEnv *env, jclass cls, jfieldID fieldID, jboolean isStatic);

   244     jint (JNICALL *Throw)

   245       (JNIEnv *env, jthrowable obj);

   246     jint (JNICALL *ThrowNew)

   247       (JNIEnv *env, jclass clazz, const char *msg);

   248     jthrowable (JNICALL *ExceptionOccurred)

   249       (JNIEnv *env);

   250     void (JNICALL *ExceptionDescribe)

   251       (JNIEnv *env);

   252     void (JNICALL *ExceptionClear)

   253       (JNIEnv *env);

   254     void (JNICALL *FatalError)

   255       (JNIEnv *env, const char *msg);

   257     jint (JNICALL *PushLocalFrame)

   258       (JNIEnv *env, jint capacity);

   259     jobject (JNICALL *PopLocalFrame)

   260       (JNIEnv *env, jobject result);

   262     jobject (JNICALL *NewGlobalRef)

   263       (JNIEnv *env, jobject lobj);

   264     void (JNICALL *DeleteGlobalRef)

   265       (JNIEnv *env, jobject gref);

   266     void (JNICALL *DeleteLocalRef)

   267       (JNIEnv *env, jobject obj);

   268     jboolean (JNICALL *IsSameObject)

   269       (JNIEnv *env, jobject obj1, jobject obj2);

   270     jobject (JNICALL *NewLocalRef)

   271       (JNIEnv *env, jobject ref);

   272     jint (JNICALL *EnsureLocalCapacity)

   273       (JNIEnv *env, jint capacity);

   275     jobject (JNICALL *AllocObject)

   276       (JNIEnv *env, jclass clazz);

   277     jobject (JNICALL *NewObject)

   278       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);

   279     jobject (JNICALL *NewObjectV)

   280       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);

   281     jobject (JNICALL *NewObjectA)

   282       (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);

   284     jclass (JNICALL *GetObjectClass)

   285       (JNIEnv *env, jobject obj);

   286     jboolean (JNICALL *IsInstanceOf)

   287       (JNIEnv *env, jobject obj, jclass clazz);

   289     jmethodID (JNICALL *GetMethodID)

   290       (JNIEnv *env, jclass clazz, const char *name, const char *sig);

   292     jobject (JNICALL *CallObjectMethod)

   293       (JNIEnv *env, jobject obj, jmethodID methodID, ...);

   294     jobject (JNICALL *CallObjectMethodV)

   295       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);

   296     jobject (JNICALL *CallObjectMethodA)

   297       (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue * args);

   299     jboolean (JNICALL *CallBooleanMethod)

   300       (JNIEnv *env, jobject obj, jmethodID methodID, ...);

   301     jboolean (JNICALL *CallBooleanMethodV)

   302       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);

   303     jboolean (JNICALL *CallBooleanMethodA)

   304       (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue * args);

   306     jbyte (JNICALL *CallByteMethod)

   307       (JNIEnv *env, jobject obj, jmethodID methodID, ...);

   308     jbyte (JNICALL *CallByteMethodV)

   309       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);

   310     jbyte (JNICALL *CallByteMethodA)

   311       (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);

   313     jchar (JNICALL *CallCharMethod)

   314       (JNIEnv *env, jobject obj, jmethodID methodID, ...);

   315     jchar (JNICALL *CallCharMethodV)

   316       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);

   317     jchar (JNICALL *CallCharMethodA)

   318       (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);

   320     jshort (JNICALL *CallShortMethod)

   321       (JNIEnv *env, jobject obj, jmethodID methodID, ...);

   322     jshort (JNICALL *CallShortMethodV)

   323       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);

   324     jshort (JNICALL *CallShortMethodA)

   325       (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);

   327     jint (JNICALL *CallIntMethod)

   328       (JNIEnv *env, jobject obj, jmethodID methodID, ...);

   329     jint (JNICALL *CallIntMethodV)

   330       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);

   331     jint (JNICALL *CallIntMethodA)

   332       (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);

   334     jlong (JNICALL *CallLongMethod)

   335       (JNIEnv *env, jobject obj, jmethodID methodID, ...);

   336     jlong (JNICALL *CallLongMethodV)

   337       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);

   338     jlong (JNICALL *CallLongMethodA)

   339       (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);

   341     jfloat (JNICALL *CallFloatMethod)

   342       (JNIEnv *env, jobject obj, jmethodID methodID, ...);

   343     jfloat (JNICALL *CallFloatMethodV)

   344       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);

   345     jfloat (JNICALL *CallFloatMethodA)

   346       (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);

   348     jdouble (JNICALL *CallDoubleMethod)

   349       (JNIEnv *env, jobject obj, jmethodID methodID, ...);

   350     jdouble (JNICALL *CallDoubleMethodV)

   351       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);

   352     jdouble (JNICALL *CallDoubleMethodA)

   353       (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);

   355     void (JNICALL *CallVoidMethod)

   356       (JNIEnv *env, jobject obj, jmethodID methodID, ...);

   357     void (JNICALL *CallVoidMethodV)

   358       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);

   359     void (JNICALL *CallVoidMethodA)

   360       (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue * args);

   362     jobject (JNICALL *CallNonvirtualObjectMethod)

   363       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);

   364     jobject (JNICALL *CallNonvirtualObjectMethodV)

   365       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,

   366        va_list args);

   367     jobject (JNICALL *CallNonvirtualObjectMethodA)

   368       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,

   369        const jvalue * args);

   371     jboolean (JNICALL *CallNonvirtualBooleanMethod)

   372       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);

   373     jboolean (JNICALL *CallNonvirtualBooleanMethodV)

   374       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,

   375        va_list args);

   376     jboolean (JNICALL *CallNonvirtualBooleanMethodA)

   377       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,

   378        const jvalue * args);

   380     jbyte (JNICALL *CallNonvirtualByteMethod)

   381       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);

   382     jbyte (JNICALL *CallNonvirtualByteMethodV)

   383       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,

   384        va_list args);

   385     jbyte (JNICALL *CallNonvirtualByteMethodA)

   386       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,

   387        const jvalue *args);

   389     jchar (JNICALL *CallNonvirtualCharMethod)

   390       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);

   391     jchar (JNICALL *CallNonvirtualCharMethodV)

   392       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,

   393        va_list args);

   394     jchar (JNICALL *CallNonvirtualCharMethodA)

   395       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,

   396        const jvalue *args);

   398     jshort (JNICALL *CallNonvirtualShortMethod)

   399       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);

   400     jshort (JNICALL *CallNonvirtualShortMethodV)

   401       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,

   402        va_list args);

   403     jshort (JNICALL *CallNonvirtualShortMethodA)

   404       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,

   405        const jvalue *args);

   407     jint (JNICALL *CallNonvirtualIntMethod)

   408       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);

   409     jint (JNICALL *CallNonvirtualIntMethodV)

   410       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,

   411        va_list args);

   412     jint (JNICALL *CallNonvirtualIntMethodA)

   413       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,

   414        const jvalue *args);

   416     jlong (JNICALL *CallNonvirtualLongMethod)

   417       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);

   418     jlong (JNICALL *CallNonvirtualLongMethodV)

   419       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,

   420        va_list args);

   421     jlong (JNICALL *CallNonvirtualLongMethodA)

   422       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,

   423        const jvalue *args);

   425     jfloat (JNICALL *CallNonvirtualFloatMethod)

   426       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);

   427     jfloat (JNICALL *CallNonvirtualFloatMethodV)

   428       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,

   429        va_list args);

   430     jfloat (JNICALL *CallNonvirtualFloatMethodA)

   431       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,

   432        const jvalue *args);

   434     jdouble (JNICALL *CallNonvirtualDoubleMethod)

   435       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);

   436     jdouble (JNICALL *CallNonvirtualDoubleMethodV)

   437       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,

   438        va_list args);

   439     jdouble (JNICALL *CallNonvirtualDoubleMethodA)

   440       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,

   441        const jvalue *args);

   443     void (JNICALL *CallNonvirtualVoidMethod)

   444       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);

   445     void (JNICALL *CallNonvirtualVoidMethodV)

   446       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,

   447        va_list args);

   448     void (JNICALL *CallNonvirtualVoidMethodA)

   449       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,

   450        const jvalue * args);

   452     jfieldID (JNICALL *GetFieldID)

   453       (JNIEnv *env, jclass clazz, const char *name, const char *sig);

   455     jobject (JNICALL *GetObjectField)

   456       (JNIEnv *env, jobject obj, jfieldID fieldID);

   457     jboolean (JNICALL *GetBooleanField)

   458       (JNIEnv *env, jobject obj, jfieldID fieldID);

   459     jbyte (JNICALL *GetByteField)

   460       (JNIEnv *env, jobject obj, jfieldID fieldID);

   461     jchar (JNICALL *GetCharField)

   462       (JNIEnv *env, jobject obj, jfieldID fieldID);

   463     jshort (JNICALL *GetShortField)

   464       (JNIEnv *env, jobject obj, jfieldID fieldID);

   465     jint (JNICALL *GetIntField)

   466       (JNIEnv *env, jobject obj, jfieldID fieldID);

   467     jlong (JNICALL *GetLongField)

   468       (JNIEnv *env, jobject obj, jfieldID fieldID);

   469     jfloat (JNICALL *GetFloatField)

   470       (JNIEnv *env, jobject obj, jfieldID fieldID);

   471     jdouble (JNICALL *GetDoubleField)

   472       (JNIEnv *env, jobject obj, jfieldID fieldID);

   474     void (JNICALL *SetObjectField)

   475       (JNIEnv *env, jobject obj, jfieldID fieldID, jobject val);

   476     void (JNICALL *SetBooleanField)

   477       (JNIEnv *env, jobject obj, jfieldID fieldID, jboolean val);

   478     void (JNICALL *SetByteField)

   479       (JNIEnv *env, jobject obj, jfieldID fieldID, jbyte val);

   480     void (JNICALL *SetCharField)

   481       (JNIEnv *env, jobject obj, jfieldID fieldID, jchar val);

   482     void (JNICALL *SetShortField)

   483       (JNIEnv *env, jobject obj, jfieldID fieldID, jshort val);

   484     void (JNICALL *SetIntField)

   485       (JNIEnv *env, jobject obj, jfieldID fieldID, jint val);

   486     void (JNICALL *SetLongField)

   487       (JNIEnv *env, jobject obj, jfieldID fieldID, jlong val);

   488     void (JNICALL *SetFloatField)

   489       (JNIEnv *env, jobject obj, jfieldID fieldID, jfloat val);

   490     void (JNICALL *SetDoubleField)

   491       (JNIEnv *env, jobject obj, jfieldID fieldID, jdouble val);

   493     jmethodID (JNICALL *GetStaticMethodID)

   494       (JNIEnv *env, jclass clazz, const char *name, const char *sig);

   496     jobject (JNICALL *CallStaticObjectMethod)

   497       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);

   498     jobject (JNICALL *CallStaticObjectMethodV)

   499       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);

   500     jobject (JNICALL *CallStaticObjectMethodA)

   501       (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);

   503     jboolean (JNICALL *CallStaticBooleanMethod)

   504       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);

   505     jboolean (JNICALL *CallStaticBooleanMethodV)

   506       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);

   507     jboolean (JNICALL *CallStaticBooleanMethodA)

   508       (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);

   510     jbyte (JNICALL *CallStaticByteMethod)

   511       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);

   512     jbyte (JNICALL *CallStaticByteMethodV)

   513       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);

   514     jbyte (JNICALL *CallStaticByteMethodA)

   515       (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);

   517     jchar (JNICALL *CallStaticCharMethod)

   518       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);

   519     jchar (JNICALL *CallStaticCharMethodV)

   520       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);

   521     jchar (JNICALL *CallStaticCharMethodA)

   522       (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);

   524     jshort (JNICALL *CallStaticShortMethod)

   525       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);

   526     jshort (JNICALL *CallStaticShortMethodV)

   527       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);

   528     jshort (JNICALL *CallStaticShortMethodA)

   529       (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);

   531     jint (JNICALL *CallStaticIntMethod)

   532       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);

   533     jint (JNICALL *CallStaticIntMethodV)

   534       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);

   535     jint (JNICALL *CallStaticIntMethodA)

   536       (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);

   538     jlong (JNICALL *CallStaticLongMethod)

   539       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);

   540     jlong (JNICALL *CallStaticLongMethodV)

   541       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);

   542     jlong (JNICALL *CallStaticLongMethodA)

   543       (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);

   545     jfloat (JNICALL *CallStaticFloatMethod)

   546       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);

   547     jfloat (JNICALL *CallStaticFloatMethodV)

   548       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);

   549     jfloat (JNICALL *CallStaticFloatMethodA)

   550       (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);

   552     jdouble (JNICALL *CallStaticDoubleMethod)

   553       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);

   554     jdouble (JNICALL *CallStaticDoubleMethodV)

   555       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);

   556     jdouble (JNICALL *CallStaticDoubleMethodA)

   557       (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);

   559     void (JNICALL *CallStaticVoidMethod)

   560       (JNIEnv *env, jclass cls, jmethodID methodID, ...);

   561     void (JNICALL *CallStaticVoidMethodV)

   562       (JNIEnv *env, jclass cls, jmethodID methodID, va_list args);

   563     void (JNICALL *CallStaticVoidMethodA)

   564       (JNIEnv *env, jclass cls, jmethodID methodID, const jvalue * args);

   566     jfieldID (JNICALL *GetStaticFieldID)

   567       (JNIEnv *env, jclass clazz, const char *name, const char *sig);

   568     jobject (JNICALL *GetStaticObjectField)

   569       (JNIEnv *env, jclass clazz, jfieldID fieldID);

   570     jboolean (JNICALL *GetStaticBooleanField)

   571       (JNIEnv *env, jclass clazz, jfieldID fieldID);

   572     jbyte (JNICALL *GetStaticByteField)

   573       (JNIEnv *env, jclass clazz, jfieldID fieldID);

   574     jchar (JNICALL *GetStaticCharField)

   575       (JNIEnv *env, jclass clazz, jfieldID fieldID);

   576     jshort (JNICALL *GetStaticShortField)

   577       (JNIEnv *env, jclass clazz, jfieldID fieldID);

   578     jint (JNICALL *GetStaticIntField)

   579       (JNIEnv *env, jclass clazz, jfieldID fieldID);

   580     jlong (JNICALL *GetStaticLongField)

   581       (JNIEnv *env, jclass clazz, jfieldID fieldID);

   582     jfloat (JNICALL *GetStaticFloatField)

   583       (JNIEnv *env, jclass clazz, jfieldID fieldID);

   584     jdouble (JNICALL *GetStaticDoubleField)

   585       (JNIEnv *env, jclass clazz, jfieldID fieldID);

   587     void (JNICALL *SetStaticObjectField)

   588       (JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value);

   589     void (JNICALL *SetStaticBooleanField)

   590       (JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value);

   591     void (JNICALL *SetStaticByteField)

   592       (JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value);

   593     void (JNICALL *SetStaticCharField)

   594       (JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value);

   595     void (JNICALL *SetStaticShortField)

   596       (JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value);

   597     void (JNICALL *SetStaticIntField)

   598       (JNIEnv *env, jclass clazz, jfieldID fieldID, jint value);

   599     void (JNICALL *SetStaticLongField)

   600       (JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value);

   601     void (JNICALL *SetStaticFloatField)

   602       (JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value);

   603     void (JNICALL *SetStaticDoubleField)

   604       (JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value);

   606     jstring (JNICALL *NewString)

   607       (JNIEnv *env, const jchar *unicode, jsize len);

   608     jsize (JNICALL *GetStringLength)

   609       (JNIEnv *env, jstring str);

   610     const jchar *(JNICALL *GetStringChars)

   611       (JNIEnv *env, jstring str, jboolean *isCopy);

   612     void (JNICALL *ReleaseStringChars)

   613       (JNIEnv *env, jstring str, const jchar *chars);

   615     jstring (JNICALL *NewStringUTF)

   616       (JNIEnv *env, const char *utf);

   617     jsize (JNICALL *GetStringUTFLength)

   618       (JNIEnv *env, jstring str);

   619     const char* (JNICALL *GetStringUTFChars)

   620       (JNIEnv *env, jstring str, jboolean *isCopy);

   621     void (JNICALL *ReleaseStringUTFChars)

   622       (JNIEnv *env, jstring str, const char* chars);

   625     jsize (JNICALL *GetArrayLength)

   626       (JNIEnv *env, jarray array);

   628     jobjectArray (JNICALL *NewObjectArray)

   629       (JNIEnv *env, jsize len, jclass clazz, jobject init);

   630     jobject (JNICALL *GetObjectArrayElement)

   631       (JNIEnv *env, jobjectArray array, jsize index);

   632     void (JNICALL *SetObjectArrayElement)

   633       (JNIEnv *env, jobjectArray array, jsize index, jobject val);

   635     jbooleanArray (JNICALL *NewBooleanArray)

   636       (JNIEnv *env, jsize len);

   637     jbyteArray (JNICALL *NewByteArray)

   638       (JNIEnv *env, jsize len);

   639     jcharArray (JNICALL *NewCharArray)

   640       (JNIEnv *env, jsize len);

   641     jshortArray (JNICALL *NewShortArray)

   642       (JNIEnv *env, jsize len);

   643     jintArray (JNICALL *NewIntArray)

   644       (JNIEnv *env, jsize len);

   645     jlongArray (JNICALL *NewLongArray)

   646       (JNIEnv *env, jsize len);

   647     jfloatArray (JNICALL *NewFloatArray)

   648       (JNIEnv *env, jsize len);

   649     jdoubleArray (JNICALL *NewDoubleArray)

   650       (JNIEnv *env, jsize len);

   652     jboolean * (JNICALL *GetBooleanArrayElements)

   653       (JNIEnv *env, jbooleanArray array, jboolean *isCopy);

   654     jbyte * (JNICALL *GetByteArrayElements)

   655       (JNIEnv *env, jbyteArray array, jboolean *isCopy);

   656     jchar * (JNICALL *GetCharArrayElements)

   657       (JNIEnv *env, jcharArray array, jboolean *isCopy);

   658     jshort * (JNICALL *GetShortArrayElements)

   659       (JNIEnv *env, jshortArray array, jboolean *isCopy);

   660     jint * (JNICALL *GetIntArrayElements)

   661       (JNIEnv *env, jintArray array, jboolean *isCopy);

   662     jlong * (JNICALL *GetLongArrayElements)

   663       (JNIEnv *env, jlongArray array, jboolean *isCopy);

   664     jfloat * (JNICALL *GetFloatArrayElements)

   665       (JNIEnv *env, jfloatArray array, jboolean *isCopy);

   666     jdouble * (JNICALL *GetDoubleArrayElements)

   667       (JNIEnv *env, jdoubleArray array, jboolean *isCopy);

   669     void (JNICALL *ReleaseBooleanArrayElements)

   670       (JNIEnv *env, jbooleanArray array, jboolean *elems, jint mode);

   671     void (JNICALL *ReleaseByteArrayElements)

   672       (JNIEnv *env, jbyteArray array, jbyte *elems, jint mode);

   673     void (JNICALL *ReleaseCharArrayElements)

   674       (JNIEnv *env, jcharArray array, jchar *elems, jint mode);

   675     void (JNICALL *ReleaseShortArrayElements)

   676       (JNIEnv *env, jshortArray array, jshort *elems, jint mode);

   677     void (JNICALL *ReleaseIntArrayElements)

   678       (JNIEnv *env, jintArray array, jint *elems, jint mode);

   679     void (JNICALL *ReleaseLongArrayElements)

   680       (JNIEnv *env, jlongArray array, jlong *elems, jint mode);

   681     void (JNICALL *ReleaseFloatArrayElements)

   682       (JNIEnv *env, jfloatArray array, jfloat *elems, jint mode);

   683     void (JNICALL *ReleaseDoubleArrayElements)

   684       (JNIEnv *env, jdoubleArray array, jdouble *elems, jint mode);

   686     void (JNICALL *GetBooleanArrayRegion)

   687       (JNIEnv *env, jbooleanArray array, jsize start, jsize l, jboolean *buf);

   688     void (JNICALL *GetByteArrayRegion)

   689       (JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf);

   690     void (JNICALL *GetCharArrayRegion)

   691       (JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf);

   692     void (JNICALL *GetShortArrayRegion)

   693       (JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf);

   694     void (JNICALL *GetIntArrayRegion)

   695       (JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf);

   696     void (JNICALL *GetLongArrayRegion)

   697       (JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf);

   698     void (JNICALL *GetFloatArrayRegion)

   699       (JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf);

   700     void (JNICALL *GetDoubleArrayRegion)

   701       (JNIEnv *env, jdoubleArray array, jsize start, jsize len, jdouble *buf);

   703     void (JNICALL *SetBooleanArrayRegion)

   704       (JNIEnv *env, jbooleanArray array, jsize start, jsize l, const jboolean *buf);

   705     void (JNICALL *SetByteArrayRegion)

   706       (JNIEnv *env, jbyteArray array, jsize start, jsize len, const jbyte *buf);

   707     void (JNICALL *SetCharArrayRegion)

   708       (JNIEnv *env, jcharArray array, jsize start, jsize len, const jchar *buf);

   709     void (JNICALL *SetShortArrayRegion)

   710       (JNIEnv *env, jshortArray array, jsize start, jsize len, const jshort *buf);

   711     void (JNICALL *SetIntArrayRegion)

   712       (JNIEnv *env, jintArray array, jsize start, jsize len, const jint *buf);

   713     void (JNICALL *SetLongArrayRegion)

   714       (JNIEnv *env, jlongArray array, jsize start, jsize len, const jlong *buf);

   715     void (JNICALL *SetFloatArrayRegion)

   716       (JNIEnv *env, jfloatArray array, jsize start, jsize len, const jfloat *buf);

   717     void (JNICALL *SetDoubleArrayRegion)

   718       (JNIEnv *env, jdoubleArray array, jsize start, jsize len, const jdouble *buf);

   720     jint (JNICALL *RegisterNatives)

   721       (JNIEnv *env, jclass clazz, const JNINativeMethod *methods,

   722        jint nMethods);

   723     jint (JNICALL *UnregisterNatives)

   724       (JNIEnv *env, jclass clazz);

   726     jint (JNICALL *MonitorEnter)

   727       (JNIEnv *env, jobject obj);

   728     jint (JNICALL *MonitorExit)

   729       (JNIEnv *env, jobject obj);

   731     jint (JNICALL *GetJavaVM)

   732       (JNIEnv *env, JavaVM **vm);

   734     void (JNICALL *GetStringRegion)

   735       (JNIEnv *env, jstring str, jsize start, jsize len, jchar *buf);

   736     void (JNICALL *GetStringUTFRegion)

   737       (JNIEnv *env, jstring str, jsize start, jsize len, char *buf);

   739     void * (JNICALL *GetPrimitiveArrayCritical)

   740       (JNIEnv *env, jarray array, jboolean *isCopy);

   741     void (JNICALL *ReleasePrimitiveArrayCritical)

   742       (JNIEnv *env, jarray array, void *carray, jint mode);

   744     const jchar * (JNICALL *GetStringCritical)

   745       (JNIEnv *env, jstring string, jboolean *isCopy);

   746     void (JNICALL *ReleaseStringCritical)

   747       (JNIEnv *env, jstring string, const jchar *cstring);

   749     jweak (JNICALL *NewWeakGlobalRef)

   750        (JNIEnv *env, jobject obj);

   751     void (JNICALL *DeleteWeakGlobalRef)

   752        (JNIEnv *env, jweak ref);

   754     jboolean (JNICALL *ExceptionCheck)

   755        (JNIEnv *env);

   757     jobject (JNICALL *NewDirectByteBuffer)

   758        (JNIEnv* env, void* address, jlong capacity);

   759     void* (JNICALL *GetDirectBufferAddress)

   760        (JNIEnv* env, jobject buf);

   761     jlong (JNICALL *GetDirectBufferCapacity)

   762        (JNIEnv* env, jobject buf);

   764     /* New JNI 1.6 Features */

   766     jobjectRefType (JNICALL *GetObjectRefType)

   767         (JNIEnv* env, jobject obj);

   768 };

   770 /*

   771  * We use inlined functions for C++ so that programmers can write:

   772  *

   773  *    env->FindClass("java/lang/String")

   774  *

   775  * in C++ rather than:

   776  *

   777  *    (*env)->FindClass(env, "java/lang/String")

   778  *

   779  * in C.

   780  */

   782 struct JNIEnv_ {

   783     const struct JNINativeInterface_ *functions;

   784 #ifdef __cplusplus

   786     jint GetVersion() {

   787         return functions->GetVersion(this);

   788     }

   789     jclass DefineClass(const char *name, jobject loader, const jbyte *buf,

   790                        jsize len) {

   791         return functions->DefineClass(this, name, loader, buf, len);

   792     }

   793     jclass FindClass(const char *name) {

   794         return functions->FindClass(this, name);

   795     }

   796     jmethodID FromReflectedMethod(jobject method) {

   797         return functions->FromReflectedMethod(this,method);

   798     }

   799     jfieldID FromReflectedField(jobject field) {

   800         return functions->FromReflectedField(this,field);

   801     }

   803     jobject ToReflectedMethod(jclass cls, jmethodID methodID, jboolean isStatic) {

   804         return functions->ToReflectedMethod(this, cls, methodID, isStatic);

   805     }

   807     jclass GetSuperclass(jclass sub) {

   808         return functions->GetSuperclass(this, sub);

   809     }

   810     jboolean IsAssignableFrom(jclass sub, jclass sup) {

   811         return functions->IsAssignableFrom(this, sub, sup);

   812     }

   814     jobject ToReflectedField(jclass cls, jfieldID fieldID, jboolean isStatic) {

   815         return functions->ToReflectedField(this,cls,fieldID,isStatic);

   816     }

   818     jint Throw(jthrowable obj) {

   819         return functions->Throw(this, obj);

   820     }

   821     jint ThrowNew(jclass clazz, const char *msg) {

   822         return functions->ThrowNew(this, clazz, msg);

   823     }

   824     jthrowable ExceptionOccurred() {

   825         return functions->ExceptionOccurred(this);

   826     }

   827     void ExceptionDescribe() {

   828         functions->ExceptionDescribe(this);

   829     }

   830     void ExceptionClear() {

   831         functions->ExceptionClear(this);

   832     }

   833     void FatalError(const char *msg) {

   834         functions->FatalError(this, msg);

   835     }

   837     jint PushLocalFrame(jint capacity) {

   838         return functions->PushLocalFrame(this,capacity);

   839     }

   840     jobject PopLocalFrame(jobject result) {

   841         return functions->PopLocalFrame(this,result);

   842     }

   844     jobject NewGlobalRef(jobject lobj) {

   845         return functions->NewGlobalRef(this,lobj);

   846     }

   847     void DeleteGlobalRef(jobject gref) {

   848         functions->DeleteGlobalRef(this,gref);

   849     }

   850     void DeleteLocalRef(jobject obj) {

   851         functions->DeleteLocalRef(this, obj);

   852     }

   854     jboolean IsSameObject(jobject obj1, jobject obj2) {

   855         return functions->IsSameObject(this,obj1,obj2);

   856     }

   858     jobject NewLocalRef(jobject ref) {

   859         return functions->NewLocalRef(this,ref);

   860     }

   861     jint EnsureLocalCapacity(jint capacity) {

   862         return functions->EnsureLocalCapacity(this,capacity);

   863     }

   865     jobject AllocObject(jclass clazz) {

   866         return functions->AllocObject(this,clazz);

   867     }

   868     jobject NewObject(jclass clazz, jmethodID methodID, ...) {

   869         va_list args;

   870         jobject result;

   871         va_start(args, methodID);

   872         result = functions->NewObjectV(this,clazz,methodID,args);

   873         va_end(args);

   874         return result;

   875     }

   876     jobject NewObjectV(jclass clazz, jmethodID methodID,

   877                        va_list args) {

   878         return functions->NewObjectV(this,clazz,methodID,args);

   879     }

   880     jobject NewObjectA(jclass clazz, jmethodID methodID,

   881                        const jvalue *args) {

   882         return functions->NewObjectA(this,clazz,methodID,args);

   883     }

   885     jclass GetObjectClass(jobject obj) {

   886         return functions->GetObjectClass(this,obj);

   887     }

   888     jboolean IsInstanceOf(jobject obj, jclass clazz) {

   889         return functions->IsInstanceOf(this,obj,clazz);

   890     }

   892     jmethodID GetMethodID(jclass clazz, const char *name,

   893                           const char *sig) {

   894         return functions->GetMethodID(this,clazz,name,sig);

   895     }

   897     jobject CallObjectMethod(jobject obj, jmethodID methodID, ...) {

   898         va_list args;

   899         jobject result;

   900         va_start(args,methodID);

   901         result = functions->CallObjectMethodV(this,obj,methodID,args);

   902         va_end(args);

   903         return result;

   904     }

   905     jobject CallObjectMethodV(jobject obj, jmethodID methodID,

   906                         va_list args) {

   907         return functions->CallObjectMethodV(this,obj,methodID,args);

   908     }

   909     jobject CallObjectMethodA(jobject obj, jmethodID methodID,

   910                         const jvalue * args) {

   911         return functions->CallObjectMethodA(this,obj,methodID,args);

   912     }

   914     jboolean CallBooleanMethod(jobject obj,

   915                                jmethodID methodID, ...) {

   916         va_list args;

   917         jboolean result;

   918         va_start(args,methodID);

   919         result = functions->CallBooleanMethodV(this,obj,methodID,args);

   920         va_end(args);

   921         return result;

   922     }

   923     jboolean CallBooleanMethodV(jobject obj, jmethodID methodID,

   924                                 va_list args) {

   925         return functions->CallBooleanMethodV(this,obj,methodID,args);

   926     }

   927     jboolean CallBooleanMethodA(jobject obj, jmethodID methodID,

   928                                 const jvalue * args) {

   929         return functions->CallBooleanMethodA(this,obj,methodID, args);

   930     }

   932     jbyte CallByteMethod(jobject obj, jmethodID methodID, ...) {

   933         va_list args;

   934         jbyte result;

   935         va_start(args,methodID);

   936         result = functions->CallByteMethodV(this,obj,methodID,args);

   937         va_end(args);

   938         return result;

   939     }

   940     jbyte CallByteMethodV(jobject obj, jmethodID methodID,

   941                           va_list args) {

   942         return functions->CallByteMethodV(this,obj,methodID,args);

   943     }

   944     jbyte CallByteMethodA(jobject obj, jmethodID methodID,

   945                           const jvalue * args) {

   946         return functions->CallByteMethodA(this,obj,methodID,args);

   947     }

   949     jchar CallCharMethod(jobject obj, jmethodID methodID, ...) {

   950         va_list args;

   951         jchar result;

   952         va_start(args,methodID);

   953         result = functions->CallCharMethodV(this,obj,methodID,args);

   954         va_end(args);

   955         return result;

   956     }

   957     jchar CallCharMethodV(jobject obj, jmethodID methodID,

   958                           va_list args) {

   959         return functions->CallCharMethodV(this,obj,methodID,args);

   960     }

   961     jchar CallCharMethodA(jobject obj, jmethodID methodID,

   962                           const jvalue * args) {

   963         return functions->CallCharMethodA(this,obj,methodID,args);

   964     }

   966     jshort CallShortMethod(jobject obj, jmethodID methodID, ...) {

   967         va_list args;

   968         jshort result;

   969         va_start(args,methodID);

   970         result = functions->CallShortMethodV(this,obj,methodID,args);

   971         va_end(args);

   972         return result;

   973     }

   974     jshort CallShortMethodV(jobject obj, jmethodID methodID,

   975                             va_list args) {

   976         return functions->CallShortMethodV(this,obj,methodID,args);

   977     }

   978     jshort CallShortMethodA(jobject obj, jmethodID methodID,

   979                             const jvalue * args) {

   980         return functions->CallShortMethodA(this,obj,methodID,args);

   981     }

   983     jint CallIntMethod(jobject obj, jmethodID methodID, ...) {

   984         va_list args;

   985         jint result;

   986         va_start(args,methodID);

   987         result = functions->CallIntMethodV(this,obj,methodID,args);

   988         va_end(args);

   989         return result;

   990     }

   991     jint CallIntMethodV(jobject obj, jmethodID methodID,

   992                         va_list args) {

   993         return functions->CallIntMethodV(this,obj,methodID,args);

   994     }

   995     jint CallIntMethodA(jobject obj, jmethodID methodID,

   996                         const jvalue * args) {

   997         return functions->CallIntMethodA(this,obj,methodID,args);

   998     }

  1000     jlong CallLongMethod(jobject obj, jmethodID methodID, ...) {

  1001         va_list args;

  1002         jlong result;

  1003         va_start(args,methodID);

  1004         result = functions->CallLongMethodV(this,obj,methodID,args);

  1005         va_end(args);

  1006         return result;

  1007     }

  1008     jlong CallLongMethodV(jobject obj, jmethodID methodID,

  1009                           va_list args) {

  1010         return functions->CallLongMethodV(this,obj,methodID,args);

  1011     }

  1012     jlong CallLongMethodA(jobject obj, jmethodID methodID,

  1013                           const jvalue * args) {

  1014         return functions->CallLongMethodA(this,obj,methodID,args);

  1015     }

  1017     jfloat CallFloatMethod(jobject obj, jmethodID methodID, ...) {

  1018         va_list args;

  1019         jfloat result;

  1020         va_start(args,methodID);

  1021         result = functions->CallFloatMethodV(this,obj,methodID,args);

  1022         va_end(args);

  1023         return result;

  1024     }

  1025     jfloat CallFloatMethodV(jobject obj, jmethodID methodID,

  1026                             va_list args) {

  1027         return functions->CallFloatMethodV(this,obj,methodID,args);

  1028     }

  1029     jfloat CallFloatMethodA(jobject obj, jmethodID methodID,

  1030                             const jvalue * args) {

  1031         return functions->CallFloatMethodA(this,obj,methodID,args);

  1032     }

  1034     jdouble CallDoubleMethod(jobject obj, jmethodID methodID, ...) {

  1035         va_list args;

  1036         jdouble result;

  1037         va_start(args,methodID);

  1038         result = functions->CallDoubleMethodV(this,obj,methodID,args);

  1039         va_end(args);

  1040         return result;

  1041     }

  1042     jdouble CallDoubleMethodV(jobject obj, jmethodID methodID,

  1043                         va_list args) {

  1044         return functions->CallDoubleMethodV(this,obj,methodID,args);

  1045     }

  1046     jdouble CallDoubleMethodA(jobject obj, jmethodID methodID,

  1047                         const jvalue * args) {

  1048         return functions->CallDoubleMethodA(this,obj,methodID,args);

  1049     }

  1051     void CallVoidMethod(jobject obj, jmethodID methodID, ...) {

  1052         va_list args;

  1053         va_start(args,methodID);

  1054         functions->CallVoidMethodV(this,obj,methodID,args);

  1055         va_end(args);

  1056     }

  1057     void CallVoidMethodV(jobject obj, jmethodID methodID,

  1058                          va_list args) {

  1059         functions->CallVoidMethodV(this,obj,methodID,args);

  1060     }

  1061     void CallVoidMethodA(jobject obj, jmethodID methodID,

  1062                          const jvalue * args) {

  1063         functions->CallVoidMethodA(this,obj,methodID,args);

  1064     }

  1066     jobject CallNonvirtualObjectMethod(jobject obj, jclass clazz,

  1067                                        jmethodID methodID, ...) {

  1068         va_list args;

  1069         jobject result;

  1070         va_start(args,methodID);

  1071         result = functions->CallNonvirtualObjectMethodV(this,obj,clazz,

  1072                                                         methodID,args);

  1073         va_end(args);

  1074         return result;

  1075     }

  1076     jobject CallNonvirtualObjectMethodV(jobject obj, jclass clazz,

  1077                                         jmethodID methodID, va_list args) {

  1078         return functions->CallNonvirtualObjectMethodV(this,obj,clazz,

  1079                                                       methodID,args);

  1080     }

  1081     jobject CallNonvirtualObjectMethodA(jobject obj, jclass clazz,

  1082                                         jmethodID methodID, const jvalue * args) {

  1083         return functions->CallNonvirtualObjectMethodA(this,obj,clazz,

  1084                                                       methodID,args);

  1085     }

  1087     jboolean CallNonvirtualBooleanMethod(jobject obj, jclass clazz,

  1088                                          jmethodID methodID, ...) {

  1089         va_list args;

  1090         jboolean result;

  1091         va_start(args,methodID);

  1092         result = functions->CallNonvirtualBooleanMethodV(this,obj,clazz,

  1093                                                          methodID,args);

  1094         va_end(args);

  1095         return result;

  1096     }

  1097     jboolean CallNonvirtualBooleanMethodV(jobject obj, jclass clazz,

  1098                                           jmethodID methodID, va_list args) {

  1099         return functions->CallNonvirtualBooleanMethodV(this,obj,clazz,

  1100                                                        methodID,args);

  1101     }

  1102     jboolean CallNonvirtualBooleanMethodA(jobject obj, jclass clazz,

  1103                                           jmethodID methodID, const jvalue * args) {

  1104         return functions->CallNonvirtualBooleanMethodA(this,obj,clazz,

  1105                                                        methodID, args);

  1106     }

  1108     jbyte CallNonvirtualByteMethod(jobject obj, jclass clazz,

  1109                                    jmethodID methodID, ...) {

  1110         va_list args;

  1111         jbyte result;

  1112         va_start(args,methodID);

  1113         result = functions->CallNonvirtualByteMethodV(this,obj,clazz,

  1114                                                       methodID,args);

  1115         va_end(args);

  1116         return result;

  1117     }

  1118     jbyte CallNonvirtualByteMethodV(jobject obj, jclass clazz,

  1119                                     jmethodID methodID, va_list args) {

  1120         return functions->CallNonvirtualByteMethodV(this,obj,clazz,

  1121                                                     methodID,args);

  1122     }

  1123     jbyte CallNonvirtualByteMethodA(jobject obj, jclass clazz,

  1124                                     jmethodID methodID, const jvalue * args) {

  1125         return functions->CallNonvirtualByteMethodA(this,obj,clazz,

  1126                                                     methodID,args);

  1127     }

  1129     jchar CallNonvirtualCharMethod(jobject obj, jclass clazz,

  1130                                    jmethodID methodID, ...) {

  1131         va_list args;

  1132         jchar result;

  1133         va_start(args,methodID);

  1134         result = functions->CallNonvirtualCharMethodV(this,obj,clazz,

  1135                                                       methodID,args);

  1136         va_end(args);

  1137         return result;

  1138     }

  1139     jchar CallNonvirtualCharMethodV(jobject obj, jclass clazz,

  1140                                     jmethodID methodID, va_list args) {

  1141         return functions->CallNonvirtualCharMethodV(this,obj,clazz,

  1142                                                     methodID,args);

  1143     }

  1144     jchar CallNonvirtualCharMethodA(jobject obj, jclass clazz,

  1145                                     jmethodID methodID, const jvalue * args) {

  1146         return functions->CallNonvirtualCharMethodA(this,obj,clazz,

  1147                                                     methodID,args);

  1148     }

  1150     jshort CallNonvirtualShortMethod(jobject obj, jclass clazz,

  1151                                      jmethodID methodID, ...) {

  1152         va_list args;

  1153         jshort result;

  1154         va_start(args,methodID);

  1155         result = functions->CallNonvirtualShortMethodV(this,obj,clazz,

  1156                                                        methodID,args);

  1157         va_end(args);

  1158         return result;

  1159     }

  1160     jshort CallNonvirtualShortMethodV(jobject obj, jclass clazz,

  1161                                       jmethodID methodID, va_list args) {

  1162         return functions->CallNonvirtualShortMethodV(this,obj,clazz,

  1163                                                      methodID,args);

  1164     }

  1165     jshort CallNonvirtualShortMethodA(jobject obj, jclass clazz,

  1166                                       jmethodID methodID, const jvalue * args) {

  1167         return functions->CallNonvirtualShortMethodA(this,obj,clazz,

  1168                                                      methodID,args);

  1169     }

  1171     jint CallNonvirtualIntMethod(jobject obj, jclass clazz,

  1172                                  jmethodID methodID, ...) {

  1173         va_list args;

  1174         jint result;

  1175         va_start(args,methodID);

  1176         result = functions->CallNonvirtualIntMethodV(this,obj,clazz,

  1177                                                      methodID,args);

  1178         va_end(args);

  1179         return result;

  1180     }

  1181     jint CallNonvirtualIntMethodV(jobject obj, jclass clazz,

  1182                                   jmethodID methodID, va_list args) {

  1183         return functions->CallNonvirtualIntMethodV(this,obj,clazz,

  1184                                                    methodID,args);

  1185     }

  1186     jint CallNonvirtualIntMethodA(jobject obj, jclass clazz,

  1187                                   jmethodID methodID, const jvalue * args) {

  1188         return functions->CallNonvirtualIntMethodA(this,obj,clazz,

  1189                                                    methodID,args);

  1190     }

  1192     jlong CallNonvirtualLongMethod(jobject obj, jclass clazz,

  1193                                    jmethodID methodID, ...) {

  1194         va_list args;

  1195         jlong result;

  1196         va_start(args,methodID);

  1197         result = functions->CallNonvirtualLongMethodV(this,obj,clazz,

  1198                                                       methodID,args);

  1199         va_end(args);

  1200         return result;

  1201     }

  1202     jlong CallNonvirtualLongMethodV(jobject obj, jclass clazz,

  1203                                     jmethodID methodID, va_list args) {

  1204         return functions->CallNonvirtualLongMethodV(this,obj,clazz,

  1205                                                     methodID,args);

  1206     }

  1207     jlong CallNonvirtualLongMethodA(jobject obj, jclass clazz,

  1208                                     jmethodID methodID, const jvalue * args) {

  1209         return functions->CallNonvirtualLongMethodA(this,obj,clazz,

  1210                                                     methodID,args);

  1211     }

  1213     jfloat CallNonvirtualFloatMethod(jobject obj, jclass clazz,

  1214                                      jmethodID methodID, ...) {

  1215         va_list args;

  1216         jfloat result;

  1217         va_start(args,methodID);

  1218         result = functions->CallNonvirtualFloatMethodV(this,obj,clazz,

  1219                                                        methodID,args);

  1220         va_end(args);

  1221         return result;

  1222     }

  1223     jfloat CallNonvirtualFloatMethodV(jobject obj, jclass clazz,

  1224                                       jmethodID methodID,

  1225                                       va_list args) {

  1226         return functions->CallNonvirtualFloatMethodV(this,obj,clazz,

  1227                                                      methodID,args);

  1228     }

  1229     jfloat CallNonvirtualFloatMethodA(jobject obj, jclass clazz,

  1230                                       jmethodID methodID,

  1231                                       const jvalue * args) {

  1232         return functions->CallNonvirtualFloatMethodA(this,obj,clazz,

  1233                                                      methodID,args);

  1234     }

  1236     jdouble CallNonvirtualDoubleMethod(jobject obj, jclass clazz,

  1237                                        jmethodID methodID, ...) {

  1238         va_list args;

  1239         jdouble result;

  1240         va_start(args,methodID);

  1241         result = functions->CallNonvirtualDoubleMethodV(this,obj,clazz,

  1242                                                         methodID,args);

  1243         va_end(args);

  1244         return result;

  1245     }

  1246     jdouble CallNonvirtualDoubleMethodV(jobject obj, jclass clazz,

  1247                                         jmethodID methodID,

  1248                                         va_list args) {

  1249         return functions->CallNonvirtualDoubleMethodV(this,obj,clazz,

  1250                                                       methodID,args);

  1251     }

  1252     jdouble CallNonvirtualDoubleMethodA(jobject obj, jclass clazz,

  1253                                         jmethodID methodID,

  1254                                         const jvalue * args) {

  1255         return functions->CallNonvirtualDoubleMethodA(this,obj,clazz,

  1256                                                       methodID,args);

  1257     }

  1259     void CallNonvirtualVoidMethod(jobject obj, jclass clazz,

  1260                                   jmethodID methodID, ...) {

  1261         va_list args;

  1262         va_start(args,methodID);

  1263         functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);

  1264         va_end(args);

  1265     }

  1266     void CallNonvirtualVoidMethodV(jobject obj, jclass clazz,

  1267                                    jmethodID methodID,

  1268                                    va_list args) {

  1269         functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);

  1270     }

  1271     void CallNonvirtualVoidMethodA(jobject obj, jclass clazz,

  1272                                    jmethodID methodID,

  1273                                    const jvalue * args) {

  1274         functions->CallNonvirtualVoidMethodA(this,obj,clazz,methodID,args);

  1275     }

  1277     jfieldID GetFieldID(jclass clazz, const char *name,

  1278                         const char *sig) {

  1279         return functions->GetFieldID(this,clazz,name,sig);

  1280     }

  1282     jobject GetObjectField(jobject obj, jfieldID fieldID) {

  1283         return functions->GetObjectField(this,obj,fieldID);

  1284     }

  1285     jboolean GetBooleanField(jobject obj, jfieldID fieldID) {

  1286         return functions->GetBooleanField(this,obj,fieldID);

  1287     }

  1288     jbyte GetByteField(jobject obj, jfieldID fieldID) {

  1289         return functions->GetByteField(this,obj,fieldID);

  1290     }

  1291     jchar GetCharField(jobject obj, jfieldID fieldID) {

  1292         return functions->GetCharField(this,obj,fieldID);

  1293     }

  1294     jshort GetShortField(jobject obj, jfieldID fieldID) {

  1295         return functions->GetShortField(this,obj,fieldID);

  1296     }

  1297     jint GetIntField(jobject obj, jfieldID fieldID) {

  1298         return functions->GetIntField(this,obj,fieldID);

  1299     }

  1300     jlong GetLongField(jobject obj, jfieldID fieldID) {

  1301         return functions->GetLongField(this,obj,fieldID);

  1302     }

  1303     jfloat GetFloatField(jobject obj, jfieldID fieldID) {

  1304         return functions->GetFloatField(this,obj,fieldID);

  1305     }

  1306     jdouble GetDoubleField(jobject obj, jfieldID fieldID) {

  1307         return functions->GetDoubleField(this,obj,fieldID);

  1308     }

  1310     void SetObjectField(jobject obj, jfieldID fieldID, jobject val) {

  1311         functions->SetObjectField(this,obj,fieldID,val);

  1312     }

  1313     void SetBooleanField(jobject obj, jfieldID fieldID,

  1314                          jboolean val) {

  1315         functions->SetBooleanField(this,obj,fieldID,val);

  1316     }

  1317     void SetByteField(jobject obj, jfieldID fieldID,

  1318                       jbyte val) {

  1319         functions->SetByteField(this,obj,fieldID,val);

  1320     }

  1321     void SetCharField(jobject obj, jfieldID fieldID,

  1322                       jchar val) {

  1323         functions->SetCharField(this,obj,fieldID,val);

  1324     }

  1325     void SetShortField(jobject obj, jfieldID fieldID,

  1326                        jshort val) {

  1327         functions->SetShortField(this,obj,fieldID,val);

  1328     }

  1329     void SetIntField(jobject obj, jfieldID fieldID,

  1330                      jint val) {

  1331         functions->SetIntField(this,obj,fieldID,val);

  1332     }

  1333     void SetLongField(jobject obj, jfieldID fieldID,

  1334                       jlong val) {

  1335         functions->SetLongField(this,obj,fieldID,val);

  1336     }

  1337     void SetFloatField(jobject obj, jfieldID fieldID,

  1338                        jfloat val) {

  1339         functions->SetFloatField(this,obj,fieldID,val);

  1340     }

  1341     void SetDoubleField(jobject obj, jfieldID fieldID,

  1342                         jdouble val) {

  1343         functions->SetDoubleField(this,obj,fieldID,val);

  1344     }

  1346     jmethodID GetStaticMethodID(jclass clazz, const char *name,

  1347                                 const char *sig) {

  1348         return functions->GetStaticMethodID(this,clazz,name,sig);

  1349     }

  1351     jobject CallStaticObjectMethod(jclass clazz, jmethodID methodID,

  1352                              ...) {

  1353         va_list args;

  1354         jobject result;

  1355         va_start(args,methodID);

  1356         result = functions->CallStaticObjectMethodV(this,clazz,methodID,args);

  1357         va_end(args);

  1358         return result;

  1359     }

  1360     jobject CallStaticObjectMethodV(jclass clazz, jmethodID methodID,

  1361                               va_list args) {

  1362         return functions->CallStaticObjectMethodV(this,clazz,methodID,args);

  1363     }

  1364     jobject CallStaticObjectMethodA(jclass clazz, jmethodID methodID,

  1365                               const jvalue *args) {

  1366         return functions->CallStaticObjectMethodA(this,clazz,methodID,args);

  1367     }

  1369     jboolean CallStaticBooleanMethod(jclass clazz,

  1370                                      jmethodID methodID, ...) {

  1371         va_list args;

  1372         jboolean result;

  1373         va_start(args,methodID);

  1374         result = functions->CallStaticBooleanMethodV(this,clazz,methodID,args);

  1375         va_end(args);

  1376         return result;

  1377     }

  1378     jboolean CallStaticBooleanMethodV(jclass clazz,

  1379                                       jmethodID methodID, va_list args) {

  1380         return functions->CallStaticBooleanMethodV(this,clazz,methodID,args);

  1381     }

  1382     jboolean CallStaticBooleanMethodA(jclass clazz,

  1383                                       jmethodID methodID, const jvalue *args) {

  1384         return functions->CallStaticBooleanMethodA(this,clazz,methodID,args);

  1385     }

  1387     jbyte CallStaticByteMethod(jclass clazz,

  1388                                jmethodID methodID, ...) {

  1389         va_list args;

  1390         jbyte result;

  1391         va_start(args,methodID);

  1392         result = functions->CallStaticByteMethodV(this,clazz,methodID,args);

  1393         va_end(args);

  1394         return result;

  1395     }

  1396     jbyte CallStaticByteMethodV(jclass clazz,

  1397                                 jmethodID methodID, va_list args) {

  1398         return functions->CallStaticByteMethodV(this,clazz,methodID,args);

  1399     }

  1400     jbyte CallStaticByteMethodA(jclass clazz,

  1401                                 jmethodID methodID, const jvalue *args) {

  1402         return functions->CallStaticByteMethodA(this,clazz,methodID,args);

  1403     }

  1405     jchar CallStaticCharMethod(jclass clazz,

  1406                                jmethodID methodID, ...) {

  1407         va_list args;

  1408         jchar result;

  1409         va_start(args,methodID);

  1410         result = functions->CallStaticCharMethodV(this,clazz,methodID,args);

  1411         va_end(args);

  1412         return result;

  1413     }

  1414     jchar CallStaticCharMethodV(jclass clazz,

  1415                                 jmethodID methodID, va_list args) {

  1416         return functions->CallStaticCharMethodV(this,clazz,methodID,args);

  1417     }

  1418     jchar CallStaticCharMethodA(jclass clazz,

  1419                                 jmethodID methodID, const jvalue *args) {

  1420         return functions->CallStaticCharMethodA(this,clazz,methodID,args);

  1421     }

  1423     jshort CallStaticShortMethod(jclass clazz,

  1424                                  jmethodID methodID, ...) {

  1425         va_list args;

  1426         jshort result;

  1427         va_start(args,methodID);

  1428         result = functions->CallStaticShortMethodV(this,clazz,methodID,args);

  1429         va_end(args);

  1430         return result;

  1431     }

  1432     jshort CallStaticShortMethodV(jclass clazz,

  1433                                   jmethodID methodID, va_list args) {

  1434         return functions->CallStaticShortMethodV(this,clazz,methodID,args);

  1435     }

  1436     jshort CallStaticShortMethodA(jclass clazz,

  1437                                   jmethodID methodID, const jvalue *args) {

  1438         return functions->CallStaticShortMethodA(this,clazz,methodID,args);

  1439     }

  1441     jint CallStaticIntMethod(jclass clazz,

  1442                              jmethodID methodID, ...) {

  1443         va_list args;

  1444         jint result;

  1445         va_start(args,methodID);

  1446         result = functions->CallStaticIntMethodV(this,clazz,methodID,args);

  1447         va_end(args);

  1448         return result;

  1449     }

  1450     jint CallStaticIntMethodV(jclass clazz,

  1451                               jmethodID methodID, va_list args) {

  1452         return functions->CallStaticIntMethodV(this,clazz,methodID,args);

  1453     }

  1454     jint CallStaticIntMethodA(jclass clazz,

  1455                               jmethodID methodID, const jvalue *args) {

  1456         return functions->CallStaticIntMethodA(this,clazz,methodID,args);

  1457     }

  1459     jlong CallStaticLongMethod(jclass clazz,

  1460                                jmethodID methodID, ...) {

  1461         va_list args;

  1462         jlong result;

  1463         va_start(args,methodID);

  1464         result = functions->CallStaticLongMethodV(this,clazz,methodID,args);

  1465         va_end(args);

  1466         return result;

  1467     }

  1468     jlong CallStaticLongMethodV(jclass clazz,

  1469                                 jmethodID methodID, va_list args) {

  1470         return functions->CallStaticLongMethodV(this,clazz,methodID,args);

  1471     }

  1472     jlong CallStaticLongMethodA(jclass clazz,

  1473                                 jmethodID methodID, const jvalue *args) {

  1474         return functions->CallStaticLongMethodA(this,clazz,methodID,args);

  1475     }

  1477     jfloat CallStaticFloatMethod(jclass clazz,

  1478                                  jmethodID methodID, ...) {

  1479         va_list args;

  1480         jfloat result;

  1481         va_start(args,methodID);

  1482         result = functions->CallStaticFloatMethodV(this,clazz,methodID,args);

  1483         va_end(args);

  1484         return result;

  1485     }

  1486     jfloat CallStaticFloatMethodV(jclass clazz,

  1487                                   jmethodID methodID, va_list args) {

  1488         return functions->CallStaticFloatMethodV(this,clazz,methodID,args);

  1489     }

  1490     jfloat CallStaticFloatMethodA(jclass clazz,

  1491                                   jmethodID methodID, const jvalue *args) {

  1492         return functions->CallStaticFloatMethodA(this,clazz,methodID,args);

  1493     }

  1495     jdouble CallStaticDoubleMethod(jclass clazz,

  1496                                    jmethodID methodID, ...) {

  1497         va_list args;

  1498         jdouble result;

  1499         va_start(args,methodID);

  1500         result = functions->CallStaticDoubleMethodV(this,clazz,methodID,args);

  1501         va_end(args);

  1502         return result;

  1503     }

  1504     jdouble CallStaticDoubleMethodV(jclass clazz,

  1505                                     jmethodID methodID, va_list args) {

  1506         return functions->CallStaticDoubleMethodV(this,clazz,methodID,args);

  1507     }

  1508     jdouble CallStaticDoubleMethodA(jclass clazz,

  1509                                     jmethodID methodID, const jvalue *args) {

  1510         return functions->CallStaticDoubleMethodA(this,clazz,methodID,args);

  1511     }

  1513     void CallStaticVoidMethod(jclass cls, jmethodID methodID, ...) {

  1514         va_list args;

  1515         va_start(args,methodID);

  1516         functions->CallStaticVoidMethodV(this,cls,methodID,args);

  1517         va_end(args);

  1518     }

  1519     void CallStaticVoidMethodV(jclass cls, jmethodID methodID,

  1520                                va_list args) {

  1521         functions->CallStaticVoidMethodV(this,cls,methodID,args);

  1522     }

  1523     void CallStaticVoidMethodA(jclass cls, jmethodID methodID,

  1524                                const jvalue * args) {

  1525         functions->CallStaticVoidMethodA(this,cls,methodID,args);

  1526     }

  1528     jfieldID GetStaticFieldID(jclass clazz, const char *name,

  1529                               const char *sig) {

  1530         return functions->GetStaticFieldID(this,clazz,name,sig);

  1531     }

  1532     jobject GetStaticObjectField(jclass clazz, jfieldID fieldID) {

  1533         return functions->GetStaticObjectField(this,clazz,fieldID);

  1534     }

  1535     jboolean GetStaticBooleanField(jclass clazz, jfieldID fieldID) {

  1536         return functions->GetStaticBooleanField(this,clazz,fieldID);

  1537     }

  1538     jbyte GetStaticByteField(jclass clazz, jfieldID fieldID) {

  1539         return functions->GetStaticByteField(this,clazz,fieldID);

  1540     }

  1541     jchar GetStaticCharField(jclass clazz, jfieldID fieldID) {

  1542         return functions->GetStaticCharField(this,clazz,fieldID);

  1543     }

  1544     jshort GetStaticShortField(jclass clazz, jfieldID fieldID) {

  1545         return functions->GetStaticShortField(this,clazz,fieldID);

  1546     }

  1547     jint GetStaticIntField(jclass clazz, jfieldID fieldID) {

  1548         return functions->GetStaticIntField(this,clazz,fieldID);

  1549     }

  1550     jlong GetStaticLongField(jclass clazz, jfieldID fieldID) {

  1551         return functions->GetStaticLongField(this,clazz,fieldID);

  1552     }

  1553     jfloat GetStaticFloatField(jclass clazz, jfieldID fieldID) {

  1554         return functions->GetStaticFloatField(this,clazz,fieldID);

  1555     }

  1556     jdouble GetStaticDoubleField(jclass clazz, jfieldID fieldID) {

  1557         return functions->GetStaticDoubleField(this,clazz,fieldID);

  1558     }

  1560     void SetStaticObjectField(jclass clazz, jfieldID fieldID,

  1561                         jobject value) {

  1562       functions->SetStaticObjectField(this,clazz,fieldID,value);

  1563     }

  1564     void SetStaticBooleanField(jclass clazz, jfieldID fieldID,

  1565                         jboolean value) {

  1566       functions->SetStaticBooleanField(this,clazz,fieldID,value);

  1567     }

  1568     void SetStaticByteField(jclass clazz, jfieldID fieldID,

  1569                         jbyte value) {

  1570       functions->SetStaticByteField(this,clazz,fieldID,value);

  1571     }

  1572     void SetStaticCharField(jclass clazz, jfieldID fieldID,

  1573                         jchar value) {

  1574       functions->SetStaticCharField(this,clazz,fieldID,value);

  1575     }

  1576     void SetStaticShortField(jclass clazz, jfieldID fieldID,

  1577                         jshort value) {

  1578       functions->SetStaticShortField(this,clazz,fieldID,value);

  1579     }

  1580     void SetStaticIntField(jclass clazz, jfieldID fieldID,

  1581                         jint value) {

  1582       functions->SetStaticIntField(this,clazz,fieldID,value);

  1583     }

  1584     void SetStaticLongField(jclass clazz, jfieldID fieldID,

  1585                         jlong value) {

  1586       functions->SetStaticLongField(this,clazz,fieldID,value);

  1587     }

  1588     void SetStaticFloatField(jclass clazz, jfieldID fieldID,

  1589                         jfloat value) {

  1590       functions->SetStaticFloatField(this,clazz,fieldID,value);

  1591     }

  1592     void SetStaticDoubleField(jclass clazz, jfieldID fieldID,

  1593                         jdouble value) {

  1594       functions->SetStaticDoubleField(this,clazz,fieldID,value);

  1595     }

  1597     jstring NewString(const jchar *unicode, jsize len) {

  1598         return functions->NewString(this,unicode,len);

  1599     }

  1600     jsize GetStringLength(jstring str) {

  1601         return functions->GetStringLength(this,str);

  1602     }

  1603     const jchar *GetStringChars(jstring str, jboolean *isCopy) {

  1604         return functions->GetStringChars(this,str,isCopy);

  1605     }

  1606     void ReleaseStringChars(jstring str, const jchar *chars) {

  1607         functions->ReleaseStringChars(this,str,chars);

  1608     }

  1610     jstring NewStringUTF(const char *utf) {

  1611         return functions->NewStringUTF(this,utf);

  1612     }

  1613     jsize GetStringUTFLength(jstring str) {

  1614         return functions->GetStringUTFLength(this,str);

  1615     }

  1616     const char* GetStringUTFChars(jstring str, jboolean *isCopy) {

  1617         return functions->GetStringUTFChars(this,str,isCopy);

  1618     }

  1619     void ReleaseStringUTFChars(jstring str, const char* chars) {

  1620         functions->ReleaseStringUTFChars(this,str,chars);

  1621     }

  1623     jsize GetArrayLength(jarray array) {

  1624         return functions->GetArrayLength(this,array);

  1625     }

  1627     jobjectArray NewObjectArray(jsize len, jclass clazz,

  1628                                 jobject init) {

  1629         return functions->NewObjectArray(this,len,clazz,init);

  1630     }

  1631     jobject GetObjectArrayElement(jobjectArray array, jsize index) {

  1632         return functions->GetObjectArrayElement(this,array,index);

  1633     }

  1634     void SetObjectArrayElement(jobjectArray array, jsize index,

  1635                                jobject val) {

  1636         functions->SetObjectArrayElement(this,array,index,val);

  1637     }

  1639     jbooleanArray NewBooleanArray(jsize len) {

  1640         return functions->NewBooleanArray(this,len);

  1641     }

  1642     jbyteArray NewByteArray(jsize len) {

  1643         return functions->NewByteArray(this,len);

  1644     }

  1645     jcharArray NewCharArray(jsize len) {

  1646         return functions->NewCharArray(this,len);

  1647     }

  1648     jshortArray NewShortArray(jsize len) {

  1649         return functions->NewShortArray(this,len);

  1650     }

  1651     jintArray NewIntArray(jsize len) {

  1652         return functions->NewIntArray(this,len);

  1653     }

  1654     jlongArray NewLongArray(jsize len) {

  1655         return functions->NewLongArray(this,len);

  1656     }

  1657     jfloatArray NewFloatArray(jsize len) {

  1658         return functions->NewFloatArray(this,len);

  1659     }

  1660     jdoubleArray NewDoubleArray(jsize len) {

  1661         return functions->NewDoubleArray(this,len);

  1662     }

  1664     jboolean * GetBooleanArrayElements(jbooleanArray array, jboolean *isCopy) {

  1665         return functions->GetBooleanArrayElements(this,array,isCopy);

  1666     }

  1667     jbyte * GetByteArrayElements(jbyteArray array, jboolean *isCopy) {

  1668         return functions->GetByteArrayElements(this,array,isCopy);

  1669     }

  1670     jchar * GetCharArrayElements(jcharArray array, jboolean *isCopy) {

  1671         return functions->GetCharArrayElements(this,array,isCopy);

  1672     }

  1673     jshort * GetShortArrayElements(jshortArray array, jboolean *isCopy) {

  1674         return functions->GetShortArrayElements(this,array,isCopy);

  1675     }

  1676     jint * GetIntArrayElements(jintArray array, jboolean *isCopy) {

  1677         return functions->GetIntArrayElements(this,array,isCopy);

  1678     }

  1679     jlong * GetLongArrayElements(jlongArray array, jboolean *isCopy) {

  1680         return functions->GetLongArrayElements(this,array,isCopy);

  1681     }

  1682     jfloat * GetFloatArrayElements(jfloatArray array, jboolean *isCopy) {

  1683         return functions->GetFloatArrayElements(this,array,isCopy);

  1684     }

  1685     jdouble * GetDoubleArrayElements(jdoubleArray array, jboolean *isCopy) {

  1686         return functions->GetDoubleArrayElements(this,array,isCopy);

  1687     }

  1689     void ReleaseBooleanArrayElements(jbooleanArray array,

  1690                                      jboolean *elems,

  1691                                      jint mode) {

  1692         functions->ReleaseBooleanArrayElements(this,array,elems,mode);

  1693     }

  1694     void ReleaseByteArrayElements(jbyteArray array,

  1695                                   jbyte *elems,

  1696                                   jint mode) {

  1697         functions->ReleaseByteArrayElements(this,array,elems,mode);

  1698     }

  1699     void ReleaseCharArrayElements(jcharArray array,

  1700                                   jchar *elems,

  1701                                   jint mode) {

  1702         functions->ReleaseCharArrayElements(this,array,elems,mode);

  1703     }

  1704     void ReleaseShortArrayElements(jshortArray array,

  1705                                    jshort *elems,

  1706                                    jint mode) {

  1707         functions->ReleaseShortArrayElements(this,array,elems,mode);

  1708     }

  1709     void ReleaseIntArrayElements(jintArray array,

  1710                                  jint *elems,

  1711                                  jint mode) {

  1712         functions->ReleaseIntArrayElements(this,array,elems,mode);

  1713     }

  1714     void ReleaseLongArrayElements(jlongArray array,

  1715                                   jlong *elems,

  1716                                   jint mode) {

  1717         functions->ReleaseLongArrayElements(this,array,elems,mode);

  1718     }

  1719     void ReleaseFloatArrayElements(jfloatArray array,

  1720                                    jfloat *elems,

  1721                                    jint mode) {

  1722         functions->ReleaseFloatArrayElements(this,array,elems,mode);

  1723     }

  1724     void ReleaseDoubleArrayElements(jdoubleArray array,

  1725                                     jdouble *elems,

  1726                                     jint mode) {

  1727         functions->ReleaseDoubleArrayElements(this,array,elems,mode);

  1728     }

  1730     void GetBooleanArrayRegion(jbooleanArray array,

  1731                                jsize start, jsize len, jboolean *buf) {

  1732         functions->GetBooleanArrayRegion(this,array,start,len,buf);

  1733     }

  1734     void GetByteArrayRegion(jbyteArray array,

  1735                             jsize start, jsize len, jbyte *buf) {

  1736         functions->GetByteArrayRegion(this,array,start,len,buf);

  1737     }

  1738     void GetCharArrayRegion(jcharArray array,

  1739                             jsize start, jsize len, jchar *buf) {

  1740         functions->GetCharArrayRegion(this,array,start,len,buf);

  1741     }

  1742     void GetShortArrayRegion(jshortArray array,

  1743                              jsize start, jsize len, jshort *buf) {

  1744         functions->GetShortArrayRegion(this,array,start,len,buf);

  1745     }

  1746     void GetIntArrayRegion(jintArray array,

  1747                            jsize start, jsize len, jint *buf) {

  1748         functions->GetIntArrayRegion(this,array,start,len,buf);

  1749     }

  1750     void GetLongArrayRegion(jlongArray array,

  1751                             jsize start, jsize len, jlong *buf) {

  1752         functions->GetLongArrayRegion(this,array,start,len,buf);

  1753     }

  1754     void GetFloatArrayRegion(jfloatArray array,

  1755                              jsize start, jsize len, jfloat *buf) {

  1756         functions->GetFloatArrayRegion(this,array,start,len,buf);

  1757     }

  1758     void GetDoubleArrayRegion(jdoubleArray array,

  1759                               jsize start, jsize len, jdouble *buf) {

  1760         functions->GetDoubleArrayRegion(this,array,start,len,buf);

  1761     }

  1763     void SetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len,

  1764                                const jboolean *buf) {

  1765         functions->SetBooleanArrayRegion(this,array,start,len,buf);

  1766     }

  1767     void SetByteArrayRegion(jbyteArray array, jsize start, jsize len,

  1768                             const jbyte *buf) {

  1769         functions->SetByteArrayRegion(this,array,start,len,buf);

  1770     }

  1771     void SetCharArrayRegion(jcharArray array, jsize start, jsize len,

  1772                             const jchar *buf) {

  1773         functions->SetCharArrayRegion(this,array,start,len,buf);

  1774     }

  1775     void SetShortArrayRegion(jshortArray array, jsize start, jsize len,

  1776                              const jshort *buf) {

  1777         functions->SetShortArrayRegion(this,array,start,len,buf);

  1778     }

  1779     void SetIntArrayRegion(jintArray array, jsize start, jsize len,

  1780                            const jint *buf) {

  1781         functions->SetIntArrayRegion(this,array,start,len,buf);

  1782     }

  1783     void SetLongArrayRegion(jlongArray array, jsize start, jsize len,

  1784                             const jlong *buf) {

  1785         functions->SetLongArrayRegion(this,array,start,len,buf);

  1786     }

  1787     void SetFloatArrayRegion(jfloatArray array, jsize start, jsize len,

  1788                              const jfloat *buf) {

  1789         functions->SetFloatArrayRegion(this,array,start,len,buf);

  1790     }

  1791     void SetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len,

  1792                               const jdouble *buf) {

  1793         functions->SetDoubleArrayRegion(this,array,start,len,buf);

  1794     }

  1796     jint RegisterNatives(jclass clazz, const JNINativeMethod *methods,

  1797                          jint nMethods) {

  1798         return functions->RegisterNatives(this,clazz,methods,nMethods);

  1799     }

  1800     jint UnregisterNatives(jclass clazz) {

  1801         return functions->UnregisterNatives(this,clazz);

  1802     }

  1804     jint MonitorEnter(jobject obj) {

  1805         return functions->MonitorEnter(this,obj);

  1806     }

  1807     jint MonitorExit(jobject obj) {

  1808         return functions->MonitorExit(this,obj);

  1809     }

  1811     jint GetJavaVM(JavaVM **vm) {

  1812         return functions->GetJavaVM(this,vm);

  1813     }

  1815     void GetStringRegion(jstring str, jsize start, jsize len, jchar *buf) {

  1816         functions->GetStringRegion(this,str,start,len,buf);

  1817     }

  1818     void GetStringUTFRegion(jstring str, jsize start, jsize len, char *buf) {

  1819         functions->GetStringUTFRegion(this,str,start,len,buf);

  1820     }

  1822     void * GetPrimitiveArrayCritical(jarray array, jboolean *isCopy) {

  1823         return functions->GetPrimitiveArrayCritical(this,array,isCopy);

  1824     }

  1825     void ReleasePrimitiveArrayCritical(jarray array, void *carray, jint mode) {

  1826         functions->ReleasePrimitiveArrayCritical(this,array,carray,mode);

  1827     }

  1829     const jchar * GetStringCritical(jstring string, jboolean *isCopy) {

  1830         return functions->GetStringCritical(this,string,isCopy);

  1831     }

  1832     void ReleaseStringCritical(jstring string, const jchar *cstring) {

  1833         functions->ReleaseStringCritical(this,string,cstring);

  1834     }

  1836     jweak NewWeakGlobalRef(jobject obj) {

  1837         return functions->NewWeakGlobalRef(this,obj);

  1838     }

  1839     void DeleteWeakGlobalRef(jweak ref) {

  1840         functions->DeleteWeakGlobalRef(this,ref);

  1841     }

  1843     jboolean ExceptionCheck() {

  1844         return functions->ExceptionCheck(this);

  1845     }

  1847     jobject NewDirectByteBuffer(void* address, jlong capacity) {

  1848         return functions->NewDirectByteBuffer(this, address, capacity);

  1849     }

  1850     void* GetDirectBufferAddress(jobject buf) {

  1851         return functions->GetDirectBufferAddress(this, buf);

  1852     }

  1853     jlong GetDirectBufferCapacity(jobject buf) {

  1854         return functions->GetDirectBufferCapacity(this, buf);

  1855     }

  1856     jobjectRefType GetObjectRefType(jobject obj) {

  1857         return functions->GetObjectRefType(this, obj);

  1858     }

  1860 #endif /* __cplusplus */

  1861 };

  1863 typedef struct JavaVMOption {

  1864     char *optionString;

  1865     void *extraInfo;

  1866 } JavaVMOption;

  1868 typedef struct JavaVMInitArgs {

  1869     jint version;

  1871     jint nOptions;

  1872     JavaVMOption *options;

  1873     jboolean ignoreUnrecognized;

  1874 } JavaVMInitArgs;

  1876 typedef struct JavaVMAttachArgs {

  1877     jint version;

  1879     char *name;

  1880     jobject group;

  1881 } JavaVMAttachArgs;

  1883 /* These will be VM-specific. */

  1885 #define JDK1_2

  1886 #define JDK1_4

  1888 /* End VM-specific. */

  1890 struct JNIInvokeInterface_ {

  1891     void *reserved0;

  1892     void *reserved1;

  1893     void *reserved2;

  1895     jint (JNICALL *DestroyJavaVM)(JavaVM *vm);

  1897     jint (JNICALL *AttachCurrentThread)(JavaVM *vm, void **penv, void *args);

  1899     jint (JNICALL *DetachCurrentThread)(JavaVM *vm);

  1901     jint (JNICALL *GetEnv)(JavaVM *vm, void **penv, jint version);

  1903     jint (JNICALL *AttachCurrentThreadAsDaemon)(JavaVM *vm, void **penv, void *args);

  1904 };

  1906 struct JavaVM_ {

  1907     const struct JNIInvokeInterface_ *functions;

  1908 #ifdef __cplusplus

  1910     jint DestroyJavaVM() {

  1911         return functions->DestroyJavaVM(this);

  1912     }

  1913     jint AttachCurrentThread(void **penv, void *args) {

  1914         return functions->AttachCurrentThread(this, penv, args);

  1915     }

  1916     jint DetachCurrentThread() {

  1917         return functions->DetachCurrentThread(this);

  1918     }

  1920     jint GetEnv(void **penv, jint version) {

  1921         return functions->GetEnv(this, penv, version);

  1922     }

  1923     jint AttachCurrentThreadAsDaemon(void **penv, void *args) {

  1924         return functions->AttachCurrentThreadAsDaemon(this, penv, args);

  1925     }

  1926 #endif

  1927 };

  1929 #ifdef _JNI_IMPLEMENTATION_

  1930 #define _JNI_IMPORT_OR_EXPORT_ JNIEXPORT

  1931 #else

  1932 #define _JNI_IMPORT_OR_EXPORT_ JNIIMPORT

  1933 #endif

  1934 _JNI_IMPORT_OR_EXPORT_ jint JNICALL

  1935 JNI_GetDefaultJavaVMInitArgs(void *args);

  1937 _JNI_IMPORT_OR_EXPORT_ jint JNICALL

  1938 JNI_CreateJavaVM(JavaVM **pvm, void **penv, void *args);

  1940 _JNI_IMPORT_OR_EXPORT_ jint JNICALL

  1941 JNI_GetCreatedJavaVMs(JavaVM **, jsize, jsize *);

  1943 /* Defined by native libraries. */

  1944 JNIEXPORT jint JNICALL

  1945 JNI_OnLoad(JavaVM *vm, void *reserved);

  1947 JNIEXPORT void JNICALL

  1948 JNI_OnUnload(JavaVM *vm, void *reserved);

  1950 #define JNI_VERSION_1_1 0x00010001

  1951 #define JNI_VERSION_1_2 0x00010002

  1952 #define JNI_VERSION_1_4 0x00010004

  1953 #define JNI_VERSION_1_6 0x00010006

  1954 #define JNI_VERSION_1_8 0x00010008

  1956 #ifdef __cplusplus

  1957 } /* extern "C" */

  1958 #endif /* __cplusplus */

  1960 #endif /* !_JAVASOFT_JNI_H_ */

Mercurial > jdk8-mips64-public > hotspot / file revision

src/share/vm/prims/jni.h@710a3c8b516e

src/share/vm/prims/jni.h