# Compile a statment node
meth compile_stmt(n: PExpr)
do
+ add_instr("/* Compile stmt {n.locate} */")
n.prepare_compile_stmt(self)
var i = cfc._variable_index
n.compile_stmt(self)
# Compile is expression node
meth compile_expr(n: PExpr): String
do
+ add_instr("/* Compile expr {n.locate} */")
var i = cfc._variable_index
var s = n.compile_expr(self)
cfc._variable_index = i
if s[0] == ' ' then
return s
end
- var v = cfc.get_var
+ var v = cfc.get_var("Result for expr {n.locate}")
add_assignment(v, s)
return v
end
# Ensure that a c expression is a var
- meth ensure_var(s: String): String
+ meth ensure_var(s: String, comment: String): String
do
if s.substring(0,3) == "variable" then
return s
end
- var v = cfc.get_var
- add_assignment(v, s)
+ var v = cfc.get_var(null)
+ add_assignment(v, "{s} /* Ensure var: {comment}*/")
return v
end
end
# Return the next available variable
- meth get_var: String
+ meth get_var(comment: String): String
do
var v = variable(_variable_index)
_variable_index = _variable_index + 1
#visitor.add_decl("val_t {v};")
_variable_index_max = _variable_index
end
+ if comment != null then
+ visitor.add_instr("/* Register {v}: {comment} */")
+ end
return v
end
meth register_variable(v: Variable): String
do
- var s = get_var
+ var s = get_var("Local variable")
_varnames[v] = "variable[{_variable_index-1}]"
return s
end
visitor.add_decl("val_t *variable = NULL;")
end
if _closurevariable_index > 0 then
- visitor.add_decl("void *closurevariable[{_closurevariable_index}];")
+ visitor.add_decl("struct WBT_ *closurevariable[{_closurevariable_index}];")
else
- visitor.add_decl("void **closurevariable = NULL;")
+ visitor.add_decl("struct WBT_ **closurevariable = NULL;")
end
end
# Prepare result value.
# In case of procedure, the return value is still used to intercept breaks
var old_bv = v.nmc.break_value
- ve = v.cfc.get_var
+ ve = v.cfc.get_var("Closure return value and escape marker")
v.nmc.break_value = ve
# Compile closure to c function
# Compile a call as constructor with given args
meth compile_constructor_call(v: CompilerVisitor, recvtype: MMType, cargs: Array[String]): String
do
- var recv = v.cfc.get_var
- v.add_instr("{recv} = NEW_{recvtype.local_class}_{global.intro.cname}({cargs.join(", ")}); /*new {recvtype}*/")
- return recv
+ return "NEW_{recvtype.local_class}_{global.intro.cname}({cargs.join(", ")}) /*new {recvtype}*/"
end
# Compile a call as call-next-method on self with given args
# Cname of the i-th closure C struct type
protected meth closure_cname(i: Int): String
do
- return "WBT_{cname}_{i}"
+ return "FWBT_{cname}_{i}"
end
end
var closcn = closure_cname(i)
var cs = signature.closures[i].signature # Closure signature
var subparams = new Array[String] # Parameters of the closure
- subparams.add("struct {closcn}*")
+ subparams.add("struct WBT_ *")
for j in [0..cs.arity[ do
var p = "val_t"
subparams.add(p)
end
var r = "void"
if cs.return_type != null then r = "val_t"
- params.add("struct {closcn} *{args[first_closure_index+i]}")
- v.add_decl("struct {closcn};")
- v.add_decl("typedef {r} (*F{closcn})({subparams.join(", ")});")
- v.add_decl("struct {closcn} \{F{closcn} fun; val_t *has_broke; val_t broke_value; val_t *variable; void **closurevariable;\};")
+ params.add("struct WBT_ *{args[first_closure_index+i]}")
+ v.add_decl("typedef {r} (*{closcn})({subparams.join(", ")});")
end
if global.is_init then
for i in [0..n_closure_decls.length[ do
var wd = n_closure_decls[i]
var cname = v.cfc.register_closurevariable(wd.variable)
- wd.variable.ctypename = "struct {v.nmc.method.closure_cname(i)} *"
+ wd.variable.ctypename = v.nmc.method.closure_cname(i)
v.add_assignment(cname, "{params[orig_sig.arity + i]}")
end
end
end
v.nmc.return_label = "return_label{v.new_number}"
- v.nmc.return_value = v.cfc.get_var
+ v.nmc.return_value = v.cfc.get_var("Method return value and escape marker")
if self isa AConcreteInitPropdef then
v.invoke_super_init_calls_after(null)
end
v.add_instr("if (UNTAG_Bool({e})) \{ /*if*/")
v.cfc.free_var(e)
v.indent
- var e = v.ensure_var(v.compile_expr(n_then))
+ var e = v.ensure_var(v.compile_expr(n_then), "Then value")
v.unindent
v.add_instr("} else \{ /*if*/")
v.cfc.free_var(e)
v.indent
- var e2 = v.ensure_var(v.compile_expr(n_else))
+ var e2 = v.ensure_var(v.compile_expr(n_else), "Else value")
v.add_assignment(e, e2)
v.unindent
v.add_instr("}")
var e = v.compile_expr(n_expr)
var ittype = meth_iterator.signature.return_type
v.cfc.free_var(e)
- var iter = v.cfc.get_var
+ var iter = v.cfc.get_var("For iterator")
v.add_assignment(iter, meth_iterator.compile_call(v, [e]))
v.add_instr("while (true) \{ /*for*/")
v.indent
- var ok = v.cfc.get_var
+ var ok = v.cfc.get_var("For 'is_ok' result")
v.add_assignment(ok, meth_is_ok.compile_call(v, [iter]))
v.add_instr("if (!UNTAG_Bool({ok})) break; /*for*/")
v.cfc.free_var(ok)
var e = meth_item.compile_call(v, [iter])
- e = v.ensure_var(e)
+ e = v.ensure_var(e, "For item")
var cname = v.cfc.register_variable(variable)
v.add_assignment(cname, e)
var n_block = n_block
redef class AOrExpr
redef meth compile_expr(v)
do
- var e = v.ensure_var(v.compile_expr(n_expr))
+ var e = v.ensure_var(v.compile_expr(n_expr), "Left 'or' operand")
v.add_instr("if (!UNTAG_Bool({e})) \{ /* or */")
v.cfc.free_var(e)
v.indent
redef class AAndExpr
redef meth compile_expr(v)
do
- var e = v.ensure_var(v.compile_expr(n_expr))
+ var e = v.ensure_var(v.compile_expr(n_expr), "Left 'and' operand")
v.add_instr("if (UNTAG_Bool({e})) \{ /* and */")
v.cfc.free_var(e)
v.indent
do
compute_string_info
var i = v.new_number
- var cvar = v.cfc.get_var
+ var cvar = v.cfc.get_var("Once String constant")
v.add_decl("static val_t once_value_{i} = NIT_NULL; /* Once value for string {cvar}*/")
v.add_instr("if (once_value_{i} != NIT_NULL) {cvar} = once_value_{i};")
v.add_instr("else \{")
redef meth compile_expr(v)
do
var array = meth_with_capacity.compile_constructor_call(v, atype, ["TAG_Int({n_exprs.length})"])
+ array = v.ensure_var(array, "Array (for super-string)")
for ne in n_exprs do
- var e = v.ensure_var(v.compile_expr(ne))
+ var e = v.ensure_var(v.compile_expr(ne), "super-string element")
if ne.stype != stype then
v.add_assignment(e, meth_to_s.compile_call(v, [e]))
end
redef meth compile_expr(v)
do
var recv = meth_with_capacity.compile_constructor_call(v, stype, ["TAG_Int({n_exprs.length})"])
+ recv = v.ensure_var(recv, "Literal array")
for ne in n_exprs do
var e = v.compile_expr(ne)
# Build closure
var closcnv = "wbclos{v.new_number}"
- v.add_decl("struct {closcn} {closcnv};")
- v.add_instr("{closcnv}.fun = {cname};")
+ v.add_decl("struct WBT_ {closcnv};")
+ v.add_instr("{closcnv}.fun = (fun_t){cname};")
v.add_instr("{closcnv}.has_broke = NULL;")
if cfc_old != null then
v.add_instr("{closcnv}.variable = closctx->variable;")
protected meth decl_csignature(v: CompilerVisitor, args: Array[String], closcn: String): String
do
var params = new Array[String]
- params.add("struct {closcn}* closctx")
+ params.add("struct WBT_ *closctx")
for i in [0..closure.signature.arity[ do
var p = "val_t {args[i]}"
params.add(p)
end
var p = params.join(", ")
var s = "{ret} {cname}({p})"
- v.add_decl("struct {closcn};")
v.add_decl("typedef {ret} (* {cname}_t)({p});")
v.add_decl(s + ";")
return s
var old_cl = v.nmc.continue_label
var old_bl = v.nmc.break_label
- v.nmc.continue_value = v.cfc.get_var
+ v.nmc.continue_value = v.cfc.get_var("Continue value and escape marker")
v.nmc.continue_label = "continue_label{v.new_number}"
v.nmc.break_label = v.nmc.return_label
var old_cl = v.nmc.continue_label
var old_bl = v.nmc.break_label
- v.nmc.continue_value = v.cfc.get_var
+ v.nmc.continue_value = v.cfc.get_var("Continue value and escape marker")
v.nmc.continue_label = "continue_label{v.new_number}"
v.nmc.break_label = v.nmc.return_label
var cargs = new Array[String]
for a in arguments do cargs.add(v.compile_expr(a))
var va: String = null
- if variable.closure.signature.return_type != null then va = v.cfc.get_var
+ if variable.closure.signature.return_type != null then va = v.cfc.get_var("Closure call result value")
if variable.closure.is_optional then
v.add_instr("if({v.cfc.varname(variable)}==NULL) \{")
v.indent
end
- var ivar = "(({variable.ctypename})({v.cfc.varname(variable)}))"
+ var ivar = v.cfc.varname(variable)
var cargs2 = [ivar]
cargs2.append(cargs)
- var s = "({ivar}->fun({cargs2.join(", ")})) /* Invoke closure {variable} */"
+ var s = "(({variable.ctypename})({ivar}->fun))({cargs2.join(", ")}) /* Invoke closure {variable} */"
if va != null then
v.add_assignment(va, s)
else
redef meth compile_expr(v)
do
var i = v.new_number
- var cvar = v.cfc.get_var
+ var cvar = v.cfc.get_var("Once expression result")
v.add_decl("static val_t once_value_{i}; static int once_bool_{i}; /* Once value for {cvar}*/")
v.add_instr("if (once_bool_{i}) {cvar} = once_value_{i};")
v.add_instr("else \{")
nitlanguage / nit.git / blobdiff