Exemple #1
0
        private static Goal Parse(string path)
        {
            var parser = new MiniJavaParser();

            try
            {
                var goal = parser.Parse(File.ReadAllText(path));
                if (goal == null)
                {
                    foreach (var error in parser.Errors)
                    {
                        Helpers.WriteLineColor(error, ConsoleColor.Red, ConsoleColor.Black);
                    }
                }
                return(goal);
            }
            catch (Exception)
            {
                foreach (var error in parser.Errors)
                {
                    Helpers.WriteLineColor(error, ConsoleColor.Red, ConsoleColor.Black);
                }
                return(null);
            }
        }
Exemple #2
0
        private void Run(string fileNameCommon)
        {
            try
            {
                Lexer grammarLexer = new Lexer(FileName);

                Console.WriteLine(MessagesHelper.InfoLexer);

                MiniJavaParser parser = new MiniJavaParser(grammarLexer.TokenStream);
                //Antlr.Runtime.Tree.CommonTree tree = parser.program().Tree;
                //Console.WriteLine();
                //Console.WriteLine(tree.ToStringTree());
                //Console.WriteLine();
                //parser.Reset();

                BaseSymbol symbol = parser.program().value;

                Console.WriteLine(MessagesHelper.InfoParser);

                //Console.WriteLine(symbol.ToStringTree());

                if (parser.HasError)
                {
                    Console.WriteLine(MessagesHelper.ErrorParser);
                    Console.WriteLine(parser.ErrorMessage);
                    Console.WriteLine(parser.ErrorPosition);
                    HasError = true;
                }
                else
                {
                    //Console.WriteLine(symbol.ToXmlTree());
                    grammarLexer.SaveToFile(string.Format("{0}{1}", fileNameCommon, LexerPostfix));
                    symbol.SaveToFile(string.Format("{0}{1}", fileNameCommon, ParserPostfix));
                    Console.WriteLine(MessagesHelper.InfoCompiler);

                    try
                    {
                        ICompilerLogger logger  = new CompilerLogger(string.Format("{0}{1}", fileNameCommon, CodegenPostfix));
                        string          exeName = string.Format("{0}.exe", fileNameCommon);
                        SharpCodeGen    codeGen = new SharpCodeGen(symbol, exeName, logger);
                        codeGen.GenerateCode();
                        logger.Save();
                        Console.WriteLine("{0}{1}{2}: [{3}]", MessagesHelper.SuccessCompiler, GrammarHelper.NewLineSymbol, MessagesHelper.Output, exeName);
                    }
                    catch (CodeGenerationException ex)
                    {
                        HasError = true;
                        Console.WriteLine("{0}{1}{2}", MessagesHelper.ErrorCompiler, GrammarHelper.NewLineSymbol, ex.CompilerMessage);
                    }
                }
            }
            catch (CompilerException ex)
            {
                Console.WriteLine("{0}{1}{2}", MessagesHelper.ErrorParser, GrammarHelper.NewLineSymbol, ex.CompilerMessage);
            }
        }
Exemple #3
0
        public void Parse(string input, string[] compilerOptions)
        {
            string fileName = Path.GetFileNameWithoutExtension(compilerOptions[0]);

            ParseCompilerOptions(compilerOptions);

            AntlrInputStream inputStream = new AntlrInputStream(input);

            MiniJavaLexer miniJavaLexer = new MiniJavaLexer(inputStream);

            CommonTokenStream commonTokenStream = new CommonTokenStream(miniJavaLexer);
            MiniJavaParser    miniJavaParser    = new MiniJavaParser(commonTokenStream);

            miniJavaParser.AddErrorListener(ErrorListener.INSTANCE);

            var cst = miniJavaParser.prg();

            if (ErrorListener.INSTANCE.errorCounter > 0)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine("Sorry this is all my fault :(");
            }
            else
            {
                // Generate AST //

                var ast = cst.ToAst();

                // Type Checking //

                TypeChecker typeChecker = new TypeChecker();
                typeChecker.InitTypeChecking(ast);
                typeChecker.StartTypeChecking(ast);

                // Convert to intermediate //

                IntermediateAstBuilder intermediate = new IntermediateAstBuilder();
                var interTree     = intermediate.BuildIntermediateAst(ast);
                var canonizedTree = new Canonizer().CanonPrg((TreePrg)interTree);

                // assembly //
                I386CodeGenerator codeGenerator = new I386CodeGenerator();
                var i386Prg = (I386Prg)codeGenerator.CodeGen(canonizedTree);

                if (WithoutAlloc)
                {
                    File.WriteAllText(fileName + "_noallocs.s", i386Prg.RenderAssembly());
                }

                // Liveness analysis //
                RegisterAllocator registerAllocator = new RegisterAllocator();
                registerAllocator.AllocateRegisters(i386Prg, codeGenerator.GetGeneralPurposeRegisters());

                Afterburner afterburner = new Afterburner();
                afterburner.RemoveRedundancies(i386Prg);



                if (Intermediate)
                {
                    File.WriteAllText(fileName + ".tree", canonizedTree.ToString());
                }
                File.WriteAllText(fileName + ".s", i386Prg.RenderAssembly());

                Console.ForegroundColor = ConsoleColor.Green;
                Console.WriteLine("You did great!");
                Console.ForegroundColor = ConsoleColor.White;
            }
        }