Ignore:
Timestamp:
Sep 15, 2001, 11:32:00 AM (24 years ago)
Author:
sandervl
Message:

restored old version + wine update

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/ole32/errorinfo.c

    r6648 r6711  
    1 /* $Id: errorinfo.c,v 1.3 2001-09-05 13:17:09 bird Exp $ */
    21/*
    32 * ErrorInfo API
    … …  
    65 *
    76 *
    8  * The errorinfo is a per-thread object. The reference is stored in the
     7 * The errorinfo is a per-thread object. The reference is stored in the 
    98 * TEB at offset 0xf80
    109 */
    … …  
    3130    WCHAR* stringBuffer;
    3231    DWORD len;
    33 
     32   
    3433    if (in == NULL)
    35     return NULL;
     34        return NULL;
    3635    /*
    3736     * Find the lenth of the buffer passed-in in bytes.
    … …  
    9089{
    9190    DWORD* bufferPointer;
    92 
     91   
    9392    /* NULL is a valid parameter */
    9493    if(!in) return;
    … …  
    112111typedef struct ErrorInfoImpl
    113112{
    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;
     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;
    124123} ErrorInfoImpl;
    125124
    126 static ICOM_VTABLE(IErrorInfo)      IErrorInfoImpl_VTable;
    127 static ICOM_VTABLE(ICreateErrorInfo)    ICreateErrorInfoImpl_VTable;
    128 static ICOM_VTABLE(ISupportErrorInfo)   ISupportErrorInfoImpl_VTable;
     125static ICOM_VTABLE(IErrorInfo)          IErrorInfoImpl_VTable;
     126static ICOM_VTABLE(ICreateErrorInfo)    ICreateErrorInfoImpl_VTable;
     127static ICOM_VTABLE(ISupportErrorInfo)   ISupportErrorInfoImpl_VTable;
    129128
    130129/*
    131130 converts a objectpointer to This
    132131 */
    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);
     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); 
    141140
    142141/*
    143142 converts This to a objectpointer
    144143 */
    145 #define _IErrorInfo_(This)      (IErrorInfo*)&(This->lpvtei)
    146 #define _ICreateErrorInfo_(This)    (ICreateErrorInfo*)&(This->lpvtcei)
    147 #define _ISupportErrorInfo_(This)   (ISupportErrorInfo*)&(This->lpvtsei)
     144#define _IErrorInfo_(This)              (IErrorInfo*)&(This->lpvtei)
     145#define _ICreateErrorInfo_(This)        (ICreateErrorInfo*)&(This->lpvtcei)
     146#define _ISupportErrorInfo_(This)       (ISupportErrorInfo*)&(This->lpvtsei)
    148147
    149148IErrorInfo * IErrorInfoImpl_Constructor()
    150149{
    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;
     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;
    164163}
    165164
    166165
    167166static HRESULT WINAPI IErrorInfoImpl_QueryInterface(
    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;
     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;
    198197}
    199198
    200199static ULONG WINAPI IErrorInfoImpl_AddRef(
    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);
     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);
    206205}
    207206
    208207static ULONG WINAPI IErrorInfoImpl_Release(
    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;
     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;
    221220}
    222221
    223222static HRESULT WINAPI IErrorInfoImpl_GetGUID(
    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;
     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;
    232231}
    233232
    234233static HRESULT WINAPI IErrorInfoImpl_GetSource(
    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;
     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;
    244243}
    245244
    246245static HRESULT WINAPI IErrorInfoImpl_GetDescription(
    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;
     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;
    258257}
    259258
    260259static HRESULT WINAPI IErrorInfoImpl_GetHelpFile(
    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;
     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;
    272271}
    273272
    274273static HRESULT WINAPI IErrorInfoImpl_GetHelpContext(
    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;
     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;
    285284}
    286285
    … …  
    291290  IErrorInfoImpl_AddRef,
    292291  IErrorInfoImpl_Release,
    293 
     292 
    294293  IErrorInfoImpl_GetGUID,
    295294  IErrorInfoImpl_GetSource,
    … …  
    301300
    302301static HRESULT WINAPI ICreateErrorInfoImpl_QueryInterface(
    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);
     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);
    310309}
    311310
    312311static ULONG WINAPI ICreateErrorInfoImpl_AddRef(
    313     ICreateErrorInfo* iface)
    314 {
    315     _ICOM_THIS_From_ICreateErrorInfo(ErrorInfoImpl, iface);
    316     TRACE("(%p)\n", This);
    317     return IErrorInfo_AddRef(_IErrorInfo_(This));
     312        ICreateErrorInfo* iface)
     313{
     314        _ICOM_THIS_From_ICreateErrorInfo(ErrorInfoImpl, iface);
     315        TRACE("(%p)\n", This);
     316        return IErrorInfo_AddRef(_IErrorInfo_(This));
    318317}
    319318
    320319static ULONG WINAPI ICreateErrorInfoImpl_Release(
    321     ICreateErrorInfo* iface)
    322 {
    323     _ICOM_THIS_From_ICreateErrorInfo(ErrorInfoImpl, iface);
    324     TRACE("(%p)\n", This);
    325     return IErrorInfo_Release(_IErrorInfo_(This));
     320        ICreateErrorInfo* iface)
     321{
     322        _ICOM_THIS_From_ICreateErrorInfo(ErrorInfoImpl, iface);
     323        TRACE("(%p)\n", This);
     324        return IErrorInfo_Release(_IErrorInfo_(This));
    326325}
    327326
    328327
    329328static HRESULT WINAPI ICreateErrorInfoImpl_SetGUID(
    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;
     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;
    337336}
    338337
    339338static HRESULT WINAPI ICreateErrorInfoImpl_SetSource(
    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;
     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;
    350349}
    351350
    352351static HRESULT WINAPI ICreateErrorInfoImpl_SetDescription(
    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;
     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;
    363362}
    364363
    365364static HRESULT WINAPI ICreateErrorInfoImpl_SetHelpFile(
    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;
     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;
    376375}
    377376
    378377static HRESULT WINAPI ICreateErrorInfoImpl_SetHelpContext(
    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;
     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;
    387386}
    388387
    … …  
    402401
    403402static HRESULT WINAPI ISupportErrorInfoImpl_QueryInterface(
    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);
     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);
    412411}
    413412
    414413static ULONG WINAPI ISupportErrorInfoImpl_AddRef(
    415     ISupportErrorInfo* iface)
    416 {
    417     _ICOM_THIS_From_ISupportErrorInfo(ErrorInfoImpl, iface);
    418     TRACE("(%p)\n", This);
    419     return IErrorInfo_AddRef(_IErrorInfo_(This));
     414        ISupportErrorInfo* iface)
     415{
     416        _ICOM_THIS_From_ISupportErrorInfo(ErrorInfoImpl, iface);
     417        TRACE("(%p)\n", This);
     418        return IErrorInfo_AddRef(_IErrorInfo_(This));
    420419}
    421420
    422421static ULONG WINAPI ISupportErrorInfoImpl_Release(
    423     ISupportErrorInfo* iface)
    424 {
    425     _ICOM_THIS_From_ISupportErrorInfo(ErrorInfoImpl, iface);
    426     TRACE("(%p)\n", This);
    427     return IErrorInfo_Release(_IErrorInfo_(This));
     422        ISupportErrorInfo* iface)
     423{
     424        _ICOM_THIS_From_ISupportErrorInfo(ErrorInfoImpl, iface);
     425        TRACE("(%p)\n", This);
     426        return IErrorInfo_Release(_IErrorInfo_(This));
    428427}
    429428
    430429
    431430static HRESULT WINAPI ISupportErrorInfoImpl_InterfaceSupportsErrorInfo(
    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;
     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;
    438437}
    439438
    … …  
    449448};
    450449/***********************************************************************
    451  *      CreateErrorInfo
     450 *              CreateErrorInfo
    452451 */
    453452HRESULT WINAPI CreateErrorInfo(ICreateErrorInfo **pperrinfo)
    454453{
    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;
     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;
    464463}
    465464
    466465/***********************************************************************
    467  *      GetErrorInfo
     466 *              GetErrorInfo
    468467 */
    469468HRESULT WINAPI GetErrorInfo(ULONG dwReserved, IErrorInfo **pperrinfo)
    470469{
    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;
     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;
    479478}
    480479
    481480/***********************************************************************
    482  *      SetErrorInfo
     481 *              SetErrorInfo
    483482 */
    484483HRESULT WINAPI SetErrorInfo(ULONG dwReserved, IErrorInfo *perrinfo)
    485484{
    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 }
     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}
Note: See TracChangeset for help on using the changeset viewer.