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

Merge topic 'vs10-rule-files' 

72333a4 VS10: Avoid creating .rule files next to outputs (#13141)
369e346 Factor out custom command .rule file path generation
f9b758e Cleanup custom command .rule file internal handling
This commit is contained in:
David Cole 2012-04-25 14:03:01 -04:00 committed by CMake Topic Stage
parent 21be162f9b 72333a4648
commit 728cbd19e3
9 changed files with 87 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
Source/cmGlobalGenerator.cxx
View File

@ -2091,6 +2091,21 @@ cmTarget cmGlobalGenerator::CreateGlobalTarget(
return target;
}
//----------------------------------------------------------------------------
std::string
cmGlobalGenerator::GenerateRuleFile(std::string const& output) const
{
std::string ruleFile = output;
ruleFile += ".rule";
const char* dir = this->GetCMakeCFGIntDir();
if(dir && dir[0] == '$')
{
cmSystemTools::ReplaceString(ruleFile, dir,
cmake::GetCMakeFilesDirectory());
}
return ruleFile;
}
//----------------------------------------------------------------------------
void cmGlobalGenerator::AppendDirectoryForConfig(const char*, const char*,
const char*, std::string&)

3
Source/cmGlobalGenerator.h
View File

@ -277,6 +277,9 @@ public:
i.e. "Can I build Debug and Release in the same tree?" */
virtual bool IsMultiConfig() { return false; }
/** Generate an <output>.rule file path for a given command output. */
virtual std::string GenerateRuleFile(std::string const& output) const;
protected:
typedef std::vector<cmLocalGenerator*> GeneratorVector;
// for a project collect all its targets by following depend

18
Source/cmGlobalVisualStudio10Generator.cxx
View File

@ -212,3 +212,21 @@ bool cmGlobalVisualStudio10Generator::Find64BitTools(cmMakefile* mf)
return false;
}
}
//----------------------------------------------------------------------------
std::string
cmGlobalVisualStudio10Generator
::GenerateRuleFile(std::string const& output) const
{
// The VS 10 generator needs to create the .rule files on disk.
// Hide them away under the CMakeFiles directory.
std::string ruleDir = this->GetCMakeInstance()->GetHomeOutputDirectory();
ruleDir += cmake::GetCMakeFilesDirectory();
ruleDir += "/";
ruleDir += cmSystemTools::ComputeStringMD5(
cmSystemTools::GetFilenamePath(output).c_str());
std::string ruleFile = ruleDir + "/";
ruleFile += cmSystemTools::GetFilenameName(output);
ruleFile += ".rule";
return ruleFile;
}

4
Source/cmGlobalVisualStudio10Generator.h
View File

@ -75,6 +75,10 @@ public:
virtual const char* GetCMakeCFGIntDir() const
{ return "$(Configuration)";}
bool Find64BitTools(cmMakefile* mf);
/** Generate an <output>.rule file path for a given command output. */
virtual std::string GenerateRuleFile(std::string const& output) const;
protected:
virtual const char* GetIDEVersion() { return "10.0"; }

6
Source/cmGlobalVisualStudio8Generator.cxx
View File

@ -214,13 +214,11 @@ void cmGlobalVisualStudio8Generator::AddCheckTarget()
// (this could be avoided with per-target source files)
const char* no_main_dependency = 0;
const char* no_working_directory = 0;
if(cmSourceFile* file =
mf->AddCustomCommandToOutput(
stamps, listFiles,
no_main_dependency, commandLines, "Checking Build System",
no_working_directory, true);
std::string ruleName = stamps[0];
ruleName += ".rule";
if(cmSourceFile* file = mf->GetSource(ruleName.c_str()))
no_working_directory, true))
{
tgt->AddSourceFile(file);
}

2
Source/cmLocalVisualStudio6Generator.cxx
View File

@ -320,7 +320,7 @@ void cmLocalVisualStudio6Generator::WriteDSPFile(std::ostream& fout,
sourceGroup.AssignSource(*i);
// while we are at it, if it is a .rule file then for visual studio 6 we
// must generate it
if ((*i)->GetExtension() == "rule")
if ((*i)->GetPropertyAsBool("__CMAKE_RULE"))
{
if(!cmSystemTools::FileExists(source.c_str()))
{

42
Source/cmMakefile.cxx
View File

@ -883,7 +883,7 @@ cmMakefile::AddCustomCommandToTarget(const char* target,
}
//----------------------------------------------------------------------------
void
cmSourceFile*
cmMakefile::AddCustomCommandToOutput(const std::vector<std::string>& outputs,
const std::vector<std::string>& depends,
const char* main_dependency,
@ -897,7 +897,7 @@ cmMakefile::AddCustomCommandToOutput(const std::vector<std::string>& outputs,
if(outputs.empty())
{
cmSystemTools::Error("Attempt to add a custom rule with no output!");
return;
return 0;
}
// Validate custom commands. TODO: More strict?
@ -910,7 +910,7 @@ cmMakefile::AddCustomCommandToOutput(const std::vector<std::string>& outputs,
cmOStringStream e;
e << "COMMAND may not contain literal quotes:\n " << cl[0] << "\n";
this->IssueMessage(cmake::FATAL_ERROR, e.str());
return;
return 0;
}
}
@ -928,7 +928,7 @@ cmMakefile::AddCustomCommandToOutput(const std::vector<std::string>& outputs,
{
// The existing custom command is identical. Silently ignore
// the duplicate.
return;
return file;
}
else
{
@ -948,17 +948,11 @@ cmMakefile::AddCustomCommandToOutput(const std::vector<std::string>& outputs,
// Generate a rule file if the main dependency is not available.
if(!file)
{
cmGlobalGenerator* gg = this->LocalGenerator->GetGlobalGenerator();
// Construct a rule file associated with the first output produced.
std::string outName = outputs[0];
outName += ".rule";
const char* dir =
this->LocalGenerator->GetGlobalGenerator()->
GetCMakeCFGIntDir();
if(dir && dir[0] == '$')
{
cmSystemTools::ReplaceString(outName, dir,
cmake::GetCMakeFilesDirectory());
}
std::string outName = gg->GenerateRuleFile(outputs[0]);
// Check if the rule file already exists.
file = this->GetSource(outName.c_str());
if(file && file->GetCustomCommand() && !replace)
@ -970,11 +964,12 @@ cmMakefile::AddCustomCommandToOutput(const std::vector<std::string>& outputs,
outName.c_str(),
"\" which already has a custom rule.");
}
return;
return file;
}
// Create a cmSourceFile for the rule file.
file = this->GetOrCreateSource(outName.c_str(), true);
file->SetProperty("__CMAKE_RULE", "1");
}
// Always create the output sources and mark them generated.
@ -1004,10 +999,11 @@ cmMakefile::AddCustomCommandToOutput(const std::vector<std::string>& outputs,
cc->SetEscapeAllowMakeVars(true);
file->SetCustomCommand(cc);
}
return file;
}
//----------------------------------------------------------------------------
void
cmSourceFile*
cmMakefile::AddCustomCommandToOutput(const char* output,
const std::vector<std::string>& depends,
const char* main_dependency,
@ -1019,7 +1015,7 @@ cmMakefile::AddCustomCommandToOutput(const char* output,
{
std::vector<std::string> outputs;
outputs.push_back(output);
this->AddCustomCommandToOutput(outputs, depends, main_dependency,
return this->AddCustomCommandToOutput(outputs, depends, main_dependency,
commandLines, comment, workingDir,
replace, escapeOldStyle);
}
@ -1054,12 +1050,13 @@ cmMakefile::AddCustomCommandOldStyle(const char* target,
{
// Get the name of this output.
const char* output = oi->c_str();
cmSourceFile* sf;
// Choose whether to use a main dependency.
if(sourceFiles.find(source))
{
// The source looks like a real file. Use it as the main dependency.
this->AddCustomCommandToOutput(output, depends, source,
sf = this->AddCustomCommandToOutput(output, depends, source,
commandLines, comment, 0);
}
else
@ -1068,20 +1065,18 @@ cmMakefile::AddCustomCommandOldStyle(const char* target,
const char* no_main_dependency = 0;
std::vector<std::string> depends2 = depends;
depends2.push_back(source);
this->AddCustomCommandToOutput(output, depends2, no_main_dependency,
sf = this->AddCustomCommandToOutput(output, depends2, no_main_dependency,
commandLines, comment, 0);
}
// If the rule was added to the source (and not a .rule file),
// then add the source to the target to make sure the rule is
// included.
std::string sname = output;
sname += ".rule";
if(!this->GetSource(sname.c_str()))
if(sf && !sf->GetPropertyAsBool("__CMAKE_RULE"))
{
if (this->Targets.find(target) != this->Targets.end())
{
this->Targets[target].AddSource(source);
this->Targets[target].AddSourceFile(sf);
}
else
{
@ -1976,7 +1971,6 @@ cmSourceFile *cmMakefile::GetSourceFileWithOutput(const char *cname)
// look through all the source files that have custom commands
// and see if the custom command has the passed source file as an output
// keep in mind the possible .rule extension that may be tacked on
for(std::vector<cmSourceFile*>::const_iterator i =
this->SourceFiles.begin(); i != this->SourceFiles.end(); ++i)
{

6
Source/cmMakefile.h
View File

@ -175,14 +175,16 @@ public:
cmTarget::CustomCommandType type,
const char* comment, const char* workingDir,
bool escapeOldStyle = true);
void AddCustomCommandToOutput(const std::vector<std::string>& outputs,
cmSourceFile* AddCustomCommandToOutput(
const std::vector<std::string>& outputs,
const std::vector<std::string>& depends,
const char* main_dependency,
const cmCustomCommandLines& commandLines,
const char* comment, const char* workingDir,
bool replace = false,
bool escapeOldStyle = true);
void AddCustomCommandToOutput(const char* output,
cmSourceFile* AddCustomCommandToOutput(
const char* output,
const std::vector<std::string>& depends,
const char* main_dependency,
const cmCustomCommandLines& commandLines,

5
Source/cmVisualStudio10TargetGenerator.cxx
View File

@ -459,8 +459,9 @@ cmVisualStudio10TargetGenerator::WriteCustomRule(cmSourceFile* source,
command)
{
std::string sourcePath = source->GetFullPath();
// the rule file seems to need to exist for vs10
if (source->GetExtension() == "rule")
// VS 10 will always rebuild a custom command attached to a .rule
// file that doesn't exist so create the file explicitly.
if (source->GetPropertyAsBool("__CMAKE_RULE"))
{
if(!cmSystemTools::FileExists(sourcePath.c_str()))
{