From 92aca5d432abb85476f6c100fb55190cd5947a00 Mon Sep 17 00:00:00 2001 From: Ricardo Markiewicz Date: Tue, 6 Apr 2004 00:30:26 +0000 Subject: [PATCH 1/1] * Comento EMUFS para Doxygen * Hago un ejemplo mas interesante --- tipo3/emufs.c | 9 +++++- tipo3/emufs.h | 71 +++++++++++++++++++++++++++++++++++++++++------ tipo3/main.c | 25 +++++++++++------ tipo3/param_cte.c | 15 ++++++++-- 4 files changed, 100 insertions(+), 20 deletions(-) diff --git a/tipo3/emufs.c b/tipo3/emufs.c index 4d74097..ae302fd 100644 --- a/tipo3/emufs.c +++ b/tipo3/emufs.c @@ -7,6 +7,8 @@ #define EXT_TIPO3_DISP ".fsc" #define EXT_TIPO3_IDS ".ids" +char *str_dup(const char *s); + char *str_dup(const char *s) { char *tmp; @@ -85,6 +87,8 @@ EMUFS *emufs_abrir(const char *filename) strcpy(name, filename); strcat(name, EXT_TIPO3_DATA); + + /* Trato de determinar el tipo de archivo */ fp = fopen(name, "r"); if (fp == NULL) return NULL; fread(&tipo, sizeof(char), 1, fp); @@ -94,7 +98,10 @@ EMUFS *emufs_abrir(const char *filename) } tmp = (EMUFS *)malloc(sizeof(EMUFS)); - if (tmp == NULL) return NULL; + if (tmp == NULL) { + fclose(fp); + return NULL; + } switch (tipo) { case T1: diff --git a/tipo3/emufs.h b/tipo3/emufs.h index 3772127..89731c9 100644 --- a/tipo3/emufs.h +++ b/tipo3/emufs.h @@ -4,22 +4,77 @@ #include #include -typedef enum {T1, T2, T3} EMUFS_TYPE; +/** Tipo de archivo. */ +typedef enum { + T1, /**< Archivo de bloque parametrizado y registro variable. */ + T2, /**< Archivo sin bloques y registros variables. */ + T3 /**< Archivo de bloque parametrizado y registro fijo. */ +} EMUFS_TYPE; +/** Tipo Abstracto para menajo de archivos. + * + * Esta estructura es utilizada para acceder a cualquier tipo de archivo. + * + * Cuando se requiere abrir o crear un nuevo archivo, esta estrucura contendrá los + * punteros a los métodos de dicho archivo, por lo que desde el código que utilice + * esta estructura no deberá ser modificado por cada tipo de archivo. + * + * Por ejemplo: + * \code + * EMUFS *fs = emufs_abrir("archivo"); + * fs->leer_registro(id, ptr, size); + * \endcode + * + * Este ejemplo funcionará sin importar de que tipo de archivo se trate, sin + * la necesidad de que el usuario tenga que hacer una selección previa del tipo + * para llamar al método correspondiente a cada tipo de archivo. + */ typedef struct _emu_fs_t { - EMUFS_TYPE tipo; /* Corregir nombres */ - unsigned long tam_bloque; /* 0 si no tiene bloques */ - int (*leer_bloque)(struct _emu_fs_t *, int, void *); - int (*leer_registro)(struct _emu_fs_t *, int, void *, unsigned long); - int (*grabar_registro)(struct _emu_fs_t *, void *, unsigned long ); - int (*borrar_registro)(struct _emu_fs_t *, int); - char *nombre; + 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); /**< Método para borrar un registro */ + char *nombre; /**< Nombre del 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. + * + * 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. + * + * 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 int tam_bloque, unsigned int tam_reg); + +/** Abre un archivo EMUFS. + * + * Abre un archivo, determinando de que tipo se trata. + * + * \param filename Nombre del archivo virtual. + */ EMUFS *emufs_abrir(const char *filename); +/** Libera un archivo virtual */ int emufs_destruir(EMUFS *e); int ver_archivo_FS(EMUFS *emu); + #endif + diff --git a/tipo3/main.c b/tipo3/main.c index 1d7cac1..b403de0 100644 --- a/tipo3/main.c +++ b/tipo3/main.c @@ -2,19 +2,29 @@ #include #include "emufs.h" -int main() +int main(int argc, char *argv[]) { EMUFS *fp; - char a[100]; - char c[100]; int n1, n2, n3, n4, n5, n6, n7; + char a[100]; char b[100]; + char c[100]; char d[100]; char e[100]; char f[100]; char g[100]; char h[100]; - + + if (argc != 2) { + printf("Modo de uso : %s tam_bloque\n", argv[0]); + return 1; + } + + if (atoi(argv[1]) < 104) { + printf("El tamaño de bloque debe ser mayor a 104\n"); + return 1; + } + strcpy(a, "1234567890"); strcpy(c, "REGISTRO NUMERO 2. ESTE REGISTRO ES MUCHO MAS LARGO QUE EL UNO"); strcpy(d, "ABCDEFGHIJKL"); @@ -24,7 +34,7 @@ int main() strcpy(h, "un registro nuevo que se llama H, acompania a G en el bloque 1"); - fp = emufs_crear("articulos", T3, 220, 100); + fp = emufs_crear("articulos", T3, atoi(argv[1]), 100); n1 = fp->grabar_registro(fp, a, 100); n2 = fp->grabar_registro(fp, c, 100); @@ -42,13 +52,12 @@ int main() printf("ID5 = %d\n", n6); printf("ID6 = %d\n", n7); - fp->leer_registro(fp, n6, b, 100); + fp->leer_registro(fp, n1, b, 100); - - printf("Ok\n"); printf("Recuperado : %s\n", b); ver_archivo_FS(fp); emufs_destruir(fp); + return 0; } diff --git a/tipo3/param_cte.c b/tipo3/param_cte.c index 149ece6..0b2cc83 100644 --- a/tipo3/param_cte.c +++ b/tipo3/param_cte.c @@ -167,7 +167,10 @@ int grabar_registro(EMUFS *emu, void *ptr, unsigned long tam) /*printf("FS = %d\n", fs);*/ reg.free_space = emu->tam_bloque - tam-sizeof(int); /*lo guardo en el archivo al final "a+"*/ - if ( (f_block_free = fopen(name_f_free,"a+"))==NULL ) return -1; /*ERROR*/ + if ( (f_block_free = fopen(name_f_free,"a+"))==NULL ) { + free(bloque); + return -1; /*ERROR*/ + } fwrite(®,sizeof(BLOCK_FREE_T),1,f_block_free); fclose(f_block_free); } else { @@ -189,7 +192,10 @@ int grabar_registro(EMUFS *emu, void *ptr, unsigned long tam) } /*actualizo el archivo de espacios libres*/ /*busco el bloque que modifique*/ - if ( (f_block_free = fopen(name_f_free,"r+")) == NULL) return -1; /*ERROR*/ + if ( (f_block_free = fopen(name_f_free,"r+")) == NULL) { + free(bloque); + return -1; /*ERROR*/ + } while ( !feof(f_block_free) ){ fread(®,sizeof(BLOCK_FREE_T),1,f_block_free); if ( reg.block == num_bloque ){ @@ -203,7 +209,10 @@ int grabar_registro(EMUFS *emu, void *ptr, unsigned long tam) } /*actualizo el archivo de bloques y registros*/ - if ( (f_block_reg = fopen(name_f_block_reg,"ab+"))==NULL ) return -1; /*ERROR*/ + if ( (f_block_reg = fopen(name_f_block_reg,"ab+"))==NULL ) { + free(bloque); + return -1; /*ERROR*/ + } reg_b.block = reg.block; reg_b.id_reg = ID_aux; fwrite(®_b,sizeof(BLOCK_REG_T),1,f_block_reg); -- 2.43.0