X-Git-Url: https://git.llucax.com/z.facultad/75.06/emufs.git/blobdiff_plain/0883f886250415d46b14fb07f65e4de3b6f4fa9c..681f9d807b6f486e251e49401abe40c09b7855c1:/emufs/tipo1.c

diff --git a/emufs/tipo1.c b/emufs/tipo1.c
index 5dbf6f3..f1cc3c9 100644
--- a/emufs/tipo1.c
+++ b/emufs/tipo1.c
@@ -1,4 +1,4 @@
-/* vim: set noexpandtab tabstop=4 shiftwidth=4:
+/* vim: set noexpandtab tabstop=4 shiftwidth=4 wrap:
  *----------------------------------------------------------------------------
  *                                  emufs
  *----------------------------------------------------------------------------
@@ -88,7 +88,6 @@ void* emufs_tipo1_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id,
 	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_BLOCK_SIZE block_size; /* tamaño del bloque leído */
 	EMUFS_TIPO1_REG_HEADER curr_reg_header; /* cabecera del registro a leer */
 
 	block_id = emufs_idx_buscar_registro(efs, reg_id);
@@ -115,8 +114,13 @@ void* emufs_tipo1_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id,
 			/* tamaño máximo ultilizable para datos en un bloque */
 			EMUFS_BLOCK_SIZE block_space
 					= efs->tam_bloque - sizeof(EMUFS_TIPO1_REG_HEADER);
+			/* tamaño de la porción de registro que se guarda */
+			EMUFS_REG_SIZE chunk_size = 0; 
+			/* puntero a la porción actual del registro */
+			char* chunk_ptr;
+
 			*reg_size = curr_reg_header.size;
-			registro = (char*) malloc(*reg_size);
+			registro = chunk_ptr = (char*) malloc(*reg_size);
 			if (registro == NULL) {
 				/* TODO Manejo de errores */
 				free(block);
@@ -124,85 +128,42 @@ void* emufs_tipo1_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id,
 				*err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */
 				return NULL;
 			}
-			/* Si el registro ocupa más de un bloque */
-			if (*reg_size > block_space) {
-				/* TODO */
-				/* tamaño de la porción de registro que se guarda */
-				EMUFS_REG_SIZE chunk_size = 0; 
-				/* puntero a la porción actual del registro */
-				char* chunk_ptr = registro;
-
-				while (1) {
-					chunk_ptr += chunk_size; /* Avanzo para guardar prox chunk */
-					curr_reg_header.size -= chunk_size; /* Resto lo que ya guardé */
-					chunk_size = MIN(curr_reg_header.size, block_space);
-					/* copio porción de registro en el buffer */
-					memcpy(chunk_ptr, block + offset, chunk_size);
-					 /* falta leer un bloque */
-					if (curr_reg_header.size > block_space) {
-						free(block);
-						if (!(block = (char*) emufs_tipo1_leer_bloque(efs,
-										++block_id, err))) {
-							/* TODO Manejo de errores */
-							free(registro);
-							PERR("no se pudo reservar memoria");
-							*err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */
-							return NULL;
-						}
-					} else { /* se terminó de leer */
-						break;
+			while (1) {
+				chunk_ptr += chunk_size; /* Avanzo para guardar prox chunk */
+				curr_reg_header.size -= chunk_size; /* Resto lo que ya guardé */
+				chunk_size = MIN(curr_reg_header.size, block_space);
+				/* copio porción de registro en el buffer */
+				memcpy(chunk_ptr, block + offset, chunk_size);
+				 /* falta leer un bloque */
+				if (curr_reg_header.size > block_space) {
+					free(block);
+					if (!(block = (char*) emufs_tipo1_leer_bloque(efs,
+									++block_id, err))) {
+						/* TODO Manejo de errores */
+						free(registro);
+						PERR("no se pudo reservar memoria");
+						*err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */
+						return NULL;
 					}
+				} else { /* se terminó de leer */
+					break;
 				}
-			} else {
-				memcpy(registro, block + offset, *reg_size);
 			}
 			break;
 		}
 		/* Desplazo el offset */
 		offset += curr_reg_header.size;
-	} while (offset < block_size);
+	} while (offset < efs->tam_bloque);
 
 	free(block);
 	return registro;
 }
 
-#if 0
-			/* tamaño máximo ultilizable para datos en un bloque */
-			EMUFS_BLOCK_SIZE block_space
-					= efs->tam_bloque - sizeof(EMUFS_TIPO1_REG_HEADER);
-			/* tamaño de la porción de registro que se guarda */
-			EMUFS_REG_SIZE chunk_size = 0; 
-			/* puntero a la porción actual del registro */
-			char* chunk_ptr;
-			/* puntero a la posición actual del bloque */
-			char* block_ptr = block + offset;
-
-			*reg_size = curr_reg_header.size; /* obtengo tamaño del registro */
-			registro = chunk_ptr = (char*) malloc(*reg_size);
-			if (registro == NULL) {
-				/* TODO Manejo de errores */
-				free(block);
-				PERR("No hay memoria");
-				*err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */
-				return NULL;
-			}
-			do {
-				block_ptr += chunk_size; /* Avanzo para guardar prox chunk */
-				chunk_ptr += chunk_size; /* Avanzo para guardar prox chunk */
-				curr_reg_header.size -= chunk_size; /* Resto lo que ya guardé */
-				chunk_size = MIN(curr_reg_header.size, block_space);
-				/* copio porción de registro en el buffer */
-				memcpy(chunk_ptr, block_ptr, chunk_size);
-			} while (curr_reg_header.size > block_space);
-#endif
-
-void* emufs_tipo1_leer_registro_raw(EMUFS *efs, EMUFS_REG_ID id,
-		EMUFS_REG_SIZE *size, int *pos)
+void* emufs_tipo1_leer_registro_raw(EMUFS *efs, EMUFS_REG_ID id, EMUFS_REG_SIZE *size, int *pos)
 {
 	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 */
 	EMUFS_BLOCK_SIZE offset; /* offset del bloque leído */
-	EMUFS_BLOCK_SIZE block_size; /* tamaño del bloque leído */
 	EMUFS_TIPO1_REG_HEADER curr_reg_header; /* cabecera del registro a leer */
 	int err;
 
@@ -210,6 +171,7 @@ void* emufs_tipo1_leer_registro_raw(EMUFS *efs, EMUFS_REG_ID id,
 	if (block_id == EMUFS_NOT_FOUND) {
 		return NULL;
 	}
+	err = 0;
 	if (!(block = (char*) emufs_tipo1_leer_bloque(efs, block_id, &err))) {
 		return NULL;
 	}
@@ -226,9 +188,9 @@ void* emufs_tipo1_leer_registro_raw(EMUFS *efs, EMUFS_REG_ID id,
 		}
 		/* Desplazo el offset */
 		offset += curr_reg_header.size;
-	} while (offset < block_size);
+	} while (offset < efs->tam_bloque);
 
-	(*size) = block_size;
+	(*size) = efs->tam_bloque;
 	return block;
 }
 
@@ -267,8 +229,7 @@ void* emufs_tipo1_leer_bloque(EMUFS* efs, EMUFS_BLOCK_ID block_id, int *err)
 	return block;
 }
 
-EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* efs, void* reg,
-		EMUFS_REG_SIZE reg_size, int* err)
+EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* efs, void* reg, EMUFS_REG_SIZE reg_size, int* err)
 {
 	EMUFS_TIPO1_REG_HEADER reg_header; /* cabecera del registro a guardar */
 	EMUFS_FREE             fs; /* espacio libre en el bloque */
@@ -287,8 +248,7 @@ EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* efs, void* reg,
 	/* si no hay bloques con suficiente espacio creo un bloque nuevo */
 	if (block_id == EMUFS_NOT_FOUND) {
 		/* tamaño máximo ultilizable para datos en un bloque */
-		EMUFS_BLOCK_SIZE block_space
-				= efs->tam_bloque - sizeof(EMUFS_TIPO1_REG_HEADER);
+		EMUFS_BLOCK_SIZE block_space = efs->tam_bloque - sizeof(EMUFS_TIPO1_REG_HEADER);
 		/* identificador del bloque que se guarda */
 		EMUFS_BLOCK_ID curr_block_id = EMUFS_NOT_FOUND;
 		/* tamaño de la porción de registro que se guarda */
@@ -311,11 +271,9 @@ EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* efs, void* reg,
 			reg_header.size -= chunk_size; /* Resto lo que ya guardé */
 			chunk_size = MIN(reg_header.size, block_space);
 			/* graba porción del registro en bloque */
-			emufs_tipo1_escribir_reg_chunk_en_memoria(block, reg_header,
-					chunk_ptr, chunk_size);
+			emufs_tipo1_escribir_reg_chunk_en_memoria(block, reg_header, chunk_ptr, chunk_size);
 			/* graba el bloque en el archivo */
-			curr_block_id = emufs_tipo1_grabar_bloque(efs, block,
-					EMUFS_NOT_FOUND, err);
+			curr_block_id = emufs_tipo1_grabar_bloque(efs, block, EMUFS_NOT_FOUND, err);
 			if (*err) {
 				PERR("error al grabar bloque");
 				free(block);