ludic/selfhost/parse_game.ludic

# parse_game.ludic — the ECS front-end: component and system declarations,
# `for (vars) in query [terms] where cond`, spawn and despawn. Mirrors the
# game-construct parsing in compiler/front/parse.c.

fn parse_component() -> Node {
  pi = pi + 1; let n = node(N_COMP); n.s = eat_id(); skipnl(); eat_op("{")
  while true { skipnl(); if is_op("}") { break }
    let f = node(N_FIELD); f.s = eat_id(); eat_op(":"); f.ty = ptype()
    if is_op("=") { pi = pi + 1; f.a = expr() }
    push(n.kids, f); if is_op(",") { pi = pi + 1 } }
  eat_op("}"); return n
}

# skip an @annotation or a reads/writes/query/... clause we don't model yet
fn skip_clause() -> void {
  if is_op("[") { let depth = 0
    while true { if is_op("[") { depth = depth + 1 };  if is_op("]") { depth = depth - 1 }
      pi = pi + 1;  if depth == 0 { break } }
  }
}

fn parse_system() -> Node {
  pi = pi + 1; let n = node(N_SYS); n.s = eat_id(); n.ty = "Update"
  # clauses: @anno, phase X, reads/writes/needs/uses [..], query (..) [..]
  # A `query (vars) [terms] where c` clause desugars to a body wrapped in one
  # `for (vars) in query [terms] where c { ... }` — the same S_QUERY node the
  # inline form builds, so `qdecl.ludic` and the inline form share a lowering.
  let has_q = false
  let qn = node(S_QUERY)
  while true {
    skipnl()                                   # clauses may span several lines
    if is_op("@") { pi = pi + 1; let a = eat_id();  if is_op("(") { let d = 0    # @anno, one per turn so a
        while true { if is_op("(") { d = d + 1 };  if is_op(")") { d = d - 1 };  pi = pi + 1;  if d == 0 { break } } }
      continue }                               # newline-separated @anno re-skips at the loop top
    if is_id("phase") { pi = pi + 1; n.ty = eat_id(); continue }
    if is_id("reads") or is_id("writes") { pi = pi + 1; skip_clause(); continue }   # `needs`/`uses` synonyms dropped (Rule A cleanup)
    if is_id("query") {
      pi = pi + 1; has_q = true
      if is_op("(") { eat_op("(")              # optional (vars); omitted when nothing binds
        while not is_op(")") { let v = node(E_ID); v.s = eat_id(); push(qn.kids, v); if is_op(",") { pi = pi + 1 } }
        eat_op(")") }
      qn.c = parse_query_tail()
      qn.b = qn.c.a                            # where-expr (or null)
      continue
    }
    break
  }
  skipnl()
  let body = block()
  if has_q {
    qn.a = body
    let wrap = node(N_BLOCK); push(wrap.kids, qn)
    n.a = wrap
  } else { n.a = body }
  return n
}

# `[Term, ...]` with optional `where <expr>`, returning a node whose kids are
# the terms (E_ID with ival=1 for {Tag} filters) and .a the where-expr or null.
fn parse_query_tail() -> Node {
  eat_op("[")
  let q = node(N_BLOCK)
  while not is_op("]") {
    if is_op("{") { pi = pi + 1; let t = node(E_ID); t.s = eat_id(); t.ival = 1; push(q.kids, t); eat_op("}") }
    else { let t = node(E_ID); t.s = eat_id(); t.ival = 0; push(q.kids, t) }
    if is_op(",") { pi = pi + 1 }
  }
  eat_op("]")
  if is_id("where") { pi = pi + 1; q.a = expr() }
  return q
}

# `for (a, b) in query [Pos, Vel] where ... { body }`
fn parse_query_for() -> Node {
  let n = node(S_QUERY)
  eat_op("(")
  while not is_op(")") { let v = node(E_ID); v.s = eat_id(); push(n.kids, v); if is_op(",") { pi = pi + 1 } }
  eat_op(")")
  let inkw = eat_id()                        # 'in'
  let qkw = eat_id()                         # 'query'
  n.c = parse_query_tail()
  n.b = n.c.a                                # where
  n.a = block()
  return n
}

# ---- @Queries annotation -----------------------------------------------------
# `@Queries(these: [Prop{constraint}, ...], on: Model)` on a handler is an
# annotation spelling of the `for (Prop, ...) in query [Prop, ..., {Model}]
# where <constraints> { body }` loop. It desugars to the same S_QUERY node, so
# the whole query backend (iteration, filters, binding, break/continue) is reused.

fn mk_and(a: Node, b: Node) -> Node {
  if ptr_is_null(a) { return b }
  let n = node(E_BIN); n.s = "and"; n.a = a; n.b = b; return n
}

# In `Prop{scale > 0}` the bare names are fields of Prop; qualify each to
# `Prop.field` (the binding var is the property name) for the desugared where.
fn qualify_fields(e: Node, prop: ptr) -> Node {
  if ptr_is_null(e) { return e }
  if e.kind == E_ID {
    let m = node(E_MEMBER); let base = node(E_ID); base.s = prop; m.a = base; m.s = e.s; return m
  }
  if e.kind == E_BIN { e.a = qualify_fields(e.a, prop); e.b = qualify_fields(e.b, prop); return e }
  if e.kind == E_UN  { e.a = qualify_fields(e.a, prop); return e }
  return e
}

# parse `(these: [...], on: Model)`, returning an S_QUERY with its vars/terms/where
# filled in (the body `.a` is attached by the caller once the handler is parsed).
fn parse_queries_anno() -> Node {
  eat_op("(")
  let qn = node(S_QUERY)
  let terms = node(N_BLOCK)
  let wh: Node = ptr_null()
  while not is_op(")") {
    skipnl()
    if is_op(")") { break }
    let key = eat_id(); eat_op(":")
    if streq(key, "these") {
      eat_op("["); skipnl()
      while not is_op("]") {
        let pname = eat_id()
        let v = node(E_ID); v.s = pname; push(qn.kids, v)              # binding var = property name
        let t = node(E_ID); t.s = pname; t.ival = 0; push(terms.kids, t)
        if is_op("{") { pi = pi + 1; let ce = expr(); eat_op("}"); wh = mk_and(wh, qualify_fields(ce, pname)) }
        if is_op(",") { pi = pi + 1 }
        skipnl()
      }
      eat_op("]")
    } else { if streq(key, "on") {
      let mname = eat_id(); let t = node(E_ID); t.s = mname; t.ival = 1; push(terms.kids, t)   # {Model} tag
    } else { expr() } }                                                # unknown key: skip its value
    if is_op(",") { pi = pi + 1 }
    skipnl()
  }
  eat_op(")")
  qn.c = terms; qn.b = wh
  return qn
}

fn parse_spawn() -> Node {
  pi = pi + 1; let n = node(S_SPAWN); n.s = eat_id(); skipnl(); eat_op("{")
  while true {
    skipnl(); if is_op("}") { break }
    let ci = node(E_FINIT); ci.s = eat_id()
    ci.a = record()                          # Comp { field: val, ... } — no `=` before the record
    push(n.kids, ci)
    if is_op(",") { pi = pi + 1 }
  }
  eat_op("}"); return n
}

# enum Name { A, B, C } — named int constants; a variant's value is its index.
# Accessed as `Name.A` (a compile-time int), so it names magic-int value spaces
# (state ids, menu selections, mode registers) without a runtime cost.
fn parse_enum() -> Node {
  pi = pi + 1; let n = node(N_ENUM); n.s = eat_id(); skipnl(); eat_op("{")
  while true { skipnl(); if is_op("}") { break }
    let v = node(E_ID); v.s = eat_id(); push(n.kids, v)
    if is_op(",") { pi = pi + 1 };  skipnl() }
  eat_op("}"); return n
}

# archetype Name { CompA, CompB } — a named entity kind (bundle of components)
fn parse_archetype() -> Node {
  pi = pi + 1; let n = node(N_ARCH); n.s = eat_id(); skipnl(); eat_op("{")
  while true { skipnl(); if is_op("}") { break }
    let c = node(E_ID); c.s = eat_id(); push(n.kids, c)
    if is_op(",") { pi = pi + 1 };  skipnl() }
  eat_op("}"); return n
}

# extern fn name(params) -> T = "symbol"
fn parse_extern() -> Node {
  pi = pi + 1                                # 'extern'
  let fnkw = eat_id()                        # 'fn'
  let n = node(N_EXTERN); n.s = eat_id(); eat_op("(")
  while not is_op(")") { let p = node(N_PARAM); p.s = eat_id(); eat_op(":"); p.ty = ptype(); push(n.kids, p)
    if is_op(",") { pi = pi + 1 } }
  eat_op(")")
  n.ty = "void"
  if is_op("->") { pi = pi + 1; n.ty = ptype() }
  eat_op("=")
  let t = toks[pi]                           # "symbol"
  n.a = node(E_STR); n.a.s = t.text;  pi = pi + 1
  return n
}

# ui Name { widget-tree } — parsed into a widget node tree (emitted later)
fn parse_widget() -> Node {
  let w = node(N_UI); w.s = eat_id()          # widget type name
  w.b = node(N_BLOCK)                        # b.kids = props (E_FINIT)
  while toks[pi].kind == TK_ID and toks[pi + 1].kind == TK_OP and streq(toks[pi + 1].text, ":") {
    let pr = node(E_FINIT); pr.s = eat_id(); eat_op(":"); pr.a = expr(); push(w.b.kids, pr)   # widget prop `key: value` (Rule A)
  }
  skipnl()
  if is_op("{") { pi = pi + 1
    while true { skipnl(); if is_op("}") { break }; push(w.kids, parse_widget()) }
    eat_op("}") }
  return w
}
fn parse_ui() -> Node {
  pi = pi + 1; let n = node(N_UI); n.s = eat_id(); n.ival = 1   # ival=1 marks the top ui block
  skipnl(); eat_op("{"); skipnl()
  n.a = parse_widget()
  skipnl(); eat_op("}")
  return n
}