Ignore:
Timestamp:
Sep 5, 2001, 3:19:02 PM (24 years ago)
Author:
bird
Message:

Added $Id:$ keyword.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/ole32/errorinfo.c

    r5602 r6648  
     1/* $Id: errorinfo.c,v 1.3 2001-09-05 13:17:09 bird Exp $ */
    12/*
    23 * ErrorInfo API
    … …  
    56 *
    67 *
    7  * The errorinfo is a per-thread object. The reference is stored in the 
     8 * The errorinfo is a per-thread object. The reference is stored in the
    89 * TEB at offset 0xf80
    910 */
    … …  
    3031    WCHAR* stringBuffer;
    3132    DWORD len;
    32    
     33
    3334    if (in == NULL)
    34         return NULL;
     35    return NULL;
    3536    /*
    3637     * Find the lenth of the buffer passed-in in bytes.
    … …  
    8990{
    9091    DWORD* bufferPointer;
    91    
     92
    9293    /* NULL is a valid parameter */
    9394    if(!in) return;
    … …  
    111112typedef struct ErrorInfoImpl
    112113{
    113         ICOM_VTABLE(IErrorInfo)         *lpvtei;
    114         ICOM_VTABLE(ICreateErrorInfo)   *lpvtcei;
    115         ICOM_VTABLE(ISupportErrorInfo)  *lpvtsei;
    116         DWORD                           ref;
    117        
    118         GUID m_Guid;
    119         BSTR bstrSource;
    120         BSTR bstrDescription;
    121         BSTR bstrHelpFile;
    122         DWORD m_dwHelpContext;
     114    ICOM_VTABLE(IErrorInfo)     *lpvtei;
     115    ICOM_VTABLE(ICreateErrorInfo)   *lpvtcei;
     116    ICOM_VTABLE(ISupportErrorInfo)  *lpvtsei;
     117    DWORD               ref;
     118
     119    GUID m_Guid;
     120    BSTR bstrSource;
     121    BSTR bstrDescription;
     122    BSTR bstrHelpFile;
     123    DWORD m_dwHelpContext;
    123124} ErrorInfoImpl;
    124125
    125 static ICOM_VTABLE(IErrorInfo)          IErrorInfoImpl_VTable;
    126 static ICOM_VTABLE(ICreateErrorInfo)    ICreateErrorInfoImpl_VTable;
    127 static ICOM_VTABLE(ISupportErrorInfo)   ISupportErrorInfoImpl_VTable;
     126static ICOM_VTABLE(IErrorInfo)      IErrorInfoImpl_VTable;
     127static ICOM_VTABLE(ICreateErrorInfo)    ICreateErrorInfoImpl_VTable;
     128static ICOM_VTABLE(ISupportErrorInfo)   ISupportErrorInfoImpl_VTable;
    128129
    129130/*
    130131 converts a objectpointer to This
    131132 */
    132 #define _IErrorInfo_Offset ((int)(&(((ErrorInfoImpl*)0)->lpvtei))) 
    133 #define _ICOM_THIS_From_IErrorInfo(class, name) class* This = (class*)(((char*)name)-_IErrorInfo_Offset); 
    134 
    135 #define _ICreateErrorInfo_Offset ((int)(&(((ErrorInfoImpl*)0)->lpvtcei))) 
    136 #define _ICOM_THIS_From_ICreateErrorInfo(class, name) class* This = (class*)(((char*)name)-_ICreateErrorInfo_Offset); 
    137 
    138 #define _ISupportErrorInfo_Offset ((int)(&(((ErrorInfoImpl*)0)->lpvtsei))) 
    139 #define _ICOM_THIS_From_ISupportErrorInfo(class, name) class* This = (class*)(((char*)name)-_ISupportErrorInfo_Offset); 
     133#define _IErrorInfo_Offset ((int)(&(((ErrorInfoImpl*)0)->lpvtei)))
     134#define _ICOM_THIS_From_IErrorInfo(class, name) class* This = (class*)(((char*)name)-_IErrorInfo_Offset);
     135
     136#define _ICreateErrorInfo_Offset ((int)(&(((ErrorInfoImpl*)0)->lpvtcei)))
     137#define _ICOM_THIS_From_ICreateErrorInfo(class, name) class* This = (class*)(((char*)name)-_ICreateErrorInfo_Offset);
     138
     139#define _ISupportErrorInfo_Offset ((int)(&(((ErrorInfoImpl*)0)->lpvtsei)))
     140#define _ICOM_THIS_From_ISupportErrorInfo(class, name) class* This = (class*)(((char*)name)-_ISupportErrorInfo_Offset);
    140141
    141142/*
    142143 converts This to a objectpointer
    143144 */
    144 #define _IErrorInfo_(This)              (IErrorInfo*)&(This->lpvtei)
    145 #define _ICreateErrorInfo_(This)        (ICreateErrorInfo*)&(This->lpvtcei)
    146 #define _ISupportErrorInfo_(This)       (ISupportErrorInfo*)&(This->lpvtsei)
     145#define _IErrorInfo_(This)      (IErrorInfo*)&(This->lpvtei)
     146#define _ICreateErrorInfo_(This)    (ICreateErrorInfo*)&(This->lpvtcei)
     147#define _ISupportErrorInfo_(This)   (ISupportErrorInfo*)&(This->lpvtsei)
    147148
    148149IErrorInfo * IErrorInfoImpl_Constructor()
    149150{
    150         ErrorInfoImpl * ei = HeapAlloc(GetProcessHeap(), 0, sizeof(ErrorInfoImpl));
    151         if (ei)
    152         {
    153           ei->lpvtei = &IErrorInfoImpl_VTable;
    154           ei->lpvtcei = &ICreateErrorInfoImpl_VTable;
    155           ei->lpvtsei = &ISupportErrorInfoImpl_VTable;
    156           ei->ref = 1;
    157           ei->bstrSource = NULL;
    158           ei->bstrDescription = NULL;
    159           ei->bstrHelpFile = NULL;
    160           ei->m_dwHelpContext = 0;
    161         }
    162         return (IErrorInfo *)ei;
     151    ErrorInfoImpl * ei = HeapAlloc(GetProcessHeap(), 0, sizeof(ErrorInfoImpl));
     152    if (ei)
     153    {
     154      ei->lpvtei = &IErrorInfoImpl_VTable;
     155      ei->lpvtcei = &ICreateErrorInfoImpl_VTable;
     156      ei->lpvtsei = &ISupportErrorInfoImpl_VTable;
     157      ei->ref = 1;
     158      ei->bstrSource = NULL;
     159      ei->bstrDescription = NULL;
     160      ei->bstrHelpFile = NULL;
     161      ei->m_dwHelpContext = 0;
     162    }
     163    return (IErrorInfo *)ei;
    163164}
    164165
    165166
    166167static HRESULT WINAPI IErrorInfoImpl_QueryInterface(
    167         IErrorInfo* iface,
    168         REFIID     riid,
    169         VOID**     ppvoid)
    170 {
    171         _ICOM_THIS_From_IErrorInfo(ErrorInfoImpl, iface);
    172         TRACE("(%p)->(\n\tIID:\t%s,%p)\n",This,debugstr_guid(riid),ppvoid);
    173 
    174         *ppvoid = NULL;
    175 
    176         if(IsEqualIID(riid, &IID_IErrorInfo))
    177         {
    178           *ppvoid = _IErrorInfo_(This);
    179         }
    180         else if(IsEqualIID(riid, &IID_ICreateErrorInfo))
    181         {
    182           *ppvoid = _ICreateErrorInfo_(This);
    183         }
    184         else if(IsEqualIID(riid, &IID_ISupportErrorInfo))
    185         {
    186           *ppvoid = _ISupportErrorInfo_(This);
    187         }
    188 
    189         if(*ppvoid)
    190         {
    191           IUnknown_AddRef( (IUnknown*)*ppvoid );
    192           TRACE("-- Interface: (%p)->(%p)\n",ppvoid,*ppvoid);
    193           return S_OK;
    194         }
    195         TRACE("-- Interface: E_NOINTERFACE\n");
    196         return E_NOINTERFACE;
     168    IErrorInfo* iface,
     169    REFIID     riid,
     170    VOID**     ppvoid)
     171{
     172    _ICOM_THIS_From_IErrorInfo(ErrorInfoImpl, iface);
     173    TRACE("(%p)->(\n\tIID:\t%s,%p)\n",This,debugstr_guid(riid),ppvoid);
     174
     175    *ppvoid = NULL;
     176
     177    if(IsEqualIID(riid, &IID_IErrorInfo))
     178    {
     179      *ppvoid = _IErrorInfo_(This);
     180    }
     181    else if(IsEqualIID(riid, &IID_ICreateErrorInfo))
     182    {
     183      *ppvoid = _ICreateErrorInfo_(This);
     184    }
     185    else if(IsEqualIID(riid, &IID_ISupportErrorInfo))
     186    {
     187      *ppvoid = _ISupportErrorInfo_(This);
     188    }
     189
     190    if(*ppvoid)
     191    {
     192      IUnknown_AddRef( (IUnknown*)*ppvoid );
     193      TRACE("-- Interface: (%p)->(%p)\n",ppvoid,*ppvoid);
     194      return S_OK;
     195    }
     196    TRACE("-- Interface: E_NOINTERFACE\n");
     197    return E_NOINTERFACE;
    197198}
    198199
    199200static ULONG WINAPI IErrorInfoImpl_AddRef(
    200         IErrorInfo* iface)
    201 {
    202         _ICOM_THIS_From_IErrorInfo(ErrorInfoImpl, iface);
    203         TRACE("(%p)->(count=%lu)\n",This,This->ref);
    204         return InterlockedIncrement(&This->ref);
     201    IErrorInfo* iface)
     202{
     203    _ICOM_THIS_From_IErrorInfo(ErrorInfoImpl, iface);
     204    TRACE("(%p)->(count=%lu)\n",This,This->ref);
     205    return InterlockedIncrement(&This->ref);
    205206}
    206207
    207208static ULONG WINAPI IErrorInfoImpl_Release(
    208         IErrorInfo* iface)
    209 {
    210         _ICOM_THIS_From_IErrorInfo(ErrorInfoImpl, iface);
    211         TRACE("(%p)->(count=%lu)\n",This,This->ref);
    212 
    213         if (!InterlockedDecrement(&This->ref))
    214         {
    215           TRACE("-- destroying IErrorInfo(%p)\n",This);
    216           HeapFree(GetProcessHeap(),0,This);
    217           return 0;
    218         }
    219         return This->ref;
     209    IErrorInfo* iface)
     210{
     211    _ICOM_THIS_From_IErrorInfo(ErrorInfoImpl, iface);
     212    TRACE("(%p)->(count=%lu)\n",This,This->ref);
     213
     214    if (!InterlockedDecrement(&This->ref))
     215    {
     216      TRACE("-- destroying IErrorInfo(%p)\n",This);
     217      HeapFree(GetProcessHeap(),0,This);
     218      return 0;
     219    }
     220    return This->ref;
    220221}
    221222
    222223static HRESULT WINAPI IErrorInfoImpl_GetGUID(
    223         IErrorInfo* iface,
    224         GUID * pGUID)
    225 {
    226         _ICOM_THIS_From_IErrorInfo(ErrorInfoImpl, iface);
    227         TRACE("(%p)->(count=%lu)\n",This,This->ref);
    228         if(!pGUID )return E_INVALIDARG;
    229         memcpy(pGUID, &This->m_Guid, sizeof(GUID));
    230         return S_OK;
     224    IErrorInfo* iface,
     225    GUID * pGUID)
     226{
     227    _ICOM_THIS_From_IErrorInfo(ErrorInfoImpl, iface);
     228    TRACE("(%p)->(count=%lu)\n",This,This->ref);
     229    if(!pGUID )return E_INVALIDARG;
     230    memcpy(pGUID, &This->m_Guid, sizeof(GUID));
     231    return S_OK;
    231232}
    232233
    233234static HRESULT WINAPI IErrorInfoImpl_GetSource(
    234         IErrorInfo* iface,
    235         BSTR *pBstrSource)
    236 {
    237         _ICOM_THIS_From_IErrorInfo(ErrorInfoImpl, iface);
    238         TRACE("(%p)->(pBstrSource=%p)\n",This,pBstrSource);
    239         if (pBstrSource == NULL)
    240             return E_INVALIDARG;
    241         *pBstrSource = ERRORINFO_SysAllocString(This->bstrSource);
    242         return S_OK;
     235    IErrorInfo* iface,
     236    BSTR *pBstrSource)
     237{
     238    _ICOM_THIS_From_IErrorInfo(ErrorInfoImpl, iface);
     239    TRACE("(%p)->(pBstrSource=%p)\n",This,pBstrSource);
     240    if (pBstrSource == NULL)
     241        return E_INVALIDARG;
     242    *pBstrSource = ERRORINFO_SysAllocString(This->bstrSource);
     243    return S_OK;
    243244}
    244245
    245246static HRESULT WINAPI IErrorInfoImpl_GetDescription(
    246         IErrorInfo* iface,
    247         BSTR *pBstrDescription)
    248 {
    249         _ICOM_THIS_From_IErrorInfo(ErrorInfoImpl, iface);
    250 
    251         TRACE("(%p)->(pBstrDescription=%p)\n",This,pBstrDescription);
    252         if (pBstrDescription == NULL)
    253             return E_INVALIDARG;
    254         *pBstrDescription = ERRORINFO_SysAllocString(This->bstrDescription);
    255        
    256         return S_OK;
     247    IErrorInfo* iface,
     248    BSTR *pBstrDescription)
     249{
     250    _ICOM_THIS_From_IErrorInfo(ErrorInfoImpl, iface);
     251
     252    TRACE("(%p)->(pBstrDescription=%p)\n",This,pBstrDescription);
     253    if (pBstrDescription == NULL)
     254        return E_INVALIDARG;
     255    *pBstrDescription = ERRORINFO_SysAllocString(This->bstrDescription);
     256
     257    return S_OK;
    257258}
    258259
    259260static HRESULT WINAPI IErrorInfoImpl_GetHelpFile(
    260         IErrorInfo* iface,
    261         BSTR *pBstrHelpFile)
    262 {
    263         _ICOM_THIS_From_IErrorInfo(ErrorInfoImpl, iface);
    264 
    265         TRACE("(%p)->(pBstrHelpFile=%p)\n",This, pBstrHelpFile);
    266         if (pBstrHelpFile == NULL)
    267             return E_INVALIDARG;
    268         *pBstrHelpFile = ERRORINFO_SysAllocString(This->bstrHelpFile);
    269        
    270         return S_OK;
     261    IErrorInfo* iface,
     262    BSTR *pBstrHelpFile)
     263{
     264    _ICOM_THIS_From_IErrorInfo(ErrorInfoImpl, iface);
     265
     266    TRACE("(%p)->(pBstrHelpFile=%p)\n",This, pBstrHelpFile);
     267    if (pBstrHelpFile == NULL)
     268        return E_INVALIDARG;
     269    *pBstrHelpFile = ERRORINFO_SysAllocString(This->bstrHelpFile);
     270
     271    return S_OK;
    271272}
    272273
    273274static HRESULT WINAPI IErrorInfoImpl_GetHelpContext(
    274         IErrorInfo* iface,
    275         DWORD *pdwHelpContext)
    276 {
    277         _ICOM_THIS_From_IErrorInfo(ErrorInfoImpl, iface);
    278         TRACE("(%p)->(pdwHelpContext=%p)\n",This, pdwHelpContext);
    279         if (pdwHelpContext == NULL)
    280             return E_INVALIDARG;
    281         *pdwHelpContext = This->m_dwHelpContext;
    282        
    283         return S_OK;
     275    IErrorInfo* iface,
     276    DWORD *pdwHelpContext)
     277{
     278    _ICOM_THIS_From_IErrorInfo(ErrorInfoImpl, iface);
     279    TRACE("(%p)->(pdwHelpContext=%p)\n",This, pdwHelpContext);
     280    if (pdwHelpContext == NULL)
     281        return E_INVALIDARG;
     282    *pdwHelpContext = This->m_dwHelpContext;
     283
     284    return S_OK;
    284285}
    285286
    … …  
    290291  IErrorInfoImpl_AddRef,
    291292  IErrorInfoImpl_Release,
    292  
     293
    293294  IErrorInfoImpl_GetGUID,
    294295  IErrorInfoImpl_GetSource,
    … …  
    300301
    301302static HRESULT WINAPI ICreateErrorInfoImpl_QueryInterface(
    302         ICreateErrorInfo* iface,
    303         REFIID     riid,
    304         VOID**     ppvoid)
    305 {
    306         _ICOM_THIS_From_ICreateErrorInfo(ErrorInfoImpl, iface);
    307         TRACE("(%p)\n", This);
    308         return IErrorInfo_QueryInterface(_IErrorInfo_(This), riid, ppvoid);
     303    ICreateErrorInfo* iface,
     304    REFIID     riid,
     305    VOID**     ppvoid)
     306{
     307    _ICOM_THIS_From_ICreateErrorInfo(ErrorInfoImpl, iface);
     308    TRACE("(%p)\n", This);
     309    return IErrorInfo_QueryInterface(_IErrorInfo_(This), riid, ppvoid);
    309310}
    310311
    311312static ULONG WINAPI ICreateErrorInfoImpl_AddRef(
    312         ICreateErrorInfo* iface)
    313 {
    314         _ICOM_THIS_From_ICreateErrorInfo(ErrorInfoImpl, iface);
    315         TRACE("(%p)\n", This);
    316         return IErrorInfo_AddRef(_IErrorInfo_(This));
     313    ICreateErrorInfo* iface)
     314{
     315    _ICOM_THIS_From_ICreateErrorInfo(ErrorInfoImpl, iface);
     316    TRACE("(%p)\n", This);
     317    return IErrorInfo_AddRef(_IErrorInfo_(This));
    317318}
    318319
    319320static ULONG WINAPI ICreateErrorInfoImpl_Release(
    320         ICreateErrorInfo* iface)
    321 {
    322         _ICOM_THIS_From_ICreateErrorInfo(ErrorInfoImpl, iface);
    323         TRACE("(%p)\n", This);
    324         return IErrorInfo_Release(_IErrorInfo_(This));
     321    ICreateErrorInfo* iface)
     322{
     323    _ICOM_THIS_From_ICreateErrorInfo(ErrorInfoImpl, iface);
     324    TRACE("(%p)\n", This);
     325    return IErrorInfo_Release(_IErrorInfo_(This));
    325326}
    326327
    327328
    328329static HRESULT WINAPI ICreateErrorInfoImpl_SetGUID(
    329         ICreateErrorInfo* iface,
    330         REFGUID rguid)
    331 {
    332         _ICOM_THIS_From_ICreateErrorInfo(ErrorInfoImpl, iface);
    333         TRACE("(%p)->(%s)\n", This, debugstr_guid(rguid));
    334         memcpy(&This->m_Guid,  rguid, sizeof(GUID));
    335         return S_OK;
     330    ICreateErrorInfo* iface,
     331    REFGUID rguid)
     332{
     333    _ICOM_THIS_From_ICreateErrorInfo(ErrorInfoImpl, iface);
     334    TRACE("(%p)->(%s)\n", This, debugstr_guid(rguid));
     335    memcpy(&This->m_Guid,  rguid, sizeof(GUID));
     336    return S_OK;
    336337}
    337338
    338339static HRESULT WINAPI ICreateErrorInfoImpl_SetSource(
    339         ICreateErrorInfo* iface,
    340         LPOLESTR szSource)
    341 {
    342         _ICOM_THIS_From_ICreateErrorInfo(ErrorInfoImpl, iface);
    343         TRACE("(%p)\n",This);
    344         if (This->bstrSource != NULL)
    345             ERRORINFO_SysFreeString(This->bstrSource);
    346         This->bstrSource = ERRORINFO_SysAllocString(szSource);
    347        
    348         return S_OK;
     340    ICreateErrorInfo* iface,
     341    LPOLESTR szSource)
     342{
     343    _ICOM_THIS_From_ICreateErrorInfo(ErrorInfoImpl, iface);
     344    TRACE("(%p)\n",This);
     345    if (This->bstrSource != NULL)
     346        ERRORINFO_SysFreeString(This->bstrSource);
     347    This->bstrSource = ERRORINFO_SysAllocString(szSource);
     348
     349    return S_OK;
    349350}
    350351
    351352static HRESULT WINAPI ICreateErrorInfoImpl_SetDescription(
    352         ICreateErrorInfo* iface,
    353         LPOLESTR szDescription)
    354 {
    355         _ICOM_THIS_From_ICreateErrorInfo(ErrorInfoImpl, iface);
    356         TRACE("(%p)\n",This);
    357         if (This->bstrDescription != NULL)
    358             ERRORINFO_SysFreeString(This->bstrDescription);
    359         This->bstrDescription = ERRORINFO_SysAllocString(szDescription);
    360        
    361         return S_OK;
     353    ICreateErrorInfo* iface,
     354    LPOLESTR szDescription)
     355{
     356    _ICOM_THIS_From_ICreateErrorInfo(ErrorInfoImpl, iface);
     357    TRACE("(%p)\n",This);
     358    if (This->bstrDescription != NULL)
     359        ERRORINFO_SysFreeString(This->bstrDescription);
     360    This->bstrDescription = ERRORINFO_SysAllocString(szDescription);
     361
     362    return S_OK;
    362363}
    363364
    364365static HRESULT WINAPI ICreateErrorInfoImpl_SetHelpFile(
    365         ICreateErrorInfo* iface,
    366         LPOLESTR szHelpFile)
    367 {
    368         _ICOM_THIS_From_ICreateErrorInfo(ErrorInfoImpl, iface);
    369         TRACE("(%p)\n",This);
    370         if (This->bstrHelpFile != NULL)
    371             ERRORINFO_SysFreeString(This->bstrHelpFile);
    372         This->bstrHelpFile = ERRORINFO_SysAllocString(szHelpFile);
    373 
    374         return S_OK;
     366    ICreateErrorInfo* iface,
     367    LPOLESTR szHelpFile)
     368{
     369    _ICOM_THIS_From_ICreateErrorInfo(ErrorInfoImpl, iface);
     370    TRACE("(%p)\n",This);
     371    if (This->bstrHelpFile != NULL)
     372        ERRORINFO_SysFreeString(This->bstrHelpFile);
     373    This->bstrHelpFile = ERRORINFO_SysAllocString(szHelpFile);
     374
     375    return S_OK;
    375376}
    376377
    377378static HRESULT WINAPI ICreateErrorInfoImpl_SetHelpContext(
    378         ICreateErrorInfo* iface,
    379         DWORD dwHelpContext)
    380 {
    381         _ICOM_THIS_From_ICreateErrorInfo(ErrorInfoImpl, iface);
    382         TRACE("(%p)\n",This);
    383         This->m_dwHelpContext = dwHelpContext;
    384        
    385         return S_OK;
     379    ICreateErrorInfo* iface,
     380    DWORD dwHelpContext)
     381{
     382    _ICOM_THIS_From_ICreateErrorInfo(ErrorInfoImpl, iface);
     383    TRACE("(%p)\n",This);
     384    This->m_dwHelpContext = dwHelpContext;
     385
     386    return S_OK;
    386387}
    387388
    … …  
    401402
    402403static HRESULT WINAPI ISupportErrorInfoImpl_QueryInterface(
    403         ISupportErrorInfo* iface,
    404         REFIID     riid,
    405         VOID**     ppvoid)
    406 {
    407         _ICOM_THIS_From_ISupportErrorInfo(ErrorInfoImpl, iface);
    408         TRACE("(%p)\n", This);
    409        
    410         return IErrorInfo_QueryInterface(_IErrorInfo_(This), riid, ppvoid);
     404    ISupportErrorInfo* iface,
     405    REFIID     riid,
     406    VOID**     ppvoid)
     407{
     408    _ICOM_THIS_From_ISupportErrorInfo(ErrorInfoImpl, iface);
     409    TRACE("(%p)\n", This);
     410
     411    return IErrorInfo_QueryInterface(_IErrorInfo_(This), riid, ppvoid);
    411412}
    412413
    413414static ULONG WINAPI ISupportErrorInfoImpl_AddRef(
    414         ISupportErrorInfo* iface)
    415 {
    416         _ICOM_THIS_From_ISupportErrorInfo(ErrorInfoImpl, iface);
    417         TRACE("(%p)\n", This);
    418         return IErrorInfo_AddRef(_IErrorInfo_(This));
     415    ISupportErrorInfo* iface)
     416{
     417    _ICOM_THIS_From_ISupportErrorInfo(ErrorInfoImpl, iface);
     418    TRACE("(%p)\n", This);
     419    return IErrorInfo_AddRef(_IErrorInfo_(This));
    419420}
    420421
    421422static ULONG WINAPI ISupportErrorInfoImpl_Release(
    422         ISupportErrorInfo* iface)
    423 {
    424         _ICOM_THIS_From_ISupportErrorInfo(ErrorInfoImpl, iface);
    425         TRACE("(%p)\n", This);
    426         return IErrorInfo_Release(_IErrorInfo_(This));
     423    ISupportErrorInfo* iface)
     424{
     425    _ICOM_THIS_From_ISupportErrorInfo(ErrorInfoImpl, iface);
     426    TRACE("(%p)\n", This);
     427    return IErrorInfo_Release(_IErrorInfo_(This));
    427428}
    428429
    429430
    430431static HRESULT WINAPI ISupportErrorInfoImpl_InterfaceSupportsErrorInfo(
    431         ISupportErrorInfo* iface,
    432         REFIID riid)
    433 {
    434         _ICOM_THIS_From_ISupportErrorInfo(ErrorInfoImpl, iface);
    435         TRACE("(%p)->(%s)\n", This, debugstr_guid(riid));
    436         return (IsEqualIID(riid, &This->m_Guid)) ? S_OK : S_FALSE;
     432    ISupportErrorInfo* iface,
     433    REFIID riid)
     434{
     435    _ICOM_THIS_From_ISupportErrorInfo(ErrorInfoImpl, iface);
     436    TRACE("(%p)->(%s)\n", This, debugstr_guid(riid));
     437    return (IsEqualIID(riid, &This->m_Guid)) ? S_OK : S_FALSE;
    437438}
    438439
    … …  
    448449};
    449450/***********************************************************************
    450  *              CreateErrorInfo
     451 *      CreateErrorInfo
    451452 */
    452453HRESULT WINAPI CreateErrorInfo(ICreateErrorInfo **pperrinfo)
    453454{
    454         IErrorInfo * pei;
    455         HRESULT res;
    456         TRACE("(%p): stub:\n", pperrinfo);
    457         if(! pperrinfo ) return E_INVALIDARG;
    458         if(!(pei=IErrorInfoImpl_Constructor()))return E_OUTOFMEMORY;
    459        
    460         res = IErrorInfo_QueryInterface(pei, &IID_ICreateErrorInfo, (LPVOID*)pperrinfo);
    461         IErrorInfo_Release(pei);
    462         return res;
     455    IErrorInfo * pei;
     456    HRESULT res;
     457    TRACE("(%p): stub:\n", pperrinfo);
     458    if(! pperrinfo ) return E_INVALIDARG;
     459    if(!(pei=IErrorInfoImpl_Constructor()))return E_OUTOFMEMORY;
     460
     461    res = IErrorInfo_QueryInterface(pei, &IID_ICreateErrorInfo, (LPVOID*)pperrinfo);
     462    IErrorInfo_Release(pei);
     463    return res;
    463464}
    464465
    465466/***********************************************************************
    466  *              GetErrorInfo
     467 *      GetErrorInfo
    467468 */
    468469HRESULT WINAPI GetErrorInfo(ULONG dwReserved, IErrorInfo **pperrinfo)
    469470{
    470         TRACE("(%ld, %p, %p): stub:\n", dwReserved, pperrinfo, NtCurrentTeb()->ErrorInfo);
    471 
    472         if(! pperrinfo ) return E_INVALIDARG;
    473         if(!(*pperrinfo = (IErrorInfo*)(NtCurrentTeb()->ErrorInfo))) return S_FALSE;
    474 
    475         /* clear thread error state */
    476         NtCurrentTeb()->ErrorInfo = NULL;
    477         return S_OK;
     471    TRACE("(%ld, %p, %p): stub:\n", dwReserved, pperrinfo, NtCurrentTeb()->ErrorInfo);
     472
     473    if(! pperrinfo ) return E_INVALIDARG;
     474    if(!(*pperrinfo = (IErrorInfo*)(NtCurrentTeb()->ErrorInfo))) return S_FALSE;
     475
     476    /* clear thread error state */
     477    NtCurrentTeb()->ErrorInfo = NULL;
     478    return S_OK;
    478479}
    479480
    480481/***********************************************************************
    481  *              SetErrorInfo
     482 *      SetErrorInfo
    482483 */
    483484HRESULT WINAPI SetErrorInfo(ULONG dwReserved, IErrorInfo *perrinfo)
    484485{
    485         IErrorInfo * pei;
    486         TRACE("(%ld, %p): stub:\n", dwReserved, perrinfo);
    487 
    488         /* release old errorinfo */
    489         pei = (IErrorInfo*)NtCurrentTeb()->ErrorInfo;
    490         if(pei) IErrorInfo_Release(pei);
    491 
    492         /* set to new value */
    493         NtCurrentTeb()->ErrorInfo = perrinfo;
    494         if(perrinfo) IErrorInfo_AddRef(perrinfo);
    495         return S_OK;
    496 }
     486    IErrorInfo * pei;
     487    TRACE("(%ld, %p): stub:\n", dwReserved, perrinfo);
     488
     489    /* release old errorinfo */
     490    pei = (IErrorInfo*)NtCurrentTeb()->ErrorInfo;
     491    if(pei) IErrorInfo_Release(pei);
     492
     493    /* set to new value */
     494    NtCurrentTeb()->ErrorInfo = perrinfo;
     495    if(perrinfo) IErrorInfo_AddRef(perrinfo);
     496    return S_OK;
     497}
Note: See TracChangeset for help on using the changeset viewer.