LEP com contexto

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#define MaxStackSize 100
#define ContadorPilha 0


/*
Nome: Nycolas Lacerda de Oliveira
Disciplina: Algoritmos e estrutura de dados
Numero EP: 3


*/

int numeral=0;
int resultadoaux=0;
int casosbase[];
char vexpre[20];

typedef struct lista
{
    char conteudo;
    struct lista *prox;
  /*  struct lista *ant; */
} celula;

typedef struct {
   int elements[MaxStackSize];
   int count;
} stackT;

typedef struct{
    int valor;
    celula* lista;

}Contexto;





/*Função auxiliar para adicionar elementos  na lista*/
void addfim(celula **lista, char valor)
{
    celula *pNow, *pNavegar;

    pNavegar = *lista;

    if((pNow = malloc(sizeof(celula))) == NULL)
    {
        printf("\nMemory Failure\n");
    }
    else
    {

        pNow->conteudo = valor;
        pNow->prox = NULL;
        /*pNow->ant = NULL; */
        if(*lista == NULL)
        {
            *lista = pNow;
        }
        else
        {
            while(pNavegar->prox!= NULL)
            {
                pNavegar = pNavegar->prox;
            }

            pNavegar->prox = pNow;
            /*pNow->ant = pNavegar;*/
        }
    }
}
/*Função para preencher a lista*/
void preencher_lista(char vetor[], int n, celula *p)
{
    int i;
    for(i=0; i<n; i++)
    {
       addfim(&p,vetor[i]);
    }

}
/*Operação de empilhar elemento na pilha*/

void Push(stackT *s, int element) {
   if (s->count == MaxStackSize){
        printf( "Stack size exceeded.\n");
      exit( EXIT_FAILURE);
   }
   s->elements[s->count++] = element;
}

/*Função para imprimir elementos da lista*/
void imprimiresquerda(celula *lista)
{
    celula *p;
    p = lista;
    if(p == NULL)
    {
        printf("\nLista Vazia");
    }
    else
    {
       p = p->prox;
        while(p!=NULL)
        {

            printf("%c",p->conteudo);
            p = p->prox;
        }
    }
}


/*Operação de desempilhar elemento do topo da pilha*/
char Pop( stackT *s) {
   if (s->count == 0) {
      printf( "Pop of an empty stack.\n");
      exit( EXIT_FAILURE);
   }
   return s->elements[--s->count];
}
void   ApplyOperator( char op, stackT *s);
void   DisplayStack( stackT* pilha);

/*Função que faz o calculo dos operadores*/
void ApplyOperator( char op, stackT *s)
{
    /*Primeiro operando*/
    int irh = Pop(s);
    /*Segundo operando*/
    int ilh = Pop(s);

    int result;

   switch (op) {
      case '+': result = ilh + irh; break;
      case '-': result = ilh - irh; break;
      case '*': result = ilh * irh; break;
      case '/': result = ilh / irh; break;
      default : printf( "Illegal operator\n");
                exit( EXIT_FAILURE);
   }
   printf( "\n--Resultado dos calculos: %d\n--", result);

   resultadoaux = result;
   Push(s,result);


}


/*Função que imprime o conteudo da pilha*/

void DisplayStack(stackT *pilha)
{
   int i;

   printf( "Stack: ");
   if (pilha->count == 0)
      printf( "empty\n");
   else {
      for (i = 0; i < pilha->count; i++) {
        printf( "%d", pilha->elements[i]);
      }
      printf( "\n");
   }
}

int resolverContexto(int n,celula* lista, celula* listacom, int casosbases[]){
char m[2];
m[1]='\0';
m[0]=lista->prox->conteudo;
/*Numero de chamadas recursivas*/
int num = atoi(m);

int num_bases = strlen(casosbases);

celula* aux;
aux = lista;

/*Pilha de contexto*/
Contexto stackContex[50];
int indexContexto = 0;

stackT* pilhaoperando;
pilhaoperando = malloc(sizeof(stackT));
pilhaoperando->count=0;

if(n<num_bases){
    return casosbases[n];
}


 while (aux->prox!=NULL) {

int digit = n + num;


    printf("\nELEMENTO VISTO NO MOMENTO:%c", aux->conteudo);
   /* CONVERTER PRA INTEIRO O CONTEUDO DA CELULA*/
    if(digit < num_bases){

            if(digit < 0){
                        Push(pilhaoperando,casosbases[0]);
            }else{
                       Push(pilhaoperando,casosbases[digit]);
                    }
    }else if(isdigit(aux->conteudo)){
        Push(pilhaoperando,aux->conteudo);
    }else if(aux->conteudo=='n')
        Push(pilhaoperando,n);
      else if(!(digit < num_bases)){
            stackContex[indexContexto].valor = n;
            stackContex[indexContexto].lista= aux->prox;
            indexContexto++;

            /*Reiniciando a expressão*/
            aux = listacom;
            n = digit;
            continue;
    }
    else if(aux->conteudo == '/' || aux->conteudo == '*' || aux->conteudo == '+' || aux->conteudo == '-'){
        ApplyOperator(aux->conteudo,pilhaoperando);
    }




    if(!aux->prox){
            if(indexContexto > 0){
                int newIndex = indexContexto - 1;
                aux = stackContex[newIndex].lista;
                n = stackContex[newIndex].valor;

                newIndex--;
                continue;
            }
        }


    aux = aux->prox;

    return Pop(pilhaoperando);


}
}

void LEP(){

/*Lendo o arquivo para captar as informações de calculo*/
FILE* arquivo;
arquivo = fopen("lep1.in","r");
char c;
int tam_b;
int n;
int j=0;


    if(arquivo == NULL)
        printf("Arquivo nao encontrando");
      else{

        do{
            fscanf(arquivo, "%d", &tam_b);
        }while((c=getc(arquivo))!= '\n');



        int i=0;
        do{

        fscanf(arquivo,"%d",&casosbase[i]);
        i++;

        }while(i!= tam_b+1 || (c=getc(arquivo))!= '\n');


     /* ERRO ESTÁ OCORRENDO AQUI */

         do{
            c = getc(arquivo);
            vexpre[j] = c;

            j++;

        }while(c != '\n');





         do{
            fscanf(arquivo,"%d",&n);
        }while((c=getc(arquivo))!= EOF);

fclose(arquivo);
}

numeral = n;

 /*ADICIONAR A EXPRESSÃO NA LISTA ENCADEADA*/
  celula *lista;
  lista = malloc (sizeof (celula));
  lista->prox = NULL;
preencher_lista(vexpre,j,lista);
imprimiresquerda(lista);

celula* listaaux;
listaaux = lista->prox;


stackT* pilhaoperando;
pilhaoperando = malloc(sizeof(stackT));
pilhaoperando->count=0;
celula* elemento;
elemento = lista->prox;



int digit;

   /*enquanto não chega no final da lista*/
   /* As vezes a lista armazena lixo, porém o que vale é o ultimo resultado */
   while (elemento->prox!=NULL) {



   printf("\nELEMENTO VISTO NO MOMENTO:%c", elemento->conteudo);
   /* CONVERTER PRA INTEIRO O CONTEUDO DA CELULA*/

        if(elemento->conteudo == 'n'){
            Push(pilhaoperando,numeral);
        }
        if(isdigit(elemento->conteudo)){
            char s1[2];
            s1[1]='\0';
            s1[0]= elemento->conteudo;
            digit = atoi(s1);
            Push(pilhaoperando, digit);
        }

        if(elemento->conteudo == '/' || elemento->conteudo == '*' || elemento->conteudo == '+')
            ApplyOperator(elemento->conteudo,pilhaoperando);
        if(elemento->conteudo == '-'){
            celula* aux;
            aux = elemento->prox;

            if(aux->conteudo==NULL || (!isdigit(aux->conteudo)))
                ApplyOperator(elemento->conteudo,pilhaoperando);
            else{
                /* PARAR A EXECUÇÃO, E RESOLVER AS CHAMADAS RECURSIVAS*/
                 int calccontexto = resolverContexto(numeral,elemento,listaaux,casosbase);
                 Push(pilhaoperando, calccontexto);
                 elemento = elemento->prox;
                }

      }

      elemento = elemento->prox;


}

}






int main( void)
{
  LEP();

}