10 Sep
2020
10 Sep
'20
4:19 p.m.
https://git.reactos.org/?p=reactos.git;a=commitdiff;h=07f98eb10ae7cabeeaec0…
commit 07f98eb10ae7cabeeaec07bf2f3f940f29b892fc
Author: Oleg Dubinskiy <oleg.dubinskij2013(a)yandex.ua>
AuthorDate: Tue Jun 30 20:42:29 2020 +0300
Commit: Mark Jansen <mark.jansen(a)reactos.org>
CommitDate: Thu Sep 10 18:19:28 2020 +0200
[DBGENG] Import dbgeng.dll from Wine Staging 4.18
CORE-17153.
---
dll/win32/CMakeLists.txt | 1 +
dll/win32/dbgeng/CMakeLists.txt | 16 +
dll/win32/dbgeng/dbgeng.c | 4105 +++++++++++++++++++++++++++++++++++++++
dll/win32/dbgeng/dbgeng.spec | 5 +
media/doc/README.WINE | 1 +
5 files changed, 4128 insertions(+)
diff --git a/dll/win32/CMakeLists.txt b/dll/win32/CMakeLists.txt
index 533d1dcf243..66a82d2d3b9 100644
--- a/dll/win32/CMakeLists.txt
+++ b/dll/win32/CMakeLists.txt
@@ -34,6 +34,7 @@ add_subdirectory(cryptdlg)
add_subdirectory(cryptdll)
add_subdirectory(cryptnet)
add_subdirectory(cryptui)
+add_subdirectory(dbgeng)
add_subdirectory(dbghelp)
add_subdirectory(dciman32)
add_subdirectory(devmgr)
diff --git a/dll/win32/dbgeng/CMakeLists.txt b/dll/win32/dbgeng/CMakeLists.txt
new file mode 100644
index 00000000000..9270aead99f
--- /dev/null
+++ b/dll/win32/dbgeng/CMakeLists.txt
@@ -0,0 +1,16 @@
+
+add_definitions(-D__WINESRC__)
+include_directories(${REACTOS_SOURCE_DIR}/sdk/include/reactos/wine)
+spec2def(dbgeng.dll dbgeng.spec)
+
+list(APPEND SOURCE
+ dbgeng.c
+ ${CMAKE_CURRENT_BINARY_DIR}/dbgeng_stubs.c
+ ${CMAKE_CURRENT_BINARY_DIR}/dbgeng.def)
+
+add_library(dbgeng MODULE ${SOURCE})
+set_module_type(dbgeng win32dll)
+target_link_libraries(dbgeng wine)
+add_importlibs(dbgeng psapi msvcrt ntdll)
+add_delay_importlibs(dbgeng version)
+add_cd_file(TARGET dbgeng DESTINATION reactos/system32 FOR all)
diff --git a/dll/win32/dbgeng/dbgeng.c b/dll/win32/dbgeng/dbgeng.c
new file mode 100644
index 00000000000..f1fe3cfb071
--- /dev/null
+++ b/dll/win32/dbgeng/dbgeng.c
@@ -0,0 +1,4105 @@
+/*
+ * Support for Microsoft Debugging Extension API
+ *
+ * Copyright (C) 2010 Volodymyr Shcherbyna
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <stdarg.h>
+
+#define COBJMACROS
+
+#include "windef.h"
+#include "winbase.h"
+#ifdef __REACTOS__
+#include "wine/winternl.h"
+#else
+#include "winternl.h"
+#endif
+#include "psapi.h"
+
+#include "initguid.h"
+#include "dbgeng.h"
+
+#include "wine/debug.h"
+#include "wine/heap.h"
+#include "wine/list.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(dbgeng);
+
+extern NTSTATUS WINAPI NtSuspendProcess(HANDLE handle);
+extern NTSTATUS WINAPI NtResumeProcess(HANDLE handle);
+
+struct module_info
+{
+ DEBUG_MODULE_PARAMETERS params;
+ char image_name[MAX_PATH];
+};
+
+struct target_process
+{
+ struct list entry;
+ unsigned int pid;
+ unsigned int attach_flags;
+ HANDLE handle;
+ struct
+ {
+ struct module_info *info;
+ unsigned int loaded;
+ unsigned int unloaded;
+ BOOL initialized;
+ } modules;
+ ULONG cpu_type;
+};
+
+struct debug_client
+{
+ IDebugClient7 IDebugClient_iface;
+ IDebugDataSpaces IDebugDataSpaces_iface;
+ IDebugSymbols3 IDebugSymbols3_iface;
+ IDebugControl2 IDebugControl2_iface;
+ IDebugAdvanced IDebugAdvanced_iface;
+ IDebugSystemObjects IDebugSystemObjects_iface;
+ LONG refcount;
+ ULONG engine_options;
+ struct list targets;
+ IDebugEventCallbacks *event_callbacks;
+};
+
+static struct target_process *debug_client_get_target(struct debug_client *debug_client)
+{
+ if (list_empty(&debug_client->targets))
+ return NULL;
+
+ return LIST_ENTRY(list_head(&debug_client->targets), struct target_process,
entry);
+}
+
+static HRESULT debug_target_return_string(const char *str, char *buffer, unsigned int
buffer_size,
+ unsigned int *size)
+{
+ unsigned int len = strlen(str), dst_len;
+
+ if (size)
+ *size = len + 1;
+
+ if (buffer && buffer_size)
+ {
+ dst_len = min(len, buffer_size - 1);
+ if (dst_len)
+ memcpy(buffer, str, dst_len);
+ buffer[dst_len] = 0;
+ }
+
+ return len < buffer_size ? S_OK : S_FALSE;
+}
+
+static WORD debug_target_get_module_machine(struct target_process *target, HMODULE
module)
+{
+ IMAGE_DOS_HEADER dos = { 0 };
+ WORD machine = 0;
+
+ ReadProcessMemory(target->handle, module, &dos, sizeof(dos), NULL);
+ if (dos.e_magic == IMAGE_DOS_SIGNATURE)
+ {
+ ReadProcessMemory(target->handle, (const char *)module + dos.e_lfanew + 4 /*
PE signature */, &machine,
+ sizeof(machine), NULL);
+ }
+
+ return machine;
+}
+
+static DWORD debug_target_get_module_timestamp(struct target_process *target, HMODULE
module)
+{
+ IMAGE_DOS_HEADER dos = { 0 };
+ DWORD timestamp = 0;
+
+ ReadProcessMemory(target->handle, module, &dos, sizeof(dos), NULL);
+ if (dos.e_magic == IMAGE_DOS_SIGNATURE)
+ {
+ ReadProcessMemory(target->handle, (const char *)module + dos.e_lfanew + 4 /*
PE signature */ +
+ FIELD_OFFSET(IMAGE_FILE_HEADER, TimeDateStamp), ×tamp,
sizeof(timestamp), NULL);
+ }
+
+ return timestamp;
+}
+
+static HRESULT debug_target_init_modules_info(struct target_process *target)
+{
+ unsigned int i, count;
+ HMODULE *modules;
+ MODULEINFO info;
+ DWORD needed;
+
+ if (target->modules.initialized)
+ return S_OK;
+
+ if (!target->handle)
+ return E_UNEXPECTED;
+
+ needed = 0;
+ EnumProcessModules(target->handle, NULL, 0, &needed);
+ if (!needed)
+ return E_FAIL;
+
+ count = needed / sizeof(HMODULE);
+
+ if (!(modules = heap_alloc(count * sizeof(*modules))))
+ return E_OUTOFMEMORY;
+
+ if (!(target->modules.info = heap_alloc_zero(count *
sizeof(*target->modules.info))))
+ {
+ heap_free(modules);
+ return E_OUTOFMEMORY;
+ }
+
+ if (EnumProcessModules(target->handle, modules, count * sizeof(*modules),
&needed))
+ {
+ for (i = 0; i < count; ++i)
+ {
+ if (!GetModuleInformation(target->handle, modules[i], &info,
sizeof(info)))
+ {
+ WARN("Failed to get module information, error %d.\n",
GetLastError());
+ continue;
+ }
+
+ target->modules.info[i].params.Base = (ULONG_PTR)info.lpBaseOfDll;
+ target->modules.info[i].params.Size = info.SizeOfImage;
+ target->modules.info[i].params.TimeDateStamp =
debug_target_get_module_timestamp(target, modules[i]);
+
+ GetModuleFileNameExA(target->handle, modules[i],
target->modules.info[i].image_name,
+ ARRAY_SIZE(target->modules.info[i].image_name));
+ }
+ }
+
+ target->cpu_type = debug_target_get_module_machine(target, modules[0]);
+
+ heap_free(modules);
+
+ target->modules.loaded = count;
+ target->modules.unloaded = 0; /* FIXME */
+
+ target->modules.initialized = TRUE;
+
+ return S_OK;
+}
+
+static const struct module_info *debug_target_get_module_info(struct target_process
*target, unsigned int i)
+{
+ if (FAILED(debug_target_init_modules_info(target)))
+ return NULL;
+
+ if (i >= target->modules.loaded)
+ return NULL;
+
+ return &target->modules.info[i];
+}
+
+static const struct module_info *debug_target_get_module_info_by_base(struct
target_process *target, ULONG64 base)
+{
+ unsigned int i;
+
+ if (FAILED(debug_target_init_modules_info(target)))
+ return NULL;
+
+ for (i = 0; i < target->modules.loaded; ++i)
+ {
+ if (target->modules.info[i].params.Base == base)
+ return &target->modules.info[i];
+ }
+
+ return NULL;
+}
+
+static void debug_client_detach_target(struct target_process *target)
+{
+ NTSTATUS status;
+
+ if (!target->handle)
+ return;
+
+ if (target->attach_flags & DEBUG_ATTACH_NONINVASIVE)
+ {
+ BOOL resume = !(target->attach_flags &
DEBUG_ATTACH_NONINVASIVE_NO_SUSPEND);
+
+ if (resume)
+ {
+ if ((status = NtResumeProcess(target->handle)))
+ WARN("Failed to resume process, status %#x.\n", status);
+ }
+ }
+
+ CloseHandle(target->handle);
+ target->handle = NULL;
+}
+
+static struct debug_client *impl_from_IDebugClient(IDebugClient7 *iface)
+{
+ return CONTAINING_RECORD(iface, struct debug_client, IDebugClient_iface);
+}
+
+static struct debug_client *impl_from_IDebugDataSpaces(IDebugDataSpaces *iface)
+{
+ return CONTAINING_RECORD(iface, struct debug_client, IDebugDataSpaces_iface);
+}
+
+static struct debug_client *impl_from_IDebugSymbols3(IDebugSymbols3 *iface)
+{
+ return CONTAINING_RECORD(iface, struct debug_client, IDebugSymbols3_iface);
+}
+
+static struct debug_client *impl_from_IDebugControl2(IDebugControl2 *iface)
+{
+ return CONTAINING_RECORD(iface, struct debug_client, IDebugControl2_iface);
+}
+
+static struct debug_client *impl_from_IDebugAdvanced(IDebugAdvanced *iface)
+{
+ return CONTAINING_RECORD(iface, struct debug_client, IDebugAdvanced_iface);
+}
+
+static struct debug_client *impl_from_IDebugSystemObjects(IDebugSystemObjects *iface)
+{
+ return CONTAINING_RECORD(iface, struct debug_client, IDebugSystemObjects_iface);
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_QueryInterface(IDebugClient7 *iface, REFIID
riid, void **obj)
+{
+ struct debug_client *debug_client = impl_from_IDebugClient(iface);
+
+ TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
+
+ if (IsEqualIID(riid, &IID_IDebugClient) ||
+ IsEqualIID(riid, &IID_IDebugClient2) ||
+ IsEqualIID(riid, &IID_IDebugClient3) ||
+ IsEqualIID(riid, &IID_IDebugClient4) ||
+ IsEqualIID(riid, &IID_IDebugClient5) ||
+ IsEqualIID(riid, &IID_IDebugClient6) ||
+ IsEqualIID(riid, &IID_IDebugClient7) ||
+ IsEqualIID(riid, &IID_IUnknown))
+ {
+ *obj = iface;
+ }
+ else if (IsEqualIID(riid, &IID_IDebugDataSpaces))
+ {
+ *obj = &debug_client->IDebugDataSpaces_iface;
+ }
+ else if (IsEqualIID(riid, &IID_IDebugSymbols)
+ || IsEqualIID(riid, &IID_IDebugSymbols2)
+ || IsEqualIID(riid, &IID_IDebugSymbols3))
+ {
+ *obj = &debug_client->IDebugSymbols3_iface;
+ }
+ else if (IsEqualIID(riid, &IID_IDebugControl2)
+ || IsEqualIID(riid, &IID_IDebugControl))
+ {
+ *obj = &debug_client->IDebugControl2_iface;
+ }
+ else if (IsEqualIID(riid, &IID_IDebugAdvanced))
+ {
+ *obj = &debug_client->IDebugAdvanced_iface;
+ }
+ else if (IsEqualIID(riid, &IID_IDebugSystemObjects))
+ {
+ *obj = &debug_client->IDebugSystemObjects_iface;
+ }
+ else
+ {
+ WARN("Unsupported interface %s.\n", debugstr_guid(riid));
+ *obj = NULL;
+ return E_NOINTERFACE;
+ }
+
+ IUnknown_AddRef((IUnknown *)*obj);
+ return S_OK;
+}
+
+static ULONG STDMETHODCALLTYPE debugclient_AddRef(IDebugClient7 *iface)
+{
+ struct debug_client *debug_client = impl_from_IDebugClient(iface);
+ ULONG refcount = InterlockedIncrement(&debug_client->refcount);
+
+ TRACE("%p, %d.\n", iface, refcount);
+
+ return refcount;
+}
+
+static void debug_target_free(struct target_process *target)
+{
+ heap_free(target->modules.info);
+ heap_free(target);
+}
+
+static ULONG STDMETHODCALLTYPE debugclient_Release(IDebugClient7 *iface)
+{
+ struct debug_client *debug_client = impl_from_IDebugClient(iface);
+ ULONG refcount = InterlockedDecrement(&debug_client->refcount);
+ struct target_process *cur, *cur2;
+
+ TRACE("%p, %d.\n", debug_client, refcount);
+
+ if (!refcount)
+ {
+ LIST_FOR_EACH_ENTRY_SAFE(cur, cur2, &debug_client->targets, struct
target_process, entry)
+ {
+ debug_client_detach_target(cur);
+ list_remove(&cur->entry);
+ debug_target_free(cur);
+ }
+ if (debug_client->event_callbacks)
+
debug_client->event_callbacks->lpVtbl->Release(debug_client->event_callbacks);
+ heap_free(debug_client);
+ }
+
+ return refcount;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_AttachKernel(IDebugClient7 *iface, ULONG
flags, const char *options)
+{
+ FIXME("%p, %#x, %s stub.\n", iface, flags, debugstr_a(options));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_GetKernelConnectionOptions(IDebugClient7
*iface, char *buffer,
+ ULONG buffer_size, ULONG *options_size)
+{
+ FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, options_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_SetKernelConnectionOptions(IDebugClient7
*iface, const char *options)
+{
+ FIXME("%p, %s stub.\n", iface, debugstr_a(options));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_StartProcessServer(IDebugClient7 *iface,
ULONG flags, const char *options,
+ void *reserved)
+{
+ FIXME("%p, %#x, %s, %p stub.\n", iface, flags, debugstr_a(options),
reserved);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_ConnectProcessServer(IDebugClient7 *iface,
const char *remote_options,
+ ULONG64 *server)
+{
+ FIXME("%p, %s, %p stub.\n", iface, debugstr_a(remote_options), server);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_DisconnectProcessServer(IDebugClient7
*iface, ULONG64 server)
+{
+ FIXME("%p, %s stub.\n", iface, wine_dbgstr_longlong(server));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_GetRunningProcessSystemIds(IDebugClient7
*iface, ULONG64 server,
+ ULONG *ids, ULONG count, ULONG *actual_count)
+{
+ FIXME("%p, %s, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(server),
ids, count, actual_count);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE
debugclient_GetRunningProcessSystemIdByExecutableName(IDebugClient7 *iface,
+ ULONG64 server, const char *exe_name, ULONG flags, ULONG *id)
+{
+ FIXME("%p, %s, %s, %#x, %p stub.\n", iface, wine_dbgstr_longlong(server),
debugstr_a(exe_name), flags, id);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_GetRunningProcessDescription(IDebugClient7
*iface, ULONG64 server,
+ ULONG systemid, ULONG flags, char *exe_name, ULONG exe_name_size, ULONG
*actual_exe_name_size,
+ char *description, ULONG description_size, ULONG *actual_description_size)
+{
+ FIXME("%p, %s, %u, %#x, %p, %u, %p, %p, %u, %p stub.\n", iface,
wine_dbgstr_longlong(server), systemid, flags,
+ exe_name, exe_name_size, actual_exe_name_size, description, description_size,
actual_description_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_AttachProcess(IDebugClient7 *iface, ULONG64
server, ULONG pid, ULONG flags)
+{
+ struct debug_client *debug_client = impl_from_IDebugClient(iface);
+ struct target_process *process;
+
+ TRACE("%p, %s, %u, %#x.\n", iface, wine_dbgstr_longlong(server), pid,
flags);
+
+ if (server)
+ {
+ FIXME("Remote debugging is not supported.\n");
+ return E_NOTIMPL;
+ }
+
+ if (!(process = heap_alloc_zero(sizeof(*process))))
+ return E_OUTOFMEMORY;
+
+ process->pid = pid;
+ process->attach_flags = flags;
+
+ list_add_head(&debug_client->targets, &process->entry);
+
+ return S_OK;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_CreateProcess(IDebugClient7 *iface, ULONG64
server, char *cmdline,
+ ULONG flags)
+{
+ FIXME("%p, %s, %s, %#x stub.\n", iface, wine_dbgstr_longlong(server),
debugstr_a(cmdline), flags);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_CreateProcessAndAttach(IDebugClient7 *iface,
ULONG64 server, char *cmdline,
+ ULONG create_flags, ULONG pid, ULONG attach_flags)
+{
+ FIXME("%p, %s, %s, %#x, %u, %#x stub.\n", iface,
wine_dbgstr_longlong(server), debugstr_a(cmdline), create_flags,
+ pid, attach_flags);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_GetProcessOptions(IDebugClient7 *iface,
ULONG *options)
+{
+ FIXME("%p, %p stub.\n", iface, options);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_AddProcessOptions(IDebugClient7 *iface,
ULONG options)
+{
+ FIXME("%p, %#x stub.\n", iface, options);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_RemoveProcessOptions(IDebugClient7 *iface,
ULONG options)
+{
+ FIXME("%p, %#x stub.\n", iface, options);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_SetProcessOptions(IDebugClient7 *iface,
ULONG options)
+{
+ FIXME("%p, %#x stub.\n", iface, options);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_OpenDumpFile(IDebugClient7 *iface, const
char *filename)
+{
+ FIXME("%p, %s stub.\n", iface, debugstr_a(filename));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_WriteDumpFile(IDebugClient7 *iface, const
char *filename, ULONG qualifier)
+{
+ FIXME("%p, %s, %u stub.\n", iface, debugstr_a(filename), qualifier);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_ConnectSession(IDebugClient7 *iface, ULONG
flags, ULONG history_limit)
+{
+ FIXME("%p, %#x, %u stub.\n", iface, flags, history_limit);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_StartServer(IDebugClient7 *iface, const char
*options)
+{
+ FIXME("%p, %s stub.\n", iface, debugstr_a(options));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_OutputServers(IDebugClient7 *iface, ULONG
output_control,
+ const char *machine, ULONG flags)
+{
+ FIXME("%p, %u, %s, %#x stub.\n", iface, output_control,
debugstr_a(machine), flags);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_TerminateProcesses(IDebugClient7 *iface)
+{
+ FIXME("%p stub.\n", iface);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_DetachProcesses(IDebugClient7 *iface)
+{
+ struct debug_client *debug_client = impl_from_IDebugClient(iface);
+ struct target_process *target;
+
+ TRACE("%p.\n", iface);
+
+ LIST_FOR_EACH_ENTRY(target, &debug_client->targets, struct target_process,
entry)
+ {
+ debug_client_detach_target(target);
+ }
+
+ return S_OK;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_EndSession(IDebugClient7 *iface, ULONG
flags)
+{
+ FIXME("%p, %#x stub.\n", iface, flags);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_GetExitCode(IDebugClient7 *iface, ULONG
*code)
+{
+ FIXME("%p, %p stub.\n", iface, code);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_DispatchCallbacks(IDebugClient7 *iface,
ULONG timeout)
+{
+ FIXME("%p, %u stub.\n", iface, timeout);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_ExitDispatch(IDebugClient7 *iface,
IDebugClient *client)
+{
+ FIXME("%p, %p stub.\n", iface, client);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_CreateClient(IDebugClient7 *iface,
IDebugClient **client)
+{
+ FIXME("%p, %p stub.\n", iface, client);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_GetInputCallbacks(IDebugClient7 *iface,
IDebugInputCallbacks **callbacks)
+{
+ FIXME("%p, %p stub.\n", iface, callbacks);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_SetInputCallbacks(IDebugClient7 *iface,
IDebugInputCallbacks *callbacks)
+{
+ FIXME("%p, %p stub.\n", iface, callbacks);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_GetOutputCallbacks(IDebugClient7 *iface,
IDebugOutputCallbacks **callbacks)
+{
+ FIXME("%p, %p stub.\n", iface, callbacks);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_SetOutputCallbacks(IDebugClient7 *iface,
IDebugOutputCallbacks *callbacks)
+{
+ FIXME("%p, %p stub.\n", iface, callbacks);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_GetOutputMask(IDebugClient7 *iface, ULONG
*mask)
+{
+ FIXME("%p, %p stub.\n", iface, mask);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_SetOutputMask(IDebugClient7 *iface, ULONG
mask)
+{
+ FIXME("%p, %#x stub.\n", iface, mask);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_GetOtherOutputMask(IDebugClient7 *iface,
IDebugClient *client, ULONG *mask)
+{
+ FIXME("%p, %p, %p stub.\n", iface, client, mask);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_SetOtherOutputMask(IDebugClient7 *iface,
IDebugClient *client, ULONG mask)
+{
+ FIXME("%p, %p, %#x stub.\n", iface, client, mask);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_GetOutputWidth(IDebugClient7 *iface, ULONG
*columns)
+{
+ FIXME("%p, %p stub.\n", iface, columns);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_SetOutputWidth(IDebugClient7 *iface, ULONG
columns)
+{
+ FIXME("%p, %u stub.\n", iface, columns);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_GetOutputLinePrefix(IDebugClient7 *iface,
char *buffer, ULONG buffer_size,
+ ULONG *prefix_size)
+{
+ FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, prefix_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_SetOutputLinePrefix(IDebugClient7 *iface,
const char *prefix)
+{
+ FIXME("%p, %s stub.\n", iface, debugstr_a(prefix));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_GetIdentity(IDebugClient7 *iface, char
*buffer, ULONG buffer_size,
+ ULONG *identity_size)
+{
+ FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size,
identity_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_OutputIdentity(IDebugClient7 *iface, ULONG
output_control, ULONG flags,
+ const char *format)
+{
+ FIXME("%p, %u, %#x, %s stub.\n", iface, output_control, flags,
debugstr_a(format));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_GetEventCallbacks(IDebugClient7 *iface,
IDebugEventCallbacks **callbacks)
+{
+ struct debug_client *debug_client = impl_from_IDebugClient(iface);
+
+ TRACE("%p, %p.\n", iface, callbacks);
+
+ if (debug_client->event_callbacks)
+ {
+ *callbacks = debug_client->event_callbacks;
+ (*callbacks)->lpVtbl->AddRef(*callbacks);
+ }
+
+ return S_OK;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_SetEventCallbacks(IDebugClient7 *iface,
IDebugEventCallbacks *callbacks)
+{
+ struct debug_client *debug_client = impl_from_IDebugClient(iface);
+
+ TRACE("%p, %p.\n", iface, callbacks);
+
+ if (debug_client->event_callbacks)
+
debug_client->event_callbacks->lpVtbl->Release(debug_client->event_callbacks);
+ if ((debug_client->event_callbacks = callbacks))
+
debug_client->event_callbacks->lpVtbl->AddRef(debug_client->event_callbacks);
+
+ return S_OK;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_FlushCallbacks(IDebugClient7 *iface)
+{
+ FIXME("%p stub.\n", iface);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_WriteDumpFile2(IDebugClient7 *iface, const
char *dumpfile, ULONG qualifier,
+ ULONG flags, const char *comment)
+{
+ FIXME("%p, %s, %d, 0x%08x, %s.\n", iface, debugstr_a(dumpfile), qualifier,
flags, debugstr_a(comment));
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_AddDumpInformationFile(IDebugClient7 *iface,
const char *infofile, ULONG type)
+{
+ FIXME("%p, %s, %d.\n", iface, debugstr_a(infofile), type);
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_EndProcessServer(IDebugClient7 *iface,
ULONG64 server)
+{
+ FIXME("%p, %s.\n", iface, wine_dbgstr_longlong(server));
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_WaitForProcessServerEnd(IDebugClient7
*iface, ULONG timeout)
+{
+ FIXME("%p, %d.\n", iface, timeout);
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_IsKernelDebuggerEnabled(IDebugClient7
*iface)
+{
+ FIXME("%p.\n", iface);
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_TerminateCurrentProcess(IDebugClient7
*iface)
+{
+ FIXME("%p.\n", iface);
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_DetachCurrentProcess(IDebugClient7 *iface)
+{
+ FIXME("%p.\n", iface);
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_AbandonCurrentProcess(IDebugClient7 *iface)
+{
+ FIXME("%p.\n", iface);
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE
debugclient_GetRunningProcessSystemIdByExecutableNameWide(IDebugClient7 *iface, ULONG64
server,
+ const WCHAR *exename, ULONG flags, ULONG *id)
+{
+ FIXME("%p, %s, %s, 0x%08x, %p.\n", iface, wine_dbgstr_longlong(server),
debugstr_w(exename), flags, id);
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE
debugclient_GetRunningProcessDescriptionWide(IDebugClient7 *iface, ULONG64 server, ULONG
id,
+ ULONG flags, WCHAR *exename, ULONG size, ULONG *actualsize, WCHAR
*description, ULONG desc_size, ULONG *actual_desc_size)
+{
+ FIXME("%p, %s, %d, 0x%08x, %s, %d, %p, %s, %d, %p.\n", iface,
wine_dbgstr_longlong(server), id, flags, debugstr_w(exename), size,
+ actualsize, debugstr_w(description), desc_size, actual_desc_size );
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_CreateProcessWide(IDebugClient7 *iface,
ULONG64 server, WCHAR *commandline, ULONG flags)
+{
+ FIXME("%p, %s, %s, 0x%08x.\n", iface, wine_dbgstr_longlong(server),
debugstr_w(commandline), flags);
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_CreateProcessAndAttachWide(IDebugClient7
*iface, ULONG64 server, WCHAR *commandline,
+ ULONG flags, ULONG processid, ULONG attachflags)
+{
+ FIXME("%p, %s, %s, 0x%08x, %d, 0x%08x.\n", iface,
wine_dbgstr_longlong(server), debugstr_w(commandline), flags, processid, attachflags);
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_OpenDumpFileWide(IDebugClient7 *iface, const
WCHAR *filename, ULONG64 handle)
+{
+ FIXME("%p, %s, %s.\n", iface, debugstr_w(filename),
wine_dbgstr_longlong(handle));
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_WriteDumpFileWide(IDebugClient7 *iface,
const WCHAR *filename, ULONG64 handle,
+ ULONG qualifier, ULONG flags, const WCHAR *comment)
+{
+ FIXME("%p, %s, %s, %d, 0x%08x, %s.\n", iface, debugstr_w(filename),
wine_dbgstr_longlong(handle),
+ qualifier, flags, debugstr_w(comment));
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_AddDumpInformationFileWide(IDebugClient7
*iface, const WCHAR *filename,
+ ULONG64 handle, ULONG type)
+{
+ FIXME("%p, %s, %s, %d.\n", iface, debugstr_w(filename),
wine_dbgstr_longlong(handle), type);
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_GetNumberDumpFiles(IDebugClient7 *iface,
ULONG *count)
+{
+ FIXME("%p, %p.\n", iface, count);
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_GetDumpFile(IDebugClient7 *iface, ULONG
index, char *buffer, ULONG buf_size,
+ ULONG *name_size, ULONG64 *handle, ULONG *type)
+{
+ FIXME("%p, %d, %p, %d, %p, %p, %p.\n", iface, index, buffer, buf_size,
name_size, handle, type);
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_GetDumpFileWide(IDebugClient7 *iface, ULONG
index, WCHAR *buffer, ULONG buf_size,
+ ULONG *name_size, ULONG64 *handle, ULONG *type)
+{
+ FIXME("%p, %d, %p, %d, %p, %p, %p.\n", iface, index, buffer, buf_size,
name_size, handle, type);
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_AttachKernelWide(IDebugClient7 *iface, ULONG
flags, const WCHAR *options)
+{
+ FIXME("%p, 0x%08x, %s.\n", iface, flags, debugstr_w(options));
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_GetKernelConnectionOptionsWide(IDebugClient7
*iface, WCHAR *buffer,
+ ULONG buf_size, ULONG *size)
+{
+ FIXME("%p, %p, %d, %p.\n", iface, buffer, buf_size, size);
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_SetKernelConnectionOptionsWide(IDebugClient7
*iface, const WCHAR *options)
+{
+ FIXME("%p, %p.\n", iface, options);
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_StartProcessServerWide(IDebugClient7 *iface,
ULONG flags, const WCHAR *options, void *reserved)
+{
+ FIXME("%p, 0x%08x, %s, %p.\n", iface, flags, debugstr_w(options),
reserved);
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_ConnectProcessServerWide(IDebugClient7
*iface, const WCHAR *options, ULONG64 *server)
+{
+ FIXME("%p, %s, %p.\n", iface, debugstr_w(options), server);
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_StartServerWide(IDebugClient7 *iface, const
WCHAR *options)
+{
+ FIXME("%p, %s.\n", iface, debugstr_w(options));
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_OutputServersWide(IDebugClient7 *iface,
ULONG control, const WCHAR *machine, ULONG flags)
+{
+ FIXME("%p, %d, %s, 0x%08x.\n", iface, control, debugstr_w(machine),
flags);
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_GetOutputCallbacksWide(IDebugClient7 *iface,
IDebugOutputCallbacksWide **callbacks)
+{
+ FIXME("%p, %p.\n", iface, callbacks);
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_SetOutputCallbacksWide(IDebugClient7 *iface,
IDebugOutputCallbacksWide *callbacks)
+{
+ FIXME("%p, %p.\n", iface, callbacks);
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_GetOutputLinePrefixWide(IDebugClient7
*iface, WCHAR *buffer, ULONG buf_size, ULONG *size)
+{
+ FIXME("%p, %p, %d, %p.\n", iface, buffer, buf_size, size);
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_SetOutputLinePrefixWide(IDebugClient7
*iface, const WCHAR *prefix)
+{
+ FIXME("%p, %s.\n", iface, debugstr_w(prefix));
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_GetIdentityWide(IDebugClient7 *iface, WCHAR
*buffer, ULONG buf_size, ULONG *identity)
+{
+ FIXME("%p, %p, %d, %p.\n", iface, buffer, buf_size, identity);
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_OutputIdentityWide(IDebugClient7 *iface,
ULONG control, ULONG flags, const WCHAR *format)
+{
+ FIXME("%p, %d, 0x%08x, %s.\n", iface, control, flags, debugstr_w(format));
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_GetEventCallbacksWide(IDebugClient7 *iface,
IDebugEventCallbacksWide **callbacks)
+{
+ FIXME("%p, %p .\n", iface, callbacks);
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_SetEventCallbacksWide(IDebugClient7 *iface,
IDebugEventCallbacksWide *callbacks)
+{
+ FIXME("%p .\n", iface);
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_CreateProcess2(IDebugClient7 *iface, ULONG64
server, char *command, void *options,
+ ULONG buf_size, const char *initial, const char *environment)
+{
+ FIXME("%p %s, %s, %p, %d, %s, %s.\n", iface, wine_dbgstr_longlong(server),
debugstr_a(command), options,
+ buf_size, debugstr_a(initial), debugstr_a(environment));
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_CreateProcess2Wide(IDebugClient7 *iface,
ULONG64 server, WCHAR *command, void *options,
+ ULONG size, const WCHAR *initial, const WCHAR *environment)
+{
+ FIXME("%p %s, %s, %p, %d, %s, %s.\n", iface, wine_dbgstr_longlong(server),
debugstr_w(command), options,
+ size, debugstr_w(initial), debugstr_w(environment));
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_CreateProcessAndAttach2(IDebugClient7
*iface, ULONG64 server, char *command,
+ void *options, ULONG buf_size, const char *initial, const char *environment,
ULONG processid, ULONG flags)
+{
+ FIXME("%p %s, %s, %p, %d, %s, %s, %d, 0x%08x.\n", iface,
wine_dbgstr_longlong(server), debugstr_a(command), options,
+ buf_size, debugstr_a(initial), debugstr_a(environment), processid, flags);
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_CreateProcessAndAttach2Wide(IDebugClient7
*iface, ULONG64 server, WCHAR *command,
+ void *buffer, ULONG buf_size, const WCHAR *initial, const WCHAR *environment,
ULONG processid, ULONG flags)
+{
+ FIXME("%p %s, %s, %p, %d, %s, %s, %d, 0x%08x.\n", iface,
wine_dbgstr_longlong(server), debugstr_w(command), buffer,
+ buf_size, debugstr_w(initial), debugstr_w(environment), processid, flags);
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_PushOutputLinePrefix(IDebugClient7 *iface,
const char *prefix, ULONG64 *handle)
+{
+ FIXME("%p, %p.\n", iface, handle);
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_PushOutputLinePrefixWide(IDebugClient7
*iface, const WCHAR *prefix, ULONG64 *handle)
+{
+ FIXME("%p, %p.\n", iface, handle);
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_PopOutputLinePrefix(IDebugClient7 *iface,
ULONG64 handle)
+{
+ FIXME("%p, %s.\n", iface, wine_dbgstr_longlong(handle));
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_GetNumberInputCallbacks(IDebugClient7
*iface, ULONG *count)
+{
+ FIXME("%p, %p.\n", iface, count);
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_GetNumberOutputCallbacks(IDebugClient7
*iface, ULONG *count)
+{
+ FIXME("%p, %p.\n", iface, count);
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_GetNumberEventCallbacks(IDebugClient7
*iface, ULONG flags, ULONG *count)
+{
+ FIXME("%p, 0x%08x, %p.\n", iface, flags, count);
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_GetQuitLockString(IDebugClient7 *iface, char
*buffer, ULONG buf_size, ULONG *size)
+{
+ FIXME("%p, %s, %d, %p.\n", iface, debugstr_a(buffer), buf_size, size);
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_SetQuitLockString(IDebugClient7 *iface, char
*string)
+{
+ FIXME("%p, %s.\n", iface, debugstr_a(string));
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_GetQuitLockStringWide(IDebugClient7 *iface,
WCHAR *buffer, ULONG buf_size, ULONG *size)
+{
+ FIXME("%p, %s, %d, %p.\n", iface, debugstr_w(buffer), buf_size, size);
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_SetQuitLockStringWide(IDebugClient7 *iface,
const WCHAR *string)
+{
+ FIXME("%p, %s.\n", iface, debugstr_w(string));
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_SetEventContextCallbacks(IDebugClient7
*iface, IDebugEventContextCallbacks *callbacks)
+{
+ FIXME("%p, %p.\n", iface, callbacks);
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugclient_SetClientContext(IDebugClient7 *iface, void
*context, ULONG size)
+{
+ FIXME("%p, %p, %d.\n", iface, context, size);
+ return E_NOTIMPL;
+}
+
+static const IDebugClient7Vtbl debugclientvtbl =
+{
+ debugclient_QueryInterface,
+ debugclient_AddRef,
+ debugclient_Release,
+ debugclient_AttachKernel,
+ debugclient_GetKernelConnectionOptions,
+ debugclient_SetKernelConnectionOptions,
+ debugclient_StartProcessServer,
+ debugclient_ConnectProcessServer,
+ debugclient_DisconnectProcessServer,
+ debugclient_GetRunningProcessSystemIds,
+ debugclient_GetRunningProcessSystemIdByExecutableName,
+ debugclient_GetRunningProcessDescription,
+ debugclient_AttachProcess,
+ debugclient_CreateProcess,
+ debugclient_CreateProcessAndAttach,
+ debugclient_GetProcessOptions,
+ debugclient_AddProcessOptions,
+ debugclient_RemoveProcessOptions,
+ debugclient_SetProcessOptions,
+ debugclient_OpenDumpFile,
+ debugclient_WriteDumpFile,
+ debugclient_ConnectSession,
+ debugclient_StartServer,
+ debugclient_OutputServers,
+ debugclient_TerminateProcesses,
+ debugclient_DetachProcesses,
+ debugclient_EndSession,
+ debugclient_GetExitCode,
+ debugclient_DispatchCallbacks,
+ debugclient_ExitDispatch,
+ debugclient_CreateClient,
+ debugclient_GetInputCallbacks,
+ debugclient_SetInputCallbacks,
+ debugclient_GetOutputCallbacks,
+ debugclient_SetOutputCallbacks,
+ debugclient_GetOutputMask,
+ debugclient_SetOutputMask,
+ debugclient_GetOtherOutputMask,
+ debugclient_SetOtherOutputMask,
+ debugclient_GetOutputWidth,
+ debugclient_SetOutputWidth,
+ debugclient_GetOutputLinePrefix,
+ debugclient_SetOutputLinePrefix,
+ debugclient_GetIdentity,
+ debugclient_OutputIdentity,
+ debugclient_GetEventCallbacks,
+ debugclient_SetEventCallbacks,
+ debugclient_FlushCallbacks,
+ /* IDebugClient2 */
+ debugclient_WriteDumpFile2,
+ debugclient_AddDumpInformationFile,
+ debugclient_EndProcessServer,
+ debugclient_WaitForProcessServerEnd,
+ debugclient_IsKernelDebuggerEnabled,
+ debugclient_TerminateCurrentProcess,
+ debugclient_DetachCurrentProcess,
+ debugclient_AbandonCurrentProcess,
+ /* IDebugClient3 */
+ debugclient_GetRunningProcessSystemIdByExecutableNameWide,
+ debugclient_GetRunningProcessDescriptionWide,
+ debugclient_CreateProcessWide,
+ debugclient_CreateProcessAndAttachWide,
+ /* IDebugClient4 */
+ debugclient_OpenDumpFileWide,
+ debugclient_WriteDumpFileWide,
+ debugclient_AddDumpInformationFileWide,
+ debugclient_GetNumberDumpFiles,
+ debugclient_GetDumpFile,
+ debugclient_GetDumpFileWide,
+ /* IDebugClient5 */
+ debugclient_AttachKernelWide,
+ debugclient_GetKernelConnectionOptionsWide,
+ debugclient_SetKernelConnectionOptionsWide,
+ debugclient_StartProcessServerWide,
+ debugclient_ConnectProcessServerWide,
+ debugclient_StartServerWide,
+ debugclient_OutputServersWide,
+ debugclient_GetOutputCallbacksWide,
+ debugclient_SetOutputCallbacksWide,
+ debugclient_GetOutputLinePrefixWide,
+ debugclient_SetOutputLinePrefixWide,
+ debugclient_GetIdentityWide,
+ debugclient_OutputIdentityWide,
+ debugclient_GetEventCallbacksWide,
+ debugclient_SetEventCallbacksWide,
+ debugclient_CreateProcess2,
+ debugclient_CreateProcess2Wide,
+ debugclient_CreateProcessAndAttach2,
+ debugclient_CreateProcessAndAttach2Wide,
+ debugclient_PushOutputLinePrefix,
+ debugclient_PushOutputLinePrefixWide,
+ debugclient_PopOutputLinePrefix,
+ debugclient_GetNumberInputCallbacks,
+ debugclient_GetNumberOutputCallbacks,
+ debugclient_GetNumberEventCallbacks,
+ debugclient_GetQuitLockString,
+ debugclient_SetQuitLockString,
+ debugclient_GetQuitLockStringWide,
+ debugclient_SetQuitLockStringWide,
+ /* IDebugClient6 */
+ debugclient_SetEventContextCallbacks,
+ /* IDebugClient7 */
+ debugclient_SetClientContext,
+};
+
+static HRESULT STDMETHODCALLTYPE debugdataspaces_QueryInterface(IDebugDataSpaces *iface,
REFIID riid, void **obj)
+{
+ struct debug_client *debug_client = impl_from_IDebugDataSpaces(iface);
+ IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
+ return IUnknown_QueryInterface(unk, riid, obj);
+}
+
+static ULONG STDMETHODCALLTYPE debugdataspaces_AddRef(IDebugDataSpaces *iface)
+{
+ struct debug_client *debug_client = impl_from_IDebugDataSpaces(iface);
+ IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
+ return IUnknown_AddRef(unk);
+}
+
+static ULONG STDMETHODCALLTYPE debugdataspaces_Release(IDebugDataSpaces *iface)
+{
+ struct debug_client *debug_client = impl_from_IDebugDataSpaces(iface);
+ IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
+ return IUnknown_Release(unk);
+}
+
+static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadVirtual(IDebugDataSpaces *iface,
ULONG64 offset, void *buffer,
+ ULONG buffer_size, ULONG *read_len)
+{
+ struct debug_client *debug_client = impl_from_IDebugDataSpaces(iface);
+ static struct target_process *target;
+ HRESULT hr = S_OK;
+ SIZE_T length;
+
+ TRACE("%p, %s, %p, %u, %p.\n", iface, wine_dbgstr_longlong(offset), buffer,
buffer_size, read_len);
+
+ if (!(target = debug_client_get_target(debug_client)))
+ return E_UNEXPECTED;
+
+ if (ReadProcessMemory(target->handle, (const void *)(ULONG_PTR)offset, buffer,
buffer_size, &length))
+ {
+ if (read_len)
+ *read_len = length;
+ }
+ else
+ {
+ hr = HRESULT_FROM_WIN32(GetLastError());
+ WARN("Failed to read process memory %#x.\n", hr);
+ }
+
+ return hr;
+}
+
+static HRESULT STDMETHODCALLTYPE debugdataspaces_WriteVirtual(IDebugDataSpaces *iface,
ULONG64 offset, void *buffer,
+ ULONG buffer_size, ULONG *written)
+{
+ FIXME("%p, %s, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset),
buffer, buffer_size, written);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugdataspaces_SearchVirtual(IDebugDataSpaces *iface,
ULONG64 offset, ULONG64 length,
+ void *pattern, ULONG pattern_size, ULONG pattern_granularity, ULONG64
*ret_offset)
+{
+ FIXME("%p, %s, %s, %p, %u, %u, %p stub.\n", iface,
wine_dbgstr_longlong(offset), wine_dbgstr_longlong(length),
+ pattern, pattern_size, pattern_granularity, ret_offset);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadVirtualUncached(IDebugDataSpaces
*iface, ULONG64 offset,
+ void *buffer, ULONG buffer_size, ULONG *read_len)
+{
+ FIXME("%p, %s, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset),
buffer, buffer_size, read_len);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugdataspaces_WriteVirtualUncached(IDebugDataSpaces
*iface, ULONG64 offset,
+ void *buffer, ULONG buffer_size, ULONG *written)
+{
+ FIXME("%p, %s, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset),
buffer, buffer_size, written);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadPointersVirtual(IDebugDataSpaces
*iface, ULONG count,
+ ULONG64 offset, ULONG64 *pointers)
+{
+ FIXME("%p, %u, %s, %p stub.\n", iface, count, wine_dbgstr_longlong(offset),
pointers);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugdataspaces_WritePointersVirtual(IDebugDataSpaces
*iface, ULONG count,
+ ULONG64 offset, ULONG64 *pointers)
+{
+ FIXME("%p, %u, %s, %p stub.\n", iface, count, wine_dbgstr_longlong(offset),
pointers);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadPhysical(IDebugDataSpaces *iface,
ULONG64 offset, void *buffer,
+ ULONG buffer_size, ULONG *read_len)
+{
+ FIXME("%p, %s, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset),
buffer, buffer_size, read_len);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugdataspaces_WritePhysical(IDebugDataSpaces *iface,
ULONG64 offset, void *buffer,
+ ULONG buffer_size, ULONG *written)
+{
+ FIXME("%p, %s, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(offset),
buffer, buffer_size, written);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadControl(IDebugDataSpaces *iface,
ULONG processor, ULONG64 offset,
+ void *buffer, ULONG buffer_size, ULONG *read_len)
+{
+ FIXME("%p, %u, %s, %p, %u, %p stub.\n", iface, processor,
wine_dbgstr_longlong(offset), buffer, buffer_size, read_len);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugdataspaces_WriteControl(IDebugDataSpaces *iface,
ULONG processor, ULONG64 offset,
+ void *buffer, ULONG buffer_size, ULONG *written)
+{
+ FIXME("%p, %u, %s, %p, %u, %p stub.\n", iface, processor,
wine_dbgstr_longlong(offset), buffer, buffer_size, written);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadIo(IDebugDataSpaces *iface, ULONG
type, ULONG bus_number,
+ ULONG address_space, ULONG64 offset, void *buffer, ULONG buffer_size, ULONG
*read_len)
+{
+ FIXME("%p, %u, %u, %u, %s, %p, %u, %p stub.\n", iface, type, bus_number,
address_space, wine_dbgstr_longlong(offset),
+ buffer, buffer_size, read_len);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugdataspaces_WriteIo(IDebugDataSpaces *iface, ULONG
type, ULONG bus_number,
+ ULONG address_space, ULONG64 offset, void *buffer, ULONG buffer_size, ULONG
*written)
+{
+ FIXME("%p, %u, %u, %u, %s, %p, %u, %p stub.\n", iface, type, bus_number,
address_space, wine_dbgstr_longlong(offset),
+ buffer, buffer_size, written);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadMsr(IDebugDataSpaces *iface, ULONG
msr, ULONG64 *value)
+{
+ FIXME("%p, %u, %p stub.\n", iface, msr, value);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugdataspaces_WriteMsr(IDebugDataSpaces *iface, ULONG
msr, ULONG64 value)
+{
+ FIXME("%p, %u, %s stub.\n", iface, msr, wine_dbgstr_longlong(value));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadBusData(IDebugDataSpaces *iface,
ULONG data_type,
+ ULONG bus_number, ULONG slot_number, ULONG offset, void *buffer, ULONG
buffer_size, ULONG *read_len)
+{
+ FIXME("%p, %u, %u, %u, %u, %p, %u, %p stub.\n", iface, data_type,
bus_number, slot_number, offset, buffer,
+ buffer_size, read_len);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugdataspaces_WriteBusData(IDebugDataSpaces *iface,
ULONG data_type,
+ ULONG bus_number, ULONG slot_number, ULONG offset, void *buffer, ULONG
buffer_size, ULONG *written)
+{
+ FIXME("%p, %u, %u, %u, %u, %p, %u, %p stub.\n", iface, data_type,
bus_number, slot_number, offset, buffer,
+ buffer_size, written);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugdataspaces_CheckLowMemory(IDebugDataSpaces *iface)
+{
+ FIXME("%p stub.\n", iface);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadDebuggerData(IDebugDataSpaces
*iface, ULONG index, void *buffer,
+ ULONG buffer_size, ULONG *data_size)
+{
+ FIXME("%p, %u, %p, %u, %p stub.\n", iface, index, buffer, buffer_size,
data_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugdataspaces_ReadProcessorSystemData(IDebugDataSpaces
*iface, ULONG processor,
+ ULONG index, void *buffer, ULONG buffer_size, ULONG *data_size)
+{
+ FIXME("%p, %u, %u, %p, %u, %p stub.\n", iface, processor, index, buffer,
buffer_size, data_size);
+
+ return E_NOTIMPL;
+}
+
+static const IDebugDataSpacesVtbl debugdataspacesvtbl =
+{
+ debugdataspaces_QueryInterface,
+ debugdataspaces_AddRef,
+ debugdataspaces_Release,
+ debugdataspaces_ReadVirtual,
+ debugdataspaces_WriteVirtual,
+ debugdataspaces_SearchVirtual,
+ debugdataspaces_ReadVirtualUncached,
+ debugdataspaces_WriteVirtualUncached,
+ debugdataspaces_ReadPointersVirtual,
+ debugdataspaces_WritePointersVirtual,
+ debugdataspaces_ReadPhysical,
+ debugdataspaces_WritePhysical,
+ debugdataspaces_ReadControl,
+ debugdataspaces_WriteControl,
+ debugdataspaces_ReadIo,
+ debugdataspaces_WriteIo,
+ debugdataspaces_ReadMsr,
+ debugdataspaces_WriteMsr,
+ debugdataspaces_ReadBusData,
+ debugdataspaces_WriteBusData,
+ debugdataspaces_CheckLowMemory,
+ debugdataspaces_ReadDebuggerData,
+ debugdataspaces_ReadProcessorSystemData,
+};
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_QueryInterface(IDebugSymbols3 *iface,
REFIID riid, void **obj)
+{
+ struct debug_client *debug_client = impl_from_IDebugSymbols3(iface);
+ IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
+ return IUnknown_QueryInterface(unk, riid, obj);
+}
+
+static ULONG STDMETHODCALLTYPE debugsymbols_AddRef(IDebugSymbols3 *iface)
+{
+ struct debug_client *debug_client = impl_from_IDebugSymbols3(iface);
+ IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
+ return IUnknown_AddRef(unk);
+}
+
+static ULONG STDMETHODCALLTYPE debugsymbols_Release(IDebugSymbols3 *iface)
+{
+ struct debug_client *debug_client = impl_from_IDebugSymbols3(iface);
+ IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
+ return IUnknown_Release(unk);
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolOptions(IDebugSymbols3 *iface,
ULONG *options)
+{
+ FIXME("%p, %p stub.\n", iface, options);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_AddSymbolOptions(IDebugSymbols3 *iface,
ULONG options)
+{
+ FIXME("%p, %#x stub.\n", iface, options);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_RemoveSymbolOptions(IDebugSymbols3 *iface,
ULONG options)
+{
+ FIXME("%p, %#x stub.\n", iface, options);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_SetSymbolOptions(IDebugSymbols3 *iface,
ULONG options)
+{
+ FIXME("%p, %#x stub.\n", iface, options);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetNameByOffset(IDebugSymbols3 *iface,
ULONG64 offset, char *buffer,
+ ULONG buffer_size, ULONG *name_size, ULONG64 *displacement)
+{
+ FIXME("%p, %s, %p, %u, %p, %p stub.\n", iface,
wine_dbgstr_longlong(offset), buffer, buffer_size,
+ name_size, displacement);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetOffsetByName(IDebugSymbols3 *iface,
const char *symbol,
+ ULONG64 *offset)
+{
+ FIXME("%p, %s, %p stub.\n", iface, debugstr_a(symbol), offset);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetNearNameByOffset(IDebugSymbols3 *iface,
ULONG64 offset, LONG delta,
+ char *buffer, ULONG buffer_size, ULONG *name_size, ULONG64 *displacement)
+{
+ FIXME("%p, %s, %d, %p, %u, %p, %p stub.\n", iface,
wine_dbgstr_longlong(offset), delta, buffer, buffer_size,
+ name_size, displacement);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetLineByOffset(IDebugSymbols3 *iface,
ULONG64 offset, ULONG *line,
+ char *buffer, ULONG buffer_size, ULONG *file_size, ULONG64 *displacement)
+{
+ FIXME("%p, %s, %p, %p, %u, %p, %p stub.\n", iface,
wine_dbgstr_longlong(offset), line, buffer, buffer_size,
+ file_size, displacement);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetOffsetByLine(IDebugSymbols3 *iface,
ULONG line, const char *file,
+ ULONG64 *offset)
+{
+ FIXME("%p, %u, %s, %p stub.\n", iface, line, debugstr_a(file), offset);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetNumberModules(IDebugSymbols3 *iface,
ULONG *loaded, ULONG *unloaded)
+{
+ struct debug_client *debug_client = impl_from_IDebugSymbols3(iface);
+ static struct target_process *target;
+ HRESULT hr;
+
+ TRACE("%p, %p, %p.\n", iface, loaded, unloaded);
+
+ if (!(target = debug_client_get_target(debug_client)))
+ return E_UNEXPECTED;
+
+ if (FAILED(hr = debug_target_init_modules_info(target)))
+ return hr;
+
+ *loaded = target->modules.loaded;
+ *unloaded = target->modules.unloaded;
+
+ return S_OK;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleByIndex(IDebugSymbols3 *iface,
ULONG index, ULONG64 *base)
+{
+ struct debug_client *debug_client = impl_from_IDebugSymbols3(iface);
+ const struct module_info *info;
+ struct target_process *target;
+
+ TRACE("%p, %u, %p.\n", iface, index, base);
+
+ if (!(target = debug_client_get_target(debug_client)))
+ return E_UNEXPECTED;
+
+ if (!(info = debug_target_get_module_info(target, index)))
+ return E_INVALIDARG;
+
+ *base = info->params.Base;
+
+ return S_OK;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleByModuleName(IDebugSymbols3
*iface, const char *name,
+ ULONG start_index, ULONG *index, ULONG64 *base)
+{
+ FIXME("%p, %s, %u, %p, %p stub.\n", iface, debugstr_a(name), start_index,
index, base);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleByOffset(IDebugSymbols3 *iface,
ULONG64 offset,
+ ULONG start_index, ULONG *index, ULONG64 *base)
+{
+ struct debug_client *debug_client = impl_from_IDebugSymbols3(iface);
+ static struct target_process *target;
+ const struct module_info *info;
+
+ TRACE("%p, %s, %u, %p, %p.\n", iface, wine_dbgstr_longlong(offset),
start_index, index, base);
+
+ if (!(target = debug_client_get_target(debug_client)))
+ return E_UNEXPECTED;
+
+ while ((info = debug_target_get_module_info(target, start_index)))
+ {
+ if (offset >= info->params.Base && offset < info->params.Base
+ info->params.Size)
+ {
+ if (index)
+ *index = start_index;
+ if (base)
+ *base = info->params.Base;
+ return S_OK;
+ }
+
+ start_index++;
+ }
+
+ return E_INVALIDARG;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleNames(IDebugSymbols3 *iface, ULONG
index, ULONG64 base,
+ char *image_name, ULONG image_name_buffer_size, ULONG *image_name_size, char
*module_name,
+ ULONG module_name_buffer_size, ULONG *module_name_size, char *loaded_image_name,
+ ULONG loaded_image_name_buffer_size, ULONG *loaded_image_size)
+{
+ FIXME("%p, %u, %s, %p, %u, %p, %p, %u, %p, %p, %u, %p stub.\n", iface,
index, wine_dbgstr_longlong(base),
+ image_name, image_name_buffer_size, image_name_size, module_name,
module_name_buffer_size,
+ module_name_size, loaded_image_name, loaded_image_name_buffer_size,
loaded_image_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleParameters(IDebugSymbols3 *iface,
ULONG count, ULONG64 *bases,
+ ULONG start, DEBUG_MODULE_PARAMETERS *params)
+{
+ struct debug_client *debug_client = impl_from_IDebugSymbols3(iface);
+ const struct module_info *info;
+ struct target_process *target;
+ unsigned int i;
+
+ TRACE("%p, %u, %p, %u, %p.\n", iface, count, bases, start, params);
+
+ if (!(target = debug_client_get_target(debug_client)))
+ return E_UNEXPECTED;
+
+ if (bases)
+ {
+ for (i = 0; i < count; ++i)
+ {
+ if ((info = debug_target_get_module_info_by_base(target, bases[i])))
+ {
+ params[i] = info->params;
+ }
+ else
+ {
+ memset(¶ms[i], 0, sizeof(*params));
+ params[i].Base = DEBUG_INVALID_OFFSET;
+ }
+ }
+ }
+ else
+ {
+ for (i = start; i < start + count; ++i)
+ {
+ if (!(info = debug_target_get_module_info(target, i)))
+ return E_INVALIDARG;
+ params[i] = info->params;
+ }
+ }
+
+ return S_OK;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolModule(IDebugSymbols3 *iface,
const char *symbol, ULONG64 *base)
+{
+ FIXME("%p, %s, %p stub.\n", iface, debugstr_a(symbol), base);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetTypeName(IDebugSymbols3 *iface, ULONG64
base, ULONG type_id,
+ char *buffer, ULONG buffer_size, ULONG *name_size)
+{
+ FIXME("%p, %s, %u, %p, %u, %p stub.\n", iface, wine_dbgstr_longlong(base),
type_id, buffer,
+ buffer_size, name_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetTypeId(IDebugSymbols3 *iface, ULONG64
base, const char *name,
+ ULONG *type_id)
+{
+ FIXME("%p, %s, %s, %p stub.\n", iface, wine_dbgstr_longlong(base),
debugstr_a(name), type_id);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetTypeSize(IDebugSymbols3 *iface, ULONG64
base, ULONG type_id,
+ ULONG *size)
+{
+ FIXME("%p, %s, %u, %p stub.\n", iface, wine_dbgstr_longlong(base), type_id,
size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetFieldOffset(IDebugSymbols3 *iface,
ULONG64 base, ULONG type_id,
+ const char *field, ULONG *offset)
+{
+ FIXME("%p, %s, %u, %s, %p stub.\n", iface, wine_dbgstr_longlong(base),
type_id, debugstr_a(field), offset);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolTypeId(IDebugSymbols3 *iface,
const char *symbol, ULONG *type_id,
+ ULONG64 *base)
+{
+ FIXME("%p, %s, %p, %p stub.\n", iface, debugstr_a(symbol), type_id, base);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetOffsetTypeId(IDebugSymbols3 *iface,
ULONG64 offset, ULONG *type_id,
+ ULONG64 *base)
+{
+ FIXME("%p, %s, %p, %p stub.\n", iface, wine_dbgstr_longlong(offset),
type_id, base);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_ReadTypedDataVirtual(IDebugSymbols3 *iface,
ULONG64 offset, ULONG64 base,
+ ULONG type_id, void *buffer, ULONG buffer_size, ULONG *read_len)
+{
+ FIXME("%p, %s, %s, %u, %p, %u, %p stub.\n", iface,
wine_dbgstr_longlong(offset), wine_dbgstr_longlong(base),
+ type_id, buffer, buffer_size, read_len);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_WriteTypedDataVirtual(IDebugSymbols3
*iface, ULONG64 offset, ULONG64 base,
+ ULONG type_id, void *buffer, ULONG buffer_size, ULONG *written)
+{
+ FIXME("%p, %s, %s, %u, %p, %u, %p stub.\n", iface,
wine_dbgstr_longlong(offset), wine_dbgstr_longlong(base),
+ type_id, buffer, buffer_size, written);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_OutputTypedDataVirtual(IDebugSymbols3
*iface, ULONG output_control,
+ ULONG64 offset, ULONG64 base, ULONG type_id, ULONG flags)
+{
+ FIXME("%p, %#x, %s, %s, %u, %#x stub.\n", iface, output_control,
wine_dbgstr_longlong(offset),
+ wine_dbgstr_longlong(base), type_id, flags);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_ReadTypedDataPhysical(IDebugSymbols3
*iface, ULONG64 offset, ULONG64 base,
+ ULONG type_id, void *buffer, ULONG buffer_size, ULONG *read_len)
+{
+ FIXME("%p, %s, %s, %u, %p, %u, %p stub.\n", iface,
wine_dbgstr_longlong(offset), wine_dbgstr_longlong(base),
+ type_id, buffer, buffer_size, read_len);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_WriteTypedDataPhysical(IDebugSymbols3
*iface, ULONG64 offset,
+ ULONG64 base, ULONG type_id, void *buffer, ULONG buffer_size, ULONG *written)
+{
+ FIXME("%p, %s, %s, %u, %p, %u, %p stub.\n", iface,
wine_dbgstr_longlong(offset), wine_dbgstr_longlong(base),
+ type_id, buffer, buffer_size, written);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_OutputTypedDataPhysical(IDebugSymbols3
*iface, ULONG output_control,
+ ULONG64 offset, ULONG64 base, ULONG type_id, ULONG flags)
+{
+ FIXME("%p, %#x, %s, %s, %u, %#x stub.\n", iface, output_control,
wine_dbgstr_longlong(offset),
+ wine_dbgstr_longlong(base), type_id, flags);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetScope(IDebugSymbols3 *iface, ULONG64
*instr_offset,
+ DEBUG_STACK_FRAME *frame, void *scope_context, ULONG scope_context_size)
+{
+ FIXME("%p, %p, %p, %p, %u stub.\n", iface, instr_offset, frame,
scope_context, scope_context_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_SetScope(IDebugSymbols3 *iface, ULONG64
instr_offset,
+ DEBUG_STACK_FRAME *frame, void *scope_context, ULONG scope_context_size)
+{
+ FIXME("%p, %s, %p, %p, %u stub.\n", iface,
wine_dbgstr_longlong(instr_offset), frame, scope_context,
+ scope_context_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_ResetScope(IDebugSymbols3 *iface)
+{
+ FIXME("%p stub.\n", iface);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetScopeSymbolGroup(IDebugSymbols3 *iface,
ULONG flags,
+ IDebugSymbolGroup *update, IDebugSymbolGroup **symbols)
+{
+ FIXME("%p, %#x, %p, %p stub.\n", iface, flags, update, symbols);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_CreateSymbolGroup(IDebugSymbols3 *iface,
IDebugSymbolGroup **group)
+{
+ FIXME("%p, %p stub.\n", iface, group);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_StartSymbolMatch(IDebugSymbols3 *iface,
const char *pattern,
+ ULONG64 *handle)
+{
+ FIXME("%p, %s, %p stub.\n", iface, pattern, handle);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetNextSymbolMatch(IDebugSymbols3 *iface,
ULONG64 handle, char *buffer,
+ ULONG buffer_size, ULONG *match_size, ULONG64 *offset)
+{
+ FIXME("%p, %s, %p, %u, %p, %p stub.\n", iface,
wine_dbgstr_longlong(handle), buffer, buffer_size, match_size, offset);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_EndSymbolMatch(IDebugSymbols3 *iface,
ULONG64 handle)
+{
+ FIXME("%p, %s stub.\n", iface, wine_dbgstr_longlong(handle));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_Reload(IDebugSymbols3 *iface, const char
*path)
+{
+ FIXME("%p, %s stub.\n", iface, debugstr_a(path));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolPath(IDebugSymbols3 *iface, char
*buffer, ULONG buffer_size,
+ ULONG *path_size)
+{
+ FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, path_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_SetSymbolPath(IDebugSymbols3 *iface, const
char *path)
+{
+ FIXME("%p, %s stub.\n", iface, debugstr_a(path));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_AppendSymbolPath(IDebugSymbols3 *iface,
const char *path)
+{
+ FIXME("%p, %s stub.\n", iface, debugstr_a(path));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetImagePath(IDebugSymbols3 *iface, char
*buffer, ULONG buffer_size,
+ ULONG *path_size)
+{
+ FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, path_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_SetImagePath(IDebugSymbols3 *iface, const
char *path)
+{
+ FIXME("%p, %s stub.\n", iface, debugstr_a(path));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_AppendImagePath(IDebugSymbols3 *iface,
const char *path)
+{
+ FIXME("%p, %s stub.\n", iface, debugstr_a(path));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourcePath(IDebugSymbols3 *iface, char
*buffer, ULONG buffer_size,
+ ULONG *path_size)
+{
+ FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, path_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourcePathElement(IDebugSymbols3 *iface,
ULONG index, char *buffer,
+ ULONG buffer_size, ULONG *element_size)
+{
+ FIXME("%p, %u, %p, %u, %p stub.\n", iface, index, buffer, buffer_size,
element_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_SetSourcePath(IDebugSymbols3 *iface, const
char *path)
+{
+ FIXME("%p, %s stub.\n", iface, debugstr_a(path));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_AppendSourcePath(IDebugSymbols3 *iface,
const char *path)
+{
+ FIXME("%p, %s stub.\n", iface, debugstr_a(path));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_FindSourceFile(IDebugSymbols3 *iface, ULONG
start, const char *file,
+ ULONG flags, ULONG *found_element, char *buffer, ULONG buffer_size, ULONG
*found_size)
+{
+ FIXME("%p, %u, %s, %#x, %p, %p, %u, %p stub.\n", iface, start,
debugstr_a(file), flags, found_element, buffer,
+ buffer_size, found_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceFileLineOffsets(IDebugSymbols3
*iface, const char *file,
+ ULONG64 *buffer, ULONG buffer_lines, ULONG *file_lines)
+{
+ FIXME("%p, %s, %p, %u, %p stub.\n", iface, debugstr_a(file), buffer,
buffer_lines, file_lines);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleVersionInformation(IDebugSymbols3
*iface, ULONG index,
+ ULONG64 base, const char *item, void *buffer, ULONG buffer_size, ULONG
*info_size)
+{
+ struct debug_client *debug_client = impl_from_IDebugSymbols3(iface);
+ const struct module_info *info;
+ struct target_process *target;
+ void *version_info, *ptr;
+ HRESULT hr = E_FAIL;
+ DWORD handle, size;
+
+ TRACE("%p, %u, %s, %s, %p, %u, %p.\n", iface, index,
wine_dbgstr_longlong(base), debugstr_a(item), buffer,
+ buffer_size, info_size);
+
+ if (!(target = debug_client_get_target(debug_client)))
+ return E_UNEXPECTED;
+
+ if (index == DEBUG_ANY_ID)
+ info = debug_target_get_module_info_by_base(target, base);
+ else
+ info = debug_target_get_module_info(target, index);
+
+ if (!info)
+ {
+ WARN("Was unable to locate module.\n");
+ return E_INVALIDARG;
+ }
+
+ if (!(size = GetFileVersionInfoSizeA(info->image_name, &handle)))
+ return E_FAIL;
+
+ if (!(version_info = heap_alloc(size)))
+ return E_OUTOFMEMORY;
+
+ if (GetFileVersionInfoA(info->image_name, handle, size, version_info))
+ {
+#ifdef __REACTOS__
+ if (VerQueryValueA(version_info, item, &ptr, (PUINT) &size))
+#else
+ if (VerQueryValueA(version_info, item, &ptr, &size))
+#endif
+ {
+ if (info_size)
+ *info_size = size;
+
+ if (buffer && buffer_size)
+ {
+ unsigned int dst_len = min(size, buffer_size);
+ if (dst_len)
+ memcpy(buffer, ptr, dst_len);
+ }
+
+ hr = buffer && buffer_size < size ? S_FALSE : S_OK;
+ }
+ }
+
+ heap_free(version_info);
+
+ return hr;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleNameString(IDebugSymbols3 *iface,
ULONG which, ULONG index,
+ ULONG64 base, char *buffer, ULONG buffer_size, ULONG *name_size)
+{
+ struct debug_client *debug_client = impl_from_IDebugSymbols3(iface);
+ const struct module_info *info;
+ struct target_process *target;
+ HRESULT hr;
+
+ TRACE("%p, %u, %u, %s, %p, %u, %p.\n", iface, which, index,
wine_dbgstr_longlong(base), buffer, buffer_size,
+ name_size);
+
+ if (!(target = debug_client_get_target(debug_client)))
+ return E_UNEXPECTED;
+
+ if (index == DEBUG_ANY_ID)
+ info = debug_target_get_module_info_by_base(target, base);
+ else
+ info = debug_target_get_module_info(target, index);
+
+ if (!info)
+ {
+ WARN("Was unable to locate module.\n");
+ return E_INVALIDARG;
+ }
+
+ switch (which)
+ {
+ case DEBUG_MODNAME_IMAGE:
+#ifdef __REACTOS__
+ hr = debug_target_return_string(info->image_name, buffer, buffer_size,
(UINT *) name_size);
+#else
+ hr = debug_target_return_string(info->image_name, buffer, buffer_size,
name_size);
+#endif
+ break;
+ case DEBUG_MODNAME_MODULE:
+ case DEBUG_MODNAME_LOADED_IMAGE:
+ case DEBUG_MODNAME_SYMBOL_FILE:
+ case DEBUG_MODNAME_MAPPED_IMAGE:
+ FIXME("Unsupported name info %d.\n", which);
+ return E_NOTIMPL;
+ default:
+ WARN("Unknown name info %d.\n", which);
+ return E_INVALIDARG;
+ }
+
+ return hr;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetConstantName(IDebugSymbols3 *iface,
ULONG64 module, ULONG type_id,
+ ULONG64 value, char *buffer, ULONG buffer_size, ULONG *name_size)
+{
+ FIXME("%p, %s, %u, %s, %p, %u, %p stub.\n", iface,
wine_dbgstr_longlong(module), type_id,
+ wine_dbgstr_longlong(value), buffer, buffer_size, name_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetFieldName(IDebugSymbols3 *iface, ULONG64
module, ULONG type_id,
+ ULONG field_index, char *buffer, ULONG buffer_size, ULONG *name_size)
+{
+ FIXME("%p, %s, %u, %u, %p, %u, %p stub.\n", iface,
wine_dbgstr_longlong(module), type_id, field_index, buffer,
+ buffer_size, name_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetTypeOptions(IDebugSymbols3 *iface, ULONG
*options)
+{
+ FIXME("%p, %p stub.\n", iface, options);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_AddTypeOptions(IDebugSymbols3 *iface, ULONG
options)
+{
+ FIXME("%p, %#x stub.\n", iface, options);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_RemoveTypeOptions(IDebugSymbols3 *iface,
ULONG options)
+{
+ FIXME("%p, %#x stub.\n", iface, options);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_SetTypeOptions(IDebugSymbols3 *iface, ULONG
options)
+{
+ FIXME("%p, %#x stub.\n", iface, options);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetNameByOffsetWide(IDebugSymbols3 *iface,
ULONG64 offset, WCHAR *buffer,
+ ULONG buffer_size, ULONG *name_size, ULONG64 *displacement)
+{
+ FIXME("%p, %s, %p, %u, %p, %p stub.\n", iface,
wine_dbgstr_longlong(offset), buffer, buffer_size, name_size,
+ displacement);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetOffsetByNameWide(IDebugSymbols3 *iface,
const WCHAR *symbol,
+ ULONG64 *offset)
+{
+ FIXME("%p, %s, %p stub.\n", iface, debugstr_w(symbol), offset);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetNearNameByOffsetWide(IDebugSymbols3
*iface, ULONG64 offset,
+ LONG delta, WCHAR *buffer, ULONG buffer_size, ULONG *name_size, ULONG64
*displacement)
+{
+ FIXME("%p, %s, %d, %p, %u, %p, %p stub.\n", iface,
wine_dbgstr_longlong(offset), delta, buffer, buffer_size,
+ name_size, displacement);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetLineByOffsetWide(IDebugSymbols3 *iface,
ULONG64 offset, ULONG *line,
+ WCHAR *buffer, ULONG buffer_size, ULONG *file_size, ULONG64 *displacement)
+{
+ FIXME("%p, %s, %p, %p, %u, %p, %p stub.\n", iface,
wine_dbgstr_longlong(offset), line, buffer, buffer_size,
+ file_size, displacement);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetOffsetByLineWide(IDebugSymbols3 *iface,
ULONG line, const WCHAR *file,
+ ULONG64 *offset)
+{
+ FIXME("%p, %u, %s, %p stub.\n", iface, line, debugstr_w(file), offset);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleByModuleNameWide(IDebugSymbols3
*iface, const WCHAR *name,
+ ULONG start_index, ULONG *index, ULONG64 *base)
+{
+ FIXME("%p, %s, %u, %p, %p stub.\n", iface, debugstr_w(name), start_index,
index, base);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolModuleWide(IDebugSymbols3 *iface,
const WCHAR *symbol,
+ ULONG64 *base)
+{
+ FIXME("%p, %s, %p stub.\n", iface, debugstr_w(symbol), base);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetTypeNameWide(IDebugSymbols3 *iface,
ULONG64 module, ULONG type_id,
+ WCHAR *buffer, ULONG buffer_size, ULONG *name_size)
+{
+ FIXME("%p, %s, %u, %p, %u, %p stub.\n", iface,
wine_dbgstr_longlong(module), type_id, buffer, buffer_size,
+ name_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetTypeIdWide(IDebugSymbols3 *iface,
ULONG64 module, const WCHAR *name,
+ ULONG *type_id)
+{
+ FIXME("%p, %s, %s, %p stub.\n", iface, wine_dbgstr_longlong(module),
debugstr_w(name), type_id);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetFieldOffsetWide(IDebugSymbols3 *iface,
ULONG64 module, ULONG type_id,
+ const WCHAR *field, ULONG *offset)
+{
+ FIXME("%p, %s, %u, %s, %p stub.\n", iface, wine_dbgstr_longlong(module),
type_id, debugstr_w(field), offset);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolTypeIdWide(IDebugSymbols3 *iface,
const WCHAR *symbol,
+ ULONG *type_id, ULONG64 *module)
+{
+ FIXME("%p, %s, %p, %p stub.\n", iface, debugstr_w(symbol), type_id,
module);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetScopeSymbolGroup2(IDebugSymbols3 *iface,
ULONG flags,
+ PDEBUG_SYMBOL_GROUP2 update, PDEBUG_SYMBOL_GROUP2 *symbols)
+{
+ FIXME("%p, %#x, %p, %p stub.\n", iface, flags, update, symbols);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_CreateSymbolGroup2(IDebugSymbols3 *iface,
PDEBUG_SYMBOL_GROUP2 *group)
+{
+ FIXME("%p, %p stub.\n", iface, group);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_StartSymbolMatchWide(IDebugSymbols3 *iface,
const WCHAR *pattern,
+ ULONG64 *handle)
+{
+ FIXME("%p, %s, %p stub.\n", iface, debugstr_w(pattern), handle);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetNextSymbolMatchWide(IDebugSymbols3
*iface, ULONG64 handle,
+ WCHAR *buffer, ULONG buffer_size, ULONG *match_size, ULONG64 *offset)
+{
+ FIXME("%p, %s, %p, %u, %p, %p stub.\n", iface,
wine_dbgstr_longlong(handle), buffer, buffer_size, match_size, offset);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_ReloadWide(IDebugSymbols3 *iface, const
WCHAR *module)
+{
+ FIXME("%p, %s stub.\n", iface, debugstr_w(module));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolPathWide(IDebugSymbols3 *iface,
WCHAR *buffer, ULONG buffer_size,
+ ULONG *path_size)
+{
+ FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, path_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_SetSymbolPathWide(IDebugSymbols3 *iface,
const WCHAR *path)
+{
+ FIXME("%p, %s stub.\n", iface, debugstr_w(path));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_AppendSymbolPathWide(IDebugSymbols3 *iface,
const WCHAR *addition)
+{
+ FIXME("%p, %s stub.\n", iface, debugstr_w(addition));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetImagePathWide(IDebugSymbols3 *iface,
WCHAR *buffer, ULONG buffer_size,
+ ULONG *path_size)
+{
+ FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, path_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_SetImagePathWide(IDebugSymbols3 *iface,
const WCHAR *path)
+{
+ FIXME("%p, %s stub.\n", iface, debugstr_w(path));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_AppendImagePathWide(IDebugSymbols3 *iface,
const WCHAR *addition)
+{
+ FIXME("%p, %s stub.\n", iface, debugstr_w(addition));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourcePathWide(IDebugSymbols3 *iface,
WCHAR *buffer, ULONG buffer_size,
+ ULONG *path_size)
+{
+ FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, path_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourcePathElementWide(IDebugSymbols3
*iface, ULONG index,
+ WCHAR *buffer, ULONG buffer_size, ULONG *element_size)
+{
+ FIXME("%p, %u, %p, %u, %p stub.\n", iface, index, buffer, buffer_size,
element_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_SetSourcePathWide(IDebugSymbols3 *iface,
const WCHAR *path)
+{
+ FIXME("%p, %s stub.\n", iface, debugstr_w(path));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_AppendSourcePathWide(IDebugSymbols3 *iface,
const WCHAR *addition)
+{
+ FIXME("%p, %s stub.\n", iface, debugstr_w(addition));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_FindSourceFileWide(IDebugSymbols3 *iface,
ULONG start_element,
+ const WCHAR *file, ULONG flags, ULONG *found_element, WCHAR *buffer, ULONG
buffer_size, ULONG *found_size)
+{
+ FIXME("%p, %u, %s, %#x, %p, %p, %u, %p stub.\n", iface, start_element,
debugstr_w(file), flags, found_element,
+ buffer, buffer_size, found_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceFileLineOffsetsWide(IDebugSymbols3
*iface, const WCHAR *file,
+ ULONG64 *buffer, ULONG buffer_lines, ULONG *file_lines)
+{
+ FIXME("%p, %s, %p, %u, %p stub.\n", iface, debugstr_w(file), buffer,
buffer_lines, file_lines);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE
debugsymbols_GetModuleVersionInformationWide(IDebugSymbols3 *iface, ULONG index,
+ ULONG64 base, const WCHAR *item, void *buffer, ULONG buffer_size, ULONG
*version_info_size)
+{
+ FIXME("%p, %u, %s, %s, %p, %u, %p stub.\n", iface, index,
wine_dbgstr_longlong(base), debugstr_w(item), buffer,
+ buffer_size, version_info_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleNameStringWide(IDebugSymbols3
*iface, ULONG which, ULONG index,
+ ULONG64 base, WCHAR *buffer, ULONG buffer_size, ULONG *name_size)
+{
+ FIXME("%p, %u, %u, %s, %p, %u, %p stub.\n", iface, which, index,
wine_dbgstr_longlong(base), buffer, buffer_size,
+ name_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetConstantNameWide(IDebugSymbols3 *iface,
ULONG64 module, ULONG type_id,
+ ULONG64 value, WCHAR *buffer, ULONG buffer_size, ULONG *name_size)
+{
+ FIXME("%p, %s, %u, %s, %p, %u, %p stub.\n", iface,
wine_dbgstr_longlong(module), type_id,
+ wine_dbgstr_longlong(value), buffer, buffer_size, name_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetFieldNameWide(IDebugSymbols3 *iface,
ULONG64 module, ULONG type_id,
+ ULONG field_index, WCHAR *buffer, ULONG buffer_size, ULONG *name_size)
+{
+ FIXME("%p, %s, %u, %u, %p, %u, %p stub.\n", iface,
wine_dbgstr_longlong(module), type_id, field_index, buffer,
+ buffer_size, name_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_IsManagedModule(IDebugSymbols3 *iface,
ULONG index, ULONG64 base)
+{
+ FIXME("%p, %u, %s stub.\n", iface, index, wine_dbgstr_longlong(base));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleByModuleName2(IDebugSymbols3
*iface, const char *name,
+ ULONG start_index, ULONG flags, ULONG *index, ULONG64 *base)
+{
+ FIXME("%p, %s, %u, %#x, %p, %p stub.\n", iface, debugstr_a(name),
start_index, flags, index, base);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleByModuleName2Wide(IDebugSymbols3
*iface, const WCHAR *name,
+ ULONG start_index, ULONG flags, ULONG *index, ULONG64 *base)
+{
+ FIXME("%p, %s, %u, %#x, %p, %p stub.\n", iface, debugstr_w(name),
start_index, flags, index, base);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetModuleByOffset2(IDebugSymbols3 *iface,
ULONG64 offset,
+ ULONG start_index, ULONG flags, ULONG *index, ULONG64 *base)
+{
+ FIXME("%p, %s, %u, %#x, %p, %p stub.\n", iface,
wine_dbgstr_longlong(offset), start_index, flags, index, base);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_AddSyntheticModule(IDebugSymbols3 *iface,
ULONG64 base, ULONG size,
+ const char *image_path, const char *module_name, ULONG flags)
+{
+ FIXME("%p, %s, %u, %s, %s, %#x stub.\n", iface, wine_dbgstr_longlong(base),
size, debugstr_a(image_path),
+ debugstr_a(module_name), flags);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_AddSyntheticModuleWide(IDebugSymbols3
*iface, ULONG64 base, ULONG size,
+ const WCHAR *image_path, const WCHAR *module_name, ULONG flags)
+{
+ FIXME("%p, %s, %u, %s, %s, %#x stub.\n", iface, wine_dbgstr_longlong(base),
size, debugstr_w(image_path),
+ debugstr_w(module_name), flags);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_RemoveSyntheticModule(IDebugSymbols3
*iface, ULONG64 base)
+{
+ FIXME("%p, %s stub.\n", iface, wine_dbgstr_longlong(base));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetCurrentScopeFrameIndex(IDebugSymbols3
*iface, ULONG *index)
+{
+ FIXME("%p, %p stub.\n", iface, index);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_SetScopeFrameByIndex(IDebugSymbols3 *iface,
ULONG index)
+{
+ FIXME("%p, %u stub.\n", iface, index);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_SetScopeFromJitDebugInfo(IDebugSymbols3
*iface, ULONG output_control,
+ ULONG64 info_offset)
+{
+ FIXME("%p, %u, %s stub.\n", iface, output_control,
wine_dbgstr_longlong(info_offset));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_SetScopeFromStoredEvent(IDebugSymbols3
*iface)
+{
+ FIXME("%p stub.\n", iface);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_OutputSymbolByOffset(IDebugSymbols3 *iface,
ULONG output_control,
+ ULONG flags, ULONG64 offset)
+{
+ FIXME("%p, %u, %#x, %s stub.\n", iface, output_control, flags,
wine_dbgstr_longlong(offset));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetFunctionEntryByOffset(IDebugSymbols3
*iface, ULONG64 offset,
+ ULONG flags, void *buffer, ULONG buffer_size, ULONG *needed_size)
+{
+ FIXME("%p, %s, %#x, %p, %u, %p stub.\n", iface,
wine_dbgstr_longlong(offset), flags, buffer, buffer_size,
+ needed_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetFieldTypeAndOffset(IDebugSymbols3
*iface, ULONG64 module,
+ ULONG container_type_id, const char *field, ULONG *field_type_id, ULONG *offset)
+{
+ FIXME("%p, %s, %u, %s, %p, %p stub.\n", iface,
wine_dbgstr_longlong(module), container_type_id, debugstr_a(field),
+ field_type_id, offset);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetFieldTypeAndOffsetWide(IDebugSymbols3
*iface, ULONG64 module,
+ ULONG container_type_id, const WCHAR *field, ULONG *field_type_id, ULONG
*offset)
+{
+ FIXME("%p, %s, %u, %s, %p, %p stub.\n", iface,
wine_dbgstr_longlong(module), container_type_id, debugstr_w(field),
+ field_type_id, offset);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_AddSyntheticSymbol(IDebugSymbols3 *iface,
ULONG64 offset, ULONG size,
+ const char *name, ULONG flags, DEBUG_MODULE_AND_ID *id)
+{
+ FIXME("%p, %s, %u, %s, %#x, %p stub.\n", iface,
wine_dbgstr_longlong(offset), size, debugstr_a(name), flags, id);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_AddSyntheticSymbolWide(IDebugSymbols3
*iface, ULONG64 offset, ULONG size,
+ const WCHAR *name, ULONG flags, DEBUG_MODULE_AND_ID *id)
+{
+ FIXME("%p, %s, %u, %s, %#x, %p stub.\n", iface,
wine_dbgstr_longlong(offset), size, debugstr_w(name), flags, id);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_RemoveSyntheticSymbol(IDebugSymbols3
*iface, DEBUG_MODULE_AND_ID *id)
+{
+ FIXME("%p, %p stub.\n", iface, id);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntriesByOffset(IDebugSymbols3
*iface, ULONG64 offset,
+ ULONG flags, DEBUG_MODULE_AND_ID *ids, LONG64 *displacements, ULONG count, ULONG
*entries)
+{
+ FIXME("%p, %s, %#x, %p, %p, %u, %p stub.\n", iface,
wine_dbgstr_longlong(offset), flags, ids, displacements, count,
+ entries);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntriesByName(IDebugSymbols3
*iface, const char *symbol,
+ ULONG flags, DEBUG_MODULE_AND_ID *ids, ULONG count, ULONG *entries)
+{
+ FIXME("%p, %s, %#x, %p, %u, %p stub.\n", iface, debugstr_a(symbol), flags,
ids, count, entries);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntriesByNameWide(IDebugSymbols3
*iface, const WCHAR *symbol,
+ ULONG flags, DEBUG_MODULE_AND_ID *ids, ULONG count, ULONG *entries)
+{
+ FIXME("%p, %s, %#x, %p, %u, %p stub.\n", iface, debugstr_w(symbol), flags,
ids, count, entries);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntryByToken(IDebugSymbols3
*iface, ULONG64 base, ULONG token,
+ DEBUG_MODULE_AND_ID *id)
+{
+ FIXME("%p, %s, %p stub.\n", iface, wine_dbgstr_longlong(base), id);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntryInformation(IDebugSymbols3
*iface, DEBUG_MODULE_AND_ID *id,
+ DEBUG_SYMBOL_ENTRY *info)
+{
+ FIXME("%p, %p, %p stub.\n", iface, id, info);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntryString(IDebugSymbols3 *iface,
DEBUG_MODULE_AND_ID *id,
+ ULONG which, char *buffer, ULONG buffer_size, ULONG *string_size)
+{
+ FIXME("%p, %p, %u, %p, %u, %p stub.\n", iface, id, which, buffer,
buffer_size, string_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntryStringWide(IDebugSymbols3
*iface, DEBUG_MODULE_AND_ID *id,
+ ULONG which, WCHAR *buffer, ULONG buffer_size, ULONG *string_size)
+{
+ FIXME("%p, %p, %u, %p, %u, %p stub.\n", iface, id, which, buffer,
buffer_size, string_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntryOffsetRegions(IDebugSymbols3
*iface, DEBUG_MODULE_AND_ID *id,
+ ULONG flags, DEBUG_OFFSET_REGION *regions, ULONG regions_count, ULONG
*regions_avail)
+{
+ FIXME("%p, %p, %#x, %p, %u, %p stub.\n", iface, id, flags, regions,
regions_count, regions_avail);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetSymbolEntryBySymbolEntry(IDebugSymbols3
*iface,
+ DEBUG_MODULE_AND_ID *from_id, ULONG flags, DEBUG_MODULE_AND_ID *to_id)
+{
+ FIXME("%p, %p, %#x, %p stub.\n", iface, from_id, flags, to_id);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceEntriesByOffset(IDebugSymbols3
*iface, ULONG64 offset,
+ ULONG flags, DEBUG_SYMBOL_SOURCE_ENTRY *entries, ULONG count, ULONG
*entries_avail)
+{
+ FIXME("%p, %s, %#x, %p, %u, %p stub.\n", iface,
wine_dbgstr_longlong(offset), flags, entries, count, entries_avail);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceEntriesByLine(IDebugSymbols3
*iface, ULONG line,
+ const char *file, ULONG flags, DEBUG_SYMBOL_SOURCE_ENTRY *entries, ULONG count,
ULONG *entries_avail)
+{
+ FIXME("%p, %s, %#x, %p, %u, %p stub.\n", iface, debugstr_a(file), flags,
entries, count, entries_avail);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceEntriesByLineWide(IDebugSymbols3
*iface, ULONG line,
+ const WCHAR *file, ULONG flags, DEBUG_SYMBOL_SOURCE_ENTRY *entries, ULONG count,
ULONG *entries_avail)
+{
+ FIXME("%p, %s, %#x, %p, %u, %p stub.\n", iface, debugstr_w(file), flags,
entries, count, entries_avail);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceEntryString(IDebugSymbols3
*iface,
+ DEBUG_SYMBOL_SOURCE_ENTRY *entry, ULONG which, char *buffer, ULONG buffer_size,
ULONG *string_size)
+{
+ FIXME("%p, %p, %u, %p, %u, %p stub.\n", iface, entry, which, buffer,
buffer_size, string_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceEntryStringWide(IDebugSymbols3
*iface,
+ DEBUG_SYMBOL_SOURCE_ENTRY *entry, ULONG which, WCHAR *buffer, ULONG buffer_size,
ULONG *string_size)
+{
+ FIXME("%p, %p, %u, %p, %u, %p stub.\n", iface, entry, which, buffer,
buffer_size, string_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceEntryOffsetRegions(IDebugSymbols3
*iface,
+ DEBUG_SYMBOL_SOURCE_ENTRY *entry, ULONG flags, DEBUG_OFFSET_REGION *regions,
ULONG count, ULONG *regions_avail)
+{
+ FIXME("%p, %p, %#x, %p, %u, %p stub.\n", iface, entry, flags, regions,
count, regions_avail);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsymbols_GetSourceEntryBySourceEntry(IDebugSymbols3
*iface,
+ DEBUG_SYMBOL_SOURCE_ENTRY *from_entry, ULONG flags, DEBUG_SYMBOL_SOURCE_ENTRY
*to_entry)
+{
+ FIXME("%p, %p, %#x, %p stub.\n", iface, from_entry, flags, to_entry);
+
+ return E_NOTIMPL;
+}
+
+static const IDebugSymbols3Vtbl debugsymbolsvtbl =
+{
+ debugsymbols_QueryInterface,
+ debugsymbols_AddRef,
+ debugsymbols_Release,
+ debugsymbols_GetSymbolOptions,
+ debugsymbols_AddSymbolOptions,
+ debugsymbols_RemoveSymbolOptions,
+ debugsymbols_SetSymbolOptions,
+ debugsymbols_GetNameByOffset,
+ debugsymbols_GetOffsetByName,
+ debugsymbols_GetNearNameByOffset,
+ debugsymbols_GetLineByOffset,
+ debugsymbols_GetOffsetByLine,
+ debugsymbols_GetNumberModules,
+ debugsymbols_GetModuleByIndex,
+ debugsymbols_GetModuleByModuleName,
+ debugsymbols_GetModuleByOffset,
+ debugsymbols_GetModuleNames,
+ debugsymbols_GetModuleParameters,
+ debugsymbols_GetSymbolModule,
+ debugsymbols_GetTypeName,
+ debugsymbols_GetTypeId,
+ debugsymbols_GetTypeSize,
+ debugsymbols_GetFieldOffset,
+ debugsymbols_GetSymbolTypeId,
+ debugsymbols_GetOffsetTypeId,
+ debugsymbols_ReadTypedDataVirtual,
+ debugsymbols_WriteTypedDataVirtual,
+ debugsymbols_OutputTypedDataVirtual,
+ debugsymbols_ReadTypedDataPhysical,
+ debugsymbols_WriteTypedDataPhysical,
+ debugsymbols_OutputTypedDataPhysical,
+ debugsymbols_GetScope,
+ debugsymbols_SetScope,
+ debugsymbols_ResetScope,
+ debugsymbols_GetScopeSymbolGroup,
+ debugsymbols_CreateSymbolGroup,
+ debugsymbols_StartSymbolMatch,
+ debugsymbols_GetNextSymbolMatch,
+ debugsymbols_EndSymbolMatch,
+ debugsymbols_Reload,
+ debugsymbols_GetSymbolPath,
+ debugsymbols_SetSymbolPath,
+ debugsymbols_AppendSymbolPath,
+ debugsymbols_GetImagePath,
+ debugsymbols_SetImagePath,
+ debugsymbols_AppendImagePath,
+ debugsymbols_GetSourcePath,
+ debugsymbols_GetSourcePathElement,
+ debugsymbols_SetSourcePath,
+ debugsymbols_AppendSourcePath,
+ debugsymbols_FindSourceFile,
+ debugsymbols_GetSourceFileLineOffsets,
+ /* IDebugSymbols2 */
+ debugsymbols_GetModuleVersionInformation,
+ debugsymbols_GetModuleNameString,
+ debugsymbols_GetConstantName,
+ debugsymbols_GetFieldName,
+ debugsymbols_GetTypeOptions,
+ debugsymbols_AddTypeOptions,
+ debugsymbols_RemoveTypeOptions,
+ debugsymbols_SetTypeOptions,
+ /* IDebugSymbols3 */
+ debugsymbols_GetNameByOffsetWide,
+ debugsymbols_GetOffsetByNameWide,
+ debugsymbols_GetNearNameByOffsetWide,
+ debugsymbols_GetLineByOffsetWide,
+ debugsymbols_GetOffsetByLineWide,
+ debugsymbols_GetModuleByModuleNameWide,
+ debugsymbols_GetSymbolModuleWide,
+ debugsymbols_GetTypeNameWide,
+ debugsymbols_GetTypeIdWide,
+ debugsymbols_GetFieldOffsetWide,
+ debugsymbols_GetSymbolTypeIdWide,
+ debugsymbols_GetScopeSymbolGroup2,
+ debugsymbols_CreateSymbolGroup2,
+ debugsymbols_StartSymbolMatchWide,
+ debugsymbols_GetNextSymbolMatchWide,
+ debugsymbols_ReloadWide,
+ debugsymbols_GetSymbolPathWide,
+ debugsymbols_SetSymbolPathWide,
+ debugsymbols_AppendSymbolPathWide,
+ debugsymbols_GetImagePathWide,
+ debugsymbols_SetImagePathWide,
+ debugsymbols_AppendImagePathWide,
+ debugsymbols_GetSourcePathWide,
+ debugsymbols_GetSourcePathElementWide,
+ debugsymbols_SetSourcePathWide,
+ debugsymbols_AppendSourcePathWide,
+ debugsymbols_FindSourceFileWide,
+ debugsymbols_GetSourceFileLineOffsetsWide,
+ debugsymbols_GetModuleVersionInformationWide,
+ debugsymbols_GetModuleNameStringWide,
+ debugsymbols_GetConstantNameWide,
+ debugsymbols_GetFieldNameWide,
+ debugsymbols_IsManagedModule,
+ debugsymbols_GetModuleByModuleName2,
+ debugsymbols_GetModuleByModuleName2Wide,
+ debugsymbols_GetModuleByOffset2,
+ debugsymbols_AddSyntheticModule,
+ debugsymbols_AddSyntheticModuleWide,
+ debugsymbols_RemoveSyntheticModule,
+ debugsymbols_GetCurrentScopeFrameIndex,
+ debugsymbols_SetScopeFrameByIndex,
+ debugsymbols_SetScopeFromJitDebugInfo,
+ debugsymbols_SetScopeFromStoredEvent,
+ debugsymbols_OutputSymbolByOffset,
+ debugsymbols_GetFunctionEntryByOffset,
+ debugsymbols_GetFieldTypeAndOffset,
+ debugsymbols_GetFieldTypeAndOffsetWide,
+ debugsymbols_AddSyntheticSymbol,
+ debugsymbols_AddSyntheticSymbolWide,
+ debugsymbols_RemoveSyntheticSymbol,
+ debugsymbols_GetSymbolEntriesByOffset,
+ debugsymbols_GetSymbolEntriesByName,
+ debugsymbols_GetSymbolEntriesByNameWide,
+ debugsymbols_GetSymbolEntryByToken,
+ debugsymbols_GetSymbolEntryInformation,
+ debugsymbols_GetSymbolEntryString,
+ debugsymbols_GetSymbolEntryStringWide,
+ debugsymbols_GetSymbolEntryOffsetRegions,
+ debugsymbols_GetSymbolEntryBySymbolEntry,
+ debugsymbols_GetSourceEntriesByOffset,
+ debugsymbols_GetSourceEntriesByLine,
+ debugsymbols_GetSourceEntriesByLineWide,
+ debugsymbols_GetSourceEntryString,
+ debugsymbols_GetSourceEntryStringWide,
+ debugsymbols_GetSourceEntryOffsetRegions,
+ debugsymbols_GetSourceEntryBySourceEntry,
+};
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_QueryInterface(IDebugControl2 *iface,
REFIID riid, void **obj)
+{
+ struct debug_client *debug_client = impl_from_IDebugControl2(iface);
+ IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
+ return IUnknown_QueryInterface(unk, riid, obj);
+}
+
+static ULONG STDMETHODCALLTYPE debugcontrol_AddRef(IDebugControl2 *iface)
+{
+ struct debug_client *debug_client = impl_from_IDebugControl2(iface);
+ IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
+ return IUnknown_AddRef(unk);
+}
+
+static ULONG STDMETHODCALLTYPE debugcontrol_Release(IDebugControl2 *iface)
+{
+ struct debug_client *debug_client = impl_from_IDebugControl2(iface);
+ IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
+ return IUnknown_Release(unk);
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetInterrupt(IDebugControl2 *iface)
+{
+ FIXME("%p stub.\n", iface);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetInterrupt(IDebugControl2 *iface, ULONG
flags)
+{
+ FIXME("%p, %#x stub.\n", iface, flags);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetInterruptTimeout(IDebugControl2 *iface,
ULONG *timeout)
+{
+ FIXME("%p, %p stub.\n", iface, timeout);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetInterruptTimeout(IDebugControl2 *iface,
ULONG timeout)
+{
+ FIXME("%p, %u stub.\n", iface, timeout);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetLogFile(IDebugControl2 *iface, char
*buffer, ULONG buffer_size,
+ ULONG *file_size, BOOL *append)
+{
+ FIXME("%p, %p, %u, %p, %p stub.\n", iface, buffer, buffer_size, file_size,
append);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_OpenLogFile(IDebugControl2 *iface, const
char *file, BOOL append)
+{
+ FIXME("%p, %s, %d stub.\n", iface, debugstr_a(file), append);
+
+ return E_NOTIMPL;
+}
+static HRESULT STDMETHODCALLTYPE debugcontrol_CloseLogFile(IDebugControl2 *iface)
+{
+ FIXME("%p stub.\n", iface);
+
+ return E_NOTIMPL;
+}
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetLogMask(IDebugControl2 *iface, ULONG
*mask)
+{
+ FIXME("%p, %p stub.\n", iface, mask);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetLogMask(IDebugControl2 *iface, ULONG
mask)
+{
+ FIXME("%p, %#x stub.\n", iface, mask);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_Input(IDebugControl2 *iface, char *buffer,
ULONG buffer_size,
+ ULONG *input_size)
+{
+ FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, input_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_ReturnInput(IDebugControl2 *iface, const
char *buffer)
+{
+ FIXME("%p, %s stub.\n", iface, debugstr_a(buffer));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODVCALLTYPE debugcontrol_Output(IDebugControl2 *iface, ULONG mask,
const char *format, ...)
+{
+ FIXME("%p, %#x, %s stub.\n", iface, mask, debugstr_a(format));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_OutputVaList(IDebugControl2 *iface, ULONG
mask, const char *format,
+ __ms_va_list args)
+{
+ FIXME("%p, %#x, %s stub.\n", iface, mask, debugstr_a(format));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODVCALLTYPE debugcontrol_ControlledOutput(IDebugControl2 *iface,
ULONG output_control,
+ ULONG mask, const char *format, ...)
+{
+ FIXME("%p, %u, %#x, %s stub.\n", iface, output_control, mask,
debugstr_a(format));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_ControlledOutputVaList(IDebugControl2
*iface, ULONG output_control,
+ ULONG mask, const char *format, __ms_va_list args)
+{
+ FIXME("%p, %u, %#x, %s stub.\n", iface, output_control, mask,
debugstr_a(format));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODVCALLTYPE debugcontrol_OutputPrompt(IDebugControl2 *iface, ULONG
output_control,
+ const char *format, ...)
+{
+ FIXME("%p, %u, %s stub.\n", iface, output_control, debugstr_a(format));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_OutputPromptVaList(IDebugControl2 *iface,
ULONG output_control,
+ const char *format, __ms_va_list args)
+{
+ FIXME("%p, %u, %s stub.\n", iface, output_control, debugstr_a(format));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetPromptText(IDebugControl2 *iface, char
*buffer, ULONG buffer_size,
+ ULONG *text_size)
+{
+ FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, text_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_OutputCurrentState(IDebugControl2 *iface,
ULONG output_control,
+ ULONG flags)
+{
+ FIXME("%p, %u, %#x stub.\n", iface, output_control, flags);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_OutputVersionInformation(IDebugControl2
*iface, ULONG output_control)
+{
+ FIXME("%p, %u stub.\n", iface, output_control);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetNotifyEventHandle(IDebugControl2 *iface,
ULONG64 *handle)
+{
+ FIXME("%p, %p stub.\n", iface, handle);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetNotifyEventHandle(IDebugControl2 *iface,
ULONG64 handle)
+{
+ FIXME("%p, %s stub.\n", iface, wine_dbgstr_longlong(handle));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_Assemble(IDebugControl2 *iface, ULONG64
offset, const char *code,
+ ULONG64 *end_offset)
+{
+ FIXME("%p, %s, %s, %p stub.\n", iface, wine_dbgstr_longlong(offset),
debugstr_a(code), end_offset);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_Disassemble(IDebugControl2 *iface, ULONG64
offset, ULONG flags,
+ char *buffer, ULONG buffer_size, ULONG *disassm_size, ULONG64 *end_offset)
+{
+ FIXME("%p, %s, %#x, %p, %u, %p, %p stub.\n", iface,
wine_dbgstr_longlong(offset), flags, buffer, buffer_size,
+ disassm_size, end_offset);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE
debugcontrol_GetDisassembleEffectiveOffset(IDebugControl2 *iface, ULONG64 *offset)
+{
+ FIXME("%p, %p stub.\n", iface, offset);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_OutputDisassembly(IDebugControl2 *iface,
ULONG output_control,
+ ULONG64 offset, ULONG flags, ULONG64 *end_offset)
+{
+ FIXME("%p, %u, %s, %#x, %p stub.\n", iface, output_control,
wine_dbgstr_longlong(offset), flags, end_offset);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_OutputDisassemblyLines(IDebugControl2
*iface, ULONG output_control,
+ ULONG prev_lines, ULONG total_lines, ULONG64 offset, ULONG flags, ULONG
*offset_line, ULONG64 *start_offset,
+ ULONG64 *end_offset, ULONG64 *line_offsets)
+{
+ FIXME("%p, %u, %u, %u, %s, %#x, %p, %p, %p, %p stub.\n", iface,
output_control, prev_lines, total_lines,
+ wine_dbgstr_longlong(offset), flags, offset_line, start_offset, end_offset,
line_offsets);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetNearInstruction(IDebugControl2 *iface,
ULONG64 offset, LONG delta,
+ ULONG64 *instr_offset)
+{
+ FIXME("%p, %s, %d, %p stub.\n", iface, wine_dbgstr_longlong(offset), delta,
instr_offset);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetStackTrace(IDebugControl2 *iface,
ULONG64 frame_offset,
+ ULONG64 stack_offset, ULONG64 instr_offset, DEBUG_STACK_FRAME *frames, ULONG
frames_size, ULONG *frames_filled)
+{
+ FIXME("%p, %s, %s, %s, %p, %u, %p stub.\n", iface,
wine_dbgstr_longlong(frame_offset),
+ wine_dbgstr_longlong(stack_offset), wine_dbgstr_longlong(instr_offset),
frames, frames_size, frames_filled);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetReturnOffset(IDebugControl2 *iface,
ULONG64 *offset)
+{
+ FIXME("%p, %p stub.\n", iface, offset);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_OutputStackTrace(IDebugControl2 *iface,
ULONG output_control,
+ DEBUG_STACK_FRAME *frames, ULONG frames_size, ULONG flags)
+{
+ FIXME("%p, %u, %p, %u, %#x stub.\n", iface, output_control, frames,
frames_size, flags);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetDebuggeeType(IDebugControl2 *iface,
ULONG *debug_class,
+ ULONG *qualifier)
+{
+ struct debug_client *debug_client = impl_from_IDebugControl2(iface);
+ static struct target_process *target;
+
+ FIXME("%p, %p, %p stub.\n", iface, debug_class, qualifier);
+
+ *debug_class = DEBUG_CLASS_UNINITIALIZED;
+ *qualifier = 0;
+
+ if (!(target = debug_client_get_target(debug_client)))
+ return E_UNEXPECTED;
+
+ *debug_class = DEBUG_CLASS_USER_WINDOWS;
+ *qualifier = DEBUG_USER_WINDOWS_PROCESS;
+
+ return S_OK;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetActualProcessorType(IDebugControl2
*iface, ULONG *type)
+{
+ FIXME("%p, %p stub.\n", iface, type);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetExecutingProcessorType(IDebugControl2
*iface, ULONG *type)
+{
+ struct debug_client *debug_client = impl_from_IDebugControl2(iface);
+ static struct target_process *target;
+ HRESULT hr;
+
+ TRACE("%p, %p.\n", iface, type);
+
+ if (!(target = debug_client_get_target(debug_client)))
+ return E_UNEXPECTED;
+
+ if (FAILED(hr = debug_target_init_modules_info(target)))
+ return hr;
+
+ *type = target->cpu_type;
+
+ return S_OK;
+}
+
+static HRESULT STDMETHODCALLTYPE
debugcontrol_GetNumberPossibleExecutingProcessorTypes(IDebugControl2 *iface,
+ ULONG *count)
+{
+ FIXME("%p, %p stub.\n", iface, count);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE
debugcontrol_GetPossibleExecutingProcessorTypes(IDebugControl2 *iface, ULONG start,
+ ULONG count, ULONG *types)
+{
+ FIXME("%p, %u, %u, %p stub.\n", iface, start, count, types);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberProcessors(IDebugControl2 *iface,
ULONG *count)
+{
+ FIXME("%p, %p stub.\n", iface, count);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetSystemVersion(IDebugControl2 *iface,
ULONG *platform_id, ULONG *major,
+ ULONG *minor, char *sp_string, ULONG sp_string_size, ULONG *sp_string_used, ULONG
*sp_number,
+ char *build_string, ULONG build_string_size, ULONG *build_string_used)
+{
+ FIXME("%p, %p, %p, %p, %p, %u, %p, %p, %p, %u, %p stub.\n", iface,
platform_id, major, minor, sp_string,
+ sp_string_size, sp_string_used, sp_number, build_string, build_string_size,
build_string_used);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetPageSize(IDebugControl2 *iface, ULONG
*size)
+{
+ FIXME("%p, %p stub.\n", iface, size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_IsPointer64Bit(IDebugControl2 *iface)
+{
+ struct debug_client *debug_client = impl_from_IDebugControl2(iface);
+ static struct target_process *target;
+ HRESULT hr;
+
+ TRACE("%p.\n", iface);
+
+ if (!(target = debug_client_get_target(debug_client)))
+ return E_UNEXPECTED;
+
+ if (FAILED(hr = debug_target_init_modules_info(target)))
+ return hr;
+
+ switch (target->cpu_type)
+ {
+ case IMAGE_FILE_MACHINE_I386:
+ case IMAGE_FILE_MACHINE_ARM:
+ hr = S_FALSE;
+ break;
+ case IMAGE_FILE_MACHINE_IA64:
+ case IMAGE_FILE_MACHINE_AMD64:
+ case IMAGE_FILE_MACHINE_ARM64:
+ hr = S_OK;
+ break;
+ default:
+ FIXME("Unexpected cpu type %#x.\n", target->cpu_type);
+ hr = E_UNEXPECTED;
+ }
+
+ return hr;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_ReadBugCheckData(IDebugControl2 *iface,
ULONG *code, ULONG64 *arg1,
+ ULONG64 *arg2, ULONG64 *arg3, ULONG64 *arg4)
+{
+ FIXME("%p, %p, %p, %p, %p, %p stub.\n", iface, code, arg1, arg2, arg3,
arg4);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE
debugcontrol_GetNumberSupportedProcessorTypes(IDebugControl2 *iface, ULONG *count)
+{
+ FIXME("%p, %p stub.\n", iface, count);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetSupportedProcessorTypes(IDebugControl2
*iface, ULONG start,
+ ULONG count, ULONG *types)
+{
+ FIXME("%p, %u, %u, %p stub.\n", iface, start, count, types);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetProcessorTypeNames(IDebugControl2
*iface, ULONG type, char *full_name,
+ ULONG full_name_buffer_size, ULONG *full_name_size, char *abbrev_name, ULONG
abbrev_name_buffer_size,
+ ULONG *abbrev_name_size)
+{
+ FIXME("%p, %u, %p, %u, %p, %p, %u, %p stub.\n", iface, type, full_name,
full_name_buffer_size, full_name_size,
+ abbrev_name, abbrev_name_buffer_size, abbrev_name_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetEffectiveProcessorType(IDebugControl2
*iface, ULONG *type)
+{
+ FIXME("%p, %p stub.\n", iface, type);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetEffectiveProcessorType(IDebugControl2
*iface, ULONG type)
+{
+ FIXME("%p, %u stub.\n", iface, type);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetExecutionStatus(IDebugControl2 *iface,
ULONG *status)
+{
+ FIXME("%p, %p stub.\n", iface, status);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetExecutionStatus(IDebugControl2 *iface,
ULONG status)
+{
+ FIXME("%p, %u stub.\n", iface, status);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetCodeLevel(IDebugControl2 *iface, ULONG
*level)
+{
+ FIXME("%p, %p stub.\n", iface, level);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetCodeLevel(IDebugControl2 *iface, ULONG
level)
+{
+ FIXME("%p, %u stub.\n", iface, level);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetEngineOptions(IDebugControl2 *iface,
ULONG *options)
+{
+ struct debug_client *debug_client = impl_from_IDebugControl2(iface);
+
+ TRACE("%p, %p.\n", iface, options);
+
+ *options = debug_client->engine_options;
+
+ return S_OK;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_AddEngineOptions(IDebugControl2 *iface,
ULONG options)
+{
+ struct debug_client *debug_client = impl_from_IDebugControl2(iface);
+
+ TRACE("%p, %#x.\n", iface, options);
+
+ if (options & ~DEBUG_ENGOPT_ALL)
+ return E_INVALIDARG;
+
+ debug_client->engine_options |= options;
+
+ return S_OK;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_RemoveEngineOptions(IDebugControl2 *iface,
ULONG options)
+{
+ struct debug_client *debug_client = impl_from_IDebugControl2(iface);
+
+ TRACE("%p, %#x.\n", iface, options);
+
+ debug_client->engine_options &= ~options;
+
+ return S_OK;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetEngineOptions(IDebugControl2 *iface,
ULONG options)
+{
+ struct debug_client *debug_client = impl_from_IDebugControl2(iface);
+
+ TRACE("%p, %#x.\n", iface, options);
+
+ if (options & ~DEBUG_ENGOPT_ALL)
+ return E_INVALIDARG;
+
+ debug_client->engine_options = options;
+
+ return S_OK;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetSystemErrorControl(IDebugControl2
*iface, ULONG *output_level,
+ ULONG *break_level)
+{
+ FIXME("%p, %p, %p stub.\n", iface, output_level, break_level);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetSystemErrorControl(IDebugControl2
*iface, ULONG output_level,
+ ULONG break_level)
+{
+ FIXME("%p, %u, %u stub.\n", iface, output_level, break_level);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetTextMacro(IDebugControl2 *iface, ULONG
slot, char *buffer,
+ ULONG buffer_size, ULONG *macro_size)
+{
+ FIXME("%p, %u, %p, %u, %p stub.\n", iface, slot, buffer, buffer_size,
macro_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetTextMacro(IDebugControl2 *iface, ULONG
slot, const char *macro)
+{
+ FIXME("%p, %u, %s stub.\n", iface, slot, debugstr_a(macro));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetRadix(IDebugControl2 *iface, ULONG
*radix)
+{
+ FIXME("%p, %p stub.\n", iface, radix);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetRadix(IDebugControl2 *iface, ULONG
radix)
+{
+ FIXME("%p, %u stub.\n", iface, radix);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_Evaluate(IDebugControl2 *iface, const char
*expression,
+ ULONG desired_type, DEBUG_VALUE *value, ULONG *remainder_index)
+{
+ FIXME("%p, %s, %u, %p, %p stub.\n", iface, debugstr_a(expression),
desired_type, value, remainder_index);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_CoerceValue(IDebugControl2 *iface,
DEBUG_VALUE input, ULONG output_type,
+ DEBUG_VALUE *output)
+{
+ FIXME("%p, %u, %p stub.\n", iface, output_type, output);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_CoerceValues(IDebugControl2 *iface, ULONG
count, DEBUG_VALUE *input,
+ ULONG *output_types, DEBUG_VALUE *output)
+{
+ FIXME("%p, %u, %p, %p, %p stub.\n", iface, count, input, output_types,
output);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_Execute(IDebugControl2 *iface, ULONG
output_control, const char *command,
+ ULONG flags)
+{
+ FIXME("%p, %u, %s, %#x stub.\n", iface, output_control,
debugstr_a(command), flags);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_ExecuteCommandFile(IDebugControl2 *iface,
ULONG output_control,
+ const char *command_file, ULONG flags)
+{
+ FIXME("%p, %u, %s, %#x stub.\n", iface, output_control,
debugstr_a(command_file), flags);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberBreakpoints(IDebugControl2 *iface,
ULONG *count)
+{
+ FIXME("%p, %p stub.\n", iface, count);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetBreakpointByIndex(IDebugControl2 *iface,
ULONG index,
+ IDebugBreakpoint **bp)
+{
+ FIXME("%p, %u, %p stub.\n", iface, index, bp);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetBreakpointById(IDebugControl2 *iface,
ULONG id, IDebugBreakpoint **bp)
+{
+ FIXME("%p, %u, %p stub.\n", iface, id, bp);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetBreakpointParameters(IDebugControl2
*iface, ULONG count, ULONG *ids,
+ ULONG start, DEBUG_BREAKPOINT_PARAMETERS *parameters)
+{
+ FIXME("%p, %u, %p, %u, %p stub.\n", iface, count, ids, start, parameters);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_AddBreakpoint(IDebugControl2 *iface, ULONG
type, ULONG desired_id,
+ IDebugBreakpoint **bp)
+{
+ FIXME("%p, %u, %u, %p stub.\n", iface, type, desired_id, bp);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_RemoveBreakpoint(IDebugControl2 *iface,
IDebugBreakpoint *bp)
+{
+ FIXME("%p, %p stub.\n", iface, bp);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_AddExtension(IDebugControl2 *iface, const
char *path, ULONG flags,
+ ULONG64 *handle)
+{
+ FIXME("%p, %s, %#x, %p stub.\n", iface, debugstr_a(path), flags, handle);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_RemoveExtension(IDebugControl2 *iface,
ULONG64 handle)
+{
+ FIXME("%p, %s stub.\n", iface, wine_dbgstr_longlong(handle));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetExtensionByPath(IDebugControl2 *iface,
const char *path,
+ ULONG64 *handle)
+{
+ FIXME("%p, %s, %p stub.\n", iface, debugstr_a(path), handle);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_CallExtension(IDebugControl2 *iface,
ULONG64 handle,
+ const char *function, const char *args)
+{
+ FIXME("%p, %s, %s, %s stub.\n", iface, wine_dbgstr_longlong(handle),
debugstr_a(function), debugstr_a(args));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetExtensionFunction(IDebugControl2 *iface,
ULONG64 handle,
+ const char *name, void *function)
+{
+ FIXME("%p, %s, %s, %p stub.\n", iface, wine_dbgstr_longlong(handle),
debugstr_a(name), function);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetWindbgExtensionApis32(IDebugControl2
*iface,
+ PWINDBG_EXTENSION_APIS32 api)
+{
+ FIXME("%p, %p stub.\n", iface, api);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetWindbgExtensionApis64(IDebugControl2
*iface,
+ PWINDBG_EXTENSION_APIS64 api)
+{
+ FIXME("%p, %p stub.\n", iface, api);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberEventFilters(IDebugControl2
*iface, ULONG *specific_events,
+ ULONG *specific_exceptions, ULONG *arbitrary_exceptions)
+{
+ FIXME("%p, %p, %p, %p stub.\n", iface, specific_events,
specific_exceptions, arbitrary_exceptions);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetEventFilterText(IDebugControl2 *iface,
ULONG index, char *buffer,
+ ULONG buffer_size, ULONG *text_size)
+{
+ FIXME("%p, %u, %p, %u, %p stub.\n", iface, index, buffer, buffer_size,
text_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetEventFilterCommand(IDebugControl2
*iface, ULONG index, char *buffer,
+ ULONG buffer_size, ULONG *command_size)
+{
+ FIXME("%p, %u, %p, %u, %p stub.\n", iface, index, buffer, buffer_size,
command_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetEventFilterCommand(IDebugControl2
*iface, ULONG index,
+ const char *command)
+{
+ FIXME("%p, %u, %s stub.\n", iface, index, debugstr_a(command));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetSpecificFilterParameters(IDebugControl2
*iface, ULONG start,
+ ULONG count, DEBUG_SPECIFIC_FILTER_PARAMETERS *parameters)
+{
+ FIXME("%p, %u, %u, %p stub.\n", iface, start, count, parameters);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetSpecificFilterParameters(IDebugControl2
*iface, ULONG start,
+ ULONG count, DEBUG_SPECIFIC_FILTER_PARAMETERS *parameters)
+{
+ FIXME("%p, %u, %u, %p stub.\n", iface, start, count, parameters);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetSpecificFilterArgument(IDebugControl2
*iface, ULONG index,
+ char *buffer, ULONG buffer_size, ULONG *argument_size)
+{
+ FIXME("%p, %u, %p, %u, %p stub.\n", iface, index, buffer, buffer_size,
argument_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetSpecificFilterArgument(IDebugControl2
*iface, ULONG index,
+ const char *argument)
+{
+ FIXME("%p, %u, %s stub.\n", iface, index, debugstr_a(argument));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetExceptionFilterParameters(IDebugControl2
*iface, ULONG count,
+ ULONG *codes, ULONG start, DEBUG_EXCEPTION_FILTER_PARAMETERS *parameters)
+{
+ FIXME("%p, %u, %p, %u, %p stub.\n", iface, count, codes, start,
parameters);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetExceptionFilterParameters(IDebugControl2
*iface, ULONG count,
+ DEBUG_EXCEPTION_FILTER_PARAMETERS *parameters)
+{
+ FIXME("%p, %u, %p stub.\n", iface, count, parameters);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE
debugcontrol_GetExceptionFilterSecondCommand(IDebugControl2 *iface, ULONG index,
+ char *buffer, ULONG buffer_size, ULONG *command_size)
+{
+ FIXME("%p, %u, %p, %u, %p stub.\n", iface, index, buffer, buffer_size,
command_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE
debugcontrol_SetExceptionFilterSecondCommand(IDebugControl2 *iface, ULONG index,
+ const char *command)
+{
+ FIXME("%p, %u, %s stub.\n", iface, index, debugstr_a(command));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_WaitForEvent(IDebugControl2 *iface, ULONG
flags, ULONG timeout)
+{
+ struct debug_client *debug_client = impl_from_IDebugControl2(iface);
+ struct target_process *target;
+
+ TRACE("%p, %#x, %u.\n", iface, flags, timeout);
+
+ /* FIXME: only one target is used currently */
+
+ if (!(target = debug_client_get_target(debug_client)))
+ return E_UNEXPECTED;
+
+ if (target->attach_flags & DEBUG_ATTACH_NONINVASIVE)
+ {
+ BOOL suspend = !(target->attach_flags &
DEBUG_ATTACH_NONINVASIVE_NO_SUSPEND);
+ DWORD access = PROCESS_VM_READ | PROCESS_VM_WRITE |
PROCESS_QUERY_LIMITED_INFORMATION;
+ NTSTATUS status;
+
+ if (suspend)
+ access |= PROCESS_SUSPEND_RESUME;
+
+ target->handle = OpenProcess(access, FALSE, target->pid);
+ if (!target->handle)
+ {
+ WARN("Failed to get process handle for pid %#x.\n",
target->pid);
+ return E_UNEXPECTED;
+ }
+
+ if (suspend)
+ {
+ status = NtSuspendProcess(target->handle);
+ if (status)
+ WARN("Failed to suspend a process, status %#x.\n", status);
+ }
+
+ return S_OK;
+ }
+ else
+ {
+ FIXME("Unsupported attach flags %#x.\n", target->attach_flags);
+ }
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetLastEventInformation(IDebugControl2
*iface, ULONG *type, ULONG *pid,
+ ULONG *tid, void *extra_info, ULONG extra_info_size, ULONG *extra_info_used, char
*description,
+ ULONG desc_size, ULONG *desc_used)
+{
+ FIXME("%p, %p, %p, %p, %p, %u, %p, %p, %u, %p stub.\n", iface, type, pid,
tid, extra_info, extra_info_size,
+ extra_info_used, description, desc_size, desc_used);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetCurrentTimeDate(IDebugControl2 *iface,
ULONG timedate)
+{
+ FIXME("%p, %u stub.\n", iface, timedate);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetCurrentSystemUpTime(IDebugControl2
*iface, ULONG uptime)
+{
+ FIXME("%p, %u stub.\n", iface, uptime);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetDumpFormatFlags(IDebugControl2 *iface,
ULONG *flags)
+{
+ FIXME("%p, %p stub.\n", iface, flags);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberTextPlacements(IDebugControl2
*iface, ULONG *count)
+{
+ FIXME("%p, %p stub.\n", iface, count);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_GetNumberTextReplacement(IDebugControl2
*iface, const char *src_text,
+ ULONG index, char *src_buffer, ULONG src_buffer_size, ULONG *src_size, char
*dst_buffer,
+ ULONG dst_buffer_size, ULONG *dst_size)
+{
+ FIXME("%p, %s, %u, %p, %u, %p, %p, %u, %p stub.\n", iface,
debugstr_a(src_text), index, src_buffer,
+ src_buffer_size, src_size, dst_buffer, dst_buffer_size, dst_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_SetTextReplacement(IDebugControl2 *iface,
const char *src_text,
+ const char *dst_text)
+{
+ FIXME("%p, %s, %s stub.\n", iface, debugstr_a(src_text),
debugstr_a(dst_text));
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_RemoveTextReplacements(IDebugControl2
*iface)
+{
+ FIXME("%p stub.\n", iface);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugcontrol_OutputTextReplacements(IDebugControl2
*iface, ULONG output_control,
+ ULONG flags)
+{
+ FIXME("%p, %u, %#x stub.\n", iface, output_control, flags);
+
+ return E_NOTIMPL;
+}
+
+static const IDebugControl2Vtbl debugcontrolvtbl =
+{
+ debugcontrol_QueryInterface,
+ debugcontrol_AddRef,
+ debugcontrol_Release,
+ debugcontrol_GetInterrupt,
+ debugcontrol_SetInterrupt,
+ debugcontrol_GetInterruptTimeout,
+ debugcontrol_SetInterruptTimeout,
+ debugcontrol_GetLogFile,
+ debugcontrol_OpenLogFile,
+ debugcontrol_CloseLogFile,
+ debugcontrol_GetLogMask,
+ debugcontrol_SetLogMask,
+ debugcontrol_Input,
+ debugcontrol_ReturnInput,
+ debugcontrol_Output,
+ debugcontrol_OutputVaList,
+ debugcontrol_ControlledOutput,
+ debugcontrol_ControlledOutputVaList,
+ debugcontrol_OutputPrompt,
+ debugcontrol_OutputPromptVaList,
+ debugcontrol_GetPromptText,
+ debugcontrol_OutputCurrentState,
+ debugcontrol_OutputVersionInformation,
+ debugcontrol_GetNotifyEventHandle,
+ debugcontrol_SetNotifyEventHandle,
+ debugcontrol_Assemble,
+ debugcontrol_Disassemble,
+ debugcontrol_GetDisassembleEffectiveOffset,
+ debugcontrol_OutputDisassembly,
+ debugcontrol_OutputDisassemblyLines,
+ debugcontrol_GetNearInstruction,
+ debugcontrol_GetStackTrace,
+ debugcontrol_GetReturnOffset,
+ debugcontrol_OutputStackTrace,
+ debugcontrol_GetDebuggeeType,
+ debugcontrol_GetActualProcessorType,
+ debugcontrol_GetExecutingProcessorType,
+ debugcontrol_GetNumberPossibleExecutingProcessorTypes,
+ debugcontrol_GetPossibleExecutingProcessorTypes,
+ debugcontrol_GetNumberProcessors,
+ debugcontrol_GetSystemVersion,
+ debugcontrol_GetPageSize,
+ debugcontrol_IsPointer64Bit,
+ debugcontrol_ReadBugCheckData,
+ debugcontrol_GetNumberSupportedProcessorTypes,
+ debugcontrol_GetSupportedProcessorTypes,
+ debugcontrol_GetProcessorTypeNames,
+ debugcontrol_GetEffectiveProcessorType,
+ debugcontrol_SetEffectiveProcessorType,
+ debugcontrol_GetExecutionStatus,
+ debugcontrol_SetExecutionStatus,
+ debugcontrol_GetCodeLevel,
+ debugcontrol_SetCodeLevel,
+ debugcontrol_GetEngineOptions,
+ debugcontrol_AddEngineOptions,
+ debugcontrol_RemoveEngineOptions,
+ debugcontrol_SetEngineOptions,
+ debugcontrol_GetSystemErrorControl,
+ debugcontrol_SetSystemErrorControl,
+ debugcontrol_GetTextMacro,
+ debugcontrol_SetTextMacro,
+ debugcontrol_GetRadix,
+ debugcontrol_SetRadix,
+ debugcontrol_Evaluate,
+ debugcontrol_CoerceValue,
+ debugcontrol_CoerceValues,
+ debugcontrol_Execute,
+ debugcontrol_ExecuteCommandFile,
+ debugcontrol_GetNumberBreakpoints,
+ debugcontrol_GetBreakpointByIndex,
+ debugcontrol_GetBreakpointById,
+ debugcontrol_GetBreakpointParameters,
+ debugcontrol_AddBreakpoint,
+ debugcontrol_RemoveBreakpoint,
+ debugcontrol_AddExtension,
+ debugcontrol_RemoveExtension,
+ debugcontrol_GetExtensionByPath,
+ debugcontrol_CallExtension,
+ debugcontrol_GetExtensionFunction,
+ debugcontrol_GetWindbgExtensionApis32,
+ debugcontrol_GetWindbgExtensionApis64,
+ debugcontrol_GetNumberEventFilters,
+ debugcontrol_GetEventFilterText,
+ debugcontrol_GetEventFilterCommand,
+ debugcontrol_SetEventFilterCommand,
+ debugcontrol_GetSpecificFilterParameters,
+ debugcontrol_SetSpecificFilterParameters,
+ debugcontrol_GetSpecificFilterArgument,
+ debugcontrol_SetSpecificFilterArgument,
+ debugcontrol_GetExceptionFilterParameters,
+ debugcontrol_SetExceptionFilterParameters,
+ debugcontrol_GetExceptionFilterSecondCommand,
+ debugcontrol_SetExceptionFilterSecondCommand,
+ debugcontrol_WaitForEvent,
+ debugcontrol_GetLastEventInformation,
+ debugcontrol_GetCurrentTimeDate,
+ debugcontrol_GetCurrentSystemUpTime,
+ debugcontrol_GetDumpFormatFlags,
+ debugcontrol_GetNumberTextPlacements,
+ debugcontrol_GetNumberTextReplacement,
+ debugcontrol_SetTextReplacement,
+ debugcontrol_RemoveTextReplacements,
+ debugcontrol_OutputTextReplacements,
+};
+
+static HRESULT STDMETHODCALLTYPE debugadvanced_QueryInterface(IDebugAdvanced *iface,
REFIID riid, void **obj)
+{
+ struct debug_client *debug_client = impl_from_IDebugAdvanced(iface);
+ IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
+ return IUnknown_QueryInterface(unk, riid, obj);
+}
+
+static ULONG STDMETHODCALLTYPE debugadvanced_AddRef(IDebugAdvanced *iface)
+{
+ struct debug_client *debug_client = impl_from_IDebugAdvanced(iface);
+ IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
+ return IUnknown_AddRef(unk);
+}
+
+static ULONG STDMETHODCALLTYPE debugadvanced_Release(IDebugAdvanced *iface)
+{
+ struct debug_client *debug_client = impl_from_IDebugAdvanced(iface);
+ IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
+ return IUnknown_Release(unk);
+}
+
+static HRESULT STDMETHODCALLTYPE debugadvanced_GetThreadContext(IDebugAdvanced *iface,
void *context,
+ ULONG context_size)
+{
+ FIXME("%p, %p, %u stub.\n", iface, context, context_size);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugadvanced_SetThreadContext(IDebugAdvanced *iface,
void *context,
+ ULONG context_size)
+{
+ FIXME("%p, %p, %u stub.\n", iface, context, context_size);
+
+ return E_NOTIMPL;
+}
+
+static const IDebugAdvancedVtbl debugadvancedvtbl =
+{
+ debugadvanced_QueryInterface,
+ debugadvanced_AddRef,
+ debugadvanced_Release,
+ /* IDebugAdvanced */
+ debugadvanced_GetThreadContext,
+ debugadvanced_SetThreadContext,
+};
+
+
+static HRESULT STDMETHODCALLTYPE debugsystemobjects_QueryInterface(IDebugSystemObjects
*iface, REFIID riid, void **obj)
+{
+ struct debug_client *debug_client = impl_from_IDebugSystemObjects(iface);
+ IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
+ return IUnknown_QueryInterface(unk, riid, obj);
+}
+
+static ULONG STDMETHODCALLTYPE debugsystemobjects_AddRef(IDebugSystemObjects *iface)
+{
+ struct debug_client *debug_client = impl_from_IDebugSystemObjects(iface);
+ IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
+ return IUnknown_AddRef(unk);
+}
+
+static ULONG STDMETHODCALLTYPE debugsystemobjects_Release(IDebugSystemObjects *iface)
+{
+ struct debug_client *debug_client = impl_from_IDebugSystemObjects(iface);
+ IUnknown *unk = (IUnknown *)&debug_client->IDebugClient_iface;
+ return IUnknown_Release(unk);
+}
+
+static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetEventThread(IDebugSystemObjects
*iface, ULONG *id)
+{
+ FIXME("%p, %p stub.\n", iface, id);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetEventProcess(IDebugSystemObjects
*iface, ULONG *id)
+{
+ FIXME("%p, %p stub.\n", iface, id);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE
debugsystemobjects_GetCurrentThreadId(IDebugSystemObjects *iface, ULONG *id)
+{
+ FIXME("%p, %p stub.\n", iface, id);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE
debugsystemobjects_SetCurrentThreadId(IDebugSystemObjects *iface, ULONG id)
+{
+ FIXME("%p, %u stub.\n", iface, id);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE
debugsystemobjects_SetCurrentProcessId(IDebugSystemObjects *iface, ULONG id)
+{
+ FIXME("%p, %u stub.\n", iface, id);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetNumberThreads(IDebugSystemObjects
*iface, ULONG *number)
+{
+ FIXME("%p, %p stub.\n", iface, number);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE
debugsystemobjects_GetTotalNumberThreads(IDebugSystemObjects *iface, ULONG *total,
+ ULONG *largest_process)
+{
+ FIXME("%p, %p, %p stub.\n", iface, total, largest_process);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE
debugsystemobjects_GetThreadIdsByIndex(IDebugSystemObjects *iface, ULONG start,
+ ULONG count, ULONG *ids, ULONG *sysids)
+{
+ FIXME("%p, %u, %u, %p, %p stub.\n", iface, start, count, ids, sysids);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE
debugsystemobjects_GetThreadIdByProcessor(IDebugSystemObjects *iface, ULONG processor,
+ ULONG *id)
+{
+ FIXME("%p, %u, %p stub.\n", iface, processor, id);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE
debugsystemobjects_GetCurrentThreadDataOffset(IDebugSystemObjects *iface,
+ ULONG64 *offset)
+{
+ FIXME("%p, %p stub.\n", iface, offset);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE
debugsystemobjects_GetThreadIdByDataOffset(IDebugSystemObjects *iface, ULONG64 offset,
+ ULONG *id)
+{
+ FIXME("%p, %s, %p stub.\n", iface, wine_dbgstr_longlong(offset), id);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE
debugsystemobjects_GetCurrentThreadTeb(IDebugSystemObjects *iface, ULONG64 *offset)
+{
+ FIXME("%p, %p stub.\n", iface, offset);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetThreadIdByTeb(IDebugSystemObjects
*iface, ULONG64 offset,
+ ULONG *id)
+{
+ FIXME("%p, %s, %p stub.\n", iface, wine_dbgstr_longlong(offset), id);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE
debugsystemobjects_GetCurrentThreadSystemId(IDebugSystemObjects *iface, ULONG *sysid)
+{
+ FIXME("%p, %p stub.\n", iface, sysid);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE
debugsystemobjects_GetThreadIdBySystemId(IDebugSystemObjects *iface, ULONG sysid,
+ ULONG *id)
+{
+ FIXME("%p, %u, %p stub.\n", iface, sysid, id);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE
debugsystemobjects_GetCurrentThreadHandle(IDebugSystemObjects *iface, ULONG64 *handle)
+{
+ FIXME("%p, %p stub.\n", iface, handle);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE
debugsystemobjects_GetThreadIdByHandle(IDebugSystemObjects *iface, ULONG64 handle,
+ ULONG *id)
+{
+ FIXME("%p, %s, %p stub.\n", iface, wine_dbgstr_longlong(handle), id);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE
debugsystemobjects_GetNumberProcesses(IDebugSystemObjects *iface, ULONG *number)
+{
+ FIXME("%p, %p stub.\n", iface, number);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE
debugsystemobjects_GetProcessIdsByIndex(IDebugSystemObjects *iface, ULONG start,
+ ULONG count, ULONG *ids, ULONG *sysids)
+{
+ FIXME("%p, %u, %u, %p, %p stub.\n", iface, start, count, ids, sysids);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE
debugsystemobjects_GetCurrentProcessDataOffset(IDebugSystemObjects *iface,
+ ULONG64 *offset)
+{
+ FIXME("%p, %p stub.\n", iface, offset);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE
debugsystemobjects_GetProcessIdByDataOffset(IDebugSystemObjects *iface,
+ ULONG64 offset, ULONG *id)
+{
+ FIXME("%p, %s, %p stub.\n", iface, wine_dbgstr_longlong(offset), id);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE
debugsystemobjects_GetCurrentProcessPeb(IDebugSystemObjects *iface, ULONG64 *offset)
+{
+ FIXME("%p, %p stub.\n", iface, offset);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE debugsystemobjects_GetProcessIdByPeb(IDebugSystemObjects
*iface, ULONG64 offset,
+ ULONG *id)
+{
+ FIXME("%p, %s, %p stub.\n", iface, wine_dbgstr_longlong(offset), id);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE
debugsystemobjects_GetCurrentProcessSystemId(IDebugSystemObjects *iface, ULONG *sysid)
+{
+ FIXME("%p, %p stub.\n", iface, sysid);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE
debugsystemobjects_GetProcessIdBySystemId(IDebugSystemObjects *iface, ULONG sysid,
+ ULONG *id)
+{
+ FIXME("%p, %u, %p stub.\n", iface, sysid, id);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE
debugsystemobjects_GetCurrentProcessHandle(IDebugSystemObjects *iface,
+ ULONG64 *handle)
+{
+ FIXME("%p, %p stub.\n", iface, handle);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE
debugsystemobjects_GetProcessIdByHandle(IDebugSystemObjects *iface, ULONG64 handle,
+ ULONG *id)
+{
+ FIXME("%p, %s, %p stub.\n", iface, wine_dbgstr_longlong(handle), id);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE
debugsystemobjects_GetCurrentProcessExecutableName(IDebugSystemObjects *iface,
+ char *buffer, ULONG buffer_size, ULONG *exe_size)
+{
+ FIXME("%p, %p, %u, %p stub.\n", iface, buffer, buffer_size, exe_size);
+
+ return E_NOTIMPL;
+}
+
+static const IDebugSystemObjectsVtbl debugsystemobjectsvtbl =
+{
+ debugsystemobjects_QueryInterface,
+ debugsystemobjects_AddRef,
+ debugsystemobjects_Release,
+ debugsystemobjects_GetEventThread,
+ debugsystemobjects_GetEventProcess,
+ debugsystemobjects_GetCurrentThreadId,
+ debugsystemobjects_SetCurrentThreadId,
+ debugsystemobjects_SetCurrentProcessId,
+ debugsystemobjects_GetNumberThreads,
+ debugsystemobjects_GetTotalNumberThreads,
+ debugsystemobjects_GetThreadIdsByIndex,
+ debugsystemobjects_GetThreadIdByProcessor,
+ debugsystemobjects_GetCurrentThreadDataOffset,
+ debugsystemobjects_GetThreadIdByDataOffset,
+ debugsystemobjects_GetCurrentThreadTeb,
+ debugsystemobjects_GetThreadIdByTeb,
+ debugsystemobjects_GetCurrentThreadSystemId,
+ debugsystemobjects_GetThreadIdBySystemId,
+ debugsystemobjects_GetCurrentThreadHandle,
+ debugsystemobjects_GetThreadIdByHandle,
+ debugsystemobjects_GetNumberProcesses,
+ debugsystemobjects_GetProcessIdsByIndex,
+ debugsystemobjects_GetCurrentProcessDataOffset,
+ debugsystemobjects_GetProcessIdByDataOffset,
+ debugsystemobjects_GetCurrentProcessPeb,
+ debugsystemobjects_GetProcessIdByPeb,
+ debugsystemobjects_GetCurrentProcessSystemId,
+ debugsystemobjects_GetProcessIdBySystemId,
+ debugsystemobjects_GetCurrentProcessHandle,
+ debugsystemobjects_GetProcessIdByHandle,
+ debugsystemobjects_GetCurrentProcessExecutableName,
+};
+
+/************************************************************
+* DebugExtensionInitialize (DBGENG.@)
+*
+* Initializing Debug Engine
+*
+* PARAMS
+* pVersion [O] Receiving the version of extension
+* pFlags [O] Reserved
+*
+* RETURNS
+* Success: S_OK
+* Failure: Anything other than S_OK
+*
+* BUGS
+* Unimplemented
+*/
+HRESULT WINAPI DebugExtensionInitialize(ULONG * pVersion, ULONG * pFlags)
+{
+ FIXME("(%p,%p): stub\n", pVersion, pFlags);
+
+ SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+
+ return E_NOTIMPL;
+}
+
+/************************************************************
+* DebugCreate (dbgeng.@)
+*/
+HRESULT WINAPI DebugCreate(REFIID riid, void **obj)
+{
+ struct debug_client *debug_client;
+ IUnknown *unk;
+ HRESULT hr;
+
+ TRACE("%s, %p.\n", debugstr_guid(riid), obj);
+
+ debug_client = heap_alloc_zero(sizeof(*debug_client));
+ if (!debug_client)
+ return E_OUTOFMEMORY;
+
+ debug_client->IDebugClient_iface.lpVtbl = &debugclientvtbl;
+ debug_client->IDebugDataSpaces_iface.lpVtbl = &debugdataspacesvtbl;
+ debug_client->IDebugSymbols3_iface.lpVtbl = &debugsymbolsvtbl;
+ debug_client->IDebugControl2_iface.lpVtbl = &debugcontrolvtbl;
+ debug_client->IDebugAdvanced_iface.lpVtbl = &debugadvancedvtbl;
+ debug_client->IDebugSystemObjects_iface.lpVtbl = &debugsystemobjectsvtbl;
+ debug_client->refcount = 1;
+ list_init(&debug_client->targets);
+
+ unk = (IUnknown *)&debug_client->IDebugClient_iface;
+
+ hr = IUnknown_QueryInterface(unk, riid, obj);
+ IUnknown_Release(unk);
+
+ return hr;
+}
+
+/************************************************************
+* DebugCreateEx (DBGENG.@)
+*/
+HRESULT WINAPI DebugCreateEx(REFIID riid, DWORD flags, void **obj)
+{
+ FIXME("(%s, %#x, %p): stub\n", debugstr_guid(riid), flags, obj);
+
+ return E_NOTIMPL;
+}
+
+/************************************************************
+* DebugConnect (DBGENG.@)
+*
+* Creating Debug Engine client object and connecting it to remote host
+*
+* PARAMS
+* RemoteOptions [I] Options which define how debugger engine connects to remote host
+* InterfaceId [I] Interface Id of debugger client
+* pInterface [O] Pointer to interface as requested via InterfaceId
+*
+* RETURNS
+* Success: S_OK
+* Failure: Anything other than S_OK
+*
+* BUGS
+* Unimplemented
+*/
+HRESULT WINAPI DebugConnect(PCSTR RemoteOptions, REFIID InterfaceId, PVOID * pInterface)
+{
+ FIXME("(%p,%p,%p): stub\n", RemoteOptions, InterfaceId, pInterface);
+
+ SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+
+ return E_NOTIMPL;
+}
diff --git a/dll/win32/dbgeng/dbgeng.spec b/dll/win32/dbgeng/dbgeng.spec
new file mode 100644
index 00000000000..e47211a4b92
--- /dev/null
+++ b/dll/win32/dbgeng/dbgeng.spec
@@ -0,0 +1,5 @@
+@ stdcall DebugConnect(str ptr ptr)
+@ stub DebugConnectWide
+@ stdcall DebugCreate(ptr ptr)
+@ stdcall DebugCreateEx(ptr long ptr)
+@ stdcall DebugExtensionInitialize(ptr ptr)
diff --git a/media/doc/README.WINE b/media/doc/README.WINE
index b174c23d3cf..72af1000226 100644
--- a/media/doc/README.WINE
+++ b/media/doc/README.WINE
@@ -65,6 +65,7 @@ dll/win32/cryptdlg # Synced to WineStaging-4.18
dll/win32/cryptdll # Synced to WineStaging-4.18
dll/win32/cryptnet # Synced to WineStaging-4.18
dll/win32/cryptui # Synced to WineStaging-4.18
+dll/win32/dbgeng # Synced to WineStaging-4.18
dll/win32/dbghelp # Synced to WineStaging-3.9
dll/win32/dciman32 # Synced to WineStaging-3.3
dll/win32/faultrep # Synced to WineStaging-4.18