-Cambie un poco la interfaz que hizo Rich, para que me quede mas comodo, asi que...

-Tenemos que ponernos de acuerdo en algunos temas de nomenclatura, sobre todo de los nombres de los archivos de indice, porque los que puse yo no me gustan para nada..

diff --git a/tipo3/interface.h b/tipo3/interface.h
index dd33b78915803a91ba03bb459c223896bde726e4..0484420f054aa8bcbd3da5b80858fd1b9dabe52c 100644 (file)
--- a/tipo3/interface.h
+++ b/tipo3/interface.h
@@ -4,9 +4,9 @@
 typedef struct _emu_fs_t {
     enum { T1, T2, T3 } tipo; /* Corregir nombres */
     unsigned long tam_bloque; /* 0 si no tiene bloques */
-    int (*leer_bloque)(int ID, void *, unsigned long tam);
-    int (*leer_registro)(int ID, void *, unsigned long tam);
-    int (*grabar_registro)(int ID, void *, unsigned long tam);
+    int (*leer_bloque)(struct _emu_fs_t *, int, void *);
+    int (*leer_registro)(struct _emu_fs_t *, int, void *, unsigned long);
+    int (*grabar_registro)(int , void *, unsigned long );
     char *nombre;
 } EMUFS;
 

diff --git a/tipo3/main.c b/tipo3/main.c
index 40418e41e21bb6c84844a87f067370a7ead0245c..c9fd819107a402fea1ea00ebaaff27af6afc5c39 100644 (file)
--- a/tipo3/main.c
+++ b/tipo3/main.c
@@ -1,20 +1,14 @@
 #include <stdio.h>
-
+typedef struct block_reg_t{
+       int block;
+       int reg;
+}block_reg_t;
 int main ( )
 {
-char v[39999];
-unsigned int ID_aux = 0, a= 0,b= 0,c=0,d=0;
-v[0]=0x00;
-v[1]=0x31;
-v[2]=0xC7;
-v[3]=0x06;
-a = v[0];
-b = v[1];
-c = v[2];
-d = v[3];
-ID_aux = (d << 0 ) | (c << 8) |  ( b << 16) | (a << 24);
-
-printf("el numero es = %x\n", ID_aux);
+       struct block_reg_t r;
+               
+       printf("sizeof(struct block_reg_t) = %d\n", sizeof(struct block_reg_t));
+       printf("sizeof(r) = %d\n", sizeof(r));  
 
        return 0;
 }

diff --git a/tipo3/param_cte.c b/tipo3/param_cte.c
index 918dbcd1387d57e737a5e99a7727eda5e893f4e5..6567a1a77aed664efb6f4b1d4d403cfff896b845 100644 (file)
--- a/tipo3/param_cte.c
+++ b/tipo3/param_cte.c
@@ -1,109 +1,114 @@
 /* archivo con bloques parametrizados y registro constante */
 
 #include "param_cte.h"
-FILE* block_reg;
-FILE* block_free;
-FILE* reg_exist;
+FILE* f_block_reg;
+FILE* f_block_free;
+FILE* f_reg_exist;
 
 
 /** Leo un registro del archivo, devuelve cero si no lo encuentra.**/
-int leer_registro(int ID, void *str, unsigned long tam)
+int leer_registro(EMUFS *emu, int ID, void *ptr, unsigned long tam_reg)
 {
-       /* FIXME : aca tam es el tamaño del registro, no del bloque!
-        *
-        * Aca deberias recibir una estructura EMUFS y de ahi sacar los datos
-        * del tamaño del bloque a leer.
-        *
-        * leer_registro(EMUFS, int,  void*,  unsigned long);
-        * 
-        * Tambien ver que siempre que hay un return se libere toda la memoria!
-        */
-       char* bloque = (char*)malloc(tam);
-       int block, ID_aux, a, b, c, d, tamanio_registro;
+       char* bloque = (char*)malloc(emu->tam_bloque);
+       char name_f_block_reg[255];
+       int block, ID_aux, a, b, c, d;
        int iterador = 0;
+       strcpy(name_f_block_reg,emu->nombre);
+       strcat(name_f_block_reg,"bloc_reg.tipo3");
+
        /* tengo que crear los archivos de indice antes de usarlos!!!!!!!!!*/
-       if ( (block_reg = fopen("block_reg.dat","a+")) == NULL )
-               return -1; /*ERROR*/
-       
-       if ( (block_free = fopen("block_free.dat","a+")) == NULL )
+       if ( (f_block_reg = fopen(name_f_block_reg,"a+")) == NULL ){
+               free(bloque);
                return -1; /*ERROR*/
+       }
        
-       if ( (reg_exist = fopen("reg_exist.dat","a+")) == NULL )
-               return -1; /*ERROR*/
+
        /* si el registro no existe, retorno*/
-       if ( existe_registro(ID) == -1 ) return -1;
+       if ( existe_registro(emu,ID) == -1 ){
+               free(bloque);
+               return -1;
+       }
        /*si existe, lo busco en el archivo de bloques*/
        
-       block = buscar_registro(ID); /*me devuelve el nro de bloque al que pertenece el registro*/
-       if (leer_bloque(block,bloque,tam)==-1) 
+       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);
                return -1; /*No se pudo leer el bloque*/
+       }
        
-       while ( iterador != (tam/tamanio_registro) ){
+       while ( iterador != emu->tam_bloque ){ 
                a = bloque[0+iterador];
                b = bloque[1+iterador];
                c = bloque[2+iterador];
                d = bloque[3+iterador];
+               iterador += 4;
                ID_aux = (d << 0 ) | (c << 8) |  ( b << 16) | (a << 24);
                if ( ID_aux == ID ){
-                               /* TODO : la copia es byte a byte. Al archivo
-                                * no le importa que tipo de estructura es
-                                */
-                               //aca va el memcpy... HACER!!
-                               //copiar(dato, &str);
+                               memcpy(ptr,bloque[iterador],tam_reg);
                                break;
                        }
-               // FIXME : El tamaño del registro es lo que debo tener
-               // aca, no el tamaño del tipo de dato.
-               //
-               // Cuando se crea el archivo se le da el tamaño de un registro
-               iterador += tamanio_registro;   
+               iterador += tam_reg;    
        }               
-       fclose(block_reg);              
-       fclose(block_free);
-       fclose(reg_exist);
+       
+       fclose(f_block_reg);            
        free(bloque);
        return 0;
-       
 }
 
 
 /*busco el registro ID en el archivo reg_exist.dat, para ver si existe.*/
-int existe_registro(int ID)
+int existe_registro(EMUFS *emu, int ID)
 {
-       int num;
-       char ex;
-       if ( (reg_exist = fopen("reg_exist.dat","r")) == NULL) return 0; /*ERROR*/
-       while ( !feof(reg_exist) ){
-               fscanf(reg_exist,"%i%c",&num,&ex);
-               if ( num == ID && ex == 'S' ){
-                       fclose(reg_exist);
+       REG_EXIST_T reg;
+       char name_f_reg_exist[255];
+       strcpy(name_f_reg_exist,emu->nombre);
+       strcat(name_f_reg_exist,"_exist_reg.tipo3");
+       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' ){
+                       fclose(f_reg_exist);
                        return 0;
                }
        }
        
-       fclose(reg_exist);
+       fclose(f_reg_exist);
        return -1;
 }
 
 
 /*busca el registro ID en el archivo "block_reg.dat" y devuelve el nro de bloque en el que se encuentra*/
-int buscar_registro(int ID)
+int buscar_registro(EMUFS *emu, int ID)
 {
-       int num_block, num_reg; 
-       if ( (block_reg = fopen("block_reg.dat","r")) == NULL) return 0; /*ERROR*/
-       while ( !feof(block_reg) ){
-               fscanf(block_reg,"%i%i",&num_block,&num_reg);
-               if ( num_reg == ID ){
-                       fclose(block_reg);
-                       return num_block;
+       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");
+       
+       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 == ID ){
+                       fclose(f_block_reg);
+                       return reg.block;
                }
        }
        
-       fclose(block_reg);
+       fclose(f_block_reg);
        return -1;
 }
 
-int leer_bloque(int ID, void* str, unsigned long tam)
+int leer_bloque(EMUFS *emu, int ID, void* ptr)
 {
+       FILE* file;
+       char name_f[255];
+       
+       strcpy(name_f,emu->nombre);
+       strcat(name_f,".tipo3");
+       
+       if ( (file = fopen(name_f,"r"))==NULL ) return -1; /*ERROR*/
+       fseek(file,ID*emu->tam_bloque,SEEK_SET);
+       fread(ptr,emu->tam_bloque,1,file);
+       
        return 0;
 }

diff --git a/tipo3/param_cte.h b/tipo3/param_cte.h
index 136b8eca25cb766a52fd37600d854f85f0794087..545c21e1a2a08c9a1574c00a9c4f09f80844cfc1 100644 (file)
--- a/tipo3/param_cte.h
+++ b/tipo3/param_cte.h
@@ -5,14 +5,29 @@
 #include <string.h>
 #include "interface.h"
 
-int leer_bloque(int ID, void *, unsigned long tam);
+typedef struct reg_exist_t{
+       int id_reg;
+       char existe;
+}REG_EXIST_T;
 
-int leer_registro(int ID, void *, unsigned long tam);
+typedef struct block_free_t{
+       int block;
+       int free_space;
+}BLOCK_FREE_T;
+
+typedef struct block_reg_t{
+       int block;
+       int id_reg;
+}BLOCK_REG_T;
+
+int leer_registro(EMUFS *emu, int ID, void *, unsigned long tam);
+
+int leer_bloque(EMUFS *emu, int ID, void *);
 
 int grabar_registro(int ID, void *, unsigned long tam);
 
-int existe_registro(int ID);
+int existe_registro(EMUFS *emu, int ID);
 
-int buscar_registro(int ID);
+int buscar_registro(EMUFS *emu, int ID);
 
 #endif