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

Removed PocketPC support. It was old and crusty and targeted a dead platform.

This commit is contained in:
Ryan C. Gordon 2012-03-09 00:44:59 -05:00
parent d1d0de3947
commit 4d46d42f73
6 changed files with 6 additions and 633 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CMakeLists.txt
View File

@ -142,7 +142,6 @@ SET(PHYSFS_SRCS
src/physfs_byteorder.c src/physfs_byteorder.c
src/physfs_unicode.c src/physfs_unicode.c
src/platform_os2.c src/platform_os2.c
src/platform_pocketpc.c
src/platform_posix.c src/platform_posix.c
src/platform_unix.c src/platform_unix.c
src/platform_macosx.c src/platform_macosx.c

9
docs/INSTALL.txt
View File

@ -86,13 +86,12 @@ If someone is willing to maintain prebuilt PhysicsFS DLLs, I'd like to hear
from you; send an email to icculus@icculus.org ... from you; send an email to icculus@icculus.org ...
PocketPC/WindowsCE: PocketPC/WindowsCE:
Code exists for PocketPC support, and there are shipping titles that used Support for PocketPC was removed in PhysicsFS 2.1.0. This was known to work
PhysicsFS 1.0 on PocketPC...but it isn't tested in 2.0, and is probably in the 1.0 releases, but wasn't tested in 2.0 and later. PhysicsFS is not
broken with the new build system. Please send patches. known to work on Windows Phone 7 (the latest Microsoft mobile tech at the
time of this writing).
MAC OS 8/9: MAC OS 8/9:

1
docs/TODO.txt
View File

@ -27,7 +27,6 @@ Stuff:
- Sanity check byte order at runtime. - Sanity check byte order at runtime.
- Memory locking? - Memory locking?
- Find a better name than dvoid and fvoid. - 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? - There's so much cut-and-paste between archivers...can this be reduced?
- General code audit. - General code audit.
- Multiple write dirs with mount points? - Multiple write dirs with mount points?

2
src/physfs.h
View File

@ -195,7 +195,7 @@
* itself doesn't support multibyte encodings. We make an earnest effort to * itself doesn't support multibyte encodings. We make an earnest effort to
* convert to/from the current locale here, but all bets are off if * convert to/from the current locale here, but all bets are off if
* you want to hand an arbitrary Japanese character through to these systems. * you want to hand an arbitrary Japanese character through to these systems.
* Modern OSes (Mac OS X, Linux, Windows, PocketPC, etc) should all be fine. * Modern OSes (Mac OS X, Linux, Windows, etc) should all be fine.
* Many game-specific archivers are seriously unprepared for Unicode (the * Many game-specific archivers are seriously unprepared for Unicode (the
* Descent HOG/MVL and Build Engine GRP archivers, for example, only offer a * Descent HOG/MVL and Build Engine GRP archivers, for example, only offer a
* DOS 8.3 filename, for example). Nothing can be done for these, but they * DOS 8.3 filename, for example). Nothing can be done for these, but they

2
src/physfs_platforms.h
View File

@ -20,7 +20,7 @@
# define PHYSFS_PLATFORM_BEOS # define PHYSFS_PLATFORM_BEOS
# define PHYSFS_PLATFORM_POSIX # define PHYSFS_PLATFORM_POSIX
#elif (defined _WIN32_WCE) || (defined _WIN64_WCE) #elif (defined _WIN32_WCE) || (defined _WIN64_WCE)
# define PHYSFS_PLATFORM_POCKETPC # error PocketPC support was dropped from PhysicsFS 2.1. Sorry.
#elif (((defined _WIN32) || (defined _WIN64)) && (!defined __CYGWIN__)) #elif (((defined _WIN32) || (defined _WIN64)) && (!defined __CYGWIN__))
# define PHYSFS_PLATFORM_WINDOWS # define PHYSFS_PLATFORM_WINDOWS
#elif (defined OS2) #elif (defined OS2)

624
src/platform_pocketpc.c
View File

@ -1,624 +0,0 @@
/*
* PocketPC 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_POCKETPC
#include <windows.h>
#include "physfs_internal.h"
#define INVALID_FILE_ATTRIBUTES 0xFFFFFFFF
#define INVALID_SET_FILE_POINTER 0xFFFFFFFF
typedef struct
{
HANDLE handle;
int readonly;
} winCEfile;
const char *__PHYSFS_platformDirSeparator = "\\";
static char *userDir = NULL;
/*
* Figure out what the last failing Win32 API call was, and
* generate a human-readable string for the error message.
*
* The return value is a static buffer that is overwritten with
* each call to this function.
*/
static const char *win32strerror(void)
{
static TCHAR msgbuf[255];
TCHAR *ptr = msgbuf;
FormatMessage(
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL,
GetLastError(),
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), /* Default language */
msgbuf,
sizeof (msgbuf) / sizeof (TCHAR),
NULL
);
/* chop off newlines. */
for (ptr = msgbuf; *ptr; ptr++)
{
if ((*ptr == '\n') || (*ptr == '\r'))
{
*ptr = ' ';
break;
} /* if */
} /* for */
return ((const char *) msgbuf);
} /* win32strerror */
/* !!! FIXME: need to check all of these for NULLs. */
#define UTF8_TO_UNICODE_STACK_MACRO(w_assignto, str) { \
if (str == NULL) \
w_assignto = NULL; \
else { \
const PHYSFS_uint64 len = (PHYSFS_uint64) ((strlen(str) * 4) + 1); \
w_assignto = (char *) __PHYSFS_smallAlloc(len); \
PHYSFS_uc2fromutf8(str, (PHYSFS_uint16 *) w_assignto, len); \
} \
} \
static char *getExePath()
{
DWORD buflen;
int success = 0;
TCHAR *ptr = NULL;
TCHAR *retval = (TCHAR*) allocator.Malloc(sizeof (TCHAR) * (MAX_PATH + 1));
char *charretval;
BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL);
retval[0] = _T('\0');
/* !!! FIXME: don't preallocate here? */
/* !!! FIXME: use smallAlloc? */
buflen = GetModuleFileName(NULL, retval, MAX_PATH + 1);
if (buflen <= 0)
__PHYSFS_setError(win32strerror());
else
{
retval[buflen] = '\0'; /* does API always null-terminate this? */
ptr = retval+buflen;
while( ptr != retval )
{
if( *ptr != _T('\\') )
*ptr-- = _T('\0');
else
break;
} /* while */
success = 1;
} /* else */
if (!success)
{
allocator.Free(retval);
return NULL; /* physfs error message will be set, above. */
} /* if */
buflen = (buflen * 4) + 1;
charretval = (char *) allocator.Malloc(buflen);
if (charretval != NULL)
PHYSFS_utf8fromucs2((const PHYSFS_uint16 *) retval, charretval, buflen);
allocator.Free(retval);
return charretval; /* w00t. */
} /* getExePath */
int __PHYSFS_platformInit(void)
{
userDir = getExePath();
BAIL_IF_MACRO(userDir == NULL, NULL, 0); /* failed? */
return 1; /* always succeed. */
} /* __PHYSFS_platformInit */
int __PHYSFS_platformDeinit(void)
{
allocator.Free(userDir);
return 1; /* always succeed. */
} /* __PHYSFS_platformDeinit */
void __PHYSFS_platformDetectAvailableCDs(PHYSFS_StringCallback cb, void *data)
{
/* no-op on this platform. */
} /* __PHYSFS_platformDetectAvailableCDs */
char *__PHYSFS_platformCalcBaseDir(const char *argv0)
{
return getExePath();
} /* __PHYSFS_platformCalcBaseDir */
char *__PHYSFS_platformGetUserName(void)
{
BAIL_MACRO(ERR_NOT_IMPLEMENTED, NULL);
} /* __PHYSFS_platformGetUserName */
char *__PHYSFS_platformGetUserDir(void)
{
return userDir;
BAIL_MACRO(ERR_NOT_IMPLEMENTED, NULL);
} /* __PHYSFS_platformGetUserDir */
void *__PHYSFS_platformGetThreadID(void)
{
return ((void *)1); /* single threaded. */ /* !!! FIXME: is this true? */
} /* __PHYSFS_platformGetThreadID */
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);
char *p;
BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL);
if (prepend)
strcpy(retval, prepend);
else
retval[0] = '\0';
strcat(retval, dirName);
if (append)
strcat(retval, append);
for (p = strchr(retval, '/'); p != NULL; p = strchr(p + 1, '/'))
*p = '\\';
return retval;
} /* __PHYSFS_platformCvtToDependent */
static int doEnumCallback(const wchar_t *w_fname)
{
const PHYSFS_uint64 len = (PHYSFS_uint64) ((wcslen(w_fname) * 4) + 1);
char *str = (char *) __PHYSFS_smallAlloc(len);
PHYSFS_utf8fromucs2((const PHYSFS_uint16 *) w_fname, str, len);
callback(callbackdata, origdir, str);
__PHYSFS_smallFree(str);
return 1;
} /* doEnumCallback */
void __PHYSFS_platformEnumerateFiles(const char *dirname,
int omitSymLinks,
PHYSFS_EnumFilesCallback callback,
const char *origdir,
void *callbackdata)
{
HANDLE dir;
WIN32_FIND_DATA ent;
char *SearchPath;
wchar_t *w_SearchPath;
size_t len = strlen(dirname);
/* Allocate a new string for path, maybe '\\', "*", and NULL terminator */
SearchPath = (char *) __PHYSFS_smallAlloc(len + 3);
BAIL_IF_MACRO(SearchPath == NULL, ERR_OUT_OF_MEMORY, NULL);
/* Copy current dirname */
strcpy(SearchPath, dirname);
/* if there's no '\\' at the end of the path, stick one in there. */
if (SearchPath[len - 1] != '\\')
{
SearchPath[len++] = '\\';
SearchPath[len] = '\0';
} /* if */
/* Append the "*" to the end of the string */
strcat(SearchPath, "*");
UTF8_TO_UNICODE_STACK_MACRO(w_SearchPath, SearchPath);
__PHYSFS_smallFree(SearchPath);
dir = FindFirstFile(w_SearchPath, &ent);
__PHYSFS_smallFree(w_SearchPath);
if (dir == INVALID_HANDLE_VALUE)
return;
do
{
const char *str = NULL;
if (wcscmp(ent.cFileName, L".") == 0)
continue;
if (wcscmp(ent.cFileName, L"..") == 0)
continue;
if (!doEnumCallback(ent.cFileName))
break;
} while (FindNextFile(dir, &ent) != 0);
FindClose(dir);
} /* __PHYSFS_platformEnumerateFiles */
char *__PHYSFS_platformCurrentDir(void)
{
return "\\";
} /* __PHYSFS_platformCurrentDir */
char *__PHYSFS_platformRealPath(const char *path)
{
char *retval = (char *) allocator.Malloc(strlen(path) + 1);
strcpy(retval,path);
return retval;
} /* __PHYSFS_platformRealPath */
int __PHYSFS_platformMkDir(const char *path)
{
int retval = 0;
wchar_t *w_path = NULL;
UTF8_TO_UNICODE_STACK_MACRO(w_path, path);
if (w_path != NULL)
{
retval = CreateDirectory(w_path, NULL);
__PHYSFS_smallFree(w_fname);
} /* if */
return retval;
} /* __PHYSFS_platformMkDir */
static void *doOpen(const char *fname, DWORD mode, DWORD creation, int rdonly)
{
HANDLE fileHandle;
winCEfile *retval;
wchar_t *w_fname = NULL;
UTF8_TO_UNICODE_STACK_MACRO(w_fname, fname);
fileHandle = CreateFile(w_fname, mode, FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL, creation, FILE_ATTRIBUTE_NORMAL, NULL);
__PHYSFS_smallFree(w_fname);
BAIL_IF_MACRO(fileHandle == INVALID_HANDLE_VALUE, win32strerror(), NULL);
retval = (winCEfile *) allocator.Malloc(sizeof (winCEfile));
if (retval == NULL)
{
CloseHandle(fileHandle);
BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL);
} /* if */
retval->readonly = rdonly;
retval->handle = fileHandle;
return retval;
} /* doOpen */
void *__PHYSFS_platformOpenRead(const char *filename)
{
return doOpen(filename, GENERIC_READ, OPEN_EXISTING, 1);
} /* __PHYSFS_platformOpenRead */
void *__PHYSFS_platformOpenWrite(const char *filename)
{
return doOpen(filename, GENERIC_WRITE, CREATE_ALWAYS, 0);
} /* __PHYSFS_platformOpenWrite */
void *__PHYSFS_platformOpenAppend(const char *filename)
{
void *retval = doOpen(filename, GENERIC_WRITE, OPEN_ALWAYS, 0);
if (retval != NULL)
{
HANDLE h = ((winCEfile *) retval)->handle;
if (SetFilePointer(h, 0, NULL, FILE_END) == INVALID_SET_FILE_POINTER)
{
const char *err = win32strerror();
CloseHandle(h);
allocator.Free(retval);
BAIL_MACRO(err, NULL);
} /* if */
} /* if */
return retval;
} /* __PHYSFS_platformOpenAppend */
PHYSFS_sint64 __PHYSFS_platformRead(void *opaque, void *buf, PHYSFS_uint64 len)
{
HANDLE Handle = ((winCEfile *) opaque)->handle;
DWORD CountOfBytesRead = 0;
BAIL_IF_MACRO(!__PHYSFS_ui64FitsAddressSpace(len),ERR_INVALID_ARGUMENT,-1);
if (!ReadFile(Handle, buf, (DWORD) len, &CountOfBytesRead, NULL))
return -1; /* !!! FIXME: set an error string? */
return (PHYSFS_sint64) CountOfBytesRead;
} /* __PHYSFS_platformRead */
PHYSFS_sint64 __PHYSFS_platformWrite(void *opaque, const void *buffer,
PHYSFS_uint64 len)
{
HANDLE Handle = ((winCEfile *) opaque)->handle;
DWORD CountOfBytesWritten = 0;
BAIL_IF_MACRO(!__PHYSFS_ui64FitsAddressSpace(len),ERR_INVALID_ARGUMENT,-1);
if (!WriteFile(Handle, buffer, (DWORD) len, &CountOfBytesWritten, NULL))
return -1;
return PHYSFS_sint64) CountOfBytesWritten;
} /* __PHYSFS_platformWrite */
int __PHYSFS_platformSeek(void *opaque, PHYSFS_uint64 pos)
{
HANDLE Handle = ((winCEfile *) opaque)->handle;
DWORD HighOrderPos;
DWORD rc;
/* Get the high order 32-bits of the position */
/*HighOrderPos = HIGHORDER_UINT64(pos);*/
HighOrderPos = (unsigned long)(pos>>32);
/*!!! SetFilePointer needs a signed 64-bit value. */
/* Move pointer "pos" count from start of file */
rc = SetFilePointer(Handle, (unsigned long)(pos&0x00000000ffffffff),
&HighOrderPos, FILE_BEGIN);
if ((rc == INVALID_SET_FILE_POINTER) && (GetLastError() != NO_ERROR))
{
BAIL_MACRO(win32strerror(), 0);
}
return 1; /* No error occured */
} /* __PHYSFS_platformSeek */
PHYSFS_sint64 __PHYSFS_platformTell(void *opaque)
{
HANDLE Handle = ((winCEfile *) opaque)->handle;
DWORD HighPos = 0;
DWORD LowPos;
PHYSFS_sint64 retval;
/* Get current position */
LowPos = SetFilePointer(Handle, 0, &HighPos, FILE_CURRENT);
if ((LowPos == INVALID_SET_FILE_POINTER) && (GetLastError() != NO_ERROR))
{
BAIL_MACRO(win32strerror(), -1);
} /* if */
else
{
/* Combine the high/low order to create the 64-bit position value */
retval = (((PHYSFS_uint64) HighPos) << 32) | LowPos;
/*assert(retval >= 0);*/
} /* else */
return retval;
} /* __PHYSFS_platformTell */
PHYSFS_sint64 __PHYSFS_platformFileLength(void *opaque)
{
HANDLE Handle = ((winCEfile *) opaque)->handle;
DWORD SizeHigh;
DWORD SizeLow;
PHYSFS_sint64 retval;
SizeLow = GetFileSize(Handle, &SizeHigh);
if ((SizeLow == INVALID_SET_FILE_POINTER) && (GetLastError() != NO_ERROR))
{
BAIL_MACRO(win32strerror(), -1);
} /* if */
else
{
/* Combine the high/low order to create the 64-bit position value */
retval = (((PHYSFS_uint64) SizeHigh) << 32) | SizeLow;
/*assert(retval >= 0);*/
} /* else */
return retval;
} /* __PHYSFS_platformFileLength */
int __PHYSFS_platformFlush(void *opaque)
{
winCEfile *fh = ((winCEfile *) opaque);
if (!fh->readonly)
BAIL_IF_MACRO(!FlushFileBuffers(fh->handle), win32strerror(), 0);
return 1;
} /* __PHYSFS_platformFlush */
void __PHYSFS_platformClose(void *opaque)
{
HANDLE Handle = ((winCEfile *) opaque)->handle;
(void) CloseHandle(Handle); /* ignore errors. You should have flushed! */
allocator.Free(opaque);
} /* __PHYSFS_platformClose */
int __PHYSFS_platformDelete(const char *path)
{
wchar_t *w_path = NULL;
UTF8_TO_UNICODE_STACK_MACRO(w_path, path);
/* If filename is a folder */
if (GetFileAttributes(w_path) == FILE_ATTRIBUTE_DIRECTORY)
{
int retval = !RemoveDirectory(w_path);
__PHYSFS_smallFree(w_path);
BAIL_IF_MACRO(retval, win32strerror(), 0);
} /* if */
else
{
int retval = !DeleteFile(w_path);
__PHYSFS_smallFree(w_path);
BAIL_IF_MACRO(retval, win32strerror(), 0);
} /* else */
return 1; /* if you got here, it worked. */
} /* __PHYSFS_platformDelete */
/* Shamelessly copied from platform_windows.c */
static PHYSFS_sint64 FileTimeToPhysfsTime(const FILETIME *ft)
{
SYSTEMTIME st_utc;
SYSTEMTIME st_localtz;
TIME_ZONE_INFORMATION tzi;
DWORD tzid;
PHYSFS_sint64 retval;
struct tm tm;
BAIL_IF_MACRO(!FileTimeToSystemTime(ft, &st_utc), winApiStrError(), -1);
tzid = GetTimeZoneInformation(&tzi);
BAIL_IF_MACRO(tzid == TIME_ZONE_ID_INVALID, winApiStrError(), -1);
/* (This API is unsupported and fails on non-NT systems. */
if (!SystemTimeToTzSpecificLocalTime(&tzi, &st_utc, &st_localtz))
{
/* do it by hand. Grumble... */
ULARGE_INTEGER ui64;
FILETIME new_ft;
ui64.LowPart = ft->dwLowDateTime;
ui64.HighPart = ft->dwHighDateTime;
if (tzid == TIME_ZONE_ID_STANDARD)
tzi.Bias += tzi.StandardBias;
else if (tzid == TIME_ZONE_ID_DAYLIGHT)
tzi.Bias += tzi.DaylightBias;
/* convert from minutes to 100-nanosecond increments... */
ui64.QuadPart -= (((LONGLONG) tzi.Bias) * (600000000));
/* Move it back into a FILETIME structure... */
new_ft.dwLowDateTime = ui64.LowPart;
new_ft.dwHighDateTime = ui64.HighPart;
/* Convert to something human-readable... */
if (!FileTimeToSystemTime(&new_ft, &st_localtz))
BAIL_MACRO(winApiStrError(), -1);
} /* if */
/* Convert to a format that mktime() can grok... */
tm.tm_sec = st_localtz.wSecond;
tm.tm_min = st_localtz.wMinute;
tm.tm_hour = st_localtz.wHour;
tm.tm_mday = st_localtz.wDay;
tm.tm_mon = st_localtz.wMonth - 1;
tm.tm_year = st_localtz.wYear - 1900;
tm.tm_wday = -1 /*st_localtz.wDayOfWeek*/;
tm.tm_yday = -1;
tm.tm_isdst = -1;
/* Convert to a format PhysicsFS can grok... */
retval = (PHYSFS_sint64) mktime(&tm);
BAIL_IF_MACRO(retval == -1, strerror(errno), -1);
return retval;
} /* FileTimeToPhysfsTime */
int __PHYSFS_platformStat(const char *filename, int *exists, PHYSFS_Stat *stat)
{
WIN32_FIND_DATA winstat;
const HANDLE searchhandle = FindFirstFile(filename, &winstat);
if (searchhandle == INVALID_HANDLE_VALUE) /* call failed? */
{
/* !!! FIXME: FindFirstFile() doesn't set errno. Use GetLastError()?. */
if (errno == ERROR_FILE_NOT_FOUND)
{
*exists = 0;
return 0;
} /* if */
BAIL_MACRO(win32strerror, 0);
} /* if */
FindClose(searchhandle); /* close handle, not needed anymore */
*exists = 1;
if(winstat.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
stat->filetype = PHYSFS_FILETYPE_DIRECTORY;
else if (winstat.dwFileAttributes & (FILE_ATTRIBUTE_OFFLINE | FILE_ATTRIBUTE_ROMMODULE))
stat->filetype = PHYSFS_FILETYPE_OTHER;
else
stat->filetype = PHYSFS_FILETYPE_OTHER; /* !!! FIXME: _REGULAR? */
if (stat->filetype == PHYSFS_FILETYPE_REGULAR)
stat->filesize = (((PHYSFS_uint64) winstat.nFileSizeHigh) << 32) | winstat.nFileSizeLow;
stat->modtime = FileTimeToPhysfsTime(&winstat.ftLastWriteTime);
stat->accesstime = FileTimeToPhysfsTime(&winstat.ftLastAccessTime);
stat->createtime = FileTimeToPhysfsTime(&winstat.ftCreationTime);
stat->readonly = ((winstat.dwFileAttributes & (FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_INROM)) != 0);
return 1;
} /* __PHYSFS_platformStat */
/*
* !!! FIXME: why aren't we using Critical Sections instead of Mutexes?
* !!! FIXME: mutexes on Windows are for cross-process sync. CritSects are
* !!! FIXME: mutexes for threads in a single process and are faster.
*/
void *__PHYSFS_platformCreateMutex(void)
{
return ((void *) CreateMutex(NULL, FALSE, NULL));
} /* __PHYSFS_platformCreateMutex */
void __PHYSFS_platformDestroyMutex(void *mutex)
{
CloseHandle((HANDLE) mutex);
} /* __PHYSFS_platformDestroyMutex */
int __PHYSFS_platformGrabMutex(void *mutex)
{
return (WaitForSingleObject((HANDLE) mutex, INFINITE) != WAIT_FAILED);
} /* __PHYSFS_platformGrabMutex */
void __PHYSFS_platformReleaseMutex(void *mutex)
{
ReleaseMutex((HANDLE) mutex);
} /* __PHYSFS_platformReleaseMutex */
/* !!! FIXME: Don't use C runtime for allocators? */
int __PHYSFS_platformSetDefaultAllocator(PHYSFS_Allocator *a)
{
return 0; /* just use malloc() and friends. */
} /* __PHYSFS_platformSetDefaultAllocator */
#endif /* PHYSFS_PLATFORM_POCKETPC */
/* end of pocketpc.c ... */