hice un par de funciones, tendria que empezar a probarlo porque van empezar a saltar...

diff --git a/tipo3/param_cte.c b/tipo3/param_cte.c
index 6567a1a77aed664efb6f4b1d4d403cfff896b845..b2f98bdcbfaacc2ff0a3422e6a2f61b63e437e3f 100644 (file)
--- a/tipo3/param_cte.c
+++ b/tipo3/param_cte.c
@@ -5,16 +5,15 @@ FILE* f_block_reg;
 FILE* f_block_free;
 FILE* f_reg_exist;
 
 FILE* f_block_free;
 FILE* f_reg_exist;
 

-

 /** Leo un registro del archivo, devuelve cero si no lo encuentra.**/
 int leer_registro(EMUFS *emu, int ID, void *ptr, unsigned long tam_reg)
 {
        char* bloque = (char*)malloc(emu->tam_bloque);
        char name_f_block_reg[255];
 /** Leo un registro del archivo, devuelve cero si no lo encuentra.**/
 int leer_registro(EMUFS *emu, int ID, void *ptr, unsigned long tam_reg)
 {
        char* bloque = (char*)malloc(emu->tam_bloque);
        char name_f_block_reg[255];

-       int block, ID_aux, a, b, c, d;
+       int block, ID_aux;

        int iterador = 0;
        strcpy(name_f_block_reg,emu->nombre);
        int iterador = 0;
        strcpy(name_f_block_reg,emu->nombre);

-       strcat(name_f_block_reg,"bloc_reg.tipo3");
+       strcat(name_f_block_reg,".id3");

 
        /* tengo que crear los archivos de indice antes de usarlos!!!!!!!!!*/
        if ( (f_block_reg = fopen(name_f_block_reg,"a+")) == NULL ){
 
        /* tengo que crear los archivos de indice antes de usarlos!!!!!!!!!*/
        if ( (f_block_reg = fopen(name_f_block_reg,"a+")) == NULL ){


@@ -23,13 +22,7 @@ int leer_registro(EMUFS *emu, int ID, void *ptr, unsigned long tam_reg)
        }
        
 
        }
        
 

-       /* si el registro no existe, retorno*/
-       if ( existe_registro(emu,ID) == -1 ){
-               free(bloque);
-               return -1;
-       }

        /*si existe, lo busco en el archivo de bloques*/
        /*si existe, lo busco en el archivo de bloques*/

-       

        block = buscar_registro(emu,ID); /*me devuelve el nro de bloque al que pertenece el registro*/
        if (leer_bloque(emu, block, bloque)==-1){
                free(bloque);
        block = buscar_registro(emu,ID); /*me devuelve el nro de bloque al que pertenece el registro*/
        if (leer_bloque(emu, block, bloque)==-1){
                free(bloque);


@@ -37,16 +30,12 @@ int leer_registro(EMUFS *emu, int ID, void *ptr, unsigned long tam_reg)
        }
        
        while ( iterador != emu->tam_bloque ){ 
        }
        
        while ( iterador != emu->tam_bloque ){ 

-               a = bloque[0+iterador];
-               b = bloque[1+iterador];
-               c = bloque[2+iterador];
-               d = bloque[3+iterador];
+               memcpy(&ID_aux, bloque+iterador, sizeof(int));

                iterador += 4;
                iterador += 4;

-               ID_aux = (d << 0 ) | (c << 8) |  ( b << 16) | (a << 24);

                if ( ID_aux == ID ){
                if ( ID_aux == ID ){

-                               memcpy(ptr,bloque[iterador],tam_reg);
-                               break;
-                       }
+                       memcpy(ptr,&bloque[iterador],tam_reg);
+                       break;
+               }

                iterador += tam_reg;    
        }               
        
                iterador += tam_reg;    
        }               
        


@@ -56,17 +45,17 @@ int leer_registro(EMUFS *emu, int ID, void *ptr, unsigned long tam_reg)
 }
 
 
 }
 
 

-/*busco el registro ID en el archivo reg_exist.dat, para ver si existe.*/
+/*busco el ID en el archivo xxxxx.ids, para ver si puedo usar ese ID.*/

 int existe_registro(EMUFS *emu, int ID)
 {
 int existe_registro(EMUFS *emu, int ID)
 {

-       REG_EXIST_T reg;
+       int reg;

        char name_f_reg_exist[255];
        strcpy(name_f_reg_exist,emu->nombre);
        char name_f_reg_exist[255];
        strcpy(name_f_reg_exist,emu->nombre);

-       strcat(name_f_reg_exist,"_exist_reg.tipo3");
+       strcat(name_f_reg_exist,".ids");

        if ( (f_reg_exist = fopen(name_f_reg_exist,"r")) == NULL) return -1; /*ERROR*/
        while ( !feof(f_reg_exist) ){
                fread(&reg,sizeof(reg),1,f_reg_exist);
        if ( (f_reg_exist = fopen(name_f_reg_exist,"r")) == NULL) return -1; /*ERROR*/
        while ( !feof(f_reg_exist) ){
                fread(&reg,sizeof(reg),1,f_reg_exist);

-               if ( reg.id_reg == ID && reg.existe == 'S' ){
+               if ( reg == ID ){

                        fclose(f_reg_exist);
                        return 0;
                }
                        fclose(f_reg_exist);
                        return 0;
                }


@@ -83,7 +72,7 @@ int buscar_registro(EMUFS *emu, int ID)
        BLOCK_REG_T reg;
        char name_f_block_reg[255];
        strcpy(name_f_block_reg,emu->nombre);
        BLOCK_REG_T reg;
        char name_f_block_reg[255];
        strcpy(name_f_block_reg,emu->nombre);

-       strcat(name_f_block_reg,"_block_reg.tipo3");
+       strcat(name_f_block_reg,".id3");

        
        if ( (f_block_reg = fopen(name_f_block_reg,"r")) == NULL) return -1; /*ERROR*/
        while ( !feof(f_block_reg) ){
        
        if ( (f_block_reg = fopen(name_f_block_reg,"r")) == NULL) return -1; /*ERROR*/
        while ( !feof(f_block_reg) ){


@@ -95,20 +84,134 @@ int buscar_registro(EMUFS *emu, int ID)
        }
        
        fclose(f_block_reg);
        }
        
        fclose(f_block_reg);

-       return -1;
+       return -1; /*no existe el registro*/

 }
 
 }
 

+
+/*leo el bloque "ID" del archivo que viene en "emu->nombre", y lo almaceno en "ptr"*/

 int leer_bloque(EMUFS *emu, int ID, void* ptr)
 {
        FILE* file;
        char name_f[255];
        
        strcpy(name_f,emu->nombre);
 int leer_bloque(EMUFS *emu, int ID, void* ptr)
 {
        FILE* file;
        char name_f[255];
        
        strcpy(name_f,emu->nombre);

-       strcat(name_f,".tipo3");
+       strcat(name_f,".dat");

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

-       fseek(file,ID*emu->tam_bloque,SEEK_SET);
+       fseek(file,5,SEEK_SET);
+       fseek(file,ID*emu->tam_bloque,SEEK_CUR);

        fread(ptr,emu->tam_bloque,1,file);
        
        fread(ptr,emu->tam_bloque,1,file);
        

+       fclose(file);
+       return 0;
+}
+
+int grabar_registro(EMUFS *emu, void *ptr, unsigned long tam)
+{
+       int ID_aux, fs, num_bloque;
+       FILE *file;
+       char name_f[255];
+       char* bloque = (char*)malloc(emu->tam_bloque);
+       strcpy(name_f,emu->nombre);
+       strcat(name_f,".dat");
+       
+       if ( (file = fopen(name_f,"r"))==NULL ) return -1; /*ERROR*/
+       
+       /* me devuelve el ID del bloque donde quepa un registro */
+       num_bloque = buscar_lugar(emu, tam, &fs);
+       /*cargo el bloque en "bloque"*/
+       if ( leer_bloque(emu,num_bloque,bloque)== -1) return -1; 
+       /*El error puede haberse producido porque la funcion buscar_lugar devolvio -1, el cual es un bloque invalido*/
+       
+       /*insertar el registro en el bloque*/
+       /*tengo que buscar un ID valido para el nuevo registro*/
+       ID_aux = get_id(emu);
+       /*grabo el id en el bloque*/
+       memcpy(bloque+emu->tam_bloque-fs,&ID_aux,sizeof(int));
+       /*grabo el registro en el bloque*/
+       memcpy(bloque+emu->tam_bloque-fs+sizeof(int),ptr,tam);
+       /*guardo el bloque en el archivo*/
+       if ( grabar_bloque(emu, bloque, num_bloque) != 0) return -1; /* se produjo un error */  
+       
+       return ID_aux;
+}
+
+/*Graba un bloque en el archivo*/
+int grabar_bloque(EMUFS *emu, void *ptr, int num)
+{
+       FILE* file;
+       char name_f[255];
+       
+       strcpy(name_f,emu->nombre);
+       strcat(name_f,".dat");
+       
+       if ( (file = fopen(name_f,"r+"))==NULL ) return -1; /*ERROR*/
+       fseek(file,num*emu->tam_bloque,SEEK_SET);       
+       fwrite(ptr, emu->tam_bloque, 1, file);
+       
+       fclose(file);

        return 0;
 }
        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 buscar_lugar(EMUFS *emu, unsigned long tam, int *fs)
+{
+       BLOCK_FREE_T reg;
+       char name_f_block_reg[255];
+       
+       strcpy(name_f_block_reg,emu->nombre);
+       strcat(name_f_block_reg,".fsc");
+
+       if ( (f_block_free = fopen(name_f_block_reg,"r"))==NULL ) return -1;
+       
+       while( !feof(f_block_free) ){
+               fread(&reg,sizeof(reg),1,f_block_free);
+               if ( reg.free_space >= tam ) 
+                       break;
+               else reg.block = -1;
+       }
+       
+       fclose(f_block_free);
+       *fs = reg.free_space;
+       return reg.block;
+}
+
+/*Busco en el archivo de Id`s un Id valido para un nuevo registro*/
+int get_id(EMUFS *emu)
+{
+       BLOCK_REG_T reg;
+       int id, max = -1;
+       char name_f_reg_exist[255];
+       char name_f_block_reg[255];
+
+       strcpy(name_f_block_reg,emu->nombre);
+       strcat(name_f_block_reg,".id3");
+
+       strcpy(name_f_reg_exist,emu->nombre);
+       strcat(name_f_reg_exist,".ids");
+
+       if ( (f_reg_exist = fopen(name_f_reg_exist,"r")) == NULL) return -1; /*ERROR*/
+       if ( !feof(f_reg_exist) ){
+               /* si el archivo no esta vacio es porque hay un nro disponible*/
+               fseek(f_reg_exist,sizeof(id),SEEK_END);
+               fread(&id,sizeof(id),1,f_reg_exist);
+               /* FIXME: tengo que truncar el archivo*/
+               /* FIXME: tengo que truncar el archivo*/
+               /* FIXME: tengo que truncar el archivo*/
+       }else{
+               /*si no, hay que buscar el mayor de los numeros*/
+               if ( (f_block_reg = fopen(name_f_block_reg,"r")) == NULL) return -1; /*ERROR*/
+               while ( !feof(f_block_reg) ){
+                       fread(&reg,sizeof(reg),1,f_block_reg);
+                       if ( reg.id_reg >= max ) 
+                               max = reg.id_reg;
+               }
+               id = max+1;
+       }
+                       
+       fclose(f_block_reg);
+       fclose(f_reg_exist);
+       return id;      
+}

diff --git a/tipo3/param_cte.h b/tipo3/param_cte.h
index 545c21e1a2a08c9a1574c00a9c4f09f80844cfc1..92c9477c6588603725ca1a82df8a6f21c82bcf50 100644 (file)
--- a/tipo3/param_cte.h
+++ b/tipo3/param_cte.h
@@ -5,10 +5,6 @@
 #include <string.h>
 #include "interface.h"
 
 #include <string.h>
 #include "interface.h"
 

-typedef struct reg_exist_t{
-       int id_reg;
-       char existe;
-}REG_EXIST_T;

 
 typedef struct block_free_t{
        int block;
 
 typedef struct block_free_t{
        int block;


@@ -24,10 +20,15 @@ int leer_registro(EMUFS *emu, int ID, void *, unsigned long tam);
 
 int leer_bloque(EMUFS *emu, int ID, void *);
 
 
 int leer_bloque(EMUFS *emu, int ID, void *);
 

-int grabar_registro(int ID, void *, unsigned long tam);
+int grabar_registro(EMUFS *emu, void *, unsigned long tam);

 
 int existe_registro(EMUFS *emu, int ID);
 
 int buscar_registro(EMUFS *emu, int ID);
 
 
 int existe_registro(EMUFS *emu, int ID);
 
 int buscar_registro(EMUFS *emu, int ID);
 

+int buscar_lugar(EMUFS *emu, unsigned long tam, int *fs);
+
+int get_id(EMUFS *emu);
+
+int grabar_bloque(EMUFS *emu, void *ptr, int num);

 #endif
 #endif