diff --git a/future/ngra-regex-sourcegen-goldens.md b/future/ngra-regex-sourcegen-goldens.md index ac8cfa77..6d1da1d7 100644 --- a/future/ngra-regex-sourcegen-goldens.md +++ b/future/ngra-regex-sourcegen-goldens.md @@ -34,12 +34,14 @@ ### 正确性核心与纯优化的分界 -- **L2 + L4 + L5 是正确性核心**：region 作用域、单指令主体、前缀装饰三者齐备， - 任意表达式即可端到端生成出语义正确的代码。 -- **L1 与 L3 是纯优化**：它们只把 L2/L4 会生成的嵌套结构压平成更好的代码形状。 - 未实现时必须干净地返回 `-1`，让窗口自然降级，**不得影响正确性**。 +- **L2 + L4 + L5 + L1 的必需项是正确性核心**：region 作用域、单指令主体、前缀装饰 + 三者支撑绝大多数形态；但 `COUNT_COMPLEX` 与 FIND 系（L1.5–L1.9）的 body 不是独立 region， + L2 接不住，没有降级路径，因此同样属于核心。 +- **L1 的压平项（L1.1–L1.4）与 L3 全部是纯优化**：它们只把 L2/L4 会生成的嵌套结构 + 压平成更好的代码形状。未实现时必须干净地返回 `-1`，让窗口自然降级，**不得影响正确性**。 -这条分界决定了实现顺序：先把 L2/L4/L5 打通拿到可运行基线，再回头做 L1/L3。 +这条分界决定了实现顺序：先把 L2/L4/L5 打通拿到可运行基线，再补 L1 的必需项， +最后才是 L1.1–L1.4 与 L3。 ## 记录模板 @@ -79,13 +81,13 @@ IR -> Code 规则: 关注点：region 槽是否必须全量分配、行结果槽能否按 `ObserveSource` 稀疏分配。 -## L1 Region 组合级（纯优化） +## L1 Region 组合级（含必需项） 一次消耗**多个 region + 尾部控制指令**，是窗口消耗量最高的形态。 这些组合在 `EmitPrefix` 里已经被识别过一次 （`TryEmitAltChain` / `TryEmitTryGroupTail` / `TryEmitComplexIR`），生成器应与之一一对应。 -除 L1.5–L1.7 外，本层全部是**代码形状优化**：不实现时窗口会降级到 L2 + L5， +除 L1.5–L1.9 外，本层全部是**代码形状优化**：不实现时窗口会降级到 L2 + L5， 生成出语义等价但嵌套更深的代码。 | # | 触发窗口 | 消耗 | 覆盖样本 | 性质 | 状态 | @@ -96,15 +98,84 @@ IR -> Code 规则: | L1.4 | L1.3 且 region 内部是 ALT 链 | 嵌套 | `(?abcd\|a(bc)c)` | 压平 | [ ] | | L1.5 | `COUNT_COMPLEX` + body | `CommandCount + 1` | `(ab){2,3}` | **必需** | [ ] | | L1.6 | `COUNT_COMPLEX` + body(含 ALT) + 线性后缀 | 嵌套 + 后缀 | `(123(4\|5)67){3,4}114514` | **必需** | [ ] | -| L1.7 | `FIND_COMPLEX` + body | `CommandCount + 1` | `.*(ab\|cd)` | **必需** | [ ] | +| L1.7 | `FIND_COMPLEX`，`CommandCount ≥ 0` | `CommandCount + 1` | `.*(ab\|cd)` | **必需** | [ ] | +| L1.8 | `FIND_COMPLEX`，`CommandCount = -1` | 1 + region 剩余 | `(?.*)234` | **必需** | [ ] | +| L1.9 | `FIND_SEQ` / `FIND_SET` | 1 + region 剩余 | `.*abc` | **必需** | [ ] | 期望代码形状：L1.1/L1.2 压平为 `if / else if / else` 链；L1.3/L1.4 在 region 成功分支写捕获区间； -L1.5–L1.7 为循环 / 搜索包裹 body，`CommandCount` 必须按前缀化后的实际条数重算。 +L1.5/L1.6 为计数循环包裹 body；L1.7–L1.9 为**候选重试循环**包裹 body（见下）。 +`CommandCount` 必须按前缀化后的实际条数重算。 -L1.5–L1.7 标记为必需，是因为 `COUNT_COMPLEX` / `FIND_COMPLEX` 的 body 不是独立 region， -L2 接不住它们，没有替代降级路径。 +L1.5–L1.9 标记为必需，是因为它们的 body 都不是独立 region，L2 接不住，没有替代降级路径。 -关注点：ALT 各 case 之间活动指针如何恢复、`PACK` 取哪一个成功结果作为捕获区间。 +### FIND 系的回溯语义 + +FIND 产出的不是一个位置，是一个**按优先级排序的候选位置序列**： + +- `FURTHEST`（贪婪 `.*`）：从最远候选起，验证失败往**前**退 +- `NEAREST`（惰性 `.*?`）：从最近候选起，验证失败往**后**进 + +body 是候选的**验证器**。验证失败必须取下一个候选重来，候选耗尽才是真失败。 +只做一次 `LastIndexOf` 就判定成败是错的——`.*abcX` 里最后一个 `abc` 后面没有 `X` 时， +必须退到倒数第二个 `abc`。 + +`CommandCount = -1` 的语义已被优化器坐实：`TryReplaceDotStar` 把 `.*` 直接产出 +`FindComplex(-1)`，随后 `TyrMergeFindRestTwice` / `TyrMergeFindRestTry` 尽力把它收敛成确定长度， +收敛不掉的保持 -1，表示「body 是 region 剩余全部」。所以后端只需处理两种 body 长度： +确定值，和 -1。 + +`FIND_SEQ` / `FIND_SET` 没有 `CommandCount` 字段，语义等同 -1。只有当它恰好是 region +最后一条时才退化成单次搜索，此时消耗为 1。 + +期望代码形状： + +```csharp +int __bound = text.Length; +__ok = false; +while (true) +{ + int __at = text[__cur..__bound].LastIndexOf("abc"); + if (__at < 0) { __ok = false; break; } // 候选耗尽，唯一失败出口 + int __save = __cur; + __cur = __cur + __at + 3; + + // ── body / region 剩余指令内联展开在这里 ── + + if (__ok) { break; } // 验证通过 + __cur = __save; + __bound = __save + __at; // 退到前一个候选 +} +``` + +### FIND 与 `POP` 的冲突（必须处理） + +`POP` 编译成 `break` 时跳出的是**最近**一层循环，而 FIND 的 `while` 比 region 的 +`do{}while(false)` 更近。body 里的 `POP` 会跳出重试循环而不是 region，语义直接错。 +不引入 `goto` 的解法是加一个 region 终结标志： + +```csharp +do // region N +{ + bool __rN_done = false; + ... + while (!__rN_done) // find retry + { + // 候选搜索 + do // ← 隔离层，POP 的 break 落在这 + { + // body，POP: __rN_ok = x; __rN_done = true; break; + } while (false); + + if (__rN_done || __ok) { break; } + // 退候选 + } +} while (false); +``` + +关注点：ALT 各 case 之间活动指针如何恢复、`PACK` 取哪一个成功结果作为捕获区间、 +嵌套 FIND 会产生嵌套重试循环（复杂度是候选数的乘积，是灾难性回溯的来源）、 +重试循环内 `__ok` 跨迭代被复写（`Observe_Line` 指向循环体内某条指令时， +读到的是最后一次迭代的值，当前前缀模型没有覆盖这个情形）。 ## L2 Region 级（正确性核心） @@ -133,7 +204,11 @@ __ok = __rN_ok; 失败路径必须把活动指针复位到 region 入口。`POP` 直接编译为 `break`，不引入标签。 -关注点：region 全部内联展开、嵌套 region 的指针复位链、`break` 只能跳出最近一层 `do`。 +**例外**：当 region 内出现 FIND 系指令时，`break` 会被 FIND 的重试循环截获， +必须改用 L1 节里的 `__rN_done` 终结标志方案。 + +关注点：region 全部内联展开、嵌套 region 的指针复位链、`break` 只能跳出最近一层循环 +（`do{}while(false)` 和 FIND 的 `while` 都算）。 ## L3 多指令定式（纯优化） @@ -144,12 +219,13 @@ __ok = __rN_ok; | --- | --- | --- | --- | --- | | L3.1 | `FIND_COMPLEX FURTHEST COUNT:-1` + `PACK` + `MATCH_SEQ` | 3 | `(?.*)234` | [ ] | | L3.2 | 同上，锚点为单字符 | 3 | `(?.*)a` | [ ] | -| L3.3 | `FIND_SEQ` + `MATCH_SEQ`，合并为一次 `IndexOf` | 2 | `.*abc` | [ ] | +| L3.3 | `FIND_SEQ` + `MATCH_SEQ`，把验证器折进搜索模式，消除回溯 | 2 | `.*abc` | [ ] | | L3.4 | `MATCH_SEQ` + `COUNT_SEQ`（`a+`、`a{m,n}` 展开形态） | 2 | `a{3,5}`、`a+` | [ ] | | L3.5 | 连续 `MATCH_SEQ` / `MATCH_SET`，合流为单个 `if` 与表达式 | 2–8 | `a[abc]d` | [ ] | | L3.6 | 尾部 `COUNT_SET .*`，快速成功 | 1–2 | `abc.*` | [ ] | 关注点：合并后失败诊断是否还能定位到原指令、合并是否破坏 `Observe_Line` 的行号引用。 +L3.3 只有在合并后 region 剩余为空时才真正消除回溯，否则 L1.9 的重试循环仍然要保留。 ## L4 单指令级 @@ -164,11 +240,13 @@ __ok = __rN_ok; | L4.5 | `MATCH_SET` 任意字符 | `.` | [ ] | | L4.6 | `COUNT_SEQ` | `a*`、`a?` | [ ] | | L4.7 | `COUNT_SET` | `[abc]*`、`\w+`、`.{11,13}`、`[.]*` | [ ] | -| L4.8 | `FIND_SEQ` | `.*abc` 降级路径 | [ ] | -| L4.9 | `FIND_SET` | — | [ ] | | L4.10 | `POP` | ALT 尾 | [ ] | | L4.11 | `PACK` | `(abc)` 默认序号组 | [ ] | +L4.8 / L4.9 已移出本层。`FIND_SEQ` / `FIND_SET` **不存在单条形态**——它们必须联动 region +剩余部分做候选重试，见 L1.9。只有 FIND 恰好是 region 末条时才退化成一次搜索， +那是 L1.9 的退化分支，不是独立的单指令生成器。编号保留空缺，避免打乱既有引用。 + 关注点：`[.]` 与 `.` 必须走不同后端语义；`[.]*` 不得被当作 `.*` 优化。 ## L5 前缀装饰（横切，消耗 0） @@ -194,7 +272,8 @@ __ok = __rN_ok; ## 实现顺序 -调度链按 L1 → L4 排列，但**实现**先拿正确性核心（L2/L4/L5），再回头填纯优化层（L1/L3）： +调度链按 L1 → L4 排列，但**实现**先拿正确性核心（L2/L4/L5），再补 L1 的必需项， +最后才是压平层（L1.1–L1.4 / L3）： 1. **L0** — 生成的空骨架能通过编译，`TextRegexSourceGen.GenFile` 的两处 TODO 闭合。 2. **L2.1** — `(abc)` 产出正确的 `do{}while(false)` 作用域与复位逻辑。 @@ -202,12 +281,18 @@ __ok = __rN_ok; 4. **L4 全部** — 兜底层补齐，任意线性表达式可端到端生成。 5. **L5.6–L5.9** — 跨行 / 跨 region 观察与提前退出，`a|b` 与 `(?abc)` 自然跑通（嵌套形态）。 **此时获得可运行基线，任何表达式都能生成正确代码。** -6. **L1.5、L1.7** — 复杂计数与复杂搜索，无降级路径，必须实现。 +6. **L1.5、L1.7–L1.9** — 复杂计数与 FIND 系，无降级路径，必须实现。 + FIND 系要连带处理 `POP` 与重试循环的 `break` 冲突。 7. **L1.1–L1.4** — 把 ALT 链与捕获组的嵌套形态压平。 8. **L3 全部** — 代码质量优化，可持续追加。 第一阶段验收口径（沿用原优先级）：`MATCH_SEQ`、`MATCH_SET`、`COUNT_SEQ`、`COUNT_SET`、 -简单 `ALT`、`PACK`、`FIND_SEQ`、`FIND_COMPLEX COUNT:-1` 全部稳定。 +简单 `ALT`、`PACK`、`FIND_COMPLEX COUNT:-1` 全部稳定。 + +注：`FIND_SEQ` 已从原口径移除。`TryReplaceDotStar` 产出的是 `FindComplex(-1)`， +IROptimize 里没有 `RegexFindSeqIR` 的生成点，`ngra-regex-ir.md` 里写的 +`.*a → FIND_SEQ(a, last)` 尚未落地。在生成点补上之前，L1.9 的 `FIND_SEQ` / `FIND_SET` +分支实际不可达，L3.3 也无从触发。 低优先级，暂不纳入 checklist： diff --git a/src/StgSharp.RegularAnalysis/Text/TextRegexSourceGen.GenClass.MultiIR.cs b/src/StgSharp.RegularAnalysis/Text/TextRegexSourceGen.GenClass.MultiIR.cs index fd2a9bce..6cfe5573 100644 --- a/src/StgSharp.RegularAnalysis/Text/TextRegexSourceGen.GenClass.MultiIR.cs +++ b/src/StgSharp.RegularAnalysis/Text/TextRegexSourceGen.GenClass.MultiIR.cs @@ -14,109 +14,6 @@ namespace StgSharp.RegularAnalysis.Text { internal partial class TextRegexSourceGen { - /* - * ======================================================================================= - * L1, several regions plus a tail - * ======================================================================================= - * - * Highest consumption in the dispatch chain, so these are offered the window first. Each - * shape here was already recognised once during prefix emission, so a generator should - * mirror the matching RegexAnalyzer.PrefixEmit recogniser rather than re-derive the shape. - * - * L1.2 ALT chain with a shared suffix - * window L1.1 followed by linear instructions in the parent region - * sample (ab|[cd]|.)x - * nature flattening, may return -1 - * - * L1.3 group tail - * window region, POP FAIL with Prev_Fail, PACK SUCCESS with Prev_Success - * mirrors TryEmitTryGroupTail - * shape region block, capture written on the success branch - * sample (?abc) - * nature flattening, may return -1 - * - * L1.4 group tail wrapping an ALT chain - * sample (?abcd|a(bc)c) - * nature flattening, may return -1 - * - * L1.5 COUNT_COMPLEX plus body - * window RegexCountComplexIR, then CommandCount entries - * mirrors TryEmitComplexIR - * shape loop wrapping the generated body - * sample (ab){2,3} - * nature REQUIRED, no fallback exists - * - * L1.6 COUNT_COMPLEX whose body contains an ALT chain, plus a linear suffix - * sample (123(4|5)67){3,4}114514 - * nature REQUIRED, no fallback exists - * - * L1.7 FIND_COMPLEX plus body - * window RegexFindComplexIR, then CommandCount entries - * shape search loop wrapping the generated body - * sample .*(ab|cd) - * nature REQUIRED, no fallback exists - * - * L1.5 to L1.7 are required because a complex body is not a region of its own. L2 cannot - * pick it up, so there is no degradation path if these are missing. - * - * CommandCount must be read from the prefixed IR. Prefix emission rebuilds these counts, - * so the value carried by the pre-prefix IR no longer applies. - * - * Open questions to settle while implementing: - * - how the cursor is restored between ALT cases - * - which successful outcome a PACK uses as its capture span - * - whether a region body ever deserves its own generated method instead of inlining - * - * ======================================================================================= - * L2, one region - * ======================================================================================= - * - * Consumes CommandCount + 1, the whole block a TRY lowers to. Together with L4 and L5 this - * is the correctness core: once these three exist, every expression can be generated, just - * with deeper nesting than L1 and L3 would produce. - * - * L2.1 RegexTryIR plus its body sample (abc) - * L2.2 the same, body containing a nested region sample (a(bc)) - * L2.3 a single instruction region folded by prefix emission sample (a) - * - * Target shape, names owned by SourceGenContext: - * - * __rN_begin = __cur; - * __rN_ok = false; - * do - * { - * // body, a POP breaks out here - * __rN_ok = __ok; - * } while (false); - * if (!__rN_ok) { __cur = __rN_begin; } - * __ok = __rN_ok; - * - * Points the implementation has to settle: - * - the failure path restores the cursor to the region entry - * - break only leaves the nearest enclosing do block, so a nested region must not rely - * on it to exit an outer one - * - the whole match body is itself region zero, which is what makes a top level POP - * legal - * - * ======================================================================================= - * L3, fixed multi instruction windows - * ======================================================================================= - * - * Consumes two to eight entries. Pure code quality work, never required for correctness. - * Every one of these must return -1 cleanly when the window does not match, so the entry - * falls through to L4. - * - * L3.1 FIND_COMPLEX FURTHEST COUNT:-1, PACK, MATCH_SEQ 3 (?.*)234 - * L3.2 the same with a single element anchor 3 (?.*)a - * L3.3 FIND_SEQ, MATCH_SEQ, merged into one search 2 .*abc - * L3.4 MATCH_SEQ, COUNT_SEQ, the expanded a+ shape 2 a{3,5}, a+ - * L3.5 a run of MATCH_SEQ and MATCH_SET, merged into one condition 2 to 8 a[abc]d - * L3.6 trailing COUNT_SET over a dot, fast success 1 to 2 abc.* - * - * Two hazards to check for each of these: - * - merging must not break the line indices an Observe_Line prefix refers to - * - a merged window still has to leave __ok describing the whole window - */ private static int TryGenerateAltChain( int outer_level, @@ -165,6 +62,201 @@ namespace StgSharp.RegularAnalysis.Text } return i; } + /* + * ======================================================================================= + * L1, several regions plus a tail + * ======================================================================================= + * + * Highest consumption in the dispatch chain, so these are offered the window first. Each + * shape here was already recognised once during prefix emission, so a generator should + * mirror the matching RegexAnalyzer.PrefixEmit recogniser rather than re-derive the shape. + * + * L1.2 ALT chain with a shared suffix + * window L1.1 followed by linear instructions in the parent region + * sample (ab|[cd]|.)x + * nature flattening, may return -1 + * + * L1.3 group tail + * window region, POP FAIL with Prev_Fail, PACK SUCCESS with Prev_Success + * mirrors TryEmitTryGroupTail + * shape region block, capture written on the success branch + * sample (?abc) + * nature flattening, may return -1 + * + * L1.4 group tail wrapping an ALT chain + * sample (?abcd|a(bc)c) + * nature flattening, may return -1 + * + * L1.5 COUNT_COMPLEX plus body + * window RegexCountComplexIR, then CommandCount entries + * mirrors TryEmitComplexIR + * shape loop wrapping the generated body + * sample (ab){2,3} + * nature REQUIRED, no fallback exists + * + * L1.6 COUNT_COMPLEX whose body contains an ALT chain, plus a linear suffix + * sample (123(4|5)67){3,4}114514 + * nature REQUIRED, no fallback exists + * + * L1.7 FIND_COMPLEX with CommandCount >= 0 + * window RegexFindComplexIR, then CommandCount entries + * shape candidate retry loop wrapping the body + * sample .*(ab|cd) + * nature REQUIRED, no fallback exists + * + * L1.8 FIND_COMPLEX with CommandCount == -1 + * window RegexFindComplexIR, then the rest of the region + * shape candidate retry loop wrapping the rest of the region + * sample (?.*)234 + * nature REQUIRED, no fallback exists + * + * L1.9 FIND_SEQ or FIND_SET + * window the instruction, then the rest of the region + * shape candidate retry loop wrapping the rest of the region + * sample .*abc + * nature REQUIRED, no fallback exists + * + * L1.5 to L1.9 are required because none of their bodies is a region of its own. L2 + * cannot pick them up, so there is no degradation path if these are missing. + * + * CommandCount must be read from the prefixed IR. Prefix emission rebuilds these counts, + * so the value carried by the pre-prefix IR no longer applies. + * + * --------------------------------------------------------------------------------------- + * Backtracking semantics of the FIND family + * --------------------------------------------------------------------------------------- + * + * A FIND does not yield one position, it yields a priority ordered sequence of candidates. + * FURTHEST starts at the last one and steps backwards on failure, NEAREST starts at the + * first and steps forwards. The body is the verifier for a candidate: when it fails, the + * next candidate has to be tried, and only an exhausted candidate list is a real failure. + * A single LastIndexOf is wrong, because .*abcX has to fall back to the second to last abc + * when the last one is not followed by an X. + * + * CommandCount == -1 means the body is the rest of the region. TryReplaceDotStar emits + * FindComplex(-1) for a bare .*, then TyrMergeFindRestTwice and TyrMergeFindRestTry try to + * collapse it into a definite length. Whatever survives stays at -1. FIND_SEQ and FIND_SET + * carry no CommandCount at all and behave like -1. Only a FIND that happens to be the last + * instruction of its region degrades into a single search, consuming one entry. + * + * Target shape: + * + * int __bound = text.Length; + * __ok = false; + * while (true) + * { + * int __at = text[__cur..__bound].LastIndexOf("abc"); + * if (__at < 0) { __ok = false; break; } // candidates exhausted, only failure + * int __save = __cur; + * __cur = __cur + __at + 3; + * + * // body, or the rest of the region, expands here + * + * if (__ok) { break; } // verified + * __cur = __save; + * __bound = __save + __at; // step to the previous candidate + * } + * + * POP conflicts with the retry loop. A POP lowers to break, and the retry while is nearer + * than the region do block, so the break would leave the wrong scope. The fix without goto + * is a region completion flag: + * + * do // region N + * { + * bool __rN_done = false; + * while (!__rN_done) // find retry + * { + * // candidate search + * do // isolation layer, POP breaks out here + * { + * // body, POP sets __rN_ok, sets __rN_done, breaks + * } while (false); + * if (__rN_done || __ok) { break; } + * // step to the next candidate + * } + * } while (false); + * + * Two further hazards: + * - nested FIND produces nested retry loops and the cost multiplies, which is the + * catastrophic backtracking shape, worth a guard or at least a marker + * - __ok is overwritten across retry iterations, so an Observe_Line prefix pointing into + * a retry body reads the value of the last iteration, a case the current prefix model + * does not cover + * + * Open questions to settle while implementing: + * - how the cursor is restored between ALT cases + * - which successful outcome a PACK uses as its capture span + * - whether a region body ever deserves its own generated method instead of inlining + * + * ======================================================================================= + * L2, one region + * ======================================================================================= + * + * Consumes CommandCount + 1, the whole block a TRY lowers to. Together with L4 and L5 this + * is the correctness core: once these three exist, every expression can be generated, just + * with deeper nesting than L1 and L3 would produce. + * + * L2.1 RegexTryIR plus its body sample (abc) + * L2.2 the same, body containing a nested region sample (a(bc)) + * L2.3 a single instruction region folded by prefix emission sample (a) + * + * Target shape, names owned by SourceGenContext: + * + * __rN_begin = __cur; + * __rN_ok = false; + * do + * { + * // body, a POP breaks out here + * __rN_ok = __ok; + * } while (false); + * if (!__rN_ok) { __cur = __rN_begin; } + * __ok = __rN_ok; + * + * Points the implementation has to settle: + * - the failure path restores the cursor to the region entry + * - break only leaves the nearest enclosing loop, and a FIND retry while counts as one, + * so a region containing a FIND needs the __rN_done flag described above instead of a + * plain break + * - a nested region must not rely on break to exit an outer one + * - the whole match body is itself region zero, which is what makes a top level POP + * legal + * + * ======================================================================================= + * L3, fixed multi instruction windows + * ======================================================================================= + * + * Consumes two to eight entries. Pure code quality work, never required for correctness. + * Every one of these must return -1 cleanly when the window does not match, so the entry + * falls through to L4. + * + * L3.1 FIND_COMPLEX FURTHEST COUNT:-1, PACK, MATCH_SEQ 3 (?.*)234 + * L3.2 the same with a single element anchor 3 (?.*)a + * L3.3 FIND_SEQ, MATCH_SEQ, merged into one search 2 .*abc + * L3.4 MATCH_SEQ, COUNT_SEQ, the expanded a+ shape 2 a{3,5}, a+ + * L3.5 a run of MATCH_SEQ and MATCH_SET, merged into one condition 2 to 8 a[abc]d + * L3.6 trailing COUNT_SET over a dot, fast success 1 to 2 abc.* + * + * Two hazards to check for each of these: + * - merging must not break the line indices an Observe_Line prefix refers to + * - a merged window still has to leave __ok describing the whole window + */ + + private static int TryGenerateTryBlock( + int outer_level, + ReadOnlySpan ir_span, + SourceGenContext sc, + in SequenceEmitter code, + in List> local_func + ) + { + if (ir_span[0]is not RegexTryIR _try) { + return -1; + } + ReadOnlySpan block = ir_span[1..(1 + _try.CommandCount)]; + + // TODO generate here + return _try.CommandCount; + } } } diff --git a/src/StgSharp.RegularAnalysis/Text/TextRegexSourceGen.GenClass.SingleIR.cs b/src/StgSharp.RegularAnalysis/Text/TextRegexSourceGen.GenClass.SingleIR.cs index bbf1eb1b..55a120ad 100644 --- a/src/StgSharp.RegularAnalysis/Text/TextRegexSourceGen.GenClass.SingleIR.cs +++ b/src/StgSharp.RegularAnalysis/Text/TextRegexSourceGen.GenClass.SingleIR.cs @@ -44,11 +44,16 @@ namespace StgSharp.RegularAnalysis.Text * L4.5 MATCH_SET, any element . * L4.6 COUNT_SEQ a*, a? * L4.7 COUNT_SET [abc]*, \w+, .{11,13}, [.]* - * L4.8 FIND_SEQ degradation path of .*abc - * L4.9 FIND_SET - * L4.10 POP ALT tail * L4.11 PACK (abc), ordinal group * + * L4.8 and L4.9 were removed. FIND_SEQ and FIND_SET have no single instruction form, + * because they have to drive a candidate retry loop over the rest of the region. See L1.9 + * in TextRegexSourceGen.GenClass.MultiIR.cs. Only a FIND that happens to be the last + * instruction of its region degrades into a single search, and that is a branch of L1.9 + * rather than a generator of its own. The numbers are left vacant so existing references + * do not shift. + * * Semantics worth pinning down before writing these: * * - [.] and . are different sets. The former is a literal dot, the latter is any @@ -56,10 +61,10 @@ namespace StgSharp.RegularAnalysis.Text * - \w has to keep full .NET semantics. TextRegex.IsCharWord is inherited by the * generated class and already carries them, so the generated code can call it * directly instead of approximating with an ASCII test. - * - This backend does not backtrack. A lazy repetition therefore consumes exactly its - * lower bound and leaves the rest to the following anchor. Lazy forms needing more - * are expected to have been rewritten into a find by the IR optimizer, so confirm - * that before adding backtracking here. + * - Repetition in this layer does not backtrack. A lazy repetition therefore consumes + * exactly its lower bound and leaves the rest to the following anchor. Backtracking + * does exist in this backend, but only inside the FIND retry loop at L1.7 to L1.9, + * never here. * - An epsilon sequence and an empty repetition unit both reach these generators. * Decide whether they are vacuous successes or an optimizer bug worth reporting. * - PACK decides nothing, so it should leave __ok untouched. Whether it runs at all is diff --git a/src/StgSharp.RegularAnalysis/Text/TextRegexSourceGen.GenClass.cs b/src/StgSharp.RegularAnalysis/Text/TextRegexSourceGen.GenClass.cs index 0bb308d4..5a8a4eb5 100644 --- a/src/StgSharp.RegularAnalysis/Text/TextRegexSourceGen.GenClass.cs +++ b/src/StgSharp.RegularAnalysis/Text/TextRegexSourceGen.GenClass.cs @@ -48,9 +48,10 @@ namespace StgSharp.RegularAnalysis.Text * 2. The dispatch chain offers a window to L1, then L2, then L3, then L4. Higher * consumption wins, so a shape spanning a whole region plus a tail is never split by * a smaller generator. - * 3. L2, L4 and L5 together are sufficient for correctness. L1 and L3 only flatten what - * those would already emit, so an unimplemented one must return -1 cleanly rather - * than emit a partial result. + * 3. L2, L4, L5 and the required entries of L1 together are sufficient for correctness. + * The flattening entries of L1 and all of L3 only improve the shape of what those + * would already emit, so an unimplemented one must return -1 cleanly rather than + * emit a partial result. * 4. A prefix consumes no IR. L1 to L4 describe what an instruction does, L5 decides * when it runs and who reads the outcome. * 5. Scope follows Prefix.WorkingRegion, not expression nesting. @@ -60,6 +61,10 @@ namespace StgSharp.RegularAnalysis.Text * A region lowers to do { ... } while(false), and POP lowers to break. The goto plus * label scheme used by the .NET generated regex backend is deliberately not adopted. * + * A FIND lowers to a candidate retry loop nested inside the region block. That loop is + * nearer than the region do block, so a POP inside it needs the __rN_done flag described + * in TextRegexSourceGen.GenClass.MultiIR.cs rather than a plain break. + * * Generated variable names are owned by SourceGenContext. No generator invents one. * * The per shape checklist this backend is rebuilt against lives in @@ -90,7 +95,6 @@ namespace StgSharp.RegularAnalysis.Text // TODO L0.1 Emit the Match signature from ROS_char and SourceGenContext.InputSpan. // TODO L0.2 Emit region anchor and region result slots, count from RegexInfo.RegionCount. // TODO L0.3 Emit line result slots, only for lines an Observe_Line prefix refers to. - // TODO L0.4 Emit the whole pattern guard from RegexInfo.MinPredictLength. // TODO L0.5 Emit the cursor, the step result and any scratch declaration the context collected. // @@ -121,6 +125,7 @@ namespace StgSharp.RegularAnalysis.Text { // GenerateRegion(region, sc, match_e, sub_match_list); _ = TryGenerateAltChain(0, region, sc, match_e, sub_match_list); + _ = TryGenerateTryBlock(0, region, sc, match_e, sub_match_list); if (end >= ir_sp.Length) { break; @@ -133,6 +138,15 @@ namespace StgSharp.RegularAnalysis.Text _ = se.AppendLine($@"public override MatchResult Match({ROS_char} text)")// .AppendLine(@"{"); + int min_predict_length = info.MinPredictLength; + if (min_predict_length > 0) { + _ = se.AppendLine($@"if (text.Length < {min_predict_length})") + .AppendLine(@"{") + .AppendLine(@"return default;") + .AppendLine(@"}") + .AppendLine(); + } + int region_count = info.RegionCount; for (int i = 0; i < region_count; i++) {