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

↩ module page · 317 lines · 13242 B
1// nx_lang_lint_ext.nx -- TWO landmine classes nx_lang_lint does not yet see, both paid for in build cycles
2// on 2026-07-25/26. This EXTENDS the existing linter's vocabulary; it does not replace it, and it
3// deliberately re-implements none of L1-L4.
4//
5// L5 EMPTYESC -- an EMPTY LITERAL IN DISGUISE. L2 catches a literal "" by looking for two adjacent quote
6//   bytes. It does not catch "\x00", which is four source characters and still a zero-length string, so it
7//   hits the SAME nx_cc defect (a zero-length literal returns a pointer to the NEXT literal in the pool).
8//   That is precisely the shape that segfaulted a gate: a sentinel spelled "\x00" silently became some
9//   other string. A detector that catches only the obvious spelling of a defect leaves the subtle spelling
10//   free to keep landing.
11//
12// L6 UNDEFCONST -- an ALL-CAPS identifier that is USED but never DECLARED anywhere in the file or in what
13//   it imports. nx_cc compiles these silently (seq1012, sev 9) and resolves them to whatever is to hand:
14//   first a wild pointer, then -- after unrelated code moved the frame -- the caller's output buffer, so
15//   the program ran and wrote WRONG DATA. A typo that does not fail the build is worse than one that does.
16//
17// HONEST SCOPE, stated rather than implied: L6 covers CONSTANT-STYLE names only ([A-Z][A-Z0-9_]+). A
18// mistyped lowercase function or variable is NOT covered yet. That is a real limit, and it is written here
19// so nobody reads a clean run as more assurance than it is. Constant-style is where the failure actually
20// happened, and it is the subset that can be detected without resolving the whole language.
21//
22// Declarations are gathered from the target AND its transitive imports, because an identifier arriving from
23// an import is not undefined -- a checker that cannot see through imports reports noise, and a checker that
24// reports noise gets switched off.
25// license_tier: ORIGINAL  expect_exit: 0
26import "nx_syscalls.nx"
27
28const LX_SRC:     i64 = 2097152
29const LX_MAXDECL: i64 = 4096
30const LX_MAXIMP:  i64 = 24
31const LX_NAME:    i64 = 64
32const LX_ROOTS:   i64 = 3
33const LX_PATH:    i64 = 512
34
35func lx_w(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
36func lx_n(v: i64) -> i64 {
  let bb: *u8=sys_mmap(28); var m: i64=v
  if m<0 { m=0-m; sys_write(1,"-" as *u8,1) }
  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 { bb[i]=t[k-1-i]; i=i+1 }
  sys_write(1,bb,k); return 0
45}
46func lx_slen(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} return n }
47func lx_eq(a: *u8, b: *u8) -> i64 {
  var i: i64=0
  while 1==1 {
      if a[i]!=b[i] { return 0 }
      if a[i]==(0 as u8) { return 1 }
      i=i+1
  }
  return 0
55}
56func lx_root(i: i64) -> *u8 {
  if i==0 { return "./runtime/_hdl_build/" as *u8 }
  if i==1 { return "./runtime/" as *u8 }
  return "./" as *u8
60}
61func lx_read(path: *u8, buf: *u8, cap: i64) -> i64 {
  let fd: i64 = sys_openat_rd(path)
  if fd<0 { return 0 }
  var total: i64=0
  while total<cap {
      let r: i64 = sys_read(fd, (((buf as i64)+total) as *u8), cap-total)
      if r<=0 { break }
      total=total+r
  }
  sys_close(fd)
  return total
72}
73// read a bare filename from whichever known source root holds it
74func lx_read_any(name: *u8, buf: *u8, cap: i64, scratch: *u8) -> i64 {
  var r: i64=0
  while r<LX_ROOTS {
      var o: i64=0
      let pre: *u8 = lx_root(r)
      var k: i64=0
      while pre[k]!=(0 as u8) { scratch[o]=pre[k]; o=o+1; k=k+1 }
      k=0
      while name[k]!=(0 as u8) { scratch[o]=name[k]; o=o+1; k=k+1 }
      scratch[o]=0 as u8
      let got: i64 = lx_read(scratch, buf, cap)
      if got>0 { return got }
      r=r+1
  }
  return 0
89}
90func lx_is_upper(c: i64) -> i64 { if c>=65 { if c<=90 { return 1 } } return 0 }
91func lx_is_idchar(c: i64) -> i64 {
  if c>=65 { if c<=90 { return 1 } }
  if c>=97 { if c<=122 { return 1 } }
  if c>=48 { if c<=57 { return 1 } }
  if c==95 { return 1 }
  return 0
97}
98// does buf match `word` at position i, with a non-identifier char before it?
99func lx_kw_at(b: *u8, n: i64, i: i64, word: *u8) -> i64 {
  let wl: i64 = lx_slen(word)
  if i+wl > n { return 0 }
  if i>0 { if lx_is_idchar(b[i-1] as i64)==1 { return 0 } }
  var k: i64=0
  while k<wl { if b[i+k]!=word[k] { return 0 } k=k+1 }
  return 1
106}
107// record a declared name (deduped)
108func lx_add_decl(names: *u8, cnt: *i64, nm: *u8) -> i64 {
  var j: i64=0
  while j<cnt[0] {
      if lx_eq((((names as i64)+j*LX_NAME) as *u8), nm)==1 { return 0 }
      j=j+1
  }
  if cnt[0] >= LX_MAXDECL { return 0-1 }
  let dst: *u8 = (((names as i64)+cnt[0]*LX_NAME) as *u8)
  var k: i64=0
  while nm[k]!=(0 as u8) { if k<LX_NAME-1 { dst[k]=nm[k] } k=k+1 }
  if k>LX_NAME-1 { k=LX_NAME-1 }
  dst[k]=0 as u8
  cnt[0]=cnt[0]+1
  return 1
122}
123// copy the identifier starting at i into out; returns its length
124func lx_take_ident(b: *u8, n: i64, i: i64, out: *u8) -> i64 {
  var k: i64=0
  while i+k<n {
      if lx_is_idchar(b[i+k] as i64)==0 { break }
      if k<LX_NAME-1 { out[k]=b[i+k] }
      k=k+1
  }
  var t: i64=k
  if t>LX_NAME-1 { t=LX_NAME-1 }
  out[t]=0 as u8
  return k
135}
136// harvest every declaration in one buffer: const/func/let/var names + func parameter names
137func lx_harvest(b: *u8, n: i64, names: *u8, cnt: *i64) -> i64 {
  let nm: *u8 = sys_mmap(LX_NAME)
  var i: i64=0
  while i<n {
      var adv: i64=0
      if lx_kw_at(b,n,i,"const " as *u8)==1 { adv=6 }
      if lx_kw_at(b,n,i,"func " as *u8)==1 { adv=5 }
      if lx_kw_at(b,n,i,"let " as *u8)==1 { adv=4 }
      if lx_kw_at(b,n,i,"var " as *u8)==1 { adv=4 }
      if adv>0 {
          var j: i64=i+adv
          while j<n { if b[j]!=(32 as u8) { break } j=j+1 }
          let l: i64 = lx_take_ident(b,n,j,nm)
          if l>0 { lx_add_decl(names,cnt,nm) }
          // a func header also DECLARES its parameters: walk to '(' and take each name before ':'
          if adv==5 {
              var p: i64=j+l
              while p<n { if b[p]==(40 as u8) { break } if b[p]==(10 as u8) { break } p=p+1 }
              if p<n { if b[p]==(40 as u8) {
                  var depth: i64=1
                  p=p+1
                  var want: i64=1
                  while p<n {
                      if depth<=0 { break }
                      let c: i64 = b[p] as i64
                      if c==40 { depth=depth+1 }
                      if c==41 { depth=depth-1 }
                      if c==44 { want=1 }
                      if want==1 { if lx_is_idchar(c)==1 {
                          let pl: i64 = lx_take_ident(b,n,p,nm)
                          if pl>0 { lx_add_decl(names,cnt,nm); p=p+pl-1 }
                          want=0
                      } }
                      p=p+1
                  }
              } }
          }
          i=i+adv
      } else { i=i+1 }
  }
  return cnt[0]
178}
179// pull each `import "name.nx"` into the import list
180func lx_imports(b: *u8, n: i64, imps: *u8, icnt: *i64) -> i64 {
  var i: i64=0
  while i<n {
      if lx_kw_at(b,n,i,"import " as *u8)==1 {
          var j: i64=i+7
          while j<n { if b[j]==(34 as u8) { break } j=j+1 }
          if j<n {
              j=j+1
              var k: i64=0
              let dst: *u8 = (((imps as i64)+icnt[0]*LX_NAME) as *u8)
              while j+k<n {
                  if b[j+k]==(34 as u8) { break }
                  if k<LX_NAME-1 { dst[k]=b[j+k] }
                  k=k+1
              }
              var t: i64=k
              if t>LX_NAME-1 { t=LX_NAME-1 }
              dst[t]=0 as u8
              if icnt[0] < LX_MAXIMP-1 { icnt[0]=icnt[0]+1 }
          }
          i=i+7
      } else { i=i+1 }
  }
  return icnt[0]
204}
205
206func main(argc: i64, argv: *i64) -> i64 {
  if argc<2 { lx_w("usage: nx_lang_lint_ext <source.nx>\n" as *u8); sys_exit(2); return 2 }
  let path: *u8 = argv[1] as *u8
  lx_w("=== nx_lang_lint_ext -- L5 disguised-empty-literal + L6 undeclared constant ===\n" as *u8)
210
  let b: *u8 = sys_mmap(LX_SRC)
  let n: i64 = lx_read(path, b, LX_SRC-16)
  if n<=0 { lx_w(" source unreadable\n" as *u8); sys_exit(2); return 2 }
214
  let names: *u8 = sys_mmap(LX_NAME*LX_MAXDECL)
  let cnt: *i64 = sys_mmap(16) as *i64
  cnt[0]=0
  lx_harvest(b, n, names, cnt)
219
  // transitive-ish: the target's imports, and THEIR imports, one level deeper. Bounded and stated.
  let imps: *u8 = sys_mmap(LX_NAME*LX_MAXIMP)
  let icnt: *i64 = sys_mmap(16) as *i64
  icnt[0]=0
  lx_imports(b, n, imps, icnt)
  let scratch: *u8 = sys_mmap(LX_PATH)
  let ib: *u8 = sys_mmap(LX_SRC)
  var resolved: i64=0
  var q: i64=0
  while q<icnt[0] {
      let nm: *u8 = (((imps as i64)+q*LX_NAME) as *u8)
      let got: i64 = lx_read_any(nm, ib, LX_SRC-16, scratch)
      if got>0 {
          resolved=resolved+1
          lx_harvest(ib, got, names, cnt)
          lx_imports(ib, got, imps, icnt)      // grows the queue in place: one more level, still bounded
      }
      q=q+1
  }
239
  lx_w("  declarations in scope=" as *u8); lx_n(cnt[0])
  lx_w("  imports seen=" as *u8); lx_n(icnt[0])
  lx_w("  imports resolved=" as *u8); lx_n(resolved); lx_w("\n" as *u8)
243
  // ---- scan the target for the two classes ----
  let nm: *u8 = sys_mmap(LX_NAME)
  var hits5: i64=0
  var hits6: i64=0
  var line: i64=1
  var i: i64=0
  var in_str: i64=0
  var in_com: i64=0
  while i<n {
      let c: i64 = b[i] as i64
      if c==10 { line=line+1; in_com=0 }
      // COMMENTS ARE PROSE, NOT CODE. The first run flagged 35 "undeclared constants" that were words
      // like MUTATES and WITH inside my own comments -- exactly the noise this file's header warns makes
      // a checker get switched off. Skip from // to end of line.
      if in_str==0 { if c==47 { if i+1<n { if b[i+1]==(47 as u8) { in_com=1 } } } }
      // L5: a quote, then \x00, then a quote -> a zero-length literal wearing an escape
      if c==34 { if in_com==0 {
          if i+5<n {
              if b[i+1]==(92 as u8) { if b[i+2]==(120 as u8) { if b[i+3]==(48 as u8) { if b[i+4]==(48 as u8) { if b[i+5]==(34 as u8) {
                  lx_w("  L5 EMPTYESC line=" as *u8); lx_n(line)
                  lx_w("  \x22\\x00\x22 is a ZERO-LENGTH literal in disguise -- same defect as \x22\x22 (seq907)\n" as *u8)
                  hits5=hits5+1
              } } } } }
          }
          in_str = 1 - in_str
      } }
      // L6: an ALL-CAPS identifier used outside a string AND outside a comment
      if in_str==0 { if in_com==0 {
          if lx_is_upper(c)==1 {
              var prev_ok: i64=1
              if i>0 { if lx_is_idchar(b[i-1] as i64)==1 { prev_ok=0 } }
              if prev_ok==1 {
                  let l: i64 = lx_take_ident(b,n,i,nm)
                  if l>=3 {
                      var all_const: i64=1
                      var k: i64=0
                      while k<l {
                          let cc: i64 = b[i+k] as i64
                          if lx_is_upper(cc)==0 { if cc!=95 { if cc<48 { all_const=0 } else { if cc>57 { all_const=0 } } } }
                          k=k+1
                      }
                      if all_const==1 {
                          var found: i64=0
                          var j: i64=0
                          while j<cnt[0] {
                              if lx_eq((((names as i64)+j*LX_NAME) as *u8), nm)==1 { found=1; j=cnt[0] } else { j=j+1 }
                          }
                          if found==0 {
                              lx_w("  L6 UNDEFCONST line=" as *u8); lx_n(line)
                              lx_w("  " as *u8); lx_w(nm)
                              lx_w(" is USED but DECLARED NOWHERE -- nx_cc will compile this silently (seq1012)\n" as *u8)
                              hits6=hits6+1
                          }
                      }
                      i=i+l-1
                  }
              }
          }
      } }
      i=i+1
  }
305
  lx_w("\n  L5 disguised-empty-literal hits=" as *u8); lx_n(hits5)
  lx_w("   L6 undeclared-constant hits=" as *u8); lx_n(hits6); lx_w("\n" as *u8)
  lx_w("  SCOPE (stated, not implied): L6 sees CONSTANT-STYLE names only. A mistyped lowercase function\n" as *u8)
  lx_w("  or variable is NOT covered -- a clean run here is not a clean bill of health.\n" as *u8)
  if hits5+hits6 == 0 {
      lx_w("VERDICT: verdict=GREEN (neither landmine class present)\n" as *u8)
      sys_exit(0)
  }
  lx_w("VERDICT: LANDMINES\n" as *u8)
  sys_exit(1)
  return 1
317}
nx_lang_lint_ext.nx source

`nx_lang_lint_ext.nx` source
