From 60d98e95bcc7a0d6f7d445076d10bf59171e74a7 Mon Sep 17 00:00:00 2001 From: "markkitt@gmail.com" Date: Tue, 5 May 2020 01:49:18 -0500 Subject: [PATCH 01/12] Consolidate globals within JNI module --- src/JNI.jl | 751 ++++++++++++++++++++++++++--------------------- src/JavaCall.jl | 3 - src/convert.jl | 70 ++--- src/core.jl | 42 +-- src/jnienv.jl | 2 + src/jvm.jl | 50 +--- test/runtests.jl | 6 +- 7 files changed, 480 insertions(+), 444 deletions(-) diff --git a/src/JNI.jl b/src/JNI.jl index 4764169..96416aa 100644 --- a/src/JNI.jl +++ b/src/JNI.jl @@ -1,5 +1,7 @@ module JNI +import Libdl + # jnienv.jl exports export JNINativeInterface, JNIEnv, JNIInvokeInterface, JavaVM # jni_md.h exports @@ -19,6 +21,10 @@ include("jnienv.jl") const jniref = Ref(JNINativeInterface()) global jnifunc +const penv = Ref(Ptr{JNIEnv}(C_NULL)) +const pjvm = Ref(Ptr{JavaVM}(C_NULL)) +const jvmfunc = Ref{JNIInvokeInterface}() + # jni_md.h const jint = Cint #ifdef _LP64 /* 64-bit Solaris */ @@ -87,518 +93,591 @@ const JNI_EINVAL = convert(Cint, -6) #/* invalid arguments */ PtrIsCopy = Union{Ptr{jboolean},Ref{jboolean},Array{jboolean,}} AnyString = Union{AbstractString,Cstring,Ptr{UInt8}} +struct JNIError <: Exception + msg::String +end + +struct JavaVMOption + optionString::Ptr{UInt8} + extraInfo::Ptr{Nothing} +end + +struct JavaVMInitArgs + version::Cint + nOptions::Cint + options::Ptr{JavaVMOption} + ignoreUnrecognized::Cchar +end + function load_jni(penv::Ptr{JNIEnv}) jnienv = unsafe_load(penv) jniref[] = unsafe_load(jnienv.JNINativeInterface_) #The JNI Function table global jnifunc = jniref[] end is_jni_loaded() = jniref[].GetVersion != C_NULL +is_env_loaded() = penv[] != C_NULL + + +""" + init_new_vm(opts) +""" +function init_new_vm(libpath,opts) + libjvm = Libdl.dlopen(libpath) + @debug("Loaded $libpath") + create = Libdl.dlsym(libjvm, :JNI_CreateJavaVM) + 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_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)) + res < 0 && throw(JNIError("Unable to initialise Java VM: $(res)")) + global penv[] = ppenv[1] + global pjvm[] = ppjvm[1] + jvm = unsafe_load(pjvm[]) + global jvmfunc[] = unsafe_load(jvm.JNIInvokeInterface_) + JNI.load_jni(penv[]) + return +end + +""" + init_current_vm() + +Allow initialization from running VM. Uses the first VM it finds. +""" +function init_current_vm(libpath) + libjvm = Libdl.dlopen(libpath) + @debug("Loaded $libpath") + ppjvm = Array{Ptr{JavaVM}}(undef, 1) + ppenv = Array{Ptr{JNIEnv}}(undef, 1) + pnum = Array{Cint}(undef, 1) + ccall(Libdl.dlsym(libjvm, :JNI_GetCreatedJavaVMs), Cint, (Ptr{Ptr{JavaVM}}, Cint, Ptr{Cint}), ppjvm, 1, pnum) + 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.JNI_VERSION_1_8) + global penv[] = ppenv[1] + JNI.load_jni(penv) +end + +function destroy() + if !is_env_loaded() + throw(JNIError("Called destroy without initialising Java VM")) + end + res = ccall(jvmfunc[].DestroyJavaVM, Cint, (Ptr{Nothing},), pjvm[]) + res < 0 && throw(JavaCallError("Unable to destroy Java VM")) + penv[] = C_NULL + pjvm[] = C_NULL + nothing +end + # === Below Generated by make_jni2.jl === -GetVersion(env::Ptr{JNIEnv}) = - ccall(jniref[].GetVersion, jint, (Ptr{JNIEnv},), env) +GetVersion() = + ccall(jniref[].GetVersion, jint, (Ptr{JNIEnv},), penv[]) -DefineClass(env::Ptr{JNIEnv}, name::AnyString, loader::jobject, buf::Array{jbyte,1}, len::Integer) = - ccall(jniref[].DefineClass, jclass, (Ptr{JNIEnv}, Cstring, jobject, Ptr{jbyte}, jsize,), env, name, loader, buf, len) +DefineClass(name::AnyString, loader::jobject, buf::Array{jbyte,1}, len::Integer) = + ccall(jniref[].DefineClass, jclass, (Ptr{JNIEnv}, Cstring, jobject, Ptr{jbyte}, jsize,), penv[], name, loader, buf, len) -FindClass(env::Ptr{JNIEnv}, name::AnyString) = - ccall(jniref[].FindClass, jclass, (Ptr{JNIEnv}, Cstring,), env, name) +FindClass(name::AnyString) = + ccall(jniref[].FindClass, jclass, (Ptr{JNIEnv}, Cstring,), penv[], name) -FromReflectedMethod(env::Ptr{JNIEnv}, method::jobject) = - ccall(jniref[].FromReflectedMethod, jmethodID, (Ptr{JNIEnv}, jobject,), env, method) +FromReflectedMethod(method::jobject) = + ccall(jniref[].FromReflectedMethod, jmethodID, (Ptr{JNIEnv}, jobject,), penv[], method) -FromReflectedField(env::Ptr{JNIEnv}, field::jobject) = - ccall(jniref[].FromReflectedField, jfieldID, (Ptr{JNIEnv}, jobject,), env, field) +FromReflectedField(field::jobject) = + ccall(jniref[].FromReflectedField, jfieldID, (Ptr{JNIEnv}, jobject,), penv[], field) -ToReflectedMethod(env::Ptr{JNIEnv}, cls::jclass, methodID::jmethodID, isStatic::jboolean) = - ccall(jniref[].ToReflectedMethod, jobject, (Ptr{JNIEnv}, jclass, jmethodID, jboolean,), env, cls, methodID, isStatic) +ToReflectedMethod(cls::jclass, methodID::jmethodID, isStatic::jboolean) = + ccall(jniref[].ToReflectedMethod, jobject, (Ptr{JNIEnv}, jclass, jmethodID, jboolean,), penv[], cls, methodID, isStatic) -GetSuperclass(env::Ptr{JNIEnv}, sub::jclass) = - ccall(jniref[].GetSuperclass, jclass, (Ptr{JNIEnv}, jclass,), env, sub) +GetSuperclass(sub::jclass) = + ccall(jniref[].GetSuperclass, jclass, (Ptr{JNIEnv}, jclass,), penv[], sub) -IsAssignableFrom(env::Ptr{JNIEnv}, sub::jclass, sup::jclass) = - ccall(jniref[].IsAssignableFrom, jboolean, (Ptr{JNIEnv}, jclass, jclass,), env, sub, sup) +IsAssignableFrom(sub::jclass, sup::jclass) = + ccall(jniref[].IsAssignableFrom, jboolean, (Ptr{JNIEnv}, jclass, jclass,), penv[], sub, sup) -ToReflectedField(env::Ptr{JNIEnv}, cls::jclass, fieldID::jfieldID, isStatic::jboolean) = - ccall(jniref[].ToReflectedField, jobject, (Ptr{JNIEnv}, jclass, jfieldID, jboolean,), env, cls, fieldID, isStatic) +ToReflectedField(cls::jclass, fieldID::jfieldID, isStatic::jboolean) = + ccall(jniref[].ToReflectedField, jobject, (Ptr{JNIEnv}, jclass, jfieldID, jboolean,), penv[], cls, fieldID, isStatic) -Throw(env::Ptr{JNIEnv}, obj::jthrowable) = - ccall(jniref[].Throw, jint, (Ptr{JNIEnv}, jthrowable,), env, obj) +Throw(obj::jthrowable) = + ccall(jniref[].Throw, jint, (Ptr{JNIEnv}, jthrowable,), penv[], obj) -ThrowNew(env::Ptr{JNIEnv}, clazz::jclass, msg::AnyString) = - ccall(jniref[].ThrowNew, jint, (Ptr{JNIEnv}, jclass, Cstring,), env, clazz, msg) +ThrowNew(clazz::jclass, msg::AnyString) = + ccall(jniref[].ThrowNew, jint, (Ptr{JNIEnv}, jclass, Cstring,), penv[], clazz, msg) -ExceptionOccurred(env::Ptr{JNIEnv}) = - ccall(jniref[].ExceptionOccurred, jthrowable, (Ptr{JNIEnv},), env) +ExceptionOccurred() = + ccall(jniref[].ExceptionOccurred, jthrowable, (Ptr{JNIEnv},), penv[]) -ExceptionDescribe(env::Ptr{JNIEnv}) = - ccall(jniref[].ExceptionDescribe, Nothing, (Ptr{JNIEnv},), env) +ExceptionDescribe() = + ccall(jniref[].ExceptionDescribe, Nothing, (Ptr{JNIEnv},), penv[]) -ExceptionClear(env::Ptr{JNIEnv}) = - ccall(jniref[].ExceptionClear, Nothing, (Ptr{JNIEnv},), env) +ExceptionClear() = + ccall(jniref[].ExceptionClear, Nothing, (Ptr{JNIEnv},), penv[]) -FatalError(env::Ptr{JNIEnv}, msg::AnyString) = - ccall(jniref[].FatalError, Nothing, (Ptr{JNIEnv}, Cstring,), env, msg) +FatalError(msg::AnyString) = + ccall(jniref[].FatalError, Nothing, (Ptr{JNIEnv}, Cstring,), penv[], msg) -PushLocalFrame(env::Ptr{JNIEnv}, capacity::jint) = - ccall(jniref[].PushLocalFrame, jint, (Ptr{JNIEnv}, jint,), env, capacity) +PushLocalFrame(capacity::jint) = + ccall(jniref[].PushLocalFrame, jint, (Ptr{JNIEnv}, jint,), penv[], capacity) -PopLocalFrame(env::Ptr{JNIEnv}, result::jobject) = - ccall(jniref[].PopLocalFrame, jobject, (Ptr{JNIEnv}, jobject,), env, result) +PopLocalFrame(result::jobject) = + ccall(jniref[].PopLocalFrame, jobject, (Ptr{JNIEnv}, jobject,), penv[], result) -NewGlobalRef(env::Ptr{JNIEnv}, lobj::jobject) = - ccall(jniref[].NewGlobalRef, jobject, (Ptr{JNIEnv}, jobject,), env, lobj) +NewGlobalRef(lobj::jobject) = + ccall(jniref[].NewGlobalRef, jobject, (Ptr{JNIEnv}, jobject,), penv[], lobj) -DeleteGlobalRef(env::Ptr{JNIEnv}, gref::jobject) = - ccall(jniref[].DeleteGlobalRef, Nothing, (Ptr{JNIEnv}, jobject,), env, gref) +DeleteGlobalRef(gref::jobject) = + ccall(jniref[].DeleteGlobalRef, Nothing, (Ptr{JNIEnv}, jobject,), penv[], gref) -DeleteLocalRef(env::Ptr{JNIEnv}, obj::jobject) = - ccall(jniref[].DeleteLocalRef, Nothing, (Ptr{JNIEnv}, jobject,), env, obj) +DeleteLocalRef(obj::jobject) = + ccall(jniref[].DeleteLocalRef, Nothing, (Ptr{JNIEnv}, jobject,), penv[], obj) -IsSameObject(env::Ptr{JNIEnv}, obj1::jobject, obj2::jobject) = - ccall(jniref[].IsSameObject, jboolean, (Ptr{JNIEnv}, jobject, jobject,), env, obj1, obj2) +IsSameObject(obj1::jobject, obj2::jobject) = + ccall(jniref[].IsSameObject, jboolean, (Ptr{JNIEnv}, jobject, jobject,), penv[], obj1, obj2) -NewLocalRef(env::Ptr{JNIEnv}, ref::jobject) = - ccall(jniref[].NewLocalRef, jobject, (Ptr{JNIEnv}, jobject,), env, ref) +NewLocalRef(ref::jobject) = + ccall(jniref[].NewLocalRef, jobject, (Ptr{JNIEnv}, jobject,), penv[], ref) -EnsureLocalCapacity(env::Ptr{JNIEnv}, capacity::jint) = - ccall(jniref[].EnsureLocalCapacity, jint, (Ptr{JNIEnv}, jint,), env, capacity) +EnsureLocalCapacity(capacity::jint) = + ccall(jniref[].EnsureLocalCapacity, jint, (Ptr{JNIEnv}, jint,), penv[], capacity) -AllocObject(env::Ptr{JNIEnv}, clazz::jclass) = - ccall(jniref[].AllocObject, jobject, (Ptr{JNIEnv}, jclass,), env, clazz) +AllocObject(clazz::jclass) = + ccall(jniref[].AllocObject, jobject, (Ptr{JNIEnv}, jclass,), penv[], clazz) -NewObjectA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].NewObjectA, jobject, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) +NewObjectA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(jniref[].NewObjectA, jobject, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), penv[], clazz, methodID, args) -GetObjectClass(env::Ptr{JNIEnv}, obj::jobject) = - ccall(jniref[].GetObjectClass, jclass, (Ptr{JNIEnv}, jobject,), env, obj) +GetObjectClass(obj::jobject) = + ccall(jniref[].GetObjectClass, jclass, (Ptr{JNIEnv}, jobject,), penv[], obj) -IsInstanceOf(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass) = - ccall(jniref[].IsInstanceOf, jboolean, (Ptr{JNIEnv}, jobject, jclass,), env, obj, clazz) +IsInstanceOf(obj::jobject, clazz::jclass) = + ccall(jniref[].IsInstanceOf, jboolean, (Ptr{JNIEnv}, jobject, jclass,), penv[], obj, clazz) -GetMethodID(env::Ptr{JNIEnv}, clazz::jclass, name::AnyString, sig::AnyString) = - ccall(jniref[].GetMethodID, jmethodID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), env, clazz, name, sig) +GetMethodID(clazz::jclass, name::AnyString, sig::AnyString) = + ccall(jniref[].GetMethodID, jmethodID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), penv[], clazz, name, sig) -CallObjectMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallObjectMethodA, jobject, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) +CallObjectMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(jniref[].CallObjectMethodA, jobject, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), penv[], obj, methodID, args) -CallBooleanMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallBooleanMethodA, jboolean, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) +CallBooleanMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(jniref[].CallBooleanMethodA, jboolean, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), penv[], obj, methodID, args) -CallByteMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallByteMethodA, jbyte, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) +CallByteMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(jniref[].CallByteMethodA, jbyte, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), penv[], obj, methodID, args) -CallCharMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallCharMethodA, jchar, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) +CallCharMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(jniref[].CallCharMethodA, jchar, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), penv[], obj, methodID, args) -CallShortMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallShortMethodA, jshort, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) +CallShortMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(jniref[].CallShortMethodA, jshort, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), penv[], obj, methodID, args) -CallIntMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallIntMethodA, jint, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) +CallIntMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(jniref[].CallIntMethodA, jint, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), penv[], obj, methodID, args) -CallLongMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallLongMethodA, jlong, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) +CallLongMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(jniref[].CallLongMethodA, jlong, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), penv[], obj, methodID, args) -CallFloatMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallFloatMethodA, jfloat, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) +CallFloatMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(jniref[].CallFloatMethodA, jfloat, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), penv[], obj, methodID, args) -CallDoubleMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallDoubleMethodA, jdouble, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) +CallDoubleMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(jniref[].CallDoubleMethodA, jdouble, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), penv[], obj, methodID, args) -CallVoidMethodA(env::Ptr{JNIEnv}, obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallVoidMethodA, Nothing, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), env, obj, methodID, args) +CallVoidMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(jniref[].CallVoidMethodA, Nothing, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), penv[], obj, methodID, args) -CallNonvirtualObjectMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallNonvirtualObjectMethodA, jobject, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) +CallNonvirtualObjectMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(jniref[].CallNonvirtualObjectMethodA, jobject, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), penv[], obj, clazz, methodID, args) -CallNonvirtualBooleanMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallNonvirtualBooleanMethodA, jboolean, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) +CallNonvirtualBooleanMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(jniref[].CallNonvirtualBooleanMethodA, jboolean, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), penv[], obj, clazz, methodID, args) -CallNonvirtualByteMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallNonvirtualByteMethodA, jbyte, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) +CallNonvirtualByteMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(jniref[].CallNonvirtualByteMethodA, jbyte, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), penv[], obj, clazz, methodID, args) -CallNonvirtualCharMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallNonvirtualCharMethodA, jchar, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) +CallNonvirtualCharMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(jniref[].CallNonvirtualCharMethodA, jchar, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), penv[], obj, clazz, methodID, args) -CallNonvirtualShortMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallNonvirtualShortMethodA, jshort, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) +CallNonvirtualShortMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(jniref[].CallNonvirtualShortMethodA, jshort, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), penv[], obj, clazz, methodID, args) -CallNonvirtualIntMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallNonvirtualIntMethodA, jint, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) +CallNonvirtualIntMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(jniref[].CallNonvirtualIntMethodA, jint, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), penv[], obj, clazz, methodID, args) -CallNonvirtualLongMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallNonvirtualLongMethodA, jlong, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) +CallNonvirtualLongMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(jniref[].CallNonvirtualLongMethodA, jlong, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), penv[], obj, clazz, methodID, args) -CallNonvirtualFloatMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallNonvirtualFloatMethodA, jfloat, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) +CallNonvirtualFloatMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(jniref[].CallNonvirtualFloatMethodA, jfloat, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), penv[], obj, clazz, methodID, args) -CallNonvirtualDoubleMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallNonvirtualDoubleMethodA, jdouble, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) +CallNonvirtualDoubleMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(jniref[].CallNonvirtualDoubleMethodA, jdouble, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), penv[], obj, clazz, methodID, args) -CallNonvirtualVoidMethodA(env::Ptr{JNIEnv}, obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallNonvirtualVoidMethodA, Nothing, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), env, obj, clazz, methodID, args) +CallNonvirtualVoidMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(jniref[].CallNonvirtualVoidMethodA, Nothing, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), penv[], obj, clazz, methodID, args) -GetFieldID(env::Ptr{JNIEnv}, clazz::jclass, name::AnyString, sig::AnyString) = - ccall(jniref[].GetFieldID, jfieldID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), env, clazz, name, sig) +GetFieldID(clazz::jclass, name::AnyString, sig::AnyString) = + ccall(jniref[].GetFieldID, jfieldID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), penv[], clazz, name, sig) -GetObjectField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = - ccall(jniref[].GetObjectField, jobject, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) +GetObjectField(obj::jobject, fieldID::jfieldID) = + ccall(jniref[].GetObjectField, jobject, (Ptr{JNIEnv}, jobject, jfieldID,), penv[], obj, fieldID) -GetBooleanField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = - ccall(jniref[].GetBooleanField, jboolean, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) +GetBooleanField(obj::jobject, fieldID::jfieldID) = + ccall(jniref[].GetBooleanField, jboolean, (Ptr{JNIEnv}, jobject, jfieldID,), penv[], obj, fieldID) -GetByteField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = - ccall(jniref[].GetByteField, jbyte, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) +GetByteField(obj::jobject, fieldID::jfieldID) = + ccall(jniref[].GetByteField, jbyte, (Ptr{JNIEnv}, jobject, jfieldID,), penv[], obj, fieldID) -GetCharField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = - ccall(jniref[].GetCharField, jchar, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) +GetCharField(obj::jobject, fieldID::jfieldID) = + ccall(jniref[].GetCharField, jchar, (Ptr{JNIEnv}, jobject, jfieldID,), penv[], obj, fieldID) -GetShortField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = - ccall(jniref[].GetShortField, jshort, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) +GetShortField(obj::jobject, fieldID::jfieldID) = + ccall(jniref[].GetShortField, jshort, (Ptr{JNIEnv}, jobject, jfieldID,), penv[], obj, fieldID) -GetIntField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = - ccall(jniref[].GetIntField, jint, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) +GetIntField(obj::jobject, fieldID::jfieldID) = + ccall(jniref[].GetIntField, jint, (Ptr{JNIEnv}, jobject, jfieldID,), penv[], obj, fieldID) -GetLongField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = - ccall(jniref[].GetLongField, jlong, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) +GetLongField(obj::jobject, fieldID::jfieldID) = + ccall(jniref[].GetLongField, jlong, (Ptr{JNIEnv}, jobject, jfieldID,), penv[], obj, fieldID) -GetFloatField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = - ccall(jniref[].GetFloatField, jfloat, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) +GetFloatField(obj::jobject, fieldID::jfieldID) = + ccall(jniref[].GetFloatField, jfloat, (Ptr{JNIEnv}, jobject, jfieldID,), penv[], obj, fieldID) -GetDoubleField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID) = - ccall(jniref[].GetDoubleField, jdouble, (Ptr{JNIEnv}, jobject, jfieldID,), env, obj, fieldID) +GetDoubleField(obj::jobject, fieldID::jfieldID) = + ccall(jniref[].GetDoubleField, jdouble, (Ptr{JNIEnv}, jobject, jfieldID,), penv[], obj, fieldID) -SetObjectField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jobject) = - ccall(jniref[].SetObjectField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jobject,), env, obj, fieldID, val) +SetObjectField(obj::jobject, fieldID::jfieldID, val::jobject) = + ccall(jniref[].SetObjectField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jobject,), penv[], obj, fieldID, val) -SetBooleanField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jboolean) = - ccall(jniref[].SetBooleanField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jboolean,), env, obj, fieldID, val) +SetBooleanField(obj::jobject, fieldID::jfieldID, val::jboolean) = + ccall(jniref[].SetBooleanField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jboolean,), penv[], obj, fieldID, val) -SetByteField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jbyte) = - ccall(jniref[].SetByteField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jbyte,), env, obj, fieldID, val) +SetByteField(obj::jobject, fieldID::jfieldID, val::jbyte) = + ccall(jniref[].SetByteField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jbyte,), penv[], obj, fieldID, val) -SetCharField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jchar) = - ccall(jniref[].SetCharField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jchar,), env, obj, fieldID, val) +SetCharField(obj::jobject, fieldID::jfieldID, val::jchar) = + ccall(jniref[].SetCharField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jchar,), penv[], obj, fieldID, val) -SetShortField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jshort) = - ccall(jniref[].SetShortField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jshort,), env, obj, fieldID, val) +SetShortField(obj::jobject, fieldID::jfieldID, val::jshort) = + ccall(jniref[].SetShortField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jshort,), penv[], obj, fieldID, val) -SetIntField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jint) = - ccall(jniref[].SetIntField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jint,), env, obj, fieldID, val) +SetIntField(obj::jobject, fieldID::jfieldID, val::jint) = + ccall(jniref[].SetIntField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jint,), penv[], obj, fieldID, val) -SetLongField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jlong) = - ccall(jniref[].SetLongField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jlong,), env, obj, fieldID, val) +SetLongField(obj::jobject, fieldID::jfieldID, val::jlong) = + ccall(jniref[].SetLongField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jlong,), penv[], obj, fieldID, val) -SetFloatField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jfloat) = - ccall(jniref[].SetFloatField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jfloat,), env, obj, fieldID, val) +SetFloatField(obj::jobject, fieldID::jfieldID, val::jfloat) = + ccall(jniref[].SetFloatField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jfloat,), penv[], obj, fieldID, val) -SetDoubleField(env::Ptr{JNIEnv}, obj::jobject, fieldID::jfieldID, val::jdouble) = - ccall(jniref[].SetDoubleField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jdouble,), env, obj, fieldID, val) +SetDoubleField(obj::jobject, fieldID::jfieldID, val::jdouble) = + ccall(jniref[].SetDoubleField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jdouble,), penv[], obj, fieldID, val) -GetStaticMethodID(env::Ptr{JNIEnv}, clazz::jclass, name::AnyString, sig::AnyString) = - ccall(jniref[].GetStaticMethodID, jmethodID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), env, clazz, name, sig) +GetStaticMethodID(clazz::jclass, name::AnyString, sig::AnyString) = + ccall(jniref[].GetStaticMethodID, jmethodID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), penv[], clazz, name, sig) -CallStaticObjectMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallStaticObjectMethodA, jobject, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) +CallStaticObjectMethodA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(jniref[].CallStaticObjectMethodA, jobject, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), penv[], clazz, methodID, args) -CallStaticBooleanMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallStaticBooleanMethodA, jboolean, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) +CallStaticBooleanMethodA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(jniref[].CallStaticBooleanMethodA, jboolean, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), penv[], clazz, methodID, args) -CallStaticByteMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallStaticByteMethodA, jbyte, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) +CallStaticByteMethodA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(jniref[].CallStaticByteMethodA, jbyte, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), penv[], clazz, methodID, args) -CallStaticCharMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallStaticCharMethodA, jchar, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) +CallStaticCharMethodA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(jniref[].CallStaticCharMethodA, jchar, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), penv[], clazz, methodID, args) -CallStaticShortMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallStaticShortMethodA, jshort, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) +CallStaticShortMethodA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(jniref[].CallStaticShortMethodA, jshort, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), penv[], clazz, methodID, args) -CallStaticIntMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallStaticIntMethodA, jint, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) +CallStaticIntMethodA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(jniref[].CallStaticIntMethodA, jint, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), penv[], clazz, methodID, args) -CallStaticLongMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallStaticLongMethodA, jlong, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) +CallStaticLongMethodA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(jniref[].CallStaticLongMethodA, jlong, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), penv[], clazz, methodID, args) -CallStaticFloatMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallStaticFloatMethodA, jfloat, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) +CallStaticFloatMethodA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(jniref[].CallStaticFloatMethodA, jfloat, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), penv[], clazz, methodID, args) -CallStaticDoubleMethodA(env::Ptr{JNIEnv}, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallStaticDoubleMethodA, jdouble, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, clazz, methodID, args) +CallStaticDoubleMethodA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(jniref[].CallStaticDoubleMethodA, jdouble, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), penv[], clazz, methodID, args) -CallStaticVoidMethodA(env::Ptr{JNIEnv}, cls::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallStaticVoidMethodA, Nothing, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), env, cls, methodID, args) +CallStaticVoidMethodA(cls::jclass, methodID::jmethodID, args::Array{jvalue,1}) = + ccall(jniref[].CallStaticVoidMethodA, Nothing, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), penv[], cls, methodID, args) -GetStaticFieldID(env::Ptr{JNIEnv}, clazz::jclass, name::AnyString, sig::AnyString) = - ccall(jniref[].GetStaticFieldID, jfieldID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), env, clazz, name, sig) +GetStaticFieldID(clazz::jclass, name::AnyString, sig::AnyString) = + ccall(jniref[].GetStaticFieldID, jfieldID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), penv[], clazz, name, sig) -GetStaticObjectField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = - ccall(jniref[].GetStaticObjectField, jobject, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) +GetStaticObjectField(clazz::jclass, fieldID::jfieldID) = + ccall(jniref[].GetStaticObjectField, jobject, (Ptr{JNIEnv}, jclass, jfieldID,), penv[], clazz, fieldID) -GetStaticBooleanField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = - ccall(jniref[].GetStaticBooleanField, jboolean, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) +GetStaticBooleanField(clazz::jclass, fieldID::jfieldID) = + ccall(jniref[].GetStaticBooleanField, jboolean, (Ptr{JNIEnv}, jclass, jfieldID,), penv[], clazz, fieldID) -GetStaticByteField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = - ccall(jniref[].GetStaticByteField, jbyte, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) +GetStaticByteField(clazz::jclass, fieldID::jfieldID) = + ccall(jniref[].GetStaticByteField, jbyte, (Ptr{JNIEnv}, jclass, jfieldID,), penv[], clazz, fieldID) -GetStaticCharField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = - ccall(jniref[].GetStaticCharField, jchar, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) +GetStaticCharField(clazz::jclass, fieldID::jfieldID) = + ccall(jniref[].GetStaticCharField, jchar, (Ptr{JNIEnv}, jclass, jfieldID,), penv[], clazz, fieldID) -GetStaticShortField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = - ccall(jniref[].GetStaticShortField, jshort, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) +GetStaticShortField(clazz::jclass, fieldID::jfieldID) = + ccall(jniref[].GetStaticShortField, jshort, (Ptr{JNIEnv}, jclass, jfieldID,), penv[], clazz, fieldID) -GetStaticIntField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = - ccall(jniref[].GetStaticIntField, jint, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) +GetStaticIntField(clazz::jclass, fieldID::jfieldID) = + ccall(jniref[].GetStaticIntField, jint, (Ptr{JNIEnv}, jclass, jfieldID,), penv[], clazz, fieldID) -GetStaticLongField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = - ccall(jniref[].GetStaticLongField, jlong, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) +GetStaticLongField(clazz::jclass, fieldID::jfieldID) = + ccall(jniref[].GetStaticLongField, jlong, (Ptr{JNIEnv}, jclass, jfieldID,), penv[], clazz, fieldID) -GetStaticFloatField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = - ccall(jniref[].GetStaticFloatField, jfloat, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) +GetStaticFloatField(clazz::jclass, fieldID::jfieldID) = + ccall(jniref[].GetStaticFloatField, jfloat, (Ptr{JNIEnv}, jclass, jfieldID,), penv[], clazz, fieldID) -GetStaticDoubleField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID) = - ccall(jniref[].GetStaticDoubleField, jdouble, (Ptr{JNIEnv}, jclass, jfieldID,), env, clazz, fieldID) +GetStaticDoubleField(clazz::jclass, fieldID::jfieldID) = + ccall(jniref[].GetStaticDoubleField, jdouble, (Ptr{JNIEnv}, jclass, jfieldID,), penv[], clazz, fieldID) -SetStaticObjectField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jobject) = - ccall(jniref[].SetStaticObjectField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jobject,), env, clazz, fieldID, value) +SetStaticObjectField(clazz::jclass, fieldID::jfieldID, value::jobject) = + ccall(jniref[].SetStaticObjectField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jobject,), penv[], clazz, fieldID, value) -SetStaticBooleanField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jboolean) = - ccall(jniref[].SetStaticBooleanField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jboolean,), env, clazz, fieldID, value) +SetStaticBooleanField(clazz::jclass, fieldID::jfieldID, value::jboolean) = + ccall(jniref[].SetStaticBooleanField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jboolean,), penv[], clazz, fieldID, value) -SetStaticByteField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jbyte) = - ccall(jniref[].SetStaticByteField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jbyte,), env, clazz, fieldID, value) +SetStaticByteField(clazz::jclass, fieldID::jfieldID, value::jbyte) = + ccall(jniref[].SetStaticByteField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jbyte,), penv[], clazz, fieldID, value) -SetStaticCharField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jchar) = - ccall(jniref[].SetStaticCharField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jchar,), env, clazz, fieldID, value) +SetStaticCharField(clazz::jclass, fieldID::jfieldID, value::jchar) = + ccall(jniref[].SetStaticCharField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jchar,), penv[], clazz, fieldID, value) -SetStaticShortField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jshort) = - ccall(jniref[].SetStaticShortField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jshort,), env, clazz, fieldID, value) +SetStaticShortField(clazz::jclass, fieldID::jfieldID, value::jshort) = + ccall(jniref[].SetStaticShortField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jshort,), penv[], clazz, fieldID, value) -SetStaticIntField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jint) = - ccall(jniref[].SetStaticIntField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jint,), env, clazz, fieldID, value) +SetStaticIntField(clazz::jclass, fieldID::jfieldID, value::jint) = + ccall(jniref[].SetStaticIntField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jint,), penv[], clazz, fieldID, value) -SetStaticLongField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jlong) = - ccall(jniref[].SetStaticLongField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jlong,), env, clazz, fieldID, value) +SetStaticLongField(clazz::jclass, fieldID::jfieldID, value::jlong) = + ccall(jniref[].SetStaticLongField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jlong,), penv[], clazz, fieldID, value) -SetStaticFloatField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jfloat) = - ccall(jniref[].SetStaticFloatField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jfloat,), env, clazz, fieldID, value) +SetStaticFloatField(clazz::jclass, fieldID::jfieldID, value::jfloat) = + ccall(jniref[].SetStaticFloatField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jfloat,), penv[], clazz, fieldID, value) -SetStaticDoubleField(env::Ptr{JNIEnv}, clazz::jclass, fieldID::jfieldID, value::jdouble) = - ccall(jniref[].SetStaticDoubleField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jdouble,), env, clazz, fieldID, value) +SetStaticDoubleField(clazz::jclass, fieldID::jfieldID, value::jdouble) = + ccall(jniref[].SetStaticDoubleField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jdouble,), penv[], clazz, fieldID, value) -NewString(env::Ptr{JNIEnv}, unicode::Array{jchar,1}, len::Integer) = - ccall(jniref[].NewString, jstring, (Ptr{JNIEnv}, Ptr{jchar}, jsize,), env, unicode, len) +NewString(unicode::Array{jchar,1}, len::Integer) = + ccall(jniref[].NewString, jstring, (Ptr{JNIEnv}, Ptr{jchar}, jsize,), penv[], unicode, len) -GetStringLength(env::Ptr{JNIEnv}, str::jstring) = - ccall(jniref[].GetStringLength, jsize, (Ptr{JNIEnv}, jstring,), env, str) +GetStringLength(str::jstring) = + ccall(jniref[].GetStringLength, jsize, (Ptr{JNIEnv}, jstring,), penv[], str) -GetStringChars(env::Ptr{JNIEnv}, str::jstring, isCopy::PtrIsCopy) = - ccall(jniref[].GetStringChars, Ptr{jchar}, (Ptr{JNIEnv}, jstring, Ptr{jboolean},), env, str, isCopy) +GetStringChars(str::jstring, isCopy::PtrIsCopy) = + ccall(jniref[].GetStringChars, Ptr{jchar}, (Ptr{JNIEnv}, jstring, Ptr{jboolean},), penv[], str, isCopy) -ReleaseStringChars(env::Ptr{JNIEnv}, str::jstring, chars::Array{jchar,1}) = - ccall(jniref[].ReleaseStringChars, Nothing, (Ptr{JNIEnv}, jstring, Ptr{jchar},), env, str, chars) +ReleaseStringChars(str::jstring, chars::Array{jchar,1}) = + ccall(jniref[].ReleaseStringChars, Nothing, (Ptr{JNIEnv}, jstring, Ptr{jchar},), penv[], str, chars) -NewStringUTF(env::Ptr{JNIEnv}, utf::AnyString) = - ccall(jniref[].NewStringUTF, jstring, (Ptr{JNIEnv}, Cstring,), env, utf) +NewStringUTF(utf::AnyString) = + ccall(jniref[].NewStringUTF, jstring, (Ptr{JNIEnv}, Cstring,), penv[], utf) -GetStringUTFLength(env::Ptr{JNIEnv}, str::jstring) = - ccall(jniref[].GetStringUTFLength, jsize, (Ptr{JNIEnv}, jstring,), env, str) +GetStringUTFLength(str::jstring) = + ccall(jniref[].GetStringUTFLength, jsize, (Ptr{JNIEnv}, jstring,), penv[], str) -GetStringUTFChars(env::Ptr{JNIEnv}, str::jstring, isCopy::PtrIsCopy) = - ccall(jniref[].GetStringUTFChars, Cstring, (Ptr{JNIEnv}, jstring, Ptr{jboolean},), env, str, isCopy) +GetStringUTFChars(str::jstring, isCopy::PtrIsCopy) = + ccall(jniref[].GetStringUTFChars, Cstring, (Ptr{JNIEnv}, jstring, Ptr{jboolean},), penv[], 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(jniref[].ReleaseStringUTFChars, Nothing, (Ptr{JNIEnv}, jstring, Ptr{UInt8},), env, str, chars) -ReleaseStringUTFChars(env::Ptr{JNIEnv}, str::jstring, chars::AnyString) = - ccall(jniref[].ReleaseStringUTFChars, Nothing, (Ptr{JNIEnv}, jstring, Cstring,), env, str, chars) +#ReleaseStringUTFChars(str::jstring, chars::Ptr{UInt8}) = +# ccall(jniref[].ReleaseStringUTFChars, Nothing, (Ptr{JNIEnv}, jstring, Ptr{UInt8},), penv[], str, chars) +ReleaseStringUTFChars(str::jstring, chars::AnyString) = + ccall(jniref[].ReleaseStringUTFChars, Nothing, (Ptr{JNIEnv}, jstring, Cstring,), penv[], str, chars) -GetArrayLength(env::Ptr{JNIEnv}, array::jarray) = - ccall(jniref[].GetArrayLength, jsize, (Ptr{JNIEnv}, jarray,), env, array) +GetArrayLength(array::jarray) = + ccall(jniref[].GetArrayLength, jsize, (Ptr{JNIEnv}, jarray,), penv[], array) -NewObjectArray(env::Ptr{JNIEnv}, len::Integer, clazz::jclass, init::jobject) = - ccall(jniref[].NewObjectArray, jobjectArray, (Ptr{JNIEnv}, jsize, jclass, jobject,), env, len, clazz, init) +NewObjectArray(len::Integer, clazz::jclass, init::jobject) = + ccall(jniref[].NewObjectArray, jobjectArray, (Ptr{JNIEnv}, jsize, jclass, jobject,), penv[], len, clazz, init) -GetObjectArrayElement(env::Ptr{JNIEnv}, array::jobjectArray, index::Integer) = - ccall(jniref[].GetObjectArrayElement, jobject, (Ptr{JNIEnv}, jobjectArray, jsize,), env, array, index) +GetObjectArrayElement(array::jobjectArray, index::Integer) = + ccall(jniref[].GetObjectArrayElement, jobject, (Ptr{JNIEnv}, jobjectArray, jsize,), penv[], array, index) -SetObjectArrayElement(env::Ptr{JNIEnv}, array::jobjectArray, index::Integer, val::jobject) = - ccall(jniref[].SetObjectArrayElement, Nothing, (Ptr{JNIEnv}, jobjectArray, jsize, jobject,), env, array, index, val) +SetObjectArrayElement(array::jobjectArray, index::Integer, val::jobject) = + ccall(jniref[].SetObjectArrayElement, Nothing, (Ptr{JNIEnv}, jobjectArray, jsize, jobject,), penv[], array, index, val) -NewBooleanArray(env::Ptr{JNIEnv}, len::Integer) = - ccall(jniref[].NewBooleanArray, jbooleanArray, (Ptr{JNIEnv}, jsize,), env, len) +NewBooleanArray(len::Integer) = + ccall(jniref[].NewBooleanArray, jbooleanArray, (Ptr{JNIEnv}, jsize,), penv[], len) -NewByteArray(env::Ptr{JNIEnv}, len::Integer) = - ccall(jniref[].NewByteArray, jbyteArray, (Ptr{JNIEnv}, jsize,), env, len) +NewByteArray(len::Integer) = + ccall(jniref[].NewByteArray, jbyteArray, (Ptr{JNIEnv}, jsize,), penv[], len) -NewCharArray(env::Ptr{JNIEnv}, len::Integer) = - ccall(jniref[].NewCharArray, jcharArray, (Ptr{JNIEnv}, jsize,), env, len) +NewCharArray(len::Integer) = + ccall(jniref[].NewCharArray, jcharArray, (Ptr{JNIEnv}, jsize,), penv[], len) -NewShortArray(env::Ptr{JNIEnv}, len::Integer) = - ccall(jniref[].NewShortArray, jshortArray, (Ptr{JNIEnv}, jsize,), env, len) +NewShortArray(len::Integer) = + ccall(jniref[].NewShortArray, jshortArray, (Ptr{JNIEnv}, jsize,), penv[], len) -NewIntArray(env::Ptr{JNIEnv}, len::Integer) = - ccall(jniref[].NewIntArray, jintArray, (Ptr{JNIEnv}, jsize,), env, len) +NewIntArray(len::Integer) = + ccall(jniref[].NewIntArray, jintArray, (Ptr{JNIEnv}, jsize,), penv[], len) -NewLongArray(env::Ptr{JNIEnv}, len::Integer) = - ccall(jniref[].NewLongArray, jlongArray, (Ptr{JNIEnv}, jsize,), env, len) +NewLongArray(len::Integer) = + ccall(jniref[].NewLongArray, jlongArray, (Ptr{JNIEnv}, jsize,), penv[], len) -NewFloatArray(env::Ptr{JNIEnv}, len::Integer) = - ccall(jniref[].NewFloatArray, jfloatArray, (Ptr{JNIEnv}, jsize,), env, len) +NewFloatArray(len::Integer) = + ccall(jniref[].NewFloatArray, jfloatArray, (Ptr{JNIEnv}, jsize,), penv[], len) -NewDoubleArray(env::Ptr{JNIEnv}, len::Integer) = - ccall(jniref[].NewDoubleArray, jdoubleArray, (Ptr{JNIEnv}, jsize,), env, len) +NewDoubleArray(len::Integer) = + ccall(jniref[].NewDoubleArray, jdoubleArray, (Ptr{JNIEnv}, jsize,), penv[], len) -GetBooleanArrayElements(env::Ptr{JNIEnv}, array::jbooleanArray, isCopy::PtrIsCopy) = - ccall(jniref[].GetBooleanArrayElements, Ptr{jboolean}, (Ptr{JNIEnv}, jbooleanArray, Ptr{jboolean},), env, array, isCopy) +GetBooleanArrayElements(array::jbooleanArray, isCopy::PtrIsCopy) = + ccall(jniref[].GetBooleanArrayElements, Ptr{jboolean}, (Ptr{JNIEnv}, jbooleanArray, Ptr{jboolean},), penv[], array, isCopy) -GetByteArrayElements(env::Ptr{JNIEnv}, array::jbyteArray, isCopy::PtrIsCopy) = - ccall(jniref[].GetByteArrayElements, Ptr{jbyte}, (Ptr{JNIEnv}, jbyteArray, Ptr{jboolean},), env, array, isCopy) +GetByteArrayElements(array::jbyteArray, isCopy::PtrIsCopy) = + ccall(jniref[].GetByteArrayElements, Ptr{jbyte}, (Ptr{JNIEnv}, jbyteArray, Ptr{jboolean},), penv[], array, isCopy) -GetCharArrayElements(env::Ptr{JNIEnv}, array::jcharArray, isCopy::PtrIsCopy) = - ccall(jniref[].GetCharArrayElements, Ptr{jchar}, (Ptr{JNIEnv}, jcharArray, Ptr{jboolean},), env, array, isCopy) +GetCharArrayElements(array::jcharArray, isCopy::PtrIsCopy) = + ccall(jniref[].GetCharArrayElements, Ptr{jchar}, (Ptr{JNIEnv}, jcharArray, Ptr{jboolean},), penv[], array, isCopy) -GetShortArrayElements(env::Ptr{JNIEnv}, array::jshortArray, isCopy::PtrIsCopy) = - ccall(jniref[].GetShortArrayElements, Ptr{jshort}, (Ptr{JNIEnv}, jshortArray, Ptr{jboolean},), env, array, isCopy) +GetShortArrayElements(array::jshortArray, isCopy::PtrIsCopy) = + ccall(jniref[].GetShortArrayElements, Ptr{jshort}, (Ptr{JNIEnv}, jshortArray, Ptr{jboolean},), penv[], array, isCopy) -GetIntArrayElements(env::Ptr{JNIEnv}, array::jintArray, isCopy::PtrIsCopy) = - ccall(jniref[].GetIntArrayElements, Ptr{jint}, (Ptr{JNIEnv}, jintArray, Ptr{jboolean},), env, array, isCopy) +GetIntArrayElements(array::jintArray, isCopy::PtrIsCopy) = + ccall(jniref[].GetIntArrayElements, Ptr{jint}, (Ptr{JNIEnv}, jintArray, Ptr{jboolean},), penv[], array, isCopy) -GetLongArrayElements(env::Ptr{JNIEnv}, array::jlongArray, isCopy::PtrIsCopy) = - ccall(jniref[].GetLongArrayElements, Ptr{jlong}, (Ptr{JNIEnv}, jlongArray, Ptr{jboolean},), env, array, isCopy) +GetLongArrayElements(array::jlongArray, isCopy::PtrIsCopy) = + ccall(jniref[].GetLongArrayElements, Ptr{jlong}, (Ptr{JNIEnv}, jlongArray, Ptr{jboolean},), penv[], array, isCopy) -GetFloatArrayElements(env::Ptr{JNIEnv}, array::jfloatArray, isCopy::PtrIsCopy) = - ccall(jniref[].GetFloatArrayElements, Ptr{jfloat}, (Ptr{JNIEnv}, jfloatArray, Ptr{jboolean},), env, array, isCopy) +GetFloatArrayElements(array::jfloatArray, isCopy::PtrIsCopy) = + ccall(jniref[].GetFloatArrayElements, Ptr{jfloat}, (Ptr{JNIEnv}, jfloatArray, Ptr{jboolean},), penv[], array, isCopy) -GetDoubleArrayElements(env::Ptr{JNIEnv}, array::jdoubleArray, isCopy::PtrIsCopy) = - ccall(jniref[].GetDoubleArrayElements, Ptr{jdouble}, (Ptr{JNIEnv}, jdoubleArray, Ptr{jboolean},), env, array, isCopy) +GetDoubleArrayElements(array::jdoubleArray, isCopy::PtrIsCopy) = + ccall(jniref[].GetDoubleArrayElements, Ptr{jdouble}, (Ptr{JNIEnv}, jdoubleArray, Ptr{jboolean},), penv[], array, isCopy) -ReleaseBooleanArrayElements(env::Ptr{JNIEnv}, array::jbooleanArray, elems::Ptr{jboolean}, mode::jint) = - ccall(jniref[].ReleaseBooleanArrayElements, Nothing, (Ptr{JNIEnv}, jbooleanArray, Ptr{jboolean}, jint,), env, array, elems, mode) +ReleaseBooleanArrayElements(array::jbooleanArray, elems::Ptr{jboolean}, mode::jint) = + ccall(jniref[].ReleaseBooleanArrayElements, Nothing, (Ptr{JNIEnv}, jbooleanArray, Ptr{jboolean}, jint,), penv[], array, elems, mode) -ReleaseByteArrayElements(env::Ptr{JNIEnv}, array::jbyteArray, elems::Ptr{jbyte}, mode::jint) = - ccall(jniref[].ReleaseByteArrayElements, Nothing, (Ptr{JNIEnv}, jbyteArray, Ptr{jbyte}, jint,), env, array, elems, mode) +ReleaseByteArrayElements(array::jbyteArray, elems::Ptr{jbyte}, mode::jint) = + ccall(jniref[].ReleaseByteArrayElements, Nothing, (Ptr{JNIEnv}, jbyteArray, Ptr{jbyte}, jint,), penv[], array, elems, mode) -ReleaseCharArrayElements(env::Ptr{JNIEnv}, array::jcharArray, elems::Ptr{jchar}, mode::jint) = - ccall(jniref[].ReleaseCharArrayElements, Nothing, (Ptr{JNIEnv}, jcharArray, Ptr{jchar}, jint,), env, array, elems, mode) +ReleaseCharArrayElements(array::jcharArray, elems::Ptr{jchar}, mode::jint) = + ccall(jniref[].ReleaseCharArrayElements, Nothing, (Ptr{JNIEnv}, jcharArray, Ptr{jchar}, jint,), penv[], array, elems, mode) -ReleaseShortArrayElements(env::Ptr{JNIEnv}, array::jshortArray, elems::Ptr{jshort}, mode::jint) = - ccall(jniref[].ReleaseShortArrayElements, Nothing, (Ptr{JNIEnv}, jshortArray, Ptr{jshort}, jint,), env, array, elems, mode) +ReleaseShortArrayElements(array::jshortArray, elems::Ptr{jshort}, mode::jint) = + ccall(jniref[].ReleaseShortArrayElements, Nothing, (Ptr{JNIEnv}, jshortArray, Ptr{jshort}, jint,), penv[], array, elems, mode) -ReleaseIntArrayElements(env::Ptr{JNIEnv}, array::jintArray, elems::Ptr{jint}, mode::jint) = - ccall(jniref[].ReleaseIntArrayElements, Nothing, (Ptr{JNIEnv}, jintArray, Ptr{jint}, jint,), env, array, elems, mode) +ReleaseIntArrayElements(array::jintArray, elems::Ptr{jint}, mode::jint) = + ccall(jniref[].ReleaseIntArrayElements, Nothing, (Ptr{JNIEnv}, jintArray, Ptr{jint}, jint,), penv[], array, elems, mode) -ReleaseLongArrayElements(env::Ptr{JNIEnv}, array::jlongArray, elems::Ptr{jlong}, mode::jint) = - ccall(jniref[].ReleaseLongArrayElements, Nothing, (Ptr{JNIEnv}, jlongArray, Ptr{jlong}, jint,), env, array, elems, mode) +ReleaseLongArrayElements(array::jlongArray, elems::Ptr{jlong}, mode::jint) = + ccall(jniref[].ReleaseLongArrayElements, Nothing, (Ptr{JNIEnv}, jlongArray, Ptr{jlong}, jint,), penv[], array, elems, mode) -ReleaseFloatArrayElements(env::Ptr{JNIEnv}, array::jfloatArray, elems::Ptr{jfloat}, mode::jint) = - ccall(jniref[].ReleaseFloatArrayElements, Nothing, (Ptr{JNIEnv}, jfloatArray, Ptr{jfloat}, jint,), env, array, elems, mode) +ReleaseFloatArrayElements(array::jfloatArray, elems::Ptr{jfloat}, mode::jint) = + ccall(jniref[].ReleaseFloatArrayElements, Nothing, (Ptr{JNIEnv}, jfloatArray, Ptr{jfloat}, jint,), penv[], array, elems, mode) -ReleaseDoubleArrayElements(env::Ptr{JNIEnv}, array::jdoubleArray, elems::Ptr{jdouble}, mode::jint) = - ccall(jniref[].ReleaseDoubleArrayElements, Nothing, (Ptr{JNIEnv}, jdoubleArray, Ptr{jdouble}, jint,), env, array, elems, mode) +ReleaseDoubleArrayElements(array::jdoubleArray, elems::Ptr{jdouble}, mode::jint) = + ccall(jniref[].ReleaseDoubleArrayElements, Nothing, (Ptr{JNIEnv}, jdoubleArray, Ptr{jdouble}, jint,), penv[], array, elems, mode) -GetBooleanArrayRegion(env::Ptr{JNIEnv}, array::jbooleanArray, start::Integer, l::Integer, buf::Array{jboolean,1}) = - ccall(jniref[].GetBooleanArrayRegion, Nothing, (Ptr{JNIEnv}, jbooleanArray, jsize, jsize, Ptr{jboolean},), env, array, start, l, buf) +GetBooleanArrayRegion(array::jbooleanArray, start::Integer, l::Integer, buf::Array{jboolean,1}) = + ccall(jniref[].GetBooleanArrayRegion, Nothing, (Ptr{JNIEnv}, jbooleanArray, jsize, jsize, Ptr{jboolean},), penv[], array, start, l, buf) -GetByteArrayRegion(env::Ptr{JNIEnv}, array::jbyteArray, start::Integer, len::Integer, buf::Array{jbyte,1}) = - ccall(jniref[].GetByteArrayRegion, Nothing, (Ptr{JNIEnv}, jbyteArray, jsize, jsize, Ptr{jbyte},), env, array, start, len, buf) +GetByteArrayRegion(array::jbyteArray, start::Integer, len::Integer, buf::Array{jbyte,1}) = + ccall(jniref[].GetByteArrayRegion, Nothing, (Ptr{JNIEnv}, jbyteArray, jsize, jsize, Ptr{jbyte},), penv[], array, start, len, buf) -GetCharArrayRegion(env::Ptr{JNIEnv}, array::jcharArray, start::Integer, len::Integer, buf::Array{jchar,1}) = - ccall(jniref[].GetCharArrayRegion, Nothing, (Ptr{JNIEnv}, jcharArray, jsize, jsize, Ptr{jchar},), env, array, start, len, buf) +GetCharArrayRegion(array::jcharArray, start::Integer, len::Integer, buf::Array{jchar,1}) = + ccall(jniref[].GetCharArrayRegion, Nothing, (Ptr{JNIEnv}, jcharArray, jsize, jsize, Ptr{jchar},), penv[], array, start, len, buf) -GetShortArrayRegion(env::Ptr{JNIEnv}, array::jshortArray, start::Integer, len::Integer, buf::Array{jshort,1}) = - ccall(jniref[].GetShortArrayRegion, Nothing, (Ptr{JNIEnv}, jshortArray, jsize, jsize, Ptr{jshort},), env, array, start, len, buf) +GetShortArrayRegion(array::jshortArray, start::Integer, len::Integer, buf::Array{jshort,1}) = + ccall(jniref[].GetShortArrayRegion, Nothing, (Ptr{JNIEnv}, jshortArray, jsize, jsize, Ptr{jshort},), penv[], array, start, len, buf) -GetIntArrayRegion(env::Ptr{JNIEnv}, array::jintArray, start::Integer, len::Integer, buf::Array{jint,1}) = - ccall(jniref[].GetIntArrayRegion, Nothing, (Ptr{JNIEnv}, jintArray, jsize, jsize, Ptr{jint},), env, array, start, len, buf) +GetIntArrayRegion(array::jintArray, start::Integer, len::Integer, buf::Array{jint,1}) = + ccall(jniref[].GetIntArrayRegion, Nothing, (Ptr{JNIEnv}, jintArray, jsize, jsize, Ptr{jint},), penv[], array, start, len, buf) -GetLongArrayRegion(env::Ptr{JNIEnv}, array::jlongArray, start::Integer, len::Integer, buf::Array{jlong,1}) = - ccall(jniref[].GetLongArrayRegion, Nothing, (Ptr{JNIEnv}, jlongArray, jsize, jsize, Ptr{jlong},), env, array, start, len, buf) +GetLongArrayRegion(array::jlongArray, start::Integer, len::Integer, buf::Array{jlong,1}) = + ccall(jniref[].GetLongArrayRegion, Nothing, (Ptr{JNIEnv}, jlongArray, jsize, jsize, Ptr{jlong},), penv[], array, start, len, buf) -GetFloatArrayRegion(env::Ptr{JNIEnv}, array::jfloatArray, start::Integer, len::Integer, buf::Array{jfloat,1}) = - ccall(jniref[].GetFloatArrayRegion, Nothing, (Ptr{JNIEnv}, jfloatArray, jsize, jsize, Ptr{jfloat},), env, array, start, len, buf) +GetFloatArrayRegion(array::jfloatArray, start::Integer, len::Integer, buf::Array{jfloat,1}) = + ccall(jniref[].GetFloatArrayRegion, Nothing, (Ptr{JNIEnv}, jfloatArray, jsize, jsize, Ptr{jfloat},), penv[], array, start, len, buf) -GetDoubleArrayRegion(env::Ptr{JNIEnv}, array::jdoubleArray, start::Integer, len::Integer, buf::Array{jdouble,1}) = - ccall(jniref[].GetDoubleArrayRegion, Nothing, (Ptr{JNIEnv}, jdoubleArray, jsize, jsize, Ptr{jdouble},), env, array, start, len, buf) +GetDoubleArrayRegion(array::jdoubleArray, start::Integer, len::Integer, buf::Array{jdouble,1}) = + ccall(jniref[].GetDoubleArrayRegion, Nothing, (Ptr{JNIEnv}, jdoubleArray, jsize, jsize, Ptr{jdouble},), penv[], array, start, len, buf) -SetBooleanArrayRegion(env::Ptr{JNIEnv}, array::jbooleanArray, start::Integer, l::Integer, buf::Array{jboolean,1}) = - ccall(jniref[].SetBooleanArrayRegion, Nothing, (Ptr{JNIEnv}, jbooleanArray, jsize, jsize, Ptr{jboolean},), env, array, start, l, buf) +SetBooleanArrayRegion(array::jbooleanArray, start::Integer, l::Integer, buf::Array{jboolean,1}) = + ccall(jniref[].SetBooleanArrayRegion, Nothing, (Ptr{JNIEnv}, jbooleanArray, jsize, jsize, Ptr{jboolean},), penv[], array, start, l, buf) -SetByteArrayRegion(env::Ptr{JNIEnv}, array::jbyteArray, start::Integer, len::Integer, buf::Array{jbyte,1}) = - ccall(jniref[].SetByteArrayRegion, Nothing, (Ptr{JNIEnv}, jbyteArray, jsize, jsize, Ptr{jbyte},), env, array, start, len, buf) +SetByteArrayRegion(array::jbyteArray, start::Integer, len::Integer, buf::Array{jbyte,1}) = + ccall(jniref[].SetByteArrayRegion, Nothing, (Ptr{JNIEnv}, jbyteArray, jsize, jsize, Ptr{jbyte},), penv[], array, start, len, buf) -SetCharArrayRegion(env::Ptr{JNIEnv}, array::jcharArray, start::Integer, len::Integer, buf::Array{jchar,1}) = - ccall(jniref[].SetCharArrayRegion, Nothing, (Ptr{JNIEnv}, jcharArray, jsize, jsize, Ptr{jchar},), env, array, start, len, buf) +SetCharArrayRegion(array::jcharArray, start::Integer, len::Integer, buf::Array{jchar,1}) = + ccall(jniref[].SetCharArrayRegion, Nothing, (Ptr{JNIEnv}, jcharArray, jsize, jsize, Ptr{jchar},), penv[], array, start, len, buf) -SetShortArrayRegion(env::Ptr{JNIEnv}, array::jshortArray, start::Integer, len::Integer, buf::Array{jshort,1}) = - ccall(jniref[].SetShortArrayRegion, Nothing, (Ptr{JNIEnv}, jshortArray, jsize, jsize, Ptr{jshort},), env, array, start, len, buf) +SetShortArrayRegion(array::jshortArray, start::Integer, len::Integer, buf::Array{jshort,1}) = + ccall(jniref[].SetShortArrayRegion, Nothing, (Ptr{JNIEnv}, jshortArray, jsize, jsize, Ptr{jshort},), penv[], array, start, len, buf) -SetIntArrayRegion(env::Ptr{JNIEnv}, array::jintArray, start::Integer, len::Integer, buf::Array{jint,1}) = - ccall(jniref[].SetIntArrayRegion, Nothing, (Ptr{JNIEnv}, jintArray, jsize, jsize, Ptr{jint},), env, array, start, len, buf) +SetIntArrayRegion(array::jintArray, start::Integer, len::Integer, buf::Array{jint,1}) = + ccall(jniref[].SetIntArrayRegion, Nothing, (Ptr{JNIEnv}, jintArray, jsize, jsize, Ptr{jint},), penv[], array, start, len, buf) -SetLongArrayRegion(env::Ptr{JNIEnv}, array::jlongArray, start::Integer, len::Integer, buf::Array{jlong,1}) = - ccall(jniref[].SetLongArrayRegion, Nothing, (Ptr{JNIEnv}, jlongArray, jsize, jsize, Ptr{jlong},), env, array, start, len, buf) +SetLongArrayRegion(array::jlongArray, start::Integer, len::Integer, buf::Array{jlong,1}) = + ccall(jniref[].SetLongArrayRegion, Nothing, (Ptr{JNIEnv}, jlongArray, jsize, jsize, Ptr{jlong},), penv[], array, start, len, buf) -SetFloatArrayRegion(env::Ptr{JNIEnv}, array::jfloatArray, start::Integer, len::Integer, buf::Array{jfloat,1}) = - ccall(jniref[].SetFloatArrayRegion, Nothing, (Ptr{JNIEnv}, jfloatArray, jsize, jsize, Ptr{jfloat},), env, array, start, len, buf) +SetFloatArrayRegion(array::jfloatArray, start::Integer, len::Integer, buf::Array{jfloat,1}) = + ccall(jniref[].SetFloatArrayRegion, Nothing, (Ptr{JNIEnv}, jfloatArray, jsize, jsize, Ptr{jfloat},), penv[], array, start, len, buf) -SetDoubleArrayRegion(env::Ptr{JNIEnv}, array::jdoubleArray, start::Integer, len::Integer, buf::Array{jdouble,1}) = - ccall(jniref[].SetDoubleArrayRegion, Nothing, (Ptr{JNIEnv}, jdoubleArray, jsize, jsize, Ptr{jdouble},), env, array, start, len, buf) +SetDoubleArrayRegion(array::jdoubleArray, start::Integer, len::Integer, buf::Array{jdouble,1}) = + ccall(jniref[].SetDoubleArrayRegion, Nothing, (Ptr{JNIEnv}, jdoubleArray, jsize, jsize, Ptr{jdouble},), penv[], array, start, len, buf) -RegisterNatives(env::Ptr{JNIEnv}, clazz::jclass, methods::Array{JNINativeMethod,1}, nMethods::jint) = - ccall(jniref[].RegisterNatives, jint, (Ptr{JNIEnv}, jclass, Ptr{JNINativeMethod}, jint,), env, clazz, methods, nMethods) +RegisterNatives(clazz::jclass, methods::Array{JNINativeMethod,1}, nMethods::jint) = + ccall(jniref[].RegisterNatives, jint, (Ptr{JNIEnv}, jclass, Ptr{JNINativeMethod}, jint,), penv[], clazz, methods, nMethods) -UnregisterNatives(env::Ptr{JNIEnv}, clazz::jclass) = - ccall(jniref[].UnregisterNatives, jint, (Ptr{JNIEnv}, jclass,), env, clazz) +UnregisterNatives(clazz::jclass) = + ccall(jniref[].UnregisterNatives, jint, (Ptr{JNIEnv}, jclass,), penv[], clazz) -MonitorEnter(env::Ptr{JNIEnv}, obj::jobject) = - ccall(jniref[].MonitorEnter, jint, (Ptr{JNIEnv}, jobject,), env, obj) +MonitorEnter(obj::jobject) = + ccall(jniref[].MonitorEnter, jint, (Ptr{JNIEnv}, jobject,), penv[], obj) -MonitorExit(env::Ptr{JNIEnv}, obj::jobject) = - ccall(jniref[].MonitorExit, jint, (Ptr{JNIEnv}, jobject,), env, obj) +MonitorExit(obj::jobject) = + ccall(jniref[].MonitorExit, jint, (Ptr{JNIEnv}, jobject,), penv[], obj) -GetJavaVM(env::Ptr{JNIEnv}, vm::Array{JavaVM,1}) = - ccall(jniref[].GetJavaVM, jint, (Ptr{JNIEnv}, Array{JavaVM,1},), env, vm) +GetJavaVM(vm::Array{JavaVM,1}) = + ccall(jniref[].GetJavaVM, jint, (Ptr{JNIEnv}, Array{JavaVM,1},), penv[], vm) -GetStringRegion(env::Ptr{JNIEnv}, str::jstring, start::Integer, len::Integer, buf::Array{jchar,1}) = - ccall(jniref[].GetStringRegion, Nothing, (Ptr{JNIEnv}, jstring, jsize, jsize, Ptr{jchar},), env, str, start, len, buf) +GetStringRegion(str::jstring, start::Integer, len::Integer, buf::Array{jchar,1}) = + ccall(jniref[].GetStringRegion, Nothing, (Ptr{JNIEnv}, jstring, jsize, jsize, Ptr{jchar},), penv[], str, start, len, buf) -GetStringUTFRegion(env::Ptr{JNIEnv}, str::jstring, start::Integer, len::Integer, buf::AnyString) = - ccall(jniref[].GetStringUTFRegion, Nothing, (Ptr{JNIEnv}, jstring, jsize, jsize, Cstring,), env, str, start, len, buf) +GetStringUTFRegion(str::jstring, start::Integer, len::Integer, buf::AnyString) = + ccall(jniref[].GetStringUTFRegion, Nothing, (Ptr{JNIEnv}, jstring, jsize, jsize, Cstring,), penv[], str, start, len, buf) -GetPrimitiveArrayCritical(env::Ptr{JNIEnv}, array::jarray, isCopy::PtrIsCopy) = - ccall(jniref[].GetPrimitiveArrayCritical, Ptr{Nothing}, (Ptr{JNIEnv}, jarray, Ptr{jboolean},), env, array, isCopy) +GetPrimitiveArrayCritical(array::jarray, isCopy::PtrIsCopy) = + ccall(jniref[].GetPrimitiveArrayCritical, Ptr{Nothing}, (Ptr{JNIEnv}, jarray, Ptr{jboolean},), penv[], array, isCopy) -ReleasePrimitiveArrayCritical(env::Ptr{JNIEnv}, array::jarray, carray::Ptr{Nothing}, mode::jint) = - ccall(jniref[].ReleasePrimitiveArrayCritical, Nothing, (Ptr{JNIEnv}, jarray, Ptr{Nothing}, jint,), env, array, carray, mode) +ReleasePrimitiveArrayCritical(array::jarray, carray::Ptr{Nothing}, mode::jint) = + ccall(jniref[].ReleasePrimitiveArrayCritical, Nothing, (Ptr{JNIEnv}, jarray, Ptr{Nothing}, jint,), penv[], array, carray, mode) -GetStringCritical(env::Ptr{JNIEnv}, string::jstring, isCopy::PtrIsCopy) = - ccall(jniref[].GetStringCritical, Ptr{jchar}, (Ptr{JNIEnv}, jstring, Ptr{jboolean},), env, string, isCopy) +GetStringCritical(string::jstring, isCopy::PtrIsCopy) = + ccall(jniref[].GetStringCritical, Ptr{jchar}, (Ptr{JNIEnv}, jstring, Ptr{jboolean},), penv[], string, isCopy) -ReleaseStringCritical(env::Ptr{JNIEnv}, string::jstring, cstring::Array{jchar,1}) = - ccall(jniref[].ReleaseStringCritical, Nothing, (Ptr{JNIEnv}, jstring, Ptr{jchar},), env, string, cstring) +ReleaseStringCritical(string::jstring, cstring::Array{jchar,1}) = + ccall(jniref[].ReleaseStringCritical, Nothing, (Ptr{JNIEnv}, jstring, Ptr{jchar},), penv[], string, cstring) -NewWeakGlobalRef(env::Ptr{JNIEnv}, obj::jobject) = - ccall(jniref[].NewWeakGlobalRef, jweak, (Ptr{JNIEnv}, jobject,), env, obj) +NewWeakGlobalRef(obj::jobject) = + ccall(jniref[].NewWeakGlobalRef, jweak, (Ptr{JNIEnv}, jobject,), penv[], obj) -DeleteWeakGlobalRef(env::Ptr{JNIEnv}, ref::jweak) = - ccall(jniref[].DeleteWeakGlobalRef, Nothing, (Ptr{JNIEnv}, jweak,), env, ref) +DeleteWeakGlobalRef(ref::jweak) = + ccall(jniref[].DeleteWeakGlobalRef, Nothing, (Ptr{JNIEnv}, jweak,), penv[], ref) -ExceptionCheck(env::Ptr{JNIEnv}) = - ccall(jniref[].ExceptionCheck, jboolean, (Ptr{JNIEnv},), env) +ExceptionCheck() = + ccall(jniref[].ExceptionCheck, jboolean, (Ptr{JNIEnv},), penv[]) -NewDirectByteBuffer(env::Ptr{JNIEnv}, address::Ptr{Nothing}, capacity::jlong) = - ccall(jniref[].NewDirectByteBuffer, jobject, (Ptr{JNIEnv}, Ptr{Nothing}, jlong,), env, address, capacity) +NewDirectByteBuffer(address::Ptr{Nothing}, capacity::jlong) = + ccall(jniref[].NewDirectByteBuffer, jobject, (Ptr{JNIEnv}, Ptr{Nothing}, jlong,), penv[], address, capacity) -GetDirectBufferAddress(env::Ptr{JNIEnv}, buf::jobject) = - ccall(jniref[].GetDirectBufferAddress, Ptr{Nothing}, (Ptr{JNIEnv}, jobject,), env, buf) +GetDirectBufferAddress(buf::jobject) = + ccall(jniref[].GetDirectBufferAddress, Ptr{Nothing}, (Ptr{JNIEnv}, jobject,), penv[], buf) -GetDirectBufferCapacity(env::Ptr{JNIEnv}, buf::jobject) = - ccall(jniref[].GetDirectBufferCapacity, jlong, (Ptr{JNIEnv}, jobject,), env, buf) +GetDirectBufferCapacity(buf::jobject) = + ccall(jniref[].GetDirectBufferCapacity, jlong, (Ptr{JNIEnv}, jobject,), penv[], buf) -GetObjectRefType(env::Ptr{JNIEnv}, obj::jobject) = - ccall(jniref[].GetObjectRefType, jobjectRefType, (Ptr{JNIEnv}, jobject,), env, obj) +GetObjectRefType(obj::jobject) = + ccall(jniref[].GetObjectRefType, jobjectRefType, (Ptr{JNIEnv}, jobject,), penv[], obj) # === Above Generated by make_jni2.jl === diff --git a/src/JavaCall.jl b/src/JavaCall.jl index 7c66bb9..6602892 100644 --- a/src/JavaCall.jl +++ b/src/JavaCall.jl @@ -11,7 +11,6 @@ export JavaObject, JavaMetaClass, # using Sys: iswindows, islinux, isunix, isapple import DataStructures: OrderedSet -import Libdl using Dates @static if Sys.iswindows() @@ -44,8 +43,6 @@ function __init__() "Calling the JVM may result in undefined behavior.") end end - findjvm() - global create = Libdl.dlsym(libjvm, :JNI_CreateJavaVM) end diff --git a/src/convert.jl b/src/convert.jl index 9001713..1bb8483 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 = JNI.NewLocalRef(penv, obj.ptr) + ptr = JNI.NewLocalRef(obj.ptr) ptr === C_NULL && geterror() return JavaObject{T}(ptr) end isnull(obj) && throw(ArgumentError("Cannot convert NULL")) - realClass = JNI.GetObjectClass(penv, obj.ptr) + realClass = JNI.GetObjectClass(obj.ptr) if isConvertible(T, realClass) #dynamic cast - ptr = JNI.NewLocalRef(penv, obj.ptr) + ptr = JNI.NewLocalRef(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) = 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 +isConvertible(T, S) = JNI.IsAssignableFrom(metaclass(S).ptr, metaclass(T).ptr) == JNI_TRUE +isConvertible(T, S::Ptr{Nothing} ) = JNI.IsAssignableFrom(S, metaclass(T).ptr) == JNI_TRUE unsafe_convert(::Type{Ptr{Nothing}}, cls::JavaMetaClass) = cls.ptr @@ -71,8 +71,8 @@ for (x, y, z) in [(:jboolean, :(JNI.NewBooleanArray), :(JNI.SetBooleanArrayRegio function convert_arg(argtype::Type{Array{$x,1}}, arg) carg = convert(argtype, arg) sz=length(carg) - arrayptr = $y(penv, sz) - $z(penv, arrayptr, 0, sz, carg) + arrayptr = $y(sz) + $z(arrayptr, 0, sz, carg) return carg, arrayptr end end @@ -83,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 = JNI.NewObjectArray(penv, sz, metaclass(T).ptr, init.ptr) + arrayptr = JNI.NewObjectArray(sz, metaclass(T).ptr, init.ptr) for i=2:sz - JNI.SetObjectArrayElement(penv, arrayptr, i-1, carg[i].ptr) + JNI.SetObjectArrayElement(arrayptr, i-1, carg[i].ptr) end return carg, arrayptr end @@ -104,11 +104,11 @@ for (x, y, z) in [(:jboolean, :(JNI.GetBooleanArrayElements), :(JNI.ReleaseBoole (:jdouble, :(JNI.GetDoubleArrayElements), :(JNI.ReleaseDoubleArrayElements)) ] m = quote function convert_result(rettype::Type{Array{$(x),1}}, result) - sz = JNI.GetArrayLength(penv, result) - arr = $y(penv, result, Ptr{jboolean}(C_NULL)) + sz = JNI.GetArrayLength(result) + arr = $y(result, Ptr{jboolean}(C_NULL)) jl_arr::Array = unsafe_wrap(Array, arr, Int(sz)) jl_arr = deepcopy(jl_arr) - $z(penv, result, arr, Int32(0)) + $z(result, arr, Int32(0)) return jl_arr end end @@ -116,12 +116,12 @@ for (x, y, z) in [(:jboolean, :(JNI.GetBooleanArrayElements), :(JNI.ReleaseBoole end function convert_result(rettype::Type{Array{JavaObject{T},1}}, result) where T - sz = JNI.GetArrayLength(penv, result) + sz = JNI.GetArrayLength(result) ret = Array{JavaObject{T}}(undef, sz) for i=1:sz - a=JNI.GetObjectArrayElement(penv, result, i-1) + a=JNI.GetObjectArrayElement(result, i-1) ret[i] = JavaObject{T}(a) end return ret @@ -130,12 +130,12 @@ end # covers return types like Vector{Vector{T}} function convert_result(rettype::Type{Array{T,1}}, result) where T - sz = JNI.GetArrayLength(penv, result) + sz = JNI.GetArrayLength(result) ret = Array{T}(undef, sz) for i=1:sz - a=JNI.GetObjectArrayElement(penv, result, i-1) + a=JNI.GetObjectArrayElement(result, i-1) ret[i] = convert_result(T, a) end return ret @@ -143,20 +143,20 @@ end function convert_result(rettype::Type{Array{JavaObject{T},2}}, result) where T - sz = JNI.GetArrayLength(penv, result) + sz = JNI.GetArrayLength(result) if sz == 0 return Array{T}(undef, 0,0) end - a_1 = JNI.GetObjectArrayElement(penv, result, 0) - sz_1 = JNI.GetArrayLength(penv, a_1) + a_1 = JNI.GetObjectArrayElement(result, 0) + sz_1 = JNI.GetArrayLength(a_1) ret = Array{JavaObject{T}}(undef, sz, sz_1) for i=1:sz - a = JNI.GetObjectArrayElement(penv, result, i-1) + a = JNI.GetObjectArrayElement(result, i-1) # check that size of the current subarray is the same as for the first one - sz_a = JNI.GetArrayLength(penv, a) + sz_a = JNI.GetArrayLength(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 = JNI.GetObjectArrayElement(penv, a, j-1) + x = JNI.GetObjectArrayElement(a, j-1) ret[i, j] = JavaObject{T}(x) end end @@ -166,17 +166,17 @@ end # matrices of primitive types and other arrays function convert_result(rettype::Type{Array{T,2}}, result) where T - sz = JNI.GetArrayLength(penv, result) + sz = JNI.GetArrayLength(result) if sz == 0 return Array{T}(undef, 0,0) end - a_1 = JNI.GetObjectArrayElement(penv, result, 0) - sz_1 = JNI.GetArrayLength(penv, a_1) + a_1 = JNI.GetObjectArrayElement(result, 0) + sz_1 = JNI.GetArrayLength(a_1) ret = Array{T}(undef, sz, sz_1) for i=1:sz - a = JNI.GetObjectArrayElement(penv, result, i-1) + a = JNI.GetObjectArrayElement(result, i-1) # check that size of the current subarray is the same as for the first one - sz_a = JNI.GetArrayLength(penv, a) + sz_a = JNI.GetArrayLength(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 @@ -252,10 +252,10 @@ 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} = JNI.GetStringUTFChars(penv, jstr.ptr, pIsCopy) - buf = JNI.GetStringUTFChars(penv, jstr.ptr, pIsCopy) + #buf::Ptr{UInt8} = JNI.GetStringUTFChars(jstr.ptr, pIsCopy) + buf = JNI.GetStringUTFChars(jstr.ptr, pIsCopy) s = unsafe_string(buf) - JNI.ReleaseStringUTFChars(penv, jstr.ptr, buf) + JNI.ReleaseStringUTFChars(jstr.ptr, buf) return s end @@ -269,11 +269,11 @@ for (x, y, z) in [(:jboolean, :(JNI.GetBooleanArrayElements), :(JNI.ReleaseBoole (:jdouble, :(JNI.GetDoubleArrayElements), :(JNI.ReleaseDoubleArrayElements)) ] m = quote function convert(::Type{Array{$(x),1}}, obj::JObject) - sz = JNI.GetArrayLength(penv, obj.ptr) - arr = $y(penv, obj.ptr, Ptr{jboolean}(C_NULL)) + sz = JNI.GetArrayLength(obj.ptr) + arr = $y(obj.ptr, Ptr{jboolean}(C_NULL)) jl_arr::Array = unsafe_wrap(Array, arr, Int(sz)) jl_arr = deepcopy(jl_arr) - $z(penv, obj.ptr, arr, Int32(0)) + $z(obj.ptr, arr, Int32(0)) return jl_arr end end @@ -282,10 +282,10 @@ end function convert(::Type{Array{T, 1}}, obj::JObject) where T - sz = JNI.GetArrayLength(penv, obj.ptr) + sz = JNI.GetArrayLength(obj.ptr) ret = Array{T}(undef, sz) for i=1:sz - ptr = JNI.GetObjectArrayElement(penv, obj.ptr, i-1) + ptr = JNI.GetObjectArrayElement(obj.ptr, i-1) ret[i] = convert(T, JObject(ptr)) end return ret diff --git a/src/core.jl b/src/core.jl index f5548c8..a8588fa 100644 --- a/src/core.jl +++ b/src/core.jl @@ -25,8 +25,8 @@ JavaObject{T}() where {T} = JavaObject{T}((),) function deleteref(x::JavaObject) if x.ptr == C_NULL; return; end - if (penv==C_NULL); return; end - JNI.DeleteLocalRef(penv, x.ptr) + if !JNI.is_env_loaded(); return; end; + JNI.DeleteLocalRef(x.ptr) x.ptr=C_NULL #Safety in case this function is called direcly, rather than at finalize return end @@ -69,7 +69,7 @@ const JClassLoader = JavaObject{Symbol("java.lang.ClassLoader")} const JString = JavaObject{Symbol("java.lang.String")} function JString(str::AbstractString) - jstring = JNI.NewStringUTF(penv, String(str)) + jstring = JNI.NewStringUTF(String(str)) if jstring == C_NULL geterror() else @@ -107,7 +107,7 @@ end function jnew(T::Symbol, argtypes::Tuple, args...) assertroottask_or_goodenv() sig = method_signature(Nothing, argtypes...) - jmethodId = JNI.GetMethodID(penv, metaclass(T).ptr, String(""), sig) + jmethodId = JNI.GetMethodID(metaclass(T).ptr, String(""), sig) if jmethodId == C_NULL throw(JavaCallError("No constructor for $T with signature $sig")) end @@ -119,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 = JNI.GetStaticMethodID(penv, metaclass(T).ptr, String(method), sig) + jmethodId = JNI.GetStaticMethodID(metaclass(T).ptr, String(method), sig) jmethodId==C_NULL && geterror(true) _jcall(metaclass(T), jmethodId, C_NULL, rettype, argtypes, args...) end @@ -128,21 +128,21 @@ end function jcall(obj::JavaObject, method::AbstractString, rettype::Type, argtypes::Tuple, args... ) assertroottask_or_goodenv() sig = method_signature(rettype, argtypes...) - jmethodId = JNI.GetMethodID(penv, metaclass(obj).ptr, String(method), sig) + jmethodId = JNI.GetMethodID(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 = JNI.GetStaticFieldID(penv, metaclass(T).ptr, String(field), signature(fieldType)) + jfieldID = JNI.GetStaticFieldID(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 = JNI.GetFieldID(penv, metaclass(obj).ptr, String(field), signature(fieldType)) + jfieldID = JNI.GetFieldID(metaclass(obj).ptr, String(field), signature(fieldType)) jfieldID==C_NULL && geterror(true) _jfield(obj, jfieldID, fieldType) end @@ -159,7 +159,7 @@ for (x, y, z) in [(:jboolean, :(JNI.GetBooleanField), :(JNI.GetStaticBooleanFiel m = quote function _jfield(obj, jfieldID::Ptr{Nothing}, fieldType::Type{$(x)}) callmethod = ifelse( typeof(obj)<:JavaObject, $y , $z ) - result = callmethod(penv, obj.ptr, jfieldID) + result = callmethod(obj.ptr, jfieldID) result==C_NULL && geterror() return convert_result(fieldType, result) end @@ -169,7 +169,7 @@ end function _jfield(obj, jfieldID::Ptr{Nothing}, fieldType::Type) callmethod = ifelse( typeof(obj)<:JavaObject, JNI.GetObjectField , JNI.GetStaticObjectField ) - result = callmethod(penv, obj.ptr, jfieldID) + result = callmethod(obj.ptr, jfieldID) result==C_NULL && geterror() return convert_result(fieldType, result) end @@ -195,7 +195,7 @@ for (x, y, z) in [(:jboolean, :(JNI.CallBooleanMethodA), :(JNI.CallStaticBoolean @assert jmethodId != C_NULL isnull(obj) && throw(JavaCallError("Attempt to call method on Java NULL")) savedArgs, convertedArgs = convert_args(argtypes, args...) - result = callmethod(penv, obj.ptr, jmethodId, convertedArgs) + result = callmethod(obj.ptr, jmethodId, convertedArgs) result==C_NULL && geterror() result == nothing && (return) return convert_result(rettype, result) @@ -219,7 +219,7 @@ function _jcall(obj, jmethodId::Ptr{Nothing}, callmethod::Union{Function,Ptr{Not @assert jmethodId != C_NULL isnull(obj) && error("Attempt to call method on Java NULL") savedArgs, convertedArgs = convert_args(argtypes, args...) - result = callmethod(penv, obj.ptr, jmethodId, convertedArgs) + result = callmethod(obj.ptr, jmethodId, convertedArgs) result==C_NULL && geterror() return convert_result(rettype, result) end @@ -229,7 +229,7 @@ global const _jmc_cache = Dict{Symbol, JavaMetaClass}() function _metaclass(class::Symbol) jclass=javaclassname(class) - jclassptr = JNI.FindClass(penv, jclass) + jclassptr = JNI.FindClass(jclass) jclassptr == C_NULL && throw(JavaCallError("Class Not Found $jclass")) return JavaMetaClass(class, jclassptr) end @@ -247,21 +247,21 @@ metaclass(::JavaObject{T}) where {T} = metaclass(T) javaclassname(class::Symbol) = replace(string(class), "."=>"/") function geterror(allow=false) - isexception = JNI.ExceptionCheck(penv) + isexception = JNI.ExceptionCheck() if isexception == JNI_TRUE - jthrow = JNI.ExceptionOccurred(penv) + jthrow = JNI.ExceptionOccurred() jthrow==C_NULL && throw(JavaCallError("Java Exception thrown, but no details could be retrieved from the JVM")) - JNI.ExceptionDescribe(penv ) #Print java stackstrace to stdout - JNI.ExceptionClear(penv ) - jclass = JNI.FindClass(penv, "java/lang/Throwable") + JNI.ExceptionDescribe() #Print java stackstrace to stdout + JNI.ExceptionClear() + jclass = JNI.FindClass("java/lang/Throwable") jclass==C_NULL && throw(JavaCallError("Java Exception thrown, but no details could be retrieved from the JVM")) - jmethodId=JNI.GetMethodID(penv, jclass, "toString", "()Ljava/lang/String;") + jmethodId=JNI.GetMethodID(jclass, "toString", "()Ljava/lang/String;") jmethodId==C_NULL && throw(JavaCallError("Java Exception thrown, but no details could be retrieved from the JVM")) - res = JNI.CallObjectMethodA(penv, jthrow, jmethodId, Int[]) + res = JNI.CallObjectMethodA(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)) - JNI.DeleteLocalRef(penv, jthrow) + JNI.DeleteLocalRef(jthrow) throw(JavaCallError(string("Error calling Java: ",msg))) else if allow==false diff --git a/src/jnienv.jl b/src/jnienv.jl index 2b2ef66..07d4c59 100644 --- a/src/jnienv.jl +++ b/src/jnienv.jl @@ -309,6 +309,7 @@ JNINativeInterface() = JNINativeInterface(repeat([C_NULL],233)...) struct JNIEnv JNINativeInterface_::Ptr{JNINativeInterface} end +JNIEnv() = JNIEnv(C_NULL) struct JNIInvokeInterface #struct JNIInvokeInterface_ { reserved0::Ptr{Nothing} #void *reserved0; @@ -325,6 +326,7 @@ struct JNIInvokeInterface #struct JNIInvokeInterface_ { AttachCurrentThreadAsDaemon::Ptr{Nothing} #jint (JNICALL *AttachCurrentThreadAsDaemon)(JavaVM *vm, void **penv, void *args); end +JNIInvokeInterface() = JNIInvokeInterface(repeat([C_NULL],8)...) struct JavaVM JNIInvokeInterface_::Ptr{JNIInvokeInterface} diff --git a/src/jvm.jl b/src/jvm.jl index 2858c6f..e0c6ef9 100644 --- a/src/jvm.jl +++ b/src/jvm.jl @@ -90,9 +90,7 @@ function findjvm() Libdl.dlopen(joinpath(bindir,m[1])) end end - global libjvm = Libdl.dlopen(libpath) - @debug("Loaded $libpath") - return + return libpath end end catch @@ -113,17 +111,6 @@ end -struct JavaVMOption - optionString::Ptr{UInt8} - extraInfo::Ptr{Nothing} -end - -struct JavaVMInitArgs - version::Cint - nOptions::Cint - options::Ptr{JavaVMOption} - ignoreUnrecognized::Cchar -end @static Sys.isunix() ? (const sep = ":") : nothing @@ -248,7 +235,7 @@ else assertroottask_or_goodenv() = isgoodenv() ? nothing : throw(ROOT_TASK_ERROR) end -isloaded() = JNI.is_jni_loaded() && isdefined(JavaCall, :penv) && penv != C_NULL +isloaded() = JNI.is_jni_loaded() && JNI.is_env_loaded() assertloaded() = isloaded() ? nothing : throw(JavaCallError("JVM not initialised. Please run init()")) assertnotloaded() = isloaded() ? throw(JavaCallError("JVM already initialised")) : nothing @@ -295,20 +282,7 @@ end function _init(opts) assertnotloaded() assertroottask_or_goodenv() - 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.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)) - res < 0 && throw(JavaCallError("Unable to initialise Java VM: $(res)")) - global penv = ppenv[1] - global pjvm = ppjvm[1] - jvm = unsafe_load(pjvm) - global jvmfunc = unsafe_load(jvm.JNIInvokeInterface_) - JNI.load_jni(penv) - return + JNI.init_new_vm(findjvm(),opts); end """ @@ -353,24 +327,10 @@ public class Julia { ``` """ function init_current_vm() - ppjvm = Array{Ptr{JavaVM}}(undef, 1) - ppenv = Array{Ptr{JNIEnv}}(undef, 1) - pnum = Array{Cint}(undef, 1) - ccall(Libdl.dlsym(libjvm, :JNI_GetCreatedJavaVMs), Cint, (Ptr{Ptr{JavaVM}}, Cint, Ptr{Cint}), ppjvm, 1, pnum) - 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.JNI_VERSION_1_8) - global penv = ppenv[1] - JNI.load_jni(penv) + JNI.init_current_vm(findjvm()) end function destroy() - if (!isdefined(JavaCall, :penv) || penv == C_NULL) - throw(JavaCallError("Called destroy without initialising Java VM")) - end assertroottask_or_goodenv() - res = ccall(jvmfunc.DestroyJavaVM, Cint, (Ptr{Nothing},), pjvm) - res < 0 && throw(JavaCallError("Unable to destroy Java VM")) - global penv=C_NULL; global pjvm=C_NULL; + JNI.destroy() end diff --git a/test/runtests.jl b/test/runtests.jl index 37846b6..4c163eb 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -35,10 +35,8 @@ System = @jimport java.lang.System @testset "unsafe_strings_1" begin a=JString("how are you") @test a.ptr != C_NULL - @test 11 == ccall(JavaCall.jnifunc.GetStringUTFLength, jint, (Ptr{JavaCall.JNIEnv}, Ptr{Nothing}), - JavaCall.penv, a.ptr) - b = ccall(JavaCall.jnifunc.GetStringUTFChars, Ptr{UInt8}, - (Ptr{JavaCall.JNIEnv}, Ptr{Nothing}, Ptr{Nothing}), JavaCall.penv, a.ptr, C_NULL) + @test 11 == JavaCall.JNI.GetStringUTFLength(a.ptr) + b = JavaCall.JNI.GetStringUTFChars(a.ptr,Ref{JavaCall.JNI.jboolean}()) @test unsafe_string(b) == "how are you" end From 1b5e00fd75d84ebc17ade1533c2143eee61a73fa Mon Sep 17 00:00:00 2001 From: "markkitt@gmail.com" Date: Wed, 6 May 2020 01:42:51 -0500 Subject: [PATCH 02/12] Eliminate ppenv and ppjvm --- src/JNI.jl | 16 +++++----------- 1 file changed, 5 insertions(+), 11 deletions(-) diff --git a/src/JNI.jl b/src/JNI.jl index 96416aa..1ba71b5 100644 --- a/src/JNI.jl +++ b/src/JNI.jl @@ -120,21 +120,19 @@ is_env_loaded() = penv[] != C_NULL """ init_new_vm(opts) + +Initialize a new Java virtual machine. """ function init_new_vm(libpath,opts) libjvm = Libdl.dlopen(libpath) @debug("Loaded $libpath") create = Libdl.dlsym(libjvm, :JNI_CreateJavaVM) 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_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, + res = ccall(create, Cint, (Ptr{Ptr{JavaVM}}, Ptr{Ptr{JNIEnv}}, Ptr{JavaVMInitArgs}), pjvm, penv, Ref(vm_args)) res < 0 && throw(JNIError("Unable to initialise Java VM: $(res)")) - global penv[] = ppenv[1] - global pjvm[] = ppjvm[1] jvm = unsafe_load(pjvm[]) global jvmfunc[] = unsafe_load(jvm.JNIInvokeInterface_) JNI.load_jni(penv[]) @@ -149,15 +147,11 @@ Allow initialization from running VM. Uses the first VM it finds. function init_current_vm(libpath) libjvm = Libdl.dlopen(libpath) @debug("Loaded $libpath") - ppjvm = Array{Ptr{JavaVM}}(undef, 1) - ppenv = Array{Ptr{JNIEnv}}(undef, 1) pnum = Array{Cint}(undef, 1) - ccall(Libdl.dlsym(libjvm, :JNI_GetCreatedJavaVMs), Cint, (Ptr{Ptr{JavaVM}}, Cint, Ptr{Cint}), ppjvm, 1, pnum) - global pjvm[] = ppjvm[1] + ccall(Libdl.dlsym(libjvm, :JNI_GetCreatedJavaVMs), Cint, (Ptr{Ptr{JavaVM}}, Cint, Ptr{Cint}), pjvm, 1, pnum) jvm = unsafe_load(pjvm[]) global jvmfunc[] = unsafe_load(jvm.JNIInvokeInterface_) - ccall(jvmfunc[].GetEnv, Cint, (Ptr{Nothing}, Ptr{Ptr{JNIEnv}}, Cint), pjvm[], ppenv, JNI.JNI_VERSION_1_8) - global penv[] = ppenv[1] + ccall(jvmfunc[].GetEnv, Cint, (Ptr{Nothing}, Ptr{Ptr{JNIEnv}}, Cint), pjvm[], penv, JNI.JNI_VERSION_1_8) JNI.load_jni(penv) end From 472726faa025c813c044ef0805e283e1f9c6a116 Mon Sep 17 00:00:00 2001 From: "markkitt@gmail.com" Date: Wed, 6 May 2020 01:53:34 -0500 Subject: [PATCH 03/12] Maintain the generator script --- src/make_jni2.jl | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/src/make_jni2.jl b/src/make_jni2.jl index 8dd901c..24a22fe 100644 --- a/src/make_jni2.jl +++ b/src/make_jni2.jl @@ -17,7 +17,11 @@ end function arg_value(m) #if m.captures[2] == "*" && m.captures[1] == "char" return "String($(m.captures[3]))" end - m.captures[3] + if m.captures[3] == "env" + "penv[]" + else + m.captures[3] + end end decl_arg_type(m) = decl_arg_type(m.captures[1], m.captures[2]) @@ -112,7 +116,8 @@ for line in open(readlines, "jnienv.jl", "r") # 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), ", ") + # skip the JNIEnv arg for julia since it is passed as a global to ccall + julia_args = join(map(julia_arg, mm)[2:end], ", ") arg_types = join(map(ccall_arg_type, mm), ", ") arg_names = join(map(arg_value, mm), ", ") From a8335a50353f2b049e4e7089f48e39a1be59ed5b Mon Sep 17 00:00:00 2001 From: "markkitt@gmail.com" Date: Sat, 9 May 2020 11:39:49 -0500 Subject: [PATCH 04/12] Squashed commit of the following: commit 66c6c3305c0d1ee1c38b154b407ba1ce37ac7639 Author: markkitt@gmail.com Date: Sat May 9 01:38:52 2020 -0500 Load multiple libraries in JNI if necessary commit a45956529287fb8e51bc3a5f8217086952733c2c Author: markkitt@gmail.com Date: Sat May 9 00:26:39 2020 -0500 Throw error from findjvm --- src/JNI.jl | 17 +++++++++++++---- src/jvm.jl | 7 ++++--- 2 files changed, 17 insertions(+), 7 deletions(-) diff --git a/src/JNI.jl b/src/JNI.jl index 1ba71b5..5330ac2 100644 --- a/src/JNI.jl +++ b/src/JNI.jl @@ -124,8 +124,7 @@ is_env_loaded() = penv[] != C_NULL Initialize a new Java virtual machine. """ function init_new_vm(libpath,opts) - libjvm = Libdl.dlopen(libpath) - @debug("Loaded $libpath") + libjvm = load_libjvm(libpath) create = Libdl.dlsym(libjvm, :JNI_CreateJavaVM) opt = [JavaVMOption(pointer(x), C_NULL) for x in opts] vm_args = JavaVMInitArgs(JNI_VERSION_1_8, convert(Cint, length(opts)), @@ -145,8 +144,7 @@ end Allow initialization from running VM. Uses the first VM it finds. """ function init_current_vm(libpath) - libjvm = Libdl.dlopen(libpath) - @debug("Loaded $libpath") + libjvm = load_libjvm(libpath) pnum = Array{Cint}(undef, 1) ccall(Libdl.dlsym(libjvm, :JNI_GetCreatedJavaVMs), Cint, (Ptr{Ptr{JavaVM}}, Cint, Ptr{Cint}), pjvm, 1, pnum) jvm = unsafe_load(pjvm[]) @@ -155,6 +153,17 @@ function init_current_vm(libpath) JNI.load_jni(penv) end +function load_libjvm(libpath::AbstractString) + libjvm = Libdl.dlopen(libpath) + @debug("Loaded $libpath") + libjvm +end + +function load_libjvm(libpaths::NTuple{N,String}) where N + Libdl.dlopen.(libpaths) + load_libjvm(libpaths[end]) +end + function destroy() if !is_env_loaded() throw(JNIError("Called destroy without initialising Java VM")) diff --git a/src/jvm.jl b/src/jvm.jl index e0c6ef9..e2aaaef 100644 --- a/src/jvm.jl +++ b/src/jvm.jl @@ -87,13 +87,14 @@ function findjvm() bindir = dirname(dirname(libpath)) m = filter(x -> occursin(r"msvcr(?:.*).dll",x), readdir(bindir)) if !isempty(m) - Libdl.dlopen(joinpath(bindir,m[1])) + return (joinpath(bindir,m[1]),libpath) end end - return libpath + return (libpath,) end end - catch + catch err + throw(err) end errorMsg = From 9449dfd5ad30bdff0a0e2077bfd7e5f839aa8335 Mon Sep 17 00:00:00 2001 From: "markkitt@gmail.com" Date: Sat, 9 May 2020 16:14:35 -0500 Subject: [PATCH 05/12] Streamline appveyor --- appveyor.yml | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/appveyor.yml b/appveyor.yml index 81cca65..e7ad0a3 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -1,13 +1,14 @@ environment: matrix: + - julia_version: 1.0 + platform: x64 # 64-bit - julia_version: 1 - - julia_version: 1.3 - - julia_version: 1.4 + platform: x64 # 64-bit + - julia_version: 1 + JAVA_HOME: C:\Program Files (x86)\Java\jdk1.8.0 + platform: x86 # 32-bit - julia_version: nightly - -platform: - - x86 # 32-bit - - x64 # 64-bit + platform: x64 # 64-bit # # Uncomment the following lines to allow failures on nightly julia # # (tests will run but not make your overall status red) From f3a0b1fe49eea0c78ca45515d1626ac9488bdb8f Mon Sep 17 00:00:00 2001 From: "markkitt@gmail.com" Date: Sat, 9 May 2020 18:08:58 -0500 Subject: [PATCH 06/12] Deference penv in init_current_vm --- src/JNI.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/JNI.jl b/src/JNI.jl index 5330ac2..0596a1a 100644 --- a/src/JNI.jl +++ b/src/JNI.jl @@ -150,7 +150,7 @@ function init_current_vm(libpath) jvm = unsafe_load(pjvm[]) global jvmfunc[] = unsafe_load(jvm.JNIInvokeInterface_) ccall(jvmfunc[].GetEnv, Cint, (Ptr{Nothing}, Ptr{Ptr{JNIEnv}}, Cint), pjvm[], penv, JNI.JNI_VERSION_1_8) - JNI.load_jni(penv) + JNI.load_jni(penv[]) end function load_libjvm(libpath::AbstractString) From 93a21390f4b9c0eeb49e733c34684c65d3853d4b Mon Sep 17 00:00:00 2001 From: "markkitt@gmail.com" Date: Sat, 9 May 2020 22:14:44 -0500 Subject: [PATCH 07/12] Use GC preserve to retain options, clean up JNI references --- src/JNI.jl | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) diff --git a/src/JNI.jl b/src/JNI.jl index 0596a1a..809b215 100644 --- a/src/JNI.jl +++ b/src/JNI.jl @@ -127,14 +127,16 @@ function init_new_vm(libpath,opts) libjvm = load_libjvm(libpath) create = Libdl.dlsym(libjvm, :JNI_CreateJavaVM) opt = [JavaVMOption(pointer(x), C_NULL) for x in opts] - vm_args = JavaVMInitArgs(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}), pjvm, penv, - Ref(vm_args)) - res < 0 && throw(JNIError("Unable to initialise Java VM: $(res)")) + GC.@preserve opt begin + vm_args = JavaVMInitArgs(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}), pjvm, penv, + Ref(vm_args)) + res < 0 && throw(JNIError("Unable to initialise Java VM: $(res)")) + end jvm = unsafe_load(pjvm[]) - global jvmfunc[] = unsafe_load(jvm.JNIInvokeInterface_) - JNI.load_jni(penv[]) + jvmfunc[] = unsafe_load(jvm.JNIInvokeInterface_) + load_jni(penv[]) return end @@ -150,7 +152,7 @@ function init_current_vm(libpath) jvm = unsafe_load(pjvm[]) global jvmfunc[] = unsafe_load(jvm.JNIInvokeInterface_) ccall(jvmfunc[].GetEnv, Cint, (Ptr{Nothing}, Ptr{Ptr{JNIEnv}}, Cint), pjvm[], penv, JNI.JNI_VERSION_1_8) - JNI.load_jni(penv[]) + load_jni(penv[]) end function load_libjvm(libpath::AbstractString) From 078278ecc4515107ded3e4e833b5f4ae64b96b76 Mon Sep 17 00:00:00 2001 From: "markkitt@gmail.com" Date: Sat, 9 May 2020 22:58:17 -0500 Subject: [PATCH 08/12] Making jnienv global helps x86 init --- src/JNI.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/JNI.jl b/src/JNI.jl index 809b215..df7a11d 100644 --- a/src/JNI.jl +++ b/src/JNI.jl @@ -110,7 +110,7 @@ struct JavaVMInitArgs end function load_jni(penv::Ptr{JNIEnv}) - jnienv = unsafe_load(penv) + global jnienv = unsafe_load(penv) jniref[] = unsafe_load(jnienv.JNINativeInterface_) #The JNI Function table global jnifunc = jniref[] end From f9d602fcd9f0ec989bac075771fc3d55d71e592e Mon Sep 17 00:00:00 2001 From: "markkitt@gmail.com" Date: Tue, 12 May 2020 01:32:32 -0500 Subject: [PATCH 09/12] Change Ref names to ppenv and ppjvm to reflect their pointer to pointer nature --- src/JNI.jl | 362 ++++++++++++++++++++++++++--------------------------- 1 file changed, 181 insertions(+), 181 deletions(-) diff --git a/src/JNI.jl b/src/JNI.jl index df7a11d..fdd922c 100644 --- a/src/JNI.jl +++ b/src/JNI.jl @@ -21,8 +21,8 @@ include("jnienv.jl") const jniref = Ref(JNINativeInterface()) global jnifunc -const penv = Ref(Ptr{JNIEnv}(C_NULL)) -const pjvm = Ref(Ptr{JavaVM}(C_NULL)) +const ppenv = Ref(Ptr{JNIEnv}(C_NULL)) +const ppjvm = Ref(Ptr{JavaVM}(C_NULL)) const jvmfunc = Ref{JNIInvokeInterface}() # jni_md.h @@ -115,7 +115,7 @@ function load_jni(penv::Ptr{JNIEnv}) global jnifunc = jniref[] end is_jni_loaded() = jniref[].GetVersion != C_NULL -is_env_loaded() = penv[] != C_NULL +is_env_loaded() = ppenv[] != C_NULL """ @@ -130,13 +130,13 @@ function init_new_vm(libpath,opts) GC.@preserve opt begin vm_args = JavaVMInitArgs(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}), pjvm, penv, + res = ccall(create, Cint, (Ptr{Ptr{JavaVM}}, Ptr{Ptr{JNIEnv}}, Ptr{JavaVMInitArgs}), ppjvm, ppenv, Ref(vm_args)) res < 0 && throw(JNIError("Unable to initialise Java VM: $(res)")) end - jvm = unsafe_load(pjvm[]) + jvm = unsafe_load(ppjvm[]) jvmfunc[] = unsafe_load(jvm.JNIInvokeInterface_) - load_jni(penv[]) + load_jni(ppenv[]) return end @@ -148,11 +148,11 @@ Allow initialization from running VM. Uses the first VM it finds. function init_current_vm(libpath) libjvm = load_libjvm(libpath) pnum = Array{Cint}(undef, 1) - ccall(Libdl.dlsym(libjvm, :JNI_GetCreatedJavaVMs), Cint, (Ptr{Ptr{JavaVM}}, Cint, Ptr{Cint}), pjvm, 1, pnum) - jvm = unsafe_load(pjvm[]) + ccall(Libdl.dlsym(libjvm, :JNI_GetCreatedJavaVMs), Cint, (Ptr{Ptr{JavaVM}}, Cint, Ptr{Cint}), ppjvm, 1, pnum) + jvm = unsafe_load(ppjvm[]) global jvmfunc[] = unsafe_load(jvm.JNIInvokeInterface_) - ccall(jvmfunc[].GetEnv, Cint, (Ptr{Nothing}, Ptr{Ptr{JNIEnv}}, Cint), pjvm[], penv, JNI.JNI_VERSION_1_8) - load_jni(penv[]) + ccall(jvmfunc[].GetEnv, Cint, (Ptr{Nothing}, Ptr{Ptr{JNIEnv}}, Cint), ppjvm[], ppenv, JNI.JNI_VERSION_1_8) + load_jni(ppenv[]) end function load_libjvm(libpath::AbstractString) @@ -170,10 +170,10 @@ function destroy() if !is_env_loaded() throw(JNIError("Called destroy without initialising Java VM")) end - res = ccall(jvmfunc[].DestroyJavaVM, Cint, (Ptr{Nothing},), pjvm[]) + res = ccall(jvmfunc[].DestroyJavaVM, Cint, (Ptr{Nothing},), ppjvm[]) res < 0 && throw(JavaCallError("Unable to destroy Java VM")) - penv[] = C_NULL - pjvm[] = C_NULL + ppenv[] = C_NULL + ppjvm[] = C_NULL nothing end @@ -181,508 +181,508 @@ end # === Below Generated by make_jni2.jl === GetVersion() = - ccall(jniref[].GetVersion, jint, (Ptr{JNIEnv},), penv[]) + ccall(jniref[].GetVersion, jint, (Ptr{JNIEnv},), ppenv[]) DefineClass(name::AnyString, loader::jobject, buf::Array{jbyte,1}, len::Integer) = - ccall(jniref[].DefineClass, jclass, (Ptr{JNIEnv}, Cstring, jobject, Ptr{jbyte}, jsize,), penv[], name, loader, buf, len) + ccall(jniref[].DefineClass, jclass, (Ptr{JNIEnv}, Cstring, jobject, Ptr{jbyte}, jsize,), ppenv[], name, loader, buf, len) FindClass(name::AnyString) = - ccall(jniref[].FindClass, jclass, (Ptr{JNIEnv}, Cstring,), penv[], name) + ccall(jniref[].FindClass, jclass, (Ptr{JNIEnv}, Cstring,), ppenv[], name) FromReflectedMethod(method::jobject) = - ccall(jniref[].FromReflectedMethod, jmethodID, (Ptr{JNIEnv}, jobject,), penv[], method) + ccall(jniref[].FromReflectedMethod, jmethodID, (Ptr{JNIEnv}, jobject,), ppenv[], method) FromReflectedField(field::jobject) = - ccall(jniref[].FromReflectedField, jfieldID, (Ptr{JNIEnv}, jobject,), penv[], field) + ccall(jniref[].FromReflectedField, jfieldID, (Ptr{JNIEnv}, jobject,), ppenv[], field) ToReflectedMethod(cls::jclass, methodID::jmethodID, isStatic::jboolean) = - ccall(jniref[].ToReflectedMethod, jobject, (Ptr{JNIEnv}, jclass, jmethodID, jboolean,), penv[], cls, methodID, isStatic) + ccall(jniref[].ToReflectedMethod, jobject, (Ptr{JNIEnv}, jclass, jmethodID, jboolean,), ppenv[], cls, methodID, isStatic) GetSuperclass(sub::jclass) = - ccall(jniref[].GetSuperclass, jclass, (Ptr{JNIEnv}, jclass,), penv[], sub) + ccall(jniref[].GetSuperclass, jclass, (Ptr{JNIEnv}, jclass,), ppenv[], sub) IsAssignableFrom(sub::jclass, sup::jclass) = - ccall(jniref[].IsAssignableFrom, jboolean, (Ptr{JNIEnv}, jclass, jclass,), penv[], sub, sup) + ccall(jniref[].IsAssignableFrom, jboolean, (Ptr{JNIEnv}, jclass, jclass,), ppenv[], sub, sup) ToReflectedField(cls::jclass, fieldID::jfieldID, isStatic::jboolean) = - ccall(jniref[].ToReflectedField, jobject, (Ptr{JNIEnv}, jclass, jfieldID, jboolean,), penv[], cls, fieldID, isStatic) + ccall(jniref[].ToReflectedField, jobject, (Ptr{JNIEnv}, jclass, jfieldID, jboolean,), ppenv[], cls, fieldID, isStatic) Throw(obj::jthrowable) = - ccall(jniref[].Throw, jint, (Ptr{JNIEnv}, jthrowable,), penv[], obj) + ccall(jniref[].Throw, jint, (Ptr{JNIEnv}, jthrowable,), ppenv[], obj) ThrowNew(clazz::jclass, msg::AnyString) = - ccall(jniref[].ThrowNew, jint, (Ptr{JNIEnv}, jclass, Cstring,), penv[], clazz, msg) + ccall(jniref[].ThrowNew, jint, (Ptr{JNIEnv}, jclass, Cstring,), ppenv[], clazz, msg) ExceptionOccurred() = - ccall(jniref[].ExceptionOccurred, jthrowable, (Ptr{JNIEnv},), penv[]) + ccall(jniref[].ExceptionOccurred, jthrowable, (Ptr{JNIEnv},), ppenv[]) ExceptionDescribe() = - ccall(jniref[].ExceptionDescribe, Nothing, (Ptr{JNIEnv},), penv[]) + ccall(jniref[].ExceptionDescribe, Nothing, (Ptr{JNIEnv},), ppenv[]) ExceptionClear() = - ccall(jniref[].ExceptionClear, Nothing, (Ptr{JNIEnv},), penv[]) + ccall(jniref[].ExceptionClear, Nothing, (Ptr{JNIEnv},), ppenv[]) FatalError(msg::AnyString) = - ccall(jniref[].FatalError, Nothing, (Ptr{JNIEnv}, Cstring,), penv[], msg) + ccall(jniref[].FatalError, Nothing, (Ptr{JNIEnv}, Cstring,), ppenv[], msg) PushLocalFrame(capacity::jint) = - ccall(jniref[].PushLocalFrame, jint, (Ptr{JNIEnv}, jint,), penv[], capacity) + ccall(jniref[].PushLocalFrame, jint, (Ptr{JNIEnv}, jint,), ppenv[], capacity) PopLocalFrame(result::jobject) = - ccall(jniref[].PopLocalFrame, jobject, (Ptr{JNIEnv}, jobject,), penv[], result) + ccall(jniref[].PopLocalFrame, jobject, (Ptr{JNIEnv}, jobject,), ppenv[], result) NewGlobalRef(lobj::jobject) = - ccall(jniref[].NewGlobalRef, jobject, (Ptr{JNIEnv}, jobject,), penv[], lobj) + ccall(jniref[].NewGlobalRef, jobject, (Ptr{JNIEnv}, jobject,), ppenv[], lobj) DeleteGlobalRef(gref::jobject) = - ccall(jniref[].DeleteGlobalRef, Nothing, (Ptr{JNIEnv}, jobject,), penv[], gref) + ccall(jniref[].DeleteGlobalRef, Nothing, (Ptr{JNIEnv}, jobject,), ppenv[], gref) DeleteLocalRef(obj::jobject) = - ccall(jniref[].DeleteLocalRef, Nothing, (Ptr{JNIEnv}, jobject,), penv[], obj) + ccall(jniref[].DeleteLocalRef, Nothing, (Ptr{JNIEnv}, jobject,), ppenv[], obj) IsSameObject(obj1::jobject, obj2::jobject) = - ccall(jniref[].IsSameObject, jboolean, (Ptr{JNIEnv}, jobject, jobject,), penv[], obj1, obj2) + ccall(jniref[].IsSameObject, jboolean, (Ptr{JNIEnv}, jobject, jobject,), ppenv[], obj1, obj2) NewLocalRef(ref::jobject) = - ccall(jniref[].NewLocalRef, jobject, (Ptr{JNIEnv}, jobject,), penv[], ref) + ccall(jniref[].NewLocalRef, jobject, (Ptr{JNIEnv}, jobject,), ppenv[], ref) EnsureLocalCapacity(capacity::jint) = - ccall(jniref[].EnsureLocalCapacity, jint, (Ptr{JNIEnv}, jint,), penv[], capacity) + ccall(jniref[].EnsureLocalCapacity, jint, (Ptr{JNIEnv}, jint,), ppenv[], capacity) AllocObject(clazz::jclass) = - ccall(jniref[].AllocObject, jobject, (Ptr{JNIEnv}, jclass,), penv[], clazz) + ccall(jniref[].AllocObject, jobject, (Ptr{JNIEnv}, jclass,), ppenv[], clazz) NewObjectA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].NewObjectA, jobject, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), penv[], clazz, methodID, args) + ccall(jniref[].NewObjectA, jobject, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), ppenv[], clazz, methodID, args) GetObjectClass(obj::jobject) = - ccall(jniref[].GetObjectClass, jclass, (Ptr{JNIEnv}, jobject,), penv[], obj) + ccall(jniref[].GetObjectClass, jclass, (Ptr{JNIEnv}, jobject,), ppenv[], obj) IsInstanceOf(obj::jobject, clazz::jclass) = - ccall(jniref[].IsInstanceOf, jboolean, (Ptr{JNIEnv}, jobject, jclass,), penv[], obj, clazz) + ccall(jniref[].IsInstanceOf, jboolean, (Ptr{JNIEnv}, jobject, jclass,), ppenv[], obj, clazz) GetMethodID(clazz::jclass, name::AnyString, sig::AnyString) = - ccall(jniref[].GetMethodID, jmethodID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), penv[], clazz, name, sig) + ccall(jniref[].GetMethodID, jmethodID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), ppenv[], clazz, name, sig) CallObjectMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallObjectMethodA, jobject, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), penv[], obj, methodID, args) + ccall(jniref[].CallObjectMethodA, jobject, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), ppenv[], obj, methodID, args) CallBooleanMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallBooleanMethodA, jboolean, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), penv[], obj, methodID, args) + ccall(jniref[].CallBooleanMethodA, jboolean, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), ppenv[], obj, methodID, args) CallByteMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallByteMethodA, jbyte, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), penv[], obj, methodID, args) + ccall(jniref[].CallByteMethodA, jbyte, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), ppenv[], obj, methodID, args) CallCharMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallCharMethodA, jchar, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), penv[], obj, methodID, args) + ccall(jniref[].CallCharMethodA, jchar, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), ppenv[], obj, methodID, args) CallShortMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallShortMethodA, jshort, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), penv[], obj, methodID, args) + ccall(jniref[].CallShortMethodA, jshort, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), ppenv[], obj, methodID, args) CallIntMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallIntMethodA, jint, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), penv[], obj, methodID, args) + ccall(jniref[].CallIntMethodA, jint, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), ppenv[], obj, methodID, args) CallLongMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallLongMethodA, jlong, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), penv[], obj, methodID, args) + ccall(jniref[].CallLongMethodA, jlong, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), ppenv[], obj, methodID, args) CallFloatMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallFloatMethodA, jfloat, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), penv[], obj, methodID, args) + ccall(jniref[].CallFloatMethodA, jfloat, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), ppenv[], obj, methodID, args) CallDoubleMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallDoubleMethodA, jdouble, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), penv[], obj, methodID, args) + ccall(jniref[].CallDoubleMethodA, jdouble, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), ppenv[], obj, methodID, args) CallVoidMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallVoidMethodA, Nothing, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), penv[], obj, methodID, args) + ccall(jniref[].CallVoidMethodA, Nothing, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), ppenv[], obj, methodID, args) CallNonvirtualObjectMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallNonvirtualObjectMethodA, jobject, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), penv[], obj, clazz, methodID, args) + ccall(jniref[].CallNonvirtualObjectMethodA, jobject, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), ppenv[], obj, clazz, methodID, args) CallNonvirtualBooleanMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallNonvirtualBooleanMethodA, jboolean, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), penv[], obj, clazz, methodID, args) + ccall(jniref[].CallNonvirtualBooleanMethodA, jboolean, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), ppenv[], obj, clazz, methodID, args) CallNonvirtualByteMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallNonvirtualByteMethodA, jbyte, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), penv[], obj, clazz, methodID, args) + ccall(jniref[].CallNonvirtualByteMethodA, jbyte, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), ppenv[], obj, clazz, methodID, args) CallNonvirtualCharMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallNonvirtualCharMethodA, jchar, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), penv[], obj, clazz, methodID, args) + ccall(jniref[].CallNonvirtualCharMethodA, jchar, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), ppenv[], obj, clazz, methodID, args) CallNonvirtualShortMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallNonvirtualShortMethodA, jshort, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), penv[], obj, clazz, methodID, args) + ccall(jniref[].CallNonvirtualShortMethodA, jshort, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), ppenv[], obj, clazz, methodID, args) CallNonvirtualIntMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallNonvirtualIntMethodA, jint, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), penv[], obj, clazz, methodID, args) + ccall(jniref[].CallNonvirtualIntMethodA, jint, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), ppenv[], obj, clazz, methodID, args) CallNonvirtualLongMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallNonvirtualLongMethodA, jlong, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), penv[], obj, clazz, methodID, args) + ccall(jniref[].CallNonvirtualLongMethodA, jlong, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), ppenv[], obj, clazz, methodID, args) CallNonvirtualFloatMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallNonvirtualFloatMethodA, jfloat, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), penv[], obj, clazz, methodID, args) + ccall(jniref[].CallNonvirtualFloatMethodA, jfloat, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), ppenv[], obj, clazz, methodID, args) CallNonvirtualDoubleMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallNonvirtualDoubleMethodA, jdouble, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), penv[], obj, clazz, methodID, args) + ccall(jniref[].CallNonvirtualDoubleMethodA, jdouble, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), ppenv[], obj, clazz, methodID, args) CallNonvirtualVoidMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallNonvirtualVoidMethodA, Nothing, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), penv[], obj, clazz, methodID, args) + ccall(jniref[].CallNonvirtualVoidMethodA, Nothing, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), ppenv[], obj, clazz, methodID, args) GetFieldID(clazz::jclass, name::AnyString, sig::AnyString) = - ccall(jniref[].GetFieldID, jfieldID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), penv[], clazz, name, sig) + ccall(jniref[].GetFieldID, jfieldID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), ppenv[], clazz, name, sig) GetObjectField(obj::jobject, fieldID::jfieldID) = - ccall(jniref[].GetObjectField, jobject, (Ptr{JNIEnv}, jobject, jfieldID,), penv[], obj, fieldID) + ccall(jniref[].GetObjectField, jobject, (Ptr{JNIEnv}, jobject, jfieldID,), ppenv[], obj, fieldID) GetBooleanField(obj::jobject, fieldID::jfieldID) = - ccall(jniref[].GetBooleanField, jboolean, (Ptr{JNIEnv}, jobject, jfieldID,), penv[], obj, fieldID) + ccall(jniref[].GetBooleanField, jboolean, (Ptr{JNIEnv}, jobject, jfieldID,), ppenv[], obj, fieldID) GetByteField(obj::jobject, fieldID::jfieldID) = - ccall(jniref[].GetByteField, jbyte, (Ptr{JNIEnv}, jobject, jfieldID,), penv[], obj, fieldID) + ccall(jniref[].GetByteField, jbyte, (Ptr{JNIEnv}, jobject, jfieldID,), ppenv[], obj, fieldID) GetCharField(obj::jobject, fieldID::jfieldID) = - ccall(jniref[].GetCharField, jchar, (Ptr{JNIEnv}, jobject, jfieldID,), penv[], obj, fieldID) + ccall(jniref[].GetCharField, jchar, (Ptr{JNIEnv}, jobject, jfieldID,), ppenv[], obj, fieldID) GetShortField(obj::jobject, fieldID::jfieldID) = - ccall(jniref[].GetShortField, jshort, (Ptr{JNIEnv}, jobject, jfieldID,), penv[], obj, fieldID) + ccall(jniref[].GetShortField, jshort, (Ptr{JNIEnv}, jobject, jfieldID,), ppenv[], obj, fieldID) GetIntField(obj::jobject, fieldID::jfieldID) = - ccall(jniref[].GetIntField, jint, (Ptr{JNIEnv}, jobject, jfieldID,), penv[], obj, fieldID) + ccall(jniref[].GetIntField, jint, (Ptr{JNIEnv}, jobject, jfieldID,), ppenv[], obj, fieldID) GetLongField(obj::jobject, fieldID::jfieldID) = - ccall(jniref[].GetLongField, jlong, (Ptr{JNIEnv}, jobject, jfieldID,), penv[], obj, fieldID) + ccall(jniref[].GetLongField, jlong, (Ptr{JNIEnv}, jobject, jfieldID,), ppenv[], obj, fieldID) GetFloatField(obj::jobject, fieldID::jfieldID) = - ccall(jniref[].GetFloatField, jfloat, (Ptr{JNIEnv}, jobject, jfieldID,), penv[], obj, fieldID) + ccall(jniref[].GetFloatField, jfloat, (Ptr{JNIEnv}, jobject, jfieldID,), ppenv[], obj, fieldID) GetDoubleField(obj::jobject, fieldID::jfieldID) = - ccall(jniref[].GetDoubleField, jdouble, (Ptr{JNIEnv}, jobject, jfieldID,), penv[], obj, fieldID) + ccall(jniref[].GetDoubleField, jdouble, (Ptr{JNIEnv}, jobject, jfieldID,), ppenv[], obj, fieldID) SetObjectField(obj::jobject, fieldID::jfieldID, val::jobject) = - ccall(jniref[].SetObjectField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jobject,), penv[], obj, fieldID, val) + ccall(jniref[].SetObjectField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jobject,), ppenv[], obj, fieldID, val) SetBooleanField(obj::jobject, fieldID::jfieldID, val::jboolean) = - ccall(jniref[].SetBooleanField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jboolean,), penv[], obj, fieldID, val) + ccall(jniref[].SetBooleanField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jboolean,), ppenv[], obj, fieldID, val) SetByteField(obj::jobject, fieldID::jfieldID, val::jbyte) = - ccall(jniref[].SetByteField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jbyte,), penv[], obj, fieldID, val) + ccall(jniref[].SetByteField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jbyte,), ppenv[], obj, fieldID, val) SetCharField(obj::jobject, fieldID::jfieldID, val::jchar) = - ccall(jniref[].SetCharField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jchar,), penv[], obj, fieldID, val) + ccall(jniref[].SetCharField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jchar,), ppenv[], obj, fieldID, val) SetShortField(obj::jobject, fieldID::jfieldID, val::jshort) = - ccall(jniref[].SetShortField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jshort,), penv[], obj, fieldID, val) + ccall(jniref[].SetShortField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jshort,), ppenv[], obj, fieldID, val) SetIntField(obj::jobject, fieldID::jfieldID, val::jint) = - ccall(jniref[].SetIntField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jint,), penv[], obj, fieldID, val) + ccall(jniref[].SetIntField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jint,), ppenv[], obj, fieldID, val) SetLongField(obj::jobject, fieldID::jfieldID, val::jlong) = - ccall(jniref[].SetLongField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jlong,), penv[], obj, fieldID, val) + ccall(jniref[].SetLongField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jlong,), ppenv[], obj, fieldID, val) SetFloatField(obj::jobject, fieldID::jfieldID, val::jfloat) = - ccall(jniref[].SetFloatField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jfloat,), penv[], obj, fieldID, val) + ccall(jniref[].SetFloatField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jfloat,), ppenv[], obj, fieldID, val) SetDoubleField(obj::jobject, fieldID::jfieldID, val::jdouble) = - ccall(jniref[].SetDoubleField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jdouble,), penv[], obj, fieldID, val) + ccall(jniref[].SetDoubleField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jdouble,), ppenv[], obj, fieldID, val) GetStaticMethodID(clazz::jclass, name::AnyString, sig::AnyString) = - ccall(jniref[].GetStaticMethodID, jmethodID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), penv[], clazz, name, sig) + ccall(jniref[].GetStaticMethodID, jmethodID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), ppenv[], clazz, name, sig) CallStaticObjectMethodA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallStaticObjectMethodA, jobject, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), penv[], clazz, methodID, args) + ccall(jniref[].CallStaticObjectMethodA, jobject, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), ppenv[], clazz, methodID, args) CallStaticBooleanMethodA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallStaticBooleanMethodA, jboolean, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), penv[], clazz, methodID, args) + ccall(jniref[].CallStaticBooleanMethodA, jboolean, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), ppenv[], clazz, methodID, args) CallStaticByteMethodA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallStaticByteMethodA, jbyte, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), penv[], clazz, methodID, args) + ccall(jniref[].CallStaticByteMethodA, jbyte, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), ppenv[], clazz, methodID, args) CallStaticCharMethodA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallStaticCharMethodA, jchar, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), penv[], clazz, methodID, args) + ccall(jniref[].CallStaticCharMethodA, jchar, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), ppenv[], clazz, methodID, args) CallStaticShortMethodA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallStaticShortMethodA, jshort, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), penv[], clazz, methodID, args) + ccall(jniref[].CallStaticShortMethodA, jshort, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), ppenv[], clazz, methodID, args) CallStaticIntMethodA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallStaticIntMethodA, jint, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), penv[], clazz, methodID, args) + ccall(jniref[].CallStaticIntMethodA, jint, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), ppenv[], clazz, methodID, args) CallStaticLongMethodA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallStaticLongMethodA, jlong, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), penv[], clazz, methodID, args) + ccall(jniref[].CallStaticLongMethodA, jlong, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), ppenv[], clazz, methodID, args) CallStaticFloatMethodA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallStaticFloatMethodA, jfloat, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), penv[], clazz, methodID, args) + ccall(jniref[].CallStaticFloatMethodA, jfloat, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), ppenv[], clazz, methodID, args) CallStaticDoubleMethodA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallStaticDoubleMethodA, jdouble, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), penv[], clazz, methodID, args) + ccall(jniref[].CallStaticDoubleMethodA, jdouble, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), ppenv[], clazz, methodID, args) CallStaticVoidMethodA(cls::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallStaticVoidMethodA, Nothing, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), penv[], cls, methodID, args) + ccall(jniref[].CallStaticVoidMethodA, Nothing, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), ppenv[], cls, methodID, args) GetStaticFieldID(clazz::jclass, name::AnyString, sig::AnyString) = - ccall(jniref[].GetStaticFieldID, jfieldID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), penv[], clazz, name, sig) + ccall(jniref[].GetStaticFieldID, jfieldID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), ppenv[], clazz, name, sig) GetStaticObjectField(clazz::jclass, fieldID::jfieldID) = - ccall(jniref[].GetStaticObjectField, jobject, (Ptr{JNIEnv}, jclass, jfieldID,), penv[], clazz, fieldID) + ccall(jniref[].GetStaticObjectField, jobject, (Ptr{JNIEnv}, jclass, jfieldID,), ppenv[], clazz, fieldID) GetStaticBooleanField(clazz::jclass, fieldID::jfieldID) = - ccall(jniref[].GetStaticBooleanField, jboolean, (Ptr{JNIEnv}, jclass, jfieldID,), penv[], clazz, fieldID) + ccall(jniref[].GetStaticBooleanField, jboolean, (Ptr{JNIEnv}, jclass, jfieldID,), ppenv[], clazz, fieldID) GetStaticByteField(clazz::jclass, fieldID::jfieldID) = - ccall(jniref[].GetStaticByteField, jbyte, (Ptr{JNIEnv}, jclass, jfieldID,), penv[], clazz, fieldID) + ccall(jniref[].GetStaticByteField, jbyte, (Ptr{JNIEnv}, jclass, jfieldID,), ppenv[], clazz, fieldID) GetStaticCharField(clazz::jclass, fieldID::jfieldID) = - ccall(jniref[].GetStaticCharField, jchar, (Ptr{JNIEnv}, jclass, jfieldID,), penv[], clazz, fieldID) + ccall(jniref[].GetStaticCharField, jchar, (Ptr{JNIEnv}, jclass, jfieldID,), ppenv[], clazz, fieldID) GetStaticShortField(clazz::jclass, fieldID::jfieldID) = - ccall(jniref[].GetStaticShortField, jshort, (Ptr{JNIEnv}, jclass, jfieldID,), penv[], clazz, fieldID) + ccall(jniref[].GetStaticShortField, jshort, (Ptr{JNIEnv}, jclass, jfieldID,), ppenv[], clazz, fieldID) GetStaticIntField(clazz::jclass, fieldID::jfieldID) = - ccall(jniref[].GetStaticIntField, jint, (Ptr{JNIEnv}, jclass, jfieldID,), penv[], clazz, fieldID) + ccall(jniref[].GetStaticIntField, jint, (Ptr{JNIEnv}, jclass, jfieldID,), ppenv[], clazz, fieldID) GetStaticLongField(clazz::jclass, fieldID::jfieldID) = - ccall(jniref[].GetStaticLongField, jlong, (Ptr{JNIEnv}, jclass, jfieldID,), penv[], clazz, fieldID) + ccall(jniref[].GetStaticLongField, jlong, (Ptr{JNIEnv}, jclass, jfieldID,), ppenv[], clazz, fieldID) GetStaticFloatField(clazz::jclass, fieldID::jfieldID) = - ccall(jniref[].GetStaticFloatField, jfloat, (Ptr{JNIEnv}, jclass, jfieldID,), penv[], clazz, fieldID) + ccall(jniref[].GetStaticFloatField, jfloat, (Ptr{JNIEnv}, jclass, jfieldID,), ppenv[], clazz, fieldID) GetStaticDoubleField(clazz::jclass, fieldID::jfieldID) = - ccall(jniref[].GetStaticDoubleField, jdouble, (Ptr{JNIEnv}, jclass, jfieldID,), penv[], clazz, fieldID) + ccall(jniref[].GetStaticDoubleField, jdouble, (Ptr{JNIEnv}, jclass, jfieldID,), ppenv[], clazz, fieldID) SetStaticObjectField(clazz::jclass, fieldID::jfieldID, value::jobject) = - ccall(jniref[].SetStaticObjectField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jobject,), penv[], clazz, fieldID, value) + ccall(jniref[].SetStaticObjectField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jobject,), ppenv[], clazz, fieldID, value) SetStaticBooleanField(clazz::jclass, fieldID::jfieldID, value::jboolean) = - ccall(jniref[].SetStaticBooleanField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jboolean,), penv[], clazz, fieldID, value) + ccall(jniref[].SetStaticBooleanField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jboolean,), ppenv[], clazz, fieldID, value) SetStaticByteField(clazz::jclass, fieldID::jfieldID, value::jbyte) = - ccall(jniref[].SetStaticByteField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jbyte,), penv[], clazz, fieldID, value) + ccall(jniref[].SetStaticByteField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jbyte,), ppenv[], clazz, fieldID, value) SetStaticCharField(clazz::jclass, fieldID::jfieldID, value::jchar) = - ccall(jniref[].SetStaticCharField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jchar,), penv[], clazz, fieldID, value) + ccall(jniref[].SetStaticCharField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jchar,), ppenv[], clazz, fieldID, value) SetStaticShortField(clazz::jclass, fieldID::jfieldID, value::jshort) = - ccall(jniref[].SetStaticShortField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jshort,), penv[], clazz, fieldID, value) + ccall(jniref[].SetStaticShortField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jshort,), ppenv[], clazz, fieldID, value) SetStaticIntField(clazz::jclass, fieldID::jfieldID, value::jint) = - ccall(jniref[].SetStaticIntField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jint,), penv[], clazz, fieldID, value) + ccall(jniref[].SetStaticIntField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jint,), ppenv[], clazz, fieldID, value) SetStaticLongField(clazz::jclass, fieldID::jfieldID, value::jlong) = - ccall(jniref[].SetStaticLongField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jlong,), penv[], clazz, fieldID, value) + ccall(jniref[].SetStaticLongField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jlong,), ppenv[], clazz, fieldID, value) SetStaticFloatField(clazz::jclass, fieldID::jfieldID, value::jfloat) = - ccall(jniref[].SetStaticFloatField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jfloat,), penv[], clazz, fieldID, value) + ccall(jniref[].SetStaticFloatField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jfloat,), ppenv[], clazz, fieldID, value) SetStaticDoubleField(clazz::jclass, fieldID::jfieldID, value::jdouble) = - ccall(jniref[].SetStaticDoubleField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jdouble,), penv[], clazz, fieldID, value) + ccall(jniref[].SetStaticDoubleField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jdouble,), ppenv[], clazz, fieldID, value) NewString(unicode::Array{jchar,1}, len::Integer) = - ccall(jniref[].NewString, jstring, (Ptr{JNIEnv}, Ptr{jchar}, jsize,), penv[], unicode, len) + ccall(jniref[].NewString, jstring, (Ptr{JNIEnv}, Ptr{jchar}, jsize,), ppenv[], unicode, len) GetStringLength(str::jstring) = - ccall(jniref[].GetStringLength, jsize, (Ptr{JNIEnv}, jstring,), penv[], str) + ccall(jniref[].GetStringLength, jsize, (Ptr{JNIEnv}, jstring,), ppenv[], str) GetStringChars(str::jstring, isCopy::PtrIsCopy) = - ccall(jniref[].GetStringChars, Ptr{jchar}, (Ptr{JNIEnv}, jstring, Ptr{jboolean},), penv[], str, isCopy) + ccall(jniref[].GetStringChars, Ptr{jchar}, (Ptr{JNIEnv}, jstring, Ptr{jboolean},), ppenv[], str, isCopy) ReleaseStringChars(str::jstring, chars::Array{jchar,1}) = - ccall(jniref[].ReleaseStringChars, Nothing, (Ptr{JNIEnv}, jstring, Ptr{jchar},), penv[], str, chars) + ccall(jniref[].ReleaseStringChars, Nothing, (Ptr{JNIEnv}, jstring, Ptr{jchar},), ppenv[], str, chars) NewStringUTF(utf::AnyString) = - ccall(jniref[].NewStringUTF, jstring, (Ptr{JNIEnv}, Cstring,), penv[], utf) + ccall(jniref[].NewStringUTF, jstring, (Ptr{JNIEnv}, Cstring,), ppenv[], utf) GetStringUTFLength(str::jstring) = - ccall(jniref[].GetStringUTFLength, jsize, (Ptr{JNIEnv}, jstring,), penv[], str) + ccall(jniref[].GetStringUTFLength, jsize, (Ptr{JNIEnv}, jstring,), ppenv[], str) GetStringUTFChars(str::jstring, isCopy::PtrIsCopy) = - ccall(jniref[].GetStringUTFChars, Cstring, (Ptr{JNIEnv}, jstring, Ptr{jboolean},), penv[], str, isCopy) + ccall(jniref[].GetStringUTFChars, Cstring, (Ptr{JNIEnv}, jstring, Ptr{jboolean},), ppenv[], str, isCopy) ## Prior to this module we used UInt8 instead of Cstring, must match return value of above #ReleaseStringUTFChars(str::jstring, chars::Ptr{UInt8}) = -# ccall(jniref[].ReleaseStringUTFChars, Nothing, (Ptr{JNIEnv}, jstring, Ptr{UInt8},), penv[], str, chars) +# ccall(jniref[].ReleaseStringUTFChars, Nothing, (Ptr{JNIEnv}, jstring, Ptr{UInt8},), ppenv[], str, chars) ReleaseStringUTFChars(str::jstring, chars::AnyString) = - ccall(jniref[].ReleaseStringUTFChars, Nothing, (Ptr{JNIEnv}, jstring, Cstring,), penv[], str, chars) + ccall(jniref[].ReleaseStringUTFChars, Nothing, (Ptr{JNIEnv}, jstring, Cstring,), ppenv[], str, chars) GetArrayLength(array::jarray) = - ccall(jniref[].GetArrayLength, jsize, (Ptr{JNIEnv}, jarray,), penv[], array) + ccall(jniref[].GetArrayLength, jsize, (Ptr{JNIEnv}, jarray,), ppenv[], array) NewObjectArray(len::Integer, clazz::jclass, init::jobject) = - ccall(jniref[].NewObjectArray, jobjectArray, (Ptr{JNIEnv}, jsize, jclass, jobject,), penv[], len, clazz, init) + ccall(jniref[].NewObjectArray, jobjectArray, (Ptr{JNIEnv}, jsize, jclass, jobject,), ppenv[], len, clazz, init) GetObjectArrayElement(array::jobjectArray, index::Integer) = - ccall(jniref[].GetObjectArrayElement, jobject, (Ptr{JNIEnv}, jobjectArray, jsize,), penv[], array, index) + ccall(jniref[].GetObjectArrayElement, jobject, (Ptr{JNIEnv}, jobjectArray, jsize,), ppenv[], array, index) SetObjectArrayElement(array::jobjectArray, index::Integer, val::jobject) = - ccall(jniref[].SetObjectArrayElement, Nothing, (Ptr{JNIEnv}, jobjectArray, jsize, jobject,), penv[], array, index, val) + ccall(jniref[].SetObjectArrayElement, Nothing, (Ptr{JNIEnv}, jobjectArray, jsize, jobject,), ppenv[], array, index, val) NewBooleanArray(len::Integer) = - ccall(jniref[].NewBooleanArray, jbooleanArray, (Ptr{JNIEnv}, jsize,), penv[], len) + ccall(jniref[].NewBooleanArray, jbooleanArray, (Ptr{JNIEnv}, jsize,), ppenv[], len) NewByteArray(len::Integer) = - ccall(jniref[].NewByteArray, jbyteArray, (Ptr{JNIEnv}, jsize,), penv[], len) + ccall(jniref[].NewByteArray, jbyteArray, (Ptr{JNIEnv}, jsize,), ppenv[], len) NewCharArray(len::Integer) = - ccall(jniref[].NewCharArray, jcharArray, (Ptr{JNIEnv}, jsize,), penv[], len) + ccall(jniref[].NewCharArray, jcharArray, (Ptr{JNIEnv}, jsize,), ppenv[], len) NewShortArray(len::Integer) = - ccall(jniref[].NewShortArray, jshortArray, (Ptr{JNIEnv}, jsize,), penv[], len) + ccall(jniref[].NewShortArray, jshortArray, (Ptr{JNIEnv}, jsize,), ppenv[], len) NewIntArray(len::Integer) = - ccall(jniref[].NewIntArray, jintArray, (Ptr{JNIEnv}, jsize,), penv[], len) + ccall(jniref[].NewIntArray, jintArray, (Ptr{JNIEnv}, jsize,), ppenv[], len) NewLongArray(len::Integer) = - ccall(jniref[].NewLongArray, jlongArray, (Ptr{JNIEnv}, jsize,), penv[], len) + ccall(jniref[].NewLongArray, jlongArray, (Ptr{JNIEnv}, jsize,), ppenv[], len) NewFloatArray(len::Integer) = - ccall(jniref[].NewFloatArray, jfloatArray, (Ptr{JNIEnv}, jsize,), penv[], len) + ccall(jniref[].NewFloatArray, jfloatArray, (Ptr{JNIEnv}, jsize,), ppenv[], len) NewDoubleArray(len::Integer) = - ccall(jniref[].NewDoubleArray, jdoubleArray, (Ptr{JNIEnv}, jsize,), penv[], len) + ccall(jniref[].NewDoubleArray, jdoubleArray, (Ptr{JNIEnv}, jsize,), ppenv[], len) GetBooleanArrayElements(array::jbooleanArray, isCopy::PtrIsCopy) = - ccall(jniref[].GetBooleanArrayElements, Ptr{jboolean}, (Ptr{JNIEnv}, jbooleanArray, Ptr{jboolean},), penv[], array, isCopy) + ccall(jniref[].GetBooleanArrayElements, Ptr{jboolean}, (Ptr{JNIEnv}, jbooleanArray, Ptr{jboolean},), ppenv[], array, isCopy) GetByteArrayElements(array::jbyteArray, isCopy::PtrIsCopy) = - ccall(jniref[].GetByteArrayElements, Ptr{jbyte}, (Ptr{JNIEnv}, jbyteArray, Ptr{jboolean},), penv[], array, isCopy) + ccall(jniref[].GetByteArrayElements, Ptr{jbyte}, (Ptr{JNIEnv}, jbyteArray, Ptr{jboolean},), ppenv[], array, isCopy) GetCharArrayElements(array::jcharArray, isCopy::PtrIsCopy) = - ccall(jniref[].GetCharArrayElements, Ptr{jchar}, (Ptr{JNIEnv}, jcharArray, Ptr{jboolean},), penv[], array, isCopy) + ccall(jniref[].GetCharArrayElements, Ptr{jchar}, (Ptr{JNIEnv}, jcharArray, Ptr{jboolean},), ppenv[], array, isCopy) GetShortArrayElements(array::jshortArray, isCopy::PtrIsCopy) = - ccall(jniref[].GetShortArrayElements, Ptr{jshort}, (Ptr{JNIEnv}, jshortArray, Ptr{jboolean},), penv[], array, isCopy) + ccall(jniref[].GetShortArrayElements, Ptr{jshort}, (Ptr{JNIEnv}, jshortArray, Ptr{jboolean},), ppenv[], array, isCopy) GetIntArrayElements(array::jintArray, isCopy::PtrIsCopy) = - ccall(jniref[].GetIntArrayElements, Ptr{jint}, (Ptr{JNIEnv}, jintArray, Ptr{jboolean},), penv[], array, isCopy) + ccall(jniref[].GetIntArrayElements, Ptr{jint}, (Ptr{JNIEnv}, jintArray, Ptr{jboolean},), ppenv[], array, isCopy) GetLongArrayElements(array::jlongArray, isCopy::PtrIsCopy) = - ccall(jniref[].GetLongArrayElements, Ptr{jlong}, (Ptr{JNIEnv}, jlongArray, Ptr{jboolean},), penv[], array, isCopy) + ccall(jniref[].GetLongArrayElements, Ptr{jlong}, (Ptr{JNIEnv}, jlongArray, Ptr{jboolean},), ppenv[], array, isCopy) GetFloatArrayElements(array::jfloatArray, isCopy::PtrIsCopy) = - ccall(jniref[].GetFloatArrayElements, Ptr{jfloat}, (Ptr{JNIEnv}, jfloatArray, Ptr{jboolean},), penv[], array, isCopy) + ccall(jniref[].GetFloatArrayElements, Ptr{jfloat}, (Ptr{JNIEnv}, jfloatArray, Ptr{jboolean},), ppenv[], array, isCopy) GetDoubleArrayElements(array::jdoubleArray, isCopy::PtrIsCopy) = - ccall(jniref[].GetDoubleArrayElements, Ptr{jdouble}, (Ptr{JNIEnv}, jdoubleArray, Ptr{jboolean},), penv[], array, isCopy) + ccall(jniref[].GetDoubleArrayElements, Ptr{jdouble}, (Ptr{JNIEnv}, jdoubleArray, Ptr{jboolean},), ppenv[], array, isCopy) ReleaseBooleanArrayElements(array::jbooleanArray, elems::Ptr{jboolean}, mode::jint) = - ccall(jniref[].ReleaseBooleanArrayElements, Nothing, (Ptr{JNIEnv}, jbooleanArray, Ptr{jboolean}, jint,), penv[], array, elems, mode) + ccall(jniref[].ReleaseBooleanArrayElements, Nothing, (Ptr{JNIEnv}, jbooleanArray, Ptr{jboolean}, jint,), ppenv[], array, elems, mode) ReleaseByteArrayElements(array::jbyteArray, elems::Ptr{jbyte}, mode::jint) = - ccall(jniref[].ReleaseByteArrayElements, Nothing, (Ptr{JNIEnv}, jbyteArray, Ptr{jbyte}, jint,), penv[], array, elems, mode) + ccall(jniref[].ReleaseByteArrayElements, Nothing, (Ptr{JNIEnv}, jbyteArray, Ptr{jbyte}, jint,), ppenv[], array, elems, mode) ReleaseCharArrayElements(array::jcharArray, elems::Ptr{jchar}, mode::jint) = - ccall(jniref[].ReleaseCharArrayElements, Nothing, (Ptr{JNIEnv}, jcharArray, Ptr{jchar}, jint,), penv[], array, elems, mode) + ccall(jniref[].ReleaseCharArrayElements, Nothing, (Ptr{JNIEnv}, jcharArray, Ptr{jchar}, jint,), ppenv[], array, elems, mode) ReleaseShortArrayElements(array::jshortArray, elems::Ptr{jshort}, mode::jint) = - ccall(jniref[].ReleaseShortArrayElements, Nothing, (Ptr{JNIEnv}, jshortArray, Ptr{jshort}, jint,), penv[], array, elems, mode) + ccall(jniref[].ReleaseShortArrayElements, Nothing, (Ptr{JNIEnv}, jshortArray, Ptr{jshort}, jint,), ppenv[], array, elems, mode) ReleaseIntArrayElements(array::jintArray, elems::Ptr{jint}, mode::jint) = - ccall(jniref[].ReleaseIntArrayElements, Nothing, (Ptr{JNIEnv}, jintArray, Ptr{jint}, jint,), penv[], array, elems, mode) + ccall(jniref[].ReleaseIntArrayElements, Nothing, (Ptr{JNIEnv}, jintArray, Ptr{jint}, jint,), ppenv[], array, elems, mode) ReleaseLongArrayElements(array::jlongArray, elems::Ptr{jlong}, mode::jint) = - ccall(jniref[].ReleaseLongArrayElements, Nothing, (Ptr{JNIEnv}, jlongArray, Ptr{jlong}, jint,), penv[], array, elems, mode) + ccall(jniref[].ReleaseLongArrayElements, Nothing, (Ptr{JNIEnv}, jlongArray, Ptr{jlong}, jint,), ppenv[], array, elems, mode) ReleaseFloatArrayElements(array::jfloatArray, elems::Ptr{jfloat}, mode::jint) = - ccall(jniref[].ReleaseFloatArrayElements, Nothing, (Ptr{JNIEnv}, jfloatArray, Ptr{jfloat}, jint,), penv[], array, elems, mode) + ccall(jniref[].ReleaseFloatArrayElements, Nothing, (Ptr{JNIEnv}, jfloatArray, Ptr{jfloat}, jint,), ppenv[], array, elems, mode) ReleaseDoubleArrayElements(array::jdoubleArray, elems::Ptr{jdouble}, mode::jint) = - ccall(jniref[].ReleaseDoubleArrayElements, Nothing, (Ptr{JNIEnv}, jdoubleArray, Ptr{jdouble}, jint,), penv[], array, elems, mode) + ccall(jniref[].ReleaseDoubleArrayElements, Nothing, (Ptr{JNIEnv}, jdoubleArray, Ptr{jdouble}, jint,), ppenv[], array, elems, mode) GetBooleanArrayRegion(array::jbooleanArray, start::Integer, l::Integer, buf::Array{jboolean,1}) = - ccall(jniref[].GetBooleanArrayRegion, Nothing, (Ptr{JNIEnv}, jbooleanArray, jsize, jsize, Ptr{jboolean},), penv[], array, start, l, buf) + ccall(jniref[].GetBooleanArrayRegion, Nothing, (Ptr{JNIEnv}, jbooleanArray, jsize, jsize, Ptr{jboolean},), ppenv[], array, start, l, buf) GetByteArrayRegion(array::jbyteArray, start::Integer, len::Integer, buf::Array{jbyte,1}) = - ccall(jniref[].GetByteArrayRegion, Nothing, (Ptr{JNIEnv}, jbyteArray, jsize, jsize, Ptr{jbyte},), penv[], array, start, len, buf) + ccall(jniref[].GetByteArrayRegion, Nothing, (Ptr{JNIEnv}, jbyteArray, jsize, jsize, Ptr{jbyte},), ppenv[], array, start, len, buf) GetCharArrayRegion(array::jcharArray, start::Integer, len::Integer, buf::Array{jchar,1}) = - ccall(jniref[].GetCharArrayRegion, Nothing, (Ptr{JNIEnv}, jcharArray, jsize, jsize, Ptr{jchar},), penv[], array, start, len, buf) + ccall(jniref[].GetCharArrayRegion, Nothing, (Ptr{JNIEnv}, jcharArray, jsize, jsize, Ptr{jchar},), ppenv[], array, start, len, buf) GetShortArrayRegion(array::jshortArray, start::Integer, len::Integer, buf::Array{jshort,1}) = - ccall(jniref[].GetShortArrayRegion, Nothing, (Ptr{JNIEnv}, jshortArray, jsize, jsize, Ptr{jshort},), penv[], array, start, len, buf) + ccall(jniref[].GetShortArrayRegion, Nothing, (Ptr{JNIEnv}, jshortArray, jsize, jsize, Ptr{jshort},), ppenv[], array, start, len, buf) GetIntArrayRegion(array::jintArray, start::Integer, len::Integer, buf::Array{jint,1}) = - ccall(jniref[].GetIntArrayRegion, Nothing, (Ptr{JNIEnv}, jintArray, jsize, jsize, Ptr{jint},), penv[], array, start, len, buf) + ccall(jniref[].GetIntArrayRegion, Nothing, (Ptr{JNIEnv}, jintArray, jsize, jsize, Ptr{jint},), ppenv[], array, start, len, buf) GetLongArrayRegion(array::jlongArray, start::Integer, len::Integer, buf::Array{jlong,1}) = - ccall(jniref[].GetLongArrayRegion, Nothing, (Ptr{JNIEnv}, jlongArray, jsize, jsize, Ptr{jlong},), penv[], array, start, len, buf) + ccall(jniref[].GetLongArrayRegion, Nothing, (Ptr{JNIEnv}, jlongArray, jsize, jsize, Ptr{jlong},), ppenv[], array, start, len, buf) GetFloatArrayRegion(array::jfloatArray, start::Integer, len::Integer, buf::Array{jfloat,1}) = - ccall(jniref[].GetFloatArrayRegion, Nothing, (Ptr{JNIEnv}, jfloatArray, jsize, jsize, Ptr{jfloat},), penv[], array, start, len, buf) + ccall(jniref[].GetFloatArrayRegion, Nothing, (Ptr{JNIEnv}, jfloatArray, jsize, jsize, Ptr{jfloat},), ppenv[], array, start, len, buf) GetDoubleArrayRegion(array::jdoubleArray, start::Integer, len::Integer, buf::Array{jdouble,1}) = - ccall(jniref[].GetDoubleArrayRegion, Nothing, (Ptr{JNIEnv}, jdoubleArray, jsize, jsize, Ptr{jdouble},), penv[], array, start, len, buf) + ccall(jniref[].GetDoubleArrayRegion, Nothing, (Ptr{JNIEnv}, jdoubleArray, jsize, jsize, Ptr{jdouble},), ppenv[], array, start, len, buf) SetBooleanArrayRegion(array::jbooleanArray, start::Integer, l::Integer, buf::Array{jboolean,1}) = - ccall(jniref[].SetBooleanArrayRegion, Nothing, (Ptr{JNIEnv}, jbooleanArray, jsize, jsize, Ptr{jboolean},), penv[], array, start, l, buf) + ccall(jniref[].SetBooleanArrayRegion, Nothing, (Ptr{JNIEnv}, jbooleanArray, jsize, jsize, Ptr{jboolean},), ppenv[], array, start, l, buf) SetByteArrayRegion(array::jbyteArray, start::Integer, len::Integer, buf::Array{jbyte,1}) = - ccall(jniref[].SetByteArrayRegion, Nothing, (Ptr{JNIEnv}, jbyteArray, jsize, jsize, Ptr{jbyte},), penv[], array, start, len, buf) + ccall(jniref[].SetByteArrayRegion, Nothing, (Ptr{JNIEnv}, jbyteArray, jsize, jsize, Ptr{jbyte},), ppenv[], array, start, len, buf) SetCharArrayRegion(array::jcharArray, start::Integer, len::Integer, buf::Array{jchar,1}) = - ccall(jniref[].SetCharArrayRegion, Nothing, (Ptr{JNIEnv}, jcharArray, jsize, jsize, Ptr{jchar},), penv[], array, start, len, buf) + ccall(jniref[].SetCharArrayRegion, Nothing, (Ptr{JNIEnv}, jcharArray, jsize, jsize, Ptr{jchar},), ppenv[], array, start, len, buf) SetShortArrayRegion(array::jshortArray, start::Integer, len::Integer, buf::Array{jshort,1}) = - ccall(jniref[].SetShortArrayRegion, Nothing, (Ptr{JNIEnv}, jshortArray, jsize, jsize, Ptr{jshort},), penv[], array, start, len, buf) + ccall(jniref[].SetShortArrayRegion, Nothing, (Ptr{JNIEnv}, jshortArray, jsize, jsize, Ptr{jshort},), ppenv[], array, start, len, buf) SetIntArrayRegion(array::jintArray, start::Integer, len::Integer, buf::Array{jint,1}) = - ccall(jniref[].SetIntArrayRegion, Nothing, (Ptr{JNIEnv}, jintArray, jsize, jsize, Ptr{jint},), penv[], array, start, len, buf) + ccall(jniref[].SetIntArrayRegion, Nothing, (Ptr{JNIEnv}, jintArray, jsize, jsize, Ptr{jint},), ppenv[], array, start, len, buf) SetLongArrayRegion(array::jlongArray, start::Integer, len::Integer, buf::Array{jlong,1}) = - ccall(jniref[].SetLongArrayRegion, Nothing, (Ptr{JNIEnv}, jlongArray, jsize, jsize, Ptr{jlong},), penv[], array, start, len, buf) + ccall(jniref[].SetLongArrayRegion, Nothing, (Ptr{JNIEnv}, jlongArray, jsize, jsize, Ptr{jlong},), ppenv[], array, start, len, buf) SetFloatArrayRegion(array::jfloatArray, start::Integer, len::Integer, buf::Array{jfloat,1}) = - ccall(jniref[].SetFloatArrayRegion, Nothing, (Ptr{JNIEnv}, jfloatArray, jsize, jsize, Ptr{jfloat},), penv[], array, start, len, buf) + ccall(jniref[].SetFloatArrayRegion, Nothing, (Ptr{JNIEnv}, jfloatArray, jsize, jsize, Ptr{jfloat},), ppenv[], array, start, len, buf) SetDoubleArrayRegion(array::jdoubleArray, start::Integer, len::Integer, buf::Array{jdouble,1}) = - ccall(jniref[].SetDoubleArrayRegion, Nothing, (Ptr{JNIEnv}, jdoubleArray, jsize, jsize, Ptr{jdouble},), penv[], array, start, len, buf) + ccall(jniref[].SetDoubleArrayRegion, Nothing, (Ptr{JNIEnv}, jdoubleArray, jsize, jsize, Ptr{jdouble},), ppenv[], array, start, len, buf) RegisterNatives(clazz::jclass, methods::Array{JNINativeMethod,1}, nMethods::jint) = - ccall(jniref[].RegisterNatives, jint, (Ptr{JNIEnv}, jclass, Ptr{JNINativeMethod}, jint,), penv[], clazz, methods, nMethods) + ccall(jniref[].RegisterNatives, jint, (Ptr{JNIEnv}, jclass, Ptr{JNINativeMethod}, jint,), ppenv[], clazz, methods, nMethods) UnregisterNatives(clazz::jclass) = - ccall(jniref[].UnregisterNatives, jint, (Ptr{JNIEnv}, jclass,), penv[], clazz) + ccall(jniref[].UnregisterNatives, jint, (Ptr{JNIEnv}, jclass,), ppenv[], clazz) MonitorEnter(obj::jobject) = - ccall(jniref[].MonitorEnter, jint, (Ptr{JNIEnv}, jobject,), penv[], obj) + ccall(jniref[].MonitorEnter, jint, (Ptr{JNIEnv}, jobject,), ppenv[], obj) MonitorExit(obj::jobject) = - ccall(jniref[].MonitorExit, jint, (Ptr{JNIEnv}, jobject,), penv[], obj) + ccall(jniref[].MonitorExit, jint, (Ptr{JNIEnv}, jobject,), ppenv[], obj) GetJavaVM(vm::Array{JavaVM,1}) = - ccall(jniref[].GetJavaVM, jint, (Ptr{JNIEnv}, Array{JavaVM,1},), penv[], vm) + ccall(jniref[].GetJavaVM, jint, (Ptr{JNIEnv}, Array{JavaVM,1},), ppenv[], vm) GetStringRegion(str::jstring, start::Integer, len::Integer, buf::Array{jchar,1}) = - ccall(jniref[].GetStringRegion, Nothing, (Ptr{JNIEnv}, jstring, jsize, jsize, Ptr{jchar},), penv[], str, start, len, buf) + ccall(jniref[].GetStringRegion, Nothing, (Ptr{JNIEnv}, jstring, jsize, jsize, Ptr{jchar},), ppenv[], str, start, len, buf) GetStringUTFRegion(str::jstring, start::Integer, len::Integer, buf::AnyString) = - ccall(jniref[].GetStringUTFRegion, Nothing, (Ptr{JNIEnv}, jstring, jsize, jsize, Cstring,), penv[], str, start, len, buf) + ccall(jniref[].GetStringUTFRegion, Nothing, (Ptr{JNIEnv}, jstring, jsize, jsize, Cstring,), ppenv[], str, start, len, buf) GetPrimitiveArrayCritical(array::jarray, isCopy::PtrIsCopy) = - ccall(jniref[].GetPrimitiveArrayCritical, Ptr{Nothing}, (Ptr{JNIEnv}, jarray, Ptr{jboolean},), penv[], array, isCopy) + ccall(jniref[].GetPrimitiveArrayCritical, Ptr{Nothing}, (Ptr{JNIEnv}, jarray, Ptr{jboolean},), ppenv[], array, isCopy) ReleasePrimitiveArrayCritical(array::jarray, carray::Ptr{Nothing}, mode::jint) = - ccall(jniref[].ReleasePrimitiveArrayCritical, Nothing, (Ptr{JNIEnv}, jarray, Ptr{Nothing}, jint,), penv[], array, carray, mode) + ccall(jniref[].ReleasePrimitiveArrayCritical, Nothing, (Ptr{JNIEnv}, jarray, Ptr{Nothing}, jint,), ppenv[], array, carray, mode) GetStringCritical(string::jstring, isCopy::PtrIsCopy) = - ccall(jniref[].GetStringCritical, Ptr{jchar}, (Ptr{JNIEnv}, jstring, Ptr{jboolean},), penv[], string, isCopy) + ccall(jniref[].GetStringCritical, Ptr{jchar}, (Ptr{JNIEnv}, jstring, Ptr{jboolean},), ppenv[], string, isCopy) ReleaseStringCritical(string::jstring, cstring::Array{jchar,1}) = - ccall(jniref[].ReleaseStringCritical, Nothing, (Ptr{JNIEnv}, jstring, Ptr{jchar},), penv[], string, cstring) + ccall(jniref[].ReleaseStringCritical, Nothing, (Ptr{JNIEnv}, jstring, Ptr{jchar},), ppenv[], string, cstring) NewWeakGlobalRef(obj::jobject) = - ccall(jniref[].NewWeakGlobalRef, jweak, (Ptr{JNIEnv}, jobject,), penv[], obj) + ccall(jniref[].NewWeakGlobalRef, jweak, (Ptr{JNIEnv}, jobject,), ppenv[], obj) DeleteWeakGlobalRef(ref::jweak) = - ccall(jniref[].DeleteWeakGlobalRef, Nothing, (Ptr{JNIEnv}, jweak,), penv[], ref) + ccall(jniref[].DeleteWeakGlobalRef, Nothing, (Ptr{JNIEnv}, jweak,), ppenv[], ref) ExceptionCheck() = - ccall(jniref[].ExceptionCheck, jboolean, (Ptr{JNIEnv},), penv[]) + ccall(jniref[].ExceptionCheck, jboolean, (Ptr{JNIEnv},), ppenv[]) NewDirectByteBuffer(address::Ptr{Nothing}, capacity::jlong) = - ccall(jniref[].NewDirectByteBuffer, jobject, (Ptr{JNIEnv}, Ptr{Nothing}, jlong,), penv[], address, capacity) + ccall(jniref[].NewDirectByteBuffer, jobject, (Ptr{JNIEnv}, Ptr{Nothing}, jlong,), ppenv[], address, capacity) GetDirectBufferAddress(buf::jobject) = - ccall(jniref[].GetDirectBufferAddress, Ptr{Nothing}, (Ptr{JNIEnv}, jobject,), penv[], buf) + ccall(jniref[].GetDirectBufferAddress, Ptr{Nothing}, (Ptr{JNIEnv}, jobject,), ppenv[], buf) GetDirectBufferCapacity(buf::jobject) = - ccall(jniref[].GetDirectBufferCapacity, jlong, (Ptr{JNIEnv}, jobject,), penv[], buf) + ccall(jniref[].GetDirectBufferCapacity, jlong, (Ptr{JNIEnv}, jobject,), ppenv[], buf) GetObjectRefType(obj::jobject) = - ccall(jniref[].GetObjectRefType, jobjectRefType, (Ptr{JNIEnv}, jobject,), penv[], obj) + ccall(jniref[].GetObjectRefType, jobjectRefType, (Ptr{JNIEnv}, jobject,), ppenv[], obj) # === Above Generated by make_jni2.jl === From 263a6a76320f70aa1fec562f135aacc46dc4d391 Mon Sep 17 00:00:00 2001 From: "markkitt@gmail.com" Date: Tue, 12 May 2020 23:21:55 -0500 Subject: [PATCH 10/12] Add Base.@deprecated_binding for jnifunc --- src/JNI.jl | 1 + src/JavaCall.jl | 2 ++ 2 files changed, 3 insertions(+) diff --git a/src/JNI.jl b/src/JNI.jl index fdd922c..1a4d861 100644 --- a/src/JNI.jl +++ b/src/JNI.jl @@ -20,6 +20,7 @@ include("jnienv.jl") const jniref = Ref(JNINativeInterface()) global jnifunc +Base.@deprecate_binding jnifunc jniref[] const ppenv = Ref(Ptr{JNIEnv}(C_NULL)) const ppjvm = Ref(Ptr{JavaVM}(C_NULL)) diff --git a/src/JavaCall.jl b/src/JavaCall.jl index 6602892..afb36d5 100644 --- a/src/JavaCall.jl +++ b/src/JavaCall.jl @@ -29,6 +29,8 @@ include("core.jl") include("convert.jl") include("reflect.jl") +Base.@deprecate_binding jnifunc JavaCall.JNI.jniref[] + function __init__() global JULIA_COPY_STACKS = get(ENV, "JULIA_COPY_STACKS", "") ∈ ("1", "yes") if ! Sys.iswindows() From 212326b03f7eb3928963b7fc17d997222558a378 Mon Sep 17 00:00:00 2001 From: "markkitt@gmail.com" Date: Wed, 13 May 2020 00:12:00 -0500 Subject: [PATCH 11/12] Remove jnifunc backwards compatability --- src/JNI.jl | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/src/JNI.jl b/src/JNI.jl index 1a4d861..b1eddef 100644 --- a/src/JNI.jl +++ b/src/JNI.jl @@ -13,13 +13,12 @@ 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 +#export jnifunc include("jnienv.jl") const jniref = Ref(JNINativeInterface()) -global jnifunc +#global jnifunc Base.@deprecate_binding jnifunc jniref[] const ppenv = Ref(Ptr{JNIEnv}(C_NULL)) @@ -113,7 +112,7 @@ end function load_jni(penv::Ptr{JNIEnv}) global jnienv = unsafe_load(penv) jniref[] = unsafe_load(jnienv.JNINativeInterface_) #The JNI Function table - global jnifunc = jniref[] + #global jnifunc = jniref[] end is_jni_loaded() = jniref[].GetVersion != C_NULL is_env_loaded() = ppenv[] != C_NULL From ef12eb7f9f7885f60c358161d26c71375182842b Mon Sep 17 00:00:00 2001 From: "markkitt@gmail.com" Date: Wed, 13 May 2020 01:34:01 -0500 Subject: [PATCH 12/12] Make penv an optional argument that defaults to ppenv[] --- src/JNI.jl | 672 +++++++++++++++++++++++------------------------ src/make_jni2.jl | 4 +- 2 files changed, 338 insertions(+), 338 deletions(-) diff --git a/src/JNI.jl b/src/JNI.jl index b1eddef..51a471f 100644 --- a/src/JNI.jl +++ b/src/JNI.jl @@ -180,509 +180,509 @@ end # === Below Generated by make_jni2.jl === -GetVersion() = - ccall(jniref[].GetVersion, jint, (Ptr{JNIEnv},), ppenv[]) +GetVersion(penv=ppenv[]) = + ccall(jniref[].GetVersion, jint, (Ptr{JNIEnv},), penv) -DefineClass(name::AnyString, loader::jobject, buf::Array{jbyte,1}, len::Integer) = - ccall(jniref[].DefineClass, jclass, (Ptr{JNIEnv}, Cstring, jobject, Ptr{jbyte}, jsize,), ppenv[], name, loader, buf, len) +DefineClass(name::AnyString, loader::jobject, buf::Array{jbyte,1}, len::Integer, penv=ppenv[]) = + ccall(jniref[].DefineClass, jclass, (Ptr{JNIEnv}, Cstring, jobject, Ptr{jbyte}, jsize,), penv, name, loader, buf, len) -FindClass(name::AnyString) = - ccall(jniref[].FindClass, jclass, (Ptr{JNIEnv}, Cstring,), ppenv[], name) +FindClass(name::AnyString, penv=ppenv[]) = + ccall(jniref[].FindClass, jclass, (Ptr{JNIEnv}, Cstring,), penv, name) -FromReflectedMethod(method::jobject) = - ccall(jniref[].FromReflectedMethod, jmethodID, (Ptr{JNIEnv}, jobject,), ppenv[], method) +FromReflectedMethod(method::jobject, penv=ppenv[]) = + ccall(jniref[].FromReflectedMethod, jmethodID, (Ptr{JNIEnv}, jobject,), penv, method) -FromReflectedField(field::jobject) = - ccall(jniref[].FromReflectedField, jfieldID, (Ptr{JNIEnv}, jobject,), ppenv[], field) +FromReflectedField(field::jobject, penv=ppenv[]) = + ccall(jniref[].FromReflectedField, jfieldID, (Ptr{JNIEnv}, jobject,), penv, field) -ToReflectedMethod(cls::jclass, methodID::jmethodID, isStatic::jboolean) = - ccall(jniref[].ToReflectedMethod, jobject, (Ptr{JNIEnv}, jclass, jmethodID, jboolean,), ppenv[], cls, methodID, isStatic) +ToReflectedMethod(cls::jclass, methodID::jmethodID, isStatic::jboolean, penv=ppenv[]) = + ccall(jniref[].ToReflectedMethod, jobject, (Ptr{JNIEnv}, jclass, jmethodID, jboolean,), penv, cls, methodID, isStatic) -GetSuperclass(sub::jclass) = - ccall(jniref[].GetSuperclass, jclass, (Ptr{JNIEnv}, jclass,), ppenv[], sub) +GetSuperclass(sub::jclass, penv=ppenv[]) = + ccall(jniref[].GetSuperclass, jclass, (Ptr{JNIEnv}, jclass,), penv, sub) -IsAssignableFrom(sub::jclass, sup::jclass) = - ccall(jniref[].IsAssignableFrom, jboolean, (Ptr{JNIEnv}, jclass, jclass,), ppenv[], sub, sup) +IsAssignableFrom(sub::jclass, sup::jclass, penv=ppenv[]) = + ccall(jniref[].IsAssignableFrom, jboolean, (Ptr{JNIEnv}, jclass, jclass,), penv, sub, sup) -ToReflectedField(cls::jclass, fieldID::jfieldID, isStatic::jboolean) = - ccall(jniref[].ToReflectedField, jobject, (Ptr{JNIEnv}, jclass, jfieldID, jboolean,), ppenv[], cls, fieldID, isStatic) +ToReflectedField(cls::jclass, fieldID::jfieldID, isStatic::jboolean, penv=ppenv[]) = + ccall(jniref[].ToReflectedField, jobject, (Ptr{JNIEnv}, jclass, jfieldID, jboolean,), penv, cls, fieldID, isStatic) -Throw(obj::jthrowable) = - ccall(jniref[].Throw, jint, (Ptr{JNIEnv}, jthrowable,), ppenv[], obj) +Throw(obj::jthrowable, penv=ppenv[]) = + ccall(jniref[].Throw, jint, (Ptr{JNIEnv}, jthrowable,), penv, obj) -ThrowNew(clazz::jclass, msg::AnyString) = - ccall(jniref[].ThrowNew, jint, (Ptr{JNIEnv}, jclass, Cstring,), ppenv[], clazz, msg) +ThrowNew(clazz::jclass, msg::AnyString, penv=ppenv[]) = + ccall(jniref[].ThrowNew, jint, (Ptr{JNIEnv}, jclass, Cstring,), penv, clazz, msg) -ExceptionOccurred() = - ccall(jniref[].ExceptionOccurred, jthrowable, (Ptr{JNIEnv},), ppenv[]) +ExceptionOccurred(penv=ppenv[]) = + ccall(jniref[].ExceptionOccurred, jthrowable, (Ptr{JNIEnv},), penv) -ExceptionDescribe() = - ccall(jniref[].ExceptionDescribe, Nothing, (Ptr{JNIEnv},), ppenv[]) +ExceptionDescribe(penv=ppenv[]) = + ccall(jniref[].ExceptionDescribe, Nothing, (Ptr{JNIEnv},), penv) -ExceptionClear() = - ccall(jniref[].ExceptionClear, Nothing, (Ptr{JNIEnv},), ppenv[]) +ExceptionClear(penv=ppenv[]) = + ccall(jniref[].ExceptionClear, Nothing, (Ptr{JNIEnv},), penv) -FatalError(msg::AnyString) = - ccall(jniref[].FatalError, Nothing, (Ptr{JNIEnv}, Cstring,), ppenv[], msg) +FatalError(msg::AnyString, penv=ppenv[]) = + ccall(jniref[].FatalError, Nothing, (Ptr{JNIEnv}, Cstring,), penv, msg) -PushLocalFrame(capacity::jint) = - ccall(jniref[].PushLocalFrame, jint, (Ptr{JNIEnv}, jint,), ppenv[], capacity) +PushLocalFrame(capacity::jint, penv=ppenv[]) = + ccall(jniref[].PushLocalFrame, jint, (Ptr{JNIEnv}, jint,), penv, capacity) -PopLocalFrame(result::jobject) = - ccall(jniref[].PopLocalFrame, jobject, (Ptr{JNIEnv}, jobject,), ppenv[], result) +PopLocalFrame(result::jobject, penv=ppenv[]) = + ccall(jniref[].PopLocalFrame, jobject, (Ptr{JNIEnv}, jobject,), penv, result) -NewGlobalRef(lobj::jobject) = - ccall(jniref[].NewGlobalRef, jobject, (Ptr{JNIEnv}, jobject,), ppenv[], lobj) +NewGlobalRef(lobj::jobject, penv=ppenv[]) = + ccall(jniref[].NewGlobalRef, jobject, (Ptr{JNIEnv}, jobject,), penv, lobj) -DeleteGlobalRef(gref::jobject) = - ccall(jniref[].DeleteGlobalRef, Nothing, (Ptr{JNIEnv}, jobject,), ppenv[], gref) +DeleteGlobalRef(gref::jobject, penv=ppenv[]) = + ccall(jniref[].DeleteGlobalRef, Nothing, (Ptr{JNIEnv}, jobject,), penv, gref) -DeleteLocalRef(obj::jobject) = - ccall(jniref[].DeleteLocalRef, Nothing, (Ptr{JNIEnv}, jobject,), ppenv[], obj) +DeleteLocalRef(obj::jobject, penv=ppenv[]) = + ccall(jniref[].DeleteLocalRef, Nothing, (Ptr{JNIEnv}, jobject,), penv, obj) -IsSameObject(obj1::jobject, obj2::jobject) = - ccall(jniref[].IsSameObject, jboolean, (Ptr{JNIEnv}, jobject, jobject,), ppenv[], obj1, obj2) +IsSameObject(obj1::jobject, obj2::jobject, penv=ppenv[]) = + ccall(jniref[].IsSameObject, jboolean, (Ptr{JNIEnv}, jobject, jobject,), penv, obj1, obj2) -NewLocalRef(ref::jobject) = - ccall(jniref[].NewLocalRef, jobject, (Ptr{JNIEnv}, jobject,), ppenv[], ref) +NewLocalRef(ref::jobject, penv=ppenv[]) = + ccall(jniref[].NewLocalRef, jobject, (Ptr{JNIEnv}, jobject,), penv, ref) -EnsureLocalCapacity(capacity::jint) = - ccall(jniref[].EnsureLocalCapacity, jint, (Ptr{JNIEnv}, jint,), ppenv[], capacity) +EnsureLocalCapacity(capacity::jint, penv=ppenv[]) = + ccall(jniref[].EnsureLocalCapacity, jint, (Ptr{JNIEnv}, jint,), penv, capacity) -AllocObject(clazz::jclass) = - ccall(jniref[].AllocObject, jobject, (Ptr{JNIEnv}, jclass,), ppenv[], clazz) +AllocObject(clazz::jclass, penv=ppenv[]) = + ccall(jniref[].AllocObject, jobject, (Ptr{JNIEnv}, jclass,), penv, clazz) -NewObjectA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].NewObjectA, jobject, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), ppenv[], clazz, methodID, args) +NewObjectA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}, penv=ppenv[]) = + ccall(jniref[].NewObjectA, jobject, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), penv, clazz, methodID, args) -GetObjectClass(obj::jobject) = - ccall(jniref[].GetObjectClass, jclass, (Ptr{JNIEnv}, jobject,), ppenv[], obj) +GetObjectClass(obj::jobject, penv=ppenv[]) = + ccall(jniref[].GetObjectClass, jclass, (Ptr{JNIEnv}, jobject,), penv, obj) -IsInstanceOf(obj::jobject, clazz::jclass) = - ccall(jniref[].IsInstanceOf, jboolean, (Ptr{JNIEnv}, jobject, jclass,), ppenv[], obj, clazz) +IsInstanceOf(obj::jobject, clazz::jclass, penv=ppenv[]) = + ccall(jniref[].IsInstanceOf, jboolean, (Ptr{JNIEnv}, jobject, jclass,), penv, obj, clazz) -GetMethodID(clazz::jclass, name::AnyString, sig::AnyString) = - ccall(jniref[].GetMethodID, jmethodID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), ppenv[], clazz, name, sig) +GetMethodID(clazz::jclass, name::AnyString, sig::AnyString, penv=ppenv[]) = + ccall(jniref[].GetMethodID, jmethodID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), penv, clazz, name, sig) -CallObjectMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallObjectMethodA, jobject, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), ppenv[], obj, methodID, args) +CallObjectMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}, penv=ppenv[]) = + ccall(jniref[].CallObjectMethodA, jobject, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), penv, obj, methodID, args) -CallBooleanMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallBooleanMethodA, jboolean, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), ppenv[], obj, methodID, args) +CallBooleanMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}, penv=ppenv[]) = + ccall(jniref[].CallBooleanMethodA, jboolean, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), penv, obj, methodID, args) -CallByteMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallByteMethodA, jbyte, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), ppenv[], obj, methodID, args) +CallByteMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}, penv=ppenv[]) = + ccall(jniref[].CallByteMethodA, jbyte, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), penv, obj, methodID, args) -CallCharMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallCharMethodA, jchar, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), ppenv[], obj, methodID, args) +CallCharMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}, penv=ppenv[]) = + ccall(jniref[].CallCharMethodA, jchar, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), penv, obj, methodID, args) -CallShortMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallShortMethodA, jshort, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), ppenv[], obj, methodID, args) +CallShortMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}, penv=ppenv[]) = + ccall(jniref[].CallShortMethodA, jshort, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), penv, obj, methodID, args) -CallIntMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallIntMethodA, jint, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), ppenv[], obj, methodID, args) +CallIntMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}, penv=ppenv[]) = + ccall(jniref[].CallIntMethodA, jint, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), penv, obj, methodID, args) -CallLongMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallLongMethodA, jlong, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), ppenv[], obj, methodID, args) +CallLongMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}, penv=ppenv[]) = + ccall(jniref[].CallLongMethodA, jlong, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), penv, obj, methodID, args) -CallFloatMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallFloatMethodA, jfloat, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), ppenv[], obj, methodID, args) +CallFloatMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}, penv=ppenv[]) = + ccall(jniref[].CallFloatMethodA, jfloat, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), penv, obj, methodID, args) -CallDoubleMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallDoubleMethodA, jdouble, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), ppenv[], obj, methodID, args) +CallDoubleMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}, penv=ppenv[]) = + ccall(jniref[].CallDoubleMethodA, jdouble, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), penv, obj, methodID, args) -CallVoidMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallVoidMethodA, Nothing, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), ppenv[], obj, methodID, args) +CallVoidMethodA(obj::jobject, methodID::jmethodID, args::Array{jvalue,1}, penv=ppenv[]) = + ccall(jniref[].CallVoidMethodA, Nothing, (Ptr{JNIEnv}, jobject, jmethodID, Ptr{jvalue},), penv, obj, methodID, args) -CallNonvirtualObjectMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallNonvirtualObjectMethodA, jobject, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), ppenv[], obj, clazz, methodID, args) +CallNonvirtualObjectMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}, penv=ppenv[]) = + ccall(jniref[].CallNonvirtualObjectMethodA, jobject, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), penv, obj, clazz, methodID, args) -CallNonvirtualBooleanMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallNonvirtualBooleanMethodA, jboolean, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), ppenv[], obj, clazz, methodID, args) +CallNonvirtualBooleanMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}, penv=ppenv[]) = + ccall(jniref[].CallNonvirtualBooleanMethodA, jboolean, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), penv, obj, clazz, methodID, args) -CallNonvirtualByteMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallNonvirtualByteMethodA, jbyte, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), ppenv[], obj, clazz, methodID, args) +CallNonvirtualByteMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}, penv=ppenv[]) = + ccall(jniref[].CallNonvirtualByteMethodA, jbyte, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), penv, obj, clazz, methodID, args) -CallNonvirtualCharMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallNonvirtualCharMethodA, jchar, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), ppenv[], obj, clazz, methodID, args) +CallNonvirtualCharMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}, penv=ppenv[]) = + ccall(jniref[].CallNonvirtualCharMethodA, jchar, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), penv, obj, clazz, methodID, args) -CallNonvirtualShortMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallNonvirtualShortMethodA, jshort, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), ppenv[], obj, clazz, methodID, args) +CallNonvirtualShortMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}, penv=ppenv[]) = + ccall(jniref[].CallNonvirtualShortMethodA, jshort, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), penv, obj, clazz, methodID, args) -CallNonvirtualIntMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallNonvirtualIntMethodA, jint, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), ppenv[], obj, clazz, methodID, args) +CallNonvirtualIntMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}, penv=ppenv[]) = + ccall(jniref[].CallNonvirtualIntMethodA, jint, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), penv, obj, clazz, methodID, args) -CallNonvirtualLongMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallNonvirtualLongMethodA, jlong, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), ppenv[], obj, clazz, methodID, args) +CallNonvirtualLongMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}, penv=ppenv[]) = + ccall(jniref[].CallNonvirtualLongMethodA, jlong, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), penv, obj, clazz, methodID, args) -CallNonvirtualFloatMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallNonvirtualFloatMethodA, jfloat, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), ppenv[], obj, clazz, methodID, args) +CallNonvirtualFloatMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}, penv=ppenv[]) = + ccall(jniref[].CallNonvirtualFloatMethodA, jfloat, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), penv, obj, clazz, methodID, args) -CallNonvirtualDoubleMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallNonvirtualDoubleMethodA, jdouble, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), ppenv[], obj, clazz, methodID, args) +CallNonvirtualDoubleMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}, penv=ppenv[]) = + ccall(jniref[].CallNonvirtualDoubleMethodA, jdouble, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), penv, obj, clazz, methodID, args) -CallNonvirtualVoidMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallNonvirtualVoidMethodA, Nothing, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), ppenv[], obj, clazz, methodID, args) +CallNonvirtualVoidMethodA(obj::jobject, clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}, penv=ppenv[]) = + ccall(jniref[].CallNonvirtualVoidMethodA, Nothing, (Ptr{JNIEnv}, jobject, jclass, jmethodID, Ptr{jvalue},), penv, obj, clazz, methodID, args) -GetFieldID(clazz::jclass, name::AnyString, sig::AnyString) = - ccall(jniref[].GetFieldID, jfieldID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), ppenv[], clazz, name, sig) +GetFieldID(clazz::jclass, name::AnyString, sig::AnyString, penv=ppenv[]) = + ccall(jniref[].GetFieldID, jfieldID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), penv, clazz, name, sig) -GetObjectField(obj::jobject, fieldID::jfieldID) = - ccall(jniref[].GetObjectField, jobject, (Ptr{JNIEnv}, jobject, jfieldID,), ppenv[], obj, fieldID) +GetObjectField(obj::jobject, fieldID::jfieldID, penv=ppenv[]) = + ccall(jniref[].GetObjectField, jobject, (Ptr{JNIEnv}, jobject, jfieldID,), penv, obj, fieldID) -GetBooleanField(obj::jobject, fieldID::jfieldID) = - ccall(jniref[].GetBooleanField, jboolean, (Ptr{JNIEnv}, jobject, jfieldID,), ppenv[], obj, fieldID) +GetBooleanField(obj::jobject, fieldID::jfieldID, penv=ppenv[]) = + ccall(jniref[].GetBooleanField, jboolean, (Ptr{JNIEnv}, jobject, jfieldID,), penv, obj, fieldID) -GetByteField(obj::jobject, fieldID::jfieldID) = - ccall(jniref[].GetByteField, jbyte, (Ptr{JNIEnv}, jobject, jfieldID,), ppenv[], obj, fieldID) +GetByteField(obj::jobject, fieldID::jfieldID, penv=ppenv[]) = + ccall(jniref[].GetByteField, jbyte, (Ptr{JNIEnv}, jobject, jfieldID,), penv, obj, fieldID) -GetCharField(obj::jobject, fieldID::jfieldID) = - ccall(jniref[].GetCharField, jchar, (Ptr{JNIEnv}, jobject, jfieldID,), ppenv[], obj, fieldID) +GetCharField(obj::jobject, fieldID::jfieldID, penv=ppenv[]) = + ccall(jniref[].GetCharField, jchar, (Ptr{JNIEnv}, jobject, jfieldID,), penv, obj, fieldID) -GetShortField(obj::jobject, fieldID::jfieldID) = - ccall(jniref[].GetShortField, jshort, (Ptr{JNIEnv}, jobject, jfieldID,), ppenv[], obj, fieldID) +GetShortField(obj::jobject, fieldID::jfieldID, penv=ppenv[]) = + ccall(jniref[].GetShortField, jshort, (Ptr{JNIEnv}, jobject, jfieldID,), penv, obj, fieldID) -GetIntField(obj::jobject, fieldID::jfieldID) = - ccall(jniref[].GetIntField, jint, (Ptr{JNIEnv}, jobject, jfieldID,), ppenv[], obj, fieldID) +GetIntField(obj::jobject, fieldID::jfieldID, penv=ppenv[]) = + ccall(jniref[].GetIntField, jint, (Ptr{JNIEnv}, jobject, jfieldID,), penv, obj, fieldID) -GetLongField(obj::jobject, fieldID::jfieldID) = - ccall(jniref[].GetLongField, jlong, (Ptr{JNIEnv}, jobject, jfieldID,), ppenv[], obj, fieldID) +GetLongField(obj::jobject, fieldID::jfieldID, penv=ppenv[]) = + ccall(jniref[].GetLongField, jlong, (Ptr{JNIEnv}, jobject, jfieldID,), penv, obj, fieldID) -GetFloatField(obj::jobject, fieldID::jfieldID) = - ccall(jniref[].GetFloatField, jfloat, (Ptr{JNIEnv}, jobject, jfieldID,), ppenv[], obj, fieldID) +GetFloatField(obj::jobject, fieldID::jfieldID, penv=ppenv[]) = + ccall(jniref[].GetFloatField, jfloat, (Ptr{JNIEnv}, jobject, jfieldID,), penv, obj, fieldID) -GetDoubleField(obj::jobject, fieldID::jfieldID) = - ccall(jniref[].GetDoubleField, jdouble, (Ptr{JNIEnv}, jobject, jfieldID,), ppenv[], obj, fieldID) +GetDoubleField(obj::jobject, fieldID::jfieldID, penv=ppenv[]) = + ccall(jniref[].GetDoubleField, jdouble, (Ptr{JNIEnv}, jobject, jfieldID,), penv, obj, fieldID) -SetObjectField(obj::jobject, fieldID::jfieldID, val::jobject) = - ccall(jniref[].SetObjectField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jobject,), ppenv[], obj, fieldID, val) +SetObjectField(obj::jobject, fieldID::jfieldID, val::jobject, penv=ppenv[]) = + ccall(jniref[].SetObjectField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jobject,), penv, obj, fieldID, val) -SetBooleanField(obj::jobject, fieldID::jfieldID, val::jboolean) = - ccall(jniref[].SetBooleanField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jboolean,), ppenv[], obj, fieldID, val) +SetBooleanField(obj::jobject, fieldID::jfieldID, val::jboolean, penv=ppenv[]) = + ccall(jniref[].SetBooleanField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jboolean,), penv, obj, fieldID, val) -SetByteField(obj::jobject, fieldID::jfieldID, val::jbyte) = - ccall(jniref[].SetByteField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jbyte,), ppenv[], obj, fieldID, val) +SetByteField(obj::jobject, fieldID::jfieldID, val::jbyte, penv=ppenv[]) = + ccall(jniref[].SetByteField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jbyte,), penv, obj, fieldID, val) -SetCharField(obj::jobject, fieldID::jfieldID, val::jchar) = - ccall(jniref[].SetCharField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jchar,), ppenv[], obj, fieldID, val) +SetCharField(obj::jobject, fieldID::jfieldID, val::jchar, penv=ppenv[]) = + ccall(jniref[].SetCharField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jchar,), penv, obj, fieldID, val) -SetShortField(obj::jobject, fieldID::jfieldID, val::jshort) = - ccall(jniref[].SetShortField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jshort,), ppenv[], obj, fieldID, val) +SetShortField(obj::jobject, fieldID::jfieldID, val::jshort, penv=ppenv[]) = + ccall(jniref[].SetShortField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jshort,), penv, obj, fieldID, val) -SetIntField(obj::jobject, fieldID::jfieldID, val::jint) = - ccall(jniref[].SetIntField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jint,), ppenv[], obj, fieldID, val) +SetIntField(obj::jobject, fieldID::jfieldID, val::jint, penv=ppenv[]) = + ccall(jniref[].SetIntField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jint,), penv, obj, fieldID, val) -SetLongField(obj::jobject, fieldID::jfieldID, val::jlong) = - ccall(jniref[].SetLongField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jlong,), ppenv[], obj, fieldID, val) +SetLongField(obj::jobject, fieldID::jfieldID, val::jlong, penv=ppenv[]) = + ccall(jniref[].SetLongField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jlong,), penv, obj, fieldID, val) -SetFloatField(obj::jobject, fieldID::jfieldID, val::jfloat) = - ccall(jniref[].SetFloatField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jfloat,), ppenv[], obj, fieldID, val) +SetFloatField(obj::jobject, fieldID::jfieldID, val::jfloat, penv=ppenv[]) = + ccall(jniref[].SetFloatField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jfloat,), penv, obj, fieldID, val) -SetDoubleField(obj::jobject, fieldID::jfieldID, val::jdouble) = - ccall(jniref[].SetDoubleField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jdouble,), ppenv[], obj, fieldID, val) +SetDoubleField(obj::jobject, fieldID::jfieldID, val::jdouble, penv=ppenv[]) = + ccall(jniref[].SetDoubleField, Nothing, (Ptr{JNIEnv}, jobject, jfieldID, jdouble,), penv, obj, fieldID, val) -GetStaticMethodID(clazz::jclass, name::AnyString, sig::AnyString) = - ccall(jniref[].GetStaticMethodID, jmethodID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), ppenv[], clazz, name, sig) +GetStaticMethodID(clazz::jclass, name::AnyString, sig::AnyString, penv=ppenv[]) = + ccall(jniref[].GetStaticMethodID, jmethodID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), penv, clazz, name, sig) -CallStaticObjectMethodA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallStaticObjectMethodA, jobject, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), ppenv[], clazz, methodID, args) +CallStaticObjectMethodA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}, penv=ppenv[]) = + ccall(jniref[].CallStaticObjectMethodA, jobject, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), penv, clazz, methodID, args) -CallStaticBooleanMethodA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallStaticBooleanMethodA, jboolean, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), ppenv[], clazz, methodID, args) +CallStaticBooleanMethodA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}, penv=ppenv[]) = + ccall(jniref[].CallStaticBooleanMethodA, jboolean, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), penv, clazz, methodID, args) -CallStaticByteMethodA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallStaticByteMethodA, jbyte, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), ppenv[], clazz, methodID, args) +CallStaticByteMethodA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}, penv=ppenv[]) = + ccall(jniref[].CallStaticByteMethodA, jbyte, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), penv, clazz, methodID, args) -CallStaticCharMethodA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallStaticCharMethodA, jchar, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), ppenv[], clazz, methodID, args) +CallStaticCharMethodA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}, penv=ppenv[]) = + ccall(jniref[].CallStaticCharMethodA, jchar, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), penv, clazz, methodID, args) -CallStaticShortMethodA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallStaticShortMethodA, jshort, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), ppenv[], clazz, methodID, args) +CallStaticShortMethodA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}, penv=ppenv[]) = + ccall(jniref[].CallStaticShortMethodA, jshort, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), penv, clazz, methodID, args) -CallStaticIntMethodA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallStaticIntMethodA, jint, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), ppenv[], clazz, methodID, args) +CallStaticIntMethodA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}, penv=ppenv[]) = + ccall(jniref[].CallStaticIntMethodA, jint, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), penv, clazz, methodID, args) -CallStaticLongMethodA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallStaticLongMethodA, jlong, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), ppenv[], clazz, methodID, args) +CallStaticLongMethodA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}, penv=ppenv[]) = + ccall(jniref[].CallStaticLongMethodA, jlong, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), penv, clazz, methodID, args) -CallStaticFloatMethodA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallStaticFloatMethodA, jfloat, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), ppenv[], clazz, methodID, args) +CallStaticFloatMethodA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}, penv=ppenv[]) = + ccall(jniref[].CallStaticFloatMethodA, jfloat, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), penv, clazz, methodID, args) -CallStaticDoubleMethodA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallStaticDoubleMethodA, jdouble, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), ppenv[], clazz, methodID, args) +CallStaticDoubleMethodA(clazz::jclass, methodID::jmethodID, args::Array{jvalue,1}, penv=ppenv[]) = + ccall(jniref[].CallStaticDoubleMethodA, jdouble, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), penv, clazz, methodID, args) -CallStaticVoidMethodA(cls::jclass, methodID::jmethodID, args::Array{jvalue,1}) = - ccall(jniref[].CallStaticVoidMethodA, Nothing, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), ppenv[], cls, methodID, args) +CallStaticVoidMethodA(cls::jclass, methodID::jmethodID, args::Array{jvalue,1}, penv=ppenv[]) = + ccall(jniref[].CallStaticVoidMethodA, Nothing, (Ptr{JNIEnv}, jclass, jmethodID, Ptr{jvalue},), penv, cls, methodID, args) -GetStaticFieldID(clazz::jclass, name::AnyString, sig::AnyString) = - ccall(jniref[].GetStaticFieldID, jfieldID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), ppenv[], clazz, name, sig) +GetStaticFieldID(clazz::jclass, name::AnyString, sig::AnyString, penv=ppenv[]) = + ccall(jniref[].GetStaticFieldID, jfieldID, (Ptr{JNIEnv}, jclass, Cstring, Cstring,), penv, clazz, name, sig) -GetStaticObjectField(clazz::jclass, fieldID::jfieldID) = - ccall(jniref[].GetStaticObjectField, jobject, (Ptr{JNIEnv}, jclass, jfieldID,), ppenv[], clazz, fieldID) +GetStaticObjectField(clazz::jclass, fieldID::jfieldID, penv=ppenv[]) = + ccall(jniref[].GetStaticObjectField, jobject, (Ptr{JNIEnv}, jclass, jfieldID,), penv, clazz, fieldID) -GetStaticBooleanField(clazz::jclass, fieldID::jfieldID) = - ccall(jniref[].GetStaticBooleanField, jboolean, (Ptr{JNIEnv}, jclass, jfieldID,), ppenv[], clazz, fieldID) +GetStaticBooleanField(clazz::jclass, fieldID::jfieldID, penv=ppenv[]) = + ccall(jniref[].GetStaticBooleanField, jboolean, (Ptr{JNIEnv}, jclass, jfieldID,), penv, clazz, fieldID) -GetStaticByteField(clazz::jclass, fieldID::jfieldID) = - ccall(jniref[].GetStaticByteField, jbyte, (Ptr{JNIEnv}, jclass, jfieldID,), ppenv[], clazz, fieldID) +GetStaticByteField(clazz::jclass, fieldID::jfieldID, penv=ppenv[]) = + ccall(jniref[].GetStaticByteField, jbyte, (Ptr{JNIEnv}, jclass, jfieldID,), penv, clazz, fieldID) -GetStaticCharField(clazz::jclass, fieldID::jfieldID) = - ccall(jniref[].GetStaticCharField, jchar, (Ptr{JNIEnv}, jclass, jfieldID,), ppenv[], clazz, fieldID) +GetStaticCharField(clazz::jclass, fieldID::jfieldID, penv=ppenv[]) = + ccall(jniref[].GetStaticCharField, jchar, (Ptr{JNIEnv}, jclass, jfieldID,), penv, clazz, fieldID) -GetStaticShortField(clazz::jclass, fieldID::jfieldID) = - ccall(jniref[].GetStaticShortField, jshort, (Ptr{JNIEnv}, jclass, jfieldID,), ppenv[], clazz, fieldID) +GetStaticShortField(clazz::jclass, fieldID::jfieldID, penv=ppenv[]) = + ccall(jniref[].GetStaticShortField, jshort, (Ptr{JNIEnv}, jclass, jfieldID,), penv, clazz, fieldID) -GetStaticIntField(clazz::jclass, fieldID::jfieldID) = - ccall(jniref[].GetStaticIntField, jint, (Ptr{JNIEnv}, jclass, jfieldID,), ppenv[], clazz, fieldID) +GetStaticIntField(clazz::jclass, fieldID::jfieldID, penv=ppenv[]) = + ccall(jniref[].GetStaticIntField, jint, (Ptr{JNIEnv}, jclass, jfieldID,), penv, clazz, fieldID) -GetStaticLongField(clazz::jclass, fieldID::jfieldID) = - ccall(jniref[].GetStaticLongField, jlong, (Ptr{JNIEnv}, jclass, jfieldID,), ppenv[], clazz, fieldID) +GetStaticLongField(clazz::jclass, fieldID::jfieldID, penv=ppenv[]) = + ccall(jniref[].GetStaticLongField, jlong, (Ptr{JNIEnv}, jclass, jfieldID,), penv, clazz, fieldID) -GetStaticFloatField(clazz::jclass, fieldID::jfieldID) = - ccall(jniref[].GetStaticFloatField, jfloat, (Ptr{JNIEnv}, jclass, jfieldID,), ppenv[], clazz, fieldID) +GetStaticFloatField(clazz::jclass, fieldID::jfieldID, penv=ppenv[]) = + ccall(jniref[].GetStaticFloatField, jfloat, (Ptr{JNIEnv}, jclass, jfieldID,), penv, clazz, fieldID) -GetStaticDoubleField(clazz::jclass, fieldID::jfieldID) = - ccall(jniref[].GetStaticDoubleField, jdouble, (Ptr{JNIEnv}, jclass, jfieldID,), ppenv[], clazz, fieldID) +GetStaticDoubleField(clazz::jclass, fieldID::jfieldID, penv=ppenv[]) = + ccall(jniref[].GetStaticDoubleField, jdouble, (Ptr{JNIEnv}, jclass, jfieldID,), penv, clazz, fieldID) -SetStaticObjectField(clazz::jclass, fieldID::jfieldID, value::jobject) = - ccall(jniref[].SetStaticObjectField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jobject,), ppenv[], clazz, fieldID, value) +SetStaticObjectField(clazz::jclass, fieldID::jfieldID, value::jobject, penv=ppenv[]) = + ccall(jniref[].SetStaticObjectField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jobject,), penv, clazz, fieldID, value) -SetStaticBooleanField(clazz::jclass, fieldID::jfieldID, value::jboolean) = - ccall(jniref[].SetStaticBooleanField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jboolean,), ppenv[], clazz, fieldID, value) +SetStaticBooleanField(clazz::jclass, fieldID::jfieldID, value::jboolean, penv=ppenv[]) = + ccall(jniref[].SetStaticBooleanField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jboolean,), penv, clazz, fieldID, value) -SetStaticByteField(clazz::jclass, fieldID::jfieldID, value::jbyte) = - ccall(jniref[].SetStaticByteField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jbyte,), ppenv[], clazz, fieldID, value) +SetStaticByteField(clazz::jclass, fieldID::jfieldID, value::jbyte, penv=ppenv[]) = + ccall(jniref[].SetStaticByteField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jbyte,), penv, clazz, fieldID, value) -SetStaticCharField(clazz::jclass, fieldID::jfieldID, value::jchar) = - ccall(jniref[].SetStaticCharField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jchar,), ppenv[], clazz, fieldID, value) +SetStaticCharField(clazz::jclass, fieldID::jfieldID, value::jchar, penv=ppenv[]) = + ccall(jniref[].SetStaticCharField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jchar,), penv, clazz, fieldID, value) -SetStaticShortField(clazz::jclass, fieldID::jfieldID, value::jshort) = - ccall(jniref[].SetStaticShortField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jshort,), ppenv[], clazz, fieldID, value) +SetStaticShortField(clazz::jclass, fieldID::jfieldID, value::jshort, penv=ppenv[]) = + ccall(jniref[].SetStaticShortField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jshort,), penv, clazz, fieldID, value) -SetStaticIntField(clazz::jclass, fieldID::jfieldID, value::jint) = - ccall(jniref[].SetStaticIntField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jint,), ppenv[], clazz, fieldID, value) +SetStaticIntField(clazz::jclass, fieldID::jfieldID, value::jint, penv=ppenv[]) = + ccall(jniref[].SetStaticIntField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jint,), penv, clazz, fieldID, value) -SetStaticLongField(clazz::jclass, fieldID::jfieldID, value::jlong) = - ccall(jniref[].SetStaticLongField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jlong,), ppenv[], clazz, fieldID, value) +SetStaticLongField(clazz::jclass, fieldID::jfieldID, value::jlong, penv=ppenv[]) = + ccall(jniref[].SetStaticLongField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jlong,), penv, clazz, fieldID, value) -SetStaticFloatField(clazz::jclass, fieldID::jfieldID, value::jfloat) = - ccall(jniref[].SetStaticFloatField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jfloat,), ppenv[], clazz, fieldID, value) +SetStaticFloatField(clazz::jclass, fieldID::jfieldID, value::jfloat, penv=ppenv[]) = + ccall(jniref[].SetStaticFloatField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jfloat,), penv, clazz, fieldID, value) -SetStaticDoubleField(clazz::jclass, fieldID::jfieldID, value::jdouble) = - ccall(jniref[].SetStaticDoubleField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jdouble,), ppenv[], clazz, fieldID, value) +SetStaticDoubleField(clazz::jclass, fieldID::jfieldID, value::jdouble, penv=ppenv[]) = + ccall(jniref[].SetStaticDoubleField, Nothing, (Ptr{JNIEnv}, jclass, jfieldID, jdouble,), penv, clazz, fieldID, value) -NewString(unicode::Array{jchar,1}, len::Integer) = - ccall(jniref[].NewString, jstring, (Ptr{JNIEnv}, Ptr{jchar}, jsize,), ppenv[], unicode, len) +NewString(unicode::Array{jchar,1}, len::Integer, penv=ppenv[]) = + ccall(jniref[].NewString, jstring, (Ptr{JNIEnv}, Ptr{jchar}, jsize,), penv, unicode, len) -GetStringLength(str::jstring) = - ccall(jniref[].GetStringLength, jsize, (Ptr{JNIEnv}, jstring,), ppenv[], str) +GetStringLength(str::jstring, penv=ppenv[]) = + ccall(jniref[].GetStringLength, jsize, (Ptr{JNIEnv}, jstring,), penv, str) -GetStringChars(str::jstring, isCopy::PtrIsCopy) = - ccall(jniref[].GetStringChars, Ptr{jchar}, (Ptr{JNIEnv}, jstring, Ptr{jboolean},), ppenv[], str, isCopy) +GetStringChars(str::jstring, isCopy::PtrIsCopy, penv=ppenv[]) = + ccall(jniref[].GetStringChars, Ptr{jchar}, (Ptr{JNIEnv}, jstring, Ptr{jboolean},), penv, str, isCopy) -ReleaseStringChars(str::jstring, chars::Array{jchar,1}) = - ccall(jniref[].ReleaseStringChars, Nothing, (Ptr{JNIEnv}, jstring, Ptr{jchar},), ppenv[], str, chars) +ReleaseStringChars(str::jstring, chars::Array{jchar,1}, penv=ppenv[]) = + ccall(jniref[].ReleaseStringChars, Nothing, (Ptr{JNIEnv}, jstring, Ptr{jchar},), penv, str, chars) -NewStringUTF(utf::AnyString) = - ccall(jniref[].NewStringUTF, jstring, (Ptr{JNIEnv}, Cstring,), ppenv[], utf) +NewStringUTF(utf::AnyString, penv=ppenv[]) = + ccall(jniref[].NewStringUTF, jstring, (Ptr{JNIEnv}, Cstring,), penv, utf) -GetStringUTFLength(str::jstring) = - ccall(jniref[].GetStringUTFLength, jsize, (Ptr{JNIEnv}, jstring,), ppenv[], str) +GetStringUTFLength(str::jstring, penv=ppenv[]) = + ccall(jniref[].GetStringUTFLength, jsize, (Ptr{JNIEnv}, jstring,), penv, str) -GetStringUTFChars(str::jstring, isCopy::PtrIsCopy) = - ccall(jniref[].GetStringUTFChars, Cstring, (Ptr{JNIEnv}, jstring, Ptr{jboolean},), ppenv[], str, isCopy) +GetStringUTFChars(str::jstring, isCopy::PtrIsCopy, penv=ppenv[]) = + ccall(jniref[].GetStringUTFChars, Cstring, (Ptr{JNIEnv}, jstring, Ptr{jboolean},), penv, str, isCopy) ## Prior to this module we used UInt8 instead of Cstring, must match return value of above -#ReleaseStringUTFChars(str::jstring, chars::Ptr{UInt8}) = -# ccall(jniref[].ReleaseStringUTFChars, Nothing, (Ptr{JNIEnv}, jstring, Ptr{UInt8},), ppenv[], str, chars) -ReleaseStringUTFChars(str::jstring, chars::AnyString) = - ccall(jniref[].ReleaseStringUTFChars, Nothing, (Ptr{JNIEnv}, jstring, Cstring,), ppenv[], str, chars) +#ReleaseStringUTFChars(str::jstring, chars::Ptr{UInt8}, penv=ppenv[]) = +# ccall(jniref[].ReleaseStringUTFChars, Nothing, (Ptr{JNIEnv}, jstring, Ptr{UInt8},), penv, str, chars) +ReleaseStringUTFChars(str::jstring, chars::AnyString, penv=ppenv[]) = + ccall(jniref[].ReleaseStringUTFChars, Nothing, (Ptr{JNIEnv}, jstring, Cstring,), penv, str, chars) -GetArrayLength(array::jarray) = - ccall(jniref[].GetArrayLength, jsize, (Ptr{JNIEnv}, jarray,), ppenv[], array) +GetArrayLength(array::jarray, penv=ppenv[]) = + ccall(jniref[].GetArrayLength, jsize, (Ptr{JNIEnv}, jarray,), penv, array) -NewObjectArray(len::Integer, clazz::jclass, init::jobject) = - ccall(jniref[].NewObjectArray, jobjectArray, (Ptr{JNIEnv}, jsize, jclass, jobject,), ppenv[], len, clazz, init) +NewObjectArray(len::Integer, clazz::jclass, init::jobject, penv=ppenv[]) = + ccall(jniref[].NewObjectArray, jobjectArray, (Ptr{JNIEnv}, jsize, jclass, jobject,), penv, len, clazz, init) -GetObjectArrayElement(array::jobjectArray, index::Integer) = - ccall(jniref[].GetObjectArrayElement, jobject, (Ptr{JNIEnv}, jobjectArray, jsize,), ppenv[], array, index) +GetObjectArrayElement(array::jobjectArray, index::Integer, penv=ppenv[]) = + ccall(jniref[].GetObjectArrayElement, jobject, (Ptr{JNIEnv}, jobjectArray, jsize,), penv, array, index) -SetObjectArrayElement(array::jobjectArray, index::Integer, val::jobject) = - ccall(jniref[].SetObjectArrayElement, Nothing, (Ptr{JNIEnv}, jobjectArray, jsize, jobject,), ppenv[], array, index, val) +SetObjectArrayElement(array::jobjectArray, index::Integer, val::jobject, penv=ppenv[]) = + ccall(jniref[].SetObjectArrayElement, Nothing, (Ptr{JNIEnv}, jobjectArray, jsize, jobject,), penv, array, index, val) -NewBooleanArray(len::Integer) = - ccall(jniref[].NewBooleanArray, jbooleanArray, (Ptr{JNIEnv}, jsize,), ppenv[], len) +NewBooleanArray(len::Integer, penv=ppenv[]) = + ccall(jniref[].NewBooleanArray, jbooleanArray, (Ptr{JNIEnv}, jsize,), penv, len) -NewByteArray(len::Integer) = - ccall(jniref[].NewByteArray, jbyteArray, (Ptr{JNIEnv}, jsize,), ppenv[], len) +NewByteArray(len::Integer, penv=ppenv[]) = + ccall(jniref[].NewByteArray, jbyteArray, (Ptr{JNIEnv}, jsize,), penv, len) -NewCharArray(len::Integer) = - ccall(jniref[].NewCharArray, jcharArray, (Ptr{JNIEnv}, jsize,), ppenv[], len) +NewCharArray(len::Integer, penv=ppenv[]) = + ccall(jniref[].NewCharArray, jcharArray, (Ptr{JNIEnv}, jsize,), penv, len) -NewShortArray(len::Integer) = - ccall(jniref[].NewShortArray, jshortArray, (Ptr{JNIEnv}, jsize,), ppenv[], len) +NewShortArray(len::Integer, penv=ppenv[]) = + ccall(jniref[].NewShortArray, jshortArray, (Ptr{JNIEnv}, jsize,), penv, len) -NewIntArray(len::Integer) = - ccall(jniref[].NewIntArray, jintArray, (Ptr{JNIEnv}, jsize,), ppenv[], len) +NewIntArray(len::Integer, penv=ppenv[]) = + ccall(jniref[].NewIntArray, jintArray, (Ptr{JNIEnv}, jsize,), penv, len) -NewLongArray(len::Integer) = - ccall(jniref[].NewLongArray, jlongArray, (Ptr{JNIEnv}, jsize,), ppenv[], len) +NewLongArray(len::Integer, penv=ppenv[]) = + ccall(jniref[].NewLongArray, jlongArray, (Ptr{JNIEnv}, jsize,), penv, len) -NewFloatArray(len::Integer) = - ccall(jniref[].NewFloatArray, jfloatArray, (Ptr{JNIEnv}, jsize,), ppenv[], len) +NewFloatArray(len::Integer, penv=ppenv[]) = + ccall(jniref[].NewFloatArray, jfloatArray, (Ptr{JNIEnv}, jsize,), penv, len) -NewDoubleArray(len::Integer) = - ccall(jniref[].NewDoubleArray, jdoubleArray, (Ptr{JNIEnv}, jsize,), ppenv[], len) +NewDoubleArray(len::Integer, penv=ppenv[]) = + ccall(jniref[].NewDoubleArray, jdoubleArray, (Ptr{JNIEnv}, jsize,), penv, len) -GetBooleanArrayElements(array::jbooleanArray, isCopy::PtrIsCopy) = - ccall(jniref[].GetBooleanArrayElements, Ptr{jboolean}, (Ptr{JNIEnv}, jbooleanArray, Ptr{jboolean},), ppenv[], array, isCopy) +GetBooleanArrayElements(array::jbooleanArray, isCopy::PtrIsCopy, penv=ppenv[]) = + ccall(jniref[].GetBooleanArrayElements, Ptr{jboolean}, (Ptr{JNIEnv}, jbooleanArray, Ptr{jboolean},), penv, array, isCopy) -GetByteArrayElements(array::jbyteArray, isCopy::PtrIsCopy) = - ccall(jniref[].GetByteArrayElements, Ptr{jbyte}, (Ptr{JNIEnv}, jbyteArray, Ptr{jboolean},), ppenv[], array, isCopy) +GetByteArrayElements(array::jbyteArray, isCopy::PtrIsCopy, penv=ppenv[]) = + ccall(jniref[].GetByteArrayElements, Ptr{jbyte}, (Ptr{JNIEnv}, jbyteArray, Ptr{jboolean},), penv, array, isCopy) -GetCharArrayElements(array::jcharArray, isCopy::PtrIsCopy) = - ccall(jniref[].GetCharArrayElements, Ptr{jchar}, (Ptr{JNIEnv}, jcharArray, Ptr{jboolean},), ppenv[], array, isCopy) +GetCharArrayElements(array::jcharArray, isCopy::PtrIsCopy, penv=ppenv[]) = + ccall(jniref[].GetCharArrayElements, Ptr{jchar}, (Ptr{JNIEnv}, jcharArray, Ptr{jboolean},), penv, array, isCopy) -GetShortArrayElements(array::jshortArray, isCopy::PtrIsCopy) = - ccall(jniref[].GetShortArrayElements, Ptr{jshort}, (Ptr{JNIEnv}, jshortArray, Ptr{jboolean},), ppenv[], array, isCopy) +GetShortArrayElements(array::jshortArray, isCopy::PtrIsCopy, penv=ppenv[]) = + ccall(jniref[].GetShortArrayElements, Ptr{jshort}, (Ptr{JNIEnv}, jshortArray, Ptr{jboolean},), penv, array, isCopy) -GetIntArrayElements(array::jintArray, isCopy::PtrIsCopy) = - ccall(jniref[].GetIntArrayElements, Ptr{jint}, (Ptr{JNIEnv}, jintArray, Ptr{jboolean},), ppenv[], array, isCopy) +GetIntArrayElements(array::jintArray, isCopy::PtrIsCopy, penv=ppenv[]) = + ccall(jniref[].GetIntArrayElements, Ptr{jint}, (Ptr{JNIEnv}, jintArray, Ptr{jboolean},), penv, array, isCopy) -GetLongArrayElements(array::jlongArray, isCopy::PtrIsCopy) = - ccall(jniref[].GetLongArrayElements, Ptr{jlong}, (Ptr{JNIEnv}, jlongArray, Ptr{jboolean},), ppenv[], array, isCopy) +GetLongArrayElements(array::jlongArray, isCopy::PtrIsCopy, penv=ppenv[]) = + ccall(jniref[].GetLongArrayElements, Ptr{jlong}, (Ptr{JNIEnv}, jlongArray, Ptr{jboolean},), penv, array, isCopy) -GetFloatArrayElements(array::jfloatArray, isCopy::PtrIsCopy) = - ccall(jniref[].GetFloatArrayElements, Ptr{jfloat}, (Ptr{JNIEnv}, jfloatArray, Ptr{jboolean},), ppenv[], array, isCopy) +GetFloatArrayElements(array::jfloatArray, isCopy::PtrIsCopy, penv=ppenv[]) = + ccall(jniref[].GetFloatArrayElements, Ptr{jfloat}, (Ptr{JNIEnv}, jfloatArray, Ptr{jboolean},), penv, array, isCopy) -GetDoubleArrayElements(array::jdoubleArray, isCopy::PtrIsCopy) = - ccall(jniref[].GetDoubleArrayElements, Ptr{jdouble}, (Ptr{JNIEnv}, jdoubleArray, Ptr{jboolean},), ppenv[], array, isCopy) +GetDoubleArrayElements(array::jdoubleArray, isCopy::PtrIsCopy, penv=ppenv[]) = + ccall(jniref[].GetDoubleArrayElements, Ptr{jdouble}, (Ptr{JNIEnv}, jdoubleArray, Ptr{jboolean},), penv, array, isCopy) -ReleaseBooleanArrayElements(array::jbooleanArray, elems::Ptr{jboolean}, mode::jint) = - ccall(jniref[].ReleaseBooleanArrayElements, Nothing, (Ptr{JNIEnv}, jbooleanArray, Ptr{jboolean}, jint,), ppenv[], array, elems, mode) +ReleaseBooleanArrayElements(array::jbooleanArray, elems::Ptr{jboolean}, mode::jint, penv=ppenv[]) = + ccall(jniref[].ReleaseBooleanArrayElements, Nothing, (Ptr{JNIEnv}, jbooleanArray, Ptr{jboolean}, jint,), penv, array, elems, mode) -ReleaseByteArrayElements(array::jbyteArray, elems::Ptr{jbyte}, mode::jint) = - ccall(jniref[].ReleaseByteArrayElements, Nothing, (Ptr{JNIEnv}, jbyteArray, Ptr{jbyte}, jint,), ppenv[], array, elems, mode) +ReleaseByteArrayElements(array::jbyteArray, elems::Ptr{jbyte}, mode::jint, penv=ppenv[]) = + ccall(jniref[].ReleaseByteArrayElements, Nothing, (Ptr{JNIEnv}, jbyteArray, Ptr{jbyte}, jint,), penv, array, elems, mode) -ReleaseCharArrayElements(array::jcharArray, elems::Ptr{jchar}, mode::jint) = - ccall(jniref[].ReleaseCharArrayElements, Nothing, (Ptr{JNIEnv}, jcharArray, Ptr{jchar}, jint,), ppenv[], array, elems, mode) +ReleaseCharArrayElements(array::jcharArray, elems::Ptr{jchar}, mode::jint, penv=ppenv[]) = + ccall(jniref[].ReleaseCharArrayElements, Nothing, (Ptr{JNIEnv}, jcharArray, Ptr{jchar}, jint,), penv, array, elems, mode) -ReleaseShortArrayElements(array::jshortArray, elems::Ptr{jshort}, mode::jint) = - ccall(jniref[].ReleaseShortArrayElements, Nothing, (Ptr{JNIEnv}, jshortArray, Ptr{jshort}, jint,), ppenv[], array, elems, mode) +ReleaseShortArrayElements(array::jshortArray, elems::Ptr{jshort}, mode::jint, penv=ppenv[]) = + ccall(jniref[].ReleaseShortArrayElements, Nothing, (Ptr{JNIEnv}, jshortArray, Ptr{jshort}, jint,), penv, array, elems, mode) -ReleaseIntArrayElements(array::jintArray, elems::Ptr{jint}, mode::jint) = - ccall(jniref[].ReleaseIntArrayElements, Nothing, (Ptr{JNIEnv}, jintArray, Ptr{jint}, jint,), ppenv[], array, elems, mode) +ReleaseIntArrayElements(array::jintArray, elems::Ptr{jint}, mode::jint, penv=ppenv[]) = + ccall(jniref[].ReleaseIntArrayElements, Nothing, (Ptr{JNIEnv}, jintArray, Ptr{jint}, jint,), penv, array, elems, mode) -ReleaseLongArrayElements(array::jlongArray, elems::Ptr{jlong}, mode::jint) = - ccall(jniref[].ReleaseLongArrayElements, Nothing, (Ptr{JNIEnv}, jlongArray, Ptr{jlong}, jint,), ppenv[], array, elems, mode) +ReleaseLongArrayElements(array::jlongArray, elems::Ptr{jlong}, mode::jint, penv=ppenv[]) = + ccall(jniref[].ReleaseLongArrayElements, Nothing, (Ptr{JNIEnv}, jlongArray, Ptr{jlong}, jint,), penv, array, elems, mode) -ReleaseFloatArrayElements(array::jfloatArray, elems::Ptr{jfloat}, mode::jint) = - ccall(jniref[].ReleaseFloatArrayElements, Nothing, (Ptr{JNIEnv}, jfloatArray, Ptr{jfloat}, jint,), ppenv[], array, elems, mode) +ReleaseFloatArrayElements(array::jfloatArray, elems::Ptr{jfloat}, mode::jint, penv=ppenv[]) = + ccall(jniref[].ReleaseFloatArrayElements, Nothing, (Ptr{JNIEnv}, jfloatArray, Ptr{jfloat}, jint,), penv, array, elems, mode) -ReleaseDoubleArrayElements(array::jdoubleArray, elems::Ptr{jdouble}, mode::jint) = - ccall(jniref[].ReleaseDoubleArrayElements, Nothing, (Ptr{JNIEnv}, jdoubleArray, Ptr{jdouble}, jint,), ppenv[], array, elems, mode) +ReleaseDoubleArrayElements(array::jdoubleArray, elems::Ptr{jdouble}, mode::jint, penv=ppenv[]) = + ccall(jniref[].ReleaseDoubleArrayElements, Nothing, (Ptr{JNIEnv}, jdoubleArray, Ptr{jdouble}, jint,), penv, array, elems, mode) -GetBooleanArrayRegion(array::jbooleanArray, start::Integer, l::Integer, buf::Array{jboolean,1}) = - ccall(jniref[].GetBooleanArrayRegion, Nothing, (Ptr{JNIEnv}, jbooleanArray, jsize, jsize, Ptr{jboolean},), ppenv[], array, start, l, buf) +GetBooleanArrayRegion(array::jbooleanArray, start::Integer, l::Integer, buf::Array{jboolean,1}, penv=ppenv[]) = + ccall(jniref[].GetBooleanArrayRegion, Nothing, (Ptr{JNIEnv}, jbooleanArray, jsize, jsize, Ptr{jboolean},), penv, array, start, l, buf) -GetByteArrayRegion(array::jbyteArray, start::Integer, len::Integer, buf::Array{jbyte,1}) = - ccall(jniref[].GetByteArrayRegion, Nothing, (Ptr{JNIEnv}, jbyteArray, jsize, jsize, Ptr{jbyte},), ppenv[], array, start, len, buf) +GetByteArrayRegion(array::jbyteArray, start::Integer, len::Integer, buf::Array{jbyte,1}, penv=ppenv[]) = + ccall(jniref[].GetByteArrayRegion, Nothing, (Ptr{JNIEnv}, jbyteArray, jsize, jsize, Ptr{jbyte},), penv, array, start, len, buf) -GetCharArrayRegion(array::jcharArray, start::Integer, len::Integer, buf::Array{jchar,1}) = - ccall(jniref[].GetCharArrayRegion, Nothing, (Ptr{JNIEnv}, jcharArray, jsize, jsize, Ptr{jchar},), ppenv[], array, start, len, buf) +GetCharArrayRegion(array::jcharArray, start::Integer, len::Integer, buf::Array{jchar,1}, penv=ppenv[]) = + ccall(jniref[].GetCharArrayRegion, Nothing, (Ptr{JNIEnv}, jcharArray, jsize, jsize, Ptr{jchar},), penv, array, start, len, buf) -GetShortArrayRegion(array::jshortArray, start::Integer, len::Integer, buf::Array{jshort,1}) = - ccall(jniref[].GetShortArrayRegion, Nothing, (Ptr{JNIEnv}, jshortArray, jsize, jsize, Ptr{jshort},), ppenv[], array, start, len, buf) +GetShortArrayRegion(array::jshortArray, start::Integer, len::Integer, buf::Array{jshort,1}, penv=ppenv[]) = + ccall(jniref[].GetShortArrayRegion, Nothing, (Ptr{JNIEnv}, jshortArray, jsize, jsize, Ptr{jshort},), penv, array, start, len, buf) -GetIntArrayRegion(array::jintArray, start::Integer, len::Integer, buf::Array{jint,1}) = - ccall(jniref[].GetIntArrayRegion, Nothing, (Ptr{JNIEnv}, jintArray, jsize, jsize, Ptr{jint},), ppenv[], array, start, len, buf) +GetIntArrayRegion(array::jintArray, start::Integer, len::Integer, buf::Array{jint,1}, penv=ppenv[]) = + ccall(jniref[].GetIntArrayRegion, Nothing, (Ptr{JNIEnv}, jintArray, jsize, jsize, Ptr{jint},), penv, array, start, len, buf) -GetLongArrayRegion(array::jlongArray, start::Integer, len::Integer, buf::Array{jlong,1}) = - ccall(jniref[].GetLongArrayRegion, Nothing, (Ptr{JNIEnv}, jlongArray, jsize, jsize, Ptr{jlong},), ppenv[], array, start, len, buf) +GetLongArrayRegion(array::jlongArray, start::Integer, len::Integer, buf::Array{jlong,1}, penv=ppenv[]) = + ccall(jniref[].GetLongArrayRegion, Nothing, (Ptr{JNIEnv}, jlongArray, jsize, jsize, Ptr{jlong},), penv, array, start, len, buf) -GetFloatArrayRegion(array::jfloatArray, start::Integer, len::Integer, buf::Array{jfloat,1}) = - ccall(jniref[].GetFloatArrayRegion, Nothing, (Ptr{JNIEnv}, jfloatArray, jsize, jsize, Ptr{jfloat},), ppenv[], array, start, len, buf) +GetFloatArrayRegion(array::jfloatArray, start::Integer, len::Integer, buf::Array{jfloat,1}, penv=ppenv[]) = + ccall(jniref[].GetFloatArrayRegion, Nothing, (Ptr{JNIEnv}, jfloatArray, jsize, jsize, Ptr{jfloat},), penv, array, start, len, buf) -GetDoubleArrayRegion(array::jdoubleArray, start::Integer, len::Integer, buf::Array{jdouble,1}) = - ccall(jniref[].GetDoubleArrayRegion, Nothing, (Ptr{JNIEnv}, jdoubleArray, jsize, jsize, Ptr{jdouble},), ppenv[], array, start, len, buf) +GetDoubleArrayRegion(array::jdoubleArray, start::Integer, len::Integer, buf::Array{jdouble,1}, penv=ppenv[]) = + ccall(jniref[].GetDoubleArrayRegion, Nothing, (Ptr{JNIEnv}, jdoubleArray, jsize, jsize, Ptr{jdouble},), penv, array, start, len, buf) -SetBooleanArrayRegion(array::jbooleanArray, start::Integer, l::Integer, buf::Array{jboolean,1}) = - ccall(jniref[].SetBooleanArrayRegion, Nothing, (Ptr{JNIEnv}, jbooleanArray, jsize, jsize, Ptr{jboolean},), ppenv[], array, start, l, buf) +SetBooleanArrayRegion(array::jbooleanArray, start::Integer, l::Integer, buf::Array{jboolean,1}, penv=ppenv[]) = + ccall(jniref[].SetBooleanArrayRegion, Nothing, (Ptr{JNIEnv}, jbooleanArray, jsize, jsize, Ptr{jboolean},), penv, array, start, l, buf) -SetByteArrayRegion(array::jbyteArray, start::Integer, len::Integer, buf::Array{jbyte,1}) = - ccall(jniref[].SetByteArrayRegion, Nothing, (Ptr{JNIEnv}, jbyteArray, jsize, jsize, Ptr{jbyte},), ppenv[], array, start, len, buf) +SetByteArrayRegion(array::jbyteArray, start::Integer, len::Integer, buf::Array{jbyte,1}, penv=ppenv[]) = + ccall(jniref[].SetByteArrayRegion, Nothing, (Ptr{JNIEnv}, jbyteArray, jsize, jsize, Ptr{jbyte},), penv, array, start, len, buf) -SetCharArrayRegion(array::jcharArray, start::Integer, len::Integer, buf::Array{jchar,1}) = - ccall(jniref[].SetCharArrayRegion, Nothing, (Ptr{JNIEnv}, jcharArray, jsize, jsize, Ptr{jchar},), ppenv[], array, start, len, buf) +SetCharArrayRegion(array::jcharArray, start::Integer, len::Integer, buf::Array{jchar,1}, penv=ppenv[]) = + ccall(jniref[].SetCharArrayRegion, Nothing, (Ptr{JNIEnv}, jcharArray, jsize, jsize, Ptr{jchar},), penv, array, start, len, buf) -SetShortArrayRegion(array::jshortArray, start::Integer, len::Integer, buf::Array{jshort,1}) = - ccall(jniref[].SetShortArrayRegion, Nothing, (Ptr{JNIEnv}, jshortArray, jsize, jsize, Ptr{jshort},), ppenv[], array, start, len, buf) +SetShortArrayRegion(array::jshortArray, start::Integer, len::Integer, buf::Array{jshort,1}, penv=ppenv[]) = + ccall(jniref[].SetShortArrayRegion, Nothing, (Ptr{JNIEnv}, jshortArray, jsize, jsize, Ptr{jshort},), penv, array, start, len, buf) -SetIntArrayRegion(array::jintArray, start::Integer, len::Integer, buf::Array{jint,1}) = - ccall(jniref[].SetIntArrayRegion, Nothing, (Ptr{JNIEnv}, jintArray, jsize, jsize, Ptr{jint},), ppenv[], array, start, len, buf) +SetIntArrayRegion(array::jintArray, start::Integer, len::Integer, buf::Array{jint,1}, penv=ppenv[]) = + ccall(jniref[].SetIntArrayRegion, Nothing, (Ptr{JNIEnv}, jintArray, jsize, jsize, Ptr{jint},), penv, array, start, len, buf) -SetLongArrayRegion(array::jlongArray, start::Integer, len::Integer, buf::Array{jlong,1}) = - ccall(jniref[].SetLongArrayRegion, Nothing, (Ptr{JNIEnv}, jlongArray, jsize, jsize, Ptr{jlong},), ppenv[], array, start, len, buf) +SetLongArrayRegion(array::jlongArray, start::Integer, len::Integer, buf::Array{jlong,1}, penv=ppenv[]) = + ccall(jniref[].SetLongArrayRegion, Nothing, (Ptr{JNIEnv}, jlongArray, jsize, jsize, Ptr{jlong},), penv, array, start, len, buf) -SetFloatArrayRegion(array::jfloatArray, start::Integer, len::Integer, buf::Array{jfloat,1}) = - ccall(jniref[].SetFloatArrayRegion, Nothing, (Ptr{JNIEnv}, jfloatArray, jsize, jsize, Ptr{jfloat},), ppenv[], array, start, len, buf) +SetFloatArrayRegion(array::jfloatArray, start::Integer, len::Integer, buf::Array{jfloat,1}, penv=ppenv[]) = + ccall(jniref[].SetFloatArrayRegion, Nothing, (Ptr{JNIEnv}, jfloatArray, jsize, jsize, Ptr{jfloat},), penv, array, start, len, buf) -SetDoubleArrayRegion(array::jdoubleArray, start::Integer, len::Integer, buf::Array{jdouble,1}) = - ccall(jniref[].SetDoubleArrayRegion, Nothing, (Ptr{JNIEnv}, jdoubleArray, jsize, jsize, Ptr{jdouble},), ppenv[], array, start, len, buf) +SetDoubleArrayRegion(array::jdoubleArray, start::Integer, len::Integer, buf::Array{jdouble,1}, penv=ppenv[]) = + ccall(jniref[].SetDoubleArrayRegion, Nothing, (Ptr{JNIEnv}, jdoubleArray, jsize, jsize, Ptr{jdouble},), penv, array, start, len, buf) -RegisterNatives(clazz::jclass, methods::Array{JNINativeMethod,1}, nMethods::jint) = - ccall(jniref[].RegisterNatives, jint, (Ptr{JNIEnv}, jclass, Ptr{JNINativeMethod}, jint,), ppenv[], clazz, methods, nMethods) +RegisterNatives(clazz::jclass, methods::Array{JNINativeMethod,1}, nMethods::jint, penv=ppenv[]) = + ccall(jniref[].RegisterNatives, jint, (Ptr{JNIEnv}, jclass, Ptr{JNINativeMethod}, jint,), penv, clazz, methods, nMethods) -UnregisterNatives(clazz::jclass) = - ccall(jniref[].UnregisterNatives, jint, (Ptr{JNIEnv}, jclass,), ppenv[], clazz) +UnregisterNatives(clazz::jclass, penv=ppenv[]) = + ccall(jniref[].UnregisterNatives, jint, (Ptr{JNIEnv}, jclass,), penv, clazz) -MonitorEnter(obj::jobject) = - ccall(jniref[].MonitorEnter, jint, (Ptr{JNIEnv}, jobject,), ppenv[], obj) +MonitorEnter(obj::jobject, penv=ppenv[]) = + ccall(jniref[].MonitorEnter, jint, (Ptr{JNIEnv}, jobject,), penv, obj) -MonitorExit(obj::jobject) = - ccall(jniref[].MonitorExit, jint, (Ptr{JNIEnv}, jobject,), ppenv[], obj) +MonitorExit(obj::jobject, penv=ppenv[]) = + ccall(jniref[].MonitorExit, jint, (Ptr{JNIEnv}, jobject,), penv, obj) -GetJavaVM(vm::Array{JavaVM,1}) = - ccall(jniref[].GetJavaVM, jint, (Ptr{JNIEnv}, Array{JavaVM,1},), ppenv[], vm) +GetJavaVM(vm::Array{JavaVM,1}, penv=ppenv[]) = + ccall(jniref[].GetJavaVM, jint, (Ptr{JNIEnv}, Array{JavaVM,1},), penv, vm) -GetStringRegion(str::jstring, start::Integer, len::Integer, buf::Array{jchar,1}) = - ccall(jniref[].GetStringRegion, Nothing, (Ptr{JNIEnv}, jstring, jsize, jsize, Ptr{jchar},), ppenv[], str, start, len, buf) +GetStringRegion(str::jstring, start::Integer, len::Integer, buf::Array{jchar,1}, penv=ppenv[]) = + ccall(jniref[].GetStringRegion, Nothing, (Ptr{JNIEnv}, jstring, jsize, jsize, Ptr{jchar},), penv, str, start, len, buf) -GetStringUTFRegion(str::jstring, start::Integer, len::Integer, buf::AnyString) = - ccall(jniref[].GetStringUTFRegion, Nothing, (Ptr{JNIEnv}, jstring, jsize, jsize, Cstring,), ppenv[], str, start, len, buf) +GetStringUTFRegion(str::jstring, start::Integer, len::Integer, buf::AnyString, penv=ppenv[]) = + ccall(jniref[].GetStringUTFRegion, Nothing, (Ptr{JNIEnv}, jstring, jsize, jsize, Cstring,), penv, str, start, len, buf) -GetPrimitiveArrayCritical(array::jarray, isCopy::PtrIsCopy) = - ccall(jniref[].GetPrimitiveArrayCritical, Ptr{Nothing}, (Ptr{JNIEnv}, jarray, Ptr{jboolean},), ppenv[], array, isCopy) +GetPrimitiveArrayCritical(array::jarray, isCopy::PtrIsCopy, penv=ppenv[]) = + ccall(jniref[].GetPrimitiveArrayCritical, Ptr{Nothing}, (Ptr{JNIEnv}, jarray, Ptr{jboolean},), penv, array, isCopy) -ReleasePrimitiveArrayCritical(array::jarray, carray::Ptr{Nothing}, mode::jint) = - ccall(jniref[].ReleasePrimitiveArrayCritical, Nothing, (Ptr{JNIEnv}, jarray, Ptr{Nothing}, jint,), ppenv[], array, carray, mode) +ReleasePrimitiveArrayCritical(array::jarray, carray::Ptr{Nothing}, mode::jint, penv=ppenv[]) = + ccall(jniref[].ReleasePrimitiveArrayCritical, Nothing, (Ptr{JNIEnv}, jarray, Ptr{Nothing}, jint,), penv, array, carray, mode) -GetStringCritical(string::jstring, isCopy::PtrIsCopy) = - ccall(jniref[].GetStringCritical, Ptr{jchar}, (Ptr{JNIEnv}, jstring, Ptr{jboolean},), ppenv[], string, isCopy) +GetStringCritical(string::jstring, isCopy::PtrIsCopy, penv=ppenv[]) = + ccall(jniref[].GetStringCritical, Ptr{jchar}, (Ptr{JNIEnv}, jstring, Ptr{jboolean},), penv, string, isCopy) -ReleaseStringCritical(string::jstring, cstring::Array{jchar,1}) = - ccall(jniref[].ReleaseStringCritical, Nothing, (Ptr{JNIEnv}, jstring, Ptr{jchar},), ppenv[], string, cstring) +ReleaseStringCritical(string::jstring, cstring::Array{jchar,1}, penv=ppenv[]) = + ccall(jniref[].ReleaseStringCritical, Nothing, (Ptr{JNIEnv}, jstring, Ptr{jchar},), penv, string, cstring) -NewWeakGlobalRef(obj::jobject) = - ccall(jniref[].NewWeakGlobalRef, jweak, (Ptr{JNIEnv}, jobject,), ppenv[], obj) +NewWeakGlobalRef(obj::jobject, penv=ppenv[]) = + ccall(jniref[].NewWeakGlobalRef, jweak, (Ptr{JNIEnv}, jobject,), penv, obj) -DeleteWeakGlobalRef(ref::jweak) = - ccall(jniref[].DeleteWeakGlobalRef, Nothing, (Ptr{JNIEnv}, jweak,), ppenv[], ref) +DeleteWeakGlobalRef(ref::jweak, penv=ppenv[]) = + ccall(jniref[].DeleteWeakGlobalRef, Nothing, (Ptr{JNIEnv}, jweak,), penv, ref) -ExceptionCheck() = - ccall(jniref[].ExceptionCheck, jboolean, (Ptr{JNIEnv},), ppenv[]) +ExceptionCheck(penv=ppenv[]) = + ccall(jniref[].ExceptionCheck, jboolean, (Ptr{JNIEnv},), penv) -NewDirectByteBuffer(address::Ptr{Nothing}, capacity::jlong) = - ccall(jniref[].NewDirectByteBuffer, jobject, (Ptr{JNIEnv}, Ptr{Nothing}, jlong,), ppenv[], address, capacity) +NewDirectByteBuffer(address::Ptr{Nothing}, capacity::jlong, penv=ppenv[]) = + ccall(jniref[].NewDirectByteBuffer, jobject, (Ptr{JNIEnv}, Ptr{Nothing}, jlong,), penv, address, capacity) -GetDirectBufferAddress(buf::jobject) = - ccall(jniref[].GetDirectBufferAddress, Ptr{Nothing}, (Ptr{JNIEnv}, jobject,), ppenv[], buf) +GetDirectBufferAddress(buf::jobject, penv=ppenv[]) = + ccall(jniref[].GetDirectBufferAddress, Ptr{Nothing}, (Ptr{JNIEnv}, jobject,), penv, buf) -GetDirectBufferCapacity(buf::jobject) = - ccall(jniref[].GetDirectBufferCapacity, jlong, (Ptr{JNIEnv}, jobject,), ppenv[], buf) +GetDirectBufferCapacity(buf::jobject, penv=ppenv[]) = + ccall(jniref[].GetDirectBufferCapacity, jlong, (Ptr{JNIEnv}, jobject,), penv, buf) -GetObjectRefType(obj::jobject) = - ccall(jniref[].GetObjectRefType, jobjectRefType, (Ptr{JNIEnv}, jobject,), ppenv[], obj) +GetObjectRefType(obj::jobject, penv=ppenv[]) = + ccall(jniref[].GetObjectRefType, jobjectRefType, (Ptr{JNIEnv}, jobject,), penv, obj) # === Above Generated by make_jni2.jl === diff --git a/src/make_jni2.jl b/src/make_jni2.jl index 24a22fe..af76fdf 100644 --- a/src/make_jni2.jl +++ b/src/make_jni2.jl @@ -18,7 +18,7 @@ end function arg_value(m) #if m.captures[2] == "*" && m.captures[1] == "char" return "String($(m.captures[3]))" end if m.captures[3] == "env" - "penv[]" + "penv" else m.captures[3] end @@ -117,7 +117,7 @@ for line in open(readlines, "jnienv.jl", "r") mm = map(x->match(r"^\s* (?:const\s+)? \s* ((?:void|j\w+|char|JNI\w+|JavaVM)) \s*? (\**) \s* (\w+) \s*$"x, x), args) # skip the JNIEnv arg for julia since it is passed as a global to ccall - julia_args = join(map(julia_arg, mm)[2:end], ", ") + julia_args = join(push!(map(julia_arg, mm)[2:end],"penv=ppenv[]"), ", ") arg_types = join(map(ccall_arg_type, mm), ", ") arg_names = join(map(arg_value, mm), ", ")