Cambios Realizados (son varios, read carefuly):

A) En los tres sets de rutinas para el manejo de los archivos auxiliares IDX,FSC y DID, se utilizan ahora los nuevos tipos de datos que definio Luca (son unsigned long int todos creo). Ademas, yo modifique algunas rutinas (y voy a tener que seguir modificando), para que se acomodem al esquema del Archivo Tipo2, en donde no tenemos bloques, tonces hay unas mini-diferencias ya que tenemos Gaps, no hay recompactacion automatica (perderia sentido tener los Gaps), se maneja la localizacion de los registros por Offsets y no bloque, etc.

B) En IDX, fixee la rutina que busca un registro por su ID. El problema que detecte ayer cuando la use, era que si terminaba de recorrer y no lo encontraba en vez de devolver -1, devolvia el ultimo ID que levanto.

C) En EMUFS.c|h, agrege a la estructura un campo para guardar el tamanio de registro, a ser utilizado solo por el Tipo3. Asi mismo, saque el ultimo parametro de la funcion dinamica borrar_registro en la cual se pasaba dicho dato, pues ahora ya se pasa en la estructura.

En el Emufs.c, ahora se deberia estar levantan correctamente el tamanio de registro en el header del archivo Tipo3 (chequeen ese OR por favor), por lo que Nico simplemente modificando tu funcion emufs_tipo3_borrar_registro, para que levante el dato de la estructura y no ese tercer parametro que ya no esta mas, deberia salir andando.

D) Por lo explicado anterioremente deshabilite las asignaciones en los Tipo1 y 3, de la rutina para Borrar Registros.

E) Tipo1 y Tipo3 me compilan, pero no se si estan tirando bien el output (o sea no se si es lo esperado). Fijense antes que nada en los printf que ahora es un unsigned int lo que se imprime y no integer, por lo que si ven un numero raro puede ser por eso. Los dos tests compilan sin warnings salvo el del truncate, pero recuerden que les saque el borrar registro, fix that.

-------------------------------------------
Bueno eso es todo, me tomo un buen rato reordenar esto con los tipos nuevos y lo que yo tenia desde ayer. Ahora voy a ver si puedo dejar mi tipo2 andando como lo habia dejado ayer y lo subo mas tarde. Por ahora solo grabo registros, ayer empeze hacer el borrar registro mio pero quebre (toy enfermo). Calculo que se me va a complicar un toque dado que si borro dos registros consecutivos deberia hacer un merge de esos dos gaps y dejarlo como uno solo en el .DID, pero bueno problema mio, cualquier cosa les pido ayuda.

Saludos, si me necesitan toy en ICQ hasta la noche facil, laburando sobre el TP.

diff --git a/emufs/Makefile b/emufs/Makefile
index 5ec47676ab8a43f9c22acb4e3e3b80bbf819cc51..e6f24ff4950e47a01e3971230444d00c00a40274 100644 (file)
--- a/emufs/Makefile
+++ b/emufs/Makefile
@@ -1,7 +1,7 @@
 CFLAGS=-Wall -g -ansi -pedantic -DDEBUG
 LDFLAGS=
 
 CFLAGS=-Wall -g -ansi -pedantic -DDEBUG
 LDFLAGS=
 

-EMUFS_COMMON=emufs.o tipo1.o tipo3.o idx.o did.o fsc.o
+EMUFS_COMMON=emufs.o tipo1.o tipo2.o tipo3.o idx.o did.o fsc.o

 
 all: libemufs.a tipo1_test tipo3_main
 
 
 all: libemufs.a tipo1_test tipo3_main
 


@@ -13,4 +13,4 @@ libemufs.a: $(EMUFS_COMMON)
        ar cru libemufs.a tipo3.o $(EMUFS_COMMON)
 
 clean:
        ar cru libemufs.a tipo3.o $(EMUFS_COMMON)
 
 clean:

-       @rm -fv *.o tipo3_main
+       @rm -fv *.o tipo3_main tipo1_test articulos.*

diff --git a/emufs/did.c b/emufs/did.c
index 9eb47daa235b01e65648f0a02ba5e2979d31738d..5c386b5d6654a9931e3e2f244f7d7f2cd6007761 100644 (file)
--- a/emufs/did.c
+++ b/emufs/did.c
@@ -40,23 +40,13 @@
 #include <string.h>
 #include <unistd.h>
 
 #include <string.h>
 #include <unistd.h>
 

-/**********************************************************************/
-/* int emufs_did_crear(EMUFS* efs)                                    */
-/*                                                                                                                                                  */
-/* Objetivo: Crea un archivo de ID's Liberados.                       */
-/* Parametros: EMUFS *efs // Struct con handlers de un Data File.     */
-/**********************************************************************/
+/* Crea un archivo de ID's Liberados. */

 int emufs_did_crear(EMUFS* efs)
 {
        return emufs_crear_archivo_auxiliar(efs->nombre, EMUFS_DID_EXT);
 }
 
 int emufs_did_crear(EMUFS* efs)
 {
        return emufs_crear_archivo_auxiliar(efs->nombre, EMUFS_DID_EXT);
 }
 

-/**********************************************************************/
-/* EMUFS_REG_ID emufs_did_get_last(EMUFS *efs)                        */
-/*                                                                                                                                                  */
-/* Objetivo: Devuelve el ID Libre, liberado mas recientemente (pila)  */
-/* Parametros: EMUFS *efs // Struct con handlers + info del openfile. */
-/**********************************************************************/
+/* Devuelve el ID Libre, liberado mas recientemente (pila) */

 EMUFS_REG_ID emufs_did_get_last(EMUFS *efs)
 {
        FILE *f_did;
 EMUFS_REG_ID emufs_did_get_last(EMUFS *efs)
 {
        FILE *f_did;


@@ -90,13 +80,7 @@ EMUFS_REG_ID emufs_did_get_last(EMUFS *efs)
        return n_RegId;
 }
 
        return n_RegId;
 }
 

-/**********************************************************************/
-/* int emufs_did_agregar(EMUFS *efs, EMUFS_REG_ID n_RegId)            */
-/*                                                                                                                                                  */
-/* Objetivo: Agrega un registro al archivo de ID's Libres (pila)      */
-/* Parametros: EMUFS *efs // Struct con handlers + info del openfile. */
-/*             EMUFS_REG_ID n_RegId // Id Libre a agregar.            */
-/**********************************************************************/
+/* Agrega un registro al archivo de ID's Libres (pila) */

 int emufs_did_agregar(EMUFS *efs, EMUFS_REG_ID n_RegId)
 {
        FILE *f_did;
 int emufs_did_agregar(EMUFS *efs, EMUFS_REG_ID n_RegId)
 {
        FILE *f_did;

diff --git a/emufs/emufs.c b/emufs/emufs.c
index 7ddd4bd72c608f3a903187a02f532cf7b648d337..b67ffaa5f1be9459d4b7be61f1f487a42034bb6d 100644 (file)
--- a/emufs/emufs.c
+++ b/emufs/emufs.c
@@ -40,6 +40,7 @@
 
 #include "emufs.h"
 #include "tipo1.h"
 
 #include "emufs.h"
 #include "tipo1.h"

+#include "tipo2.h"

 #include "tipo3.h"
 #include "did.h"
 #include "fsc.h"
 #include "tipo3.h"
 #include "did.h"
 #include "fsc.h"


@@ -47,6 +48,7 @@
 
 char *str_dup(const char *s);
 
 
 char *str_dup(const char *s);
 

+/* Duplica una cadena de caracteres y devuelve la copia.  */

 char *str_dup(const char *s)
 {
        char *tmp;
 char *str_dup(const char *s)
 {
        char *tmp;


@@ -56,6 +58,7 @@ char *str_dup(const char *s)
        return tmp;
 }
 
        return tmp;
 }
 

+/* Objetivo: Crea un archivo de nombre y extension dadas. */

 int emufs_crear_archivo_auxiliar(const char* name, const char* ext)
 {
        FILE* f;
 int emufs_crear_archivo_auxiliar(const char* name, const char* ext)
 {
        FILE* f;


@@ -78,7 +81,7 @@ int emufs_crear_archivo_auxiliar(const char* name, const char* ext)
        return 0;
 }
 
        return 0;
 }
 

-
+/* Crea un archivo de tipo dado y devuelve una estructura con las rutinas de handling de dicho archivo. */

 EMUFS *emufs_crear(const char *filename, EMUFS_TYPE tipo,
                EMUFS_BLOCK_SIZE tam_bloque, EMUFS_REG_SIZE tam_reg)
 {
 EMUFS *emufs_crear(const char *filename, EMUFS_TYPE tipo,
                EMUFS_BLOCK_SIZE tam_bloque, EMUFS_REG_SIZE tam_reg)
 {


@@ -96,9 +99,10 @@ EMUFS *emufs_crear(const char *filename, EMUFS_TYPE tipo,
        if (efs == NULL) {
                return NULL;
        }
        if (efs == NULL) {
                return NULL;
        }

-       efs->tipo       = tipo;
+       efs->tipo = tipo;

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

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

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


@@ -150,6 +154,11 @@ EMUFS *emufs_crear(const char *filename, EMUFS_TYPE tipo,
                        break;
 
                case T2:
                        break;
 
                case T2:

+                       /* Asigna punteros a funciones. */
+                       efs->grabar_registro = emufs_tipo2_grabar_registro;           
+            efs->borrar_registro = emufs_tipo2_borrar_registro;
+                       efs->nombre = str_dup(filename);
+                   /*efs->leer_registro = emufs_tipo2_leer_registro;*/                                         

                        break;
 
                case T3:
                        break;
 
                case T3:


@@ -157,12 +166,11 @@ EMUFS *emufs_crear(const char *filename, EMUFS_TYPE tipo,
                        efs->leer_bloque     = emufs_tipo3_leer_bloque;
                        efs->leer_registro   = emufs_tipo3_leer_registro;
                        efs->grabar_registro = emufs_tipo3_grabar_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;
+                       /*efs->borrar_registro = emufs_tipo3_borrar_registro;*/

 
                        /* Guarda cabeceras propias. */
                        fwrite(&tam_bloque, sizeof(EMUFS_BLOCK_SIZE), 1, fp);
 
                        /* Guarda cabeceras propias. */
                        fwrite(&tam_bloque, sizeof(EMUFS_BLOCK_SIZE), 1, fp);

-                       fwrite(&tam_reg, sizeof(EMUFS_REG_SIZE), 1, fp);
-                       
+                       fwrite(&tam_reg, sizeof(EMUFS_REG_SIZE), 1, fp);                        

                        break;
 
        }
                        break;
 
        }


@@ -171,6 +179,7 @@ EMUFS *emufs_crear(const char *filename, EMUFS_TYPE tipo,
        return efs;
 }
 
        return efs;
 }
 

+/* Realiza la apertura de un archivo dado, identifica el tipo de archivo y devuelve la estructura de handling. */

 EMUFS *emufs_abrir(const char *filename)
 {
        EMUFS *efs;
 EMUFS *emufs_abrir(const char *filename)
 {
        EMUFS *efs;


@@ -215,17 +224,18 @@ EMUFS *emufs_abrir(const char *filename)
                case T2:
                        break;
                case T3:
                case T2:
                        break;
                case T3:

-                       if (!fread(&(efs->tam_bloque), sizeof(EMUFS_BLOCK_SIZE), 1, fp)) {
+                       if ((!fread(&(efs->tam_bloque), sizeof(EMUFS_BLOCK_SIZE), 1, fp)) ||
+                          (!fread(&(efs->tam_reg), sizeof(EMUFS_REG_SIZE), 1, fp)))
+                               {

                                free(efs->nombre);
                                free(efs);
                                fclose(fp);
                                return NULL;
                                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->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;
+                       /*efs->borrar_registro = emufs_tipo3_borrar_registro;*/

                        break;
        }
 
                        break;
        }
 


@@ -233,6 +243,7 @@ EMUFS *emufs_abrir(const char *filename)
        return efs;
 }
 
        return efs;
 }
 

+/* Objetivo: Rutina llamada al destruir la aplicacion para librerar  */

 int emufs_destruir(EMUFS *e)
 {
        if (e == NULL) return 1;
 int emufs_destruir(EMUFS *e)
 {
        if (e == NULL) return 1;


@@ -241,6 +252,7 @@ int emufs_destruir(EMUFS *e)
        return 0;
 }
 
        return 0;
 }
 

+/* Visualiza espacios libres de un archivo?? */

 int ver_archivo_FS(EMUFS *emu)
 {
        FILE *f_block_free;
 int ver_archivo_FS(EMUFS *emu)
 {
        FILE *f_block_free;


@@ -256,7 +268,7 @@ int ver_archivo_FS(EMUFS *emu)
        }
        fread(&reg,sizeof(reg),1,f_block_free);
        while ( !feof(f_block_free) ){
        }
        fread(&reg,sizeof(reg),1,f_block_free);
        while ( !feof(f_block_free) ){

-               printf(" Bloque = %d   Espacio libre = %d\n",reg.block, reg.free_space);
+               printf(" Bloque = %li   Espacio libre = %li\n",reg.n_Marker, reg.n_FreeSpace);

                fread(&reg,sizeof(reg),1,f_block_free);
        }
        
                fread(&reg,sizeof(reg),1,f_block_free);
        }
        


@@ -271,7 +283,7 @@ int ver_archivo_FS(EMUFS *emu)
                f_block_free = fopen(name_f_block_free, "r");
                fread(&r, sizeof(EMUFS_IDX), 1, f_block_free);
                while (!feof(f_block_free)) {
                f_block_free = fopen(name_f_block_free, "r");
                fread(&r, sizeof(EMUFS_IDX), 1, f_block_free);
                while (!feof(f_block_free)) {

-                       printf("ID %ld en bloque %d\n", r.id_reg, r.block);
+                       printf("ID %li en bloque %li\n", r.n_IdReg, r.n_Location);

                        fread(&r, sizeof(EMUFS_IDX), 1, f_block_free);
                }
                fclose(f_block_free);
                        fread(&r, sizeof(EMUFS_IDX), 1, f_block_free);
                }
                fclose(f_block_free);

diff --git a/emufs/emufs.h b/emufs/emufs.h
index cd25bb5eef20e52f2b7294840da2f020fc2fb74d..0ce08de1e1e1f9af9051bb70fe7deedfbd311f66 100644 (file)
--- a/emufs/emufs.h
+++ b/emufs/emufs.h
@@ -89,10 +89,11 @@ typedef unsigned long EMUFS_OFFSET;
 typedef struct _emu_fs_t {
        EMUFS_TYPE tipo;
        EMUFS_BLOCK_SIZE tam_bloque; /**< Tamaño de bloque. 0 Si no tiene bloques */
 typedef struct _emu_fs_t {
        EMUFS_TYPE tipo;
        EMUFS_BLOCK_SIZE tam_bloque; /**< Tamaño de bloque. 0 Si no tiene bloques */

+    EMUFS_REG_SIZE tam_reg; /**< Tamaño de registro. 0 Si son registros variables */   

        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 (*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 ??? */
+       int (*borrar_registro)(struct _emu_fs_t*, EMUFS_REG_ID); /**< Método para borrar un registro */

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

diff --git a/emufs/fsc.c b/emufs/fsc.c
index 05218a6c19893cc596688e792826d28d101349e8..1cf873f481b9981df215fc06bcedb6520e36e4db 100644 (file)
--- a/emufs/fsc.c
+++ b/emufs/fsc.c
@@ -39,12 +39,14 @@
 #include <string.h>
 #include <unistd.h>
 
 #include <string.h>
 #include <unistd.h>
 

+/* Crea un archivo de Gaps o Espacio Libre en Bloque */

 int emufs_fsc_crear(EMUFS* efs)
 {
        return emufs_crear_archivo_auxiliar(efs->nombre, EMUFS_FSC_EXT);
 }
 
 int emufs_fsc_crear(EMUFS* efs)
 {
        return emufs_crear_archivo_auxiliar(efs->nombre, EMUFS_FSC_EXT);
 }
 

-int emufs_fsc_agregar(EMUFS *emu, EMUFS_BLOCK_ID num_bloque, EMUFS_FREE fs)
+/* Agrega un registro al archivo de espacios libres. */
+int emufs_fsc_agregar(EMUFS *emu, EMUFS_BLOCK_ID n_Marker, EMUFS_FREE n_FreeSpace)

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


@@ -53,18 +55,19 @@ int emufs_fsc_agregar(EMUFS *emu, EMUFS_BLOCK_ID num_bloque, EMUFS_FREE fs)
        strcpy(name_f_fsc,emu->nombre);
        strcat(name_f_fsc, EMUFS_FSC_EXT);
        
        strcpy(name_f_fsc,emu->nombre);
        strcat(name_f_fsc, EMUFS_FSC_EXT);
        

-       /*cargo el registro*/
-       reg.block = num_bloque; 
-       reg.free_space = fs;
-       /*lo guardo en el archivo al final  "a+"*/
+       /* Cargo el registro */
+       reg.n_Marker = n_Marker;
+       reg.n_FreeSpace = n_FreeSpace;
+
+       /* Lo guardo en el archivo al final "a+"*/

        if ( (f_fsc = fopen(name_f_fsc,"a+"))==NULL ) return -1;
        fwrite(&reg,sizeof(EMUFS_FSC),1,f_fsc);
        fclose(f_fsc);
        return 0;
 }
 
        if ( (f_fsc = fopen(name_f_fsc,"a+"))==NULL ) return -1;
        fwrite(&reg,sizeof(EMUFS_FSC),1,f_fsc);
        fclose(f_fsc);
        return 0;
 }
 

-/* busca el bloque y le resta fs de espacio libre */
-int emufs_fsc_actualizar(EMUFS *emu, EMUFS_BLOCK_ID num_bloque, EMUFS_FREE fs)
+/* Objetivo: Actualiza un registro de espacio libre de acorde al FType */
+int emufs_fsc_actualizar(EMUFS *emu, EMUFS_BLOCK_ID n_Marker, EMUFS_FREE n_FreeSpace)

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


@@ -73,12 +76,12 @@ int emufs_fsc_actualizar(EMUFS *emu, EMUFS_BLOCK_ID num_bloque, EMUFS_FREE fs)
        strcpy(name_f_fsc,emu->nombre);
        strcat(name_f_fsc, EMUFS_FSC_EXT);
 
        strcpy(name_f_fsc,emu->nombre);
        strcat(name_f_fsc, EMUFS_FSC_EXT);
 

-       /*busco el bloque que modifique*/
-       if ( (f_fsc = fopen(name_f_fsc,"r+")) == NULL) return -1; 
+       /*busco el bloque o gap que modifique*/
+    if ( (f_fsc = fopen(name_f_fsc,"r+")) == NULL) return -1; 

        while ( !feof(f_fsc) ){
                if ( fread(&reg,sizeof(EMUFS_FSC),1,f_fsc) != 1) continue;
        while ( !feof(f_fsc) ){
                if ( fread(&reg,sizeof(EMUFS_FSC),1,f_fsc) != 1) continue;

-               if ( reg.block == num_bloque ){
-                       reg.free_space = fs;
+               if ( reg.n_Marker == n_Marker ){
+                       reg.n_FreeSpace = n_FreeSpace;

                        fseek(f_fsc,-sizeof(EMUFS_FSC),SEEK_CUR);
                        fwrite(&reg,sizeof(EMUFS_FSC),1,f_fsc);
                        break;
                        fseek(f_fsc,-sizeof(EMUFS_FSC),SEEK_CUR);
                        fwrite(&reg,sizeof(EMUFS_FSC),1,f_fsc);
                        break;


@@ -88,40 +91,39 @@ int emufs_fsc_actualizar(EMUFS *emu, EMUFS_BLOCK_ID num_bloque, EMUFS_FREE fs)
        return 0;
 }
 
        return 0;
 }
 

-/* me devuelve el ID del bloque donde quepa un registro, y guarda en fs el espacio libre que queda en el bloque */
-EMUFS_BLOCK_ID emufs_fsc_buscar_lugar(EMUFS *emu, EMUFS_FREE tam, EMUFS_FREE *fs)
+/* Me devuelve el ID del bloque u Offset del Gap donde quepa un registro, y guarda en n_FreeSpace el espacio libre actualizado */
+EMUFS_BLOCK_ID emufs_fsc_buscar_lugar(EMUFS *emu, EMUFS_FREE n_RegSize, EMUFS_FREE *n_FreeSpace)

 {
        FILE *f_fsc;
        EMUFS_FSC reg;
        char name_f_fsc[255];
 {
        FILE *f_fsc;
        EMUFS_FSC reg;
        char name_f_fsc[255];

+       unsigned short int b_Found = 0;

        
        strcpy(name_f_fsc,emu->nombre);
        strcat(name_f_fsc, EMUFS_FSC_EXT);
 
        if ( (f_fsc = fopen(name_f_fsc,"r"))==NULL ) return -1;
 
        
        strcpy(name_f_fsc,emu->nombre);
        strcat(name_f_fsc, EMUFS_FSC_EXT);
 
        if ( (f_fsc = fopen(name_f_fsc,"r"))==NULL ) return -1;
 

-       /* Inicializo la estructura para evitar que si el archivo esta vacio
-        * el resultado sea correcto
-        */
-       reg.block = -1;
-       *fs = emu->tam_bloque;
-       while( !feof(f_fsc) ){
+       /* Inicializamos la estructura para devolver algun valor en concreto */
+       /* en caso de que no se halle un espacio libre apropiado */
+       while(!feof(f_fsc) && !b_Found){

                if (fread(&reg,sizeof(EMUFS_FSC),1,f_fsc) != 1) continue;
                if (fread(&reg,sizeof(EMUFS_FSC),1,f_fsc) != 1) continue;

-               if (reg.free_space >= tam) {
-                       break;
-               } else {
-                       reg.block = -1;
-                       *fs = emu->tam_bloque;
-               }
+               if (reg.n_FreeSpace >= n_RegSize) b_Found = 1;

        }
        
        }
        

+       /* Si salio por error o por fin de archivo y no encontro space... */
+       if (!b_Found) {
+         reg.n_Marker = -1;
+         *n_FreeSpace = emu->tam_bloque; 
+       }
+       else *n_FreeSpace = reg.n_FreeSpace;
+       

        fclose(f_fsc);
        fclose(f_fsc);

-       if (reg.block != -1)
-               *fs = reg.free_space;
-       return reg.block;
+       return reg.n_Marker;

 }
 
 }
 

-EMUFS_FREE emufs_fsc_get_fs(EMUFS *emu, EMUFS_BLOCK_ID num_bloque)
+/* Devuelve el espacio libre de un Bloque o Gap dado */
+EMUFS_FREE emufs_fsc_get_fs(EMUFS *emu, EMUFS_BLOCK_ID n_Marker)

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


@@ -130,15 +132,14 @@ EMUFS_FREE emufs_fsc_get_fs(EMUFS *emu, EMUFS_BLOCK_ID num_bloque)
        strcpy(name_f_fsc,emu->nombre);
        strcat(name_f_fsc, EMUFS_FSC_EXT);
 
        strcpy(name_f_fsc,emu->nombre);
        strcat(name_f_fsc, EMUFS_FSC_EXT);
 

+       /* Busco el Bloque o Gap pedido y obtengo su espacio libre */

        if ( (f_fsc = fopen(name_f_fsc,"r"))==NULL ) return -1;
        if ( (f_fsc = fopen(name_f_fsc,"r"))==NULL ) return -1;

-

        while ( !feof(f_fsc) ){
                if ( fread(&reg,sizeof(EMUFS_FSC),1,f_fsc) != 1 ) continue;
        while ( !feof(f_fsc) ){
                if ( fread(&reg,sizeof(EMUFS_FSC),1,f_fsc) != 1 ) continue;

-               if ( reg.block == num_bloque )
+               if ( reg.n_Marker == n_Marker )

                        break;
        }
                
        fclose(f_fsc);
                        break;
        }
                
        fclose(f_fsc);

-       return reg.free_space;
+       return reg.n_FreeSpace;

 }
 }

-

diff --git a/emufs/fsc.h b/emufs/fsc.h
index 01a72f162b7779d7b5f559d55770cddf4a61595f..aa2f70425de73a6072e9fd32f6007d351c32356f 100644 (file)
--- a/emufs/fsc.h
+++ b/emufs/fsc.h
@@ -43,18 +43,14 @@
 #define EMUFS_FSC_EXT ".fsc"
 
 typedef struct emufs_fsc_t {
 #define EMUFS_FSC_EXT ".fsc"
 
 typedef struct emufs_fsc_t {

-       int block;
-       int free_space;
+       unsigned long int n_Marker;
+       unsigned long int n_FreeSpace;

 } EMUFS_FSC;
 
 int emufs_fsc_crear(EMUFS*);
 } EMUFS_FSC;
 
 int emufs_fsc_crear(EMUFS*);

-

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

-

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

-

 EMUFS_BLOCK_ID emufs_fsc_buscar_lugar(EMUFS *, EMUFS_FREE, EMUFS_FREE *);
 EMUFS_BLOCK_ID emufs_fsc_buscar_lugar(EMUFS *, EMUFS_FREE, EMUFS_FREE *);

-

 EMUFS_FREE emufs_fsc_get_fs(EMUFS *, EMUFS_BLOCK_ID);
 
 #endif /* _EMUFS_FSC_H */
 EMUFS_FREE emufs_fsc_get_fs(EMUFS *, EMUFS_BLOCK_ID);
 
 #endif /* _EMUFS_FSC_H */

diff --git a/emufs/idx.c b/emufs/idx.c
index 29e021db8664c7f9c0864caf4a68828560bbd502..c05c34c2537ac0c24ae1d5257ab60141744809b4 100644 (file)
--- a/emufs/idx.c
+++ b/emufs/idx.c
@@ -40,6 +40,7 @@
 #include <strings.h>
 #include <unistd.h>
 
 #include <strings.h>
 #include <unistd.h>
 

+/* Objetivo: Realiza una apertura de un archivo indice y devuelve el handler. */

 FILE* emufs_idx_abrir(EMUFS* efs, const char* mode)
 {
        FILE* f;
 FILE* emufs_idx_abrir(EMUFS* efs, const char* mode)
 {
        FILE* f;


@@ -58,14 +59,16 @@ FILE* emufs_idx_abrir(EMUFS* efs, const char* mode)
        return f;
 }
 
        return f;
 }
 

+/* Crea un archivo indice de registros */

 int emufs_idx_crear(EMUFS *efs)
 {
        return emufs_crear_archivo_auxiliar(efs->nombre, EMUFS_IDX_EXT);
 }
 
 int emufs_idx_crear(EMUFS *efs)
 {
        return emufs_crear_archivo_auxiliar(efs->nombre, EMUFS_IDX_EXT);
 }
 

+/* Devuelve el mayor id de registro utilizado so far en el archivo de datos, revisando el indice. */

 EMUFS_REG_ID emufs_idx_buscar_mayor_id(EMUFS *emu)
 {
 EMUFS_REG_ID emufs_idx_buscar_mayor_id(EMUFS *emu)
 {

-       int id, max = -1;
+       EMUFS_REG_ID n_IdReg, max = -1;

        FILE *f_idx;    
        EMUFS_IDX reg;
        char name_f_idx[255]; /* TODO usar malloc para no limitar el tamaño de nombre de archivo */
        FILE *f_idx;    
        EMUFS_IDX reg;
        char name_f_idx[255]; /* TODO usar malloc para no limitar el tamaño de nombre de archivo */


@@ -74,44 +77,46 @@ EMUFS_REG_ID emufs_idx_buscar_mayor_id(EMUFS *emu)
        strcat(name_f_idx, EMUFS_IDX_EXT);
 
        if ( (f_idx = fopen(name_f_idx,"r")) == NULL) return -1; /*ERROR*/
        strcat(name_f_idx, EMUFS_IDX_EXT);
 
        if ( (f_idx = fopen(name_f_idx,"r")) == NULL) return -1; /*ERROR*/

-       id = -1;
+       n_IdReg = -1;

        while ( !feof(f_idx) ){
                /* Me aseguro de leer la cantidad de bytes correcta */
                if (fread(&reg,sizeof(EMUFS_IDX),1,f_idx) != 1) continue;
        while ( !feof(f_idx) ){
                /* Me aseguro de leer la cantidad de bytes correcta */
                if (fread(&reg,sizeof(EMUFS_IDX),1,f_idx) != 1) continue;

-               if ( reg.id_reg >= max ) 
-                       max = reg.id_reg;
+               if ( reg.n_IdReg >= max ) 
+                       max = reg.n_IdReg;

        }
        }

-       id = max+1;
+       n_IdReg = max+1;

        fclose(f_idx);
 
        fclose(f_idx);
 

-       return id;      
+       return n_IdReg; 

 }
 
 }
 

-/*busca el registro ID en el archivo ".idx" y devuelve el nro de bloque en el que se encuentra*/
-EMUFS_BLOCK_ID emufs_idx_buscar_registro(EMUFS *emu, EMUFS_REG_ID ID)
+/* busca el registro ID en el archivo ".idx" y devuelve el nro de bloque en el que se encuentra */
+EMUFS_BLOCK_ID emufs_idx_buscar_registro(EMUFS *emu, EMUFS_REG_ID n_IdReg)

 {
        FILE* f_idx;
        EMUFS_IDX reg;
        char name_f_idx[255];
 {
        FILE* f_idx;
        EMUFS_IDX reg;
        char name_f_idx[255];

+       unsigned short int b_Found = 0;
+       

        strcpy(name_f_idx,emu->nombre);
        strcat(name_f_idx, EMUFS_IDX_EXT);
        
        if ( (f_idx = fopen(name_f_idx,"r")) == NULL) return -1; /*ERROR*/
        strcpy(name_f_idx,emu->nombre);
        strcat(name_f_idx, EMUFS_IDX_EXT);
        
        if ( (f_idx = fopen(name_f_idx,"r")) == NULL) return -1; /*ERROR*/

-       reg.id_reg = -1;
-       reg.block = -1;
-       while ( !feof(f_idx) ){
+
+       while (!feof(f_idx) && !b_Found){

                if (fread(&reg,sizeof(EMUFS_IDX),1,f_idx) != 1) continue;
                if (fread(&reg,sizeof(EMUFS_IDX),1,f_idx) != 1) continue;

-               if ( reg.id_reg == ID ){
-                       break;
-               }
+               if (reg.n_IdReg == n_IdReg) b_Found = 1;

        }
        
        fclose(f_idx);
        }
        
        fclose(f_idx);

-       return reg.block;
+       
+       /* Sino lo encontre devuelvo uno, otherwise el offset o bloque */
+       if (!b_Found) return(-1);
+       else return(reg.n_Location);

 }
 
 /* agrega un registro al final del archivo */
 }
 
 /* agrega un registro al final del archivo */

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

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


@@ -122,14 +127,16 @@ int emufs_idx_agregar(EMUFS *emu, EMUFS_BLOCK_ID num_bloque, EMUFS_REG_ID id)
 
        if ( (f_idx = fopen(name_f_idx,"a+"))==NULL ) return -1;
                
 
        if ( (f_idx = fopen(name_f_idx,"a+"))==NULL ) return -1;
                

-       reg.block = num_bloque;
-       reg.id_reg = id;
+    /* Note: Location = Bloque para Tipo 1 y 3, Offset para Tipo 2 */
+       reg.n_Location = n_Location;
+       reg.n_IdReg = n_IdReg;

        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, EMUFS_REG_ID ID)
+/* Borra un registro del indice dada la eliminacion fisica de un reg */
+int emufs_idx_borrar(EMUFS *emu, EMUFS_REG_ID n_IdReg)

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


@@ -144,13 +151,13 @@ int emufs_idx_borrar(EMUFS *emu, EMUFS_REG_ID ID)
        while ( !feof(f_idx) ){
                /*busco cual tengo que borrar*/
                if ( fread(&reg, sizeof(EMUFS_IDX), 1, f_idx) != 1 ) continue;
        while ( !feof(f_idx) ){
                /*busco cual tengo que borrar*/
                if ( fread(&reg, sizeof(EMUFS_IDX), 1, f_idx) != 1 ) continue;

-               if ( reg.id_reg == ID )
+               if ( reg.n_IdReg == n_IdReg )

                        break;
        }
        
        /* me paro en el que tengo que borrar */
        actual = fseek(f_idx, -sizeof(EMUFS_IDX), SEEK_CUR);
                        break;
        }
        
        /* me paro en el que tengo que borrar */
        actual = fseek(f_idx, -sizeof(EMUFS_IDX), SEEK_CUR);

-       /*actual = ftell(f_idx); /* Guardo la posicion actual */
+       /*actual = ftell(f_idx);*/ /* Guardo la posicion actual */

        printf("ACTUAL = %ld\n", actual/sizeof(EMUFS_IDX));
        fseek(f_idx, 0, SEEK_END); /* me voy al final */
        final = ftell(f_idx); /* veo cuando ocupa el archivo */
        printf("ACTUAL = %ld\n", actual/sizeof(EMUFS_IDX));
        fseek(f_idx, 0, SEEK_END); /* me voy al final */
        final = ftell(f_idx); /* veo cuando ocupa el archivo */

diff --git a/emufs/idx.h b/emufs/idx.h
index 7999f064f55c8fd1a5254277cffa6d8ab2a37fd9..7e7cff9d016e11db4659a4d84801d30056fb5ec8 100644 (file)
--- a/emufs/idx.h
+++ b/emufs/idx.h
@@ -45,20 +45,15 @@
 #define EMUFS_IDX_EXT ".idx"
 
 typedef struct emufs_idx_t {
 #define EMUFS_IDX_EXT ".idx"
 
 typedef struct emufs_idx_t {

-       int block;
-       long int id_reg;
+       unsigned long int n_IdReg;
+       unsigned long int n_Location;

 } EMUFS_IDX;
 
 FILE* emufs_idx_abrir(EMUFS*, const char*);
 } EMUFS_IDX;
 
 FILE* emufs_idx_abrir(EMUFS*, const char*);

-

 int emufs_idx_crear(EMUFS*);
 int emufs_idx_crear(EMUFS*);

-

 EMUFS_REG_ID emufs_idx_buscar_mayor_id(EMUFS *);
 EMUFS_REG_ID emufs_idx_buscar_mayor_id(EMUFS *);

-

 EMUFS_BLOCK_ID emufs_idx_buscar_registro(EMUFS *, EMUFS_REG_ID);
 EMUFS_BLOCK_ID emufs_idx_buscar_registro(EMUFS *, EMUFS_REG_ID);

-

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

-

 int emufs_idx_borrar(EMUFS *emu, EMUFS_REG_ID);
 
 #endif /* _EMUFS_IDX_H */
 int emufs_idx_borrar(EMUFS *emu, EMUFS_REG_ID);
 
 #endif /* _EMUFS_IDX_H */

diff --git a/emufs/tipo1.c b/emufs/tipo1.c
index 5f0a9eddbec40f41aaddfb198c30c2c1ac0b7d47..d68095f21ccd564b0e5c8d5173dd011478a906dc 100644 (file)
--- a/emufs/tipo1.c
+++ b/emufs/tipo1.c
@@ -50,8 +50,7 @@ int emufs_tipo1_inicializar(EMUFS* efs)
        efs->leer_bloque     = emufs_tipo1_leer_bloque;
        efs->leer_registro   = emufs_tipo1_leer_registro;
        efs->grabar_registro = emufs_tipo1_grabar_registro;
        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;
-
+       /*efs->borrar_registro = emufs_tipo1_borrar_registro;*/

        return 0;
 }
 
        return 0;
 }
 


@@ -154,4 +153,3 @@ int emufs_tipo1_borrar_registro(EMUFS *emu, EMUFS_REG_ID id_reg,
 {
        return -1; /* FIXME Error */
 }
 {
        return -1; /* FIXME Error */
 }

-

diff --git a/emufs/tipo1_test.c b/emufs/tipo1_test.c
index bb18c19e8b3c9385c0562f4ed95bb604fc09a17a..7249e445381acbc180b3d2a7b4a0dc9ea1664f90 100644 (file)
--- a/emufs/tipo1_test.c
+++ b/emufs/tipo1_test.c
@@ -34,7 +34,7 @@ int main(int argc, char* argv[]) {
 
        if (efs->leer_registro(efs, 0, registro1, 4) == -1) {
                printf("No se pudo leer el registro 1.\n");
 
        if (efs->leer_registro(efs, 0, registro1, 4) == -1) {
                printf("No se pudo leer el registro 1.\n");

-               return ;
+               return 1;

        }
        registro1[4] = '\0';
        printf("Registro 1: %s\n", registro1);
        }
        registro1[4] = '\0';
        printf("Registro 1: %s\n", registro1);


@@ -51,4 +51,3 @@ int main(int argc, char* argv[]) {
        emufs_destruir(efs);
        return 0;
 }
        emufs_destruir(efs);
        return 0;
 }

-

diff --git a/emufs/tipo2.c b/emufs/tipo2.c
new file mode 100644 (file)
index 0000000..e3025cb
--- /dev/null
+++ b/emufs/tipo2.c
@@ -0,0 +1,136 @@
+/* vim: set noexpandtab tabstop=4 shiftwidth=4:
+ *----------------------------------------------------------------------------
+ *                                  emufs
+ *----------------------------------------------------------------------------
+ * This file is part of emufs.
+ *
+ * emufs is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 2 of the License, or (at your option) any later
+ * version.
+ *
+ * emufs is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with emufs; if not, write to the Free Software Foundation, Inc., 59 Temple
+ * Place, Suite 330, Boston, MA  02111-1307  USA
+ *----------------------------------------------------------------------------
+ * Creado:  Fri Apr 10 17:10:00 ART 2004
+ * Autores: Alan Kennedy <kennedya@3dgames.com.ar>
+ *----------------------------------------------------------------------------
+ *
+ * $Id: tipo3.c 85 2004-04-08 23:39:28Z sagar $
+ *
+ */
+
+/***************************************************************/
+/* Implementación del Tipo Archivo 2: Registros Variables, Sin */
+/* Bloques at all.                                             */
+/***************************************************************/
+
+#include "tipo2.h"
+#include "idx.h"
+#include "fsc.h"
+#include "did.h"
+
+/**********************************************************************/
+/* EMUFS_REG_ID emufs_tipo2_grabar_registro(EMUFS *emu, void *ptr,    */
+/*                                 EMUFS_REG_SIZE n_RegSize)          */
+/* Objetivo: Grabar un registro en un archivo del Tipo 2.             */
+/* Parametros: EMUFS *emu // Struct con handlers + info del openfile. */
+/*             void *ptr // Puntero al buffer (registro) a guardar    */
+/*             EMUFS_REG_SIZE n_RegSize // Size del reg en cuestion   */
+/**********************************************************************/
+EMUFS_REG_ID emufs_tipo2_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE n_RegSize)
+{
+       EMUFS_REG_ID n_IdReg;
+       EMUFS_FREE n_FreeSpace;
+       EMUFS_OFFSET n_WrtOffset,n_RegOffset;
+       FILE *f_data;
+       char name_f[255];
+       
+       /* Armamos el filename del archivo de datos */
+       strcpy(name_f,emu->nombre);
+       strcat(name_f,".dat");
+       
+       if ( (f_data = fopen(name_f,"a+"))==NULL ) return -1; /*ERROR*/
+       
+       /* Obtengo un offset en donde iniciar la escritura de mi registro */
+       /* de manera segura (habra espacio suficiente) */
+       n_WrtOffset = emufs_fsc_buscar_lugar(emu, n_RegSize, &n_FreeSpace);
+       printf("tipo2.c >> Searching FSC: Offset = %lu FSpace: %lu\n", n_WrtOffset, n_FreeSpace);
+       
+       /* Si no encontre un gap, entonces escribo el registro al final */
+       if (n_WrtOffset == -1) {                       
+               
+               /* Obtengo un ID libre para el registro y luego grabo a disco */
+        n_IdReg = emufs_tipo2_get_id(emu);
+               fseek(f_data, 0, SEEK_END);
+               n_RegOffset = ftell(f_data);
+
+               /* Escribo [RegId]|[RegSize]|[RegData] */
+               fwrite(&n_IdReg,sizeof(int),1,f_data);
+               fwrite(&n_RegSize,sizeof(int),1,f_data);
+               fwrite(ptr,n_RegSize,1,f_data);
+                               
+               /* Bye */
+               printf("Tipo2.c >> RegNr: %lu inserted at Offset: %lu\n",n_IdReg,n_RegOffset);
+               fclose(f_data);
+               
+       } else {
+               
+       }
+               
+       /* Finalmente, actualizamos el indice de registros (offsets) */
+       emufs_idx_agregar(emu,n_IdReg,n_RegOffset);
+               
+       return n_IdReg;
+}
+
+/**********************************************************************/
+/* int emufs_tipo2_borrar_registro(EMUFS *emu, EMUFS_REG_ID n_IdReg)  */
+/* Objetivo: Borra un registro determinado y actualiza los archivos   */
+/*           de Posicion Relativa (Indice-Offset) y el de Gaps        */
+/* Parametros: EMUFS *emu // Struct con handlers + info del openfile. */
+/*             EMUFS_REG_ID n_IdReg // Id del registro a eliminar.    */
+/**********************************************************************/
+int emufs_tipo2_borrar_registro(EMUFS *emu, EMUFS_REG_ID n_IdReg)
+{      
+       FILE *f_data;
+       char name_f[255];
+       EMUFS_OFFSET n_RegOffset;
+        
+    /* Armamos el filename del archivo de datos */
+       strcpy(name_f,emu->nombre);
+       strcat(name_f,".dat");
+
+       /* Obtenemos el tamanio del bloque */
+       if ((n_RegOffset = emufs_idx_buscar_registro(emu,n_IdReg)) != -1)
+         printf("tipo2.c >> Searching Reg %lu...Found at offset: %lu\n",n_IdReg,n_RegOffset);
+       else 
+         return -1;
+                       
+       if ((f_data = fopen(name_f,"a+")) == NULL) return -1; /* ERROR */
+       fclose(f_data);
+       
+       return(0);
+}
+
+/**********************************************************************/
+/* EMUFS_REG_ID emufs_tipo2_get_id(EMUFS *emu)                        */
+/* Objetivo: Devuelve un Id apropiado y disponible para un nuevo reg  */
+/* Parametros: EMUFS *emu // Struct con handlers + info del openfile. */
+/**********************************************************************/
+EMUFS_REG_ID emufs_tipo2_get_id(EMUFS *emu)
+{
+       EMUFS_REG_ID n_RegId;
+
+       /* Si no se hallo un id libre, entonces debo usar el maximo + 1 */
+       if ( (n_RegId = emufs_did_get_last(emu)) == -1 )
+               n_RegId = emufs_idx_buscar_mayor_id(emu);
+       
+       return n_RegId; 
+}

diff --git a/emufs/tipo2.h b/emufs/tipo2.h
new file mode 100644 (file)
index 0000000..3e55b7d
--- /dev/null
+++ b/emufs/tipo2.h
@@ -0,0 +1,47 @@
+/* vim: set noexpandtab tabstop=4 shiftwidth=4:
+ *----------------------------------------------------------------------------
+ *                                  emufs
+ *----------------------------------------------------------------------------
+ * This file is part of emufs.
+ *
+ * emufs is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 2 of the License, or (at your option) any later
+ * version.
+ *
+ * emufs is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with emufs; if not, write to the Free Software Foundation, Inc., 59 Temple
+ * Place, Suite 330, Boston, MA  02111-1307  USA
+ *----------------------------------------------------------------------------
+ * Creado:  Fri Apr 10 17:10:00 ART 2004
+ * Autores: Alan Kennedy <kennedya@3dgames.com.ar>
+ *----------------------------------------------------------------------------
+ */
+
+/***************************************************************/
+/* Implementación del Tipo Archivo 2: Registros Variables, Sin */
+/* Bloques at all.                                             */
+/***************************************************************/
+
+#ifndef _EMUFS_TIPO2_H_
+#define _EMUFS_TIPO2_H_
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include "emufs.h"
+
+EMUFS_REG_ID emufs_tipo2_grabar_registro(EMUFS *, void *, EMUFS_REG_SIZE);
+int emufs_tipo2_borrar_registro(EMUFS*, EMUFS_REG_ID);
+EMUFS_REG_ID emufs_tipo2_get_id(EMUFS *);
+
+/* int emufs_tipo2_leer_registro(EMUFS *, EMUFS_REG_ID , void *, EMUFS_REG_SIZE);
+   int emufs_tipo2_buscar_registro(EMUFS *, int); */
+
+#endif /* _EMUFS_TIPO2_H_ */

diff --git a/emufs/tipo3_main.c b/emufs/tipo3_main.c
index 559a3c9a2ba09be8fd1bb03608025ce3696b9257..d90989740644ecb8028abd15c63f09e1b11b5056 100644 (file)
--- a/emufs/tipo3_main.c
+++ b/emufs/tipo3_main.c
@@ -40,7 +40,7 @@
 int main(int argc, char *argv[])
 {
        EMUFS *fp;
 int main(int argc, char *argv[])
 {
        EMUFS *fp;

-       int n1, n2, n3, n4, n5, n6, n7, n8;
+       EMUFS_REG_ID n1, n2, n3, n4, n5, n6, n7, n8;

        char a[100];
        char b[100];
        char c[100];
        char a[100];
        char b[100];
        char c[100];


@@ -80,20 +80,20 @@ int main(int argc, char *argv[])
        n6 = fp->grabar_registro(fp, g, 100);
        n7 = fp->grabar_registro(fp, h, 100);
        n8 = fp->grabar_registro(fp, i, 100);*/
        n6 = fp->grabar_registro(fp, g, 100);
        n7 = fp->grabar_registro(fp, h, 100);
        n8 = fp->grabar_registro(fp, i, 100);*/

-       printf("ID0 = %d\n", n1);
-       printf("ID1 = %d\n", n2);
-       printf("ID2 = %d\n", n3);
-       printf("ID3 = %d\n", n4);
-       printf("ID4 = %d\n", n5);
-       printf("ID5 = %d\n", n6);
-       printf("ID6 = %d\n", n7);
+       printf("ID0 = %lu\n", n1);
+       printf("ID1 = %lu\n", n2);
+       printf("ID2 = %lu\n", n3);
+       printf("ID3 = %lu\n", n4);
+       printf("ID4 = %lu\n", n5);
+       printf("ID5 = %lu\n", n6);
+       printf("ID6 = %lu\n", n7);

 
 

-ver_archivo_FS(fp);
+    ver_archivo_FS(fp);

        /*fp->borrar_registro(fp, n4, 100);
        fp->borrar_registro(fp, n2, 100);
        fp->borrar_registro(fp, n6, 100);*/
        /*fp->borrar_registro(fp, n4, 100);
        fp->borrar_registro(fp, n2, 100);
        fp->borrar_registro(fp, n6, 100);*/

-       fp->borrar_registro(fp, n1, 100);
-       printf("borre el registro de id = %d\n",n1);
+       /*fp->borrar_registro(fp, n1, 100);*/
+       /*printf("borre el registro de id = %d\n",n1);*/

        fp->leer_registro(fp, n2, b, 100);
 
        printf("Recuperado : %s\n", b);
        fp->leer_registro(fp, n2, b, 100);
 
        printf("Recuperado : %s\n", b);