From 0a8c25d48c0fa1602556582885e33426cb2e05fa Mon Sep 17 00:00:00 2001 From: Leandro Lucarella Date: Sat, 10 Apr 2004 02:06:23 +0000 Subject: [PATCH] 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. --- emufs/Makefile | 4 ++- emufs/did.c | 4 +-- emufs/did.h | 4 +-- emufs/emufs.c | 74 +++++++++++++++++++++++++++----------------- emufs/emufs.h | 46 +++++++++++++++++++-------- emufs/fsc.c | 8 ++--- emufs/fsc.h | 8 ++--- emufs/idx.c | 10 +++--- emufs/idx.h | 8 ++--- emufs/tipo1.c | 77 ++++++++++++++++++++++++++++++++++++---------- emufs/tipo1.h | 29 ++++++++++------- emufs/tipo1_test.c | 31 +++++++++++++++++++ emufs/tipo3.c | 60 +++++++++++++++++++++--------------- emufs/tipo3.h | 21 +++++++------ 14 files changed, 260 insertions(+), 124 deletions(-) create mode 100644 emufs/tipo1_test.c diff --git a/emufs/Makefile b/emufs/Makefile index fc6b95a..5ec4767 100644 --- 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 -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) diff --git a/emufs/did.c b/emufs/did.c index 407b123..8492aa7 100644 --- 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); } -int emufs_did_get_last(EMUFS *emu) +EMUFS_REG_ID emufs_did_get_last(EMUFS *emu) { FILE * f_did; int id, offset; @@ -78,7 +78,7 @@ int emufs_did_get_last(EMUFS *emu) } /*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]; diff --git a/emufs/did.h b/emufs/did.h index e79b8ce..5b71019 100644 --- a/emufs/did.h +++ b/emufs/did.h @@ -45,8 +45,8 @@ 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 */ diff --git a/emufs/emufs.c b/emufs/emufs.c index a6a774c..7ddd4bd 100644 --- 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; - /* 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)); - efs->tipo = tipo; + if (efs == NULL) { + return NULL; + } + efs->tipo = tipo; efs->tam_bloque = tam_bloque; - efs->nombre = str_dup(filename); + efs->nombre = str_dup(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. */ - 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)) { @@ -138,14 +142,10 @@ EMUFS *emufs_crear(const char *filename, char tipo, unsigned long tam_bloque, un 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. */ - fwrite(&tam_bloque, sizeof(unsigned long), 1, fp); + fwrite(&tam_bloque, sizeof(EMUFS_BLOCK_SIZE), 1, fp); 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. */ - 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; @@ -173,7 +173,7 @@ EMUFS *emufs_crear(const char *filename, char tipo, unsigned long tam_bloque, un EMUFS *emufs_abrir(const char *filename) { - EMUFS *tmp; + EMUFS *efs; 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; - 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; } - tmp = (EMUFS *)malloc(sizeof(EMUFS)); - if (tmp == NULL) { + /* Inicializa parámetros comunes. */ + efs = (EMUFS*) malloc(sizeof(EMUFS)); + if (efs == NULL) { fclose(fp); return NULL; } + efs->tipo = tipo; + efs->nombre = str_dup(filename); 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: - break; + break; 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); - return tmp; + return efs; } int emufs_destruir(EMUFS *e) diff --git a/emufs/emufs.h b/emufs/emufs.h index f8a7067..cd25bb5 100644 --- a/emufs/emufs.h +++ b/emufs/emufs.h @@ -50,6 +50,24 @@ typedef enum { 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. @@ -70,11 +88,11 @@ typedef enum { */ 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; @@ -83,27 +101,31 @@ int emufs_crear_archivo_auxiliar(const char*, const char*); /** 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 * - * 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. */ -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. * diff --git a/emufs/fsc.c b/emufs/fsc.c index b67ce36..05218a6 100644 --- 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); } -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; @@ -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 */ -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; @@ -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 */ -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; @@ -121,7 +121,7 @@ int emufs_fsc_buscar_lugar(EMUFS *emu, unsigned long tam, int *fs) 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; diff --git a/emufs/fsc.h b/emufs/fsc.h index 9e44692..01a72f1 100644 --- 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_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 */ diff --git a/emufs/idx.c b/emufs/idx.c index 56fa4fc..f7c89fd 100644 --- 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); } -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; @@ -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*/ -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; @@ -110,7 +110,7 @@ int emufs_idx_buscar_registro(EMUFS *emu, int ID) } /* 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; @@ -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; - reg.id_reg = ID_aux; + reg.id_reg = id; fwrite(®,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; diff --git a/emufs/idx.h b/emufs/idx.h index 4dfba88..7999f06 100644 --- 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_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 */ diff --git a/emufs/tipo1.c b/emufs/tipo1.c index d5a0a58..ee444ce 100644 --- a/emufs/tipo1.c +++ b/emufs/tipo1.c @@ -36,19 +36,33 @@ */ #include "tipo1.h" +#include "idx.h" +#include "fsc.h" +#include "did.h" #include #include #include #include -#include -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) */ - 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); @@ -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. */ - 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. */ - 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); @@ -87,30 +101,59 @@ int emufs_tipo1_leer_registro(EMUFS* efs, int reg_id, void* reg_ptr, unsigned lo 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 */ } -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*/ -int emufs_tipo1_get_id(EMUFS *emu) +EMUFS_REG_ID emufs_tipo1_get_id(EMUFS *emu) { 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 */ } -/*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 */ } + diff --git a/emufs/tipo1.h b/emufs/tipo1.h index 113a66d..efd68c9 100644 --- a/emufs/tipo1.h +++ b/emufs/tipo1.h @@ -39,25 +39,32 @@ #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_ */ diff --git a/emufs/tipo1_test.c b/emufs/tipo1_test.c new file mode 100644 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 5ba6af2..f2d1279 100644 --- 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.**/ -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; - 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*/ @@ -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 ) { - 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; @@ -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"*/ -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]; @@ -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*/ - 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; @@ -93,9 +95,12 @@ int emufs_tipo3_leer_bloque(EMUFS *emu, int ID, void* ptr) 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; @@ -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*/ - memcpy(bloque,&ID_aux,sizeof(int)); + memcpy(bloque,&ID_aux,sizeof(EMUFS_REG_ID)); /*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 */ @@ -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 */ + /* 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 */ + /* 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; @@ -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*/ - 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*/ - 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*/ + /* FIXME FIXME FIXME FALTA TRADUCIR A EMUFS_XXXX */ 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*/ -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); @@ -182,7 +190,7 @@ int emufs_tipo3_get_id(EMUFS *emu) } /*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]; @@ -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*/ -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); @@ -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 ){ - memcpy(&ID_aux, bloque+ptr_elim, sizeof(int)); + memcpy(&ID_aux, bloque+ptr_elim, sizeof(EMUFS_REG_ID)); 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*/ - ptr_mov = ptr_elim + tam_reg + sizeof(int); + ptr_mov = ptr_elim + tam_reg + sizeof(EMUFS_REG_ID); 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_mov += sizeof(int) + tam_reg; + ptr_mov += sizeof(EMUFS_REG_ID) + tam_reg; } /*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); - 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; diff --git a/emufs/tipo3.h b/emufs/tipo3.h index ad84d81..2b9fdeb 100644 --- a/emufs/tipo3.h +++ b/emufs/tipo3.h @@ -47,26 +47,27 @@ #include "idx.h" #include "fsc.h" - /** 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 */ -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 */ -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 */ -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_ */ -- 2.43.0