var v = compiler.new_visitor
var n = nmodule(v)
if n == null then return
- n.finalize_ffi_wrapper(v.compiler.modelbuilder.compile_dir, v.compiler.mainmodule)
- for file in n.ffi_files do v.compiler.extern_bodies.add(file)
+ n.ensure_compile_ffi_wrapper
+ finalize_ffi_wrapper(v.compiler.modelbuilder.compile_dir, v.compiler.mainmodule)
+ for file in ffi_files do v.compiler.extern_bodies.add(file)
ensure_compile_nitni_base(v)
nitni_ccu.header_c_types.add("#include \"{name}._ffi.h\"\n")
+ nitni_ccu.header_c_types.add """
+extern void nitni_global_ref_incr(void*);
+extern void nitni_global_ref_decr(void*);
+"""
- nitni_ccu.write_as_nitni(n, v.compiler.modelbuilder.compile_dir)
+ nitni_ccu.write_as_nitni(self, v.compiler.modelbuilder.compile_dir)
for file in nitni_ccu.files do
v.compiler.extern_bodies.add(new ExternCFile(file, c_compiler_options))
end
+
+ # reset FFI things so the next compilation job, if any, starts with a clean context
+ # FIXME clean and rationalize this
+ nitni_ccu = null
+ compiled_ffi_methods.clear
+ ffi_ccu = null
+ ffi_files.clear
+ compiled_callbacks.clear
+ #Do not reset `foreign_callbacks` and `ffi_callbacks` because they are computed in previous phases
end
- fun ensure_compile_nitni_base(v: AbstractCompilerVisitor)
+ private fun ensure_compile_nitni_base(v: AbstractCompilerVisitor)
do
if nitni_ccu != null then return
return res
end
- var compiled_callbacks: Array[NitniCallback] = new Array[NitniCallback]
+ private var compiled_callbacks: Array[NitniCallback] = new Array[NitniCallback]
# Returns true if callbacks has yet to be generated and register it as being generated
- fun check_callback_compilation(cb: NitniCallback): Bool
+ private fun check_callback_compilation(cb: NitniCallback): Bool
do
var compiled = compiled_callbacks.has(cb)
if not compiled then compiled_callbacks.add(cb)
end
redef class AMethPropdef
- fun compile_ffi_support_to_c(v: AbstractCompilerVisitor)
+ private fun compile_ffi_support_to_c(v: AbstractCompilerVisitor)
do
var mmodule = mpropdef.mclassdef.mmodule
var mainmodule = v.compiler.mainmodule
v.declare_once("{csignature};")
# FFI part
- compile_ffi_method(amodule)
+ amodule.ensure_compile_ffi_wrapper
+ compile_ffi_method(mmodule)
assert self isa AExternPropdef
redef fun compile_externmeth_to_c(v, mpropdef, arguments)
do
var mmodule = mpropdef.mclassdef.mmodule
- var amodule = v.compiler.modelbuilder.mmodule2nmodule[mmodule]
# if using the old native interface fallback on previous implementation
var nextern = self.n_extern
return
end
- amodule.mmodule.uses_ffi = true
+ mmodule.uses_ffi = true
var mclass_type = mpropdef.mclassdef.bound_mtype
arguments_for_c.add(arg.name)
else
v.add("struct nitni_instance* var_for_c_{a};")
- v.add("var_for_c_{a} = malloc(sizeof(struct nitni_instance));")
+ v.add("var_for_c_{a} = nit_alloc(sizeof(struct nitni_instance));")
v.add("var_for_c_{a}->value = {arg.name};")
arguments_for_c.add("var_for_c_{a}")
end
redef fun compile_externinit_to_c(v, mpropdef, arguments)
do
var mmodule = mpropdef.mclassdef.mmodule
- var amodule = v.compiler.modelbuilder.mmodule2nmodule[mmodule]
# if using the old native interface fallback on previous implementation
var nextern = self.n_extern
return
end
- amodule.mmodule.uses_ffi = true
+ mmodule.uses_ffi = true
+
var mclass_type = mpropdef.mclassdef.bound_mtype
var externname = mpropdef.mproperty.build_cname(mpropdef.mclassdef.bound_mtype, mmodule, "___impl", long_signature)
arguments_for_c.add(arg.name)
else
v.add("struct nitni_instance* var_for_c_{a};")
- v.add("var_for_c_{a} = malloc(sizeof(struct nitni_instance));")
+ v.add("var_for_c_{a} = nit_alloc(sizeof(struct nitni_instance));")
v.add("var_for_c_{a}->value = {arg.name};")
arguments_for_c.add("var_for_c_{a}")
end
end
redef class CCompilationUnit
- fun write_as_nitni(amodule: AModule, compdir: String)
+ fun write_as_nitni(mmodule: MModule, compdir: String)
do
- var base_name = "{amodule.mmodule.name}._nitni"
+ var base_name = "{mmodule.name}._nitni"
var h_file = "{base_name}.h"
- write_header_to_file( amodule, "{compdir}/{h_file}", new Array[String],
- "{amodule.cname.to_s.to_upper}_NITG_NITNI_H")
+ write_header_to_file( mmodule, "{compdir}/{h_file}", new Array[String],
+ "{mmodule.cname.to_s.to_upper}_NITG_NITNI_H")
var c_file = "{base_name}.c"
- write_body_to_file( amodule, "{compdir}/{c_file}", ["\"{h_file}\""] )
+ write_body_to_file( mmodule, "{compdir}/{c_file}", ["\"{h_file}\""] )
files.add( "{compdir}/{c_file}" )
end
end
+redef class AbstractCompiler
+ # Cache to avoid multiple compilation of NULL values
+ # see FIXME in `MNullableType#compile_extern_helper_functions`
+ private var compiled_null_types = new Array[MNullableType]
+end
+
redef class AbstractCompilerVisitor
# Create a `RuntimeVariable` for this C variable originating from C user code
private fun var_from_c(name: String, mtype: MType): RuntimeVariable
add("return {src};")
else
add("struct nitni_instance* ret_for_c;")
- add("ret_for_c = malloc(sizeof(struct nitni_instance));")
+ add("ret_for_c = nit_alloc(sizeof(struct nitni_instance));")
add("ret_for_c->value = {src};")
add("return ret_for_c;")
end
end
redef class MType
- fun compile_extern_type(v: AbstractCompilerVisitor, ccu: CCompilationUnit)
+ private fun compile_extern_type(v: AbstractCompilerVisitor, ccu: CCompilationUnit)
do
assert not is_cprimitive
ccu.header_c_types.add("#endif\n")
end
- fun compile_extern_helper_functions(v: AbstractCompilerVisitor, ccu: CCompilationUnit)
+ private fun compile_extern_helper_functions(v: AbstractCompilerVisitor, ccu: CCompilationUnit)
do
# actually, we do not need to do anything when using the bohem garbage collector
+ var call_context = from_c_call_context
# incr_ref
- var nitni_visitor = v.compiler.new_visitor
- ccu.header_decl.add("#define {mangled_cname}_incr_ref(from) while(0)\{\}\n")
-
- # incr_ref
- nitni_visitor = v.compiler.new_visitor
- ccu.header_decl.add("#define {mangled_cname}_decr_ref(from) while(0)\{\}\n")
+ ccu.header_decl.add "#ifndef {mangled_cname}_incr_ref\n"
+ ccu.header_decl.add " #define {mangled_cname}_incr_ref(from) nitni_global_ref_incr(({call_context.name_mtype(self)})(from))\n"
+ ccu.header_decl.add "#endif\n"
+
+ # decr_ref
+ ccu.header_decl.add "#ifndef {mangled_cname}_decr_ref\n"
+ ccu.header_decl.add " #define {mangled_cname}_decr_ref(from) nitni_global_ref_decr(({call_context.name_mtype(self)})(from))\n"
+ ccu.header_decl.add "#endif\n"
end
end
# FIXME: This is ugly an broke the separate compilation principle
# The real function MUST be compiled only once, #define pragma only protect the compiler, not the loader
# However, I am not sure of the right approach here (eg. week refs are ugly)
- if is_already_compiled then return
- is_already_compiled = true
+ if v.compiler.compiled_null_types.has(self) then return
+ v.compiler.compiled_null_types.add self
# Internally, implement internal function
var nitni_visitor = v.compiler.new_visitor
var full_internal_csignature = "{cname_blind} {full_cname}()"
nitni_visitor.add("{full_internal_csignature} \{")
nitni_visitor.add("struct nitni_instance* ret_for_c;")
- nitni_visitor.add("ret_for_c = malloc(sizeof(struct nitni_instance));")
+ nitni_visitor.add("ret_for_c = nit_alloc(sizeof(struct nitni_instance));")
nitni_visitor.add("ret_for_c->value = NULL;")
nitni_visitor.add("return ret_for_c;")
nitni_visitor.add("\}")
end
-
- private var is_already_compiled = false # FIXME to remove, show above
end
redef class MExplicitCall
- fun compile_extern_callback(v: AbstractCompilerVisitor, ccu: CCompilationUnit)
+ private fun compile_extern_callback(v: AbstractCompilerVisitor, ccu: CCompilationUnit)
do
var mproperty = mproperty
assert mproperty isa MMethod
end
redef class MExplicitSuper
- fun compile_extern_callback(v: AbstractCompilerVisitor, ccu: CCompilationUnit)
+ private fun compile_extern_callback(v: AbstractCompilerVisitor, ccu: CCompilationUnit)
do
var mproperty = from.mproperty
assert mproperty isa MMethod
end
redef class MExplicitCast
- fun compile_extern_callbacks(v: AbstractCompilerVisitor, ccu: CCompilationUnit)
+ private fun compile_extern_callbacks(v: AbstractCompilerVisitor, ccu: CCompilationUnit)
do
var from = from
var to = to