protected override IEnumerable <RuleMatch> OnMatch(ExplorerContext context)
{
var primaryMatches = context.InvokeRule(_primary);
foreach (var primaryMatch in primaryMatches)
{
var primaryText = primaryMatch.Text;
var excludingContext = context.SubContext(primaryText.Length);
var excludedMatches = excludingContext.InvokeRule(_excluded);
var excludedExactLength = from ex in excludedMatches
where ex.Text.Length == primaryText.Length
select ex;
if (!excludedExactLength.Any())
{
var match = new RuleMatch(
this,
primaryText,
() => RuleOutput.ComputeOutput(
primaryText,
new Lazy <object?>(() => primaryMatch.ComputeOutput())));
yield return(match);
}
}
}
protected override IEnumerable <RuleMatch> OnMatch(ExplorerContext context)
{
var text = context.Text;
if (text.HasContent)
{
var peekRaw = text.First();
var peek = IsCaseSensitive == false?char.ToUpperInvariant(peekRaw) : peekRaw;
var first = IsCaseSensitive == false?char.ToUpperInvariant(First) : First;
var last = IsCaseSensitive == false?char.ToUpperInvariant(Last) : Last;
if (peek >= first && peek <= last)
{
var matchText = text.Take(1);
var match = new RuleMatch(
this,
matchText,
() => RuleOutput.ComputeOutput(matchText, new Lazy <object?>(matchText)));
return(new[] { match });
}
}
return(RuleMatch.EmptyMatch);
}
public void WriteResult(RuleMatch result)
{
Logger.Log($"Rule : {result.Rule.Caption}");
Logger.Log($"File : {result.File}");
Logger.Log($"Match: {result.Line}");
Logger.Log($"Line : {result.LineNumber}");
Logger.Log("-------------------------------");
}
public SingleOutputModel(
RuleMatch match,
TimeSpan grammarDuration,
TimeSpan matchDuration)
{
IsMatch = match != null;
if (match != null)
{
Rule = match.Rule.RuleName;
Text = match.Text.ToString();
// To force SubString to be serialized into strings
Output = match.ComputeTypedOutput <object>();
}
Duration = new DurationModel(grammarDuration, matchDuration);
}
private IEnumerable <RuleMatch> RecurseMatch(
// Used only for debugging purposes, to hook on the context ID of the entire sequence
int masterContextID,
ExplorerContext context,
SubString originalText,
int totalMatchLength,
int iteration,
ImmutableList <RuleMatch> childrenMatches)
{
var matches = context.InvokeRule(_rule);
var nonEmptyMatches = matches.Where(m => m.Text.Length != 0);
foreach (var match in nonEmptyMatches)
{
var newTotalMatchLength = totalMatchLength + match.LengthWithInterleaves;
var newChildrenMatches = childrenMatches.Add(match);
if (IsRepeatCountBelowMaximum(iteration + 1))
{ // Recurse to next iteration
var newContext = context.MoveForward(match);
var downstreamMatches = RecurseMatch(
masterContextID,
newContext,
originalText,
newTotalMatchLength,
iteration + 1,
newChildrenMatches);
foreach (var m in downstreamMatches)
{
yield return(m);
}
}
// We are returning the matches in decreasing order of text length, so the "current" one goes last
if (IsRepeatCountInRange(iteration))
{
var matchText = originalText.Take(newTotalMatchLength);
var completeMatch = new RuleMatch(
this,
matchText,
() => ComputeOutput(matchText, newChildrenMatches));
yield return(completeMatch);
}
}
}
protected override IEnumerable <RuleMatch> OnMatch(ExplorerContext context)
{
var text = context.Text;
if (text.Length == 0)
{
return(RuleMatch.EmptyMatch);
}
else
{
var matchText = text.Take(1);
var match = new RuleMatch(
this,
matchText,
() => RuleOutput.ComputeOutput(matchText, new Lazy <object?>(matchText)));
return(new[] { match });
}
}
protected override IEnumerable <RuleMatch> OnMatch(ExplorerContext context)
{
var text = context.Text;
if (text.HasContent &&
text.Length >= _literal.Length &&
text.Take(_literal.Length).SequenceEqual(_literal, GetCharComparer()))
{
var matchText = text.Take(_literal.Length);
var match = new RuleMatch(
this,
matchText,
() => RuleOutput.ComputeOutput(
matchText,
new Lazy <object?>(() => matchText)));
return(new[] { match });
}
else
{
return(RuleMatch.EmptyMatch);
}
}
void Preprocess(List <RuleMatch> rules)
{
RuleMatch prevRule = null;
for (var i = 0; i < rules.Count; i++)
{
if (rules[i].Rule.Type == GrammarTokenType.Operator && (prevRule == null ||
(prevRule.Rule.Type == GrammarTokenType.Operator && prevRule.Rule.Operands == 2) ||
(prevRule.Rule.Type == GrammarTokenType.Operator && prevRule.Rule.Operands == 1 && prevRule.Rule.Associativity == GrammarTokenAssociativity.Right) ||
(prevRule.Rule.Type == GrammarTokenType.LeftParenthesis)))
{
if (rules[i].Lexem.Text == "-")
{
rules[i] = _sy.Match(new Lexem("u-", typeof(string), Kinds.Operator));
}
else if (rules[i].Lexem.Text == "+")
{
rules[i] = _sy.Match(new Lexem("u+", typeof(string), Kinds.Operator));
}
}
prevRule = rules[i];
}
}
