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

ENH: some more cleanup and changes to how custom commands are stored

This commit is contained in:
Ken Martin 2005-05-24 14:42:23 -04:00
parent ef6c5ae23e
commit baeeb40823
4 changed files with 113 additions and 282 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
Source/cmGlobalUnixMakefileGenerator3.cxx
View File

@ -102,7 +102,6 @@ void cmGlobalUnixMakefileGenerator3::Generate()
// now write the support Makefiles
//this->WriteBuildMakefile();
this->WriteCleanMakefile();
}
void cmGlobalUnixMakefileGenerator3::WriteMainMakefile()
@ -382,46 +381,6 @@ void cmGlobalUnixMakefileGenerator3::WriteBuildMakefile()
}
}
void cmGlobalUnixMakefileGenerator3::WriteCleanMakefile()
{
unsigned int i;
// 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 += "/clean.make";
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);
lg->WriteMakeVariables(makefileStream);
// add the generic dependency
std::vector<std::string> depends;
std::vector<std::string> no_commands;
lg->WriteMakeRule(makefileStream, 0, "clean", depends, no_commands);
// include all the target depends
for (i = 0; i < m_LocalGenerators.size(); ++i)
{
cmLocalUnixMakefileGenerator3 *lg2 =
static_cast<cmLocalUnixMakefileGenerator3 *>(m_LocalGenerators[i]);
lg2->WriteMainTargetIncludes(makefileStream,"clean.make","clean");
lg2->WriteMainTargetRules(makefileStream,"clean.make","clean",true);
// add the directory based rules
lg2->WriteLocalCleanRule(makefileStream);
}
}
//----------------------------------------------------------------------------
void cmGlobalUnixMakefileGenerator3
@ -451,8 +410,8 @@ void cmGlobalUnixMakefileGenerator3
commands, commands);
// write the clean
commands.push_back(lg->GetRecursiveMakeCall("clean.make",0));
lg->WriteMakeRule(makefileStream, "default clean target", "clean", depends, commands);
lg->WriteMakeRule(makefileStream, "The main clean target", "clean",
commands, commands);
}
@ -600,6 +559,20 @@ cmGlobalUnixMakefileGenerator3
depends.push_back(localName);
lg->WriteMakeRule(ruleFileStream, "Convenience name for target.",
t->second.GetName(), depends, commands);
// add the clean rule
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);
commands.clear();
depends.push_back(makeTargetName);
lg->WriteMakeRule(ruleFileStream, "clean rule for target.",
"clean", depends, commands);
}
}
}

1
Source/cmGlobalUnixMakefileGenerator3.h
View File

@ -61,7 +61,6 @@ protected:
void WriteMainMakefile();
void WriteMainCMakefile();
void WriteBuildMakefile();
void WriteCleanMakefile();
void WriteMainCMakefileLanguageRules(cmGeneratedFileStream& cmakefileStream);
void WriteAllRules(cmLocalUnixMakefileGenerator3 *lg,
std::ostream& makefileStream);

302
Source/cmLocalUnixMakefileGenerator3.cxx
View File

@ -60,11 +60,6 @@ void cmLocalUnixMakefileGenerator3::Generate()
// Setup our configuration variables for this directory.
this->ConfigureOutputPaths();
// write the custom commands, this must happen before writing the targets,
// but... it may be that it needs to happen after the TraveVSDependencies
// call
this->WriteCustomCommands();
// Generate the rule files for each target.
cmTargets& targets = m_Makefile->GetTargets();
std::string empty;
@ -141,89 +136,39 @@ void cmLocalUnixMakefileGenerator3::FormatOutputPath(std::string& path,
}
void cmLocalUnixMakefileGenerator3::WriteCustomCommands()
void cmLocalUnixMakefileGenerator3
::WriteCustomCommands(const cmTarget &target,std::ostream& ruleFileStream,
std::vector<std::string>& cleanFiles)
{
std::string tgtDir = m_Makefile->GetStartOutputDirectory();
tgtDir += "/";
tgtDir += this->GetTargetDirectory(target);
// add custom commands to the clean rules?
const char* clean_no_custom = m_Makefile->GetProperty("CLEAN_NO_CUSTOM");
bool clean = cmSystemTools::IsOff(clean_no_custom);
// Generate the rule files for each custom command.
const std::vector<cmSourceFile*>& sources = m_Makefile->GetSourceFiles();
for(std::vector<cmSourceFile*>::const_iterator i = sources.begin();
i != sources.end(); ++i)
{
if(const cmCustomCommand* cc = (*i)->GetCustomCommand())
{
this->GenerateCustomRuleFile(*cc);
}
}
// generate the includes
std::string ruleFileName = "CMakeCustomRules.dir/build.make";
// 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);
cmGeneratedFileStream ruleFileStream(ruleFileNameFull.c_str());
ruleFileStream.SetCopyIfDifferent(true);
if(!ruleFileStream)
{
return;
}
this->WriteDisclaimer(ruleFileStream);
std::string relPath = this->GetHomeRelativeOutputPath();
// get the classes from the source lists then add them to the groups
const std::vector<cmSourceFile*> &classes = target.GetSourceFiles();
std::string objTarget;
for(std::set<cmStdString>::const_iterator i = m_CustomRuleFiles.begin();
i != m_CustomRuleFiles.end(); ++i)
{
objTarget = relPath;
objTarget += *i;
ruleFileStream
<< m_IncludeDirective << " "
<< this->ConvertToOutputForExisting(objTarget.c_str()).c_str()
<< "\n";
}
// now do the clean
ruleFileName = "CMakeCustomRules.dir/clean.make";
// Open the rule file. This should be copy-if-different because the
// rules may depend on this file itself.
ruleFileNameFull = this->ConvertToFullPath(ruleFileName);
cmGeneratedFileStream ruleFileStream2(ruleFileNameFull.c_str());
ruleFileStream2.SetCopyIfDifferent(true);
if(!ruleFileStream2)
{
return;
}
this->WriteDisclaimer(ruleFileStream2);
std::vector<std::string> cleanFiles;
for(std::vector<cmSourceFile*>::const_iterator i = sources.begin();
i != sources.end(); ++i)
for(std::vector<cmSourceFile*>::const_iterator i = classes.begin();
i != classes.end(); i++)
{
if(const cmCustomCommand* cc = (*i)->GetCustomCommand())
{
cleanFiles.push_back(cc->GetOutput());
objTarget = this->GenerateCustomRuleFile(*cc,tgtDir.c_str());
if (clean)
{
cleanFiles.push_back
(this->Convert(cc->GetOutput(),HOME_OUTPUT,SHELL));
}
ruleFileStream
<< m_IncludeDirective << " "
<< this->ConvertToOutputForExisting(objTarget.c_str()).c_str()
<< "\n";
}
}
if (cleanFiles.size())
{
std::vector<std::string> commands;
std::vector<std::string> depends;
this->AppendCleanCommand(commands, cleanFiles);
std::string dir = m_Makefile->GetStartOutputDirectory();
dir += "/CMakeCustomRules.dir/clean";
//dir = cmSystemTools::RelativePath(m_Makefile->GetHomeOutputDirectory(), dir.c_str());
//dir = cmSystemTools::ConvertToOutputPath(dir.c_str());
dir = this->Convert(dir.c_str(),HOME_OUTPUT,SHELL,false);
this->WriteMakeRule(ruleFileStream2,
"Clean the output of this custom command.",
dir.c_str(), depends, commands);
// do the include
commands.clear();
depends.push_back(dir);
this->WriteMakeRule(ruleFileStream2,
"Clean the output of this custom command.",
"clean", depends, commands);
}
}
//----------------------------------------------------------------------------
@ -382,18 +327,15 @@ cmLocalUnixMakefileGenerator3
this->WriteMakeVariables(ruleFileStream);
// include the custom commands rules
if (m_CustomRuleFiles.size())
// write the custom commands for this target
std::vector<std::string> cleanFiles;
// Look for files registered for cleaning in this directory.
if(const char* additional_clean_files =
m_Makefile->GetProperty("ADDITIONAL_MAKE_CLEAN_FILES"))
{
// do the include
std::string dir2 = m_Makefile->GetStartOutputDirectory();
dir2 += "/CMakeCustomRules.dir/build.make";
dir2 = this->Convert(dir2.c_str(),HOME_OUTPUT,MAKEFILE);
ruleFileStream
<< m_IncludeDirective << " "
<< this->ConvertToOutputForExisting(dir2.c_str()).c_str()
<< "\n";
}
cmSystemTools::ExpandListArgument(additional_clean_files, cleanFiles);
}
this->WriteCustomCommands(target,ruleFileStream,cleanFiles);
// Include the rule file for each object.
std::string relPath = this->GetHomeRelativeOutputPath();
@ -422,23 +364,33 @@ cmLocalUnixMakefileGenerator3
{
case cmTarget::STATIC_LIBRARY:
this->WriteStaticLibraryRule(ruleFileStream, ruleFileName.c_str(),
target, objects, external_objects);
target, objects, external_objects,
cleanFiles);
break;
case cmTarget::SHARED_LIBRARY:
this->WriteSharedLibraryRule(ruleFileStream, ruleFileName.c_str(),
target, objects, external_objects);
target, objects, external_objects,
cleanFiles);
break;
case cmTarget::MODULE_LIBRARY:
this->WriteModuleLibraryRule(ruleFileStream, ruleFileName.c_str(),
target, objects, external_objects);
target, objects, external_objects,
cleanFiles);
break;
case cmTarget::EXECUTABLE:
this->WriteExecutableRule(ruleFileStream, ruleFileName.c_str(),
target, objects, external_objects);
target, objects, external_objects,
cleanFiles);
break;
default:
break;
}
// Write the requires target.
this->WriteTargetRequiresRule(ruleFileStream, target, objects);
// Write clean target
this->WriteTargetCleanRule(ruleFileStream, target, cleanFiles);
}
//----------------------------------------------------------------------------
@ -745,14 +697,10 @@ cmLocalUnixMakefileGenerator3
}
//----------------------------------------------------------------------------
void
std::string
cmLocalUnixMakefileGenerator3
::GenerateCustomRuleFile(const cmCustomCommand& cc)
::GenerateCustomRuleFile(const cmCustomCommand& cc, const char *dir)
{
// Create a directory for custom rule files.
std::string dir = "CMakeCustomRules.dir";
cmSystemTools::MakeDirectory(this->ConvertToFullPath(dir).c_str());
// Convert the output name to a relative path if possible.
std::string output = this->Convert(cc.GetOutput(),START_OUTPUT);
@ -768,27 +716,16 @@ cmLocalUnixMakefileGenerator3
ruleFileName += customName;
ruleFileName += ".build.make";
// If this is a duplicate rule produce an error.
if(m_CustomRuleFiles.find(ruleFileName) != m_CustomRuleFiles.end())
{
cmSystemTools::Error("An output was found with multiple rules on how to build it for output: ",
cc.GetOutput());
return;
}
m_CustomRuleFiles.insert(ruleFileName);
// what is the relative path to the rule file
std::string relRuleFile = this->GetHomeRelativeOutputPath();
relRuleFile += ruleFileName;
std::string relRuleFile = this->Convert(ruleFileName.c_str(),HOME_OUTPUT);
// 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);
cmGeneratedFileStream ruleFileStream(ruleFileNameFull.c_str());
cmGeneratedFileStream ruleFileStream(ruleFileName.c_str());
ruleFileStream.SetCopyIfDifferent(true);
if(!ruleFileStream)
{
return;
return relRuleFile;
}
this->WriteDisclaimer(ruleFileStream);
ruleFileStream
@ -800,7 +737,7 @@ cmLocalUnixMakefileGenerator3
preEcho += output;
this->AppendEcho(commands, preEcho.c_str());
this->AppendCustomCommand(commands, cc);
// Collect the dependencies.
std::vector<std::string> depends;
this->AppendCustomDepend(depends, cc);
@ -817,6 +754,7 @@ cmLocalUnixMakefileGenerator3
this->WriteMakeRule(ruleFileStream, comment,
cc.GetOutput(), depends, commands);
return relRuleFile;
}
//----------------------------------------------------------------------------
@ -846,18 +784,14 @@ cmLocalUnixMakefileGenerator3
ruleFileStream
<< "# Utility rule file for " << target.GetName() << ".\n\n";
// include the custom commands rules
if (m_CustomRuleFiles.size())
// write the custom commands for this target
std::vector<std::string> cleanFiles;
if(const char* additional_clean_files =
m_Makefile->GetProperty("ADDITIONAL_MAKE_CLEAN_FILES"))
{
// do the include
std::string dir2 = m_Makefile->GetStartOutputDirectory();
dir2 += "/CMakeCustomRules.dir/build.make";
dir2 = this->Convert(dir2.c_str(),HOME_OUTPUT,MAKEFILE);
ruleFileStream
<< m_IncludeDirective << " "
<< this->ConvertToOutputForExisting(dir2.c_str()).c_str()
<< "\n";
}
cmSystemTools::ExpandListArgument(additional_clean_files, cleanFiles);
}
this->WriteCustomCommands(target,ruleFileStream, cleanFiles);
// Collect the commands and dependencies.
std::vector<std::string> commands;
@ -892,6 +826,9 @@ cmLocalUnixMakefileGenerator3
this->Convert(buildTargetRuleName.c_str(),HOME_OUTPUT,MAKEFILE);
this->WriteConvenienceRule(ruleFileStream, target.GetName(),
buildTargetRuleName.c_str());
// Write clean target
this->WriteTargetCleanRule(ruleFileStream, target, cleanFiles);
}
//----------------------------------------------------------------------------
@ -1082,21 +1019,6 @@ void cmLocalUnixMakefileGenerator3::WriteMainTargetIncludes(std::ostream& makefi
std::vector<std::string> depends;
std::vector<std::string> no_commands;
// if this is the clean rules also include the custom commands if there
// were any
const char* clean_no_custom = m_Makefile->GetProperty("CLEAN_NO_CUSTOM");
if (!strcmp(rule,"clean") && cmSystemTools::IsOff(clean_no_custom))
{
// do the include
std::string dir = m_Makefile->GetStartOutputDirectory();
dir += "/CMakeCustomRules.dir/clean.make";
dir = this->Convert(dir.c_str(),HOME_OUTPUT,MAKEFILE);
makefileStream
<< m_IncludeDirective << " "
<< this->ConvertToOutputForExisting(dir.c_str()).c_str()
<< "\n";
}
for (cmTargets::const_iterator l = m_Makefile->GetTargets().begin();
l != m_Makefile->GetTargets().end(); l++)
{
@ -1185,41 +1107,6 @@ void cmLocalUnixMakefileGenerator3::WriteMainTargetRules(std::ostream& makefileS
}
}
//----------------------------------------------------------------------------
void
cmLocalUnixMakefileGenerator3
::WriteLocalCleanRule(std::ostream& makefileStream)
{
// Collect a list of extra files to clean in this directory.
std::vector<std::string> files;
// Look for files registered for cleaning in this directory.
if(const char* additional_clean_files =
m_Makefile->GetProperty("ADDITIONAL_MAKE_CLEAN_FILES"))
{
cmSystemTools::ExpandListArgument(additional_clean_files, files);
}
// Write the local clean rule for this directory.
if(!files.empty())
{
// Have extra files to clean. Write the action to remove them.
std::string cleanTarget = this->GetHomeRelativeOutputPath();
cleanTarget += "clean.local";
std::vector<std::string> no_depends;
std::vector<std::string> commands;
this->AppendCleanCommand(commands, files);
this->WriteMakeRule(makefileStream,
"Clean extra files in this directory.",
cleanTarget.c_str(), no_depends, commands);
commands.clear();
no_depends.push_back(cleanTarget);
this->WriteMakeRule(makefileStream, 0,
"clean", no_depends, commands);
}
}
//----------------------------------------------------------------------------
void
cmLocalUnixMakefileGenerator3
@ -1482,7 +1369,8 @@ cmLocalUnixMakefileGenerator3
const char* ruleFileName,
const cmTarget& target,
const std::vector<std::string>& objects,
const std::vector<std::string>& external_objects)
const std::vector<std::string>& external_objects,
std::vector<std::string>& cleanFiles)
{
// Write the dependency generation rule.
this->WriteTargetDependRule(ruleFileStream, target, objects);
@ -1510,8 +1398,6 @@ cmLocalUnixMakefileGenerator3
objTarget += ruleFileName;
this->AppendRuleDepend(depends, objTarget.c_str());
std::vector<std::string> cleanFiles;
// Construct the full path to the executable that will be generated.
std::string targetFullPath = m_ExecutableOutputPath;
if(targetFullPath.length() == 0)
@ -1646,13 +1532,8 @@ cmLocalUnixMakefileGenerator3
this->WriteConvenienceRule(ruleFileStream, targetFullPath.c_str(),
buildTargetRuleName.c_str());
// Write clean target
cleanFiles.push_back(cleanObjs);
cleanFiles.push_back(targetOutPath.c_str());
this->WriteTargetCleanRule(ruleFileName, target, cleanFiles, objects, external_objects);
// Write the driving make target.
this->WriteTargetRequiresRule(ruleFileStream, target, objects);
}
//----------------------------------------------------------------------------
@ -1662,7 +1543,8 @@ cmLocalUnixMakefileGenerator3
const char* ruleFileName,
const cmTarget& target,
const std::vector<std::string>& objects,
const std::vector<std::string>& external_objects)
const std::vector<std::string>& external_objects,
std::vector<std::string>& cleanFiles)
{
const char* linkLanguage =
target.GetLinkerLanguage(this->GetGlobalGenerator());
@ -1674,7 +1556,7 @@ cmLocalUnixMakefileGenerator3
this->AppendFlags(extraFlags, target.GetProperty("STATIC_LIBRARY_FLAGS"));
this->WriteLibraryRule(ruleFileStream, ruleFileName, target,
objects, external_objects,
linkRuleVar.c_str(), extraFlags.c_str());
linkRuleVar.c_str(), extraFlags.c_str(),cleanFiles);
}
//----------------------------------------------------------------------------
@ -1684,7 +1566,8 @@ cmLocalUnixMakefileGenerator3
const char* ruleFileName,
const cmTarget& target,
const std::vector<std::string>& objects,
const std::vector<std::string>& external_objects)
const std::vector<std::string>& external_objects,
std::vector<std::string>& cleanFiles)
{
const char* linkLanguage =
target.GetLinkerLanguage(this->GetGlobalGenerator());
@ -1712,7 +1595,7 @@ cmLocalUnixMakefileGenerator3
}
this->WriteLibraryRule(ruleFileStream, ruleFileName, target,
objects, external_objects,
linkRuleVar.c_str(), extraFlags.c_str());
linkRuleVar.c_str(), extraFlags.c_str(), cleanFiles);
}
//----------------------------------------------------------------------------
@ -1722,7 +1605,8 @@ cmLocalUnixMakefileGenerator3
const char* ruleFileName,
const cmTarget& target,
const std::vector<std::string>& objects,
const std::vector<std::string>& external_objects)
const std::vector<std::string>& external_objects,
std::vector<std::string>& cleanFiles)
{
const char* linkLanguage =
target.GetLinkerLanguage(this->GetGlobalGenerator());
@ -1736,7 +1620,7 @@ cmLocalUnixMakefileGenerator3
// TODO: .def files should be supported here also.
this->WriteLibraryRule(ruleFileStream, ruleFileName, target,
objects, external_objects,
linkRuleVar.c_str(), extraFlags.c_str());
linkRuleVar.c_str(), extraFlags.c_str(), cleanFiles);
}
//----------------------------------------------------------------------------
@ -1748,7 +1632,8 @@ cmLocalUnixMakefileGenerator3
const std::vector<std::string>& objects,
const std::vector<std::string>& external_objects,
const char* linkRuleVar,
const char* extraFlags)
const char* extraFlags,
std::vector<std::string>& cleanFiles)
{
// Write the dependency generation rule.
this->WriteTargetDependRule(ruleFileStream, target, objects);
@ -1778,8 +1663,6 @@ cmLocalUnixMakefileGenerator3
objTarget += ruleFileName;
this->AppendRuleDepend(depends, objTarget.c_str());
std::vector<std::string> cleanFiles;
// from here up is the same for exe or lib
for(std::vector<std::string>::const_iterator obj = external_objects.begin();
@ -1964,13 +1847,8 @@ cmLocalUnixMakefileGenerator3
this->WriteConvenienceRule(ruleFileStream, targetFullPath.c_str(),
buildTargetRuleName.c_str());
// Write clean target
cleanFiles.push_back(cleanObjs);
cleanFiles.push_back(targetOutPath.c_str());
this->WriteTargetCleanRule(ruleFileName, target, cleanFiles, objects, external_objects);
// Write the driving make target.
this->WriteTargetRequiresRule(ruleFileStream, target, objects);
}
//----------------------------------------------------------------------------
@ -2058,32 +1936,10 @@ cmLocalUnixMakefileGenerator3
//----------------------------------------------------------------------------
void
cmLocalUnixMakefileGenerator3
::WriteTargetCleanRule(const char *ruleFileName,
::WriteTargetCleanRule(std::ostream& ruleFileStream,
const cmTarget& target,
const std::vector<std::string>& files,
const std::vector<std::string>& objects,
const std::vector<std::string>& external_objects)
const std::vector<std::string>& files)
{
std::string dir = cmSystemTools::GetFilenamePath(ruleFileName);
std::string cleanFileName = dir;
cleanFileName += "/clean.make";
// Open the rule file. This should be copy-if-different because the
// rules may depend on this file itself.
std::string ruleFileNameFull = this->ConvertToFullPath(cleanFileName);
cmGeneratedFileStream ruleFileStream(ruleFileNameFull.c_str());
ruleFileStream.SetCopyIfDifferent(true);
if(!ruleFileStream)
{
return;
}
this->WriteDisclaimer(ruleFileStream);
std::string variableName;
std::string variableNameExternal;
this->WriteObjectsVariable(ruleFileStream, target, objects, external_objects,
variableName, variableNameExternal);
std::vector<std::string> no_depends;
std::vector<std::string> commands;

33
Source/cmLocalUnixMakefileGenerator3.h
View File

@ -135,7 +135,6 @@ public:
void WriteSpecialTargetsBottom(std::ostream& makefileStream);
std::string GetRelativeTargetDirectory(const cmTarget& target);
void WriteLocalCleanRule(std::ostream& makefileStream);
// List the files for which to check dependency integrity. Each
// language has its own list because integrity may be checked
@ -172,7 +171,8 @@ protected:
// this is responsible for writing all of the rules for all this
// directories custom commands (but not utility targets)
void WriteCustomCommands();
void WriteCustomCommands(const cmTarget &target,std::ostream& os,
std::vector<std::string>& cleanFiles);
// this method Writes the Directory informaiton files
void WriteDirectoryInformationFile();
@ -221,31 +221,38 @@ protected:
bool verbose);
void GenerateCustomRuleFile(const cmCustomCommand& cc);
std::string GenerateCustomRuleFile(const cmCustomCommand& cc,
const char *dir);
// these three make some simple changes and then call WriteLibraryRule
void WriteStaticLibraryRule(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>& external_objects,
std::vector<std::string>& cleanFiles);
void WriteSharedLibraryRule(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>& external_objects,
std::vector<std::string>& cleanFiles);
void WriteModuleLibraryRule(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>& external_objects,
std::vector<std::string>& cleanFiles);
// 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>& external_objects,
std::vector<std::string>& cleanFiles);
// the main method for writing library rules
void WriteLibraryRule(std::ostream& ruleFileStream,
@ -254,7 +261,8 @@ protected:
const std::vector<std::string>& objects,
const std::vector<std::string>& external_objects,
const char* linkRuleVar,
const char* extraLinkFlags);
const char* extraLinkFlags,
std::vector<std::string>& cleanFiles);
void WriteLocalMakefile();
@ -275,11 +283,9 @@ protected:
void WriteTargetDependRule(std::ostream& ruleFileStream,
const cmTarget& target,
const std::vector<std::string>& objects);
void WriteTargetCleanRule(const char *ruleFileName,
void WriteTargetCleanRule(std::ostream& ruleFileStream,
const cmTarget& target,
const std::vector<std::string>& files,
const std::vector<std::string>& objects,
const std::vector<std::string>& external_objects);
const std::vector<std::string>& files);
void WriteTargetRequiresRule(std::ostream& ruleFileStream,
const cmTarget& target,
const std::vector<std::string>& objects);
@ -332,9 +338,6 @@ private:
// Flag for whether echo command needs quotes.
bool m_EchoNeedsQuote;
// Set of custom rule files that have been generated.
std::set<cmStdString> m_CustomRuleFiles;
// Set of object file names that will be built in this directory.
std::set<cmStdString> m_ObjectFiles;
};