CMake/Source/cmLocalUnixMakefileGenerato...

2363 lines
76 KiB
C++
Raw Normal View History

/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
2005-05-05 20:45:53 +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
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"
#include "cmGlobalUnixMakefileGenerator3.h"
2005-05-05 20:45:53 +04:00
#include "cmMakefile.h"
#include "cmMakefileTargetGenerator.h"
2005-05-05 20:45:53 +04:00
#include "cmSourceFile.h"
#include "cmake.h"
#include "cmVersion.h"
#include "cmFileTimeComparison.h"
#include "cmCustomCommandGenerator.h"
2015-03-08 15:51:20 +03:00
#include "cmAlgorithms.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"
#endif
#include <cmsys/auto_ptr.hxx>
#include <cmsys/Terminal.h>
2005-05-05 20:45:53 +04:00
#include <queue>
//----------------------------------------------------------------------------
// 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;
}
};
//----------------------------------------------------------------------------
// 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(cmGlobalGenerator* gg, cmLocalGenerator* parent,
cmState::Snapshot snapshot)
: cmLocalCommonGenerator(gg, parent, snapshot)
2005-05-05 20:45:53 +04:00
{
2006-03-15 19:02:08 +03:00
this->MakefileVariableSize = 0;
this->ColorMakefile = false;
this->SkipPreprocessedSourceRules = false;
this->SkipAssemblySourceRules = false;
this->MakeCommandEscapeTargetTwice = false;
this->BorlandMakeCurlyHack = false;
2005-05-05 20:45:53 +04:00
}
//----------------------------------------------------------------------------
cmLocalUnixMakefileGenerator3::~cmLocalUnixMakefileGenerator3()
{
}
2005-06-01 21:37:49 +04:00
//----------------------------------------------------------------------------
void cmLocalUnixMakefileGenerator3::Generate()
2005-06-01 21:37:49 +04:00
{
this->SetConfigName();
2005-05-05 20:45:53 +04:00
// Record whether some options are enabled to avoid checking many
// times later.
if(!this->GetGlobalGenerator()->GetCMakeInstance()->GetIsInTryCompile())
{
this->ColorMakefile = this->Makefile->IsOn("CMAKE_COLOR_MAKEFILE");
}
this->SkipPreprocessedSourceRules =
this->Makefile->IsOn("CMAKE_SKIP_PREPROCESSED_SOURCE_RULES");
this->SkipAssemblySourceRules =
this->Makefile->IsOn("CMAKE_SKIP_ASSEMBLY_SOURCE_RULES");
2005-05-05 20:45:53 +04:00
// Generate the rule files for each target.
cmGeneratorTargetsType targets = this->Makefile->GetGeneratorTargets();
cmGlobalUnixMakefileGenerator3* gg =
static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator);
for(cmGeneratorTargetsType::iterator t = targets.begin();
t != targets.end(); ++t)
2005-05-05 20:45:53 +04:00
{
if (t->second->Target->GetType() == cmTarget::INTERFACE_LIBRARY
|| t->second->Target->IsImported())
{
continue;
}
cmsys::auto_ptr<cmMakefileTargetGenerator> tg(
cmMakefileTargetGenerator::New(t->second));
if (tg.get())
2005-05-05 20:45:53 +04:00
{
tg->WriteRuleFiles();
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();
}
void cmLocalUnixMakefileGenerator3::ComputeHomeRelativeOutputPath()
{
// Compute the path to use when referencing the current output
// directory from the top output directory.
this->HomeRelativeOutputPath =
this->Convert(this->Makefile->GetCurrentBinaryDirectory(), HOME_OUTPUT);
if(this->HomeRelativeOutputPath == ".")
{
this->HomeRelativeOutputPath = "";
}
if(!this->HomeRelativeOutputPath.empty())
{
this->HomeRelativeOutputPath += "/";
}
}
//----------------------------------------------------------------------------
void cmLocalUnixMakefileGenerator3::ComputeObjectFilenames(
std::map<cmSourceFile const*, std::string>& mapping,
cmGeneratorTarget const* gt)
{
for(std::map<cmSourceFile const*, std::string>::iterator
si = mapping.begin(); si != mapping.end(); ++si)
{
cmSourceFile const* sf = si->first;
si->second = this->GetObjectFileNameWithoutTarget(*sf,
gt->ObjectDirectory);
}
}
//----------------------------------------------------------------------------
void cmLocalUnixMakefileGenerator3::
GetLocalObjectFiles(std::map<std::string, LocalObjectInfo> &localObjectFiles)
{
std::set<std::string> emitted;
cmGeneratorTargetsType targets = this->Makefile->GetGeneratorTargets();
for(cmGeneratorTargetsType::iterator ti = targets.begin();
ti != targets.end(); ++ti)
{
cmGeneratorTarget* gt = ti->second;
if (gt->GetType() == cmTarget::INTERFACE_LIBRARY)
{
continue;
}
std::vector<cmSourceFile const*> objectSources;
gt->GetObjectSources(objectSources, this->Makefile
->GetSafeDefinition("CMAKE_BUILD_TYPE"));
// Compute full path to object file directory for this target.
std::string dir;
dir += gt->Makefile->GetCurrentBinaryDirectory();
dir += "/";
dir += this->GetTargetDirectory(*gt->Target);
dir += "/";
// Compute the name of each object file.
for(std::vector<cmSourceFile const*>::iterator
si = objectSources.begin();
si != objectSources.end(); ++si)
{
cmSourceFile const* sf = *si;
bool hasSourceExtension = true;
std::string objectName = this->GetObjectFileNameWithoutTarget(*sf,
dir,
&hasSourceExtension);
if(cmSystemTools::FileIsFullPath(objectName.c_str()))
{
objectName = cmSystemTools::GetFilenameName(objectName);
}
LocalObjectInfo& info = localObjectFiles[objectName];
info.HasSourceExtension = hasSourceExtension;
info.push_back(LocalObjectEntry(gt->Target, sf->GetLanguage()));
}
}
}
//----------------------------------------------------------------------------
void cmLocalUnixMakefileGenerator3::GetIndividualFileTargets
(std::vector<std::string>& targets)
{
std::map<std::string, LocalObjectInfo> localObjectFiles;
this->GetLocalObjectFiles(localObjectFiles);
for (std::map<std::string, LocalObjectInfo>::iterator lo =
localObjectFiles.begin();
lo != 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");
}
}
}
//----------------------------------------------------------------------------
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
if (!this->GetMakefile()->IsRootMakefile())
{
ruleFileStream.SetCopyIfDifferent(true);
}
2010-11-12 00:02:07 +03:00
// write the all rules
this->WriteLocalAllRules(ruleFileStream);
2010-11-12 00:02:07 +03:00
// only write local targets unless at the top Keep track of targets already
// listed.
std::set<std::string> emittedTargets;
if (!this->GetMakefile()->IsRootMakefile())
{
// 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);
gg->WriteConvenienceRules(ruleFileStream,emittedTargets);
}
bool do_preprocess_rules =
this->GetCreatePreprocessedSourceRules();
bool do_assembly_rules =
this->GetCreateAssemblySourceRules();
std::map<std::string, LocalObjectInfo> localObjectFiles;
this->GetLocalObjectFiles(localObjectFiles);
// now write out the object rules
// for each object file name
for (std::map<std::string, LocalObjectInfo>::iterator lo =
localObjectFiles.begin();
lo != localObjectFiles.end(); ++lo)
{
// Add a convenience rule for building the object file.
this->WriteObjectConvenienceRule(ruleFileStream,
"target to build an object file",
lo->first.c_str(), lo->second);
// Check whether preprocessing and assembly rules make sense.
// They make sense only for C and C++ sources.
bool lang_has_preprocessor = false;
bool lang_has_assembly = false;
for(std::vector<LocalObjectEntry>::const_iterator ei =
lo->second.begin(); ei != lo->second.end(); ++ei)
{
if(ei->Language == "C" ||
ei->Language == "CXX" ||
ei->Language == "Fortran")
{
// Right now, C, C++ and Fortran have both a preprocessor and the
// ability to generate assembly code
lang_has_preprocessor = true;
lang_has_assembly = true;
break;
}
}
// Add convenience rules for preprocessed and assembly files.
if(lang_has_preprocessor && do_preprocess_rules)
{
std::string::size_type dot_pos = lo->first.rfind(".");
std::string base = lo->first.substr(0, dot_pos);
this->WriteObjectConvenienceRule(
ruleFileStream, "target to preprocess a source file",
(base + ".i").c_str(), lo->second);
lo->second.HasPreprocessRule = true;
}
if(lang_has_assembly && do_assembly_rules)
{
std::string::size_type dot_pos = lo->first.rfind(".");
std::string base = lo->first.substr(0, dot_pos);
this->WriteObjectConvenienceRule(
ruleFileStream, "target to generate assembly for a file",
(base + ".s").c_str(), lo->second);
lo->second.HasAssembleRule = true;
}
}
// 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);
gg->WriteHelpRule(ruleFileStream,this);
}
this->WriteSpecialTargetsBottom(ruleFileStream);
}
2005-05-06 22:49:38 +04:00
//----------------------------------------------------------------------------
void
cmLocalUnixMakefileGenerator3
::WriteObjectConvenienceRule(std::ostream& ruleFileStream,
const char* comment, const char* output,
LocalObjectInfo const& info)
{
// 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);
std::vector<std::string> no_commands;
this->WriteMakeRule(ruleFileStream, 0,
outNoExt, depends, no_commands, true, true);
inHelp = false;
}
// Recursively make the rule for each target using the object file.
std::vector<std::string> commands;
for(std::vector<LocalObjectEntry>::const_iterator t = info.begin();
t != info.end(); ++t)
{
std::string tgtMakefileName =
this->GetRelativeTargetDirectory(*(t->Target));
std::string targetName = tgtMakefileName;
tgtMakefileName += "/build.make";
targetName += "/";
targetName += output;
commands.push_back(
this->GetRecursiveMakeCall(tgtMakefileName.c_str(), targetName)
);
}
this->CreateCDCommand(commands,
this->Makefile->GetHomeOutputDirectory(),
cmLocalGenerator::START_OUTPUT);
// Write the rule to the makefile.
std::vector<std::string> no_depends;
this->WriteMakeRule(ruleFileStream, comment,
output, no_depends, commands, true, inHelp);
}
//----------------------------------------------------------------------------
void cmLocalUnixMakefileGenerator3
::WriteLocalMakefileTargets(std::ostream& ruleFileStream,
std::set<std::string> &emitted)
2005-05-05 20:45:53 +04: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
cmGeneratorTargetsType targets = this->Makefile->GetGeneratorTargets();
std::string localName;
for(cmGeneratorTargetsType::iterator t = targets.begin();
t != targets.end(); ++t)
2005-05-05 20:45:53 +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::UTILITY))
2005-05-05 20:45:53 +04:00
{
if (t->second->Target->IsImported())
{
continue;
}
emitted.insert(t->second->GetName());
// for subdirs add a rule to build this specific target by name.
localName = this->GetRelativeTargetDirectory(*t->second->Target);
localName += "/rule";
commands.clear();
depends.clear();
2010-11-12 00:02:07 +03:00
// Build the target for this pass.
std::string makefile2 = cmake::GetCMakeFilesDirectoryPostSlash();
makefile2 += "Makefile2";
commands.push_back(this->GetRecursiveMakeCall
(makefile2.c_str(),localName));
this->CreateCDCommand(commands,
2006-03-15 19:02:08 +03:00
this->Makefile->GetHomeOutputDirectory(),
cmLocalGenerator::START_OUTPUT);
this->WriteMakeRule(ruleFileStream, "Convenience name for target.",
localName, depends, commands, true);
2010-11-12 00:02:07 +03:00
// Add a target with the canonical name (no prefix, suffix or path).
if(localName != t->second->GetName())
{
commands.clear();
depends.push_back(localName);
this->WriteMakeRule(ruleFileStream, "Convenience name for target.",
t->second->GetName(), depends, commands, true);
}
// Add a fast rule to build the target
std::string makefileName =
this->GetRelativeTargetDirectory(*t->second->Target);
makefileName += "/build.make";
// make sure the makefile name is suitable for a makefile
2010-11-12 00:02:07 +03:00
std::string makeTargetName =
this->GetRelativeTargetDirectory(*t->second->Target);
makeTargetName += "/build";
localName = t->second->GetName();
localName += "/fast";
depends.clear();
commands.clear();
commands.push_back(this->GetRecursiveMakeCall
(makefileName.c_str(), makeTargetName));
this->CreateCDCommand(commands,
this->Makefile->GetHomeOutputDirectory(),
cmLocalGenerator::START_OUTPUT);
this->WriteMakeRule(ruleFileStream, "fast build rule for target.",
localName, depends, commands, true);
// Add a local name for the rule to relink the target before
// installation.
if(t->second->Target
->NeedRelinkBeforeInstall(this->ConfigName))
{
makeTargetName = this->GetRelativeTargetDirectory(*t->second->Target);
makeTargetName += "/preinstall";
localName = t->second->GetName();
localName += "/preinstall";
depends.clear();
commands.clear();
commands.push_back(this->GetRecursiveMakeCall
(makefile2.c_str(), makeTargetName));
this->CreateCDCommand(commands,
this->Makefile->GetHomeOutputDirectory(),
cmLocalGenerator::START_OUTPUT);
this->WriteMakeRule(ruleFileStream,
"Manual pre-install relink rule for target.",
localName, 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
{
std::string infoFileName = this->Makefile->GetCurrentBinaryDirectory();
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;
}
infoFileStream.SetCopyIfDifferent(true);
2005-05-05 20:45:53 +04:00
// Write the do not edit header.
this->WriteDisclaimer(infoFileStream);
// Setup relative path conversion tops.
infoFileStream
<< "# Relative path conversion top directories.\n"
<< "set(CMAKE_RELATIVE_PATH_TOP_SOURCE \""
<< this->StateSnapshot.GetDirectory().GetRelativePathTopSource()
<< "\")\n"
<< "set(CMAKE_RELATIVE_PATH_TOP_BINARY \""
<< this->StateSnapshot.GetDirectory().GetRelativePathTopBinary()
<< "\")\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"
<< "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
<< "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
<< "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
<< "set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN})\n";
2005-05-05 20:45:53 +04:00
infoFileStream
<< "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)
{
std::string dir = this->Makefile->GetCurrentBinaryDirectory();
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
}
//----------------------------------------------------------------------------
void
cmLocalUnixMakefileGenerator3
::WriteMakeRule(std::ostream& os,
const char* comment,
2014-02-07 02:31:47 +04:00
const std::string& target,
const std::vector<std::string>& depends,
const std::vector<std::string>& commands,
bool symbolic,
bool in_help)
2005-05-05 20:45:53 +04:00
{
// Make sure there is a target.
2014-02-07 02:31:47 +04:00
if(target.empty())
{
cmSystemTools::Error("No target for WriteMakeRule! called with comment: ",
comment);
return;
}
std::string replace;
// Write the comment describing the rule in the makefile.
if(comment)
{
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
{
os << "# " << replace.substr(lpos, rpos-lpos) << "\n";
lpos = rpos+1;
2005-05-05 20:45:53 +04:00
}
os << "# " << replace.substr(lpos) << "\n";
2005-05-05 20:45:53 +04:00
}
// Construct the left hand side of the rule.
std::string tgt = this->Convert(target, HOME_OUTPUT, MAKERULE);
const char* space = "";
if(tgt.size() == 1)
{
// Add a space before the ":" to avoid drive letter confusion on
// Windows.
space = " ";
}
// 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"))
{
os << cmMakeSafe(tgt) << space << ": " << sym << "\n";
}
}
// Write the rule.
if(depends.empty())
{
// No dependencies. The commands will always run.
os << cmMakeSafe(tgt) << space << ":\n";
}
else
2005-05-19 18:52:59 +04: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
{
replace = *dep;
replace = this->Convert(replace,HOME_OUTPUT,MAKERULE);
os << cmMakeSafe(tgt) << space << ": " << cmMakeSafe(replace) << "\n";
2005-12-27 23:33:47 +03:00
}
}
// Write the list of commands.
os << cmWrap("\t", commands, "", "\n") << "\n";
if(symbolic && !this->IsWatcomWMake())
2008-03-24 17:26:38 +03:00
{
os << ".PHONY : " << cmMakeSafe(tgt) << "\n";
2008-03-24 17:26:38 +03:00
}
os << "\n";
// Add the output to the local help if requested.
if(in_help)
{
this->LocalHelp.push_back(target);
}
}
//----------------------------------------------------------------------------
std::string
cmLocalUnixMakefileGenerator3
::ConvertShellCommand(std::string const& cmd, RelativeRoot root)
{
if(this->IsWatcomWMake() &&
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, scmd))
{
return this->Convert(scmd, NONE, SHELL);
}
}
return this->Convert(cmd, root, SHELL);
}
2005-05-05 20:45:53 +04:00
//----------------------------------------------------------------------------
void
cmLocalUnixMakefileGenerator3
::WriteMakeVariables(std::ostream& makefileStream)
2005-05-06 22:49:38 +04:00
{
this->WriteDivider(makefileStream);
makefileStream
<< "# Set environment variables for the build.\n"
<< "\n";
cmGlobalUnixMakefileGenerator3* gg =
static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator);
if(gg->DefineWindowsNULL)
2005-05-06 22:49:38 +04:00
{
makefileStream
<< "!IF \"$(OS)\" == \"Windows_NT\"\n"
<< "NULL=\n"
<< "!ELSE\n"
<< "NULL=nul\n"
<< "!ENDIF\n";
}
if(this->IsWindowsShell())
{
makefileStream
<< "SHELL = cmd.exe\n"
<< "\n";
}
2005-05-06 22:49:38 +04:00
else
{
#if !defined(__VMS)
makefileStream
<< "# The shell in which to execute make rules.\n"
<< "SHELL = /bin/sh\n"
<< "\n";
#endif
2005-05-06 22:49:38 +04:00
}
makefileStream
<< "# The CMake executable.\n"
<< "CMAKE_COMMAND = "
<< this->ConvertShellCommand(cmSystemTools::GetCMakeCommand(), FULL)
<< "\n"
2005-05-06 22:49:38 +04:00
<< "\n";
makefileStream
<< "# The command to remove a file.\n"
<< "RM = "
<< this->ConvertShellCommand(cmSystemTools::GetCMakeCommand(), FULL)
2005-05-06 22:49:38 +04:00
<< " -E remove -f\n"
<< "\n";
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"
<< "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";
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.",
".SUFFIXES", no_depends, no_commands, false);
if(!this->IsNMake()
&& !this->IsWatcomWMake() && !this->BorlandMakeCurlyHack)
{
// 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"
<< "SUFFIXES =\n\n";
}
// 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);
if(this->IsWatcomWMake())
{
// Switch on WMake feature, if an error or interrupt occurs during
// makefile processing, the current target being made may be deleted
// without prompting (the same as command line -e option).
makefileStream <<
"\n"
".ERASE\n"
"\n"
;
}
if(this->Makefile->IsOn("CMAKE_VERBOSE_MAKEFILE"))
{
makefileStream
<< "# Produce verbose output by default.\n"
<< "VERBOSE = 1\n"
<< "\n";
}
if(this->IsWatcomWMake())
{
makefileStream <<
"!ifndef VERBOSE\n"
".SILENT\n"
"!endif\n"
"\n"
;
}
else
{
// 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.
this->WriteMakeRule(makefileStream,
"Suppress display of executed commands.",
"$(VERBOSE).SILENT",
no_depends,
no_commands, false);
}
// Work-around for makes that drop rules that have no dependencies
// or commands.
cmGlobalUnixMakefileGenerator3* gg =
static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator);
std::string hack = gg->GetEmptyRuleHackDepends();
if(!hack.empty())
{
no_depends.push_back(hack);
}
std::string hack_cmd = gg->GetEmptyRuleHackCommand();
if(!hack_cmd.empty())
{
no_commands.push_back(hack_cmd);
}
// 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);
// 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.
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 ";
runRule += this->Convert(cmakefileName,NONE,SHELL);
runRule += " 0";
2005-05-05 20:45:53 +04:00
std::vector<std::string> no_depends;
std::vector<std::string> commands;
commands.push_back(runRule);
if(!this->GetMakefile()->IsRootMakefile())
{
this->CreateCDCommand(commands,
2006-03-15 19:02:08 +03:00
this->Makefile->GetHomeOutputDirectory(),
cmLocalGenerator::START_OUTPUT);
}
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,
commands, true);
2005-05-05 20:45:53 +04:00
}
}
//----------------------------------------------------------------------------
void
cmLocalUnixMakefileGenerator3
::WriteConvenienceRule(std::ostream& ruleFileStream,
2014-02-07 02:31:47 +04:00
const std::string& realTarget,
const std::string& helpTarget)
2005-05-05 20:45:53 +04:00
{
// A rule is only needed if the names are different.
2014-02-07 02:31:47 +04:00
if(realTarget != helpTarget)
2005-05-05 20:45:53 +04:00
{
// 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.",
helpTarget, depends, no_commands, true);
2005-05-05 20:45:53 +04:00
}
}
2005-05-11 16:45:16 +04:00
//----------------------------------------------------------------------------
std::string
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;
dir += this->GetTargetDirectory(target);
return this->Convert(dir,NONE,UNCHANGED);
}
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 std::string& newFlags)
2007-05-10 22:43:55 +04:00
{
if(this->IsWatcomWMake() && !newFlags.empty())
2007-05-10 22:43:55 +04:00
{
std::string newf = newFlags;
if(newf.find("\\\"") != newf.npos)
{
cmSystemTools::ReplaceString(newf, "\\\"", "\"");
this->cmLocalGenerator::AppendFlags(flags, newf);
2007-05-10 22:43:55 +04:00
return;
}
}
this->cmLocalGenerator::AppendFlags(flags, newFlags);
}
//----------------------------------------------------------------------------
void cmLocalUnixMakefileGenerator3::AppendFlags(std::string& flags,
const char* newFlags)
{
this->cmLocalGenerator::AppendFlags(flags, newFlags);
}
//----------------------------------------------------------------------------
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");
if(!nodep || cmSystemTools::IsOff(nodep))
2005-05-11 16:45:16 +04:00
{
depends.push_back(ruleFileName);
2005-05-11 16:45:16 +04: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
::AppendCustomDepends(std::vector<std::string>& depends,
const std::vector<cmCustomCommand>& ccs)
2005-05-05 20:45:53 +04:00
{
for(std::vector<cmCustomCommand>::const_iterator i = ccs.begin();
i != ccs.end(); ++i)
2005-05-05 20:45:53 +04:00
{
cmCustomCommandGenerator ccg(*i, this->ConfigName, this);
this->AppendCustomDepend(depends, ccg);
2005-05-05 20:45:53 +04:00
}
}
2005-05-05 20:45:53 +04:00
//----------------------------------------------------------------------------
void
cmLocalUnixMakefileGenerator3
::AppendCustomDepend(std::vector<std::string>& depends,
cmCustomCommandGenerator const& ccg)
{
for(std::vector<std::string>::const_iterator d = ccg.GetDepends().begin();
d != ccg.GetDepends().end(); ++d)
{
// Lookup the real name of the dependency in case it is a CMake target.
std::string dep;
if(this->GetRealDependency(*d, this->ConfigName,
dep))
{
depends.push_back(dep);
}
}
}
//----------------------------------------------------------------------------
void
cmLocalUnixMakefileGenerator3
::AppendCustomCommands(std::vector<std::string>& commands,
const std::vector<cmCustomCommand>& ccs,
cmTarget* target,
cmLocalGenerator::RelativeRoot relative)
{
for(std::vector<cmCustomCommand>::const_iterator i = ccs.begin();
i != ccs.end(); ++i)
2005-05-05 20:45:53 +04:00
{
cmCustomCommandGenerator ccg(*i, this->ConfigName, this);
this->AppendCustomCommand(commands, ccg, target, true, relative);
2005-05-05 20:45:53 +04:00
}
}
//----------------------------------------------------------------------------
void
cmLocalUnixMakefileGenerator3
::AppendCustomCommand(std::vector<std::string>& commands,
cmCustomCommandGenerator const& ccg,
cmTarget* target,
bool echo_comment,
cmLocalGenerator::RelativeRoot relative,
std::ostream* content)
2005-05-05 20:45:53 +04: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 = ccg.GetComment();
if(comment && *comment)
{
this->AppendEcho(commands, comment,
cmLocalUnixMakefileGenerator3::EchoGenerate);
}
}
// if the command specified a working directory use it.
std::string dir = this->Makefile->GetCurrentBinaryDirectory();
std::string workingDir = ccg.GetWorkingDirectory();
if(!workingDir.empty())
{
dir = workingDir;
}
if(content)
{
*content << dir;
}
2005-05-05 20:45:53 +04:00
// Add each command line to the set of commands.
std::vector<std::string> commands1;
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.
std::string cmd = ccg.GetCommand(c);
if (!cmd.empty())
2005-05-05 20:45:53 +04:00
{
// Use "call " before any invocations of .bat or .cmd files
// invoked as custom commands in the WindowsShell.
//
bool useCall = false;
if (this->IsWindowsShell())
{
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, "/./", "/");
// Convert the command to a relative path only if the current
// working directory will be the start-output directory.
bool had_slash = cmd.find("/") != cmd.npos;
if(workingDir.empty())
{
cmd = this->Convert(cmd,START_OUTPUT);
}
bool has_slash = cmd.find("/") != cmd.npos;
if(had_slash && !has_slash)
2005-05-20 20:09:33 +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;
}
std::string launcher =
this->MakeLauncher(ccg, target,
workingDir.empty()? START_OUTPUT : NONE);
cmd = launcher + this->ConvertShellCommand(cmd, NONE);
ccg.AppendArguments(c, cmd);
if(content)
{
// Rule content does not include the launcher.
*content << (cmd.c_str()+launcher.size());
}
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;
}
}
}
if (launcher.empty())
{
if (useCall)
{
cmd = "call " + cmd;
}
else if (this->IsNMake() && cmd[0]=='"')
{
cmd = "echo >nul && " + cmd;
}
}
2005-05-20 20:09:33 +04:00
commands1.push_back(cmd);
2005-05-05 20:45:53 +04:00
}
}
// Setup the proper working directory for the commands.
this->CreateCDCommand(commands1, dir.c_str(), relative);
// push back the custom commands
commands.insert(commands.end(), commands1.begin(), commands1.end());
2005-05-05 20:45:53 +04:00
}
//----------------------------------------------------------------------------
std::string
cmLocalUnixMakefileGenerator3::MakeLauncher(
cmCustomCommandGenerator const& ccg,
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;
std::string output;
const std::vector<std::string>& outputs = ccg.GetOutputs();
if(!outputs.empty())
{
output = this->Convert(outputs[0], relative, SHELL);
}
vars.Output = output.c_str();
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,
const std::vector<std::string>& files,
cmTarget& target, const char* filename)
2005-05-05 20:45:53 +04:00
{
std::string cleanfile = this->Makefile->GetCurrentBinaryDirectory();
cleanfile += "/";
cleanfile += this->GetTargetDirectory(target);
cleanfile += "/cmake_clean";
if(filename)
{
cleanfile += "_";
cleanfile += filename;
}
cleanfile += ".cmake";
std::string cleanfilePath = this->Convert(cleanfile, FULL);
cmsys::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())
{
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)
{
std::string fc = this->Convert(*f,START_OUTPUT,UNCHANGED);
fout << " " << cmOutputConverter::EscapeForCMake(fc) << "\n";
2005-05-05 20:45:53 +04:00
}
fout << ")\n";
}
std::string remove = "$(CMAKE_COMMAND) -P ";
remove += this->Convert(cleanfile, START_OUTPUT, SHELL);
commands.push_back(remove);
// For the main clean rule add per-language cleaning.
if(!filename)
{
// Get the set of source languages in the target.
std::set<std::string> languages;
target.GetLanguages(languages,
this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"));
fout << "\n"
<< "# Per-language clean rules from dependency scanning.\n"
2015-02-12 22:53:43 +03:00
<< "foreach(lang " << cmJoin(languages, " ") << ")\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,
std::string const& text,
EchoColor color,
EchoProgress const* progress)
2005-05-05 20:45:53 +04:00
{
// Choose the color for the text.
std::string color_name;
if(this->GlobalGenerator->GetToolSupportsColor() && this->ColorMakefile)
{
// See cmake::ExecuteEchoColor in cmake.cxx for these options.
// This color set is readable on both black and white backgrounds.
switch(color)
{
case EchoNormal:
break;
case EchoDepend:
color_name = "--magenta --bold ";
break;
case EchoBuild:
color_name = "--green ";
break;
case EchoLink:
color_name = "--green --bold ";
break;
case EchoGenerate:
color_name = "--blue --bold ";
break;
case EchoGlobal:
color_name = "--cyan ";
break;
}
}
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);
for(const char* c = text.c_str();; ++c)
2005-05-05 20:45:53 +04:00
{
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.
std::string cmd;
if(color_name.empty() && !progress)
2005-05-05 20:45:53 +04:00
{
// Use the native echo command.
cmd = "@echo ";
cmd += this->EscapeForShell(line, false, true);
2005-05-05 20:45:53 +04:00
}
else
2005-05-05 20:45:53 +04:00
{
// Use cmake to echo the text in color.
cmd = "@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) ";
cmd += color_name;
if (progress)
{
cmd += "--progress-dir=";
cmd += this->Convert(progress->Dir,
cmLocalGenerator::FULL,
cmLocalGenerator::SHELL);
cmd += " ";
cmd += "--progress-num=";
cmd += progress->Arg;
cmd += " ";
}
cmd += this->EscapeForShell(line);
2005-05-05 20:45:53 +04:00
}
commands.push_back(cmd);
}
// Reset the line to emtpy.
line = "";
// Progress appears only on first line.
progress = 0;
2005-05-05 20:45:53 +04:00
// 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 std::string& sin, const std::string& s2in)
2005-05-05 20:45:53 +04:00
{
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)
&& (!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
std::map<std::string, std::string>::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, ".", "_");
cmSystemTools::ReplaceString(ret, "-", "__");
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;
}
//----------------------------------------------------------------------------
bool cmLocalUnixMakefileGenerator3::UpdateDependencies(const char* tgtInfo,
bool verbose,
bool color)
{
// read in the target info file
if(!this->Makefile->ReadListFile(tgtInfo) ||
cmSystemTools::GetErrorOccuredFlag())
{
cmSystemTools::Error("Target DependInfo.cmake file not found");
}
// Check if any multiple output pairs have a missing file.
this->CheckMultipleOutputs(verbose);
std::string dir = cmSystemTools::GetFilenamePath(tgtInfo);
std::string internalDependFile = dir + "/depend.internal";
std::string dependFile = dir + "/depend.make";
// 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.
bool needRescanDependInfo = false;
cmFileTimeComparison* ftc =
this->GlobalGenerator->GetCMakeInstance()->GetFileComparison();
{
int result;
if(!ftc->FileTimeCompare(internalDependFile.c_str(), tgtInfo, &result) ||
result < 0)
{
if(verbose)
{
std::ostringstream msg;
msg << "Dependee \"" << tgtInfo
<< "\" is newer than depender \""
<< internalDependFile << "\"." << std::endl;
cmSystemTools::Stdout(msg.str().c_str());
}
needRescanDependInfo = true;
}
}
// 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->GetCurrentBinaryDirectory();
dirInfoFile += cmake::GetCMakeFilesDirectory();
dirInfoFile += "/CMakeDirectoryInformation.cmake";
{
int result;
2010-11-12 00:02:07 +03:00
if(!ftc->FileTimeCompare(internalDependFile.c_str(),
dirInfoFile.c_str(), &result) || result < 0)
{
if(verbose)
{
std::ostringstream msg;
msg << "Dependee \"" << dirInfoFile
<< "\" is newer than depender \""
<< internalDependFile << "\"." << std::endl;
cmSystemTools::Stdout(msg.str().c_str());
}
needRescanDirInfo = true;
}
}
2010-11-12 00:02:07 +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.
std::map<std::string, cmDepends::DependencyVector> validDependencies;
bool needRescanDependencies = false;
if (needRescanDirInfo == false)
{
cmDependsC checker;
checker.SetVerbose(verbose);
checker.SetFileComparison(ftc);
// 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
// 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
// few or one file have been edited, then also only this one file is
// actually scanned again, instead of all files for this target.
needRescanDependencies = !checker.Check(dependFile.c_str(),
internalDependFile.c_str(),
validDependencies);
}
if(needRescanDependInfo || needRescanDirInfo || needRescanDependencies)
{
// The dependencies must be regenerated.
std::string targetName = cmSystemTools::GetFilenameName(dir);
targetName = targetName.substr(0, targetName.length()-4);
std::string message = "Scanning dependencies of target ";
message += targetName;
cmSystemTools::MakefileColorEcho(
cmsysTerminal_Color_ForegroundMagenta |
cmsysTerminal_Color_ForegroundBold,
message.c_str(), true, color);
return this->ScanDependencies(dir.c_str(), validDependencies);
}
2009-09-30 19:46:42 +04:00
// The dependencies are already up-to-date.
return true;
}
2005-05-05 20:45:53 +04:00
//----------------------------------------------------------------------------
bool
cmLocalUnixMakefileGenerator3
::ScanDependencies(const char* targetDir,
std::map<std::string, cmDepends::DependencyVector>& validDeps)
2005-05-05 20:45:53 +04:00
{
// Read the directory information file.
cmMakefile* mf = this->Makefile;
2005-05-05 20:45:53 +04:00
bool haveDirectoryInfo = false;
std::string dirInfoFile = this->Makefile->GetCurrentBinaryDirectory();
dirInfoFile += cmake::GetCMakeFilesDirectory();
dirInfoFile += "/CMakeDirectoryInformation.cmake";
if(mf->ReadListFile(dirInfoFile.c_str()) &&
2005-05-05 20:45:53 +04:00
!cmSystemTools::GetErrorOccuredFlag())
{
haveDirectoryInfo = true;
}
2010-11-12 00:02:07 +03:00
// Lookup useful directory information.
2005-05-05 20:45:53 +04:00
if(haveDirectoryInfo)
{
// 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);
}
}
// Setup relative path top directories.
if(const char* relativePathTopSource =
mf->GetDefinition("CMAKE_RELATIVE_PATH_TOP_SOURCE"))
{
this->StateSnapshot.GetDirectory()
.SetRelativePathTopSource(relativePathTopSource);
}
if(const char* relativePathTopBinary =
mf->GetDefinition("CMAKE_RELATIVE_PATH_TOP_BINARY"))
{
this->StateSnapshot.GetDirectory()
.SetRelativePathTopBinary(relativePathTopBinary);
}
2005-05-05 20:45:53 +04:00
}
else
{
cmSystemTools::Error("Directory Information file not found");
}
2005-05-05 20:45:53 +04:00
// create the file stream for the depends file
std::string dir = targetDir;
// Open the make depends file. This should be copy-if-different
// because the make tool may try to reload it needlessly otherwise.
std::string ruleFileNameFull = dir;
ruleFileNameFull += "/depend.make";
cmGeneratedFileStream ruleFileStream(ruleFileNameFull.c_str());
ruleFileStream.SetCopyIfDifferent(true);
if(!ruleFileStream)
2005-05-05 20:45:53 +04:00
{
return false;
}
// 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.
std::string internalRuleFileNameFull = dir;
internalRuleFileNameFull += "/depend.internal";
cmGeneratedFileStream
2006-05-15 18:19:57 +04:00
internalRuleFileStream(internalRuleFileNameFull.c_str());
if(!internalRuleFileStream)
{
return false;
}
this->WriteDisclaimer(ruleFileStream);
this->WriteDisclaimer(internalRuleFileStream);
2010-11-12 00:02:07 +03:00
// for each language we need to scan, scan it
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 =
langs.begin(); li != langs.end(); ++li)
{
// construct the checker
std::string lang = *li;
// Create the scanner for this language
cmDepends *scanner = 0;
if(lang == "C" || lang == "CXX" || lang == "RC" || lang == "ASM")
2005-05-05 20:45:53 +04:00
{
// TODO: Handle RC (resource files) dependencies correctly.
scanner = new cmDependsC(this, targetDir, lang, &validDeps);
2005-05-05 20:45:53 +04:00
}
#ifdef CMAKE_BUILD_WITH_CMAKE
else if(lang == "Fortran")
{
scanner = new cmDependsFortran(this);
}
else if(lang == "Java")
{
scanner = new cmDependsJava();
}
2005-05-05 20:45:53 +04:00
#endif
2010-11-12 00:02:07 +03:00
if (scanner)
{
scanner->SetLocalGenerator(this);
2006-05-15 18:19:57 +04:00
scanner->SetFileComparison
(this->GlobalGenerator->GetCMakeInstance()->GetFileComparison());
scanner->SetLanguage(lang);
scanner->SetTargetDirectory(dir.c_str());
scanner->Write(ruleFileStream, internalRuleFileStream);
// free the scanner for this language
delete scanner;
}
}
return true;
2005-05-05 20:45:53 +04: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();
i != pairs.end() && (i+1) != pairs.end();)
{
const std::string& depender = *i++;
const std::string& dependee = *i++;
// 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)
{
std::ostringstream msg;
msg << "Deleting primary custom command output \"" << dependee
<< "\" because another output \""
<< depender << "\" does not exist." << std::endl;
cmSystemTools::Stdout(msg.str().c_str());
}
cmSystemTools::RemoveFile(dependee);
}
}
}
2005-05-11 16:45:16 +04:00
//----------------------------------------------------------------------------
void cmLocalUnixMakefileGenerator3
::WriteLocalAllRules(std::ostream& ruleFileStream)
2005-05-11 16:45:16 +04:00
{
this->WriteDisclaimer(ruleFileStream);
// 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);
// Help out users that try "gmake target1 target2 -j".
cmGlobalUnixMakefileGenerator3* gg =
static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator);
if(gg->AllowNotParallel())
{
std::vector<std::string> no_depends;
this->WriteMakeRule(ruleFileStream,
"Allow only one \"make -f Makefile2\" at a time, but pass parallelism.",
".NOTPARALLEL", no_depends, no_commands, false);
}
}
this->WriteSpecialTargetsTop(ruleFileStream);
// Include the progress variables for the target.
2006-02-23 18:07:24 +03:00
// Write all global targets
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-23 18:07:24 +03:00
if ( glIt->second.GetType() == cmTarget::GLOBAL_TARGET )
{
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 ...";
}
depends.insert(depends.end(), glIt->second.GetUtilities().begin(),
glIt->second.GetUtilities().end());
this->AppendEcho(commands, text,
cmLocalUnixMakefileGenerator3::EchoGlobal);
2006-02-23 18:07:24 +03: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,
glIt->second.GetPreBuildCommands(),
&glIt->second,
cmLocalGenerator::START_OUTPUT);
2010-11-12 00:02:07 +03:00
this->AppendCustomCommands(commands,
glIt->second.GetPostBuildCommands(),
&glIt->second,
cmLocalGenerator::START_OUTPUT);
std::string targetName = glIt->second.GetName();
2010-11-12 00:02:07 +03:00
this->WriteMakeRule(ruleFileStream, targetString.c_str(),
targetName, depends, commands, true);
// Provide a "/fast" version of the target.
depends.clear();
2010-11-12 00:02:07 +03:00
if((targetName == "install")
|| (targetName == "install_local")
|| (targetName == "install_strip"))
{
// 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, depends, commands, true);
}
}
2005-05-11 16:45:16 +04:00
std::vector<std::string> depends;
std::vector<std::string> commands;
2005-05-25 23:09:06 +04:00
// Write the all rule.
std::string recursiveTarget = this->Makefile->GetCurrentBinaryDirectory();
recursiveTarget += "/all";
2006-03-15 19:02:08 +03:00
depends.push_back("cmake_check_build_system");
2006-03-15 19:02:08 +03:00
std::string progressDir = this->Makefile->GetHomeOutputDirectory();
progressDir += cmake::GetCMakeFilesDirectory();
{
std::ostringstream progCmd;
2010-11-12 00:02:07 +03:00
progCmd <<
"$(CMAKE_COMMAND) -E cmake_progress_start ";
progCmd << this->Convert(progressDir,
2006-06-27 22:26:35 +04:00
cmLocalGenerator::FULL,
cmLocalGenerator::SHELL);
std::string progressFile = cmake::GetCMakeFilesDirectory();
progressFile += "/progress.marks";
std::string progressFileNameFull =
this->ConvertToFullPath(progressFile);
progCmd << " " << this->Convert(progressFileNameFull,
cmLocalGenerator::FULL,
cmLocalGenerator::SHELL);
2006-06-27 22:26:35 +04:00
commands.push_back(progCmd.str());
}
std::string mf2Dir = cmake::GetCMakeFilesDirectoryPostSlash();
mf2Dir += "Makefile2";
2006-06-15 19:51:51 +04:00
commands.push_back(this->GetRecursiveMakeCall(mf2Dir.c_str(),
recursiveTarget));
2006-01-30 21:57:01 +03:00
this->CreateCDCommand(commands,
this->Makefile->GetHomeOutputDirectory(),
cmLocalGenerator::START_OUTPUT);
2006-05-23 17:11:46 +04:00
{
std::ostringstream progCmd;
progCmd << "$(CMAKE_COMMAND) -E cmake_progress_start "; // # 0
progCmd << this->Convert(progressDir,
cmLocalGenerator::FULL,
cmLocalGenerator::SHELL);
progCmd << " 0";
2006-05-23 17:11:46 +04:00
commands.push_back(progCmd.str());
}
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.
recursiveTarget = this->Makefile->GetCurrentBinaryDirectory();
recursiveTarget += "/clean";
2005-05-25 23:09:06 +04:00
commands.clear();
depends.clear();
2006-06-15 19:51:51 +04:00
commands.push_back(this->GetRecursiveMakeCall(mf2Dir.c_str(),
recursiveTarget));
2006-01-30 21:57:01 +03:00
this->CreateCDCommand(commands,
2006-03-15 19:02:08 +03:00
this->Makefile->GetHomeOutputDirectory(),
cmLocalGenerator::START_OUTPUT);
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
// Write the preinstall rule.
recursiveTarget = this->Makefile->GetCurrentBinaryDirectory();
recursiveTarget += "/preinstall";
commands.clear();
depends.clear();
const char* noall =
2006-03-15 19:02:08 +03:00
this->Makefile->GetDefinition("CMAKE_SKIP_INSTALL_ALL_DEPENDENCY");
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
(this->GetRecursiveMakeCall(mf2Dir.c_str(), recursiveTarget));
this->CreateCDCommand(commands,
2006-03-15 19:02:08 +03:00
this->Makefile->GetHomeOutputDirectory(),
cmLocalGenerator::START_OUTPUT);
this->WriteMakeRule(ruleFileStream, "Prepare targets for installation.",
"preinstall", depends, commands, true);
depends.clear();
2006-05-02 21:31:56 +04:00
this->WriteMakeRule(ruleFileStream, "Prepare targets for installation.",
"preinstall/fast", depends, commands, true);
// write the depend rule, really a recompute depends rule
depends.clear();
commands.clear();
std::string cmakefileName = cmake::GetCMakeFilesDirectoryPostSlash();
cmakefileName += "Makefile.cmake";
std::string runRule =
"$(CMAKE_COMMAND) -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)";
runRule += " --check-build-system ";
runRule += this->Convert(cmakefileName,cmLocalGenerator::NONE,
cmLocalGenerator::SHELL);
runRule += " 1";
commands.push_back(runRule);
this->CreateCDCommand(commands,
this->Makefile->GetHomeOutputDirectory(),
cmLocalGenerator::START_OUTPUT);
2010-11-12 00:02:07 +03:00
this->WriteMakeRule(ruleFileStream, "clear depends",
"depend",
depends, commands, true);
}
//----------------------------------------------------------------------------
void cmLocalUnixMakefileGenerator3::ClearDependencies(cmMakefile* mf,
bool verbose)
{
// Get the list of target files to check
const char* infoDef = mf->GetDefinition("CMAKE_DEPEND_INFO_FILES");
if(!infoDef)
{
return;
}
std::vector<std::string> files;
cmSystemTools::ExpandListArgument(infoDef, files);
// Each depend information file corresponds to a target. Clear the
// dependencies for that target.
cmDepends clearer;
clearer.SetVerbose(verbose);
for(std::vector<std::string>::iterator l = files.begin();
l != files.end(); ++l)
2005-10-21 00:37:37 +04:00
{
std::string dir = cmSystemTools::GetFilenamePath(*l);
// Clear the implicit dependency makefile.
std::string dependFile = dir + "/depend.make";
clearer.Clear(dependFile.c_str());
// Remove the internal dependency check file to force
// regeneration.
std::string internalDependFile = dir + "/depend.internal";
cmSystemTools::RemoveFile(internalDependFile);
}
}
void cmLocalUnixMakefileGenerator3
::WriteDependLanguageInfo(std::ostream& cmakefileStream, cmTarget &target)
{
ImplicitDependLanguageMap const& implicitLangs =
this->GetImplicitDepends(target);
// list the languages
cmakefileStream
<< "# The set of languages for which implicit dependencies are needed:\n";
cmakefileStream
<< "set(CMAKE_DEPENDS_LANGUAGES\n";
for(ImplicitDependLanguageMap::const_iterator
l = implicitLangs.begin(); l != implicitLangs.end(); ++l)
{
cmakefileStream << " \"" << l->first << "\"\n";
}
cmakefileStream << " )\n";
// now list the files for each language
cmakefileStream
<< "# The set of files for implicit dependencies of each language:\n";
for(ImplicitDependLanguageMap::const_iterator
l = implicitLangs.begin(); l != implicitLangs.end(); ++l)
{
cmakefileStream
<< "set(CMAKE_DEPENDS_CHECK_" << l->first << "\n";
ImplicitDependFileMap const& implicitPairs = l->second;
// for each file pair
for(ImplicitDependFileMap::const_iterator pi = implicitPairs.begin();
pi != implicitPairs.end(); ++pi)
{
for(cmDepends::DependencyVector::const_iterator di = pi->second.begin();
di != pi->second.end(); ++ di)
{
cmakefileStream << " \"" << *di << "\" ";
cmakefileStream << "\"" << pi->first << "\"\n";
}
}
cmakefileStream << " )\n";
// 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);
if(cid && *cid)
{
cmakefileStream
<< "set(CMAKE_" << l->first << "_COMPILER_ID \""
<< cid << "\")\n";
}
// Build a list of preprocessor definitions for the target.
std::set<std::string> defines;
this->AddCompileDefinitions(defines, &target,
this->ConfigName, l->first);
if(!defines.empty())
{
cmakefileStream
<< "\n"
<< "# Preprocessor definitions for this target.\n"
<< "set(CMAKE_TARGET_DEFINITIONS_" << l->first << "\n";
for(std::set<std::string>::const_iterator di = defines.begin();
di != defines.end(); ++di)
{
cmakefileStream
<< " " << cmOutputConverter::EscapeForCMake(*di) << "\n";
}
cmakefileStream
<< " )\n";
}
// Target-specific include directories:
cmakefileStream
<< "\n"
<< "# The include file search paths:\n";
cmakefileStream
<< "set(CMAKE_" << l->first << "_TARGET_INCLUDE_PATH\n";
std::vector<std::string> includes;
cmGeneratorTarget* gt = this->GetGlobalGenerator()
->GetGeneratorTarget(&target);
const std::string& config =
this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE");
this->GetIncludeDirectories(includes, gt,
l->first, config);
for(std::vector<std::string>::iterator i = includes.begin();
i != includes.end(); ++i)
{
cmakefileStream
<< " \""
<< this->Convert(*i, cmLocalGenerator::HOME_OUTPUT)
<< "\"\n";
}
cmakefileStream
<< " )\n";
}
// 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
<< "set(CMAKE_INCLUDE_TRANSFORMS\n";
for(std::vector<std::string>::const_iterator tri = transformRules.begin();
tri != transformRules.end(); ++tri)
{
cmakefileStream << " "
<< cmOutputConverter::EscapeForCMake(*tri) << "\n";
}
cmakefileStream
<< " )\n";
}
}
//----------------------------------------------------------------------------
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() << "\""
<< " Generator, CMake Version "
<< cmVersion::GetMajorVersion() << "."
<< cmVersion::GetMinorVersion() << "\n\n";
}
//----------------------------------------------------------------------------
std::string
cmLocalUnixMakefileGenerator3
2014-02-07 02:31:47 +04:00
::GetRecursiveMakeCall(const char *makefile, const std::string& tgt)
{
// Call make on the given file.
std::string cmd;
cmd += "$(MAKE) -f ";
cmd += this->Convert(makefile,NONE,SHELL);
cmd += " ";
2010-11-12 00:02:07 +03:00
cmGlobalUnixMakefileGenerator3* gg =
static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator);
// Pass down verbosity level.
if(!gg->MakeSilentFlag.empty())
{
cmd += gg->MakeSilentFlag;
cmd += " ";
}
// Most unix makes will pass the command line flags to make down to
// sub-invoked makes via an environment variable. However, some
// makes do not support that, so you have to pass the flags
// explicitly.
if(gg->PassMakeflags)
{
cmd += "-$(MAKEFLAGS) ";
}
// Add the target.
2014-02-07 02:31:47 +04:00
if (!tgt.empty())
{
// 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);
// Escape one extra time if the make tool requires it.
if(this->MakeCommandEscapeTargetTwice)
{
tgt2 = this->EscapeForShell(tgt2, true, false);
}
// The target name is now a string that should be passed verbatim
// on the command line.
cmd += this->EscapeForShell(tgt2, true, false);
}
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 == '\\')
{
os << "\\\\";
}
else if(*c == '"')
{
os << "\\\"";
}
else
{
os << *c;
}
}
os << "\"";
}
//----------------------------------------------------------------------------
std::string
cmLocalUnixMakefileGenerator3::ConvertToQuotedOutputPath(const char* p,
bool useWatcomQuote)
{
// Split the path into its components.
std::vector<std::string> components;
cmSystemTools::SplitPath(p, components);
// Open the quoted result.
std::string result;
if(useWatcomQuote)
{
#if defined(_WIN32) && !defined(__CYGWIN__)
result = "'";
#else
result = "\"'";
#endif
}
else
{
result = "\"";
}
// Return an empty path if there are no components.
if(!components.empty())
{
// 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
// Begin the quoted result with the root component.
result += components[0];
2005-05-11 16:45:16 +04:00
if (components.size() > 1)
2005-05-11 16:45:16 +04:00
{
// Now add the rest of the components separated by the proper slash
// direction for this platform.
2015-01-24 20:07:37 +03:00
std::vector<std::string>::const_iterator compEnd
= std::remove(components.begin() + 1, components.end() - 1,
std::string());
std::vector<std::string>::const_iterator compStart
= components.begin() + 1;
result += cmJoin(cmMakeRange(compStart, compEnd), slash);
// Only the last component can be empty to avoid double slashes.
2015-01-23 03:06:40 +03:00
result += slash;
result += components.back();
2005-05-11 16:45:16 +04:00
}
}
// Close the quoted result.
if(useWatcomQuote)
{
#if defined(_WIN32) && !defined(__CYGWIN__)
result += "'";
#else
result += "'\"";
#endif
}
else
{
result += "\"";
}
return result;
}
//----------------------------------------------------------------------------
std::string
cmLocalUnixMakefileGenerator3
::GetTargetDirectory(cmTarget const& target) const
{
std::string dir = cmake::GetCMakeFilesDirectoryPostSlash();
dir += target.GetName();
#if defined(__VMS)
dir += "_dir";
#else
dir += ".dir";
#endif
return dir;
2005-05-11 16:45:16 +04:00
}
//----------------------------------------------------------------------------
cmLocalUnixMakefileGenerator3::ImplicitDependLanguageMap const&
cmLocalUnixMakefileGenerator3::GetImplicitDepends(cmTarget const& tgt)
{
return this->ImplicitDepends[tgt.GetName()];
}
//----------------------------------------------------------------------------
void
cmLocalUnixMakefileGenerator3::AddImplicitDepends(cmTarget const& tgt,
const std::string& lang,
const char* obj,
const char* src)
{
this->ImplicitDepends[tgt.GetName()][lang][obj].push_back(src);
}
//----------------------------------------------------------------------------
void cmLocalUnixMakefileGenerator3
::CreateCDCommand(std::vector<std::string>& commands, const char *tgtDir,
cmLocalGenerator::RelativeRoot relRetDir)
2005-05-11 16:45:16 +04:00
{
const char* retDir = this->GetRelativeRootPath(relRetDir);
// do we need to cd?
if (!strcmp(tgtDir,retDir))
{
return;
}
2010-11-12 00:02:07 +03: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->IsMinGWMake() ? "cd /d " : "cd ";
cmGlobalUnixMakefileGenerator3* gg =
static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator);
if(!gg->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.
std::string cmd = cd_cmd;
cmd += this->ConvertToOutputForExisting(tgtDir, relRetDir);
commands.insert(commands.begin(),cmd);
// Change back to the starting directory.
cmd = cd_cmd;
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.
2015-01-18 17:59:03 +03:00
std::string outputForExisting =
this->ConvertToOutputForExisting(tgtDir, relRetDir);
2015-01-25 17:07:27 +03:00
std::string prefix = cd_cmd + outputForExisting + " && ";
2015-01-18 18:01:54 +03:00
std::transform(commands.begin(), commands.end(), commands.begin(),
std::bind1st(std::plus<std::string>(), prefix));
2005-05-11 16:45:16 +04:00
}
}