SymTab.java

Go to the documentation of this file.

import java.util.Vector;
import java.util.Map;
import java.util.HashMap;


enum SymbolClass {
    UNKNOWN_CLASS,
    VAR_LOCAL,
    PARAM_VALOR,
    PARAM_REFER,
    PROCEDURE,
    FUNCTION
}


enum SymTabMode {
    MODE_UNDEFINED,
    MODE_BUILDING,
    MODE_REVISITING
}


class InfoSym {

    // Numero de linea y columna donde fue declarado
    private int line;

    private int coln;

    // Atributos usados en TypeCheck y en CodeGen
    private SymbolClass clas;

    private TypeTree type;

    // Atributos establecidos, y usados, solo en CodeGen
    private int offset;

    private String label;

    InfoSym(int l, int c, SymbolClass cl, TypeTree t) {
        line = l;
        coln = c;
        clas = cl;
        type = t;
    }

    InfoSym(InfoSym s) {
        line = s.line;
        coln = s.coln;
        clas = s.clas;
        type = s.type;
    }

    int getLine() {
        return line;
    }

    int getColumn() {
        return coln;
    }

    SymbolClass getClas() {
        return clas;
    }

    TypeTree getTypeTree() {
        return type;
    }

    void setTypeTree(TypeTree t) {
        type = t;
    }

    int getIdentOffset() {
        return offset;
    }

    void setIdentOffset(int n) {
        offset = n;
    }

    String getIdentLabel() {
        return label;
    }

    void setIdentLabel(String s) {
        label = s;
    }

    static private String toStringSymbolClass(SymbolClass sc) {
        switch (sc) {
        case VAR_LOCAL:
            return "VAR_LOCAL";
        case PARAM_VALOR:
            return "PARAM_VALOR";
        case PARAM_REFER:
            return "PARAM_REFER";
        case PROCEDURE:
            return "PROCEDURE";
        case FUNCTION:
            return "FUNCTION";
        default:
            return "UNKNOWN_SYMBOL_CLASS";
        }
    }

    String toString(SymTabMode mode) {
        StringBuffer sb = new StringBuffer();
        sb.append("line: " + line + " coln: " + coln);
        sb.append("  class: " + toStringSymbolClass(clas));
        sb.append("  type: " + type.toStringTree());
        if (mode == SymTabMode.MODE_REVISITING) {  // En CodeGen
            switch (clas) {
            case VAR_LOCAL:
            case PARAM_VALOR:
            case PARAM_REFER:
                sb.append("  offset: " + offset);
                break;
            case PROCEDURE:
            case FUNCTION:
                sb.append("  label: " +  label);
                break;
            }
        }
        return sb.toString();
    }

}


final class OneScope {

    private String name;

    Map<String, InfoSym> table;

    Vector<String> orderedSymbols;

    OneScope(String s) {
        name = s;
        table = new HashMap<String, InfoSym>();
        orderedSymbols = new Vector<String>();
    }

    String getScopeName() {
        return name;
    }

    String toString(SymTabMode mode) {
        StringBuffer sb = new StringBuffer();
        sb.append("scopeName: " + name + " \n");
        // Escribe los simbolos ordenados por orden de insercion
        for (int i = 0; i < orderedSymbols.size(); i++) {
            sb.append("    '" + orderedSymbols.elementAt(i) + "'\t[");
            sb.append(table.get(orderedSymbols.elementAt(i)).toString(mode));
            sb.append("]\n");    
        }
        return sb.toString();
    }
}


final class SymTab {

    private Vector<OneScope> tablesHistory;

    private Vector<Integer> tableIndexStack;

    private SymTabMode mode;

    private int nextSavedInHistory;

    SymTab() {
        tablesHistory = new Vector<OneScope>();
        tableIndexStack = new Vector<Integer>();
        mode = SymTabMode.MODE_UNDEFINED;
    }

    void initNewSymTab() {
        tablesHistory.removeAllElements();
        tableIndexStack.removeAllElements();
        mode = SymTabMode.MODE_BUILDING;
    }

    void initSavedSymTab() {
        if (mode != SymTabMode.MODE_BUILDING) {
            System.err.println("Symbol Stack Error: initSavedSymTab. No previous 'building' mode detected.");
            return;
        }
        tableIndexStack.removeAllElements();
        mode = SymTabMode.MODE_REVISITING;
        nextSavedInHistory = 0;
    }

    void pushScope(String s) {
        if (mode == SymTabMode.MODE_BUILDING) {
            // Empila una nueva tabla de simbolos en modo BUILDING:
            // la nueva tabla esta completamente vacia y la informacion
            // que pongamos sera conservada para cuando usemos la pila
            // de tablas en modo REVISITING
            tablesHistory.add(new OneScope(getFullName(s)));
            tableIndexStack.add(tablesHistory.size() - 1);
        } else if (mode == SymTabMode.MODE_REVISITING) {
            // Empila una nueva tabla de simbolos en modo REVISITING:
            // la tabla que llevamos a la cima de la pila es la siguiente
            // del historico de tablas salvadas en modo BUILDING
            if (tablesHistory.isEmpty() || nextSavedInHistory >= tablesHistory.size()) {
                System.err.println("Symbol Stack Error: pushScope. No more saved symbol table.");
                return;
            }
            if (!(s.equals("")) && !(tablesHistory.elementAt(nextSavedInHistory).getScopeName().equals(getFullName(s)))) {
                System.err.println("Symbol Stack Error: pushScope. Error in symbol table scope name (" + s + ").");
                return;
            }
            tableIndexStack.add(nextSavedInHistory);
            nextSavedInHistory++;
        } else {
            System.err.println("Symbol Stack Error: pushScope. Current mode is 'undefined'.");
        }
    }

    void popScope() {
        if (tableIndexStack.isEmpty()) {
            System.err.println("Symbol Stack Error: popScope. Symbol table stack is empty.");
            return;
        }
        if (mode == SymTabMode.MODE_BUILDING) {
            // "Desempila pero salva" una tabla de simbolos en modo BUILDING:
            // la tabla que quitamos de la cima de la pila no es destruida,
            // sino que la guardamos en el 'historial' para cuando usemos
            // la pila de tablas en modo REVISITING
            tableIndexStack.removeElementAt(tableIndexStack.size() - 1);
        } else if (mode == SymTabMode.MODE_REVISITING) {
            // "Desempila y elimina" una tabla de simbolos en modo REVISITING:
            // la tabla que quitamos de la cima de la pila es completamente
            // eliminada
            tablesHistory.setElementAt(null, tableIndexStack.lastElement());
            tableIndexStack.removeElementAt(tableIndexStack.size() - 1);
        } else {
            System.err.println("Symbol Stack Error: pushScope. Current mode is 'undefined'.");
        }
    }

    private void insertSymbol(String s, int l, int c, SymbolClass sc, TypeTree t) {
        if (tableIndexStack.isEmpty()) {
            System.err.println("Symbol Table Error: insertSymbol '" + s + "'. Symbol table stack is empty");
        } else {
            if (tablesHistory.elementAt(tableIndexStack.lastElement()).table.containsKey(s)) {
                System.err.println("Symbol Table Error: insertSymbol '" + s + "'. Already declared in the current scope.");
            } else {
                tablesHistory.elementAt(tableIndexStack.lastElement()).table.put(s, new InfoSym(l, c, sc, t));
                tablesHistory.elementAt(tableIndexStack.lastElement()).orderedSymbols.add(s);
            }
        }
    }

    void insertSymbol(CL_AST id, SymbolClass sc, TypeTree t) {
        insertSymbol(id.getText(), id.getLine(), id.getCharPositionInLine(), sc, t);
    }

    final class search_return extends InfoSym {
        private int levels;

        search_return(InfoSym info, int lev) {
            super(info);
            levels = lev;
        }

        int getLevelsDiff( ) {
            return levels;
        }
    }

    search_return searchSymbol(String s) {
        if (tableIndexStack.isEmpty()) {
            System.err.println("Symbol Table Error: searchSymbol '" + s + "'. Symbol table stack is empty.");
            return null;
        } else {
            int dl = 0;
            for (int i = tableIndexStack.size() - 1; i >= 0; i--) {
                int n = tableIndexStack.elementAt(i);
                if (tablesHistory.elementAt(n).table.containsKey(s)) {
                    return new search_return(tablesHistory.elementAt(n).table.get(s), dl);
                }
                dl++;
            }
            return null;
        }
    }

    search_return searchSymbolCurrScope(String s) {
        if (tableIndexStack.isEmpty()) {
            System.err.println("Symbol Table Error: searchSymbolCurrScope '" + s + "'. Symbol table stack is empty.");
            return null;
        } else {
            int n = tableIndexStack.lastElement();
            if (tablesHistory.elementAt(n).table.containsKey(s)) {
                return new search_return(tablesHistory.elementAt(n).table.get(s), 0);
            }
            return null;
        }
    }

    search_return searchSymbolInScopeLevel(String s, int l) {
        if (l > tableIndexStack.size()) {
            System.err.println("Symbol Table Error: searchSymbolInScopeLevel '" + s + "'. Symbol table stack has only " + tableIndexStack.size() + " levels ('" + l + "' is greater.");
            return null;
        } else {
            int n = tableIndexStack.elementAt(l - 1);
            if (tablesHistory.elementAt(n).table.containsKey(s)) {
                return new search_return(tablesHistory.elementAt(n).table.get(s), tableIndexStack.size() - l);
            }
            return null;
        }
    }

    String getFullPath(String s) {
        if (getStackDepth() > 0) {
            search_return ret = searchSymbol(s);
            if (ret == null) {
                return "";
            }
            int difn = ret.getLevelsDiff();
            int index = tableIndexStack.elementAt(tableIndexStack.size() - 1 - difn);
            return tablesHistory.elementAt(index).getScopeName();
        } else {
            return "";
        }
    }

    String getFullName(String s) {
        String fn;
        if (getStackDepth() > 0) {
            search_return ret = searchSymbol(s);
            if (ret == null) {
                return "";
            }
            int difn = ret.getLevelsDiff();
            int index = tableIndexStack.elementAt(tableIndexStack.size() - 1 - difn);
            if (ret.getClas() == SymbolClass.PROCEDURE ||
                ret.getClas() == SymbolClass.FUNCTION) {
                fn = tablesHistory.elementAt(index).getScopeName() + "_" + s;
            } else {
                fn = tablesHistory.elementAt(index).getScopeName() + ":" + s;
            }
            return fn;
        } else {
            return s;
        }
    }

    // Metodos utilizados en el recorrido ordenado de los simbolos
    // de la tabla que se encuentre en la cima de la pila
    int topSymbolsNumber() {
        if (tableIndexStack.isEmpty()) {
            System.err.println("Symbol Table Error: topSymbolsNumber. Symbol table stack is empty.");
            return -1;
        }
        return tablesHistory.elementAt(tableIndexStack.lastElement()).table.size();
    }

    String getTopSymbolName(int i) {
        if (tableIndexStack.isEmpty()) {
            System.err.println("Symbol Table Error: getTopSymbolName. Symbol table stack is empty.");
            return "";
        }
        if (i < 0 || i >= tablesHistory.elementAt(tableIndexStack.lastElement()).orderedSymbols.size()) {
            System.err.println("Symbol Table Error: getTopSymbolName. Inexistent symbol number '" + i + "'.");
            return "";
        }
        return tablesHistory.elementAt(tableIndexStack.lastElement()).orderedSymbols.elementAt(i);
    }

    InfoSym getTopSymbolInfoPtr(int i) {
        if (tableIndexStack.isEmpty()) {
            System.err.println("Symbol Table Error: getTopSymbolInfoSym. Symbol table stack is empty.");
            return null;
        }
        if (i < 0 || i >= tablesHistory.elementAt(tableIndexStack.lastElement()).orderedSymbols.size()) {
            System.err.println("Symbol Table Error: getTopSymbolInfoSym. inexistent symbol number '" + i + "'.");
            return null;
        }
        String s = tablesHistory.elementAt(tableIndexStack.lastElement()).orderedSymbols.elementAt(i);
        return tablesHistory.elementAt(tableIndexStack.lastElement()).table.get(s);
    }

    int getStackDepth() {
        return tableIndexStack.size();
    }

    public String toString() {
        StringBuffer sb = new StringBuffer();
        sb.append("\n");
        sb.append("---------------- Symbol Table Stack: top -------------------\n");
        for (int i = tableIndexStack.size() - 1; i >= 0; i--) {
            int n = tableIndexStack.elementAt(i);
            sb.append(tablesHistory.elementAt(n).toString(mode));
            if (i > 0) {
                sb.append("--------------------------------------------------------\n");
            }
        }
        sb.append("---------------- Symbol Table Stack: bottom ----------------\n");
        return sb.toString();
    }

}