From baeeb4082345577f90c2a21e6841f61995b34dbd Mon Sep 17 00:00:00 2001 From: Ken Martin Date: Tue, 24 May 2005 14:42:23 -0400 Subject: [PATCH] ENH: some more cleanup and changes to how custom commands are stored --- Source/cmGlobalUnixMakefileGenerator3.cxx | 59 ++--- Source/cmGlobalUnixMakefileGenerator3.h | 1 - Source/cmLocalUnixMakefileGenerator3.cxx | 302 ++++++---------------- Source/cmLocalUnixMakefileGenerator3.h | 33 +-- 4 files changed, 113 insertions(+), 282 deletions(-) diff --git a/Source/cmGlobalUnixMakefileGenerator3.cxx b/Source/cmGlobalUnixMakefileGenerator3.cxx index 7819b4903..d0ed30ab4 100644 --- a/Source/cmGlobalUnixMakefileGenerator3.cxx +++ b/Source/cmGlobalUnixMakefileGenerator3.cxx @@ -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(m_LocalGenerators[0]); - - // Write the do not edit header. - lg->WriteDisclaimer(makefileStream); - lg->WriteMakeVariables(makefileStream); - - // add the generic dependency - std::vector depends; - std::vector 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(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); } } } diff --git a/Source/cmGlobalUnixMakefileGenerator3.h b/Source/cmGlobalUnixMakefileGenerator3.h index 66c57d379..e1b0634b5 100644 --- a/Source/cmGlobalUnixMakefileGenerator3.h +++ b/Source/cmGlobalUnixMakefileGenerator3.h @@ -61,7 +61,6 @@ protected: void WriteMainMakefile(); void WriteMainCMakefile(); void WriteBuildMakefile(); - void WriteCleanMakefile(); void WriteMainCMakefileLanguageRules(cmGeneratedFileStream& cmakefileStream); void WriteAllRules(cmLocalUnixMakefileGenerator3 *lg, std::ostream& makefileStream); diff --git a/Source/cmLocalUnixMakefileGenerator3.cxx b/Source/cmLocalUnixMakefileGenerator3.cxx index 819d21fd7..11a86bbc9 100644 --- a/Source/cmLocalUnixMakefileGenerator3.cxx +++ b/Source/cmLocalUnixMakefileGenerator3.cxx @@ -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& 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& sources = m_Makefile->GetSourceFiles(); - for(std::vector::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 &classes = target.GetSourceFiles(); std::string objTarget; - for(std::set::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 cleanFiles; - for(std::vector::const_iterator i = sources.begin(); - i != sources.end(); ++i) + for(std::vector::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 commands; - std::vector 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 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 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 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 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 depends; std::vector 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 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 no_depends; - std::vector 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& objects, - const std::vector& external_objects) + const std::vector& external_objects, + std::vector& 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 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& objects, - const std::vector& external_objects) + const std::vector& external_objects, + std::vector& 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& objects, - const std::vector& external_objects) + const std::vector& external_objects, + std::vector& 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& objects, - const std::vector& external_objects) + const std::vector& external_objects, + std::vector& 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& objects, const std::vector& external_objects, const char* linkRuleVar, - const char* extraFlags) + const char* extraFlags, + std::vector& 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 cleanFiles; - // from here up is the same for exe or lib for(std::vector::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& files, - const std::vector& objects, - const std::vector& external_objects) + const std::vector& 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 no_depends; std::vector commands; diff --git a/Source/cmLocalUnixMakefileGenerator3.h b/Source/cmLocalUnixMakefileGenerator3.h index 9f5735c60..9f1898f74 100644 --- a/Source/cmLocalUnixMakefileGenerator3.h +++ b/Source/cmLocalUnixMakefileGenerator3.h @@ -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& 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& objects, - const std::vector& external_objects); + const std::vector& external_objects, + std::vector& cleanFiles); + void WriteSharedLibraryRule(std::ostream& ruleFileStream, const char* ruleFileName, const cmTarget& target, const std::vector& objects, - const std::vector& external_objects); + const std::vector& external_objects, + std::vector& cleanFiles); + void WriteModuleLibraryRule(std::ostream& ruleFileStream, const char* ruleFileName, const cmTarget& target, const std::vector& objects, - const std::vector& external_objects); + const std::vector& external_objects, + std::vector& cleanFiles); // the main code for writing the Executable target rules void WriteExecutableRule(std::ostream& ruleFileStream, const char* ruleFileName, const cmTarget& target, const std::vector& objects, - const std::vector& external_objects); + const std::vector& external_objects, + std::vector& cleanFiles); // the main method for writing library rules void WriteLibraryRule(std::ostream& ruleFileStream, @@ -254,7 +261,8 @@ protected: const std::vector& objects, const std::vector& external_objects, const char* linkRuleVar, - const char* extraLinkFlags); + const char* extraLinkFlags, + std::vector& cleanFiles); void WriteLocalMakefile(); @@ -275,11 +283,9 @@ protected: void WriteTargetDependRule(std::ostream& ruleFileStream, const cmTarget& target, const std::vector& objects); - void WriteTargetCleanRule(const char *ruleFileName, + void WriteTargetCleanRule(std::ostream& ruleFileStream, const cmTarget& target, - const std::vector& files, - const std::vector& objects, - const std::vector& external_objects); + const std::vector& files); void WriteTargetRequiresRule(std::ostream& ruleFileStream, const cmTarget& target, const std::vector& 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 m_CustomRuleFiles; - // Set of object file names that will be built in this directory. std::set m_ObjectFiles; };