From 8c4b45bea612dbaa2b478203697ab153a11bf18a Mon Sep 17 00:00:00 2001 From: =?utf8?q?Nicol=C3=A1s=20Dimov?= Date: Thu, 1 Apr 2004 19:10:15 +0000 Subject: [PATCH] -Cambie un poco la interfaz que hizo Rich, para que me quede mas comodo, asi que se van a tener que adaptar a mi... ja! -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.. --- tipo3/interface.h | 6 +-- tipo3/main.c | 22 +++------ tipo3/param_cte.c | 121 ++++++++++++++++++++++++---------------------- tipo3/param_cte.h | 23 +++++++-- 4 files changed, 93 insertions(+), 79 deletions(-) diff --git a/tipo3/interface.h b/tipo3/interface.h index dd33b78..0484420 100644 --- 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 40418e4..c9fd819 100644 --- a/tipo3/main.c +++ b/tipo3/main.c @@ -1,20 +1,14 @@ #include - +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 918dbcd..6567a1a 100644 --- 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(®,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(®,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 136b8ec..545c21e 100644 --- a/tipo3/param_cte.h +++ b/tipo3/param_cte.h @@ -5,14 +5,29 @@ #include #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 -- 2.43.0