Exemple #1
0
        private void analisaEscreva()
        {
            updateToken();

            if (!hasEndedTokens && isSimbol(ABRE_PARENTESES))
            {
                updateToken();

                if (!hasEndedTokens && isSimbol(IDENTIFICADOR))
                {
                    if (Semantico.pesquisaDeclVarFuncTabela(actualToken.lexem))
                    {
                        Struct identifierStruct = Semantico.pesquisaTabela(actualToken.lexem, 0);

                        if (identifierStruct.nome.Equals(NOME_FUNCAO))
                        {
                            CodeGenerator.gera(EMPTY_STRING, CALL, identifierStruct.rotulo.ToString(), EMPTY_STRING);
                            CodeGenerator.gera(EMPTY_STRING, LDV, FUNCTION_RETURN_LABEL, EMPTY_STRING);
                        }
                        else
                        {
                            CodeGenerator.gera(EMPTY_STRING, LDV, identifierStruct.rotulo.ToString(), EMPTY_STRING);
                        }

                        CodeGenerator.gera(EMPTY_STRING, PRN, EMPTY_STRING, EMPTY_STRING);

                        updateToken();

                        if (!hasEndedTokens && isSimbol(FECHA_PARENTESES))
                        {
                            updateToken();
                        }
                        else
                        {
                            throwError(new CompiladorException(ERRO_SINTATICO), ERRO_PARENTESIS);
                        }
                    }
                    else
                    {
                        throwError(new CompiladorException(ERRO_SEMANTICO), DECL_VAR_FUNC_ERROR);
                    }
                }
                else
                {
                    throwError(new CompiladorException(ERRO_SINTATICO), ERRO_NOME);
                }
            }
            else
            {
                throwError(new CompiladorException(ERRO_SINTATICO), ERRO_PARENTESIS);
            }
        }
Exemple #2
0
        private void analisaLeia()
        {
            updateToken();

            if (!hasEndedTokens && isSimbol(ABRE_PARENTESES))
            {
                updateToken();

                if (!hasEndedTokens && isSimbol(IDENTIFICADOR))
                {
                    if (Semantico.pesquisaDeclVarTabela(actualToken.lexem))
                    {
                        CodeGenerator.gera(EMPTY_STRING, RD, EMPTY_STRING, EMPTY_STRING);
                        CodeGenerator.gera(EMPTY_STRING, STR, Semantico.pesquisaTabela(actualToken.lexem, 0).rotulo.ToString(), EMPTY_STRING);
                        updateToken();

                        if (!hasEndedTokens && isSimbol(FECHA_PARENTESES))
                        {
                            updateToken();
                        }
                        else
                        {
                            throwError(new CompiladorException(ERRO_SINTATICO), ERRO_PARENTESIS);
                        }
                    }
                    else
                    {
                        throwError(new CompiladorException(ERRO_SEMANTICO), DECL_VAR_ERROR);
                    }
                }
                else
                {
                    throwError(new CompiladorException(ERRO_SINTATICO), ERRO_NOME);
                }
            }
            else
            {
                throwError(new CompiladorException(ERRO_SINTATICO), ERRO_PARENTESIS);
            }
        }
Exemple #3
0
        private void analisaFator()
        {
            if (!hasEndedTokens && isSimbol(IDENTIFICADOR))
            {
                Struct actualItem = Semantico.pesquisaTabela(actualToken.lexem, 0);

                if (actualItem != null)
                {
                    Semantico.addCharToExpression(actualToken);

                    if (actualItem.tipo == TIPO_INTEIRO || actualItem.tipo == TIPO_BOOLEANO)
                    {
                        analisaChamadaFuncao();
                    }
                    else
                    {
                        updateToken();
                    }
                }
                else
                {
                    throwError(new CompiladorException(ERRO_SEMANTICO), ITEM_NOT_FOUND);
                }
            }
            else if (!hasEndedTokens && isSimbol(NUMERO))
            {
                Semantico.addCharToExpression(actualToken);
                updateToken();
            }
            else if (!hasEndedTokens && isSimbol(NAO))
            {
                Semantico.addCharToExpression(actualToken);
                updateToken();

                analisaFator();
            }
            else if (!hasEndedTokens && isSimbol(ABRE_PARENTESES))
            {
                parentesisCount++;
                Semantico.addCharToExpression(actualToken);
                updateToken();

                analisaExpressao();

                if (!hasEndedTokens && isSimbol(FECHA_PARENTESES))
                {
                    parentesisCount--;
                    Semantico.addCharToExpression(actualToken);
                    updateToken();
                }
                else
                {
                    throwError(new CompiladorException(ERRO_SINTATICO), ERRO_PARENTESIS);
                }
            }
            else if (!hasEndedTokens && (isSimbol(VERDADEIRO) || isSimbol(FALSO)))
            {
                Semantico.addCharToExpression(actualToken);
                updateToken();
            }
            else
            {
                throwError(new CompiladorException(ERRO_SINTATICO), ERRO_CARACTER);
            }
        }
Exemple #4
0
        private void analisaAtribChamadaProc()
        {
            tokenAtribuicao             = actualToken;
            structReceivedForAssignment = Semantico.pesquisaTabela(tokenAtribuicao.lexem, 0);

            if (structReceivedForAssignment == null)
            {
                throwError(new CompiladorException(ERRO_SEMANTICO), ITEM_NOT_FOUND);
            }

            updateToken();
            bool hasSameName;

            try
            {
                if (structReceivedForAssignment != null && structReceivedForAssignment.nome.Equals(NOME_FUNCAO))
                {
                    hasSameName = structReceivedForAssignment.lexema.Equals(actualFunctionName.Peek());
                }
                else
                {
                    hasSameName = false;
                }
            }
            catch (Exception)
            {
                hasSameName = false;
            }

            if (!hasEndedTokens && isSimbol(ATRIBUICAO))
            {
                if (structReceivedForAssignment.nome.Equals(NOME_VARIAVEL))
                {
                    analisaAtribuicao();
                }
                else if (hasSameName && structReceivedForAssignment.nome.Equals(NOME_FUNCAO) && functionReturnsExpected > 0)
                {
                    analisaAtribuicao();
                    returnsMade++;
                    returnMade        = true;
                    returnAlreadyMade = true;
                }
                else
                {
                    if (!hasSameName && structReceivedForAssignment.nome.Equals(NOME_FUNCAO))
                    {
                        throwError(new CompiladorException(ERRO_SEMANTICO), INVALID_FUNCTION_NAME, tokenAtribuicao.line);
                    }
                    else
                    {
                        if (structReceivedForAssignment.tipo.Equals(TIPO_BOOLEANO))
                        {
                            throwError(new CompiladorException(ERRO_SEMANTICO), ASSIGNMENT_EXPRESSION_MUST_BE_BOOL, tokenAtribuicao.line);
                        }
                        else
                        {
                            throwError(new CompiladorException(ERRO_SEMANTICO), ASSIGNMENT_EXPRESSION_MUST_BE_INT, tokenAtribuicao.line);
                        }
                    }
                }
            }
            else
            {
                if (structReceivedForAssignment.nome.Equals(NOME_PROCEDIMENTO))
                {
                    analisaChamadaProcedimento(structReceivedForAssignment);
                }
                else
                {
                    throwError(new CompiladorException(ERRO_SEMANTICO), INVALID_PROC_CALL);
                }
            }
        }
        public static void geraCodeExpression(List <string> posFixExpression)
        {
            foreach (String field in posFixExpression)
            {
                switch (field)
                {
                case "*":
                    gera(EMPTY_STRING, MULT, EMPTY_STRING, EMPTY_STRING);
                    break;

                case "div":
                    gera(EMPTY_STRING, DIVI, EMPTY_STRING, EMPTY_STRING);
                    break;

                case "=":
                    gera(EMPTY_STRING, CEQ, EMPTY_STRING, EMPTY_STRING);
                    break;

                case "!=":
                    gera(EMPTY_STRING, DIF, EMPTY_STRING, EMPTY_STRING);
                    break;

                case ">":
                    gera(EMPTY_STRING, CMA, EMPTY_STRING, EMPTY_STRING);
                    break;

                case ">=":
                    gera(EMPTY_STRING, CMAQ, EMPTY_STRING, EMPTY_STRING);
                    break;

                case "<":
                    gera(EMPTY_STRING, CME, EMPTY_STRING, EMPTY_STRING);
                    break;

                case "<=":
                    gera(EMPTY_STRING, CMEQ, EMPTY_STRING, EMPTY_STRING);
                    break;

                case "e":
                    gera(EMPTY_STRING, AND, EMPTY_STRING, EMPTY_STRING);
                    break;

                case "ou":
                    gera(EMPTY_STRING, OR, EMPTY_STRING, EMPTY_STRING);
                    break;

                case "nao":
                    gera(EMPTY_STRING, NEG, EMPTY_STRING, EMPTY_STRING);
                    break;

                case "+":
                    gera(EMPTY_STRING, ADD, EMPTY_STRING, EMPTY_STRING);
                    break;

                case "+u":
                    break;

                case "-u":
                    gera(EMPTY_STRING, INV, EMPTY_STRING, EMPTY_STRING);
                    break;

                case "-":
                    gera(EMPTY_STRING, SUB, EMPTY_STRING, EMPTY_STRING);
                    break;

                case "verdadeiro":
                    gera(EMPTY_STRING, LDC, "1", EMPTY_STRING);
                    break;

                case "falso":
                    gera(EMPTY_STRING, LDC, "0", EMPTY_STRING);
                    break;

                default:
                    if (field.All(char.IsDigit))
                    {
                        gera(EMPTY_STRING, LDC, field, EMPTY_STRING);
                    }
                    else
                    {
                        Struct structField = Semantico.pesquisaTabela(field, 0);

                        if (structField.nome.Equals(NOME_FUNCAO))
                        {
                            CodeGenerator.gera(EMPTY_STRING, CALL, structField.rotulo.ToString(), EMPTY_STRING);
                            CodeGenerator.gera(EMPTY_STRING, LDV, FUNCTION_RETURN_LABEL, EMPTY_STRING);
                        }
                        else
                        {
                            CodeGenerator.gera(EMPTY_STRING, LDV, structField.rotulo.ToString(), EMPTY_STRING);
                        }
                    }

                    break;
                }
            }
        }