walkero
/
physfs
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

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.
This commit is contained in:
Ryan C. Gordon 2004-09-26 13:00:59 +00:00
parent 73044892fa
commit 90031c81f3
12 changed files with 806 additions and 997 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
CHANGELOG
View File

@ -2,6 +2,12 @@
* CHANGELOG. * 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, 09252004 - Cleaned up archiver interface to not deal with DirHandles anymore,
which simplifies things, removes some responsibility and code which simplifies things, removes some responsibility and code
duplication from the archivers, and trims some malloc pressure. duplication from the archivers, and trims some malloc pressure.

177
archivers/dir.c
View File

@ -18,34 +18,30 @@
#define __PHYSICSFS_INTERNAL__ #define __PHYSICSFS_INTERNAL__
#include "physfs_internal.h" #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); 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); PHYSFS_uint32 objSize, PHYSFS_uint32 objCount);
static PHYSFS_sint64 DIR_dummyRead(FileHandle *handle, void *buffer, static int DIR_eof(fvoid *opaque);
PHYSFS_uint32 objSize, PHYSFS_uint32 objCount); static PHYSFS_sint64 DIR_tell(fvoid *opaque);
static PHYSFS_sint64 DIR_dummyWrite(FileHandle *handle, const void *buffer, static int DIR_seek(fvoid *opaque, PHYSFS_uint64 offset);
PHYSFS_uint32 objSize, PHYSFS_uint32 objCount); static PHYSFS_sint64 DIR_fileLength(fvoid *opaque);
static int DIR_eof(FileHandle *handle); static int DIR_fileClose(fvoid *opaque);
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_isArchive(const char *filename, int forWriting); static int DIR_isArchive(const char *filename, int forWriting);
static void *DIR_openArchive(const char *name, 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, const char *dname,
int omitSymLinks); int omitSymLinks);
static int DIR_exists(void *opaque, const char *name); static int DIR_exists(dvoid *opaque, const char *name);
static int DIR_isDirectory(void *opaque, const char *name, int *fileExists); static int DIR_isDirectory(dvoid *opaque, const char *name, int *fileExists);
static int DIR_isSymLink(void *opaque, const char *name, int *fileExists); static int DIR_isSymLink(dvoid *opaque, const char *name, int *fileExists);
static FileHandle *DIR_openRead(void *opaque, const char *fnm, int *exist); static fvoid *DIR_openRead(dvoid *opaque, const char *fnm, int *exist);
static PHYSFS_sint64 DIR_getLastModTime(void *opaque, const char *f, int *e); static PHYSFS_sint64 DIR_getLastModTime(dvoid *opaque, const char *f, int *e);
static FileHandle *DIR_openWrite(void *opaque, const char *filename); static fvoid *DIR_openWrite(dvoid *opaque, const char *filename);
static FileHandle *DIR_openAppend(void *opaque, const char *filename); static fvoid *DIR_openAppend(dvoid *opaque, const char *filename);
static int DIR_remove(void *opaque, const char *name); static int DIR_remove(dvoid *opaque, const char *name);
static int DIR_mkdir(void *opaque, const char *name); static int DIR_mkdir(dvoid *opaque, const char *name);
static void DIR_dirClose(void *opaque); static void DIR_dirClose(dvoid *opaque);
const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_DIR = 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 */
};
const PHYSFS_Archiver __PHYSFS_Archiver_DIR =
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 =
{ {
&__PHYSFS_ArchiveInfo_DIR, &__PHYSFS_ArchiveInfo_DIR,
DIR_isArchive, /* isArchive() method */ DIR_isArchive, /* isArchive() method */
@ -96,76 +69,68 @@ const DirFunctions __PHYSFS_DirFunctions_DIR =
DIR_openAppend, /* openAppend() method */ DIR_openAppend, /* openAppend() method */
DIR_remove, /* remove() method */ DIR_remove, /* remove() method */
DIR_mkdir, /* mkdir() 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_uint32 objSize, PHYSFS_uint32 objCount)
{ {
PHYSFS_sint64 retval; PHYSFS_sint64 retval;
retval = __PHYSFS_platformRead(handle->opaque, buffer, objSize, objCount); retval = __PHYSFS_platformRead(opaque, buffer, objSize, objCount);
return(retval); return(retval);
} /* DIR_read */ } /* 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_uint32 objSize, PHYSFS_uint32 objCount)
{ {
PHYSFS_sint64 retval; PHYSFS_sint64 retval;
retval = __PHYSFS_platformWrite(handle->opaque, buffer, objSize, objCount); retval = __PHYSFS_platformWrite(opaque, buffer, objSize, objCount);
return(retval); return(retval);
} /* DIR_write */ } /* DIR_write */
static PHYSFS_sint64 DIR_dummyRead(FileHandle *handle, void *buffer, static int DIR_eof(fvoid *opaque)
PHYSFS_uint32 objSize, PHYSFS_uint32 objCount)
{ {
BAIL_MACRO(ERR_NOT_SUPPORTED, -1); return(__PHYSFS_platformEOF(opaque));
} /* 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));
} /* DIR_eof */ } /* 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 */ } /* 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 */ } /* 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 */ } /* 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 * 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 * most likely fail, but that will leave the file handle in an undefined
* state if it fails. Flush failures we can recover from. * state if it fails. Flush failures we can recover from.
*/ */
BAIL_IF_MACRO(!__PHYSFS_platformFlush(handle->opaque), NULL, 0); BAIL_IF_MACRO(!__PHYSFS_platformFlush(opaque), NULL, 0);
BAIL_IF_MACRO(!__PHYSFS_platformClose(handle->opaque), NULL, 0); BAIL_IF_MACRO(!__PHYSFS_platformClose(opaque), NULL, 0);
free(handle);
return(1); return(1);
} /* DIR_fileClose */ } /* DIR_fileClose */
@ -200,7 +165,7 @@ static void *DIR_openArchive(const char *name, int forWriting)
} /* DIR_openArchive */ } /* DIR_openArchive */
static LinkedStringList *DIR_enumerateFiles(void *opaque, static LinkedStringList *DIR_enumerateFiles(dvoid *opaque,
const char *dname, const char *dname,
int omitSymLinks) int omitSymLinks)
{ {
@ -214,7 +179,7 @@ static LinkedStringList *DIR_enumerateFiles(void *opaque,
} /* DIR_enumerateFiles */ } /* 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); char *f = __PHYSFS_platformCvtToDependent((char *) opaque, name, NULL);
int retval; int retval;
@ -226,7 +191,7 @@ static int DIR_exists(void *opaque, const char *name)
} /* DIR_exists */ } /* 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); char *d = __PHYSFS_platformCvtToDependent((char *) opaque, name, NULL);
int retval = 0; int retval = 0;
@ -240,7 +205,7 @@ static int DIR_isDirectory(void *opaque, const char *name, int *fileExists)
} /* DIR_isDirectory */ } /* 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); char *f = __PHYSFS_platformCvtToDependent((char *) opaque, name, NULL);
int retval = 0; int retval = 0;
@ -254,7 +219,7 @@ static int DIR_isSymLink(void *opaque, const char *name, int *fileExists)
} /* DIR_isSymLink */ } /* DIR_isSymLink */
static PHYSFS_sint64 DIR_getLastModTime(void *opaque, static PHYSFS_sint64 DIR_getLastModTime(dvoid *opaque,
const char *name, const char *name,
int *fileExists) int *fileExists)
{ {
@ -270,13 +235,12 @@ static PHYSFS_sint64 DIR_getLastModTime(void *opaque,
} /* DIR_getLastModTime */ } /* DIR_getLastModTime */
static FileHandle *doOpen(void *opaque, const char *name, static fvoid *doOpen(dvoid *opaque, const char *name,
void *(*openFunc)(const char *filename), void *(*openFunc)(const char *filename),
int *fileExists, const FileFunctions *fileFuncs) int *fileExists)
{ {
char *f = __PHYSFS_platformCvtToDependent((char *) opaque, name, NULL); char *f = __PHYSFS_platformCvtToDependent((char *) opaque, name, NULL);
void *rc; void *rc = NULL;
FileHandle *retval;
BAIL_IF_MACRO(f == NULL, NULL, NULL); BAIL_IF_MACRO(f == NULL, NULL, NULL);
@ -290,51 +254,32 @@ static FileHandle *doOpen(void *opaque, const char *name,
} /* if */ } /* if */
} /* if */ } /* if */
retval = (FileHandle *) malloc(sizeof (FileHandle));
if (!retval)
{
free(f);
BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL);
} /* if */
rc = openFunc(f); rc = openFunc(f);
free(f); free(f);
if (!rc) return((fvoid *) rc);
{
free(retval);
return(NULL);
} /* if */
retval->opaque = (void *) rc;
retval->funcs = fileFuncs;
return(retval);
} /* doOpen */ } /* 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, return(doOpen(opaque, fnm, __PHYSFS_platformOpenRead, exist));
&__PHYSFS_FileFunctions_DIR));
} /* DIR_openRead */ } /* 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, return(doOpen(opaque, filename, __PHYSFS_platformOpenWrite, NULL));
&__PHYSFS_FileFunctions_DIRW));
} /* DIR_openWrite */ } /* 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, return(doOpen(opaque, filename, __PHYSFS_platformOpenAppend, NULL));
&__PHYSFS_FileFunctions_DIRW));
} /* DIR_openAppend */ } /* 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); char *f = __PHYSFS_platformCvtToDependent((char *) opaque, name, NULL);
int retval; int retval;
@ -346,7 +291,7 @@ static int DIR_remove(void *opaque, const char *name)
} /* DIR_remove */ } /* 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); char *f = __PHYSFS_platformCvtToDependent((char *) opaque, name, NULL);
int retval; int retval;
@ -358,7 +303,7 @@ static int DIR_mkdir(void *opaque, const char *name)
} /* DIR_mkdir */ } /* DIR_mkdir */
static void DIR_dirClose(void *opaque) static void DIR_dirClose(dvoid *opaque)
{ {
free(opaque); free(opaque);
} /* DIR_dirClose */ } /* DIR_dirClose */

130
archivers/grp.c
View File

@ -61,30 +61,30 @@ typedef struct
} GRPfileinfo; } GRPfileinfo;
static void GRP_dirClose(void *opaque); static PHYSFS_sint64 GRP_read(fvoid *opaque, void *buffer,
static PHYSFS_sint64 GRP_read(FileHandle *handle, void *buffer,
PHYSFS_uint32 objSize, PHYSFS_uint32 objCount); 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); PHYSFS_uint32 objSize, PHYSFS_uint32 objCount);
static int GRP_eof(FileHandle *handle); static int GRP_eof(fvoid *opaque);
static PHYSFS_sint64 GRP_tell(FileHandle *handle); static PHYSFS_sint64 GRP_tell(fvoid *opaque);
static int GRP_seek(FileHandle *handle, PHYSFS_uint64 offset); static int GRP_seek(fvoid *opaque, PHYSFS_uint64 offset);
static PHYSFS_sint64 GRP_fileLength(FileHandle *handle); static PHYSFS_sint64 GRP_fileLength(fvoid *opaque);
static int GRP_fileClose(FileHandle *handle); static int GRP_fileClose(fvoid *opaque);
static int GRP_isArchive(const char *filename, int forWriting); static int GRP_isArchive(const char *filename, int forWriting);
static void *GRP_openArchive(const char *name, 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, const char *dirname,
int omitSymLinks); int omitSymLinks);
static int GRP_exists(void *opaque, const char *name); static int GRP_exists(dvoid *opaque, const char *name);
static int GRP_isDirectory(void *opaque, const char *name, int *fileExists); static int GRP_isDirectory(dvoid *opaque, const char *name, int *fileExists);
static int GRP_isSymLink(void *opaque, const char *name, int *fileExists); static int GRP_isSymLink(dvoid *opaque, const char *name, int *fileExists);
static PHYSFS_sint64 GRP_getLastModTime(void *opaque, const char *n, int *e); static PHYSFS_sint64 GRP_getLastModTime(dvoid *opaque, const char *n, int *e);
static FileHandle *GRP_openRead(void *opaque, const char *name, int *exist); static fvoid *GRP_openRead(dvoid *opaque, const char *name, int *exist);
static FileHandle *GRP_openWrite(void *opaque, const char *name); static fvoid *GRP_openWrite(dvoid *opaque, const char *name);
static FileHandle *GRP_openAppend(void *opaque, const char *name); static fvoid *GRP_openAppend(dvoid *opaque, const char *name);
static int GRP_remove(void *opaque, const char *name); static int GRP_remove(dvoid *opaque, const char *name);
static int GRP_mkdir(void *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 = const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_GRP =
{ {
@ -95,19 +95,7 @@ const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_GRP =
}; };
static const FileFunctions __PHYSFS_FileFunctions_GRP = const PHYSFS_Archiver __PHYSFS_Archiver_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 =
{ {
&__PHYSFS_ArchiveInfo_GRP, &__PHYSFS_ArchiveInfo_GRP,
GRP_isArchive, /* isArchive() method */ GRP_isArchive, /* isArchive() method */
@ -122,12 +110,19 @@ const DirFunctions __PHYSFS_DirFunctions_GRP =
GRP_openAppend, /* openAppend() method */ GRP_openAppend, /* openAppend() method */
GRP_remove, /* remove() method */ GRP_remove, /* remove() method */
GRP_mkdir, /* mkdir() 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); GRPinfo *info = ((GRPinfo *) opaque);
free(info->filename); free(info->filename);
@ -136,10 +131,10 @@ static void GRP_dirClose(void *opaque)
} /* GRP_dirClose */ } /* 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) PHYSFS_uint32 objSize, PHYSFS_uint32 objCount)
{ {
GRPfileinfo *finfo = (GRPfileinfo *) (handle->opaque); GRPfileinfo *finfo = (GRPfileinfo *) opaque;
GRPentry *entry = finfo->entry; GRPentry *entry = finfo->entry;
PHYSFS_uint32 bytesLeft = entry->size - finfo->curPos; PHYSFS_uint32 bytesLeft = entry->size - finfo->curPos;
PHYSFS_uint32 objsLeft = (bytesLeft / objSize); PHYSFS_uint32 objsLeft = (bytesLeft / objSize);
@ -156,30 +151,30 @@ static PHYSFS_sint64 GRP_read(FileHandle *handle, void *buffer,
} /* GRP_read */ } /* 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) PHYSFS_uint32 objSize, PHYSFS_uint32 objCount)
{ {
BAIL_MACRO(ERR_NOT_SUPPORTED, -1); BAIL_MACRO(ERR_NOT_SUPPORTED, -1);
} /* GRP_write */ } /* 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; GRPentry *entry = finfo->entry;
return(finfo->curPos >= entry->size); return(finfo->curPos >= entry->size);
} /* GRP_eof */ } /* 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 */ } /* 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; GRPentry *entry = finfo->entry;
int rc; int rc;
@ -193,19 +188,18 @@ static int GRP_seek(FileHandle *handle, PHYSFS_uint64 offset)
} /* GRP_seek */ } /* 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); return((PHYSFS_sint64) finfo->entry->size);
} /* GRP_fileLength */ } /* 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); BAIL_IF_MACRO(!__PHYSFS_platformClose(finfo->handle), NULL, 0);
free(finfo); free(finfo);
free(handle);
return(1); return(1);
} /* GRP_fileClose */ } /* GRP_fileClose */
@ -365,11 +359,11 @@ GRP_openArchive_failed:
} /* GRP_openArchive */ } /* GRP_openArchive */
static LinkedStringList *GRP_enumerateFiles(void *opaque, static LinkedStringList *GRP_enumerateFiles(dvoid *opaque,
const char *dirname, const char *dirname,
int omitSymLinks) int omitSymLinks)
{ {
GRPinfo *info = ((GRPinfo *) opaque); GRPinfo *info = (GRPinfo *) opaque;
GRPentry *entry = info->entries; GRPentry *entry = info->entries;
LinkedStringList *retval = NULL, *p = NULL; LinkedStringList *retval = NULL, *p = NULL;
PHYSFS_uint32 max = info->entryCount; PHYSFS_uint32 max = info->entryCount;
@ -418,31 +412,31 @@ static GRPentry *grp_find_entry(GRPinfo *info, const char *name)
} /* grp_find_entry */ } /* 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 */ } /* 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); *fileExists = GRP_exists(opaque, name);
return(0); /* never directories in a groupfile. */ return(0); /* never directories in a groupfile. */
} /* GRP_isDirectory */ } /* 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); *fileExists = GRP_exists(opaque, name);
return(0); /* never symlinks in a groupfile. */ return(0); /* never symlinks in a groupfile. */
} /* GRP_isSymLink */ } /* GRP_isSymLink */
static PHYSFS_sint64 GRP_getLastModTime(void *opaque, static PHYSFS_sint64 GRP_getLastModTime(dvoid *opaque,
const char *name, const char *name,
int *fileExists) int *fileExists)
{ {
GRPinfo *info = ((GRPinfo *) opaque); GRPinfo *info = (GRPinfo *) opaque;
PHYSFS_sint64 retval = -1; PHYSFS_sint64 retval = -1;
*fileExists = (grp_find_entry(info, name) != NULL); *fileExists = (grp_find_entry(info, name) != NULL);
@ -453,10 +447,9 @@ static PHYSFS_sint64 GRP_getLastModTime(void *opaque,
} /* GRP_getLastModTime */ } /* 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); GRPinfo *info = (GRPinfo *) opaque;
FileHandle *retval;
GRPfileinfo *finfo; GRPfileinfo *finfo;
GRPentry *entry; GRPentry *entry;
@ -464,51 +457,42 @@ static FileHandle *GRP_openRead(void *opaque, const char *fnm, int *fileExists)
*fileExists = (entry != NULL); *fileExists = (entry != NULL);
BAIL_IF_MACRO(entry == NULL, NULL, 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)); finfo = (GRPfileinfo *) malloc(sizeof (GRPfileinfo));
if (finfo == NULL) BAIL_IF_MACRO(finfo == NULL, ERR_OUT_OF_MEMORY, NULL);
{
free(retval);
BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL);
} /* if */
finfo->handle = __PHYSFS_platformOpenRead(info->filename); finfo->handle = __PHYSFS_platformOpenRead(info->filename);
if ( (finfo->handle == NULL) || if ( (finfo->handle == NULL) ||
(!__PHYSFS_platformSeek(finfo->handle, entry->startPos)) ) (!__PHYSFS_platformSeek(finfo->handle, entry->startPos)) )
{ {
free(finfo); free(finfo);
free(retval);
return(NULL); return(NULL);
} /* if */ } /* if */
finfo->curPos = 0; finfo->curPos = 0;
finfo->entry = entry; finfo->entry = entry;
retval->opaque = (void *) finfo; return(finfo);
retval->funcs = &__PHYSFS_FileFunctions_GRP;
return(retval);
} /* GRP_openRead */ } /* 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); BAIL_MACRO(ERR_NOT_SUPPORTED, NULL);
} /* GRP_openWrite */ } /* 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); BAIL_MACRO(ERR_NOT_SUPPORTED, NULL);
} /* GRP_openAppend */ } /* 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); BAIL_MACRO(ERR_NOT_SUPPORTED, 0);
} /* GRP_remove */ } /* 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); BAIL_MACRO(ERR_NOT_SUPPORTED, 0);
} /* GRP_mkdir */ } /* GRP_mkdir */

122
archivers/hog.c
View File

@ -75,30 +75,30 @@ typedef struct
} HOGfileinfo; } HOGfileinfo;
static void HOG_dirClose(void *opaque); static PHYSFS_sint64 HOG_read(fvoid *opaque, void *buffer,
static PHYSFS_sint64 HOG_read(FileHandle *handle, void *buffer,
PHYSFS_uint32 objSize, PHYSFS_uint32 objCount); 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); PHYSFS_uint32 objSize, PHYSFS_uint32 objCount);
static int HOG_eof(FileHandle *handle); static int HOG_eof(fvoid *opaque);
static PHYSFS_sint64 HOG_tell(FileHandle *handle); static PHYSFS_sint64 HOG_tell(fvoid *opaque);
static int HOG_seek(FileHandle *handle, PHYSFS_uint64 offset); static int HOG_seek(fvoid *opaque, PHYSFS_uint64 offset);
static PHYSFS_sint64 HOG_fileLength(FileHandle *handle); static PHYSFS_sint64 HOG_fileLength(fvoid *opaque);
static int HOG_fileClose(FileHandle *handle); static int HOG_fileClose(fvoid *opaque);
static int HOG_isArchive(const char *filename, int forWriting); static int HOG_isArchive(const char *filename, int forWriting);
static void *HOG_openArchive(const char *name, 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, const char *dirname,
int omitSymLinks); int omitSymLinks);
static int HOG_exists(void *opaque, const char *name); static int HOG_exists(dvoid *opaque, const char *name);
static int HOG_isDirectory(void *opaque, const char *name, int *fileExists); static int HOG_isDirectory(dvoid *opaque, const char *name, int *fileExists);
static int HOG_isSymLink(void *opaque, const char *name, int *fileExists); static int HOG_isSymLink(dvoid *opaque, const char *name, int *fileExists);
static PHYSFS_sint64 HOG_getLastModTime(void *opaque, const char *n, int *e); static PHYSFS_sint64 HOG_getLastModTime(dvoid *opaque, const char *n, int *e);
static FileHandle *HOG_openRead(void *opaque, const char *name, int *exist); static fvoid *HOG_openRead(dvoid *opaque, const char *name, int *exist);
static FileHandle *HOG_openWrite(void *opaque, const char *name); static fvoid *HOG_openWrite(dvoid *opaque, const char *name);
static FileHandle *HOG_openAppend(void *opaque, const char *name); static fvoid *HOG_openAppend(dvoid *opaque, const char *name);
static int HOG_remove(void *opaque, const char *name); static int HOG_remove(dvoid *opaque, const char *name);
static int HOG_mkdir(void *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 = const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_HOG =
{ {
@ -109,19 +109,7 @@ const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_HOG =
}; };
static const FileFunctions __PHYSFS_FileFunctions_HOG = const PHYSFS_Archiver __PHYSFS_Archiver_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 =
{ {
&__PHYSFS_ArchiveInfo_HOG, &__PHYSFS_ArchiveInfo_HOG,
HOG_isArchive, /* isArchive() method */ HOG_isArchive, /* isArchive() method */
@ -136,12 +124,19 @@ const DirFunctions __PHYSFS_DirFunctions_HOG =
HOG_openAppend, /* openAppend() method */ HOG_openAppend, /* openAppend() method */
HOG_remove, /* remove() method */ HOG_remove, /* remove() method */
HOG_mkdir, /* mkdir() 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); HOGinfo *info = ((HOGinfo *) opaque);
free(info->filename); free(info->filename);
@ -150,10 +145,10 @@ static void HOG_dirClose(void *opaque)
} /* HOG_dirClose */ } /* 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) PHYSFS_uint32 objSize, PHYSFS_uint32 objCount)
{ {
HOGfileinfo *finfo = (HOGfileinfo *) (handle->opaque); HOGfileinfo *finfo = (HOGfileinfo *) opaque;
HOGentry *entry = finfo->entry; HOGentry *entry = finfo->entry;
PHYSFS_uint32 bytesLeft = entry->size - finfo->curPos; PHYSFS_uint32 bytesLeft = entry->size - finfo->curPos;
PHYSFS_uint32 objsLeft = (bytesLeft / objSize); PHYSFS_uint32 objsLeft = (bytesLeft / objSize);
@ -170,30 +165,30 @@ static PHYSFS_sint64 HOG_read(FileHandle *handle, void *buffer,
} /* HOG_read */ } /* 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) PHYSFS_uint32 objSize, PHYSFS_uint32 objCount)
{ {
BAIL_MACRO(ERR_NOT_SUPPORTED, -1); BAIL_MACRO(ERR_NOT_SUPPORTED, -1);
} /* HOG_write */ } /* 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; HOGentry *entry = finfo->entry;
return(finfo->curPos >= entry->size); return(finfo->curPos >= entry->size);
} /* HOG_eof */ } /* 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 */ } /* 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; HOGentry *entry = finfo->entry;
int rc; int rc;
@ -207,19 +202,18 @@ static int HOG_seek(FileHandle *handle, PHYSFS_uint64 offset)
} /* HOG_seek */ } /* 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); return((PHYSFS_sint64) finfo->entry->size);
} /* HOG_fileLength */ } /* 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); BAIL_IF_MACRO(!__PHYSFS_platformClose(finfo->handle), NULL, 0);
free(finfo); free(finfo);
free(handle);
return(1); return(1);
} /* HOG_fileClose */ } /* HOG_fileClose */
@ -404,7 +398,7 @@ HOG_openArchive_failed:
} /* HOG_openArchive */ } /* HOG_openArchive */
static LinkedStringList *HOG_enumerateFiles(void *opaque, static LinkedStringList *HOG_enumerateFiles(dvoid *opaque,
const char *dirname, const char *dirname,
int omitSymLinks) int omitSymLinks)
{ {
@ -457,27 +451,27 @@ static HOGentry *hog_find_entry(HOGinfo *info, const char *name)
} /* hog_find_entry */ } /* 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); return(hog_find_entry(((HOGinfo *) opaque), name) != NULL);
} /* HOG_exists */ } /* 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); *fileExists = HOG_exists(opaque, name);
return(0); /* never directories in a groupfile. */ return(0); /* never directories in a groupfile. */
} /* HOG_isDirectory */ } /* 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); *fileExists = HOG_exists(opaque, name);
return(0); /* never symlinks in a groupfile. */ return(0); /* never symlinks in a groupfile. */
} /* HOG_isSymLink */ } /* HOG_isSymLink */
static PHYSFS_sint64 HOG_getLastModTime(void *opaque, static PHYSFS_sint64 HOG_getLastModTime(dvoid *opaque,
const char *name, const char *name,
int *fileExists) int *fileExists)
{ {
@ -492,10 +486,9 @@ static PHYSFS_sint64 HOG_getLastModTime(void *opaque,
} /* HOG_getLastModTime */ } /* 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); HOGinfo *info = ((HOGinfo *) opaque);
FileHandle *retval;
HOGfileinfo *finfo; HOGfileinfo *finfo;
HOGentry *entry; HOGentry *entry;
@ -503,51 +496,42 @@ static FileHandle *HOG_openRead(void *opaque, const char *fnm, int *fileExists)
*fileExists = (entry != NULL); *fileExists = (entry != NULL);
BAIL_IF_MACRO(entry == NULL, NULL, 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)); finfo = (HOGfileinfo *) malloc(sizeof (HOGfileinfo));
if (finfo == NULL) BAIL_IF_MACRO(finfo == NULL, ERR_OUT_OF_MEMORY, NULL);
{
free(retval);
BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL);
} /* if */
finfo->handle = __PHYSFS_platformOpenRead(info->filename); finfo->handle = __PHYSFS_platformOpenRead(info->filename);
if ( (finfo->handle == NULL) || if ( (finfo->handle == NULL) ||
(!__PHYSFS_platformSeek(finfo->handle, entry->startPos)) ) (!__PHYSFS_platformSeek(finfo->handle, entry->startPos)) )
{ {
free(finfo); free(finfo);
free(retval);
return(NULL); return(NULL);
} /* if */ } /* if */
finfo->curPos = 0; finfo->curPos = 0;
finfo->entry = entry; finfo->entry = entry;
retval->opaque = (void *) finfo; return(finfo);
retval->funcs = &__PHYSFS_FileFunctions_HOG;
return(retval);
} /* HOG_openRead */ } /* 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); BAIL_MACRO(ERR_NOT_SUPPORTED, NULL);
} /* HOG_openWrite */ } /* 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); BAIL_MACRO(ERR_NOT_SUPPORTED, NULL);
} /* HOG_openAppend */ } /* 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); BAIL_MACRO(ERR_NOT_SUPPORTED, 0);
} /* HOG_remove */ } /* 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); BAIL_MACRO(ERR_NOT_SUPPORTED, 0);
} /* HOG_mkdir */ } /* HOG_mkdir */

128
archivers/mix.c
View File

@ -80,30 +80,30 @@ typedef struct
void *handle; /* filehandle */ void *handle; /* filehandle */
} MIXfileinfo; } MIXfileinfo;
static void MIX_dirClose(void *opaque); static PHYSFS_sint64 MIX_read(fvoid *opaque, void *buffer,
static PHYSFS_sint64 MIX_read(FileHandle *handle, void *buffer,
PHYSFS_uint32 objSize, PHYSFS_uint32 objCount); 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); PHYSFS_uint32 objSize, PHYSFS_uint32 objCount);
static int MIX_eof(FileHandle *handle); static int MIX_eof(fvoid *opaque);
static PHYSFS_sint64 MIX_tell(FileHandle *handle); static PHYSFS_sint64 MIX_tell(fvoid *opaque);
static int MIX_seek(FileHandle *handle, PHYSFS_uint64 offset); static int MIX_seek(fvoid *opaque, PHYSFS_uint64 offset);
static PHYSFS_sint64 MIX_fileLength(FileHandle *handle); static PHYSFS_sint64 MIX_fileLength(fvoid *opaque);
static int MIX_fileClose(FileHandle *handle); static int MIX_fileClose(fvoid *opaque);
static int MIX_isArchive(const char *filename, int forWriting); static int MIX_isArchive(const char *filename, int forWriting);
static void *MIX_openArchive(const char *name, 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, const char *dirname,
int omitSymLinks); int omitSymLinks);
static int MIX_exists(void *opaque, const char *name); static int MIX_exists(dvoid *opaque, const char *name);
static int MIX_isDirectory(void *opaque, const char *name, int *fileExists); static int MIX_isDirectory(dvoid *opaque, const char *name, int *fileExists);
static int MIX_isSymLink(void *opaque, const char *name, int *fileExists); static int MIX_isSymLink(dvoid *opaque, const char *name, int *fileExists);
static PHYSFS_sint64 MIX_getLastModTime(void *opaque, const char *n, int *e); static PHYSFS_sint64 MIX_getLastModTime(dvoid *opaque, const char *n, int *e);
static FileHandle *MIX_openRead(void *opaque, const char *name, int *exist); static fvoid *MIX_openRead(dvoid *opaque, const char *name, int *exist);
static FileHandle *MIX_openWrite(void *opaque, const char *name); static fvoid *MIX_openWrite(dvoid *opaque, const char *name);
static FileHandle *MIX_openAppend(void *opaque, const char *name); static fvoid *MIX_openAppend(dvoid *opaque, const char *name);
static int MIX_remove(void *opaque, const char *name); static int MIX_remove(dvoid *opaque, const char *name);
static int MIX_mkdir(void *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 = const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_MIX =
{ {
@ -114,19 +114,7 @@ const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_MIX =
}; };
static const FileFunctions __PHYSFS_FileFunctions_MIX = const PHYSFS_Archiver __PHYSFS_Archiver_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 =
{ {
&__PHYSFS_ArchiveInfo_MIX, &__PHYSFS_ArchiveInfo_MIX,
MIX_isArchive, /* isArchive() method */ MIX_isArchive, /* isArchive() method */
@ -141,9 +129,17 @@ const DirFunctions __PHYSFS_DirFunctions_MIX =
MIX_openAppend, /* openAppend() method */ MIX_openAppend, /* openAppend() method */
MIX_remove, /* remove() method */ MIX_remove, /* remove() method */
MIX_mkdir, /* mkdir() 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) static PHYSFS_uint32 MIX_hash(const char *name)
{ {
PHYSFS_uint32 id = 0; PHYSFS_uint32 id = 0;
@ -176,7 +172,7 @@ static PHYSFS_uint32 MIX_hash(const char *name)
} /* MIX_hash */ } /* MIX_hash */
static void MIX_dirClose(void *opaque) static void MIX_dirClose(dvoid *opaque)
{ {
MIXinfo *info = ((MIXinfo *) opaque); MIXinfo *info = ((MIXinfo *) opaque);
free(info->entry); free(info->entry);
@ -184,10 +180,10 @@ static void MIX_dirClose(void *opaque)
} /* MIX_dirClose */ } /* 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) PHYSFS_uint32 objSize, PHYSFS_uint32 objCount)
{ {
MIXfileinfo *finfo = (MIXfileinfo*)handle->opaque; MIXfileinfo *finfo = (MIXfileinfo *) opaque;
MIXentry *entry = finfo->entry; MIXentry *entry = finfo->entry;
PHYSFS_uint32 read; PHYSFS_uint32 read;
@ -208,29 +204,29 @@ static PHYSFS_sint64 MIX_read(FileHandle *handle, void *buffer,
} /* MIX_read */ } /* 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) PHYSFS_uint32 objSize, PHYSFS_uint32 objCount)
{ {
BAIL_MACRO(ERR_NOT_SUPPORTED, -1); BAIL_MACRO(ERR_NOT_SUPPORTED, -1);
} /* MIX_write */ } /* 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); return(fifo->cur_pos >= fifo->size);
} /* MIX_eof */ } /* 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 */ } /* 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 < 0, ERR_INVALID_ARGUMENT, 0);
BAIL_IF_MACRO(offset >= h->size, ERR_PAST_EOF, 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 */ } /* 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 */ } /* 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); __PHYSFS_platformClose(finfo->handle);
free(finfo); free(finfo);
free(handle);
return(1); return(1);
} /* MIX_fileClose */ } /* MIX_fileClose */
static int MIX_isArchive(const char *filename, int forWriting) static int MIX_isArchive(const char *filename, int forWriting)
{ {
/* TODO: /* !!! FIXME:
write a simple detection routine for MIX files. write a simple detection routine for MIX files.
Unfortunaly MIX files have no ID in the header. Unfortunaly MIX files have no ID in the header.
*/ */
@ -359,7 +354,7 @@ MIX_openArchive_failed:
} /* MIX_openArchive */ } /* MIX_openArchive */
static LinkedStringList *MIX_enumerateFiles(void *opaque, static LinkedStringList *MIX_enumerateFiles(dvoid *opaque,
const char *dirname, const char *dirname,
int omitSymLinks) int omitSymLinks)
{ {
@ -399,27 +394,27 @@ static MIXentry *MIX_find_entry(MIXinfo *info, const char *name)
} /* MIX_find_entry */ } /* 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); return(MIX_find_entry(((MIXinfo *) opaque), name) != NULL);
} /* MIX_exists */ } /* 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); *fileExists = MIX_exists(opaque, name);
return(0); /* never directories in a MIX */ return(0); /* never directories in a MIX */
} /* MIX_isDirectory */ } /* 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); *fileExists = MIX_exists(opaque, name);
return(0); /* never symlinks in a MIX. */ return(0); /* never symlinks in a MIX. */
} /* MIX_isSymLink */ } /* MIX_isSymLink */
static PHYSFS_sint64 MIX_getLastModTime(void *opaque, static PHYSFS_sint64 MIX_getLastModTime(dvoid *opaque,
const char *name, const char *name,
int *fileExists) int *fileExists)
{ {
@ -427,9 +422,8 @@ static PHYSFS_sint64 MIX_getLastModTime(void *opaque,
} /* MIX_getLastModTime */ } /* 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); MIXinfo *info = ((MIXinfo*) opaque);
MIXfileinfo *finfo; MIXfileinfo *finfo;
MIXentry *entry; MIXentry *entry;
@ -441,56 +435,44 @@ static FileHandle *MIX_openRead(void *opaque, const char *fnm, int *fileExists)
/* allocate a MIX handle */ /* allocate a MIX handle */
finfo = (MIXfileinfo *) malloc(sizeof (MIXfileinfo)); finfo = (MIXfileinfo *) malloc(sizeof (MIXfileinfo));
BAIL_IF_MACRO(finfo == NULL, ERR_OUT_OF_MEMORY, NULL); 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 */ /* open the archive */
finfo->handle = __PHYSFS_platformOpenRead(info->filename); finfo->handle = __PHYSFS_platformOpenRead(info->filename);
if(!finfo->handle) if(!finfo->handle)
{ {
free(finfo); free(finfo);
free(retval);
return(NULL); return(NULL);
}; } /* if */
/* setup structures */ /* setup structures */
finfo->cur_pos = 0; finfo->cur_pos = 0;
finfo->info = info; finfo->info = info;
finfo->entry = entry; finfo->entry = entry;
finfo->size = entry->end_offset - entry->start_offset; finfo->size = entry->end_offset - entry->start_offset;
retval->opaque = (void *) finfo;
retval->funcs = &__PHYSFS_FileFunctions_MIX;
return(retval); return(finfo);
} /* MIX_openRead */ } /* 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); BAIL_MACRO(ERR_NOT_SUPPORTED, NULL);
} /* MIX_openWrite */ } /* 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); BAIL_MACRO(ERR_NOT_SUPPORTED, NULL);
} /* MIX_openAppend */ } /* 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); BAIL_MACRO(ERR_NOT_SUPPORTED, 0);
} /* MIX_remove */ } /* 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); BAIL_MACRO(ERR_NOT_SUPPORTED, 0);
} /* MIX_mkdir */ } /* MIX_mkdir */

122
archivers/mvl.c
View File

@ -64,30 +64,30 @@ typedef struct
} MVLfileinfo; } MVLfileinfo;
static void MVL_dirClose(void *opaque); static PHYSFS_sint64 MVL_read(fvoid *opaque, void *buffer,
static PHYSFS_sint64 MVL_read(FileHandle *handle, void *buffer,
PHYSFS_uint32 objSize, PHYSFS_uint32 objCount); 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); PHYSFS_uint32 objSize, PHYSFS_uint32 objCount);
static int MVL_eof(FileHandle *handle); static int MVL_eof(fvoid *opaque);
static PHYSFS_sint64 MVL_tell(FileHandle *handle); static PHYSFS_sint64 MVL_tell(fvoid *opaque);
static int MVL_seek(FileHandle *handle, PHYSFS_uint64 offset); static int MVL_seek(fvoid *opaque, PHYSFS_uint64 offset);
static PHYSFS_sint64 MVL_fileLength(FileHandle *handle); static PHYSFS_sint64 MVL_fileLength(fvoid *opaque);
static int MVL_fileClose(FileHandle *handle); static int MVL_fileClose(fvoid *opaque);
static int MVL_isArchive(const char *filename, int forWriting); static int MVL_isArchive(const char *filename, int forWriting);
static void *MVL_openArchive(const char *name, 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, const char *dirname,
int omitSymLinks); int omitSymLinks);
static int MVL_exists(void *opaque, const char *name); static int MVL_exists(dvoid *opaque, const char *name);
static int MVL_isDirectory(void *opaque, const char *name, int *fileExists); static int MVL_isDirectory(dvoid *opaque, const char *name, int *fileExists);
static int MVL_isSymLink(void *opaque, const char *name, int *fileExists); static int MVL_isSymLink(dvoid *opaque, const char *name, int *fileExists);
static PHYSFS_sint64 MVL_getLastModTime(void *opaque, const char *n, int *e); static PHYSFS_sint64 MVL_getLastModTime(dvoid *opaque, const char *n, int *e);
static FileHandle *MVL_openRead(void *opaque, const char *name, int *exist); static fvoid *MVL_openRead(dvoid *opaque, const char *name, int *exist);
static FileHandle *MVL_openWrite(void *opaque, const char *name); static fvoid *MVL_openWrite(dvoid *opaque, const char *name);
static FileHandle *MVL_openAppend(void *opaque, const char *name); static fvoid *MVL_openAppend(dvoid *opaque, const char *name);
static int MVL_remove(void *opaque, const char *name); static int MVL_remove(dvoid *opaque, const char *name);
static int MVL_mkdir(void *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 = const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_MVL =
{ {
@ -98,19 +98,7 @@ const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_MVL =
}; };
static const FileFunctions __PHYSFS_FileFunctions_MVL = const PHYSFS_Archiver __PHYSFS_Archiver_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 =
{ {
&__PHYSFS_ArchiveInfo_MVL, &__PHYSFS_ArchiveInfo_MVL,
MVL_isArchive, /* isArchive() method */ MVL_isArchive, /* isArchive() method */
@ -125,12 +113,19 @@ const DirFunctions __PHYSFS_DirFunctions_MVL =
MVL_openAppend, /* openAppend() method */ MVL_openAppend, /* openAppend() method */
MVL_remove, /* remove() method */ MVL_remove, /* remove() method */
MVL_mkdir, /* mkdir() 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); MVLinfo *info = ((MVLinfo *) opaque);
free(info->filename); free(info->filename);
@ -139,10 +134,10 @@ static void MVL_dirClose(void *opaque)
} /* MVL_dirClose */ } /* 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) PHYSFS_uint32 objSize, PHYSFS_uint32 objCount)
{ {
MVLfileinfo *finfo = (MVLfileinfo *) (handle->opaque); MVLfileinfo *finfo = (MVLfileinfo *) opaque;
MVLentry *entry = finfo->entry; MVLentry *entry = finfo->entry;
PHYSFS_uint32 bytesLeft = entry->size - finfo->curPos; PHYSFS_uint32 bytesLeft = entry->size - finfo->curPos;
PHYSFS_uint32 objsLeft = (bytesLeft / objSize); PHYSFS_uint32 objsLeft = (bytesLeft / objSize);
@ -159,30 +154,30 @@ static PHYSFS_sint64 MVL_read(FileHandle *handle, void *buffer,
} /* MVL_read */ } /* 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) PHYSFS_uint32 objSize, PHYSFS_uint32 objCount)
{ {
BAIL_MACRO(ERR_NOT_SUPPORTED, -1); BAIL_MACRO(ERR_NOT_SUPPORTED, -1);
} /* MVL_write */ } /* 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; MVLentry *entry = finfo->entry;
return(finfo->curPos >= entry->size); return(finfo->curPos >= entry->size);
} /* MVL_eof */ } /* 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 */ } /* 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; MVLentry *entry = finfo->entry;
int rc; int rc;
@ -196,19 +191,18 @@ static int MVL_seek(FileHandle *handle, PHYSFS_uint64 offset)
} /* MVL_seek */ } /* 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); return((PHYSFS_sint64) finfo->entry->size);
} /* MVL_fileLength */ } /* 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); BAIL_IF_MACRO(!__PHYSFS_platformClose(finfo->handle), NULL, 0);
free(finfo); free(finfo);
free(handle);
return(1); return(1);
} /* MVL_fileClose */ } /* MVL_fileClose */
@ -362,7 +356,7 @@ MVL_openArchive_failed:
} /* MVL_openArchive */ } /* MVL_openArchive */
static LinkedStringList *MVL_enumerateFiles(void *opaque, static LinkedStringList *MVL_enumerateFiles(dvoid *opaque,
const char *dirname, const char *dirname,
int omitSymLinks) int omitSymLinks)
{ {
@ -415,27 +409,27 @@ static MVLentry *mvl_find_entry(MVLinfo *info, const char *name)
} /* mvl_find_entry */ } /* 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); return(mvl_find_entry(((MVLinfo *) opaque), name) != NULL);
} /* MVL_exists */ } /* 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); *fileExists = MVL_exists(opaque, name);
return(0); /* never directories in a groupfile. */ return(0); /* never directories in a groupfile. */
} /* MVL_isDirectory */ } /* 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); *fileExists = MVL_exists(opaque, name);
return(0); /* never symlinks in a groupfile. */ return(0); /* never symlinks in a groupfile. */
} /* MVL_isSymLink */ } /* MVL_isSymLink */
static PHYSFS_sint64 MVL_getLastModTime(void *opaque, static PHYSFS_sint64 MVL_getLastModTime(dvoid *opaque,
const char *name, const char *name,
int *fileExists) int *fileExists)
{ {
@ -450,10 +444,9 @@ static PHYSFS_sint64 MVL_getLastModTime(void *opaque,
} /* MVL_getLastModTime */ } /* 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); MVLinfo *info = ((MVLinfo *) opaque);
FileHandle *retval;
MVLfileinfo *finfo; MVLfileinfo *finfo;
MVLentry *entry; MVLentry *entry;
@ -461,51 +454,42 @@ static FileHandle *MVL_openRead(void *opaque, const char *fnm, int *fileExists)
*fileExists = (entry != NULL); *fileExists = (entry != NULL);
BAIL_IF_MACRO(entry == NULL, NULL, 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)); finfo = (MVLfileinfo *) malloc(sizeof (MVLfileinfo));
if (finfo == NULL) BAIL_IF_MACRO(finfo == NULL, ERR_OUT_OF_MEMORY, NULL);
{
free(retval);
BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL);
} /* if */
finfo->handle = __PHYSFS_platformOpenRead(info->filename); finfo->handle = __PHYSFS_platformOpenRead(info->filename);
if ( (finfo->handle == NULL) || if ( (finfo->handle == NULL) ||
(!__PHYSFS_platformSeek(finfo->handle, entry->startPos)) ) (!__PHYSFS_platformSeek(finfo->handle, entry->startPos)) )
{ {
free(finfo); free(finfo);
free(retval);
return(NULL); return(NULL);
} /* if */ } /* if */
finfo->curPos = 0; finfo->curPos = 0;
finfo->entry = entry; finfo->entry = entry;
retval->opaque = (void *) finfo; return(finfo);
retval->funcs = &__PHYSFS_FileFunctions_MVL;
return(retval);
} /* MVL_openRead */ } /* 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); BAIL_MACRO(ERR_NOT_SUPPORTED, NULL);
} /* MVL_openWrite */ } /* 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); BAIL_MACRO(ERR_NOT_SUPPORTED, NULL);
} /* MVL_openAppend */ } /* 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); BAIL_MACRO(ERR_NOT_SUPPORTED, 0);
} /* MVL_remove */ } /* 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); BAIL_MACRO(ERR_NOT_SUPPORTED, 0);
} /* MVL_mkdir */ } /* MVL_mkdir */

122
archivers/qpak.c
View File

@ -78,30 +78,30 @@ typedef struct
#define QPAK_SIGNATURE 0x4b434150 /* "PACK" in ASCII. */ #define QPAK_SIGNATURE 0x4b434150 /* "PACK" in ASCII. */
static void QPAK_dirClose(void *opaque); static PHYSFS_sint64 QPAK_read(fvoid *opaque, void *buffer,
static PHYSFS_sint64 QPAK_read(FileHandle *handle, void *buffer,
PHYSFS_uint32 objSize, PHYSFS_uint32 objCount); 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); PHYSFS_uint32 objSize, PHYSFS_uint32 objCount);
static int QPAK_eof(FileHandle *handle); static int QPAK_eof(fvoid *opaque);
static PHYSFS_sint64 QPAK_tell(FileHandle *handle); static PHYSFS_sint64 QPAK_tell(fvoid *opaque);
static int QPAK_seek(FileHandle *handle, PHYSFS_uint64 offset); static int QPAK_seek(fvoid *opaque, PHYSFS_uint64 offset);
static PHYSFS_sint64 QPAK_fileLength(FileHandle *handle); static PHYSFS_sint64 QPAK_fileLength(fvoid *opaque);
static int QPAK_fileClose(FileHandle *handle); static int QPAK_fileClose(fvoid *opaque);
static int QPAK_isArchive(const char *filename, int forWriting); static int QPAK_isArchive(const char *filename, int forWriting);
static void *QPAK_openArchive(const char *name, 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, const char *dirname,
int omitSymLinks); int omitSymLinks);
static int QPAK_exists(void *opaque, const char *name); static int QPAK_exists(dvoid *opaque, const char *name);
static int QPAK_isDirectory(void *opaque, const char *name, int *fileExists); static int QPAK_isDirectory(dvoid *opaque, const char *name, int *fileExists);
static int QPAK_isSymLink(void *opaque, const char *name, int *fileExists); static int QPAK_isSymLink(dvoid *opaque, const char *name, int *fileExists);
static PHYSFS_sint64 QPAK_getLastModTime(void *opaque, const char *n, int *e); static PHYSFS_sint64 QPAK_getLastModTime(dvoid *opaque, const char *n, int *e);
static FileHandle *QPAK_openRead(void *opaque, const char *name, int *exist); static fvoid *QPAK_openRead(dvoid *opaque, const char *name, int *exist);
static FileHandle *QPAK_openWrite(void *opaque, const char *name); static fvoid *QPAK_openWrite(dvoid *opaque, const char *name);
static FileHandle *QPAK_openAppend(void *opaque, const char *name); static fvoid *QPAK_openAppend(dvoid *opaque, const char *name);
static int QPAK_remove(void *opaque, const char *name); static int QPAK_remove(dvoid *opaque, const char *name);
static int QPAK_mkdir(void *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 = const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_QPAK =
{ {
@ -112,19 +112,7 @@ const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_QPAK =
}; };
static const FileFunctions __PHYSFS_FileFunctions_QPAK = const PHYSFS_Archiver __PHYSFS_Archiver_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 =
{ {
&__PHYSFS_ArchiveInfo_QPAK, &__PHYSFS_ArchiveInfo_QPAK,
QPAK_isArchive, /* isArchive() method */ QPAK_isArchive, /* isArchive() method */
@ -139,12 +127,19 @@ const DirFunctions __PHYSFS_DirFunctions_QPAK =
QPAK_openAppend, /* openAppend() method */ QPAK_openAppend, /* openAppend() method */
QPAK_remove, /* remove() method */ QPAK_remove, /* remove() method */
QPAK_mkdir, /* mkdir() 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); QPAKinfo *info = ((QPAKinfo *) opaque);
free(info->filename); free(info->filename);
@ -153,10 +148,10 @@ static void QPAK_dirClose(void *opaque)
} /* QPAK_dirClose */ } /* 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) PHYSFS_uint32 objSize, PHYSFS_uint32 objCount)
{ {
QPAKfileinfo *finfo = (QPAKfileinfo *) (handle->opaque); QPAKfileinfo *finfo = (QPAKfileinfo *) opaque;
QPAKentry *entry = finfo->entry; QPAKentry *entry = finfo->entry;
PHYSFS_uint32 bytesLeft = entry->size - finfo->curPos; PHYSFS_uint32 bytesLeft = entry->size - finfo->curPos;
PHYSFS_uint32 objsLeft = (bytesLeft / objSize); PHYSFS_uint32 objsLeft = (bytesLeft / objSize);
@ -173,30 +168,30 @@ static PHYSFS_sint64 QPAK_read(FileHandle *handle, void *buffer,
} /* QPAK_read */ } /* 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) PHYSFS_uint32 objSize, PHYSFS_uint32 objCount)
{ {
BAIL_MACRO(ERR_NOT_SUPPORTED, -1); BAIL_MACRO(ERR_NOT_SUPPORTED, -1);
} /* QPAK_write */ } /* 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; QPAKentry *entry = finfo->entry;
return(finfo->curPos >= entry->size); return(finfo->curPos >= entry->size);
} /* QPAK_eof */ } /* 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 */ } /* 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; QPAKentry *entry = finfo->entry;
int rc; int rc;
@ -210,19 +205,18 @@ static int QPAK_seek(FileHandle *handle, PHYSFS_uint64 offset)
} /* QPAK_seek */ } /* 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); return((PHYSFS_sint64) finfo->entry->size);
} /* QPAK_fileLength */ } /* 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); BAIL_IF_MACRO(!__PHYSFS_platformClose(finfo->handle), NULL, 0);
free(finfo); free(finfo);
free(handle);
return(1); return(1);
} /* QPAK_fileClose */ } /* QPAK_fileClose */
@ -449,7 +443,7 @@ static PHYSFS_sint32 qpak_find_start_of_dir(QPAKinfo *info, const char *path,
} /* qpak_find_start_of_dir */ } /* qpak_find_start_of_dir */
static LinkedStringList *QPAK_enumerateFiles(void *opaque, static LinkedStringList *QPAK_enumerateFiles(dvoid *opaque,
const char *dirname, const char *dirname,
int omitSymLinks) int omitSymLinks)
{ {
@ -544,7 +538,7 @@ static QPAKentry *qpak_find_entry(QPAKinfo *info, const char *path, int *isDir)
} /* qpak_find_entry */ } /* qpak_find_entry */
static int QPAK_exists(void *opaque, const char *name) static int QPAK_exists(dvoid *opaque, const char *name)
{ {
int isDir; int isDir;
QPAKinfo *info = (QPAKinfo *) opaque; QPAKinfo *info = (QPAKinfo *) opaque;
@ -553,7 +547,7 @@ static int QPAK_exists(void *opaque, const char *name)
} /* QPAK_exists */ } /* 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; QPAKinfo *info = (QPAKinfo *) opaque;
int isDir; int isDir;
@ -567,14 +561,14 @@ static int QPAK_isDirectory(void *opaque, const char *name, int *fileExists)
} /* QPAK_isDirectory */ } /* 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); *fileExists = QPAK_exists(opaque, name);
return(0); /* never symlinks in a quake pak. */ return(0); /* never symlinks in a quake pak. */
} /* QPAK_isSymLink */ } /* QPAK_isSymLink */
static PHYSFS_sint64 QPAK_getLastModTime(void *opaque, static PHYSFS_sint64 QPAK_getLastModTime(dvoid *opaque,
const char *name, const char *name,
int *fileExists) int *fileExists)
{ {
@ -591,10 +585,9 @@ static PHYSFS_sint64 QPAK_getLastModTime(void *opaque,
} /* QPAK_getLastModTime */ } /* 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); QPAKinfo *info = ((QPAKinfo *) opaque);
FileHandle *retval;
QPAKfileinfo *finfo; QPAKfileinfo *finfo;
QPAKentry *entry; QPAKentry *entry;
int isDir; 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(isDir, ERR_NOT_A_FILE, NULL);
BAIL_IF_MACRO(entry == NULL, ERR_NO_SUCH_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)); finfo = (QPAKfileinfo *) malloc(sizeof (QPAKfileinfo));
if (finfo == NULL) BAIL_IF_MACRO(finfo == NULL, ERR_OUT_OF_MEMORY, NULL);
{
free(retval);
BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL);
} /* if */
finfo->handle = __PHYSFS_platformOpenRead(info->filename); finfo->handle = __PHYSFS_platformOpenRead(info->filename);
if ( (finfo->handle == NULL) || if ( (finfo->handle == NULL) ||
(!__PHYSFS_platformSeek(finfo->handle, entry->startPos)) ) (!__PHYSFS_platformSeek(finfo->handle, entry->startPos)) )
{ {
free(finfo); free(finfo);
free(retval);
return(NULL); return(NULL);
} /* if */ } /* if */
finfo->curPos = 0; finfo->curPos = 0;
finfo->entry = entry; finfo->entry = entry;
retval->opaque = (void *) finfo; return(finfo);
retval->funcs = &__PHYSFS_FileFunctions_QPAK;
return(retval);
} /* QPAK_openRead */ } /* 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); BAIL_MACRO(ERR_NOT_SUPPORTED, NULL);
} /* QPAK_openWrite */ } /* 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); BAIL_MACRO(ERR_NOT_SUPPORTED, NULL);
} /* QPAK_openAppend */ } /* 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); BAIL_MACRO(ERR_NOT_SUPPORTED, 0);
} /* QPAK_remove */ } /* 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); BAIL_MACRO(ERR_NOT_SUPPORTED, 0);
} /* QPAK_mkdir */ } /* QPAK_mkdir */

122
archivers/wad.c
View File

@ -80,30 +80,30 @@ typedef struct
} WADfileinfo; } WADfileinfo;
static void WAD_dirClose(void *opaque); static PHYSFS_sint64 WAD_read(fvoid *opaque, void *buffer,
static PHYSFS_sint64 WAD_read(FileHandle *handle, void *buffer,
PHYSFS_uint32 objSize, PHYSFS_uint32 objCount); 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); PHYSFS_uint32 objSize, PHYSFS_uint32 objCount);
static int WAD_eof(FileHandle *handle); static int WAD_eof(fvoid *opaque);
static PHYSFS_sint64 WAD_tell(FileHandle *handle); static PHYSFS_sint64 WAD_tell(fvoid *opaque);
static int WAD_seek(FileHandle *handle, PHYSFS_uint64 offset); static int WAD_seek(fvoid *opaque, PHYSFS_uint64 offset);
static PHYSFS_sint64 WAD_fileLength(FileHandle *handle); static PHYSFS_sint64 WAD_fileLength(fvoid *opaque);
static int WAD_fileClose(FileHandle *handle); static int WAD_fileClose(fvoid *opaque);
static int WAD_isArchive(const char *filename, int forWriting); static int WAD_isArchive(const char *filename, int forWriting);
static void *WAD_openArchive(const char *name, 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, const char *dirname,
int omitSymLinks); int omitSymLinks);
static int WAD_exists(void *opaque, const char *name); static int WAD_exists(dvoid *opaque, const char *name);
static int WAD_isDirectory(void *opaque, const char *name, int *fileExists); static int WAD_isDirectory(dvoid *opaque, const char *name, int *fileExists);
static int WAD_isSymLink(void *opaque, const char *name, int *fileExists); static int WAD_isSymLink(dvoid *opaque, const char *name, int *fileExists);
static PHYSFS_sint64 WAD_getLastModTime(void *opaque, const char *n, int *e); static PHYSFS_sint64 WAD_getLastModTime(dvoid *opaque, const char *n, int *e);
static FileHandle *WAD_openRead(void *opaque, const char *name, int *exist); static fvoid *WAD_openRead(dvoid *opaque, const char *name, int *exist);
static FileHandle *WAD_openWrite(void *opaque, const char *name); static fvoid *WAD_openWrite(dvoid *opaque, const char *name);
static FileHandle *WAD_openAppend(void *opaque, const char *name); static fvoid *WAD_openAppend(dvoid *opaque, const char *name);
static int WAD_remove(void *opaque, const char *name); static int WAD_remove(dvoid *opaque, const char *name);
static int WAD_mkdir(void *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 = const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_WAD =
{ {
@ -114,19 +114,7 @@ const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_WAD =
}; };
static const FileFunctions __PHYSFS_FileFunctions_WAD = const PHYSFS_Archiver __PHYSFS_Archiver_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 =
{ {
&__PHYSFS_ArchiveInfo_WAD, &__PHYSFS_ArchiveInfo_WAD,
WAD_isArchive, /* isArchive() method */ WAD_isArchive, /* isArchive() method */
@ -141,12 +129,19 @@ const DirFunctions __PHYSFS_DirFunctions_WAD =
WAD_openAppend, /* openAppend() method */ WAD_openAppend, /* openAppend() method */
WAD_remove, /* remove() method */ WAD_remove, /* remove() method */
WAD_mkdir, /* mkdir() 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); WADinfo *info = ((WADinfo *) opaque);
free(info->filename); free(info->filename);
@ -155,10 +150,10 @@ static void WAD_dirClose(void *opaque)
} /* WAD_dirClose */ } /* 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) PHYSFS_uint32 objSize, PHYSFS_uint32 objCount)
{ {
WADfileinfo *finfo = (WADfileinfo *) (handle->opaque); WADfileinfo *finfo = (WADfileinfo *) opaque;
WADentry *entry = finfo->entry; WADentry *entry = finfo->entry;
PHYSFS_uint32 bytesLeft = entry->size - finfo->curPos; PHYSFS_uint32 bytesLeft = entry->size - finfo->curPos;
PHYSFS_uint32 objsLeft = (bytesLeft / objSize); PHYSFS_uint32 objsLeft = (bytesLeft / objSize);
@ -175,30 +170,30 @@ static PHYSFS_sint64 WAD_read(FileHandle *handle, void *buffer,
} /* WAD_read */ } /* 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) PHYSFS_uint32 objSize, PHYSFS_uint32 objCount)
{ {
BAIL_MACRO(ERR_NOT_SUPPORTED, -1); BAIL_MACRO(ERR_NOT_SUPPORTED, -1);
} /* WAD_write */ } /* 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; WADentry *entry = finfo->entry;
return(finfo->curPos >= entry->size); return(finfo->curPos >= entry->size);
} /* WAD_eof */ } /* 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 */ } /* 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; WADentry *entry = finfo->entry;
int rc; int rc;
@ -212,19 +207,18 @@ static int WAD_seek(FileHandle *handle, PHYSFS_uint64 offset)
} /* WAD_seek */ } /* 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); return((PHYSFS_sint64) finfo->entry->size);
} /* WAD_fileLength */ } /* 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); BAIL_IF_MACRO(!__PHYSFS_platformClose(finfo->handle), NULL, 0);
free(finfo); free(finfo);
free(handle);
return(1); return(1);
} /* WAD_fileClose */ } /* WAD_fileClose */
@ -392,7 +386,7 @@ WAD_openArchive_failed:
} /* WAD_openArchive */ } /* WAD_openArchive */
static LinkedStringList *WAD_enumerateFiles(void *opaque, static LinkedStringList *WAD_enumerateFiles(dvoid *opaque,
const char *dirname, const char *dirname,
int omitSymLinks) int omitSymLinks)
{ {
@ -458,13 +452,13 @@ static WADentry *wad_find_entry(WADinfo *info, const char *name)
} /* wad_find_entry */ } /* 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); return(wad_find_entry(((WADinfo *) opaque), name) != NULL);
} /* WAD_exists */ } /* 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); WADentry *entry = wad_find_entry(((WADinfo *) opaque), name);
if (entry != NULL) if (entry != NULL)
@ -494,14 +488,14 @@ static int WAD_isDirectory(void *opaque, const char *name, int *fileExists)
} /* WAD_isDirectory */ } /* 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); *fileExists = WAD_exists(opaque, name);
return(0); /* never symlinks in a wad. */ return(0); /* never symlinks in a wad. */
} /* WAD_isSymLink */ } /* WAD_isSymLink */
static PHYSFS_sint64 WAD_getLastModTime(void *opaque, static PHYSFS_sint64 WAD_getLastModTime(dvoid *opaque,
const char *name, const char *name,
int *fileExists) int *fileExists)
{ {
@ -516,10 +510,9 @@ static PHYSFS_sint64 WAD_getLastModTime(void *opaque,
} /* WAD_getLastModTime */ } /* 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); WADinfo *info = ((WADinfo *) opaque);
FileHandle *retval;
WADfileinfo *finfo; WADfileinfo *finfo;
WADentry *entry; WADentry *entry;
@ -527,51 +520,42 @@ static FileHandle *WAD_openRead(void *opaque, const char *fnm, int *fileExists)
*fileExists = (entry != NULL); *fileExists = (entry != NULL);
BAIL_IF_MACRO(entry == NULL, NULL, 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)); finfo = (WADfileinfo *) malloc(sizeof (WADfileinfo));
if (finfo == NULL) BAIL_IF_MACRO(finfo == NULL, ERR_OUT_OF_MEMORY, NULL);
{
free(retval);
BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL);
} /* if */
finfo->handle = __PHYSFS_platformOpenRead(info->filename); finfo->handle = __PHYSFS_platformOpenRead(info->filename);
if ( (finfo->handle == NULL) || if ( (finfo->handle == NULL) ||
(!__PHYSFS_platformSeek(finfo->handle, entry->startPos)) ) (!__PHYSFS_platformSeek(finfo->handle, entry->startPos)) )
{ {
free(finfo); free(finfo);
free(retval);
return(NULL); return(NULL);
} /* if */ } /* if */
finfo->curPos = 0; finfo->curPos = 0;
finfo->entry = entry; finfo->entry = entry;
retval->opaque = (void *) finfo; return(finfo);
retval->funcs = &__PHYSFS_FileFunctions_WAD;
return(retval);
} /* WAD_openRead */ } /* 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); BAIL_MACRO(ERR_NOT_SUPPORTED, NULL);
} /* WAD_openWrite */ } /* 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); BAIL_MACRO(ERR_NOT_SUPPORTED, NULL);
} /* WAD_openAppend */ } /* 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); BAIL_MACRO(ERR_NOT_SUPPORTED, 0);
} /* WAD_remove */ } /* 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); BAIL_MACRO(ERR_NOT_SUPPORTED, 0);
} /* WAD_mkdir */ } /* WAD_mkdir */

129
archivers/zip.c
View File

@ -116,31 +116,31 @@ typedef struct
#define UNIX_FILETYPE_SYMLINK 0120000 #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); 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); PHYSFS_uint32 objSize, PHYSFS_uint32 objCount);
static int ZIP_eof(FileHandle *handle); static int ZIP_eof(fvoid *opaque);
static PHYSFS_sint64 ZIP_tell(FileHandle *handle); static PHYSFS_sint64 ZIP_tell(fvoid *opaque);
static int ZIP_seek(FileHandle *handle, PHYSFS_uint64 offset); static int ZIP_seek(fvoid *opaque, PHYSFS_uint64 offset);
static PHYSFS_sint64 ZIP_fileLength(FileHandle *handle); static PHYSFS_sint64 ZIP_fileLength(fvoid *opaque);
static int ZIP_fileClose(FileHandle *handle); static int ZIP_fileClose(fvoid *opaque);
static int ZIP_isArchive(const char *filename, int forWriting); static int ZIP_isArchive(const char *filename, int forWriting);
static void *ZIP_openArchive(const char *name, 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, const char *dirname,
int omitSymLinks); int omitSymLinks);
static int ZIP_exists(void *opaque, const char *name); static int ZIP_exists(dvoid *opaque, const char *name);
static int ZIP_isDirectory(void *opaque, const char *name, int *fileExists); static int ZIP_isDirectory(dvoid *opaque, const char *name, int *fileExists);
static int ZIP_isSymLink(void *opaque, const char *name, int *fileExists); static int ZIP_isSymLink(dvoid *opaque, const char *name, int *fileExists);
static PHYSFS_sint64 ZIP_getLastModTime(void *opaque, const char *n, int *e); static PHYSFS_sint64 ZIP_getLastModTime(dvoid *opaque, const char *n, int *e);
static FileHandle *ZIP_openRead(void *opaque, const char *filename, int *e); static fvoid *ZIP_openRead(dvoid *opaque, const char *filename, int *e);
static FileHandle *ZIP_openWrite(void *opaque, const char *filename); static fvoid *ZIP_openWrite(dvoid *opaque, const char *filename);
static FileHandle *ZIP_openAppend(void *opaque, const char *filename); static fvoid *ZIP_openAppend(dvoid *opaque, const char *filename);
static void ZIP_dirClose(void *opaque); static void ZIP_dirClose(dvoid *opaque);
static int zip_resolve(void *in, ZIPinfo *info, ZIPentry *entry); static int zip_resolve(void *in, ZIPinfo *info, ZIPentry *entry);
static int ZIP_remove(void *opaque, const char *name); static int ZIP_remove(dvoid *opaque, const char *name);
static int ZIP_mkdir(void *opaque, const char *name); static int ZIP_mkdir(dvoid *opaque, const char *name);
const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_ZIP = const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_ZIP =
@ -151,19 +151,8 @@ const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_ZIP =
"http://icculus.org/physfs/", "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 PHYSFS_Archiver __PHYSFS_Archiver_ZIP =
const DirFunctions __PHYSFS_DirFunctions_ZIP =
{ {
&__PHYSFS_ArchiveInfo_ZIP, &__PHYSFS_ArchiveInfo_ZIP,
ZIP_isArchive, /* isArchive() method */ ZIP_isArchive, /* isArchive() method */
@ -178,7 +167,14 @@ const DirFunctions __PHYSFS_DirFunctions_ZIP =
ZIP_openAppend, /* openAppend() method */ ZIP_openAppend, /* openAppend() method */
ZIP_remove, /* remove() method */ ZIP_remove, /* remove() method */
ZIP_mkdir, /* mkdir() 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) static voidpf zlibPhysfsAlloc(voidpf opaque, uInt items, uInt size)
{ {
return(((PHYSFS_allocator *) opaque)->malloc(items * size)); return(((PHYSFS_Allocator *) opaque)->malloc(items * size));
} /* zlibPhysfsAlloc */ } /* zlibPhysfsAlloc */
/* /*
@ -196,7 +192,7 @@ static voidpf zlibPhysfsAlloc(voidpf opaque, uInt items, uInt size)
*/ */
static void zlibPhysfsFree(voidpf opaque, voidpf address) static void zlibPhysfsFree(voidpf opaque, voidpf address)
{ {
((PHYSFS_allocator *) opaque)->free(address); ((PHYSFS_Allocator *) opaque)->free(address);
} /* zlibPhysfsFree */ } /* zlibPhysfsFree */
@ -269,10 +265,10 @@ static int readui16(void *in, PHYSFS_uint16 *val)
} /* readui16 */ } /* 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) PHYSFS_uint32 objSize, PHYSFS_uint32 objCount)
{ {
ZIPfileinfo *finfo = (ZIPfileinfo *) (handle->opaque); ZIPfileinfo *finfo = (ZIPfileinfo *) opaque;
ZIPentry *entry = finfo->entry; ZIPentry *entry = finfo->entry;
PHYSFS_sint64 retval = 0; PHYSFS_sint64 retval = 0;
PHYSFS_sint64 maxread = ((PHYSFS_sint64) objSize) * objCount; PHYSFS_sint64 maxread = ((PHYSFS_sint64) objSize) * objCount;
@ -343,29 +339,29 @@ static PHYSFS_sint64 ZIP_read(FileHandle *handle, void *buf,
} /* ZIP_read */ } /* 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) PHYSFS_uint32 objSize, PHYSFS_uint32 objCount)
{ {
BAIL_MACRO(ERR_NOT_SUPPORTED, -1); BAIL_MACRO(ERR_NOT_SUPPORTED, -1);
} /* ZIP_write */ } /* 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); return(finfo->uncompressed_position >= finfo->entry->uncompressed_size);
} /* ZIP_eof */ } /* 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 */ } /* 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; ZIPentry *entry = finfo->entry;
void *in = finfo->handle; void *in = finfo->handle;
@ -411,7 +407,7 @@ static int ZIP_seek(FileHandle *handle, PHYSFS_uint64 offset)
if (maxread > sizeof (buf)) if (maxread > sizeof (buf))
maxread = sizeof (buf); maxread = sizeof (buf);
if (ZIP_read(handle, buf, maxread, 1) != 1) if (ZIP_read(finfo, buf, maxread, 1) != 1)
return(0); return(0);
} /* while */ } /* while */
} /* else */ } /* else */
@ -420,16 +416,16 @@ static int ZIP_seek(FileHandle *handle, PHYSFS_uint64 offset)
} /* ZIP_seek */ } /* 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); return(finfo->entry->uncompressed_size);
} /* ZIP_fileLength */ } /* 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); BAIL_IF_MACRO(!__PHYSFS_platformClose(finfo->handle), NULL, 0);
if (finfo->entry->compression_method != COMPMETH_NONE) if (finfo->entry->compression_method != COMPMETH_NONE)
@ -439,7 +435,6 @@ static int ZIP_fileClose(FileHandle *handle)
free(finfo->buffer); free(finfo->buffer);
free(finfo); free(finfo);
free(handle);
return(1); return(1);
} /* ZIP_fileClose */ } /* ZIP_fileClose */
@ -1240,7 +1235,7 @@ static PHYSFS_sint32 zip_find_start_of_dir(ZIPinfo *info, const char *path,
} /* zip_find_start_of_dir */ } /* zip_find_start_of_dir */
static LinkedStringList *ZIP_enumerateFiles(void *opaque, static LinkedStringList *ZIP_enumerateFiles(dvoid *opaque,
const char *dirname, const char *dirname,
int omitSymLinks) int omitSymLinks)
{ {
@ -1287,7 +1282,7 @@ static LinkedStringList *ZIP_enumerateFiles(void *opaque,
} /* ZIP_enumerateFiles */ } /* ZIP_enumerateFiles */
static int ZIP_exists(void *opaque, const char *name) static int ZIP_exists(dvoid *opaque, const char *name)
{ {
int isDir; int isDir;
ZIPinfo *info = (ZIPinfo *) opaque; ZIPinfo *info = (ZIPinfo *) opaque;
@ -1296,7 +1291,7 @@ static int ZIP_exists(void *opaque, const char *name)
} /* ZIP_exists */ } /* ZIP_exists */
static PHYSFS_sint64 ZIP_getLastModTime(void *opaque, static PHYSFS_sint64 ZIP_getLastModTime(dvoid *opaque,
const char *name, const char *name,
int *fileExists) int *fileExists)
{ {
@ -1313,7 +1308,7 @@ static PHYSFS_sint64 ZIP_getLastModTime(void *opaque,
} /* ZIP_getLastModTime */ } /* 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; ZIPinfo *info = (ZIPinfo *) opaque;
int isDir; int isDir;
@ -1344,7 +1339,7 @@ static int ZIP_isDirectory(void *opaque, const char *name, int *fileExists)
} /* ZIP_isDirectory */ } /* 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; int isDir;
ZIPentry *entry = zip_find_entry((ZIPinfo *) opaque, name, &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 */ } /* 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; ZIPinfo *info = (ZIPinfo *) opaque;
ZIPentry *entry = zip_find_entry(info, fnm, NULL); ZIPentry *entry = zip_find_entry(info, fnm, NULL);
FileHandle *retval = NULL;
ZIPfileinfo *finfo = NULL; ZIPfileinfo *finfo = NULL;
void *in; 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); in = zip_get_file_handle(info->archiveName, info, entry);
BAIL_IF_MACRO(in == NULL, NULL, NULL); BAIL_IF_MACRO(in == NULL, NULL, NULL);
if ( ((retval = (FileHandle *) malloc(sizeof (FileHandle))) == NULL) || finfo = (ZIPfileinfo *) malloc(sizeof (ZIPfileinfo));
((finfo = (ZIPfileinfo *) malloc(sizeof (ZIPfileinfo))) == NULL) ) if (finfo == NULL)
{ {
if (retval)
free(retval);
__PHYSFS_platformClose(in); __PHYSFS_platformClose(in);
BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL); BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL);
} /* if */ } /* if */
retval->opaque = (void *) finfo;
retval->funcs = &__PHYSFS_FileFunctions_ZIP;
memset(finfo, '\0', sizeof (ZIPfileinfo)); memset(finfo, '\0', sizeof (ZIPfileinfo));
finfo->handle = in; finfo->handle = in;
finfo->entry = ((entry->symlink != NULL) ? entry->symlink : entry); 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) if (zlib_err(inflateInit2(&finfo->stream, -MAX_WBITS)) != Z_OK)
{ {
ZIP_fileClose(retval); ZIP_fileClose(finfo);
return(NULL); return(NULL);
} /* if */ } /* if */
finfo->buffer = (PHYSFS_uint8 *) malloc(ZIP_READBUFSIZE); finfo->buffer = (PHYSFS_uint8 *) malloc(ZIP_READBUFSIZE);
if (finfo->buffer == NULL) if (finfo->buffer == NULL)
{ {
ZIP_fileClose(retval); ZIP_fileClose(finfo);
BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL); BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL);
} /* if */ } /* if */
} /* if */ } /* if */
return(retval); return(finfo);
} /* ZIP_openRead */ } /* 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); BAIL_MACRO(ERR_NOT_SUPPORTED, NULL);
} /* ZIP_openWrite */ } /* 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); BAIL_MACRO(ERR_NOT_SUPPORTED, NULL);
} /* ZIP_openAppend */ } /* ZIP_openAppend */
static void ZIP_dirClose(void *opaque) static void ZIP_dirClose(dvoid *opaque)
{ {
ZIPinfo *zi = (ZIPinfo *) (opaque); ZIPinfo *zi = (ZIPinfo *) (opaque);
zip_free_entries(zi->entries, zi->entryCount); zip_free_entries(zi->entries, zi->entryCount);
@ -1449,13 +1438,13 @@ static void ZIP_dirClose(void *opaque)
} /* ZIP_dirClose */ } /* 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); BAIL_MACRO(ERR_NOT_SUPPORTED, 0);
} /* ZIP_remove */ } /* 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); BAIL_MACRO(ERR_NOT_SUPPORTED, 0);
} /* ZIP_mkdir */ } /* ZIP_mkdir */

513
physfs.c
View File

File diff suppressed because it is too large Load Diff

6
physfs.h
View File

@ -1842,11 +1842,11 @@ typedef struct
void *(*malloc)(size_t); void *(*malloc)(size_t);
void *(*realloc)(void *, size_t); void *(*realloc)(void *, size_t);
void (*free)(void *); 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. * \brief Hook your own allocation routines into PhysicsFS.
* *
* (This is for limited, hardcore use. If you don't immediately see a need * (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 * \return zero on failure, non-zero on success. This call only fails
* when used between PHYSFS_init() and PHYSFS_deinit() calls. * 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. */ /* Everything above this line is part of the PhysicsFS 2.0 API. */

226
physfs_internal.h
View File

@ -931,113 +931,32 @@ typedef struct __PHYSFS_LINKEDSTRINGLIST__
} 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; 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 * Returns non-zero if (filename) is a valid archive that this
* driver can handle. This filename is in platform-dependent * 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. * If you have a memory failure, return as much as you can.
* This dirname is in platform-independent notation. * This dirname is in platform-independent notation.
*/ */
LinkedStringList *(*enumerateFiles)(void *opaque, LinkedStringList *(*enumerateFiles)(dvoid *opaque,
const char *dirname, const char *dirname,
int omitSymLinks); int omitSymLinks);
@ -1077,7 +996,7 @@ typedef struct __PHYSFS_DIRFUNCTIONS__
* This filename is in platform-independent notation. * This filename is in platform-independent notation.
* You should not follow symlinks. * 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. * 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!), * non-zero if the file existed (even if it's a broken symlink!),
* zero if it did not. * 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. * 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!), * non-zero if the file existed (even if it's a broken symlink!),
* zero if it did not. * 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. * 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!), * non-zero if the file existed (even if it's a broken symlink!),
* zero if it did not. * 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. * This filename is in platform-independent notation.
* If you can't handle multiple opens of the same file, * If you can't handle multiple opens of the same file,
* you can opt to fail for the second call. * you can opt to fail for the second call.
* Fail if the file does not exist. * Fail if the file does not exist.
* Returns NULL on failure, and calls __PHYSFS_setError(). * 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 * Regardless of success or failure, please set *fileExists to
* non-zero if the file existed (even if it's a broken symlink!), * non-zero if the file existed (even if it's a broken symlink!),
* zero if it did not. * 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, * If the file does not exist, it should be created. If it exists,
* it should be truncated to zero bytes. The writing * it should be truncated to zero bytes. The writing
* offset should be the start of the file. * offset should be the start of the file.
* This filename is in platform-independent notation. * This filename is in platform-independent notation.
* This method may be NULL.
* If you can't handle multiple opens of the same file, * If you can't handle multiple opens of the same file,
* you can opt to fail for the second call. * you can opt to fail for the second call.
* Returns NULL on failure, and calls __PHYSFS_setError(). * 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 * If the file does not exist, it should be created. The writing
* offset should be the end of the file. * offset should be the end of the file.
* This filename is in platform-independent notation. * This filename is in platform-independent notation.
* This method may be NULL.
* If you can't handle multiple opens of the same file, * If you can't handle multiple opens of the same file,
* you can opt to fail for the second call. * you can opt to fail for the second call.
* Returns NULL on failure, and calls __PHYSFS_setError(). * 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. * Delete a file in the archive/directory.
@ -1159,7 +1082,7 @@ typedef struct __PHYSFS_DIRFUNCTIONS__
* This method may be NULL. * This method may be NULL.
* On failure, call __PHYSFS_setError(). * 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. * Create a directory in the archive/directory.
@ -1171,7 +1094,7 @@ typedef struct __PHYSFS_DIRFUNCTIONS__
* This method may be NULL. * This method may be NULL.
* On failure, call __PHYSFS_setError(). * 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, * 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 * that it won't be called if there are still files open from
* this archive. * this archive.
*/ */
void (*dirClose)(void *opaque); void (*dirClose)(dvoid *opaque);
} DirFunctions;
/*
* 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! * 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 * 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 * (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 * uses platform-independent notation. Note that ".", "..", and other
* metaentries should always be ignored. * metaentries should always be ignored.
*/ */