subo un par de comentarios, y tengo que buscar un bug en las stats que debe andar...

diff --git a/emufs/fsc.c b/emufs/fsc.c
index 05e29a843758dd9e5e4fb8e77dbb162203f88439..73f043d6a9b258daac482c0370e58ebdd87e33f8 100644 (file)
--- a/emufs/fsc.c
+++ b/emufs/fsc.c
@@ -453,7 +453,8 @@ EMUFS_FREE emufs_fsc_get_total_fs(EMUFS *emu)
        total = 0;
        while ( !feof(f_fsc) ){
                if ( fread(&reg, sizeof(EMUFS_FSC), 1, f_fsc) != 1) continue;
-               total += reg.freespace;
+               if ( reg.freespace > 0 )
+                       total += reg.freespace;
        }
        fclose(f_fsc);
        return total;
@@ -575,4 +576,3 @@ long emufs_fsc_get_file_size(EMUFS* efs, int* err)
        strcat(name, EMUFS_FSC_EXT);
        return emufs_common_get_file_size(name, err);
 }
-

diff --git a/emufs/idx.h b/emufs/idx.h
index cd2c3e3ec8a008a2cbe0e65dce4701ac24458d0d..4d40895ca49d31abfea5c489ea6905f48ed0e619 100644 (file)
--- a/emufs/idx.h
+++ b/emufs/idx.h
@@ -44,22 +44,37 @@
 
 #define EMUFS_IDX_EXT ".idx"
 
+/** Estructura que define el archivo .idx
+  *\param id_reg ID del registro.
+  *\param location Numero de bloque.
+  */
 typedef struct emufs_idx_t {
        EMUFS_REG_ID id_reg;
        EMUFS_BLOCK_ID location;
 } EMUFS_IDX;
 
+
+/** Abre el archivo */
 FILE* emufs_idx_abrir(EMUFS*, const char*);
 
+/** Crea el archivo vacio */
 int emufs_idx_crear(EMUFS*);
 
+/** Devuelve el mayor id libre para un nuevo registro  */
 EMUFS_REG_ID emufs_idx_buscar_mayor_id_libre(EMUFS*, int*);
 
-EMUFS_BLOCK_ID emufs_idx_buscar_registro(EMUFS*, EMUFS_REG_ID);
+/** Busca el bloque al que pertenece el id \c reg_id */
+EMUFS_BLOCK_ID emufs_idx_buscar_registro(EMUFS*, EMUFS_REG_ID reg_id);
 
-int emufs_idx_agregar(EMUFS*, EMUFS_BLOCK_ID, EMUFS_REG_ID);
+/** Agrega un nuevo registro EMUFS_IDX al archivo .idx si no existe
+  * el id \c reg_id, si existe coloca en el campo location el valor 
+  * indicado en \c block_id
+  */
+int emufs_idx_agregar(EMUFS*, EMUFS_BLOCK_ID block_id, EMUFS_REG_ID reg_id);
 
-int emufs_idx_borrar(EMUFS*, EMUFS_REG_ID);
+/** Coloca el valor -1 en el campo location, del registro que contenga el 
+  * id \c reg_id, para indicar que ese id no existe */
+int emufs_idx_borrar(EMUFS*, EMUFS_REG_ID reg_id);
 
 /** Retorna un array con los Ids validos del archivo IDX
  *
@@ -69,10 +84,13 @@ int emufs_idx_borrar(EMUFS*, EMUFS_REG_ID);
  */
 EMUFS_REG_ID *emufs_idx_get(EMUFS *emu, EMUFS_REG_ID *cant);
 
+/** Devuelve un nuevo id valido para un nuevo registro */
 EMUFS_REG_ID emufs_idx_get_new_id(EMUFS*, int*);
 
+/** Retorna 0 si \c ID existe */
 int emufs_idx_existe_id(EMUFS *emu, int ID);
 
+/** Acutaliza el valor de \c bloque segun \c ID */
 int emufs_idx_actualizar(EMUFS *emu, int ID, EMUFS_BLOCK_ID bloque);
 
 /** Obtiene el tamaño del archivo de índice. */

diff --git a/emufs/tipo3.h b/emufs/tipo3.h
index 12ed7321bd00190d37d10d337f9315c0e3f1cb35..c47c97f5dccdf91c9a5d58e93bd2179b6cdc6964 100644 (file)
--- a/emufs/tipo3.h
+++ b/emufs/tipo3.h
@@ -51,6 +51,10 @@
   * por el segundo parámetro \c ID, y almacena en \c reg_size el tamaño del
   * registro leido, que en este caso no es necesario pues es constante y es conocicdo de antemano.
   * Para realizar esta acción, busca en el archivo .idx el bloque al cual pertenece el registro.
+  * \param emu Esructura para manejar los archivos.
+  * \param ID Id del registro a leer.
+  * \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);
 
@@ -58,8 +62,11 @@ void* emufs_tipo3_leer_registro(EMUFS *emu, EMUFS_REG_ID ID, EMUFS_REG_SIZE* reg
   * el segundo parámetro \c num_bloque. Como la numeración de los bloques es virtual,
   * el acceso al archivo para levantar un bloque es directo, es decir, se posiciona directamente
   * en en número de bloque multiplicado por el tamaño del mismo, salteando antes el encabezado del archivo.
+  * \param emu Esructura para manejar los archivos.
+  * \param block_id Numero del bloque a leer.
+  * \param err Codigo de error devuelto en caso de falla.
   */
-void* emufs_tipo3_leer_bloque(EMUFS*, EMUFS_BLOCK_ID, int*);
+void* emufs_tipo3_leer_bloque(EMUFS *emu, EMUFS_BLOCK_ID block_id, int *err);
 
 /** Graba un registro en un bloque donde haya espacio suficiente, y si no 
   * crea un nuevo bloque y lo agrega al final del archivo. 
@@ -67,32 +74,64 @@ void* emufs_tipo3_leer_bloque(EMUFS*, EMUFS_BLOCK_ID, int*);
   * y el tamaño viene indicado en \c tam.
   * Luego de realizar la grabación, actualiza los archivos índice con los
   * valores correspondientes.
+  * \param emu Esructura para manejar los archivos.
+  * \param ptr Cadena de datos que contiene el registro a grabar.
+  * \param err Codigo de error devuelto en caso de falla.
   */
-EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE, int*);
+EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE, int *err);
 
-/** Graba el bloque apuntado por \c ptr en el archivo */
+/** Graba el bloque apuntado por \c ptr en el archivo 
+  * \param emu Esructura para manejar los archivos.
+  * \param ptr Cadena de datos que contiene el bloque a grabar.
+  * \param block_id Numero del bloque a leer.
+  */
 int emufs_tipo3_grabar_bloque(EMUFS *emu, void *ptr, EMUFS_BLOCK_ID num_bloque);
 
 /** Borra el registro \c id_reg del archivo de datos, y actualiza los archivos
   *    de índice para mantener la coherencia en las próximas modificaciones.
+  * \param emu Esructura para manejar los archivos.
+  * \param id_reg Id del registro a borrar.
   */
 int emufs_tipo3_borrar_registro(EMUFS *emu, EMUFS_REG_ID id_reg);
 
-/** Método para modificar un registro */
-EMUFS_REG_ID emufs_tipo3_modificar_registro(EMUFS *emu, EMUFS_REG_ID, void*, EMUFS_REG_SIZE, int*);
+/** Método para modificar un registro
+  * \param emu Esructura para manejar los archivos.
+  * \param reg_id Id del registro que se quiere modificar.
+  * \param ptr Cadena de datos que contiene el nuevo registro.
+  * \param err Codigo de error devuelto en caso de falla.
+  */
+EMUFS_REG_ID emufs_tipo3_modificar_registro(EMUFS *emu, EMUFS_REG_ID reg_id, void *ptr, EMUFS_REG_SIZE, int*err);
 
 /** Completa una estructura del tipo EMUFS_Estadisticas con las estadísticas del
   * archivo de datos, espacio libre total, cantidad de registros, cantidad de bloques,
   * tamaño del archivo en bytes, relaciones entre tamaños y espacios libres, etc.
+  * \param emu Esructura para manejar los archivos.
   */
-EMUFS_Estadisticas emufs_tipo3_leer_estadisticas(EMUFS *);
+EMUFS_Estadisticas emufs_tipo3_leer_estadisticas(EMUFS *emu);
 
-/** Lee un registro con su informacion de control */
-void* emufs_tipo3_leer_registro_raw(struct _emu_fs_t*, EMUFS_REG_ID, EMUFS_REG_SIZE*, int *);
+/** Lee un registro con su informacion de control 
+  * \param emu Esructura para manejar los archivos.
+  * \param ID Id del registro a leer.
+  * \param reg_size Tamaño del registro.
+  * \param err Codigo de error devuelto en caso de falla.
+  */
+void* emufs_tipo3_leer_registro_raw(EMUFS *emu, EMUFS_REG_ID reg_id, EMUFS_REG_SIZE *reg_size, int *err);
 
-/** Elimina los espacios libres que hay en el archivo */
+/** Elimina los espacios libres que hay en el archivo
+  * \param emu Esructura para manejar los archivos.
+  */
 void emufs_tipo3_compactar(EMUFS *emu);
 
-void emufs_tipo3_leer_bloque_raw(EMUFS *efs, EMUFS_BLOCK_ID id, char **actual, char **anterior, char **siguiente, EMUFS_BLOCK_SIZE *size1, EMUFS_BLOCK_SIZE *size2, EMUFS_BLOCK_SIZE *size3);
+/** Lee un bloque, el anterior y el siguiente 
+  * \param emu Esructura para manejar los archivos.
+  * \param block_id Id del bloque a leer.
+  * \param actual Cadena de datos que almacena el bloque indicado por \c block_id.
+  * \param anterior Cadena de datos que almacena el bloque anterior al \c actual.
+  * \param siguiente Cadena de datos que almacena el bloque siguiente al \c actual.
+  * \param size1 Tamaño del bloque actual.
+  * \param size2 Tamaño del bloque anterior.
+  * \param size3 Tamaño del bloque siguiente.
+  */
+void emufs_tipo3_leer_bloque_raw(EMUFS *emu, EMUFS_BLOCK_ID block_id, char **actual, char **anterior, char **siguiente, EMUFS_BLOCK_SIZE *size1, EMUFS_BLOCK_SIZE *size2, EMUFS_BLOCK_SIZE *size3);
 
 #endif /* _EMUFS_TIPO3_H_ */