protected virtual void OnDefineParserErrors(SyntaxErrors errorDefinition, CompilationErrorManager errorManager) { errorManager.DefineError(errorDefinition.LexicalErrorId, 0, CompilationStage.Scanning, "Invalid token: {0}"); errorManager.DefineError(errorDefinition.TokenUnexpectedId, 0, CompilationStage.Parsing, "Unexpected token: {0}"); errorManager.DefineError(errorDefinition.TokenMissingId, 0, CompilationStage.Parsing, "Missing token: {0}"); errorManager.DefineError(errorDefinition.OtherErrorId, 0, CompilationStage.Parsing, "Syntax error"); }
public void Test(SourceReader sr) { Console.WriteLine("=============== GLR Parser Combinators =================="); CompilationErrorManager em = new CompilationErrorManager(); var parser = new GLRCombinatorsTestParser(em); var errList = em.CreateErrorList(); var result = parser.Parse(sr, errList); if (errList.Count == 0) { Console.WriteLine("Result: {0}", result); } else { Console.WriteLine("Parse Errors:"); foreach (var err in from e in errList orderby e.ErrorPosition.StartLocation select e) { Console.WriteLine(err.ToString()); } } Console.WriteLine(); Console.WriteLine(); }
public void ParserFuncTest() { Lexicon test = new Lexicon(); var ID = test.DefaultLexer.DefineToken(RE.Range('a', 'z').Concat( (RE.Range('a', 'z') | RE.Range('0', '9')).Many())); var NUM = test.DefaultLexer.DefineToken(RE.Range('0', '9').Many1()); var GREATER = test.DefaultLexer.DefineToken(RE.Symbol('>')); var WHITESPACE = test.DefaultLexer.DefineToken(RE.Symbol(' ').Union(RE.Symbol('\t'))); var p1 = from i in ID from g in GREATER from g2 in GREATER.AsParser(l => l.PrefixTrivia.Count == 0) from n in NUM select "A"; var p2 = from i in ID from g in GREATER from g2 in GREATER from n in NUM select "B"; var parser1 = p1 | p2; var info = test.CreateScannerInfo(); ForkableScannerBuilder builder = new ForkableScannerBuilder(info); builder.SetTriviaTokens(WHITESPACE.Index); var errorManager = new CompilationErrorManager(); var context = new ParserContext(errorManager, 1, 2); context.DefineDefaultCompilationErrorInfo(0); ParserRunner <string> runner = new ParserRunner <string>(parser1, context); string source1 = "abc >> 123"; var sr1 = new SourceReader(new StringReader(source1)); ForkableScanner scanner1 = builder.Create(sr1); var result1 = runner.Run(scanner1); Assert.AreEqual("A", result1); Assert.AreEqual(0, errorManager.Errors.Count); string source2 = "abc > > 123"; var sr2 = new SourceReader(new StringReader(source2)); ForkableScanner scanner2 = builder.Create(sr2); var result2 = runner.Run(scanner2); Assert.AreEqual("B", result2); Assert.AreEqual(0, errorManager.Errors.Count); }
private static void ReportErrors(CompilationErrorManager errorManager) { if (errorManager.Errors.Count > 0) { foreach (var error in errorManager.Errors.OrderBy(e => e.ErrorPosition.StartLocation.CharIndex)) { Console.WriteLine(error.ToString()); } } }
public void OperatorManyTest() { string source = ""; CompilationErrorManager em = new CompilationErrorManager(); var parser = new OperatorManyParser(em); var result = parser.Parse(source, em.CreateErrorList()); ; }
public void ParserBaseTest() { string source = "A((B(,),C(,)"; CompilationErrorManager em = new CompilationErrorManager(); var parser = new TreeParser(em); var result = parser.Parse(source); ; }
public void PanicErrorRecoveryTest() { CompilationErrorManager em = new CompilationErrorManager(); var parser = new AdditionMultiplicationExpressionTestParser(em); var errList = em.CreateErrorList(); var result = parser.Parse("1+3(+(+(+(+(+(+(+(+(+(+(+2+3+3+3+3)*", errList); Assert.Greater(errList.Count, 0); }
public void ParserBaseTest() { string source = "A((B(,),C(,)"; string correct = "A(B(,),C(,))"; CompilationErrorManager em = new CompilationErrorManager(); var parser = new TreeParser(em); var result = parser.Parse(source, em.CreateErrorList()); Assert.AreEqual(correct, result.ToString()); }
protected ParserFrame(CompilationErrorManager errorManager, int lexicalErrorId, int missingTokenErrorId, int unexpectedTokenErrorId) { CodeContract.RequiresArgumentNotNull(errorManager, "errorManager"); m_errorManager = errorManager; m_missingTokenErrorId = missingTokenErrorId; m_unexpectedTokenErrorId = unexpectedTokenErrorId; m_lexicalErrorId = lexicalErrorId; m_triviaTokens = new List <Token>(); }
public void AmbiguityGrammarErrorTest() { CompilationErrorManager em = new CompilationErrorManager(); AmbiguityParser parser = new AmbiguityParser(em); const string input = "a<b>>c;"; var result = parser.Parse(input); var r = result.First() as AmbiguityStatementNode; Assert.IsNotNull(r); Assert.AreEqual(1, em.Errors.Count); }
protected ParserBase(CompilationErrorManager errorManager) { CodeContract.RequiresArgumentNotNull(errorManager, "errorManager"); m_errorManager = errorManager; m_errorDefinition = new SyntaxErrors() { LexicalErrorId = 101, TokenUnexpectedId = 201, TokenMissingId = 202, OtherErrorId = 203 }; m_triviaTokens = new List <Token>(); }
public void ErrorRecoveryTest() { Lexicon lexicon = new Lexicon(); Lexer global = lexicon.Lexer; var ID = global.DefineToken(RE.Range('a', 'z').Concat( (RE.Range('a', 'z') | RE.Range('0', '9')).Many())); var NUM = global.DefineToken(RE.Range('0', '9').Many1()); var WHITESPACE = global.DefineToken(RE.Symbol(' ').Many()); ScannerInfo info = lexicon.CreateScannerInfo(); Compiler.Scanner.Scan.Scanner scanner = new Compiler.Scanner.Scan.Scanner(info); string source = "asdf04a 1107 !@#$!@ Z if vvv xmlns 772737"; StringReader sr = new StringReader(source); scanner.SetSource(new SourceReader(sr)); scanner.SetTriviaTokens(WHITESPACE.Index); scanner.RecoverErrors = true; CompilationErrorManager em = new CompilationErrorManager(); em.DefineError(101, 0, CompilationStage.Scanning, "Invalid token: {0}"); var el = em.CreateErrorList(); scanner.ErrorList = el; scanner.LexicalErrorId = 101; Lexeme l1 = scanner.Read(); Assert.AreEqual(ID.Index, l1.TokenIndex); Lexeme l2 = scanner.Read(); Assert.AreEqual(NUM.Index, l2.TokenIndex); Assert.AreEqual(0, el.Count); Lexeme l3 = scanner.Read(); Assert.AreEqual(ID.Index, l3.TokenIndex); Assert.IsTrue(el.Count > 0); Assert.AreEqual(101, el[0].Info.Id); }
public void ParserCastTest() { Lexicon test = new Lexicon(); var ID = test.Lexer.DefineToken(RE.Range('a', 'z').Concat( (RE.Range('a', 'z') | RE.Range('0', '9')).Many())); var NUM = test.Lexer.DefineToken(RE.Range('0', '9').Many1()); var GREATER = test.Lexer.DefineToken(RE.Symbol('>')); var WHITESPACE = test.Lexer.DefineToken(RE.Symbol(' ').Union(RE.Symbol('\t'))); var p1 = from i in ID from g in GREATER from g2 in GREATER from n in NUM select "hello"; var parser1 = p1.TryCast <object>(); var info = test.CreateScannerInfo(); ForkableScannerBuilder builder = new ForkableScannerBuilder(info); builder.SetTriviaTokens(WHITESPACE.Index); var errorManager = new CompilationErrorManager(); var context = new ParserContext(errorManager, 1, 2); context.DefineDefaultCompilationErrorInfo(0); var el = errorManager.CreateErrorList(); context.ErrorList = el; ParserRunner <object> runner = new ParserRunner <object>(parser1, context); string source1 = "abc >> 123"; var sr1 = new SourceReader(new StringReader(source1)); ForkableScanner scanner1 = builder.Create(sr1); var result1 = runner.Run(scanner1); Assert.AreEqual("hello", result1); Assert.AreEqual(0, el.Count); }
public object GetResult(int index, CompilationErrorManager errorManager) { CodeContract.RequiresArgumentInRange(index >= 0 && index < m_acceptedHeads.Count, "index", "index is out of range"); var head = m_acceptedHeads[index]; if (head.Errors != null && errorManager != null) { //aggregate errors foreach (var error in head.Errors) { int errorId = error.ErrorId ?? m_errorDef.OtherErrorId; errorManager.AddError(errorId, error.ErrorPosition, error.ErrorArgument); } } return(head.TopStackValue); }
public object GetResult(int index, CompilationErrorManager errorManager) { CodeContract.RequiresArgumentInRange(index >= 0 && index < m_acceptedHeads.Count, "index", "index is out of range"); var head = m_acceptedHeads[index]; if (head.Errors != null && errorManager != null) { //aggregate errors foreach (var error in head.Errors) { int errorId = error.ErrorId ?? m_errorDef.OtherErrorId; errorManager.AddError(errorId, error.ErrorPosition, error.ErrorArgument); } } return head.TopStackValue; }
protected ParserBase(CompilationErrorManager errorManager) { CodeContract.RequiresArgumentNotNull(errorManager, "errorManager"); m_errorManager = errorManager; m_errorDefinition = new SyntaxErrors() { LexicalErrorId = 101, TokenUnexpectedId = 201, TokenMissingId = 202, TokenMistakeId = 203, OtherErrorId = 200 }; m_triviaTokens = new List <Token>(); EnableReplacementRecovery = true; EnableInsertionRecovery = true; EnableDeletionRecovery = true; }
public void AmbiguityGrammarAggregationTest() { CompilationErrorManager em = new CompilationErrorManager(); AmbiguityParser parser = new AmbiguityParser(em); const string input = "a<b>c;a<b>c;a<b>c;a<b>c;a<b>c;"; var result = parser.Parse(input); var resarr = result.ToArray(); Assert.AreEqual(5, resarr.Length); foreach (var r in resarr) { var ambStat = r as AmbiguityStatementNode; Assert.IsNotNull(ambStat); VarDeclStatementNode vardecl = ambStat.s1 as VarDeclStatementNode; if (vardecl == null) { vardecl = ambStat.s2 as VarDeclStatementNode; } Assert.IsNotNull(vardecl); ExpressionStatementNode expstat = ambStat.s1 as ExpressionStatementNode; if (expstat == null) { expstat = ambStat.s2 as ExpressionStatementNode; } Assert.IsNotNull(expstat); } }
public void ParserErrorRecoveryTest() { Lexicon binaryTreeSyntax = new Lexicon(); var lex = binaryTreeSyntax.Lexer; //lex Token LEFTPH = lex.DefineToken(RE.Symbol('(')); Token RIGHTPH = lex.DefineToken(RE.Symbol(')')); Token COMMA = lex.DefineToken(RE.Symbol(',')); Token LETTER = lex.DefineToken(RE.Range('a', 'z') | RE.Range('A', 'Z'), "ID"); //grammar Production <Node> NodeParser = new Production <Node>(); NodeParser.Rule = (from a in LETTER from _1 in LEFTPH from left in NodeParser from _2 in COMMA from right in NodeParser from _3 in RIGHTPH select new Node(a.Value.Content, left, right)) | Grammar.Empty <Node>(null); var builder = new ForkableScannerBuilder(binaryTreeSyntax.CreateScannerInfo()); const string correct = "A(B(,),C(,))"; string source = "A((B(,),C(,)"; SourceReader sr = new SourceReader( new StringReader(source)); var info = binaryTreeSyntax.CreateScannerInfo(); Scanner scanner = new Scanner(info); scanner.SetSource(sr); CompilationErrorManager errorManager = new CompilationErrorManager(); errorManager.DefineError(1, 0, CompilationStage.Parsing, "Unexpected token '{0}'"); errorManager.DefineError(2, 0, CompilationStage.Parsing, "Missing token '{0}'"); errorManager.DefineError(3, 0, CompilationStage.Parsing, "Invalid token found, did you mean '{0}' ?"); errorManager.DefineError(4, 0, CompilationStage.Parsing, "Syntax error"); ProductionInfoManager pim = new ProductionInfoManager(NodeParser.SuffixedBy(Grammar.Eos())); LR0Model lr0 = new LR0Model(pim); lr0.BuildModel(); string dot = lr0.ToString(); TransitionTable tt = TransitionTable.Create(lr0, info); SyntaxErrors errDef = new SyntaxErrors() { TokenUnexpectedId = 1, TokenMissingId = 2, OtherErrorId = 4, TokenMistakeId = 3 }; ParserEngine driver = new ParserEngine(tt, errDef); Lexeme r; do { r = scanner.Read(); driver.Input(r); } while (!r.IsEndOfStream); var result = driver.GetResult(0, errorManager.CreateErrorList()); ; }
public MethodBodyResolver(CompilationErrorManager errorManager, TypeCollection types) { m_errorManager = errorManager; m_types = types; }
public MiniSharpParser(CompilationErrorManager errorManager) : base(errorManager) { }
public OperatorManyParser(CompilationErrorManager em) : base(em) { }
public TypeDeclResolver(CompilationErrorManager errorManager) { m_errorManager = errorManager; m_types = new TypeCollection(); }
public void MultipleLexerParsingTest() { Lexicon lexicon = new Lexicon(); Lexer global = lexicon.Lexer; Lexer keywords = global.CreateSubLexer(); var PROPERTY = global.DefineToken(RE.Literal("property")); var ID = global.DefineToken(RE.Range('a', 'z').Concat( (RE.Range('a', 'z') | RE.Range('0', '9')).Many()), "ID"); var NUM = global.DefineToken(RE.Range('0', '9').Many1(), "NUM"); var EQ = global.DefineToken(RE.Symbol('=')); var SEMICOLON = global.DefineToken(RE.Symbol(';')); var LB = global.DefineToken(RE.Symbol('{')); var RB = global.DefineToken(RE.Symbol('}')); var WHITESPACE = global.DefineToken(RE.Symbol(' ').Union(RE.Symbol('\t')), "[ ]"); var GET = keywords.DefineToken(RE.Literal("get")); var assignStatement = from id in ID from eq in EQ from value in NUM from st in SEMICOLON select id.Value + "=" + value.Value; var getDef = from _get in GET from lb in LB from statements in assignStatement.Many() from rb in RB select new GetDef { Statements = statements }; var propDef = from _prop in PROPERTY from id in ID from lb in LB from getdef in getDef from rb in RB select new PropDef { PropName = id.Value.Content, GetDef = getdef }; string source = "property get { get { get = 1; } }"; SourceReader sr = new SourceReader( new StringReader(source)); var info = lexicon.CreateScannerInfo(); Scanner scanner = new Scanner(info); scanner.SetTriviaTokens(WHITESPACE.Index); scanner.SetSource(sr); CompilationErrorManager errorManager = new CompilationErrorManager(); errorManager.DefineError(1, 0, CompilationStage.Parsing, "Unexpected token '{0}'"); errorManager.DefineError(2, 0, CompilationStage.Parsing, "Missing token '{0}'"); errorManager.DefineError(3, 0, CompilationStage.Parsing, "Syntax error"); ProductionInfoManager pim = new ProductionInfoManager(propDef.SuffixedBy(Grammar.Eos())); LR0Model lr0 = new LR0Model(pim); lr0.BuildModel(); string dot = lr0.ToString(); TransitionTable tt = TransitionTable.Create(lr0, info); SyntaxErrors errDef = new SyntaxErrors() { TokenUnexpectedId = 1, TokenMissingId = 2, OtherErrorId = 3 }; ParserEngine driver = new ParserEngine(tt, errDef); Lexeme r; do { r = scanner.Read(); driver.Input(r); } while (!r.IsEndOfStream); var el = errorManager.CreateErrorList(); var result = (PropDef)driver.GetResult(0, el); Assert.AreEqual(0, el.Count); Assert.AreEqual("get", result.PropName); Assert.AreEqual("get=1", result.GetDef.Statements.First()); }
protected virtual void OnDefineParserErrors(CompilationErrorManager errorManager) { errorManager.DefineError(m_lexicalErrorId, 0, CompilationStage.Scanning, "Invalid token: {0}"); m_context.DefineDefaultCompilationErrorInfo(0); }
static void Main(string[] args) { string source = @" static class 程序入口 { //中文注释 public static void Main(string[] args) { Fac o; o = new Fac(); System.Console.WriteLine(o.ComputeFac(8)); } } class Fac { public int ComputeFac(int num) { int num_aux; if (num < 1) num_aux = 1; else num_aux = num * (this.ComputeFac(num - 1)); return num_aux; } public int Foo() { return 1; } } "; Stopwatch sw = new Stopwatch(); sw.Start(); CompilationErrorManager errorManager = new CompilationErrorManager(); CompilationErrorList errorList = errorManager.CreateErrorList(); MiniSharpParser p = new MiniSharpParser(errorManager); p.Initialize(); sw.Stop(); Console.WriteLine("Initialize time: {0} ms", sw.ElapsedMilliseconds); sw.Restart(); var ast = p.Parse(source, errorList); sw.Stop(); Console.WriteLine("Parsing time: {0} ms", sw.ElapsedMilliseconds); sw.Restart(); if (errorList.Count != 0) { ReportErrors(errorList); return; } TypeDeclResolver resolver1 = new TypeDeclResolver(errorManager); resolver1.DefineErrors(); resolver1.ErrorList = errorList; resolver1.Visit(ast); MemberDeclResolver resolver2 = new MemberDeclResolver(errorManager, resolver1.Types); resolver2.DefineErrors(); resolver2.ErrorList = errorList; resolver2.Visit(ast); MethodBodyResolver resolver3 = new MethodBodyResolver(errorManager, resolver1.Types); resolver3.DefineErrors(); resolver3.ErrorList = errorList; resolver3.Visit(ast); sw.Stop(); Console.WriteLine("Semantic analysis time: {0} ms", sw.ElapsedMilliseconds); if (errorList.Count != 0) { ReportErrors(errorList); return; } //generate Cil var codegenDomain = AppDomain.CurrentDomain; var cilTrans = new VBF.MiniSharp.Targets.Cil.EmitTranslator(codegenDomain, "test"); cilTrans.Create(ast, @"test.exe"); ; }
public void ParserDriverConflictTest() { Lexicon test = new Lexicon(); var X = test.Lexer.DefineToken(RE.Symbol('x')); var PLUS = test.Lexer.DefineToken(RE.Symbol('+')); var ASTERISK = test.Lexer.DefineToken(RE.Symbol('*')); var scannerinfo = test.CreateScannerInfo(); Production <object> E = new Production <object>(), T = new Production <object>(); E.Rule = (from e1 in E from plus in PLUS from e2 in E select(object)(((int)e1) + ((int)e2))) | (from e1 in E from mul in ASTERISK from e2 in E select(object)(((int)e1) * ((int)e2))) | T; T.Rule = from x in X select(object) 2; ProductionInfoManager pim = new ProductionInfoManager(E.SuffixedBy(Grammar.Eos())); LR0Model lr0 = new LR0Model(pim); lr0.BuildModel(); string dot = lr0.ToString(); TransitionTable tt = TransitionTable.Create(lr0, scannerinfo); ParserEngine driver = new ParserEngine(tt, new SyntaxErrors()); ForkableScannerBuilder builder = new ForkableScannerBuilder(scannerinfo); var em = new CompilationErrorManager(); var el = em.CreateErrorList(); builder.ErrorList = el; var scanner = builder.Create(new SourceReader(new StringReader("x+x*x"))); var z1 = scanner.Read(); driver.Input(z1); var z2 = scanner.Read(); driver.Input(z2); var z3 = scanner.Read(); driver.Input(z3); var z4 = scanner.Read(); driver.Input(z4); var z5 = scanner.Read(); driver.Input(z5); var z6 = scanner.Read(); driver.Input(z6); Assert.AreEqual(0, driver.CurrentStackCount); Assert.AreEqual(2, driver.AcceptedCount); var results = new[] { (int)driver.GetResult(0, null), (int)driver.GetResult(1, null) }; Assert.IsTrue(results.Contains(8)); Assert.IsTrue(results.Contains(6)); }
public void ParserDriverSimpleTest() { Lexicon test = new Lexicon(); var X = test.Lexer.DefineToken(RE.Symbol('x')); var PLUS = test.Lexer.DefineToken(RE.Symbol('+')); var scannerinfo = test.CreateScannerInfo(); Production <object> E = new Production <object>(), T = new Production <object>(); E.Rule = (from t in T from plus in PLUS from e in E select(object)(((int)t) + ((int)e))) | T; T.Rule = from x in X select(object) 1; ProductionInfoManager pim = new ProductionInfoManager(E.SuffixedBy(Grammar.Eos())); LR0Model lr0 = new LR0Model(pim); lr0.BuildModel(); string dot = lr0.ToString(); TransitionTable tt = TransitionTable.Create(lr0, scannerinfo); ParserEngine driver = new ParserEngine(tt, new SyntaxErrors() { TokenUnexpectedId = 1 }); ForkableScannerBuilder builder = new ForkableScannerBuilder(scannerinfo); var em = new CompilationErrorManager();; var el = em.CreateErrorList(); builder.ErrorList = el; var scanner = builder.Create(new SourceReader(new StringReader("x+x+x"))); var z1 = scanner.Read(); driver.Input(z1); var z2 = scanner.Read(); driver.Input(z2); var z3 = scanner.Read(); driver.Input(z3); var z4 = scanner.Read(); driver.Input(z4); var z5 = scanner.Read(); driver.Input(z5); var z6 = scanner.Read(); driver.Input(z6); Assert.AreEqual(0, driver.CurrentStackCount); Assert.AreEqual(1, driver.AcceptedCount); Assert.AreEqual(3, driver.GetResult(0, null)); }
public TreeParser(CompilationErrorManager em) : base(em) { }
public ParserContext(CompilationErrorManager errorManager, int deletionErrorId, int insertionErrorId) { m_errorManager = errorManager; InsertionErrorId = insertionErrorId; DeletionErrorId = deletionErrorId; }
public MemberDeclResolver(CompilationErrorManager errorManager, TypeCollection types) { m_errorManager = errorManager; m_types = types; }
public void WhereGrammaTest() { Lexicon test = new Lexicon(); var ID = test.Lexer.DefineToken(RE.Range('a', 'z').Concat( (RE.Range('a', 'z') | RE.Range('0', '9')).Many()), "ID"); var NUM = test.Lexer.DefineToken(RE.Range('0', '9').Many1(), "NUM"); var GREATER = test.Lexer.DefineToken(RE.Symbol('>')); var WHITESPACE = test.Lexer.DefineToken(RE.Symbol(' ').Union(RE.Symbol('\t')), "[ ]"); var p1 = from i in ID from g in GREATER from g2 in GREATER where Grammar.Check(g2.PrefixTrivia.Count == 0, 4, g2.Value.Span) from n in NUM select "A"; var p2 = from i in ID from g in GREATER from g2 in GREATER from n in NUM select "B"; var parser1 = p1 | p2; parser1.AmbiguityAggregator = (a, b) => a == "A" ? a : b; var info = test.CreateScannerInfo(); var errorManager = new CompilationErrorManager(); errorManager.DefineError(1, 0, CompilationStage.Parsing, "Unexpected token '{0}'"); errorManager.DefineError(2, 0, CompilationStage.Parsing, "Missing token '{0}'"); errorManager.DefineError(3, 0, CompilationStage.Parsing, "Syntax error"); errorManager.DefineError(4, 0, CompilationStage.Parsing, "White spaces between >> are not allowed"); var el = errorManager.CreateErrorList(); ProductionInfoManager pim = new ProductionInfoManager(parser1.SuffixedBy(Grammar.Eos())); LR0Model lr0 = new LR0Model(pim); lr0.BuildModel(); string dot = lr0.ToString(); TransitionTable tt = TransitionTable.Create(lr0, info); var errdef = new SyntaxErrors() { TokenUnexpectedId = 1, TokenMissingId = 2, OtherErrorId = 3 }; ParserEngine driver = new ParserEngine(tt, errdef); string source1 = "abc >> 123"; var sr1 = new SourceReader(new StringReader(source1)); Scanner scanner = new Scanner(info); scanner.SetTriviaTokens(WHITESPACE.Index); scanner.SetSource(sr1); Lexeme r; do { r = scanner.Read(); driver.Input(r); } while (!r.IsEndOfStream); Assert.AreEqual(1, driver.AcceptedCount); Assert.AreEqual("A", driver.GetResult(0, el)); Assert.AreEqual(0, el.Count); ParserEngine driver2 = new ParserEngine(tt, errdef); string source2 = "abc > > 123"; var sr2 = new SourceReader(new StringReader(source2)); scanner.SetSource(sr2); do { r = scanner.Read(); driver2.Input(r); } while (!r.IsEndOfStream); var el2 = errorManager.CreateErrorList(); Assert.AreEqual(1, driver2.AcceptedCount); Assert.AreEqual("B", driver2.GetResult(0, el2)); Assert.AreEqual(0, el2.Count); }