From 35c84de4b6d96cf3505ad2c075ff3998be04441b Mon Sep 17 00:00:00 2001 From: Ricardo Markiewicz Date: Thu, 13 May 2004 18:15:18 +0000 Subject: [PATCH] * Empieza el baile de usar indices desde la gui --- emufs/emufs.c | 5 ++- emufs/emufs.h | 2 +- emufs/indice_b.c | 7 +++++ emufs/indice_b.h | 1 + emufs/indices.c | 16 +++++----- emufs/indices.h | 4 +++ emufs/tipo1.c | 5 ++- emufs/tipo1.h | 2 +- emufs/tipo1_main.c | 5 +-- emufs/tipo2.c | 3 +- emufs/tipo2.h | 2 +- emufs/tipo2_main.c | 2 +- emufs/tipo3.c | 32 ++++++++++++++----- emufs/tipo3.h | 2 +- emufs/tipo3_main.c | 2 ++ emufs_gui/articulos.c | 72 +++++++++++++++++++++---------------------- emufs_gui/articulos.h | 2 ++ emufs_gui/facturas.c | 50 +++++++++++++++--------------- 18 files changed, 125 insertions(+), 89 deletions(-) diff --git a/emufs/emufs.c b/emufs/emufs.c index ad14955..76260ac 100644 --- a/emufs/emufs.c +++ b/emufs/emufs.c @@ -349,6 +349,7 @@ int emufs_agregar_indice(EMUFS *emu, char *nombre, INDICE_FUNCION funcion, INDIC /* Verifico que no existe un indice con el mismo nombre */ /* y que no exista un indice primario */ + PERR("Agregando indice"); tmp = emu->indices; while (tmp) { if (strcmp(tmp->nombre, nombre)==0) { @@ -368,14 +369,12 @@ int emufs_agregar_indice(EMUFS *emu, char *nombre, INDICE_FUNCION funcion, INDIC break; case 2: PERR("EMUFS ya tiene indice primario!!"); - break; - default: - PERR("Error no esperado!!"); } return 0; } /* Creo el nuevo indice */ + PERR("Creando indice\n"); tmp = emufs_indice_crear(emu, nombre, funcion, tipo, tipo_dato, offset, tam_bloque); if (tmp == NULL) return 0; diff --git a/emufs/emufs.h b/emufs/emufs.h index a44548c..790fdea 100644 --- a/emufs/emufs.h +++ b/emufs/emufs.h @@ -114,7 +114,7 @@ struct _emu_fs_t { EMUFS_REG_SIZE tam_reg; /**< Tamaño de registro. 0 Si son registros variables */ void* (*leer_bloque)(struct _emu_fs_t*, EMUFS_BLOCK_ID, int*); /**< Método para leer un bloque */ void (*leer_bloque_raw)(struct _emu_fs_t*, EMUFS_BLOCK_ID, char **, char **, char **, EMUFS_BLOCK_SIZE *, EMUFS_BLOCK_SIZE *, EMUFS_BLOCK_SIZE *); /**< Método para leer un bloque, el anterior y el siguiente */ - void* (*leer_registro)(struct _emu_fs_t*, EMUFS_REG_ID, EMUFS_REG_SIZE*, int*); /**< Método para leer un registro */ + void* (*leer_registro)(struct _emu_fs_t*, CLAVE, EMUFS_REG_SIZE*, int*); /**< Método para leer un registro */ void* (*leer_registro_raw)(struct _emu_fs_t*, EMUFS_REG_ID, EMUFS_REG_SIZE*, int *); /**< Método para leer un registro con todo su bloque asociado */ EMUFS_REG_ID (*grabar_registro)(struct _emu_fs_t*, void*, EMUFS_REG_SIZE, int*); /**< Método para grabar un registro */ EMUFS_REG_ID (*modificar_registro)(struct _emu_fs_t*, EMUFS_REG_ID, void*, EMUFS_REG_SIZE, int*); /**< Método para modificar un registro */ diff --git a/emufs/indice_b.c b/emufs/indice_b.c index abbdfbc..2e0ff5d 100644 --- a/emufs/indice_b.c +++ b/emufs/indice_b.c @@ -1,5 +1,6 @@ #include "indice_b.h" +#include "common.h" /* Cantidad de claves por nodo */ #define CANT_HIJOS(x) ((x->tam_bloque-sizeof(B_NodoHeader))/sizeof(B_NodoEntry)) @@ -29,6 +30,12 @@ void emufs_indice_b_crear(INDICE *idx) header.hijo_izquierdo = -1; fp = fopen(idx->filename, "w"); + PERR("Creando indice"); + fprintf(stderr, "Archivo = (%s)\n", idx->filename); + if (fp == NULL) { + PERR("Error al crear el archivo"); + return; + } /* Creo el archivo con el Nodo raiz */ bloque = (char *)malloc(idx->tam_bloque); diff --git a/emufs/indice_b.h b/emufs/indice_b.h index 6101afc..4385c61 100644 --- a/emufs/indice_b.h +++ b/emufs/indice_b.h @@ -6,6 +6,7 @@ #include #include +#include "common.h" #include "indices.h" typedef struct _b_nodo_header_ { diff --git a/emufs/indices.c b/emufs/indices.c index 4b97972..a4c07ec 100644 --- a/emufs/indices.c +++ b/emufs/indices.c @@ -2,9 +2,7 @@ #include "indices.h" #include "emufs.h" #include "indice_b.h" - -static CLAVE obtenet_clave(INDICE *idx, char *data); -static CLAVE obtenet_clave_desde_valor(INDICE *idx, char *data); +#include "common.h" INDICE *emufs_indice_crear(EMUFS *emu, char *nombre, INDICE_FUNCION funcion, INDICE_TIPO tipo, INDICE_TIPO_DATO tipo_dato, unsigned int offset, unsigned int tam_bloque) { @@ -34,6 +32,7 @@ INDICE *emufs_indice_crear(EMUFS *emu, char *nombre, INDICE_FUNCION funcion, IND switch (tipo) { case IND_B: + PERR("Creando indice con Arbol B"); emufs_indice_b_crear(tmp); tmp->agregar_entrada = emufs_indice_b_insertar; tmp->borrar_entrada = NULL; @@ -60,19 +59,20 @@ void emufs_indice_destruir(EMUFS *emu, INDICE *i) void emufs_indice_agregar(INDICE *primero, char *data, INDICE_DATO dato) { INDICE *iter = primero; - + + PERR("Agregando clave a indices"); while (iter) { - iter->agregar_entrada(iter, obtenet_clave(iter, data), dato); + iter->agregar_entrada(iter, emufs_indice_generar_clave(iter, data), dato); iter = iter->sig; } } INDICE_DATO emufs_indice_buscar(INDICE *primero, char *data) { - return primero->existe_entrada(primero, obtenet_clave_desde_valor(primero, data)); + return primero->existe_entrada(primero, emufs_indice_generar_clave_desde_valor(primero, data)); } -static CLAVE obtenet_clave_desde_valor(INDICE *idx, char *data) +CLAVE emufs_indice_generar_clave_desde_valor(INDICE *idx, char *data) { CLAVE k; switch (idx->tipo_dato) { @@ -86,7 +86,7 @@ static CLAVE obtenet_clave_desde_valor(INDICE *idx, char *data) return k; } -static CLAVE obtenet_clave(INDICE *idx, char *data) +CLAVE emufs_indice_generar_clave(INDICE *idx, char *data) { CLAVE k; switch (idx->tipo_dato) { diff --git a/emufs/indices.h b/emufs/indices.h index 7123f63..53c4c28 100644 --- a/emufs/indices.h +++ b/emufs/indices.h @@ -5,6 +5,8 @@ #include #include +#include "common.h" + #define STRUCT_OFFSET(x, y) ((int)(&(x->y))-(int)(x)) typedef struct _emu_fs_t EMUFS; @@ -92,6 +94,8 @@ void emufs_indice_agregar(INDICE *primero, char *data, INDICE_DATO dato); INDICE_DATO emufs_indice_buscar(INDICE *primero, char *data); +CLAVE emufs_indice_generar_clave(INDICE *idx, char *data); +CLAVE emufs_indice_generar_clave_desde_valor(INDICE *idx, char *data); /** Compara 2 claves de la forma c1 < c2 */ int emufs_indice_es_menor(INDICE *idx, CLAVE c1, CLAVE c2); diff --git a/emufs/tipo1.c b/emufs/tipo1.c index a442e8d..55c9841 100644 --- a/emufs/tipo1.c +++ b/emufs/tipo1.c @@ -99,13 +99,14 @@ int emufs_tipo1_inicializar(EMUFS* efs) return EMUFS_OK; } -void* emufs_tipo1_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id, +void* emufs_tipo1_leer_registro(EMUFS* efs, CLAVE clave, EMUFS_REG_SIZE* reg_size, int *err) { char* block; /* bloque leido (en donde está el registro a leer) */ char* registro; /* registro a leer */ EMUFS_BLOCK_ID block_id; /* id del bloque en donde esta el registro a leer */ EMUFS_BLOCK_SIZE offset; /* offset del bloque leído */ + EMUFS_REG_ID reg_id; EMUFS_TIPO1_REG_HEADER curr_reg_header; /* cabecera del registro a leer */ block_id = emufs_idx_buscar_registro(efs, reg_id); @@ -517,6 +518,7 @@ EMUFS_Estadisticas emufs_tipo1_leer_estadisticas(EMUFS* efs) void emufs_tipo1_compactar(EMUFS* efs) { +#ifdef ARREGLAR EMUFS_BLOCK_SIZE block_space /* tamaño para datos de un bloque */ = efs->tam_bloque - sizeof(EMUFS_TIPO1_REG_HEADER); EMUFS_REG_ID total_ids; /* cantidad total de registros en el array */ @@ -580,6 +582,7 @@ void emufs_tipo1_compactar(EMUFS* efs) emufs_fsc_truncate(efs, block_id); } } +#endif } EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque_fsc(EMUFS *efs, void *block, diff --git a/emufs/tipo1.h b/emufs/tipo1.h index 946d36e..a3c667f 100644 --- a/emufs/tipo1.h +++ b/emufs/tipo1.h @@ -48,7 +48,7 @@ int emufs_tipo1_inicializar(EMUFS* efs); /** Lee el registro \c reg_id y devolviendo su contenido. */ -void* emufs_tipo1_leer_registro(EMUFS*, EMUFS_REG_ID, EMUFS_REG_SIZE*, int*); +void* emufs_tipo1_leer_registro(EMUFS*, CLAVE, EMUFS_REG_SIZE*, int*); /** Graba un registro en el archivo. */ EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS*, void*, EMUFS_REG_SIZE, int*); diff --git a/emufs/tipo1_main.c b/emufs/tipo1_main.c index 15ac482..ebeb376 100644 --- a/emufs/tipo1_main.c +++ b/emufs/tipo1_main.c @@ -35,6 +35,7 @@ #include "emufs.h" int main(int argc, char* argv[]) { +#ifdef LA_PALOMA_MENSAJERA EMUFS* efs; char reg1[] = "Hola mundo"; char reg2[] = "Adiós mundo cruel"; @@ -191,6 +192,6 @@ int main(int argc, char* argv[]) { out: emufs_destruir(efs); - return err; - +#endif + return 0; /*err;*/ } diff --git a/emufs/tipo2.c b/emufs/tipo2.c index b2724e9..460d2e2 100644 --- a/emufs/tipo2.c +++ b/emufs/tipo2.c @@ -62,12 +62,13 @@ int emufs_tipo2_inicializar(EMUFS* efs) } /* Lee y devuelve un registro de un archivo del Tipo 2. */ -void *emufs_tipo2_leer_registro(EMUFS* efs, EMUFS_REG_ID id_reg, EMUFS_REG_SIZE* reg_size, int *err) +void *emufs_tipo2_leer_registro(EMUFS* efs, CLAVE clave, EMUFS_REG_SIZE* reg_size, int *err) { FILE* f_data; char *registro; /* registro a leer */ char name_f[255]; EMUFS_OFFSET reg_offset; /* offset donde se encuentra el registro */ + EMUFS_REG_ID id_reg; strcpy(name_f,efs->nombre); strcat(name_f,".dat"); diff --git a/emufs/tipo2.h b/emufs/tipo2.h index aad598b..c80ef3b 100644 --- a/emufs/tipo2.h +++ b/emufs/tipo2.h @@ -78,7 +78,7 @@ int emufs_tipo2_inicializar(EMUFS* efs); * \param err Indicador de error en la operacion. * \return \b void* Buffer con el registro leido. */ -void *emufs_tipo2_leer_registro(EMUFS* efs, EMUFS_REG_ID id_reg, EMUFS_REG_SIZE* reg_size, int *err); +void *emufs_tipo2_leer_registro(EMUFS* efs, CLAVE clave, EMUFS_REG_SIZE* reg_size, int *err); /** Realiza la escritura de un registro en archivos del tipo 2 en base a su \em ID, devolviendo ademas el \em Size del * registro leido. diff --git a/emufs/tipo2_main.c b/emufs/tipo2_main.c index 9fe6dbe..f7157dc 100644 --- a/emufs/tipo2_main.c +++ b/emufs/tipo2_main.c @@ -100,7 +100,7 @@ int main(int argc, char *argv[]) n9 = efs->grabar_registro(efs, d, 8, &err); /* Levanto un registro */ - registro = efs->leer_registro(efs,n1,®_size,&err); + /*registro = efs->leer_registro(efs,n1,®_size,&err);*/ if (err == 0) { printf("tipo2_main.c >>Registro: %lu Size: %lu Content: %s\n\n",n2,reg_size,registro); } diff --git a/emufs/tipo3.c b/emufs/tipo3.c index c9bddec..ca850a0 100644 --- a/emufs/tipo3.c +++ b/emufs/tipo3.c @@ -42,23 +42,31 @@ #include #include -/** Leo un registro del archivo, devuelve cero si no lo encuentra.**/ -void* emufs_tipo3_leer_registro(EMUFS *emu, EMUFS_REG_ID ID, +/** Leo un registro del archivo, devuelve NULL si no lo encuentra.**/ +void* emufs_tipo3_leer_registro(EMUFS *emu, CLAVE clave, EMUFS_REG_SIZE* reg_size, int* err) { + INDICE_DATO dato; char* bloque; char* registro; /* registro a leer */ EMUFS_BLOCK_ID block; - EMUFS_REG_ID ID_aux; + EMUFS_REG_ID ID_aux, ID; EMUFS_BLOCK_SIZE iterador = 0; int cant_bloques = 0, resto, i, copiado=0; - + cant_bloques = (emu->tam_reg / (emu->tam_bloque-sizeof(EMUFS_REG_ID))) + 1; if ( emu->tam_reg+sizeof(EMUFS_REG_ID) == emu->tam_bloque ) cant_bloques = 1; /*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 (emu->indices != NULL) { + /* TODO : Verificar donde esta el indice primario */ + dato = emu->indices->existe_entrada(emu->indices, clave); + block = dato.bloque; + ID = dato.id; + } else { + 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"); *err = -1; @@ -149,6 +157,7 @@ void* emufs_tipo3_leer_bloque(EMUFS *emu, EMUFS_BLOCK_ID ID, int* err) EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE tam, int* err) { + INDICE_DATO idx_data; EMUFS_REG_ID ID_aux; EMUFS_FREE fs, new_fs; EMUFS_BLOCK_ID num_bloque; @@ -156,7 +165,7 @@ EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE t FILE *file; char name_f[255]; char* bloque = NULL; - int cant_bloques, resto, i=0, lugar; + int cant_bloques, resto, i=0; strcpy(name_f,emu->nombre); strcat(name_f,".dat"); @@ -213,6 +222,9 @@ EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE t free(bloque); return -1; } + idx_data.id = ID_aux; + idx_data.bloque = num_bloque; + emufs_indice_agregar(emu->indices, ptr, idx_data); } /* grabo el nuevo registro en el archivo de espacios libres */ @@ -289,6 +301,9 @@ EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE t if (bloque) free(bloque); return -1; } + idx_data.id = ID_aux; + idx_data.bloque = num_bloque; + emufs_indice_agregar(emu->indices, ptr, idx_data); } } } @@ -322,7 +337,7 @@ int emufs_tipo3_borrar_registro(EMUFS *emu, EMUFS_REG_ID ID) EMUFS_BLOCK_SIZE ptr_elim; EMUFS_BLOCK_SIZE ptr_mov; EMUFS_REG_ID ID_aux; - EMUFS_FREE fs, new_fs; + EMUFS_FREE fs; char *bloque; int err = 0, i, cant_bloques; @@ -494,6 +509,8 @@ void* emufs_tipo3_leer_registro_raw(EMUFS *emu, EMUFS_REG_ID ID, EMUFS_REG_SIZE void emufs_tipo3_compactar(EMUFS *emu) { +/* TODO ARREGLAR */ +#ifdef PEPITO_EL_GALAN EMUFS_REG_ID *tmp, max_id; EMUFS_BLOCK_ID block_id; EMUFS_REG_SIZE size; @@ -528,6 +545,7 @@ void emufs_tipo3_compactar(EMUFS *emu) if(emu->tam_bloque-sizeof(EMUFS_REG_ID) < emu->tam_reg) block_id = block_id/2; if (emufs_fsc_truncate(emu, block_id)!= 0) PERR("NO TURNQUE EL FSC"); +#endif } void emufs_tipo3_leer_bloque_raw(EMUFS *efs, EMUFS_BLOCK_ID id, char **actual, char **anterior, char **siguiente, diff --git a/emufs/tipo3.h b/emufs/tipo3.h index c4b860e..ee19aee 100644 --- a/emufs/tipo3.h +++ b/emufs/tipo3.h @@ -56,7 +56,7 @@ * \param reg_size tamaño del registro. * \param err Codigo de error devuelto en caso de falla. */ -void* emufs_tipo3_leer_registro(EMUFS *emu, EMUFS_REG_ID ID, EMUFS_REG_SIZE* reg_size, int* err); +void* emufs_tipo3_leer_registro(EMUFS *emu, CLAVE clave, EMUFS_REG_SIZE* reg_size, int* err); /** Devuelve un puntero con la memoria reservada que contiene el bloque solicitado por * el segundo parámetro \c num_bloque. Como la numeración de los bloques es virtual, diff --git a/emufs/tipo3_main.c b/emufs/tipo3_main.c index 509f497..79a723e 100644 --- a/emufs/tipo3_main.c +++ b/emufs/tipo3_main.c @@ -39,6 +39,7 @@ int main(int argc, char *argv[]) { +#ifdef SENIOR_PALOMO EMUFS *fp; EMUFS_REG_ID v[100]; EMUFS_REG_SIZE reg_size; @@ -165,5 +166,6 @@ ver_archivo_FS(fp); ver_archivo_FS(fp); debug_ver_estadisticas(fp); emufs_destruir(fp); +#endif return 0; } diff --git a/emufs_gui/articulos.c b/emufs_gui/articulos.c index f768dc2..519ea4c 100644 --- a/emufs_gui/articulos.c +++ b/emufs_gui/articulos.c @@ -71,12 +71,12 @@ t_LstArticulos *art_cargar(const char *filename, int tipo, int tam_bloque) { xmlDocPtr document; xmlNode *node, *inicio; - int error = 0, i; + int error = 0; char *prop; EMUFS_REG_SIZE size; t_LstArticulos *tmp; lst_articulos = NULL; - EMUFS_REG_ID id, *indices, indices_cant; + EMUFS_REG_ID id; tmp = (t_LstArticulos *)malloc(sizeof(t_LstArticulos)); if (tmp == NULL) return NULL; @@ -107,7 +107,11 @@ t_LstArticulos *art_cargar(const char *filename, int tipo, int tam_bloque) #ifdef DEBUG fprintf(stderr, "Articulos : Tipo=%d Bloque=%d\n", tipo-1, tam_bloque); #endif + /* Creo el FS */ tmp->fp = emufs_crear("articulos", tipo-1, tam_bloque, sizeof(t_Articulo)); + /* Agrego los indices */ + PERR("Voy a agregar un indice"); + emufs_agregar_indice(tmp->fp, "codigo", IND_PRIMARIO, IND_B, IDX_INT, 0, 512); if (!tmp->fp) { PERR("NO SE PUDO CREAR ARCHIVO ARTICULOS"); free(tmp); @@ -150,7 +154,10 @@ t_LstArticulos *art_cargar(const char *filename, int tipo, int tam_bloque) xmlFreeDoc(document); xmlCleanupParser(); } else { - PERR("Voy a recuperar desde un archivo"); +/* XXX Ahora no necesito leer nada del archivo cuando lo cargo + * pues tengo todo en los indices + * + * PERR("Voy a recuperar desde un archivo"); tmp->fp = emufs_abrir("articulos"); if (tmp->fp == NULL) { PERR("No se pudo cargar archivo de articulos."); @@ -158,12 +165,12 @@ t_LstArticulos *art_cargar(const char *filename, int tipo, int tam_bloque) lst_articulos = NULL; return NULL; } - /* Ahora trato de recuperar la info */ + Ahora trato de recuperar la info indices = emufs_idx_get(tmp->fp, &indices_cant); for(i=0; ifp->leer_registro(tmp->fp, indices[i], &size, &error); if (procesar_leer_articulo(&art, save, size, tmp) == 1) { @@ -172,6 +179,7 @@ t_LstArticulos *art_cargar(const char *filename, int tipo, int tam_bloque) } } free(indices); +*/ } return tmp; @@ -198,40 +206,29 @@ int art_liberar(t_LstArticulos *l) t_Articulo *art_obtener(t_LstArticulos *lst, int numero, EMUFS_REG_ID *id) { t_Articulo *art; - t_Reg_Articulo *nodo; void *tmp; int error = 0; EMUFS_REG_SIZE size; - int n = numero; - if (lst == NULL) lst = lst_articulos; - if (lst == NULL) return NULL; - nodo = lst->primero; - while (nodo) { - if (n == nodo->numero) { - (*id) = nodo->num_reg; - art = (t_Articulo *)malloc(sizeof(t_Articulo)); - /* Ya se cual tengo que retornar. Ahora veo si lo cargo desde el archivo */ - error = 0; - tmp = lst->fp->leer_registro(lst->fp, nodo->num_reg, &size, &error); + (*id) = -1; /* XXX Ver que se hacia con esto */ + art = (t_Articulo *)malloc(sizeof(t_Articulo)); + /* Ya se cual tengo que retornar. Ahora veo si lo cargo desde el archivo */ + error = 0; + tmp = lst->fp->leer_registro(lst->fp, emufs_indice_generar_clave_desde_valor(lst->fp->indices, (char *)&numero), &size, &error); - if (error) { - free(art); - return NULL; - } + if (error) { + free(art); + return NULL; + } - if (procesar_leer_articulo(art, tmp, size, lst_articulos) != 1) { - free(art); - free(tmp); - return NULL; - } - free(tmp); - return art; - } - nodo = nodo->sig; + if (procesar_leer_articulo(art, tmp, size, lst_articulos) != 1) { + free(art); + free(tmp); + return NULL; } - return NULL; + free(tmp); + return art; } t_Articulo *art_form_buscar(WINDOW *win, EMUFS_REG_ID *id) @@ -257,21 +254,22 @@ void art_modificar(char *s) void *tmp; int error; EMUFS_REG_SIZE size; - EMUFS_REG_ID id; + EMUFS_REG_ID codigo; win = newwin(9, COLS-2, 13, 1); box(win, 0, 0); wrefresh(win); if (s == NULL) { - articulo = art_form_buscar(win, &id); + articulo = art_form_buscar(win, &codigo); } else { - id = atoi(s); + codigo = atoi(s); /* Leo el registro directamente */ articulo = (t_Articulo *)malloc(sizeof(t_Articulo)); /* Ya se cual tengo que retornar. Ahora veo si lo cargo desde el archivo */ error = 0; - tmp = lst_articulos->fp->leer_registro(lst_articulos->fp, id, &size, &error); + tmp = lst_articulos->fp->leer_registro(lst_articulos->fp, + emufs_indice_generar_clave_desde_valor(lst_articulos->fp->indices, (char *)&codigo), &size, &error); if (error) { free(articulo); articulo = NULL; @@ -309,7 +307,7 @@ void art_modificar(char *s) tmp = procesar_guardar_articulo(articulo, &size, lst_articulos); if (tmp) { error = 0; - lst_articulos->fp->modificar_registro(lst_articulos->fp, id, tmp, size, &error); + lst_articulos->fp->modificar_registro(lst_articulos->fp, codigo, tmp, size, &error); free(tmp); } @@ -529,6 +527,7 @@ void *procesar_guardar_articulo(t_Articulo *src, EMUFS_REG_SIZE *size, t_LstArti void art_reformatear(int tipo, int tam_bloque, int tam_reg) { +#ifdef NO_SE_PUEDE_USAR EMUFS *nuevo, *old; EMUFS_REG_ID *indices, id; EMUFS_REG_SIZE indices_total, i, size; @@ -599,6 +598,7 @@ void art_reformatear(int tipo, int tam_bloque, int tam_reg) rename("emufs_tmp.fsc", "articulos.fsc"); rename("emufs_tmp.did", "articulos.did"); PERR("==== TERMINE ====\n"); +#endif } int art_exportar_xml(const char *filename) diff --git a/emufs_gui/articulos.h b/emufs_gui/articulos.h index f398b63..c5eadcc 100644 --- a/emufs_gui/articulos.h +++ b/emufs_gui/articulos.h @@ -9,6 +9,8 @@ #include "form.h" #include "emufs.h" #include "common.h" +#include "indices.h" +#include "indice_b.h" /* Tipo de dato articulo */ typedef struct _articulo_ { diff --git a/emufs_gui/facturas.c b/emufs_gui/facturas.c index 0ac4861..8e2526a 100644 --- a/emufs_gui/facturas.c +++ b/emufs_gui/facturas.c @@ -178,11 +178,11 @@ t_LstFacturas *fact_cargar(const char *filename, int tipo, int tam_bloque, int t { xmlDocPtr document; xmlNode *node, *inicio; - int error = 0, cant_items, i; + int error = 0, cant_items; char *prop; EMUFS_REG_SIZE size; t_LstFacturas *tmp; - EMUFS_REG_ID id, *indices, indices_cant; + EMUFS_REG_ID id; lst_facturas = NULL; @@ -275,6 +275,7 @@ t_LstFacturas *fact_cargar(const char *filename, int tipo, int tam_bloque, int t xmlFreeDoc(document); xmlCleanupParser(); } else { +#ifdef NO_SE_USA_MAS PERR("Voy a recuperar desde un archivo"); tmp->fp = emufs_abrir("facturas"); if (tmp->fp == NULL) { @@ -305,6 +306,7 @@ t_LstFacturas *fact_cargar(const char *filename, int tipo, int tam_bloque, int t } } free(indices); +#endif } PERR("Facturas todo Ok"); @@ -333,35 +335,29 @@ int fact_liberar(t_LstFacturas *l) t_Factura *fact_buscar(t_LstFacturas *lst, int numero, EMUFS_REG_ID *id, EMUFS_REG_ID *id_texto) { t_Factura *fact; - t_Reg_Factura *reg; char *leo; EMUFS_REG_SIZE size; int error; if (lst == NULL) return NULL; fact = NULL; - reg = lst->primero; - while (reg) { - if (reg->numero == numero) { - size = 0; - error = 0; - leo = lst->fp->leer_registro(lst->fp, reg->num_reg, &size, &error); - if (leo != NULL) { - fact = (t_Factura *)malloc(sizeof(t_Factura)); - if (fact == NULL) { - free(leo); - return NULL; - } - procesar_leer_factura(fact, leo, size, lst); - (*id) = reg->num_reg; - (*id_texto) = reg->texto_reg; - free(leo); - fact->nota = lst->fp_texto->leer_registro(lst->fp_texto, reg->texto_reg, &size, &error); - } - break; + leo = lst->fp->leer_registro(lst->fp, + emufs_indice_generar_clave_desde_valor(lst->fp->indices, (char*)&numero), &size, &error); + if (leo != NULL) { + fact = (t_Factura *)malloc(sizeof(t_Factura)); + if (fact == NULL) { + free(leo); + return NULL; } - reg = reg->sig; + procesar_leer_factura(fact, leo, size, lst); + /* y esto ??! + (*id) = reg->num_reg; + (*id_texto) = reg->texto_reg; + */ + free(leo); + //fact->nota = lst->fp_texto->leer_registro(lst->fp_texto, reg->texto_reg, &size, &error); } + return fact; } @@ -717,7 +713,7 @@ void *procesar_guardar_factura(t_Factura *f, t_LstFacturas *lst, EMUFS_REG_SIZE static int procesar_leer_factura(t_Factura *dst, void *src, EMUFS_REG_SIZE size, t_LstFacturas *lst) { char *ini, *fin; - int dummy; + /*int dummy;*/ if (lst == NULL) { PERR("Puntero a lista NULO"); @@ -790,7 +786,7 @@ static int procesar_leer_factura(t_Factura *dst, void *src, EMUFS_REG_SIZE size, } else { dst->items = NULL; } - dst->nota = lst->fp_texto->leer_registro(lst->fp_texto, dst->reg_nota, (EMUFS_REG_SIZE *)&dummy, &dummy); + /*dst->nota = lst->fp_texto->leer_registro(lst->fp_texto, dst->reg_nota, (EMUFS_REG_SIZE *)&dummy, &dummy);*/ return 0; break; case T3: @@ -800,13 +796,14 @@ static int procesar_leer_factura(t_Factura *dst, void *src, EMUFS_REG_SIZE size, memcpy(dst, src, size-sizeof(t_Item)*10); dst->items = (t_Item *)malloc(10*sizeof(t_Item)); memcpy(dst->items, src+size-sizeof(t_Item)*10, 10*sizeof(t_Item)); - dst->nota = lst->fp_texto->leer_registro(lst->fp_texto, dst->reg_nota, (EMUFS_REG_SIZE *)&dummy, &dummy); + /*dst->nota = lst->fp_texto->leer_registro(lst->fp_texto, dst->reg_nota, (EMUFS_REG_SIZE *)&dummy, &dummy);*/ } return 0; } void fact_reformatear(int tipo, int tam_bloque, int tam_reg, int nota_tipo, int nota_tam_bloque, int nota_tam_registro) { +#ifdef NO_ANDA_AUN EMUFS *nuevo, *old; EMUFS_REG_ID *indices, id; EMUFS_REG_SIZE indices_total, i, size, tam_reg1; @@ -903,6 +900,7 @@ void fact_reformatear(int tipo, int tam_bloque, int tam_reg, int nota_tipo, int rename("nota_tmp.fsc", "notas.fsc"); rename("nota_tmp.did", "notas.did"); PERR("==== TERMINE ====\n"); +#endif } int fact_exportar_xml(const char *filename) -- 2.43.0