public void PreComputedGrammarIsRightRecursiveShouldNotContainSymbolsWithoutCycles()
{
ProductionExpression
A = "A",
B = "B",
C = "C",
D = "D",
E = "E";
A.Rule = B + C;
B.Rule = 'b';
C.Rule = A | D;
D.Rule = E + D | 'd';
E.Rule = 'e';
var grammar = new GrammarExpression(A).ToGrammar();
var preComputedGrammar = new PreComputedGrammar(grammar);
var rightRecursiveRules = new[] { A, C, D };
var notRightRecursiveRules = new[] { B, E };
foreach (var rightRecursiveRule in rightRecursiveRules)
{
var leftHandSide = rightRecursiveRule.ProductionModel.LeftHandSide.NonTerminal;
Assert.IsTrue(preComputedGrammar.Grammar.IsRightRecursive(leftHandSide));
}
foreach (var notRightRecursiveRule in notRightRecursiveRules)
{
var leftHandSide = notRightRecursiveRule.ProductionModel.LeftHandSide.NonTerminal;
Assert.IsFalse(preComputedGrammar.Grammar.IsRightRecursive(leftHandSide));
}
}
public void MarpaParseEngineCanParseRegex()
{
var regexGrammar = new RegexGrammar();
var preComputedRegexGrammar = new PreComputedGrammar(regexGrammar);
var parseEngine = new MarpaParseEngine(preComputedRegexGrammar);
var pattern = "[a-z][0-9]abc123";
var openBracket = new TokenType("[");
var notMeta = new TokenType("NotMeta"); // maybe make this token type a readonly property on the regex grammar?
var notCloseBracket = new TokenType("NotCloseBracket"); // maybe make this token type a readonly property on the regex grammar?
var closeBracket = new TokenType("]");
var dash = new TokenType("-");
for (int i = 0; i < pattern.Length; i++)
{
TokenType tokenType = (pattern[i]) switch
{
'[' => openBracket,
']' => closeBracket,
'-' => dash,
_ => i < 10
? notCloseBracket
: notMeta,
};
var token = new Token(pattern[i].ToString(), i, tokenType);
var result = parseEngine.Pulse(token);
Assert.IsTrue(result, $"Error at position {i}");
}
Assert.IsTrue(parseEngine.IsAccepted(), "Parse was not accepted");
}
public void InitializeTest()
{
_parseTester = new ParseTester(_grammar);
var preComputedGrammar = new PreComputedGrammar(_grammar);
_compressedParseTester = new ParseTester(
new DeterministicParseEngine(preComputedGrammar));
_marpaParseTester = new ParseTester(
new MarpaParseEngine(preComputedGrammar));
}
private static void AssertExpectedLexerRulesReturnedFromInitializedParseEngine(IGrammar grammar, int expectedCount)
{
var preComputedGrammar = new PreComputedGrammar(grammar);
var parseEngine = new DeterministicParseEngine(preComputedGrammar);
var lexerRules = parseEngine.GetExpectedLexerRules();
Assert.AreEqual(
expectedCount,
lexerRules.Count, $"Expected {expectedCount} lexerRule, Found {lexerRules.Count}");
}
public void PreComputedGrammarIsRightRecursiveShouldFindCyclicRecursion()
{
var grammar = new HiddenRightRecursionGrammar();
var preComputedGrammar = new PreComputedGrammar(grammar);
var leftHandSides = new UniqueList <INonTerminal>();
for (var p = 0; p < grammar.Productions.Count; p++)
{
var production = grammar.Productions[p];
Assert.IsTrue(preComputedGrammar.Grammar.IsRightRecursive(production.LeftHandSide));
}
}
public void DeterministicParseEngineCanParseRegex()
{
var regexGrammar = new RegexGrammar();
var preComputedRegexGrammar = new PreComputedGrammar(regexGrammar);
var parseEngine = new DeterministicParseEngine(preComputedRegexGrammar);
var pattern = "[a-z][0-9]abc123";
var openBracket = new TokenType("[");
var notMeta = new TokenType("NotMeta"); // maybe make this token type a readonly property on the regex grammar?
var notCloseBracket = new TokenType("NotCloseBracket"); // maybe make this token type a readonly property on the regex grammar?
var closeBracket = new TokenType("]");
var dash = new TokenType("-");
for (int i = 0; i < pattern.Length; i++)
{
TokenType tokenType = null;
switch (pattern[i])
{
case '[':
tokenType = openBracket;
break;
case ']':
tokenType = closeBracket;
break;
case '-':
tokenType = dash;
break;
default:
if (i < 10)
{
tokenType = notCloseBracket;
}
else
{
tokenType = notMeta;
}
break;
}
var token = new Token(pattern[i].ToString(), i, tokenType);
var result = parseEngine.Pulse(token);
Assert.IsTrue(result, $"Error at position {i}");
}
Assert.IsTrue(parseEngine.IsAccepted(), "Parse was not accepted");
}
public void DeterministicParseEngineCanParseNullableGrammar()
{
var preComputedGrammar = new PreComputedGrammar(NullableGrammar);
var parseEngine = new DeterministicParseEngine(preComputedGrammar);
var input = "aaaa";
var tokenType = new TokenType("a");
for (int i = 0; i < input.Length; i++)
{
var result = parseEngine.Pulse(new Token("a", i, tokenType));
Assert.IsTrue(result, $"Error at position {i}");
}
Assert.IsTrue(parseEngine.IsAccepted(), "Parse was not accepted");
}
public DeterministicParseEngine(PreComputedGrammar preComputedGrammar)
{
_precomputedGrammar = preComputedGrammar;
Initialize();
}
public void PreComputedGrammarIsRightRecursiveShouldFindSimpleRecursion()
{
var preComputedGrammar = new PreComputedGrammar(new RightRecursionGrammar());
}
public void PreComputedGrammarShouldLoadJsonGrammar()
{
var preComputedGrammar = new PreComputedGrammar(_jsonGrammar);
}
public void PreComputedGrammarShouldLoadNullableGrammar()
{
var preComputedGrammar = new PreComputedGrammar(new NullableGrammar());
}
public void PreComputedGrammarShouldLoadExpressionGrammar()
{
var preComputedGrammar = new PreComputedGrammar(new ExpressionGrammar());
}
public MarpaParseEngine(PreComputedGrammar preComputedGrammar)
{
_preComputedGrammar = preComputedGrammar;
Chart = new DeterministicChart();
Initialize();
}
public MarpaParseEngine(PreComputedGrammar preComputedGrammar)
{
_preComputedGrammar = preComputedGrammar;
Chart = new StateFrameChart();
Initialize();
}
