[PATCH 2/3] [WineDbg]: now using Unicode strings for all modules' references
Eric Pouech
eric.pouech at orange.fr
Sat Oct 18 02:15:10 CDT 2008
A+
---
programs/winedbg/debugger.h | 9 +++---
programs/winedbg/gdbproxy.c | 28 +++++++++++--------
programs/winedbg/info.c | 3 +-
programs/winedbg/memory.c | 22 +++++++++++++--
programs/winedbg/stack.c | 3 +-
programs/winedbg/tgt_active.c | 48 +++++++++++++++++++-------------
programs/winedbg/tgt_minidump.c | 16 +++++------
programs/winedbg/winedbg.c | 59 +++++++++++++++++++++++----------------
8 files changed, 116 insertions(+), 72 deletions(-)
diff --git a/programs/winedbg/debugger.h b/programs/winedbg/debugger.h
index a8a3fc3..aae0c0c 100644
--- a/programs/winedbg/debugger.h
+++ b/programs/winedbg/debugger.h
@@ -216,7 +216,7 @@ struct dbg_process
DWORD pid;
const struct be_process_io* process_io;
void* pio_data;
- const char* imageName;
+ const WCHAR* imageName;
struct dbg_thread* threads;
unsigned continue_on_first_exception : 1,
active_debuggee : 1;
@@ -359,7 +359,7 @@ extern BOOL memory_get_current_pc(ADDRESS64* address);
extern BOOL memory_get_current_stack(ADDRESS64* address);
extern BOOL memory_get_current_frame(ADDRESS64* address);
extern BOOL memory_get_string(struct dbg_process* pcs, void* addr, BOOL in_debuggee, BOOL unicode, char* buffer, int size);
-extern BOOL memory_get_string_indirect(struct dbg_process* pcs, void* addr, BOOL unicode, char* buffer, int size);
+extern BOOL memory_get_string_indirect(struct dbg_process* pcs, void* addr, BOOL unicode, WCHAR* buffer, int size);
extern BOOL memory_get_register(DWORD regno, DWORD** value, char* buffer, int len);
extern void memory_disassemble(const struct dbg_lvalue*, const struct dbg_lvalue*, int instruction_count);
extern BOOL memory_disasm_one_insn(ADDRESS64* addr);
@@ -430,6 +430,7 @@ extern struct dbg_type types_find_type(unsigned long linear, const char* name,
/* winedbg.c */
extern void dbg_outputA(const char* buffer, int len);
extern void dbg_outputW(const WCHAR* buffer, int len);
+extern const char* dbg_W2A(const WCHAR* buffer, unsigned len);
#ifdef __GNUC__
extern int dbg_printf(const char* format, ...) __attribute__((format (printf,1,2)));
#else
@@ -439,14 +440,14 @@ extern const struct dbg_internal_var* dbg_get_internal_var(const char*);
extern BOOL dbg_interrupt_debuggee(void);
extern unsigned dbg_num_processes(void);
extern struct dbg_process* dbg_add_process(const struct be_process_io* pio, DWORD pid, HANDLE h);
-extern void dbg_set_process_name(struct dbg_process* p, const char* name);
+extern void dbg_set_process_name(struct dbg_process* p, const WCHAR* name);
extern struct dbg_process* dbg_get_process(DWORD pid);
extern struct dbg_process* dbg_get_process_h(HANDLE handle);
extern void dbg_del_process(struct dbg_process* p);
struct dbg_thread* dbg_add_thread(struct dbg_process* p, DWORD tid, HANDLE h, void* teb);
extern struct dbg_thread* dbg_get_thread(struct dbg_process* p, DWORD tid);
extern void dbg_del_thread(struct dbg_thread* t);
-extern BOOL dbg_init(HANDLE hProc, const char* in, BOOL invade);
+extern BOOL dbg_init(HANDLE hProc, const WCHAR* in, BOOL invade);
extern BOOL dbg_get_debuggee_info(HANDLE hProcess, IMAGEHLP_MODULE* imh_mod);
/* gdbproxy.c */
diff --git a/programs/winedbg/gdbproxy.c b/programs/winedbg/gdbproxy.c
index dc80a84..7799148 100644
--- a/programs/winedbg/gdbproxy.c
+++ b/programs/winedbg/gdbproxy.c
@@ -63,6 +63,7 @@
#include "windef.h"
#include "winbase.h"
#include "tlhelp32.h"
+#include "wine/debug.h"
#define GDBPXY_TRC_LOWLEVEL 0x01
#define GDBPXY_TRC_PACKET 0x02
@@ -480,7 +481,10 @@ static BOOL handle_exception(struct gdb_context* gdbctx, EXCEPTION_DEBUG_INFO* e
static void handle_debug_event(struct gdb_context* gdbctx, DEBUG_EVENT* de)
{
- char buffer[256];
+ union {
+ char bufferA[256];
+ WCHAR buffer[256];
+ } u;
dbg_curr_thread = dbg_get_thread(gdbctx->process, de->dwThreadId);
@@ -493,19 +497,20 @@ static void handle_debug_event(struct gdb_context* gdbctx, DEBUG_EVENT* de)
memory_get_string_indirect(gdbctx->process,
de->u.CreateProcessInfo.lpImageName,
de->u.CreateProcessInfo.fUnicode,
- buffer, sizeof(buffer));
- dbg_set_process_name(gdbctx->process, buffer);
+ u.buffer, sizeof(u.buffer) / sizeof(WCHAR));
+ dbg_set_process_name(gdbctx->process, u.buffer);
if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
fprintf(stderr, "%04x:%04x: create process '%s'/%p @%p (%u<%u>)\n",
de->dwProcessId, de->dwThreadId,
- buffer, de->u.CreateProcessInfo.lpImageName,
+ dbg_W2A(u.buffer, -1),
+ de->u.CreateProcessInfo.lpImageName,
de->u.CreateProcessInfo.lpStartAddress,
de->u.CreateProcessInfo.dwDebugInfoFileOffset,
de->u.CreateProcessInfo.nDebugInfoSize);
/* de->u.CreateProcessInfo.lpStartAddress; */
- if (!dbg_init(gdbctx->process->handle, buffer, TRUE))
+ if (!dbg_init(gdbctx->process->handle, u.buffer, TRUE))
fprintf(stderr, "Couldn't initiate DbgHelp\n");
if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
@@ -524,15 +529,16 @@ static void handle_debug_event(struct gdb_context* gdbctx, DEBUG_EVENT* de)
memory_get_string_indirect(gdbctx->process,
de->u.LoadDll.lpImageName,
de->u.LoadDll.fUnicode,
- buffer, sizeof(buffer));
+ u.buffer, sizeof(u.buffer) / sizeof(WCHAR));
if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
fprintf(stderr, "%04x:%04x: loads DLL %s @%p (%u<%u>)\n",
de->dwProcessId, de->dwThreadId,
- buffer, de->u.LoadDll.lpBaseOfDll,
+ dbg_W2A(u.buffer, -1),
+ de->u.LoadDll.lpBaseOfDll,
de->u.LoadDll.dwDebugInfoFileOffset,
de->u.LoadDll.nDebugInfoSize);
- SymLoadModule(gdbctx->process->handle, de->u.LoadDll.hFile, buffer, NULL,
- (unsigned long)de->u.LoadDll.lpBaseOfDll, 0);
+ SymLoadModuleExW(gdbctx->process->handle, de->u.LoadDll.hFile, u.buffer, NULL,
+ (unsigned long)de->u.LoadDll.lpBaseOfDll, 0, NULL, 0);
break;
case UNLOAD_DLL_DEBUG_EVENT:
@@ -594,10 +600,10 @@ static void handle_debug_event(struct gdb_context* gdbctx, DEBUG_EVENT* de)
assert(dbg_curr_thread);
memory_get_string(gdbctx->process,
de->u.DebugString.lpDebugStringData, TRUE,
- de->u.DebugString.fUnicode, buffer, sizeof(buffer));
+ de->u.DebugString.fUnicode, u.bufferA, sizeof(u.bufferA));
if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
fprintf(stderr, "%08x:%08x: output debug string (%s)\n",
- de->dwProcessId, de->dwThreadId, buffer);
+ de->dwProcessId, de->dwThreadId, u.bufferA);
break;
case RIP_EVENT:
diff --git a/programs/winedbg/info.c b/programs/winedbg/info.c
index fe0292d..fd160d7 100644
--- a/programs/winedbg/info.c
+++ b/programs/winedbg/info.c
@@ -501,7 +501,8 @@ void info_win32_threads(void)
struct dbg_process* p = dbg_get_process(entry.th32OwnerProcessID);
dbg_printf("%08x%s %s\n",
- entry.th32OwnerProcessID, p ? " (D)" : "", p ? p->imageName : "");
+ entry.th32OwnerProcessID, p ? " (D)" : "",
+ p ? dbg_W2A(p->imageName, -1) : "");
lastProcessId = entry.th32OwnerProcessID;
}
dbg_printf("\t%08x %4d%s\n",
diff --git a/programs/winedbg/memory.c b/programs/winedbg/memory.c
index f605421..c6174fe 100644
--- a/programs/winedbg/memory.c
+++ b/programs/winedbg/memory.c
@@ -259,16 +259,32 @@ BOOL memory_get_string(struct dbg_process* pcs, void* addr, BOOL in_debuggee,
return TRUE;
}
-BOOL memory_get_string_indirect(struct dbg_process* pcs, void* addr, BOOL unicode, char* buffer, int size)
+BOOL memory_get_string_indirect(struct dbg_process* pcs, void* addr, BOOL unicode, WCHAR* buffer, int size)
{
void* ad;
SIZE_T sz;
buffer[0] = 0;
- if (addr &&
+ if (addr &&
pcs->process_io->read(pcs->handle, addr, &ad, sizeof(ad), &sz) && sz == sizeof(ad) && ad)
{
- return memory_get_string(pcs, ad, TRUE, unicode, buffer, size);
+ LPSTR buff;
+ BOOL ret;
+
+ if (unicode)
+ ret = pcs->process_io->read(pcs->handle, ad, buffer, size * sizeof(WCHAR), &sz) && sz != 0;
+ else
+ {
+ if ((buff = HeapAlloc(GetProcessHeap(), 0, size)))
+ {
+ ret = pcs->process_io->read(pcs->handle, ad, buff, size, &sz) && sz != 0;
+ MultiByteToWideChar(CP_ACP, 0, buff, sz, buffer, size);
+ HeapFree(GetProcessHeap(), 0, buff);
+ }
+ else ret = FALSE;
+ }
+ if (size) buffer[size-1] = 0;
+ return ret;
}
return FALSE;
}
diff --git a/programs/winedbg/stack.c b/programs/winedbg/stack.c
index 63103c1..63a245c 100644
--- a/programs/winedbg/stack.c
+++ b/programs/winedbg/stack.c
@@ -391,7 +391,8 @@ static void backtrace_all(void)
}
dbg_printf("\nBacktracing for thread %04x in process %04x (%s):\n",
- entry.th32ThreadID, dbg_curr_pid, dbg_curr_process->imageName);
+ entry.th32ThreadID, dbg_curr_pid,
+ dbg_W2A(dbg_curr_process->imageName, -1));
backtrace_tid(dbg_curr_process, entry.th32ThreadID);
}
while (Thread32Next(snapshot, &entry));
diff --git a/programs/winedbg/tgt_active.c b/programs/winedbg/tgt_active.c
index 5c4d5ee..8e27be4 100644
--- a/programs/winedbg/tgt_active.c
+++ b/programs/winedbg/tgt_active.c
@@ -30,6 +30,7 @@
#include "winternl.h"
#include "wine/debug.h"
#include "wine/exception.h"
+#include "wine/unicode.h"
WINE_DEFAULT_DEBUG_CHANNEL(winedbg);
@@ -418,16 +419,19 @@ static DWORD dbg_handle_exception(const EXCEPTION_RECORD* rec, BOOL first_chance
static BOOL tgt_process_active_close_process(struct dbg_process* pcs, BOOL kill);
static void fetch_module_name(void* name_addr, BOOL unicode, void* mod_addr,
- char* buffer, size_t bufsz, BOOL is_pcs)
+ WCHAR* buffer, size_t bufsz, BOOL is_pcs)
{
+ static WCHAR pcspid[] = {'P','r','o','c','e','s','s','_','%','0','8','x',0};
+ static WCHAR dlladdr[] = {'D','L','L','_','%','0','8','l','x',0};
+
memory_get_string_indirect(dbg_curr_process, name_addr, unicode, buffer, bufsz);
if (!buffer[0] &&
- !GetModuleFileNameExA(dbg_curr_process->handle, mod_addr, buffer, bufsz))
+ !GetModuleFileNameExW(dbg_curr_process->handle, mod_addr, buffer, bufsz))
{
if (is_pcs)
{
HMODULE h;
- WORD (WINAPI *gpif)(HANDLE, LPSTR, DWORD);
+ WORD (WINAPI *gpif)(HANDLE, LPWSTR, DWORD);
/* On Windows, when we get the process creation debug event for a process
* created by winedbg, the modules' list is not initialized yet. Hence,
@@ -436,18 +440,21 @@ static void fetch_module_name(void* name_addr, BOOL unicode, void* mod_addr,
* give us the expected result
*/
if (!(h = GetModuleHandleA("psapi")) ||
- !(gpif = (void*)GetProcAddress(h, "GetProcessImageFileName")) ||
+ !(gpif = (void*)GetProcAddress(h, "GetProcessImageFileNameW")) ||
!(gpif)(dbg_curr_process->handle, buffer, bufsz))
- snprintf(buffer, bufsz, "Process_%08x", dbg_curr_pid);
+ snprintfW(buffer, bufsz, pcspid, dbg_curr_pid);
}
else
- snprintf(buffer, bufsz, "DLL_%p", mod_addr);
+ snprintfW(buffer, bufsz, dlladdr, (unsigned long)mod_addr);
}
}
static unsigned dbg_handle_debug_event(DEBUG_EVENT* de)
{
- char buffer[256];
+ union {
+ char bufferA[256];
+ WCHAR buffer[256];
+ } u;
DWORD cont = DBG_CONTINUE;
dbg_curr_pid = de->dwProcessId;
@@ -499,20 +506,21 @@ static unsigned dbg_handle_debug_event(DEBUG_EVENT* de)
fetch_module_name(de->u.CreateProcessInfo.lpImageName,
de->u.CreateProcessInfo.fUnicode,
de->u.CreateProcessInfo.lpBaseOfImage,
- buffer, sizeof(buffer), TRUE);
+ u.buffer, sizeof(u.buffer) / sizeof(WCHAR), TRUE);
WINE_TRACE("%04x:%04x: create process '%s'/%p @%p (%u<%u>)\n",
de->dwProcessId, de->dwThreadId,
- buffer, de->u.CreateProcessInfo.lpImageName,
+ wine_dbgstr_w(u.buffer),
+ de->u.CreateProcessInfo.lpImageName,
de->u.CreateProcessInfo.lpStartAddress,
de->u.CreateProcessInfo.dwDebugInfoFileOffset,
de->u.CreateProcessInfo.nDebugInfoSize);
- dbg_set_process_name(dbg_curr_process, buffer);
+ dbg_set_process_name(dbg_curr_process, u.buffer);
- if (!dbg_init(dbg_curr_process->handle, buffer, FALSE))
+ if (!dbg_init(dbg_curr_process->handle, u.buffer, FALSE))
dbg_printf("Couldn't initiate DbgHelp\n");
- if (!SymLoadModule(dbg_curr_process->handle, de->u.CreateProcessInfo.hFile, buffer, NULL,
- (unsigned long)de->u.CreateProcessInfo.lpBaseOfImage, 0))
+ if (!SymLoadModuleExW(dbg_curr_process->handle, de->u.CreateProcessInfo.hFile, u.buffer, NULL,
+ (unsigned long)de->u.CreateProcessInfo.lpBaseOfImage, 0, NULL, 0))
dbg_printf("couldn't load main module (%u)\n", GetLastError());
WINE_TRACE("%04x:%04x: create thread I @%p\n",
@@ -593,22 +601,22 @@ static unsigned dbg_handle_debug_event(DEBUG_EVENT* de)
fetch_module_name(de->u.LoadDll.lpImageName,
de->u.LoadDll.fUnicode,
de->u.LoadDll.lpBaseOfDll,
- buffer, sizeof(buffer), FALSE);
+ u.buffer, sizeof(u.buffer) / sizeof(WCHAR), FALSE);
WINE_TRACE("%04x:%04x: loads DLL %s @%p (%u<%u>)\n",
de->dwProcessId, de->dwThreadId,
- buffer, de->u.LoadDll.lpBaseOfDll,
+ wine_dbgstr_w(u.buffer), de->u.LoadDll.lpBaseOfDll,
de->u.LoadDll.dwDebugInfoFileOffset,
de->u.LoadDll.nDebugInfoSize);
- SymLoadModule(dbg_curr_process->handle, de->u.LoadDll.hFile, buffer, NULL,
- (unsigned long)de->u.LoadDll.lpBaseOfDll, 0);
+ SymLoadModuleExW(dbg_curr_process->handle, de->u.LoadDll.hFile, u.buffer, NULL,
+ (unsigned long)de->u.LoadDll.lpBaseOfDll, 0, NULL, 0);
break_set_xpoints(FALSE);
break_check_delayed_bp();
break_set_xpoints(TRUE);
if (DBG_IVAR(BreakOnDllLoad))
{
dbg_printf("Stopping on DLL %s loading at 0x%08lx\n",
- buffer, (unsigned long)de->u.LoadDll.lpBaseOfDll);
+ dbg_W2A(u.buffer, -1), (unsigned long)de->u.LoadDll.lpBaseOfDll);
if (dbg_fetch_context()) cont = 0;
}
break;
@@ -631,9 +639,9 @@ static unsigned dbg_handle_debug_event(DEBUG_EVENT* de)
memory_get_string(dbg_curr_process,
de->u.DebugString.lpDebugStringData, TRUE,
- de->u.DebugString.fUnicode, buffer, sizeof(buffer));
+ de->u.DebugString.fUnicode, u.bufferA, sizeof(u.bufferA));
WINE_TRACE("%04x:%04x: output debug string (%s)\n",
- de->dwProcessId, de->dwThreadId, buffer);
+ de->dwProcessId, de->dwThreadId, u.bufferA);
break;
case RIP_EVENT:
diff --git a/programs/winedbg/tgt_minidump.c b/programs/winedbg/tgt_minidump.c
index 8d623dc..f6b7c35 100644
--- a/programs/winedbg/tgt_minidump.c
+++ b/programs/winedbg/tgt_minidump.c
@@ -172,9 +172,10 @@ static enum dbg_start minidump_do_reload(struct tgt_process_minidump_data* data)
MINIDUMP_MODULE_LIST* mml;
MINIDUMP_MODULE* mm;
MINIDUMP_STRING* mds;
- char exec_name[1024];
+ WCHAR exec_name[1024];
WCHAR nameW[1024];
unsigned len;
+ static WCHAR default_exec_name[] = {'<','m','i','n','i','d','u','m','p','-','e','x','e','c','>',0};
/* fetch PID */
if (MiniDumpReadDumpStream(data->mapping, MiscInfoStream, &dir, &stream, &size))
@@ -185,25 +186,24 @@ static enum dbg_start minidump_do_reload(struct tgt_process_minidump_data* data)
}
/* fetch executable name (it's normally the first one in module list) */
- strcpy(exec_name, "<minidump-exec>"); /* default */
+ lstrcpyW(exec_name, default_exec_name);
if (MiniDumpReadDumpStream(data->mapping, ModuleListStream, &dir, &stream, &size))
{
mml = (MINIDUMP_MODULE_LIST*)stream;
if (mml->NumberOfModules)
{
- char* ptr;
+ WCHAR* ptr;
mm = &mml->Modules[0];
mds = (MINIDUMP_STRING*)((char*)data->mapping + mm->ModuleNameRva);
- len = WideCharToMultiByte(CP_ACP, 0, mds->Buffer,
- mds->Length / sizeof(WCHAR),
- exec_name, sizeof(exec_name) - 1, NULL, NULL);
+ len = mds->Length / 2;
+ memcpy(exec_name, mds->Buffer, mds->Length);
exec_name[len] = 0;
for (ptr = exec_name + len - 1; ptr >= exec_name; ptr--)
{
if (*ptr == '/' || *ptr == '\\')
{
- memmove(exec_name, ptr + 1, strlen(ptr + 1) + 1);
+ memmove(exec_name, ptr + 1, (lstrlenW(ptr + 1) + 1) * sizeof(WCHAR));
break;
}
}
@@ -264,7 +264,7 @@ static enum dbg_start minidump_do_reload(struct tgt_process_minidump_data* data)
break;
}
dbg_printf(" %s was running on #%d %s CPU%s",
- exec_name, msi->u.s.NumberOfProcessors, str,
+ dbg_W2A(exec_name, -1), msi->u.s.NumberOfProcessors, str,
msi->u.s.NumberOfProcessors < 2 ? "" : "s");
switch (msi->MajorVersion)
{
diff --git a/programs/winedbg/winedbg.c b/programs/winedbg/winedbg.c
index 5cbc68f..575c829 100644
--- a/programs/winedbg/winedbg.c
+++ b/programs/winedbg/winedbg.c
@@ -125,22 +125,33 @@ void dbg_outputA(const char* buffer, int len)
}
}
-void dbg_outputW(const WCHAR* buffer, int len)
+const char* dbg_W2A(const WCHAR* buffer, unsigned len)
{
- char* ansi = NULL;
- int newlen;
-
- /* do a serious Unicode to ANSI conversion
- * FIXME: should CP_ACP be GetConsoleCP()?
- */
+ static unsigned ansilen;
+ static char* ansi;
+ unsigned newlen;
+
newlen = WideCharToMultiByte(CP_ACP, 0, buffer, len, NULL, 0, NULL, NULL);
- if (newlen)
+ if (newlen > ansilen)
{
- if (!(ansi = HeapAlloc(GetProcessHeap(), 0, newlen))) return;
- WideCharToMultiByte(CP_ACP, 0, buffer, len, ansi, newlen, NULL, NULL);
- dbg_outputA(ansi, newlen);
- HeapFree(GetProcessHeap(), 0, ansi);
+ static char* newansi;
+ if (ansi)
+ newansi = HeapReAlloc(GetProcessHeap(), 0, ansi, newlen);
+ else
+ newansi = HeapAlloc(GetProcessHeap(), 0, newlen);
+ if (!newansi) return NULL;
+ ansilen = newlen;
+ ansi = newansi;
}
+ WideCharToMultiByte(CP_ACP, 0, buffer, len, ansi, newlen, NULL, NULL);
+ return ansi;
+}
+
+void dbg_outputW(const WCHAR* buffer, int len)
+{
+ const char* ansi = dbg_W2A(buffer, len);
+ if (ansi) dbg_outputA(ansi, strlen(ansi));
+ /* FIXME: should CP_ACP be GetConsoleCP()? */
}
int dbg_printf(const char* format, ...)
@@ -315,13 +326,13 @@ struct dbg_process* dbg_add_process(const struct be_process_io* pio, DWORD pid,
return p;
}
-void dbg_set_process_name(struct dbg_process* p, const char* imageName)
+void dbg_set_process_name(struct dbg_process* p, const WCHAR* imageName)
{
assert(p->imageName == NULL);
if (imageName)
{
- char* tmp = HeapAlloc(GetProcessHeap(), 0, strlen(imageName) + 1);
- if (tmp) p->imageName = strcpy(tmp, imageName);
+ WCHAR* tmp = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(imageName) + 1) * sizeof(WCHAR));
+ if (tmp) p->imageName = lstrcpyW(tmp, imageName);
}
}
@@ -352,29 +363,29 @@ void dbg_del_process(struct dbg_process* p)
* Initializes the dbghelp library, and also sets the application directory
* as a place holder for symbol searches.
*/
-BOOL dbg_init(HANDLE hProc, const char* in, BOOL invade)
+BOOL dbg_init(HANDLE hProc, const WCHAR* in, BOOL invade)
{
BOOL ret;
ret = SymInitialize(hProc, NULL, invade);
if (ret && in)
{
- const char* last;
+ const WCHAR* last;
- for (last = in + strlen(in) - 1; last >= in; last--)
+ for (last = in + lstrlenW(in) - 1; last >= in; last--)
{
if (*last == '/' || *last == '\\')
{
- char* tmp;
- tmp = HeapAlloc(GetProcessHeap(), 0, 1024 + 1 + (last - in) + 1);
- if (tmp && SymGetSearchPath(hProc, tmp, 1024))
+ WCHAR* tmp;
+ tmp = HeapAlloc(GetProcessHeap(), 0, (1024 + 1 + (last - in) + 1) * sizeof(WCHAR));
+ if (tmp && SymGetSearchPathW(hProc, tmp, 1024))
{
- char* x = tmp + strlen(tmp);
+ WCHAR* x = tmp + lstrlenW(tmp);
*x++ = ';';
- memcpy(x, in, last - in);
+ memcpy(x, in, (last - in) * sizeof(WCHAR));
x[last - in] = '\0';
- ret = SymSetSearchPath(hProc, tmp);
+ ret = SymSetSearchPathW(hProc, tmp);
}
else ret = FALSE;
HeapFree(GetProcessHeap(), 0, tmp);
More information about the wine-patches
mailing list