contrib/llvm/tools/lldb/source/Commands/CommandObjectMultiword.cpp

   1 //===-- CommandObjectMultiword.cpp ------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "lldb/Interpreter/CommandObjectMultiword.h"
  11 #include "lldb/Core/Debugger.h"
  12 #include "lldb/Interpreter/CommandInterpreter.h"
  13 #include "lldb/Interpreter/CommandReturnObject.h"
  14 #include "lldb/Interpreter/Options.h"
  15
  16 using namespace lldb;
  17 using namespace lldb_private;
  18
  19 //-------------------------------------------------------------------------
  20 // CommandObjectMultiword
  21 //-------------------------------------------------------------------------
  22
  23 CommandObjectMultiword::CommandObjectMultiword(CommandInterpreter &interpreter,
  24                                                const char *name,
  25                                                const char *help,
  26                                                const char *syntax,
  27                                                uint32_t flags)
  28     : CommandObject(interpreter, name, help, syntax, flags),
  29       m_can_be_removed(false) {}
  30
  31 CommandObjectMultiword::~CommandObjectMultiword() = default;
  32
  33 CommandObjectSP CommandObjectMultiword::GetSubcommandSP(llvm::StringRef sub_cmd,
  34                                                         StringList *matches) {
  35   CommandObjectSP return_cmd_sp;
  36   CommandObject::CommandMap::iterator pos;
  37
  38   if (!m_subcommand_dict.empty()) {
  39     pos = m_subcommand_dict.find(sub_cmd);
  40     if (pos != m_subcommand_dict.end()) {
  41       // An exact match; append the sub_cmd to the 'matches' string list.
  42       if (matches)
  43         matches->AppendString(sub_cmd);
  44       return_cmd_sp = pos->second;
  45     } else {
  46       StringList local_matches;
  47       if (matches == nullptr)
  48         matches = &local_matches;
  49       int num_matches =
  50           AddNamesMatchingPartialString(m_subcommand_dict, sub_cmd, *matches);
  51
  52       if (num_matches == 1) {
  53         // Cleaner, but slightly less efficient would be to call back into this
  54         // function, since I now know I have an exact match...
  55
  56         sub_cmd = matches->GetStringAtIndex(0);
  57         pos = m_subcommand_dict.find(sub_cmd);
  58         if (pos != m_subcommand_dict.end())
  59           return_cmd_sp = pos->second;
  60       }
  61     }
  62   }
  63   return return_cmd_sp;
  64 }
  65
  66 CommandObject *
  67 CommandObjectMultiword::GetSubcommandObject(llvm::StringRef sub_cmd,
  68                                             StringList *matches) {
  69   return GetSubcommandSP(sub_cmd, matches).get();
  70 }
  71
  72 bool CommandObjectMultiword::LoadSubCommand(llvm::StringRef name,
  73                                             const CommandObjectSP &cmd_obj) {
  74   if (cmd_obj)
  75     assert((&GetCommandInterpreter() == &cmd_obj->GetCommandInterpreter()) &&
  76            "tried to add a CommandObject from a different interpreter");
  77
  78   CommandMap::iterator pos;
  79   bool success = true;
  80
  81   pos = m_subcommand_dict.find(name);
  82   if (pos == m_subcommand_dict.end()) {
  83     m_subcommand_dict[name] = cmd_obj;
  84   } else
  85     success = false;
  86
  87   return success;
  88 }
  89
  90 bool CommandObjectMultiword::Execute(const char *args_string,
  91                                      CommandReturnObject &result) {
  92   Args args(args_string);
  93   const size_t argc = args.GetArgumentCount();
  94   if (argc == 0) {
  95     this->CommandObject::GenerateHelpText(result);
  96     return result.Succeeded();
  97   }
  98
  99   auto sub_command = args[0].ref;
 100   if (sub_command.empty())
 101     return result.Succeeded();
 102
 103   if (sub_command.equals_lower("help")) {
 104     this->CommandObject::GenerateHelpText(result);
 105     return result.Succeeded();
 106   }
 107
 108   if (m_subcommand_dict.empty()) {
 109     result.AppendErrorWithFormat("'%s' does not have any subcommands.\n",
 110                                  GetCommandName().str().c_str());
 111     result.SetStatus(eReturnStatusFailed);
 112     return false;
 113   }
 114
 115   StringList matches;
 116   CommandObject *sub_cmd_obj = GetSubcommandObject(sub_command, &matches);
 117   if (sub_cmd_obj != nullptr) {
 118     // Now call CommandObject::Execute to process options in `rest_of_line`.
 119     // From there the command-specific version of Execute will be called, with
 120     // the processed arguments.
 121
 122     args.Shift();
 123     sub_cmd_obj->Execute(args_string, result);
 124     return result.Succeeded();
 125   }
 126
 127   std::string error_msg;
 128   const size_t num_subcmd_matches = matches.GetSize();
 129   if (num_subcmd_matches > 0)
 130     error_msg.assign("ambiguous command ");
 131   else
 132     error_msg.assign("invalid command ");
 133
 134   error_msg.append("'");
 135   error_msg.append(GetCommandName());
 136   error_msg.append(" ");
 137   error_msg.append(sub_command);
 138   error_msg.append("'.");
 139
 140   if (num_subcmd_matches > 0) {
 141     error_msg.append(" Possible completions:");
 142     for (size_t i = 0; i < matches.GetSize(); i++) {
 143       error_msg.append("\n\t");
 144       error_msg.append(matches.GetStringAtIndex(i));
 145     }
 146   }
 147   error_msg.append("\n");
 148   result.AppendRawError(error_msg.c_str());
 149   result.SetStatus(eReturnStatusFailed);
 150   return false;
 151 }
 152
 153 void CommandObjectMultiword::GenerateHelpText(Stream &output_stream) {
 154   // First time through here, generate the help text for the object and push it
 155   // to the return result object as well
 156
 157   CommandObject::GenerateHelpText(output_stream);
 158   output_stream.PutCString("\nThe following subcommands are supported:\n\n");
 159
 160   CommandMap::iterator pos;
 161   uint32_t max_len = FindLongestCommandWord(m_subcommand_dict);
 162
 163   if (max_len)
 164     max_len += 4; // Indent the output by 4 spaces.
 165
 166   for (pos = m_subcommand_dict.begin(); pos != m_subcommand_dict.end(); ++pos) {
 167     std::string indented_command("    ");
 168     indented_command.append(pos->first);
 169     if (pos->second->WantsRawCommandString()) {
 170       std::string help_text(pos->second->GetHelp());
 171       help_text.append("  Expects 'raw' input (see 'help raw-input'.)");
 172       m_interpreter.OutputFormattedHelpText(output_stream,
 173                                             indented_command.c_str(), "--",
 174                                             help_text.c_str(), max_len);
 175     } else
 176       m_interpreter.OutputFormattedHelpText(output_stream,
 177                                             indented_command.c_str(), "--",
 178                                             pos->second->GetHelp(), max_len);
 179   }
 180
 181   output_stream.PutCString("\nFor more help on any particular subcommand, type "
 182                            "'help <command> <subcommand>'.\n");
 183 }
 184
 185 int CommandObjectMultiword::HandleCompletion(CompletionRequest &request) {
 186   // Any of the command matches will provide a complete word, otherwise the
 187   // individual completers will override this.
 188   request.SetWordComplete(true);
 189
 190   auto arg0 = request.GetParsedLine()[0].ref;
 191   if (request.GetCursorIndex() == 0) {
 192     StringList new_matches, descriptions;
 193     AddNamesMatchingPartialString(m_subcommand_dict, arg0, new_matches,
 194                                   &descriptions);
 195     request.AddCompletions(new_matches, descriptions);
 196
 197     if (new_matches.GetSize() == 1 &&
 198         new_matches.GetStringAtIndex(0) != nullptr &&
 199         (arg0 == new_matches.GetStringAtIndex(0))) {
 200       StringList temp_matches;
 201       CommandObject *cmd_obj = GetSubcommandObject(arg0, &temp_matches);
 202       if (cmd_obj != nullptr) {
 203         if (request.GetParsedLine().GetArgumentCount() == 1) {
 204           request.SetWordComplete(true);
 205         } else {
 206           request.GetParsedLine().Shift();
 207           request.SetCursorCharPosition(0);
 208           request.GetParsedLine().AppendArgument(llvm::StringRef());
 209           return cmd_obj->HandleCompletion(request);
 210         }
 211       }
 212     }
 213     return new_matches.GetSize();
 214   } else {
 215     StringList new_matches;
 216     CommandObject *sub_command_object = GetSubcommandObject(arg0, &new_matches);
 217     if (sub_command_object == nullptr) {
 218       request.AddCompletions(new_matches);
 219       return request.GetNumberOfMatches();
 220     } else {
 221       // Remove the one match that we got from calling GetSubcommandObject.
 222       new_matches.DeleteStringAtIndex(0);
 223       request.AddCompletions(new_matches);
 224       request.GetParsedLine().Shift();
 225       request.SetCursorIndex(request.GetCursorIndex() - 1);
 226       return sub_command_object->HandleCompletion(request);
 227     }
 228   }
 229 }
 230
 231 const char *CommandObjectMultiword::GetRepeatCommand(Args &current_command_args,
 232                                                      uint32_t index) {
 233   index++;
 234   if (current_command_args.GetArgumentCount() <= index)
 235     return nullptr;
 236   CommandObject *sub_command_object =
 237       GetSubcommandObject(current_command_args[index].ref);
 238   if (sub_command_object == nullptr)
 239     return nullptr;
 240   return sub_command_object->GetRepeatCommand(current_command_args, index);
 241 }
 242
 243 void CommandObjectMultiword::AproposAllSubCommands(llvm::StringRef prefix,
 244                                                    llvm::StringRef search_word,
 245                                                    StringList &commands_found,
 246                                                    StringList &commands_help) {
 247   CommandObject::CommandMap::const_iterator pos;
 248
 249   for (pos = m_subcommand_dict.begin(); pos != m_subcommand_dict.end(); ++pos) {
 250     const char *command_name = pos->first.c_str();
 251     CommandObject *sub_cmd_obj = pos->second.get();
 252     StreamString complete_command_name;
 253
 254     complete_command_name << prefix << " " << command_name;
 255
 256     if (sub_cmd_obj->HelpTextContainsWord(search_word)) {
 257       commands_found.AppendString(complete_command_name.GetString());
 258       commands_help.AppendString(sub_cmd_obj->GetHelp());
 259     }
 260
 261     if (sub_cmd_obj->IsMultiwordObject())
 262       sub_cmd_obj->AproposAllSubCommands(complete_command_name.GetString(),
 263                                          search_word, commands_found,
 264                                          commands_help);
 265   }
 266 }
 267
 268 CommandObjectProxy::CommandObjectProxy(CommandInterpreter &interpreter,
 269                                        const char *name, const char *help,
 270                                        const char *syntax, uint32_t flags)
 271     : CommandObject(interpreter, name, help, syntax, flags) {}
 272
 273 CommandObjectProxy::~CommandObjectProxy() = default;
 274
 275 llvm::StringRef CommandObjectProxy::GetHelpLong() {
 276   CommandObject *proxy_command = GetProxyCommandObject();
 277   if (proxy_command)
 278     return proxy_command->GetHelpLong();
 279   return llvm::StringRef();
 280 }
 281
 282 bool CommandObjectProxy::IsRemovable() const {
 283   const CommandObject *proxy_command =
 284       const_cast<CommandObjectProxy *>(this)->GetProxyCommandObject();
 285   if (proxy_command)
 286     return proxy_command->IsRemovable();
 287   return false;
 288 }
 289
 290 bool CommandObjectProxy::IsMultiwordObject() {
 291   CommandObject *proxy_command = GetProxyCommandObject();
 292   if (proxy_command)
 293     return proxy_command->IsMultiwordObject();
 294   return false;
 295 }
 296
 297 CommandObjectMultiword *CommandObjectProxy::GetAsMultiwordCommand() {
 298   CommandObject *proxy_command = GetProxyCommandObject();
 299   if (proxy_command)
 300     return proxy_command->GetAsMultiwordCommand();
 301   return nullptr;
 302 }
 303
 304 void CommandObjectProxy::GenerateHelpText(Stream &result) {
 305   CommandObject *proxy_command = GetProxyCommandObject();
 306   if (proxy_command)
 307     return proxy_command->GenerateHelpText(result);
 308 }
 309
 310 lldb::CommandObjectSP
 311 CommandObjectProxy::GetSubcommandSP(llvm::StringRef sub_cmd,
 312                                     StringList *matches) {
 313   CommandObject *proxy_command = GetProxyCommandObject();
 314   if (proxy_command)
 315     return proxy_command->GetSubcommandSP(sub_cmd, matches);
 316   return lldb::CommandObjectSP();
 317 }
 318
 319 CommandObject *CommandObjectProxy::GetSubcommandObject(llvm::StringRef sub_cmd,
 320                                                        StringList *matches) {
 321   CommandObject *proxy_command = GetProxyCommandObject();
 322   if (proxy_command)
 323     return proxy_command->GetSubcommandObject(sub_cmd, matches);
 324   return nullptr;
 325 }
 326
 327 void CommandObjectProxy::AproposAllSubCommands(llvm::StringRef prefix,
 328                                                llvm::StringRef search_word,
 329                                                StringList &commands_found,
 330                                                StringList &commands_help) {
 331   CommandObject *proxy_command = GetProxyCommandObject();
 332   if (proxy_command)
 333     return proxy_command->AproposAllSubCommands(prefix, search_word,
 334                                                 commands_found, commands_help);
 335 }
 336
 337 bool CommandObjectProxy::LoadSubCommand(
 338     llvm::StringRef cmd_name, const lldb::CommandObjectSP &command_sp) {
 339   CommandObject *proxy_command = GetProxyCommandObject();
 340   if (proxy_command)
 341     return proxy_command->LoadSubCommand(cmd_name, command_sp);
 342   return false;
 343 }
 344
 345 bool CommandObjectProxy::WantsRawCommandString() {
 346   CommandObject *proxy_command = GetProxyCommandObject();
 347   if (proxy_command)
 348     return proxy_command->WantsRawCommandString();
 349   return false;
 350 }
 351
 352 bool CommandObjectProxy::WantsCompletion() {
 353   CommandObject *proxy_command = GetProxyCommandObject();
 354   if (proxy_command)
 355     return proxy_command->WantsCompletion();
 356   return false;
 357 }
 358
 359 Options *CommandObjectProxy::GetOptions() {
 360   CommandObject *proxy_command = GetProxyCommandObject();
 361   if (proxy_command)
 362     return proxy_command->GetOptions();
 363   return nullptr;
 364 }
 365
 366 int CommandObjectProxy::HandleCompletion(CompletionRequest &request) {
 367   CommandObject *proxy_command = GetProxyCommandObject();
 368   if (proxy_command)
 369     return proxy_command->HandleCompletion(request);
 370   return 0;
 371 }
 372
 373 int CommandObjectProxy::HandleArgumentCompletion(
 374     CompletionRequest &request, OptionElementVector &opt_element_vector) {
 375   CommandObject *proxy_command = GetProxyCommandObject();
 376   if (proxy_command)
 377     return proxy_command->HandleArgumentCompletion(request, opt_element_vector);
 378   return 0;
 379 }
 380
 381 const char *CommandObjectProxy::GetRepeatCommand(Args &current_command_args,
 382                                                  uint32_t index) {
 383   CommandObject *proxy_command = GetProxyCommandObject();
 384   if (proxy_command)
 385     return proxy_command->GetRepeatCommand(current_command_args, index);
 386   return nullptr;
 387 }
 388
 389 bool CommandObjectProxy::Execute(const char *args_string,
 390                                  CommandReturnObject &result) {
 391   CommandObject *proxy_command = GetProxyCommandObject();
 392   if (proxy_command)
 393     return proxy_command->Execute(args_string, result);
 394   result.AppendError("command is not implemented");
 395   result.SetStatus(eReturnStatusFailed);
 396   return false;
 397 }