code wiki / _hdl_build / nx_step_parse_gate.nx
nx_step_parse_gate.nx source
↩ module page · 222 lines · 8747 B
1// nx_step_parse_gate.nx -- teeth for R1a STEP structure parse on the REAL canonical assembly
2// knowledge/fetched/step_as1.stp (as1-oc-214, AP214, banked by nx_step_sample_fetch). T1 lex scale ·
3// T2 PRODUCTs found incl as1/nut/rod-assembly (probe-verified names) · T3 NAUO edges collected + EVERY
4// parent/child PD resolves PD->PDF->PRODUCT · T4 exactly ONE assembly root and it is the as1 product ·
5// T5 occurrence tree depth >= 2 (assembly of assemblies), printed for eyeball · T6 BOM leaf occurrences
6// >= 4, printed · T7 NEG-CONTROL: a real NON-STEP file (NHTSA JSON) lexes to 0 entities · T8 truncation
7// robustness: first-2000-bytes parse yields fewer entities, no crash. expect_exit: 0 license_tier: ORIGINAL
8import "nx_step_parse.nx"
9
10func spg_tooth(name: *u8, pass: i64, fails: *i64) -> i64 {
11 sp_puts(" " as *u8); sp_puts(name); sp_puts(" -> " as *u8)
12 if pass == 1 { sp_puts("PASS\n" as *u8); return 0 }
13 sp_puts("FAIL\n" as *u8)
14 fails[0] = fails[0] + 1
15 return 0
16}
17
18func spg_prod_out(st: *i64, prodidx: i64, out2: *i64) -> i64 {
19 let buf: *u8 = st[0] as *u8
20 let okk: i64 = sp_arg_span(st, prodidx, 0, out2)
21 if okk == 1 { let ig: i64 = sp_span_str_out(buf, out2[0], out2[1]) }
22 return 0
23}
24
25func main() -> i64 {
26 sp_puts("=== nx_step_parse_gate -- teeth on the REAL as1-oc-214.stp ===\n" as *u8)
27 let buf: *u8 = sys_mmap(4194304)
28 let aid: *i64 = sys_mmap(524288) as *i64
29 let anm: *i64 = sys_mmap(524288) as *i64
30 let anl: *i64 = sys_mmap(524288) as *i64
31 let aao: *i64 = sys_mmap(524288) as *i64
32 let aal: *i64 = sys_mmap(524288) as *i64
33 let st: *i64 = sys_mmap(256) as *i64
34 let out2: *i64 = sys_mmap(16) as *i64
35 let pe: *i64 = sys_mmap(2048) as *i64
36 let ce: *i64 = sys_mmap(2048) as *i64
37 let fails: *i64 = sys_mmap(8) as *i64
38 fails[0] = 0
39
40 let n: i64 = sp_read_file("knowledge/fetched/step_as1.stp" as *u8, buf, 4194304)
41 if n <= 0 { sp_puts("MISSING step_as1.stp -- run nx_step_sample_fetch first\nRED\n" as *u8); return 1 }
42 sp_puts("file bytes=" as *u8); sp_putn(n); sp_puts("\n" as *u8)
43 let ig0: i64 = sp_init(st, buf, n, aid, anm, anl, aao, aal)
44 let cnt: i64 = sp_scan(st)
45 sp_puts("entities=" as *u8); sp_putn(cnt); sp_puts("\n" as *u8)
46 var t1: i64 = 0
47 if cnt >= 1000 { t1 = 1 }
48 let ig1: i64 = spg_tooth("T1 lex scale (entities >= 1000)" as *u8, t1, fails)
49
50 // T2 products
51 var nprod: i64 = 0
52 var f_as1: i64 = 0
53 var f_nut: i64 = 0
54 var f_rod: i64 = 0
55 var k: i64 = 0
56 while k < cnt {
57 let isp: i64 = sp_name_is(st, k, "PRODUCT" as *u8)
58 if isp == 1 {
59 nprod = nprod + 1
60 let h1: i64 = sp_prod_name_is(st, k, "as1" as *u8)
61 if h1 == 1 { f_as1 = 1 }
62 let h2: i64 = sp_prod_name_is(st, k, "nut" as *u8)
63 if h2 == 1 { f_nut = 1 }
64 let h3: i64 = sp_prod_name_is(st, k, "rod-assembly" as *u8)
65 if h3 == 1 { f_rod = 1 }
66 }
67 k = k + 1
68 }
69 sp_puts("products=" as *u8); sp_putn(nprod)
70 sp_puts(" as1=" as *u8); sp_putn(f_as1)
71 sp_puts(" nut=" as *u8); sp_putn(f_nut)
72 sp_puts(" rod-assembly=" as *u8); sp_putn(f_rod); sp_puts("\n" as *u8)
73 var t2: i64 = 0
74 if nprod >= 5 { if f_as1 == 1 { if f_nut == 1 { if f_rod == 1 { t2 = 1 } } } }
75 let ig2: i64 = spg_tooth("T2 PRODUCTs incl as1/nut/rod-assembly" as *u8, t2, fails)
76
77 // T3 NAUO edges + full resolution
78 let en: i64 = sp_nauo_collect(st, pe, ce, 256)
79 sp_puts("assembly edges (NAUO)=" as *u8); sp_putn(en); sp_puts("\n" as *u8)
80 var resolved: i64 = 1
81 var i: i64 = 0
82 while i < en {
83 let pp: i64 = sp_pd_product(st, pe[i])
84 let cc: i64 = sp_pd_product(st, ce[i])
85 if pp < 0 { resolved = 0 }
86 if cc < 0 { resolved = 0 }
87 i = i + 1
88 }
89 var t3: i64 = 0
90 if en >= 6 { if resolved == 1 { t3 = 1 } }
91 let ig3: i64 = spg_tooth("T3 edges >= 6 and ALL PD->PDF->PRODUCT resolve" as *u8, t3, fails)
92
93 // T4 exactly one root and it is as1
94 let rr: *i64 = sys_mmap(512) as *i64
95 var nroots: i64 = 0
96 i = 0
97 while i < en {
98 let p: i64 = pe[i]
99 var ischild: i64 = 0
100 var j: i64 = 0
101 while j < en {
102 if ce[j] == p { ischild = 1 }
103 j = j + 1
104 }
105 if ischild == 0 {
106 var seen: i64 = 0
107 var q: i64 = 0
108 while q < nroots {
109 if rr[q] == p { seen = 1 }
110 q = q + 1
111 }
112 if seen == 0 {
113 if nroots < 64 { rr[nroots] = p; nroots = nroots + 1 }
114 }
115 }
116 i = i + 1
117 }
118 sp_puts("roots=" as *u8); sp_putn(nroots); sp_puts("\n" as *u8)
119 var t4: i64 = 0
120 if nroots == 1 {
121 let rprod: i64 = sp_pd_product(st, rr[0])
122 if rprod >= 0 {
123 let isas1: i64 = sp_prod_name_is(st, rprod, "as1" as *u8)
124 if isas1 == 1 { t4 = 1 }
125 }
126 }
127 let ig4: i64 = spg_tooth("T4 exactly 1 root = as1" as *u8, t4, fails)
128
129 // T5 occurrence tree (iterative DFS) printed + max depth
130 sp_puts("assembly occurrence tree:\n" as *u8)
131 let sd_pd: *i64 = sys_mmap(4096) as *i64
132 let sd_dep: *i64 = sys_mmap(4096) as *i64
133 var sp_: i64 = 0
134 var maxdep: i64 = 0
135 var overflow: i64 = 0
136 if nroots == 1 { sd_pd[0] = rr[0]; sd_dep[0] = 0; sp_ = 1 }
137 while sp_ > 0 {
138 sp_ = sp_ - 1
139 let pd: i64 = sd_pd[sp_]
140 let dep: i64 = sd_dep[sp_]
141 if dep > maxdep { maxdep = dep }
142 var q2: i64 = 0
143 while q2 < dep { sp_puts(" " as *u8); q2 = q2 + 1 }
144 sp_puts("- " as *u8)
145 let prodi: i64 = sp_pd_product(st, pd)
146 if prodi >= 0 { let ig5: i64 = spg_prod_out(st, prodi, out2) } else { sp_puts("(unresolved)" as *u8) }
147 sp_puts("\n" as *u8)
148 if dep < 12 {
149 var e2: i64 = 0
150 while e2 < en {
151 if pe[e2] == pd {
152 if sp_ < 250 { sd_pd[sp_] = ce[e2]; sd_dep[sp_] = dep + 1; sp_ = sp_ + 1 } else { overflow = 1 }
153 }
154 e2 = e2 + 1
155 }
156 }
157 }
158 sp_puts("max depth=" as *u8); sp_putn(maxdep); sp_puts(" overflow=" as *u8); sp_putn(overflow); sp_puts("\n" as *u8)
159 var t5: i64 = 0
160 if maxdep >= 2 { if overflow == 0 { t5 = 1 } }
161 let ig6: i64 = spg_tooth("T5 occurrence tree depth >= 2" as *u8, t5, fails)
162
163 // T6 BOM: leaf products by direct occurrence count
164 let bom: *i64 = sys_mmap(524288) as *i64
165 var totleaf: i64 = 0
166 i = 0
167 while i < en {
168 let ch: i64 = ce[i]
169 var haschild: i64 = 0
170 var j2: i64 = 0
171 while j2 < en {
172 if pe[j2] == ch { haschild = 1 }
173 j2 = j2 + 1
174 }
175 if haschild == 0 {
176 let prodi2: i64 = sp_pd_product(st, ch)
177 if prodi2 >= 0 { bom[prodi2] = bom[prodi2] + 1; totleaf = totleaf + 1 }
178 }
179 i = i + 1
180 }
181 sp_puts("BOM (leaf part x direct occurrences):\n" as *u8)
182 k = 0
183 while k < cnt {
184 if bom[k] > 0 {
185 sp_puts(" " as *u8); sp_putn(bom[k]); sp_puts("x " as *u8)
186 let ig7: i64 = spg_prod_out(st, k, out2)
187 sp_puts("\n" as *u8)
188 }
189 k = k + 1
190 }
191 sp_puts("total leaf occurrences=" as *u8); sp_putn(totleaf); sp_puts("\n" as *u8)
192 var t6: i64 = 0
193 if totleaf >= 4 { t6 = 1 }
194 let ig8: i64 = spg_tooth("T6 BOM leaf occurrences >= 4" as *u8, t6, fails)
195
196 // T7 neg-control: a real NON-STEP file lexes to 0 entities
197 let n7: i64 = sp_read_file("knowledge/fetched/ub_alt13c.raw" as *u8, buf, 4194304)
198 var t7: i64 = 0
199 if n7 > 0 {
200 let ig9: i64 = sp_init(st, buf, n7, aid, anm, anl, aao, aal)
201 let cnt7: i64 = sp_scan(st)
202 sp_puts("neg-control JSON entities=" as *u8); sp_putn(cnt7); sp_puts("\n" as *u8)
203 if cnt7 == 0 { t7 = 1 }
204 }
205 let ig10: i64 = spg_tooth("T7 neg-control non-STEP -> 0 entities" as *u8, t7, fails)
206
207 // T8 truncation robustness: first 2000 bytes parse to fewer entities, cleanly
208 let n8: i64 = sp_read_file("knowledge/fetched/step_as1.stp" as *u8, buf, 4194304)
209 var t8: i64 = 0
210 if n8 > 2000 {
211 let ig11: i64 = sp_init(st, buf, 2000, aid, anm, anl, aao, aal)
212 let cnt8: i64 = sp_scan(st)
213 sp_puts("truncated-2000B entities=" as *u8); sp_putn(cnt8); sp_puts("\n" as *u8)
214 if cnt8 < cnt { t8 = 1 }
215 }
216 let ig12: i64 = spg_tooth("T8 truncation parses cleanly (fewer entities)" as *u8, t8, fails)
217
218 sp_puts("\nfails=" as *u8); sp_putn(fails[0]); sp_puts("\n" as *u8)
219 if fails[0] == 0 { sp_puts("GREEN -- STEP structure parse teeth 8/8 on the real as1 assembly\n" as *u8); return 0 }
220 sp_puts("RED\n" as *u8)
221 return 1
222}