Aplicacao.java

Vá para a documentação deste arquivo.

//Mudar o for do iterator para o novo for.
package plp.functional1.expression;

import static java.util.Arrays.asList;
import static plp.expressions1.util.ToStringProvider.listToString;

import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import plp.expressions1.util.Tipo;
import plp.expressions2.expression.Expressao;
import plp.expressions2.expression.Id;
import plp.expressions2.expression.Valor;
import plp.expressions2.memory.AmbienteCompilacao;
import plp.expressions2.memory.AmbienteExecucao;
import plp.expressions2.memory.IdentificadorNaoDeclaradoException;
import plp.expressions2.memory.VariavelJaDeclaradaException;
import plp.expressions2.memory.VariavelNaoDeclaradaException;
import plp.functional1.memory.AmbienteExecucaoFuncional;
import plp.functional1.util.DefFuncao;
import plp.functional1.util.TipoFuncao;

public class Aplicacao implements Expressao {

        private Id func;
        private List<? extends Expressao> argsExpressao;

        public Aplicacao(Id f, Expressao... expressoes) {
                this(f, asList(expressoes));
        }

        public Aplicacao(Id f, List<? extends Expressao> expressoes) {
                func = f;
                argsExpressao = expressoes;
        }

        public Valor avaliar(AmbienteExecucao ambiente)
                        throws VariavelNaoDeclaradaException, VariavelJaDeclaradaException {
                AmbienteExecucaoFuncional ambienteFuncional = (AmbienteExecucaoFuncional) ambiente;

                DefFuncao funcao;
                try {
                        funcao = ambienteFuncional.getFuncao(func);
                } catch (IdentificadorNaoDeclaradoException e) {
                        throw new VariavelJaDeclaradaException(func);
                }

                Map<Id, Valor> mapIdValor = resolveParametersBindings(ambiente, funcao);

                ambiente.incrementa();

                includeValueBindings(ambiente, mapIdValor);

                Valor vresult = funcao.getExp().avaliar(ambiente);
                ambiente.restaura();
                return vresult;
        }

        public boolean checaTipo(AmbienteCompilacao ambiente)
                        throws VariavelNaoDeclaradaException, VariavelJaDeclaradaException {
                boolean result;
                Tipo aux = ambiente.get(func);

                if (aux instanceof TipoFuncao) {
                        TipoFuncao tipoFuncao = (TipoFuncao) aux;

                        result = tipoFuncao.checaTipo(ambiente, argsExpressao);
                } else {
                        // A função func não foi declarada.

                        // TODO: lançar uma exceção ou separar variáveis de funções no
                        // contexto de compilação.

                        result = false;
                }
                return result;
        }

        public List<? extends Expressao> getArgsExpressao() {
                return argsExpressao;
        }

        public Id getFunc() {
                return func;
        }

        public Tipo getTipo(AmbienteCompilacao ambiente)
                        throws VariavelNaoDeclaradaException, VariavelJaDeclaradaException {
                TipoFuncao tipoFuncao = (TipoFuncao) ambiente.get(func);
                return tipoFuncao.getTipo(ambiente, argsExpressao);
        }

        private void includeValueBindings(AmbienteExecucao ambiente,
                        Map<Id, Valor> mapIdValor) throws VariavelJaDeclaradaException {
                for (Map.Entry<Id, Valor> mapeamento : mapIdValor.entrySet()) {
                        Id id = mapeamento.getKey();
                        Valor valor = mapeamento.getValue();
                        ambiente.map(id, valor);
                }
        }

        private Map<Id, Valor> resolveParametersBindings(AmbienteExecucao ambiente,
                        DefFuncao funcao) throws VariavelNaoDeclaradaException,
                        VariavelJaDeclaradaException {
                List<Id> parametrosId = funcao.getListaId();
                List<? extends Expressao> expressoesValorReal = argsExpressao;

                Map<Id, Valor> mapIdValor = new HashMap<Id, Valor>();

                Iterator<? extends Expressao> iterExpressoesValor = expressoesValorReal
                                .iterator();
                for (Id id : parametrosId) {
                        Expressao exp = iterExpressoesValor.next();
                        Valor valorReal = exp.avaliar(ambiente);
                        mapIdValor.put(id, valorReal);
                }
                return mapIdValor;
        }

        @Override
        public String toString() {
                return String.format("%s(%s)", func, listToString(argsExpressao, ","));
        }

}

---