public static void Main(string[] args)
{
if (args.Length > 0)
{
try
{
string inputFileName = args[0];
if (!Path.IsPathRooted(inputFileName))
{
inputFileName = Path.Combine(Environment.CurrentDirectory, inputFileName);
}
ICharStream input = new ANTLRFileStream(inputFileName);
XML lexer = new XML(input);
while (lexer.NextToken() != Token.EOF_TOKEN)
{
;
}
}
catch (Exception ex)
{
Console.Out.WriteLine("exception: " + ex);
Console.Out.WriteLine(ex.StackTrace);
}
}
else
{
Console.Error.WriteLine("Usage: xmlLexer <input-file>");
}
}
static void Main(string[] args)
{
ICharStream stream = new ANTLRFileStream(args[0]);
ZilFormatter zform = new ZilFormatter();
zform.Format(stream, Console.Out);
}
public static void Main(string[] args)
{
if (args.Length > 0)
{
string inputFileName = args[0];
if (!Path.IsPathRooted(inputFileName))
{
inputFileName = Path.Combine(Environment.CurrentDirectory, inputFileName);
}
ICharStream input = new ANTLRFileStream(inputFileName);
CLexer lex = new CLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lex);
CParser parser = new CParser(tokens);
try {
parser.translation_unit();
}
catch (RecognitionException re) {
Console.Out.WriteLine(re.StackTrace);
}
}
else
{
Console.Error.WriteLine("Usage: cparse <input-file>");
}
}
public static void Main(string[] args)
{
if (args.Length == 1)
{
string fullpath;
if (Path.IsPathRooted(args[0]))
{
fullpath = args[0];
}
else
{
fullpath = Path.Combine(Environment.CurrentDirectory, args[0]);
}
Console.Out.WriteLine("Processing file: {0}", fullpath);
ICharStream input = new ANTLRFileStream(fullpath);
LangLexer lex = new LangLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lex);
LangParser parser = new LangParser(tokens);
//LangParser.decl_return r = parser.decl();
LangParser.start_return r = parser.start();
Console.Out.WriteLine("tree: " + ((ITree)r.Tree).ToStringTree());
CommonTree r0 = ((CommonTree)r.Tree);
CommonTreeNodeStream nodes = new CommonTreeNodeStream(r0);
nodes.TokenStream = tokens;
LangDumpDecl walker = new LangDumpDecl(nodes);
walker.decl();
}
else
{
Console.Error.WriteLine("Usage: TreeParser <input-file>");
}
}
private static int Compile(string filename)
{
filename = Path.GetFullPath(filename);
ICharStream characters = new ANTLRFileStream(filename);
var lexer = new TigerLexer(characters);
ITokenStream tokens = new CommonTokenStream(lexer);
var parser = new TigerParser(tokens);
//parser.TraceDestination = Console.Out;
var result = parser.program();
if (parser.NumberOfSyntaxErrors > 0 || lexer.Error)
{
return(1);
}
((ProgramNode)result.Tree).CheckSemantics(Scope.DefaultGlobalScope, Scope.DefaultGlobalScope.Reporter);
if (Scope.DefaultGlobalScope.Reporter.Errors.Count > 0)
{
Scope.DefaultGlobalScope.Reporter.PrintErrors(Console.Out);
return(1);
}
var generator = new CodeGenerator(filename);
generator.GenerateCode((ASTNode)result.Tree);
generator.SaveBin();
return(0);
}
/// <summary>
/// Parses the file.
/// </summary>
public void Parse()
{
try
{
ANTLRFileStream inputStream = new ANTLRFileStream(FileName);
CpsLexer lexer = new CpsLexer(inputStream);
CommonTokenStream tokens = new CommonTokenStream(lexer);
CpsParser parser = new CpsParser(tokens);
// Parse the file
ITree ct = (ITree)parser.concern().Tree;
if (ct != null)
{
Walk(ct);
}
}
catch (IOException ex)
{
throw new CpsParserException(String.Format(CultureInfo.CurrentCulture,
Resources.ConcernNotFound, FileName), FileName, ex);
}
catch (RecognitionException ex)
{
throw new CpsParserException(String.Format(CultureInfo.CurrentCulture,
Resources.UnableToParseConcern, FileName, ex.Message), FileName, ex);
}
}
public static void Main(string[] args)
{
if (args.Length == 1)
{
string fullpath;
if (Path.IsPathRooted(args[0]))
{
fullpath = args[0];
}
else
{
fullpath = Path.Combine(Environment.CurrentDirectory, args[0]);
}
Console.Out.WriteLine("Processing file: {0}", fullpath);
ICharStream input = new ANTLRFileStream(fullpath);
SimpleCLexer lex = new SimpleCLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lex);
//System.out.println("tokens="+tokens);
SimpleCParser parser = new SimpleCParser(tokens);
parser.program();
Console.Out.WriteLine("Finished processing file: {0}", fullpath);
}
else
{
Console.Error.WriteLine("Usage: llstar <input-filename>");
}
}
public static List <Tuple <ITree, string, IToken[]> > ParseAcnInputFiles(IEnumerable <string> inputFiles)
{
var parsedInputFiles = new List <Tuple <ITree, string, IToken[]> >();
foreach (var inFileName in inputFiles)
{
ICharStream input = new ANTLRFileStream(inFileName);
acnLexer lexer = new acnLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
List <IToken> tokenslst = new List <IToken>();
foreach (IToken token in tokens.GetTokens())
{
tokenslst.Add(token);
}
acnParser parser = new acnParser(tokens);
acnParser.moduleDefinitions_return result = parser.moduleDefinitions();
ITree tree = (CommonTree)result.Tree;
CommonTreeNodeStream nodes = new CommonTreeNodeStream(tree);
nodes.TokenStream = tokens;
parsedInputFiles.Add(Tuple.Create(tree, inFileName, tokenslst.ToArray()));
}
return(parsedInputFiles);
}
private static ITree RunSyntaxAnalysys(string arg)
{
ICharStream input = new ANTLRFileStream(arg);
MathLangLexer lexer = new MathLangLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
MathLangParser parser = new MathLangParser(tokens);
return((ITree)parser.execute().Tree);
}
public static bool Prefix(ANTLRFileStream __instance, string fileName, Encoding encoding)
{
var asDynamic = __instance.AsDynamic();
asDynamic.data = _textProvider.GetText(fileName).WaitForResult().Text.ToCharArray();
asDynamic.n = asDynamic.data.Length;
return(false);
}
public static FBXDocument Load(string FBXfilename)
{
ANTLRFileStream fStream = new ANTLRFileStream(FBXfilename, Encoding.ASCII);
fbxLexer lexer = new fbxLexer(fStream);
fbxParser parser = new fbxParser(new CommonTokenStream(lexer));
FBXDocument doc = parser.document();
doc.bindingManager = new FBXBindingManager(doc);
return(doc);
}
public static void Main(string[] args)
{
// Use a try/catch block for parser exceptions
try
{
string inputFileName;
string templateFileName;
if ((args.Length == 1) || (args.Length == 2))
{
if (args.Length == 1)
{
templateFileName = "Java.stg";
inputFileName = args[0];
}
else
{
templateFileName = args[0];
inputFileName = args[1];
}
// Ensure full pathnames
if (!Path.IsPathRooted(templateFileName))
{
//templateFileName = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, templateFileName);
templateFileName = Path.Combine(Environment.CurrentDirectory, templateFileName);
}
if (!Path.IsPathRooted(inputFileName))
{
inputFileName = Path.Combine(Environment.CurrentDirectory, inputFileName);
}
templates = new StringTemplateGroup(new StreamReader(templateFileName),
typeof(AngleBracketTemplateLexer));
ICharStream input = new ANTLRFileStream(inputFileName);
CMinusLexer lexer = new CMinusLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
CMinusParser parser = new CMinusParser(tokens);
parser.TemplateLib = templates;
RuleReturnScope r = parser.program();
Console.Out.WriteLine(r.Template.ToString());
}
else
{
Console.Error.WriteLine("Usage: cminus [<output-template-file>] <input-file>");
}
}
catch (System.Exception e)
{
Console.Error.WriteLine("exception: " + e);
Console.Error.WriteLine(e.StackTrace); // so we can get stack trace
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public static void main(String[] args) throws Exception
public static void Main(string[] args)
{
Thread.Sleep(10000);
ANTLRFileStream input = new ANTLRFileStream(args[0]);
JavaLexer lexer = new JavaLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
JavaParser parser = new JavaParser(tokens);
JavaParser.CompilationUnitContext tree = parser.compilationUnit();
// System.out.println(tree.toStringTree(parser));
Thread.Sleep(10000);
}
public override void LoadScript(string path)
{
ANTLRFileStream fileStream = new ANTLRFileStream(path);
try
{
InterpretAntlrStream(fileStream);
}
catch (PartialStatement e)
{
throw e.InnerException;
}
}
private static void ApiGen(string protoFile, string shimTemplate)
{
ANTLRFileStream input = new ANTLRFileStream(protoFile);
FuncProtoToShimLexer lex = new FuncProtoToShimLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lex);
FuncProtoToShimParser parser = new FuncProtoToShimParser(shimTemplate, tokens);
parser.TraceDestination = Console.Error;
parser.list();
System.Console.WriteLine(parser.ToISystemAPI());
}
private void WeaveForOne(object sender, RoutedEventArgs e)
{
//選択されたパスからファイルを取得
var targetPath = TargetPath.Text;
var aspectPath = AspectPath.Text;
//アスペクト情報を持つオブジェクトを生成する
var aspect = new ANTLRFileStream(aspectPath);
var lexer = new UniAspectLexer(aspect);
var tokens = new CommonTokenStream(lexer);
var parser = new UniAspectParser(tokens);
//アスペクトファイルを解析してASTを生成する
var result = parser.aspect();
var ast = (CommonTree)result.Tree;
//ASTを走査してパース結果をアスペクトオブジェクトとしてvisitor内に格納する
var visitor = new AstVisitor();
visitor.Visit(ast, 0, null);
//対象ファイルの拡張子を取得
var fileExtension = Path.GetExtension(targetPath);
//対象言語のソースコードでない場合は次の対象へ進む
string langType;
if (fileExtension == null ||
!TargetLanguage.TryGetValue(fileExtension, out langType))
{
WeavedSourceArea.Text = "指定のプログラミング言語には対応していません";
return;
}
var code = File.ReadAllText(targetPath, XEncoding.SJIS);
var gen =
UnifiedGenerators.GetProgramGeneratorByExtension(
fileExtension);
var model = gen.Generate(code);
Weaver.AnalizeAspect(aspectPath);
//アスペクトの合成を行う
Weaver.Weave(langType, model);
//とりえあず標準出力に表示;
var codeGen = UnifiedGenerators.GetCodeGeneratorByExtension(fileExtension);
WeavedSourceArea.Text = codeGen.Generate(model);
}
public static void Main(string[] args)
{
if (args.Length > 0)
{
ICharStream input = new ANTLRFileStream(args[0]);
SimpleLexer lex = new SimpleLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lex);
SimpleParser parser = new SimpleParser(tokens);
parser.program();
}
else
{
Console.Error.WriteLine("Usage: island <input-file>");
}
}
private static void _Main(string[] args)
{
// input "x = 2*(3+3)"
ICharStream input;
if (args.Length > 0)
{
if (args[0].Equals("-i"))
{
if (args.Length > 1)
{
input = new ANTLRFileStream(args[1]);
}
else
{
throw new Exception("No input file specified.");
}
}
else
{
input = new ANTLRStringStream(args[0]);
}
}
else
{
input = new ANTLRInputStream(Console.OpenStandardInput());
}
var lex = new VecMathLexer(input);
var tokens = new CommonTokenStream(lex);
var g = new VecMathParser(tokens);
IAstRuleReturnScope <CommonTree> r = g.prog();
CommonTree t = r.Tree;
Console.WriteLine("Original tree: " + t.ToStringTree());
var simplify = new Simplify(new CommonTreeNodeStream(t));
t = (CommonTree)simplify.Downup(t);
var reduce = new Reduce(new CommonTreeNodeStream(t));
t = (CommonTree)reduce.Downup(t);
Console.WriteLine("Simplified tree: " + t.ToStringTree());
Console.ReadKey();
}
// アスペクトファイルを解析してその結果をフィールドに格納します
public static void AnalizeAspect(string aspectPath)
{
//アスペクト情報を持つオブジェクトを生成する
var aspect = new ANTLRFileStream(aspectPath);
var lexer = new UniAspectLexer(aspect);
var tokens = new CommonTokenStream(lexer);
var parser = new UniAspectParser(tokens);
//アスペクトファイルを解析してASTを生成する
var result = parser.aspect();
var ast = (CommonTree)result.Tree;
//ASTを走査してパース結果をアスペクトオブジェクトとしてvisitor内に格納する
_visitor = new AstVisitor();
_visitor.Visit(ast, 0, null);
}
public static void Main(string[] args)
{
if (args.Length == 1)
{
ICharStream input = new ANTLRFileStream(args[0]);
TLexer lex = new TLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lex);
//System.out.println("tokens="+tokens);
TParser parser = new TParser(tokens);
parser.stat();
}
else
{
Console.Error.WriteLine("Usage: hoisted <input-file>");
}
}
public static void Main(string[] args)
{
ANTLRFileStream input = new ANTLRFileStream("test.cpp");
cvartrackerLexer lexer = new cvartrackerLexer(input);
CommonTokenStream stream = new CommonTokenStream(lexer);
cvartrackerParser parser = new cvartrackerParser(stream);
parser.greet();
Console.WriteLine("The collected names are:");
foreach (string name in parser.Names)
{
Console.WriteLine(name);
}
}
public static CommonTreeNodeStream parseFile(string fullName)
{
if (cfg.Verbosity > 2)
{
Console.WriteLine("Parsing " + Path.GetFileName(fullName));
}
ICharStream input = new ANTLRFileStream(fullName);
PreProcessor lex = new PreProcessor();
lex.AddDefine(cfg.MacroDefines);
lex.CharStream = input;
lex.TraceDestination = Console.Error;
CommonTokenStream tokens = new CommonTokenStream(lex);
// if (tokens.LT(1).Type == TokenTypes.EndOfFile)
// {
// Console.WriteLine("File is empty");
// return null;
// }
csParser p = new csParser(tokens);
p.TraceDestination = Console.Error;
p.IsJavaish = cfg.InternalIsJavaish;
csParser.compilation_unit_return parser_rt = p.compilation_unit();
if (parser_rt == null || parser_rt.Tree == null)
{
if (lex.FoundMeat)
{
Console.WriteLine("No Tree returned from parsing! (Your rule did not parse correctly)");
}
else
{
// the file was empty, this is not an error.
}
return(null);
}
CommonTreeNodeStream nodes = new CommonTreeNodeStream(parser_rt.Tree);
nodes.TokenStream = tokens;
return(nodes);
}
public void SetUp()
{
//アスペクトファイルのパスを取得
var input = new ANTLRFileStream(FixtureUtil.GetAspectPath("simple_advice_sample.apt"));
//アスペクトファイルをパースして抽象構文木を生成する
var lex = new UniAspectLexer(input);
var tokens = new CommonTokenStream(lex);
var parser = new UniAspectParser(tokens);
var result = parser.aspect();
var ast = (CommonTree)result.Tree;
//抽象構文木を走査して、ポイントカット・アドバイス情報を格納する
_visitor = new AstVisitor();
_visitor.Visit(ast, 0, null);
}
public static void Main(string[] args)
{
ICharStream input;
if (args.Length > 0)
{
input = new ANTLRFileStream(args[0]);
}
else
{
input = new ANTLRReaderStream(Console.In);
}
// BUILD AST
PolyLexer lex = new PolyLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lex);
PolyParser parser = new PolyParser(tokens);
PolyParser.poly_return r = parser.poly();
Console.Out.WriteLine("tree=" + ((ITree)r.Tree).ToStringTree());
// DIFFERENTIATE
CommonTreeNodeStream nodes = new CommonTreeNodeStream(r.Tree);
nodes.TokenStream = tokens;
PolyDifferentiator differ = new PolyDifferentiator(nodes);
PolyDifferentiator.poly_return r2 = differ.poly();
Console.Out.WriteLine("d/dx=" + ((ITree)r2.Tree).ToStringTree());
// SIMPLIFY / NORMALIZE
nodes = new CommonTreeNodeStream(r2.Tree);
nodes.TokenStream = tokens;
Simplifier reducer = new Simplifier(nodes);
Simplifier.poly_return r3 = reducer.poly();
Console.Out.WriteLine("simplified=" + ((ITree)r3.Tree).ToStringTree());
// CONVERT BACK TO POLYNOMIAL
nodes = new CommonTreeNodeStream(r3.Tree);
nodes.TokenStream = tokens;
PolyPrinter printer = new PolyPrinter(nodes);
PolyPrinter.poly_return r4 = printer.poly();
Console.Out.WriteLine(r4.ST);
}
public override Antlr4.StringTemplate.Compiler.CompiledTemplate LoadAbsoluteTemplateFile(string fileName)
{
ANTLRFileStream antlrFileStream;
try
{
antlrFileStream = new ANTLRFileStream(fileName, this.Encoding);
antlrFileStream.name = fileName;
}
catch (IOException ex)
{
return((CompiledTemplate)null);
}
return(this.LoadTemplateFile("", fileName, (ICharStream)antlrFileStream));
return(base.LoadAbsoluteTemplateFile(fileName));
}
public static int Compile(string inputPath, string outputPath)
{
try
{
ANTLRFileStream input = new ANTLRFileStream(inputPath);
//LexicalAnalysis
TigerLexer lexer = new TigerLexer(input);
CommonTokenStream tokenStream = new CommonTokenStream(lexer);
//SintaxAnalysis
TigerParser parser = new TigerParser(tokenStream); //Use tokens obtained by lexer
parser.TreeAdaptor = new ASTFactory(); //Use my ASTFactory
TigerParser.tiger_program_return tigerProgram = parser.tiger_program();
//**Check lexical and sintax errors
if (lexer.Errors.Count == 0 && parser.Errors.Count == 0)
{
//SemanticAnalysis
List <Error> semanticErrors = new List <Error>();
SymbolTable symbolTable = new SymbolTable();
InstructionNode decoratedExpr = tigerProgram.Tree as InstructionNode;
decoratedExpr.CheckSemantic(semanticErrors, symbolTable);
if (semanticErrors.Count == 0)
{
TypeExpression programReturnType = decoratedExpr.ReturnType.PrimitiveType;
if (programReturnType is BuiltInType || programReturnType is NilType)
{
ProgramGenerator.BuildTigerProgram(outputPath, decoratedExpr);
return(ReportCompilationSuccesful(inputPath));
}
string message = "If program isn't a valueless expression its return type has to be a built-in type";
semanticErrors.Add(new Error(message, decoratedExpr.Line, decoratedExpr.CharPositionInLine));
}
return(ReportCompilationFailed(semanticErrors));
}
IEnumerable <Error> antlrErrors = lexer.Errors.Union(parser.Errors);
return(ReportCompilationFailed(antlrErrors));
}
catch (Exception e)
{
IEnumerable <Error> exeption = new[] { new Error(e.Message, 0, 0, ErrorKind.UserError) };
return(ReportCompilationFailed(exeption));
}
}
public AstVisitor CreateAspectElement(string path)
{
//アスペクトファイルの生成
var aspect = new ANTLRFileStream(path);
var lexer = new UniAspectLexer(aspect);
var tokens = new CommonTokenStream(lexer);
var parser = new UniAspectParser(tokens);
//アスペクトファイルを解析してASTを生成する
var result = parser.aspect();
var ast = (CommonTree)result.Tree;
var visitor = new AstVisitor();
visitor.Visit(ast, 0, null);
return(visitor);
}
public static void Main(string[] args)
{
if (args.Length > 0)
{
ICharStream input = new ANTLRFileStream(args[0]);
PythonLexer lexer = new MyLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
PythonTokenSource indentedSource = new PythonTokenSource(tokens);
tokens = new CommonTokenStream(indentedSource);
//Console.Out.WriteLine("tokens="+tokens.GetTokens());
PythonParser parser = new PythonParser(tokens);
parser.file_input();
}
else
{
Console.Error.WriteLine("Usage: dynscope <input-file>");
}
}
public static ProgramNode ParseInput(string inputPath)
{
try
{
ANTLRFileStream input = new ANTLRFileStream(inputPath);
TigerLexer lexer = new TigerLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
TigerParser parser = new TigerParser(tokens);
parser.TreeAdaptor = new Adaptor();
var program = (ProgramNode)parser.program().Tree;
return(program);
}
catch (ParsingException exc)
{
Console.WriteLine("({1},{2}): {0}", exc.Message, exc.RecognitionError.Line, exc.RecognitionError.CharPositionInLine);
Environment.ExitCode = (int)ErrorCode.Error;
return(null);
}
}
public static COOLCommonTree Parse(string code)
{
var stringStream = new ANTLRFileStream(code);
COOLLexer lexer = new COOLLexer(stringStream);
CommonTokenStream stream = new CommonTokenStream(lexer);
COOLParser parser = new COOLParser(stream);
ITreeAdaptor adaptor = new COOLCommonTreeAdaptor();
parser.TreeAdaptor = adaptor;
parser.TraceDestination = Console.Out;
var tree = parser.program();
if (parser.NumberOfSyntaxErrors > 0)
{
Console.WriteLine("Compilation terminated because of sintax errors");
return(null);
}
return(tree.Tree);
}
public static void Main(string[] args)
{
ICharStream input;
if ( args.Length>0 ) {
input = new ANTLRFileStream(args[0]);
}
else {
input = new ANTLRReaderStream(Console.In);
}
// BUILD AST
PolyLexer lex = new PolyLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lex);
PolyParser parser = new PolyParser(tokens);
PolyParser.poly_return r = parser.poly();
Console.Out.WriteLine("tree="+((ITree)r.Tree).ToStringTree());
// DIFFERENTIATE
CommonTreeNodeStream nodes = new CommonTreeNodeStream(r.Tree);
nodes.TokenStream = tokens;
PolyDifferentiator differ = new PolyDifferentiator(nodes);
PolyDifferentiator.poly_return r2 = differ.poly();
Console.Out.WriteLine("d/dx="+((ITree) r2.Tree).ToStringTree());
// SIMPLIFY / NORMALIZE
nodes = new CommonTreeNodeStream(r2.Tree);
nodes.TokenStream = tokens;
Simplifier reducer = new Simplifier(nodes);
Simplifier.poly_return r3 = reducer.poly();
Console.Out.WriteLine("simplified="+((ITree) r3.Tree).ToStringTree());
// CONVERT BACK TO POLYNOMIAL
nodes = new CommonTreeNodeStream(r3.Tree);
nodes.TokenStream = tokens;
PolyPrinter printer = new PolyPrinter(nodes);
PolyPrinter.poly_return r4 = printer.poly();
Console.Out.WriteLine(r4.ST);
}
