diff options
Diffstat (limited to 'Source')
34 files changed, 729 insertions, 637 deletions
diff --git a/Source/CMakeLists.txt b/Source/CMakeLists.txt index 63e08de..b1f7b29 100644 --- a/Source/CMakeLists.txt +++ b/Source/CMakeLists.txt @@ -919,14 +919,14 @@ set(CTEST_SRCS cmCTest.cxx CTest/cmCTestEmptyBinaryDirectoryCommand.cxx CTest/cmCTestGenericHandler.cxx CTest/cmCTestHandlerCommand.cxx - CTest/cmCTestHardwareAllocator.cxx - CTest/cmCTestHardwareSpec.cxx + CTest/cmCTestResourceAllocator.cxx + CTest/cmCTestResourceSpec.cxx CTest/cmCTestLaunch.cxx CTest/cmCTestMemCheckCommand.cxx CTest/cmCTestMemCheckHandler.cxx CTest/cmCTestMultiProcessHandler.cxx - CTest/cmCTestProcessesLexerHelper.cxx CTest/cmCTestReadCustomFilesCommand.cxx + CTest/cmCTestResourceGroupsLexerHelper.cxx CTest/cmCTestRunScriptCommand.cxx CTest/cmCTestRunTest.cxx CTest/cmCTestScriptHandler.cxx @@ -958,9 +958,9 @@ set(CTEST_SRCS cmCTest.cxx CTest/cmCTestP4.cxx CTest/cmCTestP4.h - LexerParser/cmCTestProcessesLexer.cxx - LexerParser/cmCTestProcessesLexer.h - LexerParser/cmCTestProcessesLexer.in.l + LexerParser/cmCTestResourceGroupsLexer.cxx + LexerParser/cmCTestResourceGroupsLexer.h + LexerParser/cmCTestResourceGroupsLexer.in.l ) # Build CTestLib @@ -1177,7 +1177,7 @@ if(WIN32) unset(CMake_RCVERSION_MONTH_DAY) unset(CMake_RCVERSION_YEAR) else() - set(CMake_RCVERSION ${CMake_VERSION_MAJOR},${CMake_VERSION_MINOR},${CMake_VERSION_PATCH}) + set(CMake_RCVERSION ${CMake_VERSION_MAJOR},${CMake_VERSION_MINOR},${CMake_VERSION_PATCH},0) endif() set(CMake_RCVERSION_STR ${CMake_VERSION}) diff --git a/Source/CPack/cmCPackGenerator.cxx b/Source/CPack/cmCPackGenerator.cxx index 153f328..7a6c50b 100644 --- a/Source/CPack/cmCPackGenerator.cxx +++ b/Source/CPack/cmCPackGenerator.cxx @@ -605,14 +605,6 @@ int cmCPackGenerator::InstallProjectViaInstallCMakeProjects( cmExpandList(buildConfig, buildConfigs); } - // Try get configurations requested by the user explicitly - { - const char* const configsCstr = - this->GetOption("CPACK_INSTALL_CMAKE_CONFIGURATIONS"); - auto configs = configsCstr ? configsCstr : std::string{}; - cmExpandList(configs, buildConfigs); - } - // Remove duplicates std::sort(buildConfigs.begin(), buildConfigs.end()); buildConfigs.erase(std::unique(buildConfigs.begin(), buildConfigs.end()), diff --git a/Source/CTest/cmCTestBinPacker.cxx b/Source/CTest/cmCTestBinPacker.cxx index e9e3bee..e21b14d 100644 --- a/Source/CTest/cmCTestBinPacker.cxx +++ b/Source/CTest/cmCTestBinPacker.cxx @@ -23,7 +23,7 @@ namespace { /* * The following algorithm is used to do two things: * - * 1) Determine if a test's hardware requirements can fit within the hardware + * 1) Determine if a test's resource requirements can fit within the resources * present on the system, and * 2) Do the actual allocation * @@ -34,46 +34,46 @@ namespace { * more combinations can be tried. */ template <typename AllocationStrategy> -static bool AllocateCTestHardware( - const std::map<std::string, cmCTestHardwareAllocator::Resource>& hardware, - const std::vector<std::string>& hardwareSorted, std::size_t currentIndex, +static bool AllocateCTestResources( + const std::map<std::string, cmCTestResourceAllocator::Resource>& resources, + const std::vector<std::string>& resourcesSorted, std::size_t currentIndex, std::vector<cmCTestBinPackerAllocation*>& allocations) { // Iterate through all large enough resources until we find a solution - std::size_t hardwareIndex = 0; - while (hardwareIndex < hardwareSorted.size()) { - auto const& resource = hardware.at(hardwareSorted[hardwareIndex]); + std::size_t resourceIndex = 0; + while (resourceIndex < resourcesSorted.size()) { + auto const& resource = resources.at(resourcesSorted[resourceIndex]); if (resource.Free() >= static_cast<unsigned int>(allocations[currentIndex]->SlotsNeeded)) { // Preemptively allocate the resource - allocations[currentIndex]->Id = hardwareSorted[hardwareIndex]; + allocations[currentIndex]->Id = resourcesSorted[resourceIndex]; if (currentIndex + 1 >= allocations.size()) { // We have a solution return true; } // Move the resource up the list until it is sorted again - auto hardware2 = hardware; - auto hardwareSorted2 = hardwareSorted; - hardware2[hardwareSorted2[hardwareIndex]].Locked += + auto resources2 = resources; + auto resourcesSorted2 = resourcesSorted; + resources2[resourcesSorted2[resourceIndex]].Locked += allocations[currentIndex]->SlotsNeeded; - AllocationStrategy::IncrementalSort(hardware2, hardwareSorted2, - hardwareIndex); + AllocationStrategy::IncrementalSort(resources2, resourcesSorted2, + resourceIndex); // Recurse one level deeper - if (AllocateCTestHardware<AllocationStrategy>( - hardware2, hardwareSorted2, currentIndex + 1, allocations)) { + if (AllocateCTestResources<AllocationStrategy>( + resources2, resourcesSorted2, currentIndex + 1, allocations)) { return true; } } // No solution found here, deallocate the resource and try the next one allocations[currentIndex]->Id.clear(); - auto freeSlots = hardware.at(hardwareSorted.at(hardwareIndex)).Free(); + auto freeSlots = resources.at(resourcesSorted.at(resourceIndex)).Free(); do { - ++hardwareIndex; - } while (hardwareIndex < hardwareSorted.size() && - hardware.at(hardwareSorted.at(hardwareIndex)).Free() == + ++resourceIndex; + } while (resourceIndex < resourcesSorted.size() && + resources.at(resourcesSorted.at(resourceIndex)).Free() == freeSlots); } @@ -82,8 +82,8 @@ static bool AllocateCTestHardware( } template <typename AllocationStrategy> -static bool AllocateCTestHardware( - const std::map<std::string, cmCTestHardwareAllocator::Resource>& hardware, +static bool AllocateCTestResources( + const std::map<std::string, cmCTestResourceAllocator::Resource>& resources, std::vector<cmCTestBinPackerAllocation>& allocations) { // Sort the resource requirements in descending order by slots needed @@ -99,103 +99,105 @@ static bool AllocateCTestHardware( }); // Sort the resources according to sort strategy - std::vector<std::string> hardwareSorted; - hardwareSorted.reserve(hardware.size()); - for (auto const& hw : hardware) { - hardwareSorted.push_back(hw.first); + std::vector<std::string> resourcesSorted; + resourcesSorted.reserve(resources.size()); + for (auto const& res : resources) { + resourcesSorted.push_back(res.first); } - AllocationStrategy::InitialSort(hardware, hardwareSorted); + AllocationStrategy::InitialSort(resources, resourcesSorted); // Do the actual allocation - return AllocateCTestHardware<AllocationStrategy>( - hardware, hardwareSorted, std::size_t(0), allocationsPtr); + return AllocateCTestResources<AllocationStrategy>( + resources, resourcesSorted, std::size_t(0), allocationsPtr); } class RoundRobinAllocationStrategy { public: static void InitialSort( - const std::map<std::string, cmCTestHardwareAllocator::Resource>& hardware, - std::vector<std::string>& hardwareSorted); + const std::map<std::string, cmCTestResourceAllocator::Resource>& resources, + std::vector<std::string>& resourcesSorted); static void IncrementalSort( - const std::map<std::string, cmCTestHardwareAllocator::Resource>& hardware, - std::vector<std::string>& hardwareSorted, std::size_t lastAllocatedIndex); + const std::map<std::string, cmCTestResourceAllocator::Resource>& resources, + std::vector<std::string>& resourcesSorted, std::size_t lastAllocatedIndex); }; void RoundRobinAllocationStrategy::InitialSort( - const std::map<std::string, cmCTestHardwareAllocator::Resource>& hardware, - std::vector<std::string>& hardwareSorted) + const std::map<std::string, cmCTestResourceAllocator::Resource>& resources, + std::vector<std::string>& resourcesSorted) { std::stable_sort( - hardwareSorted.rbegin(), hardwareSorted.rend(), - [&hardware](const std::string& id1, const std::string& id2) { - return hardware.at(id1).Free() < hardware.at(id2).Free(); + resourcesSorted.rbegin(), resourcesSorted.rend(), + [&resources](const std::string& id1, const std::string& id2) { + return resources.at(id1).Free() < resources.at(id2).Free(); }); } void RoundRobinAllocationStrategy::IncrementalSort( - const std::map<std::string, cmCTestHardwareAllocator::Resource>& hardware, - std::vector<std::string>& hardwareSorted, std::size_t lastAllocatedIndex) + const std::map<std::string, cmCTestResourceAllocator::Resource>& resources, + std::vector<std::string>& resourcesSorted, std::size_t lastAllocatedIndex) { - auto tmp = hardwareSorted[lastAllocatedIndex]; + auto tmp = resourcesSorted[lastAllocatedIndex]; std::size_t i = lastAllocatedIndex; - while (i < hardwareSorted.size() - 1 && - hardware.at(hardwareSorted[i + 1]).Free() > hardware.at(tmp).Free()) { - hardwareSorted[i] = hardwareSorted[i + 1]; + while (i < resourcesSorted.size() - 1 && + resources.at(resourcesSorted[i + 1]).Free() > + resources.at(tmp).Free()) { + resourcesSorted[i] = resourcesSorted[i + 1]; ++i; } - hardwareSorted[i] = tmp; + resourcesSorted[i] = tmp; } class BlockAllocationStrategy { public: static void InitialSort( - const std::map<std::string, cmCTestHardwareAllocator::Resource>& hardware, - std::vector<std::string>& hardwareSorted); + const std::map<std::string, cmCTestResourceAllocator::Resource>& resources, + std::vector<std::string>& resourcesSorted); static void IncrementalSort( - const std::map<std::string, cmCTestHardwareAllocator::Resource>& hardware, - std::vector<std::string>& hardwareSorted, std::size_t lastAllocatedIndex); + const std::map<std::string, cmCTestResourceAllocator::Resource>& resources, + std::vector<std::string>& resourcesSorted, std::size_t lastAllocatedIndex); }; void BlockAllocationStrategy::InitialSort( - const std::map<std::string, cmCTestHardwareAllocator::Resource>& hardware, - std::vector<std::string>& hardwareSorted) + const std::map<std::string, cmCTestResourceAllocator::Resource>& resources, + std::vector<std::string>& resourcesSorted) { std::stable_sort( - hardwareSorted.rbegin(), hardwareSorted.rend(), - [&hardware](const std::string& id1, const std::string& id2) { - return hardware.at(id1).Free() < hardware.at(id2).Free(); + resourcesSorted.rbegin(), resourcesSorted.rend(), + [&resources](const std::string& id1, const std::string& id2) { + return resources.at(id1).Free() < resources.at(id2).Free(); }); } void BlockAllocationStrategy::IncrementalSort( - const std::map<std::string, cmCTestHardwareAllocator::Resource>&, - std::vector<std::string>& hardwareSorted, std::size_t lastAllocatedIndex) + const std::map<std::string, cmCTestResourceAllocator::Resource>&, + std::vector<std::string>& resourcesSorted, std::size_t lastAllocatedIndex) { - auto tmp = hardwareSorted[lastAllocatedIndex]; + auto tmp = resourcesSorted[lastAllocatedIndex]; std::size_t i = lastAllocatedIndex; while (i > 0) { - hardwareSorted[i] = hardwareSorted[i - 1]; + resourcesSorted[i] = resourcesSorted[i - 1]; --i; } - hardwareSorted[i] = tmp; + resourcesSorted[i] = tmp; } } -bool cmAllocateCTestHardwareRoundRobin( - const std::map<std::string, cmCTestHardwareAllocator::Resource>& hardware, +bool cmAllocateCTestResourcesRoundRobin( + const std::map<std::string, cmCTestResourceAllocator::Resource>& resources, std::vector<cmCTestBinPackerAllocation>& allocations) { - return AllocateCTestHardware<RoundRobinAllocationStrategy>(hardware, - allocations); + return AllocateCTestResources<RoundRobinAllocationStrategy>(resources, + allocations); } -bool cmAllocateCTestHardwareBlock( - const std::map<std::string, cmCTestHardwareAllocator::Resource>& hardware, +bool cmAllocateCTestResourcesBlock( + const std::map<std::string, cmCTestResourceAllocator::Resource>& resources, std::vector<cmCTestBinPackerAllocation>& allocations) { - return AllocateCTestHardware<BlockAllocationStrategy>(hardware, allocations); + return AllocateCTestResources<BlockAllocationStrategy>(resources, + allocations); } diff --git a/Source/CTest/cmCTestBinPacker.h b/Source/CTest/cmCTestBinPacker.h index 54f03d7..ff02b85 100644 --- a/Source/CTest/cmCTestBinPacker.h +++ b/Source/CTest/cmCTestBinPacker.h @@ -8,7 +8,7 @@ #include <string> #include <vector> -#include "cmCTestHardwareAllocator.h" +#include "cmCTestResourceAllocator.h" struct cmCTestBinPackerAllocation { @@ -20,12 +20,12 @@ struct cmCTestBinPackerAllocation bool operator!=(const cmCTestBinPackerAllocation& other) const; }; -bool cmAllocateCTestHardwareRoundRobin( - const std::map<std::string, cmCTestHardwareAllocator::Resource>& hardware, +bool cmAllocateCTestResourcesRoundRobin( + const std::map<std::string, cmCTestResourceAllocator::Resource>& resources, std::vector<cmCTestBinPackerAllocation>& allocations); -bool cmAllocateCTestHardwareBlock( - const std::map<std::string, cmCTestHardwareAllocator::Resource>& hardware, +bool cmAllocateCTestResourcesBlock( + const std::map<std::string, cmCTestResourceAllocator::Resource>& resources, std::vector<cmCTestBinPackerAllocation>& allocations); #endif diff --git a/Source/CTest/cmCTestMultiProcessHandler.cxx b/Source/CTest/cmCTestMultiProcessHandler.cxx index 7e8d548..02d396e 100644 --- a/Source/CTest/cmCTestMultiProcessHandler.cxx +++ b/Source/CTest/cmCTestMultiProcessHandler.cxx @@ -140,7 +140,7 @@ void cmCTestMultiProcessHandler::RunTests() assert(this->Completed == this->Total); assert(this->Tests.empty()); } - assert(this->AllHardwareAvailable()); + assert(this->AllResourcesAvailable()); this->MarkFinished(); this->UpdateCostData(); @@ -177,9 +177,9 @@ bool cmCTestMultiProcessHandler::StartTestProcess(int test) } testRun->SetIndex(test); testRun->SetTestProperties(this->Properties[test]); - if (this->TestHandler->UseHardwareSpec) { - testRun->SetUseAllocatedHardware(true); - testRun->SetAllocatedHardware(this->AllocatedHardware[test]); + if (this->TestHandler->UseResourceSpec) { + testRun->SetUseAllocatedResources(true); + testRun->SetAllocatedResources(this->AllocatedResources[test]); } // Find any failed dependencies for this test. We assume the more common @@ -192,10 +192,10 @@ bool cmCTestMultiProcessHandler::StartTestProcess(int test) // Always lock the resources we'll be using, even if we fail to set the // working directory because FinishTestProcess() will try to unlock them - this->AllocateResources(test); + this->LockResources(test); - if (!this->TestsHaveSufficientHardware[test]) { - testRun->StartFailure("Insufficient hardware"); + if (!this->TestsHaveSufficientResources[test]) { + testRun->StartFailure("Insufficient resources"); this->FinishTestProcess(testRun, false); return false; } @@ -218,26 +218,26 @@ bool cmCTestMultiProcessHandler::StartTestProcess(int test) return false; } -bool cmCTestMultiProcessHandler::AllocateHardware(int index) +bool cmCTestMultiProcessHandler::AllocateResources(int index) { - if (!this->TestHandler->UseHardwareSpec) { + if (!this->TestHandler->UseResourceSpec) { return true; } std::map<std::string, std::vector<cmCTestBinPackerAllocation>> allocations; - if (!this->TryAllocateHardware(index, allocations)) { + if (!this->TryAllocateResources(index, allocations)) { return false; } - auto& allocatedHardware = this->AllocatedHardware[index]; - allocatedHardware.resize(this->Properties[index]->Processes.size()); + auto& allocatedResources = this->AllocatedResources[index]; + allocatedResources.resize(this->Properties[index]->ResourceGroups.size()); for (auto const& it : allocations) { for (auto const& alloc : it.second) { - bool result = this->HardwareAllocator.AllocateResource( + bool result = this->ResourceAllocator.AllocateResource( it.first, alloc.Id, alloc.SlotsNeeded); (void)result; assert(result); - allocatedHardware[alloc.ProcessIndex][it.first].push_back( + allocatedResources[alloc.ProcessIndex][it.first].push_back( { alloc.Id, static_cast<unsigned int>(alloc.SlotsNeeded) }); } } @@ -245,14 +245,14 @@ bool cmCTestMultiProcessHandler::AllocateHardware(int index) return true; } -bool cmCTestMultiProcessHandler::TryAllocateHardware( +bool cmCTestMultiProcessHandler::TryAllocateResources( int index, std::map<std::string, std::vector<cmCTestBinPackerAllocation>>& allocations) { allocations.clear(); std::size_t processIndex = 0; - for (auto const& process : this->Properties[index]->Processes) { + for (auto const& process : this->Properties[index]->ResourceGroups) { for (auto const& requirement : process) { for (int i = 0; i < requirement.UnitsNeeded; ++i) { allocations[requirement.ResourceType].push_back( @@ -262,13 +262,13 @@ bool cmCTestMultiProcessHandler::TryAllocateHardware( ++processIndex; } - auto const& availableHardware = this->HardwareAllocator.GetResources(); + auto const& availableResources = this->ResourceAllocator.GetResources(); for (auto& it : allocations) { - if (!availableHardware.count(it.first)) { + if (!availableResources.count(it.first)) { return false; } - if (!cmAllocateCTestHardwareRoundRobin(availableHardware.at(it.first), - it.second)) { + if (!cmAllocateCTestResourcesRoundRobin(availableResources.at(it.first), + it.second)) { return false; } } @@ -276,19 +276,19 @@ bool cmCTestMultiProcessHandler::TryAllocateHardware( return true; } -void cmCTestMultiProcessHandler::DeallocateHardware(int index) +void cmCTestMultiProcessHandler::DeallocateResources(int index) { - if (!this->TestHandler->UseHardwareSpec) { + if (!this->TestHandler->UseResourceSpec) { return; } { - auto& allocatedHardware = this->AllocatedHardware[index]; - for (auto const& processAlloc : allocatedHardware) { + auto& allocatedResources = this->AllocatedResources[index]; + for (auto const& processAlloc : allocatedResources) { for (auto const& it : processAlloc) { auto resourceType = it.first; for (auto const& it2 : it.second) { - bool success = this->HardwareAllocator.DeallocateResource( + bool success = this->ResourceAllocator.DeallocateResource( resourceType, it2.Id, it2.Slots); (void)success; assert(success); @@ -296,12 +296,12 @@ void cmCTestMultiProcessHandler::DeallocateHardware(int index) } } } - this->AllocatedHardware.erase(index); + this->AllocatedResources.erase(index); } -bool cmCTestMultiProcessHandler::AllHardwareAvailable() +bool cmCTestMultiProcessHandler::AllResourcesAvailable() { - for (auto const& it : this->HardwareAllocator.GetResources()) { + for (auto const& it : this->ResourceAllocator.GetResources()) { for (auto const& it2 : it.second) { if (it2.second.Locked != 0) { return false; @@ -312,13 +312,13 @@ bool cmCTestMultiProcessHandler::AllHardwareAvailable() return true; } -void cmCTestMultiProcessHandler::CheckHardwareAvailable() +void cmCTestMultiProcessHandler::CheckResourcesAvailable() { for (auto test : this->SortedTests) { std::map<std::string, std::vector<cmCTestBinPackerAllocation>> allocations; - this->TestsHaveSufficientHardware[test] = - !this->TestHandler->UseHardwareSpec || - this->TryAllocateHardware(test, allocations); + this->TestsHaveSufficientResources[test] = + !this->TestHandler->UseResourceSpec || + this->TryAllocateResources(test, allocations); } } @@ -346,7 +346,7 @@ void cmCTestMultiProcessHandler::SetStopTimePassed() } } -void cmCTestMultiProcessHandler::AllocateResources(int index) +void cmCTestMultiProcessHandler::LockResources(int index) { this->LockedResources.insert( this->Properties[index]->LockedResources.begin(), @@ -357,7 +357,7 @@ void cmCTestMultiProcessHandler::AllocateResources(int index) } } -void cmCTestMultiProcessHandler::DeallocateResources(int index) +void cmCTestMultiProcessHandler::UnlockResources(int index) { for (std::string const& i : this->Properties[index]->LockedResources) { this->LockedResources.erase(i); @@ -404,10 +404,10 @@ bool cmCTestMultiProcessHandler::StartTest(int test) } } - // Allocate hardware - if (this->TestsHaveSufficientHardware[test] && - !this->AllocateHardware(test)) { - this->DeallocateHardware(test); + // Allocate resources + if (this->TestsHaveSufficientResources[test] && + !this->AllocateResources(test)) { + this->DeallocateResources(test); return false; } @@ -417,7 +417,7 @@ bool cmCTestMultiProcessHandler::StartTest(int test) } // This test was not able to start because it is waiting // on depends to run - this->DeallocateHardware(test); + this->DeallocateResources(test); return false; } @@ -602,8 +602,8 @@ void cmCTestMultiProcessHandler::FinishTestProcess(cmCTestRunTest* runner, this->TestFinishMap[test] = true; this->TestRunningMap[test] = false; this->WriteCheckpoint(test); - this->DeallocateHardware(test); this->DeallocateResources(test); + this->UnlockResources(test); this->RunningCount -= GetProcessorsUsed(test); for (auto p : properties->Affinity) { @@ -912,14 +912,14 @@ static Json::Value DumpTimeoutAfterMatch( return timeoutAfterMatch; } -static Json::Value DumpProcessesToJsonArray( +static Json::Value DumpResourceGroupsToJsonArray( const std::vector< std::vector<cmCTestTestHandler::cmCTestTestResourceRequirement>>& - processes) + resourceGroups) { - Json::Value jsonProcesses = Json::arrayValue; - for (auto const& it : processes) { - Json::Value jsonProcess = Json::objectValue; + Json::Value jsonResourceGroups = Json::arrayValue; + for (auto const& it : resourceGroups) { + Json::Value jsonResourceGroup = Json::objectValue; Json::Value requirements = Json::arrayValue; for (auto const& it2 : it) { Json::Value res = Json::objectValue; @@ -928,10 +928,10 @@ static Json::Value DumpProcessesToJsonArray( res["slots"] = it2.SlotsNeeded; requirements.append(res); } - jsonProcess["requirements"] = requirements; - jsonProcesses.append(jsonProcess); + jsonResourceGroup["requirements"] = requirements; + jsonResourceGroups.append(jsonResourceGroup); } - return jsonProcesses; + return jsonResourceGroups; } static Json::Value DumpCTestProperty(std::string const& name, @@ -1005,9 +1005,10 @@ static Json::Value DumpCTestProperties( "PASS_REGULAR_EXPRESSION", DumpRegExToJsonArray(testProperties.RequiredRegularExpressions))); } - if (!testProperties.Processes.empty()) { + if (!testProperties.ResourceGroups.empty()) { properties.append(DumpCTestProperty( - "PROCESSES", DumpProcessesToJsonArray(testProperties.Processes))); + "RESOURCE_GROUPS", + DumpResourceGroupsToJsonArray(testProperties.ResourceGroups))); } if (testProperties.WantAffinity) { properties.append( diff --git a/Source/CTest/cmCTestMultiProcessHandler.h b/Source/CTest/cmCTestMultiProcessHandler.h index da716f0..1db4bfd 100644 --- a/Source/CTest/cmCTestMultiProcessHandler.h +++ b/Source/CTest/cmCTestMultiProcessHandler.h @@ -14,13 +14,13 @@ #include "cm_uv.h" -#include "cmCTestHardwareAllocator.h" +#include "cmCTestResourceAllocator.h" #include "cmCTestTestHandler.h" #include "cmUVHandlePtr.h" class cmCTest; struct cmCTestBinPackerAllocation; -class cmCTestHardwareSpec; +class cmCTestResourceSpec; class cmCTestRunTest; /** \class cmCTestMultiProcessHandler @@ -47,7 +47,7 @@ public: : public std::map<int, cmCTestTestHandler::cmCTestTestProperties*> { }; - struct HardwareAllocation + struct ResourceAllocation { std::string Id; unsigned int Slots; @@ -87,12 +87,12 @@ public: void SetQuiet(bool b) { this->Quiet = b; } - void InitHardwareAllocator(const cmCTestHardwareSpec& spec) + void InitResourceAllocator(const cmCTestResourceSpec& spec) { - this->HardwareAllocator.InitializeFromHardwareSpec(spec); + this->ResourceAllocator.InitializeFromResourceSpec(spec); } - void CheckHardwareAvailable(); + void CheckResourcesAvailable(); protected: // Start the next test or tests as many as are allowed by @@ -134,16 +134,16 @@ protected: bool CheckStopTimePassed(); void SetStopTimePassed(); - void AllocateResources(int index); - void DeallocateResources(int index); + void LockResources(int index); + void UnlockResources(int index); - bool AllocateHardware(int index); - bool TryAllocateHardware( + bool AllocateResources(int index); + bool TryAllocateResources( int index, std::map<std::string, std::vector<cmCTestBinPackerAllocation>>& allocations); - void DeallocateHardware(int index); - bool AllHardwareAvailable(); + void DeallocateResources(int index); + bool AllResourcesAvailable(); // map from test number to set of depend tests TestMap Tests; @@ -166,10 +166,10 @@ protected: std::vector<std::string> LastTestsFailed; std::set<std::string> LockedResources; std::map<int, - std::vector<std::map<std::string, std::vector<HardwareAllocation>>>> - AllocatedHardware; - std::map<int, bool> TestsHaveSufficientHardware; - cmCTestHardwareAllocator HardwareAllocator; + std::vector<std::map<std::string, std::vector<ResourceAllocation>>>> + AllocatedResources; + std::map<int, bool> TestsHaveSufficientResources; + cmCTestResourceAllocator ResourceAllocator; std::vector<cmCTestTestHandler::cmCTestTestResult>* TestResults; size_t ParallelLevel; // max number of process that can be run at once unsigned long TestLoad; diff --git a/Source/CTest/cmCTestProcessesLexerHelper.cxx b/Source/CTest/cmCTestProcessesLexerHelper.cxx deleted file mode 100644 index 797164b..0000000 --- a/Source/CTest/cmCTestProcessesLexerHelper.cxx +++ /dev/null @@ -1,55 +0,0 @@ -/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying - file Copyright.txt or https://cmake.org/licensing for details. */ -#include "cmCTestProcessesLexerHelper.h" - -#include "cmCTestProcessesLexer.h" -#include "cmCTestTestHandler.h" - -cmCTestProcessesLexerHelper::cmCTestProcessesLexerHelper( - std::vector<std::vector<cmCTestTestHandler::cmCTestTestResourceRequirement>>& - output) - : Output(output) -{ -} - -bool cmCTestProcessesLexerHelper::ParseString(const std::string& value) -{ - yyscan_t lexer; - cmCTestProcesses_yylex_init_extra(this, &lexer); - - auto state = cmCTestProcesses_yy_scan_string(value.c_str(), lexer); - int retval = cmCTestProcesses_yylex(lexer); - cmCTestProcesses_yy_delete_buffer(state, lexer); - - cmCTestProcesses_yylex_destroy(lexer); - return retval == 0; -} - -void cmCTestProcessesLexerHelper::SetProcessCount(unsigned int count) -{ - this->ProcessCount = count; -} - -void cmCTestProcessesLexerHelper::SetResourceType(const std::string& type) -{ - this->ResourceType = type; -} - -void cmCTestProcessesLexerHelper::SetNeededSlots(int count) -{ - this->NeededSlots = count; -} - -void cmCTestProcessesLexerHelper::WriteRequirement() -{ - this->Process.push_back({ this->ResourceType, this->NeededSlots, 1 }); -} - -void cmCTestProcessesLexerHelper::WriteProcess() -{ - for (unsigned int i = 0; i < this->ProcessCount; ++i) { - this->Output.push_back(this->Process); - } - this->Process.clear(); - this->ProcessCount = 1; -} diff --git a/Source/CTest/cmCTestHardwareAllocator.cxx b/Source/CTest/cmCTestResourceAllocator.cxx index 2d1833d..9d468a7 100644 --- a/Source/CTest/cmCTestHardwareAllocator.cxx +++ b/Source/CTest/cmCTestResourceAllocator.cxx @@ -1,15 +1,15 @@ /* Distributed under the OSI-approved BSD 3-Clause License. See accompanying file Copyright.txt or https://cmake.org/licensing for details. */ -#include "cmCTestHardwareAllocator.h" +#include "cmCTestResourceAllocator.h" #include <utility> #include <vector> -#include "cmCTestHardwareSpec.h" +#include "cmCTestResourceSpec.h" -void cmCTestHardwareAllocator::InitializeFromHardwareSpec( - const cmCTestHardwareSpec& spec) +void cmCTestResourceAllocator::InitializeFromResourceSpec( + const cmCTestResourceSpec& spec) { this->Resources.clear(); @@ -23,13 +23,13 @@ void cmCTestHardwareAllocator::InitializeFromHardwareSpec( } const std::map<std::string, - std::map<std::string, cmCTestHardwareAllocator::Resource>>& -cmCTestHardwareAllocator::GetResources() const + std::map<std::string, cmCTestResourceAllocator::Resource>>& +cmCTestResourceAllocator::GetResources() const { return this->Resources; } -bool cmCTestHardwareAllocator::AllocateResource(const std::string& name, +bool cmCTestResourceAllocator::AllocateResource(const std::string& name, const std::string& id, unsigned int slots) { @@ -51,7 +51,7 @@ bool cmCTestHardwareAllocator::AllocateResource(const std::string& name, return true; } -bool cmCTestHardwareAllocator::DeallocateResource(const std::string& name, +bool cmCTestResourceAllocator::DeallocateResource(const std::string& name, const std::string& id, unsigned int slots) { @@ -73,13 +73,13 @@ bool cmCTestHardwareAllocator::DeallocateResource(const std::string& name, return true; } -bool cmCTestHardwareAllocator::Resource::operator==( +bool cmCTestResourceAllocator::Resource::operator==( const Resource& other) const { return this->Total == other.Total && this->Locked == other.Locked; } -bool cmCTestHardwareAllocator::Resource::operator!=( +bool cmCTestResourceAllocator::Resource::operator!=( const Resource& other) const { return !(*this == other); diff --git a/Source/CTest/cmCTestHardwareAllocator.h b/Source/CTest/cmCTestResourceAllocator.h index 441f84d..9f0b9c9 100644 --- a/Source/CTest/cmCTestHardwareAllocator.h +++ b/Source/CTest/cmCTestResourceAllocator.h @@ -1,14 +1,14 @@ /* Distributed under the OSI-approved BSD 3-Clause License. See accompanying file Copyright.txt or https://cmake.org/licensing for details. */ -#ifndef cmCTestHardwareAllocator_h -#define cmCTestHardwareAllocator_h +#ifndef cmCTestResourceAllocator_h +#define cmCTestResourceAllocator_h #include <map> #include <string> -class cmCTestHardwareSpec; +class cmCTestResourceSpec; -class cmCTestHardwareAllocator +class cmCTestResourceAllocator { public: struct Resource @@ -22,7 +22,7 @@ public: bool operator!=(const Resource& other) const; }; - void InitializeFromHardwareSpec(const cmCTestHardwareSpec& spec); + void InitializeFromResourceSpec(const cmCTestResourceSpec& spec); const std::map<std::string, std::map<std::string, Resource>>& GetResources() const; diff --git a/Source/CTest/cmCTestResourceGroupsLexerHelper.cxx b/Source/CTest/cmCTestResourceGroupsLexerHelper.cxx new file mode 100644 index 0000000..072af42 --- /dev/null +++ b/Source/CTest/cmCTestResourceGroupsLexerHelper.cxx @@ -0,0 +1,55 @@ +/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying + file Copyright.txt or https://cmake.org/licensing for details. */ +#include "cmCTestResourceGroupsLexerHelper.h" + +#include "cmCTestResourceGroupsLexer.h" +#include "cmCTestTestHandler.h" + +cmCTestResourceGroupsLexerHelper::cmCTestResourceGroupsLexerHelper( + std::vector<std::vector<cmCTestTestHandler::cmCTestTestResourceRequirement>>& + output) + : Output(output) +{ +} + +bool cmCTestResourceGroupsLexerHelper::ParseString(const std::string& value) +{ + yyscan_t lexer; + cmCTestResourceGroups_yylex_init_extra(this, &lexer); + + auto state = cmCTestResourceGroups_yy_scan_string(value.c_str(), lexer); + int retval = cmCTestResourceGroups_yylex(lexer); + cmCTestResourceGroups_yy_delete_buffer(state, lexer); + + cmCTestResourceGroups_yylex_destroy(lexer); + return retval == 0; +} + +void cmCTestResourceGroupsLexerHelper::SetProcessCount(unsigned int count) +{ + this->ProcessCount = count; +} + +void cmCTestResourceGroupsLexerHelper::SetResourceType(const std::string& type) +{ + this->ResourceType = type; +} + +void cmCTestResourceGroupsLexerHelper::SetNeededSlots(int count) +{ + this->NeededSlots = count; +} + +void cmCTestResourceGroupsLexerHelper::WriteRequirement() +{ + this->Process.push_back({ this->ResourceType, this->NeededSlots, 1 }); +} + +void cmCTestResourceGroupsLexerHelper::WriteProcess() +{ + for (unsigned int i = 0; i < this->ProcessCount; ++i) { + this->Output.push_back(this->Process); + } + this->Process.clear(); + this->ProcessCount = 1; +} diff --git a/Source/CTest/cmCTestProcessesLexerHelper.h b/Source/CTest/cmCTestResourceGroupsLexerHelper.h index 6c9289f..2cb6cb1 100644 --- a/Source/CTest/cmCTestProcessesLexerHelper.h +++ b/Source/CTest/cmCTestResourceGroupsLexerHelper.h @@ -1,25 +1,25 @@ /* Distributed under the OSI-approved BSD 3-Clause License. See accompanying file Copyright.txt or https://cmake.org/licensing for details. */ -#ifndef cmCTestProcessesLexerHelper_h -#define cmCTestProcessesLexerHelper_h +#ifndef cmCTestResourceGroupsLexerHelper_h +#define cmCTestResourceGroupsLexerHelper_h #include <string> #include <vector> #include "cmCTestTestHandler.h" -class cmCTestProcessesLexerHelper +class cmCTestResourceGroupsLexerHelper { public: struct ParserType { }; - cmCTestProcessesLexerHelper( + cmCTestResourceGroupsLexerHelper( std::vector< std::vector<cmCTestTestHandler::cmCTestTestResourceRequirement>>& output); - ~cmCTestProcessesLexerHelper() = default; + ~cmCTestResourceGroupsLexerHelper() = default; bool ParseString(const std::string& value); @@ -39,6 +39,6 @@ private: std::vector<cmCTestTestHandler::cmCTestTestResourceRequirement> Process; }; -#define YY_EXTRA_TYPE cmCTestProcessesLexerHelper* +#define YY_EXTRA_TYPE cmCTestResourceGroupsLexerHelper* #endif diff --git a/Source/CTest/cmCTestHardwareSpec.cxx b/Source/CTest/cmCTestResourceSpec.cxx index 137398a..b4a2b30 100644 --- a/Source/CTest/cmCTestHardwareSpec.cxx +++ b/Source/CTest/cmCTestResourceSpec.cxx @@ -1,6 +1,6 @@ /* Distributed under the OSI-approved BSD 3-Clause License. See accompanying file Copyright.txt or https://cmake.org/licensing for details. */ -#include "cmCTestHardwareSpec.h" +#include "cmCTestResourceSpec.h" #include <map> #include <string> @@ -16,7 +16,7 @@ static const cmsys::RegularExpression IdentifierRegex{ "^[a-z_][a-z0-9_]*$" }; static const cmsys::RegularExpression IdRegex{ "^[a-z0-9_]+$" }; -bool cmCTestHardwareSpec::ReadFromJSONFile(const std::string& filename) +bool cmCTestResourceSpec::ReadFromJSONFile(const std::string& filename) { cmsys::ifstream fin(filename.c_str()); if (!fin) { @@ -50,7 +50,7 @@ bool cmCTestHardwareSpec::ReadFromJSONFile(const std::string& filename) if (!localSocket.isObject()) { return false; } - std::map<std::string, std::vector<cmCTestHardwareSpec::Resource>> resources; + std::map<std::string, std::vector<cmCTestResourceSpec::Resource>> resources; cmsys::RegularExpressionMatch match; for (auto const& key : localSocket.getMemberNames()) { if (IdentifierRegex.find(key.c_str(), match)) { @@ -59,7 +59,7 @@ bool cmCTestHardwareSpec::ReadFromJSONFile(const std::string& filename) if (value.isArray()) { for (auto const& item : value) { if (item.isObject()) { - cmCTestHardwareSpec::Resource resource; + cmCTestResourceSpec::Resource resource; if (!item.isMember("id")) { return false; @@ -98,36 +98,36 @@ bool cmCTestHardwareSpec::ReadFromJSONFile(const std::string& filename) return true; } -bool cmCTestHardwareSpec::operator==(const cmCTestHardwareSpec& other) const +bool cmCTestResourceSpec::operator==(const cmCTestResourceSpec& other) const { return this->LocalSocket == other.LocalSocket; } -bool cmCTestHardwareSpec::operator!=(const cmCTestHardwareSpec& other) const +bool cmCTestResourceSpec::operator!=(const cmCTestResourceSpec& other) const { return !(*this == other); } -bool cmCTestHardwareSpec::Socket::operator==( - const cmCTestHardwareSpec::Socket& other) const +bool cmCTestResourceSpec::Socket::operator==( + const cmCTestResourceSpec::Socket& other) const { return this->Resources == other.Resources; } -bool cmCTestHardwareSpec::Socket::operator!=( - const cmCTestHardwareSpec::Socket& other) const +bool cmCTestResourceSpec::Socket::operator!=( + const cmCTestResourceSpec::Socket& other) const { return !(*this == other); } -bool cmCTestHardwareSpec::Resource::operator==( - const cmCTestHardwareSpec::Resource& other) const +bool cmCTestResourceSpec::Resource::operator==( + const cmCTestResourceSpec::Resource& other) const { return this->Id == other.Id && this->Capacity == other.Capacity; } -bool cmCTestHardwareSpec::Resource::operator!=( - const cmCTestHardwareSpec::Resource& other) const +bool cmCTestResourceSpec::Resource::operator!=( + const cmCTestResourceSpec::Resource& other) const { return !(*this == other); } diff --git a/Source/CTest/cmCTestHardwareSpec.h b/Source/CTest/cmCTestResourceSpec.h index a0b4cae..4646db8 100644 --- a/Source/CTest/cmCTestHardwareSpec.h +++ b/Source/CTest/cmCTestResourceSpec.h @@ -1,13 +1,13 @@ /* Distributed under the OSI-approved BSD 3-Clause License. See accompanying file Copyright.txt or https://cmake.org/licensing for details. */ -#ifndef cmCTestHardwareSpec_h -#define cmCTestHardwareSpec_h +#ifndef cmCTestResourceSpec_h +#define cmCTestResourceSpec_h #include <map> #include <string> #include <vector> -class cmCTestHardwareSpec +class cmCTestResourceSpec { public: class Resource @@ -33,8 +33,8 @@ public: bool ReadFromJSONFile(const std::string& filename); - bool operator==(const cmCTestHardwareSpec& other) const; - bool operator!=(const cmCTestHardwareSpec& other) const; + bool operator==(const cmCTestResourceSpec& other) const; + bool operator!=(const cmCTestResourceSpec& other) const; }; #endif diff --git a/Source/CTest/cmCTestRunTest.cxx b/Source/CTest/cmCTestRunTest.cxx index 7f7f736..3091050 100644 --- a/Source/CTest/cmCTestRunTest.cxx +++ b/Source/CTest/cmCTestRunTest.cxx @@ -690,25 +690,25 @@ bool cmCTestRunTest::ForkProcess(cmDuration testTimeOut, bool explicitTimeout, cmSystemTools::AppendEnv(*environment); } - if (this->UseAllocatedHardware) { - this->SetupHardwareEnvironment(); + if (this->UseAllocatedResources) { + this->SetupResourcesEnvironment(); } else { - cmSystemTools::UnsetEnv("CTEST_PROCESS_COUNT"); + cmSystemTools::UnsetEnv("CTEST_RESOURCE_GROUP_COUNT"); } return this->TestProcess->StartProcess(this->MultiTestHandler.Loop, affinity); } -void cmCTestRunTest::SetupHardwareEnvironment() +void cmCTestRunTest::SetupResourcesEnvironment() { - std::string processCount = "CTEST_PROCESS_COUNT="; - processCount += std::to_string(this->AllocatedHardware.size()); + std::string processCount = "CTEST_RESOURCE_GROUP_COUNT="; + processCount += std::to_string(this->AllocatedResources.size()); cmSystemTools::PutEnv(processCount); std::size_t i = 0; - for (auto const& process : this->AllocatedHardware) { - std::string prefix = "CTEST_PROCESS_"; + for (auto const& process : this->AllocatedResources) { + std::string prefix = "CTEST_RESOURCE_GROUP_"; prefix += std::to_string(i); std::string resourceList = prefix + '='; prefix += '_'; diff --git a/Source/CTest/cmCTestRunTest.h b/Source/CTest/cmCTestRunTest.h index 085a6b8..f781c7a 100644 --- a/Source/CTest/cmCTestRunTest.h +++ b/Source/CTest/cmCTestRunTest.h @@ -84,14 +84,17 @@ public: bool TimedOutForStopTime() const { return this->TimeoutIsForStopTime; } - void SetUseAllocatedHardware(bool use) { this->UseAllocatedHardware = use; } - void SetAllocatedHardware( + void SetUseAllocatedResources(bool use) + { + this->UseAllocatedResources = use; + } + void SetAllocatedResources( const std::vector< std::map<std::string, - std::vector<cmCTestMultiProcessHandler::HardwareAllocation>>>& - hardware) + std::vector<cmCTestMultiProcessHandler::ResourceAllocation>>>& + resources) { - this->AllocatedHardware = hardware; + this->AllocatedResources = resources; } private: @@ -105,7 +108,7 @@ private: // Run post processing of the process output for MemCheck void MemCheckPostProcess(); - void SetupHardwareEnvironment(); + void SetupResourcesEnvironment(); // Returns "completed/total Test #Index: " std::string GetTestPrefix(size_t completed, size_t total) const; @@ -125,10 +128,10 @@ private: std::string StartTime; std::string ActualCommand; std::vector<std::string> Arguments; - bool UseAllocatedHardware = false; + bool UseAllocatedResources = false; std::vector<std::map< - std::string, std::vector<cmCTestMultiProcessHandler::HardwareAllocation>>> - AllocatedHardware; + std::string, std::vector<cmCTestMultiProcessHandler::ResourceAllocation>>> + AllocatedResources; bool RunUntilFail; int NumberOfRunsLeft; bool RunAgain; diff --git a/Source/CTest/cmCTestTestCommand.cxx b/Source/CTest/cmCTestTestCommand.cxx index 5496353..9784214 100644 --- a/Source/CTest/cmCTestTestCommand.cxx +++ b/Source/CTest/cmCTestTestCommand.cxx @@ -32,7 +32,7 @@ void cmCTestTestCommand::BindArguments() this->Bind("SCHEDULE_RANDOM"_s, this->ScheduleRandom); this->Bind("STOP_TIME"_s, this->StopTime); this->Bind("TEST_LOAD"_s, this->TestLoad); - this->Bind("HARDWARE_SPEC_FILE"_s, this->HardwareSpecFile); + this->Bind("RESOURCE_SPEC_FILE"_s, this->ResourceSpecFile); } cmCTestGenericHandler* cmCTestTestCommand::InitializeHandler() @@ -88,8 +88,8 @@ cmCTestGenericHandler* cmCTestTestCommand::InitializeHandler() if (!this->ScheduleRandom.empty()) { handler->SetOption("ScheduleRandom", this->ScheduleRandom.c_str()); } - if (!this->HardwareSpecFile.empty()) { - handler->SetOption("HardwareSpecFile", this->HardwareSpecFile.c_str()); + if (!this->ResourceSpecFile.empty()) { + handler->SetOption("ResourceSpecFile", this->ResourceSpecFile.c_str()); } if (!this->StopTime.empty()) { this->CTest->SetStopTime(this->StopTime); diff --git a/Source/CTest/cmCTestTestCommand.h b/Source/CTest/cmCTestTestCommand.h index dc15279..4019694 100644 --- a/Source/CTest/cmCTestTestCommand.h +++ b/Source/CTest/cmCTestTestCommand.h @@ -58,7 +58,7 @@ protected: std::string ScheduleRandom; std::string StopTime; std::string TestLoad; - std::string HardwareSpecFile; + std::string ResourceSpecFile; }; #endif diff --git a/Source/CTest/cmCTestTestHandler.cxx b/Source/CTest/cmCTestTestHandler.cxx index 2be62ae..8e3ac22 100644 --- a/Source/CTest/cmCTestTestHandler.cxx +++ b/Source/CTest/cmCTestTestHandler.cxx @@ -29,7 +29,7 @@ #include "cmAlgorithms.h" #include "cmCTest.h" #include "cmCTestMultiProcessHandler.h" -#include "cmCTestProcessesLexerHelper.h" +#include "cmCTestResourceGroupsLexerHelper.h" #include "cmDuration.h" #include "cmExecutionStatus.h" #include "cmGeneratedFileStream.h" @@ -289,7 +289,7 @@ cmCTestTestHandler::cmCTestTestHandler() this->UseIncludeRegExpFlag = false; this->UseExcludeRegExpFlag = false; this->UseExcludeRegExpFirst = false; - this->UseHardwareSpec = false; + this->UseResourceSpec = false; this->CustomMaximumPassedTestOutputSize = 1 * 1024; this->CustomMaximumFailedTestOutputSize = 300 * 1024; @@ -510,12 +510,12 @@ bool cmCTestTestHandler::ProcessOptions() } this->SetRerunFailed(cmIsOn(this->GetOption("RerunFailed"))); - val = this->GetOption("HardwareSpecFile"); + val = this->GetOption("ResourceSpecFile"); if (val) { - this->UseHardwareSpec = true; - if (!this->HardwareSpec.ReadFromJSONFile(val)) { + this->UseResourceSpec = true; + if (!this->ResourceSpec.ReadFromJSONFile(val)) { cmCTestLog(this->CTest, ERROR_MESSAGE, - "Could not read hardware spec file: " << val << std::endl); + "Could not read resource spec file: " << val << std::endl); return false; } } @@ -1237,8 +1237,8 @@ void cmCTestTestHandler::ProcessDirectory(std::vector<std::string>& passed, } else { parallel->SetTestLoad(this->CTest->GetTestLoad()); } - if (this->UseHardwareSpec) { - parallel->InitHardwareAllocator(this->HardwareSpec); + if (this->UseResourceSpec) { + parallel->InitResourceAllocator(this->ResourceSpec); } *this->LogFile @@ -1283,7 +1283,7 @@ void cmCTestTestHandler::ProcessDirectory(std::vector<std::string>& passed, parallel->SetPassFailVectors(&passed, &failed); this->TestResults.clear(); parallel->SetTestResults(&this->TestResults); - parallel->CheckHardwareAvailable(); + parallel->CheckResourcesAvailable(); if (this->CTest->ShouldPrintLabels()) { parallel->PrintLabels(); @@ -1626,11 +1626,11 @@ std::string cmCTestTestHandler::FindExecutable( return fullPath; } -bool cmCTestTestHandler::ParseProcessesProperty( +bool cmCTestTestHandler::ParseResourceGroupsProperty( const std::string& val, - std::vector<std::vector<cmCTestTestResourceRequirement>>& processes) + std::vector<std::vector<cmCTestTestResourceRequirement>>& resourceGroups) { - cmCTestProcessesLexerHelper lexer(processes); + cmCTestResourceGroupsLexerHelper lexer(resourceGroups); return lexer.ParseString(val); } @@ -2203,8 +2203,8 @@ bool cmCTestTestHandler::SetTestsProperties( if (key == "PROCESSOR_AFFINITY") { rt.WantAffinity = cmIsOn(val); } - if (key == "PROCESSES") { - if (!ParseProcessesProperty(val, rt.Processes)) { + if (key == "RESOURCE_GROUPS") { + if (!ParseResourceGroupsProperty(val, rt.ResourceGroups)) { return false; } } diff --git a/Source/CTest/cmCTestTestHandler.h b/Source/CTest/cmCTestTestHandler.h index 525215c..eab75d0 100644 --- a/Source/CTest/cmCTestTestHandler.h +++ b/Source/CTest/cmCTestTestHandler.h @@ -19,7 +19,7 @@ #include "cmsys/RegularExpression.hxx" #include "cmCTestGenericHandler.h" -#include "cmCTestHardwareSpec.h" +#include "cmCTestResourceSpec.h" #include "cmDuration.h" #include "cmListFileCache.h" @@ -158,7 +158,7 @@ public: std::set<std::string> FixturesCleanup; std::set<std::string> FixturesRequired; std::set<std::string> RequireSuccessDepends; - std::vector<std::vector<cmCTestTestResourceRequirement>> Processes; + std::vector<std::vector<cmCTestTestResourceRequirement>> ResourceGroups; // Private test generator properties used to track backtraces cmListFileBacktrace Backtrace; }; @@ -202,9 +202,9 @@ public: std::vector<std::string>& extraPaths, std::vector<std::string>& failed); - static bool ParseProcessesProperty( + static bool ParseResourceGroupsProperty( const std::string& val, - std::vector<std::vector<cmCTestTestResourceRequirement>>& processes); + std::vector<std::vector<cmCTestTestResourceRequirement>>& resourceGroups); using ListOfTests = std::vector<cmCTestTestProperties>; @@ -336,8 +336,8 @@ private: cmsys::RegularExpression IncludeTestsRegularExpression; cmsys::RegularExpression ExcludeTestsRegularExpression; - bool UseHardwareSpec; - cmCTestHardwareSpec HardwareSpec; + bool UseResourceSpec; + cmCTestResourceSpec ResourceSpec; void GenerateRegressionImages(cmXMLWriter& xml, const std::string& dart); cmsys::RegularExpression DartStuff1; diff --git a/Source/LexerParser/.gitattributes b/Source/LexerParser/.gitattributes index e5a1d8b..bf70249 100644 --- a/Source/LexerParser/.gitattributes +++ b/Source/LexerParser/.gitattributes @@ -2,8 +2,8 @@ /cmCommandArgumentLexer.h generated /cmCommandArgumentParser.cxx generated /cmCommandArgumentParserTokens.h generated -/cmCTestProcessesLexer.cxx generated -/cmCTestProcessesLexer.h generated +/cmCTestResourceGroupsLexer.cxx generated +/cmCTestResourceGroupsLexer.h generated /cmDependsJavaLexer.cxx generated /cmDependsJavaLexer.h generated /cmDependsJavaParser.cxx generated diff --git a/Source/LexerParser/cmCTestProcessesLexer.cxx b/Source/LexerParser/cmCTestResourceGroupsLexer.cxx index 2a5dab3..de07c46 100644 --- a/Source/LexerParser/cmCTestProcessesLexer.cxx +++ b/Source/LexerParser/cmCTestResourceGroupsLexer.cxx @@ -14,213 +14,213 @@ #endif #ifdef yy_create_buffer -#define cmCTestProcesses_yy_create_buffer_ALREADY_DEFINED +#define cmCTestResourceGroups_yy_create_buffer_ALREADY_DEFINED #else -#define yy_create_buffer cmCTestProcesses_yy_create_buffer +#define yy_create_buffer cmCTestResourceGroups_yy_create_buffer #endif #ifdef yy_delete_buffer -#define cmCTestProcesses_yy_delete_buffer_ALREADY_DEFINED +#define cmCTestResourceGroups_yy_delete_buffer_ALREADY_DEFINED #else -#define yy_delete_buffer cmCTestProcesses_yy_delete_buffer +#define yy_delete_buffer cmCTestResourceGroups_yy_delete_buffer #endif #ifdef yy_scan_buffer -#define cmCTestProcesses_yy_scan_buffer_ALREADY_DEFINED +#define cmCTestResourceGroups_yy_scan_buffer_ALREADY_DEFINED #else -#define yy_scan_buffer cmCTestProcesses_yy_scan_buffer +#define yy_scan_buffer cmCTestResourceGroups_yy_scan_buffer #endif #ifdef yy_scan_string -#define cmCTestProcesses_yy_scan_string_ALREADY_DEFINED +#define cmCTestResourceGroups_yy_scan_string_ALREADY_DEFINED #else -#define yy_scan_string cmCTestProcesses_yy_scan_string +#define yy_scan_string cmCTestResourceGroups_yy_scan_string #endif #ifdef yy_scan_bytes -#define cmCTestProcesses_yy_scan_bytes_ALREADY_DEFINED +#define cmCTestResourceGroups_yy_scan_bytes_ALREADY_DEFINED #else -#define yy_scan_bytes cmCTestProcesses_yy_scan_bytes +#define yy_scan_bytes cmCTestResourceGroups_yy_scan_bytes #endif #ifdef yy_init_buffer -#define cmCTestProcesses_yy_init_buffer_ALREADY_DEFINED +#define cmCTestResourceGroups_yy_init_buffer_ALREADY_DEFINED #else -#define yy_init_buffer cmCTestProcesses_yy_init_buffer +#define yy_init_buffer cmCTestResourceGroups_yy_init_buffer #endif #ifdef yy_flush_buffer -#define cmCTestProcesses_yy_flush_buffer_ALREADY_DEFINED +#define cmCTestResourceGroups_yy_flush_buffer_ALREADY_DEFINED #else -#define yy_flush_buffer cmCTestProcesses_yy_flush_buffer +#define yy_flush_buffer cmCTestResourceGroups_yy_flush_buffer #endif #ifdef yy_load_buffer_state -#define cmCTestProcesses_yy_load_buffer_state_ALREADY_DEFINED +#define cmCTestResourceGroups_yy_load_buffer_state_ALREADY_DEFINED #else -#define yy_load_buffer_state cmCTestProcesses_yy_load_buffer_state +#define yy_load_buffer_state cmCTestResourceGroups_yy_load_buffer_state #endif #ifdef yy_switch_to_buffer -#define cmCTestProcesses_yy_switch_to_buffer_ALREADY_DEFINED +#define cmCTestResourceGroups_yy_switch_to_buffer_ALREADY_DEFINED #else -#define yy_switch_to_buffer cmCTestProcesses_yy_switch_to_buffer +#define yy_switch_to_buffer cmCTestResourceGroups_yy_switch_to_buffer #endif #ifdef yypush_buffer_state -#define cmCTestProcesses_yypush_buffer_state_ALREADY_DEFINED +#define cmCTestResourceGroups_yypush_buffer_state_ALREADY_DEFINED #else -#define yypush_buffer_state cmCTestProcesses_yypush_buffer_state +#define yypush_buffer_state cmCTestResourceGroups_yypush_buffer_state #endif #ifdef yypop_buffer_state -#define cmCTestProcesses_yypop_buffer_state_ALREADY_DEFINED +#define cmCTestResourceGroups_yypop_buffer_state_ALREADY_DEFINED #else -#define yypop_buffer_state cmCTestProcesses_yypop_buffer_state +#define yypop_buffer_state cmCTestResourceGroups_yypop_buffer_state #endif #ifdef yyensure_buffer_stack -#define cmCTestProcesses_yyensure_buffer_stack_ALREADY_DEFINED +#define cmCTestResourceGroups_yyensure_buffer_stack_ALREADY_DEFINED #else -#define yyensure_buffer_stack cmCTestProcesses_yyensure_buffer_stack +#define yyensure_buffer_stack cmCTestResourceGroups_yyensure_buffer_stack #endif #ifdef yylex -#define cmCTestProcesses_yylex_ALREADY_DEFINED +#define cmCTestResourceGroups_yylex_ALREADY_DEFINED #else -#define yylex cmCTestProcesses_yylex +#define yylex cmCTestResourceGroups_yylex #endif #ifdef yyrestart -#define cmCTestProcesses_yyrestart_ALREADY_DEFINED +#define cmCTestResourceGroups_yyrestart_ALREADY_DEFINED #else -#define yyrestart cmCTestProcesses_yyrestart +#define yyrestart cmCTestResourceGroups_yyrestart #endif #ifdef yylex_init -#define cmCTestProcesses_yylex_init_ALREADY_DEFINED +#define cmCTestResourceGroups_yylex_init_ALREADY_DEFINED #else -#define yylex_init cmCTestProcesses_yylex_init +#define yylex_init cmCTestResourceGroups_yylex_init #endif #ifdef yylex_init_extra -#define cmCTestProcesses_yylex_init_extra_ALREADY_DEFINED +#define cmCTestResourceGroups_yylex_init_extra_ALREADY_DEFINED #else -#define yylex_init_extra cmCTestProcesses_yylex_init_extra +#define yylex_init_extra cmCTestResourceGroups_yylex_init_extra #endif #ifdef yylex_destroy -#define cmCTestProcesses_yylex_destroy_ALREADY_DEFINED +#define cmCTestResourceGroups_yylex_destroy_ALREADY_DEFINED #else -#define yylex_destroy cmCTestProcesses_yylex_destroy +#define yylex_destroy cmCTestResourceGroups_yylex_destroy #endif #ifdef yyget_debug -#define cmCTestProcesses_yyget_debug_ALREADY_DEFINED +#define cmCTestResourceGroups_yyget_debug_ALREADY_DEFINED #else -#define yyget_debug cmCTestProcesses_yyget_debug +#define yyget_debug cmCTestResourceGroups_yyget_debug #endif #ifdef yyset_debug -#define cmCTestProcesses_yyset_debug_ALREADY_DEFINED +#define cmCTestResourceGroups_yyset_debug_ALREADY_DEFINED #else -#define yyset_debug cmCTestProcesses_yyset_debug +#define yyset_debug cmCTestResourceGroups_yyset_debug #endif #ifdef yyget_extra -#define cmCTestProcesses_yyget_extra_ALREADY_DEFINED +#define cmCTestResourceGroups_yyget_extra_ALREADY_DEFINED #else -#define yyget_extra cmCTestProcesses_yyget_extra +#define yyget_extra cmCTestResourceGroups_yyget_extra #endif #ifdef yyset_extra -#define cmCTestProcesses_yyset_extra_ALREADY_DEFINED +#define cmCTestResourceGroups_yyset_extra_ALREADY_DEFINED #else -#define yyset_extra cmCTestProcesses_yyset_extra +#define yyset_extra cmCTestResourceGroups_yyset_extra #endif #ifdef yyget_in -#define cmCTestProcesses_yyget_in_ALREADY_DEFINED +#define cmCTestResourceGroups_yyget_in_ALREADY_DEFINED #else -#define yyget_in cmCTestProcesses_yyget_in +#define yyget_in cmCTestResourceGroups_yyget_in #endif #ifdef yyset_in -#define cmCTestProcesses_yyset_in_ALREADY_DEFINED +#define cmCTestResourceGroups_yyset_in_ALREADY_DEFINED #else -#define yyset_in cmCTestProcesses_yyset_in +#define yyset_in cmCTestResourceGroups_yyset_in #endif #ifdef yyget_out -#define cmCTestProcesses_yyget_out_ALREADY_DEFINED +#define cmCTestResourceGroups_yyget_out_ALREADY_DEFINED #else -#define yyget_out cmCTestProcesses_yyget_out +#define yyget_out cmCTestResourceGroups_yyget_out #endif #ifdef yyset_out -#define cmCTestProcesses_yyset_out_ALREADY_DEFINED +#define cmCTestResourceGroups_yyset_out_ALREADY_DEFINED #else -#define yyset_out cmCTestProcesses_yyset_out +#define yyset_out cmCTestResourceGroups_yyset_out #endif #ifdef yyget_leng -#define cmCTestProcesses_yyget_leng_ALREADY_DEFINED +#define cmCTestResourceGroups_yyget_leng_ALREADY_DEFINED #else -#define yyget_leng cmCTestProcesses_yyget_leng +#define yyget_leng cmCTestResourceGroups_yyget_leng #endif #ifdef yyget_text -#define cmCTestProcesses_yyget_text_ALREADY_DEFINED +#define cmCTestResourceGroups_yyget_text_ALREADY_DEFINED #else -#define yyget_text cmCTestProcesses_yyget_text +#define yyget_text cmCTestResourceGroups_yyget_text #endif #ifdef yyget_lineno -#define cmCTestProcesses_yyget_lineno_ALREADY_DEFINED +#define cmCTestResourceGroups_yyget_lineno_ALREADY_DEFINED #else -#define yyget_lineno cmCTestProcesses_yyget_lineno +#define yyget_lineno cmCTestResourceGroups_yyget_lineno #endif #ifdef yyset_lineno -#define cmCTestProcesses_yyset_lineno_ALREADY_DEFINED +#define cmCTestResourceGroups_yyset_lineno_ALREADY_DEFINED #else -#define yyset_lineno cmCTestProcesses_yyset_lineno +#define yyset_lineno cmCTestResourceGroups_yyset_lineno #endif #ifdef yyget_column -#define cmCTestProcesses_yyget_column_ALREADY_DEFINED +#define cmCTestResourceGroups_yyget_column_ALREADY_DEFINED #else -#define yyget_column cmCTestProcesses_yyget_column +#define yyget_column cmCTestResourceGroups_yyget_column #endif #ifdef yyset_column -#define cmCTestProcesses_yyset_column_ALREADY_DEFINED +#define cmCTestResourceGroups_yyset_column_ALREADY_DEFINED #else -#define yyset_column cmCTestProcesses_yyset_column +#define yyset_column cmCTestResourceGroups_yyset_column #endif #ifdef yywrap -#define cmCTestProcesses_yywrap_ALREADY_DEFINED +#define cmCTestResourceGroups_yywrap_ALREADY_DEFINED #else -#define yywrap cmCTestProcesses_yywrap +#define yywrap cmCTestResourceGroups_yywrap #endif #ifdef yyalloc -#define cmCTestProcesses_yyalloc_ALREADY_DEFINED +#define cmCTestResourceGroups_yyalloc_ALREADY_DEFINED #else -#define yyalloc cmCTestProcesses_yyalloc +#define yyalloc cmCTestResourceGroups_yyalloc #endif #ifdef yyrealloc -#define cmCTestProcesses_yyrealloc_ALREADY_DEFINED +#define cmCTestResourceGroups_yyrealloc_ALREADY_DEFINED #else -#define yyrealloc cmCTestProcesses_yyrealloc +#define yyrealloc cmCTestResourceGroups_yyrealloc #endif #ifdef yyfree -#define cmCTestProcesses_yyfree_ALREADY_DEFINED +#define cmCTestResourceGroups_yyfree_ALREADY_DEFINED #else -#define yyfree cmCTestProcesses_yyfree +#define yyfree cmCTestResourceGroups_yyfree #endif /* First, we deal with platform-specific or compiler-specific issues. */ @@ -526,7 +526,7 @@ void yyfree ( void * , yyscan_t yyscanner ); /* Begin user sect3 */ -#define cmCTestProcesses_yywrap(yyscanner) (/*CONSTCOND*/1) +#define cmCTestResourceGroups_yywrap(yyscanner) (/*CONSTCOND*/1) #define YY_SKIP_YYWRAP typedef flex_uint8_t YY_CHAR; @@ -648,12 +648,12 @@ This file must be translated to C++ and modified to build everywhere. Run flex >= 2.6 like this: - flex --nounistd -DFLEXINT_H --noline --header-file=cmCTestProcessesLexer.h -ocmCTestProcessesLexer.cxx cmCTestProcessesLexer.in.l + flex --nounistd -DFLEXINT_H --noline --header-file=cmCTestResourceGroupsLexer.h -ocmCTestResourceGroupsLexer.cxx cmCTestResourceGroupsLexer.in.l -Modify cmCTestProcessesLexer.cxx: - - remove trailing whitespace: sed -i 's/\s*$//' cmCTestProcessesLexer.h cmCTestProcessesLexer.cxx - - remove blank lines at end of file: sed -i '${/^$/d;}' cmCTestProcessesLexer.h cmCTestProcessesLexer.cxx - - #include "cmStandardLexer.h" at the top: sed -i '1i#include "cmStandardLexer.h"' cmCTestProcessesLexer.cxx +Modify cmCTestResourceGroupsLexer.cxx: + - remove trailing whitespace: sed -i 's/\s*$//' cmCTestResourceGroupsLexer.h cmCTestResourceGroupsLexer.cxx + - remove blank lines at end of file: sed -i '${/^$/d;}' cmCTestResourceGroupsLexer.h cmCTestResourceGroupsLexer.cxx + - #include "cmStandardLexer.h" at the top: sed -i '1i#include "cmStandardLexer.h"' cmCTestResourceGroupsLexer.cxx */ @@ -661,7 +661,7 @@ Modify cmCTestProcessesLexer.cxx: #ifndef __clang_analyzer__ /* Suppress clang scan-build warnings */ -#include "cmCTestProcessesLexerHelper.h" +#include "cmCTestResourceGroupsLexerHelper.h" #include <string> @@ -670,8 +670,8 @@ Modify cmCTestProcessesLexer.cxx: /*--------------------------------------------------------------------------*/ #define INITIAL 0 -#define PROCESSES_START 1 -#define PROCESSES_END 2 +#define RESOURCE_GROUPS_START 1 +#define RESOURCE_GROUPS_END 2 #define RESOURCE_START 3 #define RESOURCE_COUNT 4 #define RESOURCE_END 5 @@ -990,7 +990,7 @@ YY_RULE_SETUP case 2: YY_RULE_SETUP { - BEGIN(PROCESSES_END); + BEGIN(RESOURCE_GROUPS_END); std::size_t len = yyleng; yyextra->SetProcessCount(std::stoll(yytext, &len, 10)); } @@ -1013,18 +1013,18 @@ YY_RULE_SETUP case 5: YY_RULE_SETUP { - BEGIN(PROCESSES_START); + BEGIN(RESOURCE_GROUPS_START); } YY_BREAK case 6: YY_RULE_SETUP { - BEGIN(PROCESSES_START); + BEGIN(RESOURCE_GROUPS_START); yyextra->WriteProcess(); } YY_BREAK case YY_STATE_EOF(RESOURCE_START): -case YY_STATE_EOF(PROCESSES_END): +case YY_STATE_EOF(RESOURCE_GROUPS_END): case YY_STATE_EOF(RESOURCE_END): { yyextra->WriteProcess(); @@ -1032,7 +1032,7 @@ case YY_STATE_EOF(RESOURCE_END): } YY_BREAK case YY_STATE_EOF(INITIAL): -case YY_STATE_EOF(PROCESSES_START): +case YY_STATE_EOF(RESOURCE_GROUPS_START): { return 0; } diff --git a/Source/LexerParser/cmCTestProcessesLexer.h b/Source/LexerParser/cmCTestResourceGroupsLexer.h index b6437b4..e323a50 100644 --- a/Source/LexerParser/cmCTestProcessesLexer.h +++ b/Source/LexerParser/cmCTestResourceGroupsLexer.h @@ -1,6 +1,6 @@ -#ifndef cmCTestProcesses_yyHEADER_H -#define cmCTestProcesses_yyHEADER_H 1 -#define cmCTestProcesses_yyIN_HEADER 1 +#ifndef cmCTestResourceGroups_yyHEADER_H +#define cmCTestResourceGroups_yyHEADER_H 1 +#define cmCTestResourceGroups_yyIN_HEADER 1 #define FLEXINT_H 1 #define YY_INT_ALIGNED short int @@ -16,213 +16,213 @@ #endif #ifdef yy_create_buffer -#define cmCTestProcesses_yy_create_buffer_ALREADY_DEFINED +#define cmCTestResourceGroups_yy_create_buffer_ALREADY_DEFINED #else -#define yy_create_buffer cmCTestProcesses_yy_create_buffer +#define yy_create_buffer cmCTestResourceGroups_yy_create_buffer #endif #ifdef yy_delete_buffer -#define cmCTestProcesses_yy_delete_buffer_ALREADY_DEFINED +#define cmCTestResourceGroups_yy_delete_buffer_ALREADY_DEFINED #else -#define yy_delete_buffer cmCTestProcesses_yy_delete_buffer +#define yy_delete_buffer cmCTestResourceGroups_yy_delete_buffer #endif #ifdef yy_scan_buffer -#define cmCTestProcesses_yy_scan_buffer_ALREADY_DEFINED +#define cmCTestResourceGroups_yy_scan_buffer_ALREADY_DEFINED #else -#define yy_scan_buffer cmCTestProcesses_yy_scan_buffer +#define yy_scan_buffer cmCTestResourceGroups_yy_scan_buffer #endif #ifdef yy_scan_string -#define cmCTestProcesses_yy_scan_string_ALREADY_DEFINED +#define cmCTestResourceGroups_yy_scan_string_ALREADY_DEFINED #else -#define yy_scan_string cmCTestProcesses_yy_scan_string +#define yy_scan_string cmCTestResourceGroups_yy_scan_string #endif #ifdef yy_scan_bytes -#define cmCTestProcesses_yy_scan_bytes_ALREADY_DEFINED +#define cmCTestResourceGroups_yy_scan_bytes_ALREADY_DEFINED #else -#define yy_scan_bytes cmCTestProcesses_yy_scan_bytes +#define yy_scan_bytes cmCTestResourceGroups_yy_scan_bytes #endif #ifdef yy_init_buffer -#define cmCTestProcesses_yy_init_buffer_ALREADY_DEFINED +#define cmCTestResourceGroups_yy_init_buffer_ALREADY_DEFINED #else -#define yy_init_buffer cmCTestProcesses_yy_init_buffer +#define yy_init_buffer cmCTestResourceGroups_yy_init_buffer #endif #ifdef yy_flush_buffer -#define cmCTestProcesses_yy_flush_buffer_ALREADY_DEFINED +#define cmCTestResourceGroups_yy_flush_buffer_ALREADY_DEFINED #else -#define yy_flush_buffer cmCTestProcesses_yy_flush_buffer +#define yy_flush_buffer cmCTestResourceGroups_yy_flush_buffer #endif #ifdef yy_load_buffer_state -#define cmCTestProcesses_yy_load_buffer_state_ALREADY_DEFINED +#define cmCTestResourceGroups_yy_load_buffer_state_ALREADY_DEFINED #else -#define yy_load_buffer_state cmCTestProcesses_yy_load_buffer_state +#define yy_load_buffer_state cmCTestResourceGroups_yy_load_buffer_state #endif #ifdef yy_switch_to_buffer -#define cmCTestProcesses_yy_switch_to_buffer_ALREADY_DEFINED +#define cmCTestResourceGroups_yy_switch_to_buffer_ALREADY_DEFINED #else -#define yy_switch_to_buffer cmCTestProcesses_yy_switch_to_buffer +#define yy_switch_to_buffer cmCTestResourceGroups_yy_switch_to_buffer #endif #ifdef yypush_buffer_state -#define cmCTestProcesses_yypush_buffer_state_ALREADY_DEFINED +#define cmCTestResourceGroups_yypush_buffer_state_ALREADY_DEFINED #else -#define yypush_buffer_state cmCTestProcesses_yypush_buffer_state +#define yypush_buffer_state cmCTestResourceGroups_yypush_buffer_state #endif #ifdef yypop_buffer_state -#define cmCTestProcesses_yypop_buffer_state_ALREADY_DEFINED +#define cmCTestResourceGroups_yypop_buffer_state_ALREADY_DEFINED #else -#define yypop_buffer_state cmCTestProcesses_yypop_buffer_state +#define yypop_buffer_state cmCTestResourceGroups_yypop_buffer_state #endif #ifdef yyensure_buffer_stack -#define cmCTestProcesses_yyensure_buffer_stack_ALREADY_DEFINED +#define cmCTestResourceGroups_yyensure_buffer_stack_ALREADY_DEFINED #else -#define yyensure_buffer_stack cmCTestProcesses_yyensure_buffer_stack +#define yyensure_buffer_stack cmCTestResourceGroups_yyensure_buffer_stack #endif #ifdef yylex -#define cmCTestProcesses_yylex_ALREADY_DEFINED +#define cmCTestResourceGroups_yylex_ALREADY_DEFINED #else -#define yylex cmCTestProcesses_yylex +#define yylex cmCTestResourceGroups_yylex #endif #ifdef yyrestart -#define cmCTestProcesses_yyrestart_ALREADY_DEFINED +#define cmCTestResourceGroups_yyrestart_ALREADY_DEFINED #else -#define yyrestart cmCTestProcesses_yyrestart +#define yyrestart cmCTestResourceGroups_yyrestart #endif #ifdef yylex_init -#define cmCTestProcesses_yylex_init_ALREADY_DEFINED +#define cmCTestResourceGroups_yylex_init_ALREADY_DEFINED #else -#define yylex_init cmCTestProcesses_yylex_init +#define yylex_init cmCTestResourceGroups_yylex_init #endif #ifdef yylex_init_extra -#define cmCTestProcesses_yylex_init_extra_ALREADY_DEFINED +#define cmCTestResourceGroups_yylex_init_extra_ALREADY_DEFINED #else -#define yylex_init_extra cmCTestProcesses_yylex_init_extra +#define yylex_init_extra cmCTestResourceGroups_yylex_init_extra #endif #ifdef yylex_destroy -#define cmCTestProcesses_yylex_destroy_ALREADY_DEFINED +#define cmCTestResourceGroups_yylex_destroy_ALREADY_DEFINED #else -#define yylex_destroy cmCTestProcesses_yylex_destroy +#define yylex_destroy cmCTestResourceGroups_yylex_destroy #endif #ifdef yyget_debug -#define cmCTestProcesses_yyget_debug_ALREADY_DEFINED +#define cmCTestResourceGroups_yyget_debug_ALREADY_DEFINED #else -#define yyget_debug cmCTestProcesses_yyget_debug +#define yyget_debug cmCTestResourceGroups_yyget_debug #endif #ifdef yyset_debug -#define cmCTestProcesses_yyset_debug_ALREADY_DEFINED +#define cmCTestResourceGroups_yyset_debug_ALREADY_DEFINED #else -#define yyset_debug cmCTestProcesses_yyset_debug +#define yyset_debug cmCTestResourceGroups_yyset_debug #endif #ifdef yyget_extra -#define cmCTestProcesses_yyget_extra_ALREADY_DEFINED +#define cmCTestResourceGroups_yyget_extra_ALREADY_DEFINED #else -#define yyget_extra cmCTestProcesses_yyget_extra +#define yyget_extra cmCTestResourceGroups_yyget_extra #endif #ifdef yyset_extra -#define cmCTestProcesses_yyset_extra_ALREADY_DEFINED +#define cmCTestResourceGroups_yyset_extra_ALREADY_DEFINED #else -#define yyset_extra cmCTestProcesses_yyset_extra +#define yyset_extra cmCTestResourceGroups_yyset_extra #endif #ifdef yyget_in -#define cmCTestProcesses_yyget_in_ALREADY_DEFINED +#define cmCTestResourceGroups_yyget_in_ALREADY_DEFINED #else -#define yyget_in cmCTestProcesses_yyget_in +#define yyget_in cmCTestResourceGroups_yyget_in #endif #ifdef yyset_in -#define cmCTestProcesses_yyset_in_ALREADY_DEFINED +#define cmCTestResourceGroups_yyset_in_ALREADY_DEFINED #else -#define yyset_in cmCTestProcesses_yyset_in +#define yyset_in cmCTestResourceGroups_yyset_in #endif #ifdef yyget_out -#define cmCTestProcesses_yyget_out_ALREADY_DEFINED +#define cmCTestResourceGroups_yyget_out_ALREADY_DEFINED #else -#define yyget_out cmCTestProcesses_yyget_out +#define yyget_out cmCTestResourceGroups_yyget_out #endif #ifdef yyset_out -#define cmCTestProcesses_yyset_out_ALREADY_DEFINED +#define cmCTestResourceGroups_yyset_out_ALREADY_DEFINED #else -#define yyset_out cmCTestProcesses_yyset_out +#define yyset_out cmCTestResourceGroups_yyset_out #endif #ifdef yyget_leng -#define cmCTestProcesses_yyget_leng_ALREADY_DEFINED +#define cmCTestResourceGroups_yyget_leng_ALREADY_DEFINED #else -#define yyget_leng cmCTestProcesses_yyget_leng +#define yyget_leng cmCTestResourceGroups_yyget_leng #endif #ifdef yyget_text -#define cmCTestProcesses_yyget_text_ALREADY_DEFINED +#define cmCTestResourceGroups_yyget_text_ALREADY_DEFINED #else -#define yyget_text cmCTestProcesses_yyget_text +#define yyget_text cmCTestResourceGroups_yyget_text #endif #ifdef yyget_lineno -#define cmCTestProcesses_yyget_lineno_ALREADY_DEFINED +#define cmCTestResourceGroups_yyget_lineno_ALREADY_DEFINED #else -#define yyget_lineno cmCTestProcesses_yyget_lineno +#define yyget_lineno cmCTestResourceGroups_yyget_lineno #endif #ifdef yyset_lineno -#define cmCTestProcesses_yyset_lineno_ALREADY_DEFINED +#define cmCTestResourceGroups_yyset_lineno_ALREADY_DEFINED #else -#define yyset_lineno cmCTestProcesses_yyset_lineno +#define yyset_lineno cmCTestResourceGroups_yyset_lineno #endif #ifdef yyget_column -#define cmCTestProcesses_yyget_column_ALREADY_DEFINED +#define cmCTestResourceGroups_yyget_column_ALREADY_DEFINED #else -#define yyget_column cmCTestProcesses_yyget_column +#define yyget_column cmCTestResourceGroups_yyget_column #endif #ifdef yyset_column -#define cmCTestProcesses_yyset_column_ALREADY_DEFINED +#define cmCTestResourceGroups_yyset_column_ALREADY_DEFINED #else -#define yyset_column cmCTestProcesses_yyset_column +#define yyset_column cmCTestResourceGroups_yyset_column #endif #ifdef yywrap -#define cmCTestProcesses_yywrap_ALREADY_DEFINED +#define cmCTestResourceGroups_yywrap_ALREADY_DEFINED #else -#define yywrap cmCTestProcesses_yywrap +#define yywrap cmCTestResourceGroups_yywrap #endif #ifdef yyalloc -#define cmCTestProcesses_yyalloc_ALREADY_DEFINED +#define cmCTestResourceGroups_yyalloc_ALREADY_DEFINED #else -#define yyalloc cmCTestProcesses_yyalloc +#define yyalloc cmCTestResourceGroups_yyalloc #endif #ifdef yyrealloc -#define cmCTestProcesses_yyrealloc_ALREADY_DEFINED +#define cmCTestResourceGroups_yyrealloc_ALREADY_DEFINED #else -#define yyrealloc cmCTestProcesses_yyrealloc +#define yyrealloc cmCTestResourceGroups_yyrealloc #endif #ifdef yyfree -#define cmCTestProcesses_yyfree_ALREADY_DEFINED +#define cmCTestResourceGroups_yyfree_ALREADY_DEFINED #else -#define yyfree cmCTestProcesses_yyfree +#define yyfree cmCTestResourceGroups_yyfree #endif /* First, we deal with platform-specific or compiler-specific issues. */ @@ -423,15 +423,15 @@ void yyfree ( void * , yyscan_t yyscanner ); /* Begin user sect3 */ -#define cmCTestProcesses_yywrap(yyscanner) (/*CONSTCOND*/1) +#define cmCTestResourceGroups_yywrap(yyscanner) (/*CONSTCOND*/1) #define YY_SKIP_YYWRAP #define yytext_ptr yytext_r #ifdef YY_HEADER_EXPORT_START_CONDITIONS #define INITIAL 0 -#define PROCESSES_START 1 -#define PROCESSES_END 2 +#define RESOURCE_GROUPS_START 1 +#define RESOURCE_GROUPS_END 2 #define RESOURCE_START 3 #define RESOURCE_COUNT 4 #define RESOURCE_END 5 @@ -543,150 +543,150 @@ extern int yylex (yyscan_t yyscanner); #undef YY_DECL #endif -#ifndef cmCTestProcesses_yy_create_buffer_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yy_create_buffer_ALREADY_DEFINED #undef yy_create_buffer #endif -#ifndef cmCTestProcesses_yy_delete_buffer_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yy_delete_buffer_ALREADY_DEFINED #undef yy_delete_buffer #endif -#ifndef cmCTestProcesses_yy_scan_buffer_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yy_scan_buffer_ALREADY_DEFINED #undef yy_scan_buffer #endif -#ifndef cmCTestProcesses_yy_scan_string_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yy_scan_string_ALREADY_DEFINED #undef yy_scan_string #endif -#ifndef cmCTestProcesses_yy_scan_bytes_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yy_scan_bytes_ALREADY_DEFINED #undef yy_scan_bytes #endif -#ifndef cmCTestProcesses_yy_init_buffer_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yy_init_buffer_ALREADY_DEFINED #undef yy_init_buffer #endif -#ifndef cmCTestProcesses_yy_flush_buffer_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yy_flush_buffer_ALREADY_DEFINED #undef yy_flush_buffer #endif -#ifndef cmCTestProcesses_yy_load_buffer_state_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yy_load_buffer_state_ALREADY_DEFINED #undef yy_load_buffer_state #endif -#ifndef cmCTestProcesses_yy_switch_to_buffer_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yy_switch_to_buffer_ALREADY_DEFINED #undef yy_switch_to_buffer #endif -#ifndef cmCTestProcesses_yypush_buffer_state_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yypush_buffer_state_ALREADY_DEFINED #undef yypush_buffer_state #endif -#ifndef cmCTestProcesses_yypop_buffer_state_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yypop_buffer_state_ALREADY_DEFINED #undef yypop_buffer_state #endif -#ifndef cmCTestProcesses_yyensure_buffer_stack_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yyensure_buffer_stack_ALREADY_DEFINED #undef yyensure_buffer_stack #endif -#ifndef cmCTestProcesses_yylex_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yylex_ALREADY_DEFINED #undef yylex #endif -#ifndef cmCTestProcesses_yyrestart_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yyrestart_ALREADY_DEFINED #undef yyrestart #endif -#ifndef cmCTestProcesses_yylex_init_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yylex_init_ALREADY_DEFINED #undef yylex_init #endif -#ifndef cmCTestProcesses_yylex_init_extra_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yylex_init_extra_ALREADY_DEFINED #undef yylex_init_extra #endif -#ifndef cmCTestProcesses_yylex_destroy_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yylex_destroy_ALREADY_DEFINED #undef yylex_destroy #endif -#ifndef cmCTestProcesses_yyget_debug_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yyget_debug_ALREADY_DEFINED #undef yyget_debug #endif -#ifndef cmCTestProcesses_yyset_debug_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yyset_debug_ALREADY_DEFINED #undef yyset_debug #endif -#ifndef cmCTestProcesses_yyget_extra_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yyget_extra_ALREADY_DEFINED #undef yyget_extra #endif -#ifndef cmCTestProcesses_yyset_extra_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yyset_extra_ALREADY_DEFINED #undef yyset_extra #endif -#ifndef cmCTestProcesses_yyget_in_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yyget_in_ALREADY_DEFINED #undef yyget_in #endif -#ifndef cmCTestProcesses_yyset_in_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yyset_in_ALREADY_DEFINED #undef yyset_in #endif -#ifndef cmCTestProcesses_yyget_out_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yyget_out_ALREADY_DEFINED #undef yyget_out #endif -#ifndef cmCTestProcesses_yyset_out_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yyset_out_ALREADY_DEFINED #undef yyset_out #endif -#ifndef cmCTestProcesses_yyget_leng_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yyget_leng_ALREADY_DEFINED #undef yyget_leng #endif -#ifndef cmCTestProcesses_yyget_text_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yyget_text_ALREADY_DEFINED #undef yyget_text #endif -#ifndef cmCTestProcesses_yyget_lineno_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yyget_lineno_ALREADY_DEFINED #undef yyget_lineno #endif -#ifndef cmCTestProcesses_yyset_lineno_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yyset_lineno_ALREADY_DEFINED #undef yyset_lineno #endif -#ifndef cmCTestProcesses_yyget_column_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yyget_column_ALREADY_DEFINED #undef yyget_column #endif -#ifndef cmCTestProcesses_yyset_column_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yyset_column_ALREADY_DEFINED #undef yyset_column #endif -#ifndef cmCTestProcesses_yywrap_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yywrap_ALREADY_DEFINED #undef yywrap #endif -#ifndef cmCTestProcesses_yyget_lval_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yyget_lval_ALREADY_DEFINED #undef yyget_lval #endif -#ifndef cmCTestProcesses_yyset_lval_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yyset_lval_ALREADY_DEFINED #undef yyset_lval #endif -#ifndef cmCTestProcesses_yyget_lloc_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yyget_lloc_ALREADY_DEFINED #undef yyget_lloc #endif -#ifndef cmCTestProcesses_yyset_lloc_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yyset_lloc_ALREADY_DEFINED #undef yyset_lloc #endif -#ifndef cmCTestProcesses_yyalloc_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yyalloc_ALREADY_DEFINED #undef yyalloc #endif -#ifndef cmCTestProcesses_yyrealloc_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yyrealloc_ALREADY_DEFINED #undef yyrealloc #endif -#ifndef cmCTestProcesses_yyfree_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yyfree_ALREADY_DEFINED #undef yyfree #endif -#ifndef cmCTestProcesses_yytext_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yytext_ALREADY_DEFINED #undef yytext #endif -#ifndef cmCTestProcesses_yyleng_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yyleng_ALREADY_DEFINED #undef yyleng #endif -#ifndef cmCTestProcesses_yyin_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yyin_ALREADY_DEFINED #undef yyin #endif -#ifndef cmCTestProcesses_yyout_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yyout_ALREADY_DEFINED #undef yyout #endif -#ifndef cmCTestProcesses_yy_flex_debug_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yy_flex_debug_ALREADY_DEFINED #undef yy_flex_debug #endif -#ifndef cmCTestProcesses_yylineno_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yylineno_ALREADY_DEFINED #undef yylineno #endif -#ifndef cmCTestProcesses_yytables_fload_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yytables_fload_ALREADY_DEFINED #undef yytables_fload #endif -#ifndef cmCTestProcesses_yytables_destroy_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yytables_destroy_ALREADY_DEFINED #undef yytables_destroy #endif -#ifndef cmCTestProcesses_yyTABLES_NAME_ALREADY_DEFINED +#ifndef cmCTestResourceGroups_yyTABLES_NAME_ALREADY_DEFINED #undef yyTABLES_NAME #endif -#undef cmCTestProcesses_yyIN_HEADER -#endif /* cmCTestProcesses_yyHEADER_H */ +#undef cmCTestResourceGroups_yyIN_HEADER +#endif /* cmCTestResourceGroups_yyHEADER_H */ diff --git a/Source/LexerParser/cmCTestProcessesLexer.in.l b/Source/LexerParser/cmCTestResourceGroupsLexer.in.l index ef494d5..2aabea4 100644 --- a/Source/LexerParser/cmCTestProcessesLexer.in.l +++ b/Source/LexerParser/cmCTestResourceGroupsLexer.in.l @@ -7,12 +7,12 @@ This file must be translated to C++ and modified to build everywhere. Run flex >= 2.6 like this: - flex --nounistd -DFLEXINT_H --noline --header-file=cmCTestProcessesLexer.h -ocmCTestProcessesLexer.cxx cmCTestProcessesLexer.in.l + flex --nounistd -DFLEXINT_H --noline --header-file=cmCTestResourceGroupsLexer.h -ocmCTestResourceGroupsLexer.cxx cmCTestResourceGroupsLexer.in.l -Modify cmCTestProcessesLexer.cxx: - - remove trailing whitespace: sed -i 's/\s*$//' cmCTestProcessesLexer.h cmCTestProcessesLexer.cxx - - remove blank lines at end of file: sed -i '${/^$/d;}' cmCTestProcessesLexer.h cmCTestProcessesLexer.cxx - - #include "cmStandardLexer.h" at the top: sed -i '1i#include "cmStandardLexer.h"' cmCTestProcessesLexer.cxx +Modify cmCTestResourceGroupsLexer.cxx: + - remove trailing whitespace: sed -i 's/\s*$//' cmCTestResourceGroupsLexer.h cmCTestResourceGroupsLexer.cxx + - remove blank lines at end of file: sed -i '${/^$/d;}' cmCTestResourceGroupsLexer.h cmCTestResourceGroupsLexer.cxx + - #include "cmStandardLexer.h" at the top: sed -i '1i#include "cmStandardLexer.h"' cmCTestResourceGroupsLexer.cxx */ @@ -20,7 +20,7 @@ Modify cmCTestProcessesLexer.cxx: #ifndef __clang_analyzer__ /* Suppress clang scan-build warnings */ -#include "cmCTestProcessesLexerHelper.h" +#include "cmCTestResourceGroupsLexerHelper.h" #include <string> @@ -29,15 +29,15 @@ Modify cmCTestProcessesLexer.cxx: /*--------------------------------------------------------------------------*/ %} -%option prefix="cmCTestProcesses_yy" +%option prefix="cmCTestResourceGroups_yy" %option reentrant %option noyywrap %option nodefault %pointer -%s PROCESSES_START -%s PROCESSES_END +%s RESOURCE_GROUPS_START +%s RESOURCE_GROUPS_END %s RESOURCE_START %s RESOURCE_COUNT %s RESOURCE_END @@ -47,13 +47,13 @@ IDENTIFIER [a-z_][a-z0-9_]* %% -<INITIAL,PROCESSES_START,RESOURCE_START>{IDENTIFIER}: { +<INITIAL,RESOURCE_GROUPS_START,RESOURCE_START>{IDENTIFIER}: { BEGIN(RESOURCE_COUNT); yyextra->SetResourceType(std::string(yytext, yyleng - 1)); } -<INITIAL,PROCESSES_START>{NUMBER} { - BEGIN(PROCESSES_END); +<INITIAL,RESOURCE_GROUPS_START>{NUMBER} { + BEGIN(RESOURCE_GROUPS_END); std::size_t len = yyleng; yyextra->SetProcessCount(std::stoll(yytext, &len, 10)); } @@ -65,25 +65,25 @@ IDENTIFIER [a-z_][a-z0-9_]* yyextra->WriteRequirement(); } -<PROCESSES_END,RESOURCE_END>,+ { +<RESOURCE_GROUPS_END,RESOURCE_END>,+ { BEGIN(RESOURCE_START); } -<INITIAL,PROCESSES_START,RESOURCE_START>;+ { - BEGIN(PROCESSES_START); +<INITIAL,RESOURCE_GROUPS_START,RESOURCE_START>;+ { + BEGIN(RESOURCE_GROUPS_START); } -<PROCESSES_END,RESOURCE_END>;+ { - BEGIN(PROCESSES_START); +<RESOURCE_GROUPS_END,RESOURCE_END>;+ { + BEGIN(RESOURCE_GROUPS_START); yyextra->WriteProcess(); } -<RESOURCE_START,PROCESSES_END,RESOURCE_END><<EOF>> { +<RESOURCE_START,RESOURCE_GROUPS_END,RESOURCE_END><<EOF>> { yyextra->WriteProcess(); return 0; } -<INITIAL,PROCESSES_START><<EOF>> { +<INITIAL,RESOURCE_GROUPS_START><<EOF>> { return 0; } diff --git a/Source/cmCTest.cxx b/Source/cmCTest.cxx index 10b7646..6eae26e 100644 --- a/Source/cmCTest.cxx +++ b/Source/cmCTest.cxx @@ -2090,12 +2090,12 @@ bool cmCTest::HandleCommandLineArguments(size_t& i, "ExcludeFixtureCleanupRegularExpression", args[i].c_str()); } - if (this->CheckArgument(arg, "--hardware-spec-file") && + if (this->CheckArgument(arg, "--resource-spec-file") && i < args.size() - 1) { i++; - this->GetTestHandler()->SetPersistentOption("HardwareSpecFile", + this->GetTestHandler()->SetPersistentOption("ResourceSpecFile", args[i].c_str()); - this->GetMemCheckHandler()->SetPersistentOption("HardwareSpecFile", + this->GetMemCheckHandler()->SetPersistentOption("ResourceSpecFile", args[i].c_str()); } diff --git a/Source/cmCoreTryCompile.cxx b/Source/cmCoreTryCompile.cxx index 910cc9d..5711cae 100644 --- a/Source/cmCoreTryCompile.cxx +++ b/Source/cmCoreTryCompile.cxx @@ -136,13 +136,19 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv, std::string copyFile; std::string copyFileError; std::string cStandard; + std::string objcStandard; std::string cxxStandard; + std::string objcxxStandard; std::string cudaStandard; std::string cStandardRequired; std::string cxxStandardRequired; + std::string objcStandardRequired; + std::string objcxxStandardRequired; std::string cudaStandardRequired; std::string cExtensions; std::string cxxExtensions; + std::string objcExtensions; + std::string objcxxExtensions; std::string cudaExtensions; std::vector<std::string> targets; std::vector<std::string> linkOptions; @@ -154,12 +160,18 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv, bool didCopyFileError = false; bool didCStandard = false; bool didCxxStandard = false; + bool didObjCStandard = false; + bool didObjCxxStandard = false; bool didCudaStandard = false; bool didCStandardRequired = false; bool didCxxStandardRequired = false; + bool didObjCStandardRequired = false; + bool didObjCxxStandardRequired = false; bool didCudaStandardRequired = false; bool didCExtensions = false; bool didCxxExtensions = false; + bool didObjCExtensions = false; + bool didObjCxxExtensions = false; bool didCudaExtensions = false; bool useSources = argv[2] == "SOURCES"; std::vector<std::string> sources; @@ -176,12 +188,18 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv, DoingCopyFileError, DoingCStandard, DoingCxxStandard, + DoingObjCStandard, + DoingObjCxxStandard, DoingCudaStandard, DoingCStandardRequired, DoingCxxStandardRequired, + DoingObjCStandardRequired, + DoingObjCxxStandardRequired, DoingCudaStandardRequired, DoingCExtensions, DoingCxxExtensions, + DoingObjCExtensions, + DoingObjCxxExtensions, DoingCudaExtensions, DoingSources, DoingCMakeInternal @@ -212,6 +230,12 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv, } else if (argv[i] == "CXX_STANDARD") { doing = DoingCxxStandard; didCxxStandard = true; + } else if (argv[i] == "OBJC_STANDARD") { + doing = DoingObjCStandard; + didObjCStandard = true; + } else if (argv[i] == "OBJCXX_STANDARD") { + doing = DoingObjCxxStandard; + didObjCxxStandard = true; } else if (argv[i] == "CUDA_STANDARD") { doing = DoingCudaStandard; didCudaStandard = true; @@ -221,6 +245,12 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv, } else if (argv[i] == "CXX_STANDARD_REQUIRED") { doing = DoingCxxStandardRequired; didCxxStandardRequired = true; + } else if (argv[i] == "OBJC_STANDARD_REQUIRED") { + doing = DoingObjCStandardRequired; + didObjCStandardRequired = true; + } else if (argv[i] == "OBJCXX_STANDARD_REQUIRED") { + doing = DoingObjCxxStandardRequired; + didObjCxxStandardRequired = true; } else if (argv[i] == "CUDA_STANDARD_REQUIRED") { doing = DoingCudaStandardRequired; didCudaStandardRequired = true; @@ -230,6 +260,12 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv, } else if (argv[i] == "CXX_EXTENSIONS") { doing = DoingCxxExtensions; didCxxExtensions = true; + } else if (argv[i] == "OBJC_EXTENSIONS") { + doing = DoingObjCExtensions; + didObjCExtensions = true; + } else if (argv[i] == "OBJCXX_EXTENSIONS") { + doing = DoingObjCxxExtensions; + didObjCxxExtensions = true; } else if (argv[i] == "CUDA_EXTENSIONS") { doing = DoingCudaExtensions; didCudaExtensions = true; @@ -285,6 +321,12 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv, } else if (doing == DoingCxxStandard) { cxxStandard = argv[i]; doing = DoingNone; + } else if (doing == DoingObjCStandard) { + objcStandard = argv[i]; + doing = DoingNone; + } else if (doing == DoingObjCxxStandard) { + objcxxStandard = argv[i]; + doing = DoingNone; } else if (doing == DoingCudaStandard) { cudaStandard = argv[i]; doing = DoingNone; @@ -294,6 +336,12 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv, } else if (doing == DoingCxxStandardRequired) { cxxStandardRequired = argv[i]; doing = DoingNone; + } else if (doing == DoingObjCStandardRequired) { + objcStandardRequired = argv[i]; + doing = DoingNone; + } else if (doing == DoingObjCxxStandardRequired) { + objcxxStandardRequired = argv[i]; + doing = DoingNone; } else if (doing == DoingCudaStandardRequired) { cudaStandardRequired = argv[i]; doing = DoingNone; @@ -303,6 +351,12 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv, } else if (doing == DoingCxxExtensions) { cxxExtensions = argv[i]; doing = DoingNone; + } else if (doing == DoingObjCExtensions) { + objcExtensions = argv[i]; + doing = DoingNone; + } else if (doing == DoingObjCxxExtensions) { + objcxxExtensions = argv[i]; + doing = DoingNone; } else if (doing == DoingCudaExtensions) { cudaExtensions = argv[i]; doing = DoingNone; @@ -754,16 +808,20 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv, fprintf(fout, ")\n"); bool const testC = testLangs.find("C") != testLangs.end(); + bool const testObjC = testLangs.find("OBJC") != testLangs.end(); bool const testCxx = testLangs.find("CXX") != testLangs.end(); + bool const testObjCxx = testLangs.find("OBJCXX") != testLangs.end(); bool const testCuda = testLangs.find("CUDA") != testLangs.end(); bool warnCMP0067 = false; bool honorStandard = true; - if (!didCStandard && !didCxxStandard && !didCudaStandard && - !didCStandardRequired && !didCxxStandardRequired && - !didCudaStandardRequired && !didCExtensions && !didCxxExtensions && - !didCudaExtensions) { + if (!didCStandard && !didCxxStandard && !didObjCStandard && + !didObjCxxStandard && !didCudaStandard && !didCStandardRequired && + !didCxxStandardRequired && !didObjCStandardRequired && + !didObjCxxStandardRequired && !didCudaStandardRequired && + !didCExtensions && !didCxxExtensions && !didObjCExtensions && + !didObjCxxExtensions && !didCudaExtensions) { switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0067)) { case cmPolicies::WARN: warnCMP0067 = this->Makefile->PolicyOptionalWarningEnabled( @@ -786,45 +844,42 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv, } if (honorStandard || warnCMP0067) { - if (testC) { - if (!didCStandard) { - cStandard = this->LookupStdVar("CMAKE_C_STANDARD", warnCMP0067); - } - if (!didCStandardRequired) { - cStandardRequired = - this->LookupStdVar("CMAKE_C_STANDARD_REQUIRED", warnCMP0067); - } - if (!didCExtensions) { - cExtensions = this->LookupStdVar("CMAKE_C_EXTENSIONS", warnCMP0067); - } - } - if (testCxx) { - if (!didCxxStandard) { - cxxStandard = this->LookupStdVar("CMAKE_CXX_STANDARD", warnCMP0067); - } - if (!didCxxStandardRequired) { - cxxStandardRequired = - this->LookupStdVar("CMAKE_CXX_STANDARD_REQUIRED", warnCMP0067); - } - if (!didCxxExtensions) { - cxxExtensions = - this->LookupStdVar("CMAKE_CXX_EXTENSIONS", warnCMP0067); - } - } - if (testCuda) { - if (!didCudaStandard) { - cudaStandard = - this->LookupStdVar("CMAKE_CUDA_STANDARD", warnCMP0067); - } - if (!didCudaStandardRequired) { - cudaStandardRequired = - this->LookupStdVar("CMAKE_CUDA_STANDARD_REQUIRED", warnCMP0067); - } - if (!didCudaExtensions) { - cudaExtensions = - this->LookupStdVar("CMAKE_CUDA_EXTENSIONS", warnCMP0067); - } - } + + auto testLanguage = + [&](bool testLang, bool didLangStandard, bool didLangStandardRequired, + bool didLangExtensions, std::string& langStandard, + std::string& langStandardRequired, std::string& langExtensions, + const std::string& lang) { + if (testLang) { + if (!didLangStandard) { + langStandard = this->LookupStdVar( + cmStrCat("CMAKE_", lang, "_STANDARD"), warnCMP0067); + } + if (!didLangStandardRequired) { + langStandardRequired = this->LookupStdVar( + cmStrCat("CMAKE_", lang, "_STANDARD_REQUIRED"), warnCMP0067); + } + if (!didLangExtensions) { + langExtensions = this->LookupStdVar( + cmStrCat("CMAKE_", lang, "_EXTENSIONS"), warnCMP0067); + } + } + }; + + testLanguage(testC, didCStandard, didCStandardRequired, didCExtensions, + cStandard, cStandardRequired, cExtensions, "C"); + testLanguage(testObjC, didObjCStandard, didObjCStandardRequired, + didObjCExtensions, objcStandard, objcStandardRequired, + objcExtensions, "OBJC"); + testLanguage(testCxx, didCxxStandard, didCxxStandardRequired, + didCxxExtensions, cxxStandard, cxxStandardRequired, + cxxExtensions, "CXX"); + testLanguage(testObjCxx, didObjCxxStandard, didObjCxxStandardRequired, + didObjCxxExtensions, objcxxStandard, objcxxStandardRequired, + objcxxExtensions, "OBJCXX"); + testLanguage(testCuda, didCudaStandard, didCudaStandardRequired, + didCudaExtensions, cudaStandard, cudaStandardRequired, + cudaExtensions, "CUDA"); } if (!this->WarnCMP0067.empty()) { @@ -841,44 +896,37 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv, this->Makefile->IssueMessage(MessageType::AUTHOR_WARNING, w.str()); } - if (testC) { - if (!cStandard.empty()) { - writeProperty(fout, targetName, "C_STANDARD", cStandard); - } - if (!cStandardRequired.empty()) { - writeProperty(fout, targetName, "C_STANDARD_REQUIRED", - cStandardRequired); - } - if (!cExtensions.empty()) { - writeProperty(fout, targetName, "C_EXTENSIONS", cExtensions); - } - } - - if (testCxx) { - if (!cxxStandard.empty()) { - writeProperty(fout, targetName, "CXX_STANDARD", cxxStandard); - } - if (!cxxStandardRequired.empty()) { - writeProperty(fout, targetName, "CXX_STANDARD_REQUIRED", - cxxStandardRequired); - } - if (!cxxExtensions.empty()) { - writeProperty(fout, targetName, "CXX_EXTENSIONS", cxxExtensions); - } - } - - if (testCuda) { - if (!cudaStandard.empty()) { - writeProperty(fout, targetName, "CUDA_STANDARD", cudaStandard); - } - if (!cudaStandardRequired.empty()) { - writeProperty(fout, targetName, "CUDA_STANDARD_REQUIRED", - cudaStandardRequired); - } - if (!cudaExtensions.empty()) { - writeProperty(fout, targetName, "CUDA_EXTENSIONS", cudaExtensions); + auto writeLanguageProperties = [&](bool testLang, + const std::string& langStandard, + const std::string& langStandardRequired, + const std::string& langExtensions, + const std::string& lang) { + if (testLang) { + if (!langStandard.empty()) { + writeProperty(fout, targetName, cmStrCat(lang, "_STANDARD"), + langStandard); + } + if (!langStandardRequired.empty()) { + writeProperty(fout, targetName, cmStrCat(lang, "_STANDARD_REQUIRED"), + langStandardRequired); + } + if (!langExtensions.empty()) { + writeProperty(fout, targetName, cmStrCat(lang, "_EXTENSIONS"), + langExtensions); + } } - } + }; + + writeLanguageProperties(testC, cStandard, cStandardRequired, cExtensions, + "C"); + writeLanguageProperties(testObjC, objcStandard, objcStandardRequired, + objcExtensions, "OBJC"); + writeLanguageProperties(testCxx, cxxStandard, cxxStandardRequired, + cxxExtensions, "CXX"); + writeLanguageProperties(testObjCxx, objcxxStandard, objcxxStandardRequired, + objcxxExtensions, "OBJCXX"); + writeLanguageProperties(testCuda, cudaStandard, cudaStandardRequired, + cudaExtensions, "CUDA"); if (!linkOptions.empty()) { std::vector<std::string> options; diff --git a/Source/cmFileAPICodemodel.cxx b/Source/cmFileAPICodemodel.cxx index 48561de..a12b3c9 100644 --- a/Source/cmFileAPICodemodel.cxx +++ b/Source/cmFileAPICodemodel.cxx @@ -875,7 +875,7 @@ CompileData Target::BuildCompileData(cmSourceFile* sf) if (!pchSource.empty() && !sf->GetProperty("SKIP_PRECOMPILE_HEADERS")) { std::string pchOptions; - if (sf->GetFullPath() == pchSource) { + if (sf->ResolveFullPath() == pchSource) { pchOptions = this->GT->GetPchCreateCompileOptions(this->Config, fd.Language); } else { diff --git a/Source/cmFindPackageCommand.cxx b/Source/cmFindPackageCommand.cxx index ea936cf..2b11b62 100644 --- a/Source/cmFindPackageCommand.cxx +++ b/Source/cmFindPackageCommand.cxx @@ -201,7 +201,13 @@ bool cmFindPackageCommand::InitialPass(std::vector<std::string> const& args) } // Check if System Package Registry should be disabled - if (this->Makefile->IsOn("CMAKE_FIND_PACKAGE_NO_SYSTEM_PACKAGE_REGISTRY")) { + // The `CMAKE_FIND_USE_SYSTEM_PACKAGE_REGISTRY` has + // priority over the deprecated CMAKE_FIND_PACKAGE_NO_SYSTEM_PACKAGE_REGISTRY + if (const char* def = this->Makefile->GetDefinition( + "CMAKE_FIND_USE_SYSTEM_PACKAGE_REGISTRY")) { + this->NoSystemRegistry = !cmIsOn(def); + } else if (this->Makefile->IsOn( + "CMAKE_FIND_PACKAGE_NO_SYSTEM_PACKAGE_REGISTRY")) { this->NoSystemRegistry = true; } diff --git a/Source/cmGeneratorTarget.cxx b/Source/cmGeneratorTarget.cxx index 949d9d9..c3ed9e8 100644 --- a/Source/cmGeneratorTarget.cxx +++ b/Source/cmGeneratorTarget.cxx @@ -3334,9 +3334,11 @@ std::vector<BT<std::string>> cmGeneratorTarget::GetPrecompileHeaders( std::string cmGeneratorTarget::GetPchHeader(const std::string& config, const std::string& language) const { - if (language != "C" && language != "CXX") { + if (language != "C" && language != "CXX" && language != "OBJC" && + language != "OBJCXX") { return std::string(); } + if (this->GetPropertyAsBool("DISABLE_PRECOMPILE_HEADERS")) { return std::string(); } @@ -3358,17 +3360,18 @@ std::string cmGeneratorTarget::GetPchHeader(const std::string& config, this->GetGlobalGenerator()->FindGeneratorTarget(pchReuseFrom); } - if (this->GetGlobalGenerator()->IsMultiConfig()) { - filename = cmStrCat( - generatorTarget->LocalGenerator->GetCurrentBinaryDirectory(), "/"); - } else { - // For GCC we need to have the header file .h[xx] - // next to the .h[xx].gch file - filename = generatorTarget->ObjectDirectory; - } + filename = cmStrCat( + generatorTarget->LocalGenerator->GetCurrentBinaryDirectory(), "/"); + + const std::map<std::string, std::string> languageToExtension = { + { "C", ".h" }, + { "CXX", ".hxx" }, + { "OBJC", ".objc.h" }, + { "OBJCXX", ".objcxx.hxx" } + }; filename = cmStrCat(filename, "CMakeFiles/", generatorTarget->GetName(), - ".dir/cmake_pch", ((language == "C") ? ".h" : ".hxx")); + ".dir/cmake_pch", languageToExtension.at(language)); const std::string filename_tmp = cmStrCat(filename, ".tmp"); if (!pchReuseFrom) { @@ -3418,7 +3421,8 @@ std::string cmGeneratorTarget::GetPchHeader(const std::string& config, std::string cmGeneratorTarget::GetPchSource(const std::string& config, const std::string& language) const { - if (language != "C" && language != "CXX") { + if (language != "C" && language != "CXX" && language != "OBJC" && + language != "OBJCXX") { return std::string(); } const auto inserted = @@ -3444,9 +3448,20 @@ std::string cmGeneratorTarget::GetPchSource(const std::string& config, // For GCC the source extension will be tranformed into .h[xx].gch if (!this->Makefile->IsOn("CMAKE_LINK_PCH")) { - filename += ((language == "C") ? ".h.c" : ".hxx.cxx"); + const std::map<std::string, std::string> languageToExtension = { + { "C", ".h.c" }, + { "CXX", ".hxx.cxx" }, + { "OBJC", ".objc.h.m" }, + { "OBJCXX", ".objcxx.hxx.mm" } + }; + + filename += languageToExtension.at(language); } else { - filename += ((language == "C") ? ".c" : ".cxx"); + const std::map<std::string, std::string> languageToExtension = { + { "C", ".c" }, { "CXX", ".cxx" }, { "OBJC", ".m" }, { "OBJCXX", ".mm" } + }; + + filename += languageToExtension.at(language); } const std::string filename_tmp = cmStrCat(filename, ".tmp"); @@ -3464,7 +3479,8 @@ std::string cmGeneratorTarget::GetPchSource(const std::string& config, std::string cmGeneratorTarget::GetPchFileObject(const std::string& config, const std::string& language) { - if (language != "C" && language != "CXX") { + if (language != "C" && language != "CXX" && language != "OBJC" && + language != "OBJCXX") { return std::string(); } const auto inserted = diff --git a/Source/cmGlobalXCodeGenerator.cxx b/Source/cmGlobalXCodeGenerator.cxx index 67f1a46..adeb065 100644 --- a/Source/cmGlobalXCodeGenerator.cxx +++ b/Source/cmGlobalXCodeGenerator.cxx @@ -776,7 +776,7 @@ public: "Xcode does not support per-config per-source " << property << ":\n" " " << expression << "\n" "specified for source:\n" - " " << this->SourceFile->GetFullPath() << "\n"; + " " << this->SourceFile->ResolveFullPath() << "\n"; /* clang-format on */ this->LocalGenerator->IssueMessage(MessageType::FATAL_ERROR, e.str()); } @@ -850,7 +850,7 @@ cmXCodeObject* cmGlobalXCodeGenerator::CreateXCodeSourceFile( lg->AppendFlags(flags, lg->GetIncludeFlags(includes, gtgt, lang, true)); cmXCodeObject* buildFile = - this->CreateXCodeSourceFileFromPath(sf->GetFullPath(), gtgt, lang, sf); + this->CreateXCodeSourceFileFromPath(sf->ResolveFullPath(), gtgt, lang, sf); cmXCodeObject* settings = this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP); settings->AddAttributeIfNotEmpty("COMPILER_FLAGS", @@ -896,7 +896,8 @@ void cmGlobalXCodeGenerator::AddXCodeProjBuildRule( std::string listfile = cmStrCat(target->GetLocalGenerator()->GetCurrentSourceDirectory(), "/CMakeLists.txt"); - cmSourceFile* srcCMakeLists = target->Makefile->GetOrCreateSource(listfile); + cmSourceFile* srcCMakeLists = target->Makefile->GetOrCreateSource( + listfile, false, cmSourceFileLocationKind::Known); if (!cmContains(sources, srcCMakeLists)) { sources.push_back(srcCMakeLists); } @@ -1029,7 +1030,7 @@ cmXCodeObject* cmGlobalXCodeGenerator::CreateXCodeFileReference( { std::string lang = this->CurrentLocalGenerator->GetSourceFileLanguage(*sf); - return this->CreateXCodeFileReferenceFromPath(sf->GetFullPath(), target, + return this->CreateXCodeFileReferenceFromPath(sf->ResolveFullPath(), target, lang, sf); } @@ -1064,7 +1065,7 @@ struct cmSourceFilePathCompare { bool operator()(cmSourceFile* l, cmSourceFile* r) { - return l->GetFullPath() < r->GetFullPath(); + return l->ResolveFullPath() < r->ResolveFullPath(); } }; @@ -1139,7 +1140,8 @@ bool cmGlobalXCodeGenerator::CreateXCodeTarget( // Add the Info.plist we are about to generate for an App Bundle. if (gtgt->GetPropertyAsBool("MACOSX_BUNDLE")) { std::string plist = this->ComputeInfoPListLocation(gtgt); - cmSourceFile* sf = gtgt->Makefile->GetOrCreateSource(plist, true); + cmSourceFile* sf = gtgt->Makefile->GetOrCreateSource( + plist, true, cmSourceFileLocationKind::Known); classes.push_back(sf); } @@ -2855,15 +2857,17 @@ bool cmGlobalXCodeGenerator::CreateGroups( std::string listfile = cmStrCat(gtgt->GetLocalGenerator()->GetCurrentSourceDirectory(), "/CMakeLists.txt"); - cmSourceFile* sf = gtgt->Makefile->GetOrCreateSource(listfile); - addSourceToGroup(sf->GetFullPath()); + cmSourceFile* sf = gtgt->Makefile->GetOrCreateSource( + listfile, false, cmSourceFileLocationKind::Known); + addSourceToGroup(sf->ResolveFullPath()); } // Add the Info.plist we are about to generate for an App Bundle. if (gtgt->GetPropertyAsBool("MACOSX_BUNDLE")) { std::string plist = this->ComputeInfoPListLocation(gtgt); - cmSourceFile* sf = gtgt->Makefile->GetOrCreateSource(plist, true); - addSourceToGroup(sf->GetFullPath()); + cmSourceFile* sf = gtgt->Makefile->GetOrCreateSource( + plist, true, cmSourceFileLocationKind::Known); + addSourceToGroup(sf->ResolveFullPath()); } } } diff --git a/Source/cmInstallTargetGenerator.cxx b/Source/cmInstallTargetGenerator.cxx index 0cd04cc..aa92fa7 100644 --- a/Source/cmInstallTargetGenerator.cxx +++ b/Source/cmInstallTargetGenerator.cxx @@ -775,7 +775,7 @@ void cmInstallTargetGenerator::AddChrpathPatchRule( if (this->Target->GetPropertyAsBool("INSTALL_REMOVE_ENVIRONMENT_RPATH")) { os << "\n" << indent << " INSTALL_REMOVE_ENVIRONMENT_RPATH)\n"; } else { - os << indent << ")\n"; + os << ")\n"; } } } diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx index a2eb1b9..827f55a 100644 --- a/Source/cmLocalGenerator.cxx +++ b/Source/cmLocalGenerator.cxx @@ -2266,7 +2266,7 @@ void cmLocalGenerator::AddPchDependencies(cmGeneratorTarget* target) std::vector<cmSourceFile*> sources; target->GetSourceFiles(sources, buildType); - for (const std::string& lang : { "C", "CXX" }) { + for (const std::string& lang : { "C", "CXX", "OBJC", "OBJCXX" }) { auto langSources = std::count_if(sources.begin(), sources.end(), [lang](cmSourceFile* sf) { return lang == sf->GetLanguage() && @@ -2441,7 +2441,6 @@ void cmLocalGenerator::AddUnityBuild(cmGeneratorTarget* target) std::back_inserter(filtered_sources), [&](cmSourceFile* sf) { return sf->GetLanguage() == lang && !sf->GetPropertyAsBool("SKIP_UNITY_BUILD_INCLUSION") && - !sf->GetPropertyAsBool("GENERATED") && !sf->GetProperty("COMPILE_OPTIONS") && !sf->GetProperty("COMPILE_DEFINITIONS") && !sf->GetProperty("COMPILE_FLAGS") && @@ -2488,7 +2487,7 @@ void cmLocalGenerator::AddUnityBuild(cmGeneratorTarget* target) file << beforeInclude << "\n"; } - file << "#include \"" << sf->GetFullPath() << "\"\n"; + file << "#include \"" << sf->ResolveFullPath() << "\"\n"; if (afterInclude) { file << afterInclude << "\n"; @@ -3124,6 +3123,14 @@ std::string cmLocalGenerator::GetObjectFileNameWithoutTarget( const char* pchExtension = source.GetProperty("PCH_EXTENSION"); if (pchExtension) { customOutputExtension = pchExtension; + + // Make sure that for the CMakeFiles/<target>.dir/cmake_pch.h|xx.c|xx + // source file, we don't end up having + // CMakeFiles/<target>.dir/CMakeFiles/<target>.dir/cmake_pch.h|xx.pch + cmsys::RegularExpression var("(CMakeFiles/[^/]+.dir/)"); + while (var.find(objectName)) { + objectName.erase(var.start(), var.end() - var.start()); + } } // Remove the source extension if it is to be replaced. diff --git a/Source/cmSourceGroupCommand.cxx b/Source/cmSourceGroupCommand.cxx index 3a13e57..cc62952 100644 --- a/Source/cmSourceGroupCommand.cxx +++ b/Source/cmSourceGroupCommand.cxx @@ -78,10 +78,18 @@ std::vector<std::string> prepareFilesPathsForTree( for (auto const& filePath : filesPaths) { std::string fullPath = cmSystemTools::CollapseFullPath(filePath, currentSourceDir); - // If provided file path is actually not a file, silently ignore it. - if (cmSystemTools::FileExists(fullPath, /*isFile=*/true)) { - prepared.emplace_back(std::move(fullPath)); + // If provided file path is actually not a directory, silently ignore it. + if (cmSystemTools::FileIsDirectory(fullPath)) { + continue; } + + // Handle directory that doesn't exist yet. + if (!fullPath.empty() && + (fullPath.back() == '/' || fullPath.back() == '\\')) { + continue; + } + + prepared.emplace_back(std::move(fullPath)); } return prepared; diff --git a/Source/cmSystemTools.cxx b/Source/cmSystemTools.cxx index a50e829..c4a4220 100644 --- a/Source/cmSystemTools.cxx +++ b/Source/cmSystemTools.cxx @@ -1120,8 +1120,13 @@ std::string cmSystemTools::ForceToRelativePath(std::string const& local_path, assert(local_path.front() != '\"'); assert(remote_path.front() != '\"'); - // The local path should never have a trailing slash. - assert(local_path.empty() || local_path.back() != '/'); + // The local path should never have a trailing slash except if it is just the + // bare root directory + assert(local_path.empty() || local_path.back() != '/' || + local_path.size() == 1 || + (local_path.size() == 3 && local_path[1] == ':' && + ((local_path[0] >= 'A' && local_path[0] <= 'Z') || + (local_path[0] >= 'a' && local_path[0] <= 'z')))); // If the path is already relative then just return the path. if (!cmSystemTools::FileIsFullPath(remote_path)) { diff --git a/Source/ctest.cxx b/Source/ctest.cxx index 91ee598..0d65902 100644 --- a/Source/ctest.cxx +++ b/Source/ctest.cxx @@ -103,7 +103,7 @@ static const char* cmDocumentationOptions[][2] = { "times without failing in order to pass" }, { "--max-width <width>", "Set the max width for a test name to output" }, { "--interactive-debug-mode [0|1]", "Set the interactive mode to 0 or 1." }, - { "--hardware-spec-file <file>", "Set the hardware spec file to use." }, + { "--resource-spec-file <file>", "Set the resource spec file to use." }, { "--no-label-summary", "Disable timing summary information for labels." }, { "--no-subproject-summary", "Disable timing summary information for " |