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"
12 #include "lldb/Interpreter/CommandInterpreter.h"
13 #include "lldb/Interpreter/CommandObjectMultiword.h"
14 #include "lldb/Interpreter/CommandReturnObject.h"
15 #include "lldb/Target/Target.h"
16 #include "lldb/Utility/Listener.h"
17 
18 #include "lldb/API/SBBroadcaster.h"
19 #include "lldb/API/SBCommandInterpreter.h"
20 #include "lldb/API/SBCommandInterpreterRunOptions.h"
21 #include "lldb/API/SBCommandReturnObject.h"
22 #include "lldb/API/SBEvent.h"
23 #include "lldb/API/SBExecutionContext.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 
35 class CommandPluginInterfaceImplementation : public CommandObjectParsed {
36 public:
37   CommandPluginInterfaceImplementation(CommandInterpreter &interpreter,
38                                        const char *name,
39                                        lldb::SBCommandPluginInterface *backend,
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 
79 SBCommandInterpreter::SBCommandInterpreter(CommandInterpreter *interpreter)
80     : m_opaque_ptr(interpreter) {
81   LLDB_RECORD_CONSTRUCTOR(SBCommandInterpreter,
82                           (lldb_private::CommandInterpreter *), interpreter);
83 
84 }
85 
86 SBCommandInterpreter::SBCommandInterpreter(const SBCommandInterpreter &rhs)
87     : m_opaque_ptr(rhs.m_opaque_ptr) {
88   LLDB_RECORD_CONSTRUCTOR(SBCommandInterpreter,
89                           (const lldb::SBCommandInterpreter &), rhs);
90 }
91 
92 SBCommandInterpreter::~SBCommandInterpreter() = default;
93 
94 const SBCommandInterpreter &SBCommandInterpreter::
95 operator=(const SBCommandInterpreter &rhs) {
96   LLDB_RECORD_METHOD(
97       const lldb::SBCommandInterpreter &,
98       SBCommandInterpreter, operator=,(const lldb::SBCommandInterpreter &),
99       rhs);
100 
101   m_opaque_ptr = rhs.m_opaque_ptr;
102   return LLDB_RECORD_RESULT(*this);
103 }
104 
105 bool SBCommandInterpreter::IsValid() const {
106   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreter, IsValid);
107   return this->operator bool();
108 }
109 SBCommandInterpreter::operator bool() const {
110   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreter, operator bool);
111 
112   return m_opaque_ptr != nullptr;
113 }
114 
115 bool SBCommandInterpreter::CommandExists(const char *cmd) {
116   LLDB_RECORD_METHOD(bool, SBCommandInterpreter, CommandExists, (const char *),
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 
131 bool SBCommandInterpreter::IsActive() {
132   LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, IsActive);
133 
134   return (IsValid() ? m_opaque_ptr->IsActive() : false);
135 }
136 
137 bool SBCommandInterpreter::WasInterrupted() const {
138   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreter, WasInterrupted);
139 
140   return (IsValid() ? m_opaque_ptr->WasInterrupted() : false);
141 }
142 
143 const char *SBCommandInterpreter::GetIOHandlerControlSequence(char ch) {
144   LLDB_RECORD_METHOD(const char *, SBCommandInterpreter,
145                      GetIOHandlerControlSequence, (char), ch);
146 
147   return (IsValid()
148               ? m_opaque_ptr->GetDebugger()
149                     .GetTopIOHandlerControlSequence(ch)
150                     .GetCString()
151               : nullptr);
152 }
153 
154 lldb::ReturnStatus
155 SBCommandInterpreter::HandleCommand(const char *command_line,
156                                     SBCommandReturnObject &result,
157                                     bool add_to_history) {
158   LLDB_RECORD_METHOD(lldb::ReturnStatus, SBCommandInterpreter, HandleCommand,
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 
166 lldb::ReturnStatus SBCommandInterpreter::HandleCommand(
167     const char *command_line, SBExecutionContext &override_context,
168     SBCommandReturnObject &result, bool add_to_history) {
169   LLDB_RECORD_METHOD(lldb::ReturnStatus, SBCommandInterpreter, HandleCommand,
170                      (const char *, lldb::SBExecutionContext &,
171                       lldb::SBCommandReturnObject &, bool),
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 
193 void SBCommandInterpreter::HandleCommandsFromFile(
194     lldb::SBFileSpec &file, lldb::SBExecutionContext &override_context,
195     lldb::SBCommandInterpreterRunOptions &options,
196     lldb::SBCommandReturnObject result) {
197   LLDB_RECORD_METHOD(void, SBCommandInterpreter, HandleCommandsFromFile,
198                      (lldb::SBFileSpec &, lldb::SBExecutionContext &,
199                       lldb::SBCommandInterpreterRunOptions &,
200                       lldb::SBCommandReturnObject),
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())
216     m_opaque_ptr->HandleCommandsFromFile(tmp_spec,
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 
225 int SBCommandInterpreter::HandleCompletion(
226     const char *current_line, const char *cursor, const char *last_char,
227     int match_start_point, int max_return_elements, SBStringList &matches) {
228   LLDB_RECORD_METHOD(int, SBCommandInterpreter, HandleCompletion,
229                      (const char *, const char *, const char *, int, int,
230                       lldb::SBStringList &),
231                      current_line, cursor, last_char, match_start_point,
232                      max_return_elements, matches);
233 
234   SBStringList dummy_descriptions;
235   return HandleCompletionWithDescriptions(
236       current_line, cursor, last_char, match_start_point, max_return_elements,
237       matches, dummy_descriptions);
238 }
239 
240 int SBCommandInterpreter::HandleCompletionWithDescriptions(
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) {
244   LLDB_RECORD_METHOD(int, SBCommandInterpreter,
245                      HandleCompletionWithDescriptions,
246                      (const char *, const char *, const char *, int, int,
247                       lldb::SBStringList &, lldb::SBStringList &),
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 
310 int SBCommandInterpreter::HandleCompletionWithDescriptions(
311     const char *current_line, uint32_t cursor_pos, int match_start_point,
312     int max_return_elements, SBStringList &matches,
313     SBStringList &descriptions) {
314   LLDB_RECORD_METHOD(int, SBCommandInterpreter,
315                      HandleCompletionWithDescriptions,
316                      (const char *, uint32_t, int, int, lldb::SBStringList &,
317                       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);
323   return HandleCompletionWithDescriptions(
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) {
333   LLDB_RECORD_METHOD(int, SBCommandInterpreter, HandleCompletion,
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 
344 bool SBCommandInterpreter::HasCommands() {
345   LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasCommands);
346 
347   return (IsValid() ? m_opaque_ptr->HasCommands() : false);
348 }
349 
350 bool SBCommandInterpreter::HasAliases() {
351   LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasAliases);
352 
353   return (IsValid() ? m_opaque_ptr->HasAliases() : false);
354 }
355 
356 bool SBCommandInterpreter::HasAliasOptions() {
357   LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasAliasOptions);
358 
359   return (IsValid() ? m_opaque_ptr->HasAliasOptions() : false);
360 }
361 
362 SBProcess SBCommandInterpreter::GetProcess() {
363   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBCommandInterpreter, GetProcess);
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 
379 SBDebugger SBCommandInterpreter::GetDebugger() {
380   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBDebugger, SBCommandInterpreter,
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 
390 bool SBCommandInterpreter::GetPromptOnQuit() {
391   LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, GetPromptOnQuit);
392 
393   return (IsValid() ? m_opaque_ptr->GetPromptOnQuit() : false);
394 }
395 
396 void SBCommandInterpreter::SetPromptOnQuit(bool b) {
397   LLDB_RECORD_METHOD(void, SBCommandInterpreter, SetPromptOnQuit, (bool), b);
398 
399   if (IsValid())
400     m_opaque_ptr->SetPromptOnQuit(b);
401 }
402 
403 void SBCommandInterpreter::AllowExitCodeOnQuit(bool allow) {
404   LLDB_RECORD_METHOD(void, SBCommandInterpreter, AllowExitCodeOnQuit, (bool),
405                      allow);
406 
407   if (m_opaque_ptr)
408     m_opaque_ptr->AllowExitCodeOnQuit(allow);
409 }
410 
411 bool SBCommandInterpreter::HasCustomQuitExitCode() {
412   LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasCustomQuitExitCode);
413 
414   bool exited = false;
415   if (m_opaque_ptr)
416     m_opaque_ptr->GetQuitExitCode(exited);
417   return exited;
418 }
419 
420 int SBCommandInterpreter::GetQuitStatus() {
421   LLDB_RECORD_METHOD_NO_ARGS(int, SBCommandInterpreter, GetQuitStatus);
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) {
429   LLDB_RECORD_METHOD(void, SBCommandInterpreter, ResolveCommand,
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 
442 CommandInterpreter *SBCommandInterpreter::get() { return m_opaque_ptr; }
443 
444 CommandInterpreter &SBCommandInterpreter::ref() {
445   assert(m_opaque_ptr);
446   return *m_opaque_ptr;
447 }
448 
449 void SBCommandInterpreter::reset(
450     lldb_private::CommandInterpreter *interpreter) {
451   m_opaque_ptr = interpreter;
452 }
453 
454 void SBCommandInterpreter::SourceInitFileInHomeDirectory(
455     SBCommandReturnObject &result) {
456   LLDB_RECORD_METHOD(void, SBCommandInterpreter, SourceInitFileInHomeDirectory,
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());
465     m_opaque_ptr->SourceInitFileHome(result.ref());
466   } else {
467     result->AppendError("SBCommandInterpreter is not valid");
468   }
469 }
470 
471 void SBCommandInterpreter::SourceInitFileInHomeDirectory(
472     SBCommandReturnObject &result, bool is_repl) {
473   LLDB_RECORD_METHOD(void, SBCommandInterpreter, SourceInitFileInHomeDirectory,
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 
488 void SBCommandInterpreter::SourceInitFileInCurrentWorkingDirectory(
489     SBCommandReturnObject &result) {
490   LLDB_RECORD_METHOD(void, SBCommandInterpreter,
491                      SourceInitFileInCurrentWorkingDirectory,
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());
500     m_opaque_ptr->SourceInitFileCwd(result.ref());
501   } else {
502     result->AppendError("SBCommandInterpreter is not valid");
503   }
504 }
505 
506 SBBroadcaster SBCommandInterpreter::GetBroadcaster() {
507   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBroadcaster, SBCommandInterpreter,
508                              GetBroadcaster);
509 
510 
511   SBBroadcaster broadcaster(m_opaque_ptr, false);
512 
513 
514   return LLDB_RECORD_RESULT(broadcaster);
515 }
516 
517 const char *SBCommandInterpreter::GetBroadcasterClass() {
518   LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBCommandInterpreter,
519                                     GetBroadcasterClass);
520 
521   return CommandInterpreter::GetStaticBroadcasterClass().AsCString();
522 }
523 
524 const char *SBCommandInterpreter::GetArgumentTypeAsCString(
525     const lldb::CommandArgumentType arg_type) {
526   LLDB_RECORD_STATIC_METHOD(const char *, SBCommandInterpreter,
527                             GetArgumentTypeAsCString,
528                             (const lldb::CommandArgumentType), arg_type);
529 
530   return CommandObject::GetArgumentTypeAsCString(arg_type);
531 }
532 
533 const char *SBCommandInterpreter::GetArgumentDescriptionAsCString(
534     const lldb::CommandArgumentType arg_type) {
535   LLDB_RECORD_STATIC_METHOD(const char *, SBCommandInterpreter,
536                             GetArgumentDescriptionAsCString,
537                             (const lldb::CommandArgumentType), arg_type);
538 
539   return CommandObject::GetArgumentDescriptionAsCString(arg_type);
540 }
541 
542 bool SBCommandInterpreter::EventIsCommandInterpreterEvent(
543     const lldb::SBEvent &event) {
544   LLDB_RECORD_STATIC_METHOD(bool, SBCommandInterpreter,
545                             EventIsCommandInterpreterEvent,
546                             (const lldb::SBEvent &), event);
547 
548   return event.GetBroadcasterClass() ==
549          SBCommandInterpreter::GetBroadcasterClass();
550 }
551 
552 bool SBCommandInterpreter::SetCommandOverrideCallback(
553     const char *command_name, lldb::CommandOverrideCallback callback,
554     void *baton) {
555   LLDB_RECORD_DUMMY(bool, SBCommandInterpreter, SetCommandOverrideCallback,
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 
572 lldb::SBCommand SBCommandInterpreter::AddMultiwordCommand(const char *name,
573                                                           const char *help) {
574   LLDB_RECORD_METHOD(lldb::SBCommand, SBCommandInterpreter, AddMultiwordCommand,
575                      (const char *, const char *), name, help);
576 
577   CommandObjectMultiword *new_command =
578       new CommandObjectMultiword(*m_opaque_ptr, name, help);
579   new_command->SetRemovable(true);
580   lldb::CommandObjectSP new_command_sp(new_command);
581   if (new_command_sp &&
582       m_opaque_ptr->AddUserCommand(name, new_command_sp, true))
583     return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp));
584   return LLDB_RECORD_RESULT(lldb::SBCommand());
585 }
586 
587 lldb::SBCommand SBCommandInterpreter::AddCommand(
588     const char *name, lldb::SBCommandPluginInterface *impl, const char *help) {
589   LLDB_RECORD_METHOD(
590       lldb::SBCommand, SBCommandInterpreter, AddCommand,
591       (const char *, lldb::SBCommandPluginInterface *, const char *), name,
592       impl, help);
593 
594   return LLDB_RECORD_RESULT(AddCommand(name, impl, help, /*syntax=*/nullptr,
595                                        /*auto_repeat_command=*/""))
596 }
597 
598 lldb::SBCommand
599 SBCommandInterpreter::AddCommand(const char *name,
600                                  lldb::SBCommandPluginInterface *impl,
601                                  const char *help, const char *syntax) {
602   LLDB_RECORD_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand,
603                      (const char *, lldb::SBCommandPluginInterface *,
604                       const char *, const char *),
605                      name, impl, help, syntax);
606   return LLDB_RECORD_RESULT(
607       AddCommand(name, impl, help, syntax, /*auto_repeat_command=*/""))
608 }
609 
610 lldb::SBCommand SBCommandInterpreter::AddCommand(
611     const char *name, lldb::SBCommandPluginInterface *impl, const char *help,
612     const char *syntax, const char *auto_repeat_command) {
613   LLDB_RECORD_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand,
614                      (const char *, lldb::SBCommandPluginInterface *,
615                       const char *, const char *, const char *),
616                      name, impl, help, syntax, auto_repeat_command);
617 
618   lldb::CommandObjectSP new_command_sp;
619   new_command_sp = std::make_shared<CommandPluginInterfaceImplementation>(
620       *m_opaque_ptr, name, impl, help, syntax, /*flags=*/0,
621       auto_repeat_command);
622 
623   if (new_command_sp &&
624       m_opaque_ptr->AddUserCommand(name, new_command_sp, true))
625     return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp));
626   return LLDB_RECORD_RESULT(lldb::SBCommand());
627 }
628 
629 SBCommand::SBCommand() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommand); }
630 
631 SBCommand::SBCommand(lldb::CommandObjectSP cmd_sp) : m_opaque_sp(cmd_sp) {}
632 
633 bool SBCommand::IsValid() {
634   LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommand, IsValid);
635   return this->operator bool();
636 }
637 SBCommand::operator bool() const {
638   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommand, operator bool);
639 
640   return m_opaque_sp.get() != nullptr;
641 }
642 
643 const char *SBCommand::GetName() {
644   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommand, GetName);
645 
646   return (IsValid() ? ConstString(m_opaque_sp->GetCommandName()).AsCString() : nullptr);
647 }
648 
649 const char *SBCommand::GetHelp() {
650   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommand, GetHelp);
651 
652   return (IsValid() ? ConstString(m_opaque_sp->GetHelp()).AsCString()
653                     : nullptr);
654 }
655 
656 const char *SBCommand::GetHelpLong() {
657   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommand, GetHelpLong);
658 
659   return (IsValid() ? ConstString(m_opaque_sp->GetHelpLong()).AsCString()
660                     : nullptr);
661 }
662 
663 void SBCommand::SetHelp(const char *help) {
664   LLDB_RECORD_METHOD(void, SBCommand, SetHelp, (const char *), help);
665 
666   if (IsValid())
667     m_opaque_sp->SetHelp(help);
668 }
669 
670 void SBCommand::SetHelpLong(const char *help) {
671   LLDB_RECORD_METHOD(void, SBCommand, SetHelpLong, (const char *), help);
672 
673   if (IsValid())
674     m_opaque_sp->SetHelpLong(help);
675 }
676 
677 lldb::SBCommand SBCommand::AddMultiwordCommand(const char *name,
678                                                const char *help) {
679   LLDB_RECORD_METHOD(lldb::SBCommand, SBCommand, AddMultiwordCommand,
680                      (const char *, const char *), name, help);
681 
682   if (!IsValid())
683     return LLDB_RECORD_RESULT(lldb::SBCommand());
684   if (!m_opaque_sp->IsMultiwordObject())
685     return LLDB_RECORD_RESULT(lldb::SBCommand());
686   CommandObjectMultiword *new_command = new CommandObjectMultiword(
687       m_opaque_sp->GetCommandInterpreter(), name, help);
688   new_command->SetRemovable(true);
689   lldb::CommandObjectSP new_command_sp(new_command);
690   if (new_command_sp && m_opaque_sp->LoadSubCommand(name, new_command_sp))
691     return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp));
692   return LLDB_RECORD_RESULT(lldb::SBCommand());
693 }
694 
695 lldb::SBCommand SBCommand::AddCommand(const char *name,
696                                       lldb::SBCommandPluginInterface *impl,
697                                       const char *help) {
698   LLDB_RECORD_METHOD(
699       lldb::SBCommand, SBCommand, AddCommand,
700       (const char *, lldb::SBCommandPluginInterface *, const char *), name,
701       impl, help);
702   return LLDB_RECORD_RESULT(AddCommand(name, impl, help, /*syntax=*/nullptr,
703                                        /*auto_repeat_command=*/""))
704 }
705 
706 lldb::SBCommand SBCommand::AddCommand(const char *name,
707                                       lldb::SBCommandPluginInterface *impl,
708                                       const char *help, const char *syntax) {
709   LLDB_RECORD_METHOD(lldb::SBCommand, SBCommand, AddCommand,
710                      (const char *, lldb::SBCommandPluginInterface *,
711                       const char *, const char *),
712                      name, impl, help, syntax);
713   return LLDB_RECORD_RESULT(
714       AddCommand(name, impl, help, syntax, /*auto_repeat_command=*/""))
715 }
716 
717 lldb::SBCommand SBCommand::AddCommand(const char *name,
718                                       lldb::SBCommandPluginInterface *impl,
719                                       const char *help, const char *syntax,
720                                       const char *auto_repeat_command) {
721   LLDB_RECORD_METHOD(lldb::SBCommand, SBCommand, AddCommand,
722                      (const char *, lldb::SBCommandPluginInterface *,
723                       const char *, const char *, const char *),
724                      name, impl, help, syntax, auto_repeat_command);
725 
726   if (!IsValid())
727     return LLDB_RECORD_RESULT(lldb::SBCommand());
728   if (!m_opaque_sp->IsMultiwordObject())
729     return LLDB_RECORD_RESULT(lldb::SBCommand());
730   lldb::CommandObjectSP new_command_sp;
731   new_command_sp = std::make_shared<CommandPluginInterfaceImplementation>(
732       m_opaque_sp->GetCommandInterpreter(), name, impl, help, syntax,
733       /*flags=*/0, auto_repeat_command);
734   if (new_command_sp && m_opaque_sp->LoadSubCommand(name, new_command_sp))
735     return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp));
736   return LLDB_RECORD_RESULT(lldb::SBCommand());
737 }
738 
739 uint32_t SBCommand::GetFlags() {
740   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBCommand, GetFlags);
741 
742   return (IsValid() ? m_opaque_sp->GetFlags().Get() : 0);
743 }
744 
745 void SBCommand::SetFlags(uint32_t flags) {
746   LLDB_RECORD_METHOD(void, SBCommand, SetFlags, (uint32_t), flags);
747 
748   if (IsValid())
749     m_opaque_sp->GetFlags().Set(flags);
750 }
751 
752 namespace lldb_private {
753 namespace repro {
754 
755 template <> void RegisterMethods<SBCommandInterpreter>(Registry &R) {
756   LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreter,
757                             (lldb_private::CommandInterpreter *));
758   LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreter,
759                             (const lldb::SBCommandInterpreter &));
760   LLDB_REGISTER_METHOD(
761       const lldb::SBCommandInterpreter &,
762       SBCommandInterpreter, operator=,(const lldb::SBCommandInterpreter &));
763   LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, IsValid, ());
764   LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, operator bool, ());
765   LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, CommandExists,
766                        (const char *));
767   LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, AliasExists,
768                        (const char *));
769   LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, IsActive, ());
770   LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, WasInterrupted, ());
771   LLDB_REGISTER_METHOD(const char *, SBCommandInterpreter,
772                        GetIOHandlerControlSequence, (char));
773   LLDB_REGISTER_METHOD(lldb::ReturnStatus, SBCommandInterpreter,
774                        HandleCommand,
775                        (const char *, lldb::SBCommandReturnObject &, bool));
776   LLDB_REGISTER_METHOD(lldb::ReturnStatus, SBCommandInterpreter,
777                        HandleCommand,
778                        (const char *, lldb::SBExecutionContext &,
779                         lldb::SBCommandReturnObject &, bool));
780   LLDB_REGISTER_METHOD(void, SBCommandInterpreter, HandleCommandsFromFile,
781                        (lldb::SBFileSpec &, lldb::SBExecutionContext &,
782                         lldb::SBCommandInterpreterRunOptions &,
783                         lldb::SBCommandReturnObject));
784   LLDB_REGISTER_METHOD(int, SBCommandInterpreter, HandleCompletion,
785                        (const char *, const char *, const char *, int, int,
786                         lldb::SBStringList &));
787   LLDB_REGISTER_METHOD(int, SBCommandInterpreter,
788                        HandleCompletionWithDescriptions,
789                        (const char *, const char *, const char *, int, int,
790                         lldb::SBStringList &, lldb::SBStringList &));
791   LLDB_REGISTER_METHOD(int, SBCommandInterpreter,
792                        HandleCompletionWithDescriptions,
793                        (const char *, uint32_t, int, int,
794                         lldb::SBStringList &, lldb::SBStringList &));
795   LLDB_REGISTER_METHOD(
796       int, SBCommandInterpreter, HandleCompletion,
797       (const char *, uint32_t, int, int, lldb::SBStringList &));
798   LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasCommands, ());
799   LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasAliases, ());
800   LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasAliasOptions, ());
801   LLDB_REGISTER_METHOD(lldb::SBProcess, SBCommandInterpreter, GetProcess, ());
802   LLDB_REGISTER_METHOD(lldb::SBDebugger, SBCommandInterpreter, GetDebugger,
803                        ());
804   LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, GetPromptOnQuit, ());
805   LLDB_REGISTER_METHOD(void, SBCommandInterpreter, SetPromptOnQuit, (bool));
806   LLDB_REGISTER_METHOD(void, SBCommandInterpreter, AllowExitCodeOnQuit,
807                        (bool));
808   LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasCustomQuitExitCode, ());
809   LLDB_REGISTER_METHOD(int, SBCommandInterpreter, GetQuitStatus, ());
810   LLDB_REGISTER_METHOD(void, SBCommandInterpreter, ResolveCommand,
811                        (const char *, lldb::SBCommandReturnObject &));
812   LLDB_REGISTER_METHOD(void, SBCommandInterpreter,
813                        SourceInitFileInHomeDirectory,
814                        (lldb::SBCommandReturnObject &));
815   LLDB_REGISTER_METHOD(void, SBCommandInterpreter,
816                        SourceInitFileInHomeDirectory,
817                        (lldb::SBCommandReturnObject &, bool));
818   LLDB_REGISTER_METHOD(void, SBCommandInterpreter,
819                        SourceInitFileInCurrentWorkingDirectory,
820                        (lldb::SBCommandReturnObject &));
821   LLDB_REGISTER_METHOD(lldb::SBBroadcaster, SBCommandInterpreter,
822                        GetBroadcaster, ());
823   LLDB_REGISTER_STATIC_METHOD(const char *, SBCommandInterpreter,
824                               GetBroadcasterClass, ());
825   LLDB_REGISTER_STATIC_METHOD(const char *, SBCommandInterpreter,
826                               GetArgumentTypeAsCString,
827                               (const lldb::CommandArgumentType));
828   LLDB_REGISTER_STATIC_METHOD(const char *, SBCommandInterpreter,
829                               GetArgumentDescriptionAsCString,
830                               (const lldb::CommandArgumentType));
831   LLDB_REGISTER_STATIC_METHOD(bool, SBCommandInterpreter,
832                               EventIsCommandInterpreterEvent,
833                               (const lldb::SBEvent &));
834   LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommandInterpreter,
835                        AddMultiwordCommand, (const char *, const char *));
836   LLDB_REGISTER_METHOD(
837       lldb::SBCommand, SBCommandInterpreter, AddCommand,
838       (const char *, lldb::SBCommandPluginInterface *, const char *));
839   LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand,
840                        (const char *, lldb::SBCommandPluginInterface *,
841                         const char *, const char *));
842   LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand,
843                        (const char *, lldb::SBCommandPluginInterface *,
844                         const char *, const char *, const char *));
845   LLDB_REGISTER_CONSTRUCTOR(SBCommand, ());
846   LLDB_REGISTER_METHOD(bool, SBCommand, IsValid, ());
847   LLDB_REGISTER_METHOD_CONST(bool, SBCommand, operator bool, ());
848   LLDB_REGISTER_METHOD(const char *, SBCommand, GetName, ());
849   LLDB_REGISTER_METHOD(const char *, SBCommand, GetHelp, ());
850   LLDB_REGISTER_METHOD(const char *, SBCommand, GetHelpLong, ());
851   LLDB_REGISTER_METHOD(void, SBCommand, SetHelp, (const char *));
852   LLDB_REGISTER_METHOD(void, SBCommand, SetHelpLong, (const char *));
853   LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommand, AddMultiwordCommand,
854                        (const char *, const char *));
855   LLDB_REGISTER_METHOD(
856       lldb::SBCommand, SBCommand, AddCommand,
857       (const char *, lldb::SBCommandPluginInterface *, const char *));
858   LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommand, AddCommand,
859                        (const char *, lldb::SBCommandPluginInterface *,
860                         const char *, const char *));
861   LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommand, AddCommand,
862                        (const char *, lldb::SBCommandPluginInterface *,
863                         const char *, const char *, const char *));
864   LLDB_REGISTER_METHOD(uint32_t, SBCommand, GetFlags, ());
865   LLDB_REGISTER_METHOD(void, SBCommand, SetFlags, (uint32_t));
866 }
867 }
868 }
869