EMUFS_COMMON=emufs.o tipo1.o tipo3.o idx.o did.o fsc.o
-all: libemufs.a tipo3_main
+all: libemufs.a tipo1_test tipo3_main
+
+tipo1_test: tipo1_test.o $(EMUFS_COMMON)
tipo3_main: tipo3_main.o $(EMUFS_COMMON)
return emufs_crear_archivo_auxiliar(efs->nombre, EMUFS_DID_EXT);
}
-int emufs_did_get_last(EMUFS *emu)
+EMUFS_REG_ID emufs_did_get_last(EMUFS *emu)
{
FILE * f_did;
int id, offset;
}
/*agrego un elemento al archivo */
-int emufs_did_agregar(EMUFS *emu, int ID)
+int emufs_did_agregar(EMUFS *emu, EMUFS_REG_ID ID)
{
FILE *f_did;
char name_f_did[255];
int emufs_did_crear(EMUFS*);
-int emufs_did_get_last(EMUFS *);
+EMUFS_REG_ID emufs_did_get_last(EMUFS *);
-int emufs_did_agregar(EMUFS *, int);
+int emufs_did_agregar(EMUFS *, EMUFS_REG_ID);
#endif /* _EMUFS_DID_H */
}
-EMUFS *emufs_crear(const char *filename, char tipo, unsigned long tam_bloque, unsigned long tam_reg)
+EMUFS *emufs_crear(const char *filename, EMUFS_TYPE tipo,
+ EMUFS_BLOCK_SIZE tam_bloque, EMUFS_REG_SIZE tam_reg)
{
char name[255];
FILE *fp;
EMUFS *efs;
- /* Si no es un tipo conocido, sale */
+ /* Si no es un tipo conocido, sale. */
if ((tipo != T1) && (tipo != T2) && (tipo != T3)) {
return NULL;
}
/* Inicializa parámetros comunes. */
efs = (EMUFS*) malloc(sizeof(EMUFS));
- efs->tipo = tipo;
+ if (efs == NULL) {
+ return NULL;
+ }
+ efs->tipo = tipo;
efs->tam_bloque = tam_bloque;
- efs->nombre = str_dup(filename);
+ efs->nombre = str_dup(filename);
/* Abre archivo de datos. */
strcpy(name, filename);
}
/* Guarda cabecera común. */
- fwrite(&tipo, sizeof(char), 1, fp); /* FIXME no debería ser sizeof(EMUFS_TYPE) ? */
+ fwrite(&tipo, sizeof(EMUFS_TYPE), 1, fp);
/* Crea archivo de índice. */
if (emufs_idx_crear(efs)) {
switch (tipo) {
case T1:
- /* Asigna punteros a funciones. */
- 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;
+ emufs_tipo1_inicializar(efs);
/* Guarda cabeceras propias. */
- fwrite(&tam_bloque, sizeof(unsigned long), 1, fp);
+ fwrite(&tam_bloque, sizeof(EMUFS_BLOCK_SIZE), 1, fp);
break;
efs->borrar_registro = emufs_tipo3_borrar_registro;
/* Guarda cabeceras propias. */
- fwrite(&tam_bloque, sizeof(unsigned int), 1, fp);
- fwrite(&tam_reg, sizeof(unsigned int), 1, fp);
+ fwrite(&tam_bloque, sizeof(EMUFS_BLOCK_SIZE), 1, fp);
+ fwrite(&tam_reg, sizeof(EMUFS_REG_SIZE), 1, fp);
break;
EMUFS *emufs_abrir(const char *filename)
{
- EMUFS *tmp;
+ EMUFS *efs;
char name[255];
char tipo;
FILE *fp;
/* Trato de determinar el tipo de archivo */
fp = fopen(name, "r");
if (fp == NULL) return NULL;
- fread(&tipo, sizeof(char), 1, fp);
- if ((tipo < 0) || (tipo > 2)) {
+ fread(&tipo, sizeof(EMUFS_TYPE), 1, fp);
+
+ /* Si no es un tipo conocido, sale. */
+ if ((tipo != T1) && (tipo != T2) && (tipo != T3)) {
fclose(fp);
return NULL;
}
- tmp = (EMUFS *)malloc(sizeof(EMUFS));
- if (tmp == NULL) {
+ /* Inicializa parámetros comunes. */
+ efs = (EMUFS*) malloc(sizeof(EMUFS));
+ if (efs == NULL) {
fclose(fp);
return NULL;
}
+ efs->tipo = tipo;
+ efs->nombre = str_dup(filename);
switch (tipo) {
case T1:
- break;
+ emufs_tipo1_inicializar(efs);
+ /* Lee cabeceras propias. */
+ if (!fread(&(efs->tam_bloque), sizeof(EMUFS_BLOCK_SIZE), 1, fp)) {
+ free(efs->nombre);
+ free(efs);
+ fclose(fp);
+ return NULL;
+ }
+ break;
case T2:
- break;
+ break;
case T3:
- tmp->tipo = tipo;
- fread(&tmp->tam_bloque, sizeof(int), 1, fp);
- tmp->leer_bloque = emufs_tipo3_leer_bloque;
- tmp->leer_registro = emufs_tipo3_leer_registro;
- tmp->grabar_registro = emufs_tipo3_grabar_registro;
- tmp->borrar_registro = emufs_tipo3_borrar_registro;
- tmp->nombre = str_dup(filename);
+ if (!fread(&(efs->tam_bloque), sizeof(EMUFS_BLOCK_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;
+ break;
}
fclose(fp);
- return tmp;
+ return efs;
}
int emufs_destruir(EMUFS *e)
T3 /**< Archivo de bloque parametrizado y registro fijo. */
} EMUFS_TYPE;
+/** Tipo de identificador de registro. */
+typedef unsigned long EMUFS_REG_ID;
+
+/** Tipo de tamaño de registro. */
+typedef unsigned long EMUFS_REG_SIZE;
+
+/** Tipo de identificador de bloque. */
+typedef unsigned long EMUFS_BLOCK_ID;
+
+/** Tipo de tamaño de bloque. */
+typedef unsigned long EMUFS_BLOCK_SIZE;
+
+/** Tipo de espacio libre. */
+typedef unsigned long EMUFS_FREE;
+
+/** Tipo de offset. */
+typedef unsigned long EMUFS_OFFSET;
+
/** Tipo Abstracto para menajo de archivos.
*
* Esta estructura es utilizada para acceder a cualquier tipo de archivo.
*/
typedef struct _emu_fs_t {
EMUFS_TYPE tipo;
- unsigned long tam_bloque; /**< Tamaño de bloque. 0 Si no tiene bloques */
- int (*leer_bloque)(struct _emu_fs_t *, int, void *); /**< Método para leer un bloque */
- int (*leer_registro)(struct _emu_fs_t *, int, void *, unsigned long); /**< Método para leer un registro */
- int (*grabar_registro)(struct _emu_fs_t *, void *, unsigned long ); /**< Método para grabar un registro */
- int (*borrar_registro)(struct _emu_fs_t *, int, unsigned long ); /**< Método para borrar un registro */
+ EMUFS_BLOCK_SIZE tam_bloque; /**< Tamaño de bloque. 0 Si no tiene bloques */
+ 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 ??? */
char *nombre; /**< Nombre del archivo */
} EMUFS;
/** Crea un nuevo archivo EMUFS.
*
- * Un archivo EMUFS está compuesto por 4 archivos a nivel del sistema operativo.
- * Un archivo principal con extensión .dat y 3 archivos auxiliares para manejo interno.
+ * Un archivo EMUFS está compuesto por 4 archivos a nivel del SO.
+ * Un archivo principal con extensión .dat y 3 archivos auxiliares para
+ * manejo interno.
*
- * El parámetro filename que recive esta función en el nombre virtual que se utilizará, ya
- * que las extensiones serán puestas automáticamente for EMUFS.
+ * El parámetro filename que recive esta función en el nombre virtual que se
+ * utilizará, ya que las extensiones serán puestas automáticamente for EMUFS.
*
* Un ejemplo:
* \code
* EMUFS *fp emufs_crear("archivo", T3, 100, 100);
* \endcode
*
- * En el ejemplo anterior se tiene que nuestro filesystem virtual se llamará archivo.
+ * En el ejemplo anterior se tiene que nuestro filesystem virtual se llamará
+ * archivo.
*
- * Los últimos 2 parámetros serán ignorados si el tipo de archivo no utiliza dicho parámetro.
+ * Los últimos 2 parámetros serán ignorados si el tipo de archivo no utiliza
+ * dicho parámetro.
*
* \param filename Nombre del archivo virtual.
* \param tipo Tipo de archivo.
* \param tam_bloque Tamaño del bloque.
* \param tam_reg Tamaño del registro.
*/
-EMUFS *emufs_crear(const char *filename, char tipo, unsigned long tam_bloque, unsigned long tam_reg);
+EMUFS *emufs_crear(const char *filename, EMUFS_TYPE tipo,
+ EMUFS_BLOCK_SIZE tam_bloque, EMUFS_REG_SIZE tam_reg);
/** Abre un archivo EMUFS.
*
return emufs_crear_archivo_auxiliar(efs->nombre, EMUFS_FSC_EXT);
}
-int emufs_fsc_agregar(EMUFS *emu, int num_bloque, int fs)
+int emufs_fsc_agregar(EMUFS *emu, EMUFS_BLOCK_ID num_bloque, EMUFS_FREE fs)
{
FILE *f_fsc;
EMUFS_FSC reg;
}
/* busca el bloque y le resta fs de espacio libre */
-int emufs_fsc_actualizar(EMUFS *emu, int num_bloque, int fs)
+int emufs_fsc_actualizar(EMUFS *emu, EMUFS_BLOCK_ID num_bloque, EMUFS_FREE fs)
{
FILE *f_fsc;
EMUFS_FSC reg;
}
/* me devuelve el ID del bloque donde quepa un registro, y guarda en fs el espacio libre que queda en el bloque */
-int emufs_fsc_buscar_lugar(EMUFS *emu, unsigned long tam, int *fs)
+EMUFS_BLOCK_ID emufs_fsc_buscar_lugar(EMUFS *emu, EMUFS_FREE tam, EMUFS_FREE *fs)
{
FILE *f_fsc;
EMUFS_FSC reg;
return reg.block;
}
-int emufs_fsc_get_fs(EMUFS *emu, int num_bloque)
+EMUFS_FREE emufs_fsc_get_fs(EMUFS *emu, EMUFS_BLOCK_ID num_bloque)
{
FILE *f_fsc;
EMUFS_FSC reg;
int emufs_fsc_crear(EMUFS*);
-int emufs_fsc_agregar(EMUFS *, int, int);
+int emufs_fsc_agregar(EMUFS *, EMUFS_BLOCK_ID, EMUFS_FREE);
-int emufs_fsc_actualizar(EMUFS *, int, int);
+int emufs_fsc_actualizar(EMUFS *, EMUFS_BLOCK_ID, EMUFS_FREE);
-int emufs_fsc_buscar_lugar(EMUFS *, unsigned long, int *);
+EMUFS_BLOCK_ID emufs_fsc_buscar_lugar(EMUFS *, EMUFS_FREE, EMUFS_FREE *);
-int emufs_fsc_get_fs(EMUFS *, int);
+EMUFS_FREE emufs_fsc_get_fs(EMUFS *, EMUFS_BLOCK_ID);
#endif /* _EMUFS_FSC_H */
return emufs_crear_archivo_auxiliar(efs->nombre, EMUFS_IDX_EXT);
}
-int emufs_idx_buscar_mayor_id(EMUFS *emu)
+EMUFS_REG_ID emufs_idx_buscar_mayor_id(EMUFS *emu)
{
int id, max = -1;
FILE *f_idx;
}
/*busca el registro ID en el archivo ".idx" y devuelve el nro de bloque en el que se encuentra*/
-int emufs_idx_buscar_registro(EMUFS *emu, int ID)
+EMUFS_BLOCK_ID emufs_idx_buscar_registro(EMUFS *emu, EMUFS_REG_ID ID)
{
FILE* f_idx;
EMUFS_IDX reg;
}
/* agrega un registro al final del archivo */
-int emufs_idx_agregar(EMUFS *emu, int num_bloque, int ID_aux)
+int emufs_idx_agregar(EMUFS *emu, EMUFS_BLOCK_ID num_bloque, EMUFS_REG_ID id)
{
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_aux;
+ reg.id_reg = id;
fwrite(®,sizeof(EMUFS_IDX),1,f_idx);
fclose(f_idx);
return 0;
}
-int emufs_idx_borrar(EMUFS *emu, int ID)
+int emufs_idx_borrar(EMUFS *emu, EMUFS_REG_ID ID)
{
FILE *f_idx;
EMUFS_IDX reg, buffer;
int emufs_idx_crear(EMUFS*);
-int emufs_idx_buscar_mayor_id(EMUFS *);
+EMUFS_REG_ID emufs_idx_buscar_mayor_id(EMUFS *);
-int emufs_idx_buscar_registro(EMUFS *, int);
+EMUFS_BLOCK_ID emufs_idx_buscar_registro(EMUFS *, EMUFS_REG_ID);
-int emufs_idx_agregar(EMUFS *, int , int);
+int emufs_idx_agregar(EMUFS *, EMUFS_BLOCK_ID, EMUFS_REG_ID);
-int emufs_idx_borrar(EMUFS *emu, int ID);
+int emufs_idx_borrar(EMUFS *emu, EMUFS_REG_ID);
#endif /* _EMUFS_IDX_H */
*/
#include "tipo1.h"
+#include "idx.h"
+#include "fsc.h"
+#include "did.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
-#include <malloc.h>
-int emufs_tipo1_leer_registro(EMUFS* efs, int reg_id, void* reg_ptr, unsigned long reg_size)
+int emufs_tipo1_inicializar(EMUFS* efs)
+{
+ /* Asigna punteros a funciones. */
+ 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;
+
+ return 0;
+}
+
+int emufs_tipo1_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id, void* reg_ptr,
+ EMUFS_REG_SIZE reg_size)
{
- int block_id; /* id del bloque en donde esta el registro a leer */
char* block; /* bloque leido (en donde está el registro a leer) */
- ptrdiff_t offset; /* offset del bloque a leido */
- unsigned long curr_reg_size; /* tamaño del registro leido secuencialmente */
- int curr_reg_id; /* id del registro leido secuencialmente */
+ EMUFS_BLOCK_ID block_id; /* id del bloque en donde esta el registro a leer */
+ EMUFS_BLOCK_SIZE offset; /* offset del bloque leido */
+ EMUFS_REG_SIZE curr_reg_size; /* tamaño del registro leido secuencialmente */
+ EMUFS_REG_ID curr_reg_id; /* id del registro leido secuencialmente */
block_id = emufs_idx_buscar_registro(efs, reg_id);
block = (char*) malloc(efs->tam_bloque);
offset = 0;
do {
/* Copio el id del registro de la cabecera. */
- memcpy(&curr_reg_id, block + offset, sizeof(int));
- offset += sizeof(int);
+ memcpy(&curr_reg_id, block + offset, sizeof(EMUFS_REG_ID));
+ offset += sizeof(EMUFS_REG_ID);
/* Copio el tamaño del registro de la cabecera. */
- memcpy(&curr_reg_size, block + offset, sizeof(unsigned long));
- offset += sizeof(unsigned long);
+ memcpy(&curr_reg_size, block + offset, sizeof(EMUFS_REG_SIZE));
+ offset += sizeof(EMUFS_REG_SIZE);
if (curr_reg_id == reg_id) {
/* XXX Posible checkeo de reg_size == curr_reg_size */
memcpy(reg_ptr, block + offset, curr_reg_size);
return 0;
}
-int emufs_tipo1_leer_bloque(EMUFS *emu, int ID, void* ptr)
+int emufs_tipo1_leer_bloque(EMUFS* efs, EMUFS_BLOCK_ID block_id, void *block)
+{
+ FILE* file;
+ char name_f[255];
+
+ strcpy(name_f,efs->nombre);
+ strcat(name_f,".dat");
+
+ if ( (file = fopen(name_f,"r"))==NULL ) {
+ return -1; /* FIXME ERROR */
+ }
+ fseek(file,
+ sizeof(EMUFS_TYPE) + /* Cabecera tipo */
+ sizeof(EMUFS_BLOCK_SIZE), /* Cabecera tamaño de bloque */
+ SEEK_SET);
+ /* FIXME: verificar que no se pase de fin de archivo*/
+ fseek(file, block_id * efs->tam_bloque, SEEK_CUR);
+ if (fread(block, efs->tam_bloque, 1, file) != 1) {
+ fclose(file);
+ return -1;
+ }
+
+ fclose(file);
+ return 0;
+}
+
+EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* emu, void* ptr,
+ EMUFS_REG_SIZE reg_size)
{
return -1; /* FIXME Error */
}
-int emufs_tipo1_grabar_registro(EMUFS *emu, void *ptr, unsigned long tam)
+/*Graba un bloque en el archivo*/
+int emufs_tipo1_grabar_bloque(EMUFS *emu, void *ptr, EMUFS_BLOCK_ID num_bloque)
{
return -1; /* FIXME Error */
}
/*Busco en el archivo de Id`s un Id valido para un nuevo registro*/
-int emufs_tipo1_get_id(EMUFS *emu)
+EMUFS_REG_ID emufs_tipo1_get_id(EMUFS *emu)
{
return -1; /* FIXME Error */
}
-/*Graba un bloque en el archivo*/
-int emufs_tipo1_grabar_bloque(EMUFS *emu, void *ptr, int num)
+/*borra un registro de un bloque y acomoda los registros que quedan*/
+int emufs_tipo1_buscar_registro(EMUFS *emu, EMUFS_REG_ID id_reg)
{
return -1; /* FIXME Error */
}
-/*borra un registro de un bloque y acomoda los registros que quedan*/
-int emufs_tipo1_borrar_registro(EMUFS *emu, int ID, unsigned long tam_reg)
+int emufs_tipo1_borrar_registro(EMUFS *emu, EMUFS_REG_ID id_reg,
+ EMUFS_REG_SIZE tam_reg)
{
return -1; /* FIXME Error */
}
+
#define _EMUFS_TIPO1_H_
#include "emufs.h"
-#include "did.h"
-#include "idx.h"
-#include "fsc.h"
-int emufs_tipo1_leer_registro(EMUFS *, int , void *, unsigned long);
+int emufs_tipo1_inicializar(EMUFS*);
-int emufs_tipo1_leer_bloque(EMUFS *, int , void *);
+/** Lee el registro \param id_reg y lo almacena en \param ptr */
+int emufs_tipo1_leer_registro(EMUFS *emu, EMUFS_REG_ID id_reg, void *ptr,
+ EMUFS_REG_SIZE tam_reg);
-int emufs_tipo1_grabar_registro(EMUFS *, void *, unsigned long );
+/** Lee el bloque \param num_bloque y lo almacena en \param ptr */
+int emufs_tipo1_leer_bloque(EMUFS *emu, EMUFS_BLOCK_ID num_bloque, void *ptr);
-int emufs_tipo1_grabar_bloque(EMUFS *, void *, int);
+/** Graba el registro apuntado por \param ptr en el archivo */
+EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* emu, void* ptr, EMUFS_REG_SIZE);
-int emufs_tipo1_get_id(EMUFS *);
+/** Graba el bloque apuntado por \param ptr en el archivo */
+int emufs_tipo1_grabar_bloque(EMUFS *emu, void *ptr, EMUFS_BLOCK_ID num_bloque);
-int emufs_tipo1_buscar_registro(EMUFS *, int);
+EMUFS_REG_ID emufs_tipo1_get_id(EMUFS *emu);
-int emufs_tipo1_buscar_lugar(EMUFS *, unsigned long , int *);
+int emufs_tipo1_buscar_registro(EMUFS *emu, EMUFS_REG_ID id_reg);
-int emufs_tipo1_borrar_registro(EMUFS*, int, unsigned long);
+int emufs_tipo1_borrar_registro(EMUFS *emu, EMUFS_REG_ID id_reg,
+ EMUFS_REG_SIZE tam_reg);
+/*
+int emufs_tipo1_buscar_lugar(EMUFS *emu, EMUFS_REG_SIZE tam_reg,
+ EMUFS_FREE *free_space);
+*/
#endif /* _EMUFS_TIPO1_H_ */
--- /dev/null
+#include "emufs.h"
+
+int main(int argc, char* argv[]) {
+ EMUFS* efs;
+ char registro1[5];
+ char registro2[6];
+ if (argc < 2) {
+ printf("Faltan argumentos! %s [nombre]\n", argv[0]);
+ return 1;
+ }
+ efs = emufs_abrir(argv[1]);
+ if (!efs) {
+ printf("No se pudo crear el EMUFS.\n");
+ return 1;
+ }
+ if (efs->leer_registro(efs, 1, registro1, 4) == -1) {
+ printf("No se pudo leer el registro 1.\n");
+ return ;
+ }
+ registro1[4] = '\0';
+ printf("Registro 1: %s\n", registro1);
+ if (efs->leer_registro(efs, 1, registro2, 5) == -1) {
+ printf("No se pudo leer el registro 2.\n");
+ return 1;
+ }
+ registro2[5] = '\0';
+ printf("Registro 2: %s\n", registro2);
+ emufs_destruir(efs);
+ return 0;
+}
+
#include "tipo3.h"
/** 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)
+int emufs_tipo3_leer_registro(EMUFS *emu, EMUFS_REG_ID ID, void *ptr,
+ EMUFS_REG_SIZE tam_reg)
{
char* bloque;
- int block, ID_aux;
- int iterador = 0;
+ EMUFS_BLOCK_ID block;
+ EMUFS_REG_ID ID_aux;
+ EMUFS_BLOCK_SIZE iterador = 0;
/*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*/
ID_aux = -1;
iterador = 0;
while ( iterador < emu->tam_bloque ) {
- memcpy(&ID_aux, bloque+iterador, sizeof(int));
- iterador += sizeof(int);
+ memcpy(&ID_aux, bloque+iterador, sizeof(EMUFS_REG_ID));
+ iterador += sizeof(EMUFS_REG_ID);
if ( ID_aux == ID ){
memcpy(ptr,bloque+iterador,tam_reg);
break;
}
/*leo el bloque "ID" del archivo que viene en "emu->nombre", y lo almaceno en "ptr"*/
-int emufs_tipo3_leer_bloque(EMUFS *emu, int ID, void* ptr)
+int emufs_tipo3_leer_bloque(EMUFS *emu, EMUFS_REG_ID ID, void* ptr)
{
FILE* file;
char name_f[255];
strcat(name_f,".dat");
if ( (file = fopen(name_f,"r"))==NULL ) return -1; /*ERROR*/
- fseek(file,sizeof(int)+sizeof(char)+sizeof(int),SEEK_SET);
+ fseek(file,sizeof(EMUFS_TYPE)+sizeof(EMUFS_BLOCK_SIZE)+sizeof(EMUFS_REG_SIZE),SEEK_SET);
/*FIXME: verificar que no se pase de fin de archivo*/
fseek(file,ID*emu->tam_bloque,SEEK_CUR);
if (fread(ptr,emu->tam_bloque,1,file)!=1) return -1;
return 0;
}
-int emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, unsigned long tam)
+EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE tam)
{
- int ID_aux, fs, num_bloque, cant;
+ EMUFS_REG_ID ID_aux;
+ EMUFS_FREE fs;
+ EMUFS_BLOCK_ID num_bloque;
+ EMUFS_BLOCK_SIZE cant;
FILE *file;
char name_f[255];
char* bloque;
/*tengo que buscar un ID valido para el nuevo registro*/
ID_aux = emufs_tipo3_get_id(emu);
/*grabo el id en el bloque*/
- memcpy(bloque,&ID_aux,sizeof(int));
+ memcpy(bloque,&ID_aux,sizeof(EMUFS_REG_ID));
/*grabo el registro en el bloque*/
- memcpy(bloque+sizeof(int),ptr,tam);
+ memcpy(bloque+sizeof(EMUFS_REG_ID),ptr,tam);
/* me paro al final del archivo */
fseek(file, 0, SEEK_END);
/* grabo el bloque en el final del archivo */
/*tengo que buscar la cantidad de bloques que existen*/
/*me paro al principio salteando el encabezado del archivo*/
fseek(file, 0, SEEK_END); /* Me paro al final */
+ /* FIXME FIXME FIXME FALTA TRADUCIR A EMUFS_XXXX */
cant = (ftell(file)-(sizeof(int)*2+sizeof(char))) / emu->tam_bloque;
cant--; /* Resto uno porque el numero de bloque debe empezar en 0 */
fclose(file);
num_bloque = cant;
/* grabo el nuevo registro en el archivo de espacios libres */
+ /* FIXME FIXME FIXME FALTA TRADUCIR A EMUFS_XXXX */
if ( emufs_fsc_agregar(emu, num_bloque, emu->tam_bloque - tam - sizeof(int)) != 0 ) {
free(bloque);
return -1;
/*tengo que buscar un ID valido para el nuevo registro*/
ID_aux = emufs_tipo3_get_id(emu);
/*grabo el id en el bloque*/
- memcpy(bloque+emu->tam_bloque-fs,&ID_aux,sizeof(int));
+ memcpy(bloque+emu->tam_bloque-fs,&ID_aux,sizeof(EMUFS_REG_ID));
/*grabo el registro en el bloque*/
- memcpy(bloque+emu->tam_bloque-fs+sizeof(int),ptr,tam);
+ memcpy(bloque+emu->tam_bloque-fs+sizeof(EMUFS_REG_ID),ptr,tam);
/*guardo el bloque en el archivo*/
if ( emufs_tipo3_grabar_bloque(emu, bloque, num_bloque) != 0) {
printf("error al grabar bloque\n");
return -1; /* se produjo un error */
}
/*actualizo el archivo de espacios libres*/
+ /* FIXME FIXME FIXME FALTA TRADUCIR A EMUFS_XXXX */
if ( emufs_fsc_actualizar(emu, num_bloque, fs - tam - sizeof(int)) != 0 ){
free(bloque);
return -1;
}
/*Busco en el archivo de Id`s un Id valido para un nuevo registro*/
-int emufs_tipo3_get_id(EMUFS *emu)
+EMUFS_REG_ID emufs_tipo3_get_id(EMUFS *emu)
{
- int id;
+ EMUFS_REG_ID id;
if ( (id = emufs_did_get_last(emu)) == -1 )
id = emufs_idx_buscar_mayor_id(emu);
}
/*Graba un bloque en el archivo*/
-int emufs_tipo3_grabar_bloque(EMUFS *emu, void *ptr, int num)
+int emufs_tipo3_grabar_bloque(EMUFS *emu, void *ptr, EMUFS_BLOCK_ID num)
{
FILE* file;
char name_f[255];
}
/*borra un registro de un bloque y acomoda los registros que quedan*/
-int emufs_tipo3_borrar_registro(EMUFS *emu, int ID, unsigned long tam_reg)
+int emufs_tipo3_borrar_registro(EMUFS *emu, EMUFS_REG_ID ID, EMUFS_REG_SIZE tam_reg)
{
- int num_bloque, ptr_elim, ptr_mov, ID_aux, fs;
+ EMUFS_BLOCK_SIZE num_bloque;
+ EMUFS_BLOCK_SIZE ptr_elim;
+ EMUFS_BLOCK_SIZE ptr_mov;
+ EMUFS_REG_ID ID_aux;
+ EMUFS_FREE fs;
char *bloque;
num_bloque = emufs_idx_buscar_registro(emu, ID);
/*apunto al registro que voy a eliminar*/
ptr_elim = 0;
while ( ptr_elim < emu->tam_bloque ){
- memcpy(&ID_aux, bloque+ptr_elim, sizeof(int));
+ memcpy(&ID_aux, bloque+ptr_elim, sizeof(EMUFS_REG_ID));
if ( ID_aux == ID )
break;
- ptr_elim += tam_reg + sizeof(int);
+ ptr_elim += tam_reg + sizeof(EMUFS_REG_ID);
}
/*apunto al registro que voy a mover*/
- ptr_mov = ptr_elim + tam_reg + sizeof(int);
+ ptr_mov = ptr_elim + tam_reg + sizeof(EMUFS_REG_ID);
while ( ptr_mov < emu->tam_bloque ){
- memcpy(bloque+ptr_elim, bloque+ptr_mov, sizeof(int)+tam_reg);
+ memcpy(bloque+ptr_elim, bloque+ptr_mov, sizeof(EMUFS_REG_ID)+tam_reg);
ptr_elim = ptr_mov;
- ptr_mov += sizeof(int) + tam_reg;
+ ptr_mov += sizeof(EMUFS_REG_ID) + tam_reg;
}
/*grabo el bloque en el archivo*/
/*actualizo archivo .fsc*/
fs = emufs_fsc_get_fs(emu, num_bloque);
- if ( emufs_fsc_actualizar(emu, num_bloque, fs + tam_reg + sizeof(int)) != 0 ) return -1;
+ if ( emufs_fsc_actualizar(emu, num_bloque, fs + tam_reg + sizeof(EMUFS_REG_ID)) != 0 ) return -1;
/*actualizo archivo .did*/
if ( emufs_did_agregar(emu, ID) != 0 ) return -1;
#include "idx.h"
#include "fsc.h"
-
/** Lee el registro \param id_reg y lo almacena en \param ptr */
-int emufs_tipo3_leer_registro(EMUFS *emu, int id_reg, void *ptr, unsigned long tam_reg);
+int emufs_tipo3_leer_registro(EMUFS *emu, EMUFS_REG_ID id_reg, void *ptr,
+ EMUFS_REG_SIZE tam_reg);
/** Lee el bloque \param num_bloque y lo almacena en \param ptr */
-int emufs_tipo3_leer_bloque(EMUFS *emu, int num_bloque, void *ptr);
+int emufs_tipo3_leer_bloque(EMUFS *emu, EMUFS_BLOCK_ID num_bloque, void *ptr);
/** Graba el registro apuntado por \param ptr en el archivo */
-int emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, unsigned long tam_reg);
+EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE tam_reg);
/** Graba el bloque apuntado por \param ptr en el archivo */
-int emufs_tipo3_grabar_bloque(EMUFS *emu, void *ptr, int num_bloque);
-
-int emufs_tipo3_get_id(EMUFS *emu);
+int emufs_tipo3_grabar_bloque(EMUFS *emu, void *ptr, EMUFS_BLOCK_ID num_bloque);
-int emufs_tipo3_buscar_registro(EMUFS *emu, int id_reg);
+EMUFS_REG_ID emufs_tipo3_get_id(EMUFS *emu);
-int emufs_tipo3_buscar_lugar(EMUFS *emu, unsigned long tam_reg, int *free_space);
+int emufs_tipo3_buscar_registro(EMUFS *emu, EMUFS_REG_ID id_reg);
-int emufs_tipo3_borrar_registro(EMUFS *emu, int id_reg, unsigned long tam_reg);
+int emufs_tipo3_buscar_lugar(EMUFS *emu, EMUFS_REG_SIZE tam_reg,
+ EMUFS_FREE *free_space);
+int emufs_tipo3_borrar_registro(EMUFS *emu, EMUFS_REG_ID id_reg,
+ EMUFS_REG_SIZE tam_reg);
#endif /* _EMUFS_TIPO3_H_ */
projects / z.facultad / 75.06 / emufs.git / commitdiff