Implementacion de un TAD pila de manera estatica

Ahora les presentare un programa que implementa una pila en C de manera estatica

Los creditos son vienen en el codigo.

/**********************************************************************************
Benitez Morales Octavio Isaías
(C) Febrero 2010 Versión 1.5
Programa que implementa una pila de manera estática II
Compilación: "gcc estatica.c -o Estatica"
Ejecución: "./Estatica (expresion_matematica)"
Basado en: Programa que implementa una pila de manera estática.
Del autor: EDGARDO ADRIÁN FRANCO MARTÍNEZ.

*******************************************************************************/ 
/******************************************************************************
LIBRERIAS INCLUIDAS
*******************************************************************************/
#include
#include
#include
/******************************************************************************
DEFINICIONES DE CONSTANTES
*******************************************************************************/
#define MAX_ELEMENT 60
#define TRUE 1
#define FALSE 0

/******************************************************************************
DEFINICIONES DE TIPOS DE DATO
*******************************************************************************/
//Definir un bool (Se modela con un "int")
typedef int bool;
//Definir un elemento (Se modela con una estructura "elemento")
typedef struct elemento
{
//Variables de la estructura "elemento"
bool z; // nos ayudara a evaluar si la pila esta vacia o llena
char c;
//Puntero a "elemento" para guardar la dirección del "elemento" que se encuentra debajo de la pila
struct elemento *abajo;
}elemento;
//Definir una pila (Se modela con una estructura que unicamente incluye un arreglo de elementos"
//de tamaño MAX_ELEMENT y con un entero para servir como "tope" de la pila guardara el indice del "elemento"
//de la cima dentro de la pila)
typedef struct pila
{
elemento e[MAX_ELEMENT];
int tope;
}pila;
/**************************************************************************
DEFINICIONES DE FUNCIONES
***************************************************************************/
void ini_pila(pila *p); //Inicializar pila (Iniciar una pila para su uso)
void push(pila *p, elemento e); //Empilar (Introducir un elemento a la pila)
elemento pop(pila *p); //Desempilar (Extraer un elemento de la pila)
bool vacia(pila *p); //Vacia (Preguntar si la pila esta vacia)
elemento top(pila *p); //Tope (Obtener el "elemento" del tope de la pila si extraerlo de la pila)
int tam_pila(pila *p); //Tamaño de la pila (Obtener el número de elementos en la pila)
void elimina_pila(pila *p); //Elimina pila (Borra a todos los elementos y a la pila de memoria)
elemento ver(pila *p); //Muestra el estado de la pila
/********************************************************************************
PROGRAMA PRINCIPAL
*********************************************************************************/
int main(int arc, char* argv[])
{
// Declaramos las variables necesarias para la ejecucción del programa
int i; // i sera nuestra variable para la iteracion que se inicializara posteriormente
bool bol; // a nos ayudara para verificar el estado de la pila, si se encuentra vacia o no
char cadena [50]; // cadena sera donde guardaremos la expresion matematica
strcpy(cadena,argv[1]); // usamos la funcion strcpy para copiar la expresion matematica de argv a cadena para manipular de un modo mas eficiente
//Creo una pila "mi_pila"
pila mi_pila;
//Creo dos elementos "m" y "z"
elemento m,z;
//inicializo z con 0 para evitar posibles errores
z.z=0;

//Inicializar "mi_pila"
ini_pila(&mi_pila);
// Comenzamos a buscar los caracteres de ( y )
for(i=0; i<50&&cadena[i]!='\0'; c="cadena[i];" z =" vacia(&mi_pila);" z ="=" m =" pop(&mi_pila);" z =" vacia(&mi_pila);" z ="=">tope=-1;
}

/*****************************************************************************
Operación: PUSH
Recibe: Una referencia a "pila" y un "elemento"
Devuelve:
Observaciones: Se introduce al elemento en la cima de la pila (Tope+1)
******************************************************************************************************/
void push(pila *p, elemento e)
{
p->e[++p->tope]=e;

}

/*****************************************************************************************************
Operación: POP
Recibe: Una referencia a "pila"
Devuelve: El "elemento" de cima de la pila
Observaciones: Se devuelve el elemento del tope y se debe de restar 1 al valor del tope para que indexe
al elemento de debajo en el arreglo
******************************************************************************************************/
elemento pop(pila *p)
{
return p->e[p->tope--];
}

/******************************************************************************************************
Operación: VACIA
Recibe: Una referencia a "pila"
Devuelve: Un "bool" con TRUE si la pila esta vacia o con FALSE en caso contrario
Observaciones:
******************************************************************************************************/
bool vacia(pila *p)
{
//Si el "tope" es -1 la pila esta vacia
if(p->tope==-1)
return TRUE;
//En caso de que tope se diferente de -1 la pila contiene al menos un elemento
else
return FALSE;
}

/*****************************************************************************************************
Operación: TOP
Recibe: Una referencia a "pila"
Devuelve: El "elemento" de cima de la pila
Observaciones: No se mueve el tope
******************************************************************************************************/
elemento top(pila *p)
{
return p->e[p->tope];
}

/******************************************************************************************************
Operación: TAM_PILA
Recibe: Una referencia a "pila"
Devuelve: Un "int" con el número de elementos en la pila
Observaciones: El valor del "tope" + 1 es igual al número de elementos en la pila
******************************************************************************************************/
int tam_pila(pila *p)
{
return p->tope+1;
}

/******************************************************************************************************
Operación: ELIMINA_PILA
Recibe: Una referencia a "pila"
Devuelve:
Observaciones: Se coloca el valor del tope en -1, no se puede como tal eliminar la pila (Estática)
******************************************************************************************************/
void elimina_pila(pila *p)
{
ini_pila(p);
}
/******************************************************************************************************
Operación: VER_PILA
Recibe: Una referencia a "pila"
Devuelve:
Observaciones: Muestra el estado de la pila
******************************************************************************************************/
elemento ver(pila *p)
{
printf("\nValor del tope de la pila=%d",p->tope);
printf("\nTamano de la pila=%d \n",p->tope+1);
}