hago un pequeño fix para que ande un poco mejor cuando bloque < reg

[z.facultad/75.06/emufs.git] / emufs_gui / registros.c

diff --git a/emufs_gui/registros.c b/emufs_gui/registros.c
index 7c043e7b901dadb401946533ad55e65f5c8e8efd..aa9c86758779785bdd2a4fbcdc742a9ff4e8ca95 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+7, 48, " < >  = Separador Bloques");

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


@@ -83,8 +84,10 @@ void ver_registros(WINDOW *padre, int w, int h)
        indices = emufs_idx_get(fp, &indices_total);
 
        indices_actual = 0;
        indices = emufs_idx_get(fp, &indices_total);
 
        indices_actual = 0;

-       data = (char *)fp->leer_registro_raw(fp, indices[indices_actual], &size, &pos_actual);
-       data = procesar(fp, data, &size, &pos_actual, &ancho_registro);
+       if (indices) {
+               data = (char *)fp->leer_registro_raw(fp, indices[indices_actual], &size, &pos_actual);
+               data = procesar(fp, data, &size, &pos_actual, &ancho_registro);
+       }

 
 
        offset_alto = 8;
 
 
        offset_alto = 8;


@@ -213,22 +216,29 @@ void ver_registros(WINDOW *padre, int w, int h)
                wrefresh(actual[1]);
                wrefresh(padre);
        }
                wrefresh(actual[1]);
                wrefresh(padre);
        }

-       delwin(actual[1]);
+       if (indices) free(indices);
+       if (data) free(data);
+

        delwin(actual[0]);
        wrefresh(padre);
        curs_set(1);
        delwin(actual[0]);
        wrefresh(padre);
        curs_set(1);

-       free(indices);

 }
 
 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,10 +250,15 @@ 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) {
+               fprintf(stderr, "Error de malloc en salida\n");
+               return NULL;
+       }

        tmp = ptr;
        tmp1 = salida;
        pos_actualizada = 0;
        while (i<cant_header) {
        tmp = ptr;
        tmp1 = salida;
        pos_actualizada = 0;
        while (i<cant_header) {

+               fprintf(stderr, "voy a hacer el %d de %d\n", i, cant_header);

                /* Verifico la pos_actual para el resaltado, asi queda coherente 
                 * en el cambio de formato
                 */
                /* Verifico la pos_actual para el resaltado, asi queda coherente 
                 * en el cambio de formato
                 */


@@ -252,15 +267,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) = '.';


@@ -277,9 +294,17 @@ char *procesar_registro_articulo_tipo3(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *si
                i++;
        }
        free(ptr);
                i++;
        }
        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+1;
+       } else {
+               (*size) = (*size)-sizeof(EMUFS_REG_ID)-sizeof(unsigned int)+21;
+               (*ancho) = (*size);
+       }
+       memset(tmp1, '.', (*size)-(tmp1-salida)); 
+       salida[*size-1] = '\0';
+

        return salida;
 }
 
        return salida;
 }
 


@@ -293,6 +318,7 @@ char *procesar_registro_articulo_tipo1(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *si
        /* Cuento la cantidad de registros en este bloque */
        cant_header = 0;
        offset = 0;
        /* Cuento la cantidad de registros en este bloque */
        cant_header = 0;
        offset = 0;

+       fprintf(stderr, "Tam = %lu\n", *size);

        do {
                /* Me salto el ID, que no me interesa saber su valor */
                offset += sizeof(EMUFS_REG_ID);
        do {
                /* Me salto el ID, que no me interesa saber su valor */
                offset += sizeof(EMUFS_REG_ID);


@@ -308,10 +334,12 @@ char *procesar_registro_articulo_tipo1(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *si
                } else {
                        cant_header++;
                        offset += curr_size;
                } else {
                        cant_header++;
                        offset += curr_size;

+                       fprintf(stderr, "Sume %lu\n", curr_size);

                }
                }

-       } while (offset < (*size));
+       } while (offset+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_REG_ID) < (*size));

 
        /* Proceso */
 
        /* Proceso */

+       fprintf(stderr, "Cantidad de headers = %d\n", cant_header);

        salida = (char *)malloc((*size)-sizeof(unsigned int)*cant_header*3 + 3*cant_header*10+1);
        tmp = ptr;
        tmp1 = salida;
        salida = (char *)malloc((*size)-sizeof(unsigned int)*cant_header*3 + 3*cant_header*10+1);
        tmp = ptr;
        tmp1 = salida;


@@ -341,7 +369,9 @@ char *procesar_registro_articulo_tipo1(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *si
                sprintf(tmp1, "[%08d]", *((unsigned int *)tmp));
                tmp1 += 10;
                tmp += sizeof(unsigned int);
                sprintf(tmp1, "[%08d]", *((unsigned int *)tmp));
                tmp1 += 10;
                tmp += sizeof(unsigned int);

-               j = sizeof(unsigned int);;
+               j = sizeof(unsigned int);
+               PERR("Voy aca");
+               fprintf(stderr, "son %lu\n", curr_size);

                while (j < curr_size) {
                        if (*tmp == '\0') {
                                if (ant == (*tmp))
                while (j < curr_size) {
                        if (*tmp == '\0') {
                                if (ant == (*tmp))


@@ -356,11 +386,14 @@ char *procesar_registro_articulo_tipo1(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *si
                        tmp1++;
                        j++;
                }
                        tmp1++;
                        j++;
                }

+               PERR("Y hasta todo bien");

                i++;
        }
                i++;
        }

-       free(ptr);
-       (*tmp1) = '\0';
+       /* Tengo que trabajar sobre lo que me falte (seguro es espacio libre) */

        (*size) = (*size)-sizeof(unsigned int)*cant_header*3+3*cant_header*10+1;
        (*size) = (*size)-sizeof(unsigned int)*cant_header*3+3*cant_header*10+1;

+       memset(tmp1, '.', (*size)-(tmp1-salida)); 
+       free(ptr);
+       salida[*size-1] = '\0';

        
        return salida;
 }
        
        return salida;
 }