* Limpio el codigo de tipo3

 * borrar_registro esta muerta por ahora, despues la completo.
 * Cosas raras en la GUI, al ejecutar me tira un excepcion de punto flotante!!

diff --git a/emufs/fsc.c b/emufs/fsc.c
index 0a5ba229cbfaefbc4f5726524d188c72f52130e9..692d6d1799d8a29d86846d2adff2008193894b0c 100644 (file)
--- a/emufs/fsc.c
+++ b/emufs/fsc.c
@@ -101,9 +101,9 @@ int emufs_fsc_buscar_lugar(EMUFS *emu, unsigned long tam, int *fs)
        *fs = emu->tam_bloque;
        while( !feof(f_fsc) ){
                if (fread(&reg,sizeof(EMUFS_FSC),1,f_fsc) != 1) continue;
-               if ( reg.free_space >= tam+sizeof(int)) 
+               if (reg.free_space >= tam) {
                        break;
-               else {
+               } else {
                        reg.block = -1;
                        *fs = emu->tam_bloque;
                }
@@ -135,3 +135,4 @@ int emufs_fsc_get_fs(EMUFS *emu, int num_bloque)
        fclose(f_fsc);
        return reg.free_space;
 }
+

diff --git a/emufs/idx.c b/emufs/idx.c
index be142f79a50a963bb68235618a4ce00220ef861e..cfb798ea5c9b456bf43831be5e36eff3184a5956 100644 (file)
--- a/emufs/idx.c
+++ b/emufs/idx.c
@@ -90,16 +90,17 @@ int emufs_idx_buscar_registro(EMUFS *emu, int ID)
        strcat(name_f_idx, EMUFS_IDX_EXT);
        
        if ( (f_idx = fopen(name_f_idx,"r")) == NULL) return -1; /*ERROR*/
+       reg.id_reg = -1;
+       reg.block = -1;
        while ( !feof(f_idx) ){
                if (fread(&reg,sizeof(EMUFS_IDX),1,f_idx) != 1) continue;
                if ( reg.id_reg == ID ){
-                       fclose(f_idx);
-                       return reg.block;
+                       break;
                }
        }
        
        fclose(f_idx);
-       return -1; /*no existe el registro*/
+       return reg.block;
 }
 
 /* agrega un registro al final del archivo */
@@ -112,7 +113,7 @@ int emufs_idx_agregar(EMUFS *emu, int num_bloque, int ID_aux)
        strcpy(name_f_idx,emu->nombre);
        strcat(name_f_idx, EMUFS_IDX_EXT);
 
-       if ( (f_idx = fopen(name_f_idx,"ab+"))==NULL ) return -1;
+       if ( (f_idx = fopen(name_f_idx,"a+"))==NULL ) return -1;
                
        reg.block = num_bloque;
        reg.id_reg = ID_aux;
@@ -120,3 +121,4 @@ int emufs_idx_agregar(EMUFS *emu, int num_bloque, int ID_aux)
        fclose(f_idx);
        return 0;
 }
+

diff --git a/emufs/tipo3.c b/emufs/tipo3.c
index ac3e7eea20538ac312e6591891538d53e669cfe3..e7582262a3139168744138ce169471207462ea15 100644 (file)
--- a/emufs/tipo3.c
+++ b/emufs/tipo3.c
@@ -40,19 +40,10 @@
 /** Leo un registro del archivo, devuelve cero si no lo encuentra.**/
 int emufs_tipo3_leer_registro(EMUFS *emu, int ID, void *ptr, unsigned long tam_reg)
 {
-       FILE* f_block_reg;
        char* bloque;
-       char name_f_block_reg[255];
        int block, ID_aux;
        int iterador = 0;
-       strcpy(name_f_block_reg,emu->nombre);
-       strcat(name_f_block_reg,".idx");
-
-
-       if ( (f_block_reg = fopen(name_f_block_reg,"a+")) == NULL )
-               return -1; /*ERROR*/
        
-
        /*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*/
        bloque = (char*)malloc(emu->tam_bloque);
@@ -79,7 +70,6 @@ int emufs_tipo3_leer_registro(EMUFS *emu, int ID, void *ptr, unsigned long tam_r
                iterador += tam_reg;
        }
        
-       fclose(f_block_reg);
        free(bloque);
        return 0;
 }
@@ -113,12 +103,11 @@ int emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, unsigned long tam)
        strcpy(name_f,emu->nombre);
        strcat(name_f,".dat");
        
-       if ( (file = fopen(name_f,"a+"))==NULL ) return -1; /*ERROR*/
        /* me devuelve el ID del bloque donde quepa un registro y el espacio libre en "fs"*/
        num_bloque = emufs_fsc_buscar_lugar(emu, tam, &fs);
-       printf("Lugar = %d   bloque = %d\n", fs, num_bloque);
        /*si no hay bloques con suficiente espacio creo un bloque nuevo */
        if (num_bloque == -1) {
+               if ( (file = fopen(name_f,"a+"))==NULL ) return -1; /*ERROR*/
                /*crear un nuevo bloque en memoria */
                bloque = (char*)malloc(emu->tam_bloque);
                /* grabar el registro al principio del bloque */
@@ -129,7 +118,7 @@ int emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, unsigned long tam)
                /*grabo el registro en el bloque*/
                memcpy(bloque+sizeof(int),ptr,tam);
                /* 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*/
@@ -147,7 +136,7 @@ int emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, unsigned long tam)
                }
        } else {
                /*cargo el bloque en "bloque"*/
-               bloque = (char*)malloc(emu->tam_bloque);        
+               bloque = (char*)malloc(emu->tam_bloque);
                if ( emufs_tipo3_leer_bloque(emu,num_bloque,bloque)== -1) {
                        printf("Error: no se pudo leer bloque\n");
                        return -1; 
@@ -202,8 +191,9 @@ int emufs_tipo3_grabar_bloque(EMUFS *emu, void *ptr, int num)
        strcat(name_f,".dat");
        
        if ( (file = fopen(name_f,"r+"))==NULL ) return -1; /*ERROR*/
-       fseek(file,sizeof(char)+sizeof(int)*2,SEEK_SET);
-       fseek(file,num*emu->tam_bloque,SEEK_CUR);       
+       /* Salto el header del archivo */
+       fseek(file, sizeof(char)+sizeof(int)*2, SEEK_SET);
+       fseek(file, num*emu->tam_bloque, SEEK_CUR);     
        fwrite(ptr, emu->tam_bloque, 1, file);
        
        fclose(file);
@@ -213,20 +203,12 @@ int emufs_tipo3_grabar_bloque(EMUFS *emu, void *ptr, int num)
 /*borra un registro de un bloque y acomoda los registros que quedan*/
 int emufs_tipo3_borrar_registro(EMUFS *emu, int ID, int tam_reg)
 {
-       int num_bloque, ptr_elim, ptr_mov, ID_aux, cant, i, fs;
-       long size;
+       int num_bloque, ptr_elim, ptr_mov, ID_aux, fs;
        char *bloque;
-       FILE *f_block_reg;
-       BLOCK_REG_T reg_b;
-       BLOCK_REG_T buffer[10];
-       char name_f_block_reg[255];
-       
-       strcpy(name_f_block_reg,emu->nombre);
-       strcat(name_f_block_reg,".idx");
 
        num_bloque = emufs_idx_buscar_registro(emu, ID);
        bloque = (char*)malloc(emu->tam_bloque);
-       if ( emufs_tipo3_leer_bloque(emu,num_bloque, bloque) == -1 ){
+       if ( emufs_tipo3_leer_bloque(emu,num_bloque, bloque) == -1 ) {
                printf("No se encontro el bloque\n");
                return -1;
        }
@@ -264,51 +246,18 @@ int emufs_tipo3_borrar_registro(EMUFS *emu, int ID, int tam_reg)
                
        /*actualizo archivo .idx*/
        /*busco el registro que tengo que eliminar*/
-       if ( (f_block_reg = fopen(name_f_block_reg,"r+")) == NULL ) return -1;
+       /* GAZER VER */
+/*     if ( (f_block_reg = fopen(name_f_block_reg,"r+")) == NULL ) return -1;
        while ( !feof(f_block_reg) ){
                if ( fread(&reg_b,sizeof(BLOCK_REG_T),1,f_block_reg) != 1 ) continue;
                if ( reg_b.id_reg == ID )
                        break;
-       }
-       fseek(f_block_reg, -sizeof(BLOCK_REG_T), SEEK_CUR);
+       }*/
+/*     fseek(f_block_reg, -sizeof(BLOCK_REG_T), SEEK_CUR);*/
        /* Estoy parado sobre el punto id/registro que debo borrar */
-       printf("registro borrado= %ld   en bloque = %d\n",reg_b.id_reg,reg_b.block);
        /*justifico en archivo a la izquieda*/
 
-       /* GAZER : aca hago una prueba */
-       {
-               long final, actual;
-               actual = ftell(f_block_reg); /* Guardo la posicion actual */
-               fseek(f_block_reg, 0, SEEK_END); /* me voy al final */
-               final = ftell(f_block_reg); /* veo cuando ocupa el archivo */
-               fseek(f_block_reg, actual, SEEK_SET); /* vuelvo al lugar desde donde quiero justificar */
-
-               cant = (final-actual)/sizeof(BLOCK_REG_T);
-               for(i=0; i<cant; i++) {
-                       /* Calculo donde empieza el proximo elemento a mover */
-                       final = actual+sizeof(BLOCK_REG_T);
-                       /* Me paro en ese lugar */
-                       fseek(f_block_reg, final, SEEK_SET);
-                       /* y lo leo */
-                       fread(buffer, sizeof(BLOCK_REG_T), 1, f_block_reg);
-
-                       /* Ahora me paro en la nueva posicion de este item */
-                       fseek(f_block_reg, actual, SEEK_SET);
-                       /* y lo guardo */
-                       fwrite(buffer, sizeof(BLOCK_REG_T), 1, f_block_reg);
-
-                       /* Ahora el proximo item va en la posicion siguiente */
-                       actual += sizeof(BLOCK_REG_T);
-               }
-
-       }
-       /*trunco el ultimo registro del archiv*/
-       fseek(f_block_reg,0,SEEK_END);
-  size = ftell(f_block_reg);
-  fclose(f_block_reg);
-       truncate(name_f_block_reg,size - sizeof(BLOCK_REG_T));
-
        free(bloque);
 
-return 0;
+       return 0;
 }

diff --git a/emufs/tipo3_main.c b/emufs/tipo3_main.c
index cdd7139822ee6813f74a412ab379832cf94f9db6..c5e1883890126a290aa260cd631ac0a88c3bd664 100644 (file)
--- a/emufs/tipo3_main.c
+++ b/emufs/tipo3_main.c
@@ -88,10 +88,11 @@ int main(int argc, char *argv[])
        printf("ID6 = %d\n", n7);
 
 
-       fp->borrar_registro(fp, n4, 100);
+       /*fp->borrar_registro(fp, n4, 100);
        fp->borrar_registro(fp, n2, 100);
-       fp->borrar_registro(fp, n6, 100);
+       fp->borrar_registro(fp, n6, 100);*/
        n8 = fp->grabar_registro(fp, i, 100);
+       printf("Grabe Ok\n");
        fp->leer_registro(fp, n8, b, 100);
 
        printf("Recuperado : %s\n", b);

diff --git a/emufs_gui/articulos.c b/emufs_gui/articulos.c
index 2751be37fe93b2e697cd26264da6bb0fc785057f..6226225faf7096701c2055f91bc9112b0894f81f 100644 (file)
--- a/emufs_gui/articulos.c
+++ b/emufs_gui/articulos.c
@@ -10,14 +10,10 @@ t_LstArticulos *art_cargar(const char *filename)
        xmlDocPtr document;
        xmlNode *node, *inicio;
        int cant;
-       t_Articulo art;
 
-       t_LstArticulos *tmp = (t_LstArticulos *)malloc(sizeof(t_LstArticulos));
-       if (tmp == NULL) return NULL;
 
        document = xmlReadFile(filename, "ISO-8859-1",0);
        if (document == NULL) {
-               free(tmp);
                return NULL;
        }
 
@@ -43,10 +39,13 @@ t_LstArticulos *art_cargar(const char *filename)
                        }
                }       
        }
+       t_LstArticulos *tmp = (t_LstArticulos *)malloc(sizeof(t_LstArticulos));
+       if (tmp == NULL) return NULL;
        tmp->cant = cant;
        tmp->array = (t_Reg_Articulo *)malloc(sizeof(t_Reg_Articulo)*cant);
 
        if (tmp->array == NULL) {
+               printf("Fallo malloc\n");
                xmlFreeDoc(document);
                xmlCleanupParser();
                free(tmp);
@@ -56,25 +55,27 @@ t_LstArticulos *art_cargar(const char *filename)
        /* leo los datos y los guardo en el archivo*/
        cant = 0;
        /* FIXME : por ahora hago que entren 2 bloques y me sobre algo de espacio*/
-       tmp->fp = emufs_crear("articulos", T3, sizeof(t_Articulo)*2+50, sizeof(t_Articulo)); 
+       tmp->fp = emufs_crear("articulos", T3, sizeof(t_Articulo)*2, sizeof(t_Articulo)); 
        for (node=inicio ; node ; node = node->next) {
                if (node->type == XML_ELEMENT_NODE) {
                        if (strcmp(node->name, "ARTICULO") == 0) {
-                               art.numero = atoi(xmlGetProp(node, "NroArtículo"));
-                               strncpy(art.desc, xmlGetProp(node, "Descripción"), 50);
+                               t_Articulo art;
+       /*                      art.numero = atoi(xmlGetProp(node, "NroArtículo"));*/
+       /*                      strncpy(art.desc, xmlGetProp(node, "Descripción"), 50);
                                strncpy(art.presentacion, xmlGetProp(node, "Presentación"), 30);
-                               strncpy(art.existencia, xmlGetProp(node, "Existencia"), 8);
-//                     /       strncpy(tmp->array[cant].ubicacion, xmlGetProp(node, "Ubicacion"), 30);
+                               strncpy(art.existencia, xmlGetProp(node, "Existencia"), 8);*/
+                       /*      strncpy(tmp->array[cant].ubicacion, xmlGetProp(node, "Ubicacion"), 30);*/
                                strncpy(art.pvu, xmlGetProp(node, "PVU"), 8);
-                               strncpy(art.emin, xmlGetProp(node, "Emín"), 8);
+       /*                      strncpy(art.emin, xmlGetProp(node, "Emín"), 8); */
 
                                /* Ya leido el articulo ahora paso a guardarlo en el archivo y agregarlo a la lista */
-                               tmp->array[cant].numero = art.numero;
                                tmp->array[cant].num_reg = tmp->fp->grabar_registro(tmp->fp, &art, sizeof(t_Articulo)); /* REGISTRO CTE! */ 
+                               tmp->array[cant].numero = art.numero;
                                ++cant;
                        }
                }
        }
+       printf("1\n");
        xmlFreeDoc(document);
        xmlCleanupParser();
 
@@ -99,7 +100,7 @@ int art_liberar(t_LstArticulos *l)
 t_Articulo *art_obtener(t_LstArticulos *lst, const char *numero)
 {
        /* FIXME : NO ME GUSTA :-/ */
-       static t_Articulo art;
+       t_Articulo *art;
        int i;
        int n = atoi(numero);
 
@@ -107,9 +108,10 @@ t_Articulo *art_obtener(t_LstArticulos *lst, const char *numero)
 
        for(i=0; i<lst->cant; i++) {
                if (n == lst->array[i].numero) {
+                       art = (t_Articulo *)malloc(sizeof(t_Articulo));
                        /* Ya se cual tengo que retornar. Ahora veo si lo cargo desde el archivo */
-                       lst->fp->leer_registro(lst->fp, lst->array[i].num_reg, &art, sizeof(t_Articulo));
-                       return &art;
+                       lst->fp->leer_registro(lst->fp, lst->array[i].num_reg, art, sizeof(t_Articulo));
+                       return art;
                }
        }
 
@@ -157,6 +159,7 @@ void art_modificar(char *s)
                /* TODO : Actualizar registro */
                
                form_destruir(form);
+               free(articulo);
        }       
 
        werase(win);

diff --git a/emufs_gui/articulos.h b/emufs_gui/articulos.h
index 5ac8ce074b141f8d5e4493629d18886d327d848a..2ea23ca1cacad9743a47822e5a2dfedbe2223878 100644 (file)
--- a/emufs_gui/articulos.h
+++ b/emufs_gui/articulos.h
@@ -6,7 +6,6 @@
 #include <libxml/parser.h>
 #include <libxml/tree.h>
 #include <string.h>
-#include "malloc_debug.h"
 #include "form.h"
 #include "emufs.h"
 

diff --git a/emufs_gui/form.h b/emufs_gui/form.h
index 8316e8556a11cae3c426f224503d68088c99f38c..be9da37d922448f5b50b52dab97841486d790880 100644 (file)
--- a/emufs_gui/form.h
+++ b/emufs_gui/form.h
@@ -7,8 +7,6 @@
 #include <stdlib.h>
 #include <curses.h>
 
-#include "malloc_debug.h"
-
 /** Tipos de Widgets válidos */
 typedef enum {INPUT, RADIO} t_Campo;
 

diff --git a/emufs_gui/gui.c b/emufs_gui/gui.c
index 22475cd10229e3a725d3fca397b3ed8d780ba77e..3727e40e995d68bc7c9c0be3cf51942b492079fb 100644 (file)
--- a/emufs_gui/gui.c
+++ b/emufs_gui/gui.c
@@ -25,6 +25,11 @@ int main(int argc, char *argv[])
                return 1;
        }
 
+       art_cargar(argv[1]);
+
+       art_liberar(NULL);
+       return 1;
+       
        /* Inicio Curses */
        signal(SIGINT, finish);
        initscr();
@@ -84,8 +89,6 @@ int main(int argc, char *argv[])
 
        art_liberar(NULL);
 
-
-       MD_Listar();
        return 0;
 }