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

↩ module page · 244 lines · 9328 B
1// nx_docx_rich_gate.nx -- gate for RICH .docx (formatting runs + tables), the office-census gap-closer for
2// OF-W3 (formatting) + OF-W4 (tables). The OPC writer uses STORED (uncompressed) ZIP, so the raw .docx bytes
3// contain word/document.xml VERBATIM -- the gate greps them to prove the markup is really EMITTED (not just
4// that a symbol name appears in source), and reads the text back through the real docx reader (which unzips +
5// parses -> proves the OPC package is structurally valid).
6//
7// spec fixture: H heading / B bold / I italic / P plain / a 3x3 bordered TABLE / trailing plain.
8// Rows: 1 rich-write 2 text-roundtrip(heading+plain+table-cell+trailing) 3 formatting-emitted(w:rPr+w:b+w:sz)
9//       4 table-emitted(w:tbl+w:tblPr+w:tr+w:tc) 5 italic-emitted 6 determinism 7 loud-fail-missing-spec[neg]
10// Evidence: DOCX-RICH-GATE -> stdout + knowledge/status/vizsla_gate.log; exit 0 iff 7/7.
11// license_tier: ORIGINAL
12import "nx_syscalls.nx"
13import "nx_gate_verdict.nx"
14
15func rg_slen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
16func rg_p(s: *u8) -> i64 { sys_write(1, s, rg_slen(s)); return 0 }
17
18func rg_cat(dst: *u8, off: i64, s: *u8) -> i64 {
  var i: i64 = 0
  while s[i] != (0 as u8) { dst[off + i] = s[i]; i = i + 1 }
  return off + i
22}
23
24func rg_catn(dst: *u8, off: i64, v: i64) -> i64 {
  var o: i64 = off
  var m: i64 = v
  if m < 0 { dst[o] = 45 as u8; o = o + 1; m = 0 - m }
  let t: *u8 = sys_mmap(28)
  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 i: i64 = 0
  while i < k { dst[o + i] = t[k - 1 - i]; i = i + 1 }
  return o + k
35}
36
37func rg_write(path: *u8, content: *u8) -> i64 {
  let fd: i64 = sys_openat_wr(path, 0x1a4)
  if fd < 0 { return 0 - 1 }
  sys_write(fd, content, rg_slen(content))
  sys_close(fd)
  return 0
43}
44
45func rg_readall(path: *u8, szout: *i64) -> *u8 {
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { szout[0] = 0 - 1; return 0 as *u8 }
  let sz: i64 = sys_lseek(fd, 0, 2)
  sys_lseek(fd, 0, 0)
  let buf: *u8 = sys_mmap(sz + 64)
  var got: i64 = 0
  var n: i64 = 1
  while n > 0 {
      n = sys_read(fd, (buf as i64 + got) as *u8, 65536)
      if n > 0 { got = got + n }
  }
  sys_close(fd)
  szout[0] = got
  return buf
60}
61
62func rg_runv(elf: *u8, args: *i64, outpath: *u8) -> i64 {
  let pid: i64 = sys_fork()
  if pid == 0 {
      if (outpath as i64) != 0 {
          let ofd: i64 = sys_openat_wr(outpath, 0x1a4)
          if ofd >= 0 { sys_dup3(ofd, 1, 0); sys_dup3(ofd, 2, 0) }
      }
      let argv: *i64 = sys_mmap(128) as *i64
      argv[0] = elf as i64
      var i: i64 = 0
      var go: i64 = 1
      while go == 1 {
          if args[i] == 0 { go = 0 } else {
              argv[i + 1] = args[i]
              i = i + 1
          }
      }
      argv[i + 1] = 0
      let envp: *i64 = sys_mmap(16) as *i64
      envp[0] = 0
      sys_execve(elf, argv, envp)
      sys_exit(127)
  }
  let st: *i64 = sys_mmap(16) as *i64
  sys_wait4(pid, st, 0)
  let sig: i64 = st[0] & 0x7f
  if sig != 0 { return 128 + sig }
  return (st[0] >> 8) & 0xff
90}
91
92func rg_has(path: *u8, needle: *u8) -> i64 {
  let szp: *i64 = sys_mmap(16) as *i64
  let b: *u8 = rg_readall(path, szp)
  let sz: i64 = szp[0]
  let n: i64 = rg_slen(needle)
  if sz < n { return 0 }
  var i: i64 = 0
  while i + n <= sz {
      var ok: i64 = 1
      var j: i64 = 0
      while j < n {
          if b[i + j] != needle[j] { ok = 0; j = n } else { j = j + 1 }
      }
      if ok == 1 { return 1 }
      i = i + 1
  }
  return 0
109}
110
111func rg_fileeq(p1: *u8, p2: *u8) -> i64 {
  let s1: *i64 = sys_mmap(16) as *i64
  let s2: *i64 = sys_mmap(16) as *i64
  let b1: *u8 = rg_readall(p1, s1)
  let b2: *u8 = rg_readall(p2, s2)
  if s1[0] != s2[0] { return 0 }
  if s1[0] <= 0 { return 0 }
  var i: i64 = 0
  while i < s1[0] {
      if b1[i] != b2[i] { return 0 }
      i = i + 1
  }
  return 1
124}
125
126func rg_row(name: *u8, pass: i64) -> i64 {
  rg_p("ROW " as *u8)
  rg_p(name)
  if pass == 1 { rg_p(" PASS\n" as *u8) } else { rg_p(" FAIL\n" as *u8) }
  return pass
131}
132
133func rg_args(a1: *u8, a2: *u8, a3: *u8, a4: *u8) -> *i64 {
  let a: *i64 = sys_mmap(64) as *i64
  a[0] = a1 as i64
  a[1] = a2 as i64
  a[2] = a3 as i64
  a[3] = a4 as i64
  a[4] = 0
  return a
141}
142
143func main(argc: i64, argv: *i64) -> i64 {
  rg_p("=== DOCX RICH GATE: formatting runs (bold/italic/heading) + TABLES emit + round-trip ===\n" as *u8)
  let docx: *u8 = "buildroot/_build/nx_docx.sov.elf" as *u8
  let pr: i64 = sys_openat_rd(docx)
  if pr >= 0 { sys_close(pr) } else {
      rg_p(" instrument missing -> rebuilding via durable runner\n" as *u8)
      rg_runv("_offc/nx_sov_build_run.elf" as *u8, rg_args("nx_docx" as *u8, 0 as *u8, 0 as *u8, 0 as *u8), "/tmp/dxr_rebuild.out" as *u8)
  }
151
  rg_write("/tmp/dxr_spec.txt" as *u8, "H Meeting Agenda\nB Attendees\nP Alice, Bob, and Carol\nI noted for the record\nT Item|Owner|Status\nT Budget|Alice|Done\nT Venue|Bob|Open\nP End of agenda\n" as *u8)
153
  var pass: i64 = 0
  var r: i64 = 0
156
  // row 1: write rich
  let rc1: i64 = rg_runv(docx, rg_args("writerich" as *u8, "/tmp/dxr_rich.docx" as *u8, "/tmp/dxr_spec.txt" as *u8, 0 as *u8), "/tmp/dxr_r1.txt" as *u8)
  r = 0
  if rc1 == 0 { if rg_has("/tmp/dxr_r1.txt" as *u8, "DOCX-WRITE-RICH-OK path=/tmp/dxr_rich.docx bytes=" as *u8) == 1 { r = 1 } }
  pass = pass + rg_row("rich-write" as *u8, r)
162
  // row 2: text round-trips (heading + plain + a table cell + trailing) through the REAL docx reader
  let rc2: i64 = rg_runv(docx, rg_args("read" as *u8, "/tmp/dxr_rich.docx" as *u8, 0 as *u8, 0 as *u8), "/tmp/dxr_r2.txt" as *u8)
  r = 0
  if rc2 == 0 {
      if rg_has("/tmp/dxr_r2.txt" as *u8, "Meeting Agenda" as *u8) == 1 {
          if rg_has("/tmp/dxr_r2.txt" as *u8, "Alice, Bob, and Carol" as *u8) == 1 {
              if rg_has("/tmp/dxr_r2.txt" as *u8, "Budget" as *u8) == 1 {
                  if rg_has("/tmp/dxr_r2.txt" as *u8, "End of agenda" as *u8) == 1 { r = 1 }
              }
          }
      }
  }
  pass = pass + rg_row("text-roundtrip" as *u8, r)
176
  // row 3: formatting really EMITTED (raw STORED .docx bytes carry the run-properties)
  r = 0
  if rg_has("/tmp/dxr_rich.docx" as *u8, "<w:rPr><w:b/>" as *u8) == 1 {
      if rg_has("/tmp/dxr_rich.docx" as *u8, "<w:sz w:val=\"32\"/>" as *u8) == 1 { r = 1 }
  }
  pass = pass + rg_row("formatting-emitted" as *u8, r)
183
  // row 4: table really EMITTED (tbl + tblPr + tr + tc)
  r = 0
  if rg_has("/tmp/dxr_rich.docx" as *u8, "<w:tbl>" as *u8) == 1 {
      if rg_has("/tmp/dxr_rich.docx" as *u8, "<w:tblPr>" as *u8) == 1 {
          if rg_has("/tmp/dxr_rich.docx" as *u8, "<w:tr>" as *u8) == 1 {
              if rg_has("/tmp/dxr_rich.docx" as *u8, "<w:tc>" as *u8) == 1 { r = 1 }
          }
      }
  }
  pass = pass + rg_row("table-emitted" as *u8, r)
194
  // row 5: italic run
  r = rg_has("/tmp/dxr_rich.docx" as *u8, "<w:i/>" as *u8)
  pass = pass + rg_row("italic-emitted" as *u8, r)
198
  // row 6: determinism
  rg_runv(docx, rg_args("writerich" as *u8, "/tmp/dxr_rich2.docx" as *u8, "/tmp/dxr_spec.txt" as *u8, 0 as *u8), "/tmp/dxr_r6.txt" as *u8)
  r = rg_fileeq("/tmp/dxr_rich.docx" as *u8, "/tmp/dxr_rich2.docx" as *u8)
  pass = pass + rg_row("determinism" as *u8, r)
203
  // row 7: missing spec (negative control)
  let rc7: i64 = rg_runv(docx, rg_args("writerich" as *u8, "/tmp/dxr_x.docx" as *u8, "/tmp/dxr_nope.txt" as *u8, 0 as *u8), "/tmp/dxr_r7.txt" as *u8)
  r = 0
  if rc7 == 1 { r = 1 }
  pass = pass + rg_row("loud-fail-missing-spec" as *u8, r)
209
  let permil: i64 = (pass * 1000) / 7
  let logfd: i64 = sys_openat_append("knowledge/status/vizsla_gate.log" as *u8, 0x1a4)
  var fdi: i64 = 0
  while fdi < 2 {
      var fd: i64 = 1
      if fdi == 1 { fd = logfd }
      if fd > 0 {
          let line: *u8 = sys_mmap(256)
          var o: i64 = 0
          o = rg_cat(line, o, "DOCX-RICH-GATE epoch=" as *u8)
          o = rg_catn(line, o, sys_now_realtime_sec())
          o = rg_cat(line, o, " rows=7 pass=" as *u8)
          o = rg_catn(line, o, pass)
          o = rg_cat(line, o, " permil=" as *u8)
          o = rg_catn(line, o, permil)
          if pass == 7 {
              o = rg_cat(line, o, " verdict=GREEN\n" as *u8)
          } else {
              o = rg_cat(line, o, " verdict=RED\n" as *u8)
          }
          sys_write(fd, line, o)
      }
      fdi = fdi + 1
  }
  if logfd > 0 { sys_close(logfd) }
  // MIGRATED onto nx_gate_verdict by nx_gate_dry_apply (D001, minimal form): every check
  // row above is untouched, so the PASS/FAIL vector cannot change; only the hand-rolled
  // verdict emission is replaced by the ONE shared base class. Proven by nx_gate_migrate verify.
  let ctr__dry: *i64 = gv_ctr()
  ctr__dry[0] = pass
  ctr__dry[1] = 7
  let rc__dry: i64 = gv_verdict("DOCX-RICH-GATE" as *u8, ctr__dry, "teeth unchanged; verdict emission migrated onto the shared base class" as *u8)
  sys_exit(rc__dry)
  return rc__dry
244}
nx_docx_rich_gate.nx source

`nx_docx_rich_gate.nx` source
