RegexContext IRegexExpression.Match(RegexContext context)
{
var leftChildResult = leftChild.Match(context);
var rightChildResult = rightChild.Match(leftChildResult);
return(rightChildResult);
}
private static void TestRange(RegexContext context, SequenceBuffer <char> buffer)
{
var backtrackState = new BacktrackState(true, context.CurrentState);
int j = 0;
while (true)
{
if (buffer.IsPastEnd(context.Index))
{
backtrackState.AddZeroConsumed();
context.Push(backtrackState);
context.MoveToNextState();
break;
}
var(matches, consumed) = MatchStateHere(context.CurrentState, buffer, context.Index);
if (!matches || consumed == 0)
{
backtrackState.AddZeroConsumed();
context.Push(backtrackState);
context.MoveToNextState();
break;
}
backtrackState.AddConsumption(consumed);
context.AdvanceIndex(consumed);
j++;
if (j >= context.CurrentState.Maximum)
{
context.MoveToNextState();
break;
}
}
}
private static void TestZeroOrOne(RegexContext context, SequenceBuffer <char> buffer)
{
if (buffer.IsPastEnd(context.Index))
{
context.Push(new BacktrackState(false, context.CurrentState, 0));
context.MoveToNextState();
return;
}
var(matches, consumed) = MatchStateHere(context.CurrentState, buffer, context.Index);
context.Push(new BacktrackState(matches && consumed > 0, context.CurrentState, consumed));
context.AdvanceIndex(consumed);
context.MoveToNextState();
}
RegexContext IRegexExpression.Match(RegexContext context)
{
RegexContext toRetutn = new RegexContext();
RegexContext leftChildResult = leftChild.Match(context);
foreach (var el in leftChildResult)
{
toRetutn.Add(el);
}
RegexContext rightCildResult = rightChild.Match(context);
foreach (var el in rightCildResult)
{
toRetutn.Add(el);
}
return(toRetutn);
}
RegexContext IRegexExpression.Match(RegexContext context)
{
RegexContext toReturn = new RegexContext();
foreach (var element in context)
{
if (element.Length < myString.Length)
{
continue;
}
string beginning = element.Substring(0, myString.Length);
if (beginning == myString)
{
toReturn.Add(element.Substring(myString.Length));
}
}
return(toReturn);
}
private static (bool matches, int length) Test(IReadOnlyList <State> states, SequenceBuffer <char> buffer)
{
var context = new RegexContext(states);
while (context.CurrentState.Type != StateType.EndSentinel)
{
switch (context.CurrentState.Quantifier)
{
case Quantifier.ExactlyOne:
{
var indexBeforeBacktracking = context.Index;
var ok = TestExactlyOne(context, buffer);
if (ok)
{
continue;
}
return(false, indexBeforeBacktracking);
}
case Quantifier.ZeroOrOne:
{
TestZeroOrOne(context, buffer);
continue;
}
case Quantifier.ZeroOrMore:
{
TestZeroOrMore(context, buffer);
continue;
}
case Quantifier.Range:
{
TestRange(context, buffer);
continue;
}
default:
throw new RegexException("Unrecognized quantifier");
}
}
return(true, context.Index);
}
private static bool TestExactlyOne(RegexContext context, SequenceBuffer <char> buffer)
{
var(matches, consumed) = MatchStateHere(context.CurrentState, buffer, context.Index);
if (matches)
{
context.Push(new BacktrackState(false, context.CurrentState, consumed));
context.AdvanceIndex(consumed);
context.MoveToNextState();
return(true);
}
var couldBacktrack = context.Backtrack();
if (couldBacktrack)
{
return(true);
}
return(false);
}
RegexContext IRegexExpression.Match(RegexContext context)
{
var toReturn = new RegexContext();
var prev = new RegexContext();
foreach (var el in context)
{
toReturn.Add(el);
}
while (!toReturn.IsEmpty())
{
foreach (var el in toReturn)
{
prev.Add(el);
}
toReturn = child.Match(toReturn);
}
return(prev);
}
static void RegexTests()
{
var parser = new PrefixRegexParser();
foreach (var test_prefix_expression in ExampleRegexExpression.TestExpressions)
{
var regex = parser.Parse(test_prefix_expression.Item1);
var input_context = new RegexContext(test_prefix_expression.Item2);
var out_context = regex.Match(input_context);
Console.WriteLine("Regex: {0}", regex.ToString());
Console.WriteLine("Input: {0}", test_prefix_expression.Item2);
var match_info = out_context.Matches() ? "Matched!" : "Not Matched!";
Console.WriteLine(match_info);
Console.WriteLine("");
Debug.Assert(out_context.Matches() == test_prefix_expression.Item3);
}
}
public RegexContext regex()
{
RegexContext _localctx = new RegexContext(_ctx, State);
EnterRule(_localctx, 20, RULE_regex);
try {
EnterOuterAlt(_localctx, 1);
{
State = 104; Match(REGEX);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.ReportError(this, re);
_errHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
