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

↩ module page · 164 lines · 7990 B
1// nx_pattern_emit13.nx -- PATTERN EMITTER: STATE_MACHINE (shape 18 -- the first rung of the
2// ADVANCED-STACK ladders spec 2026-06-10: the shape DirectX-class pipeline validation, CUDA-class
3// queue lifecycles, Klipper-class G-code modal interpreters, and TLS/session handshakes are all
4// made of). The Builder authors a deterministic finite state machine from a TRANSITION TABLE:
5//   spec[0]=nstates  spec[1]=nevents  spec[2]=s0 (initial state)
6//   spec[3 + s*nevents + e] = next state, or -1 = UNDEFINED (refused, never silently absorbed)
7// Authored fns (transitions BAKED as straight-line ifs -- no runtime table interpreter, rule 22):
8//   <name>_step(s, e)        -> next state; -1 on out-of-range s/e or undefined transition
9//   <name>_run(ev, n, s0)    -> final state after folding ev[0..n); -1 the moment any step refuses
10// EMIT-TIME RAILS (the PID/PREDICTOR_CODER discipline): nstates/nevents outside 1..16, s0 out of
11// range, any table value outside -1..nstates-1 -> spec REFUSED, nothing written. Test KATs are
12// COMPUTED BY THE EMITTER from the same table: a greedy defined-transition walk from s0 with the
13// expected final state, an undefined-transition refusal (or out-of-range when the table is total),
14// an out-of-range-event refusal, and a determinism re-run. Extends the emit1-12 family.
15// LAWS: struct-free, integer-only, flat ifs, no &&/||, <=6 args per func. license_tier: ORIGINAL
16import "nx_syscalls.nx"
17
18func p13_w(fd: i64, s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(fd, s, n); return 0 }
19func p13_wn(fd: i64, v: i64) -> i64 { let bb: *u8=sys_mmap(28); var m: i64=v; if m<0{m=0-m; sys_write(fd,"-" as *u8,1)}; let t: *u8=sys_mmap(28); var k: i64=0; if m==0{t[0]=48;k=1}; while m>0{t[k]=(48+(m%10)) as u8;m=m/10;k=k+1}; var i: i64=0; while i<k{bb[i]=t[k-1-i];i=i+1}; sys_write(fd,bb,k); return 0 }
20
21// the refusal rail: a malformed table is REFUSED, never authored
22func p13_spec_ok(spec: *i64) -> i64 {
  let ns: i64 = spec[0]
  let ne: i64 = spec[1]
  if ns < 1 { return 0 }
  if ns > 16 { return 0 }
  if ne < 1 { return 0 }
  if ne > 16 { return 0 }
  if spec[2] < 0 { return 0 }
  if spec[2] >= ns { return 0 }
  var i: i64 = 0
  while i < ns * ne {
      let v: i64 = spec[3 + i]
      if v < 0 - 1 { return 0 }
      if v >= ns { return 0 }
      i = i + 1
  }
  return 1
39}
40
41// author the core: per-state/per-event transitions baked as flat ifs
42func pe13_emit_state_machine(fd: i64, name: *u8, spec: *i64) -> i64 {
  let ns: i64 = spec[0]
  let ne: i64 = spec[1]
  p13_w(fd, "// AUTHORED BY THE NISHI BUILDER (pattern: STATE_MACHINE) -- baked transition walk, no Claude logic\n" as *u8)
  p13_w(fd, "import \"nx_syscalls.nx\"\n" as *u8)
  p13_w(fd, "func " as *u8); p13_w(fd, name); p13_w(fd, "_step(s: i64, e: i64) -> i64 {\n" as *u8)
  p13_w(fd, "    if s < 0 { return 0 - 1 }\n" as *u8)
  p13_w(fd, "    if s >= " as *u8); p13_wn(fd, ns); p13_w(fd, " { return 0 - 1 }\n" as *u8)
  p13_w(fd, "    if e < 0 { return 0 - 1 }\n" as *u8)
  p13_w(fd, "    if e >= " as *u8); p13_wn(fd, ne); p13_w(fd, " { return 0 - 1 }\n" as *u8)
  var s: i64 = 0
  while s < ns {
      var e: i64 = 0
      while e < ne {
          let v: i64 = spec[3 + s * ne + e]
          if v >= 0 {
              p13_w(fd, "    if s == " as *u8); p13_wn(fd, s)
              p13_w(fd, " { if e == " as *u8); p13_wn(fd, e)
              p13_w(fd, " { return " as *u8); p13_wn(fd, v); p13_w(fd, " } }\n" as *u8)
          }
          e = e + 1
      }
      s = s + 1
  }
  p13_w(fd, "    return 0 - 1\n}\n" as *u8)
  p13_w(fd, "func " as *u8); p13_w(fd, name); p13_w(fd, "_run(ev: *i64, n: i64, s0: i64) -> i64 {\n" as *u8)
  p13_w(fd, "    var s: i64 = s0\n    var i: i64 = 0\n" as *u8)
  p13_w(fd, "    while i < n {\n" as *u8)
  p13_w(fd, "        s = " as *u8); p13_w(fd, name); p13_w(fd, "_step(s, ev[i])\n" as *u8)
  p13_w(fd, "        if s < 0 { return 0 - 1 }\n" as *u8)
  p13_w(fd, "        i = i + 1\n    }\n    return s\n}\n" as *u8)
  return 1
74}
75
76// greedy defined-transition walk from s0 (lowest defined event each step, up to 8 steps);
77// writes events to wev[], expected states unused beyond final; returns walk length
78func p13_walk(spec: *i64, wev: *i64, wfinal: *i64) -> i64 {
  let ns: i64 = spec[0]
  let ne: i64 = spec[1]
  var s: i64 = spec[2]
  var len: i64 = 0
  var going: i64 = 1
  while going == 1 {
      if len >= 8 { going = 0 }
      if going == 1 {
          var found: i64 = 0 - 1
          var e: i64 = 0
          while e < ne {
              if found < 0 { if spec[3 + s * ne + e] >= 0 { found = e } }
              e = e + 1
          }
          if found < 0 { going = 0 }
          if found >= 0 {
              wev[len] = found
              s = spec[3 + s * ne + found]
              len = len + 1
          }
      }
  }
  wfinal[0] = s
  return len
103}
104
105// find an UNDEFINED (s,e) pair; returns s*256+e, or -1 if the table is total
106func p13_find_undef(spec: *i64) -> i64 {
  let ns: i64 = spec[0]
  let ne: i64 = spec[1]
  var s: i64 = 0
  while s < ns {
      var e: i64 = 0
      while e < ne {
          if spec[3 + s * ne + e] < 0 { return s * 256 + e }
          e = e + 1
      }
      s = s + 1
  }
  return 0 - 1
119}
120
121// author the test: KATs computed HERE from the same table
122func pe13_emit_state_machine_test(fd: i64, name: *u8, spec: *i64) -> i64 {
  let wev: *i64 = sys_mmap(96) as *i64
  let wfinal: *i64 = sys_mmap(16) as *i64
  let wlen: i64 = p13_walk(spec, wev, wfinal)
  let undef: i64 = p13_find_undef(spec)
  p13_w(fd, "// AUTHORED BY THE NISHI BUILDER (pattern: STATE_MACHINE test) -- KATs computed from the table at emit time\n" as *u8)
  p13_w(fd, "import \"" as *u8); p13_w(fd, name); p13_w(fd, ".nx\"\nimport \"nx_syscalls.nx\"\n" as *u8)
  p13_w(fd, "func main() -> i64 {\n    let ev: *i64 = sys_mmap(128) as *i64\n" as *u8)
  var i: i64 = 0
  while i < wlen {
      p13_w(fd, "    ev[" as *u8); p13_wn(fd, i); p13_w(fd, "] = " as *u8); p13_wn(fd, wev[i]); p13_w(fd, "\n" as *u8)
      i = i + 1
  }
  // [1] the greedy walk lands on the computed final state
  p13_w(fd, "    if " as *u8); p13_w(fd, name); p13_w(fd, "_run(ev, " as *u8); p13_wn(fd, wlen)
  p13_w(fd, ", " as *u8); p13_wn(fd, spec[2]); p13_w(fd, ") == " as *u8); p13_wn(fd, wfinal[0]); p13_w(fd, " {\n" as *u8)
  // [2] undefined transition refused (or out-of-range event when the table is total)
  if undef >= 0 {
      p13_w(fd, "    if " as *u8); p13_w(fd, name); p13_w(fd, "_step(" as *u8); p13_wn(fd, undef / 256)
      p13_w(fd, ", " as *u8); p13_wn(fd, undef % 256); p13_w(fd, ") == 0 - 1 {\n" as *u8)
  }
  if undef < 0 {
      p13_w(fd, "    if " as *u8); p13_w(fd, name); p13_w(fd, "_step(0, " as *u8); p13_wn(fd, spec[1]); p13_w(fd, ") == 0 - 1 {\n" as *u8)
  }
  // [3] out-of-range state refused
  p13_w(fd, "    if " as *u8); p13_w(fd, name); p13_w(fd, "_step(" as *u8); p13_wn(fd, spec[0]); p13_w(fd, ", 0) == 0 - 1 {\n" as *u8)
  // [4] determinism: the same walk twice
  p13_w(fd, "    if " as *u8); p13_w(fd, name); p13_w(fd, "_run(ev, " as *u8); p13_wn(fd, wlen)
  p13_w(fd, ", " as *u8); p13_wn(fd, spec[2]); p13_w(fd, ") == " as *u8); p13_wn(fd, wfinal[0])
  p13_w(fd, " { sys_exit(0) } } } }\n" as *u8)
  p13_w(fd, "    sys_exit(1)\n    return 1\n}\n" as *u8)
  return 1
154}
155
156// author module+test to disk; REFUSES a bad table (returns 0, writes nothing)
157func pe13_author_state_machine(name: *u8, modpath: *u8, testpath: *u8, spec: *i64) -> i64 {
  if p13_spec_ok(spec) != 1 { return 0 }
  let mf: i64 = sys_openat_wr(modpath, 0x1a4); if mf < 0 { return 0 }
  pe13_emit_state_machine(mf, name, spec); sys_close(mf)
  let tf: i64 = sys_openat_wr(testpath, 0x1a4); if tf < 0 { return 0 }
  pe13_emit_state_machine_test(tf, name, spec); sys_close(tf)
  return 1
164}
nx_pattern_emit13.nx source

`nx_pattern_emit13.nx` source
