public void TestCompleteBuffer() { 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); int i = 1; IToken t = tokens.LT(i); while (t.Type != CharStreamConstants.EndOfFile) { i++; t = tokens.LT(i); } tokens.LT(i++); // push it past end tokens.LT(i++); string result = tokens.ToString(); string expecting = "x = 3 * 0 + 2 * 0;"; Assert.AreEqual(expecting, result); }
public static LuaResult Compile( StaticMetaTables staticTables, string source, dynamic globals = null, string name = null) { var result = new LuaResult(); var stopwatch = new Stopwatch(); stopwatch.Start(); try { var stream = new ANTLRStringStream(source); var lexer = new ChunkLexer(stream); var tokenStream = new CommonTokenStream(lexer); var parser = new ChunkParser(tokenStream); var r = parser.chunk(); result.Errors.AddRange(parser.Errors); Expression e; var scope = Scope.NewTopLevelScop(); var chunk = new Chunk(); result.Errors.AddRange(chunk.Generate(staticTables, scope, r.Tree, out e)); var fnExp = Expression.Lambda<Func<Table, object>>(e, scope.Env.GlobalParameter); result.Chunk = new CompiledChunk(fnExp.Compile(), globals ?? new Table(), name); } finally { stopwatch.Stop(); result.ElapsedTime = stopwatch.Elapsed; result.Success = !result.Errors.ContainsError(); } return result; }
public void TestMismatchedSetError() { 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.ImportTokenVocabulary(pg); g.FileName = "<string>"; 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=; 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 MismatchedSetException(10!={5,6,7})))))"; Assert.AreEqual(expecting, result); }
/// <summary> /// Parses an expression in text form for later evaluation. /// </summary> /// <param name="pszCode">The expression to be parsed.</param> /// <param name="dwFlags">A combination of flags from the PARSEFLAGS enumeration that controls parsing.</param> /// <param name="nRadix">The radix to be used in parsing any numerical information in pszCode.</param> /// <param name="ppExpr">Returns the IDebugExpression2 object that represents the parsed expression, which is ready for binding and evaluation.</param> /// <param name="pbstrError">Returns the error message if the expression contains an error.</param> /// <param name="pichError">Returns the character index of the error in pszCode if the expression contains an error.</param> /// <returns>If successful, returns S_OK; otherwise, returns an error code.</returns> /// <remarks> /// When this method is called, a debug engine (DE) should parse the expression and validate it for correctness. /// The pbstrError and pichError parameters may be filled in if the expression is invalid. /// /// Note that the expression is not evaluated, only parsed. A later call to the IDebugExpression2.EvaluateSync /// or IDebugExpression2.EvaluateAsync methods evaluates the parsed expression. /// </remarks> public int ParseText(string pszCode, enum_PARSEFLAGS dwFlags, uint nRadix, out IDebugExpression2 ppExpr, out string pbstrError, out uint pichError) { if (pszCode == null) throw new ArgumentNullException("pszCode"); if (pszCode.Length == 0) throw new ArgumentException(); // dwFlags=0 in the Immediate window if (dwFlags != enum_PARSEFLAGS.PARSE_EXPRESSION && dwFlags != 0) throw new NotImplementedException(); try { var expressionInput = new ANTLRStringStream(pszCode); var expressionUnicodeInput = new JavaUnicodeStream(expressionInput); var expressionLexer = new Java2Lexer(expressionUnicodeInput); var expressionTokens = new CommonTokenStream(expressionLexer); var expressionParser = new Java2Parser(expressionTokens); IAstRuleReturnScope<CommonTree> result = expressionParser.standaloneExpression(); ppExpr = new JavaDebugExpression(this, result.Tree, pszCode); pbstrError = null; pichError = 0; return VSConstants.S_OK; } catch (RecognitionException e) { ppExpr = null; pbstrError = e.Message; pichError = (uint)Math.Max(0, e.Index); return VSConstants.E_FAIL; } }
public void VisitLine(String line) { Core interp_visitor = new Core(); PrintVisitor print_visitor = new PrintVisitor(interp_visitor); ANTLRStringStream string_stream = new ANTLRStringStream(line); spinachLexer lexer = new spinachLexer(string_stream); CommonTokenStream tokens = new CommonTokenStream(lexer); spinachParser parser = new Test_Core(tokens, ""); try { spinachParser.program_return program = parser.program(); //h= (l+j)*h*l+l-h; if (strBuilder.ToString() == "") { List<Element> elements = program.ret; ///-- call core function. to pass list of element. for (int i = 0; i < elements.Count; i++) { Element curr = elements[i]; curr.Accept(print_visitor); curr.Accept(interp_visitor);//PlotReceiver } } else { Onerror(101, strBuilder.ToString()); } } catch (RecognitionException e) { Onerror(102, e.Message); } }
public Expression Compile(String relinqScript) { var input = new ANTLRStringStream(relinqScript); var lex = new EcmaScriptV3Lexer(input); var tokens = new CommonTokenStream(lex); var parser = new EcmaScriptV3Parser(tokens); var es3Ast = parser.expression(); var rsAst = new RelinqScriptParser().Visit((CommonTree)es3Ast.Tree); var compilerAst = new TypeInferenceAstBuilder().Visit(rsAst); using (var engine = new TypeInferenceEngine(compilerAst)) { #if DEBUG try { var wtf = 0; while(!engine.Run()) if (wtf++ == 10) break; return new StronglyTypedAstBuilder().Visit(compilerAst); } catch (Exception) { engine.Dump(); throw; } #else engine.Run(); return new StronglyTypedAstBuilder().Visit(tiAst); #endif } }
public Boolean RunTest() { try { GlobalMemory.Clear(); var sStream = new ANTLRStringStream(input); var lexer = new SGLLexer(sStream); var tStream = new CommonTokenStream(lexer); // Parsing var parser = new SGLParser(tStream); var t = (CommonTree) parser.main().Tree; // Printing tree Console.WriteLine("; " + t.ToStringTree()); // TreeWalking var treeStream = new CommonTreeNodeStream(t); var tw = new SGLTreeWalker(treeStream, true); AbstractNode returned = tw.main(); returned.Evaluate(); if (debug) { realOutput = GlobalMemory.Instance.DebugString; } else { realOutput = GlobalMemory.Instance.StoryboardCode.ToString(); } // comparison realOutput = realOutput.Trim(); output.Trim(); if (output.Equals(realOutput)) { return true; } else { return false; } } catch (CompilerException ce) { Console.WriteLine(ce.GetExceptionAsString()); return false; } catch (Exception ex) { Console.WriteLine("Es ist ein Fehler aufgetreten."); Console.WriteLine(ex.Message); Console.WriteLine(ex.StackTrace); return false; } }
public void Execute() { string input = @" Sart(0,0) End(12,15) "; ANTLRStringStream inStream = new ANTLRStringStream(input); ConfLexer lexer = new ConfLexer(inStream); CommonTokenStream tokens = new CommonTokenStream(lexer); ConfParser parser = new ConfParser(tokens); ConfParser.prog_return returnParser = parser.prog(); var tree = returnParser.Tree as CommonTree; foreach (CommonTree item in tree.Children) { if (item.Type == ConfLexer.ID) Console.WriteLine("function=" + item.Text); else if(item.Type == ConfLexer.INT) Console.WriteLine("params:" + item.Text); } Console.ReadKey(); }
public static List<Error> Translate(Source source) { var err = new List<Error>(); var prg = new Program(); try { var input = new ANTLRStringStream(source.GetSourceData()); var lexer = new PascalLexer(input); var tokens = new CommonTokenStream(lexer); var parser = new PascalParser(tokens); prg = parser.program(); prg.SetSourceIdentifier(source.GetSourceIdentifier()); } catch (RecognitionException e) { err.Add(new Error(FormatRecognitionException(e, source.GetSourceIdentifier()))); } if (err.Count != 0) return err; var val = new Validator(); err = val.Validate(prg); Root = prg; return err; }
public static string Compile(string input) { 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(); TargetCpp target_cpp = new TargetCpp(); return ast.Accept(target_cpp).Render(); }
public ASMParser GetParser(string script) { var input = new ANTLRStringStream(script); var lexer = new ASMLexer(input); var tokens = new CommonTokenStream(lexer); return new ASMParser(tokens); }
public Context From(string source) { var stream = new ANTLRStringStream(source); var lexer = new MessageContractsLexer(stream); var tokens = new CommonTokenStream(lexer); var parser = new MessageContractsParser(tokens) { TreeAdaptor = new CommonTreeAdaptor() }; var program = parser.GetProgram(); var commonTree = (CommonTree)program.Tree; var node = commonTree as CommonErrorNode; if (node != null) { throw new InvalidOperationException(node.ToString()); } var ctx = new Context(); foreach (var child in commonTree.Children) { WalkDeclarations(child, ctx); } return ctx; }
public Boolean RunTest() { try { ANTLRStringStream sStream = new ANTLRStringStream(input); SGLLexer lexer = new SGLLexer(sStream); CommonTokenStream tStream = new CommonTokenStream(lexer); // Parsing SGLParser parser = new SGLParser(tStream); CommonTree t = (CommonTree)parser.compilationUnit().Tree; // Printing tree Console.WriteLine("; " + t.ToStringTree()); // TreeWalking CommonTreeNodeStream treeStream = new CommonTreeNodeStream(t); SGLTreeWalker tw = new SGLTreeWalker(treeStream); SGLNode returned = tw.compilationUnit(); returned.Evaluate(); realOutput = tw.GetStoryboardCode().ToString(); // comparison realOutput = realOutput.Trim(); output.Trim(); if (output.Equals(realOutput)) { return true; } else { return false; } } catch (SGLCompilerException ce) { if (ce.ErrorType.Equals("Antlr.Parser")) { Console.WriteLine("Error (wrong syntax) on " + ce.Message); } else { Console.WriteLine("Error (" + ce.ErrorType + ") on line " + ce.Line + ": " + ce.Message); } return false; } catch (Exception ex) { Console.WriteLine("Es ist ein Fehler aufgetreten."); Console.WriteLine(ex.Message); Console.WriteLine(ex.StackTrace); return false; } }
private static AntlrCalcEngineParser CreateParser( string parseText ) { var input = new ANTLRStringStream( parseText ); var lex = new AntlrCalcEngineLexer( input ); var tokens = new CommonTokenStream( lex ); return new AntlrCalcEngineParser( tokens ); }
public static JsonParser jsonParserFromString(string input) { var inputStream = new ANTLRStringStream(input); var lexer = new JsonLexer(inputStream); var tokens = new CommonTokenStream(lexer); var parser = new JsonParser(tokens); return parser; }
private CommonTree ParseViaAntlrOnly(String relinqScriptCode) { var input = new ANTLRStringStream(relinqScriptCode); var lex = new EcmaScriptV3Lexer(input); var tokens = new CommonTokenStream(lex); var parser = new EcmaScriptV3Parser(tokens); return (CommonTree)parser.expression().Tree; }
private static LexResult AssertThat(string input) { var antlrStringStream = new ANTLRStringStream(input); var lexter = new CFlatLexer(antlrStringStream); var tokens = new CommonTokenStream(lexter); return new LexResult(tokens); }
public StyleDocument LoadFromString(string input) { var stream = new ANTLRStringStream(input); var lexer = new lesscssLexer(stream); var parser = new lesscssParser(new CommonTokenStream(lexer)); var root = parser.lessCss(); return ParseDocument((BaseTree)root.Tree); }
static void Main(string[] args) { var input = new ANTLRStringStream("a=(3+4)*5\r\na+1\r\n"); var lexer = new ExprLexer(input); var tokens = new CommonTokenStream(lexer); var parser = new ExprParser(tokens); parser.prog(); }
// throws SyntaxErrorException private CommonTree AcquireAntlrAst() { var input = new ANTLRStringStream(ElfCode); var lex = new ElfLexer(input); var tokens = new CommonTokenStream(lex); var parser = new ElfParser(tokens); var esV3Ast = (CommonTree)parser.script().Tree; return esV3Ast.RecursivelyReplaceNullListsWithEmptyOnes(); }
public string Process(string template, Dictionary<string, object> variables) { //This is a hack, but it removes the need for a step to separate html from tt //by treating it all as literals between tags Console.WriteLine("--------------------------------------------"); Console.WriteLine(template); template = string.Concat("[%'", template.Replace("[%", "'^^][%").Replace("%]", "%][%'").Replace("'^^]", "'%]"), "'%]"); template = template.Replace("[%''%]", ""); Console.WriteLine("--------------------------------------------"); Console.WriteLine(template); Console.WriteLine("--------------------------------------------"); //CSharpTarget.stg contains string templates used for targeting C# //TextReader stgReader = new StreamReader(File.Open("CSharpGenerator.stg", FileMode.Open)); TextReader stgReader = new StreamReader("CSharpGenerator.stg"); StringTemplateGroup stg = new StringTemplateGroup(stgReader); //lex ICharStream input = new ANTLRStringStream(template); TemplateLexer lex = new TemplateLexer(input); //parse TemplateParser parse = new TemplateParser(new CommonTokenStream(lex)); TemplateParser.document_return parseRet = parse.document(); Console.WriteLine(( (CommonTree) parseRet.Tree).ToStringTree()); //generate C# ITreeNodeStream nodeStream = new CommonTreeNodeStream(parseRet.Tree); CSharpGenerator gen = new CSharpGenerator(nodeStream); gen.TemplateLib = stg; CSharpGenerator.document_return ret = gen.document(); //compile to executable and optionally run Console.WriteLine("--------------------------------------------"); Console.WriteLine(ret.Template.ToString()); Console.WriteLine("--------------------------------------------"); // compile and run it var inMemory = true; Assembly assembly = Generate(ret.Template.ToString(), "", inMemory); if (inMemory) { //assembly.EntryPoint.Invoke(null, new object[] { new string[] { } }); var o = assembly.CreateInstance("x"); Object[] args = {this.Settings, variables}; var result = o.GetType().InvokeMember("Render", BindingFlags.Instance | BindingFlags.Public | BindingFlags.InvokeMethod, null, o, args); return result.ToString(); } return ""; }
internal static CommonTree BuildAst(string document) { var input = new ANTLRStringStream(document); var lexer = new JavaLexer(input); var tokens = new CommonTokenStream(lexer); var parser = new JavaParser(tokens); return parser.javaSource().Tree; }
private static void Main(string[] args) { var input = new ANTLRStringStream("if row[0] = 0 then 0"); var lexer = new TigerLexer(input); var tokens = new CommonTokenStream(lexer); var parser = new TigerParser(tokens); ExpressionNode x = parser.prog(); // Debug(); }
public CommonTree BuildAST(string script) { var input = new ANTLRStringStream(script); var lexer = new NPortugolLexer(input); var tokens = new CommonTokenStream(lexer); var parser = new NPortugolParser(tokens); var ast = parser.script(); return (CommonTree) ast.Tree; }
public static AstNode Check(string src, Context context) { ICharStream input = new ANTLRStringStream(src); CCompilerLexer lexer = new CCompilerLexer(input); CommonTokenStream tokens = new CommonTokenStream(lexer); CCompilerParser parser = new CCompilerParser(tokens); parser.TreeAdaptor = new AstNodeTreeAdapter(); AstNode program = (AstNode)parser.execute().Tree; SemanticChecker.Check((AstNode)program, context); return program; }
public string Parse(string input) { Antlr.Runtime.ANTLRStringStream stream = new Antlr.Runtime.ANTLRStringStream(input); formulaLexer lexer = new formulaLexer(stream); CommonTokenStream tokens = new CommonTokenStream(lexer); formulaParser parser = new formulaParser(tokens); AstParserRuleReturnScope <CommonTree, CommonToken> result = parser.formula(); String textual = result.Tree.ToStringTree(); return(textual); }
public RelinqScriptExpression Parse() { var input = new ANTLRStringStream(RelinqScriptCode); var lex = new EcmaScriptV3Lexer(input); var tokens = new CommonTokenStream(lex); var parser = new EcmaScriptV3Parser(tokens); var esV3Ast = (CommonTree)parser.program().Tree; esV3Ast.RecursivelyReplaceNullListsWithEmptyOnes(); return Parse(esV3Ast); }
/// <summary> /// Parses the specified content. /// </summary> /// <param name="content">The content.</param> /// <returns></returns> public Stylesheet Parse(string content) { var stream = new ANTLRStringStream(content); var lexer = new ExCSSLexer(stream); var tokens = new CommonTokenStream(lexer); var parser = new ExCSSParser(tokens); var tree = parser.parse().Tree; return BuildStylesheet(tree); }
/// <summary> /// Creates and parses mapcss from a string. /// </summary> /// <param name="css"></param> /// <returns></returns> public static MapCSSFile FromString(string css) { var input = new ANTLRStringStream(css); var lexer = new MapCSSLexer(input); var tokens = new CommonTokenStream(lexer); var parser = new MapCSSParser(tokens); var tree = parser.stylesheet().Tree as Antlr.Runtime.Tree.CommonTree; // parse into domain. return MapCSSDomainParser.Parse(tree); }
private FilterTree stringPatternAST(string source) { try { ANTLRStringStream input = new ANTLRStringStream(source); StringPatternLexer lexer = new StringPatternLexer(input); CommonTokenStream tokens = new CommonTokenStream(lexer); StringPatternParser parser = new StringPatternParser(tokens); return parser.parse().Tree; } catch { } return null; }
public static Sequence ParseString(string text) { ANTLRStringStream strStream = new ANTLRStringStream(text); BonsaiLexer lexer = new BonsaiLexer(strStream); CommonTokenStream tokStream = new CommonTokenStream(lexer); Generated.BonsaiParser parser = new Generated.BonsaiParser(tokStream); var returnValue = parser.program(); CommonTree tree = (CommonTree)returnValue.Tree; CommonTreeNodeStream treeNodeStream = new CommonTreeNodeStream((CommonTree)returnValue.Tree); Generated.BonsaiTree treeWalker = new Generated.BonsaiTree(treeNodeStream); return new Sequence(treeWalker.program().result.Statements); }