CMake/Source/cmCustomCommandGenerator.cxx

180 lines
5.0 KiB
C++

/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2000-2010 Kitware, Inc., Insight Software Consortium
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
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.
============================================================================*/
#include "cmCustomCommandGenerator.h"
#include "cmCustomCommand.h"
#include "cmGeneratorExpression.h"
#include "cmLocalGenerator.h"
#include "cmMakefile.h"
#include "cmOutputConverter.h"
cmCustomCommandGenerator::cmCustomCommandGenerator(
cmCustomCommand const& cc, const std::string& config, cmLocalGenerator* lg):
CC(cc), Config(config), LG(lg),
OldStyle(cc.GetEscapeOldStyle()), MakeVars(cc.GetEscapeAllowMakeVars()),
GE(new cmGeneratorExpression(cc.GetBacktrace())), DependsDone(false)
{
}
cmCustomCommandGenerator::~cmCustomCommandGenerator()
{
delete this->GE;
}
unsigned int cmCustomCommandGenerator::GetNumberOfCommands() const
{
return static_cast<unsigned int>(this->CC.GetCommandLines().size());
}
bool cmCustomCommandGenerator::UseCrossCompilingEmulator(unsigned int c) const
{
std::string const& argv0 = this->CC.GetCommandLines()[c][0];
cmGeneratorTarget* target =
this->LG->FindGeneratorTargetToUse(argv0);
if(target && target->GetType() == cmState::EXECUTABLE)
{
return target->GetProperty("CROSSCOMPILING_EMULATOR") != 0;
}
return false;
}
std::string cmCustomCommandGenerator::GetCommand(unsigned int c) const
{
std::string const& argv0 = this->CC.GetCommandLines()[c][0];
cmGeneratorTarget* target =
this->LG->FindGeneratorTargetToUse(argv0);
if(target && target->GetType() == cmState::EXECUTABLE &&
(target->IsImported()
|| !this->LG->GetMakefile()->IsOn("CMAKE_CROSSCOMPILING")))
{
return target->GetLocation(this->Config);
}
if (target && target->GetType() == cmState::EXECUTABLE)
{
const char* emulator = target->GetProperty("CROSSCOMPILING_EMULATOR");
if (emulator)
{
return std::string(emulator);
}
}
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = this->GE->Parse(argv0);
std::string exe = cge->Evaluate(this->LG, this->Config);
return exe;
}
std::string escapeForShellOldStyle(const std::string& str)
{
std::string result;
#if defined(_WIN32) && !defined(__CYGWIN__)
// if there are spaces
std::string temp = str;
if (temp.find(" ") != std::string::npos &&
temp.find("\"")==std::string::npos)
{
result = "\"";
result += str;
result += "\"";
return result;
}
return str;
#else
for(const char* ch = str.c_str(); *ch != '\0'; ++ch)
{
if(*ch == ' ')
{
result += '\\';
}
result += *ch;
}
return result;
#endif
}
void
cmCustomCommandGenerator
::AppendArguments(unsigned int c, std::string& cmd) const
{
unsigned int offset = 1;
if (this->UseCrossCompilingEmulator(c))
{
offset = 0;
}
cmCustomCommandLine const& commandLine = this->CC.GetCommandLines()[c];
for(unsigned int j=offset;j < commandLine.size(); ++j)
{
std::string arg =
this->GE->Parse(commandLine[j])->Evaluate(this->LG,
this->Config);
cmd += " ";
if(this->OldStyle)
{
cmd += escapeForShellOldStyle(arg);
}
else
{
cmOutputConverter converter(this->LG->GetStateSnapshot());
cmd += converter.EscapeForShell(arg, this->MakeVars);
}
}
}
const char* cmCustomCommandGenerator::GetComment() const
{
return this->CC.GetComment();
}
std::string cmCustomCommandGenerator::GetWorkingDirectory() const
{
return this->CC.GetWorkingDirectory();
}
std::vector<std::string> const& cmCustomCommandGenerator::GetOutputs() const
{
return this->CC.GetOutputs();
}
std::vector<std::string> const& cmCustomCommandGenerator::GetByproducts() const
{
return this->CC.GetByproducts();
}
std::vector<std::string> const& cmCustomCommandGenerator::GetDepends() const
{
if (!this->DependsDone)
{
this->DependsDone = true;
std::vector<std::string> depends = this->CC.GetDepends();
for(std::vector<std::string>::const_iterator
i = depends.begin();
i != depends.end(); ++i)
{
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge
= this->GE->Parse(*i);
std::vector<std::string> result;
cmSystemTools::ExpandListArgument(
cge->Evaluate(this->LG, this->Config), result);
for (std::vector<std::string>::iterator it = result.begin();
it != result.end(); ++it)
{
if (cmSystemTools::FileIsFullPath(it->c_str()))
{
*it = cmSystemTools::CollapseFullPath(*it);
}
}
this->Depends.insert(this->Depends.end(), result.begin(), result.end());
}
}
return this->Depends;
}