feat(compiler): list literals, typed compound assignment, file:line diagnostics
- `[a, b, c]` list literals (E_LIST → emit_list); static_type learns slice-element, `new T`, list, string and literal kinds - `x op= y` lowers through the same path as `x = x op y` (emit_bin_vals): fixed `*=`/`/=` use the Q16.16 64-bit paths, string `+=` concatenates, int→long widens; unary `-` keeps a fixed operand's type (arith_ty) - one `unescape()` table for "strings", 'chars' and `interpolation`; `'\''`, `'\\'`, `'\"'` no longer read as 0; unterminated char literals and unexpected characters are errors instead of silently skipped - every diagnostic is `file:line: error: msg` (g_parse_file / g_err_file, Node.file + Node.line set by node()); tok_desc() in expectation errors; duplicate `function` names and unknown `phase` names are reported in source terms (phase_id used to default unknown phases to Overlay) - interpolation holes skip braces inside string literals - hand-IR preludes move from the user `@fn_` prefix to `@lp_` so a user `is_ws` / `str_eq` / `path_join` no longer collides at link time - `@ClearColor(expr)` accepts any constant expression; `Os.pid()` added (docs page + inventory); `str_starts()` in support/str - main.ludic: `else if` flag ladder, char literals, stale script comments - examples/lang/operators.ludic covers all of the above; os.ludic covers Os.pid; docs pages for Os.pid and the Overlay phase; ten changesets - reseeded: selfhost/ludicc.seed.ll is the new compiler's own fixpoint Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
This commit is contained in:
parent
ad548840c7
commit
647dfec334
88 changed files with 30081 additions and 29179 deletions
|
|
@ -7,7 +7,7 @@ const MAX_ENT: int = 1024
|
|||
|
||||
function has_systems() -> bool {
|
||||
var i = 0
|
||||
while i < len(prog) { if prog[i].kind == N_SYS { return true }; i = i + 1 }
|
||||
while i < len(prog) { if prog[i].kind == N_SYS { return true }; i += 1 }
|
||||
# a game with no hand-written handler but a well-known engine component still
|
||||
# runs a frame loop — the engine owns the system that ticks that component
|
||||
# (#43/#47). Treat it as a systems game so the loop / tick helpers are emitted.
|
||||
|
|
@ -16,7 +16,7 @@ function has_systems() -> bool {
|
|||
}
|
||||
function has_models() -> bool {
|
||||
var i = 0
|
||||
while i < len(prog) { if prog[i].kind == N_ARCH { return true }; i = i + 1 }
|
||||
while i < len(prog) { if prog[i].kind == N_ARCH { return true }; i += 1 }
|
||||
return false
|
||||
}
|
||||
# does the program declare a well-known engine component? Each one is auto-ticked
|
||||
|
|
@ -30,7 +30,7 @@ function uses_engine_systems() -> bool {
|
|||
# Motion / Light2D; packages append via @EngineSystem), or an Occluder (which
|
||||
# feeds the Light2D pass without an esys of its own).
|
||||
var i = 0
|
||||
while i < len(g_esys_comp) { if find_comp(g_esys_comp[i]) != null { return true }; i = i + 1 }
|
||||
while i < len(g_esys_comp) { if find_comp(g_esys_comp[i]) != null { return true }; i += 1 }
|
||||
if find_comp("Occluder") != null { return true }
|
||||
return false
|
||||
}
|
||||
|
|
@ -39,7 +39,7 @@ function uses_engine_systems() -> bool {
|
|||
# compiler's auto frame loop. A game with handlers and no entry uses the auto-loop.
|
||||
function has_entry() -> bool {
|
||||
var i = 0
|
||||
while i < len(prog) { if prog[i].kind == N_MAIN { return true }; i = i + 1 }
|
||||
while i < len(prog) { if prog[i].kind == N_MAIN { return true }; i += 1 }
|
||||
return false
|
||||
}
|
||||
# Does this program run the ECS? A property alone no longer answers that — the
|
||||
|
|
@ -82,11 +82,11 @@ function emit_ecs_storage() -> void {
|
|||
# one enabled-flag global per model and per handler (default enabled)
|
||||
if c.kind == N_ARCH { emith(`@ME_{c.s} = internal global i32 1\n`) }
|
||||
if c.kind == N_SYS { emith(`@HE_{c.s} = internal global i32 1\n`) }
|
||||
i = i + 1
|
||||
i += 1
|
||||
}
|
||||
# one enabled-flag global per toggled layer (default shown)
|
||||
var li = 0
|
||||
while li < len(g_toggled_layers) { emith(`@LE_{g_toggled_layers[li]} = internal global i32 1\n`); li = li + 1 }
|
||||
while li < len(g_toggled_layers) { emith(`@LE_{g_toggled_layers[li]} = internal global i32 1\n`); li += 1 }
|
||||
}
|
||||
|
||||
# L_reset(e): clear every has-flag and the archetype kind for entity e
|
||||
|
|
@ -100,7 +100,7 @@ function emit_ecs_allocator() -> void {
|
|||
emit(" "); emit(hn); emit(" = getelementptr inbounds ["); emit(me); emit(" x i8], ptr @H_"); emit(prog[i].s); emit(", i32 0, i32 %e\n")
|
||||
emit(" store i8 0, ptr "); emit(hn); emit("\n")
|
||||
}
|
||||
i = i + 1
|
||||
i += 1
|
||||
}
|
||||
emit(" %k = getelementptr inbounds ["); emit(me); emit(" x i32], ptr @L_kind, i32 0, i32 %e\n")
|
||||
emit(" store i32 0, ptr %k\n")
|
||||
|
|
|
|||
|
|
@ -68,7 +68,7 @@ function emit_engine_systems_for_phase(phase: pointer) -> void {
|
|||
var i = 0
|
||||
while i < len(g_esys_comp) {
|
||||
if (g_esys_phase[i] == phase) { emit_one_engine_system(g_esys_comp[i], g_esys_fn[i]) }
|
||||
i = i + 1
|
||||
i += 1
|
||||
}
|
||||
if (phase == "Update") {
|
||||
# Tween.* fluent handles (#48): advanced each Update tick when the game uses
|
||||
|
|
@ -100,7 +100,7 @@ function emit_countdown_system() -> void {
|
|||
if d.kind == N_COMP {
|
||||
var any = false
|
||||
var f = 0
|
||||
while f < len(d.kids) { if (d.kids[f].ty == "countdown") { any = true }; f = f + 1 }
|
||||
while f < len(d.kids) { if (d.kids[f].ty == "countdown") { any = true }; f += 1 }
|
||||
if any {
|
||||
let sk = itoa(k); let nk = itoa(k + 1)
|
||||
emit("c"); emit(sk); emit(":\n")
|
||||
|
|
@ -121,13 +121,13 @@ function emit_countdown_system() -> void {
|
|||
emit(" %fn"); emit(fk); emit(" = select i1 %fp"); emit(fk); emit(", i32 %fd"); emit(fk); emit(", i32 %fv"); emit(fk); emit("\n")
|
||||
emit(" store i32 %fn"); emit(fk); emit(", ptr %fa"); emit(fk); emit("\n")
|
||||
}
|
||||
f = f + 1
|
||||
f += 1
|
||||
}
|
||||
emit(" br label %c"); emit(nk); emit("\n")
|
||||
k = k + 1
|
||||
k += 1
|
||||
}
|
||||
}
|
||||
i = i + 1
|
||||
i += 1
|
||||
}
|
||||
emit("c"); emit(itoa(k)); emit(":\n br label %next\n")
|
||||
emit("next:\n %i1 = add i32 %i, 1\n br label %loop\ndone:\n ret void\n}\n\n")
|
||||
|
|
@ -154,7 +154,7 @@ function emit_prefab_fn(pre: Node) -> void {
|
|||
}
|
||||
function emit_prefab_fns() -> void {
|
||||
var i = 0
|
||||
while i < len(prog) { if prog[i].kind == N_PREFAB { emit_prefab_fn(prog[i]) }; i = i + 1 }
|
||||
while i < len(prog) { if prog[i].kind == N_PREFAB { emit_prefab_fn(prog[i]) }; i += 1 }
|
||||
g_uses_str = true
|
||||
ll_t = 0; ll_lbl = 0; g_term = false; loc_reset(); nloop = 0; nself = 0
|
||||
let fbody = buf_new()
|
||||
|
|
@ -167,7 +167,7 @@ function emit_prefab_fns() -> void {
|
|||
if d.kind == N_PREFAB {
|
||||
let lit = node(E_STR); lit.s = d.s
|
||||
let sv = emit_expr(lit)
|
||||
let same = emit_bind(`call i32 @fn_str_eq(ptr %name, ptr {sv.code})`)
|
||||
let same = emit_bind(`call i32 @lp_str_eq(ptr %name, ptr {sv.code})`)
|
||||
let hit = emit_bind(`icmp ne i32 {same}, 0`)
|
||||
let yes = lbl("pf"); let no = lbl("pfn")
|
||||
emit(" br i1 "); emit(hit); emit(", label %"); emit(yes); emit(", label %"); emit(no); emit("\n")
|
||||
|
|
@ -176,7 +176,7 @@ function emit_prefab_fns() -> void {
|
|||
emit(" ret i32 "); emit(r); emit("\n")
|
||||
emit(no); emit(":\n")
|
||||
}
|
||||
i = i + 1
|
||||
i += 1
|
||||
}
|
||||
emit(" ret i32 -1\n")
|
||||
code = saved
|
||||
|
|
@ -209,11 +209,20 @@ function phase_id(phase: pointer) -> int {
|
|||
if phase == "LateUpdate" { return 3 }
|
||||
if phase == "Render" { return 4 }
|
||||
if phase == "Start" { return 5 }
|
||||
if phase == "OnQuit" { return 6 }
|
||||
if phase == "OnQuit" { return 6 } # the @OnQuit hook's internal slot, never written as `phase OnQuit`
|
||||
if phase == "Overlay" { return 7 } # HUD/UI pass after the engine drew sprites
|
||||
perr(`unknown phase '{phase}'`) # the parser rejects these; a desugaring bug if we get here
|
||||
return 7
|
||||
}
|
||||
|
||||
# the phases a handler may declare — the frame loop's buckets, in the order the
|
||||
# frame runs them (Start once, then Input … Overlay every tick)
|
||||
function is_phase_name(name: pointer) -> bool {
|
||||
if name == "Start" or name == "Input" or name == "FixedUpdate" or name == "Update" { return true }
|
||||
if name == "LateUpdate" or name == "Render" or name == "Overlay" { return true }
|
||||
return false
|
||||
}
|
||||
|
||||
# --- binary-module glue (issue #64) ------------------------------------------
|
||||
# A module compiled with --emit-module carries no main and no world table (the
|
||||
# consumer owns them). It references the host's reflection ABI, so we (1) declare
|
||||
|
|
@ -248,7 +257,7 @@ function emit_module_glue() -> void {
|
|||
var i = 0
|
||||
while i < len(g_mod_sys_fn) {
|
||||
emit(" call i32 @ludic_register_system(ptr @fn_"); emit(g_mod_sys_fn[i]); emit(", i32 "); emit(itoa(phase_id(g_mod_sys_phase[i]))); emit(")\n")
|
||||
i = i + 1
|
||||
i += 1
|
||||
}
|
||||
emit(" ret void\n}\n\n")
|
||||
# run @__ludic_mod_init at image load (dyld runs constructors before main)
|
||||
|
|
@ -309,12 +318,12 @@ function emit_calls_for_phase(phase: pointer) -> void {
|
|||
while i < len(prog) {
|
||||
let d = prog[i]
|
||||
if d.kind == N_SYS and (d.ty == phase) and (d.c == null) { emit_call_one(d) }
|
||||
i = i + 1
|
||||
i += 1
|
||||
}
|
||||
# any scene-owned handlers in this phase? gate them on one @L_scene snapshot.
|
||||
var has_sc = false
|
||||
i = 0
|
||||
while i < len(prog) { let d = prog[i]; if d.kind == N_SYS and (d.ty == phase) and (d.c != null) { has_sc = true }; i = i + 1 }
|
||||
while i < len(prog) { let d = prog[i]; if d.kind == N_SYS and (d.ty == phase) and (d.c != null) { has_sc = true }; i += 1 }
|
||||
if has_sc {
|
||||
let cs = emit_bind("load i32, ptr @L_scene")
|
||||
i = 0
|
||||
|
|
@ -328,7 +337,7 @@ function emit_calls_for_phase(phase: pointer) -> void {
|
|||
emit_call_one(d)
|
||||
emit(" br label %"); emit(skip); emit("\n"); emit(skip); emit(":\n")
|
||||
}
|
||||
i = i + 1
|
||||
i += 1
|
||||
}
|
||||
}
|
||||
emit_engine_systems_for_phase(phase) # engine-owned systems run after every user handler
|
||||
|
|
@ -340,7 +349,7 @@ function emit_calls_for_phase(phase: pointer) -> void {
|
|||
function emit_scene_menu_render() -> void {
|
||||
var any = false
|
||||
var i = 0
|
||||
while i < len(g_scenes) { if (g_scenes[i].ty != null) { any = true }; i = i + 1 }
|
||||
while i < len(g_scenes) { if (g_scenes[i].ty != null) { any = true }; i += 1 }
|
||||
if not any { return }
|
||||
let cs = emit_bind("load i32, ptr @L_scene")
|
||||
i = 0
|
||||
|
|
@ -353,7 +362,7 @@ function emit_scene_menu_render() -> void {
|
|||
emit(run); emit(":\n call void @fn_rt_ui_render()\n")
|
||||
emit(" br label %"); emit(skip); emit("\n"); emit(skip); emit(":\n")
|
||||
}
|
||||
i = i + 1
|
||||
i += 1
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -393,7 +402,7 @@ function emit_scene_hooks() -> void {
|
|||
g_cur_scene = sc
|
||||
emit_scene_fn(sc.s, "enter", sc.a, sc.ty)
|
||||
emit_scene_fn(sc.s, "exit", sc.b, sc.ty)
|
||||
i = i + 1
|
||||
i += 1
|
||||
}
|
||||
g_cur_scene = null
|
||||
if len(g_scenes) > 0 { emit_scene_leave_fn() } # a program without scenes has no @L_scene
|
||||
|
|
@ -413,7 +422,7 @@ function emit_scene_leave_fn() -> void {
|
|||
emit(" br i1 %is"); emit(k); emit(", label %leave"); emit(k); emit(", label %next"); emit(k); emit("\n")
|
||||
emit("leave"); emit(k); emit(":\n call void @scene_exit_"); emit(sc.s); emit("()\n ret void\n")
|
||||
emit("next"); emit(k); emit(":\n")
|
||||
i = i + 1
|
||||
i += 1
|
||||
}
|
||||
emit(" ret void\n}\n\n")
|
||||
}
|
||||
|
|
@ -447,7 +456,7 @@ function emit_despawn_hooks() -> void {
|
|||
emit(buf_str(falloc))
|
||||
emit(buf_str(fbody))
|
||||
emit("}\n\n")
|
||||
i = i + 1
|
||||
i += 1
|
||||
}
|
||||
emit_despawn_all_fn()
|
||||
}
|
||||
|
|
@ -475,7 +484,7 @@ function emit_world_despawn_fn() -> void {
|
|||
if (find_event(dev) != null) { emit(" call void @ev_"); emit(dev); emit("(i32 %e, i32 0)\n") }
|
||||
emit(" br label %next"); emit(si); emit("\n")
|
||||
emit("next"); emit(si); emit(":\n")
|
||||
i = i + 1
|
||||
i += 1
|
||||
}
|
||||
}
|
||||
if len(g_events) > 0 { emit(" call void @ludic_sweep_entity(i32 %e)\n") } # EV5: drop entity-scoped listeners
|
||||
|
|
@ -512,7 +521,7 @@ function emit_despawn_all_fn() -> void {
|
|||
if (find_event(dev) != null) { emit(" call void @ev_"); emit(dev); emit("(i32 %i, i32 %reason)\n") }
|
||||
emit(" br label %next"); emit(si); emit("\n")
|
||||
emit("next"); emit(si); emit(":\n")
|
||||
i = i + 1
|
||||
i += 1
|
||||
}
|
||||
emit(" br label %cont\n")
|
||||
emit("cont:\n %i1 = add i32 %i, 1\n br label %loop\n")
|
||||
|
|
@ -557,7 +566,7 @@ function emit_event_fns() -> void {
|
|||
while t < len(ev.kids) {
|
||||
if t > 0 { emith(", ") }
|
||||
emith(llty(ev.kids[t].ty))
|
||||
t = t + 1
|
||||
t += 1
|
||||
}
|
||||
if ev.ival == 1 { if len(ev.kids) > 0 { emith(", ") }; emith("i32") }
|
||||
emith(" }\n")
|
||||
|
|
@ -629,7 +638,7 @@ function emit_event_fns() -> void {
|
|||
let slot = emit_alloca(lt)
|
||||
emit(" store "); emit(lt); emit(" %p"); emit(itoa(f)); emit(", ptr "); emit(slot); emit("\n")
|
||||
loc_push(fd.s, slot, fd.ty)
|
||||
f = f + 1
|
||||
f += 1
|
||||
}
|
||||
# cancellable: zero the flag and expose its address to `cancel` in the listeners
|
||||
var caddr = null
|
||||
|
|
@ -642,7 +651,7 @@ function emit_event_fns() -> void {
|
|||
var i = 0
|
||||
while i < len(g_onlisten) {
|
||||
if (g_onlisten[i].s == en) { nloc = base; g_term = false; emit_block(g_onlisten[i].a) }
|
||||
i = i + 1
|
||||
i += 1
|
||||
}
|
||||
# the open half: walk the foreign callback array in registration order
|
||||
if not g_term {
|
||||
|
|
@ -684,13 +693,13 @@ function emit_event_fns() -> void {
|
|||
while g < len(ev.kids) {
|
||||
if g > 0 { emit(", ") }
|
||||
emit(llty(ev.kids[g].ty)); emit(" %p"); emit(itoa(g))
|
||||
g = g + 1
|
||||
g += 1
|
||||
}
|
||||
emit(") {\nentry:\n")
|
||||
emit(buf_str(falloc))
|
||||
emit(buf_str(fbody))
|
||||
emit("}\n\n")
|
||||
e = e + 1
|
||||
e += 1
|
||||
}
|
||||
|
||||
# EV5: @ludic_sweep_entity(owner) — remove every entity-scoped listener owned by
|
||||
|
|
@ -719,8 +728,7 @@ function emit_event_fns() -> void {
|
|||
emit("swd"); emit(sk); emit(":\n store i32 0, ptr %ci\n")
|
||||
if (e2 + 1) < len(g_events) { emit(" br label %sw"); emit(itoa(e2 + 1)); emit("\n") }
|
||||
else { emit(" ret void\n") }
|
||||
e2 = e2 + 1
|
||||
e2 += 1
|
||||
}
|
||||
emit("}\n\n")
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -37,7 +37,7 @@ function emit_machine(st: Node) -> void {
|
|||
s = emit_bind(`call i32 @fn_rt_reg(i32 {regv.code})`)
|
||||
}
|
||||
if nmach < len(mach_stk) { mach_stk[nmach] = st } else { push(mach_stk, st) }
|
||||
nmach = nmach + 1
|
||||
nmach += 1
|
||||
let endl = lbl("smend")
|
||||
var i = 0
|
||||
while i < len(st.kids) {
|
||||
|
|
@ -50,11 +50,11 @@ function emit_machine(st: Node) -> void {
|
|||
emit_block(state.a)
|
||||
if not g_term { emit(" br label %"); emit(endl); emit("\n") }
|
||||
emit(nxt); emit(":\n"); g_term = false
|
||||
i = i + 1
|
||||
i += 1
|
||||
}
|
||||
if not g_term { emit(" br label %"); emit(endl); emit("\n") }
|
||||
emit(endl); emit(":\n"); g_term = false
|
||||
nmach = nmach - 1
|
||||
nmach -= 1
|
||||
}
|
||||
|
||||
# `become Name` — a machine state transition when Name is a state of an
|
||||
|
|
@ -66,7 +66,7 @@ function emit_become(st: Node) -> void {
|
|||
let m = mach_stk[nmach - 1]
|
||||
var target: Node = null
|
||||
var i = 0
|
||||
while i < len(m.kids) { if (m.kids[i].s == st.s) { target = m.kids[i] }; i = i + 1 }
|
||||
while i < len(m.kids) { if (m.kids[i].s == st.s) { target = m.kids[i] }; i += 1 }
|
||||
if (target != null) {
|
||||
let gv = machine_var(m.a)
|
||||
let sv = machine_state_value(m, target)
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
|
||||
function find_arch_id(name: pointer) -> int {
|
||||
var i = 0; var n = 1
|
||||
while i < len(prog) { if prog[i].kind == N_ARCH { if (prog[i].s == name) { return n }; n = n + 1 }; i = i + 1 }
|
||||
while i < len(prog) { if prog[i].kind == N_ARCH { if (prog[i].s == name) { return n }; n += 1 }; i += 1 }
|
||||
return 0
|
||||
}
|
||||
|
||||
|
|
@ -13,7 +13,7 @@ function emit_query(st: Node) -> void {
|
|||
let ip = emit_alloca("i32")
|
||||
store_at("i32", "0", ip)
|
||||
if nself < len(self_stk) { self_stk[nself] = ip } else { push(self_stk, ip) }
|
||||
nself = nself + 1
|
||||
nself += 1
|
||||
|
||||
let cond = lbl("qcond"); let body = lbl("qbody"); let nxt = lbl("qnext"); let endl = lbl("qend")
|
||||
emit(" br label %"); emit(cond); emit("\n")
|
||||
|
|
@ -54,7 +54,7 @@ function emit_query(st: Node) -> void {
|
|||
let keep = lbl("qt")
|
||||
emit(" br i1 "); emit(ok); emit(", label %"); emit(keep); emit(", label %"); emit(nxt); emit("\n")
|
||||
emit(keep); emit(":\n")
|
||||
t = t + 1
|
||||
t += 1
|
||||
}
|
||||
|
||||
# bind the requested components to the loop variables, in order
|
||||
|
|
@ -70,10 +70,10 @@ function emit_query(st: Node) -> void {
|
|||
let vslot = emit_alloca("ptr")
|
||||
emit(" store ptr "); emit(slot); emit(", ptr "); emit(vslot); emit("\n")
|
||||
loc_push(st.kids[vi].s, vslot, tm.s)
|
||||
vi = vi + 1
|
||||
vi += 1
|
||||
}
|
||||
}
|
||||
t = t + 1
|
||||
t += 1
|
||||
}
|
||||
|
||||
# optional where-clause
|
||||
|
|
@ -97,5 +97,5 @@ function emit_query(st: Node) -> void {
|
|||
store_at("i32", i3, ip)
|
||||
emit(" br label %"); emit(cond); emit("\n")
|
||||
emit(endl); emit(":\n"); g_term = false
|
||||
nself = nself - 1
|
||||
nself -= 1
|
||||
}
|
||||
|
|
|
|||
|
|
@ -18,7 +18,7 @@ var g_off: pointer = null # current byte-offset register, buffer mode
|
|||
|
||||
function emit_io(fn2: pointer, p: pointer, bytes: pointer) -> void {
|
||||
if (g_snap_mode == "file") {
|
||||
let r = `%io{itoa(g_iok)}`; g_iok = g_iok + 1
|
||||
let r = `%io{itoa(g_iok)}`; g_iok += 1
|
||||
emit(" "); emit(r); emit(" = call i64 @"); emit(fn2); emit("(ptr "); emit(p); emit(", i64 1, i64 "); emit(bytes); emit(", ptr %f)\n")
|
||||
return
|
||||
}
|
||||
|
|
@ -26,7 +26,7 @@ function emit_io(fn2: pointer, p: pointer, bytes: pointer) -> void {
|
|||
let noff = `%ioff{itoa(g_iok)}`
|
||||
emit(" "); emit(noff); emit(" = add i64 "); emit(g_off); emit(", "); emit(bytes); emit("\n")
|
||||
g_off = noff
|
||||
g_iok = g_iok + 1
|
||||
g_iok += 1
|
||||
return
|
||||
}
|
||||
# buffer mode: dst/src is %buf + g_off, copy `bytes`, then advance the cursor
|
||||
|
|
@ -40,7 +40,7 @@ function emit_io(fn2: pointer, p: pointer, bytes: pointer) -> void {
|
|||
let noff = `%ioff{itoa(g_iok)}`
|
||||
emit(" "); emit(noff); emit(" = add i64 "); emit(g_off); emit(", "); emit(bytes); emit("\n")
|
||||
g_off = noff
|
||||
g_iok = g_iok + 1
|
||||
g_iok += 1
|
||||
}
|
||||
|
||||
function emit_snapshot_blocks(fn2: pointer) -> void {
|
||||
|
|
@ -57,7 +57,7 @@ function emit_snapshot_blocks(fn2: pointer) -> void {
|
|||
# round-trips ownership (like @L_kind). Gated, so non-@Owned snapshots are unchanged.
|
||||
if net_has_owned() { emit_io(fn2, "@L_owner_arr", "%nalive") }
|
||||
var i = 0
|
||||
while i < len(prog) { if prog[i].kind == N_VAR { emit_io(fn2, `@g_{prog[i].s}`, "4") }; i = i + 1 }
|
||||
while i < len(prog) { if prog[i].kind == N_VAR { emit_io(fn2, `@g_{prog[i].s}`, "4") }; i += 1 }
|
||||
var ci = 0
|
||||
i = 0
|
||||
while i < len(prog) {
|
||||
|
|
@ -67,9 +67,9 @@ function emit_snapshot_blocks(fn2: pointer) -> void {
|
|||
emit(" "); emit(csz); emit(" = ptrtoint ptr getelementptr (%Cmp_"); emit(c); emit(", ptr null, i32 "); emit(me); emit(") to i64\n")
|
||||
emit_io(fn2, `@S_{c}`, csz)
|
||||
emit_io(fn2, `@H_{c}`, me)
|
||||
ci = ci + 1
|
||||
ci += 1
|
||||
}
|
||||
i = i + 1
|
||||
i += 1
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -6,9 +6,9 @@ function emit_hook_with_self(e: pointer, body: Node) -> void {
|
|||
let sslot = emit_alloca("i32")
|
||||
emit(" store i32 "); emit(e); emit(", ptr "); emit(sslot); emit("\n")
|
||||
if nself < len(self_stk) { self_stk[nself] = sslot } else { push(self_stk, sslot) }
|
||||
nself = nself + 1
|
||||
nself += 1
|
||||
emit_block(body)
|
||||
nself = nself - 1
|
||||
nself -= 1
|
||||
}
|
||||
|
||||
function emit_init_component(e: pointer, comp: pointer, rec: Node) -> void {
|
||||
|
|
@ -30,7 +30,7 @@ function emit_init_component(e: pointer, comp: pointer, rec: Node) -> void {
|
|||
if (lt == "ptr") { v = "null" }
|
||||
if (fd.a != null) { let dv = emit_expr(fd.a); v = dv.code }
|
||||
emit(" store "); emit(lt); emit(" "); emit(v); emit(", ptr "); emit(addr); emit("\n")
|
||||
f = f + 1
|
||||
f += 1
|
||||
}
|
||||
# per-spawn overrides
|
||||
if (rec != null) {
|
||||
|
|
@ -44,7 +44,7 @@ function emit_init_component(e: pointer, comp: pointer, rec: Node) -> void {
|
|||
let dv = emit_expr(fi.a)
|
||||
emit(" store "); emit(llty(field_type(c, fi.s))); emit(" "); emit(dv.code); emit(", ptr "); emit(addr); emit("\n")
|
||||
}
|
||||
j = j + 1
|
||||
j += 1
|
||||
}
|
||||
}
|
||||
# @OnAttach(Property) runs once the property is attached and seeded
|
||||
|
|
@ -74,7 +74,7 @@ function emit_bind_props(model: Node, e: pointer) -> void {
|
|||
let vslot = emit_alloca("ptr")
|
||||
emit(" store ptr "); emit(slot); emit(", ptr "); emit(vslot); emit("\n")
|
||||
loc_push(pname, vslot, pname)
|
||||
c = c + 1
|
||||
c += 1
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -82,7 +82,7 @@ function emit_bind_props(model: Node, e: pointer) -> void {
|
|||
function spawn_record(n: Node, cn: pointer) -> Node {
|
||||
if (n == null) { return null }
|
||||
var i = 0
|
||||
while i < len(n.kids) { if (n.kids[i].s == cn) { return n.kids[i].a }; i = i + 1 }
|
||||
while i < len(n.kids) { if (n.kids[i].s == cn) { return n.kids[i].a }; i += 1 }
|
||||
return null
|
||||
}
|
||||
# a prefab's preset fields with the spawn's own overrides after them (later wins)
|
||||
|
|
@ -91,9 +91,9 @@ function merge_records(base: Node, over: Node) -> Node {
|
|||
if (over == null) { return base }
|
||||
let m = node(E_REC)
|
||||
var i = 0
|
||||
while i < len(base.kids) { push(m.kids, base.kids[i]); i = i + 1 }
|
||||
while i < len(base.kids) { push(m.kids, base.kids[i]); i += 1 }
|
||||
i = 0
|
||||
while i < len(over.kids) { push(m.kids, over.kids[i]); i = i + 1 }
|
||||
while i < len(over.kids) { push(m.kids, over.kids[i]); i += 1 }
|
||||
return m
|
||||
}
|
||||
|
||||
|
|
@ -106,7 +106,7 @@ function spawn_model(name: pointer) -> pointer {
|
|||
let p = find_prefab(n)
|
||||
if (p == null) { return n }
|
||||
n = p.ty
|
||||
depth = depth + 1
|
||||
depth += 1
|
||||
if depth > 16 { perr(`prefab {name}: the chain of prefabs never reaches a model`) }
|
||||
}
|
||||
return n
|
||||
|
|
@ -132,7 +132,7 @@ function emit_spawn(st: Node) -> pointer {
|
|||
while c < len(arch.kids) {
|
||||
let cn = arch.kids[c].s
|
||||
emit_init_component(e, cn, merge_records(prefab_record(st.s, cn), spawn_record(st, cn)))
|
||||
c = c + 1
|
||||
c += 1
|
||||
}
|
||||
let ob = onspawn_body(model) # @OnSpawn(Model) hook runs after init
|
||||
if (ob != null) {
|
||||
|
|
@ -147,7 +147,7 @@ function emit_spawn(st: Node) -> pointer {
|
|||
if (find_event(sev) != null) { emit(" call void @ev_"); emit(sev); emit("(i32 "); emit(e); emit(")\n") }
|
||||
} else {
|
||||
var i = 0
|
||||
while i < len(st.kids) { emit_init_component(e, st.kids[i].s, st.kids[i].a); i = i + 1 }
|
||||
while i < len(st.kids) { emit_init_component(e, st.kids[i].s, st.kids[i].a); i += 1 }
|
||||
}
|
||||
return e # the new entity id (for ludic_spawn_<M>)
|
||||
}
|
||||
|
|
@ -169,7 +169,7 @@ function emit_despawn(st: Node) -> void {
|
|||
let dev = `model_{mname}_despawn` # EV1: @Public despawn event
|
||||
if (find_event(dev) != null) { emit(" call void @ev_"); emit(dev); emit("(i32 "); emit(v.code); emit(", i32 0)\n") }
|
||||
emit(" br label %"); emit(no); emit("\n"); emit(no); emit(":\n")
|
||||
i = i + 1
|
||||
i += 1
|
||||
}
|
||||
}
|
||||
if len(g_events) > 0 { emit(" call void @ludic_sweep_entity(i32 "); emit(v.code); emit(")\n") } # EV5: drop entity-scoped listeners
|
||||
|
|
@ -229,7 +229,7 @@ function emit_detach(st: Node) -> void {
|
|||
# flag). A bare `<Model>` / `<Handler>` flips a global enabled flag.
|
||||
function find_sys(name: pointer) -> Node {
|
||||
var i = 0
|
||||
while i < len(prog) { let d = prog[i]; if d.kind == N_SYS and (d.s == name) { return d }; i = i + 1 }
|
||||
while i < len(prog) { let d = prog[i]; if d.kind == N_SYS and (d.s == name) { return d }; i += 1 }
|
||||
return null
|
||||
}
|
||||
function emit_toggle(st: Node) -> void {
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ function ui_wtype(w: Node) -> int {
|
|||
}
|
||||
function ui_prop(w: Node, key: pointer) -> Node {
|
||||
var i = 0
|
||||
while i < len(w.b.kids) { if (w.b.kids[i].s == key) { return w.b.kids[i].a }; i = i + 1 }
|
||||
while i < len(w.b.kids) { if (w.b.kids[i].s == key) { return w.b.kids[i].a }; i += 1 }
|
||||
return null
|
||||
}
|
||||
# a widget's props plus the text props (font, size, fg, align) it inherits from the
|
||||
|
|
@ -25,7 +25,7 @@ function ui_props_with_inherited(i: int) -> []Node {
|
|||
let w = uiw[i]
|
||||
let out = new []Node
|
||||
var p = 0
|
||||
while p < len(w.b.kids) { push(out, w.b.kids[p]); p = p + 1 }
|
||||
while p < len(w.b.kids) { push(out, w.b.kids[p]); p += 1 }
|
||||
let keys = new []pointer
|
||||
push(keys, "font"); push(keys, "size"); push(keys, "fg"); push(keys, "align")
|
||||
var k = 0
|
||||
|
|
@ -34,11 +34,11 @@ function ui_props_with_inherited(i: int) -> []Node {
|
|||
var a = uiw_parent[i]
|
||||
while a >= 0 {
|
||||
let v = ui_prop(uiw[a], keys[k])
|
||||
if (v != null) { let fi = node(E_FINIT); fi.s = keys[k]; fi.a = v; push(out, fi); a = 0 - 1 }
|
||||
if (v != null) { let fi = node(E_FINIT); fi.s = keys[k]; fi.a = v; push(out, fi); a = -1 }
|
||||
else { a = uiw_parent[a] }
|
||||
}
|
||||
}
|
||||
k = k + 1
|
||||
k += 1
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
|
@ -46,19 +46,19 @@ function ui_flatten(w: Node, parent: int) -> void {
|
|||
let idx = len(uiw)
|
||||
push(uiw, w); push(uiw_parent, parent)
|
||||
var i = 0
|
||||
while i < len(w.kids) { ui_flatten(w.kids[i], idx); i = i + 1 }
|
||||
while i < len(w.kids) { ui_flatten(w.kids[i], idx); i += 1 }
|
||||
}
|
||||
function ui_flatten_all() -> void {
|
||||
uiw = new []Node; uiw_parent = new []int; ui_roots = new []int
|
||||
var i = 0
|
||||
while i < len(prog) {
|
||||
if prog[i].kind == N_UI and prog[i].ival == 1 { push(ui_roots, len(uiw)); ui_flatten(prog[i].a, 0 - 1) }
|
||||
i = i + 1
|
||||
if prog[i].kind == N_UI and prog[i].ival == 1 { push(ui_roots, len(uiw)); ui_flatten(prog[i].a, -1) }
|
||||
i += 1
|
||||
}
|
||||
}
|
||||
function has_ui() -> bool {
|
||||
var i = 0
|
||||
while i < len(prog) { if prog[i].kind == N_UI and prog[i].ival == 1 { return true }; i = i + 1 }
|
||||
while i < len(prog) { if prog[i].kind == N_UI and prog[i].ival == 1 { return true }; i += 1 }
|
||||
return false
|
||||
}
|
||||
|
||||
|
|
@ -69,19 +69,19 @@ function ui_index_of(nm: pointer) -> int {
|
|||
let u = 0; var bi = 0
|
||||
var i = 0
|
||||
while i < len(prog) {
|
||||
if prog[i].kind == N_UI and prog[i].ival == 1 { if (prog[i].s == s) { return ui_roots[bi] }; bi = bi + 1 }
|
||||
i = i + 1
|
||||
if prog[i].kind == N_UI and prog[i].ival == 1 { if (prog[i].s == s) { return ui_roots[bi] }; bi += 1 }
|
||||
i += 1
|
||||
}
|
||||
i = 0
|
||||
while i < len(uiw) {
|
||||
let idp = ui_prop(uiw[i], "id")
|
||||
if (idp != null) { if idp.kind == E_ID and (idp.s == s) { return i } }
|
||||
i = i + 1
|
||||
i += 1
|
||||
}
|
||||
return 0
|
||||
}
|
||||
function is_ui_ident(nm: pointer) -> bool {
|
||||
return len(nm) > 3 and nm[0] == 85 and nm[1] == 73 and nm[2] == 95 # "UI_"
|
||||
return len(nm) > 3 and nm[0] == 'U' and nm[1] == 'I' and nm[2] == '_' # "UI_"
|
||||
}
|
||||
|
||||
function ll_ui_set(idx: int, key: int, val: pointer) -> void {
|
||||
|
|
@ -92,7 +92,7 @@ function ui_prop_key(k: pointer) -> int {
|
|||
if (k == "pad") { return 7 }; if (k == "gap") { return 8 }; if (k == "bg") { return 9 }; if (k == "fg") { return 10 }
|
||||
if (k == "border") { return 11 }; if (k == "grow") { return 13 }; if (k == "font") { return 14 }; if (k == "size") { return 15 }
|
||||
if (k == "inset") { return 16 }; if (k == "focus") { return 17 }
|
||||
return 0 - 1
|
||||
return -1
|
||||
}
|
||||
|
||||
function emit_ui_build() -> void {
|
||||
|
|
@ -116,7 +116,7 @@ function emit_ui_build() -> void {
|
|||
let pr = props[p]
|
||||
let k = pr.s
|
||||
let v = pr.a
|
||||
if (k == "id") or (k == "goto") { p = p + 1; continue }
|
||||
if (k == "id") or (k == "goto") { p += 1; continue }
|
||||
if (k == "text") {
|
||||
let sv = emit_expr(v)
|
||||
emit(" call void @fn_rt_ui_static_text(i32 "); emit(itoa(i)); emit(", ptr "); emit(sv.code); emit(")\n")
|
||||
|
|
@ -138,9 +138,9 @@ function emit_ui_build() -> void {
|
|||
if key == 4 or key == 5 { ll_ui_set(i, 6, "1") }
|
||||
}
|
||||
} } }
|
||||
p = p + 1
|
||||
p += 1
|
||||
}
|
||||
i = i + 1
|
||||
i += 1
|
||||
}
|
||||
code = saved
|
||||
emit("define void @ui_build() {\nentry:\n")
|
||||
|
|
|
|||
|
|
@ -23,7 +23,7 @@ function emit_world_table() -> void {
|
|||
# and prop_id fall through to this table for a prop id >= NC.
|
||||
var ncomp = 0
|
||||
var ci0 = 0
|
||||
while ci0 < len(prog) { if prog[ci0].kind == N_COMP { ncomp = ncomp + 1 }; ci0 = ci0 + 1 }
|
||||
while ci0 < len(prog) { if prog[ci0].kind == N_COMP { ncomp += 1 }; ci0 += 1 }
|
||||
let NC = itoa(ncomp)
|
||||
emith("@dyn_count = global i32 0\n")
|
||||
emith("@dynS = global [32 x ptr] zeroinitializer\n") # storage base per dyn component
|
||||
|
|
@ -43,9 +43,9 @@ function emit_world_table() -> void {
|
|||
emit(" br i1 %e"); emit(sk); emit(", label %h"); emit(sk); emit(", label %n"); emit(sk); emit("\n")
|
||||
emit("h"); emit(sk); emit(":\n ret i32 "); emit(sk); emit("\n")
|
||||
emit("n"); emit(sk); emit(":\n")
|
||||
k = k + 1
|
||||
k += 1
|
||||
}
|
||||
i = i + 1
|
||||
i += 1
|
||||
}
|
||||
# EV7: not a compile-time component — search the dynamic (mod-registered) names
|
||||
emit(" %dpi = alloca i32\n store i32 0, ptr %dpi\n br label %dpl\n")
|
||||
|
|
@ -72,13 +72,13 @@ function emit_world_table() -> void {
|
|||
emit(" br i1 %fe"); emit(fk); emit(", label %fh"); emit(fk); emit(", label %fn"); emit(fk); emit("\n")
|
||||
emit("fh"); emit(fk); emit(":\n ret i32 "); emit(itoa(f)); emit("\n")
|
||||
emit("fn"); emit(fk); emit(":\n")
|
||||
f = f + 1
|
||||
f += 1
|
||||
}
|
||||
emit(" ret i32 -1\n")
|
||||
emit("pn"); emit(sk); emit(":\n")
|
||||
k = k + 1
|
||||
k += 1
|
||||
}
|
||||
i = i + 1
|
||||
i += 1
|
||||
}
|
||||
emit(" ret i32 -1\n}\n\n")
|
||||
|
||||
|
|
@ -115,13 +115,13 @@ function emit_world_table() -> void {
|
|||
emit(" %gr"); emit(fk); emit(" = sext i32 %gl"); emit(fk); emit(" to i64\n ret i64 %gr"); emit(fk); emit("\n")
|
||||
} }
|
||||
emit("gk"); emit(fk); emit(":\n")
|
||||
fj = fj + 1
|
||||
fj += 1
|
||||
}
|
||||
emit(" ret i64 0\n")
|
||||
emit("gn"); emit(sk); emit(":\n")
|
||||
k = k + 1
|
||||
k += 1
|
||||
}
|
||||
i = i + 1
|
||||
i += 1
|
||||
}
|
||||
# EV7: prop id >= NC -> a mod-registered component; index its flat storage
|
||||
emit(" %gdyn = sub i32 %p, "); emit(NC); emit("\n")
|
||||
|
|
@ -158,13 +158,13 @@ function emit_world_table() -> void {
|
|||
emit(" store i32 %sw"); emit(fk); emit(", ptr %sa"); emit(fk); emit("\n ret void\n")
|
||||
} }
|
||||
emit("sk"); emit(fk); emit(":\n")
|
||||
fj = fj + 1
|
||||
fj += 1
|
||||
}
|
||||
emit(" ret void\n")
|
||||
emit("gn"); emit(sk); emit(":\n")
|
||||
k = k + 1
|
||||
k += 1
|
||||
}
|
||||
i = i + 1
|
||||
i += 1
|
||||
}
|
||||
# EV7: prop id >= NC -> a mod-registered component
|
||||
emit(" %sdyn = sub i32 %p, "); emit(NC); emit("\n")
|
||||
|
|
@ -186,9 +186,9 @@ function emit_world_table() -> void {
|
|||
emit(" %hv"); emit(sk); emit(" = load i8, ptr %hp"); emit(sk); emit("\n")
|
||||
emit(" %hr"); emit(sk); emit(" = zext i8 %hv"); emit(sk); emit(" to i32\n ret i32 %hr"); emit(sk); emit("\n")
|
||||
emit("gn"); emit(sk); emit(":\n")
|
||||
k = k + 1
|
||||
k += 1
|
||||
}
|
||||
i = i + 1
|
||||
i += 1
|
||||
}
|
||||
# EV7: prop id >= NC -> a mod-registered component's has-flag array
|
||||
emit(" %hdyn = sub i32 %p, "); emit(NC); emit("\n")
|
||||
|
|
@ -234,9 +234,9 @@ function emit_world_table() -> void {
|
|||
emit(" br i1 %mde"); emit(sk); emit(", label %mdh"); emit(sk); emit(", label %mdn"); emit(sk); emit("\n")
|
||||
emit("mdh"); emit(sk); emit(":\n ret i32 "); emit(itoa(find_arch_id(prog[i].s))); emit("\n")
|
||||
emit("mdn"); emit(sk); emit(":\n")
|
||||
k = k + 1
|
||||
k += 1
|
||||
}
|
||||
i = i + 1
|
||||
i += 1
|
||||
}
|
||||
emit(" ret i32 -1\n}\n\n")
|
||||
|
||||
|
|
@ -263,7 +263,7 @@ function emit_world_table() -> void {
|
|||
emit(buf_str(fbody))
|
||||
emit("}\n\n")
|
||||
}
|
||||
i = i + 1
|
||||
i += 1
|
||||
}
|
||||
emit("define i32 @ludic_spawn(i32 %m) {\nentry:\n")
|
||||
k = 0; i = 0
|
||||
|
|
@ -274,9 +274,9 @@ function emit_world_table() -> void {
|
|||
emit(" br i1 %sm"); emit(sk); emit(", label %sh"); emit(sk); emit(", label %sn"); emit(sk); emit("\n")
|
||||
emit("sh"); emit(sk); emit(":\n %sr"); emit(sk); emit(" = call i32 @ludic_spawn_"); emit(m); emit("()\n ret i32 %sr"); emit(sk); emit("\n")
|
||||
emit("sn"); emit(sk); emit(":\n")
|
||||
k = k + 1
|
||||
k += 1
|
||||
}
|
||||
i = i + 1
|
||||
i += 1
|
||||
}
|
||||
emit(" ret i32 -1\n}\n\n")
|
||||
|
||||
|
|
@ -309,7 +309,7 @@ function emit_world_reflect_enum() -> void {
|
|||
# count the compile-time components (== the first dynamic prop id)
|
||||
var ncomp = 0
|
||||
var i = 0
|
||||
while i < len(prog) { if prog[i].kind == N_COMP { ncomp = ncomp + 1 }; i = i + 1 }
|
||||
while i < len(prog) { if prog[i].kind == N_COMP { ncomp += 1 }; i += 1 }
|
||||
let NC = itoa(ncomp)
|
||||
|
||||
# ludic_prop_count() -> total property count (compile-time + mod-registered)
|
||||
|
|
@ -326,9 +326,9 @@ function emit_world_reflect_enum() -> void {
|
|||
emit(" br i1 %pe"); emit(sk); emit(", label %ph"); emit(sk); emit(", label %pn"); emit(sk); emit("\n")
|
||||
emit("ph"); emit(sk); emit(":\n ret ptr "); emit(sc); emit("\n")
|
||||
emit("pn"); emit(sk); emit(":\n")
|
||||
k = k + 1
|
||||
k += 1
|
||||
}
|
||||
i = i + 1
|
||||
i += 1
|
||||
}
|
||||
emit(" %dyn = sub i32 %i, "); emit(NC); emit("\n %dc = load i32, ptr @dyn_count\n")
|
||||
emit(" %ib = icmp uge i32 %dyn, %dc\n br i1 %ib, label %pbad, label %pdyn\n")
|
||||
|
|
@ -345,9 +345,9 @@ function emit_world_reflect_enum() -> void {
|
|||
emit(" br i1 %fce"); emit(sk); emit(", label %fch"); emit(sk); emit(", label %fcn"); emit(sk); emit("\n")
|
||||
emit("fch"); emit(sk); emit(":\n ret i32 "); emit(itoa(len(c.kids))); emit("\n")
|
||||
emit("fcn"); emit(sk); emit(":\n")
|
||||
k = k + 1
|
||||
k += 1
|
||||
}
|
||||
i = i + 1
|
||||
i += 1
|
||||
}
|
||||
emit(" %dyn = sub i32 %p, "); emit(NC); emit("\n %dc = load i32, ptr @dyn_count\n")
|
||||
emit(" %ib = icmp uge i32 %dyn, %dc\n br i1 %ib, label %fcbad, label %fcdyn\n")
|
||||
|
|
@ -370,13 +370,13 @@ function emit_world_reflect_enum() -> void {
|
|||
emit(" br i1 %fnfe"); emit(fk); emit(", label %fnfh"); emit(fk); emit(", label %fnfn"); emit(fk); emit("\n")
|
||||
emit("fnfh"); emit(fk); emit(":\n ret ptr "); emit(fc); emit("\n")
|
||||
emit("fnfn"); emit(fk); emit(":\n")
|
||||
f = f + 1
|
||||
f += 1
|
||||
}
|
||||
emit(" ret ptr "); emit(empty); emit("\n")
|
||||
emit("fnn"); emit(sk); emit(":\n")
|
||||
k = k + 1
|
||||
k += 1
|
||||
}
|
||||
i = i + 1
|
||||
i += 1
|
||||
}
|
||||
emit(" ret ptr "); emit(empty); emit("\n}\n\n")
|
||||
|
||||
|
|
@ -396,13 +396,13 @@ function emit_world_reflect_enum() -> void {
|
|||
emit(" br i1 %ftfe"); emit(fk); emit(", label %ftfh"); emit(fk); emit(", label %ftfn"); emit(fk); emit("\n")
|
||||
emit("ftfh"); emit(fk); emit(":\n ret ptr "); emit(tc); emit("\n")
|
||||
emit("ftfn"); emit(fk); emit(":\n")
|
||||
f = f + 1
|
||||
f += 1
|
||||
}
|
||||
emit(" ret ptr "); emit(tint); emit("\n")
|
||||
emit("ftn"); emit(sk); emit(":\n")
|
||||
k = k + 1
|
||||
k += 1
|
||||
}
|
||||
i = i + 1
|
||||
i += 1
|
||||
}
|
||||
emit(" ret ptr "); emit(tint); emit("\n}\n\n")
|
||||
}
|
||||
|
|
@ -431,7 +431,7 @@ function emit_tick_helpers() -> void {
|
|||
function emit_game_defs() -> void {
|
||||
emit_system_registry() # #64: @ludic_register_system + the registry globals
|
||||
var i = 0
|
||||
while i < len(prog) { if prog[i].kind == N_SYS { emit_system_fn(prog[i]) }; i = i + 1 }
|
||||
while i < len(prog) { if prog[i].kind == N_SYS { emit_system_fn(prog[i]) }; i += 1 }
|
||||
emit_despawn_hooks()
|
||||
emit_scene_hooks()
|
||||
if has_countdowns() { emit_countdown_system() } # `countdown` fields (see emit_game.ludic)
|
||||
|
|
@ -454,7 +454,7 @@ function emit_game_main() -> void {
|
|||
var si = 0
|
||||
while si < len(g_scenes) {
|
||||
if (g_scenes[si].ival == g_start_scene) { emit(" call void @scene_enter_"); emit(g_scenes[si].s); emit("()\n") }
|
||||
si = si + 1
|
||||
si += 1
|
||||
}
|
||||
}
|
||||
if (find_event("program_start") != null) { emit(" call void @ev_program_start()\n") } # EV1: @Public @OnStart
|
||||
|
|
@ -502,7 +502,8 @@ function emit_game_main() -> void {
|
|||
# with no @ClearColor is byte-identical (it clears/shows itself, or the light
|
||||
# system owns the present).
|
||||
if g_has_clear_color and (find_fn("rt_clear") != null) {
|
||||
emit(" call void @fn_rt_clear(i32 "); emit(itoa(g_clear_color)); emit(")\n")
|
||||
let colour = emit_expr(g_clear_color) # a literal, a const, or a Color.Name
|
||||
emit(" call void @fn_rt_clear(i32 "); emit(colour.code); emit(")\n")
|
||||
}
|
||||
emit_calls_for_phase("Render")
|
||||
# Overlay: HUD / menus drawn after every engine Render system (sprites, lights), so
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue