public void GrammarShouldContainAllLexerRulesInReferencedGrammars()
{
var regex = new GrammarReferenceExpression(new RegexGrammar());
ProductionExpression
S = "S";
S.Rule = regex;
var grammarExpression = new GrammarExpression(S);
var grammar = grammarExpression.ToGrammar();
Assert.IsNotNull(grammar.LexerRules);
Assert.AreEqual(15, grammar.LexerRules.Count);
}
static EbnfGrammar()
{
LexerRule
settingIdentifier = CreateSettingIdentifierLexerRule(),
identifier = CreateIdentifierLexerRule(),
whitespace = CreateWhitespaceLexerRule(),
multiLineComment = CreateMultiLineCommentLexerRule();
ProductionExpression
definition = Definition,
block = Block,
rule = Rule,
setting = Setting,
lexerRule = LexerRule,
qualifiedIdentifier = QualifiedIdentifier,
expression = Expression,
term = Term,
factor = Factor,
literal = Literal,
grouping = Grouping,
repetition = Repetition,
optional = Optional,
lexerRuleExpression = LexerRuleExpression,
lexerRuleTerm = LexerRuleTerm,
lexerRuleFactor = LexerRuleFactor;
var regexProductionReference = new GrammarReferenceExpression(new RegexGrammar());
definition.Rule =
block
| (block + definition);
block.Rule =
rule
| setting
| lexerRule;
rule.Rule =
qualifiedIdentifier + '=' + expression + ';';
setting.Rule = (Expr)
settingIdentifier + '=' + qualifiedIdentifier + ';';
lexerRule.Rule =
qualifiedIdentifier + '~' + lexerRuleExpression + ';';
expression.Rule =
term
| (term + '|' + expression);
term.Rule =
factor
| (factor + term);
factor.Rule
= qualifiedIdentifier
| literal
| ('/' + regexProductionReference + '/')
| repetition
| optional
| grouping;
literal.Rule = (Expr)
new SimpleSingleQuoteStringLexerRule()
| new SimpleDoubleQuoteStringLexerRule();
repetition.Rule = (Expr)
'{' + expression + '}';
optional.Rule = (Expr)
'[' + expression + ']';
grouping.Rule = (Expr)
'(' + expression + ')';
qualifiedIdentifier.Rule =
identifier
| ((Expr)identifier + '.' + qualifiedIdentifier);
lexerRuleExpression.Rule =
lexerRuleTerm
| (lexerRuleTerm + '|' + lexerRuleExpression);
lexerRuleTerm.Rule =
lexerRuleFactor
| (lexerRuleFactor + lexerRuleTerm);
lexerRuleFactor.Rule =
literal
| ('/' + regexProductionReference + '/');
var grammarExpression = new GrammarExpression(
definition,
new[]
{
definition,
block,
rule,
setting,
lexerRule,
expression,
term,
factor,
literal,
repetition,
optional,
grouping,
qualifiedIdentifier,
lexerRuleExpression,
lexerRuleTerm,
lexerRuleFactor
},
new[] { whitespace, multiLineComment });
ebnfGrammar = grammarExpression.ToGrammar();
}
