* Comento EMUFS para Doxygen

 * Hago un ejemplo mas interesante

diff --git a/tipo3/emufs.c b/tipo3/emufs.c
index 4d7409706876cf9b249ad81d182ecb619c811058..ae302fdcea96359b4e9d2c594a1f34d9602b032e 100644 (file)
--- 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 3772127a50c10bbe9c8d88263a2205341f51561d..89731c9b91749023c05ce828d1f2fe1c2d65f63a 100644 (file)
--- a/tipo3/emufs.h
+++ b/tipo3/emufs.h
@@ -4,22 +4,77 @@
 #include <stdlib.h>
 #include <stdio.h>
 
-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 1d7cac1ab9123ec3d8a76b8ddfc11b235dbeb8ac..b403de0e04dd8cd03d8fb5efa9ca431070605e31 100644 (file)
--- a/tipo3/main.c
+++ b/tipo3/main.c
@@ -2,19 +2,29 @@
 #include <string.h>
 #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 149ece64f5574f98fd285fffb2f8ad8a03cd6880..0b2cc83ce9914d79917d060e071eef1a68252e1c 100644 (file)
--- 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(&reg,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(&reg,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(&reg_b,sizeof(BLOCK_REG_T),1,f_block_reg);