X-Git-Url: http://nitlanguage.org diff --git a/src/abstract_compiler.nit b/src/abstract_compiler.nit index 0ff1e22..9e67eae 100644 --- a/src/abstract_compiler.nit +++ b/src/abstract_compiler.nit @@ -51,8 +51,10 @@ redef class ToolContext var opt_no_check_assert: OptionBool = new OptionBool("Disable the evaluation of explicit 'assert' and 'as' (dangerous)", "--no-check-assert") # --no-check-autocast var opt_no_check_autocast: OptionBool = new OptionBool("Disable implicit casts on unsafe expression usage (dangerous)", "--no-check-autocast") - # --no-check-other - var opt_no_check_other: OptionBool = new OptionBool("Disable implicit tests: unset attribute, null receiver (dangerous)", "--no-check-other") + # --no-check-null + var opt_no_check_null: OptionBool = new OptionBool("Disable tests of null receiver (dangerous)", "--no-check-null") + # --no-check-all + var opt_no_check_all: OptionBool = new OptionBool("Disable all tests (dangerous)", "--no-check-all") # --typing-test-metrics var opt_typing_test_metrics: OptionBool = new OptionBool("Enable static and dynamic count of all type tests", "--typing-test-metrics") # --invocation-metrics @@ -70,7 +72,7 @@ redef class ToolContext do super self.option_context.add_option(self.opt_output, self.opt_dir, self.opt_no_cc, self.opt_no_main, self.opt_make_flags, self.opt_compile_dir, self.opt_hardening, self.opt_no_shortcut_range) - self.option_context.add_option(self.opt_no_check_covariance, self.opt_no_check_attr_isset, self.opt_no_check_assert, self.opt_no_check_autocast, self.opt_no_check_other) + self.option_context.add_option(self.opt_no_check_covariance, self.opt_no_check_attr_isset, self.opt_no_check_assert, self.opt_no_check_autocast, self.opt_no_check_null, self.opt_no_check_all) self.option_context.add_option(self.opt_typing_test_metrics, self.opt_invocation_metrics, self.opt_isset_checks_metrics) self.option_context.add_option(self.opt_stacktrace) self.option_context.add_option(self.opt_no_gcc_directive) @@ -96,6 +98,14 @@ redef class ToolContext print "Error: cannot use both --dir and --output" exit(1) end + + if opt_no_check_all.value then + opt_no_check_covariance.value = true + opt_no_check_attr_isset.value = true + opt_no_check_assert.value = true + opt_no_check_autocast.value = true + opt_no_check_null.value = true + end end end @@ -613,6 +623,25 @@ extern void nitni_global_ref_decr( struct nitni_ref *ref ); """ 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 @@ -1015,9 +1044,27 @@ abstract class AbstractCompilerVisitor 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 @@ -1100,12 +1147,22 @@ abstract class AbstractCompilerVisitor # Generate a super call from a method definition fun supercall(m: MMethodDef, recvtype: MClassType, args: Array[RuntimeVariable]): nullable RuntimeVariable is abstract + # Adapt the arguments of a method according to targetted `MMethodDef` fun adapt_signature(m: MMethodDef, args: Array[RuntimeVariable]) is abstract + # Unbox all the arguments of a method when implemented `extern` or `intern` + fun unbox_signature_extern(m: MMethodDef, args: Array[RuntimeVariable]) is abstract + # Box or unbox a value to another type iff a C type conversion is needed # ENSURE: `result.mtype.ctype == mtype.ctype` fun autobox(value: RuntimeVariable, mtype: MType): RuntimeVariable is abstract + # Box extern classes to be used in the generated code + fun box_extern(value: RuntimeVariable, mtype: MType): RuntimeVariable is abstract + + # Unbox extern classes to be used in extern code (legacy NI and FFI) + fun unbox_extern(value: RuntimeVariable, mtype: MType): RuntimeVariable is abstract + # Generate a polymorphic subtype test fun type_test(value: RuntimeVariable, mtype: MType, tag: String): RuntimeVariable is abstract @@ -1155,7 +1212,7 @@ abstract class AbstractCompilerVisitor # Add a check and an abort for a null reciever if needed fun check_recv_notnull(recv: RuntimeVariable) do - if self.compiler.modelbuilder.toolcontext.opt_no_check_other.value then return + if self.compiler.modelbuilder.toolcontext.opt_no_check_null.value then return var maybenull = recv.mcasttype isa MNullableType or recv.mcasttype isa MNullType if maybenull then @@ -1237,6 +1294,16 @@ abstract class AbstractCompilerVisitor return res end + # The difference with `new_var` is the C static type of the local variable + fun new_var_extern(mtype: MType): RuntimeVariable + do + mtype = self.anchor(mtype) + var name = self.get_name("var") + var res = new RuntimeVariable(name, mtype, mtype) + self.add_decl("{mtype.ctype_extern} {name} /* : {mtype} for extern */;") + return res + end + # Return a new uninitialized named runtime_variable fun new_named_var(mtype: MType, name: String): RuntimeVariable do @@ -1259,6 +1326,17 @@ abstract class AbstractCompilerVisitor # 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 @@ -1550,6 +1628,10 @@ redef class MType # Return the C type associated to a given Nit static type fun ctype: String do return "val*" + # C type outside of the compiler code and in boxes + fun ctype_extern: String do return "val*" + + # Short name of the `ctype` to use in unions fun ctypename: String do return "val" # Return the name of the C structure associated to a Nit live type @@ -1581,13 +1663,20 @@ redef class MClassType return "char*" else if mclass.name == "NativeArray" then return "val*" - else if mclass.kind == extern_kind then - return "void*" else return "val*" end end + redef fun ctype_extern: String + do + if mclass.kind == extern_kind then + return "void*" + else + return ctype + end + end + redef fun ctypename: String do if mclass.name == "Int" then @@ -1603,8 +1692,6 @@ redef class MClassType else if mclass.name == "NativeArray" then #return "{self.arguments.first.ctype}*" return "val" - else if mclass.kind == extern_kind then - return "ptr" else return "val" end @@ -1789,13 +1876,18 @@ redef class AMethPropdef 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 @@ -1812,6 +1904,8 @@ redef class AMethPropdef else compile_externmeth_to_c(v, mpropdef, arguments) end + else + abort end end @@ -1837,6 +1931,7 @@ redef class AMethPropdef end if pname != "==" and pname != "!=" then v.adapt_signature(mpropdef, arguments) + v.unbox_signature_extern(mpropdef, arguments) end if cname == "Int" then if pname == "output" then @@ -2008,7 +2103,7 @@ redef class AMethPropdef 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))) @@ -2082,14 +2177,16 @@ redef class AMethPropdef var ret = mpropdef.msignature.return_mtype if ret != null then ret = v.resolve_for(ret, arguments.first) - res = v.new_var(ret) + res = v.new_var_extern(ret) end v.adapt_signature(mpropdef, arguments) + v.unbox_signature_extern(mpropdef, arguments) if res == null then v.add("{externname}({arguments.join(", ")});") else v.add("{res} = {externname}({arguments.join(", ")});") + res = v.box_extern(res, ret.as(not null)) v.ret(res) end end @@ -2109,12 +2206,14 @@ redef class AMethPropdef v.add_extern(file) end v.adapt_signature(mpropdef, arguments) + v.unbox_signature_extern(mpropdef, arguments) var ret = arguments.first.mtype - var res = v.new_var(ret) + var res = v.new_var_extern(ret) arguments.shift v.add("{res} = {externname}({arguments.join(", ")});") + res = v.box_extern(res, ret) v.ret(res) end end @@ -2204,6 +2303,15 @@ redef class AClassdef 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 @@ -2212,6 +2320,7 @@ redef class AClassdef v.send(su, args_of_super) end end + var recv = arguments.first var i = 1 # Collect undefined attributes @@ -2425,22 +2534,28 @@ redef class AForExpr # Shortcut on explicit range # Avoid the instantiation of the range and the iterator var nexpr = self.n_expr - if self.variables.length == 1 and nexpr isa AOrangeExpr and not v.compiler.modelbuilder.toolcontext.opt_no_shortcut_range.value then + if self.variables.length == 1 and nexpr isa ARangeExpr and not v.compiler.modelbuilder.toolcontext.opt_no_shortcut_range.value then var from = v.expr(nexpr.n_expr, null) var to = v.expr(nexpr.n_expr2, null) var variable = v.variable(variables.first) + var one = v.new_expr("1", v.get_class("Int").mclass_type) v.assign(variable, from) v.add("for(;;) \{ /* shortcut range */") - var ok = v.send(v.get_property("<", variable.mtype), [variable, to]) + var ok + if nexpr isa AOrangeExpr then + ok = v.send(v.get_property("<", variable.mtype), [variable, to]) + else + ok = v.send(v.get_property("<=", variable.mtype), [variable, to]) + end assert ok != null v.add("if(!{ok}) break;") v.stmt(self.n_block) v.add("CONTINUE_{v.escapemark_name(escapemark)}: (void)0;") - var succ = v.send(v.get_property("succ", variable.mtype), [variable]) + var succ = v.send(v.get_property("successor", variable.mtype), [variable, one]) assert succ != null v.assign(variable, succ) v.add("\}") @@ -2792,7 +2907,7 @@ redef class ANewExpr return v.native_array_instance(elttype, l) else if ctype == "val*" then recv = v.init_instance(mtype) - else if ctype == "void*" then + else if ctype == "char*" then recv = v.new_expr("NULL/*special!*/", mtype) else recv = v.new_expr("({ctype})0/*special!*/", mtype)