From c1dc46aba1e0a54185d09d8ecd9eb1d2afd30786 Mon Sep 17 00:00:00 2001 From: Esme Povirk Date: Tue, 1 Feb 2022 15:56:23 -0600 Subject: [PATCH] diasymreader: Stub ISymUnmanagedWriter. Signed-off-by: Esme Povirk Signed-off-by: Alexandre Julliard --- dlls/diasymreader/Makefile.in | 4 +- dlls/diasymreader/diasymreader_private.h | 23 ++ dlls/diasymreader/main.c | 147 ++++++++++- dlls/diasymreader/writer.c | 303 +++++++++++++++++++++++ 4 files changed, 474 insertions(+), 3 deletions(-) create mode 100644 dlls/diasymreader/diasymreader_private.h create mode 100644 dlls/diasymreader/writer.c diff --git a/dlls/diasymreader/Makefile.in b/dlls/diasymreader/Makefile.in index 2ea95048edd..e9d6fee09e8 100644 --- a/dlls/diasymreader/Makefile.in +++ b/dlls/diasymreader/Makefile.in @@ -3,6 +3,8 @@ IMPORTS = uuid EXTRADLLFLAGS = -Wb,--prefer-native -C_SRCS = main.c +C_SRCS = \ + main.c \ + writer.c RC_SRCS = diasymreader.rc diff --git a/dlls/diasymreader/diasymreader_private.h b/dlls/diasymreader/diasymreader_private.h new file mode 100644 index 00000000000..4275193e3d4 --- /dev/null +++ b/dlls/diasymreader/diasymreader_private.h @@ -0,0 +1,23 @@ +/* + * Copyright 2022 Esme Povirk + * + * 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 "corhdr.h" +#include "cordebug.h" +#include "corsym.h" + +HRESULT SymWriter_CreateInstance(REFIID iid, void **ppv) DECLSPEC_HIDDEN; diff --git a/dlls/diasymreader/main.c b/dlls/diasymreader/main.c index a85d9cd0222..da64a156714 100644 --- a/dlls/diasymreader/main.c +++ b/dlls/diasymreader/main.c @@ -17,6 +17,8 @@ #include +#define COBJMACROS + #include "windef.h" #include "winbase.h" #include "winnls.h" @@ -26,10 +28,151 @@ #include "wine/debug.h" +#include "initguid.h" + +#include "diasymreader_private.h" + WINE_DEFAULT_DEBUG_CHANNEL(diasymreader); +typedef struct { + REFCLSID classid; + HRESULT (*constructor)(REFIID,void**); +} classinfo; + +static const classinfo classes[] = { + {&CLSID_CorSymWriter_SxS, SymWriter_CreateInstance} +}; + +typedef struct { + IClassFactory IClassFactory_iface; + LONG ref; + const classinfo *info; +} ClassFactoryImpl; + +static inline ClassFactoryImpl *impl_from_IClassFactory(IClassFactory *iface) +{ + return CONTAINING_RECORD(iface, ClassFactoryImpl, IClassFactory_iface); +} + +static HRESULT WINAPI ClassFactoryImpl_QueryInterface(IClassFactory *iface, + REFIID iid, void **ppv) +{ + ClassFactoryImpl *This = impl_from_IClassFactory(iface); + TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv); + + if (!ppv) return E_INVALIDARG; + + if (IsEqualIID(&IID_IUnknown, iid) || + IsEqualIID(&IID_IClassFactory, iid)) + { + *ppv = &This->IClassFactory_iface; + } + else + { + *ppv = NULL; + return E_NOINTERFACE; + } + + IUnknown_AddRef((IUnknown*)*ppv); + return S_OK; +} + +static ULONG WINAPI ClassFactoryImpl_AddRef(IClassFactory *iface) +{ + ClassFactoryImpl *This = impl_from_IClassFactory(iface); + ULONG ref = InterlockedIncrement(&This->ref); + + TRACE("(%p) refcount=%lu\n", iface, ref); + + return ref; +} + +static ULONG WINAPI ClassFactoryImpl_Release(IClassFactory *iface) +{ + ClassFactoryImpl *This = impl_from_IClassFactory(iface); + ULONG ref = InterlockedDecrement(&This->ref); + + TRACE("(%p) refcount=%lu\n", iface, ref); + + if (ref == 0) + HeapFree(GetProcessHeap(), 0, This); + + return ref; +} + +static HRESULT WINAPI ClassFactoryImpl_CreateInstance(IClassFactory *iface, + IUnknown *pUnkOuter, REFIID riid, void **ppv) +{ + ClassFactoryImpl *This = impl_from_IClassFactory(iface); + + *ppv = NULL; + + if (pUnkOuter) return CLASS_E_NOAGGREGATION; + + return This->info->constructor(riid, ppv); +} + +static HRESULT WINAPI ClassFactoryImpl_LockServer(IClassFactory *iface, BOOL lock) +{ + TRACE("(%p, %i): stub\n", iface, lock); + return E_NOTIMPL; +} + +static const IClassFactoryVtbl ClassFactoryImpl_Vtbl = { + ClassFactoryImpl_QueryInterface, + ClassFactoryImpl_AddRef, + ClassFactoryImpl_Release, + ClassFactoryImpl_CreateInstance, + ClassFactoryImpl_LockServer +}; + +static HRESULT ClassFactoryImpl_Constructor(const classinfo *info, REFIID riid, LPVOID *ppv) +{ + ClassFactoryImpl *This; + HRESULT ret; + + *ppv = NULL; + + This = HeapAlloc(GetProcessHeap(), 0, sizeof(ClassFactoryImpl)); + if (!This) return E_OUTOFMEMORY; + + This->IClassFactory_iface.lpVtbl = &ClassFactoryImpl_Vtbl; + This->ref = 1; + This->info = info; + + ret = IClassFactory_QueryInterface(&This->IClassFactory_iface, riid, ppv); + IClassFactory_Release(&This->IClassFactory_iface); + + return ret; +} + HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID iid, LPVOID *ppv) { - FIXME("(%s,%s,%p)\n", debugstr_guid(rclsid), debugstr_guid(iid), ppv); - return CLASS_E_CLASSNOTAVAILABLE; + HRESULT ret; + const classinfo *info=NULL; + int i; + + TRACE("(%s,%s,%p)\n", debugstr_guid(rclsid), debugstr_guid(iid), ppv); + + if (!rclsid || !iid || !ppv) + return E_INVALIDARG; + + *ppv = NULL; + + for (i=0; classes[i].classid; i++) + { + if (IsEqualCLSID(classes[i].classid, rclsid)) + { + info = &classes[i]; + break; + } + } + + if (info) + ret = ClassFactoryImpl_Constructor(info, iid, ppv); + else + ret = CLASS_E_CLASSNOTAVAILABLE; + + TRACE("<-- %08lx\n", ret); + return ret; } diff --git a/dlls/diasymreader/writer.c b/dlls/diasymreader/writer.c new file mode 100644 index 00000000000..6d86e82c92b --- /dev/null +++ b/dlls/diasymreader/writer.c @@ -0,0 +1,303 @@ +/* + * Copyright 2022 Esme Povirk + * + * 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 + +#define COBJMACROS + +#include "windef.h" +#include "winbase.h" +#include "objbase.h" + +#include "wine/debug.h" +#include "wine/heap.h" + +#include "diasymreader_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(diasymreader); + +typedef struct SymWriter { + ISymUnmanagedWriter iface; + LONG ref; +} SymWriter; + +static inline SymWriter *impl_from_ISymUnmanagedWriter(ISymUnmanagedWriter *iface) +{ + return CONTAINING_RECORD(iface, SymWriter, iface); +} + +static HRESULT WINAPI SymWriter_QueryInterface(ISymUnmanagedWriter *iface, REFIID iid, + void **ppv) +{ + SymWriter *This = impl_from_ISymUnmanagedWriter(iface); + + TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv); + + if (IsEqualIID(&IID_IUnknown, iid) || + IsEqualIID(&IID_ISymUnmanagedWriter, iid)) + { + *ppv = &This->iface; + } + else + { + WARN("unknown interface %s\n", debugstr_guid(iid)); + *ppv = NULL; + return E_NOINTERFACE; + } + + IUnknown_AddRef((IUnknown*)*ppv); + return S_OK; +} + +static ULONG WINAPI SymWriter_AddRef(ISymUnmanagedWriter *iface) +{ + SymWriter *This = impl_from_ISymUnmanagedWriter(iface); + ULONG ref = InterlockedIncrement(&This->ref); + + TRACE("(%p) refcount=%lu\n", iface, ref); + + return ref; +} + +static ULONG WINAPI SymWriter_Release(ISymUnmanagedWriter *iface) +{ + SymWriter *This = impl_from_ISymUnmanagedWriter(iface); + ULONG ref = InterlockedDecrement(&This->ref); + + TRACE("(%p) refcount=%lu\n", iface, ref); + + if (ref == 0) + { + heap_free(This); + } + + return ref; +} + +static HRESULT WINAPI SymWriter_DefineDocument(ISymUnmanagedWriter *iface, const WCHAR *url, + const GUID *language, const GUID *languageVendor, const GUID *documentType, + ISymUnmanagedDocumentWriter** pRetVal) +{ + FIXME("(%p,%s,%s,%s,%s,%p)\n", iface, debugstr_w(url), debugstr_guid(language), + debugstr_guid(languageVendor), debugstr_guid(documentType), pRetVal); + return E_NOTIMPL; +} + +static HRESULT WINAPI SymWriter_SetUserEntryPoint(ISymUnmanagedWriter *iface, mdMethodDef entryMethod) +{ + FIXME("(%p,0x%x)\n", iface, entryMethod); + return E_NOTIMPL; +} + +static HRESULT WINAPI SymWriter_OpenMethod(ISymUnmanagedWriter *iface, mdMethodDef method) +{ + FIXME("(%p,0x%x)\n", iface, method); + return E_NOTIMPL; +} + +static HRESULT WINAPI SymWriter_CloseMethod(ISymUnmanagedWriter *iface) +{ + FIXME("(%p)\n", iface); + return E_NOTIMPL; +} + +static HRESULT WINAPI SymWriter_OpenScope(ISymUnmanagedWriter *iface, ULONG32 startOffset, + ULONG32 *pRetVal) +{ + FIXME("(%p,%u,%p)\n", iface, startOffset, pRetVal); + return E_NOTIMPL; +} + +static HRESULT WINAPI SymWriter_CloseScope(ISymUnmanagedWriter *iface, ULONG32 endOffset) +{ + FIXME("(%p,%u)\n", iface, endOffset); + return E_NOTIMPL; +} + +static HRESULT WINAPI SymWriter_SetScopeRange(ISymUnmanagedWriter *iface, ULONG32 scopeID, ULONG32 startOffset, + ULONG32 endOffset) +{ + FIXME("(%p,%u,%u,%u)\n", iface, scopeID, startOffset, endOffset); + return E_NOTIMPL; +} + +static HRESULT WINAPI SymWriter_DefineLocalVariable(ISymUnmanagedWriter *iface, const WCHAR *name, + ULONG32 attributes, ULONG32 cSig, unsigned char signature[], ULONG32 addrKind, + ULONG32 addr1, ULONG32 addr2, ULONG32 addr3, ULONG32 startOffset, ULONG32 endOffset) +{ + FIXME("(%p,%s,0x%x,%u,%u)\n", iface, debugstr_w(name), attributes, cSig, addrKind); + return E_NOTIMPL; +} + +static HRESULT WINAPI SymWriter_DefineParameter(ISymUnmanagedWriter *iface, const WCHAR *name, + ULONG32 attributes, ULONG32 sequence, ULONG32 addrKind, + ULONG32 addr1, ULONG32 addr2, ULONG32 addr3) +{ + FIXME("(%p,%s,0x%x,%u,%u)\n", iface, debugstr_w(name), attributes, sequence, addrKind); + return E_NOTIMPL; +} + +static HRESULT WINAPI SymWriter_DefineField(ISymUnmanagedWriter *iface, mdTypeDef parent, + const WCHAR *name, ULONG32 attributes, ULONG32 cSig, unsigned char signature[], ULONG32 addrKind, + ULONG32 addr1, ULONG32 addr2, ULONG32 addr3) +{ + FIXME("(%p,0x%x,%s,0x%x,%u,%u)\n", iface, parent, debugstr_w(name), attributes, cSig, addrKind); + return E_NOTIMPL; +} + +static HRESULT WINAPI SymWriter_DefineGlobalVariable(ISymUnmanagedWriter *iface, const WCHAR *name, + ULONG32 attributes, ULONG32 cSig, unsigned char signature[], ULONG32 addrKind, + ULONG32 addr1, ULONG32 addr2, ULONG32 addr3) +{ + FIXME("(%p,%s,0x%x,%u,%u)\n", iface, debugstr_w(name), attributes, cSig, addrKind); + return E_NOTIMPL; +} + +static HRESULT WINAPI SymWriter_Close(ISymUnmanagedWriter *iface) +{ + FIXME("(%p)\n", iface); + return E_NOTIMPL; +} + +static HRESULT WINAPI SymWriter_SetSymAttributes(ISymUnmanagedWriter *iface, mdToken parent, + const WCHAR *name, ULONG32 cData, unsigned char data[]) +{ + FIXME("(%p,0x%x,%s,%u)\n", iface, parent, debugstr_w(name), cData); + return E_NOTIMPL; +} + +static HRESULT WINAPI SymWriter_OpenNamespace(ISymUnmanagedWriter *iface, const WCHAR *name) +{ + FIXME("(%p,%s)\n", iface, debugstr_w(name)); + return E_NOTIMPL; +} + +static HRESULT WINAPI SymWriter_CloseNamespace(ISymUnmanagedWriter *iface) +{ + FIXME("(%p)\n", iface); + return E_NOTIMPL; +} + +static HRESULT WINAPI SymWriter_UsingNamespace(ISymUnmanagedWriter *iface, const WCHAR *fullName) +{ + FIXME("(%p,%s)\n", iface, debugstr_w(fullName)); + return E_NOTIMPL; +} + +static HRESULT WINAPI SymWriter_SetMethodSourceRange(ISymUnmanagedWriter *iface, ISymUnmanagedDocumentWriter *startDoc, + ULONG32 startLine, ULONG32 startColumn, ISymUnmanagedDocumentWriter *endDoc, ULONG32 endLine, ULONG32 endColumn) +{ + FIXME("(%p,%p,%u,%u,%p,%u,%u)\n", iface, startDoc, startLine, startColumn, endDoc, endLine, endColumn); + return E_NOTIMPL; +} + +static HRESULT WINAPI SymWriter_Initialize(ISymUnmanagedWriter *iface, IUnknown *emitter, const WCHAR *filename, + IStream *pIStream, BOOL fFullBuild) +{ + FIXME("(%p,%p,%s,%p,%u)\n", iface, emitter, debugstr_w(filename), pIStream, fFullBuild); + return E_NOTIMPL; +} + +static HRESULT WINAPI SymWriter_GetDebugInfo(ISymUnmanagedWriter *iface, IMAGE_DEBUG_DIRECTORY *pIDD, DWORD cData, + DWORD *pcData, BYTE data[]) +{ + FIXME("(%p,%p,%lu,%p,%p)\n", iface, pIDD, cData, pcData, data); + return E_NOTIMPL; +} + +static HRESULT WINAPI SymWriter_DefineSequencePoints(ISymUnmanagedWriter *iface, ISymUnmanagedDocumentWriter *document, + ULONG32 spCount, ULONG32 offsets[], ULONG32 lines[], ULONG32 columns[], ULONG32 endLines[], ULONG32 endColumns[]) +{ + FIXME("(%p,%p,%u)\n", iface, document, spCount); + return E_NOTIMPL; +} + +static HRESULT WINAPI SymWriter_RemapToken(ISymUnmanagedWriter *iface, mdToken oldToken, mdToken newToken) +{ + FIXME("(%p,0x%x,0x%x)\n", iface, oldToken, newToken); + return E_NOTIMPL; +} + +static HRESULT WINAPI SymWriter_Initialize2(ISymUnmanagedWriter *iface, IUnknown *emitter, const WCHAR *tempFilename, + IStream *pIStream, BOOL fFullBuild, const WCHAR *finalFilename) +{ + FIXME("(%p,%p,%s,%p,%u,%s)\n", iface, emitter, debugstr_w(tempFilename), pIStream, fFullBuild, debugstr_w(finalFilename)); + return E_NOTIMPL; +} + +static HRESULT WINAPI SymWriter_DefineConstant(ISymUnmanagedWriter *iface, const WCHAR *name, VARIANT value, ULONG32 cSig, + unsigned char signature[]) +{ + FIXME("(%p,%s,%s,%u,%p)\n", iface, debugstr_w(name), debugstr_variant(&value), cSig, signature); + return E_NOTIMPL; +} + +static HRESULT WINAPI SymWriter_Abort(ISymUnmanagedWriter *iface) +{ + FIXME("(%p)\n", iface); + return E_NOTIMPL; +} + +static const ISymUnmanagedWriterVtbl SymWriter_Vtbl = { + SymWriter_QueryInterface, + SymWriter_AddRef, + SymWriter_Release, + SymWriter_DefineDocument, + SymWriter_SetUserEntryPoint, + SymWriter_OpenMethod, + SymWriter_CloseMethod, + SymWriter_OpenScope, + SymWriter_CloseScope, + SymWriter_SetScopeRange, + SymWriter_DefineLocalVariable, + SymWriter_DefineParameter, + SymWriter_DefineField, + SymWriter_DefineGlobalVariable, + SymWriter_Close, + SymWriter_SetSymAttributes, + SymWriter_OpenNamespace, + SymWriter_CloseNamespace, + SymWriter_UsingNamespace, + SymWriter_SetMethodSourceRange, + SymWriter_Initialize, + SymWriter_GetDebugInfo, + SymWriter_DefineSequencePoints, + SymWriter_RemapToken, + SymWriter_Initialize2, + SymWriter_DefineConstant, + SymWriter_Abort +}; + +HRESULT SymWriter_CreateInstance(REFIID iid, void **ppv) +{ + SymWriter *This; + HRESULT hr; + + This = heap_alloc(sizeof(*This)); + if (!This) + return E_OUTOFMEMORY; + + This->iface.lpVtbl = &SymWriter_Vtbl; + This->ref = 1; + + hr = IUnknown_QueryInterface(&This->iface, iid, ppv); + + ISymUnmanagedWriter_Release(&This->iface); + + return hr; +}