public StatementList Parse(string text, out IReadOnlyList <SqlParserError> errors) { ICharStream stream = CharStreams.fromstring(text); stream = new CaseChangingCharStream(stream); ITokenSource lexer = new KoraliumLexer(stream); ITokenStream tokens = new CommonTokenStream(lexer); KoraliumParser parser = new KoraliumParser(tokens) { BuildParseTree = true }; var errorsListener = new AntlrErrorListener(); parser.AddErrorListener(errorsListener); var stmnt = parser.statements_list(); errors = errorsListener.Errors; if (errors.Count > 0) { return(new StatementList()); } var visitor = new AntlrVisitor(); var statements = visitor.Visit(stmnt) as List <Statement>; return(new StatementList() { Statements = statements }); }
public void ParseSpecFile(string specification_file_name) { var listener = new ErrorListener <IToken>(); // Try current location, or template directory. var location = specification_file_name; if (!File.Exists(location)) { location = Piggy._template_directory + "\\" + specification_file_name; if (!File.Exists(location)) { Console.WriteLine("File " + specification_file_name + " does not exist."); throw new Exception(); } } var stream = CharStreams.fromPath(location); ITokenSource lexer = new SpecLexer(stream); ITokenStream tokens = new CommonTokenStream(lexer); var parser = new SpecParserParser(tokens); parser.BuildParseTree = true; parser.AddErrorListener(listener); var spec_ast = parser.spec(); if (listener.had_error) { Console.WriteLine(spec_ast.GetText()); throw new Exception(); } ParseTreeWalker.Default.Walk(this, spec_ast); }
public Parser Parse() { string input = @" root { title 'Basic example' rec: { width 250 height 200 colour colour.white background colour.black img { source: 'pics/smallblue.png' x: canvas.height / 2 } img { source: 'pics/logo.png' } } "; ICharStream stream = CharStreams.fromstring(input); ITokenSource lexer = new nmlLexer(stream); ITokenStream token = new CommonTokenStream(lexer); nmlParser parser = new nmlParser(token) { BuildParseTree = true }; IParseTree tree = parser.StartRule(); return(this); }
public void StringTest1() { var stream = CharStreams.fromstring(@"package RobotsTestModel context aMotorsForward inv@0: ""ABC""->toLower() = ""abc"" inv@0: ""123""->toInteger() = 123 inv@0: ""123""->toReal() = 123 inv@0: ""abc""->toUpper() = ""ABC"" inv@0: ""abc""->concat(""cde"")->toUpper() = ""ABCCDE"" inv@0: ""abc""->substring(1, 1) = ""a"" endpackage"); ITokenSource lexer = new OclLexer(stream); ITokenStream tokens = new CommonTokenStream(lexer); var parser = new OclParser(tokens) { BuildParseTree = true }; IParseTree tree = parser.oclFile(); Assert.IsTrue(tree.Accept(interpreter)); }
public UpgradeResult Upgrade(UpgradeJob upgradeJob) { var outputFiles = new List <UpgradeResult.OutputFile>(); foreach (var file in upgradeJob.Files) { var replacements = new List <TextReplacement>(); ICharStream input = CharStreams.fromstring(file.Source); YarnSpinnerV1Lexer lexer = new YarnSpinnerV1Lexer(input); CommonTokenStream tokens = new CommonTokenStream(lexer); YarnSpinnerV1Parser parser = new YarnSpinnerV1Parser(tokens); var tree = parser.dialogue(); var formatFunctionVisitor = new OptionsVisitor(replacements); formatFunctionVisitor.Visit(tree); outputFiles.Add(new UpgradeResult.OutputFile(file.FileName, replacements, file.Source)); } return(new UpgradeResult { Files = outputFiles, }); }
public static void Main(string[] args) { if (args.Length == 0) { Console.WriteLine("Please name the C# file that you would like to compile as a program argument."); return; } StreamReader sr = new StreamReader(args[0]); ICharStream stream = CharStreams.fromString(sr.ReadToEnd()); CSharpLexer lexer = new CSharpLexer(stream); ITokenStream tokenStream = new CommonTokenStream(lexer); CSharpParser parser = new CSharpParser(tokenStream); parser.BuildParseTree = true; IParseTree tree = parser.compilation_unit(); Console.WriteLine(tree.ToStringTree(parser)); AST ast = new AST(); SymbolTable symbolTable = new SymbolTable(); ASTBuilder astBuilder = new ASTBuilder(ast, symbolTable); ParseTreeWalker.Default.Walk(astBuilder, tree); ast.Print(); }
public void NumberTest1() { var stream = CharStreams.fromstring(@"package RobotsTestModel context aMotorsForward inv@0: 1->max(2) = 2 inv@0: 5->div(2) = 2 inv@0: 5->min(2) = 2 inv@0: 5->mod(2) = 1 inv@0: 5->abs() = 5 endpackage"); ITokenSource lexer = new OclLexer(stream); ITokenStream tokens = new CommonTokenStream(lexer); var parser = new OclParser(tokens) { BuildParseTree = true }; IParseTree tree = parser.oclFile(); Assert.IsTrue(tree.Accept(interpreter)); }
// Given a bunch of raw text, load all nodes that were inside it. public static Status CompileString(string text, string fileName, out Program program, out IDictionary <string, StringInfo> stringTable) { string inputString = PreprocessIndentationInSource(text); ICharStream input = CharStreams.fromstring(inputString); YarnSpinnerLexer lexer = new YarnSpinnerLexer(input); CommonTokenStream tokens = new CommonTokenStream(lexer); YarnSpinnerParser parser = new YarnSpinnerParser(tokens); // turning off the normal error listener and using ours parser.RemoveErrorListeners(); parser.AddErrorListener(ErrorListener.Instance); IParseTree tree = parser.dialogue(); Compiler compiler = new Compiler(fileName); compiler.Compile(tree); program = compiler.program; stringTable = compiler.StringTable; if (compiler.containsImplicitStringTags) { return(Status.SucceededUntaggedStrings); } else { return(Status.Succeeded); } }
public Func <DateTime, DateTime> ParseRuleObservedString(string source, string dayName, string country, Calendar calendar) { ICharStream stream = CharStreams.fromstring(source); var lexer = new CalendariumLexer(stream, Output, OutputError); var token = new CommonTokenStream(lexer); var _parser = new CalendariumParser(token) { BuildParseTree = true, //Trace = ScriptParser.Trace, // Ca plante sur un null, pourquoi ? }; CalendariumParser.ScriptContext _context = _parser.script(); var visitor = new ParserBaseVisitor(calendar); var call = (Expression <Func <DateTime, DateTime> >)visitor.Visit(_context); var txt = "'" + source + "' -> '" + call.Body.ToString() + "'"; Trace.WriteLine($"{country.ToString()}:{dayName} : {txt}"); if (System.Diagnostics.Debugger.IsAttached) // Build an interceptor for log { var parameter = Expression.Parameter(typeof(DateTime), "date"); var ee = Expression.Call(null, _delegateLogDebugObserved.Method, call, parameter, Expression.Constant(country), Expression.Constant(dayName), Expression.Constant(txt)); call = Expression.Lambda <Func <DateTime, DateTime> >(ee, parameter); } Func <DateTime, DateTime> f = call.Compile(); return(f); }
public static GLSL_ES300Lexer SetupLexer(string input) { ICharStream stream = CharStreams.fromstring(input); GLSL_ES300Lexer lexer = new GLSL_ES300Lexer(stream); return(lexer); }
public Shell.Types.IShellReturnable ResultOf(string src, bool program) { logger.Verbose($"Source:\n{src.Trim()}"); ICharStream charStream = CharStreams.fromstring(src); lexer = new ShellLexer(charStream); ITokenStream tokenStream = new CommonTokenStream(lexer); parser = new ShellParser(tokenStream) { BuildParseTree = true, ErrorHandler = new BailErrorStrategy() }; parser.RemoveErrorListeners(); parser.AddErrorListener(new SyntaxErrorListener()); IParseTree tree; // select the appropriate start rule if (program) { tree = parser.program(); } else { tree = parser.statement(); } logger.Debug($"Parse tree:\n{tree.ToStringTree(parser)}"); visitor.tokenSource = lexer.InputStream; return(visitor.Visit(tree)); }
public void Load() { lineMaterial = new Material(Shader.Find("Sprites/Default")); var stream = CharStreams.fromPath(filePath); var lexer = new GravisLexer(stream); var tokens = new CommonTokenStream(lexer); var parser = new GravisParser(tokens) { BuildParseTree = true }; var loader = new LoadListener(); var tree = parser.file_input(); ParseTreeWalker.Default.Walk(loader, tree); RelinkSubspaces(loader.subspaces, loader.nodes); var volume = new Volume(); var parts = Node.FindIsolatedGraphs(loader.nodes); for (var i = 0; i < parts.Count; i++) { var nodes = parts[i]; Node.AlignNodesByForceDirected(nodes); DrawNodes(nodes, i, volume); } var orbit = Camera.main.GetComponent <DragMouseOrbit>(); orbit.target = volume.GetCenter(); orbit.distance = volume.GetRadius() * 2; }
public static List <BibleReferenceRange> Parse(string input) { var inputStream = CharStreams.fromString(input); var bibleReferenceLexer = new BibleReferenceLexer(inputStream); bibleReferenceLexer.RemoveErrorListeners(); bibleReferenceLexer.AddErrorListener(ThrowingErrorListener.Instance); var commonTokenStream = new CommonTokenStream(bibleReferenceLexer); var bibleReferenceParser = new BibleReferenceParser.Grammar.Generated.BibleReferenceParser(commonTokenStream); var referenceContext = bibleReferenceParser.reference(); var listener = new BibleReferenceListener(); var tokens = commonTokenStream.GetTokens(); Console.WriteLine(); Console.WriteLine("Tokens:"); foreach (var token in tokens) { Console.WriteLine($" {token.Text} [{bibleReferenceLexer.ChannelNames[token.Channel]}]"); } var walker = new ParseTreeWalker(); walker.Walk(listener, referenceContext); return(listener.References); }
public BooleanExpression ParseFilter(string text, out IReadOnlyList <SqlParserError> errors) { ICharStream stream = CharStreams.fromstring(text); stream = new CaseChangingCharStream(stream); ITokenSource lexer = new KoraliumLexer(stream); ITokenStream tokens = new CommonTokenStream(lexer); KoraliumParser parser = new KoraliumParser(tokens) { BuildParseTree = true }; var errorsListener = new AntlrErrorListener(); parser.AddErrorListener(errorsListener); var booleanExpression = parser.boolean_expression(); errors = errorsListener.Errors; if (errors.Count > 0) { return(null); } var visitor = new AntlrVisitor(); var result = visitor.Visit(booleanExpression) as BooleanExpression; return(result); }
public string fromString(string input) { input = new Stubs() + input; ICharStream stream = CharStreams.fromString(input); ITokenSource lexer = new LangLexer(stream); ITokenStream tokens = new CommonTokenStream(lexer); var parser = new LangParser(tokens); parser.BuildParseTree = true; var tree = parser.prog(); var visitor = new Translator.Translator(tokens); var prog = visitor.VisitProg(tree); var env = new Environment(); prog.Validate(env); return(prog.ToString()); }
static void Main(string[] args) { String input = @"package P context A inv: let fact(n: var) = if n = 1 then n else n * fact(n - 1) endif; let n = 5; fact(n+1) = 720 inv: let a = 6; let b = 6; a = b endpackage"; ICharStream stream = CharStreams.fromstring(input); ITokenSource lexer = new HelloLexer(stream); ITokenStream tokens = new CommonTokenStream(lexer); HelloParser parser = new HelloParser(tokens); parser.BuildParseTree = true; IParseTree tree = parser.oclFile(); HelloPrinter printer = new HelloPrinter(); //ParseTreeWalker.Default.Walk(printer, tree); tree.Accept(printer); Console.ReadLine(); }
static void Main(string[] args) { var input = File.ReadAllText(WebGL1SpecFile); input += File.ReadAllText(WebGL2SpecFile); var inputStream = CharStreams.fromstring(input); var lexer = new WebIDLLexer(inputStream); var tokenStream = new CommonTokenStream(lexer); var parser = new WebIDLParser(tokenStream); var contextSyntaxTree = parser.webIDL(); using (var outputStream = File.CreateText(OutputFile)) { outputStream.WriteLine("using WebAssembly.Core;"); outputStream.WriteLine(); outputStream.WriteLine("namespace WebGLDotNET"); outputStream.WriteLine("{"); outputStream.WriteLine("#pragma warning disable MEN002"); var listener = new WebIDLListener(outputStream); ParseTreeWalker.Default.Walk(listener, contextSyntaxTree); outputStream.WriteLine("#pragma warning restore MEN002"); outputStream.WriteLine("}"); } }
private void Fun(string pat, string ast_string) { var ast_stream = CharStreams.fromstring(ast_string); var ast_lexer = new AstLexer(ast_stream); var ast_tokens = new CommonTokenStream(ast_lexer); var ast_parser = new AstParserParser(ast_tokens); ast_parser.BuildParseTree = true; var listener = new ErrorListener <IToken>(); ast_parser.AddErrorListener(listener); IParseTree ast_tree = ast_parser.ast(); if (listener.had_error) { throw new Exception(); } _ast = ast_tree; var lexer = new AstLexer(null); var parser = new AstParserParser(new CommonTokenStream(lexer)); ParseTreePatternMatcher ptpm = new ParseTreePatternMatcher(lexer, parser); var re = ptpm.Compile(pat, AstParserParser.RULE_node); var c = ast_tree.GetChild(0); var b = re.Matches(c); System.Console.WriteLine(b); }
/// <summary> /// Parses the specified reader as a CSV file where the separator is specified and might not be a comma. /// <para> /// This factory method takes a <seealso cref="Reader"/>. /// Callers are encouraged to use <seealso cref="CharSource"/> instead of {@code Reader} /// as it allows the resource to be safely managed. /// </para> /// <para> /// This factory method allows the separator to be controlled. /// For example, a tab-separated file is very similar to a CSV file, the only difference is the separator. /// </para> /// <para> /// CSV files sometimes contain a Unicode Byte Order Mark. /// Callers are responsible for handling this, such as by using <seealso cref="UnicodeBom"/>. /// /// </para> /// </summary> /// <param name="reader"> the file resource </param> /// <param name="headerRow"> whether the source has a header row, an empty source must still contain the header </param> /// <param name="separator"> the separator used to separate each field, typically a comma, but a tab is sometimes used </param> /// <returns> the CSV file </returns> /// <exception cref="UncheckedIOException"> if an IO exception occurs </exception> /// <exception cref="IllegalArgumentException"> if the file cannot be parsed </exception> public static CsvFile of(Reader reader, bool headerRow, char separator) { ArgChecker.notNull(reader, "source"); IList <string> lines = Unchecked.wrap(() => CharStreams.readLines(reader)); return(create(lines, headerRow, separator)); }
/// <summary> /// Public constructor /// </summary> /// <param name="expression">String representing a conditional expression</param> public UserFilter(string expression) { if (string.IsNullOrEmpty(expression)) { F = user => true; return; } var lexer = new BoolExprLexer(CharStreams.fromstring(expression)); lexer.RemoveErrorListeners(); lexer.AddErrorListener(ThrowingErrorListener.Instance); var tokens = new CommonTokenStream(lexer); var parser = new BoolExprParser(tokens) { BuildParseTree = true }; parser.RemoveErrorListeners(); parser.AddErrorListener(ThrowingErrorListener.Instance); var tree = parser.expr(); var visitor = new BoolExprVisitor(); F = visitor.Visit(tree); }
public void CollectionTest1() { var stream = CharStreams.fromstring(@"package RobotsTestModel context aMotorsForward inv@0: Bag{ ""a"", ""bb"", ""ccc""}->select(self->size() = 2)->size() = 1 inv@0: Bag{1,2,3}->forAll(x, y | x <> y implies x*y > 1) inv@0: Bag{1,2,3}->iterate(x; y : T = 0 | y + x) = 6 inv@0: Set{""1"",""2"",""3""}->collect(self = ""0"")->size() = 3 inv@0: Bag{""1"",""2"",""3""}->any(self.toInteger() > 2).toInteger() = 3 inv@0: aMotorsForward->allInstances()->size() > -1 endpackage"); ITokenSource lexer = new OclLexer(stream); ITokenStream tokens = new CommonTokenStream(lexer); var parser = new OclParser(tokens) { BuildParseTree = true }; IParseTree tree = parser.oclFile(); Assert.IsTrue(tree.Accept(interpreter)); }
static void Main(string[] args) { // standard ANTLR code // we get the input ICharStream chars = CharStreams.fromPath(args[0]); // we set up the lexer SQLLexer lexer = new SQLLexer(chars); // we use the lexer CommonTokenStream stream = new CommonTokenStream(lexer); // we set up the parser SQLParser parser = new SQLParser(stream); // we find the root node of our parse tree var tree = parser.statements(); // we create our visitor CreateVisitor createVisitor = new CreateVisitor(); List <ClassDescriptor> classes = createVisitor.VisitStatements(tree); // we choose our code generator... ICodeGenerator generator; // ...depending on the command line argument if (args.Count() > 1 && args[1] == "kotlin") { generator = new KotlinCodeGenerator(); } else { generator = new CSharpCodeGenerator(); } Console.WriteLine(generator.ToSourceCode("SQLDataTypes", classes)); }
public static PDDLParser Parse(string action) { CommonTokenStream tokens = new CommonTokenStream(new PDDLGrammarLexer(CharStreams.fromstring(action))); PDDLGrammarParser parser = new PDDLGrammarParser(tokens); PDDLParser visitor = new PDDLParser(); parser.Interpreter.PredictionMode = PredictionMode.SLL; parser.RemoveErrorListeners(); parser.ErrorHandler = new BailErrorStrategy(); try { visitor.Visit(parser.output()); } catch (SystemException exception) { if (exception.GetBaseException() is RecognitionException) { tokens.Seek(0); parser.AddErrorListener(ConsoleErrorListener <object> .Instance); parser.ErrorHandler = new DefaultErrorStrategy(); parser.Interpreter.PredictionMode = PredictionMode.LL; visitor.Visit(parser.output()); } } return(visitor); }
public static Query StaticGetQuery(string input) { ICharStream stream = CharStreams.fromString(input); ITokenSource lexer = new MiniSQLLexer(stream); ITokenStream tokens = new CommonTokenStream(lexer); MiniSQLParser parser = new MiniSQLParser(tokens); parser.BuildParseTree = true; IParseTree tree = parser.prog(); MiniSQLVisitor visitor = new MiniSQLVisitor(); Query query = (Query)visitor.Visit(tree); // import file int index = 0; while (index < query.StatementList.Count) { IStatement statement = query.StatementList[index]; if (statement.Type == StatementType.ExecFileStatement) { ExecFileStatement execFile = (ExecFileStatement)statement; query.StatementList.RemoveAt(index); string fileText = File.ReadAllText(execFile.FilePath); Query ret = StaticGetQuery(fileText); query.StatementList.InsertRange(index, ret.StatementList); continue; } index++; } return(query); }
public void ParseExpressionPattern(string expression) { var listener = new ErrorListener <IToken>(); var stream = CharStreams.fromstring(expression); ITokenSource lexer = new SpecLexer(stream); ITokenStream tokens = new CommonTokenStream(lexer); var parser = new SpecParserParser(tokens); parser.BuildParseTree = true; parser.AddErrorListener(listener); var spec_ast = parser.pattern(); if (listener.had_error) { Console.WriteLine(spec_ast.GetText()); throw new Exception(); } var template = new Template(); _current_template = template; template.TemplateName = "Grep"; _program._templates.Add(template); _current_pass = new Pass(); _current_pass.Name = "Grep"; _current_pass.Owner = _current_template; _current_template.Passes.Add(_current_pass); _program._application.OrderedPasses.Add("Grep.Grep"); ParseTreeWalker.Default.Walk(this, spec_ast); }
private void parseBtn_Click(object sender, EventArgs e) { #if DEBUG && HELLO String input = editor.Text; ICharStream stream = CharStreams.fromstring(input); ITokenSource lexer = new HelloLexer(stream); ITokenStream tokens = new CommonTokenStream(lexer); HelloParser parser = new HelloParser(tokens); HelloCustomListener helloListener = new HelloCustomListener(); parser.r().EnterRule(helloListener); #elif DEBUG && ADVANCED String input = editor.Text; ICharStream stream = CharStreams.fromstring(input); ITokenSource lexer = new VisualBasic6Lexer(stream); ITokenStream tokens = new CommonTokenStream(lexer); VisualBasic6Parser parser = new VisualBasic6Parser(tokens); IParseTree tree = parser.startRule(); ParseTreeWalker walker = new ParseTreeWalker(); VisualBasic6CustomListener listener = new VisualBasic6CustomListener(); walker.Walk(listener, tree); //parser.startRule().EnterRule(listener); #endif }
private void CompilePrepare() { if (File.Exists(mainIniFile)) { SinumerikLexer definitionLexer = new SinumerikLexer(CharStreams.fromPath(mainIniFile), null, _errorTextWriter); SinumerikParser definitionParser = new SinumerikParser(new CommonTokenStream(definitionLexer), null, _errorTextWriter); definitionParser.BuildParseTree = true; IParseTree definitionTree = definitionParser.parse(); GlobalVarsVisitor globalVars = new GlobalVarsVisitor(mainScope); globalVars.Visit(definitionTree); } foreach (var fileName in Directory.EnumerateFiles(subDir)) { SinumerikLexer subLexer = new SinumerikLexer(CharStreams.fromPath(fileName), null, _errorTextWriter); SinumerikParser subParser = new SinumerikParser(new CommonTokenStream(subLexer), null, _errorTextWriter); subParser.BuildParseTree = true; IParseTree subTree = subParser.parse(); SymbolVisitor subSymbolVisitor = new SymbolVisitor(functions); subSymbolVisitor.Visit(subTree); } mainLexer = new SinumerikLexer(CharStreams.fromstring(_text.Text), null, _errorTextWriter); }
static void Main(string[] args) { if (args.Length < 1) { return; } { //InputStreamの作り方サンプル CharStreams.fromstring("🍴 = 🍐 + \"😎\";(((x * π))) * µ + ∰; a + (x * (y ? 0 : 1) + z);"); //stringから using (var fs = File.OpenRead(args[0])) CharStreams.fromStream(fs, Encoding.UTF8); //Streamから(ファイルストリームでもメモリストリームでも) } var inputStream = CharStreams.fromPath(args[0], Encoding.UTF8); //ファイルパスから var lexer = new ExpressionLexer(inputStream); var tokenStream = new CommonTokenStream(lexer); var parser = new ExpressionParser(tokenStream); var inputTree = parser.input(); var(isSuccess, value) = new Visitor().Visit(inputTree); if (isSuccess) { Console.WriteLine($"success. {value}"); } else { Console.WriteLine("error."); } }
public static IParseTree ReconstructTree(Parser grammar, Lexer lexer, string ast_string) { /////////////////////////////////////////////////////////////////// // Parse as a parenthesized expression tree. /////////////////////////////////////////////////////////////////// var ast_stream = CharStreams.fromstring(ast_string); ITokenSource ast_lexer = new AstLexer(ast_stream); var ast_tokens = new CommonTokenStream(ast_lexer); var ast_parser = new AstParserParser(ast_tokens); ast_parser.BuildParseTree = true; var listener = new ErrorListener <IToken>(); ast_parser.AddErrorListener(listener); IParseTree ast_tree = ast_parser.ast(); ast_tree = ast_tree.GetChild(0); if (listener.had_error) { throw new Exception(); } /////////////////////////////////////////////////////////////////// // Convert parenthesized expression tree back into parse tree // of original grammar. /////////////////////////////////////////////////////////////////// var reconstructed_tree = ReconstructTreeAux(grammar, lexer, ast_tree, null); return(reconstructed_tree); }
public static BaseExpression Parse(ParsingEnvironment env, string input) { var vistor = new MyExpressionParser() { _environment = env }; ICharStream stream = CharStreams.fromString(input); ExpressionLexer lexer = new ExpressionLexer(stream); lexer.AddErrorListener(vistor); ITokenStream tokens = new CommonTokenStream(lexer); var parser = new ExpressionParser(tokens); parser.AddErrorListener(vistor); parser.BuildParseTree = true; var tree = parser.completeExpression(); // TODO: the default error listens write to the console BaseExpression result = vistor.Visit(tree); if (result is null) { // Probably missed an override of ExpressionBaseVisitor if this is thrown throw new Exception("Programming error, no expression returned."); } return(result); }