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

↩ module page · 944 lines · 49877 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}
41// LN33: refuse by name with the length DERIVED from the literal (a hand-counted length beside a string is a
42// second copy of its shape and the two drift).
43func wc_refuse(msg: *u8) -> i64 {
  var n: i64 = 0
  while msg[n] != (0 as u8) { n = n + 1 }
  sys_write(1, msg, n)
  sys_exit(1)
  return 1
49}
50// LN33: the memtype limits flags byte -- 0 min only, 1 min+max, 3 shared (which the threads proposal
51// only allows together with a maximum; the callers refuse the shared-without-max case before asking).
52func wc_mem_flags(has_max: i64, shared: i64) -> i64 {
  if shared == 1 { return 3 }
  if has_max == 1 { return 1 }
  return 0
56}
57func 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
63}
64func is_delim(c: i64) -> i64 {
  if is_ws(c) == 1 { return 1 }
  if c == 40 { return 1 }
  if c == 41 { return 1 }
  return 0
69}
70// lexer state ls[]: 0=pos 1=kind(0 eof,1 '(',2 ')',3 atom,4 string) 2=tok_start 3=tok_len
71func 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
      var closed: i64=0
      while q<n {
          if buf[q]==(34 as u8) { closed=1 }
          if closed==1 { ls[1]=4;ls[2]=st;ls[3]=q-st;ls[0]=q+1;return 0 }
          q=q+1
      }
      if closed==0 { return wc_refuse("WATC LEX: unterminated string at end of input\n" as *u8) }
      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
124}
125func 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
130}
131func 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
139}
140// classify a body mnemonic -> op code, or -1 unknown.  Operand ops: 0/1=local.get/set
141// (uleb local idx), 2=i64.const / 16=i32.const (sleb).  Rest are single-byte.
142// Native dialect opcode; binary encoding follows WebAssembly bulk-memory instructions.
143const WC_OP_MEMORY_INIT: i64 = 74
144const WC_BULK_PREFIX: i64 = 0xfc
145const WC_MEMORY_INIT: i64 = 8
146const WC_DATA_COUNT_SECTION: i64 = 12
147
148func instr_op(buf: *u8, s: i64, l: i64) -> i64 {
  if atom_eq(buf, s, l, "memory.init" as *u8) == 1 { return WC_OP_MEMORY_INIT }
  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 }
  // LN33 wasm threads (0xFE prefix, sub-opcodes per the threads proposal; memarg align = natural: 2 for the
  // 32-bit family, 3 for the 64-bit family, offset 0 -- the emitter never folds an offset in).
  if atom_eq(buf, s, l, "i32.atomic.load" as *u8) == 1 { return 59 }
  if atom_eq(buf, s, l, "i32.atomic.store" as *u8) == 1 { return 60 }
  if atom_eq(buf, s, l, "i32.atomic.rmw.add" as *u8) == 1 { return 61 }
  if atom_eq(buf, s, l, "i32.atomic.rmw.sub" as *u8) == 1 { return 62 }
  if atom_eq(buf, s, l, "i32.atomic.rmw.xchg" as *u8) == 1 { return 63 }
  if atom_eq(buf, s, l, "i32.atomic.rmw.cmpxchg" as *u8) == 1 { return 64 }
  if atom_eq(buf, s, l, "memory.atomic.wait32" as *u8) == 1 { return 65 }
  if atom_eq(buf, s, l, "memory.atomic.notify" as *u8) == 1 { return 66 }
  if atom_eq(buf, s, l, "i64.atomic.load" as *u8) == 1 { return 67 }
  if atom_eq(buf, s, l, "i64.atomic.store" as *u8) == 1 { return 68 }
  if atom_eq(buf, s, l, "i64.atomic.rmw.add" as *u8) == 1 { return 69 }
  if atom_eq(buf, s, l, "i64.atomic.rmw.sub" as *u8) == 1 { return 70 }
  if atom_eq(buf, s, l, "i64.atomic.rmw.xchg" as *u8) == 1 { return 71 }
  if atom_eq(buf, s, l, "i64.atomic.rmw.cmpxchg" as *u8) == 1 { return 72 }
  if atom_eq(buf, s, l, "atomic.fence" as *u8) == 1 { return 73 }
  return 0 - 1
231}
232func emit_instr(body: *u8, bp: i64, op: i64, arg: i64) -> i64 {
  var q: i64 = bp
  if op == WC_OP_MEMORY_INIT {
      q = w8(body,q,WC_BULK_PREFIX)
      q = q + uleb128_encode(WC_MEMORY_INIT,body,q)
      q = q + uleb128_encode(arg,body,q)
      q = w8(body,q,0)
  }
  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)
  // LN33 wasm threads: 0xFE prefix + sub-opcode + memarg(align, offset 0); atomic.fence carries one 0x00 flag byte
  if op == 59 { q = w8(body, q, 0xFE); q = w8(body, q, 0x10); q = w8(body, q, 2); q = w8(body, q, 0) }   // i32.atomic.load
  if op == 60 { q = w8(body, q, 0xFE); q = w8(body, q, 0x17); q = w8(body, q, 2); q = w8(body, q, 0) }   // i32.atomic.store
  if op == 61 { q = w8(body, q, 0xFE); q = w8(body, q, 0x1E); q = w8(body, q, 2); q = w8(body, q, 0) }   // i32.atomic.rmw.add
  if op == 62 { q = w8(body, q, 0xFE); q = w8(body, q, 0x25); q = w8(body, q, 2); q = w8(body, q, 0) }   // i32.atomic.rmw.sub
  if op == 63 { q = w8(body, q, 0xFE); q = w8(body, q, 0x41); q = w8(body, q, 2); q = w8(body, q, 0) }   // i32.atomic.rmw.xchg
  if op == 64 { q = w8(body, q, 0xFE); q = w8(body, q, 0x48); q = w8(body, q, 2); q = w8(body, q, 0) }   // i32.atomic.rmw.cmpxchg
  if op == 65 { q = w8(body, q, 0xFE); q = w8(body, q, 0x01); q = w8(body, q, 2); q = w8(body, q, 0) }   // memory.atomic.wait32
  if op == 66 { q = w8(body, q, 0xFE); q = w8(body, q, 0x00); q = w8(body, q, 2); q = w8(body, q, 0) }   // memory.atomic.notify
  if op == 67 { q = w8(body, q, 0xFE); q = w8(body, q, 0x11); q = w8(body, q, 3); q = w8(body, q, 0) }   // i64.atomic.load
  if op == 68 { q = w8(body, q, 0xFE); q = w8(body, q, 0x18); q = w8(body, q, 3); q = w8(body, q, 0) }   // i64.atomic.store
  if op == 69 { q = w8(body, q, 0xFE); q = w8(body, q, 0x1F); q = w8(body, q, 3); q = w8(body, q, 0) }   // i64.atomic.rmw.add
  if op == 70 { q = w8(body, q, 0xFE); q = w8(body, q, 0x26); q = w8(body, q, 3); q = w8(body, q, 0) }   // i64.atomic.rmw.sub
  if op == 71 { q = w8(body, q, 0xFE); q = w8(body, q, 0x42); q = w8(body, q, 3); q = w8(body, q, 0) }   // i64.atomic.rmw.xchg
  if op == 72 { q = w8(body, q, 0xFE); q = w8(body, q, 0x49); q = w8(body, q, 3); q = w8(body, q, 0) }   // i64.atomic.rmw.cmpxchg
  if op == 73 { q = w8(body, q, 0xFE); q = w8(body, q, 0x03); q = w8(body, q, 0x00) }                    // atomic.fence
  return q
319}
320// op takes an operand we read from the next atom?  0/1=local idx, 2/16=const.
321func op_has_operand(op: i64) -> i64 {
  if op == WC_OP_MEMORY_INIT { return 1 }
  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
329}
330func op_is_local(op: i64) -> i64 {
  if op == 0 { return 1 }
  if op == 1 { return 1 }
  return 0
334}
335// resolve a local operand atom: "$name" -> index via the name table, else parse int
336func 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
349}
350func 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
354}
355
356// emit the code-body locals vec from ltype[np..ntot-1] as run-length groups by type
357func 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
377}
378// emit one functype (all-i64 params/results, matching nxc2 signatures) into sc at s
379func 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
388}
389// dedup a (nparams,nresults) signature into the type table; return its typeidx
390func 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
396}
397func 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
401}
402// resolve a br target label name -> relative depth (innermost open block = 0)
403func 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
410}
411
412// resolve a call target $name -> funcidx (ftab = imports first, then defined funcs, in order)
413func 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
417}
418// pass 0: build the func symbol table by scanning every (func $name (incl import funcs, which
419// appear first in nxc2 output) so calls (even forward) resolve to a funcidx.  nimp[0]=#imports.
420func 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 pend_imp: 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 }
          // LN33: only a FUNC import occupies the function index space; a memory import (the shared-memory
          // door emits `(import "env" "memory" (memory MIN MAX shared))`) must not shift every defined
          // function's index by one, so an import counts only when its descriptor turns out to be a func.
          if atom_eq(buf, ls2[2], ls2[3], "import" as *u8) == 1 { pend_imp = 1 }
          if atom_eq(buf, ls2[2], ls2[3], "memory" as *u8) == 1 { pend_imp = 0 }
          if atom_eq(buf, ls2[2], ls2[3], "func" as *u8) == 1 {
              if pend_imp == 1 { ni = ni + 1; pend_imp = 0 }
              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
453}
454
455const WCD_ASCII_ZERO: i64 = 48
456const WCD_ASCII_NINE: i64 = 57
457const WCD_ASCII_A: i64 = 65
458const WCD_ASCII_F: i64 = 70
459const WCD_ASCII_a: i64 = 97
460const WCD_ASCII_f: i64 = 102
461const WCD_HEX_RADIX: i64 = 16
462const WCD_ESCAPE: i64 = 92
463const WCD_I32_MAX: i64 = 2147483647
464const WCD_U32_MAX: i64 = 4294967295
465const WCD_U32_MODULUS: i64 = 4294967296
466const WCD_SEGMENT_HEADER_MAX: i64 = 1+1+5+1+5 // flags, i32.const, sLEB32, end, uLEB32 length.
467const WCD_SECTION_HEADER_MAX: i64 = 1+5+5 // section ID, section length, segment count.
468const WCD_I32_CONST: i64 = 0x41
469const WCD_END: i64 = 0x0b
470
471func wc_hex(c: i64) -> i64 {
  if c>=WCD_ASCII_ZERO { if c<=WCD_ASCII_NINE { return c-WCD_ASCII_ZERO } }
  if c>=WCD_ASCII_a { if c<=WCD_ASCII_f { return c-WCD_ASCII_a+10 } }
  if c>=WCD_ASCII_A { if c<=WCD_ASCII_F { return c-WCD_ASCII_A+10 } }
  return 0-1
476}
477// The native emitter uses active memory-0 segments with fully hex-escaped bytes.
478func wc_data(buf: *u8,n: i64,ls: *i64,dst: *u8,at: i64,cap: i64) -> i64 {
  lex_next(buf,n,ls)
  var passive: i64=0
  var offset: i64=0
  if ls[1]==4 { passive=1 } else {
  if ls[1]!=1 { return wc_refuse("WATC DATA: expected offset expression or passive byte string\n" as *u8) }
  lex_next(buf,n,ls)
  if atom_eq(buf,ls[2],ls[3],"i32.const" as *u8)!=1 { return wc_refuse("WATC DATA: requires i32.const offset\n" as *u8) }
  lex_next(buf,n,ls)
  if ls[1]!=3 { return wc_refuse("WATC DATA: expected decimal offset\n" as *u8) }
  if ls[3]==0 { return wc_refuse("WATC DATA: empty offset\n" as *u8) }
  var digit: i64=0
  var checked_offset: i64=0
  while digit<ls[3] {
      let c: i64=buf[ls[2]+digit] as i64
      if c<WCD_ASCII_ZERO { return wc_refuse("WATC DATA: invalid decimal offset\n" as *u8) }
      if c>WCD_ASCII_NINE { return wc_refuse("WATC DATA: invalid decimal offset\n" as *u8) }
      let value: i64=c-WCD_ASCII_ZERO
      if checked_offset>(WCD_U32_MAX-value)/10 { return wc_refuse("WATC DATA: decimal offset exceeds wasm32\n" as *u8) }
      checked_offset=checked_offset*10+value
      digit=digit+1
  }
  offset=checked_offset
  if offset<0 { return wc_refuse("WATC DATA: negative offset\n" as *u8) }
  if offset>WCD_U32_MAX { return wc_refuse("WATC DATA: offset exceeds wasm32\n" as *u8) }
  lex_next(buf,n,ls)
  if ls[1]!=2 { return wc_refuse("WATC DATA: offset expression not closed\n" as *u8) }
  lex_next(buf,n,ls)
  }
  if ls[1]!=4 { return wc_refuse("WATC DATA: expected byte string\n" as *u8) }
  let start: i64=ls[2]
  let length: i64=ls[3]
  if length%3!=0 { return wc_refuse("WATC DATA: native byte string requires hex escapes\n" as *u8) }
  let count: i64=length/3
  // Flags + opcode + signed i32 LEB + end + u32 length LEB: at most WCD_SEGMENT_HEADER_MAX bytes.
  if cap-at<WCD_SEGMENT_HEADER_MAX { return wc_refuse("WATC DATA: metadata extent exceeds output\n" as *u8) }
  if count>cap-at-WCD_SEGMENT_HEADER_MAX { return wc_refuse("WATC DATA: payload extent exceeds output\n" as *u8) }
  var p: i64=at
  p=w8(dst,p,passive)
  if passive==0 {
  p=w8(dst,p,WCD_I32_CONST)
  var signed_offset: i64=offset
  if offset>WCD_I32_MAX { signed_offset=offset-WCD_U32_MODULUS }
  p=p+sleb128_encode(signed_offset,dst,p)
  p=w8(dst,p,WCD_END)
  }
  p=p+uleb128_encode(count,dst,p)
  var j: i64=0
  while j<length {
      if buf[start+j]!=(WCD_ESCAPE as u8) { return wc_refuse("WATC DATA: expected hex escape\n" as *u8) }
      let hi: i64=wc_hex(buf[start+j+1] as i64)
      let lo: i64=wc_hex(buf[start+j+2] as i64)
      if hi<0 { return wc_refuse("WATC DATA: invalid hex digit\n" as *u8) }
      if lo<0 { return wc_refuse("WATC DATA: invalid hex digit\n" as *u8) }
      p=w8(dst,p,hi*WCD_HEX_RADIX+lo)
      j=j+3
  }
  lex_next(buf,n,ls)
  if ls[1]!=2 { return wc_refuse("WATC DATA: segment not closed\n" as *u8) }
  return p
538}
539
540func 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]
  if n<0 { return wc_refuse("WATC DATA: negative input extent\n" as *u8) }
  if n>WCD_I32_MAX { return wc_refuse("WATC DATA: input exceeds wasm32 module extent\n" as *u8) }
  let data_cap: i64=n*2+WCD_SECTION_HEADER_MAX
  let data_bytes: *u8=sys_mmap(data_cap)
  if (data_bytes as i64)<=0 { return wc_refuse("WATC DATA: allocation failed\n" as *u8) }
  var data_len: i64=0
  var data_count: i64=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
  // LN33: memory limits (max, shared) and the imported-memory form -- flags byte 0 min-only, 1 min+max, 3 shared+max
  var mem_max: i64 = 0
  var mem_has_max: i64 = 0
  var mem_shared: i64 = 0
  var mem_imported: i64 = 0
  var imm_mod_s: i64 = 0
  var imm_mod_l: i64 = 0
  var imm_fld_s: i64 = 0
  var imm_fld_l: 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],"data" as *u8)==1 {
              data_len=wc_data(buf,n,ls,data_bytes,data_len,data_cap)
              data_count=data_count+1
          }
          if atom_eq(buf, ls[2], ls[3], "import" as *u8) == 1 {
              lex_next(buf, n, ls)   // "env"
              let im_s: i64 = ls[2]
              let im_l: i64 = ls[3]
              lex_next(buf, n, ls)   // "nx_syscall" | "memory"
              let if_s: i64 = ls[2]
              let if_l: i64 = ls[3]
              lex_next(buf, n, ls)   // ( of (func ...) | (memory ...)
              lex_next(buf, n, ls)   // func | memory
              var fg: i64 = 0
              if atom_eq(buf, ls[2], ls[3], "memory" as *u8) == 1 {
                  // LN33: (import "env" "memory" (memory MIN MAX shared)) -- the shared-memory door. The module
                  // imports the ONE memory every Worker instantiates against; it is not a function import.
                  mem_imported = 1; has_mem = 1
                  imm_mod_s = im_s; imm_mod_l = im_l; imm_fld_s = if_s; imm_fld_l = if_l
                  var mi_n: i64 = 0
                  var mdi: i64 = 1
                  while mdi > 0 {
                      lex_next(buf, n, ls)
                      if ls[1] == 3 {
                          if atom_eq(buf, ls[2], ls[3], "shared" as *u8) == 1 { mem_shared = 1 } else {
                              if mi_n == 0 { mem_min = atom_int(buf, ls[2], ls[3]) } else { mem_max = atom_int(buf, ls[2], ls[3]); mem_has_max = 1 }
                              mi_n = mi_n + 1
                          }
                      }
                      if ls[1] == 2 { mdi = 0 }
                      if ls[1] == 0 { mdi = 0 }
                  }
              } else {
                  has_import = 1
                  imp_mod_s = im_s; imp_mod_l = im_l; imp_fld_s = if_s; imp_fld_l = if_l
                  lex_next(buf, n, ls)   // $name (import func name)
                  fg = 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 mem_top_n: i64 = 0
              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)   // )
                  }
                  // LN33: (memory MIN) | (memory MIN MAX) | (memory MIN MAX shared) -- first int is the minimum,
                  // the second the maximum; the `shared` atom asks for limits flag 3 (which needs the maximum).
                  if h2 == 0 { if ls[1] == 3 {
                      if atom_eq(buf, ls[2], ls[3], "shared" as *u8) == 1 { mem_shared = 1 } else {
                          if mem_top_n == 0 { mem_min = atom_int(buf, ls[2], ls[3]) } else { mem_max = atom_int(buf, ls[2], ls[3]); mem_has_max = 1 }
                          mem_top_n = mem_top_n + 1
                      }
                  } }
                  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 }
              // LN33: `(export "memory" (memory 0))` is how an IMPORTED memory is exported; an inline
              // `(memory (export "memory") N)` already set the name and keeps it.
              if atom_eq(buf, ls[2], ls[3], "memory" as *u8) == 1 { if mem_nl == 0 { mem_ns = ename_s; mem_nl = ename_l } }
              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+data_len+WCD_SECTION_HEADER_MAX)
  let sc: *u8 = sys_mmap(K_MAGIC_8388608+data_len+WCD_SECTION_HEADER_MAX)
  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 (LN33: a memory import rides beside the optional func import; the func entry is emitted
  // first so the function index space is exactly what prescan_ftab counted)
  if has_import + mem_imported > 0 {
      s = 0
      s = s + uleb128_encode(has_import + mem_imported, sc, s)
      if has_import == 1 {
          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)
      }
      if mem_imported == 1 {
          if mem_shared == 1 { if mem_has_max == 0 { wc_refuse("WATC REFUSED: a shared memory needs a maximum -- (memory MIN MAX shared)\n" as *u8) } }
          s = emit_name(sc, s, buf, imm_mod_s, imm_mod_l)
          s = emit_name(sc, s, buf, imm_fld_s, imm_fld_l)
          s = w8(sc, s, 2)
          s = w8(sc, s, wc_mem_flags(mem_has_max, mem_shared))
          s = s + uleb128_encode(mem_min, sc, s)
          if mem_has_max == 1 { s = s + uleb128_encode(mem_max, 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 (LN33: an IMPORTED memory has no memory section of its own; a defined one carries its
  // limits flags -- 0 min only, 1 min+max, 3 shared+max -- and a shared memory without a maximum is refused)
  if has_mem == 1 { if mem_imported == 0 {
      if mem_shared == 1 { if mem_has_max == 0 { wc_refuse("WATC REFUSED: a shared memory needs a maximum -- (memory MIN MAX shared)\n" as *u8) } }
      s = 0; s = w8(sc, s, 1); s = w8(sc, s, wc_mem_flags(mem_has_max, mem_shared)); s = s + uleb128_encode(mem_min, sc, s)
      if mem_has_max == 1 { s = s + uleb128_encode(mem_max, 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)
  // Data count precedes code so memory.init indices can be validated during streaming compilation.
  if data_count>0 {
      s=uleb128_encode(data_count,sc,0)
      p=emit_section(out,p,WC_DATA_COUNT_SECTION,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 {
              if in_op[ii]==WC_OP_MEMORY_INIT {
                  if in_arg[ii]<0 { return wc_refuse("WATC memory.init: negative data index\n" as *u8) }
                  if in_arg[ii]>=data_count { return wc_refuse("WATC memory.init: data index outside declared segments\n" as *u8) }
              }
              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)
  if data_count>0 {
      s=uleb128_encode(data_count,sc,0)
      s=wcopy(sc,s,data_bytes,data_len)
      p=emit_section(out,p,11,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
939}
940
941func 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)
944}
nx_wat_compiler.nx source

`nx_wat_compiler.nx` source
