| /* Distributed under the OSI-approved BSD 3-Clause License. See accompanying |
| file Copyright.txt or https://cmake.org/licensing for details. */ |
| #include "cmGlobalUnixMakefileGenerator3.h" |
| |
| #include <algorithm> |
| #include <functional> |
| #include <sstream> |
| #include <utility> |
| |
| #include <cm/memory> |
| #include <cmext/algorithm> |
| #include <cmext/memory> |
| |
| #include "cmDocumentationEntry.h" |
| #include "cmGeneratedFileStream.h" |
| #include "cmGeneratorTarget.h" |
| #include "cmGlobalGenerator.h" |
| #include "cmLocalGenerator.h" |
| #include "cmLocalUnixMakefileGenerator3.h" |
| #include "cmMakefile.h" |
| #include "cmMakefileTargetGenerator.h" |
| #include "cmOutputConverter.h" |
| #include "cmProperty.h" |
| #include "cmState.h" |
| #include "cmStateDirectory.h" |
| #include "cmStateTypes.h" |
| #include "cmStringAlgorithms.h" |
| #include "cmSystemTools.h" |
| #include "cmTargetDepend.h" |
| #include "cmake.h" |
| |
| cmGlobalUnixMakefileGenerator3::cmGlobalUnixMakefileGenerator3(cmake* cm) |
| : cmGlobalCommonGenerator(cm) |
| { |
| // This type of makefile always requires unix style paths |
| this->ForceUnixPaths = true; |
| this->FindMakeProgramFile = "CMakeUnixFindMake.cmake"; |
| this->ToolSupportsColor = true; |
| |
| #if defined(_WIN32) || defined(__VMS) |
| this->UseLinkScript = false; |
| #else |
| this->UseLinkScript = true; |
| #endif |
| |
| this->IncludeDirective = "include"; |
| this->DefineWindowsNULL = false; |
| this->PassMakeflags = false; |
| this->UnixCD = true; |
| } |
| |
| cmGlobalUnixMakefileGenerator3::~cmGlobalUnixMakefileGenerator3() = default; |
| |
| void cmGlobalUnixMakefileGenerator3::EnableLanguage( |
| std::vector<std::string> const& languages, cmMakefile* mf, bool optional) |
| { |
| this->cmGlobalGenerator::EnableLanguage(languages, mf, optional); |
| for (std::string const& language : languages) { |
| if (language == "NONE") { |
| continue; |
| } |
| this->ResolveLanguageCompiler(language, mf, optional); |
| } |
| } |
| |
| //! Create a local generator appropriate to this Global Generator |
| std::unique_ptr<cmLocalGenerator> |
| cmGlobalUnixMakefileGenerator3::CreateLocalGenerator(cmMakefile* mf) |
| { |
| return std::unique_ptr<cmLocalGenerator>( |
| cm::make_unique<cmLocalUnixMakefileGenerator3>(this, mf)); |
| } |
| |
| void cmGlobalUnixMakefileGenerator3::GetDocumentation( |
| cmDocumentationEntry& entry) |
| { |
| entry.Name = cmGlobalUnixMakefileGenerator3::GetActualName(); |
| entry.Brief = "Generates standard UNIX makefiles."; |
| } |
| |
| std::string cmGlobalUnixMakefileGenerator3::GetEditCacheCommand() const |
| { |
| // If generating for an extra IDE, the edit_cache target cannot |
| // launch a terminal-interactive tool, so always use cmake-gui. |
| if (!this->GetExtraGeneratorName().empty()) { |
| return cmSystemTools::GetCMakeGUICommand(); |
| } |
| |
| // Use an internal cache entry to track the latest dialog used |
| // to edit the cache, and use that for the edit_cache target. |
| cmake* cm = this->GetCMakeInstance(); |
| std::string editCacheCommand = cm->GetCMakeEditCommand(); |
| if (!cm->GetCacheDefinition("CMAKE_EDIT_COMMAND") || |
| !editCacheCommand.empty()) { |
| if (editCacheCommand.empty()) { |
| editCacheCommand = cmSystemTools::GetCMakeCursesCommand(); |
| } |
| if (editCacheCommand.empty()) { |
| editCacheCommand = cmSystemTools::GetCMakeGUICommand(); |
| } |
| if (!editCacheCommand.empty()) { |
| cm->AddCacheEntry("CMAKE_EDIT_COMMAND", editCacheCommand.c_str(), |
| "Path to cache edit program executable.", |
| cmStateEnums::INTERNAL); |
| } |
| } |
| const char* edit_cmd = cm->GetCacheDefinition("CMAKE_EDIT_COMMAND"); |
| return edit_cmd ? edit_cmd : ""; |
| } |
| |
| void cmGlobalUnixMakefileGenerator3::ComputeTargetObjectDirectory( |
| cmGeneratorTarget* gt) const |
| { |
| // Compute full path to object file directory for this target. |
| std::string dir = |
| cmStrCat(gt->LocalGenerator->GetCurrentBinaryDirectory(), '/', |
| gt->LocalGenerator->GetTargetDirectory(gt), '/'); |
| gt->ObjectDirectory = dir; |
| } |
| |
| bool cmGlobalUnixMakefileGenerator3::CanEscapeOctothorpe() const |
| { |
| // Make tools that use UNIX-style '/' paths also support '\' escaping. |
| return this->ForceUnixPaths; |
| } |
| |
| void cmGlobalUnixMakefileGenerator3::Configure() |
| { |
| // Initialize CMAKE_EDIT_COMMAND cache entry. |
| this->GetEditCacheCommand(); |
| |
| this->cmGlobalGenerator::Configure(); |
| } |
| |
| void cmGlobalUnixMakefileGenerator3::Generate() |
| { |
| // first do superclass method |
| this->cmGlobalGenerator::Generate(); |
| |
| // initialize progress |
| unsigned long total = 0; |
| for (auto const& pmi : this->ProgressMap) { |
| total += pmi.second.NumberOfActions; |
| } |
| |
| // write each target's progress.make this loop is done twice. Basically the |
| // Generate pass counts all the actions, the first loop below determines |
| // how many actions have progress updates for each target and writes to |
| // corrrect variable values for everything except the all targets. The |
| // second loop actually writes out correct values for the all targets as |
| // well. This is because the all targets require more information that is |
| // computed in the first loop. |
| unsigned long current = 0; |
| for (auto& pmi : this->ProgressMap) { |
| pmi.second.WriteProgressVariables(total, current); |
| } |
| for (const auto& lg : this->LocalGenerators) { |
| std::string markFileName = |
| cmStrCat(lg->GetCurrentBinaryDirectory(), "/CMakeFiles/progress.marks"); |
| cmGeneratedFileStream markFile(markFileName); |
| markFile << this->CountProgressMarksInAll(*lg) << "\n"; |
| } |
| |
| // write the main makefile |
| this->WriteMainMakefile2(); |
| this->WriteMainCMakefile(); |
| |
| if (this->CommandDatabase) { |
| *this->CommandDatabase << "\n]"; |
| this->CommandDatabase.reset(); |
| } |
| } |
| |
| void cmGlobalUnixMakefileGenerator3::AddCXXCompileCommand( |
| const std::string& sourceFile, const std::string& workingDirectory, |
| const std::string& compileCommand) |
| { |
| if (!this->CommandDatabase) { |
| std::string commandDatabaseName = |
| this->GetCMakeInstance()->GetHomeOutputDirectory() + |
| "/compile_commands.json"; |
| this->CommandDatabase = |
| cm::make_unique<cmGeneratedFileStream>(commandDatabaseName); |
| *this->CommandDatabase << "[\n"; |
| } else { |
| *this->CommandDatabase << ",\n"; |
| } |
| *this->CommandDatabase << "{\n" |
| << R"( "directory": ")" |
| << cmGlobalGenerator::EscapeJSON(workingDirectory) |
| << "\",\n" |
| << R"( "command": ")" |
| << cmGlobalGenerator::EscapeJSON(compileCommand) |
| << "\",\n" |
| << R"( "file": ")" |
| << cmGlobalGenerator::EscapeJSON(sourceFile) |
| << "\"\n}"; |
| } |
| |
| void cmGlobalUnixMakefileGenerator3::WriteMainMakefile2() |
| { |
| // Open the output file. This should not be copy-if-different |
| // because the check-build-system step compares the makefile time to |
| // see if the build system must be regenerated. |
| std::string makefileName = |
| cmStrCat(this->GetCMakeInstance()->GetHomeOutputDirectory(), |
| "/CMakeFiles/Makefile2"); |
| cmGeneratedFileStream makefileStream(makefileName, false, |
| this->GetMakefileEncoding()); |
| if (!makefileStream) { |
| return; |
| } |
| |
| // get a local generator for some useful methods |
| auto& lg = cm::static_reference_cast<cmLocalUnixMakefileGenerator3>( |
| this->LocalGenerators[0]); |
| |
| // Write the do not edit header. |
| lg.WriteDisclaimer(makefileStream); |
| |
| // Write the main entry point target. This must be the VERY first |
| // target so that make with no arguments will run it. |
| // Just depend on the all target to drive the build. |
| std::vector<std::string> depends; |
| std::vector<std::string> no_commands; |
| depends.emplace_back("all"); |
| |
| // Write the rule. |
| lg.WriteMakeRule(makefileStream, |
| "Default target executed when no arguments are " |
| "given to make.", |
| "default_target", depends, no_commands, true); |
| |
| depends.clear(); |
| |
| // The all and preinstall rules might never have any dependencies |
| // added to them. |
| if (!this->EmptyRuleHackDepends.empty()) { |
| depends.push_back(this->EmptyRuleHackDepends); |
| } |
| |
| // Write out the "special" stuff |
| lg.WriteSpecialTargetsTop(makefileStream); |
| |
| // Write the directory level rules. |
| for (auto const& it : this->ComputeDirectoryTargets()) { |
| this->WriteDirectoryRules2(makefileStream, it.second); |
| } |
| |
| // Write the target convenience rules |
| for (const auto& localGen : this->LocalGenerators) { |
| this->WriteConvenienceRules2( |
| makefileStream, |
| cm::static_reference_cast<cmLocalUnixMakefileGenerator3>(localGen)); |
| } |
| |
| // Write special bottom targets |
| lg.WriteSpecialTargetsBottom(makefileStream); |
| } |
| |
| void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile() |
| { |
| if (this->GlobalSettingIsOn("CMAKE_SUPPRESS_REGENERATION")) { |
| return; |
| } |
| |
| // Open the output file. This should not be copy-if-different |
| // because the check-build-system step compares the makefile time to |
| // see if the build system must be regenerated. |
| std::string cmakefileName = |
| cmStrCat(this->GetCMakeInstance()->GetHomeOutputDirectory(), |
| "/CMakeFiles/Makefile.cmake"); |
| cmGeneratedFileStream cmakefileStream(cmakefileName); |
| if (!cmakefileStream) { |
| return; |
| } |
| |
| std::string makefileName = |
| cmStrCat(this->GetCMakeInstance()->GetHomeOutputDirectory(), "/Makefile"); |
| |
| { |
| // get a local generator for some useful methods |
| auto& lg = cm::static_reference_cast<cmLocalUnixMakefileGenerator3>( |
| this->LocalGenerators[0]); |
| |
| // Write the do not edit header. |
| lg.WriteDisclaimer(cmakefileStream); |
| } |
| |
| // Save the generator name |
| cmakefileStream << "# The generator used is:\n" |
| << "set(CMAKE_DEPENDS_GENERATOR \"" << this->GetName() |
| << "\")\n\n"; |
| |
| // for each cmMakefile get its list of dependencies |
| std::vector<std::string> lfiles; |
| for (const auto& localGen : this->LocalGenerators) { |
| // Get the list of files contributing to this generation step. |
| cm::append(lfiles, localGen->GetMakefile()->GetListFiles()); |
| } |
| |
| cmake* cm = this->GetCMakeInstance(); |
| if (cm->DoWriteGlobVerifyTarget()) { |
| lfiles.push_back(cm->GetGlobVerifyScript()); |
| lfiles.push_back(cm->GetGlobVerifyStamp()); |
| } |
| |
| // Sort the list and remove duplicates. |
| std::sort(lfiles.begin(), lfiles.end(), std::less<std::string>()); |
| #if !defined(__VMS) // The Compaq STL on VMS crashes, so accept duplicates. |
| auto new_end = std::unique(lfiles.begin(), lfiles.end()); |
| lfiles.erase(new_end, lfiles.end()); |
| #endif |
| |
| { |
| // reset lg to the first makefile |
| const auto& lg = cm::static_reference_cast<cmLocalUnixMakefileGenerator3>( |
| this->LocalGenerators[0]); |
| |
| const std::string& currentBinDir = lg.GetCurrentBinaryDirectory(); |
| // Save the list to the cmake file. |
| cmakefileStream |
| << "# The top level Makefile was generated from the following files:\n" |
| << "set(CMAKE_MAKEFILE_DEPENDS\n" |
| << " \"CMakeCache.txt\"\n"; |
| for (std::string const& f : lfiles) { |
| cmakefileStream << " \"" |
| << lg.MaybeConvertToRelativePath(currentBinDir, f) |
| << "\"\n"; |
| } |
| cmakefileStream << " )\n\n"; |
| |
| // Build the path to the cache check file. |
| std::string check = |
| cmStrCat(this->GetCMakeInstance()->GetHomeOutputDirectory(), |
| "/CMakeFiles/cmake.check_cache"); |
| |
| // Set the corresponding makefile in the cmake file. |
| cmakefileStream << "# The corresponding makefile is:\n" |
| << "set(CMAKE_MAKEFILE_OUTPUTS\n" |
| << " \"" |
| << lg.MaybeConvertToRelativePath(currentBinDir, |
| makefileName) |
| << "\"\n" |
| << " \"" |
| << lg.MaybeConvertToRelativePath(currentBinDir, check) |
| << "\"\n"; |
| cmakefileStream << " )\n\n"; |
| |
| const std::string& binDir = lg.GetBinaryDirectory(); |
| |
| // CMake must rerun if a byproduct is missing. |
| cmakefileStream << "# Byproducts of CMake generate step:\n" |
| << "set(CMAKE_MAKEFILE_PRODUCTS\n"; |
| |
| // add in any byproducts and all the directory information files |
| std::string tmpStr; |
| for (const auto& localGen : this->LocalGenerators) { |
| for (std::string const& outfile : |
| localGen->GetMakefile()->GetOutputFiles()) { |
| cmakefileStream << " \"" |
| << lg.MaybeConvertToRelativePath(binDir, outfile) |
| << "\"\n"; |
| } |
| tmpStr = cmStrCat(localGen->GetCurrentBinaryDirectory(), |
| "/CMakeFiles/CMakeDirectoryInformation.cmake"); |
| cmakefileStream << " \"" |
| << localGen->MaybeConvertToRelativePath(binDir, tmpStr) |
| << "\"\n"; |
| } |
| cmakefileStream << " )\n\n"; |
| } |
| |
| this->WriteMainCMakefileLanguageRules(cmakefileStream, |
| this->LocalGenerators); |
| } |
| |
| void cmGlobalUnixMakefileGenerator3::WriteMainCMakefileLanguageRules( |
| cmGeneratedFileStream& cmakefileStream, |
| std::vector<std::unique_ptr<cmLocalGenerator>>& lGenerators) |
| { |
| // now list all the target info files |
| cmakefileStream << "# Dependency information for all targets:\n"; |
| cmakefileStream << "set(CMAKE_DEPEND_INFO_FILES\n"; |
| for (const auto& lGenerator : lGenerators) { |
| const auto& lg = |
| cm::static_reference_cast<cmLocalUnixMakefileGenerator3>(lGenerator); |
| // for all of out targets |
| for (const auto& tgt : lg.GetGeneratorTargets()) { |
| if ((tgt->GetType() == cmStateEnums::EXECUTABLE) || |
| (tgt->GetType() == cmStateEnums::STATIC_LIBRARY) || |
| (tgt->GetType() == cmStateEnums::SHARED_LIBRARY) || |
| (tgt->GetType() == cmStateEnums::MODULE_LIBRARY) || |
| (tgt->GetType() == cmStateEnums::OBJECT_LIBRARY) || |
| (tgt->GetType() == cmStateEnums::UTILITY)) { |
| std::string tname = cmStrCat(lg.GetRelativeTargetDirectory(tgt.get()), |
| "/DependInfo.cmake"); |
| cmSystemTools::ConvertToUnixSlashes(tname); |
| cmakefileStream << " \"" << tname << "\"\n"; |
| } |
| } |
| } |
| cmakefileStream << " )\n"; |
| } |
| |
| void cmGlobalUnixMakefileGenerator3::WriteDirectoryRule2( |
| std::ostream& ruleFileStream, DirectoryTarget const& dt, const char* pass, |
| bool check_all, bool check_relink, std::vector<std::string> const& commands) |
| { |
| auto* lg = static_cast<cmLocalUnixMakefileGenerator3*>(dt.LG); |
| std::string makeTarget = |
| cmStrCat(lg->GetCurrentBinaryDirectory(), '/', pass); |
| |
| // The directory-level rule should depend on the target-level rules |
| // for all targets in the directory. |
| std::vector<std::string> depends; |
| for (DirectoryTarget::Target const& t : dt.Targets) { |
| // Add this to the list of depends rules in this directory. |
| if ((!check_all || t.ExcludedFromAllInConfigs.empty()) && |
| (!check_relink || |
| t.GT->NeedRelinkBeforeInstall(lg->GetConfigName()))) { |
| // The target may be from a different directory; use its local gen. |
| auto const* tlg = static_cast<cmLocalUnixMakefileGenerator3 const*>( |
| t.GT->GetLocalGenerator()); |
| std::string tname = |
| cmStrCat(tlg->GetRelativeTargetDirectory(t.GT), '/', pass); |
| depends.push_back(std::move(tname)); |
| } |
| } |
| |
| // The directory-level rule should depend on the directory-level |
| // rules of the subdirectories. |
| for (DirectoryTarget::Dir const& d : dt.Children) { |
| if (check_all && d.ExcludeFromAll) { |
| continue; |
| } |
| std::string subdir = cmStrCat(d.Path, '/', pass); |
| depends.push_back(std::move(subdir)); |
| } |
| |
| // Work-around for makes that drop rules that have no dependencies |
| // or commands. |
| if (depends.empty() && !this->EmptyRuleHackDepends.empty()) { |
| depends.push_back(this->EmptyRuleHackDepends); |
| } |
| |
| // Write the rule. |
| std::string doc; |
| if (lg->IsRootMakefile()) { |
| doc = cmStrCat("The main recursive \"", pass, "\" target."); |
| } else { |
| doc = cmStrCat("Recursive \"", pass, "\" directory target."); |
| } |
| lg->WriteMakeRule(ruleFileStream, doc.c_str(), makeTarget, depends, commands, |
| true); |
| } |
| |
| void cmGlobalUnixMakefileGenerator3::WriteDirectoryRules2( |
| std::ostream& ruleFileStream, DirectoryTarget const& dt) |
| { |
| auto* lg = static_cast<cmLocalUnixMakefileGenerator3*>(dt.LG); |
| // Begin the directory-level rules section. |
| { |
| std::string dir = |
| cmSystemTools::ConvertToOutputPath(lg->MaybeConvertToRelativePath( |
| lg->GetBinaryDirectory(), lg->GetCurrentBinaryDirectory())); |
| lg->WriteDivider(ruleFileStream); |
| if (lg->IsRootMakefile()) { |
| ruleFileStream << "# Directory level rules for the build root directory"; |
| } else { |
| ruleFileStream << "# Directory level rules for directory " << dir; |
| } |
| ruleFileStream << "\n\n"; |
| } |
| |
| // Write directory-level rules for "all". |
| this->WriteDirectoryRule2(ruleFileStream, dt, "all", true, false); |
| |
| // Write directory-level rules for "preinstall". |
| this->WriteDirectoryRule2(ruleFileStream, dt, "preinstall", true, true); |
| |
| // Write directory-level rules for "clean". |
| { |
| std::vector<std::string> cmds; |
| lg->AppendDirectoryCleanCommand(cmds); |
| this->WriteDirectoryRule2(ruleFileStream, dt, "clean", false, false, cmds); |
| } |
| } |
| |
| namespace { |
| std::string ConvertToMakefilePathForUnix(std::string const& path) |
| { |
| std::string result; |
| result.reserve(path.size()); |
| for (char c : path) { |
| switch (c) { |
| case '=': |
| // We provide 'EQUALS = =' to encode '=' in a non-assignment case. |
| result.append("$(EQUALS)"); |
| break; |
| case '$': |
| result.append("$$"); |
| break; |
| case '\\': |
| case ' ': |
| case '#': |
| result.push_back('\\'); |
| CM_FALLTHROUGH; |
| default: |
| result.push_back(c); |
| break; |
| } |
| } |
| return result; |
| } |
| |
| #if defined(_WIN32) && !defined(__CYGWIN__) |
| std::string ConvertToMakefilePathForWindows(std::string const& path) |
| { |
| bool const quote = path.find_first_of(" #") != std::string::npos; |
| std::string result; |
| result.reserve(path.size() + (quote ? 2 : 0)); |
| if (quote) { |
| result.push_back('"'); |
| } |
| for (char c : path) { |
| switch (c) { |
| case '=': |
| // We provide 'EQUALS = =' to encode '=' in a non-assignment case. |
| result.append("$(EQUALS)"); |
| break; |
| case '$': |
| result.append("$$"); |
| break; |
| case '/': |
| result.push_back('\\'); |
| break; |
| default: |
| result.push_back(c); |
| break; |
| } |
| } |
| if (quote) { |
| result.push_back('"'); |
| } |
| return result; |
| } |
| #endif |
| } |
| |
| std::string cmGlobalUnixMakefileGenerator3::ConvertToMakefilePath( |
| std::string const& path) const |
| { |
| #if defined(_WIN32) && !defined(__CYGWIN__) |
| if (!this->ForceUnixPaths) { |
| return ConvertToMakefilePathForWindows(path); |
| } |
| #endif |
| return ConvertToMakefilePathForUnix(path); |
| } |
| |
| std::vector<cmGlobalGenerator::GeneratedMakeCommand> |
| cmGlobalUnixMakefileGenerator3::GenerateBuildCommand( |
| const std::string& makeProgram, const std::string& /*projectName*/, |
| const std::string& /*projectDir*/, |
| std::vector<std::string> const& targetNames, const std::string& /*config*/, |
| bool fast, int jobs, bool verbose, |
| std::vector<std::string> const& makeOptions) |
| { |
| std::unique_ptr<cmMakefile> mfu; |
| cmMakefile* mf; |
| if (!this->Makefiles.empty()) { |
| mf = this->Makefiles[0].get(); |
| } else { |
| cmStateSnapshot snapshot = this->CMakeInstance->GetCurrentSnapshot(); |
| snapshot.GetDirectory().SetCurrentSource( |
| this->CMakeInstance->GetHomeDirectory()); |
| snapshot.GetDirectory().SetCurrentBinary( |
| this->CMakeInstance->GetHomeOutputDirectory()); |
| snapshot.SetDefaultDefinitions(); |
| mfu = cm::make_unique<cmMakefile>(this, snapshot); |
| mf = mfu.get(); |
| } |
| |
| GeneratedMakeCommand makeCommand; |
| |
| // Make it possible to set verbosity also from command line |
| if (verbose) { |
| makeCommand.Add(cmSystemTools::GetCMakeCommand()); |
| makeCommand.Add("-E"); |
| makeCommand.Add("env"); |
| makeCommand.Add("VERBOSE=1"); |
| } |
| makeCommand.Add(this->SelectMakeProgram(makeProgram)); |
| |
| if (jobs != cmake::NO_BUILD_PARALLEL_LEVEL) { |
| makeCommand.Add("-j"); |
| if (jobs != cmake::DEFAULT_BUILD_PARALLEL_LEVEL) { |
| makeCommand.Add(std::to_string(jobs)); |
| } |
| } |
| |
| makeCommand.Add(makeOptions.begin(), makeOptions.end()); |
| for (auto tname : targetNames) { |
| if (!tname.empty()) { |
| if (fast) { |
| tname += "/fast"; |
| } |
| tname = |
| mf->GetStateSnapshot().GetDirectory().ConvertToRelPathIfNotContained( |
| mf->GetState()->GetBinaryDirectory(), tname); |
| cmSystemTools::ConvertToOutputSlashes(tname); |
| makeCommand.Add(std::move(tname)); |
| } |
| } |
| return { std::move(makeCommand) }; |
| } |
| |
| void cmGlobalUnixMakefileGenerator3::WriteConvenienceRules( |
| std::ostream& ruleFileStream, std::set<std::string>& emitted) |
| { |
| std::vector<std::string> depends; |
| std::vector<std::string> commands; |
| |
| bool regenerate = !this->GlobalSettingIsOn("CMAKE_SUPPRESS_REGENERATION"); |
| if (regenerate) { |
| depends.emplace_back("cmake_check_build_system"); |
| } |
| |
| // write the target convenience rules |
| for (const auto& localGen : this->LocalGenerators) { |
| auto& lg = |
| cm::static_reference_cast<cmLocalUnixMakefileGenerator3>(localGen); |
| // for each target Generate the rule files for each target. |
| for (const auto& gtarget : lg.GetGeneratorTargets()) { |
| // Don't emit the same rule twice (e.g. two targets with the same |
| // simple name) |
| int type = gtarget->GetType(); |
| std::string name = gtarget->GetName(); |
| if (!name.empty() && emitted.insert(name).second && |
| // Handle user targets here. Global targets are handled in |
| // the local generator on a per-directory basis. |
| ((type == cmStateEnums::EXECUTABLE) || |
| (type == cmStateEnums::STATIC_LIBRARY) || |
| (type == cmStateEnums::SHARED_LIBRARY) || |
| (type == cmStateEnums::MODULE_LIBRARY) || |
| (type == cmStateEnums::OBJECT_LIBRARY) || |
| (type == cmStateEnums::UTILITY))) { |
| // Add a rule to build the target by name. |
| lg.WriteDivider(ruleFileStream); |
| ruleFileStream << "# Target rules for targets named " << name |
| << "\n\n"; |
| |
| // Write the rule. |
| commands.clear(); |
| std::string tmp = "CMakeFiles/Makefile2"; |
| commands.push_back(lg.GetRecursiveMakeCall(tmp, name)); |
| depends.clear(); |
| if (regenerate) { |
| depends.emplace_back("cmake_check_build_system"); |
| } |
| lg.WriteMakeRule(ruleFileStream, "Build rule for target.", name, |
| depends, commands, true); |
| |
| // Add a fast rule to build the target |
| std::string localName = lg.GetRelativeTargetDirectory(gtarget.get()); |
| std::string makefileName; |
| makefileName = cmStrCat(localName, "/build.make"); |
| depends.clear(); |
| commands.clear(); |
| std::string makeTargetName = cmStrCat(localName, "/build"); |
| localName = cmStrCat(name, "/fast"); |
| commands.push_back( |
| lg.GetRecursiveMakeCall(makefileName, makeTargetName)); |
| lg.WriteMakeRule(ruleFileStream, "fast build rule for target.", |
| localName, depends, commands, true); |
| |
| // Add a local name for the rule to relink the target before |
| // installation. |
| if (gtarget->NeedRelinkBeforeInstall(lg.GetConfigName())) { |
| makeTargetName = cmStrCat( |
| lg.GetRelativeTargetDirectory(gtarget.get()), "/preinstall"); |
| localName = cmStrCat(name, "/preinstall"); |
| depends.clear(); |
| commands.clear(); |
| commands.push_back( |
| lg.GetRecursiveMakeCall(makefileName, makeTargetName)); |
| lg.WriteMakeRule(ruleFileStream, |
| "Manual pre-install relink rule for target.", |
| localName, depends, commands, true); |
| } |
| } |
| } |
| } |
| } |
| |
| void cmGlobalUnixMakefileGenerator3::WriteConvenienceRules2( |
| std::ostream& ruleFileStream, cmLocalUnixMakefileGenerator3& lg) |
| { |
| std::vector<std::string> depends; |
| std::vector<std::string> commands; |
| std::string localName; |
| std::string makeTargetName; |
| |
| bool regenerate = !this->GlobalSettingIsOn("CMAKE_SUPPRESS_REGENERATION"); |
| if (regenerate) { |
| depends.emplace_back("cmake_check_build_system"); |
| } |
| |
| // for each target Generate the rule files for each target. |
| for (const auto& gtarget : lg.GetGeneratorTargets()) { |
| int type = gtarget->GetType(); |
| std::string name = gtarget->GetName(); |
| if (!name.empty() && |
| ((type == cmStateEnums::EXECUTABLE) || |
| (type == cmStateEnums::STATIC_LIBRARY) || |
| (type == cmStateEnums::SHARED_LIBRARY) || |
| (type == cmStateEnums::MODULE_LIBRARY) || |
| (type == cmStateEnums::OBJECT_LIBRARY) || |
| (type == cmStateEnums::UTILITY))) { |
| std::string makefileName; |
| // Add a rule to build the target by name. |
| localName = lg.GetRelativeTargetDirectory(gtarget.get()); |
| makefileName = cmStrCat(localName, "/build.make"); |
| |
| lg.WriteDivider(ruleFileStream); |
| ruleFileStream << "# Target rules for target " << localName << "\n\n"; |
| |
| commands.clear(); |
| makeTargetName = cmStrCat(localName, "/depend"); |
| commands.push_back( |
| lg.GetRecursiveMakeCall(makefileName, makeTargetName)); |
| |
| makeTargetName = cmStrCat(localName, "/build"); |
| commands.push_back( |
| lg.GetRecursiveMakeCall(makefileName, makeTargetName)); |
| |
| // Write the rule. |
| localName += "/all"; |
| depends.clear(); |
| |
| cmLocalUnixMakefileGenerator3::EchoProgress progress; |
| progress.Dir = cmStrCat(lg.GetBinaryDirectory(), "/CMakeFiles"); |
| { |
| std::ostringstream progressArg; |
| const char* sep = ""; |
| for (unsigned long progFile : this->ProgressMap[gtarget.get()].Marks) { |
| progressArg << sep << progFile; |
| sep = ","; |
| } |
| progress.Arg = progressArg.str(); |
| } |
| |
| bool targetMessages = true; |
| if (cmProp tgtMsg = |
| this->GetCMakeInstance()->GetState()->GetGlobalProperty( |
| "TARGET_MESSAGES")) { |
| targetMessages = cmIsOn(*tgtMsg); |
| } |
| |
| if (targetMessages) { |
| lg.AppendEcho(commands, "Built target " + name, |
| cmLocalUnixMakefileGenerator3::EchoNormal, &progress); |
| } |
| |
| this->AppendGlobalTargetDepends(depends, gtarget.get()); |
| lg.WriteMakeRule(ruleFileStream, "All Build rule for target.", localName, |
| depends, commands, true); |
| |
| // Write the rule. |
| commands.clear(); |
| |
| { |
| // TODO: Convert the total progress count to a make variable. |
| std::ostringstream progCmd; |
| progCmd << "$(CMAKE_COMMAND) -E cmake_progress_start "; |
| // # in target |
| progCmd << lg.ConvertToOutputFormat(progress.Dir, |
| cmOutputConverter::SHELL); |
| // |
| std::set<cmGeneratorTarget const*> emitted; |
| progCmd << " " |
| << this->CountProgressMarksInTarget(gtarget.get(), emitted); |
| commands.push_back(progCmd.str()); |
| } |
| std::string tmp = "CMakeFiles/Makefile2"; |
| commands.push_back(lg.GetRecursiveMakeCall(tmp, localName)); |
| { |
| std::ostringstream progCmd; |
| progCmd << "$(CMAKE_COMMAND) -E cmake_progress_start "; // # 0 |
| progCmd << lg.ConvertToOutputFormat(progress.Dir, |
| cmOutputConverter::SHELL); |
| progCmd << " 0"; |
| commands.push_back(progCmd.str()); |
| } |
| depends.clear(); |
| if (regenerate) { |
| depends.emplace_back("cmake_check_build_system"); |
| } |
| localName = |
| cmStrCat(lg.GetRelativeTargetDirectory(gtarget.get()), "/rule"); |
| lg.WriteMakeRule(ruleFileStream, |
| "Build rule for subdir invocation for target.", |
| localName, depends, commands, true); |
| |
| // Add a target with the canonical name (no prefix, suffix or path). |
| commands.clear(); |
| depends.clear(); |
| depends.push_back(localName); |
| lg.WriteMakeRule(ruleFileStream, "Convenience name for target.", name, |
| depends, commands, true); |
| |
| // Add rules to prepare the target for installation. |
| if (gtarget->NeedRelinkBeforeInstall(lg.GetConfigName())) { |
| localName = cmStrCat(lg.GetRelativeTargetDirectory(gtarget.get()), |
| "/preinstall"); |
| depends.clear(); |
| commands.clear(); |
| commands.push_back(lg.GetRecursiveMakeCall(makefileName, localName)); |
| lg.WriteMakeRule(ruleFileStream, "Pre-install relink rule for target.", |
| localName, depends, commands, true); |
| } |
| |
| // add the clean rule |
| localName = lg.GetRelativeTargetDirectory(gtarget.get()); |
| makeTargetName = cmStrCat(localName, "/clean"); |
| depends.clear(); |
| commands.clear(); |
| commands.push_back( |
| lg.GetRecursiveMakeCall(makefileName, makeTargetName)); |
| lg.WriteMakeRule(ruleFileStream, "clean rule for target.", |
| makeTargetName, depends, commands, true); |
| commands.clear(); |
| } |
| } |
| } |
| |
| // Build a map that contains the set of targets used by each local |
| // generator directory level. |
| void cmGlobalUnixMakefileGenerator3::InitializeProgressMarks() |
| { |
| this->DirectoryTargetsMap.clear(); |
| // Loop over all targets in all local generators. |
| for (const auto& lg : this->LocalGenerators) { |
| for (const auto& gt : lg->GetGeneratorTargets()) { |
| cmLocalGenerator* tlg = gt->GetLocalGenerator(); |
| |
| if (!gt->IsInBuildSystem() || IsExcluded(lg.get(), gt.get())) { |
| continue; |
| } |
| |
| cmStateSnapshot csnp = lg->GetStateSnapshot(); |
| cmStateSnapshot tsnp = tlg->GetStateSnapshot(); |
| |
| // Consider the directory containing the target and all its |
| // parents until something excludes the target. |
| for (; csnp.IsValid() && !this->IsExcluded(csnp, tsnp); |
| csnp = csnp.GetBuildsystemDirectoryParent()) { |
| // This local generator includes the target. |
| std::set<cmGeneratorTarget const*>& targetSet = |
| this->DirectoryTargetsMap[csnp]; |
| targetSet.insert(gt.get()); |
| |
| // Add dependencies of the included target. An excluded |
| // target may still be included if it is a dependency of a |
| // non-excluded target. |
| for (cmTargetDepend const& tgtdep : |
| this->GetTargetDirectDepends(gt.get())) { |
| targetSet.insert(tgtdep); |
| } |
| } |
| } |
| } |
| } |
| |
| size_t cmGlobalUnixMakefileGenerator3::CountProgressMarksInTarget( |
| cmGeneratorTarget const* target, std::set<cmGeneratorTarget const*>& emitted) |
| { |
| size_t count = 0; |
| if (emitted.insert(target).second) { |
| count = this->ProgressMap[target].Marks.size(); |
| for (cmTargetDepend const& depend : this->GetTargetDirectDepends(target)) { |
| if (!depend->IsInBuildSystem()) { |
| continue; |
| } |
| count += this->CountProgressMarksInTarget(depend, emitted); |
| } |
| } |
| return count; |
| } |
| |
| size_t cmGlobalUnixMakefileGenerator3::CountProgressMarksInAll( |
| const cmLocalGenerator& lg) |
| { |
| size_t count = 0; |
| std::set<cmGeneratorTarget const*> emitted; |
| for (cmGeneratorTarget const* target : |
| this->DirectoryTargetsMap[lg.GetStateSnapshot()]) { |
| count += this->CountProgressMarksInTarget(target, emitted); |
| } |
| return count; |
| } |
| |
| void cmGlobalUnixMakefileGenerator3::RecordTargetProgress( |
| cmMakefileTargetGenerator* tg) |
| { |
| TargetProgress& tp = this->ProgressMap[tg->GetGeneratorTarget()]; |
| tp.NumberOfActions = tg->GetNumberOfProgressActions(); |
| tp.VariableFile = tg->GetProgressFileNameFull(); |
| } |
| |
| void cmGlobalUnixMakefileGenerator3::TargetProgress::WriteProgressVariables( |
| unsigned long total, unsigned long& current) |
| { |
| cmGeneratedFileStream fout(this->VariableFile); |
| for (unsigned long i = 1; i <= this->NumberOfActions; ++i) { |
| fout << "CMAKE_PROGRESS_" << i << " = "; |
| if (total <= 100) { |
| unsigned long num = i + current; |
| fout << num; |
| this->Marks.push_back(num); |
| } else if (((i + current) * 100) / total > |
| ((i - 1 + current) * 100) / total) { |
| unsigned long num = ((i + current) * 100) / total; |
| fout << num; |
| this->Marks.push_back(num); |
| } |
| fout << "\n"; |
| } |
| fout << "\n"; |
| current += this->NumberOfActions; |
| } |
| |
| void cmGlobalUnixMakefileGenerator3::AppendGlobalTargetDepends( |
| std::vector<std::string>& depends, cmGeneratorTarget* target) |
| { |
| for (cmTargetDepend const& i : this->GetTargetDirectDepends(target)) { |
| // Create the target-level dependency. |
| cmGeneratorTarget const* dep = i; |
| if (!dep->IsInBuildSystem()) { |
| continue; |
| } |
| cmLocalUnixMakefileGenerator3* lg3 = |
| static_cast<cmLocalUnixMakefileGenerator3*>(dep->GetLocalGenerator()); |
| std::string tgtName = cmStrCat( |
| lg3->GetRelativeTargetDirectory(const_cast<cmGeneratorTarget*>(dep)), |
| "/all"); |
| depends.push_back(tgtName); |
| } |
| } |
| |
| void cmGlobalUnixMakefileGenerator3::WriteHelpRule( |
| std::ostream& ruleFileStream, cmLocalUnixMakefileGenerator3* lg) |
| { |
| // add the help target |
| std::string path; |
| std::vector<std::string> no_depends; |
| std::vector<std::string> commands; |
| lg->AppendEcho(commands, |
| "The following are some of the valid targets " |
| "for this Makefile:"); |
| lg->AppendEcho(commands, "... all (the default if no target is provided)"); |
| lg->AppendEcho(commands, "... clean"); |
| if (!this->GlobalSettingIsOn("CMAKE_SUPPRESS_REGENERATION")) { |
| lg->AppendEcho(commands, "... depend"); |
| } |
| |
| // Keep track of targets already listed. |
| std::set<std::string> emittedTargets; |
| std::set<std::string> utility_targets; |
| std::set<std::string> globals_targets; |
| std::set<std::string> project_targets; |
| |
| // for each local generator |
| for (const auto& localGen : this->LocalGenerators) { |
| const auto& lg2 = |
| cm::static_reference_cast<cmLocalUnixMakefileGenerator3>(localGen); |
| // for the passed in makefile or if this is the top Makefile wripte out |
| // the targets |
| if (&lg2 == lg || lg->IsRootMakefile()) { |
| // for each target Generate the rule files for each target. |
| for (const auto& target : lg2.GetGeneratorTargets()) { |
| cmStateEnums::TargetType type = target->GetType(); |
| if ((type == cmStateEnums::EXECUTABLE) || |
| (type == cmStateEnums::STATIC_LIBRARY) || |
| (type == cmStateEnums::SHARED_LIBRARY) || |
| (type == cmStateEnums::MODULE_LIBRARY) || |
| (type == cmStateEnums::OBJECT_LIBRARY)) { |
| project_targets.insert(target->GetName()); |
| } else if (type == cmStateEnums::GLOBAL_TARGET) { |
| globals_targets.insert(target->GetName()); |
| } else if (type == cmStateEnums::UTILITY) { |
| utility_targets.insert(target->GetName()); |
| } |
| } |
| } |
| } |
| |
| for (std::string const& name : globals_targets) { |
| path = cmStrCat("... ", name); |
| lg->AppendEcho(commands, path); |
| } |
| for (std::string const& name : utility_targets) { |
| path = cmStrCat("... ", name); |
| lg->AppendEcho(commands, path); |
| } |
| for (std::string const& name : project_targets) { |
| path = cmStrCat("... ", name); |
| lg->AppendEcho(commands, path); |
| } |
| |
| for (std::string const& o : lg->GetLocalHelp()) { |
| path = cmStrCat("... ", o); |
| lg->AppendEcho(commands, path); |
| } |
| lg->WriteMakeRule(ruleFileStream, "Help Target", "help", no_depends, |
| commands, true); |
| ruleFileStream << "\n\n"; |
| } |
