diff options
Diffstat (limited to 'Source/cmGlobalUnixMakefileGenerator3.cxx')
| -rw-r--r-- | Source/cmGlobalUnixMakefileGenerator3.cxx | 1061 |
1 files changed, 1061 insertions, 0 deletions
diff --git a/Source/cmGlobalUnixMakefileGenerator3.cxx b/Source/cmGlobalUnixMakefileGenerator3.cxx new file mode 100644 index 0000000..88cd6e5 --- /dev/null +++ b/Source/cmGlobalUnixMakefileGenerator3.cxx @@ -0,0 +1,1061 @@ +/*============================================================================ + CMake - Cross Platform Makefile Generator + Copyright 2000-2009 Kitware, Inc., Insight Software Consortium + + Distributed under the OSI-approved BSD License (the "License"); + see accompanying file Copyright.txt for details. + + This software is distributed WITHOUT ANY WARRANTY; without even the + implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + See the License for more information. +============================================================================*/ +#include "cmGlobalUnixMakefileGenerator3.h" +#include "cmLocalUnixMakefileGenerator3.h" +#include "cmMakefileTargetGenerator.h" +#include "cmMakefile.h" +#include "cmake.h" +#include "cmGeneratedFileStream.h" +#include "cmSourceFile.h" +#include "cmTarget.h" +#include "cmGeneratorTarget.h" + +cmGlobalUnixMakefileGenerator3::cmGlobalUnixMakefileGenerator3() +{ + // 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->CommandDatabase = NULL; +} + +void cmGlobalUnixMakefileGenerator3 +::EnableLanguage(std::vector<std::string>const& languages, + cmMakefile *mf, + bool optional) +{ + this->cmGlobalGenerator::EnableLanguage(languages, mf, optional); + for(std::vector<std::string>::const_iterator l = languages.begin(); + l != languages.end(); ++l) + { + if(*l == "NONE") + { + continue; + } + this->ResolveLanguageCompiler(*l, mf, optional); + } +} + +///! Create a local generator appropriate to this Global Generator +cmLocalGenerator *cmGlobalUnixMakefileGenerator3::CreateLocalGenerator() +{ + cmLocalGenerator* lg = new cmLocalUnixMakefileGenerator3; + lg->SetGlobalGenerator(this); + return lg; +} + +//---------------------------------------------------------------------------- +void cmGlobalUnixMakefileGenerator3 +::GetDocumentation(cmDocumentationEntry& entry) +{ + entry.Name = cmGlobalUnixMakefileGenerator3::GetActualName(); + entry.Brief = "Generates standard UNIX makefiles."; + entry.Full = + "A hierarchy of UNIX makefiles is generated into the build tree. Any " + "standard UNIX-style make program can build the project through the " + "default make target. A \"make install\" target is also provided."; +} + +//---------------------------------------------------------------------------- +void +cmGlobalUnixMakefileGenerator3 +::ComputeTargetObjects(cmGeneratorTarget* gt) const +{ + cmTarget* target = gt->Target; + cmLocalUnixMakefileGenerator3* lg = + static_cast<cmLocalUnixMakefileGenerator3*>(gt->LocalGenerator); + + // Compute full path to object file directory for this target. + std::string dir_max; + dir_max += gt->Makefile->GetCurrentOutputDirectory(); + dir_max += "/"; + dir_max += gt->LocalGenerator->GetTargetDirectory(*target); + dir_max += "/"; + gt->ObjectDirectory = dir_max; + + // Compute the name of each object file. + for(std::vector<cmSourceFile*>::iterator + si = gt->ObjectSources.begin(); + si != gt->ObjectSources.end(); ++si) + { + cmSourceFile* sf = *si; + bool hasSourceExtension = true; + std::string objectName = gt->LocalGenerator + ->GetObjectFileNameWithoutTarget(*sf, dir_max, + &hasSourceExtension); + gt->Objects[sf] = objectName; + lg->AddLocalObjectFile(target, sf, objectName, hasSourceExtension); + } +} + +void cmGlobalUnixMakefileGenerator3::Generate() +{ + // first do superclass method + this->cmGlobalGenerator::Generate(); + + // initialize progress + unsigned long total = 0; + for(ProgressMapType::const_iterator pmi = this->ProgressMap.begin(); + pmi != this->ProgressMap.end(); ++pmi) + { + total += pmi->second.NumberOfActions; + } + + // write each target's progress.make this loop is done twice. Bascially 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(ProgressMapType::iterator pmi = this->ProgressMap.begin(); + pmi != this->ProgressMap.end(); ++pmi) + { + pmi->second.WriteProgressVariables(total, current); + } + for(unsigned int i = 0; i < this->LocalGenerators.size(); ++i) + { + cmLocalUnixMakefileGenerator3 *lg = + static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[i]); + std::string markFileName = lg->GetMakefile()->GetStartOutputDirectory(); + markFileName += "/"; + markFileName += cmake::GetCMakeFilesDirectory(); + markFileName += "/progress.marks"; + cmGeneratedFileStream markFile(markFileName.c_str()); + markFile << this->CountProgressMarksInAll(lg) << "\n"; + } + + // write the main makefile + this->WriteMainMakefile2(); + this->WriteMainCMakefile(); + + if (this->CommandDatabase != NULL) { + *this->CommandDatabase << std::endl << "]"; + delete this->CommandDatabase; + this->CommandDatabase = NULL; + } +} + +void cmGlobalUnixMakefileGenerator3::AddCXXCompileCommand( + const std::string &sourceFile, const std::string &workingDirectory, + const std::string &compileCommand) { + if (this->CommandDatabase == NULL) + { + std::string commandDatabaseName = + std::string(this->GetCMakeInstance()->GetHomeOutputDirectory()) + + "/compile_commands.json"; + this->CommandDatabase = + new cmGeneratedFileStream(commandDatabaseName.c_str()); + *this->CommandDatabase << "[" << std::endl; + } else { + *this->CommandDatabase << "," << std::endl; + } + *this->CommandDatabase << "{" << std::endl + << " \"directory\": \"" + << cmGlobalGenerator::EscapeJSON(workingDirectory) << "\"," + << std::endl + << " \"command\": \"" << + cmGlobalGenerator::EscapeJSON(compileCommand) << "\"," + << std::endl + << " \"file\": \"" << + cmGlobalGenerator::EscapeJSON(sourceFile) << "\"" + << std::endl << "}"; +} + +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 = + this->GetCMakeInstance()->GetHomeOutputDirectory(); + makefileName += cmake::GetCMakeFilesDirectory(); + makefileName += "/Makefile2"; + cmGeneratedFileStream makefileStream(makefileName.c_str()); + if(!makefileStream) + { + return; + } + + // get a local generator for some useful methods + cmLocalUnixMakefileGenerator3 *lg = + static_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.push_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 != "") + { + depends.push_back(this->EmptyRuleHackDepends); + } + + // Write and empty all: + lg->WriteMakeRule(makefileStream, + "The main recursive all target", "all", + depends, no_commands, true); + + // Write an empty preinstall: + lg->WriteMakeRule(makefileStream, + "The main recursive preinstall target", "preinstall", + depends, no_commands, true); + + // Write out the "special" stuff + lg->WriteSpecialTargetsTop(makefileStream); + + // write the target convenience rules + unsigned int i; + for (i = 0; i < this->LocalGenerators.size(); ++i) + { + lg = + static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[i]); + this->WriteConvenienceRules2(makefileStream,lg); + } + + lg = static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[0]); + lg->WriteSpecialTargetsBottom(makefileStream); +} + + +//---------------------------------------------------------------------------- +void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile() +{ + // 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 = + this->GetCMakeInstance()->GetHomeOutputDirectory(); + cmakefileName += cmake::GetCMakeFilesDirectory(); + cmakefileName += "/Makefile.cmake"; + cmGeneratedFileStream cmakefileStream(cmakefileName.c_str()); + if(!cmakefileStream) + { + return; + } + + std::string makefileName = + this->GetCMakeInstance()->GetHomeOutputDirectory(); + makefileName += "/Makefile"; + + // get a local generator for some useful methods + cmLocalUnixMakefileGenerator3 *lg = + static_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 (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) + { + lg = + static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[i]); + + // Get the list of files contributing to this generation step. + lfiles.insert(lfiles.end(),lg->GetMakefile()->GetListFiles().begin(), + lg->GetMakefile()->GetListFiles().end()); + } + // 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. + std::vector<std::string>::iterator new_end = + std::unique(lfiles.begin(),lfiles.end()); + lfiles.erase(new_end, lfiles.end()); +#endif + + // reset lg to the first makefile + lg = static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[0]); + + // Build the path to the cache file. + std::string cache = this->GetCMakeInstance()->GetHomeOutputDirectory(); + cache += "/CMakeCache.txt"; + + // Save the list to the cmake file. + cmakefileStream + << "# The top level Makefile was generated from the following files:\n" + << "SET(CMAKE_MAKEFILE_DEPENDS\n" + << " \"" + << lg->Convert(cache.c_str(), + cmLocalGenerator::START_OUTPUT).c_str() << "\"\n"; + for(std::vector<std::string>::const_iterator i = lfiles.begin(); + i != lfiles.end(); ++i) + { + cmakefileStream + << " \"" + << lg->Convert(i->c_str(), cmLocalGenerator::START_OUTPUT).c_str() + << "\"\n"; + } + cmakefileStream + << " )\n\n"; + + // Build the path to the cache check file. + std::string check = this->GetCMakeInstance()->GetHomeOutputDirectory(); + check += cmake::GetCMakeFilesDirectory(); + check += "/cmake.check_cache"; + + // Set the corresponding makefile in the cmake file. + cmakefileStream + << "# The corresponding makefile is:\n" + << "SET(CMAKE_MAKEFILE_OUTPUTS\n" + << " \"" + << lg->Convert(makefileName.c_str(), + cmLocalGenerator::START_OUTPUT).c_str() << "\"\n" + << " \"" + << lg->Convert(check.c_str(), + cmLocalGenerator::START_OUTPUT).c_str() << "\"\n"; + cmakefileStream << " )\n\n"; + + // CMake must rerun if a byproduct is missing. + { + cmakefileStream + << "# Byproducts of CMake generate step:\n" + << "SET(CMAKE_MAKEFILE_PRODUCTS\n"; + const std::vector<std::string>& outfiles = + lg->GetMakefile()->GetOutputFiles(); + for(std::vector<std::string>::const_iterator k = outfiles.begin(); + k != outfiles.end(); ++k) + { + cmakefileStream << " \"" << + lg->Convert(k->c_str(),cmLocalGenerator::HOME_OUTPUT).c_str() + << "\"\n"; + } + + // add in all the directory information files + std::string tmpStr; + for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) + { + lg = + static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[i]); + tmpStr = lg->GetMakefile()->GetStartOutputDirectory(); + tmpStr += cmake::GetCMakeFilesDirectory(); + tmpStr += "/CMakeDirectoryInformation.cmake"; + cmakefileStream << " \"" << + lg->Convert(tmpStr.c_str(),cmLocalGenerator::HOME_OUTPUT).c_str() + << "\"\n"; + } + cmakefileStream << " )\n\n"; + } + + this->WriteMainCMakefileLanguageRules(cmakefileStream, + this->LocalGenerators); +} + +void cmGlobalUnixMakefileGenerator3 +::WriteMainCMakefileLanguageRules(cmGeneratedFileStream& cmakefileStream, + std::vector<cmLocalGenerator *> &lGenerators + ) +{ + cmLocalUnixMakefileGenerator3 *lg; + + // now list all the target info files + cmakefileStream + << "# Dependency information for all targets:\n"; + cmakefileStream + << "SET(CMAKE_DEPEND_INFO_FILES\n"; + for (unsigned int i = 0; i < lGenerators.size(); ++i) + { + lg = static_cast<cmLocalUnixMakefileGenerator3 *>(lGenerators[i]); + // for all of out targets + for (cmTargets::iterator l = lg->GetMakefile()->GetTargets().begin(); + l != lg->GetMakefile()->GetTargets().end(); l++) + { + if((l->second.GetType() == cmTarget::EXECUTABLE) || + (l->second.GetType() == cmTarget::STATIC_LIBRARY) || + (l->second.GetType() == cmTarget::SHARED_LIBRARY) || + (l->second.GetType() == cmTarget::MODULE_LIBRARY) || + (l->second.GetType() == cmTarget::OBJECT_LIBRARY) || + (l->second.GetType() == cmTarget::UTILITY)) + { + std::string tname = lg->GetRelativeTargetDirectory(l->second); + tname += "/DependInfo.cmake"; + cmSystemTools::ConvertToUnixSlashes(tname); + cmakefileStream << " \"" << tname.c_str() << "\"\n"; + } + } + } + cmakefileStream << " )\n"; +} + +//---------------------------------------------------------------------------- +void +cmGlobalUnixMakefileGenerator3 +::WriteDirectoryRule2(std::ostream& ruleFileStream, + cmLocalUnixMakefileGenerator3* lg, + const char* pass, bool check_all, + bool check_relink) +{ + // Get the relative path to the subdirectory from the top. + std::string makeTarget = lg->GetMakefile()->GetStartOutputDirectory(); + makeTarget += "/"; + makeTarget += pass; + + // The directory-level rule should depend on the target-level rules + // for all targets in the directory. + std::vector<std::string> depends; + for(cmTargets::iterator l = lg->GetMakefile()->GetTargets().begin(); + l != lg->GetMakefile()->GetTargets().end(); ++l) + { + if((l->second.GetType() == cmTarget::EXECUTABLE) || + (l->second.GetType() == cmTarget::STATIC_LIBRARY) || + (l->second.GetType() == cmTarget::SHARED_LIBRARY) || + (l->second.GetType() == cmTarget::MODULE_LIBRARY) || + (l->second.GetType() == cmTarget::OBJECT_LIBRARY) || + (l->second.GetType() == cmTarget::UTILITY)) + { + // Add this to the list of depends rules in this directory. + if((!check_all || !l->second.GetPropertyAsBool("EXCLUDE_FROM_ALL")) && + (!check_relink || + l->second.NeedRelinkBeforeInstall(lg->ConfigurationName.c_str()))) + { + std::string tname = lg->GetRelativeTargetDirectory(l->second); + tname += "/"; + tname += pass; + depends.push_back(tname); + } + } + } + + // The directory-level rule should depend on the directory-level + // rules of the subdirectories. + for(std::vector<cmLocalGenerator*>::iterator sdi = + lg->GetChildren().begin(); sdi != lg->GetChildren().end(); ++sdi) + { + cmLocalUnixMakefileGenerator3* slg = + static_cast<cmLocalUnixMakefileGenerator3*>(*sdi); + std::string subdir = slg->GetMakefile()->GetStartOutputDirectory(); + subdir += "/"; + subdir += pass; + depends.push_back(subdir); + } + + // Work-around for makes that drop rules that have no dependencies + // or commands. + if(depends.empty() && this->EmptyRuleHackDepends != "") + { + depends.push_back(this->EmptyRuleHackDepends); + } + + // Write the rule. + std::string doc = "Convenience name for \""; + doc += pass; + doc += "\" pass in the directory."; + std::vector<std::string> no_commands; + lg->WriteMakeRule(ruleFileStream, doc.c_str(), + makeTarget.c_str(), depends, no_commands, true); +} + +//---------------------------------------------------------------------------- +void +cmGlobalUnixMakefileGenerator3 +::WriteDirectoryRules2(std::ostream& ruleFileStream, + cmLocalUnixMakefileGenerator3* lg) +{ + // Only subdirectories need these rules. + if(!lg->GetParent()) + { + return; + } + + // Begin the directory-level rules section. + std::string dir = lg->GetMakefile()->GetStartOutputDirectory(); + dir = lg->Convert(dir.c_str(), cmLocalGenerator::HOME_OUTPUT, + cmLocalGenerator::MAKEFILE); + lg->WriteDivider(ruleFileStream); + ruleFileStream + << "# Directory level rules for directory " + << dir << "\n\n"; + + // Write directory-level rules for "all". + this->WriteDirectoryRule2(ruleFileStream, lg, "all", true, false); + + // Write directory-level rules for "clean". + this->WriteDirectoryRule2(ruleFileStream, lg, "clean", false, false); + + // Write directory-level rules for "preinstall". + this->WriteDirectoryRule2(ruleFileStream, lg, "preinstall", true, true); +} + + +std::string cmGlobalUnixMakefileGenerator3 +::GenerateBuildCommand(const char* makeProgram, const char *projectName, + const char *projectDir, const char* additionalOptions, + const char *targetName, const char* config, + bool ignoreErrors, bool fast) +{ + // Project name & dir and config are not used yet. + (void)projectName; + (void)projectDir; + (void)config; + + std::string makeCommand = + cmSystemTools::ConvertToUnixOutputPath(makeProgram); + + // Since we have full control over the invocation of nmake, let us + // make it quiet. + if ( strcmp(this->GetName(), "NMake Makefiles") == 0 ) + { + makeCommand += " /NOLOGO "; + } + if ( ignoreErrors ) + { + makeCommand += " -i"; + } + if ( additionalOptions ) + { + makeCommand += " "; + makeCommand += additionalOptions; + } + if ( targetName && strlen(targetName)) + { + cmLocalUnixMakefileGenerator3 *lg; + if (this->LocalGenerators.size()) + { + lg = static_cast<cmLocalUnixMakefileGenerator3 *> + (this->LocalGenerators[0]); + } + else + { + lg = static_cast<cmLocalUnixMakefileGenerator3 *> + (this->CreateLocalGenerator()); + // set the Start directories + lg->GetMakefile()->SetStartDirectory + (this->CMakeInstance->GetStartDirectory()); + lg->GetMakefile()->SetStartOutputDirectory + (this->CMakeInstance->GetStartOutputDirectory()); + lg->GetMakefile()->MakeStartDirectoriesCurrent(); + } + + makeCommand += " \""; + std::string tname = targetName; + if(fast) + { + tname += "/fast"; + } + tname = lg->Convert(tname.c_str(),cmLocalGenerator::HOME_OUTPUT, + cmLocalGenerator::MAKEFILE); + makeCommand += tname.c_str(); + makeCommand += "\""; + if (!this->LocalGenerators.size()) + { + delete lg; + } + } + return makeCommand; +} + +//---------------------------------------------------------------------------- +void +cmGlobalUnixMakefileGenerator3 +::WriteConvenienceRules(std::ostream& ruleFileStream, + std::set<cmStdString> &emitted) +{ + std::vector<std::string> depends; + std::vector<std::string> commands; + + depends.push_back("cmake_check_build_system"); + + // write the target convenience rules + unsigned int i; + cmLocalUnixMakefileGenerator3 *lg; + for (i = 0; i < this->LocalGenerators.size(); ++i) + { + lg = static_cast<cmLocalUnixMakefileGenerator3 *> + (this->LocalGenerators[i]); + // for each target Generate the rule files for each target. + cmTargets& targets = lg->GetMakefile()->GetTargets(); + for(cmTargets::iterator t = targets.begin(); t != targets.end(); ++t) + { + // Don't emit the same rule twice (e.g. two targets with the same + // simple name) + if(t->second.GetName() && + strlen(t->second.GetName()) && + emitted.insert(t->second.GetName()).second && + // Handle user targets here. Global targets are handled in + // the local generator on a per-directory basis. + ((t->second.GetType() == cmTarget::EXECUTABLE) || + (t->second.GetType() == cmTarget::STATIC_LIBRARY) || + (t->second.GetType() == cmTarget::SHARED_LIBRARY) || + (t->second.GetType() == cmTarget::MODULE_LIBRARY) || + (t->second.GetType() == cmTarget::OBJECT_LIBRARY) || + (t->second.GetType() == cmTarget::UTILITY))) + { + // Add a rule to build the target by name. + lg->WriteDivider(ruleFileStream); + ruleFileStream + << "# Target rules for targets named " + << t->second.GetName() << "\n\n"; + + // Write the rule. + commands.clear(); + std::string tmp = cmake::GetCMakeFilesDirectoryPostSlash(); + tmp += "Makefile2"; + commands.push_back(lg->GetRecursiveMakeCall + (tmp.c_str(),t->second.GetName())); + depends.clear(); + depends.push_back("cmake_check_build_system"); + lg->WriteMakeRule(ruleFileStream, + "Build rule for target.", + t->second.GetName(), depends, commands, + true); + + // Add a fast rule to build the target + std::string localName = lg->GetRelativeTargetDirectory(t->second); + std::string makefileName; + makefileName = localName; + makefileName += "/build.make"; + depends.clear(); + commands.clear(); + std::string makeTargetName = localName; + makeTargetName += "/build"; + localName = t->second.GetName(); + localName += "/fast"; + commands.push_back(lg->GetRecursiveMakeCall + (makefileName.c_str(), makeTargetName.c_str())); + lg->WriteMakeRule(ruleFileStream, "fast build rule for target.", + localName.c_str(), depends, commands, true); + + // Add a local name for the rule to relink the target before + // installation. + if(t->second.NeedRelinkBeforeInstall(lg->ConfigurationName.c_str())) + { + makeTargetName = lg->GetRelativeTargetDirectory(t->second); + makeTargetName += "/preinstall"; + localName = t->second.GetName(); + localName += "/preinstall"; + depends.clear(); + commands.clear(); + commands.push_back(lg->GetRecursiveMakeCall + (makefileName.c_str(), makeTargetName.c_str())); + lg->WriteMakeRule(ruleFileStream, + "Manual pre-install relink rule for target.", + localName.c_str(), 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; + + + // write the directory level rules for this local gen + this->WriteDirectoryRules2(ruleFileStream,lg); + + depends.push_back("cmake_check_build_system"); + + // for each target Generate the rule files for each target. + cmTargets& targets = lg->GetMakefile()->GetTargets(); + for(cmTargets::iterator t = targets.begin(); t != targets.end(); ++t) + { + if (t->second.GetName() + && strlen(t->second.GetName()) + && ((t->second.GetType() == cmTarget::EXECUTABLE) + || (t->second.GetType() == cmTarget::STATIC_LIBRARY) + || (t->second.GetType() == cmTarget::SHARED_LIBRARY) + || (t->second.GetType() == cmTarget::MODULE_LIBRARY) + || (t->second.GetType() == cmTarget::OBJECT_LIBRARY) + || (t->second.GetType() == cmTarget::UTILITY))) + { + std::string makefileName; + // Add a rule to build the target by name. + localName = lg->GetRelativeTargetDirectory(t->second); + makefileName = localName; + makefileName += "/build.make"; + + bool needRequiresStep = this->NeedRequiresStep(t->second); + + lg->WriteDivider(ruleFileStream); + ruleFileStream + << "# Target rules for target " + << localName << "\n\n"; + + commands.clear(); + makeTargetName = localName; + makeTargetName += "/depend"; + commands.push_back(lg->GetRecursiveMakeCall + (makefileName.c_str(),makeTargetName.c_str())); + + // add requires if we need it for this generator + if (needRequiresStep) + { + makeTargetName = localName; + makeTargetName += "/requires"; + commands.push_back(lg->GetRecursiveMakeCall + (makefileName.c_str(),makeTargetName.c_str())); + } + makeTargetName = localName; + makeTargetName += "/build"; + commands.push_back(lg->GetRecursiveMakeCall + (makefileName.c_str(),makeTargetName.c_str())); + + // Write the rule. + localName += "/all"; + depends.clear(); + + std::string progressDir = + lg->GetMakefile()->GetHomeOutputDirectory(); + progressDir += cmake::GetCMakeFilesDirectory(); + { + cmOStringStream progCmd; + progCmd << "$(CMAKE_COMMAND) -E cmake_progress_report "; + // all target counts + progCmd << lg->Convert(progressDir.c_str(), + cmLocalGenerator::FULL, + cmLocalGenerator::SHELL); + progCmd << " "; + std::vector<unsigned long>& progFiles = + this->ProgressMap[&t->second].Marks; + for (std::vector<unsigned long>::iterator i = progFiles.begin(); + i != progFiles.end(); ++i) + { + progCmd << " " << *i; + } + commands.push_back(progCmd.str()); + } + progressDir = "Built target "; + progressDir += t->first; + lg->AppendEcho(commands,progressDir.c_str()); + + this->AppendGlobalTargetDepends(depends,t->second); + lg->WriteMakeRule(ruleFileStream, "All Build rule for target.", + localName.c_str(), depends, commands, true); + + // add the all/all dependency + if(!this->IsExcluded(this->LocalGenerators[0], t->second)) + { + depends.clear(); + depends.push_back(localName); + commands.clear(); + lg->WriteMakeRule(ruleFileStream, "Include target in all.", + "all", depends, commands, true); + } + + // Write the rule. + commands.clear(); + progressDir = lg->GetMakefile()->GetHomeOutputDirectory(); + progressDir += cmake::GetCMakeFilesDirectory(); + + { + // TODO: Convert the total progress count to a make variable. + cmOStringStream progCmd; + progCmd << "$(CMAKE_COMMAND) -E cmake_progress_start "; + // # in target + progCmd << lg->Convert(progressDir.c_str(), + cmLocalGenerator::FULL, + cmLocalGenerator::SHELL); + // + std::set<cmTarget *> emitted; + progCmd << " " + << this->CountProgressMarksInTarget(&t->second, emitted); + commands.push_back(progCmd.str()); + } + std::string tmp = cmake::GetCMakeFilesDirectoryPostSlash(); + tmp += "Makefile2"; + commands.push_back(lg->GetRecursiveMakeCall + (tmp.c_str(),localName.c_str())); + { + cmOStringStream progCmd; + progCmd << "$(CMAKE_COMMAND) -E cmake_progress_start "; // # 0 + progCmd << lg->Convert(progressDir.c_str(), + cmLocalGenerator::FULL, + cmLocalGenerator::SHELL); + progCmd << " 0"; + commands.push_back(progCmd.str()); + } + depends.clear(); + depends.push_back("cmake_check_build_system"); + localName = lg->GetRelativeTargetDirectory(t->second); + localName += "/rule"; + lg->WriteMakeRule(ruleFileStream, + "Build rule for subdir invocation for target.", + localName.c_str(), 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.", + t->second.GetName(), depends, commands, true); + + // Add rules to prepare the target for installation. + if(t->second.NeedRelinkBeforeInstall(lg->ConfigurationName.c_str())) + { + localName = lg->GetRelativeTargetDirectory(t->second); + localName += "/preinstall"; + depends.clear(); + commands.clear(); + commands.push_back(lg->GetRecursiveMakeCall + (makefileName.c_str(), localName.c_str())); + lg->WriteMakeRule(ruleFileStream, + "Pre-install relink rule for target.", + localName.c_str(), depends, commands, true); + + if(!this->IsExcluded(this->LocalGenerators[0], t->second)) + { + depends.clear(); + depends.push_back(localName); + commands.clear(); + lg->WriteMakeRule(ruleFileStream, "Prepare target for install.", + "preinstall", depends, commands, true); + } + } + + // add the clean rule + localName = lg->GetRelativeTargetDirectory(t->second); + makeTargetName = localName; + makeTargetName += "/clean"; + depends.clear(); + commands.clear(); + commands.push_back(lg->GetRecursiveMakeCall + (makefileName.c_str(), makeTargetName.c_str())); + lg->WriteMakeRule(ruleFileStream, "clean rule for target.", + makeTargetName.c_str(), depends, commands, true); + commands.clear(); + depends.push_back(makeTargetName); + lg->WriteMakeRule(ruleFileStream, "clean rule for target.", + "clean", depends, commands, true); + } + } +} + +//---------------------------------------------------------------------------- +size_t +cmGlobalUnixMakefileGenerator3 +::CountProgressMarksInTarget(cmTarget* target, + std::set<cmTarget*>& emitted) +{ + size_t count = 0; + if(emitted.insert(target).second) + { + count = this->ProgressMap[target].Marks.size(); + TargetDependSet const& depends = this->GetTargetDirectDepends(*target); + for(TargetDependSet::const_iterator di = depends.begin(); + di != depends.end(); ++di) + { + count += this->CountProgressMarksInTarget(*di, emitted); + } + } + return count; +} + +//---------------------------------------------------------------------------- +size_t +cmGlobalUnixMakefileGenerator3 +::CountProgressMarksInAll(cmLocalUnixMakefileGenerator3* lg) +{ + size_t count = 0; + std::set<cmTarget*> emitted; + std::set<cmTarget*> const& targets = this->LocalGeneratorToTargetMap[lg]; + for(std::set<cmTarget*>::const_iterator t = targets.begin(); + t != targets.end(); ++t) + { + count += this->CountProgressMarksInTarget(*t, emitted); + } + return count; +} + +//---------------------------------------------------------------------------- +void +cmGlobalUnixMakefileGenerator3::RecordTargetProgress( + cmMakefileTargetGenerator* tg) +{ + TargetProgress& tp = this->ProgressMap[tg->GetTarget()]; + tp.NumberOfActions = tg->GetNumberOfProgressActions(); + tp.VariableFile = tg->GetProgressFileNameFull(); +} + +//---------------------------------------------------------------------------- +bool +cmGlobalUnixMakefileGenerator3::ProgressMapCompare +::operator()(cmTarget* l, cmTarget* r) const +{ + // Order by target name. + if(int c = strcmp(l->GetName(), r->GetName())) + { + return c < 0; + } + // Order duplicate targets by binary directory. + return strcmp(l->GetMakefile()->GetCurrentOutputDirectory(), + r->GetMakefile()->GetCurrentOutputDirectory()) < 0; +} + +//---------------------------------------------------------------------------- +void +cmGlobalUnixMakefileGenerator3::TargetProgress +::WriteProgressVariables(unsigned long total, unsigned long ¤t) +{ + cmGeneratedFileStream fout(this->VariableFile.c_str()); + 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, + cmTarget& target) +{ + TargetDependSet const& depends_set = this->GetTargetDirectDepends(target); + for(TargetDependSet::const_iterator i = depends_set.begin(); + i != depends_set.end(); ++i) + { + // Create the target-level dependency. + cmTarget const* dep = *i; + cmLocalUnixMakefileGenerator3* lg3 = + static_cast<cmLocalUnixMakefileGenerator3*> + (dep->GetMakefile()->GetLocalGenerator()); + std::string tgtName = lg3->GetRelativeTargetDirectory(*dep); + tgtName += "/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"); + lg->AppendEcho(commands,"... depend"); + + // Keep track of targets already listed. + std::set<cmStdString> emittedTargets; + + // for each local generator + unsigned int i; + cmLocalUnixMakefileGenerator3 *lg2; + for (i = 0; i < this->LocalGenerators.size(); ++i) + { + lg2 = + static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[i]); + // for the passed in makefile or if this is the top Makefile wripte out + // the targets + if (lg2 == lg || !lg->GetParent()) + { + // for each target Generate the rule files for each target. + cmTargets& targets = lg2->GetMakefile()->GetTargets(); + for(cmTargets::iterator t = targets.begin(); t != targets.end(); ++t) + { + if((t->second.GetType() == cmTarget::EXECUTABLE) || + (t->second.GetType() == cmTarget::STATIC_LIBRARY) || + (t->second.GetType() == cmTarget::SHARED_LIBRARY) || + (t->second.GetType() == cmTarget::MODULE_LIBRARY) || + (t->second.GetType() == cmTarget::OBJECT_LIBRARY) || + (t->second.GetType() == cmTarget::GLOBAL_TARGET) || + (t->second.GetType() == cmTarget::UTILITY)) + { + if(emittedTargets.insert(t->second.GetName()).second) + { + path = "... "; + path += t->second.GetName(); + lg->AppendEcho(commands,path.c_str()); + } + } + } + } + } + std::vector<cmStdString> const& localHelp = lg->GetLocalHelp(); + for(std::vector<cmStdString>::const_iterator o = localHelp.begin(); + o != localHelp.end(); ++o) + { + path = "... "; + path += *o; + lg->AppendEcho(commands, path.c_str()); + } + lg->WriteMakeRule(ruleFileStream, "Help Target", + "help", + no_depends, commands, true); + ruleFileStream << "\n\n"; +} + + +bool cmGlobalUnixMakefileGenerator3 +::NeedRequiresStep(cmTarget const& target) +{ + std::set<cmStdString> languages; + target.GetLanguages(languages); + for(std::set<cmStdString>::const_iterator l = languages.begin(); + l != languages.end(); ++l) + { + std::string var = "CMAKE_NEEDS_REQUIRES_STEP_"; + var += *l; + var += "_FLAG"; + if(target.GetMakefile()->GetDefinition(var.c_str())) + { + return true; + } + } + return false; +} |