gmueller/bluecore
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

initial commit

Browse Source
This commit is contained in:
cirdan
2008-01-16 11:45:17 +00:00
commit 8f17a3a819
1068 changed files with 384278 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

602
physfs/CHANGELOG.txt Normal file
View File

@ -0,0 +1,602 @@
/*
* CHANGELOG.
*/
04032007 - Added a "make dist" target for packing up source code releases.
Reverted Unix recursive mutex code. There were some portability
issues I didn't anticipate. Upped version to 1.1.1!
04022007 - Added wxWidgets-based test program (incomplete). Filled in and
corrected some Doxygen comments.
04012007 - Added PHYSFS_isInit() and PHYSFS_symbolicLinksPermitted() functions.
03312007 - Added a quick'n'dirty unpack utility to the extras directory. Moved
DIR archiver to start of the list, so we don't have to have every
other archiver fail to open a directory as a file before mounting
it. Fixed typos in makeos2.cmd and the Doxygen comments. Added
symlink support to windows.c for use on Vista-based systems.
03282007 - Logic bug in MVL/HOG/GRP archivers: only enumerated files when
looking in a directory other than the root, instead of enumerating
only for the root (thanks, Chris!). Minor fix for compilers that
don't like the BAIL_* macros with an empty argument
(thanks, Chris!)
03262007 - Tons of Unicode work in windows.c ... should now use UCS-2 on
NT/XP/Vista/etc versions of the OS, and fallback to "ANSI" versions
for 95/98/ME, tapdancing around the system codepage if it has to.
Since the Unicode entry points are dynamically loaded, it won't
have issues with missing symbols on Win9x, nor does it need to be
built separately with #define UNICODE (although it will work the
same with or without this define, as it doesn't use TCHARs or
the non-[WA] versions of APIs. Other minor Windows cleanups and
corrections.
03252007 - Improved dynamic loader and initial Unicode work in windows.c ...
03242007 - Replaced BeOS semaphores with BLockers for the mutex implementation.
It's much simpler, it has "benaphores" built in behind the scenes
for faster performance, and it's recursive...also, we were
previously setting the PhysicsFS error state if BeOS mutex grabbing
failed (a big no no!), and that's now fixed. Good wins all around.
03222007 - Replaced some Malloc and all the alloca() calls with
__PHYSFS_smallAlloc(), which will stack allocate small (128 or
less bytes) blocks and Malloc the rest...naturally these now have
to be paired with __PHYSFS_smallFree() calls, so you can't be as
lazy as a basic alloca() would let you be. The benefit is both less
malloc pressure for those temporary allocations and better stack
overflow safety (so if some jerk tries to push a 78 megabyte string
through the library as a filename, we won't try to strcpy it to
the stack). Hopefully some internal interfaces can now get
refactored to stop generating heap pointers and let the caller use
smallAlloc to further reduce malloc pressure.
03212007 - Replaced LONGLONGLITERAL with __PHYSFS_UI64/__PHYSFS_SI64 ...
03202007 - Removed platform/skeleton.c (it was out of date), added
platform/macosx.c (To further Macify the code and get the #ifdefs
out of unix.c), and refactored the platform layer to try and
make the unix/posix/macosx/beos sources try to find a split that
works. Moved the platform allocators to physfs.c, since all but
Mac OS X were using malloc()...there's now an interface for the
platform to supply a custom allocator if they don't want the malloc
version. Removed __PHYSFS_platformTimeslice(), as it's no longer
being used. Replaced manual management of pthread mutexes with
PTHREAD_MUTEX_RECURSIVE attribute...let's see what platforms
throw up on that. Handled documentation comment FIXME in physfs.h.
03192007 - Fixed two switched strings in CMakeLists.txt ... patch to compile
with latest Windows Platform SDK. Explicitly check for NULL in
PHYSFS_init() when we can't go on without a real string here.
Removed ANSI-C workaround for missing lstat() nonsense in posix.c
(POSIX != ANSI, time to give up here). Try to use /proc/self/exe
to find the base dir on Unix, so we can do without argv[0] on
systems with a Linux-like /proc filesystem.
03162007 - Changed PHYSFS_file from a typedef to a #define (in case it would
cause an aggressive compiler to think you're passing the wrong type
to a function) and added Doxygen comments to explain it.
03152007 - Bunch of work on Unicode...added case-folding stricmp, removed
platform-specific stricmp implementations, changed appropriate
calls to an ASCII-only stricmp that ignores locale. Fixed case on
UTF-8 API entry points.
03142007 - Dropped classic Mac OS support. It's just too hard to find a working
Mac OS 9 install and reasonable development tools, so it's not
worth it. If you still target OS 8 or 9, please use PhysicsFS 1.0.
03112007 - Removed zlib_license_change.txt ... it's in Subversion and the 1.0
branch for history's sake. Added shared and static build options
to CMakeLists.txt, and the expected "make install" target.
Renamed some FILENAME files to FILENAME.txt, removed physfs.rc.
Now compiles everything whether we need it or not, removing whole
files with #ifdefs...this will make it easier to "embed" this
library in other projects or use a different build system: just
push everything through the compiler with preprocessor defines for
the parts you want/need...platform modules are determined
automatically without the build system needing to intervene, so you
just have to #define the archivers, etc that you want.
Updated makeos2.cmd for newer Innotek toolchain (thanks, Dave!)
03082007 - Fixed a comment in physfs.h. Renamed win32.c to windows.c.
Cleaned up whitespace/formatting in pocketpc.c. Updated PocketPC
code to expect UTF-8 strings from the higher level. Changed
PHYSFS_SUPPORTS_LZMA to PHYSFS_SUPPORTS_7Z. Killed some #ifdefs
in physfs.c. Moved to CMake...so long, autotools! Killed MIX
archiver, too.
11052006 - More 7zip archiver work (thanks, Dennis!). Initial Unicode work.
Minor BeOS realpath tweak.
09272006 - Reworked 7zip archiver (thanks, Dennis!).
09232006 - Fixed typo in doxygen comment.
04112006 - Added LZMA archiver...7zip support (thanks, Dennis!).
03232006 - Added -fvisibility for gcc4 (http://gcc.gnu.org/wiki/Visibility)
01012006 - Cleaned up overflow checks in platform memory allocators (thanks to
Nicolas Lebedenco for pointing out the original issue with
long long literals). Added physfs.rc (thanks, Dennis!). Changed my
email address. Removed acconfig.h.
11282005 - Corrected docs on PHYSFS_setWriteDir().
10122005 - Fixed locateInStringList() in physfs.c (thanks, Matze!). Patched
archivers/wad.c to compile.
09192005 - Make unix mutexes recursive above pthread layer...fixes deadlock on
MacOS X, for now.
09182005 - API BREAKAGE: PHYSFS_enumerateFilesCallback() now passes the
original directory name back to the app in the callback. This
API was only in 1.1.0, and wasn't promised to be stable at this
point. Please update your apps! Cleaned out a FIXME in file
enumeration that would confuse the library under certain
circumstances.
09092005 - Some tweaks to PHYSFS_Allocator. Apparently configure.in doesn't
work like I thought for version bumps, so it thinks 1.1.0 isn't
binary compatible with 1.0...fixed, I think.
09062005 - Happy September. Changed the allocation abstraction to use
PHYSFS_uint64 instead of size_t, so we don't have to include
system headers inside physfs.h. Minor MingW fixes (but it's still
broken, I think).
08202005 - Fixed bug in verifyPath() that was breaking PHYSFS_setSaneConfig()
and other corner cases.
07242005 - Patched to compile on BeOS.
07232005 - Fixed bug in zip archiver (thanks, J<>rg Walter!).
More minor OS/2 tweaks. Updated zlib to 1.2.3, which properly
includes the security fix. Fixed "make dist" to handle .svn dirs
and other file changes. Removed "debian" directory. Allow a mount
point of NULL to be "/", per the documentation. Fixed warning in
physfs.c. Assert definition fix. Updated CWProjects.sit.
Upped version to 1.1.0 ... first release of 1.1 dev branch!
07212005 - Patched to compile on OS/2 again.
07132005 - Updated zlib to 1.2.2, and patched it for this security hole:
http://www.cve.mitre.org/cgi-bin/cvename.cgi?name=CAN-2005-2096
06122005 - Added support for mingw to Unix build process (thanks, Matze!).
03162005 - Added missing translation and Portuguese support (thanks, Danny!).
MPW support and several MacOS Classic fixes (thanks, Chris!).
Changed CWProjects from SITX to SIT format, so OS9 users can
unpack it.
03132005 - More mount work, added PHYSFS_getMountPoint() and more cleanups.
Replaced all the C runtime allocations with PhysFS allocation hooks.
Added pocketpc.c to EXTRA_DIST. Added allocation hooks to some
platform drivers. Updated Mac Classic build.
03122005 - Added evil GOTO_*_MACRO_* macros. Fixed unix.c to compile again on
MacOS X. Added PHYSFS_mount() (thanks, Philip!). Cleaned up the
INSTALL and CREDITS files a little. Split off start of
verifySecurity() into a path sanitizer and changed entry points to
sanitize input paths into a stack-allocated buffer before further
processing. This removes the need for a malloc() for almost all
file system operations, and generally cleaned things up. Added a
"mount" command to test_physfs. Other general cleanups.
02152005 - Minor comment fix in platform/pocketpc.c
01052005 - Fixed HOG archiver file lookup (thanks, Chris!)
12162004 - Fixed some documentation/header comment typos (thanks, Gaetan!)
10302004 - Fixed a strcpy that should have been a strcat. (thanks, Tolga!)
Build system respects external CFLAGS now. (thanks, Adam!)
Fixed infinite loop in new enumeration code. (thanks, Adam!)
10062004 - Removed profiling code from physfs.c.
09292004 - Every API that can return a list of strings can now use a
callback mechanism if the application wants to do it's own
allocation or handling on a per-item basis. The guts of those
APIs that create string lists now use the callbacks themselves to
build the lists, too. The callback functionality goes all the way
down to the archivers and platform drivers where appropriate, which
cleans things up and simplifies some internal tasks very nicely.
Got rid of all the annoying forward declarations in all the
archivers and moved their PHYSFS_Archiver data to the end of the
file, since this was annoying me and I was getting sick of updating
function signatures in two places when the internal API changed.
Removed the code/data for LinkedStringLists...it isn't used anymore
now that the callback code is in place.
09262004 - Did the same thing to FileHandles than I did to DirHandles, but
this triggered massive tweaking in physfs.c. A lot of code got
little cleanups, which was nice. Less malloc pressure, too, since
opening a file used to allocate a ton of crap and mush it
together...now it's basically down to one structure and the
instance data in whatever archiver. Minor varname tweak in win32.c
and pocketpc.c. Changed PHYSFS_file to PHYSFS_File to match the
rest of the API's naming scheme (but put a typedef for source
compatibility).
09252004 - Cleaned up archiver interface to not deal with DirHandles anymore,
which simplifies things, removes some responsibility and code
duplication from the archivers, and trims some malloc pressure.
Ripped up the allocation hook code a little. We'll try to screw
with memory locking later, since it makes everything ugly and
complex. Oh well.
09232004 - Started adding allocation hooks.
09222004 - Happy September. Added Spanish translation back in.
04092004 - Added MIX support for legacy Westwood titles (Thanks, Sebastian!).
Made bootstrap script MacOSX-friendly. Moved byteorder defines into
physfs_internal.h ...
01152003 - Added Portuguese (Brazil) translation (Thanks, Danny!)
--- This is where the 1.1 development branch starts. ---
12292003 - Updated CodeWarrior projects from CW6 to CW7, and made a bunch of
patches to get the Mac Classic target building again. Removed
zlib114 from CVS repository. Updated OS/2 build batch file.
Added Z_PREFIX define to Unix builds that use internal zlib.
Patched up some (outdated?) Visual C project files for zlib121.
Patched Doxyfile and physfs.h for newer Doxygen. Fixed OS/2
build script. Tweaked Project Builder files to at least compile.
Added some last minute BeOS and Cygwin build fixes. Updated
Visual Studio projects and tweaked some Makefile.am crap. Made
changes so Visual Studio files would pack with DOS endlines and...
Upped version to 1.0.0 (woohoo!).
12222003 - Fixed a search-and-replace mistake in win32.c that preventing
compiling on Windows. (thanks, Brian!) Converted VC6 .dsp to use
zlib121; made Z_PREFIX=1 enabled by default to avoid link clashes;
put zlib files in separate logical folder in .dsp project; updated
zlib121/zconf.h to address remaining symbols that were still
causing link warnings.
12182003 - WAD archiver now puts maps into subdirectories, making them
accessible to the application. (Thanks, Travis!) RPM spec and
Makefile.am* now package zlib_license_change.txt (Thanks, Edward!)
12142003 - Added Doom WAD support (Thanks, Travis!)
12082003 - Fixed some win32.c deficiencies that Robby Dermody pointed
out (thanks!)
12072003 - Upgraded internal zlib to 1.2.1 (thanks, Adam!) Other
Unix build fixes.
11112003 - Patches to make OS/2 support compile again.
11092003 - Added __PHYSFS_platformStrnicmp(), and made qpak.c case-insensitive.
09122003 - Happy September. Actually released current tree as 0.1.9.
08262003 - Added MiNT support to build process and fixed cross-compiling
(thanks Patrice Mandin!)
08092003 - Some Windows build fixes (thanks, Brian Hook!)
07232003 - Upped version to 0.1.9.
07202003 - Switched to zlib license (see new LICENSE text in root of source
tree, and zlib_license_switch.txt for details). Had to remove
archivers/qpak.c, the Ruby bindings from the extras directory, and
the Russian and Spanish translations, since those contributors
couldn't be contacted. If they show up, we'll readd them to the
project, otherwise we'll eventually replace their work...everyone
else signed on for the change. Committed a patch to convert all
tabs to spaces (Thanks, James!). Added patch to zip.c to fix
crash (thanks, dillo!). Reimplmented qpak.c, by welding together
bits of grp.c and zip.c. Ed contacted me, so I could readd his
contributions post-license change...I'm going to keep the new
qpak.c, but I've readded his Ruby bindings and Russian translations.
06112003 - Patches to globbing.c to handle corner cases (thanks, Bradley!).
06102003 - Added globbing.c to "extras" directory.
05232003 - Rewrote MacOSX/Darwin CD-ROM detection code to use IOKit, which is
much much more accurate than the previous code. Updated
configure.in and Makefile.am.newautomake for some MacOSX stuff.
05222003 - Fixed win32 crash if PHYSFS_init() is called with a NULL.
05182003 - PocketPC fixes (thanks, David Hedbor!)
05162003 - Compiler warning cleanup in HOG and MVL archivers (Thanks, Bradley!)
04082003 - Minor changes to extras/abs-file.h (Thanks, Adam!)
03302003 - Fixed seeking in uncompressed ZIP entries, and handle a
misbehaviour in Java's JAR creation tools. Thanks to "Tree" for
pointing these bugs out. Added HOG and MVL archive support for
Descent I and II (Thanks, Bradley Bell!). Added example code to
do case-insensitive file searches ("extras/ignorecase.*").
03192003 - Fixed problem in PHYSFS_mkdir() when dirs to be created already
exist. Fixed problem where PHYSFS_mkdir() incorrectly tripped an
alarm in __PHYSFS_verifySecurity().
03122003 - Attempt at cleaning up some type correctness for VC++6. Made QPAK
archiver case-insensitive (since Quake2 has problems without it).
01302003 - Added buffering API to OS/2 build's exported symbol list. Updated
CWProjects.sit and made several fixes to get physfs building on
MacOS Classic again.
01282003 - Fixed seeking in buffered files opened for read.
01072003 - .NET assembly and C# wrapper by Gregory S. Read in the extras dir.
01042003 - Added a hack for dealing with OSX bundles and newer PBProjects
(thanks, Eric Wing!). Added some missing files to "make dist".
Fixed minor Doxygen typo in PHYSFS_flush() docs. Upped version to
0.1.8.
12172002 - Added Apple Project Builder support files (thanks, Eric Wing!).
12112002 - Added Ruby bindings to extras directory (thanks, Ed Sinjiashvili!).
Patched win32.c to compile with Mingw32 (thanks, Niels Wagenaar!).
12032002 - Adam updated his extras/abs-file.h for the new buffering API.
12022002 - German translation added, compliments of Michael Renner.
12012002 - Minor fix to configure.in: reported --enable-debug's default
setting incorrectly. Added buffering to the API: you can now
buffer a file with PHYSFS_setBuffer(), and flush the buffer to
disk with PHYSFS_flush(). PhysicsFS file handles are unbuffered
by default (as they were before this API addition), so this does
not break the API. Other fixes for bugs I stumbled upon during
this work are in CVS, too.
11292002 - Minor fix for strange PATH strings in unix.c (thanks, Alexander!)
11222002 - Initial PocketPC port by Corona688.
10222002 - Fixed segfault in test_physfs.c when user hits CTRL-D (and
readline() thus returns NULL)...now gracefully exits, as it should.
10142002 - Added check for AMD's x86-64 ("Hammer") architecture when
determining platform byte order.
10112002 - Fixed "setsaneconfig" command in test_physfs.c ...
09232002 - Happy September. Updated VC++6 project files, fixed some
VC++ compile nags (more work to be done in zip.c).
08302002 - Cleaned tab stops out of zip.c, and fixed a possible infinite loop
in zip_find_entry().
08292002 - Fixed a mistake in makeos2.cmd, and updated the INSTALL docs.
Added physfs.spec.in to EXTRA_DIST in Makefile.am*
08292002 - Added a physfs/stdio wrapper header to the "extras" dir,
compliments of Adam D. Moss (file is "abs-file.h").
08282002 - Cleanups in grp.c so that Visual C++ doesn't complain anymore.
zip.c now works correctly when PhysicsFS is disallowing symlinks.
A few minor optimizations in zip.c, with a few more to come later.
Added VS.NET project files to CVS.
08222002 - Fixed ZIP_exists() to work with directories. Now breaks out of
__PHYSFS_verifySecurity() early if a path element is missing
(since all the others will be, too)...this check is only done
if symlinks are disabled, but we might as well save easy cycles
where we can.
08212002 - Did a couple tedious-for-small-rewards cleanups, optimizations,
corrections and streamlinings I've been meaning to do. Touched a
lot of code. One of the side results is that ZIP_isDirectory()
got fixed.
08192002 - Generalized sorting routines, moved them into physfs.c and removed
the multiple copies from the various archivers. Adding profiling
code (currently only for sort routines)...enable it with
--enable-profiling in the configure script. Fixed incorrect
behaviours in configure.in.
08172002 - Patched configure.in to work around buggy autoconfs.
08162002 - Fixed QPAK archiver, since I broke it (sorry!). Also fixed a
qpak memory leak.
08092002 - Added Quake PAK archiver (qpak.c) by Ed Sinjiashvili. Thanks!
Made (successful?) attempt to fix pthread-to-ui64 cast problem.
Check for OS/2 in configure.in, in case anyone gets autoconf and
such to work right on their OS/2 box.
08012002 - Patched win32.c to compile.
07302002 - Minor error handling fix (thanks, Alexander!)
07292002 - Found some memory leaks, thanks to Valgrind (which rules, btw).
Added Russian translations (koi8-r, cp1251, cp866, and iso-8859-5)
by Ed Sinjiashvili. Added Spanish translation by Pedro J. P<>rez.
Debian package support in CVS, thanks to Colin Bayer. French
translation by St<53>phane Peter.
07282002 - macclassic.c now returns human readable error messages instead of
ERR_OS_ERROR. Closing files on MacOS no longer fails if the volume
info can't be flushed. Minor error message tweak in os2.c. All
possible human-readable literal strings (including all those OS/2
and MacOS error messages) have moved to constants in
physfs_internal.h...this allows the library to be translated to
other spoken languages fairly easily.
07272002 - Patched the OS/2 code to be useful...works pretty well, now. Added
makeos2.cmd for building (not an ideal solution, but oh well).
Initialized some variables in zip.c to prevent compiler whining.
07262002 - Fixed a typo in documentation. Archivers with matching file
extensions are now given first shot at opening an archive, but if
they fail, the other archivers are tried. More fixes to zip.c's
ZIP_enumerateFiles(). Wrote an OS/2 platform driver based on API
specs and a heavy pounding of Google Groups...as I don't have an
OS/2 compiler at the moment, it probably doesn't even compile. :)
07252002 - configure.in and unix.c now deal with platforms that lack a
functional pthread library. Edward Rudd sent in a patch to the RPM
specfile to have the build system set the correct version.
Clean ups in grp.c, beos.cpp and macclassic.c.
07242002 - Rewrote ZIP_enumerate(). Hopefully it sucks less this time.
unix.c and configure.in now have the infrastructure to disable
the CD-ROM detection code, and use a stub that successfully (and
unconditionally) reports no detected discs. Currently this is
used on AtheOS (which doesn't have CD-ROM support at the moment
anyhow), but it will be useful to get the library up on odd,
Unix-like systems that don't use either getmntinfo() or getmntent().
07232002 - Cleaned up the cut-and-pastes in the various file enumeration
routines and moved it into __PHYSFS_addToLinkedStringList().
Tons more ZIP file enhancing. I'm fairly certain it's robust and
fast in every reasonable respect, now. GRP archiver now caches
the file table...it was generally overhauled like the ZIP driver.
Added "ls" as an alias of "enumerate" in test_physfs.
I lied about zip.c's robustness; disabled the enumeration code.
07212002 - More FreeBSD build system patches. Added some new autoconf spew to
.cvsignore. bootstrap now copies the appropriate Makefile.am
instead of rename()ing it.
07192002 - Cleaned up configure.in and unix.c so that we check by available
header to determine the appropriate CD-ROM detection code...this
should make this more future-proof (and probably get it building
out of the box on other BSD platforms.)
07172002 - Fixed seeking backwards in ZIP_seek(). Changed the error message
ERR_TOO_MANY_SYMLINKS to ERR_SYMLINK_LOOP. Patches to build system
and unix.c for FreeBSD compatibility. Added physfs.spec to
"make dist" archives (thanks, Edward Rudd!).
07152002 - Symlinks in ZIP archives are detected correctly now, I think.
07142002 - Use GetVolumeInformation() instead of GetDiskFreeSpace() in
win32.c's mediaInDrive() function. This allows Windows NT 3.x to
correctly detect CD-ROM drives. Library now appears to be fully
functional on WinNT 3.51...need to try NT 3.1 still. :)
Patches to new ZIP code; cleaned up bugs in symlink reading code,
but we incorrectly identify some entries as symlinks, which doesn't
fly...for now, symlink code is commented out, so symlinks look
like regular files (and reading from a symlink entry gives you
the link as file data).
07122002 - Rewrote the ZIP archiver to no longer use Gilles Vollant's unzip.c
code. Losing that abstraction should make the ZIP archiver
significantly more efficient, and halved the amount of code used.
Plus, being a control freak, I like my coding style more than
Gilles's. :) There are still bugs to shake out, but this is good
progress.
07112002 - configure.in updated to make it happier on newer autoconfs
(thanks again, Alexander!). FIXME cleanups.
07102002 - Added a byteorder-friendly convenience API, so you can read/write
data and convert to the native byteorder without too much effort.
Upped version to 0.1.7.
Build system corrections for BeOS and Cygwin (thanks, Alexander!).
Added RPM specfile for PhysicsFS (thanks, Edward Rudd!).
06292002 - Fixed incorrect error message when opening a file for read without
defining a search path. LOTS of win32 updates and fixes; lots of
things that were broken work now, and we are slowly becoming
more compatible with legacy win32 systems. Builds on Cygwin again.
All platform drivers (except beos.cpp) had a buffer overflow when
detecting mounted CD-ROM drives...it only occurs when a drive is
detected, and it probably won't result in your box getting rooted,
but upgrade soon anyhow. Readded the .cvsignore files from the old
build system.
06282002 - Reworked build system _AGAIN_.
06222002 - Alexander Pipelka spotted a bug in the file open routines in
posix.c; patched.
06152002 - Autoconf build system will now generate shared libraries on BeOS,
and (supposedly) Cygwin.
06142002 - Rewrote autoconf build system. It now works around the MacOS X bug
that prevented shared libraries from building.
06112002 - Updated CodeWarrior projects and added them to CVS. _Finally_
officially released 0.1.6.
06102002 - Major overhauls to platform/win32.c ... should work on all Windows
platforms, including 95/98/ME and NT/2K/XP flavors. Someone should
see if this builds on WinCE! :) You no longer need the latest
platform SDK to build it, either; the questionable DLL is accessed
with LoadLibrary() at runtime now, and handled if not present. This
now builds correctly on a freshly installed Visual Studio 6.0, and
the DLL it builds works everywhere. Plus, a bunch of other bugs
and incorrect behaviours were squashed. Visual Studio 6.0 project
file added to CVS.
06082002 - Fixes to __PHYSFS_platformEnumerateFiles() in win32.c: cleaned up
memory leak, handles paths more robustly, and prevents possible
skipped file entries. Removed AC_C_CONST and AC_TYPE_SIZE_T checks
from configure.in (not needed, and they broke BeOS build). Clean
out the docs/ directory when doing a "make dist". Fixed crashbug
when calling PHYSFS_deinit() more than once in a row. Tried to get
MacOS X to build a shared library, gave up; I'm doing something
wrong in my Makefile.am, I think. On MacOS X, running ./configure
--enable-static --disable-shared works, though. Hopefully someone
will fix this soon. In unix.c, the Darwin version of
__PHYSFS_platformDetectAvailableCDs() was free()ing a static
buffer; fixed.
06072002 - Manpages! Finally installed Doxygen and scratched together a
Doxyfile. After some revision to physfs.h, we've got a rather
nice API reference.
06062002 - Fixed __PHYSFS_platformSeek() in archivers/posix.c. Implemented the
getLastModTime method in archivers/zip.c (returns legitimate info)
and archivers/grp.c (returns lastmodtime of GRPfile itself in the
physical filesystem). Put a 64-bit _llseek() version of the seek()
and tell() methods in platform/posix.c, but you need to hack (or
rather, fix) configure.in to enable it. From Greg on win32.c: Fixed
file enumerator function (needed a wildcard '*' specification), CD
enumeration only reports CDs that have media, getLastModTime() has
been implemented.
06012002 - Added -Wall to debug builds. Removed ANSI stdio calls from
platform/posix.c, and replaced them with actual POSIX calls (that
is, fopen() became open(), fseek() became lseek(), etc...)
05272002 - Added some explicit casts when calling malloc() in platform/posix.c
05252002 - Added John Hall's file modification time patch, and added a
getlastmodtime command to test_physfs. Corrected error reporting
for missing files a little bit. Changed build system to only try
building beos.cpp if on a BeOS system (since we need a C++ compiler
available to do so). Implemented getLastModTime in macclassic.c.
05242002 - Upped version to 0.1.6 (not officially released yet).
05232002 - Fixed the build system to always package the complete source, not
just what we built for a given system, when doing a "make dist".
Updated INSTALL. Wrote BeOS platform code (platform/beos.cpp).
Split unix.c into unix.c and posix.c. Linux and BeOS both share
posix.c, although I don't think it's completely POSIX compliant at
this point (not that it matters much).
05212002 - Cleaned up some FIXMEs.
05202002 - Added .cvsignore files.
05162002 - Edward Rudd also caught an embarrassing screwup by me in
unix.c: the open-for-append call was using "wb+" instead of
"ab" when calling fopen(). Doh!
05152002 - configure script now deals with systems that have a readline
lib, but require it to be linked with curses. Thanks to Edward
Rudd for the patch.
05102002 - A trimmed-down zlib 1.1.4 is now included in the source distro, for
use by win32, MacOS, and Unix systems that don't have it installed
on the system. Autoconf support! Initial attempt at this. Lots of
stuff may be very broken.
05082002 - From Greg: More win32 work. Library is now 95% functional on win32.
Only known win32 problem is that the CD drives are reported whether
they contain a disc or not).
05062002 - From Greg: Win32 boxes without the latest Platform SDK can now
#define DISABLE_NT_SUPPORT. Other fixes.
04242002 - Updated win32 info in INSTALL to discuss Platform SDK issues.
04202002 - Added a (very) quick and (very) dirty http server to the
extras directory (public domain), as another example of using
the library.
04192002 - Corrected some win32 info in INSTALL. Changed Makefile to
package releases as .tar.gz instead of .tar.bz2.
04122002 - Some win32 cleanups and fixes across several files. Upped
version to 0.1.5.
04082002 - Fixed problem when calling __PHYSFS_setError before PHYSFS_init.
04062002 - Added MacOS info, etc to INSTALL. Patched unix.c and
test_physfs.c to compile on Darwin again.
04052002 - Added byte ordering API. Byte ordering fixes in grp.c, and some
cleanups in unzip.c. Mac work is more or less complete.
04042002 - Mac work continues. Almost complete, now. test_physfs now has
tests for write, append, and filelength, and most of the
commands can tolerate a quoted argument (although this is
hacky, it's good enough for these purposes). Upped test_physfs
version to 0.1.1. Added a malloc-failure check in the Unix
CD-ROM detection code.
04032002 - PHYSFS_init always makes sure the calling thread initializes its
error state. Win32 codebase is updated with mutex implementation
(thanks, Greg!).
04022002 - Mac work continues. Found a bug where we put a double dir
separator in if we had to resort to the fallback userdir (if
__PHYSFS_platformGetUserDir() returned NULL to calculateUserDir().
Made note of potential infinite recursion in platform driver docs.
04012002 - (_NOT_ an April Fool's Joke:) Started working on MacOS Classic
port. Added skeleton.c to platform directory. Minor patches to
get things compiling on Mac (notably, DirInfo conflicts with
a type exposed by MacOS's namespace-polluting API, and some
typecasting issues). Found a call to ferror() I had missed in
unzip.c.
03302002 - Mutexes! PhysicsFS should be thread safe now, so long as you
don't try to do something like close a file at the same time as
you are reading from it in another thread. All reasonable race
conditions should now be gone, but the new code will need some
eyeballing before we install it on life support systems or anything.
The mutex abstraction is implemented in unix.c, win32.c will be
updated shortly.
03292002 - Fixed a potential problem in ZIP_realpath() and some byte order
issues in zip.c. Converted unzip.c to use physfs file i/o
abstractions. Converted CHANGELOG to list latest entries first.
03242002 - Added __PHYSFS_platformInit() and __PHYSFS_platformDeinit(). Win32
improvements by Gregory S. Read. Added PHYSFS_[us]int(8|16|32)
types...this breaks binary compatibility with previous PhysicsFS
releases! Added platform specific i/o functions, so we don't have
to rely on stdio anymore. Updated TODO with my comments on the
physfs mailing list. 1.0, here we come! Removed race condition from
grp.c and converted to file i/o abstraction layer calls from stdio.
Tons of other fixes and enhancements.
03202002 - Patched platform/win32.c to compile.
03152002 - PHYSFS_setSaneConfig() now handles failure to set the write dir
better. Patched makefile to link the test program. Changed all the
"write" functions to get data from a "const" buffer. Added an
"extras" dir, which currently contains PhysFS->SDL_RWops glue code.
03052002 - Made unix.c's timeslice implementation more portable, and added a
Darwin-specific means to detect CDs (thanks to Patrick Stein).
Minor cleanup in win32.c (changed "for (; condition ;)" into
"while (condition)" ...)
11142001 - Removed a redundant error check in platform/win32.c
10092001 - Syntax fixes in dir.c, a FIXME in grp.c, and a "cat" command in
the test program. Apparently I had accidentally removed a rather
crucial line from dir.c a few revisions ago, and no one noticed. :(
Fixed. The win32 userdir will default to the base dir, now.
09252001 - Changed API: PHYSFS_setSaneConfig() takes an organization name, and
sets up less directories. Be warned. Fixes from David Hedbor:
make setSaneConfig() set write directory correctly if it had to
create the directory, and make sure that the writing functions
get used in dir.c when a file is opened for writing/appending.
Updated CREDITS.
09142001 - David Hedbor submitted a patch to handle a case where the
current working directory has been deleted out from under the
process (both in platform/unix.c and physfs.c itself). Thanks,
David! Added a CREDITS file. Changed the format of the author field
in PHYSFS_ArchiveInfo to put the email address between "<>" instead
of "()" chars. Updated TODO. make install now deletes previous
revisions of the library. Changed version to 0.1.4.
09012001 - Happy September. Moved the Visual C project files and the zlib
source to a separate download. Look for it at
http://icculus.org/physfs/downloads/physfs-win32-support.zip ...
Updated the INSTALL doc for Win32 building. Rewrote win32.c's
__PHYSFS_platformRealPath() to not rely on Visual C's runtime lib,
which was the last Cygwin incompatibility (although the Makefile
needs to be updated to build a DLL under Cygwin). Tinkered with the
Makefile a little, but it needs more work. Started working on a
MacOS version. All I have is CodeWarrior 4, which is way out of
date, and (for what is supposed to be an ultra-user-friendly
environment) is completely uninituitive to me. Still, managed to
get most everything compiling, which improved the quality of the
code somewhat). Haven't tried to compile the zipfile support, and
I still can't link the library. Dunno what the hell I'm supposed
to do there. Isn't Unix supposed to be hard compared to this?
08312001 - Built PhysicsFS on Mandrake 8.0 for the PowerPC. Compiles clean,
but there's at least one byte-ordering issue in zip.c that needs
to be fixed.
08292001 - win32.c calculates the base dir with GetModuleFileName() first, now,
and falls back to SearchPath() if there were problems. Changed an
occurence of _MAX_PATH to MAX_PATH, so both CygWin and Visual C can
handle it.
08282001 - win32.c now checks HOMEDRIVE, HOMEPATH, and HOME when calculating
the userdir. Added include files that make it a little closer to
compiling under Cygwin. Added a TODO file. Fixed unix.c's
__PHYSFS_platformCalcBaseDir() so that it actually works. Fixed
Makefile so that it links the test program properly.
Changed version to 0.1.3.
08232001 - Fixed a potential free()ing of a NULL pointer in
__PHYSFS_platformEnumerateFiles() in platform/unix.c. Added
platform/win32.c. Other cleanups to get this compiling with
Visual C and CygWin. Added BAIL_MACRO for times when we were doing
BAIL_IF_MACRO(1, ...). Abstracted mkdir() in the platform drivers.
Added GRP setting output to showcfg in the Makefile. Updated INSTALL
with license info and Win32 build instructions. Dependency on the
readline library in test_physfs.c is now optional.
Changed version to 0.1.2.
08072001 - Changed version to 0.1.1.
08062001 - Added CD-ROM detection code to the unix platform driver.
08012001 - Added a safety memset in error setting, fixed URLs and email addr.
07282001 - Initial release.
--ryan. (icculus@icculus.org)
/* end of CHANGELOG ... */

95
physfs/CREDITS.txt Normal file
View File

@ -0,0 +1,95 @@
Maintainer and general codemonkey:
Ryan C. Gordon
Tons of win32 help:
Adam Gates
More win32 hacking:
Gregory S. Read
Fixes for missing current working directories,
PHYSFS_setSaneConfig() improvements,
other bugfixes:
David Hedbor
Darwin support:
Patrick Stein
configure fixes,
RPM specfile:
Edward Rudd
GetLastModTime API,
other stuff:
John R. Hall
Various support, fixes and suggestions:
Alexander Pipelka
Russian translation,
Ruby bindings,
QPAK archiver:
Ed Sinjiashvili
French translation:
St<53>phane Peter
Debian package support:
Colin Bayer
"abs-file.h" in "extras" dir:
Adam D. Moss
WinCE port and other Win32 patches:
Corona688
German translation:
Michael Renner
Apple Project Builder support,
Mac OS X improvements:
Eric Wing
HOG archiver,
MVL archiver:
Bradley Bell
MIX archiver:
Sebastian Steinhauer
Bug fixes:
Tolga Dalman
Initial PHYSFS_mount() work:
Philip D. Bober
Brazillian Portuguese translation:
Danny Angelo Carminati Grein
Spanish translation:
Pedro J. P<>rez
MacOS Classic fixes,
MPW support,
bug fixes:
Chris Taylor
Mingw support,
General bug fixes:
Matze Braun
Bug fixes:
J<>rg Walter
Windows .rc file,
7zip/lzma archiver:
Dennis Schridde
OS/2 updates:
Dave Yeo
Other stuff:
Your name here! Patches go to icculus@icculus.org ...
/* end of CREDITS.txt ... */

29
physfs/LICENSE.txt Normal file
View File

@ -0,0 +1,29 @@
Copyright (c) 2003 Ryan C. Gordon and others.
This software is provided 'as-is', without any express or implied warranty.
In no event will the authors be held liable for any damages arising from
the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software in a
product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
Ryan C. Gordon <icculus@icculus.org>
(Please note that versions of PhysicsFS prior to 0.1.9 are licensed under
the GNU Lesser General Public License, which restricts you significantly more.
For your own safety, please make sure you've got 0.1.9 or later if you plan
to use physfs in a commercial or closed-source project.)

29
physfs/Makefile Normal file
View File

@ -0,0 +1,29 @@
include ../Makefile.common
CFLAGS += -I. -I../zlib -DPHYSFS_SUPPORTS_ZIP
ifeq ($(OS),LINUX)
OBJ = platform/posix.o platform/unix.o
else
OBJ = platform/windows.o
endif
OBJ += $(patsubst %.c,%.o,$(wildcard *.c)) archivers/dir.o archivers/zip.o
LIBNAME = libphysfs.a
all: $(LIBNAME)
$(LIBNAME): $(OBJ)
@echo Creating archieve $@
@ar -crsu $@ $(OBJ)
@echo
clean:
-@$(RM) *.o
-@$(RM) *.d
-@$(RM) archivers$(SLASH)*.o
-@$(RM) archivers$(SLASH)*.d
-@$(RM) platform$(SLASH)*.o
-@$(RM) platform$(SLASH)*.d
-@$(RM) $(LIBNAME)

45
physfs/TODO.txt Normal file
View File

@ -0,0 +1,45 @@
Stuff that needs to be done and wishlist:
These are in no particular order.
Some might be dupes, some might be done already.
UNICODE:
- OS/2: Codepages. No full Unicode in the filesystem, but we can probably make
a conversion effort.
Stuff:
- Other archivers: perhaps tar(.gz|.bz2), RPM, ARJ, etc. These are less
important, since streaming archives aren't of much value to games (which
is why zipfiles are king: random access), but it could have uses for, say,
an installer/updater.
- Reduce malloc() pressure all over the place. We fragment memory like mad.
- profile string list interpolation.
- We have two different ways to find dir entries in zip.c.
- Do symlinks in zip archiver work when they point to dirs?
- Enable more warnings?
- Use __cdecl in physfs.h?
- Look for FIXMEs (many marked with "!!!" in comments).
- Find some way to relax or remove the security model for external tools.
- OSX shouldn't use ~/.app for userdir.
- fscanf and fprintf support in extras dir.
- Why do we call it openArchive and dirClose?
- Sanity check byte order at runtime.
- Memory locking?
- Find a better name than dvoid and fvoid.
- Can windows.c and pocketpc.c get merged?
- There's so much cut-and-paste between archivers...can this be reduced?
- General code audit.
- Multiple write dirs with mount points?
- Deprecate PHYSFS_setSaneConfig and move it to extras?
- Why is physfsrwops.c cut-and-pasted into the ruby bindings?
- Replace code from SDL...
- Should file enumeration return an error or set error state?
- Need "getmountpoint" command in test_physfs.c ...
- Look for calloc() calls that aren't going through the allocation hooks.
- Write up a simple HOWTO on embedding physicsfs in another project.
- Archivers need abstracted i/o to read from memory or files (archives in archives?)
- Probably other stuff. Requests and recommendations are welcome.
// end of TODO.txt ...

283
physfs/archivers/dir.c Normal file
View File

@ -0,0 +1,283 @@
/*
* Standard directory I/O support routines for PhysicsFS.
*
* Please see the file LICENSE.txt in the source's root directory.
*
* This file written by Ryan C. Gordon.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "physfs.h"
#define __PHYSICSFS_INTERNAL__
#include "physfs_internal.h"
static PHYSFS_sint64 DIR_read(fvoid *opaque, void *buffer,
PHYSFS_uint32 objSize, PHYSFS_uint32 objCount)
{
PHYSFS_sint64 retval;
retval = __PHYSFS_platformRead(opaque, buffer, objSize, objCount);
return(retval);
} /* DIR_read */
static PHYSFS_sint64 DIR_write(fvoid *opaque, const void *buffer,
PHYSFS_uint32 objSize, PHYSFS_uint32 objCount)
{
PHYSFS_sint64 retval;
retval = __PHYSFS_platformWrite(opaque, buffer, objSize, objCount);
return(retval);
} /* DIR_write */
static int DIR_eof(fvoid *opaque)
{
return(__PHYSFS_platformEOF(opaque));
} /* DIR_eof */
static PHYSFS_sint64 DIR_tell(fvoid *opaque)
{
return(__PHYSFS_platformTell(opaque));
} /* DIR_tell */
static int DIR_seek(fvoid *opaque, PHYSFS_uint64 offset)
{
return(__PHYSFS_platformSeek(opaque, offset));
} /* DIR_seek */
static PHYSFS_sint64 DIR_fileLength(fvoid *opaque)
{
return(__PHYSFS_platformFileLength(opaque));
} /* DIR_fileLength */
static int DIR_fileClose(fvoid *opaque)
{
/*
* we manually flush the buffer, since that's the place a close will
* most likely fail, but that will leave the file handle in an undefined
* state if it fails. Flush failures we can recover from.
*/
BAIL_IF_MACRO(!__PHYSFS_platformFlush(opaque), NULL, 0);
BAIL_IF_MACRO(!__PHYSFS_platformClose(opaque), NULL, 0);
return(1);
} /* DIR_fileClose */
static int DIR_isArchive(const char *filename, int forWriting)
{
/* directories ARE archives in this driver... */
return(__PHYSFS_platformIsDirectory(filename));
} /* DIR_isArchive */
static void *DIR_openArchive(const char *name, int forWriting)
{
const char *dirsep = PHYSFS_getDirSeparator();
char *retval = NULL;
size_t namelen = strlen(name);
size_t seplen = strlen(dirsep);
/* !!! FIXME: when is this not called right before openArchive? */
BAIL_IF_MACRO(!DIR_isArchive(name, forWriting),
ERR_UNSUPPORTED_ARCHIVE, 0);
retval = allocator.Malloc(namelen + seplen + 1);
BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL);
/* make sure there's a dir separator at the end of the string */
strcpy(retval, name);
if (strcmp((name + namelen) - seplen, dirsep) != 0)
strcat(retval, dirsep);
return(retval);
} /* DIR_openArchive */
static void DIR_enumerateFiles(dvoid *opaque, const char *dname,
int omitSymLinks, PHYSFS_EnumFilesCallback cb,
const char *origdir, void *callbackdata)
{
char *d = __PHYSFS_platformCvtToDependent((char *)opaque, dname, NULL);
if (d != NULL)
{
__PHYSFS_platformEnumerateFiles(d, omitSymLinks, cb,
origdir, callbackdata);
allocator.Free(d);
} /* if */
} /* DIR_enumerateFiles */
static int DIR_exists(dvoid *opaque, const char *name)
{
char *f = __PHYSFS_platformCvtToDependent((char *) opaque, name, NULL);
int retval;
BAIL_IF_MACRO(f == NULL, NULL, 0);
retval = __PHYSFS_platformExists(f);
allocator.Free(f);
return(retval);
} /* DIR_exists */
static int DIR_isDirectory(dvoid *opaque, const char *name, int *fileExists)
{
char *d = __PHYSFS_platformCvtToDependent((char *) opaque, name, NULL);
int retval = 0;
BAIL_IF_MACRO(d == NULL, NULL, 0);
*fileExists = __PHYSFS_platformExists(d);
if (*fileExists)
retval = __PHYSFS_platformIsDirectory(d);
allocator.Free(d);
return(retval);
} /* DIR_isDirectory */
static int DIR_isSymLink(dvoid *opaque, const char *name, int *fileExists)
{
char *f = __PHYSFS_platformCvtToDependent((char *) opaque, name, NULL);
int retval = 0;
BAIL_IF_MACRO(f == NULL, NULL, 0);
*fileExists = __PHYSFS_platformExists(f);
if (*fileExists)
retval = __PHYSFS_platformIsSymLink(f);
allocator.Free(f);
return(retval);
} /* DIR_isSymLink */
static PHYSFS_sint64 DIR_getLastModTime(dvoid *opaque,
const char *name,
int *fileExists)
{
char *d = __PHYSFS_platformCvtToDependent((char *) opaque, name, NULL);
PHYSFS_sint64 retval = -1;
BAIL_IF_MACRO(d == NULL, NULL, 0);
*fileExists = __PHYSFS_platformExists(d);
if (*fileExists)
retval = __PHYSFS_platformGetLastModTime(d);
allocator.Free(d);
return(retval);
} /* DIR_getLastModTime */
static fvoid *doOpen(dvoid *opaque, const char *name,
void *(*openFunc)(const char *filename),
int *fileExists)
{
char *f = __PHYSFS_platformCvtToDependent((char *) opaque, name, NULL);
void *rc = NULL;
BAIL_IF_MACRO(f == NULL, NULL, NULL);
if (fileExists != NULL)
{
*fileExists = __PHYSFS_platformExists(f);
if (!(*fileExists))
{
allocator.Free(f);
return(NULL);
} /* if */
} /* if */
rc = openFunc(f);
allocator.Free(f);
return((fvoid *) rc);
} /* doOpen */
static fvoid *DIR_openRead(dvoid *opaque, const char *fnm, int *exist)
{
return(doOpen(opaque, fnm, __PHYSFS_platformOpenRead, exist));
} /* DIR_openRead */
static fvoid *DIR_openWrite(dvoid *opaque, const char *filename)
{
return(doOpen(opaque, filename, __PHYSFS_platformOpenWrite, NULL));
} /* DIR_openWrite */
static fvoid *DIR_openAppend(dvoid *opaque, const char *filename)
{
return(doOpen(opaque, filename, __PHYSFS_platformOpenAppend, NULL));
} /* DIR_openAppend */
static int DIR_remove(dvoid *opaque, const char *name)
{
char *f = __PHYSFS_platformCvtToDependent((char *) opaque, name, NULL);
int retval;
BAIL_IF_MACRO(f == NULL, NULL, 0);
retval = __PHYSFS_platformDelete(f);
allocator.Free(f);
return(retval);
} /* DIR_remove */
static int DIR_mkdir(dvoid *opaque, const char *name)
{
char *f = __PHYSFS_platformCvtToDependent((char *) opaque, name, NULL);
int retval;
BAIL_IF_MACRO(f == NULL, NULL, 0);
retval = __PHYSFS_platformMkDir(f);
allocator.Free(f);
return(retval);
} /* DIR_mkdir */
static void DIR_dirClose(dvoid *opaque)
{
allocator.Free(opaque);
} /* DIR_dirClose */
const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_DIR =
{
"",
DIR_ARCHIVE_DESCRIPTION,
"Ryan C. Gordon <icculus@icculus.org>",
"http://icculus.org/physfs/",
};
const PHYSFS_Archiver __PHYSFS_Archiver_DIR =
{
&__PHYSFS_ArchiveInfo_DIR,
DIR_isArchive, /* isArchive() method */
DIR_openArchive, /* openArchive() method */
DIR_enumerateFiles, /* enumerateFiles() method */
DIR_exists, /* exists() method */
DIR_isDirectory, /* isDirectory() method */
DIR_isSymLink, /* isSymLink() method */
DIR_getLastModTime, /* getLastModTime() method */
DIR_openRead, /* openRead() method */
DIR_openWrite, /* openWrite() method */
DIR_openAppend, /* openAppend() method */
DIR_remove, /* remove() method */
DIR_mkdir, /* mkdir() method */
DIR_dirClose, /* dirClose() method */
DIR_read, /* read() method */
DIR_write, /* write() method */
DIR_eof, /* eof() method */
DIR_tell, /* tell() method */
DIR_seek, /* seek() method */
DIR_fileLength, /* fileLength() method */
DIR_fileClose /* fileClose() method */
};
/* end of dir.c ... */

1441
physfs/archivers/zip.c Normal file
View File

File diff suppressed because it is too large Load Diff

2220
physfs/physfs.c Normal file
View File

File diff suppressed because it is too large Load Diff

2392
physfs/physfs.h Normal file
View File

File diff suppressed because it is too large Load Diff

324
physfs/physfs_byteorder.c Normal file
View File

@ -0,0 +1,324 @@
/**
* PhysicsFS; a portable, flexible file i/o abstraction.
*
* Documentation is in physfs.h. It's verbose, honest. :)
*
* Please see the file LICENSE.txt in the source's root directory.
*
* This file written by Ryan C. Gordon.
*/
#include <stdio.h>
#include <stdlib.h>
#define __PHYSICSFS_INTERNAL__
#include "physfs_internal.h"
/* The macros used to swap values */
/* Try to use superfast macros on systems that support them */
#ifdef linux
#include <asm/byteorder.h>
#ifdef __arch__swab16
#define PHYSFS_Swap16 __arch__swab16
#endif
#ifdef __arch__swab32
#define PHYSFS_Swap32 __arch__swab32
#endif
#endif /* linux */
#if (defined macintosh) && !(defined __MWERKS__)
#define __inline__
#endif
#if (defined _MSC_VER)
#define __inline__ __inline
#endif
#ifndef PHYSFS_Swap16
static __inline__ PHYSFS_uint16 PHYSFS_Swap16(PHYSFS_uint16 D)
{
return((D<<8)|(D>>8));
}
#endif
#ifndef PHYSFS_Swap32
static __inline__ PHYSFS_uint32 PHYSFS_Swap32(PHYSFS_uint32 D)
{
return((D<<24)|((D<<8)&0x00FF0000)|((D>>8)&0x0000FF00)|(D>>24));
}
#endif
#ifndef PHYSFS_NO_64BIT_SUPPORT
#ifndef PHYSFS_Swap64
static __inline__ PHYSFS_uint64 PHYSFS_Swap64(PHYSFS_uint64 val) {
PHYSFS_uint32 hi, lo;
/* Separate into high and low 32-bit values and swap them */
lo = (PHYSFS_uint32)(val&0xFFFFFFFF);
val >>= 32;
hi = (PHYSFS_uint32)(val&0xFFFFFFFF);
val = PHYSFS_Swap32(lo);
val <<= 32;
val |= PHYSFS_Swap32(hi);
return(val);
}
#endif
#else
#ifndef PHYSFS_Swap64
/* This is mainly to keep compilers from complaining in PHYSFS code.
If there is no real 64-bit datatype, then compilers will complain about
the fake 64-bit datatype that PHYSFS provides when it compiles user code.
*/
#define PHYSFS_Swap64(X) (X)
#endif
#endif /* PHYSFS_NO_64BIT_SUPPORT */
/* Byteswap item from the specified endianness to the native endianness */
#if PHYSFS_BYTEORDER == PHYSFS_LIL_ENDIAN
PHYSFS_uint16 PHYSFS_swapULE16(PHYSFS_uint16 x) { return(x); }
PHYSFS_sint16 PHYSFS_swapSLE16(PHYSFS_sint16 x) { return(x); }
PHYSFS_uint32 PHYSFS_swapULE32(PHYSFS_uint32 x) { return(x); }
PHYSFS_sint32 PHYSFS_swapSLE32(PHYSFS_sint32 x) { return(x); }
PHYSFS_uint64 PHYSFS_swapULE64(PHYSFS_uint64 x) { return(x); }
PHYSFS_sint64 PHYSFS_swapSLE64(PHYSFS_sint64 x) { return(x); }
PHYSFS_uint16 PHYSFS_swapUBE16(PHYSFS_uint16 x) { return(PHYSFS_Swap16(x)); }
PHYSFS_sint16 PHYSFS_swapSBE16(PHYSFS_sint16 x) { return(PHYSFS_Swap16(x)); }
PHYSFS_uint32 PHYSFS_swapUBE32(PHYSFS_uint32 x) { return(PHYSFS_Swap32(x)); }
PHYSFS_sint32 PHYSFS_swapSBE32(PHYSFS_sint32 x) { return(PHYSFS_Swap32(x)); }
PHYSFS_uint64 PHYSFS_swapUBE64(PHYSFS_uint64 x) { return(PHYSFS_Swap64(x)); }
PHYSFS_sint64 PHYSFS_swapSBE64(PHYSFS_sint64 x) { return(PHYSFS_Swap64(x)); }
#else
PHYSFS_uint16 PHYSFS_swapULE16(PHYSFS_uint16 x) { return(PHYSFS_Swap16(x)); }
PHYSFS_sint16 PHYSFS_swapSLE16(PHYSFS_sint16 x) { return(PHYSFS_Swap16(x)); }
PHYSFS_uint32 PHYSFS_swapULE32(PHYSFS_uint32 x) { return(PHYSFS_Swap32(x)); }
PHYSFS_sint32 PHYSFS_swapSLE32(PHYSFS_sint32 x) { return(PHYSFS_Swap32(x)); }
PHYSFS_uint64 PHYSFS_swapULE64(PHYSFS_uint64 x) { return(PHYSFS_Swap64(x)); }
PHYSFS_sint64 PHYSFS_swapSLE64(PHYSFS_sint64 x) { return(PHYSFS_Swap64(x)); }
PHYSFS_uint16 PHYSFS_swapUBE16(PHYSFS_uint16 x) { return(x); }
PHYSFS_sint16 PHYSFS_swapSBE16(PHYSFS_sint16 x) { return(x); }
PHYSFS_uint32 PHYSFS_swapUBE32(PHYSFS_uint32 x) { return(x); }
PHYSFS_sint32 PHYSFS_swapSBE32(PHYSFS_sint32 x) { return(x); }
PHYSFS_uint64 PHYSFS_swapUBE64(PHYSFS_uint64 x) { return(x); }
PHYSFS_sint64 PHYSFS_swapSBE64(PHYSFS_sint64 x) { return(x); }
#endif
int PHYSFS_readSLE16(PHYSFS_File *file, PHYSFS_sint16 *val)
{
PHYSFS_sint16 in;
BAIL_IF_MACRO(val == NULL, ERR_INVALID_ARGUMENT, 0);
BAIL_IF_MACRO(PHYSFS_read(file, &in, sizeof (in), 1) != 1, NULL, 0);
*val = PHYSFS_swapSLE16(in);
return(1);
} /* PHYSFS_readSLE16 */
int PHYSFS_readULE16(PHYSFS_File *file, PHYSFS_uint16 *val)
{
PHYSFS_uint16 in;
BAIL_IF_MACRO(val == NULL, ERR_INVALID_ARGUMENT, 0);
BAIL_IF_MACRO(PHYSFS_read(file, &in, sizeof (in), 1) != 1, NULL, 0);
*val = PHYSFS_swapULE16(in);
return(1);
} /* PHYSFS_readULE16 */
int PHYSFS_readSBE16(PHYSFS_File *file, PHYSFS_sint16 *val)
{
PHYSFS_sint16 in;
BAIL_IF_MACRO(val == NULL, ERR_INVALID_ARGUMENT, 0);
BAIL_IF_MACRO(PHYSFS_read(file, &in, sizeof (in), 1) != 1, NULL, 0);
*val = PHYSFS_swapSBE16(in);
return(1);
} /* PHYSFS_readSBE16 */
int PHYSFS_readUBE16(PHYSFS_File *file, PHYSFS_uint16 *val)
{
PHYSFS_uint16 in;
BAIL_IF_MACRO(val == NULL, ERR_INVALID_ARGUMENT, 0);
BAIL_IF_MACRO(PHYSFS_read(file, &in, sizeof (in), 1) != 1, NULL, 0);
*val = PHYSFS_swapUBE16(in);
return(1);
} /* PHYSFS_readUBE16 */
int PHYSFS_readSLE32(PHYSFS_File *file, PHYSFS_sint32 *val)
{
PHYSFS_sint32 in;
BAIL_IF_MACRO(val == NULL, ERR_INVALID_ARGUMENT, 0);
BAIL_IF_MACRO(PHYSFS_read(file, &in, sizeof (in), 1) != 1, NULL, 0);
*val = PHYSFS_swapSLE32(in);
return(1);
} /* PHYSFS_readSLE32 */
int PHYSFS_readULE32(PHYSFS_File *file, PHYSFS_uint32 *val)
{
PHYSFS_uint32 in;
BAIL_IF_MACRO(val == NULL, ERR_INVALID_ARGUMENT, 0);
BAIL_IF_MACRO(PHYSFS_read(file, &in, sizeof (in), 1) != 1, NULL, 0);
*val = PHYSFS_swapULE32(in);
return(1);
} /* PHYSFS_readULE32 */
int PHYSFS_readSBE32(PHYSFS_File *file, PHYSFS_sint32 *val)
{
PHYSFS_sint32 in;
BAIL_IF_MACRO(val == NULL, ERR_INVALID_ARGUMENT, 0);
BAIL_IF_MACRO(PHYSFS_read(file, &in, sizeof (in), 1) != 1, NULL, 0);
*val = PHYSFS_swapSBE32(in);
return(1);
} /* PHYSFS_readSBE32 */
int PHYSFS_readUBE32(PHYSFS_File *file, PHYSFS_uint32 *val)
{
PHYSFS_uint32 in;
BAIL_IF_MACRO(val == NULL, ERR_INVALID_ARGUMENT, 0);
BAIL_IF_MACRO(PHYSFS_read(file, &in, sizeof (in), 1) != 1, NULL, 0);
*val = PHYSFS_swapUBE32(in);
return(1);
} /* PHYSFS_readUBE32 */
int PHYSFS_readSLE64(PHYSFS_File *file, PHYSFS_sint64 *val)
{
PHYSFS_sint64 in;
BAIL_IF_MACRO(val == NULL, ERR_INVALID_ARGUMENT, 0);
BAIL_IF_MACRO(PHYSFS_read(file, &in, sizeof (in), 1) != 1, NULL, 0);
*val = PHYSFS_swapSLE64(in);
return(1);
} /* PHYSFS_readSLE64 */
int PHYSFS_readULE64(PHYSFS_File *file, PHYSFS_uint64 *val)
{
PHYSFS_uint64 in;
BAIL_IF_MACRO(val == NULL, ERR_INVALID_ARGUMENT, 0);
BAIL_IF_MACRO(PHYSFS_read(file, &in, sizeof (in), 1) != 1, NULL, 0);
*val = PHYSFS_swapULE64(in);
return(1);
} /* PHYSFS_readULE64 */
int PHYSFS_readSBE64(PHYSFS_File *file, PHYSFS_sint64 *val)
{
PHYSFS_sint64 in;
BAIL_IF_MACRO(val == NULL, ERR_INVALID_ARGUMENT, 0);
BAIL_IF_MACRO(PHYSFS_read(file, &in, sizeof (in), 1) != 1, NULL, 0);
*val = PHYSFS_swapSBE64(in);
return(1);
} /* PHYSFS_readSBE64 */
int PHYSFS_readUBE64(PHYSFS_File *file, PHYSFS_uint64 *val)
{
PHYSFS_uint64 in;
BAIL_IF_MACRO(val == NULL, ERR_INVALID_ARGUMENT, 0);
BAIL_IF_MACRO(PHYSFS_read(file, &in, sizeof (in), 1) != 1, NULL, 0);
*val = PHYSFS_swapUBE64(in);
return(1);
} /* PHYSFS_readUBE64 */
int PHYSFS_writeSLE16(PHYSFS_File *file, PHYSFS_sint16 val)
{
PHYSFS_sint16 out = PHYSFS_swapSLE16(val);
BAIL_IF_MACRO(PHYSFS_write(file, &out, sizeof (out), 1) != 1, NULL, 0);
return(1);
} /* PHYSFS_writeSLE16 */
int PHYSFS_writeULE16(PHYSFS_File *file, PHYSFS_uint16 val)
{
PHYSFS_uint16 out = PHYSFS_swapULE16(val);
BAIL_IF_MACRO(PHYSFS_write(file, &out, sizeof (out), 1) != 1, NULL, 0);
return(1);
} /* PHYSFS_writeULE16 */
int PHYSFS_writeSBE16(PHYSFS_File *file, PHYSFS_sint16 val)
{
PHYSFS_sint16 out = PHYSFS_swapSBE16(val);
BAIL_IF_MACRO(PHYSFS_write(file, &out, sizeof (out), 1) != 1, NULL, 0);
return(1);
} /* PHYSFS_writeSBE16 */
int PHYSFS_writeUBE16(PHYSFS_File *file, PHYSFS_uint16 val)
{
PHYSFS_uint16 out = PHYSFS_swapUBE16(val);
BAIL_IF_MACRO(PHYSFS_write(file, &out, sizeof (out), 1) != 1, NULL, 0);
return(1);
} /* PHYSFS_writeUBE16 */
int PHYSFS_writeSLE32(PHYSFS_File *file, PHYSFS_sint32 val)
{
PHYSFS_sint32 out = PHYSFS_swapSLE32(val);
BAIL_IF_MACRO(PHYSFS_write(file, &out, sizeof (out), 1) != 1, NULL, 0);
return(1);
} /* PHYSFS_writeSLE32 */
int PHYSFS_writeULE32(PHYSFS_File *file, PHYSFS_uint32 val)
{
PHYSFS_uint32 out = PHYSFS_swapULE32(val);
BAIL_IF_MACRO(PHYSFS_write(file, &out, sizeof (out), 1) != 1, NULL, 0);
return(1);
} /* PHYSFS_writeULE32 */
int PHYSFS_writeSBE32(PHYSFS_File *file, PHYSFS_sint32 val)
{
PHYSFS_sint32 out = PHYSFS_swapSBE32(val);
BAIL_IF_MACRO(PHYSFS_write(file, &out, sizeof (out), 1) != 1, NULL, 0);
return(1);
} /* PHYSFS_writeSBE32 */
int PHYSFS_writeUBE32(PHYSFS_File *file, PHYSFS_uint32 val)
{
PHYSFS_uint32 out = PHYSFS_swapUBE32(val);
BAIL_IF_MACRO(PHYSFS_write(file, &out, sizeof (out), 1) != 1, NULL, 0);
return(1);
} /* PHYSFS_writeUBE32 */
int PHYSFS_writeSLE64(PHYSFS_File *file, PHYSFS_sint64 val)
{
PHYSFS_sint64 out = PHYSFS_swapSLE64(val);
BAIL_IF_MACRO(PHYSFS_write(file, &out, sizeof (out), 1) != 1, NULL, 0);
return(1);
} /* PHYSFS_writeSLE64 */
int PHYSFS_writeULE64(PHYSFS_File *file, PHYSFS_uint64 val)
{
PHYSFS_uint64 out = PHYSFS_swapULE64(val);
BAIL_IF_MACRO(PHYSFS_write(file, &out, sizeof (out), 1) != 1, NULL, 0);
return(1);
} /* PHYSFS_writeULE64 */
int PHYSFS_writeSBE64(PHYSFS_File *file, PHYSFS_sint64 val)
{
PHYSFS_sint64 out = PHYSFS_swapSBE64(val);
BAIL_IF_MACRO(PHYSFS_write(file, &out, sizeof (out), 1) != 1, NULL, 0);
return(1);
} /* PHYSFS_writeSBE64 */
int PHYSFS_writeUBE64(PHYSFS_File *file, PHYSFS_uint64 val)
{
PHYSFS_uint64 out = PHYSFS_swapUBE64(val);
BAIL_IF_MACRO(PHYSFS_write(file, &out, sizeof (out), 1) != 1, NULL, 0);
return(1);
} /* PHYSFS_writeUBE64 */
/* end of physfs_byteorder.c ... */

2013
physfs/physfs_casefolding.h Normal file
View File

File diff suppressed because it is too large Load Diff

1779
physfs/physfs_internal.h Normal file
View File

File diff suppressed because it is too large Load Diff

37
physfs/physfs_platforms.h Normal file
View File

@ -0,0 +1,37 @@
#ifndef _INCL_PHYSFS_PLATFORMS
#define _INCL_PHYSFS_PLATFORMS
#ifndef __PHYSICSFS_INTERNAL__
#error Do not include this header from your applications.
#endif
/*
* These only define the platforms to determine which files in the platforms
* directory should be compiled. For example, technically BeOS can be called
* a "unix" system, but since it doesn't use unix.c, we don't define
* PHYSFS_PLATFORM_UNIX on that system.
*/
#if ((defined __BEOS__) || (defined __beos__))
# define PHYSFS_PLATFORM_BEOS
# define PHYSFS_PLATFORM_POSIX
#elif (defined _WIN32_WCE) || (defined _WIN64_WCE)
# define PHYSFS_PLATFORM_POCKETPC
#elif (((defined _WIN32) || (defined _WIN64)) && (!defined __CYGWIN__))
# define PHYSFS_PLATFORM_WINDOWS
#elif (defined OS2)
# define PHYSFS_PLATFORM_OS2
#elif ((defined __MACH__) && (defined __APPLE__))
# define PHYSFS_PLATFORM_MACOSX
# define PHYSFS_PLATFORM_POSIX
#elif defined(macintosh)
# error Classic Mac OS support was dropped from PhysicsFS 2.0. Move to OS X.
#elif defined(unix)
# define PHYSFS_PLATFORM_UNIX
# define PHYSFS_PLATFORM_POSIX
#else
# error Unknown platform.
#endif
#endif /* include-once blocker. */

459
physfs/physfs_unicode.c Normal file
View File

@ -0,0 +1,459 @@
#include "physfs.h"
#define __PHYSICSFS_INTERNAL__
#include "physfs_internal.h"
/*
* From rfc3629, the UTF-8 spec:
* http://www.ietf.org/rfc/rfc3629.txt
*
* Char. number range | UTF-8 octet sequence
* (hexadecimal) | (binary)
* --------------------+---------------------------------------------
* 0000 0000-0000 007F | 0xxxxxxx
* 0000 0080-0000 07FF | 110xxxxx 10xxxxxx
* 0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx
* 0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
*/
/*
* This may not be the best value, but it's one that isn't represented
* in Unicode (0x10FFFF is the largest codepoint value). We return this
* value from utf8codepoint() if there's bogus bits in the
* stream. utf8codepoint() will turn this value into something
* reasonable (like a question mark), for text that wants to try to recover,
* whereas utf8valid() will use the value to determine if a string has bad
* bits.
*/
#define UNICODE_BOGUS_CHAR_VALUE 0xFFFFFFFF
/*
* This is the codepoint we currently return when there was bogus bits in a
* UTF-8 string. May not fly in Asian locales?
*/
#define UNICODE_BOGUS_CHAR_CODEPOINT '?'
static PHYSFS_uint32 utf8codepoint(const char **_str)
{
const char *str = *_str;
PHYSFS_uint32 retval = 0;
PHYSFS_uint32 octet = (PHYSFS_uint32) ((PHYSFS_uint8) *str);
PHYSFS_uint32 octet2, octet3, octet4;
if (octet == 0) /* null terminator, end of string. */
return 0;
else if (octet < 128) /* one octet char: 0 to 127 */
{
(*_str)++; /* skip to next possible start of codepoint. */
return(octet);
} /* else if */
else if ((octet > 127) && (octet < 192)) /* bad (starts with 10xxxxxx). */
{
/*
* Apparently each of these is supposed to be flagged as a bogus
* char, instead of just resyncing to the next valid codepoint.
*/
(*_str)++; /* skip to next possible start of codepoint. */
return UNICODE_BOGUS_CHAR_VALUE;
} /* else if */
else if (octet < 224) /* two octets */
{
octet -= (128+64);
octet2 = (PHYSFS_uint32) ((PHYSFS_uint8) *(++str));
if ((octet2 & (128+64)) != 128) /* Format isn't 10xxxxxx? */
return UNICODE_BOGUS_CHAR_VALUE;
*_str += 2; /* skip to next possible start of codepoint. */
retval = ((octet << 6) | (octet2 - 128));
if ((retval >= 0x80) && (retval <= 0x7FF))
return retval;
} /* else if */
else if (octet < 240) /* three octets */
{
octet -= (128+64+32);
octet2 = (PHYSFS_uint32) ((PHYSFS_uint8) *(++str));
if ((octet2 & (128+64)) != 128) /* Format isn't 10xxxxxx? */
return UNICODE_BOGUS_CHAR_VALUE;
octet3 = (PHYSFS_uint32) ((PHYSFS_uint8) *(++str));
if ((octet3 & (128+64)) != 128) /* Format isn't 10xxxxxx? */
return UNICODE_BOGUS_CHAR_VALUE;
*_str += 3; /* skip to next possible start of codepoint. */
retval = ( ((octet << 12)) | ((octet2-128) << 6) | ((octet3-128)) );
/* There are seven "UTF-16 surrogates" that are illegal in UTF-8. */
switch (retval)
{
case 0xD800:
case 0xDB7F:
case 0xDB80:
case 0xDBFF:
case 0xDC00:
case 0xDF80:
case 0xDFFF:
return UNICODE_BOGUS_CHAR_VALUE;
} /* switch */
/* 0xFFFE and 0xFFFF are illegal, too, so we check them at the edge. */
if ((retval >= 0x800) && (retval <= 0xFFFD))
return retval;
} /* else if */
else if (octet < 248) /* four octets */
{
octet -= (128+64+32+16);
octet2 = (PHYSFS_uint32) ((PHYSFS_uint8) *(++str));
if ((octet2 & (128+64)) != 128) /* Format isn't 10xxxxxx? */
return UNICODE_BOGUS_CHAR_VALUE;
octet3 = (PHYSFS_uint32) ((PHYSFS_uint8) *(++str));
if ((octet3 & (128+64)) != 128) /* Format isn't 10xxxxxx? */
return UNICODE_BOGUS_CHAR_VALUE;
octet4 = (PHYSFS_uint32) ((PHYSFS_uint8) *(++str));
if ((octet4 & (128+64)) != 128) /* Format isn't 10xxxxxx? */
return UNICODE_BOGUS_CHAR_VALUE;
*_str += 4; /* skip to next possible start of codepoint. */
retval = ( ((octet << 18)) | ((octet2 - 128) << 12) |
((octet3 - 128) << 6) | ((octet4 - 128)) );
if ((retval >= 0x10000) && (retval <= 0x10FFFF))
return retval;
} /* else if */
/*
* Five and six octet sequences became illegal in rfc3629.
* We throw the codepoint away, but parse them to make sure we move
* ahead the right number of bytes and don't overflow the buffer.
*/
else if (octet < 252) /* five octets */
{
octet = (PHYSFS_uint32) ((PHYSFS_uint8) *(++str));
if ((octet & (128+64)) != 128) /* Format isn't 10xxxxxx? */
return UNICODE_BOGUS_CHAR_VALUE;
octet = (PHYSFS_uint32) ((PHYSFS_uint8) *(++str));
if ((octet & (128+64)) != 128) /* Format isn't 10xxxxxx? */
return UNICODE_BOGUS_CHAR_VALUE;
octet = (PHYSFS_uint32) ((PHYSFS_uint8) *(++str));
if ((octet & (128+64)) != 128) /* Format isn't 10xxxxxx? */
return UNICODE_BOGUS_CHAR_VALUE;
octet = (PHYSFS_uint32) ((PHYSFS_uint8) *(++str));
if ((octet & (128+64)) != 128) /* Format isn't 10xxxxxx? */
return UNICODE_BOGUS_CHAR_VALUE;
*_str += 5; /* skip to next possible start of codepoint. */
return UNICODE_BOGUS_CHAR_VALUE;
} /* else if */
else /* six octets */
{
octet = (PHYSFS_uint32) ((PHYSFS_uint8) *(++str));
if ((octet & (128+64)) != 128) /* Format isn't 10xxxxxx? */
return UNICODE_BOGUS_CHAR_VALUE;
octet = (PHYSFS_uint32) ((PHYSFS_uint8) *(++str));
if ((octet & (128+64)) != 128) /* Format isn't 10xxxxxx? */
return UNICODE_BOGUS_CHAR_VALUE;
octet = (PHYSFS_uint32) ((PHYSFS_uint8) *(++str));
if ((octet & (128+64)) != 128) /* Format isn't 10xxxxxx? */
return UNICODE_BOGUS_CHAR_VALUE;
octet = (PHYSFS_uint32) ((PHYSFS_uint8) *(++str));
if ((octet & (128+64)) != 128) /* Format isn't 10xxxxxx? */
return UNICODE_BOGUS_CHAR_VALUE;
octet = (PHYSFS_uint32) ((PHYSFS_uint8) *(++str));
if ((octet & (128+64)) != 128) /* Format isn't 10xxxxxx? */
return UNICODE_BOGUS_CHAR_VALUE;
*_str += 6; /* skip to next possible start of codepoint. */
return UNICODE_BOGUS_CHAR_VALUE;
} /* else if */
return UNICODE_BOGUS_CHAR_VALUE;
} /* utf8codepoint */
void PHYSFS_utf8ToUcs4(const char *src, PHYSFS_uint32 *dst, PHYSFS_uint64 len)
{
len -= sizeof (PHYSFS_uint32); /* save room for null char. */
while (len >= sizeof (PHYSFS_uint32))
{
PHYSFS_uint32 cp = utf8codepoint(&src);
if (cp == 0)
break;
else if (cp == UNICODE_BOGUS_CHAR_VALUE)
cp = UNICODE_BOGUS_CHAR_CODEPOINT;
*(dst++) = cp;
len -= sizeof (PHYSFS_uint32);
} /* while */
*dst = 0;
} /* PHYSFS_utf8ToUcs4 */
void PHYSFS_utf8ToUcs2(const char *src, PHYSFS_uint16 *dst, PHYSFS_uint64 len)
{
len -= sizeof (PHYSFS_uint16); /* save room for null char. */
while (len >= sizeof (PHYSFS_uint16))
{
PHYSFS_uint32 cp = utf8codepoint(&src);
if (cp == 0)
break;
else if (cp == UNICODE_BOGUS_CHAR_VALUE)
cp = UNICODE_BOGUS_CHAR_CODEPOINT;
/* !!! BLUESKY: UTF-16 surrogates? */
if (cp > 0xFFFF)
cp = UNICODE_BOGUS_CHAR_CODEPOINT;
*(dst++) = cp;
len -= sizeof (PHYSFS_uint16);
} /* while */
*dst = 0;
} /* PHYSFS_utf8ToUcs2 */
static void utf8fromcodepoint(PHYSFS_uint32 cp, char **_dst, PHYSFS_uint64 *_len)
{
char *dst = *_dst;
PHYSFS_uint64 len = *_len;
if (len == 0)
return;
if (cp > 0x10FFFF)
cp = UNICODE_BOGUS_CHAR_CODEPOINT;
else if ((cp == 0xFFFE) || (cp == 0xFFFF)) /* illegal values. */
cp = UNICODE_BOGUS_CHAR_CODEPOINT;
else
{
/* There are seven "UTF-16 surrogates" that are illegal in UTF-8. */
switch (cp)
{
case 0xD800:
case 0xDB7F:
case 0xDB80:
case 0xDBFF:
case 0xDC00:
case 0xDF80:
case 0xDFFF:
cp = UNICODE_BOGUS_CHAR_CODEPOINT;
} /* switch */
} /* else */
/* Do the encoding... */
if (cp < 0x80)
{
*(dst++) = (char) cp;
len--;
} /* if */
else if (cp < 0x800)
{
if (len < 2)
len = 0;
else
{
*(dst++) = (char) ((cp >> 6) | 128 | 64);
*(dst++) = (char) (cp & 0x3F) | 128;
len -= 2;
} /* else */
} /* else if */
else if (cp < 0x10000)
{
if (len < 3)
len = 0;
else
{
*(dst++) = (char) ((cp >> 12) | 128 | 64 | 32);
*(dst++) = (char) ((cp >> 6) & 0x3F) | 128;
*(dst++) = (char) (cp & 0x3F) | 128;
len -= 3;
} /* else */
} /* else if */
else
{
if (len < 4)
len = 0;
else
{
*(dst++) = (char) ((cp >> 18) | 128 | 64 | 32 | 16);
*(dst++) = (char) ((cp >> 12) & 0x3F) | 128;
*(dst++) = (char) ((cp >> 6) & 0x3F) | 128;
*(dst++) = (char) (cp & 0x3F) | 128;
len -= 4;
} /* else if */
} /* else */
*_dst = dst;
*_len = len;
} /* utf8fromcodepoint */
#define UTF8FROMTYPE(typ, src, dst, len) \
len--; \
while (len) \
{ \
const PHYSFS_uint32 cp = (PHYSFS_uint32) *(src++); \
if (cp == 0) break; \
utf8fromcodepoint(cp, &dst, &len); \
} \
*dst = '\0'; \
void PHYSFS_utf8FromUcs4(const PHYSFS_uint32 *src, char *dst, PHYSFS_uint64 len)
{
UTF8FROMTYPE(PHYSFS_uint32, src, dst, len);
} /* PHYSFS_utf8FromUcs4 */
void PHYSFS_utf8FromUcs2(const PHYSFS_uint16 *src, char *dst, PHYSFS_uint64 len)
{
UTF8FROMTYPE(PHYSFS_uint64, src, dst, len);
} /* PHYSFS_utf8FromUcs4 */
/* latin1 maps to unicode codepoints directly, we just utf-8 encode it. */
void PHYSFS_utf8FromLatin1(const char *src, char *dst, PHYSFS_uint64 len)
{
UTF8FROMTYPE(PHYSFS_uint8, src, dst, len);
} /* PHYSFS_utf8FromLatin1 */
#undef UTF8FROMTYPE
typedef struct CaseFoldMapping
{
PHYSFS_uint32 from;
PHYSFS_uint32 to0;
PHYSFS_uint32 to1;
PHYSFS_uint32 to2;
} CaseFoldMapping;
typedef struct CaseFoldHashBucket
{
const PHYSFS_uint8 count;
const CaseFoldMapping *list;
} CaseFoldHashBucket;
#include "physfs_casefolding.h"
static void locate_case_fold_mapping(const PHYSFS_uint32 from,
PHYSFS_uint32 *to)
{
PHYSFS_uint32 i;
const PHYSFS_uint8 hashed = ((from ^ (from >> 8)) & 0xFF);
const CaseFoldHashBucket *bucket = &case_fold_hash[hashed];
const CaseFoldMapping *mapping = bucket->list;
for (i = 0; i < bucket->count; i++, mapping++)
{
if (mapping->from == from)
{
to[0] = mapping->to0;
to[1] = mapping->to1;
to[2] = mapping->to2;
return;
} /* if */
} /* for */
/* Not found...there's no remapping for this codepoint. */
to[0] = from;
to[1] = 0;
to[2] = 0;
} /* locate_case_fold_mapping */
static int utf8codepointcmp(const PHYSFS_uint32 cp1, const PHYSFS_uint32 cp2)
{
PHYSFS_uint32 folded1[3], folded2[3];
locate_case_fold_mapping(cp1, folded1);
locate_case_fold_mapping(cp2, folded2);
return ( (folded1[0] == folded2[0]) &&
(folded1[1] == folded2[1]) &&
(folded1[2] == folded2[2]) );
} /* utf8codepointcmp */
int __PHYSFS_utf8strcasecmp(const char *str1, const char *str2)
{
while (1)
{
const PHYSFS_uint32 cp1 = utf8codepoint(&str1);
const PHYSFS_uint32 cp2 = utf8codepoint(&str2);
if (!utf8codepointcmp(cp1, cp2)) return 0;
if (cp1 == 0) return 1;
} /* while */
return 0; /* shouldn't hit this. */
} /* __PHYSFS_utf8strcasecmp */
int __PHYSFS_utf8strnicmp(const char *str1, const char *str2, PHYSFS_uint32 n)
{
while (n > 0)
{
const PHYSFS_uint32 cp1 = utf8codepoint(&str1);
const PHYSFS_uint32 cp2 = utf8codepoint(&str2);
if (!utf8codepointcmp(cp1, cp2)) return 0;
if (cp1 == 0) return 1;
n--;
} /* while */
return 1; /* matched to n chars. */
} /* __PHYSFS_utf8strnicmp */
int __PHYSFS_stricmpASCII(const char *str1, const char *str2)
{
while (1)
{
const char ch1 = *(str1++);
const char ch2 = *(str2++);
const char cp1 = ((ch1 >= 'A') && (ch1 <= 'Z')) ? (ch1+32) : ch1;
const char cp2 = ((ch2 >= 'A') && (ch2 <= 'Z')) ? (ch2+32) : ch2;
if (cp1 < cp2)
return -1;
else if (cp1 > cp2)
return 1;
else if (cp1 == 0) /* they're both null chars? */
return 0;
} /* while */
return 0; /* shouldn't hit this. */
} /* __PHYSFS_stricmpASCII */
int __PHYSFS_strnicmpASCII(const char *str1, const char *str2, PHYSFS_uint32 n)
{
while (n-- > 0)
{
const char ch1 = *(str1++);
const char ch2 = *(str2++);
const char cp1 = ((ch1 >= 'A') && (ch1 <= 'Z')) ? (ch1+32) : ch1;
const char cp2 = ((ch2 >= 'A') && (ch2 <= 'Z')) ? (ch2+32) : ch2;
if (cp1 < cp2)
return -1;
else if (cp1 > cp2)
return 1;
else if (cp1 == 0) /* they're both null chars? */
return 0;
} /* while */
return 0;
} /* __PHYSFS_stricmpASCII */
/* end of physfs_unicode.c ... */

396
physfs/platform/macosx.c Normal file
View File

@ -0,0 +1,396 @@
/*
* Mac OS X support routines for PhysicsFS.
*
* Please see the file LICENSE.txt in the source's root directory.
*
* This file written by Ryan C. Gordon.
*/
#define __PHYSICSFS_INTERNAL__
#include "physfs_platforms.h"
#ifdef PHYSFS_PLATFORM_MACOSX
#include <Carbon/Carbon.h>
#include <IOKit/storage/IOMedia.h>
#include <IOKit/storage/IOCDMedia.h>
#include <IOKit/storage/IODVDMedia.h>
#include <sys/mount.h>
/* Seems to get defined in some system header... */
#ifdef Free
#undef Free
#endif
#include "physfs_internal.h"
/* Wrap PHYSFS_Allocator in a CFAllocator... */
static CFAllocatorRef cfallocator = NULL;
CFStringRef cfallocDesc(const void *info)
{
return(CFStringCreateWithCString(cfallocator, "PhysicsFS",
kCFStringEncodingASCII));
} /* cfallocDesc */
static void *cfallocMalloc(CFIndex allocSize, CFOptionFlags hint, void *info)
{
return allocator.Malloc(allocSize);
} /* cfallocMalloc */
static void cfallocFree(void *ptr, void *info)
{
allocator.Free(ptr);
} /* cfallocFree */
static void *cfallocRealloc(void *ptr, CFIndex newsize,
CFOptionFlags hint, void *info)
{
if ((ptr == NULL) || (newsize <= 0))
return NULL; /* ADC docs say you should always return NULL here. */
return allocator.Realloc(ptr, newsize);
} /* cfallocRealloc */
int __PHYSFS_platformInit(void)
{
/* set up a CFAllocator, so Carbon can use the physfs allocator, too. */
CFAllocatorContext ctx;
memset(&ctx, '\0', sizeof (ctx));
ctx.copyDescription = cfallocDesc;
ctx.allocate = cfallocMalloc;
ctx.reallocate = cfallocRealloc;
ctx.deallocate = cfallocFree;
cfallocator = CFAllocatorCreate(kCFAllocatorUseContext, &ctx);
BAIL_IF_MACRO(cfallocator == NULL, ERR_OUT_OF_MEMORY, 0);
return(1); /* success. */
} /* __PHYSFS_platformInit */
int __PHYSFS_platformDeinit(void)
{
CFRelease(cfallocator);
cfallocator = NULL;
return(1); /* always succeed. */
} /* __PHYSFS_platformDeinit */
/* CD-ROM detection code... */
/*
* Code based on sample from Apple Developer Connection:
* http://developer.apple.com/samplecode/Sample_Code/Devices_and_Hardware/Disks/VolumeToBSDNode/VolumeToBSDNode.c.htm
*/
static int darwinIsWholeMedia(io_service_t service)
{
int retval = 0;
CFTypeRef wholeMedia;
if (!IOObjectConformsTo(service, kIOMediaClass))
return(0);
wholeMedia = IORegistryEntryCreateCFProperty(service,
CFSTR(kIOMediaWholeKey),
cfallocator, 0);
if (wholeMedia == NULL)
return(0);
retval = CFBooleanGetValue(wholeMedia);
CFRelease(wholeMedia);
return retval;
} /* darwinIsWholeMedia */
static int darwinIsMountedDisc(char *bsdName, mach_port_t masterPort)
{
int retval = 0;
CFMutableDictionaryRef matchingDict;
kern_return_t rc;
io_iterator_t iter;
io_service_t service;
if ((matchingDict = IOBSDNameMatching(masterPort, 0, bsdName)) == NULL)
return(0);
rc = IOServiceGetMatchingServices(masterPort, matchingDict, &iter);
if ((rc != KERN_SUCCESS) || (!iter))
return(0);
service = IOIteratorNext(iter);
IOObjectRelease(iter);
if (!service)
return(0);
rc = IORegistryEntryCreateIterator(service, kIOServicePlane,
kIORegistryIterateRecursively | kIORegistryIterateParents, &iter);
if (!iter)
return(0);
if (rc != KERN_SUCCESS)
{
IOObjectRelease(iter);
return(0);
} /* if */
IOObjectRetain(service); /* add an extra object reference... */
do
{
if (darwinIsWholeMedia(service))
{
if ( (IOObjectConformsTo(service, kIOCDMediaClass)) ||
(IOObjectConformsTo(service, kIODVDMediaClass)) )
{
retval = 1;
} /* if */
} /* if */
IOObjectRelease(service);
} while ((service = IOIteratorNext(iter)) && (!retval));
IOObjectRelease(iter);
IOObjectRelease(service);
return(retval);
} /* darwinIsMountedDisc */
void __PHYSFS_platformDetectAvailableCDs(PHYSFS_StringCallback cb, void *data)
{
const char *devPrefix = "/dev/";
const int prefixLen = strlen(devPrefix);
mach_port_t masterPort = 0;
struct statfs *mntbufp;
int i, mounts;
if (IOMasterPort(MACH_PORT_NULL, &masterPort) != KERN_SUCCESS)
BAIL_MACRO(ERR_OS_ERROR, ) /*return void*/;
mounts = getmntinfo(&mntbufp, MNT_WAIT); /* NOT THREAD SAFE! */
for (i = 0; i < mounts; i++)
{
char *dev = mntbufp[i].f_mntfromname;
char *mnt = mntbufp[i].f_mntonname;
if (strncmp(dev, devPrefix, prefixLen) != 0) /* a virtual device? */
continue;
dev += prefixLen;
if (darwinIsMountedDisc(dev, masterPort))
cb(data, mnt);
} /* for */
} /* __PHYSFS_platformDetectAvailableCDs */
static char *convertCFString(CFStringRef cfstr)
{
CFIndex len = CFStringGetMaximumSizeForEncoding(CFStringGetLength(cfstr),
kCFStringEncodingUTF8) + 1;
char *retval = (char *) allocator.Malloc(len);
BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL);
if (CFStringGetCString(cfstr, retval, len, kCFStringEncodingUTF8))
{
/* shrink overallocated buffer if possible... */
CFIndex newlen = strlen(retval) + 1;
if (newlen < len)
{
void *ptr = allocator.Realloc(retval, newlen);
if (ptr != NULL)
retval = (char *) ptr;
} /* if */
} /* if */
else /* probably shouldn't fail, but just in case... */
{
allocator.Free(retval);
BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL);
} /* else */
return(retval);
} /* convertCFString */
char *__PHYSFS_platformCalcBaseDir(const char *argv0)
{
ProcessSerialNumber psn = { 0, kCurrentProcess };
FSRef fsref;
CFRange cfrange;
CFURLRef cfurl = NULL;
CFStringRef cfstr = NULL;
CFMutableStringRef cfmutstr = NULL;
char *retval = NULL;
BAIL_IF_MACRO(GetProcessBundleLocation(&psn, &fsref) != noErr, NULL, NULL);
cfurl = CFURLCreateFromFSRef(cfallocator, &fsref);
BAIL_IF_MACRO(cfurl == NULL, NULL, NULL);
cfstr = CFURLCopyFileSystemPath(cfurl, kCFURLPOSIXPathStyle);
CFRelease(cfurl);
BAIL_IF_MACRO(cfstr == NULL, NULL, NULL);
cfmutstr = CFStringCreateMutableCopy(cfallocator, 0, cfstr);
CFRelease(cfstr);
BAIL_IF_MACRO(cfmutstr == NULL, NULL, NULL);
/* Find last dirsep so we can chop the binary's filename from the path. */
cfrange = CFStringFind(cfmutstr, CFSTR("/"), kCFCompareBackwards);
if (cfrange.location == kCFNotFound)
{
assert(0); /* shouldn't ever hit this... */
CFRelease(cfmutstr);
return(NULL);
} /* if */
/* chop the "/exename" from the end of the path string... */
cfrange.length = CFStringGetLength(cfmutstr) - cfrange.location;
CFStringDelete(cfmutstr, cfrange);
/* If we're an Application Bundle, chop everything but the base. */
cfrange = CFStringFind(cfmutstr, CFSTR("/Contents/MacOS"),
kCFCompareCaseInsensitive |
kCFCompareBackwards |
kCFCompareAnchored);
if (cfrange.location != kCFNotFound)
CFStringDelete(cfmutstr, cfrange); /* chop that, too. */
retval = convertCFString(cfmutstr);
CFRelease(cfmutstr);
return(retval); /* whew. */
} /* __PHYSFS_platformCalcBaseDir */
/* !!! FIXME */
#define osxerr(x) x
char *__PHYSFS_platformRealPath(const char *path)
{
/* The symlink and relative path resolving happens in FSPathMakeRef() */
FSRef fsref;
CFURLRef cfurl = NULL;
CFStringRef cfstr = NULL;
char *retval = NULL;
OSStatus rc = osxerr(FSPathMakeRef((UInt8 *) path, &fsref, NULL));
BAIL_IF_MACRO(rc != noErr, NULL, NULL);
/* Now get it to spit out a full path. */
cfurl = CFURLCreateFromFSRef(cfallocator, &fsref);
BAIL_IF_MACRO(cfurl == NULL, ERR_OUT_OF_MEMORY, NULL);
cfstr = CFURLCopyFileSystemPath(cfurl, kCFURLPOSIXPathStyle);
CFRelease(cfurl);
BAIL_IF_MACRO(cfstr == NULL, ERR_OUT_OF_MEMORY, NULL);
retval = convertCFString(cfstr);
CFRelease(cfstr);
return(retval);
} /* __PHYSFS_platformRealPath */
char *__PHYSFS_platformCurrentDir(void)
{
return(__PHYSFS_platformRealPath(".")); /* let CFURL sort it out. */
} /* __PHYSFS_platformCurrentDir */
/* Platform allocator uses default CFAllocator at PHYSFS_init() time. */
static CFAllocatorRef cfallocdef = NULL;
static int macosxAllocatorInit(void)
{
int retval = 0;
cfallocdef = CFAllocatorGetDefault();
retval = (cfallocdef != NULL);
if (retval)
CFRetain(cfallocdef);
return(retval);
} /* macosxAllocatorInit */
static void macosxAllocatorDeinit(void)
{
if (cfallocdef != NULL)
{
CFRelease(cfallocdef);
cfallocdef = NULL;
} /* if */
} /* macosxAllocatorDeinit */
static void *macosxAllocatorMalloc(PHYSFS_uint64 s)
{
BAIL_IF_MACRO(__PHYSFS_ui64FitsAddressSpace(s), ERR_OUT_OF_MEMORY, NULL);
return(CFAllocatorAllocate(cfallocdef, (CFIndex) s, 0));
} /* macosxAllocatorMalloc */
static void *macosxAllocatorRealloc(void *ptr, PHYSFS_uint64 s)
{
BAIL_IF_MACRO(__PHYSFS_ui64FitsAddressSpace(s), ERR_OUT_OF_MEMORY, NULL);
return(CFAllocatorReallocate(cfallocdef, ptr, (CFIndex) s, 0));
} /* macosxAllocatorRealloc */
static void macosxAllocatorFree(void *ptr)
{
CFAllocatorDeallocate(cfallocdef, ptr);
} /* macosxAllocatorFree */
int __PHYSFS_platformSetDefaultAllocator(PHYSFS_Allocator *a)
{
allocator.Init = macosxAllocatorInit;
allocator.Deinit = macosxAllocatorDeinit;
allocator.Malloc = macosxAllocatorMalloc;
allocator.Realloc = macosxAllocatorRealloc;
allocator.Free = macosxAllocatorFree;
return(1); /* return non-zero: we're supplying custom allocator. */
} /* __PHYSFS_platformSetDefaultAllocator */
PHYSFS_uint64 __PHYSFS_platformGetThreadID(void)
{
return( (PHYSFS_uint64) ((size_t) MPCurrentTaskID()) );
} /* __PHYSFS_platformGetThreadID */
void *__PHYSFS_platformCreateMutex(void)
{
MPCriticalRegionID m = NULL;
if (osxerr(MPCreateCriticalRegion(&m)) != noErr)
return NULL;
return m;
} /* __PHYSFS_platformCreateMutex */
void __PHYSFS_platformDestroyMutex(void *mutex)
{
MPCriticalRegionID m = (MPCriticalRegionID) mutex;
MPDeleteCriticalRegion(m);
} /* __PHYSFS_platformDestroyMutex */
int __PHYSFS_platformGrabMutex(void *mutex)
{
MPCriticalRegionID m = (MPCriticalRegionID) mutex;
if (MPEnterCriticalRegion(m, kDurationForever) != noErr)
return(0);
return(1);
} /* __PHYSFS_platformGrabMutex */
void __PHYSFS_platformReleaseMutex(void *mutex)
{
MPCriticalRegionID m = (MPCriticalRegionID) mutex;
MPExitCriticalRegion(m);
} /* __PHYSFS_platformReleaseMutex */
#endif /* PHYSFS_PLATFORM_MACOSX */
/* end of macosx.c ... */

404
physfs/platform/posix.c Normal file
View File

@ -0,0 +1,404 @@
/*
* Posix-esque support routines for PhysicsFS.
*
* Please see the file LICENSE.txt in the source's root directory.
*
* This file written by Ryan C. Gordon.
*/
#define __PHYSICSFS_INTERNAL__
#include "physfs_platforms.h"
#ifdef PHYSFS_PLATFORM_POSIX
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <pwd.h>
#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#ifdef PHYSFS_HAVE_LLSEEK
#include <linux/unistd.h>
#endif
#include "physfs_internal.h"
const char *__PHYSFS_platformDirSeparator = "/";
char *__PHYSFS_platformCopyEnvironmentVariable(const char *varname)
{
const char *envr = getenv(varname);
char *retval = NULL;
if (envr != NULL)
{
retval = (char *) allocator.Malloc(strlen(envr) + 1);
if (retval != NULL)
strcpy(retval, envr);
} /* if */
return(retval);
} /* __PHYSFS_platformCopyEnvironmentVariable */
static char *getUserNameByUID(void)
{
uid_t uid = getuid();
struct passwd *pw;
char *retval = NULL;
pw = getpwuid(uid);
if ((pw != NULL) && (pw->pw_name != NULL))
{
retval = (char *) allocator.Malloc(strlen(pw->pw_name) + 1);
if (retval != NULL)
strcpy(retval, pw->pw_name);
} /* if */
return(retval);
} /* getUserNameByUID */
static char *getUserDirByUID(void)
{
uid_t uid = getuid();
struct passwd *pw;
char *retval = NULL;
pw = getpwuid(uid);
if ((pw != NULL) && (pw->pw_dir != NULL))
{
retval = (char *) allocator.Malloc(strlen(pw->pw_dir) + 1);
if (retval != NULL)
strcpy(retval, pw->pw_dir);
} /* if */
return(retval);
} /* getUserDirByUID */
char *__PHYSFS_platformGetUserName(void)
{
char *retval = getUserNameByUID();
if (retval == NULL)
retval = __PHYSFS_platformCopyEnvironmentVariable("USER");
return(retval);
} /* __PHYSFS_platformGetUserName */
char *__PHYSFS_platformGetUserDir(void)
{
char *retval = __PHYSFS_platformCopyEnvironmentVariable("HOME");
if (retval == NULL)
retval = getUserDirByUID();
return(retval);
} /* __PHYSFS_platformGetUserDir */
int __PHYSFS_platformExists(const char *fname)
{
struct stat statbuf;
BAIL_IF_MACRO(lstat(fname, &statbuf) == -1, strerror(errno), 0);
return(1);
} /* __PHYSFS_platformExists */
int __PHYSFS_platformIsSymLink(const char *fname)
{
struct stat statbuf;
BAIL_IF_MACRO(lstat(fname, &statbuf) == -1, strerror(errno), 0);
return( (S_ISLNK(statbuf.st_mode)) ? 1 : 0 );
} /* __PHYSFS_platformIsSymlink */
int __PHYSFS_platformIsDirectory(const char *fname)
{
struct stat statbuf;
BAIL_IF_MACRO(stat(fname, &statbuf) == -1, strerror(errno), 0);
return( (S_ISDIR(statbuf.st_mode)) ? 1 : 0 );
} /* __PHYSFS_platformIsDirectory */
char *__PHYSFS_platformCvtToDependent(const char *prepend,
const char *dirName,
const char *append)
{
int len = ((prepend) ? strlen(prepend) : 0) +
((append) ? strlen(append) : 0) +
strlen(dirName) + 1;
char *retval = (char *) allocator.Malloc(len);
BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL);
/* platform-independent notation is Unix-style already. :) */
if (prepend)
strcpy(retval, prepend);
else
retval[0] = '\0';
strcat(retval, dirName);
if (append)
strcat(retval, append);
return(retval);
} /* __PHYSFS_platformCvtToDependent */
void __PHYSFS_platformEnumerateFiles(const char *dirname,
int omitSymLinks,
PHYSFS_EnumFilesCallback callback,
const char *origdir,
void *callbackdata)
{
DIR *dir;
struct dirent *ent;
int bufsize = 0;
char *buf = NULL;
int dlen = 0;
if (omitSymLinks) /* !!! FIXME: this malloc sucks. */
{
dlen = strlen(dirname);
bufsize = dlen + 256;
buf = (char *) allocator.Malloc(bufsize);
if (buf == NULL)
return;
strcpy(buf, dirname);
if (buf[dlen - 1] != '/')
{
buf[dlen++] = '/';
buf[dlen] = '\0';
} /* if */
} /* if */
errno = 0;
dir = opendir(dirname);
if (dir == NULL)
{
allocator.Free(buf);
return;
} /* if */
while ((ent = readdir(dir)) != NULL)
{
if (strcmp(ent->d_name, ".") == 0)
continue;
if (strcmp(ent->d_name, "..") == 0)
continue;
if (omitSymLinks)
{
char *p;
int len = strlen(ent->d_name) + dlen + 1;
if (len > bufsize)
{
p = (char *) allocator.Realloc(buf, len);
if (p == NULL)
continue;
buf = p;
bufsize = len;
} /* if */
strcpy(buf + dlen, ent->d_name);
if (__PHYSFS_platformIsSymLink(buf))
continue;
} /* if */
callback(callbackdata, origdir, ent->d_name);
} /* while */
allocator.Free(buf);
closedir(dir);
} /* __PHYSFS_platformEnumerateFiles */
int __PHYSFS_platformMkDir(const char *path)
{
int rc;
errno = 0;
rc = mkdir(path, S_IRWXU);
BAIL_IF_MACRO(rc == -1, strerror(errno), 0);
return(1);
} /* __PHYSFS_platformMkDir */
static void *doOpen(const char *filename, int mode)
{
int fd;
int *retval;
errno = 0;
fd = open(filename, mode, S_IRUSR | S_IWUSR);
BAIL_IF_MACRO(fd < 0, strerror(errno), NULL);
retval = (int *) allocator.Malloc(sizeof (int));
if (retval == NULL)
{
close(fd);
BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL);
} /* if */
*retval = fd;
return((void *) retval);
} /* doOpen */
void *__PHYSFS_platformOpenRead(const char *filename)
{
return(doOpen(filename, O_RDONLY));
} /* __PHYSFS_platformOpenRead */
void *__PHYSFS_platformOpenWrite(const char *filename)
{
return(doOpen(filename, O_WRONLY | O_CREAT | O_TRUNC));
} /* __PHYSFS_platformOpenWrite */
void *__PHYSFS_platformOpenAppend(const char *filename)
{
return(doOpen(filename, O_WRONLY | O_CREAT | O_APPEND));
} /* __PHYSFS_platformOpenAppend */
PHYSFS_sint64 __PHYSFS_platformRead(void *opaque, void *buffer,
PHYSFS_uint32 size, PHYSFS_uint32 count)
{
int fd = *((int *) opaque);
int max = size * count;
int rc = read(fd, buffer, max);
if (size == 0)
return 0;
if (count == 0)
return 0;
BAIL_IF_MACRO(rc == -1, strerror(errno), rc);
assert(rc <= max);
if ((rc < max) && (size > 1))
lseek(fd, -(rc % size), SEEK_CUR); /* rollback to object boundary. */
return (rc / size);
} /* __PHYSFS_platformRead */
PHYSFS_sint64 __PHYSFS_platformWrite(void *opaque, const void *buffer,
PHYSFS_uint32 size, PHYSFS_uint32 count)
{
int fd = *((int *) opaque);
int max = size * count;
int rc = write(fd, (void *) buffer, max);
BAIL_IF_MACRO(rc == -1, strerror(errno), rc);
assert(rc <= max);
if ((rc < max) && (size > 1))
lseek(fd, -(rc % size), SEEK_CUR); /* rollback to object boundary. */
return(rc / size);
} /* __PHYSFS_platformWrite */
int __PHYSFS_platformSeek(void *opaque, PHYSFS_uint64 pos)
{
int fd = *((int *) opaque);
#ifdef PHYSFS_HAVE_LLSEEK
unsigned long offset_high = ((pos >> 32) & 0xFFFFFFFF);
unsigned long offset_low = (pos & 0xFFFFFFFF);
loff_t retoffset;
int rc = llseek(fd, offset_high, offset_low, &retoffset, SEEK_SET);
BAIL_IF_MACRO(rc == -1, strerror(errno), 0);
#else
BAIL_IF_MACRO(lseek(fd, (int) pos, SEEK_SET) == -1, strerror(errno), 0);
#endif
return(1);
} /* __PHYSFS_platformSeek */
PHYSFS_sint64 __PHYSFS_platformTell(void *opaque)
{
int fd = *((int *) opaque);
PHYSFS_sint64 retval;
#ifdef PHYSFS_HAVE_LLSEEK
loff_t retoffset;
int rc = llseek(fd, 0, &retoffset, SEEK_CUR);
BAIL_IF_MACRO(rc == -1, strerror(errno), -1);
retval = (PHYSFS_sint64) retoffset;
#else
retval = (PHYSFS_sint64) lseek(fd, 0, SEEK_CUR);
BAIL_IF_MACRO(retval == -1, strerror(errno), -1);
#endif
return(retval);
} /* __PHYSFS_platformTell */
PHYSFS_sint64 __PHYSFS_platformFileLength(void *opaque)
{
int fd = *((int *) opaque);
struct stat statbuf;
BAIL_IF_MACRO(fstat(fd, &statbuf) == -1, strerror(errno), -1);
return((PHYSFS_sint64) statbuf.st_size);
} /* __PHYSFS_platformFileLength */
int __PHYSFS_platformEOF(void *opaque)
{
PHYSFS_sint64 pos = __PHYSFS_platformTell(opaque);
PHYSFS_sint64 len = __PHYSFS_platformFileLength(opaque);
return(pos >= len);
} /* __PHYSFS_platformEOF */
int __PHYSFS_platformFlush(void *opaque)
{
int fd = *((int *) opaque);
BAIL_IF_MACRO(fsync(fd) == -1, strerror(errno), 0);
return(1);
} /* __PHYSFS_platformFlush */
int __PHYSFS_platformClose(void *opaque)
{
int fd = *((int *) opaque);
BAIL_IF_MACRO(close(fd) == -1, strerror(errno), 0);
allocator.Free(opaque);
return(1);
} /* __PHYSFS_platformClose */
int __PHYSFS_platformDelete(const char *path)
{
BAIL_IF_MACRO(remove(path) == -1, strerror(errno), 0);
return(1);
} /* __PHYSFS_platformDelete */
PHYSFS_sint64 __PHYSFS_platformGetLastModTime(const char *fname)
{
struct stat statbuf;
BAIL_IF_MACRO(stat(fname, &statbuf) < 0, strerror(errno), -1);
return statbuf.st_mtime;
} /* __PHYSFS_platformGetLastModTime */
#endif /* PHYSFS_PLATFORM_POSIX */
/* end of posix.c ... */

395
physfs/platform/unix.c Normal file
View File

@ -0,0 +1,395 @@
/*
* Unix support routines for PhysicsFS.
*
* Please see the file LICENSE.txt in the source's root directory.
*
* This file written by Ryan C. Gordon.
*/
#define __PHYSICSFS_INTERNAL__
#include "physfs_platforms.h"
#ifdef PHYSFS_PLATFORM_UNIX
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <unistd.h>
#include <sys/types.h>
#include <pwd.h>
#include <sys/stat.h>
#include <sys/param.h>
#include <dirent.h>
#include <time.h>
#include <errno.h>
#include <sys/mount.h>
#if (!defined PHYSFS_NO_PTHREADS_SUPPORT)
#include <pthread.h>
#endif
#ifdef PHYSFS_HAVE_SYS_UCRED_H
# ifdef PHYSFS_HAVE_MNTENT_H
# undef PHYSFS_HAVE_MNTENT_H /* don't do both... */
# endif
# include <sys/ucred.h>
#endif
#ifdef PHYSFS_HAVE_MNTENT_H
#include <mntent.h>
#endif
#include "physfs_internal.h"
int __PHYSFS_platformInit(void)
{
return(1); /* always succeed. */
} /* __PHYSFS_platformInit */
int __PHYSFS_platformDeinit(void)
{
return(1); /* always succeed. */
} /* __PHYSFS_platformDeinit */
#ifdef PHYSFS_NO_CDROM_SUPPORT
/* Stub version for platforms without CD-ROM support. */
void __PHYSFS_platformDetectAvailableCDs(PHYSFS_StringCallback cb, void *data)
{
} /* __PHYSFS_platformDetectAvailableCDs */
#elif (defined PHYSFS_HAVE_SYS_UCRED_H)
void __PHYSFS_platformDetectAvailableCDs(PHYSFS_StringCallback cb, void *data)
{
int i;
struct statfs *mntbufp = NULL;
int mounts = getmntinfo(&mntbufp, MNT_WAIT);
for (i = 0; i < mounts; i++)
{
int add_it = 0;
if (strcmp(mntbufp[i].f_fstypename, "iso9660") == 0)
add_it = 1;
else if (strcmp( mntbufp[i].f_fstypename, "cd9660") == 0)
add_it = 1;
/* add other mount types here */
if (add_it)
cb(data, mntbufp[i].f_mntonname);
} /* for */
} /* __PHYSFS_platformDetectAvailableCDs */
#elif (defined PHYSFS_HAVE_MNTENT_H)
void __PHYSFS_platformDetectAvailableCDs(PHYSFS_StringCallback cb, void *data)
{
FILE *mounts = NULL;
struct mntent *ent = NULL;
mounts = setmntent("/etc/mtab", "r");
BAIL_IF_MACRO(mounts == NULL, ERR_IO_ERROR, /*return void*/);
while ( (ent = getmntent(mounts)) != NULL )
{
int add_it = 0;
if (strcmp(ent->mnt_type, "iso9660") == 0)
add_it = 1;
/* add other mount types here */
if (add_it)
cb(data, ent->mnt_dir);
} /* while */
endmntent(mounts);
} /* __PHYSFS_platformDetectAvailableCDs */
#endif
/* this is in posix.c ... */
extern char *__PHYSFS_platformCopyEnvironmentVariable(const char *varname);
/*
* See where program (bin) resides in the $PATH specified by (envr).
* returns a copy of the first element in envr that contains it, or NULL
* if it doesn't exist or there were other problems. PHYSFS_SetError() is
* called if we have a problem.
*
* (envr) will be scribbled over, and you are expected to allocator.Free() the
* return value when you're done with it.
*/
static char *findBinaryInPath(const char *bin, char *envr)
{
size_t alloc_size = 0;
char *exe = NULL;
char *start = envr;
char *ptr;
BAIL_IF_MACRO(bin == NULL, ERR_INVALID_ARGUMENT, NULL);
BAIL_IF_MACRO(envr == NULL, ERR_INVALID_ARGUMENT, NULL);
do
{
size_t size;
ptr = strchr(start, ':'); /* find next $PATH separator. */
if (ptr)
*ptr = '\0';
size = strlen(start) + strlen(bin) + 2;
if (size > alloc_size)
{
char *x = (char *) allocator.Realloc(exe, size);
if (x == NULL)
{
if (exe != NULL)
allocator.Free(exe);
BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL);
} /* if */
alloc_size = size;
exe = x;
} /* if */
/* build full binary path... */
strcpy(exe, start);
if ((exe[0] == '\0') || (exe[strlen(exe) - 1] != '/'))
strcat(exe, "/");
strcat(exe, bin);
if (access(exe, X_OK) == 0) /* Exists as executable? We're done. */
{
strcpy(exe, start); /* i'm lazy. piss off. */
return(exe);
} /* if */
start = ptr + 1; /* start points to beginning of next element. */
} while (ptr != NULL);
if (exe != NULL)
allocator.Free(exe);
return(NULL); /* doesn't exist in path. */
} /* findBinaryInPath */
char *__PHYSFS_platformCalcBaseDir(const char *argv0)
{
const char *PROC_SELF_EXE = "/proc/self/exe";
char *retval = NULL;
char *envr = NULL;
struct stat stbuf;
/* fast path: default behaviour can handle this. */
if ( (argv0 != NULL) && (strchr(argv0, '/') != NULL) )
return(NULL); /* higher level will parse out real path from argv0. */
/*
* Try to avoid using argv0 unless forced to. If there's a Linux-like
* /proc filesystem, you can get the full path to the current process from
* the /proc/self/exe symlink.
*/
if ((lstat(PROC_SELF_EXE, &stbuf) != -1) && (S_ISLNK(stbuf.st_mode)))
{
const size_t len = stbuf.st_size;
char *buf = (char *) allocator.Malloc(len+1);
if (buf != NULL) /* if NULL, maybe you'll get lucky later. */
{
if (readlink(PROC_SELF_EXE, buf, len) != len)
allocator.Free(buf);
else
{
buf[len] = '\0'; /* readlink doesn't null-terminate. */
retval = buf; /* we're good to go. */
} /* else */
} /* if */
} /* if */
if ((retval == NULL) && (argv0 != NULL))
{
/* If there's no dirsep on argv0, then look through $PATH for it. */
envr = __PHYSFS_platformCopyEnvironmentVariable("PATH");
BAIL_IF_MACRO(!envr, NULL, NULL);
retval = findBinaryInPath(argv0, envr);
allocator.Free(envr);
} /* if */
return(retval);
} /* __PHYSFS_platformCalcBaseDir */
char *__PHYSFS_platformRealPath(const char *path)
{
char resolved_path[MAXPATHLEN];
char *retval = NULL;
errno = 0;
BAIL_IF_MACRO(!realpath(path, resolved_path), strerror(errno), NULL);
retval = (char *) allocator.Malloc(strlen(resolved_path) + 1);
BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL);
strcpy(retval, resolved_path);
return(retval);
} /* __PHYSFS_platformRealPath */
char *__PHYSFS_platformCurrentDir(void)
{
/*
* This can't just do platformRealPath("."), since that would eventually
* just end up calling back into here.
*/
int allocSize = 0;
char *retval = NULL;
char *ptr;
do
{
allocSize += 100;
ptr = (char *) allocator.Realloc(retval, allocSize);
if (ptr == NULL)
{
if (retval != NULL)
allocator.Free(retval);
BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL);
} /* if */
retval = ptr;
ptr = getcwd(retval, allocSize);
} while (ptr == NULL && errno == ERANGE);
if (ptr == NULL && errno)
{
/*
* getcwd() failed for some reason, for example current
* directory not existing.
*/
if (retval != NULL)
allocator.Free(retval);
BAIL_MACRO(ERR_NO_SUCH_FILE, NULL);
} /* if */
return(retval);
} /* __PHYSFS_platformCurrentDir */
int __PHYSFS_platformSetDefaultAllocator(PHYSFS_Allocator *a)
{
return(0); /* just use malloc() and friends. */
} /* __PHYSFS_platformSetDefaultAllocator */
#if (defined PHYSFS_NO_PTHREADS_SUPPORT)
PHYSFS_uint64 __PHYSFS_platformGetThreadID(void) { return(0x0001); }
void *__PHYSFS_platformCreateMutex(void) { return((void *) 0x0001); }
void __PHYSFS_platformDestroyMutex(void *mutex) {}
int __PHYSFS_platformGrabMutex(void *mutex) { return(1); }
void __PHYSFS_platformReleaseMutex(void *mutex) {}
#else
typedef struct
{
pthread_mutex_t mutex;
pthread_t owner;
PHYSFS_uint32 count;
} PthreadMutex;
/* Just in case; this is a panic value. */
#if ((!defined SIZEOF_INT) || (SIZEOF_INT <= 0))
# define SIZEOF_INT 4
#endif
#if (SIZEOF_INT == 4)
# define PHTREAD_TO_UI64(thr) ( (PHYSFS_uint64) ((PHYSFS_uint32) (thr)) )
#elif (SIZEOF_INT == 2)
# define PHTREAD_TO_UI64(thr) ( (PHYSFS_uint64) ((PHYSFS_uint16) (thr)) )
#elif (SIZEOF_INT == 1)
# define PHTREAD_TO_UI64(thr) ( (PHYSFS_uint64) ((PHYSFS_uint8) (thr)) )
#else
# define PHTREAD_TO_UI64(thr) ((PHYSFS_uint64) (thr))
#endif
PHYSFS_uint64 __PHYSFS_platformGetThreadID(void)
{
return(PHTREAD_TO_UI64(pthread_self()));
} /* __PHYSFS_platformGetThreadID */
void *__PHYSFS_platformCreateMutex(void)
{
int rc;
PthreadMutex *m = (PthreadMutex *) allocator.Malloc(sizeof (PthreadMutex));
BAIL_IF_MACRO(m == NULL, ERR_OUT_OF_MEMORY, NULL);
rc = pthread_mutex_init(&m->mutex, NULL);
if (rc != 0)
{
allocator.Free(m);
BAIL_MACRO(strerror(rc), NULL);
} /* if */
m->count = 0;
m->owner = (pthread_t) 0xDEADBEEF;
return((void *) m);
} /* __PHYSFS_platformCreateMutex */
void __PHYSFS_platformDestroyMutex(void *mutex)
{
PthreadMutex *m = (PthreadMutex *) mutex;
/* Destroying a locked mutex is a bug, but we'll try to be helpful. */
if ((m->owner == pthread_self()) && (m->count > 0))
pthread_mutex_unlock(&m->mutex);
pthread_mutex_destroy(&m->mutex);
allocator.Free(m);
} /* __PHYSFS_platformDestroyMutex */
int __PHYSFS_platformGrabMutex(void *mutex)
{
PthreadMutex *m = (PthreadMutex *) mutex;
pthread_t tid = pthread_self();
if (m->owner != tid)
{
if (pthread_mutex_lock(&m->mutex) != 0)
return(0);
m->owner = tid;
} /* if */
m->count++;
return(1);
} /* __PHYSFS_platformGrabMutex */
void __PHYSFS_platformReleaseMutex(void *mutex)
{
PthreadMutex *m = (PthreadMutex *) mutex;
if (m->owner == pthread_self())
{
if (--m->count == 0)
{
m->owner = (pthread_t) 0xDEADBEEF;
pthread_mutex_unlock(&m->mutex);
} /* if */
} /* if */
} /* __PHYSFS_platformReleaseMutex */
#endif /* !PHYSFS_NO_PTHREADS_SUPPORT */
#endif /* PHYSFS_PLATFORM_UNIX */
/* end of unix.c ... */

1395
physfs/platform/windows.c Normal file
View File

File diff suppressed because it is too large Load Diff