Appendix C. The Java Native Interface Include File

The features of the Java Native Interface are available through the include file jni.h.

  
/***********************************************************************\
*
* aicas GmbH, Karlsruhe
*
* $Source: /CVSROOT/Jamaica/src/doc/html/jni-h.html,v $
* $Revision: 1.6.6.1 $
* $Author: rupp $
* Contents: The jamaica virtual machine JNI interface
* Systems : all
*
\***********************************************************************/

#ifndef __JNI__
#define __JNI__

#ifdef __cplusplus
extern "C"
#endif

/****************************** Includes *******************************/
#include <stdlib.h>
#include <stdarg.h>

/* NOTE: To use internal functions of JamaicaVM, you need to include
 *       jamaica_vm.h _BEFORE_ jni.h. 
 */
#ifndef __JAMAICA_VM__
#include "jamaica.h"
#endif

/****************** Conditional compilation switches *******************/
/* ??? */
#define JNIEXPORT
#define JNICALL

/***************************** Constants *******************************/
/* ??? */
#define JNI_FALSE  0
#define JNI_TRUE   1

/* ??? */
#define JNI_COMMIT 1
#define JNI_ABORT  2

/* version numbers */
#define JNI_VERSION_1_1 0x00010001
#define JNI_VERSION_1_2 0x00010002

/* error codes */
#define JNI_EDETACHED    (-2)              /* thread detached from the VM */
#define JNI_EVERSION     (-3)              /* JNI version error */

/* special constants */
#define JNI_JLONG_CONST_0       JAMAICA_INT64_CONST_0
#define JNI_JLONG_CONST_MINUS_1 JAMAICA_INT32_TO_INT64(-1)

/***************************** Datatypes *******************************/

typedef jamaica_uint8  jboolean;
typedef jamaica_int8   jbyte;
typedef jamaica_uint16 jchar;
typedef jamaica_int16  jshort;
typedef jamaica_int32  jint;
#ifndef jlong
  typedef jamaica_int64  jlong;
#endif
typedef jamaica_float  jfloat;
typedef jamaica_double jdouble;

typedef jint jsize;

typedef void FAR_REFERENCE *jobject;
typedef jobject            jclass;
typedef jobject            jstring;
typedef jobject            jarray;
typedef jobject            jobjectArray;
typedef jobject            jbooleanArray;
typedef jobject            jbyteArray;
typedef jobject            jcharArray;
typedef jobject            jshortArray;
typedef jobject            jintArray;
typedef jobject            jlongArray;
typedef jobject            jfloatArray;
typedef jobject            jdoubleArray;
typedef jobject            jthrowable;

typedef jobject            jweak;

struct _jfieldID;              /* opaque structure */
typedef struct _jfieldID *jfieldID;   /* field IDs */

struct _jmethodID;              /* opaque structure */
typedef struct _jmethodID *jmethodID; /* method IDs */

typedef union jvalue {
   jboolean z;
   jbyte    b;
   jchar    c;
   jshort   s;
   jint     i;
   jlong    j;
   jfloat   f;
   jdouble  d;
   jobject  l;
} jvalue;

typedef const struct JNINativeInterface *JNIEnv;

//jchar    *GetCharArrayElements   (JNIEnv *env, jcharArray    array, jboolean *isCopy);

typedef struct JavaVM {
//??? leer?
int xxx;
} JavaVM; 

typedef struct JavaVMAttachArgs {
  jint version;
  char *name;
  jobject group;
} JavaVMAttachArgs;

typedef struct JNINativeInterface {
   void * reserved0;
   void * reserved1;
   void * reserved2;
   void * reserved3;
   jint         (* GetVersion                   ) (JNIEnv *env);
   jclass       (* DefineClass                  ) (JNIEnv *env, jobject loader, const jbyte *buf, jsize bufLen);
   jclass       (* FindClass                    ) (JNIEnv *env, const char *name);
   void * reserved7;
   void * reserved8;
   void * reserved9;
   jclass       (* GetSuperclass                ) (JNIEnv *env, jclass clazz);
   jboolean     (* IsAssignableFrom             ) (JNIEnv *env, jclass clazz1, jclass clazz2);
   void * reserved12;
   jint         (* Throw                        ) (JNIEnv *env, jthrowable obj);
   jint         (* ThrowNew                     ) (JNIEnv *env, jclass clazz, const char *message);
   jthrowable   (* ExceptionOccurred            ) (JNIEnv *env);
   void         (* ExceptionDescribe            ) (JNIEnv *env);
   void         (* ExceptionClear               ) (JNIEnv *env);
   void         (* FatalError                   ) (JNIEnv *env, const char *msg);
   void * reserved19;
   void * reserved20;
   jobject      (* NewGlobalRef                 ) (JNIEnv *env, jobject obj);
   void         (* DeleteGlobalRef              ) (JNIEnv *env, jobject globalRef);
   void         (* DeleteLocalRef               ) (JNIEnv *env, jobject localRef);
   jboolean     (* IsSameObject                 ) (JNIEnv *env, jobject ref1, jobject ref2);
   void * reserved25;
   void * reserved26;
   jobject      (* AllocObject                  ) (JNIEnv *env, jclass clazz);
   jobject      (* NewObject                    ) (JNIEnv *env, jclass clazz, jmethodID, ...         );
   jobject      (* NewObjectV                   ) (JNIEnv *env, jclass clazz, jmethodID, va_list args);
   jobject      (* NewObjectA                   ) (JNIEnv *env, jclass clazz, jmethodID, jvalue *args);
   jclass       (* GetObjectClass               ) (JNIEnv *env, jobject obj);
   jboolean     (* IsInstanceOf                 ) (JNIEnv *env, jobject obj, jclass clazz);
   jmethodID    (* GetMethodID                  ) (JNIEnv *env, jclass clazz, const char *name, const char *sig);
   jobject      (* CallObjectMethod             ) (JNIEnv *env, jobject obj, jmethodID methodID, ...         );
   jobject      (* CallObjectMethodV            ) (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
   jobject      (* CallObjectMethodA            ) (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
   jboolean     (* CallBooleanMethod            ) (JNIEnv *env, jobject obj, jmethodID methodID, ...         );
   jboolean     (* CallBooleanMethodV           ) (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
   jboolean     (* CallBooleanMethodA           ) (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
   jbyte        (* CallByteMethod               ) (JNIEnv *env, jobject obj, jmethodID methodID, ...         );
   jbyte        (* CallByteMethodV              ) (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
   jbyte        (* CallByteMethodA              ) (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
   jchar        (* CallCharMethod               ) (JNIEnv *env, jobject obj, jmethodID methodID, ...         );
   jchar        (* CallCharMethodV              ) (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
   jchar        (* CallCharMethodA              ) (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
   jshort       (* CallShortMethod              ) (JNIEnv *env, jobject obj, jmethodID methodID, ...         );
   jshort       (* CallShortMethodV             ) (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
   jshort       (* CallShortMethodA             ) (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
   jint         (* CallIntMethod                ) (JNIEnv *env, jobject obj, jmethodID methodID, ...         );
   jint         (* CallIntMethodV               ) (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
   jint         (* CallIntMethodA               ) (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
   jlong        (* CallLongMethod               ) (JNIEnv *env, jobject obj, jmethodID methodID, ...         );
   jlong        (* CallLongMethodV              ) (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
   jlong        (* CallLongMethodA              ) (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
   jfloat       (* CallFloatMethod              ) (JNIEnv *env, jobject obj, jmethodID methodID, ...         );
   jfloat       (* CallFloatMethodV             ) (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
   jfloat       (* CallFloatMethodA             ) (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
   jdouble      (* CallDoubleMethod             ) (JNIEnv *env, jobject obj, jmethodID methodID, ...         );
   jdouble      (* CallDoubleMethodV            ) (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
   jdouble      (* CallDoubleMethodA            ) (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
   void         (* CallVoidMethod               ) (JNIEnv *env, jobject obj, jmethodID methodID, ...         );
   void         (* CallVoidMethodV              ) (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
   void         (* CallVoidMethodA              ) (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
   jobject      (* CallNonvirtualObjectMethod   ) (JNIEnv *env, jobject obj, jclass jclazz, jmethodID methodID, ...         );
   jobject      (* CallNonvirtualObjectMethodV  ) (JNIEnv *env, jobject obj, jclass jclazz, jmethodID methodID, va_list args);
   jobject      (* CallNonvirtualObjectMethodA  ) (JNIEnv *env, jobject obj, jclass jclazz, jmethodID methodID, jvalue *args);
   jboolean     (* CallNonvirtualBooleanMethod  ) (JNIEnv *env, jobject obj, jclass jclazz, jmethodID methodID, ...         );
   jboolean     (* CallNonvirtualBooleanMethodV ) (JNIEnv *env, jobject obj, jclass jclazz, jmethodID methodID, va_list args);
   jboolean     (* CallNonvirtualBooleanMethodA ) (JNIEnv *env, jobject obj, jclass jclazz, jmethodID methodID, jvalue *args);
   jbyte        (* CallNonvirtualByteMethod     ) (JNIEnv *env, jobject obj, jclass jclazz, jmethodID methodID, ...         );
   jbyte        (* CallNonvirtualByteMethodV    ) (JNIEnv *env, jobject obj, jclass jclazz, jmethodID methodID, va_list args);
   jbyte        (* CallNonvirtualByteMethodA    ) (JNIEnv *env, jobject obj, jclass jclazz, jmethodID methodID, jvalue *args);
   jchar        (* CallNonvirtualCharMethod     ) (JNIEnv *env, jobject obj, jclass jclazz, jmethodID methodID, ...         );
   jchar        (* CallNonvirtualCharMethodV    ) (JNIEnv *env, jobject obj, jclass jclazz, jmethodID methodID, va_list args);
   jchar        (* CallNonvirtualCharMethodA    ) (JNIEnv *env, jobject obj, jclass jclazz, jmethodID methodID, jvalue *args);
   jshort       (* CallNonvirtualShortMethod    ) (JNIEnv *env, jobject obj, jclass jclazz, jmethodID methodID, ...         );
   jshort       (* CallNonvirtualShortMethodV   ) (JNIEnv *env, jobject obj, jclass jclazz, jmethodID methodID, va_list args);
   jshort       (* CallNonvirtualShortMethodA   ) (JNIEnv *env, jobject obj, jclass jclazz, jmethodID methodID, jvalue *args);
   jint         (* CallNonvirtualIntMethod      ) (JNIEnv *env, jobject obj, jclass jclazz, jmethodID methodID, ...         );
   jint         (* CallNonvirtualIntMethodV     ) (JNIEnv *env, jobject obj, jclass jclazz, jmethodID methodID, va_list args);
   jint         (* CallNonvirtualIntMethodA     ) (JNIEnv *env, jobject obj, jclass jclazz, jmethodID methodID, jvalue *args);
   jlong        (* CallNonvirtualLongMethod     ) (JNIEnv *env, jobject obj, jclass jclazz, jmethodID methodID, ...         );
   jlong        (* CallNonvirtualLongMethodV    ) (JNIEnv *env, jobject obj, jclass jclazz, jmethodID methodID, va_list args);
   jlong        (* CallNonvirtualLongMethodA    ) (JNIEnv *env, jobject obj, jclass jclazz, jmethodID methodID, jvalue *args);
   jfloat       (* CallNonvirtualFloatMethod    ) (JNIEnv *env, jobject obj, jclass jclazz, jmethodID methodID, ...         );
   jfloat       (* CallNonvirtualFloatMethodV   ) (JNIEnv *env, jobject obj, jclass jclazz, jmethodID methodID, va_list args);
   jfloat       (* CallNonvirtualFloatMethodA   ) (JNIEnv *env, jobject obj, jclass jclazz, jmethodID methodID, jvalue *args);
   jdouble      (* CallNonvirtualDoubleMethod   ) (JNIEnv *env, jobject obj, jclass jclazz, jmethodID methodID, ...         );
   jdouble      (* CallNonvirtualDoubleMethodV  ) (JNIEnv *env, jobject obj, jclass jclazz, jmethodID methodID, va_list args);
   jdouble      (* CallNonvirtualDoubleMethodA  ) (JNIEnv *env, jobject obj, jclass jclazz, jmethodID methodID, jvalue *args);
   void         (* CallNonvirtualVoidMethod     ) (JNIEnv *env, jobject obj, jclass jclazz, jmethodID methodID, ...         );
   void         (* CallNonvirtualVoidMethodV    ) (JNIEnv *env, jobject obj, jclass jclazz, jmethodID methodID, va_list args);
   void         (* CallNonvirtualVoidMethodA    ) (JNIEnv *env, jobject obj, jclass jclazz, jmethodID methodID, jvalue *args);
   jfieldID     (* GetFieldID                   ) (JNIEnv *env, jclass clazz, const char *name, const char *sig);
   jobject      (* GetObjectField               ) (JNIEnv *env, jobject obj, jfieldID fieldID);
   jboolean     (* GetBooleanField              ) (JNIEnv *env, jobject obj, jfieldID fieldID);
   jbyte        (* GetByteField                 ) (JNIEnv *env, jobject obj, jfieldID fieldID);
   jchar        (* GetCharField                 ) (JNIEnv *env, jobject obj, jfieldID fieldID);
   jshort       (* GetShortField                ) (JNIEnv *env, jobject obj, jfieldID fieldID);
   jint         (* GetIntField                  ) (JNIEnv *env, jobject obj, jfieldID fieldID);
   jlong        (* GetLongField                 ) (JNIEnv *env, jobject obj, jfieldID fieldID);
   jfloat       (* GetFloatField                ) (JNIEnv *env, jobject obj, jfieldID fieldID);
   jdouble      (* GetDoubleField               ) (JNIEnv *env, jobject obj, jfieldID fieldID);
   void         (* SetObjectField               ) (JNIEnv *env, jobject obj, jfieldID fieldID, jobject  value);
   void         (* SetBooleanField              ) (JNIEnv *env, jobject obj, jfieldID fieldID, jboolean value);
   void         (* SetByteField                 ) (JNIEnv *env, jobject obj, jfieldID fieldID, jbyte    value);
   void         (* SetCharField                 ) (JNIEnv *env, jobject obj, jfieldID fieldID, jchar    value);
   void         (* SetShortField                ) (JNIEnv *env, jobject obj, jfieldID fieldID, jshort   value);
   void         (* SetIntField                  ) (JNIEnv *env, jobject obj, jfieldID fieldID, jint     value);
   void         (* SetLongField                 ) (JNIEnv *env, jobject obj, jfieldID fieldID, jlong    value);
   void         (* SetFloatField                ) (JNIEnv *env, jobject obj, jfieldID fieldID, jfloat   value);
   void         (* SetDoubleField               ) (JNIEnv *env, jobject obj, jfieldID fieldID, jdouble  value);
   jmethodID    (* GetStaticMethodID            ) (JNIEnv *env, jclass clazz, const char *name, const char *sig);
   jobject      (* CallStaticObjectMethod       ) (JNIEnv *env, jclass clazz, jmethodID methodID, ...         );
   jobject      (* CallStaticObjectMethodV      ) (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
   jobject      (* CallStaticObjectMethodA      ) (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
   jboolean     (* CallStaticBooleanMethod      ) (JNIEnv *env, jclass clazz, jmethodID methodID, ...         );
   jboolean     (* CallStaticBooleanMethodV     ) (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
   jboolean     (* CallStaticBooleanMethodA     ) (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
   jbyte        (* CallStaticByteMethod         ) (JNIEnv *env, jclass clazz, jmethodID methodID, ...         );
   jbyte        (* CallStaticByteMethodV        ) (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
   jbyte        (* CallStaticByteMethodA        ) (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
   jchar        (* CallStaticCharMethod         ) (JNIEnv *env, jclass clazz, jmethodID methodID, ...         );
   jchar        (* CallStaticCharMethodV        ) (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
   jchar        (* CallStaticCharMethodA        ) (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
   jshort       (* CallStaticShortMethod        ) (JNIEnv *env, jclass clazz, jmethodID methodID, ...         );
   jshort       (* CallStaticShortMethodV       ) (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
   jshort       (* CallStaticShortMethodA       ) (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
   jint         (* CallStaticIntMethod          ) (JNIEnv *env, jclass clazz, jmethodID methodID, ...         );
   jint         (* CallStaticIntMethodV         ) (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
   jint         (* CallStaticIntMethodA         ) (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
   jlong        (* CallStaticLongMethod         ) (JNIEnv *env, jclass clazz, jmethodID methodID, ...         );
   jlong        (* CallStaticLongMethodV        ) (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
   jlong        (* CallStaticLongMethodA        ) (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
   jfloat       (* CallStaticFloatMethod        ) (JNIEnv *env, jclass clazz, jmethodID methodID, ...         );
   jfloat       (* CallStaticFloatMethodV       ) (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
   jfloat       (* CallStaticFloatMethodA       ) (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
   jdouble      (* CallStaticDoubleMethod       ) (JNIEnv *env, jclass clazz, jmethodID methodID, ...         );
   jdouble      (* CallStaticDoubleMethodV      ) (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
   jdouble      (* CallStaticDoubleMethodA      ) (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
   void         (* CallStaticVoidMethod         ) (JNIEnv *env, jclass clazz, jmethodID methodID, ...         );
   void         (* CallStaticVoidMethodV        ) (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
   void         (* CallStaticVoidMethodA        ) (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
   jfieldID     (* GetStaticFieldID             ) (JNIEnv *env, jclass clazz, const char *name, const char *sig);
   jobject      (* GetStaticObjectField         ) (JNIEnv *env, jclass clazz, jfieldID fieldID);
   jboolean     (* GetStaticBooleanField        ) (JNIEnv *env, jclass clazz, jfieldID fieldID);
   jbyte        (* GetStaticByteField           ) (JNIEnv *env, jclass clazz, jfieldID fieldID);
   jchar        (* GetStaticCharField           ) (JNIEnv *env, jclass clazz, jfieldID fieldID);
   jshort       (* GetStaticShortField          ) (JNIEnv *env, jclass clazz, jfieldID fieldID);
   jint         (* GetStaticIntField            ) (JNIEnv *env, jclass clazz, jfieldID fieldID);
   jlong        (* GetStaticLongField           ) (JNIEnv *env, jclass clazz, jfieldID fieldID);
   jfloat       (* GetStaticFloatField          ) (JNIEnv *env, jclass clazz, jfieldID fieldID);
   jdouble      (* GetStaticDoubleField         ) (JNIEnv *env, jclass clazz, jfieldID fieldID);
   void         (* SetStaticObjectField         ) (JNIEnv *env, jclass clazz, jfieldID fieldID, jobject  value);
   void         (* SetStaticBooleanField        ) (JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value);
   void         (* SetStaticByteField           ) (JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte    value);
   void         (* SetStaticCharField           ) (JNIEnv *env, jclass clazz, jfieldID fieldID, jchar    value);
   void         (* SetStaticShortField          ) (JNIEnv *env, jclass clazz, jfieldID fieldID, jshort   value);
   void         (* SetStaticIntField            ) (JNIEnv *env, jclass clazz, jfieldID fieldID, jint     value);
   void         (* SetStaticLongField           ) (JNIEnv *env, jclass clazz, jfieldID fieldID, jlong    value);
   void         (* SetStaticFloatField          ) (JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat   value);
   void         (* SetStaticDoubleField         ) (JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble  value);
   jstring      (* NewString                    ) (JNIEnv *env, const jchar *unicodeChars, jsize len);
   jsize        (* GetStringLength              ) (JNIEnv *env, jstring string);
   const jchar *(* GetStringChars               ) (JNIEnv *env, jstring string, jboolean *isCopy);
   void         (* ReleaseStringChars           ) (JNIEnv *env, jstring string, const jchar *chars);
   jstring      (* NewStringUTF                 ) (JNIEnv *env, const char *bytes);
   jsize        (* GetStringUTFLength           ) (JNIEnv *env, jstring string);
   const char * (* GetStringUTFChars            ) (JNIEnv *env, jstring string, jboolean *isCopy);
   void         (* ReleaseStringUTFChars        ) (JNIEnv *env, jstring string, const char *utf);
   jsize        (* GetArrayLength               ) (JNIEnv *env, jarray array);
   jarray       (* NewObjectArray               ) (JNIEnv *env, jsize length, jclass elementClass, jobject initialElement);
   jobject      (* GetObjectArrayElement        ) (JNIEnv *env, jobjectArray array, jsize index);
   void         (* SetObjectArrayElement        ) (JNIEnv *env, jobjectArray array, jsize index, jobject value);
   jbooleanArray(* NewBooleanArray              ) (JNIEnv *env, jsize length);
   jbyteArray   (* NewByteArray                 ) (JNIEnv *env, jsize length);
   jcharArray   (* NewCharArray                 ) (JNIEnv *env, jsize length);
   jshortArray  (* NewShortArray                ) (JNIEnv *env, jsize length);
   jintArray    (* NewIntArray                  ) (JNIEnv *env, jsize length);
   jlongArray   (* NewLongArray                 ) (JNIEnv *env, jsize length);
   jfloatArray  (* NewFloatArray                ) (JNIEnv *env, jsize length);
   jdoubleArray (* NewDoubleArray               ) (JNIEnv *env, jsize length);
   jboolean *   (* GetBooleanArrayElements      ) (JNIEnv *env, jbooleanArray array, jboolean *isCopy);
   jbyte    *   (* GetByteArrayElements         ) (JNIEnv *env, jbyteArray    array, jboolean *isCopy);
   jchar    *   (* GetCharArrayElements         ) (JNIEnv *env, jcharArray    array, jboolean *isCopy);
   jshort   *   (* GetShortArrayElements        ) (JNIEnv *env, jshortArray   array, jboolean *isCopy);
   jint     *   (* GetIntArrayElements          ) (JNIEnv *env, jintArray     array, jboolean *isCopy);
   jlong    *   (* GetLongArrayElements         ) (JNIEnv *env, jlongArray    array, jboolean *isCopy);
   jfloat   *   (* GetFloatArrayElements        ) (JNIEnv *env, jfloatArray   array, jboolean *isCopy);
   jdouble  *   (* GetDoubleArrayElements       ) (JNIEnv *env, jdoubleArray  array, jboolean *isCopy);
   void         (* ReleaseBooleanArrayElements  ) (JNIEnv *env, jbooleanArray array, jboolean *elems, jint mode);
   void         (* ReleaseByteArrayElements     ) (JNIEnv *env, jbyteArray    array, jbyte    *elems, jint mode);
   void         (* ReleaseCharArrayElements     ) (JNIEnv *env, jcharArray    array, jchar    *elems, jint mode);
   void         (* ReleaseShortArrayElements    ) (JNIEnv *env, jshortArray   array, jshort   *elems, jint mode);
   void         (* ReleaseIntArrayElements      ) (JNIEnv *env, jintArray     array, jint     *elems, jint mode);
   void         (* ReleaseLongArrayElements     ) (JNIEnv *env, jlongArray    array, jlong    *elems, jint mode);
   void         (* ReleaseFloatArrayElements    ) (JNIEnv *env, jfloatArray   array, jfloat   *elems, jint mode);
   void         (* ReleaseDoubleArrayElements   ) (JNIEnv *env, jdoubleArray  array, jdouble  *elems, jint mode);
   void         (* GetBooleanArrayRegion        ) (JNIEnv *env, jbooleanArray array, jsize start, jsize len, jboolean *buf);
   void         (* GetByteArrayRegion           ) (JNIEnv *env, jbyteArray    array, jsize start, jsize len, jbyte    *buf);
   void         (* GetCharArrayRegion           ) (JNIEnv *env, jcharArray    array, jsize start, jsize len, jchar    *buf);
   void         (* GetShortArrayRegion          ) (JNIEnv *env, jshortArray   array, jsize start, jsize len, jshort   *buf);
   void         (* GetIntArrayRegion            ) (JNIEnv *env, jintArray     array, jsize start, jsize len, jint     *buf);
   void         (* GetLongArrayRegion           ) (JNIEnv *env, jlongArray    array, jsize start, jsize len, jlong    *buf);
   void         (* GetFloatArrayRegion          ) (JNIEnv *env, jfloatArray   array, jsize start, jsize len, jfloat   *buf);
   void         (* GetDoubleArrayRegion         ) (JNIEnv *env, jdoubleArray  array, jsize start, jsize len, jdouble  *buf);
   void         (* SetBooleanArrayRegion        ) (JNIEnv *env, jbooleanArray array, jsize start, jsize len, jboolean *buf);
   void         (* SetByteArrayRegion           ) (JNIEnv *env, jbyteArray    array, jsize start, jsize len, jbyte    *buf);
   void         (* SetCharArrayRegion           ) (JNIEnv *env, jcharArray    array, jsize start, jsize len, jchar    *buf);
   void         (* SetShortArrayRegion          ) (JNIEnv *env, jshortArray   array, jsize start, jsize len, jshort   *buf);
   void         (* SetIntArrayRegion            ) (JNIEnv *env, jintArray     array, jsize start, jsize len, jint     *buf);
   void         (* SetLongArrayRegion           ) (JNIEnv *env, jlongArray    array, jsize start, jsize len, jlong    *buf);
   void         (* SetFloatArrayRegion          ) (JNIEnv *env, jfloatArray   array, jsize start, jsize len, jfloat   *buf);
   void         (* SetDoubleArrayRegion         ) (JNIEnv *env, jdoubleArray  array, jsize start, jsize len, jdouble  *buf);
   jint         (* RegisterNatives              ) (JNIEnv *env, jclass clazz/* NYI , const JNINativeMethod *methods */, jint nMethods);
   jint         (* UnregisterNatives            ) (JNIEnv *env, jclass clazz);
   jint         (* MonitorEnter                 ) (JNIEnv *env, jobject obj);
   jint         (* MonitorExit                  ) (JNIEnv *env, jobject obj);
   jint         (* GetJavaVM                    ) (JNIEnv *env, JavaVM **vm);
   void         (* GetStringRegion              ) (JNIEnv *env, jstring str, jsize start, jsize len, jchar *buf);
   void         (* GetStringUTFRegion           ) (JNIEnv *env, jstring str, jsize start, jsize len, char *buf);
   void *       (* GetPrimitiveArrayCritical    ) (JNIEnv *env, jarray array, jboolean *isCopy);
   void         (* ReleasePrimitiveArrayCritical) (JNIEnv *env, jarray array, void *carray, jint mode);
   const jchar *(* GetStringCritical            ) (JNIEnv *env, jstring string, jboolean *isCopy);
   void         (* ReleaseStringCritical        ) (JNIEnv *env, jstring string, const jchar *cstring);
   jweak        (* NewWeakGlobalRef             ) (JNIEnv *env, jobject obj);
   void         (* DeleteWeakGlobalRef          ) (JNIEnv *env, jweak ref);
   jboolean     (* ExceptionCheck               ) (JNIEnv *env);
} JNINativeInterface;

/***************************** Variables *******************************/

/****************************** Macros *********************************/

#define JNI_INT_TO_LONG(n) JAMAICA_INT32_TO_INT64(n)
#define JNI_LONG_TO_INT(n) JAMAICA_INT64_TO_INT32(n)

/***************************** Functions *******************************/

#ifdef __cplusplus
}
#endif

#endif /* __JNI__ */

/* end of file */