X-Git-Url: http://nitlanguage.org diff --git a/src/abstract_compiler.nit b/src/abstract_compiler.nit index 8015a5a..9d441cc 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 @@ -733,7 +762,8 @@ extern void nitni_global_ref_decr( struct nitni_ref *ref ); if main_init != null then v.send(main_init, [glob_sys]) end - var main_method = mainmodule.try_get_primitive_method("main", main_type.mclass) + var main_method = mainmodule.try_get_primitive_method("run", main_type.mclass) or else + mainmodule.try_get_primitive_method("main", main_type.mclass) if main_method != null then v.send(main_method, [glob_sys]) end @@ -1014,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 @@ -1154,7 +1202,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 @@ -1258,6 +1306,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 @@ -1788,13 +1847,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 @@ -1811,6 +1875,8 @@ redef class AMethPropdef else compile_externmeth_to_c(v, mpropdef, arguments) end + else + abort end end @@ -2007,7 +2073,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))) @@ -2121,18 +2187,55 @@ end redef class AAttrPropdef redef fun compile_to_c(v, mpropdef, arguments) do - if arguments.length == 1 then - var res = v.read_attribute(self.mpropdef.mproperty, arguments.first) + if mpropdef == mreadpropdef then + assert arguments.length == 1 + var res + if is_lazy then + var nexpr = n_expr + assert nexpr != null + var set + var ret = self.mpropdef.static_mtype + var useiset = ret.ctype == "val*" and not ret isa MNullableType + var guard = self.mlazypropdef.mproperty + if useiset then + set = v.isset_attribute(self.mpropdef.mproperty, arguments.first) + else + set = v.read_attribute(guard, arguments.first) + end + v.add("if(likely({set})) \{") + res = v.read_attribute(self.mpropdef.mproperty, arguments.first) + v.add("\} else \{") + var value = v.expr(nexpr, self.mpropdef.static_mtype) + v.write_attribute(self.mpropdef.mproperty, arguments.first, value) + v.assign(res, value) + if not useiset then + var true_v = v.new_expr("1", v.bool_type) + v.write_attribute(guard, arguments.first, true_v) + end + v.add("\}") + else + res = v.read_attribute(self.mpropdef.mproperty, arguments.first) + end v.assign(v.frame.returnvar.as(not null), res) - else + else if mpropdef == mwritepropdef then + assert arguments.length == 2 v.write_attribute(self.mpropdef.mproperty, arguments.first, arguments[1]) + if is_lazy then + var ret = self.mpropdef.static_mtype + var useiset = ret.ctype == "val*" and not ret isa MNullableType + if not useiset then + v.write_attribute(self.mlazypropdef.mproperty, arguments.first, v.new_expr("1", v.bool_type)) + end + end + else + abort end end fun init_expr(v: AbstractCompilerVisitor, recv: RuntimeVariable) do var nexpr = self.n_expr - if nexpr != null then + if nexpr != null and not is_lazy then var oldnode = v.current_node v.current_node = self var old_frame = v.frame @@ -2166,6 +2269,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 @@ -2174,6 +2286,7 @@ redef class AClassdef v.send(su, args_of_super) end end + var recv = arguments.first var i = 1 # Collect undefined attributes @@ -2387,22 +2500,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("\}")