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);
}
