diff options
Diffstat (limited to 'private/oleutest/olebind/widewrap.cxx')
| -rw-r--r-- | private/oleutest/olebind/widewrap.cxx | 1840 |
1 files changed, 1840 insertions, 0 deletions
diff --git a/private/oleutest/olebind/widewrap.cxx b/private/oleutest/olebind/widewrap.cxx new file mode 100644 index 000000000..0787b9262 --- /dev/null +++ b/private/oleutest/olebind/widewrap.cxx @@ -0,0 +1,1840 @@ +//+--------------------------------------------------------------------------- +// +// Microsoft Windows +// Copyright (C) Microsoft Corporation, 1993 - 1993. +// +// File: widewrap.cxx +// +// Contents: Unicode wrapper API, used only on Chicago +// +// Functions: About fifty Win32 function wrappers +// +// Notes: 'sz' is used instead of the "correct" hungarian 'psz' +// throughout to enhance readability. +// +// Not all of every Win32 function is wrapped here. Some +// obscurely-documented features may not be handled correctly +// in these wrappers. Caller beware. +// +// These are privately exported for use by the Shell. +// +// History: 28-Dec-93 ErikGav Created +// 06-14-94 KentCe Various Chicago build fixes. +// 21-Dec-94 BruceMa Use olewcstombs + other fixes +// 21-Feb-95 BruceMa Add support for AreFileApisANSI +// +//---------------------------------------------------------------------------- + +#include <windows.h> +#include "widewrap.h" + +size_t olembstowcs(WCHAR *pwsz, const char *psz, size_t cCh); +size_t olewcstombs(char *psz, const WCHAR *pwsz , size_t cCh); + +inline size_t olembstowcs(WCHAR *pwsz, const char *psz, size_t cCh) +{ + return MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, psz, -1, pwsz, cCh); +} + +inline size_t olewcstombs(char *psz, const WCHAR *pwsz , size_t cCh) +{ + return WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK, pwsz, -1, psz, + cCh, NULL, NULL); +} + +#ifdef _CHICAGO_ + +#define HFINDFILE HANDLE +#define ERR ((char*) -1) + + +// +// BUGBUG: 9869 +// +// The length of a Unicode string (in chars) and a DBCS string are not +// always equal. We need to review all WideChar to MultiByte conversions +// logic to verify that the proper result buffer size is used. +// +// Make the below Win95 only change to get the Win95 FE build out. +// + +int UnicodeToAnsi(LPSTR sz, LPCWSTR pwsz, LONG cb) +{ + int ret; + + ret = WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK, pwsz, -1, sz, cb, NULL, NULL); + +#if DBG==1 + if (ret == -1) + { + DebugBreak(); + } +#endif + + return ret; +} + + +int UnicodeToAnsiOem(LPSTR sz, LPCWSTR pwsz, LONG cb) +{ + int ret; + + if (AreFileApisANSI()) + { + ret = WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK, pwsz, -1, sz, + cb, NULL, NULL); + } + else + { + ret = WideCharToMultiByte(CP_OEMCP, WC_COMPOSITECHECK, pwsz, -1, sz, + cb, NULL, NULL); + } + +#if DBG==1 + if (ret == -1) + { + DebugBreak(); + } +#endif + + return ret; +} + + + +#if DBG==1 +int AnsiToUnicode(LPWSTR pwsz, LPCSTR sz, LONG cb) +{ + int ret; + + ret = olembstowcs(pwsz, sz, cb); + + if (ret == -1) + { + DebugBreak(); + } + + return ret; +} +#else +#define AnsiToUnicode olembstowcs +#endif + + + +int AnsiToUnicodeOem(LPWSTR pwsz, LPCSTR sz, LONG cb) +{ + int ret; + + if (AreFileApisANSI()) + { + ret = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, sz, cb, pwsz, cb); + } + else + { + ret = MultiByteToWideChar(CP_OEMCP, MB_PRECOMPOSED, sz, cb, pwsz, cb); + } + +#if DBG==1 + if (ret == -1) + { + DebugBreak(); + } +#endif + + return ret; +} + + + + +LPSTR Convert(LPCWSTR pwsz) +{ + LONG len; + LPSTR sz = NULL; + + if (pwsz == NULL) + goto Exit; + +#if DBG==1 + // some Win32 API accept atoms in their string parameters +#endif + + len = (wcslen(pwsz) + 1) * 2; + + sz = new CHAR[len]; + if (sz==NULL) + { + sz = ERR; + goto Exit; + } + + __try + { + UnicodeToAnsi(sz, pwsz, len); + } + __except(EXCEPTION_EXECUTE_HANDLER) + { +#if DBG==1 + MessageBoxA(NULL, "GP fault in unicode conversion -- caught", + NULL, MB_OK); +#endif + if (sz) + delete sz; + sz = ERR; + } + +Exit: + return sz; +} + + + + + + + + + +LPSTR ConvertOem(LPCWSTR pwsz) +{ + LONG len; + LPSTR sz = NULL; + + if (pwsz == NULL) + goto Exit; + +#if DBG==1 + // some Win32 API accept atoms in their string parameters +#endif + + len = (wcslen(pwsz) + 1) * 2; + + sz = new CHAR[len]; + if (sz==NULL) + { + sz = ERR; + goto Exit; + } + + __try + { + UnicodeToAnsiOem(sz, pwsz, len); + } + __except(EXCEPTION_EXECUTE_HANDLER) + { +#if DBG==1 + MessageBoxA(NULL, "GP fault in unicode conversion -- caught", + NULL, MB_OK); +#endif + if (sz) + delete sz; + sz = ERR; + } + +Exit: + return sz; +} + + + + + +HANDLE WINAPI CreateFileX(LPCWSTR pwsz, DWORD fdwAccess, DWORD fdwShareMask, + LPSECURITY_ATTRIBUTES lpsa, DWORD fdwCreate, DWORD fdwAttrsAndFlags, + HANDLE hTemplateFile) +{ + #ifdef DEBUG_OUTPUT + OutputDebugString("CreateFile\n"); + #endif + + CHAR sz[MAX_PATH * 2]; + UnicodeToAnsiOem(sz, pwsz, sizeof(sz)); + + return CreateFileA(sz, fdwAccess, fdwShareMask, lpsa, fdwCreate, + fdwAttrsAndFlags, hTemplateFile); +} + +BOOL WINAPI DeleteFileX(LPCWSTR pwsz) +{ + #ifdef DEBUG_OUTPUT + OutputDebugString("DeleteFile\n"); + #endif + + CHAR sz[MAX_PATH * 2]; + UnicodeToAnsi(sz, pwsz, sizeof(sz)); + + return DeleteFileA(sz); +} + + +LONG APIENTRY RegOpenKeyX(HKEY hKey, LPCWSTR pwszSubKey, PHKEY phkResult) +{ + #ifdef DEBUG_OUTPUT + OutputDebugString("RegOpenKey\n"); + #endif + + LONG ret; + LPSTR sz; + + sz = Convert(pwszSubKey); + + if (sz == ERR) + { + return ERROR_OUTOFMEMORY; + } + + ret = RegOpenKeyA(hKey, sz, phkResult); + if (sz) + delete sz; + return ret; +} + +LONG APIENTRY RegQueryValueX(HKEY hKey, LPCWSTR pwszSubKey, LPWSTR pwszValue, + PLONG lpcbValue) +{ + #ifdef DEBUG_OUTPUT + OutputDebugString("RegQueryValue\n"); + #endif + + LONG cb, ret; + LPSTR szValue = NULL; + LPSTR sz; + + sz = Convert(pwszSubKey); + if (sz == ERR) + { + return ERROR_OUTOFMEMORY; + } + + ret = RegQueryValueA(hKey, sz, NULL, &cb); + + // If the caller was just asking for the size of the value, jump out + // now, without actually retrieving and converting the value. + + if (pwszValue == NULL) + { + // Adjust size of buffer to report, to account for CHAR -> WCHAR + *lpcbValue = cb * sizeof(WCHAR); + goto Exit; + } + + + if (ret == ERROR_SUCCESS) + { + // If the caller was asking for the value, but allocated too small + // of a buffer, set the buffer size and jump out. + + if (*lpcbValue < (LONG) (cb * sizeof(WCHAR))) + { + // Adjust size of buffer to report, to account for CHAR -> WCHAR + *lpcbValue = cb * sizeof(WCHAR); + ret = ERROR_MORE_DATA; + goto Exit; + } + + // Otherwise, retrieve and convert the value. + + szValue = new CHAR[cb]; + if (szValue == NULL) + { + ret = ERROR_OUTOFMEMORY; + goto Exit; + } + + ret = RegQueryValueA(hKey, sz, szValue, &cb); + + if (ret == ERROR_SUCCESS) + { + AnsiToUnicode(pwszValue, szValue, cb); + + // Adjust size of buffer to report, to account for CHAR -> WCHAR + *lpcbValue = cb * sizeof(WCHAR); + } + } + +Exit: + if (szValue) + delete szValue; + if (sz) + delete sz; + + return ret; +} + +LONG APIENTRY RegSetValueX(HKEY hKey, LPCWSTR lpSubKey, DWORD dwType, + LPCWSTR lpData, DWORD cbData) +{ + #ifdef DEBUG_OUTPUT + OutputDebugString("RegSetValue\n"); + #endif + + LPSTR szKey = NULL; + LPSTR szValue = NULL; + LONG ret = ERROR_OUTOFMEMORY; + + szKey = Convert(lpSubKey); + if (szKey == ERR) + { + szKey = NULL; + goto Exit; + } + + szValue = Convert(lpData); + if (szValue == ERR) + { + szValue = NULL; + goto Exit; + } + + ret = RegSetValueA(hKey, szKey, dwType, szValue, cbData); + +Exit: + if (szKey) + delete szKey; + if (szValue) + delete szValue; + return ret; +} + +LONG APIENTRY RegSetValueExX(HKEY hKey, + LPCWSTR lpSubKey, + DWORD dwReserved, + DWORD dwType, + LPBYTE lpData, + DWORD cbData) +{ + #ifdef DEBUG_OUTPUT + OutputDebugString("RegSetValueEx\n"); + #endif + + LPSTR szKey = NULL; + LPBYTE szValue = lpData; + LONG ret = ERROR_OUTOFMEMORY; + + szKey = Convert(lpSubKey); + if (szKey == ERR) + { + szKey = NULL; + goto Exit; + } + + if (dwType == REG_SZ) + { + szValue = (LPBYTE) Convert((LPWSTR)lpData); + } + if (szValue == (LPBYTE) ERR) + { + szValue = NULL; + goto Exit; + } + + ret = RegSetValueExA(hKey, szKey, dwReserved, dwType, szValue, cbData); + +Exit: + if (szKey) + delete szKey; + if ((szValue != lpData) && (szValue != (LPBYTE)ERR)) + delete szValue; + return ret; +} + +UINT WINAPI RegisterWindowMessageX(LPCWSTR lpString) +{ + #ifdef DEBUG_OUTPUT + OutputDebugString("RegisterWindowMessage\n"); + #endif + + UINT ret; +#if 0 + LPSTR sz; + + sz = Convert(lpString); + if (sz == ERR) + { + return 0; + } +#else + // BUGBUG: CairOLE calls this from libmain -- have to use static buffer + + CHAR sz[200]; + UnicodeToAnsi(sz, lpString, sizeof(sz)); +#endif + + ret = RegisterWindowMessageA(sz); +#if 0 + delete sz; +#endif + return ret; +} + +LONG +APIENTRY +RegOpenKeyExX ( + HKEY hKey, + LPCWSTR lpSubKey, + DWORD ulOptions, + REGSAM samDesired, + PHKEY phkResult + ) +{ + #ifdef DEBUG_OUTPUT + OutputDebugString("RegOpenKeyEx\n"); + #endif + + LONG ret; + LPSTR sz; + + sz = Convert(lpSubKey); + if (sz == ERR) + { + return ERROR_OUTOFMEMORY; + } + + ret = RegOpenKeyExA(hKey, sz, ulOptions, samDesired, phkResult); + if (sz) + delete sz; + return ret; +} + +LONG +APIENTRY +RegQueryValueExX( + HKEY hKey, + LPWSTR lpValueName, + LPDWORD lpReserved, + LPDWORD lpType, + LPBYTE lpData, + LPDWORD lpcbData + ) +{ + #ifdef DEBUG_OUTPUT + OutputDebugString("RegQueryValueEx\n"); + #endif + + LPBYTE lpTempBuffer; + DWORD dwTempType; + DWORD cb, cbRequired; + LONG ret; + LPSTR sz; + LPWSTR pwszTempWide; + LPSTR pszTempNarrow; + ULONG ulStringLength; + + sz = Convert(lpValueName); + if (sz == ERR) + { + return ERROR_OUTOFMEMORY; + } + + ret = RegQueryValueExA(hKey, sz, lpReserved, &dwTempType, NULL, &cb); + + // If the caller was just asking for the size of the value, jump out + // now, without actually retrieving and converting the value. + + if (lpData == NULL) + { + switch (dwTempType) + { + case REG_EXPAND_SZ: + case REG_MULTI_SZ: + case REG_SZ: + + // Adjust size of buffer to report, to account for CHAR -> WCHAR + + if (lpcbData != NULL) + *lpcbData = cb * sizeof(WCHAR); + break; + + default: + + if (lpcbData != NULL) + *lpcbData = cb; + break; + } + + // Set the type, if required. + if (lpType != NULL) + { + *lpType = dwTempType; + } + + goto Exit; + } + + + if (ret == ERROR_SUCCESS) + { + // + // Determine the size of buffer needed + // + + switch (dwTempType) + { + case REG_EXPAND_SZ: + case REG_MULTI_SZ: + case REG_SZ: + + cbRequired = cb * sizeof(WCHAR); + break; + + default: + + cbRequired = cb; + break; + } + + // If the caller was asking for the value, but allocated too small + // of a buffer, set the buffer size and jump out. + + if (lpcbData != NULL && *lpcbData < cbRequired) + { + // Adjust size of buffer to report, to account for CHAR -> WCHAR + *lpcbData = cbRequired; + + // Set the type, if required. + if (lpType != NULL) + { + *lpType = dwTempType; + } + + ret = ERROR_MORE_DATA; + goto Exit; + } + + // Otherwise, retrieve and convert the value. + + switch (dwTempType) + { + case REG_EXPAND_SZ: + case REG_MULTI_SZ: + case REG_SZ: + + lpTempBuffer = new BYTE[cbRequired]; + if (lpTempBuffer == NULL) + { + return ERROR_OUTOFMEMORY; + } + + ret = RegQueryValueExA(hKey, + sz, + lpReserved, + &dwTempType, + lpTempBuffer, + &cb); + + if (ret == ERROR_SUCCESS) + { + switch (dwTempType) + { + case REG_EXPAND_SZ: + case REG_SZ: + + AnsiToUnicode((LPWSTR) lpData, (LPSTR) lpTempBuffer, cb); + + // Adjust size of buffer to report, to account for CHAR -> WCHAR + *lpcbData = cbRequired; + + // Set the type, if required. + if (lpType != NULL) + { + *lpType = dwTempType; + } + break; + + case REG_MULTI_SZ: + + pszTempNarrow = (LPSTR) lpTempBuffer; + pwszTempWide = (LPWSTR) lpData; + + while (pszTempNarrow != NULL) + { + ulStringLength = strlen(pszTempNarrow) + 1; + AnsiToUnicode(pwszTempWide, + pszTempNarrow, + ulStringLength); + + // Compiler will scale appropriately here + pszTempNarrow += ulStringLength; + pwszTempWide += ulStringLength; + } + break; + } + } + + if (lpTempBuffer) + delete lpTempBuffer; + + break; + + default: + + // + // No conversion of out parameters needed. Just call narrow + // version with args passed in, and return directly. + // + + ret = RegQueryValueExA(hKey, + sz, + lpReserved, + lpType, + lpData, + lpcbData); + + } + } + +Exit: + if (sz) + delete sz; + return ret; +} + + + +ATOM +WINAPI +RegisterClassX( + CONST WNDCLASSW *lpWndClass) +{ + #ifdef DEBUG_OUTPUT + OutputDebugString("RegisterClass\n"); + #endif + + WNDCLASSA wc; + ATOM ret; + BOOL fAtom = FALSE; + + + memcpy(&wc, lpWndClass, sizeof(WNDCLASS)); + + wc.lpszMenuName = Convert(lpWndClass->lpszMenuName); + if (wc.lpszMenuName==ERR) + { + return NULL; + } + + if (HIWORD(lpWndClass->lpszClassName) == 0) + { + wc.lpszClassName = (LPSTR) lpWndClass->lpszClassName; + fAtom = TRUE; + } + else + { + wc.lpszClassName = Convert(lpWndClass->lpszClassName); + if (wc.lpszClassName==ERR) + { + if ((LPSTR) wc.lpszMenuName) + delete (LPSTR) wc.lpszMenuName; + return NULL; + } + } + + ret = RegisterClassA(&wc); + if ((LPSTR) wc.lpszMenuName) + delete (LPSTR) wc.lpszMenuName; + if (!fAtom) delete (LPSTR) wc.lpszClassName; + return ret; +} + +BOOL +WINAPI +UnregisterClassX( + LPCWSTR lpClassName, + HINSTANCE hInstance) +{ + #ifdef DEBUG_OUTPUT + OutputDebugString("UnregisterClass\n"); + #endif + + LPSTR sz; + BOOL ret; + BOOL fAtom = FALSE; + + if (HIWORD(lpClassName) == 0) + { + sz = (LPSTR) lpClassName; + fAtom = TRUE; + } + else + { + sz = Convert(lpClassName); + if (sz == ERR) + return FALSE; + } + + ret = UnregisterClassA(sz, hInstance); + if (!fAtom) delete sz; + return ret; +} + +HANDLE +WINAPI +GetPropX( + HWND hWnd, + LPCWSTR lpString) +{ + #ifdef DEBUG_OUTPUT + OutputDebugString("GetProp\n"); + #endif + + HANDLE ret; + LPSTR sz; + BOOL fAtom = FALSE; + + if (HIWORD(lpString)==0) + { + fAtom = TRUE; + sz = (LPSTR) lpString; + } + else + { + sz = Convert(lpString); + if (sz == ERR) + return NULL; + } + + ret = GetPropA(hWnd, sz); + if (!fAtom) delete sz; + return ret; +} + + +BOOL +WINAPI +SetPropX( + HWND hWnd, + LPCWSTR lpString, + HANDLE hData) +{ + #ifdef DEBUG_OUTPUT + OutputDebugString("SetProp\n"); + #endif + + BOOL ret; + LPSTR sz; + BOOL fAtom = FALSE; + + if (HIWORD(lpString)==0) + { + sz = (LPSTR) lpString; + fAtom = TRUE; + } + else + { + sz = Convert(lpString); + if (sz == ERR) + return NULL; + } + + ret = SetPropA(hWnd, sz, hData); + if (!fAtom) delete sz; + return ret; +} + + +HANDLE +WINAPI +RemovePropX( + HWND hWnd, + LPCWSTR lpString) +{ + #ifdef DEBUG_OUTPUT + OutputDebugString("RemoveProp\n"); + #endif + + HANDLE ret; + LPSTR sz; + BOOL fAtom = FALSE; + + if (HIWORD(lpString)==0) + { + sz = (LPSTR) lpString; + fAtom = TRUE; + } + else + { + sz = Convert(lpString); + if (sz == ERR) + return NULL; + } + + ret = RemovePropA(hWnd, sz); + if (!fAtom) delete sz; + return ret; +} + + +UINT +WINAPI +GetProfileIntX( + LPCWSTR lpAppName, + LPCWSTR lpKeyName, + INT nDefault + ) +{ + #ifdef DEBUG_OUTPUT + OutputDebugString("GetProfileInt\n"); + #endif + + LPSTR szApp; + LPSTR szKey; + UINT ret; + + szApp = Convert(lpAppName); + if (szApp==ERR) + { + return nDefault; + } + + szKey = Convert(lpKeyName); + if (szApp==ERR) + { + if (szApp) + delete szApp; + return nDefault; + } + + ret = GetProfileIntA(szApp, szKey, nDefault); + if (szApp) + delete szApp; + if (szKey) + delete szKey; + return ret; +} + +ATOM +WINAPI +GlobalAddAtomX( + LPCWSTR lpString + ) +{ + #ifdef DEBUG_OUTPUT + OutputDebugString("GlobalAddAtom\n"); + #endif + + ATOM ret; + LPSTR sz; + + sz = Convert(lpString); + if (sz==ERR) + { + return NULL; + } + + ret = GlobalAddAtomA(sz); + if (sz) + delete sz; + return ret; +} + +UINT +WINAPI +GlobalGetAtomNameX( + ATOM nAtom, + LPWSTR pwszBuffer, + int nSize + ) +{ + #ifdef DEBUG_OUTPUT + OutputDebugString("GlobalGetAtomName\n"); + #endif + + LPSTR sz; + UINT ret; + + sz = new CHAR[nSize]; + if (sz == NULL) + { + return 0; + } + + ret = GlobalGetAtomNameA(nAtom, sz, nSize); + if (ret) + { + AnsiToUnicode(pwszBuffer, sz, lstrlenA(sz) + 1); + } + if (sz) + delete sz; + return ret; +} + + +DWORD +WINAPI +GetModuleFileNameX( + HINSTANCE hModule, + LPWSTR pwszFilename, + DWORD nSize + ) +{ + #ifdef DEBUG_OUTPUT + OutputDebugString("GetModuleFileName\n"); + #endif + + LPSTR sz; + DWORD ret; + + sz = new CHAR[nSize]; + if (sz == NULL) + { + return 0; + } + + ret = GetModuleFileNameA(hModule, sz, nSize); + if (ret) + { + AnsiToUnicode(pwszFilename, sz, lstrlenA(sz) + 1); + } + + if (sz) + delete sz; + return ret; +} + + +LPWSTR +WINAPI +CharPrevX( + LPCWSTR lpszStart, + LPCWSTR lpszCurrent) +{ + #ifdef DEBUG_OUTPUT + OutputDebugString("CharPrev\n"); + #endif + + if (lpszCurrent == lpszStart) + { + return (LPWSTR) lpszStart; + } + else + { + return (LPWSTR) lpszCurrent - 1; + } +} + +HFONT WINAPI CreateFontX(int a, int b, int c, int d, int e, DWORD f, + DWORD g, DWORD h, DWORD i, DWORD j, DWORD k, + DWORD l, DWORD m, LPCWSTR pwsz) +{ + #ifdef DEBUG_OUTPUT + OutputDebugString("CreateFont\n"); + #endif + + LPSTR sz; + HFONT ret; + + sz = Convert(pwsz); + if (sz == ERR) + { + return NULL; + } + + ret = CreateFontA(a,b,c,d,e,f,g,h,i,j,k,l,m,sz); + if (sz) + delete sz; + return ret; +} + + +HINSTANCE +WINAPI +LoadLibraryX( + LPCWSTR pwszFileName + ) +{ + #ifdef DEBUG_OUTPUT + OutputDebugString("LoadLibrary\n"); + #endif + + HINSTANCE ret; + LPSTR sz; + + sz = Convert(pwszFileName); + if (sz == ERR) + { + return NULL; + } + + ret = LoadLibraryA(sz); + if (sz) + delete sz; + return ret; +} + + +HMODULE +WINAPI +LoadLibraryExX( + LPCWSTR lpLibFileName, + HANDLE hFile, + DWORD dwFlags + ) +{ + #ifdef DEBUG_OUTPUT + OutputDebugString("LoadLibrary\n"); + #endif + + HINSTANCE ret; + LPSTR sz; + + sz = ConvertOem(lpLibFileName); + if (sz == ERR) + { + return NULL; + } + + ret = LoadLibraryExA(sz, hFile, dwFlags); + if (sz) + delete sz; + return ret; +} + + + +LONG +APIENTRY +RegDeleteKeyX( + HKEY hKey, + LPCWSTR pwszSubKey + ) +{ + #ifdef DEBUG_OUTPUT + OutputDebugString("RegDeleteKey\n"); + #endif + + LONG ret; + LPSTR sz; + + sz = Convert(pwszSubKey); + if (sz == ERR) + { + return ERROR_OUTOFMEMORY; + } + + ret = RegDeleteKeyA(hKey, sz); + if (sz) + delete sz; + return ret; +} + +BOOL +APIENTRY +CreateProcessX( + LPCWSTR lpApplicationName, + LPWSTR lpCommandLine, + LPSECURITY_ATTRIBUTES lpProcessAttributes, + LPSECURITY_ATTRIBUTES lpThreadAttributes, + BOOL bInheritHandles, + DWORD dwCreationFlags, + LPVOID lpEnvironment, + LPCWSTR lpCurrentDirectory, + LPSTARTUPINFOW lpStartupInfo, + LPPROCESS_INFORMATION lpProcessInformation + ) +{ + #ifdef DEBUG_OUTPUT + OutputDebugString("CreateProcess\n"); + #endif + + STARTUPINFOA si; + BOOL ret = FALSE; + LPSTR szApp = NULL; + LPSTR szCommand = NULL; + LPSTR szDir = NULL; + + memcpy(&si, lpStartupInfo, sizeof(STARTUPINFO)); + + si.lpTitle = NULL; + + si.lpDesktop = Convert(lpStartupInfo->lpDesktop); + if (si.lpDesktop == ERR) + { + si.lpDesktop = NULL; + goto Error; + } + si.lpTitle = Convert(lpStartupInfo->lpTitle); + if (si.lpTitle == ERR) + { + si.lpTitle = NULL; + goto Error; + } + + szApp = Convert(lpApplicationName); + if (szApp == ERR) + { + szApp = NULL; + goto Error; + } + szCommand = ConvertOem(lpCommandLine); + if (szCommand == ERR) + { + szCommand = NULL; + goto Error; + } + szDir = Convert(lpCurrentDirectory); + if (szDir == ERR) + { + szDir = NULL; + goto Error; + } + + ret = CreateProcessA(szApp, szCommand, lpProcessAttributes, + lpThreadAttributes, bInheritHandles, dwCreationFlags, + lpEnvironment, szDir, &si, lpProcessInformation); + +Error: + if (si.lpDesktop) + delete si.lpDesktop; + if (si.lpTitle) + delete si.lpTitle; + + if (szApp) + delete szApp; + if (szCommand) + delete szCommand; + if (szDir) + delete szDir; + + return ret; +} + +LONG +APIENTRY +RegEnumKeyExX( + HKEY hKey, + DWORD dwIndex, + LPWSTR lpName, + LPDWORD lpcbName, + LPDWORD lpReserved, + LPWSTR lpClass, + LPDWORD lpcbClass, + PFILETIME lpftLastWriteTime + ) +{ + #ifdef DEBUG_OUTPUT + OutputDebugString("RegEnumKeyEx\n"); + #endif + + LPSTR szName; + LPSTR szClass = NULL; + LONG ret = ERROR_OUTOFMEMORY; + + szName = new CHAR[*lpcbName]; + if (szName == NULL) + goto Exit; + + if (lpClass != NULL) + { + szClass = new CHAR[*lpcbClass + 1]; + if (szName == NULL) + goto Exit; + } + + // + // Return lengths do not include zero char. + // + ret = RegEnumKeyExA(hKey, dwIndex, szName, lpcbName, lpReserved, + szClass, lpcbClass, lpftLastWriteTime); + + if (ret == ERROR_SUCCESS) + { + AnsiToUnicode(lpName, szName, *lpcbName + 1); + + if (szClass) + { + AnsiToUnicode(lpClass, szClass, *lpcbClass + 1); + } + } + +Exit: + return ret; +} + +BOOL +WINAPI +AppendMenuX( + HMENU hMenu, + UINT uFlags, + UINT uIDnewItem, + LPCWSTR lpnewItem + ) +{ + #ifdef DEBUG_OUTPUT + OutputDebugString("AppendMenu\n"); + #endif + + BOOL ret; + LPSTR sz; + + if (uFlags == MF_STRING) + { + sz = Convert(lpnewItem); + if (sz==ERR) + { + return FALSE; + } + } + else + { + sz = (LPSTR) lpnewItem; + } + + ret = AppendMenuA(hMenu, uFlags, uIDnewItem, sz); + + if (uFlags == MF_STRING) + { + if (sz) + delete sz; + } + + return ret; +} + +HANDLE +WINAPI +OpenEventX( + DWORD dwDesiredAccess, + BOOL bInheritHandle, + LPCWSTR lpName + ) +{ + #ifdef DEBUG_OUTPUT + OutputDebugString("OpenEvent\n"); + #endif + + LPSTR sz; + HANDLE ret; + + sz = Convert(lpName); + if (sz == ERR) + { + return NULL; + } + + ret = OpenEventA(dwDesiredAccess, bInheritHandle, sz); + if (sz) + delete sz; + return ret; +} + +HANDLE +WINAPI +CreateEventX( + LPSECURITY_ATTRIBUTES lpEventAttributes, + BOOL bManualReset, + BOOL bInitialState, + LPCWSTR lpName + ) +{ + #ifdef DEBUG_OUTPUT + OutputDebugString("CreateEvent\n"); + #endif + + LPSTR sz; + HANDLE ret; + + sz = Convert(lpName); + if (sz == ERR) + { + return NULL; + } + + ret = CreateEventA(lpEventAttributes, bManualReset, bInitialState, sz); + if (sz) + delete sz; + return ret; +} + +UINT +WINAPI +GetDriveTypeX( + LPCWSTR lpRootPathName + ) +{ + #ifdef DEBUG_OUTPUT + OutputDebugString("GetDriveType\n"); + #endif + + LPSTR sz; + UINT ret; + + sz = Convert(lpRootPathName); + if (sz == ERR) + { + return 0; + } + + ret = GetDriveTypeA(sz); + if (sz) + delete sz; + return ret; +} + +DWORD +WINAPI +GetFileAttributesX( + LPCWSTR lpFileName + ) +{ + #ifdef DEBUG_OUTPUT + OutputDebugString("GetFileAttributes\n"); + #endif + + LPSTR sz; + DWORD ret; + + sz = ConvertOem(lpFileName); + if (sz == ERR) + return 0xFFFFFFFF; + + ret = GetFileAttributesA(sz); + if (sz) + delete sz; + return ret; +} + +LONG +APIENTRY +RegEnumKeyX( + HKEY hKey, + DWORD dwIndex, + LPWSTR lpName, + DWORD cbName + ) +{ + #ifdef DEBUG_OUTPUT + OutputDebugString("RegEnumKey\n"); + #endif + + CHAR sz[MAX_PATH+1]; + LONG ret; + + // + // Return lengths do not include zero char. + // + ret = RegEnumKeyA(hKey, dwIndex, sz, cbName); + if (ret == ERROR_SUCCESS) + { + AnsiToUnicode(lpName, sz, lstrlenA(sz) + 1); + } + return ret; +} + +HFINDFILE +WINAPI +FindFirstFileX( + LPCWSTR lpFileName, + LPWIN32_FIND_DATAW pwszFd + ) +{ + #ifdef DEBUG_OUTPUT + OutputDebugString("FindFirstFile\n"); + #endif + + WIN32_FIND_DATAA fd; + CHAR sz[MAX_PATH * 2]; + HFINDFILE ret; + int len = wcslen(lpFileName) + 1; + + UnicodeToAnsiOem(sz, lpFileName, sizeof(sz)); + ret = FindFirstFileA(sz, &fd); + if (ret != INVALID_HANDLE_VALUE) + { + memcpy(pwszFd, &fd, sizeof(FILETIME)*3 + sizeof(DWORD)*5); + AnsiToUnicodeOem(pwszFd->cFileName, fd.cFileName, + lstrlenA(fd.cFileName) + 1); + AnsiToUnicodeOem(pwszFd->cAlternateFileName, fd.cAlternateFileName, + 14); + } + + return ret; +} + +//+--------------------------------------------------------------------------- +// +// Function: wsprintfX +// +// Synopsis: Nightmare string function +// +// Arguments: [pwszOut] -- +// [pwszFormat] -- +// [...] -- +// +// Returns: +// +// History: 1-06-94 ErikGav Created +// +// Notes: If you're reading this, you're probably having a problem with +// this function. Make sure that your "%s" in the format string +// says "%ws" if you are passing wide strings. +// +// %s on NT means "wide string" +// %s on Chicago means "ANSI string" +// +//---------------------------------------------------------------------------- + +int WINAPIV wsprintfX(LPWSTR pwszOut, LPCWSTR pwszFormat, ...) +{ + #ifdef DEBUG_OUTPUT + OutputDebugString("wsprintf\n"); + #endif + + LPSTR szFormat; + LPWSTR pwszTemp = NULL; + int i = 0; + + // Convert the format string over + + szFormat = Convert(pwszFormat); + if (szFormat == ERR) + { + szFormat = NULL; + goto Exit; + } + + // magic voodoo follows: + // + // 1. Call wvsprintf passing the varargs + // 2. Use the pwszOut as a temp buffer to hold the ANSI output + // 3. Save the returned characters + + i = wvsprintfA((LPSTR) pwszOut, szFormat, + (LPSTR) ((BYTE*)&pwszFormat) + sizeof(pwszFormat)); + + // allocate a buffer for the Ansi to Unicode conversion + + pwszTemp = new WCHAR[i+1]; + + // convert the string + + AnsiToUnicode(pwszTemp, (LPSTR) pwszOut, i+1); + + // copy it to the out buffer + + wcsncpy(pwszOut, pwszTemp, i+1); + +Exit: + if (pwszTemp) + delete pwszTemp; + if (szFormat) + delete szFormat; + return i; +} + +BOOL +WINAPI +GetComputerNameX( + LPWSTR pwszName, + LPDWORD lpcchBuffer + ) +{ + #ifdef DEBUG_OUTPUT + OutputDebugString("GetComputerName\n"); + #endif + + BOOL ret; + LPSTR sz; + + sz = new CHAR[*lpcchBuffer]; + ret = GetComputerNameA(sz, lpcchBuffer); + + if (ret) + { + AnsiToUnicode(pwszName, sz, *lpcchBuffer); + } + + if (sz) + delete sz; + return ret; +} + +DWORD +WINAPI +GetFullPathNameX( + LPCWSTR lpFileName, + DWORD cchBuffer, + LPWSTR lpPathBuffer, + LPWSTR *lppFilePart + ) +{ + #ifdef DEBUG_OUTPUT + OutputDebugString("GetFullPathName\n"); + #endif + + LPSTR szFileName; + CHAR szPathBuffer[MAX_PATH]; + LPSTR szFilePart; + DWORD ret; + + + szFileName = ConvertOem(lpFileName); + if (szFileName == ERR) + return 0; + + ret = GetFullPathNameA(szFileName, cchBuffer, szPathBuffer, &szFilePart); + + AnsiToUnicode(lpPathBuffer, szPathBuffer, cchBuffer); + + *lppFilePart = lpPathBuffer + (szFilePart - szPathBuffer); + + if (szFileName) + delete szFileName; + + return ret; +} + + +DWORD +WINAPI +GetShortPathNameX( + LPCWSTR lpszFullPath, + LPWSTR lpszShortPath, + DWORD cchBuffer + ) +{ + #ifdef DEBUG_OUTPUT + OutputDebugString("GetShortPathName\n"); + #endif + + LPSTR szFullPath; + CHAR szShortBuffer[MAX_PATH]; + DWORD ret; + + + szFullPath = Convert(lpszFullPath); + if (szFullPath == ERR) + return 0; + + if (lpszShortPath == NULL) + { + ret = GetShortPathNameA(szFullPath, NULL, cchBuffer); + } + else + { + ret = GetShortPathNameA(szFullPath, szShortBuffer, sizeof(szShortBuffer)); + + // + // Only convert the actual data, not the whole buffer. + // + if (cchBuffer > ret + 1) + cchBuffer = ret + 1; + + AnsiToUnicode(lpszShortPath, szShortBuffer, cchBuffer); + } + + delete szFullPath; + + return ret; +} + + +DWORD +WINAPI +SearchPathX( + LPCWSTR lpPath, + LPCWSTR lpFileName, + LPCWSTR lpExtension, + DWORD nBufferLength, + LPWSTR lpBuffer, + LPWSTR *lpFilePart + ) +{ + LPSTR lpszFileName; + CHAR szBuffer[MAX_PATH]; + DWORD ret; + + + #ifdef DEBUG_OUTPUT + OutputDebugString("SearchPath\n"); + #endif + + lpszFileName = Convert(lpFileName); + if (lpszFileName == ERR) + return 0; + + ret = SearchPathA(NULL, lpszFileName, NULL, sizeof(szBuffer), szBuffer, NULL); + + AnsiToUnicode(lpBuffer, szBuffer, lstrlenA(szBuffer) + 1); + + delete lpszFileName; + + return ret; +} + + +ATOM +WINAPI +GlobalFindAtomX( + LPCWSTR lpString + ) +{ + LPSTR lpszString; + ATOM retAtom; + + + #ifdef DEBUG_OUTPUT + OutputDebugString("GlobalFindAtom\n"); + #endif + + lpszString = Convert(lpString); + if (lpszString == ERR) + return 0; + + retAtom = GlobalFindAtomA(lpszString); + + delete lpszString; + + return retAtom; +} + + +int +WINAPI +GetClassNameX( + HWND hWnd, + LPWSTR lpClassName, + int nMaxCount) +{ + LPSTR lpszClassName; + int ret; + + + #ifdef DEBUG_OUTPUT + OutputDebugString("GetClassName\n"); + #endif + + lpszClassName = Convert(lpClassName); + if (lpszClassName == ERR) + return 0; + + ret = GetClassNameA(hWnd, lpszClassName, nMaxCount); + + delete lpszClassName; + + return ret; +} + + +int +WINAPI +lstrlenX(LPCWSTR lpString) +{ + return wcslen(lpString); +} + +LPWSTR +WINAPI +lstrcatX( + LPWSTR lpString1, + LPCWSTR lpString2) +{ + return wcscat(lpString1, lpString2); +} + +int +WINAPI +lstrcmpX( + LPCWSTR lpString1, + LPCWSTR lpString2 + ) +{ + return wcscmp(lpString1, lpString2); +} + +int +WINAPI +lstrcmpiX( + LPCWSTR lpString1, + LPCWSTR lpString2 + ) +{ + return _wcsicmp(lpString1, lpString2); +} + +LPWSTR +WINAPI +lstrcpyX( + LPWSTR lpString1, + LPCWSTR lpString2 + ) +{ + return wcscpy(lpString1, lpString2); +} + + + +HANDLE +WINAPI +CreateFileMappingX( + HANDLE hFile, + LPSECURITY_ATTRIBUTES lpFileMappingAttributes, + DWORD flProtect, + DWORD dwMaximumSizeHigh, + DWORD dwMaximumSizeLow, + LPCWSTR lpName + ) +{ + LPSTR lpszAName; + HANDLE ret; + + + #ifdef DEBUG_OUTPUT + OutputDebugString("CreateFileMapping\n"); + #endif + + lpszAName = Convert(lpName); + + if (lpszAName == ERR) + { + return 0; + } + + ret = CreateFileMappingA( + hFile, + lpFileMappingAttributes, + flProtect, + dwMaximumSizeHigh, + dwMaximumSizeLow, + lpszAName); + + delete lpszAName; + + return ret; +} + + +HANDLE +WINAPI +OpenFileMappingX( + DWORD dwDesiredAccess, + BOOL bInheritHandle, + LPCWSTR lpName + ) +{ + LPSTR lpszAName; + HANDLE ret; + + + #ifdef DEBUG_OUTPUT + OutputDebugString("CreateFileMapping\n"); + #endif + + lpszAName = Convert(lpName); + + if (lpszAName == ERR) + { + return 0; + } + + ret = OpenFileMappingA( + dwDesiredAccess, + bInheritHandle, + lpszAName); + + delete lpszAName; + + return ret; +} + +#endif // CHICAGO |