From dd0f4d9d9cff8eb6160fb0266b8f4da3af985e79 Mon Sep 17 00:00:00 2001 From: "Taro L. Saito" Date: Wed, 20 Mar 2013 00:10:02 +0900 Subject: [PATCH 01/12] Update version --- README.md | 2 ++ pom.xml | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 288faa0..807a633 100755 --- a/README.md +++ b/README.md @@ -51,6 +51,8 @@ In addition, high-level methods (`Snappy.compress(String)`, `Snappy.compress(flo ### Stream-based API Stream-based compressor/decompressor `SnappyOutputStream`/`SnappyInputStream` are also available for reading/writing large data sets. + * [Javadoc API](https://oss.sonatype.org/service/local/repositories/snapshots/archive/org/xerial/snappy/snappy-java/1.0.5-M5-SNAPSHOT/snappy-java-1.0.5-M5-20130319.150524-2-javadoc.jar/!/index.html) + ### Setting classpath If you have snappy-java-(VERSION).jar in the current directory, use `-classpath` option as follows: diff --git a/pom.xml b/pom.xml index 46540da..24d05c4 100755 --- a/pom.xml +++ b/pom.xml @@ -4,7 +4,7 @@ 4.0.0 org.xerial.snappy snappy-java - 1.0.5-M4 + 1.0.5-M5-SNAPSHOT Snappy for Java snappy-java: A fast compression/decompression library bundle From f0e0e9727e4d727c36ab514fdd6e775bf3f02128 Mon Sep 17 00:00:00 2001 From: "Taro L. Saito" Date: Fri, 22 Mar 2013 15:53:56 +0900 Subject: [PATCH 02/12] #25 Add raw compress methods that take memory addresses --- src/main/java/org/xerial/snappy/Snappy.java | 39 +++++++++++++++++- .../java/org/xerial/snappy/SnappyNative.cpp | 41 +++++++++++++++++++ .../java/org/xerial/snappy/SnappyNative.h | 24 +++++++++++ .../java/org/xerial/snappy/SnappyNative.java | 5 +++ .../org/xerial/snappy/SnappyNativeAPI.java | 6 +++ 5 files changed, 114 insertions(+), 1 deletion(-) diff --git a/src/main/java/org/xerial/snappy/Snappy.java b/src/main/java/org/xerial/snappy/Snappy.java index e44ded2..2247498 100755 --- a/src/main/java/org/xerial/snappy/Snappy.java +++ b/src/main/java/org/xerial/snappy/Snappy.java @@ -320,6 +320,31 @@ public class Snappy return ((SnappyNativeAPI) impl).maxCompressedLength(byteSize); } + /** + * Zero-copy compress using memory addresses. + * @param inputAddr input memory address + * @param inputSize input byte size + * @param destAddr destination address of the compressed data + * @return the compressed data size + * @throws IOException + */ + public static long rawCompress(long inputAddr, long inputSize, long destAddr) throws IOException { + return ((SnappyNativeAPI) impl).rawCompress(inputAddr, inputSize, destAddr); + } + + /** + * Zero-copy decompress using memory addresses. + * @param inputAddr input memory address + * @param inputSize input byte size + * @param destAddr destination address of the uncompressed data + * @return the uncompressed data size + * @throws IOException + */ + public static long rawUncompress(long inputAddr, long inputSize, long destAddr) throws IOException { + return ((SnappyNativeAPI) impl).rawUncompress(inputAddr, inputSize, destAddr); + } + + /** * Compress the input data and produce a byte array of the uncompressed data * @@ -547,7 +572,7 @@ public class Snappy /** * Get the uncompressed byte size of the given compressed input. This - * operation taks O(1) time. + * operation takes O(1) time. * * @param compressed * input data [pos() ... limit()) @@ -565,6 +590,18 @@ public class Snappy return ((SnappyNativeAPI) impl).uncompressedLength(compressed, compressed.position(), compressed.remaining()); } + /** + * Get the uncompressed byte size of the given compressed input. This operation takes O(1) time. + * @param inputAddr compressed data address + * @param len byte length of the input + * @return uncompressed byte length of the given input + * @throws IOException when failed to uncompress the given input. The error code is + * {@link SnappyErrorCode#PARSING_ERROR} + */ + public static long uncompressedLength(long inputAddr, long len) throws IOException { + return ((SnappyNativeAPI) impl).uncompressedLength(inputAddr, len); + } + /** * Uncompress the input as a float array * diff --git a/src/main/java/org/xerial/snappy/SnappyNative.cpp b/src/main/java/org/xerial/snappy/SnappyNative.cpp index 1059b36..386b039 100755 --- a/src/main/java/org/xerial/snappy/SnappyNative.cpp +++ b/src/main/java/org/xerial/snappy/SnappyNative.cpp @@ -36,6 +36,32 @@ JNIEXPORT jstring JNICALL Java_org_xerial_snappy_SnappyNative_nativeLibraryVersi return env->NewStringUTF("1.0.4"); } +JNIEXPORT jlong JNICALL Java_org_xerial_snappy_SnappyNative_rawCompress__JJJ + (JNIEnv* env, jobject self, jlong srcAddr, jlong length, jlong destAddr) { + size_t compressedLength; + snappy::RawCompress((char*) srcAddr, (size_t) length, (char*) destAddr, &compressedLength); + return (jlong) compressedLength; + } + + + +JNIEXPORT jlong JNICALL Java_org_xerial_snappy_SnappyNative_rawUncompress__JJJ + (JNIEnv* env, jobject self, jlong srcAddr, jlong length, jlong destAddr) { + + size_t uncompressedLength; + snappy::GetUncompressedLength((char*) srcAddr, (size_t) length, &uncompressedLength); + bool ret = snappy::RawUncompress((char*) srcAddr, (size_t) length, (char*) destAddr); + + if(!ret) { + throw_exception(env, self, 5); + return 0; + } + + return (jlong) uncompressedLength; + } + + + /* * Class: org_xerial_snappy_Snappy * Method: compress @@ -190,6 +216,21 @@ JNIEXPORT jint JNICALL Java_org_xerial_snappy_SnappyNative_uncompressedLength__L return (jint) result; } +JNIEXPORT jlong JNICALL Java_org_xerial_snappy_SnappyNative_uncompressedLength__JJ + (JNIEnv *env, jobject self, jlong inputAddr, jlong len) { + + + size_t result; + bool ret = snappy::GetUncompressedLength((char*) inputAddr, (size_t) len, &result); + if(!ret) { + throw_exception(env, self, 2); + return 0; + } + + return (jint) result; + } + + JNIEXPORT jboolean JNICALL Java_org_xerial_snappy_SnappyNative_isValidCompressedBuffer__Ljava_nio_ByteBuffer_2II (JNIEnv * env, jobject self, jobject compressed, jint cpos, jint clen) { diff --git a/src/main/java/org/xerial/snappy/SnappyNative.h b/src/main/java/org/xerial/snappy/SnappyNative.h index 37452d9..477d30a 100755 --- a/src/main/java/org/xerial/snappy/SnappyNative.h +++ b/src/main/java/org/xerial/snappy/SnappyNative.h @@ -15,6 +15,22 @@ extern "C" { JNIEXPORT jstring JNICALL Java_org_xerial_snappy_SnappyNative_nativeLibraryVersion (JNIEnv *, jobject); +/* + * Class: org_xerial_snappy_SnappyNative + * Method: rawCompress + * Signature: (JJJ)J + */ +JNIEXPORT jlong JNICALL Java_org_xerial_snappy_SnappyNative_rawCompress__JJJ + (JNIEnv *, jobject, jlong, jlong, jlong); + +/* + * Class: org_xerial_snappy_SnappyNative + * Method: rawUncompress + * Signature: (JJJ)J + */ +JNIEXPORT jlong JNICALL Java_org_xerial_snappy_SnappyNative_rawUncompress__JJJ + (JNIEnv *, jobject, jlong, jlong, jlong); + /* * Class: org_xerial_snappy_SnappyNative * Method: rawCompress @@ -71,6 +87,14 @@ JNIEXPORT jint JNICALL Java_org_xerial_snappy_SnappyNative_uncompressedLength__L JNIEXPORT jint JNICALL Java_org_xerial_snappy_SnappyNative_uncompressedLength__Ljava_lang_Object_2II (JNIEnv *, jobject, jobject, jint, jint); +/* + * Class: org_xerial_snappy_SnappyNative + * Method: uncompressedLength + * Signature: (JJ)J + */ +JNIEXPORT jlong JNICALL Java_org_xerial_snappy_SnappyNative_uncompressedLength__JJ + (JNIEnv *, jobject, jlong, jlong); + /* * Class: org_xerial_snappy_SnappyNative * Method: isValidCompressedBuffer diff --git a/src/main/java/org/xerial/snappy/SnappyNative.java b/src/main/java/org/xerial/snappy/SnappyNative.java index 9b42064..3c9acf5 100755 --- a/src/main/java/org/xerial/snappy/SnappyNative.java +++ b/src/main/java/org/xerial/snappy/SnappyNative.java @@ -48,6 +48,9 @@ public class SnappyNative implements SnappyNativeAPI // ------------------------------------------------------------------------ // Generic compression/decompression routines. // ------------------------------------------------------------------------ + public native long rawCompress(long inputAddr, long inputSize, long destAddr) throws IOException; + public native long rawUncompress(long inputAddr, long inputSize, long destAddr) throws IOException; + public native int rawCompress(ByteBuffer input, int inputOffset, int inputLength, ByteBuffer compressed, int outputOffset) throws IOException; @@ -68,6 +71,8 @@ public class SnappyNative implements SnappyNativeAPI public native int uncompressedLength(Object input, int offset, int len) throws IOException; + public native long uncompressedLength(long inputAddr, long len) throws IOException; + public native boolean isValidCompressedBuffer(ByteBuffer compressed, int offset, int len) throws IOException; public native boolean isValidCompressedBuffer(Object input, int offset, int len) throws IOException; diff --git a/src/main/java/org/xerial/snappy/SnappyNativeAPI.java b/src/main/java/org/xerial/snappy/SnappyNativeAPI.java index 6bf9fcc..902e22e 100755 --- a/src/main/java/org/xerial/snappy/SnappyNativeAPI.java +++ b/src/main/java/org/xerial/snappy/SnappyNativeAPI.java @@ -45,6 +45,9 @@ public interface SnappyNativeAPI // ------------------------------------------------------------------------ // Generic compression/decompression routines. // ------------------------------------------------------------------------ + public long rawCompress(long inputAddr, long inputSize, long destAddr) throws IOException; + public long rawUncompress(long inputAddr, long inputSize, long destAddr) throws IOException; + public int rawCompress(ByteBuffer input, int inputOffset, int inputLength, ByteBuffer compressed, int outputOffset) throws IOException; @@ -65,6 +68,9 @@ public interface SnappyNativeAPI public int uncompressedLength(Object input, int offset, int len) throws IOException; + public long uncompressedLength(long inputAddr, long len) throws IOException; + + public boolean isValidCompressedBuffer(ByteBuffer compressed, int offset, int len) throws IOException; public boolean isValidCompressedBuffer(Object input, int offset, int len) throws IOException; From dca3f64d2859f53761134e832be871875e1787eb Mon Sep 17 00:00:00 2001 From: "Taro L. Saito" Date: Fri, 22 Mar 2013 15:58:08 +0900 Subject: [PATCH 03/12] Use snappy-1.1.0 which can be compiled in Mac OS X 10.8 --- pom.xml | 2 +- src/main/java/org/xerial/snappy/VERSION | 2 +- .../native/Mac/x86_64/libsnappyjava.jnilib | Bin 48572 -> 48156 bytes 3 files changed, 2 insertions(+), 2 deletions(-) diff --git a/pom.xml b/pom.xml index 24d05c4..aa23c2b 100755 --- a/pom.xml +++ b/pom.xml @@ -4,7 +4,7 @@ 4.0.0 org.xerial.snappy snappy-java - 1.0.5-M5-SNAPSHOT + 1.1.0-SNAPSHOT Snappy for Java snappy-java: A fast compression/decompression library bundle diff --git a/src/main/java/org/xerial/snappy/VERSION b/src/main/java/org/xerial/snappy/VERSION index 5514d3b..55b51d9 100755 --- a/src/main/java/org/xerial/snappy/VERSION +++ b/src/main/java/org/xerial/snappy/VERSION @@ -1,2 +1,2 @@ -VERSION=1.0.5 +VERSION=1.1.0 diff --git a/src/main/resources/org/xerial/snappy/native/Mac/x86_64/libsnappyjava.jnilib b/src/main/resources/org/xerial/snappy/native/Mac/x86_64/libsnappyjava.jnilib index 6a177ac92da5171578aed6386a6c048b4705e01c..75f3e69c2a2993edfb26364edfa75d946fdd9052 100755 GIT binary patch delta 12152 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 From c284cc600f67e847c939eeb16ff33fd2752a6245 Mon Sep 17 00:00:00 2001 From: "Taro L. Saito" Date: Tue, 26 Mar 2013 23:48:27 -0700 Subject: [PATCH 04/12] build native libraries --- lib/inc_linux/jni.h | 1959 +++++++++++++++++ .../snappy/native/Linux/arm/libsnappyjava.so | Bin 22132 -> 22084 bytes .../native/Linux/armhf/libsnappyjava.so | Bin 22136 -> 22088 bytes .../snappy/native/Linux/i386/libsnappyjava.so | Bin 814468 -> 169780 bytes .../native/Windows/amd64/snappyjava.dll | Bin 686592 -> 136704 bytes .../snappy/native/Windows/x86/snappyjava.dll | Bin 532992 -> 118784 bytes 6 files changed, 1959 insertions(+) create mode 100644 lib/inc_linux/jni.h diff --git a/lib/inc_linux/jni.h b/lib/inc_linux/jni.h new file mode 100644 index 0000000..dc2c8f6 --- /dev/null +++ b/lib/inc_linux/jni.h @@ -0,0 +1,1959 @@ +/* + * Copyright (c) 1996, 2006, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * We used part of Netscape's Java Runtime Interface (JRI) as the starting + * point of our design and implementation. + */ + +/****************************************************************************** + * Java Runtime Interface + * Copyright (c) 1996 Netscape Communications Corporation. All rights reserved. + *****************************************************************************/ + +#ifndef _JAVASOFT_JNI_H_ +#define _JAVASOFT_JNI_H_ + +#include +#include + +/* jni_md.h contains the machine-dependent typedefs for jbyte, jint + and jlong */ + +#include "jni_md.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * JNI Types + */ + +#ifndef JNI_TYPES_ALREADY_DEFINED_IN_JNI_MD_H + +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; + +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; + +/* Return values from jobjectRefType */ +typedef enum _jobjectType { + JNIInvalidRefType = 0, + JNILocalRefType = 1, + JNIGlobalRefType = 2, + JNIWeakGlobalRefType = 3 +} jobjectRefType; + + +#endif /* JNI_TYPES_ALREADY_DEFINED_IN_JNI_MD_H */ + +/* + * 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, const 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, const 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, const 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, const 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, const 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, const 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, const 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, const 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, const 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, const 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, const 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, + const jvalue * args); + + jboolean (JNICALL *CallNonvirtualBooleanMethod) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); + jboolean (JNICALL *CallNonvirtualBooleanMethodV) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + va_list args); + jboolean (JNICALL *CallNonvirtualBooleanMethodA) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + const jvalue * args); + + jbyte (JNICALL *CallNonvirtualByteMethod) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); + jbyte (JNICALL *CallNonvirtualByteMethodV) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + va_list args); + jbyte (JNICALL *CallNonvirtualByteMethodA) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + const jvalue *args); + + jchar (JNICALL *CallNonvirtualCharMethod) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); + jchar (JNICALL *CallNonvirtualCharMethodV) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + va_list args); + jchar (JNICALL *CallNonvirtualCharMethodA) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + const jvalue *args); + + jshort (JNICALL *CallNonvirtualShortMethod) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); + jshort (JNICALL *CallNonvirtualShortMethodV) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + va_list args); + jshort (JNICALL *CallNonvirtualShortMethodA) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + const jvalue *args); + + jint (JNICALL *CallNonvirtualIntMethod) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); + jint (JNICALL *CallNonvirtualIntMethodV) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + va_list args); + jint (JNICALL *CallNonvirtualIntMethodA) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + const jvalue *args); + + jlong (JNICALL *CallNonvirtualLongMethod) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); + jlong (JNICALL *CallNonvirtualLongMethodV) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + va_list args); + jlong (JNICALL *CallNonvirtualLongMethodA) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + const jvalue *args); + + jfloat (JNICALL *CallNonvirtualFloatMethod) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); + jfloat (JNICALL *CallNonvirtualFloatMethodV) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + va_list args); + jfloat (JNICALL *CallNonvirtualFloatMethodA) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + const jvalue *args); + + jdouble (JNICALL *CallNonvirtualDoubleMethod) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); + jdouble (JNICALL *CallNonvirtualDoubleMethodV) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + va_list args); + jdouble (JNICALL *CallNonvirtualDoubleMethodA) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + const jvalue *args); + + void (JNICALL *CallNonvirtualVoidMethod) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); + void (JNICALL *CallNonvirtualVoidMethodV) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + va_list args); + void (JNICALL *CallNonvirtualVoidMethodA) + (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, + const jvalue * args); + + jfieldID (JNICALL *GetFieldID) + (JNIEnv *env, jclass clazz, const char *name, const char *sig); + + jobject (JNICALL *GetObjectField) + (JNIEnv *env, jobject obj, jfieldID fieldID); + jboolean (JNICALL *GetBooleanField) + (JNIEnv *env, jobject obj, jfieldID fieldID); + jbyte (JNICALL *GetByteField) + (JNIEnv *env, jobject obj, jfieldID fieldID); + jchar (JNICALL *GetCharField) + (JNIEnv *env, jobject obj, jfieldID fieldID); + jshort (JNICALL *GetShortField) + (JNIEnv *env, jobject obj, jfieldID fieldID); + jint (JNICALL *GetIntField) + (JNIEnv *env, jobject obj, jfieldID fieldID); + jlong (JNICALL *GetLongField) + (JNIEnv *env, jobject obj, jfieldID fieldID); + jfloat (JNICALL *GetFloatField) + (JNIEnv *env, jobject obj, jfieldID fieldID); + jdouble (JNICALL *GetDoubleField) + (JNIEnv *env, jobject obj, jfieldID fieldID); + + void (JNICALL *SetObjectField) + (JNIEnv *env, jobject obj, jfieldID fieldID, jobject val); + void (JNICALL *SetBooleanField) + (JNIEnv *env, jobject obj, jfieldID fieldID, jboolean val); + void (JNICALL *SetByteField) + (JNIEnv *env, jobject obj, jfieldID fieldID, jbyte val); + void (JNICALL *SetCharField) + (JNIEnv *env, jobject obj, jfieldID fieldID, jchar val); + void (JNICALL *SetShortField) + (JNIEnv *env, jobject obj, jfieldID fieldID, jshort val); + void (JNICALL *SetIntField) + (JNIEnv *env, jobject obj, jfieldID fieldID, jint val); + void (JNICALL *SetLongField) + (JNIEnv *env, jobject obj, jfieldID fieldID, jlong val); + void (JNICALL *SetFloatField) + (JNIEnv *env, jobject obj, jfieldID fieldID, jfloat val); + void (JNICALL *SetDoubleField) + (JNIEnv *env, jobject obj, jfieldID fieldID, jdouble val); + + jmethodID (JNICALL *GetStaticMethodID) + (JNIEnv *env, jclass clazz, const char *name, const char *sig); + + jobject (JNICALL *CallStaticObjectMethod) + (JNIEnv *env, jclass clazz, jmethodID methodID, ...); + jobject (JNICALL *CallStaticObjectMethodV) + (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); + jobject (JNICALL *CallStaticObjectMethodA) + (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args); + + jboolean (JNICALL *CallStaticBooleanMethod) + (JNIEnv *env, jclass clazz, jmethodID methodID, ...); + jboolean (JNICALL *CallStaticBooleanMethodV) + (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); + jboolean (JNICALL *CallStaticBooleanMethodA) + (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args); + + jbyte (JNICALL *CallStaticByteMethod) + (JNIEnv *env, jclass clazz, jmethodID methodID, ...); + jbyte (JNICALL *CallStaticByteMethodV) + (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); + jbyte (JNICALL *CallStaticByteMethodA) + (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args); + + jchar (JNICALL *CallStaticCharMethod) + (JNIEnv *env, jclass clazz, jmethodID methodID, ...); + jchar (JNICALL *CallStaticCharMethodV) + (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); + jchar (JNICALL *CallStaticCharMethodA) + (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args); + + jshort (JNICALL *CallStaticShortMethod) + (JNIEnv *env, jclass clazz, jmethodID methodID, ...); + jshort (JNICALL *CallStaticShortMethodV) + (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); + jshort (JNICALL *CallStaticShortMethodA) + (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args); + + jint (JNICALL *CallStaticIntMethod) + (JNIEnv *env, jclass clazz, jmethodID methodID, ...); + jint (JNICALL *CallStaticIntMethodV) + (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); + jint (JNICALL *CallStaticIntMethodA) + (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args); + + jlong (JNICALL *CallStaticLongMethod) + (JNIEnv *env, jclass clazz, jmethodID methodID, ...); + jlong (JNICALL *CallStaticLongMethodV) + (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); + jlong (JNICALL *CallStaticLongMethodA) + (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args); + + jfloat (JNICALL *CallStaticFloatMethod) + (JNIEnv *env, jclass clazz, jmethodID methodID, ...); + jfloat (JNICALL *CallStaticFloatMethodV) + (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); + jfloat (JNICALL *CallStaticFloatMethodA) + (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args); + + jdouble (JNICALL *CallStaticDoubleMethod) + (JNIEnv *env, jclass clazz, jmethodID methodID, ...); + jdouble (JNICALL *CallStaticDoubleMethodV) + (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); + jdouble (JNICALL *CallStaticDoubleMethodA) + (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args); + + void (JNICALL *CallStaticVoidMethod) + (JNIEnv *env, jclass cls, jmethodID methodID, ...); + void (JNICALL *CallStaticVoidMethodV) + (JNIEnv *env, jclass cls, jmethodID methodID, va_list args); + void (JNICALL *CallStaticVoidMethodA) + (JNIEnv *env, jclass cls, jmethodID methodID, const jvalue * args); + + jfieldID (JNICALL *GetStaticFieldID) + (JNIEnv *env, jclass clazz, const char *name, const char *sig); + jobject (JNICALL *GetStaticObjectField) + (JNIEnv *env, jclass clazz, jfieldID fieldID); + jboolean (JNICALL *GetStaticBooleanField) + (JNIEnv *env, jclass clazz, jfieldID fieldID); + jbyte (JNICALL *GetStaticByteField) + (JNIEnv *env, jclass clazz, jfieldID fieldID); + jchar (JNICALL *GetStaticCharField) + (JNIEnv *env, jclass clazz, jfieldID fieldID); + jshort (JNICALL *GetStaticShortField) + (JNIEnv *env, jclass clazz, jfieldID fieldID); + jint (JNICALL *GetStaticIntField) + (JNIEnv *env, jclass clazz, jfieldID fieldID); + jlong (JNICALL *GetStaticLongField) + (JNIEnv *env, jclass clazz, jfieldID fieldID); + jfloat (JNICALL *GetStaticFloatField) + (JNIEnv *env, jclass clazz, jfieldID fieldID); + jdouble (JNICALL *GetStaticDoubleField) + (JNIEnv *env, jclass clazz, jfieldID fieldID); + + void (JNICALL *SetStaticObjectField) + (JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value); + void (JNICALL *SetStaticBooleanField) + (JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value); + void (JNICALL *SetStaticByteField) + (JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value); + void (JNICALL *SetStaticCharField) + (JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value); + void (JNICALL *SetStaticShortField) + (JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value); + void (JNICALL *SetStaticIntField) + (JNIEnv *env, jclass clazz, jfieldID fieldID, jint value); + void (JNICALL *SetStaticLongField) + (JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value); + void (JNICALL *SetStaticFloatField) + (JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value); + void (JNICALL *SetStaticDoubleField) + (JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value); + + jstring (JNICALL *NewString) + (JNIEnv *env, const jchar *unicode, jsize len); + jsize (JNICALL *GetStringLength) + (JNIEnv *env, jstring str); + const jchar *(JNICALL *GetStringChars) + (JNIEnv *env, jstring str, jboolean *isCopy); + void (JNICALL *ReleaseStringChars) + (JNIEnv *env, jstring str, const jchar *chars); + + jstring (JNICALL *NewStringUTF) + (JNIEnv *env, const char *utf); + jsize (JNICALL *GetStringUTFLength) + (JNIEnv *env, jstring str); + const char* (JNICALL *GetStringUTFChars) + (JNIEnv *env, jstring str, jboolean *isCopy); + void (JNICALL *ReleaseStringUTFChars) + (JNIEnv *env, jstring str, const char* chars); + + + jsize (JNICALL *GetArrayLength) + (JNIEnv *env, jarray array); + + jobjectArray (JNICALL *NewObjectArray) + (JNIEnv *env, jsize len, jclass clazz, jobject init); + jobject (JNICALL *GetObjectArrayElement) + (JNIEnv *env, jobjectArray array, jsize index); + void (JNICALL *SetObjectArrayElement) + (JNIEnv *env, jobjectArray array, jsize index, jobject val); + + jbooleanArray (JNICALL *NewBooleanArray) + (JNIEnv *env, jsize len); + jbyteArray (JNICALL *NewByteArray) + (JNIEnv *env, jsize len); + jcharArray (JNICALL *NewCharArray) + (JNIEnv *env, jsize len); + jshortArray (JNICALL *NewShortArray) + (JNIEnv *env, jsize len); + jintArray (JNICALL *NewIntArray) + (JNIEnv *env, jsize len); + jlongArray (JNICALL *NewLongArray) + (JNIEnv *env, jsize len); + jfloatArray (JNICALL *NewFloatArray) + (JNIEnv *env, jsize len); + jdoubleArray (JNICALL *NewDoubleArray) + (JNIEnv *env, jsize len); + + jboolean * (JNICALL *GetBooleanArrayElements) + (JNIEnv *env, jbooleanArray array, jboolean *isCopy); + jbyte * (JNICALL *GetByteArrayElements) + (JNIEnv *env, jbyteArray array, jboolean *isCopy); + jchar * (JNICALL *GetCharArrayElements) + (JNIEnv *env, jcharArray array, jboolean *isCopy); + jshort * (JNICALL *GetShortArrayElements) + (JNIEnv *env, jshortArray array, jboolean *isCopy); + jint * (JNICALL *GetIntArrayElements) + (JNIEnv *env, jintArray array, jboolean *isCopy); + jlong * (JNICALL *GetLongArrayElements) + (JNIEnv *env, jlongArray array, jboolean *isCopy); + jfloat * (JNICALL *GetFloatArrayElements) + (JNIEnv *env, jfloatArray array, jboolean *isCopy); + jdouble * (JNICALL *GetDoubleArrayElements) + (JNIEnv *env, jdoubleArray array, jboolean *isCopy); + + void (JNICALL *ReleaseBooleanArrayElements) + (JNIEnv *env, jbooleanArray array, jboolean *elems, jint mode); + void (JNICALL *ReleaseByteArrayElements) + (JNIEnv *env, jbyteArray array, jbyte *elems, jint mode); + void (JNICALL *ReleaseCharArrayElements) + (JNIEnv *env, jcharArray array, jchar *elems, jint mode); + void (JNICALL *ReleaseShortArrayElements) + (JNIEnv *env, jshortArray array, jshort *elems, jint mode); + void (JNICALL *ReleaseIntArrayElements) + (JNIEnv *env, jintArray array, jint *elems, jint mode); + void (JNICALL *ReleaseLongArrayElements) + (JNIEnv *env, jlongArray array, jlong *elems, jint mode); + void (JNICALL *ReleaseFloatArrayElements) + (JNIEnv *env, jfloatArray array, jfloat *elems, jint mode); + void (JNICALL *ReleaseDoubleArrayElements) + (JNIEnv *env, jdoubleArray array, jdouble *elems, jint mode); + + void (JNICALL *GetBooleanArrayRegion) + (JNIEnv *env, jbooleanArray array, jsize start, jsize l, jboolean *buf); + void (JNICALL *GetByteArrayRegion) + (JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf); + void (JNICALL *GetCharArrayRegion) + (JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf); + void (JNICALL *GetShortArrayRegion) + (JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf); + void (JNICALL *GetIntArrayRegion) + (JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf); + void (JNICALL *GetLongArrayRegion) + (JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf); + void (JNICALL *GetFloatArrayRegion) + (JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf); + void (JNICALL *GetDoubleArrayRegion) + (JNIEnv *env, jdoubleArray array, jsize start, jsize len, jdouble *buf); + + void (JNICALL *SetBooleanArrayRegion) + (JNIEnv *env, jbooleanArray array, jsize start, jsize l, const jboolean *buf); + void (JNICALL *SetByteArrayRegion) + (JNIEnv *env, jbyteArray array, jsize start, jsize len, const jbyte *buf); + void (JNICALL *SetCharArrayRegion) + (JNIEnv *env, jcharArray array, jsize start, jsize len, const jchar *buf); + void (JNICALL *SetShortArrayRegion) + (JNIEnv *env, jshortArray array, jsize start, jsize len, const jshort *buf); + void (JNICALL *SetIntArrayRegion) + (JNIEnv *env, jintArray array, jsize start, jsize len, const jint *buf); + void (JNICALL *SetLongArrayRegion) + (JNIEnv *env, jlongArray array, jsize start, jsize len, const jlong *buf); + void (JNICALL *SetFloatArrayRegion) + (JNIEnv *env, jfloatArray array, jsize start, jsize len, const jfloat *buf); + void (JNICALL *SetDoubleArrayRegion) + (JNIEnv *env, jdoubleArray array, jsize start, jsize len, const jdouble *buf); + + jint (JNICALL *RegisterNatives) + (JNIEnv *env, jclass clazz, const JNINativeMethod *methods, + jint nMethods); + jint (JNICALL *UnregisterNatives) + (JNIEnv *env, jclass clazz); + + jint (JNICALL *MonitorEnter) + (JNIEnv *env, jobject obj); + jint (JNICALL *MonitorExit) + (JNIEnv *env, jobject obj); + + jint (JNICALL *GetJavaVM) + (JNIEnv *env, JavaVM **vm); + + void (JNICALL *GetStringRegion) + (JNIEnv *env, jstring str, jsize start, jsize len, jchar *buf); + void (JNICALL *GetStringUTFRegion) + (JNIEnv *env, jstring str, jsize start, jsize len, char *buf); + + void * (JNICALL *GetPrimitiveArrayCritical) + (JNIEnv *env, jarray array, jboolean *isCopy); + void (JNICALL *ReleasePrimitiveArrayCritical) + (JNIEnv *env, jarray array, void *carray, jint mode); + + const jchar * (JNICALL *GetStringCritical) + (JNIEnv *env, jstring string, jboolean *isCopy); + void (JNICALL *ReleaseStringCritical) + (JNIEnv *env, jstring string, const jchar *cstring); + + jweak (JNICALL *NewWeakGlobalRef) + (JNIEnv *env, jobject obj); + void (JNICALL *DeleteWeakGlobalRef) + (JNIEnv *env, jweak ref); + + jboolean (JNICALL *ExceptionCheck) + (JNIEnv *env); + + jobject (JNICALL *NewDirectByteBuffer) + (JNIEnv* env, void* address, jlong capacity); + void* (JNICALL *GetDirectBufferAddress) + (JNIEnv* env, jobject buf); + jlong (JNICALL *GetDirectBufferCapacity) + (JNIEnv* env, jobject buf); + + /* New JNI 1.6 Features */ + + jobjectRefType (JNICALL *GetObjectRefType) + (JNIEnv* env, jobject obj); +}; + +/* + * We use inlined functions for C++ so that programmers can write: + * + * env->FindClass("java/lang/String") + * + * in C++ rather than: + * + * (*env)->FindClass(env, "java/lang/String") + * + * in C. + */ + +struct JNIEnv_ { + const struct JNINativeInterface_ *functions; +#ifdef __cplusplus + + jint GetVersion() { + return functions->GetVersion(this); + } + jclass DefineClass(const char *name, jobject loader, const jbyte *buf, + jsize len) { + return functions->DefineClass(this, name, loader, buf, len); + } + 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 sub) { + return functions->GetSuperclass(this, sub); + } + jboolean IsAssignableFrom(jclass sub, jclass sup) { + return functions->IsAssignableFrom(this, sub, sup); + } + + 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 *msg) { + return functions->ThrowNew(this, clazz, msg); + } + 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 lobj) { + return functions->NewGlobalRef(this,lobj); + } + void DeleteGlobalRef(jobject gref) { + functions->DeleteGlobalRef(this,gref); + } + void DeleteLocalRef(jobject obj) { + functions->DeleteLocalRef(this, obj); + } + + jboolean IsSameObject(jobject obj1, jobject obj2) { + return functions->IsSameObject(this,obj1,obj2); + } + + 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; + jobject result; + va_start(args, methodID); + 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, + const 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); + } + + jobject CallObjectMethod(jobject obj, jmethodID methodID, ...) { + va_list args; + jobject result; + va_start(args,methodID); + result = functions->CallObjectMethodV(this,obj,methodID,args); + va_end(args); + return result; + } + jobject CallObjectMethodV(jobject obj, jmethodID methodID, + va_list args) { + return functions->CallObjectMethodV(this,obj,methodID,args); + } + jobject CallObjectMethodA(jobject obj, jmethodID methodID, + const jvalue * args) { + return functions->CallObjectMethodA(this,obj,methodID,args); + } + + jboolean CallBooleanMethod(jobject obj, + jmethodID methodID, ...) { + va_list args; + jboolean result; + va_start(args,methodID); + result = functions->CallBooleanMethodV(this,obj,methodID,args); + va_end(args); + return result; + } + jboolean CallBooleanMethodV(jobject obj, jmethodID methodID, + va_list args) { + return functions->CallBooleanMethodV(this,obj,methodID,args); + } + jboolean CallBooleanMethodA(jobject obj, jmethodID methodID, + const jvalue * args) { + return functions->CallBooleanMethodA(this,obj,methodID, args); + } + + jbyte CallByteMethod(jobject obj, jmethodID methodID, ...) { + va_list args; + jbyte result; + va_start(args,methodID); + result = functions->CallByteMethodV(this,obj,methodID,args); + va_end(args); + return result; + } + jbyte CallByteMethodV(jobject obj, jmethodID methodID, + va_list args) { + return functions->CallByteMethodV(this,obj,methodID,args); + } + jbyte CallByteMethodA(jobject obj, jmethodID methodID, + const jvalue * args) { + return functions->CallByteMethodA(this,obj,methodID,args); + } + + jchar CallCharMethod(jobject obj, jmethodID methodID, ...) { + va_list args; + jchar result; + va_start(args,methodID); + result = functions->CallCharMethodV(this,obj,methodID,args); + va_end(args); + return result; + } + jchar CallCharMethodV(jobject obj, jmethodID methodID, + va_list args) { + return functions->CallCharMethodV(this,obj,methodID,args); + } + jchar CallCharMethodA(jobject obj, jmethodID methodID, + const jvalue * args) { + return functions->CallCharMethodA(this,obj,methodID,args); + } + + jshort CallShortMethod(jobject obj, jmethodID methodID, ...) { + va_list args; + jshort result; + va_start(args,methodID); + result = functions->CallShortMethodV(this,obj,methodID,args); + va_end(args); + return result; + } + jshort CallShortMethodV(jobject obj, jmethodID methodID, + va_list args) { + return functions->CallShortMethodV(this,obj,methodID,args); + } + jshort CallShortMethodA(jobject obj, jmethodID methodID, + const jvalue * args) { + return functions->CallShortMethodA(this,obj,methodID,args); + } + + jint CallIntMethod(jobject obj, jmethodID methodID, ...) { + va_list args; + jint result; + va_start(args,methodID); + result = functions->CallIntMethodV(this,obj,methodID,args); + va_end(args); + return result; + } + jint CallIntMethodV(jobject obj, jmethodID methodID, + va_list args) { + return functions->CallIntMethodV(this,obj,methodID,args); + } + jint CallIntMethodA(jobject obj, jmethodID methodID, + const jvalue * args) { + return functions->CallIntMethodA(this,obj,methodID,args); + } + + jlong CallLongMethod(jobject obj, jmethodID methodID, ...) { + va_list args; + jlong result; + va_start(args,methodID); + result = functions->CallLongMethodV(this,obj,methodID,args); + va_end(args); + return result; + } + jlong CallLongMethodV(jobject obj, jmethodID methodID, + va_list args) { + return functions->CallLongMethodV(this,obj,methodID,args); + } + jlong CallLongMethodA(jobject obj, jmethodID methodID, + const jvalue * args) { + return functions->CallLongMethodA(this,obj,methodID,args); + } + + jfloat CallFloatMethod(jobject obj, jmethodID methodID, ...) { + va_list args; + jfloat result; + va_start(args,methodID); + result = functions->CallFloatMethodV(this,obj,methodID,args); + va_end(args); + return result; + } + jfloat CallFloatMethodV(jobject obj, jmethodID methodID, + va_list args) { + return functions->CallFloatMethodV(this,obj,methodID,args); + } + jfloat CallFloatMethodA(jobject obj, jmethodID methodID, + const jvalue * args) { + return functions->CallFloatMethodA(this,obj,methodID,args); + } + + jdouble CallDoubleMethod(jobject obj, jmethodID methodID, ...) { + va_list args; + jdouble result; + va_start(args,methodID); + result = functions->CallDoubleMethodV(this,obj,methodID,args); + va_end(args); + return result; + } + jdouble CallDoubleMethodV(jobject obj, jmethodID methodID, + va_list args) { + return functions->CallDoubleMethodV(this,obj,methodID,args); + } + jdouble CallDoubleMethodA(jobject obj, jmethodID methodID, + const jvalue * args) { + return functions->CallDoubleMethodA(this,obj,methodID,args); + } + + 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, + const jvalue * args) { + functions->CallVoidMethodA(this,obj,methodID,args); + } + + jobject CallNonvirtualObjectMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) { + va_list args; + jobject result; + va_start(args,methodID); + result = functions->CallNonvirtualObjectMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; + } + jobject CallNonvirtualObjectMethodV(jobject obj, jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallNonvirtualObjectMethodV(this,obj,clazz, + methodID,args); + } + jobject CallNonvirtualObjectMethodA(jobject obj, jclass clazz, + jmethodID methodID, const jvalue * args) { + return functions->CallNonvirtualObjectMethodA(this,obj,clazz, + methodID,args); + } + + jboolean CallNonvirtualBooleanMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) { + va_list args; + jboolean result; + va_start(args,methodID); + result = functions->CallNonvirtualBooleanMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; + } + jboolean CallNonvirtualBooleanMethodV(jobject obj, jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallNonvirtualBooleanMethodV(this,obj,clazz, + methodID,args); + } + jboolean CallNonvirtualBooleanMethodA(jobject obj, jclass clazz, + jmethodID methodID, const jvalue * args) { + return functions->CallNonvirtualBooleanMethodA(this,obj,clazz, + methodID, args); + } + + jbyte CallNonvirtualByteMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) { + va_list args; + jbyte result; + va_start(args,methodID); + result = functions->CallNonvirtualByteMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; + } + jbyte CallNonvirtualByteMethodV(jobject obj, jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallNonvirtualByteMethodV(this,obj,clazz, + methodID,args); + } + jbyte CallNonvirtualByteMethodA(jobject obj, jclass clazz, + jmethodID methodID, const jvalue * args) { + return functions->CallNonvirtualByteMethodA(this,obj,clazz, + methodID,args); + } + + jchar CallNonvirtualCharMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) { + va_list args; + jchar result; + va_start(args,methodID); + result = functions->CallNonvirtualCharMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; + } + jchar CallNonvirtualCharMethodV(jobject obj, jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallNonvirtualCharMethodV(this,obj,clazz, + methodID,args); + } + jchar CallNonvirtualCharMethodA(jobject obj, jclass clazz, + jmethodID methodID, const jvalue * args) { + return functions->CallNonvirtualCharMethodA(this,obj,clazz, + methodID,args); + } + + jshort CallNonvirtualShortMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) { + va_list args; + jshort result; + va_start(args,methodID); + result = functions->CallNonvirtualShortMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; + } + jshort CallNonvirtualShortMethodV(jobject obj, jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallNonvirtualShortMethodV(this,obj,clazz, + methodID,args); + } + jshort CallNonvirtualShortMethodA(jobject obj, jclass clazz, + jmethodID methodID, const jvalue * args) { + return functions->CallNonvirtualShortMethodA(this,obj,clazz, + methodID,args); + } + + jint CallNonvirtualIntMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) { + va_list args; + jint result; + va_start(args,methodID); + result = functions->CallNonvirtualIntMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; + } + jint CallNonvirtualIntMethodV(jobject obj, jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallNonvirtualIntMethodV(this,obj,clazz, + methodID,args); + } + jint CallNonvirtualIntMethodA(jobject obj, jclass clazz, + jmethodID methodID, const jvalue * args) { + return functions->CallNonvirtualIntMethodA(this,obj,clazz, + methodID,args); + } + + jlong CallNonvirtualLongMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) { + va_list args; + jlong result; + va_start(args,methodID); + result = functions->CallNonvirtualLongMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; + } + jlong CallNonvirtualLongMethodV(jobject obj, jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallNonvirtualLongMethodV(this,obj,clazz, + methodID,args); + } + jlong CallNonvirtualLongMethodA(jobject obj, jclass clazz, + jmethodID methodID, const jvalue * args) { + return functions->CallNonvirtualLongMethodA(this,obj,clazz, + methodID,args); + } + + jfloat CallNonvirtualFloatMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) { + va_list args; + jfloat result; + va_start(args,methodID); + result = functions->CallNonvirtualFloatMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; + } + jfloat CallNonvirtualFloatMethodV(jobject obj, jclass clazz, + jmethodID methodID, + va_list args) { + return functions->CallNonvirtualFloatMethodV(this,obj,clazz, + methodID,args); + } + jfloat CallNonvirtualFloatMethodA(jobject obj, jclass clazz, + jmethodID methodID, + const jvalue * args) { + return functions->CallNonvirtualFloatMethodA(this,obj,clazz, + methodID,args); + } + + jdouble CallNonvirtualDoubleMethod(jobject obj, jclass clazz, + jmethodID methodID, ...) { + va_list args; + jdouble result; + va_start(args,methodID); + result = functions->CallNonvirtualDoubleMethodV(this,obj,clazz, + methodID,args); + va_end(args); + return result; + } + jdouble CallNonvirtualDoubleMethodV(jobject obj, jclass clazz, + jmethodID methodID, + va_list args) { + return functions->CallNonvirtualDoubleMethodV(this,obj,clazz, + methodID,args); + } + jdouble CallNonvirtualDoubleMethodA(jobject obj, jclass clazz, + jmethodID methodID, + const jvalue * args) { + return functions->CallNonvirtualDoubleMethodA(this,obj,clazz, + methodID,args); + } + + 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, + const 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 val) { + functions->SetObjectField(this,obj,fieldID,val); + } + void SetBooleanField(jobject obj, jfieldID fieldID, + jboolean val) { + functions->SetBooleanField(this,obj,fieldID,val); + } + void SetByteField(jobject obj, jfieldID fieldID, + jbyte val) { + functions->SetByteField(this,obj,fieldID,val); + } + void SetCharField(jobject obj, jfieldID fieldID, + jchar val) { + functions->SetCharField(this,obj,fieldID,val); + } + void SetShortField(jobject obj, jfieldID fieldID, + jshort val) { + functions->SetShortField(this,obj,fieldID,val); + } + void SetIntField(jobject obj, jfieldID fieldID, + jint val) { + functions->SetIntField(this,obj,fieldID,val); + } + void SetLongField(jobject obj, jfieldID fieldID, + jlong val) { + functions->SetLongField(this,obj,fieldID,val); + } + void SetFloatField(jobject obj, jfieldID fieldID, + jfloat val) { + functions->SetFloatField(this,obj,fieldID,val); + } + void SetDoubleField(jobject obj, jfieldID fieldID, + jdouble val) { + functions->SetDoubleField(this,obj,fieldID,val); + } + + jmethodID GetStaticMethodID(jclass clazz, const char *name, + const char *sig) { + return functions->GetStaticMethodID(this,clazz,name,sig); + } + + jobject CallStaticObjectMethod(jclass clazz, jmethodID methodID, + ...) { + va_list args; + jobject result; + va_start(args,methodID); + result = functions->CallStaticObjectMethodV(this,clazz,methodID,args); + va_end(args); + return result; + } + jobject CallStaticObjectMethodV(jclass clazz, jmethodID methodID, + va_list args) { + return functions->CallStaticObjectMethodV(this,clazz,methodID,args); + } + jobject CallStaticObjectMethodA(jclass clazz, jmethodID methodID, + const jvalue *args) { + return functions->CallStaticObjectMethodA(this,clazz,methodID,args); + } + + jboolean CallStaticBooleanMethod(jclass clazz, + jmethodID methodID, ...) { + va_list args; + jboolean result; + va_start(args,methodID); + result = functions->CallStaticBooleanMethodV(this,clazz,methodID,args); + va_end(args); + return result; + } + jboolean CallStaticBooleanMethodV(jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallStaticBooleanMethodV(this,clazz,methodID,args); + } + jboolean CallStaticBooleanMethodA(jclass clazz, + jmethodID methodID, const jvalue *args) { + return functions->CallStaticBooleanMethodA(this,clazz,methodID,args); + } + + jbyte CallStaticByteMethod(jclass clazz, + jmethodID methodID, ...) { + va_list args; + jbyte result; + va_start(args,methodID); + result = functions->CallStaticByteMethodV(this,clazz,methodID,args); + va_end(args); + return result; + } + jbyte CallStaticByteMethodV(jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallStaticByteMethodV(this,clazz,methodID,args); + } + jbyte CallStaticByteMethodA(jclass clazz, + jmethodID methodID, const jvalue *args) { + return functions->CallStaticByteMethodA(this,clazz,methodID,args); + } + + jchar CallStaticCharMethod(jclass clazz, + jmethodID methodID, ...) { + va_list args; + jchar result; + va_start(args,methodID); + result = functions->CallStaticCharMethodV(this,clazz,methodID,args); + va_end(args); + return result; + } + jchar CallStaticCharMethodV(jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallStaticCharMethodV(this,clazz,methodID,args); + } + jchar CallStaticCharMethodA(jclass clazz, + jmethodID methodID, const jvalue *args) { + return functions->CallStaticCharMethodA(this,clazz,methodID,args); + } + + jshort CallStaticShortMethod(jclass clazz, + jmethodID methodID, ...) { + va_list args; + jshort result; + va_start(args,methodID); + result = functions->CallStaticShortMethodV(this,clazz,methodID,args); + va_end(args); + return result; + } + jshort CallStaticShortMethodV(jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallStaticShortMethodV(this,clazz,methodID,args); + } + jshort CallStaticShortMethodA(jclass clazz, + jmethodID methodID, const jvalue *args) { + return functions->CallStaticShortMethodA(this,clazz,methodID,args); + } + + jint CallStaticIntMethod(jclass clazz, + jmethodID methodID, ...) { + va_list args; + jint result; + va_start(args,methodID); + result = functions->CallStaticIntMethodV(this,clazz,methodID,args); + va_end(args); + return result; + } + jint CallStaticIntMethodV(jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallStaticIntMethodV(this,clazz,methodID,args); + } + jint CallStaticIntMethodA(jclass clazz, + jmethodID methodID, const jvalue *args) { + return functions->CallStaticIntMethodA(this,clazz,methodID,args); + } + + jlong CallStaticLongMethod(jclass clazz, + jmethodID methodID, ...) { + va_list args; + jlong result; + va_start(args,methodID); + result = functions->CallStaticLongMethodV(this,clazz,methodID,args); + va_end(args); + return result; + } + jlong CallStaticLongMethodV(jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallStaticLongMethodV(this,clazz,methodID,args); + } + jlong CallStaticLongMethodA(jclass clazz, + jmethodID methodID, const jvalue *args) { + return functions->CallStaticLongMethodA(this,clazz,methodID,args); + } + + jfloat CallStaticFloatMethod(jclass clazz, + jmethodID methodID, ...) { + va_list args; + jfloat result; + va_start(args,methodID); + result = functions->CallStaticFloatMethodV(this,clazz,methodID,args); + va_end(args); + return result; + } + jfloat CallStaticFloatMethodV(jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallStaticFloatMethodV(this,clazz,methodID,args); + } + jfloat CallStaticFloatMethodA(jclass clazz, + jmethodID methodID, const jvalue *args) { + return functions->CallStaticFloatMethodA(this,clazz,methodID,args); + } + + jdouble CallStaticDoubleMethod(jclass clazz, + jmethodID methodID, ...) { + va_list args; + jdouble result; + va_start(args,methodID); + result = functions->CallStaticDoubleMethodV(this,clazz,methodID,args); + va_end(args); + return result; + } + jdouble CallStaticDoubleMethodV(jclass clazz, + jmethodID methodID, va_list args) { + return functions->CallStaticDoubleMethodV(this,clazz,methodID,args); + } + jdouble CallStaticDoubleMethodA(jclass clazz, + jmethodID methodID, const jvalue *args) { + return functions->CallStaticDoubleMethodA(this,clazz,methodID,args); + } + + void CallStaticVoidMethod(jclass cls, jmethodID methodID, ...) { + va_list args; + va_start(args,methodID); + functions->CallStaticVoidMethodV(this,cls,methodID,args); + va_end(args); + } + void CallStaticVoidMethodV(jclass cls, jmethodID methodID, + va_list args) { + functions->CallStaticVoidMethodV(this,cls,methodID,args); + } + void CallStaticVoidMethodA(jclass cls, jmethodID methodID, + const jvalue * args) { + functions->CallStaticVoidMethodA(this,cls,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 *unicode, jsize len) { + return functions->NewString(this,unicode,len); + } + jsize GetStringLength(jstring str) { + return functions->GetStringLength(this,str); + } + const jchar *GetStringChars(jstring str, jboolean *isCopy) { + return functions->GetStringChars(this,str,isCopy); + } + void ReleaseStringChars(jstring str, const jchar *chars) { + functions->ReleaseStringChars(this,str,chars); + } + + jstring NewStringUTF(const char *utf) { + return functions->NewStringUTF(this,utf); + } + jsize GetStringUTFLength(jstring str) { + return functions->GetStringUTFLength(this,str); + } + const char* GetStringUTFChars(jstring str, jboolean *isCopy) { + return functions->GetStringUTFChars(this,str,isCopy); + } + void ReleaseStringUTFChars(jstring str, const char* chars) { + functions->ReleaseStringUTFChars(this,str,chars); + } + + jsize GetArrayLength(jarray array) { + return functions->GetArrayLength(this,array); + } + + jobjectArray NewObjectArray(jsize len, jclass clazz, + jobject init) { + return functions->NewObjectArray(this,len,clazz,init); + } + jobject GetObjectArrayElement(jobjectArray array, jsize index) { + return functions->GetObjectArrayElement(this,array,index); + } + void SetObjectArrayElement(jobjectArray array, jsize index, + jobject val) { + functions->SetObjectArrayElement(this,array,index,val); + } + + jbooleanArray NewBooleanArray(jsize len) { + return functions->NewBooleanArray(this,len); + } + jbyteArray NewByteArray(jsize len) { + return functions->NewByteArray(this,len); + } + jcharArray NewCharArray(jsize len) { + return functions->NewCharArray(this,len); + } + jshortArray NewShortArray(jsize len) { + return functions->NewShortArray(this,len); + } + jintArray NewIntArray(jsize len) { + return functions->NewIntArray(this,len); + } + jlongArray NewLongArray(jsize len) { + return functions->NewLongArray(this,len); + } + jfloatArray NewFloatArray(jsize len) { + return functions->NewFloatArray(this,len); + } + jdoubleArray NewDoubleArray(jsize len) { + return functions->NewDoubleArray(this,len); + } + + 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) { + 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 *cstring) { + functions->ReleaseStringCritical(this,string,cstring); + } + + jweak NewWeakGlobalRef(jobject obj) { + return functions->NewWeakGlobalRef(this,obj); + } + void DeleteWeakGlobalRef(jweak ref) { + functions->DeleteWeakGlobalRef(this,ref); + } + + 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); + } + jobjectRefType GetObjectRefType(jobject obj) { + return functions->GetObjectRefType(this, obj); + } + +#endif /* __cplusplus */ +}; + +typedef struct JavaVMOption { + char *optionString; + void *extraInfo; +} JavaVMOption; + +typedef struct JavaVMInitArgs { + jint version; + + jint nOptions; + JavaVMOption *options; + jboolean ignoreUnrecognized; +} JavaVMInitArgs; + +typedef struct JavaVMAttachArgs { + jint version; + + char *name; + jobject group; +} JavaVMAttachArgs; + +/* These will be VM-specific. */ + +#define JDK1_2 +#define JDK1_4 + +/* End VM-specific. */ + +struct JNIInvokeInterface_ { + void *reserved0; + void *reserved1; + void *reserved2; + + jint (JNICALL *DestroyJavaVM)(JavaVM *vm); + + jint (JNICALL *AttachCurrentThread)(JavaVM *vm, void **penv, void *args); + + jint (JNICALL *DetachCurrentThread)(JavaVM *vm); + + jint (JNICALL *GetEnv)(JavaVM *vm, void **penv, jint version); + + jint (JNICALL *AttachCurrentThreadAsDaemon)(JavaVM *vm, void **penv, void *args); +}; + +struct JavaVM_ { + const struct JNIInvokeInterface_ *functions; +#ifdef __cplusplus + + jint DestroyJavaVM() { + return functions->DestroyJavaVM(this); + } + jint AttachCurrentThread(void **penv, void *args) { + return functions->AttachCurrentThread(this, penv, args); + } + jint DetachCurrentThread() { + return functions->DetachCurrentThread(this); + } + + jint GetEnv(void **penv, jint version) { + return functions->GetEnv(this, penv, version); + } + jint AttachCurrentThreadAsDaemon(void **penv, void *args) { + return functions->AttachCurrentThreadAsDaemon(this, penv, args); + } +#endif +}; + +#ifdef _JNI_IMPLEMENTATION_ +#define _JNI_IMPORT_OR_EXPORT_ JNIEXPORT +#else +#define _JNI_IMPORT_OR_EXPORT_ JNIIMPORT +#endif +_JNI_IMPORT_OR_EXPORT_ jint JNICALL +JNI_GetDefaultJavaVMInitArgs(void *args); + +_JNI_IMPORT_OR_EXPORT_ jint JNICALL +JNI_CreateJavaVM(JavaVM **pvm, void **penv, void *args); + +_JNI_IMPORT_OR_EXPORT_ jint JNICALL +JNI_GetCreatedJavaVMs(JavaVM **, jsize, jsize *); + +/* Defined by native libraries. */ +JNIEXPORT jint JNICALL +JNI_OnLoad(JavaVM *vm, void *reserved); + +JNIEXPORT void JNICALL +JNI_OnUnload(JavaVM *vm, void *reserved); + +#define JNI_VERSION_1_1 0x00010001 +#define JNI_VERSION_1_2 0x00010002 +#define JNI_VERSION_1_4 0x00010004 +#define JNI_VERSION_1_6 0x00010006 + +#ifdef __cplusplus +} /* extern "C" */ +#endif /* __cplusplus */ + +#endif /* !_JAVASOFT_JNI_H_ */ diff --git a/src/main/resources/org/xerial/snappy/native/Linux/arm/libsnappyjava.so b/src/main/resources/org/xerial/snappy/native/Linux/arm/libsnappyjava.so index 98039486a81154e67711fc4b6c4f210073ac3c8a..3299072878be828404e870fd278680bc8b138a41 100755 GIT binary patch delta 8055 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 delta 7943 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 diff --git a/src/main/resources/org/xerial/snappy/native/Linux/armhf/libsnappyjava.so b/src/main/resources/org/xerial/snappy/native/Linux/armhf/libsnappyjava.so index e30dbbda155d5fba02213815621724ad86d1a0f0..23b37c6da1035bada6fca5a0a03fe9ca8d14fff5 100755 GIT binary patch delta 8003 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 delta 7843 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 E0gCnAU;qFB diff --git a/src/main/resources/org/xerial/snappy/native/Linux/i386/libsnappyjava.so b/src/main/resources/org/xerial/snappy/native/Linux/i386/libsnappyjava.so index 548fc6e2a84d78185e51bd6bc04b66891be8b337..008546530fc92d1aa6de1d628bf92c68641ff7a2 100755 GIT binary patch literal 169780 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

OipVxiKSiluRe9~TNF<5?-H3so7WnQy>s^*xdC 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