ExpLoader

package br.cefetmg.inf.cefetiny.interpretador.expressao;

import java.util.Stack;

import br.cefetmg.inf.cefetiny.excecoes.ErroSintatico;
import br.cefetmg.inf.cefetiny.interpretador.Interpretador;
import br.cefetmg.inf.cefetiny.interpretador.Simbolo;
import br.cefetmg.inf.cefetiny.interpretador.Constantes;

public class ExpLoader {

    private Interpretador parser = null;        // pilha de expressoes
    private Stack<Expressao> expStack;  // pilha de expressoes
    private Simbolo simboloAtual;           // ultimo simbolo lido

    public ExpLoader(Interpretador p) {
        this.parser = p;
    }

    public Expressao load() {
        this.expStack = new Stack<>();
        this.simboloAtual = parser.obterSimbolo();
        Expressao exp = start();
        parser.ungetSimbol();
        return exp;
    }

    private Expressao start() {
        addop();            // avalie o operador de adicao
        // enquanto operador relacional
        while (simboloAtual.getToken() == Constantes.RELOP) {
            // obtenha o operador
            String op = simboloAtual.getLexema();

            // obtenha o proximo operando ou '('
            simboloAtual = parser.obterSimbolo();
            // avalie os operadores de maior prioridade
            addop();

            // obtenha a ultima expressao
            Expressao e2 = (Expressao) expStack.pop();
            // obtenha a penultima expressao
            Expressao e1 = (Expressao) expStack.pop();

            // crie expressao logica
            expStack.push(new ExpLogica(e1, op, e2));
        } // fim while

        return (Expressao) expStack.pop();
    }

    // para avaliar os operadores do tipo 'ADDOP'
    private void addop() {
        mulop();            //
        // enquanto operadores ADDOP
        while (simboloAtual.getToken() == Constantes.ADDOP) {
            // obtenha o operador
            String op = simboloAtual.getLexema();
            // obtenha o proximo operando ou '('
            simboloAtual = parser.obterSimbolo();
            mulop();    // avalie os operadores de maior prioridade
            // obtenha a ultima expressao
            Expressao e2 = (Expressao) expStack.pop();
            // obtenha a penultima expressao
            Expressao e1 = (Expressao) expStack.pop();

            // se for operador logico
            if (op.equals("or")) // crie expressao logica
                expStack.push(new ExpLogica(e1, op, e2));
            else // senao
            // crie expressao binaria
                expStack.push(new ExpBinaria(e1, op, e2));
        } // fim while
    }

    // para avaliar os operadores do tipo 'MULOP'
    private void mulop() {
        fator();        // avalie a palavra lida
        // enquanto operadores MULOP
        while (simboloAtual.getToken() == Constantes.MULOP) {
            // obtenha o operador
            String op = simboloAtual.getLexema();
            // obtenha o proximo operando '('
            simboloAtual = parser.obterSimbolo();
            fator();    // avalie o fator lido
            // obtenha a ultima expressao
            Expressao e2 = (Expressao) expStack.pop();
            // obtenha a penultima expressao
            Expressao e1 = (Expressao) expStack.pop();

            // se for operador logico
            if (op.equals("and")) // crie expressao logica
            {
                expStack.push(new ExpLogica(e1, op, e2));
            } else // senao
            // crie expressao binaria
            {
                expStack.push(new ExpBinaria(e1, op, e2));
            }
        } // fim while
    }

    // para avaliar os fatores da expressao
    private void fator() {
        // verifique o fator lido
        switch (simboloAtual.getToken()) {
            case Constantes.T_IDENTIFIER:       // se variavel
                // empilhe expressao variavel
                expStack.push(new ExpVariavel(simboloAtual.getLexema()));
                break;
            case Constantes.T_CONSTANT:     // se constante
                // empilhe expressao constante
                expStack.push(new ExpConstante(simboloAtual.getTipo(), simboloAtual.getLexema()));
                break;
            case Constantes.ABREPAR:        // se abre parentese
                // obtenha o proximo simbolo
                simboloAtual = parser.obterSimbolo();
                expStack.push(start());     // inicie nova expressao
                // se o simbolo apos a expressao nao for um fechamento de parentese
                if (simboloAtual.getToken() != Constantes.FECHAPAR) // ative uma excecao de erro sintatico
                    throw new ErroSintatico("Era esperado ')'");

                break;
            case Constantes.UNOP:        // se for sqrt ou not
                // obtenha o comando
                String cmd = simboloAtual.getLexema();
                // obtenha o proximo simbolo
                simboloAtual = parser.obterSimbolo();
                // se o simbolo atual nao for abertura de parentese
                if (simboloAtual.getToken() != Constantes.ABREPAR) // ative uma excecao de erro sintatico
                    throw new ErroSintatico("Era esperado um '(' na linha " + parser.getLineNumber());

                // obtenha o proximo simbolo
                simboloAtual = parser.obterSimbolo();
                // analise a expressao desse comando
                expStack.push(start());
                // se o simbolo apos a expressao nao for um fechamento de parentese
                if (simboloAtual.getToken() != Constantes.FECHAPAR) // ative uma excecao de erro sintatico
                    throw new ErroSintatico("Era esperado ')' na linha " + parser.getLineNumber());

                // desempilhe uma expressao
                Expressao exp = (Expressao) expStack.pop();
                // crie e empilhe uma expressao unaria
                expStack.push(new ExpUnaria(cmd, exp));
                break;
            default:    // se o simbolo lido nao for valido
                // ative um erro sintatico
                throw new ErroSintatico("Erro: era esperado um operando ou um '(' na linha " + parser.getLineNumber());
        } // fim switch

        // obtenha o proximo simbolo
        simboloAtual = parser.obterSimbolo();
    }
}