Added support for WinRT 8.1 Universal Apps.

Hopefully this will work on Win10 as well... Only time will tell!
Here's what's changed:
1. Added a platform_winrt.cpp file. It's based on platform_windows.c but has some WinRT-specific changes.
2. Changed physfs_platforms.h to define PHYSFS_PLATFORM_WINRT when running on WinRT. PHYSFS_PLATFORM_WINDOWS should also be defined, as WinRT behaves a lot like "normal" Windows and this flag is tested against in multiple parts of the PhysFS source code.
3. Changed platform_windows.c to not be used when PHYSFS_PLATFORM_WINRT is defined.
4. In order to work on Windows ARM devices, I had to change in physfs_internal.h, to include _M_ARM as a flag for running on ARM as "ARM" and "__arm__" aren't defined when running on a Windows ARM device.

What I've tested:
* Setting up a "sane folder configuration"
* Reading and writing files
* Mounting zip files
* Using seek & tell
* Checking file length

All of these work fine. I couldn't get the actual test software to run on WinRT, but it seems like eveyrthing's working. I've tested these things on my Windows 8.1 computer, as well as my Lumia 920 which is currently running Windows 8.1.

src/physfs_internal.h

@@ -134,7 +134,7 @@ void __PHYSFS_smallFree(void *ptr);
 #if  defined(__i386__) || defined(__ia64__) || \
      defined(_M_IX86) || defined(_M_IA64) || defined(_M_X64) || \
     (defined(__alpha__) || defined(__alpha)) || \
-     defined(__arm__) || defined(ARM) || \
+     defined(__arm__) || defined(ARM) || defined(_M_ARM) || \
     (defined(__mips__) && defined(__MIPSEL__)) || \
      defined(__SYMBIAN32__) || \
      defined(__x86_64__) || \

src/physfs_platforms.h

@@ -21,6 +21,10 @@
 #  define PHYSFS_PLATFORM_POSIX 1
 #elif (defined _WIN32_WCE) || (defined _WIN64_WCE)
 #  error PocketPC support was dropped from PhysicsFS 2.1. Sorry.
+#elif ((defined WINAPI_FAMILY) && WINAPI_FAMILY == WINAPI_FAMILY_APP)
+#	define PHYSFS_PLATFORM_WINRT 1
+#	define PHYSFS_NO_CDROM_SUPPORT 1
+#   define PHYSFS_PLATFORM_WINDOWS 1;
 #elif (((defined _WIN32) || (defined _WIN64)) && (!defined __CYGWIN__))
 #  define PHYSFS_PLATFORM_WINDOWS 1
 #elif (defined OS2)

src/platform_windows.c

@@ -10,6 +10,7 @@
 #include "physfs_platforms.h"
 
 #ifdef PHYSFS_PLATFORM_WINDOWS
+#ifndef PHYSFS_PLATFORM_WINRT
 
 /* Forcibly disable UNICODE macro, since we manage this ourselves. */
 #ifdef UNICODE
@@ -928,6 +929,7 @@ int __PHYSFS_platformSetDefaultAllocator(PHYSFS_Allocator *a)
 } /* __PHYSFS_platformSetDefaultAllocator */
 
 #endif  /* PHYSFS_PLATFORM_WINDOWS */
+#endif  /* PHYSFS_PLATFORM_WINRT */
 
 /* end of windows.c ... */
 

src/platform_winrt.cpp

@@ -0,0 +1,674 @@
+/*
+* Windows Runtime support routines for PhysicsFS.
+*
+* Please see the file LICENSE.txt in the source's root directory.
+*
+*  This file is based on "platform_windows.c" by Ryan C. Gordon and Gregory S. Read.
+*  Windows Runtime-specific additions and changes are made by Martin "T-Bone" Ahrnbom. 
+*
+* Instructions for setting up PhysFS in a WinRT Universal 8.1 app in Visual Studio 2013:
+* (hopefully these instructions will be somewhat valid with Windows 10 Apps as well...)
+*
+*  1. In Visual Studio 2013 (or later?), hit File -> New -> Project...
+*  2. On the left, navigate to Templates -> Visual C++ -> Store Apps -> Universal Apps
+*  3. In the middle of the window, select "DLL (Universal Apps)"
+*  4. Near the bottom, give the project a name (like PhysFS-WinRT) and choose a location
+*  5. In the Solution Explorer (to the right typically), delete all .cpp and .h files in
+*     PhysFS-WinRT.Shared except targetver.h.
+*  6. In Windows Explorer, find the "src" folder of the PhysFS source code. Select all files
+* 	  in the folder (ignore the "lzma" folder, we're not including 7Zip support because it's messy to compile).
+*	  Drag and drop all of the source files onto PhysFS-WinRT-Shared in Visual Studio.
+*  7. In Windows Explorer, find the file called "physfs.h". Copy this file into a folder of its own somewhere.
+*	  I suggest naming that folder "include". This will be your "include" folder for any projects using PhysFS.
+*  8. In the Solution Explorer, right click on PhysFS-WinRT.Windows and select Properties. Make sure that "Configuration" is set to 
+*     "All Configurations" and "Platform" is set to "All Platforms" near the top of the window.
+*  9. On the left, select "Precompiled Headers". Change "Precompiled Header" from "Use (/Yu)" to "Not Using Precompiled Headers".
+* 10. On the left, navigate to Configuration Properties -> C/C++ -> Preprocessor. In Preprocessor Definitions, add "_CRT_SECURE_NO_WARNINGS"
+* 11. Hit the OK button.
+* 12. Repeat steps 8-11 but for PhysFS-WinRT.WindowsPhone.
+* 13. In the Solution Explorer, find "platform_winrt.cpp" in PhysFS-WinRT.Shared. Right click on it and select "Properties". 
+* 14. On the left, navigate to Configuration Properties -> C/C++ -> General. On the right, change "Consume Windows Runtime Extensions"
+*	  from "No" to "Yes (/ZW)". Hit "OK".
+* 15. Near the top of the Visual Studio window, select BUILD -> Batch Build... Hit "Select All", and then "Build".
+* 16. Now you have a bunch of .dll and .lib files, as well as an include folder that you can use in your projects!
+* 17. ???
+* 18. Profit!
+*/
+
+
+#define __PHYSICSFS_INTERNAL__
+#include "physfs_platforms.h"
+
+#ifdef PHYSFS_PLATFORM_WINRT
+
+#include "physfs_internal.h"
+
+#include <windows.h>
+#include <errno.h>
+#include <ctype.h>
+#include <time.h>
+
+#define LOWORDER_UINT64(pos) ((PHYSFS_uint32) (pos & 0xFFFFFFFF))
+#define HIGHORDER_UINT64(pos) ((PHYSFS_uint32) ((pos >> 32) & 0xFFFFFFFF))
+
+
+/*
+* Users without the platform SDK don't have this defined.  The original docs
+*  for SetFilePointer() just said to compare with 0xFFFFFFFF, so this should
+*  work as desired.
+*/
+#define PHYSFS_INVALID_SET_FILE_POINTER  0xFFFFFFFF
+
+/* just in case... */
+#define PHYSFS_INVALID_FILE_ATTRIBUTES   0xFFFFFFFF
+
+/* Not defined before the Vista SDK. */
+#define PHYSFS_IO_REPARSE_TAG_SYMLINK    0xA000000C
+
+
+#define UTF8_TO_UNICODE_STACK_MACRO(w_assignto, str) { \
+    if (str == NULL) \
+        w_assignto = NULL; \
+			    else { \
+        const PHYSFS_uint64 len = (PHYSFS_uint64) ((strlen(str) + 1) * 2); \
+        w_assignto = (WCHAR *) __PHYSFS_smallAlloc(len); \
+        if (w_assignto != NULL) \
+            PHYSFS_utf8ToUtf16(str, (PHYSFS_uint16 *) w_assignto, len); \
+			    } \
+} \
+
+/* Note this counts WCHARs, not codepoints! */
+static PHYSFS_uint64 wStrLen(const WCHAR *wstr)
+{
+	PHYSFS_uint64 len = 0;
+	while (*(wstr++))
+		len++;
+	return len;
+} /* wStrLen */
+
+/* !!! FIXME: do we really need readonly? If not, do we need this struct? */
+typedef struct
+{
+	HANDLE handle;
+	int readonly;
+} WinApiFile;
+
+static HANDLE detectCDThreadHandle = NULL;
+static HWND detectCDHwnd = 0;
+static volatile int initialDiscDetectionComplete = 0;
+static volatile DWORD drivesWithMediaBitmap = 0;
+
+
+static PHYSFS_ErrorCode errcodeFromWinApiError(const DWORD err)
+{
+	/*
+	* win32 error codes are sort of a tricky thing; Microsoft intentionally
+	*  doesn't list which ones a given API might trigger, there are several
+	*  with overlapping and unclear meanings...and there's 16 thousand of
+	*  them in Windows 7. It looks like the ones we care about are in the
+	*  first 500, but I can't say this list is perfect; we might miss
+	*  important values or misinterpret others.
+	*
+	* Don't treat this list as anything other than a work in progress.
+	*/
+	switch (err)
+	{
+	case ERROR_SUCCESS: return PHYSFS_ERR_OK;
+	case ERROR_ACCESS_DENIED: return PHYSFS_ERR_PERMISSION;
+	case ERROR_NETWORK_ACCESS_DENIED: return PHYSFS_ERR_PERMISSION;
+	case ERROR_NOT_READY: return PHYSFS_ERR_IO;
+	case ERROR_CRC: return PHYSFS_ERR_IO;
+	case ERROR_SEEK: return PHYSFS_ERR_IO;
+	case ERROR_SECTOR_NOT_FOUND: return PHYSFS_ERR_IO;
+	case ERROR_NOT_DOS_DISK: return PHYSFS_ERR_IO;
+	case ERROR_WRITE_FAULT: return PHYSFS_ERR_IO;
+	case ERROR_READ_FAULT: return PHYSFS_ERR_IO;
+	case ERROR_DEV_NOT_EXIST: return PHYSFS_ERR_IO;
+		/* !!! FIXME: ?? case ELOOP: return PHYSFS_ERR_SYMLINK_LOOP; */
+	case ERROR_BUFFER_OVERFLOW: return PHYSFS_ERR_BAD_FILENAME;
+	case ERROR_INVALID_NAME: return PHYSFS_ERR_BAD_FILENAME;
+	case ERROR_BAD_PATHNAME: return PHYSFS_ERR_BAD_FILENAME;
+	case ERROR_DIRECTORY: return PHYSFS_ERR_BAD_FILENAME;
+	case ERROR_FILE_NOT_FOUND: return PHYSFS_ERR_NOT_FOUND;
+	case ERROR_PATH_NOT_FOUND: return PHYSFS_ERR_NOT_FOUND;
+	case ERROR_DELETE_PENDING: return PHYSFS_ERR_NOT_FOUND;
+	case ERROR_INVALID_DRIVE: return PHYSFS_ERR_NOT_FOUND;
+	case ERROR_HANDLE_DISK_FULL: return PHYSFS_ERR_NO_SPACE;
+	case ERROR_DISK_FULL: return PHYSFS_ERR_NO_SPACE;
+		/* !!! FIXME: ?? case ENOTDIR: return PHYSFS_ERR_NOT_FOUND; */
+		/* !!! FIXME: ?? case EISDIR: return PHYSFS_ERR_NOT_A_FILE; */
+	case ERROR_WRITE_PROTECT: return PHYSFS_ERR_READ_ONLY;
+	case ERROR_LOCK_VIOLATION: return PHYSFS_ERR_BUSY;
+	case ERROR_SHARING_VIOLATION: return PHYSFS_ERR_BUSY;
+	case ERROR_CURRENT_DIRECTORY: return PHYSFS_ERR_BUSY;
+	case ERROR_DRIVE_LOCKED: return PHYSFS_ERR_BUSY;
+	case ERROR_PATH_BUSY: return PHYSFS_ERR_BUSY;
+	case ERROR_BUSY: return PHYSFS_ERR_BUSY;
+	case ERROR_NOT_ENOUGH_MEMORY: return PHYSFS_ERR_OUT_OF_MEMORY;
+	case ERROR_OUTOFMEMORY: return PHYSFS_ERR_OUT_OF_MEMORY;
+	case ERROR_DIR_NOT_EMPTY: return PHYSFS_ERR_DIR_NOT_EMPTY;
+	default: return PHYSFS_ERR_OS_ERROR;
+	} /* switch */
+} /* errcodeFromWinApiError */
+
+static inline PHYSFS_ErrorCode errcodeFromWinApi(void)
+{
+	return errcodeFromWinApiError(GetLastError());
+} /* errcodeFromWinApi */
+
+
+typedef BOOL(WINAPI *fnSTEM)(DWORD, LPDWORD b);
+
+static DWORD pollDiscDrives(void)
+{
+	// We don't do discs
+	return 0;
+} /* pollDiscDrives */
+
+
+static LRESULT CALLBACK detectCDWndProc(HWND hwnd, UINT msg,
+	WPARAM wp, LPARAM lparam)
+{
+	return FALSE;
+} /* detectCDWndProc */
+
+
+static DWORD WINAPI detectCDThread(LPVOID lpParameter)
+{
+	return 0;
+} /* detectCDThread */
+
+
+void __PHYSFS_platformDetectAvailableCDs(PHYSFS_StringCallback cb, void *data)
+{
+	return;
+} /* __PHYSFS_platformDetectAvailableCDs */
+
+
+static char *unicodeToUtf8Heap(const WCHAR *w_str)
+{
+	char *retval = NULL;
+	if (w_str != NULL)
+	{
+		void *ptr = NULL;
+		const PHYSFS_uint64 len = (wStrLen(w_str) * 4) + 1;
+		retval = (char*)allocator.Malloc(len);
+		BAIL_IF_MACRO(!retval, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
+		PHYSFS_utf8FromUtf16((const PHYSFS_uint16 *)w_str, retval, len);
+		ptr = allocator.Realloc(retval, strlen(retval) + 1); /* shrink. */
+		if (ptr != NULL)
+			retval = (char *)ptr;
+	} /* if */
+	return retval;
+} /* unicodeToUtf8Heap */
+
+char *__PHYSFS_platformCalcBaseDir(const char *argv0)
+{
+	const wchar_t* path = Windows::ApplicationModel::Package::Current->InstalledLocation->Path->Data();
+	wchar_t path2[1024];
+	wcscpy_s(path2, path);
+	wcscat_s(path2, L"\\");
+	return unicodeToUtf8Heap(path2);
+
+} /* __PHYSFS_platformCalcBaseDir */
+
+
+char *__PHYSFS_platformCalcPrefDir(const char *org, const char *app)
+{
+	const wchar_t* path = Windows::Storage::ApplicationData::Current->LocalFolder->Path->Data();
+	wchar_t path2[1024];
+	wcscpy_s(path2, path);
+	wcscat_s(path2, L"\\");
+	return unicodeToUtf8Heap(path2);
+} /* __PHYSFS_platformCalcPrefDir */
+
+
+char *__PHYSFS_platformCalcUserDir(void)
+{
+	return __PHYSFS_platformCalcPrefDir(NULL, NULL);
+} /* __PHYSFS_platformCalcUserDir */
+
+
+void *__PHYSFS_platformGetThreadID(void)
+{
+	return ((void *)((size_t)GetCurrentThreadId()));
+} /* __PHYSFS_platformGetThreadID */
+
+
+static int isSymlinkAttrs(const DWORD attr, const DWORD tag)
+{
+	return ((attr & FILE_ATTRIBUTE_REPARSE_POINT) &&
+		(tag == PHYSFS_IO_REPARSE_TAG_SYMLINK));
+} /* isSymlinkAttrs */
+
+
+void __PHYSFS_platformEnumerateFiles(const char *dirname,
+	PHYSFS_EnumFilesCallback callback,
+	const char *origdir,
+	void *callbackdata)
+{
+
+	HANDLE dir = INVALID_HANDLE_VALUE;
+	WIN32_FIND_DATAW entw;
+	size_t len = strlen(dirname);
+	char *searchPath = NULL;
+	WCHAR *wSearchPath = NULL;
+
+	/* Allocate a new string for path, maybe '\\', "*", and NULL terminator */
+	searchPath = (char *)__PHYSFS_smallAlloc(len + 3);
+	if (searchPath == NULL)
+		return;
+
+	/* 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(wSearchPath, searchPath);
+	if (!wSearchPath)
+		return;  /* oh well. */
+
+	//dir = FindFirstFileW(wSearchPath, &entw);
+	dir = FindFirstFileExW(wSearchPath, FindExInfoStandard, &entw, FindExSearchNameMatch, NULL, 0);
+
+	__PHYSFS_smallFree(wSearchPath);
+	__PHYSFS_smallFree(searchPath);
+	if (dir == INVALID_HANDLE_VALUE)
+		return;
+
+	do
+	{
+		const DWORD attr = entw.dwFileAttributes;
+		const DWORD tag = entw.dwReserved0;
+		const WCHAR *fn = entw.cFileName;
+		char *utf8;
+
+		if ((fn[0] == '.') && (fn[1] == '\0'))
+			continue;
+		if ((fn[0] == '.') && (fn[1] == '.') && (fn[2] == '\0'))
+			continue;
+
+		utf8 = unicodeToUtf8Heap(fn);
+		if (utf8 != NULL)
+		{
+			callback(callbackdata, origdir, utf8);
+			allocator.Free(utf8);
+		} /* if */
+	} while (FindNextFileW(dir, &entw) != 0);
+
+	FindClose(dir);
+} /* __PHYSFS_platformEnumerateFiles */
+
+
+int __PHYSFS_platformMkDir(const char *path)
+{
+	WCHAR *wpath;
+	DWORD rc;
+	UTF8_TO_UNICODE_STACK_MACRO(wpath, path);
+	rc = CreateDirectoryW(wpath, NULL);
+	__PHYSFS_smallFree(wpath);
+	BAIL_IF_MACRO(rc == 0, errcodeFromWinApi(), 0);
+	return 1;
+} /* __PHYSFS_platformMkDir */
+
+
+int __PHYSFS_platformInit(void)
+{
+	return 1;  /* It's all good */
+} /* __PHYSFS_platformInit */
+
+
+int __PHYSFS_platformDeinit(void)
+{
+	return 1; /* It's all good */
+} /* __PHYSFS_platformDeinit */
+
+
+static void *doOpen(const char *fname, DWORD mode, DWORD creation, int rdonly)
+{
+	HANDLE fileh;
+	WinApiFile *retval;
+	WCHAR *wfname;
+
+	UTF8_TO_UNICODE_STACK_MACRO(wfname, fname);
+	BAIL_IF_MACRO(!wfname, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
+	//fileh = CreateFileW(wfname, mode, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, creation, FILE_ATTRIBUTE_NORMAL, NULL);
+	fileh = CreateFile2(wfname, mode, FILE_SHARE_READ | FILE_SHARE_WRITE, creation, NULL);
+	__PHYSFS_smallFree(wfname);
+
+	BAIL_IF_MACRO(fileh == INVALID_HANDLE_VALUE, errcodeFromWinApi(), NULL);
+
+	retval = (WinApiFile *)allocator.Malloc(sizeof(WinApiFile));
+	if (!retval)
+	{
+		CloseHandle(fileh);
+		BAIL_MACRO(PHYSFS_ERR_OUT_OF_MEMORY, NULL);
+	} /* if */
+
+	retval->readonly = rdonly;
+	retval->handle = fileh;
+	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 = ((WinApiFile *)retval)->handle;
+		//DWORD rc = SetFilePointer(h, 0, NULL, FILE_END);
+		const LARGE_INTEGER zero = { 0 };
+		DWORD rc = SetFilePointerEx(h, zero, NULL, FILE_END);
+		if (rc == PHYSFS_INVALID_SET_FILE_POINTER)
+		{
+			const PHYSFS_ErrorCode err = errcodeFromWinApi();
+			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 = ((WinApiFile *)opaque)->handle;
+	PHYSFS_sint64 totalRead = 0;
+
+	if (!__PHYSFS_ui64FitsAddressSpace(len))
+		BAIL_MACRO(PHYSFS_ERR_INVALID_ARGUMENT, -1);
+
+	while (len > 0)
+	{
+		const DWORD thislen = (len > 0xFFFFFFFF) ? 0xFFFFFFFF : (DWORD)len;
+		DWORD numRead = 0;
+		if (!ReadFile(Handle, buf, thislen, &numRead, NULL))
+			BAIL_MACRO(errcodeFromWinApi(), -1);
+		len -= (PHYSFS_uint64)numRead;
+		totalRead += (PHYSFS_sint64)numRead;
+		if (numRead != thislen)
+			break;
+	} /* while */
+	
+	return totalRead;
+} /* __PHYSFS_platformRead */
+
+
+PHYSFS_sint64 __PHYSFS_platformWrite(void *opaque, const void *buffer,
+	PHYSFS_uint64 len)
+{
+	HANDLE Handle = ((WinApiFile *)opaque)->handle;
+	PHYSFS_sint64 totalWritten = 0;
+
+	if (!__PHYSFS_ui64FitsAddressSpace(len))
+		BAIL_MACRO(PHYSFS_ERR_INVALID_ARGUMENT, -1);
+
+	while (len > 0)
+	{
+		const DWORD thislen = (len > 0xFFFFFFFF) ? 0xFFFFFFFF : (DWORD)len;
+		DWORD numWritten = 0;
+		if (!WriteFile(Handle, buffer, thislen, &numWritten, NULL))
+			BAIL_MACRO(errcodeFromWinApi(), -1);
+		len -= (PHYSFS_uint64)numWritten;
+		totalWritten += (PHYSFS_sint64)numWritten;
+		if (numWritten != thislen)
+			break;
+	} /* while */
+
+	return totalWritten;
+} /* __PHYSFS_platformWrite */
+
+
+int __PHYSFS_platformSeek(void *opaque, PHYSFS_uint64 pos)
+{
+	HANDLE Handle = ((WinApiFile *)opaque)->handle;
+	BOOL rc;
+
+	LARGE_INTEGER li;
+	li.LowPart = LOWORDER_UINT64(pos);
+	li.HighPart = HIGHORDER_UINT64(pos);
+
+	rc = SetFilePointerEx(Handle, li, NULL, FILE_BEGIN);
+
+	if (!rc && (GetLastError() != NO_ERROR))
+	{
+		BAIL_MACRO(errcodeFromWinApi(), 0);
+	} /* if */
+
+	return 1;  /* No error occured */
+} /* __PHYSFS_platformSeek */
+
+
+PHYSFS_sint64 __PHYSFS_platformTell(void *opaque)
+{
+	HANDLE Handle = ((WinApiFile *)opaque)->handle;
+	PHYSFS_sint64 retval;
+	BOOL rc;
+
+	LARGE_INTEGER zero;
+	zero.QuadPart = 0;
+	LARGE_INTEGER out;
+
+	rc = SetFilePointerEx(Handle, zero, &out, FILE_CURRENT);
+	if (!rc)
+	{
+		BAIL_MACRO(errcodeFromWinApi(), -1);
+	} /* if */
+	else
+	{
+		retval = out.QuadPart;
+		assert(retval >= 0);
+	} /* else */
+
+	return retval;
+} /* __PHYSFS_platformTell */
+
+
+PHYSFS_sint64 __PHYSFS_platformFileLength(void *opaque)
+{
+	HANDLE Handle = ((WinApiFile *)opaque)->handle;
+	PHYSFS_sint64 retval;
+
+	FILE_STANDARD_INFO file_info = { 0 };
+	const BOOL res = GetFileInformationByHandleEx(Handle, FileStandardInfo, &file_info, sizeof(file_info));
+	if (res) {
+		retval = file_info.EndOfFile.QuadPart;
+		assert(retval >= 0);
+	}
+	else {
+		PHYSFS_setErrorCode(PHYSFS_ERR_NOT_FOUND);
+	}
+
+	
+	return retval;
+} /* __PHYSFS_platformFileLength */
+
+
+int __PHYSFS_platformFlush(void *opaque)
+{
+	WinApiFile *fh = ((WinApiFile *)opaque);
+	if (!fh->readonly)
+		BAIL_IF_MACRO(!FlushFileBuffers(fh->handle), errcodeFromWinApi(), 0);
+
+	return 1;
+} /* __PHYSFS_platformFlush */
+
+
+void __PHYSFS_platformClose(void *opaque)
+{
+	HANDLE Handle = ((WinApiFile *)opaque)->handle;
+	(void)CloseHandle(Handle); /* ignore errors. You should have flushed! */
+	allocator.Free(opaque);
+} /* __PHYSFS_platformClose */
+
+
+static int doPlatformDelete(LPWSTR wpath)
+{
+	//const int isdir = (GetFileAttributesW(wpath) & FILE_ATTRIBUTE_DIRECTORY);
+	int isdir = 0;
+	WIN32_FILE_ATTRIBUTE_DATA file_info;
+	const BOOL res = GetFileAttributesEx(wpath, GetFileExInfoStandard, &file_info);
+	if (res) {
+		isdir = (file_info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY);
+	}
+
+	const BOOL rc = (isdir) ? RemoveDirectoryW(wpath) : DeleteFileW(wpath);
+	BAIL_IF_MACRO(!rc, errcodeFromWinApi(), 0);
+	return 1;   /* if you made it here, it worked. */
+} /* doPlatformDelete */
+
+
+int __PHYSFS_platformDelete(const char *path)
+{
+	int retval = 0;
+	LPWSTR wpath = NULL;
+	UTF8_TO_UNICODE_STACK_MACRO(wpath, path);
+	BAIL_IF_MACRO(!wpath, PHYSFS_ERR_OUT_OF_MEMORY, 0);
+	retval = doPlatformDelete(wpath);
+	__PHYSFS_smallFree(wpath);
+	return retval;
+} /* __PHYSFS_platformDelete */
+
+
+void *__PHYSFS_platformCreateMutex(void)
+{
+	LPCRITICAL_SECTION lpcs;
+	lpcs = (LPCRITICAL_SECTION)allocator.Malloc(sizeof(CRITICAL_SECTION));
+	BAIL_IF_MACRO(!lpcs, PHYSFS_ERR_OUT_OF_MEMORY, NULL);
+	//InitializeCriticalSection(lpcs);
+	InitializeCriticalSectionEx(lpcs, 2000, 0);
+	return lpcs;
+} /* __PHYSFS_platformCreateMutex */
+
+
+void __PHYSFS_platformDestroyMutex(void *mutex)
+{
+	DeleteCriticalSection((LPCRITICAL_SECTION)mutex);
+	allocator.Free(mutex);
+} /* __PHYSFS_platformDestroyMutex */
+
+
+int __PHYSFS_platformGrabMutex(void *mutex)
+{
+	EnterCriticalSection((LPCRITICAL_SECTION)mutex);
+	return 1;
+} /* __PHYSFS_platformGrabMutex */
+
+
+void __PHYSFS_platformReleaseMutex(void *mutex)
+{
+	LeaveCriticalSection((LPCRITICAL_SECTION)mutex);
+} /* __PHYSFS_platformReleaseMutex */
+
+
+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;
+	BOOL rc;
+
+	BAIL_IF_MACRO(!FileTimeToSystemTime(ft, &st_utc), errcodeFromWinApi(), -1);
+	tzid = GetTimeZoneInformation(&tzi);
+	BAIL_IF_MACRO(tzid == TIME_ZONE_ID_INVALID, errcodeFromWinApi(), -1);
+	rc = SystemTimeToTzSpecificLocalTime(&tzi, &st_utc, &st_localtz);
+	BAIL_IF_MACRO(!rc, errcodeFromWinApi(), -1);
+
+	/* 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, PHYSFS_ERR_OS_ERROR, -1);
+	return retval;
+} /* FileTimeToPhysfsTime */
+
+
+int __PHYSFS_platformStat(const char *filename, PHYSFS_Stat *st)
+{
+	WIN32_FILE_ATTRIBUTE_DATA winstat;
+	WCHAR *wstr = NULL;
+	DWORD err = 0;
+	BOOL rc = 0;
+
+	UTF8_TO_UNICODE_STACK_MACRO(wstr, filename);
+	BAIL_IF_MACRO(!wstr, PHYSFS_ERR_OUT_OF_MEMORY, 0);
+	rc = GetFileAttributesExW(wstr, GetFileExInfoStandard, &winstat);
+	err = (!rc) ? GetLastError() : 0;
+	__PHYSFS_smallFree(wstr);
+	BAIL_IF_MACRO(!rc, errcodeFromWinApiError(err), 0);
+
+	st->modtime = FileTimeToPhysfsTime(&winstat.ftLastWriteTime);
+	st->accesstime = FileTimeToPhysfsTime(&winstat.ftLastAccessTime);
+	st->createtime = FileTimeToPhysfsTime(&winstat.ftCreationTime);
+
+	if (winstat.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
+	{
+		st->filetype = PHYSFS_FILETYPE_DIRECTORY;
+		st->filesize = 0;
+	} /* if */
+
+	else if (winstat.dwFileAttributes & (FILE_ATTRIBUTE_OFFLINE | FILE_ATTRIBUTE_DEVICE))
+	{
+		/* !!! FIXME: what are reparse points? */
+		st->filetype = PHYSFS_FILETYPE_OTHER;
+		/* !!! FIXME: don't rely on this */
+		st->filesize = 0;
+	} /* else if */
+
+	/* !!! FIXME: check for symlinks on Vista. */
+
+	else
+	{
+		st->filetype = PHYSFS_FILETYPE_REGULAR;
+		st->filesize = (((PHYSFS_uint64)winstat.nFileSizeHigh) << 32) | winstat.nFileSizeLow;
+	} /* else */
+
+	st->readonly = ((winstat.dwFileAttributes & FILE_ATTRIBUTE_READONLY) != 0);
+
+	return 1;
+} /* __PHYSFS_platformStat */
+
+
+/* !!! 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_WINRT */