private SyntaxVisitorResult <IN, OUT> Visit(GroupSyntaxNode <IN> node, object context = null)
{
var group = new Group <IN, OUT>();
var values = new List <SyntaxVisitorResult <IN, OUT> >();
foreach (var n in node.Children)
{
var v = Visit(n, context);
if (v.IsValue)
{
group.Add(n.Name, v.ValueResult);
}
if (v.IsToken)
{
if (!v.Discarded)
{
group.Add(n.Name, v.TokenResult);
}
}
}
var res = SyntaxVisitorResult <IN, OUT> .NewGroup(group);
return(res);
}
private SyntaxVisitorResult <IN, OUT> Visit(GroupSyntaxNode <IN> node)
{
Group <IN, OUT> group = new Group <IN, OUT>();
List <SyntaxVisitorResult <IN, OUT> > values = new List <SyntaxVisitorResult <IN, OUT> >();
foreach (ISyntaxNode <IN> n in node.Children)
{
SyntaxVisitorResult <IN, OUT> v = Visit(n);
if (v.IsValue)
{
group.Add(n.Name, v.ValueResult);
}
if (v.IsToken)
{
if (!v.Discarded)
{
group.Add(n.Name, v.TokenResult);
}
}
}
var res = SyntaxVisitorResult <IN, OUT> .NewGroup(group);
return(res);
}
public virtual SyntaxParseResult <IN> Parse(IList <Token <IN> > tokens, Rule <IN> rule, int position, string nonTerminalName)
{
int currentPosition = position;
List <UnexpectedTokenSyntaxError <IN> > errors = new List <UnexpectedTokenSyntaxError <IN> >();
bool isError = false;
List <ISyntaxNode <IN> > children = new List <ISyntaxNode <IN> >();
if (rule.PossibleLeadingTokens.Contains(tokens[position].TokenID))
{
if (rule.Clauses != null && rule.Clauses.Count > 0)
{
children = new List <ISyntaxNode <IN> >();
foreach (IClause <IN> clause in rule.Clauses)
{
if (clause is TerminalClause <IN> )
{
SyntaxParseResult <IN> termRes = ParseTerminal(tokens, clause as TerminalClause <IN>, currentPosition);
if (!termRes.IsError)
{
children.Add(termRes.Root);
currentPosition = termRes.EndingPosition;
}
else
{
Token <IN> tok = tokens[currentPosition];
errors.Add(new UnexpectedTokenSyntaxError <IN>(tok, ((TerminalClause <IN>)clause).ExpectedToken));
}
isError = isError || termRes.IsError;
}
else if (clause is NonTerminalClause <IN> )
{
SyntaxParseResult <IN> nonTerminalResult =
ParseNonTerminal(tokens, clause as NonTerminalClause <IN>, currentPosition);
if (!nonTerminalResult.IsError)
{
children.Add(nonTerminalResult.Root);
currentPosition = nonTerminalResult.EndingPosition;
if (nonTerminalResult.Errors != null && nonTerminalResult.Errors.Any())
{
errors.AddRange(nonTerminalResult.Errors);
}
}
else
{
errors.AddRange(nonTerminalResult.Errors);
}
isError = isError || nonTerminalResult.IsError;
}
if (isError)
{
break;
}
}
}
}
if (nonTerminalName == "rootGroup")
{
;
}
SyntaxParseResult <IN> result = new SyntaxParseResult <IN>();
result.IsError = isError;
result.Errors = errors;
result.EndingPosition = currentPosition;
if (!isError)
{
SyntaxNode <IN> node = null;
if (rule.IsSubRule)
{
node = new GroupSyntaxNode <IN>($"{nonTerminalName}__{rule.Key}", children);
}
else
{
node = new SyntaxNode <IN>($"{nonTerminalName}__{rule.Key}", children);
}
node = ManageExpressionRules(rule, node);
if (node.IsByPassNode) // inutile de créer un niveau supplémentaire
{
result.Root = children[0];
}
result.Root = node;
result.IsEnded = result.EndingPosition >= tokens.Count - 1 ||
result.EndingPosition == tokens.Count - 2 && tokens[tokens.Count - 1].TokenID.Equals(default(IN));
if (result.IsEnded)
{
;
}
if (rule.IsExpressionRule)
{
}
}
return(result);
}
private DotNode Visit(GroupSyntaxNode <IN> node)
{
return(Visit(node as SyntaxNode <IN>));
}
public override SyntaxParseResult <IN> Parse(IList <Token <IN> > tokens, Rule <IN> rule, int position,
string nonTerminalName)
{
var currentPosition = position;
var errors = new List <UnexpectedTokenSyntaxError <IN> >();
var isError = false;
var children = new List <ISyntaxNode <IN> >();
if (rule.PossibleLeadingTokens.Contains(tokens[position].TokenID) || rule.MayBeEmpty)
{
if (rule.Clauses != null && rule.Clauses.Count > 0)
{
children = new List <ISyntaxNode <IN> >();
foreach (var clause in rule.Clauses)
{
if (clause is TerminalClause <IN> termClause)
{
var termRes =
ParseTerminal(tokens, termClause, currentPosition);
if (!termRes.IsError)
{
children.Add(termRes.Root);
currentPosition = termRes.EndingPosition;
}
else
{
var tok = tokens[currentPosition];
errors.Add(new UnexpectedTokenSyntaxError <IN>(tok,
((TerminalClause <IN>)clause).ExpectedToken));
}
isError = isError || termRes.IsError;
}
else if (clause is NonTerminalClause <IN> )
{
var nonTerminalResult =
ParseNonTerminal(tokens, clause as NonTerminalClause <IN>, currentPosition);
if (!nonTerminalResult.IsError)
{
errors.AddRange(nonTerminalResult.Errors);
children.Add(nonTerminalResult.Root);
currentPosition = nonTerminalResult.EndingPosition;
}
else
{
errors.AddRange(nonTerminalResult.Errors);
}
isError = isError || nonTerminalResult.IsError;
}
else if (clause is OneOrMoreClause <IN> || clause is ZeroOrMoreClause <IN> )
{
SyntaxParseResult <IN> manyResult = null;
if (clause is OneOrMoreClause <IN> oneOrMore)
{
manyResult = ParseOneOrMore(tokens, oneOrMore, currentPosition);
}
else if (clause is ZeroOrMoreClause <IN> zeroOrMore)
{
manyResult = ParseZeroOrMore(tokens, zeroOrMore, currentPosition);
}
if (!manyResult.IsError)
{
errors.AddRange(manyResult.Errors);
children.Add(manyResult.Root);
currentPosition = manyResult.EndingPosition;
}
else
{
if (manyResult.Errors != null && manyResult.Errors.Count > 0)
{
errors.AddRange(manyResult.Errors);
}
}
isError = isError || manyResult.IsError;
}
else if (clause is OptionClause <IN> option)
{
var optionResult = ParseOption(tokens, option, rule, currentPosition);
currentPosition = optionResult.EndingPosition;
children.Add(optionResult.Root);
}
if (isError)
{
break;
}
}
}
}
var result = new SyntaxParseResult <IN>();
result.IsError = isError;
result.Errors = errors;
result.EndingPosition = currentPosition;
if (!isError)
{
SyntaxNode <IN> node = null;
if (rule.IsSubRule)
{
node = new GroupSyntaxNode <IN>(nonTerminalName + "__" + rule.Key, children);
node = ManageExpressionRules(rule, node);
result.Root = node;
result.IsEnded = currentPosition >= tokens.Count - 1 ||
currentPosition == tokens.Count - 2 &&
tokens[tokens.Count - 1].TokenID.Equals(default(IN));
}
else
{
node = new SyntaxNode <IN>(nonTerminalName + "__" + rule.Key, children);
node.ExpressionAffix = rule.ExpressionAffix;
node = ManageExpressionRules(rule, node);
result.Root = node;
result.IsEnded = currentPosition >= tokens.Count - 1 ||
currentPosition == tokens.Count - 2 &&
tokens[tokens.Count - 1].TokenID.Equals(default(IN));
}
}
return(result);
}
