• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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:
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="")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 
IsRemovable() const52   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.
GetRepeatCommand(Args & current_command_args,uint32_t index)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:
DoExecute(Args & command,CommandReturnObject & result)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 
SBCommandInterpreter(CommandInterpreter * interpreter)79 SBCommandInterpreter::SBCommandInterpreter(CommandInterpreter *interpreter)
80     : m_opaque_ptr(interpreter) {
81   LLDB_RECORD_CONSTRUCTOR(SBCommandInterpreter,
82                           (lldb_private::CommandInterpreter *), interpreter);
83 
84 }
85 
SBCommandInterpreter(const SBCommandInterpreter & rhs)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::
operator =(const SBCommandInterpreter & rhs)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 
IsValid() const105 bool SBCommandInterpreter::IsValid() const {
106   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreter, IsValid);
107   return this->operator bool();
108 }
operator bool() const109 SBCommandInterpreter::operator bool() const {
110   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreter, operator bool);
111 
112   return m_opaque_ptr != nullptr;
113 }
114 
CommandExists(const char * cmd)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 
AliasExists(const char * cmd)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 
IsActive()131 bool SBCommandInterpreter::IsActive() {
132   LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, IsActive);
133 
134   return (IsValid() ? m_opaque_ptr->IsActive() : false);
135 }
136 
WasInterrupted() const137 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 
GetIOHandlerControlSequence(char ch)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
HandleCommand(const char * command_line,SBCommandReturnObject & result,bool add_to_history)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 
HandleCommand(const char * command_line,SBExecutionContext & override_context,SBCommandReturnObject & result,bool add_to_history)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 
175   ExecutionContext ctx, *ctx_ptr;
176   if (override_context.get()) {
177     ctx = override_context.get()->Lock(true);
178     ctx_ptr = &ctx;
179   } else
180     ctx_ptr = nullptr;
181 
182   result.Clear();
183   if (command_line && IsValid()) {
184     result.ref().SetInteractive(false);
185     m_opaque_ptr->HandleCommand(command_line,
186                                 add_to_history ? eLazyBoolYes : eLazyBoolNo,
187                                 result.ref(), ctx_ptr);
188   } else {
189     result->AppendError(
190         "SBCommandInterpreter or the command line is not valid");
191     result->SetStatus(eReturnStatusFailed);
192   }
193 
194 
195   return result.GetStatus();
196 }
197 
HandleCommandsFromFile(lldb::SBFileSpec & file,lldb::SBExecutionContext & override_context,lldb::SBCommandInterpreterRunOptions & options,lldb::SBCommandReturnObject result)198 void SBCommandInterpreter::HandleCommandsFromFile(
199     lldb::SBFileSpec &file, lldb::SBExecutionContext &override_context,
200     lldb::SBCommandInterpreterRunOptions &options,
201     lldb::SBCommandReturnObject result) {
202   LLDB_RECORD_METHOD(void, SBCommandInterpreter, HandleCommandsFromFile,
203                      (lldb::SBFileSpec &, lldb::SBExecutionContext &,
204                       lldb::SBCommandInterpreterRunOptions &,
205                       lldb::SBCommandReturnObject),
206                      file, override_context, options, result);
207 
208   if (!IsValid()) {
209     result->AppendError("SBCommandInterpreter is not valid.");
210     result->SetStatus(eReturnStatusFailed);
211     return;
212   }
213 
214   if (!file.IsValid()) {
215     SBStream s;
216     file.GetDescription(s);
217     result->AppendErrorWithFormat("File is not valid: %s.", s.GetData());
218     result->SetStatus(eReturnStatusFailed);
219   }
220 
221   FileSpec tmp_spec = file.ref();
222   ExecutionContext ctx, *ctx_ptr;
223   if (override_context.get()) {
224     ctx = override_context.get()->Lock(true);
225     ctx_ptr = &ctx;
226   } else
227     ctx_ptr = nullptr;
228 
229   m_opaque_ptr->HandleCommandsFromFile(tmp_spec, ctx_ptr, options.ref(),
230                                        result.ref());
231 }
232 
HandleCompletion(const char * current_line,const char * cursor,const char * last_char,int match_start_point,int max_return_elements,SBStringList & matches)233 int SBCommandInterpreter::HandleCompletion(
234     const char *current_line, const char *cursor, const char *last_char,
235     int match_start_point, int max_return_elements, SBStringList &matches) {
236   LLDB_RECORD_METHOD(int, SBCommandInterpreter, HandleCompletion,
237                      (const char *, const char *, const char *, int, int,
238                       lldb::SBStringList &),
239                      current_line, cursor, last_char, match_start_point,
240                      max_return_elements, matches);
241 
242   SBStringList dummy_descriptions;
243   return HandleCompletionWithDescriptions(
244       current_line, cursor, last_char, match_start_point, max_return_elements,
245       matches, dummy_descriptions);
246 }
247 
HandleCompletionWithDescriptions(const char * current_line,const char * cursor,const char * last_char,int match_start_point,int max_return_elements,SBStringList & matches,SBStringList & descriptions)248 int SBCommandInterpreter::HandleCompletionWithDescriptions(
249     const char *current_line, const char *cursor, const char *last_char,
250     int match_start_point, int max_return_elements, SBStringList &matches,
251     SBStringList &descriptions) {
252   LLDB_RECORD_METHOD(int, SBCommandInterpreter,
253                      HandleCompletionWithDescriptions,
254                      (const char *, const char *, const char *, int, int,
255                       lldb::SBStringList &, lldb::SBStringList &),
256                      current_line, cursor, last_char, match_start_point,
257                      max_return_elements, matches, descriptions);
258 
259   // Sanity check the arguments that are passed in: cursor & last_char have to
260   // be within the current_line.
261   if (current_line == nullptr || cursor == nullptr || last_char == nullptr)
262     return 0;
263 
264   if (cursor < current_line || last_char < current_line)
265     return 0;
266 
267   size_t current_line_size = strlen(current_line);
268   if (cursor - current_line > static_cast<ptrdiff_t>(current_line_size) ||
269       last_char - current_line > static_cast<ptrdiff_t>(current_line_size))
270     return 0;
271 
272   if (!IsValid())
273     return 0;
274 
275   lldb_private::StringList lldb_matches, lldb_descriptions;
276   CompletionResult result;
277   CompletionRequest request(current_line, cursor - current_line, result);
278   m_opaque_ptr->HandleCompletion(request);
279   result.GetMatches(lldb_matches);
280   result.GetDescriptions(lldb_descriptions);
281 
282   // Make the result array indexed from 1 again by adding the 'common prefix'
283   // of all completions as element 0. This is done to emulate the old API.
284   if (request.GetParsedLine().GetArgumentCount() == 0) {
285     // If we got an empty string, insert nothing.
286     lldb_matches.InsertStringAtIndex(0, "");
287     lldb_descriptions.InsertStringAtIndex(0, "");
288   } else {
289     // Now figure out if there is a common substring, and if so put that in
290     // element 0, otherwise put an empty string in element 0.
291     std::string command_partial_str = request.GetCursorArgumentPrefix().str();
292 
293     std::string common_prefix = lldb_matches.LongestCommonPrefix();
294     const size_t partial_name_len = command_partial_str.size();
295     common_prefix.erase(0, partial_name_len);
296 
297     // If we matched a unique single command, add a space... Only do this if
298     // the completer told us this was a complete word, however...
299     if (lldb_matches.GetSize() == 1) {
300       char quote_char = request.GetParsedArg().GetQuoteChar();
301       common_prefix =
302           Args::EscapeLLDBCommandArgument(common_prefix, quote_char);
303       if (request.GetParsedArg().IsQuoted())
304         common_prefix.push_back(quote_char);
305       common_prefix.push_back(' ');
306     }
307     lldb_matches.InsertStringAtIndex(0, common_prefix.c_str());
308     lldb_descriptions.InsertStringAtIndex(0, "");
309   }
310 
311   SBStringList temp_matches_list(&lldb_matches);
312   matches.AppendList(temp_matches_list);
313   SBStringList temp_descriptions_list(&lldb_descriptions);
314   descriptions.AppendList(temp_descriptions_list);
315   return result.GetNumberOfResults();
316 }
317 
HandleCompletionWithDescriptions(const char * current_line,uint32_t cursor_pos,int match_start_point,int max_return_elements,SBStringList & matches,SBStringList & descriptions)318 int SBCommandInterpreter::HandleCompletionWithDescriptions(
319     const char *current_line, uint32_t cursor_pos, int match_start_point,
320     int max_return_elements, SBStringList &matches,
321     SBStringList &descriptions) {
322   LLDB_RECORD_METHOD(int, SBCommandInterpreter,
323                      HandleCompletionWithDescriptions,
324                      (const char *, uint32_t, int, int, lldb::SBStringList &,
325                       lldb::SBStringList &),
326                      current_line, cursor_pos, match_start_point,
327                      max_return_elements, matches, descriptions);
328 
329   const char *cursor = current_line + cursor_pos;
330   const char *last_char = current_line + strlen(current_line);
331   return HandleCompletionWithDescriptions(
332       current_line, cursor, last_char, match_start_point, max_return_elements,
333       matches, descriptions);
334 }
335 
HandleCompletion(const char * current_line,uint32_t cursor_pos,int match_start_point,int max_return_elements,lldb::SBStringList & matches)336 int SBCommandInterpreter::HandleCompletion(const char *current_line,
337                                            uint32_t cursor_pos,
338                                            int match_start_point,
339                                            int max_return_elements,
340                                            lldb::SBStringList &matches) {
341   LLDB_RECORD_METHOD(int, SBCommandInterpreter, HandleCompletion,
342                      (const char *, uint32_t, int, int, lldb::SBStringList &),
343                      current_line, cursor_pos, match_start_point,
344                      max_return_elements, matches);
345 
346   const char *cursor = current_line + cursor_pos;
347   const char *last_char = current_line + strlen(current_line);
348   return HandleCompletion(current_line, cursor, last_char, match_start_point,
349                           max_return_elements, matches);
350 }
351 
HasCommands()352 bool SBCommandInterpreter::HasCommands() {
353   LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasCommands);
354 
355   return (IsValid() ? m_opaque_ptr->HasCommands() : false);
356 }
357 
HasAliases()358 bool SBCommandInterpreter::HasAliases() {
359   LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasAliases);
360 
361   return (IsValid() ? m_opaque_ptr->HasAliases() : false);
362 }
363 
HasAliasOptions()364 bool SBCommandInterpreter::HasAliasOptions() {
365   LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasAliasOptions);
366 
367   return (IsValid() ? m_opaque_ptr->HasAliasOptions() : false);
368 }
369 
GetProcess()370 SBProcess SBCommandInterpreter::GetProcess() {
371   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBCommandInterpreter, GetProcess);
372 
373   SBProcess sb_process;
374   ProcessSP process_sp;
375   if (IsValid()) {
376     TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
377     if (target_sp) {
378       std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
379       process_sp = target_sp->GetProcessSP();
380       sb_process.SetSP(process_sp);
381     }
382   }
383 
384   return LLDB_RECORD_RESULT(sb_process);
385 }
386 
GetDebugger()387 SBDebugger SBCommandInterpreter::GetDebugger() {
388   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBDebugger, SBCommandInterpreter,
389                              GetDebugger);
390 
391   SBDebugger sb_debugger;
392   if (IsValid())
393     sb_debugger.reset(m_opaque_ptr->GetDebugger().shared_from_this());
394 
395   return LLDB_RECORD_RESULT(sb_debugger);
396 }
397 
GetPromptOnQuit()398 bool SBCommandInterpreter::GetPromptOnQuit() {
399   LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, GetPromptOnQuit);
400 
401   return (IsValid() ? m_opaque_ptr->GetPromptOnQuit() : false);
402 }
403 
SetPromptOnQuit(bool b)404 void SBCommandInterpreter::SetPromptOnQuit(bool b) {
405   LLDB_RECORD_METHOD(void, SBCommandInterpreter, SetPromptOnQuit, (bool), b);
406 
407   if (IsValid())
408     m_opaque_ptr->SetPromptOnQuit(b);
409 }
410 
AllowExitCodeOnQuit(bool allow)411 void SBCommandInterpreter::AllowExitCodeOnQuit(bool allow) {
412   LLDB_RECORD_METHOD(void, SBCommandInterpreter, AllowExitCodeOnQuit, (bool),
413                      allow);
414 
415   if (m_opaque_ptr)
416     m_opaque_ptr->AllowExitCodeOnQuit(allow);
417 }
418 
HasCustomQuitExitCode()419 bool SBCommandInterpreter::HasCustomQuitExitCode() {
420   LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasCustomQuitExitCode);
421 
422   bool exited = false;
423   if (m_opaque_ptr)
424     m_opaque_ptr->GetQuitExitCode(exited);
425   return exited;
426 }
427 
GetQuitStatus()428 int SBCommandInterpreter::GetQuitStatus() {
429   LLDB_RECORD_METHOD_NO_ARGS(int, SBCommandInterpreter, GetQuitStatus);
430 
431   bool exited = false;
432   return (m_opaque_ptr ? m_opaque_ptr->GetQuitExitCode(exited) : 0);
433 }
434 
ResolveCommand(const char * command_line,SBCommandReturnObject & result)435 void SBCommandInterpreter::ResolveCommand(const char *command_line,
436                                           SBCommandReturnObject &result) {
437   LLDB_RECORD_METHOD(void, SBCommandInterpreter, ResolveCommand,
438                      (const char *, lldb::SBCommandReturnObject &),
439                      command_line, result);
440 
441   result.Clear();
442   if (command_line && IsValid()) {
443     m_opaque_ptr->ResolveCommand(command_line, result.ref());
444   } else {
445     result->AppendError(
446         "SBCommandInterpreter or the command line is not valid");
447     result->SetStatus(eReturnStatusFailed);
448   }
449 }
450 
get()451 CommandInterpreter *SBCommandInterpreter::get() { return m_opaque_ptr; }
452 
ref()453 CommandInterpreter &SBCommandInterpreter::ref() {
454   assert(m_opaque_ptr);
455   return *m_opaque_ptr;
456 }
457 
reset(lldb_private::CommandInterpreter * interpreter)458 void SBCommandInterpreter::reset(
459     lldb_private::CommandInterpreter *interpreter) {
460   m_opaque_ptr = interpreter;
461 }
462 
SourceInitFileInHomeDirectory(SBCommandReturnObject & result)463 void SBCommandInterpreter::SourceInitFileInHomeDirectory(
464     SBCommandReturnObject &result) {
465   LLDB_RECORD_METHOD(void, SBCommandInterpreter, SourceInitFileInHomeDirectory,
466                      (lldb::SBCommandReturnObject &), result);
467 
468   result.Clear();
469   if (IsValid()) {
470     TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
471     std::unique_lock<std::recursive_mutex> lock;
472     if (target_sp)
473       lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
474     m_opaque_ptr->SourceInitFileHome(result.ref());
475   } else {
476     result->AppendError("SBCommandInterpreter is not valid");
477     result->SetStatus(eReturnStatusFailed);
478   }
479 }
480 
SourceInitFileInHomeDirectory(SBCommandReturnObject & result,bool is_repl)481 void SBCommandInterpreter::SourceInitFileInHomeDirectory(
482     SBCommandReturnObject &result, bool is_repl) {
483   LLDB_RECORD_METHOD(void, SBCommandInterpreter, SourceInitFileInHomeDirectory,
484                      (lldb::SBCommandReturnObject &, bool), result, is_repl);
485 
486   result.Clear();
487   if (IsValid()) {
488     TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
489     std::unique_lock<std::recursive_mutex> lock;
490     if (target_sp)
491       lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
492     m_opaque_ptr->SourceInitFileHome(result.ref(), is_repl);
493   } else {
494     result->AppendError("SBCommandInterpreter is not valid");
495     result->SetStatus(eReturnStatusFailed);
496   }
497 }
498 
SourceInitFileInCurrentWorkingDirectory(SBCommandReturnObject & result)499 void SBCommandInterpreter::SourceInitFileInCurrentWorkingDirectory(
500     SBCommandReturnObject &result) {
501   LLDB_RECORD_METHOD(void, SBCommandInterpreter,
502                      SourceInitFileInCurrentWorkingDirectory,
503                      (lldb::SBCommandReturnObject &), result);
504 
505   result.Clear();
506   if (IsValid()) {
507     TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
508     std::unique_lock<std::recursive_mutex> lock;
509     if (target_sp)
510       lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
511     m_opaque_ptr->SourceInitFileCwd(result.ref());
512   } else {
513     result->AppendError("SBCommandInterpreter is not valid");
514     result->SetStatus(eReturnStatusFailed);
515   }
516 }
517 
GetBroadcaster()518 SBBroadcaster SBCommandInterpreter::GetBroadcaster() {
519   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBroadcaster, SBCommandInterpreter,
520                              GetBroadcaster);
521 
522 
523   SBBroadcaster broadcaster(m_opaque_ptr, false);
524 
525 
526   return LLDB_RECORD_RESULT(broadcaster);
527 }
528 
GetBroadcasterClass()529 const char *SBCommandInterpreter::GetBroadcasterClass() {
530   LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBCommandInterpreter,
531                                     GetBroadcasterClass);
532 
533   return CommandInterpreter::GetStaticBroadcasterClass().AsCString();
534 }
535 
GetArgumentTypeAsCString(const lldb::CommandArgumentType arg_type)536 const char *SBCommandInterpreter::GetArgumentTypeAsCString(
537     const lldb::CommandArgumentType arg_type) {
538   LLDB_RECORD_STATIC_METHOD(const char *, SBCommandInterpreter,
539                             GetArgumentTypeAsCString,
540                             (const lldb::CommandArgumentType), arg_type);
541 
542   return CommandObject::GetArgumentTypeAsCString(arg_type);
543 }
544 
GetArgumentDescriptionAsCString(const lldb::CommandArgumentType arg_type)545 const char *SBCommandInterpreter::GetArgumentDescriptionAsCString(
546     const lldb::CommandArgumentType arg_type) {
547   LLDB_RECORD_STATIC_METHOD(const char *, SBCommandInterpreter,
548                             GetArgumentDescriptionAsCString,
549                             (const lldb::CommandArgumentType), arg_type);
550 
551   return CommandObject::GetArgumentDescriptionAsCString(arg_type);
552 }
553 
EventIsCommandInterpreterEvent(const lldb::SBEvent & event)554 bool SBCommandInterpreter::EventIsCommandInterpreterEvent(
555     const lldb::SBEvent &event) {
556   LLDB_RECORD_STATIC_METHOD(bool, SBCommandInterpreter,
557                             EventIsCommandInterpreterEvent,
558                             (const lldb::SBEvent &), event);
559 
560   return event.GetBroadcasterClass() ==
561          SBCommandInterpreter::GetBroadcasterClass();
562 }
563 
SetCommandOverrideCallback(const char * command_name,lldb::CommandOverrideCallback callback,void * baton)564 bool SBCommandInterpreter::SetCommandOverrideCallback(
565     const char *command_name, lldb::CommandOverrideCallback callback,
566     void *baton) {
567   LLDB_RECORD_DUMMY(bool, SBCommandInterpreter, SetCommandOverrideCallback,
568                     (const char *, lldb::CommandOverrideCallback, void *),
569                     command_name, callback, baton);
570 
571   if (command_name && command_name[0] && IsValid()) {
572     llvm::StringRef command_name_str = command_name;
573     CommandObject *cmd_obj =
574         m_opaque_ptr->GetCommandObjectForCommand(command_name_str);
575     if (cmd_obj) {
576       assert(command_name_str.empty());
577       cmd_obj->SetOverrideCallback(callback, baton);
578       return true;
579     }
580   }
581   return false;
582 }
583 
AddMultiwordCommand(const char * name,const char * help)584 lldb::SBCommand SBCommandInterpreter::AddMultiwordCommand(const char *name,
585                                                           const char *help) {
586   LLDB_RECORD_METHOD(lldb::SBCommand, SBCommandInterpreter, AddMultiwordCommand,
587                      (const char *, const char *), name, help);
588 
589   CommandObjectMultiword *new_command =
590       new CommandObjectMultiword(*m_opaque_ptr, name, help);
591   new_command->SetRemovable(true);
592   lldb::CommandObjectSP new_command_sp(new_command);
593   if (new_command_sp &&
594       m_opaque_ptr->AddUserCommand(name, new_command_sp, true))
595     return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp));
596   return LLDB_RECORD_RESULT(lldb::SBCommand());
597 }
598 
AddCommand(const char * name,lldb::SBCommandPluginInterface * impl,const char * help)599 lldb::SBCommand SBCommandInterpreter::AddCommand(
600     const char *name, lldb::SBCommandPluginInterface *impl, const char *help) {
601   LLDB_RECORD_METHOD(
602       lldb::SBCommand, SBCommandInterpreter, AddCommand,
603       (const char *, lldb::SBCommandPluginInterface *, const char *), name,
604       impl, help);
605 
606   return LLDB_RECORD_RESULT(AddCommand(name, impl, help, /*syntax=*/nullptr,
607                                        /*auto_repeat_command=*/""))
608 }
609 
610 lldb::SBCommand
AddCommand(const char * name,lldb::SBCommandPluginInterface * impl,const char * help,const char * syntax)611 SBCommandInterpreter::AddCommand(const char *name,
612                                  lldb::SBCommandPluginInterface *impl,
613                                  const char *help, const char *syntax) {
614   LLDB_RECORD_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand,
615                      (const char *, lldb::SBCommandPluginInterface *,
616                       const char *, const char *),
617                      name, impl, help, syntax);
618   return LLDB_RECORD_RESULT(
619       AddCommand(name, impl, help, syntax, /*auto_repeat_command=*/""))
620 }
621 
AddCommand(const char * name,lldb::SBCommandPluginInterface * impl,const char * help,const char * syntax,const char * auto_repeat_command)622 lldb::SBCommand SBCommandInterpreter::AddCommand(
623     const char *name, lldb::SBCommandPluginInterface *impl, const char *help,
624     const char *syntax, const char *auto_repeat_command) {
625   LLDB_RECORD_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand,
626                      (const char *, lldb::SBCommandPluginInterface *,
627                       const char *, const char *, const char *),
628                      name, impl, help, syntax, auto_repeat_command);
629 
630   lldb::CommandObjectSP new_command_sp;
631   new_command_sp = std::make_shared<CommandPluginInterfaceImplementation>(
632       *m_opaque_ptr, name, impl, help, syntax, /*flags=*/0,
633       auto_repeat_command);
634 
635   if (new_command_sp &&
636       m_opaque_ptr->AddUserCommand(name, new_command_sp, true))
637     return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp));
638   return LLDB_RECORD_RESULT(lldb::SBCommand());
639 }
640 
SBCommand()641 SBCommand::SBCommand() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommand); }
642 
SBCommand(lldb::CommandObjectSP cmd_sp)643 SBCommand::SBCommand(lldb::CommandObjectSP cmd_sp) : m_opaque_sp(cmd_sp) {}
644 
IsValid()645 bool SBCommand::IsValid() {
646   LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommand, IsValid);
647   return this->operator bool();
648 }
operator bool() const649 SBCommand::operator bool() const {
650   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommand, operator bool);
651 
652   return m_opaque_sp.get() != nullptr;
653 }
654 
GetName()655 const char *SBCommand::GetName() {
656   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommand, GetName);
657 
658   return (IsValid() ? ConstString(m_opaque_sp->GetCommandName()).AsCString() : nullptr);
659 }
660 
GetHelp()661 const char *SBCommand::GetHelp() {
662   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommand, GetHelp);
663 
664   return (IsValid() ? ConstString(m_opaque_sp->GetHelp()).AsCString()
665                     : nullptr);
666 }
667 
GetHelpLong()668 const char *SBCommand::GetHelpLong() {
669   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommand, GetHelpLong);
670 
671   return (IsValid() ? ConstString(m_opaque_sp->GetHelpLong()).AsCString()
672                     : nullptr);
673 }
674 
SetHelp(const char * help)675 void SBCommand::SetHelp(const char *help) {
676   LLDB_RECORD_METHOD(void, SBCommand, SetHelp, (const char *), help);
677 
678   if (IsValid())
679     m_opaque_sp->SetHelp(help);
680 }
681 
SetHelpLong(const char * help)682 void SBCommand::SetHelpLong(const char *help) {
683   LLDB_RECORD_METHOD(void, SBCommand, SetHelpLong, (const char *), help);
684 
685   if (IsValid())
686     m_opaque_sp->SetHelpLong(help);
687 }
688 
AddMultiwordCommand(const char * name,const char * help)689 lldb::SBCommand SBCommand::AddMultiwordCommand(const char *name,
690                                                const char *help) {
691   LLDB_RECORD_METHOD(lldb::SBCommand, SBCommand, AddMultiwordCommand,
692                      (const char *, const char *), name, help);
693 
694   if (!IsValid())
695     return LLDB_RECORD_RESULT(lldb::SBCommand());
696   if (!m_opaque_sp->IsMultiwordObject())
697     return LLDB_RECORD_RESULT(lldb::SBCommand());
698   CommandObjectMultiword *new_command = new CommandObjectMultiword(
699       m_opaque_sp->GetCommandInterpreter(), name, help);
700   new_command->SetRemovable(true);
701   lldb::CommandObjectSP new_command_sp(new_command);
702   if (new_command_sp && m_opaque_sp->LoadSubCommand(name, new_command_sp))
703     return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp));
704   return LLDB_RECORD_RESULT(lldb::SBCommand());
705 }
706 
AddCommand(const char * name,lldb::SBCommandPluginInterface * impl,const char * help)707 lldb::SBCommand SBCommand::AddCommand(const char *name,
708                                       lldb::SBCommandPluginInterface *impl,
709                                       const char *help) {
710   LLDB_RECORD_METHOD(
711       lldb::SBCommand, SBCommand, AddCommand,
712       (const char *, lldb::SBCommandPluginInterface *, const char *), name,
713       impl, help);
714   return LLDB_RECORD_RESULT(AddCommand(name, impl, help, /*syntax=*/nullptr,
715                                        /*auto_repeat_command=*/""))
716 }
717 
AddCommand(const char * name,lldb::SBCommandPluginInterface * impl,const char * help,const char * syntax)718 lldb::SBCommand SBCommand::AddCommand(const char *name,
719                                       lldb::SBCommandPluginInterface *impl,
720                                       const char *help, const char *syntax) {
721   LLDB_RECORD_METHOD(lldb::SBCommand, SBCommand, AddCommand,
722                      (const char *, lldb::SBCommandPluginInterface *,
723                       const char *, const char *),
724                      name, impl, help, syntax);
725   return LLDB_RECORD_RESULT(
726       AddCommand(name, impl, help, syntax, /*auto_repeat_command=*/""))
727 }
728 
AddCommand(const char * name,lldb::SBCommandPluginInterface * impl,const char * help,const char * syntax,const char * auto_repeat_command)729 lldb::SBCommand SBCommand::AddCommand(const char *name,
730                                       lldb::SBCommandPluginInterface *impl,
731                                       const char *help, const char *syntax,
732                                       const char *auto_repeat_command) {
733   LLDB_RECORD_METHOD(lldb::SBCommand, SBCommand, AddCommand,
734                      (const char *, lldb::SBCommandPluginInterface *,
735                       const char *, const char *, const char *),
736                      name, impl, help, syntax, auto_repeat_command);
737 
738   if (!IsValid())
739     return LLDB_RECORD_RESULT(lldb::SBCommand());
740   if (!m_opaque_sp->IsMultiwordObject())
741     return LLDB_RECORD_RESULT(lldb::SBCommand());
742   lldb::CommandObjectSP new_command_sp;
743   new_command_sp = std::make_shared<CommandPluginInterfaceImplementation>(
744       m_opaque_sp->GetCommandInterpreter(), name, impl, help, syntax,
745       /*flags=*/0, auto_repeat_command);
746   if (new_command_sp && m_opaque_sp->LoadSubCommand(name, new_command_sp))
747     return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp));
748   return LLDB_RECORD_RESULT(lldb::SBCommand());
749 }
750 
GetFlags()751 uint32_t SBCommand::GetFlags() {
752   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBCommand, GetFlags);
753 
754   return (IsValid() ? m_opaque_sp->GetFlags().Get() : 0);
755 }
756 
SetFlags(uint32_t flags)757 void SBCommand::SetFlags(uint32_t flags) {
758   LLDB_RECORD_METHOD(void, SBCommand, SetFlags, (uint32_t), flags);
759 
760   if (IsValid())
761     m_opaque_sp->GetFlags().Set(flags);
762 }
763 
764 namespace lldb_private {
765 namespace repro {
766 
RegisterMethods(Registry & R)767 template <> void RegisterMethods<SBCommandInterpreter>(Registry &R) {
768   LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreter,
769                             (lldb_private::CommandInterpreter *));
770   LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreter,
771                             (const lldb::SBCommandInterpreter &));
772   LLDB_REGISTER_METHOD(
773       const lldb::SBCommandInterpreter &,
774       SBCommandInterpreter, operator=,(const lldb::SBCommandInterpreter &));
775   LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, IsValid, ());
776   LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, operator bool, ());
777   LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, CommandExists,
778                        (const char *));
779   LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, AliasExists,
780                        (const char *));
781   LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, IsActive, ());
782   LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, WasInterrupted, ());
783   LLDB_REGISTER_METHOD(const char *, SBCommandInterpreter,
784                        GetIOHandlerControlSequence, (char));
785   LLDB_REGISTER_METHOD(lldb::ReturnStatus, SBCommandInterpreter,
786                        HandleCommand,
787                        (const char *, lldb::SBCommandReturnObject &, bool));
788   LLDB_REGISTER_METHOD(lldb::ReturnStatus, SBCommandInterpreter,
789                        HandleCommand,
790                        (const char *, lldb::SBExecutionContext &,
791                         lldb::SBCommandReturnObject &, bool));
792   LLDB_REGISTER_METHOD(void, SBCommandInterpreter, HandleCommandsFromFile,
793                        (lldb::SBFileSpec &, lldb::SBExecutionContext &,
794                         lldb::SBCommandInterpreterRunOptions &,
795                         lldb::SBCommandReturnObject));
796   LLDB_REGISTER_METHOD(int, SBCommandInterpreter, HandleCompletion,
797                        (const char *, const char *, const char *, int, int,
798                         lldb::SBStringList &));
799   LLDB_REGISTER_METHOD(int, SBCommandInterpreter,
800                        HandleCompletionWithDescriptions,
801                        (const char *, const char *, const char *, int, int,
802                         lldb::SBStringList &, lldb::SBStringList &));
803   LLDB_REGISTER_METHOD(int, SBCommandInterpreter,
804                        HandleCompletionWithDescriptions,
805                        (const char *, uint32_t, int, int,
806                         lldb::SBStringList &, lldb::SBStringList &));
807   LLDB_REGISTER_METHOD(
808       int, SBCommandInterpreter, HandleCompletion,
809       (const char *, uint32_t, int, int, lldb::SBStringList &));
810   LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasCommands, ());
811   LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasAliases, ());
812   LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasAliasOptions, ());
813   LLDB_REGISTER_METHOD(lldb::SBProcess, SBCommandInterpreter, GetProcess, ());
814   LLDB_REGISTER_METHOD(lldb::SBDebugger, SBCommandInterpreter, GetDebugger,
815                        ());
816   LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, GetPromptOnQuit, ());
817   LLDB_REGISTER_METHOD(void, SBCommandInterpreter, SetPromptOnQuit, (bool));
818   LLDB_REGISTER_METHOD(void, SBCommandInterpreter, AllowExitCodeOnQuit,
819                        (bool));
820   LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasCustomQuitExitCode, ());
821   LLDB_REGISTER_METHOD(int, SBCommandInterpreter, GetQuitStatus, ());
822   LLDB_REGISTER_METHOD(void, SBCommandInterpreter, ResolveCommand,
823                        (const char *, lldb::SBCommandReturnObject &));
824   LLDB_REGISTER_METHOD(void, SBCommandInterpreter,
825                        SourceInitFileInHomeDirectory,
826                        (lldb::SBCommandReturnObject &));
827   LLDB_REGISTER_METHOD(void, SBCommandInterpreter,
828                        SourceInitFileInHomeDirectory,
829                        (lldb::SBCommandReturnObject &, bool));
830   LLDB_REGISTER_METHOD(void, SBCommandInterpreter,
831                        SourceInitFileInCurrentWorkingDirectory,
832                        (lldb::SBCommandReturnObject &));
833   LLDB_REGISTER_METHOD(lldb::SBBroadcaster, SBCommandInterpreter,
834                        GetBroadcaster, ());
835   LLDB_REGISTER_STATIC_METHOD(const char *, SBCommandInterpreter,
836                               GetBroadcasterClass, ());
837   LLDB_REGISTER_STATIC_METHOD(const char *, SBCommandInterpreter,
838                               GetArgumentTypeAsCString,
839                               (const lldb::CommandArgumentType));
840   LLDB_REGISTER_STATIC_METHOD(const char *, SBCommandInterpreter,
841                               GetArgumentDescriptionAsCString,
842                               (const lldb::CommandArgumentType));
843   LLDB_REGISTER_STATIC_METHOD(bool, SBCommandInterpreter,
844                               EventIsCommandInterpreterEvent,
845                               (const lldb::SBEvent &));
846   LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommandInterpreter,
847                        AddMultiwordCommand, (const char *, const char *));
848   LLDB_REGISTER_METHOD(
849       lldb::SBCommand, SBCommandInterpreter, AddCommand,
850       (const char *, lldb::SBCommandPluginInterface *, const char *));
851   LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand,
852                        (const char *, lldb::SBCommandPluginInterface *,
853                         const char *, const char *));
854   LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand,
855                        (const char *, lldb::SBCommandPluginInterface *,
856                         const char *, const char *, const char *));
857   LLDB_REGISTER_CONSTRUCTOR(SBCommand, ());
858   LLDB_REGISTER_METHOD(bool, SBCommand, IsValid, ());
859   LLDB_REGISTER_METHOD_CONST(bool, SBCommand, operator bool, ());
860   LLDB_REGISTER_METHOD(const char *, SBCommand, GetName, ());
861   LLDB_REGISTER_METHOD(const char *, SBCommand, GetHelp, ());
862   LLDB_REGISTER_METHOD(const char *, SBCommand, GetHelpLong, ());
863   LLDB_REGISTER_METHOD(void, SBCommand, SetHelp, (const char *));
864   LLDB_REGISTER_METHOD(void, SBCommand, SetHelpLong, (const char *));
865   LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommand, AddMultiwordCommand,
866                        (const char *, const char *));
867   LLDB_REGISTER_METHOD(
868       lldb::SBCommand, SBCommand, AddCommand,
869       (const char *, lldb::SBCommandPluginInterface *, const char *));
870   LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommand, AddCommand,
871                        (const char *, lldb::SBCommandPluginInterface *,
872                         const char *, const char *));
873   LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommand, AddCommand,
874                        (const char *, lldb::SBCommandPluginInterface *,
875                         const char *, const char *, const char *));
876   LLDB_REGISTER_METHOD(uint32_t, SBCommand, GetFlags, ());
877   LLDB_REGISTER_METHOD(void, SBCommand, SetFlags, (uint32_t));
878 }
879 }
880 }
881