preparo para debuguear tipo3

[z.facultad/75.06/emufs.git] / emufs / tipo1.c

diff --git a/emufs/tipo1.c b/emufs/tipo1.c
index 99cf50c63dc322200705ae5ba58ad9a9608d5369..1af58b462bd9b8f622cdc238a8a27a68cdaff750 100644 (file)
--- a/emufs/tipo1.c
+++ b/emufs/tipo1.c
@@ -75,8 +75,8 @@ static void* emufs_tipo1_leer_bloque(EMUFS*, EMUFS_BLOCK_ID, int*);
 static EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque_fsc(EMUFS*, void*,
                EMUFS_BLOCK_ID, EMUFS_FREE, int*);
 
 static EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque_fsc(EMUFS*, void*,
                EMUFS_BLOCK_ID, EMUFS_FREE, int*);
 

-
-CLAVE insertar_odenado_en_bloque(EMUFS *emu, void *ptr, void *bloque, int num_bloque);
+static CLAVE grabar_ordenado_en_bloque(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, 
+               void *bloque, int num_bloque, EMUFS_FREE fs, int *err);

 
 /*------------------ Funciones públicas ----------------------*/
 
 
 /*------------------ Funciones públicas ----------------------*/
 


@@ -369,7 +369,7 @@ EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* efs, void* reg,
        return header.id;
 }
 
        return header.id;
 }
 

-int emufs_tipo1_borrar_registro(EMUFS* efs, CLAVE k)
+int emufs_tipo1_borrar_registro(EMUFS* efs, CLAVE k, INDICE_DATO dato1)

 {
        char* block; /* bloque leido (en donde está el registro a leer) */
        EMUFS_BLOCK_ID block_id; /* id del bloque en donde esta el registro a leer */
 {
        char* block; /* bloque leido (en donde está el registro a leer) */
        EMUFS_BLOCK_ID block_id; /* id del bloque en donde esta el registro a leer */


@@ -399,6 +399,7 @@ int emufs_tipo1_borrar_registro(EMUFS* efs, CLAVE k)
                return err;
        }
 
                return err;
        }
 

+       emufs_indice_borrar(efs->indices, k, dato1);

        /* Busco secuencialmente en el bloque el registro a leer */
        offset = 0;
        do {
        /* Busco secuencialmente en el bloque el registro a leer */
        offset = 0;
        do {


@@ -461,10 +462,7 @@ int emufs_tipo1_borrar_registro(EMUFS* efs, CLAVE k)
                                /* si es necesario desplazar */
                                if (offset < offset_reg_end) {
                                        /* muevo la porción de bloque a izquierda */
                                /* si es necesario desplazar */
                                if (offset < offset_reg_end) {
                                        /* muevo la porción de bloque a izquierda */

-                                       /* XXX Este memcpy() puede copiar regiones de memoria que
-                                        * se superponen, si copia de principio a fin y byte a byte
-                                        * no debería haber problema */
-                                       memcpy(block + offset, block + offset_reg_end,
+                                       memmove(block + offset, block + offset_reg_end,

                                                efs->tam_bloque - offset_reg_end);
                                        /* rellena el espacio libre con ceros para la GUI */
                                        memset(block + efs->tam_bloque - offset_reg_end - orig_fs + offset,
                                                efs->tam_bloque - offset_reg_end);
                                        /* rellena el espacio libre con ceros para la GUI */
                                        memset(block + efs->tam_bloque - offset_reg_end - orig_fs + offset,


@@ -632,7 +630,7 @@ EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque_fsc(EMUFS *efs, void *block,
                PERR("Error al obtener tamaño del archivo.");
                return EMUFS_NOT_FOUND;
        }
                PERR("Error al obtener tamaño del archivo.");
                return EMUFS_NOT_FOUND;
        }

-
+       

        /* abre archivo */
        strcpy(name_f,efs->nombre);
        strcat(name_f,".dat");
        /* abre archivo */
        strcpy(name_f,efs->nombre);
        strcat(name_f,".dat");


@@ -698,9 +696,9 @@ EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque_fsc(EMUFS *efs, void *block,
 }
 
 EMUFS_REG_ID emufs_tipo1_modificar_registro(EMUFS* efs, CLAVE k,
 }
 
 EMUFS_REG_ID emufs_tipo1_modificar_registro(EMUFS* efs, CLAVE k,

-               void *data, EMUFS_REG_SIZE size, int* err)
+               void *data, EMUFS_REG_SIZE size, int* err, INDICE_DATO dato)

 {
 {

-       emufs_tipo1_borrar_registro(efs, k);
+       emufs_tipo1_borrar_registro(efs, k, dato);

        return emufs_tipo1_grabar_registro(efs, data, size, err);
 }
 
        return emufs_tipo1_grabar_registro(efs, data, size, err);
 }
 


@@ -727,53 +725,6 @@ int emufs_tipo1_block_jump(EMUFS* efs, FILE* fp, EMUFS_BLOCK_ID block_count)
        return EMUFS_OK;
 }
 
        return EMUFS_OK;
 }
 

-/*crea un bloque y devuelve en numero del mismo*/
-EMUFS_BLOCK_ID create_new_block(EMUFS *emu)
-{
-       FILE *fp;
-       char name[255];
-       char *dummy;
-       EMUFS_BLOCK_ID num;
-       
-       /* obtengo nombre del archivo */
-       strcpy(name, emu->nombre);
-       strcat(name,".dat");
-       
-       if ( (fp=fopen(name,"a+")) == NULL ){
-               PERR("NO SE PUDO ABRIR EL ARCHIVO");
-               return -1;
-       }
-       
-       dummy = (char*)malloc(emu->tam_bloque);
-       memset(dummy, 0, emu->tam_bloque);
-       fwrite(dummy, emu->tam_bloque, 1, fp);
-       
-       num = (ftell(fp)-emufs_tipo1_header_size())/emu->tam_bloque;
-       fclose(fp);
-       free(dummy);
-       return num;
-}
-
-/*devuelve un numero de bloque siguiente al ultimo*/
-EMUFS_BLOCK_ID get_new_block_number(EMUFS *emu)
-{
-       FILE *fp;
-       char name[255];
-       EMUFS_BLOCK_ID num;
-       
-       /* obtengo nombre del archivo */
-       strcpy(name, emu->nombre);
-       strcat(name,".dat");
-
-       if ( (fp=fopen(name,"a+")) == NULL ){
-               PERR("NO SE PUDO ABRIR EL ARCHIVO");
-               return -1;
-       }
-       num = (ftell(fp)-emufs_tipo1_header_size())/emu->tam_bloque;
-       fclose(fp);
-       return num+1;
-}
-

 void emufs_tipo1_escribir_reg_chunk_en_memoria(char* dst,
                EMUFS_TIPO1_REG_HEADER header, char* reg, EMUFS_REG_SIZE reg_size)
 {
 void emufs_tipo1_escribir_reg_chunk_en_memoria(char* dst,
                EMUFS_TIPO1_REG_HEADER header, char* reg, EMUFS_REG_SIZE reg_size)
 {


@@ -796,17 +747,18 @@ void emufs_tipo1_leer_bloque_raw(EMUFS *efs, EMUFS_BLOCK_ID id, char **actual, c
 
 int emufs_tipo1_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, int *err)
 {
 
 int emufs_tipo1_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, int *err)
 {

-       #ifdef ESTO_NO_ANDA_TODAVIA
-       CLAVE clave, clave_ajena;
-       EMUFS_BLOCK_ID num_bloque = get_new_block_number(emu); 
+       CLAVE clave, menor_clave_bloque_nuevo;
+       EMUFS_BLOCK_ID num_bloque; 

        EMUFS_TIPO1_REG_HEADER header;
        EMUFS_TIPO1_REG_HEADER header;

-       EMUFS_REG_SIZE tam_reg;
+       EMUFS_REG_SIZE tam_reg, move_size;

        INDEX_DAT query;
        INDEX_DAT query;

-       char *bloque, *aux, *new_bloque, *registro;
-       int cant_reg, i, j;
+       EMUFS_FREE fs;
+       char *bloque = 0, *aux, *new_bloque = 0;
+       int cant_reg, i, result, dif;

        
        /*le asigno un posible numero de bloque para el caso en que no encuentre donde meterlo*/
        
        /*le asigno un posible numero de bloque para el caso en que no encuentre donde meterlo*/

-       query.num_bloque = num_bloque;  
+       num_bloque = emufs_get_new_block_number(emu);   
+       query.num_bloque = num_bloque;

        /*saco la clave del stream*/
        query.clave = emufs_indice_generar_clave(emu->indices, ptr);
        /*mando a buscar en el arbol el bloque correspondiente a esa clave*/
        /*saco la clave del stream*/
        query.clave = emufs_indice_generar_clave(emu->indices, ptr);
        /*mando a buscar en el arbol el bloque correspondiente a esa clave*/


@@ -814,21 +766,37 @@ int emufs_tipo1_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, in
        /*debo insertar el reg en el bloque en forma ordenada*/
        /*si es el menor de todos tengo que cambiar el ancla en el arbol*/
        /*si no entra, tengo que insertar una nueva clave en el arbol y separar los registros en 2 bloques*/
        /*debo insertar el reg en el bloque en forma ordenada*/
        /*si es el menor de todos tengo que cambiar el ancla en el arbol*/
        /*si no entra, tengo que insertar una nueva clave en el arbol y separar los registros en 2 bloques*/

-       if ( emu->indices->emufs_b_plus_get_bloque(ind, &query) == -1 ){
+       /* emufs_b_plus_get_bloque retorna asi
+       -1 = Nuevo bloque, retorno idem num_bloque que ingreso
+       0 = Sin problemas, retorno bloque donde insertar
+       1 = Error de lectura en algun nodo, abortar operacion en funcion invocante.
+       */
+       result = emufs_b_plus_get_bloque(emu->indices, &query, 0);
+       if (result == 1){
+               PERR("SE PRODUJO UN ERROR EN EL ARBOL.. ABORTANDO");
+               return -1;
+       }
+       if ( result == -1 ){            

                /*creo un bloque nuevo*/
                bloque = (char*) malloc(emu->tam_bloque);
                if (bloque == NULL){
                        PERR("NO SE PUDO CREAR EL BLOQUE");
                        return -1;
                }
                /*creo un bloque nuevo*/
                bloque = (char*) malloc(emu->tam_bloque);
                if (bloque == NULL){
                        PERR("NO SE PUDO CREAR EL BLOQUE");
                        return -1;
                }

-               header.id = emufs_idx_get_new_id(efs, err);
+               memset(bloque, 0, emu->tam_bloque);
+               header.id = emufs_idx_get_new_id(emu, err);
+               if (*err) {
+                       PERR("NO SE PUDO OBTENER UN ID");
+                       free(bloque);
+                       return -1;
+               }

                header.size = size;
                cant_reg = 1;
                /*pongo la cabecera en el registro*/
                memcpy(bloque, &header, sizeof(EMUFS_TIPO1_REG_HEADER)); 
                /*inserto el footer en el bloque*/
                memcpy(bloque+emu->tam_bloque-sizeof(int), &cant_reg, sizeof(int));
                header.size = size;
                cant_reg = 1;
                /*pongo la cabecera en el registro*/
                memcpy(bloque, &header, sizeof(EMUFS_TIPO1_REG_HEADER)); 
                /*inserto el footer en el bloque*/
                memcpy(bloque+emu->tam_bloque-sizeof(int), &cant_reg, sizeof(int));

-               /*inserto el registro en el bloque*/
+               /*inserto el registro en el bloqude*/

                if ( size <= emu->tam_bloque-sizeof(EMUFS_TIPO1_REG_HEADER)-sizeof(int) )
                        memcpy(bloque+sizeof(EMUFS_TIPO1_REG_HEADER), ptr, size); 
                else {
                if ( size <= emu->tam_bloque-sizeof(EMUFS_TIPO1_REG_HEADER)-sizeof(int) )
                        memcpy(bloque+sizeof(EMUFS_TIPO1_REG_HEADER), ptr, size); 
                else {


@@ -837,62 +805,135 @@ int emufs_tipo1_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, in
                        return -1;
                }
                /*hago lugar en el archivo para grabar*/
                        return -1;
                }
                /*hago lugar en el archivo para grabar*/

-               if ( num_bloque != create_new_block(emu) )      PERR("NUMEROS DE NUEVO BLOQUE DISTINTOS");
+               if ( num_bloque != emufs_create_new_block(emu) )        PERR("NUMEROS DE NUEVO BLOQUE DISTINTOS");

                /*grabo el bloque en el archivo*/ /* OJO CON LO DE FS = 0 */
                /*grabo el bloque en el archivo*/ /* OJO CON LO DE FS = 0 */

-               emufs_tipo1_grabar_bloque_fsc(emu, bloque, query->num_bloque, EMUFS_NOT_FOUND, err);
+               emufs_tipo1_grabar_bloque_fsc(emu, bloque, query.num_bloque, EMUFS_NOT_FOUND, err);

                /*agrego la clave al arbol*/
                emufs_b_plus_insertar(emu->indices, &query);
                free(bloque);
                return 0;
        } else { /*tengo que meter el registro en el bloque que me dijo el arbol*/
                /*leo el bloque correspondiente*/
                /*agrego la clave al arbol*/
                emufs_b_plus_insertar(emu->indices, &query);
                free(bloque);
                return 0;
        } else { /*tengo que meter el registro en el bloque que me dijo el arbol*/
                /*leo el bloque correspondiente*/

-               bloque = emufs_tipo1_leer_bloque(emu, num_bloque, err);
+               bloque = emufs_tipo1_leer_bloque(emu, query.num_bloque, err);

                /*me fijo cuantos registros hay en el */
                memcpy(&cant_reg, bloque+emu->tam_bloque-sizeof(int), sizeof(int));
                /*me fijo si entra en nuevo reg en el bloque */
                /*me fijo cuantos registros hay en el */
                memcpy(&cant_reg, bloque+emu->tam_bloque-sizeof(int), sizeof(int));
                /*me fijo si entra en nuevo reg en el bloque */

+               fs = emu->tam_bloque;

                aux = bloque;
                for (i=0; i<cant_reg; i++){
                        memcpy(&tam_reg, aux+sizeof(EMUFS_REG_ID), sizeof(EMUFS_REG_SIZE));
                        aux += sizeof(EMUFS_TIPO1_REG_HEADER)+tam_reg;
                aux = bloque;
                for (i=0; i<cant_reg; i++){
                        memcpy(&tam_reg, aux+sizeof(EMUFS_REG_ID), sizeof(EMUFS_REG_SIZE));
                        aux += sizeof(EMUFS_TIPO1_REG_HEADER)+tam_reg;

-                       fs -= (tam_reg+sizeof(EMUFS_TIPO1_REG_HEADER);
+                       fs -= (tam_reg+sizeof(EMUFS_TIPO1_REG_HEADER));

                } /*aca deberia estar apuntando al final de los registros. espacio libre*/
                fs -= sizeof(int); /*footer*/
                } /*aca deberia estar apuntando al final de los registros. espacio libre*/
                fs -= sizeof(int); /*footer*/

-               if ( fs >= size ){ /* puedo meter el registro en este bloque*/  
-                       insertar_odenado_en_bloque(emu, ptr, bloque, query->num_bloque);
+               if ( fs >= size+sizeof(EMUFS_TIPO1_REG_HEADER) ){ /* puedo meter el registro en este bloque*/
+                       PERR("GRABO ORDENADO");                 
+                       grabar_ordenado_en_bloque(emu, ptr, size, bloque, query.num_bloque, fs, err);

                        /*en teoria el nuevo registro no debe cambiar el ancla, por lo cual no actualizo el arbol*/
                        /*en teoria el nuevo registro no debe cambiar el ancla, por lo cual no actualizo el arbol*/

+                       free(bloque);

                        return 0;
                        return 0;

-               /*aca va lo que saque*/

                } else { /* el registro no entra en el bloque, hay que crear uno nuevo y desparramar */
                } else { /* el registro no entra en el bloque, hay que crear uno nuevo y desparramar */

+                       PERR(" COMO NO ENTRA DEBO DIVIDIR LOS REGISTROS EN 2 BLOQUES");

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

-                       for(i=0; i<cant_reg/2; i++);
-                               
-       #endif
+                       memset(new_bloque,0,emu->tam_bloque);
+                       move_size=0;
+                       aux = bloque;
+                       for(i=0; i<cant_reg/2; i++){ /*copio mitad-1 aca y mitad en el nuevo*/
+                               /*avanzo*/
+                               memcpy(&tam_reg, aux+sizeof(EMUFS_REG_ID), sizeof(EMUFS_REG_SIZE));
+                               aux += sizeof(EMUFS_TIPO1_REG_HEADER)+tam_reg;
+                               move_size += sizeof(EMUFS_TIPO1_REG_HEADER)+tam_reg;
+                       }/*apunto al reg mitad_mas_uno para copiar todo a otro bloque*/
+                       /*copio el resto del bloque al nuevo bloque*/      /*footer ¿?*/
+                       memcpy(new_bloque, aux, emu->tam_bloque-move_size-sizeof(int));
+                       /*borro lo que sobra en el bloque original, guardando el footer*/
+                       memset(aux, 0, emu->tam_bloque - move_size - sizeof(int));
+                       menor_clave_bloque_nuevo = emufs_indice_generar_clave(emu->indices, new_bloque+sizeof(EMUFS_TIPO1_REG_HEADER));
+                       /* TENGO QUE VER EN CUAL DE LOS DOS BLOQUES METO EL REGISTRO NUEVO */
+                       if ( emufs_indice_es_menor(emu->indices, menor_clave_bloque_nuevo, clave) ){
+                               /* GRABO EN EL BLOQUE NUEVO */
+                               /*actualizo la cant de registros del bloque original (footer)*/
+                               memcpy(bloque+emu->tam_bloque-sizeof(int), &i, sizeof(int));
+                               /*actualizo el footer del nuevo bloque*/
+                               dif = cant_reg - i; /*por las dudas*/
+                               memcpy(new_bloque+emu->tam_bloque-sizeof(int), &dif, sizeof(int));
+                               /*genero un nuevo espacio para un bloque en el archivo y lo cargo en queryla clave ya estaba en query desde antes*/
+                               num_bloque = query.num_bloque;
+                               query.num_bloque = emufs_create_new_block(emu);
+                               /*inserto el nuevo registro en el nuevo bloque y obtengo la clave del menor*/
+                               clave = grabar_ordenado_en_bloque(emu,ptr,size,new_bloque,query.num_bloque, emu->tam_bloque-move_size,err);
+                               /*actualizo el arbol con la nueva clave*/
+                               query.clave = clave;
+                               printf("clave enviada = %d\n", clave);
+                               emufs_b_plus_insertar(emu->indices, &query);
+                               /*grabo el bloque original*/
+                               emufs_tipo1_grabar_bloque_fsc(emu, bloque, num_bloque, EMUFS_NOT_FOUND, err);
+                       } else {
+                               PERR("GRABO EN BLOQUE VIEJO");
+                               /* GRABO EN EL BLOQUE VIEJO */
+                               /*actualizo la cant de registros del bloque original (footer)*/
+                               memcpy(bloque+emu->tam_bloque-sizeof(int), &i, sizeof(int));
+                               /*actualizo el footer del nuevo bloque*/
+                               dif = cant_reg - i; /*por las dudas*/
+                               /*meto el footer en el reg */
+                               memcpy(new_bloque+emu->tam_bloque-sizeof(int), &dif, sizeof(int));
+                               /*guardo el num de bloque original */
+                               num_bloque = query.num_bloque;
+                               /* pido un bloque nuevo para guardar */
+                               query.num_bloque = emufs_create_new_block(emu);
+                               /*grabo el bloque nuevo*/
+                               emufs_tipo1_grabar_bloque_fsc(emu, new_bloque, query.num_bloque, EMUFS_NOT_FOUND, err);
+                               /*grabo el registro en el bloque original*/
+                               grabar_ordenado_en_bloque(emu,ptr,size,bloque,num_bloque,fs+move_size,err);
+                               /*actualizo el arbol con la menor clave del bloque nuevo*/
+                               query.clave = emufs_indice_generar_clave(emu->indices, new_bloque+sizeof(EMUFS_TIPO1_REG_HEADER));
+                               emufs_b_plus_insertar(emu->indices, &query);
+                       }
+                       if(*err != 0){
+                               PERR("NO SE PUDO GRABAR ORDENADO");
+                               free(new_bloque);
+                               free(bloque);
+                               return -1;
+                       }
+                       free(new_bloque);
+                       free(bloque);
+                       return 0;
+               }
+       }
+       if (new_bloque) free(new_bloque);
+       if (bloque) free(bloque);
+       return 0;

 }
 
 /*inserta un registro ordenado en un bloque y devuelve la menor de las claves*/
 }
 
 /*inserta un registro ordenado en un bloque y devuelve la menor de las claves*/

-CLAVE insertar_odenado_en_bloque(EMUFS *emu, void *ptr, void *bloque, int num_bloque)
+CLAVE grabar_ordenado_en_bloque(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, void *bloque, int num_bloque, EMUFS_FREE fs, int *err)

 {
 {

-       #ifdef CAMBIAR

        char *aux, *new_bloque;
        int cant_reg, tam_reg, i, j;
        EMUFS_TIPO1_REG_HEADER header;
        CLAVE clave, clave_ajena;
        
        char *aux, *new_bloque;
        int cant_reg, tam_reg, i, j;
        EMUFS_TIPO1_REG_HEADER header;
        CLAVE clave, clave_ajena;
        

-       header.id = emufs_idx_get_new_id(efs, err);
+       /*saco la cant de registros del bloque*/
+       memcpy(&cant_reg, bloque+emu->tam_bloque-sizeof(int), sizeof(int));
+       /*obtengo la clave del nuevo registro*/
+       clave = emufs_indice_generar_clave(emu->indices, ptr);
+       /*cargo el header*/
+       header.id = emufs_idx_get_new_id(emu, err);

        header.size = size;
        header.size = size;

-       cant_reg++;

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

+       memset(new_bloque, 0, emu->tam_bloque);

        aux = new_bloque;
        for (i=0; i<cant_reg+1; i++){
                bloque += sizeof(EMUFS_TIPO1_REG_HEADER); /*salteo el encabezado del registro*/
                if ( emu->tam_bloque-fs < sizeof(EMUFS_TIPO1_REG_HEADER)+emu->indices->offset ){
                        PERR("ESTOY LEYENDO FUERA DEL BLOQUE!!!");
                        free(new_bloque);
        aux = new_bloque;
        for (i=0; i<cant_reg+1; i++){
                bloque += sizeof(EMUFS_TIPO1_REG_HEADER); /*salteo el encabezado del registro*/
                if ( emu->tam_bloque-fs < sizeof(EMUFS_TIPO1_REG_HEADER)+emu->indices->offset ){
                        PERR("ESTOY LEYENDO FUERA DEL BLOQUE!!!");
                        free(new_bloque);

+                       *err = -1;

                        return clave;
                }
                clave_ajena = emufs_indice_generar_clave(emu->indices, bloque); /*leo la clave*/
                bloque -= sizeof(EMUFS_TIPO1_REG_HEADER); /*vuelvo al principio*/
                        return clave;
                }
                clave_ajena = emufs_indice_generar_clave(emu->indices, bloque); /*leo la clave*/
                bloque -= sizeof(EMUFS_TIPO1_REG_HEADER); /*vuelvo al principio*/

-               if (  i<cant_reg && emufs_indice_es_menor(clave_ajena, clave) ){
+               if (  i<cant_reg && emufs_indice_es_menor(emu->indices, clave_ajena, clave) ){

                        memcpy(&tam_reg, bloque+sizeof(EMUFS_REG_ID), sizeof(EMUFS_REG_SIZE));
                        /*copio el reg al bloque nuevo*/
                        memcpy(new_bloque, bloque, sizeof(EMUFS_TIPO1_REG_HEADER)+tam_reg);
                        memcpy(&tam_reg, bloque+sizeof(EMUFS_REG_ID), sizeof(EMUFS_REG_SIZE));
                        /*copio el reg al bloque nuevo*/
                        memcpy(new_bloque, bloque, sizeof(EMUFS_TIPO1_REG_HEADER)+tam_reg);


@@ -916,12 +957,79 @@ CLAVE insertar_odenado_en_bloque(EMUFS *emu, void *ptr, void *bloque, int num_bl
                break; /*corto el for porque ya inserte todos*/
                }
        }
                break; /*corto el for porque ya inserte todos*/
                }
        }

-       free(bloque);/*no lo uso mas*/

        /*grabo el bloque en el archivo*/
        new_bloque = aux; /*apunto al principio del bloque*/
        /*grabo el bloque en el archivo*/
        new_bloque = aux; /*apunto al principio del bloque*/

-       emufs_tipo1_grabar_bloque_fsc(emu, new_bloque, query->num_bloque, EMUFS_NOT_FOUND, err);
+       cant_reg++; /*voy a poner un reg mas*/
+       memcpy(new_bloque+emu->tam_bloque-sizeof(int), &cant_reg, sizeof(int));
+       emufs_tipo1_grabar_bloque_fsc(emu, new_bloque, num_bloque, EMUFS_NOT_FOUND, err);

        clave = emufs_indice_generar_clave(emu->indices, new_bloque+sizeof(EMUFS_TIPO1_REG_HEADER));
        free(new_bloque);
        return clave;
        clave = emufs_indice_generar_clave(emu->indices, new_bloque+sizeof(EMUFS_TIPO1_REG_HEADER));
        free(new_bloque);
        return clave;

-       #endif CAMBIAR
+}
+
+int emufs_tipo1_eliminar_ordenado(EMUFS *emu, CLAVE clave, int *err)
+{
+       char *bloque, *aux;
+       INDEX_DAT query;
+       int result, iter, cant_reg;
+       EMUFS_REG_SIZE tam_reg;
+       CLAVE clave_ajena;
+       /*cargo el query para buscar*/
+       query.num_bloque = 0;
+       query.clave = clave;
+       /*mando a buscar el bloque donde esta la clave que quiero eliminar*/
+       result = emufs_b_plus_get_bloque(emu->indices, &query, 0);
+       if ( result == 1 ){
+               PERR("SE PRODUJO UN ERROR EN EL ARBOL");
+               return -1;
+       }
+       if ( result == -1 ){
+               PERR("NO EXISTE EL BLOQUE ¿?¿?¿?");
+               return -1;
+       }
+       /*cargo el bloque que corresponde*/
+       bloque = emufs_tipo1_leer_bloque(emu, query.num_bloque, err);
+       if ( bloque == NULL ){
+               PERR("NO SE CARGO EL BLOQUE");
+               return -1;
+       }
+       /*leo la cantidad de registros en el bloque*/
+       memcpy(&cant_reg, bloque+emu->tam_bloque-sizeof(int), sizeof(int));
+       /*busco y elimino*/
+       iter = 0;
+       aux = bloque;
+       /*me fijo si el que tengo que eliminar es el ancla del bloque*/
+       clave_ajena = emufs_indice_generar_clave(emu->indices, bloque+sizeof(EMUFS_TIPO1_REG_HEADER));
+       if ( emufs_indice_es_igual(emu->indices, clave, clave_ajena) ){
+               /* TENGOQ QUE BORRAR LA CLAVE DEL ARBOL !!!!*/
+               /* Y HAY QUE BORRAR EL BLOQUE DEL ARCHIVO*/
+       }
+       while ( iter < emu->tam_bloque ){
+               memcpy(&tam_reg, aux+sizeof(EMUFS_REG_ID), sizeof(EMUFS_REG_SIZE));
+               clave_ajena = emufs_indice_generar_clave(emu->indices, aux+sizeof(EMUFS_TIPO1_REG_HEADER));
+               if ( emufs_indice_es_igual(emu->indices, clave, clave_ajena) ){
+                       /*tenngo que borrar este registro*/
+                       /*limpio el espacio que ocupaba*/
+                       memset(aux, 0, tam_reg+sizeof(EMUFS_TIPO1_REG_HEADER));
+                       /*hay que reacomodar todo*/
+                       /*me posiciono en el reg siguiente*/
+                       iter += tam_reg+sizeof(EMUFS_TIPO1_REG_HEADER);
+                       break;/*ya borre, corto aca*/
+               }
+               iter += tam_reg+sizeof(EMUFS_TIPO1_REG_HEADER);
+               aux += iter;
+       }
+       
+       /*reacomodo el bloque */
+       memcpy(bloque+iter-tam_reg-sizeof(EMUFS_TIPO1_REG_HEADER), aux+iter, emu->tam_bloque-iter-sizeof(int)); 
+       /*le vuelvo a copiar la cantidad de registros*/
+       cant_reg--;
+       memcpy(bloque+emu->tam_bloque-sizeof(int), &cant_reg, sizeof(int));
+       /*grabo el bloque en el archivo*/
+       if ( emufs_tipo1_grabar_bloque_fsc(emu, bloque, query.num_bloque, EMUFS_NOT_FOUND, err) == EMUFS_NOT_FOUND ){
+               PERR("NO SE PUDO GRABAR EL BLOQUE");
+               return -1;
+       }
+       free(bloque);
+       return 0;

 }
 }