From 90031c81f3568abc2e9eb4e84aea85c62a244adf Mon Sep 17 00:00:00 2001 From: "Ryan C. Gordon" Date: Sun, 26 Sep 2004 13:00:59 +0000 Subject: [PATCH] Did the same thing to FileHandles than I did to DirHandles, but this triggered massive tweaking in physfs.c. A lot of code got little cleanups, which was nice. Less malloc pressure, too, since opening a file used to allocate a ton of crap and mush it together...now it's basically down to one structure and the instance data in whatever archiver. --- CHANGELOG | 6 + archivers/dir.c | 177 ++++++---------- archivers/grp.c | 130 ++++++------ archivers/hog.c | 122 +++++------ archivers/mix.c | 128 +++++------- archivers/mvl.c | 122 +++++------ archivers/qpak.c | 122 +++++------ archivers/wad.c | 122 +++++------ archivers/zip.c | 129 ++++++------ physfs.c | 513 ++++++++++++++++++++++------------------------ physfs.h | 6 +- physfs_internal.h | 226 ++++++++++---------- 12 files changed, 806 insertions(+), 997 deletions(-) diff --git a/CHANGELOG b/CHANGELOG index a84cd63..e93b266 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -2,6 +2,12 @@ * CHANGELOG. */ +09262004 - Did the same thing to FileHandles than I did to DirHandles, but + this triggered massive tweaking in physfs.c. A lot of code got + little cleanups, which was nice. Less malloc pressure, too, since + opening a file used to allocate a ton of crap and mush it + together...now it's basically down to one structure and the + instance data in whatever archiver. 09252004 - Cleaned up archiver interface to not deal with DirHandles anymore, which simplifies things, removes some responsibility and code duplication from the archivers, and trims some malloc pressure. diff --git a/archivers/dir.c b/archivers/dir.c index da2bf5b..1a431e5 100644 --- a/archivers/dir.c +++ b/archivers/dir.c @@ -18,34 +18,30 @@ #define __PHYSICSFS_INTERNAL__ #include "physfs_internal.h" -static PHYSFS_sint64 DIR_read(FileHandle *handle, void *buffer, +static PHYSFS_sint64 DIR_read(fvoid *opaque, void *buffer, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount); -static PHYSFS_sint64 DIR_write(FileHandle *handle, const void *buffer, +static PHYSFS_sint64 DIR_write(fvoid *opaque, const void *buffer, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount); -static PHYSFS_sint64 DIR_dummyRead(FileHandle *handle, void *buffer, - PHYSFS_uint32 objSize, PHYSFS_uint32 objCount); -static PHYSFS_sint64 DIR_dummyWrite(FileHandle *handle, const void *buffer, - PHYSFS_uint32 objSize, PHYSFS_uint32 objCount); -static int DIR_eof(FileHandle *handle); -static PHYSFS_sint64 DIR_tell(FileHandle *handle); -static int DIR_seek(FileHandle *handle, PHYSFS_uint64 offset); -static PHYSFS_sint64 DIR_fileLength(FileHandle *handle); -static int DIR_fileClose(FileHandle *handle); +static int DIR_eof(fvoid *opaque); +static PHYSFS_sint64 DIR_tell(fvoid *opaque); +static int DIR_seek(fvoid *opaque, PHYSFS_uint64 offset); +static PHYSFS_sint64 DIR_fileLength(fvoid *opaque); +static int DIR_fileClose(fvoid *opaque); static int DIR_isArchive(const char *filename, int forWriting); static void *DIR_openArchive(const char *name, int forWriting); -static LinkedStringList *DIR_enumerateFiles(void *opaque, +static LinkedStringList *DIR_enumerateFiles(dvoid *opaque, const char *dname, int omitSymLinks); -static int DIR_exists(void *opaque, const char *name); -static int DIR_isDirectory(void *opaque, const char *name, int *fileExists); -static int DIR_isSymLink(void *opaque, const char *name, int *fileExists); -static FileHandle *DIR_openRead(void *opaque, const char *fnm, int *exist); -static PHYSFS_sint64 DIR_getLastModTime(void *opaque, const char *f, int *e); -static FileHandle *DIR_openWrite(void *opaque, const char *filename); -static FileHandle *DIR_openAppend(void *opaque, const char *filename); -static int DIR_remove(void *opaque, const char *name); -static int DIR_mkdir(void *opaque, const char *name); -static void DIR_dirClose(void *opaque); +static int DIR_exists(dvoid *opaque, const char *name); +static int DIR_isDirectory(dvoid *opaque, const char *name, int *fileExists); +static int DIR_isSymLink(dvoid *opaque, const char *name, int *fileExists); +static fvoid *DIR_openRead(dvoid *opaque, const char *fnm, int *exist); +static PHYSFS_sint64 DIR_getLastModTime(dvoid *opaque, const char *f, int *e); +static fvoid *DIR_openWrite(dvoid *opaque, const char *filename); +static fvoid *DIR_openAppend(dvoid *opaque, const char *filename); +static int DIR_remove(dvoid *opaque, const char *name); +static int DIR_mkdir(dvoid *opaque, const char *name); +static void DIR_dirClose(dvoid *opaque); const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_DIR = @@ -57,31 +53,8 @@ const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_DIR = }; -static const FileFunctions __PHYSFS_FileFunctions_DIR = -{ - DIR_read, /* read() method */ - DIR_dummyWrite, /* write() method */ - DIR_eof, /* eof() method */ - DIR_tell, /* tell() method */ - DIR_seek, /* seek() method */ - DIR_fileLength, /* fileLength() method */ - DIR_fileClose /* fileClose() method */ -}; - -static const FileFunctions __PHYSFS_FileFunctions_DIRW = -{ - DIR_dummyRead, /* read() method */ - DIR_write, /* write() method */ - DIR_eof, /* eof() method */ - DIR_tell, /* tell() method */ - DIR_seek, /* seek() method */ - DIR_fileLength, /* fileLength() method */ - DIR_fileClose /* fileClose() method */ -}; - - -const DirFunctions __PHYSFS_DirFunctions_DIR = +const PHYSFS_Archiver __PHYSFS_Archiver_DIR = { &__PHYSFS_ArchiveInfo_DIR, DIR_isArchive, /* isArchive() method */ @@ -96,76 +69,68 @@ const DirFunctions __PHYSFS_DirFunctions_DIR = DIR_openAppend, /* openAppend() method */ DIR_remove, /* remove() method */ DIR_mkdir, /* mkdir() method */ - DIR_dirClose /* dirClose() method */ + DIR_dirClose, /* dirClose() method */ + DIR_read, /* read() method */ + DIR_write, /* write() method */ + DIR_eof, /* eof() method */ + DIR_tell, /* tell() method */ + DIR_seek, /* seek() method */ + DIR_fileLength, /* fileLength() method */ + DIR_fileClose /* fileClose() method */ }; -static PHYSFS_sint64 DIR_read(FileHandle *handle, void *buffer, +static PHYSFS_sint64 DIR_read(fvoid *opaque, void *buffer, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount) { PHYSFS_sint64 retval; - retval = __PHYSFS_platformRead(handle->opaque, buffer, objSize, objCount); + retval = __PHYSFS_platformRead(opaque, buffer, objSize, objCount); return(retval); } /* DIR_read */ -static PHYSFS_sint64 DIR_write(FileHandle *handle, const void *buffer, +static PHYSFS_sint64 DIR_write(fvoid *opaque, const void *buffer, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount) { PHYSFS_sint64 retval; - retval = __PHYSFS_platformWrite(handle->opaque, buffer, objSize, objCount); + retval = __PHYSFS_platformWrite(opaque, buffer, objSize, objCount); return(retval); } /* DIR_write */ -static PHYSFS_sint64 DIR_dummyRead(FileHandle *handle, void *buffer, - PHYSFS_uint32 objSize, PHYSFS_uint32 objCount) +static int DIR_eof(fvoid *opaque) { - BAIL_MACRO(ERR_NOT_SUPPORTED, -1); -} /* DIR_dummyRead */ - - -static PHYSFS_sint64 DIR_dummyWrite(FileHandle *handle, const void *buffer, - PHYSFS_uint32 objSize, PHYSFS_uint32 objCount) -{ - BAIL_MACRO(ERR_NOT_SUPPORTED, -1); -} /* DIR_dummyWrite */ - - -static int DIR_eof(FileHandle *handle) -{ - return(__PHYSFS_platformEOF(handle->opaque)); + return(__PHYSFS_platformEOF(opaque)); } /* DIR_eof */ -static PHYSFS_sint64 DIR_tell(FileHandle *handle) +static PHYSFS_sint64 DIR_tell(fvoid *opaque) { - return(__PHYSFS_platformTell(handle->opaque)); + return(__PHYSFS_platformTell(opaque)); } /* DIR_tell */ -static int DIR_seek(FileHandle *handle, PHYSFS_uint64 offset) +static int DIR_seek(fvoid *opaque, PHYSFS_uint64 offset) { - return(__PHYSFS_platformSeek(handle->opaque, offset)); + return(__PHYSFS_platformSeek(opaque, offset)); } /* DIR_seek */ -static PHYSFS_sint64 DIR_fileLength(FileHandle *handle) +static PHYSFS_sint64 DIR_fileLength(fvoid *opaque) { - return(__PHYSFS_platformFileLength(handle->opaque)); + return(__PHYSFS_platformFileLength(opaque)); } /* DIR_fileLength */ -static int DIR_fileClose(FileHandle *handle) +static int DIR_fileClose(fvoid *opaque) { /* * we manually flush the buffer, since that's the place a close will * most likely fail, but that will leave the file handle in an undefined * state if it fails. Flush failures we can recover from. */ - BAIL_IF_MACRO(!__PHYSFS_platformFlush(handle->opaque), NULL, 0); - BAIL_IF_MACRO(!__PHYSFS_platformClose(handle->opaque), NULL, 0); - free(handle); + BAIL_IF_MACRO(!__PHYSFS_platformFlush(opaque), NULL, 0); + BAIL_IF_MACRO(!__PHYSFS_platformClose(opaque), NULL, 0); return(1); } /* DIR_fileClose */ @@ -200,7 +165,7 @@ static void *DIR_openArchive(const char *name, int forWriting) } /* DIR_openArchive */ -static LinkedStringList *DIR_enumerateFiles(void *opaque, +static LinkedStringList *DIR_enumerateFiles(dvoid *opaque, const char *dname, int omitSymLinks) { @@ -214,7 +179,7 @@ static LinkedStringList *DIR_enumerateFiles(void *opaque, } /* DIR_enumerateFiles */ -static int DIR_exists(void *opaque, const char *name) +static int DIR_exists(dvoid *opaque, const char *name) { char *f = __PHYSFS_platformCvtToDependent((char *) opaque, name, NULL); int retval; @@ -226,7 +191,7 @@ static int DIR_exists(void *opaque, const char *name) } /* DIR_exists */ -static int DIR_isDirectory(void *opaque, const char *name, int *fileExists) +static int DIR_isDirectory(dvoid *opaque, const char *name, int *fileExists) { char *d = __PHYSFS_platformCvtToDependent((char *) opaque, name, NULL); int retval = 0; @@ -240,7 +205,7 @@ static int DIR_isDirectory(void *opaque, const char *name, int *fileExists) } /* DIR_isDirectory */ -static int DIR_isSymLink(void *opaque, const char *name, int *fileExists) +static int DIR_isSymLink(dvoid *opaque, const char *name, int *fileExists) { char *f = __PHYSFS_platformCvtToDependent((char *) opaque, name, NULL); int retval = 0; @@ -254,7 +219,7 @@ static int DIR_isSymLink(void *opaque, const char *name, int *fileExists) } /* DIR_isSymLink */ -static PHYSFS_sint64 DIR_getLastModTime(void *opaque, +static PHYSFS_sint64 DIR_getLastModTime(dvoid *opaque, const char *name, int *fileExists) { @@ -270,13 +235,12 @@ static PHYSFS_sint64 DIR_getLastModTime(void *opaque, } /* DIR_getLastModTime */ -static FileHandle *doOpen(void *opaque, const char *name, - void *(*openFunc)(const char *filename), - int *fileExists, const FileFunctions *fileFuncs) +static fvoid *doOpen(dvoid *opaque, const char *name, + void *(*openFunc)(const char *filename), + int *fileExists) { char *f = __PHYSFS_platformCvtToDependent((char *) opaque, name, NULL); - void *rc; - FileHandle *retval; + void *rc = NULL; BAIL_IF_MACRO(f == NULL, NULL, NULL); @@ -290,51 +254,32 @@ static FileHandle *doOpen(void *opaque, const char *name, } /* if */ } /* if */ - retval = (FileHandle *) malloc(sizeof (FileHandle)); - if (!retval) - { - free(f); - BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL); - } /* if */ - rc = openFunc(f); free(f); - if (!rc) - { - free(retval); - return(NULL); - } /* if */ - - retval->opaque = (void *) rc; - retval->funcs = fileFuncs; - - return(retval); + return((fvoid *) rc); } /* doOpen */ -static FileHandle *DIR_openRead(void *opaque, const char *fnm, int *exist) +static fvoid *DIR_openRead(dvoid *opaque, const char *fnm, int *exist) { - return(doOpen(opaque, fnm, __PHYSFS_platformOpenRead, exist, - &__PHYSFS_FileFunctions_DIR)); + return(doOpen(opaque, fnm, __PHYSFS_platformOpenRead, exist)); } /* DIR_openRead */ -static FileHandle *DIR_openWrite(void *opaque, const char *filename) +static fvoid *DIR_openWrite(dvoid *opaque, const char *filename) { - return(doOpen(opaque, filename, __PHYSFS_platformOpenWrite, NULL, - &__PHYSFS_FileFunctions_DIRW)); + return(doOpen(opaque, filename, __PHYSFS_platformOpenWrite, NULL)); } /* DIR_openWrite */ -static FileHandle *DIR_openAppend(void *opaque, const char *filename) +static fvoid *DIR_openAppend(dvoid *opaque, const char *filename) { - return(doOpen(opaque, filename, __PHYSFS_platformOpenAppend, NULL, - &__PHYSFS_FileFunctions_DIRW)); + return(doOpen(opaque, filename, __PHYSFS_platformOpenAppend, NULL)); } /* DIR_openAppend */ -static int DIR_remove(void *opaque, const char *name) +static int DIR_remove(dvoid *opaque, const char *name) { char *f = __PHYSFS_platformCvtToDependent((char *) opaque, name, NULL); int retval; @@ -346,7 +291,7 @@ static int DIR_remove(void *opaque, const char *name) } /* DIR_remove */ -static int DIR_mkdir(void *opaque, const char *name) +static int DIR_mkdir(dvoid *opaque, const char *name) { char *f = __PHYSFS_platformCvtToDependent((char *) opaque, name, NULL); int retval; @@ -358,7 +303,7 @@ static int DIR_mkdir(void *opaque, const char *name) } /* DIR_mkdir */ -static void DIR_dirClose(void *opaque) +static void DIR_dirClose(dvoid *opaque) { free(opaque); } /* DIR_dirClose */ diff --git a/archivers/grp.c b/archivers/grp.c index 15440fc..fc4a1e1 100644 --- a/archivers/grp.c +++ b/archivers/grp.c @@ -61,30 +61,30 @@ typedef struct } GRPfileinfo; -static void GRP_dirClose(void *opaque); -static PHYSFS_sint64 GRP_read(FileHandle *handle, void *buffer, +static PHYSFS_sint64 GRP_read(fvoid *opaque, void *buffer, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount); -static PHYSFS_sint64 GRP_write(FileHandle *handle, const void *buffer, +static PHYSFS_sint64 GRP_write(fvoid *opaque, const void *buffer, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount); -static int GRP_eof(FileHandle *handle); -static PHYSFS_sint64 GRP_tell(FileHandle *handle); -static int GRP_seek(FileHandle *handle, PHYSFS_uint64 offset); -static PHYSFS_sint64 GRP_fileLength(FileHandle *handle); -static int GRP_fileClose(FileHandle *handle); +static int GRP_eof(fvoid *opaque); +static PHYSFS_sint64 GRP_tell(fvoid *opaque); +static int GRP_seek(fvoid *opaque, PHYSFS_uint64 offset); +static PHYSFS_sint64 GRP_fileLength(fvoid *opaque); +static int GRP_fileClose(fvoid *opaque); static int GRP_isArchive(const char *filename, int forWriting); static void *GRP_openArchive(const char *name, int forWriting); -static LinkedStringList *GRP_enumerateFiles(void *opaque, +static LinkedStringList *GRP_enumerateFiles(dvoid *opaque, const char *dirname, int omitSymLinks); -static int GRP_exists(void *opaque, const char *name); -static int GRP_isDirectory(void *opaque, const char *name, int *fileExists); -static int GRP_isSymLink(void *opaque, const char *name, int *fileExists); -static PHYSFS_sint64 GRP_getLastModTime(void *opaque, const char *n, int *e); -static FileHandle *GRP_openRead(void *opaque, const char *name, int *exist); -static FileHandle *GRP_openWrite(void *opaque, const char *name); -static FileHandle *GRP_openAppend(void *opaque, const char *name); -static int GRP_remove(void *opaque, const char *name); -static int GRP_mkdir(void *opaque, const char *name); +static int GRP_exists(dvoid *opaque, const char *name); +static int GRP_isDirectory(dvoid *opaque, const char *name, int *fileExists); +static int GRP_isSymLink(dvoid *opaque, const char *name, int *fileExists); +static PHYSFS_sint64 GRP_getLastModTime(dvoid *opaque, const char *n, int *e); +static fvoid *GRP_openRead(dvoid *opaque, const char *name, int *exist); +static fvoid *GRP_openWrite(dvoid *opaque, const char *name); +static fvoid *GRP_openAppend(dvoid *opaque, const char *name); +static int GRP_remove(dvoid *opaque, const char *name); +static int GRP_mkdir(dvoid *opaque, const char *name); +static void GRP_dirClose(dvoid *opaque); const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_GRP = { @@ -95,19 +95,7 @@ const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_GRP = }; -static const FileFunctions __PHYSFS_FileFunctions_GRP = -{ - GRP_read, /* read() method */ - GRP_write, /* write() method */ - GRP_eof, /* eof() method */ - GRP_tell, /* tell() method */ - GRP_seek, /* seek() method */ - GRP_fileLength, /* fileLength() method */ - GRP_fileClose /* fileClose() method */ -}; - - -const DirFunctions __PHYSFS_DirFunctions_GRP = +const PHYSFS_Archiver __PHYSFS_Archiver_GRP = { &__PHYSFS_ArchiveInfo_GRP, GRP_isArchive, /* isArchive() method */ @@ -122,12 +110,19 @@ const DirFunctions __PHYSFS_DirFunctions_GRP = GRP_openAppend, /* openAppend() method */ GRP_remove, /* remove() method */ GRP_mkdir, /* mkdir() method */ - GRP_dirClose /* dirClose() method */ + GRP_dirClose, /* dirClose() method */ + GRP_read, /* read() method */ + GRP_write, /* write() method */ + GRP_eof, /* eof() method */ + GRP_tell, /* tell() method */ + GRP_seek, /* seek() method */ + GRP_fileLength, /* fileLength() method */ + GRP_fileClose /* fileClose() method */ }; -static void GRP_dirClose(void *opaque) +static void GRP_dirClose(dvoid *opaque) { GRPinfo *info = ((GRPinfo *) opaque); free(info->filename); @@ -136,10 +131,10 @@ static void GRP_dirClose(void *opaque) } /* GRP_dirClose */ -static PHYSFS_sint64 GRP_read(FileHandle *handle, void *buffer, +static PHYSFS_sint64 GRP_read(fvoid *opaque, void *buffer, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount) { - GRPfileinfo *finfo = (GRPfileinfo *) (handle->opaque); + GRPfileinfo *finfo = (GRPfileinfo *) opaque; GRPentry *entry = finfo->entry; PHYSFS_uint32 bytesLeft = entry->size - finfo->curPos; PHYSFS_uint32 objsLeft = (bytesLeft / objSize); @@ -156,30 +151,30 @@ static PHYSFS_sint64 GRP_read(FileHandle *handle, void *buffer, } /* GRP_read */ -static PHYSFS_sint64 GRP_write(FileHandle *handle, const void *buffer, +static PHYSFS_sint64 GRP_write(fvoid *opaque, const void *buffer, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount) { BAIL_MACRO(ERR_NOT_SUPPORTED, -1); } /* GRP_write */ -static int GRP_eof(FileHandle *handle) +static int GRP_eof(fvoid *opaque) { - GRPfileinfo *finfo = (GRPfileinfo *) (handle->opaque); + GRPfileinfo *finfo = (GRPfileinfo *) opaque; GRPentry *entry = finfo->entry; return(finfo->curPos >= entry->size); } /* GRP_eof */ -static PHYSFS_sint64 GRP_tell(FileHandle *handle) +static PHYSFS_sint64 GRP_tell(fvoid *opaque) { - return(((GRPfileinfo *) (handle->opaque))->curPos); + return(((GRPfileinfo *) opaque)->curPos); } /* GRP_tell */ -static int GRP_seek(FileHandle *handle, PHYSFS_uint64 offset) +static int GRP_seek(fvoid *opaque, PHYSFS_uint64 offset) { - GRPfileinfo *finfo = (GRPfileinfo *) (handle->opaque); + GRPfileinfo *finfo = (GRPfileinfo *) opaque; GRPentry *entry = finfo->entry; int rc; @@ -193,19 +188,18 @@ static int GRP_seek(FileHandle *handle, PHYSFS_uint64 offset) } /* GRP_seek */ -static PHYSFS_sint64 GRP_fileLength(FileHandle *handle) +static PHYSFS_sint64 GRP_fileLength(fvoid *opaque) { - GRPfileinfo *finfo = ((GRPfileinfo *) handle->opaque); + GRPfileinfo *finfo = (GRPfileinfo *) opaque; return((PHYSFS_sint64) finfo->entry->size); } /* GRP_fileLength */ -static int GRP_fileClose(FileHandle *handle) +static int GRP_fileClose(fvoid *opaque) { - GRPfileinfo *finfo = ((GRPfileinfo *) handle->opaque); + GRPfileinfo *finfo = (GRPfileinfo *) opaque; BAIL_IF_MACRO(!__PHYSFS_platformClose(finfo->handle), NULL, 0); free(finfo); - free(handle); return(1); } /* GRP_fileClose */ @@ -365,11 +359,11 @@ GRP_openArchive_failed: } /* GRP_openArchive */ -static LinkedStringList *GRP_enumerateFiles(void *opaque, +static LinkedStringList *GRP_enumerateFiles(dvoid *opaque, const char *dirname, int omitSymLinks) { - GRPinfo *info = ((GRPinfo *) opaque); + GRPinfo *info = (GRPinfo *) opaque; GRPentry *entry = info->entries; LinkedStringList *retval = NULL, *p = NULL; PHYSFS_uint32 max = info->entryCount; @@ -418,31 +412,31 @@ static GRPentry *grp_find_entry(GRPinfo *info, const char *name) } /* grp_find_entry */ -static int GRP_exists(void *opaque, const char *name) +static int GRP_exists(dvoid *opaque, const char *name) { - return(grp_find_entry(((GRPinfo *) opaque), name) != NULL); + return(grp_find_entry((GRPinfo *) opaque, name) != NULL); } /* GRP_exists */ -static int GRP_isDirectory(void *opaque, const char *name, int *fileExists) +static int GRP_isDirectory(dvoid *opaque, const char *name, int *fileExists) { *fileExists = GRP_exists(opaque, name); return(0); /* never directories in a groupfile. */ } /* GRP_isDirectory */ -static int GRP_isSymLink(void *opaque, const char *name, int *fileExists) +static int GRP_isSymLink(dvoid *opaque, const char *name, int *fileExists) { *fileExists = GRP_exists(opaque, name); return(0); /* never symlinks in a groupfile. */ } /* GRP_isSymLink */ -static PHYSFS_sint64 GRP_getLastModTime(void *opaque, +static PHYSFS_sint64 GRP_getLastModTime(dvoid *opaque, const char *name, int *fileExists) { - GRPinfo *info = ((GRPinfo *) opaque); + GRPinfo *info = (GRPinfo *) opaque; PHYSFS_sint64 retval = -1; *fileExists = (grp_find_entry(info, name) != NULL); @@ -453,10 +447,9 @@ static PHYSFS_sint64 GRP_getLastModTime(void *opaque, } /* GRP_getLastModTime */ -static FileHandle *GRP_openRead(void *opaque, const char *fnm, int *fileExists) +static fvoid *GRP_openRead(dvoid *opaque, const char *fnm, int *fileExists) { - GRPinfo *info = ((GRPinfo *) opaque); - FileHandle *retval; + GRPinfo *info = (GRPinfo *) opaque; GRPfileinfo *finfo; GRPentry *entry; @@ -464,51 +457,42 @@ static FileHandle *GRP_openRead(void *opaque, const char *fnm, int *fileExists) *fileExists = (entry != NULL); BAIL_IF_MACRO(entry == NULL, NULL, NULL); - retval = (FileHandle *) malloc(sizeof (FileHandle)); - BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL); finfo = (GRPfileinfo *) malloc(sizeof (GRPfileinfo)); - if (finfo == NULL) - { - free(retval); - BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL); - } /* if */ + BAIL_IF_MACRO(finfo == NULL, ERR_OUT_OF_MEMORY, NULL); finfo->handle = __PHYSFS_platformOpenRead(info->filename); if ( (finfo->handle == NULL) || (!__PHYSFS_platformSeek(finfo->handle, entry->startPos)) ) { free(finfo); - free(retval); return(NULL); } /* if */ finfo->curPos = 0; finfo->entry = entry; - retval->opaque = (void *) finfo; - retval->funcs = &__PHYSFS_FileFunctions_GRP; - return(retval); + return(finfo); } /* GRP_openRead */ -static FileHandle *GRP_openWrite(void *opaque, const char *name) +static fvoid *GRP_openWrite(dvoid *opaque, const char *name) { BAIL_MACRO(ERR_NOT_SUPPORTED, NULL); } /* GRP_openWrite */ -static FileHandle *GRP_openAppend(void *opaque, const char *name) +static fvoid *GRP_openAppend(dvoid *opaque, const char *name) { BAIL_MACRO(ERR_NOT_SUPPORTED, NULL); } /* GRP_openAppend */ -static int GRP_remove(void *opaque, const char *name) +static int GRP_remove(dvoid *opaque, const char *name) { BAIL_MACRO(ERR_NOT_SUPPORTED, 0); } /* GRP_remove */ -static int GRP_mkdir(void *opaque, const char *name) +static int GRP_mkdir(dvoid *opaque, const char *name) { BAIL_MACRO(ERR_NOT_SUPPORTED, 0); } /* GRP_mkdir */ diff --git a/archivers/hog.c b/archivers/hog.c index b9ec1df..ee4ecfb 100644 --- a/archivers/hog.c +++ b/archivers/hog.c @@ -75,30 +75,30 @@ typedef struct } HOGfileinfo; -static void HOG_dirClose(void *opaque); -static PHYSFS_sint64 HOG_read(FileHandle *handle, void *buffer, +static PHYSFS_sint64 HOG_read(fvoid *opaque, void *buffer, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount); -static PHYSFS_sint64 HOG_write(FileHandle *handle, const void *buffer, +static PHYSFS_sint64 HOG_write(fvoid *opaque, const void *buffer, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount); -static int HOG_eof(FileHandle *handle); -static PHYSFS_sint64 HOG_tell(FileHandle *handle); -static int HOG_seek(FileHandle *handle, PHYSFS_uint64 offset); -static PHYSFS_sint64 HOG_fileLength(FileHandle *handle); -static int HOG_fileClose(FileHandle *handle); +static int HOG_eof(fvoid *opaque); +static PHYSFS_sint64 HOG_tell(fvoid *opaque); +static int HOG_seek(fvoid *opaque, PHYSFS_uint64 offset); +static PHYSFS_sint64 HOG_fileLength(fvoid *opaque); +static int HOG_fileClose(fvoid *opaque); static int HOG_isArchive(const char *filename, int forWriting); static void *HOG_openArchive(const char *name, int forWriting); -static LinkedStringList *HOG_enumerateFiles(void *opaque, +static LinkedStringList *HOG_enumerateFiles(dvoid *opaque, const char *dirname, int omitSymLinks); -static int HOG_exists(void *opaque, const char *name); -static int HOG_isDirectory(void *opaque, const char *name, int *fileExists); -static int HOG_isSymLink(void *opaque, const char *name, int *fileExists); -static PHYSFS_sint64 HOG_getLastModTime(void *opaque, const char *n, int *e); -static FileHandle *HOG_openRead(void *opaque, const char *name, int *exist); -static FileHandle *HOG_openWrite(void *opaque, const char *name); -static FileHandle *HOG_openAppend(void *opaque, const char *name); -static int HOG_remove(void *opaque, const char *name); -static int HOG_mkdir(void *opaque, const char *name); +static int HOG_exists(dvoid *opaque, const char *name); +static int HOG_isDirectory(dvoid *opaque, const char *name, int *fileExists); +static int HOG_isSymLink(dvoid *opaque, const char *name, int *fileExists); +static PHYSFS_sint64 HOG_getLastModTime(dvoid *opaque, const char *n, int *e); +static fvoid *HOG_openRead(dvoid *opaque, const char *name, int *exist); +static fvoid *HOG_openWrite(dvoid *opaque, const char *name); +static fvoid *HOG_openAppend(dvoid *opaque, const char *name); +static int HOG_remove(dvoid *opaque, const char *name); +static int HOG_mkdir(dvoid *opaque, const char *name); +static void HOG_dirClose(dvoid *opaque); const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_HOG = { @@ -109,19 +109,7 @@ const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_HOG = }; -static const FileFunctions __PHYSFS_FileFunctions_HOG = -{ - HOG_read, /* read() method */ - HOG_write, /* write() method */ - HOG_eof, /* eof() method */ - HOG_tell, /* tell() method */ - HOG_seek, /* seek() method */ - HOG_fileLength, /* fileLength() method */ - HOG_fileClose /* fileClose() method */ -}; - - -const DirFunctions __PHYSFS_DirFunctions_HOG = +const PHYSFS_Archiver __PHYSFS_Archiver_HOG = { &__PHYSFS_ArchiveInfo_HOG, HOG_isArchive, /* isArchive() method */ @@ -136,12 +124,19 @@ const DirFunctions __PHYSFS_DirFunctions_HOG = HOG_openAppend, /* openAppend() method */ HOG_remove, /* remove() method */ HOG_mkdir, /* mkdir() method */ - HOG_dirClose /* dirClose() method */ + HOG_dirClose, /* dirClose() method */ + HOG_read, /* read() method */ + HOG_write, /* write() method */ + HOG_eof, /* eof() method */ + HOG_tell, /* tell() method */ + HOG_seek, /* seek() method */ + HOG_fileLength, /* fileLength() method */ + HOG_fileClose /* fileClose() method */ }; -static void HOG_dirClose(void *opaque) +static void HOG_dirClose(dvoid *opaque) { HOGinfo *info = ((HOGinfo *) opaque); free(info->filename); @@ -150,10 +145,10 @@ static void HOG_dirClose(void *opaque) } /* HOG_dirClose */ -static PHYSFS_sint64 HOG_read(FileHandle *handle, void *buffer, +static PHYSFS_sint64 HOG_read(fvoid *opaque, void *buffer, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount) { - HOGfileinfo *finfo = (HOGfileinfo *) (handle->opaque); + HOGfileinfo *finfo = (HOGfileinfo *) opaque; HOGentry *entry = finfo->entry; PHYSFS_uint32 bytesLeft = entry->size - finfo->curPos; PHYSFS_uint32 objsLeft = (bytesLeft / objSize); @@ -170,30 +165,30 @@ static PHYSFS_sint64 HOG_read(FileHandle *handle, void *buffer, } /* HOG_read */ -static PHYSFS_sint64 HOG_write(FileHandle *handle, const void *buffer, +static PHYSFS_sint64 HOG_write(fvoid *opaque, const void *buffer, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount) { BAIL_MACRO(ERR_NOT_SUPPORTED, -1); } /* HOG_write */ -static int HOG_eof(FileHandle *handle) +static int HOG_eof(fvoid *opaque) { - HOGfileinfo *finfo = (HOGfileinfo *) (handle->opaque); + HOGfileinfo *finfo = (HOGfileinfo *) opaque; HOGentry *entry = finfo->entry; return(finfo->curPos >= entry->size); } /* HOG_eof */ -static PHYSFS_sint64 HOG_tell(FileHandle *handle) +static PHYSFS_sint64 HOG_tell(fvoid *opaque) { - return(((HOGfileinfo *) (handle->opaque))->curPos); + return(((HOGfileinfo *) opaque)->curPos); } /* HOG_tell */ -static int HOG_seek(FileHandle *handle, PHYSFS_uint64 offset) +static int HOG_seek(fvoid *opaque, PHYSFS_uint64 offset) { - HOGfileinfo *finfo = (HOGfileinfo *) (handle->opaque); + HOGfileinfo *finfo = (HOGfileinfo *) opaque; HOGentry *entry = finfo->entry; int rc; @@ -207,19 +202,18 @@ static int HOG_seek(FileHandle *handle, PHYSFS_uint64 offset) } /* HOG_seek */ -static PHYSFS_sint64 HOG_fileLength(FileHandle *handle) +static PHYSFS_sint64 HOG_fileLength(fvoid *opaque) { - HOGfileinfo *finfo = ((HOGfileinfo *) handle->opaque); + HOGfileinfo *finfo = (HOGfileinfo *) opaque; return((PHYSFS_sint64) finfo->entry->size); } /* HOG_fileLength */ -static int HOG_fileClose(FileHandle *handle) +static int HOG_fileClose(fvoid *opaque) { - HOGfileinfo *finfo = ((HOGfileinfo *) handle->opaque); + HOGfileinfo *finfo = (HOGfileinfo *) opaque; BAIL_IF_MACRO(!__PHYSFS_platformClose(finfo->handle), NULL, 0); free(finfo); - free(handle); return(1); } /* HOG_fileClose */ @@ -404,7 +398,7 @@ HOG_openArchive_failed: } /* HOG_openArchive */ -static LinkedStringList *HOG_enumerateFiles(void *opaque, +static LinkedStringList *HOG_enumerateFiles(dvoid *opaque, const char *dirname, int omitSymLinks) { @@ -457,27 +451,27 @@ static HOGentry *hog_find_entry(HOGinfo *info, const char *name) } /* hog_find_entry */ -static int HOG_exists(void *opaque, const char *name) +static int HOG_exists(dvoid *opaque, const char *name) { return(hog_find_entry(((HOGinfo *) opaque), name) != NULL); } /* HOG_exists */ -static int HOG_isDirectory(void *opaque, const char *name, int *fileExists) +static int HOG_isDirectory(dvoid *opaque, const char *name, int *fileExists) { *fileExists = HOG_exists(opaque, name); return(0); /* never directories in a groupfile. */ } /* HOG_isDirectory */ -static int HOG_isSymLink(void *opaque, const char *name, int *fileExists) +static int HOG_isSymLink(dvoid *opaque, const char *name, int *fileExists) { *fileExists = HOG_exists(opaque, name); return(0); /* never symlinks in a groupfile. */ } /* HOG_isSymLink */ -static PHYSFS_sint64 HOG_getLastModTime(void *opaque, +static PHYSFS_sint64 HOG_getLastModTime(dvoid *opaque, const char *name, int *fileExists) { @@ -492,10 +486,9 @@ static PHYSFS_sint64 HOG_getLastModTime(void *opaque, } /* HOG_getLastModTime */ -static FileHandle *HOG_openRead(void *opaque, const char *fnm, int *fileExists) +static fvoid *HOG_openRead(dvoid *opaque, const char *fnm, int *fileExists) { HOGinfo *info = ((HOGinfo *) opaque); - FileHandle *retval; HOGfileinfo *finfo; HOGentry *entry; @@ -503,51 +496,42 @@ static FileHandle *HOG_openRead(void *opaque, const char *fnm, int *fileExists) *fileExists = (entry != NULL); BAIL_IF_MACRO(entry == NULL, NULL, NULL); - retval = (FileHandle *) malloc(sizeof (FileHandle)); - BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL); finfo = (HOGfileinfo *) malloc(sizeof (HOGfileinfo)); - if (finfo == NULL) - { - free(retval); - BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL); - } /* if */ + BAIL_IF_MACRO(finfo == NULL, ERR_OUT_OF_MEMORY, NULL); finfo->handle = __PHYSFS_platformOpenRead(info->filename); if ( (finfo->handle == NULL) || (!__PHYSFS_platformSeek(finfo->handle, entry->startPos)) ) { free(finfo); - free(retval); return(NULL); } /* if */ finfo->curPos = 0; finfo->entry = entry; - retval->opaque = (void *) finfo; - retval->funcs = &__PHYSFS_FileFunctions_HOG; - return(retval); + return(finfo); } /* HOG_openRead */ -static FileHandle *HOG_openWrite(void *opaque, const char *name) +static fvoid *HOG_openWrite(dvoid *opaque, const char *name) { BAIL_MACRO(ERR_NOT_SUPPORTED, NULL); } /* HOG_openWrite */ -static FileHandle *HOG_openAppend(void *opaque, const char *name) +static fvoid *HOG_openAppend(dvoid *opaque, const char *name) { BAIL_MACRO(ERR_NOT_SUPPORTED, NULL); } /* HOG_openAppend */ -static int HOG_remove(void *opaque, const char *name) +static int HOG_remove(dvoid *opaque, const char *name) { BAIL_MACRO(ERR_NOT_SUPPORTED, 0); } /* HOG_remove */ -static int HOG_mkdir(void *opaque, const char *name) +static int HOG_mkdir(dvoid *opaque, const char *name) { BAIL_MACRO(ERR_NOT_SUPPORTED, 0); } /* HOG_mkdir */ diff --git a/archivers/mix.c b/archivers/mix.c index b0ea88d..f00e763 100644 --- a/archivers/mix.c +++ b/archivers/mix.c @@ -80,30 +80,30 @@ typedef struct void *handle; /* filehandle */ } MIXfileinfo; -static void MIX_dirClose(void *opaque); -static PHYSFS_sint64 MIX_read(FileHandle *handle, void *buffer, +static PHYSFS_sint64 MIX_read(fvoid *opaque, void *buffer, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount); -static PHYSFS_sint64 MIX_write(FileHandle *handle, const void *buffer, +static PHYSFS_sint64 MIX_write(fvoid *opaque, const void *buffer, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount); -static int MIX_eof(FileHandle *handle); -static PHYSFS_sint64 MIX_tell(FileHandle *handle); -static int MIX_seek(FileHandle *handle, PHYSFS_uint64 offset); -static PHYSFS_sint64 MIX_fileLength(FileHandle *handle); -static int MIX_fileClose(FileHandle *handle); +static int MIX_eof(fvoid *opaque); +static PHYSFS_sint64 MIX_tell(fvoid *opaque); +static int MIX_seek(fvoid *opaque, PHYSFS_uint64 offset); +static PHYSFS_sint64 MIX_fileLength(fvoid *opaque); +static int MIX_fileClose(fvoid *opaque); static int MIX_isArchive(const char *filename, int forWriting); static void *MIX_openArchive(const char *name, int forWriting); -static LinkedStringList *MIX_enumerateFiles(void *opaque, +static LinkedStringList *MIX_enumerateFiles(dvoid *opaque, const char *dirname, int omitSymLinks); -static int MIX_exists(void *opaque, const char *name); -static int MIX_isDirectory(void *opaque, const char *name, int *fileExists); -static int MIX_isSymLink(void *opaque, const char *name, int *fileExists); -static PHYSFS_sint64 MIX_getLastModTime(void *opaque, const char *n, int *e); -static FileHandle *MIX_openRead(void *opaque, const char *name, int *exist); -static FileHandle *MIX_openWrite(void *opaque, const char *name); -static FileHandle *MIX_openAppend(void *opaque, const char *name); -static int MIX_remove(void *opaque, const char *name); -static int MIX_mkdir(void *opaque, const char *name); +static int MIX_exists(dvoid *opaque, const char *name); +static int MIX_isDirectory(dvoid *opaque, const char *name, int *fileExists); +static int MIX_isSymLink(dvoid *opaque, const char *name, int *fileExists); +static PHYSFS_sint64 MIX_getLastModTime(dvoid *opaque, const char *n, int *e); +static fvoid *MIX_openRead(dvoid *opaque, const char *name, int *exist); +static fvoid *MIX_openWrite(dvoid *opaque, const char *name); +static fvoid *MIX_openAppend(dvoid *opaque, const char *name); +static int MIX_remove(dvoid *opaque, const char *name); +static int MIX_mkdir(dvoid *opaque, const char *name); +static void MIX_dirClose(dvoid *opaque); const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_MIX = { @@ -114,19 +114,7 @@ const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_MIX = }; -static const FileFunctions __PHYSFS_FileFunctions_MIX = -{ - MIX_read, /* read() method */ - MIX_write, /* write() method */ - MIX_eof, /* eof() method */ - MIX_tell, /* tell() method */ - MIX_seek, /* seek() method */ - MIX_fileLength, /* fileLength() method */ - MIX_fileClose /* fileClose() method */ -}; - - -const DirFunctions __PHYSFS_DirFunctions_MIX = +const PHYSFS_Archiver __PHYSFS_Archiver_MIX = { &__PHYSFS_ArchiveInfo_MIX, MIX_isArchive, /* isArchive() method */ @@ -141,9 +129,17 @@ const DirFunctions __PHYSFS_DirFunctions_MIX = MIX_openAppend, /* openAppend() method */ MIX_remove, /* remove() method */ MIX_mkdir, /* mkdir() method */ - MIX_dirClose /* dirClose() method */ + MIX_dirClose, /* dirClose() method */ + MIX_read, /* read() method */ + MIX_write, /* write() method */ + MIX_eof, /* eof() method */ + MIX_tell, /* tell() method */ + MIX_seek, /* seek() method */ + MIX_fileLength, /* fileLength() method */ + MIX_fileClose /* fileClose() method */ }; + static PHYSFS_uint32 MIX_hash(const char *name) { PHYSFS_uint32 id = 0; @@ -176,7 +172,7 @@ static PHYSFS_uint32 MIX_hash(const char *name) } /* MIX_hash */ -static void MIX_dirClose(void *opaque) +static void MIX_dirClose(dvoid *opaque) { MIXinfo *info = ((MIXinfo *) opaque); free(info->entry); @@ -184,10 +180,10 @@ static void MIX_dirClose(void *opaque) } /* MIX_dirClose */ -static PHYSFS_sint64 MIX_read(FileHandle *handle, void *buffer, +static PHYSFS_sint64 MIX_read(fvoid *opaque, void *buffer, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount) { - MIXfileinfo *finfo = (MIXfileinfo*)handle->opaque; + MIXfileinfo *finfo = (MIXfileinfo *) opaque; MIXentry *entry = finfo->entry; PHYSFS_uint32 read; @@ -208,29 +204,29 @@ static PHYSFS_sint64 MIX_read(FileHandle *handle, void *buffer, } /* MIX_read */ -static PHYSFS_sint64 MIX_write(FileHandle *handle, const void *buffer, +static PHYSFS_sint64 MIX_write(fvoid *opaque, const void *buffer, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount) { BAIL_MACRO(ERR_NOT_SUPPORTED, -1); } /* MIX_write */ -static int MIX_eof(FileHandle *handle) +static int MIX_eof(fvoid *opaque) { - MIXfileinfo *fifo = (MIXfileinfo *) handle->opaque; + MIXfileinfo *fifo = (MIXfileinfo *) opaque; return(fifo->cur_pos >= fifo->size); } /* MIX_eof */ -static PHYSFS_sint64 MIX_tell(FileHandle *handle) +static PHYSFS_sint64 MIX_tell(fvoid *opaque) { - return(((MIXfileinfo *) (handle->opaque))->cur_pos); + return(((MIXfileinfo *) opaque)->cur_pos); } /* MIX_tell */ -static int MIX_seek(FileHandle *handle, PHYSFS_uint64 offset) +static int MIX_seek(fvoid *opaque, PHYSFS_uint64 offset) { - MIXfileinfo *h = (MIXfileinfo *) (handle->opaque); + MIXfileinfo *h = (MIXfileinfo *) opaque; BAIL_IF_MACRO(offset < 0, ERR_INVALID_ARGUMENT, 0); BAIL_IF_MACRO(offset >= h->size, ERR_PAST_EOF, 0); @@ -239,25 +235,24 @@ static int MIX_seek(FileHandle *handle, PHYSFS_uint64 offset) } /* MIX_seek */ -static PHYSFS_sint64 MIX_fileLength(FileHandle *handle) +static PHYSFS_sint64 MIX_fileLength(fvoid *opaque) { - return (((MIXfileinfo *) (handle->opaque))->size); + return (((MIXfileinfo *) opaque)->size); } /* MIX_fileLength */ -static int MIX_fileClose(FileHandle *handle) +static int MIX_fileClose(fvoid *opaque) { - MIXfileinfo *finfo = (MIXfileinfo *) handle->opaque; + MIXfileinfo *finfo = (MIXfileinfo *) opaque; __PHYSFS_platformClose(finfo->handle); free(finfo); - free(handle); return(1); } /* MIX_fileClose */ static int MIX_isArchive(const char *filename, int forWriting) { - /* TODO: + /* !!! FIXME: write a simple detection routine for MIX files. Unfortunaly MIX files have no ID in the header. */ @@ -359,7 +354,7 @@ MIX_openArchive_failed: } /* MIX_openArchive */ -static LinkedStringList *MIX_enumerateFiles(void *opaque, +static LinkedStringList *MIX_enumerateFiles(dvoid *opaque, const char *dirname, int omitSymLinks) { @@ -399,27 +394,27 @@ static MIXentry *MIX_find_entry(MIXinfo *info, const char *name) } /* MIX_find_entry */ -static int MIX_exists(void *opaque, const char *name) +static int MIX_exists(dvoid *opaque, const char *name) { return(MIX_find_entry(((MIXinfo *) opaque), name) != NULL); } /* MIX_exists */ -static int MIX_isDirectory(void *opaque, const char *name, int *fileExists) +static int MIX_isDirectory(dvoid *opaque, const char *name, int *fileExists) { *fileExists = MIX_exists(opaque, name); return(0); /* never directories in a MIX */ } /* MIX_isDirectory */ -static int MIX_isSymLink(void *opaque, const char *name, int *fileExists) +static int MIX_isSymLink(dvoid *opaque, const char *name, int *fileExists) { *fileExists = MIX_exists(opaque, name); return(0); /* never symlinks in a MIX. */ } /* MIX_isSymLink */ -static PHYSFS_sint64 MIX_getLastModTime(void *opaque, +static PHYSFS_sint64 MIX_getLastModTime(dvoid *opaque, const char *name, int *fileExists) { @@ -427,9 +422,8 @@ static PHYSFS_sint64 MIX_getLastModTime(void *opaque, } /* MIX_getLastModTime */ -static FileHandle *MIX_openRead(void *opaque, const char *fnm, int *fileExists) +static fvoid *MIX_openRead(dvoid *opaque, const char *fnm, int *fileExists) { - FileHandle *retval; MIXinfo *info = ((MIXinfo*) opaque); MIXfileinfo *finfo; MIXentry *entry; @@ -441,56 +435,44 @@ static FileHandle *MIX_openRead(void *opaque, const char *fnm, int *fileExists) /* allocate a MIX handle */ finfo = (MIXfileinfo *) malloc(sizeof (MIXfileinfo)); BAIL_IF_MACRO(finfo == NULL, ERR_OUT_OF_MEMORY, NULL); - - /* allocate a filehandle */ - retval = (FileHandle*) malloc(sizeof (FileHandle)); - if (!retval) - { - free(finfo); - BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL); - } /* if */ /* open the archive */ finfo->handle = __PHYSFS_platformOpenRead(info->filename); if(!finfo->handle) { free(finfo); - free(retval); return(NULL); - }; + } /* if */ /* setup structures */ finfo->cur_pos = 0; finfo->info = info; finfo->entry = entry; finfo->size = entry->end_offset - entry->start_offset; - - retval->opaque = (void *) finfo; - retval->funcs = &__PHYSFS_FileFunctions_MIX; - return(retval); + return(finfo); } /* MIX_openRead */ -static FileHandle *MIX_openWrite(void *opaque, const char *name) +static fvoid *MIX_openWrite(dvoid *opaque, const char *name) { BAIL_MACRO(ERR_NOT_SUPPORTED, NULL); } /* MIX_openWrite */ -static FileHandle *MIX_openAppend(void *opaque, const char *name) +static fvoid *MIX_openAppend(dvoid *opaque, const char *name) { BAIL_MACRO(ERR_NOT_SUPPORTED, NULL); } /* MIX_openAppend */ -static int MIX_remove(void *opaque, const char *name) +static int MIX_remove(dvoid *opaque, const char *name) { BAIL_MACRO(ERR_NOT_SUPPORTED, 0); } /* MIX_remove */ -static int MIX_mkdir(void *opaque, const char *name) +static int MIX_mkdir(dvoid *opaque, const char *name) { BAIL_MACRO(ERR_NOT_SUPPORTED, 0); } /* MIX_mkdir */ diff --git a/archivers/mvl.c b/archivers/mvl.c index 14ed327..165bda6 100644 --- a/archivers/mvl.c +++ b/archivers/mvl.c @@ -64,30 +64,30 @@ typedef struct } MVLfileinfo; -static void MVL_dirClose(void *opaque); -static PHYSFS_sint64 MVL_read(FileHandle *handle, void *buffer, +static PHYSFS_sint64 MVL_read(fvoid *opaque, void *buffer, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount); -static PHYSFS_sint64 MVL_write(FileHandle *handle, const void *buffer, +static PHYSFS_sint64 MVL_write(fvoid *opaque, const void *buffer, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount); -static int MVL_eof(FileHandle *handle); -static PHYSFS_sint64 MVL_tell(FileHandle *handle); -static int MVL_seek(FileHandle *handle, PHYSFS_uint64 offset); -static PHYSFS_sint64 MVL_fileLength(FileHandle *handle); -static int MVL_fileClose(FileHandle *handle); +static int MVL_eof(fvoid *opaque); +static PHYSFS_sint64 MVL_tell(fvoid *opaque); +static int MVL_seek(fvoid *opaque, PHYSFS_uint64 offset); +static PHYSFS_sint64 MVL_fileLength(fvoid *opaque); +static int MVL_fileClose(fvoid *opaque); static int MVL_isArchive(const char *filename, int forWriting); static void *MVL_openArchive(const char *name, int forWriting); -static LinkedStringList *MVL_enumerateFiles(void *opaque, +static LinkedStringList *MVL_enumerateFiles(dvoid *opaque, const char *dirname, int omitSymLinks); -static int MVL_exists(void *opaque, const char *name); -static int MVL_isDirectory(void *opaque, const char *name, int *fileExists); -static int MVL_isSymLink(void *opaque, const char *name, int *fileExists); -static PHYSFS_sint64 MVL_getLastModTime(void *opaque, const char *n, int *e); -static FileHandle *MVL_openRead(void *opaque, const char *name, int *exist); -static FileHandle *MVL_openWrite(void *opaque, const char *name); -static FileHandle *MVL_openAppend(void *opaque, const char *name); -static int MVL_remove(void *opaque, const char *name); -static int MVL_mkdir(void *opaque, const char *name); +static int MVL_exists(dvoid *opaque, const char *name); +static int MVL_isDirectory(dvoid *opaque, const char *name, int *fileExists); +static int MVL_isSymLink(dvoid *opaque, const char *name, int *fileExists); +static PHYSFS_sint64 MVL_getLastModTime(dvoid *opaque, const char *n, int *e); +static fvoid *MVL_openRead(dvoid *opaque, const char *name, int *exist); +static fvoid *MVL_openWrite(dvoid *opaque, const char *name); +static fvoid *MVL_openAppend(dvoid *opaque, const char *name); +static int MVL_remove(dvoid *opaque, const char *name); +static int MVL_mkdir(dvoid *opaque, const char *name); +static void MVL_dirClose(dvoid *opaque); const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_MVL = { @@ -98,19 +98,7 @@ const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_MVL = }; -static const FileFunctions __PHYSFS_FileFunctions_MVL = -{ - MVL_read, /* read() method */ - MVL_write, /* write() method */ - MVL_eof, /* eof() method */ - MVL_tell, /* tell() method */ - MVL_seek, /* seek() method */ - MVL_fileLength, /* fileLength() method */ - MVL_fileClose /* fileClose() method */ -}; - - -const DirFunctions __PHYSFS_DirFunctions_MVL = +const PHYSFS_Archiver __PHYSFS_Archiver_MVL = { &__PHYSFS_ArchiveInfo_MVL, MVL_isArchive, /* isArchive() method */ @@ -125,12 +113,19 @@ const DirFunctions __PHYSFS_DirFunctions_MVL = MVL_openAppend, /* openAppend() method */ MVL_remove, /* remove() method */ MVL_mkdir, /* mkdir() method */ - MVL_dirClose /* dirClose() method */ + MVL_dirClose, /* dirClose() method */ + MVL_read, /* read() method */ + MVL_write, /* write() method */ + MVL_eof, /* eof() method */ + MVL_tell, /* tell() method */ + MVL_seek, /* seek() method */ + MVL_fileLength, /* fileLength() method */ + MVL_fileClose /* fileClose() method */ }; -static void MVL_dirClose(void *opaque) +static void MVL_dirClose(dvoid *opaque) { MVLinfo *info = ((MVLinfo *) opaque); free(info->filename); @@ -139,10 +134,10 @@ static void MVL_dirClose(void *opaque) } /* MVL_dirClose */ -static PHYSFS_sint64 MVL_read(FileHandle *handle, void *buffer, +static PHYSFS_sint64 MVL_read(fvoid *opaque, void *buffer, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount) { - MVLfileinfo *finfo = (MVLfileinfo *) (handle->opaque); + MVLfileinfo *finfo = (MVLfileinfo *) opaque; MVLentry *entry = finfo->entry; PHYSFS_uint32 bytesLeft = entry->size - finfo->curPos; PHYSFS_uint32 objsLeft = (bytesLeft / objSize); @@ -159,30 +154,30 @@ static PHYSFS_sint64 MVL_read(FileHandle *handle, void *buffer, } /* MVL_read */ -static PHYSFS_sint64 MVL_write(FileHandle *handle, const void *buffer, +static PHYSFS_sint64 MVL_write(fvoid *opaque, const void *buffer, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount) { BAIL_MACRO(ERR_NOT_SUPPORTED, -1); } /* MVL_write */ -static int MVL_eof(FileHandle *handle) +static int MVL_eof(fvoid *opaque) { - MVLfileinfo *finfo = (MVLfileinfo *) (handle->opaque); + MVLfileinfo *finfo = (MVLfileinfo *) opaque; MVLentry *entry = finfo->entry; return(finfo->curPos >= entry->size); } /* MVL_eof */ -static PHYSFS_sint64 MVL_tell(FileHandle *handle) +static PHYSFS_sint64 MVL_tell(fvoid *opaque) { - return(((MVLfileinfo *) (handle->opaque))->curPos); + return(((MVLfileinfo *) opaque)->curPos); } /* MVL_tell */ -static int MVL_seek(FileHandle *handle, PHYSFS_uint64 offset) +static int MVL_seek(fvoid *opaque, PHYSFS_uint64 offset) { - MVLfileinfo *finfo = (MVLfileinfo *) (handle->opaque); + MVLfileinfo *finfo = (MVLfileinfo *) opaque; MVLentry *entry = finfo->entry; int rc; @@ -196,19 +191,18 @@ static int MVL_seek(FileHandle *handle, PHYSFS_uint64 offset) } /* MVL_seek */ -static PHYSFS_sint64 MVL_fileLength(FileHandle *handle) +static PHYSFS_sint64 MVL_fileLength(fvoid *opaque) { - MVLfileinfo *finfo = ((MVLfileinfo *) handle->opaque); + MVLfileinfo *finfo = (MVLfileinfo *) opaque; return((PHYSFS_sint64) finfo->entry->size); } /* MVL_fileLength */ -static int MVL_fileClose(FileHandle *handle) +static int MVL_fileClose(fvoid *opaque) { - MVLfileinfo *finfo = ((MVLfileinfo *) handle->opaque); + MVLfileinfo *finfo = (MVLfileinfo *) opaque; BAIL_IF_MACRO(!__PHYSFS_platformClose(finfo->handle), NULL, 0); free(finfo); - free(handle); return(1); } /* MVL_fileClose */ @@ -362,7 +356,7 @@ MVL_openArchive_failed: } /* MVL_openArchive */ -static LinkedStringList *MVL_enumerateFiles(void *opaque, +static LinkedStringList *MVL_enumerateFiles(dvoid *opaque, const char *dirname, int omitSymLinks) { @@ -415,27 +409,27 @@ static MVLentry *mvl_find_entry(MVLinfo *info, const char *name) } /* mvl_find_entry */ -static int MVL_exists(void *opaque, const char *name) +static int MVL_exists(dvoid *opaque, const char *name) { return(mvl_find_entry(((MVLinfo *) opaque), name) != NULL); } /* MVL_exists */ -static int MVL_isDirectory(void *opaque, const char *name, int *fileExists) +static int MVL_isDirectory(dvoid *opaque, const char *name, int *fileExists) { *fileExists = MVL_exists(opaque, name); return(0); /* never directories in a groupfile. */ } /* MVL_isDirectory */ -static int MVL_isSymLink(void *opaque, const char *name, int *fileExists) +static int MVL_isSymLink(dvoid *opaque, const char *name, int *fileExists) { *fileExists = MVL_exists(opaque, name); return(0); /* never symlinks in a groupfile. */ } /* MVL_isSymLink */ -static PHYSFS_sint64 MVL_getLastModTime(void *opaque, +static PHYSFS_sint64 MVL_getLastModTime(dvoid *opaque, const char *name, int *fileExists) { @@ -450,10 +444,9 @@ static PHYSFS_sint64 MVL_getLastModTime(void *opaque, } /* MVL_getLastModTime */ -static FileHandle *MVL_openRead(void *opaque, const char *fnm, int *fileExists) +static fvoid *MVL_openRead(dvoid *opaque, const char *fnm, int *fileExists) { MVLinfo *info = ((MVLinfo *) opaque); - FileHandle *retval; MVLfileinfo *finfo; MVLentry *entry; @@ -461,51 +454,42 @@ static FileHandle *MVL_openRead(void *opaque, const char *fnm, int *fileExists) *fileExists = (entry != NULL); BAIL_IF_MACRO(entry == NULL, NULL, NULL); - retval = (FileHandle *) malloc(sizeof (FileHandle)); - BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL); finfo = (MVLfileinfo *) malloc(sizeof (MVLfileinfo)); - if (finfo == NULL) - { - free(retval); - BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL); - } /* if */ + BAIL_IF_MACRO(finfo == NULL, ERR_OUT_OF_MEMORY, NULL); finfo->handle = __PHYSFS_platformOpenRead(info->filename); if ( (finfo->handle == NULL) || (!__PHYSFS_platformSeek(finfo->handle, entry->startPos)) ) { free(finfo); - free(retval); return(NULL); } /* if */ finfo->curPos = 0; finfo->entry = entry; - retval->opaque = (void *) finfo; - retval->funcs = &__PHYSFS_FileFunctions_MVL; - return(retval); + return(finfo); } /* MVL_openRead */ -static FileHandle *MVL_openWrite(void *opaque, const char *name) +static fvoid *MVL_openWrite(dvoid *opaque, const char *name) { BAIL_MACRO(ERR_NOT_SUPPORTED, NULL); } /* MVL_openWrite */ -static FileHandle *MVL_openAppend(void *opaque, const char *name) +static fvoid *MVL_openAppend(dvoid *opaque, const char *name) { BAIL_MACRO(ERR_NOT_SUPPORTED, NULL); } /* MVL_openAppend */ -static int MVL_remove(void *opaque, const char *name) +static int MVL_remove(dvoid *opaque, const char *name) { BAIL_MACRO(ERR_NOT_SUPPORTED, 0); } /* MVL_remove */ -static int MVL_mkdir(void *opaque, const char *name) +static int MVL_mkdir(dvoid *opaque, const char *name) { BAIL_MACRO(ERR_NOT_SUPPORTED, 0); } /* MVL_mkdir */ diff --git a/archivers/qpak.c b/archivers/qpak.c index b36ee6e..0f8f0c3 100644 --- a/archivers/qpak.c +++ b/archivers/qpak.c @@ -78,30 +78,30 @@ typedef struct #define QPAK_SIGNATURE 0x4b434150 /* "PACK" in ASCII. */ -static void QPAK_dirClose(void *opaque); -static PHYSFS_sint64 QPAK_read(FileHandle *handle, void *buffer, +static PHYSFS_sint64 QPAK_read(fvoid *opaque, void *buffer, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount); -static PHYSFS_sint64 QPAK_write(FileHandle *handle, const void *buffer, +static PHYSFS_sint64 QPAK_write(fvoid *opaque, const void *buffer, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount); -static int QPAK_eof(FileHandle *handle); -static PHYSFS_sint64 QPAK_tell(FileHandle *handle); -static int QPAK_seek(FileHandle *handle, PHYSFS_uint64 offset); -static PHYSFS_sint64 QPAK_fileLength(FileHandle *handle); -static int QPAK_fileClose(FileHandle *handle); +static int QPAK_eof(fvoid *opaque); +static PHYSFS_sint64 QPAK_tell(fvoid *opaque); +static int QPAK_seek(fvoid *opaque, PHYSFS_uint64 offset); +static PHYSFS_sint64 QPAK_fileLength(fvoid *opaque); +static int QPAK_fileClose(fvoid *opaque); static int QPAK_isArchive(const char *filename, int forWriting); static void *QPAK_openArchive(const char *name, int forWriting); -static LinkedStringList *QPAK_enumerateFiles(void *opaque, +static LinkedStringList *QPAK_enumerateFiles(dvoid *opaque, const char *dirname, int omitSymLinks); -static int QPAK_exists(void *opaque, const char *name); -static int QPAK_isDirectory(void *opaque, const char *name, int *fileExists); -static int QPAK_isSymLink(void *opaque, const char *name, int *fileExists); -static PHYSFS_sint64 QPAK_getLastModTime(void *opaque, const char *n, int *e); -static FileHandle *QPAK_openRead(void *opaque, const char *name, int *exist); -static FileHandle *QPAK_openWrite(void *opaque, const char *name); -static FileHandle *QPAK_openAppend(void *opaque, const char *name); -static int QPAK_remove(void *opaque, const char *name); -static int QPAK_mkdir(void *opaque, const char *name); +static int QPAK_exists(dvoid *opaque, const char *name); +static int QPAK_isDirectory(dvoid *opaque, const char *name, int *fileExists); +static int QPAK_isSymLink(dvoid *opaque, const char *name, int *fileExists); +static PHYSFS_sint64 QPAK_getLastModTime(dvoid *opaque, const char *n, int *e); +static fvoid *QPAK_openRead(dvoid *opaque, const char *name, int *exist); +static fvoid *QPAK_openWrite(dvoid *opaque, const char *name); +static fvoid *QPAK_openAppend(dvoid *opaque, const char *name); +static int QPAK_remove(dvoid *opaque, const char *name); +static int QPAK_mkdir(dvoid *opaque, const char *name); +static void QPAK_dirClose(dvoid *opaque); const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_QPAK = { @@ -112,19 +112,7 @@ const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_QPAK = }; -static const FileFunctions __PHYSFS_FileFunctions_QPAK = -{ - QPAK_read, /* read() method */ - QPAK_write, /* write() method */ - QPAK_eof, /* eof() method */ - QPAK_tell, /* tell() method */ - QPAK_seek, /* seek() method */ - QPAK_fileLength, /* fileLength() method */ - QPAK_fileClose /* fileClose() method */ -}; - - -const DirFunctions __PHYSFS_DirFunctions_QPAK = +const PHYSFS_Archiver __PHYSFS_Archiver_QPAK = { &__PHYSFS_ArchiveInfo_QPAK, QPAK_isArchive, /* isArchive() method */ @@ -139,12 +127,19 @@ const DirFunctions __PHYSFS_DirFunctions_QPAK = QPAK_openAppend, /* openAppend() method */ QPAK_remove, /* remove() method */ QPAK_mkdir, /* mkdir() method */ - QPAK_dirClose /* dirClose() method */ + QPAK_dirClose, /* dirClose() method */ + QPAK_read, /* read() method */ + QPAK_write, /* write() method */ + QPAK_eof, /* eof() method */ + QPAK_tell, /* tell() method */ + QPAK_seek, /* seek() method */ + QPAK_fileLength, /* fileLength() method */ + QPAK_fileClose /* fileClose() method */ }; -static void QPAK_dirClose(void *opaque) +static void QPAK_dirClose(dvoid *opaque) { QPAKinfo *info = ((QPAKinfo *) opaque); free(info->filename); @@ -153,10 +148,10 @@ static void QPAK_dirClose(void *opaque) } /* QPAK_dirClose */ -static PHYSFS_sint64 QPAK_read(FileHandle *handle, void *buffer, +static PHYSFS_sint64 QPAK_read(fvoid *opaque, void *buffer, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount) { - QPAKfileinfo *finfo = (QPAKfileinfo *) (handle->opaque); + QPAKfileinfo *finfo = (QPAKfileinfo *) opaque; QPAKentry *entry = finfo->entry; PHYSFS_uint32 bytesLeft = entry->size - finfo->curPos; PHYSFS_uint32 objsLeft = (bytesLeft / objSize); @@ -173,30 +168,30 @@ static PHYSFS_sint64 QPAK_read(FileHandle *handle, void *buffer, } /* QPAK_read */ -static PHYSFS_sint64 QPAK_write(FileHandle *handle, const void *buffer, +static PHYSFS_sint64 QPAK_write(fvoid *opaque, const void *buffer, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount) { BAIL_MACRO(ERR_NOT_SUPPORTED, -1); } /* QPAK_write */ -static int QPAK_eof(FileHandle *handle) +static int QPAK_eof(fvoid *opaque) { - QPAKfileinfo *finfo = (QPAKfileinfo *) (handle->opaque); + QPAKfileinfo *finfo = (QPAKfileinfo *) opaque; QPAKentry *entry = finfo->entry; return(finfo->curPos >= entry->size); } /* QPAK_eof */ -static PHYSFS_sint64 QPAK_tell(FileHandle *handle) +static PHYSFS_sint64 QPAK_tell(fvoid *opaque) { - return(((QPAKfileinfo *) (handle->opaque))->curPos); + return(((QPAKfileinfo *) opaque)->curPos); } /* QPAK_tell */ -static int QPAK_seek(FileHandle *handle, PHYSFS_uint64 offset) +static int QPAK_seek(fvoid *opaque, PHYSFS_uint64 offset) { - QPAKfileinfo *finfo = (QPAKfileinfo *) (handle->opaque); + QPAKfileinfo *finfo = (QPAKfileinfo *) opaque; QPAKentry *entry = finfo->entry; int rc; @@ -210,19 +205,18 @@ static int QPAK_seek(FileHandle *handle, PHYSFS_uint64 offset) } /* QPAK_seek */ -static PHYSFS_sint64 QPAK_fileLength(FileHandle *handle) +static PHYSFS_sint64 QPAK_fileLength(fvoid *opaque) { - QPAKfileinfo *finfo = ((QPAKfileinfo *) handle->opaque); + QPAKfileinfo *finfo = (QPAKfileinfo *) opaque; return((PHYSFS_sint64) finfo->entry->size); } /* QPAK_fileLength */ -static int QPAK_fileClose(FileHandle *handle) +static int QPAK_fileClose(fvoid *opaque) { - QPAKfileinfo *finfo = ((QPAKfileinfo *) handle->opaque); + QPAKfileinfo *finfo = (QPAKfileinfo *) opaque; BAIL_IF_MACRO(!__PHYSFS_platformClose(finfo->handle), NULL, 0); free(finfo); - free(handle); return(1); } /* QPAK_fileClose */ @@ -449,7 +443,7 @@ static PHYSFS_sint32 qpak_find_start_of_dir(QPAKinfo *info, const char *path, } /* qpak_find_start_of_dir */ -static LinkedStringList *QPAK_enumerateFiles(void *opaque, +static LinkedStringList *QPAK_enumerateFiles(dvoid *opaque, const char *dirname, int omitSymLinks) { @@ -544,7 +538,7 @@ static QPAKentry *qpak_find_entry(QPAKinfo *info, const char *path, int *isDir) } /* qpak_find_entry */ -static int QPAK_exists(void *opaque, const char *name) +static int QPAK_exists(dvoid *opaque, const char *name) { int isDir; QPAKinfo *info = (QPAKinfo *) opaque; @@ -553,7 +547,7 @@ static int QPAK_exists(void *opaque, const char *name) } /* QPAK_exists */ -static int QPAK_isDirectory(void *opaque, const char *name, int *fileExists) +static int QPAK_isDirectory(dvoid *opaque, const char *name, int *fileExists) { QPAKinfo *info = (QPAKinfo *) opaque; int isDir; @@ -567,14 +561,14 @@ static int QPAK_isDirectory(void *opaque, const char *name, int *fileExists) } /* QPAK_isDirectory */ -static int QPAK_isSymLink(void *opaque, const char *name, int *fileExists) +static int QPAK_isSymLink(dvoid *opaque, const char *name, int *fileExists) { *fileExists = QPAK_exists(opaque, name); return(0); /* never symlinks in a quake pak. */ } /* QPAK_isSymLink */ -static PHYSFS_sint64 QPAK_getLastModTime(void *opaque, +static PHYSFS_sint64 QPAK_getLastModTime(dvoid *opaque, const char *name, int *fileExists) { @@ -591,10 +585,9 @@ static PHYSFS_sint64 QPAK_getLastModTime(void *opaque, } /* QPAK_getLastModTime */ -static FileHandle *QPAK_openRead(void *opaque, const char *fnm, int *fileExists) +static fvoid *QPAK_openRead(dvoid *opaque, const char *fnm, int *fileExists) { QPAKinfo *info = ((QPAKinfo *) opaque); - FileHandle *retval; QPAKfileinfo *finfo; QPAKentry *entry; int isDir; @@ -604,51 +597,42 @@ static FileHandle *QPAK_openRead(void *opaque, const char *fnm, int *fileExists) BAIL_IF_MACRO(isDir, ERR_NOT_A_FILE, NULL); BAIL_IF_MACRO(entry == NULL, ERR_NO_SUCH_FILE, NULL); - retval = (FileHandle *) malloc(sizeof (FileHandle)); - BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL); finfo = (QPAKfileinfo *) malloc(sizeof (QPAKfileinfo)); - if (finfo == NULL) - { - free(retval); - BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL); - } /* if */ + BAIL_IF_MACRO(finfo == NULL, ERR_OUT_OF_MEMORY, NULL); finfo->handle = __PHYSFS_platformOpenRead(info->filename); if ( (finfo->handle == NULL) || (!__PHYSFS_platformSeek(finfo->handle, entry->startPos)) ) { free(finfo); - free(retval); return(NULL); } /* if */ finfo->curPos = 0; finfo->entry = entry; - retval->opaque = (void *) finfo; - retval->funcs = &__PHYSFS_FileFunctions_QPAK; - return(retval); + return(finfo); } /* QPAK_openRead */ -static FileHandle *QPAK_openWrite(void *opaque, const char *name) +static fvoid *QPAK_openWrite(dvoid *opaque, const char *name) { BAIL_MACRO(ERR_NOT_SUPPORTED, NULL); } /* QPAK_openWrite */ -static FileHandle *QPAK_openAppend(void *opaque, const char *name) +static fvoid *QPAK_openAppend(dvoid *opaque, const char *name) { BAIL_MACRO(ERR_NOT_SUPPORTED, NULL); } /* QPAK_openAppend */ -static int QPAK_remove(void *opaque, const char *name) +static int QPAK_remove(dvoid *opaque, const char *name) { BAIL_MACRO(ERR_NOT_SUPPORTED, 0); } /* QPAK_remove */ -static int QPAK_mkdir(void *opaque, const char *name) +static int QPAK_mkdir(dvoid *opaque, const char *name) { BAIL_MACRO(ERR_NOT_SUPPORTED, 0); } /* QPAK_mkdir */ diff --git a/archivers/wad.c b/archivers/wad.c index dac0c0c..1e60496 100644 --- a/archivers/wad.c +++ b/archivers/wad.c @@ -80,30 +80,30 @@ typedef struct } WADfileinfo; -static void WAD_dirClose(void *opaque); -static PHYSFS_sint64 WAD_read(FileHandle *handle, void *buffer, +static PHYSFS_sint64 WAD_read(fvoid *opaque, void *buffer, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount); -static PHYSFS_sint64 WAD_write(FileHandle *handle, const void *buffer, +static PHYSFS_sint64 WAD_write(fvoid *opaque, const void *buffer, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount); -static int WAD_eof(FileHandle *handle); -static PHYSFS_sint64 WAD_tell(FileHandle *handle); -static int WAD_seek(FileHandle *handle, PHYSFS_uint64 offset); -static PHYSFS_sint64 WAD_fileLength(FileHandle *handle); -static int WAD_fileClose(FileHandle *handle); +static int WAD_eof(fvoid *opaque); +static PHYSFS_sint64 WAD_tell(fvoid *opaque); +static int WAD_seek(fvoid *opaque, PHYSFS_uint64 offset); +static PHYSFS_sint64 WAD_fileLength(fvoid *opaque); +static int WAD_fileClose(fvoid *opaque); static int WAD_isArchive(const char *filename, int forWriting); static void *WAD_openArchive(const char *name, int forWriting); -static LinkedStringList *WAD_enumerateFiles(void *opaque, +static LinkedStringList *WAD_enumerateFiles(dvoid *opaque, const char *dirname, int omitSymLinks); -static int WAD_exists(void *opaque, const char *name); -static int WAD_isDirectory(void *opaque, const char *name, int *fileExists); -static int WAD_isSymLink(void *opaque, const char *name, int *fileExists); -static PHYSFS_sint64 WAD_getLastModTime(void *opaque, const char *n, int *e); -static FileHandle *WAD_openRead(void *opaque, const char *name, int *exist); -static FileHandle *WAD_openWrite(void *opaque, const char *name); -static FileHandle *WAD_openAppend(void *opaque, const char *name); -static int WAD_remove(void *opaque, const char *name); -static int WAD_mkdir(void *opaque, const char *name); +static int WAD_exists(dvoid *opaque, const char *name); +static int WAD_isDirectory(dvoid *opaque, const char *name, int *fileExists); +static int WAD_isSymLink(dvoid *opaque, const char *name, int *fileExists); +static PHYSFS_sint64 WAD_getLastModTime(dvoid *opaque, const char *n, int *e); +static fvoid *WAD_openRead(dvoid *opaque, const char *name, int *exist); +static fvoid *WAD_openWrite(dvoid *opaque, const char *name); +static fvoid *WAD_openAppend(dvoid *opaque, const char *name); +static int WAD_remove(dvoid *opaque, const char *name); +static int WAD_mkdir(dvoid *opaque, const char *name); +static void WAD_dirClose(dvoid *opaque); const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_WAD = { @@ -114,19 +114,7 @@ const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_WAD = }; -static const FileFunctions __PHYSFS_FileFunctions_WAD = -{ - WAD_read, /* read() method */ - WAD_write, /* write() method */ - WAD_eof, /* eof() method */ - WAD_tell, /* tell() method */ - WAD_seek, /* seek() method */ - WAD_fileLength, /* fileLength() method */ - WAD_fileClose /* fileClose() method */ -}; - - -const DirFunctions __PHYSFS_DirFunctions_WAD = +const PHYSFS_Archiver __PHYSFS_Archiver_WAD = { &__PHYSFS_ArchiveInfo_WAD, WAD_isArchive, /* isArchive() method */ @@ -141,12 +129,19 @@ const DirFunctions __PHYSFS_DirFunctions_WAD = WAD_openAppend, /* openAppend() method */ WAD_remove, /* remove() method */ WAD_mkdir, /* mkdir() method */ - WAD_dirClose /* dirClose() method */ + WAD_dirClose, /* dirClose() method */ + WAD_read, /* read() method */ + WAD_write, /* write() method */ + WAD_eof, /* eof() method */ + WAD_tell, /* tell() method */ + WAD_seek, /* seek() method */ + WAD_fileLength, /* fileLength() method */ + WAD_fileClose /* fileClose() method */ }; -static void WAD_dirClose(void *opaque) +static void WAD_dirClose(dvoid *opaque) { WADinfo *info = ((WADinfo *) opaque); free(info->filename); @@ -155,10 +150,10 @@ static void WAD_dirClose(void *opaque) } /* WAD_dirClose */ -static PHYSFS_sint64 WAD_read(FileHandle *handle, void *buffer, +static PHYSFS_sint64 WAD_read(fvoid *opaque, void *buffer, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount) { - WADfileinfo *finfo = (WADfileinfo *) (handle->opaque); + WADfileinfo *finfo = (WADfileinfo *) opaque; WADentry *entry = finfo->entry; PHYSFS_uint32 bytesLeft = entry->size - finfo->curPos; PHYSFS_uint32 objsLeft = (bytesLeft / objSize); @@ -175,30 +170,30 @@ static PHYSFS_sint64 WAD_read(FileHandle *handle, void *buffer, } /* WAD_read */ -static PHYSFS_sint64 WAD_write(FileHandle *handle, const void *buffer, +static PHYSFS_sint64 WAD_write(fvoid *opaque, const void *buffer, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount) { BAIL_MACRO(ERR_NOT_SUPPORTED, -1); } /* WAD_write */ -static int WAD_eof(FileHandle *handle) +static int WAD_eof(fvoid *opaque) { - WADfileinfo *finfo = (WADfileinfo *) (handle->opaque); + WADfileinfo *finfo = (WADfileinfo *) opaque; WADentry *entry = finfo->entry; return(finfo->curPos >= entry->size); } /* WAD_eof */ -static PHYSFS_sint64 WAD_tell(FileHandle *handle) +static PHYSFS_sint64 WAD_tell(fvoid *opaque) { - return(((WADfileinfo *) (handle->opaque))->curPos); + return(((WADfileinfo *) opaque)->curPos); } /* WAD_tell */ -static int WAD_seek(FileHandle *handle, PHYSFS_uint64 offset) +static int WAD_seek(fvoid *opaque, PHYSFS_uint64 offset) { - WADfileinfo *finfo = (WADfileinfo *) (handle->opaque); + WADfileinfo *finfo = (WADfileinfo *) opaque; WADentry *entry = finfo->entry; int rc; @@ -212,19 +207,18 @@ static int WAD_seek(FileHandle *handle, PHYSFS_uint64 offset) } /* WAD_seek */ -static PHYSFS_sint64 WAD_fileLength(FileHandle *handle) +static PHYSFS_sint64 WAD_fileLength(fvoid *opaque) { - WADfileinfo *finfo = ((WADfileinfo *) handle->opaque); + WADfileinfo *finfo = (WADfileinfo *) opaque; return((PHYSFS_sint64) finfo->entry->size); } /* WAD_fileLength */ -static int WAD_fileClose(FileHandle *handle) +static int WAD_fileClose(fvoid *opaque) { - WADfileinfo *finfo = ((WADfileinfo *) handle->opaque); + WADfileinfo *finfo = (WADfileinfo *) opaque; BAIL_IF_MACRO(!__PHYSFS_platformClose(finfo->handle), NULL, 0); free(finfo); - free(handle); return(1); } /* WAD_fileClose */ @@ -392,7 +386,7 @@ WAD_openArchive_failed: } /* WAD_openArchive */ -static LinkedStringList *WAD_enumerateFiles(void *opaque, +static LinkedStringList *WAD_enumerateFiles(dvoid *opaque, const char *dirname, int omitSymLinks) { @@ -458,13 +452,13 @@ static WADentry *wad_find_entry(WADinfo *info, const char *name) } /* wad_find_entry */ -static int WAD_exists(void *opaque, const char *name) +static int WAD_exists(dvoid *opaque, const char *name) { return(wad_find_entry(((WADinfo *) opaque), name) != NULL); } /* WAD_exists */ -static int WAD_isDirectory(void *opaque, const char *name, int *fileExists) +static int WAD_isDirectory(dvoid *opaque, const char *name, int *fileExists) { WADentry *entry = wad_find_entry(((WADinfo *) opaque), name); if (entry != NULL) @@ -494,14 +488,14 @@ static int WAD_isDirectory(void *opaque, const char *name, int *fileExists) } /* WAD_isDirectory */ -static int WAD_isSymLink(void *opaque, const char *name, int *fileExists) +static int WAD_isSymLink(dvoid *opaque, const char *name, int *fileExists) { *fileExists = WAD_exists(opaque, name); return(0); /* never symlinks in a wad. */ } /* WAD_isSymLink */ -static PHYSFS_sint64 WAD_getLastModTime(void *opaque, +static PHYSFS_sint64 WAD_getLastModTime(dvoid *opaque, const char *name, int *fileExists) { @@ -516,10 +510,9 @@ static PHYSFS_sint64 WAD_getLastModTime(void *opaque, } /* WAD_getLastModTime */ -static FileHandle *WAD_openRead(void *opaque, const char *fnm, int *fileExists) +static fvoid *WAD_openRead(dvoid *opaque, const char *fnm, int *fileExists) { WADinfo *info = ((WADinfo *) opaque); - FileHandle *retval; WADfileinfo *finfo; WADentry *entry; @@ -527,51 +520,42 @@ static FileHandle *WAD_openRead(void *opaque, const char *fnm, int *fileExists) *fileExists = (entry != NULL); BAIL_IF_MACRO(entry == NULL, NULL, NULL); - retval = (FileHandle *) malloc(sizeof (FileHandle)); - BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL); finfo = (WADfileinfo *) malloc(sizeof (WADfileinfo)); - if (finfo == NULL) - { - free(retval); - BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL); - } /* if */ + BAIL_IF_MACRO(finfo == NULL, ERR_OUT_OF_MEMORY, NULL); finfo->handle = __PHYSFS_platformOpenRead(info->filename); if ( (finfo->handle == NULL) || (!__PHYSFS_platformSeek(finfo->handle, entry->startPos)) ) { free(finfo); - free(retval); return(NULL); } /* if */ finfo->curPos = 0; finfo->entry = entry; - retval->opaque = (void *) finfo; - retval->funcs = &__PHYSFS_FileFunctions_WAD; - return(retval); + return(finfo); } /* WAD_openRead */ -static FileHandle *WAD_openWrite(void *opaque, const char *name) +static fvoid *WAD_openWrite(dvoid *opaque, const char *name) { BAIL_MACRO(ERR_NOT_SUPPORTED, NULL); } /* WAD_openWrite */ -static FileHandle *WAD_openAppend(void *opaque, const char *name) +static fvoid *WAD_openAppend(dvoid *opaque, const char *name) { BAIL_MACRO(ERR_NOT_SUPPORTED, NULL); } /* WAD_openAppend */ -static int WAD_remove(void *opaque, const char *name) +static int WAD_remove(dvoid *opaque, const char *name) { BAIL_MACRO(ERR_NOT_SUPPORTED, 0); } /* WAD_remove */ -static int WAD_mkdir(void *opaque, const char *name) +static int WAD_mkdir(dvoid *opaque, const char *name) { BAIL_MACRO(ERR_NOT_SUPPORTED, 0); } /* WAD_mkdir */ diff --git a/archivers/zip.c b/archivers/zip.c index bdad74a..b9296bf 100644 --- a/archivers/zip.c +++ b/archivers/zip.c @@ -116,31 +116,31 @@ typedef struct #define UNIX_FILETYPE_SYMLINK 0120000 -static PHYSFS_sint64 ZIP_read(FileHandle *handle, void *buffer, +static PHYSFS_sint64 ZIP_read(fvoid *opaque, void *buffer, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount); -static PHYSFS_sint64 ZIP_write(FileHandle *handle, const void *buffer, +static PHYSFS_sint64 ZIP_write(fvoid *opaque, const void *buffer, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount); -static int ZIP_eof(FileHandle *handle); -static PHYSFS_sint64 ZIP_tell(FileHandle *handle); -static int ZIP_seek(FileHandle *handle, PHYSFS_uint64 offset); -static PHYSFS_sint64 ZIP_fileLength(FileHandle *handle); -static int ZIP_fileClose(FileHandle *handle); +static int ZIP_eof(fvoid *opaque); +static PHYSFS_sint64 ZIP_tell(fvoid *opaque); +static int ZIP_seek(fvoid *opaque, PHYSFS_uint64 offset); +static PHYSFS_sint64 ZIP_fileLength(fvoid *opaque); +static int ZIP_fileClose(fvoid *opaque); static int ZIP_isArchive(const char *filename, int forWriting); static void *ZIP_openArchive(const char *name, int forWriting); -static LinkedStringList *ZIP_enumerateFiles(void *opaque, +static LinkedStringList *ZIP_enumerateFiles(dvoid *opaque, const char *dirname, int omitSymLinks); -static int ZIP_exists(void *opaque, const char *name); -static int ZIP_isDirectory(void *opaque, const char *name, int *fileExists); -static int ZIP_isSymLink(void *opaque, const char *name, int *fileExists); -static PHYSFS_sint64 ZIP_getLastModTime(void *opaque, const char *n, int *e); -static FileHandle *ZIP_openRead(void *opaque, const char *filename, int *e); -static FileHandle *ZIP_openWrite(void *opaque, const char *filename); -static FileHandle *ZIP_openAppend(void *opaque, const char *filename); -static void ZIP_dirClose(void *opaque); +static int ZIP_exists(dvoid *opaque, const char *name); +static int ZIP_isDirectory(dvoid *opaque, const char *name, int *fileExists); +static int ZIP_isSymLink(dvoid *opaque, const char *name, int *fileExists); +static PHYSFS_sint64 ZIP_getLastModTime(dvoid *opaque, const char *n, int *e); +static fvoid *ZIP_openRead(dvoid *opaque, const char *filename, int *e); +static fvoid *ZIP_openWrite(dvoid *opaque, const char *filename); +static fvoid *ZIP_openAppend(dvoid *opaque, const char *filename); +static void ZIP_dirClose(dvoid *opaque); static int zip_resolve(void *in, ZIPinfo *info, ZIPentry *entry); -static int ZIP_remove(void *opaque, const char *name); -static int ZIP_mkdir(void *opaque, const char *name); +static int ZIP_remove(dvoid *opaque, const char *name); +static int ZIP_mkdir(dvoid *opaque, const char *name); const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_ZIP = @@ -151,19 +151,8 @@ const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_ZIP = "http://icculus.org/physfs/", }; -static const FileFunctions __PHYSFS_FileFunctions_ZIP = -{ - ZIP_read, /* read() method */ - ZIP_write, /* write() method */ - ZIP_eof, /* eof() method */ - ZIP_tell, /* tell() method */ - ZIP_seek, /* seek() method */ - ZIP_fileLength, /* fileLength() method */ - ZIP_fileClose /* fileClose() method */ -}; - -const DirFunctions __PHYSFS_DirFunctions_ZIP = +const PHYSFS_Archiver __PHYSFS_Archiver_ZIP = { &__PHYSFS_ArchiveInfo_ZIP, ZIP_isArchive, /* isArchive() method */ @@ -178,7 +167,14 @@ const DirFunctions __PHYSFS_DirFunctions_ZIP = ZIP_openAppend, /* openAppend() method */ ZIP_remove, /* remove() method */ ZIP_mkdir, /* mkdir() method */ - ZIP_dirClose /* dirClose() method */ + ZIP_dirClose, /* dirClose() method */ + ZIP_read, /* read() method */ + ZIP_write, /* write() method */ + ZIP_eof, /* eof() method */ + ZIP_tell, /* tell() method */ + ZIP_seek, /* seek() method */ + ZIP_fileLength, /* fileLength() method */ + ZIP_fileClose /* fileClose() method */ }; @@ -188,7 +184,7 @@ const DirFunctions __PHYSFS_DirFunctions_ZIP = */ static voidpf zlibPhysfsAlloc(voidpf opaque, uInt items, uInt size) { - return(((PHYSFS_allocator *) opaque)->malloc(items * size)); + return(((PHYSFS_Allocator *) opaque)->malloc(items * size)); } /* zlibPhysfsAlloc */ /* @@ -196,7 +192,7 @@ static voidpf zlibPhysfsAlloc(voidpf opaque, uInt items, uInt size) */ static void zlibPhysfsFree(voidpf opaque, voidpf address) { - ((PHYSFS_allocator *) opaque)->free(address); + ((PHYSFS_Allocator *) opaque)->free(address); } /* zlibPhysfsFree */ @@ -269,10 +265,10 @@ static int readui16(void *in, PHYSFS_uint16 *val) } /* readui16 */ -static PHYSFS_sint64 ZIP_read(FileHandle *handle, void *buf, +static PHYSFS_sint64 ZIP_read(fvoid *opaque, void *buf, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount) { - ZIPfileinfo *finfo = (ZIPfileinfo *) (handle->opaque); + ZIPfileinfo *finfo = (ZIPfileinfo *) opaque; ZIPentry *entry = finfo->entry; PHYSFS_sint64 retval = 0; PHYSFS_sint64 maxread = ((PHYSFS_sint64) objSize) * objCount; @@ -343,29 +339,29 @@ static PHYSFS_sint64 ZIP_read(FileHandle *handle, void *buf, } /* ZIP_read */ -static PHYSFS_sint64 ZIP_write(FileHandle *handle, const void *buf, +static PHYSFS_sint64 ZIP_write(fvoid *opaque, const void *buf, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount) { BAIL_MACRO(ERR_NOT_SUPPORTED, -1); } /* ZIP_write */ -static int ZIP_eof(FileHandle *handle) +static int ZIP_eof(fvoid *opaque) { - ZIPfileinfo *finfo = ((ZIPfileinfo *) (handle->opaque)); + ZIPfileinfo *finfo = (ZIPfileinfo *) opaque; return(finfo->uncompressed_position >= finfo->entry->uncompressed_size); } /* ZIP_eof */ -static PHYSFS_sint64 ZIP_tell(FileHandle *handle) +static PHYSFS_sint64 ZIP_tell(fvoid *opaque) { - return(((ZIPfileinfo *) (handle->opaque))->uncompressed_position); + return(((ZIPfileinfo *) opaque)->uncompressed_position); } /* ZIP_tell */ -static int ZIP_seek(FileHandle *handle, PHYSFS_uint64 offset) +static int ZIP_seek(fvoid *opaque, PHYSFS_uint64 offset) { - ZIPfileinfo *finfo = (ZIPfileinfo *) (handle->opaque); + ZIPfileinfo *finfo = (ZIPfileinfo *) opaque; ZIPentry *entry = finfo->entry; void *in = finfo->handle; @@ -411,7 +407,7 @@ static int ZIP_seek(FileHandle *handle, PHYSFS_uint64 offset) if (maxread > sizeof (buf)) maxread = sizeof (buf); - if (ZIP_read(handle, buf, maxread, 1) != 1) + if (ZIP_read(finfo, buf, maxread, 1) != 1) return(0); } /* while */ } /* else */ @@ -420,16 +416,16 @@ static int ZIP_seek(FileHandle *handle, PHYSFS_uint64 offset) } /* ZIP_seek */ -static PHYSFS_sint64 ZIP_fileLength(FileHandle *handle) +static PHYSFS_sint64 ZIP_fileLength(fvoid *opaque) { - ZIPfileinfo *finfo = (ZIPfileinfo *) (handle->opaque); + ZIPfileinfo *finfo = (ZIPfileinfo *) opaque; return(finfo->entry->uncompressed_size); } /* ZIP_fileLength */ -static int ZIP_fileClose(FileHandle *handle) +static int ZIP_fileClose(fvoid *opaque) { - ZIPfileinfo *finfo = (ZIPfileinfo *) (handle->opaque); + ZIPfileinfo *finfo = (ZIPfileinfo *) opaque; BAIL_IF_MACRO(!__PHYSFS_platformClose(finfo->handle), NULL, 0); if (finfo->entry->compression_method != COMPMETH_NONE) @@ -439,7 +435,6 @@ static int ZIP_fileClose(FileHandle *handle) free(finfo->buffer); free(finfo); - free(handle); return(1); } /* ZIP_fileClose */ @@ -1240,7 +1235,7 @@ static PHYSFS_sint32 zip_find_start_of_dir(ZIPinfo *info, const char *path, } /* zip_find_start_of_dir */ -static LinkedStringList *ZIP_enumerateFiles(void *opaque, +static LinkedStringList *ZIP_enumerateFiles(dvoid *opaque, const char *dirname, int omitSymLinks) { @@ -1287,7 +1282,7 @@ static LinkedStringList *ZIP_enumerateFiles(void *opaque, } /* ZIP_enumerateFiles */ -static int ZIP_exists(void *opaque, const char *name) +static int ZIP_exists(dvoid *opaque, const char *name) { int isDir; ZIPinfo *info = (ZIPinfo *) opaque; @@ -1296,7 +1291,7 @@ static int ZIP_exists(void *opaque, const char *name) } /* ZIP_exists */ -static PHYSFS_sint64 ZIP_getLastModTime(void *opaque, +static PHYSFS_sint64 ZIP_getLastModTime(dvoid *opaque, const char *name, int *fileExists) { @@ -1313,7 +1308,7 @@ static PHYSFS_sint64 ZIP_getLastModTime(void *opaque, } /* ZIP_getLastModTime */ -static int ZIP_isDirectory(void *opaque, const char *name, int *fileExists) +static int ZIP_isDirectory(dvoid *opaque, const char *name, int *fileExists) { ZIPinfo *info = (ZIPinfo *) opaque; int isDir; @@ -1344,7 +1339,7 @@ static int ZIP_isDirectory(void *opaque, const char *name, int *fileExists) } /* ZIP_isDirectory */ -static int ZIP_isSymLink(void *opaque, const char *name, int *fileExists) +static int ZIP_isSymLink(dvoid *opaque, const char *name, int *fileExists) { int isDir; ZIPentry *entry = zip_find_entry((ZIPinfo *) opaque, name, &isDir); @@ -1378,11 +1373,10 @@ static void *zip_get_file_handle(const char *fn, ZIPinfo *inf, ZIPentry *entry) } /* zip_get_file_handle */ -static FileHandle *ZIP_openRead(void *opaque, const char *fnm, int *fileExists) +static fvoid *ZIP_openRead(dvoid *opaque, const char *fnm, int *fileExists) { ZIPinfo *info = (ZIPinfo *) opaque; ZIPentry *entry = zip_find_entry(info, fnm, NULL); - FileHandle *retval = NULL; ZIPfileinfo *finfo = NULL; void *in; @@ -1392,18 +1386,13 @@ static FileHandle *ZIP_openRead(void *opaque, const char *fnm, int *fileExists) in = zip_get_file_handle(info->archiveName, info, entry); BAIL_IF_MACRO(in == NULL, NULL, NULL); - if ( ((retval = (FileHandle *) malloc(sizeof (FileHandle))) == NULL) || - ((finfo = (ZIPfileinfo *) malloc(sizeof (ZIPfileinfo))) == NULL) ) + finfo = (ZIPfileinfo *) malloc(sizeof (ZIPfileinfo)); + if (finfo == NULL) { - if (retval) - free(retval); __PHYSFS_platformClose(in); BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL); } /* if */ - retval->opaque = (void *) finfo; - retval->funcs = &__PHYSFS_FileFunctions_ZIP; - memset(finfo, '\0', sizeof (ZIPfileinfo)); finfo->handle = in; finfo->entry = ((entry->symlink != NULL) ? entry->symlink : entry); @@ -1412,35 +1401,35 @@ static FileHandle *ZIP_openRead(void *opaque, const char *fnm, int *fileExists) { if (zlib_err(inflateInit2(&finfo->stream, -MAX_WBITS)) != Z_OK) { - ZIP_fileClose(retval); + ZIP_fileClose(finfo); return(NULL); } /* if */ finfo->buffer = (PHYSFS_uint8 *) malloc(ZIP_READBUFSIZE); if (finfo->buffer == NULL) { - ZIP_fileClose(retval); + ZIP_fileClose(finfo); BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL); } /* if */ } /* if */ - return(retval); + return(finfo); } /* ZIP_openRead */ -static FileHandle *ZIP_openWrite(void *opaque, const char *filename) +static fvoid *ZIP_openWrite(dvoid *opaque, const char *filename) { BAIL_MACRO(ERR_NOT_SUPPORTED, NULL); } /* ZIP_openWrite */ -static FileHandle *ZIP_openAppend(void *opaque, const char *filename) +static fvoid *ZIP_openAppend(dvoid *opaque, const char *filename) { BAIL_MACRO(ERR_NOT_SUPPORTED, NULL); } /* ZIP_openAppend */ -static void ZIP_dirClose(void *opaque) +static void ZIP_dirClose(dvoid *opaque) { ZIPinfo *zi = (ZIPinfo *) (opaque); zip_free_entries(zi->entries, zi->entryCount); @@ -1449,13 +1438,13 @@ static void ZIP_dirClose(void *opaque) } /* ZIP_dirClose */ -static int ZIP_remove(void *opaque, const char *name) +static int ZIP_remove(dvoid *opaque, const char *name) { BAIL_MACRO(ERR_NOT_SUPPORTED, 0); } /* ZIP_remove */ -static int ZIP_mkdir(void *opaque, const char *name) +static int ZIP_mkdir(dvoid *opaque, const char *name) { BAIL_MACRO(ERR_NOT_SUPPORTED, 0); } /* ZIP_mkdir */ diff --git a/physfs.c b/physfs.c index 79e1dbd..053b61b 100644 --- a/physfs.c +++ b/physfs.c @@ -26,21 +26,29 @@ #include "physfs_internal.h" -/* !!! FIXME: Get rid of this. Merge it with PhysDirInfo. */ typedef struct __PHYSFS_DIRHANDLE__ { - /* - * This is reserved for the driver to store information. - */ - void *opaque; - - /* - * Pointer to the directory i/o functions for this handle. - */ - const struct __PHYSFS_DIRFUNCTIONS__ *funcs; + void *opaque; /* Instance data unique to the archiver. */ + char *dirName; /* Path to archive in platform-dependent notation. */ + const PHYSFS_Archiver *funcs; /* Ptr to archiver info for this handle. */ + struct __PHYSFS_DIRHANDLE__ *next; /* linked list stuff. */ } DirHandle; +typedef struct __PHYSFS_FILEHANDLE__ +{ + void *opaque; /* Instance data unique to the archiver for this file. */ + PHYSFS_uint8 forReading; /* Non-zero if reading, zero if write/append */ + const DirHandle *dirHandle; /* Archiver instance that created this */ + const PHYSFS_Archiver *funcs; /* Ptr to archiver info for this handle. */ + PHYSFS_uint8 *buffer; /* Buffer, if set (NULL otherwise). Don't touch! */ + PHYSFS_uint32 bufsize; /* Bufsize, if set (0 otherwise). Don't touch! */ + PHYSFS_uint32 buffill; /* Buffer fill size. Don't touch! */ + PHYSFS_uint32 bufpos; /* Buffer position. Don't touch! */ + struct __PHYSFS_FILEHANDLE__ *next; /* linked list stuff. */ +} FileHandle; + + typedef struct __PHYSFS_ERRMSGTYPE__ { PHYSFS_uint64 tid; @@ -49,58 +57,45 @@ typedef struct __PHYSFS_ERRMSGTYPE__ struct __PHYSFS_ERRMSGTYPE__ *next; } ErrMsg; -typedef struct __PHYSFS_DIRINFO__ -{ - char *dirName; - DirHandle *dirHandle; - struct __PHYSFS_DIRINFO__ *next; -} PhysDirInfo; - -typedef struct __PHYSFS_FILEHANDLELIST__ -{ - PHYSFS_file handle; - struct __PHYSFS_FILEHANDLELIST__ *next; -} FileHandleList; - /* The various i/o drivers... */ #if (defined PHYSFS_SUPPORTS_ZIP) -extern const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_ZIP; -extern const DirFunctions __PHYSFS_DirFunctions_ZIP; +extern const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_ZIP; +extern const PHYSFS_Archiver __PHYSFS_Archiver_ZIP; #endif #if (defined PHYSFS_SUPPORTS_GRP) -extern const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_GRP; -extern const DirFunctions __PHYSFS_DirFunctions_GRP; +extern const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_GRP; +extern const PHYSFS_Archiver __PHYSFS_Archiver_GRP; #endif #if (defined PHYSFS_SUPPORTS_QPAK) -extern const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_QPAK; -extern const DirFunctions __PHYSFS_DirFunctions_QPAK; +extern const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_QPAK; +extern const PHYSFS_Archiver __PHYSFS_Archiver_QPAK; #endif #if (defined PHYSFS_SUPPORTS_HOG) -extern const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_HOG; -extern const DirFunctions __PHYSFS_DirFunctions_HOG; +extern const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_HOG; +extern const PHYSFS_Archiver __PHYSFS_Archiver_HOG; #endif #if (defined PHYSFS_SUPPORTS_MVL) -extern const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_MVL; -extern const DirFunctions __PHYSFS_DirFunctions_MVL; +extern const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_MVL; +extern const PHYSFS_Archiver __PHYSFS_Archiver_MVL; #endif #if (defined PHYSFS_SUPPORTS_WAD) -extern const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_WAD; -extern const DirFunctions __PHYSFS_DirFunctions_WAD; +extern const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_WAD; +extern const PHYSFS_Archiver __PHYSFS_Archiver_WAD; #endif #if (defined PHYSFS_SUPPORTS_MIX) -extern const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_MIX; -extern const DirFunctions __PHYSFS_DirFunctions_MIX; +extern const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_MIX; +extern const PHYSFS_Archiver __PHYSFS_Archiver_MIX; #endif -extern const DirFunctions __PHYSFS_DirFunctions_DIR; +extern const PHYSFS_Archiver __PHYSFS_Archiver_DIR; static const PHYSFS_ArchiveInfo *supported_types[] = @@ -136,37 +131,37 @@ static const PHYSFS_ArchiveInfo *supported_types[] = NULL }; -static const DirFunctions *dirFunctions[] = +static const PHYSFS_Archiver *archivers[] = { #if (defined PHYSFS_SUPPORTS_ZIP) - &__PHYSFS_DirFunctions_ZIP, + &__PHYSFS_Archiver_ZIP, #endif #if (defined PHYSFS_SUPPORTS_GRP) - &__PHYSFS_DirFunctions_GRP, + &__PHYSFS_Archiver_GRP, #endif #if (defined PHYSFS_SUPPORTS_QPAK) - &__PHYSFS_DirFunctions_QPAK, + &__PHYSFS_Archiver_QPAK, #endif #if (defined PHYSFS_SUPPORTS_HOG) - &__PHYSFS_DirFunctions_HOG, + &__PHYSFS_Archiver_HOG, #endif #if (defined PHYSFS_SUPPORTS_MVL) - &__PHYSFS_DirFunctions_MVL, + &__PHYSFS_Archiver_MVL, #endif #if (defined PHYSFS_SUPPORTS_WAD) - &__PHYSFS_DirFunctions_WAD, + &__PHYSFS_Archiver_WAD, #endif #if (defined PHYSFS_SUPPORTS_MIX) - &__PHYSFS_DirFunctions_MIX, + &__PHYSFS_Archiver_MIX, #endif - &__PHYSFS_DirFunctions_DIR, + &__PHYSFS_Archiver_DIR, NULL }; @@ -175,10 +170,10 @@ static const DirFunctions *dirFunctions[] = /* General PhysicsFS state ... */ static int initialized = 0; static ErrMsg *errorMessages = NULL; -static PhysDirInfo *searchPath = NULL; -static PhysDirInfo *writeDir = NULL; -static FileHandleList *openWriteList = NULL; -static FileHandleList *openReadList = NULL; +static DirHandle *searchPath = NULL; +static DirHandle *writeDir = NULL; +static FileHandle *openWriteList = NULL; +static FileHandle *openReadList = NULL; static char *baseDir = NULL; static char *userDir = NULL; static int allowSymLinks = 0; @@ -189,7 +184,7 @@ static void *stateLock = NULL; /* protects other PhysFS static state. */ /* allocator ... */ static int externalAllocator = 0; -static PHYSFS_allocator allocator; +static PHYSFS_Allocator allocator; /* functions ... */ @@ -545,20 +540,22 @@ static const char *find_filename_extension(const char *fname) } /* find_filename_extension */ -static DirHandle *tryOpenDir(const DirFunctions *f, const char *d, int fw) +static DirHandle *tryOpenDir(const PHYSFS_Archiver *funcs, + const char *d, int forWriting) { DirHandle *retval = NULL; - if (f->isArchive(d, fw)) /* fw == "for writing" */ + if (funcs->isArchive(d, forWriting)) { - void *opaque = f->openArchive(d, fw); + void *opaque = funcs->openArchive(d, forWriting); if (opaque != NULL) { retval = (DirHandle *) allocator.malloc(sizeof (DirHandle)); if (retval == NULL) - f->dirClose(opaque); + funcs->dirClose(opaque); else { - retval->funcs = f; + memset(retval, '\0', sizeof (DirHandle)); + retval->funcs = funcs; retval->opaque = opaque; } /* else */ } /* if */ @@ -571,7 +568,7 @@ static DirHandle *tryOpenDir(const DirFunctions *f, const char *d, int fw) static DirHandle *openDirectory(const char *d, int forWriting) { DirHandle *retval = NULL; - const DirFunctions **i; + const PHYSFS_Archiver **i; const char *ext; BAIL_IF_MACRO(!__PHYSFS_platformExists(d), ERR_NO_SUCH_FILE, NULL); @@ -580,14 +577,14 @@ static DirHandle *openDirectory(const char *d, int forWriting) if (ext != NULL) { /* Look for archivers with matching file extensions first... */ - for (i = dirFunctions; (*i != NULL) && (retval == NULL); i++) + for (i = archivers; (*i != NULL) && (retval == NULL); i++) { if (__PHYSFS_platformStricmp(ext, (*i)->info->extension) == 0) retval = tryOpenDir(*i, d, forWriting); } /* for */ /* failing an exact file extension match, try all the others... */ - for (i = dirFunctions; (*i != NULL) && (retval == NULL); i++) + for (i = archivers; (*i != NULL) && (retval == NULL); i++) { if (__PHYSFS_platformStricmp(ext, (*i)->info->extension) != 0) retval = tryOpenDir(*i, d, forWriting); @@ -596,7 +593,7 @@ static DirHandle *openDirectory(const char *d, int forWriting) else /* no extension? Try them all. */ { - for (i = dirFunctions; (*i != NULL) && (retval == NULL); i++) + for (i = archivers; (*i != NULL) && (retval == NULL); i++) retval = tryOpenDir(*i, d, forWriting); } /* else */ @@ -605,61 +602,44 @@ static DirHandle *openDirectory(const char *d, int forWriting) } /* openDirectory */ -static PhysDirInfo *buildDirInfo(const char *newDir, int forWriting) +static DirHandle *createDirHandle(const char *newDir, int forWriting) { DirHandle *dirHandle = NULL; - PhysDirInfo *di = NULL; - BAIL_IF_MACRO(newDir == NULL, ERR_INVALID_ARGUMENT, 0); + BAIL_IF_MACRO(newDir == NULL, ERR_INVALID_ARGUMENT, NULL); dirHandle = openDirectory(newDir, forWriting); - BAIL_IF_MACRO(dirHandle == NULL, NULL, 0); + BAIL_IF_MACRO(dirHandle == NULL, NULL, NULL); - /* !!! FIXME: get rid of this allocation */ - di = (PhysDirInfo *) malloc(sizeof (PhysDirInfo)); - if (di == NULL) + dirHandle->dirName = (char *) malloc(strlen(newDir) + 1); + if (dirHandle->dirName == NULL) { dirHandle->funcs->dirClose(dirHandle->opaque); free(dirHandle); - BAIL_IF_MACRO(di == NULL, ERR_OUT_OF_MEMORY, 0); + BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL); } /* if */ - di->dirName = (char *) malloc(strlen(newDir) + 1); - if (di->dirName == NULL) - { - free(di); - dirHandle->funcs->dirClose(dirHandle->opaque); - free(dirHandle); - BAIL_MACRO(ERR_OUT_OF_MEMORY, 0); - } /* if */ - - di->next = NULL; - di->dirHandle = dirHandle; - strcpy(di->dirName, newDir); - return(di); -} /* buildDirInfo */ + strcpy(dirHandle->dirName, newDir); + return(dirHandle); +} /* createDirHandle */ /* MAKE SURE you've got the stateLock held before calling this! */ -static int freeDirInfo(PhysDirInfo *di, FileHandleList *openList) +static int freeDirHandle(DirHandle *dh, FileHandle *openList) { - FileHandleList *i; + FileHandle *i; - if (di == NULL) + if (dh == NULL) return(1); for (i = openList; i != NULL; i = i->next) - { - const DirHandle *h = ((FileHandle *) &(i->handle.opaque))->dirHandle; - BAIL_IF_MACRO(h == di->dirHandle, ERR_FILES_STILL_OPEN, 0); - } /* for */ + BAIL_IF_MACRO(i->dirHandle == dh, ERR_FILES_STILL_OPEN, 0); - di->dirHandle->funcs->dirClose(di->dirHandle->opaque); - free(di->dirHandle); - free(di->dirName); - free(di); + dh->funcs->dirClose(dh->opaque); + free(dh->dirName); + free(dh); return(1); -} /* freeDirInfo */ +} /* freeDirHandle */ static char *calculateUserDir(void) @@ -752,9 +732,8 @@ static char *calculateBaseDir(const char *argv0) * Last ditch effort: it's the current working directory. (*shrug*) */ retval = __PHYSFS_platformCurrentDir(); - if(retval != NULL) { - return(retval); - } + if (retval != NULL) + return(retval); /* * Ok, current directory doesn't exist, use the root directory. @@ -855,17 +834,16 @@ int PHYSFS_init(const char *argv0) /* MAKE SURE you hold stateLock before calling this! */ -static int closeFileHandleList(FileHandleList **list) +static int closeFileHandleList(FileHandle **list) { - FileHandleList *i; - FileHandleList *next = NULL; + FileHandle *i; + FileHandle *next = NULL; FileHandle *h; for (i = *list; i != NULL; i = next) { next = i->next; - h = (FileHandle *) (i->handle.opaque); - if (!h->funcs->fileClose(h)) + if (!i->funcs->fileClose(i->opaque)) { *list = i; return(0); @@ -882,8 +860,8 @@ static int closeFileHandleList(FileHandleList **list) /* MAKE SURE you hold the stateLock before calling this! */ static void freeSearchPath(void) { - PhysDirInfo *i; - PhysDirInfo *next = NULL; + DirHandle *i; + DirHandle *next = NULL; closeFileHandleList(&openReadList); @@ -892,7 +870,7 @@ static void freeSearchPath(void) for (i = searchPath; i != NULL; i = next) { next = i->next; - freeDirInfo(i, openReadList); + freeDirHandle(i, openReadList); } /* for */ searchPath = NULL; } /* if */ @@ -996,14 +974,14 @@ int PHYSFS_setWriteDir(const char *newDir) if (writeDir != NULL) { - BAIL_IF_MACRO_MUTEX(!freeDirInfo(writeDir, openWriteList), NULL, + BAIL_IF_MACRO_MUTEX(!freeDirHandle(writeDir, openWriteList), NULL, stateLock, 0); writeDir = NULL; } /* if */ if (newDir != NULL) { - writeDir = buildDirInfo(newDir, 1); + writeDir = createDirHandle(newDir, 1); retval = (writeDir != NULL); } /* if */ @@ -1015,9 +993,9 @@ int PHYSFS_setWriteDir(const char *newDir) int PHYSFS_addToSearchPath(const char *newDir, int appendToPath) { - PhysDirInfo *di; - PhysDirInfo *prev = NULL; - PhysDirInfo *i; + DirHandle *dh; + DirHandle *prev = NULL; + DirHandle *i; __PHYSFS_platformGrabMutex(stateLock); @@ -1028,21 +1006,20 @@ int PHYSFS_addToSearchPath(const char *newDir, int appendToPath) prev = i; } /* for */ - di = buildDirInfo(newDir, 0); - BAIL_IF_MACRO_MUTEX(di == NULL, NULL, stateLock, 0); + dh = createDirHandle(newDir, 0); + BAIL_IF_MACRO_MUTEX(dh == NULL, NULL, stateLock, 0); if (appendToPath) { - di->next = NULL; if (prev == NULL) - searchPath = di; + searchPath = dh; else - prev->next = di; + prev->next = dh; } /* if */ else { - di->next = searchPath; - searchPath = di; + dh->next = searchPath; + searchPath = dh; } /* else */ __PHYSFS_platformReleaseMutex(stateLock); @@ -1052,9 +1029,9 @@ int PHYSFS_addToSearchPath(const char *newDir, int appendToPath) int PHYSFS_removeFromSearchPath(const char *oldDir) { - PhysDirInfo *i; - PhysDirInfo *prev = NULL; - PhysDirInfo *next = NULL; + DirHandle *i; + DirHandle *prev = NULL; + DirHandle *next = NULL; BAIL_IF_MACRO(oldDir == NULL, ERR_INVALID_ARGUMENT, 0); @@ -1064,7 +1041,7 @@ int PHYSFS_removeFromSearchPath(const char *oldDir) if (strcmp(i->dirName, oldDir) == 0) { next = i->next; - BAIL_IF_MACRO_MUTEX(!freeDirInfo(i, openReadList), NULL, + BAIL_IF_MACRO_MUTEX(!freeDirHandle(i, openReadList), NULL, stateLock, 0); if (prev == NULL) @@ -1085,7 +1062,7 @@ char **PHYSFS_getSearchPath(void) { int count = 1; int x; - PhysDirInfo *i; + DirHandle *i; char **retval; __PHYSFS_platformGrabMutex(stateLock); @@ -1151,7 +1128,7 @@ int PHYSFS_setSaneConfig(const char *organization, const char *appName, } /* if */ else { - no_write = 1; + no_write = 1; } /* else */ if (no_write) @@ -1385,7 +1362,7 @@ int PHYSFS_mkdir(const char *dname) __PHYSFS_platformGrabMutex(stateLock); BAIL_IF_MACRO_MUTEX(writeDir == NULL, ERR_NO_WRITE_DIR, stateLock, 0); - h = writeDir->dirHandle; + h = writeDir; BAIL_IF_MACRO_MUTEX(!__PHYSFS_verifySecurity(h,dname,1),NULL,stateLock,0); start = str = malloc(strlen(dname) + 1); BAIL_IF_MACRO_MUTEX(str == NULL, ERR_OUT_OF_MEMORY, stateLock, 0); @@ -1433,7 +1410,7 @@ int PHYSFS_delete(const char *fname) __PHYSFS_platformGrabMutex(stateLock); BAIL_IF_MACRO_MUTEX(writeDir == NULL, ERR_NO_WRITE_DIR, stateLock, 0); - h = writeDir->dirHandle; + h = writeDir; BAIL_IF_MACRO_MUTEX(!__PHYSFS_verifySecurity(h,fname,0),NULL,stateLock,0); retval = h->funcs->remove(h->opaque, fname); @@ -1444,7 +1421,7 @@ int PHYSFS_delete(const char *fname) const char *PHYSFS_getRealDir(const char *filename) { - PhysDirInfo *i; + DirHandle *i; const char *retval = NULL; while (*filename == '/') @@ -1453,10 +1430,9 @@ const char *PHYSFS_getRealDir(const char *filename) __PHYSFS_platformGrabMutex(stateLock); for (i = searchPath; ((i != NULL) && (retval == NULL)); i = i->next) { - DirHandle *h = i->dirHandle; - if (__PHYSFS_verifySecurity(h, filename, 0)) + if (__PHYSFS_verifySecurity(i, filename, 0)) { - if (h->funcs->exists(h->opaque, filename)) + if (i->funcs->exists(i->opaque, filename)) retval = i->dirName; } /* if */ } /* for */ @@ -1557,7 +1533,7 @@ static void interpolateStringLists(LinkedStringList **final, char **PHYSFS_enumerateFiles(const char *path) { - PhysDirInfo *i; + DirHandle *i; char **retval = NULL; LinkedStringList *rc; LinkedStringList *finalList = NULL; @@ -1570,10 +1546,9 @@ char **PHYSFS_enumerateFiles(const char *path) __PHYSFS_platformGrabMutex(stateLock); for (i = searchPath; i != NULL; i = i->next) { - DirHandle *h = i->dirHandle; - if (__PHYSFS_verifySecurity(h, path, 0)) + if (__PHYSFS_verifySecurity(i, path, 0)) { - rc = h->funcs->enumerateFiles(h->opaque, path, omitSymLinks); + rc = i->funcs->enumerateFiles(i->opaque, path, omitSymLinks); interpolateStringLists(&finalList, rc); } /* if */ } /* for */ @@ -1596,7 +1571,7 @@ int PHYSFS_exists(const char *fname) PHYSFS_sint64 PHYSFS_getLastModTime(const char *fname) { - PhysDirInfo *i; + DirHandle *i; PHYSFS_sint64 retval = -1; int fileExists = 0; @@ -1610,9 +1585,8 @@ PHYSFS_sint64 PHYSFS_getLastModTime(const char *fname) __PHYSFS_platformGrabMutex(stateLock); for (i = searchPath; ((i != NULL) && (!fileExists)); i = i->next) { - DirHandle *h = i->dirHandle; - if (__PHYSFS_verifySecurity(h, fname, 0)) - retval = h->funcs->getLastModTime(h->opaque, fname, &fileExists); + if (__PHYSFS_verifySecurity(i, fname, 0)) + retval = i->funcs->getLastModTime(i->opaque, fname, &fileExists); } /* for */ __PHYSFS_platformReleaseMutex(stateLock); @@ -1622,7 +1596,7 @@ PHYSFS_sint64 PHYSFS_getLastModTime(const char *fname) int PHYSFS_isDirectory(const char *fname) { - PhysDirInfo *i; + DirHandle *i; int retval = 0; int fileExists = 0; @@ -1635,9 +1609,8 @@ int PHYSFS_isDirectory(const char *fname) __PHYSFS_platformGrabMutex(stateLock); for (i = searchPath; ((i != NULL) && (!fileExists)); i = i->next) { - DirHandle *h = i->dirHandle; - if (__PHYSFS_verifySecurity(h, fname, 0)) - retval = h->funcs->isDirectory(h->opaque, fname, &fileExists); + if (__PHYSFS_verifySecurity(i, fname, 0)) + retval = i->funcs->isDirectory(i->opaque, fname, &fileExists); } /* for */ __PHYSFS_platformReleaseMutex(stateLock); @@ -1647,7 +1620,7 @@ int PHYSFS_isDirectory(const char *fname) int PHYSFS_isSymbolicLink(const char *fname) { - PhysDirInfo *i; + DirHandle *i; int retval = 0; int fileExists = 0; @@ -1662,9 +1635,8 @@ int PHYSFS_isSymbolicLink(const char *fname) __PHYSFS_platformGrabMutex(stateLock); for (i = searchPath; ((i != NULL) && (!fileExists)); i = i->next) { - DirHandle *h = i->dirHandle; - if (__PHYSFS_verifySecurity(h, fname, 0)) - retval = h->funcs->isSymLink(h->opaque, fname, &fileExists); + if (__PHYSFS_verifySecurity(i, fname, 0)) + retval = i->funcs->isSymLink(i->opaque, fname, &fileExists); } /* for */ __PHYSFS_platformReleaseMutex(stateLock); @@ -1674,47 +1646,48 @@ int PHYSFS_isSymbolicLink(const char *fname) static PHYSFS_file *doOpenWrite(const char *fname, int appending) { - PHYSFS_file *retval = NULL; - FileHandle *rc = NULL; - DirHandle *h; - const DirFunctions *f; - FileHandleList *list; + void *opaque = NULL; + FileHandle *fh = NULL; + DirHandle *h = NULL; + const PHYSFS_Archiver *f; BAIL_IF_MACRO(fname == NULL, ERR_INVALID_ARGUMENT, NULL); while (*fname == '/') fname++; __PHYSFS_platformGrabMutex(stateLock); - h = (writeDir == NULL) ? NULL : writeDir->dirHandle; - BAIL_IF_MACRO_MUTEX(!h, ERR_NO_WRITE_DIR, stateLock, NULL); + BAIL_IF_MACRO_MUTEX(!writeDir, ERR_NO_WRITE_DIR, stateLock, NULL); + + h = writeDir; BAIL_IF_MACRO_MUTEX(!__PHYSFS_verifySecurity(h, fname, 0), NULL, stateLock, NULL); - list = (FileHandleList *) malloc(sizeof (FileHandleList)); - BAIL_IF_MACRO_MUTEX(!list, ERR_OUT_OF_MEMORY, stateLock, NULL); - f = h->funcs; if (appending) - rc = f->openAppend(h->opaque, fname); + opaque = f->openAppend(h->opaque, fname); else - rc = f->openWrite(h->opaque, fname); + opaque = f->openWrite(h->opaque, fname); - if (rc == NULL) - free(list); + BAIL_IF_MACRO_MUTEX(opaque == NULL, NULL, stateLock, NULL); + + fh = (FileHandle *) malloc(sizeof (FileHandle)); + if (fh == NULL) + { + f->fileClose(opaque); + BAIL_MACRO_MUTEX(ERR_OUT_OF_MEMORY, stateLock, NULL); + } /* if */ else { - rc->dirHandle = h; - rc->buffer = NULL; /* just in case. */ - rc->buffill = rc->bufpos = rc->bufsize = 0; /* just in case. */ - rc->forReading = 0; - list->handle.opaque = (void *) rc; - list->next = openWriteList; - openWriteList = list; - retval = &(list->handle); + memset(fh, '\0', sizeof (FileHandle)); + fh->opaque = opaque; + fh->dirHandle = h; + fh->funcs = h->funcs; + fh->next = openWriteList; + openWriteList = fh; } /* else */ __PHYSFS_platformReleaseMutex(stateLock); - return(retval); + return((PHYSFS_file *) fh); } /* doOpenWrite */ @@ -1732,12 +1705,10 @@ PHYSFS_file *PHYSFS_openAppend(const char *filename) PHYSFS_file *PHYSFS_openRead(const char *fname) { - PHYSFS_file *retval = NULL; - FileHandle *rc = NULL; - FileHandleList *list; - DirHandle *h = NULL; + FileHandle *fh = NULL; int fileExists = 0; - PhysDirInfo *i = NULL; + DirHandle *i = NULL; + fvoid *opaque = NULL; BAIL_IF_MACRO(fname == NULL, ERR_INVALID_ARGUMENT, NULL); while (*fname == '/') @@ -1745,47 +1716,56 @@ PHYSFS_file *PHYSFS_openRead(const char *fname) __PHYSFS_platformGrabMutex(stateLock); BAIL_IF_MACRO_MUTEX(!searchPath, ERR_NOT_IN_SEARCH_PATH, stateLock, NULL); - for (i = searchPath; ((i != NULL) && (!fileExists)); i = i->next) + + i = searchPath; + + do { - h = i->dirHandle; - if (__PHYSFS_verifySecurity(h, fname, 0)) - rc = h->funcs->openRead(h->opaque, fname, &fileExists); - } /* for */ - BAIL_IF_MACRO_MUTEX(rc == NULL, NULL, stateLock, NULL); + if (__PHYSFS_verifySecurity(i, fname, 0)) + { + opaque = i->funcs->openRead(i->opaque, fname, &fileExists); + if (opaque) + break; + } /* if */ + i = i->next; + } while ((i != NULL) && (!fileExists)); - rc->dirHandle = h; + BAIL_IF_MACRO_MUTEX(opaque == NULL, NULL, stateLock, NULL); - list = (FileHandleList *) malloc(sizeof (FileHandleList)); - BAIL_IF_MACRO_MUTEX(!list, ERR_OUT_OF_MEMORY, stateLock, NULL); - list->handle.opaque = (void *) rc; - list->next = openReadList; - openReadList = list; - retval = &(list->handle); + fh = (FileHandle *) malloc(sizeof (FileHandle)); + if (fh == NULL) + { + i->funcs->fileClose(opaque); + BAIL_MACRO_MUTEX(ERR_OUT_OF_MEMORY, stateLock, NULL); + } /* if */ + + memset(fh, '\0', sizeof (FileHandle)); + fh->opaque = opaque; + fh->forReading = 1; + fh->dirHandle = i; + fh->funcs = i->funcs; + fh->next = openReadList; + openReadList = fh; __PHYSFS_platformReleaseMutex(stateLock); - rc->buffer = NULL; /* just in case. */ - rc->buffill = rc->bufpos = rc->bufsize = 0; /* just in case. */ - rc->forReading = 1; - - return(retval); + return((PHYSFS_file *) fh); } /* PHYSFS_openRead */ -static int closeHandleInOpenList(FileHandleList **list, PHYSFS_file *handle) +static int closeHandleInOpenList(FileHandle **list, FileHandle *handle) { - FileHandle *h = (FileHandle *) handle->opaque; - FileHandleList *prev = NULL; - FileHandleList *i; + FileHandle *prev = NULL; + FileHandle *i; int rc = 1; for (i = *list; i != NULL; i = i->next) { - if (&i->handle == handle) /* handle is in this list? */ + if (i == handle) /* handle is in this list? */ { - PHYSFS_uint8 *tmp = h->buffer; - rc = PHYSFS_flush(handle); + PHYSFS_uint8 *tmp = handle->buffer; + rc = PHYSFS_flush((PHYSFS_file *) handle); if (rc) - rc = h->funcs->fileClose(h); + rc = handle->funcs->fileClose(handle->opaque); if (!rc) return(-1); @@ -1793,11 +1773,11 @@ static int closeHandleInOpenList(FileHandleList **list, PHYSFS_file *handle) free(tmp); if (prev == NULL) - *list = i->next; + *list = handle->next; else - prev->next = i->next; + prev->next = handle->next; - free(i); + free(handle); return(1); } /* if */ prev = i; @@ -1807,8 +1787,9 @@ static int closeHandleInOpenList(FileHandleList **list, PHYSFS_file *handle) } /* closeHandleInOpenList */ -int PHYSFS_close(PHYSFS_file *handle) +int PHYSFS_close(PHYSFS_file *_handle) { + FileHandle *handle = (FileHandle *) _handle; int rc; __PHYSFS_platformGrabMutex(stateLock); @@ -1828,39 +1809,39 @@ int PHYSFS_close(PHYSFS_file *handle) } /* PHYSFS_close */ -static PHYSFS_sint64 doBufferedRead(PHYSFS_file *handle, void *buffer, +static PHYSFS_sint64 doBufferedRead(FileHandle *fh, void *buffer, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount) { - FileHandle *h = (FileHandle *) handle->opaque; PHYSFS_sint64 retval = 0; PHYSFS_uint32 remainder = 0; while (objCount > 0) { - PHYSFS_uint32 buffered = h->buffill - h->bufpos; + PHYSFS_uint32 buffered = fh->buffill - fh->bufpos; PHYSFS_uint64 mustread = (objSize * objCount) - remainder; PHYSFS_uint32 copied; if (buffered == 0) /* need to refill buffer? */ { - PHYSFS_sint64 rc = h->funcs->read(h, h->buffer, 1, h->bufsize); + PHYSFS_sint64 rc = fh->funcs->read(fh->opaque, fh->buffer, + 1, fh->bufsize); if (rc <= 0) { - h->bufpos -= remainder; + fh->bufpos -= remainder; return(((rc == -1) && (retval == 0)) ? -1 : retval); } /* if */ - buffered = h->buffill = (PHYSFS_uint32) rc; - h->bufpos = 0; + buffered = fh->buffill = (PHYSFS_uint32) rc; + fh->bufpos = 0; } /* if */ if (buffered > mustread) buffered = (PHYSFS_uint32) mustread; - memcpy(buffer, h->buffer + h->bufpos, (size_t) buffered); + memcpy(buffer, fh->buffer + fh->bufpos, (size_t) buffered); buffer = ((PHYSFS_uint8 *) buffer) + buffered; - h->bufpos += buffered; + fh->bufpos += buffered; buffered += remainder; /* take remainder into account. */ copied = (buffered / objSize); remainder = (buffered % objSize); @@ -1875,13 +1856,13 @@ static PHYSFS_sint64 doBufferedRead(PHYSFS_file *handle, void *buffer, PHYSFS_sint64 PHYSFS_read(PHYSFS_file *handle, void *buffer, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount) { - FileHandle *h = (FileHandle *) handle->opaque; + FileHandle *fh = (FileHandle *) handle; - BAIL_IF_MACRO(!h->forReading, ERR_FILE_ALREADY_OPEN_W, -1); - if (h->buffer != NULL) - return(doBufferedRead(handle, buffer, objSize, objCount)); + BAIL_IF_MACRO(!fh->forReading, ERR_FILE_ALREADY_OPEN_W, -1); + if (fh->buffer != NULL) + return(doBufferedRead(fh, buffer, objSize, objCount)); - return(h->funcs->read(h, buffer, objSize, objCount)); + return(fh->funcs->read(fh->opaque, buffer, objSize, objCount)); } /* PHYSFS_read */ @@ -1889,94 +1870,97 @@ static PHYSFS_sint64 doBufferedWrite(PHYSFS_file *handle, const void *buffer, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount) { - FileHandle *h = (FileHandle *) handle->opaque; - + FileHandle *fh = (FileHandle *) handle; + /* whole thing fits in the buffer? */ - if (h->buffill + (objSize * objCount) < h->bufsize) + if (fh->buffill + (objSize * objCount) < fh->bufsize) { - memcpy(h->buffer + h->buffill, buffer, objSize * objCount); - h->buffill += (objSize * objCount); + memcpy(fh->buffer + fh->buffill, buffer, objSize * objCount); + fh->buffill += (objSize * objCount); return(objCount); } /* if */ /* would overflow buffer. Flush and then write the new objects, too. */ BAIL_IF_MACRO(!PHYSFS_flush(handle), NULL, -1); - return(h->funcs->write(h, buffer, objSize, objCount)); + return(fh->funcs->write(fh->opaque, buffer, objSize, objCount)); } /* doBufferedWrite */ PHYSFS_sint64 PHYSFS_write(PHYSFS_file *handle, const void *buffer, PHYSFS_uint32 objSize, PHYSFS_uint32 objCount) { - FileHandle *h = (FileHandle *) handle->opaque; + FileHandle *fh = (FileHandle *) handle; - BAIL_IF_MACRO(h->forReading, ERR_FILE_ALREADY_OPEN_R, -1); - if (h->buffer != NULL) + BAIL_IF_MACRO(fh->forReading, ERR_FILE_ALREADY_OPEN_R, -1); + if (fh->buffer != NULL) return(doBufferedWrite(handle, buffer, objSize, objCount)); - return(h->funcs->write(h, buffer, objSize, objCount)); + return(fh->funcs->write(fh->opaque, buffer, objSize, objCount)); } /* PHYSFS_write */ int PHYSFS_eof(PHYSFS_file *handle) { - FileHandle *h = (FileHandle *) handle->opaque; + FileHandle *fh = (FileHandle *) handle; - if (!h->forReading) /* never EOF on files opened for write/append. */ + if (!fh->forReading) /* never EOF on files opened for write/append. */ return(0); /* eof if buffer is empty and archiver says so. */ - return((h->bufpos == h->buffill) && (h->funcs->eof(h))); + return((fh->bufpos == fh->buffill) && (fh->funcs->eof(fh->opaque))); } /* PHYSFS_eof */ PHYSFS_sint64 PHYSFS_tell(PHYSFS_file *handle) { - FileHandle *h = (FileHandle *) handle->opaque; - PHYSFS_sint64 retval = h->forReading ? - (h->funcs->tell(h) - h->buffill) + h->bufpos : - (h->funcs->tell(h) + h->buffill); + FileHandle *fh = (FileHandle *) handle; + PHYSFS_sint64 pos = fh->funcs->tell(fh->opaque); + PHYSFS_sint64 retval = fh->forReading ? + (pos - fh->buffill) + fh->bufpos : + (pos + fh->buffill); return(retval); } /* PHYSFS_tell */ int PHYSFS_seek(PHYSFS_file *handle, PHYSFS_uint64 pos) { - FileHandle *h = (FileHandle *) handle->opaque; + FileHandle *fh = (FileHandle *) handle; BAIL_IF_MACRO(!PHYSFS_flush(handle), NULL, 0); - if (h->buffer && h->forReading) + if (fh->buffer && fh->forReading) { /* avoid throwing away our precious buffer if seeking within it. */ PHYSFS_sint64 offset = pos - PHYSFS_tell(handle); if ( /* seeking within the already-buffered range? */ - ((offset >= 0) && (offset <= h->buffill - h->bufpos)) /* forwards */ - || ((offset < 0) && (-offset <= h->bufpos)) /* backwards */ ) + ((offset >= 0) && (offset <= fh->buffill - fh->bufpos)) /* fwd */ + || ((offset < 0) && (-offset <= fh->bufpos)) /* backward */ ) { - h->bufpos += offset; + fh->bufpos += offset; return(1); /* successful seek */ } /* if */ } /* if */ /* we have to fall back to a 'raw' seek. */ - h->buffill = h->bufpos = 0; - return(h->funcs->seek(h, pos)); + fh->buffill = fh->bufpos = 0; + return(fh->funcs->seek(fh->opaque, pos)); } /* PHYSFS_seek */ PHYSFS_sint64 PHYSFS_fileLength(PHYSFS_file *handle) { - FileHandle *h = (FileHandle *) handle->opaque; - return(h->funcs->fileLength(h)); + FileHandle *fh = (FileHandle *) handle; + return(fh->funcs->fileLength(fh->opaque)); } /* PHYSFS_filelength */ int PHYSFS_setBuffer(PHYSFS_file *handle, PHYSFS_uint64 _bufsize) { - FileHandle *h = (FileHandle *) handle->opaque; - PHYSFS_uint32 bufsize = (PHYSFS_uint32) _bufsize; + FileHandle *fh = (FileHandle *) handle; + PHYSFS_uint32 bufsize; BAIL_IF_MACRO(_bufsize > 0xFFFFFFFF, "buffer must fit in 32-bits", 0); + bufsize = (PHYSFS_uint32) _bufsize; + BAIL_IF_MACRO(!PHYSFS_flush(handle), NULL, 0); /* @@ -1984,49 +1968,50 @@ int PHYSFS_setBuffer(PHYSFS_file *handle, PHYSFS_uint64 _bufsize) * if we weren't buffering, so that the next read will get the * right chunk of stuff from the file. PHYSFS_flush() handles writes. */ - if ((h->forReading) && (h->buffill != h->bufpos)) + if ((fh->forReading) && (fh->buffill != fh->bufpos)) { PHYSFS_uint64 pos; - PHYSFS_sint64 curpos = h->funcs->tell(h); + PHYSFS_sint64 curpos = fh->funcs->tell(fh->opaque); BAIL_IF_MACRO(curpos == -1, NULL, 0); - pos = ((curpos - h->buffill) + h->bufpos); - BAIL_IF_MACRO(!h->funcs->seek(h, pos), NULL, 0); + pos = ((curpos - fh->buffill) + fh->bufpos); + BAIL_IF_MACRO(!fh->funcs->seek(fh->opaque, pos), NULL, 0); } /* if */ if (bufsize == 0) /* delete existing buffer. */ { - if (h->buffer != NULL) + if (fh->buffer != NULL) { - free(h->buffer); - h->buffer = NULL; + free(fh->buffer); + fh->buffer = NULL; } /* if */ } /* if */ else { - PHYSFS_uint8 *newbuf = realloc(h->buffer, bufsize); + PHYSFS_uint8 *newbuf = realloc(fh->buffer, bufsize); BAIL_IF_MACRO(newbuf == NULL, ERR_OUT_OF_MEMORY, 0); - h->buffer = newbuf; + fh->buffer = newbuf; } /* else */ - h->bufsize = bufsize; - h->buffill = h->bufpos = 0; + fh->bufsize = bufsize; + fh->buffill = fh->bufpos = 0; return(1); } /* PHYSFS_setBuffer */ int PHYSFS_flush(PHYSFS_file *handle) { - FileHandle *h = (FileHandle *) handle->opaque; + FileHandle *fh = (FileHandle *) handle; PHYSFS_sint64 rc; - if ((h->forReading) || (h->bufpos == h->buffill)) + if ((fh->forReading) || (fh->bufpos == fh->buffill)) return(1); /* open for read or buffer empty are successful no-ops. */ /* dump buffer to disk. */ - rc = h->funcs->write(h, h->buffer + h->bufpos, h->buffill - h->bufpos, 1); + rc = fh->funcs->write(fh->opaque, fh->buffer + fh->bufpos, + fh->buffill - fh->bufpos, 1); BAIL_IF_MACRO(rc <= 0, NULL, 0); - h->bufpos = h->buffill = 0; + fh->bufpos = fh->buffill = 0; return(1); } /* PHYSFS_flush */ @@ -2065,12 +2050,12 @@ LinkedStringList *__PHYSFS_addToLinkedStringList(LinkedStringList *retval, } /* __PHYSFS_addToLinkedStringList */ -int PHYSFS_setAllocator(PHYSFS_allocator *a) +int PHYSFS_setAllocator(PHYSFS_Allocator *a) { BAIL_IF_MACRO(initialized, ERR_IS_INITIALIZED, 0); externalAllocator = (a != NULL); if (externalAllocator) - memcpy(&allocator, a, sizeof (PHYSFS_allocator)); + memcpy(&allocator, a, sizeof (PHYSFS_Allocator)); return(1); } /* PHYSFS_setAllocator */ @@ -2087,7 +2072,7 @@ static void setDefaultAllocator(void) } /* setDefaultAllocator */ -PHYSFS_allocator *__PHYSFS_getAllocator(void) +PHYSFS_Allocator *__PHYSFS_getAllocator(void) { return(&allocator); } /* __PHYFS_getAllocator */ diff --git a/physfs.h b/physfs.h index 75f4b36..3c0c613 100644 --- a/physfs.h +++ b/physfs.h @@ -1842,11 +1842,11 @@ typedef struct void *(*malloc)(size_t); void *(*realloc)(void *, size_t); void (*free)(void *); -} PHYSFS_allocator; +} PHYSFS_Allocator; /** - * \fn int PHYSFS_setAllocator(PHYSFS_allocator *allocator) + * \fn int PHYSFS_setAllocator(PHYSFS_Allocator *allocator) * \brief Hook your own allocation routines into PhysicsFS. * * (This is for limited, hardcore use. If you don't immediately see a need @@ -1870,7 +1870,7 @@ typedef struct * \return zero on failure, non-zero on success. This call only fails * when used between PHYSFS_init() and PHYSFS_deinit() calls. */ -__EXPORT__ int PHYSFS_setAllocator(PHYSFS_allocator *allocator); +__EXPORT__ int PHYSFS_setAllocator(PHYSFS_Allocator *allocator); /* Everything above this line is part of the PhysicsFS 2.0 API. */ diff --git a/physfs_internal.h b/physfs_internal.h index dcd862b..ccc7d29 100644 --- a/physfs_internal.h +++ b/physfs_internal.h @@ -931,113 +931,32 @@ typedef struct __PHYSFS_LINKEDSTRINGLIST__ } LinkedStringList; -typedef struct __PHYSFS_FILEHANDLE__ +/* !!! FIXME: find something better than "dvoid" and "fvoid" ... */ +/* Opaque data for file and dir handlers... */ +typedef void dvoid; +typedef void fvoid; + + +typedef struct { /* - * This is reserved for the driver to store information. + * Basic info about this archiver... */ - void *opaque; - - /* - * Non-zero if file opened for reading, zero if write/append. - */ - PHYSFS_uint8 forReading; - - /* - * This is the buffer, if one is set (NULL otherwise). Don't touch. - */ - PHYSFS_uint8 *buffer; - - /* - * This is the buffer size, if one is set (0 otherwise). Don't touch. - */ - PHYSFS_uint32 bufsize; - - /* - * This is the buffer fill size. Don't touch. - */ - PHYSFS_uint32 buffill; - - /* - * This is the buffer position. Don't touch. - */ - PHYSFS_uint32 bufpos; - - /* - * This should be the DirHandle that created this FileHandle. - */ - const struct __PHYSFS_DIRHANDLE__ *dirHandle; - - /* - * Pointer to the file i/o functions for this filehandle. - */ - const struct __PHYSFS_FILEFUNCTIONS__ *funcs; -} FileHandle; - - -typedef struct __PHYSFS_FILEFUNCTIONS__ -{ - /* - * Read more from the file. - * Returns number of objects of (objSize) bytes read from file, -1 - * if complete failure. - * On failure, call __PHYSFS_setError(). - */ - PHYSFS_sint64 (*read)(FileHandle *handle, void *buffer, - PHYSFS_uint32 objSize, PHYSFS_uint32 objCount); - - /* - * Write more to the file. Archives don't have to implement this. - * (Set it to NULL if not implemented). - * Returns number of objects of (objSize) bytes written to file, -1 - * if complete failure. - * On failure, call __PHYSFS_setError(). - */ - PHYSFS_sint64 (*write)(FileHandle *handle, const void *buffer, - PHYSFS_uint32 objSize, PHYSFS_uint32 objCount); - - /* - * Returns non-zero if at end of file. - */ - int (*eof)(FileHandle *handle); - - /* - * Returns byte offset from start of file. - */ - PHYSFS_sint64 (*tell)(FileHandle *handle); - - /* - * Move read/write pointer to byte offset from start of file. - * Returns non-zero on success, zero on error. - * On failure, call __PHYSFS_setError(). - */ - int (*seek)(FileHandle *handle, PHYSFS_uint64 offset); - - /* - * Return number of bytes available in the file, or -1 if you - * aren't able to determine. - * On failure, call __PHYSFS_setError(). - */ - PHYSFS_sint64 (*fileLength)(FileHandle *handle); - - /* - * Close the file, and free the FileHandle structure (including "opaque"). - * returns non-zero on success, zero if can't close file. - * On failure, call __PHYSFS_setError(). - */ - int (*fileClose)(FileHandle *handle); -} FileFunctions; - - -/* - * Symlinks should always be followed; PhysicsFS will use - * DirFunctions->isSymLink() and make a judgement on whether to - * continue to call other methods based on that. - */ -typedef struct __PHYSFS_DIRFUNCTIONS__ -{ const PHYSFS_ArchiveInfo *info; + + /* + * DIRECTORY ROUTINES: + * These functions are for dir handles. Generate a handle with the + * openArchive() method, then pass it as the "opaque" dvoid to the + * others. + * + * Symlinks should always be followed; PhysicsFS will use the + * isSymLink() method and make a judgement on whether to + * continue to call other methods based on that. + */ + + /* * Returns non-zero if (filename) is a valid archive that this * driver can handle. This filename is in platform-dependent @@ -1067,7 +986,7 @@ typedef struct __PHYSFS_DIRFUNCTIONS__ * If you have a memory failure, return as much as you can. * This dirname is in platform-independent notation. */ - LinkedStringList *(*enumerateFiles)(void *opaque, + LinkedStringList *(*enumerateFiles)(dvoid *opaque, const char *dirname, int omitSymLinks); @@ -1077,7 +996,7 @@ typedef struct __PHYSFS_DIRFUNCTIONS__ * This filename is in platform-independent notation. * You should not follow symlinks. */ - int (*exists)(void *opaque, const char *name); + int (*exists)(dvoid *opaque, const char *name); /* * Returns non-zero if filename is really a directory. @@ -1089,7 +1008,7 @@ typedef struct __PHYSFS_DIRFUNCTIONS__ * non-zero if the file existed (even if it's a broken symlink!), * zero if it did not. */ - int (*isDirectory)(void *opaque, const char *name, int *fileExists); + int (*isDirectory)(dvoid *opaque, const char *name, int *fileExists); /* * Returns non-zero if filename is really a symlink. @@ -1099,7 +1018,7 @@ typedef struct __PHYSFS_DIRFUNCTIONS__ * non-zero if the file existed (even if it's a broken symlink!), * zero if it did not. */ - int (*isSymLink)(void *opaque, const char *name, int *fileExists); + int (*isSymLink)(dvoid *opaque, const char *name, int *fileExists); /* * Retrieve the last modification time (mtime) of a file. @@ -1111,46 +1030,50 @@ typedef struct __PHYSFS_DIRFUNCTIONS__ * non-zero if the file existed (even if it's a broken symlink!), * zero if it did not. */ - PHYSFS_sint64 (*getLastModTime)(void *opaque, const char *fnm, int *exist); + PHYSFS_sint64 (*getLastModTime)(dvoid *opaque, const char *fnm, int *exist); /* - * Open file for reading, and return a FileHandle. + * Open file for reading. * This filename is in platform-independent notation. * If you can't handle multiple opens of the same file, * you can opt to fail for the second call. * Fail if the file does not exist. * Returns NULL on failure, and calls __PHYSFS_setError(). + * Returns non-NULL on success. The pointer returned will be + * passed as the "opaque" parameter for later file calls. * * Regardless of success or failure, please set *fileExists to * non-zero if the file existed (even if it's a broken symlink!), * zero if it did not. */ - FileHandle *(*openRead)(void *opaque, const char *fname, int *fileExists); + fvoid *(*openRead)(dvoid *opaque, const char *fname, int *fileExists); /* - * Open file for writing, and return a FileHandle. + * Open file for writing. * If the file does not exist, it should be created. If it exists, * it should be truncated to zero bytes. The writing * offset should be the start of the file. * This filename is in platform-independent notation. - * This method may be NULL. * If you can't handle multiple opens of the same file, * you can opt to fail for the second call. * Returns NULL on failure, and calls __PHYSFS_setError(). + * Returns non-NULL on success. The pointer returned will be + * passed as the "opaque" parameter for later file calls. */ - FileHandle *(*openWrite)(void *opaque, const char *filename); + fvoid *(*openWrite)(dvoid *opaque, const char *filename); /* - * Open file for appending, and return a FileHandle. + * Open file for appending. * If the file does not exist, it should be created. The writing * offset should be the end of the file. * This filename is in platform-independent notation. - * This method may be NULL. * If you can't handle multiple opens of the same file, * you can opt to fail for the second call. * Returns NULL on failure, and calls __PHYSFS_setError(). + * Returns non-NULL on success. The pointer returned will be + * passed as the "opaque" parameter for later file calls. */ - FileHandle *(*openAppend)(void *opaque, const char *filename); + fvoid *(*openAppend)(dvoid *opaque, const char *filename); /* * Delete a file in the archive/directory. @@ -1159,7 +1082,7 @@ typedef struct __PHYSFS_DIRFUNCTIONS__ * This method may be NULL. * On failure, call __PHYSFS_setError(). */ - int (*remove)(void *opaque, const char *filename); + int (*remove)(dvoid *opaque, const char *filename); /* * Create a directory in the archive/directory. @@ -1171,7 +1094,7 @@ typedef struct __PHYSFS_DIRFUNCTIONS__ * This method may be NULL. * On failure, call __PHYSFS_setError(). */ - int (*mkdir)(void *opaque, const char *filename); + int (*mkdir)(dvoid *opaque, const char *filename); /* * Close directories/archives, and free any associated memory, @@ -1179,8 +1102,67 @@ typedef struct __PHYSFS_DIRFUNCTIONS__ * that it won't be called if there are still files open from * this archive. */ - void (*dirClose)(void *opaque); -} DirFunctions; + void (*dirClose)(dvoid *opaque); + + + + /* + * FILE ROUTINES: + * These functions are for file handles generated by the open*() methods. + * They are distinguished by taking a "fvoid" instead of a "dvoid" for + * the opaque handle. + */ + + /* + * Read more from the file. + * Returns number of objects of (objSize) bytes read from file, -1 + * if complete failure. + * On failure, call __PHYSFS_setError(). + */ + PHYSFS_sint64 (*read)(fvoid *opaque, void *buffer, + PHYSFS_uint32 objSize, PHYSFS_uint32 objCount); + + /* + * Write more to the file. Archives don't have to implement this. + * (Set it to NULL if not implemented). + * Returns number of objects of (objSize) bytes written to file, -1 + * if complete failure. + * On failure, call __PHYSFS_setError(). + */ + PHYSFS_sint64 (*write)(fvoid *opaque, const void *buffer, + PHYSFS_uint32 objSize, PHYSFS_uint32 objCount); + + /* + * Returns non-zero if at end of file. + */ + int (*eof)(fvoid *opaque); + + /* + * Returns byte offset from start of file. + */ + PHYSFS_sint64 (*tell)(fvoid *opaque); + + /* + * Move read/write pointer to byte offset from start of file. + * Returns non-zero on success, zero on error. + * On failure, call __PHYSFS_setError(). + */ + int (*seek)(fvoid *opaque, PHYSFS_uint64 offset); + + /* + * Return number of bytes available in the file, or -1 if you + * aren't able to determine. + * On failure, call __PHYSFS_setError(). + */ + PHYSFS_sint64 (*fileLength)(fvoid *opaque); + + /* + * Close the file, and free associated resources, including (opaque) + * if applicable. Returns non-zero on success, zero if can't close + * file. On failure, call __PHYSFS_setError(). + */ + int (*fileClose)(fvoid *opaque); +} PHYSFS_Archiver; /* @@ -1272,7 +1254,7 @@ void __PHYSFS_sort(void *entries, PHYSFS_uint32 max, /* * Get the current allocator. Not valid before PHYSFS_init is called! */ -PHYSFS_allocator *__PHYSFS_getAllocator(void); +PHYSFS_Allocator *__PHYSFS_getAllocator(void); /*--------------------------------------------------------------------------*/ @@ -1571,9 +1553,9 @@ void __PHYSFS_platformTimeslice(void); /* * Enumerate a directory of files. This follows the rules for the - * DirFunctions->enumerateFiles() method (see above), except that the + * PHYSFS_Archiver->enumerateFiles() method (see above), except that the * (dirName) that is passed to this function is converted to - * platform-DEPENDENT notation by the caller. The DirFunctions version + * platform-DEPENDENT notation by the caller. The PHYSFS_Archiver version * uses platform-independent notation. Note that ".", "..", and other * metaentries should always be ignored. */