From e0b7ff4af2a8f5a2c2f746c0976cd22367212c8a Mon Sep 17 00:00:00 2001 From: Gabor Bencze Date: Sun, 4 Aug 2019 14:42:52 +0200 Subject: [PATCH] cmCommand refactor: cmListCommand --- Source/cmCommands.cxx | 2 +- Source/cmListCommand.cxx | 415 ++++++++++++++++++++++----------------- Source/cmListCommand.h | 51 +---- 3 files changed, 244 insertions(+), 224 deletions(-) diff --git a/Source/cmCommands.cxx b/Source/cmCommands.cxx index 08bf1821e5..285c48ed60 100644 --- a/Source/cmCommands.cxx +++ b/Source/cmCommands.cxx @@ -144,7 +144,7 @@ void GetScriptingCommands(cmState* state) state->AddBuiltinCommand("if", cmIfCommand); state->AddBuiltinCommand("include", cmIncludeCommand); state->AddBuiltinCommand("include_guard", cmIncludeGuardCommand); - state->AddBuiltinCommand("list", cm::make_unique()); + state->AddBuiltinCommand("list", cmListCommand); state->AddBuiltinCommand("macro", cmMacroCommand); state->AddBuiltinCommand("make_directory", cm::make_unique()); diff --git a/Source/cmListCommand.cxx b/Source/cmListCommand.cxx index cbb1d3a72f..4db80cd400 100644 --- a/Source/cmListCommand.cxx +++ b/Source/cmListCommand.cxx @@ -18,6 +18,7 @@ #include "cm_memory.hxx" #include "cmAlgorithms.h" +#include "cmExecutionStatus.h" #include "cmGeneratorExpression.h" #include "cmMakefile.h" #include "cmMessageType.h" @@ -27,79 +28,124 @@ #include "cmStringReplaceHelper.h" #include "cmSystemTools.h" -class cmExecutionStatus; +namespace { +bool HandleLengthCommand(std::vector const& args, + cmExecutionStatus& status); +bool HandleGetCommand(std::vector const& args, + cmExecutionStatus& status); +bool HandleAppendCommand(std::vector const& args, + cmMakefile& makefile); +bool HandlePrependCommand(std::vector const& args, + cmMakefile& makefile); +bool HandlePopBackCommand(std::vector const& args, + cmMakefile& makefile); +bool HandlePopFrontCommand(std::vector const& args, + cmMakefile& makefile); +bool HandleFindCommand(std::vector const& args, + cmExecutionStatus& status); +bool HandleInsertCommand(std::vector const& args, + cmExecutionStatus& status); +bool HandleJoinCommand(std::vector const& args, + cmExecutionStatus& status); +bool HandleRemoveAtCommand(std::vector const& args, + cmExecutionStatus& status); +bool HandleRemoveItemCommand(std::vector const& args, + cmExecutionStatus& status); +bool HandleRemoveDuplicatesCommand(std::vector const& args, + cmExecutionStatus& status); +bool HandleTransformCommand(std::vector const& args, + cmExecutionStatus& status); +bool HandleSortCommand(std::vector const& args, + cmExecutionStatus& status); +bool HandleSublistCommand(std::vector const& args, + cmExecutionStatus& status); +bool HandleReverseCommand(std::vector const& args, + cmExecutionStatus& status); +bool HandleFilterCommand(std::vector const& args, + cmExecutionStatus& status); +bool FilterRegex(std::vector const& args, bool includeMatches, + std::string const& listName, + std::vector& varArgsExpanded, + cmExecutionStatus& status); -bool cmListCommand::InitialPass(std::vector const& args, - cmExecutionStatus&) +bool GetList(std::vector& list, const std::string& var, + const cmMakefile& makefile); +bool GetListString(std::string& listString, const std::string& var, + const cmMakefile& makefile); +} + +bool cmListCommand(std::vector const& args, + cmExecutionStatus& status) { if (args.size() < 2) { - this->SetError("must be called with at least two arguments."); + status.SetError("must be called with at least two arguments."); return false; } const std::string& subCommand = args[0]; if (subCommand == "LENGTH") { - return this->HandleLengthCommand(args); + return HandleLengthCommand(args, status); } if (subCommand == "GET") { - return this->HandleGetCommand(args); + return HandleGetCommand(args, status); } if (subCommand == "APPEND") { - return this->HandleAppendCommand(args); + return HandleAppendCommand(args, status.GetMakefile()); } if (subCommand == "PREPEND") { - return this->HandlePrependCommand(args); + return HandlePrependCommand(args, status.GetMakefile()); } if (subCommand == "POP_BACK") { - return this->HandlePopBackCommand(args); + return HandlePopBackCommand(args, status.GetMakefile()); } if (subCommand == "POP_FRONT") { - return this->HandlePopFrontCommand(args); + return HandlePopFrontCommand(args, status.GetMakefile()); } if (subCommand == "FIND") { - return this->HandleFindCommand(args); + return HandleFindCommand(args, status); } if (subCommand == "INSERT") { - return this->HandleInsertCommand(args); + return HandleInsertCommand(args, status); } if (subCommand == "JOIN") { - return this->HandleJoinCommand(args); + return HandleJoinCommand(args, status); } if (subCommand == "REMOVE_AT") { - return this->HandleRemoveAtCommand(args); + return HandleRemoveAtCommand(args, status); } if (subCommand == "REMOVE_ITEM") { - return this->HandleRemoveItemCommand(args); + return HandleRemoveItemCommand(args, status); } if (subCommand == "REMOVE_DUPLICATES") { - return this->HandleRemoveDuplicatesCommand(args); + return HandleRemoveDuplicatesCommand(args, status); } if (subCommand == "TRANSFORM") { - return this->HandleTransformCommand(args); + return HandleTransformCommand(args, status); } if (subCommand == "SORT") { - return this->HandleSortCommand(args); + return HandleSortCommand(args, status); } if (subCommand == "SUBLIST") { - return this->HandleSublistCommand(args); + return HandleSublistCommand(args, status); } if (subCommand == "REVERSE") { - return this->HandleReverseCommand(args); + return HandleReverseCommand(args, status); } if (subCommand == "FILTER") { - return this->HandleFilterCommand(args); + return HandleFilterCommand(args, status); } std::string e = "does not recognize sub-command " + subCommand; - this->SetError(e); + status.SetError(e); return false; } -bool cmListCommand::GetListString(std::string& listString, - const std::string& var) +namespace { +bool GetListString(std::string& listString, const std::string& var, + const cmMakefile& makefile) { // get the old value - const char* cacheValue = this->Makefile->GetDefinition(var); + const char* cacheValue = makefile.GetDefinition(var); if (!cacheValue) { return false; } @@ -107,11 +153,11 @@ bool cmListCommand::GetListString(std::string& listString, return true; } -bool cmListCommand::GetList(std::vector& list, - const std::string& var) +bool GetList(std::vector& list, const std::string& var, + const cmMakefile& makefile) { std::string listString; - if (!this->GetListString(listString, var)) { + if (!GetListString(listString, var, makefile)) { return false; } // if the size of the list @@ -125,7 +171,7 @@ bool cmListCommand::GetList(std::vector& list, return true; } // if we have empty elements we need to check policy CMP0007 - switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0007)) { + switch (makefile.GetPolicyStatus(cmPolicies::CMP0007)) { case cmPolicies::WARN: { // Default is to warn and use old behavior // OLD behavior is to allow compatibility, so recall @@ -137,7 +183,7 @@ bool cmListCommand::GetList(std::vector& list, warn += " List has value = ["; warn += listString; warn += "]."; - this->Makefile->IssueMessage(MessageType::AUTHOR_WARNING, warn); + makefile.IssueMessage(MessageType::AUTHOR_WARNING, warn); return true; } case cmPolicies::OLD: @@ -151,7 +197,7 @@ bool cmListCommand::GetList(std::vector& list, return true; case cmPolicies::REQUIRED_IF_USED: case cmPolicies::REQUIRED_ALWAYS: - this->Makefile->IssueMessage( + makefile.IssueMessage( MessageType::FATAL_ERROR, cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0007)); return false; @@ -159,10 +205,11 @@ bool cmListCommand::GetList(std::vector& list, return true; } -bool cmListCommand::HandleLengthCommand(std::vector const& args) +bool HandleLengthCommand(std::vector const& args, + cmExecutionStatus& status) { if (args.size() != 3) { - this->SetError("sub-command LENGTH requires two arguments."); + status.SetError("sub-command LENGTH requires two arguments."); return false; } @@ -172,19 +219,20 @@ bool cmListCommand::HandleLengthCommand(std::vector const& args) // do not check the return value here // if the list var is not found varArgsExpanded will have size 0 // and we will return 0 - this->GetList(varArgsExpanded, listName); + GetList(varArgsExpanded, listName, status.GetMakefile()); size_t length = varArgsExpanded.size(); char buffer[1024]; sprintf(buffer, "%d", static_cast(length)); - this->Makefile->AddDefinition(variableName, buffer); + status.GetMakefile().AddDefinition(variableName, buffer); return true; } -bool cmListCommand::HandleGetCommand(std::vector const& args) +bool HandleGetCommand(std::vector const& args, + cmExecutionStatus& status) { if (args.size() < 4) { - this->SetError("sub-command GET requires at least three arguments."); + status.SetError("sub-command GET requires at least three arguments."); return false; } @@ -192,13 +240,13 @@ bool cmListCommand::HandleGetCommand(std::vector const& args) const std::string& variableName = args.back(); // expand the variable std::vector varArgsExpanded; - if (!this->GetList(varArgsExpanded, listName)) { - this->Makefile->AddDefinition(variableName, "NOTFOUND"); + if (!GetList(varArgsExpanded, listName, status.GetMakefile())) { + status.GetMakefile().AddDefinition(variableName, "NOTFOUND"); return true; } // FIXME: Add policy to make non-existing lists an error like empty lists. if (varArgsExpanded.empty()) { - this->SetError("GET given empty list"); + status.SetError("GET given empty list"); return false; } @@ -217,17 +265,18 @@ bool cmListCommand::HandleGetCommand(std::vector const& args) std::ostringstream str; str << "index: " << item << " out of range (-" << nitem << ", " << nitem - 1 << ")"; - this->SetError(str.str()); + status.SetError(str.str()); return false; } value += varArgsExpanded[item]; } - this->Makefile->AddDefinition(variableName, value); + status.GetMakefile().AddDefinition(variableName, value); return true; } -bool cmListCommand::HandleAppendCommand(std::vector const& args) +bool HandleAppendCommand(std::vector const& args, + cmMakefile& makefile) { assert(args.size() >= 2); @@ -239,7 +288,7 @@ bool cmListCommand::HandleAppendCommand(std::vector const& args) std::string const& listName = args[1]; // expand the variable std::string listString; - this->GetListString(listString, listName); + GetListString(listString, listName, makefile); // If `listString` or `args` is empty, no need to append `;`, // then index is going to be `1` and points to the end-of-string ";" @@ -247,11 +296,12 @@ bool cmListCommand::HandleAppendCommand(std::vector const& args) std::string::size_type(listString.empty() || args.empty()); listString += &";"[offset] + cmJoin(cmMakeRange(args).advance(2), ";"); - this->Makefile->AddDefinition(listName, listString); + makefile.AddDefinition(listName, listString); return true; } -bool cmListCommand::HandlePrependCommand(std::vector const& args) +bool HandlePrependCommand(std::vector const& args, + cmMakefile& makefile) { assert(args.size() >= 2); @@ -263,7 +313,7 @@ bool cmListCommand::HandlePrependCommand(std::vector const& args) std::string const& listName = args[1]; // expand the variable std::string listString; - this->GetListString(listString, listName); + GetListString(listString, listName, makefile); // If `listString` or `args` is empty, no need to append `;`, // then `offset` is going to be `1` and points to the end-of-string ";" @@ -272,11 +322,12 @@ bool cmListCommand::HandlePrependCommand(std::vector const& args) listString.insert(0, cmJoin(cmMakeRange(args).advance(2), ";") + &";"[offset]); - this->Makefile->AddDefinition(listName, listString); + makefile.AddDefinition(listName, listString); return true; } -bool cmListCommand::HandlePopBackCommand(std::vector const& args) +bool HandlePopBackCommand(std::vector const& args, + cmMakefile& makefile) { assert(args.size() >= 2); @@ -284,10 +335,10 @@ bool cmListCommand::HandlePopBackCommand(std::vector const& args) ++ai; // Skip subcommand name std::string const& listName = *ai++; std::vector varArgsExpanded; - if (!this->GetList(varArgsExpanded, listName)) { + if (!GetList(varArgsExpanded, listName, makefile)) { // Can't get the list definition... undefine any vars given after. for (; ai != args.cend(); ++ai) { - this->Makefile->RemoveDefinition(*ai); + makefile.RemoveDefinition(*ai); } return true; } @@ -300,29 +351,30 @@ bool cmListCommand::HandlePopBackCommand(std::vector const& args) // Ok, assign elements to be removed to the given variables for (; !varArgsExpanded.empty() && ai != args.cend(); ++ai) { assert(!ai->empty()); - this->Makefile->AddDefinition(*ai, varArgsExpanded.back()); + makefile.AddDefinition(*ai, varArgsExpanded.back()); varArgsExpanded.pop_back(); } // Undefine the rest variables if the list gets empty earlier... for (; ai != args.cend(); ++ai) { - this->Makefile->RemoveDefinition(*ai); + makefile.RemoveDefinition(*ai); } } - this->Makefile->AddDefinition(listName, cmJoin(varArgsExpanded, ";")); + makefile.AddDefinition(listName, cmJoin(varArgsExpanded, ";")); } else if (ai != args.cend()) { // The list is empty, but some args were given // Need to *undefine* 'em all, cuz there are no items to assign... for (; ai != args.cend(); ++ai) { - this->Makefile->RemoveDefinition(*ai); + makefile.RemoveDefinition(*ai); } } return true; } -bool cmListCommand::HandlePopFrontCommand(std::vector const& args) +bool HandlePopFrontCommand(std::vector const& args, + cmMakefile& makefile) { assert(args.size() >= 2); @@ -330,10 +382,10 @@ bool cmListCommand::HandlePopFrontCommand(std::vector const& args) ++ai; // Skip subcommand name std::string const& listName = *ai++; std::vector varArgsExpanded; - if (!this->GetList(varArgsExpanded, listName)) { + if (!GetList(varArgsExpanded, listName, makefile)) { // Can't get the list definition... undefine any vars given after. for (; ai != args.cend(); ++ai) { - this->Makefile->RemoveDefinition(*ai); + makefile.RemoveDefinition(*ai); } return true; } @@ -347,32 +399,33 @@ bool cmListCommand::HandlePopFrontCommand(std::vector const& args) auto vi = varArgsExpanded.begin(); for (; vi != varArgsExpanded.end() && ai != args.cend(); ++ai, ++vi) { assert(!ai->empty()); - this->Makefile->AddDefinition(*ai, *vi); + makefile.AddDefinition(*ai, *vi); } varArgsExpanded.erase(varArgsExpanded.begin(), vi); // Undefine the rest variables if the list gets empty earlier... for (; ai != args.cend(); ++ai) { - this->Makefile->RemoveDefinition(*ai); + makefile.RemoveDefinition(*ai); } } - this->Makefile->AddDefinition(listName, cmJoin(varArgsExpanded, ";")); + makefile.AddDefinition(listName, cmJoin(varArgsExpanded, ";")); } else if (ai != args.cend()) { // The list is empty, but some args were given // Need to *undefine* 'em all, cuz there are no items to assign... for (; ai != args.cend(); ++ai) { - this->Makefile->RemoveDefinition(*ai); + makefile.RemoveDefinition(*ai); } } return true; } -bool cmListCommand::HandleFindCommand(std::vector const& args) +bool HandleFindCommand(std::vector const& args, + cmExecutionStatus& status) { if (args.size() != 4) { - this->SetError("sub-command FIND requires three arguments."); + status.SetError("sub-command FIND requires three arguments."); return false; } @@ -380,8 +433,8 @@ bool cmListCommand::HandleFindCommand(std::vector const& args) const std::string& variableName = args.back(); // expand the variable std::vector varArgsExpanded; - if (!this->GetList(varArgsExpanded, listName)) { - this->Makefile->AddDefinition(variableName, "-1"); + if (!GetList(varArgsExpanded, listName, status.GetMakefile())) { + status.GetMakefile().AddDefinition(variableName, "-1"); return true; } @@ -390,18 +443,19 @@ bool cmListCommand::HandleFindCommand(std::vector const& args) if (it != varArgsExpanded.end()) { std::ostringstream indexStream; indexStream << std::distance(varArgsExpanded.begin(), it); - this->Makefile->AddDefinition(variableName, indexStream.str()); + status.GetMakefile().AddDefinition(variableName, indexStream.str()); return true; } - this->Makefile->AddDefinition(variableName, "-1"); + status.GetMakefile().AddDefinition(variableName, "-1"); return true; } -bool cmListCommand::HandleInsertCommand(std::vector const& args) +bool HandleInsertCommand(std::vector const& args, + cmExecutionStatus& status) { if (args.size() < 4) { - this->SetError("sub-command INSERT requires at least three arguments."); + status.SetError("sub-command INSERT requires at least three arguments."); return false; } @@ -410,11 +464,12 @@ bool cmListCommand::HandleInsertCommand(std::vector const& args) // expand the variable int item = atoi(args[2].c_str()); std::vector varArgsExpanded; - if ((!this->GetList(varArgsExpanded, listName) || varArgsExpanded.empty()) && + if ((!GetList(varArgsExpanded, listName, status.GetMakefile()) || + varArgsExpanded.empty()) && item != 0) { std::ostringstream str; str << "index: " << item << " out of range (0, 0)"; - this->SetError(str.str()); + status.SetError(str.str()); return false; } @@ -427,7 +482,7 @@ bool cmListCommand::HandleInsertCommand(std::vector const& args) std::ostringstream str; str << "index: " << item << " out of range (-" << varArgsExpanded.size() << ", " << varArgsExpanded.size() << ")"; - this->SetError(str.str()); + status.SetError(str.str()); return false; } } @@ -436,17 +491,18 @@ bool cmListCommand::HandleInsertCommand(std::vector const& args) args.end()); std::string value = cmJoin(varArgsExpanded, ";"); - this->Makefile->AddDefinition(listName, value); + status.GetMakefile().AddDefinition(listName, value); return true; } -bool cmListCommand::HandleJoinCommand(std::vector const& args) +bool HandleJoinCommand(std::vector const& args, + cmExecutionStatus& status) { if (args.size() != 4) { std::ostringstream error; error << "sub-command JOIN requires three arguments (" << args.size() - 1 << " found)."; - this->SetError(error.str()); + status.SetError(error.str()); return false; } @@ -456,30 +512,30 @@ bool cmListCommand::HandleJoinCommand(std::vector const& args) // expand the variable std::vector varArgsExpanded; - if (!this->GetList(varArgsExpanded, listName)) { - this->Makefile->AddDefinition(variableName, ""); + if (!GetList(varArgsExpanded, listName, status.GetMakefile())) { + status.GetMakefile().AddDefinition(variableName, ""); return true; } std::string value = cmJoin(cmMakeRange(varArgsExpanded.begin(), varArgsExpanded.end()), glue); - this->Makefile->AddDefinition(variableName, value); + status.GetMakefile().AddDefinition(variableName, value); return true; } -bool cmListCommand::HandleRemoveItemCommand( - std::vector const& args) +bool HandleRemoveItemCommand(std::vector const& args, + cmExecutionStatus& status) { if (args.size() < 3) { - this->SetError("sub-command REMOVE_ITEM requires two or more arguments."); + status.SetError("sub-command REMOVE_ITEM requires two or more arguments."); return false; } const std::string& listName = args[1]; // expand the variable std::vector varArgsExpanded; - if (!this->GetList(varArgsExpanded, listName)) { + if (!GetList(varArgsExpanded, listName, status.GetMakefile())) { return true; } @@ -493,44 +549,45 @@ bool cmListCommand::HandleRemoveItemCommand( cmRemoveMatching(varArgsExpanded, cmMakeRange(remBegin, remEnd)); std::vector::const_iterator argsBegin = varArgsExpanded.begin(); std::string value = cmJoin(cmMakeRange(argsBegin, argsEnd), ";"); - this->Makefile->AddDefinition(listName, value); + status.GetMakefile().AddDefinition(listName, value); return true; } -bool cmListCommand::HandleReverseCommand(std::vector const& args) +bool HandleReverseCommand(std::vector const& args, + cmExecutionStatus& status) { assert(args.size() >= 2); if (args.size() > 2) { - this->SetError("sub-command REVERSE only takes one argument."); + status.SetError("sub-command REVERSE only takes one argument."); return false; } const std::string& listName = args[1]; // expand the variable std::vector varArgsExpanded; - if (!this->GetList(varArgsExpanded, listName)) { + if (!GetList(varArgsExpanded, listName, status.GetMakefile())) { return true; } std::string value = cmJoin(cmReverseRange(varArgsExpanded), ";"); - this->Makefile->AddDefinition(listName, value); + status.GetMakefile().AddDefinition(listName, value); return true; } -bool cmListCommand::HandleRemoveDuplicatesCommand( - std::vector const& args) +bool HandleRemoveDuplicatesCommand(std::vector const& args, + cmExecutionStatus& status) { assert(args.size() >= 2); if (args.size() > 2) { - this->SetError("sub-command REMOVE_DUPLICATES only takes one argument."); + status.SetError("sub-command REMOVE_DUPLICATES only takes one argument."); return false; } const std::string& listName = args[1]; // expand the variable std::vector varArgsExpanded; - if (!this->GetList(varArgsExpanded, listName)) { + if (!GetList(varArgsExpanded, listName, status.GetMakefile())) { return true; } @@ -539,12 +596,11 @@ bool cmListCommand::HandleRemoveDuplicatesCommand( std::vector::const_iterator argsBegin = varArgsExpanded.begin(); std::string value = cmJoin(cmMakeRange(argsBegin, argsEnd), ";"); - this->Makefile->AddDefinition(listName, value); + status.GetMakefile().AddDefinition(listName, value); return true; } // Helpers for list(TRANSFORM ...) -namespace { using transform_type = std::function; class transform_error : public std::runtime_error @@ -759,13 +815,12 @@ public: private: cmStringReplaceHelper ReplaceHelper; }; -} -bool cmListCommand::HandleTransformCommand( - std::vector const& args) +bool HandleTransformCommand(std::vector const& args, + cmExecutionStatus& status) { if (args.size() < 3) { - this->SetError( + status.SetError( "sub-command TRANSFORM requires an action to be specified."); return false; } @@ -888,7 +943,7 @@ bool cmListCommand::HandleTransformCommand( if (descriptor == descriptors.end()) { std::ostringstream error; error << " sub-command TRANSFORM, " << args[index] << " invalid action."; - this->SetError(error.str()); + status.SetError(error.str()); return false; } @@ -898,7 +953,7 @@ bool cmListCommand::HandleTransformCommand( std::ostringstream error; error << "sub-command TRANSFORM, action " << descriptor->Name << " expects " << descriptor->Arity << " argument(s)."; - this->SetError(error.str()); + status.SetError(error.str()); return false; } @@ -911,10 +966,10 @@ bool cmListCommand::HandleTransformCommand( if (command.Name == "REPLACE") { try { - command.Action = - cm::make_unique(command.Arguments, this->Makefile); + command.Action = cm::make_unique( + command.Arguments, &status.GetMakefile()); } catch (const transform_error& e) { - this->SetError(e.what()); + status.SetError(e.what()); return false; } } @@ -929,15 +984,15 @@ bool cmListCommand::HandleTransformCommand( std::ostringstream error; error << "sub-command TRANSFORM, selector already specified (" << command.Selector->Tag << ")."; - this->SetError(error.str()); + status.SetError(error.str()); return false; } // REGEX selector if (args[index] == REGEX) { if (args.size() == ++index) { - this->SetError("sub-command TRANSFORM, selector REGEX expects " - "'regular expression' argument."); + status.SetError("sub-command TRANSFORM, selector REGEX expects " + "'regular expression' argument."); return false; } @@ -947,7 +1002,7 @@ bool cmListCommand::HandleTransformCommand( error << "sub-command TRANSFORM, selector REGEX failed to compile " "regex \""; error << args[index] << "\"."; - this->SetError(error.str()); + status.SetError(error.str()); return false; } @@ -977,7 +1032,7 @@ bool cmListCommand::HandleTransformCommand( } if (indexes.empty()) { - this->SetError( + status.SetError( "sub-command TRANSFORM, selector AT expects at least one " "numeric value."); return false; @@ -992,8 +1047,9 @@ bool cmListCommand::HandleTransformCommand( // FOR selector if (args[index] == FOR) { if (args.size() <= ++index + 1) { - this->SetError("sub-command TRANSFORM, selector FOR expects, at least," - " two arguments."); + status.SetError( + "sub-command TRANSFORM, selector FOR expects, at least," + " two arguments."); return false; } @@ -1018,8 +1074,8 @@ bool cmListCommand::HandleTransformCommand( valid = false; } if (!valid) { - this->SetError("sub-command TRANSFORM, selector FOR expects, " - "at least, two numeric values."); + status.SetError("sub-command TRANSFORM, selector FOR expects, " + "at least, two numeric values."); return false; } // try to read a third numeric value for step @@ -1040,8 +1096,8 @@ bool cmListCommand::HandleTransformCommand( } if (step < 0) { - this->SetError("sub-command TRANSFORM, selector FOR expects " - "non negative numeric value for ."); + status.SetError("sub-command TRANSFORM, selector FOR expects " + "non negative numeric value for ."); } command.Selector = @@ -1053,8 +1109,8 @@ bool cmListCommand::HandleTransformCommand( // output variable if (args[index] == OUTPUT_VARIABLE) { if (args.size() == ++index) { - this->SetError("sub-command TRANSFORM, OUTPUT_VARIABLE " - "expects variable name argument."); + status.SetError("sub-command TRANSFORM, OUTPUT_VARIABLE " + "expects variable name argument."); return false; } @@ -1066,14 +1122,14 @@ bool cmListCommand::HandleTransformCommand( error << "sub-command TRANSFORM, '" << cmJoin(cmMakeRange(args).advance(index), " ") << "': unexpected argument(s)."; - this->SetError(error.str()); + status.SetError(error.str()); return false; } // expand the list variable std::vector varArgsExpanded; - if (!this->GetList(varArgsExpanded, command.ListName)) { - this->Makefile->AddDefinition(command.OutputName, ""); + if (!GetList(varArgsExpanded, command.ListName, status.GetMakefile())) { + status.GetMakefile().AddDefinition(command.OutputName, ""); return true; } @@ -1085,12 +1141,12 @@ bool cmListCommand::HandleTransformCommand( try { command.Selector->Transform(varArgsExpanded, descriptor->Transform); } catch (const transform_error& e) { - this->SetError(e.what()); + status.SetError(e.what()); return false; } - this->Makefile->AddDefinition(command.OutputName, - cmJoin(varArgsExpanded, ";")); + status.GetMakefile().AddDefinition(command.OutputName, + cmJoin(varArgsExpanded, ";")); return true; } @@ -1170,11 +1226,12 @@ protected: bool descending; }; -bool cmListCommand::HandleSortCommand(std::vector const& args) +bool HandleSortCommand(std::vector const& args, + cmExecutionStatus& status) { assert(args.size() >= 2); if (args.size() > 8) { - this->SetError("sub-command SORT only takes up to six arguments."); + status.SetError("sub-command SORT only takes up to six arguments."); return false; } @@ -1191,7 +1248,7 @@ bool cmListCommand::HandleSortCommand(std::vector const& args) if (sortCompare != cmStringSorter::Compare::UNINITIALIZED) { std::string error = cmStrCat(messageHint, "option \"", option, "\" has been specified multiple times."); - this->SetError(error); + status.SetError(error); return false; } if (argumentIndex < args.size()) { @@ -1204,19 +1261,19 @@ bool cmListCommand::HandleSortCommand(std::vector const& args) std::string error = cmStrCat(messageHint, "value \"", argument, "\" for option \"", option, "\" is invalid."); - this->SetError(error); + status.SetError(error); return false; } } else { - this->SetError(cmStrCat(messageHint, "missing argument for option \"", - option, "\".")); + status.SetError(cmStrCat(messageHint, "missing argument for option \"", + option, "\".")); return false; } } else if (option == "CASE") { if (sortCaseSensitivity != cmStringSorter::CaseSensitivity::UNINITIALIZED) { - this->SetError(cmStrCat(messageHint, "option \"", option, - "\" has been specified multiple times.")); + status.SetError(cmStrCat(messageHint, "option \"", option, + "\" has been specified multiple times.")); return false; } if (argumentIndex < args.size()) { @@ -1226,21 +1283,21 @@ bool cmListCommand::HandleSortCommand(std::vector const& args) } else if (argument == "INSENSITIVE") { sortCaseSensitivity = cmStringSorter::CaseSensitivity::INSENSITIVE; } else { - this->SetError(cmStrCat(messageHint, "value \"", argument, - "\" for option \"", option, - "\" is invalid.")); + status.SetError(cmStrCat(messageHint, "value \"", argument, + "\" for option \"", option, + "\" is invalid.")); return false; } } else { - this->SetError(cmStrCat(messageHint, "missing argument for option \"", - option, "\".")); + status.SetError(cmStrCat(messageHint, "missing argument for option \"", + option, "\".")); return false; } } else if (option == "ORDER") { if (sortOrder != cmStringSorter::Order::UNINITIALIZED) { - this->SetError(cmStrCat(messageHint, "option \"", option, - "\" has been specified multiple times.")); + status.SetError(cmStrCat(messageHint, "option \"", option, + "\" has been specified multiple times.")); return false; } if (argumentIndex < args.size()) { @@ -1250,18 +1307,18 @@ bool cmListCommand::HandleSortCommand(std::vector const& args) } else if (argument == "DESCENDING") { sortOrder = cmStringSorter::Order::DESCENDING; } else { - this->SetError(cmStrCat(messageHint, "value \"", argument, - "\" for option \"", option, - "\" is invalid.")); + status.SetError(cmStrCat(messageHint, "value \"", argument, + "\" for option \"", option, + "\" is invalid.")); return false; } } else { - this->SetError(cmStrCat(messageHint, "missing argument for option \"", - option, "\".")); + status.SetError(cmStrCat(messageHint, "missing argument for option \"", + option, "\".")); return false; } } else { - this->SetError( + status.SetError( cmStrCat(messageHint, "option \"", option, "\" is unknown.")); return false; } @@ -1280,7 +1337,7 @@ bool cmListCommand::HandleSortCommand(std::vector const& args) const std::string& listName = args[1]; // expand the variable std::vector varArgsExpanded; - if (!this->GetList(varArgsExpanded, listName)) { + if (!GetList(varArgsExpanded, listName, status.GetMakefile())) { return true; } @@ -1294,17 +1351,18 @@ bool cmListCommand::HandleSortCommand(std::vector const& args) } std::string value = cmJoin(varArgsExpanded, ";"); - this->Makefile->AddDefinition(listName, value); + status.GetMakefile().AddDefinition(listName, value); return true; } -bool cmListCommand::HandleSublistCommand(std::vector const& args) +bool HandleSublistCommand(std::vector const& args, + cmExecutionStatus& status) { if (args.size() != 5) { std::ostringstream error; error << "sub-command SUBLIST requires four arguments (" << args.size() - 1 << " found)."; - this->SetError(error.str()); + status.SetError(error.str()); return false; } @@ -1313,8 +1371,9 @@ bool cmListCommand::HandleSublistCommand(std::vector const& args) // expand the variable std::vector varArgsExpanded; - if (!this->GetList(varArgsExpanded, listName) || varArgsExpanded.empty()) { - this->Makefile->AddDefinition(variableName, ""); + if (!GetList(varArgsExpanded, listName, status.GetMakefile()) || + varArgsExpanded.empty()) { + status.GetMakefile().AddDefinition(variableName, ""); return true; } @@ -1327,13 +1386,13 @@ bool cmListCommand::HandleSublistCommand(std::vector const& args) std::ostringstream error; error << "begin index: " << start << " is out of range 0 - " << varArgsExpanded.size() - 1; - this->SetError(error.str()); + status.SetError(error.str()); return false; } if (length < -1) { std::ostringstream error; error << "length: " << length << " should be -1 or greater"; - this->SetError(error.str()); + status.SetError(error.str()); return false; } @@ -1343,22 +1402,24 @@ bool cmListCommand::HandleSublistCommand(std::vector const& args) : size_type(start + length); std::vector sublist(varArgsExpanded.begin() + start, varArgsExpanded.begin() + end); - this->Makefile->AddDefinition(variableName, cmJoin(sublist, ";")); + status.GetMakefile().AddDefinition(variableName, cmJoin(sublist, ";")); return true; } -bool cmListCommand::HandleRemoveAtCommand(std::vector const& args) +bool HandleRemoveAtCommand(std::vector const& args, + cmExecutionStatus& status) { if (args.size() < 3) { - this->SetError("sub-command REMOVE_AT requires at least " - "two arguments."); + status.SetError("sub-command REMOVE_AT requires at least " + "two arguments."); return false; } const std::string& listName = args[1]; // expand the variable std::vector varArgsExpanded; - if (!this->GetList(varArgsExpanded, listName) || varArgsExpanded.empty()) { + if (!GetList(varArgsExpanded, listName, status.GetMakefile()) || + varArgsExpanded.empty()) { std::ostringstream str; str << "index: "; for (size_t i = 1; i < args.size(); ++i) { @@ -1368,7 +1429,7 @@ bool cmListCommand::HandleRemoveAtCommand(std::vector const& args) } } str << " out of range (0, 0)"; - this->SetError(str.str()); + status.SetError(str.str()); return false; } @@ -1384,7 +1445,7 @@ bool cmListCommand::HandleRemoveAtCommand(std::vector const& args) std::ostringstream str; str << "index: " << item << " out of range (-" << nitem << ", " << nitem - 1 << ")"; - this->SetError(str.str()); + status.SetError(str.str()); return false; } removed.push_back(static_cast(item)); @@ -1400,24 +1461,26 @@ bool cmListCommand::HandleRemoveAtCommand(std::vector const& args) std::vector::const_iterator argsBegin = varArgsExpanded.begin(); std::string value = cmJoin(cmMakeRange(argsBegin, argsEnd), ";"); - this->Makefile->AddDefinition(listName, value); + status.GetMakefile().AddDefinition(listName, value); return true; } -bool cmListCommand::HandleFilterCommand(std::vector const& args) +bool HandleFilterCommand(std::vector const& args, + cmExecutionStatus& status) { if (args.size() < 2) { - this->SetError("sub-command FILTER requires a list to be specified."); + status.SetError("sub-command FILTER requires a list to be specified."); return false; } if (args.size() < 3) { - this->SetError("sub-command FILTER requires an operator to be specified."); + status.SetError( + "sub-command FILTER requires an operator to be specified."); return false; } if (args.size() < 4) { - this->SetError("sub-command FILTER requires a mode to be specified."); + status.SetError("sub-command FILTER requires a mode to be specified."); return false; } @@ -1428,28 +1491,29 @@ bool cmListCommand::HandleFilterCommand(std::vector const& args) } else if (op == "EXCLUDE") { includeMatches = false; } else { - this->SetError("sub-command FILTER does not recognize operator " + op); + status.SetError("sub-command FILTER does not recognize operator " + op); return false; } const std::string& listName = args[1]; // expand the variable std::vector varArgsExpanded; - if (!this->GetList(varArgsExpanded, listName)) { + if (!GetList(varArgsExpanded, listName, status.GetMakefile())) { return true; } const std::string& mode = args[3]; if (mode == "REGEX") { if (args.size() != 5) { - this->SetError("sub-command FILTER, mode REGEX " - "requires five arguments."); + status.SetError("sub-command FILTER, mode REGEX " + "requires five arguments."); return false; } - return this->FilterRegex(args, includeMatches, listName, varArgsExpanded); + return FilterRegex(args, includeMatches, listName, varArgsExpanded, + status); } - this->SetError("sub-command FILTER does not recognize mode " + mode); + status.SetError("sub-command FILTER does not recognize mode " + mode); return false; } @@ -1472,10 +1536,10 @@ private: const bool includeMatches; }; -bool cmListCommand::FilterRegex(std::vector const& args, - bool includeMatches, - std::string const& listName, - std::vector& varArgsExpanded) +bool FilterRegex(std::vector const& args, bool includeMatches, + std::string const& listName, + std::vector& varArgsExpanded, + cmExecutionStatus& status) { const std::string& pattern = args[4]; cmsys::RegularExpression regex(pattern); @@ -1484,7 +1548,7 @@ bool cmListCommand::FilterRegex(std::vector const& args, error += "failed to compile regex \""; error += pattern; error += "\"."; - this->SetError(error); + status.SetError(error); return false; } @@ -1494,6 +1558,7 @@ bool cmListCommand::FilterRegex(std::vector const& args, std::remove_if(argsBegin, argsEnd, MatchesRegex(regex, includeMatches)); std::string value = cmJoin(cmMakeRange(argsBegin, newArgsEnd), ";"); - this->Makefile->AddDefinition(listName, value); + status.GetMakefile().AddDefinition(listName, value); return true; } +} diff --git a/Source/cmListCommand.h b/Source/cmListCommand.h index 70c7f4e172..274d9fdbd6 100644 --- a/Source/cmListCommand.h +++ b/Source/cmListCommand.h @@ -8,58 +8,13 @@ #include #include -#include "cm_memory.hxx" - -#include "cmCommand.h" - class cmExecutionStatus; -/** \class cmListCommand +/** * \brief Common list operations * */ -class cmListCommand : public cmCommand -{ -public: - /** - * This is a virtual constructor for the command. - */ - std::unique_ptr Clone() override - { - return cm::make_unique(); - } - - /** - * This is called when the command is first encountered in - * the CMakeLists.txt file. - */ - bool InitialPass(std::vector const& args, - cmExecutionStatus& status) override; - -protected: - bool HandleLengthCommand(std::vector const& args); - bool HandleGetCommand(std::vector const& args); - bool HandleAppendCommand(std::vector const& args); - bool HandlePrependCommand(std::vector const& args); - bool HandlePopBackCommand(std::vector const& args); - bool HandlePopFrontCommand(std::vector const& args); - bool HandleFindCommand(std::vector const& args); - bool HandleInsertCommand(std::vector const& args); - bool HandleJoinCommand(std::vector const& args); - bool HandleRemoveAtCommand(std::vector const& args); - bool HandleRemoveItemCommand(std::vector const& args); - bool HandleRemoveDuplicatesCommand(std::vector const& args); - bool HandleTransformCommand(std::vector const& args); - bool HandleSortCommand(std::vector const& args); - bool HandleSublistCommand(std::vector const& args); - bool HandleReverseCommand(std::vector const& args); - bool HandleFilterCommand(std::vector const& args); - bool FilterRegex(std::vector const& args, bool includeMatches, - std::string const& listName, - std::vector& varArgsExpanded); - - bool GetList(std::vector& list, const std::string& var); - bool GetListString(std::string& listString, const std::string& var); -}; +bool cmListCommand(std::vector const& args, + cmExecutionStatus& status); #endif