public Questionnaire BuildAST(string inputString) { MemoryStream inputStream = new MemoryStream(Encoding.UTF8.GetBytes(inputString ?? "")); AntlrInputStream antlrInputStream = new AntlrInputStream(inputStream); QLLexer lexer = new QLLexer(antlrInputStream); CommonTokenStream tokens = new CommonTokenStream(lexer); _parser = new QLParser(tokens); //Replaxe lexer/parser error listeners lexer.RemoveErrorListeners(); _parser.RemoveErrorListeners(); lexer.AddErrorListener(new LexerErrorListener() { OnError = LexerErrors.Add }); _parser.AddErrorListener(new ParserErrorListener() { OnError = ParserErrors.Add }); //set manager on partial parser class _parser.SetIdManager(Memory); //build AST _parseTree = _parser.questionnaire(); AST = _parser.GetAST(); //check for lexer/parser errors if (!LexerErrors.Any() && !ParserErrors.Any()) { TypeChecker.Run(AST); } return AST; }
public static App ReadAppText(string inputString) { var input = new Antlr4.Runtime.AntlrInputStream(inputString); var app = GestureAppFromAntlrInput(input); return(app); }
public static bool TryGetLineStatements(string text, int lineNumber, out IList<IParseTree> statementTrees, out IList<IToken> tokens) { Contract.Requires<ArgumentNullException>(text != null, "text"); Contract.Requires<ArgumentOutOfRangeException>(lineNumber >= 0); try { AntlrInputStream input = new AntlrInputStream(text); JavaLexer lexer = new JavaLexer(new JavaUnicodeStreamV4(input)); CommonTokenStream tokenStream = new CommonTokenStream(lexer); JavaParser parser = new JavaParser(tokenStream); parser.Interpreter.PredictionMode = PredictionMode.Sll; parser.BuildParseTree = true; JavaParser.CompilationUnitContext result = parser.compilationUnit(); statementTrees = null; tokens = tokenStream.GetTokens(); AssociatedTreeListener listener = new AssociatedTreeListener(lineNumber, tokens); ParseTreeWalker.Default.Walk(listener, result); statementTrees = listener.StatementTrees; return true; } catch (Exception e) { if (ErrorHandler.IsCriticalException(e)) throw; statementTrees = null; tokens = null; return false; } }
/// <summary> /// Exports the specified component to a temporary file, loads, and then parses the exported file. /// </summary> /// <param name="component"></param> public IDictionary<Tuple<string, DeclarationType>, Attributes> Parse(VBComponent component) { var path = _exporter.Export(component); if (!File.Exists(path)) { // a document component without any code wouldn't be exported (file would be empty anyway). return new Dictionary<Tuple<string, DeclarationType>, Attributes>(); } var code = File.ReadAllText(path); File.Delete(path); var type = component.Type == vbext_ComponentType.vbext_ct_StdModule ? DeclarationType.Module : DeclarationType.Class; var listener = new AttributeListener(Tuple.Create(component.Name, type)); var stream = new AntlrInputStream(code); var lexer = new VBALexer(stream); var tokens = new CommonTokenStream(lexer); var parser = new VBAParser(tokens); // parse tree isn't usable for declarations because // line numbers are offset due to module header and attributes // (these don't show up in the VBE, that's why we're parsing an exported file) var tree = parser.startRule(); ParseTreeWalker.Default.Walk(listener, tree); return listener.Attributes; }
public static void Main(string[] args) { var path = @"C:\Users\alexander.higgins\source\repos\ILDisassembler\MSILParser\IlDisassembler.il"; var text = File.ReadAllText(path); var stream = new Antlr4.Runtime.AntlrInputStream(text); var lexer = new MSILLexer((ICharStream)stream); var tokenStream = new CommonTokenStream(lexer); var parser = new MSILParser(tokenStream); parser.BuildParseTree = true; var ctx = parser.decls(); MSILParser.StartContext start = parser.start(); var classDecs = parser.start(); var vistor = new MsilVisitor(); vistor.Visit(start); var decl = parser.decl(); vistor.Visit(decl); //parser.d }
protected void Build(string input) { Inputstream = new AntlrInputStream(input); Lexer = new QLLexer(Inputstream); Tokenstream = new CommonTokenStream(Lexer); Parser = new QLParser(Tokenstream); }
public void ParsesEmptyForm() { var code = @" VERSION 5.00 Begin {C62A69F0-16DC-11CE-9E98-00AA00574A4F} Form1 Caption = ""Form1"" ClientHeight = 2640 ClientLeft = 45 ClientTop = 375 ClientWidth = 4710 OleObjectBlob = ""Form1.frx"":0000 StartUpPosition = 1 'CenterOwner End Attribute VB_Name = ""Form1"" Attribute VB_GlobalNameSpace = False Attribute VB_Creatable = False Attribute VB_PredeclaredId = True Attribute VB_Exposed = False "; var stream = new AntlrInputStream(code); var lexer = new VBALexer(stream); var tokens = new CommonTokenStream(lexer); var parser = new VBAParser(tokens); parser.ErrorListeners.Clear(); parser.ErrorListeners.Add(new ExceptionErrorListener()); var tree = parser.startRule(); Assert.IsNotNull(tree); }
public Expression(string expression) { var input = new AntlrInputStream(expression); var lexer = new EstimatingExpressionEvaluatorLexer(input); var tokens = new CommonTokenStream(lexer); this.parser = new EstimatingExpressionEvaluatorParser(tokens); this.parseTree = parser.parse(); }
void IScanner.SetSource(string source, int offset) { m_source = source.Substring(offset); var inputStream = new AntlrInputStream(m_source); var lexer = new cqlLexer(inputStream); m_tokens = lexer.GetAllTokens(); m_tokenIndex = 0; }
public static void Main(string[] args) { Stream inputStream = Console.OpenStandardInput(); AntlrInputStream input = new AntlrInputStream(inputStream); CalculatorLexer lexer = new CalculatorLexer(input); CommonTokenStream tokens = new CommonTokenStream(lexer); CalculatorParser parser = new CalculatorParser(tokens); }
private void Init() { var inputStream = new AntlrInputStream(new System.IO.StreamReader(_filename)); var lexer = new PropositionalCalculusLexer(inputStream); var tokenStream = new CommonTokenStream(lexer); _parser = new PropositionalCalculusParser(tokenStream) { BuildParseTree = true }; _tree = _parser.text(); }
public String GetParseTreeAsString(String rule) { AntlrInputStream input = new AntlrInputStream(rule); RuleSetLexer lexer = new RuleSetLexer(input); var tokens = new CommonTokenStream(lexer); RuleSetParser parser = new RuleSetParser(tokens); return parser.rule_set().ToStringTree(parser); }
public void ParseClojure() { var inputStream = new AntlrInputStream("(def lst '(a b c))"); var lexer = new ClojureLexer(inputStream); var commonTokenStream = new CommonTokenStream(lexer); var parser = new ClojureParser(commonTokenStream); var visitor = new CstBuilderForAntlr4(parser); visitor.Visit(parser.file()); Console.WriteLine(visitor.FinishParsing()); }
public static List<Expression> getConstraints() { List<Expression> pathConstraints = new List<Expression>(); FileStream fileStream = new FileStream(@"c:\example2.txt", FileMode.Open, FileAccess.Read); AntlrInputStream input = new AntlrInputStream(fileStream); VBGrammarLexer lexer = new VBGrammarLexer(input); CommonTokenStream tokens = new CommonTokenStream(lexer); VBGrammarParser parser = new VBGrammarParser(tokens); IParseTree tree = parser.startRule(); //Console.WriteLine(tree.ToStringTree(parser)); // Use visitor pattern to get "raw" constraints VbaTreeVisitor eval = new VbaTreeVisitor(); Expression exp = eval.Visit(tree); List<RawConstraint> rawConstraints = eval.rawConstraints; // Create negated expressions for ELSE blocks RawConstraint.updateElseBlocks(rawConstraints); // Update constraints to transform into binary tree and get leaf nodes RawConstraint.updateParents(rawConstraints); List<RawConstraint> leafNodes = RawConstraint.getLeafNodes(rawConstraints); // For each leaf node, work the way up to generate PathConstraints foreach (RawConstraint leaf in leafNodes) { var parentLine = leaf.ParentLineNumber; if (leaf.Expr == null) { continue; } // find parent RawConstraint parent = findParent(rawConstraints, parentLine); // AND with parent BinaryExpression binExp = (BinaryExpression)leaf.Expr; while (parent != null) { if (parent.Expr == null) { break; } else { binExp = BinaryExpression.And(binExp, parent.Expr); } parent = findParent(rawConstraints, parent.ParentLineNumber); } pathConstraints.Add(binExp); // Console.WriteLine("Leaf: " + leaf.Expr); // Console.WriteLine("AND: " + binExp); } return pathConstraints; }
public static void Main() { var s = new Antlr4.Runtime.AntlrInputStream(File.OpenRead("Program.m")); var l = new MethLab.Parser.ANTLR.MATLABLexer(s); var p = new MethLab.Parser.ANTLR.MATLABParser(new CommonTokenStream(l)); var o = new MatlabListener(); var w = new ParseTreeWalker(); w.Walk(o, p.file()); Console.ReadLine(); }
static void Main(string[] args) { var str = new Antlr4.Runtime.AntlrInputStream("1 + 2"); var lexer = new arithmeticLexer(str); var tokens = new CommonTokenStream(lexer); var parser = new arithmeticParser(tokens); var tree = parser.expression(); System.Console.WriteLine(tree.ToStringTree(parser.RuleNames)); }
public IEnumerable<NodeSelector> Parse(string source) { var inputStream = new AntlrInputStream(source); var lexer = new TreeSelectorLexer(inputStream); var commonTokenStream = new CommonTokenStream(lexer); var parser = new TreeSelectorParser(commonTokenStream); var context = parser.init(); var visitor = new TreeSelectorVisitor(); return visitor.VisitInit(context); }
/// <summary> /// Using http://programming-pages.com/2013/12/14/antlr-4-with-c-and-visual-studio-2012/ as a guide. /// </summary> /// <param name="args"></param> static void Main(string[] args) { string test = "a = 10*10"; var input = new AntlrInputStream(test); var lexer = new calculatorLexer(input); CommonTokenStream tokens = new CommonTokenStream(lexer); var parser = new calculatorParser(tokens); var tree = parser.equation(); Console.WriteLine(tree.ToStringTree(parser)); }
public Library TranslateLibrary(string source) { var inputStream = new AntlrInputStream(source); var lexer = new cqlLexer(inputStream); var tokenStream = new CommonTokenStream(lexer); var parser = new cqlParser(tokenStream); var parseTree = parser.logic(); var visitor = new cqlTranslationVisitor(); return visitor.Visit(parseTree) as Library; }
/// <summary> /// Parses the specified input. /// </summary> /// <param name="input">The input.</param> /// <returns>The AST for the input</returns> /// <exception cref="System.ArgumentNullException">input</exception> public INode Parse(string input) { if (string.IsNullOrEmpty(input)) throw new ArgumentNullException("input"); AntlrInputStream InputStream = new AntlrInputStream(input); PNZRLexer Lexer = new PNZRLexer(InputStream); CommonTokenStream TokenStream = new CommonTokenStream(Lexer); PNZRParser Parser = new PNZRParser(TokenStream); IParseTree Tree = Parser.program(); PNZRVisitor Visitor = new PNZRVisitor(); return Visitor.Visit(Tree); }
public InterfaceExtruder(string objcFileContent) { content = objcFileContent; var input = new AntlrInputStream (content); lexer = new ObjCLexer (input); tokens = new CommonTokenStream (lexer); parser = new ObjCParser (tokens); listner = new ObjCListnerImpl (); walker = new ParseTreeWalker (); }
static void Main(string[] args) { Stream inputStream = Console.OpenStandardInput(); AntlrInputStream input = new AntlrInputStream(inputStream); CalculatorLexer lexer = new CalculatorLexer(input); lexer.AddErrorHandlers(); CommonTokenStream tokens = new CommonTokenStream(lexer); CalculatorParser parser = new CalculatorParser(tokens); parser.addSubExpr(); Console.ReadLine(); }
public Document Build(string data) { var stream = new MemoryStream(Encoding.UTF8.GetBytes(data)); var reader = new StreamReader(stream); var input = new AntlrInputStream(reader); var lexer = new GraphQLLexer(input); var tokens = new CommonTokenStream(lexer); var parser = new GraphQLParser(tokens); var documentTree = parser.document(); var vistor = new GraphQLVisitor(); return vistor.Visit(documentTree) as Document; }
static void CreateCode() { AntlrInputStream input = new AntlrInputStream(File.OpenRead(structurePath)); eRegsGrammarLexer lexer = new eRegsGrammarLexer(input); CommonTokenStream tokens = new CommonTokenStream(lexer); eRegsGrammarParser parser = new eRegsGrammarParser(tokens); IParseTree tree = parser.r(); MyVisitor visitor = new MyVisitor(); File.WriteAllText(classPath, visitor.Visit(tree).ToString()); }
public void TestGrammar() { String input = "hello zome\r\nhello tezt"; AntlrInputStream stream = new AntlrInputStream(input); ITokenSource lexer = new TagzLexer(stream); ITokenStream tokens = new CommonTokenStream(lexer); TagzParser parser = new TagzParser(tokens); parser.BuildParseTree = true; IParseTree tree = parser.r(); TagzKeyPrinter printer = new TagzKeyPrinter(); ParseTreeWalker.Default.Walk(printer, tree); }
public static LinearIntegerExpression parseLinearExpression(String input) { var stream = new AntlrInputStream(input); var lexer = new SymbolicStringsLexer(stream); var tokens = new CommonTokenStream(lexer); var parser = new SymbolicStringsParser(tokens); parser.BuildParseTree = true; var tree = parser.integer(); if (parser.NumberOfSyntaxErrors == 0) return tree.value; return null; }
public static App ReadAppText(string inputString) { //var input = new Antlr4.Runtime.AntlrFileStream(filename); //"..\\..\\Tests\\simple.app" var input = new Antlr4.Runtime.AntlrInputStream(inputString); //"..\\..\\Tests\\simple.app" var lexer = new PreposeGesturesLexer(input); var tokens = new CommonTokenStream(lexer); var parser = new PreposeGesturesParser(tokens); var tree = parser.app(); // parse var visitor = new AppConverter(); var app = (App)visitor.Visit(tree); return(app); }
public static SymbolicString parseSymbolicString(String input, List<String> alphabet) { var stream = new AntlrInputStream(input); var lexer = new SymbolicStringsLexer(stream); var tokens = new CommonTokenStream(lexer); var parser = new SymbolicStringsParser(tokens); parser.alphabet = alphabet; parser.BuildParseTree = true; var tree = parser.symbolic_string(); if (parser.NumberOfSyntaxErrors == 0 && parser.word_error == null) return tree.value; return null; }
public void ParseC() { var inputStream = new AntlrInputStream(@" int main(int argc, char **args) { printf(args[0]); return 0; }"); var lexer = new CLexer(inputStream); var commonTokenStream = new CommonTokenStream(lexer); var parser = new CParser(commonTokenStream); var visitor = new CstBuilderForAntlr4(parser); visitor.Visit(parser.compilationUnit()); Console.WriteLine(visitor.FinishParsing()); }
public static App ReadAppText(string inputString) { //var input = new Antlr4.Runtime.AntlrFileStream(filename); //"..\\..\\Tests\\simple.app" var input = new Antlr4.Runtime.AntlrInputStream(inputString); //"..\\..\\Tests\\simple.app" var lexer = new PreposeGesturesLexer(input); var tokens = new CommonTokenStream(lexer); var parser = new PreposeGesturesParser(tokens); var tree = parser.app(); // parse var visitor = new AppConverter(); var app = (App)visitor.Visit(tree); return app; }
static void Main(string[] args) { if (args.Length == 0) { Console.WriteLine("Error: No arguments given"); Console.WriteLine("Usage: AdaGrammar.exe <filename>"); return; } StreamReader stream = null; try { stream = new StreamReader(args[0]); } catch (Exception ex) { Console.WriteLine("Error: {0}", ex.Message); return; } Stopwatch stopwatch = Stopwatch.StartNew(); using (stream) { try { var input = new Antlr4.Runtime.AntlrInputStream(stream); AdaLexer lexer = new AdaLexer(input); CommonTokenStream tokens = new CommonTokenStream(lexer); AdaParser parser = new AdaParser(tokens); var result = parser.compilation_unit(); } finally { stream.Close(); } } stopwatch.Stop(); Console.WriteLine("Parse Elapsed time: {0}", stopwatch.Elapsed); }
///<summary> /// Constructor. ///</summary> public DomainProblem(string domainfile, string problemfile) : this() { using (var domstream = new StreamReader(domainfile)) { var inp = new Antlr4.Runtime.AntlrInputStream(domstream); var lexer = new pddlLexer(inp); var stream = new Antlr4.Runtime.CommonTokenStream(lexer); var parser = new pddlParser(stream); var tree = parser.domain(); this.domain = new DomainListener(); var walker = new Antlr4.Runtime.Tree.ParseTreeWalker(); walker.Walk(this.domain, tree); } using (var probstream = new StreamReader(problemfile)) { var inp = new Antlr4.Runtime.AntlrInputStream(probstream); var lexer = new pddlLexer(inp); var stream = new Antlr4.Runtime.CommonTokenStream(lexer); var parser = new pddlParser(stream); var tree = parser.problem(); this.problem = new ProblemListener(); var walker = new Antlr4.Runtime.Tree.ParseTreeWalker(); walker.Walk(this.problem, tree); } }
static void Main(string[] args) { bool show_tree = false; bool show_tokens = false; bool old = false; bool two_byte = false; string file_name = null; string input = null; System.Text.Encoding encoding = null; for (int i = 0; i < args.Length; ++i) { if (args[i].Equals("-tokens")) { show_tokens = true; continue; } else if (args[i].Equals("-two-byte")) { two_byte = true; continue; } else if (args[i].Equals("-old")) { old = true; continue; } else if (args[i].Equals("-tree")) { show_tree = true; continue; } else if (args[i].Equals("-input")) { input = args[++i]; } else if (args[i].Equals("-file")) { file_name = args[++i]; } else if (args[i].Equals("-encoding")) { ++i; encoding = Encoding.GetEncoding( args[i], new EncoderReplacementFallback("(unknown)"), new DecoderReplacementFallback("(error)")); if (encoding == null) { throw new Exception(@"Unknown encoding. Must be an Internet Assigned Numbers Authority (IANA) code page name. https://www.iana.org/assignments/character-sets/character-sets.xhtml"); } } } ICharStream str = null; if (input == null && file_name == null) { str = CharStreams.fromStream(System.Console.OpenStandardInput()); } else if (input != null) { str = CharStreams.fromString(input); } else if (file_name != null) { if (two_byte) { str = new TwoByteCharStream(file_name); } else if (old) { FileStream fs = new FileStream(file_name, FileMode.Open); str = new Antlr4.Runtime.AntlrInputStream(fs); } else if (encoding == null) { str = CharStreams.fromPath(file_name); } else { str = CharStreams.fromPath(file_name, encoding); } } var lexer = new JavaScriptLexer(str); if (show_tokens) { StringBuilder new_s = new StringBuilder(); for (int i = 0; ; ++i) { var ro_token = lexer.NextToken(); var token = (CommonToken)ro_token; token.TokenIndex = i; new_s.AppendLine(token.ToString()); if (token.Type == Antlr4.Runtime.TokenConstants.EOF) { break; } } System.Console.Error.WriteLine(new_s.ToString()); lexer.Reset(); } var tokens = new CommonTokenStream(lexer); var parser = new JavaScriptParser(tokens); var listener_lexer = new ErrorListener <int>(); var listener_parser = new ErrorListener <IToken>(); lexer.AddErrorListener(listener_lexer); parser.AddErrorListener(listener_parser); DateTime before = DateTime.Now; var tree = parser.program(); DateTime after = DateTime.Now; System.Console.Error.WriteLine("Time: " + (after - before)); if (listener_lexer.had_error || listener_parser.had_error) { System.Console.Error.WriteLine("Parse failed."); } else { System.Console.Error.WriteLine("Parse succeeded."); } if (show_tree) { System.Console.Error.WriteLine(tree.ToStringTree(parser)); } System.Environment.Exit(listener_lexer.had_error || listener_parser.had_error ? 1 : 0); }
static void Main(string[] args) { bool show_tree = false; bool show_tokens = false; bool old = false; bool two_byte = false; string file_name = null; string input = null; System.Text.Encoding encoding = null; for (int i = 0; i \ < args.Length; ++i) { if (args[i].Equals("-tokens")) { show_tokens = true; continue; } else if (args[i].Equals("-two-byte")) { two_byte = true; continue; } else if (args[i].Equals("-old")) { old = true; continue; } else if (args[i].Equals("-tree")) { show_tree = true; continue; } else if (args[i].Equals("-input")) { input = args[++i]; } else if (args[i].Equals("-file")) { file_name = args[++i]; } else if (args[i].Equals("-encoding")) { ++i; encoding = Encoding.GetEncoding( args[i], new EncoderReplacementFallback("(unknown)"), new DecoderReplacementFallback("(error)")); if (encoding == null) { throw new Exception(@"Unknown encoding. Must be an Internet Assigned Numbers Authority (IANA) code page name. https://www.iana.org/assignments/character-sets/character-sets.xhtml"); } } } ICharStream str = null; if (input == null && file_name == null) { str = CharStreams.fromStream(System.Console.OpenStandardInput()); } else if (input != null) { str = CharStreams.fromString(input); } else if (file_name != null) { if (two_byte) { str = new TwoByteCharStream(file_name); } else if (old) { FileStream fs = new FileStream(file_name, FileMode.Open); str = new Antlr4.Runtime.AntlrInputStream(fs); } else if (encoding == null) { str = CharStreams.fromPath(file_name); } else { str = CharStreams.fromPath(file_name, encoding); } }
static Antlr4.Runtime.Tree.IParseTree DoParse(string input) { bool show_tree = false; bool show_tokens = false; bool old = false; bool two_byte = false; string file_name = null; System.Text.Encoding encoding = null; ICharStream str = null; if (input == null && file_name == null) { str = CharStreams.fromStream(System.Console.OpenStandardInput()); } else if (input != null) { str = CharStreams.fromString(input); } else if (file_name != null) { if (two_byte) { str = new TwoByteCharStream(file_name); } else if (old) { FileStream fs = new FileStream(file_name, FileMode.Open); str = new Antlr4.Runtime.AntlrInputStream(fs); } else if (encoding == null) { str = CharStreams.fromPath(file_name); } else { str = CharStreams.fromPath(file_name, encoding); } } var lexer = new ArithmeticLexer(str); if (show_tokens) { StringBuilder new_s = new StringBuilder(); for (int i = 0; ; ++i) { var ro_token = lexer.NextToken(); var token = (CommonToken)ro_token; token.TokenIndex = i; new_s.AppendLine(token.ToString()); if (token.Type == Antlr4.Runtime.TokenConstants.EOF) { break; } } System.Console.Error.WriteLine(new_s.ToString()); lexer.Reset(); } var tokens = new CommonTokenStream(lexer); var parser = new ArithmeticParser(tokens); var listener_lexer = new ErrorListener <int>(); var listener_parser = new ErrorListener <IToken>(); lexer.AddErrorListener(listener_lexer); parser.AddErrorListener(listener_parser); DateTime before = DateTime.Now; ArithmeticParser.File_Context tree = parser.file_(); DateTime after = DateTime.Now; System.Console.Error.WriteLine("Time: " + (after - before)); if (listener_lexer.had_error || listener_parser.had_error) { System.Console.Error.WriteLine("Parse failed."); } else { System.Console.Error.WriteLine("Parse succeeded."); } if (show_tree) { System.Console.Error.WriteLine(tree.ToStringTree(parser)); } System.Environment.Exit(listener_lexer.had_error || listener_parser.had_error ? 1 : 0); return(tree); }
private static Document Build( AntlrDocumentBuilder antlrDocumentBuilder, string data ) { using( MemoryStream memoryStream = new MemoryStream( Encoding.UTF8.GetBytes( data ) ) ) using( StreamReader streamReader = new StreamReader( memoryStream ) ) { AntlrInputStream inputStream = new AntlrInputStream( streamReader ); GraphQLLexer lexer = new GraphQLLexer( inputStream ); if( antlrDocumentBuilder.LexerErrorListeners != null ) { lexer.RemoveErrorListeners(); antlrDocumentBuilder.LexerErrorListeners.Apply( x => lexer.AddErrorListener( x ) ); } CommonTokenStream tokenStream = new CommonTokenStream( lexer ); GraphQLParser parser = new GraphQLParser( tokenStream ); if( antlrDocumentBuilder.ParserErrorListeners != null ) { parser.RemoveErrorListeners(); antlrDocumentBuilder.ParserErrorListeners.Apply( x => parser.AddErrorListener( x ) ); } GraphQLVisitor vistor = new GraphQLVisitor(); return vistor.Visit( parser.document() ) as Document; } }
private void btnParse_Click(object sender, EventArgs e) { txtOutput.Clear(); string inputString = txtInput.Text; MemoryStream inputStream = new MemoryStream(Encoding.UTF8.GetBytes(inputString ?? "")); AntlrInputStream input = new AntlrInputStream(inputStream); QLLexer lexer = new QLLexer(input); CommonTokenStream tokens = new CommonTokenStream(lexer); QLParser parser = new QLParser(tokens); lexer.RemoveErrorListeners(); parser.RemoveErrorListeners(); lexer.AddErrorListener(new LexerErrorListener(){OnError = WriteError}); parser.AddErrorListener(new ParserErrorListener(){OnError = WriteError}); IParseTree tree = parser.questionnaire(); //if (parser.NumberOfSyntaxErrors > 0) // txtOutput.Text += string.Format("Parser errors found: {0}", parser.NumberOfSyntaxErrors); QLVisitor visitor = new QLVisitor(); visitor.Visit(tree); txtOutput.Text += string.Format(@"{0}{0} Generated parse tree: {0} {1} {0} {2}" , Environment.NewLine , tree.ToStringTree(parser) , visitor.Visit(tree)); }
public static CsharpParseResults InvokeParse(string fileName) { if (string.IsNullOrWhiteSpace(fileName)) return null; if (!System.IO.File.Exists(fileName)) return null; var tr = System.IO.File.OpenRead(fileName); var input = new AntlrInputStream(tr); var lexer = new CSharp4Lexer(input); var tokens = new CommonTokenStream(lexer); var parser = new CSharp4Parser(tokens); var tree = parser.compilation_unit(); var walker = new ParseTreeWalker(); var loader = new CsharpParseTree(); walker.Walk(loader, tree); var results = loader.Results; tr.Close(); return results; }
internal void LoadCommandStack(string Script) { // Clear the current stack // this.Commands.Clear(); this._CompileErrorMessages.Clear(); // Create a token stream and do lexal analysis // AntlrInputStream TextStream = new AntlrInputStream(Script); HScriptLexer HorseLexer = new HScriptLexer(TextStream); // Parse the script // CommonTokenStream HorseTokenStream = new CommonTokenStream(HorseLexer); HScriptParser HorseParser = new HScriptParser(HorseTokenStream); HorseParser.RemoveErrorListeners(); HorseParser.AddErrorListener(new ParserErrorListener()); // Create an executer object // CommandVisitor processor = new CommandVisitor(this.Home); // Load the call stack // try { foreach (HScriptParser.CommandContext context in HorseParser.compile_unit().command_set().command()) { this.Commands.Add(context); } } catch (Exception e) { this._CompileErrorMessages.Add(e.Message); } }