Agreguo los nuevos tipos de datos:

EMUFS_REG_ID
EMUFS_REG_SIZE
EMUFS_BLOCK_ID
EMUFS_BLOCK_SIZE
EMUFS_FREE
EMUFS_OFFSET /* este hay que ver si vuela y hacemos un mismo tipo para BLOCK y
                OFFSET */
En tipo3 hay cosas no convertidas porque no estaba seguro de que tipo de dato
tenia que guardar (nico por favor mira los sizeof(int) o similares).
Agrego un test del tipo1 que no anda.

diff --git a/emufs/Makefile b/emufs/Makefile
index fc6b95aa3c912c4b15b971946db8ac6b22655dc2..5ec47676ab8a43f9c22acb4e3e3b80bbf819cc51 100644 (file)
--- a/emufs/Makefile
+++ b/emufs/Makefile
@@ -3,7 +3,9 @@ LDFLAGS=
 
 EMUFS_COMMON=emufs.o tipo1.o tipo3.o idx.o did.o fsc.o
 
 
 EMUFS_COMMON=emufs.o tipo1.o tipo3.o idx.o did.o fsc.o
 

-all: libemufs.a tipo3_main
+all: libemufs.a tipo1_test tipo3_main
+
+tipo1_test: tipo1_test.o $(EMUFS_COMMON)

 
 tipo3_main: tipo3_main.o $(EMUFS_COMMON)
 
 
 tipo3_main: tipo3_main.o $(EMUFS_COMMON)
 

diff --git a/emufs/did.c b/emufs/did.c
index 407b123e418e1db47f92a6d080391d3ac2a03ebf..8492aa76e4d5d7197ae4d353e78fbb9eaa2cba98 100644 (file)
--- a/emufs/did.c
+++ b/emufs/did.c
@@ -45,7 +45,7 @@ int emufs_did_crear(EMUFS* efs)
        return emufs_crear_archivo_auxiliar(efs->nombre, EMUFS_DID_EXT);
 }
 
        return emufs_crear_archivo_auxiliar(efs->nombre, EMUFS_DID_EXT);
 }
 

-int emufs_did_get_last(EMUFS *emu)
+EMUFS_REG_ID emufs_did_get_last(EMUFS *emu)

 {
        FILE * f_did;
        int id, offset;
 {
        FILE * f_did;
        int id, offset;


@@ -78,7 +78,7 @@ int emufs_did_get_last(EMUFS *emu)
 }
 
 /*agrego un elemento al archivo */
 }
 
 /*agrego un elemento al archivo */

-int emufs_did_agregar(EMUFS *emu, int ID)
+int emufs_did_agregar(EMUFS *emu, EMUFS_REG_ID ID)

 {
        FILE *f_did;
        char name_f_did[255];
 {
        FILE *f_did;
        char name_f_did[255];

diff --git a/emufs/did.h b/emufs/did.h
index e79b8cee1e497596c72b972694b3715eb2ad8cc2..5b710197dedc40510bb761c015b64522a03c6f2b 100644 (file)
--- a/emufs/did.h
+++ b/emufs/did.h
@@ -45,8 +45,8 @@
 
 int emufs_did_crear(EMUFS*);
 
 
 int emufs_did_crear(EMUFS*);
 

-int emufs_did_get_last(EMUFS *); 
+EMUFS_REG_ID emufs_did_get_last(EMUFS *); 

 
 

-int emufs_did_agregar(EMUFS *, int);
+int emufs_did_agregar(EMUFS *, EMUFS_REG_ID);

 
 #endif /* _EMUFS_DID_H */
 
 #endif /* _EMUFS_DID_H */

diff --git a/emufs/emufs.c b/emufs/emufs.c
index a6a774c32dff5cb6aff9661a808a1075b2256ca9..7ddd4bd72c608f3a903187a02f532cf7b648d337 100644 (file)
--- a/emufs/emufs.c
+++ b/emufs/emufs.c
@@ -79,22 +79,26 @@ int emufs_crear_archivo_auxiliar(const char* name, const char* ext)
 }
 
 
 }
 
 

-EMUFS *emufs_crear(const char *filename, char tipo, unsigned long tam_bloque, unsigned long tam_reg)
+EMUFS *emufs_crear(const char *filename, EMUFS_TYPE tipo,
+               EMUFS_BLOCK_SIZE tam_bloque, EMUFS_REG_SIZE tam_reg)

 {
        char name[255];
        FILE *fp;
        EMUFS *efs;
 
 {
        char name[255];
        FILE *fp;
        EMUFS *efs;
 

-       /* Si no es un tipo conocido, sale */
+       /* Si no es un tipo conocido, sale. */

        if ((tipo != T1) && (tipo != T2) && (tipo != T3)) {
                return NULL;
        }
 
        /* Inicializa parámetros comunes. */
        efs = (EMUFS*) malloc(sizeof(EMUFS));
        if ((tipo != T1) && (tipo != T2) && (tipo != T3)) {
                return NULL;
        }
 
        /* Inicializa parámetros comunes. */
        efs = (EMUFS*) malloc(sizeof(EMUFS));

-       efs->tipo = tipo;
+       if (efs == NULL) {
+               return NULL;
+       }
+       efs->tipo       = tipo;

        efs->tam_bloque = tam_bloque;
        efs->tam_bloque = tam_bloque;

-       efs->nombre = str_dup(filename);
+       efs->nombre     = str_dup(filename);

 
        /* Abre archivo de datos. */
        strcpy(name, filename);
 
        /* Abre archivo de datos. */
        strcpy(name, filename);


@@ -108,7 +112,7 @@ EMUFS *emufs_crear(const char *filename, char tipo, unsigned long tam_bloque, un
        }
 
        /* Guarda cabecera común. */
        }
 
        /* Guarda cabecera común. */

-       fwrite(&tipo, sizeof(char), 1, fp); /* FIXME no debería ser sizeof(EMUFS_TYPE) ? */
+       fwrite(&tipo, sizeof(EMUFS_TYPE), 1, fp);

 
        /* Crea archivo de índice. */
        if (emufs_idx_crear(efs)) {
 
        /* Crea archivo de índice. */
        if (emufs_idx_crear(efs)) {


@@ -138,14 +142,10 @@ EMUFS *emufs_crear(const char *filename, char tipo, unsigned long tam_bloque, un
        switch (tipo) {
 
                case T1:
        switch (tipo) {
 
                case T1:

-                       /* Asigna punteros a funciones. */
-                       efs->leer_bloque     = emufs_tipo1_leer_bloque;
-                       efs->leer_registro   = emufs_tipo1_leer_registro;
-                       efs->grabar_registro = emufs_tipo1_grabar_registro;
-                       efs->borrar_registro = emufs_tipo1_borrar_registro;
+                       emufs_tipo1_inicializar(efs);

 
                        /* Guarda cabeceras propias. */
 
                        /* Guarda cabeceras propias. */

-                       fwrite(&tam_bloque, sizeof(unsigned long), 1, fp);
+                       fwrite(&tam_bloque, sizeof(EMUFS_BLOCK_SIZE), 1, fp);

 
                        break;
 
 
                        break;
 


@@ -160,8 +160,8 @@ EMUFS *emufs_crear(const char *filename, char tipo, unsigned long tam_bloque, un
                        efs->borrar_registro = emufs_tipo3_borrar_registro;
 
                        /* Guarda cabeceras propias. */
                        efs->borrar_registro = emufs_tipo3_borrar_registro;
 
                        /* Guarda cabeceras propias. */

-                       fwrite(&tam_bloque, sizeof(unsigned int), 1, fp);
-                       fwrite(&tam_reg, sizeof(unsigned int), 1, fp);
+                       fwrite(&tam_bloque, sizeof(EMUFS_BLOCK_SIZE), 1, fp);
+                       fwrite(&tam_reg, sizeof(EMUFS_REG_SIZE), 1, fp);

                        
                        break;
 
                        
                        break;
 


@@ -173,7 +173,7 @@ EMUFS *emufs_crear(const char *filename, char tipo, unsigned long tam_bloque, un
 
 EMUFS *emufs_abrir(const char *filename)
 {
 
 EMUFS *emufs_abrir(const char *filename)
 {

-       EMUFS *tmp;
+       EMUFS *efs;

        char name[255];
        char tipo;
        FILE *fp;
        char name[255];
        char tipo;
        FILE *fp;


@@ -184,35 +184,53 @@ EMUFS *emufs_abrir(const char *filename)
        /* Trato de determinar el tipo de archivo */
        fp = fopen(name, "r");
        if (fp == NULL) return NULL;
        /* Trato de determinar el tipo de archivo */
        fp = fopen(name, "r");
        if (fp == NULL) return NULL;

-       fread(&tipo, sizeof(char), 1, fp);
-       if ((tipo < 0) || (tipo > 2)) {
+       fread(&tipo, sizeof(EMUFS_TYPE), 1, fp);
+
+       /* Si no es un tipo conocido, sale. */
+       if ((tipo != T1) && (tipo != T2) && (tipo != T3)) {

                fclose(fp);
                return NULL;
        }
        
                fclose(fp);
                return NULL;
        }
        

-       tmp = (EMUFS *)malloc(sizeof(EMUFS));
-       if (tmp == NULL) {
+       /* Inicializa parámetros comunes. */
+       efs = (EMUFS*) malloc(sizeof(EMUFS));
+       if (efs == NULL) {

                fclose(fp);
                return NULL;
        }
                fclose(fp);
                return NULL;
        }

+       efs->tipo = tipo;
+       efs->nombre = str_dup(filename);

 
        switch (tipo) {
                case T1:
 
        switch (tipo) {
                case T1:

-               break;
+                       emufs_tipo1_inicializar(efs);
+                       /* Lee cabeceras propias. */
+                       if (!fread(&(efs->tam_bloque), sizeof(EMUFS_BLOCK_SIZE), 1, fp)) {
+                               free(efs->nombre);
+                               free(efs);
+                               fclose(fp);
+                               return NULL;
+                       }
+                       break;

                case T2:
                case T2:

-               break;
+                       break;

                case T3:
                case T3:

-                       tmp->tipo = tipo;
-                       fread(&tmp->tam_bloque, sizeof(int), 1, fp);
-                       tmp->leer_bloque = emufs_tipo3_leer_bloque;
-                       tmp->leer_registro = emufs_tipo3_leer_registro;
-                       tmp->grabar_registro = emufs_tipo3_grabar_registro;
-                       tmp->borrar_registro = emufs_tipo3_borrar_registro;
-                       tmp->nombre = str_dup(filename);
+                       if (!fread(&(efs->tam_bloque), sizeof(EMUFS_BLOCK_SIZE), 1, fp)) {
+                               free(efs->nombre);
+                               free(efs);
+                               fclose(fp);
+                               return NULL;
+                       }
+                       /* FIXME no falta leer el tamaño del registro????  */
+                       efs->leer_bloque = emufs_tipo3_leer_bloque;
+                       efs->leer_registro = emufs_tipo3_leer_registro;
+                       efs->grabar_registro = emufs_tipo3_grabar_registro;
+                       efs->borrar_registro = emufs_tipo3_borrar_registro;
+                       break;

        }
 
        fclose(fp);
        }
 
        fclose(fp);

-       return tmp;
+       return efs;

 }
 
 int emufs_destruir(EMUFS *e)
 }
 
 int emufs_destruir(EMUFS *e)

diff --git a/emufs/emufs.h b/emufs/emufs.h
index f8a70673bb190a8c8099ce39fc9245d8f61ba789..cd25bb5eef20e52f2b7294840da2f020fc2fb74d 100644 (file)
--- a/emufs/emufs.h
+++ b/emufs/emufs.h
@@ -50,6 +50,24 @@ typedef enum {
        T3  /**< Archivo de bloque parametrizado y registro fijo. */
 } EMUFS_TYPE;
 
        T3  /**< Archivo de bloque parametrizado y registro fijo. */
 } EMUFS_TYPE;
 

+/** Tipo de identificador de registro. */
+typedef unsigned long EMUFS_REG_ID;
+
+/** Tipo de tamaño de registro. */
+typedef unsigned long EMUFS_REG_SIZE;
+
+/** Tipo de identificador de bloque. */
+typedef unsigned long EMUFS_BLOCK_ID;
+
+/** Tipo de tamaño de bloque. */
+typedef unsigned long EMUFS_BLOCK_SIZE;
+
+/** Tipo de espacio libre. */
+typedef unsigned long EMUFS_FREE;
+
+/** Tipo de offset. */
+typedef unsigned long EMUFS_OFFSET;
+

 /** Tipo Abstracto para menajo de archivos.
  *
  *  Esta estructura es utilizada para acceder a cualquier tipo de archivo.
 /** Tipo Abstracto para menajo de archivos.
  *
  *  Esta estructura es utilizada para acceder a cualquier tipo de archivo.


@@ -70,11 +88,11 @@ typedef enum {
  */
 typedef struct _emu_fs_t {
        EMUFS_TYPE tipo;
  */
 typedef struct _emu_fs_t {
        EMUFS_TYPE tipo;

-       unsigned long tam_bloque; /**< Tamaño de bloque. 0 Si no tiene bloques */
-       int (*leer_bloque)(struct _emu_fs_t *, int, void *); /**< Método para leer un bloque */
-       int (*leer_registro)(struct _emu_fs_t *, int, void *, unsigned long); /**< Método para leer un registro */
-       int (*grabar_registro)(struct _emu_fs_t *, void *, unsigned long ); /**< Método para grabar un registro */
-       int (*borrar_registro)(struct _emu_fs_t *, int, unsigned long ); /**< Método para borrar un registro */
+       EMUFS_BLOCK_SIZE tam_bloque; /**< Tamaño de bloque. 0 Si no tiene bloques */
+       int (*leer_bloque)(struct _emu_fs_t*, EMUFS_BLOCK_ID, void*); /**< Método para leer un bloque */
+       int (*leer_registro)(struct _emu_fs_t*, EMUFS_REG_ID, void *, EMUFS_REG_SIZE); /**< Método para leer un registro */
+       EMUFS_REG_ID (*grabar_registro)(struct _emu_fs_t*, void*, EMUFS_REG_SIZE); /**< Método para grabar un registro */
+       int (*borrar_registro)(struct _emu_fs_t*, EMUFS_REG_ID, unsigned long ); /**< Método para borrar un registro */ /* XXX QUE CATSO ES EL unsigned long ??? */

        char *nombre; /**< Nombre del archivo */
 } EMUFS;
 
        char *nombre; /**< Nombre del archivo */
 } EMUFS;
 


@@ -83,27 +101,31 @@ int emufs_crear_archivo_auxiliar(const char*, const char*);
 
 /** Crea un nuevo archivo EMUFS.
  *
 
 /** Crea un nuevo archivo EMUFS.
  *

- *  Un archivo EMUFS está compuesto por 4 archivos a nivel del sistema operativo.
- *  Un archivo principal con extensión .dat y 3 archivos auxiliares para manejo interno.
+ *  Un archivo EMUFS está compuesto por 4 archivos a nivel del SO.
+ *  Un archivo principal con extensión .dat y 3 archivos auxiliares para
+ *  manejo interno.

  *
  *

- *  El parámetro filename que recive esta función en el nombre virtual que se utilizará, ya
- *  que las extensiones serán puestas automáticamente for EMUFS.
+ *  El parámetro filename que recive esta función en el nombre virtual que se
+ *  utilizará, ya que las extensiones serán puestas automáticamente for EMUFS.

  *
  *  Un ejemplo:
  *  \code
  *  EMUFS *fp  emufs_crear("archivo", T3, 100, 100);
  *  \endcode
  *
  *
  *  Un ejemplo:
  *  \code
  *  EMUFS *fp  emufs_crear("archivo", T3, 100, 100);
  *  \endcode
  *

- *  En el ejemplo anterior se tiene que nuestro filesystem virtual se llamará archivo.
+ *  En el ejemplo anterior se tiene que nuestro filesystem virtual se llamará
+ *  archivo.

  *
  *

- *  Los últimos 2 parámetros serán ignorados si el tipo de archivo no utiliza dicho parámetro.
+ *  Los últimos 2 parámetros serán ignorados si el tipo de archivo no utiliza
+ *  dicho parámetro.

  *
  *  \param filename Nombre del archivo virtual.
  *  \param tipo Tipo de archivo.
  *  \param tam_bloque Tamaño del bloque.
  *  \param tam_reg Tamaño del registro.
  */
  *
  *  \param filename Nombre del archivo virtual.
  *  \param tipo Tipo de archivo.
  *  \param tam_bloque Tamaño del bloque.
  *  \param tam_reg Tamaño del registro.
  */

-EMUFS *emufs_crear(const char *filename, char tipo, unsigned long tam_bloque, unsigned long tam_reg);
+EMUFS *emufs_crear(const char *filename, EMUFS_TYPE tipo,
+               EMUFS_BLOCK_SIZE tam_bloque, EMUFS_REG_SIZE tam_reg);

 
 /** Abre un archivo EMUFS.
  *
 
 /** Abre un archivo EMUFS.
  *

diff --git a/emufs/fsc.c b/emufs/fsc.c
index b67ce36367e499d736c25ab74560a39c06a88bcb..05218a6c19893cc596688e792826d28d101349e8 100644 (file)
--- a/emufs/fsc.c
+++ b/emufs/fsc.c
@@ -44,7 +44,7 @@ int emufs_fsc_crear(EMUFS* efs)
        return emufs_crear_archivo_auxiliar(efs->nombre, EMUFS_FSC_EXT);
 }
 
        return emufs_crear_archivo_auxiliar(efs->nombre, EMUFS_FSC_EXT);
 }
 

-int emufs_fsc_agregar(EMUFS *emu, int num_bloque, int fs)
+int emufs_fsc_agregar(EMUFS *emu, EMUFS_BLOCK_ID num_bloque, EMUFS_FREE fs)

 {
        FILE *f_fsc;
        EMUFS_FSC reg;
 {
        FILE *f_fsc;
        EMUFS_FSC reg;


@@ -64,7 +64,7 @@ int emufs_fsc_agregar(EMUFS *emu, int num_bloque, int fs)
 }
 
 /* busca el bloque y le resta fs de espacio libre */
 }
 
 /* busca el bloque y le resta fs de espacio libre */

-int emufs_fsc_actualizar(EMUFS *emu, int num_bloque, int fs)
+int emufs_fsc_actualizar(EMUFS *emu, EMUFS_BLOCK_ID num_bloque, EMUFS_FREE fs)

 {
        FILE *f_fsc;
        EMUFS_FSC reg;
 {
        FILE *f_fsc;
        EMUFS_FSC reg;


@@ -89,7 +89,7 @@ int emufs_fsc_actualizar(EMUFS *emu, int num_bloque, int fs)
 }
 
 /* me devuelve el ID del bloque donde quepa un registro, y guarda en fs el espacio libre que queda en el bloque */
 }
 
 /* me devuelve el ID del bloque donde quepa un registro, y guarda en fs el espacio libre que queda en el bloque */

-int emufs_fsc_buscar_lugar(EMUFS *emu, unsigned long tam, int *fs)
+EMUFS_BLOCK_ID emufs_fsc_buscar_lugar(EMUFS *emu, EMUFS_FREE tam, EMUFS_FREE *fs)

 {
        FILE *f_fsc;
        EMUFS_FSC reg;
 {
        FILE *f_fsc;
        EMUFS_FSC reg;


@@ -121,7 +121,7 @@ int emufs_fsc_buscar_lugar(EMUFS *emu, unsigned long tam, int *fs)
        return reg.block;
 }
 
        return reg.block;
 }
 

-int emufs_fsc_get_fs(EMUFS *emu, int num_bloque)
+EMUFS_FREE emufs_fsc_get_fs(EMUFS *emu, EMUFS_BLOCK_ID num_bloque)

 {
        FILE *f_fsc;
        EMUFS_FSC reg;
 {
        FILE *f_fsc;
        EMUFS_FSC reg;

diff --git a/emufs/fsc.h b/emufs/fsc.h
index 9e44692c496abe642e1dc0430441a78122db6a11..01a72f162b7779d7b5f559d55770cddf4a61595f 100644 (file)
--- a/emufs/fsc.h
+++ b/emufs/fsc.h
@@ -49,12 +49,12 @@ typedef struct emufs_fsc_t {
 
 int emufs_fsc_crear(EMUFS*);
 
 
 int emufs_fsc_crear(EMUFS*);
 

-int emufs_fsc_agregar(EMUFS *, int, int);
+int emufs_fsc_agregar(EMUFS *, EMUFS_BLOCK_ID, EMUFS_FREE);

 
 

-int emufs_fsc_actualizar(EMUFS *, int, int);
+int emufs_fsc_actualizar(EMUFS *, EMUFS_BLOCK_ID, EMUFS_FREE);

 
 

-int emufs_fsc_buscar_lugar(EMUFS *, unsigned long, int *);
+EMUFS_BLOCK_ID emufs_fsc_buscar_lugar(EMUFS *, EMUFS_FREE, EMUFS_FREE *);

 
 

-int emufs_fsc_get_fs(EMUFS *, int);
+EMUFS_FREE emufs_fsc_get_fs(EMUFS *, EMUFS_BLOCK_ID);

 
 #endif /* _EMUFS_FSC_H */
 
 #endif /* _EMUFS_FSC_H */

diff --git a/emufs/idx.c b/emufs/idx.c
index 56fa4fca3b0bb787b65c2d1eb3ecdb0f088d7f37..f7c89fd2498c6fab5dceeff653274c91196368dd 100644 (file)
--- a/emufs/idx.c
+++ b/emufs/idx.c
@@ -62,7 +62,7 @@ int emufs_idx_crear(EMUFS *efs)
        return emufs_crear_archivo_auxiliar(efs->nombre, EMUFS_IDX_EXT);
 }
 
        return emufs_crear_archivo_auxiliar(efs->nombre, EMUFS_IDX_EXT);
 }
 

-int emufs_idx_buscar_mayor_id(EMUFS *emu)
+EMUFS_REG_ID emufs_idx_buscar_mayor_id(EMUFS *emu)

 {
        int id, max = -1;
        FILE *f_idx;    
 {
        int id, max = -1;
        FILE *f_idx;    


@@ -87,7 +87,7 @@ int emufs_idx_buscar_mayor_id(EMUFS *emu)
 }
 
 /*busca el registro ID en el archivo ".idx" y devuelve el nro de bloque en el que se encuentra*/
 }
 
 /*busca el registro ID en el archivo ".idx" y devuelve el nro de bloque en el que se encuentra*/

-int emufs_idx_buscar_registro(EMUFS *emu, int ID)
+EMUFS_BLOCK_ID emufs_idx_buscar_registro(EMUFS *emu, EMUFS_REG_ID ID)

 {
        FILE* f_idx;
        EMUFS_IDX reg;
 {
        FILE* f_idx;
        EMUFS_IDX reg;


@@ -110,7 +110,7 @@ int emufs_idx_buscar_registro(EMUFS *emu, int ID)
 }
 
 /* agrega un registro al final del archivo */
 }
 
 /* agrega un registro al final del archivo */

-int emufs_idx_agregar(EMUFS *emu, int num_bloque, int ID_aux)
+int emufs_idx_agregar(EMUFS *emu, EMUFS_BLOCK_ID num_bloque, EMUFS_REG_ID id)

 {
        FILE *f_idx;
        EMUFS_IDX reg;
 {
        FILE *f_idx;
        EMUFS_IDX reg;


@@ -122,13 +122,13 @@ int emufs_idx_agregar(EMUFS *emu, int num_bloque, int ID_aux)
        if ( (f_idx = fopen(name_f_idx,"a+"))==NULL ) return -1;
                
        reg.block = num_bloque;
        if ( (f_idx = fopen(name_f_idx,"a+"))==NULL ) return -1;
                
        reg.block = num_bloque;

-       reg.id_reg = ID_aux;
+       reg.id_reg = id;

        fwrite(&reg,sizeof(EMUFS_IDX),1,f_idx); 
        fclose(f_idx);
        return 0;
 }
 
        fwrite(&reg,sizeof(EMUFS_IDX),1,f_idx); 
        fclose(f_idx);
        return 0;
 }
 

-int emufs_idx_borrar(EMUFS *emu, int ID)
+int emufs_idx_borrar(EMUFS *emu, EMUFS_REG_ID ID)

 {
        FILE *f_idx;
        EMUFS_IDX reg, buffer;
 {
        FILE *f_idx;
        EMUFS_IDX reg, buffer;

diff --git a/emufs/idx.h b/emufs/idx.h
index 4dfba88acd068c8fa193c1445590c4f624cc3be6..7999f064f55c8fd1a5254277cffa6d8ab2a37fd9 100644 (file)
--- a/emufs/idx.h
+++ b/emufs/idx.h
@@ -53,12 +53,12 @@ FILE* emufs_idx_abrir(EMUFS*, const char*);
 
 int emufs_idx_crear(EMUFS*);
 
 
 int emufs_idx_crear(EMUFS*);
 

-int emufs_idx_buscar_mayor_id(EMUFS *);
+EMUFS_REG_ID emufs_idx_buscar_mayor_id(EMUFS *);

 
 

-int emufs_idx_buscar_registro(EMUFS *, int);
+EMUFS_BLOCK_ID emufs_idx_buscar_registro(EMUFS *, EMUFS_REG_ID);

 
 

-int emufs_idx_agregar(EMUFS *, int , int);
+int emufs_idx_agregar(EMUFS *, EMUFS_BLOCK_ID, EMUFS_REG_ID);

 
 

-int emufs_idx_borrar(EMUFS *emu, int ID);
+int emufs_idx_borrar(EMUFS *emu, EMUFS_REG_ID);

 
 #endif /* _EMUFS_IDX_H */
 
 #endif /* _EMUFS_IDX_H */

diff --git a/emufs/tipo1.c b/emufs/tipo1.c
index d5a0a58cb5575345c95086b30526149684abce5e..ee444cec3f773f3c6f7a8284c41ad55b98823516 100644 (file)
--- a/emufs/tipo1.c
+++ b/emufs/tipo1.c
@@ -36,19 +36,33 @@
  */
 
 #include "tipo1.h"
  */
 
 #include "tipo1.h"

+#include "idx.h"
+#include "fsc.h"
+#include "did.h"

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

-#include <malloc.h>

 
 

-int emufs_tipo1_leer_registro(EMUFS* efs, int reg_id, void* reg_ptr, unsigned long reg_size)
+int emufs_tipo1_inicializar(EMUFS* efs)
+{
+       /* Asigna punteros a funciones. */
+       efs->leer_bloque     = emufs_tipo1_leer_bloque;
+       efs->leer_registro   = emufs_tipo1_leer_registro;
+       efs->grabar_registro = emufs_tipo1_grabar_registro;
+       efs->borrar_registro = emufs_tipo1_borrar_registro;
+
+       return 0;
+}
+
+int emufs_tipo1_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id, void* reg_ptr,
+               EMUFS_REG_SIZE reg_size)

 {
 {

-       int block_id; /* id del bloque en donde esta el registro a leer */

        char* block; /* bloque leido (en donde está el registro a leer) */
        char* block; /* bloque leido (en donde está el registro a leer) */

-       ptrdiff_t offset; /* offset del bloque a leido */
-       unsigned long curr_reg_size; /* tamaño del registro leido secuencialmente */
-       int curr_reg_id; /* id del registro leido secuencialmente */
+       EMUFS_BLOCK_ID block_id; /* id del bloque en donde esta el registro a leer */
+       EMUFS_BLOCK_SIZE offset; /* offset del bloque leido */
+       EMUFS_REG_SIZE curr_reg_size; /* tamaño del registro leido secuencialmente */
+       EMUFS_REG_ID curr_reg_id; /* id del registro leido secuencialmente */

 
        block_id = emufs_idx_buscar_registro(efs, reg_id);
        block = (char*) malloc(efs->tam_bloque);
 
        block_id = emufs_idx_buscar_registro(efs, reg_id);
        block = (char*) malloc(efs->tam_bloque);


@@ -69,11 +83,11 @@ int emufs_tipo1_leer_registro(EMUFS* efs, int reg_id, void* reg_ptr, unsigned lo
        offset = 0;
        do {
                /* Copio el id del registro de la cabecera. */
        offset = 0;
        do {
                /* Copio el id del registro de la cabecera. */

-               memcpy(&curr_reg_id, block + offset, sizeof(int));
-               offset += sizeof(int);
+               memcpy(&curr_reg_id, block + offset, sizeof(EMUFS_REG_ID));
+               offset += sizeof(EMUFS_REG_ID);

                /* Copio el tamaño del registro de la cabecera. */
                /* Copio el tamaño del registro de la cabecera. */

-               memcpy(&curr_reg_size, block + offset, sizeof(unsigned long));
-               offset += sizeof(unsigned long);
+               memcpy(&curr_reg_size, block + offset, sizeof(EMUFS_REG_SIZE));
+               offset += sizeof(EMUFS_REG_SIZE);

                if (curr_reg_id == reg_id) {
                        /* XXX Posible checkeo de reg_size == curr_reg_size */
                        memcpy(reg_ptr, block + offset, curr_reg_size);
                if (curr_reg_id == reg_id) {
                        /* XXX Posible checkeo de reg_size == curr_reg_size */
                        memcpy(reg_ptr, block + offset, curr_reg_size);


@@ -87,30 +101,59 @@ int emufs_tipo1_leer_registro(EMUFS* efs, int reg_id, void* reg_ptr, unsigned lo
        return 0;
 }
 
        return 0;
 }
 

-int emufs_tipo1_leer_bloque(EMUFS *emu, int ID, void* ptr)
+int emufs_tipo1_leer_bloque(EMUFS* efs, EMUFS_BLOCK_ID block_id, void *block)
+{
+       FILE* file;
+       char name_f[255];
+       
+       strcpy(name_f,efs->nombre);
+       strcat(name_f,".dat");
+       
+       if ( (file = fopen(name_f,"r"))==NULL ) {
+               return -1; /* FIXME ERROR */
+       }
+       fseek(file,
+                       sizeof(EMUFS_TYPE) +      /* Cabecera tipo */
+                       sizeof(EMUFS_BLOCK_SIZE), /* Cabecera tamaño de bloque */
+                       SEEK_SET);
+       /* FIXME: verificar que no se pase de fin de archivo*/
+       fseek(file, block_id * efs->tam_bloque, SEEK_CUR);
+       if (fread(block, efs->tam_bloque, 1, file) != 1) {
+               fclose(file);
+               return -1;
+       }
+
+       fclose(file);
+       return 0;
+}
+
+EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* emu, void* ptr,
+               EMUFS_REG_SIZE reg_size)

 {
        return -1; /* FIXME Error */
 }
 
 {
        return -1; /* FIXME Error */
 }
 

-int emufs_tipo1_grabar_registro(EMUFS *emu, void *ptr, unsigned long tam)
+/*Graba un bloque en el archivo*/
+int emufs_tipo1_grabar_bloque(EMUFS *emu, void *ptr, EMUFS_BLOCK_ID num_bloque)

 {
        return -1; /* FIXME Error */
 }
 
 /*Busco en el archivo de Id`s un Id valido para un nuevo registro*/
 {
        return -1; /* FIXME Error */
 }
 
 /*Busco en el archivo de Id`s un Id valido para un nuevo registro*/

-int emufs_tipo1_get_id(EMUFS *emu)
+EMUFS_REG_ID emufs_tipo1_get_id(EMUFS *emu)

 {
        return -1; /* FIXME Error */
 }
 
 {
        return -1; /* FIXME Error */
 }
 

-/*Graba un bloque en el archivo*/
-int emufs_tipo1_grabar_bloque(EMUFS *emu, void *ptr, int num)
+/*borra un registro de un bloque y acomoda los registros que quedan*/
+int emufs_tipo1_buscar_registro(EMUFS *emu, EMUFS_REG_ID id_reg)

 {
        return -1; /* FIXME Error */
 }
 
 {
        return -1; /* FIXME Error */
 }
 

-/*borra un registro de un bloque y acomoda los registros que quedan*/
-int emufs_tipo1_borrar_registro(EMUFS *emu, int ID, unsigned long tam_reg)
+int emufs_tipo1_borrar_registro(EMUFS *emu, EMUFS_REG_ID id_reg,
+               EMUFS_REG_SIZE tam_reg)

 {
        return -1; /* FIXME Error */
 }
 {
        return -1; /* FIXME Error */
 }

+

diff --git a/emufs/tipo1.h b/emufs/tipo1.h
index 113a66dab410771c0a54ed66dd03d47257e76cfc..efd68c97060905e70715e7f0ec9bd230778ad6d1 100644 (file)
--- a/emufs/tipo1.h
+++ b/emufs/tipo1.h
@@ -39,25 +39,32 @@
 #define _EMUFS_TIPO1_H_
 
 #include "emufs.h"
 #define _EMUFS_TIPO1_H_
 
 #include "emufs.h"

-#include "did.h"
-#include "idx.h"
-#include "fsc.h"

 
 

-int emufs_tipo1_leer_registro(EMUFS *, int , void *, unsigned long);
+int emufs_tipo1_inicializar(EMUFS*);

 
 

-int emufs_tipo1_leer_bloque(EMUFS *, int , void *);
+/** Lee el registro \param id_reg y lo almacena en \param ptr */
+int emufs_tipo1_leer_registro(EMUFS *emu, EMUFS_REG_ID id_reg, void *ptr,
+               EMUFS_REG_SIZE tam_reg);

 
 

-int emufs_tipo1_grabar_registro(EMUFS *, void *, unsigned long );
+/** Lee el bloque \param num_bloque y lo almacena en \param ptr */
+int emufs_tipo1_leer_bloque(EMUFS *emu, EMUFS_BLOCK_ID num_bloque, void *ptr);

 
 

-int emufs_tipo1_grabar_bloque(EMUFS *, void *, int);
+/** Graba el registro apuntado por \param ptr en el archivo */
+EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* emu, void* ptr, EMUFS_REG_SIZE);

 
 

-int emufs_tipo1_get_id(EMUFS *);
+/** Graba el bloque apuntado por \param ptr en el archivo */
+int emufs_tipo1_grabar_bloque(EMUFS *emu, void *ptr, EMUFS_BLOCK_ID num_bloque);

 
 

-int emufs_tipo1_buscar_registro(EMUFS *, int);
+EMUFS_REG_ID emufs_tipo1_get_id(EMUFS *emu);

 
 

-int emufs_tipo1_buscar_lugar(EMUFS *, unsigned long , int *);
+int emufs_tipo1_buscar_registro(EMUFS *emu, EMUFS_REG_ID id_reg);

 
 

-int emufs_tipo1_borrar_registro(EMUFS*, int, unsigned long);
+int emufs_tipo1_borrar_registro(EMUFS *emu, EMUFS_REG_ID id_reg,
+               EMUFS_REG_SIZE tam_reg);

 
 

+/*
+int emufs_tipo1_buscar_lugar(EMUFS *emu, EMUFS_REG_SIZE tam_reg,
+               EMUFS_FREE *free_space);
+*/

 
 #endif /* _EMUFS_TIPO1_H_ */
 
 #endif /* _EMUFS_TIPO1_H_ */

diff --git a/emufs/tipo1_test.c b/emufs/tipo1_test.c
new file mode 100644 (file)
index 0000000..8b3e1b9
--- /dev/null
+++ b/emufs/tipo1_test.c
@@ -0,0 +1,31 @@
+#include "emufs.h"
+
+int main(int argc, char* argv[]) {
+       EMUFS* efs;
+       char registro1[5];
+       char registro2[6];
+       if (argc < 2) {
+               printf("Faltan argumentos! %s [nombre]\n", argv[0]);
+               return 1;
+       }
+       efs = emufs_abrir(argv[1]);
+       if (!efs) {
+               printf("No se pudo crear el EMUFS.\n");
+               return 1;
+       }
+       if (efs->leer_registro(efs, 1, registro1, 4) == -1) {
+               printf("No se pudo leer el registro 1.\n");
+               return ;
+       }
+       registro1[4] = '\0';
+       printf("Registro 1: %s\n", registro1);
+       if (efs->leer_registro(efs, 1, registro2, 5) == -1) {
+               printf("No se pudo leer el registro 2.\n");
+               return 1;
+       }
+       registro2[5] = '\0';
+       printf("Registro 2: %s\n", registro2);
+       emufs_destruir(efs);
+       return 0;
+}
+

diff --git a/emufs/tipo3.c b/emufs/tipo3.c
index 5ba6af242a496f0bf6b278761e31134164b7bb80..f2d1279a4f2ab069de7e97c83b4c262b801bd71b 100644 (file)
--- a/emufs/tipo3.c
+++ b/emufs/tipo3.c
@@ -38,11 +38,13 @@
 #include "tipo3.h"
 
 /** Leo un registro del archivo, devuelve cero si no lo encuentra.**/
 #include "tipo3.h"
 
 /** Leo un registro del archivo, devuelve cero si no lo encuentra.**/

-int emufs_tipo3_leer_registro(EMUFS *emu, int ID, void *ptr, unsigned long tam_reg)
+int emufs_tipo3_leer_registro(EMUFS *emu, EMUFS_REG_ID ID, void *ptr,
+               EMUFS_REG_SIZE tam_reg)

 {
        char* bloque;
 {
        char* bloque;

-       int block, ID_aux;
-       int iterador = 0;
+       EMUFS_BLOCK_ID block;
+       EMUFS_REG_ID ID_aux;
+       EMUFS_BLOCK_SIZE iterador = 0;

        
        /*si existe, lo busco en el archivo de bloques*/
        block = emufs_idx_buscar_registro(emu,ID); /*me devuelve el nro de bloque al que pertenece el registro*/
        
        /*si existe, lo busco en el archivo de bloques*/
        block = emufs_idx_buscar_registro(emu,ID); /*me devuelve el nro de bloque al que pertenece el registro*/


@@ -61,8 +63,8 @@ int emufs_tipo3_leer_registro(EMUFS *emu, int ID, void *ptr, unsigned long tam_r
        ID_aux = -1;
        iterador = 0;
        while ( iterador < emu->tam_bloque ) {
        ID_aux = -1;
        iterador = 0;
        while ( iterador < emu->tam_bloque ) {

-               memcpy(&ID_aux, bloque+iterador, sizeof(int));
-               iterador += sizeof(int);
+               memcpy(&ID_aux, bloque+iterador, sizeof(EMUFS_REG_ID));
+               iterador += sizeof(EMUFS_REG_ID);

                if ( ID_aux == ID ){
                        memcpy(ptr,bloque+iterador,tam_reg);
                        break;
                if ( ID_aux == ID ){
                        memcpy(ptr,bloque+iterador,tam_reg);
                        break;


@@ -75,7 +77,7 @@ int emufs_tipo3_leer_registro(EMUFS *emu, int ID, void *ptr, unsigned long tam_r
 }
 
 /*leo el bloque "ID" del archivo que viene en "emu->nombre", y lo almaceno en "ptr"*/
 }
 
 /*leo el bloque "ID" del archivo que viene en "emu->nombre", y lo almaceno en "ptr"*/

-int emufs_tipo3_leer_bloque(EMUFS *emu, int ID, void* ptr)
+int emufs_tipo3_leer_bloque(EMUFS *emu, EMUFS_REG_ID ID, void* ptr)

 {
        FILE* file;
        char name_f[255];
 {
        FILE* file;
        char name_f[255];


@@ -84,7 +86,7 @@ int emufs_tipo3_leer_bloque(EMUFS *emu, int ID, void* ptr)
        strcat(name_f,".dat");
        
        if ( (file = fopen(name_f,"r"))==NULL ) return -1; /*ERROR*/
        strcat(name_f,".dat");
        
        if ( (file = fopen(name_f,"r"))==NULL ) return -1; /*ERROR*/

-       fseek(file,sizeof(int)+sizeof(char)+sizeof(int),SEEK_SET);
+       fseek(file,sizeof(EMUFS_TYPE)+sizeof(EMUFS_BLOCK_SIZE)+sizeof(EMUFS_REG_SIZE),SEEK_SET);

        /*FIXME: verificar que no se pase de fin de archivo*/
        fseek(file,ID*emu->tam_bloque,SEEK_CUR);
        if (fread(ptr,emu->tam_bloque,1,file)!=1) return -1;
        /*FIXME: verificar que no se pase de fin de archivo*/
        fseek(file,ID*emu->tam_bloque,SEEK_CUR);
        if (fread(ptr,emu->tam_bloque,1,file)!=1) return -1;


@@ -93,9 +95,12 @@ int emufs_tipo3_leer_bloque(EMUFS *emu, int ID, void* ptr)
        return 0;
 }
 
        return 0;
 }
 

-int emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, unsigned long tam)
+EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE tam)

 {
 {

-       int ID_aux, fs, num_bloque, cant;
+       EMUFS_REG_ID ID_aux;
+       EMUFS_FREE fs;
+       EMUFS_BLOCK_ID num_bloque;
+       EMUFS_BLOCK_SIZE cant;

        FILE *file;
        char name_f[255];
        char* bloque;
        FILE *file;
        char name_f[255];
        char* bloque;


@@ -114,9 +119,9 @@ int emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, unsigned long tam)
                /*tengo que buscar un ID valido para el nuevo registro*/
                ID_aux = emufs_tipo3_get_id(emu);
                /*grabo el id en el bloque*/
                /*tengo que buscar un ID valido para el nuevo registro*/
                ID_aux = emufs_tipo3_get_id(emu);
                /*grabo el id en el bloque*/

-               memcpy(bloque,&ID_aux,sizeof(int));
+               memcpy(bloque,&ID_aux,sizeof(EMUFS_REG_ID));

                /*grabo el registro en el bloque*/
                /*grabo el registro en el bloque*/

-               memcpy(bloque+sizeof(int),ptr,tam);
+               memcpy(bloque+sizeof(EMUFS_REG_ID),ptr,tam);

                /* me paro al final del archivo */
                fseek(file, 0, SEEK_END); 
                /* grabo el bloque en el final del archivo */
                /* me paro al final del archivo */
                fseek(file, 0, SEEK_END); 
                /* grabo el bloque en el final del archivo */


@@ -125,11 +130,13 @@ int emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, unsigned long tam)
                /*tengo que buscar la cantidad de bloques que existen*/
                /*me paro al principio salteando el encabezado del archivo*/
                fseek(file, 0, SEEK_END); /* Me paro al final */
                /*tengo que buscar la cantidad de bloques que existen*/
                /*me paro al principio salteando el encabezado del archivo*/
                fseek(file, 0, SEEK_END); /* Me paro al final */

+               /* FIXME FIXME FIXME FALTA TRADUCIR A EMUFS_XXXX */

                cant = (ftell(file)-(sizeof(int)*2+sizeof(char))) / emu->tam_bloque;
                cant--; /* Resto uno porque el numero de bloque debe empezar en 0 */
                fclose(file);
                num_bloque = cant;
                /* grabo el nuevo registro en el archivo de espacios libres */
                cant = (ftell(file)-(sizeof(int)*2+sizeof(char))) / emu->tam_bloque;
                cant--; /* Resto uno porque el numero de bloque debe empezar en 0 */
                fclose(file);
                num_bloque = cant;
                /* grabo el nuevo registro en el archivo de espacios libres */

+               /* FIXME FIXME FIXME FALTA TRADUCIR A EMUFS_XXXX */

                if ( emufs_fsc_agregar(emu, num_bloque, emu->tam_bloque - tam - sizeof(int)) != 0 ) {
                        free(bloque);
                        return -1;
                if ( emufs_fsc_agregar(emu, num_bloque, emu->tam_bloque - tam - sizeof(int)) != 0 ) {
                        free(bloque);
                        return -1;


@@ -146,15 +153,16 @@ int emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, unsigned long tam)
                /*tengo que buscar un ID valido para el nuevo registro*/
                ID_aux = emufs_tipo3_get_id(emu);
                /*grabo el id en el bloque*/
                /*tengo que buscar un ID valido para el nuevo registro*/
                ID_aux = emufs_tipo3_get_id(emu);
                /*grabo el id en el bloque*/

-               memcpy(bloque+emu->tam_bloque-fs,&ID_aux,sizeof(int));
+               memcpy(bloque+emu->tam_bloque-fs,&ID_aux,sizeof(EMUFS_REG_ID));

                /*grabo el registro en el bloque*/
                /*grabo el registro en el bloque*/

-               memcpy(bloque+emu->tam_bloque-fs+sizeof(int),ptr,tam);
+               memcpy(bloque+emu->tam_bloque-fs+sizeof(EMUFS_REG_ID),ptr,tam);

                /*guardo el bloque en el archivo*/
                if ( emufs_tipo3_grabar_bloque(emu, bloque, num_bloque) != 0) {
                        printf("error al grabar bloque\n");
                        return -1; /* se produjo un error */    
                }
                /*actualizo el archivo de espacios libres*/
                /*guardo el bloque en el archivo*/
                if ( emufs_tipo3_grabar_bloque(emu, bloque, num_bloque) != 0) {
                        printf("error al grabar bloque\n");
                        return -1; /* se produjo un error */    
                }
                /*actualizo el archivo de espacios libres*/

+               /* FIXME FIXME FIXME FALTA TRADUCIR A EMUFS_XXXX */

                if ( emufs_fsc_actualizar(emu, num_bloque, fs - tam - sizeof(int)) != 0 ){
                        free(bloque);
                        return -1;
                if ( emufs_fsc_actualizar(emu, num_bloque, fs - tam - sizeof(int)) != 0 ){
                        free(bloque);
                        return -1;


@@ -172,9 +180,9 @@ int emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, unsigned long tam)
 }
 
 /*Busco en el archivo de Id`s un Id valido para un nuevo registro*/
 }
 
 /*Busco en el archivo de Id`s un Id valido para un nuevo registro*/

-int emufs_tipo3_get_id(EMUFS *emu)
+EMUFS_REG_ID emufs_tipo3_get_id(EMUFS *emu)

 {
 {

-       int id;
+       EMUFS_REG_ID id;

 
        if ( (id = emufs_did_get_last(emu)) == -1 )
                id = emufs_idx_buscar_mayor_id(emu);
 
        if ( (id = emufs_did_get_last(emu)) == -1 )
                id = emufs_idx_buscar_mayor_id(emu);


@@ -182,7 +190,7 @@ int emufs_tipo3_get_id(EMUFS *emu)
 }
 
 /*Graba un bloque en el archivo*/
 }
 
 /*Graba un bloque en el archivo*/

-int emufs_tipo3_grabar_bloque(EMUFS *emu, void *ptr, int num)
+int emufs_tipo3_grabar_bloque(EMUFS *emu, void *ptr, EMUFS_BLOCK_ID num)

 {
        FILE* file;
        char name_f[255];
 {
        FILE* file;
        char name_f[255];


@@ -201,9 +209,13 @@ int emufs_tipo3_grabar_bloque(EMUFS *emu, void *ptr, int num)
 }
 
 /*borra un registro de un bloque y acomoda los registros que quedan*/
 }
 
 /*borra un registro de un bloque y acomoda los registros que quedan*/

-int emufs_tipo3_borrar_registro(EMUFS *emu, int ID, unsigned long tam_reg)
+int emufs_tipo3_borrar_registro(EMUFS *emu, EMUFS_REG_ID ID, EMUFS_REG_SIZE tam_reg)

 {
 {

-       int num_bloque, ptr_elim, ptr_mov, ID_aux, fs;
+       EMUFS_BLOCK_SIZE num_bloque;
+       EMUFS_BLOCK_SIZE ptr_elim;
+       EMUFS_BLOCK_SIZE ptr_mov;
+       EMUFS_REG_ID ID_aux;
+       EMUFS_FREE fs;

        char *bloque;
 
        num_bloque = emufs_idx_buscar_registro(emu, ID);
        char *bloque;
 
        num_bloque = emufs_idx_buscar_registro(emu, ID);


@@ -216,19 +228,19 @@ int emufs_tipo3_borrar_registro(EMUFS *emu, int ID, unsigned long tam_reg)
        /*apunto al registro que voy a eliminar*/
        ptr_elim = 0;
        while ( ptr_elim < emu->tam_bloque ){
        /*apunto al registro que voy a eliminar*/
        ptr_elim = 0;
        while ( ptr_elim < emu->tam_bloque ){

-               memcpy(&ID_aux, bloque+ptr_elim, sizeof(int));
+               memcpy(&ID_aux, bloque+ptr_elim, sizeof(EMUFS_REG_ID));

                if ( ID_aux == ID )
                        break;
                if ( ID_aux == ID )
                        break;

-               ptr_elim += tam_reg + sizeof(int);
+               ptr_elim += tam_reg + sizeof(EMUFS_REG_ID);

        }
        
        /*apunto al registro que voy a mover*/
        }
        
        /*apunto al registro que voy a mover*/

-       ptr_mov = ptr_elim + tam_reg + sizeof(int);
+       ptr_mov = ptr_elim + tam_reg + sizeof(EMUFS_REG_ID);

        
        while ( ptr_mov < emu->tam_bloque ){
        
        while ( ptr_mov < emu->tam_bloque ){

-               memcpy(bloque+ptr_elim, bloque+ptr_mov, sizeof(int)+tam_reg);
+               memcpy(bloque+ptr_elim, bloque+ptr_mov, sizeof(EMUFS_REG_ID)+tam_reg);

                ptr_elim = ptr_mov;
                ptr_elim = ptr_mov;

-               ptr_mov += sizeof(int) + tam_reg;
+               ptr_mov += sizeof(EMUFS_REG_ID) + tam_reg;

        }
        
        /*grabo el bloque en el archivo*/       
        }
        
        /*grabo el bloque en el archivo*/       


@@ -239,7 +251,7 @@ int emufs_tipo3_borrar_registro(EMUFS *emu, int ID, unsigned long tam_reg)
        
        /*actualizo archivo .fsc*/
        fs = emufs_fsc_get_fs(emu, num_bloque);
        
        /*actualizo archivo .fsc*/
        fs = emufs_fsc_get_fs(emu, num_bloque);

-       if ( emufs_fsc_actualizar(emu, num_bloque, fs + tam_reg + sizeof(int)) != 0 ) return -1;
+       if ( emufs_fsc_actualizar(emu, num_bloque, fs + tam_reg + sizeof(EMUFS_REG_ID)) != 0 ) return -1;

        
        /*actualizo archivo .did*/
        if ( emufs_did_agregar(emu, ID) != 0 ) return -1;
        
        /*actualizo archivo .did*/
        if ( emufs_did_agregar(emu, ID) != 0 ) return -1;

diff --git a/emufs/tipo3.h b/emufs/tipo3.h
index ad84d81effa16fca18e1ca182880e6ac0e5d9db3..2b9fdeb470872fa1d42fa07f141f1dea0a8686f3 100644 (file)
--- a/emufs/tipo3.h
+++ b/emufs/tipo3.h
@@ -47,26 +47,27 @@
 #include "idx.h"
 #include "fsc.h"
 
 #include "idx.h"
 #include "fsc.h"
 

-

 /** Lee el registro \param id_reg y lo almacena en \param ptr */
 /** Lee el registro \param id_reg y lo almacena en \param ptr */

-int emufs_tipo3_leer_registro(EMUFS *emu, int id_reg, void *ptr, unsigned long tam_reg);
+int emufs_tipo3_leer_registro(EMUFS *emu, EMUFS_REG_ID id_reg, void *ptr,
+               EMUFS_REG_SIZE tam_reg);

 
 /** Lee el bloque \param num_bloque y lo almacena en \param ptr */
 
 /** Lee el bloque \param num_bloque y lo almacena en \param ptr */

-int emufs_tipo3_leer_bloque(EMUFS *emu, int num_bloque, void *ptr);
+int emufs_tipo3_leer_bloque(EMUFS *emu, EMUFS_BLOCK_ID num_bloque, void *ptr);

 
 /** Graba el registro apuntado por \param ptr en el archivo */
 
 /** Graba el registro apuntado por \param ptr en el archivo */

-int emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, unsigned long tam_reg);
+EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE tam_reg);

 
 /** Graba el bloque apuntado por \param ptr en el archivo */
 
 /** Graba el bloque apuntado por \param ptr en el archivo */

-int emufs_tipo3_grabar_bloque(EMUFS *emu, void *ptr, int num_bloque);
-
-int emufs_tipo3_get_id(EMUFS *emu);
+int emufs_tipo3_grabar_bloque(EMUFS *emu, void *ptr, EMUFS_BLOCK_ID num_bloque);

 
 

-int emufs_tipo3_buscar_registro(EMUFS *emu, int id_reg);
+EMUFS_REG_ID emufs_tipo3_get_id(EMUFS *emu);

 
 

-int emufs_tipo3_buscar_lugar(EMUFS *emu, unsigned long tam_reg, int *free_space);
+int emufs_tipo3_buscar_registro(EMUFS *emu, EMUFS_REG_ID id_reg);

 
 

-int emufs_tipo3_borrar_registro(EMUFS *emu, int id_reg, unsigned long tam_reg);
+int emufs_tipo3_buscar_lugar(EMUFS *emu, EMUFS_REG_SIZE tam_reg,
+               EMUFS_FREE *free_space);

 
 

+int emufs_tipo3_borrar_registro(EMUFS *emu, EMUFS_REG_ID id_reg,
+               EMUFS_REG_SIZE tam_reg);

 
 #endif /* _EMUFS_TIPO3_H_ */
 
 #endif /* _EMUFS_TIPO3_H_ */