code wiki / _hdl_build / nx_wat_compiler.nx
`nx_wat_compiler.nx` source

↩ module page · 695 lines · 35361 B
1// nx_wat_compiler.nx -- G-WASM-001 milestone 3: the SOVEREIGN WAT-text -> WASM-binary pipeline
2// end to end (lexer + parser + binary emit), reusing leb128.nx.  Reads a .wat file (the dialect
3// nxc2 --target wat emits) and writes a .wasm.  NO node/python/WABT in this organ; verified
4// byte-exact vs WABT used ONCE as an alignment oracle, then dropped.
5// Subset this milestone handles (the f.wat function): (module (memory (export "memory") N)
6//   (func (export "name") (param i64)* (result i64)? (local i64)*  <body of: local.get/local.set/
7//   i64.const/i64.add> )).  Remaining opcodes (control flow/call/load/store/etc) = next iterations.
8// usage: nx_wat_compiler <in.wat> <out.wasm>
9// STATUS: byte-exact vs WABT on REAL nxc2 output (g.wat: import + 2 funcs + call + br_table +
10//   block/loop/br + mixed i32/i64 locals + arith). Handles: type-dedup, import section, multi-
11//   function (function/code N entries), func symbol table + call, top-level & inline exports,
12//   memory, named/numeric locals, 20+ opcodes, control flow + label depth, br_table.
13//   GAMES: COMPLETE -- compiles nx_dungeon_alpha_wasm (a real game) byte-identical to WABT (9176B),
14//   output instantiates + runs (GAME-LOGIC-OK). Handles flat if/else/end + i64.load/store/load8_u/store8.
15//   GOTCHA fixed: i64.load8_u = 0x31 (0x30 is load8_s); buffers sized in BYTES not entries (overflow=corruption).
16//   The full nx->wat->wasm path is sovereign; WABT/node only ever one-time align/verify oracles.
17// F618 wasm-SIMD FLIP (2026-07-21): + v128.load/store, i8x16.sub_sat_u, v128.or, extadd-pairwise
18// u8->u16->u32 (_u and the _s mutation twin), i32x4.extract_lane <lane>, and `(local $x v128)`
19// (valtype 0x7B). All 0xFD-prefixed, sub-opcodes spec-verified. Unknown mnemonics still REFUSE.
20// license_tier: ORIGINAL
21import "leb128.nx"
22import "nx_syscalls.nx"
23const K_MAGIC_65536: i64 = 65536
24const K_MAGIC_4194304: i64 = 4194304
25const K_MAGIC_2097152: i64 = 2097152
26const K_MAGIC_524288: i64 = 524288
27const K_MAGIC_8388608: i64 = 8388608
28
29func w8(b: *u8, p: i64, v: i64) -> i64 { b[p] = v as u8; return p + 1 }
30func wcopy(dst: *u8, dp: i64, src: *u8, n: i64) -> i64 {
  var i: i64 = 0
  while i < n { dst[dp + i] = src[i]; i = i + 1 }
  return dp + n
34}
35func emit_section(out: *u8, p: i64, id: i64, sc: *u8, sclen: i64) -> i64 {
  var q: i64 = w8(out, p, id)
  q = q + uleb128_encode(sclen, out, q)
  q = wcopy(out, q, sc, sclen)
  return q
40}
41func is_ws(c: i64) -> i64 {
  if c == 32 { return 1 }
  if c == 9 { return 1 }
  if c == 10 { return 1 }
  if c == 13 { return 1 }
  return 0
47}
48func is_delim(c: i64) -> i64 {
  if is_ws(c) == 1 { return 1 }
  if c == 40 { return 1 }
  if c == 41 { return 1 }
  return 0
53}
54// lexer state ls[]: 0=pos 1=kind(0 eof,1 '(',2 ')',3 atom,4 string) 2=tok_start 3=tok_len
55func lex_next(buf: *u8, n: i64, ls: *i64) -> i64 {
  var pos: i64 = ls[0]
  var skip: i64 = 1
  while skip == 1 {
      skip = 0
      var ws_go: i64 = 1
      while ws_go == 1 {
          if pos >= n { ws_go = 0 } else {
              if is_ws(buf[pos] as i64) == 1 { pos = pos + 1 } else { ws_go = 0 }
          }
      }
      if pos < n {
          if buf[pos] == (59 as u8) {
              if pos + 1 < n {
                  if buf[pos + 1] == (59 as u8) {
                      var cm: i64 = 1
                      while cm == 1 {
                          if pos >= n { cm = 0 } else {
                              if buf[pos] == (10 as u8) { cm = 0 } else { pos = pos + 1 }
                          }
                      }
                      skip = 1
                  }
              }
          }
      }
  }
  if pos >= n { ls[1] = 0; ls[0] = pos; return 0 }
  let c: i64 = buf[pos] as i64
  if c == 40 { ls[1] = 1; ls[2] = pos; ls[3] = 1; ls[0] = pos + 1; return 0 }
  if c == 41 { ls[1] = 2; ls[2] = pos; ls[3] = 1; ls[0] = pos + 1; return 0 }
  if c == 34 {
      let st: i64 = pos + 1
      var q: i64 = st
      while buf[q] != (34 as u8) { q = q + 1 }
      ls[1] = 4; ls[2] = st; ls[3] = q - st; ls[0] = q + 1; return 0
  }
  let st2: i64 = pos
  var e: i64 = pos
  var done: i64 = 0
  while done == 0 {
      if e >= n { done = 1 } else {
          if is_delim(buf[e] as i64) == 1 { done = 1 } else { e = e + 1 }
      }
  }
  ls[1] = 3; ls[2] = st2; ls[3] = e - st2; ls[0] = e
  return 0
102}
103func atom_eq(buf: *u8, s: i64, l: i64, kw: *u8) -> i64 {
  var i: i64 = 0
  while i < l { if buf[s + i] != kw[i] { return 0 } i = i + 1 }
  if kw[l] != (0 as u8) { return 0 }
  return 1
108}
109func atom_int(buf: *u8, s: i64, l: i64) -> i64 {
  var i: i64 = 0
  var neg: i64 = 0
  if l > 0 { if buf[s] == (45 as u8) { neg = 1; i = 1 } }
  var v: i64 = 0
  while i < l { v = v * 10 + ((buf[s + i] as i64) - 48); i = i + 1 }
  if neg == 1 { return 0 - v }
  return v
117}
118// classify a body mnemonic -> op code, or -1 unknown.  Operand ops: 0/1=local.get/set
119// (uleb local idx), 2=i64.const / 16=i32.const (sleb).  Rest are single-byte.
120func instr_op(buf: *u8, s: i64, l: i64) -> i64 {
  if atom_eq(buf, s, l, "local.get" as *u8) == 1 { return 0 }
  if atom_eq(buf, s, l, "local.set" as *u8) == 1 { return 1 }
  if atom_eq(buf, s, l, "i64.const" as *u8) == 1 { return 2 }
  if atom_eq(buf, s, l, "i64.add" as *u8) == 1 { return 3 }
  if atom_eq(buf, s, l, "i64.sub" as *u8) == 1 { return 4 }
  if atom_eq(buf, s, l, "i64.mul" as *u8) == 1 { return 5 }
  if atom_eq(buf, s, l, "i64.and" as *u8) == 1 { return 6 }
  if atom_eq(buf, s, l, "i64.shr_s" as *u8) == 1 { return 7 }
  if atom_eq(buf, s, l, "i64.div_s" as *u8) == 1 { return 8 }
  if atom_eq(buf, s, l, "i64.rem_s" as *u8) == 1 { return 9 }
  if atom_eq(buf, s, l, "i64.eq" as *u8) == 1 { return 10 }
  if atom_eq(buf, s, l, "i64.ne" as *u8) == 1 { return 11 }
  if atom_eq(buf, s, l, "i64.lt_s" as *u8) == 1 { return 12 }
  if atom_eq(buf, s, l, "i64.gt_s" as *u8) == 1 { return 13 }
  if atom_eq(buf, s, l, "i64.le_s" as *u8) == 1 { return 14 }
  if atom_eq(buf, s, l, "i64.ge_s" as *u8) == 1 { return 15 }
  if atom_eq(buf, s, l, "i32.const" as *u8) == 1 { return 16 }
  if atom_eq(buf, s, l, "i32.wrap_i64" as *u8) == 1 { return 17 }
  if atom_eq(buf, s, l, "i64.extend_i32_u" as *u8) == 1 { return 18 }
  if atom_eq(buf, s, l, "unreachable" as *u8) == 1 { return 19 }
  if atom_eq(buf, s, l, "i64.or" as *u8) == 1 { return 20 }
  if atom_eq(buf, s, l, "i64.shl" as *u8) == 1 { return 21 }
  if atom_eq(buf, s, l, "i64.xor" as *u8) == 1 { return 22 }
  if atom_eq(buf, s, l, "br" as *u8) == 1 { return 28 }
  if atom_eq(buf, s, l, "br_table" as *u8) == 1 { return 29 }
  if atom_eq(buf, s, l, "call" as *u8) == 1 { return 30 }
  if atom_eq(buf, s, l, "if" as *u8) == 1 { return 25 }
  if atom_eq(buf, s, l, "else" as *u8) == 1 { return 26 }
  if atom_eq(buf, s, l, "end" as *u8) == 1 { return 27 }
  if atom_eq(buf, s, l, "i64.load" as *u8) == 1 { return 31 }
  if atom_eq(buf, s, l, "i64.store" as *u8) == 1 { return 32 }
  if atom_eq(buf, s, l, "i64.load8_u" as *u8) == 1 { return 33 }
  if atom_eq(buf, s, l, "i64.store8" as *u8) == 1 { return 34 }
  // full subword-memory family (2026-07-10 sext debt fix): the emitter now picks _s/_u per the sext
  // bit, and 16/32-bit widths were previously UNASSEMBLABLE here (emitter could emit them -> WATC
  // REFUSED). Opcodes: load8_s=0x30 load16_s/u=0x32/0x33 load32_s/u=0x34/0x35 store16=0x3D store32=0x3E.
  if atom_eq(buf, s, l, "i64.load8_s" as *u8) == 1 { return 35 }
  if atom_eq(buf, s, l, "i64.load16_s" as *u8) == 1 { return 36 }
  if atom_eq(buf, s, l, "i64.load16_u" as *u8) == 1 { return 37 }
  if atom_eq(buf, s, l, "i64.load32_s" as *u8) == 1 { return 38 }
  if atom_eq(buf, s, l, "i64.load32_u" as *u8) == 1 { return 39 }
  if atom_eq(buf, s, l, "i64.store16" as *u8) == 1 { return 48 }
  if atom_eq(buf, s, l, "i64.store32" as *u8) == 1 { return 49 }
  if atom_eq(buf, s, l, "f32.add" as *u8) == 1 { return 40 }
  if atom_eq(buf, s, l, "f32.sub" as *u8) == 1 { return 41 }
  if atom_eq(buf, s, l, "f32.mul" as *u8) == 1 { return 42 }
  if atom_eq(buf, s, l, "f32.div" as *u8) == 1 { return 43 }
  if atom_eq(buf, s, l, "f32.convert_i64_s" as *u8) == 1 { return 44 }
  if atom_eq(buf, s, l, "i64.trunc_f32_s" as *u8) == 1 { return 45 }
  if atom_eq(buf, s, l, "i32.reinterpret_f32" as *u8) == 1 { return 46 }
  if atom_eq(buf, s, l, "f32.reinterpret_i32" as *u8) == 1 { return 47 }
  // F618 wasm-SIMD subset (0xFD prefix; sub-opcodes spec-verified)
  if atom_eq(buf, s, l, "v128.load" as *u8) == 1 { return 50 }
  if atom_eq(buf, s, l, "i8x16.sub_sat_u" as *u8) == 1 { return 51 }
  if atom_eq(buf, s, l, "v128.or" as *u8) == 1 { return 52 }
  if atom_eq(buf, s, l, "i16x8.extadd_pairwise_i8x16_u" as *u8) == 1 { return 53 }
  if atom_eq(buf, s, l, "i32x4.extadd_pairwise_i16x8_u" as *u8) == 1 { return 54 }
  if atom_eq(buf, s, l, "i32x4.extract_lane" as *u8) == 1 { return 55 }
  if atom_eq(buf, s, l, "i16x8.extadd_pairwise_i8x16_s" as *u8) == 1 { return 56 }
  if atom_eq(buf, s, l, "v128.store" as *u8) == 1 { return 57 }
  // memory.grow (2026-07-29, the sys_mmap 0-stub root fix): the emitter's $nx_wasm_mmap helper is
  // stateless grow-per-allocation, so the ONLY new opcode the language needed was grow itself.
  if atom_eq(buf, s, l, "memory.grow" as *u8) == 1 { return 58 }
  return 0 - 1
185}
186func emit_instr(body: *u8, bp: i64, op: i64, arg: i64) -> i64 {
  var q: i64 = bp
  if op == 0 { q = w8(body, q, 0x20); q = q + uleb128_encode(arg, body, q) }
  if op == 1 { q = w8(body, q, 0x21); q = q + uleb128_encode(arg, body, q) }
  if op == 2 { q = w8(body, q, 0x42); q = q + sleb128_encode(arg, body, q) }
  if op == 3 { q = w8(body, q, 0x7C) }
  if op == 4 { q = w8(body, q, 0x7D) }
  if op == 5 { q = w8(body, q, 0x7E) }
  if op == 6 { q = w8(body, q, 0x83) }
  if op == 7 { q = w8(body, q, 0x87) }
  if op == 8 { q = w8(body, q, 0x7F) }
  if op == 9 { q = w8(body, q, 0x81) }
  if op == 10 { q = w8(body, q, 0x51) }
  if op == 11 { q = w8(body, q, 0x52) }
  if op == 12 { q = w8(body, q, 0x53) }
  if op == 13 { q = w8(body, q, 0x55) }
  if op == 14 { q = w8(body, q, 0x57) }
  if op == 15 { q = w8(body, q, 0x59) }
  if op == 16 { q = w8(body, q, 0x41); q = q + sleb128_encode(arg, body, q) }
  if op == 17 { q = w8(body, q, 0xA7) }
  if op == 18 { q = w8(body, q, 0xAD) }
  if op == 19 { q = w8(body, q, 0x00) }
  if op == 20 { q = w8(body, q, 0x84) }
  if op == 21 { q = w8(body, q, 0x86) }
  if op == 22 { q = w8(body, q, 0x85) }
  if op == 23 { q = w8(body, q, 0x02); q = w8(body, q, 0x40) }
  if op == 24 { q = w8(body, q, 0x03); q = w8(body, q, 0x40) }
  if op == 25 { q = w8(body, q, 0x04); q = w8(body, q, 0x40) }
  if op == 26 { q = w8(body, q, 0x05) }
  if op == 27 { q = w8(body, q, 0x0B) }
  if op == 28 { q = w8(body, q, 0x0C); q = q + uleb128_encode(arg, body, q) }
  if op == 30 { q = w8(body, q, 0x10); q = q + uleb128_encode(arg, body, q) }
  if op == 31 { q = w8(body, q, 0x29); q = w8(body, q, 3); q = w8(body, q, 0) }
  if op == 32 { q = w8(body, q, 0x37); q = w8(body, q, 3); q = w8(body, q, 0) }
  if op == 33 { q = w8(body, q, 0x31); q = w8(body, q, 0); q = w8(body, q, 0) }
  if op == 34 { q = w8(body, q, 0x3C); q = w8(body, q, 0); q = w8(body, q, 0) }
  // subword-memory family (sext fix): align exponent = natural (0 for 8-bit, 1 for 16, 2 for 32)
  if op == 35 { q = w8(body, q, 0x30); q = w8(body, q, 0); q = w8(body, q, 0) }   // i64.load8_s
  if op == 36 { q = w8(body, q, 0x32); q = w8(body, q, 1); q = w8(body, q, 0) }   // i64.load16_s
  if op == 37 { q = w8(body, q, 0x33); q = w8(body, q, 1); q = w8(body, q, 0) }   // i64.load16_u
  if op == 38 { q = w8(body, q, 0x34); q = w8(body, q, 2); q = w8(body, q, 0) }   // i64.load32_s
  if op == 39 { q = w8(body, q, 0x35); q = w8(body, q, 2); q = w8(body, q, 0) }   // i64.load32_u
  if op == 48 { q = w8(body, q, 0x3D); q = w8(body, q, 1); q = w8(body, q, 0) }   // i64.store16
  if op == 49 { q = w8(body, q, 0x3E); q = w8(body, q, 2); q = w8(body, q, 0) }   // i64.store32
  if op == 40 { q = w8(body, q, 0x92) }     // f32.add
  if op == 41 { q = w8(body, q, 0x93) }     // f32.sub
  if op == 42 { q = w8(body, q, 0x94) }     // f32.mul
  if op == 43 { q = w8(body, q, 0x95) }     // f32.div
  if op == 44 { q = w8(body, q, 0xB4) }     // f32.convert_i64_s
  if op == 45 { q = w8(body, q, 0xAE) }     // i64.trunc_f32_s
  if op == 46 { q = w8(body, q, 0xBC) }     // i32.reinterpret_f32
  if op == 47 { q = w8(body, q, 0xBE) }     // f32.reinterpret_i32
  // F618 wasm-SIMD subset: 0xFD prefix + LEB128 sub-opcode (all subs here < 0x80 = single byte).
  // memarg for v128.load/store: align exponent 0 (byte-aligned hint -- SAD reads ARE unaligned at
  // arbitrary motion offsets; unaligned v128 access is architecturally legal in wasm), offset 0.
  if op == 50 { q = w8(body, q, 0xFD); q = w8(body, q, 0x00); q = w8(body, q, 0); q = w8(body, q, 0) }   // v128.load
  if op == 51 { q = w8(body, q, 0xFD); q = w8(body, q, 0x73) }                                          // i8x16.sub_sat_u
  if op == 52 { q = w8(body, q, 0xFD); q = w8(body, q, 0x50) }                                          // v128.or
  if op == 53 { q = w8(body, q, 0xFD); q = w8(body, q, 0x7D) }                                          // i16x8.extadd_pairwise_i8x16_u
  if op == 54 { q = w8(body, q, 0xFD); q = w8(body, q, 0x7F) }                                          // i32x4.extadd_pairwise_i16x8_u
  if op == 55 { q = w8(body, q, 0xFD); q = w8(body, q, 0x1B); q = w8(body, q, arg) }                    // i32x4.extract_lane <lane>
  if op == 56 { q = w8(body, q, 0xFD); q = w8(body, q, 0x7C) }                                          // i16x8.extadd_pairwise_i8x16_s (mutation-gate twin)
  if op == 57 { q = w8(body, q, 0xFD); q = w8(body, q, 0x0B); q = w8(body, q, 0); q = w8(body, q, 0) }  // v128.store
  if op == 58 { q = w8(body, q, 0x40); q = w8(body, q, 0x00) }                                          // memory.grow (memidx 0)
  return q
251}
252// op takes an operand we read from the next atom?  0/1=local idx, 2/16=const.
253func op_has_operand(op: i64) -> i64 {
  if op == 0 { return 1 }
  if op == 1 { return 1 }
  if op == 2 { return 1 }
  if op == 16 { return 1 }
  if op == 55 { return 1 }   // i32x4.extract_lane <laneidx> (plain int atom, emitted as one raw byte)
  return 0
260}
261func op_is_local(op: i64) -> i64 {
  if op == 0 { return 1 }
  if op == 1 { return 1 }
  return 0
265}
266// resolve a local operand atom: "$name" -> index via the name table, else parse int
267func resolve_local(buf: *u8, s: i64, l: i64, lns: *i64, lnl: *i64, cnt: i64) -> i64 {
  if buf[s] != (36 as u8) { return atom_int(buf, s, l) }
  var i: i64 = 0
  while i < cnt {
      if lns[i] >= 0 { if lnl[i] == l {
          var j: i64 = 0
          var same: i64 = 1
          while j < l { if buf[lns[i] + j] != buf[s + j] { same = 0 } j = j + 1 }
          if same == 1 { return i }
      } }
      i = i + 1
  }
  return 0
280}
281func emit_name(sc: *u8, s: i64, buf: *u8, ns: i64, nl: i64) -> i64 {
  var q: i64 = s + uleb128_encode(nl, sc, s)
  q = wcopy(sc, q, ((buf as i64) + ns) as *u8, nl)
  return q
285}
286
287// emit the code-body locals vec from ltype[np..ntot-1] as run-length groups by type
288func emit_locals(body: *u8, bp: i64, ltype: *i64, np: i64, ntot: i64) -> i64 {
  var groups: i64 = 0
  var gi: i64 = np
  while gi < ntot {
      let t: i64 = ltype[gi]
      var go: i64 = 1
      while go == 1 { if gi >= ntot { go = 0 } else { if ltype[gi] == t { gi = gi + 1 } else { go = 0 } } }
      groups = groups + 1
  }
  var q: i64 = bp + uleb128_encode(groups, body, bp)
  gi = np
  while gi < ntot {
      let t: i64 = ltype[gi]
      var run: i64 = 0
      var go2: i64 = 1
      while go2 == 1 { if gi >= ntot { go2 = 0 } else { if ltype[gi] == t { run = run + 1; gi = gi + 1 } else { go2 = 0 } } }
      q = q + uleb128_encode(run, body, q)
      q = w8(body, q, t)
  }
  return q
308}
309// emit one functype (all-i64 params/results, matching nxc2 signatures) into sc at s
310func emit_functype(sc: *u8, s: i64, np: i64, nr: i64) -> i64 {
  var q: i64 = w8(sc, s, 0x60)
  q = q + uleb128_encode(np, sc, q)
  var i: i64 = 0
  while i < np { q = w8(sc, q, 0x7E); i = i + 1 }
  q = q + uleb128_encode(nr, sc, q)
  i = 0
  while i < nr { q = w8(sc, q, 0x7E); i = i + 1 }
  return q
319}
320// dedup a (nparams,nresults) signature into the type table; return its typeidx
321func sig_find_or_add(tnp: *i64, tnr: *i64, ntp: *i64, np: i64, nr: i64) -> i64 {
  var i: i64 = 0
  let nt: i64 = ntp[0]
  while i < nt { if tnp[i] == np { if tnr[i] == nr { return i } } i = i + 1 }
  tnp[nt] = np; tnr[nt] = nr; ntp[0] = nt + 1
  return nt
327}
328func substr_eq(buf: *u8, a: i64, b: i64, l: i64) -> i64 {
  var j: i64 = 0
  while j < l { if buf[a + j] != buf[b + j] { return 0 } j = j + 1 }
  return 1
332}
333// resolve a br target label name -> relative depth (innermost open block = 0)
334func resolve_label(buf: *u8, s: i64, l: i64, lks: *i64, lkl: *i64, lsp: i64) -> i64 {
  var i: i64 = lsp - 1
  while i >= 0 {
      if lkl[i] == l { if substr_eq(buf, s, lks[i], l) == 1 { return (lsp - 1) - i } }
      i = i - 1
  }
  return 0
341}
342
343// resolve a call target $name -> funcidx (ftab = imports first, then defined funcs, in order)
344func resolve_func(buf: *u8, s: i64, l: i64, fts: *i64, ftl: *i64, nf: i64) -> i64 {
  var i: i64 = 0
  while i < nf { if ftl[i] == l { if substr_eq(buf, s, fts[i], l) == 1 { return i } } i = i + 1 }
  return 0
348}
349// pass 0: build the func symbol table by scanning every (func $name (incl import funcs, which
350// appear first in nxc2 output) so calls (even forward) resolve to a funcidx.  nimp[0]=#imports.
351func prescan_ftab(buf: *u8, n: i64, fts: *i64, ftl: *i64, nimp: *i64) -> i64 {
  let ls2: *i64 = sys_mmap(64) as *i64
  ls2[0] = 0
  var nf: i64 = 0
  var ni: i64 = 0
  var depth: i64 = 0
  var in_export: i64 = 0
  var exp_depth: i64 = 0
  var go: i64 = 1
  while go == 1 {
      lex_next(buf, n, ls2)
      if ls2[1] == 0 { go = 0 }
      if ls2[1] == 1 { depth = depth + 1 }
      if ls2[1] == 2 { depth = depth - 1; if in_export == 1 { if depth < exp_depth { in_export = 0 } } }
      if ls2[1] == 3 {
          if atom_eq(buf, ls2[2], ls2[3], "export" as *u8) == 1 { in_export = 1; exp_depth = depth }
          if atom_eq(buf, ls2[2], ls2[3], "import" as *u8) == 1 { ni = ni + 1 }
          if atom_eq(buf, ls2[2], ls2[3], "func" as *u8) == 1 {
              if in_export == 0 {
                  lex_next(buf, n, ls2)
                  if ls2[1] == 3 { fts[nf] = ls2[2]; ftl[nf] = ls2[3]; nf = nf + 1 }
              }
          }
      }
  }
  nimp[0] = ni
  return nf
378}
379
380func wc_compile_file(inp: *u8, outp: *u8) -> i64 {
  let lenp: *i64 = sys_mmap(16) as *i64
  let buf: *u8 = sys_read_file(inp, lenp)
  if buf == (0 as i64) as *u8 { sys_write(1, "WATC REFUSED: cannot read input\n" as *u8, 32); sys_exit(1); return 1 }
  let n: i64 = lenp[0]
  let ls: *i64 = sys_mmap(64) as *i64
  ls[0] = 0
  // pass 0: func symbol table (imports first, then defined funcs, by $name)
  // CAPACITY HARDENING 2026-07-05: the video-client module with the sovereign codec = 382 funcs /
  // 46K lines / 192 exports -- the old caps (256 funcs, 64 per-func slots, 32K instrs) silently
  // OVERFLOWED and the wraparound surfaced as "unknown mnemonic" at line 1. All pools sized 16-64x
  // with the biggest real module in mind; a dev-tool's mmap is free.
  let fts: *i64 = sys_mmap(K_MAGIC_65536) as *i64
  let ftl: *i64 = sys_mmap(K_MAGIC_65536) as *i64
  let nimp: *i64 = sys_mmap(16) as *i64
  let nftot: i64 = prescan_ftab(buf, n, fts, ftl, nimp)
  let num_imports: i64 = nimp[0]
  // module-level state
  var has_import: i64 = 0
  var imp_mod_s: i64 = 0
  var imp_mod_l: i64 = 0
  var imp_fld_s: i64 = 0
  var imp_fld_l: i64 = 0
  var imp_np: i64 = 0
  var imp_nr: i64 = 0
  var has_mem: i64 = 0
  var mem_min: i64 = 1
  var mem_ns: i64 = 0
  var mem_nl: i64 = 0
  // shared pools across all functions
  let in_op: *i64 = sys_mmap(K_MAGIC_4194304) as *i64
  let in_arg: *i64 = sys_mmap(K_MAGIC_4194304) as *i64
  var ninstr: i64 = 0
  let lns: *i64 = sys_mmap(K_MAGIC_2097152) as *i64
  let lnl: *i64 = sys_mmap(K_MAGIC_2097152) as *i64
  let ltype: *i64 = sys_mmap(K_MAGIC_2097152) as *i64
  var ntot: i64 = 0
  var pend_s: i64 = 0 - 1
  var pend_l: i64 = 0
  let lks: *i64 = sys_mmap(K_MAGIC_524288) as *i64
  let lkl: *i64 = sys_mmap(K_MAGIC_524288) as *i64
  var lsp: i64 = 0
  let bt_pool: *i64 = sys_mmap(K_MAGIC_2097152) as *i64
  var btp: i64 = 0
  // per-defined-function arrays (sig, export, local pool range, instr range)
  let fexp_s: *i64 = sys_mmap(K_MAGIC_65536) as *i64
  let fexp_l: *i64 = sys_mmap(K_MAGIC_65536) as *i64
  let fnp: *i64 = sys_mmap(K_MAGIC_65536) as *i64
  let fnr: *i64 = sys_mmap(K_MAGIC_65536) as *i64
  let fnl: *i64 = sys_mmap(K_MAGIC_65536) as *i64
  let flbase: *i64 = sys_mmap(K_MAGIC_65536) as *i64
  let fist: *i64 = sys_mmap(K_MAGIC_65536) as *i64
  let fic: *i64 = sys_mmap(K_MAGIC_65536) as *i64
  var NF: i64 = 0
  // ( module ...   NOTE: a `handled` flag stops a consumed inner group's ')' from
  // prematurely closing the parent loop (NishiLang has no break / else-if).
  lex_next(buf, n, ls)   // (
  lex_next(buf, n, ls)   // module
  var top: i64 = 1
  while top == 1 {
      lex_next(buf, n, ls)
      var h1: i64 = 0
      if ls[1] == 1 {
          h1 = 1
          lex_next(buf, n, ls)        // section keyword atom
          if atom_eq(buf, ls[2], ls[3], "import" as *u8) == 1 {
              has_import = 1
              lex_next(buf, n, ls); imp_mod_s = ls[2]; imp_mod_l = ls[3]   // "env"
              lex_next(buf, n, ls); imp_fld_s = ls[2]; imp_fld_l = ls[3]   // "nx_syscall"
              lex_next(buf, n, ls)   // ( of (func ...)
              lex_next(buf, n, ls)   // func
              lex_next(buf, n, ls)   // $name (import func name)
              var fg: i64 = 1
              while fg > 0 {
                  lex_next(buf, n, ls)
                  var hi: i64 = 0
                  if ls[1] == 1 {
                      hi = 1
                      lex_next(buf, n, ls)   // param|result
                      if atom_eq(buf, ls[2], ls[3], "param" as *u8) == 1 {
                          var pi: i64 = 1
                          while pi > 0 { lex_next(buf, n, ls); if ls[1] == 2 { pi = 0 } if ls[1] == 3 { imp_np = imp_np + 1 } if ls[1] == 0 { pi = 0 } }
                      }
                      if atom_eq(buf, ls[2], ls[3], "result" as *u8) == 1 {
                          var ri: i64 = 1
                          while ri > 0 { lex_next(buf, n, ls); if ls[1] == 2 { ri = 0 } if ls[1] == 3 { imp_nr = imp_nr + 1 } if ls[1] == 0 { ri = 0 } }
                      }
                  }
                  if hi == 0 { if ls[1] == 2 { fg = 0 } }   // func's )
                  if ls[1] == 0 { fg = 0 }
              }
              lex_next(buf, n, ls)   // ) closing (import ...)
          }
          if atom_eq(buf, ls[2], ls[3], "memory" as *u8) == 1 {
              has_mem = 1
              var md: i64 = 1
              while md > 0 {
                  lex_next(buf, n, ls)
                  var h2: i64 = 0
                  if ls[1] == 1 {
                      h2 = 1
                      lex_next(buf, n, ls)   // export
                      lex_next(buf, n, ls)   // "memory" string
                      mem_ns = ls[2]; mem_nl = ls[3]
                      lex_next(buf, n, ls)   // )
                  }
                  if h2 == 0 { if ls[1] == 3 { mem_min = atom_int(buf, ls[2], ls[3]) } }
                  if h2 == 0 { if ls[1] == 2 { md = 0 } }
                  if ls[1] == 0 { md = 0 }
              }
          }
          if atom_eq(buf, ls[2], ls[3], "func" as *u8) == 1 {
              let F: i64 = NF
              let fbase: i64 = ntot
              let fist0: i64 = ninstr
              lsp = 0
              fexp_s[F] = 0; fexp_l[F] = 0; fnp[F] = 0; fnr[F] = 0; fnl[F] = 0
              lex_next(buf, n, ls)   // optional $name or first group/atom
              var have_tok: i64 = 1
              if ls[1] == 3 { have_tok = 0 }
              var fd: i64 = 1
              while fd > 0 {
                  if have_tok == 0 { lex_next(buf, n, ls) }
                  have_tok = 0
                  var h3: i64 = 0
                  if ls[1] == 1 {
                      h3 = 1
                      lex_next(buf, n, ls)   // export|param|result|local
                      if atom_eq(buf, ls[2], ls[3], "export" as *u8) == 1 {
                          lex_next(buf, n, ls); fexp_s[F] = ls[2]; fexp_l[F] = ls[3]
                          lex_next(buf, n, ls)   // )
                      }
                      if atom_eq(buf, ls[2], ls[3], "param" as *u8) == 1 {
                          pend_s = 0 - 1
                          var pp: i64 = 1
                          while pp > 0 { lex_next(buf, n, ls); if ls[1] == 2 { pp = 0 }
                              if ls[1] == 3 {
                                  if buf[ls[2]] == (36 as u8) { pend_s = ls[2]; pend_l = ls[3] } else { lns[ntot] = pend_s; lnl[ntot] = pend_l; ltype[ntot] = 126; if atom_eq(buf, ls[2], ls[3], "i32" as *u8) == 1 { ltype[ntot] = 127 } ntot = ntot + 1; fnp[F] = fnp[F] + 1; pend_s = 0 - 1 }
                              }
                              if ls[1] == 0 { pp = 0 } }
                      }
                      if atom_eq(buf, ls[2], ls[3], "result" as *u8) == 1 {
                          var rr: i64 = 1
                          while rr > 0 { lex_next(buf, n, ls); if ls[1] == 2 { rr = 0 } if ls[1] == 3 { fnr[F] = fnr[F] + 1 } if ls[1] == 0 { rr = 0 } }
                      }
                      if atom_eq(buf, ls[2], ls[3], "local" as *u8) == 1 {
                          pend_s = 0 - 1
                          var lc: i64 = 1
                          while lc > 0 { lex_next(buf, n, ls); if ls[1] == 2 { lc = 0 }
                              if ls[1] == 3 {
                                  if buf[ls[2]] == (36 as u8) { pend_s = ls[2]; pend_l = ls[3] } else { lns[ntot] = pend_s; lnl[ntot] = pend_l; ltype[ntot] = 126; if atom_eq(buf, ls[2], ls[3], "i32" as *u8) == 1 { ltype[ntot] = 127 } if atom_eq(buf, ls[2], ls[3], "v128" as *u8) == 1 { ltype[ntot] = 123 } ntot = ntot + 1; fnl[F] = fnl[F] + 1; pend_s = 0 - 1 }
                              }
                              if ls[1] == 0 { lc = 0 } }
                      }
                      if atom_eq(buf, ls[2], ls[3], "block" as *u8) == 1 {
                          in_op[ninstr] = 23; in_arg[ninstr] = 0; ninstr = ninstr + 1
                          lex_next(buf, n, ls); lks[lsp] = ls[2]; lkl[lsp] = ls[3]; lsp = lsp + 1
                      }
                      if atom_eq(buf, ls[2], ls[3], "loop" as *u8) == 1 {
                          in_op[ninstr] = 24; in_arg[ninstr] = 0; ninstr = ninstr + 1
                          lex_next(buf, n, ls); lks[lsp] = ls[2]; lkl[lsp] = ls[3]; lsp = lsp + 1
                      }
                  }
                  if h3 == 0 { if ls[1] == 3 {
                      let op: i64 = instr_op(buf, ls[2], ls[3])
                      if op < 0 { sys_write(1, "WATC REFUSED: unknown mnemonic: " as *u8, 31); sys_write(1, ((buf as i64) + ls[2]) as *u8, ls[3]); sys_write(1, "\n" as *u8, 1); sys_exit(1); return 1 }
                      if op == 29 {
                          let btoff: i64 = btp
                          var nlab: i64 = 0
                          var btgo: i64 = 1
                          while btgo == 1 {
                              lex_next(buf, n, ls)
                              if ls[1] == 3 { bt_pool[btoff + 1 + nlab] = resolve_label(buf, ls[2], ls[3], lks, lkl, lsp); nlab = nlab + 1 }
                              if ls[1] == 2 { btgo = 0 }
                              if ls[1] == 0 { btgo = 0 }
                          }
                          bt_pool[btoff] = nlab - 1
                          btp = btoff + 1 + nlab
                          in_op[ninstr] = 29; in_arg[ninstr] = btoff; ninstr = ninstr + 1
                      }
                      if op == 25 { in_op[ninstr] = 25; in_arg[ninstr] = 0; ninstr = ninstr + 1; lks[lsp] = 0; lkl[lsp] = 0; lsp = lsp + 1 }
                      if op == 27 { if lsp > 0 { lsp = lsp - 1 } in_op[ninstr] = 27; in_arg[ninstr] = 0; ninstr = ninstr + 1 }
                      if op != 29 { if op != 25 { if op != 27 {
                          var arg: i64 = 0
                          if op == 28 { lex_next(buf, n, ls); arg = resolve_label(buf, ls[2], ls[3], lks, lkl, lsp) }
                          if op == 30 { lex_next(buf, n, ls); arg = resolve_func(buf, ls[2], ls[3], fts, ftl, nftot) }
                          if op_has_operand(op) == 1 {
                              lex_next(buf, n, ls)
                              if op_is_local(op) == 1 { arg = resolve_local(buf, ls[2], ls[3], ((lns as i64) + fbase * 8) as *i64, ((lnl as i64) + fbase * 8) as *i64, ntot - fbase) } else { arg = atom_int(buf, ls[2], ls[3]) }
                          }
                          in_op[ninstr] = op; in_arg[ninstr] = arg; ninstr = ninstr + 1
                      } } }
                  } }
                  if h3 == 0 { if ls[1] == 2 {
                      if lsp > 0 { lsp = lsp - 1; in_op[ninstr] = 27; in_arg[ninstr] = 0; ninstr = ninstr + 1 } else { fd = 0 }
                  } }
                  if ls[1] == 0 { fd = 0 }
              }
              flbase[F] = fbase; fist[F] = fist0; fic[F] = ninstr - fist0
              NF = NF + 1
          }
          if atom_eq(buf, ls[2], ls[3], "export" as *u8) == 1 {
              lex_next(buf, n, ls)   // "name"
              let ename_s: i64 = ls[2]
              let ename_l: i64 = ls[3]
              lex_next(buf, n, ls)   // (
              lex_next(buf, n, ls)   // func|memory|...
              var is_func: i64 = 0
              if atom_eq(buf, ls[2], ls[3], "func" as *u8) == 1 { is_func = 1 }
              lex_next(buf, n, ls)   // $name or index
              if is_func == 1 {
                  let fidx: i64 = resolve_func(buf, ls[2], ls[3], fts, ftl, nftot)
                  let defidx: i64 = fidx - num_imports
                  if defidx >= 0 { fexp_s[defidx] = ename_s; fexp_l[defidx] = ename_l }
              }
              lex_next(buf, n, ls)   // ) of (func ...)
              lex_next(buf, n, ls)   // ) of (export ...)
          }
      }
      if h1 == 0 { if ls[1] == 2 { top = 0 } }
      if ls[1] == 0 { top = 0 }
  }
  // ---- emit ----
  let out: *u8 = sys_mmap(K_MAGIC_8388608)
  let sc: *u8 = sys_mmap(K_MAGIC_8388608)
  let body: *u8 = sys_mmap(K_MAGIC_2097152)
  var p: i64 = 0
  p = w8(out, p, 0); p = w8(out, p, 0x61); p = w8(out, p, 0x73); p = w8(out, p, 0x6D)
  p = w8(out, p, 1); p = w8(out, p, 0); p = w8(out, p, 0); p = w8(out, p, 0)
  // type table dedup (import + every func sig; nxc2 sigs all-i64)
  let tnp: *i64 = sys_mmap(K_MAGIC_65536) as *i64
  let tnr: *i64 = sys_mmap(K_MAGIC_65536) as *i64
  let ntp: *i64 = sys_mmap(16) as *i64
  ntp[0] = 0
  let ftypeidx: *i64 = sys_mmap(K_MAGIC_65536) as *i64
  var imp_tidx: i64 = 0
  if has_import == 1 { imp_tidx = sig_find_or_add(tnp, tnr, ntp, imp_np, imp_nr) }
  var fj: i64 = 0
  while fj < NF { ftypeidx[fj] = sig_find_or_add(tnp, tnr, ntp, fnp[fj], fnr[fj]); fj = fj + 1 }
  // type section
  var s: i64 = 0
  s = s + uleb128_encode(ntp[0], sc, s)
  var ti: i64 = 0
  while ti < ntp[0] { s = emit_functype(sc, s, tnp[ti], tnr[ti]); ti = ti + 1 }
  p = emit_section(out, p, 1, sc, s)
  // import section
  if has_import == 1 {
      s = 0
      s = s + uleb128_encode(1, sc, s)
      s = emit_name(sc, s, buf, imp_mod_s, imp_mod_l)
      s = emit_name(sc, s, buf, imp_fld_s, imp_fld_l)
      s = w8(sc, s, 0)
      s = s + uleb128_encode(imp_tidx, sc, s)
      p = emit_section(out, p, 2, sc, s)
  }
  // function section: NF entries
  s = 0
  s = s + uleb128_encode(NF, sc, s)
  fj = 0
  while fj < NF { s = s + uleb128_encode(ftypeidx[fj], sc, s); fj = fj + 1 }
  p = emit_section(out, p, 3, sc, s)
  // memory section
  if has_mem == 1 {
      s = 0; s = w8(sc, s, 1); s = w8(sc, s, 0); s = s + uleb128_encode(mem_min, sc, s); p = emit_section(out, p, 5, sc, s)
  }
  // export section: memory (if any) + every func that has an export name
  s = 0
  var nexp: i64 = 0
  if has_mem == 1 { nexp = nexp + 1 }
  fj = 0
  while fj < NF { if fexp_l[fj] > 0 { nexp = nexp + 1 } fj = fj + 1 }
  s = s + uleb128_encode(nexp, sc, s)
  if has_mem == 1 { s = emit_name(sc, s, buf, mem_ns, mem_nl); s = w8(sc, s, 2); s = w8(sc, s, 0) }
  fj = 0
  while fj < NF { if fexp_l[fj] > 0 { s = emit_name(sc, s, buf, fexp_s[fj], fexp_l[fj]); s = w8(sc, s, 0); s = s + uleb128_encode(num_imports + fj, sc, s) } fj = fj + 1 }
  p = emit_section(out, p, 7, sc, s)
  // code section: NF entries (each func's locals vec + body + end)
  s = 0
  s = s + uleb128_encode(NF, sc, s)
  fj = 0
  while fj < NF {
      var bp: i64 = 0
      bp = emit_locals(body, bp, ltype, flbase[fj] + fnp[fj], flbase[fj] + fnp[fj] + fnl[fj])
      var ii: i64 = fist[fj]
      let iend: i64 = fist[fj] + fic[fj]
      while ii < iend {
          if in_op[ii] == 29 {
              let off2: i64 = in_arg[ii]
              let cnt2: i64 = bt_pool[off2]
              bp = w8(body, bp, 0x0E)
              bp = bp + uleb128_encode(cnt2, body, bp)
              var k2: i64 = 0
              while k2 < cnt2 { bp = bp + uleb128_encode(bt_pool[off2 + 1 + k2], body, bp); k2 = k2 + 1 }
              bp = bp + uleb128_encode(bt_pool[off2 + 1 + cnt2], body, bp)
          } else { bp = emit_instr(body, bp, in_op[ii], in_arg[ii]) }
          ii = ii + 1
      }
      bp = w8(body, bp, 0x0B)
      s = s + uleb128_encode(bp, sc, s)
      s = wcopy(sc, s, body, bp)
      fj = fj + 1
  }
  p = emit_section(out, p, 10, sc, s)
  // write
  let fd: i64 = sys_openat_wr(outp, 0x1a4)
  if fd < 0 { sys_write(1, "WATC REFUSED: cannot write output\n" as *u8, 34); sys_exit(1); return 1 }
  sys_write(fd, out, p); sys_close(fd)
  sys_write(1, "WATC GREEN: wat->wasm\n" as *u8, 22)
  sys_exit(0)
  return 0
690}
691
692func main(argc: i64, argv: *i64) -> i64 {
  if argc < 3 { sys_write(1, "usage: nx_wat_compiler <in.wat> <out.wasm>\n" as *u8, 43); sys_exit(2); return 2 }
  return wc_compile_file(argv[1] as *u8, argv[2] as *u8)
695}
nx_wat_compiler.nx source

`nx_wat_compiler.nx` source
