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
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)
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
"""
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
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
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
# 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
# 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
# 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("\}")
nitlanguage / nit.git / blobdiff