jmethodID java_meth_id;
// retrieve the current JVM
- Sys sys = {{{mmodule.name}}}___Pointer_sys(NULL);
- JNIEnv *nit_ffi_jni_env = {{{mmodule.name}}}___Sys_jni_env(sys);
+ Sys sys = Pointer_sys(NULL);
+ JNIEnv *nit_ffi_jni_env = Sys_jni_env(sys);
// retrieve the implementation Java class
- java_class = {{{mmodule.name}}}___Sys_load_jclass(sys, "{{{mmodule.impl_java_class_name}}}");
+ java_class = Sys_load_jclass(sys, "{{{mmodule.impl_java_class_name}}}");
if (java_class == NULL) {
- fprintf(stderr, "Nit FFI with Java error: failed to load class.\\n");
+ PRINT_ERROR("Nit FFI with Java error: failed to load class.\\n");
(*nit_ffi_jni_env)->ExceptionDescribe(nit_ffi_jni_env);
exit(1);
}
// retreive the implementation static function
java_meth_id = (*nit_ffi_jni_env)->GetStaticMethodID(nit_ffi_jni_env, java_class, "{{{java_fun_name}}}", "{{{jni_format}}}");
if (java_meth_id == NULL) {
- fprintf(stderr, "Nit FFI with Java error: Java implementation not found.\\n");
+ PRINT_ERROR("Nit FFI with Java error: Java implementation not found.\\n");
(*nit_ffi_jni_env)->ExceptionDescribe(nit_ffi_jni_env);
exit(1);
}
end
end
- for p in signature.mparameters do params.add(p.name)
+ for p in signature.mparameters do
+ var param_mtype = p.mtype
+ param_mtype = param_mtype.resolve_for(mclass_type, mclass_type, mmodule, true)
+ params.add(to_java_call_context.cast_to(param_mtype, p.name))
+ end
var cname = "(*nit_ffi_jni_env)->CallStatic{jni_signature_alt}Method"
var ccall
// execute implementation code
{{{ccall}}}
if ((*nit_ffi_jni_env)->ExceptionCheck(nit_ffi_jni_env)) {
- fprintf(stderr, "Nit FFI with Java error: Exception after call.\\n");
+ PRINT_ERROR("Nit FFI with Java error: Exception after call.\\n");
(*nit_ffi_jni_env)->ExceptionDescribe(nit_ffi_jni_env);
exit(1);
}
mmodule.insert_compiler_options
# Enable linking C callbacks to java native methods
- mmodule.ensure_linking_callback_methods(ffi_ccu, mmodule.ffi_callbacks[self])
+ mmodule.ensure_linking_callback_methods(ffi_ccu.as(not null), mmodule.ffi_callbacks[self])
# Java implementation code
var java_file = mmodule.java_file
mmodule.ffi_files.add(extern_java_file)
end
- var ffi_ccu: CCompilationUnit # HACK
+ var ffi_ccu: nullable CCompilationUnit = null # HACK
redef fun compile_callback(callback, mmodule, mainmodule, ccu)
do
ffi_ccu = ccu
- callback.compile_callback_to_java(mmodule, ccu)
+ callback.compile_callback_to_java(mmodule, mainmodule, ccu)
end
end
};
jint res = (*env)->RegisterNatives(env, jclazz, methods, n_methods);
if (res != JNI_OK) {
- fprintf(stderr, "RegisterNatives failed\\n");
+ PRINT_ERROR("RegisterNatives failed\\n");
(*env)->ExceptionDescribe(env);
exit(1);
}
var modelbuilder = toolcontext.modelbuilder
var mmodule = mpropdef.mclassdef.mmodule
+ # We use callbacks from the C FFI since they will be called from generated C
+ var c_language_visitor = toolcontext.ffi_language_assignation_phase.as(FFILanguageAssignationPhase).c_language
+ if not mmodule.ffi_callbacks.keys.has(c_language_visitor) then
+ mmodule.ffi_callbacks[c_language_visitor] = new HashSet[NitniCallback]
+ end
+
# Pointer::sys
var pointer_class = modelbuilder.try_get_mclass_by_name(self, mmodule, "Pointer")
assert pointer_class != null
var explicit_call = new MExplicitCall(pointer_class.mclass_type, pointer_sys_meth, mmodule)
fcc.callbacks.add(explicit_call)
- explicit_call.fill_type_for(fcc, mmodule)
+ mmodule.ffi_callbacks[c_language_visitor].add(explicit_call)
# Sys::jni_env
var sys_class = modelbuilder.try_get_mclass_by_name(self, mmodule, "Sys")
assert sys_class != null
var sys_jni_env_meth = modelbuilder.try_get_mproperty_by_name2(self, mmodule, sys_class.mclass_type, "jni_env")
- assert sys_jni_env_meth != null
- assert sys_jni_env_meth isa MMethod
+ if sys_jni_env_meth == null or not sys_jni_env_meth isa MMethod then
+ toolcontext.error(self.location, "Java FFI error: you must import the `java` module when using the FFI with Java")
+ return
+ end
explicit_call = new MExplicitCall(sys_class.mclass_type, sys_jni_env_meth, mmodule)
fcc.callbacks.add(explicit_call)
- explicit_call.fill_type_for(fcc, mmodule)
+ mmodule.ffi_callbacks[c_language_visitor].add(explicit_call)
# Sys::load_jclass
var sys_jni_load_jclass_meth = modelbuilder.try_get_mproperty_by_name2(self, mmodule, sys_class.mclass_type, "load_jclass")
explicit_call = new MExplicitCall(sys_class.mclass_type, sys_jni_load_jclass_meth, mmodule)
fcc.callbacks.add(explicit_call)
+ mmodule.ffi_callbacks[c_language_visitor].add(explicit_call)
explicit_call.fill_type_for(fcc, mmodule)
end
end
super ExternFile
redef fun makefile_rule_name do return "{filename.basename(".java")}.class"
- redef fun makefile_rule_content do return "javac {filename} -d ."
+ redef fun makefile_rule_content do return "javac {filename.basename("")} -d ."
redef fun add_to_jar do return true
end
redef class NitniCallback
# Compile C and Java code to implement this callback
- fun compile_callback_to_java(mmodule: MModule, ccu: CCompilationUnit) do end
+ fun compile_callback_to_java(mmodule: MModule, mainmodule: MModule, ccu: CCompilationUnit) do end
# Returns the list of C functions to link with extern Java methods, as required
# to enable this callback from Java code.
end
redef class MExplicitCall
- redef fun compile_callback_to_java(mmodule, ccu)
+ redef fun compile_callback_to_java(mmodule, mainmodule, ccu)
do
var mproperty = mproperty
assert mproperty isa MMethod
# In C, indirection implementing the Java extern methods
var csignature = mproperty.build_c_implementation_signature(recv_mtype, mmodule, "___indirect", long_signature, from_java_call_context)
var cf = new CFunction("JNIEXPORT {csignature}")
- cf.exprs.add "\t{mproperty.build_ccall(recv_mtype, mmodule, null, long_signature, from_java_call_context, null)}\n"
+ cf.exprs.add "\t{mproperty.build_ccall(recv_mtype, mainmodule, null, long_signature, from_java_call_context, null)}\n"
ccu.add_local_function cf
# In Java, declare the extern method as a private static local method
- var java_signature = mproperty.build_csignature(recv_mtype, mmodule, null, short_signature, java_call_context)
+ var java_signature = mproperty.build_csignature(recv_mtype, mainmodule, null, short_signature, java_call_context)
mmodule.java_file.class_content.add "private native static {java_signature};\n"
end
redef fun java_type
do
var ftype = mclass.ftype
- if ftype isa ForeignJavaType then return ftype.java_type
+ if ftype isa ForeignJavaType then return ftype.java_type.
+ replace('/', ".").replace('$', ".").replace(' ', "").replace('\n',"")
if mclass.name == "Bool" then return "boolean"
if mclass.name == "Char" then return "char"
- if mclass.name == "Int" then return "int"
+ if mclass.name == "Int" then return "long"
if mclass.name == "Float" then return "double"
return super
end
if ftype isa ForeignJavaType then return "jobject"
if mclass.name == "Bool" then return "jboolean"
if mclass.name == "Char" then return "jchar"
- if mclass.name == "Int" then return "jint"
+ if mclass.name == "Int" then return "jlong"
if mclass.name == "Float" then return "jdouble"
return super
end
redef fun jni_format
do
var ftype = mclass.ftype
- if ftype isa ForeignJavaType then return "L{ftype.java_type.replace('.', "/").replace(' ', "")};"
+ if ftype isa ForeignJavaType then
+ var ori_jni_type = jni_type
+ var jni_type = ftype.java_type.
+ replace('.', "/").replace(' ', "").replace('\n', "")
+
+ # Remove parameters of generic types
+ loop
+ var i = jni_type.last_index_of('<')
+ if i >= 0 then
+ var j = jni_type.index_of_from('>', i)
+ if j == -1 then
+ print "Error: missing closing '>' in extern Java type of \"{mclass.name}\""
+ exit 1
+ end
+ jni_type = jni_type.substring(0, i) +
+ jni_type.substring(j+1, jni_type.length)
+ else break
+ end
+
+ return "L{jni_type};"
+ end
if mclass.name == "Bool" then return "Z"
if mclass.name == "Char" then return "C"
- if mclass.name == "Int" then return "I"
+ if mclass.name == "Int" then return "J"
if mclass.name == "Float" then return "D"
return super
end
if ftype isa ForeignJavaType then return "Object"
if mclass.name == "Bool" then return "Boolean"
if mclass.name == "Char" then return "Char"
- if mclass.name == "Int" then return "Int"
+ if mclass.name == "Int" then return "Long"
if mclass.name == "Float" then return "Double"
return super
end
nitlanguage / nit.git / blobdiff