MultiInterpretador.java

Vá para a documentação deste arquivo.

package plp;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.util.LinkedList;
import java.util.List;
import java.util.StringTokenizer;

import javax.swing.JTextArea;

import plp.expressions1.parser.Exp1Parser;
import plp.expressions1.parser.ParseException;
import plp.expressions2.expression.ValorBooleano;
import plp.expressions2.expression.ValorInteiro;
import plp.expressions2.expression.ValorString;
import plp.expressions2.parser.Exp2Parser;
import plp.functional1.parser.Func1Parser;
import plp.functional2.parser.Func2Parser;
import plp.functional3.parser.Func3Parser;

public class MultiInterpretador {

        private static final int EXP1 = 0;

        private static final int EXP2 = 1;

        private static final int FUNC1 = 2;

        private static final int FUNC2 = 3;

        private static final int FUNC3 = 4;

        private static final int IMP1 = 5;

        private static final int IMP2 = 6;

        private static final int OO1 = 7;

        private JTextArea messageBoard;

        private Exp1Parser exp1Parser = null;
        private Exp2Parser exp2Parser = null;
        private Func1Parser func1Parser = null;
        private Func2Parser func2Parser = null;
        private Func3Parser func3Parser = null;

        public MultiInterpretador(JTextArea textAreaMensagens) {
                super();
                messageBoard = textAreaMensagens;
        }

        public void interpretarCodigo(String sourceCode, String listaEntrada,
                        int selectedIndex) {
                try {
                        ByteArrayInputStream fis = new ByteArrayInputStream(sourceCode
                                        .getBytes());

                        switch (selectedIndex) {
                        case EXP1:
                                interpretarExp1(fis);
                                break;
                        case EXP2:
                                interpretarExp2(fis);
                                break;
                        case FUNC1:
                                interpretarFunc1(fis);
                                break;
                        case FUNC2:
                                interpretarFunc2(fis);
                                break;
                        case FUNC3:
                                interpretarFunc3(fis);
                                break;
                        }
                } catch (Exception e1) {
                        messageBoard.setText(e1.getMessage());
                        e1.printStackTrace();
                } catch (Throwable t) {
                        messageBoard.setText(t.getMessage());
                        t.printStackTrace();
                }

        }

        private void interpretarExp1(InputStream fis) throws ParseException {
                plp.expressions1.Programa prog;
                if (exp1Parser == null) {
                        exp1Parser = new Exp1Parser(fis);
                } else {
                        Exp1Parser.ReInit(fis);
                }
                prog = Exp1Parser.Input();
                messageBoard.setText("sintaxe verificada com sucesso!\n");
                if (prog.checaTipo()) {
                        messageBoard.append("resultado = " + prog.executar().toString());
                } else {
                        messageBoard.append("erro de tipos!");
                }
        }

        private void interpretarExp2(InputStream fis) throws Exception {
                plp.expressions2.Programa prog;
                if (exp2Parser == null) {
                        exp2Parser = new Exp2Parser(fis);
                } else {
                        Exp2Parser.ReInit(fis);
                }
                prog = Exp2Parser.Input();

                messageBoard.setText("sintaxe verificada com sucesso!\n");
                if (prog.checaTipo()) {
                        messageBoard.append("resultado = " + prog.executar().toString());
                } else {
                        messageBoard.append("erro de tipos!");
                }
        }

        private void interpretarFunc1(InputStream fis) throws Exception {
                plp.functional1.Programa prog;
                if (func1Parser == null) {
                        func1Parser = new Func1Parser(fis);
                } else {
                        Func1Parser.ReInit(fis);
                }
                prog = Func1Parser.Input();

                messageBoard.setText("sintaxe verificada com sucesso!\n");
                if (prog.checaTipo()) {
                        messageBoard.append("resultado = " + prog.executar().toString());
                } else {
                        messageBoard.append("erro de tipos!");
                }
        }

        private void interpretarFunc2(InputStream fis) throws Exception {
                plp.functional2.Programa prog;
                if (func2Parser == null) {
                        func2Parser = new Func2Parser(fis);
                } else {
                        Func2Parser.ReInit(fis);
                }

                prog = Func2Parser.Input();

                messageBoard.setText("sintaxe verificada com sucesso!\n");
                messageBoard.append("resultado = " + prog.executar().toString());
        }

        private void interpretarFunc3(InputStream fis) throws Exception {
                plp.functional3.Programa prog;
                if (func3Parser == null) {
                        func3Parser = new Func3Parser(fis);
                } else {
                        Func3Parser.ReInit(fis);
                }

                prog = Func3Parser.Input();

                messageBoard.setText("sintaxe verificada com sucesso!\n");
                messageBoard.append("resultado = " + prog.executar().toString());
        }

        

        

}

---