kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

ENH: updates

This commit is contained in:
Ken Martin 2005-05-06 14:49:38 -04:00
parent dc75c22645
commit 0cb20474d8
4 changed files with 650 additions and 643 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

325
Source/cmGlobalUnixMakefileGenerator3.cxx
View File

@ -90,22 +90,93 @@ void cmGlobalUnixMakefileGenerator3::GetDocumentation(cmDocumentationEntry& entr
"default make target. A \"make install\" target is also provided.";
}
//----------------------------------------------------------------------------
void cmGlobalUnixMakefileGenerator3::Generate()
{
// first do superclass method
this->cmGlobalGenerator::Generate();
// write the main makefile
this->WriteMainMakefile();
this->WriteMainCMakefile();
// now write the support Makefiles
this->WriteDependMakefile();
this->WriteBuildMakefile();
this->WriteCleanMakefile();
}
void cmGlobalUnixMakefileGenerator3::WriteMainMakefile()
{
// 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 += "/Makefile";
cmGeneratedFileStream makefileStream(makefileName.c_str());
if(!makefileStream)
{
return;
}
// get a local generator for some useful methods
cmLocalUnixMakefileGenerator3 *lg =
static_cast<cmLocalUnixMakefileGenerator3 *>(m_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);
lg->WriteMakeVariables(makefileStream);
lg->WriteSpecialTargetsTop(makefileStream);
this->WriteAllRules(lg,makefileStream);
// write the target convenience rules
unsigned int i;
for (i = 0; i < m_LocalGenerators.size(); ++i)
{
lg = static_cast<cmLocalUnixMakefileGenerator3 *>(m_LocalGenerators[i]);
this->WriteConvenienceRules(makefileStream,lg);
}
}
//----------------------------------------------------------------------------
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();
std::string cmakefileName =
this->GetCMakeInstance()->GetHomeOutputDirectory();
cmakefileName += "/Makefile.cmake";
std::string makefileName = this->GetCMakeInstance()->GetHomeOutputDirectory();
makefileName += "/Makefile";
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 *>(m_LocalGenerators[0]);
@ -174,12 +245,20 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
<< " \"" << this->ConvertToHomeRelativePath(tmpStr.c_str()).c_str() << "\"\n";
}
cmakefileStream << " )\n\n";
this->WriteMainCMakefileLanguageRules(cmakefileStream);
}
void cmGlobalUnixMakefileGenerator3
::WriteMainCMakefileLanguageRules(cmGeneratedFileStream& cmakefileStream)
{
cmLocalUnixMakefileGenerator3 *lg;
// now write all the language stuff
// Set the set of files to check for dependency integrity.
// loop over all of the local generators to collect this
std::set<cmStdString> checkSetLangs;
for (i = 0; i < m_LocalGenerators.size(); ++i)
for (unsigned int i = 0; i < m_LocalGenerators.size(); ++i)
{
lg = static_cast<cmLocalUnixMakefileGenerator3 *>(m_LocalGenerators[i]);
std::map<cmStdString,cmLocalUnixMakefileGenerator3::IntegrityCheckSet>& checkSet =
@ -211,7 +290,7 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
cmakefileStream
<< "SET(CMAKE_DEPENDS_CHECK_" << l->c_str() << "\n";
// now for each local gen get the checkset
for (i = 0; i < m_LocalGenerators.size(); ++i)
for (unsigned int i = 0; i < m_LocalGenerators.size(); ++i)
{
lg = static_cast<cmLocalUnixMakefileGenerator3 *>(m_LocalGenerators[i]);
// get the check set for this local gen and language
@ -228,90 +307,6 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
}
cmakefileStream << " )\n";
}
}
void cmGlobalUnixMakefileGenerator3::WriteMainMakefile()
{
// 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 += "/Makefile";
cmGeneratedFileStream makefileStream(makefileName.c_str());
if(!makefileStream)
{
return;
}
// get a local generator for some useful methods
cmLocalUnixMakefileGenerator3 *lg =
static_cast<cmLocalUnixMakefileGenerator3 *>(m_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);
lg->WriteMakeVariables(makefileStream);
lg->WriteSpecialTargetsTop(makefileStream);
lg->WriteAllRules(makefileStream);
// 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 = makefileName;
cmakefileName += ".cmake";
std::string runRule = this->GetCMakeInstance()->GetCacheDefinition("CMAKE_COMMAND");
runRule += " -H";
runRule += this->GetCMakeInstance()->GetHomeDirectory();
runRule += " -B";
runRule += this->GetCMakeInstance()->GetHomeOutputDirectory();
runRule += " --check-build-system ";
runRule += lg->ConvertToRelativeOutputPath(cmakefileName.c_str());
std::vector<std::string> no_depends;
std::vector<std::string> commands;
commands.push_back(runRule);
lg->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);
// write the target convenience rules
unsigned int i;
for (i = 0; i < m_LocalGenerators.size(); ++i)
{
lg = static_cast<cmLocalUnixMakefileGenerator3 *>(m_LocalGenerators[i]);
lg->WriteConvenienceRules(makefileStream);
}
}
void cmGlobalUnixMakefileGenerator3::WriteSupportMakefiles()
{
this->WriteDependMakefile();
this->WriteBuildMakefile();
this->WriteCleanMakefile();
}
void cmGlobalUnixMakefileGenerator3::WriteDependMakefile()
@ -455,15 +450,149 @@ void cmGlobalUnixMakefileGenerator3::WriteCleanMakefile()
}
//----------------------------------------------------------------------------
void cmGlobalUnixMakefileGenerator3::Generate()
void cmGlobalUnixMakefileGenerator3
::WriteAllRules(cmLocalUnixMakefileGenerator3 *lg,
std::ostream& makefileStream)
{
// first do superclass method
this->cmGlobalGenerator::Generate();
// Write section header.
lg->WriteDivider(makefileStream);
makefileStream
<< "# Rules to build dependencies and targets.\n"
<< "\n";
// write the main makefile
this->WriteMainMakefile();
this->WriteMainCMakefile();
std::vector<std::string> depends;
std::vector<std::string> commands;
// now write the support Makefiles
this->WriteSupportMakefiles();
// Check the build system in this directory.
depends.push_back("cmake_check_build_system");
commands.push_back(this->GetRecursiveMakeCall("depend.make",0));
commands.push_back(this->GetRecursiveMakeCall("build.make",0));
// Write the rule.
lg->WriteMakeRule(makefileStream, "The main all target", "all", depends, commands);
// write the clean
commands.clear();
commands.push_back(this->GetRecursiveMakeCall("clean.make",0));
lg->WriteMakeRule(makefileStream, "default clean target", "clean", depends, commands);
// 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 = this->GetCMakeInstance()->GetHomeOutputDirectory();
cmakefileName += "/Makefile.cmake";
std::string runRule = this->GetCMakeInstance()->GetCacheDefinition("CMAKE_COMMAND");
runRule += " -H";
runRule += this->GetCMakeInstance()->GetHomeDirectory();
runRule += " -B";
runRule += this->GetCMakeInstance()->GetHomeOutputDirectory();
runRule += " --check-build-system ";
runRule += lg->ConvertToRelativeOutputPath(cmakefileName.c_str());
std::vector<std::string> no_depends;
commands.clear();
commands.push_back(runRule);
lg->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);
}
//----------------------------------------------------------------------------
std::string
cmGlobalUnixMakefileGenerator3
::GetRecursiveMakeCall(const char *Makefile, const char* tgt)
{
cmLocalUnixMakefileGenerator3 *lg =
static_cast<cmLocalUnixMakefileGenerator3*>(m_LocalGenerators[0]);
// Call make on the given file.
std::string cmd;
cmd += "$(MAKE) -f ";
cmd += Makefile;
cmd += " ";
// Pass down verbosity level.
if(lg->GetMakeSilentFlag().size())
{
cmd += lg->GetMakeSilentFlag();
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(lg->GetPassMakeflags())
{
cmd += "-$(MAKEFLAGS) ";
}
// Add the target.
if (tgt && tgt[0] != '\0')
{
cmd += tgt;
}
return cmd;
}
//----------------------------------------------------------------------------
void
cmGlobalUnixMakefileGenerator3
::WriteConvenienceRules(std::ostream& ruleFileStream, cmLocalUnixMakefileGenerator3 *lg)
{
std::vector<std::string> depends;
std::vector<std::string> tgt_depends;
std::vector<std::string> commands;
depends.push_back("cmake_check_build_system");
// for each target
// Generate the rule files for each target.
const cmTargets& targets = lg->GetMakefile()->GetTargets();
std::string localName;
std::string makeTargetName;
for(cmTargets::const_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))
{
// Add a rule to build the target by name.
localName = lg->GetRelativeTargetDirectory(t->second);
commands.clear();
makeTargetName = localName;
makeTargetName += "/depend";
commands.push_back(this->GetRecursiveMakeCall("depend.make",makeTargetName.c_str()));
makeTargetName = localName;
makeTargetName += "/build";
commands.push_back(this->GetRecursiveMakeCall("build.make",makeTargetName.c_str()));
// Write the rule.
lg->WriteMakeRule(ruleFileStream, "Convenience name for target.",
localName.c_str(), depends, commands);
// Add a target with the canonical name (no prefix, suffix or path).
if(localName != t->second.GetName())
{
commands.clear();
tgt_depends.clear();
tgt_depends.push_back(localName);
lg->WriteMakeRule(ruleFileStream, "Convenience name for target.",
t->second.GetName(), tgt_depends, commands);
}
}
}
}

14
Source/cmGlobalUnixMakefileGenerator3.h
View File

@ -19,6 +19,9 @@
#include "cmGlobalGenerator.h"
class cmGeneratedFileStream;
class cmLocalUnixMakefileGenerator3;
/** \class cmGlobalUnixMakefileGenerator3
* \brief Write a Unix makefiles.
*
@ -60,8 +63,15 @@ protected:
void WriteDependMakefile();
void WriteBuildMakefile();
void WriteCleanMakefile();
void WriteSupportMakefiles();
void WriteMainCMakefileLanguageRules(cmGeneratedFileStream& cmakefileStream);
void WriteAllRules(cmLocalUnixMakefileGenerator3 *lg,
std::ostream& makefileStream);
/** used to create a recursive make call */
std::string GetRecursiveMakeCall(const char *makefile, const char* tgt);
void WriteConvenienceRules(std::ostream& ruleFileStream, cmLocalUnixMakefileGenerator3 *);
};
#endif

718
Source/cmLocalUnixMakefileGenerator3.cxx
View File

@ -34,9 +34,6 @@
#include <memory> // auto_ptr
#include <queue>
// TODO: Convert makefile name to a runtime switch.
#define CMLUMG_MAKEFILE_NAME "Makefile"
// TODO: Add "help" target.
// TODO: Identify remaining relative path violations.
// TODO: Need test for separate executable/library output path.
@ -57,16 +54,6 @@ cmLocalUnixMakefileGenerator3::~cmLocalUnixMakefileGenerator3()
{
}
//----------------------------------------------------------------------------
void cmLocalUnixMakefileGenerator3::SetEmptyCommand(const char* cmd)
{
m_EmptyCommands.clear();
if(cmd)
{
m_EmptyCommands.push_back(cmd);
}
}
//----------------------------------------------------------------------------
void cmLocalUnixMakefileGenerator3::Generate()
{
@ -82,20 +69,69 @@ void cmLocalUnixMakefileGenerator3::Generate()
(t->second.GetType() == cmTarget::SHARED_LIBRARY) ||
(t->second.GetType() == cmTarget::MODULE_LIBRARY))
{
this->GenerateTargetRuleFile(t->second);
this->WriteTargetRuleFiles(t->second);
}
else if(t->second.GetType() == cmTarget::UTILITY)
{
this->GenerateUtilityRuleFile(t->second);
this->WriteUtilityRuleFiles(t->second);
}
}
this->WriteCustomCommands();
// Generate the cmake file with information for this directory.
this->GenerateDirectoryInformationFile();
// Write the cmake file with information for this directory.
this->WriteDirectoryInformationFile();
}
//----------------------------------------------------------------------------
void cmLocalUnixMakefileGenerator3::ConfigureOutputPaths()
{
// Format the library and executable output paths.
if(const char* libOut = m_Makefile->GetDefinition("LIBRARY_OUTPUT_PATH"))
{
m_LibraryOutputPath = libOut;
this->FormatOutputPath(m_LibraryOutputPath, "LIBRARY");
}
if(const char* exeOut = m_Makefile->GetDefinition("EXECUTABLE_OUTPUT_PATH"))
{
m_ExecutableOutputPath = exeOut;
this->FormatOutputPath(m_ExecutableOutputPath, "EXECUTABLE");
}
}
//----------------------------------------------------------------------------
void cmLocalUnixMakefileGenerator3::FormatOutputPath(std::string& path,
const char* name)
{
if(!path.empty())
{
// Convert the output path to a full path in case it is
// specified as a relative path. Treat a relative path as
// relative to the current output directory for this makefile.
path =
cmSystemTools::CollapseFullPath(path.c_str(),
m_Makefile->GetStartOutputDirectory());
// Add a trailing slash for easy appending later.
if(path.empty() || path[path.size()-1] != '/')
{
path += "/";
}
// Make sure the output path exists on disk.
if(!cmSystemTools::MakeDirectory(path.c_str()))
{
cmSystemTools::Error("Error failed to create ",
name, "_OUTPUT_PATH directory:", path.c_str());
}
// Add this as a link directory automatically.
m_Makefile->AddLinkDirectory(path.c_str());
}
}
void cmLocalUnixMakefileGenerator3::WriteCustomCommands()
{
// Generate the rule files for each custom command.
@ -135,7 +171,6 @@ void cmLocalUnixMakefileGenerator3::WriteCustomCommands()
<< this->ConvertToOutputForExisting(objTarget.c_str()).c_str()
<< "\n";
}
// now do the clean
ruleFileName = "CMakeCustomRules.dir/clean.make";
@ -182,7 +217,7 @@ void cmLocalUnixMakefileGenerator3::WriteCustomCommands()
}
//----------------------------------------------------------------------------
void cmLocalUnixMakefileGenerator3::GenerateDirectoryInformationFile()
void cmLocalUnixMakefileGenerator3::WriteDirectoryInformationFile()
{
std::string infoFileName = m_Makefile->GetStartOutputDirectory();
infoFileName += "/CMakeDirectoryInformation.cmake";
@ -246,6 +281,29 @@ void cmLocalUnixMakefileGenerator3::GenerateDirectoryInformationFile()
<< "SET(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN})\n";
}
//----------------------------------------------------------------------------
std::string
cmLocalUnixMakefileGenerator3
::ConvertToFullPath(const std::string& localPath)
{
std::string dir = m_Makefile->GetStartOutputDirectory();
dir += "/";
dir += localPath;
return dir;
}
//----------------------------------------------------------------------------
void cmLocalUnixMakefileGenerator3::WriteDisclaimer(std::ostream& os)
{
os
<< "# CMAKE generated file: DO NOT EDIT!\n"
<< "# Generated by \"" << m_GlobalGenerator->GetName() << "\""
<< " Generator, CMake Version "
<< cmMakefile::GetMajorVersion() << "."
<< cmMakefile::GetMinorVersion() << "\n\n";
}
std::string cmLocalUnixMakefileGenerator3::GetHomeRelativeOutputPath()
{
// Include the rule file for each object.
@ -262,7 +320,7 @@ std::string cmLocalUnixMakefileGenerator3::GetHomeRelativeOutputPath()
//----------------------------------------------------------------------------
void
cmLocalUnixMakefileGenerator3
::GenerateTargetRuleFile(const cmTarget& target)
::WriteTargetRuleFiles(const cmTarget& target)
{
// Create a directory for this target.
std::string dir = this->GetTargetDirectory(target);
@ -283,8 +341,7 @@ cmLocalUnixMakefileGenerator3
if(!m_GlobalGenerator->IgnoreFile((*source)->GetSourceExtension().c_str()))
{
// Generate this object file's rule file.
this->GenerateObjectRuleFile(target, *(*source), objects,
provides_requires);
this->WriteObjectRuleFiles(target, *(*source), objects,provides_requires);
}
else if((*source)->GetPropertyAsBool("EXTERNAL_OBJECT"))
{
@ -303,9 +360,6 @@ cmLocalUnixMakefileGenerator3
std::string ruleFileName = dir;
ruleFileName += "/build.make";
// The rule file must be included by the makefile.
m_IncludeRuleFiles.push_back(ruleFileName);
// Open the rule file. This should be copy-if-different because the
// rules may depend on this file itself.
std::string ruleFileNameFull = this->ConvertToFullPath(ruleFileName);
@ -370,13 +424,22 @@ cmLocalUnixMakefileGenerator3
//----------------------------------------------------------------------------
void
cmLocalUnixMakefileGenerator3
::GenerateObjectDependFile(const std::string& obj, const cmSourceFile& source,
std::vector<std::string>& objects,
std::vector<std::string>& provides_requires,
const std::string& depMarkFile,
std::vector<std::string>& depends)
::WriteObjectDependFile(std::string &obj,
const char * lang,
const cmSourceFile& source,
std::vector<std::string>& depends,
std::string& depMakeFile)
{
const char* lang = this->GetSourceFileLanguage(source);
// TODO: what the heck is this?
// Generate the build-time dependencies file for this object file.
std::string depMarkFile;
if(!this->GenerateDependsMakeFile(lang, obj.c_str(),
depMakeFile, depMarkFile))
{
cmSystemTools::Error("No dependency checker available for language \"",
lang, "\".");
return;
}
// Open the rule file for writing. This should be copy-if-different
// because the rules may depend on this file itself.
@ -441,68 +504,14 @@ cmLocalUnixMakefileGenerator3
//----------------------------------------------------------------------------
void
cmLocalUnixMakefileGenerator3
::GenerateObjectRuleFile(const cmTarget& target, const cmSourceFile& source,
std::vector<std::string>& objects,
std::vector<std::string>& provides_requires)
::WriteObjectBuildFile(std::string &obj,
const char *lang,
const cmTarget& target,
const cmSourceFile& source,
std::vector<std::string>& depends,
std::string &depMakeFile,
std::vector<std::string>& provides_requires)
{
// Identify the language of the source file.
const char* lang = this->GetSourceFileLanguage(source);
if(!lang)
{
// If language is not known, this is an error.
cmSystemTools::Error("Source file \"", source.GetFullPath().c_str(),
"\" has unknown type.");
return;
}
// Get the full path name of the object file.
std::string obj = this->GetObjectFileName(target, source);
// Avoid generating duplicate rules.
if(m_ObjectFiles.find(obj) == m_ObjectFiles.end())
{
m_ObjectFiles.insert(obj);
}
else
{
cmOStringStream err;
err << "Warning: Source file \""
<< source.GetSourceName().c_str() << "."
<< source.GetSourceExtension().c_str()
<< "\" is listed multiple times for target \"" << target.GetName()
<< "\".";
cmSystemTools::Message(err.str().c_str(), "Warning");
return;
}
// Create the directory containing the object file. This may be a
// subdirectory under the target's directory.
std::string dir = cmSystemTools::GetFilenamePath(obj.c_str());
cmSystemTools::MakeDirectory(this->ConvertToFullPath(dir).c_str());
// Generate the build-time dependencies file for this object file.
std::string depMakeFile;
std::string depMarkFile;
if(!this->GenerateDependsMakeFile(lang, obj.c_str(),
depMakeFile, depMarkFile))
{
cmSystemTools::Error("No dependency checker available for language \"",
lang, "\".");
return;
}
// Save this in the target's list of object files.
objects.push_back(obj);
std::string relativeObj = this->GetHomeRelativeOutputPath();
relativeObj += obj;
// The object file should be checked for dependency integrity.
m_CheckDependFiles[lang].insert(obj);
// write the .depends.make file
std::vector<std::string> depends;
this->GenerateObjectDependFile(obj,source,objects,provides_requires,depMarkFile,depends);
// Open the rule file for writing. This should be copy-if-different
// because the rules may depend on this file itself.
std::string ruleFileName = obj;
@ -570,6 +579,8 @@ cmLocalUnixMakefileGenerator3
this->ConvertToRelativeOutputPath(obj.c_str());
// Construct the build message.
std::string relativeObj = this->GetHomeRelativeOutputPath();
relativeObj += obj;
std::vector<std::string> commands;
std::string buildEcho = "Building ";
buildEcho += lang;
@ -626,6 +637,91 @@ cmLocalUnixMakefileGenerator3
}
}
//----------------------------------------------------------------------------
void
cmLocalUnixMakefileGenerator3
::WriteObjectRuleFiles(const cmTarget& target, const cmSourceFile& source,
std::vector<std::string>& objects,
std::vector<std::string>& provides_requires)
{
// Identify the language of the source file.
const char* lang = this->GetSourceFileLanguage(source);
if(!lang)
{
// If language is not known, this is an error.
cmSystemTools::Error("Source file \"", source.GetFullPath().c_str(),
"\" has unknown type.");
return;
}
// Get the full path name of the object file.
std::string obj = this->GetObjectFileName(target, source);
// Avoid generating duplicate rules.
if(m_ObjectFiles.find(obj) == m_ObjectFiles.end())
{
m_ObjectFiles.insert(obj);
}
else
{
cmOStringStream err;
err << "Warning: Source file \""
<< source.GetSourceName().c_str() << "."
<< source.GetSourceExtension().c_str()
<< "\" is listed multiple times for target \"" << target.GetName()
<< "\".";
cmSystemTools::Message(err.str().c_str(), "Warning");
return;
}
// Create the directory containing the object file. This may be a
// subdirectory under the target's directory.
std::string dir = cmSystemTools::GetFilenamePath(obj.c_str());
cmSystemTools::MakeDirectory(this->ConvertToFullPath(dir).c_str());
// Save this in the target's list of object files.
objects.push_back(obj);
std::string relativeObj = this->GetHomeRelativeOutputPath();
relativeObj += obj;
// we compute some depends when writing the depend.make that we will also
// use in the build.make, same with depMakeFile
std::vector<std::string> depends;
std::string depMakeFile;
// generate the depends rule file
this->WriteObjectDependFile(obj, lang, source, depends, depMakeFile);
// generate the build rule file
this->WriteObjectBuildFile(obj, lang, target, source, depends, depMakeFile,
provides_requires);
// The object file should be checked for dependency integrity.
m_CheckDependFiles[lang].insert(relativeObj);
// If the language needs provides-requires mode, create the
// corresponding targets.
/*
if(strcmp(lang, "Fortran") == 0)
{
std::string objectRequires = obj;
std::string objectProvides = obj;
objectRequires += ".requires";
objectProvides += ".provides";
// Add the provides target to build the object file.
std::vector<std::string> no_commands;
std::vector<std::string> p_depends;
p_depends.push_back(obj);
this->WriteMakeRule(ruleFileStream, 0,
objectProvides.c_str(), p_depends, no_commands);
// Add this to the set of provides-requires objects on the target.
provides_requires.push_back(objectRequires);
}
*/
}
//----------------------------------------------------------------------------
void
cmLocalUnixMakefileGenerator3
@ -659,9 +755,6 @@ cmLocalUnixMakefileGenerator3
}
m_CustomRuleFiles.insert(ruleFileName);
// This rule should be included by the makefile.
m_IncludeRuleFiles.push_back(ruleFileName);
// what is the relative path to the rule file
std::string relRuleFile = this->GetHomeRelativeOutputPath();
relRuleFile += ruleFileName;
@ -707,7 +800,7 @@ cmLocalUnixMakefileGenerator3
//----------------------------------------------------------------------------
void
cmLocalUnixMakefileGenerator3
::GenerateUtilityRuleFile(const cmTarget& target)
::WriteUtilityRuleFiles(const cmTarget& target)
{
// Create a directory for this target.
std::string dir = this->GetTargetDirectory(target);
@ -717,9 +810,6 @@ cmLocalUnixMakefileGenerator3
std::string ruleFileName = dir;
ruleFileName += "/build.make";
// This rule should be included by the makefile.
m_IncludeRuleFiles.push_back(ruleFileName);
// Open the rule file. This should be copy-if-different because the
// rules may depend on this file itself.
std::string ruleFileNameFull = this->ConvertToFullPath(ruleFileName);
@ -785,9 +875,11 @@ cmLocalUnixMakefileGenerator3
depMakeFile = checker->GetMakeFileName();
depMarkFile = checker->GetMarkFileName();
// Todo is this required???
// Check the dependencies.
checker->Check();
return true;
}
return false;
@ -867,6 +959,88 @@ cmLocalUnixMakefileGenerator3
os << "\n";
}
//----------------------------------------------------------------------------
void cmLocalUnixMakefileGenerator3::WriteDivider(std::ostream& os)
{
os
<< "#======================================"
<< "=======================================\n";
}
//----------------------------------------------------------------------------
void
cmLocalUnixMakefileGenerator3
::WriteMakeVariables(std::ostream& makefileStream)
{
this->WriteDivider(makefileStream);
makefileStream
<< "# Set environment variables for the build.\n"
<< "\n";
if(m_WindowsShell)
{
makefileStream
<< "!IF \"$(OS)\" == \"Windows_NT\"\n"
<< "NULL=\n"
<< "!ELSE\n"
<< "NULL=nul\n"
<< "!ENDIF\n";
}
else
{
makefileStream
<< "# The shell in which to execute make rules.\n"
<< "SHELL = /bin/sh\n"
<< "\n";
}
if(m_Makefile->IsOn("CMAKE_VERBOSE_MAKEFILE"))
{
makefileStream
<< "# Produce verbose output by default.\n"
<< "VERBOSE = 1\n"
<< "\n";
}
std::string cmakecommand =
this->ConvertToOutputForExisting(
m_Makefile->GetRequiredDefinition("CMAKE_COMMAND"));
makefileStream
<< "# The CMake executable.\n"
<< "CMAKE_COMMAND = "
<< m_GlobalGenerator->ConvertToHomeRelativeOutputPath
(cmakecommand.c_str()).c_str() << "\n"
<< "\n";
makefileStream
<< "# The command to remove a file.\n"
<< "RM = "
<< this->ConvertToRelativeOutputPath(cmakecommand.c_str()).c_str()
<< " -E remove -f\n"
<< "\n";
if(m_Makefile->GetDefinition("CMAKE_EDIT_COMMAND"))
{
makefileStream
<< "# The program to use to edit the cache.\n"
<< "CMAKE_EDIT_COMMAND = "
<< (this->ConvertToOutputForExisting(
m_Makefile->GetDefinition("CMAKE_EDIT_COMMAND"))) << "\n"
<< "\n";
}
makefileStream
<< "# The top-level source directory on which CMake was run.\n"
<< "CMAKE_SOURCE_DIR = "
<< this->ConvertToRelativeOutputPath(m_Makefile->GetHomeDirectory())
<< "\n"
<< "\n";
makefileStream
<< "# The top-level build directory on which CMake was run.\n"
<< "CMAKE_BINARY_DIR = "
<< this->ConvertToRelativeOutputPath(m_Makefile->GetHomeOutputDirectory())
<< "\n"
<< "\n";
}
void cmLocalUnixMakefileGenerator3::WriteTargetIncludes(std::ostream& makefileStream,
const char *file,
const char *rule)
@ -973,98 +1147,6 @@ cmLocalUnixMakefileGenerator3
}
}
//----------------------------------------------------------------------------
void cmLocalUnixMakefileGenerator3::WriteDivider(std::ostream& os)
{
os
<< "#======================================"
<< "=======================================\n";
}
//----------------------------------------------------------------------------
void cmLocalUnixMakefileGenerator3::WriteDisclaimer(std::ostream& os)
{
os
<< "# CMAKE generated file: DO NOT EDIT!\n"
<< "# Generated by \"" << m_GlobalGenerator->GetName() << "\""
<< " Generator, CMake Version "
<< cmMakefile::GetMajorVersion() << "."
<< cmMakefile::GetMinorVersion() << "\n\n";
}
//----------------------------------------------------------------------------
void
cmLocalUnixMakefileGenerator3
::WriteMakeVariables(std::ostream& makefileStream)
{
this->WriteDivider(makefileStream);
makefileStream
<< "# Set environment variables for the build.\n"
<< "\n";
if(m_WindowsShell)
{
makefileStream
<< "!IF \"$(OS)\" == \"Windows_NT\"\n"
<< "NULL=\n"
<< "!ELSE\n"
<< "NULL=nul\n"
<< "!ENDIF\n";
}
else
{
makefileStream
<< "# The shell in which to execute make rules.\n"
<< "SHELL = /bin/sh\n"
<< "\n";
}
if(m_Makefile->IsOn("CMAKE_VERBOSE_MAKEFILE"))
{
makefileStream
<< "# Produce verbose output by default.\n"
<< "VERBOSE = 1\n"
<< "\n";
}
std::string cmakecommand =
this->ConvertToOutputForExisting(
m_Makefile->GetRequiredDefinition("CMAKE_COMMAND"));
makefileStream
<< "# The CMake executable.\n"
<< "CMAKE_COMMAND = "
<< m_GlobalGenerator->ConvertToHomeRelativeOutputPath
(cmakecommand.c_str()).c_str() << "\n"
<< "\n";
makefileStream
<< "# The command to remove a file.\n"
<< "RM = "
<< this->ConvertToRelativeOutputPath(cmakecommand.c_str()).c_str()
<< " -E remove -f\n"
<< "\n";
if(m_Makefile->GetDefinition("CMAKE_EDIT_COMMAND"))
{
makefileStream
<< "# The program to use to edit the cache.\n"
<< "CMAKE_EDIT_COMMAND = "
<< (this->ConvertToOutputForExisting(
m_Makefile->GetDefinition("CMAKE_EDIT_COMMAND"))) << "\n"
<< "\n";
}
makefileStream
<< "# The top-level source directory on which CMake was run.\n"
<< "CMAKE_SOURCE_DIR = "
<< this->ConvertToRelativeOutputPath(m_Makefile->GetHomeDirectory())
<< "\n"
<< "\n";
makefileStream
<< "# The top-level build directory on which CMake was run.\n"
<< "CMAKE_BINARY_DIR = "
<< this->ConvertToRelativeOutputPath(m_Makefile->GetHomeOutputDirectory())
<< "\n"
<< "\n";
}
//----------------------------------------------------------------------------
void
@ -1219,7 +1301,7 @@ cmLocalUnixMakefileGenerator3
{
// Build command to run CMake to check if anything needs regenerating.
std::string cmakefileName = m_Makefile->GetStartOutputDirectory();
cmakefileName += "/" CMLUMG_MAKEFILE_NAME ".cmake";
cmakefileName += "/Makefile.cmake";
std::string runRule =
"$(CMAKE_COMMAND) -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)";
runRule += " --check-build-system ";
@ -1267,86 +1349,7 @@ cmLocalUnixMakefileGenerator3
".SUFFIXES", depends, no_commands);
}
//----------------------------------------------------------------------------
void
cmLocalUnixMakefileGenerator3
::WriteAllRules(std::ostream& makefileStream)
{
// Write section header.
this->WriteDivider(makefileStream);
makefileStream
<< "# Rules to build dependencies and targets.\n"
<< "\n";
std::vector<std::string> depends;
std::vector<std::string> commands;
// Check the build system in this directory.
depends.push_back("cmake_check_build_system");
commands.push_back(this->GetRecursiveMakeCall("depend.make",0));
commands.push_back(this->GetRecursiveMakeCall("build.make",0));
// Write the rule.
this->WriteMakeRule(makefileStream, "The main all target", "all", depends, commands);
// write the clean
commands.clear();
commands.push_back(this->GetRecursiveMakeCall("clean.make",0));
this->WriteMakeRule(makefileStream, "default clean target", "clean", depends, commands);
}
//----------------------------------------------------------------------------
void
cmLocalUnixMakefileGenerator3
::WriteConvenienceRules(std::ostream& ruleFileStream)
{
std::vector<std::string> depends;
std::vector<std::string> tgt_depends;
std::vector<std::string> commands;
depends.push_back("cmake_check_build_system");
// for each target
// Generate the rule files for each target.
const cmTargets& targets = m_Makefile->GetTargets();
std::string localName;
std::string makeTargetName;
for(cmTargets::const_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))
{
// Add a rule to build the target by name.
localName = this->GetRelativeTargetDirectory(t->second);
commands.clear();
makeTargetName = localName;
makeTargetName += "/depend";
commands.push_back(this->GetRecursiveMakeCall("depend.make",makeTargetName.c_str()));
makeTargetName = localName;
makeTargetName += "/build";
commands.push_back(this->GetRecursiveMakeCall("build.make",makeTargetName.c_str()));
// Write the rule.
this->WriteMakeRule(ruleFileStream, "Convenience name for target.",
localName.c_str(), depends, commands);
// Add a target with the canonical name (no prefix, suffix or path).
if(localName != t->second.GetName())
{
commands.clear();
tgt_depends.clear();
tgt_depends.push_back(localName);
this->WriteMakeRule(ruleFileStream, "Convenience name for target.",
t->second.GetName(), tgt_depends, commands);
}
}
}
}
//----------------------------------------------------------------------------
void
@ -1371,35 +1374,6 @@ cmLocalUnixMakefileGenerator3
}
}
//----------------------------------------------------------------------------
void
cmLocalUnixMakefileGenerator3
::WriteRuleFileIncludes(std::ostream& makefileStream)
{
// Make sure we have some rules to include.
if(m_IncludeRuleFiles.empty())
{
return;
}
// Write section header.
this->WriteDivider(makefileStream);
makefileStream
<< "# Include rule files for this directory.\n"
<< "\n";
// Write the include rules.
for(std::vector<std::string>::const_iterator i = m_IncludeRuleFiles.begin();
i != m_IncludeRuleFiles.end(); ++i)
{
makefileStream
<< m_IncludeDirective << " "
<< this->ConvertToOutputForExisting(i->c_str()).c_str()
<< "\n";
}
makefileStream << "\n";
}
//----------------------------------------------------------------------------
void
cmLocalUnixMakefileGenerator3
@ -2061,52 +2035,6 @@ cmLocalUnixMakefileGenerator3
cleanTarget.c_str(), no_depends, commands);
}
//----------------------------------------------------------------------------
void
cmLocalUnixMakefileGenerator3
::WriteTargetRequiresRule(std::ostream& ruleFileStream, const cmTarget& target,
const std::vector<std::string>& provides_requires)
{
// Create the driving make target.
std::string targetRequires = target.GetName();
targetRequires += ".requires";
std::string comment = "Directory-level driver rulue for this target.";
if(provides_requires.empty())
{
// No provides-requires mode objects in this target. Anything
// that requires the target can build it directly.
std::vector<std::string> no_commands;
std::vector<std::string> depends;
depends.push_back(target.GetName());
this->WriteMakeRule(ruleFileStream, comment.c_str(),
targetRequires.c_str(), depends, no_commands);
}
else
{
// There are provides-requires mode objects in this target. Use
// provides-requires mode to build the target itself.
std::string targetProvides = target.GetName();
targetProvides += ".provides";
{
std::vector<std::string> no_commands;
std::vector<std::string> depends;
depends.push_back(target.GetName());
this->WriteMakeRule(ruleFileStream, 0,
targetProvides.c_str(), depends, no_commands);
}
{
// Build list of require-level dependencies.
std::vector<std::string> depends;
for(std::vector<std::string>::const_iterator
pr = provides_requires.begin();
pr != provides_requires.end(); ++pr)
{
depends.push_back(*pr);
}
}
}
}
//----------------------------------------------------------------------------
void
@ -2239,17 +2167,6 @@ cmLocalUnixMakefileGenerator3
->GetLanguageFromExtension(source.GetSourceExtension().c_str()));
}
//----------------------------------------------------------------------------
std::string
cmLocalUnixMakefileGenerator3
::ConvertToFullPath(const std::string& localPath)
{
std::string dir = m_Makefile->GetStartOutputDirectory();
dir += "/";
dir += localPath;
return dir;
}
//----------------------------------------------------------------------------
std::string
cmLocalUnixMakefileGenerator3::ConvertToRelativeOutputPath(const char* p)
@ -2319,53 +2236,6 @@ cmLocalUnixMakefileGenerator3::ConvertToQuotedOutputPath(const char* p)
return result;
}
//----------------------------------------------------------------------------
void cmLocalUnixMakefileGenerator3::ConfigureOutputPaths()
{
// Format the library and executable output paths.
if(const char* libOut = m_Makefile->GetDefinition("LIBRARY_OUTPUT_PATH"))
{
m_LibraryOutputPath = libOut;
this->FormatOutputPath(m_LibraryOutputPath, "LIBRARY");
}
if(const char* exeOut = m_Makefile->GetDefinition("EXECUTABLE_OUTPUT_PATH"))
{
m_ExecutableOutputPath = exeOut;
this->FormatOutputPath(m_ExecutableOutputPath, "EXECUTABLE");
}
}
//----------------------------------------------------------------------------
void cmLocalUnixMakefileGenerator3::FormatOutputPath(std::string& path,
const char* name)
{
if(!path.empty())
{
// Convert the output path to a full path in case it is
// specified as a relative path. Treat a relative path as
// relative to the current output directory for this makefile.
path =
cmSystemTools::CollapseFullPath(path.c_str(),
m_Makefile->GetStartOutputDirectory());
// Add a trailing slash for easy appending later.
if(path.empty() || path[path.size()-1] != '/')
{
path += "/";
}
// Make sure the output path exists on disk.
if(!cmSystemTools::MakeDirectory(path.c_str()))
{
cmSystemTools::Error("Error failed to create ",
name, "_OUTPUT_PATH directory:", path.c_str());
}
// Add this as a link directory automatically.
m_Makefile->AddLinkDirectory(path.c_str());
}
}
//----------------------------------------------------------------------------
void
cmLocalUnixMakefileGenerator3
@ -2839,43 +2709,6 @@ cmLocalUnixMakefileGenerator3
}
//============================================================================
//----------------------------------------------------------------------------
std::string
cmLocalUnixMakefileGenerator3
::GetRecursiveMakeCall(const char *Makefile, const char* tgt)
{
// Call make on the given file.
std::string cmd;
cmd += "$(MAKE) -f ";
cmd += Makefile;
cmd += " ";
// Pass down verbosity level.
if(m_MakeSilentFlag.size())
{
cmd += m_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(m_PassMakeflags)
{
cmd += "-$(MAKEFLAGS) ";
}
// Add the target.
if (tgt && tgt[0] != '\0')
{
std::string tgt2 = this->ConvertToRelativeOutputPath(tgt);
tgt2 = this->ConvertToMakeTarget(tgt2.c_str());
cmd += tgt2;
}
return cmd;
}
//----------------------------------------------------------------------------
cmDepends*
cmLocalUnixMakefileGenerator3::GetDependsChecker(const std::string& lang,
@ -3039,3 +2872,4 @@ void cmLocalUnixMakefileGenerator3::CheckDependencies(cmMakefile* mf)
}
}
}

236
Source/cmLocalUnixMakefileGenerator3.h
View File

@ -35,16 +35,54 @@ class cmSourceFile;
class cmLocalUnixMakefileGenerator3 : public cmLocalGenerator
{
public:
///! Set cache only and recurse to false by default.
cmLocalUnixMakefileGenerator3();
virtual ~cmLocalUnixMakefileGenerator3();
/** Set the command used when there are no dependencies or rules for
a target. This is used to avoid errors on some make
implementations. */
void SetEmptyCommand(const char* cmd);
/**
* Generate the makefile for this directory.
*/
virtual void Generate();
/** creates the common disclainer text at the top of each makefile */
void WriteDisclaimer(std::ostream& os);
// this returns the relative path between the HomeOutputDirectory and this
// local generators StartOutputDirectory
std::string GetHomeRelativeOutputPath();
// Write out a make rule
void WriteMakeRule(std::ostream& os,
const char* comment,
const char* target,
const std::vector<std::string>& depends,
const std::vector<std::string>& commands);
// write the main variables used by the makefiles
void WriteMakeVariables(std::ostream& makefileStream);
// write a comment line #====... in the stream
void WriteDivider(std::ostream& os);
/**
* If true, then explicitly pass MAKEFLAGS on the make all target for makes
* that do not use environment variables.
*
*/
void SetPassMakeflags(bool s){m_PassMakeflags = s;}
bool GetPassMakeflags() { return m_PassMakeflags; }
/**
* Set the flag used to keep the make program silent.
*/
void SetMakeSilentFlag(const char* s) { m_MakeSilentFlag = s; }
std::string &GetMakeSilentFlag() { return m_MakeSilentFlag; }
/** Set whether the echo command needs its argument quoted. */
void SetEchoNeedsQuote(bool b) { m_EchoNeedsQuote = b; }
@ -62,11 +100,6 @@ public:
void SetIncludeDirective(const char* s) { m_IncludeDirective = s; }
const char *GetIncludeDirective() { return m_IncludeDirective.c_str(); }
/**
* Set the flag used to keep the make program silent.
*/
void SetMakeSilentFlag(const char* s) { m_MakeSilentFlag = s; }
/**
* Set max makefile variable size, default is 0 which means unlimited.
*/
@ -78,45 +111,29 @@ public:
*/
void SetIgnoreLibPrefix(bool s) { m_IgnoreLibPrefix = s; }
/**
* If true, then explicitly pass MAKEFLAGS on the make all target for makes
* that do not use environment variables.
*
*/
void SetPassMakeflags(bool s){m_PassMakeflags = s;}
/**
* Generate the makefile for this directory.
*/
virtual void Generate();
/** Called from command-line hook to scan dependencies. */
static bool ScanDependencies(std::vector<std::string> const& args);
/** Called from command-line hook to check dependencies. */
static void CheckDependencies(cmMakefile* mf);
/** write some extra rules suahc as make test etc */
void WriteSpecialTargetsTop(std::ostream& makefileStream);
void WriteDisclaimer(std::ostream& os);
void WriteMakeRule(std::ostream& os,
const char* comment,
const char* target,
const std::vector<std::string>& depends,
const std::vector<std::string>& commands);
void WriteAllRules(std::ostream& makefileStream);
void WriteTargetIncludes(std::ostream& makefileStream,const char *file,
const char *rule);
void WriteSpecialTargetsTop(std::ostream& makefileStream);
void WriteSpecialTargetsBottom(std::ostream& makefileStream);
void WriteMakeVariables(std::ostream& makefileStream);
std::string ConvertToRelativeOutputPath(const char* p);
void WriteConvenienceRules(std::ostream& ruleFileStream);
std::string GetRelativeTargetDirectory(const cmTarget& target);
void WriteLocalCleanRule(std::ostream& makefileStream);
// this returns the relative path between the HomeOutputDirectory and this
// local generators StartOutputDirectory
std::string GetHomeRelativeOutputPath();
// List the files for which to check dependency integrity. Each
// language has its own list because integrity may be checked
// differently.
@ -126,45 +143,69 @@ public:
protected:
void GenerateMakefile();
void GenerateCMakefile();
void GenerateDirectoryInformationFile();
void GenerateTargetRuleFile(const cmTarget& target);
void GenerateObjectRuleFile(const cmTarget& target,
const cmSourceFile& source,
std::vector<std::string>& objects,
std::vector<std::string>& provides_requires);
void GenerateObjectDependFile(const std::string& obj,
const cmSourceFile& source,
std::vector<std::string>& objects,
std::vector<std::string>& provides_requires,
const std::string& depMarkFile,
std::vector<std::string>& depends);
void GenerateCustomRuleFile(const cmCustomCommand& cc);
void GenerateUtilityRuleFile(const cmTarget& target);
// these two methods just compute reasonable values for m_LibraryOutputPath and
// m_ExecutableOutputPath
void ConfigureOutputPaths();
void FormatOutputPath(std::string& path, const char* name);
// this converts a file name that is relative to the StartOuputDirectory
// into a full path
std::string ConvertToFullPath(const std::string& localPath);
// this is responsible for writing all of the rules for all this
// directories custom commands (but not utility targets)
void WriteCustomCommands();
// this method Writes the Directory informaiton files
void WriteDirectoryInformationFile();
// cleanup the name of a potential target
std::string ConvertToMakeTarget(const char* tgt);
// used in writing out Cmake files such as WriteDirectoryInformation
void WriteCMakeArgument(std::ostream& os, const char* s);
// write out all the rules for this target
void WriteTargetRuleFiles(const cmTarget& target);
void WriteUtilityRuleFiles(const cmTarget& target);
// create the rule files for an object
void WriteObjectRuleFiles(const cmTarget& target,
const cmSourceFile& source,
std::vector<std::string>& objects,
std::vector<std::string>& provides_requires);
// write the build rule for an object
void WriteObjectBuildFile(std::string &obj,
const char *lang,
const cmTarget& target,
const cmSourceFile& source,
std::vector<std::string>& depends,
std::string &depMakeFile,
std::vector<std::string>& provides_requires);
// write the depend.make file for an object
void WriteObjectDependFile(std::string& obj,
const char *lang,
const cmSourceFile& source,
std::vector<std::string>& depends,
std::string& depMarkFile);
// this is used only by WriteObjectDependFile
bool GenerateDependsMakeFile(const std::string& lang,
const char* objFile,
std::string& depMakeFile,
std::string& depMarkFile);
void WriteDivider(std::ostream& os);
void WriteRuleFileIncludes(std::ostream& makefileStream);
void WriteSubdirRules(std::ostream& makefileStream, const char* pass);
void WriteSubdirRule(std::ostream& makefileStream, const char* pass,
const char* subdir, std::string& last);
void WriteSubdirDriverRule(std::ostream& makefileStream, const char* pass,
const char* order, const std::string& last);
void WriteLocalRule(std::ostream& ruleFileStream, const char* pass,
const char* dependency);
void WriteConvenienceRule(std::ostream& ruleFileStream,
const char* realTarget,
const char* helpTarget);
void WriteCustomCommands();
void WriteExecutableRule(std::ostream& ruleFileStream,
const char* ruleFileName,
const cmTarget& target,
const std::vector<std::string>& objects,
const std::vector<std::string>& external_objects,
const std::vector<std::string>& provides_requires);
// return the appropriate depends checker
static cmDepends* GetDependsChecker(const std::string& lang,
const char* dir,
const char* objFile);
void GenerateCustomRuleFile(const cmCustomCommand& cc);
// these three make some simple changes and then call WriteLibraryRule
void WriteStaticLibraryRule(std::ostream& ruleFileStream,
const char* ruleFileName,
const cmTarget& target,
@ -183,6 +224,16 @@ protected:
const std::vector<std::string>& objects,
const std::vector<std::string>& external_objects,
const std::vector<std::string>& provides_requires);
// the main code for writing the Executable target rules
void WriteExecutableRule(std::ostream& ruleFileStream,
const char* ruleFileName,
const cmTarget& target,
const std::vector<std::string>& objects,
const std::vector<std::string>& external_objects,
const std::vector<std::string>& provides_requires);
// the main method for writing library rules
void WriteLibraryRule(std::ostream& ruleFileStream,
const char* ruleFileName,
const cmTarget& target,
@ -191,6 +242,17 @@ protected:
const char* linkRuleVar,
const char* extraLinkFlags,
const std::vector<std::string>& provides_requires);
void WriteLocalRule(std::ostream& ruleFileStream, const char* pass,
const char* dependency);
void WriteConvenienceRule(std::ostream& ruleFileStream,
const char* realTarget,
const char* helpTarget);
void WriteObjectsVariable(std::ostream& ruleFileStream,
const cmTarget& target,
const std::vector<std::string>& objects,
@ -205,19 +267,13 @@ protected:
const std::vector<std::string>& files,
const std::vector<std::string>& objects,
const std::vector<std::string>& external_objects);
void WriteTargetRequiresRule(std::ostream& ruleFileStream,
const cmTarget& target,
const std::vector<std::string>& provides_requires);
void WriteCMakeArgument(std::ostream& os, const char* s);
std::string GetTargetDirectory(const cmTarget& target);
std::string GetSubdirTargetName(const char* pass, const char* subdir);
std::string GetObjectFileName(const cmTarget& target,
const cmSourceFile& source);
const char* GetSourceFileLanguage(const cmSourceFile& source);
std::string ConvertToFullPath(const std::string& localPath);
std::string ConvertToQuotedOutputPath(const char* p);
void ConfigureOutputPaths();
void FormatOutputPath(std::string& path, const char* name);
void AppendTargetDepends(std::vector<std::string>& depends,
const cmTarget& target);
@ -240,33 +296,14 @@ protected:
//==========================================================================
bool SamePath(const char* path1, const char* path2);
std::string ConvertToMakeTarget(const char* tgt);
std::string& CreateSafeUniqueObjectFileName(const char* sin);
std::string CreateMakeVariable(const char* sin, const char* s2in);
//==========================================================================
std::string GetRecursiveMakeCall(const char *makefile, const char* tgt);
void WriteJumpAndBuildRules(std::ostream& makefileStream);
static cmDepends* GetDependsChecker(const std::string& lang,
const char* dir,
const char* objFile);
private:
// Map from target name to build directory containing it for
// jump-and-build targets.
struct RemoteTarget
{
std::string m_BuildDirectory;
std::string m_FilePath;
};
std::map<cmStdString, RemoteTarget> m_JumpAndBuild;
std::map<cmStdString, IntegrityCheckSet> m_CheckDependFiles;
// Command used when a rule has no dependencies or commands.
std::vector<std::string> m_EmptyCommands;
//==========================================================================
// Configuration settings.
int m_MakefileVariableSize;
@ -283,9 +320,6 @@ private:
// Flag for whether echo command needs quotes.
bool m_EchoNeedsQuote;
// List of make rule files that need to be included by the makefile.
std::vector<std::string> m_IncludeRuleFiles;
// Set of custom rule files that have been generated.
std::set<cmStdString> m_CustomRuleFiles;