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