private static EbnfLexerRuleFactor VisitLexerRuleFactorNode(IInternalTreeNode node)
{
for (int c = 0; c < node.Children.Count; c++)
{
var child = node.Children[c];
if (child.NodeType != TreeNodeType.Internal)
{
continue;
}
var internalNode = child as IInternalTreeNode;
var symbolValue = internalNode.Symbol.Value;
if (EbnfGrammar.Literal == symbolValue)
{
return(new EbnfLexerRuleFactorLiteral(
VisitLiteralNode(internalNode)));
}
if (RegexGrammar.Regex == symbolValue)
{
var regexVisitor = new RegexVisitor();
internalNode.Accept(regexVisitor);
return(new EbnfLexerRuleFactorRegex(regexVisitor.Regex));
}
}
throw UnreachableCodeException();
}
private EbnfFactor VisitFactorNode(IInternalTreeNode node)
{
for (int c = 0; c < node.Children.Count; c++)
{
var child = node.Children[c];
switch (child.NodeType)
{
case TreeNodeType.Internal:
var internalNode = child as IInternalTreeNode;
var symbolValue = internalNode.Symbol.Value;
if (EbnfGrammar.QualifiedIdentifier == symbolValue)
{
return(new EbnfFactorIdentifier(
VisitQualifiedIdentifierNode(internalNode)));
}
if (EbnfGrammar.Literal == symbolValue)
{
return(new EbnfFactorLiteral(
VisitLiteralNode(internalNode)));
}
if (EbnfGrammar.Repetition == symbolValue)
{
return(VisitRepetitionNode(internalNode));
}
if (EbnfGrammar.Optional == symbolValue)
{
return(VisitOptionalNode(internalNode));
}
if (EbnfGrammar.Grouping == symbolValue)
{
return(VisitGroupingNode(internalNode));
}
if (RegexGrammar.Regex == symbolValue)
{
var regexVisitor = new RegexVisitor();
internalNode.Accept(regexVisitor);
return(new EbnfFactorRegex(regexVisitor.Regex));
}
break;
case TreeNodeType.Token:
break;
}
}
throw UnreachableCodeException();
}
private static IEbnfLexerRuleFactor VisitLexerRuleFactorNode(IInternalTreeNode node)
{
foreach (var internalNode in node.Children.OfType <IInternalTreeNode>())
{
if (internalNode.Is(EbnfGrammar.Literal))
{
return(new EbnfLexerRuleFactorLiteral(VisitLiteralNode(internalNode)));
}
if (internalNode.Is(RegexGrammar.Regex))
{
var regexVisitor = new RegexVisitor();
internalNode.Accept(regexVisitor);
return(new EbnfLexerRuleFactorRegex(regexVisitor.Regex));
}
}
throw UnreachableCodeException();
}
private IEbnfFactor VisitFactorNode(IInternalTreeNode node)
{
foreach (var internalNode in node.Children.OfType <IInternalTreeNode>())
{
if (internalNode.Is(EbnfGrammar.QualifiedIdentifier))
{
return(new EbnfFactorIdentifier(VisitQualifiedIdentifierNode(internalNode)));
}
if (internalNode.Is(EbnfGrammar.Literal))
{
return(new EbnfFactorLiteral(VisitLiteralNode(internalNode)));
}
if (internalNode.Is(EbnfGrammar.Repetition))
{
return(VisitRepetitionNode(internalNode));
}
if (internalNode.Is(EbnfGrammar.Optional))
{
return(VisitOptionalNode(internalNode));
}
if (internalNode.Is(EbnfGrammar.Grouping))
{
return(VisitGroupingNode(internalNode));
}
if (internalNode.Is(RegexGrammar.Regex))
{
var regexVisitor = new RegexVisitor();
internalNode.Accept(regexVisitor);
return(new EbnfFactorRegex(regexVisitor.Regex));
}
}
throw UnreachableCodeException();
}