299 lines
14 KiB
Plaintext
299 lines
14 KiB
Plaintext
// -----------------------------------------------------------------------------
|
|
// file="TextRegexSourceGen.GenClass.MultiIR"
|
|
// Project: StgSharp
|
|
// Copyright (c) Nitload.
|
|
// SPDX-License-Identifier: MIT
|
|
// -----------------------------------------------------------------------------
|
|
|
|
using StgSharp.RegularAnalysis.Abstraction;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Runtime.Serialization.Formatters;
|
|
using System.Threading;
|
|
|
|
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 (?<name>abc)
|
|
* nature flattening, may return -1
|
|
*
|
|
* L1.4 group tail wrapping an ALT chain
|
|
* sample (?<a>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 (?<name>.*)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 (?<name>.*)234
|
|
* L3.2 the same with a single element anchor 3 (?<name>.*)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
|
|
*/
|
|
|
|
#region code
|
|
|
|
private static int TryGenerateTryBlock(
|
|
int outer_level,
|
|
ReadOnlySpan<RegexIR> ir_span,
|
|
SourceGenContext sc,
|
|
in SequenceEmitter<string> code,
|
|
in List<SequenceEmitter<string>> local_func
|
|
)
|
|
{
|
|
if (ir_span[0]is not RegexTryIR _try) {
|
|
return -1;
|
|
}
|
|
ReadOnlySpan<RegexIR> block = ir_span[1..(1 + _try.CommandCount)];
|
|
|
|
// TODO generate here
|
|
return _try.CommandCount;
|
|
}
|
|
|
|
private static int TryGenerateNamedCountAny(
|
|
int outer_level,
|
|
ReadOnlySpan<RegexIR> ir_span,
|
|
SourceGenContext sc,
|
|
in SequenceEmitter<string> code,
|
|
in List<SequenceEmitter<string>> local_func
|
|
)
|
|
{
|
|
/*
|
|
* (?<name>.*)234
|
|
* [010] 0003, DEF , DEF , NONE, 0000, FIND_COMPLEX FURTHEST COUNT: -1
|
|
* [011] 0003, Sccs, DEF , LINE, 0010, PACK SUCCESS GROUP: "name"
|
|
* [012] 0000, DEF , DEF , NONE, 0000, MATCH_SEQ "234"
|
|
*/
|
|
if (ir_span[0] is not RegexFindComplexIR { CommandCount: -1 } ||
|
|
ir_span[1] is not RegexPackIR pack)
|
|
{
|
|
return -1;
|
|
}
|
|
string group_name = pack.GroupName;
|
|
|
|
int i = 0;
|
|
for (; i < ir_span.Length; i++) { }
|
|
|
|
return -1;
|
|
}
|
|
|
|
private static int TryGenerateAltChain(
|
|
int outer_level,
|
|
ReadOnlySpan<RegexIR> ir_span,
|
|
SourceGenContext sc,
|
|
in SequenceEmitter<string> code,
|
|
in List<SequenceEmitter<string>> local_func
|
|
)
|
|
{
|
|
/*
|
|
* L1.1 ALT chain
|
|
* window region, then further regions carrying Prev_Fail
|
|
* mirrors TryEmitAltChain
|
|
* shape if / else if / else
|
|
* sample a|b, ab|cd|ef, a|bc|def
|
|
* nature flattening, may return -1
|
|
*/
|
|
|
|
/*
|
|
* [004] 0001, DEF , DEF , NONE, 0000, MATCH_SEQ "abc"
|
|
* [005] 0002, DEF , Sccs, NONE, 0000, MATCH_SEQ "d" <- an alt chain begins here
|
|
* [006] 0002, Fail, Sccs, LINE, 0005, MATCH_SEQ "c" <- an alt chain ends here
|
|
* [007] 0001, Fail, DEF , LINE, 0006, POP FAIL
|
|
*/
|
|
|
|
const RegexIRPrefixMask simple_alt = RegexIRPrefixMask.Prev_Fail | RegexIRPrefixMask.Pop_Success;
|
|
|
|
int cur_level = ir_span[0].Prefix.WorkingRegion;
|
|
if (cur_level == outer_level) {
|
|
return -1;
|
|
}
|
|
int i = 1;
|
|
RegexIR ir;
|
|
for (; i < ir_span.Length; i++)
|
|
{
|
|
ir = ir_span[i];
|
|
if ((ir.Prefix.Mask & simple_alt) == simple_alt)
|
|
{
|
|
if (TryGenerateSingleIR(outer_level, [ir], sc, code, local_func) > 0)
|
|
{
|
|
// TODO add additional code for the alt chain
|
|
}
|
|
|
|
// simple match
|
|
} else if (ir is RegexTryIR _try && (ir.Prefix.Mask & simple_alt) == simple_alt)
|
|
{
|
|
// match a try region
|
|
ReadOnlySpan<RegexIR> body_span = ir_span.Slice(i + 1, i + _try.CommandCount);
|
|
i += _try.CommandCount;
|
|
}
|
|
}
|
|
return i;
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|