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.
Las funciones de ficheros también entienden varios nombres "mágicos" que pueden ser usados por varios motivos. Estos nombres son:
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().