* Ahi la GUI carga bien y no se producen los problemas de memoria. Para resolverlo

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

diff --git a/emufs/tipo3.c b/emufs/tipo3.c
index 4aa7c6cd8f0a3881ed4b2a9e1bcbacc749d6e776..05d8bad2f74bbe9d02088f68ec3937170bc15726 100644 (file)
--- a/emufs/tipo3.c
+++ b/emufs/tipo3.c
@@ -40,19 +40,10 @@
 /** 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)
 {
 /** 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)
 {

-       FILE* f_block_reg;

        char* bloque;
        char* bloque;

-       char name_f_block_reg[255];

        int block, ID_aux;
        int iterador = 0;
        int block, ID_aux;
        int iterador = 0;

-       strcpy(name_f_block_reg,emu->nombre);
-       strcat(name_f_block_reg,".idx");
-
-
-       if ( (f_block_reg = fopen(name_f_block_reg,"a+")) == NULL )
-               return -1; /*ERROR*/

        
        

-

        /*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*/
        bloque = (char*)malloc(emu->tam_bloque);
        /*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*/
        bloque = (char*)malloc(emu->tam_bloque);


@@ -79,7 +70,6 @@ int emufs_tipo3_leer_registro(EMUFS *emu, int ID, void *ptr, unsigned long tam_r
                iterador += tam_reg;
        }
        
                iterador += tam_reg;
        }
        

-       fclose(f_block_reg);

        free(bloque);
        return 0;
 }
        free(bloque);
        return 0;
 }


@@ -113,12 +103,11 @@ int emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, unsigned long tam)
        strcpy(name_f,emu->nombre);
        strcat(name_f,".dat");
        
        strcpy(name_f,emu->nombre);
        strcat(name_f,".dat");
        

-       if ( (file = fopen(name_f,"a+"))==NULL ) return -1; /*ERROR*/

        /* me devuelve el ID del bloque donde quepa un registro y el espacio libre en "fs"*/
        /* me devuelve el ID del bloque donde quepa un registro y el espacio libre en "fs"*/

-       num_bloque = emufs_tipo3_buscar_lugar(emu, tam, &fs);
-       printf("Lugar = %d   bloque = %d\n", fs, num_bloque);
+       num_bloque = emufs_fsc_buscar_lugar(emu, tam, &fs);

        /*si no hay bloques con suficiente espacio creo un bloque nuevo */
        if (num_bloque == -1) {
        /*si no hay bloques con suficiente espacio creo un bloque nuevo */
        if (num_bloque == -1) {

+               if ( (file = fopen(name_f,"a+"))==NULL ) return -1; /*ERROR*/

                /*crear un nuevo bloque en memoria */
                bloque = (char*)malloc(emu->tam_bloque);
                /* grabar el registro al principio del bloque */
                /*crear un nuevo bloque en memoria */
                bloque = (char*)malloc(emu->tam_bloque);
                /* grabar el registro al principio del bloque */


@@ -129,7 +118,7 @@ int emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, unsigned long tam)
                /*grabo el registro en el bloque*/
                memcpy(bloque+sizeof(int),ptr,tam);
                /* me paro al final del archivo */
                /*grabo el registro en el bloque*/
                memcpy(bloque+sizeof(int),ptr,tam);
                /* me paro al final del archivo */

-               fseek(file, 0, SEEK_END); 
+               fseek(file, 0, SEEK_END); 

                /* grabo el bloque en el final del archivo */
                fwrite(bloque,emu->tam_bloque,1,file);
                /*actualizo el archivo de espacios libres*/
                /* grabo el bloque en el final del archivo */
                fwrite(bloque,emu->tam_bloque,1,file);
                /*actualizo el archivo de espacios libres*/


@@ -141,13 +130,13 @@ int emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, unsigned long tam)
                fclose(file);
                num_bloque = cant;
                /* grabo el nuevo registro en el archivo de espacios libres */
                fclose(file);
                num_bloque = cant;
                /* grabo el nuevo registro en el archivo de espacios libres */

-               if ( emufs_fsc_agregar(emu, num_bloque, emu->tam_bloque - tam-sizeof(int)) != 0 ) {
+               if ( emufs_fsc_agregar(emu, num_bloque, emu->tam_bloque - tam - sizeof(int)) != 0 ) {

                        free(bloque);
                        return -1;
                }
        } else {
                /*cargo el bloque en "bloque"*/
                        free(bloque);
                        return -1;
                }
        } else {
                /*cargo el bloque en "bloque"*/

-               bloque = (char*)malloc(emu->tam_bloque);        
+               bloque = (char*)malloc(emu->tam_bloque);

                if ( emufs_tipo3_leer_bloque(emu,num_bloque,bloque)== -1) {
                        printf("Error: no se pudo leer bloque\n");
                        return -1; 
                if ( emufs_tipo3_leer_bloque(emu,num_bloque,bloque)== -1) {
                        printf("Error: no se pudo leer bloque\n");
                        return -1; 


@@ -166,7 +155,7 @@ int emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, unsigned long tam)
                        return -1; /* se produjo un error */    
                }
                /*actualizo el archivo de espacios libres*/
                        return -1; /* se produjo un error */    
                }
                /*actualizo el archivo de espacios libres*/

-               if ( emufs_fsc_actualizar(emu, num_bloque, tam+sizeof(int)) != 0 ){
+               if ( emufs_fsc_actualizar(emu, num_bloque, fs - tam - sizeof(int)) != 0 ){

                        free(bloque);
                        return -1;
                }
                        free(bloque);
                        return -1;
                }


@@ -202,66 +191,24 @@ int emufs_tipo3_grabar_bloque(EMUFS *emu, void *ptr, int num)
        strcat(name_f,".dat");
        
        if ( (file = fopen(name_f,"r+"))==NULL ) return -1; /*ERROR*/
        strcat(name_f,".dat");
        
        if ( (file = fopen(name_f,"r+"))==NULL ) return -1; /*ERROR*/

-       fseek(file,sizeof(char)+sizeof(int)*2,SEEK_SET);
-       fseek(file,num*emu->tam_bloque,SEEK_CUR);       
+       /* Salto el header del archivo */
+       fseek(file, sizeof(char)+sizeof(int)*2, SEEK_SET);
+       fseek(file, num*emu->tam_bloque, SEEK_CUR);     

        fwrite(ptr, emu->tam_bloque, 1, file);
        
        fclose(file);
        return 0;
 }
 
        fwrite(ptr, emu->tam_bloque, 1, file);
        
        fclose(file);
        return 0;
 }
 

-
-
-/* me devuelve el ID del bloque donde quepa un registro, y guarda en fs el espacio libre que queda en el bloque */
-int emufs_tipo3_buscar_lugar(EMUFS *emu, unsigned long tam, int *fs)
-{
-       FILE *f_block_free;
-       BLOCK_FREE_T reg;
-       char name_f_block_free[255];
-       
-       strcpy(name_f_block_free,emu->nombre);
-       strcat(name_f_block_free,".fsc");
-
-       if ( (f_block_free = fopen(name_f_block_free,"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_block_free) ){
-               if (fread(&reg,sizeof(BLOCK_FREE_T),1,f_block_free) != 1) continue;
-               if ( reg.free_space >= tam ) 
-                       break;
-               else {
-                       reg.block = -1;
-                       *fs = emu->tam_bloque;
-               }
-       }
-       
-       fclose(f_block_free);
-       if (reg.block != -1)
-               *fs = reg.free_space;
-       return reg.block;
-}
-

 /*borra un registro de un bloque y acomoda los registros que quedan*/
 /*borra un registro de un bloque y acomoda los registros que quedan*/

-int emufs_tipo3_borrar_registro(EMUFS *emu, int ID, int tam_reg)
+int emufs_tipo3_borrar_registro(EMUFS *emu, int ID, unsigned long tam_reg)

 {
 {

-       int num_bloque, ptr_elim, ptr_mov, ID_aux, cant, i;
-       long size;
+       int num_bloque, ptr_elim, ptr_mov, ID_aux, fs;

        char *bloque;
        char *bloque;

-       FILE *f_block_reg;
-       BLOCK_REG_T reg_b;
-       BLOCK_REG_T buffer[10];
-       char name_f_block_reg[255];
-       
-       strcpy(name_f_block_reg,emu->nombre);
-       strcat(name_f_block_reg,".idx");

 
        num_bloque = emufs_idx_buscar_registro(emu, ID);
        bloque = (char*)malloc(emu->tam_bloque);
 
        num_bloque = emufs_idx_buscar_registro(emu, ID);
        bloque = (char*)malloc(emu->tam_bloque);

-       if ( emufs_tipo3_leer_bloque(emu,num_bloque, bloque) == -1 ){
+       if ( emufs_tipo3_leer_bloque(emu,num_bloque, bloque) == -1 ) {

                printf("No se encontro el bloque\n");
                return -1;
        }
                printf("No se encontro el bloque\n");
                return -1;
        }


@@ -291,58 +238,26 @@ int emufs_tipo3_borrar_registro(EMUFS *emu, int ID, int tam_reg)
        }
        
        /*actualizo archivo .fsc*/
        }
        
        /*actualizo archivo .fsc*/

-       if ( emufs_fsc_actualizar(emu, num_bloque, -(tam_reg + sizeof(int)) ) != 0 ) return -1;
+       fs = emufs_fsc_get_fs(emu, num_bloque);
+       if ( emufs_fsc_actualizar(emu, num_bloque, fs + tam_reg + sizeof(int)) != 0 ) return -1;

        
        /*actualizo archivo .did*/
        if ( emufs_did_agregar(emu, ID) != 0 ) return -1;
                
        /*actualizo archivo .idx*/
        /*busco el registro que tengo que eliminar*/
        
        /*actualizo archivo .did*/
        if ( emufs_did_agregar(emu, ID) != 0 ) return -1;
                
        /*actualizo archivo .idx*/
        /*busco el registro que tengo que eliminar*/

-       if ( (f_block_reg = fopen(name_f_block_reg,"r+")) == NULL ) return -1;
+       /* GAZER VER */
+/*     if ( (f_block_reg = fopen(name_f_block_reg,"r+")) == NULL ) return -1;

        while ( !feof(f_block_reg) ){
                if ( fread(&reg_b,sizeof(BLOCK_REG_T),1,f_block_reg) != 1 ) continue;
                if ( reg_b.id_reg == ID )
                        break;
        while ( !feof(f_block_reg) ){
                if ( fread(&reg_b,sizeof(BLOCK_REG_T),1,f_block_reg) != 1 ) continue;
                if ( reg_b.id_reg == ID )
                        break;

-       }
-       fseek(f_block_reg, -sizeof(BLOCK_REG_T), SEEK_CUR);
+       }*/
+/*     fseek(f_block_reg, -sizeof(BLOCK_REG_T), SEEK_CUR);*/

        /* Estoy parado sobre el punto id/registro que debo borrar */
        /* Estoy parado sobre el punto id/registro que debo borrar */

-       printf("registro borrado= %ld   en bloque = %d\n",reg_b.id_reg,reg_b.block);

        /*justifico en archivo a la izquieda*/
 
        /*justifico en archivo a la izquieda*/
 

-       /* GAZER : aca hago una prueba */
-       {
-               long final, actual;
-               actual = ftell(f_block_reg); /* Guardo la posicion actual */
-               fseek(f_block_reg, 0, SEEK_END); /* me voy al final */
-               final = ftell(f_block_reg); /* veo cuando ocupa el archivo */
-               fseek(f_block_reg, actual, SEEK_SET); /* vuelvo al lugar desde donde quiero justificar */
-
-               cant = (final-actual)/sizeof(BLOCK_REG_T);
-               for(i=0; i<cant; i++) {
-                       /* Calculo donde empieza el proximo elemento a mover */
-                       final = actual+sizeof(BLOCK_REG_T);
-                       /* Me paro en ese lugar */
-                       fseek(f_block_reg, final, SEEK_SET);
-                       /* y lo leo */
-                       fread(buffer, sizeof(BLOCK_REG_T), 1, f_block_reg);
-
-                       /* Ahora me paro en la nueva posicion de este item */
-                       fseek(f_block_reg, actual, SEEK_SET);
-                       /* y lo guardo */
-                       fwrite(buffer, sizeof(BLOCK_REG_T), 1, f_block_reg);
-
-                       /* Ahora el proximo item va en la posicion siguiente */
-                       actual += sizeof(BLOCK_REG_T);
-               }
-
-       }
-       /*trunco el ultimo registro del archiv*/
-       fseek(f_block_reg,0,SEEK_END);
-  size = ftell(f_block_reg);
-  fclose(f_block_reg);
-       truncate(name_f_block_reg,size - sizeof(BLOCK_REG_T));
-

        free(bloque);
 
        free(bloque);
 

-return 0;
+       return 0;

 }
 }