mirrors/cmake
2
0
Fork 0
mirror of https://gitlab.kitware.com/cmake/cmake.git synced 2026-09-25 04:09:36 +03:00
Code Activity

cmA*Command: Turn into free functions

Browse Source 
Ref: #19499
This commit is contained in:
Regina Pfeifer
2019-08-07 10:16:32 +02:00
parent 52d9cd624f
commit 9ba0bf60c6
25 changed files with 257 additions and 594 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Source/cmAddExecutableCommand.cxx
+28 -31
View File
@@ -4,22 +4,22 @@
#include <sstream>
#include "cmExecutionStatus.h"
#include "cmGeneratorExpression.h"
#include "cmGlobalGenerator.h"
#include "cmMakefile.h"
#include "cmStateTypes.h"
#include "cmTarget.h"
class cmExecutionStatus;
// cmExecutableCommand
bool cmAddExecutableCommand::InitialPass(std::vector<std::string> const& args,
cmExecutionStatus&)
bool cmAddExecutableCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.empty()) {
this->SetError("called with incorrect number of arguments");
status.SetError("called with incorrect number of arguments");
return false;
}
cmMakefile& mf = status.GetMakefile();
std::vector<std::string>::const_iterator s = args.begin();
std::string const& exename = *s;
@@ -61,59 +61,58 @@ bool cmAddExecutableCommand::InitialPass(std::vector<std::string> const& args,
if (nameOk && !importTarget && !isAlias) {
nameOk = exename.find(':') == std::string::npos;
}
if (!nameOk &&
!this->Makefile->CheckCMP0037(exename, cmStateEnums::EXECUTABLE)) {
if (!nameOk && !mf.CheckCMP0037(exename, cmStateEnums::EXECUTABLE)) {
return false;
}
// Special modifiers are not allowed with IMPORTED signature.
if (importTarget && (use_win32 || use_macbundle || excludeFromAll)) {
if (use_win32) {
this->SetError("may not be given WIN32 for an IMPORTED target.");
status.SetError("may not be given WIN32 for an IMPORTED target.");
} else if (use_macbundle) {
this->SetError("may not be given MACOSX_BUNDLE for an IMPORTED target.");
status.SetError(
"may not be given MACOSX_BUNDLE for an IMPORTED target.");
} else // if(excludeFromAll)
{
this->SetError(
status.SetError(
"may not be given EXCLUDE_FROM_ALL for an IMPORTED target.");
}
return false;
}
if (isAlias) {
if (!cmGeneratorExpression::IsValidTargetName(exename)) {
this->SetError("Invalid name for ALIAS: " + exename);
status.SetError("Invalid name for ALIAS: " + exename);
return false;
}
if (excludeFromAll) {
this->SetError("EXCLUDE_FROM_ALL with ALIAS makes no sense.");
status.SetError("EXCLUDE_FROM_ALL with ALIAS makes no sense.");
return false;
}
if (importTarget || importGlobal) {
this->SetError("IMPORTED with ALIAS is not allowed.");
status.SetError("IMPORTED with ALIAS is not allowed.");
return false;
}
if (args.size() != 3) {
std::ostringstream e;
e << "ALIAS requires exactly one target argument.";
this->SetError(e.str());
status.SetError(e.str());
return false;
}
std::string const& aliasedName = *s;
if (this->Makefile->IsAlias(aliasedName)) {
if (mf.IsAlias(aliasedName)) {
std::ostringstream e;
e << "cannot create ALIAS target \"" << exename << "\" because target \""
<< aliasedName << "\" is itself an ALIAS.";
this->SetError(e.str());
status.SetError(e.str());
return false;
}
cmTarget* aliasedTarget =
this->Makefile->FindTargetToUse(aliasedName, true);
cmTarget* aliasedTarget = mf.FindTargetToUse(aliasedName, true);
if (!aliasedTarget) {
std::ostringstream e;
e << "cannot create ALIAS target \"" << exename << "\" because target \""
<< aliasedName << "\" does not already exist.";
this->SetError(e.str());
status.SetError(e.str());
return false;
}
cmStateEnums::TargetType type = aliasedTarget->GetType();
@@ -121,7 +120,7 @@ bool cmAddExecutableCommand::InitialPass(std::vector<std::string> const& args,
std::ostringstream e;
e << "cannot create ALIAS target \"" << exename << "\" because target \""
<< aliasedName << "\" is not an executable.";
this->SetError(e.str());
status.SetError(e.str());
return false;
}
if (aliasedTarget->IsImported() &&
@@ -129,42 +128,40 @@ bool cmAddExecutableCommand::InitialPass(std::vector<std::string> const& args,
std::ostringstream e;
e << "cannot create ALIAS target \"" << exename << "\" because target \""
<< aliasedName << "\" is imported but not globally visible.";
this->SetError(e.str());
status.SetError(e.str());
return false;
}
this->Makefile->AddAlias(exename, aliasedName);
mf.AddAlias(exename, aliasedName);
return true;
}
// Handle imported target creation.
if (importTarget) {
// Make sure the target does not already exist.
if (this->Makefile->FindTargetToUse(exename)) {
if (mf.FindTargetToUse(exename)) {
std::ostringstream e;
e << "cannot create imported target \"" << exename
<< "\" because another target with the same name already exists.";
this->SetError(e.str());
status.SetError(e.str());
return false;
}
// Create the imported target.
this->Makefile->AddImportedTarget(exename, cmStateEnums::EXECUTABLE,
importGlobal);
mf.AddImportedTarget(exename, cmStateEnums::EXECUTABLE, importGlobal);
return true;
}
// Enforce name uniqueness.
{
std::string msg;
if (!this->Makefile->EnforceUniqueName(exename, msg)) {
this->SetError(msg);
if (!mf.EnforceUniqueName(exename, msg)) {
status.SetError(msg);
return false;
}
}
std::vector<std::string> srclists(s, args.end());
cmTarget* tgt =
this->Makefile->AddExecutable(exename, srclists, excludeFromAll);
cmTarget* tgt = mf.AddExecutable(exename, srclists, excludeFromAll);
if (use_win32) {
tgt->SetProperty("WIN32_EXECUTABLE", "ON");
}