/*--------------------------------------------------------------------
 * FICHERO:       Memoria.h
 * OBJETIVO:      Definir el objeto "Memoria"
 * IDENTIFICADOR: Mem
 * AUTOR:         Pedro Reina
 * FECHA:         L.17.7.1995
 *------------------------------------------------------------------*/

/*--------------------------------------------------------------------
 * Funciones pblicas
 *
 *   Mem_Crea()              Memoria.h
 *   Mem_Ajusta()            Memoria.h
 *   Mem_Destruye()          Memoria.h
 *   Mem_Asigna()            Memoria.h
 *   Mem_Copia()             Memoria.h
 *   Mem_LeeOcteto()         Memoria.h
 *   Mem_EscribeOcteto()     Memoria.h
 *   Mem_LeeMenudo()         Memoria.h
 *   Mem_EscribeMenudo()     Memoria.h
 *   Mem_Intercambia()       MemInter.c
 *   Mem_IntercambiaLarga()  MemIntLa.c
 *   Mem_LeeContpos()        MemLeeCp.c
 *   Mem_EscribeContpos()    MemEscCp.c
 *   Mem_LeeContador()       MemLeeCo.c
 *   Mem_EscribeContador()   MemEscCo.c
 *   Mem_LeeEntpos()         MemLeeEp.c
 *   Mem_EscribeEntpos()     MemEscEp.c
 *   Mem_LeeEntero()         MemLeeEn.c
 *   Mem_EscribeEntero()     MemEscEn.c
 *------------------------------------------------------------------*/

/*--------------------------------------------------------------------
 * Funciones conocidas
 *
 *   Ninguna
 *------------------------------------------------------------------*/

/*--------------------------------------------------------------------
 * Funciones privadas
 *
 *   Ninguna
 *------------------------------------------------------------------*/

#ifndef _MEMORIA_
#define _MEMORIA_

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

#include "General.h"

#include <stdlib.h>    /*  malloc()  free()                         */
#include <string.h>    /*  memset()  memcpy()                       */

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

/* Posibles modos de colocacin de octetos en memoria */

#define MEM_MOTOROLA ((octeto)0)  /* El valor ms significativo, antes */
#define MEM_INTEL    ((octeto)1)  /* El valor ms significativo, despus */

/*--------------------------------------------------------------------
 * Definicin de tipos
 *------------------------------------------------------------------*/

typedef octeto *memoria;

/*--------------------------------------------------------------------
 * Variables globales
 *------------------------------------------------------------------*/

   /* Ninguna */

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

void     Mem_Intercambia();
void     Mem_IntercambiaLarga();
contpos  Mem_LeeContpos();
contpos  Mem_EscribeContpos();
contador Mem_LeeContador();
contador Mem_EscribeContador();
entpos   Mem_LeeEntpos();
entpos   Mem_EscribeEntpos();
entero   Mem_LeeEntero();
entero   Mem_EscribeEntero();

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

/*--------------------------------------------------------------Olimpo
 * MACRO:    Mem_Crea()
 * OBJETIVO: Reservar cierta cantidad de memoria
 * ENTRADAS: El nmero de octetos que hay que reservar
 * SALIDAS:  La memoria reservada o NULO si no se puede reservar
 * EJEMPLO:  Mem_Crea (1024)
 * NOTA:     En el PC, con esta funcin no se puede reservar un
 *           bloque mayor de 64K
 *------------------------------------------------------------------*/
#define Mem_Crea(t)  ((memoria)malloc((size_t)t))

/*--------------------------------------------------------------Olimpo
 * MACRO:    Mem_Ajusta()
 * OBJETIVO: Ajustar la reserva de memoria
 * ENTRADAS: La posicin de memoria reservada con anterioridad
 *           y el nuevo nmero de octetos que hay que reservar
 * SALIDAS:  La nueva memoria, ya ajustada o NULO si no se
 *           puede ajustar
 * EJEMPLO:  Mem_Ajusta (Auxiliar,2048)
 * NOTA:     En el PC, con esta funcin no se puede reservar un
 *           bloque mayor de 64K
 *------------------------------------------------------------------*/
#define Mem_Ajusta(m,t)  ((memoria)realloc((memoria)m,(size_t)t))

/*--------------------------------------------------------------Olimpo
 * MACRO:    Mem_Destruye()
 * OBJETIVO: Devolver memoria reservada con anterioridad
 * ENTRADAS: La memoria reservada
 * SALIDAS:  Si la memoria era NULO, NO; si la memoria era
 *           no NULO, SI
 * EJEMPLO:  Mem_Destruye (Memoria)
 *------------------------------------------------------------------*/
#define Mem_Destruye(m)  ((memoria)m?(free((memoria)m),SI):NO)

/*--------------------------------------------------------------Olimpo
 * MACRO:    Mem_Asigna()
 * OBJETIVO: Dar un valor a un grupo de octetos
 * ENTRADAS: La posicin de memoria donde comenzar, el valor
 *           y la cantidad de octetos
 * SALIDAS:  La posicin de memoria
 * EJEMPLO:  Mem_Asigna (Memoria,32,1024)
 *------------------------------------------------------------------*/
#define Mem_Asigna(m,v,c)  memset(m,v,c)

/*--------------------------------------------------------------Olimpo
 * MACRO:    Mem_Copia()
 * OBJETIVO: Copiar los valores de una zona de memoria a otra
 * ENTRADAS: La posicin de memoria destino, la origen y la
 *           cantidad de octetos
 * SALIDAS:  La posicin de memoria destino
 * EJEMPLO:  Mem_Copia (MemoriaFinal,MemoriaInicial,1024)
 *------------------------------------------------------------------*/
#define Mem_Copia(d,o,c)  memcpy(d,o,(size_t)c)

/*--------------------------------------------------------------Olimpo
 * MACRO:    Mem_LeeOcteto()
 * OBJETIVO: Dar el valor de una posicin de memoria como octeto
 * ENTRADAS: La posicin de memoria
 * SALIDAS:  El valor
 * EJEMPLO:  Mem_LeeOcteto (Memoria+10)
 *------------------------------------------------------------------*/
#define Mem_LeeOcteto(m)  (*((memoria)(m)))

/*--------------------------------------------------------------Olimpo
 * MACRO:    Mem_EscribeOcteto()
 * OBJETIVO: Poner en una posicin de memoria un valor dado
 *           como octeto
 * ENTRADAS: La posicin de memoria y el valor
 * SALIDAS:  El valor
 * EJEMPLO:  Mem_EscribeOcteto (Memoria+10, 205)
 *------------------------------------------------------------------*/
#define Mem_EscribeOcteto(m,v)  (*((memoria)(m))=(octeto)(v))

/*--------------------------------------------------------------Olimpo
 * MACRO:    Mem_LeeMenudo()
 * OBJETIVO: Dar el valor de una posicin de memoria como menudo
 * ENTRADAS: La posicin de memoria
 * SALIDAS:  El valor
 * EJEMPLO:  Mem_LeeMenudo (Memoria+10)
 *------------------------------------------------------------------*/
#define Mem_LeeMenudo(m)  ((menudo)*((memoria)(m)))

/*--------------------------------------------------------------Olimpo
 * MACRO:    Mem_EscribeMenudo()
 * OBJETIVO: Poner en una posicin de memoria un valor dado
 *           como menudo
 * ENTRADAS: La posicin de memoria y el valor
 * SALIDAS:  El valor
 * EJEMPLO:  Mem_EscribeMenudo (Memoria+10, -105)
 *------------------------------------------------------------------*/
#define Mem_EscribeMenudo(m,v)  (*((memoria)(m))=(menudo)(v))

#endif /* _MEMORIA_ */
