"""
end
+ fun compile_finalizer_function
+ do
+ var finalizable_type = mainmodule.finalizable_type
+ if finalizable_type == null then return
+
+ var finalize_meth = mainmodule.try_get_primitive_method("finalize", finalizable_type.mclass)
+
+ if finalize_meth == null then
+ modelbuilder.toolcontext.error(null, "The `Finalizable` class doesn't declare the `finalize` method.")
+ return
+ end
+
+ var v = self.new_visitor
+ v.add_decl "void gc_finalize (void *obj, void *client_data) \{"
+ var recv = v.new_expr("obj", finalizable_type)
+ v.send(finalize_meth, [recv])
+ v.add "\}"
+ end
+
# Generate the main C function.
# This function:
# * allocate the Sys object if it exists
return self.compiler.modelbuilder.force_get_primitive_method(self.current_node.as(not null), name, recv.mclass, self.compiler.mainmodule)
end
- fun compile_callsite(callsite: CallSite, args: Array[RuntimeVariable]): nullable RuntimeVariable
+ fun compile_callsite(callsite: CallSite, arguments: Array[RuntimeVariable]): nullable RuntimeVariable
do
- return self.send(callsite.mproperty, args)
+ var initializers = callsite.mpropdef.initializers
+ if not initializers.is_empty then
+ var recv = arguments.first
+
+ assert initializers.length == arguments.length - 1 else debug("expected {initializers.length}, got {arguments.length - 1}")
+ var i = 1
+ for p in initializers do
+ if p isa MMethod then
+ self.send(p, [recv, arguments[i]])
+ else if p isa MAttribute then
+ self.write_attribute(p, recv, arguments[i])
+ else abort
+ i += 1
+ end
+
+ return self.send(callsite.mproperty, [recv])
+ end
+
+ return self.send(callsite.mproperty, arguments)
end
fun native_array_instance(elttype: MType, length: RuntimeVariable): RuntimeVariable is abstract
# Generate a alloc-instance + init-attributes
fun init_instance(mtype: MClassType): RuntimeVariable is abstract
+ # Set a GC finalizer on `recv`, only if `recv` isa Finalizable
+ fun set_finalizer(recv: RuntimeVariable)
+ do
+ var mtype = recv.mtype
+ var finalizable_type = compiler.mainmodule.finalizable_type
+ if finalizable_type != null and not mtype.need_anchor and
+ mtype.is_subtype(compiler.mainmodule, null, finalizable_type) then
+ add "gc_register_finalizer({recv});"
+ end
+ end
+
# Generate an integer value
fun int_instance(value: Int): RuntimeVariable
do
if auto_super_inits != null then
var args = [arguments.first]
for auto_super_init in auto_super_inits do
+ assert auto_super_init.mproperty != mpropdef.mproperty
args.clear
for i in [0..auto_super_init.msignature.arity+1[ do
args.add(arguments[i])
end
+ assert auto_super_init.mproperty != mpropdef.mproperty
v.compile_callsite(auto_super_init, args)
end
end
+ if auto_super_call then
+ v.supercall(mpropdef, arguments.first.mtype.as(MClassType), arguments)
+ end
var n_block = n_block
if n_block != null then
else
compile_externmeth_to_c(v, mpropdef, arguments)
end
+ else
+ abort
end
end
v.add("{arguments[0]}[{arguments[1]}]={arguments[2]};")
return
else if pname == "copy_to" then
- v.add("memcpy({arguments[1]}+{arguments[4]},{arguments[0]}+{arguments[3]},{arguments[2]});")
+ v.add("memmove({arguments[1]}+{arguments[4]},{arguments[0]}+{arguments[3]},{arguments[2]});")
return
else if pname == "atoi" then
v.ret(v.new_expr("atoi({arguments[0]});", ret.as(not null)))
private fun compile_to_c(v: AbstractCompilerVisitor, mpropdef: MMethodDef, arguments: Array[RuntimeVariable])
do
if mpropdef == self.mfree_init then
+ if mpropdef.mproperty.is_root_init then
+ assert self.super_inits == null
+ assert arguments.length == 1
+ if not mpropdef.is_intro then
+ v.supercall(mpropdef, arguments.first.mtype.as(MClassType), arguments)
+ end
+ return
+ end
+
var super_inits = self.super_inits
if super_inits != null then
var args_of_super = arguments
v.send(su, args_of_super)
end
end
+
var recv = arguments.first
var i = 1
# Collect undefined attributes