/*--------------------------------------------------------------------
 * FICHERO:  Vmem.c
 * OBJETIVO: Probar el objeto Memoria
 * AUTOR:    Pedro Reina
 * FECHA:    S.1.7.1995
 *------------------------------------------------------------------*/

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

#include "Memoria.h"

/*--------------------------------------------------------------------
 * Definicin de macros constantes
 *------------------------------------------------------------------*/

   /* Ninguno */

/*--------------------------------------------------------------------
 * Definicin de variables globales
 *------------------------------------------------------------------*/

   /* Ninguna */

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

void P_Mem_Crea();
void P_Mem_Ajusta();
void P_Mem_Asigna();
void P_Mem_Copia();
void P_Mem_Octeto();
void P_Mem_Menudo();
void P_Mem_Intercambia();
void P_Mem_IntercambiaLarga();
void P_Mem_Contpos();
void P_Mem_Contador();
void P_Mem_Entpos();
void P_Mem_Entero();

/*--------------------------------------------------------------------
 * Definicin de macros funciones
 *------------------------------------------------------------------*/

   /* Ninguno */

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

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

    printf ( "\n0. Fin del programa" );
    printf ( "\n1. Mem_Crea() y Mem_Destruye()" );
    printf ( "\n2. Mem_Asigna()" );
    printf ( "\n3. Mem_Ajusta()" );
    printf ( "\n4. Mem_Copia()" );
    printf ( "\n5. Mem_Octeto()" );
    printf ( "\n6. Mem_Menudo()" );
    printf ( "\n7. Mem_Intercambia()" );
    printf ( "\n8. Mem_IntercambiaLarga()" );
    printf ( "\n9. Mem_Contpos()" );
    printf ( "\n10. Mem_Contador()" );
    printf ( "\n11. Mem_Entpos()" );
    printf ( "\n12. Mem_Entero()" );

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

    switch ( Opcion )
      {
      case 0:   Sigue = 0;                break;
      case 1:   P_Mem_Crea();             break;
      case 2:   P_Mem_Asigna();           break;
      case 3:   P_Mem_Ajusta();           break;
      case 4:   P_Mem_Copia();            break;
      case 5:   P_Mem_Octeto();           break;
      case 6:   P_Mem_Menudo();           break;
      case 7:   P_Mem_Intercambia();      break;
      case 8:   P_Mem_IntercambiaLarga(); break;
      case 9:   P_Mem_Contpos();          break;
      case 10:  P_Mem_Contador();         break;
      case 11:  P_Mem_Entpos();           break;
      case 12:  P_Mem_Entero();           break;
      }
    }
  }

/*--------------------------------------------------------------------
 * Funcin P_Mem_Crea()
 *------------------------------------------------------------------*/
void P_Mem_Crea()
  {
  memoria Nuevo;
  
  printf ( "\n" );

  printf ( "\nPrueba de Mem_Crea() y Mem_Destruye()" );
  printf ( "\n-------------------------------------\n" );
  
  Nuevo = Mem_Crea (30 * 1024);
  printf ( "\nSe piden 30 K, reservadas en la posicin %p", Nuevo);
  
  Mem_Destruye (Nuevo);
  printf ( "\nSe liberan." );

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

/*--------------------------------------------------------------------
 * Funcin P_Mem_Ajusta()
 *------------------------------------------------------------------*/
void P_Mem_Ajusta()
  {
  memoria Nuevo;
  
  printf ( "\n" );

  printf ( "\nPrueba de Mem_Ajusta()" );
  printf ( "\n----------------------\n" );
  
  Nuevo = Mem_Crea (30 * 1024);
  printf ( "\nSe piden 30 K, reservadas en la posicin %p", Nuevo);

  Nuevo = Mem_Ajusta (Nuevo, 20 * 1024);
  printf ( "\nSe ajusta a 20 K, reservadas en la posicin %p", Nuevo);
    
  Mem_Destruye (Nuevo);
  printf ( "\nSe liberan." );

  printf ( "\n\nPulsa ENTER para seguir: " );
  getchar();
  }
                                        
/*--------------------------------------------------------------------
 * Funcin P_Mem_Asigna()
 *------------------------------------------------------------------*/
void P_Mem_Asigna()
  {
  memoria Memoria;
  int     i, Long = 10;
  
  printf ( "\n" );

  printf ( "\nPrueba de Mem_Asigna()" );
  printf ( "\n----------------------\n" );
  
  Memoria = Mem_Crea (Long);
  printf ( "\nValores antes: ");
  
  for ( i=0 ; i<Long ; i++ )
    { printf (" %d", Memoria[i]); }
    
  Mem_Asigna (Memoria, 200, Long);

  printf ( "\nValores despus: ");
  
  for ( i=0 ; i<Long ; i++ )
    { printf (" %d", Memoria[i]); }
    
  Mem_Destruye (Memoria);
    
  printf ( "\n\nPulsa ENTER para seguir: " );
  getchar();
  }

/*--------------------------------------------------------------------
 * Funcin P_Mem_Copia()
 *------------------------------------------------------------------*/
void P_Mem_Copia()
  {
  memoria Memoria, Origen;
  int     i, Long = 5;
  
  printf ( "\n" );

  printf ( "\nPrueba de Mem_Copia()" );
  printf ( "\n---------------------\n" );
  
  Memoria = Mem_Crea (Long);
  Origen = Mem_Crea (Long);

  printf ( "\nValores antes: ");
  for ( i=0 ; i<Long ; i++ )
    { printf (" %d %d", Memoria[i], Origen[i]); }
    
  Mem_Copia (Memoria, Origen, Long);

  printf ( "\nValores despus: ");
  for ( i=0 ; i<Long ; i++ )
    { printf (" %d %d", Memoria[i], Origen[i]); }

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

/*--------------------------------------------------------------------
 * Funcin P_Mem_Octeto()
 *------------------------------------------------------------------*/
void P_Mem_Octeto()
  {
  memoria Memoria;
  int     i, Long = 5;
  
  printf ( "\n" );

  printf ( "\nPrueba de Mem_LeeOcteto() y Mem_EscribeOcteto()" );
  printf ( "\n-----------------------------------------------\n" );
  
  Memoria = Mem_Crea (Long);

  printf ( "\nValores antes: ");
  for ( i=0 ; i<Long ; i++ )
    { printf (" %d", Mem_LeeOcteto(Memoria+i)); }
    
  for ( i=0 ; i<Long ; i++ )
    { Mem_EscribeOcteto(Memoria+i,127+i); }

  printf ( "\nValores despus: ");
  for ( i=0 ; i<Long ; i++ )
    { printf (" %d", Mem_LeeOcteto(Memoria+i)); }

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

/*--------------------------------------------------------------------
 * Funcin P_Mem_Menudo()
 *------------------------------------------------------------------*/
void P_Mem_Menudo()
  {
  memoria Memoria;
  int     i, Long = 5;
  
  printf ( "\n" );

  printf ( "\nPrueba de Mem_LeeMenudo() y Mem_EscribeMenudo()" );
  printf ( "\n-----------------------------------------------\n" );
  
  Memoria = Mem_Crea (Long);

  printf ( "\nValores antes: ");
  for ( i=0 ; i<Long ; i++ )
    { printf (" %d", Mem_LeeMenudo(Memoria+i)); }
    
  for ( i=0 ; i<Long ; i++ )
    { Mem_EscribeMenudo(Memoria+i,3-i); }

  printf ( "\nValores despus: ");
  for ( i=0 ; i<Long ; i++ )
    { printf (" %d", Mem_LeeMenudo(Memoria+i)); }

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

/*--------------------------------------------------------------------
 * Funcin P_Mem_Contpos()
 *------------------------------------------------------------------*/
void P_Mem_Contpos()
  {
  memoria Memoria;
  contpos Numero;
  
  Numero = 40200;
  printf ( "\n" );

  printf ( "\nPrueba de Mem_Contpos()" );
  printf ( "\n----------------------\n" );
  
  Memoria = Mem_Crea (2);
  printf ( "\nValores antes: ");
  printf ("%d %d", Mem_LeeOcteto(Memoria), Mem_LeeOcteto(Memoria+1));
    
  Mem_EscribeContpos (Memoria, MEM_MOTOROLA, Numero);
  printf ( "\nEscribo un valor en modo Motorola.");
  printf ( "\nValores despus: ");
  printf ("%d %d", Mem_LeeOcteto(Memoria), Mem_LeeOcteto(Memoria+1));
  printf ( "\nLo leo en modo Motorola y en modo Intel: ");
  printf ("%u %u", Mem_LeeContpos(Memoria,MEM_MOTOROLA), 
                   Mem_LeeContpos(Memoria,MEM_INTEL));
  
  Mem_EscribeContpos (Memoria, MEM_INTEL, Numero);
  printf ( "\nEscribo un valor en modo Intel.");
  printf ( "\nValores despus: ");
  printf ("%d %d", Mem_LeeOcteto(Memoria), Mem_LeeOcteto(Memoria+1));
  printf ( "\nLo leo en modo Motorola y en modo Intel: ");
  printf ("%u %u", Mem_LeeContpos(Memoria,MEM_MOTOROLA), 
                   Mem_LeeContpos(Memoria,MEM_INTEL));
  
  Mem_Destruye (Memoria);
    
  printf ( "\n\nPulsa ENTER para seguir: " );
  getchar();
  }

/*--------------------------------------------------------------------
 * Funcin P_Mem_Intercambia()
 *------------------------------------------------------------------*/
void P_Mem_Intercambia()
  {
  memoria Memoria;
  
  printf ( "\n" );

  printf ( "\nPrueba de Mem_Intercambia()" );
  printf ( "\n---------------------------\n" );
  
  Memoria = Mem_Crea (2);
  printf ( "\nValores antes: ");
  printf ("%d %d", Mem_LeeOcteto(Memoria), Mem_LeeOcteto(Memoria+1));
    
  Mem_Intercambia (Memoria, Memoria+1);
  printf ( "\nIntercambio.");
  printf ( "\nValores despus: ");
  printf ("%d %d", Mem_LeeOcteto(Memoria), Mem_LeeOcteto(Memoria+1));
  
  Mem_Destruye (Memoria);
    
  printf ( "\n\nPulsa ENTER para seguir: " );
  getchar();
  }

/*--------------------------------------------------------------------
 * Funcin P_Mem_IntercambiaLarga()
 *------------------------------------------------------------------*/
void P_Mem_IntercambiaLarga()
  {
  memoria Memoria, Aux;
  octeto  i;
  
  printf ( "\n" );

  printf ( "\nPrueba de Mem_IntercambiaLarga()" );
  printf ( "\n--------------------------------\n" );
  
  Memoria = Mem_Crea (8);
  Aux = Mem_Crea (4);
  printf ( "\nValores antes: ");
  for ( i=0 ; i<8 ; i++ )
    { printf ("%d ", Mem_LeeOcteto(Memoria+i)); }
    
  Mem_IntercambiaLarga (Memoria, Memoria+4, Aux, 4);
  printf ( "\nIntercambio.");
  printf ( "\nValores despus: ");
  for ( i=0 ; i<8 ; i++ )
    { printf ("%d ", Mem_LeeOcteto(Memoria+i)); }
  
  Mem_Destruye (Memoria);
    
  printf ( "\n\nPulsa ENTER para seguir: " );
  getchar();
  }

/*--------------------------------------------------------------------
 * Funcin P_Mem_Contador()
 *------------------------------------------------------------------*/
void P_Mem_Contador()
  {
  memoria  Memoria;
  contador Numero;
  
  Numero = -20205;
  printf ( "\n" );

  printf ( "\nPrueba de Mem_Contador()" );
  printf ( "\n------------------------\n" );
  
  Memoria = Mem_Crea (2);
  printf ( "\nValores antes: ");
  printf ("%d %d", Mem_LeeOcteto(Memoria), Mem_LeeOcteto(Memoria+1));
    
  Mem_EscribeContador (Memoria, MEM_MOTOROLA, Numero);
  printf ( "\nEscribo un valor en modo Motorola.");
  printf ( "\nValores despus: ");
  printf ("%d %d", Mem_LeeOcteto(Memoria), Mem_LeeOcteto(Memoria+1));
  printf ( "\nLo leo en modo Motorola y en modo Intel: ");
  printf ("%d %d", Mem_LeeContador(Memoria,MEM_MOTOROLA), 
                   Mem_LeeContador(Memoria,MEM_INTEL));
  
  Mem_EscribeContador (Memoria, MEM_INTEL, Numero);
  printf ( "\nEscribo un valor en modo Intel.");
  printf ( "\nValores despus: ");
  printf ("%d %d", Mem_LeeOcteto(Memoria), Mem_LeeOcteto(Memoria+1));
  printf ( "\nLo leo en modo Motorola y en modo Intel: ");
  printf ("%d %d", Mem_LeeContador(Memoria,MEM_MOTOROLA), 
                   Mem_LeeContador(Memoria,MEM_INTEL));
  
  Mem_Destruye (Memoria);
    
  printf ( "\n\nPulsa ENTER para seguir: " );
  getchar();
  }

/*--------------------------------------------------------------------
 * Funcin P_Mem_Entpos()
 *------------------------------------------------------------------*/
void P_Mem_Entpos()
  {
  memoria Memoria;
  entpos  Numero;
  
  Numero = 3000111222;
  printf ( "\n" );

  printf ( "\nPrueba de Mem_Entpos()" );
  printf ( "\n----------------------\n" );
  
  Memoria = Mem_Crea (4);
  printf ( "\nValores antes: ");
  printf ("%d %d %d %d", Mem_LeeOcteto(Memoria), Mem_LeeOcteto(Memoria+1),
                         Mem_LeeOcteto(Memoria+2), Mem_LeeOcteto(Memoria+3));
    
  Mem_EscribeEntpos (Memoria, MEM_MOTOROLA, Numero);
  printf ( "\nEscribo un valor en modo Motorola.");
  printf ( "\nValores despus: ");
  printf ("%d %d %d %d", Mem_LeeOcteto(Memoria), Mem_LeeOcteto(Memoria+1),
                         Mem_LeeOcteto(Memoria+2), Mem_LeeOcteto(Memoria+3));
  printf ( "\nLo leo en modo Motorola y en modo Intel: ");
  printf ("%lu %lu", Mem_LeeEntpos(Memoria,MEM_MOTOROLA), 
                     Mem_LeeEntpos(Memoria,MEM_INTEL));
  
  Mem_EscribeEntpos (Memoria, MEM_INTEL, Numero);
  printf ( "\nEscribo un valor en modo Intel.");
  printf ( "\nValores despus: ");
  printf ("%d %d %d %d", Mem_LeeOcteto(Memoria), Mem_LeeOcteto(Memoria+1),
                         Mem_LeeOcteto(Memoria+2), Mem_LeeOcteto(Memoria+3));
  printf ( "\nLo leo en modo Motorola y en modo Intel: ");
  printf ("%lu %lu", Mem_LeeEntpos(Memoria,MEM_MOTOROLA), 
                     Mem_LeeEntpos(Memoria,MEM_INTEL));
  
  Mem_Destruye (Memoria);
    
  printf ( "\n\nPulsa ENTER para seguir: " );
  getchar();
  }

/*--------------------------------------------------------------------
 * Funcin P_Mem_Entero()
 *------------------------------------------------------------------*/
void P_Mem_Entero()
  {
  memoria Memoria;
  entero  Numero;
  
  Numero = -2000111222;
  printf ( "\n" );

  printf ( "\nPrueba de Mem_Entero()" );
  printf ( "\n----------------------\n" );
  
  Memoria = Mem_Crea (4);
  printf ( "\nValores antes: ");
  printf ("%d %d %d %d", Mem_LeeOcteto(Memoria), Mem_LeeOcteto(Memoria+1),
                         Mem_LeeOcteto(Memoria+2), Mem_LeeOcteto(Memoria+3));
    
  Mem_EscribeEntero (Memoria, MEM_MOTOROLA, Numero);
  printf ( "\nEscribo un valor en modo Motorola.");
  printf ( "\nValores despus: ");
  printf ("%d %d %d %d", Mem_LeeOcteto(Memoria), Mem_LeeOcteto(Memoria+1),
                         Mem_LeeOcteto(Memoria+2), Mem_LeeOcteto(Memoria+3));
  printf ( "\nLo leo en modo Motorola y en modo Intel: ");
  printf ("%ld %ld", Mem_LeeEntero(Memoria,MEM_MOTOROLA), 
                     Mem_LeeEntero(Memoria,MEM_INTEL));
  
  Mem_EscribeEntero (Memoria, MEM_INTEL, Numero);
  printf ( "\nEscribo un valor en modo Intel.");
  printf ( "\nValores despus: ");
  printf ("%d %d %d %d", Mem_LeeOcteto(Memoria), Mem_LeeOcteto(Memoria+1),
                         Mem_LeeOcteto(Memoria+2), Mem_LeeOcteto(Memoria+3));
  printf ( "\nLo leo en modo Motorola y en modo Intel: ");
  printf ("%ld %ld", Mem_LeeEntero(Memoria,MEM_MOTOROLA), 
                     Mem_LeeEntero(Memoria,MEM_INTEL));
  
  Mem_Destruye (Memoria);
    
  printf ( "\n\nPulsa ENTER para seguir: " );
  getchar();
  }

