Aplicacao.java

Vá para a documentação deste arquivo.

package plp.functional3.expression;

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

import java.util.ArrayList;
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.VariavelJaDeclaradaException;
import plp.expressions2.memory.VariavelNaoDeclaradaException;
import plp.functional1.util.DefFuncao;
import plp.functional1.util.TipoFuncao;
import plp.functional1.util.TipoPolimorfico;
import plp.functional2.expression.ValorFuncao;

public class Aplicacao implements Expressao {

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

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

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

        public Valor avaliar(AmbienteExecucao ambiente)
                        throws VariavelNaoDeclaradaException, VariavelJaDeclaradaException {

                ValorFuncao funcao = (ValorFuncao) func.avaliar(ambiente);

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

                ambiente.incrementa();

                includeValueBindings(ambiente, mapIdValor);

                Expressao exp = funcao.getExp();
                Valor vresult = exp.avaliar(ambiente);

                ambiente.restaura();
                return vresult;
        }

        public boolean checaTipo(AmbienteCompilacao ambiente)
                        throws VariavelNaoDeclaradaException, VariavelJaDeclaradaException {
                Tipo tipo = getFuncType(ambiente);

                boolean result;

                TipoFuncao tipoFuncao = (TipoFuncao) tipo;
                result = tipoFuncao.checaTipo(ambiente, argsExpressao);

                return result;
        }

        private Tipo getFuncType(AmbienteCompilacao ambiente) {
                Tipo tipoFuncao = null;
                if (func instanceof Id) {
                        tipoFuncao = ambiente.get((Id) func);
                } else if (func instanceof ValorFuncao) {
                        tipoFuncao = ((ValorFuncao) func).getTipo(ambiente);
                }

                if (tipoFuncao == null || tipoFuncao instanceof TipoPolimorfico) {
                        ArrayList<Tipo> params = new ArrayList<Tipo>();
                        for (Expressao valorReal : argsExpressao) {
                                params.add(valorReal.getTipo(ambiente));
                        }
                        tipoFuncao = new TipoFuncao(params, new TipoPolimorfico());
                }
                return tipoFuncao;
        }

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

        public Expressao getFunc() {
                return func;
        }

        public Tipo getTipo(AmbienteCompilacao ambiente)
                        throws VariavelNaoDeclaradaException, VariavelJaDeclaradaException {

                Tipo tipo = getFuncType(ambiente);

                TipoFuncao tipoFuncao = (TipoFuncao) tipo;

                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) {
                        
                        if (id instanceof VarargsId){
                                //cria uma nova lista
                        ValorLista valorLista = ValorLista.getInstancia(null, null);
                        
                        while (iterExpressoesValor.hasNext()) {
                                valorLista = valorLista.cons(iterExpressoesValor.next().avaliar(ambiente));                             
                        }
                        
                        //pega o última parâmetro para ser o identificador do varargs
                        // A construção 'new Id(id.getIdName())' porque no momento da 
                        // avaliação, o valorLista não estava conseguindo ser obetido
                        // do map.
                        mapIdValor.put(new Id(id.getIdName()), valorLista.inverter());
                        } else {
                                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, ","));
        }
}

---