* Actualizo leer_registro_raw de tipo1

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

diff --git a/emufs_gui/viewer.c b/emufs_gui/viewer.c
index bcae4bd28c213208efecfb38072ec33054dc6ee8..5d325dabd357fcda9e847bfdea98ce7f18012c68 100644 (file)
--- a/emufs_gui/viewer.c
+++ b/emufs_gui/viewer.c
@@ -5,9 +5,11 @@
 #include "facturas.h"
 #include "gui.h"
 #include "common.h"
 #include "facturas.h"
 #include "gui.h"
 #include "common.h"

+#include <ctype.h>

 
 /* Se encarga de reemplazar los \0 un caracter visual, y segurar un \0 al final */
 static char *procesar_registro_articulo_tipo3(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho);
 
 /* Se encarga de reemplazar los \0 un caracter visual, y segurar un \0 al final */
 static char *procesar_registro_articulo_tipo3(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho);

+static char *procesar_registro_articulo_tipo2(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho);

 static char *procesar_registro_articulo_tipo1(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho);
 
 static char *procesar_registro_factura_tipo3(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho);
 static char *procesar_registro_articulo_tipo1(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho);
 
 static char *procesar_registro_factura_tipo3(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho);


@@ -15,6 +17,14 @@ static char *procesar_registro_factura_tipo1(EMUFS *emu, char *ptr, EMUFS_REG_SI
 
 static int preguntar_id(WINDOW *win, EMUFS *fp);
 
 
 static int preguntar_id(WINDOW *win, EMUFS *fp);
 

+void copy_char(char *dst, char *src)
+{
+       /* Todos los espacidores los pongo iguales */
+       if (isspace(*src)) *dst = ' ';
+       else if (iscntrl(*src)) *dst = '*';
+       else *dst = *src;
+}
+

 void mostrar_info(WINDOW *padre, int h, int offset_alto, int opt)
 {
        /* Info de teclas */
 void mostrar_info(WINDOW *padre, int h, int offset_alto, int opt)
 {
        /* Info de teclas */


@@ -72,9 +82,9 @@ char *juntar_memoria(char *s1, char *s2, char *s3, int size1, int size2, int siz
                        return NULL;
        }
 
                        return NULL;
        }
 

-       if (s1) memcpy(salida, s1, size1);
-       if (s2) memcpy(salida+size2, s2, size2);
-       if (s3) memcpy(salida+size2+size3, s3, size3);
+       if (s1) memcpy(salida, s1, size1); else size1 = 0;
+       if (s2) memcpy(salida+size1, s2, size2); else size2 = 0;
+       if (s3) memcpy(salida+size1+size2, s3, size3);

        if (s1) free(s1);
        if (s2) free(s2);
        if (s3) free(s3);
        if (s1) free(s1);
        if (s2) free(s2);
        if (s3) free(s3);


@@ -285,13 +295,19 @@ void ver_registros(WINDOW *padre, int w, int h, int cual)
        wattroff(padre, COLOR_PAIR(COLOR_BLUE));
        switch (fp->tipo) {
                case T1:
        wattroff(padre, COLOR_PAIR(COLOR_BLUE));
        switch (fp->tipo) {
                case T1:

-               case T2:

                        waddstr(padre, "Registro variable con bloque parametrizado.");
                        if (cual == 0)
                                procesar = procesar_registro_articulo_tipo1;
                        else
                                procesar = procesar_registro_factura_tipo1;
                break;
                        waddstr(padre, "Registro variable con bloque parametrizado.");
                        if (cual == 0)
                                procesar = procesar_registro_articulo_tipo1;
                        else
                                procesar = procesar_registro_factura_tipo1;
                break;

+               case T2:
+                       waddstr(padre, "Registro variable con sin bloques.");
+                       if (cual == 0)
+                               procesar = procesar_registro_articulo_tipo2;
+                       else
+                               procesar = procesar_registro_factura_tipo1;
+               break;

                case T3:
                        if (cual == 0)
                                procesar = procesar_registro_articulo_tipo3;
                case T3:
                        if (cual == 0)
                                procesar = procesar_registro_articulo_tipo3;


@@ -459,25 +475,19 @@ char *procesar_registro_articulo_tipo3(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *si
        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 */

-       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);
-       }
+       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);

 
 

-       /* El tamaño del nuevo array lo calculo asi :
-        *   
-        *   tamañoviejo - tamaño_headers_en_int - tamaño_ints_en_registro
-        *               + 10*(cant_headers+cant_registros) +1
-        *
-        *   En tipo3, la cantidad de headers y cant de registros es la misma
-        *   El 10 es por : (XXXXXXXX)
-        *   +1 == Por el \0
-        */
-       salida = (char *)malloc((*size)-sizeof(unsigned int)*cant_header*2 + 2*cant_header*10+1);
+       (*size) = (*size)-sizeof(EMUFS_REG_ID)*cant_header*2 + 2*cant_header*10+1;
+       (*ancho) = sizeof(t_Articulo)-sizeof(EMUFS_REG_ID)+10;
+       if ((*ancho) > (*size))
+               (*ancho) = (*size);
+       if ((tam_data) > ((*size)-sizeof(EMUFS_REG_ID))) {
+               tam_data = (*size) - sizeof(EMUFS_REG_ID);
+       }
+       salida = (char *)malloc(*size);
+       memset(salida, '.', *size);

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


@@ -496,10 +506,6 @@ char *procesar_registro_articulo_tipo3(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *si
                sprintf(tmp1, "(%08lu)", *((EMUFS_REG_ID *)tmp));
                tmp1 += 10;
                tmp += sizeof(EMUFS_REG_ID);
                sprintf(tmp1, "(%08lu)", *((EMUFS_REG_ID *)tmp));
                tmp1 += 10;
                tmp += sizeof(EMUFS_REG_ID);

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

                j = 0;
                while (j < (tam_data)) {
                        if (*tmp == '\0') {
                j = 0;
                while (j < (tam_data)) {
                        if (*tmp == '\0') {


@@ -508,7 +514,7 @@ char *procesar_registro_articulo_tipo3(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *si
                                else
                                        (*tmp1) = '|';
                        } else {
                                else
                                        (*tmp1) = '|';
                        } else {

-                               (*tmp1) = (*tmp);
+                               copy_char(tmp1, tmp);

                        }
                        ant = (*tmp);
                        tmp++;
                        }
                        ant = (*tmp);
                        tmp++;


@@ -519,15 +525,7 @@ char *procesar_registro_articulo_tipo3(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *si
        }
        free(ptr);
        
        }
        free(ptr);
        

-       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-2] = '\0';
+       salida[*size-1] = '\0';

 
        return salida;
 }
 
        return salida;
 }


@@ -542,6 +540,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;

+       PERR("Voy a contar la cantidad de headers");

        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);


@@ -550,6 +549,9 @@ char *procesar_registro_articulo_tipo1(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *si
                offset += sizeof(EMUFS_REG_SIZE);
 
                /* Desplazo el offset */
                offset += sizeof(EMUFS_REG_SIZE);
 
                /* Desplazo el offset */

+#ifdef DEBUG
+               fprintf(stderr, "Tamaño Registro = %lu\n", curr_size);
+#endif

                if (curr_size == 0) {
                        /* Si el tamaño de registro es 0, quiere decir que llegue a la
                         * parte que esta vacia */
                if (curr_size == 0) {
                        /* Si el tamaño de registro es 0, quiere decir que llegue a la
                         * parte que esta vacia */


@@ -561,7 +563,8 @@ char *procesar_registro_articulo_tipo1(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *si
        } while (offset+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_REG_ID) < (*size));
 
        /* Proceso */
        } while (offset+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_REG_ID) < (*size));
 
        /* Proceso */

-       salida = (char *)malloc((*size)-sizeof(unsigned int)*cant_header*3 + 3*cant_header*10+1);
+       salida = (char *)malloc((*size)-sizeof(unsigned int)*cant_header*2 + 2*cant_header*10+1);
+       memset(salida, '.',(*size)-sizeof(unsigned int)*cant_header*2 + 2*cant_header*10+1);

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


@@ -581,17 +584,13 @@ char *procesar_registro_articulo_tipo1(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *si
                sprintf(tmp1, "{%08lu}", *((EMUFS_REG_SIZE *)tmp));
                curr_size = *((EMUFS_REG_SIZE *)tmp);
                if (pos_actualizada == 1) {
                sprintf(tmp1, "{%08lu}", *((EMUFS_REG_SIZE *)tmp));
                curr_size = *((EMUFS_REG_SIZE *)tmp);
                if (pos_actualizada == 1) {

-                       (*ancho) = curr_size-sizeof(unsigned int)+30;
+                       (*ancho) = curr_size+20;

                        pos_actualizada = 2;
                }
                tmp1 += 10;
                tmp += sizeof(EMUFS_REG_SIZE);
                        pos_actualizada = 2;
                }
                tmp1 += 10;
                tmp += sizeof(EMUFS_REG_SIZE);

-               /* Pongo el campo numero del registro */
-               sprintf(tmp1, "[%08d]", *((unsigned int *)tmp));
-               tmp1 += 10;
-               tmp += sizeof(unsigned int);
-               j = sizeof(unsigned int);

                PERR("Voy aca");
                PERR("Voy aca");

+               j = 0;

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


@@ -599,7 +598,7 @@ char *procesar_registro_articulo_tipo1(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *si
                                else
                                        (*tmp1) = '|';
                        } else {
                                else
                                        (*tmp1) = '|';
                        } else {

-                               (*tmp1) = (*tmp);
+                               copy_char(tmp1, tmp);

                        }
                        ant = (*tmp);
                        tmp++;
                        }
                        ant = (*tmp);
                        tmp++;


@@ -610,10 +609,9 @@ char *procesar_registro_articulo_tipo1(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *si
                i++;
        }
        /* Tengo que trabajar sobre lo que me falte (seguro es espacio libre) */
                i++;
        }
        /* 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;
-       memset(tmp1, '.', (*size)-(tmp1-salida)); 
+       (*size) = (*size)-sizeof(unsigned int)*cant_header*2+2*cant_header*10+1;

        free(ptr);
        free(ptr);

-       salida[*size-2] = '\0';
+       salida[*size-1] = '\0';

        
        return salida;
 }
        
        return salida;
 }


@@ -925,3 +923,56 @@ char *procesar_registro_factura_tipo1(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *siz
        return salida;
 }
 
        return salida;
 }
 

+char *procesar_registro_articulo_tipo2(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho)
+{
+       char *salida, *tmp;
+       char *in;
+       int i;
+       EMUFS_REG_SIZE tam_data;
+       if (ptr == NULL) return NULL;
+
+       (*size) = *size - sizeof(EMUFS_REG_SIZE) - sizeof(EMUFS_REG_ID) + 21;
+       (*ancho) = *size-101;
+       salida = (char *)malloc(*size);
+       memset(salida, '.', *size);
+
+       PERR("Voy por el espacio antes");
+       for(i=0; i < *pos_actual; i++) {
+               /* Los datos que tengo por ahora los pongo enmascarados! */
+               copy_char(&salida[i], in);
+               in++;
+       }
+       tmp = salida + *pos_actual;
+       in = ptr + *pos_actual;
+
+       PERR("Voy por el header");
+       /* ID de registro */
+       sprintf(tmp, "(%08lu)", *((EMUFS_REG_ID *)in));
+       tmp += 10;
+       in += sizeof(EMUFS_REG_ID);
+       /* Tamaño de registro */
+       sprintf(tmp, "{%08lu}", *((EMUFS_REG_SIZE *)in));
+       tam_data = *((EMUFS_REG_SIZE *)in);
+       tmp += 10;
+       in += sizeof(EMUFS_REG_SIZE);
+       PERR("Voy por la data");
+       i = 0;
+       while (i < tam_data) {
+               copy_char(tmp, in);
+               tmp++;
+               in++;
+               i++;
+       }
+       PERR("Voy por el espacio despues");
+       for(i=0; i < 100-*pos_actual; i++) {
+               copy_char(tmp, in);
+               tmp++;
+               in++;
+       }
+
+       free(ptr);
+       PERR("LISTO");
+       salida[*size-1] = '\0';
+       return salida;
+}
+