diff options
Diffstat (limited to 'Source/cmLocalUnixMakefileGenerator3.cxx')
| -rw-r--r-- | Source/cmLocalUnixMakefileGenerator3.cxx | 1740 |
1 files changed, 712 insertions, 1028 deletions
diff --git a/Source/cmLocalUnixMakefileGenerator3.cxx b/Source/cmLocalUnixMakefileGenerator3.cxx index 82220be..88c6d61 100644 --- a/Source/cmLocalUnixMakefileGenerator3.cxx +++ b/Source/cmLocalUnixMakefileGenerator3.cxx @@ -26,8 +26,8 @@ // C/C++ scanner is needed for bootstrapping CMake. #include "cmDependsC.h" #ifdef CMAKE_BUILD_WITH_CMAKE -# include "cmDependsFortran.h" -# include "cmDependsJava.h" +#include "cmDependsFortran.h" +#include "cmDependsJava.h" #endif #include <cmsys/Terminal.h> @@ -40,23 +40,31 @@ class cmMakeSafe { public: - cmMakeSafe(const char* s): Data(s) {} - cmMakeSafe(std::string const& s): Data(s.c_str()) {} + cmMakeSafe(const char* s) + : Data(s) + { + } + cmMakeSafe(std::string const& s) + : Data(s.c_str()) + { + } + private: const char* Data; - friend std::ostream& operator<<(std::ostream& os, - cmMakeSafe const& self) - { - for(const char* c = self.Data; *c; ++c) - { - switch (*c) - { - case '=': os << "$(EQUALS)"; break; - default: os << *c; break; - } + friend std::ostream& operator<<(std::ostream& os, cmMakeSafe const& self) + { + for (const char* c = self.Data; *c; ++c) { + switch (*c) { + case '=': + os << "$(EQUALS)"; + break; + default: + os << *c; + break; } - return os; } + return os; + } }; // Helper function used below. @@ -64,21 +72,18 @@ static std::string cmSplitExtension(std::string const& in, std::string& base) { std::string ext; std::string::size_type dot_pos = in.rfind("."); - if(dot_pos != std::string::npos) - { + if (dot_pos != std::string::npos) { // Remove the extension first in case &base == &in. ext = in.substr(dot_pos, std::string::npos); base = in.substr(0, dot_pos); - } - else - { + } else { base = in; - } + } return ext; } -cmLocalUnixMakefileGenerator3:: -cmLocalUnixMakefileGenerator3(cmGlobalGenerator* gg, cmMakefile* mf) +cmLocalUnixMakefileGenerator3::cmLocalUnixMakefileGenerator3( + cmGlobalGenerator* gg, cmMakefile* mf) : cmLocalCommonGenerator(gg, mf) { this->MakefileVariableSize = 0; @@ -99,10 +104,9 @@ void cmLocalUnixMakefileGenerator3::Generate() // Record whether some options are enabled to avoid checking many // times later. - if(!this->GetGlobalGenerator()->GetCMakeInstance()->GetIsInTryCompile()) - { + if (!this->GetGlobalGenerator()->GetCMakeInstance()->GetIsInTryCompile()) { this->ColorMakefile = this->Makefile->IsOn("CMAKE_COLOR_MAKEFILE"); - } + } this->SkipPreprocessedSourceRules = this->Makefile->IsOn("CMAKE_SKIP_PREPROCESSED_SOURCE_RULES"); this->SkipAssemblySourceRules = @@ -112,21 +116,18 @@ void cmLocalUnixMakefileGenerator3::Generate() std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets(); cmGlobalUnixMakefileGenerator3* gg = static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator); - for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin(); - t != targets.end(); ++t) - { - if ((*t)->GetType() == cmState::INTERFACE_LIBRARY) - { + for (std::vector<cmGeneratorTarget*>::iterator t = targets.begin(); + t != targets.end(); ++t) { + if ((*t)->GetType() == cmState::INTERFACE_LIBRARY) { continue; - } + } cmsys::auto_ptr<cmMakefileTargetGenerator> tg( cmMakefileTargetGenerator::New(*t)); - if (tg.get()) - { + if (tg.get()) { tg->WriteRuleFiles(); gg->RecordTargetProgress(tg.get()); - } } + } // write the local Makefile this->WriteLocalMakefile(); @@ -141,44 +142,40 @@ void cmLocalUnixMakefileGenerator3::ComputeHomeRelativeOutputPath() // directory from the top output directory. this->HomeRelativeOutputPath = this->Convert(this->GetCurrentBinaryDirectory(), HOME_OUTPUT); - if(this->HomeRelativeOutputPath == ".") - { + if (this->HomeRelativeOutputPath == ".") { this->HomeRelativeOutputPath = ""; - } - if(!this->HomeRelativeOutputPath.empty()) - { + } + if (!this->HomeRelativeOutputPath.empty()) { this->HomeRelativeOutputPath += "/"; - } + } } void cmLocalUnixMakefileGenerator3::ComputeObjectFilenames( - std::map<cmSourceFile const*, std::string>& mapping, - cmGeneratorTarget const* gt) + std::map<cmSourceFile const*, std::string>& mapping, + cmGeneratorTarget const* gt) { - for(std::map<cmSourceFile const*, std::string>::iterator - si = mapping.begin(); si != mapping.end(); ++si) - { + for (std::map<cmSourceFile const*, std::string>::iterator si = + mapping.begin(); + si != mapping.end(); ++si) { cmSourceFile const* sf = si->first; - si->second = this->GetObjectFileNameWithoutTarget(*sf, - gt->ObjectDirectory); - } + si->second = + this->GetObjectFileNameWithoutTarget(*sf, gt->ObjectDirectory); + } } -void cmLocalUnixMakefileGenerator3:: -GetLocalObjectFiles(std::map<std::string, LocalObjectInfo> &localObjectFiles) +void cmLocalUnixMakefileGenerator3::GetLocalObjectFiles( + std::map<std::string, LocalObjectInfo>& localObjectFiles) { std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets(); - for(std::vector<cmGeneratorTarget*>::iterator ti = targets.begin(); - ti != targets.end(); ++ti) - { + for (std::vector<cmGeneratorTarget*>::iterator ti = targets.begin(); + ti != targets.end(); ++ti) { cmGeneratorTarget* gt = *ti; - if (gt->GetType() == cmState::INTERFACE_LIBRARY) - { + if (gt->GetType() == cmState::INTERFACE_LIBRARY) { continue; - } + } std::vector<cmSourceFile const*> objectSources; - gt->GetObjectSources(objectSources, this->Makefile - ->GetSafeDefinition("CMAKE_BUILD_TYPE")); + gt->GetObjectSources( + objectSources, this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE")); // Compute full path to object file directory for this target. std::string dir; dir += gt->LocalGenerator->GetCurrentBinaryDirectory(); @@ -186,49 +183,42 @@ GetLocalObjectFiles(std::map<std::string, LocalObjectInfo> &localObjectFiles) dir += this->GetTargetDirectory(gt); dir += "/"; // Compute the name of each object file. - for(std::vector<cmSourceFile const*>::iterator - si = objectSources.begin(); - si != objectSources.end(); ++si) - { + for (std::vector<cmSourceFile const*>::iterator si = objectSources.begin(); + si != objectSources.end(); ++si) { cmSourceFile const* sf = *si; bool hasSourceExtension = true; - std::string objectName = this->GetObjectFileNameWithoutTarget(*sf, - dir, - &hasSourceExtension); - if(cmSystemTools::FileIsFullPath(objectName.c_str())) - { + std::string objectName = + this->GetObjectFileNameWithoutTarget(*sf, dir, &hasSourceExtension); + if (cmSystemTools::FileIsFullPath(objectName.c_str())) { objectName = cmSystemTools::GetFilenameName(objectName); - } + } LocalObjectInfo& info = localObjectFiles[objectName]; info.HasSourceExtension = hasSourceExtension; info.push_back(LocalObjectEntry(gt, sf->GetLanguage())); - } } + } } -void cmLocalUnixMakefileGenerator3::GetIndividualFileTargets - (std::vector<std::string>& targets) +void cmLocalUnixMakefileGenerator3::GetIndividualFileTargets( + std::vector<std::string>& targets) { std::map<std::string, LocalObjectInfo> localObjectFiles; this->GetLocalObjectFiles(localObjectFiles); for (std::map<std::string, LocalObjectInfo>::iterator lo = localObjectFiles.begin(); - lo != localObjectFiles.end(); ++lo) - { + lo != localObjectFiles.end(); ++lo) { targets.push_back(lo->first); std::string::size_type dot_pos = lo->first.rfind("."); std::string base = lo->first.substr(0, dot_pos); - if(lo->second.HasPreprocessRule) - { + if (lo->second.HasPreprocessRule) { targets.push_back(base + ".i"); - } + } - if(lo->second.HasAssembleRule) - { + if (lo->second.HasAssembleRule) { targets.push_back(base + ".s"); - } } + } } void cmLocalUnixMakefileGenerator3::WriteLocalMakefile() @@ -240,15 +230,13 @@ void cmLocalUnixMakefileGenerator3::WriteLocalMakefile() // rules may depend on this file itself. std::string ruleFileNameFull = this->ConvertToFullPath(ruleFileName); cmGeneratedFileStream ruleFileStream(ruleFileNameFull.c_str()); - if(!ruleFileStream) - { + if (!ruleFileStream) { return; - } + } // always write the top makefile - if (!this->IsRootMakefile()) - { + if (!this->IsRootMakefile()) { ruleFileStream.SetCopyIfDifferent(true); - } + } // write the all rules this->WriteLocalAllRules(ruleFileStream); @@ -256,23 +244,18 @@ void cmLocalUnixMakefileGenerator3::WriteLocalMakefile() // only write local targets unless at the top Keep track of targets already // listed. std::set<std::string> emittedTargets; - if (!this->IsRootMakefile()) - { + if (!this->IsRootMakefile()) { // write our targets, and while doing it collect up the object // file rules - this->WriteLocalMakefileTargets(ruleFileStream,emittedTargets); - } - else - { - cmGlobalUnixMakefileGenerator3 *gg = + this->WriteLocalMakefileTargets(ruleFileStream, emittedTargets); + } else { + cmGlobalUnixMakefileGenerator3* gg = static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator); - gg->WriteConvenienceRules(ruleFileStream,emittedTargets); - } + gg->WriteConvenienceRules(ruleFileStream, emittedTargets); + } - bool do_preprocess_rules = - this->GetCreatePreprocessedSourceRules(); - bool do_assembly_rules = - this->GetCreateAssemblySourceRules(); + bool do_preprocess_rules = this->GetCreatePreprocessedSourceRules(); + bool do_assembly_rules = this->GetCreateAssemblySourceRules(); std::map<std::string, LocalObjectInfo> localObjectFiles; this->GetLocalObjectFiles(localObjectFiles); @@ -281,8 +264,7 @@ void cmLocalUnixMakefileGenerator3::WriteLocalMakefile() // for each object file name for (std::map<std::string, LocalObjectInfo>::iterator lo = localObjectFiles.begin(); - lo != localObjectFiles.end(); ++lo) - { + lo != localObjectFiles.end(); ++lo) { // Add a convenience rule for building the object file. this->WriteObjectConvenienceRule(ruleFileStream, "target to build an object file", @@ -293,66 +275,57 @@ void cmLocalUnixMakefileGenerator3::WriteLocalMakefile() bool lang_has_preprocessor = false; bool lang_has_assembly = false; - for(std::vector<LocalObjectEntry>::const_iterator ei = - lo->second.begin(); ei != lo->second.end(); ++ei) - { - if(ei->Language == "C" || - ei->Language == "CXX" || - ei->Language == "Fortran") - { + for (std::vector<LocalObjectEntry>::const_iterator ei = lo->second.begin(); + ei != lo->second.end(); ++ei) { + if (ei->Language == "C" || ei->Language == "CXX" || + ei->Language == "Fortran") { // Right now, C, C++ and Fortran have both a preprocessor and the // ability to generate assembly code lang_has_preprocessor = true; lang_has_assembly = true; break; - } } + } // Add convenience rules for preprocessed and assembly files. - if(lang_has_preprocessor && do_preprocess_rules) - { + if (lang_has_preprocessor && do_preprocess_rules) { std::string::size_type dot_pos = lo->first.rfind("."); std::string base = lo->first.substr(0, dot_pos); - this->WriteObjectConvenienceRule( - ruleFileStream, "target to preprocess a source file", - (base + ".i").c_str(), lo->second); + this->WriteObjectConvenienceRule(ruleFileStream, + "target to preprocess a source file", + (base + ".i").c_str(), lo->second); lo->second.HasPreprocessRule = true; - } + } - if(lang_has_assembly && do_assembly_rules) - { + if (lang_has_assembly && do_assembly_rules) { std::string::size_type dot_pos = lo->first.rfind("."); std::string base = lo->first.substr(0, dot_pos); this->WriteObjectConvenienceRule( - ruleFileStream, "target to generate assembly for a file", - (base + ".s").c_str(), lo->second); + ruleFileStream, "target to generate assembly for a file", + (base + ".s").c_str(), lo->second); lo->second.HasAssembleRule = true; - } } + } // add a help target as long as there isn;t a real target named help - if(emittedTargets.insert("help").second) - { - cmGlobalUnixMakefileGenerator3 *gg = + if (emittedTargets.insert("help").second) { + cmGlobalUnixMakefileGenerator3* gg = static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator); - gg->WriteHelpRule(ruleFileStream,this); - } + gg->WriteHelpRule(ruleFileStream, this); + } this->WriteSpecialTargetsBottom(ruleFileStream); } -void -cmLocalUnixMakefileGenerator3 -::WriteObjectConvenienceRule(std::ostream& ruleFileStream, - const char* comment, const char* output, - LocalObjectInfo const& info) +void cmLocalUnixMakefileGenerator3::WriteObjectConvenienceRule( + std::ostream& ruleFileStream, const char* comment, const char* output, + LocalObjectInfo const& info) { // If the rule includes the source file extension then create a // version that has the extension removed. The help should include // only the version without source extension. bool inHelp = true; - if(info.HasSourceExtension) - { + if (info.HasSourceExtension) { // Remove the last extension. This should be kept. std::string outBase1 = output; std::string outExt1 = cmSplitExtension(outBase1, outBase1); @@ -367,39 +340,34 @@ cmLocalUnixMakefileGenerator3 std::vector<std::string> depends; depends.push_back(output); std::vector<std::string> no_commands; - this->WriteMakeRule(ruleFileStream, 0, - outNoExt, depends, no_commands, true, true); + this->WriteMakeRule(ruleFileStream, 0, outNoExt, depends, no_commands, + true, true); inHelp = false; - } + } // Recursively make the rule for each target using the object file. std::vector<std::string> commands; - for(std::vector<LocalObjectEntry>::const_iterator t = info.begin(); - t != info.end(); ++t) - { - std::string tgtMakefileName = - this->GetRelativeTargetDirectory(t->Target); + for (std::vector<LocalObjectEntry>::const_iterator t = info.begin(); + t != info.end(); ++t) { + std::string tgtMakefileName = this->GetRelativeTargetDirectory(t->Target); std::string targetName = tgtMakefileName; tgtMakefileName += "/build.make"; targetName += "/"; targetName += output; commands.push_back( - this->GetRecursiveMakeCall(tgtMakefileName.c_str(), targetName) - ); - } - this->CreateCDCommand(commands, - this->GetBinaryDirectory(), + this->GetRecursiveMakeCall(tgtMakefileName.c_str(), targetName)); + } + this->CreateCDCommand(commands, this->GetBinaryDirectory(), cmLocalGenerator::START_OUTPUT); // Write the rule to the makefile. std::vector<std::string> no_depends; - this->WriteMakeRule(ruleFileStream, comment, - output, no_depends, commands, true, inHelp); + this->WriteMakeRule(ruleFileStream, comment, output, no_depends, commands, + true, inHelp); } -void cmLocalUnixMakefileGenerator3 -::WriteLocalMakefileTargets(std::ostream& ruleFileStream, - std::set<std::string> &emitted) +void cmLocalUnixMakefileGenerator3::WriteLocalMakefileTargets( + std::ostream& ruleFileStream, std::set<std::string>& emitted) { std::vector<std::string> depends; std::vector<std::string> commands; @@ -408,16 +376,14 @@ void cmLocalUnixMakefileGenerator3 // on the target std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets(); std::string localName; - for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin(); - t != targets.end(); ++t) - { - if(((*t)->GetType() == cmState::EXECUTABLE) || - ((*t)->GetType() == cmState::STATIC_LIBRARY) || - ((*t)->GetType() == cmState::SHARED_LIBRARY) || - ((*t)->GetType() == cmState::MODULE_LIBRARY) || - ((*t)->GetType() == cmState::OBJECT_LIBRARY) || - ((*t)->GetType() == cmState::UTILITY)) - { + for (std::vector<cmGeneratorTarget*>::iterator t = targets.begin(); + t != targets.end(); ++t) { + if (((*t)->GetType() == cmState::EXECUTABLE) || + ((*t)->GetType() == cmState::STATIC_LIBRARY) || + ((*t)->GetType() == cmState::SHARED_LIBRARY) || + ((*t)->GetType() == cmState::MODULE_LIBRARY) || + ((*t)->GetType() == cmState::OBJECT_LIBRARY) || + ((*t)->GetType() == cmState::UTILITY)) { emitted.insert((*t)->GetName()); // for subdirs add a rule to build this specific target by name. @@ -429,64 +395,57 @@ void cmLocalUnixMakefileGenerator3 // Build the target for this pass. std::string makefile2 = cmake::GetCMakeFilesDirectoryPostSlash(); makefile2 += "Makefile2"; - commands.push_back(this->GetRecursiveMakeCall - (makefile2.c_str(),localName)); - this->CreateCDCommand(commands, - this->GetBinaryDirectory(), + commands.push_back( + this->GetRecursiveMakeCall(makefile2.c_str(), localName)); + this->CreateCDCommand(commands, this->GetBinaryDirectory(), cmLocalGenerator::START_OUTPUT); this->WriteMakeRule(ruleFileStream, "Convenience name for target.", localName, depends, commands, true); // Add a target with the canonical name (no prefix, suffix or path). - if(localName != (*t)->GetName()) - { + if (localName != (*t)->GetName()) { commands.clear(); depends.push_back(localName); this->WriteMakeRule(ruleFileStream, "Convenience name for target.", (*t)->GetName(), depends, commands, true); - } + } // Add a fast rule to build the target - std::string makefileName = - this->GetRelativeTargetDirectory(*t); + std::string makefileName = this->GetRelativeTargetDirectory(*t); makefileName += "/build.make"; // make sure the makefile name is suitable for a makefile - std::string makeTargetName = - this->GetRelativeTargetDirectory(*t); + std::string makeTargetName = this->GetRelativeTargetDirectory(*t); makeTargetName += "/build"; localName = (*t)->GetName(); localName += "/fast"; depends.clear(); commands.clear(); - commands.push_back(this->GetRecursiveMakeCall - (makefileName.c_str(), makeTargetName)); - this->CreateCDCommand(commands, - this->GetBinaryDirectory(), + commands.push_back( + this->GetRecursiveMakeCall(makefileName.c_str(), makeTargetName)); + this->CreateCDCommand(commands, this->GetBinaryDirectory(), cmLocalGenerator::START_OUTPUT); this->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((*t)->NeedRelinkBeforeInstall(this->ConfigName)) - { + if ((*t)->NeedRelinkBeforeInstall(this->ConfigName)) { makeTargetName = this->GetRelativeTargetDirectory(*t); makeTargetName += "/preinstall"; localName = (*t)->GetName(); localName += "/preinstall"; depends.clear(); commands.clear(); - commands.push_back(this->GetRecursiveMakeCall - (makefile2.c_str(), makeTargetName)); - this->CreateCDCommand(commands, - this->GetBinaryDirectory(), + commands.push_back( + this->GetRecursiveMakeCall(makefile2.c_str(), makeTargetName)); + this->CreateCDCommand(commands, this->GetBinaryDirectory(), cmLocalGenerator::START_OUTPUT); this->WriteMakeRule(ruleFileStream, "Manual pre-install relink rule for target.", localName, depends, commands, true); - } } } + } } void cmLocalUnixMakefileGenerator3::WriteDirectoryInformationFile() @@ -497,10 +456,9 @@ void cmLocalUnixMakefileGenerator3::WriteDirectoryInformationFile() // Open the output file. cmGeneratedFileStream infoFileStream(infoFileName.c_str()); - if(!infoFileStream) - { + if (!infoFileStream) { return; - } + } infoFileStream.SetCopyIfDifferent(true); // Write the do not edit header. @@ -520,43 +478,35 @@ void cmLocalUnixMakefileGenerator3::WriteDirectoryInformationFile() /* clang-format on */ // Tell the dependency scanner to use unix paths if necessary. - if(cmSystemTools::GetForceUnixPaths()) - { + if (cmSystemTools::GetForceUnixPaths()) { /* clang-format off */ infoFileStream << "# Force unix paths in dependencies.\n" << "set(CMAKE_FORCE_UNIX_PATHS 1)\n" << "\n"; /* clang-format on */ - } + } // Store the include regular expressions for this directory. - infoFileStream - << "\n" - << "# The C and CXX include file regular expressions for " - << "this directory.\n"; - infoFileStream - << "set(CMAKE_C_INCLUDE_REGEX_SCAN "; + infoFileStream << "\n" + << "# The C and CXX include file regular expressions for " + << "this directory.\n"; + infoFileStream << "set(CMAKE_C_INCLUDE_REGEX_SCAN "; this->WriteCMakeArgument(infoFileStream, this->Makefile->GetIncludeRegularExpression()); - infoFileStream - << ")\n"; - infoFileStream - << "set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "; + infoFileStream << ")\n"; + infoFileStream << "set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "; this->WriteCMakeArgument(infoFileStream, this->Makefile->GetComplainRegularExpression()); - infoFileStream - << ")\n"; + infoFileStream << ")\n"; infoFileStream << "set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN})\n"; - infoFileStream - << "set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN " - "${CMAKE_C_INCLUDE_REGEX_COMPLAIN})\n"; + infoFileStream << "set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN " + "${CMAKE_C_INCLUDE_REGEX_COMPLAIN})\n"; } -std::string -cmLocalUnixMakefileGenerator3 -::ConvertToFullPath(const std::string& localPath) +std::string cmLocalUnixMakefileGenerator3::ConvertToFullPath( + const std::string& localPath) { std::string dir = this->GetCurrentBinaryDirectory(); dir += "/"; @@ -564,156 +514,126 @@ cmLocalUnixMakefileGenerator3 return dir; } - -const std::string &cmLocalUnixMakefileGenerator3::GetHomeRelativeOutputPath() +const std::string& cmLocalUnixMakefileGenerator3::GetHomeRelativeOutputPath() { return this->HomeRelativeOutputPath; } -void -cmLocalUnixMakefileGenerator3 -::WriteMakeRule(std::ostream& os, - const char* comment, - const std::string& target, - const std::vector<std::string>& depends, - const std::vector<std::string>& commands, - bool symbolic, - bool in_help) +void cmLocalUnixMakefileGenerator3::WriteMakeRule( + std::ostream& os, const char* comment, const std::string& target, + const std::vector<std::string>& depends, + const std::vector<std::string>& commands, bool symbolic, bool in_help) { // Make sure there is a target. - if(target.empty()) - { + if (target.empty()) { cmSystemTools::Error("No target for WriteMakeRule! called with comment: ", comment); return; - } + } std::string replace; // Write the comment describing the rule in the makefile. - if(comment) - { + if (comment) { replace = comment; std::string::size_type lpos = 0; std::string::size_type rpos; - while((rpos = replace.find('\n', lpos)) != std::string::npos) - { - os << "# " << replace.substr(lpos, rpos-lpos) << "\n"; - lpos = rpos+1; - } - os << "# " << replace.substr(lpos) << "\n"; + while ((rpos = replace.find('\n', lpos)) != std::string::npos) { + os << "# " << replace.substr(lpos, rpos - lpos) << "\n"; + lpos = rpos + 1; } + os << "# " << replace.substr(lpos) << "\n"; + } // Construct the left hand side of the rule. std::string tgt = this->Convert(target, HOME_OUTPUT, MAKERULE); const char* space = ""; - if(tgt.size() == 1) - { + if (tgt.size() == 1) { // Add a space before the ":" to avoid drive letter confusion on // Windows. space = " "; - } + } // Mark the rule as symbolic if requested. - if(symbolic) - { - if(const char* sym = - this->Makefile->GetDefinition("CMAKE_MAKE_SYMBOLIC_RULE")) - { + if (symbolic) { + if (const char* sym = + this->Makefile->GetDefinition("CMAKE_MAKE_SYMBOLIC_RULE")) { os << cmMakeSafe(tgt) << space << ": " << sym << "\n"; - } } + } // Write the rule. - if(depends.empty()) - { + if (depends.empty()) { // No dependencies. The commands will always run. os << cmMakeSafe(tgt) << space << ":\n"; - } - else - { + } else { // Split dependencies into multiple rule lines. This allows for // very long dependency lists even on older make implementations. - for(std::vector<std::string>::const_iterator dep = depends.begin(); - dep != depends.end(); ++dep) - { + for (std::vector<std::string>::const_iterator dep = depends.begin(); + dep != depends.end(); ++dep) { replace = *dep; - replace = this->Convert(replace,HOME_OUTPUT,MAKERULE); + replace = this->Convert(replace, HOME_OUTPUT, MAKERULE); os << cmMakeSafe(tgt) << space << ": " << cmMakeSafe(replace) << "\n"; - } } + } // Write the list of commands. os << cmWrap("\t", commands, "", "\n") << "\n"; - if(symbolic && !this->IsWatcomWMake()) - { + if (symbolic && !this->IsWatcomWMake()) { os << ".PHONY : " << cmMakeSafe(tgt) << "\n"; - } + } os << "\n"; // Add the output to the local help if requested. - if(in_help) - { + if (in_help) { this->LocalHelp.push_back(target); - } + } } -std::string -cmLocalUnixMakefileGenerator3 -::ConvertShellCommand(std::string const& cmd, RelativeRoot root) +std::string cmLocalUnixMakefileGenerator3::ConvertShellCommand( + std::string const& cmd, RelativeRoot root) { - if(this->IsWatcomWMake() && - cmSystemTools::FileIsFullPath(cmd.c_str()) && - cmd.find_first_of("( )") != cmd.npos) - { + if (this->IsWatcomWMake() && cmSystemTools::FileIsFullPath(cmd.c_str()) && + cmd.find_first_of("( )") != cmd.npos) { // On Watcom WMake use the windows short path for the command // name. This is needed to avoid funny quoting problems on // lines with shell redirection operators. std::string scmd; - if(cmSystemTools::GetShortPath(cmd, scmd)) - { + if (cmSystemTools::GetShortPath(cmd, scmd)) { return this->Convert(scmd, NONE, SHELL); - } } + } return this->Convert(cmd, root, SHELL); } -void -cmLocalUnixMakefileGenerator3 -::WriteMakeVariables(std::ostream& makefileStream) +void cmLocalUnixMakefileGenerator3::WriteMakeVariables( + std::ostream& makefileStream) { this->WriteDivider(makefileStream); - makefileStream - << "# Set environment variables for the build.\n" - << "\n"; + makefileStream << "# Set environment variables for the build.\n" + << "\n"; cmGlobalUnixMakefileGenerator3* gg = static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator); - if(gg->DefineWindowsNULL) - { - makefileStream - << "!IF \"$(OS)\" == \"Windows_NT\"\n" - << "NULL=\n" - << "!ELSE\n" - << "NULL=nul\n" - << "!ENDIF\n"; - } - if(this->IsWindowsShell()) - { - makefileStream - << "SHELL = cmd.exe\n" - << "\n"; - } - else - { + if (gg->DefineWindowsNULL) { + makefileStream << "!IF \"$(OS)\" == \"Windows_NT\"\n" + << "NULL=\n" + << "!ELSE\n" + << "NULL=nul\n" + << "!ENDIF\n"; + } + if (this->IsWindowsShell()) { + makefileStream << "SHELL = cmd.exe\n" + << "\n"; + } else { #if !defined(__VMS) /* clang-format off */ makefileStream << "# The shell in which to execute make rules.\n" << "SHELL = /bin/sh\n" << "\n"; - /* clang-format on */ +/* clang-format on */ #endif - } + } /* clang-format off */ makefileStream @@ -747,14 +667,12 @@ cmLocalUnixMakefileGenerator3 /* clang-format on */ } -void -cmLocalUnixMakefileGenerator3 -::WriteSpecialTargetsTop(std::ostream& makefileStream) +void cmLocalUnixMakefileGenerator3::WriteSpecialTargetsTop( + std::ostream& makefileStream) { this->WriteDivider(makefileStream); - makefileStream - << "# Special targets provided by cmake.\n" - << "\n"; + makefileStream << "# Special targets provided by cmake.\n" + << "\n"; std::vector<std::string> no_commands; std::vector<std::string> no_depends; @@ -762,25 +680,23 @@ cmLocalUnixMakefileGenerator3 // Special target to cleanup operation of make tool. // This should be the first target except for the default_target in // the interface Makefile. - this->WriteMakeRule( - makefileStream, "Disable implicit rules so canonical targets will work.", - ".SUFFIXES", no_depends, no_commands, false); + this->WriteMakeRule(makefileStream, + "Disable implicit rules so canonical targets will work.", + ".SUFFIXES", no_depends, no_commands, false); - if(!this->IsNMake() - && !this->IsWatcomWMake() && !this->BorlandMakeCurlyHack) - { + if (!this->IsNMake() && !this->IsWatcomWMake() && + !this->BorlandMakeCurlyHack) { // turn off RCS and SCCS automatic stuff from gmake makefileStream << "# Remove some rules from gmake that .SUFFIXES does not remove.\n" << "SUFFIXES =\n\n"; - } + } // Add a fake suffix to keep HP happy. Must be max 32 chars for SGI make. std::vector<std::string> depends; depends.push_back(".hpux_make_needs_suffix_list"); - this->WriteMakeRule(makefileStream, 0, - ".SUFFIXES", depends, no_commands, false); - if(this->IsWatcomWMake()) - { + this->WriteMakeRule(makefileStream, 0, ".SUFFIXES", depends, no_commands, + false); + if (this->IsWatcomWMake()) { // Switch on WMake feature, if an error or interrupt occurs during // makefile processing, the current target being made may be deleted // without prompting (the same as command line -e option). @@ -791,18 +707,16 @@ cmLocalUnixMakefileGenerator3 "\n" ; /* clang-format on */ - } - if(this->Makefile->IsOn("CMAKE_VERBOSE_MAKEFILE")) - { + } + if (this->Makefile->IsOn("CMAKE_VERBOSE_MAKEFILE")) { /* clang-format off */ makefileStream << "# Produce verbose output by default.\n" << "VERBOSE = 1\n" << "\n"; /* clang-format on */ - } - if(this->IsWatcomWMake()) - { + } + if (this->IsWatcomWMake()) { /* clang-format off */ makefileStream << "!ifndef VERBOSE\n" @@ -811,9 +725,7 @@ cmLocalUnixMakefileGenerator3 "\n" ; /* clang-format on */ - } - else - { + } else { // Write special target to silence make output. This must be after // the default target in case VERBOSE is set (which changes the // name). The setting of CMAKE_VERBOSE_MAKEFILE to ON will cause a @@ -822,89 +734,73 @@ cmLocalUnixMakefileGenerator3 // the user. this->WriteMakeRule(makefileStream, "Suppress display of executed commands.", - "$(VERBOSE).SILENT", - no_depends, - no_commands, false); - } + "$(VERBOSE).SILENT", no_depends, no_commands, false); + } // Work-around for makes that drop rules that have no dependencies // or commands. cmGlobalUnixMakefileGenerator3* gg = static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator); std::string hack = gg->GetEmptyRuleHackDepends(); - if(!hack.empty()) - { + if (!hack.empty()) { no_depends.push_back(hack); - } + } std::string hack_cmd = gg->GetEmptyRuleHackCommand(); - if(!hack_cmd.empty()) - { + if (!hack_cmd.empty()) { no_commands.push_back(hack_cmd); - } + } // Special symbolic target that never exists to force dependers to // run their rules. - this->WriteMakeRule - (makefileStream, - "A target that is always out of date.", - "cmake_force", no_depends, no_commands, true); + this->WriteMakeRule(makefileStream, "A target that is always out of date.", + "cmake_force", no_depends, no_commands, true); // Variables for reference by other rules. this->WriteMakeVariables(makefileStream); } -void cmLocalUnixMakefileGenerator3 -::WriteSpecialTargetsBottom(std::ostream& makefileStream) +void cmLocalUnixMakefileGenerator3::WriteSpecialTargetsBottom( + std::ostream& makefileStream) { this->WriteDivider(makefileStream); - makefileStream - << "# Special targets to cleanup operation of make.\n" - << "\n"; + makefileStream << "# Special targets to cleanup operation of make.\n" + << "\n"; // Write special "cmake_check_build_system" target to run cmake with // the --check-build-system flag. { - // Build command to run CMake to check if anything needs regenerating. - std::string cmakefileName = cmake::GetCMakeFilesDirectoryPostSlash(); - cmakefileName += "Makefile.cmake"; - std::string runRule = - "$(CMAKE_COMMAND) -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)"; - runRule += " --check-build-system "; - runRule += this->Convert(cmakefileName,NONE,SHELL); - runRule += " 0"; + // Build command to run CMake to check if anything needs regenerating. + std::string cmakefileName = cmake::GetCMakeFilesDirectoryPostSlash(); + cmakefileName += "Makefile.cmake"; + std::string runRule = + "$(CMAKE_COMMAND) -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)"; + runRule += " --check-build-system "; + runRule += this->Convert(cmakefileName, NONE, SHELL); + runRule += " 0"; - std::vector<std::string> no_depends; - std::vector<std::string> commands; - commands.push_back(runRule); - if(!this->IsRootMakefile()) - { - this->CreateCDCommand(commands, - this->GetBinaryDirectory(), - cmLocalGenerator::START_OUTPUT); + std::vector<std::string> no_depends; + std::vector<std::string> commands; + commands.push_back(runRule); + if (!this->IsRootMakefile()) { + this->CreateCDCommand(commands, this->GetBinaryDirectory(), + cmLocalGenerator::START_OUTPUT); } - this->WriteMakeRule(makefileStream, - "Special rule to run CMake to check the build system " + this->WriteMakeRule( + makefileStream, "Special rule to run CMake to check the build system " "integrity.\n" "No rule that depends on this can have " "commands that come from listfiles\n" "because they might be regenerated.", - "cmake_check_build_system", - no_depends, - commands, true); + "cmake_check_build_system", no_depends, commands, true); } } - - -void -cmLocalUnixMakefileGenerator3 -::WriteConvenienceRule(std::ostream& ruleFileStream, - const std::string& realTarget, - const std::string& helpTarget) +void cmLocalUnixMakefileGenerator3::WriteConvenienceRule( + std::ostream& ruleFileStream, const std::string& realTarget, + const std::string& helpTarget) { // A rule is only needed if the names are different. - if(realTarget != helpTarget) - { + if (realTarget != helpTarget) { // The helper target depends on the real target. std::vector<std::string> depends; depends.push_back(realTarget); @@ -915,34 +811,28 @@ cmLocalUnixMakefileGenerator3 // Write the rule. this->WriteMakeRule(ruleFileStream, "Convenience name for target.", helpTarget, depends, no_commands, true); - } + } } - -std::string -cmLocalUnixMakefileGenerator3 -::GetRelativeTargetDirectory(cmGeneratorTarget* target) +std::string cmLocalUnixMakefileGenerator3::GetRelativeTargetDirectory( + cmGeneratorTarget* target) { std::string dir = this->HomeRelativeOutputPath; dir += this->GetTargetDirectory(target); - return this->Convert(dir,NONE,UNCHANGED); + return this->Convert(dir, NONE, UNCHANGED); } - - void cmLocalUnixMakefileGenerator3::AppendFlags(std::string& flags, const std::string& newFlags) { - if(this->IsWatcomWMake() && !newFlags.empty()) - { + if (this->IsWatcomWMake() && !newFlags.empty()) { std::string newf = newFlags; - if(newf.find("\\\"") != newf.npos) - { + if (newf.find("\\\"") != newf.npos) { cmSystemTools::ReplaceString(newf, "\\\"", "\""); this->cmLocalGenerator::AppendFlags(flags, newf); return; - } } + } this->cmLocalGenerator::AppendFlags(flags, newFlags); } @@ -952,203 +842,161 @@ void cmLocalUnixMakefileGenerator3::AppendFlags(std::string& flags, this->cmLocalGenerator::AppendFlags(flags, newFlags); } -void -cmLocalUnixMakefileGenerator3 -::AppendRuleDepend(std::vector<std::string>& depends, - const char* ruleFileName) +void cmLocalUnixMakefileGenerator3::AppendRuleDepend( + std::vector<std::string>& depends, const char* ruleFileName) { // Add a dependency on the rule file itself unless an option to skip // it is specifically enabled by the user or project. const char* nodep = this->Makefile->GetDefinition("CMAKE_SKIP_RULE_DEPENDENCY"); - if(!nodep || cmSystemTools::IsOff(nodep)) - { + if (!nodep || cmSystemTools::IsOff(nodep)) { depends.push_back(ruleFileName); - } + } } -void -cmLocalUnixMakefileGenerator3 -::AppendRuleDepends(std::vector<std::string>& depends, - std::vector<std::string> const& ruleFiles) +void cmLocalUnixMakefileGenerator3::AppendRuleDepends( + std::vector<std::string>& depends, std::vector<std::string> const& ruleFiles) { // Add a dependency on the rule file itself unless an option to skip // it is specifically enabled by the user or project. - if(!this->Makefile->IsOn("CMAKE_SKIP_RULE_DEPENDENCY")) - { + if (!this->Makefile->IsOn("CMAKE_SKIP_RULE_DEPENDENCY")) { depends.insert(depends.end(), ruleFiles.begin(), ruleFiles.end()); - } + } } -void -cmLocalUnixMakefileGenerator3 -::AppendCustomDepends(std::vector<std::string>& depends, - const std::vector<cmCustomCommand>& ccs) +void cmLocalUnixMakefileGenerator3::AppendCustomDepends( + std::vector<std::string>& depends, const std::vector<cmCustomCommand>& ccs) { - for(std::vector<cmCustomCommand>::const_iterator i = ccs.begin(); - i != ccs.end(); ++i) - { + for (std::vector<cmCustomCommand>::const_iterator i = ccs.begin(); + i != ccs.end(); ++i) { cmCustomCommandGenerator ccg(*i, this->ConfigName, this); this->AppendCustomDepend(depends, ccg); - } + } } -void -cmLocalUnixMakefileGenerator3 -::AppendCustomDepend(std::vector<std::string>& depends, - cmCustomCommandGenerator const& ccg) +void cmLocalUnixMakefileGenerator3::AppendCustomDepend( + std::vector<std::string>& depends, cmCustomCommandGenerator const& ccg) { - for(std::vector<std::string>::const_iterator d = ccg.GetDepends().begin(); - d != ccg.GetDepends().end(); ++d) - { + for (std::vector<std::string>::const_iterator d = ccg.GetDepends().begin(); + d != ccg.GetDepends().end(); ++d) { // Lookup the real name of the dependency in case it is a CMake target. std::string dep; - if(this->GetRealDependency(*d, this->ConfigName, - dep)) - { + if (this->GetRealDependency(*d, this->ConfigName, dep)) { depends.push_back(dep); - } } + } } -void -cmLocalUnixMakefileGenerator3 -::AppendCustomCommands(std::vector<std::string>& commands, - const std::vector<cmCustomCommand>& ccs, - cmGeneratorTarget* target, - cmLocalGenerator::RelativeRoot relative) +void cmLocalUnixMakefileGenerator3::AppendCustomCommands( + std::vector<std::string>& commands, const std::vector<cmCustomCommand>& ccs, + cmGeneratorTarget* target, cmLocalGenerator::RelativeRoot relative) { - for(std::vector<cmCustomCommand>::const_iterator i = ccs.begin(); - i != ccs.end(); ++i) - { + for (std::vector<cmCustomCommand>::const_iterator i = ccs.begin(); + i != ccs.end(); ++i) { cmCustomCommandGenerator ccg(*i, this->ConfigName, this); this->AppendCustomCommand(commands, ccg, target, true, relative); - } + } } -void -cmLocalUnixMakefileGenerator3 -::AppendCustomCommand(std::vector<std::string>& commands, - cmCustomCommandGenerator const& ccg, - cmGeneratorTarget* target, - bool echo_comment, - cmLocalGenerator::RelativeRoot relative, - std::ostream* content) +void cmLocalUnixMakefileGenerator3::AppendCustomCommand( + std::vector<std::string>& commands, cmCustomCommandGenerator const& ccg, + cmGeneratorTarget* target, bool echo_comment, + cmLocalGenerator::RelativeRoot relative, std::ostream* content) { // Optionally create a command to display the custom command's // comment text. This is used for pre-build, pre-link, and // post-build command comments. Custom build step commands have // their comments generated elsewhere. - if(echo_comment) - { + if (echo_comment) { const char* comment = ccg.GetComment(); - if(comment && *comment) - { + if (comment && *comment) { this->AppendEcho(commands, comment, cmLocalUnixMakefileGenerator3::EchoGenerate); - } } + } // if the command specified a working directory use it. - std::string dir = this->GetCurrentBinaryDirectory(); + std::string dir = this->GetCurrentBinaryDirectory(); std::string workingDir = ccg.GetWorkingDirectory(); - if(!workingDir.empty()) - { + if (!workingDir.empty()) { dir = workingDir; - } - if(content) - { + } + if (content) { *content << dir; - } + } // Add each command line to the set of commands. std::vector<std::string> commands1; - for(unsigned int c = 0; c < ccg.GetNumberOfCommands(); ++c) - { + for (unsigned int c = 0; c < ccg.GetNumberOfCommands(); ++c) { // Build the command line in a single string. std::string cmd = ccg.GetCommand(c); - if (!cmd.empty()) - { + if (!cmd.empty()) { // Use "call " before any invocations of .bat or .cmd files // invoked as custom commands in the WindowsShell. // bool useCall = false; - if (this->IsWindowsShell()) - { + if (this->IsWindowsShell()) { std::string suffix; - if (cmd.size() > 4) - { - suffix = cmSystemTools::LowerCase(cmd.substr(cmd.size()-4)); - if (suffix == ".bat" || suffix == ".cmd") - { + if (cmd.size() > 4) { + suffix = cmSystemTools::LowerCase(cmd.substr(cmd.size() - 4)); + if (suffix == ".bat" || suffix == ".cmd") { useCall = true; - } } } + } cmSystemTools::ReplaceString(cmd, "/./", "/"); // Convert the command to a relative path only if the current // working directory will be the start-output directory. bool had_slash = cmd.find("/") != cmd.npos; - if(workingDir.empty()) - { - cmd = this->Convert(cmd,START_OUTPUT); - } + if (workingDir.empty()) { + cmd = this->Convert(cmd, START_OUTPUT); + } bool has_slash = cmd.find("/") != cmd.npos; - if(had_slash && !has_slash) - { + if (had_slash && !has_slash) { // This command was specified as a path to a file in the // current directory. Add a leading "./" so it can run // without the current directory being in the search path. cmd = "./" + cmd; - } - std::string launcher = - this->MakeLauncher(ccg, target, - workingDir.empty()? START_OUTPUT : NONE); + } + std::string launcher = this->MakeLauncher( + ccg, target, workingDir.empty() ? START_OUTPUT : NONE); cmd = launcher + this->ConvertShellCommand(cmd, NONE); ccg.AppendArguments(c, cmd); - if(content) - { + if (content) { // Rule content does not include the launcher. - *content << (cmd.c_str()+launcher.size()); - } - if(this->BorlandMakeCurlyHack) - { + *content << (cmd.c_str() + launcher.size()); + } + if (this->BorlandMakeCurlyHack) { // Borland Make has a very strange bug. If the first curly // brace anywhere in the command string is a left curly, it // must be written {{} instead of just {. Otherwise some // curly braces are removed. The hack can be skipped if the // first curly brace is the last character. std::string::size_type lcurly = cmd.find("{"); - if(lcurly != cmd.npos && lcurly < (cmd.size()-1)) - { + if (lcurly != cmd.npos && lcurly < (cmd.size() - 1)) { std::string::size_type rcurly = cmd.find("}"); - if(rcurly == cmd.npos || rcurly > lcurly) - { + if (rcurly == cmd.npos || rcurly > lcurly) { // The first curly is a left curly. Use the hack. std::string hack_cmd = cmd.substr(0, lcurly); hack_cmd += "{{}"; - hack_cmd += cmd.substr(lcurly+1); + hack_cmd += cmd.substr(lcurly + 1); cmd = hack_cmd; - } } } - if (launcher.empty()) - { - if (useCall) - { + } + if (launcher.empty()) { + if (useCall) { cmd = "call " + cmd; - } - else if (this->IsNMake() && cmd[0]=='"') - { + } else if (this->IsNMake() && cmd[0] == '"') { cmd = "echo >nul && " + cmd; - } } - commands1.push_back(cmd); } + commands1.push_back(cmd); } + } // Setup the proper working directory for the commands. this->CreateCDCommand(commands1, dir.c_str(), relative); @@ -1157,18 +1005,16 @@ cmLocalUnixMakefileGenerator3 commands.insert(commands.end(), commands1.begin(), commands1.end()); } -std::string -cmLocalUnixMakefileGenerator3::MakeLauncher( - cmCustomCommandGenerator const& ccg, - cmGeneratorTarget* target, RelativeRoot relative) +std::string cmLocalUnixMakefileGenerator3::MakeLauncher( + cmCustomCommandGenerator const& ccg, cmGeneratorTarget* target, + RelativeRoot relative) { // Short-circuit if there is no launcher. const char* prop = "RULE_LAUNCH_CUSTOM"; const char* val = this->GetRuleLauncher(target, prop); - if(!(val && *val)) - { + if (!(val && *val)) { return ""; - } + } // Expand rules in the empty string. It may insert the launcher and // perform replacements. @@ -1177,65 +1023,56 @@ cmLocalUnixMakefileGenerator3::MakeLauncher( vars.CMTarget = target; std::string output; const std::vector<std::string>& outputs = ccg.GetOutputs(); - if(!outputs.empty()) - { + if (!outputs.empty()) { output = this->Convert(outputs[0], relative, SHELL); - } + } vars.Output = output.c_str(); std::string launcher; this->ExpandRuleVariables(launcher, vars); - if(!launcher.empty()) - { + if (!launcher.empty()) { launcher += " "; - } + } return launcher; } -void -cmLocalUnixMakefileGenerator3 -::AppendCleanCommand(std::vector<std::string>& commands, - const std::vector<std::string>& files, - cmGeneratorTarget* target, const char* filename) +void cmLocalUnixMakefileGenerator3::AppendCleanCommand( + std::vector<std::string>& commands, const std::vector<std::string>& files, + cmGeneratorTarget* target, const char* filename) { std::string cleanfile = this->GetCurrentBinaryDirectory(); cleanfile += "/"; cleanfile += this->GetTargetDirectory(target); cleanfile += "/cmake_clean"; - if(filename) - { + if (filename) { cleanfile += "_"; cleanfile += filename; - } + } cleanfile += ".cmake"; std::string cleanfilePath = this->Convert(cleanfile, FULL); cmsys::ofstream fout(cleanfilePath.c_str()); - if(!fout) - { + if (!fout) { cmSystemTools::Error("Could not create ", cleanfilePath.c_str()); - } - if(!files.empty()) - { + } + if (!files.empty()) { fout << "file(REMOVE_RECURSE\n"; - for(std::vector<std::string>::const_iterator f = files.begin(); - f != files.end(); ++f) - { - std::string fc = this->Convert(*f,START_OUTPUT,UNCHANGED); + for (std::vector<std::string>::const_iterator f = files.begin(); + f != files.end(); ++f) { + std::string fc = this->Convert(*f, START_OUTPUT, UNCHANGED); fout << " " << cmOutputConverter::EscapeForCMake(fc) << "\n"; - } - fout << ")\n"; } + fout << ")\n"; + } std::string remove = "$(CMAKE_COMMAND) -P "; remove += this->Convert(cleanfile, START_OUTPUT, SHELL); commands.push_back(remove); // For the main clean rule add per-language cleaning. - if(!filename) - { + if (!filename) { // Get the set of source languages in the target. std::set<std::string> languages; - target->GetLanguages(languages, - this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE")); + target->GetLanguages( + languages, this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE")); /* clang-format off */ fout << "\n" << "# Per-language clean rules from dependency scanning.\n" @@ -1244,23 +1081,19 @@ cmLocalUnixMakefileGenerator3 << "/cmake_clean_${lang}.cmake OPTIONAL)\n" << "endforeach()\n"; /* clang-format on */ - } + } } -void -cmLocalUnixMakefileGenerator3::AppendEcho(std::vector<std::string>& commands, - std::string const& text, - EchoColor color, - EchoProgress const* progress) +void cmLocalUnixMakefileGenerator3::AppendEcho( + std::vector<std::string>& commands, std::string const& text, EchoColor color, + EchoProgress const* progress) { // Choose the color for the text. std::string color_name; - if(this->GlobalGenerator->GetToolSupportsColor() && this->ColorMakefile) - { + if (this->GlobalGenerator->GetToolSupportsColor() && this->ColorMakefile) { // See cmake::ExecuteEchoColor in cmake.cxx for these options. // This color set is readable on both black and white backgrounds. - switch(color) - { + switch (color) { case EchoNormal: break; case EchoDepend: @@ -1278,47 +1111,39 @@ cmLocalUnixMakefileGenerator3::AppendEcho(std::vector<std::string>& commands, case EchoGlobal: color_name = "--cyan "; break; - } } + } // Echo one line at a time. std::string line; line.reserve(200); - for(const char* c = text.c_str();; ++c) - { - if(*c == '\n' || *c == '\0') - { + for (const char* c = text.c_str();; ++c) { + if (*c == '\n' || *c == '\0') { // Avoid writing a blank last line on end-of-string. - if(*c != '\0' || !line.empty()) - { + if (*c != '\0' || !line.empty()) { // Add a command to echo this line. std::string cmd; - if(color_name.empty() && !progress) - { + if (color_name.empty() && !progress) { // Use the native echo command. cmd = "@echo "; cmd += this->EscapeForShell(line, false, true); - } - else - { + } else { // Use cmake to echo the text in color. cmd = "@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) "; cmd += color_name; - if (progress) - { + if (progress) { cmd += "--progress-dir="; - cmd += this->Convert(progress->Dir, - cmLocalGenerator::FULL, + cmd += this->Convert(progress->Dir, cmLocalGenerator::FULL, cmLocalGenerator::SHELL); cmd += " "; cmd += "--progress-num="; cmd += progress->Arg; cmd += " "; - } - cmd += this->EscapeForShell(line); } - commands.push_back(cmd); + cmd += this->EscapeForShell(line); } + commands.push_back(cmd); + } // Reset the line to emtpy. line = ""; @@ -1327,22 +1152,18 @@ cmLocalUnixMakefileGenerator3::AppendEcho(std::vector<std::string>& commands, progress = 0; // Terminate on end-of-string. - if(*c == '\0') - { + if (*c == '\0') { return; - } } - else if(*c != '\r') - { + } else if (*c != '\r') { // Append this character to the current line. line += *c; - } } + } } -std::string -cmLocalUnixMakefileGenerator3 -::CreateMakeVariable(const std::string& sin, const std::string& s2in) +std::string cmLocalUnixMakefileGenerator3::CreateMakeVariable( + const std::string& sin, const std::string& s2in) { std::string s = sin; std::string s2 = s2in; @@ -1351,27 +1172,24 @@ cmLocalUnixMakefileGenerator3 // if there is no restriction on the length of make variables // and there are no "." characters in the string, then return the // unmodified combination. - if((!this->MakefileVariableSize && unmodified.find('.') == s.npos) - && (!this->MakefileVariableSize && unmodified.find('+') == s.npos) - && (!this->MakefileVariableSize && unmodified.find('-') == s.npos)) - { + if ((!this->MakefileVariableSize && unmodified.find('.') == s.npos) && + (!this->MakefileVariableSize && unmodified.find('+') == s.npos) && + (!this->MakefileVariableSize && unmodified.find('-') == s.npos)) { return unmodified; - } + } // see if the variable has been defined before and return // the modified version of the variable std::map<std::string, std::string>::iterator i = this->MakeVariableMap.find(unmodified); - if(i != this->MakeVariableMap.end()) - { + if (i != this->MakeVariableMap.end()) { return i->second; - } + } // start with the unmodified variable std::string ret = unmodified; // if this there is no value for this->MakefileVariableSize then // the string must have bad characters in it - if(!this->MakefileVariableSize) - { + if (!this->MakefileVariableSize) { cmSystemTools::ReplaceString(ret, ".", "_"); cmSystemTools::ReplaceString(ret, "-", "__"); cmSystemTools::ReplaceString(ret, "+", "___"); @@ -1379,53 +1197,47 @@ cmLocalUnixMakefileGenerator3 char buffer[5]; // make sure the _ version is not already used, if // it is used then add number to the end of the variable - while(this->ShortMakeVariableMap.count(ret) && ni < 1000) - { + while (this->ShortMakeVariableMap.count(ret) && ni < 1000) { ++ni; sprintf(buffer, "%04d", ni); ret = unmodified + buffer; - } + } this->ShortMakeVariableMap[ret] = "1"; this->MakeVariableMap[unmodified] = ret; return ret; - } + } // if the string is greater than 32 chars it is an invalid variable name // for borland make - if(static_cast<int>(ret.size()) > this->MakefileVariableSize) - { + if (static_cast<int>(ret.size()) > this->MakefileVariableSize) { int keep = this->MakefileVariableSize - 8; int size = keep + 3; std::string str1 = s; std::string str2 = s2; // we must shorten the combined string by 4 characters // keep no more than 24 characters from the second string - if(static_cast<int>(str2.size()) > keep) - { + if (static_cast<int>(str2.size()) > keep) { str2 = str2.substr(0, keep); - } - if(static_cast<int>(str1.size()) + static_cast<int>(str2.size()) > size) - { + } + if (static_cast<int>(str1.size()) + static_cast<int>(str2.size()) > size) { str1 = str1.substr(0, size - str2.size()); - } + } char buffer[5]; int ni = 0; sprintf(buffer, "%04d", ni); ret = str1 + str2 + buffer; - while(this->ShortMakeVariableMap.count(ret) && ni < 1000) - { + while (this->ShortMakeVariableMap.count(ret) && ni < 1000) { ++ni; sprintf(buffer, "%04d", ni); ret = str1 + str2 + buffer; - } - if(ni == 1000) - { + } + if (ni == 1000) { cmSystemTools::Error("Borland makefile variable length too long"); return unmodified; - } + } // once an unused variable is found this->ShortMakeVariableMap[ret] = "1"; - } + } // always make an entry into the unmodified to variable map this->MakeVariableMap[unmodified] = ret; return ret; @@ -1436,11 +1248,10 @@ bool cmLocalUnixMakefileGenerator3::UpdateDependencies(const char* tgtInfo, bool color) { // read in the target info file - if(!this->Makefile->ReadListFile(tgtInfo) || - cmSystemTools::GetErrorOccuredFlag()) - { + if (!this->Makefile->ReadListFile(tgtInfo) || + cmSystemTools::GetErrorOccuredFlag()) { cmSystemTools::Error("Target DependInfo.cmake file not found"); - } + } // Check if any multiple output pairs have a missing file. this->CheckMultipleOutputs(verbose); @@ -1457,19 +1268,16 @@ bool cmLocalUnixMakefileGenerator3::UpdateDependencies(const char* tgtInfo, cmFileTimeComparison* ftc = this->GlobalGenerator->GetCMakeInstance()->GetFileComparison(); { - int result; - if(!ftc->FileTimeCompare(internalDependFile.c_str(), tgtInfo, &result) || - result < 0) - { - if(verbose) - { - std::ostringstream msg; - msg << "Dependee \"" << tgtInfo - << "\" is newer than depender \"" - << internalDependFile << "\"." << std::endl; - cmSystemTools::Stdout(msg.str().c_str()); + int result; + if (!ftc->FileTimeCompare(internalDependFile.c_str(), tgtInfo, &result) || + result < 0) { + if (verbose) { + std::ostringstream msg; + msg << "Dependee \"" << tgtInfo << "\" is newer than depender \"" + << internalDependFile << "\"." << std::endl; + cmSystemTools::Stdout(msg.str().c_str()); } - needRescanDependInfo = true; + needRescanDependInfo = true; } } @@ -1480,19 +1288,17 @@ bool cmLocalUnixMakefileGenerator3::UpdateDependencies(const char* tgtInfo, dirInfoFile += cmake::GetCMakeFilesDirectory(); dirInfoFile += "/CMakeDirectoryInformation.cmake"; { - int result; - if(!ftc->FileTimeCompare(internalDependFile.c_str(), - dirInfoFile.c_str(), &result) || result < 0) - { - if(verbose) - { - std::ostringstream msg; - msg << "Dependee \"" << dirInfoFile - << "\" is newer than depender \"" - << internalDependFile << "\"." << std::endl; - cmSystemTools::Stdout(msg.str().c_str()); + int result; + if (!ftc->FileTimeCompare(internalDependFile.c_str(), dirInfoFile.c_str(), + &result) || + result < 0) { + if (verbose) { + std::ostringstream msg; + msg << "Dependee \"" << dirInfoFile << "\" is newer than depender \"" + << internalDependFile << "\"." << std::endl; + cmSystemTools::Stdout(msg.str().c_str()); } - needRescanDirInfo = true; + needRescanDirInfo = true; } } @@ -1502,8 +1308,7 @@ bool cmLocalUnixMakefileGenerator3::UpdateDependencies(const char* tgtInfo, // not be considered. std::map<std::string, cmDepends::DependencyVector> validDependencies; bool needRescanDependencies = false; - if (needRescanDirInfo == false) - { + if (needRescanDirInfo == false) { cmDependsC checker; checker.SetVerbose(verbose); checker.SetFileComparison(ftc); @@ -1517,34 +1322,30 @@ bool cmLocalUnixMakefileGenerator3::UpdateDependencies(const char* tgtInfo, // dependency vector. This means that in the normal case, when only // few or one file have been edited, then also only this one file is // actually scanned again, instead of all files for this target. - needRescanDependencies = !checker.Check(dependFile.c_str(), - internalDependFile.c_str(), - validDependencies); - } + needRescanDependencies = !checker.Check( + dependFile.c_str(), internalDependFile.c_str(), validDependencies); + } - if(needRescanDependInfo || needRescanDirInfo || needRescanDependencies) - { + if (needRescanDependInfo || needRescanDirInfo || needRescanDependencies) { // The dependencies must be regenerated. std::string targetName = cmSystemTools::GetFilenameName(dir); - targetName = targetName.substr(0, targetName.length()-4); + targetName = targetName.substr(0, targetName.length() - 4); std::string message = "Scanning dependencies of target "; message += targetName; - cmSystemTools::MakefileColorEcho( - cmsysTerminal_Color_ForegroundMagenta | - cmsysTerminal_Color_ForegroundBold, - message.c_str(), true, color); + cmSystemTools::MakefileColorEcho(cmsysTerminal_Color_ForegroundMagenta | + cmsysTerminal_Color_ForegroundBold, + message.c_str(), true, color); return this->ScanDependencies(dir.c_str(), validDependencies); - } + } // The dependencies are already up-to-date. return true; } -bool -cmLocalUnixMakefileGenerator3 -::ScanDependencies(const char* targetDir, - std::map<std::string, cmDepends::DependencyVector>& validDeps) +bool cmLocalUnixMakefileGenerator3::ScanDependencies( + const char* targetDir, + std::map<std::string, cmDepends::DependencyVector>& validDeps) { // Read the directory information file. cmMakefile* mf = this->Makefile; @@ -1552,42 +1353,34 @@ cmLocalUnixMakefileGenerator3 std::string dirInfoFile = this->GetCurrentBinaryDirectory(); dirInfoFile += cmake::GetCMakeFilesDirectory(); dirInfoFile += "/CMakeDirectoryInformation.cmake"; - if(mf->ReadListFile(dirInfoFile.c_str()) && - !cmSystemTools::GetErrorOccuredFlag()) - { + if (mf->ReadListFile(dirInfoFile.c_str()) && + !cmSystemTools::GetErrorOccuredFlag()) { haveDirectoryInfo = true; - } + } // Lookup useful directory information. - if(haveDirectoryInfo) - { + if (haveDirectoryInfo) { // Test whether we need to force Unix paths. - if(const char* force = mf->GetDefinition("CMAKE_FORCE_UNIX_PATHS")) - { - if(!cmSystemTools::IsOff(force)) - { + if (const char* force = mf->GetDefinition("CMAKE_FORCE_UNIX_PATHS")) { + if (!cmSystemTools::IsOff(force)) { cmSystemTools::SetForceUnixPaths(true); - } } + } // Setup relative path top directories. - if(const char* relativePathTopSource = - mf->GetDefinition("CMAKE_RELATIVE_PATH_TOP_SOURCE")) - { - this->StateSnapshot.GetDirectory() - .SetRelativePathTopSource(relativePathTopSource); - } - if(const char* relativePathTopBinary = - mf->GetDefinition("CMAKE_RELATIVE_PATH_TOP_BINARY")) - { - this->StateSnapshot.GetDirectory() - .SetRelativePathTopBinary(relativePathTopBinary); - } + if (const char* relativePathTopSource = + mf->GetDefinition("CMAKE_RELATIVE_PATH_TOP_SOURCE")) { + this->StateSnapshot.GetDirectory().SetRelativePathTopSource( + relativePathTopSource); } - else - { - cmSystemTools::Error("Directory Information file not found"); + if (const char* relativePathTopBinary = + mf->GetDefinition("CMAKE_RELATIVE_PATH_TOP_BINARY")) { + this->StateSnapshot.GetDirectory().SetRelativePathTopBinary( + relativePathTopBinary); } + } else { + cmSystemTools::Error("Directory Information file not found"); + } // create the file stream for the depends file std::string dir = targetDir; @@ -1598,67 +1391,59 @@ cmLocalUnixMakefileGenerator3 ruleFileNameFull += "/depend.make"; cmGeneratedFileStream ruleFileStream(ruleFileNameFull.c_str()); ruleFileStream.SetCopyIfDifferent(true); - if(!ruleFileStream) - { + if (!ruleFileStream) { return false; - } + } // Open the cmake dependency tracking file. This should not be // copy-if-different because dependencies are re-scanned when it is // older than the DependInfo.cmake. std::string internalRuleFileNameFull = dir; internalRuleFileNameFull += "/depend.internal"; - cmGeneratedFileStream - internalRuleFileStream(internalRuleFileNameFull.c_str()); - if(!internalRuleFileStream) - { + cmGeneratedFileStream internalRuleFileStream( + internalRuleFileNameFull.c_str()); + if (!internalRuleFileStream) { return false; - } + } this->WriteDisclaimer(ruleFileStream); this->WriteDisclaimer(internalRuleFileStream); // for each language we need to scan, scan it - const char *langStr = mf->GetSafeDefinition("CMAKE_DEPENDS_LANGUAGES"); + const char* langStr = mf->GetSafeDefinition("CMAKE_DEPENDS_LANGUAGES"); std::vector<std::string> langs; cmSystemTools::ExpandListArgument(langStr, langs); - for (std::vector<std::string>::iterator li = - langs.begin(); li != langs.end(); ++li) - { + for (std::vector<std::string>::iterator li = langs.begin(); + li != langs.end(); ++li) { // construct the checker std::string lang = *li; // Create the scanner for this language - cmDepends *scanner = 0; - if(lang == "C" || lang == "CXX" || lang == "RC" || lang == "ASM") - { + cmDepends* scanner = 0; + if (lang == "C" || lang == "CXX" || lang == "RC" || lang == "ASM") { // TODO: Handle RC (resource files) dependencies correctly. scanner = new cmDependsC(this, targetDir, lang, &validDeps); - } + } #ifdef CMAKE_BUILD_WITH_CMAKE - else if(lang == "Fortran") - { + else if (lang == "Fortran") { scanner = new cmDependsFortran(this); - } - else if(lang == "Java") - { + } else if (lang == "Java") { scanner = new cmDependsJava(); - } + } #endif - if (scanner) - { + if (scanner) { scanner->SetLocalGenerator(this); - scanner->SetFileComparison - (this->GlobalGenerator->GetCMakeInstance()->GetFileComparison()); + scanner->SetFileComparison( + this->GlobalGenerator->GetCMakeInstance()->GetFileComparison()); scanner->SetLanguage(lang); scanner->SetTargetDirectory(dir.c_str()); scanner->Write(ruleFileStream, internalRuleFileStream); // free the scanner for this language delete scanner; - } } + } return true; } @@ -1669,68 +1454,62 @@ void cmLocalUnixMakefileGenerator3::CheckMultipleOutputs(bool verbose) // Get the string listing the multiple output pairs. const char* pairs_string = mf->GetDefinition("CMAKE_MULTIPLE_OUTPUT_PAIRS"); - if(!pairs_string) - { + if (!pairs_string) { return; - } + } // Convert the string to a list and preserve empty entries. std::vector<std::string> pairs; cmSystemTools::ExpandListArgument(pairs_string, pairs, true); - for(std::vector<std::string>::const_iterator i = pairs.begin(); - i != pairs.end() && (i+1) != pairs.end();) - { + for (std::vector<std::string>::const_iterator i = pairs.begin(); + i != pairs.end() && (i + 1) != pairs.end();) { const std::string& depender = *i++; const std::string& dependee = *i++; // If the depender is missing then delete the dependee to make // sure both will be regenerated. - if(cmSystemTools::FileExists(dependee.c_str()) && - !cmSystemTools::FileExists(depender.c_str())) - { - if(verbose) - { + if (cmSystemTools::FileExists(dependee.c_str()) && + !cmSystemTools::FileExists(depender.c_str())) { + if (verbose) { std::ostringstream msg; msg << "Deleting primary custom command output \"" << dependee - << "\" because another output \"" - << depender << "\" does not exist." << std::endl; + << "\" because another output \"" << depender + << "\" does not exist." << std::endl; cmSystemTools::Stdout(msg.str().c_str()); - } - cmSystemTools::RemoveFile(dependee); } + cmSystemTools::RemoveFile(dependee); } + } } -void cmLocalUnixMakefileGenerator3 -::WriteLocalAllRules(std::ostream& ruleFileStream) +void cmLocalUnixMakefileGenerator3::WriteLocalAllRules( + std::ostream& ruleFileStream) { this->WriteDisclaimer(ruleFileStream); // 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.push_back("all"); + // Just depend on the all target to drive the build. + std::vector<std::string> depends; + std::vector<std::string> no_commands; + depends.push_back("all"); - // Write the rule. - this->WriteMakeRule(ruleFileStream, - "Default target executed when no arguments are " - "given to make.", - "default_target", - depends, - no_commands, true); - - // Help out users that try "gmake target1 target2 -j". - cmGlobalUnixMakefileGenerator3* gg = - static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator); - if(gg->AllowNotParallel()) - { - std::vector<std::string> no_depends; + // Write the rule. this->WriteMakeRule(ruleFileStream, - "Allow only one \"make -f Makefile2\" at a time, but pass parallelism.", - ".NOTPARALLEL", no_depends, no_commands, false); + "Default target executed when no arguments are " + "given to make.", + "default_target", depends, no_commands, true); + + // Help out users that try "gmake target1 target2 -j". + cmGlobalUnixMakefileGenerator3* gg = + static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator); + if (gg->AllowNotParallel()) { + std::vector<std::string> no_depends; + this->WriteMakeRule(ruleFileStream, "Allow only one \"make -f " + "Makefile2\" at a time, but pass " + "parallelism.", + ".NOTPARALLEL", no_depends, no_commands, false); } } @@ -1739,25 +1518,21 @@ void cmLocalUnixMakefileGenerator3 // Include the progress variables for the target. // Write all global targets this->WriteDivider(ruleFileStream); - ruleFileStream - << "# Targets provided globally by CMake.\n" - << "\n"; + ruleFileStream << "# Targets provided globally by CMake.\n" + << "\n"; std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets(); std::vector<cmGeneratorTarget*>::iterator glIt; - for ( glIt = targets.begin(); glIt != targets.end(); ++ glIt ) - { - if ( (*glIt)->GetType() == cmState::GLOBAL_TARGET ) - { - std::string targetString = "Special rule for the target " + - (*glIt)->GetName(); + for (glIt = targets.begin(); glIt != targets.end(); ++glIt) { + if ((*glIt)->GetType() == cmState::GLOBAL_TARGET) { + std::string targetString = + "Special rule for the target " + (*glIt)->GetName(); std::vector<std::string> commands; std::vector<std::string> depends; const char* text = (*glIt)->GetProperty("EchoString"); - if ( !text ) - { + if (!text) { text = "Running external command ..."; - } + } depends.insert(depends.end(), (*glIt)->GetUtilities().begin(), (*glIt)->GetUtilities().end()); this->AppendEcho(commands, text, @@ -1766,43 +1541,33 @@ void cmLocalUnixMakefileGenerator3 cmGeneratorTarget* gt = *glIt; // Global targets store their rules in pre- and post-build commands. - this->AppendCustomDepends(depends, - gt->GetPreBuildCommands()); - this->AppendCustomDepends(depends, - gt->GetPostBuildCommands()); - this->AppendCustomCommands(commands, - gt->GetPreBuildCommands(), - gt, + this->AppendCustomDepends(depends, gt->GetPreBuildCommands()); + this->AppendCustomDepends(depends, gt->GetPostBuildCommands()); + this->AppendCustomCommands(commands, gt->GetPreBuildCommands(), gt, cmLocalGenerator::START_OUTPUT); - this->AppendCustomCommands(commands, - gt->GetPostBuildCommands(), - gt, + this->AppendCustomCommands(commands, gt->GetPostBuildCommands(), gt, cmLocalGenerator::START_OUTPUT); std::string targetName = gt->GetName(); - this->WriteMakeRule(ruleFileStream, targetString.c_str(), - targetName, depends, commands, true); + this->WriteMakeRule(ruleFileStream, targetString.c_str(), targetName, + depends, commands, true); // Provide a "/fast" version of the target. depends.clear(); - if((targetName == "install") - || (targetName == "install_local") - || (targetName == "install_strip")) - { + if ((targetName == "install") || (targetName == "install_local") || + (targetName == "install_strip")) { // Provide a fast install target that does not depend on all // but has the same command. depends.push_back("preinstall/fast"); - } - else - { + } else { // Just forward to the real target so at least it will work. depends.push_back(targetName); commands.clear(); - } - targetName += "/fast"; - this->WriteMakeRule(ruleFileStream, targetString.c_str(), - targetName, depends, commands, true); } + targetName += "/fast"; + this->WriteMakeRule(ruleFileStream, targetString.c_str(), targetName, + depends, commands, true); } + } std::vector<std::string> depends; std::vector<std::string> commands; @@ -1815,52 +1580,46 @@ void cmLocalUnixMakefileGenerator3 std::string progressDir = this->GetBinaryDirectory(); progressDir += cmake::GetCMakeFilesDirectory(); - { + { std::ostringstream progCmd; - progCmd << - "$(CMAKE_COMMAND) -E cmake_progress_start "; - progCmd << this->Convert(progressDir, - cmLocalGenerator::FULL, + progCmd << "$(CMAKE_COMMAND) -E cmake_progress_start "; + progCmd << this->Convert(progressDir, cmLocalGenerator::FULL, cmLocalGenerator::SHELL); std::string progressFile = cmake::GetCMakeFilesDirectory(); progressFile += "/progress.marks"; - std::string progressFileNameFull = - this->ConvertToFullPath(progressFile); - progCmd << " " << this->Convert(progressFileNameFull, - cmLocalGenerator::FULL, - cmLocalGenerator::SHELL); + std::string progressFileNameFull = this->ConvertToFullPath(progressFile); + progCmd << " " + << this->Convert(progressFileNameFull, cmLocalGenerator::FULL, + cmLocalGenerator::SHELL); commands.push_back(progCmd.str()); - } + } std::string mf2Dir = cmake::GetCMakeFilesDirectoryPostSlash(); mf2Dir += "Makefile2"; - commands.push_back(this->GetRecursiveMakeCall(mf2Dir.c_str(), - recursiveTarget)); - this->CreateCDCommand(commands, - this->GetBinaryDirectory(), + commands.push_back( + this->GetRecursiveMakeCall(mf2Dir.c_str(), recursiveTarget)); + this->CreateCDCommand(commands, this->GetBinaryDirectory(), cmLocalGenerator::START_OUTPUT); - { + { std::ostringstream progCmd; progCmd << "$(CMAKE_COMMAND) -E cmake_progress_start "; // # 0 - progCmd << this->Convert(progressDir, - cmLocalGenerator::FULL, + progCmd << this->Convert(progressDir, cmLocalGenerator::FULL, cmLocalGenerator::SHELL); progCmd << " 0"; commands.push_back(progCmd.str()); - } - this->WriteMakeRule(ruleFileStream, "The main all target", "all", - depends, commands, true); + } + this->WriteMakeRule(ruleFileStream, "The main all target", "all", depends, + commands, true); // Write the clean rule. recursiveTarget = this->GetCurrentBinaryDirectory(); recursiveTarget += "/clean"; commands.clear(); depends.clear(); - commands.push_back(this->GetRecursiveMakeCall(mf2Dir.c_str(), - recursiveTarget)); - this->CreateCDCommand(commands, - this->GetBinaryDirectory(), - cmLocalGenerator::START_OUTPUT); + commands.push_back( + this->GetRecursiveMakeCall(mf2Dir.c_str(), recursiveTarget)); + this->CreateCDCommand(commands, this->GetBinaryDirectory(), + cmLocalGenerator::START_OUTPUT); this->WriteMakeRule(ruleFileStream, "The main clean target", "clean", depends, commands, true); commands.clear(); @@ -1876,20 +1635,16 @@ void cmLocalUnixMakefileGenerator3 depends.clear(); const char* noall = this->Makefile->GetDefinition("CMAKE_SKIP_INSTALL_ALL_DEPENDENCY"); - if(!noall || cmSystemTools::IsOff(noall)) - { + if (!noall || cmSystemTools::IsOff(noall)) { // Drive the build before installing. depends.push_back("all"); - } - else - { + } else { // At least make sure the build system is up to date. depends.push_back("cmake_check_build_system"); - } - commands.push_back - (this->GetRecursiveMakeCall(mf2Dir.c_str(), recursiveTarget)); - this->CreateCDCommand(commands, - this->GetBinaryDirectory(), + } + commands.push_back( + this->GetRecursiveMakeCall(mf2Dir.c_str(), recursiveTarget)); + this->CreateCDCommand(commands, this->GetBinaryDirectory(), cmLocalGenerator::START_OUTPUT); this->WriteMakeRule(ruleFileStream, "Prepare targets for installation.", "preinstall", depends, commands, true); @@ -1905,28 +1660,24 @@ void cmLocalUnixMakefileGenerator3 std::string runRule = "$(CMAKE_COMMAND) -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)"; runRule += " --check-build-system "; - runRule += this->Convert(cmakefileName,cmLocalGenerator::NONE, + runRule += this->Convert(cmakefileName, cmLocalGenerator::NONE, cmLocalGenerator::SHELL); runRule += " 1"; commands.push_back(runRule); - this->CreateCDCommand(commands, - this->GetBinaryDirectory(), + this->CreateCDCommand(commands, this->GetBinaryDirectory(), cmLocalGenerator::START_OUTPUT); - this->WriteMakeRule(ruleFileStream, "clear depends", - "depend", - depends, commands, true); + this->WriteMakeRule(ruleFileStream, "clear depends", "depend", depends, + commands, true); } - void cmLocalUnixMakefileGenerator3::ClearDependencies(cmMakefile* mf, bool verbose) { // Get the list of target files to check const char* infoDef = mf->GetDefinition("CMAKE_DEPEND_INFO_FILES"); - if(!infoDef) - { + if (!infoDef) { return; - } + } std::vector<std::string> files; cmSystemTools::ExpandListArgument(infoDef, files); @@ -1934,9 +1685,8 @@ void cmLocalUnixMakefileGenerator3::ClearDependencies(cmMakefile* mf, // dependencies for that target. cmDepends clearer; clearer.SetVerbose(verbose); - for(std::vector<std::string>::iterator l = files.begin(); - l != files.end(); ++l) - { + for (std::vector<std::string>::iterator l = files.begin(); l != files.end(); + ++l) { std::string dir = cmSystemTools::GetFilenamePath(*l); // Clear the implicit dependency makefile. @@ -1947,64 +1697,60 @@ void cmLocalUnixMakefileGenerator3::ClearDependencies(cmMakefile* mf, // regeneration. std::string internalDependFile = dir + "/depend.internal"; cmSystemTools::RemoveFile(internalDependFile); - } + } } - -namespace +namespace { +// Helper predicate for removing absolute paths that don't point to the +// source or binary directory. It is used when CMAKE_DEPENDS_IN_PROJECT_ONLY +// is set ON, to only consider in-project dependencies during the build. +class NotInProjectDir { - // Helper predicate for removing absolute paths that don't point to the - // source or binary directory. It is used when CMAKE_DEPENDS_IN_PROJECT_ONLY - // is set ON, to only consider in-project dependencies during the build. - class NotInProjectDir +public: + // Constructor with the source and binary directory's path + NotInProjectDir(const std::string& sourceDir, const std::string& binaryDir) + : SourceDir(sourceDir) + , BinaryDir(binaryDir) { - public: - // Constructor with the source and binary directory's path - NotInProjectDir(const std::string& sourceDir, - const std::string& binaryDir) - : SourceDir(sourceDir), BinaryDir(binaryDir) {} - - // Operator evaluating the predicate - bool operator()(const std::string& path) const - { - // Keep all relative paths: - if(!cmSystemTools::FileIsFullPath(path)) - { - return false; - } - // If it's an absolute path, check if it starts with the source - // direcotory: - return (!(IsInDirectory(SourceDir, path)|| - IsInDirectory(BinaryDir, path))); - } + } - private: - // Helper function used by the predicate - static bool IsInDirectory(const std::string& baseDir, - const std::string& testDir) - { - // First check if the test directory "starts with" the base directory: - if (testDir.find(baseDir) != 0) - { - return false; - } - // If it does, then check that it's either the same string, or that the - // next character is a slash: - return ((testDir.size() == baseDir.size())|| - (testDir[baseDir.size()] == '/')); - } + // Operator evaluating the predicate + bool operator()(const std::string& path) const + { + // Keep all relative paths: + if (!cmSystemTools::FileIsFullPath(path)) { + return false; + } + // If it's an absolute path, check if it starts with the source + // direcotory: + return ( + !(IsInDirectory(SourceDir, path) || IsInDirectory(BinaryDir, path))); + } - // The path to the source directory - std::string SourceDir; - // The path to the binary directory - std::string BinaryDir; - }; -} +private: + // Helper function used by the predicate + static bool IsInDirectory(const std::string& baseDir, + const std::string& testDir) + { + // First check if the test directory "starts with" the base directory: + if (testDir.find(baseDir) != 0) { + return false; + } + // If it does, then check that it's either the same string, or that the + // next character is a slash: + return ((testDir.size() == baseDir.size()) || + (testDir[baseDir.size()] == '/')); + } + // The path to the source directory + std::string SourceDir; + // The path to the binary directory + std::string BinaryDir; +}; +} -void cmLocalUnixMakefileGenerator3 -::WriteDependLanguageInfo(std::ostream& cmakefileStream, - cmGeneratorTarget* target) +void cmLocalUnixMakefileGenerator3::WriteDependLanguageInfo( + std::ostream& cmakefileStream, cmGeneratorTarget* target) { ImplicitDependLanguageMap const& implicitLangs = this->GetImplicitDepends(target); @@ -2012,36 +1758,30 @@ void cmLocalUnixMakefileGenerator3 // list the languages cmakefileStream << "# The set of languages for which implicit dependencies are needed:\n"; - cmakefileStream - << "set(CMAKE_DEPENDS_LANGUAGES\n"; - for(ImplicitDependLanguageMap::const_iterator - l = implicitLangs.begin(); l != implicitLangs.end(); ++l) - { + cmakefileStream << "set(CMAKE_DEPENDS_LANGUAGES\n"; + for (ImplicitDependLanguageMap::const_iterator l = implicitLangs.begin(); + l != implicitLangs.end(); ++l) { cmakefileStream << " \"" << l->first << "\"\n"; - } + } cmakefileStream << " )\n"; // now list the files for each language cmakefileStream << "# The set of files for implicit dependencies of each language:\n"; - for(ImplicitDependLanguageMap::const_iterator - l = implicitLangs.begin(); l != implicitLangs.end(); ++l) - { - cmakefileStream - << "set(CMAKE_DEPENDS_CHECK_" << l->first << "\n"; + for (ImplicitDependLanguageMap::const_iterator l = implicitLangs.begin(); + l != implicitLangs.end(); ++l) { + cmakefileStream << "set(CMAKE_DEPENDS_CHECK_" << l->first << "\n"; ImplicitDependFileMap const& implicitPairs = l->second; // for each file pair - for(ImplicitDependFileMap::const_iterator pi = implicitPairs.begin(); - pi != implicitPairs.end(); ++pi) - { - for(cmDepends::DependencyVector::const_iterator di = pi->second.begin(); - di != pi->second.end(); ++ di) - { + for (ImplicitDependFileMap::const_iterator pi = implicitPairs.begin(); + pi != implicitPairs.end(); ++pi) { + for (cmDepends::DependencyVector::const_iterator di = pi->second.begin(); + di != pi->second.end(); ++di) { cmakefileStream << " \"" << *di << "\" "; cmakefileStream << "\"" << pi->first << "\"\n"; - } } + } cmakefileStream << " )\n"; // Tell the dependency scanner what compiler is used. @@ -2049,138 +1789,112 @@ void cmLocalUnixMakefileGenerator3 cidVar += l->first; cidVar += "_COMPILER_ID"; const char* cid = this->Makefile->GetDefinition(cidVar); - if(cid && *cid) - { - cmakefileStream - << "set(CMAKE_" << l->first << "_COMPILER_ID \"" - << cid << "\")\n"; - } + if (cid && *cid) { + cmakefileStream << "set(CMAKE_" << l->first << "_COMPILER_ID \"" << cid + << "\")\n"; + } // Build a list of preprocessor definitions for the target. std::set<std::string> defines; - this->AddCompileDefinitions(defines, target, - this->ConfigName, l->first); - if(!defines.empty()) - { + this->AddCompileDefinitions(defines, target, this->ConfigName, l->first); + if (!defines.empty()) { /* clang-format off */ cmakefileStream << "\n" << "# Preprocessor definitions for this target.\n" << "set(CMAKE_TARGET_DEFINITIONS_" << l->first << "\n"; /* clang-format on */ - for(std::set<std::string>::const_iterator di = defines.begin(); - di != defines.end(); ++di) - { - cmakefileStream - << " " << cmOutputConverter::EscapeForCMake(*di) << "\n"; - } - cmakefileStream - << " )\n"; + for (std::set<std::string>::const_iterator di = defines.begin(); + di != defines.end(); ++di) { + cmakefileStream << " " << cmOutputConverter::EscapeForCMake(*di) + << "\n"; } + cmakefileStream << " )\n"; + } // Target-specific include directories: - cmakefileStream - << "\n" - << "# The include file search paths:\n"; - cmakefileStream - << "set(CMAKE_" << l->first << "_TARGET_INCLUDE_PATH\n"; + cmakefileStream << "\n" + << "# The include file search paths:\n"; + cmakefileStream << "set(CMAKE_" << l->first << "_TARGET_INCLUDE_PATH\n"; std::vector<std::string> includes; - const std::string& config = this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"); - this->GetIncludeDirectories(includes, target, - l->first, config); - if(this->Makefile->IsOn("CMAKE_DEPENDS_IN_PROJECT_ONLY")) - { + this->GetIncludeDirectories(includes, target, l->first, config); + if (this->Makefile->IsOn("CMAKE_DEPENDS_IN_PROJECT_ONLY")) { const char* sourceDir = this->GetState()->GetSourceDirectory(); const char* binaryDir = this->GetState()->GetBinaryDirectory(); std::vector<std::string>::iterator itr = std::remove_if(includes.begin(), includes.end(), ::NotInProjectDir(sourceDir, binaryDir)); includes.erase(itr, includes.end()); - } - for(std::vector<std::string>::iterator i = includes.begin(); - i != includes.end(); ++i) - { - cmakefileStream - << " \"" - << this->Convert(*i, cmLocalGenerator::HOME_OUTPUT) - << "\"\n"; - } - cmakefileStream - << " )\n"; } + for (std::vector<std::string>::iterator i = includes.begin(); + i != includes.end(); ++i) { + cmakefileStream << " \"" + << this->Convert(*i, cmLocalGenerator::HOME_OUTPUT) + << "\"\n"; + } + cmakefileStream << " )\n"; + } // Store include transform rule properties. Write the directory // rules first because they may be overridden by later target rules. std::vector<std::string> transformRules; - if(const char* xform = - this->Makefile->GetProperty("IMPLICIT_DEPENDS_INCLUDE_TRANSFORM")) - { + if (const char* xform = + this->Makefile->GetProperty("IMPLICIT_DEPENDS_INCLUDE_TRANSFORM")) { cmSystemTools::ExpandListArgument(xform, transformRules); - } - if(const char* xform = - target->GetProperty("IMPLICIT_DEPENDS_INCLUDE_TRANSFORM")) - { + } + if (const char* xform = + target->GetProperty("IMPLICIT_DEPENDS_INCLUDE_TRANSFORM")) { cmSystemTools::ExpandListArgument(xform, transformRules); + } + if (!transformRules.empty()) { + cmakefileStream << "set(CMAKE_INCLUDE_TRANSFORMS\n"; + for (std::vector<std::string>::const_iterator tri = transformRules.begin(); + tri != transformRules.end(); ++tri) { + cmakefileStream << " " << cmOutputConverter::EscapeForCMake(*tri) + << "\n"; } - if(!transformRules.empty()) - { - cmakefileStream - << "set(CMAKE_INCLUDE_TRANSFORMS\n"; - for(std::vector<std::string>::const_iterator tri = transformRules.begin(); - tri != transformRules.end(); ++tri) - { - cmakefileStream << " " - << cmOutputConverter::EscapeForCMake(*tri) << "\n"; - } - cmakefileStream - << " )\n"; - } + cmakefileStream << " )\n"; + } } void cmLocalUnixMakefileGenerator3::WriteDisclaimer(std::ostream& os) { - os - << "# CMAKE generated file: DO NOT EDIT!\n" - << "# Generated by \"" << this->GlobalGenerator->GetName() << "\"" - << " Generator, CMake Version " - << cmVersion::GetMajorVersion() << "." - << cmVersion::GetMinorVersion() << "\n\n"; + os << "# CMAKE generated file: DO NOT EDIT!\n" + << "# Generated by \"" << this->GlobalGenerator->GetName() << "\"" + << " Generator, CMake Version " << cmVersion::GetMajorVersion() << "." + << cmVersion::GetMinorVersion() << "\n\n"; } -std::string -cmLocalUnixMakefileGenerator3 -::GetRecursiveMakeCall(const char *makefile, const std::string& tgt) +std::string cmLocalUnixMakefileGenerator3::GetRecursiveMakeCall( + const char* makefile, const std::string& tgt) { // Call make on the given file. std::string cmd; cmd += "$(MAKE) -f "; - cmd += this->Convert(makefile,NONE,SHELL); + cmd += this->Convert(makefile, NONE, SHELL); cmd += " "; cmGlobalUnixMakefileGenerator3* gg = static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator); // Pass down verbosity level. - if(!gg->MakeSilentFlag.empty()) - { + if (!gg->MakeSilentFlag.empty()) { cmd += gg->MakeSilentFlag; cmd += " "; - } + } // Most unix makes will pass the command line flags to make down to // sub-invoked makes via an environment variable. However, some // makes do not support that, so you have to pass the flags // explicitly. - if(gg->PassMakeflags) - { + if (gg->PassMakeflags) { cmd += "-$(MAKEFLAGS) "; - } + } // Add the target. - if (!tgt.empty()) - { + if (!tgt.empty()) { // The make target is always relative to the top of the build tree. std::string tgt2 = this->Convert(tgt, HOME_OUTPUT); @@ -2188,53 +1902,43 @@ cmLocalUnixMakefileGenerator3 cmSystemTools::ConvertToOutputSlashes(tgt2); // Escape one extra time if the make tool requires it. - if(this->MakeCommandEscapeTargetTwice) - { + if (this->MakeCommandEscapeTargetTwice) { tgt2 = this->EscapeForShell(tgt2, true, false); - } + } // The target name is now a string that should be passed verbatim // on the command line. cmd += this->EscapeForShell(tgt2, true, false); - } + } return cmd; } void cmLocalUnixMakefileGenerator3::WriteDivider(std::ostream& os) { - os - << "#======================================" - << "=======================================\n"; + os << "#======================================" + << "=======================================\n"; } -void -cmLocalUnixMakefileGenerator3 -::WriteCMakeArgument(std::ostream& os, const char* s) +void cmLocalUnixMakefileGenerator3::WriteCMakeArgument(std::ostream& os, + const char* s) { // Write the given string to the stream with escaping to get it back // into CMake through the lexical scanner. os << "\""; - for(const char* c = s; *c; ++c) - { - if(*c == '\\') - { + for (const char* c = s; *c; ++c) { + if (*c == '\\') { os << "\\\\"; - } - else if(*c == '"') - { + } else if (*c == '"') { os << "\\\""; - } - else - { + } else { os << *c; - } } + } os << "\""; } -std::string -cmLocalUnixMakefileGenerator3::ConvertToQuotedOutputPath(const char* p, - bool useWatcomQuote) +std::string cmLocalUnixMakefileGenerator3::ConvertToQuotedOutputPath( + const char* p, bool useWatcomQuote) { // Split the path into its components. std::vector<std::string> components; @@ -2242,78 +1946,65 @@ cmLocalUnixMakefileGenerator3::ConvertToQuotedOutputPath(const char* p, // Open the quoted result. std::string result; - if(useWatcomQuote) - { + if (useWatcomQuote) { #if defined(_WIN32) && !defined(__CYGWIN__) result = "'"; #else result = "\"'"; #endif - } - else - { + } else { result = "\""; - } + } // Return an empty path if there are no components. - if(!components.empty()) - { + if (!components.empty()) { // Choose a slash direction and fix root component. const char* slash = "/"; #if defined(_WIN32) && !defined(__CYGWIN__) - if(!cmSystemTools::GetForceUnixPaths()) - { + if (!cmSystemTools::GetForceUnixPaths()) { slash = "\\"; - for(std::string::iterator i = components[0].begin(); - i != components[0].end(); ++i) - { - if(*i == '/') - { + for (std::string::iterator i = components[0].begin(); + i != components[0].end(); ++i) { + if (*i == '/') { *i = '\\'; - } } } + } #endif // Begin the quoted result with the root component. result += components[0]; - if (components.size() > 1) - { + if (components.size() > 1) { // Now add the rest of the components separated by the proper slash // direction for this platform. - std::vector<std::string>::const_iterator compEnd - = std::remove(components.begin() + 1, components.end() - 1, - std::string()); - std::vector<std::string>::const_iterator compStart - = components.begin() + 1; + std::vector<std::string>::const_iterator compEnd = std::remove( + components.begin() + 1, components.end() - 1, std::string()); + std::vector<std::string>::const_iterator compStart = + components.begin() + 1; result += cmJoin(cmMakeRange(compStart, compEnd), slash); // Only the last component can be empty to avoid double slashes. result += slash; result += components.back(); - } } + } // Close the quoted result. - if(useWatcomQuote) - { + if (useWatcomQuote) { #if defined(_WIN32) && !defined(__CYGWIN__) result += "'"; #else result += "'\""; #endif - } - else - { + } else { result += "\""; - } + } return result; } -std::string -cmLocalUnixMakefileGenerator3 -::GetTargetDirectory(cmGeneratorTarget const* target) const +std::string cmLocalUnixMakefileGenerator3::GetTargetDirectory( + cmGeneratorTarget const* target) const { std::string dir = cmake::GetCMakeFilesDirectoryPostSlash(); dir += target->GetName(); @@ -2326,32 +2017,28 @@ cmLocalUnixMakefileGenerator3 } cmLocalUnixMakefileGenerator3::ImplicitDependLanguageMap const& -cmLocalUnixMakefileGenerator3::GetImplicitDepends( - const cmGeneratorTarget* tgt) +cmLocalUnixMakefileGenerator3::GetImplicitDepends(const cmGeneratorTarget* tgt) { return this->ImplicitDepends[tgt->GetName()]; } -void -cmLocalUnixMakefileGenerator3::AddImplicitDepends(const cmGeneratorTarget* tgt, - const std::string& lang, - const char* obj, - const char* src) +void cmLocalUnixMakefileGenerator3::AddImplicitDepends( + const cmGeneratorTarget* tgt, const std::string& lang, const char* obj, + const char* src) { this->ImplicitDepends[tgt->GetName()][lang][obj].push_back(src); } -void cmLocalUnixMakefileGenerator3 -::CreateCDCommand(std::vector<std::string>& commands, const char *tgtDir, - cmLocalGenerator::RelativeRoot relRetDir) +void cmLocalUnixMakefileGenerator3::CreateCDCommand( + std::vector<std::string>& commands, const char* tgtDir, + cmLocalGenerator::RelativeRoot relRetDir) { const char* retDir = this->GetRelativeRootPath(relRetDir); // do we need to cd? - if (!strcmp(tgtDir,retDir)) - { + if (!strcmp(tgtDir, retDir)) { return; - } + } // In a Windows shell we must change drive letter too. The shell // used by NMake and Borland make does not support "cd /d" so this @@ -2361,29 +2048,26 @@ void cmLocalUnixMakefileGenerator3 cmGlobalUnixMakefileGenerator3* gg = static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator); - if(!gg->UnixCD) - { + if (!gg->UnixCD) { // On Windows we must perform each step separately and then change // back because the shell keeps the working directory between // commands. std::string cmd = cd_cmd; cmd += this->ConvertToOutputForExisting(tgtDir, relRetDir); - commands.insert(commands.begin(),cmd); + commands.insert(commands.begin(), cmd); // Change back to the starting directory. cmd = cd_cmd; cmd += this->ConvertToOutputForExisting(relRetDir, tgtDir); commands.push_back(cmd); - } - else - { + } else { // On UNIX we must construct a single shell command to change // directory and build because make resets the directory between // each command. std::string outputForExisting = - this->ConvertToOutputForExisting(tgtDir, relRetDir); + this->ConvertToOutputForExisting(tgtDir, relRetDir); std::string prefix = cd_cmd + outputForExisting + " && "; std::transform(commands.begin(), commands.end(), commands.begin(), std::bind1st(std::plus<std::string>(), prefix)); - } + } } |