C anotação polonesa não funcionando, queria entender o porque

[GabrielVilhenaMagri]

<#include <string.h>
#include <stdio.h>

#define TAMANHO_MAXIMO_DE_PILHA 100
#define TAMANHO_MAXIMO_DE_FILA  100

typedef struct {
    char pedaco [21];
} Elemento;

typedef struct {
    Elemento vetor_de_elementos [TAMANHO_MAXIMO_DE_PILHA];
    int      posicao_do_ultimo_elemento;
    int      topo;
} Pilha;

typedef struct {
    Elemento vetor_de_Elementos [TAMANHO_MAXIMO_DE_FILA];
    int      posicao_do_ultimo_Elemento;
} Fila;

void inicialize_a_pilha (Pilha* p)
{
    (*p).posicao_do_ultimo_elemento=-1;
}

unsigned char /*boolean*/ pilha_vazia (Pilha p)
{
    if (p.posicao_do_ultimo_elemento==-1)
    {
        printf("Infelizmente sua pilha esta vazia");
        return 1/*true*/;
    }
    else
    {
        printf("felizmente sua pilha não esta vazia");
        return 0/*false*/;
    }
}

unsigned char /*boolean*/ pilha_cheia (Pilha p)
{
    if (p.posicao_do_ultimo_elemento==TAMANHO_MAXIMO_DE_PILHA-1)
        return 1/*true*/;
    else
        return 0/*false*/;
}

void guarde_item_na_pilha (Pilha* p, Elemento e)
{
    (*p).posicao_do_ultimo_elemento++;
    (*p).vetor_de_elementos[(*p).posicao_do_ultimo_elemento] = e;
}

Elemento  recupere_um_item_da_pilha (Pilha p ){

   return p.vetor_de_elementos[p.posicao_do_ultimo_elemento];
}

void remova_um_item_da_pilha (Pilha* p)
{
    (*p).posicao_do_ultimo_elemento--;
}

void inicialize_a_fila (Fila* f)
{
    (*f).posicao_do_ultimo_Elemento=-1;
}

unsigned char fila_vazia (Fila f)
{
    if (f.posicao_do_ultimo_Elemento==-1)
        {
            printf("Infelizmente sua pilha esta vazia");
            return 1/*true*/;
        }
    else
    {
        printf("felizmente sua fila não esta vazia");
        return 0/*false*/;

    }
}

unsigned char  fila_cheia (Fila f)
{
    if (f.posicao_do_ultimo_Elemento==TAMANHO_MAXIMO_DE_FILA-1)
        return 1/*true*/;
    else
        return 0/*false*/;
}

void guarde_item_na_fila (Fila* f, Elemento e)
{
    (*f).posicao_do_ultimo_Elemento++;
    (*f).vetor_de_Elementos[(*f).posicao_do_ultimo_Elemento] = e;
}

Elemento recupere_um_item_da_fila (Fila f)
{
    return f.vetor_de_Elementos[f.posicao_do_ultimo_Elemento];
}

void remova_um_item_da_fila (Fila* f)
{
    int i;

    for (i=1; i<=(*f).posicao_do_ultimo_Elemento; i++)
        (*f).vetor_de_Elementos [i-1]=(*f).vetor_de_Elementos [i];

    (*f).posicao_do_ultimo_Elemento--;
}

unsigned char  so_tem_chars_validos (char expressao [201])
{
    unsigned int i, tamanho=strlen(expressao)-1;

    for (i=0; i<tamanho; i++){
        if (strchr("(^*/+-) .0123456789",expressao[i])==NULL){
            printf("expressão invalida!");
            return 0;
        }
    }

    return 1/*true*/;
}
unsigned char posso_desempilhar (Elemento *doTopoDaPilha, char daSequencia)
{
    int i,j;
    int linha, coluna;
    char char_validos [7] = "(^/+-)";
    unsigned char tabela [7][7] = {{0,0,0,0,0,0,1},
                                   {0,0,1,1,1,1,1},
                                   {0,0,1,1,1,1,1},
                                   {0,0,1,1,1,1,1},
                                   {0,0,0,0,1,1,1},
                                   {0,0,0,0,1,1,1},
                                   {0,0,0,0,0,0,0}};

    for(i=0;i<7;i++){
        if(char_validos[i] == doTopoDaPilha){
            linha = i;
        }
    }
    for(j=0;j<7;j++){
        if(char_validos[j] == daSequencia){
            coluna = j;
        }
    }

    return tabela[linha][coluna];
}

unsigned char  parenteses_balanceados (char expressao [201])
{
    unsigned int i, tamanho=strlen(expressao)-1, qtd_parenteses_abertos=0;

    for (i=0; i<tamanho; i++)
        if (expressao[i]=='(')
            qtd_parenteses_abertos++;
        else if (expressao[i]==')')
            if (qtd_parenteses_abertos==0){
                printf("expressão invalida! ");
                return 0/*false*/;
            }
            else{
               qtd_parenteses_abertos--;
            }

    if (qtd_parenteses_abertos!=0){
        printf("expressão invalida! ");
        return 0/*false*/;
    }
    else{
        return 1/*true*/;
    }
}

void elimine_espacos (char expressao [], int pos)
{

    char* string_comecando_no_1o_espaco=strchr(expressao,' ');

    while (pos!=-1)
    {
        memmove(string_comecando_no_1o_espaco,string_comecando_no_1o_espaco+1,strlen(string_comecando_no_1o_espaco+1));
        string_comecando_no_1o_espaco=strchr(expressao,' ');
    }
}

void obtem_pedaco (char expressao[], char pedaco[], int* pos)
{
    int i=0; // 1,2

    if (expressao[*pos]>='0' && expressao[*pos]<='9')
    {
        while (expressao[*pos]>='0' && expressao[*pos]<='9')
        {
            pedaco[i]=expressao[*pos];
            i++;
            (*pos)++;
        }
        pedaco[i]='\0';
    }
    else
    {
            pedaco[i]=expressao[*pos];
            i++;
            (*pos)++;
            pedaco[i]='\0';
    }
}

int main ()
{
    char item_fila;
    char item_fila_numero;
    Elemento elem;
    Pilha operadoresPilha;
    Fila expressaoFila,numerosFila,saidaFila;
    int i,n,x,y,g;
    char expressao [201] = "";
    char pedaco [21]; // "20"
    int  pos=0; // 1,2,3,4,5
    int verificacao = 0;
    int verificacaoParenteses = 0;
    int tamanhoNumerosFila;
    int tamanhoPilha;
    int verificaPilha;
    char possodesempilhar;
    Elemento ultimoElemento;
    int tamanhoFilaNumero;
    int tamanhoPilhaOperador;
    int tamanhoFilaSaida;
    char parenteses_fechados[1] = ")";
    char parenteses_abertos[1] = "(" ;
    

    inicialize_a_fila(&expressaoFila);
    inicialize_a_fila(&numerosFila);
    inicialize_a_fila(&saidaFila);
    inicialize_a_pilha(&operadoresPilha);

    while(verificacao == 0 || verificacaoParenteses == 0)
    {
        printf(" Digite a sua expressão: ");
        fgets(expressao,200,stdin);
        verificacao = so_tem_chars_validos(expressao);
        verificacaoParenteses = parenteses_balanceados(expressao);
    }
    
    
    int tamanho = strlen(expressao);
    for(i=0;i<=tamanho+2;i++)
        {
            obtem_pedaco (expressao,pedaco,&i);
            strcpy(elem.pedaco,pedaco);
            if (pedaco>='0' && pedaco<='9' || pedaco == '.')
            {
                if( i ==  tamanho-1)
                {
                    guarde_item_na_fila(&saidaFila,elem);
                }
                else
                {
                    guarde_item_na_fila(&numerosFila,elem);
                }
            }
            else{
                tamanhoNumerosFila = numerosFila.vetor_de_Elementos;
                for(x=0;x<tamanhoNumerosFila;x++){
                    if (pedaco>='0' && pedaco<='9' || pedaco == '.'){
                        guarde_item_na_fila(&saidaFila,elem);
                        remova_um_item_da_fila(&numerosFila);
                        }
                    }
                }
                verificaPilha = operadoresPilha.vetor_de_elementos;
                if(pedaco == parenteses_fechados[0]){
                    while(g==1){
                        if(verificaPilha != parenteses_abertos[0]){
                            guarde_item_na_fila(&saidaFila, elem);
                            remova_um_item_da_pilha(&operadoresPilha);
                        }
                        else{
                            remova_um_item_da_pilha(&operadoresPilha);
                            g = 0;
                        }
                    }
                }
                 else{
                        tamanhoPilha = operadoresPilha.vetor_de_elementos;
                        if(tamanhoPilha == 0){
                            guarde_item_na_pilha(&operadoresPilha,elem);
                        }
                        
                        else{
                            while(tamanhoPilha > 0){
                                ultimoElemento = recupere_um_item_da_pilha (operadoresPilha);
                                possodesempilhar = posso_desempilhar(&ultimoElemento,pedaco);
                                if(possodesempilhar == 1 && tamanhoPilha > 0){
                                    remova_um_item_da_pilha(&operadoresPilha);
                                    guarde_item_na_fila(&saidaFila,elem);
                                    tamanhoPilha = tamanhoPilha - 1;
                                }
                                else if(possodesempilhar == 1 && tamanhoPilha == 0){
                                    guarde_item_na_pilha(&operadoresPilha,elem);
                                    tamanhoPilha = tamanhoPilha - 1;
                                }
                                else{
                                    guarde_item_na_pilha(&operadoresPilha,elem);
                                    tamanhoPilha = tamanhoPilha - 1;
                                }
                            }
                        }
                            
                    }
                }
                tamanhoFilaNumero = numerosFila.vetor_de_Elementos;
                if( tamanhoFilaNumero > 0 ){
                    for(i=0;i<tamanhoFilaNumero;i++){
                        guarde_item_na_fila(&saidaFila, elem);
                        remova_um_item_da_fila(&numerosFila);
                    }
                }
                
                tamanhoPilhaOperador = operadoresPilha.vetor_de_elementos;
                if( tamanhoPilhaOperador > 0){
                    for(i=0;i<tamanhoPilhaOperador;i++){
                        guarde_item_na_fila(&saidaFila, elem);
                        remova_um_item_da_pilha(&operadoresPilha);
                    }
                }
                tamanhoFilaSaida = saidaFila.vetor_de_Elementos;
                for(i=0;i<tamanhoFilaSaida;i++){
                    printf("%c",recupere_um_item_da_fila(saidaFila));
                }
    return 0;
}>
 

[arfneto]

x.c(145,45): warning C4047: '==': 'int' differs in levels of indirection from 'Elemento *'
x.c(264,27): warning C4047: '>=': 'char [21]' differs in levels of indirection from 'int'
x.c(264,44): warning C4047: '<=': 'char [21]' differs in levels of indirection from 'int'
x.c(264,60): warning C4047: '==': 'char [21]' differs in levels of indirection from 'int'
x.c(277,64): warning C4047: '=': 'int' differs in levels of indirection from 'Elemento *'
x.c(280,35): warning C4047: '>=': 'char [21]' differs in levels of indirection from 'int'
x.c(280,52): warning C4047: '<=': 'char [21]' differs in levels of indirection from 'int'
x.c(280,68): warning C4047: '==': 'char [21]' differs in levels of indirection from 'int'
x.c(287,59): warning C4047: '=': 'int' differs in levels of indirection from 'Elemento *'
x.c(288,45): warning C4047: '==': 'char [21]' differs in levels of indirection from 'int'
x.c(306,62): warning C4047: '=': 'int' differs in levels of indirection from 'Elemento *'
x.c(319,66): warning C4047: 'function': 'char' differs in levels of indirection from 'char [21]'
x.c(319,60): warning C4024: 'posso_desempilhar': different types for formal and actual parameter 2
x.c(340,55): warning C4047: '=': 'int' differs in levels of indirection from 'Elemento *'
x.c(350,62): warning C4047: '=': 'int' differs in levels of indirection from 'Elemento *'
x.c(359,52): warning C4047: '=': 'int' differs in levels of indirection from 'Elemento *'
x.c(362,16): warning C4477: 'printf' : format string '%c' requires an argument of type \
  'int', but variadic argument 1 has type 'Elemento'
x.c(224,14): warning C4101: 'item_fila': unreferenced local variable
x.c(229,23): warning C4101: 'y': unreferenced local variable
x.c(225,14): warning C4101: 'item_fila_numero': unreferenced local variable
x.c(229,17): warning C4101: 'n': unreferenced local variable
x.c(290): error C4700: uninitialized local variable 'g' used

 

Sobre esses erros: acho que deve olhar um a um

 

Use o tal botão code como explicado no forum...

 

Veja a diferença

 

#include<string.h>
#include <stdio.h>

#define TAMANHO_MAXIMO_DE_PILHA 100
#define TAMANHO_MAXIMO_DE_FILA 100

    typedef struct
{
    char pedaco[21];
} Elemento;

typedef struct
{
    Elemento vetor_de_elementos[TAMANHO_MAXIMO_DE_PILHA];
    int      posicao_do_ultimo_elemento;
    int      topo;
} Pilha;

typedef struct
{
    Elemento vetor_de_Elementos[TAMANHO_MAXIMO_DE_FILA];
    int      posicao_do_ultimo_Elemento;
} Fila;

void inicialize_a_pilha(Pilha* p)
{
    (*p).posicao_do_ultimo_elemento = -1;
}

unsigned char /*boolean*/ pilha_vazia(Pilha p)
{
    if (p.posicao_do_ultimo_elemento == -1)
    {
        printf("Infelizmente sua pilha esta vazia");
        return 1 /*true*/;
    }
    else
    {
        printf("felizmente sua pilha não esta vazia");
        return 0 /*false*/;
    }
}

unsigned char /*boolean*/ pilha_cheia(Pilha p)
{
    if (p.posicao_do_ultimo_elemento == TAMANHO_MAXIMO_DE_PILHA - 1)
        return 1 /*true*/;
    else
        return 0 /*false*/;
}

void guarde_item_na_pilha(Pilha* p, Elemento e)
{
    (*p).posicao_do_ultimo_elemento++;
    (*p).vetor_de_elementos[(*p).posicao_do_ultimo_elemento] = e;
}

Elemento recupere_um_item_da_pilha(Pilha p)
{
    return p.vetor_de_elementos[p.posicao_do_ultimo_elemento];
}

void remova_um_item_da_pilha(Pilha* p)
{
    (*p).posicao_do_ultimo_elemento--;
}

void inicialize_a_fila(Fila* f)
{
    (*f).posicao_do_ultimo_Elemento = -1;
}

unsigned char fila_vazia(Fila f)
{
    if (f.posicao_do_ultimo_Elemento == -1)
    {
        printf("Infelizmente sua pilha esta vazia");
        return 1 /*true*/;
    }
    else
    {
        printf("felizmente sua fila não esta vazia");
        return 0 /*false*/;
    }
}

unsigned char fila_cheia(Fila f)
{
    if (f.posicao_do_ultimo_Elemento == TAMANHO_MAXIMO_DE_FILA - 1)
        return 1 /*true*/;
    else
        return 0 /*false*/;
}

void guarde_item_na_fila(Fila* f, Elemento e)
{
    (*f).posicao_do_ultimo_Elemento++;
    (*f).vetor_de_Elementos[(*f).posicao_do_ultimo_Elemento] = e;
}

Elemento recupere_um_item_da_fila(Fila f)
{
    return f.vetor_de_Elementos[f.posicao_do_ultimo_Elemento];
}

void remova_um_item_da_fila(Fila* f)
{
    int i;

    for (i = 1; i <= (*f).posicao_do_ultimo_Elemento; i++)
        (*f).vetor_de_Elementos[i - 1] = (*f).vetor_de_Elementos[i];

    (*f).posicao_do_ultimo_Elemento--;
}

unsigned char so_tem_chars_validos(char expressao[201])
{
    unsigned int i, tamanho = strlen(expressao) - 1;

    for (i = 0; i < tamanho; i++)
    {
        if (strchr("(^*/+-) .0123456789", expressao[i]) == NULL)
        {
            printf("expressão invalida!");
            return 0;
        }
    }

    return 1 /*true*/;
}
unsigned char posso_desempilhar(
    Elemento* doTopoDaPilha, char daSequencia)
{
    int           i, j;
    int           linha, coluna;
    char          char_validos[7] = "(^/+-)";
    unsigned char tabela[7][7]    = {
        {0, 0, 0, 0, 0, 0, 1}, {0, 0, 1, 1, 1, 1, 1},
        {0, 0, 1, 1, 1, 1, 1}, {0, 0, 1, 1, 1, 1, 1},
        {0, 0, 0, 0, 1, 1, 1}, {0, 0, 0, 0, 1, 1, 1},
        {0, 0, 0, 0, 0, 0, 0}};

    for (i = 0; i < 7; i++)
    {
        if (char_validos[i] == doTopoDaPilha) { linha = i; }
    }
    for (j = 0; j < 7; j++)
    {
        if (char_validos[j] == daSequencia) { coluna = j; }
    }

    return tabela[linha][coluna];
}

unsigned char parenteses_balanceados(char expressao[201])
{
    unsigned int i, tamanho = strlen(expressao) - 1,
                    qtd_parenteses_abertos = 0;

    for (i = 0; i < tamanho; i++)
        if (expressao[i] == '(')
            qtd_parenteses_abertos++;
        else if (expressao[i] == ')')
            if (qtd_parenteses_abertos == 0)
            {
                printf("expressão invalida! ");
                return 0 /*false*/;
            }
            else
            {
                qtd_parenteses_abertos--;
            }

    if (qtd_parenteses_abertos != 0)
    {
        printf("expressão invalida! ");
        return 0 /*false*/;
    }
    else
    {
        return 1 /*true*/;
    }
}

void elimine_espacos(char expressao[], int pos)
{
    char* string_comecando_no_1o_espaco = strchr(expressao, ' ');

    while (pos != -1)
    {
        memmove(
            string_comecando_no_1o_espaco,
            string_comecando_no_1o_espaco + 1,
            strlen(string_comecando_no_1o_espaco + 1));
        string_comecando_no_1o_espaco = strchr(expressao, ' ');
    }
}

void obtem_pedaco(char expressao[], char pedaco[], int* pos)
{
    int i = 0;  // 1,2

    if (expressao[*pos] >= '0' && expressao[*pos] <= '9')
    {
        while (expressao[*pos] >= '0' && expressao[*pos] <= '9')
        {
            pedaco[i] = expressao[*pos];
            i++;
            (*pos)++;
        }
        pedaco[i] = '\0';
    }
    else
    {
        pedaco[i] = expressao[*pos];
        i++;
        (*pos)++;
        pedaco[i] = '\0';
    }
}

int main()
{
    char     item_fila;
    char     item_fila_numero;
    Elemento elem;
    Pilha    operadoresPilha;
    Fila     expressaoFila, numerosFila, saidaFila;
    int      i, n, x, y, g;
    char     expressao[201] = "";
    char     pedaco[21];                 // "20"
    int      pos                   = 0;  // 1,2,3,4,5
    int      verificacao           = 0;
    int      verificacaoParenteses = 0;
    int      tamanhoNumerosFila;
    int      tamanhoPilha;
    int      verificaPilha;
    char     possodesempilhar;
    Elemento ultimoElemento;
    int      tamanhoFilaNumero;
    int      tamanhoPilhaOperador;
    int      tamanhoFilaSaida;
    char     parenteses_fechados[1] = ")";
    char     parenteses_abertos[1]  = "(";

    inicialize_a_fila(&expressaoFila);
    inicialize_a_fila(&numerosFila);
    inicialize_a_fila(&saidaFila);
    inicialize_a_pilha(&operadoresPilha);

    while (verificacao == 0 || verificacaoParenteses == 0)
    {
        printf(" Digite a sua expressão: ");
        fgets(expressao, 200, stdin);
        verificacao           = so_tem_chars_validos(expressao);
        verificacaoParenteses = parenteses_balanceados(expressao);
    }

    int tamanho = strlen(expressao);
    for (i = 0; i <= tamanho + 2; i++)
    {
        obtem_pedaco(expressao, pedaco, &i);
        strcpy(elem.pedaco, pedaco);
        if (pedaco >= '0' && pedaco <= '9' || pedaco == '.')
        {
            if (i == tamanho - 1)
            {
                guarde_item_na_fila(&saidaFila, elem);
            }
            else
            {
                guarde_item_na_fila(&numerosFila, elem);
            }
        }
        else
        {
            tamanhoNumerosFila = numerosFila.vetor_de_Elementos;
            for (x = 0; x < tamanhoNumerosFila; x++)
            {
                if (pedaco >= '0' && pedaco <= '9' || pedaco == '.')
                {
                    guarde_item_na_fila(&saidaFila, elem);
                    remova_um_item_da_fila(&numerosFila);
                }
            }
        }
        verificaPilha = operadoresPilha.vetor_de_elementos;
        if (pedaco == parenteses_fechados[0])
        {
            while (g == 1)
            {
                if (verificaPilha != parenteses_abertos[0])
                {
                    guarde_item_na_fila(&saidaFila, elem);
                    remova_um_item_da_pilha(&operadoresPilha);
                }
                else
                {
                    remova_um_item_da_pilha(&operadoresPilha);
                    g = 0;
                }
            }
        }
        else
        {
            tamanhoPilha = operadoresPilha.vetor_de_elementos;
            if (tamanhoPilha == 0)
            {
                guarde_item_na_pilha(&operadoresPilha, elem);
            }

            else
            {
                while (tamanhoPilha > 0)
                {
                    ultimoElemento =
                        recupere_um_item_da_pilha(operadoresPilha);
                    possodesempilhar =
                        posso_desempilhar(&ultimoElemento, pedaco);
                    if (possodesempilhar == 1 && tamanhoPilha > 0)
                    {
                        remova_um_item_da_pilha(&operadoresPilha);
                        guarde_item_na_fila(&saidaFila, elem);
                        tamanhoPilha = tamanhoPilha - 1;
                    }
                    else if (possodesempilhar == 1 && tamanhoPilha == 0)
                    {
                        guarde_item_na_pilha(&operadoresPilha, elem);
                        tamanhoPilha = tamanhoPilha - 1;
                    }
                    else
                    {
                        guarde_item_na_pilha(&operadoresPilha, elem);
                        tamanhoPilha = tamanhoPilha - 1;
                    }
                }
            }
        }
    }
    tamanhoFilaNumero = numerosFila.vetor_de_Elementos;
    if (tamanhoFilaNumero > 0)
    {
        for (i = 0; i < tamanhoFilaNumero; i++)
        {
            guarde_item_na_fila(&saidaFila, elem);
            remova_um_item_da_fila(&numerosFila);
        }
    }

    tamanhoPilhaOperador = operadoresPilha.vetor_de_elementos;
    if (tamanhoPilhaOperador > 0)
    {
        for (i = 0; i < tamanhoPilhaOperador; i++)
        {
            guarde_item_na_fila(&saidaFila, elem);
            remova_um_item_da_pilha(&operadoresPilha);
        }
    }
    tamanhoFilaSaida = saidaFila.vetor_de_Elementos;
    for (i = 0; i < tamanhoFilaSaida; i++)
    {
        printf("%c", recupere_um_item_da_fila(saidaFila));
    }
    return 0;
}  //

 

Sobre o programa

 

        if (char_validos[i] == doTopoDaPilha) { linha = i; }

 

Tem muito disso no código. Pode estar certo mas não parece nada bom. doTopodaPilha é um ponteiro para Elemento, que coeça por pedaco que é char[21]

 

O layout de pilha e fila está ok mas seria melhor se fosse mais genérico, tivesse o tamanho da estruturainclluído e não tivesse esses nomes gigantes... Não estaria bem com final, rabo, tail? precisa de   posicao_do_ultimo_elemento com mais de 25 letras?

 

Evite retornar void.

 

void inicialize_a_pilha(Pilha* p)

 

é mais claro e versátil como

 

Pilha*   inicia_pilha(unsigned size);

 

por exemplo, onde pode especificar o tamanho do vetor que vai conter a pilha e retorna o endereço dela...

                    ultimoElemento =
                        recupere_um_item_da_pilha(operadoresPilha);
                    possodesempilhar =
                        posso_desempilhar(&ultimoElemento, pedaco);

 

diferenciar variáveis com nomes enormes por um '_' ? Não faça isso. Se alguém vai te dar uma nota por isso certamente vai ser penalizado.

 

	remova_um_item_da_pilha();
	guarde_item_na_fila();
	guarde_item_na_pilha();

 

Essas coisas já tem nomes consagrados: pop, push, top. Talvez deva manter...

 

Procure manter seus dados em um primeiro nível, a expressão é o seu dado. E as estruturas de dados mais ocultas.

 

Ao ler main() deve ser possível entender que avaliar uma expressão RPN do modo como está fazendo --- não vi com muito detalhe --- implica em processar a expressão da esquerda para a direita e usar a pilha para processar resultados intermediários. E considere que a os parenteses serão avaliados como outra expressão e isso pode ser uma simples recursão. Recursão e pilha são caminhos para esse caso.