Esempio n. 1
0
        public void ExpY()
        {
            AnalisadorLexico.Analisar();
            Int32 opType        = TokenManager.Instance.TokenCode;
            bool  is_valid_flag = false;

            if (opType == LexMap.Consts["MULTIPLICACAO"])
            {
                is_valid_flag = true;
            }

            if (opType == LexMap.Consts["DIVISAO"])
            {
                is_valid_flag = true;
            }

            if (opType == LexMap.Consts["MODC"])
            {
                is_valid_flag = true;
            }

            if (is_valid_flag)
            {
                this.ExpK();

                this.ExpY();
            }
        }
Esempio n. 2
0
        private void While()
        {
            if (TokenManager.Instance.TokenCode == LexMap.Consts["WHILE"])
            {
                AnalisadorLexico.Analisar();
                if (TokenManager.Instance.TokenCode != LexMap.Consts["ABREPAR"])
                {
                    throw new AnalisadorException("O token ( era esperado");
                }

                this.Exp();

                if (TokenManager.Instance.TokenCode != LexMap.Consts["FECHAPAR"])
                {
                    throw new AnalisadorException("O token ) era esperado");
                }

                AnalisadorLexico.Analisar();
                if (TokenManager.Instance.TokenCode != LexMap.Consts["ABRECHAVES"])
                {
                    throw new AnalisadorException("O token { era esperado");
                }

                this.ListaComandos();

                if (TokenManager.Instance.TokenCode != LexMap.Consts["FECHACHAVES"])
                {
                    throw new AnalisadorException("O token } era esperado");
                }
            }
        }
Esempio n. 3
0
        private void DecC()
        {
            //AnalisadorLexico.Analisar();

            this.ListaDecParm();

            if (TokenManager.Instance.TokenCode != LexMap.Consts["FECHAPAR"])
            {
                throw new AnalisadorException("O token ) era esperado.");
            }

            AnalisadorLexico.Analisar();
            if (TokenManager.Instance.TokenCode != LexMap.Consts["ABRECHAVES"])
            {
                throw new AnalisadorException("O token { era esperado.");
            }

            this.ListaComandos();

            this.Retorno();

            //AnalisadorLexico.Analisar();
            if (TokenManager.Instance.TokenCode != LexMap.Consts["FECHACHAVES"])
            {
                throw new AnalisadorException("O token } era esperado.");
            }
        }
Esempio n. 4
0
        private void Switch()
        {
            if (TokenManager.Instance.TokenCode == LexMap.Consts["SWITCH"])
            {
                AnalisadorLexico.Analisar();
                if (TokenManager.Instance.TokenCode != LexMap.Consts["ABREPAR"])
                {
                    throw new AnalisadorException("O token ( era esperado");
                }

                this.Exp();

                if (TokenManager.Instance.TokenCode != LexMap.Consts["FECHAPAR"])
                {
                    throw new AnalisadorException("O token ) era esperado");
                }

                AnalisadorLexico.Analisar();
                if (TokenManager.Instance.TokenCode != LexMap.Consts["ABRECHAVES"])
                {
                    throw new AnalisadorException("O token { era esperado");
                }

                this.ListaCase();

                this.SwitchDefault();

                AnalisadorLexico.Analisar();
                if (TokenManager.Instance.TokenCode != LexMap.Consts["FECHACHAVES"])
                {
                    throw new AnalisadorException("O token } era esperado");
                }
            }
        }
Esempio n. 5
0
        private void DecB()
        {
            AnalisadorLexico.Analisar();

            if (TokenManager.Instance.TokenCode == LexMap.Consts["PONTOVIRGULA"])
            {
                return;
            }
            else if (TokenManager.Instance.TokenCode == LexMap.Consts["VIRGULA"])
            {
                AnalisadorLexico.Analisar();

                if (TokenManager.Instance.TokenCode != LexMap.Consts["ID"])
                {
                    throw new AnalisadorException("Um identificador era esperado.");
                }

                this.ListaVar();

                if (TokenManager.Instance.TokenCode != LexMap.Consts["PONTOVIRGULA"])
                {
                    throw new AnalisadorException("O Token ; era esperado.");
                }
            }
            else if (TokenManager.Instance.TokenCode == LexMap.Consts["ABREPAR"])
            {
                this.DecC();
            }
            else
            {
                throw new AnalisadorException("O token ; , ( era esperado.");
            }
        }
Esempio n. 6
0
        private void ListaCase()
        {
            AnalisadorLexico.Analisar();
            if (TokenManager.Instance.TokenCode == LexMap.Consts["CASE"])
            {
                AnalisadorLexico.Analisar();
                if (TokenManager.Instance.TokenCode != LexMap.Consts["CONSTINTEIRO"])
                {
                    throw new AnalisadorException("O token constante inteiro era esperado");
                }

                AnalisadorLexico.Analisar();
                if (TokenManager.Instance.TokenCode != LexMap.Consts["DOISPONTOS"])
                {
                    throw new AnalisadorException("O token : era esperado");
                }

                AnalisadorLexico.Analisar();
                if (TokenManager.Instance.TokenCode != LexMap.Consts["ABRECHAVES"])
                {
                    throw new AnalisadorException("O token { era esperado");
                }

                this.ListaComandos();

                this.CaseEnd();

                this.ListaCase();
            }
            else
            {
                LineManager.Instance.ResetToLastPos();
            }
        }
Esempio n. 7
0
        private void Funcao()
        {
            //if (TokenManager.Instance.TokenCode == LexMap.Consts["ID"])
            //{
            //    AnalisadorLexico.Analisar();
            if (TokenManager.Instance.TokenCode == LexMap.Consts["PONTO"])
            {
                AnalisadorLexico.Analisar();
                if (TokenManager.Instance.TokenCode != LexMap.Consts["ID"])
                {
                    throw new AnalisadorException("O token id era esperado, id.id()");
                }

                AnalisadorLexico.Analisar();
            }

            if (TokenManager.Instance.TokenCode != LexMap.Consts["ABREPAR"])
            {
                throw new AnalisadorException("O token ( era esperado");
            }

            AnalisadorLexico.Analisar();
            //se for sem parametro
            if (TokenManager.Instance.TokenCode != LexMap.Consts["FECHAPAR"])
            {
                LineManager.Instance.ResetToLastPos();
                this.ListaParam();
            }

            if (TokenManager.Instance.TokenCode != LexMap.Consts["FECHAPAR"])
            {
                throw new AnalisadorException("O token ) era esperado");
            }
            //}
        }
Esempio n. 8
0
        private void SwitchDefault()
        {
            AnalisadorLexico.Analisar();
            if (TokenManager.Instance.TokenCode == LexMap.Consts["DEFAULT"])
            {
                AnalisadorLexico.Analisar();
                if (TokenManager.Instance.TokenCode != LexMap.Consts["DOISPONTOS"])
                {
                    throw new AnalisadorException("O token : era esperado");
                }

                AnalisadorLexico.Analisar();
                if (TokenManager.Instance.TokenCode != LexMap.Consts["ABRECHAVES"])
                {
                    throw new AnalisadorException("O token { era esperado");
                }

                this.ListaComandos();

                this.CaseEnd();
            }
            else
            {
                LineManager.Instance.ResetToLastPos();
            }
        }
Esempio n. 9
0
 public void Atribuicao()
 {
     AnalisadorLexico.Analisar();
     if (TokenManager.Instance.TokenCode == LexMap.Consts["ATRIBUICAO"])
     {
         this.Exp();
     }
 }
Esempio n. 10
0
        private void ListaAtrib()
        {
            AnalisadorLexico.Analisar();
            if (TokenManager.Instance.TokenCode != LexMap.Consts["ID"])
            {
                throw new AnalisadorException("O token identificador era esperado");
            }
            this.Atribuicao();

            this.ListaAtribA();
        }
Esempio n. 11
0
        public void TipoVar()
        {
            AnalisadorLexico.Analisar();

            if (TokenManager.Instance.TokenCode != LexMap.Consts["INTEIRO"] &&
                TokenManager.Instance.TokenCode != LexMap.Consts["FLOAT"] &&
                TokenManager.Instance.TokenCode != LexMap.Consts["BYTE"] &&
                TokenManager.Instance.TokenCode != LexMap.Consts["LONG"])
            {
                throw new AnalisadorException("Tipo de variável não pode ser identificado.");
            }
        }
Esempio n. 12
0
        public void ExpK()
        {
            AnalisadorLexico.Analisar();
            int tkc = TokenManager.Instance.TokenCode;

            if (tkc == LexMap.Consts["CONSTINTEIRO"] ||
                tkc == LexMap.Consts["CONSTFLOAT"] ||
                tkc == LexMap.Consts["CONSTFLOATPONTO"] ||
                tkc == LexMap.Consts["CONSTFLOATPONTONUM"] ||
                tkc == LexMap.Consts["CONSTFLOATNUME"] ||
                tkc == LexMap.Consts["CONSTFLOATNUMPONTO"] ||
                tkc == LexMap.Consts["CONSTFLOATE"] ||
                tkc == LexMap.Consts["TRUE"] ||
                tkc == LexMap.Consts["FALSE"] ||
                tkc == LexMap.Consts["HIGH"] ||
                tkc == LexMap.Consts["LOW"] ||
                tkc == LexMap.Consts["INPUT"] ||
                tkc == LexMap.Consts["OUTPUT"] ||
                tkc == LexMap.Consts["ID"])
            {
                if (tkc == LexMap.Consts["ID"])
                {
                    AnalisadorLexico.Analisar();
                    if (TokenManager.Instance.TokenCode == LexMap.Consts["ABREPAR"] || TokenManager.Instance.TokenCode == LexMap.Consts["PONTO"])
                    {
                        this.Funcao();
                    }
                    else
                    {
                        LineManager.Instance.ResetToLastPos();
                    }
                }

                return;
            }

            if (TokenManager.Instance.TokenCode == LexMap.Consts["ABREPAR"])
            {
                this.Exp();

                if (TokenManager.Instance.TokenCode != LexMap.Consts["FECHAPAR"])
                {
                    throw new AnalisadorException(
                              String.Format("Era esperado o token {0}", LexMap.TokenGetNome(LexMap.Consts["FECHAPAR"]))
                              );
                }

                return;
            }

            throw new AnalisadorException("O valor da expressão (K) não é válido");
        }
        public static void Analisar()
        {
            String nome;

            StringBuilder sb = new StringBuilder();

            sb.AppendLine(String.Format("Token: {0}", TokenManager.Instance.TokenSymbol));
            sb.AppendLine(String.Format("Token Anterior: {0}", TokenManager.Instance.TokenSymbolAnt));
            sb.AppendLine(String.Format("Código do Token: {0}", TokenManager.Instance.TokenCode));
            sb.AppendLine(String.Format("Código do Token Anterior: {0}", TokenManager.Instance.TokenCodeAnt));
            sb.AppendLine(String.Format("Posição do Caracter de parada: {0}", LineManager.Instance.PosCurrentCaracter));
            sb.AppendLine(String.Format("Posição de início de leitura do Token: {0}", LineManager.Instance.PosStartToken));

            if (AnalisadorLexico.Reconhecedor())
            {
                if (TokenManager.Instance.TokenCode == LexMap.Consts["ID"])
                {
                    try
                    {
                        TokenManager.Instance.TokenCode = LexMap.PalavraReservada[TokenManager.Instance.TokenSymbol];
                    }
                    catch (Exception) { }
                }

                try
                {
                    nome = LexMap.TokenNome[TokenManager.Instance.TokenCode];

                    LineManager.Instance.LinesOut.Add(
                        String.Format("Cod: {0}\tLinha: {1}\tColuna: {2}\tTipo: {3}\tLexema: {4}\n",
                                      TokenManager.Instance.TokenCode,
                                      LineManager.Instance.LineIndex,
                                      LineManager.Instance.PosStartToken,
                                      nome,
                                      TokenManager.Instance.TokenSymbol));
                }
                catch (Exception)
                {
                    throw new AnalisadorException(String.Format("O Token -{0}- não foi encontrado", TokenManager.Instance.TokenSymbol));
                }
            }
            else
            {
                TokenManager.Instance.TokenCode = 0;
                //TokenManager.Instance.TokenCodeAnt = 0;
                TokenManager.Instance.TokenSymbol = "Provável fim de arquivo";
                //TokenManager.Instance.TokenSymbolAnt = "Provável fim de arquivo";
                //throw new AnalisadorFimArquivoException("O reconhecedor encontrou uma sintaxe não finalizada" + Environment.NewLine + sb.ToString());
            }
        }
Esempio n. 14
0
        private void ListaDecParmB()
        {
            AnalisadorLexico.Analisar();
            if (TokenManager.Instance.TokenCode == LexMap.Consts["VIRGULA"])
            {
                this.TipoVar();

                AnalisadorLexico.Analisar();
                if (TokenManager.Instance.TokenCode != LexMap.Consts["ID"])
                {
                    throw new AnalisadorException("Um identificador era esperado");
                }

                this.ListaDecParmB();
            }
        }
Esempio n. 15
0
        /*
         * Declaracao -> TipoVar id DecB | void id ( DecC
         * DecB -> ; | , id ListaVar ; | ( DecC
         * DecC -> ListaParm) {ListaComandos}
         */
        private void Declaracao()
        {
            int gramatica = 0;

            try
            {
                this.TipoVar();
            }
            catch (AnalisadorException) //o tipo ainda pode ser void
            {
                gramatica = 1;
            }

            if (gramatica == 0)
            {
                AnalisadorLexico.Analisar();
                if (TokenManager.Instance.TokenCode != LexMap.Consts["ID"])
                {
                    throw new AnalisadorException("Um identificador era esperado.");
                }

                this.DecB();
            }
            else
            {
                if (TokenManager.Instance.TokenCode != LexMap.Consts["VOID"])
                {
                    throw new AnalisadorException("Tipo de variável não pode ser identificado.");
                }

                AnalisadorLexico.Analisar();
                if (TokenManager.Instance.TokenCode != LexMap.Consts["ID"])
                {
                    throw new AnalisadorException("Um identificador era esperado.");
                }

                AnalisadorLexico.Analisar();
                if (TokenManager.Instance.TokenCode != LexMap.Consts["ABREPAR"])
                {
                    throw new AnalisadorException("O token ( era esperado.");
                }

                this.DecC();
            }
        }
Esempio n. 16
0
        private void DeclaraVar()
        {
            this.TipoVar();

            AnalisadorLexico.Analisar();

            if (TokenManager.Instance.TokenCode != LexMap.Consts["ID"])
            {
                throw new AnalisadorException("Um identificador era esperado");
            }

            this.ListaVar();

            if (TokenManager.Instance.TokenCode != LexMap.Consts["PONTOVIRGULA"])
            {
                throw new AnalisadorException("O Token ; era esperado.");
            }
        }
Esempio n. 17
0
        public void ListaVar()
        {
            AnalisadorLexico.Analisar();

            if (TokenManager.Instance.TokenCode == LexMap.Consts["VIRGULA"])
            {
                AnalisadorLexico.Analisar();

                if (TokenManager.Instance.TokenCode == LexMap.Consts["ID"])
                {
                    this.ListaVar();
                }
                else
                {
                    throw new AnalisadorException("Tipo de variável não pode ser identificado.");
                }
            }
        }
Esempio n. 18
0
        public void ExpU()
        {
            AnalisadorLexico.Analisar();
            Int32 opType        = TokenManager.Instance.TokenCode;
            bool  is_valid_flag = false;

            if (opType == LexMap.Consts["E"])
            {
                is_valid_flag = true;
            }

            if (is_valid_flag)
            {
                this.ExpF();

                this.ExpU();
            }
        }
Esempio n. 19
0
        private void For()
        {
            if (TokenManager.Instance.TokenCode == LexMap.Consts["FOR"])
            {
                AnalisadorLexico.Analisar();
                if (TokenManager.Instance.TokenCode != LexMap.Consts["ABREPAR"])
                {
                    throw new AnalisadorException("O token ( era esperado");
                }

                this.ListaAtrib();
                if (TokenManager.Instance.TokenCode != LexMap.Consts["PONTOVIRGULA"])
                {
                    throw new AnalisadorException("O token ; era esperado");
                }

                this.Exp();
                if (TokenManager.Instance.TokenCode != LexMap.Consts["PONTOVIRGULA"])
                {
                    throw new AnalisadorException("O token ; era esperado");
                }

                // falta o i++
                this.ListaAtrib();

                if (TokenManager.Instance.TokenCode != LexMap.Consts["FECHAPAR"])
                {
                    throw new AnalisadorException("O token ) era esperado");
                }

                AnalisadorLexico.Analisar();
                if (TokenManager.Instance.TokenCode != LexMap.Consts["ABRECHAVES"])
                {
                    throw new AnalisadorException("O token { era esperado");
                }

                this.ListaComandos();

                if (TokenManager.Instance.TokenCode != LexMap.Consts["FECHACHAVES"])
                {
                    throw new AnalisadorException("O token } era esperado");
                }
            }
        }
Esempio n. 20
0
        public void ExpV()
        {
            AnalisadorLexico.Analisar();
            Int32 opType        = TokenManager.Instance.TokenCode;
            bool  is_valid_flag = false;

            if (opType == LexMap.Consts["MAIOR"])
            {
                is_valid_flag = true;
            }

            if (opType == LexMap.Consts["IGUAL"])
            {
                is_valid_flag = true;
            }

            if (opType == LexMap.Consts["MENOR"])
            {
                is_valid_flag = true;
            }

            if (opType == LexMap.Consts["MAIORIGUAL"])
            {
                is_valid_flag = true;
            }

            if (opType == LexMap.Consts["DIFERENTE"])
            {
                is_valid_flag = true;
            }

            if (opType == LexMap.Consts["MENORIGUAL"])
            {
                is_valid_flag = true;
            }

            if (is_valid_flag)
            {
                this.ExpH();

                this.ExpV();
            }
        }
Esempio n. 21
0
        public void ExpG()
        {
            AnalisadorLexico.Analisar();
            if (TokenManager.Instance.TokenCode == LexMap.Consts["NAO"])
            {
                this.ExpG();
            }
            else
            {
                //ACHO
                LineManager.Instance.ResetToLastPos();

                this.ExpH();


                this.ExpV();

                LineManager.Instance.ResetToLastPos();
            }
        }
Esempio n. 22
0
        private void CaseEnd()
        {
            if (TokenManager.Instance.TokenCode != LexMap.Consts["FECHACHAVES"])
            {
                throw new AnalisadorException("O token } era esperado");
            }

            AnalisadorLexico.Analisar();
            if (TokenManager.Instance.TokenCode == LexMap.Consts["BREAK"])
            {
                AnalisadorLexico.Analisar();
                if (TokenManager.Instance.TokenCode != LexMap.Consts["PONTOVIRGULA"])
                {
                    throw new AnalisadorException("O token ; era esperado");
                }
            }
            else
            {
                LineManager.Instance.ResetToLastPos();
            }
        }
Esempio n. 23
0
        /*
         *  ListaDecParm -> TipoVar id ListaDecParmB | {}
         *  ListaDecParmB -> , TipoVar id ListaDecParmB | {}
         */
        private void ListaDecParm()
        {
            try
            {
                this.TipoVar();
            }
            catch (AnalisadorException) {
                //vazio
                return;
            }

            //se TipoVar não causou uma exception, então estou dando parse nos parametros

            AnalisadorLexico.Analisar();
            if (TokenManager.Instance.TokenCode != LexMap.Consts["ID"])
            {
                throw new AnalisadorException("Um identificador era esperado");
            }

            this.ListaDecParmB();
        }
Esempio n. 24
0
 private void Retorno()
 {
     if (TokenManager.Instance.TokenCode == LexMap.Consts["RETURN"])
     {
         AnalisadorLexico.Analisar();
         if (TokenManager.Instance.TokenCode == LexMap.Consts["PONTOVIRGULA"])
         {
             AnalisadorLexico.Analisar();
             return;
         }
         else
         {
             LineManager.Instance.ResetToLastPos();
             this.Exp();
             if (TokenManager.Instance.TokenCode != LexMap.Consts["PONTOVIRGULA"])
             {
                 throw new AnalisadorException("O token ; era esperado.");
             }
             AnalisadorLexico.Analisar();
         }
     }
 }
Esempio n. 25
0
        private void IfEnd()
        {
            AnalisadorLexico.Analisar();
            if (TokenManager.Instance.TokenCode == LexMap.Consts["ELSE"])
            {
                AnalisadorLexico.Analisar();
                if (TokenManager.Instance.TokenCode == LexMap.Consts["ABRECHAVES"])
                {
                    this.ListaComandos();

                    if (TokenManager.Instance.TokenCode != LexMap.Consts["FECHACHAVES"])
                    {
                        throw new AnalisadorException("O token } era esperado");
                    }
                }
                else if (TokenManager.Instance.TokenCode == LexMap.Consts["IF"])
                {
                    // quebra de linha entre else e if da erro:
                    // if(a){ if(a){}else
                    // if(1){} }
                    // no case tbm:
                    // switch(1){
                    // case
                    // }
                    this.If();
                }
                else
                {
                    throw new AnalisadorException("O token ( ou if era esperado");
                }
            }
            else
            {
                LineManager.Instance.ResetToLastPos();
            }
        }
Esempio n. 26
0
        private void ListaComandosX()
        {
            bool recur_flag = false;

            AnalisadorLexico.Analisar();

            //declaração variaveis
            if (TokenManager.Instance.TokenCode == LexMap.Consts["INTEIRO"] ||
                TokenManager.Instance.TokenCode == LexMap.Consts["FLOAT"] ||
                TokenManager.Instance.TokenCode == LexMap.Consts["BYTE"] ||
                TokenManager.Instance.TokenCode == LexMap.Consts["LONG"] ||
                TokenManager.Instance.TokenCode == LexMap.Consts["VOID"])
            {
                LineManager.Instance.ResetToLastPos();
                this.Declaracao();
                recur_flag = true;
            }
            else

            //if
            if (TokenManager.Instance.TokenCode == LexMap.Consts["IF"])
            {
                this.If();
                recur_flag = true;
            }
            else

            //while
            if (TokenManager.Instance.TokenCode == LexMap.Consts["WHILE"])
            {
                this.While();
                recur_flag = true;
            }
            else

            //do while
            if (TokenManager.Instance.TokenCode == LexMap.Consts["DO"])
            {
                this.DoWhile();
                recur_flag = true;
            }
            else

            //for
            if (TokenManager.Instance.TokenCode == LexMap.Consts["FOR"])
            {
                this.For();
                recur_flag = true;
            }
            else

            //switch
            if (TokenManager.Instance.TokenCode == LexMap.Consts["SWITCH"])
            {
                this.Switch();
                recur_flag = true;
            }
            else

            if (TokenManager.Instance.TokenCode == LexMap.Consts["ID"])
            {
                //atribuição
                this.Atribuicao();
                recur_flag = true;

                //funcao
                if (TokenManager.Instance.TokenCode == LexMap.Consts["ABREPAR"] || TokenManager.Instance.TokenCode == LexMap.Consts["PONTO"])
                {
                    //LineManager.Instance.ResetToLastPos(); // nao retrocede por causa da Atribuicao
                    this.Funcao();
                    AnalisadorLexico.Analisar();
                }

                if (TokenManager.Instance.TokenCode != LexMap.Consts["PONTOVIRGULA"])
                {
                    throw new AnalisadorException("O Token ; era esperado");
                }
            }

            //recursão
            if (recur_flag == true)
            {
                this.ListaComandosX();
            }
        }