From d8845b0be57dd9e1c3df6dd60dbd2de76e154c99 Mon Sep 17 00:00:00 2001 From: "Ryan C. Gordon" Date: Mon, 26 Mar 2007 06:36:39 +0000 Subject: [PATCH] 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. Other minor Windows cleanups and corrections. --- CHANGELOG.txt | 9 + platform/windows.c | 637 ++++++++++++++++++++++++++++++--------------- 2 files changed, 431 insertions(+), 215 deletions(-) diff --git a/CHANGELOG.txt b/CHANGELOG.txt index 89370054..75f6cc24 100644 --- a/CHANGELOG.txt +++ b/CHANGELOG.txt @@ -2,6 +2,15 @@ * CHANGELOG. */ +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 diff --git a/platform/windows.c b/platform/windows.c index 51aaded1..c657bc14 100644 --- a/platform/windows.c +++ b/platform/windows.c @@ -11,6 +11,11 @@ #ifdef PHYSFS_PLATFORM_WINDOWS +/* Forcibly disable UNICODE, since we manage this ourselves. */ +#ifdef UNICODE +#undef UNICODE +#endif + #include #include #include @@ -41,25 +46,71 @@ 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); \ + w_assignto = (WCHAR *) __PHYSFS_smallAlloc(len); \ + if (w_assignto != NULL) \ + PHYSFS_utf8ToUcs2(str, (PHYSFS_uint16 *) w_assignto, len); \ } \ } \ +static PHYSFS_uint64 wStrLen(const WCHAR *wstr) +{ + PHYSFS_uint64 len = 0; + while (*(wstr++)) + len++; + return(len); +} /* wStrLen */ + +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 = allocator.Malloc(len); + BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL); + PHYSFS_utf8FromUcs2((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 */ + + +static char *codepageToUtf8Heap(const char *cpstr) +{ + char *retval = NULL; + if (cpstr != NULL) + { + const int len = (int) (strlen(cpstr) + 1); + WCHAR *wbuf = (WCHAR *) __PHYSFS_smallAlloc(len * sizeof (WCHAR)); + BAIL_IF_MACRO(wbuf == NULL, ERR_OUT_OF_MEMORY, NULL); + MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, cpstr, len, wbuf, len); + retval = (char *) allocator.Malloc(len * 4); + if (retval == NULL) + __PHYSFS_setError(ERR_OUT_OF_MEMORY); + else + PHYSFS_utf8FromUcs2(wbuf, retval, len * 4); + __PHYSFS_smallFree(wbuf); + } /* if */ + return(retval); +} /* codepageToUtf8Heap */ + + typedef struct { HANDLE handle; int readonly; -} win32file; +} WinApiFile; -const char *__PHYSFS_platformDirSeparator = "\\"; +static char *userDir = NULL; /* pointers for APIs that may not exist on some Windows versions... */ static HANDLE libKernel32 = NULL; static HANDLE libUserEnv = NULL; static HANDLE libAdvApi32 = NULL; -static DWORD (WINAPI *pGetModuleFileNameA)(HMODULE, LPCH, DWORD); static DWORD (WINAPI *pGetModuleFileNameW)(HMODULE, LPWCH, DWORD); static BOOL (WINAPI *pGetUserProfileDirectoryW)(HANDLE, LPWSTR, LPDWORD); static BOOL (WINAPI *pGetUserNameW)(LPWSTR, LPDWORD); @@ -76,18 +127,135 @@ static BOOL (WINAPI *pGetFileAttributesExW) (LPCWSTR, GET_FILEEX_INFO_LEVELS, LPVOID); static DWORD (WINAPI *pFormatMessageW) (DWORD, LPCVOID, DWORD, DWORD, LPWSTR, DWORD, va_list *); -static DWORD (WINAPI *pSearchPathW) - (LPCWSTR, LPCWSTR, LPCWSTR, DWORD, LPWSTR, LPWSTR *); static HANDLE (WINAPI *pCreateFileW) (LPCWSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES, DWORD, DWORD, HANDLE); -static char *userDir = NULL; + +/* + * Fallbacks for missing Unicode functions on Win95/98/ME. These are filled + * into the function pointers if looking up the real Unicode entry points + * in the system DLLs fails, so they're never used on WinNT/XP/Vista/etc. + * They make an earnest effort to convert to/from UTF-8 and UCS-2 to + * the user's current codepage. + */ + +static BOOL WINAPI fallbackGetUserNameW(LPWSTR buf, LPDWORD len) +{ + const DWORD cplen = *len; + char *cpstr = __PHYSFS_smallAlloc(cplen); + BOOL retval = GetUserNameA(cpstr, len); + if (buf != NULL) + MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, cpstr, cplen, buf, *len); + __PHYSFS_smallFree(cpstr); + return(retval); +} /* fallbackGetUserNameW */ + +static DWORD WINAPI fallbackFormatMessageW(DWORD dwFlags, LPCVOID lpSource, + DWORD dwMessageId, DWORD dwLangId, + LPWSTR lpBuf, DWORD nSize, + va_list *Arguments) +{ + char *cpbuf = (char *) __PHYSFS_smallAlloc(nSize); + DWORD retval = FormatMessageA(dwFlags, lpSource, dwMessageId, dwLangId, + cpbuf, nSize, Arguments); + if (retval > 0) + MultiByteToWideChar(CP_ACP,MB_PRECOMPOSED,cpbuf,retval,lpBuf,nSize); + __PHYSFS_smallFree(cpbuf); + return(retval); +} /* fallbackFormatMessageW */ + +static DWORD WINAPI fallbackGetModuleFileNameW(HMODULE hMod, LPWCH lpBuf, + DWORD nSize) +{ + char *cpbuf = (char *) __PHYSFS_smallAlloc(nSize); + DWORD retval = GetModuleFileNameA(hMod, cpbuf, nSize); + if (retval > 0) + MultiByteToWideChar(CP_ACP,MB_PRECOMPOSED,cpbuf,retval,lpBuf,nSize); + __PHYSFS_smallFree(cpbuf); + return(retval); +} /* fallbackGetModuleFileNameW */ + +static DWORD WINAPI fallbackGetFileAttributesW(LPCWSTR fname) +{ + DWORD retval = 0; + const int buflen = (int) (wStrLen(fname) + 1); + char *cpstr = (char *) __PHYSFS_smallAlloc(buflen); + WideCharToMultiByte(CP_ACP, 0, fname, buflen, cpstr, buflen, NULL, NULL); + retval = GetFileAttributesA(cpstr); + __PHYSFS_smallFree(cpstr); + return(retval); +} /* fallbackGetFileAttributesW */ + +static DWORD WINAPI fallbackGetCurrentDirectoryW(DWORD buflen, LPWSTR buf) +{ + DWORD retval = 0; + char *cpbuf = NULL; + if (buf != NULL) + cpbuf = (char *) __PHYSFS_smallAlloc(buflen); + retval = GetCurrentDirectoryA(buflen, cpbuf); + if (cpbuf != NULL) + { + MultiByteToWideChar(CP_ACP,MB_PRECOMPOSED,cpbuf,retval,buf,buflen); + __PHYSFS_smallFree(cpbuf); + } /* if */ + return(retval); +} /* fallbackGetCurrentDirectoryW */ + +static BOOL WINAPI fallbackRemoveDirectoryW(LPCWSTR dname) +{ + BOOL retval = 0; + const int buflen = (int) (wStrLen(dname) + 1); + char *cpstr = (char *) __PHYSFS_smallAlloc(buflen); + WideCharToMultiByte(CP_ACP, 0, dname, buflen, cpstr, buflen, NULL, NULL); + retval = RemoveDirectoryA(cpstr); + __PHYSFS_smallFree(cpstr); + return(retval); +} /* fallbackRemoveDirectoryW */ + +static BOOL WINAPI fallbackCreateDirectoryW(LPCWSTR dname, + LPSECURITY_ATTRIBUTES attr) +{ + BOOL retval = 0; + const int buflen = (int) (wStrLen(dname) + 1); + char *cpstr = (char *) __PHYSFS_smallAlloc(buflen); + WideCharToMultiByte(CP_ACP, 0, dname, buflen, cpstr, buflen, NULL, NULL); + retval = CreateDirectoryA(cpstr, attr); + __PHYSFS_smallFree(cpstr); + return(retval); +} /* fallbackCreateDirectoryW */ + +static BOOL WINAPI fallbackDeleteFileW(LPCWSTR fname) +{ + BOOL retval = 0; + const int buflen = (int) (wStrLen(fname) + 1); + char *cpstr = (char *) __PHYSFS_smallAlloc(buflen); + WideCharToMultiByte(CP_ACP, 0, fname, buflen, cpstr, buflen, NULL, NULL); + retval = DeleteFileA(cpstr); + __PHYSFS_smallFree(cpstr); + return(retval); +} /* fallbackDeleteFileW */ + +static HANDLE WINAPI fallbackCreateFileW(LPCWSTR fname, + DWORD dwDesiredAccess, DWORD dwShareMode, + LPSECURITY_ATTRIBUTES lpSecurityAttrs, + DWORD dwCreationDisposition, + DWORD dwFlagsAndAttrs, HANDLE hTemplFile) +{ + HANDLE retval; + const int buflen = (int) (wStrLen(fname) + 1); + char *cpstr = (char *) __PHYSFS_smallAlloc(buflen); + WideCharToMultiByte(CP_ACP, 0, fname, buflen, cpstr, buflen, NULL, NULL); + retval = CreateFileA(cpstr, dwDesiredAccess, dwShareMode, lpSecurityAttrs, + dwCreationDisposition, dwFlagsAndAttrs, hTemplFile); + __PHYSFS_smallFree(cpstr); + return(retval); +} /* fallbackCreateFileW */ /* A blatant abuse of pointer casting... */ -static void symLookup(HMODULE dll, void **addr, const char *sym) +static int symLookup(HMODULE dll, void **addr, const char *sym) { - *addr = GetProcAddress(dll, sym); + return( (*addr = GetProcAddress(dll, sym)) != NULL ); } /* symLookup */ @@ -95,81 +263,85 @@ static int findApiSymbols(void) { HMODULE dll = NULL; - #define LOOKUP(x) { symLookup(dll, (void **) &p##x, #x); } + #define LOOKUP_NOFALLBACK(x) { symLookup(dll, (void **) &p##x, #x); } +// #define LOOKUP(x) { \ +// if (!symLookup(dll, (void **) &p##x, #x)) \ + + #define LOOKUP(x) { \ + p##x = fallback##x; \ + } - dll = libUserEnv = LoadLibrary("userenv.dll"); + dll = libUserEnv = LoadLibraryA("userenv.dll"); if (dll != NULL) - LOOKUP(GetUserProfileDirectoryW); + LOOKUP_NOFALLBACK(GetUserProfileDirectoryW); /* !!! FIXME: what do they call advapi32.dll on Win64? */ - dll = libAdvApi32 = LoadLibrary("advapi32.dll"); + dll = libAdvApi32 = LoadLibraryA("advapi32.dll"); if (dll != NULL) LOOKUP(GetUserNameW); /* !!! FIXME: what do they call kernel32.dll on Win64? */ - dll = libKernel32 = LoadLibrary("kernel32.dll"); + dll = libKernel32 = LoadLibraryA("kernel32.dll"); if (dll != NULL) { - LOOKUP(GetModuleFileNameA); + LOOKUP_NOFALLBACK(GetFileAttributesExA); +// LOOKUP_NOFALLBACK(GetFileAttributesExW); LOOKUP(GetModuleFileNameW); LOOKUP(FormatMessageW); - LOOKUP(FindFirstFileW); - LOOKUP(FindNextFileW); +// LOOKUP_NOFALLBACK(FindFirstFileW); +// LOOKUP_NOFALLBACK(FindNextFileW); LOOKUP(GetFileAttributesW); - LOOKUP(GetFileAttributesExA); - LOOKUP(GetFileAttributesExW); LOOKUP(GetCurrentDirectoryW); LOOKUP(CreateDirectoryW); LOOKUP(RemoveDirectoryW); LOOKUP(CreateFileW); LOOKUP(DeleteFileW); - LOOKUP(SearchPathW); } /* if */ + #undef LOOKUP_NOFALLBACK #undef LOOKUP return(1); } /* findApiSymbols */ +const char *__PHYSFS_platformDirSeparator = "\\"; + + /* - * Figure out what the last failing Win32 API call was, and + * Figure out what the last failing Windows 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 const char *winApiStrError(void) { - static TCHAR msgbuf[255]; - TCHAR *ptr = msgbuf; - - /* !!! FIXME: unicode version. */ - FormatMessage( - FORMAT_MESSAGE_FROM_SYSTEM | - FORMAT_MESSAGE_IGNORE_INSERTS, - NULL, - GetLastError(), - MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), /* Default language */ - msgbuf, - sizeof (msgbuf) / sizeof (TCHAR), - NULL - ); + static char utf8buf[255]; + WCHAR msgbuf[255]; + WCHAR *ptr; + DWORD rc = pFormatMessageW( + FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, GetLastError(), + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), + msgbuf, __PHYSFS_ARRAYLEN(msgbuf), + NULL); /* chop off newlines. */ for (ptr = msgbuf; *ptr; ptr++) { if ((*ptr == '\n') || (*ptr == '\r')) { - *ptr = ' '; + *ptr = '\0'; break; } /* if */ } /* for */ - /* !!! FIXME: convert to UTF-8. */ - - return((const char *) msgbuf); -} /* win32strerror */ + /* may truncate, but oh well. */ + PHYSFS_utf8FromUcs2((PHYSFS_uint16 *) msgbuf, utf8buf, sizeof (utf8buf)); + return((const char *) utf8buf); +} /* winApiStrError */ static char *getExePath(void) @@ -195,7 +367,7 @@ static char *getExePath(void) if (rc == 0) { allocator.Free(modpath); - BAIL_MACRO(win32strerror(), NULL); + BAIL_MACRO(winApiStrError(), NULL); } /* if */ if (rc < buflen) @@ -222,23 +394,11 @@ static char *getExePath(void) else { *(ptr + 1) = '\0'; /* chop off filename. */ - retval = (char *) allocator.Malloc(buflen * 6); - if (retval == NULL) - __PHYSFS_setError(ERR_OUT_OF_MEMORY); - else - PHYSFS_utf8FromUcs2((const PHYSFS_uint16 *) modpath, retval, buflen * 6); + retval = unicodeToUtf8Heap(modpath); } /* else */ } /* else */ allocator.Free(modpath); - /* free up the bytes we didn't actually use. */ - if (retval != NULL) - { - void *ptr = allocator.Realloc(retval, strlen(retval) + 1); - if (ptr != NULL) - retval = (char *) ptr; - } /* if */ - return(retval); /* w00t. */ } /* getExePath */ @@ -289,13 +449,7 @@ static int determineUserDir(void) if (wstr != NULL) { if (pGetUserProfileDirectoryW(accessToken, wstr, &psize)) - { - const PHYSFS_uint64 buflen = psize * 6; - userDir = (char *) allocator.Malloc(buflen); - if (userDir != NULL) - PHYSFS_utf8FromUcs2((const PHYSFS_uint16 *) wstr, userDir, buflen); - /* !!! FIXME: shrink allocation... */ - } /* if */ + userDir = unicodeToUtf8Heap(wstr); __PHYSFS_smallFree(wstr); } /* else */ } /* if */ @@ -324,7 +478,7 @@ static BOOL mediaInDrive(const char *drive) oldErrorMode = SetErrorMode(SEM_FAILCRITICALERRORS); /* If this function succeeds, there's media in the drive */ - retval = GetVolumeInformation(drive, NULL, 0, NULL, NULL, &tmp, NULL, 0); + retval = GetVolumeInformationA(drive, NULL, 0, NULL, NULL, &tmp, NULL, 0); /* Revert back to old windows error handler */ SetErrorMode(oldErrorMode); @@ -360,28 +514,20 @@ char *__PHYSFS_platformCalcBaseDir(const char *argv0) char *__PHYSFS_platformGetUserName(void) { DWORD bufsize = 0; - LPTSTR retval = NULL; - - /* !!! FIXME: unicode version. */ - if (GetUserName(NULL, &bufsize) == 0) /* This SHOULD fail. */ - { - retval = (LPTSTR) allocator.Malloc(bufsize); - BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL); - /* !!! FIXME: unicode version. */ - if (GetUserName(retval, &bufsize) == 0) /* ?! */ - { - __PHYSFS_setError(win32strerror()); - allocator.Free(retval); - retval = NULL; - } /* if */ - } /* if */ - - if (retval != NULL) + char *retval = NULL; + + if (pGetUserNameW(NULL, &bufsize) == 0) /* This SHOULD fail. */ { - /* !!! FIXME: convert to UTF-8. */ + LPWSTR wbuf = (LPWSTR) __PHYSFS_smallAlloc(bufsize * sizeof (WCHAR)); + BAIL_IF_MACRO(wbuf == NULL, ERR_OUT_OF_MEMORY, NULL); + if (pGetUserNameW(wbuf, &bufsize) == 0) /* ?! */ + __PHYSFS_setError(winApiStrError()); + else + retval = unicodeToUtf8Heap(wbuf); + __PHYSFS_smallFree(wbuf); } /* if */ - return((char *) retval); + return(retval); } /* __PHYSFS_platformGetUserName */ @@ -400,15 +546,26 @@ PHYSFS_uint64 __PHYSFS_platformGetThreadID(void) } /* __PHYSFS_platformGetThreadID */ -int __PHYSFS_platformExists(const char *fname) +static int doPlatformExists(LPWSTR wpath) { BAIL_IF_MACRO ( - /* !!! FIXME: unicode version. */ - GetFileAttributes(fname) == PHYSFS_INVALID_FILE_ATTRIBUTES, - win32strerror(), 0 + pGetFileAttributesW(wpath) == PHYSFS_INVALID_FILE_ATTRIBUTES, + winApiStrError(), 0 ); return(1); +} /* doPlatformExists */ + + +int __PHYSFS_platformExists(const char *fname) +{ + int retval = 0; + LPWSTR wpath; + UTF8_TO_UNICODE_STACK_MACRO(wpath, fname); + BAIL_IF_MACRO(wpath == NULL, ERR_OUT_OF_MEMORY, 0); + retval = doPlatformExists(wpath); + __PHYSFS_smallFree(wpath); + return(retval); } /* __PHYSFS_platformExists */ @@ -421,8 +578,13 @@ int __PHYSFS_platformIsSymLink(const char *fname) int __PHYSFS_platformIsDirectory(const char *fname) { - /* !!! FIXME: unicode version. */ - return((GetFileAttributes(fname) & FILE_ATTRIBUTE_DIRECTORY) != 0); + int retval = 0; + LPWSTR wpath; + UTF8_TO_UNICODE_STACK_MACRO(wpath, fname); + BAIL_IF_MACRO(wpath == NULL, ERR_OUT_OF_MEMORY, 0); + retval = ((pGetFileAttributesW(wpath) & FILE_ATTRIBUTE_DIRECTORY) != 0); + __PHYSFS_smallFree(wpath); + return(retval); } /* __PHYSFS_platformIsDirectory */ @@ -461,49 +623,93 @@ void __PHYSFS_platformEnumerateFiles(const char *dirname, const char *origdir, void *callbackdata) { - HANDLE dir; + const int unicode = (pFindFirstFileW != NULL) && (pFindNextFileW != NULL); + HANDLE dir = INVALID_HANDLE_VALUE; WIN32_FIND_DATA ent; + WIN32_FIND_DATAW entw; size_t len = strlen(dirname); - char *SearchPath; + char *searchPath = NULL; + WCHAR *wSearchPath = NULL; + char *utf8 = NULL; /* Allocate a new string for path, maybe '\\', "*", and NULL terminator */ - SearchPath = (char *) __PHYSFS_smallAlloc(len + 3); - if (SearchPath == NULL) + searchPath = (char *) __PHYSFS_smallAlloc(len + 3); + if (searchPath == NULL) return; /* Copy current dirname */ - strcpy(SearchPath, dirname); + strcpy(searchPath, dirname); /* if there's no '\\' at the end of the path, stick one in there. */ - if (SearchPath[len - 1] != '\\') + if (searchPath[len - 1] != '\\') { - SearchPath[len++] = '\\'; - SearchPath[len] = '\0'; + searchPath[len++] = '\\'; + searchPath[len] = '\0'; } /* if */ /* Append the "*" to the end of the string */ - strcat(SearchPath, "*"); + strcat(searchPath, "*"); - /* !!! FIXME: unicode version. */ - dir = FindFirstFile(SearchPath, &ent); - __PHYSFS_smallFree(SearchPath); - if (dir == INVALID_HANDLE_VALUE) - return; + UTF8_TO_UNICODE_STACK_MACRO(wSearchPath, searchPath); + if (wSearchPath == NULL) + return; /* oh well. */ - do + if (unicode) + dir = pFindFirstFileW(wSearchPath, &entw); + else { - /* !!! FIXME: unicode version. */ - if (strcmp(ent.cFileName, ".") == 0) - continue; + const int len = (int) (wStrLen(wSearchPath) + 1); + char *cp = (char *) __PHYSFS_smallAlloc(len); + if (cp != NULL) + { + WideCharToMultiByte(CP_ACP, 0, wSearchPath, len, cp, len, 0, 0); + dir = FindFirstFileA(cp, &ent); + __PHYSFS_smallFree(cp); + } /* if */ + } /* else */ - /* !!! FIXME: unicode version. */ - if (strcmp(ent.cFileName, "..") == 0) - continue; + __PHYSFS_smallFree(wSearchPath); + __PHYSFS_smallFree(searchPath); + if (dir == INVALID_HANDLE_VALUE) + return; - callback(callbackdata, origdir, ent.cFileName); + if (unicode) + { + do + { + const WCHAR *fn = entw.cFileName; + if ((fn[0] == '.') && (fn[1] == '\0')) + continue; + if ((fn[0] == '.') && (fn[1] == '.') && (fn[2] == '\0')) + continue; + + utf8 = unicodeToUtf8Heap(entw.cFileName); + if (utf8 != NULL) + { + callback(callbackdata, origdir, utf8); + allocator.Free(utf8); + } /* if */ + } while (pFindNextFileW(dir, &entw) != 0); + } /* if */ - /* !!! FIXME: unicode version. */ - } while (FindNextFile(dir, &ent) != 0); + else /* ANSI fallback. */ + { + do + { + const char *fn = ent.cFileName; + if ((fn[0] == '.') && (fn[1] == '\0')) + continue; + if ((fn[0] == '.') && (fn[1] == '.') && (fn[2] == '\0')) + continue; + + utf8 = codepageToUtf8Heap(ent.cFileName); + if (utf8 != NULL) + { + callback(callbackdata, origdir, utf8); + allocator.Free(utf8); + } /* if */ + } while (FindNextFileA(dir, &ent) != 0); + } /* else */ FindClose(dir); } /* __PHYSFS_platformEnumerateFiles */ @@ -511,26 +717,33 @@ void __PHYSFS_platformEnumerateFiles(const char *dirname, char *__PHYSFS_platformCurrentDir(void) { - LPTSTR retval; + char *retval = NULL; + WCHAR *wbuf = NULL; DWORD buflen = 0; - /* !!! FIXME: unicode version. */ - buflen = GetCurrentDirectory(buflen, NULL); - retval = (LPTSTR) allocator.Malloc(sizeof (TCHAR) * (buflen + 2)); - BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL); - /* !!! FIXME: unicode version. */ - GetCurrentDirectory(buflen, retval); + buflen = pGetCurrentDirectoryW(buflen, NULL); + wbuf = (WCHAR *) __PHYSFS_smallAlloc((buflen + 2) * sizeof (WCHAR)); + BAIL_IF_MACRO(wbuf == NULL, ERR_OUT_OF_MEMORY, NULL); + pGetCurrentDirectoryW(buflen, wbuf); - if (retval[buflen - 2] != '\\') - strcat(retval, "\\"); + if (wbuf[buflen - 2] == '\\') + wbuf[buflen-1] = '\0'; /* just in case... */ + else + { + wbuf[buflen - 1] = '\\'; + wbuf[buflen] = '\0'; + } /* else */ - return((char *) retval); + retval = unicodeToUtf8Heap(wbuf); + __PHYSFS_smallFree(wbuf); + return(retval); } /* __PHYSFS_platformCurrentDir */ /* this could probably use a cleanup. */ char *__PHYSFS_platformRealPath(const char *path) { + /* !!! FIXME: try GetFullPathName() instead? */ /* this function should be UTF-8 clean. */ char *retval = NULL; char *p = NULL; @@ -652,38 +865,19 @@ char *__PHYSFS_platformRealPath(const char *path) int __PHYSFS_platformMkDir(const char *path) { - /* !!! FIXME: unicode version. */ - DWORD rc = CreateDirectory(path, NULL); - BAIL_IF_MACRO(rc == 0, win32strerror(), 0); + WCHAR *wpath; + DWORD rc; + UTF8_TO_UNICODE_STACK_MACRO(wpath, path); + rc = pCreateDirectoryW(wpath, NULL); + __PHYSFS_smallFree(wpath); + BAIL_IF_MACRO(rc == 0, winApiStrError(), 0); return(1); } /* __PHYSFS_platformMkDir */ -/* - * Get OS info and save the important parts. - * - * Returns non-zero if successful, otherwise it returns zero on failure. - */ -static int getOSInfo(void) -{ -#if 0 /* we don't actually use this at the moment, but may in the future. */ - OSVERSIONINFO OSVersionInfo; /* Information about the OS */ - OSVersionInfo.dwOSVersionInfoSize = sizeof(OSVersionInfo); - BAIL_IF_MACRO(!GetVersionEx(&OSVersionInfo), win32strerror(), 0); - - /* Set to TRUE if we are runnign a WinNT based OS 4.0 or greater */ - runningNT = ((OSVersionInfo.dwPlatformId == VER_PLATFORM_WIN32_NT) && - (OSVersionInfo.dwMajorVersion >= 4)); -#endif - - return(1); -} /* getOSInfo */ - - int __PHYSFS_platformInit(void) { BAIL_IF_MACRO(!findApiSymbols(), NULL, 0); - BAIL_IF_MACRO(!getOSInfo(), NULL, 0); BAIL_IF_MACRO(!determineUserDir(), NULL, 0); return(1); /* It's all good */ } /* __PHYSFS_platformInit */ @@ -712,19 +906,22 @@ int __PHYSFS_platformDeinit(void) static void *doOpen(const char *fname, DWORD mode, DWORD creation, int rdonly) { HANDLE fileHandle; - win32file *retval; + WinApiFile *retval; + WCHAR *wfname; - /* !!! FIXME: unicode version. */ - fileHandle = CreateFile(fname, mode, FILE_SHARE_READ, NULL, - creation, FILE_ATTRIBUTE_NORMAL, NULL); + UTF8_TO_UNICODE_STACK_MACRO(wfname, fname); + BAIL_IF_MACRO(wfname == NULL, ERR_OUT_OF_MEMORY, NULL); + fileHandle = pCreateFileW(wfname, mode, FILE_SHARE_READ, NULL, + creation, FILE_ATTRIBUTE_NORMAL, NULL); + __PHYSFS_smallFree(wfname); BAIL_IF_MACRO ( fileHandle == INVALID_HANDLE_VALUE, - win32strerror(), NULL + winApiStrError(), NULL ); - retval = (win32file *) allocator.Malloc(sizeof (win32file)); + retval = (WinApiFile *) allocator.Malloc(sizeof (WinApiFile)); if (retval == NULL) { CloseHandle(fileHandle); @@ -754,11 +951,11 @@ void *__PHYSFS_platformOpenAppend(const char *filename) void *retval = doOpen(filename, GENERIC_WRITE, OPEN_ALWAYS, 0); if (retval != NULL) { - HANDLE h = ((win32file *) retval)->handle; + HANDLE h = ((WinApiFile *) retval)->handle; DWORD rc = SetFilePointer(h, 0, NULL, FILE_END); if (rc == PHYSFS_INVALID_SET_FILE_POINTER) { - const char *err = win32strerror(); + const char *err = winApiStrError(); CloseHandle(h); allocator.Free(retval); BAIL_MACRO(err, NULL); @@ -772,7 +969,7 @@ void *__PHYSFS_platformOpenAppend(const char *filename) PHYSFS_sint64 __PHYSFS_platformRead(void *opaque, void *buffer, PHYSFS_uint32 size, PHYSFS_uint32 count) { - HANDLE Handle = ((win32file *) opaque)->handle; + HANDLE Handle = ((WinApiFile *) opaque)->handle; DWORD CountOfBytesRead; PHYSFS_sint64 retval; @@ -780,7 +977,7 @@ PHYSFS_sint64 __PHYSFS_platformRead(void *opaque, void *buffer, /* !!! FIXME: uint32 might be a greater # than DWORD */ if(!ReadFile(Handle, buffer, count * size, &CountOfBytesRead, NULL)) { - BAIL_MACRO(win32strerror(), -1); + BAIL_MACRO(winApiStrError(), -1); } /* if */ else { @@ -796,7 +993,7 @@ PHYSFS_sint64 __PHYSFS_platformRead(void *opaque, void *buffer, PHYSFS_sint64 __PHYSFS_platformWrite(void *opaque, const void *buffer, PHYSFS_uint32 size, PHYSFS_uint32 count) { - HANDLE Handle = ((win32file *) opaque)->handle; + HANDLE Handle = ((WinApiFile *) opaque)->handle; DWORD CountOfBytesWritten; PHYSFS_sint64 retval; @@ -804,7 +1001,7 @@ PHYSFS_sint64 __PHYSFS_platformWrite(void *opaque, const void *buffer, /* !!! FIXME: uint32 might be a greater # than DWORD */ if(!WriteFile(Handle, buffer, count * size, &CountOfBytesWritten, NULL)) { - BAIL_MACRO(win32strerror(), -1); + BAIL_MACRO(winApiStrError(), -1); } /* if */ else { @@ -819,7 +1016,7 @@ PHYSFS_sint64 __PHYSFS_platformWrite(void *opaque, const void *buffer, int __PHYSFS_platformSeek(void *opaque, PHYSFS_uint64 pos) { - HANDLE Handle = ((win32file *) opaque)->handle; + HANDLE Handle = ((WinApiFile *) opaque)->handle; DWORD HighOrderPos; DWORD *pHighOrderPos; DWORD rc; @@ -848,7 +1045,7 @@ int __PHYSFS_platformSeek(void *opaque, PHYSFS_uint64 pos) if ( (rc == PHYSFS_INVALID_SET_FILE_POINTER) && (GetLastError() != NO_ERROR) ) { - BAIL_MACRO(win32strerror(), 0); + BAIL_MACRO(winApiStrError(), 0); } /* if */ return(1); /* No error occured */ @@ -857,7 +1054,7 @@ int __PHYSFS_platformSeek(void *opaque, PHYSFS_uint64 pos) PHYSFS_sint64 __PHYSFS_platformTell(void *opaque) { - HANDLE Handle = ((win32file *) opaque)->handle; + HANDLE Handle = ((WinApiFile *) opaque)->handle; DWORD HighPos = 0; DWORD LowPos; PHYSFS_sint64 retval; @@ -867,7 +1064,7 @@ PHYSFS_sint64 __PHYSFS_platformTell(void *opaque) if ( (LowPos == PHYSFS_INVALID_SET_FILE_POINTER) && (GetLastError() != NO_ERROR) ) { - BAIL_MACRO(win32strerror(), 0); + BAIL_MACRO(winApiStrError(), 0); } /* if */ else { @@ -882,7 +1079,7 @@ PHYSFS_sint64 __PHYSFS_platformTell(void *opaque) PHYSFS_sint64 __PHYSFS_platformFileLength(void *opaque) { - HANDLE Handle = ((win32file *) opaque)->handle; + HANDLE Handle = ((WinApiFile *) opaque)->handle; DWORD SizeHigh; DWORD SizeLow; PHYSFS_sint64 retval; @@ -891,7 +1088,7 @@ PHYSFS_sint64 __PHYSFS_platformFileLength(void *opaque) if ( (SizeLow == PHYSFS_INVALID_SET_FILE_POINTER) && (GetLastError() != NO_ERROR) ) { - BAIL_MACRO(win32strerror(), -1); + BAIL_MACRO(winApiStrError(), -1); } /* if */ else { @@ -922,9 +1119,9 @@ int __PHYSFS_platformEOF(void *opaque) int __PHYSFS_platformFlush(void *opaque) { - win32file *fh = ((win32file *) opaque); + WinApiFile *fh = ((WinApiFile *) opaque); if (!fh->readonly) - BAIL_IF_MACRO(!FlushFileBuffers(fh->handle), win32strerror(), 0); + BAIL_IF_MACRO(!FlushFileBuffers(fh->handle), winApiStrError(), 0); return(1); } /* __PHYSFS_platformFlush */ @@ -932,28 +1129,38 @@ int __PHYSFS_platformFlush(void *opaque) int __PHYSFS_platformClose(void *opaque) { - HANDLE Handle = ((win32file *) opaque)->handle; - BAIL_IF_MACRO(!CloseHandle(Handle), win32strerror(), 0); + HANDLE Handle = ((WinApiFile *) opaque)->handle; + BAIL_IF_MACRO(!CloseHandle(Handle), winApiStrError(), 0); allocator.Free(opaque); return(1); } /* __PHYSFS_platformClose */ -int __PHYSFS_platformDelete(const char *path) +static int doPlatformDelete(LPWSTR wpath) { /* If filename is a folder */ - if (GetFileAttributes(path) == FILE_ATTRIBUTE_DIRECTORY) + if (pGetFileAttributesW(wpath) == FILE_ATTRIBUTE_DIRECTORY) { - /* !!! FIXME: unicode version. */ - BAIL_IF_MACRO(!RemoveDirectory(path), win32strerror(), 0); + BAIL_IF_MACRO(!pRemoveDirectoryW(wpath), winApiStrError(), 0); } /* if */ else { - /* !!! FIXME: unicode version. */ - BAIL_IF_MACRO(!DeleteFile(path), win32strerror(), 0); + BAIL_IF_MACRO(!pDeleteFileW(wpath), winApiStrError(), 0); } /* else */ - return(1); /* if you got here, it worked. */ + return(1); /* if you made it here, it worked. */ +} /* doPlatformDelete */ + + +int __PHYSFS_platformDelete(const char *path) +{ + int retval = 0; + LPWSTR wpath; + UTF8_TO_UNICODE_STACK_MACRO(wpath, path); + BAIL_IF_MACRO(wpath == NULL, ERR_OUT_OF_MEMORY, 0); + retval = doPlatformDelete(wpath); + __PHYSFS_smallFree(wpath); + return(retval); } /* __PHYSFS_platformDelete */ @@ -995,11 +1202,11 @@ static PHYSFS_sint64 FileTimeToPhysfsTime(const FILETIME *ft) PHYSFS_sint64 retval; struct tm tm; - BAIL_IF_MACRO(!FileTimeToSystemTime(ft, &st_utc), win32strerror(), -1); + BAIL_IF_MACRO(!FileTimeToSystemTime(ft, &st_utc), winApiStrError(), -1); tzid = GetTimeZoneInformation(&tzi); - BAIL_IF_MACRO(tzid == TIME_ZONE_ID_INVALID, win32strerror(), -1); + BAIL_IF_MACRO(tzid == TIME_ZONE_ID_INVALID, winApiStrError(), -1); - /* (This API is unsupported and fails on non-NT systems. */ + /* (This API is unsupported and fails on non-NT systems. */ if (!SystemTimeToTzSpecificLocalTime(&tzi, &st_utc, &st_localtz)) { /* do it by hand. Grumble... */ @@ -1014,28 +1221,7 @@ static PHYSFS_sint64 FileTimeToPhysfsTime(const FILETIME *ft) tzi.Bias += tzi.DaylightBias; /* convert from minutes to 100-nanosecond increments... */ - #if 0 /* For compilers that puke on 64-bit math. */ - /* goddamn this is inefficient... */ - while (tzi.Bias > 0) - { - DWORD tmp = ui64.LowPart - 60000000; - if ((ui64.LowPart < tmp) && (tmp > 60000000)) - ui64.HighPart--; - ui64.LowPart = tmp; - tzi.Bias--; - } /* while */ - - while (tzi.Bias < 0) - { - DWORD tmp = ui64.LowPart + 60000000; - if ((ui64.LowPart > tmp) && (tmp < 60000000)) - ui64.HighPart++; - ui64.LowPart = tmp; - tzi.Bias++; - } /* while */ - #else - ui64.QuadPart -= (((LONGLONG) tzi.Bias) * (600000000)); - #endif + ui64.QuadPart -= (((LONGLONG) tzi.Bias) * (600000000)); /* Move it back into a FILETIME structure... */ new_ft.dwLowDateTime = ui64.LowPart; @@ -1043,7 +1229,7 @@ static PHYSFS_sint64 FileTimeToPhysfsTime(const FILETIME *ft) /* Convert to something human-readable... */ if (!FileTimeToSystemTime(&new_ft, &st_localtz)) - BAIL_MACRO(win32strerror(), -1); + BAIL_MACRO(winApiStrError(), -1); } /* if */ /* Convert to a format that mktime() can grok... */ @@ -1067,21 +1253,42 @@ static PHYSFS_sint64 FileTimeToPhysfsTime(const FILETIME *ft) PHYSFS_sint64 __PHYSFS_platformGetLastModTime(const char *fname) { PHYSFS_sint64 retval = -1; - WIN32_FILE_ATTRIBUTE_DATA attrData; - memset(&attrData, '\0', sizeof (attrData)); + WIN32_FILE_ATTRIBUTE_DATA attr; + int rc = 0; + + memset(&attr, '\0', sizeof (attr)); /* GetFileAttributesEx didn't show up until Win98 and NT4. */ - if (pGetFileAttributesExA != NULL) + if ((pGetFileAttributesExW != NULL) || (pGetFileAttributesExA != NULL)) { - /* !!! FIXME: unicode version. */ - if (pGetFileAttributesExA(fname, GetFileExInfoStandard, &attrData)) + WCHAR *wstr; + UTF8_TO_UNICODE_STACK_MACRO(wstr, fname); + if (wstr != NULL) /* if NULL, maybe the fallback will work. */ { - /* 0 return value indicates an error or not supported */ - if ( (attrData.ftLastWriteTime.dwHighDateTime != 0) || - (attrData.ftLastWriteTime.dwLowDateTime != 0) ) + if (pGetFileAttributesExW != NULL) /* NT/XP/Vista/etc system. */ + rc = pGetFileAttributesExW(wstr, GetFileExInfoStandard, &attr); + else /* Win98/ME system */ { - retval = FileTimeToPhysfsTime(&attrData.ftLastWriteTime); - } /* if */ + const int len = (int) (wStrLen(wstr) + 1); + char *cp = (char *) __PHYSFS_smallAlloc(len); + if (cp != NULL) + { + WideCharToMultiByte(CP_ACP, 0, wstr, len, cp, len, 0, 0); + rc = pGetFileAttributesExA(cp, GetFileExInfoStandard, &attr); + __PHYSFS_smallFree(cp); + } /* if */ + } /* else */ + __PHYSFS_smallFree(wstr); + } /* if */ + } /* if */ + + if (rc) /* had API entry point and it worked. */ + { + /* 0 return value indicates an error or not supported */ + if ( (attr.ftLastWriteTime.dwHighDateTime != 0) || + (attr.ftLastWriteTime.dwLowDateTime != 0) ) + { + retval = FileTimeToPhysfsTime(&attr.ftLastWriteTime); } /* if */ } /* if */ @@ -1091,10 +1298,10 @@ PHYSFS_sint64 __PHYSFS_platformGetLastModTime(const char *fname) FILETIME ft; BOOL rc; const char *err; - win32file *f = (win32file *) __PHYSFS_platformOpenRead(fname); + WinApiFile *f = (WinApiFile *) __PHYSFS_platformOpenRead(fname); BAIL_IF_MACRO(f == NULL, NULL, -1) rc = GetFileTime(f->handle, NULL, NULL, &ft); - err = win32strerror(); + err = winApiStrError(); CloseHandle(f->handle); allocator.Free(f); BAIL_IF_MACRO(!rc, err, -1);