# 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
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
# 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
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)
for ne in n_exprs do
var e = v.ensure_var(v.compile_expr(ne))
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)
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
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