/* ***** BEGIN LICENSE BLOCK *****

 * Version: MPL 1.1/GPL 2.0/LGPL 2.1

 *

 * The contents of this file are subject to the Mozilla Public License Version

 * 1.1 (the "License"); you may not use this file except in compliance with

 * the License. You may obtain a copy of the License at

 * http://www.mozilla.org/MPL/

 *

 * Software distributed under the License is distributed on an "AS IS" basis,

 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License

 * for the specific language governing rights and limitations under the

 * License.

 *

 * The Original Code is the Java Runtime Interface.

 *

 * The Initial Developer of the Original Code is

 * Netscape Communications Corporation and Sun Microsystems, Inc.

 * Portions created by the Initial Developer are Copyright (C) 1993-1996

 * the Initial Developer. All Rights Reserved.

 *

 * Contributor(s):

 *

 * Alternatively, the contents of this file may be used under the terms of

 * either the GNU General Public License Version 2 or later (the "GPL"), or

 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),

 * in which case the provisions of the GPL or the LGPL are applicable instead

 * of those above. If you wish to allow use of your version of this file only

 * under the terms of either the GPL or the LGPL, and not to allow others to

 * use your version of this file under the terms of the MPL, indicate your

 * decision by deleting the provisions above and replace them with the notice

 * and other provisions required by the GPL or the LGPL. If you do not delete

 * the provisions above, a recipient may use your version of this file under

 * the terms of any one of the MPL, the GPL or the LGPL.

 *

 * ***** END LICENSE BLOCK ***** */

#ifndef JNI_H

#define JNI_H

#include <stdio.h>

#include <stdarg.h>

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

   and jlong */ 

#include "jni_md.h"

#ifdef __cplusplus

extern "C" {

#endif

/*

 * JNI Types

 */

typedef unsigned char	jboolean;

typedef unsigned short	jchar;

typedef short		jshort;

typedef float		jfloat;

typedef double		jdouble;

typedef jint            jsize;

#ifdef __cplusplus

class _jobject {};

class _jclass : public _jobject {};

class _jthrowable : public _jobject {};

class _jstring : public _jobject {};

class _jarray : public _jobject {};

class _jbooleanArray : public _jarray {};

class _jbyteArray : public _jarray {};

class _jcharArray : public _jarray {};

class _jshortArray : public _jarray {};

class _jintArray : public _jarray {};

class _jlongArray : public _jarray {};

class _jfloatArray : public _jarray {};

class _jdoubleArray : public _jarray {};

class _jobjectArray : public _jarray {};

typedef _jobject *jobject;

typedef _jclass *jclass;

typedef _jthrowable *jthrowable;

typedef _jstring *jstring;

typedef _jarray *jarray;

typedef _jbooleanArray *jbooleanArray;

typedef _jbyteArray *jbyteArray;

typedef _jcharArray *jcharArray;

typedef _jshortArray *jshortArray;

typedef _jintArray *jintArray;

typedef _jlongArray *jlongArray;

typedef _jfloatArray *jfloatArray;

typedef _jdoubleArray *jdoubleArray;

typedef _jobjectArray *jobjectArray;

#else

struct _jobject;

typedef struct _jobject *jobject;

typedef jobject jclass;

typedef jobject jthrowable;

typedef jobject jstring;

typedef jobject jarray;

typedef jarray jbooleanArray;

typedef jarray jbyteArray;

typedef jarray jcharArray;

typedef jarray jshortArray;

typedef jarray jintArray;

typedef jarray jlongArray;

typedef jarray jfloatArray;

typedef jarray jdoubleArray;

typedef jarray jobjectArray;

#endif

typedef jobject jweak;

#if 0	/* moved to jri_md.h */

typedef jobject jref; /* For transition---not meant to be part of public 

			 API anymore.*/

#endif

typedef union jvalue {

    jboolean z;

    jbyte    b;

    jchar    c;

    jshort   s;

    jint     i;

    jlong    j;

    jfloat   f;

    jdouble  d;

    jobject  l;

} jvalue;

struct _jfieldID;

typedef struct _jfieldID *jfieldID;

struct _jmethodID;

typedef struct _jmethodID *jmethodID;

/*

 * jboolean constants

 */

#define JNI_FALSE 0

#define JNI_TRUE 1

/*

 * possible return values for JNI functions.

 */

#define JNI_OK           0                 /* success */

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

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

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

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

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

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

/*

 * used in ReleaseScalarArrayElements

 */

#define JNI_COMMIT 1

#define JNI_ABORT 2

/*

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

 * and function pointer.

 */

typedef struct {

    char *name;

    char *signature;

    void *fnPtr;

} JNINativeMethod;

/*

 * JNI Native Method Interface.

 */

struct JNINativeInterface_;

struct JNIEnv_;

#ifdef __cplusplus

typedef JNIEnv_ JNIEnv;

#else

typedef const struct JNINativeInterface_ *JNIEnv;

#endif

/*

 * JNI Invocation Interface.

 */

struct JNIInvokeInterface_;

struct JavaVM_;

#ifdef __cplusplus

typedef JavaVM_ JavaVM;

#else

typedef const struct JNIInvokeInterface_ *JavaVM;

#endif

struct JNINativeInterface_ {

    void *reserved0;

    void *reserved1;

    void *reserved2;

    void *reserved3;

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

    jclass (JNICALL *DefineClass)

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

       jsize len);

    jclass (JNICALL *FindClass)

      (JNIEnv *env, const char *name);

    jmethodID (JNICALL *FromReflectedMethod)

      (JNIEnv *env, jobject method);

    jfieldID (JNICALL *FromReflectedField)

      (JNIEnv *env, jobject field);

    jobject (JNICALL *ToReflectedMethod)

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

    jclass (JNICALL *GetSuperclass)

      (JNIEnv *env, jclass sub);

    jboolean (JNICALL *IsAssignableFrom)

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

    jobject (JNICALL *ToReflectedField)

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

    jint (JNICALL *Throw)

      (JNIEnv *env, jthrowable obj);

    jint (JNICALL *ThrowNew)

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

    jthrowable (JNICALL *ExceptionOccurred)

      (JNIEnv *env);

    void (JNICALL *ExceptionDescribe)

      (JNIEnv *env);

    void (JNICALL *ExceptionClear)

      (JNIEnv *env);

    void (JNICALL *FatalError)

      (JNIEnv *env, const char *msg);

    jint (JNICALL *PushLocalFrame)

      (JNIEnv *env, jint capacity);

    jobject (JNICALL *PopLocalFrame)

      (JNIEnv *env, jobject result);

    jobject (JNICALL *NewGlobalRef)

      (JNIEnv *env, jobject lobj);

    void (JNICALL *DeleteGlobalRef)

      (JNIEnv *env, jobject gref);

    void (JNICALL *DeleteLocalRef)

      (JNIEnv *env, jobject obj);

    jboolean (JNICALL *IsSameObject)

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

    jobject (JNICALL *NewLocalRef)

      (JNIEnv *env, jobject ref);

    jint (JNICALL *EnsureLocalCapacity)

      (JNIEnv *env, jint capacity);

    jobject (JNICALL *AllocObject)

      (JNIEnv *env, jclass clazz);

    jobject (JNICALL *NewObject)

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

    jobject (JNICALL *NewObjectV)

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

    jobject (JNICALL *NewObjectA)

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

    jclass (JNICALL *GetObjectClass)

      (JNIEnv *env, jobject obj);

    jboolean (JNICALL *IsInstanceOf)

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

    jmethodID (JNICALL *GetMethodID)

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

    jobject (JNICALL *CallObjectMethod)

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

    jobject (JNICALL *CallObjectMethodV)

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

    jobject (JNICALL *CallObjectMethodA)

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

    jboolean (JNICALL *CallBooleanMethod)

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

    jboolean (JNICALL *CallBooleanMethodV)

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

    jboolean (JNICALL *CallBooleanMethodA)

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

    jbyte (JNICALL *CallByteMethod)

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

    jbyte (JNICALL *CallByteMethodV)

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

    jbyte (JNICALL *CallByteMethodA)

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

    jchar (JNICALL *CallCharMethod)

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

    jchar (JNICALL *CallCharMethodV)

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

    jchar (JNICALL *CallCharMethodA)

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

    jshort (JNICALL *CallShortMethod)

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

    jshort (JNICALL *CallShortMethodV)

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

    jshort (JNICALL *CallShortMethodA)

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

    jint (JNICALL *CallIntMethod)

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

    jint (JNICALL *CallIntMethodV)

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

    jint (JNICALL *CallIntMethodA)

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

    jlong (JNICALL *CallLongMethod)

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

    jlong (JNICALL *CallLongMethodV)

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

    jlong (JNICALL *CallLongMethodA)

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

    jfloat (JNICALL *CallFloatMethod)

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

    jfloat (JNICALL *CallFloatMethodV)

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

    jfloat (JNICALL *CallFloatMethodA)

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

    jdouble (JNICALL *CallDoubleMethod)

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

    jdouble (JNICALL *CallDoubleMethodV)

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

    jdouble (JNICALL *CallDoubleMethodA)

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

    void (JNICALL *CallVoidMethod)

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

    void (JNICALL *CallVoidMethodV)

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

    void (JNICALL *CallVoidMethodA)

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

    jobject (JNICALL *CallNonvirtualObjectMethod)

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

    jobject (JNICALL *CallNonvirtualObjectMethodV)

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

       va_list args);

    jobject (JNICALL *CallNonvirtualObjectMethodA)

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

       jvalue * args);

    jboolean (JNICALL *CallNonvirtualBooleanMethod)

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