nx_forge_ctx.nx source
↩ module page · 527 lines · 17916 B
1// nx_forge_ctx.nx -- FORGE F2: the context-pack EMITTER core (pure lib, no main; CLI =
2// nx_forge_ctx_emit, gate = nx_forge_ctx_gate). Emits the NishiLang coding pack from SOURCES
3// instead of a hand seed: (1) the curated rules corpus knowledge/forge/pack_rules_v1.txt copied
4// verbatim -- FAIL-CLOSED if any line begins UNVERIFIED; (2) the stdlib API section EXTRACTED
5// LIVE from runtime/nx_lib_std.nx (every `func std_` signature line) so a stale signature is
6// impossible by construction; (3) the exemplar EMBEDDED verbatim from runtime/nx_fbench_probe.nx
7// (lane-GREEN, re-verified before each pack bless). fc_check_sigs is the gate's cross-checker:
8// every emitted signature must exist verbatim in the live lib (catches planted/stale rows).
9// license_tier: ORIGINAL
10import "nx_syscalls.nx"
11import "nx_lib_std.nx"
12const K_MAGIC_32768: i64 = 32768
13const K_MAGIC_65536: i64 = 65536
14
15func fc_read(path: *u8, buf: *u8, cap: i64) -> i64 {
16 let fd: i64 = sys_openat_rd(path)
17 if fd < 0 {
18 let neg: i64 = 0 - 1
19 return neg
20 }
21 var total: i64 = 0
22 var going: i64 = 1
23 while going == 1 {
24 let lim: i64 = cap - 1
25 let room: i64 = lim - total
26 if room <= 0 { going = 0 }
27 if going == 1 {
28 let p: *u8 = buf + total
29 let n: i64 = sys_read(fd, p, room)
30 if n <= 0 { going = 0 }
31 if n > 0 { total = total + n }
32 }
33 }
34 sys_close(fd)
35 buf[total] = 0 as u8
36 return total
37}
38
39func fc_wb(fd: i64, p: *u8, n: i64) -> i64 {
40 var off: i64 = 0
41 while off < n {
42 let q: *u8 = p + off
43 let rem: i64 = n - off
44 let w: i64 = sys_write(fd, q, rem)
45 if w <= 0 {
46 let neg: i64 = 0 - 1
47 return neg
48 }
49 off = off + w
50 }
51 return 0
52}
53
54func fc_ws(fd: i64, s: *u8) -> i64 {
55 let n: i64 = std_slen(s)
56 let r: i64 = fc_wb(fd, s, n)
57 return r
58}
59
60// 1 if any line in [0,n) begins with UNVERIFIED
61func fc_has_unverified(buf: *u8, n: i64) -> i64 {
62 var i: i64 = 0
63 var atstart: i64 = 1
64 while i < n {
65 let c: i64 = buf[i] as i64
66 if atstart == 1 {
67 if c == 85 {
68 let rem: i64 = n - i
69 if rem >= 10 {
70 var j: i64 = 0
71 var ok: i64 = 1
72 let m: *u8 = "UNVERIFIED" as *u8
73 while j < 10 {
74 let bi: i64 = i + j
75 let a: i64 = buf[bi] as i64
76 let b: i64 = m[j] as i64
77 if a != b { ok = 0; j = 10 }
78 if a == b { j = j + 1 }
79 }
80 if ok == 1 { return 1 }
81 }
82 }
83 }
84 atstart = 0
85 if c == 10 { atstart = 1 }
86 i = i + 1
87 }
88 return 0
89}
90
91// naive substring: 1 if nd[0..nn) occurs in hay[0..hn)
92func fc_contains(hay: *u8, hn: i64, nd: *u8, nn: i64) -> i64 {
93 if nn <= 0 { return 0 }
94 if hn < nn { return 0 }
95 var i: i64 = 0
96 let stop: i64 = hn - nn
97 while i <= stop {
98 var j: i64 = 0
99 var ok: i64 = 1
100 while j < nn {
101 let hidx: i64 = i + j
102 let a: i64 = hay[hidx] as i64
103 let b: i64 = nd[j] as i64
104 if a != b { ok = 0; j = nn }
105 if a == b { j = j + 1 }
106 }
107 if ok == 1 { return 1 }
108 i = i + 1
109 }
110 return 0
111}
112
113// 1 if the line [ls,le) begins with `func std_`
114func fc_line_is_sig(buf: *u8, ls: i64, le: i64) -> i64 {
115 let ll: i64 = le - ls
116 if ll < 9 { return 0 }
117 var j: i64 = 0
118 var ok: i64 = 1
119 let m: *u8 = "func std_" as *u8
120 while j < 9 {
121 let bi: i64 = ls + j
122 let a: i64 = buf[bi] as i64
123 let b: i64 = m[j] as i64
124 if a != b { ok = 0; j = 9 }
125 if a == b { j = j + 1 }
126 }
127 return ok
128}
129
130// content end of line [ls,le): strip one trailing CR
131func fc_line_cend(buf: *u8, ls: i64, le: i64) -> i64 {
132 var cend: i64 = le
133 if cend > ls {
134 let last: i64 = cend - 1
135 let lc: i64 = buf[last] as i64
136 if lc == 13 { cend = cend - 1 }
137 }
138 return cend
139}
140
141// write every `func std_` line of lib[0..n) to fd (CR-stripped, one per line); returns count
142func fc_extract_sigs(buf: *u8, n: i64, fd: i64) -> i64 {
143 var count: i64 = 0
144 var i: i64 = 0
145 while i < n {
146 var e: i64 = i
147 var scan: i64 = 1
148 while scan == 1 {
149 if e >= n { scan = 0 }
150 if scan == 1 {
151 let c: i64 = buf[e] as i64
152 if c == 10 { scan = 0 }
153 if c != 10 { e = e + 1 }
154 }
155 }
156 let issig: i64 = fc_line_is_sig(buf, i, e)
157 if issig == 1 {
158 let cend: i64 = fc_line_cend(buf, i, e)
159 let clen: i64 = cend - i
160 let lp: *u8 = buf + i
161 let w1: i64 = fc_wb(fd, lp, clen)
162 let w2: i64 = fc_ws(fd, "\n" as *u8)
163 if w1 == 0 {
164 if w2 == 0 { count = count + 1 }
165 }
166 }
167 i = e + 1
168 }
169 return count
170}
171
172// cross-check: every `func std_` line in pack[0..pn) must occur verbatim in lib[0..ln); returns bad count
173func fc_check_sigs(pack: *u8, pn: i64, lib: *u8, ln: i64) -> i64 {
174 var bad: i64 = 0
175 var i: i64 = 0
176 while i < pn {
177 var e: i64 = i
178 var scan: i64 = 1
179 while scan == 1 {
180 if e >= pn { scan = 0 }
181 if scan == 1 {
182 let c: i64 = pack[e] as i64
183 if c == 10 { scan = 0 }
184 if c != 10 { e = e + 1 }
185 }
186 }
187 let issig: i64 = fc_line_is_sig(pack, i, e)
188 if issig == 1 {
189 let cend: i64 = fc_line_cend(pack, i, e)
190 let clen: i64 = cend - i
191 let lp: *u8 = pack + i
192 let found: i64 = fc_contains(lib, ln, lp, clen)
193 if found == 0 { bad = bad + 1 }
194 }
195 i = e + 1
196 }
197 return bad
198}
199
200// start index of pipe-separated field n within [ls,le); -1 if absent
201func fc_fstart(buf: *u8, ls: i64, le: i64, n: i64) -> i64 {
202 if n == 0 { return ls }
203 var i: i64 = ls
204 var seen: i64 = 0
205 while i < le {
206 let c: i64 = buf[i] as i64
207 if c == 124 {
208 seen = seen + 1
209 if seen == n {
210 let r: i64 = i + 1
211 return r
212 }
213 }
214 i = i + 1
215 }
216 let neg: i64 = 0 - 1
217 return neg
218}
219
220func fc_fend(buf: *u8, fs: i64, le: i64) -> i64 {
221 var i: i64 = fs
222 while i < le {
223 let c: i64 = buf[i] as i64
224 if c == 124 { return i }
225 i = i + 1
226 }
227 return le
228}
229
230// render ACTIVE+GUARD rows of the vetted registry as pack rules (statement + WHY); RETIRED rows
231// are OMITTED (the language outgrew them). Returns rendered row count.
232func fc_render_rules(buf: *u8, n: i64, fd: i64) -> i64 {
233 var count: i64 = 0
234 var i: i64 = 0
235 while i < n {
236 var e: i64 = i
237 var scan: i64 = 1
238 while scan == 1 {
239 if e >= n { scan = 0 }
240 if scan == 1 {
241 let c: i64 = buf[e] as i64
242 if c == 10 { scan = 0 }
243 if c != 10 { e = e + 1 }
244 }
245 }
246 let ll: i64 = e - i
247 var isrule: i64 = 0
248 if ll > 5 {
249 let c0: i64 = buf[i] as i64
250 let i1: i64 = i + 1
251 let c1: i64 = buf[i1] as i64
252 let i2: i64 = i + 2
253 let c2: i64 = buf[i2] as i64
254 let i3: i64 = i + 3
255 let c3: i64 = buf[i3] as i64
256 let i4: i64 = i + 4
257 let c4: i64 = buf[i4] as i64
258 if c0 == 82 {
259 if c1 == 85 {
260 if c2 == 76 {
261 if c3 == 69 {
262 if c4 == 124 { isrule = 1 }
263 }
264 }
265 }
266 }
267 }
268 if isrule == 1 {
269 let sts: i64 = fc_fstart(buf, i, e, 2)
270 let ste: i64 = fc_fend(buf, sts, e)
271 let stm: i64 = fc_fstart(buf, i, e, 4)
272 let stme: i64 = fc_fend(buf, stm, e)
273 let whys: i64 = fc_fstart(buf, i, e, 5)
274 let whye: i64 = fc_fend(buf, whys, e)
275 var okrow: i64 = 1
276 if sts < 0 { okrow = 0 }
277 if stm < 0 { okrow = 0 }
278 if whys < 0 { okrow = 0 }
279 if okrow == 1 {
280 let sb: i64 = buf[sts] as i64
281 if sb != 82 {
282 var werr2: i64 = 0
283 let w1: i64 = fc_ws(fd, "- " as *u8)
284 werr2 = werr2 + w1
285 let stl: i64 = ste - sts
286 let stp: *u8 = buf + sts
287 let w2: i64 = fc_wb(fd, stp, stl)
288 werr2 = werr2 + w2
289 let w3: i64 = fc_ws(fd, ": " as *u8)
290 werr2 = werr2 + w3
291 let stml: i64 = stme - stm
292 let stmp: *u8 = buf + stm
293 let w4: i64 = fc_wb(fd, stmp, stml)
294 werr2 = werr2 + w4
295 let w5: i64 = fc_ws(fd, "\n WHY: " as *u8)
296 werr2 = werr2 + w5
297 let wys: i64 = whys + 4
298 let wyl: i64 = whye - wys
299 var w6: i64 = 0
300 if wyl > 0 {
301 let wyp: *u8 = buf + wys
302 w6 = fc_wb(fd, wyp, wyl)
303 }
304 werr2 = werr2 + w6
305 let w7: i64 = fc_ws(fd, "\n" as *u8)
306 werr2 = werr2 + w7
307 if werr2 == 0 { count = count + 1 }
308 }
309 }
310 }
311 i = e + 1
312 }
313 return count
314}
315
316// render ACTIVE+GUARD rows STATEMENTS-ONLY (no WHY) -- the LOCAL-TIER budget variant
317func fc_render_rules_brief(buf: *u8, n: i64, fd: i64) -> i64 {
318 var count: i64 = 0
319 var i: i64 = 0
320 while i < n {
321 var e: i64 = i
322 var scan: i64 = 1
323 while scan == 1 {
324 if e >= n { scan = 0 }
325 if scan == 1 {
326 let c: i64 = buf[e] as i64
327 if c == 10 { scan = 0 }
328 if c != 10 { e = e + 1 }
329 }
330 }
331 let ll: i64 = e - i
332 var isrule: i64 = 0
333 if ll > 5 {
334 let c0: i64 = buf[i] as i64
335 let i1: i64 = i + 1
336 let c1: i64 = buf[i1] as i64
337 let i2: i64 = i + 2
338 let c2: i64 = buf[i2] as i64
339 let i3: i64 = i + 3
340 let c3: i64 = buf[i3] as i64
341 let i4: i64 = i + 4
342 let c4: i64 = buf[i4] as i64
343 if c0 == 82 && c1 == 85 && c2 == 76 && c3 == 69 && c4 == 124 { isrule = 1 }
344 }
345 if isrule == 1 {
346 let sts: i64 = fc_fstart(buf, i, e, 2)
347 let stm: i64 = fc_fstart(buf, i, e, 4)
348 let stme: i64 = fc_fend(buf, stm, e)
349 if sts >= 0 && stm >= 0 {
350 let sb: i64 = buf[sts] as i64
351 if sb != 82 {
352 var werr2: i64 = 0
353 let w1: i64 = fc_ws(fd, "- " as *u8)
354 werr2 = werr2 + w1
355 let stml: i64 = stme - stm
356 let stmp: *u8 = buf + stm
357 let w2: i64 = fc_wb(fd, stmp, stml)
358 werr2 = werr2 + w2
359 let w3: i64 = fc_ws(fd, "\n" as *u8)
360 werr2 = werr2 + w3
361 if werr2 == 0 { count = count + 1 }
362 }
363 }
364 }
365 i = e + 1
366 }
367 return count
368}
369
370// LOCAL-TIER MINI PACK: condensed prose + statements-only vetted rules + live stdlib sigs +
371// a small lane-verified exemplar. budget = hard byte cap (the serve prompt cap minus task
372// headroom); over-budget returns -11 (fail-closed). Returns emitted SIZE on success.
373func fc_emit_mini(rules_path: *u8, vet_path: *u8, lib_path: *u8, ex_path: *u8, out_path: *u8, budget: i64) -> i64 {
374 let rbuf: *u8 = sys_mmap(K_MAGIC_32768) as *u8
375 let rn: i64 = fc_read(rules_path, rbuf, K_MAGIC_32768)
376 if rn <= 0 {
377 let e2: i64 = 0 - 2
378 return e2
379 }
380 let unv: i64 = fc_has_unverified(rbuf, rn)
381 if unv == 1 {
382 let e3: i64 = 0 - 3
383 return e3
384 }
385 let vbuf: *u8 = sys_mmap(K_MAGIC_32768) as *u8
386 let vn: i64 = fc_read(vet_path, vbuf, K_MAGIC_32768)
387 if vn <= 0 {
388 let e9: i64 = 0 - 9
389 return e9
390 }
391 let lbuf: *u8 = sys_mmap(K_MAGIC_65536) as *u8
392 let ln: i64 = fc_read(lib_path, lbuf, K_MAGIC_65536)
393 if ln <= 0 {
394 let e4: i64 = 0 - 4
395 return e4
396 }
397 let ebuf: *u8 = sys_mmap(K_MAGIC_65536) as *u8
398 let en: i64 = fc_read(ex_path, ebuf, K_MAGIC_65536)
399 if en <= 0 {
400 let e5: i64 = 0 - 5
401 return e5
402 }
403 let fd: i64 = sys_openat_wr(out_path, 420)
404 if fd < 0 {
405 let e6: i64 = 0 - 6
406 return e6
407 }
408 var werr: i64 = 0
409 let h1: i64 = fc_ws(fd, "NISHILANG MINI PACK v1 -- local-tier (organ-emitted by nx_forge_ctx; budget-capped for the serve prompt window). Follow EXACTLY; stay inside the verified subset.\n\n" as *u8)
410 werr = werr + h1
411 let wr: i64 = fc_wb(fd, rbuf, rn)
412 werr = werr + wr
413 let hv1: i64 = fc_ws(fd, "\nHARD RULES (vetted registry, statements only; full WHY in the big pack):\n" as *u8)
414 werr = werr + hv1
415 let nrr: i64 = fc_render_rules_brief(vbuf, vn, fd)
416 if nrr <= 0 {
417 sys_close(fd)
418 let e10: i64 = 0 - 10
419 return e10
420 }
421 let h3: i64 = fc_ws(fd, "\nSOVEREIGN STANDARD LIBRARY (live-extracted; PREFER over redefining):\n" as *u8)
422 werr = werr + h3
423 let sigs: i64 = fc_extract_sigs(lbuf, ln, fd)
424 if sigs <= 0 {
425 sys_close(fd)
426 let e7: i64 = 0 - 7
427 return e7
428 }
429 let h5: i64 = fc_ws(fd, "\nVERIFIED EXEMPLAR (lane-GREEN; reuse the style):\n" as *u8)
430 werr = werr + h5
431 let we: i64 = fc_wb(fd, ebuf, en)
432 werr = werr + we
433 sys_close(fd)
434 if werr < 0 {
435 let e8: i64 = 0 - 8
436 return e8
437 }
438 let chk: *u8 = sys_mmap(K_MAGIC_65536) as *u8
439 let total: i64 = fc_read(out_path, chk, K_MAGIC_65536)
440 if total > budget {
441 let e11: i64 = 0 - 11
442 return e11
443 }
444 return total
445}
446
447// emit the pack: rules verbatim + VETTED HARD RULES rendered from the registry (ACTIVE+GUARD
448// only, each with its measured WHY; RETIRED omitted) + live-extracted stdlib sigs + embedded
449// exemplar (LAST, so the gate can tail-compare). Returns sig count (>0) on success; negative
450// code on any failure: -2 rules unreadable, -3 UNVERIFIED marker (fail-closed), -4 lib
451// unreadable, -5 exemplar unreadable, -6 out unwritable, -7 zero signatures extracted,
452// -8 write error, -9 vet registry unreadable, -10 zero rules rendered, -11 mini over budget.
453func fc_emit(rules_path: *u8, vet_path: *u8, lib_path: *u8, ex_path: *u8, out_path: *u8) -> i64 {
454 let rbuf: *u8 = sys_mmap(K_MAGIC_32768) as *u8
455 let rn: i64 = fc_read(rules_path, rbuf, K_MAGIC_32768)
456 if rn <= 0 {
457 let e2: i64 = 0 - 2
458 return e2
459 }
460 let unv: i64 = fc_has_unverified(rbuf, rn)
461 if unv == 1 {
462 let e3: i64 = 0 - 3
463 return e3
464 }
465 let vbuf: *u8 = sys_mmap(K_MAGIC_32768) as *u8
466 let vn: i64 = fc_read(vet_path, vbuf, K_MAGIC_32768)
467 if vn <= 0 {
468 let e9: i64 = 0 - 9
469 return e9
470 }
471 let lbuf: *u8 = sys_mmap(K_MAGIC_65536) as *u8
472 let ln: i64 = fc_read(lib_path, lbuf, K_MAGIC_65536)
473 if ln <= 0 {
474 let e4: i64 = 0 - 4
475 return e4
476 }
477 let ebuf: *u8 = sys_mmap(K_MAGIC_65536) as *u8
478 let en: i64 = fc_read(ex_path, ebuf, K_MAGIC_65536)
479 if en <= 0 {
480 let e5: i64 = 0 - 5
481 return e5
482 }
483 let fd: i64 = sys_openat_wr(out_path, 420)
484 if fd < 0 {
485 let e6: i64 = 0 - 6
486 return e6
487 }
488 var werr: i64 = 0
489 let h1: i64 = fc_ws(fd, "NISHILANG CODING CONTEXT PACK v1 -- organ-emitted by nx_forge_ctx (rules corpus + stdlib signatures extracted LIVE from the tree + lane-verified exemplar). Follow it EXACTLY; stay inside the verified subset.\n" as *u8)
490 werr = werr + h1
491 let h2: i64 = fc_ws(fd, "====================================================================\n\n" as *u8)
492 werr = werr + h2
493 let wr: i64 = fc_wb(fd, rbuf, rn)
494 werr = werr + wr
495 let hv1: i64 = fc_ws(fd, "\nHARD RULES -- VETTED REGISTRY (rendered live from knowledge/forge/pack_rules_vet_v1.txt; statuses re-measured by nx_pack_rules_vet_gate; RETIRED restrictions omitted -- each rule carries its measured WHY)\n" as *u8)
496 werr = werr + hv1
497 let hv2: i64 = fc_ws(fd, "--------------------------------------------------------------------\n" as *u8)
498 werr = werr + hv2
499 let nrr: i64 = fc_render_rules(vbuf, vn, fd)
500 if nrr <= 0 {
501 sys_close(fd)
502 let e10: i64 = 0 - 10
503 return e10
504 }
505 let h3: i64 = fc_ws(fd, "\nSOVEREIGN STANDARD LIBRARY -- signatures below are extracted LIVE from runtime/nx_lib_std.nx at emit time (gate nx_lib_std_gate GREEN). PREFER these over redefining helpers; import nx_lib_std.nx next to the syscalls import.\n" as *u8)
506 werr = werr + h3
507 let h4: i64 = fc_ws(fd, "--------------------------------------------------------------------\n" as *u8)
508 werr = werr + h4
509 let sigs: i64 = fc_extract_sigs(lbuf, ln, fd)
510 if sigs <= 0 {
511 sys_close(fd)
512 let e7: i64 = 0 - 7
513 return e7
514 }
515 let h5: i64 = fc_ws(fd, "\nVERIFIED EXEMPLAR -- embedded verbatim from runtime/nx_fbench_probe.nx (sovereign-lane GREEN; reuse these helpers freely)\n" as *u8)
516 werr = werr + h5
517 let h6: i64 = fc_ws(fd, "--------------------------------------------------------------------\n" as *u8)
518 werr = werr + h6
519 let we: i64 = fc_wb(fd, ebuf, en)
520 werr = werr + we
521 sys_close(fd)
522 if werr < 0 {
523 let e8: i64 = 0 - 8
524 return e8
525 }
526 return sigs
527}