hice unos pequeños cambios en fsc e idx pero no creo que afecte en nada a los otros...

[z.facultad/75.06/emufs.git] / emufs / tipo1.c

diff --git a/emufs/tipo1.c b/emufs/tipo1.c
index dc6a813ee9f750f32aff8556abfd17c1aa7f57ed..fa24cf0ad71051cae620f9ef3950168c492c2f91 100644 (file)
--- a/emufs/tipo1.c
+++ b/emufs/tipo1.c
@@ -205,25 +205,32 @@ void* emufs_tipo1_leer_bloque(EMUFS* efs, EMUFS_BLOCK_ID block_id, int *err)
 EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* efs, void* reg,
                EMUFS_REG_SIZE reg_size, int* err)
 {
-       EMUFS_TIPO1_REG_HEADER reg_header;
-       EMUFS_FREE             fs;
-       EMUFS_BLOCK_ID         block_id;
+       EMUFS_TIPO1_REG_HEADER reg_header; /* cabecera del registro a guardar */
+       EMUFS_FREE             fs; /* espacio libre en el bloque */
+       EMUFS_BLOCK_ID         block_id; /* identificador del 1er bloque */
+       char*                  block; /* buffer del bloque a guardar en disco */
        char                   name_f[255];
-       char*                  block;
 
        strcpy(name_f, efs->nombre);
        strcat(name_f, ".dat");
 
        /* pongo tamaño del registro en la cabecera. */
        reg_header.size = reg_size;
-       /* me devuelve el ID del bloque donde quepa un registro y el espacio libre en "fs"*/
-       block_id = emufs_fsc_buscar_lugar(efs, reg_size
-                       + sizeof(EMUFS_TIPO1_REG_HEADER), &fs);
+       /* busco lugar para el registro en un bloque existente */
+       block_id = emufs_fsc_buscar_lugar(efs, sizeof(EMUFS_TIPO1_REG_HEADER)
+                       + reg_size, &fs);
        /* si no hay bloques con suficiente espacio creo un bloque nuevo */
        if (block_id == EMUFS_NOT_FOUND) {
-               /* Tamaño máximo ultilizable para datos en un bloque */
-               EMUFS_BLOCK_SIZE block_space;
-               block_space = efs->tam_bloque - sizeof(EMUFS_TIPO1_REG_HEADER);
+               /* tamaño máximo ultilizable para datos en un bloque */
+               EMUFS_BLOCK_SIZE block_space
+                       = efs->tam_bloque - sizeof(EMUFS_TIPO1_REG_HEADER);
+               /* identificador del bloque que se guarda */
+               EMUFS_BLOCK_ID curr_block_id = EMUFS_NOT_FOUND;
+               /* tamaño de la porción de registro que se guarda */
+               EMUFS_REG_SIZE chunk_size = 0; 
+               /* puntero a la poción del registro */
+               char* chunk_ptr = reg; 
+
                /* crear un nuevo bloque en memoria */
                block = (char*) malloc(efs->tam_bloque);
                if (block == NULL) {
@@ -233,51 +240,36 @@ EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* efs, void* reg,
                        return EMUFS_NOT_FOUND;
                }
                reg_header.id = emufs_idx_get_new_id(efs, err);
-               memset(block, 0, efs->tam_bloque); /* inicializa bloque */
-               /* verifica que el registro no sea más grande que el bloque */
-               if (reg_size > block_space) {
-                       EMUFS_REG_SIZE chunk_size = 0; /* Tamaño de la porción de registro */
-                       char* chunk_pointer = reg; /* Puntero a la poción del registro */
-                       do {
-                               memset(block, 0, efs->tam_bloque); /* inicializa bloque */
-                               reg_header.size -= chunk_size;
-                               chunk_size = MIN(reg_header.size, block_space);
-                               /* graba porción del registro en bloque */
-                               emufs_tipo1_escribir_reg_chunk_en_memoria(block, reg_header, reg,
-                                               chunk_size);
-                               /* graba el bloque en el archivo */
-                               block_id = emufs_tipo1_grabar_bloque(efs, block, block_id, err);
-                               if (*err) {
-                                       PERR("error al grabar bloque");
-                                       free(block);
-                                       return EMUFS_NOT_FOUND;
-                               }
+               do {
+                       memset(block, 0, efs->tam_bloque); /* inicializa bloque */
+                       chunk_ptr += chunk_size; /* Avanzo para guardar prox chunk */
+                       reg_header.size -= chunk_size; /* Resto lo que ya guardé */
+                       chunk_size = MIN(reg_header.size, block_space);
+                       /* graba porción del registro en bloque */
+                       emufs_tipo1_escribir_reg_chunk_en_memoria(block, reg_header,
+                                       chunk_ptr, chunk_size);
+                       /* graba el bloque en el archivo */
+                       curr_block_id = emufs_tipo1_grabar_bloque(efs, block,
+                                       EMUFS_NOT_FOUND, err);
+                       if (*err) {
+                               PERR("error al grabar bloque");
                                free(block);
-                               /* grabo el nuevo registro en el archivo de espacios libres */
-                               *err = emufs_fsc_agregar(efs, block_id, block_space - chunk_size);
-                               if (*err) {
-                                       PERR("No se pudo agregar fsc");
-                                       return EMUFS_NOT_FOUND;
-                               }
-                       } while (chunk_size > block_space);
-               }
-               /* graba registro en bloque */
-               emufs_tipo1_escribir_reg_en_memoria(block, reg_header, reg);
-               /* graba el bloque en el archivo */
-               block_id = emufs_tipo1_grabar_bloque(efs, block, block_id, err);
-               if (*err) {
-                       PERR("error al grabar bloque");
-                       free(block);
-                       return EMUFS_NOT_FOUND;
-               }
+                               return EMUFS_NOT_FOUND;
+                       }
+                       /* grabo el nuevo registro en el archivo de espacios libres */
+                       *err = emufs_fsc_agregar(efs, curr_block_id, block_space - chunk_size);
+                       if (*err) {
+                               PERR("No se pudo agregar fsc");
+                               free(block);
+                               return EMUFS_NOT_FOUND;
+                       }
+                       /* si es el primer id de bloque obtenido, lo guardo para
+                        * agregarlo después al archivo de índices. */
+                       if (block_id == EMUFS_NOT_FOUND) {
+                               block_id = curr_block_id;
+                       }
+               } while (reg_header.size > block_space);
                free(block);
-               /* grabo el nuevo registro en el archivo de espacios libres */
-               *err = emufs_fsc_agregar(efs, block_id, efs->tam_bloque - reg_size
-                               - sizeof(EMUFS_TIPO1_REG_HEADER));
-               if (*err) {
-                       PERR("No se pudo agregar fsc");
-                       return EMUFS_NOT_FOUND;
-               }
 
        /* Encontró espacio en un bloque existente, graba registro ahí */
        } else {
@@ -419,7 +411,7 @@ int emufs_tipo1_block_jump(EMUFS* efs, FILE* fp, EMUFS_BLOCK_ID block_count)
 void emufs_tipo1_escribir_reg_en_memoria(char* dst, EMUFS_TIPO1_REG_HEADER header,
                char* reg)
 {
-       return emufs_tipo1_escribir_reg_chunk_en_memoria(dst, header, reg, header.size);
+       emufs_tipo1_escribir_reg_chunk_en_memoria(dst, header, reg, header.size);
 }
 
 void emufs_tipo1_escribir_reg_chunk_en_memoria(char* dst,