Exemple #1
0
        private void CalcExpressaoUnaria(INoArvore no, int acumulador)
        {
            NoArvoreComposite noOperadorUnario = no as NoArvoreComposite;

            Expressao(noOperadorUnario [1], acumulador);
            GeraCalculoExpressao(noOperadorUnario [0].Token, acumulador);
        }
Exemple #2
0
        private INoArvore Expressao()
        {
            INoArvore no = null;

            no = Termo();

            while (token.TipoToken == Tokens.OP_SOMA || token.TipoToken == Tokens.OP_SUB)
            {
                NoArvoreComposite noPai = new NoArvoreComposite(Soma());
                if (no != null)
                {
                    noPai.Add(no);                       // filho1
                }
                else
                {
                    EmiteErroSintaxe("left operand not defined");
                }

                no = Termo();

                if (no != null)
                {
                    noPai.Add(no);                      // filho2
                }
                else
                {
                    EmiteErroSintaxe("right operand not defined");
                }
                no = noPai;
            }

            return(no);
        }
Exemple #3
0
        private INoArvore ExpressaoLogicaE()
        {
            INoArvore         no    = null;
            NoArvoreComposite noPai = null;

            no = ExpressaoLogica();

            while (token.TipoToken == Tokens.OP_LOGIC_E)
            {
                Casamento(Tokens.OP_LOGIC_E);
                noPai = new NoArvoreComposite(new NoArvore(tokenAnterior, TipoExpressao.ExpressaoLogica, TipoOperador.OperadorLogico));
                if (no != null)
                {
                    noPai.Add(no);                      // expressao lado esquerda do operador
                }
                else
                {
                    EmiteErroSintaxe("left expression not defined");
                }

                no = ExpressaoLogica();
                if (no != null)
                {
                    noPai.Add(no);
                }
                else
                {
                    EmiteErroSintaxe("right expression not defined");
                }

                no = noPai;
            }

            return(no);
        }
Exemple #4
0
        private void ExpressaoLogica(NoArvoreComposite no, int acumulador)
        {
            double valor1, valor2;

            switch (no [0].Token.TipoToken)
            {
            case Tokens.OP_LOGIC_E:
                ExpressaoLogica(no [1] as NoArvoreComposite, acumulador);
                ExpressaoLogica(no [2] as NoArvoreComposite, acumulador + 1);

                if (registro [acumulador] == 1 && registro [acumulador + 1] == 1)
                {
                    registro [acumulador] = 1;
                }
                else
                {
                    registro [acumulador] = 0;
                }
                break;

            case Tokens.OP_LOGIC_OU:
                ExpressaoLogica(no [1] as NoArvoreComposite, acumulador);
                ExpressaoLogica(no [2] as NoArvoreComposite, acumulador + 1);

                if (registro [acumulador] == 1 || registro [acumulador + 1] == 1)
                {
                    registro [acumulador] = 1;
                }
                else
                {
                    registro [acumulador] = 0;
                }
                break;

            case Tokens.OP_REL_IGUAL:
            case Tokens.OP_REL_MAIOR:
            case Tokens.OP_REL_MAIOR_QUE:
            case Tokens.OP_REL_MENOR:
            case Tokens.OP_REL_MENOR_QUE:
                Expressao(no [1], acumulador);
                valor1 = registro [acumulador];
                Expressao(no [2], acumulador + 1);
                valor2 = registro [acumulador + 1];
                Swap(ref valor1, ref registro [8]);
                Swap(ref valor2, ref registro [9]);
                ComparaExpressaoLogica(no [0].Token, 8, 9);
                registro [acumulador] = registro [8];
                Swap(ref registro [8], ref valor1);
                Swap(ref registro [9], ref valor2);
                break;

            default:
                throw new Exception("Compile error " + no [0].Token.Lexema +
                                    " line: " + no [0].Token.Linha.ToString() +
                                    " column: " + no [0].Token.Coluna.ToString() +
                                    no [0].Token.Lexema +
                                    " is a logical expression");
            }
        }
Exemple #5
0
        private INoArvore Fator()
        {
            NoArvoreComposite noPai;
            INoArvore         no = null;

            switch (token.TipoToken)
            {
            case Tokens.ID:
                Casamento(Tokens.ID);
                no = new NoArvore(tokenAnterior, TipoExpressao.Identificador, TipoOperador.Nenhum);
                break;

            case Tokens.NUMERO:
                Casamento(Tokens.NUMERO);
                no = new NoArvore(tokenAnterior, TipoExpressao.Numero, TipoOperador.Nenhum);
                break;

            case Tokens.PARENTESE_ESQUERDO:
                Casamento(Tokens.PARENTESE_ESQUERDO);
                no = Expressao();
                Casamento(Tokens.PARENTESE_DIREITO);
                break;

            case Tokens.COS:
            case Tokens.SEN:
            case Tokens.TANG:
            case Tokens.ACOS:
            case Tokens.ASEN:
            case Tokens.ATANG:
            case Tokens.LOG:
            case Tokens.LOG2:
            case Tokens.LOG10:
            case Tokens.RQD:
                no    = OpCientifico();
                noPai = new NoArvoreComposite(no);
                Casamento(Tokens.PARENTESE_ESQUERDO);
                no = Expressao();
                noPai.Add(no);
                no = noPai;
                Casamento(Tokens.PARENTESE_DIREITO);
                break;

            case Tokens.PI:
                Casamento(Tokens.PI);
                no = new NoArvore(tokenAnterior, TipoExpressao.Constante, TipoOperador.Nenhum);
                break;

            case Tokens.NEP:
                Casamento(Tokens.NEP);
                no = new NoArvore(tokenAnterior, TipoExpressao.Constante, TipoOperador.Nenhum);
                break;

            default:
                EmiteErroSintaxe("Error  of sintaxe on the line:" + token.Linha + " next to line: " +
                                 token.Coluna + " invalid token" + token.Lexema + "'");
                break;
            }
            return(no);
        }
Exemple #6
0
        private INoArvore ListaExpresao()
        {
            INoArvore         no = null;
            NoArvoreComposite noPai;

            no = ExpressaoLogicaE();

            while (token.TipoToken == Tokens.OP_LOGIC_OU)
            {
                Casamento(Tokens.OP_LOGIC_OU);
                noPai = new NoArvoreComposite(new NoArvore(tokenAnterior, TipoExpressao.ExpressaoLogica, TipoOperador.OperadorLogico));

                if (no != null)
                {
                    noPai.Add(no);
                }
                else
                {
                    EmiteErroSintaxe("error expression");
                }

                no = ExpressaoLogicaE();

                if (no != null)
                {
                    noPai.Add(no);
                }
                else
                {
                    EmiteErroSintaxe("error expression");
                }

                no = noPai;
            }

            return(no);
        }
Exemple #7
0
        public void DoParse()
        {
            linha = 0;

            /* inicia a tabela de simbolo com as palavras reservadas */
            IniciarTabelaSimbolo();
            token = scan.ObterToken();

            INoArvore no = ListaExpresao();

            if (token.TipoToken != Tokens.NENHUM)
            {
                EmiteErroSintaxe("error in the expression, compile finish before the end of expression.");
            }
            //TODO: throw the exception for imcomplete parse

            if (no == null)
            {
                return;
            }

            if (no.NumeroFilhos == 0)
            {
                arvoreSintatica = new NoArvoreComposite(no);
            }
            else
            {
                arvoreSintatica = (NoArvoreComposite)no;
            }

            if (arvoreSintatica != null)
            {
                parseFeito = true;
                DefineExpressaoLogica(arvoreSintatica);
            }
        }
Exemple #8
0
        private INoArvore Termo()
        {
            INoArvore         no = null;
            NoArvoreComposite noPai;

            switch (token.TipoToken)
            {
            case Tokens.NUMERO:
            case Tokens.ID:
            case Tokens.PARENTESE_ESQUERDO:
            case Tokens.COS:
            case Tokens.SEN:
            case Tokens.TANG:
            case Tokens.ACOS:
            case Tokens.ASEN:
            case Tokens.ATANG:
            case Tokens.LOG:
            case Tokens.LOG2:
            case Tokens.LOG10:
            case Tokens.PI:
            case Tokens.NEP:
            case Tokens.RQD:
                no = Fator();

                if (token.TipoToken == Tokens.OP_FATORIAL)
                {
                    Casamento(Tokens.OP_FATORIAL);
                    noPai = new NoArvoreComposite(new NoArvore(tokenAnterior, TipoExpressao.Expressao, TipoOperador.Cientifico));
                    noPai.Add(no);
                    no = noPai;
                }

                while (token.TipoToken == Tokens.OP_MULT || token.TipoToken == Tokens.OP_DIV ||
                       token.TipoToken == Tokens.OP_MOD || token.TipoToken == Tokens.OP_EXPOENTE)
                {
                    noPai = new NoArvoreComposite(Mult());
                    if (no != null)
                    {
                        noPai.Add(no);                          // filho1
                    }
                    else
                    {
                        EmiteErroSintaxe("Erro expect na expression");
                    }
                    no = Fator();
                    if (no != null)
                    {
                        noPai.Add(no);                          // filho2
                    }
                    else
                    {
                        EmiteErroSintaxe("Error expect an expression");
                    }
                    no = noPai;
                }

                break;

            //case Tokens.NENHUM:
            //	break;
            default:
                EmiteErroSintaxe("Error sintaxe");
                break;
            }

            return(no);
        }
Exemple #9
0
        private INoArvore ExpressaoLogica()
        {
            INoArvore         no = null;
            NoArvoreComposite noPai;

            no = Expressao();
            switch (token.TipoToken)
            {
            case Tokens.OP_REL_MAIOR:
                Casamento(Tokens.OP_REL_MAIOR);
                noPai = new NoArvoreComposite(new NoArvore(tokenAnterior, TipoExpressao.Expressao, TipoOperador.OperadorLogico));
                if (no != null)
                {
                    noPai.Add(no);                        // expressao a esquerda do operador logico relacional
                }
                else
                {
                    EmiteErroSintaxe("left expression not defined");
                }

                no = Expressao();
                if (no != null)
                {
                    noPai.Add(no);                      // expressa a direita do operador logico relaciona
                }
                else
                {
                    EmiteErroSintaxe("right expression not defined");
                }
                no = noPai;
                break;

            case Tokens.OP_REL_MENOR:
                Casamento(Tokens.OP_REL_MENOR);
                noPai = new NoArvoreComposite(new NoArvore(tokenAnterior, TipoExpressao.Expressao, TipoOperador.OperadorLogico));
                if (no != null)
                {
                    noPai.Add(no);                        // expressao a esquerda do operador logico relacional
                }
                else
                {
                    EmiteErroSintaxe("left expression not defined");
                }

                no = Expressao();
                if (no != null)
                {
                    noPai.Add(no);                      // expressao a direita do operador logico relaciona
                }
                else
                {
                    EmiteErroSintaxe("right expression not defined");
                }
                no = noPai;
                break;

            case Tokens.OP_REL_MAIOR_QUE:
                Casamento(Tokens.OP_REL_MAIOR_QUE);
                noPai = new NoArvoreComposite(new NoArvore(tokenAnterior, TipoExpressao.Expressao, TipoOperador.OperadorLogico));
                if (no != null)
                {
                    noPai.Add(no);                        // expressao a esquerda do operador logico relacional
                }
                else
                {
                    EmiteErroSintaxe("left expression not defined");
                }

                no = Expressao();
                if (no != null)
                {
                    noPai.Add(no);                      // expressa a direita do operador logico relaciona
                }
                else
                {
                    EmiteErroSintaxe("right expression not defined");
                }
                no = noPai;
                break;

            case Tokens.OP_REL_MENOR_QUE:
                Casamento(Tokens.OP_REL_MENOR_QUE);
                noPai = new NoArvoreComposite(new NoArvore(tokenAnterior, TipoExpressao.Expressao, TipoOperador.OperadorLogico));
                if (no != null)
                {
                    noPai.Add(no);                        // expressao a esquerda do operador logico relacional
                }
                else
                {
                    EmiteErroSintaxe("left expression not defined");
                }

                no = Expressao();
                if (no != null)
                {
                    noPai.Add(no);                      // expressa a direita do operador logico relaciona
                }
                else
                {
                    EmiteErroSintaxe("right expression not defined");
                }

                no = noPai;
                break;

            case Tokens.OP_REL_IGUAL:
                Casamento(Tokens.OP_REL_IGUAL);
                noPai = new NoArvoreComposite(new NoArvore(tokenAnterior, TipoExpressao.Expressao, TipoOperador.OperadorLogico));
                if (no != null)
                {
                    noPai.Add(no);                        // expressao a esquerda do operador logico relacional
                }
                else
                {
                    EmiteErroSintaxe("left operando not defined");
                }

                no = Expressao();
                if (no != null)
                {
                    noPai.Add(no);                      // expressa a direita do operador logico relaciona
                }
                else
                {
                    EmiteErroSintaxe("right operand not defined");
                }

                no = noPai;
                break;
            }

            return(no);
        }