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(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
private fun ensure_compile_nitni_base(v: AbstractCompilerVisitor)
end
end
-redef class AExternPropdef
+redef class AMethPropdef
private fun compile_ffi_support_to_c(v: AbstractCompilerVisitor)
do
var mmodule = mpropdef.mclassdef.mmodule
amodule.ensure_compile_ffi_wrapper
compile_ffi_method(mmodule)
+ assert self isa AExternPropdef
+
# nitni - Compile missing callbacks
mmodule.ensure_compile_nitni_base(v)
var ccu = mmodule.nitni_ccu.as(not null)
# manage nitni callback set
mmodule.foreign_callbacks.join(foreign_callbacks)
end
-end
-redef class AExternMethPropdef
- redef fun compile_to_c(v, mpropdef, arguments)
+ redef fun compile_externmeth_to_c(v, mpropdef, arguments)
do
var mmodule = mpropdef.mclassdef.mmodule
end
v.adapt_signature(mpropdef, arguments)
+ v.unbox_signature_extern(mpropdef, arguments)
var arguments_for_c = new Array[String]
for a in [0..arguments.length[ do
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
v.add("ret_var = {externname}({arguments_for_c.join(", ")});")
v.add("{recv_var} = ret_var->value;")
end
+ recv_var = v.box_extern(recv_var, return_mtype)
v.ret(recv_var)
end
compile_ffi_support_to_c(v)
end
-end
-redef class AExternInitPropdef
- redef fun compile_to_c(v, mpropdef, arguments)
+ redef fun compile_externinit_to_c(v, mpropdef, arguments)
do
var mmodule = mpropdef.mclassdef.mmodule
var recv_var = v.new_var(return_mtype)
v.adapt_signature(mpropdef, arguments)
+ v.unbox_signature_extern(mpropdef, arguments)
arguments.shift
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
v.add("ret_var = {externname}({arguments_for_c.join(", ")});")
v.add("{recv_var} = ret_var->value;")
end
+ recv_var = v.box_extern(recv_var, return_mtype)
v.ret(recv_var)
compile_ffi_support_to_c(v)
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
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
var mtype: MType = recv_mtype
var recv_var = null
if mproperty.is_init then
- if recv_mtype.mclass.kind == extern_kind then
- recv_var = nitni_visitor.new_var(mtype)
- else
- var recv_mtype = recv_mtype
- recv_var = nitni_visitor.init_instance(recv_mtype)
- nitni_visitor.add("{mtype.ctype} recv /* var self: {mtype} */;")
- nitni_visitor.add("recv = {recv_var};")
- end
+ var recv_mtype = recv_mtype
+ recv_var = nitni_visitor.init_instance(recv_mtype)
+ nitni_visitor.add("{mtype.ctype} recv /* var self: {mtype} */;")
+ nitni_visitor.add("recv = {recv_var};")
else
mtype = mtype.anchor_to(v.compiler.mainmodule, recv_mtype)
recv_var = nitni_visitor.var_from_c("recv", mtype)
+ recv_var = nitni_visitor.box_extern(recv_var, mtype)
end
vars.add(recv_var)
for p in msignature.mparameters do
var arg_mtype = p.mtype.anchor_to(v.compiler.mainmodule, recv_mtype)
var arg = nitni_visitor.var_from_c(p.name, arg_mtype)
+ arg = nitni_visitor.box_extern(arg, arg_mtype)
vars.add(arg)
end
assert ret_var != null
return_mtype = return_mtype.anchor_to(v.compiler.mainmodule, recv_mtype)
ret_var = nitni_visitor.autobox(ret_var, return_mtype)
+ ret_var = nitni_visitor.unbox_extern(ret_var, return_mtype)
nitni_visitor.ret_to_c(ret_var, return_mtype)
end
nitni_visitor.add("\}")
var vars = new Array[RuntimeVariable]
var recv_var = nitni_visitor.var_from_c("recv", mclass_type)
+ recv_var = nitni_visitor.box_extern(recv_var, mclass_type)
vars.add(recv_var)
for p in msignature.mparameters do
var arg_mtype = v.anchor(p.mtype)
var arg = nitni_visitor.var_from_c(p.name, arg_mtype)
+ arg = nitni_visitor.box_extern(arg, arg_mtype)
vars.add(arg)
end
if return_mtype != null then
assert ret_var != null
return_mtype = v.anchor(return_mtype)
+ ret_var = nitni_visitor.autobox(ret_var, return_mtype)
+ ret_var = nitni_visitor.unbox_extern(ret_var, return_mtype)
nitni_visitor.ret_to_c(ret_var, return_mtype)
end
nitni_visitor.add("\}")
var nitni_visitor = v.compiler.new_visitor
nitni_visitor.frame = v.frame
- var full_internal_csignature = "int {v.compiler.mainmodule.name }___{from.mangled_cname}_is_a_{to.mangled_cname}({from.cname_blind} from)"
+ var full_internal_csignature = "int {v.compiler.mainmodule.name }___{from.mangled_cname}_is_a_{to.mangled_cname}({internal_call_context.name_mtype(from)} from)"
+
nitni_visitor.add_decl("/* nitni check for {from} to {to} */")
nitni_visitor.add_decl("{full_internal_csignature} \{")
- var from_var = new RuntimeVariable("from->value", from, from)
+ #var from_var = new RuntimeVariable("from->value", from, from)
+ var from_var = nitni_visitor.var_from_c("from", from)
+ from_var = nitni_visitor.box_extern(from_var, from)
var recv_var = nitni_visitor.type_test(from_var, to, "FFI isa")
nitni_visitor.add("return {recv_var};")
nitni_visitor = v.compiler.new_visitor
nitni_visitor.frame = v.frame
- full_internal_csignature = "{to.cname_blind} {v.compiler.mainmodule.name }___{from.mangled_cname}_as_{to.mangled_cname}({from.cname_blind} from)"
+ full_internal_csignature = "{to.cname_blind} {v.compiler.mainmodule.name }___{from.mangled_cname}_as_{to.mangled_cname}({internal_call_context.name_mtype(from)} from)"
nitni_visitor.add_decl("/* nitni cast for {from} to {to} */")
nitni_visitor.add_decl("{full_internal_csignature} \{")
from_var = nitni_visitor.var_from_c("from", from)
+ from_var = nitni_visitor.box_extern(from_var, from)
## test type
var check = nitni_visitor.type_test(from_var, to, "FFI cast")
## internal cast
recv_var = nitni_visitor.autobox(from_var, to)
+ recv_var = nitni_visitor.unbox_extern(recv_var, to)
nitni_visitor.ret_to_c(recv_var, to)
nitlanguage / nit.git / blobdiff