/*--------------------------------------------------------------------
 * FICHERO:  Vcad.c
 * OBJETIVO: Probar el objeto "Cadena"
 * AUTOR:    Pedro Reina
 * FECHA:    D.6.8.1995
 *------------------------------------------------------------------*/

/*--------------------------------------------------------------------
 * Ficheros de cabecera
 *------------------------------------------------------------------*/

#include "Cadena.h"

/*--------------------------------------------------------------------
 * Declaracin de funciones
 *------------------------------------------------------------------*/

void P_Cad_Cambia();
void P_Cad_CarPertenece();
void P_Cad_Entero();
void P_Cad_Longitud();
void P_Cad_PrimerUtil();
void P_Cad_QuitaCar();
void P_Cad_Subcadena();
void P_Cad_Trozo();
void P_Cad_Une();
void P_Cad_Mueve();
void P_Cad_Igual();
void P_Cad_Duplica();
void P_Cad_Compara();
void P_Cad_Mayus();
void P_Cad_Minus();
void P_Cad_Convierte();
void P_Cad_RecortaFinal();

/*--------------------------------------------------------------------
 * Programa principal
 *------------------------------------------------------------------*/
void main()
  {
  int Opcion, Sigue=1;

  while ( Sigue )
    {
    printf ( "\n\n" );
    printf ( "\nPrueba del objeto Cadena" );
    printf ( "\n========================\n" );

    printf ( "\n0.  Fin del programa" );
    printf ( "\n1.  Cad_Cambia()" );
    printf ( "\n2.  Cad_CarPertenece()" );
    printf ( "\n3.  Cad_Entero()" );
    printf ( "\n4.  Cad_Longitud()" );
    printf ( "\n5.  Cad_PrimerUtil()" );
    printf ( "\n6.  Cad_QuitaCar()" );
    printf ( "\n7.  Cad_Subcadena()" );
    printf ( "\n8.  Cad_Trozo()" );
    printf ( "\n9.  Cad_Une()" );
    printf ( "\n10. Cad_Mueve()" );
    printf ( "\n11. Cad_Igual()" );
    printf ( "\n12. Cad_Duplica()" );
    printf ( "\n13. Cad_Compara()" );
    printf ( "\n14. Cad_Mayus()" );
    printf ( "\n15. Cad_Convierte()" );
    printf ( "\n16. Cad_RecortaFinal()" );

    printf ( "\n\nIntroduce nmero de opcin: " );
    scanf ( "%d", &Opcion );
    getchar();

    switch ( Opcion )
      {
      case 0:   Sigue = 0;                 break;
      case 1:   P_Cad_Cambia();            break;
      case 2:   P_Cad_CarPertenece();      break;
      case 3:   P_Cad_Entero();            break;
      case 4:   P_Cad_Longitud();          break;
      case 5:   P_Cad_PrimerUtil();        break;
      case 6:   P_Cad_QuitaCar();          break;
      case 7:   P_Cad_Subcadena();         break;
      case 8:   P_Cad_Trozo();             break;
      case 9:   P_Cad_Une();               break;
      case 10:  P_Cad_Mueve();             break;
      case 11:  P_Cad_Igual();             break;
      case 12:  P_Cad_Duplica();           break;
      case 13:  P_Cad_Compara();           break;
      case 14:  P_Cad_Mayus();             break;
      case 15:  P_Cad_Convierte();         break;
      case 16:  P_Cad_RecortaFinal();      break;
      }
    }
  }

/*--------------------------------------------------------------------
 * Funcin P_Cad_Cambia()
 *------------------------------------------------------------------*/
void P_Cad_Cambia()
  {
  cadena C;

  printf ( "\n\n" );
  printf ( "\nPrueba de Cad_Cambia()" );
  printf ( "\n----------------------\n" );

  C = Cad_Crea(10);
  Cad_Copia (C,"AABBCdefgh");

  printf ( "\nCadena original: %s",C );
  Cad_Cambia (C,'B','x');
  printf ( "\nCambiando B por x: %s",C );
  Cad_Cambia (C,'a','y');
  printf ( "\nCambiando a por y: %s",C );

  Cad_Destruye (C);

  printf ("\n\nPulsa ENTER para seguir: ");
  getchar();
  }

/*--------------------------------------------------------------------
 * Funcin P_Cad_CarPertenece()
 *------------------------------------------------------------------*/
void P_Cad_CarPertenece()
  {
  char   Car;
  cadena Cad;

  printf ( "\n\n" );
  printf ( "\nPrueba de Cad_CarPertenece()" );
  printf ( "\n--------------------------\n" );

  Cad = "Calabaza", Car = 'a';
  printf ( "\nPosicin de %c en %s: %d",Car,Cad,Cad_CarPertenece(Cad,Car) );

  Cad = "Alianza", Car = 'A';
  printf ( "\nPosicin de %c en %s: %d",Car,Cad,Cad_CarPertenece(Cad,Car) );

  Cad = "Calabaza", Car = 'x';
  printf ( "\nPosicin de %c en %s: %d",Car,Cad,Cad_CarPertenece(Cad,Car) );

  printf ("\n\nPulsa ENTER para seguir: ");
  getchar();
  }

/*--------------------------------------------------------------------
 * Funcin P_Cad_Entero()
 *------------------------------------------------------------------*/
void P_Cad_Entero()
  {
  cadena   Cad;
  contador n;

  printf ( "\n\n" );
  printf ( "\nPrueba de Cad_Entero()" );
  printf ( "\n----------------------\n" );

  n = 12345;
  Cad = Cad_Entero (n);
  printf ( "\nEl nmero %d convertido en cadena: %s", n, Cad );
  Cad_Destruye (Cad);

  n = -30312;
  Cad = Cad_Entero (n);
  printf ( "\nEl nmero %d convertido en cadena: %s", n, Cad );
  Cad_Destruye (Cad);

  printf ("\n\nPulsa ENTER para seguir: ");
  getchar();
  }

/*--------------------------------------------------------------------
 * Funcin P_Cad_Longitud()
 *------------------------------------------------------------------*/
void P_Cad_Longitud()
  {
  cadena   Cad;
  contador n;

  printf ( "\n\n" );
  printf ( "\nPrueba de Cad_Longitud()" );
  printf ( "\n------------------------\n" );

  Cad = "Hola, mundo";
  n = Cad_Longitud (Cad);
  printf ( "\nLongitud de \"%s\": %d", Cad, n );

  Cad = "";
  n = Cad_Longitud (Cad);
  printf ( "\nLongitud de \"%s\": %d", Cad, n );

  Cad = "12345678901234567890";
  n = Cad_Longitud (Cad);
  printf ( "\nLongitud de \"%s\": %d", Cad, n );

  printf ("\n\nPulsa ENTER para seguir: ");
  getchar();
  }

/*--------------------------------------------------------------------
 * Funcin P_Cad_PrimerUtil()
 *------------------------------------------------------------------*/
void P_Cad_PrimerUtil()
  {
  cadena   Cad;
  contador n;

  printf ( "\n\n" );
  printf ( "\nPrueba de Cad_PrimerUtil()" );
  printf ( "\n--------------------------\n" );

  Cad = "Hola, mundo";
  n = Cad_PrimerUtil (Cad);
  printf ( "\nPrimer caracter no blanco de \"%s\": %d", Cad, n );

  Cad = "";
  n = Cad_PrimerUtil (Cad);
  printf ( "\nPrimer caracter no blanco de \"%s\": %d", Cad, n );

  Cad = "   Hey";
  n = Cad_PrimerUtil (Cad);
  printf ( "\nPrimer caracter no blanco de \"%s\": %d", Cad, n );

  printf ("\n\nPulsa ENTER para seguir: ");
  getchar();
  }

/*--------------------------------------------------------------------
 * Funcin P_Cad_QuitaCar()
 *------------------------------------------------------------------*/
void P_Cad_QuitaCar()
  {
  cadena   Cad;
  contador n;

  printf ( "\n\n" );
  printf ( "\nPrueba de Cad_QuitaCar()" );
  printf ( "\n------------------------\n" );

  Cad = Cad_Crea(10);
  Cad_Copia (Cad,"abcdefghij");
  n = 3;
  printf ( "\nSe quita a la cadena \"%s\" el carcter %d: ", Cad, n );
  Cad = Cad_QuitaCar (Cad,n);
  printf ( "%s", Cad );

  Cad_Copia (Cad,"abcdefghij");
  n = 0;
  printf ( "\nSe quita a la cadena \"%s\" el carcter %d: ", Cad, n );
  Cad = Cad_QuitaCar (Cad,n);
  printf ( "%s", Cad );

  Cad_Copia (Cad,"abcdefghij");
  n = 30;
  printf ( "\nSe quita a la cadena \"%s\" el carcter %d: ", Cad, n );
  Cad = Cad_QuitaCar (Cad,n);
  printf ( "%s", Cad );
  Cad_Destruye (Cad);

  printf ("\n\nPulsa ENTER para seguir: ");
  getchar();
  }

/*--------------------------------------------------------------------
 * Funcin P_Cad_Subcadena()
 *------------------------------------------------------------------*/
void P_Cad_Subcadena()
  {
  cadena   C1, C2;
  contador n;

  printf ( "\n\n" );
  printf ( "\nPrueba de Cad_Subcadena()" );
  printf ( "\n-------------------------\n" );

  C1 = "abcdefghij";
  C2 = "def";
  n = Cad_Subcadena (C1,C2);
  printf ( "\nPosicin de \"%s\" dentro de \"%s\": %d: ", C2, C1, n );

  C1 = "abcdefghij";
  C2 = "xef";
  n = Cad_Subcadena (C1,C2);
  printf ( "\nPosicin de \"%s\" dentro de \"%s\": %d: ", C2, C1, n );

  C2 = "abcdefghij";
  C1 = "def";
  n = Cad_Subcadena (C1,C2);
  printf ( "\nPosicin de \"%s\" dentro de \"%s\": %d: ", C2, C1, n );

  printf ("\n\nPulsa ENTER para seguir: ");
  getchar();
  }

/*--------------------------------------------------------------------
 * Funcin P_Cad_Trozo()
 *------------------------------------------------------------------*/
void P_Cad_Trozo()
  {
  cadena   Cad, Trozo;
  contador n1, n2;

  printf ( "\n\n" );
  printf ( "\nPrueba de Cad_Trozo()" );
  printf ( "\n---------------------\n" );

  n1 = 3, n2 = 5;
  Cad = "abcdefghij";
  Trozo = Cad_Trozo (Cad,n1,n2);
  printf ( "\nEl trozo de %d a %d de \"%s\" es: %s", n1, n2, Cad, Trozo );
  Cad_Destruye (Trozo);

  n1 = 3, n2 = 15;
  Cad = "abcdefghij";
  Trozo = Cad_Trozo (Cad,n1,n2);
  printf ( "\nEl trozo de %d a %d de \"%s\" es: %s", n1, n2, Cad, Trozo );
  Cad_Destruye (Trozo);

  n1 = 3, n2 = 3;
  Cad = "abcdefghij";
  Trozo = Cad_Trozo (Cad,n1,n2);
  printf ( "\nEl trozo de %d a %d de \"%s\" es: %s", n1, n2, Cad, Trozo );
  Cad_Destruye (Trozo);

  printf ("\n\nPulsa ENTER para seguir: ");
  getchar();
  }

/*--------------------------------------------------------------------
 * Funcin P_Cad_Une()
 *------------------------------------------------------------------*/
void P_Cad_Une()
  {
  cadena   U, C1, C2, C3;

  printf ( "\n\n" );
  printf ( "\nPrueba de Cad_Une()" );
  printf ( "\n-------------------\n" );

  C1 = "Cadena 1.";
  U = Cad_Une (C1,CAD_FIN);
  printf ( "\nLa unin de \"%s\" es: %s", C1, U );
  Cad_Destruye (U);

  C2 = "Cadena 2.";
  U = Cad_Une (C1,C2,CAD_FIN);
  printf ( "\nLa unin de \"%s\" y \"%s\" es: %s", C1, C2, U );
  Cad_Destruye (U);

  C3 = "Cadena 3.";
  U = Cad_Une (C1,C2,C3,CAD_FIN);
  printf ( "\nLa unin de \"%s\", \"%s\" y \"%s\" es: %s", C1, C2, C3, U );
  Cad_Destruye (U);

  printf ("\n\nPulsa ENTER para seguir: ");
  getchar();
  }

/*--------------------------------------------------------------------
 * Funcin P_Cad_Mueve()
 *------------------------------------------------------------------*/
void P_Cad_Mueve()
  {
  cadena   Cad;
  contador n, Mx;

  printf ( "\n\n" );
  printf ( "\nPrueba de Cad_Mueve()" );
  printf ( "\n---------------------\n" );

  Cad = "abcdefghij";
  n = 3;
  Mx = 20;
  printf ( "\nCadena \"%s\", carcter %d, mximo %d: ", Cad, n, Mx );
  Cad = Cad_Mueve (Cad,n,Mx);
  printf ( "%s", Cad );

  Cad = "abcdefghij";
  n = 20;
  Mx = 20;
  printf ( "\nCadena \"%s\", carcter %d, mximo %d: ", Cad, n, Mx );
  Cad = Cad_Mueve (Cad,n,Mx);
  printf ( "%s", Cad );

  Cad = "abcdefghij";
  n = 2;
  Mx = 5;
  printf ( "\nCadena \"%s\", carcter %d, mximo %d: ", Cad, n, Mx );
  Cad = Cad_Mueve (Cad,n,Mx);
  printf ( "%s", Cad );

  printf ("\n\nPulsa ENTER para seguir: ");
  getchar();
  }

/*--------------------------------------------------------------------
 * Funcin P_Cad_Igual()
 *------------------------------------------------------------------*/
void P_Cad_Igual()
  {
  cadena C1, C2;
  printf ( "\n\n" );
  printf ( "\nPrueba de Cad_Igual()" );
  printf ( "\n---------------------\n" );

  C1 = "Abcde"; C2 = "abcde";
  printf ( "\nSon iguales \"%s\" y \"%s\": %d", C1, C2, Cad_Igual(C1,C2) );

  C1 = "abcde"; C2 = "abcde";
  printf ( "\nSon iguales \"%s\" y \"%s\": %d", C1, C2, Cad_Igual(C1,C2) );

  printf ("\n\nPulsa ENTER para seguir: ");
  getchar();
  }

/*--------------------------------------------------------------------
 * Funcin P_Cad_Duplica()
 *------------------------------------------------------------------*/
void P_Cad_Duplica()
  {
  cadena Cad, CadDup;

  printf ( "\n\n" );
  printf ( "\nPrueba de Cad_Duplica()" );
  printf ( "\n-----------------------\n" );

  Cad = "Hola, mundo";
  CadDup = Cad_Duplica(Cad);
  printf ( "\nOriginal: \"%s\"; duplicado: \"%s\"", Cad, CadDup );
  Cad_Destruye (CadDup);

  printf ("\n\nPulsa ENTER para seguir: ");
  getchar();
  }
  
/*--------------------------------------------------------------------
 * Funcin P_Cad_Compara()
 *------------------------------------------------------------------*/
void P_Cad_Compara()
  {
  cadena C1, C2;

  printf ( "\n\n" );
  printf ( "\nPrueba de Cad_Compara()" );
  printf ( "\n---------------------\n" );

  C1 = "Cao" , C2 = "Cazo" ;
  printf ( "\nComparacin de \"%s\" y \"%s\" -> %d" , 
            C1, C2, Cad_Compara(C1,C2) );

  C1 = "Cama" , C2 = "Camalen" ;
  printf ( "\nComparacin de \"%s\" y \"%s\" -> %d" , 
            C1, C2, Cad_Compara(C1,C2) );

  C1 = "Cspita" , C2 = "Caspita" ;
  printf ( "\nComparacin de \"%s\" y \"%s\" -> %d" , 
            C1, C2, Cad_Compara(C1,C2) );

  C1 = "Mesa" , C2 = "Mrida" ;
  printf ( "\nComparacin de \"%s\" y \"%s\" -> %d" , 
            C1, C2, Cad_Compara(C1,C2) );

  printf ("\n\nPulsa ENTER para seguir: ");
  getchar();
  }
  
/*--------------------------------------------------------------------
 * Funcin P_Cad_Mayus()
 *------------------------------------------------------------------*/
void P_Cad_Mayus()
  {
  cadena   Cad, C1, C2;
  contador n;

  printf ( "\n\n" );
  printf ( "\nPrueba de Cad_Mayus()" );
  printf ( "\n---------------------\n" );

  Cad = "stos, cmpralos para los nios";
  C1 = Cad_Mayus (Cad_Duplica(Cad));
  C2 = Cad_Minus (Cad_Duplica(Cad));
  printf ( "\nCadena original: \"%s\"", Cad );
  printf ( "\nCadena en mayus: \"%s\"", C1 );
  printf ( "\nCadena en minus: \"%s\"", C2 );
  
  Cad_Destruye (C1);
  Cad_Destruye (C2);

  Cad = "     ";
  C1 = Cad_Mayus (Cad_Duplica(Cad));
  C2 = Cad_Minus (Cad_Duplica(Cad));
  printf ( "\n\nCadena original: \"%s\"", Cad );
  printf ( "\nCadena en mayus: \"%s\"", C1 );
  printf ( "\nCadena en minus: \"%s\"", C2 );
  
  Cad_Destruye (C1);
  Cad_Destruye (C2);

  printf ("\n\nPulsa ENTER para seguir: ");
  getchar();
  }

/*--------------------------------------------------------------------
 * Funcin P_Cad_Convierte()
 *------------------------------------------------------------------*/
void P_Cad_Convierte()
  {
  cadena   Cad, C1;
  contador n;

  printf ( "\n\n" );
  printf ( "\nPrueba de Cad_Convierte...()" );
  printf ( "\n--------------------------\n" );

  Cad = "stos, cmpralos para los nios";
  printf ( "\nCadena original: \"%s\"", Cad );

  C1 = Cad_ConvierteQLaPC (Cad_Duplica(Cad));
  printf ( "\nCadena QL -> PC: \"%s\"", C1 );
  Cad_Destruye (C1);

  C1 = Cad_ConviertePCaQL (Cad_Duplica(Cad));
  printf ( "\nCadena PC -> QL: \"%s\"", C1 );
  Cad_Destruye (C1);

  C1 = Cad_ConvierteQLaANSI (Cad_Duplica(Cad));
  printf ( "\nCadena QL -> ANSI: \"%s\"", C1 );
  Cad_Destruye (C1);

  C1 = Cad_ConvierteANSIaQL (Cad_Duplica(Cad));
  printf ( "\nCadena ANSI -> QL: \"%s\"", C1 );
  Cad_Destruye (C1);

  C1 = Cad_ConviertePCaANSI (Cad_Duplica(Cad));
  printf ( "\nCadena PC -> ANSI: \"%s\"", C1 );
  Cad_Destruye (C1);

  C1 = Cad_ConvierteANSIaPC (Cad_Duplica(Cad));
  printf ( "\nCadena ANSI -> PC: \"%s\"", C1 );
  Cad_Destruye (C1);

  printf ("\n\nPulsa ENTER para seguir: ");
  getchar();
  }

/*--------------------------------------------------------------------
 * Funcin P_Cad_RecortaFinal()
 *------------------------------------------------------------------*/
void P_Cad_RecortaFinal()
  {
  cadena   Cad, C1;

  printf ( "\n\n" );
  printf ( "\nPrueba de Cad_RecortaFinal()" );
  printf ( "\n----------------------------\n" );

  Cad = "  Se respira bien    ";
  C1 = Cad_RecortaFinal (Cad_Duplica(Cad));
  printf ( "\nCadena original: \"%s\"", Cad );
  printf ( "\nCadena recortada: \"%s\"", C1 );
  
  Cad_Destruye (C1);

  printf ("\n\nPulsa ENTER para seguir: ");
  getchar();
  }
