+++ /dev/null
-/*
- * Copyright (C) 2006 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#define LOG_TAG "JNIHelp"
-
-#include "JNIHelp.h"
-#include "cutils/log.h"
-
-#include <stdlib.h>
-#include <string.h>
-#include <assert.h>
-
-/**
- * Equivalent to ScopedLocalRef, but for C_JNIEnv instead. (And slightly more powerful.)
- */
-template<typename T>
-class scoped_local_ref {
-public:
- scoped_local_ref(C_JNIEnv* env, T localRef = NULL)
- : mEnv(env), mLocalRef(localRef)
- {
- }
-
- ~scoped_local_ref() {
- reset();
- }
-
- void reset(T localRef = NULL) {
- if (mLocalRef != NULL) {
- (*mEnv)->DeleteLocalRef(reinterpret_cast<JNIEnv*>(mEnv), mLocalRef);
- mLocalRef = localRef;
- }
- }
-
- T get() const {
- return mLocalRef;
- }
-
-private:
- C_JNIEnv* mEnv;
- T mLocalRef;
-
- // Disallow copy and assignment.
- scoped_local_ref(const scoped_local_ref&);
- void operator=(const scoped_local_ref&);
-};
-
-static jclass findClass(C_JNIEnv* env, const char* className) {
- JNIEnv* e = reinterpret_cast<JNIEnv*>(env);
- return (*env)->FindClass(e, className);
-}
-
-extern "C" int jniRegisterNativeMethods(C_JNIEnv* env, const char* className,
- const JNINativeMethod* gMethods, int numMethods)
-{
- JNIEnv* e = reinterpret_cast<JNIEnv*>(env);
-
- ALOGV("Registering %s natives", className);
-
- scoped_local_ref<jclass> c(env, findClass(env, className));
- if (c.get() == NULL) {
- ALOGE("Native registration unable to find class '%s', aborting", className);
- abort();
- }
-
- if ((*env)->RegisterNatives(e, c.get(), gMethods, numMethods) < 0) {
- ALOGE("RegisterNatives failed for '%s', aborting", className);
- abort();
- }
-
- return 0;
-}
-
-/*
- * Returns a human-readable summary of an exception object. The buffer will
- * be populated with the "binary" class name and, if present, the
- * exception message.
- */
-static char* getExceptionSummary0(C_JNIEnv* env, jthrowable exception) {
- JNIEnv* e = reinterpret_cast<JNIEnv*>(env);
-
- /* get the name of the exception's class */
- scoped_local_ref<jclass> exceptionClass(env, (*env)->GetObjectClass(e, exception)); // can't fail
- scoped_local_ref<jclass> classClass(env,
- (*env)->GetObjectClass(e, exceptionClass.get())); // java.lang.Class, can't fail
- jmethodID classGetNameMethod =
- (*env)->GetMethodID(e, classClass.get(), "getName", "()Ljava/lang/String;");
- scoped_local_ref<jstring> classNameStr(env,
- (jstring) (*env)->CallObjectMethod(e, exceptionClass.get(), classGetNameMethod));
- if (classNameStr.get() == NULL) {
- return NULL;
- }
-
- /* get printable string */
- const char* classNameChars = (*env)->GetStringUTFChars(e, classNameStr.get(), NULL);
- if (classNameChars == NULL) {
- return NULL;
- }
-
- /* if the exception has a detail message, get that */
- jmethodID getMessage =
- (*env)->GetMethodID(e, exceptionClass.get(), "getMessage", "()Ljava/lang/String;");
- scoped_local_ref<jstring> messageStr(env,
- (jstring) (*env)->CallObjectMethod(e, exception, getMessage));
- if (messageStr.get() == NULL) {
- return strdup(classNameChars);
- }
-
- char* result = NULL;
- const char* messageChars = (*env)->GetStringUTFChars(e, messageStr.get(), NULL);
- if (messageChars != NULL) {
- asprintf(&result, "%s: %s", classNameChars, messageChars);
- (*env)->ReleaseStringUTFChars(e, messageStr.get(), messageChars);
- } else {
- (*env)->ExceptionClear(e); // clear OOM
- asprintf(&result, "%s: <error getting message>", classNameChars);
- }
-
- (*env)->ReleaseStringUTFChars(e, classNameStr.get(), classNameChars);
- return result;
-}
-
-static char* getExceptionSummary(C_JNIEnv* env, jthrowable exception) {
- JNIEnv* e = reinterpret_cast<JNIEnv*>(env);
- char* result = getExceptionSummary0(env, exception);
- if (result == NULL) {
- (*env)->ExceptionClear(e);
- result = strdup("<error getting class name>");
- }
- return result;
-}
-
-/*
- * Returns an exception (with stack trace) as a string.
- */
-static char* getStackTrace(C_JNIEnv* env, jthrowable exception) {
- JNIEnv* e = reinterpret_cast<JNIEnv*>(env);
-
- scoped_local_ref<jclass> stringWriterClass(env, findClass(env, "java/io/StringWriter"));
- if (stringWriterClass.get() == NULL) {
- return NULL;
- }
-
- jmethodID stringWriterCtor = (*env)->GetMethodID(e, stringWriterClass.get(), "<init>", "()V");
- jmethodID stringWriterToStringMethod =
- (*env)->GetMethodID(e, stringWriterClass.get(), "toString", "()Ljava/lang/String;");
-
- scoped_local_ref<jclass> printWriterClass(env, findClass(env, "java/io/PrintWriter"));
- if (printWriterClass.get() == NULL) {
- return NULL;
- }
-
- jmethodID printWriterCtor =
- (*env)->GetMethodID(e, printWriterClass.get(), "<init>", "(Ljava/io/Writer;)V");
-
- scoped_local_ref<jobject> stringWriter(env,
- (*env)->NewObject(e, stringWriterClass.get(), stringWriterCtor));
- if (stringWriter.get() == NULL) {
- return NULL;
- }
-
- jobject printWriter =
- (*env)->NewObject(e, printWriterClass.get(), printWriterCtor, stringWriter.get());
- if (printWriter == NULL) {
- return NULL;
- }
-
- scoped_local_ref<jclass> exceptionClass(env, (*env)->GetObjectClass(e, exception)); // can't fail
- jmethodID printStackTraceMethod =
- (*env)->GetMethodID(e, exceptionClass.get(), "printStackTrace", "(Ljava/io/PrintWriter;)V");
- (*env)->CallVoidMethod(e, exception, printStackTraceMethod, printWriter);
-
- if ((*env)->ExceptionCheck(e)) {
- return NULL;
- }
-
- scoped_local_ref<jstring> messageStr(env,
- (jstring) (*env)->CallObjectMethod(e, stringWriter.get(), stringWriterToStringMethod));
- if (messageStr.get() == NULL) {
- return NULL;
- }
-
- const char* utfChars = (*env)->GetStringUTFChars(e, messageStr.get(), NULL);
- if (utfChars == NULL) {
- return NULL;
- }
-
- char* result = strdup(utfChars);
- (*env)->ReleaseStringUTFChars(e, messageStr.get(), utfChars);
- return result;
-}
-
-extern "C" int jniThrowException(C_JNIEnv* env, const char* className, const char* msg) {
- JNIEnv* e = reinterpret_cast<JNIEnv*>(env);
-
- if ((*env)->ExceptionCheck(e)) {
- /* TODO: consider creating the new exception with this as "cause" */
- scoped_local_ref<jthrowable> exception(env, (*env)->ExceptionOccurred(e));
- (*env)->ExceptionClear(e);
-
- if (exception.get() != NULL) {
- char* text = getExceptionSummary(env, exception.get());
- ALOGW("Discarding pending exception (%s) to throw %s", text, className);
- free(text);
- }
- }
-
- scoped_local_ref<jclass> exceptionClass(env, findClass(env, className));
- if (exceptionClass.get() == NULL) {
- ALOGE("Unable to find exception class %s", className);
- /* ClassNotFoundException now pending */
- return -1;
- }
-
- if ((*env)->ThrowNew(e, exceptionClass.get(), msg) != JNI_OK) {
- ALOGE("Failed throwing '%s' '%s'", className, msg);
- /* an exception, most likely OOM, will now be pending */
- return -1;
- }
-
- return 0;
-}
-
-int jniThrowExceptionFmt(C_JNIEnv* env, const char* className, const char* fmt, va_list args) {
- char msgBuf[512];
- vsnprintf(msgBuf, sizeof(msgBuf), fmt, args);
- return jniThrowException(env, className, msgBuf);
-}
-
-int jniThrowNullPointerException(C_JNIEnv* env, const char* msg) {
- return jniThrowException(env, "java/lang/NullPointerException", msg);
-}
-
-int jniThrowRuntimeException(C_JNIEnv* env, const char* msg) {
- return jniThrowException(env, "java/lang/RuntimeException", msg);
-}
-
-int jniThrowIOException(C_JNIEnv* env, int errnum) {
- char buffer[80];
- const char* message = jniStrError(errnum, buffer, sizeof(buffer));
- return jniThrowException(env, "java/io/IOException", message);
-}
-
-void jniLogException(C_JNIEnv* env, int priority, const char* tag, jthrowable exception) {
- JNIEnv* e = reinterpret_cast<JNIEnv*>(env);
-
- scoped_local_ref<jthrowable> currentException(env, (*env)->ExceptionOccurred(e));
- if (exception == NULL) {
- exception = currentException.get();
- if (exception == NULL) {
- return;
- }
- }
-
- if (currentException.get() != NULL) {
- (*env)->ExceptionClear(e);
- }
-
- char* buffer = getStackTrace(env, exception);
- if (buffer == NULL) {
- (*env)->ExceptionClear(e);
- buffer = getExceptionSummary(env, exception);
- }
-
- __android_log_write(priority, tag, buffer);
- free(buffer);
-
- if (currentException.get() != NULL) {
- (*env)->Throw(e, currentException.get()); // rethrow
- }
-}
-
-const char* jniStrError(int errnum, char* buf, size_t buflen) {
- // Note: glibc has a nonstandard strerror_r that returns char* rather than POSIX's int.
- // char *strerror_r(int errnum, char *buf, size_t n);
- char* ret = (char*) strerror_r(errnum, buf, buflen);
- if (((int)ret) == 0) {
- // POSIX strerror_r, success
- return buf;
- } else if (((int)ret) == -1) {
- // POSIX strerror_r, failure
- // (Strictly, POSIX only guarantees a value other than 0. The safest
- // way to implement this function is to use C++ and overload on the
- // type of strerror_r to accurately distinguish GNU from POSIX. But
- // realistic implementations will always return -1.)
- snprintf(buf, buflen, "errno %d", errnum);
- return buf;
- } else {
- // glibc strerror_r returning a string
- return ret;
- }
-}
-
-static struct CachedFields {
- jclass fileDescriptorClass;
- jmethodID fileDescriptorCtor;
- jfieldID descriptorField;
-} gCachedFields;
-
-int registerJniHelp(JNIEnv* env) {
- gCachedFields.fileDescriptorClass =
- reinterpret_cast<jclass>(env->NewGlobalRef(env->FindClass("java/io/FileDescriptor")));
- if (gCachedFields.fileDescriptorClass == NULL) {
- return -1;
- }
-
- gCachedFields.fileDescriptorCtor =
- env->GetMethodID(gCachedFields.fileDescriptorClass, "<init>", "()V");
- if (gCachedFields.fileDescriptorCtor == NULL) {
- return -1;
- }
-
- gCachedFields.descriptorField =
- env->GetFieldID(gCachedFields.fileDescriptorClass, "descriptor", "I");
- if (gCachedFields.descriptorField == NULL) {
- return -1;
- }
-
- return 0;
-}
-
-jobject jniCreateFileDescriptor(C_JNIEnv* env, int fd) {
- JNIEnv* e = reinterpret_cast<JNIEnv*>(env);
- jobject fileDescriptor = (*env)->NewObject(e,
- gCachedFields.fileDescriptorClass, gCachedFields.fileDescriptorCtor);
- jniSetFileDescriptorOfFD(env, fileDescriptor, fd);
- return fileDescriptor;
-}
-
-int jniGetFDFromFileDescriptor(C_JNIEnv* env, jobject fileDescriptor) {
- JNIEnv* e = reinterpret_cast<JNIEnv*>(env);
- return (*env)->GetIntField(e, fileDescriptor, gCachedFields.descriptorField);
-}
-
-void jniSetFileDescriptorOfFD(C_JNIEnv* env, jobject fileDescriptor, int value) {
- JNIEnv* e = reinterpret_cast<JNIEnv*>(env);
- (*env)->SetIntField(e, fileDescriptor, gCachedFields.descriptorField, value);
-}
-
-/*
- * DO NOT USE THIS FUNCTION
- *
- * Get a pointer to the elements of a non-movable array.
- *
- * The semantics are similar to GetDirectBufferAddress. Specifically, the VM
- * guarantees that the array will not move, and the caller must ensure that
- * it does not continue to use the pointer after the object is collected.
- *
- * We currently use an illegal sequence that trips up CheckJNI when
- * the "forcecopy" mode is enabled. We pass in a magic value to work
- * around the problem.
- *
- * Returns NULL if the array is movable.
- */
-#define kNoCopyMagic 0xd5aab57f /* also in CheckJni.c */
-extern "C" jbyte* jniGetNonMovableArrayElements(C_JNIEnv* env, jarray arrayObj) {
- JNIEnv* e = reinterpret_cast<JNIEnv*>(env);
-
- jbyteArray byteArray = reinterpret_cast<jbyteArray>(arrayObj);
-
- /*
- * Normally the "isCopy" parameter is for a return value only, so the
- * non-CheckJNI VM will ignore whatever we pass in.
- */
- uint32_t noCopy = kNoCopyMagic;
- jbyte* result = (*env)->GetByteArrayElements(e, byteArray, reinterpret_cast<jboolean*>(&noCopy));
-
- /*
- * The non-CheckJNI implementation only cares about the array object,
- * so we can replace the element pointer with the magic value.
- */
- (*env)->ReleaseByteArrayElements(e, byteArray, reinterpret_cast<jbyte*>(kNoCopyMagic), 0);
- return result;
-}
+++ /dev/null
-/*
- * Copyright (C) 2006 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/*
- * JNI specification, as defined by Sun:
- * http://java.sun.com/javase/6/docs/technotes/guides/jni/spec/jniTOC.html
- *
- * Everything here is expected to be VM-neutral.
- */
-
-#ifndef JNI_H_
-#define JNI_H_
-
-#include <stdarg.h>
-
-/*
- * Primitive types that match up with Java equivalents.
- */
-#ifdef HAVE_INTTYPES_H
-# include <inttypes.h> /* C99 */
-typedef uint8_t jboolean; /* unsigned 8 bits */
-typedef int8_t jbyte; /* signed 8 bits */
-typedef uint16_t jchar; /* unsigned 16 bits */
-typedef int16_t jshort; /* signed 16 bits */
-typedef int32_t jint; /* signed 32 bits */
-typedef int64_t jlong; /* signed 64 bits */
-typedef float jfloat; /* 32-bit IEEE 754 */
-typedef double jdouble; /* 64-bit IEEE 754 */
-#else
-typedef unsigned char jboolean; /* unsigned 8 bits */
-typedef signed char jbyte; /* signed 8 bits */
-typedef unsigned short jchar; /* unsigned 16 bits */
-typedef short jshort; /* signed 16 bits */
-typedef int jint; /* signed 32 bits */
-typedef long long jlong; /* signed 64 bits */
-typedef float jfloat; /* 32-bit IEEE 754 */
-typedef double jdouble; /* 64-bit IEEE 754 */
-#endif
-
-/* "cardinal indices and sizes" */
-typedef jint jsize;
-
-#ifdef __cplusplus
-/*
- * Reference types, in C++
- */
-class _jobject {};
-class _jclass : public _jobject {};
-class _jstring : public _jobject {};
-class _jarray : public _jobject {};
-class _jobjectArray : public _jarray {};
-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 _jthrowable : public _jobject {};
-
-typedef _jobject* jobject;
-typedef _jclass* jclass;
-typedef _jstring* jstring;
-typedef _jarray* jarray;
-typedef _jobjectArray* jobjectArray;
-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 _jthrowable* jthrowable;
-typedef _jobject* jweak;
-
-
-#else /* not __cplusplus */
-
-/*
- * Reference types, in C.
- */
-typedef void* jobject;
-typedef jobject jclass;
-typedef jobject jstring;
-typedef jobject jarray;
-typedef jarray jobjectArray;
-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 jobject jthrowable;
-typedef jobject jweak;
-
-#endif /* not __cplusplus */
-
-struct _jfieldID; /* opaque structure */
-typedef struct _jfieldID* jfieldID; /* field IDs */
-
-struct _jmethodID; /* opaque structure */
-typedef struct _jmethodID* jmethodID; /* method IDs */
-
-struct JNIInvokeInterface;
-
-typedef union jvalue {
- jboolean z;
- jbyte b;
- jchar c;
- jshort s;
- jint i;
- jlong j;
- jfloat f;
- jdouble d;
- jobject l;
-} jvalue;
-
-typedef enum jobjectRefType {
- JNIInvalidRefType = 0,
- JNILocalRefType = 1,
- JNIGlobalRefType = 2,
- JNIWeakGlobalRefType = 3
-} jobjectRefType;
-
-typedef struct {
- const char* name;
- const char* signature;
- void* fnPtr;
-} JNINativeMethod;
-
-struct _JNIEnv;
-struct _JavaVM;
-typedef const struct JNINativeInterface* C_JNIEnv;
-
-#if defined(__cplusplus)
-typedef _JNIEnv JNIEnv;
-typedef _JavaVM JavaVM;
-#else
-typedef const struct JNINativeInterface* JNIEnv;
-typedef const struct JNIInvokeInterface* JavaVM;
-#endif
-
-/*
- * Table of interface function pointers.
- */
-struct JNINativeInterface {
- void* reserved0;
- void* reserved1;
- void* reserved2;
- void* reserved3;
-
- jint (*GetVersion)(JNIEnv *);
-
- jclass (*DefineClass)(JNIEnv*, const char*, jobject, const jbyte*,
- jsize);
- jclass (*FindClass)(JNIEnv*, const char*);
-
- jmethodID (*FromReflectedMethod)(JNIEnv*, jobject);
- jfieldID (*FromReflectedField)(JNIEnv*, jobject);
- /* spec doesn't show jboolean parameter */
- jobject (*ToReflectedMethod)(JNIEnv*, jclass, jmethodID, jboolean);
-
- jclass (*GetSuperclass)(JNIEnv*, jclass);
- jboolean (*IsAssignableFrom)(JNIEnv*, jclass, jclass);
-
- /* spec doesn't show jboolean parameter */
- jobject (*ToReflectedField)(JNIEnv*, jclass, jfieldID, jboolean);
-
- jint (*Throw)(JNIEnv*, jthrowable);
- jint (*ThrowNew)(JNIEnv *, jclass, const char *);
- jthrowable (*ExceptionOccurred)(JNIEnv*);
- void (*ExceptionDescribe)(JNIEnv*);
- void (*ExceptionClear)(JNIEnv*);
- void (*FatalError)(JNIEnv*, const char*);
-
- jint (*PushLocalFrame)(JNIEnv*, jint);
- jobject (*PopLocalFrame)(JNIEnv*, jobject);
-
- jobject (*NewGlobalRef)(JNIEnv*, jobject);
- void (*DeleteGlobalRef)(JNIEnv*, jobject);
- void (*DeleteLocalRef)(JNIEnv*, jobject);
- jboolean (*IsSameObject)(JNIEnv*, jobject, jobject);
-
- jobject (*NewLocalRef)(JNIEnv*, jobject);
- jint (*EnsureLocalCapacity)(JNIEnv*, jint);
-
- jobject (*AllocObject)(JNIEnv*, jclass);
- jobject (*NewObject)(JNIEnv*, jclass, jmethodID, ...);
- jobject (*NewObjectV)(JNIEnv*, jclass, jmethodID, va_list);
- jobject (*NewObjectA)(JNIEnv*, jclass, jmethodID, jvalue*);
-
- jclass (*GetObjectClass)(JNIEnv*, jobject);
- jboolean (*IsInstanceOf)(JNIEnv*, jobject, jclass);
- jmethodID (*GetMethodID)(JNIEnv*, jclass, const char*, const char*);
-
- jobject (*CallObjectMethod)(JNIEnv*, jobject, jmethodID, ...);
- jobject (*CallObjectMethodV)(JNIEnv*, jobject, jmethodID, va_list);
- jobject (*CallObjectMethodA)(JNIEnv*, jobject, jmethodID, jvalue*);
- jboolean (*CallBooleanMethod)(JNIEnv*, jobject, jmethodID, ...);
- jboolean (*CallBooleanMethodV)(JNIEnv*, jobject, jmethodID, va_list);
- jboolean (*CallBooleanMethodA)(JNIEnv*, jobject, jmethodID, jvalue*);
- jbyte (*CallByteMethod)(JNIEnv*, jobject, jmethodID, ...);
- jbyte (*CallByteMethodV)(JNIEnv*, jobject, jmethodID, va_list);
- jbyte (*CallByteMethodA)(JNIEnv*, jobject, jmethodID, jvalue*);
- jchar (*CallCharMethod)(JNIEnv*, jobject, jmethodID, ...);
- jchar (*CallCharMethodV)(JNIEnv*, jobject, jmethodID, va_list);
- jchar (*CallCharMethodA)(JNIEnv*, jobject, jmethodID, jvalue*);
- jshort (*CallShortMethod)(JNIEnv*, jobject, jmethodID, ...);
- jshort (*CallShortMethodV)(JNIEnv*, jobject, jmethodID, va_list);
- jshort (*CallShortMethodA)(JNIEnv*, jobject, jmethodID, jvalue*);
- jint (*CallIntMethod)(JNIEnv*, jobject, jmethodID, ...);
- jint (*CallIntMethodV)(JNIEnv*, jobject, jmethodID, va_list);
- jint (*CallIntMethodA)(JNIEnv*, jobject, jmethodID, jvalue*);
- jlong (*CallLongMethod)(JNIEnv*, jobject, jmethodID, ...);
- jlong (*CallLongMethodV)(JNIEnv*, jobject, jmethodID, va_list);
- jlong (*CallLongMethodA)(JNIEnv*, jobject, jmethodID, jvalue*);
- jfloat (*CallFloatMethod)(JNIEnv*, jobject, jmethodID, ...);
- jfloat (*CallFloatMethodV)(JNIEnv*, jobject, jmethodID, va_list);
- jfloat (*CallFloatMethodA)(JNIEnv*, jobject, jmethodID, jvalue*);
- jdouble (*CallDoubleMethod)(JNIEnv*, jobject, jmethodID, ...);
- jdouble (*CallDoubleMethodV)(JNIEnv*, jobject, jmethodID, va_list);
- jdouble (*CallDoubleMethodA)(JNIEnv*, jobject, jmethodID, jvalue*);
- void (*CallVoidMethod)(JNIEnv*, jobject, jmethodID, ...);
- void (*CallVoidMethodV)(JNIEnv*, jobject, jmethodID, va_list);
- void (*CallVoidMethodA)(JNIEnv*, jobject, jmethodID, jvalue*);
-
- jobject (*CallNonvirtualObjectMethod)(JNIEnv*, jobject, jclass,
- jmethodID, ...);
- jobject (*CallNonvirtualObjectMethodV)(JNIEnv*, jobject, jclass,
- jmethodID, va_list);
- jobject (*CallNonvirtualObjectMethodA)(JNIEnv*, jobject, jclass,
- jmethodID, jvalue*);
- jboolean (*CallNonvirtualBooleanMethod)(JNIEnv*, jobject, jclass,
- jmethodID, ...);
- jboolean (*CallNonvirtualBooleanMethodV)(JNIEnv*, jobject, jclass,
- jmethodID, va_list);
- jboolean (*CallNonvirtualBooleanMethodA)(JNIEnv*, jobject, jclass,
- jmethodID, jvalue*);
- jbyte (*CallNonvirtualByteMethod)(JNIEnv*, jobject, jclass,
- jmethodID, ...);
- jbyte (*CallNonvirtualByteMethodV)(JNIEnv*, jobject, jclass,
- jmethodID, va_list);
- jbyte (*CallNonvirtualByteMethodA)(JNIEnv*, jobject, jclass,
- jmethodID, jvalue*);
- jchar (*CallNonvirtualCharMethod)(JNIEnv*, jobject, jclass,
- jmethodID, ...);
- jchar (*CallNonvirtualCharMethodV)(JNIEnv*, jobject, jclass,
- jmethodID, va_list);
- jchar (*CallNonvirtualCharMethodA)(JNIEnv*, jobject, jclass,
- jmethodID, jvalue*);
- jshort (*CallNonvirtualShortMethod)(JNIEnv*, jobject, jclass,
- jmethodID, ...);
- jshort (*CallNonvirtualShortMethodV)(JNIEnv*, jobject, jclass,
- jmethodID, va_list);
- jshort (*CallNonvirtualShortMethodA)(JNIEnv*, jobject, jclass,
- jmethodID, jvalue*);
- jint (*CallNonvirtualIntMethod)(JNIEnv*, jobject, jclass,
- jmethodID, ...);
- jint (*CallNonvirtualIntMethodV)(JNIEnv*, jobject, jclass,
- jmethodID, va_list);
- jint (*CallNonvirtualIntMethodA)(JNIEnv*, jobject, jclass,
- jmethodID, jvalue*);
- jlong (*CallNonvirtualLongMethod)(JNIEnv*, jobject, jclass,
- jmethodID, ...);
- jlong (*CallNonvirtualLongMethodV)(JNIEnv*, jobject, jclass,
- jmethodID, va_list);
- jlong (*CallNonvirtualLongMethodA)(JNIEnv*, jobject, jclass,
- jmethodID, jvalue*);
- jfloat (*CallNonvirtualFloatMethod)(JNIEnv*, jobject, jclass,
- jmethodID, ...);
- jfloat (*CallNonvirtualFloatMethodV)(JNIEnv*, jobject, jclass,
- jmethodID, va_list);
- jfloat (*CallNonvirtualFloatMethodA)(JNIEnv*, jobject, jclass,
- jmethodID, jvalue*);
- jdouble (*CallNonvirtualDoubleMethod)(JNIEnv*, jobject, jclass,
- jmethodID, ...);
- jdouble (*CallNonvirtualDoubleMethodV)(JNIEnv*, jobject, jclass,
- jmethodID, va_list);
- jdouble (*CallNonvirtualDoubleMethodA)(JNIEnv*, jobject, jclass,
- jmethodID, jvalue*);
- void (*CallNonvirtualVoidMethod)(JNIEnv*, jobject, jclass,
- jmethodID, ...);
- void (*CallNonvirtualVoidMethodV)(JNIEnv*, jobject, jclass,
- jmethodID, va_list);
- void (*CallNonvirtualVoidMethodA)(JNIEnv*, jobject, jclass,
- jmethodID, jvalue*);
-
- jfieldID (*GetFieldID)(JNIEnv*, jclass, const char*, const char*);
-
- jobject (*GetObjectField)(JNIEnv*, jobject, jfieldID);
- jboolean (*GetBooleanField)(JNIEnv*, jobject, jfieldID);
- jbyte (*GetByteField)(JNIEnv*, jobject, jfieldID);
- jchar (*GetCharField)(JNIEnv*, jobject, jfieldID);
- jshort (*GetShortField)(JNIEnv*, jobject, jfieldID);
- jint (*GetIntField)(JNIEnv*, jobject, jfieldID);
- jlong (*GetLongField)(JNIEnv*, jobject, jfieldID);
- jfloat (*GetFloatField)(JNIEnv*, jobject, jfieldID);
- jdouble (*GetDoubleField)(JNIEnv*, jobject, jfieldID);
-
- void (*SetObjectField)(JNIEnv*, jobject, jfieldID, jobject);
- void (*SetBooleanField)(JNIEnv*, jobject, jfieldID, jboolean);
- void (*SetByteField)(JNIEnv*, jobject, jfieldID, jbyte);
- void (*SetCharField)(JNIEnv*, jobject, jfieldID, jchar);
- void (*SetShortField)(JNIEnv*, jobject, jfieldID, jshort);
- void (*SetIntField)(JNIEnv*, jobject, jfieldID, jint);
- void (*SetLongField)(JNIEnv*, jobject, jfieldID, jlong);
- void (*SetFloatField)(JNIEnv*, jobject, jfieldID, jfloat);
- void (*SetDoubleField)(JNIEnv*, jobject, jfieldID, jdouble);
-
- jmethodID (*GetStaticMethodID)(JNIEnv*, jclass, const char*, const char*);
-
- jobject (*CallStaticObjectMethod)(JNIEnv*, jclass, jmethodID, ...);
- jobject (*CallStaticObjectMethodV)(JNIEnv*, jclass, jmethodID, va_list);
- jobject (*CallStaticObjectMethodA)(JNIEnv*, jclass, jmethodID, jvalue*);
- jboolean (*CallStaticBooleanMethod)(JNIEnv*, jclass, jmethodID, ...);
- jboolean (*CallStaticBooleanMethodV)(JNIEnv*, jclass, jmethodID,
- va_list);
- jboolean (*CallStaticBooleanMethodA)(JNIEnv*, jclass, jmethodID,
- jvalue*);
- jbyte (*CallStaticByteMethod)(JNIEnv*, jclass, jmethodID, ...);
- jbyte (*CallStaticByteMethodV)(JNIEnv*, jclass, jmethodID, va_list);
- jbyte (*CallStaticByteMethodA)(JNIEnv*, jclass, jmethodID, jvalue*);
- jchar (*CallStaticCharMethod)(JNIEnv*, jclass, jmethodID, ...);
- jchar (*CallStaticCharMethodV)(JNIEnv*, jclass, jmethodID, va_list);
- jchar (*CallStaticCharMethodA)(JNIEnv*, jclass, jmethodID, jvalue*);
- jshort (*CallStaticShortMethod)(JNIEnv*, jclass, jmethodID, ...);
- jshort (*CallStaticShortMethodV)(JNIEnv*, jclass, jmethodID, va_list);
- jshort (*CallStaticShortMethodA)(JNIEnv*, jclass, jmethodID, jvalue*);
- jint (*CallStaticIntMethod)(JNIEnv*, jclass, jmethodID, ...);
- jint (*CallStaticIntMethodV)(JNIEnv*, jclass, jmethodID, va_list);
- jint (*CallStaticIntMethodA)(JNIEnv*, jclass, jmethodID, jvalue*);
- jlong (*CallStaticLongMethod)(JNIEnv*, jclass, jmethodID, ...);
- jlong (*CallStaticLongMethodV)(JNIEnv*, jclass, jmethodID, va_list);
- jlong (*CallStaticLongMethodA)(JNIEnv*, jclass, jmethodID, jvalue*);
- jfloat (*CallStaticFloatMethod)(JNIEnv*, jclass, jmethodID, ...);
- jfloat (*CallStaticFloatMethodV)(JNIEnv*, jclass, jmethodID, va_list);
- jfloat (*CallStaticFloatMethodA)(JNIEnv*, jclass, jmethodID, jvalue*);
- jdouble (*CallStaticDoubleMethod)(JNIEnv*, jclass, jmethodID, ...);
- jdouble (*CallStaticDoubleMethodV)(JNIEnv*, jclass, jmethodID, va_list);
- jdouble (*CallStaticDoubleMethodA)(JNIEnv*, jclass, jmethodID, jvalue*);
- void (*CallStaticVoidMethod)(JNIEnv*, jclass, jmethodID, ...);
- void (*CallStaticVoidMethodV)(JNIEnv*, jclass, jmethodID, va_list);
- void (*CallStaticVoidMethodA)(JNIEnv*, jclass, jmethodID, jvalue*);
-
- jfieldID (*GetStaticFieldID)(JNIEnv*, jclass, const char*,
- const char*);
-
- jobject (*GetStaticObjectField)(JNIEnv*, jclass, jfieldID);
- jboolean (*GetStaticBooleanField)(JNIEnv*, jclass, jfieldID);
- jbyte (*GetStaticByteField)(JNIEnv*, jclass, jfieldID);
- jchar (*GetStaticCharField)(JNIEnv*, jclass, jfieldID);
- jshort (*GetStaticShortField)(JNIEnv*, jclass, jfieldID);
- jint (*GetStaticIntField)(JNIEnv*, jclass, jfieldID);
- jlong (*GetStaticLongField)(JNIEnv*, jclass, jfieldID);
- jfloat (*GetStaticFloatField)(JNIEnv*, jclass, jfieldID);
- jdouble (*GetStaticDoubleField)(JNIEnv*, jclass, jfieldID);
-
- void (*SetStaticObjectField)(JNIEnv*, jclass, jfieldID, jobject);
- void (*SetStaticBooleanField)(JNIEnv*, jclass, jfieldID, jboolean);
- void (*SetStaticByteField)(JNIEnv*, jclass, jfieldID, jbyte);
- void (*SetStaticCharField)(JNIEnv*, jclass, jfieldID, jchar);
- void (*SetStaticShortField)(JNIEnv*, jclass, jfieldID, jshort);
- void (*SetStaticIntField)(JNIEnv*, jclass, jfieldID, jint);
- void (*SetStaticLongField)(JNIEnv*, jclass, jfieldID, jlong);
- void (*SetStaticFloatField)(JNIEnv*, jclass, jfieldID, jfloat);
- void (*SetStaticDoubleField)(JNIEnv*, jclass, jfieldID, jdouble);
-
- jstring (*NewString)(JNIEnv*, const jchar*, jsize);
- jsize (*GetStringLength)(JNIEnv*, jstring);
- const jchar* (*GetStringChars)(JNIEnv*, jstring, jboolean*);
- void (*ReleaseStringChars)(JNIEnv*, jstring, const jchar*);
- jstring (*NewStringUTF)(JNIEnv*, const char*);
- jsize (*GetStringUTFLength)(JNIEnv*, jstring);
- /* JNI spec says this returns const jbyte*, but that's inconsistent */
- const char* (*GetStringUTFChars)(JNIEnv*, jstring, jboolean*);
- void (*ReleaseStringUTFChars)(JNIEnv*, jstring, const char*);
- jsize (*GetArrayLength)(JNIEnv*, jarray);
- jobjectArray (*NewObjectArray)(JNIEnv*, jsize, jclass, jobject);
- jobject (*GetObjectArrayElement)(JNIEnv*, jobjectArray, jsize);
- void (*SetObjectArrayElement)(JNIEnv*, jobjectArray, jsize, jobject);
-
- jbooleanArray (*NewBooleanArray)(JNIEnv*, jsize);
- jbyteArray (*NewByteArray)(JNIEnv*, jsize);
- jcharArray (*NewCharArray)(JNIEnv*, jsize);
- jshortArray (*NewShortArray)(JNIEnv*, jsize);
- jintArray (*NewIntArray)(JNIEnv*, jsize);
- jlongArray (*NewLongArray)(JNIEnv*, jsize);
- jfloatArray (*NewFloatArray)(JNIEnv*, jsize);
- jdoubleArray (*NewDoubleArray)(JNIEnv*, jsize);
-
- jboolean* (*GetBooleanArrayElements)(JNIEnv*, jbooleanArray, jboolean*);
- jbyte* (*GetByteArrayElements)(JNIEnv*, jbyteArray, jboolean*);
- jchar* (*GetCharArrayElements)(JNIEnv*, jcharArray, jboolean*);
- jshort* (*GetShortArrayElements)(JNIEnv*, jshortArray, jboolean*);
- jint* (*GetIntArrayElements)(JNIEnv*, jintArray, jboolean*);
- jlong* (*GetLongArrayElements)(JNIEnv*, jlongArray, jboolean*);
- jfloat* (*GetFloatArrayElements)(JNIEnv*, jfloatArray, jboolean*);
- jdouble* (*GetDoubleArrayElements)(JNIEnv*, jdoubleArray, jboolean*);
-
- void (*ReleaseBooleanArrayElements)(JNIEnv*, jbooleanArray,
- jboolean*, jint);
- void (*ReleaseByteArrayElements)(JNIEnv*, jbyteArray,
- jbyte*, jint);
- void (*ReleaseCharArrayElements)(JNIEnv*, jcharArray,
- jchar*, jint);
- void (*ReleaseShortArrayElements)(JNIEnv*, jshortArray,
- jshort*, jint);
- void (*ReleaseIntArrayElements)(JNIEnv*, jintArray,
- jint*, jint);
- void (*ReleaseLongArrayElements)(JNIEnv*, jlongArray,
- jlong*, jint);
- void (*ReleaseFloatArrayElements)(JNIEnv*, jfloatArray,
- jfloat*, jint);
- void (*ReleaseDoubleArrayElements)(JNIEnv*, jdoubleArray,
- jdouble*, jint);
-
- void (*GetBooleanArrayRegion)(JNIEnv*, jbooleanArray,
- jsize, jsize, jboolean*);
- void (*GetByteArrayRegion)(JNIEnv*, jbyteArray,
- jsize, jsize, jbyte*);
- void (*GetCharArrayRegion)(JNIEnv*, jcharArray,
- jsize, jsize, jchar*);
- void (*GetShortArrayRegion)(JNIEnv*, jshortArray,
- jsize, jsize, jshort*);
- void (*GetIntArrayRegion)(JNIEnv*, jintArray,
- jsize, jsize, jint*);
- void (*GetLongArrayRegion)(JNIEnv*, jlongArray,
- jsize, jsize, jlong*);
- void (*GetFloatArrayRegion)(JNIEnv*, jfloatArray,
- jsize, jsize, jfloat*);
- void (*GetDoubleArrayRegion)(JNIEnv*, jdoubleArray,
- jsize, jsize, jdouble*);
-
- /* spec shows these without const; some jni.h do, some don't */
- void (*SetBooleanArrayRegion)(JNIEnv*, jbooleanArray,
- jsize, jsize, const jboolean*);
- void (*SetByteArrayRegion)(JNIEnv*, jbyteArray,
- jsize, jsize, const jbyte*);
- void (*SetCharArrayRegion)(JNIEnv*, jcharArray,
- jsize, jsize, const jchar*);
- void (*SetShortArrayRegion)(JNIEnv*, jshortArray,
- jsize, jsize, const jshort*);
- void (*SetIntArrayRegion)(JNIEnv*, jintArray,
- jsize, jsize, const jint*);
- void (*SetLongArrayRegion)(JNIEnv*, jlongArray,
- jsize, jsize, const jlong*);
- void (*SetFloatArrayRegion)(JNIEnv*, jfloatArray,
- jsize, jsize, const jfloat*);
- void (*SetDoubleArrayRegion)(JNIEnv*, jdoubleArray,
- jsize, jsize, const jdouble*);
-
- jint (*RegisterNatives)(JNIEnv*, jclass, const JNINativeMethod*,
- jint);
- jint (*UnregisterNatives)(JNIEnv*, jclass);
- jint (*MonitorEnter)(JNIEnv*, jobject);
- jint (*MonitorExit)(JNIEnv*, jobject);
- jint (*GetJavaVM)(JNIEnv*, JavaVM**);
-
- void (*GetStringRegion)(JNIEnv*, jstring, jsize, jsize, jchar*);
- void (*GetStringUTFRegion)(JNIEnv*, jstring, jsize, jsize, char*);
-
- void* (*GetPrimitiveArrayCritical)(JNIEnv*, jarray, jboolean*);
- void (*ReleasePrimitiveArrayCritical)(JNIEnv*, jarray, void*, jint);
-
- const jchar* (*GetStringCritical)(JNIEnv*, jstring, jboolean*);
- void (*ReleaseStringCritical)(JNIEnv*, jstring, const jchar*);
-
- jweak (*NewWeakGlobalRef)(JNIEnv*, jobject);
- void (*DeleteWeakGlobalRef)(JNIEnv*, jweak);
-
- jboolean (*ExceptionCheck)(JNIEnv*);
-
- jobject (*NewDirectByteBuffer)(JNIEnv*, void*, jlong);
- void* (*GetDirectBufferAddress)(JNIEnv*, jobject);
- jlong (*GetDirectBufferCapacity)(JNIEnv*, jobject);
-
- /* added in JNI 1.6 */
- jobjectRefType (*GetObjectRefType)(JNIEnv*, jobject);
-};
-
-/*
- * C++ object wrapper.
- *
- * This is usually overlaid on a C struct whose first element is a
- * JNINativeInterface*. We rely somewhat on compiler behavior.
- */
-struct _JNIEnv {
- /* do not rename this; it does not seem to be entirely opaque */
- const struct JNINativeInterface* functions;
-
-#if defined(__cplusplus)
-
- jint GetVersion()
- { return functions->GetVersion(this); }
-
- jclass DefineClass(const char *name, jobject loader, const jbyte* buf,
- jsize bufLen)
- { return functions->DefineClass(this, name, loader, buf, bufLen); }
-
- jclass FindClass(const char* name)
- { return functions->FindClass(this, name); }
-
- jmethodID FromReflectedMethod(jobject method)
- { return functions->FromReflectedMethod(this, method); }
-
- jfieldID FromReflectedField(jobject field)
- { return functions->FromReflectedField(this, field); }
-
- jobject ToReflectedMethod(jclass cls, jmethodID methodID, jboolean isStatic)
- { return functions->ToReflectedMethod(this, cls, methodID, isStatic); }
-
- jclass GetSuperclass(jclass clazz)
- { return functions->GetSuperclass(this, clazz); }
-
- jboolean IsAssignableFrom(jclass clazz1, jclass clazz2)
- { return functions->IsAssignableFrom(this, clazz1, clazz2); }
-
- jobject ToReflectedField(jclass cls, jfieldID fieldID, jboolean isStatic)
- { return functions->ToReflectedField(this, cls, fieldID, isStatic); }
-
- jint Throw(jthrowable obj)
- { return functions->Throw(this, obj); }
-
- jint ThrowNew(jclass clazz, const char* message)
- { return functions->ThrowNew(this, clazz, message); }
-
- jthrowable ExceptionOccurred()
- { return functions->ExceptionOccurred(this); }
-
- void ExceptionDescribe()
- { functions->ExceptionDescribe(this); }
-
- void ExceptionClear()
- { functions->ExceptionClear(this); }
-
- void FatalError(const char* msg)
- { functions->FatalError(this, msg); }
-
- jint PushLocalFrame(jint capacity)
- { return functions->PushLocalFrame(this, capacity); }
-
- jobject PopLocalFrame(jobject result)
- { return functions->PopLocalFrame(this, result); }
-
- jobject NewGlobalRef(jobject obj)
- { return functions->NewGlobalRef(this, obj); }
-
- void DeleteGlobalRef(jobject globalRef)
- { functions->DeleteGlobalRef(this, globalRef); }
-
- void DeleteLocalRef(jobject localRef)
- { functions->DeleteLocalRef(this, localRef); }
-
- jboolean IsSameObject(jobject ref1, jobject ref2)
- { return functions->IsSameObject(this, ref1, ref2); }
-
- jobject NewLocalRef(jobject ref)
- { return functions->NewLocalRef(this, ref); }
-
- jint EnsureLocalCapacity(jint capacity)
- { return functions->EnsureLocalCapacity(this, capacity); }
-
- jobject AllocObject(jclass clazz)
- { return functions->AllocObject(this, clazz); }
-
- jobject NewObject(jclass clazz, jmethodID methodID, ...)
- {
- va_list args;
- va_start(args, methodID);
- jobject result = functions->NewObjectV(this, clazz, methodID, args);
- va_end(args);
- return result;
- }
-
- jobject NewObjectV(jclass clazz, jmethodID methodID, va_list args)
- { return functions->NewObjectV(this, clazz, methodID, args); }
-
- jobject NewObjectA(jclass clazz, jmethodID methodID, jvalue* args)
- { return functions->NewObjectA(this, clazz, methodID, args); }
-
- jclass GetObjectClass(jobject obj)
- { return functions->GetObjectClass(this, obj); }
-
- jboolean IsInstanceOf(jobject obj, jclass clazz)
- { return functions->IsInstanceOf(this, obj, clazz); }
-
- jmethodID GetMethodID(jclass clazz, const char* name, const char* sig)
- { return functions->GetMethodID(this, clazz, name, sig); }
-
-#define CALL_TYPE_METHOD(_jtype, _jname) \
- _jtype Call##_jname##Method(jobject obj, jmethodID methodID, ...) \
- { \
- _jtype result; \
- va_list args; \
- va_start(args, methodID); \
- result = functions->Call##_jname##MethodV(this, obj, methodID, \
- args); \
- va_end(args); \
- return result; \
- }
-#define CALL_TYPE_METHODV(_jtype, _jname) \
- _jtype Call##_jname##MethodV(jobject obj, jmethodID methodID, \
- va_list args) \
- { return functions->Call##_jname##MethodV(this, obj, methodID, args); }
-#define CALL_TYPE_METHODA(_jtype, _jname) \
- _jtype Call##_jname##MethodA(jobject obj, jmethodID methodID, \
- jvalue* args) \
- { return functions->Call##_jname##MethodA(this, obj, methodID, args); }
-
-#define CALL_TYPE(_jtype, _jname) \
- CALL_TYPE_METHOD(_jtype, _jname) \
- CALL_TYPE_METHODV(_jtype, _jname) \
- CALL_TYPE_METHODA(_jtype, _jname)
-
- CALL_TYPE(jobject, Object)
- CALL_TYPE(jboolean, Boolean)
- CALL_TYPE(jbyte, Byte)
- CALL_TYPE(jchar, Char)
- CALL_TYPE(jshort, Short)
- CALL_TYPE(jint, Int)
- CALL_TYPE(jlong, Long)
- CALL_TYPE(jfloat, Float)
- CALL_TYPE(jdouble, Double)
-
- void CallVoidMethod(jobject obj, jmethodID methodID, ...)
- {
- va_list args;
- va_start(args, methodID);
- functions->CallVoidMethodV(this, obj, methodID, args);
- va_end(args);
- }
- void CallVoidMethodV(jobject obj, jmethodID methodID, va_list args)
- { functions->CallVoidMethodV(this, obj, methodID, args); }
- void CallVoidMethodA(jobject obj, jmethodID methodID, jvalue* args)
- { functions->CallVoidMethodA(this, obj, methodID, args); }
-
-#define CALL_NONVIRT_TYPE_METHOD(_jtype, _jname) \
- _jtype CallNonvirtual##_jname##Method(jobject obj, jclass clazz, \
- jmethodID methodID, ...) \
- { \
- _jtype result; \
- va_list args; \
- va_start(args, methodID); \
- result = functions->CallNonvirtual##_jname##MethodV(this, obj, \
- clazz, methodID, args); \
- va_end(args); \
- return result; \
- }
-#define CALL_NONVIRT_TYPE_METHODV(_jtype, _jname) \
- _jtype CallNonvirtual##_jname##MethodV(jobject obj, jclass clazz, \
- jmethodID methodID, va_list args) \
- { return functions->CallNonvirtual##_jname##MethodV(this, obj, clazz, \
- methodID, args); }
-#define CALL_NONVIRT_TYPE_METHODA(_jtype, _jname) \
- _jtype CallNonvirtual##_jname##MethodA(jobject obj, jclass clazz, \
- jmethodID methodID, jvalue* args) \
- { return functions->CallNonvirtual##_jname##MethodA(this, obj, clazz, \
- methodID, args); }
-
-#define CALL_NONVIRT_TYPE(_jtype, _jname) \
- CALL_NONVIRT_TYPE_METHOD(_jtype, _jname) \
- CALL_NONVIRT_TYPE_METHODV(_jtype, _jname) \
- CALL_NONVIRT_TYPE_METHODA(_jtype, _jname)
-
- CALL_NONVIRT_TYPE(jobject, Object)
- CALL_NONVIRT_TYPE(jboolean, Boolean)
- CALL_NONVIRT_TYPE(jbyte, Byte)
- CALL_NONVIRT_TYPE(jchar, Char)
- CALL_NONVIRT_TYPE(jshort, Short)
- CALL_NONVIRT_TYPE(jint, Int)
- CALL_NONVIRT_TYPE(jlong, Long)
- CALL_NONVIRT_TYPE(jfloat, Float)
- CALL_NONVIRT_TYPE(jdouble, Double)
-
- void CallNonvirtualVoidMethod(jobject obj, jclass clazz,
- jmethodID methodID, ...)
- {
- va_list args;
- va_start(args, methodID);
- functions->CallNonvirtualVoidMethodV(this, obj, clazz, methodID, args);
- va_end(args);
- }
- void CallNonvirtualVoidMethodV(jobject obj, jclass clazz,
- jmethodID methodID, va_list args)
- { functions->CallNonvirtualVoidMethodV(this, obj, clazz, methodID, args); }
- void CallNonvirtualVoidMethodA(jobject obj, jclass clazz,
- jmethodID methodID, jvalue* args)
- { functions->CallNonvirtualVoidMethodA(this, obj, clazz, methodID, args); }
-
- jfieldID GetFieldID(jclass clazz, const char* name, const char* sig)
- { return functions->GetFieldID(this, clazz, name, sig); }
-
- jobject GetObjectField(jobject obj, jfieldID fieldID)
- { return functions->GetObjectField(this, obj, fieldID); }
- jboolean GetBooleanField(jobject obj, jfieldID fieldID)
- { return functions->GetBooleanField(this, obj, fieldID); }
- jbyte GetByteField(jobject obj, jfieldID fieldID)
- { return functions->GetByteField(this, obj, fieldID); }
- jchar GetCharField(jobject obj, jfieldID fieldID)
- { return functions->GetCharField(this, obj, fieldID); }
- jshort GetShortField(jobject obj, jfieldID fieldID)
- { return functions->GetShortField(this, obj, fieldID); }
- jint GetIntField(jobject obj, jfieldID fieldID)
- { return functions->GetIntField(this, obj, fieldID); }
- jlong GetLongField(jobject obj, jfieldID fieldID)
- { return functions->GetLongField(this, obj, fieldID); }
- jfloat GetFloatField(jobject obj, jfieldID fieldID)
- { return functions->GetFloatField(this, obj, fieldID); }
- jdouble GetDoubleField(jobject obj, jfieldID fieldID)
- { return functions->GetDoubleField(this, obj, fieldID); }
-
- void SetObjectField(jobject obj, jfieldID fieldID, jobject value)
- { functions->SetObjectField(this, obj, fieldID, value); }
- void SetBooleanField(jobject obj, jfieldID fieldID, jboolean value)
- { functions->SetBooleanField(this, obj, fieldID, value); }
- void SetByteField(jobject obj, jfieldID fieldID, jbyte value)
- { functions->SetByteField(this, obj, fieldID, value); }
- void SetCharField(jobject obj, jfieldID fieldID, jchar value)
- { functions->SetCharField(this, obj, fieldID, value); }
- void SetShortField(jobject obj, jfieldID fieldID, jshort value)
- { functions->SetShortField(this, obj, fieldID, value); }
- void SetIntField(jobject obj, jfieldID fieldID, jint value)
- { functions->SetIntField(this, obj, fieldID, value); }
- void SetLongField(jobject obj, jfieldID fieldID, jlong value)
- { functions->SetLongField(this, obj, fieldID, value); }
- void SetFloatField(jobject obj, jfieldID fieldID, jfloat value)
- { functions->SetFloatField(this, obj, fieldID, value); }
- void SetDoubleField(jobject obj, jfieldID fieldID, jdouble value)
- { functions->SetDoubleField(this, obj, fieldID, value); }
-
- jmethodID GetStaticMethodID(jclass clazz, const char* name, const char* sig)
- { return functions->GetStaticMethodID(this, clazz, name, sig); }
-
-#define CALL_STATIC_TYPE_METHOD(_jtype, _jname) \
- _jtype CallStatic##_jname##Method(jclass clazz, jmethodID methodID, \
- ...) \
- { \
- _jtype result; \
- va_list args; \
- va_start(args, methodID); \
- result = functions->CallStatic##_jname##MethodV(this, clazz, \
- methodID, args); \
- va_end(args); \
- return result; \
- }
-#define CALL_STATIC_TYPE_METHODV(_jtype, _jname) \
- _jtype CallStatic##_jname##MethodV(jclass clazz, jmethodID methodID, \
- va_list args) \
- { return functions->CallStatic##_jname##MethodV(this, clazz, methodID, \
- args); }
-#define CALL_STATIC_TYPE_METHODA(_jtype, _jname) \
- _jtype CallStatic##_jname##MethodA(jclass clazz, jmethodID methodID, \
- jvalue* args) \
- { return functions->CallStatic##_jname##MethodA(this, clazz, methodID, \
- args); }
-
-#define CALL_STATIC_TYPE(_jtype, _jname) \
- CALL_STATIC_TYPE_METHOD(_jtype, _jname) \
- CALL_STATIC_TYPE_METHODV(_jtype, _jname) \
- CALL_STATIC_TYPE_METHODA(_jtype, _jname)
-
- CALL_STATIC_TYPE(jobject, Object)
- CALL_STATIC_TYPE(jboolean, Boolean)
- CALL_STATIC_TYPE(jbyte, Byte)
- CALL_STATIC_TYPE(jchar, Char)
- CALL_STATIC_TYPE(jshort, Short)
- CALL_STATIC_TYPE(jint, Int)
- CALL_STATIC_TYPE(jlong, Long)
- CALL_STATIC_TYPE(jfloat, Float)
- CALL_STATIC_TYPE(jdouble, Double)
-
- void CallStaticVoidMethod(jclass clazz, jmethodID methodID, ...)
- {
- va_list args;
- va_start(args, methodID);
- functions->CallStaticVoidMethodV(this, clazz, methodID, args);
- va_end(args);
- }
- void CallStaticVoidMethodV(jclass clazz, jmethodID methodID, va_list args)
- { functions->CallStaticVoidMethodV(this, clazz, methodID, args); }
- void CallStaticVoidMethodA(jclass clazz, jmethodID methodID, jvalue* args)
- { functions->CallStaticVoidMethodA(this, clazz, methodID, args); }
-
- jfieldID GetStaticFieldID(jclass clazz, const char* name, const char* sig)
- { return functions->GetStaticFieldID(this, clazz, name, sig); }
-
- jobject GetStaticObjectField(jclass clazz, jfieldID fieldID)
- { return functions->GetStaticObjectField(this, clazz, fieldID); }
- jboolean GetStaticBooleanField(jclass clazz, jfieldID fieldID)
- { return functions->GetStaticBooleanField(this, clazz, fieldID); }
- jbyte GetStaticByteField(jclass clazz, jfieldID fieldID)
- { return functions->GetStaticByteField(this, clazz, fieldID); }
- jchar GetStaticCharField(jclass clazz, jfieldID fieldID)
- { return functions->GetStaticCharField(this, clazz, fieldID); }
- jshort GetStaticShortField(jclass clazz, jfieldID fieldID)
- { return functions->GetStaticShortField(this, clazz, fieldID); }
- jint GetStaticIntField(jclass clazz, jfieldID fieldID)
- { return functions->GetStaticIntField(this, clazz, fieldID); }
- jlong GetStaticLongField(jclass clazz, jfieldID fieldID)
- { return functions->GetStaticLongField(this, clazz, fieldID); }
- jfloat GetStaticFloatField(jclass clazz, jfieldID fieldID)
- { return functions->GetStaticFloatField(this, clazz, fieldID); }
- jdouble GetStaticDoubleField(jclass clazz, jfieldID fieldID)
- { return functions->GetStaticDoubleField(this, clazz, fieldID); }
-
- void SetStaticObjectField(jclass clazz, jfieldID fieldID, jobject value)
- { functions->SetStaticObjectField(this, clazz, fieldID, value); }
- void SetStaticBooleanField(jclass clazz, jfieldID fieldID, jboolean value)
- { functions->SetStaticBooleanField(this, clazz, fieldID, value); }
- void SetStaticByteField(jclass clazz, jfieldID fieldID, jbyte value)
- { functions->SetStaticByteField(this, clazz, fieldID, value); }
- void SetStaticCharField(jclass clazz, jfieldID fieldID, jchar value)
- { functions->SetStaticCharField(this, clazz, fieldID, value); }
- void SetStaticShortField(jclass clazz, jfieldID fieldID, jshort value)
- { functions->SetStaticShortField(this, clazz, fieldID, value); }
- void SetStaticIntField(jclass clazz, jfieldID fieldID, jint value)
- { functions->SetStaticIntField(this, clazz, fieldID, value); }
- void SetStaticLongField(jclass clazz, jfieldID fieldID, jlong value)
- { functions->SetStaticLongField(this, clazz, fieldID, value); }
- void SetStaticFloatField(jclass clazz, jfieldID fieldID, jfloat value)
- { functions->SetStaticFloatField(this, clazz, fieldID, value); }
- void SetStaticDoubleField(jclass clazz, jfieldID fieldID, jdouble value)
- { functions->SetStaticDoubleField(this, clazz, fieldID, value); }
-
- jstring NewString(const jchar* unicodeChars, jsize len)
- { return functions->NewString(this, unicodeChars, len); }
-
- jsize GetStringLength(jstring string)
- { return functions->GetStringLength(this, string); }
-
- const jchar* GetStringChars(jstring string, jboolean* isCopy)
- { return functions->GetStringChars(this, string, isCopy); }
-
- void ReleaseStringChars(jstring string, const jchar* chars)
- { functions->ReleaseStringChars(this, string, chars); }
-
- jstring NewStringUTF(const char* bytes)
- { return functions->NewStringUTF(this, bytes); }
-
- jsize GetStringUTFLength(jstring string)
- { return functions->GetStringUTFLength(this, string); }
-
- const char* GetStringUTFChars(jstring string, jboolean* isCopy)
- { return functions->GetStringUTFChars(this, string, isCopy); }
-
- void ReleaseStringUTFChars(jstring string, const char* utf)
- { functions->ReleaseStringUTFChars(this, string, utf); }
-
- jsize GetArrayLength(jarray array)
- { return functions->GetArrayLength(this, array); }
-
- jobjectArray NewObjectArray(jsize length, jclass elementClass,
- jobject initialElement)
- { return functions->NewObjectArray(this, length, elementClass,
- initialElement); }
-
- jobject GetObjectArrayElement(jobjectArray array, jsize index)
- { return functions->GetObjectArrayElement(this, array, index); }
-
- void SetObjectArrayElement(jobjectArray array, jsize index, jobject value)
- { functions->SetObjectArrayElement(this, array, index, value); }
-
- jbooleanArray NewBooleanArray(jsize length)
- { return functions->NewBooleanArray(this, length); }
- jbyteArray NewByteArray(jsize length)
- { return functions->NewByteArray(this, length); }
- jcharArray NewCharArray(jsize length)
- { return functions->NewCharArray(this, length); }
- jshortArray NewShortArray(jsize length)
- { return functions->NewShortArray(this, length); }
- jintArray NewIntArray(jsize length)
- { return functions->NewIntArray(this, length); }
- jlongArray NewLongArray(jsize length)
- { return functions->NewLongArray(this, length); }
- jfloatArray NewFloatArray(jsize length)
- { return functions->NewFloatArray(this, length); }
- jdoubleArray NewDoubleArray(jsize length)
- { return functions->NewDoubleArray(this, length); }
-
- jboolean* GetBooleanArrayElements(jbooleanArray array, jboolean* isCopy)
- { return functions->GetBooleanArrayElements(this, array, isCopy); }
- jbyte* GetByteArrayElements(jbyteArray array, jboolean* isCopy)
- { return functions->GetByteArrayElements(this, array, isCopy); }
- jchar* GetCharArrayElements(jcharArray array, jboolean* isCopy)
- { return functions->GetCharArrayElements(this, array, isCopy); }
- jshort* GetShortArrayElements(jshortArray array, jboolean* isCopy)
- { return functions->GetShortArrayElements(this, array, isCopy); }
- jint* GetIntArrayElements(jintArray array, jboolean* isCopy)
- { return functions->GetIntArrayElements(this, array, isCopy); }
- jlong* GetLongArrayElements(jlongArray array, jboolean* isCopy)
- { return functions->GetLongArrayElements(this, array, isCopy); }
- jfloat* GetFloatArrayElements(jfloatArray array, jboolean* isCopy)
- { return functions->GetFloatArrayElements(this, array, isCopy); }
- jdouble* GetDoubleArrayElements(jdoubleArray array, jboolean* isCopy)
- { return functions->GetDoubleArrayElements(this, array, isCopy); }
-
- void ReleaseBooleanArrayElements(jbooleanArray array, jboolean* elems,
- jint mode)
- { functions->ReleaseBooleanArrayElements(this, array, elems, mode); }
- void ReleaseByteArrayElements(jbyteArray array, jbyte* elems,
- jint mode)
- { functions->ReleaseByteArrayElements(this, array, elems, mode); }
- void ReleaseCharArrayElements(jcharArray array, jchar* elems,
- jint mode)
- { functions->ReleaseCharArrayElements(this, array, elems, mode); }
- void ReleaseShortArrayElements(jshortArray array, jshort* elems,
- jint mode)
- { functions->ReleaseShortArrayElements(this, array, elems, mode); }
- void ReleaseIntArrayElements(jintArray array, jint* elems,
- jint mode)
- { functions->ReleaseIntArrayElements(this, array, elems, mode); }
- void ReleaseLongArrayElements(jlongArray array, jlong* elems,
- jint mode)
- { functions->ReleaseLongArrayElements(this, array, elems, mode); }
- void ReleaseFloatArrayElements(jfloatArray array, jfloat* elems,
- jint mode)
- { functions->ReleaseFloatArrayElements(this, array, elems, mode); }
- void ReleaseDoubleArrayElements(jdoubleArray array, jdouble* elems,
- jint mode)
- { functions->ReleaseDoubleArrayElements(this, array, elems, mode); }
-
- void GetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len,
- jboolean* buf)
- { functions->GetBooleanArrayRegion(this, array, start, len, buf); }
- void GetByteArrayRegion(jbyteArray array, jsize start, jsize len,
- jbyte* buf)
- { functions->GetByteArrayRegion(this, array, start, len, buf); }
- void GetCharArrayRegion(jcharArray array, jsize start, jsize len,
- jchar* buf)
- { functions->GetCharArrayRegion(this, array, start, len, buf); }
- void GetShortArrayRegion(jshortArray array, jsize start, jsize len,
- jshort* buf)
- { functions->GetShortArrayRegion(this, array, start, len, buf); }
- void GetIntArrayRegion(jintArray array, jsize start, jsize len,
- jint* buf)
- { functions->GetIntArrayRegion(this, array, start, len, buf); }
- void GetLongArrayRegion(jlongArray array, jsize start, jsize len,
- jlong* buf)
- { functions->GetLongArrayRegion(this, array, start, len, buf); }
- void GetFloatArrayRegion(jfloatArray array, jsize start, jsize len,
- jfloat* buf)
- { functions->GetFloatArrayRegion(this, array, start, len, buf); }
- void GetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len,
- jdouble* buf)
- { functions->GetDoubleArrayRegion(this, array, start, len, buf); }
-
- void SetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len,
- const jboolean* buf)
- { functions->SetBooleanArrayRegion(this, array, start, len, buf); }
- void SetByteArrayRegion(jbyteArray array, jsize start, jsize len,
- const jbyte* buf)
- { functions->SetByteArrayRegion(this, array, start, len, buf); }
- void SetCharArrayRegion(jcharArray array, jsize start, jsize len,
- const jchar* buf)
- { functions->SetCharArrayRegion(this, array, start, len, buf); }
- void SetShortArrayRegion(jshortArray array, jsize start, jsize len,
- const jshort* buf)
- { functions->SetShortArrayRegion(this, array, start, len, buf); }
- void SetIntArrayRegion(jintArray array, jsize start, jsize len,
- const jint* buf)
- { functions->SetIntArrayRegion(this, array, start, len, buf); }
- void SetLongArrayRegion(jlongArray array, jsize start, jsize len,
- const jlong* buf)
- { functions->SetLongArrayRegion(this, array, start, len, buf); }
- void SetFloatArrayRegion(jfloatArray array, jsize start, jsize len,
- const jfloat* buf)
- { functions->SetFloatArrayRegion(this, array, start, len, buf); }
- void SetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len,
- const jdouble* buf)
- { functions->SetDoubleArrayRegion(this, array, start, len, buf); }
-
- jint RegisterNatives(jclass clazz, const JNINativeMethod* methods,
- jint nMethods)
- { return functions->RegisterNatives(this, clazz, methods, nMethods); }
-
- jint UnregisterNatives(jclass clazz)
- { return functions->UnregisterNatives(this, clazz); }
-
- jint MonitorEnter(jobject obj)
- { return functions->MonitorEnter(this, obj); }
-
- jint MonitorExit(jobject obj)
- { return functions->MonitorExit(this, obj); }
-
- jint GetJavaVM(JavaVM** vm)
- { return functions->GetJavaVM(this, vm); }
-
- void GetStringRegion(jstring str, jsize start, jsize len, jchar* buf)
- { functions->GetStringRegion(this, str, start, len, buf); }
-
- void GetStringUTFRegion(jstring str, jsize start, jsize len, char* buf)
- { return functions->GetStringUTFRegion(this, str, start, len, buf); }
-
- void* GetPrimitiveArrayCritical(jarray array, jboolean* isCopy)
- { return functions->GetPrimitiveArrayCritical(this, array, isCopy); }
-
- void ReleasePrimitiveArrayCritical(jarray array, void* carray, jint mode)
- { functions->ReleasePrimitiveArrayCritical(this, array, carray, mode); }
-
- const jchar* GetStringCritical(jstring string, jboolean* isCopy)
- { return functions->GetStringCritical(this, string, isCopy); }
-
- void ReleaseStringCritical(jstring string, const jchar* carray)
- { functions->ReleaseStringCritical(this, string, carray); }
-
- jweak NewWeakGlobalRef(jobject obj)
- { return functions->NewWeakGlobalRef(this, obj); }
-
- void DeleteWeakGlobalRef(jweak obj)
- { functions->DeleteWeakGlobalRef(this, obj); }
-
- jboolean ExceptionCheck()
- { return functions->ExceptionCheck(this); }
-
- jobject NewDirectByteBuffer(void* address, jlong capacity)
- { return functions->NewDirectByteBuffer(this, address, capacity); }
-
- void* GetDirectBufferAddress(jobject buf)
- { return functions->GetDirectBufferAddress(this, buf); }
-
- jlong GetDirectBufferCapacity(jobject buf)
- { return functions->GetDirectBufferCapacity(this, buf); }
-
- /* added in JNI 1.6 */
- jobjectRefType GetObjectRefType(jobject obj)
- { return functions->GetObjectRefType(this, obj); }
-#endif /*__cplusplus*/
-};
-
-
-/*
- * JNI invocation interface.
- */
-struct JNIInvokeInterface {
- void* reserved0;
- void* reserved1;
- void* reserved2;
-
- jint (*DestroyJavaVM)(JavaVM*);
- jint (*AttachCurrentThread)(JavaVM*, JNIEnv**, void*);
- jint (*DetachCurrentThread)(JavaVM*);
- jint (*GetEnv)(JavaVM*, void**, jint);
- jint (*AttachCurrentThreadAsDaemon)(JavaVM*, JNIEnv**, void*);
-};
-
-/*
- * C++ version.
- */
-struct _JavaVM {
- const struct JNIInvokeInterface* functions;
-
-#if defined(__cplusplus)
- jint DestroyJavaVM()
- { return functions->DestroyJavaVM(this); }
- jint AttachCurrentThread(JNIEnv** p_env, void* thr_args)
- { return functions->AttachCurrentThread(this, p_env, thr_args); }
- jint DetachCurrentThread()
- { return functions->DetachCurrentThread(this); }
- jint GetEnv(void** env, jint version)
- { return functions->GetEnv(this, env, version); }
- jint AttachCurrentThreadAsDaemon(JNIEnv** p_env, void* thr_args)
- { return functions->AttachCurrentThreadAsDaemon(this, p_env, thr_args); }
-#endif /*__cplusplus*/
-};
-
-struct JavaVMAttachArgs {
- jint version; /* must be >= JNI_VERSION_1_2 */
- const char* name; /* NULL or name of thread as modified UTF-8 str */
- jobject group; /* global ref of a ThreadGroup object, or NULL */
-};
-typedef struct JavaVMAttachArgs JavaVMAttachArgs;
-
-/*
- * JNI 1.2+ initialization. (As of 1.6, the pre-1.2 structures are no
- * longer supported.)
- */
-typedef struct JavaVMOption {
- const char* optionString;
- void* extraInfo;
-} JavaVMOption;
-
-typedef struct JavaVMInitArgs {
- jint version; /* use JNI_VERSION_1_2 or later */
-
- jint nOptions;
- JavaVMOption* options;
- jboolean ignoreUnrecognized;
-} JavaVMInitArgs;
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-/*
- * VM initialization functions.
- *
- * Note these are the only symbols exported for JNI by the VM.
- */
-jint JNI_GetDefaultJavaVMInitArgs(void*);
-jint JNI_CreateJavaVM(JavaVM**, JNIEnv**, void*);
-jint JNI_GetCreatedJavaVMs(JavaVM**, jsize, jsize*);
-
-#define JNIIMPORT
-#define JNIEXPORT __attribute__ ((visibility ("default")))
-#define JNICALL
-
-/*
- * Prototypes for functions exported by loadable shared libs. These are
- * called by JNI, not provided by JNI.
- */
-JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved);
-JNIEXPORT void JNI_OnUnload(JavaVM* vm, void* reserved);
-
-#ifdef __cplusplus
-}
-#endif
-
-
-/*
- * Manifest constants.
- */
-#define JNI_FALSE 0
-#define JNI_TRUE 1
-
-#define JNI_VERSION_1_1 0x00010001
-#define JNI_VERSION_1_2 0x00010002
-#define JNI_VERSION_1_4 0x00010004
-#define JNI_VERSION_1_6 0x00010006
-
-#define JNI_OK (0) /* no error */
-#define JNI_ERR (-1) /* generic error */
-#define JNI_EDETACHED (-2) /* thread detached from the VM */
-#define JNI_EVERSION (-3) /* JNI version error */
-
-#define JNI_COMMIT 1 /* copy content, do not free buffer */
-#define JNI_ABORT 2 /* free buffer w/o copying back */
-
-#endif /* JNI_H_ */
OSDN Git Service
