public static ASPParser Parse(string atom)
{
CommonTokenStream tokens = new CommonTokenStream(new ASPGrammarLexer(CharStreams.fromString(atom)));
ASPGrammarParser parser = new ASPGrammarParser(tokens);
ASPParser visitor = new ASPParser();
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 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);
}
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 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 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());
}
public void canParseCommentLikeCssValue()
{
String css = "#999";
MIndentingLexer lexer = new MIndentingLexer(CharStreams.fromString(css));
IToken token = lexer.NextToken();
Assert.AreEqual(MLexer.CSS_DATA, token.Type);
}
public ISqlParser CreateSqlParser(string sql)
{
var charStream = CharStreams.fromString(sql);
var mySqlLexer = new SqlServerLexer(charStream);
var commonTokenStream = new CommonTokenStream(mySqlLexer);
return(new SqlParser.SqlServerParser(commonTokenStream));
}
public static bool TryParse <T>(string source, out T ast, out List <FifthCompilationError> errors)
where T : IAstNode
{
TypeRegistry.DefaultRegistry.LoadPrimitiveTypes();
InbuiltOperatorRegistry.DefaultRegistry.LoadBuiltinOperators();
ast = (T)ParseAndAnnotate <T>(CharStreams.fromString(source));
errors = new List <FifthCompilationError>();
return(true);
}
public void Setup()
{
ICharStream stream = CharStreams.fromString(TestCode);
ITokenSource lexer = new DazelLexer(stream);
ITokenStream tokens = new CommonTokenStream(lexer);
parseTree = new DazelParser(tokens)
{
BuildParseTree = true
}.start();
}
public static PostgreSQLParser getPostgreSQLParser(string script)
{
var CharStream = CharStreams.fromString(script);
var Lexer = new PostgreSQLLexer(CharStream);
var Tokens = new CommonTokenStream(Lexer);
var Parser = new PostgreSQLParser(Tokens);
var ErrorListener = new PostgreSQLParserErrorListener();
ErrorListener.grammar = Parser;
Parser.AddErrorListener(ErrorListener);
return(Parser);
}
public static (LangParser, ITokenStream) GetTree(string code)
{
ICharStream stream = CharStreams.fromString(code);
ITokenSource lexer = new LangLexer(stream);
ITokenStream tokens = new CommonTokenStream(lexer);
var parser = new LangParser(tokens);
parser.BuildParseTree = true;
return(parser, tokens);
}
static void Main(string[] args)
{
string input = "log(10 + A1 * 35 + (5.4 - 7.4))";
ICharStream inputStream = CharStreams.fromString(input);
SpreadsheetLexer spreadsheetLexer = new SpreadsheetLexer(inputStream);
CommonTokenStream commonTokenStream = new CommonTokenStream(spreadsheetLexer);
SpreadsheetParser spreadsheetParser = new SpreadsheetParser(commonTokenStream);
SpreadsheetParser.ExpressionContext expressionContext = spreadsheetParser.expression();
DoubleSpreadsheetVisitor visitor = new DoubleSpreadsheetVisitor();
Console.WriteLine(visitor.Visit(expressionContext));
}
public JavaAST Parse(string filePath)
{
var code = File.ReadAllText(filePath);
var stream = CharStreams.fromString(code);
var lexer = new Java8Lexer(stream);
var tokens = new CommonTokenStream(lexer);
var parser = new Java8Parser(tokens);
parser.BuildParseTree = true;
var cu = parser.compilationUnit();
return(JavaAST.ConstructAST(cu));
}
public static Exception ValidateSyntax(this Query query)
{
var stream = CharStreams.fromString(query.Text);
var lexer = new CypherLexer(stream);
var tokens = new CommonTokenStream(lexer);
var parser = new CypherParser(tokens)
{
BuildParseTree = true,
TrimParseTree = true
};
var cypher = parser.oC_Cypher();
return(cypher.exception);
}
public PostgreSQLParser getPostgreSQLParser(string script)
{
var charStream = CharStreams.fromString(script);
var lexer = new PostgreSQLLexer(charStream);
var tokens = new CommonTokenStream(lexer);
var parser = new PostgreSQLParser(tokens);
lexer.RemoveErrorListeners();
parser.RemoveErrorListeners();
var listener_lexer = new LexerDispatchingErrorListener((this.InputStream as CommonTokenStream).TokenSource as Lexer);
var listener_parser = new ParserDispatchingErrorListener(this);
lexer.AddErrorListener(listener_lexer);
parser.AddErrorListener(listener_parser);
return(parser);
}
public P4Parser(string input, P4ParserErrorListener errorListener)
{
ICharStream stream = CharStreams.fromString(input);
Lexer = new p4Lexer(stream);
Lexer.RemoveErrorListeners();
Lexer.AddErrorListener(errorListener);
ITokenStream tokens = new CommonTokenStream(Lexer);
Parser = new p4Parser(tokens);
Parser.RemoveErrorListeners();
Parser.AddErrorListener(errorListener);
Parser.BuildParseTree = true;
Parser.s(); // Run parser on rule s (start rule)
}
// if you need to output something during tests
// private readonly ITestOutputHelper output;
//
// public SpreadsheetTests(ITestOutputHelper output)
// {
// this.output = output;
// }
private void setup(String input)
{
ICharStream inputStream = CharStreams.fromString(input);
lexer = new SpreadsheetLexer(inputStream);
CommonTokenStream commonTokenStream = new CommonTokenStream(lexer);
parser = new SpreadsheetParser(commonTokenStream);
StringWriter writer = new StringWriter();
errorListener = new SpreadsheetErrorListener(writer);
lexer.RemoveErrorListeners();
// uncomment this if you want to see errors from the lexer
//lexer.addErrorListener(errorListener);
parser.RemoveErrorListeners();
parser.AddErrorListener(errorListener);
}
static void Main(string[] args)
{
bool show_tree = false;
bool show_tokens = false;
string file_name = null;
string input = null;
for (int i = 0; i \ < args.Length; ++i)
{
if (args[i].Equals("-tokens"))
{
show_tokens = 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];
}
}
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)
{
str = CharStreams.fromPath(file_name);
}
private IEnumerable <IParseTree> BuildParseTrees()
{
List <IParseTree> parseTrees = new List <IParseTree>();
foreach (string file in files)
{
ICharStream stream = fromFile ? CharStreams.fromPath(file) : CharStreams.fromString(file);
ITokenSource lexer = new DazelLexer(stream);
ITokenStream tokens = new CommonTokenStream(lexer);
DazelParser parser = new DazelParser(tokens)
{
BuildParseTree = true
};
parser.AddErrorListener(new DazelErrorListener());
parseTrees.Add(parser.start());
}
return(parseTrees);
}
public IParseTree CreateTree(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 = ast_parser.ast();
if (listener.had_error)
{
throw new Exception();
}
var convert = Convert(ast);
return(convert.First());
}
public static string Parse(IPDDLDataCollection actions, string spdOutput, bool two_stageParsing)
{
CommonTokenStream tokens = new CommonTokenStream(new SPDGrammarLexer(CharStreams.fromString(spdOutput)));
SPDGrammarParser parser = new SPDGrammarParser(tokens);
SPDGrammarBaseVisitorImplementation visitor = new SPDGrammarBaseVisitorImplementation(actions);
if (!two_stageParsing)
{
visitor.Visit(parser.json());
return(visitor.errors);
}
parser.Interpreter.PredictionMode = PredictionMode.SLL;
parser.RemoveErrorListeners();
parser.ErrorHandler = new BailErrorStrategy();
try
{
visitor.Visit(parser.json());
}
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.json());
}
}
return(visitor.errors);
}
public ExpressionNode Parse(string expression)
{
var stream = CharStreams.fromString(expression);
var lexer = new AudioSynthesisGrammarLexer(stream);
var tokens = new CommonTokenStream(lexer);
var parser = new AudioSynthesisGrammarParser(tokens);
parser.BuildParseTree = true;
parser.RemoveErrorListeners();
parser.AddErrorListener(new ThrowingErrorListener <IToken>());
IParseTree tree = parser.compileUnit();
var visitor = new AudioSynthesisVisitor();
var res = tree.Accept(visitor);
if (res is null)
{
throw new ParseError("Unexpected null building AST.");
}
return(res);
}
static void Main(string[] args)
{
var input = System.IO.File.ReadAllText("./examples/example.dc");
var stream = CharStreams.fromString(input);
var lexer = new DecafLexer(stream);
var tokens = new CommonTokenStream(lexer);
tokens.Fill();
foreach (var token in tokens.GetTokens())
{
var typeName = DecafLexer.DefaultVocabulary.GetDisplayName(token.Type);
System.Console.WriteLine($"{token} type: {typeName}");
}
var parser = new DecafParser(tokens);
parser.BuildParseTree = true;
parser.AddParseListener(new FunctionLockCheckLisnter());
IParseTree tree = parser.sourceFile();
}
public static void Parse(IDatalogDataCollection minimalModels, string atomsList, bool two_stageParsing)
{
CommonTokenStream tokens = new CommonTokenStream(new IDLVLexer(CharStreams.fromString(atomsList)));
IDLVParser parser = new IDLVParser(tokens);
IDLVParserBaseVisitorImplementation visitor = new IDLVParserBaseVisitorImplementation(minimalModels);
if (!two_stageParsing)
{
visitor.Visit(parser.output());
return;
}
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());
}
}
}
public static AbstractSyntaxTree BuildAst(params string[] code)
{
List <IParseTree> parseTrees = new List <IParseTree>();
DazelLogger.ThrowExceptions = true;
foreach (string s in code)
{
ICharStream stream = CharStreams.fromString(s);
ITokenSource lexer = new DazelLexer(stream);
ITokenStream tokens = new CommonTokenStream(lexer);
DazelParser parser = new DazelParser(tokens)
{
BuildParseTree = true
};
parser.AddErrorListener(new DazelErrorListener());
parseTrees.Add(parser.start());
}
AbstractSyntaxTree ast = new AstBuilder().BuildAst(parseTrees);
return(ast);
}
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);
}
static void Main(string[] args)
{
bool show_tree = false;
bool show_tokens = false;
string file_name = null;
string input = null;
for (int i = 0; i < args.Length; ++i)
{
if (args[i].Equals("-tokens"))
{
show_tokens = 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];
}
}
ICharStream str = null;
if (input == null && file_name == null)
{
StringBuilder sb = new StringBuilder();
int ch;
while ((ch = System.Console.Read()) != -1)
{
sb.Append((char)ch);
}
input = sb.ToString();
str = CharStreams.fromString(input);
}
else if (input != null)
{
str = CharStreams.fromString(input);
}
else if (file_name != null)
{
str = CharStreams.fromPath(file_name);
}
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);
var tree = parser.file();
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);
}
}
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);
}
}
