static void Main(string[] args)
{
var sampleBnf = @"
<syntax> ::= <rule> | <rule> <syntax>
<rule> ::= <identifier> ""::="" <expression> <line-end>
<expression> ::= <list> | <list> ""|"" <expression>
<line-end> ::= <EOL> | <line-end> <line-end>
<list> ::= <term > | <term> <list>
<term> ::= <literal > | <identifier>
<identifier> ::= ""<"" <rule-name> "">""
<literal> ::= '""' <text> '""' | ""'"" <text> ""'""";
var grammar = new BnfGrammar();
for (long i = 0; i < 10000; i++)
{
var parseEngine = new ParseEngine(grammar);
var parseInterface = new ParseInterface(parseEngine, sampleBnf);
var stringReader = new StringReader(sampleBnf);
while (!parseInterface.EndOfStream() && parseInterface.Read()) { }
var result = parseInterface.ParseEngine.IsAccepted();
}
}
public void TestParseEngine45()
{
var engine = new ParseEngine();
var json = "[,\"a\", ]";
Assert.Throws(typeof(ArgumentException), () => engine.Parse(json));
}
public Regex Parse(string regularExpression)
{
var grammar = new RegexGrammar();
var parseEngine = new ParseEngine(grammar, new ParseEngineOptions());
var parseRunner = new ParseRunner(parseEngine, regularExpression);
while (!parseRunner.EndOfStream())
{
if (!parseRunner.Read())
{
throw new Exception(
$"Unable to parse regular expression. Error at position {parseRunner.Position}.");
}
}
if (!parseEngine.IsAccepted())
{
throw new Exception(
$"Error parsing regular expression. Error at position {parseRunner.Position}");
}
var parseTree = parseEngine.GetParseTree();
var regexVisitor = new RegexVisitor();
parseTree.Accept(regexVisitor);
return(regexVisitor.Regex);
}
public override IEnumerable <OutputRecord> Execute(ParseEngine context)
{
context.Log(ToString());
context.Log("{");
// if (!context.Grammar.IsTokenGrammar)
// Console.WriteLine("Executing " + Name);
IEnumerable <OutputRecord> nonterminal = context.ApplyNonterminal(this, context.Position);
// if (!context.Grammar.IsTokenGrammar)
// Console.WriteLine("Executed " + Name);
// if (!context.IsFailure(nonterminal) && !context.Grammar.IsTokenGrammar)
// Logger.WriteLine("Accepted " + Name + " (" + nonterminal.Concatenate(" ", o => o.OutputType == OutputType.None ? o.ToString() : "") + ")");
if (context.IsFailure(nonterminal))
{
context.Log(ParseEngine.Indent + "Failed");
}
else
{
context.Log(ParseEngine.Indent + "Succeeded");
}
context.Log("}");
return(nonterminal);
}
public void TestJObject02()
{
var employee = new EmployeeJson
{
Name = "Alan",
Department = "hardware",
Married = true,
Position = "manager",
Dob = new DateTime(1975, 10, 2),
Site = Site.London,
Age = 40
};
var context = JsonMapper.NewContext().UseDateFormat(string.Empty).For <EmployeeJson>(y => y.MapProperty(x => x.Dob).With("Birthday"));
var json = context.ToJson(employee);
var engine = new ParseEngine();
var emp = engine.Parse(json) as JObject;
Assert.NotNull(emp);
Assert.Equal("Alan", emp.GetString("Name"));
Assert.Equal("hardware", emp.GetString("Department"));
Assert.Equal("manager", emp.GetString("Position"));
Assert.Equal(40, emp.GetInt32("Age"));
Assert.True(emp.GetBool("Married"));
var dt = DateTime.Parse(emp.GetString("Birthday"));
Assert.Equal(1975, dt.Year);
Assert.Equal(10, dt.Month);
Assert.Equal(2, dt.Day);
}
public void ParseEngineWhenScanCompletedShouldCreateInternalAndTerminalNodes()
{
ProductionExpression S = "S";
S.Rule = (Expr)'a';
var grammar = new GrammarExpression(S, new[] { S })
.ToGrammar();
var tokens = Tokenize("a");
var parseEngine = new ParseEngine(grammar);
ParseInput(parseEngine, tokens);
var parseNode = parseEngine.GetParseForestRootNode();
Assert.IsNotNull(parseNode);
var S_0_1 = parseNode as ISymbolForestNode;
Assert.IsNotNull(S_0_1);
Assert.AreEqual(1, S_0_1.Children.Count);
var S_0_1_1 = S_0_1.Children[0] as IAndForestNode;
Assert.IsNotNull(S_0_1_1);
Assert.AreEqual(1, S_0_1_1.Children.Count);
var a_0_1 = S_0_1_1.Children[0] as ITokenForestNode;
Assert.IsNotNull(a_0_1);
Assert.AreEqual("a", a_0_1.Token.Value);
}
public Regex Parse(string regularExpression)
{
var grammar = new RegexGrammar();
var parseEngine = new ParseEngine(grammar, new ParseEngineOptions(optimizeRightRecursion: true));
var parseRunner = new ParseRunner(parseEngine, regularExpression);
while (!parseRunner.EndOfStream())
{
if (!parseRunner.Read())
{
throw new Exception(
$"Unable to parse regular expression. Error at position {parseRunner.Position}.");
}
}
if (!parseEngine.IsAccepted())
{
throw new Exception(
$"Error parsing regular expression. Error at position {parseRunner.Position}");
}
var parseForest = parseEngine.GetParseForestRootNode();
var parseTree = new InternalTreeNode(
parseForest as IInternalForestNode,
new SelectFirstChildDisambiguationAlgorithm());
var regexVisitor = new RegexVisitor();
parseTree.Accept(regexVisitor);
return(regexVisitor.Regex);
}
#pragma warning disable CC0091 // Use static method
public EbnfDefinition Parse(string ebnf)
{
var grammar = new EbnfGrammar();
var parseEngine = new ParseEngine(
grammar,
new ParseEngineOptions(
optimizeRightRecursion: true,
loggingEnabled: false));
var parseRunner = new ParseRunner(parseEngine, ebnf);
while (!parseRunner.EndOfStream())
{
if (!parseRunner.Read())
{
throw new Exception(
$"Unable to parse Ebnf. Error at line {parseRunner.Line}, column {parseRunner.Column}.");
}
}
if (!parseEngine.IsAccepted())
{
throw new Exception(
$"Ebnf parse not accepted. Error at line {parseRunner.Line}, column {parseRunner.Column}.");
}
var parseForest = parseEngine.GetParseForestRootNode();
var parseTree = new InternalTreeNode(
parseForest as IInternalForestNode,
new SelectFirstChildDisambiguationAlgorithm());
var ebnfVisitor = new EbnfVisitor();
parseTree.Accept(ebnfVisitor);
return(ebnfVisitor.Definition);
}
public void TestParseEngine46()
{
var engine = new ParseEngine();
var json = "{\"a\": \"b\", \"c\"}";
Assert.Throws(typeof(ArgumentException), () => engine.Parse(json));
}
public void TestParseEngine22()
{
var json = "21.0002345";
var parseEngine = new ParseEngine();
Assert.Equal("21.0002345", (parseEngine.Parse(json) as JNumber).Value);
}
public void TestParseEngine19()
{
var json = "{\"name\": \"Jack\", \"country\": \"usa\", \"age\": 30, \"married\": false, \"child\": Nill}";
var parseEngine = new ParseEngine();
Assert.Throws(typeof(ArgumentException), () => parseEngine.Parse(json));
}
public void TestParseEngine20()
{
var json = "\"Jason\"";
var parseEngine = new ParseEngine();
Assert.Equal("Jason", parseEngine.Parse(json).Value);
}
public void ParseRunnerShouldEmitTokenWhenIgnoreCharacterIsEncountered()
{
const string input = "aa aa";
ProductionExpression S = "S";
S.Rule = _wordRule + S | _wordRule;
var grammar = new GrammarExpression(
S,
new[] { S },
new[] { _whitespaceRule },
null)
.ToGrammar();
var parseEngine = new ParseEngine(grammar);
var parseRunner = new ParseRunner(parseEngine, input);
var chart = GetParseEngineChart(parseEngine);
for (int i = 0; i < 2; i++)
{
Assert.IsTrue(parseRunner.Read());
}
Assert.IsTrue(parseRunner.Read());
Assert.AreEqual(2, chart.EarleySets.Count);
}
public void ParseRunnerWhenNoLexemesMatchCharacterShouldCreateNewLexeme()
{
#if false
const string input = "aaaa";
ProductionExpression A = "A", S = "S";
A.Rule = (Expr)'a' + 'a';
var aGrammar = new GrammarExpression(A, new[] { A }).ToGrammar();
var a = new GrammarLexerRule("a", aGrammar);
S.Rule = (a + S) | a;
var grammar = new GrammarExpression(S, new[] { S }).ToGrammar();
var parseEngine = new ParseEngine(grammar);
var parseRunner = new ParseRunner(parseEngine, input);
var chart = GetParseEngineChart(parseEngine);
for (var i = 0; i < 3; i++)
{
Assert.IsTrue(parseRunner.Read());
}
Assert.AreEqual(2, chart.Count);
#endif
}
public void EbnfParserShouldParseComplexGrammarWithRepeat()
{
var stringBuilder = new StringBuilder()
//.AppendLine("file = ws directives ws ;")
.AppendLine("file = \"1\" { \"2\" } \"1\";");
//.AppendLine("directives = directive { ows directive };")
//.AppendLine("directive = \"0\" | \"1\"; ");
var actual = Parse(stringBuilder.ToString());
var grammar = new EbnfGrammar();
var parseEngine = new ParseEngine(grammar, new ParseEngineOptions(false));
var parseRunner = new ParseRunner(parseEngine, stringBuilder.ToString());
while (!parseRunner.EndOfStream())
{
if (!parseRunner.Read())
{
throw new Exception(
$"Unable to parse Ebnf. Error at position {parseRunner.Position}.");
}
}
if (!parseEngine.IsAccepted())
{
throw new Exception(
$"Unable to parse Ebnf. Error at position {parseRunner.Position}");
}
var parseForest = parseEngine.GetParseForestRootNode();
var visitor = new LoggingForestNodeVisitor(Console.Out);
parseForest.Accept(visitor);
}
public bool Parse()
{
var parseEngine = new ParseEngine(_grammar);
var parseRunner = new ParseRunner(parseEngine, _sampleBnf);
return(parseRunner.RunToEnd());
}
public IEbnfDefinition Parse(string ebnf)
{
var grammar = new EbnfGrammar();
var parseEngine = new ParseEngine(
grammar,
new ParseEngineOptions());
var parseRunner = new ParseRunner(parseEngine, ebnf);
while (!parseRunner.EndOfStream())
{
if (!parseRunner.Read())
{
throw new Exception(
$"Unable to parse Ebnf. Error at line {parseRunner.Line}, column {parseRunner.Column}.");
}
}
if (!parseEngine.IsAccepted())
{
throw new Exception(
$"Ebnf parse not accepted. Error at line {parseRunner.Line}, column {parseRunner.Column}.");
}
var parseTree = parseEngine.GetParseTree();
var ebnfVisitor = new EbnfVisitor();
parseTree.Accept(ebnfVisitor);
return(ebnfVisitor.Definition);
}
public IEnumerable <IEnumerable <OutputRecord> > GetResults(ParseEngine engine, IEnumerable <OutputRecord> first)
{
do
{
yield return(first);
}while (!engine.IsFailure(first = Operand.Execute(engine)));
}
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 TestParseEngine07()
{
var json = "{\"name\": \"Jack\", \"country\": \"usa\", \"age\": .30}";
var parseEngine = new ParseEngine();
Assert.Throws(typeof(ArgumentException), () => parseEngine.Parse(json));
}
public void RunMain()
{
Proposition expr;
string result;
//string s = "( p -> ( q & r ) ) <-> y";
//string s = "(A ->( B -> C )) <-> ( C -> D ) & ( D -> E) ";
//string s = "p<->p";
//string s = "p <-> a & b";
//string s = "((p | q) & (~p | r)) -> (q | r)";
//string s = "(P|(S&T))|R";
//string s = "(A&B)|(~A)|(~B)";
//string s = "(~p)<->(p->F)";
//string s = "(~((a&b)|c)&d)|(((a&b)|c)&(~d))";
string s = "(a&b)|(c&d)|(e&f)";
ParseEngine parseEngine = new ParseEngine();
parseEngine.TryParse(out expr, out result, s);
LogicEngine logicEng = new LogicEngine();
Proposition nnfExpr = logicEng.ConvertToNNF(expr);
Proposition cnfExpr = logicEng.ConvertToCNF(nnfExpr);
bool b = logicEng.IsTautology(cnfExpr);
WriteFile(cnfExpr.ToString());
}
public void Test_AycockHorspoolAlgorithm_That_Vulnerable_Grammar_Accepts_Input()
{
var a = new TerminalLexerRule(
new Terminal('a'),
new TokenType("a"));
var grammar = new GrammarBuilder("S'")
.Production("S'", r => r
.Rule("S"))
.Production("S", r => r
.Rule("A", "A", "A", "A"))
.Production("A", r => r
.Rule(a)
.Rule("E"))
.Production("E", r => r
.Lambda())
.ToGrammar();
var parseEngine = new ParseEngine(grammar);
parseEngine.Pulse(new Token("a", 0, a.TokenType));
var privateObject = new PrivateObject(parseEngine);
var chart = privateObject.GetField("_chart") as Chart;
Assert.IsNotNull(chart);
Assert.AreEqual(2, chart.Count);
Assert.IsTrue(parseEngine.IsAccepted());
}
public IInternalTreeNode Parse(string source)
{
var grammar = MakeGrammar();
var parseEngine = new ParseEngine(
grammar,
new ParseEngineOptions(loggingEnabled: true));
var parseRunner = new ParseRunner(parseEngine, source);
while (!parseRunner.EndOfStream())
{
if (!parseRunner.Read())
{
throw new Exception(
$"Unable to parse expression. Error at line {parseRunner.Line+1}, column {parseRunner.Column+1}.");
}
Console.WriteLine("-----");
Console.ReadKey(true);
}
if (!parseEngine.IsAccepted())
{
throw new Exception(
$"expression parse not accepted. Error at line {parseRunner.Line+1}, column {parseRunner.Column+1}.");
}
return(parseEngine.GetParseTree());
}
public void TestParseEngine28()
{
var json =
"{\"english\": {\"top\": [\"arsenal\", \"man utd\", \"chelsea\", \"man city\"], \"holder\": \"chelsea\"}, \"spain\": {\"top\": [\"barcelona\", \"real\"], \"holder\": \"barcelona\"}}";
var parseEngine = new ParseEngine();
var value = parseEngine.Parse(json) as JObject;
Assert.NotNull(value);
var english = value["english"] as JObject;
Assert.NotNull(english);
var englishTop = english["top"] as JArray;
Assert.NotNull(englishTop);
Assert.Equal("arsenal", englishTop[0].Value);
Assert.Equal("man utd", englishTop[1].Value);
Assert.Equal("chelsea", englishTop[2].Value);
Assert.Equal("man city", englishTop[3].Value);
Assert.Equal("chelsea", english["holder"].Value);
var spain = value["spain"] as JObject;
Assert.NotNull(spain);
var spainTop = spain["top"] as JArray;
Assert.NotNull(spainTop);
Assert.Equal("barcelona", spainTop[0].Value);
Assert.Equal("real", spainTop[1].Value);
Assert.Equal("barcelona", spain["holder"].Value);
}
public override IEnumerable <OutputRecord> Execute(ParseEngine engine)
{
var result = NoResults;
IEnumerable <OutputRecord> current;
var mark = engine.Mark();
int count;
for (count = 0; !engine.IsFailure(current = Operand.Execute(engine)); count++)
{
if (count > Max)
{
engine.Reset(mark);
return(null);
}
result = result.Concat(current);
}
if (count < Min)
{
engine.Reset(mark);
return(null);
}
return(result);
}
public void TestParseEngine03()
{
var json = "{\"nam\"e\": \"Jack\"}{";
var parseEngine = new ParseEngine();
Assert.Throws(typeof(ArgumentException), () => parseEngine.Parse(json));
}
public void ParseRunnerShouldHandleCleanupOfUnUsedIgnoreLexemes()
{
var grammar = new PdlGrammar();
var parseEngine = new ParseEngine(grammar);
var stringBuilder = new StringBuilder()
.AppendLine("ws = [ ows ] ; /* white space */")
.AppendLine("ows = \"_\" ; /* obligatory white space */");
RunParse(parseEngine, stringBuilder.ToString());
var chart = parseEngine.Chart;
Assert.IsTrue(chart.EarleySets.Count > 7);
var seventhSet = chart.EarleySets[7];
Assert.IsNotNull(seventhSet);
Assert.AreEqual(1, seventhSet.Completions.Count);
var onlyCompletion = seventhSet.Completions[0];
Assert.IsNotNull(onlyCompletion);
var parseNode = onlyCompletion.ParseNode as IInternalForestNode;
var parseNodeAndNode = parseNode.Children[0];
var tokenParseNode = parseNodeAndNode.Children[0] as ITokenForestNode;
var token = tokenParseNode.Token;
Assert.AreEqual(PdlGrammar.TokenTypes.Identifier, token.TokenType);
Assert.AreEqual("ows", token.Capture.ToString());
}
public void ParseEngineShouldHandleTransitionsFromRightRecursionToNormalGrammar()
{
var grammar = CreateRegularExpressionStubGrammar();
var input = Tokenize("aaaa");
var parseEngine = new ParseEngine(grammar);
ParseInput(parseEngine, input);
// R_0_7 -> E_0_7
// E_0_7 -> T_0_7
// T_0_7 -> F_0_1 T_1_7
// F_0_1 -> 'a'
// T_1_7 -> F_1_2 T_2_7
// F_1_2 -> 'a'
// T_2_7 -> F_2_3 T_3_7
// F_2_3 -> 'a'
// T_3_7 -> F_3_4 T_4_7
// F_3_4 -> 'a'
// T_4_7 -> F_4_5 T_5_7
// F_4_5 -> 'a'
// T_5_7 -> F_5_6 T_6_7
// F_5_6 -> 'a'
// T_6_7 -> F_6_7
// F_6_7 -> 'a'
var parseForestRoot = parseEngine.GetParseForestRootNode();
var root = parseForestRoot;
var R_0_4 = CastAndCountChildren <ISymbolForestNode>(root, 1);
AssertNodeProperties(R_0_4, "R", 0, 4);
var E_0_4 = GetAndCastChildAtIndex <ISymbolForestNode>(R_0_4, 0);
AssertNodeProperties(E_0_4, "E", 0, 4);
var T_0_4 = GetAndCastChildAtIndex <ISymbolForestNode>(E_0_4, 0);
AssertNodeProperties(T_0_4, "T", 0, 4);
var F_0_1 = GetAndCastChildAtIndex <ISymbolForestNode>(T_0_4, 0);
AssertNodeProperties(F_0_1, "F", 0, 1);
var T_1_4 = GetAndCastChildAtIndex <ISymbolForestNode>(T_0_4, 1);
AssertNodeProperties(T_1_4, "T", 1, 4);
var F_1_2 = GetAndCastChildAtIndex <ISymbolForestNode>(T_1_4, 0);
AssertNodeProperties(F_1_2, "F", 1, 2);
var T_2_4 = GetAndCastChildAtIndex <ISymbolForestNode>(T_1_4, 1);
AssertNodeProperties(T_2_4, "T", 2, 4);
var F_2_4 = GetAndCastChildAtIndex <ISymbolForestNode>(T_2_4, 0);
AssertNodeProperties(F_2_4, "F", 2, 3);
var T_3_4 = GetAndCastChildAtIndex <ISymbolForestNode>(T_2_4, 1);
AssertNodeProperties(T_3_4, "T", 3, 4);
var F_3_4 = GetAndCastChildAtIndex <ISymbolForestNode>(T_3_4, 0);
AssertNodeProperties(F_3_4, "F", 3, 4);
}
public static T To <T>(string json, Transformer <JValue, T> transform)
{
Guarder.CheckNull(transform, "transform");
var engine = new ParseEngine();
var value = engine.Parse(json);
return(transform(value));
}
public static T To <T>(string json, IJsonConverter <T> converter)
{
Guarder.CheckNull(converter, "converter");
var engine = new ParseEngine();
var value = engine.Parse(json);
return(converter.Convert(value));
}
private ParseResult ParseString(string data)
{
ParseEngine parser = new ParseEngine();
using (StringReader stream = new StringReader(data))
{
return parser.Parse(stream);
}
}
public void TestParseEngine30()
{
var engine = new ParseEngine();
var json = "[]";
var array = engine.Parse(json) as JArray;
Assert.Equal(0, array.Length);
}
public void Test_Lexeme_That_Consumes_Character_Sequence()
{
var grammar = new GrammarBuilder("sequence")
.Production("sequence", r => r
.Rule('a', 'b', 'c', '1', '2', '3'))
.ToGrammar();
var parseEngine = new ParseEngine(grammar);
var lexeme = new ParseEngineLexeme(parseEngine, new TokenType("sequence"));
var input = "abc123";
for (int i = 0; i < input.Length; i++)
Assert.IsTrue(lexeme.Scan(input[i]));
Assert.IsTrue(lexeme.IsAccepted());
}
public void Test_Bnf_That_Parses_Large_Grammar_In_File()
{
var bnf = File.ReadAllText(Path.Combine(TestContext.TestDeploymentDir, "Bnf", "AnsiC.bnf"));
Assert.IsFalse(string.IsNullOrEmpty(bnf));
var grammar = new BnfGrammar();
var parseEngine = new ParseEngine(grammar);
var parseInterface = new ParseInterface(parseEngine, bnf);
while (!parseInterface.EndOfStream())
{
if (!parseInterface.Read())
Assert.Fail("Error Parsing At Position {0}", parseInterface.Position);
}
Assert.IsTrue(parseEngine.IsAccepted());
}
public void Test_NodeWalker_That_Walks_Simple_Regex()
{
var regexGrammar = new RegexGrammar();
var regexParseEngine = new ParseEngine(regexGrammar);
var regexParseInterface = new ParseInterface(regexParseEngine, @"[(]\d[)]");
while (!regexParseInterface.EndOfStream())
{
if (!regexParseInterface.Read())
Assert.Fail("error parsing input at position {0}", regexParseInterface.Position);
}
Assert.IsTrue(regexParseEngine.IsAccepted());
var nodeVisitor = new NodeVisitor();
var root = regexParseEngine.GetRoot();
root.Accept(nodeVisitor);
Assert.AreEqual(34, nodeVisitor.VisitLog.Count);
}
public void Test_Lexeme_That_Matches_Longest_Acceptable_Token_When_Given_Ambiguity()
{
var lexemeList = new List<ParseEngineLexeme>();
const string There = "there";
var thereGrammar = new GrammarBuilder(There)
.Production(There, r => r
.Rule('t', 'h', 'e', 'r', 'e'))
.ToGrammar();
var thereParseEngine = new ParseEngine(thereGrammar);
var thereLexeme = new ParseEngineLexeme(thereParseEngine, new TokenType(There));
lexemeList.Add(thereLexeme);
const string Therefore = "therefore";
var thereforeGrammar = new GrammarBuilder(Therefore)
.Production(Therefore, r => r
.Rule('t', 'h', 'e', 'r', 'e', 'f', 'o', 'r', 'e'))
.ToGrammar();
var parseEngine = new ParseEngine(thereforeGrammar);
var thereforeLexeme = new ParseEngineLexeme(parseEngine, new TokenType(Therefore));
lexemeList.Add(thereforeLexeme);
var input = "therefore";
var i = 0;
for (; i < input.Length; i++)
{
var passedLexemes = lexemeList
.Where(l => l.Scan(input[i]))
.ToList();
// all existing lexemes have failed
// fall back onto the lexemes that existed before
// we read this character
if (passedLexemes.Count() == 0)
break;
lexemeList = passedLexemes;
}
Assert.AreEqual(i, input.Length);
Assert.AreEqual(1, lexemeList.Count);
var remainingLexeme = lexemeList[0];
Assert.IsNotNull(remainingLexeme);
Assert.IsTrue(remainingLexeme.IsAccepted());
}
public void Test_Lexeme_That_Consumes_Whitespace()
{
var grammar = new GrammarBuilder("S")
.Production("S", r=>r
.Rule("W")
.Rule("W", "S"))
.Production("W", r => r
.Rule(new WhitespaceTerminal()))
.ToGrammar();
var lexerRule = new GrammarLexerRule(
"whitespace",
grammar);
var parseEngine = new ParseEngine(lexerRule.Grammar);
var lexeme = new ParseEngineLexeme(parseEngine, new TokenType("whitespace"));
var input = "\t\r\n\v\f ";
for (int i = 0; i < input.Length; i++)
Assert.IsTrue(lexeme.Scan(input[i]));
Assert.IsTrue(lexeme.IsAccepted());
}
public void Test_Bnf_That_Parse_Produces_Bnf_Chart()
{
var grammar = new BnfGrammar();
var parseEngine = new ParseEngine(grammar);
var parseInterface = new ParseInterface(parseEngine, _bnfText);
while (!parseInterface.EndOfStream())
{
if (!parseInterface.Read())
{
var position = parseInterface.Position;
var startIndex = 0;
for (int i = position; i >= 0; i--)
{
if (_bnfText[i] == '\n' && i > 0)
if (_bnfText[i - 1] == '\r')
{
startIndex = i;
break;
}
}
var endIndex = _bnfText.IndexOf("\r\n", position);
endIndex = endIndex < 0 ? _bnfText.Length : endIndex;
var length = endIndex - startIndex;
var stringBuilder = new StringBuilder();
stringBuilder
.AppendFormat("Error parsing input string at position {0}.", parseInterface.Position)
.AppendLine()
.AppendFormat("start: {0}", startIndex)
.AppendLine()
.AppendLine(_bnfText.Substring(startIndex, length));
Assert.Fail(stringBuilder.ToString());
}
}
Assert.IsTrue(
parseInterface.ParseEngine.IsAccepted(),
"error at position {0}", parseInterface.Position);
}
public YAMPOperatorMissingError(ParseEngine pe)
: this(pe.CurrentLine, pe.CurrentColumn)
{
}
internal YAMPFunctionArgumentsSymbols(ParseEngine pe)
: this(pe.CurrentLine, pe.CurrentColumn)
{
}
/// <summary>
/// Creates a new YAMP Parse Exception.
/// </summary>
/// <param name="engine">The engine where this happend.</param>
public YAMPParseException(ParseEngine engine)
: base("The query can not run, since the parser encountered {0} error(s).", engine.ErrorCount)
{
Errors = engine.Errors;
}
internal YAMPForArgumentsMissing(ParseEngine pe)
: this(pe.CurrentLine, pe.CurrentColumn)
{
}
internal YAMPStringNotTerminatedError(ParseEngine pe)
: this(pe.CurrentLine, pe.CurrentColumn)
{
}
internal YAMPExpressionMissingError(ParseEngine pe)
: this(pe.CurrentLine, pe.CurrentColumn)
{
}
internal YAMPKeywordNotPossible(ParseEngine pe, String keyword)
: this(pe.CurrentLine, pe.CurrentColumn, keyword)
{
}
internal YAMPBracketNotClosedError(ParseEngine pe)
: this(pe.CurrentLine, pe.CurrentColumn)
{
}
internal YAMPExpressionMissingError(ParseEngine pe, Operator op, Int32 found)
: base(pe.CurrentLine, pe.CurrentColumn, "The {0} operator requires {1} expression(s), but only {2} expression(s) have been found.", op.Op, op.Expressions, found)
{
}
internal YAMPIfRequiredError(ParseEngine pe)
: this(pe.CurrentLine, pe.CurrentColumn)
{
}
internal YAMPVariableNameMissing(ParseEngine pe)
: this(pe.CurrentLine, pe.CurrentColumn)
{
}
internal YAMPBracketEmptyError(ParseEngine pe)
: this(pe.CurrentLine, pe.CurrentColumn)
{
}
internal YAMPTerminatorMissingError(ParseEngine pe, Char terminator)
: this(pe.CurrentLine, pe.CurrentColumn, terminator)
{
}
internal YAMPSingleElseError(ParseEngine pe)
: this(pe.CurrentLine, pe.CurrentColumn)
{
}
internal YAMPFunctionNameMissing(ParseEngine pe)
: this(pe.CurrentLine, pe.CurrentColumn)
{
}
internal YAMPEscapeSequenceNotFoundError(ParseEngine pe, Char sequence)
: this(pe.CurrentLine, pe.CurrentColumn, sequence)
{
}
/// <summary>
/// Creates a new instance.
/// </summary>
/// <param name="child">The child to add.</param>
/// <param name="engine">The engine that has been used.</param>
public TreeExpression(ContainerExpression child, ParseEngine engine)
: this(child, engine.Query, engine.CurrentLine, engine.CurrentColumn)
{
}
internal YAMPDoWhileNotEmptyError(ParseEngine pe)
: this(pe.CurrentLine, pe.CurrentColumn)
{
}
