ContextoExecucao.java

Go to the documentation of this file.

package plp.orientadaObjetos1.memoria;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Enumeration;

import plp.orientadaObjetos1.excecao.declaracao.ClasseJaDeclaradaException;
import plp.orientadaObjetos1.excecao.declaracao.ClasseNaoDeclaradaException;
import plp.orientadaObjetos1.excecao.declaracao.ObjetoJaDeclaradoException;
import plp.orientadaObjetos1.excecao.declaracao.ObjetoNaoDeclaradoException;
import plp.orientadaObjetos1.excecao.declaracao.VariavelJaDeclaradaException;
import plp.orientadaObjetos1.excecao.declaracao.VariavelNaoDeclaradaException;
import plp.orientadaObjetos1.excecao.execucao.EntradaInvalidaException;
import plp.orientadaObjetos1.expressao.leftExpression.Id;
import plp.orientadaObjetos1.expressao.valor.Valor;
import plp.orientadaObjetos1.expressao.valor.ValorBooleano;
import plp.orientadaObjetos1.expressao.valor.ValorInteiro;
import plp.orientadaObjetos1.expressao.valor.ValorNull;
import plp.orientadaObjetos1.expressao.valor.ValorRef;
import plp.orientadaObjetos1.expressao.valor.ValorString;
import plp.orientadaObjetos1.memoria.colecao.HashIdDefClasse;
import plp.orientadaObjetos1.memoria.colecao.HashIdValor;
import plp.orientadaObjetos1.memoria.colecao.HashTipoTipo;
import plp.orientadaObjetos1.memoria.colecao.HashValorObjeto;
import plp.orientadaObjetos1.memoria.colecao.ListaValor;
import plp.orientadaObjetos1.memoria.colecao.StackHashIdDefClasse;
import plp.orientadaObjetos1.memoria.colecao.StackHashIdValor;
import plp.orientadaObjetos1.memoria.colecao.StackHashTipoTipo;
import plp.orientadaObjetos1.memoria.colecao.StackHashValorObjeto;
import plp.orientadaObjetos1.util.Tipo;
import plp.orientadaObjetos1.util.TipoPrimitivo;

public class ContextoExecucao implements AmbienteExecucao {

    private StackHashIdValor pilha;

    private StackHashTipoTipo pilhaTipoReal;
    
    private StackHashIdDefClasse pilhaDefClasse;

    private StackHashValorObjeto pilhaObjeto;

    private ListaValor entrada;

    private ListaValor saida;

    private ValorRef proxRef;

    public ContextoExecucao(){
        pilha = new StackHashIdValor();
        pilhaTipoReal = new StackHashTipoTipo();

        pilhaObjeto = new StackHashValorObjeto();       // esta pilha nao cresce
        pilhaObjeto.push(new HashValorObjeto());        // tem de incrementar no começo

        pilhaDefClasse = new StackHashIdDefClasse();    // esta pilha nao cresce
        pilhaDefClasse.push(new HashIdDefClasse());     // tem de incrementar no começo

        this.entrada = null;
        this.saida = new ListaValor();
    }

    public ContextoExecucao(AmbienteExecucao ambiente) throws VariavelJaDeclaradaException{
        this.proxRef = ambiente.getRef();
        this.pilhaObjeto = ambiente.getPilhaObjeto();
       this.pilhaDefClasse = ambiente.getPilhaDefClasse();
       this.entrada = ambiente.getEntrada();
       this.saida = ambiente.getSaida();
       pilhaTipoReal = ambiente.getPilhaTipoTipo();
       pilha = new StackHashIdValor();
       HashIdValor aux = new HashIdValor();
       aux.put(new Id("this"), new ValorNull());
       pilha.push(aux);

  }

    public ContextoExecucao(ListaValor entrada){
        pilha = new StackHashIdValor();
        pilhaTipoReal = new StackHashTipoTipo();

        pilhaObjeto = new StackHashValorObjeto();       // esta pilha nao cresce
        pilhaObjeto.push(new HashValorObjeto());        // tem de incrementar no começo

        pilhaDefClasse = new StackHashIdDefClasse();    // esta pilha nao cresce
        pilhaDefClasse.push(new HashIdDefClasse());     // tem de incrementar no começo

        this.entrada = entrada;
        this.saida = new ListaValor();
    }

    public StackHashIdValor getPilha(){
       return this.pilha;
    }

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

    public StackHashIdDefClasse getPilhaDefClasse(){
       return this.pilhaDefClasse;
    }

    public StackHashValorObjeto getPilhaObjeto(){
       return this.pilhaObjeto;
    }

    public Valor read(Tipo tipoIdLido) throws EntradaInvalidaException {
      String valorLido = leEntrada(tipoIdLido);
      if (valorLido!=null){
        valorLido = valorLido.trim();
        if (tipoIdLido instanceof TipoPrimitivo){
            TipoPrimitivo tipo = (TipoPrimitivo) tipoIdLido;
            try {
              if (tipo.eBooleano()){
                  return new ValorBooleano(Boolean.getBoolean(valorLido));
              } else if (tipo.eInteiro()){
                  return new ValorInteiro(Integer.parseInt(valorLido));
              } else if (tipo.eString()){
                  return new ValorString(valorLido);
              }
            }
            catch(NumberFormatException e){
              throw new EntradaInvalidaException("O tipo da entrada e o da variável"+
                                                 " a ser lida são diferentes!");
            }
        }
      }
      throw new EntradaInvalidaException("O tipo da variável a ser lida não é um tipo Primitivo!");
    }

    private String leEntrada(Tipo tipoIdLido) throws EntradaInvalidaException{
      if(this.entrada==null) {
        return leDaEntradaPadrao(tipoIdLido);
      } else {
        // Se nao tivermos mais nada na lista de valores
        if(entrada.length()==0) {
          throw new EntradaInvalidaException("Número de argumentos menor do que o número de reads!");
        }
        return leDaListaValor();
      }
    }
    private String leDaEntradaPadrao(Tipo tipoIdLido){
      try {
        System.out.println("Digite um " +tipoIdLido.toString());
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        return in.readLine();
      }
      catch (IOException e){
         System.out.println("Erro no valor lido da entrada padrão");
      }
      return "";
    }

    private String leDaListaValor(){
      String retorno = entrada.head().toString();
      entrada = entrada.tail();
      return retorno;
    }

    public ListaValor getSaida() {
        return saida;
    }

    public ListaValor getEntrada(){
        return entrada;
    }

    public AmbienteExecucao write(Valor v){
        saida.write(v);
        return this;
    }
    public void incrementa() {
        pilha.push(new HashIdValor());
        pilhaTipoReal.push(new HashTipoTipo());
        //pilhaDefClasse.push(new HashIdDefClasse());   // só incrementa no construtor
        //pilhaObjeto.push(new HashValorObjeto());      // só incrementa no construtor
    }

    public void restaura(){
        pilha.pop();
        pilhaTipoReal.pop();
        //pilhaDefClasse.pop();                         // não restaura
        //pilhaObjeto.pop();                            // não restaura
    }

    public void mapValor(Id idArg, Valor valorId)
        throws VariavelJaDeclaradaException {
        HashIdValor aux = pilha.peek();
        if (aux.put(idArg, valorId) != null) {
            throw new VariavelJaDeclaradaException(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 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 mapObjeto(ValorRef valorRef, Objeto objeto)
        throws ObjetoJaDeclaradoException {
        HashValorObjeto aux = pilhaObjeto.peek();
        if (aux.put(valorRef, objeto) != null) {
            throw new ObjetoJaDeclaradoException(objeto.getClasse());
        }
    }

    public void changeValor(Id idArg, Valor valorId)
        throws VariavelNaoDeclaradaException {
        Valor result = null;
        StackHashIdValor auxStack = new StackHashIdValor();
        while (result == null && !pilha.empty()) {
            HashIdValor aux = pilha.pop();
            auxStack.push(aux);
            result = aux.get(idArg);
            if(result != null) {
                aux.change(idArg, valorId);
                break;
            }
        }
        while (!auxStack.empty()) {
            pilha.push(auxStack.pop());
        }
        if (result == null) {
            throw new VariavelNaoDeclaradaException(idArg);
        }
    }

    public Valor getValor( Id idArg )
        throws VariavelNaoDeclaradaException {
        Valor result = null;
        StackHashIdValor auxStack = new StackHashIdValor();
        while (result == null && !pilha.empty()) {
            HashIdValor 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 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 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 Objeto getObjeto(ValorRef valorRef)
        throws ObjetoNaoDeclaradoException {
        Objeto result = null;
        StackHashValorObjeto auxStack = new StackHashValorObjeto();
        while (result == null && !pilhaObjeto.empty()) {
            HashValorObjeto aux = pilhaObjeto.pop();
            auxStack.push(aux);
            result = aux.get(valorRef);
        }
        while (!auxStack.empty()) {
            pilhaObjeto.push(auxStack.pop());
        }
        if (result == null) {
            throw new ObjetoNaoDeclaradoException(new Id(valorRef.toString()));
        } else {
            return result;
        }
    }

    public ValorRef getProxRef() {
        ValorRef aux = new ValorRef(proxRef.valor());
        proxRef = proxRef.incrementa();
        return aux;
    }

    public ValorRef getRef() {
        if (proxRef == null)
            proxRef = new ValorRef(proxRef.VALOR_INICIAL);
          return proxRef;
    }

    public String toString() {
        String resposta = null;
        Valor valor = null;
        ValorRef valorRef = null;
        Objeto objeto = null;
        Id id = null;
        StackHashIdValor auxStack = new StackHashIdValor();
        StackHashValorObjeto auxStackObjeto = new StackHashValorObjeto();

        while (!pilha.empty()) {
            HashIdValor aux = pilha.pop();
            auxStack.push(aux);
            Enumeration enumeration = aux.keys();
            while(enumeration.hasMoreElements()) {
                id = (Id)enumeration.nextElement();
                  valor = aux.get(id);
                resposta = id + " " + valor + "\n";
            }
        }
        while (!auxStack.empty()) {
            pilha.push(auxStack.pop());
        }
        while (!pilhaObjeto.empty()) {
            HashValorObjeto aux = pilhaObjeto.pop();
            auxStackObjeto.push(aux);
            Enumeration enumeration = aux.keys();
            while(enumeration.hasMoreElements()) {
                valorRef = (ValorRef)enumeration.nextElement();
                  objeto = aux.get(valorRef);
                resposta = valorRef + " " + objeto + "\n";
            }
        }
        while (!auxStackObjeto.empty()) {
            pilhaObjeto.push(auxStackObjeto.pop());
        }
        return resposta;
    }

    public ContextoExecucao getContextoIdValor() {
        ContextoExecucao ambiente = new ContextoExecucao(this.getEntrada());
        ambiente.pilha = this.pilha;
        ambiente.saida = this.saida;
        return ambiente;
    }
}

---