git.oblomov.eu Git - wine/blob - dlls/ole32/errorinfo.c

   1 /*
   2  * ErrorInfo API
   3  *
   4  * Copyright 2000 Patrik Stridvall, Juergen Schmied
   5  *
   6  *
   7  * The errorinfo is a per-thread object. The reference is stored in the
   8  * TEB at offset 0xf80
   9  */
  10
  11 #include "debugtools.h"
  12 #include "windef.h"
  13 #include "heap.h"
  14 #include "winerror.h"
  15 #include "thread.h"
  16 #include "debugtools.h"
  17 #include "wine/obj_errorinfo.h"
  18
  19 DEFAULT_DEBUG_CHANNEL(ole)
  20
  21 typedef struct ErrorInfoImpl
  22 {
  23         ICOM_VTABLE(IErrorInfo)         *lpvtei;
  24         ICOM_VTABLE(ICreateErrorInfo)   *lpvtcei;
  25         ICOM_VTABLE(ISupportErrorInfo)  *lpvtsei;
  26         DWORD                           ref;
  27
  28         const GUID *pGuid;
  29 } ErrorInfoImpl;
  30
  31 static ICOM_VTABLE(IErrorInfo)          IErrorInfoImpl_VTable;
  32 static ICOM_VTABLE(ICreateErrorInfo)    ICreateErrorInfoImpl_VTable;
  33 static ICOM_VTABLE(ISupportErrorInfo)   ISupportErrorInfoImpl_VTable;
  34
  35 /*
  36  converts a objectpointer to This
  37  */
  38 #define _IErrorInfo_Offset ((int)(&(((ErrorInfoImpl*)0)->lpvtei)))
  39 #define _ICOM_THIS_From_IErrorInfo(class, name) class* This = (class*)(((char*)name)-_IErrorInfo_Offset);
  40
  41 #define _ICreateErrorInfo_Offset ((int)(&(((ErrorInfoImpl*)0)->lpvtcei)))
  42 #define _ICOM_THIS_From_ICreateErrorInfo(class, name) class* This = (class*)(((char*)name)-_ICreateErrorInfo_Offset);
  43
  44 #define _ISupportErrorInfo_Offset ((int)(&(((ErrorInfoImpl*)0)->lpvtsei)))
  45 #define _ICOM_THIS_From_ISupportErrorInfo(class, name) class* This = (class*)(((char*)name)-_ISupportErrorInfo_Offset);
  46
  47 /*
  48  converts This to a objectpointer
  49  */
  50 #define _IErrorInfo_(This)              (IErrorInfo*)&(This->lpvtei)
  51 #define _ICreateErrorInfo_(This)        (ICreateErrorInfo*)&(This->lpvtcei)
  52 #define _ISupportErrorInfo_(This)       (ISupportErrorInfo*)&(This->lpvtsei)
  53
  54 IErrorInfo * IErrorInfoImpl_Constructor()
  55 {
  56         ErrorInfoImpl * ei = HeapAlloc(GetProcessHeap(), 0, sizeof(ErrorInfoImpl));
  57         if (ei)
  58         {
  59           ei->lpvtei = &IErrorInfoImpl_VTable;
  60           ei->lpvtcei = &ICreateErrorInfoImpl_VTable;
  61           ei->lpvtsei = &ISupportErrorInfoImpl_VTable;
  62           ei->ref = 1;
  63         }
  64         return (IErrorInfo *)ei;
  65 }
  66
  67
  68 static HRESULT WINAPI IErrorInfoImpl_QueryInterface(
  69         IErrorInfo* iface,
  70         REFIID     riid,
  71         VOID**     ppvoid)
  72 {
  73         _ICOM_THIS_From_IErrorInfo(ErrorInfoImpl, iface);
  74         TRACE("(%p)->(\n\tIID:\t%s,%p)\n",This,debugstr_guid(riid),ppvoid);
  75
  76         *ppvoid = NULL;
  77
  78         if(IsEqualIID(riid, &IID_IErrorInfo))
  79         {
  80           *ppvoid = _IErrorInfo_(This);
  81         }
  82         else if(IsEqualIID(riid, &IID_ICreateErrorInfo))
  83         {
  84           *ppvoid = _ICreateErrorInfo_(This);
  85         }
  86         else if(IsEqualIID(riid, &IID_ISupportErrorInfo))
  87         {
  88           *ppvoid = _ISupportErrorInfo_(This);
  89         }
  90
  91         if(*ppvoid)
  92         {
  93           IUnknown_AddRef( (IUnknown*)*ppvoid );
  94           TRACE("-- Interface: (%p)->(%p)\n",ppvoid,*ppvoid);
  95           return S_OK;
  96         }
  97         TRACE("-- Interface: E_NOINTERFACE\n");
  98         return E_NOINTERFACE;
  99 }
 100
 101 static ULONG WINAPI IErrorInfoImpl_AddRef(
 102         IErrorInfo* iface)
 103 {
 104         _ICOM_THIS_From_IErrorInfo(ErrorInfoImpl, iface);
 105         TRACE("(%p)->(count=%lu)\n",This,This->ref);
 106         return InterlockedIncrement(&This->ref);
 107 }
 108
 109 static ULONG WINAPI IErrorInfoImpl_Release(
 110         IErrorInfo* iface)
 111 {
 112         _ICOM_THIS_From_IErrorInfo(ErrorInfoImpl, iface);
 113         TRACE("(%p)->(count=%lu)\n",This,This->ref);
 114
 115         if (!InterlockedDecrement(&This->ref))
 116         {
 117           TRACE("-- destroying IErrorInfo(%p)\n",This);
 118           HeapFree(GetProcessHeap(),0,This);
 119           return 0;
 120         }
 121         return This->ref;
 122 }
 123
 124 static HRESULT WINAPI IErrorInfoImpl_GetTypeInfoCount(
 125         IErrorInfo* iface,
 126         unsigned int* pctinfo)
 127 {
 128         _ICOM_THIS_From_IErrorInfo(ErrorInfoImpl, iface);
 129         FIXME("(%p)\n", This);
 130
 131         return E_NOTIMPL;
 132 }
 133
 134 static HRESULT WINAPI IErrorInfoImpl_GetTypeInfo(
 135         IErrorInfo* iface,
 136         UINT iTInfo,
 137         LCID lcid,
 138         ITypeInfo** ppTInfo)
 139 {
 140         _ICOM_THIS_From_IErrorInfo(ErrorInfoImpl, iface);
 141         FIXME("(%p)\n", This);
 142
 143         return E_NOTIMPL;
 144 }
 145
 146 static HRESULT WINAPI IErrorInfoImpl_GetIDsOfNames(
 147         IErrorInfo* iface,
 148         REFIID riid,
 149         LPOLESTR* rgszNames,
 150         UINT cNames,
 151         LCID lcid,
 152         DISPID* rgDispId)
 153 {
 154         _ICOM_THIS_From_IErrorInfo(ErrorInfoImpl, iface);
 155         FIXME("(%p)\n", This);
 156
 157         return E_NOTIMPL;
 158 }
 159
 160 static HRESULT WINAPI IErrorInfoImpl_Invoke(
 161         IErrorInfo* iface,
 162         DISPID dispIdMember,
 163         REFIID riid,
 164         LCID lcid,
 165         WORD wFlags,
 166         DISPPARAMS* pDispParams,
 167         VARIANT* pVarResult,
 168         EXCEPINFO* pExepInfo,
 169         UINT* puArgErr)
 170 {
 171         _ICOM_THIS_From_IErrorInfo(ErrorInfoImpl, iface);
 172         FIXME("(%p)\n", This);
 173
 174         return E_NOTIMPL;
 175 }
 176
 177 /* FIXME: is this OK? Original is GUID* pGUID! This can't work! (js) */
 178 static HRESULT WINAPI IErrorInfoImpl_GetGUID(
 179         IErrorInfo* iface,
 180         GUID const ** pGUID)
 181 {
 182         _ICOM_THIS_From_IErrorInfo(ErrorInfoImpl, iface);
 183         FIXME("(%p) check function prototype\n", This);
 184
 185         if(!pGUID || !*pGUID)return E_INVALIDARG;
 186         *pGUID = This->pGuid;
 187         return S_OK;
 188 }
 189
 190 static HRESULT WINAPI IErrorInfoImpl_GetSource(
 191         IErrorInfo* iface,
 192         BSTR *pBstrSource)
 193 {
 194         _ICOM_THIS_From_IErrorInfo(ErrorInfoImpl, iface);
 195         FIXME("(%p)\n", This);
 196
 197         return E_NOTIMPL;
 198 }
 199
 200 static HRESULT WINAPI IErrorInfoImpl_GetDescription(
 201         IErrorInfo* iface,
 202         BSTR *pBstrDescription)
 203 {
 204         _ICOM_THIS_From_IErrorInfo(ErrorInfoImpl, iface);
 205         FIXME("(%p)\n", This);
 206
 207         return E_NOTIMPL;
 208 }
 209
 210 static HRESULT WINAPI IErrorInfoImpl_GetHelpFile(
 211         IErrorInfo* iface,
 212         BSTR *pBstrHelpFile)
 213 {
 214         _ICOM_THIS_From_IErrorInfo(ErrorInfoImpl, iface);
 215         FIXME("(%p)\n", This);
 216
 217         return E_NOTIMPL;
 218 }
 219
 220 static HRESULT WINAPI IErrorInfoImpl_GetHelpContext(
 221         IErrorInfo* iface,
 222         DWORD *pdwHelpContext)
 223 {
 224         _ICOM_THIS_From_IErrorInfo(ErrorInfoImpl, iface);
 225         FIXME("(%p)\n", This);
 226
 227         return E_NOTIMPL;
 228 }
 229
 230 static ICOM_VTABLE(IErrorInfo) IErrorInfoImpl_VTable =
 231 {
 232   ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 233   IErrorInfoImpl_QueryInterface,
 234   IErrorInfoImpl_AddRef,
 235   IErrorInfoImpl_Release,
 236   IErrorInfoImpl_GetTypeInfoCount,
 237   IErrorInfoImpl_GetTypeInfo,
 238   IErrorInfoImpl_GetIDsOfNames,
 239   IErrorInfoImpl_Invoke,
 240
 241   IErrorInfoImpl_GetGUID,
 242   IErrorInfoImpl_GetSource,
 243   IErrorInfoImpl_GetDescription,
 244   IErrorInfoImpl_GetHelpFile,
 245   IErrorInfoImpl_GetHelpContext
 246 };
 247
 248
 249 static HRESULT WINAPI ICreateErrorInfoImpl_QueryInterface(
 250         ICreateErrorInfo* iface,
 251         REFIID     riid,
 252         VOID**     ppvoid)
 253 {
 254         _ICOM_THIS_From_ICreateErrorInfo(ErrorInfoImpl, iface);
 255         TRACE("(%p)\n", This);
 256         return IErrorInfo_QueryInterface(_IErrorInfo_(This), riid, ppvoid);
 257 }
 258
 259 static ULONG WINAPI ICreateErrorInfoImpl_AddRef(
 260         ICreateErrorInfo* iface)
 261 {
 262         _ICOM_THIS_From_ICreateErrorInfo(ErrorInfoImpl, iface);
 263         TRACE("(%p)\n", This);
 264         return IErrorInfo_AddRef(_IErrorInfo_(This));
 265 }
 266
 267 static ULONG WINAPI ICreateErrorInfoImpl_Release(
 268         ICreateErrorInfo* iface)
 269 {
 270         _ICOM_THIS_From_ICreateErrorInfo(ErrorInfoImpl, iface);
 271         TRACE("(%p)\n", This);
 272         return IErrorInfo_Release(_IErrorInfo_(This));
 273 }
 274
 275 static HRESULT WINAPI ICreateErrorInfoImpl_GetTypeInfoCount(
 276         ICreateErrorInfo* iface,
 277         unsigned int* pctinfo)
 278 {
 279         _ICOM_THIS_From_ICreateErrorInfo(ErrorInfoImpl, iface);
 280         TRACE("(%p)\n", This);
 281         return IErrorInfo_GetTypeInfoCount(_IErrorInfo_(This), pctinfo);
 282 }
 283
 284 static HRESULT WINAPI ICreateErrorInfoImpl_GetTypeInfo(
 285         ICreateErrorInfo* iface,
 286         UINT iTInfo,
 287         LCID lcid,
 288         ITypeInfo** ppTInfo)
 289 {
 290         _ICOM_THIS_From_ICreateErrorInfo(ErrorInfoImpl, iface);
 291         TRACE("(%p)\n", This);
 292         return IErrorInfo_GetTypeInfo(_IErrorInfo_(This),iTInfo,lcid,ppTInfo);
 293 }
 294
 295 static HRESULT WINAPI ICreateErrorInfoImpl_GetIDsOfNames(
 296         ICreateErrorInfo* iface,
 297         REFIID riid,
 298         LPOLESTR* rgszNames,
 299         UINT cNames,
 300         LCID lcid,
 301         DISPID* rgDispId)
 302 {
 303         _ICOM_THIS_From_ICreateErrorInfo(ErrorInfoImpl, iface);
 304         TRACE("(%p)\n", This);
 305         return IErrorInfo_GetIDsOfNames(_IErrorInfo_(This),riid,rgszNames,cNames,lcid,rgDispId);
 306 }
 307
 308 static HRESULT WINAPI ICreateErrorInfoImpl_Invoke(
 309         ICreateErrorInfo* iface,
 310         DISPID dispIdMember,
 311         REFIID riid,
 312         LCID lcid,
 313         WORD wFlags,
 314         DISPPARAMS* pDispParams,
 315         VARIANT* pVarResult,
 316         EXCEPINFO* pExepInfo,
 317         UINT* puArgErr)
 318 {
 319         _ICOM_THIS_From_ICreateErrorInfo(ErrorInfoImpl, iface);
 320         TRACE("(%p)\n", This);
 321         return IErrorInfo_Invoke(_IErrorInfo_(This),dispIdMember,riid,lcid,wFlags,pDispParams,
 322                 pVarResult,pExepInfo,puArgErr);
 323 }
 324
 325 static HRESULT WINAPI ICreateErrorInfoImpl_SetGUID(
 326         ICreateErrorInfo* iface,
 327         REFGUID rguid)
 328 {
 329         _ICOM_THIS_From_ICreateErrorInfo(ErrorInfoImpl, iface);
 330         TRACE("(%p)->(%s)\n", This, debugstr_guid(rguid));
 331         This->pGuid = rguid;
 332         return S_OK;
 333 }
 334
 335 static HRESULT WINAPI ICreateErrorInfoImpl_SetSource(
 336         ICreateErrorInfo* iface,
 337         LPOLESTR szSource)
 338 {
 339         _ICOM_THIS_From_ICreateErrorInfo(ErrorInfoImpl, iface);
 340         FIXME("(%p)\n", This);
 341
 342         return E_NOTIMPL;
 343 }
 344
 345 static HRESULT WINAPI ICreateErrorInfoImpl_SetDescription(
 346         ICreateErrorInfo* iface,
 347         LPOLESTR szDescription)
 348 {
 349         _ICOM_THIS_From_ICreateErrorInfo(ErrorInfoImpl, iface);
 350         FIXME("(%p)\n", This);
 351
 352         return E_NOTIMPL;
 353 }
 354
 355 static HRESULT WINAPI ICreateErrorInfoImpl_SetHelpFile(
 356         ICreateErrorInfo* iface,
 357         LPOLESTR szHelpFile)
 358 {
 359         _ICOM_THIS_From_ICreateErrorInfo(ErrorInfoImpl, iface);
 360         FIXME("(%p)\n", This);
 361
 362         return E_NOTIMPL;
 363 }
 364
 365 static HRESULT WINAPI ICreateErrorInfoImpl_SetHelpContext(
 366         ICreateErrorInfo* iface,
 367         DWORD dwHelpContext)
 368 {
 369         _ICOM_THIS_From_ICreateErrorInfo(ErrorInfoImpl, iface);
 370         FIXME("(%p)\n", This);
 371
 372         return E_NOTIMPL;
 373 }
 374
 375 static ICOM_VTABLE(ICreateErrorInfo) ICreateErrorInfoImpl_VTable =
 376 {
 377   ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 378   ICreateErrorInfoImpl_QueryInterface,
 379   ICreateErrorInfoImpl_AddRef,
 380   ICreateErrorInfoImpl_Release,
 381
 382   ICreateErrorInfoImpl_GetTypeInfoCount,
 383   ICreateErrorInfoImpl_GetTypeInfo,
 384   ICreateErrorInfoImpl_GetIDsOfNames,
 385   ICreateErrorInfoImpl_Invoke,
 386
 387   ICreateErrorInfoImpl_SetGUID,
 388   ICreateErrorInfoImpl_SetSource,
 389   ICreateErrorInfoImpl_SetDescription,
 390   ICreateErrorInfoImpl_SetHelpFile,
 391   ICreateErrorInfoImpl_SetHelpContext
 392 };
 393
 394 static HRESULT WINAPI ISupportErrorInfoImpl_QueryInterface(
 395         ISupportErrorInfo* iface,
 396         REFIID     riid,
 397         VOID**     ppvoid)
 398 {
 399         _ICOM_THIS_From_ISupportErrorInfo(ErrorInfoImpl, iface);
 400         FIXME("(%p)\n", This);
 401
 402         return IErrorInfo_QueryInterface(_IErrorInfo_(This), riid, ppvoid);
 403 }
 404
 405 static ULONG WINAPI ISupportErrorInfoImpl_AddRef(
 406         ISupportErrorInfo* iface)
 407 {
 408         _ICOM_THIS_From_ISupportErrorInfo(ErrorInfoImpl, iface);
 409         TRACE("(%p)\n", This);
 410         return IErrorInfo_AddRef(_IErrorInfo_(This));
 411 }
 412
 413 static ULONG WINAPI ISupportErrorInfoImpl_Release(
 414         ISupportErrorInfo* iface)
 415 {
 416         _ICOM_THIS_From_ISupportErrorInfo(ErrorInfoImpl, iface);
 417         TRACE("(%p)\n", This);
 418         return IErrorInfo_Release(_IErrorInfo_(This));
 419 }
 420
 421 static HRESULT WINAPI ISupportErrorInfoImpl_GetTypeInfoCount(
 422         ISupportErrorInfo* iface,
 423         unsigned int* pctinfo)
 424 {
 425         _ICOM_THIS_From_ISupportErrorInfo(ErrorInfoImpl, iface);
 426         TRACE("(%p)\n", This);
 427         return IErrorInfo_GetTypeInfoCount(_IErrorInfo_(This), pctinfo);
 428 }
 429
 430 static HRESULT WINAPI ISupportErrorInfoImpl_GetTypeInfo(
 431         ISupportErrorInfo* iface,
 432         UINT iTInfo,
 433         LCID lcid,
 434         ITypeInfo** ppTInfo)
 435 {
 436         _ICOM_THIS_From_ISupportErrorInfo(ErrorInfoImpl, iface);
 437         TRACE("(%p)\n", This);
 438         return IErrorInfo_GetTypeInfo(_IErrorInfo_(This),iTInfo,lcid,ppTInfo);
 439 }
 440
 441 static HRESULT WINAPI ISupportErrorInfoImpl_GetIDsOfNames(
 442         ISupportErrorInfo* iface,
 443         REFIID riid,
 444         LPOLESTR* rgszNames,
 445         UINT cNames,
 446         LCID lcid,
 447         DISPID* rgDispId)
 448 {
 449         _ICOM_THIS_From_ISupportErrorInfo(ErrorInfoImpl, iface);
 450         TRACE("(%p)\n", This);
 451         return IErrorInfo_GetIDsOfNames(_IErrorInfo_(This),riid,rgszNames,cNames,lcid,rgDispId);
 452 }
 453
 454 static HRESULT WINAPI ISupportErrorInfoImpl_Invoke(
 455         ISupportErrorInfo* iface,
 456         DISPID dispIdMember,
 457         REFIID riid,
 458         LCID lcid,
 459         WORD wFlags,
 460         DISPPARAMS* pDispParams,
 461         VARIANT* pVarResult,
 462         EXCEPINFO* pExepInfo,
 463         UINT* puArgErr)
 464 {
 465         _ICOM_THIS_From_ISupportErrorInfo(ErrorInfoImpl, iface);
 466         TRACE("(%p)\n", This);
 467         return IErrorInfo_Invoke(_IErrorInfo_(This),dispIdMember,riid,lcid,wFlags,pDispParams,
 468                 pVarResult,pExepInfo,puArgErr);
 469 }
 470
 471 static HRESULT WINAPI ISupportErrorInfoImpl_InterfaceSupportsErrorInfo(
 472         ISupportErrorInfo* iface,
 473         REFIID riid)
 474 {
 475         _ICOM_THIS_From_ISupportErrorInfo(ErrorInfoImpl, iface);
 476         TRACE("(%p)->(%s)\n", This, debugstr_guid(riid));
 477         return (riid == This->pGuid) ? S_OK : S_FALSE;
 478 }
 479
 480 static ICOM_VTABLE(ISupportErrorInfo) ISupportErrorInfoImpl_VTable =
 481 {
 482   ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 483   ISupportErrorInfoImpl_QueryInterface,
 484   ISupportErrorInfoImpl_AddRef,
 485   ISupportErrorInfoImpl_Release,
 486
 487   ISupportErrorInfoImpl_GetTypeInfoCount,
 488   ISupportErrorInfoImpl_GetTypeInfo,
 489   ISupportErrorInfoImpl_GetIDsOfNames,
 490   ISupportErrorInfoImpl_Invoke,
 491
 492   ISupportErrorInfoImpl_InterfaceSupportsErrorInfo
 493 };
 494 /***********************************************************************
 495  *              CreateErrorInfo
 496  */
 497 HRESULT WINAPI CreateErrorInfo(ICreateErrorInfo **pperrinfo)
 498 {
 499         IErrorInfo * pei;
 500         HRESULT res;
 501
 502         TRACE("(%p): stub:\n", pperrinfo);
 503
 504         if(! pperrinfo || !*pperrinfo) return E_INVALIDARG;
 505         if(!(pei=IErrorInfoImpl_Constructor()))return E_OUTOFMEMORY;
 506
 507         res = IErrorInfo_QueryInterface(pei, &IID_ICreateErrorInfo, (LPVOID*)pperrinfo);
 508         IErrorInfo_Release(pei);
 509         return res;
 510 }
 511
 512 /***********************************************************************
 513  *              GetErrorInfo
 514  */
 515 HRESULT WINAPI GetErrorInfo(ULONG dwReserved, IErrorInfo **pperrinfo)
 516 {
 517         TRACE("(%ld, %p): stub:\n", dwReserved, pperrinfo);
 518
 519         if(! pperrinfo || !*pperrinfo) return E_INVALIDARG;
 520         if(!(*pperrinfo = (IErrorInfo*)(NtCurrentTeb()->ErrorInfo))) return S_FALSE;
 521
 522         /* clear thread error state */
 523         NtCurrentTeb()->ErrorInfo = NULL;
 524         return S_OK;
 525 }
 526
 527 /***********************************************************************
 528  *              SetErrorInfo
 529  */
 530 HRESULT WINAPI SetErrorInfo(ULONG dwReserved, IErrorInfo *perrinfo)
 531 {
 532         IErrorInfo * pei;
 533         TRACE("(%ld, %p): stub:\n", dwReserved, perrinfo);
 534
 535         /* release old errorinfo */
 536         pei = (IErrorInfo*)NtCurrentTeb()->ErrorInfo;
 537         if(pei) IErrorInfo_Release(pei);
 538
 539         /* set to new value */
 540         NtCurrentTeb()->ErrorInfo = perrinfo;
 541         if(perrinfo) IErrorInfo_AddRef(perrinfo);
 542         return S_OK;
 543 }