1 # This file is part of NIT ( http://www.nitlanguage.org ).
3 # Copyright 2013-2014 Alexis Laferrière <alexis.laf@xymus.net>
5 # Licensed under the Apache License, Version 2.0 (the "License");
6 # you may not use this file except in compliance with the License.
7 # You may obtain a copy of the License at
9 # http://www.apache.org/licenses/LICENSE-2.0
11 # Unless required by applicable law or agreed to in writing, software
12 # distributed under the License is distributed on an "AS IS" BASIS,
13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 # See the License for the specific language governing permissions and
15 # limitations under the License.
17 # FFI support for the Java language
19 # TODO support callbacks to super and casts
24 import c_compiler_options
26 redef class FFILanguageAssignationPhase
27 var java_language
: FFILanguage = new JavaLanguage(self)
33 redef fun identify_language
(n
) do return n
.is_java
35 redef fun compile_module_block
(block
, ccu
, mmodule
)
37 mmodule
.ensure_java_files
38 var java_file
= mmodule
.java_file
39 assert java_file
!= null
41 if block
.is_inner_java
then
42 java_file
.class_content
.add
(block
.code
)
43 else java_file
.header
.add
(block
.code
)
46 redef fun compile_extern_method
(block
, m
, ccu
, mmodule
)
49 mmodule
.ensure_java_files
50 var java_file
= mmodule
.java_file
51 assert java_file
!= null
53 var mclass_type
= m
.parent
.as(AClassdef).mclass
.mclass_type
54 var mmethodef
= m
.mpropdef
55 var mproperty
= m
.mpropdef
.mproperty
57 # C function calling the Java method through JNI
58 var fc
= new ExternCFunction(m
, mmodule
)
62 jmethodID java_meth_id;
64 // retrieve the current JVM
65 Sys sys = Pointer_sys(NULL);
66 JNIEnv *nit_ffi_jni_env = Sys_jni_env(sys);
68 // retrieve the implementation Java class
69 java_class = Sys_load_jclass(sys, "{{{mmodule.impl_java_class_name}}}");
70 if (java_class == NULL) {
71 PRINT_ERROR("Nit FFI with Java error: failed to load class.\\n");
72 (*nit_ffi_jni_env)->ExceptionDescribe(nit_ffi_jni_env);
76 // register callbacks (only once per Nit module)
77 if (!nit_ffi_with_java_registered_natives) nit_ffi_with_java_register_natives(nit_ffi_jni_env, java_class);
80 # Retrieve the Java implementation function id
81 var java_fun_name
= mproperty
.build_cname
(mclass_type
, mmodule
, "___java_impl", long_signature
)
82 var jni_format
= mproperty
.build_jni_format
(mclass_type
, mmodule
)
84 // retreive the implementation static function
85 java_meth_id = (*nit_ffi_jni_env)->GetStaticMethodID(nit_ffi_jni_env, java_class, "{{{java_fun_name}}}", "{{{jni_format}}}");
86 if (java_meth_id == NULL) {
87 PRINT_ERROR("Nit FFI with Java error: Java implementation not found.\\n");
88 (*nit_ffi_jni_env)->ExceptionDescribe(nit_ffi_jni_env);
93 # Call the C Java implementation method from C
94 var signature
= mmethodef
.msignature
95 assert signature
!= null
99 var params
= new Array[String]
100 params
.add
"nit_ffi_jni_env"
101 params
.add
"java_class"
102 params
.add
"java_meth_id"
104 if mproperty
.is_init
then
105 jni_signature_alt
= mclass_type
.jni_signature_alt
106 return_type
= mclass_type
108 params
.add to_java_call_context
.cast_to
(mclass_type
, "self")
109 if signature
.return_mtype
!= null then
110 var ret_mtype
= signature
.return_mtype
111 ret_mtype
= ret_mtype
.resolve_for
(mclass_type
, mclass_type
, mmodule
, true)
112 return_type
= signature
.return_mtype
113 jni_signature_alt
= return_type
.jni_signature_alt
115 jni_signature_alt
= "Void"
120 for p
in signature
.mparameters
do
121 var param_mtype
= p
.mtype
122 param_mtype
= param_mtype
.resolve_for
(mclass_type
, mclass_type
, mmodule
, true)
123 params
.add
(to_java_call_context
.cast_to
(param_mtype
, p
.name
))
126 var cname
= "(*nit_ffi_jni_env)->CallStatic{jni_signature_alt}Method"
128 if return_type
!= null then
129 ccall
= "{return_type.jni_type} jni_res = {cname}({params.join(", ")});"
130 else ccall
= "{cname}({params.join(", ")});"
133 // execute implementation code
135 if ((*nit_ffi_jni_env)->ExceptionCheck(nit_ffi_jni_env)) {
136 PRINT_ERROR("Nit FFI with Java error: Exception after call.\\n");
137 (*nit_ffi_jni_env)->ExceptionDescribe(nit_ffi_jni_env);
141 (*nit_ffi_jni_env)->DeleteLocalRef(nit_ffi_jni_env, java_class);
144 if return_type
!= null then
145 fc
.exprs
.add
"\treturn {to_java_call_context.cast_from(return_type, "jni_res")};"
148 ccu
.add_exported_function
( fc
)
150 # Java implementation function in Java
151 var java_csig
= mproperty
.build_csignature
(mclass_type
, mmodule
, "___java_impl", long_signature
, java_call_context
)
152 mmodule
.java_file
.class_content
.add
"""
153 public static {{{java_csig}}} {
154 // from Nit FII at: {{{block.location}}}
159 mmodule
.callbacks_used_from_java
.join m
.foreign_callbacks
162 redef fun compile_extern_class
(block
, m
, ccu
, mmodule
) do end
164 redef fun get_ftype
(block
, m
) do return new ForeignJavaType(block
.code
)
166 redef fun compile_to_files
(mmodule
, compdir
)
168 var ffi_ccu
= ffi_ccu
169 assert ffi_ccu
!= null
171 # Make sure we have a .java file
172 mmodule
.ensure_java_files
174 # Needed compiler and linker options
175 mmodule
.insert_compiler_options
177 # Enable linking C callbacks to java native methods
178 mmodule
.ensure_linking_callback_methods
(ffi_ccu
)
180 # Function to build instances to the Java class NitObject
181 var callbacks
= mmodule
.callbacks_used_from_java
.callbacks
182 if callbacks
.not_empty
then
183 var cf
= new CFunction("jobject nit_ffi_with_java_new_nit_object(JNIEnv *env, void *data)")
185 // retrieve the current JVM
186 Sys sys = Pointer_sys(NULL);
188 jclass java_class = Sys_load_jclass(sys, "nit/app/NitObject");
189 if (java_class == NULL) {
190 PRINT_ERROR("Nit FFI with Java error: failed to load class NitObject.\\n");
191 (*env)->ExceptionDescribe(env);
195 jmethodID java_init = (*env)->GetMethodID(env, java_class, "<init>", "(J)V");
196 if (java_init == NULL) {
197 PRINT_ERROR("Nit FFI with Java error: NitObject constructor not found.\\n");
198 (*env)->ExceptionDescribe(env);
202 jobject nit_object = (*env)->NewObject(env, java_class, java_init, (jlong)data);
203 if (nit_object == NULL) {
204 PRINT_ERROR("Nit FFI with Java error: NitObject construction failed.\\n");
205 (*env)->ExceptionDescribe(env);
211 ffi_ccu
.add_local_function cf
213 # Function to extract the pointer held by instances of the Java class NitObject
214 cf
= new CFunction("void *nit_ffi_with_java_nit_object_data(JNIEnv *env, jobject nit_object)")
216 Sys sys = Pointer_sys(NULL);
217 jclass java_class = Sys_load_jclass(sys, "nit/app/NitObject");
218 if (java_class == NULL) {
219 PRINT_ERROR("Nit FFI with Java error: failed to load class NitObject.\\n");
220 (*env)->ExceptionDescribe(env);
224 jfieldID java_field = (*env)->GetFieldID(env, java_class, "pointer", "J");
225 if (java_field == NULL) {
226 PRINT_ERROR("Nit FFI with Java error: NitObject field not found.\\n");
227 (*env)->ExceptionDescribe(env);
231 jlong data = (*env)->GetLongField(env, nit_object, java_field);
235 ffi_ccu
.add_local_function cf
238 # Java implementation code
239 var java_file
= mmodule
.java_file
240 assert java_file
!= null
241 var extern_java_file
= java_file
.write_to_files
(compdir
)
242 mmodule
.ffi_files
.add
(extern_java_file
)
245 var ffi_ccu
: nullable CCompilationUnit = null # HACK
247 redef fun compile_callback
(callback
, mmodule
, mainmodule
, ccu
)
250 callback
.compile_callback_to_java
(mmodule
, mainmodule
, ccu
)
255 private var callbacks_used_from_java
= new ForeignCallbackSet
257 # Java source file extracted from user FFI code with generated structure
258 var java_file
: nullable JavaClassTemplate = null
260 # Set up the templates of the Java implementation class
261 private fun ensure_java_files
263 if java_file
!= null then return
265 # Java implementation code
266 java_file
= new JavaClassTemplate(impl_java_class_name
)
269 # Compile C code to call JNI and link C callbacks implementations to Java extern methods
270 private fun ensure_linking_callback_methods
(ccu
: CCompilationUnit)
272 var callbacks
= callbacks_used_from_java
.callbacks
273 if callbacks
.is_empty
then
274 ccu
.body_decl
.add
"static int nit_ffi_with_java_registered_natives = 1;\n"
278 ccu
.body_decl
.add
"static int nit_ffi_with_java_registered_natives = 0;\n"
280 var jni_methods
= new Array[String]
281 for cb
in callbacks
do
282 jni_methods
.add_all
(cb
.jni_methods_declaration
(self))
284 for cb
in callbacks_used_from_java
.types
do
285 jni_methods
.add_all
(cb
.jni_methods_declaration
(self))
288 var cf
= new CFunction("void nit_ffi_with_java_register_natives(JNIEnv* env, jclass jclazz)")
290 nit_ffi_with_java_registered_natives = 1;
292 jint n_methods = {{{jni_methods.length}}};
293 JNINativeMethod methods[] = {
294 {{{jni_methods.join(",\n\t\t")}}}
296 jint res = (*env)->RegisterNatives(env, jclazz, methods, n_methods);
298 PRINT_ERROR("RegisterNatives failed\\n");
299 (*env)->ExceptionDescribe(env);
303 ccu
.add_local_function cf
306 # Tell the C compiler where to find jni.h and how to link with libjvm
307 private fun insert_compiler_options
309 cflags
.add_one
("", "-I $(JAVA_HOME)/include/ -I $(JAVA_HOME)/include/linux/")
312 # Name of the generated Java class where to store all implementation methods of this module
313 # as well as generated callbacks.
314 private fun impl_java_class_name
: String do return "Nit_{name}"
317 redef class AMethPropdef
318 redef fun verify_nitni_callbacks
(toolcontext
)
322 var block
= n_extern_code_block
323 if block
!= null and block
.is_java
then
324 insert_artificial_callbacks
(toolcontext
)
328 # Insert additional explicit calls to get the current `JNIEnv`
330 # This forces declaration of callbacks to Nit. The callbacks will be available in Java
331 # but will be used mainly by the FFI itself.
333 # The developer can also customize the JNIEnv used by the FFI by redefining `Sys::jni_env`.
334 private fun insert_artificial_callbacks
(toolcontext
: ToolContext)
336 var fcc
= foreign_callbacks
338 var modelbuilder
= toolcontext
.modelbuilder
339 var mmodule
= mpropdef
.mclassdef
.mmodule
341 # We use callbacks from the C FFI since they will be called from generated C
342 var c_language_visitor
= toolcontext
.ffi_language_assignation_phase
.as(FFILanguageAssignationPhase).c_language
343 if not mmodule
.ffi_callbacks
.keys
.has
(c_language_visitor
) then
344 mmodule
.ffi_callbacks
[c_language_visitor
] = new HashSet[NitniCallback]
348 var pointer_class
= modelbuilder
.try_get_mclass_by_name
(self, mmodule
, "Pointer")
349 assert pointer_class
!= null
350 var pointer_sys_meth
= modelbuilder
.try_get_mproperty_by_name2
(self, mmodule
, pointer_class
.mclass_type
, "sys")
351 assert pointer_sys_meth
!= null and pointer_sys_meth
isa MMethod
353 var explicit_call
= new MExplicitCall(pointer_class
.mclass_type
, pointer_sys_meth
, mmodule
)
354 fcc
.callbacks
.add
(explicit_call
)
355 mmodule
.ffi_callbacks
[c_language_visitor
].add
(explicit_call
)
358 var sys_class
= modelbuilder
.try_get_mclass_by_name
(self, mmodule
, "Sys")
359 assert sys_class
!= null
360 var sys_jni_env_meth
= modelbuilder
.try_get_mproperty_by_name2
(self, mmodule
, sys_class
.mclass_type
, "jni_env")
361 if sys_jni_env_meth
== null or not sys_jni_env_meth
isa MMethod then
362 toolcontext
.error
(self.location
, "Java FFI Error: you must import the `java` module when using the FFI with Java")
366 explicit_call
= new MExplicitCall(sys_class
.mclass_type
, sys_jni_env_meth
, mmodule
)
367 fcc
.callbacks
.add
(explicit_call
)
368 mmodule
.ffi_callbacks
[c_language_visitor
].add
(explicit_call
)
371 var sys_jni_load_jclass_meth
= modelbuilder
.try_get_mproperty_by_name2
(self, mmodule
, sys_class
.mclass_type
, "load_jclass")
372 assert sys_jni_load_jclass_meth
!= null
373 assert sys_jni_load_jclass_meth
isa MMethod
375 explicit_call
= new MExplicitCall(sys_class
.mclass_type
, sys_jni_load_jclass_meth
, mmodule
)
376 fcc
.callbacks
.add
(explicit_call
)
377 mmodule
.ffi_callbacks
[c_language_visitor
].add
(explicit_call
)
378 explicit_call
.fill_type_for
(fcc
, mmodule
)
382 redef class AExternCodeBlock
383 # Is this code block in Java?
384 fun is_java
: Bool do return is_default_java
or (parent
isa AModule and is_inner_java
)
386 # Is this code block in Java, with the default mode? (On module blocks it targets the file header)
387 private fun is_default_java
: Bool do return language_name
!= null and
388 language_name_lowered
== "java"
390 # Is this code block in Java, and for a module block to generate in the class?
391 private fun is_inner_java
: Bool do return language_name
!= null and
392 language_name_lowered
== "java inner"
395 # Java class source template
396 class JavaClassTemplate
399 var java_class_name
: String
401 var header
= new Template
402 var class_content
= new Template
404 fun write_to_files
(compdir
: String): ExternFile
406 var filename
= "{java_class_name}.java"
407 var filepath
= compdir
/filename
409 write_to_file filepath
411 return new JavaFile(filename
)
418 add
"public class {java_class_name} \{\n"
424 # A generated Java source file, represent the corresponding Makefile rules
428 # Full Java class name: package and class
429 fun full_name
: String do return filename
.basename
(".java")
431 redef fun makefile_rule_name
do return full_name
.replace
(".", "/") + ".class"
432 redef fun makefile_rule_content
do return "javac {filename} -d ."
433 redef fun add_to_jar
do return true
436 # Context in pure Java code
437 private class JavaCallContext
440 redef fun name_mtype
(mtype
) do return mtype
.java_type
443 # Context in C, when call are from normal C to JNI
444 private class ToJavaCallContext
447 redef fun cast_to
(mtype
, name
)
449 if mtype
.java_is_nit_object
then
450 return "nit_ffi_with_java_new_nit_object(nit_ffi_jni_env, {name})"
452 return "({mtype.jni_type})({name})"
456 redef fun cast_from
(mtype
, name
)
458 if mtype
.java_is_nit_object
then
459 return "({mtype.cname})nit_ffi_with_java_nit_object_data(nit_ffi_jni_env, {name})"
461 return "({mtype.cname})({name})"
465 redef fun name_mtype
(mtype
) do return mtype
.jni_type
468 # Context in C, when call are from JNI to normal C
469 private class FromJavaCallContext
472 redef fun cast_to
(mtype
, name
)
474 if mtype
.java_is_nit_object
then
475 return "({mtype.cname})nit_ffi_with_java_nit_object_data(nit_ffi_jni_env, {name})"
477 return "({mtype.cname})({name})"
481 redef fun cast_from
(mtype
, name
)
483 if mtype
.java_is_nit_object
then
484 return "nit_ffi_with_java_new_nit_object(nit_ffi_jni_env, {name})"
486 return "({mtype.jni_type})({name})"
490 redef fun name_mtype
(mtype
) do return mtype
.jni_type
493 # Foreign type attach to Nit extern Java classes
494 class ForeignJavaType
497 var java_type
: String
500 redef class NitniCallback
501 # Compile C and Java code to implement this callback
502 fun compile_callback_to_java
(mmodule
: MModule, mainmodule
: MModule, ccu
: CCompilationUnit) do end
504 # Returns the list of C functions to link with extern Java methods, as required
505 # to enable this callback from Java code.
507 # Return used by `MModule::ensure_linking_callback_methods`
509 # TODO we return an Array to support cast and other features like that
510 fun jni_methods_declaration
(from_module
: MModule): Array[String] do return new Array[String]
513 redef class MExplicitCall
514 redef fun compile_callback_to_java
(mmodule
, mainmodule
, ccu
)
516 if not mmodule
.callbacks_used_from_java
.callbacks
.has
(self) then return
518 var mproperty
= mproperty
519 assert mproperty
isa MMethod
521 # In C, indirection implementing the Java extern methods
522 var csignature
= mproperty
.build_c_implementation_signature
(recv_mtype
, mmodule
, "___indirect", long_signature
, from_java_call_context
)
523 var cf
= new CFunction("JNIEXPORT {csignature}")
524 cf
.exprs
.add
"\t{mproperty.build_ccall(recv_mtype, mainmodule, null, long_signature, from_java_call_context, null)}\n"
525 ccu
.add_non_static_local_function cf
527 # In Java, declare the extern method as a private static local method
528 var java_signature
= mproperty
.build_csignature
(recv_mtype
, mainmodule
, null, short_signature
, java_call_context
)
529 mmodule
.java_file
.class_content
.add
"private native static {java_signature};\n"
532 redef fun jni_methods_declaration
(from_mmodule
)
534 var mproperty
= mproperty
535 assert mproperty
isa MMethod
537 var java_name
= mproperty
.build_cname
(recv_mtype
, from_mmodule
, null, short_signature
)
538 var jni_format
= mproperty
.build_jni_format
(recv_mtype
, from_mmodule
)
539 var c_name
= mproperty
.build_cname
(recv_mtype
, from_mmodule
, "___indirect", long_signature
)
541 return ["""{"{{{java_name}}}", "{{{jni_format}}}", {{{c_name}}}}"""]
549 # * Primitives common to both languages use their Java primitive type
550 # * Nit extern Java classes are represented by their full Java type
551 # * Other Nit objects are represented by `NitObject` in Java, a class
552 # encapsulating the pointer to the underlying C structure.
553 private fun java_type
: String do return "nit.app.NitObject"
555 # Is this type opaque in Java? As so it is represented by `nit.app.NitObject`.
556 private fun java_is_nit_object
: Bool do return true
558 # JNI type name (in C)
560 # So this is a C type, usually defined in `jni.h`
561 private fun jni_type
: String do return "jobject"
563 # JNI short type name (for signatures)
565 # Is used by `MMethod::build_jni_format` to pass a Java method signature
566 # to the JNI function `GetStaticMetodId`.
567 private fun jni_format
: String do return "Lnit/app/NitObject;"
569 # Type name appearing within JNI function names.
571 # Used by `JavaLanguage::compile_extern_method` when calling JNI's `CallStatic*Method`.
572 # This strategy is used by JNI to type the return of callbacks to Java.
573 private fun jni_signature_alt
: String do return "Int"
575 redef fun compile_callback_to_java
(mmodule
, mainmodule
, ccu
)
577 if self isa MClassType and mclass
.ftype
isa ForeignJavaType then return
579 var java_file
= mmodule
.java_file
580 if java_file
== null or mmodule
.callbacks_used_from_java
.callbacks
.is_empty
then return
582 for variation
in ["incr", "decr"] do
583 var friendly_name
= "{mangled_cname}_{variation}_ref"
586 var csignature
= "void {mmodule.impl_java_class_name}_{friendly_name}(JNIEnv *nit_ffi_jni_env, jclass clazz, jobject object)"
587 var cf
= new CFunction("JNIEXPORT {csignature}")
588 cf
.exprs
.add
"\tnitni_global_ref_{variation}(nit_ffi_with_java_nit_object_data(nit_ffi_jni_env, object));"
589 ccu
.add_non_static_local_function cf
592 java_file
.class_content
.add
"private native static void {friendly_name}(nit.app.NitObject object);\n"
596 redef fun jni_methods_declaration
(from_mmodule
)
598 var arr
= new Array[String]
599 for variation
in ["incr", "decr"] do
600 var friendly_name
= "{mangled_cname}_{variation}_ref"
601 var jni_format
= "(Lnit/app/NitObject;)V"
602 var cname
= "{from_mmodule.impl_java_class_name}_{friendly_name}"
603 arr
.add
"""{"{{{friendly_name}}}", "{{{jni_format}}}", {{{cname}}}}"""
610 redef class MClassType
613 var ftype
= mclass
.ftype
614 if ftype
isa ForeignJavaType then return ftype
.java_type
.
615 replace
('/', ".").replace
('$', ".").replace
(' ', "").replace
('\n',"")
616 if mclass
.name
== "Bool" then return "boolean"
617 if mclass
.name
== "Char" then return "int"
618 if mclass
.name
== "Int" then return "long"
619 if mclass
.name
== "Float" then return "double"
620 if mclass
.name
== "Byte" then return "byte"
621 if mclass
.name
== "Int8" then return "byte"
622 if mclass
.name
== "Int16" then return "short"
623 if mclass
.name
== "UInt16" then return "short"
624 if mclass
.name
== "Int32" then return "int"
625 if mclass
.name
== "UInt32" then return "int"
629 redef fun java_is_nit_object
631 var ftype
= mclass
.ftype
632 if ftype
isa ForeignJavaType then return false
634 var java_primitives
= once
new HashSet[String].from
(
635 ["Bool", "Char", "Int", "Float", "Byte", "Int8", "Int16", "UInt16", "Int32", "UInt32"])
636 return not java_primitives
.has
(mclass
.name
)
641 var ftype
= mclass
.ftype
642 if ftype
isa ForeignJavaType then return "jobject"
643 if mclass
.name
== "Bool" then return "jboolean"
644 if mclass
.name
== "Char" then return "jint"
645 if mclass
.name
== "Int" then return "jlong"
646 if mclass
.name
== "Float" then return "jdouble"
647 if mclass
.name
== "Byte" then return "jbyte"
648 if mclass
.name
== "Int8" then return "jbyte"
649 if mclass
.name
== "Int16" then return "jshort"
650 if mclass
.name
== "UInt16" then return "jshort"
651 if mclass
.name
== "Int32" then return "jint"
652 if mclass
.name
== "UInt32" then return "jint"
658 var ftype
= mclass
.ftype
659 if ftype
isa ForeignJavaType then
660 var jni_type
= ftype
.java_type
.
661 replace
('.', "/").replace
(' ', "").replace
('\n', "")
663 # Remove parameters of generic types
665 var i
= jni_type
.last_index_of
('<')
667 var j
= jni_type
.index_of_from
('>', i
)
669 print
"Error: missing closing '>' in extern Java type of \"{mclass.name}\
""
672 jni_type
= jni_type
.substring
(0, i
) +
673 jni_type
.substring
(j
+1, jni_type
.length
)
677 # Change `float[]` to `[float`
678 if jni_type
.has
('[') then
679 var depth
= jni_type
.chars
.count
('[')
680 var java_type
= jni_type
.replace
("[]", "")
683 if java_type
== "boolean" then
685 else if java_type
== "byte" then
687 else if java_type
== "char" then
689 else if java_type
== "short" then
691 else if java_type
== "int" then
693 else if java_type
== "long" then
695 else if java_type
== "float" then
697 else if java_type
== "double" then
700 short
= "L{java_type};"
703 return "["*depth
+ short
706 return "L{jni_type};"
708 if mclass
.name
== "Bool" then return "Z"
709 if mclass
.name
== "Char" then return "I"
710 if mclass
.name
== "Int" then return "J"
711 if mclass
.name
== "Float" then return "D"
712 if mclass
.name
== "Byte" then return "B"
713 if mclass
.name
== "Int8" then return "B"
714 if mclass
.name
== "Int16" then return "S"
715 if mclass
.name
== "UInt16" then return "S"
716 if mclass
.name
== "Int32" then return "I"
717 if mclass
.name
== "UInt32" then return "I"
721 redef fun jni_signature_alt
723 var ftype
= mclass
.ftype
725 if ftype
isa ForeignJavaType then return "Object"
726 if mclass
.name
== "Bool" then return "Boolean"
727 if mclass
.name
== "Char" then return "Int"
728 if mclass
.name
== "Int" then return "Long"
729 if mclass
.name
== "Float" then return "Double"
730 if mclass
.name
== "Byte" then return "Byte"
731 if mclass
.name
== "Int8" then return "Byte"
732 if mclass
.name
== "Int16" then return "Short"
733 if mclass
.name
== "UInt16" then return "Short"
734 if mclass
.name
== "Int32" then return "Int"
735 if mclass
.name
== "UInt32" then return "Int"
739 redef fun compile_callback_to_java
(mmodule
, mainmodule
, ccu
)
741 # Don't generate functions for reference counters on extern classes
742 if mclass
.ftype
!= null then return
747 redef fun jni_methods_declaration
(from_mmodule
)
749 # Don't generate functions for reference counters on extern classes
750 if mclass
.ftype
!= null then return new Array[String]
757 # Returns the JNI signature format of this Nit method
759 # Example: a Nity signature `(Bool, Int, Float, JavaString)` is represented by
760 # the JNI format `(ZIDLjava/lang/string;)V"
761 private fun build_jni_format
(recv_mtype
: MClassType, from_mmodule
: MModule): String
763 var mmethoddef
= lookup_first_definition
(from_mmodule
, recv_mtype
)
764 var msignature
= mmethoddef
.msignature
765 var format
= new Array[String]
770 if not self.is_init
then format
.add recv_mtype
.jni_format
773 for p
in msignature
.mparameters
do
774 var param_mtype
= p
.mtype
.resolve_for
(recv_mtype
, recv_mtype
, from_mmodule
, true)
775 format
.add param_mtype
.jni_format
781 format
.add recv_mtype
.jni_format
783 var return_mtype
= msignature
.return_mtype
784 if return_mtype
!= null then
785 return_mtype
= return_mtype
.resolve_for
(recv_mtype
, recv_mtype
, from_mmodule
, true)
786 format
.add return_mtype
.jni_format
793 # Similar to `build_c_signature` but adapted to create the signature expected by JNI for C functions
794 # implementing Java extern methods.
796 # Is used to generate FFI callbacks to Nit at `MExplicitCall::compile_callback_to_java`.
797 private fun build_c_implementation_signature
(recv_mtype
: MClassType, from_mmodule
: MModule,
798 suffix
: nullable String, length
: SignatureLength, call_context
: CallContext): String
800 var mmethoddef
= lookup_first_definition
(from_mmodule
, recv_mtype
)
801 var signature
= mmethoddef
.msignature
802 assert signature
!= null
806 creturn_type
= call_context
.name_mtype
(recv_mtype
)
807 else if signature
.return_mtype
!= null then
808 var ret_mtype
= signature
.return_mtype
809 ret_mtype
= ret_mtype
.resolve_for
(recv_mtype
, recv_mtype
, from_mmodule
, true)
810 creturn_type
= call_context
.name_mtype
(ret_mtype
)
812 creturn_type
= "void"
815 var cname
= build_cname
(recv_mtype
, from_mmodule
, suffix
, length
)
817 var cparams
= new List[String]
819 cparams
.add
"JNIEnv *nit_ffi_jni_env"
820 cparams
.add
"jclass clazz"
822 if not self.is_init
then
823 cparams
.add
"{call_context.name_mtype(recv_mtype)} self"
825 for p
in signature
.mparameters
do
826 var param_mtype
= p
.mtype
.resolve_for
(recv_mtype
, recv_mtype
, from_mmodule
, true)
827 cparams
.add
"{call_context.name_mtype(param_mtype)} {p.name}"
830 return "{creturn_type} {cname}( {cparams.join(", ")} )"
834 private fun java_call_context
: JavaCallContext do return new JavaCallContext
835 private fun to_java_call_context
: ToJavaCallContext do return new ToJavaCallContext
836 private fun from_java_call_context
: FromJavaCallContext do return new FromJavaCallContext
838 redef class CCompilationUnit
839 # Similar to `add_local_function` but not `static`
841 # Used when the signature contains a visibility attribute.
842 private fun add_non_static_local_function
(c_function
: CFunction)
844 body_decl
.add c_function
.signature
848 body_impl
.add c_function
.to_writer