2009-09-28 19:43:28 +04:00
|
|
|
/*============================================================================
|
|
|
|
CMake - Cross Platform Makefile Generator
|
|
|
|
Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
|
2005-05-05 20:45:53 +04:00
|
|
|
|
2009-09-28 19:43:28 +04:00
|
|
|
Distributed under the OSI-approved BSD License (the "License");
|
|
|
|
see accompanying file Copyright.txt for details.
|
2005-05-05 20:45:53 +04:00
|
|
|
|
2009-09-28 19:43:28 +04:00
|
|
|
This software is distributed WITHOUT ANY WARRANTY; without even the
|
|
|
|
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
|
See the License for more information.
|
|
|
|
============================================================================*/
|
2005-05-05 20:45:53 +04:00
|
|
|
#include "cmLocalUnixMakefileGenerator3.h"
|
|
|
|
|
|
|
|
#include "cmGeneratedFileStream.h"
|
2005-07-27 17:49:37 +04:00
|
|
|
#include "cmGlobalUnixMakefileGenerator3.h"
|
2005-05-05 20:45:53 +04:00
|
|
|
#include "cmMakefile.h"
|
2006-02-15 18:34:11 +03:00
|
|
|
#include "cmMakefileTargetGenerator.h"
|
2005-05-05 20:45:53 +04:00
|
|
|
#include "cmSourceFile.h"
|
|
|
|
#include "cmake.h"
|
2006-11-29 23:59:16 +03:00
|
|
|
#include "cmVersion.h"
|
2008-03-12 00:53:54 +03:00
|
|
|
#include "cmFileTimeComparison.h"
|
2010-12-08 00:23:38 +03:00
|
|
|
#include "cmCustomCommandGenerator.h"
|
2005-05-05 20:45:53 +04:00
|
|
|
|
|
|
|
// Include dependency scanners for supported languages. Only the
|
|
|
|
// C/C++ scanner is needed for bootstrapping CMake.
|
|
|
|
#include "cmDependsC.h"
|
|
|
|
#ifdef CMAKE_BUILD_WITH_CMAKE
|
|
|
|
# include "cmDependsFortran.h"
|
|
|
|
# include "cmDependsJava.h"
|
2007-12-20 01:15:41 +03:00
|
|
|
# include <cmsys/Terminal.h>
|
2005-05-05 20:45:53 +04:00
|
|
|
#endif
|
|
|
|
|
2009-06-25 17:58:51 +04:00
|
|
|
#include <cmsys/auto_ptr.hxx>
|
|
|
|
|
2005-05-05 20:45:53 +04:00
|
|
|
#include <queue>
|
|
|
|
|
2012-06-06 16:30:54 +04:00
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
// Escape special characters in Makefile dependency lines
|
|
|
|
class cmMakeSafe
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
cmMakeSafe(const char* s): Data(s) {}
|
|
|
|
cmMakeSafe(std::string const& s): Data(s.c_str()) {}
|
|
|
|
private:
|
|
|
|
const char* Data;
|
|
|
|
friend std::ostream& operator<<(std::ostream& os,
|
|
|
|
cmMakeSafe const& self)
|
|
|
|
{
|
|
|
|
for(const char* c = self.Data; *c; ++c)
|
|
|
|
{
|
|
|
|
switch (*c)
|
|
|
|
{
|
|
|
|
case '=': os << "$(EQUALS)"; break;
|
|
|
|
default: os << *c; break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return os;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2008-01-08 00:12:37 +03:00
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
// Helper function used below.
|
|
|
|
static std::string cmSplitExtension(std::string const& in, std::string& base)
|
|
|
|
{
|
|
|
|
std::string ext;
|
|
|
|
std::string::size_type dot_pos = in.rfind(".");
|
|
|
|
if(dot_pos != std::string::npos)
|
|
|
|
{
|
|
|
|
// Remove the extension first in case &base == &in.
|
|
|
|
ext = in.substr(dot_pos, std::string::npos);
|
|
|
|
base = in.substr(0, dot_pos);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
base = in;
|
|
|
|
}
|
|
|
|
return ext;
|
|
|
|
}
|
|
|
|
|
2005-05-05 20:45:53 +04:00
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
cmLocalUnixMakefileGenerator3::cmLocalUnixMakefileGenerator3()
|
|
|
|
{
|
2006-03-15 19:02:08 +03:00
|
|
|
this->SilentNoColon = false;
|
|
|
|
this->WindowsShell = false;
|
|
|
|
this->IncludeDirective = "include";
|
|
|
|
this->MakefileVariableSize = 0;
|
|
|
|
this->IgnoreLibPrefix = false;
|
|
|
|
this->PassMakeflags = false;
|
|
|
|
this->DefineWindowsNULL = false;
|
|
|
|
this->UnixCD = true;
|
2006-05-25 22:16:19 +04:00
|
|
|
this->ColorMakefile = false;
|
2006-08-09 17:56:52 +04:00
|
|
|
this->SkipPreprocessedSourceRules = false;
|
|
|
|
this->SkipAssemblySourceRules = false;
|
2007-03-08 21:05:02 +03:00
|
|
|
this->MakeCommandEscapeTargetTwice = false;
|
2007-05-17 18:53:18 +04:00
|
|
|
this->BorlandMakeCurlyHack = false;
|
2005-05-05 20:45:53 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
cmLocalUnixMakefileGenerator3::~cmLocalUnixMakefileGenerator3()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2005-06-01 21:37:49 +04:00
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
void cmLocalUnixMakefileGenerator3::Configure()
|
|
|
|
{
|
2007-03-08 21:19:39 +03:00
|
|
|
// Compute the path to use when referencing the current output
|
|
|
|
// directory from the top output directory.
|
|
|
|
this->HomeRelativeOutputPath =
|
|
|
|
this->Convert(this->Makefile->GetStartOutputDirectory(), HOME_OUTPUT);
|
2007-03-14 23:29:10 +03:00
|
|
|
if(this->HomeRelativeOutputPath == ".")
|
|
|
|
{
|
|
|
|
this->HomeRelativeOutputPath = "";
|
|
|
|
}
|
2007-03-08 21:19:39 +03:00
|
|
|
if(!this->HomeRelativeOutputPath.empty())
|
2006-01-30 22:25:07 +03:00
|
|
|
{
|
2006-03-15 19:02:08 +03:00
|
|
|
this->HomeRelativeOutputPath += "/";
|
2006-01-30 22:25:07 +03:00
|
|
|
}
|
2005-06-01 21:37:49 +04:00
|
|
|
this->cmLocalGenerator::Configure();
|
|
|
|
}
|
|
|
|
|
2005-05-05 20:45:53 +04:00
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
void cmLocalUnixMakefileGenerator3::Generate()
|
|
|
|
{
|
2007-03-08 22:57:28 +03:00
|
|
|
// Store the configuration name that will be generated.
|
|
|
|
if(const char* config = this->Makefile->GetDefinition("CMAKE_BUILD_TYPE"))
|
|
|
|
{
|
|
|
|
// Use the build type given by the user.
|
|
|
|
this->ConfigurationName = config;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// No configuration type given.
|
|
|
|
this->ConfigurationName = "";
|
|
|
|
}
|
2005-05-05 20:45:53 +04:00
|
|
|
|
2006-08-09 17:56:52 +04:00
|
|
|
// Record whether some options are enabled to avoid checking many
|
2006-05-25 22:16:19 +04:00
|
|
|
// times later.
|
2009-07-21 19:58:43 +04:00
|
|
|
if(!this->GetGlobalGenerator()->GetCMakeInstance()->GetIsInTryCompile())
|
|
|
|
{
|
|
|
|
this->ColorMakefile = this->Makefile->IsOn("CMAKE_COLOR_MAKEFILE");
|
|
|
|
}
|
2006-08-09 17:56:52 +04:00
|
|
|
this->SkipPreprocessedSourceRules =
|
|
|
|
this->Makefile->IsOn("CMAKE_SKIP_PREPROCESSED_SOURCE_RULES");
|
|
|
|
this->SkipAssemblySourceRules =
|
|
|
|
this->Makefile->IsOn("CMAKE_SKIP_ASSEMBLY_SOURCE_RULES");
|
2006-05-25 22:16:19 +04:00
|
|
|
|
2005-05-05 20:45:53 +04:00
|
|
|
// Generate the rule files for each target.
|
2012-10-10 23:32:37 +04:00
|
|
|
cmGeneratorTargetsType targets = this->Makefile->GetGeneratorTargets();
|
2009-06-25 17:58:51 +04:00
|
|
|
cmGlobalUnixMakefileGenerator3* gg =
|
|
|
|
static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator);
|
2012-10-10 23:32:37 +04:00
|
|
|
for(cmGeneratorTargetsType::iterator t = targets.begin();
|
|
|
|
t != targets.end(); ++t)
|
2005-05-05 20:45:53 +04:00
|
|
|
{
|
2013-11-20 15:44:04 +04:00
|
|
|
if (t->second->Target->GetType() == cmTarget::INTERFACE_LIBRARY
|
|
|
|
|| t->second->Target->IsImported())
|
2012-10-10 23:32:37 +04:00
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
2009-06-25 17:58:51 +04:00
|
|
|
cmsys::auto_ptr<cmMakefileTargetGenerator> tg(
|
2012-10-10 23:32:37 +04:00
|
|
|
cmMakefileTargetGenerator::New(t->second));
|
2009-06-25 17:58:51 +04:00
|
|
|
if (tg.get())
|
2005-05-05 20:45:53 +04:00
|
|
|
{
|
2006-02-15 18:34:11 +03:00
|
|
|
tg->WriteRuleFiles();
|
2009-06-25 17:58:51 +04:00
|
|
|
gg->RecordTargetProgress(tg.get());
|
2005-05-05 20:45:53 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-05-11 16:45:16 +04:00
|
|
|
// write the local Makefile
|
|
|
|
this->WriteLocalMakefile();
|
2010-11-12 00:02:07 +03:00
|
|
|
|
2005-05-06 22:49:38 +04:00
|
|
|
// Write the cmake file with information for this directory.
|
|
|
|
this->WriteDirectoryInformationFile();
|
2006-07-11 17:55:27 +04:00
|
|
|
}
|
|
|
|
|
2012-03-06 23:42:40 +04:00
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
void cmLocalUnixMakefileGenerator3::AddLocalObjectFile(
|
|
|
|
cmTarget* target, cmSourceFile* sf, std::string objNoTargetDir,
|
|
|
|
bool hasSourceExtension)
|
|
|
|
{
|
|
|
|
if(cmSystemTools::FileIsFullPath(objNoTargetDir.c_str()))
|
|
|
|
{
|
|
|
|
objNoTargetDir = cmSystemTools::GetFilenameName(objNoTargetDir);
|
|
|
|
}
|
|
|
|
LocalObjectInfo& info = this->LocalObjectFiles[objNoTargetDir];
|
|
|
|
info.HasSourceExtension = hasSourceExtension;
|
|
|
|
info.push_back(LocalObjectEntry(target, sf->GetLanguage()));
|
|
|
|
}
|
|
|
|
|
2009-09-17 02:01:23 +04:00
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
void cmLocalUnixMakefileGenerator3::GetIndividualFileTargets
|
|
|
|
(std::vector<std::string>& targets)
|
|
|
|
{
|
2010-11-12 00:02:07 +03:00
|
|
|
for (std::map<cmStdString, LocalObjectInfo>::iterator lo =
|
2009-09-17 02:01:23 +04:00
|
|
|
this->LocalObjectFiles.begin();
|
|
|
|
lo != this->LocalObjectFiles.end(); ++lo)
|
|
|
|
{
|
|
|
|
targets.push_back(lo->first);
|
|
|
|
|
|
|
|
std::string::size_type dot_pos = lo->first.rfind(".");
|
|
|
|
std::string base = lo->first.substr(0, dot_pos);
|
|
|
|
if(lo->second.HasPreprocessRule)
|
|
|
|
{
|
|
|
|
targets.push_back(base + ".i");
|
|
|
|
}
|
|
|
|
|
|
|
|
if(lo->second.HasAssembleRule)
|
|
|
|
{
|
|
|
|
targets.push_back(base + ".s");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-02-15 18:34:11 +03:00
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
void cmLocalUnixMakefileGenerator3::WriteLocalMakefile()
|
|
|
|
{
|
|
|
|
// generate the includes
|
|
|
|
std::string ruleFileName = "Makefile";
|
|
|
|
|
|
|
|
// 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());
|
|
|
|
if(!ruleFileStream)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
// always write the top makefile
|
2006-03-15 19:02:08 +03:00
|
|
|
if (this->Parent)
|
2006-02-15 18:34:11 +03:00
|
|
|
{
|
|
|
|
ruleFileStream.SetCopyIfDifferent(true);
|
|
|
|
}
|
2010-11-12 00:02:07 +03:00
|
|
|
|
2006-02-15 18:34:11 +03:00
|
|
|
// write the all rules
|
|
|
|
this->WriteLocalAllRules(ruleFileStream);
|
2010-11-12 00:02:07 +03:00
|
|
|
|
2006-02-15 18:34:11 +03:00
|
|
|
// only write local targets unless at the top Keep track of targets already
|
|
|
|
// listed.
|
|
|
|
std::set<cmStdString> emittedTargets;
|
2006-03-15 19:02:08 +03:00
|
|
|
if (this->Parent)
|
2006-02-15 18:34:11 +03:00
|
|
|
{
|
|
|
|
// write our targets, and while doing it collect up the object
|
|
|
|
// file rules
|
|
|
|
this->WriteLocalMakefileTargets(ruleFileStream,emittedTargets);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2010-11-12 00:02:07 +03:00
|
|
|
cmGlobalUnixMakefileGenerator3 *gg =
|
2006-03-15 19:02:08 +03:00
|
|
|
static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator);
|
2006-02-15 18:34:11 +03:00
|
|
|
gg->WriteConvenienceRules(ruleFileStream,emittedTargets);
|
|
|
|
}
|
2006-08-08 07:25:21 +04:00
|
|
|
|
|
|
|
bool do_preprocess_rules =
|
|
|
|
this->GetCreatePreprocessedSourceRules();
|
|
|
|
bool do_assembly_rules =
|
|
|
|
this->GetCreateAssemblySourceRules();
|
|
|
|
|
2006-02-15 18:34:11 +03:00
|
|
|
// now write out the object rules
|
|
|
|
// for each object file name
|
2010-11-12 00:02:07 +03:00
|
|
|
for (std::map<cmStdString, LocalObjectInfo>::iterator lo =
|
2006-03-15 19:02:08 +03:00
|
|
|
this->LocalObjectFiles.begin();
|
|
|
|
lo != this->LocalObjectFiles.end(); ++lo)
|
2006-02-15 18:34:11 +03:00
|
|
|
{
|
2006-08-08 07:25:21 +04:00
|
|
|
// Add a convenience rule for building the object file.
|
2006-08-02 19:06:32 +04:00
|
|
|
this->WriteObjectConvenienceRule(ruleFileStream,
|
|
|
|
"target to build an object file",
|
|
|
|
lo->first.c_str(), lo->second);
|
2006-08-08 07:25:21 +04:00
|
|
|
|
2006-08-15 20:00:27 +04:00
|
|
|
// Check whether preprocessing and assembly rules make sense.
|
|
|
|
// They make sense only for C and C++ sources.
|
|
|
|
bool lang_is_c_or_cxx = false;
|
|
|
|
for(std::vector<LocalObjectEntry>::const_iterator ei =
|
|
|
|
lo->second.begin(); ei != lo->second.end(); ++ei)
|
|
|
|
{
|
|
|
|
if(ei->Language == "C" || ei->Language == "CXX")
|
|
|
|
{
|
|
|
|
lang_is_c_or_cxx = true;
|
2011-11-05 19:17:23 +04:00
|
|
|
break;
|
2006-08-15 20:00:27 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-08-08 07:25:21 +04:00
|
|
|
// Add convenience rules for preprocessed and assembly files.
|
2006-08-15 20:00:27 +04:00
|
|
|
if(lang_is_c_or_cxx && (do_preprocess_rules || do_assembly_rules))
|
2006-08-08 07:25:21 +04:00
|
|
|
{
|
|
|
|
std::string::size_type dot_pos = lo->first.rfind(".");
|
|
|
|
std::string base = lo->first.substr(0, dot_pos);
|
|
|
|
if(do_preprocess_rules)
|
|
|
|
{
|
|
|
|
this->WriteObjectConvenienceRule(
|
|
|
|
ruleFileStream, "target to preprocess a source file",
|
2006-08-09 19:43:35 +04:00
|
|
|
(base + ".i").c_str(), lo->second);
|
2009-09-17 02:01:23 +04:00
|
|
|
lo->second.HasPreprocessRule = true;
|
2006-08-08 07:25:21 +04:00
|
|
|
}
|
|
|
|
if(do_assembly_rules)
|
|
|
|
{
|
|
|
|
this->WriteObjectConvenienceRule(
|
|
|
|
ruleFileStream, "target to generate assembly for a file",
|
2006-08-09 19:43:35 +04:00
|
|
|
(base + ".s").c_str(), lo->second);
|
2009-09-17 02:01:23 +04:00
|
|
|
lo->second.HasAssembleRule = true;
|
2006-08-08 07:25:21 +04:00
|
|
|
}
|
|
|
|
}
|
2006-02-15 18:34:11 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// add a help target as long as there isn;t a real target named help
|
|
|
|
if(emittedTargets.insert("help").second)
|
|
|
|
{
|
2010-11-12 00:02:07 +03:00
|
|
|
cmGlobalUnixMakefileGenerator3 *gg =
|
2006-03-15 19:02:08 +03:00
|
|
|
static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator);
|
2006-02-15 18:34:11 +03:00
|
|
|
gg->WriteHelpRule(ruleFileStream,this);
|
|
|
|
}
|
|
|
|
|
|
|
|
this->WriteSpecialTargetsBottom(ruleFileStream);
|
|
|
|
}
|
2005-05-06 22:49:38 +04:00
|
|
|
|
2006-08-02 19:06:32 +04:00
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
void
|
|
|
|
cmLocalUnixMakefileGenerator3
|
|
|
|
::WriteObjectConvenienceRule(std::ostream& ruleFileStream,
|
|
|
|
const char* comment, const char* output,
|
2008-01-08 00:12:37 +03:00
|
|
|
LocalObjectInfo const& info)
|
2006-08-02 19:06:32 +04:00
|
|
|
{
|
2008-01-08 00:12:37 +03:00
|
|
|
// If the rule includes the source file extension then create a
|
|
|
|
// version that has the extension removed. The help should include
|
|
|
|
// only the version without source extension.
|
|
|
|
bool inHelp = true;
|
|
|
|
if(info.HasSourceExtension)
|
|
|
|
{
|
|
|
|
// Remove the last extension. This should be kept.
|
|
|
|
std::string outBase1 = output;
|
|
|
|
std::string outExt1 = cmSplitExtension(outBase1, outBase1);
|
|
|
|
|
|
|
|
// Now remove the source extension and put back the last
|
|
|
|
// extension.
|
|
|
|
std::string outNoExt;
|
|
|
|
cmSplitExtension(outBase1, outNoExt);
|
|
|
|
outNoExt += outExt1;
|
|
|
|
|
|
|
|
// Add a rule to drive the rule below.
|
|
|
|
std::vector<std::string> depends;
|
|
|
|
depends.push_back(output);
|
2008-01-14 17:20:58 +03:00
|
|
|
std::vector<std::string> no_commands;
|
2008-01-08 00:12:37 +03:00
|
|
|
this->WriteMakeRule(ruleFileStream, 0,
|
2008-01-14 17:20:58 +03:00
|
|
|
outNoExt.c_str(), depends, no_commands, true, true);
|
2008-01-08 00:12:37 +03:00
|
|
|
inHelp = false;
|
|
|
|
}
|
|
|
|
|
2006-08-02 19:06:32 +04:00
|
|
|
// Recursively make the rule for each target using the object file.
|
|
|
|
std::vector<std::string> commands;
|
2008-01-08 00:12:37 +03:00
|
|
|
for(std::vector<LocalObjectEntry>::const_iterator t = info.begin();
|
|
|
|
t != info.end(); ++t)
|
2006-08-02 19:06:32 +04:00
|
|
|
{
|
2006-08-15 20:00:27 +04:00
|
|
|
std::string tgtMakefileName =
|
|
|
|
this->GetRelativeTargetDirectory(*(t->Target));
|
2006-08-02 19:06:32 +04:00
|
|
|
std::string targetName = tgtMakefileName;
|
|
|
|
tgtMakefileName += "/build.make";
|
|
|
|
targetName += "/";
|
|
|
|
targetName += output;
|
|
|
|
commands.push_back(
|
|
|
|
this->GetRecursiveMakeCall(tgtMakefileName.c_str(), targetName.c_str())
|
|
|
|
);
|
|
|
|
}
|
2008-10-06 19:04:06 +04:00
|
|
|
this->CreateCDCommand(commands,
|
|
|
|
this->Makefile->GetHomeOutputDirectory(),
|
2008-10-09 23:30:07 +04:00
|
|
|
cmLocalGenerator::START_OUTPUT);
|
2006-08-02 19:06:32 +04:00
|
|
|
|
|
|
|
// Write the rule to the makefile.
|
|
|
|
std::vector<std::string> no_depends;
|
|
|
|
this->WriteMakeRule(ruleFileStream, comment,
|
2008-01-08 00:12:37 +03:00
|
|
|
output, no_depends, commands, true, inHelp);
|
2006-08-02 19:06:32 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
2005-05-24 22:42:23 +04:00
|
|
|
void cmLocalUnixMakefileGenerator3
|
2006-02-15 18:34:11 +03:00
|
|
|
::WriteLocalMakefileTargets(std::ostream& ruleFileStream,
|
|
|
|
std::set<cmStdString> &emitted)
|
2005-05-05 20:45:53 +04:00
|
|
|
{
|
2006-02-15 18:34:11 +03:00
|
|
|
std::vector<std::string> depends;
|
|
|
|
std::vector<std::string> commands;
|
|
|
|
|
|
|
|
// for each target we just provide a rule to cd up to the top and do a make
|
|
|
|
// on the target
|
2012-10-10 23:32:37 +04:00
|
|
|
cmGeneratorTargetsType targets = this->Makefile->GetGeneratorTargets();
|
2006-02-15 18:34:11 +03:00
|
|
|
std::string localName;
|
2012-10-10 23:32:37 +04:00
|
|
|
for(cmGeneratorTargetsType::iterator t = targets.begin();
|
|
|
|
t != targets.end(); ++t)
|
2005-05-05 20:45:53 +04:00
|
|
|
{
|
2012-10-10 23:32:37 +04:00
|
|
|
if((t->second->GetType() == cmTarget::EXECUTABLE) ||
|
|
|
|
(t->second->GetType() == cmTarget::STATIC_LIBRARY) ||
|
|
|
|
(t->second->GetType() == cmTarget::SHARED_LIBRARY) ||
|
|
|
|
(t->second->GetType() == cmTarget::MODULE_LIBRARY) ||
|
|
|
|
(t->second->GetType() == cmTarget::OBJECT_LIBRARY) ||
|
|
|
|
(t->second->GetType() == cmTarget::INTERFACE_LIBRARY) ||
|
|
|
|
(t->second->GetType() == cmTarget::UTILITY))
|
2005-05-05 20:45:53 +04:00
|
|
|
{
|
2012-10-10 23:32:37 +04:00
|
|
|
emitted.insert(t->second->GetName());
|
2006-02-15 18:34:11 +03:00
|
|
|
|
|
|
|
// for subdirs add a rule to build this specific target by name.
|
2012-10-10 23:32:37 +04:00
|
|
|
localName = this->GetRelativeTargetDirectory(*t->second->Target);
|
2006-02-15 18:34:11 +03:00
|
|
|
localName += "/rule";
|
|
|
|
commands.clear();
|
|
|
|
depends.clear();
|
2010-11-12 00:02:07 +03:00
|
|
|
|
2006-02-15 18:34:11 +03:00
|
|
|
// Build the target for this pass.
|
2007-08-04 00:31:08 +04:00
|
|
|
std::string makefile2 = cmake::GetCMakeFilesDirectoryPostSlash();
|
|
|
|
makefile2 += "Makefile2";
|
2006-02-15 18:34:11 +03:00
|
|
|
commands.push_back(this->GetRecursiveMakeCall
|
2007-08-04 00:31:08 +04:00
|
|
|
(makefile2.c_str(),localName.c_str()));
|
2006-02-15 18:34:11 +03:00
|
|
|
this->CreateCDCommand(commands,
|
2006-03-15 19:02:08 +03:00
|
|
|
this->Makefile->GetHomeOutputDirectory(),
|
2008-10-09 23:30:07 +04:00
|
|
|
cmLocalGenerator::START_OUTPUT);
|
2006-02-15 18:34:11 +03:00
|
|
|
this->WriteMakeRule(ruleFileStream, "Convenience name for target.",
|
2006-02-16 00:35:16 +03:00
|
|
|
localName.c_str(), depends, commands, true);
|
2010-11-12 00:02:07 +03:00
|
|
|
|
2006-02-15 18:34:11 +03:00
|
|
|
// Add a target with the canonical name (no prefix, suffix or path).
|
2012-10-10 23:32:37 +04:00
|
|
|
if(localName != t->second->GetName())
|
2005-05-24 22:42:23 +04:00
|
|
|
{
|
2006-02-15 18:34:11 +03:00
|
|
|
commands.clear();
|
|
|
|
depends.push_back(localName);
|
|
|
|
this->WriteMakeRule(ruleFileStream, "Convenience name for target.",
|
2012-10-10 23:32:37 +04:00
|
|
|
t->second->GetName(), depends, commands, true);
|
2005-05-24 22:42:23 +04:00
|
|
|
}
|
2006-06-01 22:09:21 +04:00
|
|
|
|
|
|
|
// Add a fast rule to build the target
|
2012-10-10 23:32:37 +04:00
|
|
|
std::string makefileName =
|
|
|
|
this->GetRelativeTargetDirectory(*t->second->Target);
|
2006-06-01 22:09:21 +04:00
|
|
|
makefileName += "/build.make";
|
2007-02-19 22:25:45 +03:00
|
|
|
// make sure the makefile name is suitable for a makefile
|
2010-11-12 00:02:07 +03:00
|
|
|
std::string makeTargetName =
|
2012-10-10 23:32:37 +04:00
|
|
|
this->GetRelativeTargetDirectory(*t->second->Target);
|
2006-06-01 22:09:21 +04:00
|
|
|
makeTargetName += "/build";
|
2012-10-10 23:32:37 +04:00
|
|
|
localName = t->second->GetName();
|
2006-06-01 22:09:21 +04:00
|
|
|
localName += "/fast";
|
|
|
|
depends.clear();
|
|
|
|
commands.clear();
|
|
|
|
commands.push_back(this->GetRecursiveMakeCall
|
|
|
|
(makefileName.c_str(), makeTargetName.c_str()));
|
|
|
|
this->CreateCDCommand(commands,
|
|
|
|
this->Makefile->GetHomeOutputDirectory(),
|
2008-10-09 23:30:07 +04:00
|
|
|
cmLocalGenerator::START_OUTPUT);
|
2006-06-01 22:09:21 +04:00
|
|
|
this->WriteMakeRule(ruleFileStream, "fast build rule for target.",
|
|
|
|
localName.c_str(), depends, commands, true);
|
2007-08-04 00:31:08 +04:00
|
|
|
|
|
|
|
// Add a local name for the rule to relink the target before
|
|
|
|
// installation.
|
2012-10-10 23:32:37 +04:00
|
|
|
if(t->second->Target
|
|
|
|
->NeedRelinkBeforeInstall(this->ConfigurationName.c_str()))
|
2007-08-04 00:31:08 +04:00
|
|
|
{
|
2012-10-10 23:32:37 +04:00
|
|
|
makeTargetName = this->GetRelativeTargetDirectory(*t->second->Target);
|
2007-08-04 00:31:08 +04:00
|
|
|
makeTargetName += "/preinstall";
|
2012-10-10 23:32:37 +04:00
|
|
|
localName = t->second->GetName();
|
2007-08-04 00:31:08 +04:00
|
|
|
localName += "/preinstall";
|
|
|
|
depends.clear();
|
|
|
|
commands.clear();
|
|
|
|
commands.push_back(this->GetRecursiveMakeCall
|
|
|
|
(makefile2.c_str(), makeTargetName.c_str()));
|
|
|
|
this->CreateCDCommand(commands,
|
|
|
|
this->Makefile->GetHomeOutputDirectory(),
|
2008-10-09 23:30:07 +04:00
|
|
|
cmLocalGenerator::START_OUTPUT);
|
2007-08-04 00:31:08 +04:00
|
|
|
this->WriteMakeRule(ruleFileStream,
|
|
|
|
"Manual pre-install relink rule for target.",
|
|
|
|
localName.c_str(), depends, commands, true);
|
|
|
|
}
|
2005-05-05 20:45:53 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
2005-05-06 22:49:38 +04:00
|
|
|
void cmLocalUnixMakefileGenerator3::WriteDirectoryInformationFile()
|
2005-05-05 20:45:53 +04:00
|
|
|
{
|
2006-03-15 19:02:08 +03:00
|
|
|
std::string infoFileName = this->Makefile->GetStartOutputDirectory();
|
2006-06-14 20:28:32 +04:00
|
|
|
infoFileName += cmake::GetCMakeFilesDirectory();
|
|
|
|
infoFileName += "/CMakeDirectoryInformation.cmake";
|
2005-05-05 20:45:53 +04:00
|
|
|
|
|
|
|
// Open the output file.
|
|
|
|
cmGeneratedFileStream infoFileStream(infoFileName.c_str());
|
|
|
|
if(!infoFileStream)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-09-22 22:40:23 +04:00
|
|
|
infoFileStream.SetCopyIfDifferent(true);
|
2005-05-05 20:45:53 +04:00
|
|
|
// Write the do not edit header.
|
|
|
|
this->WriteDisclaimer(infoFileStream);
|
|
|
|
|
2007-03-16 23:48:27 +03:00
|
|
|
// Setup relative path conversion tops.
|
|
|
|
infoFileStream
|
|
|
|
<< "# Relative path conversion top directories.\n"
|
2013-08-22 13:30:19 +04:00
|
|
|
<< "set(CMAKE_RELATIVE_PATH_TOP_SOURCE \"" << this->RelativePathTopSource
|
2007-03-16 23:48:27 +03:00
|
|
|
<< "\")\n"
|
2013-08-22 13:30:19 +04:00
|
|
|
<< "set(CMAKE_RELATIVE_PATH_TOP_BINARY \"" << this->RelativePathTopBinary
|
2007-03-16 23:48:27 +03:00
|
|
|
<< "\")\n"
|
|
|
|
<< "\n";
|
|
|
|
|
2005-05-05 20:45:53 +04:00
|
|
|
// Tell the dependency scanner to use unix paths if necessary.
|
|
|
|
if(cmSystemTools::GetForceUnixPaths())
|
|
|
|
{
|
|
|
|
infoFileStream
|
|
|
|
<< "# Force unix paths in dependencies.\n"
|
2013-08-22 13:30:19 +04:00
|
|
|
<< "set(CMAKE_FORCE_UNIX_PATHS 1)\n"
|
2005-05-05 20:45:53 +04:00
|
|
|
<< "\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
// Store the include regular expressions for this directory.
|
|
|
|
infoFileStream
|
|
|
|
<< "\n"
|
2006-05-15 18:19:57 +04:00
|
|
|
<< "# The C and CXX include file regular expressions for "
|
|
|
|
<< "this directory.\n";
|
2005-05-05 20:45:53 +04:00
|
|
|
infoFileStream
|
2013-08-22 13:30:19 +04:00
|
|
|
<< "set(CMAKE_C_INCLUDE_REGEX_SCAN ";
|
2005-05-05 20:45:53 +04:00
|
|
|
this->WriteCMakeArgument(infoFileStream,
|
2006-03-15 19:02:08 +03:00
|
|
|
this->Makefile->GetIncludeRegularExpression());
|
2005-05-05 20:45:53 +04:00
|
|
|
infoFileStream
|
|
|
|
<< ")\n";
|
|
|
|
infoFileStream
|
2013-08-22 13:30:19 +04:00
|
|
|
<< "set(CMAKE_C_INCLUDE_REGEX_COMPLAIN ";
|
2005-05-05 20:45:53 +04:00
|
|
|
this->WriteCMakeArgument(infoFileStream,
|
2006-03-15 19:02:08 +03:00
|
|
|
this->Makefile->GetComplainRegularExpression());
|
2005-05-05 20:45:53 +04:00
|
|
|
infoFileStream
|
|
|
|
<< ")\n";
|
|
|
|
infoFileStream
|
2013-08-22 13:30:19 +04:00
|
|
|
<< "set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN})\n";
|
2005-05-05 20:45:53 +04:00
|
|
|
infoFileStream
|
2013-08-22 13:30:19 +04:00
|
|
|
<< "set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN "
|
2006-05-15 18:19:57 +04:00
|
|
|
"${CMAKE_C_INCLUDE_REGEX_COMPLAIN})\n";
|
2005-05-05 20:45:53 +04:00
|
|
|
}
|
|
|
|
|
2005-05-06 22:49:38 +04:00
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
std::string
|
|
|
|
cmLocalUnixMakefileGenerator3
|
|
|
|
::ConvertToFullPath(const std::string& localPath)
|
|
|
|
{
|
2006-03-15 19:02:08 +03:00
|
|
|
std::string dir = this->Makefile->GetStartOutputDirectory();
|
2005-05-06 22:49:38 +04:00
|
|
|
dir += "/";
|
|
|
|
dir += localPath;
|
|
|
|
return dir;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-06-01 21:37:49 +04:00
|
|
|
const std::string &cmLocalUnixMakefileGenerator3::GetHomeRelativeOutputPath()
|
|
|
|
{
|
2006-03-15 19:02:08 +03:00
|
|
|
return this->HomeRelativeOutputPath;
|
2005-05-05 20:45:53 +04:00
|
|
|
}
|
|
|
|
|
2006-02-15 18:34:11 +03:00
|
|
|
|
2005-05-05 20:45:53 +04:00
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
void
|
|
|
|
cmLocalUnixMakefileGenerator3
|
2006-02-15 18:34:11 +03:00
|
|
|
::WriteMakeRule(std::ostream& os,
|
|
|
|
const char* comment,
|
|
|
|
const char* target,
|
|
|
|
const std::vector<std::string>& depends,
|
2006-02-16 00:35:16 +03:00
|
|
|
const std::vector<std::string>& commands,
|
2006-08-23 17:45:24 +04:00
|
|
|
bool symbolic,
|
|
|
|
bool in_help)
|
2005-05-05 20:45:53 +04:00
|
|
|
{
|
2006-02-15 18:34:11 +03:00
|
|
|
// Make sure there is a target.
|
|
|
|
if(!target || !*target)
|
2005-07-27 17:49:37 +04:00
|
|
|
{
|
2006-02-15 18:34:11 +03:00
|
|
|
cmSystemTools::Error("No target for WriteMakeRule! called with comment: ",
|
|
|
|
comment);
|
2005-07-27 17:49:37 +04:00
|
|
|
return;
|
|
|
|
}
|
2006-02-15 18:34:11 +03:00
|
|
|
|
|
|
|
std::string replace;
|
|
|
|
|
|
|
|
// Write the comment describing the rule in the makefile.
|
|
|
|
if(comment)
|
2005-08-01 18:19:35 +04:00
|
|
|
{
|
2006-02-15 18:34:11 +03:00
|
|
|
replace = comment;
|
|
|
|
std::string::size_type lpos = 0;
|
|
|
|
std::string::size_type rpos;
|
|
|
|
while((rpos = replace.find('\n', lpos)) != std::string::npos)
|
2005-05-05 20:45:53 +04:00
|
|
|
{
|
2006-02-15 18:34:11 +03:00
|
|
|
os << "# " << replace.substr(lpos, rpos-lpos) << "\n";
|
|
|
|
lpos = rpos+1;
|
2005-05-05 20:45:53 +04:00
|
|
|
}
|
2006-02-15 18:34:11 +03:00
|
|
|
os << "# " << replace.substr(lpos) << "\n";
|
2005-05-05 20:45:53 +04:00
|
|
|
}
|
2006-02-15 18:34:11 +03:00
|
|
|
|
|
|
|
// Construct the left hand side of the rule.
|
|
|
|
replace = target;
|
|
|
|
std::string tgt = this->Convert(replace.c_str(),HOME_OUTPUT,MAKEFILE);
|
|
|
|
const char* space = "";
|
|
|
|
if(tgt.size() == 1)
|
2005-08-01 18:19:35 +04:00
|
|
|
{
|
2006-02-15 18:34:11 +03:00
|
|
|
// Add a space before the ":" to avoid drive letter confusion on
|
|
|
|
// Windows.
|
|
|
|
space = " ";
|
|
|
|
}
|
2005-12-26 21:14:19 +03:00
|
|
|
|
2006-02-16 00:35:16 +03:00
|
|
|
// Mark the rule as symbolic if requested.
|
|
|
|
if(symbolic)
|
|
|
|
{
|
|
|
|
if(const char* sym =
|
2006-03-15 19:02:08 +03:00
|
|
|
this->Makefile->GetDefinition("CMAKE_MAKE_SYMBOLIC_RULE"))
|
2006-02-16 00:35:16 +03:00
|
|
|
{
|
2012-06-06 16:30:54 +04:00
|
|
|
os << cmMakeSafe(tgt) << space << ": " << sym << "\n";
|
2006-02-16 00:35:16 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-02-15 18:34:11 +03:00
|
|
|
// Write the rule.
|
|
|
|
if(depends.empty())
|
|
|
|
{
|
|
|
|
// No dependencies. The commands will always run.
|
2012-06-06 16:30:54 +04:00
|
|
|
os << cmMakeSafe(tgt) << space << ":\n";
|
2005-08-01 18:19:35 +04:00
|
|
|
}
|
2006-02-15 18:34:11 +03:00
|
|
|
else
|
2005-05-19 18:52:59 +04:00
|
|
|
{
|
2006-02-15 18:34:11 +03:00
|
|
|
// Split dependencies into multiple rule lines. This allows for
|
|
|
|
// very long dependency lists even on older make implementations.
|
|
|
|
for(std::vector<std::string>::const_iterator dep = depends.begin();
|
|
|
|
dep != depends.end(); ++dep)
|
2005-12-27 23:33:47 +03:00
|
|
|
{
|
2006-02-15 18:34:11 +03:00
|
|
|
replace = *dep;
|
|
|
|
replace = this->Convert(replace.c_str(),HOME_OUTPUT,MAKEFILE);
|
2012-06-06 16:30:54 +04:00
|
|
|
os << cmMakeSafe(tgt) << space << ": " << cmMakeSafe(replace) << "\n";
|
2005-12-27 23:33:47 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-02-15 18:34:11 +03:00
|
|
|
// Write the list of commands.
|
|
|
|
for(std::vector<std::string>::const_iterator i = commands.begin();
|
|
|
|
i != commands.end(); ++i)
|
2005-12-26 21:14:19 +03:00
|
|
|
{
|
2006-02-15 18:34:11 +03:00
|
|
|
replace = *i;
|
|
|
|
os << "\t" << replace.c_str() << "\n";
|
2005-12-26 21:14:19 +03:00
|
|
|
}
|
2008-03-25 17:11:48 +03:00
|
|
|
if(symbolic && !this->WatcomWMake)
|
2008-03-24 17:26:38 +03:00
|
|
|
{
|
2012-06-06 16:30:54 +04:00
|
|
|
os << ".PHONY : " << cmMakeSafe(tgt) << "\n";
|
2008-03-24 17:26:38 +03:00
|
|
|
}
|
2006-02-15 18:34:11 +03:00
|
|
|
os << "\n";
|
2006-08-23 17:45:24 +04:00
|
|
|
// Add the output to the local help if requested.
|
|
|
|
if(in_help)
|
|
|
|
{
|
|
|
|
this->LocalHelp.push_back(target);
|
|
|
|
}
|
2005-12-26 21:14:19 +03:00
|
|
|
}
|
|
|
|
|
2011-11-03 16:59:50 +04:00
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
std::string
|
|
|
|
cmLocalUnixMakefileGenerator3
|
|
|
|
::ConvertShellCommand(std::string const& cmd, RelativeRoot root)
|
|
|
|
{
|
|
|
|
if(this->WatcomWMake &&
|
|
|
|
cmSystemTools::FileIsFullPath(cmd.c_str()) &&
|
|
|
|
cmd.find_first_of("( )") != cmd.npos)
|
|
|
|
{
|
|
|
|
// On Watcom WMake use the windows short path for the command
|
|
|
|
// name. This is needed to avoid funny quoting problems on
|
|
|
|
// lines with shell redirection operators.
|
|
|
|
std::string scmd;
|
|
|
|
if(cmSystemTools::GetShortPath(cmd.c_str(), scmd))
|
|
|
|
{
|
|
|
|
return this->Convert(scmd.c_str(), NONE, SHELL);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return this->Convert(cmd.c_str(), root, SHELL);
|
|
|
|
}
|
|
|
|
|
2005-05-05 20:45:53 +04:00
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
void
|
|
|
|
cmLocalUnixMakefileGenerator3
|
2006-02-15 18:34:11 +03:00
|
|
|
::WriteMakeVariables(std::ostream& makefileStream)
|
2005-05-06 22:49:38 +04:00
|
|
|
{
|
|
|
|
this->WriteDivider(makefileStream);
|
|
|
|
makefileStream
|
|
|
|
<< "# Set environment variables for the build.\n"
|
|
|
|
<< "\n";
|
2006-03-15 19:02:08 +03:00
|
|
|
if(this->DefineWindowsNULL)
|
2005-05-06 22:49:38 +04:00
|
|
|
{
|
|
|
|
makefileStream
|
|
|
|
<< "!IF \"$(OS)\" == \"Windows_NT\"\n"
|
|
|
|
<< "NULL=\n"
|
|
|
|
<< "!ELSE\n"
|
|
|
|
<< "NULL=nul\n"
|
|
|
|
<< "!ENDIF\n";
|
|
|
|
}
|
2006-03-15 19:02:08 +03:00
|
|
|
if(this->WindowsShell)
|
2005-12-23 00:42:36 +03:00
|
|
|
{
|
|
|
|
makefileStream
|
2006-04-27 05:51:23 +04:00
|
|
|
<< "SHELL = cmd.exe\n"
|
|
|
|
<< "\n";
|
2005-12-23 00:42:36 +03:00
|
|
|
}
|
2005-05-06 22:49:38 +04:00
|
|
|
else
|
|
|
|
{
|
2009-06-10 21:03:37 +04:00
|
|
|
#if !defined(__VMS)
|
2005-12-23 00:42:36 +03:00
|
|
|
makefileStream
|
|
|
|
<< "# The shell in which to execute make rules.\n"
|
|
|
|
<< "SHELL = /bin/sh\n"
|
|
|
|
<< "\n";
|
2009-06-10 21:03:37 +04:00
|
|
|
#endif
|
2005-05-06 22:49:38 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
std::string cmakecommand =
|
2006-03-15 19:02:08 +03:00
|
|
|
this->Makefile->GetRequiredDefinition("CMAKE_COMMAND");
|
2005-05-06 22:49:38 +04:00
|
|
|
makefileStream
|
|
|
|
<< "# The CMake executable.\n"
|
|
|
|
<< "CMAKE_COMMAND = "
|
2011-11-03 16:59:50 +04:00
|
|
|
<< this->ConvertShellCommand(cmakecommand, FULL)
|
2005-07-05 17:21:44 +04:00
|
|
|
<< "\n"
|
2005-05-06 22:49:38 +04:00
|
|
|
<< "\n";
|
|
|
|
makefileStream
|
|
|
|
<< "# The command to remove a file.\n"
|
|
|
|
<< "RM = "
|
2011-11-03 16:59:50 +04:00
|
|
|
<< this->ConvertShellCommand(cmakecommand, FULL)
|
2005-05-06 22:49:38 +04:00
|
|
|
<< " -E remove -f\n"
|
|
|
|
<< "\n";
|
2012-06-06 16:30:54 +04:00
|
|
|
makefileStream
|
|
|
|
<< "# Escaping for special characters.\n"
|
|
|
|
<< "EQUALS = =\n"
|
|
|
|
<< "\n";
|
2005-05-06 22:49:38 +04:00
|
|
|
makefileStream
|
|
|
|
<< "# The top-level source directory on which CMake was run.\n"
|
|
|
|
<< "CMAKE_SOURCE_DIR = "
|
2006-03-15 19:02:08 +03:00
|
|
|
<< this->Convert(this->Makefile->GetHomeDirectory(), FULL, SHELL)
|
2005-05-06 22:49:38 +04:00
|
|
|
<< "\n"
|
|
|
|
<< "\n";
|
|
|
|
makefileStream
|
|
|
|
<< "# The top-level build directory on which CMake was run.\n"
|
2005-07-05 17:21:44 +04:00
|
|
|
<< "CMAKE_BINARY_DIR = "
|
2006-03-15 19:02:08 +03:00
|
|
|
<< this->Convert(this->Makefile->GetHomeOutputDirectory(), FULL, SHELL)
|
2005-05-06 22:49:38 +04:00
|
|
|
<< "\n"
|
|
|
|
<< "\n";
|
|
|
|
}
|
|
|
|
|
2005-05-05 20:45:53 +04:00
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
void
|
|
|
|
cmLocalUnixMakefileGenerator3
|
|
|
|
::WriteSpecialTargetsTop(std::ostream& makefileStream)
|
|
|
|
{
|
|
|
|
this->WriteDivider(makefileStream);
|
|
|
|
makefileStream
|
|
|
|
<< "# Special targets provided by cmake.\n"
|
|
|
|
<< "\n";
|
|
|
|
|
2006-09-08 18:42:14 +04:00
|
|
|
std::vector<std::string> no_commands;
|
|
|
|
std::vector<std::string> no_depends;
|
|
|
|
|
|
|
|
// Special target to cleanup operation of make tool.
|
|
|
|
// This should be the first target except for the default_target in
|
|
|
|
// the interface Makefile.
|
|
|
|
this->WriteMakeRule(
|
2011-11-04 22:49:40 +04:00
|
|
|
makefileStream, "Disable implicit rules so canonical targets will work.",
|
2006-09-08 18:42:14 +04:00
|
|
|
".SUFFIXES", no_depends, no_commands, false);
|
|
|
|
|
2008-03-18 18:51:23 +03:00
|
|
|
if(!this->NMake && !this->WatcomWMake && !this->BorlandMakeCurlyHack)
|
2008-03-18 18:28:59 +03:00
|
|
|
{
|
|
|
|
// turn off RCS and SCCS automatic stuff from gmake
|
2008-03-18 18:51:23 +03:00
|
|
|
makefileStream
|
|
|
|
<< "# Remove some rules from gmake that .SUFFIXES does not remove.\n"
|
2008-04-10 19:55:49 +04:00
|
|
|
<< "SUFFIXES =\n\n";
|
2008-03-18 18:28:59 +03:00
|
|
|
}
|
2006-09-08 18:42:14 +04:00
|
|
|
// Add a fake suffix to keep HP happy. Must be max 32 chars for SGI make.
|
|
|
|
std::vector<std::string> depends;
|
|
|
|
depends.push_back(".hpux_make_needs_suffix_list");
|
|
|
|
this->WriteMakeRule(makefileStream, 0,
|
|
|
|
".SUFFIXES", depends, no_commands, false);
|
|
|
|
|
2007-06-06 00:35:24 +04:00
|
|
|
cmGlobalUnixMakefileGenerator3* gg =
|
|
|
|
static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator);
|
2005-10-21 23:24:12 +04:00
|
|
|
// Write special target to silence make output. This must be after
|
|
|
|
// the default target in case VERBOSE is set (which changes the
|
|
|
|
// name). The setting of CMAKE_VERBOSE_MAKEFILE to ON will cause a
|
|
|
|
// "VERBOSE=1" to be added as a make variable which will change the
|
|
|
|
// name of this special target. This gives a make-time choice to
|
|
|
|
// the user.
|
2010-11-12 00:06:09 +03:00
|
|
|
if(this->Makefile->IsOn("CMAKE_VERBOSE_MAKEFILE"))
|
2005-12-31 05:54:03 +03:00
|
|
|
{
|
|
|
|
makefileStream
|
|
|
|
<< "# Produce verbose output by default.\n"
|
|
|
|
<< "VERBOSE = 1\n"
|
|
|
|
<< "\n";
|
|
|
|
}
|
2006-03-15 19:02:08 +03:00
|
|
|
if(this->SilentNoColon)
|
2006-01-17 18:21:45 +03:00
|
|
|
{
|
|
|
|
makefileStream << "$(VERBOSE).SILENT\n";
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
this->WriteMakeRule(makefileStream,
|
|
|
|
"Suppress display of executed commands.",
|
|
|
|
"$(VERBOSE).SILENT",
|
|
|
|
no_depends,
|
2006-09-08 18:42:14 +04:00
|
|
|
no_commands, false);
|
2006-01-17 18:21:45 +03:00
|
|
|
}
|
2005-10-21 23:24:12 +04:00
|
|
|
|
2007-02-28 17:33:25 +03:00
|
|
|
// Work-around for makes that drop rules that have no dependencies
|
|
|
|
// or commands.
|
|
|
|
std::string hack = gg->GetEmptyRuleHackDepends();
|
|
|
|
if(!hack.empty())
|
|
|
|
{
|
|
|
|
no_depends.push_back(hack);
|
|
|
|
}
|
2007-05-16 21:24:17 +04:00
|
|
|
std::string hack_cmd = gg->GetEmptyRuleHackCommand();
|
|
|
|
if(!hack_cmd.empty())
|
|
|
|
{
|
|
|
|
no_commands.push_back(hack_cmd);
|
|
|
|
}
|
2007-02-28 17:33:25 +03:00
|
|
|
|
2006-09-20 20:13:50 +04:00
|
|
|
// Special symbolic target that never exists to force dependers to
|
|
|
|
// run their rules.
|
|
|
|
this->WriteMakeRule
|
|
|
|
(makefileStream,
|
|
|
|
"A target that is always out of date.",
|
|
|
|
"cmake_force", no_depends, no_commands, true);
|
|
|
|
|
2006-09-08 18:42:14 +04:00
|
|
|
// Variables for reference by other rules.
|
|
|
|
this->WriteMakeVariables(makefileStream);
|
2005-05-05 20:45:53 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
2006-05-15 18:19:57 +04:00
|
|
|
void cmLocalUnixMakefileGenerator3
|
2005-05-05 20:45:53 +04:00
|
|
|
::WriteSpecialTargetsBottom(std::ostream& makefileStream)
|
|
|
|
{
|
|
|
|
this->WriteDivider(makefileStream);
|
|
|
|
makefileStream
|
|
|
|
<< "# Special targets to cleanup operation of make.\n"
|
|
|
|
<< "\n";
|
|
|
|
|
|
|
|
// 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.
|
2006-06-14 20:28:32 +04:00
|
|
|
std::string cmakefileName = cmake::GetCMakeFilesDirectoryPostSlash();
|
|
|
|
cmakefileName += "Makefile.cmake";
|
2005-05-05 20:45:53 +04:00
|
|
|
std::string runRule =
|
|
|
|
"$(CMAKE_COMMAND) -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)";
|
|
|
|
runRule += " --check-build-system ";
|
2005-05-13 17:54:30 +04:00
|
|
|
runRule += this->Convert(cmakefileName.c_str(),NONE,SHELL);
|
2005-10-21 19:10:30 +04:00
|
|
|
runRule += " 0";
|
2006-03-02 02:54:17 +03:00
|
|
|
|
2005-05-05 20:45:53 +04:00
|
|
|
std::vector<std::string> no_depends;
|
|
|
|
std::vector<std::string> commands;
|
|
|
|
commands.push_back(runRule);
|
2006-03-15 19:02:08 +03:00
|
|
|
if(this->Parent)
|
2006-03-02 02:54:17 +03:00
|
|
|
{
|
|
|
|
this->CreateCDCommand(commands,
|
2006-03-15 19:02:08 +03:00
|
|
|
this->Makefile->GetHomeOutputDirectory(),
|
2008-10-09 23:30:07 +04:00
|
|
|
cmLocalGenerator::START_OUTPUT);
|
2006-03-02 02:54:17 +03:00
|
|
|
}
|
2005-05-05 20:45:53 +04:00
|
|
|
this->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,
|
2006-02-16 00:35:16 +03:00
|
|
|
commands, true);
|
2005-05-05 20:45:53 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
void
|
|
|
|
cmLocalUnixMakefileGenerator3
|
|
|
|
::WriteConvenienceRule(std::ostream& ruleFileStream,
|
|
|
|
const char* realTarget,
|
|
|
|
const char* helpTarget)
|
|
|
|
{
|
|
|
|
// A rule is only needed if the names are different.
|
|
|
|
if(strcmp(realTarget, helpTarget) != 0)
|
|
|
|
{
|
|
|
|
// The helper target depends on the real target.
|
|
|
|
std::vector<std::string> depends;
|
|
|
|
depends.push_back(realTarget);
|
|
|
|
|
|
|
|
// There are no commands.
|
|
|
|
std::vector<std::string> no_commands;
|
|
|
|
|
|
|
|
// Write the rule.
|
|
|
|
this->WriteMakeRule(ruleFileStream, "Convenience name for target.",
|
2006-02-16 00:35:16 +03:00
|
|
|
helpTarget, depends, no_commands, true);
|
2005-05-05 20:45:53 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-02-15 18:34:11 +03:00
|
|
|
|
2005-05-11 16:45:16 +04:00
|
|
|
//----------------------------------------------------------------------------
|
2006-02-15 18:34:11 +03:00
|
|
|
std::string
|
2007-12-23 23:03:42 +03:00
|
|
|
cmLocalUnixMakefileGenerator3
|
|
|
|
::GetRelativeTargetDirectory(cmTarget const& target)
|
2005-05-11 16:45:16 +04:00
|
|
|
{
|
2006-04-11 20:51:20 +04:00
|
|
|
std::string dir = this->HomeRelativeOutputPath;
|
2006-02-15 18:34:11 +03:00
|
|
|
dir += this->GetTargetDirectory(target);
|
2007-02-19 20:26:32 +03:00
|
|
|
return this->Convert(dir.c_str(),NONE,UNCHANGED);
|
2006-02-15 18:34:11 +03:00
|
|
|
}
|
|
|
|
|
2005-05-11 16:45:16 +04:00
|
|
|
|
2005-05-17 19:15:09 +04:00
|
|
|
|
2007-05-10 22:43:55 +04:00
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
void cmLocalUnixMakefileGenerator3::AppendFlags(std::string& flags,
|
|
|
|
const char* newFlags)
|
|
|
|
{
|
|
|
|
if(this->WatcomWMake && newFlags && *newFlags)
|
|
|
|
{
|
|
|
|
std::string newf = newFlags;
|
|
|
|
if(newf.find("\\\"") != newf.npos)
|
|
|
|
{
|
|
|
|
cmSystemTools::ReplaceString(newf, "\\\"", "\"");
|
|
|
|
this->cmLocalGenerator::AppendFlags(flags, newf.c_str());
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
this->cmLocalGenerator::AppendFlags(flags, newFlags);
|
|
|
|
}
|
|
|
|
|
2006-02-15 18:34:11 +03:00
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
void
|
|
|
|
cmLocalUnixMakefileGenerator3
|
|
|
|
::AppendRuleDepend(std::vector<std::string>& depends,
|
|
|
|
const char* ruleFileName)
|
|
|
|
{
|
|
|
|
// Add a dependency on the rule file itself unless an option to skip
|
|
|
|
// it is specifically enabled by the user or project.
|
2010-11-12 00:02:07 +03:00
|
|
|
const char* nodep =
|
2006-05-15 18:19:57 +04:00
|
|
|
this->Makefile->GetDefinition("CMAKE_SKIP_RULE_DEPENDENCY");
|
2006-02-15 18:34:11 +03:00
|
|
|
if(!nodep || cmSystemTools::IsOff(nodep))
|
2005-05-11 16:45:16 +04:00
|
|
|
{
|
2006-02-15 18:34:11 +03:00
|
|
|
depends.push_back(ruleFileName);
|
2005-05-11 16:45:16 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-03-15 21:07:36 +03:00
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
void
|
|
|
|
cmLocalUnixMakefileGenerator3
|
|
|
|
::AppendRuleDepends(std::vector<std::string>& depends,
|
|
|
|
std::vector<std::string> const& ruleFiles)
|
|
|
|
{
|
|
|
|
// Add a dependency on the rule file itself unless an option to skip
|
|
|
|
// it is specifically enabled by the user or project.
|
|
|
|
if(!this->Makefile->IsOn("CMAKE_SKIP_RULE_DEPENDENCY"))
|
|
|
|
{
|
|
|
|
depends.insert(depends.end(), ruleFiles.begin(), ruleFiles.end());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-05-05 20:45:53 +04:00
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
void
|
|
|
|
cmLocalUnixMakefileGenerator3
|
2006-02-15 18:34:11 +03:00
|
|
|
::AppendCustomDepends(std::vector<std::string>& depends,
|
|
|
|
const std::vector<cmCustomCommand>& ccs)
|
2005-05-05 20:45:53 +04:00
|
|
|
{
|
2006-02-15 18:34:11 +03:00
|
|
|
for(std::vector<cmCustomCommand>::const_iterator i = ccs.begin();
|
|
|
|
i != ccs.end(); ++i)
|
2005-05-05 20:45:53 +04:00
|
|
|
{
|
2006-02-15 18:34:11 +03:00
|
|
|
this->AppendCustomDepend(depends, *i);
|
2005-05-05 20:45:53 +04:00
|
|
|
}
|
2006-02-15 18:34:11 +03:00
|
|
|
}
|
2005-05-05 20:45:53 +04:00
|
|
|
|
2006-02-15 18:34:11 +03:00
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
void
|
|
|
|
cmLocalUnixMakefileGenerator3
|
|
|
|
::AppendCustomDepend(std::vector<std::string>& depends,
|
|
|
|
const cmCustomCommand& cc)
|
|
|
|
{
|
|
|
|
for(std::vector<std::string>::const_iterator d = cc.GetDepends().begin();
|
|
|
|
d != cc.GetDepends().end(); ++d)
|
2005-11-17 21:49:10 +03:00
|
|
|
{
|
2006-02-15 18:34:11 +03:00
|
|
|
// Lookup the real name of the dependency in case it is a CMake target.
|
2010-12-09 00:51:16 +03:00
|
|
|
std::string dep;
|
|
|
|
if(this->GetRealDependency(d->c_str(), this->ConfigurationName.c_str(),
|
|
|
|
dep))
|
|
|
|
{
|
|
|
|
depends.push_back(dep);
|
|
|
|
}
|
2005-11-17 21:49:10 +03:00
|
|
|
}
|
2006-02-15 18:34:11 +03:00
|
|
|
}
|
2005-11-17 21:49:10 +03:00
|
|
|
|
2006-02-15 18:34:11 +03:00
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
void
|
|
|
|
cmLocalUnixMakefileGenerator3
|
|
|
|
::AppendCustomCommands(std::vector<std::string>& commands,
|
2008-10-09 23:30:07 +04:00
|
|
|
const std::vector<cmCustomCommand>& ccs,
|
2009-02-10 16:50:33 +03:00
|
|
|
cmTarget* target,
|
2008-10-09 23:30:07 +04:00
|
|
|
cmLocalGenerator::RelativeRoot relative)
|
2006-02-15 18:34:11 +03:00
|
|
|
{
|
|
|
|
for(std::vector<cmCustomCommand>::const_iterator i = ccs.begin();
|
|
|
|
i != ccs.end(); ++i)
|
2005-05-05 20:45:53 +04:00
|
|
|
{
|
2009-02-10 16:50:33 +03:00
|
|
|
this->AppendCustomCommand(commands, *i, target, true, relative);
|
2005-05-05 20:45:53 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
void
|
|
|
|
cmLocalUnixMakefileGenerator3
|
|
|
|
::AppendCustomCommand(std::vector<std::string>& commands,
|
2009-02-10 16:50:33 +03:00
|
|
|
const cmCustomCommand& cc,
|
|
|
|
cmTarget* target,
|
|
|
|
bool echo_comment,
|
2009-02-02 21:28:12 +03:00
|
|
|
cmLocalGenerator::RelativeRoot relative,
|
|
|
|
std::ostream* content)
|
2005-05-05 20:45:53 +04:00
|
|
|
{
|
2007-12-18 17:50:08 +03:00
|
|
|
// Optionally create a command to display the custom command's
|
|
|
|
// comment text. This is used for pre-build, pre-link, and
|
|
|
|
// post-build command comments. Custom build step commands have
|
|
|
|
// their comments generated elsewhere.
|
|
|
|
if(echo_comment)
|
|
|
|
{
|
|
|
|
const char* comment = cc.GetComment();
|
|
|
|
if(comment && *comment)
|
|
|
|
{
|
|
|
|
this->AppendEcho(commands, comment,
|
|
|
|
cmLocalUnixMakefileGenerator3::EchoGenerate);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-06-26 23:27:51 +04:00
|
|
|
// if the command specified a working directory use it.
|
|
|
|
const char* dir = this->Makefile->GetStartOutputDirectory();
|
|
|
|
const char* workingDir = cc.GetWorkingDirectory();
|
|
|
|
if(workingDir)
|
|
|
|
{
|
|
|
|
dir = workingDir;
|
|
|
|
}
|
2009-02-02 21:28:12 +03:00
|
|
|
if(content)
|
|
|
|
{
|
|
|
|
*content << dir;
|
|
|
|
}
|
2010-12-08 00:23:38 +03:00
|
|
|
cmCustomCommandGenerator ccg(cc, this->ConfigurationName.c_str(),
|
|
|
|
this->Makefile);
|
2005-05-05 20:45:53 +04:00
|
|
|
|
|
|
|
// Add each command line to the set of commands.
|
2006-06-26 23:27:51 +04:00
|
|
|
std::vector<std::string> commands1;
|
2010-12-08 00:23:38 +03:00
|
|
|
for(unsigned int c = 0; c < ccg.GetNumberOfCommands(); ++c)
|
2005-05-05 20:45:53 +04:00
|
|
|
{
|
|
|
|
// Build the command line in a single string.
|
2010-12-08 00:23:38 +03:00
|
|
|
std::string cmd = ccg.GetCommand(c);
|
2005-05-20 20:09:33 +04:00
|
|
|
if (cmd.size())
|
2005-05-05 20:45:53 +04:00
|
|
|
{
|
2010-06-03 21:43:39 +04:00
|
|
|
// Use "call " before any invocations of .bat or .cmd files
|
|
|
|
// invoked as custom commands in the WindowsShell.
|
|
|
|
//
|
|
|
|
bool useCall = false;
|
|
|
|
|
|
|
|
if (this->WindowsShell)
|
|
|
|
{
|
|
|
|
std::string suffix;
|
|
|
|
if (cmd.size() > 4)
|
|
|
|
{
|
|
|
|
suffix = cmSystemTools::LowerCase(cmd.substr(cmd.size()-4));
|
|
|
|
if (suffix == ".bat" || suffix == ".cmd")
|
|
|
|
{
|
|
|
|
useCall = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-05-20 20:09:33 +04:00
|
|
|
cmSystemTools::ReplaceString(cmd, "/./", "/");
|
2006-06-26 23:27:51 +04:00
|
|
|
// Convert the command to a relative path only if the current
|
|
|
|
// working directory will be the start-output directory.
|
2007-05-23 20:05:05 +04:00
|
|
|
bool had_slash = cmd.find("/") != cmd.npos;
|
2006-06-26 23:27:51 +04:00
|
|
|
if(!workingDir)
|
|
|
|
{
|
|
|
|
cmd = this->Convert(cmd.c_str(),START_OUTPUT);
|
|
|
|
}
|
2007-05-23 20:05:05 +04:00
|
|
|
bool has_slash = cmd.find("/") != cmd.npos;
|
|
|
|
if(had_slash && !has_slash)
|
2005-05-20 20:09:33 +04:00
|
|
|
{
|
2007-05-23 20:05:05 +04:00
|
|
|
// This command was specified as a path to a file in the
|
|
|
|
// current directory. Add a leading "./" so it can run
|
|
|
|
// without the current directory being in the search path.
|
2005-05-20 20:09:33 +04:00
|
|
|
cmd = "./" + cmd;
|
|
|
|
}
|
2009-02-10 16:51:15 +03:00
|
|
|
std::string launcher =
|
|
|
|
this->MakeLauncher(cc, target, workingDir? NONE : START_OUTPUT);
|
2011-11-03 16:59:50 +04:00
|
|
|
cmd = launcher + this->ConvertShellCommand(cmd, NONE);
|
2010-12-08 00:23:38 +03:00
|
|
|
|
|
|
|
ccg.AppendArguments(c, cmd);
|
2009-02-02 21:28:12 +03:00
|
|
|
if(content)
|
|
|
|
{
|
2009-02-10 16:51:15 +03:00
|
|
|
// Rule content does not include the launcher.
|
|
|
|
*content << (cmd.c_str()+launcher.size());
|
2009-02-02 21:28:12 +03:00
|
|
|
}
|
2007-05-17 18:53:18 +04:00
|
|
|
if(this->BorlandMakeCurlyHack)
|
|
|
|
{
|
|
|
|
// Borland Make has a very strange bug. If the first curly
|
|
|
|
// brace anywhere in the command string is a left curly, it
|
|
|
|
// must be written {{} instead of just {. Otherwise some
|
|
|
|
// curly braces are removed. The hack can be skipped if the
|
|
|
|
// first curly brace is the last character.
|
|
|
|
std::string::size_type lcurly = cmd.find("{");
|
|
|
|
if(lcurly != cmd.npos && lcurly < (cmd.size()-1))
|
|
|
|
{
|
|
|
|
std::string::size_type rcurly = cmd.find("}");
|
|
|
|
if(rcurly == cmd.npos || rcurly > lcurly)
|
|
|
|
{
|
|
|
|
// The first curly is a left curly. Use the hack.
|
|
|
|
std::string hack_cmd = cmd.substr(0, lcurly);
|
|
|
|
hack_cmd += "{{}";
|
|
|
|
hack_cmd += cmd.substr(lcurly+1);
|
|
|
|
cmd = hack_cmd;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2010-09-11 00:17:39 +04:00
|
|
|
if (launcher.empty())
|
2010-06-03 21:43:39 +04:00
|
|
|
{
|
2010-09-11 00:17:39 +04:00
|
|
|
if (useCall)
|
|
|
|
{
|
|
|
|
cmd = "call " + cmd;
|
|
|
|
}
|
|
|
|
else if (this->NMake && cmd[0]=='"')
|
|
|
|
{
|
|
|
|
cmd = "echo >nul && " + cmd;
|
|
|
|
}
|
2010-06-03 21:43:39 +04:00
|
|
|
}
|
2005-05-20 20:09:33 +04:00
|
|
|
commands1.push_back(cmd);
|
2005-05-05 20:45:53 +04:00
|
|
|
}
|
2005-05-20 19:01:21 +04:00
|
|
|
}
|
|
|
|
|
2006-06-26 23:27:51 +04:00
|
|
|
// Setup the proper working directory for the commands.
|
2008-10-09 23:30:07 +04:00
|
|
|
this->CreateCDCommand(commands1, dir, relative);
|
2006-02-15 18:34:11 +03:00
|
|
|
|
2006-06-26 23:27:51 +04:00
|
|
|
// push back the custom commands
|
2005-10-19 18:03:20 +04:00
|
|
|
commands.insert(commands.end(), commands1.begin(), commands1.end());
|
2005-05-05 20:45:53 +04:00
|
|
|
}
|
|
|
|
|
2009-02-10 16:51:15 +03:00
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
std::string
|
|
|
|
cmLocalUnixMakefileGenerator3::MakeLauncher(const cmCustomCommand& cc,
|
|
|
|
cmTarget* target,
|
|
|
|
RelativeRoot relative)
|
|
|
|
{
|
|
|
|
// Short-circuit if there is no launcher.
|
|
|
|
const char* prop = "RULE_LAUNCH_CUSTOM";
|
|
|
|
const char* val = this->GetRuleLauncher(target, prop);
|
|
|
|
if(!(val && *val))
|
|
|
|
{
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
|
|
|
// Expand rules in the empty string. It may insert the launcher and
|
|
|
|
// perform replacements.
|
|
|
|
RuleVariables vars;
|
|
|
|
vars.RuleLauncher = prop;
|
|
|
|
vars.CMTarget = target;
|
2009-02-10 16:52:07 +03:00
|
|
|
std::string output;
|
|
|
|
const std::vector<std::string>& outputs = cc.GetOutputs();
|
|
|
|
if(!outputs.empty())
|
|
|
|
{
|
|
|
|
output = this->Convert(outputs[0].c_str(), relative, SHELL);
|
|
|
|
}
|
|
|
|
vars.Output = output.c_str();
|
2009-02-10 16:51:15 +03:00
|
|
|
|
|
|
|
std::string launcher;
|
|
|
|
this->ExpandRuleVariables(launcher, vars);
|
|
|
|
if(!launcher.empty())
|
|
|
|
{
|
|
|
|
launcher += " ";
|
|
|
|
}
|
|
|
|
return launcher;
|
|
|
|
}
|
|
|
|
|
2005-05-05 20:45:53 +04:00
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
void
|
|
|
|
cmLocalUnixMakefileGenerator3
|
|
|
|
::AppendCleanCommand(std::vector<std::string>& commands,
|
2006-03-09 22:30:35 +03:00
|
|
|
const std::vector<std::string>& files,
|
|
|
|
cmTarget& target, const char* filename)
|
2005-05-05 20:45:53 +04:00
|
|
|
{
|
2013-10-16 17:52:37 +04:00
|
|
|
std::string cleanfile = this->Makefile->GetCurrentOutputDirectory();
|
|
|
|
cleanfile += "/";
|
|
|
|
cleanfile += this->GetTargetDirectory(target);
|
|
|
|
cleanfile += "/cmake_clean";
|
|
|
|
if(filename)
|
|
|
|
{
|
|
|
|
cleanfile += "_";
|
|
|
|
cleanfile += filename;
|
|
|
|
}
|
|
|
|
cleanfile += ".cmake";
|
|
|
|
std::string cleanfilePath = this->Convert(cleanfile.c_str(), FULL);
|
|
|
|
std::ofstream fout(cleanfilePath.c_str());
|
|
|
|
if(!fout)
|
|
|
|
{
|
|
|
|
cmSystemTools::Error("Could not create ", cleanfilePath.c_str());
|
|
|
|
}
|
2005-05-05 20:45:53 +04:00
|
|
|
if(!files.empty())
|
|
|
|
{
|
2013-08-22 13:30:19 +04:00
|
|
|
fout << "file(REMOVE_RECURSE\n";
|
2005-05-05 20:45:53 +04:00
|
|
|
for(std::vector<std::string>::const_iterator f = files.begin();
|
|
|
|
f != files.end(); ++f)
|
|
|
|
{
|
2008-05-11 02:39:06 +04:00
|
|
|
std::string fc = this->Convert(f->c_str(),START_OUTPUT,UNCHANGED);
|
|
|
|
fout << " " << this->EscapeForCMake(fc.c_str()) << "\n";
|
2005-05-05 20:45:53 +04:00
|
|
|
}
|
2006-03-09 22:30:35 +03:00
|
|
|
fout << ")\n";
|
2013-10-16 17:52:37 +04:00
|
|
|
}
|
|
|
|
std::string remove = "$(CMAKE_COMMAND) -P ";
|
|
|
|
remove += this->Convert(cleanfile.c_str(), START_OUTPUT, SHELL);
|
|
|
|
commands.push_back(remove);
|
2007-12-28 19:50:14 +03:00
|
|
|
|
2013-10-16 17:52:37 +04:00
|
|
|
// For the main clean rule add per-language cleaning.
|
|
|
|
if(!filename)
|
|
|
|
{
|
|
|
|
// Get the set of source languages in the target.
|
|
|
|
std::set<cmStdString> languages;
|
|
|
|
target.GetLanguages(languages);
|
|
|
|
fout << "\n"
|
|
|
|
<< "# Per-language clean rules from dependency scanning.\n"
|
|
|
|
<< "foreach(lang";
|
|
|
|
for(std::set<cmStdString>::const_iterator l = languages.begin();
|
|
|
|
l != languages.end(); ++l)
|
2007-12-28 19:50:14 +03:00
|
|
|
{
|
2013-10-16 17:52:37 +04:00
|
|
|
fout << " " << *l;
|
2007-12-28 19:50:14 +03:00
|
|
|
}
|
2013-10-16 17:52:37 +04:00
|
|
|
fout << ")\n"
|
|
|
|
<< " include(" << this->GetTargetDirectory(target)
|
|
|
|
<< "/cmake_clean_${lang}.cmake OPTIONAL)\n"
|
|
|
|
<< "endforeach()\n";
|
2005-05-05 20:45:53 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
void
|
|
|
|
cmLocalUnixMakefileGenerator3::AppendEcho(std::vector<std::string>& commands,
|
2006-03-31 00:39:03 +04:00
|
|
|
const char* text,
|
|
|
|
EchoColor color)
|
2005-05-05 20:45:53 +04:00
|
|
|
{
|
2006-03-31 00:39:03 +04:00
|
|
|
// Choose the color for the text.
|
2006-04-27 05:31:39 +04:00
|
|
|
std::string color_name;
|
2006-04-27 05:53:21 +04:00
|
|
|
#ifdef CMAKE_BUILD_WITH_CMAKE
|
2006-05-25 22:16:19 +04:00
|
|
|
if(this->GlobalGenerator->GetToolSupportsColor() && this->ColorMakefile)
|
2006-03-31 00:39:03 +04:00
|
|
|
{
|
2006-04-27 05:31:39 +04:00
|
|
|
// See cmake::ExecuteEchoColor in cmake.cxx for these options.
|
|
|
|
// This color set is readable on both black and white backgrounds.
|
2006-03-31 00:39:03 +04:00
|
|
|
switch(color)
|
|
|
|
{
|
|
|
|
case EchoNormal:
|
|
|
|
break;
|
|
|
|
case EchoDepend:
|
2006-04-27 05:31:39 +04:00
|
|
|
color_name = "--magenta --bold ";
|
2006-03-31 00:39:03 +04:00
|
|
|
break;
|
|
|
|
case EchoBuild:
|
2006-04-27 05:31:39 +04:00
|
|
|
color_name = "--green ";
|
2006-03-31 00:39:03 +04:00
|
|
|
break;
|
|
|
|
case EchoLink:
|
2006-04-27 05:31:39 +04:00
|
|
|
color_name = "--red --bold ";
|
2006-03-31 00:39:03 +04:00
|
|
|
break;
|
|
|
|
case EchoGenerate:
|
2006-04-27 05:31:39 +04:00
|
|
|
color_name = "--blue --bold ";
|
2006-03-31 00:39:03 +04:00
|
|
|
break;
|
|
|
|
case EchoGlobal:
|
2006-04-27 05:31:39 +04:00
|
|
|
color_name = "--cyan ";
|
2006-03-31 00:39:03 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2006-05-15 21:02:28 +04:00
|
|
|
#else
|
|
|
|
(void)color;
|
2006-04-27 05:53:21 +04:00
|
|
|
#endif
|
2006-03-31 00:39:03 +04:00
|
|
|
|
2005-05-05 20:45:53 +04:00
|
|
|
// Echo one line at a time.
|
|
|
|
std::string line;
|
2006-04-11 20:51:20 +04:00
|
|
|
line.reserve(200);
|
2005-05-05 20:45:53 +04:00
|
|
|
for(const char* c = text;; ++c)
|
|
|
|
{
|
|
|
|
if(*c == '\n' || *c == '\0')
|
|
|
|
{
|
|
|
|
// Avoid writing a blank last line on end-of-string.
|
|
|
|
if(*c != '\0' || !line.empty())
|
|
|
|
{
|
|
|
|
// Add a command to echo this line.
|
2006-04-27 05:31:39 +04:00
|
|
|
std::string cmd;
|
|
|
|
if(color_name.empty())
|
2005-05-05 20:45:53 +04:00
|
|
|
{
|
2006-04-27 05:31:39 +04:00
|
|
|
// Use the native echo command.
|
2011-06-16 23:43:17 +04:00
|
|
|
cmd = "@echo ";
|
|
|
|
cmd += this->EscapeForShell(line.c_str(), false, true);
|
2005-05-05 20:45:53 +04:00
|
|
|
}
|
2006-04-27 05:31:39 +04:00
|
|
|
else
|
2005-05-05 20:45:53 +04:00
|
|
|
{
|
2006-04-27 05:31:39 +04:00
|
|
|
// Use cmake to echo the text in color.
|
|
|
|
cmd = "@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) ";
|
|
|
|
cmd += color_name;
|
2006-10-05 02:52:29 +04:00
|
|
|
cmd += this->EscapeForShell(line.c_str());
|
2005-05-05 20:45:53 +04:00
|
|
|
}
|
|
|
|
commands.push_back(cmd);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Reset the line to emtpy.
|
|
|
|
line = "";
|
|
|
|
|
|
|
|
// Terminate on end-of-string.
|
|
|
|
if(*c == '\0')
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if(*c != '\r')
|
|
|
|
{
|
|
|
|
// Append this character to the current line.
|
|
|
|
line += *c;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
std::string
|
|
|
|
cmLocalUnixMakefileGenerator3
|
|
|
|
::CreateMakeVariable(const char* sin, const char* s2in)
|
|
|
|
{
|
|
|
|
std::string s = sin;
|
|
|
|
std::string s2 = s2in;
|
|
|
|
std::string unmodified = s;
|
|
|
|
unmodified += s2;
|
|
|
|
// if there is no restriction on the length of make variables
|
2012-11-07 20:13:09 +04:00
|
|
|
// and there are no "." characters in the string, then return the
|
2005-05-05 20:45:53 +04:00
|
|
|
// unmodified combination.
|
2006-03-15 19:02:08 +03:00
|
|
|
if((!this->MakefileVariableSize && unmodified.find('.') == s.npos)
|
2011-08-25 00:08:31 +04:00
|
|
|
&& (!this->MakefileVariableSize && unmodified.find('+') == s.npos)
|
2006-03-15 19:02:08 +03:00
|
|
|
&& (!this->MakefileVariableSize && unmodified.find('-') == s.npos))
|
2005-05-05 20:45:53 +04:00
|
|
|
{
|
|
|
|
return unmodified;
|
|
|
|
}
|
|
|
|
|
|
|
|
// see if the variable has been defined before and return
|
|
|
|
// the modified version of the variable
|
2010-11-12 00:02:07 +03:00
|
|
|
std::map<cmStdString, cmStdString>::iterator i =
|
2006-05-15 18:19:57 +04:00
|
|
|
this->MakeVariableMap.find(unmodified);
|
2006-03-15 19:02:08 +03:00
|
|
|
if(i != this->MakeVariableMap.end())
|
2005-05-05 20:45:53 +04:00
|
|
|
{
|
|
|
|
return i->second;
|
|
|
|
}
|
|
|
|
// start with the unmodified variable
|
|
|
|
std::string ret = unmodified;
|
2006-03-15 19:02:08 +03:00
|
|
|
// if this there is no value for this->MakefileVariableSize then
|
2005-05-05 20:45:53 +04:00
|
|
|
// the string must have bad characters in it
|
2006-03-15 19:02:08 +03:00
|
|
|
if(!this->MakefileVariableSize)
|
2005-05-05 20:45:53 +04:00
|
|
|
{
|
|
|
|
cmSystemTools::ReplaceString(ret, ".", "_");
|
2006-02-07 00:32:09 +03:00
|
|
|
cmSystemTools::ReplaceString(ret, "-", "__");
|
2011-08-25 00:08:31 +04:00
|
|
|
cmSystemTools::ReplaceString(ret, "+", "___");
|
2005-05-05 20:45:53 +04:00
|
|
|
int ni = 0;
|
|
|
|
char buffer[5];
|
|
|
|
// make sure the _ version is not already used, if
|
|
|
|
// it is used then add number to the end of the variable
|
2006-03-15 19:02:08 +03:00
|
|
|
while(this->ShortMakeVariableMap.count(ret) && ni < 1000)
|
2005-05-05 20:45:53 +04:00
|
|
|
{
|
|
|
|
++ni;
|
|
|
|
sprintf(buffer, "%04d", ni);
|
|
|
|
ret = unmodified + buffer;
|
|
|
|
}
|
2006-03-15 19:02:08 +03:00
|
|
|
this->ShortMakeVariableMap[ret] = "1";
|
|
|
|
this->MakeVariableMap[unmodified] = ret;
|
2005-05-05 20:45:53 +04:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-11-07 20:13:09 +04:00
|
|
|
// if the string is greater than 32 chars it is an invalid variable name
|
2005-05-05 20:45:53 +04:00
|
|
|
// for borland make
|
2006-03-15 19:02:08 +03:00
|
|
|
if(static_cast<int>(ret.size()) > this->MakefileVariableSize)
|
2005-05-05 20:45:53 +04:00
|
|
|
{
|
2006-03-15 19:02:08 +03:00
|
|
|
int keep = this->MakefileVariableSize - 8;
|
2005-05-05 20:45:53 +04:00
|
|
|
int size = keep + 3;
|
|
|
|
std::string str1 = s;
|
|
|
|
std::string str2 = s2;
|
2012-11-07 20:13:09 +04:00
|
|
|
// we must shorten the combined string by 4 characters
|
|
|
|
// keep no more than 24 characters from the second string
|
2005-05-05 20:45:53 +04:00
|
|
|
if(static_cast<int>(str2.size()) > keep)
|
|
|
|
{
|
|
|
|
str2 = str2.substr(0, keep);
|
|
|
|
}
|
|
|
|
if(static_cast<int>(str1.size()) + static_cast<int>(str2.size()) > size)
|
|
|
|
{
|
|
|
|
str1 = str1.substr(0, size - str2.size());
|
|
|
|
}
|
|
|
|
char buffer[5];
|
|
|
|
int ni = 0;
|
|
|
|
sprintf(buffer, "%04d", ni);
|
|
|
|
ret = str1 + str2 + buffer;
|
2006-03-15 19:02:08 +03:00
|
|
|
while(this->ShortMakeVariableMap.count(ret) && ni < 1000)
|
2005-05-05 20:45:53 +04:00
|
|
|
{
|
|
|
|
++ni;
|
|
|
|
sprintf(buffer, "%04d", ni);
|
|
|
|
ret = str1 + str2 + buffer;
|
|
|
|
}
|
|
|
|
if(ni == 1000)
|
|
|
|
{
|
|
|
|
cmSystemTools::Error("Borland makefile variable length too long");
|
|
|
|
return unmodified;
|
|
|
|
}
|
|
|
|
// once an unused variable is found
|
2006-03-15 19:02:08 +03:00
|
|
|
this->ShortMakeVariableMap[ret] = "1";
|
2005-05-05 20:45:53 +04:00
|
|
|
}
|
|
|
|
// always make an entry into the unmodified to variable map
|
2006-03-15 19:02:08 +03:00
|
|
|
this->MakeVariableMap[unmodified] = ret;
|
2005-05-05 20:45:53 +04:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-12-20 00:36:30 +03:00
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
bool cmLocalUnixMakefileGenerator3::UpdateDependencies(const char* tgtInfo,
|
2007-12-20 01:15:41 +03:00
|
|
|
bool verbose,
|
|
|
|
bool color)
|
2007-12-20 00:36:30 +03:00
|
|
|
{
|
2007-12-21 20:22:12 +03:00
|
|
|
// read in the target info file
|
|
|
|
if(!this->Makefile->ReadListFile(0, tgtInfo) ||
|
|
|
|
cmSystemTools::GetErrorOccuredFlag())
|
|
|
|
{
|
|
|
|
cmSystemTools::Error("Target DependInfo.cmake file not found");
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check if any multiple output pairs have a missing file.
|
|
|
|
this->CheckMultipleOutputs(verbose);
|
|
|
|
|
2007-12-20 00:36:30 +03:00
|
|
|
std::string dir = cmSystemTools::GetFilenamePath(tgtInfo);
|
|
|
|
std::string internalDependFile = dir + "/depend.internal";
|
|
|
|
std::string dependFile = dir + "/depend.make";
|
|
|
|
|
2008-03-12 00:53:54 +03:00
|
|
|
// If the target DependInfo.cmake file has changed since the last
|
|
|
|
// time dependencies were scanned then force rescanning. This may
|
|
|
|
// happen when a new source file is added and CMake regenerates the
|
|
|
|
// project but no other sources were touched.
|
2009-09-22 22:40:23 +04:00
|
|
|
bool needRescanDependInfo = false;
|
2008-03-12 00:53:54 +03:00
|
|
|
cmFileTimeComparison* ftc =
|
|
|
|
this->GlobalGenerator->GetCMakeInstance()->GetFileComparison();
|
|
|
|
{
|
|
|
|
int result;
|
|
|
|
if(!ftc->FileTimeCompare(internalDependFile.c_str(), tgtInfo, &result) ||
|
|
|
|
result < 0)
|
|
|
|
{
|
|
|
|
if(verbose)
|
|
|
|
{
|
|
|
|
cmOStringStream msg;
|
|
|
|
msg << "Dependee \"" << tgtInfo
|
|
|
|
<< "\" is newer than depender \""
|
|
|
|
<< internalDependFile << "\"." << std::endl;
|
|
|
|
cmSystemTools::Stdout(msg.str().c_str());
|
|
|
|
}
|
2009-09-22 22:40:23 +04:00
|
|
|
needRescanDependInfo = true;
|
2008-03-12 00:53:54 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-09-22 22:40:23 +04:00
|
|
|
// If the directory information is newer than depend.internal, include dirs
|
|
|
|
// may have changed. In this case discard all old dependencies.
|
|
|
|
bool needRescanDirInfo = false;
|
|
|
|
std::string dirInfoFile = this->Makefile->GetStartOutputDirectory();
|
|
|
|
dirInfoFile += cmake::GetCMakeFilesDirectory();
|
|
|
|
dirInfoFile += "/CMakeDirectoryInformation.cmake";
|
|
|
|
{
|
|
|
|
int result;
|
2010-11-12 00:02:07 +03:00
|
|
|
if(!ftc->FileTimeCompare(internalDependFile.c_str(),
|
2009-09-22 22:40:23 +04:00
|
|
|
dirInfoFile.c_str(), &result) || result < 0)
|
|
|
|
{
|
|
|
|
if(verbose)
|
|
|
|
{
|
|
|
|
cmOStringStream msg;
|
2009-09-23 22:02:05 +04:00
|
|
|
msg << "Dependee \"" << dirInfoFile
|
2009-09-22 22:40:23 +04:00
|
|
|
<< "\" is newer than depender \""
|
2009-09-23 22:02:05 +04:00
|
|
|
<< internalDependFile << "\"." << std::endl;
|
2009-09-22 22:40:23 +04:00
|
|
|
cmSystemTools::Stdout(msg.str().c_str());
|
|
|
|
}
|
|
|
|
needRescanDirInfo = true;
|
|
|
|
}
|
|
|
|
}
|
2010-11-12 00:02:07 +03:00
|
|
|
|
2007-12-20 00:36:30 +03:00
|
|
|
// Check the implicit dependencies to see if they are up to date.
|
|
|
|
// The build.make file may have explicit dependencies for the object
|
|
|
|
// files but these will not affect the scanning process so they need
|
|
|
|
// not be considered.
|
2009-09-23 22:02:05 +04:00
|
|
|
std::map<std::string, cmDepends::DependencyVector> validDependencies;
|
2009-09-22 22:40:23 +04:00
|
|
|
bool needRescanDependencies = false;
|
|
|
|
if (needRescanDirInfo == false)
|
|
|
|
{
|
|
|
|
cmDependsC checker;
|
|
|
|
checker.SetVerbose(verbose);
|
|
|
|
checker.SetFileComparison(ftc);
|
2009-09-23 22:02:05 +04:00
|
|
|
// cmDependsC::Check() fills the vector validDependencies() with the
|
|
|
|
// dependencies for those files where they are still valid, i.e. neither
|
|
|
|
// the files themselves nor any files they depend on have changed.
|
2010-11-12 00:02:07 +03:00
|
|
|
// We don't do that if the CMakeDirectoryInformation.cmake file has
|
2009-09-23 22:02:05 +04:00
|
|
|
// changed, because then potentially all dependencies have changed.
|
|
|
|
// This information is given later on to cmDependsC, which then only
|
|
|
|
// rescans the files where it did not get valid dependencies via this
|
2010-11-12 00:02:07 +03:00
|
|
|
// dependency vector. This means that in the normal case, when only
|
2009-09-23 22:02:05 +04:00
|
|
|
// few or one file have been edited, then also only this one file is
|
|
|
|
// actually scanned again, instead of all files for this target.
|
2009-09-22 22:40:23 +04:00
|
|
|
needRescanDependencies = !checker.Check(dependFile.c_str(),
|
2009-09-23 22:02:05 +04:00
|
|
|
internalDependFile.c_str(),
|
|
|
|
validDependencies);
|
2009-09-22 22:40:23 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
if(needRescanDependInfo || needRescanDirInfo || needRescanDependencies)
|
2007-12-20 00:36:30 +03:00
|
|
|
{
|
|
|
|
// The dependencies must be regenerated.
|
|
|
|
std::string targetName = cmSystemTools::GetFilenameName(dir);
|
|
|
|
targetName = targetName.substr(0, targetName.length()-4);
|
2007-12-20 01:15:41 +03:00
|
|
|
std::string message = "Scanning dependencies of target ";
|
|
|
|
message += targetName;
|
|
|
|
#ifdef CMAKE_BUILD_WITH_CMAKE
|
|
|
|
cmSystemTools::MakefileColorEcho(
|
|
|
|
cmsysTerminal_Color_ForegroundMagenta |
|
|
|
|
cmsysTerminal_Color_ForegroundBold,
|
|
|
|
message.c_str(), true, color);
|
|
|
|
#else
|
|
|
|
fprintf(stdout, "%s\n", message.c_str());
|
|
|
|
#endif
|
2007-12-20 00:36:30 +03:00
|
|
|
|
2009-09-23 22:02:05 +04:00
|
|
|
return this->ScanDependencies(dir.c_str(), validDependencies);
|
2007-12-20 00:36:30 +03:00
|
|
|
}
|
2009-09-30 19:46:42 +04:00
|
|
|
|
|
|
|
// The dependencies are already up-to-date.
|
|
|
|
return true;
|
2007-12-20 00:36:30 +03:00
|
|
|
}
|
|
|
|
|
2005-05-05 20:45:53 +04:00
|
|
|
//----------------------------------------------------------------------------
|
2007-12-21 20:22:12 +03:00
|
|
|
bool
|
|
|
|
cmLocalUnixMakefileGenerator3
|
2009-09-23 22:02:05 +04:00
|
|
|
::ScanDependencies(const char* targetDir,
|
|
|
|
std::map<std::string, cmDepends::DependencyVector>& validDeps)
|
2005-05-05 20:45:53 +04:00
|
|
|
{
|
|
|
|
// Read the directory information file.
|
2006-05-25 17:47:30 +04:00
|
|
|
cmMakefile* mf = this->Makefile;
|
2005-05-05 20:45:53 +04:00
|
|
|
bool haveDirectoryInfo = false;
|
2006-05-25 17:47:30 +04:00
|
|
|
std::string dirInfoFile = this->Makefile->GetStartOutputDirectory();
|
2006-06-14 20:28:32 +04:00
|
|
|
dirInfoFile += cmake::GetCMakeFilesDirectory();
|
|
|
|
dirInfoFile += "/CMakeDirectoryInformation.cmake";
|
2005-06-07 18:47:28 +04:00
|
|
|
if(mf->ReadListFile(0, dirInfoFile.c_str()) &&
|
2005-05-05 20:45:53 +04:00
|
|
|
!cmSystemTools::GetErrorOccuredFlag())
|
|
|
|
{
|
|
|
|
haveDirectoryInfo = true;
|
|
|
|
}
|
2010-11-12 00:02:07 +03:00
|
|
|
|
2007-03-16 23:48:27 +03:00
|
|
|
// Lookup useful directory information.
|
2005-05-05 20:45:53 +04:00
|
|
|
if(haveDirectoryInfo)
|
|
|
|
{
|
2007-03-16 23:48:27 +03:00
|
|
|
// Test whether we need to force Unix paths.
|
2005-05-05 20:45:53 +04:00
|
|
|
if(const char* force = mf->GetDefinition("CMAKE_FORCE_UNIX_PATHS"))
|
|
|
|
{
|
|
|
|
if(!cmSystemTools::IsOff(force))
|
|
|
|
{
|
|
|
|
cmSystemTools::SetForceUnixPaths(true);
|
|
|
|
}
|
|
|
|
}
|
2007-03-16 23:48:27 +03:00
|
|
|
|
|
|
|
// Setup relative path top directories.
|
|
|
|
this->RelativePathsConfigured = true;
|
|
|
|
if(const char* relativePathTopSource =
|
|
|
|
mf->GetDefinition("CMAKE_RELATIVE_PATH_TOP_SOURCE"))
|
|
|
|
{
|
|
|
|
this->RelativePathTopSource = relativePathTopSource;
|
|
|
|
}
|
|
|
|
if(const char* relativePathTopBinary =
|
|
|
|
mf->GetDefinition("CMAKE_RELATIVE_PATH_TOP_BINARY"))
|
|
|
|
{
|
|
|
|
this->RelativePathTopBinary = relativePathTopBinary;
|
|
|
|
}
|
2005-05-05 20:45:53 +04:00
|
|
|
}
|
2005-06-07 18:47:28 +04:00
|
|
|
else
|
|
|
|
{
|
|
|
|
cmSystemTools::Error("Directory Information file not found");
|
|
|
|
}
|
2005-05-05 20:45:53 +04:00
|
|
|
|
2005-07-27 17:49:37 +04:00
|
|
|
// create the file stream for the depends file
|
2007-12-21 20:22:12 +03:00
|
|
|
std::string dir = targetDir;
|
2008-05-08 01:25:05 +04:00
|
|
|
|
|
|
|
// Open the make depends file. This should be copy-if-different
|
|
|
|
// because the make tool may try to reload it needlessly otherwise.
|
2005-07-27 17:49:37 +04:00
|
|
|
std::string ruleFileNameFull = dir;
|
2005-10-12 21:52:29 +04:00
|
|
|
ruleFileNameFull += "/depend.make";
|
2005-07-27 17:49:37 +04:00
|
|
|
cmGeneratedFileStream ruleFileStream(ruleFileNameFull.c_str());
|
|
|
|
ruleFileStream.SetCopyIfDifferent(true);
|
|
|
|
if(!ruleFileStream)
|
2005-05-05 20:45:53 +04:00
|
|
|
{
|
2005-07-27 17:49:37 +04:00
|
|
|
return false;
|
|
|
|
}
|
2008-05-08 01:25:05 +04:00
|
|
|
|
|
|
|
// Open the cmake dependency tracking file. This should not be
|
|
|
|
// copy-if-different because dependencies are re-scanned when it is
|
|
|
|
// older than the DependInfo.cmake.
|
2005-10-12 21:52:29 +04:00
|
|
|
std::string internalRuleFileNameFull = dir;
|
|
|
|
internalRuleFileNameFull += "/depend.internal";
|
2008-05-08 01:25:05 +04:00
|
|
|
cmGeneratedFileStream
|
2006-05-15 18:19:57 +04:00
|
|
|
internalRuleFileStream(internalRuleFileNameFull.c_str());
|
2005-10-12 21:52:29 +04:00
|
|
|
if(!internalRuleFileStream)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2005-07-27 17:49:37 +04:00
|
|
|
this->WriteDisclaimer(ruleFileStream);
|
2005-10-12 21:52:29 +04:00
|
|
|
this->WriteDisclaimer(internalRuleFileStream);
|
2005-08-17 19:43:58 +04:00
|
|
|
|
2010-11-12 00:02:07 +03:00
|
|
|
// for each language we need to scan, scan it
|
2005-07-27 17:49:37 +04:00
|
|
|
const char *langStr = mf->GetSafeDefinition("CMAKE_DEPENDS_LANGUAGES");
|
|
|
|
std::vector<std::string> langs;
|
|
|
|
cmSystemTools::ExpandListArgument(langStr, langs);
|
2010-11-12 00:02:07 +03:00
|
|
|
for (std::vector<std::string>::iterator li =
|
2005-07-27 17:49:37 +04:00
|
|
|
langs.begin(); li != langs.end(); ++li)
|
|
|
|
{
|
|
|
|
// construct the checker
|
|
|
|
std::string lang = li->c_str();
|
2005-08-17 19:43:58 +04:00
|
|
|
|
2005-07-27 17:49:37 +04:00
|
|
|
// Create the scanner for this language
|
|
|
|
cmDepends *scanner = 0;
|
2011-10-05 23:51:35 +04:00
|
|
|
if(lang == "C" || lang == "CXX" || lang == "RC" || lang == "ASM")
|
2005-05-05 20:45:53 +04:00
|
|
|
{
|
2005-07-27 17:49:37 +04:00
|
|
|
// TODO: Handle RC (resource files) dependencies correctly.
|
2009-09-23 22:02:05 +04:00
|
|
|
scanner = new cmDependsC(this, targetDir, lang.c_str(), &validDeps);
|
2005-05-05 20:45:53 +04:00
|
|
|
}
|
|
|
|
#ifdef CMAKE_BUILD_WITH_CMAKE
|
2005-07-27 17:49:37 +04:00
|
|
|
else if(lang == "Fortran")
|
|
|
|
{
|
2008-05-08 18:09:14 +04:00
|
|
|
scanner = new cmDependsFortran(this);
|
2005-07-27 17:49:37 +04:00
|
|
|
}
|
|
|
|
else if(lang == "Java")
|
|
|
|
{
|
|
|
|
scanner = new cmDependsJava();
|
|
|
|
}
|
2005-05-05 20:45:53 +04:00
|
|
|
#endif
|
2010-11-12 00:02:07 +03:00
|
|
|
|
2005-07-27 17:49:37 +04:00
|
|
|
if (scanner)
|
|
|
|
{
|
2007-10-12 17:32:48 +04:00
|
|
|
scanner->SetLocalGenerator(this);
|
2006-05-15 18:19:57 +04:00
|
|
|
scanner->SetFileComparison
|
|
|
|
(this->GlobalGenerator->GetCMakeInstance()->GetFileComparison());
|
2007-12-23 06:41:42 +03:00
|
|
|
scanner->SetLanguage(lang.c_str());
|
|
|
|
scanner->SetTargetDirectory(dir.c_str());
|
|
|
|
scanner->Write(ruleFileStream, internalRuleFileStream);
|
2005-08-19 18:13:04 +04:00
|
|
|
|
|
|
|
// free the scanner for this language
|
2005-07-27 17:49:37 +04:00
|
|
|
delete scanner;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
2005-05-05 20:45:53 +04:00
|
|
|
}
|
|
|
|
|
2007-12-21 20:22:12 +03:00
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
void cmLocalUnixMakefileGenerator3::CheckMultipleOutputs(bool verbose)
|
|
|
|
{
|
|
|
|
cmMakefile* mf = this->Makefile;
|
|
|
|
|
|
|
|
// Get the string listing the multiple output pairs.
|
|
|
|
const char* pairs_string = mf->GetDefinition("CMAKE_MULTIPLE_OUTPUT_PAIRS");
|
|
|
|
if(!pairs_string)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Convert the string to a list and preserve empty entries.
|
|
|
|
std::vector<std::string> pairs;
|
|
|
|
cmSystemTools::ExpandListArgument(pairs_string, pairs, true);
|
|
|
|
for(std::vector<std::string>::const_iterator i = pairs.begin();
|
2008-05-11 02:39:00 +04:00
|
|
|
i != pairs.end() && (i+1) != pairs.end();)
|
2007-12-21 20:22:12 +03:00
|
|
|
{
|
2008-05-11 02:39:00 +04:00
|
|
|
const std::string& depender = *i++;
|
|
|
|
const std::string& dependee = *i++;
|
2007-12-21 20:22:12 +03:00
|
|
|
|
2008-05-11 02:39:00 +04:00
|
|
|
// If the depender is missing then delete the dependee to make
|
|
|
|
// sure both will be regenerated.
|
|
|
|
if(cmSystemTools::FileExists(dependee.c_str()) &&
|
|
|
|
!cmSystemTools::FileExists(depender.c_str()))
|
|
|
|
{
|
|
|
|
if(verbose)
|
2007-12-21 20:22:12 +03:00
|
|
|
{
|
2008-05-11 02:39:00 +04:00
|
|
|
cmOStringStream msg;
|
|
|
|
msg << "Deleting primary custom command output \"" << dependee
|
|
|
|
<< "\" because another output \""
|
|
|
|
<< depender << "\" does not exist." << std::endl;
|
|
|
|
cmSystemTools::Stdout(msg.str().c_str());
|
2007-12-21 20:22:12 +03:00
|
|
|
}
|
2008-05-11 02:39:00 +04:00
|
|
|
cmSystemTools::RemoveFile(dependee.c_str());
|
2007-12-21 20:22:12 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-05-11 16:45:16 +04:00
|
|
|
//----------------------------------------------------------------------------
|
2005-10-20 21:40:28 +04:00
|
|
|
void cmLocalUnixMakefileGenerator3
|
|
|
|
::WriteLocalAllRules(std::ostream& ruleFileStream)
|
2005-05-11 16:45:16 +04:00
|
|
|
{
|
|
|
|
this->WriteDisclaimer(ruleFileStream);
|
2006-02-16 00:35:16 +03:00
|
|
|
|
|
|
|
// 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.
|
|
|
|
this->WriteMakeRule(ruleFileStream,
|
|
|
|
"Default target executed when no arguments are "
|
|
|
|
"given to make.",
|
|
|
|
"default_target",
|
|
|
|
depends,
|
|
|
|
no_commands, true);
|
|
|
|
}
|
|
|
|
|
2006-09-08 18:42:14 +04:00
|
|
|
this->WriteSpecialTargetsTop(ruleFileStream);
|
|
|
|
|
|
|
|
// Include the progress variables for the target.
|
2006-02-23 18:07:24 +03:00
|
|
|
// Write all global targets
|
2006-09-08 18:42:14 +04:00
|
|
|
this->WriteDivider(ruleFileStream);
|
|
|
|
ruleFileStream
|
|
|
|
<< "# Targets provided globally by CMake.\n"
|
|
|
|
<< "\n";
|
2006-03-15 19:02:08 +03:00
|
|
|
cmTargets* targets = &(this->Makefile->GetTargets());
|
2006-02-23 18:07:24 +03:00
|
|
|
cmTargets::iterator glIt;
|
|
|
|
for ( glIt = targets->begin(); glIt != targets->end(); ++ glIt )
|
2006-02-16 00:35:16 +03:00
|
|
|
{
|
2006-02-23 18:07:24 +03:00
|
|
|
if ( glIt->second.GetType() == cmTarget::GLOBAL_TARGET )
|
2006-02-16 00:35:16 +03:00
|
|
|
{
|
2006-02-23 18:07:24 +03:00
|
|
|
std::string targetString = "Special rule for the target " + glIt->first;
|
|
|
|
std::vector<std::string> commands;
|
|
|
|
std::vector<std::string> depends;
|
|
|
|
|
|
|
|
const char* text = glIt->second.GetProperty("EchoString");
|
|
|
|
if ( !text )
|
|
|
|
{
|
|
|
|
text = "Running external command ...";
|
|
|
|
}
|
2006-02-24 02:25:07 +03:00
|
|
|
std::set<cmStdString>::const_iterator dit;
|
2006-02-24 01:30:12 +03:00
|
|
|
for ( dit = glIt->second.GetUtilities().begin();
|
|
|
|
dit != glIt->second.GetUtilities().end();
|
|
|
|
++ dit )
|
2006-02-23 18:07:24 +03:00
|
|
|
{
|
2006-02-24 01:30:12 +03:00
|
|
|
depends.push_back(dit->c_str());
|
2006-02-23 18:07:24 +03:00
|
|
|
}
|
2006-03-31 00:39:03 +04:00
|
|
|
this->AppendEcho(commands, text,
|
|
|
|
cmLocalUnixMakefileGenerator3::EchoGlobal);
|
2006-02-23 18:07:24 +03:00
|
|
|
|
2006-06-01 22:43:28 +04:00
|
|
|
// Global targets store their rules in pre- and post-build commands.
|
2010-11-12 00:02:07 +03:00
|
|
|
this->AppendCustomDepends(depends,
|
2006-03-15 19:02:08 +03:00
|
|
|
glIt->second.GetPreBuildCommands());
|
2010-11-12 00:02:07 +03:00
|
|
|
this->AppendCustomDepends(depends,
|
2006-03-15 19:02:08 +03:00
|
|
|
glIt->second.GetPostBuildCommands());
|
2010-11-12 00:02:07 +03:00
|
|
|
this->AppendCustomCommands(commands,
|
2008-10-09 23:30:07 +04:00
|
|
|
glIt->second.GetPreBuildCommands(),
|
2009-02-10 16:50:33 +03:00
|
|
|
&glIt->second,
|
2008-10-09 23:30:07 +04:00
|
|
|
cmLocalGenerator::START_OUTPUT);
|
2010-11-12 00:02:07 +03:00
|
|
|
this->AppendCustomCommands(commands,
|
2008-10-09 23:30:07 +04:00
|
|
|
glIt->second.GetPostBuildCommands(),
|
2009-02-10 16:50:33 +03:00
|
|
|
&glIt->second,
|
2008-10-09 23:30:07 +04:00
|
|
|
cmLocalGenerator::START_OUTPUT);
|
2006-06-01 22:43:28 +04:00
|
|
|
std::string targetName = glIt->second.GetName();
|
2010-11-12 00:02:07 +03:00
|
|
|
this->WriteMakeRule(ruleFileStream, targetString.c_str(),
|
2006-06-01 22:43:28 +04:00
|
|
|
targetName.c_str(), depends, commands, true);
|
|
|
|
|
|
|
|
// Provide a "/fast" version of the target.
|
|
|
|
depends.clear();
|
2010-11-12 00:02:07 +03:00
|
|
|
if((targetName == "install")
|
2007-05-18 21:43:39 +04:00
|
|
|
|| (targetName == "install_local")
|
|
|
|
|| (targetName == "install_strip"))
|
2006-06-01 22:43:28 +04:00
|
|
|
{
|
|
|
|
// Provide a fast install target that does not depend on all
|
|
|
|
// but has the same command.
|
|
|
|
depends.push_back("preinstall/fast");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// Just forward to the real target so at least it will work.
|
|
|
|
depends.push_back(targetName);
|
|
|
|
commands.clear();
|
|
|
|
}
|
|
|
|
targetName += "/fast";
|
|
|
|
this->WriteMakeRule(ruleFileStream, targetString.c_str(),
|
|
|
|
targetName.c_str(), depends, commands, true);
|
2006-02-16 00:35:16 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-05-11 16:45:16 +04:00
|
|
|
std::vector<std::string> depends;
|
|
|
|
std::vector<std::string> commands;
|
2006-02-16 00:35:16 +03:00
|
|
|
|
2005-05-25 23:09:06 +04:00
|
|
|
// Write the all rule.
|
2006-10-10 21:47:50 +04:00
|
|
|
std::string dir;
|
|
|
|
std::string recursiveTarget = this->Makefile->GetStartOutputDirectory();
|
|
|
|
recursiveTarget += "/all";
|
2006-03-15 19:02:08 +03:00
|
|
|
|
2006-03-02 02:54:17 +03:00
|
|
|
depends.push_back("cmake_check_build_system");
|
2006-03-15 19:02:08 +03:00
|
|
|
|
2006-06-27 18:24:09 +04:00
|
|
|
std::string progressDir = this->Makefile->GetHomeOutputDirectory();
|
|
|
|
progressDir += cmake::GetCMakeFilesDirectory();
|
|
|
|
{
|
2006-06-27 22:26:35 +04:00
|
|
|
cmOStringStream progCmd;
|
2010-11-12 00:02:07 +03:00
|
|
|
progCmd <<
|
2006-07-11 17:55:27 +04:00
|
|
|
"$(CMAKE_COMMAND) -E cmake_progress_start ";
|
2006-06-27 22:26:35 +04:00
|
|
|
progCmd << this->Convert(progressDir.c_str(),
|
|
|
|
cmLocalGenerator::FULL,
|
|
|
|
cmLocalGenerator::SHELL);
|
2008-01-18 18:25:25 +03:00
|
|
|
|
|
|
|
std::string progressFile = cmake::GetCMakeFilesDirectory();
|
2009-06-25 17:58:51 +04:00
|
|
|
progressFile += "/progress.marks";
|
2008-01-18 18:25:25 +03:00
|
|
|
std::string progressFileNameFull =
|
|
|
|
this->ConvertToFullPath(progressFile.c_str());
|
|
|
|
progCmd << " " << this->Convert(progressFileNameFull.c_str(),
|
|
|
|
cmLocalGenerator::FULL,
|
|
|
|
cmLocalGenerator::SHELL);
|
2006-06-27 22:26:35 +04:00
|
|
|
commands.push_back(progCmd.str());
|
2006-06-27 18:24:09 +04:00
|
|
|
}
|
2006-06-14 20:28:32 +04:00
|
|
|
std::string mf2Dir = cmake::GetCMakeFilesDirectoryPostSlash();
|
|
|
|
mf2Dir += "Makefile2";
|
2006-06-15 19:51:51 +04:00
|
|
|
commands.push_back(this->GetRecursiveMakeCall(mf2Dir.c_str(),
|
2006-10-10 21:47:50 +04:00
|
|
|
recursiveTarget.c_str()));
|
2006-01-30 21:57:01 +03:00
|
|
|
this->CreateCDCommand(commands,
|
2006-06-14 20:28:32 +04:00
|
|
|
this->Makefile->GetHomeOutputDirectory(),
|
2008-10-09 23:30:07 +04:00
|
|
|
cmLocalGenerator::START_OUTPUT);
|
2006-05-23 17:11:46 +04:00
|
|
|
{
|
|
|
|
cmOStringStream progCmd;
|
2006-05-31 00:23:24 +04:00
|
|
|
progCmd << "$(CMAKE_COMMAND) -E cmake_progress_start "; // # 0
|
2006-05-23 17:58:10 +04:00
|
|
|
progCmd << this->Convert(progressDir.c_str(),
|
|
|
|
cmLocalGenerator::FULL,
|
|
|
|
cmLocalGenerator::SHELL);
|
|
|
|
progCmd << " 0";
|
2006-05-23 17:11:46 +04:00
|
|
|
commands.push_back(progCmd.str());
|
|
|
|
}
|
2006-02-16 00:35:16 +03:00
|
|
|
this->WriteMakeRule(ruleFileStream, "The main all target", "all",
|
|
|
|
depends, commands, true);
|
2005-05-11 16:45:16 +04:00
|
|
|
|
2005-05-25 23:09:06 +04:00
|
|
|
// Write the clean rule.
|
2006-10-10 21:47:50 +04:00
|
|
|
recursiveTarget = this->Makefile->GetStartOutputDirectory();
|
|
|
|
recursiveTarget += "/clean";
|
2005-05-25 23:09:06 +04:00
|
|
|
commands.clear();
|
2005-10-20 22:25:08 +04:00
|
|
|
depends.clear();
|
2006-06-15 19:51:51 +04:00
|
|
|
commands.push_back(this->GetRecursiveMakeCall(mf2Dir.c_str(),
|
2006-10-10 21:47:50 +04:00
|
|
|
recursiveTarget.c_str()));
|
2006-01-30 21:57:01 +03:00
|
|
|
this->CreateCDCommand(commands,
|
2006-03-15 19:02:08 +03:00
|
|
|
this->Makefile->GetHomeOutputDirectory(),
|
2008-10-09 23:30:07 +04:00
|
|
|
cmLocalGenerator::START_OUTPUT);
|
2006-02-16 00:35:16 +03:00
|
|
|
this->WriteMakeRule(ruleFileStream, "The main clean target", "clean",
|
|
|
|
depends, commands, true);
|
2006-05-02 17:56:42 +04:00
|
|
|
commands.clear();
|
|
|
|
depends.clear();
|
|
|
|
depends.push_back("clean");
|
|
|
|
this->WriteMakeRule(ruleFileStream, "The main clean target", "clean/fast",
|
|
|
|
depends, commands, true);
|
2005-05-25 23:09:06 +04:00
|
|
|
|
2006-03-02 02:54:17 +03:00
|
|
|
// Write the preinstall rule.
|
2006-10-10 21:47:50 +04:00
|
|
|
recursiveTarget = this->Makefile->GetStartOutputDirectory();
|
|
|
|
recursiveTarget += "/preinstall";
|
2006-03-02 02:54:17 +03:00
|
|
|
commands.clear();
|
|
|
|
depends.clear();
|
|
|
|
const char* noall =
|
2006-03-15 19:02:08 +03:00
|
|
|
this->Makefile->GetDefinition("CMAKE_SKIP_INSTALL_ALL_DEPENDENCY");
|
2006-03-02 02:54:17 +03:00
|
|
|
if(!noall || cmSystemTools::IsOff(noall))
|
|
|
|
{
|
|
|
|
// Drive the build before installing.
|
|
|
|
depends.push_back("all");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// At least make sure the build system is up to date.
|
|
|
|
depends.push_back("cmake_check_build_system");
|
|
|
|
}
|
|
|
|
commands.push_back
|
2006-10-10 21:47:50 +04:00
|
|
|
(this->GetRecursiveMakeCall(mf2Dir.c_str(), recursiveTarget.c_str()));
|
2006-03-02 02:54:17 +03:00
|
|
|
this->CreateCDCommand(commands,
|
2006-03-15 19:02:08 +03:00
|
|
|
this->Makefile->GetHomeOutputDirectory(),
|
2008-10-09 23:30:07 +04:00
|
|
|
cmLocalGenerator::START_OUTPUT);
|
2006-03-02 02:54:17 +03:00
|
|
|
this->WriteMakeRule(ruleFileStream, "Prepare targets for installation.",
|
|
|
|
"preinstall", depends, commands, true);
|
2006-06-01 22:09:21 +04:00
|
|
|
depends.clear();
|
2006-05-02 21:31:56 +04:00
|
|
|
this->WriteMakeRule(ruleFileStream, "Prepare targets for installation.",
|
|
|
|
"preinstall/fast", depends, commands, true);
|
2006-03-02 02:54:17 +03:00
|
|
|
|
2005-10-20 21:40:28 +04:00
|
|
|
// write the depend rule, really a recompute depends rule
|
|
|
|
depends.clear();
|
|
|
|
commands.clear();
|
2006-06-14 20:28:32 +04:00
|
|
|
std::string cmakefileName = cmake::GetCMakeFilesDirectoryPostSlash();
|
|
|
|
cmakefileName += "Makefile.cmake";
|
2005-10-20 21:40:28 +04:00
|
|
|
std::string runRule =
|
|
|
|
"$(CMAKE_COMMAND) -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)";
|
|
|
|
runRule += " --check-build-system ";
|
|
|
|
runRule += this->Convert(cmakefileName.c_str(),cmLocalGenerator::NONE,
|
|
|
|
cmLocalGenerator::SHELL);
|
|
|
|
runRule += " 1";
|
|
|
|
commands.push_back(runRule);
|
2007-12-20 01:54:24 +03:00
|
|
|
this->CreateCDCommand(commands,
|
|
|
|
this->Makefile->GetHomeOutputDirectory(),
|
2008-10-09 23:30:07 +04:00
|
|
|
cmLocalGenerator::START_OUTPUT);
|
2010-11-12 00:02:07 +03:00
|
|
|
this->WriteMakeRule(ruleFileStream, "clear depends",
|
|
|
|
"depend",
|
2006-02-16 00:35:16 +03:00
|
|
|
depends, commands, true);
|
2005-10-20 21:40:28 +04:00
|
|
|
}
|
|
|
|
|
2006-02-15 18:34:11 +03:00
|
|
|
|
2005-10-20 21:40:28 +04:00
|
|
|
//----------------------------------------------------------------------------
|
2007-12-20 00:36:30 +03:00
|
|
|
void cmLocalUnixMakefileGenerator3::ClearDependencies(cmMakefile* mf,
|
|
|
|
bool verbose)
|
2005-10-20 21:40:28 +04:00
|
|
|
{
|
2006-02-15 18:34:11 +03:00
|
|
|
// Get the list of target files to check
|
|
|
|
const char* infoDef = mf->GetDefinition("CMAKE_DEPEND_INFO_FILES");
|
|
|
|
if(!infoDef)
|
2005-10-20 21:40:28 +04:00
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
2006-02-15 18:34:11 +03:00
|
|
|
std::vector<std::string> files;
|
|
|
|
cmSystemTools::ExpandListArgument(infoDef, files);
|
|
|
|
|
2007-12-20 00:36:30 +03:00
|
|
|
// Each depend information file corresponds to a target. Clear the
|
|
|
|
// dependencies for that target.
|
|
|
|
cmDepends clearer;
|
|
|
|
clearer.SetVerbose(verbose);
|
2006-02-15 18:34:11 +03:00
|
|
|
for(std::vector<std::string>::iterator l = files.begin();
|
|
|
|
l != files.end(); ++l)
|
2005-10-21 00:37:37 +04:00
|
|
|
{
|
2006-02-15 18:34:11 +03:00
|
|
|
std::string dir = cmSystemTools::GetFilenamePath(l->c_str());
|
2007-12-20 00:36:30 +03:00
|
|
|
|
|
|
|
// Clear the implicit dependency makefile.
|
2006-02-15 18:34:11 +03:00
|
|
|
std::string dependFile = dir + "/depend.make";
|
2007-12-20 00:36:30 +03:00
|
|
|
clearer.Clear(dependFile.c_str());
|
|
|
|
|
|
|
|
// Remove the internal dependency check file to force
|
|
|
|
// regeneration.
|
|
|
|
std::string internalDependFile = dir + "/depend.internal";
|
|
|
|
cmSystemTools::RemoveFile(internalDependFile.c_str());
|
2006-02-15 18:34:11 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void cmLocalUnixMakefileGenerator3
|
|
|
|
::WriteDependLanguageInfo(std::ostream& cmakefileStream, cmTarget &target)
|
|
|
|
{
|
2007-08-07 21:57:13 +04:00
|
|
|
ImplicitDependLanguageMap const& implicitLangs =
|
|
|
|
this->GetImplicitDepends(target);
|
|
|
|
|
2006-02-15 18:34:11 +03:00
|
|
|
// list the languages
|
|
|
|
cmakefileStream
|
2007-08-07 21:57:13 +04:00
|
|
|
<< "# The set of languages for which implicit dependencies are needed:\n";
|
2006-02-15 18:34:11 +03:00
|
|
|
cmakefileStream
|
2013-08-22 13:30:19 +04:00
|
|
|
<< "set(CMAKE_DEPENDS_LANGUAGES\n";
|
2007-08-07 21:57:13 +04:00
|
|
|
for(ImplicitDependLanguageMap::const_iterator
|
|
|
|
l = implicitLangs.begin(); l != implicitLangs.end(); ++l)
|
2006-02-15 18:34:11 +03:00
|
|
|
{
|
2007-08-07 21:57:13 +04:00
|
|
|
cmakefileStream << " \"" << l->first.c_str() << "\"\n";
|
2006-02-15 18:34:11 +03:00
|
|
|
}
|
|
|
|
cmakefileStream << " )\n";
|
2007-08-07 21:57:13 +04:00
|
|
|
|
2006-02-15 18:34:11 +03:00
|
|
|
// now list the files for each language
|
2007-08-07 21:57:13 +04:00
|
|
|
cmakefileStream
|
|
|
|
<< "# The set of files for implicit dependencies of each language:\n";
|
|
|
|
for(ImplicitDependLanguageMap::const_iterator
|
|
|
|
l = implicitLangs.begin(); l != implicitLangs.end(); ++l)
|
2005-10-20 21:40:28 +04:00
|
|
|
{
|
2006-02-15 18:34:11 +03:00
|
|
|
cmakefileStream
|
2013-08-22 13:30:19 +04:00
|
|
|
<< "set(CMAKE_DEPENDS_CHECK_" << l->first.c_str() << "\n";
|
2007-08-07 21:57:13 +04:00
|
|
|
ImplicitDependFileMap const& implicitPairs = l->second;
|
|
|
|
|
|
|
|
// for each file pair
|
|
|
|
for(ImplicitDependFileMap::const_iterator pi = implicitPairs.begin();
|
|
|
|
pi != implicitPairs.end(); ++pi)
|
2006-02-15 18:34:11 +03:00
|
|
|
{
|
2012-09-30 20:34:57 +04:00
|
|
|
for(cmDepends::DependencyVector::const_iterator di = pi->second.begin();
|
|
|
|
di != pi->second.end(); ++ di)
|
|
|
|
{
|
|
|
|
cmakefileStream << " \"" << *di << "\" ";
|
|
|
|
cmakefileStream << "\"" << pi->first << "\"\n";
|
|
|
|
}
|
2006-02-15 18:34:11 +03:00
|
|
|
}
|
|
|
|
cmakefileStream << " )\n";
|
2008-01-02 19:04:52 +03:00
|
|
|
|
|
|
|
// Tell the dependency scanner what compiler is used.
|
|
|
|
std::string cidVar = "CMAKE_";
|
|
|
|
cidVar += l->first;
|
|
|
|
cidVar += "_COMPILER_ID";
|
|
|
|
const char* cid = this->Makefile->GetDefinition(cidVar.c_str());
|
|
|
|
if(cid && *cid)
|
|
|
|
{
|
|
|
|
cmakefileStream
|
2013-08-22 13:30:19 +04:00
|
|
|
<< "set(CMAKE_" << l->first.c_str() << "_COMPILER_ID \""
|
2008-01-02 19:04:52 +03:00
|
|
|
<< cid << "\")\n";
|
|
|
|
}
|
2006-02-15 18:34:11 +03:00
|
|
|
}
|
2008-01-09 18:30:11 +03:00
|
|
|
|
2008-01-18 03:58:01 +03:00
|
|
|
// Build a list of preprocessor definitions for the target.
|
2013-02-07 04:49:17 +04:00
|
|
|
std::set<std::string> defines;
|
2013-06-06 20:13:35 +04:00
|
|
|
this->AddCompileDefinitions(defines, &target,
|
|
|
|
this->ConfigurationName.c_str());
|
2008-01-18 03:58:01 +03:00
|
|
|
if(!defines.empty())
|
|
|
|
{
|
|
|
|
cmakefileStream
|
|
|
|
<< "\n"
|
|
|
|
<< "# Preprocessor definitions for this target.\n"
|
2013-08-22 13:30:19 +04:00
|
|
|
<< "set(CMAKE_TARGET_DEFINITIONS\n";
|
2013-02-07 04:49:17 +04:00
|
|
|
for(std::set<std::string>::const_iterator di = defines.begin();
|
2008-01-18 03:58:01 +03:00
|
|
|
di != defines.end(); ++di)
|
|
|
|
{
|
|
|
|
cmakefileStream
|
|
|
|
<< " " << this->EscapeForCMake(di->c_str()) << "\n";
|
|
|
|
}
|
|
|
|
cmakefileStream
|
|
|
|
<< " )\n";
|
|
|
|
}
|
2008-05-14 19:54:52 +04:00
|
|
|
|
|
|
|
// Store include transform rule properties. Write the directory
|
|
|
|
// rules first because they may be overridden by later target rules.
|
|
|
|
std::vector<std::string> transformRules;
|
|
|
|
if(const char* xform =
|
|
|
|
this->Makefile->GetProperty("IMPLICIT_DEPENDS_INCLUDE_TRANSFORM"))
|
|
|
|
{
|
|
|
|
cmSystemTools::ExpandListArgument(xform, transformRules);
|
|
|
|
}
|
|
|
|
if(const char* xform =
|
|
|
|
target.GetProperty("IMPLICIT_DEPENDS_INCLUDE_TRANSFORM"))
|
|
|
|
{
|
|
|
|
cmSystemTools::ExpandListArgument(xform, transformRules);
|
|
|
|
}
|
|
|
|
if(!transformRules.empty())
|
|
|
|
{
|
|
|
|
cmakefileStream
|
2013-08-22 13:30:19 +04:00
|
|
|
<< "set(CMAKE_INCLUDE_TRANSFORMS\n";
|
2008-05-14 19:54:52 +04:00
|
|
|
for(std::vector<std::string>::const_iterator tri = transformRules.begin();
|
|
|
|
tri != transformRules.end(); ++tri)
|
|
|
|
{
|
|
|
|
cmakefileStream << " " << this->EscapeForCMake(tri->c_str()) << "\n";
|
|
|
|
}
|
|
|
|
cmakefileStream
|
|
|
|
<< " )\n";
|
|
|
|
}
|
2006-02-15 18:34:11 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
void cmLocalUnixMakefileGenerator3::WriteDisclaimer(std::ostream& os)
|
|
|
|
{
|
|
|
|
os
|
|
|
|
<< "# CMAKE generated file: DO NOT EDIT!\n"
|
2006-03-15 19:02:08 +03:00
|
|
|
<< "# Generated by \"" << this->GlobalGenerator->GetName() << "\""
|
2006-02-15 18:34:11 +03:00
|
|
|
<< " Generator, CMake Version "
|
2006-11-29 23:59:16 +03:00
|
|
|
<< cmVersion::GetMajorVersion() << "."
|
|
|
|
<< cmVersion::GetMinorVersion() << "\n\n";
|
2006-02-15 18:34:11 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
std::string
|
|
|
|
cmLocalUnixMakefileGenerator3
|
2006-03-16 00:32:40 +03:00
|
|
|
::GetRecursiveMakeCall(const char *makefile, const char* tgt)
|
2006-02-15 18:34:11 +03:00
|
|
|
{
|
|
|
|
// Call make on the given file.
|
|
|
|
std::string cmd;
|
|
|
|
cmd += "$(MAKE) -f ";
|
2007-02-22 05:24:17 +03:00
|
|
|
cmd += this->Convert(makefile,NONE,SHELL);
|
2006-02-15 18:34:11 +03:00
|
|
|
cmd += " ";
|
2010-11-12 00:02:07 +03:00
|
|
|
|
2009-02-10 00:36:56 +03:00
|
|
|
// Pass down verbosity level.
|
2006-02-15 18:34:11 +03:00
|
|
|
if(this->GetMakeSilentFlag().size())
|
|
|
|
{
|
|
|
|
cmd += this->GetMakeSilentFlag();
|
|
|
|
cmd += " ";
|
|
|
|
}
|
2005-10-20 21:40:28 +04:00
|
|
|
|
2006-02-15 18:34:11 +03:00
|
|
|
// 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(this->GetPassMakeflags())
|
2005-06-02 21:41:34 +04:00
|
|
|
{
|
2006-02-15 18:34:11 +03:00
|
|
|
cmd += "-$(MAKEFLAGS) ";
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add the target.
|
|
|
|
if (tgt && tgt[0] != '\0')
|
|
|
|
{
|
2007-03-08 19:49:30 +03:00
|
|
|
// The make target is always relative to the top of the build tree.
|
|
|
|
std::string tgt2 = this->Convert(tgt, HOME_OUTPUT);
|
|
|
|
|
|
|
|
// The target may have been written with windows paths.
|
|
|
|
cmSystemTools::ConvertToOutputSlashes(tgt2);
|
|
|
|
|
2007-03-08 21:05:02 +03:00
|
|
|
// Escape one extra time if the make tool requires it.
|
|
|
|
if(this->MakeCommandEscapeTargetTwice)
|
|
|
|
{
|
|
|
|
tgt2 = this->EscapeForShell(tgt2.c_str(), true, false);
|
|
|
|
}
|
|
|
|
|
2007-03-08 19:49:30 +03:00
|
|
|
// The target name is now a string that should be passed verbatim
|
|
|
|
// on the command line.
|
|
|
|
cmd += this->EscapeForShell(tgt2.c_str(), true, false);
|
2006-02-15 18:34:11 +03:00
|
|
|
}
|
|
|
|
return cmd;
|
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
void cmLocalUnixMakefileGenerator3::WriteDivider(std::ostream& os)
|
|
|
|
{
|
|
|
|
os
|
|
|
|
<< "#======================================"
|
|
|
|
<< "=======================================\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
void
|
|
|
|
cmLocalUnixMakefileGenerator3
|
|
|
|
::WriteCMakeArgument(std::ostream& os, const char* s)
|
|
|
|
{
|
|
|
|
// Write the given string to the stream with escaping to get it back
|
|
|
|
// into CMake through the lexical scanner.
|
|
|
|
os << "\"";
|
|
|
|
for(const char* c = s; *c; ++c)
|
|
|
|
{
|
|
|
|
if(*c == '\\')
|
2005-06-02 21:41:34 +04:00
|
|
|
{
|
2006-02-15 18:34:11 +03:00
|
|
|
os << "\\\\";
|
|
|
|
}
|
|
|
|
else if(*c == '"')
|
|
|
|
{
|
|
|
|
os << "\\\"";
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
os << *c;
|
2005-06-02 21:41:34 +04:00
|
|
|
}
|
|
|
|
}
|
2006-02-15 18:34:11 +03:00
|
|
|
os << "\"";
|
|
|
|
}
|
2005-06-30 17:53:03 +04:00
|
|
|
|
2006-02-15 18:34:11 +03:00
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
std::string
|
|
|
|
cmLocalUnixMakefileGenerator3::ConvertToQuotedOutputPath(const char* p)
|
|
|
|
{
|
2010-11-12 00:02:07 +03:00
|
|
|
|
2006-02-15 18:34:11 +03:00
|
|
|
// Split the path into its components.
|
|
|
|
std::vector<std::string> components;
|
|
|
|
cmSystemTools::SplitPath(p, components);
|
|
|
|
|
|
|
|
// Return an empty path if there are no components.
|
|
|
|
if(components.empty())
|
2005-10-20 21:40:28 +04:00
|
|
|
{
|
2006-02-15 18:34:11 +03:00
|
|
|
return "\"\"";
|
2005-10-20 21:40:28 +04:00
|
|
|
}
|
|
|
|
|
2006-02-15 18:34:11 +03:00
|
|
|
// Choose a slash direction and fix root component.
|
|
|
|
const char* slash = "/";
|
|
|
|
#if defined(_WIN32) && !defined(__CYGWIN__)
|
|
|
|
if(!cmSystemTools::GetForceUnixPaths())
|
|
|
|
{
|
|
|
|
slash = "\\";
|
|
|
|
for(std::string::iterator i = components[0].begin();
|
|
|
|
i != components[0].end(); ++i)
|
|
|
|
{
|
|
|
|
if(*i == '/')
|
|
|
|
{
|
|
|
|
*i = '\\';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
2005-05-11 16:45:16 +04:00
|
|
|
|
2006-02-15 18:34:11 +03:00
|
|
|
// Begin the quoted result with the root component.
|
|
|
|
std::string result = "\"";
|
|
|
|
result += components[0];
|
2005-05-11 16:45:16 +04:00
|
|
|
|
2006-02-15 18:34:11 +03:00
|
|
|
// Now add the rest of the components separated by the proper slash
|
|
|
|
// direction for this platform.
|
|
|
|
bool first = true;
|
|
|
|
for(unsigned int i=1; i < components.size(); ++i)
|
2005-05-11 16:45:16 +04:00
|
|
|
{
|
2006-02-15 18:34:11 +03:00
|
|
|
// Only the last component can be empty to avoid double slashes.
|
|
|
|
if(components[i].length() > 0 || (i == (components.size()-1)))
|
2005-05-11 16:45:16 +04:00
|
|
|
{
|
2006-02-15 18:34:11 +03:00
|
|
|
if(!first)
|
2005-05-11 16:45:16 +04:00
|
|
|
{
|
2006-02-15 18:34:11 +03:00
|
|
|
result += slash;
|
2005-05-11 16:45:16 +04:00
|
|
|
}
|
2006-02-15 18:34:11 +03:00
|
|
|
result += components[i];
|
|
|
|
first = false;
|
2005-05-11 16:45:16 +04:00
|
|
|
}
|
|
|
|
}
|
2006-02-15 18:34:11 +03:00
|
|
|
|
|
|
|
// Close the quoted result.
|
|
|
|
result += "\"";
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
std::string
|
2007-08-01 23:25:40 +04:00
|
|
|
cmLocalUnixMakefileGenerator3
|
|
|
|
::GetTargetDirectory(cmTarget const& target) const
|
2006-02-15 18:34:11 +03:00
|
|
|
{
|
2006-06-14 20:28:32 +04:00
|
|
|
std::string dir = cmake::GetCMakeFilesDirectoryPostSlash();
|
2006-02-15 18:34:11 +03:00
|
|
|
dir += target.GetName();
|
2009-06-10 21:03:11 +04:00
|
|
|
#if defined(__VMS)
|
|
|
|
dir += "_dir";
|
|
|
|
#else
|
2006-02-15 18:34:11 +03:00
|
|
|
dir += ".dir";
|
2009-06-10 21:03:11 +04:00
|
|
|
#endif
|
2006-02-15 18:34:11 +03:00
|
|
|
return dir;
|
2005-05-11 16:45:16 +04:00
|
|
|
}
|
|
|
|
|
2007-08-07 21:57:13 +04:00
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
cmLocalUnixMakefileGenerator3::ImplicitDependLanguageMap const&
|
|
|
|
cmLocalUnixMakefileGenerator3::GetImplicitDepends(cmTarget const& tgt)
|
|
|
|
{
|
|
|
|
return this->ImplicitDepends[tgt.GetName()];
|
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
void
|
|
|
|
cmLocalUnixMakefileGenerator3::AddImplicitDepends(cmTarget const& tgt,
|
|
|
|
const char* lang,
|
|
|
|
const char* obj,
|
|
|
|
const char* src)
|
|
|
|
{
|
2012-09-30 20:34:57 +04:00
|
|
|
this->ImplicitDepends[tgt.GetName()][lang][obj].push_back(src);
|
2007-08-07 21:57:13 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
2005-06-02 21:41:34 +04:00
|
|
|
void cmLocalUnixMakefileGenerator3
|
2005-10-20 21:40:28 +04:00
|
|
|
::CreateCDCommand(std::vector<std::string>& commands, const char *tgtDir,
|
2008-10-09 23:30:07 +04:00
|
|
|
cmLocalGenerator::RelativeRoot relRetDir)
|
2005-05-11 16:45:16 +04:00
|
|
|
{
|
2008-10-09 23:30:07 +04:00
|
|
|
const char* retDir = this->GetRelativeRootPath(relRetDir);
|
|
|
|
|
2005-10-20 21:40:28 +04:00
|
|
|
// do we need to cd?
|
|
|
|
if (!strcmp(tgtDir,retDir))
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
2010-11-12 00:02:07 +03:00
|
|
|
|
2011-04-09 00:12:18 +04:00
|
|
|
// In a Windows shell we must change drive letter too. The shell
|
|
|
|
// used by NMake and Borland make does not support "cd /d" so this
|
|
|
|
// feature simply cannot work with them (Borland make does not even
|
|
|
|
// support changing the drive letter with just "d:").
|
|
|
|
const char* cd_cmd = this->MinGWMake? "cd /d " : "cd ";
|
2011-04-08 17:28:59 +04:00
|
|
|
|
2006-03-15 19:02:08 +03:00
|
|
|
if(!this->UnixCD)
|
2005-05-11 16:45:16 +04:00
|
|
|
{
|
|
|
|
// On Windows we must perform each step separately and then change
|
|
|
|
// back because the shell keeps the working directory between
|
|
|
|
// commands.
|
2011-04-08 17:28:59 +04:00
|
|
|
std::string cmd = cd_cmd;
|
2008-10-09 23:30:07 +04:00
|
|
|
cmd += this->ConvertToOutputForExisting(tgtDir, relRetDir);
|
2005-10-19 18:03:20 +04:00
|
|
|
commands.insert(commands.begin(),cmd);
|
2008-10-09 23:30:07 +04:00
|
|
|
|
|
|
|
// Change back to the starting directory.
|
2011-04-08 17:28:59 +04:00
|
|
|
cmd = cd_cmd;
|
2008-10-09 23:30:07 +04:00
|
|
|
cmd += this->ConvertToOutputForExisting(relRetDir, tgtDir);
|
2005-05-11 16:45:16 +04:00
|
|
|
commands.push_back(cmd);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// On UNIX we must construct a single shell command to change
|
|
|
|
// directory and build because make resets the directory between
|
|
|
|
// each command.
|
2005-10-19 18:03:20 +04:00
|
|
|
std::vector<std::string>::iterator i = commands.begin();
|
|
|
|
for (; i != commands.end(); ++i)
|
|
|
|
{
|
2011-04-08 17:28:59 +04:00
|
|
|
std::string cmd = cd_cmd;
|
2008-10-09 23:30:07 +04:00
|
|
|
cmd += this->ConvertToOutputForExisting(tgtDir, relRetDir);
|
2005-10-19 18:03:20 +04:00
|
|
|
cmd += " && ";
|
|
|
|
cmd += *i;
|
|
|
|
*i = cmd;
|
|
|
|
}
|
2005-05-11 16:45:16 +04:00
|
|
|
}
|
|
|
|
}
|