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

Cleanup BAIL_* and GOTO_* macros to be less cluttered. 

This also fixes really aggressive compiler warnings about the "if (!ERRPASS)"
construct producing unreachable code.
This commit is contained in:
Ryan C. Gordon 2017-07-06 11:51:41 -04:00
parent 9aebcff5ba
commit 32da097a55
22 changed files with 577 additions and 577 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
src/archiver_dir.c
View File

@ -15,7 +15,7 @@
static char *cvtToDependent(const char *prepend, const char *path, char *buf)
{
BAIL_IF_MACRO(buf == NULL, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL_IF(buf == NULL, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
sprintf(buf, "%s%s", prepend ? prepend : "", path);
if (__PHYSFS_platformDirSeparator != '/')
@ -45,12 +45,12 @@ static void *DIR_openArchive(PHYSFS_Io *io, const char *name, int forWriting)
const size_t seplen = 1;
assert(io == NULL); /* shouldn't create an Io for these. */
BAIL_IF_MACRO(!__PHYSFS_platformStat(name, &st), ERRPASS, NULL);
BAIL_IF_ERRPASS(!__PHYSFS_platformStat(name, &st), NULL);
if (st.filetype != PHYSFS_FILETYPE_DIRECTORY)
BAIL_MACRO(PHYSFS_ERR_UNSUPPORTED, NULL);
BAIL(PHYSFS_ERR_UNSUPPORTED, NULL);
retval = allocator.Malloc(namelen + seplen + 1);
BAIL_IF_MACRO(retval == NULL, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL_IF(retval == NULL, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
strcpy(retval, name);
@ -86,7 +86,7 @@ static PHYSFS_Io *doOpen(void *opaque, const char *name, const int mode)
char *f = NULL;
CVT_TO_DEPENDENT(f, opaque, name);
BAIL_IF_MACRO(!f, ERRPASS, NULL);
BAIL_IF_ERRPASS(!f, NULL);
io = __PHYSFS_createNativeIo(f, mode);
if (io == NULL)
@ -127,7 +127,7 @@ static int DIR_remove(void *opaque, const char *name)
char *f;
CVT_TO_DEPENDENT(f, opaque, name);
BAIL_IF_MACRO(!f, ERRPASS, 0);
BAIL_IF_ERRPASS(!f, 0);
retval = __PHYSFS_platformDelete(f);
__PHYSFS_smallFree(f);
return retval;
@ -140,7 +140,7 @@ static int DIR_mkdir(void *opaque, const char *name)
char *f;
CVT_TO_DEPENDENT(f, opaque, name);
BAIL_IF_MACRO(!f, ERRPASS, 0);
BAIL_IF_ERRPASS(!f, 0);
retval = __PHYSFS_platformMkDir(f);
__PHYSFS_smallFree(f);
return retval;
@ -159,7 +159,7 @@ static int DIR_stat(void *opaque, const char *name, PHYSFS_Stat *stat)
char *d;
CVT_TO_DEPENDENT(d, opaque, name);
BAIL_IF_MACRO(!d, ERRPASS, 0);
BAIL_IF_ERRPASS(!d, 0);
retval = __PHYSFS_platformStat(d, stat);
__PHYSFS_smallFree(d);
return retval;

16
src/archiver_grp.c
View File

@ -37,14 +37,14 @@ static UNPKentry *grpLoadEntries(PHYSFS_Io *io, PHYSFS_uint32 fileCount)
char *ptr = NULL;
entries = (UNPKentry *) allocator.Malloc(sizeof (UNPKentry) * fileCount);
BAIL_IF_MACRO(entries == NULL, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL_IF(entries == NULL, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
location += (16 * fileCount);
for (entry = entries; fileCount > 0; fileCount--, entry++)
{
GOTO_IF_MACRO(!__PHYSFS_readAll(io, &entry->name, 12), ERRPASS, failed);
GOTO_IF_MACRO(!__PHYSFS_readAll(io, &entry->size, 4), ERRPASS, failed);
GOTO_IF_ERRPASS(!__PHYSFS_readAll(io, &entry->name, 12), failed);
GOTO_IF_ERRPASS(!__PHYSFS_readAll(io, &entry->size, 4), failed);
entry->name[12] = '\0'; /* name isn't null-terminated in file. */
if ((ptr = strchr(entry->name, ' ')) != NULL)
*ptr = '\0'; /* trim extra spaces. */
@ -70,17 +70,17 @@ static void *GRP_openArchive(PHYSFS_Io *io, const char *name, int forWriting)
assert(io != NULL); /* shouldn't ever happen. */
BAIL_IF_MACRO(forWriting, PHYSFS_ERR_READ_ONLY, NULL);
BAIL_IF(forWriting, PHYSFS_ERR_READ_ONLY, NULL);
BAIL_IF_MACRO(!__PHYSFS_readAll(io, buf, sizeof (buf)), ERRPASS, NULL);
BAIL_IF_ERRPASS(!__PHYSFS_readAll(io, buf, sizeof (buf)), NULL);
if (memcmp(buf, "KenSilverman", sizeof (buf)) != 0)
BAIL_MACRO(PHYSFS_ERR_UNSUPPORTED, NULL);
BAIL(PHYSFS_ERR_UNSUPPORTED, NULL);
BAIL_IF_MACRO(!__PHYSFS_readAll(io, &count, sizeof(count)), ERRPASS, NULL);
BAIL_IF_ERRPASS(!__PHYSFS_readAll(io, &count, sizeof(count)), NULL);
count = PHYSFS_swapULE32(count);
entries = grpLoadEntries(io, count);
BAIL_IF_MACRO(!entries, ERRPASS, NULL);
BAIL_IF_ERRPASS(!entries, NULL);
return UNPK_openArchive(io, entries, count);
} /* GRP_openArchive */

16
src/archiver_hog.c
View File

@ -48,13 +48,13 @@ static UNPKentry *hogLoadEntries(PHYSFS_Io *io, PHYSFS_uint32 *_entCount)
{
entCount++;
ptr = allocator.Realloc(ptr, sizeof (UNPKentry) * entCount);
GOTO_IF_MACRO(ptr == NULL, PHYSFS_ERR_OUT_OF_MEMORY, failed);
GOTO_IF(ptr == NULL, PHYSFS_ERR_OUT_OF_MEMORY, failed);
entries = (UNPKentry *) ptr;
entry = &entries[entCount-1];
GOTO_IF_MACRO(!__PHYSFS_readAll(io, &entry->name, 13), ERRPASS, failed);
GOTO_IF_ERRPASS(!__PHYSFS_readAll(io, &entry->name, 13), failed);
pos += 13;
GOTO_IF_MACRO(!__PHYSFS_readAll(io, &size, 4), ERRPASS, failed);
GOTO_IF_ERRPASS(!__PHYSFS_readAll(io, &size, 4), failed);
pos += 4;
entry->size = PHYSFS_swapULE32(size);
@ -62,7 +62,7 @@ static UNPKentry *hogLoadEntries(PHYSFS_Io *io, PHYSFS_uint32 *_entCount)
pos += size;
/* skip over entry */
GOTO_IF_MACRO(!io->seek(io, pos), ERRPASS, failed);
GOTO_IF_ERRPASS(!io->seek(io, pos), failed);
} /* while */
*_entCount = entCount;
@ -81,12 +81,12 @@ static void *HOG_openArchive(PHYSFS_Io *io, const char *name, int forWriting)
UNPKentry *entries = NULL;
assert(io != NULL); /* shouldn't ever happen. */
BAIL_IF_MACRO(forWriting, PHYSFS_ERR_READ_ONLY, NULL);
BAIL_IF_MACRO(!__PHYSFS_readAll(io, buf, 3), ERRPASS, NULL);
BAIL_IF_MACRO(memcmp(buf, "DHF", 3) != 0, PHYSFS_ERR_UNSUPPORTED, NULL);
BAIL_IF(forWriting, PHYSFS_ERR_READ_ONLY, NULL);
BAIL_IF_ERRPASS(!__PHYSFS_readAll(io, buf, 3), NULL);
BAIL_IF(memcmp(buf, "DHF", 3) != 0, PHYSFS_ERR_UNSUPPORTED, NULL);
entries = hogLoadEntries(io, &count);
BAIL_IF_MACRO(!entries, ERRPASS, NULL);
BAIL_IF_ERRPASS(!entries, NULL);
return UNPK_openArchive(io, entries, count);
} /* HOG_openArchive */

113
src/archiver_iso9660.c
View File

@ -292,8 +292,8 @@ static int iso_extractfilenameISO(ISO9660FileDescriptor *descriptor,
for(;pos < descriptor->filenamelen; pos++)
if (descriptor->filename[pos] == ';')
lastfound = pos;
BAIL_IF_MACRO(lastfound < 1, PHYSFS_ERR_NOT_FOUND /* !!! FIXME: PHYSFS_ERR_BAD_FILENAME */, -1);
BAIL_IF_MACRO(lastfound == (descriptor->filenamelen -1), PHYSFS_ERR_NOT_FOUND /* !!! PHYSFS_ERR_BAD_FILENAME */, -1);
BAIL_IF(lastfound < 1, PHYSFS_ERR_NOT_FOUND /* !!! FIXME: PHYSFS_ERR_BAD_FILENAME */, -1);
BAIL_IF(lastfound == (descriptor->filenamelen -1), PHYSFS_ERR_NOT_FOUND /* !!! PHYSFS_ERR_BAD_FILENAME */, -1);
strncpy(filename, descriptor->filename, lastfound);
if (filename[lastfound - 1] == '.')
filename[lastfound - 1] = '\0'; /* consume trailing ., as done in all implementations */
@ -346,9 +346,9 @@ static int iso_readimage(ISO9660Handle *handle, PHYSFS_uint64 where,
void *buffer, PHYSFS_uint64 len)
{
int rc = -1;
BAIL_IF_MACRO(!__PHYSFS_platformGrabMutex(handle->mutex), ERRPASS, -1);
BAIL_IF_ERRPASS(!__PHYSFS_platformGrabMutex(handle->mutex), -1);
if (where != handle->currpos)
GOTO_IF_MACRO(!handle->io->seek(handle->io,where), ERRPASS, unlockme);
GOTO_IF_ERRPASS(!handle->io->seek(handle->io,where), unlockme);
rc = handle->io->read(handle->io, buffer, len);
if (rc == -1)
{
@ -369,16 +369,16 @@ static PHYSFS_sint64 iso_readfiledescriptor(ISO9660Handle *handle,
{
PHYSFS_sint64 rc = iso_readimage(handle, where, descriptor,
sizeof (descriptor->recordlen));
BAIL_IF_MACRO(rc == -1, ERRPASS, -1);
BAIL_IF_MACRO(rc != 1, PHYSFS_ERR_CORRUPT, -1);
BAIL_IF_ERRPASS(rc == -1, -1);
BAIL_IF(rc != 1, PHYSFS_ERR_CORRUPT, -1);
if (descriptor->recordlen == 0)
return 0; /* fill bytes at the end of a sector */
rc = iso_readimage(handle, where + 1, &descriptor->extattributelen,
descriptor->recordlen - sizeof(descriptor->recordlen));
BAIL_IF_MACRO(rc == -1, ERRPASS, -1);
BAIL_IF_MACRO(rc != 1, PHYSFS_ERR_CORRUPT, -1);
BAIL_IF_ERRPASS(rc == -1, -1);
BAIL_IF(rc != 1, PHYSFS_ERR_CORRUPT, -1);
return 0;
} /* iso_readfiledescriptor */
@ -416,7 +416,7 @@ static int iso_find_dir_entry(ISO9660Handle *handle,const char *path,
iso_extractsubpath(mypath, &subpath);
while (1)
{
BAIL_IF_MACRO(iso_readfiledescriptor(handle, readpos, descriptor), ERRPASS, -1);
BAIL_IF_ERRPASS(iso_readfiledescriptor(handle, readpos, descriptor), -1);
/* recordlen = 0 -> no more entries or fill entry */
if (!descriptor->recordlen)
@ -435,9 +435,7 @@ static int iso_find_dir_entry(ISO9660Handle *handle,const char *path,
|| descriptor->filename[0] == 1))
continue; /* special ones, ignore */
BAIL_IF_MACRO(
iso_extractfilename(handle, descriptor, filename, &version),
ERRPASS, -1);
BAIL_IF_ERRPASS(iso_extractfilename(handle, descriptor, filename, &version), -1);
if (strcmp(filename, mypath) == 0)
{
@ -479,7 +477,7 @@ static int ISO9660_flush(PHYSFS_Io *io) { return 1; /* no write support. */ }
static PHYSFS_Io *ISO9660_duplicate(PHYSFS_Io *_io)
{
BAIL_MACRO(PHYSFS_ERR_UNSUPPORTED, NULL); /* !!! FIXME: write me. */
BAIL(PHYSFS_ERR_UNSUPPORTED, NULL); /* !!! FIXME: write me. */
} /* ISO9660_duplicate */
@ -500,7 +498,7 @@ static PHYSFS_sint64 ISO9660_read(PHYSFS_Io *io, void *buf, PHYSFS_uint64 len)
static PHYSFS_sint64 ISO9660_write(PHYSFS_Io *io, const void *b, PHYSFS_uint64 l)
{
BAIL_MACRO(PHYSFS_ERR_READ_ONLY, -1);
BAIL(PHYSFS_ERR_READ_ONLY, -1);
} /* ISO9660_write */
@ -550,37 +548,37 @@ static void *ISO9660_openArchive(PHYSFS_Io *io, const char *filename, int forWri
assert(io != NULL); /* shouldn't ever happen. */
BAIL_IF_MACRO(forWriting, PHYSFS_ERR_READ_ONLY, NULL);
BAIL_IF(forWriting, PHYSFS_ERR_READ_ONLY, NULL);
/* Skip system area to magic number in Volume descriptor */
BAIL_IF_MACRO(!io->seek(io, 32769), ERRPASS, NULL);
BAIL_IF_MACRO(io->read(io, magicnumber, 5) != 5, ERRPASS, NULL);
BAIL_IF_ERRPASS(!io->seek(io, 32769), NULL);
BAIL_IF_ERRPASS(io->read(io, magicnumber, 5) != 5, NULL);
if (memcmp(magicnumber, "CD001", 6) != 0)
BAIL_MACRO(PHYSFS_ERR_UNSUPPORTED, NULL);
BAIL(PHYSFS_ERR_UNSUPPORTED, NULL);
handle = allocator.Malloc(sizeof(ISO9660Handle));
GOTO_IF_MACRO(!handle, PHYSFS_ERR_OUT_OF_MEMORY, errorcleanup);
GOTO_IF(!handle, PHYSFS_ERR_OUT_OF_MEMORY, errorcleanup);
handle->path = 0;
handle->mutex= 0;
handle->io = NULL;
handle->path = allocator.Malloc(strlen(filename) + 1);
GOTO_IF_MACRO(!handle->path, PHYSFS_ERR_OUT_OF_MEMORY, errorcleanup);
GOTO_IF(!handle->path, PHYSFS_ERR_OUT_OF_MEMORY, errorcleanup);
strcpy(handle->path, filename);
handle->mutex = __PHYSFS_platformCreateMutex();
GOTO_IF_MACRO(!handle->mutex, ERRPASS, errorcleanup);
GOTO_IF_ERRPASS(!handle->mutex, errorcleanup);
handle->io = io;
/* seek Primary Volume Descriptor */
GOTO_IF_MACRO(!io->seek(io, 32768), PHYSFS_ERR_IO, errorcleanup);
GOTO_IF_ERRPASS(!io->seek(io, 32768), errorcleanup);
while (1)
{
ISO9660VolumeDescriptor descriptor;
GOTO_IF_MACRO(io->read(io, &descriptor, sizeof(ISO9660VolumeDescriptor)) != sizeof(ISO9660VolumeDescriptor), PHYSFS_ERR_IO, errorcleanup);
GOTO_IF_MACRO(strncmp(descriptor.identifier, "CD001", 5) != 0, PHYSFS_ERR_UNSUPPORTED, errorcleanup);
GOTO_IF_ERRPASS(io->read(io, &descriptor, sizeof(ISO9660VolumeDescriptor)) != sizeof(ISO9660VolumeDescriptor), errorcleanup);
GOTO_IF(strncmp(descriptor.identifier, "CD001", 5) != 0, PHYSFS_ERR_UNSUPPORTED, errorcleanup);
if (descriptor.type == 255)
{
@ -588,7 +586,7 @@ static void *ISO9660_openArchive(PHYSFS_Io *io, const char *filename, int forWri
if (founddescriptor)
return handle; /* ok, we've found one volume descriptor */
else
GOTO_MACRO(PHYSFS_ERR_CORRUPT, errorcleanup);
GOTO(PHYSFS_ERR_CORRUPT, errorcleanup);
} /* if */
if (descriptor.type == 1 && !founddescriptor)
{
@ -622,7 +620,7 @@ static void *ISO9660_openArchive(PHYSFS_Io *io, const char *filename, int forWri
} /* if */
} /* while */
GOTO_MACRO(PHYSFS_ERR_CORRUPT, errorcleanup); /* not found. */
GOTO(PHYSFS_ERR_CORRUPT, errorcleanup); /* not found. */
errorcleanup:
if (handle)
@ -672,8 +670,8 @@ static PHYSFS_uint32 iso_file_read_mem(ISO9660FileHandle *filehandle,
static int iso_file_seek_mem(ISO9660FileHandle *fhandle, PHYSFS_sint64 offset)
{
BAIL_IF_MACRO(offset < 0, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF_MACRO(offset >= fhandle->filesize, PHYSFS_ERR_PAST_EOF, 0);
BAIL_IF(offset < 0, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF(offset >= fhandle->filesize, PHYSFS_ERR_PAST_EOF, 0);
fhandle->currpos = offset;
return 0;
@ -698,10 +696,10 @@ static PHYSFS_uint32 iso_file_read_foreign(ISO9660FileHandle *filehandle,
len = bytesleft;
rc = filehandle->io->read(filehandle->io, buffer, len);
BAIL_IF_MACRO(rc == -1, ERRPASS, -1);
BAIL_IF_ERRPASS(rc == -1, -1);
filehandle->currpos += rc; /* i trust my internal book keeping */
BAIL_IF_MACRO(rc < len, PHYSFS_ERR_CORRUPT, -1);
BAIL_IF(rc < len, PHYSFS_ERR_CORRUPT, -1);
return rc;
} /* iso_file_read_foreign */
@ -711,11 +709,11 @@ static int iso_file_seek_foreign(ISO9660FileHandle *fhandle,
{
PHYSFS_sint64 pos;
BAIL_IF_MACRO(offset < 0, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF_MACRO(offset >= fhandle->filesize, PHYSFS_ERR_PAST_EOF, 0);
BAIL_IF(offset < 0, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF(offset >= fhandle->filesize, PHYSFS_ERR_PAST_EOF, 0);
pos = fhandle->startblock * 2048 + offset;
BAIL_IF_MACRO(!fhandle->io->seek(fhandle->io, pos), ERRPASS, -1);
BAIL_IF_ERRPASS(!fhandle->io->seek(fhandle->io, pos), -1);
fhandle->currpos = offset;
return 0;
@ -733,11 +731,11 @@ static int iso_file_open_mem(ISO9660Handle *handle, ISO9660FileHandle *fhandle)
{
int rc;
fhandle->cacheddata = allocator.Malloc(fhandle->filesize);
BAIL_IF_MACRO(!fhandle->cacheddata, PHYSFS_ERR_OUT_OF_MEMORY, -1);
BAIL_IF(!fhandle->cacheddata, PHYSFS_ERR_OUT_OF_MEMORY, -1);
rc = iso_readimage(handle, fhandle->startblock * 2048,
fhandle->cacheddata, fhandle->filesize);
GOTO_IF_MACRO(rc < 0, ERRPASS, freemem);
GOTO_IF_MACRO(rc == 0, PHYSFS_ERR_CORRUPT, freemem);
GOTO_IF_ERRPASS(rc < 0, freemem);
GOTO_IF(rc == 0, PHYSFS_ERR_CORRUPT, freemem);
fhandle->read = iso_file_read_mem;
fhandle->seek = iso_file_seek_mem;
@ -753,20 +751,19 @@ freemem:
static int iso_file_open_foreign(ISO9660Handle *handle,
ISO9660FileHandle *fhandle)
{
int rc;
fhandle->io = __PHYSFS_createNativeIo(handle->path, 'r');
BAIL_IF_MACRO(!fhandle->io, ERRPASS, -1);
rc = fhandle->io->seek(fhandle->io, fhandle->startblock * 2048);
GOTO_IF_MACRO(!rc, ERRPASS, closefile);
BAIL_IF_ERRPASS(!fhandle->io, -1);
if (!fhandle->io->seek(fhandle->io, fhandle->startblock * 2048))
{
fhandle->io->destroy(fhandle->io);
return -1;
} /* if */
fhandle->read = iso_file_read_foreign;
fhandle->seek = iso_file_seek_foreign;
fhandle->close = iso_file_close_foreign;
return 0;
closefile:
fhandle->io->destroy(fhandle->io);
return -1;
} /* iso_file_open_foreign */
@ -779,15 +776,15 @@ static PHYSFS_Io *ISO9660_openRead(void *opaque, const char *filename)
int rc;
fhandle = allocator.Malloc(sizeof(ISO9660FileHandle));
BAIL_IF_MACRO(fhandle == 0, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL_IF(fhandle == 0, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
fhandle->cacheddata = 0;
retval = allocator.Malloc(sizeof(PHYSFS_Io));
GOTO_IF_MACRO(retval == 0, PHYSFS_ERR_OUT_OF_MEMORY, errorhandling);
GOTO_IF(retval == 0, PHYSFS_ERR_OUT_OF_MEMORY, errorhandling);
/* find file descriptor */
rc = iso_find_dir_entry(handle, filename, &descriptor);
GOTO_IF_MACRO(rc, ERRPASS, errorhandling);
GOTO_IF_ERRPASS(rc, errorhandling);
fhandle->startblock = descriptor.extentpos + descriptor.extattributelen;
fhandle->filesize = descriptor.datalen;
@ -800,7 +797,7 @@ static PHYSFS_Io *ISO9660_openRead(void *opaque, const char *filename)
rc = iso_file_open_mem(handle, fhandle);
else
rc = iso_file_open_foreign(handle, fhandle);
GOTO_IF_MACRO(rc, ERRPASS, errorhandling);
GOTO_IF_ERRPASS(rc, errorhandling);
memcpy(retval, &ISO9660_Io, sizeof (PHYSFS_Io));
retval->opaque = fhandle;
@ -837,8 +834,8 @@ static void ISO9660_enumerateFiles(void *opaque, const char *dname,
else
{
printf("pfad %s\n",dname);
BAIL_IF_MACRO(iso_find_dir_entry(handle,dname, &descriptor), ERRPASS,);
BAIL_IF_MACRO(!descriptor.flags.directory, ERRPASS,);
BAIL_IF_ERRPASS(iso_find_dir_entry(handle,dname, &descriptor),);
BAIL_IF_ERRPASS(!descriptor.flags.directory,);
readpos = descriptor.extentpos * 2048;
end_of_dir = readpos + descriptor.datalen;
@ -846,7 +843,7 @@ static void ISO9660_enumerateFiles(void *opaque, const char *dname,
while (1)
{
BAIL_IF_MACRO(iso_readfiledescriptor(handle, readpos, &descriptor), ERRPASS, );
BAIL_IF_ERRPASS(iso_readfiledescriptor(handle, readpos, &descriptor), );
/* recordlen = 0 -> no more entries or fill entry */
if (!descriptor.recordlen)
@ -877,15 +874,15 @@ static int ISO9660_stat(void *opaque, const char *name, PHYSFS_Stat *stat)
ISO9660Handle *handle = (ISO9660Handle*) opaque;
ISO9660FileDescriptor descriptor;
ISO9660ExtAttributeRec extattr;
BAIL_IF_MACRO(iso_find_dir_entry(handle, name, &descriptor), ERRPASS, -1);
BAIL_IF_ERRPASS(iso_find_dir_entry(handle, name, &descriptor), -1);
stat->readonly = 1;
/* try to get extended info */
if (descriptor.extattributelen)
{
BAIL_IF_MACRO(iso_read_ext_attributes(handle,
descriptor.extentpos, &extattr), ERRPASS, -1);
BAIL_IF_ERRPASS(iso_read_ext_attributes(handle,
descriptor.extentpos, &extattr), -1);
stat->createtime = iso_volume_mktime(&extattr.create_time);
stat->modtime = iso_volume_mktime(&extattr.mod_time);
stat->accesstime = iso_volume_mktime(&extattr.mod_time);
@ -918,25 +915,25 @@ static int ISO9660_stat(void *opaque, const char *name, PHYSFS_Stat *stat)
static PHYSFS_Io *ISO9660_openWrite(void *opaque, const char *name)
{
BAIL_MACRO(PHYSFS_ERR_READ_ONLY, NULL);
BAIL(PHYSFS_ERR_READ_ONLY, NULL);
} /* ISO9660_openWrite */
static PHYSFS_Io *ISO9660_openAppend(void *opaque, const char *name)
{
BAIL_MACRO(PHYSFS_ERR_READ_ONLY, NULL);
BAIL(PHYSFS_ERR_READ_ONLY, NULL);
} /* ISO9660_openAppend */
static int ISO9660_remove(void *opaque, const char *name)
{
BAIL_MACRO(PHYSFS_ERR_READ_ONLY, 0);
BAIL(PHYSFS_ERR_READ_ONLY, 0);
} /* ISO9660_remove */
static int ISO9660_mkdir(void *opaque, const char *name)
{
BAIL_MACRO(PHYSFS_ERR_READ_ONLY, 0);
BAIL(PHYSFS_ERR_READ_ONLY, 0);
} /* ISO9660_mkdir */

44
src/archiver_lzma.c
View File

@ -205,7 +205,7 @@ static LZMAfile * lzma_find_file(const LZMAarchive *archive, const char *name)
{
LZMAfile *file = bsearch(name, archive->files, archive->db.Database.NumFiles, sizeof(*archive->files), lzma_file_cmp_stdlib); /* FIXME: Should become __PHYSFS_search!!! */
BAIL_IF_MACRO(file == NULL, PHYSFS_ERR_NOT_FOUND, NULL);
BAIL_IF(file == NULL, PHYSFS_ERR_NOT_FOUND, NULL);
return file;
} /* lzma_find_file */
@ -324,8 +324,10 @@ static PHYSFS_sint64 LZMA_read(PHYSFS_Io *io, void *outBuf, PHYSFS_uint64 len)
const size_t remainingSize = file->item->Size - file->position;
size_t fileSize = 0;
BAIL_IF_MACRO(wantedSize == 0, ERRPASS, 0); /* quick rejection. */
BAIL_IF_MACRO(remainingSize == 0, PHYSFS_ERR_PAST_EOF, 0);
if (wantedSize == 0)
return 0; /* quick rejection. */
BAIL_IF(remainingSize == 0, PHYSFS_ERR_PAST_EOF, 0);
if (wantedSize > remainingSize)
wantedSize = remainingSize;
@ -364,7 +366,7 @@ static PHYSFS_sint64 LZMA_read(PHYSFS_Io *io, void *outBuf, PHYSFS_uint64 len)
static PHYSFS_sint64 LZMA_write(PHYSFS_Io *io, const void *b, PHYSFS_uint64 len)
{
BAIL_MACRO(PHYSFS_ERR_READ_ONLY, -1);
BAIL(PHYSFS_ERR_READ_ONLY, -1);
} /* LZMA_write */
@ -379,7 +381,7 @@ static int LZMA_seek(PHYSFS_Io *io, PHYSFS_uint64 offset)
{
LZMAfile *file = (LZMAfile *) io->opaque;
BAIL_IF_MACRO(offset > file->item->Size, PHYSFS_ERR_PAST_EOF, 0);
BAIL_IF(offset > file->item->Size, PHYSFS_ERR_PAST_EOF, 0);
file->position = offset; /* We only use a virtual position... */
@ -398,7 +400,7 @@ static PHYSFS_Io *LZMA_duplicate(PHYSFS_Io *_io)
{
/* !!! FIXME: this archiver needs to be reworked to allow multiple
* !!! FIXME: opens before we worry about duplication. */
BAIL_MACRO(PHYSFS_ERR_UNSUPPORTED, NULL);
BAIL(PHYSFS_ERR_UNSUPPORTED, NULL);
} /* LZMA_duplicate */
@ -447,15 +449,15 @@ static void *LZMA_openArchive(PHYSFS_Io *io, const char *name, int forWriting)
assert(io != NULL); /* shouldn't ever happen. */
BAIL_IF_MACRO(forWriting, PHYSFS_ERR_READ_ONLY, NULL);
BAIL_IF(forWriting, PHYSFS_ERR_READ_ONLY, NULL);
if (io->read(io, sig, k7zSignatureSize) != k7zSignatureSize)
return 0;
BAIL_IF_MACRO(!TestSignatureCandidate(sig), PHYSFS_ERR_UNSUPPORTED, NULL);
BAIL_IF_MACRO(!io->seek(io, 0), ERRPASS, NULL);
BAIL_IF(!TestSignatureCandidate(sig), PHYSFS_ERR_UNSUPPORTED, NULL);
BAIL_IF_ERRPASS(!io->seek(io, 0), NULL);
archive = (LZMAarchive *) allocator.Malloc(sizeof (LZMAarchive));
BAIL_IF_MACRO(archive == NULL, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL_IF(archive == NULL, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
lzma_archive_init(archive);
archive->stream.io = io;
@ -478,7 +480,7 @@ static void *LZMA_openArchive(PHYSFS_Io *io, const char *name, int forWriting)
{
SzArDbExFree(&archive->db, SzFreePhysicsFS);
lzma_archive_exit(archive);
BAIL_MACRO(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
}
/*
@ -493,7 +495,7 @@ static void *LZMA_openArchive(PHYSFS_Io *io, const char *name, int forWriting)
{
SzArDbExFree(&archive->db, SzFreePhysicsFS);
lzma_archive_exit(archive);
BAIL_MACRO(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
}
/*
@ -506,7 +508,7 @@ static void *LZMA_openArchive(PHYSFS_Io *io, const char *name, int forWriting)
{
SzArDbExFree(&archive->db, SzFreePhysicsFS);
lzma_archive_exit(archive);
BAIL_MACRO(PHYSFS_ERR_OTHER_ERROR, NULL);
BAIL(PHYSFS_ERR_OTHER_ERROR, NULL);
}
return archive;
@ -551,7 +553,7 @@ static void LZMA_enumerateFiles(void *opaque, const char *dname,
file = archive->files;
}
BAIL_IF_MACRO(file == NULL, PHYSFS_ERR_NOT_FOUND, );
BAIL_IF(file == NULL, PHYSFS_ERR_NOT_FOUND, );
while (file < lastFile)
{
@ -581,14 +583,14 @@ static PHYSFS_Io *LZMA_openRead(void *opaque, const char *name)
LZMAfile *file = lzma_find_file(archive, name);
PHYSFS_Io *io = NULL;
BAIL_IF_MACRO(file == NULL, PHYSFS_ERR_NOT_FOUND, NULL);
BAIL_IF_MACRO(file->folder == NULL, PHYSFS_ERR_NOT_A_FILE, NULL);
BAIL_IF(file == NULL, PHYSFS_ERR_NOT_FOUND, NULL);
BAIL_IF(file->folder == NULL, PHYSFS_ERR_NOT_A_FILE, NULL);
file->position = 0;
file->folder->references++; /* Increase refcount for automatic cleanup... */
io = (PHYSFS_Io *) allocator.Malloc(sizeof (PHYSFS_Io));
BAIL_IF_MACRO(io == NULL, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL_IF(io == NULL, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
memcpy(io, &LZMA_Io, sizeof (*io));
io->opaque = file;
@ -598,13 +600,13 @@ static PHYSFS_Io *LZMA_openRead(void *opaque, const char *name)
static PHYSFS_Io *LZMA_openWrite(void *opaque, const char *filename)
{
BAIL_MACRO(PHYSFS_ERR_READ_ONLY, NULL);
BAIL(PHYSFS_ERR_READ_ONLY, NULL);
} /* LZMA_openWrite */
static PHYSFS_Io *LZMA_openAppend(void *opaque, const char *filename)
{
BAIL_MACRO(PHYSFS_ERR_READ_ONLY, NULL);
BAIL(PHYSFS_ERR_READ_ONLY, NULL);
} /* LZMA_openAppend */
@ -628,13 +630,13 @@ static void LZMA_closeArchive(void *opaque)
static int LZMA_remove(void *opaque, const char *name)
{
BAIL_MACRO(PHYSFS_ERR_READ_ONLY, 0);
BAIL(PHYSFS_ERR_READ_ONLY, 0);
} /* LZMA_remove */
static int LZMA_mkdir(void *opaque, const char *name)
{
BAIL_MACRO(PHYSFS_ERR_READ_ONLY, 0);
BAIL(PHYSFS_ERR_READ_ONLY, 0);
} /* LZMA_mkdir */
static int LZMA_stat(void *opaque, const char *filename, PHYSFS_Stat *stat)

10
src/archiver_mvl.c
View File

@ -39,7 +39,7 @@ static UNPKentry *mvlLoadEntries(PHYSFS_Io *io, PHYSFS_uint32 fileCount)
UNPKentry *entry = NULL;
entries = (UNPKentry *) allocator.Malloc(sizeof (UNPKentry) * fileCount);
BAIL_IF_MACRO(entries == NULL, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL_IF(entries == NULL, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
location += (17 * fileCount);
@ -67,10 +67,10 @@ static void *MVL_openArchive(PHYSFS_Io *io, const char *name, int forWriting)
UNPKentry *entries = NULL;
assert(io != NULL); /* shouldn't ever happen. */
BAIL_IF_MACRO(forWriting, PHYSFS_ERR_READ_ONLY, NULL);
BAIL_IF_MACRO(!__PHYSFS_readAll(io, buf, 4), ERRPASS, NULL);
BAIL_IF_MACRO(memcmp(buf, "DMVL", 4) != 0, PHYSFS_ERR_UNSUPPORTED, NULL);
BAIL_IF_MACRO(!__PHYSFS_readAll(io, &count, sizeof(count)), ERRPASS, NULL);
BAIL_IF(forWriting, PHYSFS_ERR_READ_ONLY, NULL);
BAIL_IF_ERRPASS(!__PHYSFS_readAll(io, buf, 4), NULL);
BAIL_IF(memcmp(buf, "DMVL", 4) != 0, PHYSFS_ERR_UNSUPPORTED, NULL);
BAIL_IF_ERRPASS(!__PHYSFS_readAll(io, &count, sizeof(count)), NULL);
count = PHYSFS_swapULE32(count);
entries = mvlLoadEntries(io, count);

18
src/archiver_qpak.c
View File

@ -42,7 +42,7 @@ static UNPKentry *qpakLoadEntries(PHYSFS_Io *io, PHYSFS_uint32 fileCount)
UNPKentry *entry = NULL;
entries = (UNPKentry *) allocator.Malloc(sizeof (UNPKentry) * fileCount);
BAIL_IF_MACRO(entries == NULL, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL_IF(entries == NULL, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
for (entry = entries; fileCount > 0; fileCount--, entry++)
{
@ -70,26 +70,26 @@ static void *QPAK_openArchive(PHYSFS_Io *io, const char *name, int forWriting)
assert(io != NULL); /* shouldn't ever happen. */
BAIL_IF_MACRO(forWriting, PHYSFS_ERR_READ_ONLY, NULL);
BAIL_IF(forWriting, PHYSFS_ERR_READ_ONLY, NULL);
BAIL_IF_MACRO(!__PHYSFS_readAll(io, &val, 4), ERRPASS, NULL);
BAIL_IF_ERRPASS(!__PHYSFS_readAll(io, &val, 4), NULL);
if (PHYSFS_swapULE32(val) != QPAK_SIG)
BAIL_MACRO(PHYSFS_ERR_UNSUPPORTED, NULL);
BAIL(PHYSFS_ERR_UNSUPPORTED, NULL);
BAIL_IF_MACRO(!__PHYSFS_readAll(io, &val, 4), ERRPASS, NULL);
BAIL_IF_ERRPASS(!__PHYSFS_readAll(io, &val, 4), NULL);
pos = PHYSFS_swapULE32(val); /* directory table offset. */
BAIL_IF_MACRO(!__PHYSFS_readAll(io, &val, 4), ERRPASS, NULL);
BAIL_IF_ERRPASS(!__PHYSFS_readAll(io, &val, 4), NULL);
count = PHYSFS_swapULE32(val);
/* corrupted archive? */
BAIL_IF_MACRO((count % 64) != 0, PHYSFS_ERR_CORRUPT, NULL);
BAIL_IF((count % 64) != 0, PHYSFS_ERR_CORRUPT, NULL);
count /= 64;
BAIL_IF_MACRO(!io->seek(io, pos), ERRPASS, NULL);
BAIL_IF_ERRPASS(!io->seek(io, pos), NULL);
entries = qpakLoadEntries(io, count);
BAIL_IF_MACRO(!entries, ERRPASS, NULL);
BAIL_IF_ERRPASS(!entries, NULL);
return UNPK_openArchive(io, entries, count);
} /* QPAK_openArchive */

29
src/archiver_slb.c
View File

@ -26,7 +26,7 @@ static UNPKentry *slbLoadEntries(PHYSFS_Io *io, PHYSFS_uint32 fileCount)
UNPKentry *entry = NULL;
entries = (UNPKentry *) allocator.Malloc(sizeof (UNPKentry) * fileCount);
BAIL_IF_MACRO(entries == NULL, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL_IF(entries == NULL, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
for (entry = entries; fileCount > 0; fileCount--, entry++)
{
@ -34,11 +34,11 @@ static UNPKentry *slbLoadEntries(PHYSFS_Io *io, PHYSFS_uint32 fileCount)
/* don't include the '\' in the beginning */
char backslash;
GOTO_IF_MACRO(!__PHYSFS_readAll(io, &backslash, 1), ERRPASS, failed);
GOTO_IF_MACRO(backslash != '\\', ERRPASS, failed);
GOTO_IF_ERRPASS(!__PHYSFS_readAll(io, &backslash, 1), failed);
GOTO_IF_ERRPASS(backslash != '\\', failed);
/* read the rest of the buffer, 63 bytes */
GOTO_IF_MACRO(!__PHYSFS_readAll(io, &entry->name, 63), ERRPASS, failed);
GOTO_IF_ERRPASS(!__PHYSFS_readAll(io, &entry->name, 63), failed);
entry->name[63] = '\0'; /* in case the name lacks the null terminator */
/* convert backslashes */
@ -48,11 +48,10 @@ static UNPKentry *slbLoadEntries(PHYSFS_Io *io, PHYSFS_uint32 fileCount)
*ptr = '/';
} /* for */
GOTO_IF_MACRO(!__PHYSFS_readAll(io, &entry->startPos, 4),
ERRPASS, failed);
GOTO_IF_ERRPASS(!__PHYSFS_readAll(io, &entry->startPos, 4), failed);
entry->startPos = PHYSFS_swapULE32(entry->startPos);
GOTO_IF_MACRO(!__PHYSFS_readAll(io, &entry->size, 4), ERRPASS, failed);
GOTO_IF_ERRPASS(!__PHYSFS_readAll(io, &entry->size, 4), failed);
entry->size = PHYSFS_swapULE32(entry->size);
} /* for */
@ -74,26 +73,24 @@ static void *SLB_openArchive(PHYSFS_Io *io, const char *name, int forWriting)
assert(io != NULL); /* shouldn't ever happen. */
BAIL_IF_MACRO(forWriting, PHYSFS_ERR_READ_ONLY, NULL);
BAIL_IF(forWriting, PHYSFS_ERR_READ_ONLY, NULL);
BAIL_IF_MACRO(!__PHYSFS_readAll(io, &version, sizeof(version)),
ERRPASS, NULL);
BAIL_IF_ERRPASS(!__PHYSFS_readAll(io, &version, sizeof(version)), NULL);
version = PHYSFS_swapULE32(version);
BAIL_IF_MACRO(version != 0, ERRPASS, NULL);
BAIL_IF(version != 0, PHYSFS_ERR_UNSUPPORTED, NULL);
BAIL_IF_MACRO(!__PHYSFS_readAll(io, &count, sizeof(count)), ERRPASS, NULL);
BAIL_IF_ERRPASS(!__PHYSFS_readAll(io, &count, sizeof(count)), NULL);
count = PHYSFS_swapULE32(count);
/* offset of the table of contents */
BAIL_IF_MACRO(!__PHYSFS_readAll(io, &tocPos, sizeof(tocPos)),
ERRPASS, NULL);
BAIL_IF_ERRPASS(!__PHYSFS_readAll(io, &tocPos, sizeof(tocPos)), NULL);
tocPos = PHYSFS_swapULE32(tocPos);
/* seek to the table of contents */
BAIL_IF_MACRO(!io->seek(io, tocPos), ERRPASS, NULL);
BAIL_IF_ERRPASS(!io->seek(io, tocPos), NULL);
entries = slbLoadEntries(io, count);
BAIL_IF_MACRO(!entries, ERRPASS, NULL);
BAIL_IF_ERRPASS(!entries, NULL);
return UNPK_openArchive(io, entries, count);
} /* SLB_openArchive */

30
src/archiver_unpacked.c
View File

@ -63,7 +63,7 @@ static PHYSFS_sint64 UNPK_read(PHYSFS_Io *io, void *buffer, PHYSFS_uint64 len)
static PHYSFS_sint64 UNPK_write(PHYSFS_Io *io, const void *b, PHYSFS_uint64 len)
{
BAIL_MACRO(PHYSFS_ERR_READ_ONLY, -1);
BAIL(PHYSFS_ERR_READ_ONLY, -1);
} /* UNPK_write */
@ -79,7 +79,7 @@ static int UNPK_seek(PHYSFS_Io *io, PHYSFS_uint64 offset)
const UNPKentry *entry = finfo->entry;
int rc;
BAIL_IF_MACRO(offset >= entry->size, PHYSFS_ERR_PAST_EOF, 0);
BAIL_IF(offset >= entry->size, PHYSFS_ERR_PAST_EOF, 0);
rc = finfo->io->seek(finfo->io, entry->startPos + offset);
if (rc)
finfo->curPos = (PHYSFS_uint32) offset;
@ -101,8 +101,8 @@ static PHYSFS_Io *UNPK_duplicate(PHYSFS_Io *_io)
PHYSFS_Io *io = NULL;
PHYSFS_Io *retval = (PHYSFS_Io *) allocator.Malloc(sizeof (PHYSFS_Io));
UNPKfileinfo *finfo = (UNPKfileinfo *) allocator.Malloc(sizeof (UNPKfileinfo));
GOTO_IF_MACRO(!retval, PHYSFS_ERR_OUT_OF_MEMORY, UNPK_duplicate_failed);
GOTO_IF_MACRO(!finfo, PHYSFS_ERR_OUT_OF_MEMORY, UNPK_duplicate_failed);
GOTO_IF(!retval, PHYSFS_ERR_OUT_OF_MEMORY, UNPK_duplicate_failed);
GOTO_IF(!finfo, PHYSFS_ERR_OUT_OF_MEMORY, UNPK_duplicate_failed);
io = origfinfo->io->duplicate(origfinfo->io);
if (!io) goto UNPK_duplicate_failed;
@ -340,7 +340,7 @@ static UNPKentry *findEntry(const UNPKinfo *info, const char *path, int *isDir)
if (isDir != NULL)
*isDir = 0;
BAIL_MACRO(PHYSFS_ERR_NOT_FOUND, NULL);
BAIL(PHYSFS_ERR_NOT_FOUND, NULL);
} /* findEntry */
@ -352,17 +352,17 @@ PHYSFS_Io *UNPK_openRead(void *opaque, const char *name)
int isdir = 0;
UNPKentry *entry = findEntry(info, name, &isdir);
GOTO_IF_MACRO(isdir, PHYSFS_ERR_NOT_A_FILE, UNPK_openRead_failed);
GOTO_IF_MACRO(!entry, ERRPASS, UNPK_openRead_failed);
GOTO_IF(isdir, PHYSFS_ERR_NOT_A_FILE, UNPK_openRead_failed);
GOTO_IF_ERRPASS(!entry, UNPK_openRead_failed);
retval = (PHYSFS_Io *) allocator.Malloc(sizeof (PHYSFS_Io));
GOTO_IF_MACRO(!retval, PHYSFS_ERR_OUT_OF_MEMORY, UNPK_openRead_failed);
GOTO_IF(!retval, PHYSFS_ERR_OUT_OF_MEMORY, UNPK_openRead_failed);
finfo = (UNPKfileinfo *) allocator.Malloc(sizeof (UNPKfileinfo));
GOTO_IF_MACRO(!finfo, PHYSFS_ERR_OUT_OF_MEMORY, UNPK_openRead_failed);
GOTO_IF(!finfo, PHYSFS_ERR_OUT_OF_MEMORY, UNPK_openRead_failed);
finfo->io = info->io->duplicate(info->io);
GOTO_IF_MACRO(!finfo->io, ERRPASS, UNPK_openRead_failed);
GOTO_IF_ERRPASS(!finfo->io, UNPK_openRead_failed);
if (!finfo->io->seek(finfo->io, entry->startPos))
goto UNPK_openRead_failed;
@ -391,25 +391,25 @@ UNPK_openRead_failed:
PHYSFS_Io *UNPK_openWrite(void *opaque, const char *name)
{
BAIL_MACRO(PHYSFS_ERR_READ_ONLY, NULL);
BAIL(PHYSFS_ERR_READ_ONLY, NULL);
} /* UNPK_openWrite */
PHYSFS_Io *UNPK_openAppend(void *opaque, const char *name)
{
BAIL_MACRO(PHYSFS_ERR_READ_ONLY, NULL);
BAIL(PHYSFS_ERR_READ_ONLY, NULL);
} /* UNPK_openAppend */
int UNPK_remove(void *opaque, const char *name)
{
BAIL_MACRO(PHYSFS_ERR_READ_ONLY, 0);
BAIL(PHYSFS_ERR_READ_ONLY, 0);
} /* UNPK_remove */
int UNPK_mkdir(void *opaque, const char *name)
{
BAIL_MACRO(PHYSFS_ERR_READ_ONLY, 0);
BAIL(PHYSFS_ERR_READ_ONLY, 0);
} /* UNPK_mkdir */
@ -449,7 +449,7 @@ void *UNPK_openArchive(PHYSFS_Io *io, UNPKentry *e, const PHYSFS_uint32 num)
if (info == NULL)
{
allocator.Free(e);
BAIL_MACRO(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
} /* if */
__PHYSFS_sort(e, (size_t) num, entryCmp, entrySwap);

32
src/archiver_vdf.c
View File

@ -154,7 +154,7 @@ static PHYSFS_sint64 VDF_read(PHYSFS_Io *io, void *buffer, PHYSFS_uint64 len)
static PHYSFS_sint64 VDF_write(PHYSFS_Io *io, const void *b, PHYSFS_uint64 len)
{
BAIL_MACRO(PHYSFS_ERR_READ_ONLY, -1);
BAIL(PHYSFS_ERR_READ_ONLY, -1);
} /* VDF_write */
@ -170,7 +170,7 @@ static int VDF_seek(PHYSFS_Io *io, PHYSFS_uint64 offset)
const VdfEntryInfo *entry = finfo->entry;
int rc;
BAIL_IF_MACRO(offset >= entry->size, PHYSFS_ERR_PAST_EOF, 0);
BAIL_IF(offset >= entry->size, PHYSFS_ERR_PAST_EOF, 0);
rc = finfo->io->seek(finfo->io, entry->jump + offset);
if (rc)
finfo->curPos = (PHYSFS_uint32)offset;
@ -192,8 +192,8 @@ static PHYSFS_Io *VDF_duplicate(PHYSFS_Io *_io)
PHYSFS_Io *io = NULL;
PHYSFS_Io *retval = (PHYSFS_Io *)allocator.Malloc(sizeof(PHYSFS_Io));
VdfFileinfo *finfo = (VdfFileinfo *)allocator.Malloc(sizeof(VdfFileinfo));
GOTO_IF_MACRO(!retval, PHYSFS_ERR_OUT_OF_MEMORY, VDF_duplicate_failed);
GOTO_IF_MACRO(!finfo, PHYSFS_ERR_OUT_OF_MEMORY, VDF_duplicate_failed);
GOTO_IF(!retval, PHYSFS_ERR_OUT_OF_MEMORY, VDF_duplicate_failed);
GOTO_IF(!finfo, PHYSFS_ERR_OUT_OF_MEMORY, VDF_duplicate_failed);
io = origfinfo->io->duplicate(origfinfo->io);
if (!io) goto VDF_duplicate_failed;
@ -322,10 +322,10 @@ static void vdfAddEntry(VdfRecord *record, VdfEntryInfo *entry)
static VdfRecord *vdfLoadRecord(PHYSFS_Io *io, VdfHeader header)
{
VdfRecord *record = (VdfRecord*)allocator.Malloc(sizeof(VdfRecord));
BAIL_IF_MACRO(!record, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL_IF(!record, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
VdfEntryInfo *entries = (VdfEntryInfo *)allocator.Malloc(sizeof(VdfEntryInfo) * header.numEntries);
GOTO_IF_MACRO(!entries, PHYSFS_ERR_OUT_OF_MEMORY, failed);
GOTO_IF(!entries, PHYSFS_ERR_OUT_OF_MEMORY, failed);
if (!__PHYSFS_readAll(io, entries, sizeof(VdfEntryInfo) * header.numEntries)) goto failed;
@ -416,8 +416,8 @@ void *VDF_openArchive(PHYSFS_Io *io, const char *name, int forWriting)
VdfRecord *record = NULL;
assert(io != NULL); /* shouldn't ever happen. */
BAIL_IF_MACRO(forWriting, PHYSFS_ERR_READ_ONLY, NULL);
BAIL_IF_MACRO(!__PHYSFS_readAll(io, &header, sizeof(VdfHeader)), ERRPASS, NULL);
BAIL_IF(forWriting, PHYSFS_ERR_READ_ONLY, NULL);
BAIL_IF_ERRPASS(!__PHYSFS_readAll(io, &header, sizeof(VdfHeader)), NULL);
header.numEntries = PHYSFS_swapULE32(header.numEntries);
header.numFiles = PHYSFS_swapULE32(header.numFiles);
@ -426,16 +426,16 @@ void *VDF_openArchive(PHYSFS_Io *io, const char *name, int forWriting)
header.rootCatOffset = PHYSFS_swapULE32(header.rootCatOffset);
header.version = PHYSFS_swapULE32(header.version);
BAIL_IF_MACRO(header.version != 0x50, PHYSFS_ERR_UNSUPPORTED, NULL);
BAIL_IF(header.version != 0x50, PHYSFS_ERR_UNSUPPORTED, NULL);
if ((memcmp(header.signature, VDF_SIGNATURE_G1, VDF_HEADER_SIGNATURE_LENGTH) != 0) &&
(memcmp(header.signature, VDF_SIGNATURE_G2, VDF_HEADER_SIGNATURE_LENGTH) != 0))
{
BAIL_MACRO(PHYSFS_ERR_UNSUPPORTED, NULL);
BAIL(PHYSFS_ERR_UNSUPPORTED, NULL);
} /* if */
record = vdfLoadRecord(io, header);
BAIL_IF_MACRO(!record, ERRPASS, NULL);
BAIL_IF_ERRPASS(!record, NULL);
record->io = io;
return record;
} /* VDF_openArchive */
@ -464,16 +464,16 @@ PHYSFS_Io *VDF_openRead(void *opaque, const char *name)
VdfRecord *record = (VdfRecord *)opaque;
VdfFileinfo *finfo = NULL;
VdfEntryInfo entry;
GOTO_IF_MACRO(!vdfFindFile(record, name, &entry), PHYSFS_ERR_NOT_FOUND, VDF_openRead_failed);
GOTO_IF(!vdfFindFile(record, name, &entry), PHYSFS_ERR_NOT_FOUND, VDF_openRead_failed);
retval = (PHYSFS_Io *)allocator.Malloc(sizeof(PHYSFS_Io));
GOTO_IF_MACRO(!retval, PHYSFS_ERR_OUT_OF_MEMORY, VDF_openRead_failed);
GOTO_IF(!retval, PHYSFS_ERR_OUT_OF_MEMORY, VDF_openRead_failed);
finfo = (VdfFileinfo *)allocator.Malloc(sizeof(VdfFileinfo));
GOTO_IF_MACRO(!finfo, PHYSFS_ERR_OUT_OF_MEMORY, VDF_openRead_failed);
GOTO_IF(!finfo, PHYSFS_ERR_OUT_OF_MEMORY, VDF_openRead_failed);
finfo->io = record->io->duplicate(record->io);
GOTO_IF_MACRO(!finfo->io, ERRPASS, VDF_openRead_failed);
GOTO_IF_ERRPASS(!finfo->io, VDF_openRead_failed);
if (!finfo->io->seek(finfo->io, entry.jump))
goto VDF_openRead_failed;
@ -481,7 +481,7 @@ PHYSFS_Io *VDF_openRead(void *opaque, const char *name)
finfo->curPos = 0;
finfo->entry = (VdfEntryInfo *)allocator.Malloc(sizeof(VdfEntryInfo));
GOTO_IF_MACRO(!finfo->entry, PHYSFS_ERR_OUT_OF_MEMORY, VDF_openRead_failed);
GOTO_IF(!finfo->entry, PHYSFS_ERR_OUT_OF_MEMORY, VDF_openRead_failed);
memcpy(finfo->entry, &entry, sizeof(VdfEntryInfo));
memcpy(retval, &VDF_Io, sizeof(*retval));

16
src/archiver_wad.c
View File

@ -53,13 +53,13 @@ static UNPKentry *wadLoadEntries(PHYSFS_Io *io, PHYSFS_uint32 fileCount)
UNPKentry *entries = NULL;
UNPKentry *entry = NULL;
BAIL_IF_MACRO(!__PHYSFS_readAll(io, &directoryOffset, 4), ERRPASS, 0);
BAIL_IF_ERRPASS(!__PHYSFS_readAll(io, &directoryOffset, 4), 0);
directoryOffset = PHYSFS_swapULE32(directoryOffset);
BAIL_IF_MACRO(!io->seek(io, directoryOffset), ERRPASS, 0);
BAIL_IF_ERRPASS(!io->seek(io, directoryOffset), 0);
entries = (UNPKentry *) allocator.Malloc(sizeof (UNPKentry) * fileCount);
BAIL_IF_MACRO(!entries, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL_IF(!entries, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
for (entry = entries; fileCount > 0; fileCount--, entry++)
{
@ -88,16 +88,16 @@ static void *WAD_openArchive(PHYSFS_Io *io, const char *name, int forWriting)
assert(io != NULL); /* shouldn't ever happen. */
BAIL_IF_MACRO(forWriting, PHYSFS_ERR_READ_ONLY, NULL);
BAIL_IF_MACRO(!__PHYSFS_readAll(io, buf, sizeof (buf)), ERRPASS, NULL);
BAIL_IF(forWriting, PHYSFS_ERR_READ_ONLY, NULL);
BAIL_IF_ERRPASS(!__PHYSFS_readAll(io, buf, sizeof (buf)), NULL);
if ((memcmp(buf, "IWAD", 4) != 0) && (memcmp(buf, "PWAD", 4) != 0))
BAIL_MACRO(PHYSFS_ERR_UNSUPPORTED, NULL);
BAIL(PHYSFS_ERR_UNSUPPORTED, NULL);
BAIL_IF_MACRO(!__PHYSFS_readAll(io, &count, sizeof (count)), ERRPASS, NULL);
BAIL_IF_ERRPASS(!__PHYSFS_readAll(io, &count, sizeof (count)), NULL);
count = PHYSFS_swapULE32(count);
entries = wadLoadEntries(io, count);
BAIL_IF_MACRO(!entries, ERRPASS, NULL);
BAIL_IF_ERRPASS(!entries, NULL);
return UNPK_openArchive(io, entries, count);
} /* WAD_openArchive */

226
src/archiver_zip.c
View File

@ -210,7 +210,7 @@ static int zip_prep_crypto_keys(ZIPfileinfo *finfo, const PHYSFS_uint8 *crypto_h
/* you have a 1/256 chance of passing this test incorrectly. :/ */
if (finalbyte != verifier)
BAIL_MACRO(PHYSFS_ERR_BAD_PASSWORD, 0);
BAIL(PHYSFS_ERR_BAD_PASSWORD, 0);
/* save the initial vector for seeking purposes. Not secure!! */
memcpy(finfo->initial_crypto_keys, finfo->crypto_keys, 12);
@ -283,7 +283,7 @@ static inline PHYSFS_uint32 zip_hash_string(const ZIPinfo *info, const char *s)
static int readui64(PHYSFS_Io *io, PHYSFS_uint64 *val)
{
PHYSFS_uint64 v;
BAIL_IF_MACRO(!__PHYSFS_readAll(io, &v, sizeof (v)), ERRPASS, 0);
BAIL_IF_ERRPASS(!__PHYSFS_readAll(io, &v, sizeof (v)), 0);
*val = PHYSFS_swapULE64(v);
return 1;
} /* readui64 */
@ -294,7 +294,7 @@ static int readui64(PHYSFS_Io *io, PHYSFS_uint64 *val)
static int readui32(PHYSFS_Io *io, PHYSFS_uint32 *val)
{
PHYSFS_uint32 v;
BAIL_IF_MACRO(!__PHYSFS_readAll(io, &v, sizeof (v)), ERRPASS, 0);
BAIL_IF_ERRPASS(!__PHYSFS_readAll(io, &v, sizeof (v)), 0);
*val = PHYSFS_swapULE32(v);
return 1;
} /* readui32 */
@ -306,7 +306,7 @@ static int readui32(PHYSFS_Io *io, PHYSFS_uint32 *val)
static int readui16(PHYSFS_Io *io, PHYSFS_uint16 *val)
{
PHYSFS_uint16 v;
BAIL_IF_MACRO(!__PHYSFS_readAll(io, &v, sizeof (v)), ERRPASS, 0);
BAIL_IF_ERRPASS(!__PHYSFS_readAll(io, &v, sizeof (v)), 0);
*val = PHYSFS_swapULE16(v);
return 1;
} /* readui16 */
@ -324,7 +324,7 @@ static PHYSFS_sint64 ZIP_read(PHYSFS_Io *_io, void *buf, PHYSFS_uint64 len)
if (avail < maxread)
maxread = avail;
BAIL_IF_MACRO(maxread == 0, ERRPASS, 0); /* quick rejection. */
BAIL_IF_ERRPASS(maxread == 0, 0); /* quick rejection. */
if (entry->compression_method == COMPMETH_NONE)
retval = zip_read_decrypt(finfo, buf, maxread);
@ -375,7 +375,7 @@ static PHYSFS_sint64 ZIP_read(PHYSFS_Io *_io, void *buf, PHYSFS_uint64 len)
static PHYSFS_sint64 ZIP_write(PHYSFS_Io *io, const void *b, PHYSFS_uint64 len)
{
BAIL_MACRO(PHYSFS_ERR_READ_ONLY, -1);
BAIL(PHYSFS_ERR_READ_ONLY, -1);
} /* ZIP_write */
@ -392,12 +392,12 @@ static int ZIP_seek(PHYSFS_Io *_io, PHYSFS_uint64 offset)
PHYSFS_Io *io = finfo->io;
const int encrypted = zip_entry_is_tradional_crypto(entry);
BAIL_IF_MACRO(offset > entry->uncompressed_size, PHYSFS_ERR_PAST_EOF, 0);
BAIL_IF(offset > entry->uncompressed_size, PHYSFS_ERR_PAST_EOF, 0);
if (!encrypted && (entry->compression_method == COMPMETH_NONE))
{
PHYSFS_sint64 newpos = offset + entry->offset;
BAIL_IF_MACRO(!io->seek(io, newpos), ERRPASS, 0);
BAIL_IF_ERRPASS(!io->seek(io, newpos), 0);
finfo->uncompressed_position = (PHYSFS_uint32) offset;
} /* if */
@ -460,18 +460,18 @@ static PHYSFS_Io *ZIP_duplicate(PHYSFS_Io *io)
ZIPfileinfo *origfinfo = (ZIPfileinfo *) io->opaque;
PHYSFS_Io *retval = (PHYSFS_Io *) allocator.Malloc(sizeof (PHYSFS_Io));
ZIPfileinfo *finfo = (ZIPfileinfo *) allocator.Malloc(sizeof (ZIPfileinfo));
GOTO_IF_MACRO(!retval, PHYSFS_ERR_OUT_OF_MEMORY, failed);
GOTO_IF_MACRO(!finfo, PHYSFS_ERR_OUT_OF_MEMORY, failed);
GOTO_IF(!retval, PHYSFS_ERR_OUT_OF_MEMORY, failed);
GOTO_IF(!finfo, PHYSFS_ERR_OUT_OF_MEMORY, failed);
memset(finfo, '\0', sizeof (*finfo));
finfo->entry = origfinfo->entry;
finfo->io = zip_get_io(origfinfo->io, NULL, finfo->entry);
GOTO_IF_MACRO(!finfo->io, ERRPASS, failed);
GOTO_IF_ERRPASS(!finfo->io, failed);
if (finfo->entry->compression_method != COMPMETH_NONE)
{
finfo->buffer = (PHYSFS_uint8 *) allocator.Malloc(ZIP_READBUFSIZE);
GOTO_IF_MACRO(!finfo->buffer, PHYSFS_ERR_OUT_OF_MEMORY, failed);
GOTO_IF(!finfo->buffer, PHYSFS_ERR_OUT_OF_MEMORY, failed);
if (zlib_err(inflateInit2(&finfo->stream, -MAX_WBITS)) != Z_OK)
goto failed;
} /* if */
@ -546,7 +546,7 @@ static PHYSFS_sint64 zip_find_end_of_central_dir(PHYSFS_Io *io, PHYSFS_sint64 *l
int found = 0;
filelen = io->length(io);
BAIL_IF_MACRO(filelen == -1, ERRPASS, -1);
BAIL_IF_ERRPASS(filelen == -1, -1);
/*
* Jump to the end of the file and start reading backwards.
@ -573,7 +573,7 @@ static PHYSFS_sint64 zip_find_end_of_central_dir(PHYSFS_Io *io, PHYSFS_sint64 *l
while ((totalread < filelen) && (totalread < 65557))
{
BAIL_IF_MACRO(!io->seek(io, filepos), ERRPASS, -1);
BAIL_IF_ERRPASS(!io->seek(io, filepos), -1);
/* make sure we catch a signature between buffers. */
if (totalread != 0)
@ -612,7 +612,7 @@ static PHYSFS_sint64 zip_find_end_of_central_dir(PHYSFS_Io *io, PHYSFS_sint64 *l
filepos = 0;
} /* while */
BAIL_IF_MACRO(!found, PHYSFS_ERR_UNSUPPORTED, -1);
BAIL_IF(!found, PHYSFS_ERR_UNSUPPORTED, -1);
if (len != NULL)
*len = filelen;
@ -676,7 +676,7 @@ static ZIPentry *zip_find_entry(ZIPinfo *info, const char *path)
prev = retval;
} /* for */
BAIL_MACRO(PHYSFS_ERR_NOT_FOUND, NULL);
BAIL(PHYSFS_ERR_NOT_FOUND, NULL);
} /* zip_find_entry */
@ -796,10 +796,10 @@ static int zip_resolve_symlink(PHYSFS_Io *io, ZIPinfo *info, ZIPentry *entry)
* follow it.
*/
BAIL_IF_MACRO(!io->seek(io, entry->offset), ERRPASS, 0);
BAIL_IF_ERRPASS(!io->seek(io, entry->offset), 0);
path = (char *) __PHYSFS_smallAlloc(size + 1);
BAIL_IF_MACRO(!path, PHYSFS_ERR_OUT_OF_MEMORY, 0);
BAIL_IF(!path, PHYSFS_ERR_OUT_OF_MEMORY, 0);
if (entry->compression_method == COMPMETH_NONE)
rc = __PHYSFS_readAll(io, path, size);
@ -867,28 +867,28 @@ static int zip_parse_local(PHYSFS_Io *io, ZIPentry *entry)
!!! FIXME: which is probably true for Jar files, fwiw, but we don't
!!! FIXME: care about these values anyhow. */
BAIL_IF_MACRO(!io->seek(io, entry->offset), ERRPASS, 0);
BAIL_IF_MACRO(!readui32(io, &ui32), ERRPASS, 0);
BAIL_IF_MACRO(ui32 != ZIP_LOCAL_FILE_SIG, PHYSFS_ERR_CORRUPT, 0);
BAIL_IF_MACRO(!readui16(io, &ui16), ERRPASS, 0);
BAIL_IF_MACRO(ui16 != entry->version_needed, PHYSFS_ERR_CORRUPT, 0);
BAIL_IF_MACRO(!readui16(io, &ui16), ERRPASS, 0); /* general bits. */
BAIL_IF_MACRO(!readui16(io, &ui16), ERRPASS, 0);
BAIL_IF_MACRO(ui16 != entry->compression_method, PHYSFS_ERR_CORRUPT, 0);
BAIL_IF_MACRO(!readui32(io, &ui32), ERRPASS, 0); /* date/time */
BAIL_IF_MACRO(!readui32(io, &ui32), ERRPASS, 0);
BAIL_IF_MACRO(ui32 && (ui32 != entry->crc), PHYSFS_ERR_CORRUPT, 0);
BAIL_IF_ERRPASS(!io->seek(io, entry->offset), 0);
BAIL_IF_ERRPASS(!readui32(io, &ui32), 0);
BAIL_IF(ui32 != ZIP_LOCAL_FILE_SIG, PHYSFS_ERR_CORRUPT, 0);
BAIL_IF_ERRPASS(!readui16(io, &ui16), 0);
BAIL_IF(ui16 != entry->version_needed, PHYSFS_ERR_CORRUPT, 0);
BAIL_IF_ERRPASS(!readui16(io, &ui16), 0); /* general bits. */
BAIL_IF_ERRPASS(!readui16(io, &ui16), 0);
BAIL_IF(ui16 != entry->compression_method, PHYSFS_ERR_CORRUPT, 0);
BAIL_IF_ERRPASS(!readui32(io, &ui32), 0); /* date/time */
BAIL_IF_ERRPASS(!readui32(io, &ui32), 0);
BAIL_IF(ui32 && (ui32 != entry->crc), PHYSFS_ERR_CORRUPT, 0);
BAIL_IF_MACRO(!readui32(io, &ui32), ERRPASS, 0);
BAIL_IF_MACRO(ui32 && (ui32 != 0xFFFFFFFF) &&
BAIL_IF_ERRPASS(!readui32(io, &ui32), 0);
BAIL_IF(ui32 && (ui32 != 0xFFFFFFFF) &&
(ui32 != entry->compressed_size), PHYSFS_ERR_CORRUPT, 0);
BAIL_IF_MACRO(!readui32(io, &ui32), ERRPASS, 0);
BAIL_IF_MACRO(ui32 && (ui32 != 0xFFFFFFFF) &&
BAIL_IF_ERRPASS(!readui32(io, &ui32), 0);
BAIL_IF(ui32 && (ui32 != 0xFFFFFFFF) &&
(ui32 != entry->uncompressed_size), PHYSFS_ERR_CORRUPT, 0);
BAIL_IF_MACRO(!readui16(io, &fnamelen), ERRPASS, 0);
BAIL_IF_MACRO(!readui16(io, &extralen), ERRPASS, 0);
BAIL_IF_ERRPASS(!readui16(io, &fnamelen), 0);
BAIL_IF_ERRPASS(!readui16(io, &extralen), 0);
entry->offset += fnamelen + extralen + 30;
return 1;
@ -904,11 +904,11 @@ static int zip_resolve(PHYSFS_Io *io, ZIPinfo *info, ZIPentry *entry)
return 1; /* we're good. */
/* Don't bother if we've failed to resolve this entry before. */
BAIL_IF_MACRO(resolve_type == ZIP_BROKEN_FILE, PHYSFS_ERR_CORRUPT, 0);
BAIL_IF_MACRO(resolve_type == ZIP_BROKEN_SYMLINK, PHYSFS_ERR_CORRUPT, 0);
BAIL_IF(resolve_type == ZIP_BROKEN_FILE, PHYSFS_ERR_CORRUPT, 0);
BAIL_IF(resolve_type == ZIP_BROKEN_SYMLINK, PHYSFS_ERR_CORRUPT, 0);
/* uhoh...infinite symlink loop! */
BAIL_IF_MACRO(resolve_type == ZIP_RESOLVING, PHYSFS_ERR_SYMLINK_LOOP, 0);
BAIL_IF(resolve_type == ZIP_RESOLVING, PHYSFS_ERR_SYMLINK_LOOP, 0);
/*
* We fix up the offset to point to the actual data on the
@ -962,13 +962,13 @@ static ZIPentry *zip_hash_ancestors(ZIPinfo *info, char *name)
if (retval != NULL)
{
if (retval->resolved != ZIP_DIRECTORY)
BAIL_MACRO(PHYSFS_ERR_CORRUPT, NULL);
BAIL(PHYSFS_ERR_CORRUPT, NULL);
return retval; /* already hashed. */
} /* if */
/* okay, this is a new dir. Build and hash us. */
retval = (ZIPentry *) allocator.Malloc(sizeof (ZIPentry) + namelen);
BAIL_IF_MACRO(!retval, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL_IF(!retval, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
memset(retval, '\0', sizeof (*retval));
retval->name = ((char *) retval) + sizeof (ZIPentry);
memcpy(retval->name, name, namelen);
@ -1098,7 +1098,7 @@ static ZIPentry *zip_load_entry(PHYSFS_Io *io, const int zip64,
/* sanity check with central directory signature... */
if (!readui32(io, &ui32)) return NULL;
BAIL_IF_MACRO(ui32 != ZIP_CENTRAL_DIR_SIG, PHYSFS_ERR_CORRUPT, NULL);
BAIL_IF(ui32 != ZIP_CENTRAL_DIR_SIG, PHYSFS_ERR_CORRUPT, NULL);
/* Get the pertinent parts of the record... */
if (!readui16(io, &entry.version)) return NULL;
@ -1123,7 +1123,7 @@ static ZIPentry *zip_load_entry(PHYSFS_Io *io, const int zip64,
offset = (PHYSFS_uint64) ui32;
retval = (ZIPentry *) allocator.Malloc(sizeof (ZIPentry) + fnamelen + 1);
BAIL_IF_MACRO(retval == NULL, PHYSFS_ERR_OUT_OF_MEMORY, 0);
BAIL_IF(retval == NULL, PHYSFS_ERR_OUT_OF_MEMORY, 0);
memcpy(retval, &entry, sizeof (*retval));
retval->name = ((char *) retval) + sizeof (ZIPentry);
@ -1182,11 +1182,11 @@ static ZIPentry *zip_load_entry(PHYSFS_Io *io, const int zip64,
break;
} /* while */
GOTO_IF_MACRO(!found, PHYSFS_ERR_CORRUPT, zip_load_entry_puked);
GOTO_IF(!found, PHYSFS_ERR_CORRUPT, zip_load_entry_puked);
if (retval->uncompressed_size == 0xFFFFFFFF)
{
GOTO_IF_MACRO(len < 8, PHYSFS_ERR_CORRUPT, zip_load_entry_puked);
GOTO_IF(len < 8, PHYSFS_ERR_CORRUPT, zip_load_entry_puked);
if (!readui64(io, &retval->uncompressed_size))
goto zip_load_entry_puked;
len -= 8;
@ -1194,7 +1194,7 @@ static ZIPentry *zip_load_entry(PHYSFS_Io *io, const int zip64,
if (retval->compressed_size == 0xFFFFFFFF)
{
GOTO_IF_MACRO(len < 8, PHYSFS_ERR_CORRUPT, zip_load_entry_puked);
GOTO_IF(len < 8, PHYSFS_ERR_CORRUPT, zip_load_entry_puked);
if (!readui64(io, &retval->compressed_size))
goto zip_load_entry_puked;
len -= 8;
@ -1202,7 +1202,7 @@ static ZIPentry *zip_load_entry(PHYSFS_Io *io, const int zip64,
if (offset == 0xFFFFFFFF)
{
GOTO_IF_MACRO(len < 8, PHYSFS_ERR_CORRUPT, zip_load_entry_puked);
GOTO_IF(len < 8, PHYSFS_ERR_CORRUPT, zip_load_entry_puked);
if (!readui64(io, &offset))
goto zip_load_entry_puked;
len -= 8;
@ -1210,16 +1210,16 @@ static ZIPentry *zip_load_entry(PHYSFS_Io *io, const int zip64,
if (starting_disk == 0xFFFFFFFF)
{
GOTO_IF_MACRO(len < 8, PHYSFS_ERR_CORRUPT, zip_load_entry_puked);
GOTO_IF(len < 8, PHYSFS_ERR_CORRUPT, zip_load_entry_puked);
if (!readui32(io, &starting_disk))
goto zip_load_entry_puked;
len -= 4;
} /* if */
GOTO_IF_MACRO(len != 0, PHYSFS_ERR_CORRUPT, zip_load_entry_puked);
GOTO_IF(len != 0, PHYSFS_ERR_CORRUPT, zip_load_entry_puked);
} /* if */
GOTO_IF_MACRO(starting_disk != 0, PHYSFS_ERR_CORRUPT, zip_load_entry_puked);
GOTO_IF(starting_disk != 0, PHYSFS_ERR_CORRUPT, zip_load_entry_puked);
retval->offset = offset + ofs_fixup;
@ -1262,7 +1262,7 @@ static int zip_load_entries(ZIPinfo *info,
if (find->last_mod_time != 0) /* duplicate? */
{
allocator.Free(entry);
BAIL_MACRO(PHYSFS_ERR_CORRUPT, 0);
BAIL(PHYSFS_ERR_CORRUPT, 0);
} /* if */
else /* we filled this in as a placeholder. Update it. */
{
@ -1319,8 +1319,8 @@ static PHYSFS_sint64 zip64_find_end_of_central_dir(PHYSFS_Io *io,
/* Try offset specified in the Zip64 end of central directory locator. */
/* This works if the entire PHYSFS_Io is the zip file. */
BAIL_IF_MACRO(!io->seek(io, offset), ERRPASS, -1);
BAIL_IF_MACRO(!readui32(io, &ui32), ERRPASS, -1);
BAIL_IF_ERRPASS(!io->seek(io, offset), -1);
BAIL_IF_ERRPASS(!readui32(io, &ui32), -1);
if (ui32 == ZIP64_END_OF_CENTRAL_DIR_SIG)
return offset;
@ -1328,8 +1328,8 @@ static PHYSFS_sint64 zip64_find_end_of_central_dir(PHYSFS_Io *io,
/* This works if the record isn't variable length and is version 1. */
if (pos > 56)
{
BAIL_IF_MACRO(!io->seek(io, pos-56), ERRPASS, -1);
BAIL_IF_MACRO(!readui32(io, &ui32), ERRPASS, -1);
BAIL_IF_ERRPASS(!io->seek(io, pos-56), -1);
BAIL_IF_ERRPASS(!readui32(io, &ui32), -1);
if (ui32 == ZIP64_END_OF_CENTRAL_DIR_SIG)
return pos-56;
} /* if */
@ -1338,8 +1338,8 @@ static PHYSFS_sint64 zip64_find_end_of_central_dir(PHYSFS_Io *io,
/* This works if the record isn't variable length and is version 2. */
if (pos > 84)
{
BAIL_IF_MACRO(!io->seek(io, pos-84), ERRPASS, -1);
BAIL_IF_MACRO(!readui32(io, &ui32), ERRPASS, -1);
BAIL_IF_ERRPASS(!io->seek(io, pos-84), -1);
BAIL_IF_ERRPASS(!readui32(io, &ui32), -1);
if (ui32 == ZIP64_END_OF_CENTRAL_DIR_SIG)
return pos-84;
} /* if */
@ -1357,7 +1357,7 @@ static PHYSFS_sint64 zip64_find_end_of_central_dir(PHYSFS_Io *io,
len = maxbuflen;
buf = (PHYSFS_uint8 *) __PHYSFS_smallAlloc(len);
BAIL_IF_MACRO(!buf, PHYSFS_ERR_OUT_OF_MEMORY, -1);
BAIL_IF(!buf, PHYSFS_ERR_OUT_OF_MEMORY, -1);
if (!io->seek(io, pos - len) || !__PHYSFS_readAll(io, buf, len))
{
@ -1378,7 +1378,7 @@ static PHYSFS_sint64 zip64_find_end_of_central_dir(PHYSFS_Io *io,
__PHYSFS_smallFree(buf);
} /* if */
BAIL_MACRO(PHYSFS_ERR_CORRUPT, -1); /* didn't find it. */
BAIL(PHYSFS_ERR_CORRUPT, -1); /* didn't find it. */
} /* zip64_find_end_of_central_dir */
@ -1398,22 +1398,22 @@ static int zip64_parse_end_of_central_dir(ZIPinfo *info,
if ((pos < 0) || (!io->seek(io, pos)))
return 0;
BAIL_IF_MACRO(!readui32(io, &ui32), ERRPASS, 0);
BAIL_IF_ERRPASS(!readui32(io, &ui32), 0);
if (ui32 != ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR_SIG)
return -1; /* it's not a Zip64 archive. Not an error, though! */
info->zip64 = 1;
/* number of the disk with the start of the central directory. */
BAIL_IF_MACRO(!readui32(io, &ui32), ERRPASS, 0);
BAIL_IF_MACRO(ui32 != 0, PHYSFS_ERR_CORRUPT, 0);
BAIL_IF_ERRPASS(!readui32(io, &ui32), 0);
BAIL_IF(ui32 != 0, PHYSFS_ERR_CORRUPT, 0);
/* offset of Zip64 end of central directory record. */
BAIL_IF_MACRO(!readui64(io, &ui64), ERRPASS, 0);
BAIL_IF_ERRPASS(!readui64(io, &ui64), 0);
/* total number of disks */
BAIL_IF_MACRO(!readui32(io, &ui32), ERRPASS, 0);
BAIL_IF_MACRO(ui32 != 1, PHYSFS_ERR_CORRUPT, 0);
BAIL_IF_ERRPASS(!readui32(io, &ui32), 0);
BAIL_IF(ui32 != 1, PHYSFS_ERR_CORRUPT, 0);
pos = zip64_find_end_of_central_dir(io, pos, ui64);
if (pos < 0)
@ -1429,41 +1429,41 @@ static int zip64_parse_end_of_central_dir(ZIPinfo *info,
assert(((PHYSFS_uint64) pos) >= ui64);
*data_start = ((PHYSFS_uint64) pos) - ui64;
BAIL_IF_MACRO(!io->seek(io, pos), ERRPASS, 0);
BAIL_IF_ERRPASS(!io->seek(io, pos), 0);
/* check signature again, just in case. */
BAIL_IF_MACRO(!readui32(io, &ui32), ERRPASS, 0);
BAIL_IF_MACRO(ui32 != ZIP64_END_OF_CENTRAL_DIR_SIG, PHYSFS_ERR_CORRUPT, 0);
BAIL_IF_ERRPASS(!readui32(io, &ui32), 0);
BAIL_IF(ui32 != ZIP64_END_OF_CENTRAL_DIR_SIG, PHYSFS_ERR_CORRUPT, 0);
/* size of Zip64 end of central directory record. */
BAIL_IF_MACRO(!readui64(io, &ui64), ERRPASS, 0);
BAIL_IF_ERRPASS(!readui64(io, &ui64), 0);
/* version made by. */
BAIL_IF_MACRO(!readui16(io, &ui16), ERRPASS, 0);
BAIL_IF_ERRPASS(!readui16(io, &ui16), 0);
/* version needed to extract. */
BAIL_IF_MACRO(!readui16(io, &ui16), ERRPASS, 0);
BAIL_IF_ERRPASS(!readui16(io, &ui16), 0);
/* number of this disk. */
BAIL_IF_MACRO(!readui32(io, &ui32), ERRPASS, 0);
BAIL_IF_MACRO(ui32 != 0, PHYSFS_ERR_CORRUPT, 0);
BAIL_IF_ERRPASS(!readui32(io, &ui32), 0);
BAIL_IF(ui32 != 0, PHYSFS_ERR_CORRUPT, 0);
/* number of disk with start of central directory record. */
BAIL_IF_MACRO(!readui32(io, &ui32), ERRPASS, 0);
BAIL_IF_MACRO(ui32 != 0, PHYSFS_ERR_CORRUPT, 0);
BAIL_IF_ERRPASS(!readui32(io, &ui32), 0);
BAIL_IF(ui32 != 0, PHYSFS_ERR_CORRUPT, 0);
/* total number of entries in the central dir on this disk */
BAIL_IF_MACRO(!readui64(io, &ui64), ERRPASS, 0);
BAIL_IF_ERRPASS(!readui64(io, &ui64), 0);
/* total number of entries in the central dir */
BAIL_IF_MACRO(!readui64(io, entry_count), ERRPASS, 0);
BAIL_IF_MACRO(ui64 != *entry_count, PHYSFS_ERR_CORRUPT, 0);
BAIL_IF_ERRPASS(!readui64(io, entry_count), 0);
BAIL_IF(ui64 != *entry_count, PHYSFS_ERR_CORRUPT, 0);
/* size of the central directory */
BAIL_IF_MACRO(!readui64(io, &ui64), ERRPASS, 0);
BAIL_IF_ERRPASS(!readui64(io, &ui64), 0);
/* offset of central directory */
BAIL_IF_MACRO(!readui64(io, dir_ofs), ERRPASS, 0);
BAIL_IF_ERRPASS(!readui64(io, dir_ofs), 0);
/* Since we know the difference, fix up the central dir offset... */
*dir_ofs += *data_start;
@ -1493,12 +1493,12 @@ static int zip_parse_end_of_central_dir(ZIPinfo *info,
/* find the end-of-central-dir record, and seek to it. */
pos = zip_find_end_of_central_dir(io, &len);
BAIL_IF_MACRO(pos == -1, ERRPASS, 0);
BAIL_IF_MACRO(!io->seek(io, pos), ERRPASS, 0);
BAIL_IF_ERRPASS(pos == -1, 0);
BAIL_IF_ERRPASS(!io->seek(io, pos), 0);
/* check signature again, just in case. */
BAIL_IF_MACRO(!readui32(io, &ui32), ERRPASS, 0);
BAIL_IF_MACRO(ui32 != ZIP_END_OF_CENTRAL_DIR_SIG, PHYSFS_ERR_CORRUPT, 0);
BAIL_IF_ERRPASS(!readui32(io, &ui32), 0);
BAIL_IF(ui32 != ZIP_END_OF_CENTRAL_DIR_SIG, PHYSFS_ERR_CORRUPT, 0);
/* Seek back to see if "Zip64 end of central directory locator" exists. */
/* this record is 20 bytes before end-of-central-dir */
@ -1512,32 +1512,32 @@ static int zip_parse_end_of_central_dir(ZIPinfo *info,
assert(rc == -1); /* no error, just not a Zip64 archive. */
/* Not Zip64? Seek back to where we were and keep processing. */
BAIL_IF_MACRO(!io->seek(io, pos + 4), ERRPASS, 0);
BAIL_IF_ERRPASS(!io->seek(io, pos + 4), 0);
/* number of this disk */
BAIL_IF_MACRO(!readui16(io, &ui16), ERRPASS, 0);
BAIL_IF_MACRO(ui16 != 0, PHYSFS_ERR_CORRUPT, 0);
BAIL_IF_ERRPASS(!readui16(io, &ui16), 0);
BAIL_IF(ui16 != 0, PHYSFS_ERR_CORRUPT, 0);
/* number of the disk with the start of the central directory */
BAIL_IF_MACRO(!readui16(io, &ui16), ERRPASS, 0);
BAIL_IF_MACRO(ui16 != 0, PHYSFS_ERR_CORRUPT, 0);
BAIL_IF_ERRPASS(!readui16(io, &ui16), 0);
BAIL_IF(ui16 != 0, PHYSFS_ERR_CORRUPT, 0);
/* total number of entries in the central dir on this disk */
BAIL_IF_MACRO(!readui16(io, &ui16), ERRPASS, 0);
BAIL_IF_ERRPASS(!readui16(io, &ui16), 0);
/* total number of entries in the central dir */
BAIL_IF_MACRO(!readui16(io, &entryCount16), ERRPASS, 0);
BAIL_IF_MACRO(ui16 != entryCount16, PHYSFS_ERR_CORRUPT, 0);
BAIL_IF_ERRPASS(!readui16(io, &entryCount16), 0);
BAIL_IF(ui16 != entryCount16, PHYSFS_ERR_CORRUPT, 0);
*entry_count = entryCount16;
/* size of the central directory */
BAIL_IF_MACRO(!readui32(io, &ui32), ERRPASS, 0);
BAIL_IF_ERRPASS(!readui32(io, &ui32), 0);
/* offset of central directory */
BAIL_IF_MACRO(!readui32(io, &offset32), ERRPASS, 0);
BAIL_IF_ERRPASS(!readui32(io, &offset32), 0);
*dir_ofs = (PHYSFS_uint64) offset32;
BAIL_IF_MACRO(pos < (*dir_ofs + ui32), PHYSFS_ERR_CORRUPT, 0);
BAIL_IF(pos < (*dir_ofs + ui32), PHYSFS_ERR_CORRUPT, 0);
/*
* For self-extracting archives, etc, there's crapola in the file
@ -1553,14 +1553,14 @@ static int zip_parse_end_of_central_dir(ZIPinfo *info,
*dir_ofs += *data_start;
/* zipfile comment length */
BAIL_IF_MACRO(!readui16(io, &ui16), ERRPASS, 0);
BAIL_IF_ERRPASS(!readui16(io, &ui16), 0);
/*
* Make sure that the comment length matches to the end of file...
* If it doesn't, we're either in the wrong part of the file, or the
* file is corrupted, but we give up either way.
*/
BAIL_IF_MACRO((pos + 22 + ui16) != len, PHYSFS_ERR_CORRUPT, 0);
BAIL_IF((pos + 22 + ui16) != len, PHYSFS_ERR_CORRUPT, 0);
return 1; /* made it. */
} /* zip_parse_end_of_central_dir */
@ -1576,7 +1576,7 @@ static int zip_alloc_hashtable(ZIPinfo *info, const PHYSFS_uint64 entry_count)
alloclen = info->hashBuckets * sizeof (ZIPentry *);
info->hash = (ZIPentry **) allocator.Malloc(alloclen);
BAIL_IF_MACRO(!info->hash, PHYSFS_ERR_OUT_OF_MEMORY, 0);
BAIL_IF(!info->hash, PHYSFS_ERR_OUT_OF_MEMORY, 0);
memset(info->hash, '\0', alloclen);
return 1;
@ -1593,11 +1593,11 @@ static void *ZIP_openArchive(PHYSFS_Io *io, const char *name, int forWriting)
assert(io != NULL); /* shouldn't ever happen. */
BAIL_IF_MACRO(forWriting, PHYSFS_ERR_READ_ONLY, NULL);
BAIL_IF_MACRO(!isZip(io), ERRPASS, NULL);
BAIL_IF(forWriting, PHYSFS_ERR_READ_ONLY, NULL);
BAIL_IF_ERRPASS(!isZip(io), NULL);
info = (ZIPinfo *) allocator.Malloc(sizeof (ZIPinfo));
BAIL_IF_MACRO(!info, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL_IF(!info, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
memset(info, '\0', sizeof (ZIPinfo));
info->root.resolved = ZIP_DIRECTORY;
info->io = io;
@ -1640,7 +1640,7 @@ static PHYSFS_Io *zip_get_io(PHYSFS_Io *io, ZIPinfo *inf, ZIPentry *entry)
{
int success;
PHYSFS_Io *retval = io->duplicate(io);
BAIL_IF_MACRO(!retval, ERRPASS, NULL);
BAIL_IF_ERRPASS(!retval, NULL);
/* !!! FIXME: if you open a dir here, it should bail ERR_NOT_A_FILE */
@ -1680,7 +1680,7 @@ static PHYSFS_Io *ZIP_openRead(void *opaque, const char *filename)
{
const PHYSFS_uint64 len = (PHYSFS_uint64) (ptr - filename);
char *str = (char *) __PHYSFS_smallAlloc(len + 1);
BAIL_IF_MACRO(!str, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL_IF(!str, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
memcpy(str, filename, len);
str[len] = '\0';
entry = zip_find_entry(info, str);
@ -1689,17 +1689,17 @@ static PHYSFS_Io *ZIP_openRead(void *opaque, const char *filename)
} /* if */
} /* if */
BAIL_IF_MACRO(!entry, ERRPASS, NULL);
BAIL_IF_ERRPASS(!entry, NULL);
retval = (PHYSFS_Io *) allocator.Malloc(sizeof (PHYSFS_Io));
GOTO_IF_MACRO(!retval, PHYSFS_ERR_OUT_OF_MEMORY, ZIP_openRead_failed);
GOTO_IF(!retval, PHYSFS_ERR_OUT_OF_MEMORY, ZIP_openRead_failed);
finfo = (ZIPfileinfo *) allocator.Malloc(sizeof (ZIPfileinfo));
GOTO_IF_MACRO(!finfo, PHYSFS_ERR_OUT_OF_MEMORY, ZIP_openRead_failed);
GOTO_IF(!finfo, PHYSFS_ERR_OUT_OF_MEMORY, ZIP_openRead_failed);
memset(finfo, '\0', sizeof (ZIPfileinfo));
io = zip_get_io(info->io, info, entry);
GOTO_IF_MACRO(!io, ERRPASS, ZIP_openRead_failed);
GOTO_IF_ERRPASS(!io, ZIP_openRead_failed);
finfo->io = io;
finfo->entry = ((entry->symlink != NULL) ? entry->symlink : entry);
initializeZStream(&finfo->stream);
@ -1708,17 +1708,17 @@ static PHYSFS_Io *ZIP_openRead(void *opaque, const char *filename)
{
finfo->buffer = (PHYSFS_uint8 *) allocator.Malloc(ZIP_READBUFSIZE);
if (!finfo->buffer)
GOTO_MACRO(PHYSFS_ERR_OUT_OF_MEMORY, ZIP_openRead_failed);
GOTO(PHYSFS_ERR_OUT_OF_MEMORY, ZIP_openRead_failed);
else if (zlib_err(inflateInit2(&finfo->stream, -MAX_WBITS)) != Z_OK)
goto ZIP_openRead_failed;
} /* if */
if (!zip_entry_is_tradional_crypto(entry))
GOTO_IF_MACRO(password != NULL, PHYSFS_ERR_BAD_PASSWORD, ZIP_openRead_failed);
GOTO_IF(password != NULL, PHYSFS_ERR_BAD_PASSWORD, ZIP_openRead_failed);
else
{
PHYSFS_uint8 crypto_header[12];
GOTO_IF_MACRO(password == NULL, PHYSFS_ERR_BAD_PASSWORD, ZIP_openRead_failed);
GOTO_IF(password == NULL, PHYSFS_ERR_BAD_PASSWORD, ZIP_openRead_failed);
if (io->read(io, crypto_header, 12) != 12)
goto ZIP_openRead_failed;
else if (!zip_prep_crypto_keys(finfo, crypto_header, password))
@ -1754,13 +1754,13 @@ ZIP_openRead_failed:
static PHYSFS_Io *ZIP_openWrite(void *opaque, const char *filename)
{
BAIL_MACRO(PHYSFS_ERR_READ_ONLY, NULL);
BAIL(PHYSFS_ERR_READ_ONLY, NULL);
} /* ZIP_openWrite */
static PHYSFS_Io *ZIP_openAppend(void *opaque, const char *filename)
{
BAIL_MACRO(PHYSFS_ERR_READ_ONLY, NULL);
BAIL(PHYSFS_ERR_READ_ONLY, NULL);
} /* ZIP_openAppend */
@ -1799,13 +1799,13 @@ static void ZIP_closeArchive(void *opaque)
static int ZIP_remove(void *opaque, const char *name)
{
BAIL_MACRO(PHYSFS_ERR_READ_ONLY, 0);
BAIL(PHYSFS_ERR_READ_ONLY, 0);
} /* ZIP_remove */
static int ZIP_mkdir(void *opaque, const char *name)
{
BAIL_MACRO(PHYSFS_ERR_READ_ONLY, 0);
BAIL(PHYSFS_ERR_READ_ONLY, 0);
} /* ZIP_mkdir */

290
src/physfs.c
View File

@ -154,11 +154,11 @@ PHYSFS_Io *__PHYSFS_createNativeIo(const char *path, const int mode)
assert((mode == 'r') || (mode == 'w') || (mode == 'a'));
io = (PHYSFS_Io *) allocator.Malloc(sizeof (PHYSFS_Io));
GOTO_IF_MACRO(!io, PHYSFS_ERR_OUT_OF_MEMORY, createNativeIo_failed);
GOTO_IF(!io, PHYSFS_ERR_OUT_OF_MEMORY, createNativeIo_failed);
info = (NativeIoInfo *) allocator.Malloc(sizeof (NativeIoInfo));
GOTO_IF_MACRO(!info, PHYSFS_ERR_OUT_OF_MEMORY, createNativeIo_failed);
GOTO_IF(!info, PHYSFS_ERR_OUT_OF_MEMORY, createNativeIo_failed);
pathdup = (char *) allocator.Malloc(strlen(path) + 1);
GOTO_IF_MACRO(!pathdup, PHYSFS_ERR_OUT_OF_MEMORY, createNativeIo_failed);
GOTO_IF(!pathdup, PHYSFS_ERR_OUT_OF_MEMORY, createNativeIo_failed);
if (mode == 'r')
handle = __PHYSFS_platformOpenRead(path);
@ -167,7 +167,7 @@ PHYSFS_Io *__PHYSFS_createNativeIo(const char *path, const int mode)
else if (mode == 'a')
handle = __PHYSFS_platformOpenAppend(path);
GOTO_IF_MACRO(!handle, ERRPASS, createNativeIo_failed);
GOTO_IF_ERRPASS(!handle, createNativeIo_failed);
strcpy(pathdup, path);
info->handle = handle;
@ -218,13 +218,13 @@ static PHYSFS_sint64 memoryIo_read(PHYSFS_Io *io, void *buf, PHYSFS_uint64 len)
static PHYSFS_sint64 memoryIo_write(PHYSFS_Io *io, const void *buffer,
PHYSFS_uint64 len)
{
BAIL_MACRO(PHYSFS_ERR_OPEN_FOR_READING, -1);
BAIL(PHYSFS_ERR_OPEN_FOR_READING, -1);
} /* memoryIo_write */
static int memoryIo_seek(PHYSFS_Io *io, PHYSFS_uint64 offset)
{
MemoryIoInfo *info = (MemoryIoInfo *) io->opaque;
BAIL_IF_MACRO(offset > info->len, PHYSFS_ERR_PAST_EOF, 0);
BAIL_IF(offset > info->len, PHYSFS_ERR_PAST_EOF, 0);
info->pos = offset;
return 1;
} /* memoryIo_seek */
@ -258,12 +258,12 @@ static PHYSFS_Io *memoryIo_duplicate(PHYSFS_Io *io)
/* we're the parent. */
retval = (PHYSFS_Io *) allocator.Malloc(sizeof (PHYSFS_Io));
BAIL_IF_MACRO(!retval, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL_IF(!retval, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
newinfo = (MemoryIoInfo *) allocator.Malloc(sizeof (MemoryIoInfo));
if (!newinfo)
{
allocator.Free(retval);
BAIL_MACRO(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
} /* if */
/* !!! FIXME: want lockless atomic increment. */
@ -346,9 +346,9 @@ PHYSFS_Io *__PHYSFS_createMemoryIo(const void *buf, PHYSFS_uint64 len,
MemoryIoInfo *info = NULL;
io = (PHYSFS_Io *) allocator.Malloc(sizeof (PHYSFS_Io));
GOTO_IF_MACRO(!io, PHYSFS_ERR_OUT_OF_MEMORY, createMemoryIo_failed);
GOTO_IF(!io, PHYSFS_ERR_OUT_OF_MEMORY, createMemoryIo_failed);
info = (MemoryIoInfo *) allocator.Malloc(sizeof (MemoryIoInfo));
GOTO_IF_MACRO(!info, PHYSFS_ERR_OUT_OF_MEMORY, createMemoryIo_failed);
GOTO_IF(!info, PHYSFS_ERR_OUT_OF_MEMORY, createMemoryIo_failed);
memset(info, '\0', sizeof (*info));
info->buf = (const PHYSFS_uint8 *) buf;
@ -407,24 +407,24 @@ static PHYSFS_Io *handleIo_duplicate(PHYSFS_Io *io)
FileHandle *newfh = (FileHandle *) allocator.Malloc(sizeof (FileHandle));
PHYSFS_Io *retval = NULL;
GOTO_IF_MACRO(!newfh, PHYSFS_ERR_OUT_OF_MEMORY, handleIo_dupe_failed);
GOTO_IF(!newfh, PHYSFS_ERR_OUT_OF_MEMORY, handleIo_dupe_failed);
memset(newfh, '\0', sizeof (*newfh));
retval = (PHYSFS_Io *) allocator.Malloc(sizeof (PHYSFS_Io));
GOTO_IF_MACRO(!retval, PHYSFS_ERR_OUT_OF_MEMORY, handleIo_dupe_failed);
GOTO_IF(!retval, PHYSFS_ERR_OUT_OF_MEMORY, handleIo_dupe_failed);
#if 0 /* we don't buffer the duplicate, at least not at the moment. */
if (origfh->buffer != NULL)
{
newfh->buffer = (PHYSFS_uint8 *) allocator.Malloc(origfh->bufsize);
if (!newfh->buffer)
GOTO_MACRO(PHYSFS_ERR_OUT_OF_MEMORY, handleIo_dupe_failed);
GOTO(PHYSFS_ERR_OUT_OF_MEMORY, handleIo_dupe_failed);
newfh->bufsize = origfh->bufsize;
} /* if */
#endif
newfh->io = origfh->io->duplicate(origfh->io);
GOTO_IF_MACRO(!newfh->io, ERRPASS, handleIo_dupe_failed);
GOTO_IF_ERRPASS(!newfh->io, handleIo_dupe_failed);
newfh->forReading = origfh->forReading;
newfh->dirHandle = origfh->dirHandle;
@ -485,7 +485,7 @@ static const PHYSFS_Io __PHYSFS_handleIoInterface =
static PHYSFS_Io *__PHYSFS_createHandleIo(PHYSFS_File *f)
{
PHYSFS_Io *io = (PHYSFS_Io *) allocator.Malloc(sizeof (PHYSFS_Io));
BAIL_IF_MACRO(!io, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL_IF(!io, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
memcpy(io, &__PHYSFS_handleIoInterface, sizeof (*io));
io->opaque = f;
return io;
@ -534,7 +534,7 @@ static char **doEnumStringList(void (*func)(PHYSFS_StringCallback, void *))
EnumStringListCallbackData ecd;
memset(&ecd, '\0', sizeof (ecd));
ecd.list = (char **) allocator.Malloc(sizeof (char *));
BAIL_IF_MACRO(!ecd.list, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL_IF(!ecd.list, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
func(enumStringListCallback, &ecd);
if (ecd.errcode)
@ -803,7 +803,7 @@ static DirHandle *tryOpenDir(PHYSFS_Io *io, const PHYSFS_Archiver *funcs,
void *opaque = NULL;
if (io != NULL)
BAIL_IF_MACRO(!io->seek(io, 0), ERRPASS, NULL);
BAIL_IF_ERRPASS(!io->seek(io, 0), NULL);
opaque = funcs->openArchive(io, d, forWriting);
if (opaque != NULL)
@ -842,7 +842,7 @@ static DirHandle *openDirectory(PHYSFS_Io *io, const char *d, int forWriting)
return retval;
io = __PHYSFS_createNativeIo(d, forWriting ? 'w' : 'r');
BAIL_IF_MACRO(!io, ERRPASS, 0);
BAIL_IF_ERRPASS(!io, 0);
created_io = 1;
} /* if */
@ -873,7 +873,7 @@ static DirHandle *openDirectory(PHYSFS_Io *io, const char *d, int forWriting)
if ((!retval) && (created_io))
io->destroy(io);
BAIL_IF_MACRO(!retval, PHYSFS_ERR_UNSUPPORTED, NULL);
BAIL_IF(!retval, PHYSFS_ERR_UNSUPPORTED, NULL);
return retval;
} /* openDirectory */
@ -900,13 +900,13 @@ static int sanitizePlatformIndependentPath(const char *src, char *dst)
ch = *(src++);
if ((ch == ':') || (ch == '\\')) /* illegal chars in a physfs path. */
BAIL_MACRO(PHYSFS_ERR_BAD_FILENAME, 0);
BAIL(PHYSFS_ERR_BAD_FILENAME, 0);
if (ch == '/') /* path separator. */
{
*dst = '\0'; /* "." and ".." are illegal pathnames. */
if ((strcmp(prev, ".") == 0) || (strcmp(prev, "..") == 0))
BAIL_MACRO(PHYSFS_ERR_BAD_FILENAME, 0);
BAIL(PHYSFS_ERR_BAD_FILENAME, 0);
while (*src == '/') /* chop out doubles... */
src++;
@ -972,14 +972,14 @@ static DirHandle *createDirHandle(PHYSFS_Io *io, const char *newDir,
{
const size_t len = strlen(mountPoint) + 1;
tmpmntpnt = (char *) __PHYSFS_smallAlloc(len);
GOTO_IF_MACRO(!tmpmntpnt, PHYSFS_ERR_OUT_OF_MEMORY, badDirHandle);
GOTO_IF(!tmpmntpnt, PHYSFS_ERR_OUT_OF_MEMORY, badDirHandle);
if (!sanitizePlatformIndependentPath(mountPoint, tmpmntpnt))
goto badDirHandle;
mountPoint = tmpmntpnt; /* sanitized version. */
} /* if */
dirHandle = openDirectory(io, newDir, forWriting);
GOTO_IF_MACRO(!dirHandle, ERRPASS, badDirHandle);
GOTO_IF_ERRPASS(!dirHandle, badDirHandle);
if (newDir == NULL)
dirHandle->dirName = NULL;
@ -987,7 +987,7 @@ static DirHandle *createDirHandle(PHYSFS_Io *io, const char *newDir,
{
dirHandle->dirName = (char *) allocator.Malloc(strlen(newDir) + 1);
if (!dirHandle->dirName)
GOTO_MACRO(PHYSFS_ERR_OUT_OF_MEMORY, badDirHandle);
GOTO(PHYSFS_ERR_OUT_OF_MEMORY, badDirHandle);
strcpy(dirHandle->dirName, newDir);
} /* else */
@ -995,7 +995,7 @@ static DirHandle *createDirHandle(PHYSFS_Io *io, const char *newDir,
{
dirHandle->mountPoint = (char *)allocator.Malloc(strlen(mountPoint)+2);
if (!dirHandle->mountPoint)
GOTO_MACRO(PHYSFS_ERR_OUT_OF_MEMORY, badDirHandle);
GOTO(PHYSFS_ERR_OUT_OF_MEMORY, badDirHandle);
strcpy(dirHandle->mountPoint, mountPoint);
strcat(dirHandle->mountPoint, "/");
} /* if */
@ -1026,7 +1026,7 @@ static int freeDirHandle(DirHandle *dh, FileHandle *openList)
return 1;
for (i = openList; i != NULL; i = i->next)
BAIL_IF_MACRO(i->dirHandle == dh, PHYSFS_ERR_FILES_STILL_OPEN, 0);
BAIL_IF(i->dirHandle == dh, PHYSFS_ERR_FILES_STILL_OPEN, 0);
dh->funcs->closeArchive(dh->opaque);
allocator.Free(dh->dirName);
@ -1048,21 +1048,21 @@ static char *calculateBaseDir(const char *argv0)
return retval;
/* We need argv0 to go on. */
BAIL_IF_MACRO(argv0 == NULL, PHYSFS_ERR_ARGV0_IS_NULL, NULL);
BAIL_IF(argv0 == NULL, PHYSFS_ERR_ARGV0_IS_NULL, NULL);
ptr = strrchr(argv0, dirsep);
if (ptr != NULL)
{
const size_t size = ((size_t) (ptr - argv0)) + 1;
retval = (char *) allocator.Malloc(size + 1);
BAIL_IF_MACRO(!retval, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL_IF(!retval, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
memcpy(retval, argv0, size);
retval[size] = '\0';
return retval;
} /* if */
/* argv0 wasn't helpful. */
BAIL_MACRO(PHYSFS_ERR_INVALID_ARGUMENT, NULL);
BAIL(PHYSFS_ERR_INVALID_ARGUMENT, NULL);
} /* calculateBaseDir */
@ -1143,7 +1143,7 @@ static int doDeinit(void);
int PHYSFS_init(const char *argv0)
{
BAIL_IF_MACRO(initialized, PHYSFS_ERR_IS_INITIALIZED, 0);
BAIL_IF(initialized, PHYSFS_ERR_IS_INITIALIZED, 0);
if (!externalAllocator)
setDefaultAllocator();
@ -1254,7 +1254,7 @@ static int doDeregisterArchiver(const size_t idx)
/* make sure nothing is still using this archiver */
if (archiverInUse(arc, searchPath) || archiverInUse(arc, writeDir))
BAIL_MACRO(PHYSFS_ERR_FILES_STILL_OPEN, 0);
BAIL(PHYSFS_ERR_FILES_STILL_OPEN, 0);
allocator.Free((void *) info->extension);
allocator.Free((void *) info->description);
@ -1291,7 +1291,7 @@ static void freeArchivers(void)
static int doDeinit(void)
{
closeFileHandleList(&openWriteList);
BAIL_IF_MACRO(!PHYSFS_setWriteDir(NULL), PHYSFS_ERR_FILES_STILL_OPEN, 0);
BAIL_IF(!PHYSFS_setWriteDir(NULL), PHYSFS_ERR_FILES_STILL_OPEN, 0);
freeSearchPath();
freeArchivers();
@ -1339,7 +1339,7 @@ static int doDeinit(void)
errorLock = stateLock = NULL;
/* !!! FIXME: what on earth are you supposed to do if this fails? */
BAIL_IF_MACRO(!__PHYSFS_platformDeinit(), ERRPASS, 0);
BAIL_IF_ERRPASS(!__PHYSFS_platformDeinit(), 0);
return 1;
} /* doDeinit */
@ -1347,7 +1347,7 @@ static int doDeinit(void)
int PHYSFS_deinit(void)
{
BAIL_IF_MACRO(!initialized, PHYSFS_ERR_NOT_INITIALIZED, 0);
BAIL_IF(!initialized, PHYSFS_ERR_NOT_INITIALIZED, 0);
return doDeinit();
} /* PHYSFS_deinit */
@ -1387,32 +1387,32 @@ static int doRegisterArchiver(const PHYSFS_Archiver *_archiver)
void *ptr = NULL;
size_t i;
BAIL_IF_MACRO(!_archiver, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF_MACRO(_archiver->version > maxver, PHYSFS_ERR_UNSUPPORTED, 0);
BAIL_IF_MACRO(!_archiver->info.extension, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF_MACRO(!_archiver->info.description, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF_MACRO(!_archiver->info.author, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF_MACRO(!_archiver->info.url, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF_MACRO(!_archiver->openArchive, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF_MACRO(!_archiver->enumerateFiles, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF_MACRO(!_archiver->openRead, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF_MACRO(!_archiver->openWrite, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF_MACRO(!_archiver->openAppend, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF_MACRO(!_archiver->remove, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF_MACRO(!_archiver->mkdir, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF_MACRO(!_archiver->closeArchive, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF_MACRO(!_archiver->stat, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF(!_archiver, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF(_archiver->version > maxver, PHYSFS_ERR_UNSUPPORTED, 0);
BAIL_IF(!_archiver->info.extension, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF(!_archiver->info.description, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF(!_archiver->info.author, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF(!_archiver->info.url, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF(!_archiver->openArchive, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF(!_archiver->enumerateFiles, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF(!_archiver->openRead, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF(!_archiver->openWrite, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF(!_archiver->openAppend, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF(!_archiver->remove, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF(!_archiver->mkdir, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF(!_archiver->closeArchive, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF(!_archiver->stat, PHYSFS_ERR_INVALID_ARGUMENT, 0);
ext = _archiver->info.extension;
for (i = 0; i < numArchivers; i++)
{
if (__PHYSFS_utf8stricmp(archiveInfo[i]->extension, ext) == 0)
BAIL_MACRO(PHYSFS_ERR_DUPLICATE, 0); /* !!! FIXME: better error? ERR_IN_USE? */
BAIL(PHYSFS_ERR_DUPLICATE, 0); /* !!! FIXME: better error? ERR_IN_USE? */
} /* for */
/* make a copy of the data. */
archiver = (PHYSFS_Archiver *) allocator.Malloc(sizeof (*archiver));
GOTO_IF_MACRO(!archiver, PHYSFS_ERR_OUT_OF_MEMORY, regfailed);
GOTO_IF(!archiver, PHYSFS_ERR_OUT_OF_MEMORY, regfailed);
/* Must copy sizeof (OLD_VERSION_OF_STRUCT) when version changes! */
memcpy(archiver, _archiver, sizeof (*archiver));
@ -1421,7 +1421,7 @@ static int doRegisterArchiver(const PHYSFS_Archiver *_archiver)
memset(info, '\0', sizeof (*info)); /* NULL in case an alloc fails. */
#define CPYSTR(item) \
info->item = __PHYSFS_strdup(_archiver->info.item); \
GOTO_IF_MACRO(!info->item, PHYSFS_ERR_OUT_OF_MEMORY, regfailed);
GOTO_IF(!info->item, PHYSFS_ERR_OUT_OF_MEMORY, regfailed);
CPYSTR(extension);
CPYSTR(description);
CPYSTR(author);
@ -1430,11 +1430,11 @@ static int doRegisterArchiver(const PHYSFS_Archiver *_archiver)
#undef CPYSTR
ptr = allocator.Realloc(archiveInfo, len);
GOTO_IF_MACRO(!ptr, PHYSFS_ERR_OUT_OF_MEMORY, regfailed);
GOTO_IF(!ptr, PHYSFS_ERR_OUT_OF_MEMORY, regfailed);
archiveInfo = (const PHYSFS_ArchiveInfo **) ptr;
ptr = allocator.Realloc(archivers, len);
GOTO_IF_MACRO(!ptr, PHYSFS_ERR_OUT_OF_MEMORY, regfailed);
GOTO_IF(!ptr, PHYSFS_ERR_OUT_OF_MEMORY, regfailed);
archivers = (const PHYSFS_Archiver **) ptr;
archiveInfo[numArchivers] = info;
@ -1464,7 +1464,7 @@ regfailed:
int PHYSFS_registerArchiver(const PHYSFS_Archiver *archiver)
{
int retval;
BAIL_IF_MACRO(!initialized, PHYSFS_ERR_NOT_INITIALIZED, 0);
BAIL_IF(!initialized, PHYSFS_ERR_NOT_INITIALIZED, 0);
__PHYSFS_platformGrabMutex(stateLock);
retval = doRegisterArchiver(archiver);
__PHYSFS_platformReleaseMutex(stateLock);
@ -1476,8 +1476,8 @@ int PHYSFS_deregisterArchiver(const char *ext)
{
size_t i;
BAIL_IF_MACRO(!initialized, PHYSFS_ERR_NOT_INITIALIZED, 0);
BAIL_IF_MACRO(!ext, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF(!initialized, PHYSFS_ERR_NOT_INITIALIZED, 0);
BAIL_IF(!ext, PHYSFS_ERR_INVALID_ARGUMENT, 0);
__PHYSFS_platformGrabMutex(stateLock);
for (i = 0; i < numArchivers; i++)
@ -1491,13 +1491,13 @@ int PHYSFS_deregisterArchiver(const char *ext)
} /* for */
__PHYSFS_platformReleaseMutex(stateLock);
BAIL_MACRO(PHYSFS_ERR_NOT_FOUND, 0);
BAIL(PHYSFS_ERR_NOT_FOUND, 0);
} /* PHYSFS_deregisterArchiver */
const PHYSFS_ArchiveInfo **PHYSFS_supportedArchiveTypes(void)
{
BAIL_IF_MACRO(!initialized, PHYSFS_ERR_NOT_INITIALIZED, NULL);
BAIL_IF(!initialized, PHYSFS_ERR_NOT_INITIALIZED, NULL);
return archiveInfo;
} /* PHYSFS_supportedArchiveTypes */
@ -1541,15 +1541,15 @@ const char *PHYSFS_getPrefDir(const char *org, const char *app)
char *ptr = NULL;
char *endstr = NULL;
BAIL_IF_MACRO(!initialized, PHYSFS_ERR_NOT_INITIALIZED, 0);
BAIL_IF_MACRO(!org, PHYSFS_ERR_INVALID_ARGUMENT, NULL);
BAIL_IF_MACRO(*org == '\0', PHYSFS_ERR_INVALID_ARGUMENT, NULL);
BAIL_IF_MACRO(!app, PHYSFS_ERR_INVALID_ARGUMENT, NULL);
BAIL_IF_MACRO(*app == '\0', PHYSFS_ERR_INVALID_ARGUMENT, NULL);
BAIL_IF(!initialized, PHYSFS_ERR_NOT_INITIALIZED, 0);
BAIL_IF(!org, PHYSFS_ERR_INVALID_ARGUMENT, NULL);
BAIL_IF(*org == '\0', PHYSFS_ERR_INVALID_ARGUMENT, NULL);
BAIL_IF(!app, PHYSFS_ERR_INVALID_ARGUMENT, NULL);
BAIL_IF(*app == '\0', PHYSFS_ERR_INVALID_ARGUMENT, NULL);
allocator.Free(prefDir);
prefDir = __PHYSFS_platformCalcPrefDir(org, app);
BAIL_IF_MACRO(!prefDir, ERRPASS, NULL);
BAIL_IF_ERRPASS(!prefDir, NULL);
assert(strlen(prefDir) > 0);
endstr = prefDir + (strlen(prefDir) - 1);
@ -1617,7 +1617,7 @@ int PHYSFS_setWriteDir(const char *newDir)
if (writeDir != NULL)
{
BAIL_IF_MACRO_MUTEX(!freeDirHandle(writeDir, openWriteList), ERRPASS,
BAIL_IF_MUTEX_ERRPASS(!freeDirHandle(writeDir, openWriteList),
stateLock, 0);
writeDir = NULL;
} /* if */
@ -1653,13 +1653,13 @@ static int doMount(PHYSFS_Io *io, const char *fname,
{
/* already in search path? */
if ((i->dirName != NULL) && (strcmp(fname, i->dirName) == 0))
BAIL_MACRO_MUTEX(ERRPASS, stateLock, 1);
BAIL_MUTEX_ERRPASS(stateLock, 1);
prev = i;
} /* for */
} /* if */
dh = createDirHandle(io, fname, mountPoint, 0);
BAIL_IF_MACRO_MUTEX(!dh, ERRPASS, stateLock, 0);
BAIL_IF_MUTEX_ERRPASS(!dh, stateLock, 0);
if (appendToPath)
{
@ -1682,8 +1682,8 @@ static int doMount(PHYSFS_Io *io, const char *fname,
int PHYSFS_mountIo(PHYSFS_Io *io, const char *fname,
const char *mountPoint, int appendToPath)
{
BAIL_IF_MACRO(!io, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF_MACRO(io->version != 0, PHYSFS_ERR_UNSUPPORTED, 0);
BAIL_IF(!io, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF(io->version != 0, PHYSFS_ERR_UNSUPPORTED, 0);
return doMount(io, fname, mountPoint, appendToPath);
} /* PHYSFS_mountIo */
@ -1695,10 +1695,10 @@ int PHYSFS_mountMemory(const void *buf, PHYSFS_uint64 len, void (*del)(void *),
int retval = 0;
PHYSFS_Io *io = NULL;
BAIL_IF_MACRO(!buf, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF(!buf, PHYSFS_ERR_INVALID_ARGUMENT, 0);
io = __PHYSFS_createMemoryIo(buf, len, del);
BAIL_IF_MACRO(!io, ERRPASS, 0);
BAIL_IF_ERRPASS(!io, 0);
retval = doMount(io, fname, mountPoint, appendToPath);
if (!retval)
{
@ -1718,10 +1718,10 @@ int PHYSFS_mountHandle(PHYSFS_File *file, const char *fname,
int retval = 0;
PHYSFS_Io *io = NULL;
BAIL_IF_MACRO(file == NULL, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF(file == NULL, PHYSFS_ERR_INVALID_ARGUMENT, 0);
io = __PHYSFS_createHandleIo(file);
BAIL_IF_MACRO(!io, ERRPASS, 0);
BAIL_IF_ERRPASS(!io, 0);
retval = doMount(io, fname, mountPoint, appendToPath);
if (!retval)
{
@ -1736,7 +1736,7 @@ int PHYSFS_mountHandle(PHYSFS_File *file, const char *fname,
int PHYSFS_mount(const char *newDir, const char *mountPoint, int appendToPath)
{
BAIL_IF_MACRO(!newDir, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF(!newDir, PHYSFS_ERR_INVALID_ARGUMENT, 0);
return doMount(NULL, newDir, mountPoint, appendToPath);
} /* PHYSFS_mount */
@ -1759,7 +1759,7 @@ int PHYSFS_unmount(const char *oldDir)
DirHandle *prev = NULL;
DirHandle *next = NULL;
BAIL_IF_MACRO(oldDir == NULL, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF(oldDir == NULL, PHYSFS_ERR_INVALID_ARGUMENT, 0);
__PHYSFS_platformGrabMutex(stateLock);
for (i = searchPath; i != NULL; i = i->next)
@ -1767,7 +1767,7 @@ int PHYSFS_unmount(const char *oldDir)
if (strcmp(i->dirName, oldDir) == 0)
{
next = i->next;
BAIL_IF_MACRO_MUTEX(!freeDirHandle(i, openReadList), ERRPASS,
BAIL_IF_MUTEX_ERRPASS(!freeDirHandle(i, openReadList),
stateLock, 0);
if (prev == NULL)
@ -1775,12 +1775,12 @@ int PHYSFS_unmount(const char *oldDir)
else
prev->next = next;
BAIL_MACRO_MUTEX(ERRPASS, stateLock, 1);
BAIL_MUTEX_ERRPASS(stateLock, 1);
} /* if */
prev = i;
} /* for */
BAIL_MACRO_MUTEX(PHYSFS_ERR_NOT_MOUNTED, stateLock, 0);
BAIL_MUTEX(PHYSFS_ERR_NOT_MOUNTED, stateLock, 0);
} /* PHYSFS_unmount */
@ -1805,7 +1805,7 @@ const char *PHYSFS_getMountPoint(const char *dir)
} /* for */
__PHYSFS_platformReleaseMutex(stateLock);
BAIL_MACRO(PHYSFS_ERR_NOT_MOUNTED, NULL);
BAIL(PHYSFS_ERR_NOT_MOUNTED, NULL);
} /* PHYSFS_getMountPoint */
@ -1846,15 +1846,15 @@ int PHYSFS_setSaneConfig(const char *organization, const char *appName,
const char *basedir;
const char *prefdir;
BAIL_IF_MACRO(!initialized, PHYSFS_ERR_NOT_INITIALIZED, 0);
BAIL_IF(!initialized, PHYSFS_ERR_NOT_INITIALIZED, 0);
prefdir = PHYSFS_getPrefDir(organization, appName);
BAIL_IF_MACRO(!prefdir, ERRPASS, 0);
BAIL_IF_ERRPASS(!prefdir, 0);
basedir = PHYSFS_getBaseDir();
BAIL_IF_MACRO(!basedir, ERRPASS, 0);
BAIL_IF_ERRPASS(!basedir, 0);
BAIL_IF_MACRO(!PHYSFS_setWriteDir(prefdir), PHYSFS_ERR_NO_WRITE_DIR, 0);
BAIL_IF(!PHYSFS_setWriteDir(prefdir), PHYSFS_ERR_NO_WRITE_DIR, 0);
/* Put write dir first in search path... */
PHYSFS_mount(prefdir, NULL, 0);
@ -1947,12 +1947,12 @@ static int verifyPath(DirHandle *h, char **_fname, int allowMissing)
size_t len = strlen(fname);
assert(mntpntlen > 1); /* root mount points should be NULL. */
/* not under the mountpoint, so skip this archive. */
BAIL_IF_MACRO(len < mntpntlen-1, PHYSFS_ERR_NOT_FOUND, 0);
BAIL_IF(len < mntpntlen-1, PHYSFS_ERR_NOT_FOUND, 0);
/* !!! FIXME: Case insensitive? */
retval = strncmp(h->mountPoint, fname, mntpntlen-1);
BAIL_IF_MACRO(retval != 0, PHYSFS_ERR_NOT_FOUND, 0);
BAIL_IF(retval != 0, PHYSFS_ERR_NOT_FOUND, 0);
if (len > mntpntlen-1) /* corner case... */
BAIL_IF_MACRO(fname[mntpntlen-1]!='/', PHYSFS_ERR_NOT_FOUND, 0);
BAIL_IF(fname[mntpntlen-1]!='/', PHYSFS_ERR_NOT_FOUND, 0);
fname += mntpntlen-1; /* move to start of actual archive path. */
if (*fname == '/')
fname++;
@ -1979,7 +1979,7 @@ static int verifyPath(DirHandle *h, char **_fname, int allowMissing)
if (end != NULL) *end = '/';
/* insecure path (has a disallowed symlink in it)? */
BAIL_IF_MACRO(rc, PHYSFS_ERR_SYMLINK_FORBIDDEN, 0);
BAIL_IF(rc, PHYSFS_ERR_SYMLINK_FORBIDDEN, 0);
/* break out early if path element is missing. */
if (!retval)
@ -2013,12 +2013,12 @@ static int doMkdir(const char *_dname, char *dname)
int retval = 0;
int exists = 1; /* force existance check on first path element. */
BAIL_IF_MACRO(!sanitizePlatformIndependentPath(_dname, dname), ERRPASS, 0);
BAIL_IF_ERRPASS(!sanitizePlatformIndependentPath(_dname, dname), 0);
__PHYSFS_platformGrabMutex(stateLock);
BAIL_IF_MACRO_MUTEX(!writeDir, PHYSFS_ERR_NO_WRITE_DIR, stateLock, 0);
BAIL_IF_MUTEX(!writeDir, PHYSFS_ERR_NO_WRITE_DIR, stateLock, 0);
h = writeDir;
BAIL_IF_MACRO_MUTEX(!verifyPath(h, &dname, 1), ERRPASS, stateLock, 0);
BAIL_IF_MUTEX_ERRPASS(!verifyPath(h, &dname, 1), stateLock, 0);
start = dname;
while (1)
@ -2061,10 +2061,10 @@ int PHYSFS_mkdir(const char *_dname)
char *dname;
size_t len;
BAIL_IF_MACRO(!_dname, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF(!_dname, PHYSFS_ERR_INVALID_ARGUMENT, 0);
len = strlen(_dname) + 1;
dname = (char *) __PHYSFS_smallAlloc(len);
BAIL_IF_MACRO(!dname, PHYSFS_ERR_OUT_OF_MEMORY, 0);
BAIL_IF(!dname, PHYSFS_ERR_OUT_OF_MEMORY, 0);
retval = doMkdir(_dname, dname);
__PHYSFS_smallFree(dname);
return retval;
@ -2075,13 +2075,13 @@ static int doDelete(const char *_fname, char *fname)
{
int retval;
DirHandle *h;
BAIL_IF_MACRO(!sanitizePlatformIndependentPath(_fname, fname), ERRPASS, 0);
BAIL_IF_ERRPASS(!sanitizePlatformIndependentPath(_fname, fname), 0);
__PHYSFS_platformGrabMutex(stateLock);
BAIL_IF_MACRO_MUTEX(!writeDir, PHYSFS_ERR_NO_WRITE_DIR, stateLock, 0);
BAIL_IF_MUTEX(!writeDir, PHYSFS_ERR_NO_WRITE_DIR, stateLock, 0);
h = writeDir;
BAIL_IF_MACRO_MUTEX(!verifyPath(h, &fname, 0), ERRPASS, stateLock, 0);
BAIL_IF_MUTEX_ERRPASS(!verifyPath(h, &fname, 0), stateLock, 0);
retval = h->funcs->remove(h->opaque, fname);
__PHYSFS_platformReleaseMutex(stateLock);
@ -2095,10 +2095,10 @@ int PHYSFS_delete(const char *_fname)
char *fname;
size_t len;
BAIL_IF_MACRO(!_fname, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF(!_fname, PHYSFS_ERR_INVALID_ARGUMENT, 0);
len = strlen(_fname) + 1;
fname = (char *) __PHYSFS_smallAlloc(len);
BAIL_IF_MACRO(!fname, PHYSFS_ERR_OUT_OF_MEMORY, 0);
BAIL_IF(!fname, PHYSFS_ERR_OUT_OF_MEMORY, 0);
retval = doDelete(_fname, fname);
__PHYSFS_smallFree(fname);
return retval;
@ -2111,10 +2111,10 @@ const char *PHYSFS_getRealDir(const char *_fname)
char *fname = NULL;
size_t len;
BAIL_IF_MACRO(!_fname, PHYSFS_ERR_INVALID_ARGUMENT, NULL);
BAIL_IF(!_fname, PHYSFS_ERR_INVALID_ARGUMENT, NULL);
len = strlen(_fname) + 1;
fname = __PHYSFS_smallAlloc(len);
BAIL_IF_MACRO(!fname, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL_IF(!fname, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
if (sanitizePlatformIndependentPath(_fname, fname))
{
DirHandle *i;
@ -2218,7 +2218,7 @@ char **PHYSFS_enumerateFiles(const char *path)
EnumStringListCallbackData ecd;
memset(&ecd, '\0', sizeof (ecd));
ecd.list = (char **) allocator.Malloc(sizeof (char *));
BAIL_IF_MACRO(!ecd.list, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL_IF(!ecd.list, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
PHYSFS_enumerateFilesCallback(path, enumFilesCallback, &ecd);
ecd.list[ecd.size] = NULL;
return ecd.list;
@ -2293,12 +2293,12 @@ void PHYSFS_enumerateFilesCallback(const char *_fname,
size_t len;
char *fname;
BAIL_IF_MACRO(!_fname, PHYSFS_ERR_INVALID_ARGUMENT, ) /*0*/;
BAIL_IF_MACRO(!callback, PHYSFS_ERR_INVALID_ARGUMENT, ) /*0*/;
BAIL_IF(!_fname, PHYSFS_ERR_INVALID_ARGUMENT, ) /*0*/;
BAIL_IF(!callback, PHYSFS_ERR_INVALID_ARGUMENT, ) /*0*/;
len = strlen(_fname) + 1;
fname = (char *) __PHYSFS_smallAlloc(len);
BAIL_IF_MACRO(!fname, PHYSFS_ERR_OUT_OF_MEMORY, ) /*0*/;
BAIL_IF(!fname, PHYSFS_ERR_OUT_OF_MEMORY, ) /*0*/;
if (sanitizePlatformIndependentPath(_fname, fname))
{
@ -2352,7 +2352,7 @@ int PHYSFS_exists(const char *fname)
PHYSFS_sint64 PHYSFS_getLastModTime(const char *fname)
{
PHYSFS_Stat statbuf;
BAIL_IF_MACRO(!PHYSFS_stat(fname, &statbuf), ERRPASS, -1);
BAIL_IF_ERRPASS(!PHYSFS_stat(fname, &statbuf), -1);
return statbuf.modtime;
} /* PHYSFS_getLastModTime */
@ -2360,7 +2360,7 @@ PHYSFS_sint64 PHYSFS_getLastModTime(const char *fname)
int PHYSFS_isDirectory(const char *fname)
{
PHYSFS_Stat statbuf;
BAIL_IF_MACRO(!PHYSFS_stat(fname, &statbuf), ERRPASS, 0);
BAIL_IF_ERRPASS(!PHYSFS_stat(fname, &statbuf), 0);
return (statbuf.filetype == PHYSFS_FILETYPE_DIRECTORY);
} /* PHYSFS_isDirectory */
@ -2368,7 +2368,7 @@ int PHYSFS_isDirectory(const char *fname)
int PHYSFS_isSymbolicLink(const char *fname)
{
PHYSFS_Stat statbuf;
BAIL_IF_MACRO(!PHYSFS_stat(fname, &statbuf), ERRPASS, 0);
BAIL_IF_ERRPASS(!PHYSFS_stat(fname, &statbuf), 0);
return (statbuf.filetype == PHYSFS_FILETYPE_SYMLINK);
} /* PHYSFS_isSymbolicLink */
@ -2379,10 +2379,10 @@ static PHYSFS_File *doOpenWrite(const char *_fname, int appending)
size_t len;
char *fname;
BAIL_IF_MACRO(!_fname, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF(!_fname, PHYSFS_ERR_INVALID_ARGUMENT, 0);
len = strlen(_fname) + 1;
fname = (char *) __PHYSFS_smallAlloc(len);
BAIL_IF_MACRO(!fname, PHYSFS_ERR_OUT_OF_MEMORY, 0);
BAIL_IF(!fname, PHYSFS_ERR_OUT_OF_MEMORY, 0);
if (sanitizePlatformIndependentPath(_fname, fname))
{
@ -2392,10 +2392,10 @@ static PHYSFS_File *doOpenWrite(const char *_fname, int appending)
__PHYSFS_platformGrabMutex(stateLock);
GOTO_IF_MACRO(!writeDir, PHYSFS_ERR_NO_WRITE_DIR, doOpenWriteEnd);
GOTO_IF(!writeDir, PHYSFS_ERR_NO_WRITE_DIR, doOpenWriteEnd);
h = writeDir;
GOTO_IF_MACRO(!verifyPath(h, &fname, 0), ERRPASS, doOpenWriteEnd);
GOTO_IF_ERRPASS(!verifyPath(h, &fname, 0), doOpenWriteEnd);
f = h->funcs;
if (appending)
@ -2403,13 +2403,13 @@ static PHYSFS_File *doOpenWrite(const char *_fname, int appending)
else
io = f->openWrite(h->opaque, fname);
GOTO_IF_MACRO(!io, ERRPASS, doOpenWriteEnd);
GOTO_IF_ERRPASS(!io, doOpenWriteEnd);
fh = (FileHandle *) allocator.Malloc(sizeof (FileHandle));
if (fh == NULL)
{
io->destroy(io);
GOTO_MACRO(PHYSFS_ERR_OUT_OF_MEMORY, doOpenWriteEnd);
GOTO(PHYSFS_ERR_OUT_OF_MEMORY, doOpenWriteEnd);
} /* if */
else
{
@ -2447,10 +2447,10 @@ PHYSFS_File *PHYSFS_openRead(const char *_fname)
char *fname;
size_t len;
BAIL_IF_MACRO(!_fname, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF(!_fname, PHYSFS_ERR_INVALID_ARGUMENT, 0);
len = strlen(_fname) + 1;
fname = (char *) __PHYSFS_smallAlloc(len);
BAIL_IF_MACRO(!fname, PHYSFS_ERR_OUT_OF_MEMORY, 0);
BAIL_IF(!fname, PHYSFS_ERR_OUT_OF_MEMORY, 0);
if (sanitizePlatformIndependentPath(_fname, fname))
{
@ -2459,7 +2459,7 @@ PHYSFS_File *PHYSFS_openRead(const char *_fname)
__PHYSFS_platformGrabMutex(stateLock);
GOTO_IF_MACRO(!searchPath, PHYSFS_ERR_NOT_FOUND, openReadEnd);
GOTO_IF(!searchPath, PHYSFS_ERR_NOT_FOUND, openReadEnd);
for (i = searchPath; i != NULL; i = i->next)
{
@ -2472,13 +2472,13 @@ PHYSFS_File *PHYSFS_openRead(const char *_fname)
} /* if */
} /* for */
GOTO_IF_MACRO(!io, ERRPASS, openReadEnd);
GOTO_IF_ERRPASS(!io, openReadEnd);
fh = (FileHandle *) allocator.Malloc(sizeof (FileHandle));
if (fh == NULL)
{
io->destroy(io);
GOTO_MACRO(PHYSFS_ERR_OUT_OF_MEMORY, openReadEnd);
GOTO(PHYSFS_ERR_OUT_OF_MEMORY, openReadEnd);
} /* if */
memset(fh, '\0', sizeof (FileHandle));
@ -2541,15 +2541,15 @@ int PHYSFS_close(PHYSFS_File *_handle)
/* -1 == close failure. 0 == not found. 1 == success. */
rc = closeHandleInOpenList(&openReadList, handle);
BAIL_IF_MACRO_MUTEX(rc == -1, ERRPASS, stateLock, 0);
BAIL_IF_MUTEX_ERRPASS(rc == -1, stateLock, 0);
if (!rc)
{
rc = closeHandleInOpenList(&openWriteList, handle);
BAIL_IF_MACRO_MUTEX(rc == -1, ERRPASS, stateLock, 0);
BAIL_IF_MUTEX_ERRPASS(rc == -1, stateLock, 0);
} /* if */
__PHYSFS_platformReleaseMutex(stateLock);
BAIL_IF_MACRO(!rc, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF(!rc, PHYSFS_ERR_INVALID_ARGUMENT, 0);
return 1;
} /* PHYSFS_close */
@ -2632,11 +2632,11 @@ PHYSFS_sint64 PHYSFS_readBytes(PHYSFS_File *handle, void *buffer,
#endif
if (!__PHYSFS_ui64FitsAddressSpace(len))
BAIL_MACRO(PHYSFS_ERR_INVALID_ARGUMENT, -1);
BAIL(PHYSFS_ERR_INVALID_ARGUMENT, -1);
BAIL_IF_MACRO(len > maxlen, PHYSFS_ERR_INVALID_ARGUMENT, -1);
BAIL_IF_MACRO(!fh->forReading, PHYSFS_ERR_OPEN_FOR_WRITING, -1);
BAIL_IF_MACRO(len == 0, ERRPASS, 0);
BAIL_IF(len > maxlen, PHYSFS_ERR_INVALID_ARGUMENT, -1);
BAIL_IF(!fh->forReading, PHYSFS_ERR_OPEN_FOR_WRITING, -1);
BAIL_IF_ERRPASS(len == 0, 0);
if (fh->buffer)
return doBufferedRead(fh, buffer, len);
@ -2658,7 +2658,7 @@ static PHYSFS_sint64 doBufferedWrite(PHYSFS_File *handle, const void *buffer,
} /* if */
/* would overflow buffer. Flush and then write the new objects, too. */
BAIL_IF_MACRO(!PHYSFS_flush(handle), ERRPASS, -1);
BAIL_IF_ERRPASS(!PHYSFS_flush(handle), -1);
return fh->io->write(fh->io, buffer, len);
} /* doBufferedWrite */
@ -2684,11 +2684,11 @@ PHYSFS_sint64 PHYSFS_writeBytes(PHYSFS_File *handle, const void *buffer,
#endif
if (!__PHYSFS_ui64FitsAddressSpace(len))
BAIL_MACRO(PHYSFS_ERR_INVALID_ARGUMENT, -1);
BAIL(PHYSFS_ERR_INVALID_ARGUMENT, -1);
BAIL_IF_MACRO(len > maxlen, PHYSFS_ERR_INVALID_ARGUMENT, -1);
BAIL_IF_MACRO(fh->forReading, PHYSFS_ERR_OPEN_FOR_READING, -1);
BAIL_IF_MACRO(len == 0, ERRPASS, 0);
BAIL_IF(len > maxlen, PHYSFS_ERR_INVALID_ARGUMENT, -1);
BAIL_IF(fh->forReading, PHYSFS_ERR_OPEN_FOR_READING, -1);
BAIL_IF_ERRPASS(len == 0, 0);
if (fh->buffer)
return doBufferedWrite(handle, buffer, len);
@ -2733,7 +2733,7 @@ PHYSFS_sint64 PHYSFS_tell(PHYSFS_File *handle)
int PHYSFS_seek(PHYSFS_File *handle, PHYSFS_uint64 pos)
{
FileHandle *fh = (FileHandle *) handle;
BAIL_IF_MACRO(!PHYSFS_flush(handle), ERRPASS, 0);
BAIL_IF_ERRPASS(!PHYSFS_flush(handle), 0);
if (fh->buffer && fh->forReading)
{
@ -2767,11 +2767,11 @@ int PHYSFS_setBuffer(PHYSFS_File *handle, PHYSFS_uint64 _bufsize)
PHYSFS_uint32 bufsize;
/* !!! FIXME: actually, why use 32 bits here? */
/*BAIL_IF_MACRO(_bufsize > 0xFFFFFFFF, "buffer must fit in 32-bits", 0);*/
BAIL_IF_MACRO(_bufsize > __PHYSFS_UI64(0xFFFFFFFF), PHYSFS_ERR_INVALID_ARGUMENT, 0);
/*BAIL_IF(_bufsize > 0xFFFFFFFF, "buffer must fit in 32-bits", 0);*/
BAIL_IF(_bufsize > __PHYSFS_UI64(0xFFFFFFFF), PHYSFS_ERR_INVALID_ARGUMENT, 0);
bufsize = (PHYSFS_uint32) _bufsize;
BAIL_IF_MACRO(!PHYSFS_flush(handle), ERRPASS, 0);
BAIL_IF_ERRPASS(!PHYSFS_flush(handle), 0);
/*
* For reads, we need to move the file pointer to where it would be
@ -2782,9 +2782,9 @@ int PHYSFS_setBuffer(PHYSFS_File *handle, PHYSFS_uint64 _bufsize)
{
PHYSFS_uint64 pos;
const PHYSFS_sint64 curpos = fh->io->tell(fh->io);
BAIL_IF_MACRO(curpos == -1, ERRPASS, 0);
BAIL_IF_ERRPASS(curpos == -1, 0);
pos = ((curpos - fh->buffill) + fh->bufpos);
BAIL_IF_MACRO(!fh->io->seek(fh->io, pos), ERRPASS, 0);
BAIL_IF_ERRPASS(!fh->io->seek(fh->io, pos), 0);
} /* if */
if (bufsize == 0) /* delete existing buffer. */
@ -2800,7 +2800,7 @@ int PHYSFS_setBuffer(PHYSFS_File *handle, PHYSFS_uint64 _bufsize)
{
PHYSFS_uint8 *newbuf;
newbuf = (PHYSFS_uint8 *) allocator.Realloc(fh->buffer, bufsize);
BAIL_IF_MACRO(!newbuf, PHYSFS_ERR_OUT_OF_MEMORY, 0);
BAIL_IF(!newbuf, PHYSFS_ERR_OUT_OF_MEMORY, 0);
fh->buffer = newbuf;
} /* else */
@ -2822,7 +2822,7 @@ int PHYSFS_flush(PHYSFS_File *handle)
/* dump buffer to disk. */
io = fh->io;
rc = io->write(io, fh->buffer + fh->bufpos, fh->buffill - fh->bufpos);
BAIL_IF_MACRO(rc <= 0, ERRPASS, 0);
BAIL_IF_ERRPASS(rc <= 0, 0);
fh->bufpos = fh->buffill = 0;
return io->flush ? io->flush(io) : 1;
} /* PHYSFS_flush */
@ -2834,11 +2834,11 @@ int PHYSFS_stat(const char *_fname, PHYSFS_Stat *stat)
char *fname;
size_t len;
BAIL_IF_MACRO(!_fname, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF_MACRO(!stat, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF(!_fname, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF(!stat, PHYSFS_ERR_INVALID_ARGUMENT, 0);
len = strlen(_fname) + 1;
fname = (char *) __PHYSFS_smallAlloc(len);
BAIL_IF_MACRO(!fname, PHYSFS_ERR_OUT_OF_MEMORY, 0);
BAIL_IF(!fname, PHYSFS_ERR_OUT_OF_MEMORY, 0);
/* set some sane defaults... */
stat->filesize = -1;
@ -2930,7 +2930,7 @@ void __PHYSFS_smallFree(void *ptr)
int PHYSFS_setAllocator(const PHYSFS_Allocator *a)
{
BAIL_IF_MACRO(initialized, PHYSFS_ERR_IS_INITIALIZED, 0);
BAIL_IF(initialized, PHYSFS_ERR_IS_INITIALIZED, 0);
externalAllocator = (a != NULL);
if (externalAllocator)
memcpy(&allocator, a, sizeof (PHYSFS_Allocator));
@ -2941,7 +2941,7 @@ int PHYSFS_setAllocator(const PHYSFS_Allocator *a)
const PHYSFS_Allocator *PHYSFS_getAllocator(void)
{
BAIL_IF_MACRO(!initialized, PHYSFS_ERR_NOT_INITIALIZED, NULL);
BAIL_IF(!initialized, PHYSFS_ERR_NOT_INITIALIZED, NULL);
return &allocator;
} /* PHYSFS_getAllocator */
@ -2949,7 +2949,7 @@ const PHYSFS_Allocator *PHYSFS_getAllocator(void)
static void *mallocAllocatorMalloc(PHYSFS_uint64 s)
{
if (!__PHYSFS_ui64FitsAddressSpace(s))
BAIL_MACRO(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
#undef malloc
return malloc((size_t) s);
} /* mallocAllocatorMalloc */
@ -2958,7 +2958,7 @@ static void *mallocAllocatorMalloc(PHYSFS_uint64 s)
static void *mallocAllocatorRealloc(void *ptr, PHYSFS_uint64 s)
{
if (!__PHYSFS_ui64FitsAddressSpace(s))
BAIL_MACRO(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
#undef realloc
return realloc(ptr, (size_t) s);
} /* mallocAllocatorRealloc */

6
src/physfs_byteorder.c
View File

@ -88,8 +88,8 @@ static inline int readAll(PHYSFS_File *file, void *val, const size_t len)
#define PHYSFS_BYTEORDER_READ(datatype, swaptype) \
int PHYSFS_read##swaptype(PHYSFS_File *file, PHYSFS_##datatype *val) { \
PHYSFS_##datatype in; \
BAIL_IF_MACRO(val == NULL, PHYSFS_ERR_INVALID_ARGUMENT, 0); \
BAIL_IF_MACRO(!readAll(file, &in, sizeof (in)), ERRPASS, 0); \
BAIL_IF(val == NULL, PHYSFS_ERR_INVALID_ARGUMENT, 0); \
BAIL_IF_ERRPASS(!readAll(file, &in, sizeof (in)), 0); \
*val = PHYSFS_swap##swaptype(in); \
return 1; \
}
@ -116,7 +116,7 @@ static inline int writeAll(PHYSFS_File *f, const void *val, const size_t len)
#define PHYSFS_BYTEORDER_WRITE(datatype, swaptype) \
int PHYSFS_write##swaptype(PHYSFS_File *file, PHYSFS_##datatype val) { \
const PHYSFS_##datatype out = PHYSFS_swap##swaptype(val); \
BAIL_IF_MACRO(!writeAll(file, &out, sizeof (out)), ERRPASS, 0); \
BAIL_IF_ERRPASS(!writeAll(file, &out, sizeof (out)), 0); \
return 1; \
}

32
src/physfs_internal.h
View File

@ -172,21 +172,25 @@ void __PHYSFS_sort(void *entries, size_t max,
int (*cmpfn)(void *, size_t, size_t),
void (*swapfn)(void *, size_t, size_t));
/*
* This isn't a formal error code, it's just for BAIL_MACRO.
* It means: there was an error, but someone else already set it for us.
*/
#define ERRPASS PHYSFS_ERR_OK
/* These get used all over for lessening code clutter. */
#define BAIL_MACRO(e, r) do { if (e) PHYSFS_setErrorCode(e); return r; } while (0)
#define BAIL_IF_MACRO(c, e, r) do { if (c) { if (e) PHYSFS_setErrorCode(e); return r; } } while (0)
#define BAIL_MACRO_MUTEX(e, m, r) do { if (e) PHYSFS_setErrorCode(e); __PHYSFS_platformReleaseMutex(m); return r; } while (0)
#define BAIL_IF_MACRO_MUTEX(c, e, m, r) do { if (c) { if (e) PHYSFS_setErrorCode(e); __PHYSFS_platformReleaseMutex(m); return r; } } while (0)
#define GOTO_MACRO(e, g) do { if (e) PHYSFS_setErrorCode(e); goto g; } while (0)
#define GOTO_IF_MACRO(c, e, g) do { if (c) { if (e) PHYSFS_setErrorCode(e); goto g; } } while (0)
#define GOTO_MACRO_MUTEX(e, m, g) do { if (e) PHYSFS_setErrorCode(e); __PHYSFS_platformReleaseMutex(m); goto g; } while (0)
#define GOTO_IF_MACRO_MUTEX(c, e, m, g) do { if (c) { if (e) PHYSFS_setErrorCode(e); __PHYSFS_platformReleaseMutex(m); goto g; } } while (0)
/* "ERRPASS" means "something else just set the error state for us" and is
just to make it clear where the responsibility for the error state lays. */
#define BAIL(e, r) do { if (e) PHYSFS_setErrorCode(e); return r; } while (0)
#define BAIL_ERRPASS(r) do { return r; } while (0)
#define BAIL_IF(c, e, r) do { if (c) { if (e) PHYSFS_setErrorCode(e); return r; } } while (0)
#define BAIL_IF_ERRPASS(c, r) do { if (c) { return r; } } while (0)
#define BAIL_MUTEX(e, m, r) do { if (e) PHYSFS_setErrorCode(e); __PHYSFS_platformReleaseMutex(m); return r; } while (0)
#define BAIL_MUTEX_ERRPASS(m, r) do { __PHYSFS_platformReleaseMutex(m); return r; } while (0)
#define BAIL_IF_MUTEX(c, e, m, r) do { if (c) { if (e) PHYSFS_setErrorCode(e); __PHYSFS_platformReleaseMutex(m); return r; } } while (0)
#define BAIL_IF_MUTEX_ERRPASS(c, m, r) do { if (c) { __PHYSFS_platformReleaseMutex(m); return r; } } while (0)
#define GOTO(e, g) do { if (e) PHYSFS_setErrorCode(e); goto g; } while (0)
#define GOTO_ERRPASS(g) do { goto g; } while (0)
#define GOTO_IF(c, e, g) do { if (c) { if (e) PHYSFS_setErrorCode(e); goto g; } } while (0)
#define GOTO_IF_ERRPASS(c, g) do { if (c) { goto g; } } while (0)
#define GOTO_MUTEX(e, m, g) do { if (e) PHYSFS_setErrorCode(e); __PHYSFS_platformReleaseMutex(m); goto g; } while (0)
#define GOTO_MUTEX_ERRPASS(m, g) do { __PHYSFS_platformReleaseMutex(m); goto g; } while (0)
#define GOTO_IF_MUTEX(c, e, m, g) do { if (c) { if (e) PHYSFS_setErrorCode(e); __PHYSFS_platformReleaseMutex(m); goto g; } } while (0)
#define GOTO_IF_MUTEX_ERRPASS(c, m, g) do { if (c) { __PHYSFS_platformReleaseMutex(m); goto g; } } while (0)
#define __PHYSFS_ARRAYLEN(x) ( (sizeof (x)) / (sizeof (x[0])) )

4
src/platform_beos.cpp
View File

@ -178,7 +178,7 @@ char *__PHYSFS_platformCalcBaseDir(const char *argv0)
assert(str != NULL);
const size_t len = strlen(str);
char *retval = (char *) allocator.Malloc(len + 2);
BAIL_IF_MACRO(!retval, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL_IF(!retval, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
strcpy(retval, str);
retval[len] = '/';
retval[len+1] = '\0';
@ -192,7 +192,7 @@ char *__PHYSFS_platformCalcPrefDir(const char *org, const char *app)
const char *append = "config/settings/";
const size_t len = strlen(userdir) + strlen(append) + strlen(app) + 2;
char *retval = allocator.Malloc(len);
BAIL_IF_MACRO(!retval, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL_IF(!retval, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
snprintf(retval, len, "%s%s%s/", userdir, append, app);
return retval;
} /* __PHYSFS_platformCalcPrefDir */

20
src/platform_macosx.c
View File

@ -70,7 +70,7 @@ int __PHYSFS_platformInit(void)
ctx.reallocate = cfallocRealloc;
ctx.deallocate = cfallocFree;
cfallocator = CFAllocatorCreate(kCFAllocatorUseContext, &ctx);
BAIL_IF_MACRO(!cfallocator, PHYSFS_ERR_OUT_OF_MEMORY, 0);
BAIL_IF(!cfallocator, PHYSFS_ERR_OUT_OF_MEMORY, 0);
return 1; /* success. */
} /* __PHYSFS_platformInit */
@ -180,7 +180,7 @@ void __PHYSFS_platformDetectAvailableCDs(PHYSFS_StringCallback cb, void *data)
int i, mounts;
if (IOMasterPort(MACH_PORT_NULL, &masterPort) != KERN_SUCCESS)
BAIL_MACRO(PHYSFS_ERR_OS_ERROR, ) /*return void*/;
BAIL(PHYSFS_ERR_OS_ERROR, ) /*return void*/;
mounts = getmntinfo(&mntbufp, MNT_WAIT); /* NOT THREAD SAFE! */
for (i = 0; i < mounts; i++)
@ -203,7 +203,7 @@ static char *convertCFString(CFStringRef cfstr)
CFIndex len = CFStringGetMaximumSizeForEncoding(CFStringGetLength(cfstr),
kCFStringEncodingUTF8) + 1;
char *retval = (char *) allocator.Malloc(len);
BAIL_IF_MACRO(!retval, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL_IF(!retval, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
if (CFStringGetCString(cfstr, retval, len, kCFStringEncodingUTF8))
{
@ -220,7 +220,7 @@ static char *convertCFString(CFStringRef cfstr)
else /* probably shouldn't fail, but just in case... */
{
allocator.Free(retval);
BAIL_MACRO(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
} /* else */
return retval;
@ -235,13 +235,13 @@ char *__PHYSFS_platformCalcBaseDir(const char *argv0)
char *retval = NULL;
cfurl = CFBundleCopyBundleURL(CFBundleGetMainBundle());
BAIL_IF_MACRO(cfurl == NULL, PHYSFS_ERR_OS_ERROR, NULL);
BAIL_IF(cfurl == NULL, PHYSFS_ERR_OS_ERROR, NULL);
cfstr = CFURLCopyFileSystemPath(cfurl, kCFURLPOSIXPathStyle);
CFRelease(cfurl);
BAIL_IF_MACRO(!cfstr, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL_IF(!cfstr, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
cfmutstr = CFStringCreateMutableCopy(cfallocator, 0, cfstr);
CFRelease(cfstr);
BAIL_IF_MACRO(!cfmutstr, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL_IF(!cfmutstr, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
CFStringAppendCString(cfmutstr, "/", kCFStringEncodingUTF8);
retval = convertCFString(cfmutstr);
CFRelease(cfmutstr);
@ -257,7 +257,7 @@ char *__PHYSFS_platformCalcPrefDir(const char *org, const char *app)
const char *append = "Library/Application Support/";
const size_t len = strlen(userdir) + strlen(append) + strlen(app) + 2;
char *retval = allocator.Malloc(len);
BAIL_IF_MACRO(!retval, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL_IF(!retval, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
snprintf(retval, len, "%s%s%s/", userdir, append, app);
return retval;
} /* __PHYSFS_platformCalcPrefDir */
@ -291,7 +291,7 @@ static void macosxAllocatorDeinit(void)
static void *macosxAllocatorMalloc(PHYSFS_uint64 s)
{
if (!__PHYSFS_ui64FitsAddressSpace(s))
BAIL_MACRO(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
return CFAllocatorAllocate(cfallocdef, (CFIndex) s, 0);
} /* macosxAllocatorMalloc */
@ -299,7 +299,7 @@ static void *macosxAllocatorMalloc(PHYSFS_uint64 s)
static void *macosxAllocatorRealloc(void *ptr, PHYSFS_uint64 s)
{
if (!__PHYSFS_ui64FitsAddressSpace(s))
BAIL_MACRO(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
return CFAllocatorReallocate(cfallocdef, ptr, (CFIndex) s, 0);
} /* macosxAllocatorRealloc */

62
src/platform_os2.c
View File

@ -205,7 +205,7 @@ void __PHYSFS_platformDetectAvailableCDs(PHYSFS_StringCallback cb, void *data)
ULONG drivemap = 0;
ULONG i, bit;
const APIRET rc = DosQueryCurrentDisk(&dummy, &drivemap);
BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc),);
BAIL_IF(rc != NO_ERROR, errcodeFromAPIRET(rc),);
for (i = 0, bit = 1; i < 26; i++, bit <<= 1)
{
@ -232,9 +232,9 @@ char *__PHYSFS_platformCalcBaseDir(const char *argv0)
PHYSFS_sint32 len;
rc = DosGetInfoBlocks(&ptib, &ppib);
BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc), 0);
BAIL_IF(rc != NO_ERROR, errcodeFromAPIRET(rc), 0);
rc = DosQueryModuleName(ppib->pib_hmte, sizeof (buf), (PCHAR) buf);
BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc), 0);
BAIL_IF(rc != NO_ERROR, errcodeFromAPIRET(rc), 0);
/* chop off filename, leave path. */
for (len = strlen(buf) - 1; len >= 0; len--)
@ -252,7 +252,7 @@ char *__PHYSFS_platformCalcBaseDir(const char *argv0)
cvt_path_to_correct_case(buf);
retval = (char *) allocator.Malloc(len + 1);
BAIL_IF_MACRO(retval == NULL, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL_IF(retval == NULL, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
strcpy(retval, buf);
return retval;
} /* __PHYSFS_platformCalcBaseDir */
@ -285,7 +285,7 @@ char *__PHYSFS_platformCvtToDependent(const char *prepend,
char *retval = allocator.Malloc(len);
char *p;
BAIL_IF_MACRO(retval == NULL, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL_IF(retval == NULL, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
if (prepend)
strcpy(retval, prepend);
@ -315,7 +315,7 @@ void __PHYSFS_platformEnumerateFiles(const char *dirname,
ULONG count = 1;
APIRET rc;
BAIL_IF_MACRO(strlen(dirname) > sizeof (spec) - 5, PHYSFS_ERR_BAD_FILENAME,);
BAIL_IF(strlen(dirname) > sizeof (spec) - 5, PHYSFS_ERR_BAD_FILENAME,);
strcpy(spec, dirname);
strcat(spec, (spec[strlen(spec) - 1] != '\\') ? "\\*.*" : "*.*");
@ -325,7 +325,7 @@ void __PHYSFS_platformEnumerateFiles(const char *dirname,
FILE_READONLY | FILE_HIDDEN | FILE_SYSTEM,
&fb, sizeof (fb), &count, FIL_STANDARD);
BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc),);
BAIL_IF(rc != NO_ERROR, errcodeFromAPIRET(rc),);
while (count == 1)
{
@ -349,20 +349,20 @@ char *__PHYSFS_platformCurrentDir(void)
BYTE byte;
rc = DosQueryCurrentDisk(&currentDisk, &dummy);
BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc), NULL);
BAIL_IF(rc != NO_ERROR, errcodeFromAPIRET(rc), NULL);
/* The first call just tells us how much space we need for the string. */
rc = DosQueryCurrentDir(currentDisk, &byte, &pathSize);
pathSize++; /* Add space for null terminator. */
retval = (char *) allocator.Malloc(pathSize + 3); /* plus "x:\\" */
BAIL_IF_MACRO(retval == NULL, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL_IF(retval == NULL, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
/* Actually get the string this time. */
rc = DosQueryCurrentDir(currentDisk, (PBYTE) (retval + 3), &pathSize);
if (rc != NO_ERROR)
{
allocator.Free(retval);
BAIL_MACRO(errcodeFromAPIRET(rc), NULL);
BAIL(errcodeFromAPIRET(rc), NULL);
} /* if */
retval[0] = ('A' + (currentDisk - 1));
@ -378,9 +378,9 @@ char *__PHYSFS_platformRealPath(const char *_path)
char buf[CCHMAXPATH];
char *retval;
APIRET rc = DosQueryPathInfo(path, FIL_QUERYFULLNAME, buf, sizeof (buf));
BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc), NULL);
BAIL_IF(rc != NO_ERROR, errcodeFromAPIRET(rc), NULL);
retval = (char *) allocator.Malloc(strlen(buf) + 1);
BAIL_IF_MACRO(retval == NULL, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL_IF(retval == NULL, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
strcpy(retval, buf);
return retval;
} /* __PHYSFS_platformRealPath */
@ -390,7 +390,7 @@ int __PHYSFS_platformMkDir(const char *_filename)
{
const unsigned char *filename = (const unsigned char *) _filename;
const APIRET rc = DosCreateDir(filename, NULL);
BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc), 0);
BAIL_IF(rc != NO_ERROR, errcodeFromAPIRET(rc), 0);
return 1;
} /* __PHYSFS_platformMkDir */
@ -410,7 +410,7 @@ void *__PHYSFS_platformOpenRead(const char *_filename)
OPEN_FLAGS_FAIL_ON_ERROR | OPEN_FLAGS_NO_LOCALITY |
OPEN_FLAGS_NOINHERIT | OPEN_SHARE_DENYWRITE |
OPEN_ACCESS_READONLY, NULL);
BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc), NULL);
BAIL_IF(rc != NO_ERROR, errcodeFromAPIRET(rc), NULL);
return ((void *) hfile);
} /* __PHYSFS_platformOpenRead */
@ -431,7 +431,7 @@ void *__PHYSFS_platformOpenWrite(const char *_filename)
OPEN_FLAGS_FAIL_ON_ERROR | OPEN_FLAGS_NO_LOCALITY |
OPEN_FLAGS_NOINHERIT | OPEN_SHARE_DENYWRITE |
OPEN_ACCESS_READWRITE, NULL);
BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc), NULL);
BAIL_IF(rc != NO_ERROR, errcodeFromAPIRET(rc), NULL);
return ((void *) hfile);
} /* __PHYSFS_platformOpenWrite */
@ -454,13 +454,13 @@ void *__PHYSFS_platformOpenAppend(const char *_filename)
OPEN_FLAGS_NOINHERIT | OPEN_SHARE_DENYWRITE |
OPEN_ACCESS_READWRITE, NULL);
BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc), NULL);
BAIL_IF(rc != NO_ERROR, errcodeFromAPIRET(rc), NULL);
rc = DosSetFilePtr(hfile, 0, FILE_END, &dummy);
if (rc != NO_ERROR)
{
DosClose(hfile);
BAIL_MACRO(errcodeFromAPIRET(rc), NULL);
BAIL(errcodeFromAPIRET(rc), NULL);
} /* if */
return ((void *) hfile);
@ -471,9 +471,9 @@ PHYSFS_sint64 __PHYSFS_platformRead(void *opaque, void *buf, PHYSFS_uint64 len)
{
ULONG br = 0;
APIRET rc;
BAIL_IF_MACRO(!__PHYSFS_ui64FitsAddressSpace(len),PHYSFS_ERR_INVALID_ARGUMENT,-1);
BAIL_IF(!__PHYSFS_ui64FitsAddressSpace(len),PHYSFS_ERR_INVALID_ARGUMENT,-1);
rc = DosRead((HFILE) opaque, buf, (ULONG) len, &br);
BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc), (br > 0) ? ((PHYSFS_sint64) br) : -1);
BAIL_IF(rc != NO_ERROR, errcodeFromAPIRET(rc), (br > 0) ? ((PHYSFS_sint64) br) : -1);
return (PHYSFS_sint64) br;
} /* __PHYSFS_platformRead */
@ -483,9 +483,9 @@ PHYSFS_sint64 __PHYSFS_platformWrite(void *opaque, const void *buf,
{
ULONG bw = 0;
APIRET rc;
BAIL_IF_MACRO(!__PHYSFS_ui64FitsAddressSpace(len),PHYSFS_ERR_INVALID_ARGUMENT,-1);
BAIL_IF(!__PHYSFS_ui64FitsAddressSpace(len),PHYSFS_ERR_INVALID_ARGUMENT,-1);
rc = DosWrite((HFILE) opaque, (void *) buf, (ULONG) len, &bw);
BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc), (bw > 0) ? ((PHYSFS_sint64) bw) : -1);
BAIL_IF(rc != NO_ERROR, errcodeFromAPIRET(rc), (bw > 0) ? ((PHYSFS_sint64) bw) : -1);
return (PHYSFS_sint64) bw;
} /* __PHYSFS_platformWrite */
@ -498,9 +498,9 @@ int __PHYSFS_platformSeek(void *opaque, PHYSFS_uint64 pos)
APIRET rc;
/* hooray for 32-bit filesystem limits! :) */
BAIL_IF_MACRO((PHYSFS_uint64) dist != pos, PHYSFS_ERR_INVALID_ARGUMENT, 0);
BAIL_IF((PHYSFS_uint64) dist != pos, PHYSFS_ERR_INVALID_ARGUMENT, 0);
rc = DosSetFilePtr(hfile, dist, FILE_BEGIN, &dummy);
BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc), 0);
BAIL_IF(rc != NO_ERROR, errcodeFromAPIRET(rc), 0);
return 1;
} /* __PHYSFS_platformSeek */
@ -510,7 +510,7 @@ PHYSFS_sint64 __PHYSFS_platformTell(void *opaque)
ULONG pos;
HFILE hfile = (HFILE) opaque;
const APIRET rc = DosSetFilePtr(hfile, 0, FILE_CURRENT, &pos);
BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc), -1);
BAIL_IF(rc != NO_ERROR, errcodeFromAPIRET(rc), -1);
return ((PHYSFS_sint64) pos);
} /* __PHYSFS_platformTell */
@ -520,7 +520,7 @@ PHYSFS_sint64 __PHYSFS_platformFileLength(void *opaque)
FILESTATUS3 fs;
HFILE hfile = (HFILE) opaque;
const APIRET rc = DosQueryFileInfo(hfile, FIL_STANDARD, &fs, sizeof (fs));
BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc), -1);
BAIL_IF(rc != NO_ERROR, errcodeFromAPIRET(rc), -1);
return ((PHYSFS_sint64) fs.cbFile);
} /* __PHYSFS_platformFileLength */
@ -528,7 +528,7 @@ PHYSFS_sint64 __PHYSFS_platformFileLength(void *opaque)
int __PHYSFS_platformFlush(void *opaque)
{
const APIRET rc = DosResetBuffer((HFILE) opaque);
BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc), 0);
BAIL_IF(rc != NO_ERROR, errcodeFromAPIRET(rc), 0);
return 1;
} /* __PHYSFS_platformFlush */
@ -544,9 +544,9 @@ int __PHYSFS_platformDelete(const char *_path)
FILESTATUS3 fs;
const unsigned char *path = (const unsigned char *) _path;
APIRET rc = DosQueryPathInfo(path, FIL_STANDARD, &fs, sizeof (fs));
BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc), 0);
BAIL_IF(rc != NO_ERROR, errcodeFromAPIRET(rc), 0);
rc = (fs.attrFile & FILE_DIRECTORY) ? DosDeleteDir(path) : DosDelete(path);
BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc), 0);
BAIL_IF(rc != NO_ERROR, errcodeFromAPIRET(rc), 0);
return 1;
} /* __PHYSFS_platformDelete */
@ -575,7 +575,7 @@ int __PHYSFS_platformStat(const char *filename, PHYSFS_Stat *stat)
FILESTATUS3 fs;
const unsigned char *fname = (const unsigned char *) filename;
const APIRET rc = DosQueryPathInfo(fname, FIL_STANDARD, &fs, sizeof (fs));
BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc), 0);
BAIL_IF(rc != NO_ERROR, errcodeFromAPIRET(rc), 0);
if (fs.attrFile & FILE_DIRECTORY)
{
@ -616,7 +616,7 @@ void *__PHYSFS_platformGetThreadID(void)
* default value (zero might as well do) if it does.
*/
const APIRET rc = DosGetInfoBlocks(&ptib, &ppib);
BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc), 0);
BAIL_IF(rc != NO_ERROR, errcodeFromAPIRET(rc), 0);
return ((void *) ptib->tib_ordinal);
} /* __PHYSFS_platformGetThreadID */
@ -625,7 +625,7 @@ void *__PHYSFS_platformCreateMutex(void)
{
HMTX hmtx = NULLHANDLE;
const APIRET rc = DosCreateMutexSem(NULL, &hmtx, 0, 0);
BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc), NULL);
BAIL_IF(rc != NO_ERROR, errcodeFromAPIRET(rc), NULL);
return ((void *) hmtx);
} /* __PHYSFS_platformCreateMutex */

32
src/platform_posix.c
View File

@ -156,7 +156,7 @@ void __PHYSFS_platformEnumerateFiles(const char *dirname,
int __PHYSFS_platformMkDir(const char *path)
{
const int rc = mkdir(path, S_IRWXU);
BAIL_IF_MACRO(rc == -1, errcodeFromErrno(), 0);
BAIL_IF(rc == -1, errcodeFromErrno(), 0);
return 1;
} /* __PHYSFS_platformMkDir */
@ -172,7 +172,7 @@ static void *doOpen(const char *filename, int mode)
mode &= ~O_APPEND;
fd = open(filename, mode, S_IRUSR | S_IWUSR);
BAIL_IF_MACRO(fd < 0, errcodeFromErrno(), NULL);
BAIL_IF(fd < 0, errcodeFromErrno(), NULL);
if (appending)
{
@ -180,7 +180,7 @@ static void *doOpen(const char *filename, int mode)
{
const int err = errno;
close(fd);
BAIL_MACRO(errcodeFromErrnoError(err), NULL);
BAIL(errcodeFromErrnoError(err), NULL);
} /* if */
} /* if */
@ -188,7 +188,7 @@ static void *doOpen(const char *filename, int mode)
if (!retval)
{
close(fd);
BAIL_MACRO(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
} /* if */
*retval = fd;
@ -221,10 +221,10 @@ PHYSFS_sint64 __PHYSFS_platformRead(void *opaque, void *buffer,
ssize_t rc = 0;
if (!__PHYSFS_ui64FitsAddressSpace(len))
BAIL_MACRO(PHYSFS_ERR_INVALID_ARGUMENT, -1);
BAIL(PHYSFS_ERR_INVALID_ARGUMENT, -1);
rc = read(fd, buffer, (size_t) len);
BAIL_IF_MACRO(rc == -1, errcodeFromErrno(), -1);
BAIL_IF(rc == -1, errcodeFromErrno(), -1);
assert(rc >= 0);
assert(rc <= len);
return (PHYSFS_sint64) rc;
@ -238,10 +238,10 @@ PHYSFS_sint64 __PHYSFS_platformWrite(void *opaque, const void *buffer,
ssize_t rc = 0;
if (!__PHYSFS_ui64FitsAddressSpace(len))
BAIL_MACRO(PHYSFS_ERR_INVALID_ARGUMENT, -1);
BAIL(PHYSFS_ERR_INVALID_ARGUMENT, -1);
rc = write(fd, (void *) buffer, (size_t) len);
BAIL_IF_MACRO(rc == -1, errcodeFromErrno(), rc);
BAIL_IF(rc == -1, errcodeFromErrno(), rc);
assert(rc >= 0);
assert(rc <= len);
return (PHYSFS_sint64) rc;
@ -252,7 +252,7 @@ int __PHYSFS_platformSeek(void *opaque, PHYSFS_uint64 pos)
{
const int fd = *((int *) opaque);
const int rc = lseek(fd, (off_t) pos, SEEK_SET);
BAIL_IF_MACRO(rc == -1, errcodeFromErrno(), 0);
BAIL_IF(rc == -1, errcodeFromErrno(), 0);
return 1;
} /* __PHYSFS_platformSeek */
@ -262,7 +262,7 @@ PHYSFS_sint64 __PHYSFS_platformTell(void *opaque)
const int fd = *((int *) opaque);
PHYSFS_sint64 retval;
retval = (PHYSFS_sint64) lseek(fd, 0, SEEK_CUR);
BAIL_IF_MACRO(retval == -1, errcodeFromErrno(), -1);
BAIL_IF(retval == -1, errcodeFromErrno(), -1);
return retval;
} /* __PHYSFS_platformTell */
@ -271,7 +271,7 @@ PHYSFS_sint64 __PHYSFS_platformFileLength(void *opaque)
{
const int fd = *((int *) opaque);
struct stat statbuf;
BAIL_IF_MACRO(fstat(fd, &statbuf) == -1, errcodeFromErrno(), -1);
BAIL_IF(fstat(fd, &statbuf) == -1, errcodeFromErrno(), -1);
return ((PHYSFS_sint64) statbuf.st_size);
} /* __PHYSFS_platformFileLength */
@ -280,7 +280,7 @@ int __PHYSFS_platformFlush(void *opaque)
{
const int fd = *((int *) opaque);
if ((fcntl(fd, F_GETFL) & O_ACCMODE) != O_RDONLY)
BAIL_IF_MACRO(fsync(fd) == -1, errcodeFromErrno(), 0);
BAIL_IF(fsync(fd) == -1, errcodeFromErrno(), 0);
return 1;
} /* __PHYSFS_platformFlush */
@ -295,7 +295,7 @@ void __PHYSFS_platformClose(void *opaque)
int __PHYSFS_platformDelete(const char *path)
{
BAIL_IF_MACRO(remove(path) == -1, errcodeFromErrno(), 0);
BAIL_IF(remove(path) == -1, errcodeFromErrno(), 0);
return 1;
} /* __PHYSFS_platformDelete */
@ -304,7 +304,7 @@ int __PHYSFS_platformStat(const char *filename, PHYSFS_Stat *st)
{
struct stat statbuf;
BAIL_IF_MACRO(lstat(filename, &statbuf) == -1, errcodeFromErrno(), 0);
BAIL_IF(lstat(filename, &statbuf) == -1, errcodeFromErrno(), 0);
if (S_ISREG(statbuf.st_mode))
{
@ -369,12 +369,12 @@ void *__PHYSFS_platformCreateMutex(void)
{
int rc;
PthreadMutex *m = (PthreadMutex *) allocator.Malloc(sizeof (PthreadMutex));
BAIL_IF_MACRO(!m, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL_IF(!m, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
rc = pthread_mutex_init(&m->mutex, NULL);
if (rc != 0)
{
allocator.Free(m);
BAIL_MACRO(PHYSFS_ERR_OS_ERROR, NULL);
BAIL(PHYSFS_ERR_OS_ERROR, NULL);
} /* if */
m->count = 0;

12
src/platform_unix.c
View File

@ -92,7 +92,7 @@ void __PHYSFS_platformDetectAvailableCDs(PHYSFS_StringCallback cb, void *data)
struct mntent *ent = NULL;
mounts = setmntent("/etc/mtab", "r");
BAIL_IF_MACRO(mounts == NULL, PHYSFS_ERR_IO, /*return void*/);
BAIL_IF(mounts == NULL, PHYSFS_ERR_IO, /*return void*/);
while ( (ent = getmntent(mounts)) != NULL )
{
@ -122,7 +122,7 @@ void __PHYSFS_platformDetectAvailableCDs(PHYSFS_StringCallback cb, void *data)
FILE *mounts = fopen(MNTTAB, "r");
struct mnttab ent;
BAIL_IF_MACRO(mounts == NULL, PHYSFS_ERR_IO, /*return void*/);
BAIL_IF(mounts == NULL, PHYSFS_ERR_IO, /*return void*/);
while (getmntent(mounts, &ent) == 0)
{
int add_it = 0;
@ -180,7 +180,7 @@ static char *findBinaryInPath(const char *bin, char *envr)
{
if (exe != NULL)
allocator.Free(exe);
BAIL_MACRO(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
} /* if */
alloc_size = size;
@ -311,7 +311,7 @@ char *__PHYSFS_platformCalcBaseDir(const char *argv0)
if (envr != NULL)
{
char *path = (char *) __PHYSFS_smallAlloc(strlen(envr) + 1);
BAIL_IF_MACRO(!path, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL_IF(!path, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
strcpy(path, envr);
retval = findBinaryInPath(argv0, path);
__PHYSFS_smallFree(path);
@ -348,13 +348,13 @@ char *__PHYSFS_platformCalcPrefDir(const char *org, const char *app)
{
/* You end up with "$HOME/.local/share/Game Name 2" */
envr = __PHYSFS_getUserDir();
BAIL_IF_MACRO(!envr, ERRPASS, NULL); /* oh well. */
BAIL_IF_ERRPASS(!envr, NULL); /* oh well. */
append = ".local/share/";
} /* if */
len = strlen(envr) + strlen(append) + strlen(app) + 2;
retval = (char *) allocator.Malloc(len);
BAIL_IF_MACRO(!retval, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL_IF(!retval, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
snprintf(retval, len, "%s%s%s/", envr, append, app);
return retval;
} /* __PHYSFS_platformCalcPrefDir */

74
src/platform_windows.c
View File

@ -45,7 +45,7 @@
#define PHYSFS_IO_REPARSE_TAG_SYMLINK 0xA000000C
#define UTF8_TO_UNICODE_STACK_MACRO(w_assignto, str) { \
#define UTF8_TO_UNICODE_STACK(w_assignto, str) { \
if (str == NULL) \
w_assignto = NULL; \
else { \
@ -73,7 +73,7 @@ static char *unicodeToUtf8Heap(const WCHAR *w_str)
void *ptr = NULL;
const PHYSFS_uint64 len = (wStrLen(w_str) * 4) + 1;
retval = allocator.Malloc(len);
BAIL_IF_MACRO(!retval, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL_IF(!retval, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
PHYSFS_utf8FromUtf16((const PHYSFS_uint16 *) w_str, retval, len);
ptr = allocator.Realloc(retval, strlen(retval) + 1); /* shrink. */
if (ptr != NULL)
@ -339,7 +339,7 @@ char *__PHYSFS_platformCalcBaseDir(const char *argv0)
if ( (ptr = allocator.Realloc(modpath, buflen*sizeof(WCHAR))) == NULL )
{
allocator.Free(modpath);
BAIL_MACRO(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
} /* if */
modpath = (LPWSTR) ptr;
@ -347,7 +347,7 @@ char *__PHYSFS_platformCalcBaseDir(const char *argv0)
if (rc == 0)
{
allocator.Free(modpath);
BAIL_MACRO(errcodeFromWinApi(), NULL);
BAIL(errcodeFromWinApi(), NULL);
} /* if */
if (rc < buflen)
@ -400,16 +400,16 @@ char *__PHYSFS_platformCalcPrefDir(const char *org, const char *app)
if (!SUCCEEDED(SHGetFolderPathW(NULL, CSIDL_APPDATA | CSIDL_FLAG_CREATE,
NULL, 0, path)))
BAIL_MACRO(PHYSFS_ERR_OS_ERROR, NULL);
BAIL(PHYSFS_ERR_OS_ERROR, NULL);
utf8 = unicodeToUtf8Heap(path);
BAIL_IF_MACRO(!utf8, ERRPASS, NULL);
BAIL_IF_ERRPASS(!utf8, NULL);
len = strlen(utf8) + strlen(org) + strlen(app) + 4;
retval = allocator.Malloc(len);
if (!retval)
{
allocator.Free(utf8);
BAIL_MACRO(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
} /* if */
sprintf(retval, "%s\\%s\\%s\\", utf8, org, app);
@ -427,12 +427,12 @@ char *__PHYSFS_platformCalcUserDir(void)
char *retval = NULL;
lib = LoadLibraryA("userenv.dll");
BAIL_IF_MACRO(!lib, errcodeFromWinApi(), NULL);
BAIL_IF(!lib, errcodeFromWinApi(), NULL);
pGetDir=(fnGetUserProfDirW) GetProcAddress(lib,"GetUserProfileDirectoryW");
GOTO_IF_MACRO(!pGetDir, errcodeFromWinApi(), done);
GOTO_IF(!pGetDir, errcodeFromWinApi(), done);
if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &accessToken))
GOTO_MACRO(errcodeFromWinApi(), done);
GOTO(errcodeFromWinApi(), done);
else
{
DWORD psize = 0;
@ -509,7 +509,7 @@ void __PHYSFS_platformEnumerateFiles(const char *dirname,
/* Append the "*" to the end of the string */
strcat(searchPath, "*");
UTF8_TO_UNICODE_STACK_MACRO(wSearchPath, searchPath);
UTF8_TO_UNICODE_STACK(wSearchPath, searchPath);
if (!wSearchPath)
return; /* oh well. */
@ -546,10 +546,10 @@ int __PHYSFS_platformMkDir(const char *path)
{
WCHAR *wpath;
DWORD rc;
UTF8_TO_UNICODE_STACK_MACRO(wpath, path);
UTF8_TO_UNICODE_STACK(wpath, path);
rc = CreateDirectoryW(wpath, NULL);
__PHYSFS_smallFree(wpath);
BAIL_IF_MACRO(rc == 0, errcodeFromWinApi(), 0);
BAIL_IF(rc == 0, errcodeFromWinApi(), 0);
return 1;
} /* __PHYSFS_platformMkDir */
@ -582,19 +582,19 @@ static void *doOpen(const char *fname, DWORD mode, DWORD creation, int rdonly)
WinApiFile *retval;
WCHAR *wfname;
UTF8_TO_UNICODE_STACK_MACRO(wfname, fname);
BAIL_IF_MACRO(!wfname, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
UTF8_TO_UNICODE_STACK(wfname, fname);
BAIL_IF(!wfname, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
fileh = CreateFileW(wfname, mode, FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL, creation, FILE_ATTRIBUTE_NORMAL, NULL);
__PHYSFS_smallFree(wfname);
BAIL_IF_MACRO(fileh == INVALID_HANDLE_VALUE,errcodeFromWinApi(), NULL);
BAIL_IF(fileh == INVALID_HANDLE_VALUE,errcodeFromWinApi(), NULL);
retval = (WinApiFile *) allocator.Malloc(sizeof (WinApiFile));
if (!retval)
{
CloseHandle(fileh);
BAIL_MACRO(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
} /* if */
retval->readonly = rdonly;
@ -627,7 +627,7 @@ void *__PHYSFS_platformOpenAppend(const char *filename)
const PHYSFS_ErrorCode err = errcodeFromWinApi();
CloseHandle(h);
allocator.Free(retval);
BAIL_MACRO(err, NULL);
BAIL(err, NULL);
} /* if */
} /* if */
@ -641,14 +641,14 @@ PHYSFS_sint64 __PHYSFS_platformRead(void *opaque, void *buf, PHYSFS_uint64 len)
PHYSFS_sint64 totalRead = 0;
if (!__PHYSFS_ui64FitsAddressSpace(len))
BAIL_MACRO(PHYSFS_ERR_INVALID_ARGUMENT, -1);
BAIL(PHYSFS_ERR_INVALID_ARGUMENT, -1);
while (len > 0)
{
const DWORD thislen = (len > 0xFFFFFFFF) ? 0xFFFFFFFF : (DWORD) len;
DWORD numRead = 0;
if (!ReadFile(Handle, buf, thislen, &numRead, NULL))
BAIL_MACRO(errcodeFromWinApi(), -1);
BAIL(errcodeFromWinApi(), -1);
len -= (PHYSFS_uint64) numRead;
totalRead += (PHYSFS_sint64) numRead;
if (numRead != thislen)
@ -666,14 +666,14 @@ PHYSFS_sint64 __PHYSFS_platformWrite(void *opaque, const void *buffer,
PHYSFS_sint64 totalWritten = 0;
if (!__PHYSFS_ui64FitsAddressSpace(len))
BAIL_MACRO(PHYSFS_ERR_INVALID_ARGUMENT, -1);
BAIL(PHYSFS_ERR_INVALID_ARGUMENT, -1);
while (len > 0)
{
const DWORD thislen = (len > 0xFFFFFFFF) ? 0xFFFFFFFF : (DWORD) len;
DWORD numWritten = 0;
if (!WriteFile(Handle, buffer, thislen, &numWritten, NULL))
BAIL_MACRO(errcodeFromWinApi(), -1);
BAIL(errcodeFromWinApi(), -1);
len -= (PHYSFS_uint64) numWritten;
totalWritten += (PHYSFS_sint64) numWritten;
if (numWritten != thislen)
@ -707,7 +707,7 @@ int __PHYSFS_platformSeek(void *opaque, PHYSFS_uint64 pos)
if ( (rc == PHYSFS_INVALID_SET_FILE_POINTER) &&
(GetLastError() != NO_ERROR) )
{
BAIL_MACRO(errcodeFromWinApi(), 0);
BAIL(errcodeFromWinApi(), 0);
} /* if */
return 1; /* No error occured */
@ -726,7 +726,7 @@ PHYSFS_sint64 __PHYSFS_platformTell(void *opaque)
if ( (LowPos == PHYSFS_INVALID_SET_FILE_POINTER) &&
(GetLastError() != NO_ERROR) )
{
BAIL_MACRO(errcodeFromWinApi(), -1);
BAIL(errcodeFromWinApi(), -1);
} /* if */
else
{
@ -750,7 +750,7 @@ PHYSFS_sint64 __PHYSFS_platformFileLength(void *opaque)
if ( (SizeLow == PHYSFS_INVALID_SET_FILE_POINTER) &&
(GetLastError() != NO_ERROR) )
{
BAIL_MACRO(errcodeFromWinApi(), -1);
BAIL(errcodeFromWinApi(), -1);
} /* if */
else
{
@ -767,7 +767,7 @@ int __PHYSFS_platformFlush(void *opaque)
{
WinApiFile *fh = ((WinApiFile *) opaque);
if (!fh->readonly)
BAIL_IF_MACRO(!FlushFileBuffers(fh->handle), errcodeFromWinApi(), 0);
BAIL_IF(!FlushFileBuffers(fh->handle), errcodeFromWinApi(), 0);
return 1;
} /* __PHYSFS_platformFlush */
@ -785,7 +785,7 @@ static int doPlatformDelete(LPWSTR wpath)
{
const int isdir = (GetFileAttributesW(wpath) & FILE_ATTRIBUTE_DIRECTORY);
const BOOL rc = (isdir) ? RemoveDirectoryW(wpath) : DeleteFileW(wpath);
BAIL_IF_MACRO(!rc, errcodeFromWinApi(), 0);
BAIL_IF(!rc, errcodeFromWinApi(), 0);
return 1; /* if you made it here, it worked. */
} /* doPlatformDelete */
@ -794,8 +794,8 @@ int __PHYSFS_platformDelete(const char *path)
{
int retval = 0;
LPWSTR wpath = NULL;
UTF8_TO_UNICODE_STACK_MACRO(wpath, path);
BAIL_IF_MACRO(!wpath, PHYSFS_ERR_OUT_OF_MEMORY, 0);
UTF8_TO_UNICODE_STACK(wpath, path);
BAIL_IF(!wpath, PHYSFS_ERR_OUT_OF_MEMORY, 0);
retval = doPlatformDelete(wpath);
__PHYSFS_smallFree(wpath);
return retval;
@ -806,7 +806,7 @@ void *__PHYSFS_platformCreateMutex(void)
{
LPCRITICAL_SECTION lpcs;
lpcs = (LPCRITICAL_SECTION) allocator.Malloc(sizeof (CRITICAL_SECTION));
BAIL_IF_MACRO(!lpcs, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL_IF(!lpcs, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
InitializeCriticalSection(lpcs);
return lpcs;
} /* __PHYSFS_platformCreateMutex */
@ -842,11 +842,11 @@ static PHYSFS_sint64 FileTimeToPhysfsTime(const FILETIME *ft)
struct tm tm;
BOOL rc;
BAIL_IF_MACRO(!FileTimeToSystemTime(ft, &st_utc), errcodeFromWinApi(), -1);
BAIL_IF(!FileTimeToSystemTime(ft, &st_utc), errcodeFromWinApi(), -1);
tzid = GetTimeZoneInformation(&tzi);
BAIL_IF_MACRO(tzid == TIME_ZONE_ID_INVALID, errcodeFromWinApi(), -1);
BAIL_IF(tzid == TIME_ZONE_ID_INVALID, errcodeFromWinApi(), -1);
rc = SystemTimeToTzSpecificLocalTime(&tzi, &st_utc, &st_localtz);
BAIL_IF_MACRO(!rc, errcodeFromWinApi(), -1);
BAIL_IF(!rc, errcodeFromWinApi(), -1);
/* Convert to a format that mktime() can grok... */
tm.tm_sec = st_localtz.wSecond;
@ -861,7 +861,7 @@ static PHYSFS_sint64 FileTimeToPhysfsTime(const FILETIME *ft)
/* Convert to a format PhysicsFS can grok... */
retval = (PHYSFS_sint64) mktime(&tm);
BAIL_IF_MACRO(retval == -1, PHYSFS_ERR_OS_ERROR, -1);
BAIL_IF(retval == -1, PHYSFS_ERR_OS_ERROR, -1);
return retval;
} /* FileTimeToPhysfsTime */
@ -873,12 +873,12 @@ int __PHYSFS_platformStat(const char *filename, PHYSFS_Stat *st)
DWORD err = 0;
BOOL rc = 0;
UTF8_TO_UNICODE_STACK_MACRO(wstr, filename);
BAIL_IF_MACRO(!wstr, PHYSFS_ERR_OUT_OF_MEMORY, 0);
UTF8_TO_UNICODE_STACK(wstr, filename);
BAIL_IF(!wstr, PHYSFS_ERR_OUT_OF_MEMORY, 0);
rc = GetFileAttributesExW(wstr, GetFileExInfoStandard, &winstat);
err = (!rc) ? GetLastError() : 0;
__PHYSFS_smallFree(wstr);
BAIL_IF_MACRO(!rc, errcodeFromWinApiError(err), 0);
BAIL_IF(!rc, errcodeFromWinApiError(err), 0);
st->modtime = FileTimeToPhysfsTime(&winstat.ftLastWriteTime);
st->accesstime = FileTimeToPhysfsTime(&winstat.ftLastAccessTime);

56
src/platform_winrt.cpp
View File

@ -68,7 +68,7 @@
#define PHYSFS_IO_REPARSE_TAG_SYMLINK 0xA000000C
#define UTF8_TO_UNICODE_STACK_MACRO(w_assignto, str) { \
#define UTF8_TO_UNICODE_STACK(w_assignto, str) { \
if (str == NULL) \
w_assignto = NULL; \
else { \
@ -195,7 +195,7 @@ static char *unicodeToUtf8Heap(const WCHAR *w_str)
void *ptr = NULL;
const PHYSFS_uint64 len = (wStrLen(w_str) * 4) + 1;
retval = (char*)allocator.Malloc(len);
BAIL_IF_MACRO(!retval, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL_IF(!retval, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
PHYSFS_utf8FromUtf16((const PHYSFS_uint16 *)w_str, retval, len);
ptr = allocator.Realloc(retval, strlen(retval) + 1); /* shrink. */
if (ptr != NULL)
@ -274,7 +274,7 @@ void __PHYSFS_platformEnumerateFiles(const char *dirname,
/* Append the "*" to the end of the string */
strcat(searchPath, "*");
UTF8_TO_UNICODE_STACK_MACRO(wSearchPath, searchPath);
UTF8_TO_UNICODE_STACK(wSearchPath, searchPath);
if (!wSearchPath)
return; /* oh well. */
@ -314,10 +314,10 @@ int __PHYSFS_platformMkDir(const char *path)
{
WCHAR *wpath;
DWORD rc;
UTF8_TO_UNICODE_STACK_MACRO(wpath, path);
UTF8_TO_UNICODE_STACK(wpath, path);
rc = CreateDirectoryW(wpath, NULL);
__PHYSFS_smallFree(wpath);
BAIL_IF_MACRO(rc == 0, errcodeFromWinApi(), 0);
BAIL_IF(rc == 0, errcodeFromWinApi(), 0);
return 1;
} /* __PHYSFS_platformMkDir */
@ -340,19 +340,19 @@ static void *doOpen(const char *fname, DWORD mode, DWORD creation, int rdonly)
WinApiFile *retval;
WCHAR *wfname;
UTF8_TO_UNICODE_STACK_MACRO(wfname, fname);
BAIL_IF_MACRO(!wfname, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
UTF8_TO_UNICODE_STACK(wfname, fname);
BAIL_IF(!wfname, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
//fileh = CreateFileW(wfname, mode, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, creation, FILE_ATTRIBUTE_NORMAL, NULL);
fileh = CreateFile2(wfname, mode, FILE_SHARE_READ | FILE_SHARE_WRITE, creation, NULL);
__PHYSFS_smallFree(wfname);
BAIL_IF_MACRO(fileh == INVALID_HANDLE_VALUE, errcodeFromWinApi(), NULL);
BAIL_IF(fileh == INVALID_HANDLE_VALUE, errcodeFromWinApi(), NULL);
retval = (WinApiFile *)allocator.Malloc(sizeof(WinApiFile));
if (!retval)
{
CloseHandle(fileh);
BAIL_MACRO(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
} /* if */
retval->readonly = rdonly;
@ -387,7 +387,7 @@ void *__PHYSFS_platformOpenAppend(const char *filename)
const PHYSFS_ErrorCode err = errcodeFromWinApi();
CloseHandle(h);
allocator.Free(retval);
BAIL_MACRO(err, NULL);
BAIL(err, NULL);
} /* if */
} /* if */
@ -401,14 +401,14 @@ PHYSFS_sint64 __PHYSFS_platformRead(void *opaque, void *buf, PHYSFS_uint64 len)
PHYSFS_sint64 totalRead = 0;
if (!__PHYSFS_ui64FitsAddressSpace(len))
BAIL_MACRO(PHYSFS_ERR_INVALID_ARGUMENT, -1);
BAIL(PHYSFS_ERR_INVALID_ARGUMENT, -1);
while (len > 0)
{
const DWORD thislen = (len > 0xFFFFFFFF) ? 0xFFFFFFFF : (DWORD)len;
DWORD numRead = 0;
if (!ReadFile(Handle, buf, thislen, &numRead, NULL))
BAIL_MACRO(errcodeFromWinApi(), -1);
BAIL(errcodeFromWinApi(), -1);
len -= (PHYSFS_uint64)numRead;
totalRead += (PHYSFS_sint64)numRead;
if (numRead != thislen)
@ -426,14 +426,14 @@ PHYSFS_sint64 __PHYSFS_platformWrite(void *opaque, const void *buffer,
PHYSFS_sint64 totalWritten = 0;
if (!__PHYSFS_ui64FitsAddressSpace(len))
BAIL_MACRO(PHYSFS_ERR_INVALID_ARGUMENT, -1);
BAIL(PHYSFS_ERR_INVALID_ARGUMENT, -1);
while (len > 0)
{
const DWORD thislen = (len > 0xFFFFFFFF) ? 0xFFFFFFFF : (DWORD)len;
DWORD numWritten = 0;
if (!WriteFile(Handle, buffer, thislen, &numWritten, NULL))
BAIL_MACRO(errcodeFromWinApi(), -1);
BAIL(errcodeFromWinApi(), -1);
len -= (PHYSFS_uint64)numWritten;
totalWritten += (PHYSFS_sint64)numWritten;
if (numWritten != thislen)
@ -457,7 +457,7 @@ int __PHYSFS_platformSeek(void *opaque, PHYSFS_uint64 pos)
if (!rc && (GetLastError() != NO_ERROR))
{
BAIL_MACRO(errcodeFromWinApi(), 0);
BAIL(errcodeFromWinApi(), 0);
} /* if */
return 1; /* No error occured */
@ -477,7 +477,7 @@ PHYSFS_sint64 __PHYSFS_platformTell(void *opaque)
rc = SetFilePointerEx(Handle, zero, &out, FILE_CURRENT);
if (!rc)
{
BAIL_MACRO(errcodeFromWinApi(), -1);
BAIL(errcodeFromWinApi(), -1);
} /* if */
else
{
@ -513,7 +513,7 @@ int __PHYSFS_platformFlush(void *opaque)
{
WinApiFile *fh = ((WinApiFile *)opaque);
if (!fh->readonly)
BAIL_IF_MACRO(!FlushFileBuffers(fh->handle), errcodeFromWinApi(), 0);
BAIL_IF(!FlushFileBuffers(fh->handle), errcodeFromWinApi(), 0);
return 1;
} /* __PHYSFS_platformFlush */
@ -538,7 +538,7 @@ static int doPlatformDelete(LPWSTR wpath)
}
const BOOL rc = (isdir) ? RemoveDirectoryW(wpath) : DeleteFileW(wpath);
BAIL_IF_MACRO(!rc, errcodeFromWinApi(), 0);
BAIL_IF(!rc, errcodeFromWinApi(), 0);
return 1; /* if you made it here, it worked. */
} /* doPlatformDelete */
@ -547,8 +547,8 @@ int __PHYSFS_platformDelete(const char *path)
{
int retval = 0;
LPWSTR wpath = NULL;
UTF8_TO_UNICODE_STACK_MACRO(wpath, path);
BAIL_IF_MACRO(!wpath, PHYSFS_ERR_OUT_OF_MEMORY, 0);
UTF8_TO_UNICODE_STACK(wpath, path);
BAIL_IF(!wpath, PHYSFS_ERR_OUT_OF_MEMORY, 0);
retval = doPlatformDelete(wpath);
__PHYSFS_smallFree(wpath);
return retval;
@ -559,7 +559,7 @@ void *__PHYSFS_platformCreateMutex(void)
{
LPCRITICAL_SECTION lpcs;
lpcs = (LPCRITICAL_SECTION)allocator.Malloc(sizeof(CRITICAL_SECTION));
BAIL_IF_MACRO(!lpcs, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
BAIL_IF(!lpcs, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
//InitializeCriticalSection(lpcs);
InitializeCriticalSectionEx(lpcs, 2000, 0);
return lpcs;
@ -596,11 +596,11 @@ static PHYSFS_sint64 FileTimeToPhysfsTime(const FILETIME *ft)
struct tm tm;
BOOL rc;
BAIL_IF_MACRO(!FileTimeToSystemTime(ft, &st_utc), errcodeFromWinApi(), -1);
BAIL_IF(!FileTimeToSystemTime(ft, &st_utc), errcodeFromWinApi(), -1);
tzid = GetTimeZoneInformation(&tzi);
BAIL_IF_MACRO(tzid == TIME_ZONE_ID_INVALID, errcodeFromWinApi(), -1);
BAIL_IF(tzid == TIME_ZONE_ID_INVALID, errcodeFromWinApi(), -1);
rc = SystemTimeToTzSpecificLocalTime(&tzi, &st_utc, &st_localtz);
BAIL_IF_MACRO(!rc, errcodeFromWinApi(), -1);
BAIL_IF(!rc, errcodeFromWinApi(), -1);
/* Convert to a format that mktime() can grok... */
tm.tm_sec = st_localtz.wSecond;
@ -615,7 +615,7 @@ static PHYSFS_sint64 FileTimeToPhysfsTime(const FILETIME *ft)
/* Convert to a format PhysicsFS can grok... */
retval = (PHYSFS_sint64)mktime(&tm);
BAIL_IF_MACRO(retval == -1, PHYSFS_ERR_OS_ERROR, -1);
BAIL_IF(retval == -1, PHYSFS_ERR_OS_ERROR, -1);
return retval;
} /* FileTimeToPhysfsTime */
@ -627,12 +627,12 @@ int __PHYSFS_platformStat(const char *filename, PHYSFS_Stat *st)
DWORD err = 0;
BOOL rc = 0;
UTF8_TO_UNICODE_STACK_MACRO(wstr, filename);
BAIL_IF_MACRO(!wstr, PHYSFS_ERR_OUT_OF_MEMORY, 0);
UTF8_TO_UNICODE_STACK(wstr, filename);
BAIL_IF(!wstr, PHYSFS_ERR_OUT_OF_MEMORY, 0);
rc = GetFileAttributesExW(wstr, GetFileExInfoStandard, &winstat);
err = (!rc) ? GetLastError() : 0;
__PHYSFS_smallFree(wstr);
BAIL_IF_MACRO(!rc, errcodeFromWinApiError(err), 0);
BAIL_IF(!rc, errcodeFromWinApiError(err), 0);
st->modtime = FileTimeToPhysfsTime(&winstat.ftLastWriteTime);
st->accesstime = FileTimeToPhysfsTime(&winstat.ftLastAccessTime);