/******************************************************************************
 * Universidade Federal da Paraíba (U.F.P.B)                                  *
 * Estrutura de Dados                                                         *
 * Professora: Liliane dos Santos Machado                                     *
 * Aluno: Vinícius Antônio Campos Fagundes                                    *
 * Matrícula: 10921059                                                        *
 * Data: 28 de Outubro de 2010(28/10/2010)                                    *
 *----------------------------------------------------------------------------*
 * Apresentação do projeto:                                                   *
 * 1ª Parte do projeto. Aqui foi construída a biblioteca da pilha. As funções *
 * serão para criar uma pilha, adicionar elementos nela, remover elementos,   *
 * verificar se a pilha está vazia e liberar a pilha                          *
 * PS: a função imprime_pilha foi implementada apenas para conferir os        *
 * resultados, seguindo estritamente os conceitos de pilha, esta função não   *
 * deve ser implementada.                                                     *
 ******************************************************************************/

#include <stdio.h>
#include <stdlib.h>

struct no{         // Estrutura que representará os nós da lista
        char info;
        struct no *prox;
        };

struct pilha{      // Estrutura que representará um ponteiro para o primeiro
        struct no *prim;   // elemento da lista.
        };

/******************************************************************************/

/* Protótipos */
void LimpaBuffer(void);
struct pilha* cria_pilha(void);
void push(struct pilha *pile, char valor);
void pop(struct pilha *pile);
void pilha_vazia(struct pilha *pile);
void libera_pilha(struct pilha *pile);

/******************************************************************************/

void LimpaBuffer(void){
     int valorLido;
     do{
         valorLido = getchar();
         }while((valorLido != '\n') && (valorLido != EOF));
}

/******************************************************************************/

/* Função para a criação da Pilha */
struct pilha* cria_pilha(void){
     struct pilha *pile;    // Cria um ponteiro que apontará para o primeiro
                            // elemento da lista.
     pile = (struct pilha*)malloc(sizeof(struct pilha)); // Aloca espaço para ele
     pile->prim = NULL;                         // e inicia ele com NULL
     return pile;
}

/******************************************************************************/

/* Função para adicionar elementos na Pilha */
void push(struct pilha *pile, char valor){
     struct no *novo; // Cria o novo elemento.
     novo = (struct no*)malloc(sizeof(struct no)); // Aloca espaço para ele.
     novo->info = valor;          // Atribui o valor que será inserido ao campo
                                  // info da estrutura.
     novo->prox = pile->prim;   // Faz o elemento que será inserido apontar
                                // para onde prim aponta.
     pile->prim = novo;    // Faz prim apontar para o novo elemento, tornanando
                           // este o novo primeiro elemento da pilha.
}

/******************************************************************************/

/* Função para remover o elemento do topo da Pilha */
/* Eventual transtorno como no caso de a Pilha estiver vazia foi tratado */
void pop(struct pilha *pile){
     if(!(pile->prim)) printf("\n=> Pilha Vazia !"); // Caso a pilha esteja
                       // vazia, emita uma mensagem de advertência.

     else{             // Caso contrário..
          struct no *rem;        // Crie uma variável que
          rem = pile->prim;      // apontará para o primeiro elemento da lista.
          pile->prim = rem->prox;  // Faça o ponteiro da pilha apontar então
                                   // para o segundo elemento da lista.
          rem->prox = NULL; // Tire o apontamento do primeiro elemento.
          printf("\n=> O elemento %c foi removido com sucesso !",rem->info);
          free(rem); // Remova-o.
          if(!(pile->prim))  printf("\n=> Pilha Vazia\n=> Parabens!!");
     }
}

/******************************************************************************/

/* Função para verificar se a Pilha está vazia */
void pilha_vazia(struct pilha *pile){
     if(!(pile->prim))  printf("\n=> Pilha Vazia\n=> Parabens!!");
     else               printf("\n=> Erro: Pilha nao Vazia !");
}

/******************************************************************************/

/* Função para liberar a Pilha */
void libera_pilha(struct pilha *pile){
     free(pile);
     }

/******************************************************************************/

/* Função para imprimir os elementos da Pilha */
void imprime_pilha(struct pilha *pile){
     if(!(pile->prim))    printf("\n=> Pilha Vazia !");
     else{
          int i = 1;  // Variável para indicar as posições dos elementos
                      // de cima à baixo
          struct no *var;  // Ponteiro para varrer a lista
          for(var = pile->prim ; var ; var = var->prox, i++){
             printf("\n=> %do Elemento: %c",i,var->info);
             }
          }
}

/******************************************************************************/

/* Função para imprimir os elementos da Pilha */
/* Esta sim, pode ser implementada seguindo os conceitos de Pilha */
/* Nesta daqui, após consultar o elemento do topo, ele é apagado para que se */
/* possa consultar o elemento posterior, e assim sucessivamente */
void imprime_true_pilha(struct pilha *pile){
     if(!(pile->prim))         printf("\n=> Pilha Vazia !");
     else{
          int i = 1;  // Variável para indicar as posições dos elementos de cima
                      // à baixo
          struct no *varre;  // Ponteiro que irá varrer a Pilha
          for(varre = pile->prim ; varre ; i++){
                    printf("\n=> %do Elemento: %c",i,varre->info);
                    varre = varre->prox;
                    pop(pile);
                    printf("\n");
          // Cada elemento que é lido, em seguida é apagado, seguindo assim os
          //n conceitos de pilha.
                    }
          }
}

/******************************************************************************/