Hojun-Cho/ww
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

lib/regex: fold-2b tranche C — search (first end-to-end match)

Browse Source 
Port of search (ref/hare/regex/regex.ha:746-898) per the drew §9c
map: the thread-machine driver over bufio.scanrune — per-rune
dispatch, all_matched best-pick (leftmost-longest), need_captures
early-exit, first-match leftmost trim, same-pc dedup, failed sweep.
compile()'s literal programs now match end to end; test/find (the
exec surface) ride tranche D behind the C6 multi-success `?` gate.

Spelling divergences, each documented at site with its ha cite:
io::handle param → io.stream; alloc([thread{...}])? → decl + append;
defer-block cleanup omitted (single-expr defer, no-op frees, #27);
rep_counters prefill → ratified loud n_reps>0 abort (no 2b program
can set it); newscanner default maxread → types.I32_MAX; scanrune
nomem arm dropped (no such member) and multi-type arms split (#13);
`return [];` → bind-first zero header (#25/#31 ruling); `result`
internals spelled []capture (#20/#38 alias family — reverts with
#47); ha:820's indexed capture spread loud-bounded provably-empty
(#35); `&..` by-ref ranges → index loops; the ha:821 sized
fill-append → count loop (self-activates with the group fold).

Two checker findings surfaced mid-port, probe-isolated, dodged at
site and FILED: #51 (cs≠ww — the cstage checker types a
match-EXPRESSION by its first arm's yield and rejects the io.eof
arm against rune; w6c_ww accepts the expression form and emits
runtime-correct code, review-verified on scratch/r51.ww), so the
scanrune receive is a statement match assigning into a pre-declared
(rune | io.eof); #52 (cs≠ww, wwstage only) — a same-name let in a
CLOSED sibling scope poisons a later for-init rhs (`let j: i64 =
i + 1` resolves i against the dead `let i: size`), so the ha:872
dedup counters are di/dj at site (scratch probes p51/p51b/c/d
isolate the trigger and prove the rename byte-identical).

add_thread's dedup bound reverts to len(*threads) — the FB1/#41
dodge, fix landed at 796d41b. Imports grow bufio + types.

regex_test: +3 @test fns (signalled 20-22) driving private search
directly over memio.fixed streams. search_matches = 6 struct-row
table rows: full match mid-string, mismatch-restart bcd/abcd,
leftmost-longest aa/aaa, zero-length ""/"" (the all_matched path
with matchlen 0 must NOT take the need_captures=false early-exit),
multibyte b.d over "aßbxd" (root 2/3..5/6 — every idx differs from
its bytesize), dedup-heavy aa/aaaa (stable across >=3 same-pc
passes). search_early_exit pins ha:845-847 (empty result, len 0);
search_no_match pins thread-drain void + EOF-mid-pattern void.
Every match row checks all four root indices plus content and
result_frees its result (including the early-exit empty one).

Coverage limit, mutation-verified and documented at the dedup row:
in 2a's fixed-length program space every match ties on match_len,
so the leftmost trim (ha:860-866) and the dedup sweep (ha:872-889)
are result-invisible — disabling either still passes the table;
disabling the failed sweep hangs (caught). Both turn result- and
termination-visible with the split/star fold; result stability is
the only external pin available today (threads is search-local).

Both drivers run the fixture exit 0; w6c vs w6c_ww on the
regenerated combined are byte-identical (FC0). PC1-PC4 + P12 probed
at base; PC2's blocker fix is the separate #49 commit (c34a48a).
This commit is contained in:
Hojun-Cho
2026-06-04 14:51:49 +09:00
parent c34a48a81f
commit 6160277098
2 changed files with 365 additions and 17 deletions
Download Patch File Download Diff File Expand all files Collapse all files

134
lib/regex/regex_test.ww
View File

@@ -1,8 +1,9 @@
// regex_test — exercises the lib/regex fold-1 data model (the type
// model + finish()), the fold-2a compile() literal core, and the
// model + finish()), the fold-2a compile() literal core, the
// fold-2b tranche-A/B thread machine (thread/newmatch + result_free
// + strerror; delete_thread/is_consuming_inst/add_thread/run_thread;
// search and the exec surface are deferred — see regex.ww). Run with
// + strerror; delete_thread/is_consuming_inst/add_thread/run_thread),
// and the tranche-C search end-to-end matches (the exec surface
// test/find is tranche D — see regex.ww). Run with
// `out/bin/ww run lib/regex/regex_test.ww`.
//
// Private symbols (thread, newmatch) are reached unqualified: this
@@ -31,6 +32,7 @@ package regex;
import regex;
import io;
import memio;
import os;
import strings;
@@ -664,6 +666,129 @@ fn ic_one(v: regex.inst, want: bool) void = {
if (ts2[0].root_capture.end != (0: size)) { fail(); };
};
// search (regex.ha:746-898) driven DIRECTLY (private fn, package-regex
// test) over memio-backed streams — the exec surface (test/find) is
// tranche D. Each match row pins the root capture's four indices plus
// content; the multibyte row keeps idx != bytesize honest. Rows share
// (expr, input, need_captures, want) shape — the P12 struct-row table.
type scase = struct {
expr: str,
input: str,
nc: bool,
start: size,
sb: size,
end: size,
eb: size,
content: str,
};
@test fn search_matches() void = {
let rows: [6]scase = [
// full match mid-string: skip-respawn + dispatch +
// all_matched exit
scase { expr = "ab", input = "xab", nc = true,
start = 1, sb = 1, end = 3, eb = 3, content = "ab" },
// mismatch-restart: the idx-0 child fails and is swept; the
// restarted thread wins (failed-sweep interplay)
scase { expr = "bcd", input = "abcd", nc = true,
start = 1, sb = 1, end = 4, eb = 4, content = "bcd" },
// leftmost-longest best-pick + first_match_idx trim
scase { expr = "aa", input = "aaa", nc = true,
start = 0, sb = 0, end = 2, eb = 2, content = "aa" },
// zero-length: the all_matched path with matchlen 0 must
// NOT take the need_captures=false early-exit (ha:845
// requires matchlen > 0) — hence nc=false expecting the
// FULL one-capture result, not the empty early-exit slice
scase { expr = "", input = "", nc = false,
start = 0, sb = 0, end = 0, eb = 0, content = "" },
// multibyte: the 2-byte ß before the match start splits
// every idx from its bytesize; inst_any consumes 'x'
scase { expr = "b.d", input = "aßbxd", nc = true,
start = 2, sb = 3, end = 5, eb = 6, content = "bxd" },
// dedup-heavy: same-pc threads spawn on every step across
// >=3 passes (ha:872-889); the pick must stay stable.
// Result stability is the only external pin available this
// fold: 2a programs are all fixed-length, every match ties
// on match_len, and best-pick's insertion-order tiebreak
// alone yields leftmost — so the dedup sweep and the
// leftmost trim are result-invisible (mutation-verified:
// disabling either still passes this table; disabling the
// failed sweep hangs). Both turn result- and
// termination-visible with the split/star fold.
scase { expr = "aa", input = "aaaa", nc = true,
start = 0, sb = 0, end = 2, eb = 2, content = "aa" },
];
let i: i32 = 0;
for (i < len(rows)) {
let ex: str = rows[i].expr;
let inp: str = rows[i].input;
let c: (regex.regex | regex.error | nomem) = regex.compile(ex);
match (c) {
case let re: regex.regex => {
let strm: memio.stream =
memio.fixed(strings.toutf8(inp));
let r: (void | []capture | nomem) =
search(&re, inp, &strm.vt, rows[i].nc);
if (!(r is []capture)) { fail(); };
let caps: []capture = r as []capture;
if (len(caps) != 1) { fail(); };
if (caps[0].start != rows[i].start) { fail(); };
if (caps[0].start_bytesize != rows[i].sb) { fail(); };
if (caps[0].end != rows[i].end) { fail(); };
if (caps[0].end_bytesize != rows[i].eb) { fail(); };
let wc: str = rows[i].content;
if (strings.compare(caps[0].content, wc) != 0) {
fail();
};
regex.result_free(caps);
regex.finish(&re);
};
case => fail();
};
i += 1;
};
};
// ha:845-847: a non-zero-length newmatch with need_captures=false
// returns the empty result immediately, skipping the best-pick pass.
@test fn search_early_exit() void = {
let c: (regex.regex | regex.error | nomem) = regex.compile("ab");
match (c) {
case let re: regex.regex => {
let strm: memio.stream = memio.fixed(strings.toutf8("xab"));
let r: (void | []capture | nomem) =
search(&re, "xab", &strm.vt, false);
if (!(r is []capture)) { fail(); };
let caps: []capture = r as []capture;
if (len(caps) != 0) { fail(); };
regex.result_free(caps);
regex.finish(&re);
};
case => fail();
};
};
// void rows: no match anywhere ("ab" over "xyz" — every thread fails,
// the list drains, ha:777-779) and EOF mid-pattern ("ab" over "a" —
// the consuming-inst EOF fail).
@test fn search_no_match() void = {
let c: (regex.regex | regex.error | nomem) = regex.compile("ab");
match (c) {
case let re: regex.regex => {
let strm: memio.stream = memio.fixed(strings.toutf8("xyz"));
let r: (void | []capture | nomem) =
search(&re, "xyz", &strm.vt, true);
if (!(r is void)) { fail(); };
let strm2: memio.stream = memio.fixed(strings.toutf8("a"));
let r2: (void | []capture | nomem) =
search(&re, "a", &strm2.vt, true);
if (!(r2 is void)) { fail(); };
regex.finish(&re);
};
case => fail();
};
};
export fn main() i32 = {
signalled = 1; lit_and_match();
signalled = 2; size_aliases_distinct();
@@ -684,5 +809,8 @@ export fn main() i32 = {
signalled = 17; add_thread_dedup_inherit();
signalled = 18; run_thread_literal_program();
signalled = 19; run_thread_anchored_route();
signalled = 20; search_matches();
signalled = 21; search_early_exit();
signalled = 22; search_no_match();
return 0;
};