code wiki / (root) / nx_diag_voice_gate.nx
`nx_diag_voice_gate.nx` source

↩ module page · 272 lines · 15899 B
1// nx_diag_voice_gate.nx -- LN27 (lang.plan, 2026-09-02): EVERY DIAGNOSTIC TEACHES IN ONE VOICE.
2// The operator named the first LN24 messages as output that does not help a programmer grow: a
3// location and a fact, no why, no fix. The parser's teaching sites already carry the shape (nx_diag_at,
4// nx_diag_caret, then "why the build stopped:" and "fix:"); this gate walks EVERY diagnostic emission
5// site in the toolchain sources and refuses a BARE site -- a location or a refusal printed without a
6// why line and a fix line within its window -- as a RATCHET: the bare count per file may never RISE
7// above knowledge/status/diag_voice_ratchet.conf, it self-tightens on every fall, and it never rewrites
8// its baseline on a rise (a ratchet that launders itself green is a threshold wearing a ratchet's name).
9// It prints the worklist (BARE file:line) so the count is actionable, never a bare number.
10//
11// SITE RULE (mechanical, declared, bite-proven below): a source line is an emission site when it is
12// not a comment line and, before any `//`, contains one of
13//   nx_diag_at(   nx_diag_organ_at(   "error:    nxcx_log("nx_compile_x86:    "nxasm: FATAL    "error at function
14// and is not a `func ` definition line. It is VOICED when, within the next DV_WINDOW lines and before
15// the next site, one line carries a why ("why the build stopped" or a call to nx_diag_why_) and one
16// carries a fix ("fix:" or a did-you-mean nx_dym_note). Everything else is BARE.
17// The classifier is a pure function over a buffer so the fixtures below are assembled at RUNTIME --
18// a detector that scans source would otherwise find its own test fixture in this very file.
19//
20//   nx_diag_voice_gate            -- census + ratchet + controls, verdict in the exit code (gv_verdict)
21// license_tier: ORIGINAL  layer: lang  module: nishi-core.lang.diag_voice_gate
22import "nx_syscalls.nx"
23import "nx_gate_verdict.nx"
24
25const DV_WINDOW:   i64 = 60        // lines after a site in which why and fix must appear (the exhaustiveness site lists every missing variant first: 48 lines)
26const DV_LINECAP:  i64 = 4096      // longest source line examined (longer lines are cut, never skipped)
27const DV_NFILES:   i64 = 8
28const DV_PATHCAP:  i64 = 256
29const DV_CONFCAP:  i64 = 4096
30const DV_RATCHET:  *u8 = "knowledge/status/diag_voice_ratchet.conf\x00" as *u8
31
32func dv_slen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
33func dv_w(s: *u8) -> i64 { sys_write(1, s, dv_slen(s)); return 0 }
34func dv_n(v: i64) -> i64 {
  if v == 0 { sys_write(1, "0" as *u8, 1); return 0 }
  var m: i64 = v; if m < 0 { sys_write(1, "-" as *u8, 1); m = 0 - m }
  let t: *u8 = sys_mmap(24); var k: i64 = 0
  while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
  let o: *u8 = sys_mmap(24); var w: i64 = 0; var q: i64 = k - 1
  while q >= 0 { o[w] = t[q]; w = w + 1; q = q - 1 }
  sys_write(1, o, w); return 0
42}
43func dv_cat(dst: *u8, off: i64, s: *u8) -> i64 { var o: i64 = off; var i: i64 = 0; while s[i] != (0 as u8) { dst[o] = s[i]; o = o + 1; i = i + 1 } dst[o] = 0 as u8; return o }
44
45// first index of pat in line[0..n), or -1.
46func dv_find(line: *u8, n: i64, pat: *u8) -> i64 {
  let pl: i64 = dv_slen(pat)
  if pl <= 0 { return 0 - 1 }
  var i: i64 = 0
  while i + pl <= n {
      var j: i64 = 0; var ok: i64 = 1
      while j < pl { if line[i + j] != pat[j] { ok = 0; j = pl } else { j = j + 1 } }
      if ok == 1 { return i }
      i = i + 1
  }
  return 0 - 1
57}
58// index of the first non-space byte.
59func dv_lead(line: *u8, n: i64) -> i64 {
  var i: i64 = 0
  while i < n { if line[i] == (32 as u8) { i = i + 1 } else { if line[i] == (9 as u8) { i = i + 1 } else { return i } } }
  return n
63}
64// a pattern counts only when it sits BEFORE any line comment.
65func dv_has_code(line: *u8, n: i64, pat: *u8) -> i64 {
  let p: i64 = dv_find(line, n, pat)
  if p < 0 { return 0 }
  let c: i64 = dv_find(line, n, "//" as *u8)
  if c >= 0 { if c < p { return 0 } }
  return 1
71}
72func dv_is_site(line: *u8, n: i64) -> i64 {
  let l: i64 = dv_lead(line, n)
  if l + 1 < n { if line[l] == (47 as u8) { if line[l + 1] == (47 as u8) { return 0 } } }     // comment line
  if dv_find(line, n, "func " as *u8) == l { return 0 }                                          // a definition, not a site
  if dv_has_code(line, n, "nx_diag_at(" as *u8) == 1 { return 1 }
  if dv_has_code(line, n, "nx_diag_organ_at(" as *u8) == 1 { return 1 }
  if dv_has_code(line, n, "\"error: " as *u8) == 1 { return 1 }
  if dv_has_code(line, n, "nxcx_log(\"nx_compile_x86: " as *u8) == 1 { return 1 }
  if dv_has_code(line, n, "\"nxasm: FATAL" as *u8) == 1 { return 1 }
  if dv_has_code(line, n, "\"error at function" as *u8) == 1 { return 1 }
  return 0
83}
84func dv_is_why(line: *u8, n: i64) -> i64 {
  if dv_find(line, n, "why the build stopped" as *u8) >= 0 { return 1 }
  if dv_find(line, n, "why this matters" as *u8) >= 0 { return 1 }          // the non-fatal form: a warning still teaches
  if dv_has_code(line, n, "nx_diag_why_" as *u8) == 1 { return 1 }
  return 0
89}
90func dv_is_fix(line: *u8, n: i64) -> i64 {
  if dv_find(line, n, "fix:" as *u8) >= 0 { return 1 }
  if dv_has_code(line, n, "nx_dym_note" as *u8) == 1 { return 1 }
  return 0
94}
95
96// THE CENSUS over one buffer. out[0]=sites out[1]=bare out[2]=voiced. list=1 prints BARE <fname>:<line>.
97// Lines are indexed into ls[] once, then every site looks ahead through the window.
98func dv_census(buf: *u8, n: i64, fname: *u8, out: *i64, list: i64) -> i64 {
  var nl: i64 = 1; var i: i64 = 0
  while i < n { if buf[i] == (10 as u8) { nl = nl + 1 } i = i + 1 }
  let ls: *i64 = sys_mmap((nl + 2) * 8) as *i64
  let ll: *i64 = sys_mmap((nl + 2) * 8) as *i64
  var cnt: i64 = 0; var st: i64 = 0; i = 0
  while i <= n {
      var eol: i64 = 0
      if i == n { eol = 1 } else { if buf[i] == (10 as u8) { eol = 1 } }
      if eol == 1 { ls[cnt] = st; var w: i64 = i - st; if w > DV_LINECAP { w = DV_LINECAP } ll[cnt] = w; cnt = cnt + 1; st = i + 1 }
      i = i + 1
  }
  let issite: *i64 = sys_mmap((cnt + 2) * 8) as *i64
  var k: i64 = 0
  while k < cnt { issite[k] = dv_is_site((buf as i64 + ls[k]) as *u8, ll[k]); k = k + 1 }
  var sites: i64 = 0; var bare: i64 = 0; var voiced: i64 = 0
  k = 0
  while k < cnt {
      if issite[k] == 1 {
          sites = sites + 1
          var why: i64 = 0; var fix: i64 = 0
          var j: i64 = k + 1; var go: i64 = 1
          while go == 1 {
              if j >= cnt { go = 0 } else {
                  if j - k > DV_WINDOW { go = 0 } else {
                      if issite[j] == 1 { go = 0 } else {
                          let lp: *u8 = (buf as i64 + ls[j]) as *u8
                          if dv_is_why(lp, ll[j]) == 1 { why = 1 }
                          if dv_is_fix(lp, ll[j]) == 1 { fix = 1 }
                          j = j + 1
                      }
                  }
              }
          }
          if (why == 1) & (fix == 1) { voiced = voiced + 1 } else {
              bare = bare + 1
              if list == 1 { dv_w("  BARE " as *u8); dv_w(fname); dv_w(":" as *u8); dv_n(k + 1); if why == 0 { dv_w(" no-why" as *u8) } if fix == 0 { dv_w(" no-fix" as *u8) } dv_w("\n" as *u8) }
          }
      }
      k = k + 1
  }
  out[0] = sites; out[1] = bare; out[2] = voiced
  return sites
141}
142
143// read <root>/<fname> with a two-root probe: buildroot/runtime/ (NAS gate CWD) then runtime/ (laptop CWD).
144func dv_read_src(fname: *u8, lenp: *i64) -> *u8 {
  let p: *u8 = sys_mmap(DV_PATHCAP)
  var o: i64 = dv_cat(p, 0, "buildroot/runtime/" as *u8); o = dv_cat(p, o, fname)
  lenp[0] = 0
  var b: *u8 = sys_read_file(p, lenp)
  if lenp[0] > 0 { return b }
  o = dv_cat(p, 0, "runtime/" as *u8); o = dv_cat(p, o, fname)
  lenp[0] = 0
  b = sys_read_file(p, lenp)
  return b
154}
155// baseline row "<fname>=<n>" -> n, or -1 when absent.
156func dv_baseline(conf: *u8, cn: i64, fname: *u8) -> i64 {
  if cn <= 0 { return 0 - 1 }
  let key: *u8 = sys_mmap(DV_PATHCAP)
  var o: i64 = dv_cat(key, 0, fname); o = dv_cat(key, o, "=" as *u8)
  let p: i64 = dv_find(conf, cn, key)
  if p < 0 { return 0 - 1 }
  var i: i64 = p + o; var v: i64 = 0; var any: i64 = 0
  while i < cn { let c: i64 = conf[i] as i64; if (c >= 48) & (c <= 57) { v = v * 10 + (c - 48); any = 1; i = i + 1 } else { i = cn } }
  if any == 0 { return 0 - 1 }
  return v
166}
167func dv_write_conf(names: *i64, bares: *i64, nf: i64) -> i64 {
  let b: *u8 = sys_mmap(DV_CONFCAP)
  var o: i64 = dv_cat(b, 0, "# diag_voice_ratchet.conf -- BARE diagnostic sites per toolchain source (LN27). Written by nx_diag_voice_gate on every FALL; a RISE is RED and never rewrites this file.\n" as *u8)
  var i: i64 = 0
  while i < nf {
      o = dv_cat(b, o, names[i] as *u8); o = dv_cat(b, o, "=" as *u8)
      let t: *u8 = sys_mmap(24); var m: i64 = bares[i]; var k: i64 = 0
      if m == 0 { t[0] = 48 as u8; k = 1 }
      while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
      var q: i64 = k - 1
      while q >= 0 { b[o] = t[q]; o = o + 1; q = q - 1 }
      b[o] = 10 as u8; o = o + 1; b[o] = 0 as u8
      i = i + 1
  }
  let fd: i64 = sys_openat_wr(DV_RATCHET, 420)
  if fd < 0 { return 0 - 1 }
  sys_write(fd, b, o); sys_close(fd)
  return o
185}
186
187// THE SYMBOL THE lang.matrix WATCH MEASURES (diag_voice_gate): the whole census + ratchet as one call.
188// Returns the total BARE count over the toolchain, or -1 when a source could not be read.
189func diag_voice_gate(c: *i64) -> i64 {
  let names: *i64 = sys_mmap(DV_NFILES * 8) as *i64
  names[0] = "nx_tokenizer.nx" as *u8 as i64;  names[1] = "nx_parse.nx" as *u8 as i64
  names[2] = "nx_ir.nx" as *u8 as i64;         names[3] = "nx_compile_x86.nx" as *u8 as i64
  names[4] = "nxasm_x86_main.nx" as *u8 as i64; names[5] = "nx_x86_64_ctx.nx" as *u8 as i64
  names[6] = "nx_opt.nx" as *u8 as i64;        names[7] = "nx_x86_regalloc.nx" as *u8 as i64
  let bares: *i64 = sys_mmap(DV_NFILES * 8) as *i64
  let lenp: *i64 = sys_mmap(16) as *i64
  let out: *i64 = sys_mmap(32) as *i64
  let cl: *i64 = sys_mmap(16) as *i64
  cl[0] = 0
  let conf: *u8 = sys_read_file(DV_RATCHET, cl)
  var readok: i64 = 0; var sites: i64 = 0; var bare: i64 = 0; var voiced: i64 = 0
  var rises: i64 = 0; var falls: i64 = 0; var firsts: i64 = 0
  var i: i64 = 0
  while i < DV_NFILES {
      let fname: *u8 = names[i] as *u8
      let b: *u8 = dv_read_src(fname, lenp)
      if lenp[0] > 0 {
          readok = readok + 1
          dv_census(b, lenp[0], fname, out, 1)
          sites = sites + out[0]; bare = bare + out[1]; voiced = voiced + out[2]
          bares[i] = out[1]
          let base: i64 = dv_baseline(conf, cl[0], fname)
          dv_w("  FILE " as *u8); dv_w(fname); dv_w(" sites=" as *u8); dv_n(out[0]); dv_w(" voiced=" as *u8); dv_n(out[2]); dv_w(" bare=" as *u8); dv_n(out[1]); dv_w(" baseline=" as *u8); dv_n(base)
          if base < 0 { firsts = firsts + 1; dv_w(" FIRST-SIGHT" as *u8) } else {
              if out[1] > base { rises = rises + 1; dv_w(" RISE" as *u8) }
              if out[1] < base { falls = falls + 1; dv_w(" FALL" as *u8) }
          }
          dv_w("\n" as *u8)
      } else { bares[i] = 0 - 1; dv_w("  FILE " as *u8); dv_w(fname); dv_w(" UNREADABLE\n" as *u8) }
      i = i + 1
  }
  dv_w("DIAG-VOICE files=" as *u8); dv_n(readok); dv_w("/" as *u8); dv_n(DV_NFILES); dv_w(" sites=" as *u8); dv_n(sites); dv_w(" voiced=" as *u8); dv_n(voiced); dv_w(" bare=" as *u8); dv_n(bare)
  dv_w(" rises=" as *u8); dv_n(rises); dv_w(" falls=" as *u8); dv_n(falls); dv_w(" first_sight=" as *u8); dv_n(firsts); dv_w(" (voiced+bare=sites per file; a BARE row above names the site)\n" as *u8)
  gv_check("toolchain-sources-all-readable" as *u8, readok == DV_NFILES, c)
  gv_check("emission-sites-found-not-vacuous" as *u8, sites > 0, c)
  gv_check("positive-control-existing-teaching-sites-are-voiced" as *u8, voiced > 0, c)
  gv_check("partition-voiced-plus-bare-equals-sites" as *u8, voiced + bare == sites, c)
  gv_check("ratchet-no-file-rises-above-its-baseline" as *u8, rises == 0, c)
  // TIGHTEN on a fall or a first sight; NEVER on a rise (a rise stays RED against the old baseline).
  var wrote: i64 = 0
  if rises == 0 { if (falls > 0) | (firsts > 0) { wrote = dv_write_conf(names, bares, DV_NFILES) } }
  if wrote > 0 {
      let cl2: *i64 = sys_mmap(16) as *i64; cl2[0] = 0
      let conf2: *u8 = sys_read_file(DV_RATCHET, cl2)
      var agree: i64 = 1; i = 0
      while i < DV_NFILES { if dv_baseline(conf2, cl2[0], names[i] as *u8) != bares[i] { agree = 0 } i = i + 1 }
      gv_check("ratchet-tightened-and-reread-matches-by-content" as *u8, agree == 1, c)
      dv_w("  RATCHET written " as *u8); dv_w(DV_RATCHET); dv_w(" bytes=" as *u8); dv_n(wrote); dv_w("\n" as *u8)
  }
  if readok < DV_NFILES { return 0 - 1 }
  return bare
242}
243
244func main() -> i64 {
  let c: *i64 = gv_ctr()
  // ---- NEGATIVE / POSITIVE CONTROLS on runtime-assembled fixtures (never files the census scans) ----
  let out: *i64 = sys_mmap(32) as *i64
  let fx: *u8 = sys_mmap(4096)
  var o: i64 = dv_cat(fx, 0, "func f(P: *Parser) -> i64 {\n    nx_diag_at(t.line)\n    nx_diag_puts(\": this name is used before it is declared\\n\" as *u8)\n    return 1\n}\n" as *u8)
  dv_census(fx, o, "fx_bare" as *u8, out, 0)
  gv_check("neg-control-planted-bare-site-reads-BARE" as *u8, (out[0] == 1) & (out[1] == 1), c)
  o = dv_cat(fx, 0, "func f(P: *Parser) -> i64 {\n    nx_diag_at(t.line)\n    nx_diag_puts(\": this name is used before it is declared\\n\" as *u8)\n    nx_diag_puts(\"  why the build stopped: a use before a declaration has nothing to bind to\\n\" as *u8)\n    nx_diag_puts(\"  fix: move the declaration above this line\\n\" as *u8)\n    return 1\n}\n" as *u8)
  dv_census(fx, o, "fx_voiced" as *u8, out, 0)
  gv_check("control-voiced-site-reads-VOICED" as *u8, (out[0] == 1) & (out[2] == 1) & (out[1] == 0), c)
  o = dv_cat(fx, 0, "func f() -> i64 {\n    // the parser calls nx_diag_at( here in prose only\n    let x: i64 = 1  // nx_diag_organ_at( in a trailing comment\n    return x\n}\n" as *u8)
  dv_census(fx, o, "fx_comment" as *u8, out, 0)
  gv_check("control-comment-mentions-are-not-sites" as *u8, out[0] == 0, c)
  o = dv_cat(fx, 0, "func nx_diag_at(line: i64) -> i64 {\n    nx_diag_puts(\"error at \" as *u8)\n    return nx_diag_loc(line)\n}\n" as *u8)
  dv_census(fx, o, "fx_def" as *u8, out, 0)
  gv_check("control-the-voice-helper-definition-is-not-a-site" as *u8, out[0] == 0, c)
  o = dv_cat(fx, 0, "func g() -> i64 {\n    nx_diag_at(t.line)\n    nx_diag_puts(\": x\\n\" as *u8)\n    nx_diag_why_undefined()\n    nx_dym_note2(P, nm, nl)\n    return 1\n}\n" as *u8)
  dv_census(fx, o, "fx_helpers" as *u8, out, 0)
  gv_check("control-why-and-fix-helpers-count-as-voice" as *u8, (out[0] == 1) & (out[2] == 1), c)
  o = dv_cat(fx, 0, "func h() -> i64 {\n    nx_diag_at(t.line)\n    nx_diag_puts(\"  why the build stopped: only why, no fix\\n\" as *u8)\n    nx_diag_at(u.line)\n    nx_diag_puts(\"  fix: the fix belongs to the SECOND site, not the first\\n\" as *u8)\n    return 1\n}\n" as *u8)
  dv_census(fx, o, "fx_window" as *u8, out, 0)
  gv_check("neg-control-a-fix-after-the-next-site-does-not-voice-the-first" as *u8, (out[0] == 2) & (out[1] == 2), c)
267
  // ---- THE CENSUS over the toolchain sources ----
  let bare: i64 = diag_voice_gate(c)
  gv_check("census-ran-over-the-toolchain" as *u8, bare >= 0, c)
  return gv_verdict("DIAG-VOICE-GATE" as *u8, c, "LN27: every diagnostic emission site in the toolchain carries where, why and fix -- bare sites ratchet down, never up" as *u8)
272}
nx_diag_voice_gate.nx source

`nx_diag_voice_gate.nx` source
