public static MAst Compile(AstHelper runtime, ICharStream stream) { var lexer = new TigerLexer(stream); var tokens = new CommonTokenStream(lexer); var parser = new TigerParser(tokens); ProgramExpression programExpression = parser.parse(); if (parser.NumberOfSyntaxErrors > 0) { IEnumerable <string> errors = from e in parser.Errors select e.ToString(); throw new SyntaxException(errors); } AstHelper helper = runtime.CreateChild(function: true, variables: true, types: true); programExpression.CheckSemantics(helper); if (helper.Errors.HasErrors) { throw new SemanticException(helper.Errors); } return(programExpression.Transform()); }
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); }
public static TigerParser CreateParser(string program) { var stream = new ANTLRStringStream(program); var lexer = new TigerLexer(stream); var tokens = new CommonTokenStream(lexer); var parser = new TigerParser(tokens); return(parser); }
private static void Main(string[] args) { var input = new ANTLRStringStream("if row[0] = 0 then 0"); var lexer = new TigerLexer(input); var tokens = new CommonTokenStream(lexer); var parser = new TigerParser(tokens); ExpressionNode x = parser.prog(); // Debug(); }
protected AstNode ParseText(string text) { var s = new StreamReader(GenerateStreamFromString(text)); var stm = new AntlrInputStream(s);; var lexer = new TigerLexer(stm); var tokenStream = new CommonTokenStream(lexer); var parser = new TigerParser(tokenStream); var expContext = parser.program(); var contextVisitor = new BuildAstVisitor(); return(expContext.Accept(contextVisitor)); }
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 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); } }
private static void Debug() { string[] files = Directory.GetFiles(@"C:\HERE\School\!4to\Complementos de Compilacion\Compilador\Test cases\Others", "*.tig"); syntax_error = new List<string>(); syntax_error.Add("appel_test49.tig"); syntax_error.Add("comment_not_ended_before_program.tig"); syntax_error.Add("break_out_of_for"); //No ponen nada dentro del let-in int errorsCount = 0; foreach (string file in files) { if (HasSyntaxError(file)) { continue; } // Console.WriteLine(string.Format("Testing file: {0}", file)); var input = new ANTLRFileStream(file); var lexer = new TigerLexer(input); var tokens = new CommonTokenStream(lexer); var parser = new TigerParser(tokens); ExpressionNode x = parser.prog(); if (parser.Errors.Count > 0) { Console.WriteLine(string.Format("Error in file: {0}", file)); errorsCount++; foreach (string error in parser.Errors) { Console.WriteLine(string.Format("Error: {0}", error)); } // Console.ReadLine(); } // else // { // Console.WriteLine("OK!"); // } } Console.WriteLine(string.Format("Done. Errors: {0}", errorsCount)); Console.ReadLine(); }
static Node ParseInput(string inputPath) { try { var input = new AntlrFileStream(inputPath); var lexer = new TigerLexer(input); var errors = new List <string>(); lexer.RemoveErrorListeners(); lexer.AddErrorListener(new LexerErrorListener(errors)); var tokens = new CommonTokenStream(lexer); var parser = new TigerParser(tokens); parser.RemoveErrorListeners(); parser.AddErrorListener(new ParserErrorListener(errors)); IParseTree tree = parser.compileUnit(); if (errors.Any()) { Console.WriteLine(); foreach (var error in errors) { Console.WriteLine(error); } return(null); } var astBuilder = new ASTBuilder(); Node ast = astBuilder.Visit(tree); return(ast); } catch (Exception e) { Console.Error.WriteLine(e.Message); return(null); } }
/// <summary> /// Compila el codigo que se encuentra en el fichero filename /// </summary> /// <param name="filename">El fichero a compilar</param> /// <param name="typeName">El nombre del tipo que contendra las funciones que se definan</param> /// <returns>Retorna una lista con los errores que se produjeron</returns> private IEnumerable <AnalysisError> Compile(string filename, string typeName) { var s = new StreamReader(filename); var stm = new AntlrInputStream(s);; var lexer = new TigerLexer(stm); var tokenStream = new CommonTokenStream(lexer); var parser = new BengalaParser(tokenStream); parser.ConfigErrorListeners(); var expContext = parser.program(); var contextVisitor = new BuildAstVisitor(); var errorsWarning = parser.Errors; if (parser.NumberOfSyntaxErrors != 0 || parser.Errors.Any()) { return(errorsWarning); } var astRoot = expContext.Accept(contextVisitor); var generalScope = new Scope(null); init = new Inizializator <ILCode>(generalScope); InitScope(generalScope); var errorListener = new BengalaBaseErrorListener(); var staticAnalysisVisitor = new StaticChecker(errorListener, generalScope); astRoot.Accept(staticAnalysisVisitor); if (GenerateCode && !errorListener.Errors.Any()) { CreateCode(FileName(filename), typeName, astRoot); } return(errorListener.Errors); }
private static int Main(string[] args) { Console.WriteLine("Tiger Compiler version 1.0"); Console.WriteLine(@"Copyright (C) 2015-2016 Laila González Fernández & Mario César Muñiz Jiménez"); //Creating report, parser and lexer var arg = args[0]; var report = new Report(); var characters = new ANTLRFileStream(arg); var lexer = new TigerLexer(report, characters); var tokens = new CommonTokenStream(lexer); var parser = new TigerParser(report, tokens) { TraceDestination = Console.Out, TreeAdaptor = new TreeAdaptor() }; //Syntactic analysis var ret = (ProgramNode)parser.program().Tree; if (!report.IsOk) { foreach (var message in report) { Console.WriteLine($"({message.Line}, {message.Column}): {message.Text}"); } return(1); } //Preparing assembly var name = Path.GetFileNameWithoutExtension(arg); var filename = name + ".exe"; var assemblyName = new AssemblyName(name); var assembly = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.RunAndSave); var moduleBuilder = assembly.DefineDynamicModule(name, filename); var programType = moduleBuilder.DefineType(name + ".Program", TypeAttributes.Public); var mainMethod = programType.DefineMethod("Main", MethodAttributes.Static | MethodAttributes.Public, typeof(void), Type.EmptyTypes); var generator = mainMethod.GetILGenerator(); assembly.SetEntryPoint(mainMethod); ProgramNode.Module = moduleBuilder; ProgramNode.Program = programType; //Semantic analysis ret.CheckSemantics(new TigerScope(programType), report); if (!report.IsOk) { foreach (var message in report) { Console.WriteLine($"({message.Line}, {message.Column}): {message.Text}"); } return(1); } generator.BeginExceptionBlock(); //Code generation ret.GenerateCode(generator); if (!TigerType.AreOfSameType(ret.TigerType, TigerType.Void)) { generator.Emit(OpCodes.Pop); } generator.BeginCatchBlock(typeof(Exception)); generator.BeginScope(); LocalBuilder exception = generator.DeclareLocal(typeof(Exception)); MethodInfo writeLineSO = typeof(TextWriter).GetMethod("WriteLine", new Type[] { typeof(string), typeof(object) }); MethodInfo writeLineS = typeof(TextWriter).GetMethod("WriteLine", new Type[] { typeof(string) }); MethodInfo standardErrorOutput = typeof(Console).GetProperty("Error").GetGetMethod(); generator.Emit(OpCodes.Stloc, exception); generator.Emit(OpCodes.Call, standardErrorOutput); generator.Emit(OpCodes.Ldstr, "Exception of type '{0}' was thrown."); generator.Emit(OpCodes.Ldloc, exception); generator.Emit(OpCodes.Callvirt, typeof(Exception).GetMethod("GetType", Type.EmptyTypes)); generator.Emit(OpCodes.Callvirt, typeof(Type).GetProperty("Name").GetGetMethod()); generator.Emit(OpCodes.Callvirt, writeLineSO); generator.Emit(OpCodes.Call, standardErrorOutput); generator.Emit(OpCodes.Ldloc, exception); generator.Emit(OpCodes.Callvirt, typeof(Exception).GetProperty("Message").GetGetMethod()); generator.Emit(OpCodes.Callvirt, writeLineS); generator.EndScope(); generator.Emit(OpCodes.Ldc_I4_1); generator.Emit(OpCodes.Call, typeof(Environment).GetMethod("Exit")); generator.EndExceptionBlock(); generator.Emit(OpCodes.Ret); programType.CreateType(); assembly.Save(filename); return(0); }
/// <summary> /// Compiles a Tiger source code /// </summary> /// <param name="input">Source code input</param> /// <returns>True if compilation proccess succeded, False otherwise</returns> private static bool Compile(ICharStream input) { ///limpiamos los errores antes del proceso de compilación Errors = new List <CompileError>(); ///creamos el lexer Lexer = new TigerLexer(input); ///creamos los tokens Tokens = new CommonTokenStream(Lexer); ///creamos el parser Parser = new TigerParser(Tokens); Parser.TreeAdaptor = new TigerAdaptor(); try { ///análisis sintáctico Lexer.OnLexicalErrorOcurrence += NotifyLexicError; Parser.OnParsingErrorOcurrence += NotifySyntacticError; Ast = Parser.program().Tree as ExpressionNode; ///en caso de que no fuera un ExpressionNode if (Ast == null) { throw new Exception("A parsing error ocurred"); } ///en caso de haber errores sintácticos if (Errors.Count > 0) { return(false); } ///creamos la tabla de símbolos SemanticSymbolTable = new SymbolTable(); ///análisis semántico Ast.CheckSemantic(SemanticSymbolTable, Errors); ///en caso de haber errores semánticos if (Errors.Count > 0) { return(false); } ///generamos código CodeGenerator = new ILCodeGenerator(ExecutableFileName, ParentDirectory); CodeGenerator.OnBuildingErrorOcurrence += NotifyBuildError; Ast.GenerateCode(CodeGenerator); ///si el Ast retorna valor, lo sacamos de la pila if (Ast.NodeInfo.BuiltInType.IsReturnType()) { CodeGenerator.ILGenerator.Emit(OpCodes.Pop); } ///salvamos el ejecutable return(CodeGenerator.SaveExecutable()); } catch (RecognitionException re) { ///elaboramos el mensaje de error string errorMessage = Lexer.GetErrorMessage(re, Lexer.TokenNames); ///agregamos el error sintáctico(aunque esto es en caso de que el parser explote) Errors.Add(new CompileError { Line = re.Line, Column = re.CharPositionInLine, ErrorMessage = errorMessage, Kind = ErrorKind.Lexic }); return(false); } catch (Exception e) { //change Errors.Add(new CompileError { Line = 0, Column = 0, ErrorMessage = "Compile process terminated due to unexpected error", Kind = ErrorKind.Build }); return(false); } }