CL.java

Go to the documentation of this file.

import java.util.List;
import org.antlr.runtime.*;
import org.antlr.runtime.tree.*;
import org.antlr.stringtemplate.*;
import java.io.*;

public class CL {

    private static final int DEFAULT_LAST_STEP = 8;

    public static void main(String[] args) throws Exception, RecognitionException {
        ANTLRStringStream input     = new ANTLRStringStream();
        int               last_step = DEFAULT_LAST_STEP;

        // En primer lugar se determina de donde se lee el
        // programa de entrada y en que; paso se detiene el
        // traductor/interprete.
        if (args.length == 0) {         // sin argumentos en args
            last_step = DEFAULT_LAST_STEP;
            input     = new ANTLRInputStream(System.in);
        } else if (args.length == 1) {  // un solo argumento en args
            if (args[0].startsWith("-")) {
                last_step = Integer.parseInt(args[0].substring(1, args[0].length()));
                input     = new ANTLRInputStream(System.in);
            } else {
                last_step = DEFAULT_LAST_STEP;
                input     = new ANTLRFileStream(args[0]);
            }
        } else if (args.length == 2) {  // dos argumentos en args
            last_step = Integer.parseInt(args[0].substring(1, args[0].length()));
            input     = new ANTLRFileStream(args[1]);
        } else {                        // numero incorrecto de argumentos en args
            System.out.println("Usage: java CL [-<step>] [<file>]");
            System.out.println("       with <step> in 1..11\t(default = " + DEFAULT_LAST_STEP + ")");
            System.exit(1);
        }

        // Se declara el lexer y otras las variables necesarias
        // para crear correctamente el parser, y se le especifica
        // como son los arboles que construira.
        CLLexer           lexer  = new CLLexer(input);
        CommonTokenStream tokens = new CommonTokenStream(lexer);
        CLParser          parser = new CLParser(tokens);

        parser.setTreeAdaptor(new CL_AST_Adaptor());

        List<RecognitionException> recognitionExceptions;

        // Se llama al parser y se obtiene el AST construido.
        CLParser.program_return ret = parser.program();

        CL_AST ast = (CL_AST) ret.getTree();

        // Se comprueban los errores lexicos.
        recognitionExceptions = lexer.getExceptions();
        if (recognitionExceptions.size() > 0) {
            System.out.println("Lexer threw exceptions -- see output");
            System.exit(1);
        }

        // Se comprueban los errores sintacticos.
        recognitionExceptions = parser.getExceptions();
        if (recognitionExceptions.size() > 0) {
            System.out.println("Parser threw exceptions -- see output");
            System.exit(1);
        }

        if (last_step == 1 || last_step == 2) {
            System.exit(0);
        }

        // Se escribe el AST tanto en formato multilinea
        // con tabulacion como en formato DOT para que mas tarde
        // pueda verse como un grafico.
        // // System.out.println(ast.toStringTree());
        if (last_step == 3) {
            System.out.print(CL_AST.toIndentedTreeString(ast));
            DOTTreeGenerator gen    = new DOTTreeGenerator();
            StringTemplate st       = gen.toDOT(ast);
            FileWriter outputStream = new FileWriter("ast.dot");
            outputStream.write(st.toString());
            outputStream.close();
            System.exit(0);
        }

        // Se declaran las variables necesarias para crear
        // correctamente el typeCheck especificandole
        // la tabla de simbolos que usara (inicialmente vacia).
        CommonTreeNodeStream nodes     = new CommonTreeNodeStream(ast);
        SymTab               symtab    = new SymTab();
        TypeCheck            typeCheck = new TypeCheck(nodes, symtab);

        // Se llama al analisis semantico typeCheck.
        typeCheck.program();

        // Se comprueban los errores de no reconocimiento del AST.
        recognitionExceptions = typeCheck.getExceptions();
        if (recognitionExceptions.size() > 0) {
            System.out.println("Tree parser 'TypeCheck' threw exceptions -- see output");
            System.exit(1);
        }

        if (last_step == 4) {
            System.exit(0);
        }

        // Se vuelve a escribir el AST en formato multilinea con
        // tabulacion. Ahora se visualizara tambien su decoracion.
        if (last_step == 5) {
            System.out.print(CL_AST.toIndentedTreeString(ast));
            System.exit(0);
        }

        // Se obtienen y, si existen, se escriben los errores semanticos.
        SemanticErrors errors = typeCheck.getSemanticErrors();

        if (typeCheck.getNumberOfSemanticErrors() > 0 && last_step == 6) {
            System.out.print(errors.toString());
            System.exit(0);
        }

        if (last_step == 6) {
            System.exit(0);
        }

        // Si existen errores semanticos se detiene la compilacion
        // aunque se haya pedido llegar hasta un paso posterior.
        if (typeCheck.getNumberOfSemanticErrors() > 0) {
            System.out.print(errors.toString());
            System.out.println("Type checking: " + typeCheck.getNumberOfSemanticErrors() + " semantic errors has been found.");
            System.exit(0);
        }

        // Se declaran las variables necesarias para crear
        // correctamente el codeGen especificandole
        // la tabla de simbolos y la biblioteca
        // de templates que usara. Se usa el mismo NodeStream
        // que en el typeCheck pero se hace un reset para
        // situarse otra vez en la raiz del AST.

        // load the group file CodeGen.stg, put in templates var
        FileReader groupFileR         = new FileReader("CodeGen.stg");
        StringTemplateGroup templates = new StringTemplateGroup(groupFileR);
        groupFileR.close();

        nodes.reset();  // NodeStream will be revisited
        CodeGen codeGen = new CodeGen(nodes, symtab);

        codeGen.setTemplateLib(templates);  // where to find templates

        // Se llama al generador de codigo codeGen y se obtiene
        // el template con el t-codigo generado.
        CodeGen.program_return ret2 = codeGen.program();

        StringTemplate output       = (StringTemplate) ret2.getTemplate();

        // Se comprueban los errores de no reconocimiento del AST.
        recognitionExceptions = codeGen.getExceptions();
        if (recognitionExceptions.size() > 0) {
            System.out.println("Tree parser 'CodeGen' threw exceptions -- see output");
            System.exit(1);
        }

        if (last_step == 7) {
            System.exit(0);
        }

        // Se transforma el template en texto, y se hacen algunos
        // cambios para que quede visualmente mejor.
        String         myTCode       = output.toString();  // render full template
        String myTCodeWoutBlankLines = myTCode.replaceAll("\n[\n]+","\n").replaceAll("\nsubroutine","\n\nsubroutine");

        // Se escribe el t-codigo generado.
        if (last_step == 8) {
            // Emit Codegen
            // get template from return values struct
            System.out.print(myTCodeWoutBlankLines);
            System.exit(0);
        }

        // Comienza el interprete que tiene dos partes
        //    (1) analisis lexico y sintactico del t-codigo
        //    (2) analisis semantico del t-codigo
        //    (3) ejecucion del t-codigo
        // Se declaran las variables necesarias para crear
        // correctamente el lexer y el parser del t-codigo.
        ANTLRStringStream tcodeInput  = new ANTLRStringStream(myTCodeWoutBlankLines);
        TCodeLexer        tcodeLexer  = new TCodeLexer(tcodeInput);
        CommonTokenStream tcodeTokens = new CommonTokenStream(tcodeLexer);
        TCodeParser       tcodeParser = new TCodeParser(tcodeTokens);

        // Se llama al parser de t-codigo.
        tcodeParser.program();

        // Se comprueban los errores lexico/sintacticos del t-codigo.
        recognitionExceptions = tcodeParser.getExceptions();
        if (recognitionExceptions.size() > 0) {
            System.out.println("Parser 'TCodeParser' threw exceptions -- see output");
            System.exit(1);
        }

        if (last_step == 9) {
            System.exit(0);
        }

        // Se obtiene la representacion del t-codigo generada
        // por el parser.
        TCode  tcode   = tcodeParser.getTCode();

        // Se obtienen y, si existen, se escriben los errores semanticos.
        TCodeSemanticErrors tcErrors = tcode.getSemanticErrors();

        if (tcErrors.getNumberOfSemanticErrors() > 0 && last_step == 10) {
            System.out.print(tcErrors.toString());
            System.exit(0);
        }

        if (last_step == 10) {
            System.exit(0);
        }

        // Si existen errores semanticos se detiene la compilacion
        // aunque se haya pedido llegar hasta un paso posterior.
        if (tcErrors.getNumberOfSemanticErrors() > 0) {
            System.out.println("The TCode generated has " + tcErrors.getNumberOfSemanticErrors() + " semantic errors:");
            System.out.print(tcErrors.toString());
            System.exit(0);
        }

        // A continuacion se ejecuta usando el metodo run() que
        // devuelve un string con los resultados, y finalmente
        // estos se escriben.
        String results = tcode.run();
        System.out.print(results);
    }

}