26 Rutinas de ficheros y compresión



Las siguientes rutinas implementan un sistema de ficheros I/O con buffer rápido, que soporta la lectura y escritura de ficheros comprimidos usando un algoritmo de buffer de anillo basado en el compresor LZSS de Haruhiko Okumura. Esto no consigue tan buenas compresiones como zip o lha, pero la descompresión es muy rápida y no requiere mucha memoria. Los ficheros comprimidos siempre comienzan con el valor de 32 bits F_PACK_MAGIC, y autodetecta ficheros con el valor F_NOPACK_MAGIC.

char *fix_filename_case(char *path);
Convierte un nombre de fichero a un estado estandarizado. En platadormas DOS, los nombres serán todo mayúsculas. Devuelve una copia del parámetro de camino.

char *fix_filename_slashes(char *path);
Convierte los separadores de directorios de un nombre de fichero a un carácter estándar. En plataformas DOS, esto es la antibarra. Devuelve una copia del parámetro de camino.

char *fix_filename_path(char *dest, char *path, int size);
Convierte un nombre de fichero parcial en un camino completo, generando hasta el máximo número de carácteres especificados. Devuelve una copia del parámetro dest.

char *replace_filename(char *dest, char *path, char *filename, int size);
Sustituye el camino+nombre de fichero especificados con un nuevo nombre de fichero, generando hasta el máximo número de carácteres especificados. Devuelve una copia del parámetro dest.

char *replace_extension(char *dest, char *filename, char *ext, int size);
Sustituye el nombre de fichero+extensión especificados con una nueva extensión, generando hasta el máximo número de carácteres especificados. Devuelve una copia del parámetro dest.

char *append_filename(char *dest, char *path, char *filename, int size);
Concatena el nombre de fichero especificado al final del camino especificado, generando hasta el máximo número de carácteres especificados. Devuelve una copia del parámetro dest.

char *get_filename(char *path);
Cuando se le pasa el path específico de un fichero, devuelve un puntero a la porción del nombre del fichero. Tanto '\' como '/' son reconocidos como separadores de directorios.

char *get_extension(char *filename);
Cuando se le pasa un nombre de fichero completo (con o sin información de path) devuelve un puntero a la extensión del fichero.

void put_backslash(char *filename);
Si el último caracter de un nombre no es '\' o '/', esta rutina le añadirá '\'.

int file_exists(char *filename, int attrib, int *aret);
Chequea la existencia de un fichero de nombre y atributos dados, devolviendo no-cero si el fichero existe. Los atributos pueden contener cualquiera de las constantes FA_* de dir.h. Si aret no es NULL, será fijado a los atributos del fichero existente. Si ocurre un error, el código de error de sistema será almacenado en errno.

int exists(char *filename);
Versión reducida de file_exists(), que chequea la existencia de ficheros normales, los cuales pueden tener los bits de archivo o sólo lectura activados, pero no son ocultos, directorios, ficheros de sistema, etc.

long file_size(char *filename);
Devuelve el tamaño del fichero en bytes. Si el fichero no existe u ocurre un error, devolverá cero y almacenará el código de error de sistema en errno.

long file_time(char *filename);
Devuelve el tiempo de modificación de un fichero.

int delete_file(char *filename);
Borra un fichero.

int for_each_file(char *name, int attrib, void (*callback)(), int param);
Encuentra todos los ficheros que se ajusten al nombre (ej: *.exe) y atributos especificados, y ejecuta callback() por cada uno de ellos. A callback() se le pasan tres parámetros, el primero es la cadena que contiene el nombre completo del fichero, el segundo los atributos del fichero, y el tercer parámetro es un entero que es copia de param (puede usar esto para lo que quiera). Si ocurre un error, el código de error será almacenado en errno, y callback() puede abortar for_each_file al activar errno. Devuelve el número de llamadas con éxito hechas a callback(). Los atributos de fichero pueden contener cualquiera de los biestables FA_* de dir.h.

void packfile_password(char *password);
Activa el password de encriptación que será usado para todas las operaciones de escritura/lectura de ficheros comprimidos. Los ficheros escritos con un password no pueden ser leídos a no ser que se seleccione el password correcto, por lo que cuidado: si olvida la clave, ¡nadie podrá recuperar su datos! Pase NULL o una cadena vacía para volver al modo normal, no encriptado. Si está usando esta función para evitar que otros accedan a sus ficheros de datos, tenga cuidado de no salvar una copia obvia de su clave en el ejecutable: si hay cadenas como "Soy la clave del fichero de datos", sería muy fácil acceder a sus datos :-)

PACKFILE *pack_fopen(char *filename, char *mode);
Abre un fichero según el modo, que puede contener cualquiera de los siguientes biestables.

En vez de estos biestables, una de las constantes F_READ, FWRITE, F_READ_PACKED, F_WRITE_PACKED o F_WRITE_NOPACK puede ser usada como el parámetro de modo. Si todo funciona, pack_fopen() devuelve un puntero a una estructura de fichero, y con error, devuelve NULL y almacena el código de error en errno. Un intento de leer un fichero normal en modo comprimido activará errno a EDOM.

Las funciones de ficheros también entienden varios nombres "mágicos" que pueden ser usados por varios motivos. Estos nombres son:

Con estos nombres especiales, los contenidos de un objeto de un fichero de datos o de un fichero añadido pueden ser leídos de modo idéntico que un fichero normal, por lo que cualquiera de las funciones de acceso a ficheros de Allegro (ejemplo: load_pcx() y set_config_file()) pueden ser usadas para leerlos. Sin embargo, no podrá escribir en estos ficheros: sólo pueden ser leídos. Además, debe tener su fichero de datos descomprimido o con compresión por objetos si planea leer objetos individuales (de otra manera, habrá una sobrecarga de búsqueda al ser leído). Finalmente, tenga en cuenta que los tipos de objetos especiales de Allegro no son los mismos que los de los ficheros que importas los datos. Cuando importe datos como bitmaps o samples en el grabber, éstos son convertidos en un formato específico de Allegro, pero el marcador de sintaxis de ficheros '#' lee los objetos como trozos binarios raw. Esto significa, que si por ejemplo, quiere usar load_pcx para leer una imagen de un fichero de datos, debería importarlos como un bloque binario en vez de un objeto BITMAP.

int pack_fclose(PACKFILE *f);
int pack_fseek(PACKFILE *f, int offset);
int pack_feof(PACKFILE *f);
int pack_ferror(PACKFILE *f);
int pack_getc(PACKFILE *f);
int pack_putc(int c, PACKFILE *f);
int pack_igetw(PACKFILE *f);
long pack_igetl(PACKFILE *f);
int pack_iputw(int w, PACKFILE *f);
long pack_iputl(long l, PACKFILE *f);
int pack_mgetw(PACKFILE *f);
long pack_mgetl(PACKFILE *f);
int pack_mputw(int w, PACKFILE *f);
long pack_mputl(long l, PACKFILE *f);
long pack_fread(void *p, long n, PACKFILE *f);
long pack_fwrite(void *p, long n, PACKFILE *f);
char *pack_fgets(char *p, int max, PACKFILE *f);
int pack_fputs(char *p, PACKFILE *f);

Todas estas funcionan como las funciones equivalentes stdio, excepto que pack_fread() y pack_fwrite() toman un sólo parámetro de tamaño en vez de ese estúpido sistema de tamaño y num_elements, y sólo puede avanzar en un fichero hacia delante desde la posición relativa actual. Las rutinas pack_i* y pack_m leen y escriben valores de 16 y 32 bits usando los sistemas de orden de Intel y Motorola respectivamente. Tome nota que la búsqueda es muy lenta cuando lea ficheros comprimidos, y que debería ser evitada a no ser que sepa que el fichero no está comprimido.

PACKFILE *pack_fopen_chunk(PACKFILE *f, int pack);
Abre sub_chunks en un fichero. Los chunks son primariamente usados por el código de ficheros de datos, pero pueden serle útiles para sus propias rutinas de ficheros. Un chunk provee una vista lógica de parte de un fichero, que puede ser comprimido como un ente individual y será automáticamente insertado y chequea los contadores de tamaño para prevenir la lectura después del final del chunk. Para escribir un chunk en un fichero f, use este código:

      /* Asumo que f es un PACKFILE * que ha sido abierto en modo escritura*/
      f = pack_fopen_chunk(f, pack);
      escribe datos en f
      f = pack_fclose_chunk(f);

Los datos escritos en el chunk serán precedidos con dos counts (32 bits, big-endian). Para descomprimir chunks, éstos serán ajustados al tamaño de los datos del chunk. Para chunks comprimidos (creados al ajustar el biestable pack), el primer tamaño es el tamaño real del chunk, y el segundo será el tamaño negativo de los datos descomprimidos.

Para leer el chunk, use este código:

      /* Asumo que f es un PACKFILE * que ha sido abierto en modo escritura*/
      f = pack_fopen_chunk(f, FALSE);
      lee datos de f
      f = pack_fclose_chunk(f);

Esta secuencia leerá los counts de tamaño creados cuando el chunk fue escrito, y automáticamente descomprimirá el contenido del chunk si fue comprimido. El tamaño también evitará leer después del final del chunk (Allegro devolverá EOF si intenta esto), y automáticamente ignora los chunks no leídos cuando llamas pack_fclose_chunk().

Los chunks pueden ser anidados unos dentro de otros al hacer llamadas repetidas a pack_fopen_chunk(). Al escribir un fichero, el estado de compresión es heredado del fichero padre, por lo que sólo tiene que activar el biestable pack si el fichero padre no fue comprimido pero quiere comprimir los datos del chunk. Si el fichero padre ya está abierto en modo comprimido, activar el biestable pack hará que los datos sean comprimidos dos veces: una cuando los datos son escritos en el chunk, y otra cuando el chunk es escrito en el fichero padre.

PACKFILE *pack_fclose_chunk(PACKFILE *f);
Cierra un sub-chunk de un fichero, que previamente ha sido obtenido al llamar pack_fopen_chunk().




Volver al Indice