nx_map_delegate.nx source

1// nx_map_delegate.nx -- FULL-SCALE delegation conductor: apply the SAME rule-15 delegation (add a lib import 2// + remove a byte-identical helper block) to EVERY consumer in a list, in ONE run. SAFE BY CONSTRUCTION: 3// only edits a file where the block occurs EXACTLY ONCE and the anchor occurs EXACTLY ONCE; else SKIP 4// untouched (a non-matching organ never gets a half-edit / double-definition). Verify the batch by re-running 5// nx_funcmine (the dup group collapses) + compiling a consumer. 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 MD_CAP: i64 = 1048576 12const MD_LIST: i64 = 131072 13const MD_PATH: i64 = 1024 14 15func md_slen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n } 16 17func md_one(path: *u8, block: *u8, bn: i64, anchor: *u8, an: i64, imp: *u8, in2: i64, work: *u8, tmp: *u8) -> i64 { 18 let n: i64 = dp_read(path, work, MD_CAP) 19 if n <= 0 { return 0 } 20 if ge_count(work, n, block, bn) != 1 { return 0 } 21 if ge_count(work, n, anchor, an) != 1 { return 0 } 22 let ap: i64 = ge_find(work, n, anchor, an, 0) 23 let insat: i64 = ap + an 24 var t: i64 = 0 25 var i: i64 = 0 26 while i < insat { tmp[t] = work[i]; t = t + 1; i = i + 1 } 27 tmp[t] = 10 as u8; t = t + 1 28 var m: i64 = 0 29 while m < in2 { tmp[t] = imp[m]; t = t + 1; m = m + 1 } 30 var z: i64 = insat 31 while z < n { tmp[t] = work[z]; t = t + 1; z = z + 1 } 32 let bp: i64 = ge_find(tmp, t, block, bn, 0) 33 if bp < 0 { return 0 } 34 var w: i64 = 0 35 var a: i64 = 0 36 while a < bp { work[w] = tmp[a]; w = w + 1; a = a + 1 } 37 var b: i64 = bp + bn 38 while b < t { work[w] = tmp[b]; w = w + 1; b = b + 1 } 39 if dp_writefile(path, work, w) < 0 { return 0 - 1 } 40 return 1 41} 42 43func main(argc: i64, argv: *i64) -> i64 { 44 if argc < 5 { sd_w("usage: nx_map_delegate <listfile> <blockfile> <anchor> <impline>\n" as *u8); sys_exit(2); return 2 } 45 let listp: *u8 = argv[1] as *u8 46 let blockp: *u8 = argv[2] as *u8 47 let anchor: *u8 = argv[3] as *u8 48 let imp: *u8 = argv[4] as *u8 49 if argc >= 6 { let ofd: i64 = sys_openat_wr(argv[5] as *u8, 0x1a4); if ofd >= 0 { sys_dup3(ofd, 1, 0) } } 50 let an: i64 = md_slen(anchor) 51 let in2: i64 = md_slen(imp) 52 let list: *u8 = sys_mmap(MD_LIST) 53 let ln: i64 = dp_read(listp, list, MD_LIST) 54 if ln <= 0 { sd_w("NX-MAP-DELEGATE list-absent. FIX: <listfile> = one consumer path per line.\n" as *u8); sys_exit(2); return 2 } 55 let block: *u8 = sys_mmap(MD_CAP) 56 let bn: i64 = dp_read(blockp, block, MD_CAP) 57 if bn <= 0 { sd_w("NX-MAP-DELEGATE block-absent. FIX: <blockfile> = the exact helper block to remove.\n" as *u8); sys_exit(2); return 2 } 58 let work: *u8 = sys_mmap(MD_CAP) 59 let tmp: *u8 = sys_mmap(MD_CAP) 60 let path: *u8 = sys_mmap(MD_PATH) 61 var edited: i64 = 0 62 var skipped: i64 = 0 63 var errs: i64 = 0 64 var i: i64 = 0 65 while i < ln { 66 var le: i64 = i 67 var f: i64 = 1 68 while f == 1 { if le >= ln { f = 0 } else { if list[le] == (10 as u8) { f = 0 } else { le = le + 1 } } } 69 if le > i { 70 var aa: i64 = 0 71 var p: i64 = i 72 while p < le { path[aa] = list[p]; aa = aa + 1; p = p + 1 } 73 path[aa] = 0 as u8 74 let r: i64 = md_one(path, block, bn, anchor, an, imp, in2, work, tmp) 75 if r == 1 { edited = edited + 1; sd_w("EDITED " 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) } } 76 } 77 i = le 78 if i < ln { i = i + 1 } 79 } 80 sd_w("NX-MAP-DELEGATE edited=" as *u8) 81 let nb: *u8 = sys_mmap(24) 82 sd_num(nb, 0, edited) 83 sd_w(nb) 84 sd_w(" skipped=" as *u8) 85 sd_num(nb, 0, skipped) 86 sd_w(nb) 87 sd_w(" errs=" as *u8) 88 sd_num(nb, 0, errs) 89 sd_w(nb) 90 sd_w("\n" as *u8) 91 return 0 92}