From 3c7f1aa02791d7810dafd12b0cb3b8f9aba2ae6b Mon Sep 17 00:00:00 2001 From: Hojun-Cho Date: Mon, 8 Jun 2026 11:47:43 +0900 Subject: [PATCH] =?UTF-8?q?lib/path:=20#138=20c3-posix=20dirname/basename?= =?UTF-8?q?=20=E2=80=94=20faithful=20posix.ha=20port,=20table-driven=20@te?= =?UTF-8?q?st=20(cstage)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit dirname/basename ported verbatim from ref/hare/path/posix.ha:17,37, re-routing Hare's byte scanning to bytes.rtrim/rindex. Additive to the c2-stack buffer core; no harness/Makefile/module-const changes. Work-var renamed path->p to avoid Hare's param-shadowing `let path = toutf8(path)`: ww's cgen N_LET prepends the new local into the name-keyed localfind chain BEFORE the init is emitted, so the shadow-init reads the fresh uninit slot — a silent miscompile, both-wrong-identical, filed #152 and fixed independently next. drew ruled path->p a permanent acceptable spelling (internal work-var, not API surface; avoids a param-shadow footgun; not a rule-7 workaround). WHY-comment + #152 pointer at both sites. Tests: 10-row dirname/basename table (posix.ha:51-71 verbatim) — root, no-sep, empty, trailing-sep, multi-sep all covered, expecteds traced. C-first: cstage @test green; the str-view-vs-literal rows are #146-deferred (wwstage byte-id, rides #125). Gate: all 324 passed, byte-id 990-997 green, w6c/w6c_ww unchanged (lib-only additive). --- lib/path/path.ww | 53 ++++++++++++++++++++++++++++++++++++++++++-- lib/path/pathtest.ww | 34 ++++++++++++++++++++++++++++ 2 files changed, 85 insertions(+), 2 deletions(-) diff --git a/lib/path/path.ww b/lib/path/path.ww index b1f1c2fe..4fdeec50 100644 --- a/lib/path/path.ww +++ b/lib/path/path.ww @@ -1,8 +1,9 @@ // path — filesystem path manipulation. UTF-8 paths, '/' separator. // Mirrors Hare's path:: surface (ref/hare/path/). This is the // path::buffer stack-buffer port (c2-stack subset: error/posix defs + -// buffer + isroot + appendlit + appendnorm + push + string + set). -// init/abs/dirname/basename and the rest land in later folds. +// buffer + isroot + appendlit + appendnorm + push + string + set) plus +// the c3-posix subset (dirname + basename, ref/hare/path/posix.ha). +// init/abs and the rest land in later folds. package path; @@ -137,3 +138,51 @@ export fn set(buf: *buffer, items: str...) (str | error) = { buf.end = 0; return push(buf, items...); }; + +// ---- POSIX jail (ref/hare/path/posix.ha) ------------------------------ +// POSIX-compliant dirname/basename. They do NOT normalize the input and +// operate on plain str (no buffer), so they sit apart from the stack +// paradigm above — same POSIX-complaint as posix.ha:7-11. + +// ref/hare/path/posix.ha:17. Does *not* normalize; the return is either a +// literal ("."/sepstr) or a borrowed view of the input. Div: toutf8 stays +// strings.toutf8; len(path)→path.len; fromutf8_unsafe→strings.frombytes +// (rule-9 carve-out); rindex z:size→i32; reslice `[..z]`→`[0:z]` (div #4). +// Div: Hare shadows the param (`let path = strings::toutf8(path)`); ww's +// new `let` binding is in scope for its OWN initializer, so the shadow +// reads the uninitialized local — work var renamed `p` (cstage self-init +// scope bug, #152). +export fn dirname(path: str) str = { + let p: []u8 = strings.toutf8(path); + if (p.len == 0) { return "."; }; + + p = bytes.rtrim(p, SEP); + if (p.len == 0) { return sepstr; }; + + match (bytes.rindex(p, SEP)) { + case void => { return "."; }; + case let z: i32 => { p = p[0:z]; }; + }; + p = bytes.rtrim(p, SEP); + + if (p.len == 0) { return sepstr; }; + return strings.frombytes(p); +}; + +// ref/hare/path/posix.ha:37. Does *not* normalize; the return is a +// borrowed view of the input. Div: as dirname (incl. param-shadow rename +// to `p`, #152); reslice `[z+1..]`→`[z+1:]` (div #4); empty-match no-op +// arm spelled `case void => void;` (bytes.ww:130 precedent). +export fn basename(path: str) str = { + let p: []u8 = strings.toutf8(path); + if (p.len == 0) { return "."; }; + + p = bytes.rtrim(p, SEP); + if (p.len == 0) { return sepstr; }; + + match (bytes.rindex(p, SEP)) { + case void => void; + case let z: i32 => { p = p[z+1:]; }; + }; + return strings.frombytes(p); +}; diff --git a/lib/path/pathtest.ww b/lib/path/pathtest.ww index 91d338c1..905d6bfc 100644 --- a/lib/path/pathtest.ww +++ b/lib/path/pathtest.ww @@ -115,9 +115,43 @@ fn fail() void = { os.exit(signalled + 10); }; if (string(&buf) != "foo") { fail(); }; }; +// ---- dirname() / basename() ------------------------------------------- +// ref/hare/path/posix.ha:51-71. Hare seeds each row through _local/local() +// for cross-platform SEP; on ww (Linux, SEP='/') that is identity, so the +// raw str literals stand in directly (local/_local defer to c3). POSIX +// dirname/basename do NOT normalize the input (posix.ha:14-15,35), so no +// seeding is needed. Parallel `[N]str` rows (cgen chained-field gap, as +// above). Rows whose expected is a borrowed VIEW (not a "."/"/" literal) +// compare a computed str to a literal — cstage-correct; wwstage mis- +// compares via #146 (str== over a frombytes result), and this @test is +// cstage-gated, so those rows are #146-deferred on wwstage only. + +@test fn dirname_basename_cases() void = { + let inputs: [10]str; + let wantdir: [10]str; + let wantbase: [10]str; + inputs[0]="usr"; wantdir[0]="."; wantbase[0]="usr"; + inputs[1]="usr/"; wantdir[1]="."; wantbase[1]="usr"; + inputs[2]=""; wantdir[2]="."; wantbase[2]="."; + inputs[3]="/"; wantdir[3]="/"; wantbase[3]="/"; + inputs[4]="//"; wantdir[4]="/"; wantbase[4]="/"; // impl-defined + inputs[5]="///"; wantdir[5]="/"; wantbase[5]="/"; + inputs[6]="/usr/"; wantdir[6]="/"; wantbase[6]="usr"; + inputs[7]="/usr/lib"; wantdir[7]="/usr"; wantbase[7]="lib"; + inputs[8]="//usr//lib//"; wantdir[8]="//usr"; wantbase[8]="lib"; + inputs[9]="/home//dwc//test"; wantdir[9]="/home//dwc"; wantbase[9]="test"; + let i: i32 = 0; + for (i < 10) { + if (dirname(inputs[i]) != wantdir[i]) { fail(); }; + if (basename(inputs[i]) != wantbase[i]) { fail(); }; + i += 1; + }; +}; + export fn main() i32 = { signalled = 1; push_cases(); signalled = 2; isroot_cases(); signalled = 3; string_cases(); + signalled = 4; dirname_basename_cases(); return 0; };