code wiki / _hdl_build / nx_product_decompose.nx
nx_product_decompose.nx source
↩ module page · 138 lines · 6507 B
1// nx_product_decompose.nx v2 -- PRODUCT decomposition (name-an-outcome -> required capabilities -> gaps) over
2// the real design-to-market NEEDS + CAPABILITIES planes, WITH persistence: writes the coverage/gap result to a
3// decompose- plane (the atlas-out compounding loop -- results bank back for the F208 opportunity feeder). Each
4// need matched to a fulfilling capability by name-in-note substring; needs with none = unproven-opportunity GAPS.
5// usage: nx_product_decompose [needs-prefix] [caps-prefix] [out-prefix] license_tier: ORIGINAL expect_exit:0
6import "nx_store_seed_lib.nx"
7import "nx_seg_store.nx"
8import "nx_syscalls.nx"
9const PD_MAGIC_1024: i64 = 1024
10
11const PD_CAP: i64 = 262144
12const PD_NL: i64 = 10
13const PD_TAB: i64 = 9
14const PD_MAXCOL: i64 = 16
15const PD_MAXROW: i64 = 64
16const PD_STDERR: i64 = 2
17const CT_NOTE: i64 = 6
18
19func pd_slen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
20func pd_werr(s: *u8) -> i64 { sys_write(PD_STDERR, s, pd_slen(s)); return 0 }
21func pd_w(s: *u8) -> i64 { sys_write(1, s, pd_slen(s)); return 0 }
22func pd_wn(v: i64) -> i64 { let b: *u8 = sys_mmap(24); var m: i64 = v; if m < 0 { sys_write(1, "-" as *u8, 1); m = 0 - m } let t: *u8 = sys_mmap(24); 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 j: i64 = 0; while j < k { b[j] = t[k-1-j]; j = j + 1 } sys_write(1, b, k); return 0 }
23func pd_wslice(q: *u8, a: i64, b: i64) -> i64 { let buf: *u8 = sys_mmap(PD_MAGIC_1024); var n: i64 = 0; var i: i64 = a; while i < b { if n < PD_MAGIC_1024 { buf[n] = q[i]; n = n + 1 } i = i + 1 } if n > 0 { sys_write(1, buf, n) } return 0 }
24func pd_cat(dst: *u8, o: i64, src: *u8, a: i64, b: i64) -> i64 { var oo: i64 = o; var i: i64 = a; while i < b { dst[oo] = src[i]; oo = oo + 1; i = i + 1 } return oo }
25func pd_cols(q: *u8, ls: i64, le: i64, sp: *i64) -> i64 {
26 var c: i64 = 0
27 var p: i64 = ls
28 while c < PD_MAXCOL {
29 var e: i64 = p
30 var s: i64 = 1
31 while s == 1 { if e >= le { s = 0 } else { if q[e] == (PD_TAB as u8) { s = 0 } else { e = e + 1 } } }
32 sp[c*2] = p
33 sp[c*2+1] = e
34 c = c + 1
35 if e >= le { return c }
36 p = e + 1
37 }
38 return c
39}
40func pd_has_sub(q: *u8, a: i64, b: i64, w: *u8, wl: i64) -> i64 {
41 if wl < 3 { return 0 }
42 var i: i64 = a
43 while i + wl <= b {
44 var m: i64 = 1
45 var j: i64 = 0
46 while j < wl { if q[i+j] != w[j] { m = 0; j = wl } else { j = j + 1 } }
47 if m == 1 { return 1 }
48 i = i + 1
49 }
50 return 0
51}
52func pd_parse(buf: *u8, n: i64, na: *i64, nb: *i64, ta: *i64, tb: *i64) -> i64 {
53 let sp: *i64 = sys_mmap(PD_MAXCOL*2*8) as *i64
54 var rc: i64 = 0
55 var i: i64 = 0
56 while i < n {
57 var le: i64 = i
58 var s: i64 = 1
59 while s == 1 { if le >= n { s = 0 } else { if buf[le] == (PD_NL as u8) { s = 0 } else { le = le + 1 } } }
60 if le > i { if rc < PD_MAXROW {
61 let nc: i64 = pd_cols(buf, i, le, sp)
62 if nc >= 1 {
63 na[rc] = sp[0]
64 nb[rc] = sp[1]
65 if nc > CT_NOTE { ta[rc] = sp[CT_NOTE*2]; tb[rc] = sp[CT_NOTE*2+1] } else { ta[rc] = sp[0]; tb[rc] = sp[1] }
66 rc = rc + 1
67 }
68 } }
69 i = le + 1
70 }
71 return rc
72}
73
74func main(argc: i64, argv: *i64) -> i64 {
75 var needsp: *u8 = "knowledge/store/dmktneeds-" as *u8
76 var capsp: *u8 = "knowledge/store/dmktcap-" as *u8
77 var outp: *u8 = "knowledge/store/decompose-" as *u8
78 if argc > 1 { needsp = argv[1] as *u8 }
79 if argc > 2 { capsp = argv[2] as *u8 }
80 if argc > 3 { outp = argv[3] as *u8 }
81 let nbuf: *u8 = sys_mmap(PD_CAP)
82 let nn: i64 = sts_load(needsp, nbuf, PD_CAP)
83 if nn <= 0 { pd_werr("needs plane EMPTY (fail-closed)\n" as *u8); sys_exit(1); return 1 }
84 let cbuf: *u8 = sys_mmap(PD_CAP)
85 let cnn: i64 = sts_load(capsp, cbuf, PD_CAP)
86 if cnn <= 0 { pd_werr("caps plane EMPTY (fail-closed)\n" as *u8); sys_exit(1); return 1 }
87 let nna: *i64 = sys_mmap(PD_MAXROW*8) as *i64
88 let nnb: *i64 = sys_mmap(PD_MAXROW*8) as *i64
89 let nta: *i64 = sys_mmap(PD_MAXROW*8) as *i64
90 let ntb: *i64 = sys_mmap(PD_MAXROW*8) as *i64
91 let nrows: i64 = pd_parse(nbuf, nn, nna, nnb, nta, ntb)
92 let cna: *i64 = sys_mmap(PD_MAXROW*8) as *i64
93 let cnb: *i64 = sys_mmap(PD_MAXROW*8) as *i64
94 let cta: *i64 = sys_mmap(PD_MAXROW*8) as *i64
95 let ctb: *i64 = sys_mmap(PD_MAXROW*8) as *i64
96 let crows: i64 = pd_parse(cbuf, cnn, cna, cnb, cta, ctb)
97 pd_w("=== nx_product_decompose v2: name-an-outcome -> required capabilities -> gaps (persisted) ===\n" as *u8)
98 pd_w("needs=" as *u8); pd_wn(nrows); pd_w(" capabilities=" as *u8); pd_wn(crows); pd_w("\n" as *u8)
99 let obuf: *u8 = sys_mmap(PD_CAP)
100 var oo: i64 = 0
101 let nmb: *u8 = sys_mmap(256)
102 var covered: i64 = 0
103 var gaps: i64 = 0
104 var i: i64 = 0
105 while i < nrows {
106 var nml: i64 = 0
107 var kk: i64 = nna[i]
108 while kk < nnb[i] { if nml < 255 { nmb[nml] = nbuf[kk]; nml = nml + 1 } kk = kk + 1 }
109 var hit: i64 = 0 - 1
110 var j: i64 = 0
111 while j < crows {
112 if hit < 0 { if pd_has_sub(cbuf, cta[j], ctb[j], nmb, nml) == 1 { hit = j } }
113 j = j + 1
114 }
115 oo = ss_cat(obuf, oo, "need-" as *u8)
116 oo = pd_cat(obuf, oo, nbuf, nna[i], nnb[i])
117 obuf[oo] = PD_TAB as u8; oo = oo + 1
118 oo = pd_cat(obuf, oo, nbuf, nna[i], nnb[i])
119 obuf[oo] = PD_TAB as u8; oo = oo + 1
120 pd_w("NEED " as *u8); pd_wslice(nbuf, nna[i], nnb[i])
121 if hit >= 0 {
122 pd_w(" -> FULFILLED by " as *u8); pd_wslice(cbuf, cna[hit], cnb[hit]); pd_w("\n" as *u8)
123 oo = ss_cat(obuf, oo, "FULFILLED\tproduct\t" as *u8)
124 oo = pd_cat(obuf, oo, cbuf, cna[hit], cnb[hit])
125 covered = covered + 1
126 } else {
127 pd_w(" -> GAP: no capability yet (unproven-opportunity to build)\n" as *u8)
128 oo = ss_cat(obuf, oo, "GAP\tproduct\tunproven-opportunity-build-next" as *u8)
129 gaps = gaps + 1
130 }
131 obuf[oo] = PD_NL as u8; oo = oo + 1
132 i = i + 1
133 }
134 if sts_seed(outp, obuf, oo) < 0 { pd_werr("decompose plane commit error\n" as *u8) }
135 pd_w("COVERAGE covered=" as *u8); pd_wn(covered); pd_w("/" as *u8); pd_wn(nrows); pd_w(" gaps=" as *u8); pd_wn(gaps); pd_w(" -> persisted to the decompose- plane (atlas-out loop)\n" as *u8)
136 sys_exit(0)
137 return 0
138}