ContextoCompilacao.java

Go to the documentation of this file.

package plp.orientadaObjetos1.memoria;

import plp.orientadaObjetos1.declaracao.procedimento.ListaDeclaracaoParametro;
import plp.orientadaObjetos1.excecao.declaracao.ClasseJaDeclaradaException;
import plp.orientadaObjetos1.excecao.declaracao.ClasseNaoDeclaradaException;
import plp.orientadaObjetos1.excecao.declaracao.ProcedimentoJaDeclaradoException;
import plp.orientadaObjetos1.excecao.declaracao.ProcedimentoNaoDeclaradoException;
import plp.orientadaObjetos1.excecao.declaracao.VariavelJaDeclaradaException;
import plp.orientadaObjetos1.excecao.declaracao.VariavelNaoDeclaradaException;
import plp.orientadaObjetos1.expressao.leftExpression.Id;
import plp.orientadaObjetos1.memoria.colecao.HashIdDefClasse;
import plp.orientadaObjetos1.memoria.colecao.HashIdListaDeclaracaoParametro;
import plp.orientadaObjetos1.memoria.colecao.HashIdTipo;
import plp.orientadaObjetos1.memoria.colecao.HashTipoTipo;
import plp.orientadaObjetos1.memoria.colecao.ListaValor;
import plp.orientadaObjetos1.memoria.colecao.StackHashIdDefClasse;
import plp.orientadaObjetos1.memoria.colecao.StackHashIdListaDeclaracaoParametro;
import plp.orientadaObjetos1.memoria.colecao.StackHashIdTipo;
import plp.orientadaObjetos1.memoria.colecao.StackHashTipoTipo;
import plp.orientadaObjetos1.util.Tipo;
public class ContextoCompilacao implements AmbienteCompilacao {

    private StackHashIdTipo pilha;

    private StackHashTipoTipo pilhaTipoReal;

    private StackHashIdListaDeclaracaoParametro pilhaProcedimento;


    private StackHashIdDefClasse pilhaDefClasse;

    private StackHashIdTipo pilhaGeneric;
    
    private ListaValor entrada;

    public ContextoCompilacao(ListaValor entrada){
        pilha = new StackHashIdTipo();
        pilhaTipoReal = new StackHashTipoTipo();
        
        pilhaGeneric = new StackHashIdTipo();
        pilhaProcedimento = new StackHashIdListaDeclaracaoParametro();
        
        pilhaDefClasse = new StackHashIdDefClasse();    // esta pilha nao cresce
        pilhaDefClasse.push(new HashIdDefClasse());     // tem de incrementar no começo
        this.entrada = entrada;
    }

    public void incrementa(){
        pilha.push(new HashIdTipo());
        pilhaProcedimento.push(new HashIdListaDeclaracaoParametro());
        pilhaGeneric.push(new HashIdTipo());
        pilhaTipoReal.push(new HashTipoTipo());        
        //pilhaDefClasse.push(new HashIdDefClasse());   // so incrementa no comeco (vide construtor)
    }

    public void restaura(){
        pilha.pop();
        pilhaProcedimento.pop();
        pilhaGeneric.pop();
        pilhaTipoReal.pop();        
        //pilhaDefClasse.pop();                         // nao restaura
    }
    public void mapTipo(Id idArg, Tipo tipoId)
        throws VariavelJaDeclaradaException {
        HashIdTipo aux = (HashIdTipo) pilha.peek();
        if (aux.put(idArg, tipoId) != null) {
            throw new VariavelJaDeclaradaException(idArg);
        }
    }

    public void mapGeneric(Id idArg, Tipo tipoId) throws ClasseJaDeclaradaException {
        HashIdTipo aux = (HashIdTipo) pilhaGeneric.peek();
        if (aux.put(idArg, tipoId) != null) {
            throw new ClasseJaDeclaradaException(idArg);
        }
    }

    public void mapParametrosProcedimento(Id idArg, ListaDeclaracaoParametro parametrosId)
        throws ProcedimentoJaDeclaradoException {
        HashIdListaDeclaracaoParametro aux = (HashIdListaDeclaracaoParametro) pilhaProcedimento.peek();
        if (aux.put(idArg, parametrosId) != null) {
            throw new ProcedimentoJaDeclaradoException(idArg);
        }
    }

    public void mapDefClasse(Id idArg, DefClasse defClasse)
        throws ClasseJaDeclaradaException {
        HashIdDefClasse aux = (HashIdDefClasse) pilhaDefClasse.peek();
        if (aux.put(idArg, defClasse) != null) {
            throw new ClasseJaDeclaradaException(idArg);
        }
    }

    public void mapTipoReal(Tipo tipoGeneric, Tipo tipoReal)
        throws ClasseJaDeclaradaException {
        HashTipoTipo aux = pilhaTipoReal.peek();
        if (aux.put(tipoGeneric, tipoReal) != null) {
            throw new ClasseJaDeclaradaException(tipoGeneric.getTipo());
        }
    }
    
    public Tipo getTipo(Id idArg)
        throws VariavelNaoDeclaradaException {
        Tipo result = null;
        StackHashIdTipo auxStack = new StackHashIdTipo();
        while (result == null && !pilha.empty()) {
            HashIdTipo aux = pilha.pop();
            auxStack.push(aux);
            result = aux.get(idArg);
        }
        while (!auxStack.empty()) {
            pilha.push(auxStack.pop());
        }
        if (result == null) {
            throw new VariavelNaoDeclaradaException(idArg);
        } else {
            return result;
        }
    }

    public ListaDeclaracaoParametro getParametrosProcedimento(Id idArg)
        throws ProcedimentoNaoDeclaradoException  {
        ListaDeclaracaoParametro result = null;
        StackHashIdListaDeclaracaoParametro auxStack = new StackHashIdListaDeclaracaoParametro();
        while (result == null && !pilhaProcedimento.empty()) {
            HashIdListaDeclaracaoParametro aux = pilhaProcedimento.pop();
            auxStack.push(aux);
            result = aux.get(idArg);
        }
        while (!auxStack.empty()) {
            pilhaProcedimento.push(auxStack.pop());
        }
        if (result == null) {
            throw new ProcedimentoNaoDeclaradoException(idArg);
        } else {
            return result;
        }
    }

    public DefClasse getDefClasse(Id idArg)
        throws ClasseNaoDeclaradaException  {
        DefClasse result = null;
        StackHashIdDefClasse auxStack = new StackHashIdDefClasse();
        while (result == null && !pilhaDefClasse.empty()) {
            HashIdDefClasse aux = pilhaDefClasse.pop();
            auxStack.push(aux);
            result = aux.get(idArg);
        }
        while (!auxStack.empty()) {
            pilhaDefClasse.push(auxStack.pop());
        }
        if (result == null) {
            throw new ClasseNaoDeclaradaException(idArg);
        } else {
            return result;
        }
    }

    public Tipo getTipoReal( Tipo tipoGeneric)
        throws ClasseNaoDeclaradaException {
        Tipo result = null;
        StackHashTipoTipo auxStack = new StackHashTipoTipo();
        while (result == null && !pilhaTipoReal.empty()) {
            HashTipoTipo aux = pilhaTipoReal.pop();
            auxStack.push(aux);
            result = aux.get(tipoGeneric);
        }
        while (!auxStack.empty()) {
            pilhaTipoReal.push(auxStack.pop());
        }
        if (result == null) {
            throw new ClasseNaoDeclaradaException(tipoGeneric.getTipo());
        } else {
            return result;
        }
    }
    

    public Tipo getGeneric(Id idArg)
        throws ClasseNaoDeclaradaException {
        Tipo result = null;
        StackHashIdTipo auxStack = new StackHashIdTipo();
        while (result == null && !pilhaGeneric.empty()) {
            HashIdTipo aux = pilhaGeneric.pop();
            auxStack.push(aux);
            result = aux.get(idArg);
        }
        while (!auxStack.empty()) {
            pilhaGeneric.push(auxStack.pop());
        }
        if (result == null) {
            throw new ClasseNaoDeclaradaException(idArg);
        } else {
            return result;
        }
    }

    public Tipo getTipoEntrada()
        throws VariavelNaoDeclaradaException {
        Tipo aux =  entrada.head().getTipo(this);
        entrada = entrada.tail();
        return aux;
    }

    public StackHashTipoTipo getPilhaTipoTipo(){
       return this.pilhaTipoReal;
    }
    
    
}

---