tarea pilas y colas

este es el codigo que isimos en clase pero modificado pero me marca un error
(no funciona)

// cabecera de la libreria de matrices

#ifndef final_H

#define final_H

#include <stdio.h> 
#include <stdlib.h> // malloc
#include <limits.h> 
#include <ctype.h> 
#include <string.h> 

#define LARGO_DE_NOMBRE 80
#define SIN_DEFINIR -1
#define LARGO_MAXIMO 12

char pide_opcion(char* permitidos);
int pide_numero(int minimo, int maximo);
void pide_cadena(char* final); 

#endif

#include "final.h"
#include "bool.h"

char pide_opcion(char* permitidos) {
  char actual;
  bool listo = FALSE;

  while (TRUE) {
    if (!listo) {
               actual = tolower(getchar());
               if (strchr(permitidos, actual) != NULL) {
    listo = TRUE;
      } 
    } else {if (getchar() == '\n') {
    if (listo) {
      break;
    }
      }
    }
  }
  return actual;
}

int pide_numero(int minimo, int maximo) {
if(pide_numero < maximo){
return;}
  int numero = SIN_DEFINIR;
  char* final = NULL;
  char actual = NULL;
  int pos;
  double temp;
  
  final = (char*)malloc(sizeof(char)*LARGO_MAXIMO - 1);
  if (final == NULL) {
    return SIN_DEFINIR;
  }
  do {
    printf("Dame un valor entre %d y %d: ",
if(numero > maximo){printf("valor no permitido");}
       minimo, maximo);
    // insistir
    pos = 0;
    do {
      actual = getchar();
      if (pos > LARGO_MAXIMO) {printf("valor no permitido");
    if (isdigit(actual)) {
      final[pos++] = actual;
    }
      }
    } while (actual != '\n'); // brincando enter
    final[pos] = '\0'; 
    temp = atof(final);
    if (temp > INT_MAX - 1) {
      continue;
    }
    numero = atoi(entrada);
  } while (numero < minimo || numero > maximo);
  printf("Gracias.\n");
  free(final);
  return numero;
}

void pide_cadena(char* final) {
  char actual;
  int pos;
  bool ignorar_resto;
  
  do {
    ignorar_resto = FALSE;
    pos = 0;
    actual = getchar();
    if (!isalpha(actual)) {
      ignorar_resto = TRUE;
    } else {
      entrada[pos++] = toupper(actual);}
    do {
      actual = getchar();
      if (pos > LARGO_MAXIMO) {
     {
      entrada[pos++] = toupper(actual)} else {
      if (actual == '\n') {
        break;
      }
      ignorar_resto = false;
    }
      }
    } while (false);
    if (ignorar_resto) {
      pos = 0;
    }
  } while (pos == 0);
  final[pos] = '\0'; 
  printf("Gracias: <%s>\n", final);
  return;
}

**********************************************************************************
PUNTOS EXTRAS:
por si ai algunas personas con la duda todavia de punteros
estos son unos ejemplos mios de como usar punteros espero y  les sean de ayuda->

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

main()
{
     int eco1=2, eco2=3, eco3=4;
     int *puntero1, *puntero2, *puntero3;
     printf("eco1 vale -> %d\n", eco1);
     puntero1 = &eco1;  //el puntero esta apuntando a la variable eco 1 y tratara de modificar su valor//
     *puntero1 = 5; // se le pone el nuevo valor asignado al puntero con direccion a la variable eco1//
     printf("aora eco1 vale-> %d\n", eco1);  /// aqui el valor ya fue cambiado aora "a" vale 5//
     printf("eco2 vale -> %d\n", eco2);
     puntero2 = &eco2;
     *puntero2 = 6;
     printf("aora eco2 vale -> %d\n", eco2);
     printf("eco3 vale -> %d\n", eco3);
     puntero3 = &eco3;
     *puntero3 = 8;
     printf("aora eco3 vale -> %d\n", eco3);
     printf("asi se trabaja con los punteros\n");
    getche();
   
    //esta es una pequeña demostracion de como trabaja un puntero//
              }

------------------------------------------------------------------------------------------------

este otro programa es un puntero apuntando en direccion a una tabla

#include<stdio.h>

main()
{
      int tabla[]={1,2,3,4,5},i;
      int *puntero=tabla; //definimos puntero y le damos la direccion
      for(i=0;i<5;i++)
      {
                      printf("%d",*puntero++);
                      }
                      getche();
                      }

********************************************************************************************************************************************************************
DEFINICION DE PILAS CON ALGUNOS EJEMPLOS 
PILAS:

La pila es una estructura de datos que permite almacenar datos en el orden LIFO (Last In First Out) en español, último en entrar, primero en salir). 
La recuperación de los datos es hecha en el orden inverso de su inserción. 

Para la implementación he elegido una lista enlazada simple, presentada sobre la vertical. 
Ya que la inserción es siempre hecha al inicio de la lista, el 1er elemento de la lista será el ultimo elemento ingresado, por lo tanto estará en la cabeza de la pila. 
No he utilizado un puntero fin, como lo hice en el caso de la lista enlazada simple, ya que el objetivo no es el de tratar una lista enlazada, sino una pila. 
Lo interesante es que el ultimo elemento ingresado, será el 1er elemento recuperado. 

III. La construcción del modelo de un elemento de la pila

Para definir un elemento de la pila será utilizado el tipo struct. 
El elemento de la pila contendrá un campo dato y un puntero siguiente. 
El puntero siguiente debe ser del mismo tipo que el elemento, de lo contrario no podrá apuntar hacia el elemento. 
El puntero siguiente permitirá el acceso al próximo elemento. 

typedef struct ElementoLista {

    char *dato;

    struct ElementoLista *siguiente;

}Elemento;

Para permitir las operaciones sobre la pila, vamos a guardar ciertos elementos:

·         el primer elemento

·         el numero de elementos

El 1er elemento, que se encuentra en la cabeza de la pila, nos permitirá realizar la operación de recuperación de los datos situados en la parte superior de la pila. 

Para ello, será utilizada otra estructura (no es obligatorio, pueden ser utilizadas variables). 

typedef struct ListaUbicación{

  Elemento *inicio;

  int tamaño;

} Pila;

El puntero inicio contendrá la dirección del 1er elemento de la lista. 
La variable tamaño contiene el numero de elementos. 

Nota: 
Esta vez no utilizamos un puntero fin (ver la lista enlazada simple), no lo necesitamos puesto que únicamente trabajamos al inicio de la lista. 

Cualquiera que sea la posición en la lista, el puntero inicio apunta siempre hacia el 1er elemento, que estará en la cabeza de la pila. 
El campo tamaño contendrá el numero de elementos de la pila, cualquiera que sea la operación efectuada sobre la pila. 

A. Inicialización

Modelo de la función: 

void inicialización (Pila *tas);

Esta operación debe ser hecha antes de cualquier otra operación sobre la pila. 
Esta inicializa el puntero inicio con el puntero NULL, y el tamaño con el valor 0. 

La función 

void inicialización (Pila * tas){

  tas->inicio = NULL;

  tas->tamaño = 0;

}

B. Inserción de un elemento en la pila

A continuación el algoritmo de inserción y registro de los elementos:

·         declaración del elemento a insertar

·         asignación de la memoria para el nuevo elemento

·         rellenar el contenido del campo de datos

·         actualizar el puntero inicio hacia el 1er elemento (la cabeza de la pila)

·         Actualizar el tamaño de la pila.

Modelo de la función: 

int apilar (Pila *tas, char *dato);

La primera imagen muestra el inicio de la inserción, por lo tanto la lista de tamaño 1 después de la inserción. La característica de la pila no es muy apreciada con un solo elemento, ya que es el único a recuperar. 

En cambio la 2da imagen nos permite observar el comportamiento de la pila. 
Lo que debemos retener es que la inserción siempre se hace en la parte superior de la pila (al inicio de la lista). 

La función 

/* apilar (añadir) un elemento en la pila */

int apilar (Pila * tas, char *dato){

  Elemento *nuevo_elemento;

  if ((nuevo_elemento = (Elemento *) malloc (sizeof (Elemento))) == NULL)

    return -1;

  if ((nuevo_elemento->dato = (char *) malloc (50 * sizeof (char)))

      == NULL)

    return -1;

  strcpy (nuevo_elemento->dato, dato);

  nuevo_elemento->siguiente = tas->inicio;

  tas->inicio = nuevo_elemento;

  tas->tamaño++;

}

C. Eliminar un elemento de la pila

Para eliminar un elemento de la pila, simplemente hay que eliminar el elemento hacia el cual apunta el puntero inicio. 
Esta operación no permite recuperar el dato en la cabeza de la pila, solo eliminarlo.