* BUGFIXES en tipo3 :

    - En grabar registro se estaba agregando a IDX el numero de bloque del ultimo
		  bloque ocupado en lugar del primero (para el caso de reg > block)
	  - El caso de cant_bloques == 1 decia cant_bloques == 0
 * Se actualiza tipo3_leer_raw para leer registros de muchos bloques
 * La GUI se pone al dia con tipo3 y ahora en pantalla se muestran correctamente
   los registros que ocupan mas de 1 bloque (se pone <> para indicar el cambio de bloque)

diff --git a/emufs/tipo3.c b/emufs/tipo3.c
index f5291ec043086467ecf36e8b7af0f06366f16996..fd59a683ae197ed1f5cf47885c135a7ed287f4c5 100644 (file)
--- a/emufs/tipo3.c
+++ b/emufs/tipo3.c
@@ -158,15 +158,17 @@ EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE t
                if ( (file = fopen(name_f,"a+"))==NULL ) return -1; /*ERROR*/
                /*tengo que buscar un ID valido para el nuevo registro*/
                ID_aux = emufs_idx_get_new_id(emu, err);
                if ( (file = fopen(name_f,"a+"))==NULL ) return -1; /*ERROR*/
                /*tengo que buscar un ID valido para el nuevo registro*/
                ID_aux = emufs_idx_get_new_id(emu, err);

+
+               /* El free esta al final de la funcion! */
+               bloque = (char*)malloc(emu->tam_bloque);

                for (i=0; i<cant_bloques; i++) {
                        /*crear un nuevo bloque en memoria */
                for (i=0; i<cant_bloques; i++) {
                        /*crear un nuevo bloque en memoria */

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

                        memset(bloque, 0, emu->tam_bloque);
                        /* grabar el registro al principio del bloque */
                        /*grabo el id en el bloque*/
                        memcpy(bloque,&ID_aux,sizeof(EMUFS_REG_ID));
                        /*grabo el registro en el bloque*/
                        memset(bloque, 0, emu->tam_bloque);
                        /* grabar el registro al principio del bloque */
                        /*grabo el id en el bloque*/
                        memcpy(bloque,&ID_aux,sizeof(EMUFS_REG_ID));
                        /*grabo el registro en el bloque*/

-                       if ( cant_bloques == 0 ){
+                       if ( cant_bloques == 1 ){

                                memcpy(bloque+sizeof(EMUFS_REG_ID),ptr,emu->tam_reg);
                        } else {
                                if ( cant_bloques-1 == i )
                                memcpy(bloque+sizeof(EMUFS_REG_ID),ptr,emu->tam_reg);
                        } else {
                                if ( cant_bloques-1 == i )


@@ -174,7 +176,7 @@ EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE t
                                memcpy(bloque+sizeof(EMUFS_REG_ID),((char*)ptr)+i*(emu->tam_bloque-sizeof(EMUFS_REG_ID)),resto);
                        }
                        /* me paro al final del archivo */
                                memcpy(bloque+sizeof(EMUFS_REG_ID),((char*)ptr)+i*(emu->tam_bloque-sizeof(EMUFS_REG_ID)),resto);
                        }
                        /* 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*/


@@ -183,6 +185,14 @@ EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE t
                        cant = (ftell(file)-(sizeof(EMUFS_Tipo)+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_BLOCK_SIZE))) / emu->tam_bloque;
                        cant--; /* Resto uno porque el numero de bloque debe empezar en 0 */
                        num_bloque = cant;
                        cant = (ftell(file)-(sizeof(EMUFS_Tipo)+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_BLOCK_SIZE))) / emu->tam_bloque;
                        cant--; /* Resto uno porque el numero de bloque debe empezar en 0 */
                        num_bloque = cant;

+
+                       if (i == 0) {
+                               /* Tengo que agregar el primer bloque en IDX */
+                               if ( emufs_idx_agregar(emu, ID_aux, num_bloque) != 0 ){
+                                       free(bloque);
+                                       return -1;
+                               }
+                       }

                        /* grabo el nuevo registro en el archivo de espacios libres */
                        if ( emufs_fsc_agregar(emu, num_bloque, emu->tam_bloque - resto - sizeof(EMUFS_REG_ID)) != 0 ) {
                                fclose(file);
                        /* grabo el nuevo registro en el archivo de espacios libres */
                        if ( emufs_fsc_agregar(emu, num_bloque, emu->tam_bloque - resto - sizeof(EMUFS_REG_ID)) != 0 ) {
                                fclose(file);


@@ -191,11 +201,6 @@ EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE t
                        }
                }
                fclose(file);
                        }
                }
                fclose(file);

-               /*actualizo el archivo de bloques y registros*/
-               if ( emufs_idx_agregar(emu, ID_aux, num_bloque) != 0 ){
-                       free(bloque);
-                       return -1;
-               }

        } else {
                /*cargo el bloque en "bloque"*/
                if (!(bloque = emufs_tipo3_leer_bloque(emu, num_bloque, err))) {
        } else {
                /*cargo el bloque en "bloque"*/
                if (!(bloque = emufs_tipo3_leer_bloque(emu, num_bloque, err))) {


@@ -345,47 +350,79 @@ EMUFS_REG_ID emufs_tipo3_modificar_registro(EMUFS *emu, EMUFS_REG_ID id, void *d
 
 void* emufs_tipo3_leer_registro_raw(EMUFS *emu, EMUFS_REG_ID ID, EMUFS_REG_SIZE *size, int *pos)
 {
 
 void* emufs_tipo3_leer_registro_raw(EMUFS *emu, EMUFS_REG_ID ID, EMUFS_REG_SIZE *size, int *pos)
 {

-       char* bloque;
+       char* bloque, *tmp, *cur;

        EMUFS_BLOCK_ID block;
        EMUFS_REG_ID ID_aux;
        EMUFS_BLOCK_SIZE iterador = 0;
        EMUFS_BLOCK_ID block;
        EMUFS_REG_ID ID_aux;
        EMUFS_BLOCK_SIZE iterador = 0;

-       int err;
-       
-       /*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*/
-       if ( block == EMUFS_NOT_FOUND ){
-               PERR("No se encontro el bloque");
-               return NULL;
-       }
-       if ((bloque = emufs_tipo3_leer_bloque(emu, block, &err)) == NULL) {
-               /* TODO Manejo de errores, queda en el codigo de error lo que devolvio
-                * emufs_tipo3_leer_bloque() */
-               PERR("no se pudo leer el bloque");
-               return NULL; /*No se pudo leer el bloque*/
-       }
-       
-       ID_aux = -1;
-       iterador = 0;
+       int err, cant_bloques, i;

        
        

-       if ( emu->tam_bloque < emu->tam_reg ){
-               *pos = sizeof(EMUFS_REG_ID);
-               *size = emu->tam_bloque;
-               return bloque;
-       }
+       bloque = NULL;
+       if (emu->tam_reg < emu->tam_bloque) {
+               /* Aca estoy en el caso de que 1 registro entra en 1 solo bloque */
+               block = emufs_idx_buscar_registro(emu,ID);
+               if ( block == EMUFS_NOT_FOUND ){
+                       return NULL;
+               }
+               if ((bloque = emufs_tipo3_leer_bloque(emu, block, &err)) == NULL) {
+                       return NULL;
+               }
+               
+               ID_aux = -1;
+               iterador = 0;

        
        

-       /* Busco el offset desde el comienzo desde donde arranca el registro
-        * buscado, para luego resaltarlo en al GUI
-        */
-       while ( iterador < emu->tam_bloque ) {
-               memcpy(&ID_aux, bloque+iterador, sizeof(EMUFS_REG_ID));
-               if ( ID_aux == ID ){
-                       *pos = iterador; 
-                       *size = emu->tam_bloque;
-                       break;
+               /* Busco el offset desde el comienzo desde donde arranca el registro
+                * buscado, para luego resaltarlo en al GUI
+                */
+               while ( iterador < emu->tam_bloque ) {
+                       memcpy(&ID_aux, bloque+iterador, sizeof(EMUFS_REG_ID));
+                       if ( ID_aux == ID ){
+                               *pos = iterador; 
+                               *size = emu->tam_bloque;
+                               break;
+                       }
+                       iterador += sizeof(EMUFS_REG_ID);
+                       iterador += emu->tam_reg;

                }
                }

-               iterador += sizeof(EMUFS_REG_ID);
-               iterador += emu->tam_reg;
+       } else {
+               /* Junto todos los bloques que ocupa el registro y agrego un separador de bloques */
+               
+               /* Busco el primer bloque */
+               block = emufs_idx_buscar_registro(emu,ID);
+               if ( block == EMUFS_NOT_FOUND ){
+                       return NULL;
+               }
+               cant_bloques = emu->tam_reg / emu->tam_bloque + 1;
+               *size = emu->tam_bloque*cant_bloques + cant_bloques*2 - sizeof(EMUFS_REG_ID)*(cant_bloques-1);
+               bloque = (char *)malloc(*size);
+               cur = bloque;
+               *pos = 0; 
+
+               /* El bloque 0 va completo */
+               if ((tmp = emufs_tipo3_leer_bloque(emu, block, &err)) == NULL) {
+                       /* Oops! ... un bloque no existe, todo mal! */
+                       free(bloque);
+                       return NULL;
+               }
+               memcpy(cur, tmp, emu->tam_bloque);
+               cur += emu->tam_bloque;
+               memcpy(cur, "<>", 2);
+               cur += 2;
+               free(tmp);
+               
+               /* En resto de los bloques no pongo el ID porque ya esta en el primero */
+               for(i=1; i<cant_bloques; i++) {
+                       if ((tmp = emufs_tipo3_leer_bloque(emu, block+i, &err)) == NULL) {
+                               /* Oops! ... un bloque no existe, todo mal! */
+                               free(bloque);
+                               return NULL;
+                       }
+                       memcpy(cur, tmp+sizeof(EMUFS_REG_ID), emu->tam_bloque-sizeof(EMUFS_REG_ID));
+                       cur += emu->tam_bloque - sizeof(EMUFS_REG_ID);
+                       memcpy(cur, "<>", 2);
+                       cur += 2;
+                       free(tmp);
+               }
+               (*cur) = '\0';

        }
        }

-       

        return bloque;
 }
        return bloque;
 }

diff --git a/emufs_gui/articulos.c b/emufs_gui/articulos.c
index 150910ed35ab49d22a3e45fe9eeb07b86decef1a..241547f1aa14320d620b0c19410d06adc6b3018e 100644 (file)
--- a/emufs_gui/articulos.c
+++ b/emufs_gui/articulos.c
@@ -101,6 +101,7 @@ t_LstArticulos *art_cargar(const char *filename, int tipo, int tam_bloque)
                                if (strcmp(node->name, "ARTICULO") == 0) {
                                        t_Articulo art;
                                        void *save;
                                if (strcmp(node->name, "ARTICULO") == 0) {
                                        t_Articulo art;
                                        void *save;

+                                       memset(&art, 0, sizeof(t_Articulo));

                                        art.numero = atoi(xmlGetProp(node, "NroArtículo"));
                                        strncpy(art.desc, xmlGetProp(node, "Descripción"), 50);
                                        strncpy(art.presentacion, xmlGetProp(node, "Presentación"), 30);
                                        art.numero = atoi(xmlGetProp(node, "NroArtículo"));
                                        strncpy(art.desc, xmlGetProp(node, "Descripción"), 50);
                                        strncpy(art.presentacion, xmlGetProp(node, "Presentación"), 30);

diff --git a/emufs_gui/registros.c b/emufs_gui/registros.c
index 7c043e7b901dadb401946533ad55e65f5c8e8efd..bbd2ff610ecec26887383bf3e1183baef133a23a 100644 (file)
--- a/emufs_gui/registros.c
+++ b/emufs_gui/registros.c
@@ -46,6 +46,7 @@ void mostrar_info(WINDOW *padre, int h, int offset_alto)
        mvwaddstr(padre, h-offset_alto+4, 48, "(XXX) = ID de registro");
        mvwaddstr(padre, h-offset_alto+5, 48, "{XXX} = Tam. de registro");
        mvwaddstr(padre, h-offset_alto+6, 48, "  .   = Esp. Libre");
        mvwaddstr(padre, h-offset_alto+4, 48, "(XXX) = ID de registro");
        mvwaddstr(padre, h-offset_alto+5, 48, "{XXX} = Tam. de registro");
        mvwaddstr(padre, h-offset_alto+6, 48, "  .   = Esp. Libre");

+       mvwaddstr(padre, h-offset_alto+6, 48, " < >  = Separador Bloques");

 }
        
 void ver_registros(WINDOW *padre, int w, int h)
 }
        
 void ver_registros(WINDOW *padre, int w, int h)


@@ -223,12 +224,18 @@ void ver_registros(WINDOW *padre, int w, int h)
 char *procesar_registro_articulo_tipo3(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho)
 {
        char *tmp, *salida, *tmp1, pos_actualizada, ant;
 char *procesar_registro_articulo_tipo3(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho)
 {
        char *tmp, *salida, *tmp1, pos_actualizada, ant;

-       int cant_header, i=0, j;
+       int cant_header, i=0, j, tam_data;

        if (ptr == NULL) return NULL;
 
        /* Calculo cuantos headers de registros va a haber en el archivo */
        if (ptr == NULL) return NULL;
 
        /* Calculo cuantos headers de registros va a haber en el archivo */

-       cant_header = emu->tam_bloque / (emu->tam_reg+sizeof(EMUFS_REG_ID));
-       if (cant_header == 0) cant_header++; /* Si tam_reg > tam_bloque, voy a tener solo 1 header */
+       if (emu->tam_bloque > emu->tam_reg) {
+               cant_header = emu->tam_bloque / (emu->tam_reg+sizeof(EMUFS_REG_ID));
+               if (cant_header == 0) cant_header++; /* Si tam_reg > tam_bloque, voy a tener solo 1 header */
+               tam_data = sizeof(t_Articulo)-sizeof(unsigned int);
+       } else {
+               cant_header = 1;
+               tam_data = *size - sizeof(EMUFS_REG_ID)-sizeof(unsigned int);
+       }

 
        /* El tamaño del nuevo array lo calculo asi :
         *   
 
        /* El tamaño del nuevo array lo calculo asi :
         *   


@@ -240,6 +247,9 @@ char *procesar_registro_articulo_tipo3(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *si
         *   +1 == Por el \0
         */
        salida = (char *)malloc((*size)-sizeof(unsigned int)*cant_header*2 + 2*cant_header*10+1);
         *   +1 == Por el \0
         */
        salida = (char *)malloc((*size)-sizeof(unsigned int)*cant_header*2 + 2*cant_header*10+1);

+       if (salida == NULL) {
+               return NULL;
+       }

        tmp = ptr;
        tmp1 = salida;
        pos_actualizada = 0;
        tmp = ptr;
        tmp1 = salida;
        pos_actualizada = 0;


@@ -252,15 +262,17 @@ char *procesar_registro_articulo_tipo3(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *si
                        pos_actualizada = 1;
                }
                /* Pongo el ID del registro */
                        pos_actualizada = 1;
                }
                /* Pongo el ID del registro */

-               sprintf(tmp1, "(%08d)", *((unsigned int *)tmp));
+               sprintf(tmp1, "(%08lu)", *((EMUFS_REG_ID *)tmp));
+               fprintf(stderr, "ID=%lu\n",*((EMUFS_REG_ID *)tmp) );

                tmp1 += 10;
                tmp1 += 10;

-               tmp += sizeof(unsigned int);
+               tmp += sizeof(EMUFS_REG_ID);

                /* Pongo el campo numero del registro */
                sprintf(tmp1, "[%08d]", *((unsigned int *)tmp));
                /* Pongo el campo numero del registro */
                sprintf(tmp1, "[%08d]", *((unsigned int *)tmp));

+               fprintf(stderr, "Numero=%d\n",*((unsigned int *)tmp) );

                tmp1 += 10;
                tmp += sizeof(unsigned int);
                j = 0;
                tmp1 += 10;
                tmp += sizeof(unsigned int);
                j = 0;

-               while (j < (sizeof(t_Articulo)-sizeof(unsigned int))) {
+               while (j < (tam_data)) {

                        if (*tmp == '\0') {
                                if (ant == (*tmp))
                                        (*tmp1) = '.';
                        if (*tmp == '\0') {
                                if (ant == (*tmp))
                                        (*tmp1) = '.';


@@ -278,8 +290,16 @@ char *procesar_registro_articulo_tipo3(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *si
        }
        free(ptr);
        (*tmp1) = '\0';
        }
        free(ptr);
        (*tmp1) = '\0';

-       (*size) = (*size)-sizeof(unsigned int)*cant_header*2+2*cant_header*10+1;
-       (*ancho) = sizeof(t_Articulo)-sizeof(unsigned int)*2+20;
+       
+       if (emu->tam_bloque > emu->tam_reg) {
+               (*size) = (*size)-sizeof(unsigned int)*cant_header*2+2*cant_header*10+1;
+               (*ancho) = sizeof(t_Articulo)-sizeof(unsigned int)*2+20;
+       } else {
+               (*size) = (*size)-sizeof(EMUFS_REG_ID)-sizeof(unsigned int)+21;
+               (*ancho) = (*size);
+       }
+
+       fprintf(stderr, "SALI OK\n");

        return salida;
 }
 
        return salida;
 }