private static JsonObject ParseANTLRStream(ANTLRStringStream inputStream)
{
var lexer = new JsonLexer(inputStream);
var tokens = new CommonTokenStream(lexer);
var parser = new JsonParser(tokens);
var parseTree = parser.@object().Tree;
var stream = new CommonTreeNodeStream(parseTree);
var tree = new JsonTree(stream);
var @object = tree.@object();
Contract.Assume(@object != null);
return(new JsonObject(JsonValueTypes.Interpret(@object)));
}
public Document(string sourcetext)
{
var stringstream = new ANTLRStringStream(sourcetext);
var lexer = new WebIDLLexer(stringstream);
var tokens = new CommonTokenStream(lexer);
var grammar = new WebIDLParser(tokens);
this.members = new Package(this);
this.members.append((CommonTree)grammar.documentDef().Tree);
}
private void Highlighting(object sender, TextChangedEventArgs e)
{
try
{ //ANTLRReaderStream input = new ANTLRReaderStream(Code.Document)
string text = new TextRange(Code.Document.ContentStart, Code.Document.ContentEnd).Text;
//ANTLRInputStream reader = new ANTLRInputStream(text);
ANTLRStringStream input = new ANTLRStringStream(text);
GrammarLexer lexer = new GrammarLexer((Antlr4.Runtime.ICharStream)input);
ITokenStream tokens = new CommonTokenStream((Antlr.Runtime.ITokenSource)lexer);
GrammarParser parser = new GrammarParser((Antlr4.Runtime.ITokenStream)tokens);
parser.prog();
}
catch (Exception ex)
{ }
}
public void FreeExprGrouping()
{
string input = "a=1 AND b=2 OR c=3 AND d=4 OR e=5";
var stream = new ANTLRStringStream(input);
var lexer = new SQLFilterLexer(stream);
var tokens = new CommonTokenStream(lexer);
var parser = new SQLFilterParser(tokens);
var val = parser.prog();
/*outer or tree */
Assert.AreEqual(SQLFilterParser.OR, val.Tree.Type);
Assert.AreEqual(3, val.Tree.ChildCount);
Assert.AreEqual(SQLFilterParser.AND, val.Tree.GetChild(0).Type);
Assert.AreEqual(SQLFilterParser.AND, val.Tree.GetChild(1).Type);
Assert.AreEqual(SQLFilterParser.NUM_EXPR, val.Tree.GetChild(2).Type);
}
public void NumExprSubtyping()
{
string input = @"Players <> 3";
var stream = new ANTLRStringStream(input);
var lexer = new SQLFilterLexer(stream);
var tokens = new CommonTokenStream(lexer);
var parser = new SQLFilterParser(tokens);
var root = parser.prog().Tree;
Filter<FakeServer>.NormalizeNodes((SQLTree)root);
/* now check our tree */
Assert.AreEqual(SQLFilterLexer.AND, root.Type);
Assert.AreEqual(SQLFilterLexer.NUM_EXPR, root.Children[0].Type);
Assert.AreEqual(SQLFilterLexer.INT, root.Children[0].GetChild(0).GetChild(1).Type);
Assert.AreEqual(SQLFilterLexer.INT32, ((FilterTree)root.Children[0].GetChild(0).GetChild(1)).SubType);
}
public void IPV4Expr()
{
string input = @"FakeAddress >= 127.0.0.1";
var stream = new ANTLRStringStream(input);
var lexer = new SQLFilterLexer(stream);
var tokens = new CommonTokenStream(lexer);
var parser = new SQLFilterParser(tokens);
var root = parser.prog().Tree;
Filter<FakeServer>.NormalizeNodes((SQLTree)root);
Assert.AreEqual(SQLFilterLexer.AND, root.Type);
Assert.AreEqual(SQLFilterLexer.IP_EXPR, root.Children[0].Type);
Assert.AreEqual(SQLFilterLexer.GREATEROREQUALS, root.Children[0].GetChild(0).Type);
Assert.AreEqual(SQLFilterLexer.ID, root.Children[0].GetChild(0).GetChild(0).Type);
Assert.AreEqual(SQLFilterLexer.IPV4, root.Children[0].GetChild(0).GetChild(1).Type);
}
public static JsonArray Parse(string s)
{
var inputStream = new ANTLRStringStream(s);
var lexer = new JsonLexer(inputStream);
var tokens = new CommonTokenStream(lexer);
var parser = new JsonParser(tokens);
var parseTree = parser.array().Tree;
var stream = new CommonTreeNodeStream(parseTree);
var tree = new JsonTree(stream);
var @object = tree.array();
Contract.Assume(@object != null);
return(new JsonArray(JsonValueTypes.Interpret(@object)));
}
public static IExpression <T> Parse <T>(string expressionText)
{
var stream = new ANTLRStringStream(expressionText);
var lexer = new netmxprLexer(stream);
var tokens = new CommonTokenStream(lexer);
var parser = new netmxprParser(tokens)
{
TreeAdaptor = new CommonTreeAdaptor()
};
var result = parser.parse();
var tree = (BaseTree)result.Tree;
return((IExpression <T>)VisitNode(tree));
}
public void SimpleExprGroup()
{
string input = "6532432 <= balalajka AND _kabza LIKE \'%asfe%\'";
var stream = new ANTLRStringStream(input);
var lexer = new SQLFilterLexer(stream);
var tokens = new CommonTokenStream(lexer);
var parser = new SQLFilterParser(tokens);
var val = parser.prog();
Assert.AreEqual(SQLFilterParser.AND, val.Tree.Type);
Assert.AreEqual(2, val.Tree.ChildCount);
Assert.AreEqual(SQLFilterParser.NUM_EXPR, val.Tree.GetChild(0).Type);
Assert.AreEqual(1, val.Tree.GetChild(0).ChildCount);
Assert.AreEqual(SQLFilterParser.STRING_EXPR, val.Tree.GetChild(1).Type);
Assert.AreEqual(1, val.Tree.GetChild(1).ChildCount);
}
private static void _Main(string[] args)
{
// input "x = 2*(3+3)"
ICharStream input;
if (args.Length > 0)
{
if (args[0].Equals("-i"))
{
if (args.Length > 1)
{
input = new ANTLRFileStream(args[1]);
}
else
{
throw new Exception("No input file specified.");
}
}
else
{
input = new ANTLRStringStream(args[0]);
}
}
else
{
input = new ANTLRInputStream(Console.OpenStandardInput());
}
var lex = new VecMathLexer(input);
var tokens = new CommonTokenStream(lex);
var g = new VecMathParser(tokens);
IAstRuleReturnScope <CommonTree> r = g.prog();
CommonTree t = r.Tree;
Console.WriteLine("Original tree: " + t.ToStringTree());
var simplify = new Simplify(new CommonTreeNodeStream(t));
t = (CommonTree)simplify.Downup(t);
var reduce = new Reduce(new CommonTreeNodeStream(t));
t = (CommonTree)reduce.Downup(t);
Console.WriteLine("Simplified tree: " + t.ToStringTree());
Console.ReadKey();
}
public static TargetCppResult Compile(string input, string file_name)
{
if (file_name.LastIndexOf("/") != -1)
{
file_name = file_name.Substring(file_name.LastIndexOf("/") + 1);
}
if (file_name.LastIndexOf("\\") != -1)
{
file_name = file_name.Substring(file_name.LastIndexOf("\\") + 1);
}
input = input.Replace("\r", "");
ANTLRStringStream Input = new ANTLRStringStream(input);
SugarCppLexer lexer = new SugarCppLexer(Input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
SugarCppParser parser = new SugarCppParser(tokens);
AstParserRuleReturnScope <CommonTree, IToken> t = parser.root();
CommonTree ct = (CommonTree)t.Tree;
if (parser.errors.Count() > 0)
{
StringBuilder sb = new StringBuilder();
foreach (var error in parser.errors)
{
sb.Append(error);
sb.Append("\n");
}
throw new Exception(sb.ToString());
}
CommonTreeNodeStream nodes = new CommonTreeNodeStream(ct);
SugarWalker walker = new SugarWalker(nodes);
Root ast = walker.root();
TargetCppHeader header = new TargetCppHeader();
TargetCppImplementation implementation = new TargetCppImplementation();
implementation.HeaderFileName = string.Format("{0}.h", file_name);
TargetCppResult result = new TargetCppResult();
result.Header = ast.Accept(header).Render();
result.Implementation = ast.Accept(implementation).Render();
return(result);
}
public void TestEmptyComment()
{
string inputText = "/**/ ";
var input = new ANTLRStringStream(inputText);
var lexer = new PreprocessorLexer(input);
var tokenStream = new CommonTokenStream(lexer);
tokenStream.Fill();
List <IToken> tokens = tokenStream.GetTokens();
Assert.AreEqual(2, tokens.Count);
Assert.AreEqual(PreprocessorLexer.DELIMITED_COMMENT, tokens[0].Type);
Assert.AreEqual("/**/", tokens[0].Text);
Assert.AreEqual(PreprocessorLexer.EOF, tokens[1].Type);
}
/// <summary>
/// Test-parses the MapCSS.
/// </summary>
/// <param name="embeddedPath"></param>
private AstParserRuleReturnScope <object, IToken> TestMapCSSParsing(string embeddedPath)
{
// get the text from the embedded test file.
Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(embeddedPath);
Assert.IsNotNull(stream);
var reader = new StreamReader(stream);
string s = reader.ReadToEnd();
var input = new ANTLRStringStream(s);
var lexer = new MapCSSLexer(input);
var tokens = new CommonTokenStream(lexer);
var parser = new MapCSSParser(tokens);
return(parser.stylesheet());
}
private ITree GetAntlrComputedExpressionTree()
{
ICharStream input = new ANTLRStringStream(sourceText);
JavascriptLexer lexer = new JavascriptLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
JavascriptParser parser = new JavascriptParser(tokens);
try
{
return(parser.Expression().Tree);
}
catch (RecognitionException re)
{
throw new ArgumentException(re.Message, re);
}
}
public IEnumerable ExecQuery(string query)
{
ICharStream input = new ANTLRStringStream(query);
//Lexer
DhsqLexer lexer = new DhsqLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
//Parser and AST construction
DhsqParser parser = new DhsqParser(tokens);
DhsqParser.query_return result = parser.query();
var visitor = new InterpreterVisitor();
return(visitor.VisitSelect((SelectStatement)result.StatementValue));
}
public static TypeSyntax Parse(string name)
{
try
{
var inputStream = new ANTLRStringStream(name);
var lexer = new CSharpNamesLexer(inputStream);
var tokenStream = new CommonTokenStream(lexer);
var parser = new CSharpNamesParser(tokenStream);
return(parser.prog().value);
}
catch (Exception ex)
{
throw new CSharpSyntaxException("Cannot parse name", ex);
}
}
public Module Compile(string function)
{
var input = new ANTLRStringStream(function);
var lexer = new NPortugolLexer(input);
var tokens = new CommonTokenStream(lexer);
var parser = new NPortugolParser(tokens);
var ast = parser.script();
var tree = (CommonTree)ast.Tree;
var nodes = new CommonTreeNodeStream(tree)
{
TokenStream = tokens
};
var walker = new NPortugolWalker(nodes);
return(walker.compile());
}
public void SimpleEnumExpr()
{
string input = "\"szafa\" = \'asdas\'";
var stream = new ANTLRStringStream(input);
var lexer = new SQLFilterLexer(stream);
var tokens = new CommonTokenStream(lexer);
var parser = new SQLFilterParser(tokens);
var val = parser.prog();
Assert.AreEqual(SQLFilterParser.AND, val.Tree.Type);
Assert.AreEqual(1, val.Tree.ChildCount);
ITree exprTree = val.Tree.Children[0];
Assert.AreEqual(SQLFilterParser.ENUM_EXPR, exprTree.Type);
Assert.AreEqual(1, exprTree.ChildCount);
Assert.AreEqual("=", exprTree.GetChild(0).Text);
Assert.AreEqual(2, exprTree.GetChild(0).ChildCount);
Assert.AreEqual("szafa", exprTree.GetChild(0).GetChild(0).Text);
Assert.AreEqual("asdas", exprTree.GetChild(0).GetChild(1).Text);
}
public void ComplexStringExpr()
{
string input = "\'%_%ho _s!ama\' LIKE _karamba";
var stream = new ANTLRStringStream(input);
var lexer = new SQLFilterLexer(stream);
var tokens = new CommonTokenStream(lexer);
var parser = new SQLFilterParser(tokens);
var val = parser.prog();
Assert.AreEqual(SQLFilterParser.AND, val.Tree.Type);
Assert.AreEqual(1, val.Tree.ChildCount);
ITree exprTree = val.Tree.Children[0];
Assert.AreEqual(SQLFilterParser.STRING_EXPR, exprTree.Type);
Assert.AreEqual(1, exprTree.ChildCount);
Assert.AreEqual(StringPatternParser.COMPLEX, exprTree.GetChild(0).Type);
Assert.AreEqual(2, exprTree.GetChild(0).ChildCount);
Assert.AreEqual("_karamba", exprTree.GetChild(0).GetChild(0).Text);
Assert.AreEqual("%_%ho _s!ama", exprTree.GetChild(0).GetChild(1).Text);
}
public static void Main(string[] args)
{
try {
// в зависимости от наличия параметров командной строки разбираем
// либо файл с именем, переданным первым параметром, либо стандартный ввод
Context context = new Context(null);
string src = @"
void printInt(int a) { }
void printDouble(double a) { }
double sqrt(double a) { }
double sqr(double a) { }
int readInt() { }
double readDouble() { }
";
//Check(src, context);
src = args.Length == 1 ? new StreamReader(args[0]).ReadToEnd()
: Console.In.ReadToEnd();
ICharStream input = new ANTLRStringStream(src);
MathExprLexer lexer = new MathExprLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
MathExprParser parser = new MathExprParser(tokens);
parser.TreeAdaptor = new AstNodeTreeAdapter();
ITree program = (ITree)parser.execute().Tree;
AstNodePrinter.Print(program);
Console.WriteLine();
SemanticChecker.Check((AstNode)program, context);
AstNodePrinter.Print(program);
//Console.ReadLine();
AstNodePrinter.Print(program);
Console.WriteLine();
string msil = MSILGenerator.GenerateMSIL(program, context);
Console.WriteLine(msil);
Console.WriteLine();
Console.ReadLine();
}
catch (Exception e) {
Console.WriteLine("Error: {0}", e);
Console.ReadLine();
}
}
private ITree GetAntlrComputedExpressionTree()
{
ICharStream input = new ANTLRStringStream(sourceText);
JavascriptLexer lexer = new JavascriptLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
JavascriptParser parser = new JavascriptParser(tokens);
try
{
return(parser.Expression().Tree);
}
catch (RecognitionException re)
{
throw new ArgumentException(re.Message, re);
}
// LUCENENET: Antlr 3.5.1 doesn't ever wrap ParseException, so the other catch block
// for RuntimeException that wraps ParseException would have
// been completely unnecesary in Java and is also unnecessary here.
}
public void SimpleIPExpr()
{
string input = "65.43.23.198 > _karamba";
var stream = new ANTLRStringStream(input);
var lexer = new SQLFilterLexer(stream);
var tokens = new CommonTokenStream(lexer);
var parser = new SQLFilterParser(tokens);
var val = parser.prog();
Assert.AreEqual(SQLFilterParser.AND, val.Tree.Type);
Assert.AreEqual(1, val.Tree.ChildCount);
ITree exprTree = val.Tree.Children[0];
Assert.AreEqual(SQLFilterParser.IP_EXPR, exprTree.Type);
Assert.AreEqual(1, exprTree.ChildCount);
Assert.AreEqual(SQLFilterParser.LESSER, exprTree.GetChild(0).Type);
Assert.AreEqual(2, exprTree.GetChild(0).ChildCount);
Assert.AreEqual("_karamba", exprTree.GetChild(0).GetChild(0).Text);
Assert.AreEqual("65.43.23.198", exprTree.GetChild(0).GetChild(1).Text);
Assert.AreEqual(SQLFilterParser.IPV4, exprTree.GetChild(0).GetChild(1).Type);
}
private static DotGraph <int> Parse(string content)
{
var antlrStream = new ANTLRStringStream(content);
var lexer = new DotGrammarLexer(antlrStream);
var tokenStream = new CommonTokenStream(lexer);
var parser = new DotGrammarParser(tokenStream);
var builder = new IntDotGraphBuilder();
parser.Builder = builder;
// parser.dot();
try
{
parser.dot();
}
catch (StackOverflowException e)
{
Console.WriteLine(e.Message + "\n" + e.StackTrace + "\n" + e.Source);
}
return(builder.DotGraph);
}
public void SimpleNumericExpr()
{
string input = "6532432 <= balalajka";
var stream = new ANTLRStringStream(input);
var lexer = new SQLFilterLexer(stream);
var tokens = new CommonTokenStream(lexer);
var parser = new SQLFilterParser(tokens);
var val = parser.prog();
Assert.AreEqual(SQLFilterParser.AND, val.Tree.Type);
Assert.AreEqual(1, val.Tree.ChildCount);
ITree exprTree = val.Tree.Children[0];
Assert.AreEqual(SQLFilterParser.NUM_EXPR, exprTree.Type);
Assert.AreEqual(1, exprTree.ChildCount);
Assert.AreEqual(SQLFilterParser.GREATEROREQUALS, exprTree.GetChild(0).Type);
Assert.AreEqual(2, exprTree.GetChild(0).ChildCount);
Assert.AreEqual("balalajka", exprTree.GetChild(0).GetChild(0).Text);
Assert.AreEqual(SQLFilterParser.ID, exprTree.GetChild(0).GetChild(0).Type);
Assert.AreEqual("6532432", exprTree.GetChild(0).GetChild(1).Text);
Assert.AreEqual(SQLFilterParser.INT, exprTree.GetChild(0).GetChild(1).Type);
}
private void CreatesAst(string source)
{
//ANTLRFileStream fStream = new ANTLRFileStream(source, Encoding.ASCII);
ANTLRStringStream stream = new ANTLRStringStream(source);
HlslLexer lexer = new HlslLexer(stream);
HlslParser parser = new HlslParser(new CommonTokenStream(lexer));
parser.GlobalScope = _globalScope;
var program = parser.Program();
_programs.Add(program);
if (parser.Errors.Count > 0)
{
foreach (var item in parser.Errors)
{
_log.Error(item.Message, item.Line, item.CharPositionInLine);
}
return;
}
}
public void TestCreateDot()
{
ANTLRStringStream input = new ANTLRStringStream("3 * x");
SimpleExpressionLexer lexer = new SimpleExpressionLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
SimpleExpressionParser parser = new SimpleExpressionParser(tokens);
var result = parser.expression();
var tree = result.Tree;
var adaptor = parser.TreeAdaptor;
DotTreeGenerator gen = new DotTreeGenerator();
string output = gen.ToDot(tree, adaptor);
string newline = Environment.NewLine;
string expected =
@"digraph {" + newline
+ newline
+ @" ordering=out;"+ newline
+ @" ranksep=.4;"+ newline
+ @" bgcolor=""lightgrey""; node [shape=box, fixedsize=false, fontsize=12, fontname=""Helvetica-bold"", fontcolor=""blue"""+ newline
+ @" width=.25, height=.25, color=""black"", fillcolor=""white"", style=""filled, solid, bold""];"+ newline
+ @" edge [arrowsize=.5, color=""black"", style=""bold""]"+ newline
+ newline
+ @" n0 [label=""""];" + newline
+ @" n1 [label=""*""];" + newline
+ @" n1 [label=""*""];" + newline
+ @" n2 [label=""3""];" + newline
+ @" n3 [label=""x""];" + newline
+ @" n4 [label=""""];" + newline
+ newline
+ @" n0 -> n1 // """" -> ""*""" + newline
+ @" n1 -> n2 // ""*"" -> ""3""" + newline
+ @" n1 -> n3 // ""*"" -> ""x""" + newline
+ @" n0 -> n4 // """" -> """"" + newline
+ newline
+ @"}" + newline
+ @"";
Assert.AreEqual(expected, output);
}
public static void Loop2()
{
bool exit = false;
string input = "";
KermitParser parser = new KermitParser(null);
//parser.TreeAdaptor = new KermitAdaptor();
while (!exit)
{
if (input == string.Empty)
{
Console.Write("> ");
}
else
{
Console.Write(".. ");
}
input += Console.ReadLine() + "\n";
ANTLRStringStream stream = new ANTLRStringStream(input);
KermitLexer lexer = new KermitLexer(stream);
TokenRewriteStream tokens = new TokenRewriteStream(lexer);
parser.TokenStream = tokens;
try
{
AstParserRuleReturnScope <KermitAST, CommonToken> result = parser.program();
var tree = (CommonTree)result.Tree;
DotTreeGenerator gen = new DotTreeGenerator();
Console.WriteLine("{0}", gen.ToDot(tree));
input = "";
//Console.WriteLine(globalScope.ToString());
}
catch (PartialStatement)
{
}
catch (ParserException e)
{
}
}
}
public BaseAST Parse(string code)
{
var codeStream = new ANTLRStringStream(code);
var lexer = new EvaluationGrammarLexer(codeStream);
if (lexer.NumberOfSyntaxErrors > 0)
{
return(null);
}
var tokenStream = new CommonTokenStream(lexer);
var parser = new EvaluationGrammarParser(tokenStream);
var parseTree = (CommonTree)parser.program().Tree;
if (parser.NumberOfSyntaxErrors > 0)
{
return(null);
}
var nodes = new CommonTreeNodeStream(parseTree);
var astGenerator = new ASTGenerator(nodes);
return(astGenerator.getAST());
}
public void TestMismatchedTokenError()
{
Assert.Inconclusive("May be failing on just my port...");
Grammar pg = new Grammar(
"parser grammar p;\n" +
"prog : WHILE ID LCURLY (assign)* RCURLY;\n" +
"assign : ID ASSIGN expr SEMI ;\n" +
"expr : INT | FLOAT | ID ;\n");
Grammar g = new Grammar();
g.FileName = Grammar.IGNORE_STRING_IN_GRAMMAR_FILE_NAME + "string";
g.ImportTokenVocabulary(pg);
g.SetGrammarContent(
"lexer grammar t;\n" +
"WHILE : 'while';\n" +
"LCURLY : '{';\n" +
"RCURLY : '}';\n" +
"ASSIGN : '=';\n" +
"SEMI : ';';\n" +
"ID : ('a'..'z')+ ;\n" +
"INT : (DIGIT)+ ;\n" +
"FLOAT : (DIGIT)+ '.' (DIGIT)* ;\n" +
"fragment DIGIT : '0'..'9';\n" +
"WS : (' ')+ ;\n");
ICharStream input = new ANTLRStringStream("while x { i=1 y=3.42; z=y; }");
Interpreter lexEngine = new Interpreter(g, input);
FilteringTokenStream tokens = new FilteringTokenStream(lexEngine);
tokens.SetTokenTypeChannel(g.GetTokenType("WS"), 99);
//System.out.println("tokens="+tokens.toString());
Interpreter parseEngine = new Interpreter(pg, tokens);
ParseTree t = parseEngine.Parse("prog");
string result = t.ToStringTree();
string expecting =
"(<grammar p> (prog while x { (assign i = (expr 1) MismatchedTokenException(5!=9))))";
assertEquals(expecting, result);
}
public void Test2ndToken()
{
Grammar g = new Grammar(
"lexer grammar t;\n" +
"ID : 'a'..'z'+;\n" +
"INT : '0'..'9'+;\n" +
"SEMI : ';';\n" +
"ASSIGN : '=';\n" +
"PLUS : '+';\n" +
"MULT : '*';\n" +
"WS : ' '+;\n");
// Tokens: 012345678901234567
// Input: x = 3 * 0 + 2 * 0;
ICharStream input = new ANTLRStringStream("x = 3 * 0 + 2 * 0;");
Interpreter lexEngine = new Interpreter(g, input);
BufferedTokenStream tokens = new BufferedTokenStream(lexEngine);
string result = tokens.LT(2).Text;
string expecting = " ";
Assert.AreEqual(expecting, result);
}
public void TestSizeOnANTLRStringStream()
{
ANTLRStringStream s1 = new ANTLRStringStream("lexer\r\n");
Assert.AreEqual(7, s1.Size());
ANTLRStringStream s2 = new ANTLRStringStream(grammarStr);
Assert.AreEqual(grammarStr.Length, s2.Size());
ANTLRStringStream s3 = new ANTLRStringStream("grammar P;");
Assert.AreEqual(10, s3.Size());
}
public void TestResetOnANTLRStringStream()
{
ANTLRStringStream stream = new ANTLRStringStream("One\r\nTwo");
Assert.AreEqual(0, stream.Index());
Assert.AreEqual(0, stream.CharPositionInLine);
Assert.AreEqual(1, stream.Line);
stream.Consume(); // O
stream.Consume(); // n
Assert.AreEqual('e', stream.LA(1));
Assert.AreEqual(2, stream.Index());
stream.Reset();
Assert.AreEqual('O', stream.LA(1));
Assert.AreEqual(0, stream.Index());
Assert.AreEqual(0, stream.CharPositionInLine);
Assert.AreEqual(1, stream.Line);
stream.Consume(); // O
Assert.AreEqual('n', stream.LA(1));
Assert.AreEqual(1, stream.Index());
Assert.AreEqual(1, stream.CharPositionInLine);
Assert.AreEqual(1, stream.Line);
stream.Consume(); // n
Assert.AreEqual('e', stream.LA(1));
Assert.AreEqual(2, stream.Index());
Assert.AreEqual(2, stream.CharPositionInLine);
Assert.AreEqual(1, stream.Line);
stream.Consume(); // e
}
public void TestSubstringOnANTLRStringStream()
{
ANTLRStringStream stream = new ANTLRStringStream("One\r\nTwo\r\nThree");
Assert.AreEqual("Two", stream.Substring(5, 7));
Assert.AreEqual("One", stream.Substring(0, 2));
Assert.AreEqual("Three", stream.Substring(10, 14));
stream.Consume();
Assert.AreEqual("Two", stream.Substring(5, 7));
Assert.AreEqual("One", stream.Substring(0, 2));
Assert.AreEqual("Three", stream.Substring(10, 14));
}
public void TestSizeOnEmptyANTLRStringStream()
{
ANTLRStringStream s1 = new ANTLRStringStream("");
Assert.AreEqual(0, s1.Size());
Assert.AreEqual(0, s1.Index());
}
/// <summary>
/// Create a Lexer,
/// get the tokens from the source,
/// create a Parser.
/// </summary>
/// <param name="source">The source code</param>
/// <returns>The Psimulex Parser</returns>
private static PsimulexParser CreateParser(string source)
{
// StringStreem
var stream = new ANTLRStringStream(source);
// Lexer
PsimulexLexer lexer = new PsimulexLexer(stream);
// TokenStreem
CommonTokenStream tokenStreem = new CommonTokenStream(lexer);
// Parser
return new PsimulexParser(tokenStreem);
}
public void TestConsumeOnANTLRStringStream()
{
ANTLRStringStream stream = new ANTLRStringStream("One\r\nTwo");
Assert.AreEqual(0, stream.Index());
Assert.AreEqual(0, stream.CharPositionInLine);
Assert.AreEqual(1, stream.Line);
stream.Consume(); // O
Assert.AreEqual(1, stream.Index());
Assert.AreEqual(1, stream.CharPositionInLine);
Assert.AreEqual(1, stream.Line);
stream.Consume(); // n
Assert.AreEqual(2, stream.Index());
Assert.AreEqual(2, stream.CharPositionInLine);
Assert.AreEqual(1, stream.Line);
stream.Consume(); // e
Assert.AreEqual(3, stream.Index());
Assert.AreEqual(3, stream.CharPositionInLine);
Assert.AreEqual(1, stream.Line);
stream.Consume(); // \r
Assert.AreEqual(4, stream.Index());
Assert.AreEqual(4, stream.CharPositionInLine);
Assert.AreEqual(1, stream.Line);
stream.Consume(); // \n
Assert.AreEqual(5, stream.Index());
Assert.AreEqual(0, stream.CharPositionInLine);
Assert.AreEqual(2, stream.Line);
stream.Consume(); // T
Assert.AreEqual(6, stream.Index());
Assert.AreEqual(1, stream.CharPositionInLine);
Assert.AreEqual(2, stream.Line);
stream.Consume(); // w
Assert.AreEqual(7, stream.Index());
Assert.AreEqual(2, stream.CharPositionInLine);
Assert.AreEqual(2, stream.Line);
stream.Consume(); // o
Assert.AreEqual(8, stream.Index());
Assert.AreEqual(3, stream.CharPositionInLine);
Assert.AreEqual(2, stream.Line);
stream.Consume(); // EOF
Assert.AreEqual(8, stream.Index());
Assert.AreEqual(3, stream.CharPositionInLine);
Assert.AreEqual(2, stream.Line);
stream.Consume(); // EOF
Assert.AreEqual(8, stream.Index());
Assert.AreEqual(3, stream.CharPositionInLine);
Assert.AreEqual(2, stream.Line);
}
