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