bool XmlDataGdbServerRegisterFile::SetRegistersByTargetFile()

in Exdi/exdigdbsrv/GdbSrvControllerLib/XmlDataHelpers.cpp [1115:1203]
78 lines of code
14 McCabe index (conditional complexity)

bool XmlDataGdbServerRegisterFile::SetRegistersByTargetFile(_In_ TAG_ATTR_LIST* const pTagAttrList,
    _Out_ ConfigExdiGdbSrvData* pConfigTable)
{
    HRESULT hr;
    bool isSet = false;

    ConfigTargetRegisterDescriptionFileEntry registerFileData = { 0 };
    if (IsFeatureRegisterFile(pTagAttrList->tagName))
    {
        hr = XmlDataHelpers::GetXmlTagAttributeValues(pTagAttrList, attrRegistersFile, ARRAYSIZE(attrRegistersFile),
            sizeof(ConfigTargetRegisterDescriptionFileEntry), static_cast<void*>(&registerFileData));
        if (SUCCEEDED(hr))
        {
            //  Check if the feature is supported
            auto it = pConfigTable->gdbServerRegisters.featureNameSupported->find(pConfigTable->file.registerGroupArchitecture);
            if (it == pConfigTable->gdbServerRegisters.featureNameSupported->end())
            {
                throw _com_error(E_INVALIDARG);
            }

            if ((it->second->compare(L"all") == 0) ||
                (wcsstr(registerFileData.featureName, it->second->c_str()) != nullptr))
            {
                pConfigTable->gdbServerRegisters.featureName = registerFileData.featureName;
            }

            pConfigTable->gdbServerRegisters.spRegisterSystemSet.reset(new(std::nothrow) GdbServerRegisterMap());
            if (pConfigTable->gdbServerRegisters.spRegisterSystemSet == nullptr)
            {
                throw _com_error(E_OUTOFMEMORY);
            }
            pConfigTable->gdbServerRegisters.spRegisterSystemSet->emplace(
                pConfigTable->file.registerGroupArchitecture,
                new(std::nothrow) RegisterVector());

            isSet = true;
        }
    }
    else if (!pConfigTable->gdbServerRegisters.featureName.empty() &&
        IsRegisterFileEntry(pTagAttrList->tagName))
    {
        hr = XmlDataHelpers::GetXmlTagAttributeValues(pTagAttrList, attrRegistersFile, ARRAYSIZE(attrRegistersFile),
            sizeof(ConfigTargetRegisterDescriptionFileEntry), static_cast<void*>(&registerFileData));
        if (SUCCEEDED(hr))
        {
            char nameBuf[256] = {};
            if (WideCharToMultiByte(CP_ACP, 0, registerFileData.RegisterName, static_cast<int>(wcslen(registerFileData.RegisterName)),
                nameBuf, sizeof(nameBuf), nullptr, nullptr) == 0)
            {
                throw _com_error(E_INVALIDARG);
            }

            size_t registerSize = static_cast<size_t>(_wtoi(registerFileData.RegistBitSize));
            size_t leftBits = registerSize % 8;
            registerSize /= 8;
            if (leftBits != 0)
            {
                registerSize++;
            }

            size_t regOrder = static_cast<size_t>(_wtoi(registerFileData.RegisterNum));
            char nameOrderBuf[128] = {};
            sprintf_s(nameOrderBuf, _countof(nameOrderBuf), "%zx", regOrder);

            char groupBuf[128] = {};
            if (WideCharToMultiByte(CP_ACP, 0, registerFileData.RegisterGroup, static_cast<int>(wcslen(registerFileData.RegisterGroup)),
                groupBuf, sizeof(groupBuf), nullptr, nullptr) == 0)
            {
                throw _com_error(E_INVALIDARG);
            }

            RegistersStruct registerSet = {};
            registerSet.name = nameBuf;
            registerSet.nameOrder = nameOrderBuf;
            registerSet.registerSize = registerSize;
            registerSet.group = groupBuf;
            auto it = pConfigTable->gdbServerRegisters.spRegisterSystemSet->find(pConfigTable->file.registerGroupArchitecture);
            if (it == pConfigTable->gdbServerRegisters.spRegisterSystemSet->end())
            {
                throw _com_error(E_INVALIDARG);
            }
            it->second->push_back(move(registerSet));

            isSet = true;
        }
    }

    return isSet;
}