for(SDirectoryRecord* pRecord3 = pRecord1->m_pFirstRecord; pRecord3;)
{
  for(;pRecord3 != NULL; pRecord3 = pRecord3->m_pNextDirectory) 
  {

[skip]

VD>Да в твоем случае дейсвтительно лишние извраты.

P>equal:
P>for(SDirectoryRecord* pRecord3 = pRecord1->m_pFirstRecord; pRecord3 != NULL; pRecord3 = pRecord3->m_pNextDirectory) {
P>   if(pRecord3 != pRecord2 && pRecord2->m_nLevel == pRecord3->m_nLevel) {
P>       nRes = CompareRecord(pRecord2, pRecord3, nType) == 0 ? CCB_ERR_EQUAL_ID : CCB_ERR_NOERROR;
P>       if(nRes != CCB_ERR_NOERROR) {
P>            pCheckControl->m_data1 = reinterpret_cast<long>(pRecord2);
P>            pCheckControl->m_data2 = reinterpret_cast<long>(pRecord3);
P>            nCallBackRes = pCheckControl->DoControl(nRes); //Передается юзеру, который должен как-то отреагировать на ошибку
P>            nErrorCount++;
P>            
P>            if(nCallBackRes == CCB_RES_MAKEAUTO || nCallBackRes == CCB_RES_IGNORE) continue; //OK, продолжаем дальше
P>            else if(nCallBackRes == CCB_RES_ABORT) return nErrorCount; //Failed, отмена
P>            else goto equal; //Юзер попытался исправить ошибку, надо проверить заново
P>       }
P>   }
P>}

P>

for(SDirectoryRecord* pRecord3 = pRecord1->m_pFirstRecord; pRecord3 != NULL; pRecord3 = pRecord3->m_pNextDirectory) {
   if(pRecord3 != pRecord2 && pRecord2->m_nLevel == pRecord3->m_nLevel) {
       nRes = CompareRecord(pRecord2, pRecord3, nType) == 0 ? CCB_ERR_EQUAL_ID : CCB_ERR_NOERROR;
       if(nRes != CCB_ERR_NOERROR) {
            pCheckControl->m_data1 = reinterpret_cast<long>(pRecord2);
            pCheckControl->m_data2 = reinterpret_cast<long>(pRecord3);
            nCallBackRes = pCheckControl->DoControl(nRes); //Передается юзеру, который должен как-то отреагировать на ошибку
            nErrorCount++;
            
            if(nCallBackRes == CCB_RES_MAKEAUTO || nCallBackRes == CCB_RES_IGNORE) continue; //OK, продолжаем дальше
            else if(nCallBackRes == CCB_RES_ABORT) return nErrorCount; //Failed, отмена
            else
            {
                pRecord3 = pRecord1->m_pFirstRecord; //Юзер попытался исправить ошибку, надо проверить заново
                continue;
             }
       }
   }
}

#define START  int _err_code = 0;
#define ERROR  error:
#define EXIT   return _err_code;
#define CHECK(er,test) if (!(test)) { _err_code = er; goto _error; }

int foo(void *p)
{
    START;

    CHECK(1,p);
    // and so on

    ERROR:
    // some cleanup code
    EXIT;
}

HRESULT CFile::CopyFile(IMetaDataDispenserEx *pDisp, bool bCleanup)
{
    HRESULT hr = S_OK;
    if (m_SrcFile != NULL && _wcsicmp(m_SrcFile, m_Path) != 0) {
        if (W_CopyFile(m_SrcFile, m_Path, FALSE) == FALSE)
            return ReportError(HRESULT_FROM_WIN32(GetLastError()));
        bCleanup = true;
    } else
        hr = S_FALSE; // FLASE because we did nothing

    if (bCleanup) {
        mdToken tkAR, tkAttrib[4] = {mdTokenNil, mdTokenNil, mdTokenNil, mdTokenNil };
        const static WCHAR names [4][2] = {  {0,0}, {'S', 0}, {'M', 0}, {'S', 'M'} };
        CTokenMap Map;
        ALPEFile module;
        CComPtr<IMetaDataEmit> pNewEmit, pOldEmit;
        CComPtr<IMetaDataAssemblyImport> pAImport;
        CComPtr<IMetaDataFilter> pFilter;
        ULONG count;
        mdAssemblyRef ar[4];
        HCORENUM hEnum = NULL;

        if (FAILED(hr = module.OpenFileAs( pDisp, m_Path, true, true)))
            // A COM+ or WIN32 error
            goto CLEANUP;

        if (FAILED(hr = pDisp->DefineScope(CLSID_CorMetaDataRuntime,   // Format of metadata
                                           0,                           // flags
                                           IID_IMetaDataEmit,           // Emitting interface
                                           (IUnknown **) &pNewEmit)))
            goto CLEANUP;

        if (FAILED(hr = module.pImport->QueryInterface(IID_IMetaDataAssemblyImport, (void**)&pAImport))||
            FAILED(hr = module.pImport->QueryInterface(IID_IMetaDataEmit, (void**)&pOldEmit)) ||
            FAILED(hr = module.pImport->QueryInterface(IID_IMetaDataFilter, (void**)&pFilter)))
            goto CLEANUP;


        while (SUCCEEDED(pAImport->EnumAssemblyRefs( &hEnum, ar, lengthof(ar), &count)) && count > 0) {
            ULONG len = 0;
            WCHAR buffer[32];
            for (ULONG i = 0; i < count; i++) {
                if (FAILED(hr = pAImport->GetAssemblyRefProps( ar[i], NULL, NULL, buffer, lengthof(buffer), &len, NULL, NULL, NULL, NULL))) {
                    pAImport->CloseEnum(hEnum);
                    goto CLEANUP;
                }
                if (len == 9 && wcscmp(buffer, L"mscorlib") == 0) {
                    tkAR = ar[i];
                    pAImport->CloseEnum(hEnum);
                    goto FoundMscorLib;
                }
            }
        }
        pAImport->CloseEnum(hEnum);
        tkAR = mdTokenNil;

FoundMscorLib:
        pAImport = NULL; // Release it

        for (int i = 0; i < 4 && SUCCEEDED(hr); i++) {
            WCHAR name[1024];
            wcscpy(name, MODULE_CA_LOCATION);
            mdToken tkAssem = mdTokenNil;
            wcscat(name, names[i]);
            // Try both a scoped and unscoped reference
            if (FAILED(hr = module.pImport->FindTypeRef(tkAR, name, &tkAssem)) &&
                (hr != CLDB_E_RECORD_NOTFOUND || tkAR == mdTokenNil || FAILED(hr = module.pImport->FindTypeRef(mdTokenNil, name, &tkAssem)))) {
                if (hr == CLDB_E_RECORD_NOTFOUND) {
                    hr = S_FALSE;
                    continue;
                } else
                    break;
            }

            tkAttrib[i] = tkAssem;
            if (!IsNilToken(tkAssem)) {
                DeleteToken func(pOldEmit);
                hr = EnumAllExcept( module.pImport, &func, tkAssem, NULL, 0, NULL, &CallEnumCustomAttributes);
            }
        }
        pOldEmit = NULL;
        if (FAILED(hr) || FAILED(hr = pFilter->UnmarkAll()))
            goto CLEANUP;

        {
            MarkToken func(pFilter);

            if (FAILED(hr = EnumAllExcept( module.pImport, &func, &CallEnumUserStrings, NULL, 0, NULL)) ||
                FAILED(hr = EnumAllExcept( module.pImport, &func, &CallEnumSignatures, NULL, 0, NULL)) ||
                FAILED(hr = EnumAllExcept( module.pImport, &func, &CallEnumTypeDefs, NULL, 0, &CallEnumMembers)) ||
                // Get Global functions/methods
                FAILED(hr = EnumAllExcept( module.pImport, &func, mdTokenNil, NULL, 0, &CallEnumMembers)) ||
                FAILED(hr = EnumAllExcept( module.pImport, &func, &CallEnumTypeRefs, tkAttrib, lengthof(tkAttrib), &CallEnumMemberRefs)) ||
                // Get Global functions/methods
                FAILED(hr = EnumAllExcept( module.pImport, &func, mdTokenNil, tkAttrib, lengthof(tkAttrib), &CallEnumMemberRefs)) ||
                FAILED(hr = EnumAllExcept( module.pImport, &func, &CallEnumTypeSpecs, NULL, 0, NULL)))
                goto CLEANUP;
        }

        if (FAILED(hr = pNewEmit->SetModuleProps(GetModuleName())))
            goto CLEANUP;


        if (FAILED(hr = pNewEmit->Merge( module.pImport, &Map, NULL)) ||
            FAILED(hr = pNewEmit->MergeEnd()) ||
            FAILED(hr = pNewEmit->GetSaveSize((CorSaveSize)(cssAccurate | cssDiscardTransientCAs), &count)))
            goto CLEANUP;

        if (FAILED(hr = module.EmitMembers( NULL, NULL, NULL, NULL, NULL, &Map, pNewEmit)) ||
            FAILED(hr = module.WriteNewMetaData(pNewEmit, count)) ||
            FAILED(hr = module.Close()))
            hr = ReportError(hr);

CLEANUP:; // Клинап, блин! :)
    }

    return hr;
}

S>Что касается ATL, то в atlbase.h можно было легко обойтись без goto, не потеряв читабельности. atlcom.h — CSecurityDescriptor::GetTokenSids и CSecurityDescriptor::Attach, по-моему, написаны не слишком тщательно, там при некоторых ошибках лики вроде могут быть (да и код этот явно унаследованный). atldb.h — одно большое глюкало, явно писалось на скорую руку (когда пришлось однажды его использовать, нашел кучу разнообразных утечек). statreg.h — в CRegObject::RegisterFromResource (написанной в сишном стиле, кстати) от goto без труда можно было бы избавиться (вроде даже без объектных оберток); в CRegParser::RegisterSubkeys вообще хрен чего поймешь, что с goto, что без него — код явно write-only , напрашивается на полное переписывание при необходимости малейшей модификации. Так что насчет "настоящих ООП-пацанов" я сильно не уверен

    HRESULT    GetPropertyInfo(ULONG cPropertySets, 
                        const DBPROPIDSET rgPropertySets[], ULONG* pcPropertyInfoSets,
                        DBPROPINFOSET**    prgPropertyInfoSets, 
                        WCHAR** ppDescBuffer, bool bInitialized = true, 
                        const GUID* pGuid = NULL)
    {
        CComCritSecLock<CComAutoCriticalSection> lock(m_oCriticalSection);
        HRESULT    hr = S_OK;
        ULONG ul, ulSet, ulNext, ulEnd;
        ULONG ulOutIndex;
        ULONG cSets;
        ULONG cPropInfos;
        //ULONG ulIndex = 0;
        ULONG cBuffers = 0;
        DWORD dwStatus = 0;
        DBPROPINFO*    pPropInfo = NULL;
        DBPROPINFO*    pCurPropInfo = NULL;
        WCHAR* pDescBuffer = NULL;
        DBPROPINFOSET* pPropInfoSet = NULL;
        UPROPINFO* pUPropInfo = NULL;
        WCHAR wszBuff[256];
        int    cch;
        CAtlArray<ULONG> rgInitPropsetIndexes;

        // If the consumer does not restrict the property sets
        // by specify an array of property sets and a cPropertySets
        // greater than 0, then we need to make sure we 
        // have some to return
        if(cPropertySets == 0)
        {
            // Determine the number of property sets supported
            // In this case, it usually the enumerator or data source asking for 
            // DBPROPSET_DBINIT information.

            if (pGuid != NULL)
            {
                // Need to determine if there are any UPROPSET_USERINIT sets here
                // they should be added to DBINIT.
                ULONG ulUserInitSets = 0;
                for (ULONG l=0; l<m_cUPropSet; l++)
                    if (m_pUPropSet[l].dwFlags & UPROPSET_USERINIT)
                        ulUserInitSets++;

                cSets = 1 + ulUserInitSets;        // one for DBINIT which is required
            }
            else
            {
                cSets = m_cUPropSet;
            }
        }
        else
        {
            cSets = 0;

            // Determine number of property sets required 
            // This is only required when any of the "special" property set GUIDs were specified
            for(ulSet=0; ulSet<cPropertySets; ulSet++)
            {
                if (GetPropertySetIndex(&(rgPropertySets[ulSet].guidPropertySet)) == S_OK)
                    cSets += m_cPropSetDex;
                else
                    cSets++;
            }
        }
        ATLASSERT(cSets);

        // Allocate the DBPROPINFOSET structures
        pPropInfoSet = (DBPROPINFOSET*)CoTaskMemAlloc(cSets * sizeof(DBPROPINFOSET));
        if(pPropInfoSet == NULL)
        {
            ATLTRACE(atlTraceDBProvider, 0, _T("Could not allocate DBPROPSET array for GetProperties\n"));
            hr =  E_OUTOFMEMORY;
            goto EXIT;
        }

        memset(pPropInfoSet, 0, cSets * sizeof(DBPROPINFOSET));

        ulOutIndex = 0;
        ULONG ulTempPropsetIndex = 0;
        ulEnd = cPropertySets == 0 ? cSets : cPropertySets; 
        // Fill in the output array
        for(ulSet=0; ulSet<ulEnd; ulSet++)
        {
             // Depending of if Property sets are specified store the
            // return property set.
            if (cPropertySets == 0)
            {
                if (pGuid != NULL)
                {
                    // Need to change this: set the guidPropertySet to the maching
                    // initialization property group (not DBINITALL).
                    for (ULONG ulCurrentInitSet = ulTempPropsetIndex; ulCurrentInitSet < m_cUPropSet; ulCurrentInitSet++)
                    {
                        // We need to locate either the DBINIT or USERINIT property sets here
                        // and set the property set index up correctly.
                        if (InlineIsEqualGUID(*(m_pUPropSet[ulCurrentInitSet].pPropSet), DBPROPSET_DBINIT) ||
                            (m_pUPropSet[ulCurrentInitSet].dwFlags & UPROPSET_USERINIT))
                        {
                            rgInitPropsetIndexes.Add(ulCurrentInitSet);
                            ulTempPropsetIndex = ulCurrentInitSet + 1;
                            //ulIndex = ulCurrentInitSet;
                            //pPropInfoSet[ulSet].guidPropertySet = *pGuid;
                            pPropInfoSet[ulSet].guidPropertySet = *(m_pUPropSet[ulCurrentInitSet].pPropSet);
                            GetPropertySetIndex(&pPropInfoSet[ulSet].guidPropertySet);    // Need to set the m_cPropSetDex variable
                            break;
                        }
                    }
                    //if (ulCurrentInitSet == m_cUPropSet)
                    //{
                    //    ulIndex = 0;
                    //}

                }
                else
                {
                    pPropInfoSet[ulSet].guidPropertySet = *(m_pUPropSet[ulSet].pPropSet);
                }
            }
            else
            {
                GUID const& guidSet = rgPropertySets[ulSet].guidPropertySet;
                if( (InlineIsEqualGUID(guidSet, DBPROPSET_DATASOURCEALL) ||
                    InlineIsEqualGUID(guidSet, DBPROPSET_DATASOURCEINFOALL) ||
                    InlineIsEqualGUID(guidSet, DBPROPSET_DBINITALL) ||
                    InlineIsEqualGUID(guidSet, DBPROPSET_SESSIONALL) ||
                    InlineIsEqualGUID(guidSet, DBPROPSET_COLUMNALL) ||
                    InlineIsEqualGUID(guidSet, DBPROPSET_CONSTRAINTALL) ||
                    InlineIsEqualGUID(guidSet, DBPROPSET_INDEXALL) ||
                    InlineIsEqualGUID(guidSet, DBPROPSET_TABLEALL) ||
                    InlineIsEqualGUID(guidSet, DBPROPSET_TRUSTEEALL) ||
                    InlineIsEqualGUID(guidSet, DBPROPSET_VIEWALL) ||
                    InlineIsEqualGUID(guidSet, DBPROPSET_ROWSETALL)) &&
                    GetPropertySetIndex(&guidSet) == S_OK )
                {
                    for(ul=0; ul<m_cPropSetDex; ul++,ulOutIndex++)
                    {
                        pPropInfoSet[ulOutIndex].guidPropertySet    = *(m_pUPropSet[m_rgiPropSetDex[ul]].pPropSet);
//                        pPropInfoSet[ulOutIndex].guidPropertySet    = rgPropertySets[ulSet].guidPropertySet;
                        pPropInfoSet[ulOutIndex].cPropertyInfos        = 0;
                    }
                }
                else
                {
                    // Handle non-category property sets
                    // Handle unknown property sets
                    pPropInfoSet[ulOutIndex].guidPropertySet = guidSet; 
                    pPropInfoSet[ulOutIndex].cPropertyInfos     = rgPropertySets[ulSet].cPropertyIDs; 
                    ulOutIndex++;
                }
            }
        }

        // Allocate a Description Buffer if needed
        if( ppDescBuffer )
        {
            cBuffers = CalcDescripBuffers(cSets, pPropInfoSet);
            if( cBuffers != 0 )
            {
                pDescBuffer = (WCHAR*)CoTaskMemAlloc(cBuffers * cchDescBuffSize * sizeof(WCHAR));
                if(pDescBuffer == NULL)
                {
                    hr = E_OUTOFMEMORY;
                    goto EXIT;
                }
                *ppDescBuffer = pDescBuffer;
                memset(pDescBuffer, 0, (cBuffers * cchDescBuffSize * sizeof(WCHAR)));
            }
        }

        // Process requested or derived Property sets
        dwStatus = 0;
        for(ulSet=0; ulSet<cSets; ulSet++)
        {
            ulNext=0;
            cPropInfos = 0;
            pPropInfo = NULL;
            dwStatus &= (GETPROPINFO_ERRORSOCCURRED | GETPROPINFO_VALIDPROP);

            // Calculate the number of property nodes needed for this
            // property set.
            if( cPropertySets == 0 )
            {
                ULONG ulTempSet;
                if (pGuid != NULL)
                {
                    ATLASSERT( ulSet < rgInitPropsetIndexes.GetCount() );
                    ulTempSet = rgInitPropsetIndexes[ulSet]; // ulIndex;
                }
                else
                    ulTempSet = ulSet;

                cPropInfos = m_pUPropSet[ulTempSet].cUPropInfo;
                dwStatus |= GETPROPINFO_ALLPROPIDS;
                m_rgiPropSetDex[0] = ulTempSet;
                m_cPropSetDex = 1; 
                _ATLDUMPPROPSETIID(*m_pUPropSet[ulTempSet].pPropSet, dwStatus);
            }
            else
            {
                // If the count of PROPIDs is 0 (NOTE: the above routine already determined
                // if it belonged to a category and if so set the count of properties to 0 for
                // each propset in that category.
                if( pPropInfoSet[ulSet].cPropertyInfos == 0 )
                {
                    dwStatus |= GETPROPINFO_ALLPROPIDS;
                    // We have to determine if the property set is supported and if so
                    // the count of properties in the set.
                    if( (GetPropertySetIndex(&(pPropInfoSet[ulSet].guidPropertySet)) == S_FALSE)
                        || (!bInitialized && 
                        !(InlineIsEqualGUID(pPropInfoSet[ulSet].guidPropertySet, DBPROPSET_DBINIT)) &&
                        !(InlineIsEqualGUID(pPropInfoSet[ulSet].guidPropertySet, DBPROPSET_DBINITALL))))
                    {
                        dwStatus |= GETPROPINFO_NOTSUPPORTED;
                        dwStatus |= GETPROPINFO_ERRORSOCCURRED;
                        _ATLDUMPPROPSETIID(pPropInfoSet[ulSet].guidPropertySet, dwStatus);
                        goto NEXT_SET;
                    }
                    else                        
                    {
                        ATLASSERT( m_cPropSetDex == 1 );
                        cPropInfos += m_pUPropSet[m_rgiPropSetDex[0]].cUPropInfo;
                        _ATLDUMPPROPSETIID(pPropInfoSet[ulSet].guidPropertySet, dwStatus);
                    }
//                    else
//                    {
//                        // Not Supported                    
//                        dwStatus |= GETPROPINFO_ERRORSOCCURRED;
//                        goto NEXT_SET;
//                    }
                }
                else
                {
                    // We also handle the case here where the user has requested
                    // a non-initialization group property info set while the
                    // provider is not initialized.  In this case, properties should
                    // not be set.
                    cPropInfos = pPropInfoSet[ulSet].cPropertyInfos;
                    if( (GetPropertySetIndex(&(pPropInfoSet[ulSet].guidPropertySet)) == S_FALSE)
                        || (!bInitialized && 
                        !(InlineIsEqualGUID(pPropInfoSet[ulSet].guidPropertySet, DBPROPSET_DBINIT)) &&
                        !(InlineIsEqualGUID(pPropInfoSet[ulSet].guidPropertySet, DBPROPSET_DBINITALL))))
                    {
                        dwStatus |= GETPROPINFO_NOTSUPPORTED;
                        dwStatus |= GETPROPINFO_ERRORSOCCURRED;
                        _ATLDUMPPROPSETIID(pPropInfoSet[ulSet].guidPropertySet, dwStatus);
                    }
                }
            }


            // Allocate DBPROP array
            ATLASSERT( cPropInfos != 0 );
            pPropInfo = (DBPROPINFO*)CoTaskMemAlloc(cPropInfos * sizeof(DBPROPINFO));
            if( pPropInfo )
            {
                // Initialize Buffer
                memset(pPropInfo, 0, cPropInfos * sizeof(DBPROPINFO));
                for(ULONG ulProp=0; ulProp<cPropInfos; ulProp++)
                {
                    VariantInit(&(pPropInfo[ulProp].vValues));
                    if( dwStatus & GETPROPINFO_NOTSUPPORTED )
                    {
                        // Not supported, thus we need to mark all as NOT_SUPPORTED
                        pPropInfo[ulProp].dwPropertyID = rgPropertySets[ulSet].rgPropertyIDs[ulProp];
                        pPropInfo[ulProp].dwFlags = DBPROPFLAGS_NOTSUPPORTED;
                        dwStatus |= GETPROPINFO_ERRORSOCCURRED;
                        _ATLDUMPPROPERTY(pPropInfo[ulProp].dwPropertyID, pPropInfo[ulProp].dwFlags);
                    }                    
                }
                // Make sure we support the property set
                if( dwStatus & GETPROPINFO_NOTSUPPORTED )
                {
                    ulNext = cPropInfos;
                    goto NEXT_SET;
                }

                // Retrieve the property information for this property set
                for(ul=0; ul<m_cPropSetDex; ul++)
                {
                    pUPropInfo = (m_pUPropSet[m_rgiPropSetDex[ul]].pUPropInfo);
                    ATLASSERT( pUPropInfo );

                    // Retrieve current value of properties
                    if( dwStatus & GETPROPINFO_ALLPROPIDS )
                    {
                        for(ulProp=0; ulProp<m_pUPropSet[m_rgiPropSetDex[ul]].cUPropInfo; ulProp++)
                        {
                            // Verify property is supported, if not do not return 
                            if( !TESTBIT(&(m_rgdwSupported[m_rgiPropSetDex[ul] * m_cElemPerSupported]), ulProp) )
                                continue;

                            pCurPropInfo = &(pPropInfo[ulNext]);

                            // If the ppDescBuffer pointer was not NULL, then
                            // we need supply description of the properties
                            if( ppDescBuffer )
                            {
                                // Set Buffer pointer
                                pCurPropInfo->pwszDescription = pDescBuffer;

                                // Load the string into temp buffer
                                cch = LoadDescription(pUPropInfo[ulProp].ulIDS, wszBuff, (sizeof(wszBuff)/sizeof(*wszBuff)));
                                if( cch )
                                {
                                    // Adjust for '\0'
                                    cch++;

                                    // Transfer to official buffer if room
                                    memcpy(pDescBuffer, wszBuff, cch * sizeof(WCHAR));
                                    pDescBuffer += cch;
                                }
                                else
                                {
                                    wcscpy(pDescBuffer, L"UNKNOWN");
                                    pDescBuffer += (wcslen(L"UNKNOWN") + 1);
                                    _ATLDUMPPROPERTY(pCurPropInfo->dwPropertyID, ATLDB_NO_STRING);
                                }
                            }

                            pCurPropInfo->dwPropertyID = pUPropInfo[ulProp].dwPropId;

                            // Strip out any user defined flags that may be around.  Note,
                            // this isn't a full-proof thing because properties change.  It
                            // won't work in OLE DB 2.5 if someone does a property like 0x40000
                            DWORD dwFlags = pUPropInfo[ulProp].dwFlags & 0xfffff;

                            pCurPropInfo->dwFlags = dwFlags;
                            pCurPropInfo->vtType = pUPropInfo[ulProp].VarType;
                            pCurPropInfo->vValues.vt = VT_EMPTY;

                            dwStatus |= GETPROPINFO_VALIDPROP;
                            // Increment to next available buffer
                            ulNext++;
                            _ATLDUMPPROPERTY(pCurPropInfo->dwPropertyID, pCurPropInfo->dwFlags);
                        }
                    }
                    else
                    {
                        ATLASSERT( m_cPropSetDex == 1 );
                        ULONG cIterations = ((cPropInfos>cBuffers) && (ppDescBuffer)) ? cBuffers : cPropInfos;

                        for( ulProp = 0; ulProp < cIterations; ulProp++, ulNext++ )
                        {
                            pCurPropInfo = &(pPropInfo[ulNext]);

                            // Process Properties based on Restriction array.
                            pCurPropInfo->dwPropertyID = rgPropertySets[ulSet].rgPropertyIDs[ulProp];

                            if( GetUPropInfoPtr(m_rgiPropSetDex[ul], pCurPropInfo->dwPropertyID, &pUPropInfo)
                                == S_OK )
                            {
                                // If the ppDescBuffer pointer was not NULL, then
                                // we need supply description of the properties
                                if( ppDescBuffer )
                                {
                                    // Set Buffer pointer
                                    pCurPropInfo->pwszDescription = pDescBuffer;

                                    // Load the string into temp buffer
                                    cch = LoadDescription(pUPropInfo->ulIDS, wszBuff, (sizeof(wszBuff)/sizeof(*wszBuff)));
                                    if( cch )
                                    {
                                        // Adjust for '\0'
                                        cch++;

                                        // Transfer to official buffer if room
                                        memcpy(pDescBuffer, wszBuff, cch * sizeof(WCHAR));
                                        pDescBuffer += cch;
                                    }
                                    else
                                    {
                                        wcscpy(pDescBuffer, L"UNKNOWN");
                                        pDescBuffer += (wcslen(L"UNKNOWN") + 1);
                                        _ATLDUMPPROPERTY(pCurPropInfo->dwPropertyID, ATLDB_NO_STRING);
                                    }
                                }

                                pCurPropInfo->dwPropertyID = pUPropInfo->dwPropId;

                                // Strip out any user defined flags that may be around.  Note,
                                // this isn't a full-proof thing because properties change.  It
                                // won't work in OLE DB 2.5 if someone does a property like 0x40000
                                DWORD dwFlags = pUPropInfo->dwFlags & 0xfffff;

                                pCurPropInfo->dwFlags = dwFlags;
                                pCurPropInfo->vtType = pUPropInfo->VarType;

                                dwStatus |= GETPROPINFO_VALIDPROP;
                            }
                            else
                            {
                                // Not Supported
                                pCurPropInfo->dwFlags = DBPROPFLAGS_NOTSUPPORTED;
                                dwStatus |= GETPROPINFO_ERRORSOCCURRED;
                            }
                            _ATLDUMPPROPERTY(pCurPropInfo->dwPropertyID, pCurPropInfo->dwFlags);
                        }
                    }
                }
            }
            else
            {
                hr = E_OUTOFMEMORY;
                goto EXIT;
            }

NEXT_SET:
            pPropInfoSet[ulSet].cPropertyInfos = ulNext;
            pPropInfoSet[ulSet].rgPropertyInfos = pPropInfo;
        }

        // Success, set return values
        *pcPropertyInfoSets = cSets;
        *prgPropertyInfoSets = pPropInfoSet;

        // At least one propid was marked as not S_OK
        if( dwStatus & GETPROPINFO_ERRORSOCCURRED )
        {
            // If at least 1 property was set
            if( dwStatus & GETPROPINFO_VALIDPROP )
                return DB_S_ERRORSOCCURRED;
            else
            {
                // Do not free any of the rgPropertyInfoSets, but
                // do free the ppDescBuffer
                if( pDescBuffer )
                {
                    ATLASSERT( ppDescBuffer );
                    CoTaskMemFree(pDescBuffer);
                    *ppDescBuffer = NULL;
                }
                return DB_E_ERRORSOCCURRED;
            }
        }

        return S_OK;
EXIT:
        // Check if failure and clean up any allocated memory
        if( FAILED(hr) && 
            (hr != DB_E_ERRORSOCCURRED) )
        {
            // Free Description Buffer
            if( pDescBuffer )
            {
                ATLASSERT( ppDescBuffer );

                CoTaskMemFree(pDescBuffer);
                *ppDescBuffer = NULL;
            }

            if( pPropInfoSet )
            {
                // Loop through Property Sets
                for(ulSet=0; ulSet<cSets; ulSet++)
                    CoTaskMemFree(pPropInfoSet[ulSet].rgPropertyInfos);
                CoTaskMemFree(pPropInfoSet);
            }
        }

        return hr;
    }