From 8ce4d4e0c26cd8d13fdf64818f08f216576823f4 Mon Sep 17 00:00:00 2001 From: Adam Brewster Date: Sat, 2 Jan 2016 19:01:59 -0500 Subject: [PATCH 01/18] move some types to jnienv --- src/core.jl | 17 ----------------- src/jnienv.jl | 17 +++++++++++++++++ 2 files changed, 17 insertions(+), 17 deletions(-) diff --git a/src/core.jl b/src/core.jl index dbaacbc..1bc079f 100644 --- a/src/core.jl +++ b/src/core.jl @@ -1,21 +1,4 @@ -# jni_md.h -typealias jint Cint -#ifdef _LP64 /* 64-bit Solaris */ -# typedef long jlong; -typealias jlong Clonglong -typealias jbyte Cchar - -# jni.h - -typealias jboolean Cuchar -typealias jchar Cushort -typealias jshort Cshort -typealias jfloat Cfloat -typealias jdouble Cdouble -typealias jsize jint -jprimitive = @compat Union{jboolean, jchar, jshort, jfloat, jdouble, jint, jlong} - immutable JavaMetaClass{T} ptr::Ptr{Void} end diff --git a/src/jnienv.jl b/src/jnienv.jl index d88d16d..8087e7b 100644 --- a/src/jnienv.jl +++ b/src/jnienv.jl @@ -1,3 +1,20 @@ +# jni_md.h +typealias jint Cint +#ifdef _LP64 /* 64-bit Solaris */ +# typedef long jlong; +typealias jlong Clonglong +typealias jbyte Cchar + +# jni.h + +typealias jboolean Cuchar +typealias jchar Cushort +typealias jshort Cshort +typealias jfloat Cfloat +typealias jdouble Cdouble +typealias jsize jint +jprimitive = @compat Union{jboolean, jchar, jshort, jfloat, jdouble, jint, jlong} + immutable JNINativeInterface #struct JNINativeInterface_ { From 5c4e55f4602a88503f2097e7c53fa3427a57b0b2 Mon Sep 17 00:00:00 2001 From: Adam Brewster Date: Sat, 2 Jan 2016 19:02:42 -0500 Subject: [PATCH 02/18] first cut jnienv2.jl --- src/JavaCall.jl | 3 + src/jnienv2.jl | 679 +++++++++++++++++++++++++++++++++++++++++++++++ src/make_jni2.jl | 88 ++++++ 3 files changed, 770 insertions(+) create mode 100644 src/jnienv2.jl create mode 100644 src/make_jni2.jl diff --git a/src/JavaCall.jl b/src/JavaCall.jl index 4123028..5dfd147 100644 --- a/src/JavaCall.jl +++ b/src/JavaCall.jl @@ -32,6 +32,9 @@ end include("jvm.jl") include("jnienv.jl") +include("jnienv2.jl") +using .JNI + include("core.jl") include("convert.jl") include("reflect.jl") diff --git a/src/jnienv2.jl b/src/jnienv2.jl new file mode 100644 index 0000000..33dd55d --- /dev/null +++ b/src/jnienv2.jl @@ -0,0 +1,679 @@ +module JNI +import ..JavaCall: JNIEnv, JavaVM, jbyte, jchar, jshort, jint, jlong, jsize, jdouble, jfloat, jboolean +typealias jobject Ptr{Void} +typealias jclass Ptr{Void} +typealias jthrowable Ptr{Void} +typealias jweak Ptr{Void} +typealias jmethodID Ptr{Void} +typealias jfieldID Ptr{Void} +typealias jvalue Ptr{Void} +typealias jstring Ptr{Void} +typealias jarray Ptr{Void} +typealias JNINativeMethod Ptr{Void} +typealias jobjectArray Ptr{Void} +typealias jbooleanArray Ptr{Void} +typealias jbyteArray Ptr{Void} +typealias jshortArray Ptr{Void} +typealias jintArray Ptr{Void} +typealias jlongArray Ptr{Void} +typealias jfloatArray Ptr{Void} +typealias jdoubleArray Ptr{Void} +typealias jcharArray Ptr{Void} + +export GetVersion +GetVersion(env::Ptr{JNIEnv}) = + ccall(Main.JavaCall.jnifunc.GetVersion, jint, (Ptr{JNIEnv},), env) + +export DefineClass +DefineClass(env::Ptr{JNIEnv}, name::AbstractString, loader::jobject, buf::Array{jbyte,1}, len::Integer) = + ccall(Main.JavaCall.jnifunc.DefineClass, jclass, (Ptr{JNIEnv}, Cstring, jobject, Ptr{jbyte}, jsize,), env, utf8(name), loader, buf, len) + +export FindClass +FindClass(env::Ptr{JNIEnv}, name::AbstractString) = + ccall(Main.JavaCall.jnifunc.FindClass, jclass, (Ptr{JNIEnv}, Cstring,), env, utf8(name)) + +export FromReflectedMethod +FromReflectedMethod(env::Ptr{JNIEnv}, method::jobject) = + ccall(Main.JavaCall.jnifunc.FromReflectedMethod, jmethodID, (Ptr{JNIEnv}, jobject,), env, method) + +export FromReflectedField +FromReflectedField(env::Ptr{JNIEnv}, field::jobject) = + ccall(Main.JavaCall.jnifunc.FromReflectedField, jfieldID, (Ptr{JNIEnv}, jobject,), env, field) + +export ToReflectedMethod +ToReflectedMethod(env::Ptr{JNIEnv}, cls::jclass, methodID::jmethodID, isStatic::jboolean) = + ccall(Main.JavaCall.jnifunc.ToReflectedMethod, jobject, (Ptr{JNIEnv}, jclass, jmethodID, jboolean,), env, cls, methodID, isStatic) + +export GetSuperclass +GetSuperclass(env::Ptr{JNIEnv}, sub::jclass) = + ccall(Main.JavaCall.jnifunc.GetSuperclass, jclass, (Ptr{JNIEnv}, jclass,), env, sub) + +export IsAssignableFrom +IsAssignableFrom(env::Ptr{JNIEnv}, sub::jclass, sup::jclass) = + ccall(Main.JavaCall.jnifunc.IsAssignableFrom, jboolean, (Ptr{JNIEnv}, jclass, jclass,), env, sub, sup) + +export ToReflectedField +ToReflectedField(env::Ptr{JNIEnv}, cls::jclass, fieldID::jfieldID, isStatic::jboolean) = + ccall(Main.JavaCall.jnifunc.ToReflectedField, jobject, (Ptr{JNIEnv}, jclass, jfieldID, jboolean,), env, cls, fieldID, isStatic) + +export Throw +Throw(env::Ptr{JNIEnv}, obj::jthrowable) = + ccall(Main.JavaCall.jnifunc.Throw, jint, (Ptr{JNIEnv}, jthrowable,), env, obj) + +export ThrowNew +ThrowNew(env::Ptr{JNIEnv}, clazz::jclass, msg::AbstractString) = + ccall(Main.JavaCall.jnifunc.ThrowNew, jint, (Ptr{JNIEnv}, jclass, Cstring,), env, clazz, utf8(msg)) + +export ExceptionOccurred +ExceptionOccurred(env::Ptr{JNIEnv}) = + ccall(Main.JavaCall.jnifunc.ExceptionOccurred, jthrowable, (Ptr{JNIEnv},), env) + +export ExceptionDescribe +ExceptionDescribe(env::Ptr{JNIEnv}) = + ccall(Main.JavaCall.jnifunc.ExceptionDescribe, Void, (Ptr{JNIEnv},), env) + +export ExceptionClear +ExceptionClear(env::Ptr{JNIEnv}) = + ccall(Main.JavaCall.jnifunc.ExceptionClear, Void, (Ptr{JNIEnv},), env) + +export FatalError +FatalError(env::Ptr{JNIEnv}, msg::AbstractString) = + ccall(Main.JavaCall.jnifunc.FatalError, Void, (Ptr{JNIEnv}, Cstring,), env, utf8(msg)) + +export PushLocalFrame +PushLocalFrame(env::Ptr{JNIEnv}, capacity::jint) = + ccall(Main.JavaCall.jnifunc.PushLocalFrame, jint, (Ptr{JNIEnv}, jint,), env, capacity) + +export PopLocalFrame +PopLocalFrame(env::Ptr{JNIEnv}, result::jobject) = + ccall(Main.JavaCall.jnifunc.PopLocalFrame, jobject, (Ptr{JNIEnv}, jobject,), env, result) + +export NewGlobalRef +NewGlobalRef(env::Ptr{JNIEnv}, lobj::jobject) = + ccall(Main.JavaCall.jnifunc.NewGlobalRef, jobject, (Ptr{JNIEnv}, jobject,), env, lobj) + +export DeleteGlobalRef +DeleteGlobalRef(env::Ptr{JNIEnv}, gref::jobject) = + ccall(Main.JavaCall.jnifunc.DeleteGlobalRef, Void, (Ptr{JNIEnv}, jobject,), env, gref) + +export DeleteLocalRef +DeleteLocalRef(env::Ptr{JNIEnv}, obj::jobject) = + ccall(Main.JavaCall.jnifunc.DeleteLocalRef, Void, (Ptr{JNIEnv}, jobject,), env, obj) + +export IsSameObject +IsSameObject(env::Ptr{JNIEnv}, obj1::jobject, obj2::jobject) = + ccall(Main.JavaCall.jnifunc.IsSameObject, jboolean, (Ptr{JNIEnv}, jobject, jobject,), env, obj1, obj2) + +export NewLocalRef +NewLocalRef(env::Ptr{JNIEnv}, ref::jobject) = + ccall(Main.JavaCall.jnifunc.NewLocalRef, jobject, (Ptr{JNIEnv}, jobject,), env, ref) + +export EnsureLocalCapacity +EnsureLocalCapacity(env::Ptr{JNIEnv}, capacity::jint) = + ccall(Main.JavaCall.jnifunc.EnsureLocalCapacity, jint, (Ptr{JNIEnv}, jint,), env, capacity) + +export AllocObject +AllocObject(env::Ptr{JNIEnv}, clazz::jclass) = + ccall(Main.JavaCall.jnifunc.AllocObject, jobject, (Ptr{JNIEnv}, jclass,), env, clazz) + +export NewObjectA +NewObjectA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(Main.JavaCall.jnifunc.NewObjectA, jobject, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) + +export GetObjectClass +GetObjectClass(env::Ptr{JNIEnv}, obj::jobject) = + ccall(Main.JavaCall.jnifunc.GetObjectClass, jclass, (Ptr{JNIEnv}, jobject,), env, obj) + +export IsInstanceOf +IsInstanceOf(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass) = + ccall(Main.JavaCall.jnifunc.IsInstanceOf, jboolean, (Ptr{JNIEnv}, jobject, jclass,), env, obj, clazz) + +export GetMethodID +GetMethodID(env::Ptr{JNIEnv}, clazz::jclass, name::AbstractString, sig::AbstractString) = + ccall(Main.JavaCall.jnifunc.GetMethodID, jmethodID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), env, clazz, utf8(name), utf8(sig)) + +export CallObjectMethodA +CallObjectMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(Main.JavaCall.jnifunc.CallObjectMethodA, jobject, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) + +export CallBooleanMethodA +CallBooleanMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(Main.JavaCall.jnifunc.CallBooleanMethodA, jboolean, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) + +export CallByteMethodA +CallByteMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(Main.JavaCall.jnifunc.CallByteMethodA, jbyte, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) + +export CallCharMethodA +CallCharMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(Main.JavaCall.jnifunc.CallCharMethodA, jchar, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) + +export CallShortMethodA +CallShortMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(Main.JavaCall.jnifunc.CallShortMethodA, jshort, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) + +export CallIntMethodA +CallIntMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(Main.JavaCall.jnifunc.CallIntMethodA, jint, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) + +export CallLongMethodA +CallLongMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(Main.JavaCall.jnifunc.CallLongMethodA, jlong, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) + +export CallFloatMethodA +CallFloatMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(Main.JavaCall.jnifunc.CallFloatMethodA, jfloat, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) + +export CallDoubleMethodA +CallDoubleMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(Main.JavaCall.jnifunc.CallDoubleMethodA, jdouble, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) + +export CallVoidMethodA +CallVoidMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(Main.JavaCall.jnifunc.CallVoidMethodA, Void, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) + +export CallNonvirtualObjectMethodA +CallNonvirtualObjectMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(Main.JavaCall.jnifunc.CallNonvirtualObjectMethodA, jobject, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) + +export CallNonvirtualBooleanMethodA +CallNonvirtualBooleanMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(Main.JavaCall.jnifunc.CallNonvirtualBooleanMethodA, jboolean, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) + +export CallNonvirtualByteMethodA +CallNonvirtualByteMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(Main.JavaCall.jnifunc.CallNonvirtualByteMethodA, jbyte, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) + +export CallNonvirtualCharMethodA +CallNonvirtualCharMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(Main.JavaCall.jnifunc.CallNonvirtualCharMethodA, jchar, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) + +export CallNonvirtualShortMethodA +CallNonvirtualShortMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(Main.JavaCall.jnifunc.CallNonvirtualShortMethodA, jshort, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) + +export CallNonvirtualIntMethodA +CallNonvirtualIntMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(Main.JavaCall.jnifunc.CallNonvirtualIntMethodA, jint, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) + +export CallNonvirtualLongMethodA +CallNonvirtualLongMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(Main.JavaCall.jnifunc.CallNonvirtualLongMethodA, jlong, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) + +export CallNonvirtualFloatMethodA +CallNonvirtualFloatMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(Main.JavaCall.jnifunc.CallNonvirtualFloatMethodA, jfloat, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) + +export CallNonvirtualDoubleMethodA +CallNonvirtualDoubleMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(Main.JavaCall.jnifunc.CallNonvirtualDoubleMethodA, jdouble, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) + +export CallNonvirtualVoidMethodA +CallNonvirtualVoidMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(Main.JavaCall.jnifunc.CallNonvirtualVoidMethodA, Void, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) + +export GetFieldID +GetFieldID(env::Ptr{JNIEnv}, clazz::jclass, name::AbstractString, sig::AbstractString) = + ccall(Main.JavaCall.jnifunc.GetFieldID, jfieldID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), env, clazz, utf8(name), utf8(sig)) + +export GetObjectField +GetObjectField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = + ccall(Main.JavaCall.jnifunc.GetObjectField, jobject, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) + +export GetBooleanField +GetBooleanField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = + ccall(Main.JavaCall.jnifunc.GetBooleanField, jboolean, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) + +export GetByteField +GetByteField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = + ccall(Main.JavaCall.jnifunc.GetByteField, jbyte, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) + +export GetCharField +GetCharField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = + ccall(Main.JavaCall.jnifunc.GetCharField, jchar, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) + +export GetShortField +GetShortField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = + ccall(Main.JavaCall.jnifunc.GetShortField, jshort, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) + +export GetIntField +GetIntField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = + ccall(Main.JavaCall.jnifunc.GetIntField, jint, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) + +export GetLongField +GetLongField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = + ccall(Main.JavaCall.jnifunc.GetLongField, jlong, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) + +export GetFloatField +GetFloatField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = + ccall(Main.JavaCall.jnifunc.GetFloatField, jfloat, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) + +export GetDoubleField +GetDoubleField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = + ccall(Main.JavaCall.jnifunc.GetDoubleField, jdouble, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) + +export SetObjectField +SetObjectField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jobject) = + ccall(Main.JavaCall.jnifunc.SetObjectField, Void, (Ptr{JNIEnv}, jobject, jfieldID, jobject,), env, obj, fieldID, val) + +export SetBooleanField +SetBooleanField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jboolean) = + ccall(Main.JavaCall.jnifunc.SetBooleanField, Void, (Ptr{JNIEnv}, jobject, jfieldID, jboolean,), env, obj, fieldID, val) + +export SetByteField +SetByteField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jbyte) = + ccall(Main.JavaCall.jnifunc.SetByteField, Void, (Ptr{JNIEnv}, jobject, jfieldID, jbyte,), env, obj, fieldID, val) + +export SetCharField +SetCharField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jchar) = + ccall(Main.JavaCall.jnifunc.SetCharField, Void, (Ptr{JNIEnv}, jobject, jfieldID, jchar,), env, obj, fieldID, val) + +export SetShortField +SetShortField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jshort) = + ccall(Main.JavaCall.jnifunc.SetShortField, Void, (Ptr{JNIEnv}, jobject, jfieldID, jshort,), env, obj, fieldID, val) + +export SetIntField +SetIntField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jint) = + ccall(Main.JavaCall.jnifunc.SetIntField, Void, (Ptr{JNIEnv}, jobject, jfieldID, jint,), env, obj, fieldID, val) + +export SetLongField +SetLongField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jlong) = + ccall(Main.JavaCall.jnifunc.SetLongField, Void, (Ptr{JNIEnv}, jobject, jfieldID, jlong,), env, obj, fieldID, val) + +export SetFloatField +SetFloatField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jfloat) = + ccall(Main.JavaCall.jnifunc.SetFloatField, Void, (Ptr{JNIEnv}, jobject, jfieldID, jfloat,), env, obj, fieldID, val) + +export SetDoubleField +SetDoubleField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jdouble) = + ccall(Main.JavaCall.jnifunc.SetDoubleField, Void, (Ptr{JNIEnv}, jobject, jfieldID, jdouble,), env, obj, fieldID, val) + +export GetStaticMethodID +GetStaticMethodID(env::Ptr{JNIEnv}, clazz::jclass, name::AbstractString, sig::AbstractString) = + ccall(Main.JavaCall.jnifunc.GetStaticMethodID, jmethodID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), env, clazz, utf8(name), utf8(sig)) + +export CallStaticObjectMethodA +CallStaticObjectMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(Main.JavaCall.jnifunc.CallStaticObjectMethodA, jobject, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) + +export CallStaticBooleanMethodA +CallStaticBooleanMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(Main.JavaCall.jnifunc.CallStaticBooleanMethodA, jboolean, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) + +export CallStaticByteMethodA +CallStaticByteMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(Main.JavaCall.jnifunc.CallStaticByteMethodA, jbyte, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) + +export CallStaticCharMethodA +CallStaticCharMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(Main.JavaCall.jnifunc.CallStaticCharMethodA, jchar, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) + +export CallStaticShortMethodA +CallStaticShortMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(Main.JavaCall.jnifunc.CallStaticShortMethodA, jshort, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) + +export CallStaticIntMethodA +CallStaticIntMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(Main.JavaCall.jnifunc.CallStaticIntMethodA, jint, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) + +export CallStaticLongMethodA +CallStaticLongMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(Main.JavaCall.jnifunc.CallStaticLongMethodA, jlong, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) + +export CallStaticFloatMethodA +CallStaticFloatMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(Main.JavaCall.jnifunc.CallStaticFloatMethodA, jfloat, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) + +export CallStaticDoubleMethodA +CallStaticDoubleMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(Main.JavaCall.jnifunc.CallStaticDoubleMethodA, jdouble, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) + +export CallStaticVoidMethodA +CallStaticVoidMethodA(env::Ptr{JNIEnv}, cls::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(Main.JavaCall.jnifunc.CallStaticVoidMethodA, Void, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, cls, methodID, args) + +export GetStaticFieldID +GetStaticFieldID(env::Ptr{JNIEnv}, clazz::jclass, name::AbstractString, sig::AbstractString) = + ccall(Main.JavaCall.jnifunc.GetStaticFieldID, jfieldID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), env, clazz, utf8(name), utf8(sig)) + +export GetStaticObjectField +GetStaticObjectField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = + ccall(Main.JavaCall.jnifunc.GetStaticObjectField, jobject, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) + +export GetStaticBooleanField +GetStaticBooleanField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = + ccall(Main.JavaCall.jnifunc.GetStaticBooleanField, jboolean, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) + +export GetStaticByteField +GetStaticByteField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = + ccall(Main.JavaCall.jnifunc.GetStaticByteField, jbyte, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) + +export GetStaticCharField +GetStaticCharField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = + ccall(Main.JavaCall.jnifunc.GetStaticCharField, jchar, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) + +export GetStaticShortField +GetStaticShortField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = + ccall(Main.JavaCall.jnifunc.GetStaticShortField, jshort, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) + +export GetStaticIntField +GetStaticIntField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = + ccall(Main.JavaCall.jnifunc.GetStaticIntField, jint, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) + +export GetStaticLongField +GetStaticLongField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = + ccall(Main.JavaCall.jnifunc.GetStaticLongField, jlong, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) + +export GetStaticFloatField +GetStaticFloatField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = + ccall(Main.JavaCall.jnifunc.GetStaticFloatField, jfloat, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) + +export GetStaticDoubleField +GetStaticDoubleField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = + ccall(Main.JavaCall.jnifunc.GetStaticDoubleField, jdouble, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) + +export SetStaticObjectField +SetStaticObjectField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jobject) = + ccall(Main.JavaCall.jnifunc.SetStaticObjectField, Void, (Ptr{JNIEnv}, jclass, jfieldID, jobject,), env, clazz, fieldID, value) + +export SetStaticBooleanField +SetStaticBooleanField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jboolean) = + ccall(Main.JavaCall.jnifunc.SetStaticBooleanField, Void, (Ptr{JNIEnv}, jclass, jfieldID, jboolean,), env, clazz, fieldID, value) + +export SetStaticByteField +SetStaticByteField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jbyte) = + ccall(Main.JavaCall.jnifunc.SetStaticByteField, Void, (Ptr{JNIEnv}, jclass, jfieldID, jbyte,), env, clazz, fieldID, value) + +export SetStaticCharField +SetStaticCharField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jchar) = + ccall(Main.JavaCall.jnifunc.SetStaticCharField, Void, (Ptr{JNIEnv}, jclass, jfieldID, jchar,), env, clazz, fieldID, value) + +export SetStaticShortField +SetStaticShortField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jshort) = + ccall(Main.JavaCall.jnifunc.SetStaticShortField, Void, (Ptr{JNIEnv}, jclass, jfieldID, jshort,), env, clazz, fieldID, value) + +export SetStaticIntField +SetStaticIntField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jint) = + ccall(Main.JavaCall.jnifunc.SetStaticIntField, Void, (Ptr{JNIEnv}, jclass, jfieldID, jint,), env, clazz, fieldID, value) + +export SetStaticLongField +SetStaticLongField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jlong) = + ccall(Main.JavaCall.jnifunc.SetStaticLongField, Void, (Ptr{JNIEnv}, jclass, jfieldID, jlong,), env, clazz, fieldID, value) + +export SetStaticFloatField +SetStaticFloatField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jfloat) = + ccall(Main.JavaCall.jnifunc.SetStaticFloatField, Void, (Ptr{JNIEnv}, jclass, jfieldID, jfloat,), env, clazz, fieldID, value) + +export SetStaticDoubleField +SetStaticDoubleField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jdouble) = + ccall(Main.JavaCall.jnifunc.SetStaticDoubleField, Void, (Ptr{JNIEnv}, jclass, jfieldID, jdouble,), env, clazz, fieldID, value) + +export NewString +NewString(env::Ptr{JNIEnv}, unicode::Array{jchar,1}, len::Integer) = + ccall(Main.JavaCall.jnifunc.NewString, jstring, (Ptr{JNIEnv}, Ptr{jchar}, jsize,), env, unicode, len) + +export GetStringLength +GetStringLength(env::Ptr{JNIEnv}, str::jstring) = + ccall(Main.JavaCall.jnifunc.GetStringLength, jsize, (Ptr{JNIEnv}, jstring,), env, str) + +export ReleaseStringChars +ReleaseStringChars(env::Ptr{JNIEnv}, str::jstring, chars::Array{jchar,1}) = + ccall(Main.JavaCall.jnifunc.ReleaseStringChars, Void, (Ptr{JNIEnv}, jstring, Ptr{jchar},), env, str, chars) + +export NewStringUTF +NewStringUTF(env::Ptr{JNIEnv}, utf::AbstractString) = + ccall(Main.JavaCall.jnifunc.NewStringUTF, jstring, (Ptr{JNIEnv}, Cstring,), env, utf8(utf)) + +export GetStringUTFLength +GetStringUTFLength(env::Ptr{JNIEnv}, str::jstring) = + ccall(Main.JavaCall.jnifunc.GetStringUTFLength, jsize, (Ptr{JNIEnv}, jstring,), env, str) + +export ReleaseStringUTFChars +ReleaseStringUTFChars(env::Ptr{JNIEnv}, str::jstring, chars::AbstractString) = + ccall(Main.JavaCall.jnifunc.ReleaseStringUTFChars, Void, (Ptr{JNIEnv}, jstring, Cstring,), env, str, utf8(chars)) + +export GetArrayLength +GetArrayLength(env::Ptr{JNIEnv}, array::jarray) = + ccall(Main.JavaCall.jnifunc.GetArrayLength, jsize, (Ptr{JNIEnv}, jarray,), env, array) + +export NewObjectArray +NewObjectArray(env::Ptr{JNIEnv}, len::Integer, clazz::jclass, init::jobject) = + ccall(Main.JavaCall.jnifunc.NewObjectArray, jobjectArray, (Ptr{JNIEnv}, jsize, jclass, jobject,), env, len, clazz, init) + +export GetObjectArrayElement +GetObjectArrayElement(env::Ptr{JNIEnv}, array::jobjectArray, index::Integer) = + ccall(Main.JavaCall.jnifunc.GetObjectArrayElement, jobject, (Ptr{JNIEnv}, jobjectArray, jsize,), env, array, index) + +export SetObjectArrayElement +SetObjectArrayElement(env::Ptr{JNIEnv}, array::jobjectArray, index::Integer, val::jobject) = + ccall(Main.JavaCall.jnifunc.SetObjectArrayElement, Void, (Ptr{JNIEnv}, jobjectArray, jsize, jobject,), env, array, index, val) + +export NewBooleanArray +NewBooleanArray(env::Ptr{JNIEnv}, len::Integer) = + ccall(Main.JavaCall.jnifunc.NewBooleanArray, jbooleanArray, (Ptr{JNIEnv}, jsize,), env, len) + +export NewByteArray +NewByteArray(env::Ptr{JNIEnv}, len::Integer) = + ccall(Main.JavaCall.jnifunc.NewByteArray, jbyteArray, (Ptr{JNIEnv}, jsize,), env, len) + +export NewCharArray +NewCharArray(env::Ptr{JNIEnv}, len::Integer) = + ccall(Main.JavaCall.jnifunc.NewCharArray, jcharArray, (Ptr{JNIEnv}, jsize,), env, len) + +export NewShortArray +NewShortArray(env::Ptr{JNIEnv}, len::Integer) = + ccall(Main.JavaCall.jnifunc.NewShortArray, jshortArray, (Ptr{JNIEnv}, jsize,), env, len) + +export NewIntArray +NewIntArray(env::Ptr{JNIEnv}, len::Integer) = + ccall(Main.JavaCall.jnifunc.NewIntArray, jintArray, (Ptr{JNIEnv}, jsize,), env, len) + +export NewLongArray +NewLongArray(env::Ptr{JNIEnv}, len::Integer) = + ccall(Main.JavaCall.jnifunc.NewLongArray, jlongArray, (Ptr{JNIEnv}, jsize,), env, len) + +export NewFloatArray +NewFloatArray(env::Ptr{JNIEnv}, len::Integer) = + ccall(Main.JavaCall.jnifunc.NewFloatArray, jfloatArray, (Ptr{JNIEnv}, jsize,), env, len) + +export NewDoubleArray +NewDoubleArray(env::Ptr{JNIEnv}, len::Integer) = + ccall(Main.JavaCall.jnifunc.NewDoubleArray, jdoubleArray, (Ptr{JNIEnv}, jsize,), env, len) + +export GetBooleanArrayElements +GetBooleanArrayElements(env::Ptr{JNIEnv}, array::jbooleanArray, isCopy::Array{jboolean,1}) = + ccall(Main.JavaCall.jnifunc.GetBooleanArrayElements, Ptr{jboolean}, (Ptr{JNIEnv}, jbooleanArray, Ptr{jboolean},), env, array, isCopy) + +export GetByteArrayElements +GetByteArrayElements(env::Ptr{JNIEnv}, array::jbyteArray, isCopy::Array{jboolean,1}) = + ccall(Main.JavaCall.jnifunc.GetByteArrayElements, Ptr{jbyte}, (Ptr{JNIEnv}, jbyteArray, Ptr{jboolean},), env, array, isCopy) + +export GetCharArrayElements +GetCharArrayElements(env::Ptr{JNIEnv}, array::jcharArray, isCopy::Array{jboolean,1}) = + ccall(Main.JavaCall.jnifunc.GetCharArrayElements, Ptr{jchar}, (Ptr{JNIEnv}, jcharArray, Ptr{jboolean},), env, array, isCopy) + +export GetShortArrayElements +GetShortArrayElements(env::Ptr{JNIEnv}, array::jshortArray, isCopy::Array{jboolean,1}) = + ccall(Main.JavaCall.jnifunc.GetShortArrayElements, Ptr{jshort}, (Ptr{JNIEnv}, jshortArray, Ptr{jboolean},), env, array, isCopy) + +export GetIntArrayElements +GetIntArrayElements(env::Ptr{JNIEnv}, array::jintArray, isCopy::Array{jboolean,1}) = + ccall(Main.JavaCall.jnifunc.GetIntArrayElements, Ptr{jint}, (Ptr{JNIEnv}, jintArray, Ptr{jboolean},), env, array, isCopy) + +export GetLongArrayElements +GetLongArrayElements(env::Ptr{JNIEnv}, array::jlongArray, isCopy::Array{jboolean,1}) = + ccall(Main.JavaCall.jnifunc.GetLongArrayElements, Ptr{jlong}, (Ptr{JNIEnv}, jlongArray, Ptr{jboolean},), env, array, isCopy) + +export GetFloatArrayElements +GetFloatArrayElements(env::Ptr{JNIEnv}, array::jfloatArray, isCopy::Array{jboolean,1}) = + ccall(Main.JavaCall.jnifunc.GetFloatArrayElements, Ptr{jfloat}, (Ptr{JNIEnv}, jfloatArray, Ptr{jboolean},), env, array, isCopy) + +export GetDoubleArrayElements +GetDoubleArrayElements(env::Ptr{JNIEnv}, array::jdoubleArray, isCopy::Array{jboolean,1}) = + ccall(Main.JavaCall.jnifunc.GetDoubleArrayElements, Ptr{jdouble}, (Ptr{JNIEnv}, jdoubleArray, Ptr{jboolean},), env, array, isCopy) + +export ReleaseBooleanArrayElements +ReleaseBooleanArrayElements(env::Ptr{JNIEnv}, array::jbooleanArray, elems::Array{jboolean,1}, mode::jint) = + ccall(Main.JavaCall.jnifunc.ReleaseBooleanArrayElements, Void, (Ptr{JNIEnv}, jbooleanArray, Ptr{jboolean}, jint,), env, array, elems, mode) + +export ReleaseByteArrayElements +ReleaseByteArrayElements(env::Ptr{JNIEnv}, array::jbyteArray, elems::Array{jbyte,1}, mode::jint) = + ccall(Main.JavaCall.jnifunc.ReleaseByteArrayElements, Void, (Ptr{JNIEnv}, jbyteArray, Ptr{jbyte}, jint,), env, array, elems, mode) + +export ReleaseCharArrayElements +ReleaseCharArrayElements(env::Ptr{JNIEnv}, array::jcharArray, elems::Array{jchar,1}, mode::jint) = + ccall(Main.JavaCall.jnifunc.ReleaseCharArrayElements, Void, (Ptr{JNIEnv}, jcharArray, Ptr{jchar}, jint,), env, array, elems, mode) + +export ReleaseShortArrayElements +ReleaseShortArrayElements(env::Ptr{JNIEnv}, array::jshortArray, elems::Array{jshort,1}, mode::jint) = + ccall(Main.JavaCall.jnifunc.ReleaseShortArrayElements, Void, (Ptr{JNIEnv}, jshortArray, Ptr{jshort}, jint,), env, array, elems, mode) + +export ReleaseIntArrayElements +ReleaseIntArrayElements(env::Ptr{JNIEnv}, array::jintArray, elems::Array{jint,1}, mode::jint) = + ccall(Main.JavaCall.jnifunc.ReleaseIntArrayElements, Void, (Ptr{JNIEnv}, jintArray, Ptr{jint}, jint,), env, array, elems, mode) + +export ReleaseLongArrayElements +ReleaseLongArrayElements(env::Ptr{JNIEnv}, array::jlongArray, elems::Array{jlong,1}, mode::jint) = + ccall(Main.JavaCall.jnifunc.ReleaseLongArrayElements, Void, (Ptr{JNIEnv}, jlongArray, Ptr{jlong}, jint,), env, array, elems, mode) + +export ReleaseFloatArrayElements +ReleaseFloatArrayElements(env::Ptr{JNIEnv}, array::jfloatArray, elems::Array{jfloat,1}, mode::jint) = + ccall(Main.JavaCall.jnifunc.ReleaseFloatArrayElements, Void, (Ptr{JNIEnv}, jfloatArray, Ptr{jfloat}, jint,), env, array, elems, mode) + +export ReleaseDoubleArrayElements +ReleaseDoubleArrayElements(env::Ptr{JNIEnv}, array::jdoubleArray, elems::Array{jdouble,1}, mode::jint) = + ccall(Main.JavaCall.jnifunc.ReleaseDoubleArrayElements, Void, (Ptr{JNIEnv}, jdoubleArray, Ptr{jdouble}, jint,), env, array, elems, mode) + +export GetBooleanArrayRegion +GetBooleanArrayRegion(env::Ptr{JNIEnv}, array::jbooleanArray, start::Integer, l::Integer, buf::Array{jboolean,1}) = + ccall(Main.JavaCall.jnifunc.GetBooleanArrayRegion, Void, (Ptr{JNIEnv}, jbooleanArray, jsize, jsize, Ptr{jboolean},), env, array, start, l, buf) + +export GetByteArrayRegion +GetByteArrayRegion(env::Ptr{JNIEnv}, array::jbyteArray, start::Integer, len::Integer, buf::Array{jbyte,1}) = + ccall(Main.JavaCall.jnifunc.GetByteArrayRegion, Void, (Ptr{JNIEnv}, jbyteArray, jsize, jsize, Ptr{jbyte},), env, array, start, len, buf) + +export GetCharArrayRegion +GetCharArrayRegion(env::Ptr{JNIEnv}, array::jcharArray, start::Integer, len::Integer, buf::Array{jchar,1}) = + ccall(Main.JavaCall.jnifunc.GetCharArrayRegion, Void, (Ptr{JNIEnv}, jcharArray, jsize, jsize, Ptr{jchar},), env, array, start, len, buf) + +export GetShortArrayRegion +GetShortArrayRegion(env::Ptr{JNIEnv}, array::jshortArray, start::Integer, len::Integer, buf::Array{jshort,1}) = + ccall(Main.JavaCall.jnifunc.GetShortArrayRegion, Void, (Ptr{JNIEnv}, jshortArray, jsize, jsize, Ptr{jshort},), env, array, start, len, buf) + +export GetIntArrayRegion +GetIntArrayRegion(env::Ptr{JNIEnv}, array::jintArray, start::Integer, len::Integer, buf::Array{jint,1}) = + ccall(Main.JavaCall.jnifunc.GetIntArrayRegion, Void, (Ptr{JNIEnv}, jintArray, jsize, jsize, Ptr{jint},), env, array, start, len, buf) + +export GetLongArrayRegion +GetLongArrayRegion(env::Ptr{JNIEnv}, array::jlongArray, start::Integer, len::Integer, buf::Array{jlong,1}) = + ccall(Main.JavaCall.jnifunc.GetLongArrayRegion, Void, (Ptr{JNIEnv}, jlongArray, jsize, jsize, Ptr{jlong},), env, array, start, len, buf) + +export GetFloatArrayRegion +GetFloatArrayRegion(env::Ptr{JNIEnv}, array::jfloatArray, start::Integer, len::Integer, buf::Array{jfloat,1}) = + ccall(Main.JavaCall.jnifunc.GetFloatArrayRegion, Void, (Ptr{JNIEnv}, jfloatArray, jsize, jsize, Ptr{jfloat},), env, array, start, len, buf) + +export GetDoubleArrayRegion +GetDoubleArrayRegion(env::Ptr{JNIEnv}, array::jdoubleArray, start::Integer, len::Integer, buf::Array{jdouble,1}) = + ccall(Main.JavaCall.jnifunc.GetDoubleArrayRegion, Void, (Ptr{JNIEnv}, jdoubleArray, jsize, jsize, Ptr{jdouble},), env, array, start, len, buf) + +export SetBooleanArrayRegion +SetBooleanArrayRegion(env::Ptr{JNIEnv}, array::jbooleanArray, start::Integer, l::Integer, buf::Array{jboolean,1}) = + ccall(Main.JavaCall.jnifunc.SetBooleanArrayRegion, Void, (Ptr{JNIEnv}, jbooleanArray, jsize, jsize, Ptr{jboolean},), env, array, start, l, buf) + +export SetByteArrayRegion +SetByteArrayRegion(env::Ptr{JNIEnv}, array::jbyteArray, start::Integer, len::Integer, buf::Array{jbyte,1}) = + ccall(Main.JavaCall.jnifunc.SetByteArrayRegion, Void, (Ptr{JNIEnv}, jbyteArray, jsize, jsize, Ptr{jbyte},), env, array, start, len, buf) + +export SetCharArrayRegion +SetCharArrayRegion(env::Ptr{JNIEnv}, array::jcharArray, start::Integer, len::Integer, buf::Array{jchar,1}) = + ccall(Main.JavaCall.jnifunc.SetCharArrayRegion, Void, (Ptr{JNIEnv}, jcharArray, jsize, jsize, Ptr{jchar},), env, array, start, len, buf) + +export SetShortArrayRegion +SetShortArrayRegion(env::Ptr{JNIEnv}, array::jshortArray, start::Integer, len::Integer, buf::Array{jshort,1}) = + ccall(Main.JavaCall.jnifunc.SetShortArrayRegion, Void, (Ptr{JNIEnv}, jshortArray, jsize, jsize, Ptr{jshort},), env, array, start, len, buf) + +export SetIntArrayRegion +SetIntArrayRegion(env::Ptr{JNIEnv}, array::jintArray, start::Integer, len::Integer, buf::Array{jint,1}) = + ccall(Main.JavaCall.jnifunc.SetIntArrayRegion, Void, (Ptr{JNIEnv}, jintArray, jsize, jsize, Ptr{jint},), env, array, start, len, buf) + +export SetLongArrayRegion +SetLongArrayRegion(env::Ptr{JNIEnv}, array::jlongArray, start::Integer, len::Integer, buf::Array{jlong,1}) = + ccall(Main.JavaCall.jnifunc.SetLongArrayRegion, Void, (Ptr{JNIEnv}, jlongArray, jsize, jsize, Ptr{jlong},), env, array, start, len, buf) + +export SetFloatArrayRegion +SetFloatArrayRegion(env::Ptr{JNIEnv}, array::jfloatArray, start::Integer, len::Integer, buf::Array{jfloat,1}) = + ccall(Main.JavaCall.jnifunc.SetFloatArrayRegion, Void, (Ptr{JNIEnv}, jfloatArray, jsize, jsize, Ptr{jfloat},), env, array, start, len, buf) + +export SetDoubleArrayRegion +SetDoubleArrayRegion(env::Ptr{JNIEnv}, array::jdoubleArray, start::Integer, len::Integer, buf::Array{jdouble,1}) = + ccall(Main.JavaCall.jnifunc.SetDoubleArrayRegion, Void, (Ptr{JNIEnv}, jdoubleArray, jsize, jsize, Ptr{jdouble},), env, array, start, len, buf) + +export RegisterNatives +RegisterNatives(env::Ptr{JNIEnv}, clazz::jclass, methods::Array{JNINativeMethod,1}, nMethods::jint) = + ccall(Main.JavaCall.jnifunc.RegisterNatives, jint, (Ptr{JNIEnv}, jclass, Ptr{JNINativeMethod}, jint,), env, clazz, methods, nMethods) + +export UnregisterNatives +UnregisterNatives(env::Ptr{JNIEnv}, clazz::jclass) = + ccall(Main.JavaCall.jnifunc.UnregisterNatives, jint, (Ptr{JNIEnv}, jclass,), env, clazz) + +export MonitorEnter +MonitorEnter(env::Ptr{JNIEnv}, obj::jobject) = + ccall(Main.JavaCall.jnifunc.MonitorEnter, jint, (Ptr{JNIEnv}, jobject,), env, obj) + +export MonitorExit +MonitorExit(env::Ptr{JNIEnv}, obj::jobject) = + ccall(Main.JavaCall.jnifunc.MonitorExit, jint, (Ptr{JNIEnv}, jobject,), env, obj) + +export GetJavaVM +GetJavaVM(env::Ptr{JNIEnv}, vm::Array{JavaVM,1}) = + ccall(Main.JavaCall.jnifunc.GetJavaVM, jint, (Ptr{JNIEnv}, Array{JavaVM,1},), env, vm) + +export GetStringRegion +GetStringRegion(env::Ptr{JNIEnv}, str::jstring, start::Integer, len::Integer, buf::Array{jchar,1}) = + ccall(Main.JavaCall.jnifunc.GetStringRegion, Void, (Ptr{JNIEnv}, jstring, jsize, jsize, Ptr{jchar},), env, str, start, len, buf) + +export GetStringUTFRegion +GetStringUTFRegion(env::Ptr{JNIEnv}, str::jstring, start::Integer, len::Integer, buf::AbstractString) = + ccall(Main.JavaCall.jnifunc.GetStringUTFRegion, Void, (Ptr{JNIEnv}, jstring, jsize, jsize, Cstring,), env, str, start, len, utf8(buf)) + +export GetPrimitiveArrayCritical +GetPrimitiveArrayCritical(env::Ptr{JNIEnv}, array::jarray, isCopy::Array{jboolean,1}) = + ccall(Main.JavaCall.jnifunc.GetPrimitiveArrayCritical, Ptr{Void}, (Ptr{JNIEnv}, jarray, Ptr{jboolean},), env, array, isCopy) + +export ReleasePrimitiveArrayCritical +ReleasePrimitiveArrayCritical(env::Ptr{JNIEnv}, array::jarray, carray::Ptr{Void}, mode::jint) = + ccall(Main.JavaCall.jnifunc.ReleasePrimitiveArrayCritical, Void, (Ptr{JNIEnv}, jarray, Ptr{Void}, jint,), env, array, carray, mode) + +export ReleaseStringCritical +ReleaseStringCritical(env::Ptr{JNIEnv}, string::jstring, cstring::Array{jchar,1}) = + ccall(Main.JavaCall.jnifunc.ReleaseStringCritical, Void, (Ptr{JNIEnv}, jstring, Ptr{jchar},), env, string, cstring) + +export NewWeakGlobalRef +NewWeakGlobalRef(env::Ptr{JNIEnv}, obj::jobject) = + ccall(Main.JavaCall.jnifunc.NewWeakGlobalRef, jweak, (Ptr{JNIEnv}, jobject,), env, obj) + +export DeleteWeakGlobalRef +DeleteWeakGlobalRef(env::Ptr{JNIEnv}, ref::jweak) = + ccall(Main.JavaCall.jnifunc.DeleteWeakGlobalRef, Void, (Ptr{JNIEnv}, jweak,), env, ref) + +export ExceptionCheck +ExceptionCheck(env::Ptr{JNIEnv}) = + ccall(Main.JavaCall.jnifunc.ExceptionCheck, jboolean, (Ptr{JNIEnv},), env) + +export NewDirectByteBuffer +NewDirectByteBuffer(env::Ptr{JNIEnv}, address::Ptr{Void}, capacity::jlong) = + ccall(Main.JavaCall.jnifunc.NewDirectByteBuffer, jobject, (Ptr{JNIEnv}, Ptr{Void}, jlong,), env, address, capacity) + +export GetDirectBufferAddress +GetDirectBufferAddress(env::Ptr{JNIEnv}, buf::jobject) = + ccall(Main.JavaCall.jnifunc.GetDirectBufferAddress, Ptr{Void}, (Ptr{JNIEnv}, jobject,), env, buf) + +export GetDirectBufferCapacity +GetDirectBufferCapacity(env::Ptr{JNIEnv}, buf::jobject) = + ccall(Main.JavaCall.jnifunc.GetDirectBufferCapacity, jlong, (Ptr{JNIEnv}, jobject,), env, buf) + +export GetObjectRefType +GetObjectRefType(env::Ptr{JNIEnv}, obj::jobject) = + ccall(Main.JavaCall.jnifunc.GetObjectRefType, jobjectRefType, (Ptr{JNIEnv}, jobject,), env, obj) + +end diff --git a/src/make_jni2.jl b/src/make_jni2.jl new file mode 100644 index 0000000..6f3d104 --- /dev/null +++ b/src/make_jni2.jl @@ -0,0 +1,88 @@ +println("module JNI") +println("import ..JavaCall: JNIEnv, JavaVM, jbyte, jchar, jshort, jint, jlong, jsize, jdouble, jfloat, jboolean") +for t in ["jobject", "jclass", "jthrowable", "jweak", "jmethodID", "jfieldID", "jvalue", "jstring", "jarray", "JNINativeMethod"] +println("typealias $t Ptr{Void}") +end +for t in ["object", "boolean", "byte", "short", "int", "long", "float", "double", "char"] +println("typealias j$(t)Array Ptr{Void}") +end +println() + +function arg_name(m) + m.captures[3] +end + +function arg_value(m) + if m.captures[2] == "*" && m.captures[1] == "char" return "utf8($(m.captures[3]))" end + m.captures[3] +end + +decl_arg_type(m) = decl_arg_type(m.captures[1], m.captures[2]) +ccall_arg_type(m; r=false) = ccall_arg_type(m.captures[1], m.captures[2], r=r) + +function decl_arg_type(t, s) + if s == "*" + if t == "char" + return "AbstractString" + elseif t == "void" + return "Ptr{Void}" + elseif t == "JNIEnv" + return "Ptr{JNIEnv}" + else + return "Array{$t,1}" + end + elseif t == "jsize" #|| t == "jint" || t == "jlong" || t == "jshort" || t == "jbyte" + return Integer + end + + if t == "void" + return "Void" + end + + return s == "" ? t : "Array{$t,1}" +end + +function ccall_arg_type(t, s; r=false) + if s == "*" + if t == "char" + return "Cstring" + elseif t == "void" + return "Ptr{Void}" + elseif t == "JNIEnv" + return "Ptr{JNIEnv}" + else + return "Ptr{$t}" + end + end + + if t == "void" + return "Void" + end + + return s == "" ? t : r ? "Ptr{$t}" : "Array{$t,1}" +end + +julia_arg(m) = string(arg_name(m), "::", decl_arg_type(m)) + +for line in open(readlines, "jnienv.jl", "r") + m = match(r"\# \s* ((?:void|j\w+)) \s* (\**) \s* \( \s* \* (\w+) \s* \) \s* \((.*)\) \s* ;"x, line) + if m === nothing continue end + + if contains(m.captures[4], "...") continue end + if contains(m.captures[4], "va_list") continue end + + rtype = ccall_arg_type(m.captures[1], m.captures[2], r=true) + + fname = m.captures[3] + args = split(m.captures[4], ",") + mm = map(x->match(r"^\s* (?:const\s+)? \s* ((?:void|j\w+|char|JNI\w+|JavaVM)) \s*? (\**) \s* (\w+) \s*$"x, x), args) + + julia_args = join(map(julia_arg, mm), ", ") + arg_types = join(map(ccall_arg_type, mm), ", ") + arg_names = join(map(arg_value, mm), ", ") + + print("export $fname\n") + print("$fname($julia_args) =\n ccall(Main.JavaCall.jnifunc.$(fname), $rtype, ($arg_types,), $arg_names)\n\n") +end + +println("end") From 3c383bfc5669ea51fcc98ee60e5c2d2117ea6b5a Mon Sep 17 00:00:00 2001 From: Adam Brewster Date: Sat, 2 Jan 2016 19:27:36 -0500 Subject: [PATCH 03/18] use new methods --- src/convert.jl | 4 ++-- src/core.jl | 31 ++++++++++++++++--------------- 2 files changed, 18 insertions(+), 17 deletions(-) diff --git a/src/convert.jl b/src/convert.jl index 10a7887..5ed1491 100644 --- a/src/convert.jl +++ b/src/convert.jl @@ -15,8 +15,8 @@ function convert{T,S}(::Type{JavaObject{T}}, obj::JavaObject{S}) end #Is java type convertible from S to T. -isConvertible(T, S) = (ccall(jnifunc.IsAssignableFrom, jboolean, (Ptr{JNIEnv}, Ptr{Void}, Ptr{Void}), penv, metaclass(S), metaclass(T) ) == JNI_TRUE) -isConvertible(T, S::Ptr{Void} ) = (ccall(jnifunc.IsAssignableFrom, jboolean, (Ptr{JNIEnv}, Ptr{Void}, Ptr{Void}), penv, S, metaclass(T) ) == JNI_TRUE) +isConvertible(T, S) = (ccall(jnifunc.IsAssignableFrom, jboolean, (Ptr{JNIEnv}, Ptr{Void}, Ptr{Void}), penv, metaclass(S).ptr, metaclass(T).ptr ) == JNI_TRUE) +isConvertible(T, S::Ptr{Void} ) = (ccall(jnifunc.IsAssignableFrom, jboolean, (Ptr{JNIEnv}, Ptr{Void}, Ptr{Void}), penv, S, metaclass(T).ptr ) == JNI_TRUE) unsafe_convert(::Type{Ptr{Void}}, cls::JavaMetaClass) = cls.ptr diff --git a/src/core.jl b/src/core.jl index 1bc079f..23c8310 100644 --- a/src/core.jl +++ b/src/core.jl @@ -25,12 +25,13 @@ function deleteref(x::JavaObject) if x.ptr == C_NULL; return; end if (penv==C_NULL); return; end #ccall(:jl_,Void,(Any,),x) - ccall(jnifunc.DeleteLocalRef, Void, (Ptr{JNIEnv}, Ptr{Void}), penv, x.ptr) + DeleteLocalRef(penv, x.ptr) x.ptr=C_NULL #Safety in case this function is called direcly, rather than at finalize return end +isnull(obj::Ptr{Void}) = obj == C_NULL isnull(obj::JavaObject) = obj.ptr == C_NULL isnull(obj::JavaMetaClass) = obj.ptr == C_NULL @@ -40,7 +41,7 @@ typealias JMethod JavaObject{symbol("java.lang.reflect.Method")} typealias JString JavaObject{symbol("java.lang.String")} function JString(str::AbstractString) - jstring = ccall(jnifunc.NewStringUTF, Ptr{Void}, (Ptr{JNIEnv}, Ptr{UInt8}), penv, utf8(str)) + jstring = NewStringUTF(penv, utf8(str)) if jstring == C_NULL geterror() else @@ -74,7 +75,7 @@ end function jnew(T::Symbol, argtypes::Tuple, args...) sig = method_signature(Void, argtypes...) - jmethodId = ccall(jnifunc.GetMethodID, Ptr{Void}, (Ptr{JNIEnv}, Ptr{Void}, Ptr{UInt8}, Ptr{UInt8}), penv, metaclass(T), utf8(""), sig) + jmethodId = GetMethodID(penv, metaclass(T).ptr, utf8(""), sig) if (jmethodId == C_NULL) error("No constructor for $T with signature $sig") end @@ -87,7 +88,7 @@ function jcall{T}(typ::Type{JavaObject{T}}, method::AbstractString, rettype::Typ gc_enable(false) sig = method_signature(rettype, argtypes...) - jmethodId = ccall(jnifunc.GetStaticMethodID, Ptr{Void}, (Ptr{JNIEnv}, Ptr{Void}, Ptr{UInt8}, Ptr{UInt8}), penv, metaclass(T), utf8(method), sig) + jmethodId = GetStaticMethodID(penv, metaclass(T).ptr, utf8(method), sig) if jmethodId==C_NULL; geterror(true); end _jcall(metaclass(T), jmethodId, C_NULL, rettype, argtypes, args...) @@ -102,7 +103,7 @@ function jcall(obj::JavaObject, method::AbstractString, rettype::Type, argtypes: try gc_enable(false) sig = method_signature(rettype, argtypes...) - jmethodId = ccall(jnifunc.GetMethodID, Ptr{Void}, (Ptr{JNIEnv}, Ptr{Void}, Ptr{UInt8}, Ptr{UInt8}), penv, metaclass(obj), utf8(method), sig) + jmethodId = GetMethodID(penv, metaclass(obj).ptr, utf8(method), sig) if jmethodId==C_NULL; geterror(true); end _jcall(obj, jmethodId, C_NULL, rettype, argtypes, args...) finally @@ -111,13 +112,13 @@ function jcall(obj::JavaObject, method::AbstractString, rettype::Type, argtypes: end function jfield{T}(typ::Type{JavaObject{T}}, field::AbstractString, fieldType::Type) - jfieldID = ccall(jnifunc.GetStaticFieldID, Ptr{Void}, (Ptr{JNIEnv}, Ptr{Void}, Ptr{UInt8}, Ptr{UInt8}), penv, metaclass(T), utf8(field), signature(fieldType)) + jfieldID = GetStaticFieldID(penv, metaclass(T).ptr, utf8(field), signature(fieldType)) if jfieldID==C_NULL; geterror(true); end _jfield(metaclass(T), jfieldID, fieldType) end function jfield(obj::JavaObject, field::AbstractString, fieldType::Type) - jfieldID = ccall(jnifunc.GetFieldID, Ptr{Void}, (Ptr{JNIEnv}, Ptr{Void}, Ptr{UInt8}, Ptr{UInt8}), penv, metaclass(obj), utf8(field), signature(fieldType)) + jfieldID = GetFieldID(penv, metaclass(obj).ptr, utf8(field), signature(fieldType)) if jfieldID==C_NULL; geterror(true); end _jfield(obj, jfieldID, fieldType) end @@ -208,21 +209,21 @@ metaclass{T}(::JavaObject{T}) = metaclass(T) javaclassname(class::Symbol) = utf8(replace(string(class), '.', '/')) function geterror(allow=false) - isexception = ccall(jnifunc.ExceptionCheck, jboolean, (Ptr{JNIEnv},), penv ) + isexception = ExceptionCheck(penv) if isexception == JNI_TRUE - jthrow = ccall(jnifunc.ExceptionOccurred, Ptr{Void}, (Ptr{JNIEnv},), penv) + jthrow = ExceptionOccurred(penv) if jthrow==C_NULL ; error("Java Exception thrown, but no details could be retrieved from the JVM"); end - ccall(jnifunc.ExceptionDescribe, Void, (Ptr{JNIEnv},), penv ) #Print java stackstrace to stdout - ccall(jnifunc.ExceptionClear, Void, (Ptr{JNIEnv},), penv ) - jclass = ccall(jnifunc.FindClass, Ptr{Void}, (Ptr{JNIEnv},Ptr{UInt8}), penv, "java/lang/Throwable") + ExceptionDescribe(penv ) #Print java stackstrace to stdout + ExceptionClear(penv ) + jclass = FindClass(penv, "java/lang/Throwable") if jclass==C_NULL; error("Java Exception thrown, but no details could be retrieved from the JVM"); end - jmethodId=ccall(jnifunc.GetMethodID, Ptr{Void}, (Ptr{JNIEnv}, Ptr{Void}, Ptr{UInt8}, Ptr{UInt8}), penv, jclass, "toString", "()Ljava/lang/String;") + jmethodId=GetMethodID(penv, jclass, "toString", "()Ljava/lang/String;") if jmethodId==C_NULL; error("Java Exception thrown, but no details could be retrieved from the JVM"); end - res = ccall(jnifunc.CallObjectMethodA, Ptr{Void}, (Ptr{JNIEnv}, Ptr{Void}, Ptr{Void}, Ptr{Void}), penv, jthrow, jmethodId,C_NULL) + res = CallObjectMethodA(penv, jthrow, jmethodId,C_NULL) if res==C_NULL; error("Java Exception thrown, but no details could be retrieved from the JVM"); end msg = bytestring(JString(res)) - ccall(jnifunc.DeleteLocalRef, Void, (Ptr{JNIEnv}, Ptr{Void}), penv, jthrow) + DeleteLocalRef(penv, jthrow) error(string("Error calling Java: ",msg)) else if allow==false From b12da1263086d2cd83e543c6e222ef9ba0505e97 Mon Sep 17 00:00:00 2001 From: Adam Brewster Date: Sat, 2 Jan 2016 20:34:18 -0500 Subject: [PATCH 04/18] Fix tests --- src/core.jl | 2 +- src/jnienv2.jl | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/core.jl b/src/core.jl index 23c8310..bbad4b9 100644 --- a/src/core.jl +++ b/src/core.jl @@ -220,7 +220,7 @@ function geterror(allow=false) if jclass==C_NULL; error("Java Exception thrown, but no details could be retrieved from the JVM"); end jmethodId=GetMethodID(penv, jclass, "toString", "()Ljava/lang/String;") if jmethodId==C_NULL; error("Java Exception thrown, but no details could be retrieved from the JVM"); end - res = CallObjectMethodA(penv, jthrow, jmethodId,C_NULL) + res = CallObjectMethodA(penv, jthrow, jmethodId, Int[]) if res==C_NULL; error("Java Exception thrown, but no details could be retrieved from the JVM"); end msg = bytestring(JString(res)) DeleteLocalRef(penv, jthrow) diff --git a/src/jnienv2.jl b/src/jnienv2.jl index 33dd55d..b0603d6 100644 --- a/src/jnienv2.jl +++ b/src/jnienv2.jl @@ -6,7 +6,7 @@ typealias jthrowable Ptr{Void} typealias jweak Ptr{Void} typealias jmethodID Ptr{Void} typealias jfieldID Ptr{Void} -typealias jvalue Ptr{Void} +typealias jvalue Int typealias jstring Ptr{Void} typealias jarray Ptr{Void} typealias JNINativeMethod Ptr{Void} From 9d83c8eb2639706d955f775e089a4625847a8499 Mon Sep 17 00:00:00 2001 From: Adam Brewster Date: Sat, 2 Jan 2016 20:50:49 -0500 Subject: [PATCH 05/18] fix const char* return values in make_jni2 --- src/jnienv2.jl | 14 +++++++++++++- src/make_jni2.jl | 5 +++-- 2 files changed, 16 insertions(+), 3 deletions(-) diff --git a/src/jnienv2.jl b/src/jnienv2.jl index b0603d6..1d848f9 100644 --- a/src/jnienv2.jl +++ b/src/jnienv2.jl @@ -6,7 +6,6 @@ typealias jthrowable Ptr{Void} typealias jweak Ptr{Void} typealias jmethodID Ptr{Void} typealias jfieldID Ptr{Void} -typealias jvalue Int typealias jstring Ptr{Void} typealias jarray Ptr{Void} typealias JNINativeMethod Ptr{Void} @@ -19,6 +18,7 @@ typealias jlongArray Ptr{Void} typealias jfloatArray Ptr{Void} typealias jdoubleArray Ptr{Void} typealias jcharArray Ptr{Void} +typealias jvalue Int64 export GetVersion GetVersion(env::Ptr{JNIEnv}) = @@ -416,6 +416,10 @@ export GetStringLength GetStringLength(env::Ptr{JNIEnv}, str::jstring) = ccall(Main.JavaCall.jnifunc.GetStringLength, jsize, (Ptr{JNIEnv}, jstring,), env, str) +export GetStringChars +GetStringChars(env::Ptr{JNIEnv}, str::jstring, isCopy::Array{jboolean,1}) = + ccall(Main.JavaCall.jnifunc.GetStringChars, Ptr{jchar}, (Ptr{JNIEnv}, jstring, Ptr{jboolean},), env, str, isCopy) + export ReleaseStringChars ReleaseStringChars(env::Ptr{JNIEnv}, str::jstring, chars::Array{jchar,1}) = ccall(Main.JavaCall.jnifunc.ReleaseStringChars, Void, (Ptr{JNIEnv}, jstring, Ptr{jchar},), env, str, chars) @@ -428,6 +432,10 @@ export GetStringUTFLength GetStringUTFLength(env::Ptr{JNIEnv}, str::jstring) = ccall(Main.JavaCall.jnifunc.GetStringUTFLength, jsize, (Ptr{JNIEnv}, jstring,), env, str) +export GetStringUTFChars +GetStringUTFChars(env::Ptr{JNIEnv}, str::jstring, isCopy::Array{jboolean,1}) = + ccall(Main.JavaCall.jnifunc.GetStringUTFChars, Cstring, (Ptr{JNIEnv}, jstring, Ptr{jboolean},), env, str, isCopy) + export ReleaseStringUTFChars ReleaseStringUTFChars(env::Ptr{JNIEnv}, str::jstring, chars::AbstractString) = ccall(Main.JavaCall.jnifunc.ReleaseStringUTFChars, Void, (Ptr{JNIEnv}, jstring, Cstring,), env, str, utf8(chars)) @@ -644,6 +652,10 @@ export ReleasePrimitiveArrayCritical ReleasePrimitiveArrayCritical(env::Ptr{JNIEnv}, array::jarray, carray::Ptr{Void}, mode::jint) = ccall(Main.JavaCall.jnifunc.ReleasePrimitiveArrayCritical, Void, (Ptr{JNIEnv}, jarray, Ptr{Void}, jint,), env, array, carray, mode) +export GetStringCritical +GetStringCritical(env::Ptr{JNIEnv}, string::jstring, isCopy::Array{jboolean,1}) = + ccall(Main.JavaCall.jnifunc.GetStringCritical, Ptr{jchar}, (Ptr{JNIEnv}, jstring, Ptr{jboolean},), env, string, isCopy) + export ReleaseStringCritical ReleaseStringCritical(env::Ptr{JNIEnv}, string::jstring, cstring::Array{jchar,1}) = ccall(Main.JavaCall.jnifunc.ReleaseStringCritical, Void, (Ptr{JNIEnv}, jstring, Ptr{jchar},), env, string, cstring) diff --git a/src/make_jni2.jl b/src/make_jni2.jl index 6f3d104..7ecb3de 100644 --- a/src/make_jni2.jl +++ b/src/make_jni2.jl @@ -1,11 +1,12 @@ println("module JNI") println("import ..JavaCall: JNIEnv, JavaVM, jbyte, jchar, jshort, jint, jlong, jsize, jdouble, jfloat, jboolean") -for t in ["jobject", "jclass", "jthrowable", "jweak", "jmethodID", "jfieldID", "jvalue", "jstring", "jarray", "JNINativeMethod"] +for t in ["jobject", "jclass", "jthrowable", "jweak", "jmethodID", "jfieldID", "jstring", "jarray", "JNINativeMethod"] println("typealias $t Ptr{Void}") end for t in ["object", "boolean", "byte", "short", "int", "long", "float", "double", "char"] println("typealias j$(t)Array Ptr{Void}") end +println("typealias jvalue Int64") println() function arg_name(m) @@ -65,7 +66,7 @@ end julia_arg(m) = string(arg_name(m), "::", decl_arg_type(m)) for line in open(readlines, "jnienv.jl", "r") - m = match(r"\# \s* ((?:void|j\w+)) \s* (\**) \s* \( \s* \* (\w+) \s* \) \s* \((.*)\) \s* ;"x, line) + m = match(r"\# \s* (?:const\s*)? ((?:void|char|j\w+)) \s* (\**) \s* \( \s* \* (\w+) \s* \) \s* \((.*)\) \s* ;"x, line) if m === nothing continue end if contains(m.captures[4], "...") continue end From 9a406ac38a48c55552b142b0000ab4a7ac291b3f Mon Sep 17 00:00:00 2001 From: Adam Brewster Date: Sat, 2 Jan 2016 20:51:53 -0500 Subject: [PATCH 06/18] ReleaseSrtingUTFChars is a special case, it needs the same pointr JNI passes us instead of some string that we're providing. All of the ReleaseX methods probably need similar treatment. --- src/jnienv2.jl | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/jnienv2.jl b/src/jnienv2.jl index 1d848f9..5efb6d3 100644 --- a/src/jnienv2.jl +++ b/src/jnienv2.jl @@ -437,8 +437,8 @@ GetStringUTFChars(env::Ptr{JNIEnv}, str::jstring, isCopy::Array{jboolean,1}) = ccall(Main.JavaCall.jnifunc.GetStringUTFChars, Cstring, (Ptr{JNIEnv}, jstring, Ptr{jboolean},), env, str, isCopy) export ReleaseStringUTFChars -ReleaseStringUTFChars(env::Ptr{JNIEnv}, str::jstring, chars::AbstractString) = - ccall(Main.JavaCall.jnifunc.ReleaseStringUTFChars, Void, (Ptr{JNIEnv}, jstring, Cstring,), env, str, utf8(chars)) +ReleaseStringUTFChars(env::Ptr{JNIEnv}, str::jstring, chars::Ptr{UInt8}) = + ccall(Main.JavaCall.jnifunc.ReleaseStringUTFChars, Void, (Ptr{JNIEnv}, jstring, Ptr{UInt8},), env, str, chars) export GetArrayLength GetArrayLength(env::Ptr{JNIEnv}, array::jarray) = From 5e892e2af85e7796f53086bf25c0ca1e9cc48570 Mon Sep 17 00:00:00 2001 From: Adam Brewster Date: Sat, 2 Jan 2016 20:52:07 -0500 Subject: [PATCH 07/18] Use new methods in convert.jl --- src/convert.jl | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/src/convert.jl b/src/convert.jl index 5ed1491..c671e86 100644 --- a/src/convert.jl +++ b/src/convert.jl @@ -7,7 +7,7 @@ function convert{T,S}(::Type{JavaObject{T}}, obj::JavaObject{S}) return JavaObject{T}(obj.ptr) end if isnull(obj) ; error("Cannot convert NULL"); end - realClass = ccall(jnifunc.GetObjectClass, Ptr{Void}, (Ptr{JNIEnv}, Ptr{Void} ), penv, obj.ptr) + realClass = GetObjectClass(penv, obj.ptr) if isConvertible(T, realClass) #dynamic cast return JavaObject{T}(obj.ptr) end @@ -15,8 +15,8 @@ function convert{T,S}(::Type{JavaObject{T}}, obj::JavaObject{S}) end #Is java type convertible from S to T. -isConvertible(T, S) = (ccall(jnifunc.IsAssignableFrom, jboolean, (Ptr{JNIEnv}, Ptr{Void}, Ptr{Void}), penv, metaclass(S).ptr, metaclass(T).ptr ) == JNI_TRUE) -isConvertible(T, S::Ptr{Void} ) = (ccall(jnifunc.IsAssignableFrom, jboolean, (Ptr{JNIEnv}, Ptr{Void}, Ptr{Void}), penv, S, metaclass(T).ptr ) == JNI_TRUE) +isConvertible(T, S) = IsAssignableFrom(penv, metaclass(S).ptr, metaclass(T).ptr) == JNI_TRUE +isConvertible(T, S::Ptr{Void} ) = IsAssignableFrom(penv, S, metaclass(T).ptr) == JNI_TRUE unsafe_convert(::Type{Ptr{Void}}, cls::JavaMetaClass) = cls.ptr @@ -80,9 +80,9 @@ function convert_arg{T<:JavaObject}(argtype::Type{Array{T,1}}, arg) carg = convert(argtype, arg) sz=length(carg) init=carg[1] - arrayptr = ccall(jnifunc.NewObjectArray, Ptr{Void}, (Ptr{JNIEnv}, jint, Ptr{Void}, Ptr{Void}), penv, sz, metaclass(T), init.ptr) + arrayptr = NewObjectArray(penv, sz, metaclass(T).ptr, init.ptr) for i=2:sz - ccall(jnifunc.SetObjectArrayElement, Void, (Ptr{JNIEnv}, Ptr{Void}, jint, Ptr{Void}), penv, arrayptr, i-1, carg[i].ptr) + SetObjectArrayElement(penv, arrayptr, i-1, carg[i].ptr) end return carg, arrayptr end @@ -101,7 +101,7 @@ for (x, y, z) in [ (:jboolean, :(jnifunc.GetBooleanArrayElements), :(jnifunc.Rel (:jdouble, :(jnifunc.GetDoubleArrayElements), :(jnifunc.ReleaseDoubleArrayElements)) ] m=quote function convert_result(rettype::Type{Array{$(x),1}}, result) - sz = ccall(jnifunc.GetArrayLength, jint, (Ptr{JNIEnv}, Ptr{Void}), penv, result) + sz = GetArrayLength(penv, result) arr = ccall($(y), Ptr{$(x)}, (Ptr{JNIEnv}, Ptr{Void}, Ptr{jboolean} ), penv, result, C_NULL ) jl_arr::Array = pointer_to_array(arr, (@compat Int(sz)), false) jl_arr = deepcopy(jl_arr) @@ -113,12 +113,12 @@ for (x, y, z) in [ (:jboolean, :(jnifunc.GetBooleanArrayElements), :(jnifunc.Rel end function convert_result{T}(rettype::Type{Array{JavaObject{T},1}}, result) - sz = ccall(jnifunc.GetArrayLength, jint, (Ptr{JNIEnv}, Ptr{Void}), penv, result) + sz = GetArrayLength(penv, result) ret = Array(JavaObject{T}, sz) for i=1:sz - a=ccall(jnifunc.GetObjectArrayElement, Ptr{Void}, (Ptr{JNIEnv},Ptr{Void}, jint), penv, result, i-1) + a=GetObjectArrayElement(penv, result, i-1) ret[i] = JavaObject{T}(a) end return ret @@ -164,8 +164,8 @@ convert{X,Y}(::Type{@jimport(java.util.Map)}, K::Type{JavaObject{X}}, V::Type{Ja function bytestring(jstr::JString) #jstr must be a jstring obtained via a JNI call if isnull(jstr); return ""; end #Return empty string to keep type stability. But this is questionable pIsCopy = Array(jboolean, 1) - buf::Ptr{UInt8} = ccall(jnifunc.GetStringUTFChars, Ptr{UInt8}, (Ptr{JNIEnv}, Ptr{Void}, Ptr{jboolean}), penv, jstr.ptr, pIsCopy) + buf::Ptr{UInt8} = GetStringUTFChars(penv, jstr.ptr, pIsCopy) s=bytestring(buf) - ccall(jnifunc.ReleaseStringUTFChars, Void, (Ptr{JNIEnv}, Ptr{Void}, Ptr{UInt8}), penv, jstr.ptr, buf) + ReleaseStringUTFChars(penv, jstr.ptr, buf) return s end From 5ba60abe144b4ca31746893591e157a6d028c91c Mon Sep 17 00:00:00 2001 From: "markkitt@gmail.com" Date: Sat, 2 May 2020 00:44:33 -0500 Subject: [PATCH 08/18] Modernize @adambrewster jni-methods PR branch --- src/JavaCall.jl | 4 +- src/convert.jl | 5 +- src/core.jl | 24 +----- src/jnienv.jl | 17 ---- src/jnienv2.jl | 199 +++++++++++++++++++++++++++-------------------- src/make_jni2.jl | 18 ++--- 6 files changed, 130 insertions(+), 137 deletions(-) diff --git a/src/JavaCall.jl b/src/JavaCall.jl index ced7326..3eac0d0 100644 --- a/src/JavaCall.jl +++ b/src/JavaCall.jl @@ -23,11 +23,9 @@ import Base: convert, unsafe_convert, unsafe_string JULIA_COPY_STACKS = false -include("jnienv.jl") -include("jvm.jl") include("jnienv2.jl") using .JNI - +include("jvm.jl") include("core.jl") include("convert.jl") include("reflect.jl") diff --git a/src/convert.jl b/src/convert.jl index 3350605..38320f7 100644 --- a/src/convert.jl +++ b/src/convert.jl @@ -18,8 +18,9 @@ function convert(::Type{JavaObject{T}}, obj::JavaObject{S}) where {T,S} throw(JavaCallError("Cannot cast java object from $S to $T")) end +#Is java type convertible from S to T. isConvertible(T, S) = IsAssignableFrom(penv, metaclass(S).ptr, metaclass(T).ptr) == JNI_TRUE -isConvertible(T, S::Ptr{Void} ) = IsAssignableFrom(penv, S, metaclass(T).ptr) == JNI_TRUE +isConvertible(T, S::Ptr{Nothing} ) = IsAssignableFrom(penv, S, metaclass(T).ptr) == JNI_TRUE unsafe_convert(::Type{Ptr{Nothing}}, cls::JavaMetaClass) = cls.ptr @@ -108,7 +109,6 @@ for (x, y, z) in [(:jboolean, :(jnifunc.GetBooleanArrayElements), :(jnifunc.Rele arr = ccall($(y), Ptr{$(x)}, (Ptr{JNIEnv}, Ptr{Nothing}, Ptr{jboolean} ), penv, result, C_NULL) jl_arr::Array = unsafe_wrap(Array, arr, Int(sz)) - #jl_arr::Array = pointer_to_array(arr, (@compat Int(sz)), false) jl_arr = deepcopy(jl_arr) ccall($(z), Nothing, (Ptr{JNIEnv},Ptr{Nothing}, Ptr{$(x)}, jint), penv, result, arr, 0) return jl_arr @@ -261,7 +261,6 @@ function unsafe_string(jstr::JString) #jstr must be a jstring obtained via a JN pIsCopy = Array{jboolean}(undef, 1) buf::Ptr{UInt8} = GetStringUTFChars(penv, jstr.ptr, pIsCopy) s = unsafe_string(buf) - # s = bytestring(buf) ReleaseStringUTFChars(penv, jstr.ptr, buf) return s end diff --git a/src/core.jl b/src/core.jl index 321021b..97ec9ff 100644 --- a/src/core.jl +++ b/src/core.jl @@ -1,21 +1,3 @@ - -# jni_md.h -const jint = Cint -#ifdef _LP64 /* 64-bit Solaris */ -# typedef long jlong; -const jlong = Clonglong -const jbyte = Cchar - -# jni.h - -const jboolean = Cuchar -const jchar = Cushort -const jshort = Cshort -const jfloat = Cfloat -const jdouble = Cdouble -const jsize = jint -jprimitive = Union{jboolean, jchar, jshort, jfloat, jdouble, jint, jlong} - struct JavaMetaClass{T} ptr::Ptr{Nothing} end @@ -64,7 +46,7 @@ Checks if the passed JavaObject is null or not true if the passed object is null else false """ isnull(obj::JavaObject) = obj.ptr == C_NULL -isnull(obj::Ptr{Void}) = obj == C_NULL +isnull(obj::Ptr{Nothing}) = obj == C_NULL """ ``` @@ -134,7 +116,6 @@ function jnew(T::Symbol, argtypes::Tuple, args...) end # Call static methods -<<<<<<< HEAD function jcall(typ::Type{JavaObject{T}}, method::AbstractString, rettype::Type, argtypes::Tuple, args... ) where T assertroottask_or_goodenv() @@ -146,7 +127,6 @@ end # Call instance methods function jcall(obj::JavaObject, method::AbstractString, rettype::Type, argtypes::Tuple, args... ) -<<<<<<< HEAD assertroottask_or_goodenv() sig = method_signature(rettype, argtypes...) jmethodId = GetMethodID(penv, metaclass(obj).ptr, String(method), sig) @@ -278,7 +258,7 @@ function geterror(allow=false) jthrow==C_NULL && throw(JavaCallError("Java Exception thrown, but no details could be retrieved from the JVM")) ExceptionDescribe(penv ) #Print java stackstrace to stdout ExceptionClear(penv ) - "java/lang/Throwable") + jclass = FindClass(penv, "java/lang/Throwable") jclass==C_NULL && throw(JavaCallError("Java Exception thrown, but no details could be retrieved from the JVM")) jmethodId=GetMethodID(penv, jclass, "toString", "()Ljava/lang/String;") jmethodId==C_NULL && throw(JavaCallError("Java Exception thrown, but no details could be retrieved from the JVM")) diff --git a/src/jnienv.jl b/src/jnienv.jl index b70ae79..e7732f9 100644 --- a/src/jnienv.jl +++ b/src/jnienv.jl @@ -1,20 +1,3 @@ -# jni_md.h -typealias jint Cint -#ifdef _LP64 /* 64-bit Solaris */ -# typedef long jlong; -typealias jlong Clonglong -typealias jbyte Cchar - -# jni.h - -typealias jboolean Cuchar -typealias jchar Cushort -typealias jshort Cshort -typealias jfloat Cfloat -typealias jdouble Cdouble -typealias jsize jint -jprimitive = @compat Union{jboolean, jchar, jshort, jfloat, jdouble, jint, jlong} - struct JNINativeInterface #struct JNINativeInterface_ { diff --git a/src/jnienv2.jl b/src/jnienv2.jl index 0665553..e525473 100644 --- a/src/jnienv2.jl +++ b/src/jnienv2.jl @@ -1,24 +1,57 @@ module JNI -import ..JavaCall: JNIEnv, JavaVM, jbyte, jchar, jshort, jint, jlong, jsize, jdouble, jfloat, jboolean -typealias jobject Ptr{Void} -typealias jclass Ptr{Void} -typealias jthrowable Ptr{Void} -typealias jweak Ptr{Void} -typealias jmethodID Ptr{Void} -typealias jfieldID Ptr{Void} -typealias jstring Ptr{Void} -typealias jarray Ptr{Void} -typealias JNINativeMethod Ptr{Void} -typealias jobjectArray Ptr{Void} -typealias jbooleanArray Ptr{Void} -typealias jbyteArray Ptr{Void} -typealias jshortArray Ptr{Void} -typealias jintArray Ptr{Void} -typealias jlongArray Ptr{Void} -typealias jfloatArray Ptr{Void} -typealias jdoubleArray Ptr{Void} -typealias jcharArray Ptr{Void} -typealias jvalue Int64 + +# jnienv.jl exports +export JNINativeInterface, JNIEnv, JNIInvokeInterface, JavaVM, JavaCallError +# jni_md.h exports +export jint, jlong, jbyte +# jni.h exports +export jboolean, jchar, jshort, jfloat, jdouble, jsize, jprimitive + +include("jnienv.jl") + +# jni_md.h +const jint = Cint +#ifdef _LP64 /* 64-bit Solaris */ +# typedef long jlong; +const jlong = Clonglong +const jbyte = Cchar + +# jni.h + +const jboolean = Cuchar +const jchar = Cushort +const jshort = Cshort +const jfloat = Cfloat +const jdouble = Cdouble +const jsize = jint +jprimitive = Union{jboolean, jchar, jshort, jfloat, jdouble, jint, jlong} + +jobject = Ptr{Nothing} +jclass = Ptr{Nothing} +jthrowable = Ptr{Nothing} +jweak = Ptr{Nothing} +jmethodID = Ptr{Nothing} +jfieldID = Ptr{Nothing} +jstring = Ptr{Nothing} +jarray = Ptr{Nothing} +JNINativeMethod = Ptr{Nothing} +jobjectArray = Ptr{Nothing} +jbooleanArray = Ptr{Nothing} +jbyteArray = Ptr{Nothing} +jshortArray = Ptr{Nothing} +jintArray = Ptr{Nothing} +jlongArray = Ptr{Nothing} +jfloatArray = Ptr{Nothing} +jdoubleArray = Ptr{Nothing} +jcharArray = Ptr{Nothing} +jvalue = Int64 + +@enum jobjectRefType begin + JNIInvalidRefType = 0 + JNILocalRefType = 1 + JNIGlobalRefType = 2 + JNIWeakGlobalRefType = 3 +end export GetVersion GetVersion(env::Ptr{JNIEnv}) = @@ -70,15 +103,15 @@ ExceptionOccurred(env::Ptr{JNIEnv}) = export ExceptionDescribe ExceptionDescribe(env::Ptr{JNIEnv}) = - ccall(Main.JavaCall.jnifunc.ExceptionDescribe, Void, (Ptr{JNIEnv},), env) + ccall(Main.JavaCall.jnifunc.ExceptionDescribe, Nothing, (Ptr{JNIEnv},), env) export ExceptionClear ExceptionClear(env::Ptr{JNIEnv}) = - ccall(Main.JavaCall.jnifunc.ExceptionClear, Void, (Ptr{JNIEnv},), env) + ccall(Main.JavaCall.jnifunc.ExceptionClear, Nothing, (Ptr{JNIEnv},), env) export FatalError FatalError(env::Ptr{JNIEnv}, msg::AbstractString) = - ccall(Main.JavaCall.jnifunc.FatalError, Void, (Ptr{JNIEnv}, Cstring,), env, String(msg)) + ccall(Main.JavaCall.jnifunc.FatalError, Nothing, (Ptr{JNIEnv}, Cstring,), env, String(msg)) export PushLocalFrame PushLocalFrame(env::Ptr{JNIEnv}, capacity::jint) = @@ -94,11 +127,11 @@ NewGlobalRef(env::Ptr{JNIEnv}, lobj::jobject) = export DeleteGlobalRef DeleteGlobalRef(env::Ptr{JNIEnv}, gref::jobject) = - ccall(Main.JavaCall.jnifunc.DeleteGlobalRef, Void, (Ptr{JNIEnv}, jobject,), env, gref) + ccall(Main.JavaCall.jnifunc.DeleteGlobalRef, Nothing, (Ptr{JNIEnv}, jobject,), env, gref) export DeleteLocalRef DeleteLocalRef(env::Ptr{JNIEnv}, obj::jobject) = - ccall(Main.JavaCall.jnifunc.DeleteLocalRef, Void, (Ptr{JNIEnv}, jobject,), env, obj) + ccall(Main.JavaCall.jnifunc.DeleteLocalRef, Nothing, (Ptr{JNIEnv}, jobject,), env, obj) export IsSameObject IsSameObject(env::Ptr{JNIEnv}, obj1::jobject, obj2::jobject) = @@ -170,7 +203,7 @@ CallDoubleMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Arr export CallVoidMethodA CallVoidMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(Main.JavaCall.jnifunc.CallVoidMethodA, Void, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) + ccall(Main.JavaCall.jnifunc.CallVoidMethodA, Nothing, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) export CallNonvirtualObjectMethodA CallNonvirtualObjectMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = @@ -210,7 +243,7 @@ CallNonvirtualDoubleMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, metho export CallNonvirtualVoidMethodA CallNonvirtualVoidMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(Main.JavaCall.jnifunc.CallNonvirtualVoidMethodA, Void, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) + ccall(Main.JavaCall.jnifunc.CallNonvirtualVoidMethodA, Nothing, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) export GetFieldID GetFieldID(env::Ptr{JNIEnv}, clazz::jclass, name::AbstractString, sig::AbstractString) = @@ -254,39 +287,39 @@ GetDoubleField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = export SetObjectField SetObjectField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jobject) = - ccall(Main.JavaCall.jnifunc.SetObjectField, Void, (Ptr{JNIEnv}, jobject, jfieldID, jobject,), env, obj, fieldID, val) + ccall(Main.JavaCall.jnifunc.SetObjectField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jobject,), env, obj, fieldID, val) export SetBooleanField SetBooleanField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jboolean) = - ccall(Main.JavaCall.jnifunc.SetBooleanField, Void, (Ptr{JNIEnv}, jobject, jfieldID, jboolean,), env, obj, fieldID, val) + ccall(Main.JavaCall.jnifunc.SetBooleanField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jboolean,), env, obj, fieldID, val) export SetByteField SetByteField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jbyte) = - ccall(Main.JavaCall.jnifunc.SetByteField, Void, (Ptr{JNIEnv}, jobject, jfieldID, jbyte,), env, obj, fieldID, val) + ccall(Main.JavaCall.jnifunc.SetByteField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jbyte,), env, obj, fieldID, val) export SetCharField SetCharField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jchar) = - ccall(Main.JavaCall.jnifunc.SetCharField, Void, (Ptr{JNIEnv}, jobject, jfieldID, jchar,), env, obj, fieldID, val) + ccall(Main.JavaCall.jnifunc.SetCharField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jchar,), env, obj, fieldID, val) export SetShortField SetShortField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jshort) = - ccall(Main.JavaCall.jnifunc.SetShortField, Void, (Ptr{JNIEnv}, jobject, jfieldID, jshort,), env, obj, fieldID, val) + ccall(Main.JavaCall.jnifunc.SetShortField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jshort,), env, obj, fieldID, val) export SetIntField SetIntField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jint) = - ccall(Main.JavaCall.jnifunc.SetIntField, Void, (Ptr{JNIEnv}, jobject, jfieldID, jint,), env, obj, fieldID, val) + ccall(Main.JavaCall.jnifunc.SetIntField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jint,), env, obj, fieldID, val) export SetLongField SetLongField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jlong) = - ccall(Main.JavaCall.jnifunc.SetLongField, Void, (Ptr{JNIEnv}, jobject, jfieldID, jlong,), env, obj, fieldID, val) + ccall(Main.JavaCall.jnifunc.SetLongField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jlong,), env, obj, fieldID, val) export SetFloatField SetFloatField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jfloat) = - ccall(Main.JavaCall.jnifunc.SetFloatField, Void, (Ptr{JNIEnv}, jobject, jfieldID, jfloat,), env, obj, fieldID, val) + ccall(Main.JavaCall.jnifunc.SetFloatField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jfloat,), env, obj, fieldID, val) export SetDoubleField SetDoubleField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jdouble) = - ccall(Main.JavaCall.jnifunc.SetDoubleField, Void, (Ptr{JNIEnv}, jobject, jfieldID, jdouble,), env, obj, fieldID, val) + ccall(Main.JavaCall.jnifunc.SetDoubleField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jdouble,), env, obj, fieldID, val) export GetStaticMethodID GetStaticMethodID(env::Ptr{JNIEnv}, clazz::jclass, name::AbstractString, sig::AbstractString) = @@ -330,7 +363,7 @@ CallStaticDoubleMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, ar export CallStaticVoidMethodA CallStaticVoidMethodA(env::Ptr{JNIEnv}, cls::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(Main.JavaCall.jnifunc.CallStaticVoidMethodA, Void, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, cls, methodID, args) + ccall(Main.JavaCall.jnifunc.CallStaticVoidMethodA, Nothing, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, cls, methodID, args) export GetStaticFieldID GetStaticFieldID(env::Ptr{JNIEnv}, clazz::jclass, name::AbstractString, sig::AbstractString) = @@ -374,39 +407,39 @@ GetStaticDoubleField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = export SetStaticObjectField SetStaticObjectField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jobject) = - ccall(Main.JavaCall.jnifunc.SetStaticObjectField, Void, (Ptr{JNIEnv}, jclass, jfieldID, jobject,), env, clazz, fieldID, value) + ccall(Main.JavaCall.jnifunc.SetStaticObjectField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jobject,), env, clazz, fieldID, value) export SetStaticBooleanField SetStaticBooleanField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jboolean) = - ccall(Main.JavaCall.jnifunc.SetStaticBooleanField, Void, (Ptr{JNIEnv}, jclass, jfieldID, jboolean,), env, clazz, fieldID, value) + ccall(Main.JavaCall.jnifunc.SetStaticBooleanField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jboolean,), env, clazz, fieldID, value) export SetStaticByteField SetStaticByteField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jbyte) = - ccall(Main.JavaCall.jnifunc.SetStaticByteField, Void, (Ptr{JNIEnv}, jclass, jfieldID, jbyte,), env, clazz, fieldID, value) + ccall(Main.JavaCall.jnifunc.SetStaticByteField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jbyte,), env, clazz, fieldID, value) export SetStaticCharField SetStaticCharField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jchar) = - ccall(Main.JavaCall.jnifunc.SetStaticCharField, Void, (Ptr{JNIEnv}, jclass, jfieldID, jchar,), env, clazz, fieldID, value) + ccall(Main.JavaCall.jnifunc.SetStaticCharField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jchar,), env, clazz, fieldID, value) export SetStaticShortField SetStaticShortField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jshort) = - ccall(Main.JavaCall.jnifunc.SetStaticShortField, Void, (Ptr{JNIEnv}, jclass, jfieldID, jshort,), env, clazz, fieldID, value) + ccall(Main.JavaCall.jnifunc.SetStaticShortField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jshort,), env, clazz, fieldID, value) export SetStaticIntField SetStaticIntField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jint) = - ccall(Main.JavaCall.jnifunc.SetStaticIntField, Void, (Ptr{JNIEnv}, jclass, jfieldID, jint,), env, clazz, fieldID, value) + ccall(Main.JavaCall.jnifunc.SetStaticIntField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jint,), env, clazz, fieldID, value) export SetStaticLongField SetStaticLongField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jlong) = - ccall(Main.JavaCall.jnifunc.SetStaticLongField, Void, (Ptr{JNIEnv}, jclass, jfieldID, jlong,), env, clazz, fieldID, value) + ccall(Main.JavaCall.jnifunc.SetStaticLongField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jlong,), env, clazz, fieldID, value) export SetStaticFloatField SetStaticFloatField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jfloat) = - ccall(Main.JavaCall.jnifunc.SetStaticFloatField, Void, (Ptr{JNIEnv}, jclass, jfieldID, jfloat,), env, clazz, fieldID, value) + ccall(Main.JavaCall.jnifunc.SetStaticFloatField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jfloat,), env, clazz, fieldID, value) export SetStaticDoubleField SetStaticDoubleField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jdouble) = - ccall(Main.JavaCall.jnifunc.SetStaticDoubleField, Void, (Ptr{JNIEnv}, jclass, jfieldID, jdouble,), env, clazz, fieldID, value) + ccall(Main.JavaCall.jnifunc.SetStaticDoubleField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jdouble,), env, clazz, fieldID, value) export NewString NewString(env::Ptr{JNIEnv}, unicode::Array{jchar,1}, len::Integer) = @@ -422,7 +455,7 @@ GetStringChars(env::Ptr{JNIEnv}, str::jstring, isCopy::Array{jboolean,1}) = export ReleaseStringChars ReleaseStringChars(env::Ptr{JNIEnv}, str::jstring, chars::Array{jchar,1}) = - ccall(Main.JavaCall.jnifunc.ReleaseStringChars, Void, (Ptr{JNIEnv}, jstring, Ptr{jchar},), env, str, chars) + ccall(Main.JavaCall.jnifunc.ReleaseStringChars, Nothing, (Ptr{JNIEnv}, jstring, Ptr{jchar},), env, str, chars) export NewStringUTF NewStringUTF(env::Ptr{JNIEnv}, utf::AbstractString) = @@ -438,7 +471,7 @@ GetStringUTFChars(env::Ptr{JNIEnv}, str::jstring, isCopy::Array{jboolean,1}) = export ReleaseStringUTFChars ReleaseStringUTFChars(env::Ptr{JNIEnv}, str::jstring, chars::Ptr{UInt8}) = - ccall(Main.JavaCall.jnifunc.ReleaseStringUTFChars, Void, (Ptr{JNIEnv}, jstring, Ptr{UInt8},), env, str, chars) + ccall(Main.JavaCall.jnifunc.ReleaseStringUTFChars, Nothing, (Ptr{JNIEnv}, jstring, Ptr{UInt8},), env, str, chars) export GetArrayLength GetArrayLength(env::Ptr{JNIEnv}, array::jarray) = @@ -454,7 +487,7 @@ GetObjectArrayElement(env::Ptr{JNIEnv}, array::jobjectArray, index::Integer) = export SetObjectArrayElement SetObjectArrayElement(env::Ptr{JNIEnv}, array::jobjectArray, index::Integer, val::jobject) = - ccall(Main.JavaCall.jnifunc.SetObjectArrayElement, Void, (Ptr{JNIEnv}, jobjectArray, jsize, jobject,), env, array, index, val) + ccall(Main.JavaCall.jnifunc.SetObjectArrayElement, Nothing, (Ptr{JNIEnv}, jobjectArray, jsize, jobject,), env, array, index, val) export NewBooleanArray NewBooleanArray(env::Ptr{JNIEnv}, len::Integer) = @@ -522,99 +555,99 @@ GetDoubleArrayElements(env::Ptr{JNIEnv}, array::jdoubleArray, isCopy::Array{jboo export ReleaseBooleanArrayElements ReleaseBooleanArrayElements(env::Ptr{JNIEnv}, array::jbooleanArray, elems::Array{jboolean,1}, mode::jint) = - ccall(Main.JavaCall.jnifunc.ReleaseBooleanArrayElements, Void, (Ptr{JNIEnv}, jbooleanArray, Ptr{jboolean}, jint,), env, array, elems, mode) + ccall(Main.JavaCall.jnifunc.ReleaseBooleanArrayElements, Nothing, (Ptr{JNIEnv}, jbooleanArray, Ptr{jboolean}, jint,), env, array, elems, mode) export ReleaseByteArrayElements ReleaseByteArrayElements(env::Ptr{JNIEnv}, array::jbyteArray, elems::Array{jbyte,1}, mode::jint) = - ccall(Main.JavaCall.jnifunc.ReleaseByteArrayElements, Void, (Ptr{JNIEnv}, jbyteArray, Ptr{jbyte}, jint,), env, array, elems, mode) + ccall(Main.JavaCall.jnifunc.ReleaseByteArrayElements, Nothing, (Ptr{JNIEnv}, jbyteArray, Ptr{jbyte}, jint,), env, array, elems, mode) export ReleaseCharArrayElements ReleaseCharArrayElements(env::Ptr{JNIEnv}, array::jcharArray, elems::Array{jchar,1}, mode::jint) = - ccall(Main.JavaCall.jnifunc.ReleaseCharArrayElements, Void, (Ptr{JNIEnv}, jcharArray, Ptr{jchar}, jint,), env, array, elems, mode) + ccall(Main.JavaCall.jnifunc.ReleaseCharArrayElements, Nothing, (Ptr{JNIEnv}, jcharArray, Ptr{jchar}, jint,), env, array, elems, mode) export ReleaseShortArrayElements ReleaseShortArrayElements(env::Ptr{JNIEnv}, array::jshortArray, elems::Array{jshort,1}, mode::jint) = - ccall(Main.JavaCall.jnifunc.ReleaseShortArrayElements, Void, (Ptr{JNIEnv}, jshortArray, Ptr{jshort}, jint,), env, array, elems, mode) + ccall(Main.JavaCall.jnifunc.ReleaseShortArrayElements, Nothing, (Ptr{JNIEnv}, jshortArray, Ptr{jshort}, jint,), env, array, elems, mode) export ReleaseIntArrayElements ReleaseIntArrayElements(env::Ptr{JNIEnv}, array::jintArray, elems::Array{jint,1}, mode::jint) = - ccall(Main.JavaCall.jnifunc.ReleaseIntArrayElements, Void, (Ptr{JNIEnv}, jintArray, Ptr{jint}, jint,), env, array, elems, mode) + ccall(Main.JavaCall.jnifunc.ReleaseIntArrayElements, Nothing, (Ptr{JNIEnv}, jintArray, Ptr{jint}, jint,), env, array, elems, mode) export ReleaseLongArrayElements ReleaseLongArrayElements(env::Ptr{JNIEnv}, array::jlongArray, elems::Array{jlong,1}, mode::jint) = - ccall(Main.JavaCall.jnifunc.ReleaseLongArrayElements, Void, (Ptr{JNIEnv}, jlongArray, Ptr{jlong}, jint,), env, array, elems, mode) + ccall(Main.JavaCall.jnifunc.ReleaseLongArrayElements, Nothing, (Ptr{JNIEnv}, jlongArray, Ptr{jlong}, jint,), env, array, elems, mode) export ReleaseFloatArrayElements ReleaseFloatArrayElements(env::Ptr{JNIEnv}, array::jfloatArray, elems::Array{jfloat,1}, mode::jint) = - ccall(Main.JavaCall.jnifunc.ReleaseFloatArrayElements, Void, (Ptr{JNIEnv}, jfloatArray, Ptr{jfloat}, jint,), env, array, elems, mode) + ccall(Main.JavaCall.jnifunc.ReleaseFloatArrayElements, Nothing, (Ptr{JNIEnv}, jfloatArray, Ptr{jfloat}, jint,), env, array, elems, mode) export ReleaseDoubleArrayElements ReleaseDoubleArrayElements(env::Ptr{JNIEnv}, array::jdoubleArray, elems::Array{jdouble,1}, mode::jint) = - ccall(Main.JavaCall.jnifunc.ReleaseDoubleArrayElements, Void, (Ptr{JNIEnv}, jdoubleArray, Ptr{jdouble}, jint,), env, array, elems, mode) + ccall(Main.JavaCall.jnifunc.ReleaseDoubleArrayElements, Nothing, (Ptr{JNIEnv}, jdoubleArray, Ptr{jdouble}, jint,), env, array, elems, mode) export GetBooleanArrayRegion GetBooleanArrayRegion(env::Ptr{JNIEnv}, array::jbooleanArray, start::Integer, l::Integer, buf::Array{jboolean,1}) = - ccall(Main.JavaCall.jnifunc.GetBooleanArrayRegion, Void, (Ptr{JNIEnv}, jbooleanArray, jsize, jsize, Ptr{jboolean},), env, array, start, l, buf) + ccall(Main.JavaCall.jnifunc.GetBooleanArrayRegion, Nothing, (Ptr{JNIEnv}, jbooleanArray, jsize, jsize, Ptr{jboolean},), env, array, start, l, buf) export GetByteArrayRegion GetByteArrayRegion(env::Ptr{JNIEnv}, array::jbyteArray, start::Integer, len::Integer, buf::Array{jbyte,1}) = - ccall(Main.JavaCall.jnifunc.GetByteArrayRegion, Void, (Ptr{JNIEnv}, jbyteArray, jsize, jsize, Ptr{jbyte},), env, array, start, len, buf) + ccall(Main.JavaCall.jnifunc.GetByteArrayRegion, Nothing, (Ptr{JNIEnv}, jbyteArray, jsize, jsize, Ptr{jbyte},), env, array, start, len, buf) export GetCharArrayRegion GetCharArrayRegion(env::Ptr{JNIEnv}, array::jcharArray, start::Integer, len::Integer, buf::Array{jchar,1}) = - ccall(Main.JavaCall.jnifunc.GetCharArrayRegion, Void, (Ptr{JNIEnv}, jcharArray, jsize, jsize, Ptr{jchar},), env, array, start, len, buf) + ccall(Main.JavaCall.jnifunc.GetCharArrayRegion, Nothing, (Ptr{JNIEnv}, jcharArray, jsize, jsize, Ptr{jchar},), env, array, start, len, buf) export GetShortArrayRegion GetShortArrayRegion(env::Ptr{JNIEnv}, array::jshortArray, start::Integer, len::Integer, buf::Array{jshort,1}) = - ccall(Main.JavaCall.jnifunc.GetShortArrayRegion, Void, (Ptr{JNIEnv}, jshortArray, jsize, jsize, Ptr{jshort},), env, array, start, len, buf) + ccall(Main.JavaCall.jnifunc.GetShortArrayRegion, Nothing, (Ptr{JNIEnv}, jshortArray, jsize, jsize, Ptr{jshort},), env, array, start, len, buf) export GetIntArrayRegion GetIntArrayRegion(env::Ptr{JNIEnv}, array::jintArray, start::Integer, len::Integer, buf::Array{jint,1}) = - ccall(Main.JavaCall.jnifunc.GetIntArrayRegion, Void, (Ptr{JNIEnv}, jintArray, jsize, jsize, Ptr{jint},), env, array, start, len, buf) + ccall(Main.JavaCall.jnifunc.GetIntArrayRegion, Nothing, (Ptr{JNIEnv}, jintArray, jsize, jsize, Ptr{jint},), env, array, start, len, buf) export GetLongArrayRegion GetLongArrayRegion(env::Ptr{JNIEnv}, array::jlongArray, start::Integer, len::Integer, buf::Array{jlong,1}) = - ccall(Main.JavaCall.jnifunc.GetLongArrayRegion, Void, (Ptr{JNIEnv}, jlongArray, jsize, jsize, Ptr{jlong},), env, array, start, len, buf) + ccall(Main.JavaCall.jnifunc.GetLongArrayRegion, Nothing, (Ptr{JNIEnv}, jlongArray, jsize, jsize, Ptr{jlong},), env, array, start, len, buf) export GetFloatArrayRegion GetFloatArrayRegion(env::Ptr{JNIEnv}, array::jfloatArray, start::Integer, len::Integer, buf::Array{jfloat,1}) = - ccall(Main.JavaCall.jnifunc.GetFloatArrayRegion, Void, (Ptr{JNIEnv}, jfloatArray, jsize, jsize, Ptr{jfloat},), env, array, start, len, buf) + ccall(Main.JavaCall.jnifunc.GetFloatArrayRegion, Nothing, (Ptr{JNIEnv}, jfloatArray, jsize, jsize, Ptr{jfloat},), env, array, start, len, buf) export GetDoubleArrayRegion GetDoubleArrayRegion(env::Ptr{JNIEnv}, array::jdoubleArray, start::Integer, len::Integer, buf::Array{jdouble,1}) = - ccall(Main.JavaCall.jnifunc.GetDoubleArrayRegion, Void, (Ptr{JNIEnv}, jdoubleArray, jsize, jsize, Ptr{jdouble},), env, array, start, len, buf) + ccall(Main.JavaCall.jnifunc.GetDoubleArrayRegion, Nothing, (Ptr{JNIEnv}, jdoubleArray, jsize, jsize, Ptr{jdouble},), env, array, start, len, buf) export SetBooleanArrayRegion SetBooleanArrayRegion(env::Ptr{JNIEnv}, array::jbooleanArray, start::Integer, l::Integer, buf::Array{jboolean,1}) = - ccall(Main.JavaCall.jnifunc.SetBooleanArrayRegion, Void, (Ptr{JNIEnv}, jbooleanArray, jsize, jsize, Ptr{jboolean},), env, array, start, l, buf) + ccall(Main.JavaCall.jnifunc.SetBooleanArrayRegion, Nothing, (Ptr{JNIEnv}, jbooleanArray, jsize, jsize, Ptr{jboolean},), env, array, start, l, buf) export SetByteArrayRegion SetByteArrayRegion(env::Ptr{JNIEnv}, array::jbyteArray, start::Integer, len::Integer, buf::Array{jbyte,1}) = - ccall(Main.JavaCall.jnifunc.SetByteArrayRegion, Void, (Ptr{JNIEnv}, jbyteArray, jsize, jsize, Ptr{jbyte},), env, array, start, len, buf) + ccall(Main.JavaCall.jnifunc.SetByteArrayRegion, Nothing, (Ptr{JNIEnv}, jbyteArray, jsize, jsize, Ptr{jbyte},), env, array, start, len, buf) export SetCharArrayRegion SetCharArrayRegion(env::Ptr{JNIEnv}, array::jcharArray, start::Integer, len::Integer, buf::Array{jchar,1}) = - ccall(Main.JavaCall.jnifunc.SetCharArrayRegion, Void, (Ptr{JNIEnv}, jcharArray, jsize, jsize, Ptr{jchar},), env, array, start, len, buf) + ccall(Main.JavaCall.jnifunc.SetCharArrayRegion, Nothing, (Ptr{JNIEnv}, jcharArray, jsize, jsize, Ptr{jchar},), env, array, start, len, buf) export SetShortArrayRegion SetShortArrayRegion(env::Ptr{JNIEnv}, array::jshortArray, start::Integer, len::Integer, buf::Array{jshort,1}) = - ccall(Main.JavaCall.jnifunc.SetShortArrayRegion, Void, (Ptr{JNIEnv}, jshortArray, jsize, jsize, Ptr{jshort},), env, array, start, len, buf) + ccall(Main.JavaCall.jnifunc.SetShortArrayRegion, Nothing, (Ptr{JNIEnv}, jshortArray, jsize, jsize, Ptr{jshort},), env, array, start, len, buf) export SetIntArrayRegion SetIntArrayRegion(env::Ptr{JNIEnv}, array::jintArray, start::Integer, len::Integer, buf::Array{jint,1}) = - ccall(Main.JavaCall.jnifunc.SetIntArrayRegion, Void, (Ptr{JNIEnv}, jintArray, jsize, jsize, Ptr{jint},), env, array, start, len, buf) + ccall(Main.JavaCall.jnifunc.SetIntArrayRegion, Nothing, (Ptr{JNIEnv}, jintArray, jsize, jsize, Ptr{jint},), env, array, start, len, buf) export SetLongArrayRegion SetLongArrayRegion(env::Ptr{JNIEnv}, array::jlongArray, start::Integer, len::Integer, buf::Array{jlong,1}) = - ccall(Main.JavaCall.jnifunc.SetLongArrayRegion, Void, (Ptr{JNIEnv}, jlongArray, jsize, jsize, Ptr{jlong},), env, array, start, len, buf) + ccall(Main.JavaCall.jnifunc.SetLongArrayRegion, Nothing, (Ptr{JNIEnv}, jlongArray, jsize, jsize, Ptr{jlong},), env, array, start, len, buf) export SetFloatArrayRegion SetFloatArrayRegion(env::Ptr{JNIEnv}, array::jfloatArray, start::Integer, len::Integer, buf::Array{jfloat,1}) = - ccall(Main.JavaCall.jnifunc.SetFloatArrayRegion, Void, (Ptr{JNIEnv}, jfloatArray, jsize, jsize, Ptr{jfloat},), env, array, start, len, buf) + ccall(Main.JavaCall.jnifunc.SetFloatArrayRegion, Nothing, (Ptr{JNIEnv}, jfloatArray, jsize, jsize, Ptr{jfloat},), env, array, start, len, buf) export SetDoubleArrayRegion SetDoubleArrayRegion(env::Ptr{JNIEnv}, array::jdoubleArray, start::Integer, len::Integer, buf::Array{jdouble,1}) = - ccall(Main.JavaCall.jnifunc.SetDoubleArrayRegion, Void, (Ptr{JNIEnv}, jdoubleArray, jsize, jsize, Ptr{jdouble},), env, array, start, len, buf) + ccall(Main.JavaCall.jnifunc.SetDoubleArrayRegion, Nothing, (Ptr{JNIEnv}, jdoubleArray, jsize, jsize, Ptr{jdouble},), env, array, start, len, buf) export RegisterNatives RegisterNatives(env::Ptr{JNIEnv}, clazz::jclass, methods::Array{JNINativeMethod,1}, nMethods::jint) = @@ -638,19 +671,19 @@ GetJavaVM(env::Ptr{JNIEnv}, vm::Array{JavaVM,1}) = export GetStringRegion GetStringRegion(env::Ptr{JNIEnv}, str::jstring, start::Integer, len::Integer, buf::Array{jchar,1}) = - ccall(Main.JavaCall.jnifunc.GetStringRegion, Void, (Ptr{JNIEnv}, jstring, jsize, jsize, Ptr{jchar},), env, str, start, len, buf) + ccall(Main.JavaCall.jnifunc.GetStringRegion, Nothing, (Ptr{JNIEnv}, jstring, jsize, jsize, Ptr{jchar},), env, str, start, len, buf) export GetStringUTFRegion GetStringUTFRegion(env::Ptr{JNIEnv}, str::jstring, start::Integer, len::Integer, buf::AbstractString) = - ccall(Main.JavaCall.jnifunc.GetStringUTFRegion, Void, (Ptr{JNIEnv}, jstring, jsize, jsize, Cstring,), env, str, start, len, String(buf)) + ccall(Main.JavaCall.jnifunc.GetStringUTFRegion, Nothing, (Ptr{JNIEnv}, jstring, jsize, jsize, Cstring,), env, str, start, len, String(buf)) export GetPrimitiveArrayCritical GetPrimitiveArrayCritical(env::Ptr{JNIEnv}, array::jarray, isCopy::Array{jboolean,1}) = - ccall(Main.JavaCall.jnifunc.GetPrimitiveArrayCritical, Ptr{Void}, (Ptr{JNIEnv}, jarray, Ptr{jboolean},), env, array, isCopy) + ccall(Main.JavaCall.jnifunc.GetPrimitiveArrayCritical, Ptr{Nothing}, (Ptr{JNIEnv}, jarray, Ptr{jboolean},), env, array, isCopy) export ReleasePrimitiveArrayCritical -ReleasePrimitiveArrayCritical(env::Ptr{JNIEnv}, array::jarray, carray::Ptr{Void}, mode::jint) = - ccall(Main.JavaCall.jnifunc.ReleasePrimitiveArrayCritical, Void, (Ptr{JNIEnv}, jarray, Ptr{Void}, jint,), env, array, carray, mode) +ReleasePrimitiveArrayCritical(env::Ptr{JNIEnv}, array::jarray, carray::Ptr{Nothing}, mode::jint) = + ccall(Main.JavaCall.jnifunc.ReleasePrimitiveArrayCritical, Nothing, (Ptr{JNIEnv}, jarray, Ptr{Nothing}, jint,), env, array, carray, mode) export GetStringCritical GetStringCritical(env::Ptr{JNIEnv}, string::jstring, isCopy::Array{jboolean,1}) = @@ -658,7 +691,7 @@ GetStringCritical(env::Ptr{JNIEnv}, string::jstring, isCopy::Array{jboolean,1}) export ReleaseStringCritical ReleaseStringCritical(env::Ptr{JNIEnv}, string::jstring, cstring::Array{jchar,1}) = - ccall(Main.JavaCall.jnifunc.ReleaseStringCritical, Void, (Ptr{JNIEnv}, jstring, Ptr{jchar},), env, string, cstring) + ccall(Main.JavaCall.jnifunc.ReleaseStringCritical, Nothing, (Ptr{JNIEnv}, jstring, Ptr{jchar},), env, string, cstring) export NewWeakGlobalRef NewWeakGlobalRef(env::Ptr{JNIEnv}, obj::jobject) = @@ -666,19 +699,19 @@ NewWeakGlobalRef(env::Ptr{JNIEnv}, obj::jobject) = export DeleteWeakGlobalRef DeleteWeakGlobalRef(env::Ptr{JNIEnv}, ref::jweak) = - ccall(Main.JavaCall.jnifunc.DeleteWeakGlobalRef, Void, (Ptr{JNIEnv}, jweak,), env, ref) + ccall(Main.JavaCall.jnifunc.DeleteWeakGlobalRef, Nothing, (Ptr{JNIEnv}, jweak,), env, ref) export ExceptionCheck ExceptionCheck(env::Ptr{JNIEnv}) = ccall(Main.JavaCall.jnifunc.ExceptionCheck, jboolean, (Ptr{JNIEnv},), env) export NewDirectByteBuffer -NewDirectByteBuffer(env::Ptr{JNIEnv}, address::Ptr{Void}, capacity::jlong) = - ccall(Main.JavaCall.jnifunc.NewDirectByteBuffer, jobject, (Ptr{JNIEnv}, Ptr{Void}, jlong,), env, address, capacity) +NewDirectByteBuffer(env::Ptr{JNIEnv}, address::Ptr{Nothing}, capacity::jlong) = + ccall(Main.JavaCall.jnifunc.NewDirectByteBuffer, jobject, (Ptr{JNIEnv}, Ptr{Nothing}, jlong,), env, address, capacity) export GetDirectBufferAddress GetDirectBufferAddress(env::Ptr{JNIEnv}, buf::jobject) = - ccall(Main.JavaCall.jnifunc.GetDirectBufferAddress, Ptr{Void}, (Ptr{JNIEnv}, jobject,), env, buf) + ccall(Main.JavaCall.jnifunc.GetDirectBufferAddress, Ptr{Nothing}, (Ptr{JNIEnv}, jobject,), env, buf) export GetDirectBufferCapacity GetDirectBufferCapacity(env::Ptr{JNIEnv}, buf::jobject) = diff --git a/src/make_jni2.jl b/src/make_jni2.jl index 4463ab1..43a4f7b 100644 --- a/src/make_jni2.jl +++ b/src/make_jni2.jl @@ -1,12 +1,12 @@ println("module JNI") println("import ..JavaCall: JNIEnv, JavaVM, jbyte, jchar, jshort, jint, jlong, jsize, jdouble, jfloat, jboolean") for t in ["jobject", "jclass", "jthrowable", "jweak", "jmethodID", "jfieldID", "jstring", "jarray", "JNINativeMethod"] -println("typealias $t Ptr{Void}") +println("$t = Ptr{Nothing}") end for t in ["object", "boolean", "byte", "short", "int", "long", "float", "double", "char"] -println("typealias j$(t)Array Ptr{Void}") +println("j$(t)Array = Ptr{Nothing}") end -println("typealias jvalue Int64") +println("jvalue = Int64") println() function arg_name(m) @@ -26,7 +26,7 @@ function decl_arg_type(t, s) if t == "char" return "AbstractString" elseif t == "void" - return "Ptr{Void}" + return "Ptr{Nothing}" elseif t == "JNIEnv" return "Ptr{JNIEnv}" else @@ -37,7 +37,7 @@ function decl_arg_type(t, s) end if t == "void" - return "Void" + return "Nothing" end return s == "" ? t : "Array{$t,1}" @@ -48,7 +48,7 @@ function ccall_arg_type(t, s; r=false) if t == "char" return "Cstring" elseif t == "void" - return "Ptr{Void}" + return "Ptr{Nothing}" elseif t == "JNIEnv" return "Ptr{JNIEnv}" else @@ -57,7 +57,7 @@ function ccall_arg_type(t, s; r=false) end if t == "void" - return "Void" + return "Nothing" end return s == "" ? t : r ? "Ptr{$t}" : "Array{$t,1}" @@ -69,8 +69,8 @@ for line in open(readlines, "jnienv.jl", "r") m = match(r"\# \s* (?:const\s*)? ((?:void|char|j\w+)) \s* (\**) \s* \( \s* \* (\w+) \s* \) \s* \((.*)\) \s* ;"x, line) if m === nothing continue end - if contains(m.captures[4], "...") continue end - if contains(m.captures[4], "va_list") continue end + if occursin("...", m.captures[4]) continue end + if occursin("va_list", m.captures[4]) continue end rtype = ccall_arg_type(m.captures[1], m.captures[2], r=true) From f854e944dd67b22c6f1d3cf27661359ec26ee3e4 Mon Sep 17 00:00:00 2001 From: "markkitt@gmail.com" Date: Sat, 2 May 2020 14:06:21 -0500 Subject: [PATCH 09/18] Fix capitalization typos --- src/jnienv.jl | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/jnienv.jl b/src/jnienv.jl index e7732f9..22cdbb6 100644 --- a/src/jnienv.jl +++ b/src/jnienv.jl @@ -76,7 +76,7 @@ struct JNINativeInterface #struct JNINativeInterface_ { CallLongMethodA::Ptr{Nothing} #jlong ( *CallLongMethodA) (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args); CallFloatMethod::Ptr{Nothing} #jfloat ( *CallFloatMethod) (JNIEnv *env, jobject obj, jmethodID methodID, ...); - CallFloatMEthodV::Ptr{Nothing} #jfloat ( *CallFloatMethodV) (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); + CallFloatMethodV::Ptr{Nothing} #jfloat ( *CallFloatMethodV) (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); CallFloatMethodA::Ptr{Nothing} #jfloat ( *CallFloatMethodA) (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args); CallDoubleMethod::Ptr{Nothing} #jdouble ( *CallDoubleMethod) (JNIEnv *env, jobject obj, jmethodID methodID, ...); @@ -89,7 +89,7 @@ struct JNINativeInterface #struct JNINativeInterface_ { CallNonvirtualObjectMethod::Ptr{Nothing} #jobject ( *CallNonvirtualObjectMethod) (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); CallNonvirtualObjectMethodV::Ptr{Nothing} #jobject ( *CallNonvirtualObjectMethodV) (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args); - CallNonvirtualObjectMEthodA::Ptr{Nothing} #jobject ( *CallNonvirtualObjectMethodA) (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, const jvalue * args); + CallNonvirtualObjectMethodA::Ptr{Nothing} #jobject ( *CallNonvirtualObjectMethodA) (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, const jvalue * args); CallNonvirtualBooleanMethod::Ptr{Nothing} #jboolean ( *CallNonvirtualBooleanMethod) (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); CallNonvirtualBooleanMethodV::Ptr{Nothing} #jboolean ( *CallNonvirtualBooleanMethodV) (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args); From e8e5e6e33539d20b892fde6d6597ecb5ab1e885e Mon Sep 17 00:00:00 2001 From: "markkitt@gmail.com" Date: Sat, 2 May 2020 22:17:09 -0500 Subject: [PATCH 10/18] Create an independent JNI module --- src/convert.jl | 127 ++++----- src/core.jl | 90 +++--- src/jnienv2.jl | 727 ++++++++++++++++++++++++----------------------- src/jvm.jl | 8 +- src/make_jni2.jl | 63 +++- 5 files changed, 526 insertions(+), 489 deletions(-) diff --git a/src/convert.jl b/src/convert.jl index 38320f7..9001713 100644 --- a/src/convert.jl +++ b/src/convert.jl @@ -4,14 +4,14 @@ convert(::Type{JObject}, str::AbstractString) = convert(JObject, JString(str)) #Cast java object from S to T . Needed for polymorphic calls function convert(::Type{JavaObject{T}}, obj::JavaObject{S}) where {T,S} if isConvertible(T, S) #Safe static cast - ptr = ccall(jnifunc.NewLocalRef, Ptr{Nothing}, (Ptr{JNIEnv}, Ptr{Nothing}), penv, obj.ptr) + ptr = JNI.NewLocalRef(penv, obj.ptr) ptr === C_NULL && geterror() return JavaObject{T}(ptr) end isnull(obj) && throw(ArgumentError("Cannot convert NULL")) - realClass = GetObjectClass(penv, obj.ptr) + realClass = JNI.GetObjectClass(penv, obj.ptr) if isConvertible(T, realClass) #dynamic cast - ptr = ccall(jnifunc.NewLocalRef, Ptr{Nothing}, (Ptr{JNIEnv}, Ptr{Nothing}), penv, obj.ptr) + ptr = JNI.NewLocalRef(penv, obj.ptr) ptr === C_NULL && geterror() return JavaObject{T}(ptr) end @@ -19,8 +19,8 @@ function convert(::Type{JavaObject{T}}, obj::JavaObject{S}) where {T,S} end #Is java type convertible from S to T. -isConvertible(T, S) = IsAssignableFrom(penv, metaclass(S).ptr, metaclass(T).ptr) == JNI_TRUE -isConvertible(T, S::Ptr{Nothing} ) = IsAssignableFrom(penv, S, metaclass(T).ptr) == JNI_TRUE +isConvertible(T, S) = JNI.IsAssignableFrom(penv, metaclass(S).ptr, metaclass(T).ptr) == JNI_TRUE +isConvertible(T, S::Ptr{Nothing} ) = JNI.IsAssignableFrom(penv, S, metaclass(T).ptr) == JNI_TRUE unsafe_convert(::Type{Ptr{Nothing}}, cls::JavaMetaClass) = cls.ptr @@ -59,21 +59,20 @@ function convert_arg(argtype::Type{T}, arg) where T<:JavaObject return x, x.ptr end -for (x, y, z) in [ (:jboolean, :(jnifunc.NewBooleanArray), :(jnifunc.SetBooleanArrayRegion)), - (:jchar, :(jnifunc.NewCharArray), :(jnifunc.SetCharArrayRegion)), - (:jbyte, :(jnifunc.NewByteArray), :(jnifunc.SetByteArrayRegion)), - (:jshort, :(jnifunc.NewShortArray), :(jnifunc.SetShortArrayRegion)), - (:jint, :(jnifunc.NewIntArray), :(jnifunc.SetIntArrayRegion)), - (:jlong, :(jnifunc.NewLongArray), :(jnifunc.SetLongArrayRegion)), - (:jfloat, :(jnifunc.NewFloatArray), :(jnifunc.SetFloatArrayRegion)), - (:jdouble, :(jnifunc.NewDoubleArray), :(jnifunc.SetDoubleArrayRegion)) ] +for (x, y, z) in [(:jboolean, :(JNI.NewBooleanArray), :(JNI.SetBooleanArrayRegion)), + (:jchar, :(JNI.NewCharArray), :(JNI.SetCharArrayRegion)) , + (:jbyte, :(JNI.NewByteArray), :(JNI.SetByteArrayRegion)) , + (:jshort, :(JNI.NewShortArray), :(JNI.SetShortArrayRegion)) , + (:jint, :(JNI.NewIntArray), :(JNI.SetIntArrayRegion)) , + (:jlong, :(JNI.NewLongArray), :(JNI.SetLongArrayRegion)) , + (:jfloat, :(JNI.NewFloatArray), :(JNI.SetFloatArrayRegion)) , + (:jdouble, :(JNI.NewDoubleArray), :(JNI.SetDoubleArrayRegion)) ] m = quote function convert_arg(argtype::Type{Array{$x,1}}, arg) carg = convert(argtype, arg) sz=length(carg) - arrayptr = ccall($y, Ptr{Nothing}, (Ptr{JNIEnv}, jint), penv, sz) - ccall($z, Nothing, (Ptr{JNIEnv}, Ptr{Nothing}, jint, jint, Ptr{$x}), penv, arrayptr, 0, sz, - carg) + arrayptr = $y(penv, sz) + $z(penv, arrayptr, 0, sz, carg) return carg, arrayptr end end @@ -84,9 +83,9 @@ function convert_arg(argtype::Type{Array{T,1}}, arg) where T<:JavaObject carg = convert(argtype, arg) sz = length(carg) init = carg[1] - arrayptr = NewObjectArray(penv, sz, metaclass(T).ptr, init.ptr) + arrayptr = JNI.NewObjectArray(penv, sz, metaclass(T).ptr, init.ptr) for i=2:sz - SetObjectArrayElement(penv, arrayptr, i-1, carg[i].ptr) + JNI.SetObjectArrayElement(penv, arrayptr, i-1, carg[i].ptr) end return carg, arrayptr end @@ -95,22 +94,21 @@ convert_result(rettype::Type{T}, result) where {T<:JString} = unsafe_string(JStr convert_result(rettype::Type{T}, result) where {T<:JavaObject} = T(result) convert_result(rettype, result) = result -for (x, y, z) in [(:jboolean, :(jnifunc.GetBooleanArrayElements), :(jnifunc.ReleaseBooleanArrayElements)), - (:jchar, :(jnifunc.GetCharArrayElements), :(jnifunc.ReleaseCharArrayElements)), - (:jbyte, :(jnifunc.GetByteArrayElements), :(jnifunc.ReleaseByteArrayElements)), - (:jshort, :(jnifunc.GetShortArrayElements), :(jnifunc.ReleaseShortArrayElements)), - (:jint, :(jnifunc.GetIntArrayElements), :(jnifunc.ReleaseIntArrayElements)), - (:jlong, :(jnifunc.GetLongArrayElements), :(jnifunc.ReleaseLongArrayElements)), - (:jfloat, :(jnifunc.GetFloatArrayElements), :(jnifunc.ReleaseFloatArrayElements)), - (:jdouble, :(jnifunc.GetDoubleArrayElements), :(jnifunc.ReleaseDoubleArrayElements)) ] +for (x, y, z) in [(:jboolean, :(JNI.GetBooleanArrayElements), :(JNI.ReleaseBooleanArrayElements)), + (:jchar, :(JNI.GetCharArrayElements), :(JNI.ReleaseCharArrayElements)) , + (:jbyte, :(JNI.GetByteArrayElements), :(JNI.ReleaseByteArrayElements)) , + (:jshort, :(JNI.GetShortArrayElements), :(JNI.ReleaseShortArrayElements)) , + (:jint, :(JNI.GetIntArrayElements), :(JNI.ReleaseIntArrayElements)) , + (:jlong, :(JNI.GetLongArrayElements), :(JNI.ReleaseLongArrayElements)) , + (:jfloat, :(JNI.GetFloatArrayElements), :(JNI.ReleaseFloatArrayElements)) , + (:jdouble, :(JNI.GetDoubleArrayElements), :(JNI.ReleaseDoubleArrayElements)) ] m = quote function convert_result(rettype::Type{Array{$(x),1}}, result) - sz = GetArrayLength(penv, result) - arr = ccall($(y), Ptr{$(x)}, (Ptr{JNIEnv}, Ptr{Nothing}, Ptr{jboolean} ), penv, result, - C_NULL) + sz = JNI.GetArrayLength(penv, result) + arr = $y(penv, result, Ptr{jboolean}(C_NULL)) jl_arr::Array = unsafe_wrap(Array, arr, Int(sz)) jl_arr = deepcopy(jl_arr) - ccall($(z), Nothing, (Ptr{JNIEnv},Ptr{Nothing}, Ptr{$(x)}, jint), penv, result, arr, 0) + $z(penv, result, arr, Int32(0)) return jl_arr end end @@ -118,12 +116,12 @@ for (x, y, z) in [(:jboolean, :(jnifunc.GetBooleanArrayElements), :(jnifunc.Rele end function convert_result(rettype::Type{Array{JavaObject{T},1}}, result) where T - sz = GetArrayLength(penv, result) + sz = JNI.GetArrayLength(penv, result) ret = Array{JavaObject{T}}(undef, sz) for i=1:sz - a=GetObjectArrayElement(penv, result, i-1) + a=JNI.GetObjectArrayElement(penv, result, i-1) ret[i] = JavaObject{T}(a) end return ret @@ -132,12 +130,12 @@ end # covers return types like Vector{Vector{T}} function convert_result(rettype::Type{Array{T,1}}, result) where T - sz = ccall(jnifunc.GetArrayLength, jint, (Ptr{JNIEnv}, Ptr{Nothing}), penv, result) + sz = JNI.GetArrayLength(penv, result) ret = Array{T}(undef, sz) for i=1:sz - a=ccall(jnifunc.GetObjectArrayElement, Ptr{Nothing}, (Ptr{JNIEnv},Ptr{Nothing}, jint), penv, result, i-1) + a=JNI.GetObjectArrayElement(penv, result, i-1) ret[i] = convert_result(T, a) end return ret @@ -145,23 +143,20 @@ end function convert_result(rettype::Type{Array{JavaObject{T},2}}, result) where T - sz = ccall(jnifunc.GetArrayLength, jint, (Ptr{JNIEnv}, Ptr{Nothing}), penv, result) + sz = JNI.GetArrayLength(penv, result) if sz == 0 return Array{T}(undef, 0,0) end - a_1 = ccall(jnifunc.GetObjectArrayElement, Ptr{Nothing}, (Ptr{JNIEnv},Ptr{Nothing}, jint), penv, - result, 0) - sz_1 = ccall(jnifunc.GetArrayLength, jint, (Ptr{JNIEnv}, Ptr{Nothing}), penv, a_1) + a_1 = JNI.GetObjectArrayElement(penv, result, 0) + sz_1 = JNI.GetArrayLength(penv, a_1) ret = Array{JavaObject{T}}(undef, sz, sz_1) for i=1:sz - a = ccall(jnifunc.GetObjectArrayElement, Ptr{Nothing}, (Ptr{JNIEnv},Ptr{Nothing}, jint), penv, - result, i-1) + a = JNI.GetObjectArrayElement(penv, result, i-1) # check that size of the current subarray is the same as for the first one - sz_a = ccall(jnifunc.GetArrayLength, jint, (Ptr{JNIEnv}, Ptr{Nothing}), penv, a) + sz_a = JNI.GetArrayLength(penv, a) @assert(sz_a == sz_1, "Size of $(i)th subrarray is $sz_a, but size of the 1st subarray was $sz_1") for j=1:sz_1 - x = ccall(jnifunc.GetObjectArrayElement, Ptr{Nothing}, (Ptr{JNIEnv},Ptr{Nothing}, jint), - penv, a, j-1) + x = JNI.GetObjectArrayElement(penv, a, j-1) ret[i, j] = JavaObject{T}(x) end end @@ -171,19 +166,17 @@ end # matrices of primitive types and other arrays function convert_result(rettype::Type{Array{T,2}}, result) where T - sz = ccall(jnifunc.GetArrayLength, jint, (Ptr{JNIEnv}, Ptr{Nothing}), penv, result) + sz = JNI.GetArrayLength(penv, result) if sz == 0 return Array{T}(undef, 0,0) end - a_1 = ccall(jnifunc.GetObjectArrayElement, Ptr{Nothing}, (Ptr{JNIEnv},Ptr{Nothing}, jint), penv, - result, 0) - sz_1 = ccall(jnifunc.GetArrayLength, jint, (Ptr{JNIEnv}, Ptr{Nothing}), penv, a_1) + a_1 = JNI.GetObjectArrayElement(penv, result, 0) + sz_1 = JNI.GetArrayLength(penv, a_1) ret = Array{T}(undef, sz, sz_1) for i=1:sz - a = ccall(jnifunc.GetObjectArrayElement, Ptr{Nothing}, (Ptr{JNIEnv},Ptr{Nothing}, jint), penv, - result, i-1) + a = JNI.GetObjectArrayElement(penv, result, i-1) # check that size of the current subarray is the same as for the first one - sz_a = ccall(jnifunc.GetArrayLength, jint, (Ptr{JNIEnv}, Ptr{Nothing}), penv, a) + sz_a = JNI.GetArrayLength(penv, a) @assert(sz_a == sz_1, "Size of $(i)th subrarray is $sz_a, but size of the 1st subarray was $sz_1") ret[i, :] = convert_result(Vector{T}, a) end @@ -259,28 +252,28 @@ end function unsafe_string(jstr::JString) #jstr must be a jstring obtained via a JNI call if isnull(jstr); return ""; end #Return empty string to keep type stability. But this is questionable pIsCopy = Array{jboolean}(undef, 1) - buf::Ptr{UInt8} = GetStringUTFChars(penv, jstr.ptr, pIsCopy) + #buf::Ptr{UInt8} = JNI.GetStringUTFChars(penv, jstr.ptr, pIsCopy) + buf = JNI.GetStringUTFChars(penv, jstr.ptr, pIsCopy) s = unsafe_string(buf) - ReleaseStringUTFChars(penv, jstr.ptr, buf) + JNI.ReleaseStringUTFChars(penv, jstr.ptr, buf) return s end -for (x, y, z) in [(:jboolean, :(jnifunc.GetBooleanArrayElements), :(jnifunc.ReleaseBooleanArrayElements)), - (:jchar, :(jnifunc.GetCharArrayElements), :(jnifunc.ReleaseCharArrayElements)), - (:jbyte, :(jnifunc.GetByteArrayElements), :(jnifunc.ReleaseByteArrayElements)), - (:jshort, :(jnifunc.GetShortArrayElements), :(jnifunc.ReleaseShortArrayElements)), - (:jint, :(jnifunc.GetIntArrayElements), :(jnifunc.ReleaseIntArrayElements)), - (:jlong, :(jnifunc.GetLongArrayElements), :(jnifunc.ReleaseLongArrayElements)), - (:jfloat, :(jnifunc.GetFloatArrayElements), :(jnifunc.ReleaseFloatArrayElements)), - (:jdouble, :(jnifunc.GetDoubleArrayElements), :(jnifunc.ReleaseDoubleArrayElements)) ] +for (x, y, z) in [(:jboolean, :(JNI.GetBooleanArrayElements), :(JNI.ReleaseBooleanArrayElements)), + (:jchar, :(JNI.GetCharArrayElements), :(JNI.ReleaseCharArrayElements)) , + (:jbyte, :(JNI.GetByteArrayElements), :(JNI.ReleaseByteArrayElements)) , + (:jshort, :(JNI.GetShortArrayElements), :(JNI.ReleaseShortArrayElements)) , + (:jint, :(JNI.GetIntArrayElements), :(JNI.ReleaseIntArrayElements)) , + (:jlong, :(JNI.GetLongArrayElements), :(JNI.ReleaseLongArrayElements)) , + (:jfloat, :(JNI.GetFloatArrayElements), :(JNI.ReleaseFloatArrayElements)) , + (:jdouble, :(JNI.GetDoubleArrayElements), :(JNI.ReleaseDoubleArrayElements)) ] m = quote function convert(::Type{Array{$(x),1}}, obj::JObject) - sz = ccall(jnifunc.GetArrayLength, jint, (Ptr{JNIEnv}, Ptr{Nothing}), penv, obj.ptr) - arr = ccall($(y), Ptr{$(x)}, (Ptr{JNIEnv}, Ptr{Nothing}, Ptr{jboolean}), penv, obj.ptr, - C_NULL) + sz = JNI.GetArrayLength(penv, obj.ptr) + arr = $y(penv, obj.ptr, Ptr{jboolean}(C_NULL)) jl_arr::Array = unsafe_wrap(Array, arr, Int(sz)) jl_arr = deepcopy(jl_arr) - ccall($(z), Nothing, (Ptr{JNIEnv},Ptr{Nothing}, Ptr{$(x)}, jint), penv, obj.ptr, arr, 0) + $z(penv, obj.ptr, arr, Int32(0)) return jl_arr end end @@ -289,12 +282,10 @@ end function convert(::Type{Array{T, 1}}, obj::JObject) where T - sz = ccall(jnifunc.GetArrayLength, jint, - (Ptr{JNIEnv}, Ptr{Nothing}), penv, obj.ptr) + sz = JNI.GetArrayLength(penv, obj.ptr) ret = Array{T}(undef, sz) for i=1:sz - ptr = ccall(jnifunc.GetObjectArrayElement, Ptr{Nothing}, - (Ptr{JNIEnv}, Ptr{Nothing}, jint), penv, obj.ptr, i-1) + ptr = JNI.GetObjectArrayElement(penv, obj.ptr, i-1) ret[i] = convert(T, JObject(ptr)) end return ret diff --git a/src/core.jl b/src/core.jl index 97ec9ff..f5548c8 100644 --- a/src/core.jl +++ b/src/core.jl @@ -26,8 +26,7 @@ JavaObject{T}() where {T} = JavaObject{T}((),) function deleteref(x::JavaObject) if x.ptr == C_NULL; return; end if (penv==C_NULL); return; end - #ccall(:jl_,Nothing,(Any,),x) - DeleteLocalRef(penv, x.ptr) + JNI.DeleteLocalRef(penv, x.ptr) x.ptr=C_NULL #Safety in case this function is called direcly, rather than at finalize return end @@ -70,7 +69,7 @@ const JClassLoader = JavaObject{Symbol("java.lang.ClassLoader")} const JString = JavaObject{Symbol("java.lang.String")} function JString(str::AbstractString) - jstring = NewStringUTF(penv, String(str)) + jstring = JNI.NewStringUTF(penv, String(str)) if jstring == C_NULL geterror() else @@ -108,11 +107,11 @@ end function jnew(T::Symbol, argtypes::Tuple, args...) assertroottask_or_goodenv() sig = method_signature(Nothing, argtypes...) - jmethodId = GetMethodID(penv, metaclass(T).ptr, String(""), sig) + jmethodId = JNI.GetMethodID(penv, metaclass(T).ptr, String(""), sig) if jmethodId == C_NULL throw(JavaCallError("No constructor for $T with signature $sig")) end - return _jcall(metaclass(T), jmethodId, jnifunc.NewObjectA, JavaObject{T}, argtypes, args...) + return _jcall(metaclass(T), jmethodId, JNI.NewObjectA, JavaObject{T}, argtypes, args...) end # Call static methods @@ -120,7 +119,7 @@ function jcall(typ::Type{JavaObject{T}}, method::AbstractString, rettype::Type, args... ) where T assertroottask_or_goodenv() sig = method_signature(rettype, argtypes...) - jmethodId = GetStaticMethodID(penv, metaclass(T).ptr, String(method), sig) + jmethodId = JNI.GetStaticMethodID(penv, metaclass(T).ptr, String(method), sig) jmethodId==C_NULL && geterror(true) _jcall(metaclass(T), jmethodId, C_NULL, rettype, argtypes, args...) end @@ -129,39 +128,38 @@ end function jcall(obj::JavaObject, method::AbstractString, rettype::Type, argtypes::Tuple, args... ) assertroottask_or_goodenv() sig = method_signature(rettype, argtypes...) - jmethodId = GetMethodID(penv, metaclass(obj).ptr, String(method), sig) + jmethodId = JNI.GetMethodID(penv, metaclass(obj).ptr, String(method), sig) jmethodId==C_NULL && geterror(true) _jcall(obj, jmethodId, C_NULL, rettype, argtypes, args...) end function jfield(typ::Type{JavaObject{T}}, field::AbstractString, fieldType::Type) where T assertroottask_or_goodenv() - jfieldID = GetStaticFieldID(penv, metaclass(T).ptr, String(field), signature(fieldType)) + jfieldID = JNI.GetStaticFieldID(penv, metaclass(T).ptr, String(field), signature(fieldType)) jfieldID==C_NULL && geterror(true) _jfield(metaclass(T), jfieldID, fieldType) end function jfield(obj::JavaObject, field::AbstractString, fieldType::Type) assertroottask_or_goodenv() - jfieldID = GetFieldID(penv, metaclass(obj).ptr, String(field), signature(fieldType)) + jfieldID = JNI.GetFieldID(penv, metaclass(obj).ptr, String(field), signature(fieldType)) jfieldID==C_NULL && geterror(true) _jfield(obj, jfieldID, fieldType) end -for (x, y, z) in [(:jboolean, :(jnifunc.GetBooleanField), :(jnifunc.GetStaticBooleanField)), - (:jchar, :(jnifunc.GetCharField), :(jnifunc.GetStaticCharField)), - (:jbyte, :(jnifunc.GetByteField), :(jnifunc.GetStaticBypeField)), - (:jshort, :(jnifunc.GetShortField), :(jnifunc.GetStaticShortField)), - (:jint, :(jnifunc.GetIntField), :(jnifunc.GetStaticIntField)), - (:jlong, :(jnifunc.GetLongField), :(jnifunc.GetStaticLongField)), - (:jfloat, :(jnifunc.GetFloatField), :(jnifunc.GetStaticFloatField)), - (:jdouble, :(jnifunc.GetDoubleField), :(jnifunc.GetStaticDoubleField)) ] +for (x, y, z) in [(:jboolean, :(JNI.GetBooleanField), :(JNI.GetStaticBooleanField)), + (:jchar, :(JNI.GetCharField), :(JNI.GetStaticCharField)) , + (:jbyte, :(JNI.GetByteField), :(JNI.GetStaticBypeField)) , + (:jshort, :(JNI.GetShortField), :(JNI.GetStaticShortField)) , + (:jint, :(JNI.GetIntField), :(JNI.GetStaticIntField)) , + (:jlong, :(JNI.GetLongField), :(JNI.GetStaticLongField)) , + (:jfloat, :(JNI.GetFloatField), :(JNI.GetStaticFloatField)) , + (:jdouble, :(JNI.GetDoubleField), :(JNI.GetStaticDoubleField)) ] m = quote function _jfield(obj, jfieldID::Ptr{Nothing}, fieldType::Type{$(x)}) callmethod = ifelse( typeof(obj)<:JavaObject, $y , $z ) - result = ccall(callmethod, $x, (Ptr{JNIEnv}, Ptr{Nothing}, Ptr{Nothing}), penv, obj.ptr, - jfieldID) + result = callmethod(penv, obj.ptr, jfieldID) result==C_NULL && geterror() return convert_result(fieldType, result) end @@ -170,24 +168,23 @@ for (x, y, z) in [(:jboolean, :(jnifunc.GetBooleanField), :(jnifunc.GetStaticBoo end function _jfield(obj, jfieldID::Ptr{Nothing}, fieldType::Type) - callmethod = ifelse( typeof(obj)<:JavaObject, jnifunc.GetObjectField , jnifunc.GetStaticObjectField ) - result = ccall(callmethod, Ptr{Nothing}, (Ptr{JNIEnv}, Ptr{Nothing}, Ptr{Nothing}), penv, obj.ptr, - jfieldID) + callmethod = ifelse( typeof(obj)<:JavaObject, JNI.GetObjectField , JNI.GetStaticObjectField ) + result = callmethod(penv, obj.ptr, jfieldID) result==C_NULL && geterror() return convert_result(fieldType, result) end #Generate these methods to satisfy ccall's compile time constant requirement #_jcall for primitive and Nothing return types -for (x, y, z) in [ (:jboolean, :(jnifunc.CallBooleanMethodA), :(jnifunc.CallStaticBooleanMethodA)), - (:jchar, :(jnifunc.CallCharMethodA), :(jnifunc.CallStaticCharMethodA)), - (:jbyte, :(jnifunc.CallByteMethodA), :(jnifunc.CallStaticByteMethodA)), - (:jshort, :(jnifunc.CallShortMethodA), :(jnifunc.CallStaticShortMethodA)), - (:jint, :(jnifunc.CallIntMethodA), :(jnifunc.CallStaticIntMethodA)), - (:jlong, :(jnifunc.CallLongMethodA), :(jnifunc.CallStaticLongMethodA)), - (:jfloat, :(jnifunc.CallFloatMethodA), :(jnifunc.CallStaticFloatMethodA)), - (:jdouble, :(jnifunc.CallDoubleMethodA), :(jnifunc.CallStaticDoubleMethodA)), - (:Nothing, :(jnifunc.CallVoidMethodA), :(jnifunc.CallStaticVoidMethodA)) ] +for (x, y, z) in [(:jboolean, :(JNI.CallBooleanMethodA), :(JNI.CallStaticBooleanMethodA)), + (:jchar, :(JNI.CallCharMethodA), :(JNI.CallStaticCharMethodA)) , + (:jbyte, :(JNI.CallByteMethodA), :(JNI.CallStaticByteMethodA)) , + (:jshort, :(JNI.CallShortMethodA), :(JNI.CallStaticShortMethodA)) , + (:jint, :(JNI.CallIntMethodA), :(JNI.CallStaticIntMethodA)) , + (:jlong, :(JNI.CallLongMethodA), :(JNI.CallStaticLongMethodA)) , + (:jfloat, :(JNI.CallFloatMethodA), :(JNI.CallStaticFloatMethodA)) , + (:jdouble, :(JNI.CallDoubleMethodA), :(JNI.CallStaticDoubleMethodA)) , + (:Nothing, :(JNI.CallVoidMethodA), :(JNI.CallStaticVoidMethodA)) ] m = quote function _jcall(obj, jmethodId::Ptr{Nothing}, callmethod::Ptr{Nothing}, rettype::Type{$(x)}, argtypes::Tuple, args...) @@ -198,7 +195,7 @@ for (x, y, z) in [ (:jboolean, :(jnifunc.CallBooleanMethodA), :(jnifunc.CallStat @assert jmethodId != C_NULL isnull(obj) && throw(JavaCallError("Attempt to call method on Java NULL")) savedArgs, convertedArgs = convert_args(argtypes, args...) - result = ccall(callmethod, $x , (Ptr{JNIEnv}, Ptr{Nothing}, Ptr{Nothing}, Ptr{Nothing}), penv, obj.ptr, jmethodId, convertedArgs) + result = callmethod(penv, obj.ptr, jmethodId, convertedArgs) result==C_NULL && geterror() result == nothing && (return) return convert_result(rettype, result) @@ -211,18 +208,18 @@ end #obj -- receiver - Class pointer or object prointer #jmethodId -- Java method ID #callmethod -- the C method pointer to call -function _jcall(obj, jmethodId::Ptr{Nothing}, callmethod::Ptr{Nothing}, rettype::Type, argtypes::Tuple, +function _jcall(obj, jmethodId::Ptr{Nothing}, callmethod::Union{Function,Ptr{Nothing}}, rettype::Type, argtypes::Tuple, args...) if callmethod == C_NULL - callmethod = ifelse(typeof(obj)<:JavaObject, jnifunc.CallObjectMethodA , - jnifunc.CallStaticObjectMethodA) + callmethod = ifelse(typeof(obj)<:JavaObject, + JNI.CallObjectMethodA , + JNI.CallStaticObjectMethodA) end @assert callmethod != C_NULL @assert jmethodId != C_NULL isnull(obj) && error("Attempt to call method on Java NULL") savedArgs, convertedArgs = convert_args(argtypes, args...) - result = ccall(callmethod, Ptr{Nothing}, (Ptr{JNIEnv}, Ptr{Nothing}, Ptr{Nothing}, Ptr{Nothing}), - penv, obj.ptr, jmethodId, convertedArgs) + result = callmethod(penv, obj.ptr, jmethodId, convertedArgs) result==C_NULL && geterror() return convert_result(rettype, result) end @@ -232,7 +229,7 @@ global const _jmc_cache = Dict{Symbol, JavaMetaClass}() function _metaclass(class::Symbol) jclass=javaclassname(class) - jclassptr = ccall(jnifunc.FindClass, Ptr{Nothing}, (Ptr{JNIEnv}, Ptr{UInt8}), penv, jclass) + jclassptr = JNI.FindClass(penv, jclass) jclassptr == C_NULL && throw(JavaCallError("Class Not Found $jclass")) return JavaMetaClass(class, jclassptr) end @@ -250,22 +247,21 @@ metaclass(::JavaObject{T}) where {T} = metaclass(T) javaclassname(class::Symbol) = replace(string(class), "."=>"/") function geterror(allow=false) - isexception = ExceptionCheck(penv) + isexception = JNI.ExceptionCheck(penv) if isexception == JNI_TRUE - jthrow = ExceptionOccurred(penv) - jthrow = ccall(jnifunc.ExceptionOccurred, Ptr{Nothing}, (Ptr{JNIEnv},), penv) + jthrow = JNI.ExceptionOccurred(penv) jthrow==C_NULL && throw(JavaCallError("Java Exception thrown, but no details could be retrieved from the JVM")) - ExceptionDescribe(penv ) #Print java stackstrace to stdout - ExceptionClear(penv ) - jclass = FindClass(penv, "java/lang/Throwable") + JNI.ExceptionDescribe(penv ) #Print java stackstrace to stdout + JNI.ExceptionClear(penv ) + jclass = JNI.FindClass(penv, "java/lang/Throwable") jclass==C_NULL && throw(JavaCallError("Java Exception thrown, but no details could be retrieved from the JVM")) - jmethodId=GetMethodID(penv, jclass, "toString", "()Ljava/lang/String;") + jmethodId=JNI.GetMethodID(penv, jclass, "toString", "()Ljava/lang/String;") jmethodId==C_NULL && throw(JavaCallError("Java Exception thrown, but no details could be retrieved from the JVM")) - res = CallObjectMethodA(penv, jthrow, jmethodId, Int[]) + res = JNI.CallObjectMethodA(penv, jthrow, jmethodId, Int[]) res==C_NULL && throw(JavaCallError("Java Exception thrown, but no details could be retrieved from the JVM")) msg = unsafe_string(JString(res)) - DeleteLocalRef(penv, jthrow) + JNI.DeleteLocalRef(penv, jthrow) throw(JavaCallError(string("Error calling Java: ",msg))) else if allow==false diff --git a/src/jnienv2.jl b/src/jnienv2.jl index e525473..91172e2 100644 --- a/src/jnienv2.jl +++ b/src/jnienv2.jl @@ -6,9 +6,13 @@ export JNINativeInterface, JNIEnv, JNIInvokeInterface, JavaVM, JavaCallError export jint, jlong, jbyte # jni.h exports export jboolean, jchar, jshort, jfloat, jdouble, jsize, jprimitive +# Legacy exports +export jnifunc include("jnienv.jl") +global jnifunc + # jni_md.h const jint = Cint #ifdef _LP64 /* 64-bit Solaris */ @@ -53,672 +57,685 @@ jvalue = Int64 JNIWeakGlobalRefType = 3 end -export GetVersion +# There is likely over specification here +PtrIsCopy = Union{Ptr{jboolean},Ref{jboolean},Array{jboolean,}} +AnyString = Union{AbstractString,Cstring,Ptr{UInt8}} + +function load_jni(penv::Ptr{JNIEnv}) + jnienv = unsafe_load(penv) + global jnifunc = unsafe_load(jnienv.JNINativeInterface_) #The JNI Function table +end +is_jni_loaded() = isdefined(JNI, :jnifunc) + +#export GetVersion GetVersion(env::Ptr{JNIEnv}) = - ccall(Main.JavaCall.jnifunc.GetVersion, jint, (Ptr{JNIEnv},), env) + ccall(jnifunc.GetVersion, jint, (Ptr{JNIEnv},), env) -export DefineClass +#export DefineClass DefineClass(env::Ptr{JNIEnv}, name::AbstractString, loader::jobject, buf::Array{jbyte,1}, len::Integer) = - ccall(Main.JavaCall.jnifunc.DefineClass, jclass, (Ptr{JNIEnv}, Cstring, jobject, Ptr{jbyte}, jsize,), env, String(name), loader, buf, len) + ccall(jnifunc.DefineClass, jclass, (Ptr{JNIEnv}, Cstring, jobject, Ptr{jbyte}, jsize,), env, String(name), loader, buf, len) -export FindClass +#export FindClass FindClass(env::Ptr{JNIEnv}, name::AbstractString) = - ccall(Main.JavaCall.jnifunc.FindClass, jclass, (Ptr{JNIEnv}, Cstring,), env, String(name)) + ccall(jnifunc.FindClass, jclass, (Ptr{JNIEnv}, Cstring,), env, String(name)) -export FromReflectedMethod +#export FromReflectedMethod FromReflectedMethod(env::Ptr{JNIEnv}, method::jobject) = - ccall(Main.JavaCall.jnifunc.FromReflectedMethod, jmethodID, (Ptr{JNIEnv}, jobject,), env, method) + ccall(jnifunc.FromReflectedMethod, jmethodID, (Ptr{JNIEnv}, jobject,), env, method) -export FromReflectedField +#export FromReflectedField FromReflectedField(env::Ptr{JNIEnv}, field::jobject) = - ccall(Main.JavaCall.jnifunc.FromReflectedField, jfieldID, (Ptr{JNIEnv}, jobject,), env, field) + ccall(jnifunc.FromReflectedField, jfieldID, (Ptr{JNIEnv}, jobject,), env, field) -export ToReflectedMethod +#export ToReflectedMethod ToReflectedMethod(env::Ptr{JNIEnv}, cls::jclass, methodID::jmethodID, isStatic::jboolean) = - ccall(Main.JavaCall.jnifunc.ToReflectedMethod, jobject, (Ptr{JNIEnv}, jclass, jmethodID, jboolean,), env, cls, methodID, isStatic) + ccall(jnifunc.ToReflectedMethod, jobject, (Ptr{JNIEnv}, jclass, jmethodID, jboolean,), env, cls, methodID, isStatic) -export GetSuperclass +#export GetSuperclass GetSuperclass(env::Ptr{JNIEnv}, sub::jclass) = - ccall(Main.JavaCall.jnifunc.GetSuperclass, jclass, (Ptr{JNIEnv}, jclass,), env, sub) + ccall(jnifunc.GetSuperclass, jclass, (Ptr{JNIEnv}, jclass,), env, sub) -export IsAssignableFrom +#export IsAssignableFrom IsAssignableFrom(env::Ptr{JNIEnv}, sub::jclass, sup::jclass) = - ccall(Main.JavaCall.jnifunc.IsAssignableFrom, jboolean, (Ptr{JNIEnv}, jclass, jclass,), env, sub, sup) + ccall(jnifunc.IsAssignableFrom, jboolean, (Ptr{JNIEnv}, jclass, jclass,), env, sub, sup) -export ToReflectedField +#export ToReflectedField ToReflectedField(env::Ptr{JNIEnv}, cls::jclass, fieldID::jfieldID, isStatic::jboolean) = - ccall(Main.JavaCall.jnifunc.ToReflectedField, jobject, (Ptr{JNIEnv}, jclass, jfieldID, jboolean,), env, cls, fieldID, isStatic) + ccall(jnifunc.ToReflectedField, jobject, (Ptr{JNIEnv}, jclass, jfieldID, jboolean,), env, cls, fieldID, isStatic) -export Throw +#export Throw Throw(env::Ptr{JNIEnv}, obj::jthrowable) = - ccall(Main.JavaCall.jnifunc.Throw, jint, (Ptr{JNIEnv}, jthrowable,), env, obj) + ccall(jnifunc.Throw, jint, (Ptr{JNIEnv}, jthrowable,), env, obj) -export ThrowNew +#export ThrowNew ThrowNew(env::Ptr{JNIEnv}, clazz::jclass, msg::AbstractString) = - ccall(Main.JavaCall.jnifunc.ThrowNew, jint, (Ptr{JNIEnv}, jclass, Cstring,), env, clazz, String(msg)) + ccall(jnifunc.ThrowNew, jint, (Ptr{JNIEnv}, jclass, Cstring,), env, clazz, String(msg)) -export ExceptionOccurred +#export ExceptionOccurred ExceptionOccurred(env::Ptr{JNIEnv}) = - ccall(Main.JavaCall.jnifunc.ExceptionOccurred, jthrowable, (Ptr{JNIEnv},), env) + ccall(jnifunc.ExceptionOccurred, jthrowable, (Ptr{JNIEnv},), env) -export ExceptionDescribe +#export ExceptionDescribe ExceptionDescribe(env::Ptr{JNIEnv}) = - ccall(Main.JavaCall.jnifunc.ExceptionDescribe, Nothing, (Ptr{JNIEnv},), env) + ccall(jnifunc.ExceptionDescribe, Nothing, (Ptr{JNIEnv},), env) -export ExceptionClear +#export ExceptionClear ExceptionClear(env::Ptr{JNIEnv}) = - ccall(Main.JavaCall.jnifunc.ExceptionClear, Nothing, (Ptr{JNIEnv},), env) + ccall(jnifunc.ExceptionClear, Nothing, (Ptr{JNIEnv},), env) -export FatalError +#export FatalError FatalError(env::Ptr{JNIEnv}, msg::AbstractString) = - ccall(Main.JavaCall.jnifunc.FatalError, Nothing, (Ptr{JNIEnv}, Cstring,), env, String(msg)) + ccall(jnifunc.FatalError, Nothing, (Ptr{JNIEnv}, Cstring,), env, String(msg)) -export PushLocalFrame +#export PushLocalFrame PushLocalFrame(env::Ptr{JNIEnv}, capacity::jint) = - ccall(Main.JavaCall.jnifunc.PushLocalFrame, jint, (Ptr{JNIEnv}, jint,), env, capacity) + ccall(jnifunc.PushLocalFrame, jint, (Ptr{JNIEnv}, jint,), env, capacity) -export PopLocalFrame +#export PopLocalFrame PopLocalFrame(env::Ptr{JNIEnv}, result::jobject) = - ccall(Main.JavaCall.jnifunc.PopLocalFrame, jobject, (Ptr{JNIEnv}, jobject,), env, result) + ccall(jnifunc.PopLocalFrame, jobject, (Ptr{JNIEnv}, jobject,), env, result) -export NewGlobalRef +#export NewGlobalRef NewGlobalRef(env::Ptr{JNIEnv}, lobj::jobject) = - ccall(Main.JavaCall.jnifunc.NewGlobalRef, jobject, (Ptr{JNIEnv}, jobject,), env, lobj) + ccall(jnifunc.NewGlobalRef, jobject, (Ptr{JNIEnv}, jobject,), env, lobj) -export DeleteGlobalRef +#export DeleteGlobalRef DeleteGlobalRef(env::Ptr{JNIEnv}, gref::jobject) = - ccall(Main.JavaCall.jnifunc.DeleteGlobalRef, Nothing, (Ptr{JNIEnv}, jobject,), env, gref) + ccall(jnifunc.DeleteGlobalRef, Nothing, (Ptr{JNIEnv}, jobject,), env, gref) -export DeleteLocalRef +#export DeleteLocalRef DeleteLocalRef(env::Ptr{JNIEnv}, obj::jobject) = - ccall(Main.JavaCall.jnifunc.DeleteLocalRef, Nothing, (Ptr{JNIEnv}, jobject,), env, obj) + ccall(jnifunc.DeleteLocalRef, Nothing, (Ptr{JNIEnv}, jobject,), env, obj) -export IsSameObject +#export IsSameObject IsSameObject(env::Ptr{JNIEnv}, obj1::jobject, obj2::jobject) = - ccall(Main.JavaCall.jnifunc.IsSameObject, jboolean, (Ptr{JNIEnv}, jobject, jobject,), env, obj1, obj2) + ccall(jnifunc.IsSameObject, jboolean, (Ptr{JNIEnv}, jobject, jobject,), env, obj1, obj2) -export NewLocalRef +#export NewLocalRef NewLocalRef(env::Ptr{JNIEnv}, ref::jobject) = - ccall(Main.JavaCall.jnifunc.NewLocalRef, jobject, (Ptr{JNIEnv}, jobject,), env, ref) + ccall(jnifunc.NewLocalRef, jobject, (Ptr{JNIEnv}, jobject,), env, ref) -export EnsureLocalCapacity +#export EnsureLocalCapacity EnsureLocalCapacity(env::Ptr{JNIEnv}, capacity::jint) = - ccall(Main.JavaCall.jnifunc.EnsureLocalCapacity, jint, (Ptr{JNIEnv}, jint,), env, capacity) + ccall(jnifunc.EnsureLocalCapacity, jint, (Ptr{JNIEnv}, jint,), env, capacity) -export AllocObject +#export AllocObject AllocObject(env::Ptr{JNIEnv}, clazz::jclass) = - ccall(Main.JavaCall.jnifunc.AllocObject, jobject, (Ptr{JNIEnv}, jclass,), env, clazz) + ccall(jnifunc.AllocObject, jobject, (Ptr{JNIEnv}, jclass,), env, clazz) -export NewObjectA +#export NewObjectA NewObjectA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(Main.JavaCall.jnifunc.NewObjectA, jobject, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) + ccall(jnifunc.NewObjectA, jobject, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) -export GetObjectClass +#export GetObjectClass GetObjectClass(env::Ptr{JNIEnv}, obj::jobject) = - ccall(Main.JavaCall.jnifunc.GetObjectClass, jclass, (Ptr{JNIEnv}, jobject,), env, obj) + ccall(jnifunc.GetObjectClass, jclass, (Ptr{JNIEnv}, jobject,), env, obj) -export IsInstanceOf +#export IsInstanceOf IsInstanceOf(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass) = - ccall(Main.JavaCall.jnifunc.IsInstanceOf, jboolean, (Ptr{JNIEnv}, jobject, jclass,), env, obj, clazz) + ccall(jnifunc.IsInstanceOf, jboolean, (Ptr{JNIEnv}, jobject, jclass,), env, obj, clazz) -export GetMethodID +#export GetMethodID GetMethodID(env::Ptr{JNIEnv}, clazz::jclass, name::AbstractString, sig::AbstractString) = - ccall(Main.JavaCall.jnifunc.GetMethodID, jmethodID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), env, clazz, String(name), String(sig)) + ccall(jnifunc.GetMethodID, jmethodID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), env, clazz, String(name), String(sig)) -export CallObjectMethodA +#export CallObjectMethodA CallObjectMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(Main.JavaCall.jnifunc.CallObjectMethodA, jobject, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) + ccall(jnifunc.CallObjectMethodA, jobject, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) -export CallBooleanMethodA +#export CallBooleanMethodA CallBooleanMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(Main.JavaCall.jnifunc.CallBooleanMethodA, jboolean, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) + ccall(jnifunc.CallBooleanMethodA, jboolean, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) -export CallByteMethodA +#export CallByteMethodA CallByteMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(Main.JavaCall.jnifunc.CallByteMethodA, jbyte, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) + ccall(jnifunc.CallByteMethodA, jbyte, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) -export CallCharMethodA +#export CallCharMethodA CallCharMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(Main.JavaCall.jnifunc.CallCharMethodA, jchar, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) + ccall(jnifunc.CallCharMethodA, jchar, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) -export CallShortMethodA +#export CallShortMethodA CallShortMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(Main.JavaCall.jnifunc.CallShortMethodA, jshort, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) + ccall(jnifunc.CallShortMethodA, jshort, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) -export CallIntMethodA +#export CallIntMethodA CallIntMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(Main.JavaCall.jnifunc.CallIntMethodA, jint, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) + ccall(jnifunc.CallIntMethodA, jint, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) -export CallLongMethodA +#export CallLongMethodA CallLongMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(Main.JavaCall.jnifunc.CallLongMethodA, jlong, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) + ccall(jnifunc.CallLongMethodA, jlong, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) -export CallFloatMethodA +#export CallFloatMethodA CallFloatMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(Main.JavaCall.jnifunc.CallFloatMethodA, jfloat, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) + ccall(jnifunc.CallFloatMethodA, jfloat, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) -export CallDoubleMethodA +#export CallDoubleMethodA CallDoubleMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(Main.JavaCall.jnifunc.CallDoubleMethodA, jdouble, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) + ccall(jnifunc.CallDoubleMethodA, jdouble, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) -export CallVoidMethodA +#export CallVoidMethodA CallVoidMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(Main.JavaCall.jnifunc.CallVoidMethodA, Nothing, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) + ccall(jnifunc.CallVoidMethodA, Nothing, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) -export CallNonvirtualObjectMethodA +#export CallNonvirtualObjectMethodA CallNonvirtualObjectMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(Main.JavaCall.jnifunc.CallNonvirtualObjectMethodA, jobject, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) + ccall(jnifunc.CallNonvirtualObjectMethodA, jobject, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) -export CallNonvirtualBooleanMethodA +#export CallNonvirtualBooleanMethodA CallNonvirtualBooleanMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(Main.JavaCall.jnifunc.CallNonvirtualBooleanMethodA, jboolean, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) + ccall(jnifunc.CallNonvirtualBooleanMethodA, jboolean, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) -export CallNonvirtualByteMethodA +#export CallNonvirtualByteMethodA CallNonvirtualByteMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(Main.JavaCall.jnifunc.CallNonvirtualByteMethodA, jbyte, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) + ccall(jnifunc.CallNonvirtualByteMethodA, jbyte, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) -export CallNonvirtualCharMethodA +#export CallNonvirtualCharMethodA CallNonvirtualCharMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(Main.JavaCall.jnifunc.CallNonvirtualCharMethodA, jchar, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) + ccall(jnifunc.CallNonvirtualCharMethodA, jchar, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) -export CallNonvirtualShortMethodA +#export CallNonvirtualShortMethodA CallNonvirtualShortMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(Main.JavaCall.jnifunc.CallNonvirtualShortMethodA, jshort, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) + ccall(jnifunc.CallNonvirtualShortMethodA, jshort, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) -export CallNonvirtualIntMethodA +#export CallNonvirtualIntMethodA CallNonvirtualIntMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(Main.JavaCall.jnifunc.CallNonvirtualIntMethodA, jint, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) + ccall(jnifunc.CallNonvirtualIntMethodA, jint, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) -export CallNonvirtualLongMethodA +#export CallNonvirtualLongMethodA CallNonvirtualLongMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(Main.JavaCall.jnifunc.CallNonvirtualLongMethodA, jlong, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) + ccall(jnifunc.CallNonvirtualLongMethodA, jlong, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) -export CallNonvirtualFloatMethodA +#export CallNonvirtualFloatMethodA CallNonvirtualFloatMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(Main.JavaCall.jnifunc.CallNonvirtualFloatMethodA, jfloat, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) + ccall(jnifunc.CallNonvirtualFloatMethodA, jfloat, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) -export CallNonvirtualDoubleMethodA +#export CallNonvirtualDoubleMethodA CallNonvirtualDoubleMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(Main.JavaCall.jnifunc.CallNonvirtualDoubleMethodA, jdouble, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) + ccall(jnifunc.CallNonvirtualDoubleMethodA, jdouble, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) -export CallNonvirtualVoidMethodA +#export CallNonvirtualVoidMethodA CallNonvirtualVoidMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(Main.JavaCall.jnifunc.CallNonvirtualVoidMethodA, Nothing, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) + ccall(jnifunc.CallNonvirtualVoidMethodA, Nothing, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) -export GetFieldID +#export GetFieldID GetFieldID(env::Ptr{JNIEnv}, clazz::jclass, name::AbstractString, sig::AbstractString) = - ccall(Main.JavaCall.jnifunc.GetFieldID, jfieldID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), env, clazz, String(name), String(sig)) + ccall(jnifunc.GetFieldID, jfieldID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), env, clazz, String(name), String(sig)) -export GetObjectField +#export GetObjectField GetObjectField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = - ccall(Main.JavaCall.jnifunc.GetObjectField, jobject, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) + ccall(jnifunc.GetObjectField, jobject, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) -export GetBooleanField +#export GetBooleanField GetBooleanField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = - ccall(Main.JavaCall.jnifunc.GetBooleanField, jboolean, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) + ccall(jnifunc.GetBooleanField, jboolean, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) -export GetByteField +#export GetByteField GetByteField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = - ccall(Main.JavaCall.jnifunc.GetByteField, jbyte, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) + ccall(jnifunc.GetByteField, jbyte, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) -export GetCharField +#export GetCharField GetCharField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = - ccall(Main.JavaCall.jnifunc.GetCharField, jchar, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) + ccall(jnifunc.GetCharField, jchar, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) -export GetShortField +#export GetShortField GetShortField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = - ccall(Main.JavaCall.jnifunc.GetShortField, jshort, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) + ccall(jnifunc.GetShortField, jshort, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) -export GetIntField +#export GetIntField GetIntField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = - ccall(Main.JavaCall.jnifunc.GetIntField, jint, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) + ccall(jnifunc.GetIntField, jint, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) -export GetLongField +#export GetLongField GetLongField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = - ccall(Main.JavaCall.jnifunc.GetLongField, jlong, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) + ccall(jnifunc.GetLongField, jlong, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) -export GetFloatField +#export GetFloatField GetFloatField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = - ccall(Main.JavaCall.jnifunc.GetFloatField, jfloat, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) + ccall(jnifunc.GetFloatField, jfloat, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) -export GetDoubleField +#export GetDoubleField GetDoubleField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = - ccall(Main.JavaCall.jnifunc.GetDoubleField, jdouble, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) + ccall(jnifunc.GetDoubleField, jdouble, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) -export SetObjectField +#export SetObjectField SetObjectField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jobject) = - ccall(Main.JavaCall.jnifunc.SetObjectField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jobject,), env, obj, fieldID, val) + ccall(jnifunc.SetObjectField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jobject,), env, obj, fieldID, val) -export SetBooleanField +#export SetBooleanField SetBooleanField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jboolean) = - ccall(Main.JavaCall.jnifunc.SetBooleanField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jboolean,), env, obj, fieldID, val) + ccall(jnifunc.SetBooleanField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jboolean,), env, obj, fieldID, val) -export SetByteField +#export SetByteField SetByteField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jbyte) = - ccall(Main.JavaCall.jnifunc.SetByteField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jbyte,), env, obj, fieldID, val) + ccall(jnifunc.SetByteField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jbyte,), env, obj, fieldID, val) -export SetCharField +#export SetCharField SetCharField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jchar) = - ccall(Main.JavaCall.jnifunc.SetCharField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jchar,), env, obj, fieldID, val) + ccall(jnifunc.SetCharField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jchar,), env, obj, fieldID, val) -export SetShortField +#export SetShortField SetShortField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jshort) = - ccall(Main.JavaCall.jnifunc.SetShortField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jshort,), env, obj, fieldID, val) + ccall(jnifunc.SetShortField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jshort,), env, obj, fieldID, val) -export SetIntField +#export SetIntField SetIntField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jint) = - ccall(Main.JavaCall.jnifunc.SetIntField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jint,), env, obj, fieldID, val) + ccall(jnifunc.SetIntField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jint,), env, obj, fieldID, val) -export SetLongField +#export SetLongField SetLongField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jlong) = - ccall(Main.JavaCall.jnifunc.SetLongField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jlong,), env, obj, fieldID, val) + ccall(jnifunc.SetLongField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jlong,), env, obj, fieldID, val) -export SetFloatField +#export SetFloatField SetFloatField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jfloat) = - ccall(Main.JavaCall.jnifunc.SetFloatField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jfloat,), env, obj, fieldID, val) + ccall(jnifunc.SetFloatField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jfloat,), env, obj, fieldID, val) -export SetDoubleField +#export SetDoubleField SetDoubleField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jdouble) = - ccall(Main.JavaCall.jnifunc.SetDoubleField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jdouble,), env, obj, fieldID, val) + ccall(jnifunc.SetDoubleField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jdouble,), env, obj, fieldID, val) -export GetStaticMethodID +#export GetStaticMethodID GetStaticMethodID(env::Ptr{JNIEnv}, clazz::jclass, name::AbstractString, sig::AbstractString) = - ccall(Main.JavaCall.jnifunc.GetStaticMethodID, jmethodID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), env, clazz, String(name), String(sig)) + ccall(jnifunc.GetStaticMethodID, jmethodID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), env, clazz, String(name), String(sig)) -export CallStaticObjectMethodA +#export CallStaticObjectMethodA CallStaticObjectMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(Main.JavaCall.jnifunc.CallStaticObjectMethodA, jobject, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) + ccall(jnifunc.CallStaticObjectMethodA, jobject, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) -export CallStaticBooleanMethodA +#export CallStaticBooleanMethodA CallStaticBooleanMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(Main.JavaCall.jnifunc.CallStaticBooleanMethodA, jboolean, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) + ccall(jnifunc.CallStaticBooleanMethodA, jboolean, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) -export CallStaticByteMethodA +#export CallStaticByteMethodA CallStaticByteMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(Main.JavaCall.jnifunc.CallStaticByteMethodA, jbyte, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) + ccall(jnifunc.CallStaticByteMethodA, jbyte, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) -export CallStaticCharMethodA +#export CallStaticCharMethodA CallStaticCharMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(Main.JavaCall.jnifunc.CallStaticCharMethodA, jchar, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) + ccall(jnifunc.CallStaticCharMethodA, jchar, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) -export CallStaticShortMethodA +#export CallStaticShortMethodA CallStaticShortMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(Main.JavaCall.jnifunc.CallStaticShortMethodA, jshort, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) + ccall(jnifunc.CallStaticShortMethodA, jshort, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) -export CallStaticIntMethodA +#export CallStaticIntMethodA CallStaticIntMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(Main.JavaCall.jnifunc.CallStaticIntMethodA, jint, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) + ccall(jnifunc.CallStaticIntMethodA, jint, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) -export CallStaticLongMethodA +#export CallStaticLongMethodA CallStaticLongMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(Main.JavaCall.jnifunc.CallStaticLongMethodA, jlong, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) + ccall(jnifunc.CallStaticLongMethodA, jlong, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) -export CallStaticFloatMethodA +#export CallStaticFloatMethodA CallStaticFloatMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(Main.JavaCall.jnifunc.CallStaticFloatMethodA, jfloat, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) + ccall(jnifunc.CallStaticFloatMethodA, jfloat, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) -export CallStaticDoubleMethodA +#export CallStaticDoubleMethodA CallStaticDoubleMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(Main.JavaCall.jnifunc.CallStaticDoubleMethodA, jdouble, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) + ccall(jnifunc.CallStaticDoubleMethodA, jdouble, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) -export CallStaticVoidMethodA +#export CallStaticVoidMethodA CallStaticVoidMethodA(env::Ptr{JNIEnv}, cls::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(Main.JavaCall.jnifunc.CallStaticVoidMethodA, Nothing, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, cls, methodID, args) + ccall(jnifunc.CallStaticVoidMethodA, Nothing, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, cls, methodID, args) -export GetStaticFieldID +#export GetStaticFieldID GetStaticFieldID(env::Ptr{JNIEnv}, clazz::jclass, name::AbstractString, sig::AbstractString) = - ccall(Main.JavaCall.jnifunc.GetStaticFieldID, jfieldID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), env, clazz, String(name), String(sig)) + ccall(jnifunc.GetStaticFieldID, jfieldID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), env, clazz, String(name), String(sig)) -export GetStaticObjectField +#export GetStaticObjectField GetStaticObjectField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = - ccall(Main.JavaCall.jnifunc.GetStaticObjectField, jobject, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) + ccall(jnifunc.GetStaticObjectField, jobject, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) -export GetStaticBooleanField +#export GetStaticBooleanField GetStaticBooleanField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = - ccall(Main.JavaCall.jnifunc.GetStaticBooleanField, jboolean, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) + ccall(jnifunc.GetStaticBooleanField, jboolean, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) -export GetStaticByteField +#export GetStaticByteField GetStaticByteField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = - ccall(Main.JavaCall.jnifunc.GetStaticByteField, jbyte, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) + ccall(jnifunc.GetStaticByteField, jbyte, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) -export GetStaticCharField +#export GetStaticCharField GetStaticCharField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = - ccall(Main.JavaCall.jnifunc.GetStaticCharField, jchar, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) + ccall(jnifunc.GetStaticCharField, jchar, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) -export GetStaticShortField +#export GetStaticShortField GetStaticShortField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = - ccall(Main.JavaCall.jnifunc.GetStaticShortField, jshort, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) + ccall(jnifunc.GetStaticShortField, jshort, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) -export GetStaticIntField +#export GetStaticIntField GetStaticIntField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = - ccall(Main.JavaCall.jnifunc.GetStaticIntField, jint, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) + ccall(jnifunc.GetStaticIntField, jint, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) -export GetStaticLongField +#export GetStaticLongField GetStaticLongField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = - ccall(Main.JavaCall.jnifunc.GetStaticLongField, jlong, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) + ccall(jnifunc.GetStaticLongField, jlong, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) -export GetStaticFloatField +#export GetStaticFloatField GetStaticFloatField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = - ccall(Main.JavaCall.jnifunc.GetStaticFloatField, jfloat, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) + ccall(jnifunc.GetStaticFloatField, jfloat, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) -export GetStaticDoubleField +#export GetStaticDoubleField GetStaticDoubleField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = - ccall(Main.JavaCall.jnifunc.GetStaticDoubleField, jdouble, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) + ccall(jnifunc.GetStaticDoubleField, jdouble, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) -export SetStaticObjectField +#export SetStaticObjectField SetStaticObjectField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jobject) = - ccall(Main.JavaCall.jnifunc.SetStaticObjectField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jobject,), env, clazz, fieldID, value) + ccall(jnifunc.SetStaticObjectField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jobject,), env, clazz, fieldID, value) -export SetStaticBooleanField +#export SetStaticBooleanField SetStaticBooleanField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jboolean) = - ccall(Main.JavaCall.jnifunc.SetStaticBooleanField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jboolean,), env, clazz, fieldID, value) + ccall(jnifunc.SetStaticBooleanField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jboolean,), env, clazz, fieldID, value) -export SetStaticByteField +#export SetStaticByteField SetStaticByteField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jbyte) = - ccall(Main.JavaCall.jnifunc.SetStaticByteField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jbyte,), env, clazz, fieldID, value) + ccall(jnifunc.SetStaticByteField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jbyte,), env, clazz, fieldID, value) -export SetStaticCharField +#export SetStaticCharField SetStaticCharField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jchar) = - ccall(Main.JavaCall.jnifunc.SetStaticCharField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jchar,), env, clazz, fieldID, value) + ccall(jnifunc.SetStaticCharField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jchar,), env, clazz, fieldID, value) -export SetStaticShortField +#export SetStaticShortField SetStaticShortField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jshort) = - ccall(Main.JavaCall.jnifunc.SetStaticShortField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jshort,), env, clazz, fieldID, value) + ccall(jnifunc.SetStaticShortField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jshort,), env, clazz, fieldID, value) -export SetStaticIntField +#export SetStaticIntField SetStaticIntField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jint) = - ccall(Main.JavaCall.jnifunc.SetStaticIntField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jint,), env, clazz, fieldID, value) + ccall(jnifunc.SetStaticIntField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jint,), env, clazz, fieldID, value) -export SetStaticLongField +#export SetStaticLongField SetStaticLongField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jlong) = - ccall(Main.JavaCall.jnifunc.SetStaticLongField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jlong,), env, clazz, fieldID, value) + ccall(jnifunc.SetStaticLongField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jlong,), env, clazz, fieldID, value) -export SetStaticFloatField +#export SetStaticFloatField SetStaticFloatField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jfloat) = - ccall(Main.JavaCall.jnifunc.SetStaticFloatField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jfloat,), env, clazz, fieldID, value) + ccall(jnifunc.SetStaticFloatField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jfloat,), env, clazz, fieldID, value) -export SetStaticDoubleField +#export SetStaticDoubleField SetStaticDoubleField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jdouble) = - ccall(Main.JavaCall.jnifunc.SetStaticDoubleField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jdouble,), env, clazz, fieldID, value) + ccall(jnifunc.SetStaticDoubleField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jdouble,), env, clazz, fieldID, value) -export NewString +#export NewString NewString(env::Ptr{JNIEnv}, unicode::Array{jchar,1}, len::Integer) = - ccall(Main.JavaCall.jnifunc.NewString, jstring, (Ptr{JNIEnv}, Ptr{jchar}, jsize,), env, unicode, len) + ccall(jnifunc.NewString, jstring, (Ptr{JNIEnv}, Ptr{jchar}, jsize,), env, unicode, len) -export GetStringLength +#export GetStringLength GetStringLength(env::Ptr{JNIEnv}, str::jstring) = - ccall(Main.JavaCall.jnifunc.GetStringLength, jsize, (Ptr{JNIEnv}, jstring,), env, str) + ccall(jnifunc.GetStringLength, jsize, (Ptr{JNIEnv}, jstring,), env, str) -export GetStringChars -GetStringChars(env::Ptr{JNIEnv}, str::jstring, isCopy::Array{jboolean,1}) = - ccall(Main.JavaCall.jnifunc.GetStringChars, Ptr{jchar}, (Ptr{JNIEnv}, jstring, Ptr{jboolean},), env, str, isCopy) +#export GetStringChars +GetStringChars(env::Ptr{JNIEnv}, str::jstring, isCopy::PtrIsCopy) = + ccall(jnifunc.GetStringChars, Ptr{jchar}, (Ptr{JNIEnv}, jstring, Ptr{jboolean},), env, str, isCopy) -export ReleaseStringChars +#export ReleaseStringChars ReleaseStringChars(env::Ptr{JNIEnv}, str::jstring, chars::Array{jchar,1}) = - ccall(Main.JavaCall.jnifunc.ReleaseStringChars, Nothing, (Ptr{JNIEnv}, jstring, Ptr{jchar},), env, str, chars) + ccall(jnifunc.ReleaseStringChars, Nothing, (Ptr{JNIEnv}, jstring, Ptr{jchar},), env, str, chars) -export NewStringUTF +#export NewStringUTF NewStringUTF(env::Ptr{JNIEnv}, utf::AbstractString) = - ccall(Main.JavaCall.jnifunc.NewStringUTF, jstring, (Ptr{JNIEnv}, Cstring,), env, String(utf)) + ccall(jnifunc.NewStringUTF, jstring, (Ptr{JNIEnv}, Cstring,), env, String(utf)) -export GetStringUTFLength +#export GetStringUTFLength GetStringUTFLength(env::Ptr{JNIEnv}, str::jstring) = - ccall(Main.JavaCall.jnifunc.GetStringUTFLength, jsize, (Ptr{JNIEnv}, jstring,), env, str) + ccall(jnifunc.GetStringUTFLength, jsize, (Ptr{JNIEnv}, jstring,), env, str) -export GetStringUTFChars -GetStringUTFChars(env::Ptr{JNIEnv}, str::jstring, isCopy::Array{jboolean,1}) = - ccall(Main.JavaCall.jnifunc.GetStringUTFChars, Cstring, (Ptr{JNIEnv}, jstring, Ptr{jboolean},), env, str, isCopy) +#export GetStringUTFChars +GetStringUTFChars(env::Ptr{JNIEnv}, str::jstring, isCopy::PtrIsCopy) = + ccall(jnifunc.GetStringUTFChars, Cstring, (Ptr{JNIEnv}, jstring, Ptr{jboolean},), env, str, isCopy) -export ReleaseStringUTFChars -ReleaseStringUTFChars(env::Ptr{JNIEnv}, str::jstring, chars::Ptr{UInt8}) = - ccall(Main.JavaCall.jnifunc.ReleaseStringUTFChars, Nothing, (Ptr{JNIEnv}, jstring, Ptr{UInt8},), env, str, chars) +#export ReleaseStringUTFChars +## Prior to this module we used UInt8 instead of Cstring, must match return value of above +#ReleaseStringUTFChars(env::Ptr{JNIEnv}, str::jstring, chars::Ptr{UInt8}) = +# ccall(jnifunc.ReleaseStringUTFChars, Nothing, (Ptr{JNIEnv}, jstring, Ptr{UInt8},), env, str, chars) +ReleaseStringUTFChars(env::Ptr{JNIEnv}, str::jstring, chars::Cstring) = + ccall(jnifunc.ReleaseStringUTFChars, Nothing, (Ptr{JNIEnv}, jstring, Cstring,), env, str, chars) -export GetArrayLength +#export GetArrayLength GetArrayLength(env::Ptr{JNIEnv}, array::jarray) = - ccall(Main.JavaCall.jnifunc.GetArrayLength, jsize, (Ptr{JNIEnv}, jarray,), env, array) + ccall(jnifunc.GetArrayLength, jsize, (Ptr{JNIEnv}, jarray,), env, array) -export NewObjectArray +#export NewObjectArray NewObjectArray(env::Ptr{JNIEnv}, len::Integer, clazz::jclass, init::jobject) = - ccall(Main.JavaCall.jnifunc.NewObjectArray, jobjectArray, (Ptr{JNIEnv}, jsize, jclass, jobject,), env, len, clazz, init) + ccall(jnifunc.NewObjectArray, jobjectArray, (Ptr{JNIEnv}, jsize, jclass, jobject,), env, len, clazz, init) -export GetObjectArrayElement +#export GetObjectArrayElement GetObjectArrayElement(env::Ptr{JNIEnv}, array::jobjectArray, index::Integer) = - ccall(Main.JavaCall.jnifunc.GetObjectArrayElement, jobject, (Ptr{JNIEnv}, jobjectArray, jsize,), env, array, index) + ccall(jnifunc.GetObjectArrayElement, jobject, (Ptr{JNIEnv}, jobjectArray, jsize,), env, array, index) -export SetObjectArrayElement +#export SetObjectArrayElement SetObjectArrayElement(env::Ptr{JNIEnv}, array::jobjectArray, index::Integer, val::jobject) = - ccall(Main.JavaCall.jnifunc.SetObjectArrayElement, Nothing, (Ptr{JNIEnv}, jobjectArray, jsize, jobject,), env, array, index, val) + ccall(jnifunc.SetObjectArrayElement, Nothing, (Ptr{JNIEnv}, jobjectArray, jsize, jobject,), env, array, index, val) -export NewBooleanArray +#export NewBooleanArray NewBooleanArray(env::Ptr{JNIEnv}, len::Integer) = - ccall(Main.JavaCall.jnifunc.NewBooleanArray, jbooleanArray, (Ptr{JNIEnv}, jsize,), env, len) + ccall(jnifunc.NewBooleanArray, jbooleanArray, (Ptr{JNIEnv}, jsize,), env, len) -export NewByteArray +#export NewByteArray NewByteArray(env::Ptr{JNIEnv}, len::Integer) = - ccall(Main.JavaCall.jnifunc.NewByteArray, jbyteArray, (Ptr{JNIEnv}, jsize,), env, len) + ccall(jnifunc.NewByteArray, jbyteArray, (Ptr{JNIEnv}, jsize,), env, len) -export NewCharArray +#export NewCharArray NewCharArray(env::Ptr{JNIEnv}, len::Integer) = - ccall(Main.JavaCall.jnifunc.NewCharArray, jcharArray, (Ptr{JNIEnv}, jsize,), env, len) + ccall(jnifunc.NewCharArray, jcharArray, (Ptr{JNIEnv}, jsize,), env, len) -export NewShortArray +#export NewShortArray NewShortArray(env::Ptr{JNIEnv}, len::Integer) = - ccall(Main.JavaCall.jnifunc.NewShortArray, jshortArray, (Ptr{JNIEnv}, jsize,), env, len) + ccall(jnifunc.NewShortArray, jshortArray, (Ptr{JNIEnv}, jsize,), env, len) -export NewIntArray +#export NewIntArray NewIntArray(env::Ptr{JNIEnv}, len::Integer) = - ccall(Main.JavaCall.jnifunc.NewIntArray, jintArray, (Ptr{JNIEnv}, jsize,), env, len) + ccall(jnifunc.NewIntArray, jintArray, (Ptr{JNIEnv}, jsize,), env, len) -export NewLongArray +#export NewLongArray NewLongArray(env::Ptr{JNIEnv}, len::Integer) = - ccall(Main.JavaCall.jnifunc.NewLongArray, jlongArray, (Ptr{JNIEnv}, jsize,), env, len) + ccall(jnifunc.NewLongArray, jlongArray, (Ptr{JNIEnv}, jsize,), env, len) -export NewFloatArray +#export NewFloatArray NewFloatArray(env::Ptr{JNIEnv}, len::Integer) = - ccall(Main.JavaCall.jnifunc.NewFloatArray, jfloatArray, (Ptr{JNIEnv}, jsize,), env, len) + ccall(jnifunc.NewFloatArray, jfloatArray, (Ptr{JNIEnv}, jsize,), env, len) -export NewDoubleArray +#export NewDoubleArray NewDoubleArray(env::Ptr{JNIEnv}, len::Integer) = - ccall(Main.JavaCall.jnifunc.NewDoubleArray, jdoubleArray, (Ptr{JNIEnv}, jsize,), env, len) + ccall(jnifunc.NewDoubleArray, jdoubleArray, (Ptr{JNIEnv}, jsize,), env, len) -export GetBooleanArrayElements -GetBooleanArrayElements(env::Ptr{JNIEnv}, array::jbooleanArray, isCopy::Array{jboolean,1}) = - ccall(Main.JavaCall.jnifunc.GetBooleanArrayElements, Ptr{jboolean}, (Ptr{JNIEnv}, jbooleanArray, Ptr{jboolean},), env, array, isCopy) +#export GetBooleanArrayElements +GetBooleanArrayElements(env::Ptr{JNIEnv}, array::jbooleanArray, isCopy::PtrIsCopy) = + ccall(jnifunc.GetBooleanArrayElements, Ptr{jboolean}, (Ptr{JNIEnv}, jbooleanArray, Ptr{jboolean},), env, array, isCopy) -export GetByteArrayElements -GetByteArrayElements(env::Ptr{JNIEnv}, array::jbyteArray, isCopy::Array{jboolean,1}) = - ccall(Main.JavaCall.jnifunc.GetByteArrayElements, Ptr{jbyte}, (Ptr{JNIEnv}, jbyteArray, Ptr{jboolean},), env, array, isCopy) +#export GetByteArrayElements +GetByteArrayElements(env::Ptr{JNIEnv}, array::jbyteArray, isCopy::PtrIsCopy) = + ccall(jnifunc.GetByteArrayElements, Ptr{jbyte}, (Ptr{JNIEnv}, jbyteArray, Ptr{jboolean},), env, array, isCopy) -export GetCharArrayElements -GetCharArrayElements(env::Ptr{JNIEnv}, array::jcharArray, isCopy::Array{jboolean,1}) = - ccall(Main.JavaCall.jnifunc.GetCharArrayElements, Ptr{jchar}, (Ptr{JNIEnv}, jcharArray, Ptr{jboolean},), env, array, isCopy) +#export GetCharArrayElements +GetCharArrayElements(env::Ptr{JNIEnv}, array::jcharArray, isCopy::PtrIsCopy) = + ccall(jnifunc.GetCharArrayElements, Ptr{jchar}, (Ptr{JNIEnv}, jcharArray, Ptr{jboolean},), env, array, isCopy) -export GetShortArrayElements -GetShortArrayElements(env::Ptr{JNIEnv}, array::jshortArray, isCopy::Array{jboolean,1}) = - ccall(Main.JavaCall.jnifunc.GetShortArrayElements, Ptr{jshort}, (Ptr{JNIEnv}, jshortArray, Ptr{jboolean},), env, array, isCopy) +#export GetShortArrayElements +GetShortArrayElements(env::Ptr{JNIEnv}, array::jshortArray, isCopy::PtrIsCopy) = + ccall(jnifunc.GetShortArrayElements, Ptr{jshort}, (Ptr{JNIEnv}, jshortArray, Ptr{jboolean},), env, array, isCopy) -export GetIntArrayElements -GetIntArrayElements(env::Ptr{JNIEnv}, array::jintArray, isCopy::Array{jboolean,1}) = - ccall(Main.JavaCall.jnifunc.GetIntArrayElements, Ptr{jint}, (Ptr{JNIEnv}, jintArray, Ptr{jboolean},), env, array, isCopy) +#export GetIntArrayElements +GetIntArrayElements(env::Ptr{JNIEnv}, array::jintArray, isCopy::PtrIsCopy) = + ccall(jnifunc.GetIntArrayElements, Ptr{jint}, (Ptr{JNIEnv}, jintArray, Ptr{jboolean},), env, array, isCopy) -export GetLongArrayElements -GetLongArrayElements(env::Ptr{JNIEnv}, array::jlongArray, isCopy::Array{jboolean,1}) = - ccall(Main.JavaCall.jnifunc.GetLongArrayElements, Ptr{jlong}, (Ptr{JNIEnv}, jlongArray, Ptr{jboolean},), env, array, isCopy) +#export GetLongArrayElements +GetLongArrayElements(env::Ptr{JNIEnv}, array::jlongArray, isCopy::PtrIsCopy) = + ccall(jnifunc.GetLongArrayElements, Ptr{jlong}, (Ptr{JNIEnv}, jlongArray, Ptr{jboolean},), env, array, isCopy) -export GetFloatArrayElements -GetFloatArrayElements(env::Ptr{JNIEnv}, array::jfloatArray, isCopy::Array{jboolean,1}) = - ccall(Main.JavaCall.jnifunc.GetFloatArrayElements, Ptr{jfloat}, (Ptr{JNIEnv}, jfloatArray, Ptr{jboolean},), env, array, isCopy) +#export GetFloatArrayElements +GetFloatArrayElements(env::Ptr{JNIEnv}, array::jfloatArray, isCopy::PtrIsCopy) = + ccall(jnifunc.GetFloatArrayElements, Ptr{jfloat}, (Ptr{JNIEnv}, jfloatArray, Ptr{jboolean},), env, array, isCopy) -export GetDoubleArrayElements -GetDoubleArrayElements(env::Ptr{JNIEnv}, array::jdoubleArray, isCopy::Array{jboolean,1}) = - ccall(Main.JavaCall.jnifunc.GetDoubleArrayElements, Ptr{jdouble}, (Ptr{JNIEnv}, jdoubleArray, Ptr{jboolean},), env, array, isCopy) +#export GetDoubleArrayElements +GetDoubleArrayElements(env::Ptr{JNIEnv}, array::jdoubleArray, isCopy::PtrIsCopy) = + ccall(jnifunc.GetDoubleArrayElements, Ptr{jdouble}, (Ptr{JNIEnv}, jdoubleArray, Ptr{jboolean},), env, array, isCopy) -export ReleaseBooleanArrayElements -ReleaseBooleanArrayElements(env::Ptr{JNIEnv}, array::jbooleanArray, elems::Array{jboolean,1}, mode::jint) = - ccall(Main.JavaCall.jnifunc.ReleaseBooleanArrayElements, Nothing, (Ptr{JNIEnv}, jbooleanArray, Ptr{jboolean}, jint,), env, array, elems, mode) +#export ReleaseBooleanArrayElements +ReleaseBooleanArrayElements(env::Ptr{JNIEnv}, array::jbooleanArray, elems::Ptr{jboolean}, mode::jint) = + ccall(jnifunc.ReleaseBooleanArrayElements, Nothing, (Ptr{JNIEnv}, jbooleanArray, Ptr{jboolean}, jint,), env, array, elems, mode) -export ReleaseByteArrayElements -ReleaseByteArrayElements(env::Ptr{JNIEnv}, array::jbyteArray, elems::Array{jbyte,1}, mode::jint) = - ccall(Main.JavaCall.jnifunc.ReleaseByteArrayElements, Nothing, (Ptr{JNIEnv}, jbyteArray, Ptr{jbyte}, jint,), env, array, elems, mode) +#export ReleaseByteArrayElements +ReleaseByteArrayElements(env::Ptr{JNIEnv}, array::jbyteArray, elems::Ptr{jbyte}, mode::jint) = + ccall(jnifunc.ReleaseByteArrayElements, Nothing, (Ptr{JNIEnv}, jbyteArray, Ptr{jbyte}, jint,), env, array, elems, mode) -export ReleaseCharArrayElements -ReleaseCharArrayElements(env::Ptr{JNIEnv}, array::jcharArray, elems::Array{jchar,1}, mode::jint) = - ccall(Main.JavaCall.jnifunc.ReleaseCharArrayElements, Nothing, (Ptr{JNIEnv}, jcharArray, Ptr{jchar}, jint,), env, array, elems, mode) +#export ReleaseCharArrayElements +ReleaseCharArrayElements(env::Ptr{JNIEnv}, array::jcharArray, elems::Ptr{jchar}, mode::jint) = + ccall(jnifunc.ReleaseCharArrayElements, Nothing, (Ptr{JNIEnv}, jcharArray, Ptr{jchar}, jint,), env, array, elems, mode) -export ReleaseShortArrayElements -ReleaseShortArrayElements(env::Ptr{JNIEnv}, array::jshortArray, elems::Array{jshort,1}, mode::jint) = - ccall(Main.JavaCall.jnifunc.ReleaseShortArrayElements, Nothing, (Ptr{JNIEnv}, jshortArray, Ptr{jshort}, jint,), env, array, elems, mode) +#export ReleaseShortArrayElements +ReleaseShortArrayElements(env::Ptr{JNIEnv}, array::jshortArray, elems::Ptr{jshort}, mode::jint) = + ccall(jnifunc.ReleaseShortArrayElements, Nothing, (Ptr{JNIEnv}, jshortArray, Ptr{jshort}, jint,), env, array, elems, mode) -export ReleaseIntArrayElements -ReleaseIntArrayElements(env::Ptr{JNIEnv}, array::jintArray, elems::Array{jint,1}, mode::jint) = - ccall(Main.JavaCall.jnifunc.ReleaseIntArrayElements, Nothing, (Ptr{JNIEnv}, jintArray, Ptr{jint}, jint,), env, array, elems, mode) +#export ReleaseIntArrayElements +ReleaseIntArrayElements(env::Ptr{JNIEnv}, array::jintArray, elems::Ptr{jint}, mode::jint) = + ccall(jnifunc.ReleaseIntArrayElements, Nothing, (Ptr{JNIEnv}, jintArray, Ptr{jint}, jint,), env, array, elems, mode) -export ReleaseLongArrayElements -ReleaseLongArrayElements(env::Ptr{JNIEnv}, array::jlongArray, elems::Array{jlong,1}, mode::jint) = - ccall(Main.JavaCall.jnifunc.ReleaseLongArrayElements, Nothing, (Ptr{JNIEnv}, jlongArray, Ptr{jlong}, jint,), env, array, elems, mode) +#export ReleaseLongArrayElements +ReleaseLongArrayElements(env::Ptr{JNIEnv}, array::jlongArray, elems::Ptr{jlong}, mode::jint) = + ccall(jnifunc.ReleaseLongArrayElements, Nothing, (Ptr{JNIEnv}, jlongArray, Ptr{jlong}, jint,), env, array, elems, mode) -export ReleaseFloatArrayElements -ReleaseFloatArrayElements(env::Ptr{JNIEnv}, array::jfloatArray, elems::Array{jfloat,1}, mode::jint) = - ccall(Main.JavaCall.jnifunc.ReleaseFloatArrayElements, Nothing, (Ptr{JNIEnv}, jfloatArray, Ptr{jfloat}, jint,), env, array, elems, mode) +#export ReleaseFloatArrayElements +ReleaseFloatArrayElements(env::Ptr{JNIEnv}, array::jfloatArray, elems::Ptr{jfloat}, mode::jint) = + ccall(jnifunc.ReleaseFloatArrayElements, Nothing, (Ptr{JNIEnv}, jfloatArray, Ptr{jfloat}, jint,), env, array, elems, mode) -export ReleaseDoubleArrayElements -ReleaseDoubleArrayElements(env::Ptr{JNIEnv}, array::jdoubleArray, elems::Array{jdouble,1}, mode::jint) = - ccall(Main.JavaCall.jnifunc.ReleaseDoubleArrayElements, Nothing, (Ptr{JNIEnv}, jdoubleArray, Ptr{jdouble}, jint,), env, array, elems, mode) +#export ReleaseDoubleArrayElements +ReleaseDoubleArrayElements(env::Ptr{JNIEnv}, array::jdoubleArray, elems::Ptr{jdouble}, mode::jint) = + ccall(jnifunc.ReleaseDoubleArrayElements, Nothing, (Ptr{JNIEnv}, jdoubleArray, Ptr{jdouble}, jint,), env, array, elems, mode) -export GetBooleanArrayRegion +#export GetBooleanArrayRegion GetBooleanArrayRegion(env::Ptr{JNIEnv}, array::jbooleanArray, start::Integer, l::Integer, buf::Array{jboolean,1}) = - ccall(Main.JavaCall.jnifunc.GetBooleanArrayRegion, Nothing, (Ptr{JNIEnv}, jbooleanArray, jsize, jsize, Ptr{jboolean},), env, array, start, l, buf) + ccall(jnifunc.GetBooleanArrayRegion, Nothing, (Ptr{JNIEnv}, jbooleanArray, jsize, jsize, Ptr{jboolean},), env, array, start, l, buf) -export GetByteArrayRegion +#export GetByteArrayRegion GetByteArrayRegion(env::Ptr{JNIEnv}, array::jbyteArray, start::Integer, len::Integer, buf::Array{jbyte,1}) = - ccall(Main.JavaCall.jnifunc.GetByteArrayRegion, Nothing, (Ptr{JNIEnv}, jbyteArray, jsize, jsize, Ptr{jbyte},), env, array, start, len, buf) + ccall(jnifunc.GetByteArrayRegion, Nothing, (Ptr{JNIEnv}, jbyteArray, jsize, jsize, Ptr{jbyte},), env, array, start, len, buf) -export GetCharArrayRegion +#export GetCharArrayRegion GetCharArrayRegion(env::Ptr{JNIEnv}, array::jcharArray, start::Integer, len::Integer, buf::Array{jchar,1}) = - ccall(Main.JavaCall.jnifunc.GetCharArrayRegion, Nothing, (Ptr{JNIEnv}, jcharArray, jsize, jsize, Ptr{jchar},), env, array, start, len, buf) + ccall(jnifunc.GetCharArrayRegion, Nothing, (Ptr{JNIEnv}, jcharArray, jsize, jsize, Ptr{jchar},), env, array, start, len, buf) -export GetShortArrayRegion +#export GetShortArrayRegion GetShortArrayRegion(env::Ptr{JNIEnv}, array::jshortArray, start::Integer, len::Integer, buf::Array{jshort,1}) = - ccall(Main.JavaCall.jnifunc.GetShortArrayRegion, Nothing, (Ptr{JNIEnv}, jshortArray, jsize, jsize, Ptr{jshort},), env, array, start, len, buf) + ccall(jnifunc.GetShortArrayRegion, Nothing, (Ptr{JNIEnv}, jshortArray, jsize, jsize, Ptr{jshort},), env, array, start, len, buf) -export GetIntArrayRegion +#export GetIntArrayRegion GetIntArrayRegion(env::Ptr{JNIEnv}, array::jintArray, start::Integer, len::Integer, buf::Array{jint,1}) = - ccall(Main.JavaCall.jnifunc.GetIntArrayRegion, Nothing, (Ptr{JNIEnv}, jintArray, jsize, jsize, Ptr{jint},), env, array, start, len, buf) + ccall(jnifunc.GetIntArrayRegion, Nothing, (Ptr{JNIEnv}, jintArray, jsize, jsize, Ptr{jint},), env, array, start, len, buf) -export GetLongArrayRegion +#export GetLongArrayRegion GetLongArrayRegion(env::Ptr{JNIEnv}, array::jlongArray, start::Integer, len::Integer, buf::Array{jlong,1}) = - ccall(Main.JavaCall.jnifunc.GetLongArrayRegion, Nothing, (Ptr{JNIEnv}, jlongArray, jsize, jsize, Ptr{jlong},), env, array, start, len, buf) + ccall(jnifunc.GetLongArrayRegion, Nothing, (Ptr{JNIEnv}, jlongArray, jsize, jsize, Ptr{jlong},), env, array, start, len, buf) -export GetFloatArrayRegion +#export GetFloatArrayRegion GetFloatArrayRegion(env::Ptr{JNIEnv}, array::jfloatArray, start::Integer, len::Integer, buf::Array{jfloat,1}) = - ccall(Main.JavaCall.jnifunc.GetFloatArrayRegion, Nothing, (Ptr{JNIEnv}, jfloatArray, jsize, jsize, Ptr{jfloat},), env, array, start, len, buf) + ccall(jnifunc.GetFloatArrayRegion, Nothing, (Ptr{JNIEnv}, jfloatArray, jsize, jsize, Ptr{jfloat},), env, array, start, len, buf) -export GetDoubleArrayRegion +#export GetDoubleArrayRegion GetDoubleArrayRegion(env::Ptr{JNIEnv}, array::jdoubleArray, start::Integer, len::Integer, buf::Array{jdouble,1}) = - ccall(Main.JavaCall.jnifunc.GetDoubleArrayRegion, Nothing, (Ptr{JNIEnv}, jdoubleArray, jsize, jsize, Ptr{jdouble},), env, array, start, len, buf) + ccall(jnifunc.GetDoubleArrayRegion, Nothing, (Ptr{JNIEnv}, jdoubleArray, jsize, jsize, Ptr{jdouble},), env, array, start, len, buf) -export SetBooleanArrayRegion +#export SetBooleanArrayRegion SetBooleanArrayRegion(env::Ptr{JNIEnv}, array::jbooleanArray, start::Integer, l::Integer, buf::Array{jboolean,1}) = - ccall(Main.JavaCall.jnifunc.SetBooleanArrayRegion, Nothing, (Ptr{JNIEnv}, jbooleanArray, jsize, jsize, Ptr{jboolean},), env, array, start, l, buf) + ccall(jnifunc.SetBooleanArrayRegion, Nothing, (Ptr{JNIEnv}, jbooleanArray, jsize, jsize, Ptr{jboolean},), env, array, start, l, buf) -export SetByteArrayRegion +#export SetByteArrayRegion SetByteArrayRegion(env::Ptr{JNIEnv}, array::jbyteArray, start::Integer, len::Integer, buf::Array{jbyte,1}) = - ccall(Main.JavaCall.jnifunc.SetByteArrayRegion, Nothing, (Ptr{JNIEnv}, jbyteArray, jsize, jsize, Ptr{jbyte},), env, array, start, len, buf) + ccall(jnifunc.SetByteArrayRegion, Nothing, (Ptr{JNIEnv}, jbyteArray, jsize, jsize, Ptr{jbyte},), env, array, start, len, buf) -export SetCharArrayRegion +#export SetCharArrayRegion SetCharArrayRegion(env::Ptr{JNIEnv}, array::jcharArray, start::Integer, len::Integer, buf::Array{jchar,1}) = - ccall(Main.JavaCall.jnifunc.SetCharArrayRegion, Nothing, (Ptr{JNIEnv}, jcharArray, jsize, jsize, Ptr{jchar},), env, array, start, len, buf) + ccall(jnifunc.SetCharArrayRegion, Nothing, (Ptr{JNIEnv}, jcharArray, jsize, jsize, Ptr{jchar},), env, array, start, len, buf) -export SetShortArrayRegion +#export SetShortArrayRegion SetShortArrayRegion(env::Ptr{JNIEnv}, array::jshortArray, start::Integer, len::Integer, buf::Array{jshort,1}) = - ccall(Main.JavaCall.jnifunc.SetShortArrayRegion, Nothing, (Ptr{JNIEnv}, jshortArray, jsize, jsize, Ptr{jshort},), env, array, start, len, buf) + ccall(jnifunc.SetShortArrayRegion, Nothing, (Ptr{JNIEnv}, jshortArray, jsize, jsize, Ptr{jshort},), env, array, start, len, buf) -export SetIntArrayRegion +#export SetIntArrayRegion SetIntArrayRegion(env::Ptr{JNIEnv}, array::jintArray, start::Integer, len::Integer, buf::Array{jint,1}) = - ccall(Main.JavaCall.jnifunc.SetIntArrayRegion, Nothing, (Ptr{JNIEnv}, jintArray, jsize, jsize, Ptr{jint},), env, array, start, len, buf) + ccall(jnifunc.SetIntArrayRegion, Nothing, (Ptr{JNIEnv}, jintArray, jsize, jsize, Ptr{jint},), env, array, start, len, buf) -export SetLongArrayRegion +#export SetLongArrayRegion SetLongArrayRegion(env::Ptr{JNIEnv}, array::jlongArray, start::Integer, len::Integer, buf::Array{jlong,1}) = - ccall(Main.JavaCall.jnifunc.SetLongArrayRegion, Nothing, (Ptr{JNIEnv}, jlongArray, jsize, jsize, Ptr{jlong},), env, array, start, len, buf) + ccall(jnifunc.SetLongArrayRegion, Nothing, (Ptr{JNIEnv}, jlongArray, jsize, jsize, Ptr{jlong},), env, array, start, len, buf) -export SetFloatArrayRegion +#export SetFloatArrayRegion SetFloatArrayRegion(env::Ptr{JNIEnv}, array::jfloatArray, start::Integer, len::Integer, buf::Array{jfloat,1}) = - ccall(Main.JavaCall.jnifunc.SetFloatArrayRegion, Nothing, (Ptr{JNIEnv}, jfloatArray, jsize, jsize, Ptr{jfloat},), env, array, start, len, buf) + ccall(jnifunc.SetFloatArrayRegion, Nothing, (Ptr{JNIEnv}, jfloatArray, jsize, jsize, Ptr{jfloat},), env, array, start, len, buf) -export SetDoubleArrayRegion +#export SetDoubleArrayRegion SetDoubleArrayRegion(env::Ptr{JNIEnv}, array::jdoubleArray, start::Integer, len::Integer, buf::Array{jdouble,1}) = - ccall(Main.JavaCall.jnifunc.SetDoubleArrayRegion, Nothing, (Ptr{JNIEnv}, jdoubleArray, jsize, jsize, Ptr{jdouble},), env, array, start, len, buf) + ccall(jnifunc.SetDoubleArrayRegion, Nothing, (Ptr{JNIEnv}, jdoubleArray, jsize, jsize, Ptr{jdouble},), env, array, start, len, buf) -export RegisterNatives +#export RegisterNatives RegisterNatives(env::Ptr{JNIEnv}, clazz::jclass, methods::Array{JNINativeMethod,1}, nMethods::jint) = - ccall(Main.JavaCall.jnifunc.RegisterNatives, jint, (Ptr{JNIEnv}, jclass, Ptr{JNINativeMethod}, jint,), env, clazz, methods, nMethods) + ccall(jnifunc.RegisterNatives, jint, (Ptr{JNIEnv}, jclass, Ptr{JNINativeMethod}, jint,), env, clazz, methods, nMethods) -export UnregisterNatives +#export UnregisterNatives UnregisterNatives(env::Ptr{JNIEnv}, clazz::jclass) = - ccall(Main.JavaCall.jnifunc.UnregisterNatives, jint, (Ptr{JNIEnv}, jclass,), env, clazz) + ccall(jnifunc.UnregisterNatives, jint, (Ptr{JNIEnv}, jclass,), env, clazz) -export MonitorEnter +#export MonitorEnter MonitorEnter(env::Ptr{JNIEnv}, obj::jobject) = - ccall(Main.JavaCall.jnifunc.MonitorEnter, jint, (Ptr{JNIEnv}, jobject,), env, obj) + ccall(jnifunc.MonitorEnter, jint, (Ptr{JNIEnv}, jobject,), env, obj) -export MonitorExit +#export MonitorExit MonitorExit(env::Ptr{JNIEnv}, obj::jobject) = - ccall(Main.JavaCall.jnifunc.MonitorExit, jint, (Ptr{JNIEnv}, jobject,), env, obj) + ccall(jnifunc.MonitorExit, jint, (Ptr{JNIEnv}, jobject,), env, obj) -export GetJavaVM +#export GetJavaVM GetJavaVM(env::Ptr{JNIEnv}, vm::Array{JavaVM,1}) = - ccall(Main.JavaCall.jnifunc.GetJavaVM, jint, (Ptr{JNIEnv}, Array{JavaVM,1},), env, vm) + ccall(jnifunc.GetJavaVM, jint, (Ptr{JNIEnv}, Array{JavaVM,1},), env, vm) -export GetStringRegion +#export GetStringRegion GetStringRegion(env::Ptr{JNIEnv}, str::jstring, start::Integer, len::Integer, buf::Array{jchar,1}) = - ccall(Main.JavaCall.jnifunc.GetStringRegion, Nothing, (Ptr{JNIEnv}, jstring, jsize, jsize, Ptr{jchar},), env, str, start, len, buf) + ccall(jnifunc.GetStringRegion, Nothing, (Ptr{JNIEnv}, jstring, jsize, jsize, Ptr{jchar},), env, str, start, len, buf) -export GetStringUTFRegion +#export GetStringUTFRegion GetStringUTFRegion(env::Ptr{JNIEnv}, str::jstring, start::Integer, len::Integer, buf::AbstractString) = - ccall(Main.JavaCall.jnifunc.GetStringUTFRegion, Nothing, (Ptr{JNIEnv}, jstring, jsize, jsize, Cstring,), env, str, start, len, String(buf)) + ccall(jnifunc.GetStringUTFRegion, Nothing, (Ptr{JNIEnv}, jstring, jsize, jsize, Cstring,), env, str, start, len, String(buf)) -export GetPrimitiveArrayCritical -GetPrimitiveArrayCritical(env::Ptr{JNIEnv}, array::jarray, isCopy::Array{jboolean,1}) = - ccall(Main.JavaCall.jnifunc.GetPrimitiveArrayCritical, Ptr{Nothing}, (Ptr{JNIEnv}, jarray, Ptr{jboolean},), env, array, isCopy) +#export GetPrimitiveArrayCritical +GetPrimitiveArrayCritical(env::Ptr{JNIEnv}, array::jarray, isCopy::PtrIsCopy) = + ccall(jnifunc.GetPrimitiveArrayCritical, Ptr{Nothing}, (Ptr{JNIEnv}, jarray, Ptr{jboolean},), env, array, isCopy) -export ReleasePrimitiveArrayCritical +#export ReleasePrimitiveArrayCritical ReleasePrimitiveArrayCritical(env::Ptr{JNIEnv}, array::jarray, carray::Ptr{Nothing}, mode::jint) = - ccall(Main.JavaCall.jnifunc.ReleasePrimitiveArrayCritical, Nothing, (Ptr{JNIEnv}, jarray, Ptr{Nothing}, jint,), env, array, carray, mode) + ccall(jnifunc.ReleasePrimitiveArrayCritical, Nothing, (Ptr{JNIEnv}, jarray, Ptr{Nothing}, jint,), env, array, carray, mode) -export GetStringCritical -GetStringCritical(env::Ptr{JNIEnv}, string::jstring, isCopy::Array{jboolean,1}) = - ccall(Main.JavaCall.jnifunc.GetStringCritical, Ptr{jchar}, (Ptr{JNIEnv}, jstring, Ptr{jboolean},), env, string, isCopy) +#export GetStringCritical +GetStringCritical(env::Ptr{JNIEnv}, string::jstring, isCopy::PtrIsCopy) = + ccall(jnifunc.GetStringCritical, Ptr{jchar}, (Ptr{JNIEnv}, jstring, Ptr{jboolean},), env, string, isCopy) -export ReleaseStringCritical +#export ReleaseStringCritical ReleaseStringCritical(env::Ptr{JNIEnv}, string::jstring, cstring::Array{jchar,1}) = - ccall(Main.JavaCall.jnifunc.ReleaseStringCritical, Nothing, (Ptr{JNIEnv}, jstring, Ptr{jchar},), env, string, cstring) + ccall(jnifunc.ReleaseStringCritical, Nothing, (Ptr{JNIEnv}, jstring, Ptr{jchar},), env, string, cstring) -export NewWeakGlobalRef +#export NewWeakGlobalRef NewWeakGlobalRef(env::Ptr{JNIEnv}, obj::jobject) = - ccall(Main.JavaCall.jnifunc.NewWeakGlobalRef, jweak, (Ptr{JNIEnv}, jobject,), env, obj) + ccall(jnifunc.NewWeakGlobalRef, jweak, (Ptr{JNIEnv}, jobject,), env, obj) -export DeleteWeakGlobalRef +#export DeleteWeakGlobalRef DeleteWeakGlobalRef(env::Ptr{JNIEnv}, ref::jweak) = - ccall(Main.JavaCall.jnifunc.DeleteWeakGlobalRef, Nothing, (Ptr{JNIEnv}, jweak,), env, ref) + ccall(jnifunc.DeleteWeakGlobalRef, Nothing, (Ptr{JNIEnv}, jweak,), env, ref) -export ExceptionCheck +#export ExceptionCheck ExceptionCheck(env::Ptr{JNIEnv}) = - ccall(Main.JavaCall.jnifunc.ExceptionCheck, jboolean, (Ptr{JNIEnv},), env) + ccall(jnifunc.ExceptionCheck, jboolean, (Ptr{JNIEnv},), env) -export NewDirectByteBuffer +#export NewDirectByteBuffer NewDirectByteBuffer(env::Ptr{JNIEnv}, address::Ptr{Nothing}, capacity::jlong) = - ccall(Main.JavaCall.jnifunc.NewDirectByteBuffer, jobject, (Ptr{JNIEnv}, Ptr{Nothing}, jlong,), env, address, capacity) + ccall(jnifunc.NewDirectByteBuffer, jobject, (Ptr{JNIEnv}, Ptr{Nothing}, jlong,), env, address, capacity) -export GetDirectBufferAddress +#export GetDirectBufferAddress GetDirectBufferAddress(env::Ptr{JNIEnv}, buf::jobject) = - ccall(Main.JavaCall.jnifunc.GetDirectBufferAddress, Ptr{Nothing}, (Ptr{JNIEnv}, jobject,), env, buf) + ccall(jnifunc.GetDirectBufferAddress, Ptr{Nothing}, (Ptr{JNIEnv}, jobject,), env, buf) -export GetDirectBufferCapacity +#export GetDirectBufferCapacity GetDirectBufferCapacity(env::Ptr{JNIEnv}, buf::jobject) = - ccall(Main.JavaCall.jnifunc.GetDirectBufferCapacity, jlong, (Ptr{JNIEnv}, jobject,), env, buf) + ccall(jnifunc.GetDirectBufferCapacity, jlong, (Ptr{JNIEnv}, jobject,), env, buf) -export GetObjectRefType +#export GetObjectRefType GetObjectRefType(env::Ptr{JNIEnv}, obj::jobject) = - ccall(Main.JavaCall.jnifunc.GetObjectRefType, jobjectRefType, (Ptr{JNIEnv}, jobject,), env, obj) + ccall(jnifunc.GetObjectRefType, jobjectRefType, (Ptr{JNIEnv}, jobject,), env, obj) end diff --git a/src/jvm.jl b/src/jvm.jl index 96088b1..f6f28fe 100644 --- a/src/jvm.jl +++ b/src/jvm.jl @@ -262,7 +262,7 @@ else assertroottask_or_goodenv() = isgoodenv() ? nothing : throw(ROOT_TASK_ERROR) end -isloaded() = isdefined(JavaCall, :jnifunc) && isdefined(JavaCall, :penv) && penv != C_NULL +isloaded() = JNI.is_jni_loaded() && isdefined(JavaCall, :penv) && penv != C_NULL assertloaded() = isloaded() ? nothing : throw(JavaCallError("JVM not initialised. Please run init()")) assertnotloaded() = isloaded() ? throw(JavaCallError("JVM already initialised")) : nothing @@ -281,10 +281,9 @@ function init(opts) res < 0 && throw(JavaCallError("Unable to initialise Java VM: $(res)")) global penv = ppenv[1] global pjvm = ppjvm[1] - jnienv = unsafe_load(penv) jvm = unsafe_load(pjvm) global jvmfunc = unsafe_load(jvm.JNIInvokeInterface_) - global jnifunc = unsafe_load(jnienv.JNINativeInterface_) #The JNI Function table + JNI.load_jni(penv) return end @@ -339,8 +338,7 @@ function init_current_vm() global jvmfunc = unsafe_load(jvm.JNIInvokeInterface_) ccall(jvmfunc.GetEnv, Cint, (Ptr{Nothing}, Ptr{Ptr{JNIEnv}}, Cint), pjvm, ppenv, JNI_VERSION_1_8) global penv = ppenv[1] - jnienv = unsafe_load(penv) - global jnifunc = unsafe_load(jnienv.JNINativeInterface_) #The JNI Function table + JNI.load_jni(penv) end function destroy() diff --git a/src/make_jni2.jl b/src/make_jni2.jl index 43a4f7b..5fbcbc8 100644 --- a/src/make_jni2.jl +++ b/src/make_jni2.jl @@ -1,13 +1,14 @@ -println("module JNI") -println("import ..JavaCall: JNIEnv, JavaVM, jbyte, jchar, jshort, jint, jlong, jsize, jdouble, jfloat, jboolean") -for t in ["jobject", "jclass", "jthrowable", "jweak", "jmethodID", "jfieldID", "jstring", "jarray", "JNINativeMethod"] -println("$t = Ptr{Nothing}") -end -for t in ["object", "boolean", "byte", "short", "int", "long", "float", "double", "char"] -println("j$(t)Array = Ptr{Nothing}") -end -println("jvalue = Int64") -println() +#println("module JNI") +#println("import ..JavaCall: JNIEnv, JavaVM, jbyte, jchar, jshort, jint, jlong, jsize, jdouble, jfloat, jboolean") +#for t in ["jobject", "jclass", "jthrowable", "jweak", "jmethodID", "jfieldID", "jstring", "jarray", "JNINativeMethod"] +#println("$t = Ptr{Nothing}") +#end +#for t in ["object", "boolean", "byte", "short", "int", "long", "float", "double", "char"] +#println("j$(t)Array = Ptr{Nothing}") +#end +#println("jvalue = Int64") +#println() +println("# === Below Generated by ",PROGRAM_FILE," ===") function arg_name(m) m.captures[3] @@ -31,6 +32,7 @@ function decl_arg_type(t, s) return "Ptr{JNIEnv}" else return "Array{$t,1}" +# return "Ptr{$t}" end elseif t == "jsize" #|| t == "jint" || t == "jlong" || t == "jshort" || t == "jbyte" return Integer @@ -41,6 +43,7 @@ function decl_arg_type(t, s) end return s == "" ? t : "Array{$t,1}" +# return s == "" ? t : "Ptr{$t}" end function ccall_arg_type(t, s; r=false) @@ -60,30 +63,62 @@ function ccall_arg_type(t, s; r=false) return "Nothing" end + # No asterisk: type + # If return type, Ptr + # Else Array return s == "" ? t : r ? "Ptr{$t}" : "Array{$t,1}" end -julia_arg(m) = string(arg_name(m), "::", decl_arg_type(m)) +# julia_arg(m) = string(arg_name(m), "::", decl_arg_type(m)) +function julia_arg(m) + if arg_name(m) == "isCopy" + "isCopy::PtrIsCopy" + elseif arg_name(m) == "elems" + string(arg_name(m), "::", "Ptr{$(m.captures[1])}") + else + string(arg_name(m), "::", decl_arg_type(m)) + end +end for line in open(readlines, "jnienv.jl", "r") + # m: match comments + # Example: + # # jclass ( *GetSuperclass) (JNIEnv *env, jclass sub); + # Group 1: Return type ((?:void|char|j\w+)) "jclass" + # Group 2: Asterisk (\**) "" + # Group 3: Function name (\w+) "GetSuperclass" + # Group 4: Arguments \((.*)\) "JNIEnv *env, jclass sub" m = match(r"\# \s* (?:const\s*)? ((?:void|char|j\w+)) \s* (\**) \s* \( \s* \* (\w+) \s* \) \s* \((.*)\) \s* ;"x, line) if m === nothing continue end + # Ignore functions with variable argument syntax + # Only process vararg functions that end in A if occursin("...", m.captures[4]) continue end if occursin("va_list", m.captures[4]) continue end + # Get return type rtype = ccall_arg_type(m.captures[1], m.captures[2], r=true) + # Function name fname = m.captures[3] + # Split arguments args = split(m.captures[4], ",") + + # mm: Analyze arguments + # Example: [1] "JNIEnv *env", [2] "jclass sub" + # Group 1: Argument type ((?:void|j\w+|char|JNI\w+|JavaVM)) + # Group 2: Asterisk (\**) + # Group 3: Argument name (\w+) mm = map(x->match(r"^\s* (?:const\s+)? \s* ((?:void|j\w+|char|JNI\w+|JavaVM)) \s*? (\**) \s* (\w+) \s*$"x, x), args) julia_args = join(map(julia_arg, mm), ", ") arg_types = join(map(ccall_arg_type, mm), ", ") arg_names = join(map(arg_value, mm), ", ") - print("export $fname\n") - print("$fname($julia_args) =\n ccall(Main.JavaCall.jnifunc.$(fname), $rtype, ($arg_types,), $arg_names)\n\n") + # Commented out export command + print("#export $fname\n") + print("$fname($julia_args) =\n ccall(jnifunc.$(fname), $rtype, ($arg_types,), $arg_names)\n\n") end -println("end") +# println("end") +println("# === Above Generated by ",PROGRAM_FILE," ===") From 9052b14ea76e9637229a3a4de863b3a6121ef334 Mon Sep 17 00:00:00 2001 From: "markkitt@gmail.com" Date: Sat, 2 May 2020 22:29:22 -0500 Subject: [PATCH 11/18] Rename jnienv2.jl to JNI.jl --- src/{jnienv2.jl => JNI.jl} | 0 src/JavaCall.jl | 2 +- 2 files changed, 1 insertion(+), 1 deletion(-) rename src/{jnienv2.jl => JNI.jl} (100%) diff --git a/src/jnienv2.jl b/src/JNI.jl similarity index 100% rename from src/jnienv2.jl rename to src/JNI.jl diff --git a/src/JavaCall.jl b/src/JavaCall.jl index 3eac0d0..7c66bb9 100644 --- a/src/JavaCall.jl +++ b/src/JavaCall.jl @@ -23,7 +23,7 @@ import Base: convert, unsafe_convert, unsafe_string JULIA_COPY_STACKS = false -include("jnienv2.jl") +include("JNI.jl") using .JNI include("jvm.jl") include("core.jl") From 22c34a3be8ee7c4a749fcd6be79f88d489078a1a Mon Sep 17 00:00:00 2001 From: "markkitt@gmail.com" Date: Sat, 2 May 2020 23:00:42 -0500 Subject: [PATCH 12/18] Generalize String JNI calls, Move JNI constants to JNI module --- src/JNI.jl | 68 +++++++++++++++++++++++++++++++++--------------- src/jvm.jl | 20 +------------- src/make_jni2.jl | 6 +++-- 3 files changed, 52 insertions(+), 42 deletions(-) diff --git a/src/JNI.jl b/src/JNI.jl index 91172e2..38eb907 100644 --- a/src/JNI.jl +++ b/src/JNI.jl @@ -6,6 +6,8 @@ export JNINativeInterface, JNIEnv, JNIInvokeInterface, JavaVM, JavaCallError export jint, jlong, jbyte # jni.h exports export jboolean, jchar, jshort, jfloat, jdouble, jsize, jprimitive +# constant export +export JNI_TRUE, JNI_FALSE # Legacy exports export jnifunc @@ -57,6 +59,26 @@ jvalue = Int64 JNIWeakGlobalRefType = 3 end +const JNI_VERSION_1_1 = convert(Cint, 0x00010001) +const JNI_VERSION_1_2 = convert(Cint, 0x00010002) +const JNI_VERSION_1_4 = convert(Cint, 0x00010004) +const JNI_VERSION_1_6 = convert(Cint, 0x00010006) +const JNI_VERSION_1_8 = convert(Cint, 0x00010008) +const JNI_VERSION_9 = convert(Cint, 0x00090000) +const JNI_VERSION_10 = convert(Cint, 0x000a0000) + +const JNI_TRUE = convert(Cchar, 1) +const JNI_FALSE = convert(Cchar, 0) + +# Return Values +const JNI_OK = convert(Cint, 0) #/* success */ +const JNI_ERR = convert(Cint, -1) #/* unknown error */ +const JNI_EDETACHED = convert(Cint, -2) #/* thread detached from the VM */ +const JNI_EVERSION = convert(Cint, -3) #/* JNI version error */ +const JNI_ENOMEM = convert(Cint, -4) #/* not enough memory */ +const JNI_EEXIST = convert(Cint, -5) #/* VM already created */ +const JNI_EINVAL = convert(Cint, -6) #/* invalid arguments */ + # There is likely over specification here PtrIsCopy = Union{Ptr{jboolean},Ref{jboolean},Array{jboolean,}} AnyString = Union{AbstractString,Cstring,Ptr{UInt8}} @@ -67,17 +89,19 @@ function load_jni(penv::Ptr{JNIEnv}) end is_jni_loaded() = isdefined(JNI, :jnifunc) +# === Below Generated by make_jni2.jl === + #export GetVersion GetVersion(env::Ptr{JNIEnv}) = ccall(jnifunc.GetVersion, jint, (Ptr{JNIEnv},), env) #export DefineClass -DefineClass(env::Ptr{JNIEnv}, name::AbstractString, loader::jobject, buf::Array{jbyte,1}, len::Integer) = - ccall(jnifunc.DefineClass, jclass, (Ptr{JNIEnv}, Cstring, jobject, Ptr{jbyte}, jsize,), env, String(name), loader, buf, len) +DefineClass(env::Ptr{JNIEnv}, name::AnyString, loader::jobject, buf::Array{jbyte,1}, len::Integer) = + ccall(jnifunc.DefineClass, jclass, (Ptr{JNIEnv}, Cstring, jobject, Ptr{jbyte}, jsize,), env, name, loader, buf, len) #export FindClass -FindClass(env::Ptr{JNIEnv}, name::AbstractString) = - ccall(jnifunc.FindClass, jclass, (Ptr{JNIEnv}, Cstring,), env, String(name)) +FindClass(env::Ptr{JNIEnv}, name::AnyString) = + ccall(jnifunc.FindClass, jclass, (Ptr{JNIEnv}, Cstring,), env, name) #export FromReflectedMethod FromReflectedMethod(env::Ptr{JNIEnv}, method::jobject) = @@ -108,8 +132,8 @@ Throw(env::Ptr{JNIEnv}, obj::jthrowable) = ccall(jnifunc.Throw, jint, (Ptr{JNIEnv}, jthrowable,), env, obj) #export ThrowNew -ThrowNew(env::Ptr{JNIEnv}, clazz::jclass, msg::AbstractString) = - ccall(jnifunc.ThrowNew, jint, (Ptr{JNIEnv}, jclass, Cstring,), env, clazz, String(msg)) +ThrowNew(env::Ptr{JNIEnv}, clazz::jclass, msg::AnyString) = + ccall(jnifunc.ThrowNew, jint, (Ptr{JNIEnv}, jclass, Cstring,), env, clazz, msg) #export ExceptionOccurred ExceptionOccurred(env::Ptr{JNIEnv}) = @@ -124,8 +148,8 @@ ExceptionClear(env::Ptr{JNIEnv}) = ccall(jnifunc.ExceptionClear, Nothing, (Ptr{JNIEnv},), env) #export FatalError -FatalError(env::Ptr{JNIEnv}, msg::AbstractString) = - ccall(jnifunc.FatalError, Nothing, (Ptr{JNIEnv}, Cstring,), env, String(msg)) +FatalError(env::Ptr{JNIEnv}, msg::AnyString) = + ccall(jnifunc.FatalError, Nothing, (Ptr{JNIEnv}, Cstring,), env, msg) #export PushLocalFrame PushLocalFrame(env::Ptr{JNIEnv}, capacity::jint) = @@ -176,8 +200,8 @@ IsInstanceOf(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass) = ccall(jnifunc.IsInstanceOf, jboolean, (Ptr{JNIEnv}, jobject, jclass,), env, obj, clazz) #export GetMethodID -GetMethodID(env::Ptr{JNIEnv}, clazz::jclass, name::AbstractString, sig::AbstractString) = - ccall(jnifunc.GetMethodID, jmethodID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), env, clazz, String(name), String(sig)) +GetMethodID(env::Ptr{JNIEnv}, clazz::jclass, name::AnyString, sig::AnyString) = + ccall(jnifunc.GetMethodID, jmethodID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), env, clazz, name, sig) #export CallObjectMethodA CallObjectMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = @@ -260,8 +284,8 @@ CallNonvirtualVoidMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodI ccall(jnifunc.CallNonvirtualVoidMethodA, Nothing, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) #export GetFieldID -GetFieldID(env::Ptr{JNIEnv}, clazz::jclass, name::AbstractString, sig::AbstractString) = - ccall(jnifunc.GetFieldID, jfieldID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), env, clazz, String(name), String(sig)) +GetFieldID(env::Ptr{JNIEnv}, clazz::jclass, name::AnyString, sig::AnyString) = + ccall(jnifunc.GetFieldID, jfieldID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), env, clazz, name, sig) #export GetObjectField GetObjectField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = @@ -336,8 +360,8 @@ SetDoubleField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jdouble) ccall(jnifunc.SetDoubleField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jdouble,), env, obj, fieldID, val) #export GetStaticMethodID -GetStaticMethodID(env::Ptr{JNIEnv}, clazz::jclass, name::AbstractString, sig::AbstractString) = - ccall(jnifunc.GetStaticMethodID, jmethodID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), env, clazz, String(name), String(sig)) +GetStaticMethodID(env::Ptr{JNIEnv}, clazz::jclass, name::AnyString, sig::AnyString) = + ccall(jnifunc.GetStaticMethodID, jmethodID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), env, clazz, name, sig) #export CallStaticObjectMethodA CallStaticObjectMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = @@ -380,8 +404,8 @@ CallStaticVoidMethodA(env::Ptr{JNIEnv}, cls::jclass, methodID::jmethodID, args:: ccall(jnifunc.CallStaticVoidMethodA, Nothing, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, cls, methodID, args) #export GetStaticFieldID -GetStaticFieldID(env::Ptr{JNIEnv}, clazz::jclass, name::AbstractString, sig::AbstractString) = - ccall(jnifunc.GetStaticFieldID, jfieldID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), env, clazz, String(name), String(sig)) +GetStaticFieldID(env::Ptr{JNIEnv}, clazz::jclass, name::AnyString, sig::AnyString) = + ccall(jnifunc.GetStaticFieldID, jfieldID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), env, clazz, name, sig) #export GetStaticObjectField GetStaticObjectField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = @@ -472,8 +496,8 @@ ReleaseStringChars(env::Ptr{JNIEnv}, str::jstring, chars::Array{jchar,1}) = ccall(jnifunc.ReleaseStringChars, Nothing, (Ptr{JNIEnv}, jstring, Ptr{jchar},), env, str, chars) #export NewStringUTF -NewStringUTF(env::Ptr{JNIEnv}, utf::AbstractString) = - ccall(jnifunc.NewStringUTF, jstring, (Ptr{JNIEnv}, Cstring,), env, String(utf)) +NewStringUTF(env::Ptr{JNIEnv}, utf::AnyString) = + ccall(jnifunc.NewStringUTF, jstring, (Ptr{JNIEnv}, Cstring,), env, utf) #export GetStringUTFLength GetStringUTFLength(env::Ptr{JNIEnv}, str::jstring) = @@ -487,7 +511,7 @@ GetStringUTFChars(env::Ptr{JNIEnv}, str::jstring, isCopy::PtrIsCopy) = ## Prior to this module we used UInt8 instead of Cstring, must match return value of above #ReleaseStringUTFChars(env::Ptr{JNIEnv}, str::jstring, chars::Ptr{UInt8}) = # ccall(jnifunc.ReleaseStringUTFChars, Nothing, (Ptr{JNIEnv}, jstring, Ptr{UInt8},), env, str, chars) -ReleaseStringUTFChars(env::Ptr{JNIEnv}, str::jstring, chars::Cstring) = +ReleaseStringUTFChars(env::Ptr{JNIEnv}, str::jstring, chars::AnyString) = ccall(jnifunc.ReleaseStringUTFChars, Nothing, (Ptr{JNIEnv}, jstring, Cstring,), env, str, chars) #export GetArrayLength @@ -691,8 +715,8 @@ GetStringRegion(env::Ptr{JNIEnv}, str::jstring, start::Integer, len::Integer, bu ccall(jnifunc.GetStringRegion, Nothing, (Ptr{JNIEnv}, jstring, jsize, jsize, Ptr{jchar},), env, str, start, len, buf) #export GetStringUTFRegion -GetStringUTFRegion(env::Ptr{JNIEnv}, str::jstring, start::Integer, len::Integer, buf::AbstractString) = - ccall(jnifunc.GetStringUTFRegion, Nothing, (Ptr{JNIEnv}, jstring, jsize, jsize, Cstring,), env, str, start, len, String(buf)) +GetStringUTFRegion(env::Ptr{JNIEnv}, str::jstring, start::Integer, len::Integer, buf::AnyString) = + ccall(jnifunc.GetStringUTFRegion, Nothing, (Ptr{JNIEnv}, jstring, jsize, jsize, Cstring,), env, str, start, len, buf) #export GetPrimitiveArrayCritical GetPrimitiveArrayCritical(env::Ptr{JNIEnv}, array::jarray, isCopy::PtrIsCopy) = @@ -738,4 +762,6 @@ GetDirectBufferCapacity(env::Ptr{JNIEnv}, buf::jobject) = GetObjectRefType(env::Ptr{JNIEnv}, obj::jobject) = ccall(jnifunc.GetObjectRefType, jobjectRefType, (Ptr{JNIEnv}, jobject,), env, obj) +# === Above Generated by make_jni2.jl === + end diff --git a/src/jvm.jl b/src/jvm.jl index f6f28fe..d0966c4 100644 --- a/src/jvm.jl +++ b/src/jvm.jl @@ -1,21 +1,3 @@ -const JNI_VERSION_1_1 = convert(Cint, 0x00010001) -const JNI_VERSION_1_2 = convert(Cint, 0x00010002) -const JNI_VERSION_1_4 = convert(Cint, 0x00010004) -const JNI_VERSION_1_6 = convert(Cint, 0x00010006) -const JNI_VERSION_1_8 = convert(Cint, 0x00010008) - -const JNI_TRUE = convert(Cchar, 1) -const JNI_FALSE = convert(Cchar, 0) - -# Return Values -const JNI_OK = convert(Cint, 0) #/* success */ -const JNI_ERR = convert(Cint, -1) #/* unknown error */ -const JNI_EDETACHED = convert(Cint, -2) #/* thread detached from the VM */ -const JNI_EVERSION = convert(Cint, -3) #/* JNI version error */ -const JNI_ENOMEM = convert(Cint, -4) #/* not enough memory */ -const JNI_EEXIST = convert(Cint, -5) #/* VM already created */ -const JNI_EINVAL = convert(Cint, -6) #/* invalid arguments */ - const JAVA_HOME_CANDIDATES = ["/usr/lib/jvm/default-java/", "/usr/lib/jvm/default/"] @@ -274,7 +256,7 @@ function init(opts) opt = [JavaVMOption(pointer(x), C_NULL) for x in opts] ppjvm = Array{Ptr{JavaVM}}(undef, 1) ppenv = Array{Ptr{JNIEnv}}(undef, 1) - vm_args = JavaVMInitArgs(JNI_VERSION_1_6, convert(Cint, length(opts)), + vm_args = JavaVMInitArgs(JNI.JNI_VERSION_1_8, convert(Cint, length(opts)), convert(Ptr{JavaVMOption}, pointer(opt)), JNI_TRUE) res = ccall(create, Cint, (Ptr{Ptr{JavaVM}}, Ptr{Ptr{JNIEnv}}, Ptr{JavaVMInitArgs}), ppjvm, ppenv, Ref(vm_args)) diff --git a/src/make_jni2.jl b/src/make_jni2.jl index 5fbcbc8..0beff6d 100644 --- a/src/make_jni2.jl +++ b/src/make_jni2.jl @@ -9,13 +9,14 @@ #println("jvalue = Int64") #println() println("# === Below Generated by ",PROGRAM_FILE," ===") +println("") function arg_name(m) m.captures[3] end function arg_value(m) - if m.captures[2] == "*" && m.captures[1] == "char" return "String($(m.captures[3]))" end + #if m.captures[2] == "*" && m.captures[1] == "char" return "String($(m.captures[3]))" end m.captures[3] end @@ -25,7 +26,7 @@ ccall_arg_type(m; r=false) = ccall_arg_type(m.captures[1], m.captures[2], r=r) function decl_arg_type(t, s) if s == "*" if t == "char" - return "AbstractString" + return "AnyString" elseif t == "void" return "Ptr{Nothing}" elseif t == "JNIEnv" @@ -121,4 +122,5 @@ for line in open(readlines, "jnienv.jl", "r") end # println("end") +println("") println("# === Above Generated by ",PROGRAM_FILE," ===") From ac48b34f43974641b4de7e21e82894562eaaf34c Mon Sep 17 00:00:00 2001 From: "markkitt@gmail.com" Date: Sat, 2 May 2020 23:28:53 -0500 Subject: [PATCH 13/18] Move JavaCallError out of JNI module --- src/JNI.jl | 2 +- src/jnienv.jl | 4 ---- src/jvm.jl | 4 ++++ 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/JNI.jl b/src/JNI.jl index 38eb907..ee44100 100644 --- a/src/JNI.jl +++ b/src/JNI.jl @@ -1,7 +1,7 @@ module JNI # jnienv.jl exports -export JNINativeInterface, JNIEnv, JNIInvokeInterface, JavaVM, JavaCallError +export JNINativeInterface, JNIEnv, JNIInvokeInterface, JavaVM # jni_md.h exports export jint, jlong, jbyte # jni.h exports diff --git a/src/jnienv.jl b/src/jnienv.jl index 22cdbb6..95b1d1c 100644 --- a/src/jnienv.jl +++ b/src/jnienv.jl @@ -328,7 +328,3 @@ end struct JavaVM JNIInvokeInterface_::Ptr{JNIInvokeInterface} end - -struct JavaCallError <: Exception - msg::String -end diff --git a/src/jvm.jl b/src/jvm.jl index d0966c4..11e2e49 100644 --- a/src/jvm.jl +++ b/src/jvm.jl @@ -1,6 +1,10 @@ const JAVA_HOME_CANDIDATES = ["/usr/lib/jvm/default-java/", "/usr/lib/jvm/default/"] +struct JavaCallError <: Exception + msg::String +end + function javahome_winreg() keys = ["SOFTWARE\\JavaSoft\\Java Runtime Environment", "SOFTWARE\\JavaSoft\\Java Development Kit", "SOFTWARE\\JavaSoft\\JDK"] From 25d4abe6c441ea730a9182f864d3f2a3dfaabee3 Mon Sep 17 00:00:00 2001 From: "markkitt@gmail.com" Date: Sun, 3 May 2020 21:30:25 -0500 Subject: [PATCH 14/18] Fix init_current_vm() --- src/jvm.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/jvm.jl b/src/jvm.jl index 7a72627..2858c6f 100644 --- a/src/jvm.jl +++ b/src/jvm.jl @@ -360,7 +360,7 @@ function init_current_vm() global pjvm = ppjvm[1] jvm = unsafe_load(pjvm) global jvmfunc = unsafe_load(jvm.JNIInvokeInterface_) - ccall(jvmfunc.GetEnv, Cint, (Ptr{Nothing}, Ptr{Ptr{JNIEnv}}, Cint), pjvm, ppenv, JNI_VERSION_1_8) + ccall(jvmfunc.GetEnv, Cint, (Ptr{Nothing}, Ptr{Ptr{JNIEnv}}, Cint), pjvm, ppenv, JNI.JNI_VERSION_1_8) global penv = ppenv[1] JNI.load_jni(penv) end From c041f1d5c9a3a5897ef9ab0593305d8ff2fed750 Mon Sep 17 00:00:00 2001 From: "markkitt@gmail.com" Date: Sun, 3 May 2020 21:36:35 -0500 Subject: [PATCH 15/18] Do not export ccall wrappers from JNI module --- src/JNI.jl | 170 +---------------------------------------------- src/make_jni2.jl | 2 +- 2 files changed, 4 insertions(+), 168 deletions(-) diff --git a/src/JNI.jl b/src/JNI.jl index ee44100..1aee240 100644 --- a/src/JNI.jl +++ b/src/JNI.jl @@ -8,6 +8,8 @@ export jint, jlong, jbyte export jboolean, jchar, jshort, jfloat, jdouble, jsize, jprimitive # constant export export JNI_TRUE, JNI_FALSE +export JNI_VERSION_1_1, JNI_VERSION_1_2, JNI_VERSION_1_4, JNI_VERSION_1_6, JNI_VERSION_1_8 +export JNI_OK, JNI_ERR, JNI_EDETACHED, JNI_EVERSION, JNI_ENOMEM, JNI_EEXIST, JNI_EINV # Legacy exports export jnifunc @@ -91,677 +93,511 @@ is_jni_loaded() = isdefined(JNI, :jnifunc) # === Below Generated by make_jni2.jl === -#export GetVersion GetVersion(env::Ptr{JNIEnv}) = ccall(jnifunc.GetVersion, jint, (Ptr{JNIEnv},), env) -#export DefineClass DefineClass(env::Ptr{JNIEnv}, name::AnyString, loader::jobject, buf::Array{jbyte,1}, len::Integer) = ccall(jnifunc.DefineClass, jclass, (Ptr{JNIEnv}, Cstring, jobject, Ptr{jbyte}, jsize,), env, name, loader, buf, len) -#export FindClass FindClass(env::Ptr{JNIEnv}, name::AnyString) = ccall(jnifunc.FindClass, jclass, (Ptr{JNIEnv}, Cstring,), env, name) -#export FromReflectedMethod FromReflectedMethod(env::Ptr{JNIEnv}, method::jobject) = ccall(jnifunc.FromReflectedMethod, jmethodID, (Ptr{JNIEnv}, jobject,), env, method) -#export FromReflectedField FromReflectedField(env::Ptr{JNIEnv}, field::jobject) = ccall(jnifunc.FromReflectedField, jfieldID, (Ptr{JNIEnv}, jobject,), env, field) -#export ToReflectedMethod ToReflectedMethod(env::Ptr{JNIEnv}, cls::jclass, methodID::jmethodID, isStatic::jboolean) = ccall(jnifunc.ToReflectedMethod, jobject, (Ptr{JNIEnv}, jclass, jmethodID, jboolean,), env, cls, methodID, isStatic) -#export GetSuperclass GetSuperclass(env::Ptr{JNIEnv}, sub::jclass) = ccall(jnifunc.GetSuperclass, jclass, (Ptr{JNIEnv}, jclass,), env, sub) -#export IsAssignableFrom IsAssignableFrom(env::Ptr{JNIEnv}, sub::jclass, sup::jclass) = ccall(jnifunc.IsAssignableFrom, jboolean, (Ptr{JNIEnv}, jclass, jclass,), env, sub, sup) -#export ToReflectedField ToReflectedField(env::Ptr{JNIEnv}, cls::jclass, fieldID::jfieldID, isStatic::jboolean) = ccall(jnifunc.ToReflectedField, jobject, (Ptr{JNIEnv}, jclass, jfieldID, jboolean,), env, cls, fieldID, isStatic) -#export Throw Throw(env::Ptr{JNIEnv}, obj::jthrowable) = ccall(jnifunc.Throw, jint, (Ptr{JNIEnv}, jthrowable,), env, obj) -#export ThrowNew ThrowNew(env::Ptr{JNIEnv}, clazz::jclass, msg::AnyString) = ccall(jnifunc.ThrowNew, jint, (Ptr{JNIEnv}, jclass, Cstring,), env, clazz, msg) -#export ExceptionOccurred ExceptionOccurred(env::Ptr{JNIEnv}) = ccall(jnifunc.ExceptionOccurred, jthrowable, (Ptr{JNIEnv},), env) -#export ExceptionDescribe ExceptionDescribe(env::Ptr{JNIEnv}) = ccall(jnifunc.ExceptionDescribe, Nothing, (Ptr{JNIEnv},), env) -#export ExceptionClear ExceptionClear(env::Ptr{JNIEnv}) = ccall(jnifunc.ExceptionClear, Nothing, (Ptr{JNIEnv},), env) -#export FatalError FatalError(env::Ptr{JNIEnv}, msg::AnyString) = ccall(jnifunc.FatalError, Nothing, (Ptr{JNIEnv}, Cstring,), env, msg) -#export PushLocalFrame PushLocalFrame(env::Ptr{JNIEnv}, capacity::jint) = ccall(jnifunc.PushLocalFrame, jint, (Ptr{JNIEnv}, jint,), env, capacity) -#export PopLocalFrame PopLocalFrame(env::Ptr{JNIEnv}, result::jobject) = ccall(jnifunc.PopLocalFrame, jobject, (Ptr{JNIEnv}, jobject,), env, result) -#export NewGlobalRef NewGlobalRef(env::Ptr{JNIEnv}, lobj::jobject) = ccall(jnifunc.NewGlobalRef, jobject, (Ptr{JNIEnv}, jobject,), env, lobj) -#export DeleteGlobalRef DeleteGlobalRef(env::Ptr{JNIEnv}, gref::jobject) = ccall(jnifunc.DeleteGlobalRef, Nothing, (Ptr{JNIEnv}, jobject,), env, gref) -#export DeleteLocalRef DeleteLocalRef(env::Ptr{JNIEnv}, obj::jobject) = ccall(jnifunc.DeleteLocalRef, Nothing, (Ptr{JNIEnv}, jobject,), env, obj) -#export IsSameObject IsSameObject(env::Ptr{JNIEnv}, obj1::jobject, obj2::jobject) = ccall(jnifunc.IsSameObject, jboolean, (Ptr{JNIEnv}, jobject, jobject,), env, obj1, obj2) -#export NewLocalRef NewLocalRef(env::Ptr{JNIEnv}, ref::jobject) = ccall(jnifunc.NewLocalRef, jobject, (Ptr{JNIEnv}, jobject,), env, ref) -#export EnsureLocalCapacity EnsureLocalCapacity(env::Ptr{JNIEnv}, capacity::jint) = ccall(jnifunc.EnsureLocalCapacity, jint, (Ptr{JNIEnv}, jint,), env, capacity) -#export AllocObject AllocObject(env::Ptr{JNIEnv}, clazz::jclass) = ccall(jnifunc.AllocObject, jobject, (Ptr{JNIEnv}, jclass,), env, clazz) -#export NewObjectA NewObjectA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = ccall(jnifunc.NewObjectA, jobject, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) -#export GetObjectClass GetObjectClass(env::Ptr{JNIEnv}, obj::jobject) = ccall(jnifunc.GetObjectClass, jclass, (Ptr{JNIEnv}, jobject,), env, obj) -#export IsInstanceOf IsInstanceOf(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass) = ccall(jnifunc.IsInstanceOf, jboolean, (Ptr{JNIEnv}, jobject, jclass,), env, obj, clazz) -#export GetMethodID GetMethodID(env::Ptr{JNIEnv}, clazz::jclass, name::AnyString, sig::AnyString) = ccall(jnifunc.GetMethodID, jmethodID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), env, clazz, name, sig) -#export CallObjectMethodA CallObjectMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = ccall(jnifunc.CallObjectMethodA, jobject, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) -#export CallBooleanMethodA CallBooleanMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = ccall(jnifunc.CallBooleanMethodA, jboolean, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) -#export CallByteMethodA CallByteMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = ccall(jnifunc.CallByteMethodA, jbyte, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) -#export CallCharMethodA CallCharMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = ccall(jnifunc.CallCharMethodA, jchar, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) -#export CallShortMethodA CallShortMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = ccall(jnifunc.CallShortMethodA, jshort, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) -#export CallIntMethodA CallIntMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = ccall(jnifunc.CallIntMethodA, jint, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) -#export CallLongMethodA CallLongMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = ccall(jnifunc.CallLongMethodA, jlong, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) -#export CallFloatMethodA CallFloatMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = ccall(jnifunc.CallFloatMethodA, jfloat, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) -#export CallDoubleMethodA CallDoubleMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = ccall(jnifunc.CallDoubleMethodA, jdouble, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) -#export CallVoidMethodA CallVoidMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = ccall(jnifunc.CallVoidMethodA, Nothing, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) -#export CallNonvirtualObjectMethodA CallNonvirtualObjectMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = ccall(jnifunc.CallNonvirtualObjectMethodA, jobject, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) -#export CallNonvirtualBooleanMethodA CallNonvirtualBooleanMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = ccall(jnifunc.CallNonvirtualBooleanMethodA, jboolean, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) -#export CallNonvirtualByteMethodA CallNonvirtualByteMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = ccall(jnifunc.CallNonvirtualByteMethodA, jbyte, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) -#export CallNonvirtualCharMethodA CallNonvirtualCharMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = ccall(jnifunc.CallNonvirtualCharMethodA, jchar, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) -#export CallNonvirtualShortMethodA CallNonvirtualShortMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = ccall(jnifunc.CallNonvirtualShortMethodA, jshort, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) -#export CallNonvirtualIntMethodA CallNonvirtualIntMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = ccall(jnifunc.CallNonvirtualIntMethodA, jint, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) -#export CallNonvirtualLongMethodA CallNonvirtualLongMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = ccall(jnifunc.CallNonvirtualLongMethodA, jlong, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) -#export CallNonvirtualFloatMethodA CallNonvirtualFloatMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = ccall(jnifunc.CallNonvirtualFloatMethodA, jfloat, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) -#export CallNonvirtualDoubleMethodA CallNonvirtualDoubleMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = ccall(jnifunc.CallNonvirtualDoubleMethodA, jdouble, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) -#export CallNonvirtualVoidMethodA CallNonvirtualVoidMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = ccall(jnifunc.CallNonvirtualVoidMethodA, Nothing, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) -#export GetFieldID GetFieldID(env::Ptr{JNIEnv}, clazz::jclass, name::AnyString, sig::AnyString) = ccall(jnifunc.GetFieldID, jfieldID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), env, clazz, name, sig) -#export GetObjectField GetObjectField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = ccall(jnifunc.GetObjectField, jobject, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) -#export GetBooleanField GetBooleanField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = ccall(jnifunc.GetBooleanField, jboolean, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) -#export GetByteField GetByteField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = ccall(jnifunc.GetByteField, jbyte, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) -#export GetCharField GetCharField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = ccall(jnifunc.GetCharField, jchar, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) -#export GetShortField GetShortField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = ccall(jnifunc.GetShortField, jshort, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) -#export GetIntField GetIntField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = ccall(jnifunc.GetIntField, jint, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) -#export GetLongField GetLongField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = ccall(jnifunc.GetLongField, jlong, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) -#export GetFloatField GetFloatField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = ccall(jnifunc.GetFloatField, jfloat, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) -#export GetDoubleField GetDoubleField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = ccall(jnifunc.GetDoubleField, jdouble, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) -#export SetObjectField SetObjectField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jobject) = ccall(jnifunc.SetObjectField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jobject,), env, obj, fieldID, val) -#export SetBooleanField SetBooleanField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jboolean) = ccall(jnifunc.SetBooleanField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jboolean,), env, obj, fieldID, val) -#export SetByteField SetByteField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jbyte) = ccall(jnifunc.SetByteField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jbyte,), env, obj, fieldID, val) -#export SetCharField SetCharField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jchar) = ccall(jnifunc.SetCharField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jchar,), env, obj, fieldID, val) -#export SetShortField SetShortField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jshort) = ccall(jnifunc.SetShortField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jshort,), env, obj, fieldID, val) -#export SetIntField SetIntField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jint) = ccall(jnifunc.SetIntField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jint,), env, obj, fieldID, val) -#export SetLongField SetLongField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jlong) = ccall(jnifunc.SetLongField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jlong,), env, obj, fieldID, val) -#export SetFloatField SetFloatField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jfloat) = ccall(jnifunc.SetFloatField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jfloat,), env, obj, fieldID, val) -#export SetDoubleField SetDoubleField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jdouble) = ccall(jnifunc.SetDoubleField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jdouble,), env, obj, fieldID, val) -#export GetStaticMethodID GetStaticMethodID(env::Ptr{JNIEnv}, clazz::jclass, name::AnyString, sig::AnyString) = ccall(jnifunc.GetStaticMethodID, jmethodID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), env, clazz, name, sig) -#export CallStaticObjectMethodA CallStaticObjectMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = ccall(jnifunc.CallStaticObjectMethodA, jobject, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) -#export CallStaticBooleanMethodA CallStaticBooleanMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = ccall(jnifunc.CallStaticBooleanMethodA, jboolean, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) -#export CallStaticByteMethodA CallStaticByteMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = ccall(jnifunc.CallStaticByteMethodA, jbyte, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) -#export CallStaticCharMethodA CallStaticCharMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = ccall(jnifunc.CallStaticCharMethodA, jchar, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) -#export CallStaticShortMethodA CallStaticShortMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = ccall(jnifunc.CallStaticShortMethodA, jshort, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) -#export CallStaticIntMethodA CallStaticIntMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = ccall(jnifunc.CallStaticIntMethodA, jint, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) -#export CallStaticLongMethodA CallStaticLongMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = ccall(jnifunc.CallStaticLongMethodA, jlong, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) -#export CallStaticFloatMethodA CallStaticFloatMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = ccall(jnifunc.CallStaticFloatMethodA, jfloat, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) -#export CallStaticDoubleMethodA CallStaticDoubleMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = ccall(jnifunc.CallStaticDoubleMethodA, jdouble, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) -#export CallStaticVoidMethodA CallStaticVoidMethodA(env::Ptr{JNIEnv}, cls::jclass, methodID::jmethodID, args::Array{jvalue,1}) = ccall(jnifunc.CallStaticVoidMethodA, Nothing, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, cls, methodID, args) -#export GetStaticFieldID GetStaticFieldID(env::Ptr{JNIEnv}, clazz::jclass, name::AnyString, sig::AnyString) = ccall(jnifunc.GetStaticFieldID, jfieldID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), env, clazz, name, sig) -#export GetStaticObjectField GetStaticObjectField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = ccall(jnifunc.GetStaticObjectField, jobject, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) -#export GetStaticBooleanField GetStaticBooleanField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = ccall(jnifunc.GetStaticBooleanField, jboolean, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) -#export GetStaticByteField GetStaticByteField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = ccall(jnifunc.GetStaticByteField, jbyte, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) -#export GetStaticCharField GetStaticCharField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = ccall(jnifunc.GetStaticCharField, jchar, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) -#export GetStaticShortField GetStaticShortField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = ccall(jnifunc.GetStaticShortField, jshort, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) -#export GetStaticIntField GetStaticIntField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = ccall(jnifunc.GetStaticIntField, jint, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) -#export GetStaticLongField GetStaticLongField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = ccall(jnifunc.GetStaticLongField, jlong, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) -#export GetStaticFloatField GetStaticFloatField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = ccall(jnifunc.GetStaticFloatField, jfloat, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) -#export GetStaticDoubleField GetStaticDoubleField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = ccall(jnifunc.GetStaticDoubleField, jdouble, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) -#export SetStaticObjectField SetStaticObjectField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jobject) = ccall(jnifunc.SetStaticObjectField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jobject,), env, clazz, fieldID, value) -#export SetStaticBooleanField SetStaticBooleanField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jboolean) = ccall(jnifunc.SetStaticBooleanField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jboolean,), env, clazz, fieldID, value) -#export SetStaticByteField SetStaticByteField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jbyte) = ccall(jnifunc.SetStaticByteField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jbyte,), env, clazz, fieldID, value) -#export SetStaticCharField SetStaticCharField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jchar) = ccall(jnifunc.SetStaticCharField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jchar,), env, clazz, fieldID, value) -#export SetStaticShortField SetStaticShortField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jshort) = ccall(jnifunc.SetStaticShortField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jshort,), env, clazz, fieldID, value) -#export SetStaticIntField SetStaticIntField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jint) = ccall(jnifunc.SetStaticIntField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jint,), env, clazz, fieldID, value) -#export SetStaticLongField SetStaticLongField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jlong) = ccall(jnifunc.SetStaticLongField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jlong,), env, clazz, fieldID, value) -#export SetStaticFloatField SetStaticFloatField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jfloat) = ccall(jnifunc.SetStaticFloatField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jfloat,), env, clazz, fieldID, value) -#export SetStaticDoubleField SetStaticDoubleField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jdouble) = ccall(jnifunc.SetStaticDoubleField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jdouble,), env, clazz, fieldID, value) -#export NewString NewString(env::Ptr{JNIEnv}, unicode::Array{jchar,1}, len::Integer) = ccall(jnifunc.NewString, jstring, (Ptr{JNIEnv}, Ptr{jchar}, jsize,), env, unicode, len) -#export GetStringLength GetStringLength(env::Ptr{JNIEnv}, str::jstring) = ccall(jnifunc.GetStringLength, jsize, (Ptr{JNIEnv}, jstring,), env, str) -#export GetStringChars GetStringChars(env::Ptr{JNIEnv}, str::jstring, isCopy::PtrIsCopy) = ccall(jnifunc.GetStringChars, Ptr{jchar}, (Ptr{JNIEnv}, jstring, Ptr{jboolean},), env, str, isCopy) -#export ReleaseStringChars ReleaseStringChars(env::Ptr{JNIEnv}, str::jstring, chars::Array{jchar,1}) = ccall(jnifunc.ReleaseStringChars, Nothing, (Ptr{JNIEnv}, jstring, Ptr{jchar},), env, str, chars) -#export NewStringUTF NewStringUTF(env::Ptr{JNIEnv}, utf::AnyString) = ccall(jnifunc.NewStringUTF, jstring, (Ptr{JNIEnv}, Cstring,), env, utf) -#export GetStringUTFLength GetStringUTFLength(env::Ptr{JNIEnv}, str::jstring) = ccall(jnifunc.GetStringUTFLength, jsize, (Ptr{JNIEnv}, jstring,), env, str) -#export GetStringUTFChars GetStringUTFChars(env::Ptr{JNIEnv}, str::jstring, isCopy::PtrIsCopy) = ccall(jnifunc.GetStringUTFChars, Cstring, (Ptr{JNIEnv}, jstring, Ptr{jboolean},), env, str, isCopy) -#export ReleaseStringUTFChars ## Prior to this module we used UInt8 instead of Cstring, must match return value of above #ReleaseStringUTFChars(env::Ptr{JNIEnv}, str::jstring, chars::Ptr{UInt8}) = # ccall(jnifunc.ReleaseStringUTFChars, Nothing, (Ptr{JNIEnv}, jstring, Ptr{UInt8},), env, str, chars) ReleaseStringUTFChars(env::Ptr{JNIEnv}, str::jstring, chars::AnyString) = ccall(jnifunc.ReleaseStringUTFChars, Nothing, (Ptr{JNIEnv}, jstring, Cstring,), env, str, chars) -#export GetArrayLength GetArrayLength(env::Ptr{JNIEnv}, array::jarray) = ccall(jnifunc.GetArrayLength, jsize, (Ptr{JNIEnv}, jarray,), env, array) -#export NewObjectArray NewObjectArray(env::Ptr{JNIEnv}, len::Integer, clazz::jclass, init::jobject) = ccall(jnifunc.NewObjectArray, jobjectArray, (Ptr{JNIEnv}, jsize, jclass, jobject,), env, len, clazz, init) -#export GetObjectArrayElement GetObjectArrayElement(env::Ptr{JNIEnv}, array::jobjectArray, index::Integer) = ccall(jnifunc.GetObjectArrayElement, jobject, (Ptr{JNIEnv}, jobjectArray, jsize,), env, array, index) -#export SetObjectArrayElement SetObjectArrayElement(env::Ptr{JNIEnv}, array::jobjectArray, index::Integer, val::jobject) = ccall(jnifunc.SetObjectArrayElement, Nothing, (Ptr{JNIEnv}, jobjectArray, jsize, jobject,), env, array, index, val) -#export NewBooleanArray NewBooleanArray(env::Ptr{JNIEnv}, len::Integer) = ccall(jnifunc.NewBooleanArray, jbooleanArray, (Ptr{JNIEnv}, jsize,), env, len) -#export NewByteArray NewByteArray(env::Ptr{JNIEnv}, len::Integer) = ccall(jnifunc.NewByteArray, jbyteArray, (Ptr{JNIEnv}, jsize,), env, len) -#export NewCharArray NewCharArray(env::Ptr{JNIEnv}, len::Integer) = ccall(jnifunc.NewCharArray, jcharArray, (Ptr{JNIEnv}, jsize,), env, len) -#export NewShortArray NewShortArray(env::Ptr{JNIEnv}, len::Integer) = ccall(jnifunc.NewShortArray, jshortArray, (Ptr{JNIEnv}, jsize,), env, len) -#export NewIntArray NewIntArray(env::Ptr{JNIEnv}, len::Integer) = ccall(jnifunc.NewIntArray, jintArray, (Ptr{JNIEnv}, jsize,), env, len) -#export NewLongArray NewLongArray(env::Ptr{JNIEnv}, len::Integer) = ccall(jnifunc.NewLongArray, jlongArray, (Ptr{JNIEnv}, jsize,), env, len) -#export NewFloatArray NewFloatArray(env::Ptr{JNIEnv}, len::Integer) = ccall(jnifunc.NewFloatArray, jfloatArray, (Ptr{JNIEnv}, jsize,), env, len) -#export NewDoubleArray NewDoubleArray(env::Ptr{JNIEnv}, len::Integer) = ccall(jnifunc.NewDoubleArray, jdoubleArray, (Ptr{JNIEnv}, jsize,), env, len) -#export GetBooleanArrayElements GetBooleanArrayElements(env::Ptr{JNIEnv}, array::jbooleanArray, isCopy::PtrIsCopy) = ccall(jnifunc.GetBooleanArrayElements, Ptr{jboolean}, (Ptr{JNIEnv}, jbooleanArray, Ptr{jboolean},), env, array, isCopy) -#export GetByteArrayElements GetByteArrayElements(env::Ptr{JNIEnv}, array::jbyteArray, isCopy::PtrIsCopy) = ccall(jnifunc.GetByteArrayElements, Ptr{jbyte}, (Ptr{JNIEnv}, jbyteArray, Ptr{jboolean},), env, array, isCopy) -#export GetCharArrayElements GetCharArrayElements(env::Ptr{JNIEnv}, array::jcharArray, isCopy::PtrIsCopy) = ccall(jnifunc.GetCharArrayElements, Ptr{jchar}, (Ptr{JNIEnv}, jcharArray, Ptr{jboolean},), env, array, isCopy) -#export GetShortArrayElements GetShortArrayElements(env::Ptr{JNIEnv}, array::jshortArray, isCopy::PtrIsCopy) = ccall(jnifunc.GetShortArrayElements, Ptr{jshort}, (Ptr{JNIEnv}, jshortArray, Ptr{jboolean},), env, array, isCopy) -#export GetIntArrayElements GetIntArrayElements(env::Ptr{JNIEnv}, array::jintArray, isCopy::PtrIsCopy) = ccall(jnifunc.GetIntArrayElements, Ptr{jint}, (Ptr{JNIEnv}, jintArray, Ptr{jboolean},), env, array, isCopy) -#export GetLongArrayElements GetLongArrayElements(env::Ptr{JNIEnv}, array::jlongArray, isCopy::PtrIsCopy) = ccall(jnifunc.GetLongArrayElements, Ptr{jlong}, (Ptr{JNIEnv}, jlongArray, Ptr{jboolean},), env, array, isCopy) -#export GetFloatArrayElements GetFloatArrayElements(env::Ptr{JNIEnv}, array::jfloatArray, isCopy::PtrIsCopy) = ccall(jnifunc.GetFloatArrayElements, Ptr{jfloat}, (Ptr{JNIEnv}, jfloatArray, Ptr{jboolean},), env, array, isCopy) -#export GetDoubleArrayElements GetDoubleArrayElements(env::Ptr{JNIEnv}, array::jdoubleArray, isCopy::PtrIsCopy) = ccall(jnifunc.GetDoubleArrayElements, Ptr{jdouble}, (Ptr{JNIEnv}, jdoubleArray, Ptr{jboolean},), env, array, isCopy) -#export ReleaseBooleanArrayElements ReleaseBooleanArrayElements(env::Ptr{JNIEnv}, array::jbooleanArray, elems::Ptr{jboolean}, mode::jint) = ccall(jnifunc.ReleaseBooleanArrayElements, Nothing, (Ptr{JNIEnv}, jbooleanArray, Ptr{jboolean}, jint,), env, array, elems, mode) -#export ReleaseByteArrayElements ReleaseByteArrayElements(env::Ptr{JNIEnv}, array::jbyteArray, elems::Ptr{jbyte}, mode::jint) = ccall(jnifunc.ReleaseByteArrayElements, Nothing, (Ptr{JNIEnv}, jbyteArray, Ptr{jbyte}, jint,), env, array, elems, mode) -#export ReleaseCharArrayElements ReleaseCharArrayElements(env::Ptr{JNIEnv}, array::jcharArray, elems::Ptr{jchar}, mode::jint) = ccall(jnifunc.ReleaseCharArrayElements, Nothing, (Ptr{JNIEnv}, jcharArray, Ptr{jchar}, jint,), env, array, elems, mode) -#export ReleaseShortArrayElements ReleaseShortArrayElements(env::Ptr{JNIEnv}, array::jshortArray, elems::Ptr{jshort}, mode::jint) = ccall(jnifunc.ReleaseShortArrayElements, Nothing, (Ptr{JNIEnv}, jshortArray, Ptr{jshort}, jint,), env, array, elems, mode) -#export ReleaseIntArrayElements ReleaseIntArrayElements(env::Ptr{JNIEnv}, array::jintArray, elems::Ptr{jint}, mode::jint) = ccall(jnifunc.ReleaseIntArrayElements, Nothing, (Ptr{JNIEnv}, jintArray, Ptr{jint}, jint,), env, array, elems, mode) -#export ReleaseLongArrayElements ReleaseLongArrayElements(env::Ptr{JNIEnv}, array::jlongArray, elems::Ptr{jlong}, mode::jint) = ccall(jnifunc.ReleaseLongArrayElements, Nothing, (Ptr{JNIEnv}, jlongArray, Ptr{jlong}, jint,), env, array, elems, mode) -#export ReleaseFloatArrayElements ReleaseFloatArrayElements(env::Ptr{JNIEnv}, array::jfloatArray, elems::Ptr{jfloat}, mode::jint) = ccall(jnifunc.ReleaseFloatArrayElements, Nothing, (Ptr{JNIEnv}, jfloatArray, Ptr{jfloat}, jint,), env, array, elems, mode) -#export ReleaseDoubleArrayElements ReleaseDoubleArrayElements(env::Ptr{JNIEnv}, array::jdoubleArray, elems::Ptr{jdouble}, mode::jint) = ccall(jnifunc.ReleaseDoubleArrayElements, Nothing, (Ptr{JNIEnv}, jdoubleArray, Ptr{jdouble}, jint,), env, array, elems, mode) -#export GetBooleanArrayRegion GetBooleanArrayRegion(env::Ptr{JNIEnv}, array::jbooleanArray, start::Integer, l::Integer, buf::Array{jboolean,1}) = ccall(jnifunc.GetBooleanArrayRegion, Nothing, (Ptr{JNIEnv}, jbooleanArray, jsize, jsize, Ptr{jboolean},), env, array, start, l, buf) -#export GetByteArrayRegion GetByteArrayRegion(env::Ptr{JNIEnv}, array::jbyteArray, start::Integer, len::Integer, buf::Array{jbyte,1}) = ccall(jnifunc.GetByteArrayRegion, Nothing, (Ptr{JNIEnv}, jbyteArray, jsize, jsize, Ptr{jbyte},), env, array, start, len, buf) -#export GetCharArrayRegion GetCharArrayRegion(env::Ptr{JNIEnv}, array::jcharArray, start::Integer, len::Integer, buf::Array{jchar,1}) = ccall(jnifunc.GetCharArrayRegion, Nothing, (Ptr{JNIEnv}, jcharArray, jsize, jsize, Ptr{jchar},), env, array, start, len, buf) -#export GetShortArrayRegion GetShortArrayRegion(env::Ptr{JNIEnv}, array::jshortArray, start::Integer, len::Integer, buf::Array{jshort,1}) = ccall(jnifunc.GetShortArrayRegion, Nothing, (Ptr{JNIEnv}, jshortArray, jsize, jsize, Ptr{jshort},), env, array, start, len, buf) -#export GetIntArrayRegion GetIntArrayRegion(env::Ptr{JNIEnv}, array::jintArray, start::Integer, len::Integer, buf::Array{jint,1}) = ccall(jnifunc.GetIntArrayRegion, Nothing, (Ptr{JNIEnv}, jintArray, jsize, jsize, Ptr{jint},), env, array, start, len, buf) -#export GetLongArrayRegion GetLongArrayRegion(env::Ptr{JNIEnv}, array::jlongArray, start::Integer, len::Integer, buf::Array{jlong,1}) = ccall(jnifunc.GetLongArrayRegion, Nothing, (Ptr{JNIEnv}, jlongArray, jsize, jsize, Ptr{jlong},), env, array, start, len, buf) -#export GetFloatArrayRegion GetFloatArrayRegion(env::Ptr{JNIEnv}, array::jfloatArray, start::Integer, len::Integer, buf::Array{jfloat,1}) = ccall(jnifunc.GetFloatArrayRegion, Nothing, (Ptr{JNIEnv}, jfloatArray, jsize, jsize, Ptr{jfloat},), env, array, start, len, buf) -#export GetDoubleArrayRegion GetDoubleArrayRegion(env::Ptr{JNIEnv}, array::jdoubleArray, start::Integer, len::Integer, buf::Array{jdouble,1}) = ccall(jnifunc.GetDoubleArrayRegion, Nothing, (Ptr{JNIEnv}, jdoubleArray, jsize, jsize, Ptr{jdouble},), env, array, start, len, buf) -#export SetBooleanArrayRegion SetBooleanArrayRegion(env::Ptr{JNIEnv}, array::jbooleanArray, start::Integer, l::Integer, buf::Array{jboolean,1}) = ccall(jnifunc.SetBooleanArrayRegion, Nothing, (Ptr{JNIEnv}, jbooleanArray, jsize, jsize, Ptr{jboolean},), env, array, start, l, buf) -#export SetByteArrayRegion SetByteArrayRegion(env::Ptr{JNIEnv}, array::jbyteArray, start::Integer, len::Integer, buf::Array{jbyte,1}) = ccall(jnifunc.SetByteArrayRegion, Nothing, (Ptr{JNIEnv}, jbyteArray, jsize, jsize, Ptr{jbyte},), env, array, start, len, buf) -#export SetCharArrayRegion SetCharArrayRegion(env::Ptr{JNIEnv}, array::jcharArray, start::Integer, len::Integer, buf::Array{jchar,1}) = ccall(jnifunc.SetCharArrayRegion, Nothing, (Ptr{JNIEnv}, jcharArray, jsize, jsize, Ptr{jchar},), env, array, start, len, buf) -#export SetShortArrayRegion SetShortArrayRegion(env::Ptr{JNIEnv}, array::jshortArray, start::Integer, len::Integer, buf::Array{jshort,1}) = ccall(jnifunc.SetShortArrayRegion, Nothing, (Ptr{JNIEnv}, jshortArray, jsize, jsize, Ptr{jshort},), env, array, start, len, buf) -#export SetIntArrayRegion SetIntArrayRegion(env::Ptr{JNIEnv}, array::jintArray, start::Integer, len::Integer, buf::Array{jint,1}) = ccall(jnifunc.SetIntArrayRegion, Nothing, (Ptr{JNIEnv}, jintArray, jsize, jsize, Ptr{jint},), env, array, start, len, buf) -#export SetLongArrayRegion SetLongArrayRegion(env::Ptr{JNIEnv}, array::jlongArray, start::Integer, len::Integer, buf::Array{jlong,1}) = ccall(jnifunc.SetLongArrayRegion, Nothing, (Ptr{JNIEnv}, jlongArray, jsize, jsize, Ptr{jlong},), env, array, start, len, buf) -#export SetFloatArrayRegion SetFloatArrayRegion(env::Ptr{JNIEnv}, array::jfloatArray, start::Integer, len::Integer, buf::Array{jfloat,1}) = ccall(jnifunc.SetFloatArrayRegion, Nothing, (Ptr{JNIEnv}, jfloatArray, jsize, jsize, Ptr{jfloat},), env, array, start, len, buf) -#export SetDoubleArrayRegion SetDoubleArrayRegion(env::Ptr{JNIEnv}, array::jdoubleArray, start::Integer, len::Integer, buf::Array{jdouble,1}) = ccall(jnifunc.SetDoubleArrayRegion, Nothing, (Ptr{JNIEnv}, jdoubleArray, jsize, jsize, Ptr{jdouble},), env, array, start, len, buf) -#export RegisterNatives RegisterNatives(env::Ptr{JNIEnv}, clazz::jclass, methods::Array{JNINativeMethod,1}, nMethods::jint) = ccall(jnifunc.RegisterNatives, jint, (Ptr{JNIEnv}, jclass, Ptr{JNINativeMethod}, jint,), env, clazz, methods, nMethods) -#export UnregisterNatives UnregisterNatives(env::Ptr{JNIEnv}, clazz::jclass) = ccall(jnifunc.UnregisterNatives, jint, (Ptr{JNIEnv}, jclass,), env, clazz) -#export MonitorEnter MonitorEnter(env::Ptr{JNIEnv}, obj::jobject) = ccall(jnifunc.MonitorEnter, jint, (Ptr{JNIEnv}, jobject,), env, obj) -#export MonitorExit MonitorExit(env::Ptr{JNIEnv}, obj::jobject) = ccall(jnifunc.MonitorExit, jint, (Ptr{JNIEnv}, jobject,), env, obj) -#export GetJavaVM GetJavaVM(env::Ptr{JNIEnv}, vm::Array{JavaVM,1}) = ccall(jnifunc.GetJavaVM, jint, (Ptr{JNIEnv}, Array{JavaVM,1},), env, vm) -#export GetStringRegion GetStringRegion(env::Ptr{JNIEnv}, str::jstring, start::Integer, len::Integer, buf::Array{jchar,1}) = ccall(jnifunc.GetStringRegion, Nothing, (Ptr{JNIEnv}, jstring, jsize, jsize, Ptr{jchar},), env, str, start, len, buf) -#export GetStringUTFRegion GetStringUTFRegion(env::Ptr{JNIEnv}, str::jstring, start::Integer, len::Integer, buf::AnyString) = ccall(jnifunc.GetStringUTFRegion, Nothing, (Ptr{JNIEnv}, jstring, jsize, jsize, Cstring,), env, str, start, len, buf) -#export GetPrimitiveArrayCritical GetPrimitiveArrayCritical(env::Ptr{JNIEnv}, array::jarray, isCopy::PtrIsCopy) = ccall(jnifunc.GetPrimitiveArrayCritical, Ptr{Nothing}, (Ptr{JNIEnv}, jarray, Ptr{jboolean},), env, array, isCopy) -#export ReleasePrimitiveArrayCritical ReleasePrimitiveArrayCritical(env::Ptr{JNIEnv}, array::jarray, carray::Ptr{Nothing}, mode::jint) = ccall(jnifunc.ReleasePrimitiveArrayCritical, Nothing, (Ptr{JNIEnv}, jarray, Ptr{Nothing}, jint,), env, array, carray, mode) -#export GetStringCritical GetStringCritical(env::Ptr{JNIEnv}, string::jstring, isCopy::PtrIsCopy) = ccall(jnifunc.GetStringCritical, Ptr{jchar}, (Ptr{JNIEnv}, jstring, Ptr{jboolean},), env, string, isCopy) -#export ReleaseStringCritical ReleaseStringCritical(env::Ptr{JNIEnv}, string::jstring, cstring::Array{jchar,1}) = ccall(jnifunc.ReleaseStringCritical, Nothing, (Ptr{JNIEnv}, jstring, Ptr{jchar},), env, string, cstring) -#export NewWeakGlobalRef NewWeakGlobalRef(env::Ptr{JNIEnv}, obj::jobject) = ccall(jnifunc.NewWeakGlobalRef, jweak, (Ptr{JNIEnv}, jobject,), env, obj) -#export DeleteWeakGlobalRef DeleteWeakGlobalRef(env::Ptr{JNIEnv}, ref::jweak) = ccall(jnifunc.DeleteWeakGlobalRef, Nothing, (Ptr{JNIEnv}, jweak,), env, ref) -#export ExceptionCheck ExceptionCheck(env::Ptr{JNIEnv}) = ccall(jnifunc.ExceptionCheck, jboolean, (Ptr{JNIEnv},), env) -#export NewDirectByteBuffer NewDirectByteBuffer(env::Ptr{JNIEnv}, address::Ptr{Nothing}, capacity::jlong) = ccall(jnifunc.NewDirectByteBuffer, jobject, (Ptr{JNIEnv}, Ptr{Nothing}, jlong,), env, address, capacity) -#export GetDirectBufferAddress GetDirectBufferAddress(env::Ptr{JNIEnv}, buf::jobject) = ccall(jnifunc.GetDirectBufferAddress, Ptr{Nothing}, (Ptr{JNIEnv}, jobject,), env, buf) -#export GetDirectBufferCapacity GetDirectBufferCapacity(env::Ptr{JNIEnv}, buf::jobject) = ccall(jnifunc.GetDirectBufferCapacity, jlong, (Ptr{JNIEnv}, jobject,), env, buf) -#export GetObjectRefType GetObjectRefType(env::Ptr{JNIEnv}, obj::jobject) = ccall(jnifunc.GetObjectRefType, jobjectRefType, (Ptr{JNIEnv}, jobject,), env, obj) + # === Above Generated by make_jni2.jl === end diff --git a/src/make_jni2.jl b/src/make_jni2.jl index 0beff6d..4cdc78a 100644 --- a/src/make_jni2.jl +++ b/src/make_jni2.jl @@ -117,7 +117,7 @@ for line in open(readlines, "jnienv.jl", "r") arg_names = join(map(arg_value, mm), ", ") # Commented out export command - print("#export $fname\n") + # print("#export $fname\n") print("$fname($julia_args) =\n ccall(jnifunc.$(fname), $rtype, ($arg_types,), $arg_names)\n\n") end From 44af649acf8ec42d224b1fb5d8873e45a9df4f19 Mon Sep 17 00:00:00 2001 From: "markkitt@gmail.com" Date: Sun, 3 May 2020 22:07:01 -0500 Subject: [PATCH 16/18] Use a constant reference rather than global for JNINativeInterface --- src/JNI.jl | 343 ++++++++++++++++++++++++----------------------- src/make_jni2.jl | 2 +- 2 files changed, 174 insertions(+), 171 deletions(-) diff --git a/src/JNI.jl b/src/JNI.jl index 1aee240..273551c 100644 --- a/src/JNI.jl +++ b/src/JNI.jl @@ -9,13 +9,15 @@ export jboolean, jchar, jshort, jfloat, jdouble, jsize, jprimitive # constant export export JNI_TRUE, JNI_FALSE export JNI_VERSION_1_1, JNI_VERSION_1_2, JNI_VERSION_1_4, JNI_VERSION_1_6, JNI_VERSION_1_8 +# export JNI_VERSION_9, JNI_VERSION_10 # Intentionally excluded, use JNI.JNI_VERSION_9 export JNI_OK, JNI_ERR, JNI_EDETACHED, JNI_EVERSION, JNI_ENOMEM, JNI_EEXIST, JNI_EINV # Legacy exports export jnifunc include("jnienv.jl") -global jnifunc +const jniref = Ref{JNINativeInterface}() +global jnifunc::JNINativeInterface # jni_md.h const jint = Cint @@ -87,515 +89,516 @@ AnyString = Union{AbstractString,Cstring,Ptr{UInt8}} function load_jni(penv::Ptr{JNIEnv}) jnienv = unsafe_load(penv) - global jnifunc = unsafe_load(jnienv.JNINativeInterface_) #The JNI Function table + jniref[] = unsafe_load(jnienv.JNINativeInterface_) #The JNI Function table + global jnifunc = jniref[] end is_jni_loaded() = isdefined(JNI, :jnifunc) # === Below Generated by make_jni2.jl === GetVersion(env::Ptr{JNIEnv}) = - ccall(jnifunc.GetVersion, jint, (Ptr{JNIEnv},), env) + ccall(jniref[].GetVersion, jint, (Ptr{JNIEnv},), env) DefineClass(env::Ptr{JNIEnv}, name::AnyString, loader::jobject, buf::Array{jbyte,1}, len::Integer) = - ccall(jnifunc.DefineClass, jclass, (Ptr{JNIEnv}, Cstring, jobject, Ptr{jbyte}, jsize,), env, name, loader, buf, len) + ccall(jniref[].DefineClass, jclass, (Ptr{JNIEnv}, Cstring, jobject, Ptr{jbyte}, jsize,), env, name, loader, buf, len) FindClass(env::Ptr{JNIEnv}, name::AnyString) = - ccall(jnifunc.FindClass, jclass, (Ptr{JNIEnv}, Cstring,), env, name) + ccall(jniref[].FindClass, jclass, (Ptr{JNIEnv}, Cstring,), env, name) FromReflectedMethod(env::Ptr{JNIEnv}, method::jobject) = - ccall(jnifunc.FromReflectedMethod, jmethodID, (Ptr{JNIEnv}, jobject,), env, method) + ccall(jniref[].FromReflectedMethod, jmethodID, (Ptr{JNIEnv}, jobject,), env, method) FromReflectedField(env::Ptr{JNIEnv}, field::jobject) = - ccall(jnifunc.FromReflectedField, jfieldID, (Ptr{JNIEnv}, jobject,), env, field) + ccall(jniref[].FromReflectedField, jfieldID, (Ptr{JNIEnv}, jobject,), env, field) ToReflectedMethod(env::Ptr{JNIEnv}, cls::jclass, methodID::jmethodID, isStatic::jboolean) = - ccall(jnifunc.ToReflectedMethod, jobject, (Ptr{JNIEnv}, jclass, jmethodID, jboolean,), env, cls, methodID, isStatic) + ccall(jniref[].ToReflectedMethod, jobject, (Ptr{JNIEnv}, jclass, jmethodID, jboolean,), env, cls, methodID, isStatic) GetSuperclass(env::Ptr{JNIEnv}, sub::jclass) = - ccall(jnifunc.GetSuperclass, jclass, (Ptr{JNIEnv}, jclass,), env, sub) + ccall(jniref[].GetSuperclass, jclass, (Ptr{JNIEnv}, jclass,), env, sub) IsAssignableFrom(env::Ptr{JNIEnv}, sub::jclass, sup::jclass) = - ccall(jnifunc.IsAssignableFrom, jboolean, (Ptr{JNIEnv}, jclass, jclass,), env, sub, sup) + ccall(jniref[].IsAssignableFrom, jboolean, (Ptr{JNIEnv}, jclass, jclass,), env, sub, sup) ToReflectedField(env::Ptr{JNIEnv}, cls::jclass, fieldID::jfieldID, isStatic::jboolean) = - ccall(jnifunc.ToReflectedField, jobject, (Ptr{JNIEnv}, jclass, jfieldID, jboolean,), env, cls, fieldID, isStatic) + ccall(jniref[].ToReflectedField, jobject, (Ptr{JNIEnv}, jclass, jfieldID, jboolean,), env, cls, fieldID, isStatic) Throw(env::Ptr{JNIEnv}, obj::jthrowable) = - ccall(jnifunc.Throw, jint, (Ptr{JNIEnv}, jthrowable,), env, obj) + ccall(jniref[].Throw, jint, (Ptr{JNIEnv}, jthrowable,), env, obj) ThrowNew(env::Ptr{JNIEnv}, clazz::jclass, msg::AnyString) = - ccall(jnifunc.ThrowNew, jint, (Ptr{JNIEnv}, jclass, Cstring,), env, clazz, msg) + ccall(jniref[].ThrowNew, jint, (Ptr{JNIEnv}, jclass, Cstring,), env, clazz, msg) ExceptionOccurred(env::Ptr{JNIEnv}) = - ccall(jnifunc.ExceptionOccurred, jthrowable, (Ptr{JNIEnv},), env) + ccall(jniref[].ExceptionOccurred, jthrowable, (Ptr{JNIEnv},), env) ExceptionDescribe(env::Ptr{JNIEnv}) = - ccall(jnifunc.ExceptionDescribe, Nothing, (Ptr{JNIEnv},), env) + ccall(jniref[].ExceptionDescribe, Nothing, (Ptr{JNIEnv},), env) ExceptionClear(env::Ptr{JNIEnv}) = - ccall(jnifunc.ExceptionClear, Nothing, (Ptr{JNIEnv},), env) + ccall(jniref[].ExceptionClear, Nothing, (Ptr{JNIEnv},), env) FatalError(env::Ptr{JNIEnv}, msg::AnyString) = - ccall(jnifunc.FatalError, Nothing, (Ptr{JNIEnv}, Cstring,), env, msg) + ccall(jniref[].FatalError, Nothing, (Ptr{JNIEnv}, Cstring,), env, msg) PushLocalFrame(env::Ptr{JNIEnv}, capacity::jint) = - ccall(jnifunc.PushLocalFrame, jint, (Ptr{JNIEnv}, jint,), env, capacity) + ccall(jniref[].PushLocalFrame, jint, (Ptr{JNIEnv}, jint,), env, capacity) PopLocalFrame(env::Ptr{JNIEnv}, result::jobject) = - ccall(jnifunc.PopLocalFrame, jobject, (Ptr{JNIEnv}, jobject,), env, result) + ccall(jniref[].PopLocalFrame, jobject, (Ptr{JNIEnv}, jobject,), env, result) NewGlobalRef(env::Ptr{JNIEnv}, lobj::jobject) = - ccall(jnifunc.NewGlobalRef, jobject, (Ptr{JNIEnv}, jobject,), env, lobj) + ccall(jniref[].NewGlobalRef, jobject, (Ptr{JNIEnv}, jobject,), env, lobj) DeleteGlobalRef(env::Ptr{JNIEnv}, gref::jobject) = - ccall(jnifunc.DeleteGlobalRef, Nothing, (Ptr{JNIEnv}, jobject,), env, gref) + ccall(jniref[].DeleteGlobalRef, Nothing, (Ptr{JNIEnv}, jobject,), env, gref) DeleteLocalRef(env::Ptr{JNIEnv}, obj::jobject) = - ccall(jnifunc.DeleteLocalRef, Nothing, (Ptr{JNIEnv}, jobject,), env, obj) + ccall(jniref[].DeleteLocalRef, Nothing, (Ptr{JNIEnv}, jobject,), env, obj) IsSameObject(env::Ptr{JNIEnv}, obj1::jobject, obj2::jobject) = - ccall(jnifunc.IsSameObject, jboolean, (Ptr{JNIEnv}, jobject, jobject,), env, obj1, obj2) + ccall(jniref[].IsSameObject, jboolean, (Ptr{JNIEnv}, jobject, jobject,), env, obj1, obj2) NewLocalRef(env::Ptr{JNIEnv}, ref::jobject) = - ccall(jnifunc.NewLocalRef, jobject, (Ptr{JNIEnv}, jobject,), env, ref) + ccall(jniref[].NewLocalRef, jobject, (Ptr{JNIEnv}, jobject,), env, ref) EnsureLocalCapacity(env::Ptr{JNIEnv}, capacity::jint) = - ccall(jnifunc.EnsureLocalCapacity, jint, (Ptr{JNIEnv}, jint,), env, capacity) + ccall(jniref[].EnsureLocalCapacity, jint, (Ptr{JNIEnv}, jint,), env, capacity) AllocObject(env::Ptr{JNIEnv}, clazz::jclass) = - ccall(jnifunc.AllocObject, jobject, (Ptr{JNIEnv}, jclass,), env, clazz) + ccall(jniref[].AllocObject, jobject, (Ptr{JNIEnv}, jclass,), env, clazz) NewObjectA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jnifunc.NewObjectA, jobject, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) + ccall(jniref[].NewObjectA, jobject, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) GetObjectClass(env::Ptr{JNIEnv}, obj::jobject) = - ccall(jnifunc.GetObjectClass, jclass, (Ptr{JNIEnv}, jobject,), env, obj) + ccall(jniref[].GetObjectClass, jclass, (Ptr{JNIEnv}, jobject,), env, obj) IsInstanceOf(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass) = - ccall(jnifunc.IsInstanceOf, jboolean, (Ptr{JNIEnv}, jobject, jclass,), env, obj, clazz) + ccall(jniref[].IsInstanceOf, jboolean, (Ptr{JNIEnv}, jobject, jclass,), env, obj, clazz) GetMethodID(env::Ptr{JNIEnv}, clazz::jclass, name::AnyString, sig::AnyString) = - ccall(jnifunc.GetMethodID, jmethodID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), env, clazz, name, sig) + ccall(jniref[].GetMethodID, jmethodID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), env, clazz, name, sig) CallObjectMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jnifunc.CallObjectMethodA, jobject, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) + ccall(jniref[].CallObjectMethodA, jobject, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) CallBooleanMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jnifunc.CallBooleanMethodA, jboolean, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) + ccall(jniref[].CallBooleanMethodA, jboolean, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) CallByteMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jnifunc.CallByteMethodA, jbyte, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) + ccall(jniref[].CallByteMethodA, jbyte, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) CallCharMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jnifunc.CallCharMethodA, jchar, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) + ccall(jniref[].CallCharMethodA, jchar, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) CallShortMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jnifunc.CallShortMethodA, jshort, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) + ccall(jniref[].CallShortMethodA, jshort, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) CallIntMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jnifunc.CallIntMethodA, jint, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) + ccall(jniref[].CallIntMethodA, jint, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) CallLongMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jnifunc.CallLongMethodA, jlong, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) + ccall(jniref[].CallLongMethodA, jlong, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) CallFloatMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jnifunc.CallFloatMethodA, jfloat, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) + ccall(jniref[].CallFloatMethodA, jfloat, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) CallDoubleMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jnifunc.CallDoubleMethodA, jdouble, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) + ccall(jniref[].CallDoubleMethodA, jdouble, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) CallVoidMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jnifunc.CallVoidMethodA, Nothing, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) + ccall(jniref[].CallVoidMethodA, Nothing, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) CallNonvirtualObjectMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jnifunc.CallNonvirtualObjectMethodA, jobject, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) + ccall(jniref[].CallNonvirtualObjectMethodA, jobject, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) CallNonvirtualBooleanMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jnifunc.CallNonvirtualBooleanMethodA, jboolean, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) + ccall(jniref[].CallNonvirtualBooleanMethodA, jboolean, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) CallNonvirtualByteMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jnifunc.CallNonvirtualByteMethodA, jbyte, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) + ccall(jniref[].CallNonvirtualByteMethodA, jbyte, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) CallNonvirtualCharMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jnifunc.CallNonvirtualCharMethodA, jchar, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) + ccall(jniref[].CallNonvirtualCharMethodA, jchar, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) CallNonvirtualShortMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jnifunc.CallNonvirtualShortMethodA, jshort, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) + ccall(jniref[].CallNonvirtualShortMethodA, jshort, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) CallNonvirtualIntMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jnifunc.CallNonvirtualIntMethodA, jint, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) + ccall(jniref[].CallNonvirtualIntMethodA, jint, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) CallNonvirtualLongMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jnifunc.CallNonvirtualLongMethodA, jlong, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) + ccall(jniref[].CallNonvirtualLongMethodA, jlong, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) CallNonvirtualFloatMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jnifunc.CallNonvirtualFloatMethodA, jfloat, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) + ccall(jniref[].CallNonvirtualFloatMethodA, jfloat, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) CallNonvirtualDoubleMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jnifunc.CallNonvirtualDoubleMethodA, jdouble, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) + ccall(jniref[].CallNonvirtualDoubleMethodA, jdouble, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) CallNonvirtualVoidMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jnifunc.CallNonvirtualVoidMethodA, Nothing, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) + ccall(jniref[].CallNonvirtualVoidMethodA, Nothing, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) GetFieldID(env::Ptr{JNIEnv}, clazz::jclass, name::AnyString, sig::AnyString) = - ccall(jnifunc.GetFieldID, jfieldID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), env, clazz, name, sig) + ccall(jniref[].GetFieldID, jfieldID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), env, clazz, name, sig) GetObjectField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = - ccall(jnifunc.GetObjectField, jobject, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) + ccall(jniref[].GetObjectField, jobject, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) GetBooleanField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = - ccall(jnifunc.GetBooleanField, jboolean, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) + ccall(jniref[].GetBooleanField, jboolean, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) GetByteField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = - ccall(jnifunc.GetByteField, jbyte, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) + ccall(jniref[].GetByteField, jbyte, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) GetCharField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = - ccall(jnifunc.GetCharField, jchar, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) + ccall(jniref[].GetCharField, jchar, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) GetShortField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = - ccall(jnifunc.GetShortField, jshort, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) + ccall(jniref[].GetShortField, jshort, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) GetIntField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = - ccall(jnifunc.GetIntField, jint, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) + ccall(jniref[].GetIntField, jint, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) GetLongField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = - ccall(jnifunc.GetLongField, jlong, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) + ccall(jniref[].GetLongField, jlong, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) GetFloatField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = - ccall(jnifunc.GetFloatField, jfloat, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) + ccall(jniref[].GetFloatField, jfloat, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) GetDoubleField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = - ccall(jnifunc.GetDoubleField, jdouble, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) + ccall(jniref[].GetDoubleField, jdouble, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) SetObjectField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jobject) = - ccall(jnifunc.SetObjectField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jobject,), env, obj, fieldID, val) + ccall(jniref[].SetObjectField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jobject,), env, obj, fieldID, val) SetBooleanField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jboolean) = - ccall(jnifunc.SetBooleanField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jboolean,), env, obj, fieldID, val) + ccall(jniref[].SetBooleanField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jboolean,), env, obj, fieldID, val) SetByteField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jbyte) = - ccall(jnifunc.SetByteField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jbyte,), env, obj, fieldID, val) + ccall(jniref[].SetByteField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jbyte,), env, obj, fieldID, val) SetCharField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jchar) = - ccall(jnifunc.SetCharField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jchar,), env, obj, fieldID, val) + ccall(jniref[].SetCharField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jchar,), env, obj, fieldID, val) SetShortField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jshort) = - ccall(jnifunc.SetShortField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jshort,), env, obj, fieldID, val) + ccall(jniref[].SetShortField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jshort,), env, obj, fieldID, val) SetIntField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jint) = - ccall(jnifunc.SetIntField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jint,), env, obj, fieldID, val) + ccall(jniref[].SetIntField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jint,), env, obj, fieldID, val) SetLongField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jlong) = - ccall(jnifunc.SetLongField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jlong,), env, obj, fieldID, val) + ccall(jniref[].SetLongField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jlong,), env, obj, fieldID, val) SetFloatField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jfloat) = - ccall(jnifunc.SetFloatField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jfloat,), env, obj, fieldID, val) + ccall(jniref[].SetFloatField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jfloat,), env, obj, fieldID, val) SetDoubleField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jdouble) = - ccall(jnifunc.SetDoubleField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jdouble,), env, obj, fieldID, val) + ccall(jniref[].SetDoubleField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jdouble,), env, obj, fieldID, val) GetStaticMethodID(env::Ptr{JNIEnv}, clazz::jclass, name::AnyString, sig::AnyString) = - ccall(jnifunc.GetStaticMethodID, jmethodID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), env, clazz, name, sig) + ccall(jniref[].GetStaticMethodID, jmethodID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), env, clazz, name, sig) CallStaticObjectMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jnifunc.CallStaticObjectMethodA, jobject, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) + ccall(jniref[].CallStaticObjectMethodA, jobject, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) CallStaticBooleanMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jnifunc.CallStaticBooleanMethodA, jboolean, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) + ccall(jniref[].CallStaticBooleanMethodA, jboolean, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) CallStaticByteMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jnifunc.CallStaticByteMethodA, jbyte, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) + ccall(jniref[].CallStaticByteMethodA, jbyte, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) CallStaticCharMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jnifunc.CallStaticCharMethodA, jchar, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) + ccall(jniref[].CallStaticCharMethodA, jchar, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) CallStaticShortMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jnifunc.CallStaticShortMethodA, jshort, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) + ccall(jniref[].CallStaticShortMethodA, jshort, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) CallStaticIntMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jnifunc.CallStaticIntMethodA, jint, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) + ccall(jniref[].CallStaticIntMethodA, jint, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) CallStaticLongMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jnifunc.CallStaticLongMethodA, jlong, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) + ccall(jniref[].CallStaticLongMethodA, jlong, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) CallStaticFloatMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jnifunc.CallStaticFloatMethodA, jfloat, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) + ccall(jniref[].CallStaticFloatMethodA, jfloat, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) CallStaticDoubleMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jnifunc.CallStaticDoubleMethodA, jdouble, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) + ccall(jniref[].CallStaticDoubleMethodA, jdouble, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) CallStaticVoidMethodA(env::Ptr{JNIEnv}, cls::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jnifunc.CallStaticVoidMethodA, Nothing, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, cls, methodID, args) + ccall(jniref[].CallStaticVoidMethodA, Nothing, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, cls, methodID, args) GetStaticFieldID(env::Ptr{JNIEnv}, clazz::jclass, name::AnyString, sig::AnyString) = - ccall(jnifunc.GetStaticFieldID, jfieldID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), env, clazz, name, sig) + ccall(jniref[].GetStaticFieldID, jfieldID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), env, clazz, name, sig) GetStaticObjectField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = - ccall(jnifunc.GetStaticObjectField, jobject, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) + ccall(jniref[].GetStaticObjectField, jobject, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) GetStaticBooleanField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = - ccall(jnifunc.GetStaticBooleanField, jboolean, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) + ccall(jniref[].GetStaticBooleanField, jboolean, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) GetStaticByteField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = - ccall(jnifunc.GetStaticByteField, jbyte, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) + ccall(jniref[].GetStaticByteField, jbyte, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) GetStaticCharField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = - ccall(jnifunc.GetStaticCharField, jchar, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) + ccall(jniref[].GetStaticCharField, jchar, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) GetStaticShortField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = - ccall(jnifunc.GetStaticShortField, jshort, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) + ccall(jniref[].GetStaticShortField, jshort, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) GetStaticIntField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = - ccall(jnifunc.GetStaticIntField, jint, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) + ccall(jniref[].GetStaticIntField, jint, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) GetStaticLongField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = - ccall(jnifunc.GetStaticLongField, jlong, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) + ccall(jniref[].GetStaticLongField, jlong, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) GetStaticFloatField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = - ccall(jnifunc.GetStaticFloatField, jfloat, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) + ccall(jniref[].GetStaticFloatField, jfloat, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) GetStaticDoubleField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = - ccall(jnifunc.GetStaticDoubleField, jdouble, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) + ccall(jniref[].GetStaticDoubleField, jdouble, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) SetStaticObjectField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jobject) = - ccall(jnifunc.SetStaticObjectField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jobject,), env, clazz, fieldID, value) + ccall(jniref[].SetStaticObjectField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jobject,), env, clazz, fieldID, value) SetStaticBooleanField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jboolean) = - ccall(jnifunc.SetStaticBooleanField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jboolean,), env, clazz, fieldID, value) + ccall(jniref[].SetStaticBooleanField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jboolean,), env, clazz, fieldID, value) SetStaticByteField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jbyte) = - ccall(jnifunc.SetStaticByteField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jbyte,), env, clazz, fieldID, value) + ccall(jniref[].SetStaticByteField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jbyte,), env, clazz, fieldID, value) SetStaticCharField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jchar) = - ccall(jnifunc.SetStaticCharField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jchar,), env, clazz, fieldID, value) + ccall(jniref[].SetStaticCharField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jchar,), env, clazz, fieldID, value) SetStaticShortField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jshort) = - ccall(jnifunc.SetStaticShortField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jshort,), env, clazz, fieldID, value) + ccall(jniref[].SetStaticShortField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jshort,), env, clazz, fieldID, value) SetStaticIntField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jint) = - ccall(jnifunc.SetStaticIntField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jint,), env, clazz, fieldID, value) + ccall(jniref[].SetStaticIntField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jint,), env, clazz, fieldID, value) SetStaticLongField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jlong) = - ccall(jnifunc.SetStaticLongField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jlong,), env, clazz, fieldID, value) + ccall(jniref[].SetStaticLongField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jlong,), env, clazz, fieldID, value) SetStaticFloatField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jfloat) = - ccall(jnifunc.SetStaticFloatField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jfloat,), env, clazz, fieldID, value) + ccall(jniref[].SetStaticFloatField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jfloat,), env, clazz, fieldID, value) SetStaticDoubleField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jdouble) = - ccall(jnifunc.SetStaticDoubleField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jdouble,), env, clazz, fieldID, value) + ccall(jniref[].SetStaticDoubleField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jdouble,), env, clazz, fieldID, value) NewString(env::Ptr{JNIEnv}, unicode::Array{jchar,1}, len::Integer) = - ccall(jnifunc.NewString, jstring, (Ptr{JNIEnv}, Ptr{jchar}, jsize,), env, unicode, len) + ccall(jniref[].NewString, jstring, (Ptr{JNIEnv}, Ptr{jchar}, jsize,), env, unicode, len) GetStringLength(env::Ptr{JNIEnv}, str::jstring) = - ccall(jnifunc.GetStringLength, jsize, (Ptr{JNIEnv}, jstring,), env, str) + ccall(jniref[].GetStringLength, jsize, (Ptr{JNIEnv}, jstring,), env, str) GetStringChars(env::Ptr{JNIEnv}, str::jstring, isCopy::PtrIsCopy) = - ccall(jnifunc.GetStringChars, Ptr{jchar}, (Ptr{JNIEnv}, jstring, Ptr{jboolean},), env, str, isCopy) + ccall(jniref[].GetStringChars, Ptr{jchar}, (Ptr{JNIEnv}, jstring, Ptr{jboolean},), env, str, isCopy) ReleaseStringChars(env::Ptr{JNIEnv}, str::jstring, chars::Array{jchar,1}) = - ccall(jnifunc.ReleaseStringChars, Nothing, (Ptr{JNIEnv}, jstring, Ptr{jchar},), env, str, chars) + ccall(jniref[].ReleaseStringChars, Nothing, (Ptr{JNIEnv}, jstring, Ptr{jchar},), env, str, chars) NewStringUTF(env::Ptr{JNIEnv}, utf::AnyString) = - ccall(jnifunc.NewStringUTF, jstring, (Ptr{JNIEnv}, Cstring,), env, utf) + ccall(jniref[].NewStringUTF, jstring, (Ptr{JNIEnv}, Cstring,), env, utf) GetStringUTFLength(env::Ptr{JNIEnv}, str::jstring) = - ccall(jnifunc.GetStringUTFLength, jsize, (Ptr{JNIEnv}, jstring,), env, str) + ccall(jniref[].GetStringUTFLength, jsize, (Ptr{JNIEnv}, jstring,), env, str) GetStringUTFChars(env::Ptr{JNIEnv}, str::jstring, isCopy::PtrIsCopy) = - ccall(jnifunc.GetStringUTFChars, Cstring, (Ptr{JNIEnv}, jstring, Ptr{jboolean},), env, str, isCopy) + ccall(jniref[].GetStringUTFChars, Cstring, (Ptr{JNIEnv}, jstring, Ptr{jboolean},), env, str, isCopy) ## Prior to this module we used UInt8 instead of Cstring, must match return value of above #ReleaseStringUTFChars(env::Ptr{JNIEnv}, str::jstring, chars::Ptr{UInt8}) = -# ccall(jnifunc.ReleaseStringUTFChars, Nothing, (Ptr{JNIEnv}, jstring, Ptr{UInt8},), env, str, chars) +# ccall(jniref[].ReleaseStringUTFChars, Nothing, (Ptr{JNIEnv}, jstring, Ptr{UInt8},), env, str, chars) ReleaseStringUTFChars(env::Ptr{JNIEnv}, str::jstring, chars::AnyString) = - ccall(jnifunc.ReleaseStringUTFChars, Nothing, (Ptr{JNIEnv}, jstring, Cstring,), env, str, chars) + ccall(jniref[].ReleaseStringUTFChars, Nothing, (Ptr{JNIEnv}, jstring, Cstring,), env, str, chars) GetArrayLength(env::Ptr{JNIEnv}, array::jarray) = - ccall(jnifunc.GetArrayLength, jsize, (Ptr{JNIEnv}, jarray,), env, array) + ccall(jniref[].GetArrayLength, jsize, (Ptr{JNIEnv}, jarray,), env, array) NewObjectArray(env::Ptr{JNIEnv}, len::Integer, clazz::jclass, init::jobject) = - ccall(jnifunc.NewObjectArray, jobjectArray, (Ptr{JNIEnv}, jsize, jclass, jobject,), env, len, clazz, init) + ccall(jniref[].NewObjectArray, jobjectArray, (Ptr{JNIEnv}, jsize, jclass, jobject,), env, len, clazz, init) GetObjectArrayElement(env::Ptr{JNIEnv}, array::jobjectArray, index::Integer) = - ccall(jnifunc.GetObjectArrayElement, jobject, (Ptr{JNIEnv}, jobjectArray, jsize,), env, array, index) + ccall(jniref[].GetObjectArrayElement, jobject, (Ptr{JNIEnv}, jobjectArray, jsize,), env, array, index) SetObjectArrayElement(env::Ptr{JNIEnv}, array::jobjectArray, index::Integer, val::jobject) = - ccall(jnifunc.SetObjectArrayElement, Nothing, (Ptr{JNIEnv}, jobjectArray, jsize, jobject,), env, array, index, val) + ccall(jniref[].SetObjectArrayElement, Nothing, (Ptr{JNIEnv}, jobjectArray, jsize, jobject,), env, array, index, val) NewBooleanArray(env::Ptr{JNIEnv}, len::Integer) = - ccall(jnifunc.NewBooleanArray, jbooleanArray, (Ptr{JNIEnv}, jsize,), env, len) + ccall(jniref[].NewBooleanArray, jbooleanArray, (Ptr{JNIEnv}, jsize,), env, len) NewByteArray(env::Ptr{JNIEnv}, len::Integer) = - ccall(jnifunc.NewByteArray, jbyteArray, (Ptr{JNIEnv}, jsize,), env, len) + ccall(jniref[].NewByteArray, jbyteArray, (Ptr{JNIEnv}, jsize,), env, len) NewCharArray(env::Ptr{JNIEnv}, len::Integer) = - ccall(jnifunc.NewCharArray, jcharArray, (Ptr{JNIEnv}, jsize,), env, len) + ccall(jniref[].NewCharArray, jcharArray, (Ptr{JNIEnv}, jsize,), env, len) NewShortArray(env::Ptr{JNIEnv}, len::Integer) = - ccall(jnifunc.NewShortArray, jshortArray, (Ptr{JNIEnv}, jsize,), env, len) + ccall(jniref[].NewShortArray, jshortArray, (Ptr{JNIEnv}, jsize,), env, len) NewIntArray(env::Ptr{JNIEnv}, len::Integer) = - ccall(jnifunc.NewIntArray, jintArray, (Ptr{JNIEnv}, jsize,), env, len) + ccall(jniref[].NewIntArray, jintArray, (Ptr{JNIEnv}, jsize,), env, len) NewLongArray(env::Ptr{JNIEnv}, len::Integer) = - ccall(jnifunc.NewLongArray, jlongArray, (Ptr{JNIEnv}, jsize,), env, len) + ccall(jniref[].NewLongArray, jlongArray, (Ptr{JNIEnv}, jsize,), env, len) NewFloatArray(env::Ptr{JNIEnv}, len::Integer) = - ccall(jnifunc.NewFloatArray, jfloatArray, (Ptr{JNIEnv}, jsize,), env, len) + ccall(jniref[].NewFloatArray, jfloatArray, (Ptr{JNIEnv}, jsize,), env, len) NewDoubleArray(env::Ptr{JNIEnv}, len::Integer) = - ccall(jnifunc.NewDoubleArray, jdoubleArray, (Ptr{JNIEnv}, jsize,), env, len) + ccall(jniref[].NewDoubleArray, jdoubleArray, (Ptr{JNIEnv}, jsize,), env, len) GetBooleanArrayElements(env::Ptr{JNIEnv}, array::jbooleanArray, isCopy::PtrIsCopy) = - ccall(jnifunc.GetBooleanArrayElements, Ptr{jboolean}, (Ptr{JNIEnv}, jbooleanArray, Ptr{jboolean},), env, array, isCopy) + ccall(jniref[].GetBooleanArrayElements, Ptr{jboolean}, (Ptr{JNIEnv}, jbooleanArray, Ptr{jboolean},), env, array, isCopy) GetByteArrayElements(env::Ptr{JNIEnv}, array::jbyteArray, isCopy::PtrIsCopy) = - ccall(jnifunc.GetByteArrayElements, Ptr{jbyte}, (Ptr{JNIEnv}, jbyteArray, Ptr{jboolean},), env, array, isCopy) + ccall(jniref[].GetByteArrayElements, Ptr{jbyte}, (Ptr{JNIEnv}, jbyteArray, Ptr{jboolean},), env, array, isCopy) GetCharArrayElements(env::Ptr{JNIEnv}, array::jcharArray, isCopy::PtrIsCopy) = - ccall(jnifunc.GetCharArrayElements, Ptr{jchar}, (Ptr{JNIEnv}, jcharArray, Ptr{jboolean},), env, array, isCopy) + ccall(jniref[].GetCharArrayElements, Ptr{jchar}, (Ptr{JNIEnv}, jcharArray, Ptr{jboolean},), env, array, isCopy) GetShortArrayElements(env::Ptr{JNIEnv}, array::jshortArray, isCopy::PtrIsCopy) = - ccall(jnifunc.GetShortArrayElements, Ptr{jshort}, (Ptr{JNIEnv}, jshortArray, Ptr{jboolean},), env, array, isCopy) + ccall(jniref[].GetShortArrayElements, Ptr{jshort}, (Ptr{JNIEnv}, jshortArray, Ptr{jboolean},), env, array, isCopy) GetIntArrayElements(env::Ptr{JNIEnv}, array::jintArray, isCopy::PtrIsCopy) = - ccall(jnifunc.GetIntArrayElements, Ptr{jint}, (Ptr{JNIEnv}, jintArray, Ptr{jboolean},), env, array, isCopy) + ccall(jniref[].GetIntArrayElements, Ptr{jint}, (Ptr{JNIEnv}, jintArray, Ptr{jboolean},), env, array, isCopy) GetLongArrayElements(env::Ptr{JNIEnv}, array::jlongArray, isCopy::PtrIsCopy) = - ccall(jnifunc.GetLongArrayElements, Ptr{jlong}, (Ptr{JNIEnv}, jlongArray, Ptr{jboolean},), env, array, isCopy) + ccall(jniref[].GetLongArrayElements, Ptr{jlong}, (Ptr{JNIEnv}, jlongArray, Ptr{jboolean},), env, array, isCopy) GetFloatArrayElements(env::Ptr{JNIEnv}, array::jfloatArray, isCopy::PtrIsCopy) = - ccall(jnifunc.GetFloatArrayElements, Ptr{jfloat}, (Ptr{JNIEnv}, jfloatArray, Ptr{jboolean},), env, array, isCopy) + ccall(jniref[].GetFloatArrayElements, Ptr{jfloat}, (Ptr{JNIEnv}, jfloatArray, Ptr{jboolean},), env, array, isCopy) GetDoubleArrayElements(env::Ptr{JNIEnv}, array::jdoubleArray, isCopy::PtrIsCopy) = - ccall(jnifunc.GetDoubleArrayElements, Ptr{jdouble}, (Ptr{JNIEnv}, jdoubleArray, Ptr{jboolean},), env, array, isCopy) + ccall(jniref[].GetDoubleArrayElements, Ptr{jdouble}, (Ptr{JNIEnv}, jdoubleArray, Ptr{jboolean},), env, array, isCopy) ReleaseBooleanArrayElements(env::Ptr{JNIEnv}, array::jbooleanArray, elems::Ptr{jboolean}, mode::jint) = - ccall(jnifunc.ReleaseBooleanArrayElements, Nothing, (Ptr{JNIEnv}, jbooleanArray, Ptr{jboolean}, jint,), env, array, elems, mode) + ccall(jniref[].ReleaseBooleanArrayElements, Nothing, (Ptr{JNIEnv}, jbooleanArray, Ptr{jboolean}, jint,), env, array, elems, mode) ReleaseByteArrayElements(env::Ptr{JNIEnv}, array::jbyteArray, elems::Ptr{jbyte}, mode::jint) = - ccall(jnifunc.ReleaseByteArrayElements, Nothing, (Ptr{JNIEnv}, jbyteArray, Ptr{jbyte}, jint,), env, array, elems, mode) + ccall(jniref[].ReleaseByteArrayElements, Nothing, (Ptr{JNIEnv}, jbyteArray, Ptr{jbyte}, jint,), env, array, elems, mode) ReleaseCharArrayElements(env::Ptr{JNIEnv}, array::jcharArray, elems::Ptr{jchar}, mode::jint) = - ccall(jnifunc.ReleaseCharArrayElements, Nothing, (Ptr{JNIEnv}, jcharArray, Ptr{jchar}, jint,), env, array, elems, mode) + ccall(jniref[].ReleaseCharArrayElements, Nothing, (Ptr{JNIEnv}, jcharArray, Ptr{jchar}, jint,), env, array, elems, mode) ReleaseShortArrayElements(env::Ptr{JNIEnv}, array::jshortArray, elems::Ptr{jshort}, mode::jint) = - ccall(jnifunc.ReleaseShortArrayElements, Nothing, (Ptr{JNIEnv}, jshortArray, Ptr{jshort}, jint,), env, array, elems, mode) + ccall(jniref[].ReleaseShortArrayElements, Nothing, (Ptr{JNIEnv}, jshortArray, Ptr{jshort}, jint,), env, array, elems, mode) ReleaseIntArrayElements(env::Ptr{JNIEnv}, array::jintArray, elems::Ptr{jint}, mode::jint) = - ccall(jnifunc.ReleaseIntArrayElements, Nothing, (Ptr{JNIEnv}, jintArray, Ptr{jint}, jint,), env, array, elems, mode) + ccall(jniref[].ReleaseIntArrayElements, Nothing, (Ptr{JNIEnv}, jintArray, Ptr{jint}, jint,), env, array, elems, mode) ReleaseLongArrayElements(env::Ptr{JNIEnv}, array::jlongArray, elems::Ptr{jlong}, mode::jint) = - ccall(jnifunc.ReleaseLongArrayElements, Nothing, (Ptr{JNIEnv}, jlongArray, Ptr{jlong}, jint,), env, array, elems, mode) + ccall(jniref[].ReleaseLongArrayElements, Nothing, (Ptr{JNIEnv}, jlongArray, Ptr{jlong}, jint,), env, array, elems, mode) ReleaseFloatArrayElements(env::Ptr{JNIEnv}, array::jfloatArray, elems::Ptr{jfloat}, mode::jint) = - ccall(jnifunc.ReleaseFloatArrayElements, Nothing, (Ptr{JNIEnv}, jfloatArray, Ptr{jfloat}, jint,), env, array, elems, mode) + ccall(jniref[].ReleaseFloatArrayElements, Nothing, (Ptr{JNIEnv}, jfloatArray, Ptr{jfloat}, jint,), env, array, elems, mode) ReleaseDoubleArrayElements(env::Ptr{JNIEnv}, array::jdoubleArray, elems::Ptr{jdouble}, mode::jint) = - ccall(jnifunc.ReleaseDoubleArrayElements, Nothing, (Ptr{JNIEnv}, jdoubleArray, Ptr{jdouble}, jint,), env, array, elems, mode) + ccall(jniref[].ReleaseDoubleArrayElements, Nothing, (Ptr{JNIEnv}, jdoubleArray, Ptr{jdouble}, jint,), env, array, elems, mode) GetBooleanArrayRegion(env::Ptr{JNIEnv}, array::jbooleanArray, start::Integer, l::Integer, buf::Array{jboolean,1}) = - ccall(jnifunc.GetBooleanArrayRegion, Nothing, (Ptr{JNIEnv}, jbooleanArray, jsize, jsize, Ptr{jboolean},), env, array, start, l, buf) + ccall(jniref[].GetBooleanArrayRegion, Nothing, (Ptr{JNIEnv}, jbooleanArray, jsize, jsize, Ptr{jboolean},), env, array, start, l, buf) GetByteArrayRegion(env::Ptr{JNIEnv}, array::jbyteArray, start::Integer, len::Integer, buf::Array{jbyte,1}) = - ccall(jnifunc.GetByteArrayRegion, Nothing, (Ptr{JNIEnv}, jbyteArray, jsize, jsize, Ptr{jbyte},), env, array, start, len, buf) + ccall(jniref[].GetByteArrayRegion, Nothing, (Ptr{JNIEnv}, jbyteArray, jsize, jsize, Ptr{jbyte},), env, array, start, len, buf) GetCharArrayRegion(env::Ptr{JNIEnv}, array::jcharArray, start::Integer, len::Integer, buf::Array{jchar,1}) = - ccall(jnifunc.GetCharArrayRegion, Nothing, (Ptr{JNIEnv}, jcharArray, jsize, jsize, Ptr{jchar},), env, array, start, len, buf) + ccall(jniref[].GetCharArrayRegion, Nothing, (Ptr{JNIEnv}, jcharArray, jsize, jsize, Ptr{jchar},), env, array, start, len, buf) GetShortArrayRegion(env::Ptr{JNIEnv}, array::jshortArray, start::Integer, len::Integer, buf::Array{jshort,1}) = - ccall(jnifunc.GetShortArrayRegion, Nothing, (Ptr{JNIEnv}, jshortArray, jsize, jsize, Ptr{jshort},), env, array, start, len, buf) + ccall(jniref[].GetShortArrayRegion, Nothing, (Ptr{JNIEnv}, jshortArray, jsize, jsize, Ptr{jshort},), env, array, start, len, buf) GetIntArrayRegion(env::Ptr{JNIEnv}, array::jintArray, start::Integer, len::Integer, buf::Array{jint,1}) = - ccall(jnifunc.GetIntArrayRegion, Nothing, (Ptr{JNIEnv}, jintArray, jsize, jsize, Ptr{jint},), env, array, start, len, buf) + ccall(jniref[].GetIntArrayRegion, Nothing, (Ptr{JNIEnv}, jintArray, jsize, jsize, Ptr{jint},), env, array, start, len, buf) GetLongArrayRegion(env::Ptr{JNIEnv}, array::jlongArray, start::Integer, len::Integer, buf::Array{jlong,1}) = - ccall(jnifunc.GetLongArrayRegion, Nothing, (Ptr{JNIEnv}, jlongArray, jsize, jsize, Ptr{jlong},), env, array, start, len, buf) + ccall(jniref[].GetLongArrayRegion, Nothing, (Ptr{JNIEnv}, jlongArray, jsize, jsize, Ptr{jlong},), env, array, start, len, buf) GetFloatArrayRegion(env::Ptr{JNIEnv}, array::jfloatArray, start::Integer, len::Integer, buf::Array{jfloat,1}) = - ccall(jnifunc.GetFloatArrayRegion, Nothing, (Ptr{JNIEnv}, jfloatArray, jsize, jsize, Ptr{jfloat},), env, array, start, len, buf) + ccall(jniref[].GetFloatArrayRegion, Nothing, (Ptr{JNIEnv}, jfloatArray, jsize, jsize, Ptr{jfloat},), env, array, start, len, buf) GetDoubleArrayRegion(env::Ptr{JNIEnv}, array::jdoubleArray, start::Integer, len::Integer, buf::Array{jdouble,1}) = - ccall(jnifunc.GetDoubleArrayRegion, Nothing, (Ptr{JNIEnv}, jdoubleArray, jsize, jsize, Ptr{jdouble},), env, array, start, len, buf) + ccall(jniref[].GetDoubleArrayRegion, Nothing, (Ptr{JNIEnv}, jdoubleArray, jsize, jsize, Ptr{jdouble},), env, array, start, len, buf) SetBooleanArrayRegion(env::Ptr{JNIEnv}, array::jbooleanArray, start::Integer, l::Integer, buf::Array{jboolean,1}) = - ccall(jnifunc.SetBooleanArrayRegion, Nothing, (Ptr{JNIEnv}, jbooleanArray, jsize, jsize, Ptr{jboolean},), env, array, start, l, buf) + ccall(jniref[].SetBooleanArrayRegion, Nothing, (Ptr{JNIEnv}, jbooleanArray, jsize, jsize, Ptr{jboolean},), env, array, start, l, buf) SetByteArrayRegion(env::Ptr{JNIEnv}, array::jbyteArray, start::Integer, len::Integer, buf::Array{jbyte,1}) = - ccall(jnifunc.SetByteArrayRegion, Nothing, (Ptr{JNIEnv}, jbyteArray, jsize, jsize, Ptr{jbyte},), env, array, start, len, buf) + ccall(jniref[].SetByteArrayRegion, Nothing, (Ptr{JNIEnv}, jbyteArray, jsize, jsize, Ptr{jbyte},), env, array, start, len, buf) SetCharArrayRegion(env::Ptr{JNIEnv}, array::jcharArray, start::Integer, len::Integer, buf::Array{jchar,1}) = - ccall(jnifunc.SetCharArrayRegion, Nothing, (Ptr{JNIEnv}, jcharArray, jsize, jsize, Ptr{jchar},), env, array, start, len, buf) + ccall(jniref[].SetCharArrayRegion, Nothing, (Ptr{JNIEnv}, jcharArray, jsize, jsize, Ptr{jchar},), env, array, start, len, buf) SetShortArrayRegion(env::Ptr{JNIEnv}, array::jshortArray, start::Integer, len::Integer, buf::Array{jshort,1}) = - ccall(jnifunc.SetShortArrayRegion, Nothing, (Ptr{JNIEnv}, jshortArray, jsize, jsize, Ptr{jshort},), env, array, start, len, buf) + ccall(jniref[].SetShortArrayRegion, Nothing, (Ptr{JNIEnv}, jshortArray, jsize, jsize, Ptr{jshort},), env, array, start, len, buf) SetIntArrayRegion(env::Ptr{JNIEnv}, array::jintArray, start::Integer, len::Integer, buf::Array{jint,1}) = - ccall(jnifunc.SetIntArrayRegion, Nothing, (Ptr{JNIEnv}, jintArray, jsize, jsize, Ptr{jint},), env, array, start, len, buf) + ccall(jniref[].SetIntArrayRegion, Nothing, (Ptr{JNIEnv}, jintArray, jsize, jsize, Ptr{jint},), env, array, start, len, buf) SetLongArrayRegion(env::Ptr{JNIEnv}, array::jlongArray, start::Integer, len::Integer, buf::Array{jlong,1}) = - ccall(jnifunc.SetLongArrayRegion, Nothing, (Ptr{JNIEnv}, jlongArray, jsize, jsize, Ptr{jlong},), env, array, start, len, buf) + ccall(jniref[].SetLongArrayRegion, Nothing, (Ptr{JNIEnv}, jlongArray, jsize, jsize, Ptr{jlong},), env, array, start, len, buf) SetFloatArrayRegion(env::Ptr{JNIEnv}, array::jfloatArray, start::Integer, len::Integer, buf::Array{jfloat,1}) = - ccall(jnifunc.SetFloatArrayRegion, Nothing, (Ptr{JNIEnv}, jfloatArray, jsize, jsize, Ptr{jfloat},), env, array, start, len, buf) + ccall(jniref[].SetFloatArrayRegion, Nothing, (Ptr{JNIEnv}, jfloatArray, jsize, jsize, Ptr{jfloat},), env, array, start, len, buf) SetDoubleArrayRegion(env::Ptr{JNIEnv}, array::jdoubleArray, start::Integer, len::Integer, buf::Array{jdouble,1}) = - ccall(jnifunc.SetDoubleArrayRegion, Nothing, (Ptr{JNIEnv}, jdoubleArray, jsize, jsize, Ptr{jdouble},), env, array, start, len, buf) + ccall(jniref[].SetDoubleArrayRegion, Nothing, (Ptr{JNIEnv}, jdoubleArray, jsize, jsize, Ptr{jdouble},), env, array, start, len, buf) RegisterNatives(env::Ptr{JNIEnv}, clazz::jclass, methods::Array{JNINativeMethod,1}, nMethods::jint) = - ccall(jnifunc.RegisterNatives, jint, (Ptr{JNIEnv}, jclass, Ptr{JNINativeMethod}, jint,), env, clazz, methods, nMethods) + ccall(jniref[].RegisterNatives, jint, (Ptr{JNIEnv}, jclass, Ptr{JNINativeMethod}, jint,), env, clazz, methods, nMethods) UnregisterNatives(env::Ptr{JNIEnv}, clazz::jclass) = - ccall(jnifunc.UnregisterNatives, jint, (Ptr{JNIEnv}, jclass,), env, clazz) + ccall(jniref[].UnregisterNatives, jint, (Ptr{JNIEnv}, jclass,), env, clazz) MonitorEnter(env::Ptr{JNIEnv}, obj::jobject) = - ccall(jnifunc.MonitorEnter, jint, (Ptr{JNIEnv}, jobject,), env, obj) + ccall(jniref[].MonitorEnter, jint, (Ptr{JNIEnv}, jobject,), env, obj) MonitorExit(env::Ptr{JNIEnv}, obj::jobject) = - ccall(jnifunc.MonitorExit, jint, (Ptr{JNIEnv}, jobject,), env, obj) + ccall(jniref[].MonitorExit, jint, (Ptr{JNIEnv}, jobject,), env, obj) GetJavaVM(env::Ptr{JNIEnv}, vm::Array{JavaVM,1}) = - ccall(jnifunc.GetJavaVM, jint, (Ptr{JNIEnv}, Array{JavaVM,1},), env, vm) + ccall(jniref[].GetJavaVM, jint, (Ptr{JNIEnv}, Array{JavaVM,1},), env, vm) GetStringRegion(env::Ptr{JNIEnv}, str::jstring, start::Integer, len::Integer, buf::Array{jchar,1}) = - ccall(jnifunc.GetStringRegion, Nothing, (Ptr{JNIEnv}, jstring, jsize, jsize, Ptr{jchar},), env, str, start, len, buf) + ccall(jniref[].GetStringRegion, Nothing, (Ptr{JNIEnv}, jstring, jsize, jsize, Ptr{jchar},), env, str, start, len, buf) GetStringUTFRegion(env::Ptr{JNIEnv}, str::jstring, start::Integer, len::Integer, buf::AnyString) = - ccall(jnifunc.GetStringUTFRegion, Nothing, (Ptr{JNIEnv}, jstring, jsize, jsize, Cstring,), env, str, start, len, buf) + ccall(jniref[].GetStringUTFRegion, Nothing, (Ptr{JNIEnv}, jstring, jsize, jsize, Cstring,), env, str, start, len, buf) GetPrimitiveArrayCritical(env::Ptr{JNIEnv}, array::jarray, isCopy::PtrIsCopy) = - ccall(jnifunc.GetPrimitiveArrayCritical, Ptr{Nothing}, (Ptr{JNIEnv}, jarray, Ptr{jboolean},), env, array, isCopy) + ccall(jniref[].GetPrimitiveArrayCritical, Ptr{Nothing}, (Ptr{JNIEnv}, jarray, Ptr{jboolean},), env, array, isCopy) ReleasePrimitiveArrayCritical(env::Ptr{JNIEnv}, array::jarray, carray::Ptr{Nothing}, mode::jint) = - ccall(jnifunc.ReleasePrimitiveArrayCritical, Nothing, (Ptr{JNIEnv}, jarray, Ptr{Nothing}, jint,), env, array, carray, mode) + ccall(jniref[].ReleasePrimitiveArrayCritical, Nothing, (Ptr{JNIEnv}, jarray, Ptr{Nothing}, jint,), env, array, carray, mode) GetStringCritical(env::Ptr{JNIEnv}, string::jstring, isCopy::PtrIsCopy) = - ccall(jnifunc.GetStringCritical, Ptr{jchar}, (Ptr{JNIEnv}, jstring, Ptr{jboolean},), env, string, isCopy) + ccall(jniref[].GetStringCritical, Ptr{jchar}, (Ptr{JNIEnv}, jstring, Ptr{jboolean},), env, string, isCopy) ReleaseStringCritical(env::Ptr{JNIEnv}, string::jstring, cstring::Array{jchar,1}) = - ccall(jnifunc.ReleaseStringCritical, Nothing, (Ptr{JNIEnv}, jstring, Ptr{jchar},), env, string, cstring) + ccall(jniref[].ReleaseStringCritical, Nothing, (Ptr{JNIEnv}, jstring, Ptr{jchar},), env, string, cstring) NewWeakGlobalRef(env::Ptr{JNIEnv}, obj::jobject) = - ccall(jnifunc.NewWeakGlobalRef, jweak, (Ptr{JNIEnv}, jobject,), env, obj) + ccall(jniref[].NewWeakGlobalRef, jweak, (Ptr{JNIEnv}, jobject,), env, obj) DeleteWeakGlobalRef(env::Ptr{JNIEnv}, ref::jweak) = - ccall(jnifunc.DeleteWeakGlobalRef, Nothing, (Ptr{JNIEnv}, jweak,), env, ref) + ccall(jniref[].DeleteWeakGlobalRef, Nothing, (Ptr{JNIEnv}, jweak,), env, ref) ExceptionCheck(env::Ptr{JNIEnv}) = - ccall(jnifunc.ExceptionCheck, jboolean, (Ptr{JNIEnv},), env) + ccall(jniref[].ExceptionCheck, jboolean, (Ptr{JNIEnv},), env) NewDirectByteBuffer(env::Ptr{JNIEnv}, address::Ptr{Nothing}, capacity::jlong) = - ccall(jnifunc.NewDirectByteBuffer, jobject, (Ptr{JNIEnv}, Ptr{Nothing}, jlong,), env, address, capacity) + ccall(jniref[].NewDirectByteBuffer, jobject, (Ptr{JNIEnv}, Ptr{Nothing}, jlong,), env, address, capacity) GetDirectBufferAddress(env::Ptr{JNIEnv}, buf::jobject) = - ccall(jnifunc.GetDirectBufferAddress, Ptr{Nothing}, (Ptr{JNIEnv}, jobject,), env, buf) + ccall(jniref[].GetDirectBufferAddress, Ptr{Nothing}, (Ptr{JNIEnv}, jobject,), env, buf) GetDirectBufferCapacity(env::Ptr{JNIEnv}, buf::jobject) = - ccall(jnifunc.GetDirectBufferCapacity, jlong, (Ptr{JNIEnv}, jobject,), env, buf) + ccall(jniref[].GetDirectBufferCapacity, jlong, (Ptr{JNIEnv}, jobject,), env, buf) GetObjectRefType(env::Ptr{JNIEnv}, obj::jobject) = - ccall(jnifunc.GetObjectRefType, jobjectRefType, (Ptr{JNIEnv}, jobject,), env, obj) + ccall(jniref[].GetObjectRefType, jobjectRefType, (Ptr{JNIEnv}, jobject,), env, obj) # === Above Generated by make_jni2.jl === diff --git a/src/make_jni2.jl b/src/make_jni2.jl index 4cdc78a..8dd901c 100644 --- a/src/make_jni2.jl +++ b/src/make_jni2.jl @@ -118,7 +118,7 @@ for line in open(readlines, "jnienv.jl", "r") # Commented out export command # print("#export $fname\n") - print("$fname($julia_args) =\n ccall(jnifunc.$(fname), $rtype, ($arg_types,), $arg_names)\n\n") + print("$fname($julia_args) =\n ccall(jniref[].$(fname), $rtype, ($arg_types,), $arg_names)\n\n") end # println("end") From b50fc1519c94ade5275f3c4793904c268247c675 Mon Sep 17 00:00:00 2001 From: "markkitt@gmail.com" Date: Mon, 4 May 2020 02:53:55 -0500 Subject: [PATCH 17/18] Improve JNINativeInterface initialization and is_jni_loaded() --- src/JNI.jl | 6 +++--- src/jnienv.jl | 1 + 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/src/JNI.jl b/src/JNI.jl index 273551c..4764169 100644 --- a/src/JNI.jl +++ b/src/JNI.jl @@ -16,8 +16,8 @@ export jnifunc include("jnienv.jl") -const jniref = Ref{JNINativeInterface}() -global jnifunc::JNINativeInterface +const jniref = Ref(JNINativeInterface()) +global jnifunc # jni_md.h const jint = Cint @@ -92,7 +92,7 @@ function load_jni(penv::Ptr{JNIEnv}) jniref[] = unsafe_load(jnienv.JNINativeInterface_) #The JNI Function table global jnifunc = jniref[] end -is_jni_loaded() = isdefined(JNI, :jnifunc) +is_jni_loaded() = jniref[].GetVersion != C_NULL # === Below Generated by make_jni2.jl === diff --git a/src/jnienv.jl b/src/jnienv.jl index 95b1d1c..a127e20 100644 --- a/src/jnienv.jl +++ b/src/jnienv.jl @@ -303,6 +303,7 @@ struct JNINativeInterface #struct JNINativeInterface_ { #/* New JNI 1.6 Features */ GetObjectRefType::Ptr{Nothing} # jobjectRefType ( *GetObjectRefType) (JNIEnv* env, jobject obj); + JNINativeInterface() = new(repeat([C_NULL],233)...) end #}; struct JNIEnv From e505d185f06bc9b5892f758e8e92a23f49fe84ae Mon Sep 17 00:00:00 2001 From: "markkitt@gmail.com" Date: Mon, 4 May 2020 03:12:35 -0500 Subject: [PATCH 18/18] Move constructor outside for Julia 1.0.x --- src/jnienv.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/jnienv.jl b/src/jnienv.jl index a127e20..2b2ef66 100644 --- a/src/jnienv.jl +++ b/src/jnienv.jl @@ -303,8 +303,8 @@ struct JNINativeInterface #struct JNINativeInterface_ { #/* New JNI 1.6 Features */ GetObjectRefType::Ptr{Nothing} # jobjectRefType ( *GetObjectRefType) (JNIEnv* env, jobject obj); - JNINativeInterface() = new(repeat([C_NULL],233)...) end #}; +JNINativeInterface() = JNINativeInterface(repeat([C_NULL],233)...) struct JNIEnv JNINativeInterface_::Ptr{JNINativeInterface}