# Variable where a functionnal nit return must store its value
readable writable attr _return_value: String
-
+
+ # Generate an fprintf to display an error location
+ meth printf_locate_error(node: PNode): String
+ do
+ var s = "fprintf(stderr, \""
+ if method != null then s.append(" in %s")
+ s.append(" (%s:%d)\\n\", ")
+ if method != null then s.append("LOCATE_{method.cname}, ")
+ s.append("LOCATE_{module.name}, {node.line_number});")
+ return s
+ end
+
redef init(module: MMSrcModule)
do
super
end
j += 1
end
- var stop_prop: MMMethod
+ var stop_prop: MMMethod = null
if j < n.explicit_super_init_calls.length then
stop_prop = n.explicit_super_init_calls[j]
end
# == and != are guarded and possibly inlined
meth compile_call(v: CompilerVisitor, cargs: Array[String]): String
do
- var i = concrete_property
+ var i = self
assert i isa MMSrcMethod
if i.node isa AInternMethPropdef or
(i.local_class.name == (once "Array".to_symbol) and name == (once "[]".to_symbol))
var ee = once "==".to_symbol
var ne = once "!=".to_symbol
if name == ne then
- var eqp = signature.recv.select_method(ee)
+ var eqp = signature.recv.local_class.select_method(ee)
var eqcall = eqp.compile_call(v, cargs)
return "TAG_Bool(!UNTAG_Bool({eqcall}))"
end
end
end
-redef class MMSrcLocalProperty
+redef class MMLocalProperty
# Compile the property as a C property
meth compile_property_to_c(v: CompilerVisitor) do end
end
protected meth decl_csignature(v: CompilerVisitor, args: Array[String]): String
do
var params = new Array[String]
- var params_new: Array[String]
+ var params_new: Array[String] = null
if global.is_init then
params_new = new Array[String]
end
args.add(" param{i}")
end
var cs = decl_csignature(v, args)
+ v.add_decl("#define LOCATE_{cname} \"{full_name}\"")
v.add_instr("{cs} \{")
v.indent
var ctx_old = v.ctx
v.ctx = new CContext
- v.add_decl("struct trace_t trace = \{NULL, \"{module.name}::{local_class.name}::{name} ({node.locate})\"};")
+ v.add_decl("struct trace_t trace = \{NULL, LOCATE_{module.name}, {node.line_number}, LOCATE_{cname}};")
v.add_instr("trace.prev = tracehead; tracehead = &trace;")
var s = do_compile_inside(v, args)
v.add_instr("tracehead = trace.prev;")
do
# Fixme: handle formaltypes
var g = local_class.global
- v.add_instr("if (({recv}!=NIT_NULL) && !VAL_ISA({recv}, {g.color_id}, {g.id_id})) \{ fprintf(stderr, \"Cast failled at {n.locate}\\n\"); nit_exit(1); } /*cast {self}*/;")
+ v.add_instr("if (({recv}!=NIT_NULL) && !VAL_ISA({recv}, {g.color_id}, {g.id_id})) \{ fprintf(stderr, \"Cast failled\"); {v.printf_locate_error(n)} nit_exit(1); } /*cast {self}*/;")
end
end
redef meth do_compile_inside(v, method, params)
do
var orig_meth: MMLocalProperty = method.global.intro
- var orig_sig = orig_meth.signature.adaptation_to(method.signature.recv)
+ var orig_sig = orig_meth.signature_for(method.signature.recv)
if n_signature != null then
var sig = n_signature
assert sig isa ASignature
var old_return_value = v.return_value
var old_has_return = v.has_return
- var itpos: String
+ var itpos: String = null
if self isa AConcreteInitPropdef then
itpos = "VAL2OBJ({params[0]})->vft[{method.local_class.global.init_table_pos_id}].i"
# v.add_instr("printf(\"{method.full_name}: inittable[%d] = %d\\n\", {itpos}, init_table[{itpos}]);")
else
v.return_value = null
end
+ v.method = method
if self isa AConcreteInitPropdef then
- v.method = method
v.invoke_super_init_calls_after(null)
end
if n_block != null then
redef class ADeferredMethPropdef
redef meth do_compile_inside(v, method, params)
do
- v.add_instr("fprintf(stderr, \"Deferred method {name} called ({first_token.locate})\\n\");")
+ v.add_instr("fprintf(stderr, \"Deferred method %s called\");")
+ v.add_instr(v.printf_locate_error(self))
v.add_instr("nit_exit(1);")
if method.signature.return_type != null then
return("NIT_NULL")
do
var c = method.local_class.name
var n = method.name
- var s: String
+ var s: String = null
if c == once "Int".to_symbol then
if n == once "object_id".to_symbol then
s = "{p[0]}"
end
else if c == once "Float".to_symbol then
if n == once "object_id".to_symbol then
- s = "TAG_Int((int)UNBOX_Float({p[0]}))"
+ s = "TAG_Int((bigint)UNBOX_Float({p[0]}))"
else if n == once "unary -".to_symbol then
s = "BOX_Float(-UNBOX_Float({p[0]}))"
else if n == once "output".to_symbol then
v.add_instr("printf(\"%f\\n\", UNBOX_Float({p[0]}));")
else if n == once "to_i".to_symbol then
- s = "TAG_Int((int)UNBOX_Float({p[0]}))"
+ s = "TAG_Int((bigint)UNBOX_Float({p[0]}))"
else if n == once "+".to_symbol then
s = "BOX_Float(UNBOX_Float({p[0]})+UNBOX_Float({p[1]}))"
else if n == once "-".to_symbol then
v.add_instr("(void)memcpy(UNBOX_NativeString({p[1]})+UNTAG_Int({p[4]}), UNBOX_NativeString({p[0]})+UNTAG_Int({p[3]}), UNTAG_Int({p[2]}));")
end
else if n == once "object_id".to_symbol then
- s = "TAG_Int((int){p[0]})"
+ s = "TAG_Int((bigint){p[0]})"
else if n == once "sys".to_symbol then
s = "(G_sys)"
else if n == once "is_same_type".to_symbol then
redef class AAbortExpr
redef meth compile_stmt(v)
do
- v.add_instr("fprintf(stderr, \"Aborted: {locate}\\n\"); nit_exit(1);")
+ v.add_instr("fprintf(stderr, \"Aborted\"); {v.printf_locate_error(self)} nit_exit(1);")
end
end
redef meth compile_stmt(v)
do
var e = v.compile_expr(n_expr)
- var prop = n_expr.stype.select_method(once "iterator".to_symbol)
+ var prop = n_expr.stype.local_class.select_method(once "iterator".to_symbol)
if prop == null then
printl("No iterator")
return
v.free_var(e)
var iter = v.get_var
v.add_assignment(iter, prop.compile_call(v, [e]))
- var prop2 = ittype.select_method(once "is_ok".to_symbol)
+ var prop2 = ittype.local_class.select_method(once "is_ok".to_symbol)
if prop2 == null then
printl("No is_ok")
return
end
- var prop3 = ittype.select_method(once "item".to_symbol)
+ var prop3 = ittype.local_class.select_method(once "item".to_symbol)
if prop3 == null then
printl("No item")
return
end
- var prop4 = ittype.select_method(once "next".to_symbol)
+ var prop4 = ittype.local_class.select_method(once "next".to_symbol)
if prop4 == null then
printl("No next")
return
redef meth compile_stmt(v)
do
var e = v.compile_expr(n_expr)
- var s = "Assert"
+ var s = ""
if n_id != null then
- s = "Assert '{n_id.text}' "
+ s = " '{n_id.text}' "
end
- v.add_instr("if (!UNTAG_Bool({e})) \{ fprintf(stderr, \"{s} failed: {locate}\\n\"); nit_exit(1);}")
+ v.add_instr("if (!UNTAG_Bool({e})) \{ fprintf(stderr, \"Assert%s failed\", \"{s}\"); {v.printf_locate_error(self)} nit_exit(1);}")
end
end
end
end
+redef class AAsCastExpr
+ redef meth compile_expr(v)
+ do
+ var e = v.compile_expr(n_expr)
+ n_type.stype.compile_type_check(v, e, self)
+ return e
+ end
+end
+
redef class ATrueExpr
redef meth compile_expr(v)
do
redef class AStringFormExpr
redef meth compile_expr(v)
do
- var prop = stype.select_method(once "with_native".to_symbol)
+ var prop = stype.local_class.select_method(once "with_native".to_symbol)
compute_string_info
return prop.compile_constructor_call(v, ["BOX_NativeString(\"{_cstring}\")", "TAG_Int({_cstring_length})"])
end
redef class ASuperstringExpr
redef meth compile_expr(v)
do
- var prop = stype.select_method(once "init".to_symbol)
+ var prop = stype.local_class.select_method(once "init".to_symbol)
var recv = prop.compile_constructor_call(v, new Array[String])
- var prop2 = stype.select_method(once "append".to_symbol)
+ var prop2 = stype.local_class.select_method(once "append".to_symbol)
- var prop3 = stype.select_method(once "to_s".to_symbol)
+ var prop3 = stype.local_class.select_method(once "to_s".to_symbol)
for ne in n_exprs do
var e = v.ensure_var(v.compile_expr(ne))
if ne.stype != stype then
redef class AArrayExpr
redef meth compile_expr(v)
do
- var prop = stype.select_method(once "with_capacity".to_symbol)
+ var prop = stype.local_class.select_method(once "with_capacity".to_symbol)
var recv = prop.compile_constructor_call(v,["TAG_Int({n_exprs.length})"])
- var prop2 = stype.select_method(once "add".to_symbol)
+ var prop2 = stype.local_class.select_method(once "add".to_symbol)
for ne in n_exprs do
var e = v.compile_expr(ne)
prop2.compile_call(v, [recv, e])
redef class ARangeExpr
redef meth compile_expr(v)
do
- var prop = stype.select_method(propname)
+ var prop = stype.local_class.select_method(propname)
var e = v.compile_expr(n_expr)
var e2 = v.compile_expr(n_expr2)
return prop.compile_constructor_call(v, [e, e2])
nitlanguage / nit.git / blobdiff