From 15c18b0c04a80be9dee250876d78ccacee0baab4 Mon Sep 17 00:00:00 2001 From: "Ryan C. Gordon" Date: Wed, 5 Jul 2017 21:29:37 -0400 Subject: [PATCH] os2: added OS/2 support back in. With the release of ArcaOS, this is a live platform again. This code probably doesn't compile yet; I've just given it a first shot at resolving the changes between the last OS/2-supported revision and now. This still needs Unicode support added in any case. --- CMakeLists.txt | 2 +- docs/TODO.txt | 2 + src/physfs.h | 12 +- src/physfs_internal.h | 2 +- src/physfs_platforms.h | 4 +- src/platform_os2.c | 673 +++++++++++++++++++++++++++++++++++++++++ 6 files changed, 686 insertions(+), 9 deletions(-) create mode 100644 src/platform_os2.c diff --git a/CMakeLists.txt b/CMakeLists.txt index b5e05384..c5833d30 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -185,7 +185,7 @@ if(UNIX) endif() endif() -if(WINDOWS) +if(WINDOWS OR OS2) set(PHYSFS_HAVE_CDROM_SUPPORT TRUE) set(PHYSFS_HAVE_THREAD_SUPPORT TRUE) endif() diff --git a/docs/TODO.txt b/docs/TODO.txt index 029ef697..8daa16c5 100644 --- a/docs/TODO.txt +++ b/docs/TODO.txt @@ -74,6 +74,8 @@ Other stuff I thought of... - Reduce the BAIL and GOTO macro use. A lot of these don't add anything. - Modernize CMakeLists.txt - Change the term "search path" to something less confusing. +- OS/2 codepages. No full Unicode in the filesystem, but we can probably make + a conversion effort. Probably other stuff. Requests and recommendations are welcome. diff --git a/src/physfs.h b/src/physfs.h index 3a313633..0d739272 100644 --- a/src/physfs.h +++ b/src/physfs.h @@ -187,11 +187,11 @@ * PhysicsFS offers basic encoding conversion support, but not a whole string * library. Get your stuff into whatever format you can work with. * - * All platforms supported by PhysicsFS 2.1 and later fully support Unicode. - * We have dropped platforms that don't (OS/2, Mac OS 9, Windows 95, etc), as - * even an OS that's over a decade old should be expected to handle this well. - * If you absolutely must support one of these platforms, you should use an - * older release of PhysicsFS. + * Most platforms supported by PhysicsFS 2.1 and later fully support Unicode. + * Some older platforms have been dropped (Windows 95, Mac OS 9). Some, like + * OS/2, might be able to convert to a local codepage or will just fail to + * open/create the file. Modern OSes (macOS, Linux, Windows, etc) should all + * be fine. * * Many game-specific archivers are seriously unprepared for Unicode (the * Descent HOG/MVL and Build Engine GRP archivers, for example, only offer a @@ -251,6 +251,8 @@ extern "C" { /* do nothing. */ #elif defined(__WIN32__) && !defined(__GNUC__) #define PHYSFS_CALL __cdecl +#elif defined(__OS2__) || defined(OS2) /* should work across all compilers. */ +#define PHYSFS_CALL _System #else #define PHYSFS_CALL #endif diff --git a/src/physfs_internal.h b/src/physfs_internal.h index 09bb054c..f8716f87 100644 --- a/src/physfs_internal.h +++ b/src/physfs_internal.h @@ -330,7 +330,7 @@ int UNPK_stat(void *opaque, const char *fn, PHYSFS_Stat *st); * Obviously, this isn't a function. If you need more than one char for this, * you'll need to pull some old pieces of PhysicsFS out of revision control. */ -#if PHYSFS_PLATFORM_WINDOWS +#if PHYSFS_PLATFORM_WINDOWS || PHYSFS_PLATFORM_OS2 #define __PHYSFS_platformDirSeparator '\\' #else #define __PHYSFS_platformDirSeparator '/' diff --git a/src/physfs_platforms.h b/src/physfs_platforms.h index 60976a99..2a6c820a 100644 --- a/src/physfs_platforms.h +++ b/src/physfs_platforms.h @@ -27,8 +27,8 @@ # define PHYSFS_PLATFORM_WINDOWS 1 #elif (((defined _WIN32) || (defined _WIN64)) && (!defined __CYGWIN__)) # define PHYSFS_PLATFORM_WINDOWS 1 -#elif (defined OS2) -# error OS/2 support was dropped from PhysicsFS 2.1. Sorry. +#elif defined(__OS2__) || defined(OS2) +# define PHYSFS_PLATFORM_OS2 1 #elif ((defined __MACH__) && (defined __APPLE__)) /* To check if iphone or not, we need to include this file */ # include diff --git a/src/platform_os2.c b/src/platform_os2.c new file mode 100644 index 00000000..814079d0 --- /dev/null +++ b/src/platform_os2.c @@ -0,0 +1,673 @@ +/* + * OS/2 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_OS2 + +#define INCL_DOSSEMAPHORES +#define INCL_DOSDATETIME +#define INCL_DOSFILEMGR +#define INCL_DOSMODULEMGR +#define INCL_DOSERRORS +#define INCL_DOSPROCESS +#define INCL_DOSDEVICES +#define INCL_DOSDEVIOCTL +#define INCL_DOSMISC +#include + +#include +#include +#include + +#include "physfs_internal.h" + +static PHYSFS_ErrorCode errcodeFromAPIRET(const APIRET rc) +{ + switch (rc) + { + case NO_ERROR: return PHYSFS_ERR_OK; /* not an error. */ + case ERROR_INTERRUPT: return PHYSFS_ERR_OK; /* not an error. */ + case ERROR_TIMEOUT: return PHYSFS_ERR_OK; /* not an error. */ + case ERROR_NOT_ENOUGH_MEMORY: return ERR_OUT_OF_MEMORY; + case ERROR_FILE_NOT_FOUND: return PHYSFS_ERR_NOT_FOUND; + case ERROR_PATH_NOT_FOUND: return PHYSFS_ERR_NOT_FOUND; + case ERROR_ACCESS_DENIED: return PHYSFS_ERR_PERMISSION; + case ERROR_NOT_DOS_DISK: return PHYSFS_ERR_NOT_FOUND; + case ERROR_SHARING_VIOLATION: return PHYSFS_ERR_PERMISSION; + case ERROR_CANNOT_MAKE: return PHYSFS_ERR_IO; /* maybe this is wrong? */ + case ERROR_DEVICE_IN_USE: return PHYSFS_ERR_BUSY; + case ERROR_OPEN_FAILED: return PHYSFS_ERR_IO; /* maybe this is wrong? */ + case ERROR_DISK_FULL: return PHYSFS_ERR_NO_SPACE; + case ERROR_PIPE_BUSY: return PHYSFS_ERR_BUSY; + case ERROR_SHARING_BUFFER_EXCEEDED: return PHYSFS_ERR_IO; + case ERROR_FILENAME_EXCED_RANGE: return PHYSFS_ERR_BAD_FILENAME; + case ERROR_META_EXPANSION_TOO_LONG: return PHYSFS_ERR_BAD_FILENAME; + case ERROR_TOO_MANY_HANDLES: return PHYSFS_ERR_IO; + case ERROR_TOO_MANY_OPEN_FILES: return PHYSFS_ERR_IO; + case ERROR_NO_MORE_SEARCH_HANDLES: return PHYSFS_ERR_IO; + case ERROR_SEEK_ON_DEVICE: return PHYSFS_ERR_IO; + case ERROR_NEGATIVE_SEEK: return PHYSFS_ERR_INVALID_ARGUMENT; + /*!!! FIXME: Where did this go? case ERROR_DEL_CURRENT_DIRECTORY: return ERR_DEL_CWD;*/ + case ERROR_WRITE_PROTECT: return PHYSFS_ERR_PERMISSION; + case ERROR_WRITE_FAULT: return PHYSFS_ERR_IO; + case ERROR_UNCERTAIN_MEDIA: return PHYSFS_ERR_IO; + case ERROR_PROTECTION_VIOLATION: return PHYSFS_ERR_IO; + case ERROR_BROKEN_PIPE: return PHYSFS_ERR_IO; + + /* !!! FIXME: some of these might be PHYSFS_ERR_BAD_FILENAME, etc */ + case ERROR_LOCK_VIOLATION: + case ERROR_GEN_FAILURE: + case ERROR_INVALID_PARAMETER: + case ERROR_INVALID_NAME: + case ERROR_INVALID_DRIVE: + case ERROR_INVALID_HANDLE: + case ERROR_INVALID_FUNCTION: + case ERROR_INVALID_LEVEL: + case ERROR_INVALID_CATEGORY: + case ERROR_DUPLICATE_NAME: + case ERROR_BUFFER_OVERFLOW: + case ERROR_BAD_LENGTH: + case ERROR_BAD_DRIVER_LEVEL: + case ERROR_DIRECT_ACCESS_HANDLE: + case ERROR_NOT_OWNER: + return PHYSFS_ERR_OS_ERROR; + + default: break; + } /* switch */ + + return PHYSFS_ERR_OTHER_ERROR; +} /* errcodeFromAPIRET */ + + +/* (be gentle, this function isn't very robust.) */ +static void cvt_path_to_correct_case(char *buf) +{ + char *fname = buf + 3; /* point to first element. */ + char *ptr = strchr(fname, '\\'); /* find end of first element. */ + + buf[0] = toupper(buf[0]); /* capitalize drive letter. */ + + /* + * Go through each path element, and enumerate its parent dir until + * a case-insensitive match is found. If one is (and it SHOULD be) + * then overwrite the original element with the correct case. + * If there's an error, or the path has vanished for some reason, it + * won't hurt to have the original case, so we just keep going. + */ + while (fname != NULL) + { + char spec[CCHMAXPATH]; + FILEFINDBUF3 fb; + HDIR hdir = HDIR_CREATE; + ULONG count = 1; + APIRET rc; + + *(fname - 1) = '\0'; /* isolate parent dir string. */ + + strcpy(spec, buf); /* copy isolated parent dir... */ + strcat(spec, "\\*.*"); /* ...and add wildcard search spec. */ + + if (ptr != NULL) /* isolate element to find (fname is the start). */ + *ptr = '\0'; + + rc = DosFindFirst((unsigned char *) spec, &hdir, FILE_DIRECTORY, + &fb, sizeof (fb), &count, FIL_STANDARD); + if (rc == NO_ERROR) + { + while (count == 1) /* while still entries to enumerate... */ + { + if (__PHYSFS_stricmpASCII(fb.achName, fname) == 0) + { + strcpy(fname, fb.achName); + break; /* there it is. Overwrite and stop searching. */ + } /* if */ + + DosFindNext(hdir, &fb, sizeof (fb), &count); + } /* while */ + DosFindClose(hdir); + } /* if */ + + *(fname - 1) = '\\'; /* unisolate parent dir. */ + fname = ptr; /* point to next element. */ + if (ptr != NULL) + { + *ptr = '\\'; /* unisolate element. */ + ptr = strchr(++fname, '\\'); /* find next element. */ + } /* if */ + } /* while */ +} /* cvt_file_to_correct_case */ + + +static char *baseDir = NULL; + +int __PHYSFS_platformInit(void) +{ + return 1; /* it's all good. */ +} /* __PHYSFS_platformInit */ + + +int __PHYSFS_platformDeinit(void) +{ + if (baseDir != NULL) + { + allocator.Free(baseDir); + baseDir = NULL; + } /* if */ + + return 1; /* success. */ +} /* __PHYSFS_platformDeinit */ + + +static int disc_is_inserted(ULONG drive) +{ + int rc; + char buf[20]; + DosError(FERR_DISABLEHARDERR | FERR_DISABLEEXCEPTION); + rc = DosQueryFSInfo(drive + 1, FSIL_VOLSER, buf, sizeof (buf)); + DosError(FERR_ENABLEHARDERR | FERR_ENABLEEXCEPTION); + return (rc == NO_ERROR); +} /* is_cdrom_inserted */ + + +/* looks like "CD01" in ASCII (littleendian)...used for an ioctl. */ +#define CD01 0x31304443 + +static int is_cdrom_drive(ULONG drive) +{ + PHYSFS_uint32 param, data; + ULONG ul1, ul2; + APIRET rc; + HFILE hfile = NULLHANDLE; + unsigned char drivename[3] = { 'A' + drive, ':', '\0' }; + + rc = DosOpen(drivename, &hfile, &ul1, 0, 0, + OPEN_ACTION_OPEN_IF_EXISTS | OPEN_ACTION_FAIL_IF_NEW, + OPEN_FLAGS_DASD | OPEN_FLAGS_FAIL_ON_ERROR | + OPEN_FLAGS_NOINHERIT | OPEN_SHARE_DENYNONE, NULL); + BAIL_IF_MACRO(rc != NO_ERROR, NULL, 0); + + data = 0; + param = PHYSFS_swapULE32(CD01); + ul1 = ul2 = sizeof (PHYSFS_uint32); + rc = DosDevIOCtl(hfile, IOCTL_CDROMDISK, CDROMDISK_GETDRIVER, + ¶m, sizeof (param), &ul1, &data, sizeof (data), &ul2); + + DosClose(hfile); + return ((rc == NO_ERROR) && (PHYSFS_swapULE32(data) == CD01)); +} /* is_cdrom_drive */ + + +void __PHYSFS_platformDetectAvailableCDs(PHYSFS_StringCallback cb, void *data) +{ + ULONG dummy = 0; + ULONG drivemap = 0; + ULONG i, bit; + const APIRET rc = DosQueryCurrentDisk(&dummy, &drivemap); + BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc),); + + for (i = 0, bit = 1; i < 26; i++, bit <<= 1) + { + if (drivemap & bit) /* this logical drive exists. */ + { + if ((is_cdrom_drive(i)) && (disc_is_inserted(i))) + { + char drive[4] = "x:\\"; + drive[0] = ('A' + i); + cb(data, drive); + } /* if */ + } /* if */ + } /* for */ +} /* __PHYSFS_platformDetectAvailableCDs */ + + +char *__PHYSFS_platformCalcBaseDir(const char *argv0) +{ + if (baseDir == NULL) + { + char buf[CCHMAXPATH]; + APIRET rc; + PTIB ptib; + PPIB ppib; + PHYSFS_sint32 len; + + rc = DosGetInfoBlocks(&ptib, &ppib); + BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc), 0); + rc = DosQueryModuleName(ppib->pib_hmte, sizeof (buf), (PCHAR) buf); + BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc), 0); + + /* chop off filename, leave path. */ + for (len = strlen(buf) - 1; len >= 0; len--) + { + if (buf[len] == '\\') + { + buf[len] = '\0'; + break; + } /* if */ + } /* for */ + + assert(len > 0); /* should have been a "x:\\" on the front on string. */ + + /* The string is capitalized! Figure out the REAL case... */ + cvt_path_to_correct_case(buf); + + baseDir = (char *) allocator.Malloc(len + 1); + BAIL_IF_MACRO(baseDir == NULL, ERR_OUT_OF_MEMORY, 0); + strcpy(baseDir, buf); + } /* if */ + + char *retval = (char *) allocator.Malloc(strlen(baseDir) + 1); + BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL); + strcpy(retval, baseDir); + return retval; +} /* __PHYSFS_platformCalcBaseDir */ + + +char *__PHYSFS_platformGetUserName(void) +{ + return NULL; /* (*shrug*) */ +} /* __PHYSFS_platformGetUserName */ + + +char *__PHYSFS_platformGetUserDir(void) +{ + return __PHYSFS_platformCalcBaseDir(NULL); +} /* __PHYSFS_platformGetUserDir */ + + +/* !!! FIXME: can we lose the malloc here? */ +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 = 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 */ + + +void __PHYSFS_platformEnumerateFiles(const char *dirname, + int omitSymLinks, + PHYSFS_EnumFilesCallback callback, + const char *origdir, + void *callbackdata) +{ + char spec[CCHMAXPATH]; + FILEFINDBUF3 fb; + HDIR hdir = HDIR_CREATE; + ULONG count = 1; + APIRET rc; + + if (strlen(dirname) > sizeof (spec) - 5) + { + __PHYSFS_setError(ERR_BAD_FILENAME); + return; + } /* if */ + + strcpy(spec, dirname); + strcat(spec, (spec[strlen(spec) - 1] != '\\') ? "\\*.*" : "*.*"); + + rc = DosFindFirst((unsigned char *) spec, &hdir, + FILE_DIRECTORY | FILE_ARCHIVED | + FILE_READONLY | FILE_HIDDEN | FILE_SYSTEM, + &fb, sizeof (fb), &count, FIL_STANDARD); + + BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc),); + + while (count == 1) + { + if ((strcmp(fb.achName, ".") != 0) && (strcmp(fb.achName, "..") != 0)) + callback(callbackdata, origdir, fb.achName); + + DosFindNext(hdir, &fb, sizeof (fb), &count); + } /* while */ + + DosFindClose(hdir); +} /* __PHYSFS_platformEnumerateFiles */ + + +char *__PHYSFS_platformCurrentDir(void) +{ + char *retval; + ULONG currentDisk; + ULONG dummy; + ULONG pathSize = 0; + APIRET rc; + BYTE byte; + + rc = DosQueryCurrentDisk(¤tDisk, &dummy); + BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc), NULL); + + /* The first call just tells us how much space we need for the string. */ + rc = DosQueryCurrentDir(currentDisk, &byte, &pathSize); + pathSize++; /* Add space for null terminator. */ + retval = (char *) allocator.Malloc(pathSize + 3); /* plus "x:\\" */ + BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL); + + /* Actually get the string this time. */ + rc = DosQueryCurrentDir(currentDisk, (PBYTE) (retval + 3), &pathSize); + if (rc != NO_ERROR) + { + allocator.Free(retval); + BAIL_MACRO(errcodeFromAPIRET(rc), NULL); + } /* if */ + + retval[0] = ('A' + (currentDisk - 1)); + retval[1] = ':'; + retval[2] = '\\'; + return retval; +} /* __PHYSFS_platformCurrentDir */ + + +char *__PHYSFS_platformRealPath(const char *_path) +{ + const unsigned char *path = (const unsigned char *) _path; + char buf[CCHMAXPATH]; + char *retval; + APIRET rc = DosQueryPathInfo(path, FIL_QUERYFULLNAME, buf, sizeof (buf)); + BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc), NULL); + retval = (char *) allocator.Malloc(strlen(buf) + 1); + BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL); + strcpy(retval, buf); + return retval; +} /* __PHYSFS_platformRealPath */ + + +int __PHYSFS_platformMkDir(const char *_filename) +{ + const unsigned char *filename = (const unsigned char *) _filename; + const APIRET rc = DosCreateDir(filename, NULL); + BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc), 0); + return 1; +} /* __PHYSFS_platformMkDir */ + + +void *__PHYSFS_platformOpenRead(const char *_filename) +{ + const unsigned char *filename = (const unsigned char *) _filename; + ULONG actionTaken = 0; + HFILE hfile = NULLHANDLE; + + /* + * File must be opened SHARE_DENYWRITE and ACCESS_READONLY, otherwise + * DosQueryFileInfo() will fail if we try to get a file length, etc. + */ + const APIRET rc = DosOpen(filename, &hfile, &actionTaken, 0, FILE_NORMAL, + OPEN_ACTION_OPEN_IF_EXISTS | OPEN_ACTION_FAIL_IF_NEW, + OPEN_FLAGS_FAIL_ON_ERROR | OPEN_FLAGS_NO_LOCALITY | + OPEN_FLAGS_NOINHERIT | OPEN_SHARE_DENYWRITE | + OPEN_ACCESS_READONLY, NULL); + BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc), NULL); + + return ((void *) hfile); +} /* __PHYSFS_platformOpenRead */ + + +void *__PHYSFS_platformOpenWrite(const char *_filename) +{ + const unsigned char *filename = (const unsigned char *) _filename; + ULONG actionTaken = 0; + HFILE hfile = NULLHANDLE; + + /* + * File must be opened SHARE_DENYWRITE and ACCESS_READWRITE, otherwise + * DosQueryFileInfo() will fail if we try to get a file length, etc. + */ + const APIRET rc = DosOpen(filename, &hfile, &actionTaken, 0, FILE_NORMAL, + OPEN_ACTION_REPLACE_IF_EXISTS | OPEN_ACTION_CREATE_IF_NEW, + OPEN_FLAGS_FAIL_ON_ERROR | OPEN_FLAGS_NO_LOCALITY | + OPEN_FLAGS_NOINHERIT | OPEN_SHARE_DENYWRITE | + OPEN_ACCESS_READWRITE, NULL); + BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc), NULL); + + return ((void *) hfile); +} /* __PHYSFS_platformOpenWrite */ + + +void *__PHYSFS_platformOpenAppend(const char *_filename) +{ + const unsigned char *filename = (const unsigned char *) _filename; + ULONG dummy = 0; + HFILE hfile = NULLHANDLE; + APIRET rc; + + /* + * File must be opened SHARE_DENYWRITE and ACCESS_READWRITE, otherwise + * DosQueryFileInfo() will fail if we try to get a file length, etc. + */ + rc = DosOpen(filename, &hfile, &dummy, 0, FILE_NORMAL, + OPEN_ACTION_OPEN_IF_EXISTS | OPEN_ACTION_CREATE_IF_NEW, + OPEN_FLAGS_FAIL_ON_ERROR | OPEN_FLAGS_NO_LOCALITY | + OPEN_FLAGS_NOINHERIT | OPEN_SHARE_DENYWRITE | + OPEN_ACCESS_READWRITE, NULL); + + BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc), NULL); + + rc = DosSetFilePtr(hfile, 0, FILE_END, &dummy); + if (rc != NO_ERROR) + { + DosClose(hfile); + BAIL_MACRO(errcodeFromAPIRET(rc), NULL); + } /* if */ + + return ((void *) hfile); +} /* __PHYSFS_platformOpenAppend */ + + +PHYSFS_sint64 __PHYSFS_platformRead(void *opaque, void *buf, PHYSFS_uint64 len) +{ + ULONG br = 0; + APIRET rc; + BAIL_IF_MACRO(!__PHYSFS_ui64FitsAddressSpace(len),ERR_INVALID_ARGUMENT,-1); + rc = DosRead((HFILE) opaque, buf, (ULONG) len, &br); + BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc), (br > 0) ? ((PHYSFS_sint64) br) : -1); + return (PHYSFS_sint64) br; +} /* __PHYSFS_platformRead */ + + +PHYSFS_sint64 __PHYSFS_platformWrite(void *opaque, const void *buf, + PHYSFS_uint64 len) +{ + ULONG bw = 0; + APIRET rc; + BAIL_IF_MACRO(!__PHYSFS_ui64FitsAddressSpace(len),ERR_INVALID_ARGUMENT,-1); + rc = DosWrite((HFILE) opaque, buf, (ULONG) len, &bw); + BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc), (bw > 0) ? ((PHYSFS_sint64) bw) : -1); + return (PHYSFS_sint64) bw; +} /* __PHYSFS_platformWrite */ + + +int __PHYSFS_platformSeek(void *opaque, PHYSFS_uint64 pos) +{ + ULONG dummy; + HFILE hfile = (HFILE) opaque; + LONG dist = (LONG) pos; + APIRET rc; + + /* hooray for 32-bit filesystem limits! :) */ + BAIL_IF_MACRO((PHYSFS_uint64) dist != pos, ERR_SEEK_OUT_OF_RANGE, 0); + rc = DosSetFilePtr(hfile, dist, FILE_BEGIN, &dummy); + BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc), 0); + return 1; +} /* __PHYSFS_platformSeek */ + + +PHYSFS_sint64 __PHYSFS_platformTell(void *opaque) +{ + ULONG pos; + HFILE hfile = (HFILE) opaque; + const APIRET rc = DosSetFilePtr(hfile, 0, FILE_CURRENT, &pos); + BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc), -1); + return ((PHYSFS_sint64) pos); +} /* __PHYSFS_platformTell */ + + +PHYSFS_sint64 __PHYSFS_platformFileLength(void *opaque) +{ + FILESTATUS3 fs; + HFILE hfile = (HFILE) opaque; + const APIRET rc = DosQueryFileInfo(hfile, FIL_STANDARD, &fs, sizeof (fs)); + BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc), -1); + return ((PHYSFS_sint64) fs.cbFile); +} /* __PHYSFS_platformFileLength */ + + +int __PHYSFS_platformFlush(void *opaque) +{ + const APIRET rc = DosResetBuffer((HFILE) opaque); + BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc), 0); + return 1; +} /* __PHYSFS_platformFlush */ + + +void __PHYSFS_platformClose(void *opaque) +{ + DosClose((HFILE) opaque); /* ignore errors. You should have flushed! */ +} /* __PHYSFS_platformClose */ + + +int __PHYSFS_platformDelete(const char *_path) +{ + FILESTATUS3 fs; + const unsigned char *path = (const unsigned char *) _path; + APIRET rc = DosQueryPathInfo(path, FIL_STANDARD, &fs, sizeof (fs)); + BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc), 0); + rc = (fs.attrFile & FILE_DIRECTORY) ? DosDeleteDir(path) : DosDelete(path); + BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc), 0); + return 1; +} /* __PHYSFS_platformDelete */ + + +/* Convert to a format PhysicsFS can grok... */ +PHYSFS_sint64 os2TimeToUnixTime(const FDATE *date, const FTIME *time) +{ + struct tm tm; + + tm.tm_sec = ((PHYSFS_uint32) time->.twosecs) * 2; + tm.tm_min = time->minutes; + tm.tm_hour = time->hours; + tm.tm_mday = date->day; + tm.tm_mon = date->month; + tm.tm_year = ((PHYSFS_uint32) date->year) + 80; + tm.tm_wday = -1 /*st_localtz.wDayOfWeek*/; + tm.tm_yday = -1; + tm.tm_isdst = -1; + + return (PHYSFS_sint64) mktime(&tm); +} /* os2TimeToUnixTime */ + + +int __PHYSFS_platformStat(const char *filename, PHYSFS_Stat *st) +{ + struct tm tm; + FILESTATUS3 fs; + const unsigned char *fname = (const unsigned char *) _fname; + const APIRET rc = DosQueryPathInfo(fname, FIL_STANDARD, &fs, sizeof (fs)); + BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc), 0); + + if (fs.attrFile & FILE_DIRECTORY) + { + stat->filetype = PHYSFS_FILETYPE_DIRECTORY; + stat->filesize = 0; + } /* if */ + else + { + stat->filetype = PHYSFS_FILETYPE_REGULAR; + stat->filesize = fs.cbFile; + } /* else */ + + stat->modtime = os2TimeToUnixTime(&fs.fdateLastWrite, &fs.ftimeLastWrite); + if (stat->modtime < 0) + stat->modtime = 0; + + stat->accesstime = os2TimeToUnixTime(&fs.fdateLastAccess, &fs.ftimeLastAccess); + if (stat->accesstime < 0) + stat->accesstime = 0; + + stat->createtime = os2TimeToUnixTime(&fs.fdateCreation, &fs.ftimeCreation); + if (stat->createtime < 0) + stat->createtime = 0; + + stat->readonly = ((fs.attrFile & FILE_READONLY) == FILE_READONLY); + + return 1; +} /* __PHYSFS_platformStat */ + + +void *__PHYSFS_platformGetThreadID(void) +{ + PTIB ptib; + PPIB ppib; + + /* + * Allegedly, this API never fails, but we'll punt and return a + * default value (zero might as well do) if it does. + */ + const APIRET rc = DosGetInfoBlocks(&ptib, &ppib); + BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc), 0); + return ((void *) ptib->tib_ordinal); +} /* __PHYSFS_platformGetThreadID */ + + +void *__PHYSFS_platformCreateMutex(void) +{ + HMTX hmtx = NULLHANDLE; + const APIRET rc = DosCreateMutexSem(NULL, &hmtx, 0, 0); + BAIL_IF_MACRO(rc != NO_ERROR, errcodeFromAPIRET(rc), NULL); + return ((void *) hmtx); +} /* __PHYSFS_platformCreateMutex */ + + +void __PHYSFS_platformDestroyMutex(void *mutex) +{ + DosCloseMutexSem((HMTX) mutex); +} /* __PHYSFS_platformDestroyMutex */ + + +int __PHYSFS_platformGrabMutex(void *mutex) +{ + /* Do _NOT_ set the physfs error message in here! */ + return (DosRequestMutexSem((HMTX) mutex, SEM_INDEFINITE_WAIT) == NO_ERROR); +} /* __PHYSFS_platformGrabMutex */ + + +void __PHYSFS_platformReleaseMutex(void *mutex) +{ + DosReleaseMutexSem((HMTX) 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_OS2 */ + +/* end of os2.c ... */