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

↩ module page · 1013 lines · 46704 B
1// nx_glsl_tok_lib.nx -- THE SHADER TOKEN RULER (gameengine S12c accept-rule instrument, 2026-09-05).
2//
3// WHY: the cast port's pre-declared accept rule says the IR-emitted GLSL must match the hand-written MVS/MFS at ZERO
4// normalised-token distance before its WGSL twin is trusted. A byte diff cannot be that ruler (the hand shader has
5// formatting freedom, comments, `.5` for `0.5`, `br/=nr` for `br=br/nr`) and a string-run ruler cannot either (it
6// has no grammar). This lib is ONE tokenizer + ONE canonicaliser + ONE compound-assignment expander + ONE differ,
7// composed in-process by nx_glsl_tokdiff (the program) and nx_glsl_tokdiff_gate (planted fixtures, both directions).
8// NORMALISATIONS, each named: whitespace and comments dropped; numeric literals canonicalised (`.5`->`0.5`, `1.`->`1.0`,
9// trailing f/F/u/U dropped); `x op= y` expanded to `x = x op y` for op in + - * / where x is an lvalue of the grammar
10// ident ( '.' ident | '[' ... ']' )* -- any other shape is left literal and COUNTED (expand_refused=), never guessed.
11// Everything else must match token for token: a renamed identifier, a moved parenthesis, a changed constant is a DIFF,
12// and the first differing token is named with both spellings.
13// Token = 3 words (start, len, kind); kinds 1 ident, 2 number, 3 operator/punct. Buffers are sized from the input
14// (one token cannot be shorter than one byte, so 3*n words is a bound that cannot overflow -- no guessed cap).
15// license_tier: ORIGINAL   No hw writes (Rule 26).
16import "nx_syscalls.nx"
17
18const GT_K_IDENT: i64 = 1
19const GT_K_NUM: i64 = 2
20const GT_K_OP: i64 = 3
21const GT_TW: i64 = 3
22const GT_R_TOKA: i64 = 0
23const GT_R_TOKB: i64 = 1
24const GT_R_EXPA: i64 = 2
25const GT_R_EXPB: i64 = 3
26const GT_R_FIRSTDIFF: i64 = 4
27const GT_R_VERDICT: i64 = 5
28const GT_R_REFUSED: i64 = 6
29const GT_R_SLOTS: i64 = 20
30const GT_V_IDENTICAL: i64 = 0
31const GT_V_DIFFERS: i64 = 1
32const GT_V_UNREADABLE: i64 = 2
33const GT_CANON_CAP: i64 = 512
34const GT_NUMBUF: i64 = 32
35const C_TAB: i64 = 9
36const C_NL: i64 = 10
37const C_CR: i64 = 13
38const C_SP: i64 = 32
39const C_BANG: i64 = 33
40const C_AMP: i64 = 38
41const C_LPAR: i64 = 40
42const C_RPAR: i64 = 41
43const C_STAR: i64 = 42
44const C_PLUS: i64 = 43
45const C_MINUS: i64 = 45
46const C_DOT: i64 = 46
47const C_SLASH: i64 = 47
48const C_0: i64 = 48
49const C_9: i64 = 57
50const C_LT: i64 = 60
51const C_EQ: i64 = 61
52const C_GT: i64 = 62
53const C_A: i64 = 65
54const C_E: i64 = 69
55const C_F: i64 = 70
56const C_U: i64 = 85
57const C_Z: i64 = 90
58const C_LBR: i64 = 91
59const C_RBR: i64 = 93
60const C_USCORE: i64 = 95
61const C_a: i64 = 97
62const C_e: i64 = 101
63const C_f: i64 = 102
64const C_u: i64 = 117
65const C_z: i64 = 122
66const C_BAR: i64 = 124
67
68func gt_slen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
69func gt_fputs(fd: i64, s: *u8) -> i64 { sys_write(fd, s, gt_slen(s)); return 0 }
70func gt_fputn(fd: i64, v: i64) -> i64 {
  let t: *u8 = sys_mmap(GT_NUMBUF)
  let o: *u8 = sys_mmap(GT_NUMBUF)
  var m: i64 = v
  if m < 0 { sys_write(fd, "-" as *u8, 1); m = 0 - m }
  var k: i64 = 0
  if m == 0 { t[0] = C_0 as u8; k = 1 }
  while m > 0 { t[k] = (C_0 + (m % 10)) as u8; m = m / 10; k = k + 1 }
  var i: i64 = 0
  while i < k { o[i] = t[k - 1 - i]; i = i + 1 }
  sys_write(fd, o, k)
  return 0
82}
83func gt_isalpha(c: i64) -> i64 {
  if c >= C_A { if c <= C_Z { return 1 } }
  if c >= C_a { if c <= C_z { return 1 } }
  if c == C_USCORE { return 1 }
  return 0
88}
89func gt_isdigit(c: i64) -> i64 { if c >= C_0 { if c <= C_9 { return 1 } } return 0 }
90func gt_isspace(c: i64) -> i64 {
  if c == C_SP { return 1 }
  if c == C_NL { return 1 }
  if c == C_TAB { return 1 }
  if c == C_CR { return 1 }
  return 0
96}
97// is the two-char sequence at i one operator? (<< >> <= >= == != && || += -= *= /= ++ --)
98func gt_op2(a: i64, b: i64) -> i64 {
  if b == C_EQ {
      if a == C_LT { return 1 }
      if a == C_GT { return 1 }
      if a == C_EQ { return 1 }
      if a == C_BANG { return 1 }
      if a == C_PLUS { return 1 }
      if a == C_MINUS { return 1 }
      if a == C_STAR { return 1 }
      if a == C_SLASH { return 1 }
  }
  if a == C_LT { if b == C_LT { return 1 } }
  if a == C_GT { if b == C_GT { return 1 } }
  if a == C_AMP { if b == C_AMP { return 1 } }
  if a == C_BAR { if b == C_BAR { return 1 } }
  if a == C_PLUS { if b == C_PLUS { return 1 } }
  if a == C_MINUS { if b == C_MINUS { return 1 } }
  return 0
116}
117
118// tokenize src[0,n) into toks (3 words each). Returns the token count. toks must hold 3*n words (bound, not a guess).
119func gt_tokenize(src: *u8, n: i64, toks: *i64) -> i64 {
  var i: i64 = 0
  var k: i64 = 0
  while i < n {
      let c: i64 = src[i] as i64
      var done: i64 = 0
      if gt_isspace(c) == 1 { i = i + 1; done = 1 }
      if done == 0 { if c == C_SLASH { if i + 1 < n {
          let c2: i64 = src[i + 1] as i64
          if c2 == C_SLASH {
              var go: i64 = 1
              while go == 1 { if i >= n { go = 0 } else { if (src[i] as i64) == C_NL { go = 0 } else { i = i + 1 } } }
              done = 1
          }
          if done == 0 { if c2 == C_STAR {
              i = i + 2
              var go2: i64 = 1
              while go2 == 1 {
                  if i + 1 >= n { i = n; go2 = 0 } else {
                      if (src[i] as i64) == C_STAR { if (src[i + 1] as i64) == C_SLASH { i = i + 2; go2 = 0 } else { i = i + 1 } } else { i = i + 1 }
                  }
              }
              done = 1
          } }
      } } }
      if done == 0 { if gt_isalpha(c) == 1 {
          let s: i64 = i
          var go3: i64 = 1
          while go3 == 1 {
              if i >= n { go3 = 0 } else {
                  let cc: i64 = src[i] as i64
                  if gt_isalpha(cc) == 1 { i = i + 1 } else { if gt_isdigit(cc) == 1 { i = i + 1 } else { go3 = 0 } }
              }
          }
          toks[k * GT_TW] = s; toks[k * GT_TW + 1] = i - s; toks[k * GT_TW + 2] = GT_K_IDENT; k = k + 1
          done = 1
      } }
      if done == 0 {
          var isnum: i64 = gt_isdigit(c)
          if isnum == 0 { if c == C_DOT { if i + 1 < n { if gt_isdigit(src[i + 1] as i64) == 1 { isnum = 1 } } } }
          if isnum == 1 {
              let s: i64 = i
              var go4: i64 = 1
              while go4 == 1 {
                  if i >= n { go4 = 0 } else {
                      let cc: i64 = src[i] as i64
                      if gt_isdigit(cc) == 1 { i = i + 1 } else { if cc == C_DOT { i = i + 1 } else {
                          if cc == C_e { i = i + 1; if i < n { if (src[i] as i64) == C_MINUS { i = i + 1 } else { if (src[i] as i64) == C_PLUS { i = i + 1 } } } } else {
                          if cc == C_E { i = i + 1; if i < n { if (src[i] as i64) == C_MINUS { i = i + 1 } else { if (src[i] as i64) == C_PLUS { i = i + 1 } } } } else {
                          if cc == C_f { i = i + 1 } else { if cc == C_F { i = i + 1 } else { if cc == C_u { i = i + 1 } else { if cc == C_U { i = i + 1 } else { go4 = 0 } } } } } } } }
                  }
              }
              toks[k * GT_TW] = s; toks[k * GT_TW + 1] = i - s; toks[k * GT_TW + 2] = GT_K_NUM; k = k + 1
              done = 1
          }
      }
      if done == 0 {
          var ln: i64 = 1
          if i + 1 < n { if gt_op2(c, src[i + 1] as i64) == 1 { ln = 2 } }
          toks[k * GT_TW] = i; toks[k * GT_TW + 1] = ln; toks[k * GT_TW + 2] = GT_K_OP; k = k + 1
          i = i + ln
      }
  }
  return k
183}
184
185// canonical spelling of token t of src into out; returns its length. Numbers: strip f/F/u/U, `.5`->`0.5`, `1.`->`1.0`.
186func gt_canon(src: *u8, toks: *i64, t: i64, out: *u8, cap: i64) -> i64 {
  let s: i64 = toks[t * GT_TW]
  let ln: i64 = toks[t * GT_TW + 1]
  let kd: i64 = toks[t * GT_TW + 2]
  var o: i64 = 0
  if kd != GT_K_NUM {
      var i: i64 = 0
      while i < ln { if o < cap { out[o] = src[s + i]; o = o + 1 } i = i + 1 }
      return o
  }
  var e: i64 = ln
  var go: i64 = 1
  while go == 1 {
      if e <= 0 { go = 0 } else {
          let cc: i64 = src[s + e - 1] as i64
          if cc == C_f { e = e - 1 } else { if cc == C_F { e = e - 1 } else { if cc == C_u { e = e - 1 } else { if cc == C_U { e = e - 1 } else { go = 0 } } } }
      }
  }
  if (src[s] as i64) == C_DOT { out[o] = C_0 as u8; o = o + 1 }
  var j: i64 = 0
  while j < e { if o < cap { out[o] = src[s + j]; o = o + 1 } j = j + 1 }
  if e > 0 { if (src[s + e - 1] as i64) == C_DOT { if o < cap { out[o] = C_0 as u8; o = o + 1 } } }
  return o
209}
210
211// is token t of src the op `X=` for X in + - * / (never == <= >= !=)?
212func gt_is_compound(src: *u8, toks: *i64, t: i64) -> i64 {
  if toks[t * GT_TW + 2] != GT_K_OP { return 0 }
  if toks[t * GT_TW + 1] != 2 { return 0 }
  let s: i64 = toks[t * GT_TW]
  if (src[s + 1] as i64) != C_EQ { return 0 }
  let a: i64 = src[s] as i64
  if a == C_PLUS { return 1 }
  if a == C_MINUS { return 1 }
  if a == C_STAR { return 1 }
  if a == C_SLASH { return 1 }
  return 0
223}
224func gt_tok_is(src: *u8, toks: *i64, t: i64, ch: i64) -> i64 {
  if toks[t * GT_TW + 2] != GT_K_OP { return 0 }
  if toks[t * GT_TW + 1] != 1 { return 0 }
  if (src[toks[t * GT_TW]] as i64) == ch { return 1 }
  return 0
229}
230// the start index of the lvalue ending at token `last` (an ident, or `]` closing an index) under the grammar
231// ident ( '.' ident | '[' ... ']' )*; -1 when the shape is not an lvalue.
232func gt_lvalue_start(src: *u8, toks: *i64, last: i64) -> i64 {
  var j: i64 = last
  var go: i64 = 1
  while go == 1 {
      if j < 0 { return 0 - 1 }
      if gt_tok_is(src, toks, j, C_RBR) == 1 {
          var depth: i64 = 0
          var found: i64 = 0 - 1
          var q: i64 = j
          var go2: i64 = 1
          while go2 == 1 {
              if q < 0 { go2 = 0 } else {
                  if gt_tok_is(src, toks, q, C_RBR) == 1 { depth = depth + 1 }
                  if gt_tok_is(src, toks, q, C_LBR) == 1 { depth = depth - 1; if depth == 0 { found = q; go2 = 0 } }
                  if go2 == 1 { q = q - 1 }
              }
          }
          if found < 1 { return 0 - 1 }
          j = found - 1
      }
      if j < 0 { return 0 - 1 }
      if toks[j * GT_TW + 2] != GT_K_IDENT { return 0 - 1 }
      if j >= 1 { if gt_tok_is(src, toks, j - 1, C_DOT) == 1 { j = j - 2 } else { go = 0 } } else { go = 0 }
  }
  return j
257}
258
259// expand compound assignments: xt receives the rewritten token list (3 words each; a synthesised `=` or op points INTO
260// the compound token's own bytes, so every token still names a byte range of src). Returns the new count; box[0]
261// receives the number of compound tokens whose lvalue shape was refused (left literal). xt must hold 3*(3*k) words.
262func gt_expand(src: *u8, toks: *i64, k: i64, xt: *i64, box: *i64) -> i64 {
  var t: i64 = 0
  var o: i64 = 0
  box[0] = 0
  while t < k {
      var handled: i64 = 0
      if gt_is_compound(src, toks, t) == 1 { if o >= 1 {
          let ls: i64 = gt_lvalue_start(src, xt, o - 1)
          if ls >= 0 {
              let cs: i64 = toks[t * GT_TW]
              xt[o * GT_TW] = cs + 1; xt[o * GT_TW + 1] = 1; xt[o * GT_TW + 2] = GT_K_OP; o = o + 1
              var c: i64 = ls
              let hi: i64 = o - 1
              while c < hi { xt[o * GT_TW] = xt[c * GT_TW]; xt[o * GT_TW + 1] = xt[c * GT_TW + 1]; xt[o * GT_TW + 2] = xt[c * GT_TW + 2]; o = o + 1; c = c + 1 }
              xt[o * GT_TW] = cs; xt[o * GT_TW + 1] = 1; xt[o * GT_TW + 2] = GT_K_OP; o = o + 1
              handled = 1
          } else { box[0] = box[0] + 1 }
      } }
      if handled == 0 { xt[o * GT_TW] = toks[t * GT_TW]; xt[o * GT_TW + 1] = toks[t * GT_TW + 1]; xt[o * GT_TW + 2] = toks[t * GT_TW + 2]; o = o + 1 }
      t = t + 1
  }
  return o
284}
285
286// the ruler: fills r (GT_R_SLOTS words) and returns the verdict code.
287func gt_diff(a: *u8, na: i64, b: *u8, nb: i64, r: *i64) -> i64 {
  let ta: *i64 = sys_mmap(GT_TW * 8 * (na + 1)) as *i64
  let tb: *i64 = sys_mmap(GT_TW * 8 * (nb + 1)) as *i64
  let ka: i64 = gt_tokenize(a, na, ta)
  let kb: i64 = gt_tokenize(b, nb, tb)
  let xa: *i64 = sys_mmap(GT_TW * 8 * (3 * ka + 3)) as *i64
  let xb: *i64 = sys_mmap(GT_TW * 8 * (3 * kb + 3)) as *i64
  let boxa: *i64 = sys_mmap(16) as *i64
  let boxb: *i64 = sys_mmap(16) as *i64
  let ea: i64 = gt_expand(a, ta, ka, xa, boxa)
  let eb: i64 = gt_expand(b, tb, kb, xb, boxb)
  r[GT_R_TOKA] = ka; r[GT_R_TOKB] = kb; r[GT_R_EXPA] = ea; r[GT_R_EXPB] = eb
  r[GT_R_REFUSED] = boxa[0] + boxb[0]
  r[GT_R_FIRSTDIFF] = 0 - 1
  let ca: *u8 = sys_mmap(GT_CANON_CAP)
  let cb: *u8 = sys_mmap(GT_CANON_CAP)
  var i: i64 = 0
  var lim: i64 = ea
  if eb < lim { lim = eb }
  var go: i64 = 1
  while go == 1 {
      if i >= lim { go = 0 } else {
          let la: i64 = gt_canon(a, xa, i, ca, GT_CANON_CAP)
          let lb: i64 = gt_canon(b, xb, i, cb, GT_CANON_CAP)
          var same: i64 = 1
          if la != lb { same = 0 } else {
              var q: i64 = 0
              while q < la { if ca[q] != cb[q] { same = 0; q = la } else { q = q + 1 } }
          }
          if same == 0 { r[GT_R_FIRSTDIFF] = i; go = 0 } else { i = i + 1 }
      }
  }
  if r[GT_R_FIRSTDIFF] < 0 { if ea != eb { r[GT_R_FIRSTDIFF] = lim } }
  if r[GT_R_FIRSTDIFF] < 0 { r[GT_R_VERDICT] = GT_V_IDENTICAL } else { r[GT_R_VERDICT] = GT_V_DIFFERS }
  return r[GT_R_VERDICT]
322}
323
324// print the canonical token i of the EXPANDED stream of src (re-derived; the report never trusts a cached string)
325func gt_put_expanded_tok(fd: i64, src: *u8, n: i64, i: i64) -> i64 {
  let t: *i64 = sys_mmap(GT_TW * 8 * (n + 1)) as *i64
  let k: i64 = gt_tokenize(src, n, t)
  let x: *i64 = sys_mmap(GT_TW * 8 * (3 * k + 3)) as *i64
  let bx: *i64 = sys_mmap(16) as *i64
  let e: i64 = gt_expand(src, t, k, x, bx)
  if i < 0 { gt_fputs(fd, "-" as *u8); return 0 }
  if i >= e { gt_fputs(fd, "<end>" as *u8); return 0 }
  let c: *u8 = sys_mmap(GT_CANON_CAP)
  let l: i64 = gt_canon(src, x, i, c, GT_CANON_CAP)
  sys_write(fd, c, l)
  return 0
337}
338func gt_report(fd: i64, a: *u8, na: i64, b: *u8, nb: i64, r: *i64) -> i64 {
  gt_fputs(fd, "tokens_a=" as *u8); gt_fputn(fd, r[GT_R_TOKA])
  gt_fputs(fd, " tokens_b=" as *u8); gt_fputn(fd, r[GT_R_TOKB])
  gt_fputs(fd, " expanded_a=" as *u8); gt_fputn(fd, r[GT_R_EXPA])
  gt_fputs(fd, " expanded_b=" as *u8); gt_fputn(fd, r[GT_R_EXPB])
  gt_fputs(fd, " expand_refused=" as *u8); gt_fputn(fd, r[GT_R_REFUSED])
  gt_fputs(fd, " first_diff=" as *u8); gt_fputn(fd, r[GT_R_FIRSTDIFF])
  if r[GT_R_FIRSTDIFF] >= 0 {
      gt_fputs(fd, " a_tok=" as *u8); gt_put_expanded_tok(fd, a, na, r[GT_R_FIRSTDIFF])
      gt_fputs(fd, " b_tok=" as *u8); gt_put_expanded_tok(fd, b, nb, r[GT_R_FIRSTDIFF])
  }
  gt_fputs(fd, "\n" as *u8)
  if r[GT_R_VERDICT] == GT_V_IDENTICAL { gt_fputs(fd, "verdict=IDENTICAL\n" as *u8) } else { gt_fputs(fd, "verdict=DIFFERS\n" as *u8) }
  return 0
352}
353
354// ---- S12c-2 (2026-09-05): THE CANONICAL FORM -- redundant parentheses, multi-declarators, brace-less branches, counted loops ----
355// WHY: the IR backends parenthesise EVERY binary, negation and select node ((a+b)*c is spelled ((a+b)*c), -x is (-x),
356// c?a:b is (c?a:b)), spell one declarator per statement, brace every branch and lower a counted loop to
357// init;while(true){if(until){break;}body;step;} -- while a person writes the minimal form. Token identity between the two
358// is therefore unreachable BY SPELLING while the programs are identical BY STRUCTURE. The honest ruler is structural: both
359// sides are parsed with the GLSL ES 3.00 precedence table into one expression tree per statement and RE-PRINTED in the
360// backend's own fully-parenthesised form, so a redundant parenthesis vanishes and a meaningful one survives ((a+b)*c and
361// a+b*c print differently because they ARE different). The emitters are untouched: a live shader's bytes never move for a
362// ruler's convenience, and the world shader's pinned hand text stays pinned.
363// NORMALISATIONS ADDED, each named and each bitten in the gate: (1) precedence re-parenthesisation of every expression;
364// (2) `T a=x,b=y;` -> `T a=x;T b=y;`; (3) a brace-less if/else/while body is braced and `else if` becomes `else{if ...}`;
365// (4) `for(init;cond;step)body` -> `init;while(true){if(not-cond){break;}body;step;}` with `i++`/`i--`/`++i` spelled
366// `i=(i+1)` / `i=(i-1)`; (5) not-of-a-comparison prints as the inverted comparison (`not-(a<b)` -> `(a>=b)`, six ops)
367// because the IR carries no unary not and its authors spell the inverted comparison -- the ONE semantic caveat of this
368// ruler: it identifies two forms that differ only on NaN, declared here rather than hidden. An input the grammar cannot
369// parse is REFUSED and the refusing token is named by byte offset and spelling (verdict UNREADABLE), never passed through.
370// GRAMMAR COVERED: literals, identifiers, calls/constructors/casts (an identifier followed by '('), [index], .member,
371// unary - and not, prefix/postfix ++ --, the binary table || && | ^ & == != < > <= >= << >> + - * / %, ?:, =, declarations
372// (T name[N]=expr with const/highp/mediump/lowp qualifiers), if/else, while, for, return, discard, break, continue, blocks;
373// module scope is copied token for token except that the right side of an `=` is canonicalised.
374// SHAPE: ONE recursive-descent function per layer that only ever calls ITSELF (gp_parse over modes, gp_stmt over wrap), so
375// no function is referenced before its definition and there is exactly one parser.
376const GN_KIND: i64 = 0
377const GN_TOK: i64 = 1
378const GN_A: i64 = 2
379const GN_B: i64 = 3
380const GN_C: i64 = 4
381const GN_NEXT: i64 = 5
382const GN_SLOTS: i64 = 6
383const GN_LEAF: i64 = 1
384const GN_BIN: i64 = 2
385const GN_UN: i64 = 3
386const GN_TERN: i64 = 4
387const GN_CALL: i64 = 5
388const GN_INDEX: i64 = 6
389const GN_SWZ: i64 = 7
390const GN_ASSIGN: i64 = 8
391const GN_INCDEC: i64 = 9
392const GP_POS: i64 = 0
393const GP_NTOK: i64 = 1
394const GP_OUT: i64 = 2
395const GP_ERR: i64 = 3
396const GP_NCOUNT: i64 = 4
397const GP_SRC: i64 = 5
398const GP_TOKS: i64 = 6
399const GP_NODES: i64 = 7
400const GP_OUTBUF: i64 = 8
401const GP_CAP: i64 = 9
402const GP_OVER: i64 = 10
403const GP_TMP: i64 = 11
404const GP_SLOTS: i64 = 12
405const GP_M_ASSIGN: i64 = 1
406const GP_M_TERN: i64 = 2
407const GP_M_BIN: i64 = 3
408const GP_M_UNARY: i64 = 4
409const GP_P_LOR: i64 = 1
410const GP_P_LAND: i64 = 2
411const GP_P_BOR: i64 = 3
412const GP_P_BXOR: i64 = 4
413const GP_P_BAND: i64 = 5
414const GP_P_EQ: i64 = 6
415const GP_P_REL: i64 = 7
416const GP_P_SHIFT: i64 = 8
417const GP_P_ADD: i64 = 9
418const GP_P_MUL: i64 = 10
419const GP_INV_NONE: i64 = 0
420const GP_INV_GE: i64 = 1
421const GP_INV_LE: i64 = 2
422const GP_INV_GT: i64 = 3
423const GP_INV_LT: i64 = 4
424const GP_INV_NE: i64 = 5
425const GP_INV_EQ: i64 = 6
426const C_QMARK: i64 = 63
427const C_COLON: i64 = 58
428const C_SEMI: i64 = 59
429const C_COMMA: i64 = 44
430const C_LBRACE: i64 = 123
431const C_RBRACE: i64 = 125
432const C_CARET: i64 = 94
433const C_PCT: i64 = 37
434const C_1: i64 = 49
435// canonical text bound, derived: a token of one byte prints as at most "( x ) " (6 bytes) under wrapping and a `for`
436// lowering adds a fixed head, so MULT bytes per source byte plus HEAD is a bound, not a guess
437const GT_CANON_OUT_MULT: i64 = 8
438const GT_CANON_OUT_HEAD: i64 = 4096
439// result slots past the incumbent's 7 (GT_R_SLOTS is 20, declared at the head of this file)
440const GT_R_CANA: i64 = 7
441const GT_R_CANB: i64 = 8
442const GT_R_ERRA: i64 = 9
443const GT_R_ERRB: i64 = 10
444const GT_R_ERRLA: i64 = 11
445const GT_R_ERRLB: i64 = 12
446const GT_R_CAPTR_A: i64 = 13
447const GT_R_CALEN_A: i64 = 14
448const GT_R_CAPTR_B: i64 = 15
449const GT_R_CALEN_B: i64 = 16
450const GT_R_SRCA: i64 = 17
451const GT_R_SRCB: i64 = 18
452const GT_R_OVER: i64 = 19
453
454func gp_tk(ps: *i64, t: i64, w: i64) -> i64 { let tk: *i64 = ps[GP_TOKS] as *i64; return tk[t * GT_TW + w] }
455func gp_byte(ps: *i64, t: i64, i: i64) -> i64 { let s: *u8 = ps[GP_SRC] as *u8; return s[gp_tk(ps, t, 0) + i] as i64 }
456func gp_kind(ps: *i64, t: i64) -> i64 {
  if t < 0 { return 0 }
  if t >= ps[GP_NTOK] { return 0 }
  return gp_tk(ps, t, 2)
460}
461func gp_is1(ps: *i64, t: i64, ch: i64) -> i64 {
  if gp_kind(ps, t) != GT_K_OP { return 0 }
  if gp_tk(ps, t, 1) != 1 { return 0 }
  if gp_byte(ps, t, 0) == ch { return 1 }
  return 0
466}
467func gp_is2(ps: *i64, t: i64, a: i64, b: i64) -> i64 {
  if gp_kind(ps, t) != GT_K_OP { return 0 }
  if gp_tk(ps, t, 1) != 2 { return 0 }
  if gp_byte(ps, t, 0) != a { return 0 }
  if gp_byte(ps, t, 1) == b { return 1 }
  return 0
473}
474func gp_isword(ps: *i64, t: i64, w: *u8) -> i64 {
  if gp_kind(ps, t) != GT_K_IDENT { return 0 }
  let ln: i64 = gp_tk(ps, t, 1)
  if gt_slen(w) != ln { return 0 }
  var i: i64 = 0
  while i < ln { if gp_byte(ps, t, i) != (w[i] as i64) { return 0 } i = i + 1 }
  return 1
481}
482func gp_fail(ps: *i64, t: i64) -> i64 { if ps[GP_ERR] < 0 { ps[GP_ERR] = t } return 0 }
483func gp_n(ps: *i64, id: i64, w: i64) -> i64 { let nd: *i64 = ps[GP_NODES] as *i64; return nd[id * GN_SLOTS + w] }
484func gp_nset(ps: *i64, id: i64, w: i64, v: i64) -> i64 { let nd: *i64 = ps[GP_NODES] as *i64; nd[id * GN_SLOTS + w] = v; return 0 }
485func gp_node(ps: *i64, kind: i64, tok: i64, a: i64, b: i64, c: i64) -> i64 {
  let id: i64 = ps[GP_NCOUNT]
  ps[GP_NCOUNT] = id + 1
  gp_nset(ps, id, GN_KIND, kind); gp_nset(ps, id, GN_TOK, tok); gp_nset(ps, id, GN_A, a); gp_nset(ps, id, GN_B, b); gp_nset(ps, id, GN_C, c); gp_nset(ps, id, GN_NEXT, 0)
  return id
490}
491func gp_putc(ps: *i64, ch: i64) -> i64 {
  if ps[GP_OUT] + 1 >= ps[GP_CAP] { ps[GP_OVER] = 1; return 0 }
  let o: *u8 = ps[GP_OUTBUF] as *u8
  o[ps[GP_OUT]] = ch as u8
  ps[GP_OUT] = ps[GP_OUT] + 1
  return 0
497}
498func gp_emit_c(ps: *i64, ch: i64) -> i64 { gp_putc(ps, ch); gp_putc(ps, C_SP); return 0 }
499func gp_emit_s(ps: *i64, s: *u8) -> i64 {
  var i: i64 = 0
  while s[i] != (0 as u8) { gp_putc(ps, s[i] as i64); i = i + 1 }
  gp_putc(ps, C_SP)
  return 0
504}
505// the canonical spelling of token t (numbers canonicalised by gt_canon), then one space so re-tokenising cannot merge tokens
506func gp_emit_tok(ps: *i64, t: i64) -> i64 {
  let tmp: *u8 = ps[GP_TMP] as *u8
  let l: i64 = gt_canon(ps[GP_SRC] as *u8, ps[GP_TOKS] as *i64, t, tmp, GT_CANON_CAP)
  var i: i64 = 0
  while i < l { gp_putc(ps, tmp[i] as i64); i = i + 1 }
  gp_putc(ps, C_SP)
  return 0
513}
514func gp_take(ps: *i64) -> i64 { ps[GP_POS] = ps[GP_POS] + 1; return 0 }
515// the one-char op ch at the cursor: emit + consume, or refuse there
516func gp_expect(ps: *i64, ch: i64) -> i64 {
  if gp_is1(ps, ps[GP_POS], ch) == 0 { return gp_fail(ps, ps[GP_POS]) }
  gp_emit_c(ps, ch); gp_take(ps)
  return 1
520}
521// the binary precedence of token t (GLSL ES 3.00 table, higher binds tighter), 0 when t is not a binary operator
522func gp_binprec(ps: *i64, t: i64) -> i64 {
  if gp_kind(ps, t) != GT_K_OP { return 0 }
  let ln: i64 = gp_tk(ps, t, 1)
  let a: i64 = gp_byte(ps, t, 0)
  if ln == 2 {
      let b: i64 = gp_byte(ps, t, 1)
      if a == C_BAR { if b == C_BAR { return GP_P_LOR } }
      if a == C_AMP { if b == C_AMP { return GP_P_LAND } }
      if b == C_EQ {
          if a == C_EQ { return GP_P_EQ }
          if a == C_BANG { return GP_P_EQ }
          if a == C_LT { return GP_P_REL }
          if a == C_GT { return GP_P_REL }
      }
      if a == C_LT { if b == C_LT { return GP_P_SHIFT } }
      if a == C_GT { if b == C_GT { return GP_P_SHIFT } }
      return 0
  }
  if a == C_BAR { return GP_P_BOR }
  if a == C_CARET { return GP_P_BXOR }
  if a == C_AMP { return GP_P_BAND }
  if a == C_LT { return GP_P_REL }
  if a == C_GT { return GP_P_REL }
  if a == C_PLUS { return GP_P_ADD }
  if a == C_MINUS { return GP_P_ADD }
  if a == C_STAR { return GP_P_MUL }
  if a == C_SLASH { return GP_P_MUL }
  if a == C_PCT { return GP_P_MUL }
  return 0
551}
552// ONE recursive descent over the expanded token stream; `mode` selects the layer (assignment > ternary > binary(minp) >
553// unary+postfix) so the function only ever calls ITSELF. Returns a node id, 0 on refusal (the refusing token is recorded once).
554func gp_parse(ps: *i64, mode: i64, minp: i64) -> i64 {
  if mode == GP_M_ASSIGN {
      let l: i64 = gp_parse(ps, GP_M_TERN, 0)
      if l == 0 { return 0 }
      // a compound assignment is parsed STRUCTURALLY: `x op= y` is ASSIGN(x, BIN(op, x, y)) with y a whole assignment-
      // expression -- so `x*=a+b` is x=(x*(a+b)), never the token-level x=x*a+b the raw expander spells (that expander cannot
      // see where y ends; this parser can -- measured 2026-09-05 on the hand MVS line `aP2.x*=1.+.08*w2`, which the raw
      // expansion would have identified with the WRONG tree). The BIN carries GN_C=1 so its printer spells the single-
      // character op of the compound token.
      let tc: i64 = ps[GP_POS]
      if gt_is_compound(ps[GP_SRC] as *u8, ps[GP_TOKS] as *i64, tc) == 1 {
          gp_take(ps)
          let rc: i64 = gp_parse(ps, GP_M_ASSIGN, 0)
          if rc == 0 { return 0 }
          return gp_node(ps, GN_ASSIGN, 0, l, gp_node(ps, GN_BIN, tc, l, rc, 1), 0)
      }
      if gp_is1(ps, ps[GP_POS], C_EQ) == 1 {
          gp_take(ps)
          let r: i64 = gp_parse(ps, GP_M_ASSIGN, 0)
          if r == 0 { return 0 }
          return gp_node(ps, GN_ASSIGN, 0, l, r, 0)
      }
      return l
  }
  if mode == GP_M_TERN {
      let c: i64 = gp_parse(ps, GP_M_BIN, GP_P_LOR)
      if c == 0 { return 0 }
      if gp_is1(ps, ps[GP_POS], C_QMARK) == 1 {
          gp_take(ps)
          let a: i64 = gp_parse(ps, GP_M_TERN, 0)
          if a == 0 { return 0 }
          if gp_is1(ps, ps[GP_POS], C_COLON) == 0 { return gp_fail(ps, ps[GP_POS]) }
          gp_take(ps)
          let b: i64 = gp_parse(ps, GP_M_TERN, 0)
          if b == 0 { return 0 }
          return gp_node(ps, GN_TERN, 0, c, a, b)
      }
      return c
  }
  if mode == GP_M_BIN {
      var left: i64 = gp_parse(ps, GP_M_UNARY, 0)
      if left == 0 { return 0 }
      var go: i64 = 1
      while go == 1 {
          let tb: i64 = ps[GP_POS]
          let pr: i64 = gp_binprec(ps, tb)
          if pr < minp { go = 0 } else { if pr == 0 { go = 0 } else {
              gp_take(ps)
              let right: i64 = gp_parse(ps, GP_M_BIN, pr + 1)
              if right == 0 { return 0 }
              left = gp_node(ps, GN_BIN, tb, left, right, 0)
          } }
      }
      return left
  }
  // GP_M_UNARY: prefix operators, then a primary with its postfix chain
  let t0: i64 = ps[GP_POS]
  if gp_is1(ps, t0, C_MINUS) == 1 { gp_take(ps); let e1: i64 = gp_parse(ps, GP_M_UNARY, 0); if e1 == 0 { return 0 } return gp_node(ps, GN_UN, C_MINUS, e1, 0, 0) }
  if gp_is1(ps, t0, C_BANG) == 1 { gp_take(ps); let e2: i64 = gp_parse(ps, GP_M_UNARY, 0); if e2 == 0 { return 0 } return gp_node(ps, GN_UN, C_BANG, e2, 0, 0) }
  if gp_is2(ps, t0, C_PLUS, C_PLUS) == 1 { gp_take(ps); let e3: i64 = gp_parse(ps, GP_M_UNARY, 0); if e3 == 0 { return 0 } return gp_node(ps, GN_INCDEC, t0, e3, 0, 0) }
  if gp_is2(ps, t0, C_MINUS, C_MINUS) == 1 { gp_take(ps); let e4: i64 = gp_parse(ps, GP_M_UNARY, 0); if e4 == 0 { return 0 } return gp_node(ps, GN_INCDEC, t0, e4, 0, 0) }
  var base: i64 = 0
  let k: i64 = gp_kind(ps, t0)
  if k == GT_K_NUM { gp_take(ps); base = gp_node(ps, GN_LEAF, t0, 0, 0, 0) }
  if k == GT_K_IDENT {
      gp_take(ps)
      if gp_is1(ps, t0 + 1, C_LPAR) == 1 {
          gp_take(ps)
          base = gp_node(ps, GN_CALL, t0, 0, 0, 0)
          if gp_is1(ps, ps[GP_POS], C_RPAR) == 1 { gp_take(ps) } else {
              var last: i64 = 0
              var ga: i64 = 1
              while ga == 1 {
                  let ea: i64 = gp_parse(ps, GP_M_ASSIGN, 0)
                  if ea == 0 { return 0 }
                  if last == 0 { gp_nset(ps, base, GN_A, ea) } else { gp_nset(ps, last, GN_NEXT, ea) }
                  last = ea
                  if gp_is1(ps, ps[GP_POS], C_COMMA) == 1 { gp_take(ps) } else {
                      if gp_is1(ps, ps[GP_POS], C_RPAR) == 1 { gp_take(ps); ga = 0 } else { return gp_fail(ps, ps[GP_POS]) }
                  }
              }
          }
      } else { base = gp_node(ps, GN_LEAF, t0, 0, 0, 0) }
  }
  if base == 0 { if gp_is1(ps, t0, C_LPAR) == 1 {
      gp_take(ps)
      let g: i64 = gp_parse(ps, GP_M_ASSIGN, 0)
      if g == 0 { return 0 }
      if gp_is1(ps, ps[GP_POS], C_RPAR) == 0 { return gp_fail(ps, ps[GP_POS]) }
      gp_take(ps)
      base = g
  } }
  if base == 0 { return gp_fail(ps, t0) }
  var go2: i64 = 1
  while go2 == 1 {
      let tp: i64 = ps[GP_POS]
      if gp_is1(ps, tp, C_LBR) == 1 {
          gp_take(ps)
          let ix: i64 = gp_parse(ps, GP_M_ASSIGN, 0)
          if ix == 0 { return 0 }
          if gp_is1(ps, ps[GP_POS], C_RBR) == 0 { return gp_fail(ps, ps[GP_POS]) }
          gp_take(ps)
          base = gp_node(ps, GN_INDEX, 0, base, ix, 0)
      } else { if gp_is1(ps, tp, C_DOT) == 1 {
          if gp_kind(ps, tp + 1) != GT_K_IDENT { return gp_fail(ps, tp + 1) }
          gp_take(ps); gp_take(ps)
          base = gp_node(ps, GN_SWZ, tp + 1, base, 0, 0)
      } else { if gp_is2(ps, tp, C_PLUS, C_PLUS) == 1 { gp_take(ps); base = gp_node(ps, GN_INCDEC, tp, base, 0, 0) }
      else { if gp_is2(ps, tp, C_MINUS, C_MINUS) == 1 { gp_take(ps); base = gp_node(ps, GN_INCDEC, tp, base, 0, 0) }
      else { go2 = 0 } } } }
  }
  return base
666}
667// the inverted spelling of a comparison operator token, or GP_INV_NONE
668func gp_inv(ps: *i64, t: i64) -> i64 {
  if gp_kind(ps, t) != GT_K_OP { return GP_INV_NONE }
  let ln: i64 = gp_tk(ps, t, 1)
  let a: i64 = gp_byte(ps, t, 0)
  if ln == 1 {
      if a == C_LT { return GP_INV_GE }
      if a == C_GT { return GP_INV_LE }
      return GP_INV_NONE
  }
  if gp_byte(ps, t, 1) != C_EQ { return GP_INV_NONE }
  if a == C_LT { return GP_INV_GT }
  if a == C_GT { return GP_INV_LT }
  if a == C_EQ { return GP_INV_NE }
  if a == C_BANG { return GP_INV_EQ }
  return GP_INV_NONE
683}
684func gp_emit_inv(ps: *i64, inv: i64) -> i64 {
  if inv == GP_INV_GE { gp_putc(ps, C_GT); gp_putc(ps, C_EQ) }
  if inv == GP_INV_LE { gp_putc(ps, C_LT); gp_putc(ps, C_EQ) }
  if inv == GP_INV_GT { gp_putc(ps, C_GT) }
  if inv == GP_INV_LT { gp_putc(ps, C_LT) }
  if inv == GP_INV_NE { gp_putc(ps, C_BANG); gp_putc(ps, C_EQ) }
  if inv == GP_INV_EQ { gp_putc(ps, C_EQ); gp_putc(ps, C_EQ) }
  gp_putc(ps, C_SP)
  return 0
693}
694// print a tree in the backend's own shape: every binary / unary / select node wrapped, calls and postfix bare
695func gp_print(ps: *i64, id: i64) -> i64 {
  if id == 0 { return 0 }
  let k: i64 = gp_n(ps, id, GN_KIND)
  let a: i64 = gp_n(ps, id, GN_A)
  let b: i64 = gp_n(ps, id, GN_B)
  if k == GN_LEAF { gp_emit_tok(ps, gp_n(ps, id, GN_TOK)); return 0 }
  if k == GN_BIN {
      gp_emit_c(ps, C_LPAR); gp_print(ps, a)
      // GN_C=1 marks the BIN synthesised from a compound assignment: spell the op's first byte, never the `op=` token
      if gp_n(ps, id, GN_C) == 1 { gp_emit_c(ps, gp_byte(ps, gp_n(ps, id, GN_TOK), 0)) } else { gp_emit_tok(ps, gp_n(ps, id, GN_TOK)) }
      gp_print(ps, b); gp_emit_c(ps, C_RPAR)
      return 0
  }
  if k == GN_UN {
      let ch: i64 = gp_n(ps, id, GN_TOK)
      if ch == C_BANG { if gp_n(ps, a, GN_KIND) == GN_BIN {
          let inv: i64 = gp_inv(ps, gp_n(ps, a, GN_TOK))
          if inv != GP_INV_NONE {
              gp_emit_c(ps, C_LPAR); gp_print(ps, gp_n(ps, a, GN_A)); gp_emit_inv(ps, inv); gp_print(ps, gp_n(ps, a, GN_B)); gp_emit_c(ps, C_RPAR)
              return 0
          }
      } }
      gp_emit_c(ps, C_LPAR); gp_emit_c(ps, ch); gp_print(ps, a); gp_emit_c(ps, C_RPAR)
      return 0
  }
  if k == GN_TERN { gp_emit_c(ps, C_LPAR); gp_print(ps, a); gp_emit_c(ps, C_QMARK); gp_print(ps, b); gp_emit_c(ps, C_COLON); gp_print(ps, gp_n(ps, id, GN_C)); gp_emit_c(ps, C_RPAR); return 0 }
  if k == GN_CALL {
      gp_emit_tok(ps, gp_n(ps, id, GN_TOK)); gp_emit_c(ps, C_LPAR)
      var e: i64 = a
      var first: i64 = 1
      while e != 0 {
          if first == 0 { gp_emit_c(ps, C_COMMA) }
          first = 0
          gp_print(ps, e)
          e = gp_n(ps, e, GN_NEXT)
      }
      gp_emit_c(ps, C_RPAR)
      return 0
  }
  if k == GN_INDEX { gp_print(ps, a); gp_emit_c(ps, C_LBR); gp_print(ps, b); gp_emit_c(ps, C_RBR); return 0 }
  if k == GN_SWZ { gp_print(ps, a); gp_emit_c(ps, C_DOT); gp_emit_tok(ps, gp_n(ps, id, GN_TOK)); return 0 }
  if k == GN_ASSIGN { gp_print(ps, a); gp_emit_c(ps, C_EQ); gp_print(ps, b); return 0 }
  if k == GN_INCDEC {
      gp_print(ps, a); gp_emit_c(ps, C_EQ); gp_emit_c(ps, C_LPAR); gp_print(ps, a); gp_emit_c(ps, gp_byte(ps, gp_n(ps, id, GN_TOK), 0)); gp_emit_c(ps, C_1); gp_emit_c(ps, C_RPAR)
      return 0
  }
  return 0
742}
743// one statement; wrap=1 braces a statement that is not itself a block (an if / else / while body). Returns 1, or 0 refused.
744func gp_stmt(ps: *i64, wrap: i64) -> i64 {
  let t: i64 = ps[GP_POS]
  if t >= ps[GP_NTOK] { return gp_fail(ps, t) }
  if gp_is1(ps, t, C_LBRACE) == 1 {
      gp_take(ps); gp_emit_c(ps, C_LBRACE)
      var gb0: i64 = 1
      while gb0 == 1 {
          if ps[GP_POS] >= ps[GP_NTOK] { return gp_fail(ps, ps[GP_POS]) }
          if gp_is1(ps, ps[GP_POS], C_RBRACE) == 1 { gb0 = 0 } else { if gp_stmt(ps, 0) == 0 { return 0 } }
      }
      gp_take(ps); gp_emit_c(ps, C_RBRACE)
      return 1
  }
  if wrap == 1 { gp_emit_c(ps, C_LBRACE) }
  var handled: i64 = 0
  if gp_isword(ps, t, "if" as *u8) == 1 {
      handled = 1
      gp_take(ps); gp_emit_s(ps, "if" as *u8)
      if gp_expect(ps, C_LPAR) == 0 { return 0 }
      let c: i64 = gp_parse(ps, GP_M_ASSIGN, 0)
      if c == 0 { return 0 }
      gp_print(ps, c)
      if gp_expect(ps, C_RPAR) == 0 { return 0 }
      if gp_stmt(ps, 1) == 0 { return 0 }
      if gp_isword(ps, ps[GP_POS], "else" as *u8) == 1 {
          gp_take(ps); gp_emit_s(ps, "else" as *u8)
          if gp_stmt(ps, 1) == 0 { return 0 }
      }
  }
  if handled == 0 { if gp_isword(ps, t, "while" as *u8) == 1 {
      handled = 1
      gp_take(ps); gp_emit_s(ps, "while" as *u8)
      if gp_expect(ps, C_LPAR) == 0 { return 0 }
      let c2: i64 = gp_parse(ps, GP_M_ASSIGN, 0)
      if c2 == 0 { return 0 }
      gp_print(ps, c2)
      if gp_expect(ps, C_RPAR) == 0 { return 0 }
      if gp_stmt(ps, 1) == 0 { return 0 }
  } }
  if handled == 0 { if gp_isword(ps, t, "for" as *u8) == 1 {
      handled = 1
      gp_take(ps)
      if gp_is1(ps, ps[GP_POS], C_LPAR) == 0 { return gp_fail(ps, ps[GP_POS]) }
      gp_take(ps)
      if gp_is1(ps, ps[GP_POS], C_SEMI) == 1 { gp_take(ps) } else { if gp_stmt(ps, 0) == 0 { return 0 } }
      gp_emit_s(ps, "while" as *u8); gp_emit_c(ps, C_LPAR); gp_emit_s(ps, "true" as *u8); gp_emit_c(ps, C_RPAR); gp_emit_c(ps, C_LBRACE)
      if gp_is1(ps, ps[GP_POS], C_SEMI) == 1 { gp_take(ps) } else {
          let cnd: i64 = gp_parse(ps, GP_M_ASSIGN, 0)
          if cnd == 0 { return 0 }
          if gp_is1(ps, ps[GP_POS], C_SEMI) == 0 { return gp_fail(ps, ps[GP_POS]) }
          gp_take(ps)
          let nt: i64 = gp_node(ps, GN_UN, C_BANG, cnd, 0, 0)
          gp_emit_s(ps, "if" as *u8); gp_emit_c(ps, C_LPAR); gp_print(ps, nt); gp_emit_c(ps, C_RPAR)
          gp_emit_c(ps, C_LBRACE); gp_emit_s(ps, "break" as *u8); gp_emit_c(ps, C_SEMI); gp_emit_c(ps, C_RBRACE)
      }
      var step: i64 = 0
      if gp_is1(ps, ps[GP_POS], C_RPAR) == 1 { gp_take(ps) } else {
          step = gp_parse(ps, GP_M_ASSIGN, 0)
          if step == 0 { return 0 }
          if gp_is1(ps, ps[GP_POS], C_RPAR) == 0 { return gp_fail(ps, ps[GP_POS]) }
          gp_take(ps)
      }
      if gp_is1(ps, ps[GP_POS], C_LBRACE) == 1 {
          gp_take(ps)
          var gb: i64 = 1
          while gb == 1 {
              if ps[GP_POS] >= ps[GP_NTOK] { return gp_fail(ps, ps[GP_POS]) }
              if gp_is1(ps, ps[GP_POS], C_RBRACE) == 1 { gb = 0 } else { if gp_stmt(ps, 0) == 0 { return 0 } }
          }
          gp_take(ps)
      } else { if gp_stmt(ps, 0) == 0 { return 0 } }
      if step != 0 { gp_print(ps, step); gp_emit_c(ps, C_SEMI) }
      gp_emit_c(ps, C_RBRACE)
  } }
  if handled == 0 { if gp_isword(ps, t, "return" as *u8) == 1 {
      handled = 1
      gp_take(ps); gp_emit_s(ps, "return" as *u8)
      if gp_is1(ps, ps[GP_POS], C_SEMI) == 0 {
          let re: i64 = gp_parse(ps, GP_M_ASSIGN, 0)
          if re == 0 { return 0 }
          gp_print(ps, re)
      }
      if gp_expect(ps, C_SEMI) == 0 { return 0 }
  } }
  if handled == 0 {
      var bare: i64 = 0
      if gp_isword(ps, t, "discard" as *u8) == 1 { bare = 1 }
      if gp_isword(ps, t, "break" as *u8) == 1 { bare = 1 }
      if gp_isword(ps, t, "continue" as *u8) == 1 { bare = 1 }
      if bare == 1 {
          handled = 1
          gp_emit_tok(ps, t); gp_take(ps)
          if gp_expect(ps, C_SEMI) == 0 { return 0 }
      }
  }
  if handled == 0 { if gp_kind(ps, t) == GT_K_IDENT { if gp_kind(ps, t + 1) == GT_K_IDENT {
      // a declaration: [qualifiers] T name[N] [= expr] (, name[N] [= expr])* ;  -- one declarator per emitted statement
      handled = 1
      var ty: i64 = t
      var gq: i64 = 1
      while gq == 1 {
          var isq: i64 = 0
          if gp_isword(ps, ty, "const" as *u8) == 1 { isq = 1 }
          if gp_isword(ps, ty, "highp" as *u8) == 1 { isq = 1 }
          if gp_isword(ps, ty, "mediump" as *u8) == 1 { isq = 1 }
          if gp_isword(ps, ty, "lowp" as *u8) == 1 { isq = 1 }
          if isq == 1 { gp_emit_tok(ps, ty); ty = ty + 1 } else { gq = 0 }
      }
      if gp_kind(ps, ty) != GT_K_IDENT { return gp_fail(ps, ty) }
      gp_emit_tok(ps, ty)
      ps[GP_POS] = ty + 1
      var gd: i64 = 1
      while gd == 1 {
          let nm: i64 = ps[GP_POS]
          if gp_kind(ps, nm) != GT_K_IDENT { return gp_fail(ps, nm) }
          gp_emit_tok(ps, nm); gp_take(ps)
          if gp_is1(ps, ps[GP_POS], C_LBR) == 1 {
              gp_take(ps); gp_emit_c(ps, C_LBR)
              let an: i64 = gp_parse(ps, GP_M_ASSIGN, 0)
              if an == 0 { return 0 }
              gp_print(ps, an)
              if gp_expect(ps, C_RBR) == 0 { return 0 }
          }
          if gp_is1(ps, ps[GP_POS], C_EQ) == 1 {
              gp_take(ps); gp_emit_c(ps, C_EQ)
              let iv: i64 = gp_parse(ps, GP_M_ASSIGN, 0)
              if iv == 0 { return 0 }
              gp_print(ps, iv)
          }
          if gp_is1(ps, ps[GP_POS], C_COMMA) == 1 { gp_take(ps); gp_emit_c(ps, C_SEMI); gp_emit_tok(ps, ty) } else {
              if gp_expect(ps, C_SEMI) == 0 { return 0 }
              gd = 0
          }
      }
  } } }
  if handled == 0 {
      let ex: i64 = gp_parse(ps, GP_M_ASSIGN, 0)
      if ex == 0 { return 0 }
      gp_print(ps, ex)
      if gp_expect(ps, C_SEMI) == 0 { return 0 }
  }
  if wrap == 1 { gp_emit_c(ps, C_RBRACE) }
  return 1
887}
888// module scope: tokens copied (numbers canonicalised); a block is parsed as statements; the right side of `=` canonicalised
889func gp_toplevel(ps: *i64) -> i64 {
  while ps[GP_POS] < ps[GP_NTOK] {
      let t: i64 = ps[GP_POS]
      if gp_is1(ps, t, C_LBRACE) == 1 { if gp_stmt(ps, 0) == 0 { return 0 } } else {
          if gp_is1(ps, t, C_EQ) == 1 {
              gp_take(ps); gp_emit_c(ps, C_EQ)
              let e: i64 = gp_parse(ps, GP_M_TERN, 0)
              if e == 0 { return 0 }
              gp_print(ps, e)
          } else { gp_emit_tok(ps, t); gp_take(ps) }
      }
      if ps[GP_ERR] >= 0 { return 0 }
  }
  return 1
903}
904// canonical text of src[0,n) into out (cap bytes). Returns the canonical length, or -1 refused: box[0] = byte offset of the
905// refusing token (n when the input ended early), box[1] = its length, box[2] = raw tokens, box[3] = expanded tokens,
906// box[4] = compounds refused by the expander, box[5] = 1 when the output bound was hit (never a silent truncation).
907func gt_canon_text(src: *u8, n: i64, out: *u8, cap: i64, box: *i64) -> i64 {
  let toks: *i64 = sys_mmap(GT_TW * 8 * (n + 1)) as *i64
  let k: i64 = gt_tokenize(src, n, toks)
  let xt: *i64 = sys_mmap(GT_TW * 8 * (3 * k + 3)) as *i64
  let bx: *i64 = sys_mmap(16) as *i64
  let e: i64 = gt_expand(src, toks, k, xt, bx)
  box[0] = 0 - 1; box[1] = 0; box[2] = k; box[3] = e; box[4] = bx[0]; box[5] = 0
  let ps: *i64 = sys_mmap(GP_SLOTS * 8) as *i64
  // the parser reads the RAW tokens: compound assignment is parsed structurally (gp_parse), never token-expanded, so the
  // right-hand side keeps its own tree; the expander runs only to report expanded_a/expanded_b beside the raw count
  ps[GP_POS] = 0; ps[GP_NTOK] = k; ps[GP_OUT] = 0; ps[GP_ERR] = 0 - 1; ps[GP_NCOUNT] = 1
  ps[GP_SRC] = src as i64; ps[GP_TOKS] = toks as i64
  ps[GP_NODES] = sys_mmap(GN_SLOTS * 8 * (3 * k + 16)) as i64
  ps[GP_OUTBUF] = out as i64; ps[GP_CAP] = cap; ps[GP_OVER] = 0
  ps[GP_TMP] = sys_mmap(GT_CANON_CAP) as i64
  let ok: i64 = gp_toplevel(ps)
  if ps[GP_OVER] == 1 { box[5] = 1; return 0 - 1 }
  if ok == 0 {
      var et: i64 = ps[GP_ERR]
      if et < 0 { et = ps[GP_POS] }
      if et >= k { box[0] = n; box[1] = 0 } else { box[0] = toks[et * GT_TW]; box[1] = toks[et * GT_TW + 1] }
      return 0 - 1
  }
  return ps[GP_OUT]
931}
932// THE CANONICAL RULER: canonicalise both sides, then run the incumbent token differ over the two canonical texts.
933func gt_diff_canon(a: *u8, na: i64, b: *u8, nb: i64, r: *i64) -> i64 {
  let capa: i64 = GT_CANON_OUT_MULT * na + GT_CANON_OUT_HEAD
  let capb: i64 = GT_CANON_OUT_MULT * nb + GT_CANON_OUT_HEAD
  let ca: *u8 = sys_mmap(capa)
  let cb: *u8 = sys_mmap(capb)
  let ba: *i64 = sys_mmap(64) as *i64
  let bb: *i64 = sys_mmap(64) as *i64
  let la: i64 = gt_canon_text(a, na, ca, capa, ba)
  let lb: i64 = gt_canon_text(b, nb, cb, capb, bb)
  r[GT_R_TOKA] = ba[2]; r[GT_R_TOKB] = bb[2]; r[GT_R_EXPA] = ba[3]; r[GT_R_EXPB] = bb[3]
  r[GT_R_REFUSED] = ba[4] + bb[4]
  r[GT_R_ERRA] = ba[0]; r[GT_R_ERRLA] = ba[1]; r[GT_R_ERRB] = bb[0]; r[GT_R_ERRLB] = bb[1]
  r[GT_R_OVER] = ba[5] + bb[5]
  r[GT_R_SRCA] = a as i64; r[GT_R_SRCB] = b as i64
  r[GT_R_CAPTR_A] = ca as i64; r[GT_R_CAPTR_B] = cb as i64
  r[GT_R_CALEN_A] = 0; r[GT_R_CALEN_B] = 0
  if la >= 0 { r[GT_R_CALEN_A] = la }
  if lb >= 0 { r[GT_R_CALEN_B] = lb }
  r[GT_R_CANA] = 0; r[GT_R_CANB] = 0; r[GT_R_FIRSTDIFF] = 0 - 1
  if la < 0 { r[GT_R_VERDICT] = GT_V_UNREADABLE; return GT_V_UNREADABLE }
  if lb < 0 { r[GT_R_VERDICT] = GT_V_UNREADABLE; return GT_V_UNREADABLE }
  let r2: *i64 = sys_mmap(GT_R_SLOTS * 8) as *i64
  let v: i64 = gt_diff(ca, la, cb, lb, r2)
  r[GT_R_CANA] = r2[GT_R_EXPA]; r[GT_R_CANB] = r2[GT_R_EXPB]
  r[GT_R_FIRSTDIFF] = r2[GT_R_FIRSTDIFF]
  r[GT_R_VERDICT] = v
  return v
960}
961// THE PER-SLICE ACCEPT SIGNAL. A transcribed slice is emitted as a WHOLE function, so its canonical stream ends with the closing
962// brace of main while the hand text continues: the shorter side is a prefix of the longer UP TO that brace. slice_prefix=1 when
963// IDENTICAL, when the shorter is a pure prefix (first_diff at its length), or when the first difference is the shorter's LAST
964// token and that token is `}`; 0 for every real divergence and for an unreadable side. Derived from the canonical texts the
965// ruler already holds, so the report and the gate read the same predicate.
966func gt_slice_prefix(r: *i64) -> i64 {
  if r[GT_R_VERDICT] == GT_V_UNREADABLE { return 0 }
  if r[GT_R_VERDICT] == GT_V_IDENTICAL { return 1 }
  if r[GT_R_CANA] == r[GT_R_CANB] { return 0 }
  var mn: i64 = r[GT_R_CANA]
  var sp: i64 = r[GT_R_CAPTR_A]
  var sl: i64 = r[GT_R_CALEN_A]
  if r[GT_R_CANB] < mn { mn = r[GT_R_CANB]; sp = r[GT_R_CAPTR_B]; sl = r[GT_R_CALEN_B] }
  if r[GT_R_FIRSTDIFF] == mn { return 1 }
  if r[GT_R_FIRSTDIFF] != mn - 1 { return 0 }
  if sl < 2 { return 0 }
  let s: *u8 = sp as *u8
  if (s[sl - 1] as i64) != C_SP { return 0 }
  if (s[sl - 2] as i64) != C_RBRACE { return 0 }
  return 1
981}
982func gt_report_canon(fd: i64, r: *i64) -> i64 {
  gt_fputs(fd, "tokens_a=" as *u8); gt_fputn(fd, r[GT_R_TOKA])
  gt_fputs(fd, " tokens_b=" as *u8); gt_fputn(fd, r[GT_R_TOKB])
  gt_fputs(fd, " expanded_a=" as *u8); gt_fputn(fd, r[GT_R_EXPA])
  gt_fputs(fd, " expanded_b=" as *u8); gt_fputn(fd, r[GT_R_EXPB])
  gt_fputs(fd, " expand_refused=" as *u8); gt_fputn(fd, r[GT_R_REFUSED])
  gt_fputs(fd, " canon_a=" as *u8); gt_fputn(fd, r[GT_R_CANA])
  gt_fputs(fd, " canon_b=" as *u8); gt_fputn(fd, r[GT_R_CANB])
  gt_fputs(fd, " canon_refused_a=" as *u8); gt_fputn(fd, r[GT_R_ERRA])
  gt_fputs(fd, " canon_refused_b=" as *u8); gt_fputn(fd, r[GT_R_ERRB])
  gt_fputs(fd, " canon_overflow=" as *u8); gt_fputn(fd, r[GT_R_OVER])
  gt_fputs(fd, " first_diff=" as *u8); gt_fputn(fd, r[GT_R_FIRSTDIFF])
  var pre: i64 = 0
  if r[GT_R_FIRSTDIFF] >= 0 {
      var mn: i64 = r[GT_R_CANA]
      if r[GT_R_CANB] < mn { mn = r[GT_R_CANB] }
      if r[GT_R_FIRSTDIFF] == mn { if r[GT_R_CANA] != r[GT_R_CANB] { pre = 1 } }
  }
  gt_fputs(fd, " shorter_is_prefix=" as *u8); gt_fputn(fd, pre)
  gt_fputs(fd, " slice_prefix=" as *u8); gt_fputn(fd, gt_slice_prefix(r))
  if r[GT_R_FIRSTDIFF] >= 0 {
      gt_fputs(fd, " a_tok=" as *u8); gt_put_expanded_tok(fd, r[GT_R_CAPTR_A] as *u8, r[GT_R_CALEN_A], r[GT_R_FIRSTDIFF])
      gt_fputs(fd, " b_tok=" as *u8); gt_put_expanded_tok(fd, r[GT_R_CAPTR_B] as *u8, r[GT_R_CALEN_B], r[GT_R_FIRSTDIFF])
  }
  if r[GT_R_ERRA] >= 0 { gt_fputs(fd, " canon_refused_a_tok=" as *u8); sys_write(fd, ((r[GT_R_SRCA] + r[GT_R_ERRA]) as *u8), r[GT_R_ERRLA]) }
  if r[GT_R_ERRB] >= 0 { gt_fputs(fd, " canon_refused_b_tok=" as *u8); sys_write(fd, ((r[GT_R_SRCB] + r[GT_R_ERRB]) as *u8), r[GT_R_ERRLB]) }
  gt_fputs(fd, "\n" as *u8)
  if r[GT_R_VERDICT] == GT_V_IDENTICAL { gt_fputs(fd, "verdict=IDENTICAL\n" as *u8) } else {
      if r[GT_R_VERDICT] == GT_V_UNREADABLE { gt_fputs(fd, "verdict=UNREADABLE\n" as *u8) } else { gt_fputs(fd, "verdict=DIFFERS\n" as *u8) }
  }
  return 0
1013}
nx_glsl_tok_lib.nx source

`nx_glsl_tok_lib.nx` source
