public void GrammarRulesConainingSymbolShouldReturnAllRulesContainingSymbol()
{
ProductionExpression
S = nameof(S),
A = nameof(A),
B = nameof(B),
C = nameof(C);
S.Rule = A | B;
A.Rule = A | C | 'a';
B.Rule = 'b' | B;
C.Rule = 'c';
var grammarExpression = new GrammarExpression(S);
var grammar = grammarExpression.ToGrammar();
var rulesContainingA = grammar.RulesContainingSymbol(A.ProductionModel.LeftHandSide.NonTerminal);
Assert.AreEqual(2, rulesContainingA.Count);
var rulesContainingB = grammar.RulesContainingSymbol(B.ProductionModel.LeftHandSide.NonTerminal);
Assert.AreEqual(2, rulesContainingB.Count);
var rulesContainingC = grammar.RulesContainingSymbol(C.ProductionModel.LeftHandSide.NonTerminal);
Assert.AreEqual(1, rulesContainingC.Count);
var rulesContainingS = grammar.RulesContainingSymbol(S.ProductionModel.LeftHandSide.NonTerminal);
Assert.AreEqual(0, rulesContainingS.Count);
}
public void GrammarShouldContainAllLexerRulesInSuppliedProductionsIgnoresAndTrivia()
{
ProductionExpression
S = nameof(S),
A = nameof(A),
B = nameof(B),
C = nameof(C);
S.Rule = A | B;
A.Rule = A | C | 'a';
B.Rule = 'b' | B;
C.Rule = 'c';
var grammarExpression = new GrammarExpression(
S,
null,
new[] { new WhitespaceLexerRule() },
new[] { new WordLexerRule() });
var grammar = grammarExpression.ToGrammar();
Assert.IsNotNull(grammar.LexerRules);
Assert.AreEqual(5, grammar.LexerRules.Count);
foreach (var rule in grammar.LexerRules)
{
Assert.IsNotNull(rule);
}
}
public void AycockHorspoolAlgorithmShouldAcceptVulnerableGrammar()
{
var a = new TerminalLexerRule(
new CharacterTerminal('a'),
new TokenName("a"));
ProductionExpression
SPrime = "S'",
S = "S",
A = "A",
E = "E";
SPrime.Rule = S;
S.Rule = (Expr)S | (A + A + A + A);
A.Rule = (Expr)"a" | E;
var expression = new GrammarExpression(
SPrime,
new[] { SPrime, S, A, E });
var grammar = expression.ToGrammar();
var parseEngine = new ParseEngine(grammar);
parseEngine.Pulse(new VerbatimToken(a.TokenName, 0, "a"));
//var privateObject = new PrivateObject(parseEngine);
//var chart = privateObject.GetField("_chart") as Chart;
var chart = parseEngine.Chart;
Assert.IsNotNull(chart);
Assert.AreEqual(2, chart.Count);
Assert.IsTrue(parseEngine.IsAccepted());
}
public void GrammarShouldContainAllLexerRulesInReferencedGrammars()
{
var regex = new ProductionReferenceExpression(new RegexGrammar());
ProductionExpression S = nameof(S);
S.Rule = regex;
var grammarExpression = new GrammarExpression(S);
var grammar = grammarExpression.ToGrammar();
Assert.IsNotNull(grammar.LexerRules);
Assert.AreEqual(15, grammar.LexerRules.Count);
}
public void DeterministicParseEngineShouldParseInSubCubicTimeGivenRightRecursiveGrammar()
{
var a = new TerminalLexerRule(
new CharacterTerminal('a'),
new TokenType("a"));
ProductionExpression A = "A";
A.Rule =
'a' + A
| (Expr)null;
var grammarExpression = new GrammarExpression(A, new[] { A });
var parseTester = new ParseTester(
new DeterministicParseEngine(
new PreComputedGrammar(grammarExpression.ToGrammar())));
const string input = "aaaaa";
parseTester.RunParse(input);
}
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();
}
static PdlGrammar()
{
BaseLexerRule
settingIdentifier = SettingIdentifier(),
notDoubleQuote = NotDoubleQuote(),
notSingleQuote = NotSingleQuote(),
identifier = Identifier(),
any = new TerminalLexerRule(new AnyTerminal(), "."),
notCloseBracket = new TerminalLexerRule(
new NegationTerminal(new CharacterTerminal(']')), "[^\\]]"),
escapeCharacter = EscapeCharacter(),
whitespace = Whitespace(),
multiLineComment = MultiLineComment();
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 regexGrammar = new RegexGrammar();
var regexProductionReference = new ProductionReferenceExpression(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 SingleQuoteStringLexerRule()
| new DoubleQuoteStringLexerRule();
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[] { new LexerRuleModel(whitespace), new LexerRuleModel(multiLineComment) });
_pdlGrammar = grammarExpression.ToGrammar();
}
public ParseTester(GrammarExpression expression)
: this(expression.ToGrammar())
{
}
