contrib/llvm-project/lldb/source/Interpreter/CommandAlias.cpp

   1 //===-- CommandAlias.cpp -----------------------------------------*- C++-*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "lldb/Interpreter/CommandAlias.h"
  10
  11 #include "llvm/Support/ErrorHandling.h"
  12
  13 #include "lldb/Interpreter/CommandInterpreter.h"
  14 #include "lldb/Interpreter/CommandObject.h"
  15 #include "lldb/Interpreter/CommandReturnObject.h"
  16 #include "lldb/Interpreter/Options.h"
  17 #include "lldb/Utility/StreamString.h"
  18
  19 using namespace lldb;
  20 using namespace lldb_private;
  21
  22 static bool ProcessAliasOptionsArgs(lldb::CommandObjectSP &cmd_obj_sp,
  23                                     llvm::StringRef options_args,
  24                                     OptionArgVectorSP &option_arg_vector_sp) {
  25   bool success = true;
  26   OptionArgVector *option_arg_vector = option_arg_vector_sp.get();
  27
  28   if (options_args.size() < 1)
  29     return true;
  30
  31   Args args(options_args);
  32   std::string options_string(options_args);
  33   // TODO: Find a way to propagate errors in this CommandReturnObject up the
  34   // stack.
  35   CommandReturnObject result;
  36   // Check to see if the command being aliased can take any command options.
  37   Options *options = cmd_obj_sp->GetOptions();
  38   if (options) {
  39     // See if any options were specified as part of the alias;  if so, handle
  40     // them appropriately.
  41     ExecutionContext exe_ctx =
  42         cmd_obj_sp->GetCommandInterpreter().GetExecutionContext();
  43     options->NotifyOptionParsingStarting(&exe_ctx);
  44
  45     llvm::Expected<Args> args_or =
  46         options->ParseAlias(args, option_arg_vector, options_string);
  47     if (!args_or) {
  48       result.AppendError(toString(args_or.takeError()));
  49       result.AppendError("Unable to create requested alias.\n");
  50       result.SetStatus(eReturnStatusFailed);
  51       return false;
  52     }
  53     args = std::move(*args_or);
  54     options->VerifyPartialOptions(result);
  55     if (!result.Succeeded() &&
  56         result.GetStatus() != lldb::eReturnStatusStarted) {
  57       result.AppendError("Unable to create requested alias.\n");
  58       return false;
  59     }
  60   }
  61
  62   if (!options_string.empty()) {
  63     if (cmd_obj_sp->WantsRawCommandString())
  64       option_arg_vector->emplace_back("<argument>", -1, options_string);
  65     else {
  66       for (auto &entry : args.entries()) {
  67         if (!entry.ref().empty())
  68           option_arg_vector->emplace_back(std::string("<argument>"), -1,
  69                                           std::string(entry.ref()));
  70       }
  71     }
  72   }
  73
  74   return success;
  75 }
  76
  77 CommandAlias::CommandAlias(CommandInterpreter &interpreter,
  78                            lldb::CommandObjectSP cmd_sp,
  79                            llvm::StringRef options_args, llvm::StringRef name,
  80                            llvm::StringRef help, llvm::StringRef syntax,
  81                            uint32_t flags)
  82     : CommandObject(interpreter, name, help, syntax, flags),
  83       m_underlying_command_sp(), m_option_string(options_args),
  84       m_option_args_sp(new OptionArgVector),
  85       m_is_dashdash_alias(eLazyBoolCalculate), m_did_set_help(false),
  86       m_did_set_help_long(false) {
  87   if (ProcessAliasOptionsArgs(cmd_sp, options_args, m_option_args_sp)) {
  88     m_underlying_command_sp = cmd_sp;
  89     for (int i = 0;
  90          auto cmd_entry = m_underlying_command_sp->GetArgumentEntryAtIndex(i);
  91          i++) {
  92       m_arguments.push_back(*cmd_entry);
  93     }
  94     if (!help.empty()) {
  95       StreamString sstr;
  96       StreamString translation_and_help;
  97       GetAliasExpansion(sstr);
  98
  99       translation_and_help.Printf(
 100           "(%s)  %s", sstr.GetData(),
 101           GetUnderlyingCommand()->GetHelp().str().c_str());
 102       SetHelp(translation_and_help.GetString());
 103     }
 104   }
 105 }
 106
 107 bool CommandAlias::WantsRawCommandString() {
 108   if (IsValid())
 109     return m_underlying_command_sp->WantsRawCommandString();
 110   return false;
 111 }
 112
 113 bool CommandAlias::WantsCompletion() {
 114   if (IsValid())
 115     return m_underlying_command_sp->WantsCompletion();
 116   return false;
 117 }
 118
 119 void CommandAlias::HandleCompletion(CompletionRequest &request) {
 120   if (IsValid())
 121     m_underlying_command_sp->HandleCompletion(request);
 122 }
 123
 124 void CommandAlias::HandleArgumentCompletion(
 125     CompletionRequest &request, OptionElementVector &opt_element_vector) {
 126   if (IsValid())
 127     m_underlying_command_sp->HandleArgumentCompletion(request,
 128                                                       opt_element_vector);
 129 }
 130
 131 Options *CommandAlias::GetOptions() {
 132   if (IsValid())
 133     return m_underlying_command_sp->GetOptions();
 134   return nullptr;
 135 }
 136
 137 bool CommandAlias::Execute(const char *args_string,
 138                            CommandReturnObject &result) {
 139   llvm_unreachable("CommandAlias::Execute is not to be called");
 140 }
 141
 142 void CommandAlias::GetAliasExpansion(StreamString &help_string) const {
 143   llvm::StringRef command_name = m_underlying_command_sp->GetCommandName();
 144   help_string.Printf("'%*s", (int)command_name.size(), command_name.data());
 145
 146   if (!m_option_args_sp) {
 147     help_string.Printf("'");
 148     return;
 149   }
 150
 151   OptionArgVector *options = m_option_args_sp.get();
 152   std::string opt;
 153   std::string value;
 154
 155   for (const auto &opt_entry : *options) {
 156     std::tie(opt, std::ignore, value) = opt_entry;
 157     if (opt == "<argument>") {
 158       help_string.Printf(" %s", value.c_str());
 159     } else {
 160       help_string.Printf(" %s", opt.c_str());
 161       if ((value != "<no-argument>") && (value != "<need-argument")) {
 162         help_string.Printf(" %s", value.c_str());
 163       }
 164     }
 165   }
 166
 167   help_string.Printf("'");
 168 }
 169
 170 bool CommandAlias::IsDashDashCommand() {
 171   if (m_is_dashdash_alias != eLazyBoolCalculate)
 172     return (m_is_dashdash_alias == eLazyBoolYes);
 173   m_is_dashdash_alias = eLazyBoolNo;
 174   if (!IsValid())
 175     return false;
 176
 177   std::string opt;
 178   std::string value;
 179
 180   for (const auto &opt_entry : *GetOptionArguments()) {
 181     std::tie(opt, std::ignore, value) = opt_entry;
 182     if (opt == "<argument>" && !value.empty() &&
 183         llvm::StringRef(value).endswith("--")) {
 184       m_is_dashdash_alias = eLazyBoolYes;
 185       break;
 186     }
 187   }
 188
 189   // if this is a nested alias, it may be adding arguments on top of an already
 190   // dash-dash alias
 191   if ((m_is_dashdash_alias == eLazyBoolNo) && IsNestedAlias())
 192     m_is_dashdash_alias =
 193         (GetUnderlyingCommand()->IsDashDashCommand() ? eLazyBoolYes
 194                                                      : eLazyBoolNo);
 195   return (m_is_dashdash_alias == eLazyBoolYes);
 196 }
 197
 198 bool CommandAlias::IsNestedAlias() {
 199   if (GetUnderlyingCommand())
 200     return GetUnderlyingCommand()->IsAlias();
 201   return false;
 202 }
 203
 204 std::pair<lldb::CommandObjectSP, OptionArgVectorSP> CommandAlias::Desugar() {
 205   auto underlying = GetUnderlyingCommand();
 206   if (!underlying)
 207     return {nullptr, nullptr};
 208
 209   if (underlying->IsAlias()) {
 210     auto desugared = ((CommandAlias *)underlying.get())->Desugar();
 211     auto options = GetOptionArguments();
 212     options->insert(options->begin(), desugared.second->begin(),
 213                     desugared.second->end());
 214     return {desugared.first, options};
 215   }
 216
 217   return {underlying, GetOptionArguments()};
 218 }
 219
 220 // allow CommandAlias objects to provide their own help, but fallback to the
 221 // info for the underlying command if no customization has been provided
 222 void CommandAlias::SetHelp(llvm::StringRef str) {
 223   this->CommandObject::SetHelp(str);
 224   m_did_set_help = true;
 225 }
 226
 227 void CommandAlias::SetHelpLong(llvm::StringRef str) {
 228   this->CommandObject::SetHelpLong(str);
 229   m_did_set_help_long = true;
 230 }
 231
 232 llvm::StringRef CommandAlias::GetHelp() {
 233   if (!m_cmd_help_short.empty() || m_did_set_help)
 234     return m_cmd_help_short;
 235   if (IsValid())
 236     return m_underlying_command_sp->GetHelp();
 237   return llvm::StringRef();
 238 }
 239
 240 llvm::StringRef CommandAlias::GetHelpLong() {
 241   if (!m_cmd_help_long.empty() || m_did_set_help_long)
 242     return m_cmd_help_long;
 243   if (IsValid())
 244     return m_underlying_command_sp->GetHelpLong();
 245   return llvm::StringRef();
 246 }