ContextoExecucaoOO1.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.HashMap;
import java.util.Stack;

import plp.expressions2.expression.Id;
import plp.expressions2.memory.VariavelJaDeclaradaException;
import plp.expressions2.memory.VariavelNaoDeclaradaException;
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.execucao.EntradaInvalidaException;
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.ListaValor;
import plp.orientadaObjetos1.util.Tipo;
import plp.orientadaObjetos1.util.TipoPrimitivo;

public class ContextoExecucaoOO1 implements AmbienteExecucaoOO1 {

    private Stack<HashMap<Id, Valor>> pilha;

    private HashMap<Id, DefClasse> mapDefClasse;

    private Stack<HashMap<ValorRef, Objeto>> pilhaObjeto;

    private ListaValor entrada;

    private ListaValor saida;

    private ValorRef proxRef;

    public ContextoExecucaoOO1(){
        pilha = new Stack<HashMap<Id, Valor>>();

        pilhaObjeto = new Stack<HashMap<ValorRef, Objeto>>();       // esta
                                                                                                                                        // pilha nao
                                                                                                                                        // cresce
        pilhaObjeto.push(new HashMap<ValorRef, Objeto>());        // tem de
                                                                                                                                        // incrementar
                                                                                                                                        // no começo

        mapDefClasse = new HashMap<Id, DefClasse>();    // criacao do mapeamento de classes
        
        this.entrada = null;
        this.saida = new ListaValor();
    }

    public ContextoExecucaoOO1(AmbienteExecucaoOO1 ambiente) throws VariavelJaDeclaradaException{
       proxRef = ambiente.getRef();
       this.pilhaObjeto = ambiente.getPilhaObjeto();
       this.mapDefClasse = ambiente.getMapDefClasse();
       this.entrada = ambiente.getEntrada();
       this.saida = ambiente.getSaida();
       pilha = new Stack<HashMap<Id, Valor>>();
           HashMap<Id, Valor> aux = new HashMap<Id, Valor>();
       aux.put(new Id("this"), new ValorNull());
       pilha.push(aux);

  }

    public ContextoExecucaoOO1(ListaValor entrada){
        pilha = new Stack<HashMap<Id, Valor>>();

        pilhaObjeto = new Stack<HashMap<ValorRef, Objeto>>();       // esta
                                                                                                                                        // pilha nao
                                                                                                                                        // cresce
        pilhaObjeto.push(new HashMap<ValorRef, Objeto>());        // tem de
                                                                                                                                        // incrementar
                                                                                                                                        // no começo

        mapDefClasse = new HashMap<Id, DefClasse>();    // inicializacao do map
        
        this.entrada = entrada;
        this.saida = new ListaValor();
    }

    public Stack<HashMap<Id, Valor>> getPilha(){
       return this.pilha;
    }

    public HashMap<Id, DefClasse> getMapDefClasse(){
       return this.mapDefClasse;
    }

    public Stack<HashMap<ValorRef, Objeto>> getPilhaObjeto(){
       return this.pilhaObjeto;
    }

    public Valor read(Tipo tipoIdLido) throws EntradaInvalidaException {
      String valorLido = leEntrada();
      if (valorLido!=null){
        valorLido = valorLido.trim();
        if (tipoIdLido instanceof TipoPrimitivo){
            TipoPrimitivo tipo = (TipoPrimitivo) tipoIdLido;
            try {
              if (tipo.eBooleano()){
                  return new ValorBooleano(Boolean.parseBoolean(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() throws EntradaInvalidaException{
      if(this.entrada==null) {
        return leDaEntradaPadrao();
      } else {
        // Se nao tivermos mais nada na tail 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(){
      try {
        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.getHead().toString();
      entrada = (ListaValor)entrada.getTail();
      return retorno;
    }

    public ListaValor getSaida() {
        return saida;
    }

    public ListaValor getEntrada(){
        return entrada;
    }

    public AmbienteExecucaoOO1 write(Valor v){
        saida.write(v);
        return this;
    }
    public void incrementa() {
        pilha.push(new HashMap<Id, Valor>());
        // pilhaDefClasse.push(new HashIdDefClasse()); // só incrementa no
                // construtor
        // pilhaObjeto.push(new HashValorObjeto()); // só incrementa no
                // construtor
    }

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

    public void map(Id idArg, Valor valorId)
        throws VariavelJaDeclaradaException {
                HashMap<Id, Valor> aux = pilha.peek();
        if (aux.put(idArg, valorId) != null) {
            throw new VariavelJaDeclaradaException(idArg);
        }

    }

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

     public void mapObjeto(ValorRef valorRef, Objeto objeto)
        throws ObjetoJaDeclaradoException {
                 HashMap<ValorRef, Objeto> 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;
        Stack<HashMap<Id, Valor>> auxStack = new Stack<HashMap<Id, Valor>>();
        while (result == null && !pilha.empty()) {
                        HashMap<Id, Valor> aux = pilha.pop();
            auxStack.push(aux);
            result = aux.get(idArg);
            if(result != null) {
                aux.put(idArg, valorId);
                break;
            }
        }
        while (!auxStack.empty()) {
            pilha.push(auxStack.pop());
        }
        if (result == null) {
            throw new VariavelNaoDeclaradaException(idArg);
        }
    }

    public Valor get( Id idArg )
        throws VariavelNaoDeclaradaException {
        Valor result = null;
        Stack<HashMap<Id, Valor>> auxStack = new Stack<HashMap<Id, Valor>>();
        while (result == null && !pilha.empty()) {
            HashMap<Id, Valor> 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 DefClasse getDefClasse(Id idArg)
        throws ClasseNaoDeclaradaException  {
        DefClasse result = null;
        result = this.mapDefClasse.get(idArg);
        return result;
    }

    public Objeto getObjeto(ValorRef valorRef)
        throws ObjetoNaoDeclaradoException {
        Objeto result = null;
        Stack<HashMap<ValorRef, Objeto>> auxStack = new Stack<HashMap<ValorRef, Objeto>>();
        while (result == null && !pilhaObjeto.empty()) {
                        HashMap<ValorRef, Objeto> 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(ValorRef.VALOR_INICIAL);
          return proxRef;
    }

    public String toString() {
        String resposta = null;
        Valor valor = null;
        Objeto objeto = null;
        Stack<HashMap<Id, Valor>> auxStack = new Stack<HashMap<Id, Valor>>();
        Stack<HashMap<ValorRef, Objeto>> auxStackObjeto = new Stack<HashMap<ValorRef, Objeto>>();

        while (!pilha.empty()) {
                        HashMap<Id, Valor> aux = pilha.pop();
            auxStack.push(aux);
                        for (Id id : aux.keySet()) {
                valor = aux.get(id);
                resposta = id + " " + valor + "\n";
            }
        }
        while (!auxStack.empty()) {
            pilha.push(auxStack.pop());
        }
        while (!pilhaObjeto.empty()) {
                        HashMap<ValorRef, Objeto> aux = pilhaObjeto.pop();
            auxStackObjeto.push(aux);
            for(ValorRef valorRef : aux.keySet()) {
                objeto = aux.get(valorRef);
                resposta = valorRef + " " + objeto + "\n";
            }
        }
        while (!auxStackObjeto.empty()) {
            pilhaObjeto.push(auxStackObjeto.pop());
        }
        return resposta;
    }

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

}

---