src/jni.h

   1 /*
   2  * Copyright (C) 2003, 2004, 2005, 2006, 2007
   3  * Robert Lougher <rob@lougher.org.uk>.
   4  *
   5  * This file is part of JamVM.
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation; either version 2,
  10  * or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  20  */
  21
  22 #ifndef __JNI_H__
  23 #define __JNI_H__
  24 #include <stdio.h>
  25 #include <stdarg.h>
  26
  27 #define JNI_VERSION_1_1 0x00010001
  28 #define JNI_VERSION_1_2 0x00010002
  29 #define JNI_VERSION_1_4 0x00010004
  30
  31 #define JNI_FALSE 0
  32 #define JNI_TRUE 1
  33
  34 #define JNI_OK 0
  35 #define JNI_ERR (-1)
  36 #define JNI_EDETACHED (-2)
  37 #define JNI_EVERSION (-3)
  38
  39 #define JNI_COMMIT 1
  40 #define JNI_ABORT 2
  41
  42 #define JNIEXPORT
  43 #define JNICALL
  44
  45 typedef int             jint;
  46 typedef long long       jlong;
  47 typedef signed char     jbyte;
  48 typedef unsigned char   jboolean;
  49 typedef unsigned short  jchar;
  50 typedef short           jshort;
  51 typedef float           jfloat;
  52 typedef double          jdouble;
  53 typedef jint            jsize;
  54
  55 typedef void *jobject;
  56 typedef jobject jclass;
  57 typedef jobject jthrowable;
  58 typedef jobject jstring;
  59 typedef jobject jarray;
  60 typedef jarray jbooleanArray;
  61 typedef jarray jbyteArray;
  62 typedef jarray jcharArray;
  63 typedef jarray jshortArray;
  64 typedef jarray jintArray;
  65 typedef jarray jlongArray;
  66 typedef jarray jfloatArray;
  67 typedef jarray jdoubleArray;
  68 typedef jarray jobjectArray;
  69
  70 typedef jobject jweak;
  71
  72 typedef union jvalue {
  73     jboolean z;
  74     jbyte    b;
  75     jchar    c;
  76     jshort   s;
  77     jint     i;
  78     jlong    j;
  79     jfloat   f;
  80     jdouble  d;
  81     jobject  l;
  82 } jvalue;
  83
  84 typedef struct {
  85     char *name;
  86     char *signature;
  87     void *fnPtr;
  88 } JNINativeMethod;
  89
  90 typedef void *jfieldID;
  91 typedef void *jmethodID;
  92
  93 struct _JNINativeInterface;
  94 typedef const struct _JNINativeInterface *JNIEnv;
  95
  96 struct _JNIInvokeInterface;
  97 typedef const struct _JNIInvokeInterface *JavaVM;
  98
  99 #define VIRTUAL_METHOD(type, native_type)                                                   \
 100 native_type (*Call##type##Method)(JNIEnv *env, jobject obj, jmethodID mID, ...);            \
 101 native_type (*Call##type##MethodV)(JNIEnv *env, jobject obj, jmethodID mID, va_list jargs); \
 102 native_type (*Call##type##MethodA)(JNIEnv *env, jobject obj, jmethodID mID, jvalue *jargs);
 103
 104 #define NONVIRTUAL_METHOD(type, native_type)                                                \
 105 native_type (*CallNonvirtual##type##Method)(JNIEnv *env, jobject obj, jclass clazz,         \
 106                 jmethodID methodID, ...);                                                   \
 107 native_type (*CallNonvirtual##type##MethodV)(JNIEnv *env, jobject obj, jclass clazz,        \
 108                 jmethodID methodID, va_list jargs);                                         \
 109 native_type (*CallNonvirtual##type##MethodA)(JNIEnv *env, jobject obj, jclass clazz,        \
 110                 jmethodID methodID, jvalue *jargs);
 111
 112 #define STATIC_METHOD(type, native_type)                                                    \
 113 native_type (*CallStatic##type##Method)(JNIEnv *env, jclass clazz, jmethodID methodID, ...);\
 114 native_type (*CallStatic##type##MethodV)(JNIEnv *env, jclass clazz, jmethodID methodID,     \
 115                 va_list jargs);                                                             \
 116 native_type (*CallStatic##type##MethodA)(JNIEnv *env, jclass clazz, jmethodID methodID,     \
 117                 jvalue *jargs);
 118
 119 #define VOID_VIRTUAL_METHOD                                                                 \
 120 void (*CallVoidMethod)(JNIEnv *env, jobject obj, jmethodID methodID, ...);                  \
 121 void (*CallVoidMethodV)(JNIEnv *env, jobject obj, jmethodID methodID, va_list jargs);       \
 122 void (*CallVoidMethodA)(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *jargs);       \
 123
 124 #define VOID_NONVIRTUAL_METHOD                                                              \
 125 void (*CallNonvirtualVoidMethod)(JNIEnv *env, jobject obj, jclass clazz,                    \
 126                 jmethodID methodID, ...);                                                   \
 127 void (*CallNonvirtualVoidMethodV)(JNIEnv *env, jobject obj, jclass clazz,                   \
 128                 jmethodID methodID, va_list jargs);                                         \
 129 void (*CallNonvirtualVoidMethodA)(JNIEnv *env, jobject obj, jclass clazz,                   \
 130                 jmethodID methodID, jvalue *jargs);
 131
 132 #define VOID_STATIC_METHOD                                                                  \
 133 void (*CallStaticVoidMethod)(JNIEnv *env, jclass clazz, jmethodID methodID, ...);           \
 134 void (*CallStaticVoidMethodV)(JNIEnv *env, jclass clazz, jmethodID methodID, va_list jargs);\
 135 void (*CallStaticVoidMethodA)(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *jargs);
 136
 137 #define CALL_METHOD(access)         \
 138 access##_METHOD(Object, jobject);   \
 139 access##_METHOD(Boolean, jboolean); \
 140 access##_METHOD(Byte, jbyte);       \
 141 access##_METHOD(Char, jchar);       \
 142 access##_METHOD(Short, jshort);     \
 143 access##_METHOD(Int, jint);         \
 144 access##_METHOD(Long, jlong);       \
 145 access##_METHOD(Float, jfloat);     \
 146 access##_METHOD(Double, jdouble);   \
 147 VOID_##access##_METHOD;
 148
 149
 150 #define NEW_PRIM_ARRAY(type, native_type, array_type) \
 151 native_type##Array (*New##type##Array)(JNIEnv *env, jsize length);
 152
 153 #define GET_ELEMENTS_PRIM_ARRAY(type, native_type, array_type) \
 154 native_type *(*Get##type##ArrayElements)(JNIEnv *env, native_type##Array array, jboolean *isCopy);
 155
 156 #define RELEASE_ELEMENTS_PRIM_ARRAY(type, native_type, array_type) \
 157 void (*Release##type##ArrayElements)(JNIEnv *env, native_type##Array array, native_type *elems, jint mode);
 158
 159 #define GET_REGION_PRIM_ARRAY(type, native_type, array_type) \
 160 void (*Get##type##ArrayRegion)(JNIEnv *env, native_type##Array array, jsize start, jsize len, native_type *buf);
 161
 162 #define SET_REGION_PRIM_ARRAY(type, native_type, array_type) \
 163 void (*Set##type##ArrayRegion)(JNIEnv *env, native_type##Array array, jsize start, jsize len, native_type *buf);
 164
 165 #define PRIM_ARRAY_OP(op)                      \
 166 op##_PRIM_ARRAY(Boolean, jboolean, T_BOOLEAN); \
 167 op##_PRIM_ARRAY(Byte, jbyte, T_BYTE);          \
 168 op##_PRIM_ARRAY(Char, jchar, T_CHAR);          \
 169 op##_PRIM_ARRAY(Short, jshort, T_SHORT);       \
 170 op##_PRIM_ARRAY(Int, jint, T_INT);             \
 171 op##_PRIM_ARRAY(Long, jlong, T_LONG);          \
 172 op##_PRIM_ARRAY(Float, jfloat, T_FLOAT);       \
 173 op##_PRIM_ARRAY(Double, jdouble, T_DOUBLE);
 174
 175
 176 #define GET_FIELD(type, native_type) \
 177 native_type (*Get##type##Field)(JNIEnv *env, jobject obj, jfieldID fieldID);
 178
 179 #define SET_FIELD(type, native_type) \
 180 void (*Set##type##Field)(JNIEnv *env, jobject obj, jfieldID fieldID, native_type value);
 181
 182 #define GET_STATIC_FIELD(type, native_type) \
 183 native_type (*GetStatic##type##Field)(JNIEnv *env, jclass clazz, jfieldID fieldID);
 184
 185 #define SET_STATIC_FIELD(type, native_type) \
 186 void (*SetStatic##type##Field)(JNIEnv *env, jclass clazz, jfieldID fieldID, native_type value);
 187
 188 #define FIELD_OP(op)           \
 189 op##_FIELD(Object, jobject);   \
 190 op##_FIELD(Boolean, jboolean); \
 191 op##_FIELD(Byte, jbyte);       \
 192 op##_FIELD(Char, jchar);       \
 193 op##_FIELD(Short, jshort);     \
 194 op##_FIELD(Int, jint);         \
 195 op##_FIELD(Long, jlong);       \
 196 op##_FIELD(Float, jfloat);     \
 197 op##_FIELD(Double, jdouble);
 198
 199
 200 struct _JNINativeInterface {
 201     void *reserved0;
 202     void *reserved1;
 203     void *reserved2;
 204     void *reserved3;
 205
 206     jint (*GetVersion)(JNIEnv *env);
 207
 208     jclass (*DefineClass)(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len);
 209     jclass (*FindClass)(JNIEnv *env, const char *name);
 210
 211     jmethodID (*FromReflectedMethod)(JNIEnv *env, jobject method);
 212     jfieldID (*FromReflectedField)(JNIEnv *env, jobject field);
 213     jobject (*ToReflectedMethod)(JNIEnv *env, jclass cls, jmethodID methodID, jboolean isStatic);
 214
 215     jclass (*GetSuperclass)(JNIEnv *env, jclass sub);
 216     jboolean (*IsAssignableFrom)(JNIEnv *env, jclass sub, jclass sup);
 217
 218     jobject (*ToReflectedField)(JNIEnv *env, jclass cls, jfieldID fieldID, jboolean isStatic);
 219
 220     jint (*Throw)(JNIEnv *env, jthrowable obj);
 221     jint (*ThrowNew)(JNIEnv *env, jclass clazz, const char *msg);
 222
 223     jthrowable (*ExceptionOccurred)(JNIEnv *env);
 224     void (*ExceptionDescribe)(JNIEnv *env);
 225     void (*ExceptionClear)(JNIEnv *env);
 226     void (*FatalError)(JNIEnv *env, const char *msg);
 227
 228     jint (*PushLocalFrame)(JNIEnv *env, jint capacity);
 229     jobject (*PopLocalFrame)(JNIEnv *env, jobject result);
 230
 231     jobject (*NewGlobalRef)(JNIEnv *env, jobject obj);
 232     void (*DeleteGlobalRef)(JNIEnv *env, jobject obj);
 233     void (*DeleteLocalRef)(JNIEnv *env, jobject obj);
 234     jboolean (*IsSameObject)(JNIEnv *env, jobject obj1, jobject obj2);
 235
 236     jobject (*NewLocalRef)(JNIEnv *env, jobject obj);
 237     jint (*EnsureLocalCapacity)(JNIEnv *env, jint capacity);
 238
 239     jobject (*AllocObject)(JNIEnv *env, jclass clazz);
 240     jobject (*NewObject)(JNIEnv *env, jclass clazz, jmethodID methodID, ...);
 241     jobject (*NewObjectV)(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
 242     jobject (*NewObjectA)(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
 243
 244     jclass (*GetObjectClass)(JNIEnv *env, jobject obj);
 245     jboolean (*IsInstanceOf)(JNIEnv *env, jobject obj, jclass clazz);
 246
 247     jmethodID (*GetMethodID)(JNIEnv *env, jclass clazz, const char *name, const char *sig);
 248
 249     CALL_METHOD(VIRTUAL);
 250     CALL_METHOD(NONVIRTUAL);
 251
 252     jfieldID (*GetFieldID)(JNIEnv *env, jclass clazz, const char *name, const char *sig);
 253
 254     FIELD_OP(GET);
 255     FIELD_OP(SET);
 256
 257     jmethodID (*GetStaticMethodID)(JNIEnv *env, jclass clazz, const char *name, const char *sig);
 258
 259     CALL_METHOD(STATIC);
 260
 261     jfieldID (*GetStaticFieldID)(JNIEnv *env, jclass clazz, const char *name, const char *sig);
 262
 263     FIELD_OP(GET_STATIC);
 264     FIELD_OP(SET_STATIC);
 265
 266     jstring (*NewString)(JNIEnv *env, const jchar *unicode, jsize len);
 267     jsize (*GetStringLength)(JNIEnv *env, jstring str);
 268     const jchar *(*GetStringChars)(JNIEnv *env, jstring str, jboolean *isCopy);
 269     void (*ReleaseStringChars)(JNIEnv *env, jstring str, const jchar *chars);
 270
 271     jstring (*NewStringUTF)(JNIEnv *env, const char *utf);
 272     jsize (*GetStringUTFLength)(JNIEnv *env, jstring str);
 273     const char* (*GetStringUTFChars)(JNIEnv *env, jstring str, jboolean *isCopy);
 274     void (*ReleaseStringUTFChars)(JNIEnv *env, jstring str, const char* chars);
 275
 276     jsize (*GetArrayLength)(JNIEnv *env, jarray array);
 277
 278     jobjectArray (*NewObjectArray)(JNIEnv *env, jsize len, jclass clazz, jobject init);
 279     jobject (*GetObjectArrayElement)(JNIEnv *env, jobjectArray array, jsize index);
 280     void (*SetObjectArrayElement)(JNIEnv *env, jobjectArray array, jsize index, jobject val);
 281
 282     PRIM_ARRAY_OP(NEW);
 283     PRIM_ARRAY_OP(GET_ELEMENTS);
 284     PRIM_ARRAY_OP(RELEASE_ELEMENTS);
 285     PRIM_ARRAY_OP(GET_REGION);
 286     PRIM_ARRAY_OP(SET_REGION);
 287
 288     jint (*RegisterNatives)(JNIEnv *env, jclass clazz, const JNINativeMethod *methods, jint nMethods);
 289     jint (*UnregisterNatives)(JNIEnv *env, jclass clazz);
 290
 291     jint (*MonitorEnter)(JNIEnv *env, jobject obj);
 292     jint (*MonitorExit)(JNIEnv *env, jobject obj);
 293
 294     jint (*GetJavaVM)(JNIEnv *env, JavaVM **vm);
 295
 296     void (*GetStringRegion)(JNIEnv *env, jstring str, jsize start, jsize len, jchar *buf);
 297     void (*GetStringUTFRegion)(JNIEnv *env, jstring str, jsize start, jsize len, char *buf);
 298
 299     void *(*GetPrimitiveArrayCritical)(JNIEnv *env, jarray array, jboolean *isCopy);
 300     void (*ReleasePrimitiveArrayCritical)(JNIEnv *env, jarray array, void *carray, jint mode);
 301
 302     const jchar *(*GetStringCritical)(JNIEnv *env, jstring string, jboolean *isCopy);
 303     void (*ReleaseStringCritical)(JNIEnv *env, jstring string, const jchar *cstring);
 304
 305     jweak (*NewWeakGlobalRef)(JNIEnv *env, jobject obj);
 306     void (*DeleteWeakGlobalRef)(JNIEnv *env, jweak obj);
 307
 308     jboolean (*ExceptionCheck)(JNIEnv *env);
 309     jobject (*NewDirectByteBuffer)(JNIEnv *env, void *addr, jlong capacity);
 310     void* (*GetDirectBufferAddress)(JNIEnv *env, jobject buffer);
 311     jlong (*GetDirectBufferCapacity)(JNIEnv *env, jobject buffer);
 312 };
 313
 314 struct _JNIInvokeInterface {
 315     void *reserved0;
 316     void *reserved1;
 317     void *reserved2;
 318
 319     jint (*DestroyJavaVM)(JavaVM *vm);
 320     jint (*AttachCurrentThread)(JavaVM *vm, void **penv, void *args);
 321     jint (*DetachCurrentThread)(JavaVM *vm);
 322     jint (*GetEnv)(JavaVM *vm, void **penv, jint version);
 323     jint (*AttachCurrentThreadAsDaemon)(JavaVM *vm, void **penv, void *args);
 324 };
 325
 326 typedef struct JavaVMOption {
 327     char *optionString;
 328     void *extraInfo;
 329 } JavaVMOption;
 330
 331 typedef struct JavaVMInitArgs {
 332     jint version;
 333     jint nOptions;
 334     JavaVMOption *options;
 335     jboolean ignoreUnrecognized;
 336 } JavaVMInitArgs;
 337
 338 typedef struct JavaVMAttachArgs {
 339     jint version;
 340     char *name;
 341     jobject group;
 342 } JavaVMAttachArgs;
 343
 344 #undef VIRTUAL_METHOD
 345 #undef NONVIRTUAL_METHOD
 346 #undef STATIC_METHOD
 347 #undef VOID_VIRTUAL_METHOD
 348 #undef VOID_NONVIRTUAL_METHOD
 349 #undef VOID_STATIC_METHOD
 350 #undef CALL_METHOD
 351 #undef NEW_PRIM_ARRAY
 352 #undef GET_ELEMENTS_PRIM_ARRAY
 353 #undef RELEASE_ELEMENTS_PRIM_ARRAY
 354 #undef GET_REGION_PRIM_ARRAY
 355 #undef SET_REGION_PRIM_ARRAY
 356 #undef PRIM_ARRAY_OP
 357 #undef GET_FIELD
 358 #undef SET_FIELD
 359 #undef GET_STATIC_FIELD
 360 #undef SET_STATIC_FIELD
 361 #undef FIELD_OP
 362 #endif