A) En los tres sets de rutinas para el manejo de los archivos auxiliares IDX,FSC y DID, se utilizan ahora los nuevos tipos de datos que definio Luca (son unsigned long int todos creo). Ademas, yo modifique algunas rutinas (y voy a tener que seguir modificando), para que se acomodem al esquema del Archivo Tipo2, en donde no tenemos bloques, tonces hay unas mini-diferencias ya que tenemos Gaps, no hay recompactacion automatica (perderia sentido tener los Gaps), se maneja la localizacion de los registros por Offsets y no bloque, etc.
B) En IDX, fixee la rutina que busca un registro por su ID. El problema que detecte ayer cuando la use, era que si terminaba de recorrer y no lo encontraba en vez de devolver -1, devolvia el ultimo ID que levanto.
C) En EMUFS.c|h, agrege a la estructura un campo para guardar el tamanio de registro, a ser utilizado solo por el Tipo3. Asi mismo, saque el ultimo parametro de la funcion dinamica borrar_registro en la cual se pasaba dicho dato, pues ahora ya se pasa en la estructura.
En el Emufs.c, ahora se deberia estar levantan correctamente el tamanio de registro en el header del archivo Tipo3 (chequeen ese OR por favor), por lo que Nico simplemente modificando tu funcion emufs_tipo3_borrar_registro, para que levante el dato de la estructura y no ese tercer parametro que ya no esta mas, deberia salir andando.
D) Por lo explicado anterioremente deshabilite las asignaciones en los Tipo1 y 3, de la rutina para Borrar Registros.
E) Tipo1 y Tipo3 me compilan, pero no se si estan tirando bien el output (o sea no se si es lo esperado). Fijense antes que nada en los printf que ahora es un unsigned int lo que se imprime y no integer, por lo que si ven un numero raro puede ser por eso. Los dos tests compilan sin warnings salvo el del truncate, pero recuerden que les saque el borrar registro, fix that.
-------------------------------------------
Bueno eso es todo, me tomo un buen rato reordenar esto con los tipos nuevos y lo que yo tenia desde ayer. Ahora voy a ver si puedo dejar mi tipo2 andando como lo habia dejado ayer y lo subo mas tarde. Por ahora solo grabo registros, ayer empeze hacer el borrar registro mio pero quebre (toy enfermo). Calculo que se me va a complicar un toque dado que si borro dos registros consecutivos deberia hacer un merge de esos dos gaps y dejarlo como uno solo en el .DID, pero bueno problema mio, cualquier cosa les pido ayuda.
Saludos, si me necesitan toy en ICQ hasta la noche facil, laburando sobre el TP.
CFLAGS=-Wall -g -ansi -pedantic -DDEBUG
LDFLAGS=
-EMUFS_COMMON=emufs.o tipo1.o tipo3.o idx.o did.o fsc.o
+EMUFS_COMMON=emufs.o tipo1.o tipo2.o tipo3.o idx.o did.o fsc.o
all: libemufs.a tipo1_test tipo3_main
ar cru libemufs.a tipo3.o $(EMUFS_COMMON)
clean:
- @rm -fv *.o tipo3_main
+ @rm -fv *.o tipo3_main tipo1_test articulos.*
#include <string.h>
#include <unistd.h>
-/**********************************************************************/
-/* int emufs_did_crear(EMUFS* efs) */
-/* */
-/* Objetivo: Crea un archivo de ID's Liberados. */
-/* Parametros: EMUFS *efs // Struct con handlers de un Data File. */
-/**********************************************************************/
+/* Crea un archivo de ID's Liberados. */
int emufs_did_crear(EMUFS* efs)
{
return emufs_crear_archivo_auxiliar(efs->nombre, EMUFS_DID_EXT);
}
-/**********************************************************************/
-/* EMUFS_REG_ID emufs_did_get_last(EMUFS *efs) */
-/* */
-/* Objetivo: Devuelve el ID Libre, liberado mas recientemente (pila) */
-/* Parametros: EMUFS *efs // Struct con handlers + info del openfile. */
-/**********************************************************************/
+/* Devuelve el ID Libre, liberado mas recientemente (pila) */
EMUFS_REG_ID emufs_did_get_last(EMUFS *efs)
{
FILE *f_did;
return n_RegId;
}
-/**********************************************************************/
-/* int emufs_did_agregar(EMUFS *efs, EMUFS_REG_ID n_RegId) */
-/* */
-/* Objetivo: Agrega un registro al archivo de ID's Libres (pila) */
-/* Parametros: EMUFS *efs // Struct con handlers + info del openfile. */
-/* EMUFS_REG_ID n_RegId // Id Libre a agregar. */
-/**********************************************************************/
+/* Agrega un registro al archivo de ID's Libres (pila) */
int emufs_did_agregar(EMUFS *efs, EMUFS_REG_ID n_RegId)
{
FILE *f_did;
#include "emufs.h"
#include "tipo1.h"
+#include "tipo2.h"
#include "tipo3.h"
#include "did.h"
#include "fsc.h"
char *str_dup(const char *s);
+/* Duplica una cadena de caracteres y devuelve la copia. */
char *str_dup(const char *s)
{
char *tmp;
return tmp;
}
+/* Objetivo: Crea un archivo de nombre y extension dadas. */
int emufs_crear_archivo_auxiliar(const char* name, const char* ext)
{
FILE* f;
return 0;
}
-
+/* Crea un archivo de tipo dado y devuelve una estructura con las rutinas de handling de dicho archivo. */
EMUFS *emufs_crear(const char *filename, EMUFS_TYPE tipo,
EMUFS_BLOCK_SIZE tam_bloque, EMUFS_REG_SIZE tam_reg)
{
if (efs == NULL) {
return NULL;
}
- efs->tipo = tipo;
+ efs->tipo = tipo;
efs->tam_bloque = tam_bloque;
- efs->nombre = str_dup(filename);
+ efs->tam_reg = tam_reg;
+ efs->nombre = str_dup(filename);
/* Abre archivo de datos. */
strcpy(name, filename);
break;
case T2:
+ /* Asigna punteros a funciones. */
+ efs->grabar_registro = emufs_tipo2_grabar_registro;
+ efs->borrar_registro = emufs_tipo2_borrar_registro;
+ efs->nombre = str_dup(filename);
+ /*efs->leer_registro = emufs_tipo2_leer_registro;*/
break;
case T3:
efs->leer_bloque = emufs_tipo3_leer_bloque;
efs->leer_registro = emufs_tipo3_leer_registro;
efs->grabar_registro = emufs_tipo3_grabar_registro;
- efs->borrar_registro = emufs_tipo3_borrar_registro;
+ /*efs->borrar_registro = emufs_tipo3_borrar_registro;*/
/* Guarda cabeceras propias. */
fwrite(&tam_bloque, sizeof(EMUFS_BLOCK_SIZE), 1, fp);
- fwrite(&tam_reg, sizeof(EMUFS_REG_SIZE), 1, fp);
-
+ fwrite(&tam_reg, sizeof(EMUFS_REG_SIZE), 1, fp);
break;
}
return efs;
}
+/* Realiza la apertura de un archivo dado, identifica el tipo de archivo y devuelve la estructura de handling. */
EMUFS *emufs_abrir(const char *filename)
{
EMUFS *efs;
case T2:
break;
case T3:
- if (!fread(&(efs->tam_bloque), sizeof(EMUFS_BLOCK_SIZE), 1, fp)) {
+ if ((!fread(&(efs->tam_bloque), sizeof(EMUFS_BLOCK_SIZE), 1, fp)) ||
+ (!fread(&(efs->tam_reg), sizeof(EMUFS_REG_SIZE), 1, fp)))
+ {
free(efs->nombre);
free(efs);
fclose(fp);
return NULL;
- }
- /* FIXME no falta leer el tamaño del registro???? */
+ }
efs->leer_bloque = emufs_tipo3_leer_bloque;
efs->leer_registro = emufs_tipo3_leer_registro;
efs->grabar_registro = emufs_tipo3_grabar_registro;
- efs->borrar_registro = emufs_tipo3_borrar_registro;
+ /*efs->borrar_registro = emufs_tipo3_borrar_registro;*/
break;
}
return efs;
}
+/* Objetivo: Rutina llamada al destruir la aplicacion para librerar */
int emufs_destruir(EMUFS *e)
{
if (e == NULL) return 1;
return 0;
}
+/* Visualiza espacios libres de un archivo?? */
int ver_archivo_FS(EMUFS *emu)
{
FILE *f_block_free;
}
fread(®,sizeof(reg),1,f_block_free);
while ( !feof(f_block_free) ){
- printf(" Bloque = %d Espacio libre = %d\n",reg.block, reg.free_space);
+ printf(" Bloque = %li Espacio libre = %li\n",reg.n_Marker, reg.n_FreeSpace);
fread(®,sizeof(reg),1,f_block_free);
}
f_block_free = fopen(name_f_block_free, "r");
fread(&r, sizeof(EMUFS_IDX), 1, f_block_free);
while (!feof(f_block_free)) {
- printf("ID %ld en bloque %d\n", r.id_reg, r.block);
+ printf("ID %li en bloque %li\n", r.n_IdReg, r.n_Location);
fread(&r, sizeof(EMUFS_IDX), 1, f_block_free);
}
fclose(f_block_free);
typedef struct _emu_fs_t {
EMUFS_TYPE tipo;
EMUFS_BLOCK_SIZE tam_bloque; /**< Tamaño de bloque. 0 Si no tiene bloques */
+ EMUFS_REG_SIZE tam_reg; /**< Tamaño de registro. 0 Si son registros variables */
int (*leer_bloque)(struct _emu_fs_t*, EMUFS_BLOCK_ID, void*); /**< Método para leer un bloque */
int (*leer_registro)(struct _emu_fs_t*, EMUFS_REG_ID, void *, EMUFS_REG_SIZE); /**< Método para leer un registro */
EMUFS_REG_ID (*grabar_registro)(struct _emu_fs_t*, void*, EMUFS_REG_SIZE); /**< Método para grabar un registro */
- int (*borrar_registro)(struct _emu_fs_t*, EMUFS_REG_ID, unsigned long ); /**< Método para borrar un registro */ /* XXX QUE CATSO ES EL unsigned long ??? */
+ int (*borrar_registro)(struct _emu_fs_t*, EMUFS_REG_ID); /**< Método para borrar un registro */
char *nombre; /**< Nombre del archivo */
} EMUFS;
#include <string.h>
#include <unistd.h>
+/* Crea un archivo de Gaps o Espacio Libre en Bloque */
int emufs_fsc_crear(EMUFS* efs)
{
return emufs_crear_archivo_auxiliar(efs->nombre, EMUFS_FSC_EXT);
}
-int emufs_fsc_agregar(EMUFS *emu, EMUFS_BLOCK_ID num_bloque, EMUFS_FREE fs)
+/* Agrega un registro al archivo de espacios libres. */
+int emufs_fsc_agregar(EMUFS *emu, EMUFS_BLOCK_ID n_Marker, EMUFS_FREE n_FreeSpace)
{
FILE *f_fsc;
EMUFS_FSC reg;
strcpy(name_f_fsc,emu->nombre);
strcat(name_f_fsc, EMUFS_FSC_EXT);
- /*cargo el registro*/
- reg.block = num_bloque;
- reg.free_space = fs;
- /*lo guardo en el archivo al final "a+"*/
+ /* Cargo el registro */
+ reg.n_Marker = n_Marker;
+ reg.n_FreeSpace = n_FreeSpace;
+
+ /* Lo guardo en el archivo al final "a+"*/
if ( (f_fsc = fopen(name_f_fsc,"a+"))==NULL ) return -1;
fwrite(®,sizeof(EMUFS_FSC),1,f_fsc);
fclose(f_fsc);
return 0;
}
-/* busca el bloque y le resta fs de espacio libre */
-int emufs_fsc_actualizar(EMUFS *emu, EMUFS_BLOCK_ID num_bloque, EMUFS_FREE fs)
+/* Objetivo: Actualiza un registro de espacio libre de acorde al FType */
+int emufs_fsc_actualizar(EMUFS *emu, EMUFS_BLOCK_ID n_Marker, EMUFS_FREE n_FreeSpace)
{
FILE *f_fsc;
EMUFS_FSC reg;
strcpy(name_f_fsc,emu->nombre);
strcat(name_f_fsc, EMUFS_FSC_EXT);
- /*busco el bloque que modifique*/
- if ( (f_fsc = fopen(name_f_fsc,"r+")) == NULL) return -1;
+ /*busco el bloque o gap que modifique*/
+ if ( (f_fsc = fopen(name_f_fsc,"r+")) == NULL) return -1;
while ( !feof(f_fsc) ){
if ( fread(®,sizeof(EMUFS_FSC),1,f_fsc) != 1) continue;
- if ( reg.block == num_bloque ){
- reg.free_space = fs;
+ if ( reg.n_Marker == n_Marker ){
+ reg.n_FreeSpace = n_FreeSpace;
fseek(f_fsc,-sizeof(EMUFS_FSC),SEEK_CUR);
fwrite(®,sizeof(EMUFS_FSC),1,f_fsc);
break;
return 0;
}
-/* me devuelve el ID del bloque donde quepa un registro, y guarda en fs el espacio libre que queda en el bloque */
-EMUFS_BLOCK_ID emufs_fsc_buscar_lugar(EMUFS *emu, EMUFS_FREE tam, EMUFS_FREE *fs)
+/* Me devuelve el ID del bloque u Offset del Gap donde quepa un registro, y guarda en n_FreeSpace el espacio libre actualizado */
+EMUFS_BLOCK_ID emufs_fsc_buscar_lugar(EMUFS *emu, EMUFS_FREE n_RegSize, EMUFS_FREE *n_FreeSpace)
{
FILE *f_fsc;
EMUFS_FSC reg;
char name_f_fsc[255];
+ unsigned short int b_Found = 0;
strcpy(name_f_fsc,emu->nombre);
strcat(name_f_fsc, EMUFS_FSC_EXT);
if ( (f_fsc = fopen(name_f_fsc,"r"))==NULL ) return -1;
- /* Inicializo la estructura para evitar que si el archivo esta vacio
- * el resultado sea correcto
- */
- reg.block = -1;
- *fs = emu->tam_bloque;
- while( !feof(f_fsc) ){
+ /* Inicializamos la estructura para devolver algun valor en concreto */
+ /* en caso de que no se halle un espacio libre apropiado */
+ while(!feof(f_fsc) && !b_Found){
if (fread(®,sizeof(EMUFS_FSC),1,f_fsc) != 1) continue;
- if (reg.free_space >= tam) {
- break;
- } else {
- reg.block = -1;
- *fs = emu->tam_bloque;
- }
+ if (reg.n_FreeSpace >= n_RegSize) b_Found = 1;
}
+ /* Si salio por error o por fin de archivo y no encontro space... */
+ if (!b_Found) {
+ reg.n_Marker = -1;
+ *n_FreeSpace = emu->tam_bloque;
+ }
+ else *n_FreeSpace = reg.n_FreeSpace;
+
fclose(f_fsc);
- if (reg.block != -1)
- *fs = reg.free_space;
- return reg.block;
+ return reg.n_Marker;
}
-EMUFS_FREE emufs_fsc_get_fs(EMUFS *emu, EMUFS_BLOCK_ID num_bloque)
+/* Devuelve el espacio libre de un Bloque o Gap dado */
+EMUFS_FREE emufs_fsc_get_fs(EMUFS *emu, EMUFS_BLOCK_ID n_Marker)
{
FILE *f_fsc;
EMUFS_FSC reg;
strcpy(name_f_fsc,emu->nombre);
strcat(name_f_fsc, EMUFS_FSC_EXT);
+ /* Busco el Bloque o Gap pedido y obtengo su espacio libre */
if ( (f_fsc = fopen(name_f_fsc,"r"))==NULL ) return -1;
-
while ( !feof(f_fsc) ){
if ( fread(®,sizeof(EMUFS_FSC),1,f_fsc) != 1 ) continue;
- if ( reg.block == num_bloque )
+ if ( reg.n_Marker == n_Marker )
break;
}
fclose(f_fsc);
- return reg.free_space;
+ return reg.n_FreeSpace;
}
-
#define EMUFS_FSC_EXT ".fsc"
typedef struct emufs_fsc_t {
- int block;
- int free_space;
+ unsigned long int n_Marker;
+ unsigned long int n_FreeSpace;
} EMUFS_FSC;
int emufs_fsc_crear(EMUFS*);
-
int emufs_fsc_agregar(EMUFS *, EMUFS_BLOCK_ID, EMUFS_FREE);
-
int emufs_fsc_actualizar(EMUFS *, EMUFS_BLOCK_ID, EMUFS_FREE);
-
EMUFS_BLOCK_ID emufs_fsc_buscar_lugar(EMUFS *, EMUFS_FREE, EMUFS_FREE *);
-
EMUFS_FREE emufs_fsc_get_fs(EMUFS *, EMUFS_BLOCK_ID);
#endif /* _EMUFS_FSC_H */
#include <strings.h>
#include <unistd.h>
+/* Objetivo: Realiza una apertura de un archivo indice y devuelve el handler. */
FILE* emufs_idx_abrir(EMUFS* efs, const char* mode)
{
FILE* f;
return f;
}
+/* Crea un archivo indice de registros */
int emufs_idx_crear(EMUFS *efs)
{
return emufs_crear_archivo_auxiliar(efs->nombre, EMUFS_IDX_EXT);
}
+/* Devuelve el mayor id de registro utilizado so far en el archivo de datos, revisando el indice. */
EMUFS_REG_ID emufs_idx_buscar_mayor_id(EMUFS *emu)
{
- int id, max = -1;
+ EMUFS_REG_ID n_IdReg, max = -1;
FILE *f_idx;
EMUFS_IDX reg;
char name_f_idx[255]; /* TODO usar malloc para no limitar el tamaño de nombre de archivo */
strcat(name_f_idx, EMUFS_IDX_EXT);
if ( (f_idx = fopen(name_f_idx,"r")) == NULL) return -1; /*ERROR*/
- id = -1;
+ n_IdReg = -1;
while ( !feof(f_idx) ){
/* Me aseguro de leer la cantidad de bytes correcta */
if (fread(®,sizeof(EMUFS_IDX),1,f_idx) != 1) continue;
- if ( reg.id_reg >= max )
- max = reg.id_reg;
+ if ( reg.n_IdReg >= max )
+ max = reg.n_IdReg;
}
- id = max+1;
+ n_IdReg = max+1;
fclose(f_idx);
- return id;
+ return n_IdReg;
}
-/*busca el registro ID en el archivo ".idx" y devuelve el nro de bloque en el que se encuentra*/
-EMUFS_BLOCK_ID emufs_idx_buscar_registro(EMUFS *emu, EMUFS_REG_ID ID)
+/* busca el registro ID en el archivo ".idx" y devuelve el nro de bloque en el que se encuentra */
+EMUFS_BLOCK_ID emufs_idx_buscar_registro(EMUFS *emu, EMUFS_REG_ID n_IdReg)
{
FILE* f_idx;
EMUFS_IDX reg;
char name_f_idx[255];
+ unsigned short int b_Found = 0;
+
strcpy(name_f_idx,emu->nombre);
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) ){
+
+ while (!feof(f_idx) && !b_Found){
if (fread(®,sizeof(EMUFS_IDX),1,f_idx) != 1) continue;
- if ( reg.id_reg == ID ){
- break;
- }
+ if (reg.n_IdReg == n_IdReg) b_Found = 1;
}
fclose(f_idx);
- return reg.block;
+
+ /* Sino lo encontre devuelvo uno, otherwise el offset o bloque */
+ if (!b_Found) return(-1);
+ else return(reg.n_Location);
}
/* agrega un registro al final del archivo */
-int emufs_idx_agregar(EMUFS *emu, EMUFS_BLOCK_ID num_bloque, EMUFS_REG_ID id)
+int emufs_idx_agregar(EMUFS *emu, EMUFS_BLOCK_ID n_Location, EMUFS_REG_ID n_IdReg)
{
FILE *f_idx;
EMUFS_IDX reg;
if ( (f_idx = fopen(name_f_idx,"a+"))==NULL ) return -1;
- reg.block = num_bloque;
- reg.id_reg = id;
+ /* Note: Location = Bloque para Tipo 1 y 3, Offset para Tipo 2 */
+ reg.n_Location = n_Location;
+ reg.n_IdReg = n_IdReg;
fwrite(®,sizeof(EMUFS_IDX),1,f_idx);
fclose(f_idx);
return 0;
}
-int emufs_idx_borrar(EMUFS *emu, EMUFS_REG_ID ID)
+/* Borra un registro del indice dada la eliminacion fisica de un reg */
+int emufs_idx_borrar(EMUFS *emu, EMUFS_REG_ID n_IdReg)
{
FILE *f_idx;
EMUFS_IDX reg, buffer;
while ( !feof(f_idx) ){
/*busco cual tengo que borrar*/
if ( fread(®, sizeof(EMUFS_IDX), 1, f_idx) != 1 ) continue;
- if ( reg.id_reg == ID )
+ if ( reg.n_IdReg == n_IdReg )
break;
}
/* me paro en el que tengo que borrar */
actual = fseek(f_idx, -sizeof(EMUFS_IDX), SEEK_CUR);
- /*actual = ftell(f_idx); /* Guardo la posicion actual */
+ /*actual = ftell(f_idx);*/ /* Guardo la posicion actual */
printf("ACTUAL = %ld\n", actual/sizeof(EMUFS_IDX));
fseek(f_idx, 0, SEEK_END); /* me voy al final */
final = ftell(f_idx); /* veo cuando ocupa el archivo */
#define EMUFS_IDX_EXT ".idx"
typedef struct emufs_idx_t {
- int block;
- long int id_reg;
+ unsigned long int n_IdReg;
+ unsigned long int n_Location;
} EMUFS_IDX;
FILE* emufs_idx_abrir(EMUFS*, const char*);
-
int emufs_idx_crear(EMUFS*);
-
EMUFS_REG_ID emufs_idx_buscar_mayor_id(EMUFS *);
-
EMUFS_BLOCK_ID emufs_idx_buscar_registro(EMUFS *, EMUFS_REG_ID);
-
int emufs_idx_agregar(EMUFS *, EMUFS_BLOCK_ID, EMUFS_REG_ID);
-
int emufs_idx_borrar(EMUFS *emu, EMUFS_REG_ID);
#endif /* _EMUFS_IDX_H */
efs->leer_bloque = emufs_tipo1_leer_bloque;
efs->leer_registro = emufs_tipo1_leer_registro;
efs->grabar_registro = emufs_tipo1_grabar_registro;
- efs->borrar_registro = emufs_tipo1_borrar_registro;
-
+ /*efs->borrar_registro = emufs_tipo1_borrar_registro;*/
return 0;
}
{
return -1; /* FIXME Error */
}
-
if (efs->leer_registro(efs, 0, registro1, 4) == -1) {
printf("No se pudo leer el registro 1.\n");
- return ;
+ return 1;
}
registro1[4] = '\0';
printf("Registro 1: %s\n", registro1);
emufs_destruir(efs);
return 0;
}
-
--- /dev/null
+/* vim: set noexpandtab tabstop=4 shiftwidth=4:
+ *----------------------------------------------------------------------------
+ * emufs
+ *----------------------------------------------------------------------------
+ * This file is part of emufs.
+ *
+ * emufs is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 2 of the License, or (at your option) any later
+ * version.
+ *
+ * emufs is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with emufs; if not, write to the Free Software Foundation, Inc., 59 Temple
+ * Place, Suite 330, Boston, MA 02111-1307 USA
+ *----------------------------------------------------------------------------
+ * Creado: Fri Apr 10 17:10:00 ART 2004
+ * Autores: Alan Kennedy <kennedya@3dgames.com.ar>
+ *----------------------------------------------------------------------------
+ *
+ * $Id: tipo3.c 85 2004-04-08 23:39:28Z sagar $
+ *
+ */
+
+/***************************************************************/
+/* Implementación del Tipo Archivo 2: Registros Variables, Sin */
+/* Bloques at all. */
+/***************************************************************/
+
+#include "tipo2.h"
+#include "idx.h"
+#include "fsc.h"
+#include "did.h"
+
+/**********************************************************************/
+/* EMUFS_REG_ID emufs_tipo2_grabar_registro(EMUFS *emu, void *ptr, */
+/* EMUFS_REG_SIZE n_RegSize) */
+/* Objetivo: Grabar un registro en un archivo del Tipo 2. */
+/* Parametros: EMUFS *emu // Struct con handlers + info del openfile. */
+/* void *ptr // Puntero al buffer (registro) a guardar */
+/* EMUFS_REG_SIZE n_RegSize // Size del reg en cuestion */
+/**********************************************************************/
+EMUFS_REG_ID emufs_tipo2_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE n_RegSize)
+{
+ EMUFS_REG_ID n_IdReg;
+ EMUFS_FREE n_FreeSpace;
+ EMUFS_OFFSET n_WrtOffset,n_RegOffset;
+ FILE *f_data;
+ char name_f[255];
+
+ /* Armamos el filename del archivo de datos */
+ strcpy(name_f,emu->nombre);
+ strcat(name_f,".dat");
+
+ if ( (f_data = fopen(name_f,"a+"))==NULL ) return -1; /*ERROR*/
+
+ /* Obtengo un offset en donde iniciar la escritura de mi registro */
+ /* de manera segura (habra espacio suficiente) */
+ n_WrtOffset = emufs_fsc_buscar_lugar(emu, n_RegSize, &n_FreeSpace);
+ printf("tipo2.c >> Searching FSC: Offset = %lu FSpace: %lu\n", n_WrtOffset, n_FreeSpace);
+
+ /* Si no encontre un gap, entonces escribo el registro al final */
+ if (n_WrtOffset == -1) {
+
+ /* Obtengo un ID libre para el registro y luego grabo a disco */
+ n_IdReg = emufs_tipo2_get_id(emu);
+ fseek(f_data, 0, SEEK_END);
+ n_RegOffset = ftell(f_data);
+
+ /* Escribo [RegId]|[RegSize]|[RegData] */
+ fwrite(&n_IdReg,sizeof(int),1,f_data);
+ fwrite(&n_RegSize,sizeof(int),1,f_data);
+ fwrite(ptr,n_RegSize,1,f_data);
+
+ /* Bye */
+ printf("Tipo2.c >> RegNr: %lu inserted at Offset: %lu\n",n_IdReg,n_RegOffset);
+ fclose(f_data);
+
+ } else {
+
+ }
+
+ /* Finalmente, actualizamos el indice de registros (offsets) */
+ emufs_idx_agregar(emu,n_IdReg,n_RegOffset);
+
+ return n_IdReg;
+}
+
+/**********************************************************************/
+/* int emufs_tipo2_borrar_registro(EMUFS *emu, EMUFS_REG_ID n_IdReg) */
+/* Objetivo: Borra un registro determinado y actualiza los archivos */
+/* de Posicion Relativa (Indice-Offset) y el de Gaps */
+/* Parametros: EMUFS *emu // Struct con handlers + info del openfile. */
+/* EMUFS_REG_ID n_IdReg // Id del registro a eliminar. */
+/**********************************************************************/
+int emufs_tipo2_borrar_registro(EMUFS *emu, EMUFS_REG_ID n_IdReg)
+{
+ FILE *f_data;
+ char name_f[255];
+ EMUFS_OFFSET n_RegOffset;
+
+ /* Armamos el filename del archivo de datos */
+ strcpy(name_f,emu->nombre);
+ strcat(name_f,".dat");
+
+ /* Obtenemos el tamanio del bloque */
+ if ((n_RegOffset = emufs_idx_buscar_registro(emu,n_IdReg)) != -1)
+ printf("tipo2.c >> Searching Reg %lu...Found at offset: %lu\n",n_IdReg,n_RegOffset);
+ else
+ return -1;
+
+ if ((f_data = fopen(name_f,"a+")) == NULL) return -1; /* ERROR */
+ fclose(f_data);
+
+ return(0);
+}
+
+/**********************************************************************/
+/* EMUFS_REG_ID emufs_tipo2_get_id(EMUFS *emu) */
+/* Objetivo: Devuelve un Id apropiado y disponible para un nuevo reg */
+/* Parametros: EMUFS *emu // Struct con handlers + info del openfile. */
+/**********************************************************************/
+EMUFS_REG_ID emufs_tipo2_get_id(EMUFS *emu)
+{
+ EMUFS_REG_ID n_RegId;
+
+ /* Si no se hallo un id libre, entonces debo usar el maximo + 1 */
+ if ( (n_RegId = emufs_did_get_last(emu)) == -1 )
+ n_RegId = emufs_idx_buscar_mayor_id(emu);
+
+ return n_RegId;
+}
--- /dev/null
+/* vim: set noexpandtab tabstop=4 shiftwidth=4:
+ *----------------------------------------------------------------------------
+ * emufs
+ *----------------------------------------------------------------------------
+ * This file is part of emufs.
+ *
+ * emufs is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 2 of the License, or (at your option) any later
+ * version.
+ *
+ * emufs is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with emufs; if not, write to the Free Software Foundation, Inc., 59 Temple
+ * Place, Suite 330, Boston, MA 02111-1307 USA
+ *----------------------------------------------------------------------------
+ * Creado: Fri Apr 10 17:10:00 ART 2004
+ * Autores: Alan Kennedy <kennedya@3dgames.com.ar>
+ *----------------------------------------------------------------------------
+ */
+
+/***************************************************************/
+/* Implementación del Tipo Archivo 2: Registros Variables, Sin */
+/* Bloques at all. */
+/***************************************************************/
+
+#ifndef _EMUFS_TIPO2_H_
+#define _EMUFS_TIPO2_H_
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include "emufs.h"
+
+EMUFS_REG_ID emufs_tipo2_grabar_registro(EMUFS *, void *, EMUFS_REG_SIZE);
+int emufs_tipo2_borrar_registro(EMUFS*, EMUFS_REG_ID);
+EMUFS_REG_ID emufs_tipo2_get_id(EMUFS *);
+
+/* int emufs_tipo2_leer_registro(EMUFS *, EMUFS_REG_ID , void *, EMUFS_REG_SIZE);
+ int emufs_tipo2_buscar_registro(EMUFS *, int); */
+
+#endif /* _EMUFS_TIPO2_H_ */
int main(int argc, char *argv[])
{
EMUFS *fp;
- int n1, n2, n3, n4, n5, n6, n7, n8;
+ EMUFS_REG_ID n1, n2, n3, n4, n5, n6, n7, n8;
char a[100];
char b[100];
char c[100];
n6 = fp->grabar_registro(fp, g, 100);
n7 = fp->grabar_registro(fp, h, 100);
n8 = fp->grabar_registro(fp, i, 100);*/
- printf("ID0 = %d\n", n1);
- printf("ID1 = %d\n", n2);
- printf("ID2 = %d\n", n3);
- printf("ID3 = %d\n", n4);
- printf("ID4 = %d\n", n5);
- printf("ID5 = %d\n", n6);
- printf("ID6 = %d\n", n7);
+ printf("ID0 = %lu\n", n1);
+ printf("ID1 = %lu\n", n2);
+ printf("ID2 = %lu\n", n3);
+ printf("ID3 = %lu\n", n4);
+ printf("ID4 = %lu\n", n5);
+ printf("ID5 = %lu\n", n6);
+ printf("ID6 = %lu\n", n7);
-ver_archivo_FS(fp);
+ ver_archivo_FS(fp);
/*fp->borrar_registro(fp, n4, 100);
fp->borrar_registro(fp, n2, 100);
fp->borrar_registro(fp, n6, 100);*/
- fp->borrar_registro(fp, n1, 100);
- printf("borre el registro de id = %d\n",n1);
+ /*fp->borrar_registro(fp, n1, 100);*/
+ /*printf("borre el registro de id = %d\n",n1);*/
fp->leer_registro(fp, n2, b, 100);
printf("Recuperado : %s\n", b);
projects / z.facultad / 75.06 / emufs.git / commitdiff