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