LLDB  mainline
SBCommandInterpreter.cpp
Go to the documentation of this file.
1 //===-- SBCommandInterpreter.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 
9 #include "lldb/lldb-types.h"
10 
11 #include "SBReproducerPrivate.h"
15 #include "lldb/Target/Target.h"
16 #include "lldb/Utility/Listener.h"
17 
18 #include "lldb/API/SBBroadcaster.h"
22 #include "lldb/API/SBEvent.h"
24 #include "lldb/API/SBListener.h"
25 #include "lldb/API/SBProcess.h"
26 #include "lldb/API/SBStream.h"
27 #include "lldb/API/SBStringList.h"
28 #include "lldb/API/SBTarget.h"
29 
30 #include <memory>
31 
32 using namespace lldb;
33 using namespace lldb_private;
34 
36 public:
38  const char *name,
40  const char *help = nullptr,
41  const char *syntax = nullptr,
42  uint32_t flags = 0,
43  const char *auto_repeat_command = "")
44  : CommandObjectParsed(interpreter, name, help, syntax, flags),
45  m_backend(backend) {
46  m_auto_repeat_command =
47  auto_repeat_command == nullptr
48  ? llvm::None
49  : llvm::Optional<std::string>(auto_repeat_command);
50  }
51 
52  bool IsRemovable() const override { return true; }
53 
54  /// More documentation is available in lldb::CommandObject::GetRepeatCommand,
55  /// but in short, if nullptr is returned, the previous command will be
56  /// repeated, and if an empty string is returned, no commands will be
57  /// executed.
58  const char *GetRepeatCommand(Args &current_command_args,
59  uint32_t index) override {
60  if (!m_auto_repeat_command)
61  return nullptr;
62  else
63  return m_auto_repeat_command->c_str();
64  }
65 
66 protected:
67  bool DoExecute(Args &command, CommandReturnObject &result) override {
68  SBCommandReturnObject sb_return(result);
69  SBCommandInterpreter sb_interpreter(&m_interpreter);
70  SBDebugger debugger_sb(m_interpreter.GetDebugger().shared_from_this());
71  bool ret = m_backend->DoExecute(
72  debugger_sb, command.GetArgumentVector(), sb_return);
73  return ret;
74  }
75  std::shared_ptr<lldb::SBCommandPluginInterface> m_backend;
76  llvm::Optional<std::string> m_auto_repeat_command;
77 };
78 
80  : m_opaque_ptr(interpreter) {
82  (lldb_private::CommandInterpreter *), interpreter);
83 
84 }
85 
87  : m_opaque_ptr(rhs.m_opaque_ptr) {
89  (const lldb::SBCommandInterpreter &), rhs);
90 }
91 
93 
99  rhs);
100 
102  return LLDB_RECORD_RESULT(*this);
103 }
104 
107  return this->operator bool();
108 }
109 SBCommandInterpreter::operator bool() const {
111 
112  return m_opaque_ptr != nullptr;
113 }
114 
115 bool SBCommandInterpreter::CommandExists(const char *cmd) {
117  cmd);
118 
119  return (((cmd != nullptr) && IsValid()) ? m_opaque_ptr->CommandExists(cmd)
120  : false);
121 }
122 
123 bool SBCommandInterpreter::AliasExists(const char *cmd) {
124  LLDB_RECORD_METHOD(bool, SBCommandInterpreter, AliasExists, (const char *),
125  cmd);
126 
127  return (((cmd != nullptr) && IsValid()) ? m_opaque_ptr->AliasExists(cmd)
128  : false);
129 }
130 
133 
134  return (IsValid() ? m_opaque_ptr->IsActive() : false);
135 }
136 
139 
140  return (IsValid() ? m_opaque_ptr->WasInterrupted() : false);
141 }
142 
145  GetIOHandlerControlSequence, (char), ch);
146 
147  return (IsValid()
150  .GetCString()
151  : nullptr);
152 }
153 
155 SBCommandInterpreter::HandleCommand(const char *command_line,
156  SBCommandReturnObject &result,
157  bool add_to_history) {
159  (const char *, lldb::SBCommandReturnObject &, bool),
160  command_line, result, add_to_history);
161 
162  SBExecutionContext sb_exe_ctx;
163  return HandleCommand(command_line, sb_exe_ctx, result, add_to_history);
164 }
165 
167  const char *command_line, SBExecutionContext &override_context,
168  SBCommandReturnObject &result, bool add_to_history) {
170  (const char *, lldb::SBExecutionContext &,
172  command_line, override_context, result, add_to_history);
173 
174  result.Clear();
175  if (command_line && IsValid()) {
176  result.ref().SetInteractive(false);
177  auto do_add_to_history = add_to_history ? eLazyBoolYes : eLazyBoolNo;
178  if (override_context.get())
179  m_opaque_ptr->HandleCommand(command_line, do_add_to_history,
180  override_context.get()->Lock(true),
181  result.ref());
182  else
183  m_opaque_ptr->HandleCommand(command_line, do_add_to_history,
184  result.ref());
185  } else {
186  result->AppendError(
187  "SBCommandInterpreter or the command line is not valid");
188  }
189 
190  return result.GetStatus();
191 }
192 
194  lldb::SBFileSpec &file, lldb::SBExecutionContext &override_context,
201  file, override_context, options, result);
202 
203  if (!IsValid()) {
204  result->AppendError("SBCommandInterpreter is not valid.");
205  return;
206  }
207 
208  if (!file.IsValid()) {
209  SBStream s;
210  file.GetDescription(s);
211  result->AppendErrorWithFormat("File is not valid: %s.", s.GetData());
212  }
213 
214  FileSpec tmp_spec = file.ref();
215  if (override_context.get())
217  override_context.get()->Lock(true),
218  options.ref(),
219  result.ref());
220 
221  else
222  m_opaque_ptr->HandleCommandsFromFile(tmp_spec, options.ref(), result.ref());
223 }
224 
226  const char *current_line, const char *cursor, const char *last_char,
227  int match_start_point, int max_return_elements, SBStringList &matches) {
229  (const char *, const char *, const char *, int, int,
231  current_line, cursor, last_char, match_start_point,
232  max_return_elements, matches);
233 
234  SBStringList dummy_descriptions;
236  current_line, cursor, last_char, match_start_point, max_return_elements,
237  matches, dummy_descriptions);
238 }
239 
241  const char *current_line, const char *cursor, const char *last_char,
242  int match_start_point, int max_return_elements, SBStringList &matches,
243  SBStringList &descriptions) {
246  (const char *, const char *, const char *, int, int,
248  current_line, cursor, last_char, match_start_point,
249  max_return_elements, matches, descriptions);
250 
251  // Sanity check the arguments that are passed in: cursor & last_char have to
252  // be within the current_line.
253  if (current_line == nullptr || cursor == nullptr || last_char == nullptr)
254  return 0;
255 
256  if (cursor < current_line || last_char < current_line)
257  return 0;
258 
259  size_t current_line_size = strlen(current_line);
260  if (cursor - current_line > static_cast<ptrdiff_t>(current_line_size) ||
261  last_char - current_line > static_cast<ptrdiff_t>(current_line_size))
262  return 0;
263 
264  if (!IsValid())
265  return 0;
266 
267  lldb_private::StringList lldb_matches, lldb_descriptions;
268  CompletionResult result;
269  CompletionRequest request(current_line, cursor - current_line, result);
270  m_opaque_ptr->HandleCompletion(request);
271  result.GetMatches(lldb_matches);
272  result.GetDescriptions(lldb_descriptions);
273 
274  // Make the result array indexed from 1 again by adding the 'common prefix'
275  // of all completions as element 0. This is done to emulate the old API.
276  if (request.GetParsedLine().GetArgumentCount() == 0) {
277  // If we got an empty string, insert nothing.
278  lldb_matches.InsertStringAtIndex(0, "");
279  lldb_descriptions.InsertStringAtIndex(0, "");
280  } else {
281  // Now figure out if there is a common substring, and if so put that in
282  // element 0, otherwise put an empty string in element 0.
283  std::string command_partial_str = request.GetCursorArgumentPrefix().str();
284 
285  std::string common_prefix = lldb_matches.LongestCommonPrefix();
286  const size_t partial_name_len = command_partial_str.size();
287  common_prefix.erase(0, partial_name_len);
288 
289  // If we matched a unique single command, add a space... Only do this if
290  // the completer told us this was a complete word, however...
291  if (lldb_matches.GetSize() == 1) {
292  char quote_char = request.GetParsedArg().GetQuoteChar();
293  common_prefix =
294  Args::EscapeLLDBCommandArgument(common_prefix, quote_char);
295  if (request.GetParsedArg().IsQuoted())
296  common_prefix.push_back(quote_char);
297  common_prefix.push_back(' ');
298  }
299  lldb_matches.InsertStringAtIndex(0, common_prefix.c_str());
300  lldb_descriptions.InsertStringAtIndex(0, "");
301  }
302 
303  SBStringList temp_matches_list(&lldb_matches);
304  matches.AppendList(temp_matches_list);
305  SBStringList temp_descriptions_list(&lldb_descriptions);
306  descriptions.AppendList(temp_descriptions_list);
307  return result.GetNumberOfResults();
308 }
309 
311  const char *current_line, uint32_t cursor_pos, int match_start_point,
312  int max_return_elements, SBStringList &matches,
313  SBStringList &descriptions) {
316  (const char *, uint32_t, int, int, lldb::SBStringList &,
318  current_line, cursor_pos, match_start_point,
319  max_return_elements, matches, descriptions);
320 
321  const char *cursor = current_line + cursor_pos;
322  const char *last_char = current_line + strlen(current_line);
324  current_line, cursor, last_char, match_start_point, max_return_elements,
325  matches, descriptions);
326 }
327 
328 int SBCommandInterpreter::HandleCompletion(const char *current_line,
329  uint32_t cursor_pos,
330  int match_start_point,
331  int max_return_elements,
332  lldb::SBStringList &matches) {
334  (const char *, uint32_t, int, int, lldb::SBStringList &),
335  current_line, cursor_pos, match_start_point,
336  max_return_elements, matches);
337 
338  const char *cursor = current_line + cursor_pos;
339  const char *last_char = current_line + strlen(current_line);
340  return HandleCompletion(current_line, cursor, last_char, match_start_point,
341  max_return_elements, matches);
342 }
343 
346 
347  return (IsValid() ? m_opaque_ptr->HasCommands() : false);
348 }
349 
352 
353  return (IsValid() ? m_opaque_ptr->HasAliases() : false);
354 }
355 
358 
359  return (IsValid() ? m_opaque_ptr->HasAliasOptions() : false);
360 }
361 
364 
365  SBProcess sb_process;
366  ProcessSP process_sp;
367  if (IsValid()) {
368  TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
369  if (target_sp) {
370  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
371  process_sp = target_sp->GetProcessSP();
372  sb_process.SetSP(process_sp);
373  }
374  }
375 
376  return LLDB_RECORD_RESULT(sb_process);
377 }
378 
381  GetDebugger);
382 
383  SBDebugger sb_debugger;
384  if (IsValid())
385  sb_debugger.reset(m_opaque_ptr->GetDebugger().shared_from_this());
386 
387  return LLDB_RECORD_RESULT(sb_debugger);
388 }
389 
392 
393  return (IsValid() ? m_opaque_ptr->GetPromptOnQuit() : false);
394 }
395 
398 
399  if (IsValid())
401 }
402 
405  allow);
406 
407  if (m_opaque_ptr)
409 }
410 
413 
414  bool exited = false;
415  if (m_opaque_ptr)
416  m_opaque_ptr->GetQuitExitCode(exited);
417  return exited;
418 }
419 
422 
423  bool exited = false;
424  return (m_opaque_ptr ? m_opaque_ptr->GetQuitExitCode(exited) : 0);
425 }
426 
427 void SBCommandInterpreter::ResolveCommand(const char *command_line,
428  SBCommandReturnObject &result) {
430  (const char *, lldb::SBCommandReturnObject &),
431  command_line, result);
432 
433  result.Clear();
434  if (command_line && IsValid()) {
435  m_opaque_ptr->ResolveCommand(command_line, result.ref());
436  } else {
437  result->AppendError(
438  "SBCommandInterpreter or the command line is not valid");
439  }
440 }
441 
443 
445  assert(m_opaque_ptr);
446  return *m_opaque_ptr;
447 }
448 
450  lldb_private::CommandInterpreter *interpreter) {
451  m_opaque_ptr = interpreter;
452 }
453 
455  SBCommandReturnObject &result) {
457  (lldb::SBCommandReturnObject &), result);
458 
459  result.Clear();
460  if (IsValid()) {
461  TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
462  std::unique_lock<std::recursive_mutex> lock;
463  if (target_sp)
464  lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
466  } else {
467  result->AppendError("SBCommandInterpreter is not valid");
468  }
469 }
470 
472  SBCommandReturnObject &result, bool is_repl) {
474  (lldb::SBCommandReturnObject &, bool), result, is_repl);
475 
476  result.Clear();
477  if (IsValid()) {
478  TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
479  std::unique_lock<std::recursive_mutex> lock;
480  if (target_sp)
481  lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
482  m_opaque_ptr->SourceInitFileHome(result.ref(), is_repl);
483  } else {
484  result->AppendError("SBCommandInterpreter is not valid");
485  }
486 }
487 
489  SBCommandReturnObject &result) {
492  (lldb::SBCommandReturnObject &), result);
493 
494  result.Clear();
495  if (IsValid()) {
496  TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
497  std::unique_lock<std::recursive_mutex> lock;
498  if (target_sp)
499  lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
501  } else {
502  result->AppendError("SBCommandInterpreter is not valid");
503  }
504 }
505 
509 
510 
511  SBBroadcaster broadcaster(m_opaque_ptr, false);
512 
513 
514  return LLDB_RECORD_RESULT(broadcaster);
515 }
516 
520 
521  return CommandInterpreter::GetStaticBroadcasterClass().AsCString();
522 }
523 
525  const lldb::CommandArgumentType arg_type) {
528  (const lldb::CommandArgumentType), arg_type);
529 
530  return CommandObject::GetArgumentTypeAsCString(arg_type);
531 }
532 
534  const lldb::CommandArgumentType arg_type) {
537  (const lldb::CommandArgumentType), arg_type);
538 
539  return CommandObject::GetArgumentDescriptionAsCString(arg_type);
540 }
541 
543  const lldb::SBEvent &event) {
546  (const lldb::SBEvent &), event);
547 
548  return event.GetBroadcasterClass() ==
550 }
551 
553  const char *command_name, lldb::CommandOverrideCallback callback,
554  void *baton) {
556  (const char *, lldb::CommandOverrideCallback, void *),
557  command_name, callback, baton);
558 
559  if (command_name && command_name[0] && IsValid()) {
560  llvm::StringRef command_name_str = command_name;
561  CommandObject *cmd_obj =
562  m_opaque_ptr->GetCommandObjectForCommand(command_name_str);
563  if (cmd_obj) {
564  assert(command_name_str.empty());
565  cmd_obj->SetOverrideCallback(callback, baton);
566  return true;
567  }
568  }
569  return false;
570 }
571 
573  const char *help) {
575  (const char *, const char *), name, help);
576 
577  lldb::CommandObjectSP new_command_sp(
578  new CommandObjectMultiword(*m_opaque_ptr, name, help));
579  new_command_sp->GetAsMultiwordCommand()->SetRemovable(true);
580  Status add_error = m_opaque_ptr->AddUserCommand(name, new_command_sp, true);
581  if (add_error.Success())
582  return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp));
584 }
585 
587  const char *name, lldb::SBCommandPluginInterface *impl, const char *help) {
590  (const char *, lldb::SBCommandPluginInterface *, const char *), name,
591  impl, help);
592 
593  return LLDB_RECORD_RESULT(AddCommand(name, impl, help, /*syntax=*/nullptr,
594  /*auto_repeat_command=*/""))
595 }
596 
600  const char *help, const char *syntax) {
602  (const char *, lldb::SBCommandPluginInterface *,
603  const char *, const char *),
604  name, impl, help, syntax);
605  return LLDB_RECORD_RESULT(
606  AddCommand(name, impl, help, syntax, /*auto_repeat_command=*/""))
607 }
608 
610  const char *name, lldb::SBCommandPluginInterface *impl, const char *help,
611  const char *syntax, const char *auto_repeat_command) {
613  (const char *, lldb::SBCommandPluginInterface *,
614  const char *, const char *, const char *),
615  name, impl, help, syntax, auto_repeat_command);
616 
617  lldb::CommandObjectSP new_command_sp;
618  new_command_sp = std::make_shared<CommandPluginInterfaceImplementation>(
619  *m_opaque_ptr, name, impl, help, syntax, /*flags=*/0,
620  auto_repeat_command);
621 
622  Status add_error = m_opaque_ptr->AddUserCommand(name, new_command_sp, true);
623  if (add_error.Success())
624  return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp));
626 }
627 
629 
630 SBCommand::SBCommand(lldb::CommandObjectSP cmd_sp) : m_opaque_sp(cmd_sp) {}
631 
634  return this->operator bool();
635 }
636 SBCommand::operator bool() const {
637  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommand, operator bool);
638 
639  return m_opaque_sp.get() != nullptr;
640 }
641 
642 const char *SBCommand::GetName() {
644 
645  return (IsValid() ? ConstString(m_opaque_sp->GetCommandName()).AsCString() : nullptr);
646 }
647 
648 const char *SBCommand::GetHelp() {
650 
651  return (IsValid() ? ConstString(m_opaque_sp->GetHelp()).AsCString()
652  : nullptr);
653 }
654 
655 const char *SBCommand::GetHelpLong() {
657 
658  return (IsValid() ? ConstString(m_opaque_sp->GetHelpLong()).AsCString()
659  : nullptr);
660 }
661 
662 void SBCommand::SetHelp(const char *help) {
663  LLDB_RECORD_METHOD(void, SBCommand, SetHelp, (const char *), help);
664 
665  if (IsValid())
666  m_opaque_sp->SetHelp(help);
667 }
668 
669 void SBCommand::SetHelpLong(const char *help) {
670  LLDB_RECORD_METHOD(void, SBCommand, SetHelpLong, (const char *), help);
671 
672  if (IsValid())
673  m_opaque_sp->SetHelpLong(help);
674 }
675 
677  const char *help) {
679  (const char *, const char *), name, help);
680 
681  if (!IsValid())
683  if (!m_opaque_sp->IsMultiwordObject())
686  m_opaque_sp->GetCommandInterpreter(), name, help);
687  new_command->SetRemovable(true);
688  lldb::CommandObjectSP new_command_sp(new_command);
689  if (new_command_sp && m_opaque_sp->LoadSubCommand(name, new_command_sp))
690  return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp));
692 }
693 
696  const char *help) {
699  (const char *, lldb::SBCommandPluginInterface *, const char *), name,
700  impl, help);
701  return LLDB_RECORD_RESULT(AddCommand(name, impl, help, /*syntax=*/nullptr,
702  /*auto_repeat_command=*/""))
703 }
704 
707  const char *help, const char *syntax) {
709  (const char *, lldb::SBCommandPluginInterface *,
710  const char *, const char *),
711  name, impl, help, syntax);
712  return LLDB_RECORD_RESULT(
713  AddCommand(name, impl, help, syntax, /*auto_repeat_command=*/""))
714 }
715 
718  const char *help, const char *syntax,
719  const char *auto_repeat_command) {
721  (const char *, lldb::SBCommandPluginInterface *,
722  const char *, const char *, const char *),
723  name, impl, help, syntax, auto_repeat_command);
724 
725  if (!IsValid())
727  if (!m_opaque_sp->IsMultiwordObject())
729  lldb::CommandObjectSP new_command_sp;
730  new_command_sp = std::make_shared<CommandPluginInterfaceImplementation>(
731  m_opaque_sp->GetCommandInterpreter(), name, impl, help, syntax,
732  /*flags=*/0, auto_repeat_command);
733  if (new_command_sp && m_opaque_sp->LoadSubCommand(name, new_command_sp))
734  return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp));
736 }
737 
740 
741  return (IsValid() ? m_opaque_sp->GetFlags().Get() : 0);
742 }
743 
745  LLDB_RECORD_METHOD(void, SBCommand, SetFlags, (uint32_t), flags);
746 
747  if (IsValid())
748  m_opaque_sp->GetFlags().Set(flags);
749 }
750 
751 namespace lldb_private {
752 namespace repro {
753 
758  (const lldb::SBCommandInterpreter &));
761  SBCommandInterpreter, operator=,(const lldb::SBCommandInterpreter &));
763  LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, operator bool, ());
764  LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, CommandExists,
765  (const char *));
766  LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, AliasExists,
767  (const char *));
768  LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, IsActive, ());
769  LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, WasInterrupted, ());
771  GetIOHandlerControlSequence, (char));
773  HandleCommand,
774  (const char *, lldb::SBCommandReturnObject &, bool));
776  HandleCommand,
777  (const char *, lldb::SBExecutionContext &,
778  lldb::SBCommandReturnObject &, bool));
779  LLDB_REGISTER_METHOD(void, SBCommandInterpreter, HandleCommandsFromFile,
783  LLDB_REGISTER_METHOD(int, SBCommandInterpreter, HandleCompletion,
784  (const char *, const char *, const char *, int, int,
785  lldb::SBStringList &));
787  HandleCompletionWithDescriptions,
788  (const char *, const char *, const char *, int, int,
791  HandleCompletionWithDescriptions,
792  (const char *, uint32_t, int, int,
795  int, SBCommandInterpreter, HandleCompletion,
796  (const char *, uint32_t, int, int, lldb::SBStringList &));
797  LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasCommands, ());
798  LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasAliases, ());
799  LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasAliasOptions, ());
802  ());
803  LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, GetPromptOnQuit, ());
804  LLDB_REGISTER_METHOD(void, SBCommandInterpreter, SetPromptOnQuit, (bool));
805  LLDB_REGISTER_METHOD(void, SBCommandInterpreter, AllowExitCodeOnQuit,
806  (bool));
807  LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasCustomQuitExitCode, ());
808  LLDB_REGISTER_METHOD(int, SBCommandInterpreter, GetQuitStatus, ());
809  LLDB_REGISTER_METHOD(void, SBCommandInterpreter, ResolveCommand,
810  (const char *, lldb::SBCommandReturnObject &));
812  SourceInitFileInHomeDirectory,
815  SourceInitFileInHomeDirectory,
816  (lldb::SBCommandReturnObject &, bool));
818  SourceInitFileInCurrentWorkingDirectory,
821  GetBroadcaster, ());
823  GetBroadcasterClass, ());
825  GetArgumentTypeAsCString,
826  (const lldb::CommandArgumentType));
828  GetArgumentDescriptionAsCString,
829  (const lldb::CommandArgumentType));
831  EventIsCommandInterpreterEvent,
832  (const lldb::SBEvent &));
834  AddMultiwordCommand, (const char *, const char *));
837  (const char *, lldb::SBCommandPluginInterface *, const char *));
839  (const char *, lldb::SBCommandPluginInterface *,
840  const char *, const char *));
842  (const char *, lldb::SBCommandPluginInterface *,
843  const char *, const char *, const char *));
845  LLDB_REGISTER_METHOD(bool, SBCommand, IsValid, ());
846  LLDB_REGISTER_METHOD_CONST(bool, SBCommand, operator bool, ());
847  LLDB_REGISTER_METHOD(const char *, SBCommand, GetName, ());
848  LLDB_REGISTER_METHOD(const char *, SBCommand, GetHelp, ());
849  LLDB_REGISTER_METHOD(const char *, SBCommand, GetHelpLong, ());
850  LLDB_REGISTER_METHOD(void, SBCommand, SetHelp, (const char *));
851  LLDB_REGISTER_METHOD(void, SBCommand, SetHelpLong, (const char *));
852  LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommand, AddMultiwordCommand,
853  (const char *, const char *));
855  lldb::SBCommand, SBCommand, AddCommand,
856  (const char *, lldb::SBCommandPluginInterface *, const char *));
858  (const char *, lldb::SBCommandPluginInterface *,
859  const char *, const char *));
861  (const char *, lldb::SBCommandPluginInterface *,
862  const char *, const char *, const char *));
863  LLDB_REGISTER_METHOD(uint32_t, SBCommand, GetFlags, ());
864  LLDB_REGISTER_METHOD(void, SBCommand, SetFlags, (uint32_t));
865 }
866 }
867 }
lldb_private::CommandInterpreter::GetPromptOnQuit
bool GetPromptOnQuit() const
Definition: CommandInterpreter.cpp:141
lldb::SBCommandReturnObject::ref
lldb_private::CommandReturnObject & ref() const
Definition: SBCommandReturnObject.cpp:225
lldb::SBStringList
Definition: SBStringList.h:16
lldb_private::CommandObjectParsed
Definition: CommandObject.h:394
SBCommandInterpreterRunOptions.h
LLDB_RECORD_STATIC_METHOD_NO_ARGS
#define LLDB_RECORD_STATIC_METHOD_NO_ARGS(Result, Class, Method)
Definition: ReproducerInstrumentation.h:174
lldb::SBCommandInterpreter::SourceInitFileInHomeDirectory
void SourceInitFileInHomeDirectory(lldb::SBCommandReturnObject &result)
Definition: SBCommandInterpreter.cpp:454
lldb::SBCommandPluginInterface
Definition: SBCommandInterpreter.h:279
lldb::SBCommandInterpreter::~SBCommandInterpreter
~SBCommandInterpreter()
lldb::SBCommandInterpreter::get
lldb_private::CommandInterpreter * get()
Definition: SBCommandInterpreter.cpp:442
lldb_private::CompletionRequest::GetParsedArg
const Args::ArgEntry & GetParsedArg()
Definition: CompletionRequest.h:138
lldb_private::CommandInterpreter::GetCommandObjectForCommand
CommandObject * GetCommandObjectForCommand(llvm::StringRef &command_line)
LLDB_RECORD_RESULT
#define LLDB_RECORD_RESULT(Result)
Definition: ReproducerInstrumentation.h:211
lldb_private::CompletionRequest::GetParsedLine
const Args & GetParsedLine() const
Definition: CompletionRequest.h:134
lldb_private::CommandInterpreter::HandleCommand
bool HandleCommand(const char *command_line, LazyBool add_to_history, const ExecutionContext &override_context, CommandReturnObject &result)
CommandPluginInterfaceImplementation::DoExecute
bool DoExecute(Args &command, CommandReturnObject &result) override
Definition: SBCommandInterpreter.cpp:67
lldb::SBCommandReturnObject
Definition: SBCommandReturnObject.h:24
LLDB_RECORD_METHOD_CONST_NO_ARGS
#define LLDB_RECORD_METHOD_CONST_NO_ARGS(Result, Class, Method)
Definition: ReproducerInstrumentation.h:168
lldb::SBCommandInterpreter::GetQuitStatus
int GetQuitStatus()
Returns the exit code that the user has specified when running the 'quit' command.
Definition: SBCommandInterpreter.cpp:420
lldb::SBCommandInterpreter
Definition: SBCommandInterpreter.h:19
SBStringList.h
lldb::SBCommand::AddMultiwordCommand
lldb::SBCommand AddMultiwordCommand(const char *name, const char *help=nullptr)
Definition: SBCommandInterpreter.cpp:676
lldb::SBProcess::SetSP
void SetSP(const lldb::ProcessSP &process_sp)
Definition: SBProcess.cpp:108
lldb_private::eLazyBoolYes
@ eLazyBoolYes
Definition: lldb-private-enumerations.h:115
LLDB_RECORD_METHOD_NO_ARGS
#define LLDB_RECORD_METHOD_NO_ARGS(Result, Class, Method)
Definition: ReproducerInstrumentation.h:165
lldb::SBCommandInterpreter::AllowExitCodeOnQuit
void AllowExitCodeOnQuit(bool allow)
Sets whether the command interpreter should allow custom exit codes for the 'quit' command.
Definition: SBCommandInterpreter.cpp:403
lldb::SBCommandInterpreter::HasCommands
bool HasCommands()
Definition: SBCommandInterpreter.cpp:344
lldb_private::CommandInterpreter::HasCommands
bool HasCommands() const
lldb::SBCommandInterpreter::GetPromptOnQuit
bool GetPromptOnQuit()
Definition: SBCommandInterpreter.cpp:390
lldb::SBCommand::SetFlags
void SetFlags(uint32_t flags)
Definition: SBCommandInterpreter.cpp:744
CommandPluginInterfaceImplementation::GetRepeatCommand
const char * GetRepeatCommand(Args &current_command_args, uint32_t index) override
More documentation is available in lldb::CommandObject::GetRepeatCommand, but in short,...
Definition: SBCommandInterpreter.cpp:58
LLDB_RECORD_CONSTRUCTOR_NO_ARGS
#define LLDB_RECORD_CONSTRUCTOR_NO_ARGS(Class)
Definition: ReproducerInstrumentation.h:136
lldb::SBCommandInterpreter::GetProcess
lldb::SBProcess GetProcess()
Definition: SBCommandInterpreter.cpp:362
lldb_private::ConstString::AsCString
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
Definition: ConstString.h:193
LLDB_REGISTER_METHOD_CONST
#define LLDB_REGISTER_METHOD_CONST(Result, Class, Method, Signature)
Definition: ReproducerInstrumentation.h:98
lldb::SBExecutionContext::get
lldb_private::ExecutionContextRef * get() const
Definition: SBExecutionContext.cpp:80
lldb::SBCommandInterpreter::GetBroadcasterClass
static const char * GetBroadcasterClass()
Definition: SBCommandInterpreter.cpp:517
lldb::SBCommand::GetFlags
uint32_t GetFlags()
Definition: SBCommandInterpreter.cpp:738
lldb::SBEvent
Definition: SBEvent.h:21
lldb::SBProcess
Definition: SBProcess.h:23
lldb::SBCommandInterpreter::GetDebugger
lldb::SBDebugger GetDebugger()
Definition: SBCommandInterpreter.cpp:379
lldb_private::StringList::InsertStringAtIndex
void InsertStringAtIndex(size_t idx, const std::string &str)
Definition: StringList.cpp:127
lldb_private::Debugger::GetTopIOHandlerControlSequence
ConstString GetTopIOHandlerControlSequence(char ch)
Definition: Debugger.cpp:945
lldb_private::Args
Definition: Args.h:33
lldb_private::CompletionResult::GetMatches
void GetMatches(StringList &matches) const
Adds all collected completion matches to the given list.
Definition: CompletionRequest.cpp:71
SBReproducerPrivate.h
lldb_private::CommandInterpreter::SourceInitFileHome
void SourceInitFileHome(CommandReturnObject &result, bool is_repl=false)
LLDB_REGISTER_CONSTRUCTOR
#define LLDB_REGISTER_CONSTRUCTOR(Class, Signature)
Definition: ReproducerInstrumentation.h:89
lldb::SBCommandInterpreter::HandleCommand
lldb::ReturnStatus HandleCommand(const char *command_line, lldb::SBCommandReturnObject &result, bool add_to_history=false)
Definition: SBCommandInterpreter.cpp:155
CommandReturnObject.h
lldb_private::CommandInterpreter::SetPromptOnQuit
void SetPromptOnQuit(bool enable)
Definition: CommandInterpreter.cpp:147
Listener.h
SBListener.h
lldb::SBExecutionContext
Definition: SBExecutionContext.h:20
lldb_private::ExecutionContextRef::Lock
ExecutionContext Lock(bool thread_and_frame_only_if_stopped) const
Create an ExecutionContext object from this object.
Definition: ExecutionContext.cpp:615
lldb::SBCommandInterpreter::IsValid
bool IsValid() const
Definition: SBCommandInterpreter.cpp:105
lldb_private::CommandInterpreter::AllowExitCodeOnQuit
void AllowExitCodeOnQuit(bool allow)
Specify if the command interpreter should allow that the user can specify a custom exit code when cal...
Definition: CommandInterpreter.cpp:195
lldb_private::StringList::GetSize
size_t GetSize() const
Definition: StringList.cpp:68
lldb::SBFileSpec::GetDescription
bool GetDescription(lldb::SBStream &description) const
Definition: SBFileSpec.cpp:174
lldb::SBCommand::m_opaque_sp
lldb::CommandObjectSP m_opaque_sp
Definition: SBCommandInterpreter.h:404
Target.h
lldb::SBCommandInterpreter::GetIOHandlerControlSequence
const char * GetIOHandlerControlSequence(char ch)
Get the string that needs to be written to the debugger stdin file handle when a control character is...
Definition: SBCommandInterpreter.cpp:143
lldb_private::FileSpec
Definition: FileSpec.h:56
lldb_private::CommandObjectMultiword::SetRemovable
void SetRemovable(bool removable)
Definition: CommandObjectMultiword.h:70
lldb_private::CommandObjectMultiword
Definition: CommandObjectMultiword.h:19
lldb_private::Status::Success
bool Success() const
Test for success condition.
Definition: Status.cpp:288
SBStream.h
lldb::SBCommandInterpreter::AddMultiwordCommand
lldb::SBCommand AddMultiwordCommand(const char *name, const char *help)
Definition: SBCommandInterpreter.cpp:572
lldb_private::CommandInterpreter::HandleCompletion
void HandleCompletion(CompletionRequest &request)
lldb::CommandArgumentType
CommandArgumentType
Definition: lldb-enumerations.h:515
lldb::SBCommandInterpreterRunOptions::ref
lldb_private::CommandInterpreterRunOptions & ref() const
Definition: SBCommandInterpreterRunOptions.cpp:197
LLDB_RECORD_METHOD
#define LLDB_RECORD_METHOD(Result, Class, Method, Signature,...)
Definition: ReproducerInstrumentation.h:158
lldb::SBDebugger
Definition: SBDebugger.h:34
lldb::ReturnStatus
ReturnStatus
Command Return Status Types.
Definition: lldb-enumerations.h:258
lldb::SBCommandInterpreter::SourceInitFileInCurrentWorkingDirectory
void SourceInitFileInCurrentWorkingDirectory(lldb::SBCommandReturnObject &result)
Definition: SBCommandInterpreter.cpp:488
lldb::SBCommand::GetHelpLong
const char * GetHelpLong()
Definition: SBCommandInterpreter.cpp:655
lldb_private::CommandInterpreter::GetQuitExitCode
int GetQuitExitCode(bool &exited) const
Returns the exit code that the user has specified when running the 'quit' command.
Definition: CommandInterpreter.cpp:208
lldb::SBCommandReturnObject::GetStatus
lldb::ReturnStatus GetStatus()
Definition: SBCommandReturnObject.cpp:173
lldb::SBCommandInterpreter::AliasExists
bool AliasExists(const char *cmd)
Definition: SBCommandInterpreter.cpp:123
GetName
static llvm::StringRef GetName(XcodeSDK::Type type)
Definition: XcodeSDK.cpp:21
lldb_private::CommandInterpreter::SourceInitFileCwd
void SourceInitFileCwd(CommandReturnObject &result)
lldb_private::StringList
Definition: StringList.h:25
SBBroadcaster.h
lldb_private::ConstString
Definition: ConstString.h:40
lldb::SBCommandInterpreter::HasAliases
bool HasAliases()
Definition: SBCommandInterpreter.cpp:350
lldb_private::CommandInterpreter::ResolveCommand
void ResolveCommand(const char *command_line, CommandReturnObject &result)
Definition: CommandInterpreter.cpp:215
lldb::SBCommandInterpreter::GetBroadcaster
lldb::SBBroadcaster GetBroadcaster()
Definition: SBCommandInterpreter.cpp:506
lldb_private::StringList::LongestCommonPrefix
std::string LongestCommonPrefix()
Definition: StringList.cpp:101
lldb::SBCommandInterpreter::ref
lldb_private::CommandInterpreter & ref()
Definition: SBCommandInterpreter.cpp:444
lldb::SBFileSpec::ref
const lldb_private::FileSpec & ref() const
Definition: SBFileSpec.cpp:168
lldb::SBFileSpec::IsValid
bool IsValid() const
Definition: SBFileSpec.cpp:79
lldb::SBCommandInterpreter::HasCustomQuitExitCode
bool HasCustomQuitExitCode()
Returns true if the user has called the 'quit' command with a custom exit code.
Definition: SBCommandInterpreter.cpp:411
lldb::SBCommandInterpreter::GetArgumentTypeAsCString
static const char * GetArgumentTypeAsCString(const lldb::CommandArgumentType arg_type)
Definition: SBCommandInterpreter.cpp:524
lldb_private::CommandInterpreter
Definition: CommandInterpreter.h:214
lldb_private::CommandInterpreter::AliasExists
bool AliasExists(llvm::StringRef cmd) const
Determine whether an alias command with this name exists.
CommandObjectMultiword.h
lldb::SBCommandInterpreter::SBCommandInterpreter
SBCommandInterpreter(const lldb::SBCommandInterpreter &rhs)
Definition: SBCommandInterpreter.cpp:86
lldb::SBCommandReturnObject::Clear
void Clear()
Definition: SBCommandReturnObject.cpp:167
lldb::SBCommand::SetHelpLong
void SetHelpLong(const char *)
Definition: SBCommandInterpreter.cpp:669
lldb_private::CommandInterpreter::AddUserCommand
Status AddUserCommand(llvm::StringRef name, const lldb::CommandObjectSP &cmd_sp, bool can_replace)
lldb::SBCommand
Definition: SBCommandInterpreter.h:289
lldb_private::CompletionRequest::GetCursorArgumentPrefix
llvm::StringRef GetCursorArgumentPrefix() const
Definition: CompletionRequest.h:217
LLDB_REGISTER_STATIC_METHOD
#define LLDB_REGISTER_STATIC_METHOD(Result, Class, Method, Signature)
Definition: ReproducerInstrumentation.h:103
lldb_private::CommandInterpreter::HasAliases
bool HasAliases() const
lldb_private::CommandInterpreter::CommandExists
bool CommandExists(llvm::StringRef cmd) const
Determine whether a root level, built-in command with this name exists.
string
string(SUBSTRING ${p} 10 -1 pStripped) if($
Definition: Plugins/CMakeLists.txt:40
lldb::SBDebugger::reset
void reset(const lldb::DebuggerSP &debugger_sp)
Definition: SBDebugger.cpp:1274
lldb_private::Args::ArgEntry::GetQuoteChar
char GetQuoteChar() const
Definition: Args.h:55
lldb_private::CommandInterpreter::WasInterrupted
bool WasInterrupted() const
lldb::SBCommandInterpreter::CommandExists
bool CommandExists(const char *cmd)
Definition: SBCommandInterpreter.cpp:115
lldb::SBCommand::GetHelp
const char * GetHelp()
Definition: SBCommandInterpreter.cpp:648
lldb::SBCommandInterpreter::HandleCompletion
int HandleCompletion(const char *current_line, const char *cursor, const char *last_char, int match_start_point, int max_return_elements, lldb::SBStringList &matches)
Definition: SBCommandInterpreter.cpp:225
lldb::SBCommand::AddCommand
lldb::SBCommand AddCommand(const char *name, lldb::SBCommandPluginInterface *impl, const char *help=nullptr)
Add a new subcommand to the lldb::SBCommand.
Definition: SBCommandInterpreter.cpp:694
lldb-types.h
lldb_private::repro::RegisterMethods< SBCommandInterpreter >
void RegisterMethods< SBCommandInterpreter >(Registry &R)
Definition: SBCommandInterpreter.cpp:754
lldb_private::CommandObject
Definition: CommandObject.h:67
LLDB_RECORD_CONSTRUCTOR
#define LLDB_RECORD_CONSTRUCTOR(Class, Signature,...)
Definition: ReproducerInstrumentation.h:133
lldb_private::repro::Registry
The registry contains a unique mapping between functions and their ID.
Definition: ReproducerInstrumentation.h:517
lldb_private::CommandObject::SetOverrideCallback
void SetOverrideCallback(lldb::CommandOverrideCallback callback, void *baton)
Definition: CommandObject.h:299
lldb::SBCommandInterpreter::AddCommand
lldb::SBCommand AddCommand(const char *name, lldb::SBCommandPluginInterface *impl, const char *help)
Add a new command to the lldb::CommandInterpreter.
Definition: SBCommandInterpreter.cpp:586
lldb::SBCommandInterpreter::HasAliasOptions
bool HasAliasOptions()
Definition: SBCommandInterpreter.cpp:356
lldb_private::Status
Definition: Status.h:44
lldb_private::CommandReturnObject
Definition: CommandReturnObject.h:25
uint32_t
lldb_private::eLazyBoolNo
@ eLazyBoolNo
Definition: lldb-private-enumerations.h:115
lldb::SBCommandInterpreter::WasInterrupted
bool WasInterrupted() const
Definition: SBCommandInterpreter.cpp:137
CommandPluginInterfaceImplementation::IsRemovable
bool IsRemovable() const override
Definition: SBCommandInterpreter.cpp:52
lldb_private::CommandInterpreter::GetDebugger
Debugger & GetDebugger()
Definition: CommandInterpreter.h:436
lldb_private::CommandInterpreter::HasAliasOptions
bool HasAliasOptions() const
lldb::SBCommandInterpreter::ResolveCommand
void ResolveCommand(const char *command_line, SBCommandReturnObject &result)
Resolve the command just as HandleCommand would, expanding abbreviations and aliases.
Definition: SBCommandInterpreter.cpp:427
lldb_private::CommandInterpreter::HandleCommandsFromFile
void HandleCommandsFromFile(FileSpec &file, const ExecutionContext &context, const CommandInterpreterRunOptions &options, CommandReturnObject &result)
Execute a list of commands from a file.
lldb::SBCommandInterpreter::HandleCommandsFromFile
void HandleCommandsFromFile(lldb::SBFileSpec &file, lldb::SBExecutionContext &override_context, lldb::SBCommandInterpreterRunOptions &options, lldb::SBCommandReturnObject result)
Definition: SBCommandInterpreter.cpp:193
lldb_private::CommandInterpreter::IsActive
bool IsActive()
CommandPluginInterfaceImplementation::m_backend
std::shared_ptr< lldb::SBCommandPluginInterface > m_backend
Definition: SBCommandInterpreter.cpp:75
CommandPluginInterfaceImplementation::CommandPluginInterfaceImplementation
CommandPluginInterfaceImplementation(CommandInterpreter &interpreter, const char *name, lldb::SBCommandPluginInterface *backend, const char *help=nullptr, const char *syntax=nullptr, uint32_t flags=0, const char *auto_repeat_command="")
Definition: SBCommandInterpreter.cpp:37
lldb::SBCommandInterpreter::operator=
const lldb::SBCommandInterpreter & operator=(const lldb::SBCommandInterpreter &rhs)
Definition: SBCommandInterpreter.cpp:95
lldb_private::CommandReturnObject::SetInteractive
void SetInteractive(bool b)
Definition: CommandReturnObject.cpp:158
SBExecutionContext.h
lldb::SBCommand::SetHelp
void SetHelp(const char *)
Definition: SBCommandInterpreter.cpp:662
CommandPluginInterfaceImplementation::m_auto_repeat_command
llvm::Optional< std::string > m_auto_repeat_command
Definition: SBCommandInterpreter.cpp:76
lldb::SBCommandInterpreter::GetArgumentDescriptionAsCString
static const char * GetArgumentDescriptionAsCString(const lldb::CommandArgumentType arg_type)
Definition: SBCommandInterpreter.cpp:533
lldb_private::ConstString::GetCString
const char * GetCString() const
Get the string value as a C string.
Definition: ConstString.h:216
CommandPluginInterfaceImplementation
Definition: SBCommandInterpreter.cpp:35
lldb::SBFileSpec
Definition: SBFileSpec.h:16
SBEvent.h
lldb_private::Args::GetArgumentVector
char ** GetArgumentVector()
Gets the argument vector.
Definition: Args.cpp:265
lldb_private::CommandReturnObject::AppendErrorWithFormat
void AppendErrorWithFormat(const char *format,...) __attribute__((format(printf
Definition: CommandReturnObject.cpp:46
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::Debugger::GetSelectedTarget
lldb::TargetSP GetSelectedTarget()
Definition: Debugger.h:210
lldb::SBCommand::SBCommand
SBCommand()
Definition: SBCommandInterpreter.cpp:628
SBCommandReturnObject.h
lldb::CommandOverrideCallback
bool(* CommandOverrideCallback)(void *baton, const char **argv)
Definition: lldb-types.h:71
lldb::SBCommandInterpreter::reset
void reset(lldb_private::CommandInterpreter *)
Definition: SBCommandInterpreter.cpp:449
CommandInterpreter.h
lldb::SBBroadcaster
Definition: SBBroadcaster.h:16
SBProcess.h
SBCommandInterpreter.h
lldb::SBCommandInterpreter::HandleCompletionWithDescriptions
int HandleCompletionWithDescriptions(const char *current_line, const char *cursor, const char *last_char, int match_start_point, int max_return_elements, lldb::SBStringList &matches, lldb::SBStringList &descriptions)
Definition: SBCommandInterpreter.cpp:240
LLDB_RECORD_STATIC_METHOD
#define LLDB_RECORD_STATIC_METHOD(Result, Class, Method, Signature,...)
Definition: ReproducerInstrumentation.h:171
lldb::SBCommandInterpreterRunOptions
Definition: SBCommandInterpreterRunOptions.h:23
lldb::SBCommandInterpreter::SetPromptOnQuit
void SetPromptOnQuit(bool b)
Definition: SBCommandInterpreter.cpp:396
lldb_private::CompletionResult
Definition: CompletionRequest.h:38
LLDB_RECORD_DUMMY
#define LLDB_RECORD_DUMMY(Result, Class, Method, Signature,...)
The LLDB_RECORD_DUMMY macro is special because it doesn't actually record anything.
Definition: ReproducerInstrumentation.h:216
lldb::SBStream
Definition: SBStream.h:18
lldb_private::CompletionResult::GetNumberOfResults
std::size_t GetNumberOfResults() const
Definition: CompletionRequest.h:90
lldb::SBCommandInterpreter::EventIsCommandInterpreterEvent
static bool EventIsCommandInterpreterEvent(const lldb::SBEvent &event)
Definition: SBCommandInterpreter.cpp:542
lldb::SBCommandInterpreter::SetCommandOverrideCallback
bool SetCommandOverrideCallback(const char *command_name, lldb::CommandOverrideCallback callback, void *baton)
Definition: SBCommandInterpreter.cpp:552
lldb::SBCommand::GetName
const char * GetName()
Definition: SBCommandInterpreter.cpp:642
lldb_private::CommandReturnObject::AppendError
void void AppendError(llvm::StringRef in_string)
Definition: CommandReturnObject.cpp:100
SBTarget.h
lldb_private::Args::ArgEntry::IsQuoted
bool IsQuoted() const
Returns true if this argument was quoted in any way.
Definition: Args.h:54
lldb_private::Args::GetArgumentCount
size_t GetArgumentCount() const
Gets the number of arguments left in this command object.
Definition: Args.h:118
lldb_private::CompletionResult::GetDescriptions
void GetDescriptions(StringList &descriptions) const
Adds all collected completion descriptions to the given list.
Definition: CompletionRequest.cpp:77
lldb::SBCommandInterpreter::m_opaque_ptr
lldb_private::CommandInterpreter * m_opaque_ptr
Definition: SBCommandInterpreter.h:276
lldb
Definition: SBAddress.h:15
lldb::SBCommand::IsValid
bool IsValid()
Definition: SBCommandInterpreter.cpp:632
lldb::SBStringList::AppendList
void AppendList(const char **strv, int strc)
Definition: SBStringList.cpp:73
lldb::SBStream::GetData
const char * GetData()
Definition: SBStream.cpp:43
lldb_private::CompletionRequest
Definition: CompletionRequest.h:100
LLDB_REGISTER_METHOD
#define LLDB_REGISTER_METHOD(Result, Class, Method, Signature)
Definition: ReproducerInstrumentation.h:93
lldb::SBCommandInterpreter::IsActive
bool IsActive()
Return true if the command interpreter is the active IO handler.
Definition: SBCommandInterpreter.cpp:131