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");
189  }
190 
191  return result.GetStatus();
192 }
193 
195  lldb::SBFileSpec &file, lldb::SBExecutionContext &override_context,
202  file, override_context, options, result);
203 
204  if (!IsValid()) {
205  result->AppendError("SBCommandInterpreter is not valid.");
207  return;
208  }
209 
210  if (!file.IsValid()) {
211  SBStream s;
212  file.GetDescription(s);
213  result->AppendErrorWithFormat("File is not valid: %s.", s.GetData());
215  }
216 
217  FileSpec tmp_spec = file.ref();
218  if (override_context.get())
220  override_context.get()->Lock(true),
221  options.ref(),
222  result.ref());
223 
224  else
225  m_opaque_ptr->HandleCommandsFromFile(tmp_spec, options.ref(), result.ref());
226 }
227 
229  const char *current_line, const char *cursor, const char *last_char,
230  int match_start_point, int max_return_elements, SBStringList &matches) {
232  (const char *, const char *, const char *, int, int,
234  current_line, cursor, last_char, match_start_point,
235  max_return_elements, matches);
236 
237  SBStringList dummy_descriptions;
239  current_line, cursor, last_char, match_start_point, max_return_elements,
240  matches, dummy_descriptions);
241 }
242 
244  const char *current_line, const char *cursor, const char *last_char,
245  int match_start_point, int max_return_elements, SBStringList &matches,
246  SBStringList &descriptions) {
249  (const char *, const char *, const char *, int, int,
251  current_line, cursor, last_char, match_start_point,
252  max_return_elements, matches, descriptions);
253 
254  // Sanity check the arguments that are passed in: cursor & last_char have to
255  // be within the current_line.
256  if (current_line == nullptr || cursor == nullptr || last_char == nullptr)
257  return 0;
258 
259  if (cursor < current_line || last_char < current_line)
260  return 0;
261 
262  size_t current_line_size = strlen(current_line);
263  if (cursor - current_line > static_cast<ptrdiff_t>(current_line_size) ||
264  last_char - current_line > static_cast<ptrdiff_t>(current_line_size))
265  return 0;
266 
267  if (!IsValid())
268  return 0;
269 
270  lldb_private::StringList lldb_matches, lldb_descriptions;
271  CompletionResult result;
272  CompletionRequest request(current_line, cursor - current_line, result);
273  m_opaque_ptr->HandleCompletion(request);
274  result.GetMatches(lldb_matches);
275  result.GetDescriptions(lldb_descriptions);
276 
277  // Make the result array indexed from 1 again by adding the 'common prefix'
278  // of all completions as element 0. This is done to emulate the old API.
279  if (request.GetParsedLine().GetArgumentCount() == 0) {
280  // If we got an empty string, insert nothing.
281  lldb_matches.InsertStringAtIndex(0, "");
282  lldb_descriptions.InsertStringAtIndex(0, "");
283  } else {
284  // Now figure out if there is a common substring, and if so put that in
285  // element 0, otherwise put an empty string in element 0.
286  std::string command_partial_str = request.GetCursorArgumentPrefix().str();
287 
288  std::string common_prefix = lldb_matches.LongestCommonPrefix();
289  const size_t partial_name_len = command_partial_str.size();
290  common_prefix.erase(0, partial_name_len);
291 
292  // If we matched a unique single command, add a space... Only do this if
293  // the completer told us this was a complete word, however...
294  if (lldb_matches.GetSize() == 1) {
295  char quote_char = request.GetParsedArg().GetQuoteChar();
296  common_prefix =
297  Args::EscapeLLDBCommandArgument(common_prefix, quote_char);
298  if (request.GetParsedArg().IsQuoted())
299  common_prefix.push_back(quote_char);
300  common_prefix.push_back(' ');
301  }
302  lldb_matches.InsertStringAtIndex(0, common_prefix.c_str());
303  lldb_descriptions.InsertStringAtIndex(0, "");
304  }
305 
306  SBStringList temp_matches_list(&lldb_matches);
307  matches.AppendList(temp_matches_list);
308  SBStringList temp_descriptions_list(&lldb_descriptions);
309  descriptions.AppendList(temp_descriptions_list);
310  return result.GetNumberOfResults();
311 }
312 
314  const char *current_line, uint32_t cursor_pos, int match_start_point,
315  int max_return_elements, SBStringList &matches,
316  SBStringList &descriptions) {
319  (const char *, uint32_t, int, int, lldb::SBStringList &,
321  current_line, cursor_pos, match_start_point,
322  max_return_elements, matches, descriptions);
323 
324  const char *cursor = current_line + cursor_pos;
325  const char *last_char = current_line + strlen(current_line);
327  current_line, cursor, last_char, match_start_point, max_return_elements,
328  matches, descriptions);
329 }
330 
331 int SBCommandInterpreter::HandleCompletion(const char *current_line,
332  uint32_t cursor_pos,
333  int match_start_point,
334  int max_return_elements,
335  lldb::SBStringList &matches) {
337  (const char *, uint32_t, int, int, lldb::SBStringList &),
338  current_line, cursor_pos, match_start_point,
339  max_return_elements, matches);
340 
341  const char *cursor = current_line + cursor_pos;
342  const char *last_char = current_line + strlen(current_line);
343  return HandleCompletion(current_line, cursor, last_char, match_start_point,
344  max_return_elements, matches);
345 }
346 
349 
350  return (IsValid() ? m_opaque_ptr->HasCommands() : false);
351 }
352 
355 
356  return (IsValid() ? m_opaque_ptr->HasAliases() : false);
357 }
358 
361 
362  return (IsValid() ? m_opaque_ptr->HasAliasOptions() : false);
363 }
364 
367 
368  SBProcess sb_process;
369  ProcessSP process_sp;
370  if (IsValid()) {
371  TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
372  if (target_sp) {
373  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
374  process_sp = target_sp->GetProcessSP();
375  sb_process.SetSP(process_sp);
376  }
377  }
378 
379  return LLDB_RECORD_RESULT(sb_process);
380 }
381 
384  GetDebugger);
385 
386  SBDebugger sb_debugger;
387  if (IsValid())
388  sb_debugger.reset(m_opaque_ptr->GetDebugger().shared_from_this());
389 
390  return LLDB_RECORD_RESULT(sb_debugger);
391 }
392 
395 
396  return (IsValid() ? m_opaque_ptr->GetPromptOnQuit() : false);
397 }
398 
401 
402  if (IsValid())
404 }
405 
408  allow);
409 
410  if (m_opaque_ptr)
412 }
413 
416 
417  bool exited = false;
418  if (m_opaque_ptr)
419  m_opaque_ptr->GetQuitExitCode(exited);
420  return exited;
421 }
422 
425 
426  bool exited = false;
427  return (m_opaque_ptr ? m_opaque_ptr->GetQuitExitCode(exited) : 0);
428 }
429 
430 void SBCommandInterpreter::ResolveCommand(const char *command_line,
431  SBCommandReturnObject &result) {
433  (const char *, lldb::SBCommandReturnObject &),
434  command_line, result);
435 
436  result.Clear();
437  if (command_line && IsValid()) {
438  m_opaque_ptr->ResolveCommand(command_line, result.ref());
439  } else {
440  result->AppendError(
441  "SBCommandInterpreter or the command line is not valid");
443  }
444 }
445 
447 
449  assert(m_opaque_ptr);
450  return *m_opaque_ptr;
451 }
452 
454  lldb_private::CommandInterpreter *interpreter) {
455  m_opaque_ptr = interpreter;
456 }
457 
459  SBCommandReturnObject &result) {
461  (lldb::SBCommandReturnObject &), result);
462 
463  result.Clear();
464  if (IsValid()) {
465  TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
466  std::unique_lock<std::recursive_mutex> lock;
467  if (target_sp)
468  lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
470  } else {
471  result->AppendError("SBCommandInterpreter is not valid");
473  }
474 }
475 
477  SBCommandReturnObject &result, bool is_repl) {
479  (lldb::SBCommandReturnObject &, bool), result, is_repl);
480 
481  result.Clear();
482  if (IsValid()) {
483  TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
484  std::unique_lock<std::recursive_mutex> lock;
485  if (target_sp)
486  lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
487  m_opaque_ptr->SourceInitFileHome(result.ref(), is_repl);
488  } else {
489  result->AppendError("SBCommandInterpreter is not valid");
491  }
492 }
493 
495  SBCommandReturnObject &result) {
498  (lldb::SBCommandReturnObject &), result);
499 
500  result.Clear();
501  if (IsValid()) {
502  TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
503  std::unique_lock<std::recursive_mutex> lock;
504  if (target_sp)
505  lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
507  } else {
508  result->AppendError("SBCommandInterpreter is not valid");
510  }
511 }
512 
516 
517 
518  SBBroadcaster broadcaster(m_opaque_ptr, false);
519 
520 
521  return LLDB_RECORD_RESULT(broadcaster);
522 }
523 
527 
528  return CommandInterpreter::GetStaticBroadcasterClass().AsCString();
529 }
530 
532  const lldb::CommandArgumentType arg_type) {
535  (const lldb::CommandArgumentType), arg_type);
536 
537  return CommandObject::GetArgumentTypeAsCString(arg_type);
538 }
539 
541  const lldb::CommandArgumentType arg_type) {
544  (const lldb::CommandArgumentType), arg_type);
545 
546  return CommandObject::GetArgumentDescriptionAsCString(arg_type);
547 }
548 
550  const lldb::SBEvent &event) {
553  (const lldb::SBEvent &), event);
554 
555  return event.GetBroadcasterClass() ==
557 }
558 
560  const char *command_name, lldb::CommandOverrideCallback callback,
561  void *baton) {
563  (const char *, lldb::CommandOverrideCallback, void *),
564  command_name, callback, baton);
565 
566  if (command_name && command_name[0] && IsValid()) {
567  llvm::StringRef command_name_str = command_name;
568  CommandObject *cmd_obj =
569  m_opaque_ptr->GetCommandObjectForCommand(command_name_str);
570  if (cmd_obj) {
571  assert(command_name_str.empty());
572  cmd_obj->SetOverrideCallback(callback, baton);
573  return true;
574  }
575  }
576  return false;
577 }
578 
580  const char *help) {
582  (const char *, const char *), name, help);
583 
584  CommandObjectMultiword *new_command =
585  new CommandObjectMultiword(*m_opaque_ptr, name, help);
586  new_command->SetRemovable(true);
587  lldb::CommandObjectSP new_command_sp(new_command);
588  if (new_command_sp &&
589  m_opaque_ptr->AddUserCommand(name, new_command_sp, true))
590  return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp));
592 }
593 
595  const char *name, lldb::SBCommandPluginInterface *impl, const char *help) {
598  (const char *, lldb::SBCommandPluginInterface *, const char *), name,
599  impl, help);
600 
601  return LLDB_RECORD_RESULT(AddCommand(name, impl, help, /*syntax=*/nullptr,
602  /*auto_repeat_command=*/""))
603 }
604 
608  const char *help, const char *syntax) {
610  (const char *, lldb::SBCommandPluginInterface *,
611  const char *, const char *),
612  name, impl, help, syntax);
613  return LLDB_RECORD_RESULT(
614  AddCommand(name, impl, help, syntax, /*auto_repeat_command=*/""))
615 }
616 
618  const char *name, lldb::SBCommandPluginInterface *impl, const char *help,
619  const char *syntax, const char *auto_repeat_command) {
621  (const char *, lldb::SBCommandPluginInterface *,
622  const char *, const char *, const char *),
623  name, impl, help, syntax, auto_repeat_command);
624 
625  lldb::CommandObjectSP new_command_sp;
626  new_command_sp = std::make_shared<CommandPluginInterfaceImplementation>(
627  *m_opaque_ptr, name, impl, help, syntax, /*flags=*/0,
628  auto_repeat_command);
629 
630  if (new_command_sp &&
631  m_opaque_ptr->AddUserCommand(name, new_command_sp, true))
632  return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp));
634 }
635 
637 
638 SBCommand::SBCommand(lldb::CommandObjectSP cmd_sp) : m_opaque_sp(cmd_sp) {}
639 
642  return this->operator bool();
643 }
644 SBCommand::operator bool() const {
645  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommand, operator bool);
646 
647  return m_opaque_sp.get() != nullptr;
648 }
649 
650 const char *SBCommand::GetName() {
652 
653  return (IsValid() ? ConstString(m_opaque_sp->GetCommandName()).AsCString() : nullptr);
654 }
655 
656 const char *SBCommand::GetHelp() {
658 
659  return (IsValid() ? ConstString(m_opaque_sp->GetHelp()).AsCString()
660  : nullptr);
661 }
662 
663 const char *SBCommand::GetHelpLong() {
665 
666  return (IsValid() ? ConstString(m_opaque_sp->GetHelpLong()).AsCString()
667  : nullptr);
668 }
669 
670 void SBCommand::SetHelp(const char *help) {
671  LLDB_RECORD_METHOD(void, SBCommand, SetHelp, (const char *), help);
672 
673  if (IsValid())
674  m_opaque_sp->SetHelp(help);
675 }
676 
677 void SBCommand::SetHelpLong(const char *help) {
678  LLDB_RECORD_METHOD(void, SBCommand, SetHelpLong, (const char *), help);
679 
680  if (IsValid())
681  m_opaque_sp->SetHelpLong(help);
682 }
683 
685  const char *help) {
687  (const char *, const char *), name, help);
688 
689  if (!IsValid())
691  if (!m_opaque_sp->IsMultiwordObject())
694  m_opaque_sp->GetCommandInterpreter(), name, help);
695  new_command->SetRemovable(true);
696  lldb::CommandObjectSP new_command_sp(new_command);
697  if (new_command_sp && m_opaque_sp->LoadSubCommand(name, new_command_sp))
698  return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp));
700 }
701 
704  const char *help) {
707  (const char *, lldb::SBCommandPluginInterface *, const char *), name,
708  impl, help);
709  return LLDB_RECORD_RESULT(AddCommand(name, impl, help, /*syntax=*/nullptr,
710  /*auto_repeat_command=*/""))
711 }
712 
715  const char *help, const char *syntax) {
717  (const char *, lldb::SBCommandPluginInterface *,
718  const char *, const char *),
719  name, impl, help, syntax);
720  return LLDB_RECORD_RESULT(
721  AddCommand(name, impl, help, syntax, /*auto_repeat_command=*/""))
722 }
723 
726  const char *help, const char *syntax,
727  const char *auto_repeat_command) {
729  (const char *, lldb::SBCommandPluginInterface *,
730  const char *, const char *, const char *),
731  name, impl, help, syntax, auto_repeat_command);
732 
733  if (!IsValid())
735  if (!m_opaque_sp->IsMultiwordObject())
737  lldb::CommandObjectSP new_command_sp;
738  new_command_sp = std::make_shared<CommandPluginInterfaceImplementation>(
739  m_opaque_sp->GetCommandInterpreter(), name, impl, help, syntax,
740  /*flags=*/0, auto_repeat_command);
741  if (new_command_sp && m_opaque_sp->LoadSubCommand(name, new_command_sp))
742  return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp));
744 }
745 
748 
749  return (IsValid() ? m_opaque_sp->GetFlags().Get() : 0);
750 }
751 
753  LLDB_RECORD_METHOD(void, SBCommand, SetFlags, (uint32_t), flags);
754 
755  if (IsValid())
756  m_opaque_sp->GetFlags().Set(flags);
757 }
758 
759 namespace lldb_private {
760 namespace repro {
761 
766  (const lldb::SBCommandInterpreter &));
769  SBCommandInterpreter, operator=,(const lldb::SBCommandInterpreter &));
771  LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, operator bool, ());
772  LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, CommandExists,
773  (const char *));
774  LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, AliasExists,
775  (const char *));
776  LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, IsActive, ());
777  LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, WasInterrupted, ());
779  GetIOHandlerControlSequence, (char));
781  HandleCommand,
782  (const char *, lldb::SBCommandReturnObject &, bool));
784  HandleCommand,
785  (const char *, lldb::SBExecutionContext &,
786  lldb::SBCommandReturnObject &, bool));
787  LLDB_REGISTER_METHOD(void, SBCommandInterpreter, HandleCommandsFromFile,
791  LLDB_REGISTER_METHOD(int, SBCommandInterpreter, HandleCompletion,
792  (const char *, const char *, const char *, int, int,
793  lldb::SBStringList &));
795  HandleCompletionWithDescriptions,
796  (const char *, const char *, const char *, int, int,
799  HandleCompletionWithDescriptions,
800  (const char *, uint32_t, int, int,
803  int, SBCommandInterpreter, HandleCompletion,
804  (const char *, uint32_t, int, int, lldb::SBStringList &));
805  LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasCommands, ());
806  LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasAliases, ());
807  LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasAliasOptions, ());
810  ());
811  LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, GetPromptOnQuit, ());
812  LLDB_REGISTER_METHOD(void, SBCommandInterpreter, SetPromptOnQuit, (bool));
813  LLDB_REGISTER_METHOD(void, SBCommandInterpreter, AllowExitCodeOnQuit,
814  (bool));
815  LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasCustomQuitExitCode, ());
816  LLDB_REGISTER_METHOD(int, SBCommandInterpreter, GetQuitStatus, ());
817  LLDB_REGISTER_METHOD(void, SBCommandInterpreter, ResolveCommand,
818  (const char *, lldb::SBCommandReturnObject &));
820  SourceInitFileInHomeDirectory,
823  SourceInitFileInHomeDirectory,
824  (lldb::SBCommandReturnObject &, bool));
826  SourceInitFileInCurrentWorkingDirectory,
829  GetBroadcaster, ());
831  GetBroadcasterClass, ());
833  GetArgumentTypeAsCString,
834  (const lldb::CommandArgumentType));
836  GetArgumentDescriptionAsCString,
837  (const lldb::CommandArgumentType));
839  EventIsCommandInterpreterEvent,
840  (const lldb::SBEvent &));
842  AddMultiwordCommand, (const char *, const char *));
845  (const char *, lldb::SBCommandPluginInterface *, const char *));
847  (const char *, lldb::SBCommandPluginInterface *,
848  const char *, const char *));
850  (const char *, lldb::SBCommandPluginInterface *,
851  const char *, const char *, const char *));
853  LLDB_REGISTER_METHOD(bool, SBCommand, IsValid, ());
854  LLDB_REGISTER_METHOD_CONST(bool, SBCommand, operator bool, ());
855  LLDB_REGISTER_METHOD(const char *, SBCommand, GetName, ());
856  LLDB_REGISTER_METHOD(const char *, SBCommand, GetHelp, ());
857  LLDB_REGISTER_METHOD(const char *, SBCommand, GetHelpLong, ());
858  LLDB_REGISTER_METHOD(void, SBCommand, SetHelp, (const char *));
859  LLDB_REGISTER_METHOD(void, SBCommand, SetHelpLong, (const char *));
860  LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommand, AddMultiwordCommand,
861  (const char *, const char *));
863  lldb::SBCommand, SBCommand, AddCommand,
864  (const char *, lldb::SBCommandPluginInterface *, const char *));
866  (const char *, lldb::SBCommandPluginInterface *,
867  const char *, const char *));
869  (const char *, lldb::SBCommandPluginInterface *,
870  const char *, const char *, const char *));
871  LLDB_REGISTER_METHOD(uint32_t, SBCommand, GetFlags, ());
872  LLDB_REGISTER_METHOD(void, SBCommand, SetFlags, (uint32_t));
873 }
874 }
875 }
lldb_private::CommandInterpreter::GetPromptOnQuit
bool GetPromptOnQuit() const
Definition: CommandInterpreter.cpp:141
lldb::SBCommandReturnObject::ref
lldb_private::CommandReturnObject & ref() const
Definition: SBCommandReturnObject.cpp:226
lldb::SBStringList
Definition: SBStringList.h:16
lldb_private::CommandObjectParsed
Definition: CommandObject.h:378
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:458
lldb::SBCommandPluginInterface
Definition: SBCommandInterpreter.h:279
lldb::SBCommandInterpreter::~SBCommandInterpreter
~SBCommandInterpreter()
lldb::SBCommandInterpreter::get
lldb_private::CommandInterpreter * get()
Definition: SBCommandInterpreter.cpp:446
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:423
lldb::SBCommandInterpreter
Definition: SBCommandInterpreter.h:19
SBStringList.h
lldb::SBCommand::AddMultiwordCommand
lldb::SBCommand AddMultiwordCommand(const char *name, const char *help=nullptr)
Definition: SBCommandInterpreter.cpp:684
lldb::SBProcess::SetSP
void SetSP(const lldb::ProcessSP &process_sp)
Definition: SBProcess.cpp:109
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:406
lldb::SBCommandInterpreter::HasCommands
bool HasCommands()
Definition: SBCommandInterpreter.cpp:347
lldb_private::CommandInterpreter::HasCommands
bool HasCommands() const
lldb::SBCommandInterpreter::GetPromptOnQuit
bool GetPromptOnQuit()
Definition: SBCommandInterpreter.cpp:393
lldb::SBCommand::SetFlags
void SetFlags(uint32_t flags)
Definition: SBCommandInterpreter.cpp:752
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:365
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:524
lldb::SBCommand::GetFlags
uint32_t GetFlags()
Definition: SBCommandInterpreter.cpp:746
lldb::SBEvent
Definition: SBEvent.h:21
lldb::SBProcess
Definition: SBProcess.h:23
lldb::SBCommandInterpreter::GetDebugger
lldb::SBDebugger GetDebugger()
Definition: SBCommandInterpreter.cpp:382
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:936
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_private::CommandInterpreter::AddUserCommand
bool AddUserCommand(llvm::StringRef name, const lldb::CommandObjectSP &cmd_sp, bool can_replace)
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:616
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:185
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:62
lldb_private::CommandObjectMultiword
Definition: CommandObjectMultiword.h:19
SBStream.h
lldb::SBCommandInterpreter::AddMultiwordCommand
lldb::SBCommand AddMultiwordCommand(const char *name, const char *help)
Definition: SBCommandInterpreter.cpp:579
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:494
lldb::SBCommand::GetHelpLong
const char * GetHelpLong()
Definition: SBCommandInterpreter.cpp:663
lldb_private::CommandReturnObject::SetStatus
void SetStatus(lldb::ReturnStatus status)
Definition: CommandReturnObject.cpp:131
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:198
lldb::SBCommandReturnObject::GetStatus
lldb::ReturnStatus GetStatus()
Definition: SBCommandReturnObject.cpp:174
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:353
lldb_private::CommandInterpreter::ResolveCommand
void ResolveCommand(const char *command_line, CommandReturnObject &result)
Definition: CommandInterpreter.cpp:205
lldb::SBCommandInterpreter::GetBroadcaster
lldb::SBBroadcaster GetBroadcaster()
Definition: SBCommandInterpreter.cpp:513
lldb_private::StringList::LongestCommonPrefix
std::string LongestCommonPrefix()
Definition: StringList.cpp:101
lldb::SBCommandInterpreter::ref
lldb_private::CommandInterpreter & ref()
Definition: SBCommandInterpreter.cpp:448
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:414
lldb::SBCommandInterpreter::GetArgumentTypeAsCString
static const char * GetArgumentTypeAsCString(const lldb::CommandArgumentType arg_type)
Definition: SBCommandInterpreter.cpp:531
lldb_private::CommandInterpreter
Definition: CommandInterpreter.h:221
lldb_private::CommandInterpreter::AliasExists
bool AliasExists(llvm::StringRef cmd) const
CommandObjectMultiword.h
lldb::eReturnStatusFailed
@ eReturnStatusFailed
Definition: lldb-enumerations.h:265
lldb::SBCommandInterpreter::SBCommandInterpreter
SBCommandInterpreter(const lldb::SBCommandInterpreter &rhs)
Definition: SBCommandInterpreter.cpp:86
lldb::SBCommandReturnObject::Clear
void Clear()
Definition: SBCommandReturnObject.cpp:168
lldb::SBCommand::SetHelpLong
void SetHelpLong(const char *)
Definition: SBCommandInterpreter.cpp:677
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
string
string(SUBSTRING ${p} 10 -1 pStripped) if($
Definition: Plugins/CMakeLists.txt:38
lldb::SBDebugger::reset
void reset(const lldb::DebuggerSP &debugger_sp)
Definition: SBDebugger.cpp:1275
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:656
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:228
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:702
lldb-types.h
lldb_private::repro::RegisterMethods< SBCommandInterpreter >
void RegisterMethods< SBCommandInterpreter >(Registry &R)
Definition: SBCommandInterpreter.cpp:762
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:284
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:594
lldb::SBCommandInterpreter::HasAliasOptions
bool HasAliasOptions()
Definition: SBCommandInterpreter.cpp:359
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:400
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:430
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:194
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:167
SBExecutionContext.h
lldb::SBCommand::SetHelp
void SetHelp(const char *)
Definition: SBCommandInterpreter.cpp:670
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:540
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:48
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:636
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:453
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:243
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:399
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:549
lldb::SBCommandInterpreter::SetCommandOverrideCallback
bool SetCommandOverrideCallback(const char *command_name, lldb::CommandOverrideCallback callback, void *baton)
Definition: SBCommandInterpreter.cpp:559
lldb::SBCommand::GetName
const char * GetName()
Definition: SBCommandInterpreter.cpp:650
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:640
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