code wiki / _hdl_build / nx_map_remove_func.nx
nx_map_remove_func.nx source
↩ module page · 244 lines · 10695 B
1// nx_map_remove_func.nx -- VARIANT-AGNOSTIC full-scale delegation. For each consumer in a list: find a top-level
2// func by NAME, extract its OWN body (funcmine BOL rule: `func<name>(` -> next `func ` at BOL), REMOVE it, and
3// ensure a shared-lib import is present. Because it reads each consumer's own body, ONE run handles ALL formatting
4// variants of a helper (exact-block matching cannot). SAFE: edits only where the def occurs EXACTLY ONCE and the
5// import anchor occurs exactly once; else SKIP untouched. license_tier: ORIGINAL No hw writes (Rule 26).
6import "nx_seat_drive_lib.nx"
7import "nx_deploy_lib.nx"
8import "nx_ge_str_lib.nx"
9import "nx_syscalls.nx"
10
11const MR_CAP: i64 = 1048576
12const MR_LIST: i64 = 131072
13const MR_PATH: i64 = 1024
14const MR_BAKBUF: i64 = 2048
15
16func mr_slen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
17
18func mr_find_bol(buf: *u8, n: i64, pat: *u8, pl: i64) -> i64 {
19 var i: i64 = 0
20 var bol: i64 = 1
21 while i < n {
22 if bol == 1 {
23 var m: i64 = 1
24 var k: i64 = 0
25 while k < pl { if i + k >= n { m = 0; k = pl } else { if buf[i+k] != pat[k] { m = 0; k = pl } else { k = k + 1 } } }
26 if m == 1 { return i }
27 }
28 if buf[i] == (10 as u8) { bol = 1 } else { bol = 0 }
29 i = i + 1
30 }
31 return 0 - 1
32}
33func mr_count_bol(buf: *u8, n: i64, pat: *u8, pl: i64) -> i64 {
34 var c: i64 = 0
35 var i: i64 = 0
36 var bol: i64 = 1
37 while i < n {
38 if bol == 1 {
39 var m: i64 = 1
40 var k: i64 = 0
41 while k < pl { if i + k >= n { m = 0; k = pl } else { if buf[i+k] != pat[k] { m = 0; k = pl } else { k = k + 1 } } }
42 if m == 1 { c = c + 1 }
43 }
44 if buf[i] == (10 as u8) { bol = 1 } else { bol = 0 }
45 i = i + 1
46 }
47 return c
48}
49func mr_next_func(buf: *u8, n: i64, from: i64) -> i64 {
50 var i: i64 = from
51 var bol: i64 = 0
52 while i < n {
53 if bol == 1 {
54 var m: i64 = 1
55 if i + 5 > n { m = 0 }
56 if m == 1 { if buf[i] != (102 as u8) { m = 0 } }
57 if m == 1 { if buf[i+1] != (117 as u8) { m = 0 } }
58 if m == 1 { if buf[i+2] != (110 as u8) { m = 0 } }
59 if m == 1 { if buf[i+3] != (99 as u8) { m = 0 } }
60 if m == 1 { if buf[i+4] != (32 as u8) { m = 0 } }
61 if m == 1 { return i }
62 }
63 if buf[i] == (10 as u8) { bol = 1 } else { bol = 0 }
64 i = i + 1
65 }
66 return n
67}
68func mr_first_import(buf: *u8, n: i64) -> i64 {
69 var i: i64 = 0
70 var bol: i64 = 1
71 while i < n {
72 if bol == 1 {
73 var m: i64 = 1
74 if i + 7 > n { m = 0 }
75 if m == 1 { if buf[i] != (105 as u8) { m = 0 } }
76 if m == 1 { if buf[i+1] != (109 as u8) { m = 0 } }
77 if m == 1 { if buf[i+2] != (112 as u8) { m = 0 } }
78 if m == 1 { if buf[i+3] != (111 as u8) { m = 0 } }
79 if m == 1 { if buf[i+4] != (114 as u8) { m = 0 } }
80 if m == 1 { if buf[i+5] != (116 as u8) { m = 0 } }
81 if m == 1 { if buf[i+6] != (32 as u8) { m = 0 } }
82 if m == 1 {
83 var e: i64 = i
84 while e < n { if buf[e] == (10 as u8) { return e } e = e + 1 }
85 return n
86 }
87 }
88 if buf[i] == (10 as u8) { bol = 1 } else { bol = 0 }
89 i = i + 1
90 }
91 return 0 - 1
92}
93func mr_norm(src: *u8, s: i64, e: i64, dst: *u8) -> i64 {
94 var w: i64 = 0
95 var i: i64 = s
96 while i < e {
97 let c: i64 = src[i] as i64
98 if c != 32 { if c != 9 { if c != 10 { if c != 13 { dst[w] = src[i]; w = w + 1 } } } }
99 i = i + 1
100 }
101 return w
102}
103func mr_eqbytes(a: *u8, alen: i64, b: *u8, blen: i64) -> i64 {
104 if alen != blen { return 0 }
105 var i: i64 = 0
106 while i < alen { if a[i] != b[i] { return 0 } i = i + 1 }
107 return 1
108}
109func mr_backup(path: *u8, buf: *u8, n: i64) -> i64 {
110 let bakbuf: *u8 = sys_mmap(MR_BAKBUF)
111 var i: i64 = 0
112 while path[i] != (0 as u8) { bakbuf[i] = path[i]; i = i + 1 }
113 let suf: *u8 = ".bak-predelegate" as *u8
114 var j: i64 = 0
115 while suf[j] != (0 as u8) { bakbuf[i] = suf[j]; i = i + 1; j = j + 1 }
116 bakbuf[i] = 0 as u8
117 let ex: i64 = sys_openat_rd(bakbuf)
118 if ex >= 0 { return 0 }
119 return dp_writefile(bakbuf, buf, n)
120}
121func mr_is_firmware(buf: *u8, n: i64) -> i64 {
122 if ge_find(buf, n, "brick" as *u8, 5, 0) >= 0 { return 1 }
123 if ge_find(buf, n, "BRICK" as *u8, 5, 0) >= 0 { return 1 }
124 if ge_find(buf, n, "vBIOS" as *u8, 5, 0) >= 0 { return 1 }
125 if ge_find(buf, n, "EEPROM" as *u8, 6, 0) >= 0 { return 1 }
126 if ge_find(buf, n, "firmware" as *u8, 8, 0) >= 0 { return 1 }
127 if ge_find(buf, n, "Firmware" as *u8, 8, 0) >= 0 { return 1 }
128 if ge_find(buf, n, "CMOS" as *u8, 4, 0) >= 0 { return 1 }
129 if ge_find(buf, n, "UEFI" as *u8, 4, 0) >= 0 { return 1 }
130 return 0
131}
132func mr_one(path: *u8, pat: *u8, pl: i64, imp: *u8, in2: i64, libnorm: *u8, libnlen: i64, check: i64, mode: i64, work: *u8, out: *u8, lnbuf: *u8) -> i64 {
133 let n: i64 = dp_read(path, work, MR_CAP)
134 if n <= 0 { return 0 }
135 if mr_is_firmware(work, n) == 1 { return 3 }
136 if mr_count_bol(work, n, pat, pl) != 1 { return 0 }
137 let fp: i64 = mr_find_bol(work, n, pat, pl)
138 let be: i64 = mr_next_func(work, n, fp + pl)
139 let has_imp: i64 = ge_find(work, n, imp, in2, 0)
140 // deadshadow mode: ONLY files already importing the lib qualify -- their local NAME is DEAD
141 // (import overrides a same-name local: proven by nx_shadow_probe AND DEC020's controlled test),
142 // so removal is behaviour-preserving regardless of body; body-compare applies in normal mode only.
143 if mode == 1 { if has_imp < 0 { return 0 } }
144 if mode == 0 { if check == 1 {
145 let lnlen: i64 = mr_norm(work, fp, be, lnbuf)
146 if mr_eqbytes(lnbuf, lnlen, libnorm, libnlen) == 0 { return 2 }
147 } }
148 if has_imp < 0 { if mr_first_import(work, n) < 0 { return 0 } }
149 if mr_backup(path, work, n) < 0 { return 0 - 1 }
150 var o: i64 = 0
151 var i: i64 = 0
152 while i < fp { out[o] = work[i]; o = o + 1; i = i + 1 }
153 var j: i64 = be
154 while j < n { out[o] = work[j]; o = o + 1; j = j + 1 }
155 if has_imp >= 0 {
156 if dp_writefile(path, out, o) < 0 { return 0 - 1 }
157 return 1
158 }
159 let ap: i64 = mr_first_import(out, o)
160 if ap < 0 { return 0 }
161 let insat: i64 = ap
162 var w: i64 = 0
163 var a: i64 = 0
164 while a < insat { work[w] = out[a]; w = w + 1; a = a + 1 }
165 work[w] = 10 as u8; w = w + 1
166 var m2: i64 = 0
167 while m2 < in2 { work[w] = imp[m2]; w = w + 1; m2 = m2 + 1 }
168 var z: i64 = insat
169 while z < o { work[w] = out[z]; w = w + 1; z = z + 1 }
170 if dp_writefile(path, work, w) < 0 { return 0 - 1 }
171 return 1
172}
173func main(argc: i64, argv: *i64) -> i64 {
174 if argc < 4 { sd_w("usage: nx_map_remove_func <listfile> <funcname> <impline> [libpath] [outfile] [deadshadow]\n" as *u8); sys_exit(2); return 2 }
175 var mode: i64 = 0
176 if argc >= 7 { let ms: *u8 = argv[6] as *u8; if ms[0] == (100 as u8) { mode = 1 } } // 'd' = deadshadow
177 let listp: *u8 = argv[1] as *u8
178 let fname: *u8 = argv[2] as *u8
179 let imp: *u8 = argv[3] as *u8
180 if argc >= 6 { let ofd: i64 = sys_openat_wr(argv[5] as *u8, 0x1a4); if ofd >= 0 { sys_dup3(ofd, 1, 0) } }
181 let pat: *u8 = sys_mmap(MR_PATH)
182 var pl: i64 = 0
183 let pre: *u8 = "func " as *u8
184 var i: i64 = 0
185 while pre[i] != (0 as u8) { pat[pl] = pre[i]; pl = pl + 1; i = i + 1 }
186 i = 0
187 while fname[i] != (0 as u8) { pat[pl] = fname[i]; pl = pl + 1; i = i + 1 }
188 pat[pl] = 40 as u8; pl = pl + 1
189 let libnorm: *u8 = sys_mmap(MR_CAP)
190 var libnlen: i64 = 0
191 var check: i64 = 0
192 if argc >= 5 {
193 let libp: *u8 = argv[4] as *u8
194 let libsrc: *u8 = sys_mmap(MR_CAP)
195 let lln: i64 = dp_read(libp, libsrc, MR_CAP)
196 if lln <= 0 { sd_w("NX-MAP-REMOVE-FUNC lib-unreadable\n" as *u8); sys_exit(3); return 3 }
197 let lfp: i64 = mr_find_bol(libsrc, lln, pat, pl)
198 if lfp < 0 { sd_w("NX-MAP-REMOVE-FUNC lib-missing-func\n" as *u8); sys_exit(3); return 3 }
199 let lbe: i64 = mr_next_func(libsrc, lln, lfp + pl)
200 libnlen = mr_norm(libsrc, lfp, lbe, libnorm)
201 check = 1
202 }
203 let in2: i64 = mr_slen(imp)
204 let list: *u8 = sys_mmap(MR_LIST)
205 let ln: i64 = dp_read(listp, list, MR_LIST)
206 let work: *u8 = sys_mmap(MR_CAP)
207 let out: *u8 = sys_mmap(MR_CAP)
208 let lnbuf: *u8 = sys_mmap(MR_CAP)
209 let path: *u8 = sys_mmap(MR_PATH)
210 var edited: i64 = 0
211 var skipped: i64 = 0
212 var variant: i64 = 0
213 var fw: i64 = 0
214 var errs: i64 = 0
215 var p: i64 = 0
216 while p < ln {
217 var le: i64 = p
218 var f: i64 = 1
219 while f == 1 { if le >= ln { f = 0 } else { if list[le] == (10 as u8) { f = 0 } else { le = le + 1 } } }
220 if le > p {
221 var a2: i64 = 0
222 var q: i64 = p
223 while q < le { path[a2] = list[q]; a2 = a2 + 1; q = q + 1 }
224 path[a2] = 0 as u8
225 let r: i64 = mr_one(path, pat, pl, imp, in2, libnorm, libnlen, check, mode, work, out, lnbuf)
226 if r == 1 { edited = edited + 1; sd_w("EDITED " as *u8); sd_w(path); sd_w("\n" as *u8) } else { if r == 2 { variant = variant + 1; sd_w("VARIANT " as *u8); sd_w(path); sd_w("\n" as *u8) } else { if r == 3 { fw = fw + 1; sd_w("FIRMWARE " as *u8); sd_w(path); sd_w("\n" as *u8) } else { if r == 0 { skipped = skipped + 1; sd_w("SKIP " as *u8); sd_w(path); sd_w("\n" as *u8) } else { errs = errs + 1; sd_w("IO-ERR " as *u8); sd_w(path); sd_w("\n" as *u8) } } } }
227 }
228 p = le
229 if p < ln { p = p + 1 }
230 }
231 sd_w("NX-MAP-REMOVE-FUNC edited=" as *u8)
232 let nb: *u8 = sys_mmap(24)
233 sd_num(nb, 0, edited); sd_w(nb)
234 sd_w(" skipped=" as *u8); sd_num(nb, 0, skipped); sd_w(nb)
235 sd_w(" variant=" as *u8); sd_num(nb, 0, variant); sd_w(nb)
236 sd_w(" fw=" as *u8); sd_num(nb, 0, fw); sd_w(nb)
237 sd_w(" errs=" as *u8); sd_num(nb, 0, errs); sd_w(nb); sd_w("\n" as *u8)
238 let sm: *u8 = "NX-MAP-REMOVE-FUNC edited=" as *u8; sys_write(2, sm, mr_slen(sm)); sd_num(nb, 0, edited); sys_write(2, nb, mr_slen(nb))
239 let s2: *u8 = " skipped=" as *u8; sys_write(2, s2, mr_slen(s2)); sd_num(nb, 0, skipped); sys_write(2, nb, mr_slen(nb))
240 let s3: *u8 = " variant=" as *u8; sys_write(2, s3, mr_slen(s3)); sd_num(nb, 0, variant); sys_write(2, nb, mr_slen(nb))
241 let s4: *u8 = " fw=" as *u8; sys_write(2, s4, mr_slen(s4)); sd_num(nb, 0, fw); sys_write(2, nb, mr_slen(nb))
242 let s5: *u8 = " errs=" as *u8; sys_write(2, s5, mr_slen(s5)); sd_num(nb, 0, errs); sys_write(2, nb, mr_slen(nb)); sys_write(2, "\n" as *u8, 1)
243 return 0
244}