| //===-- SBCommandInterpreter.cpp ------------------------------------------===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "lldb/lldb-types.h" |
| |
| #include "SBReproducerPrivate.h" |
| #include "lldb/Interpreter/CommandInterpreter.h" |
| #include "lldb/Interpreter/CommandObjectMultiword.h" |
| #include "lldb/Interpreter/CommandReturnObject.h" |
| #include "lldb/Target/Target.h" |
| #include "lldb/Utility/Listener.h" |
| |
| #include "lldb/API/SBBroadcaster.h" |
| #include "lldb/API/SBCommandInterpreter.h" |
| #include "lldb/API/SBCommandInterpreterRunOptions.h" |
| #include "lldb/API/SBCommandReturnObject.h" |
| #include "lldb/API/SBEvent.h" |
| #include "lldb/API/SBExecutionContext.h" |
| #include "lldb/API/SBListener.h" |
| #include "lldb/API/SBProcess.h" |
| #include "lldb/API/SBStream.h" |
| #include "lldb/API/SBStringList.h" |
| #include "lldb/API/SBTarget.h" |
| |
| #include <memory> |
| |
| using namespace lldb; |
| using namespace lldb_private; |
| |
| class CommandPluginInterfaceImplementation : public CommandObjectParsed { |
| 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 = "") |
| : CommandObjectParsed(interpreter, name, help, syntax, flags), |
| m_backend(backend) { |
| m_auto_repeat_command = |
| auto_repeat_command == nullptr |
| ? llvm::None |
| : llvm::Optional<std::string>(auto_repeat_command); |
| } |
| |
| bool IsRemovable() const override { return true; } |
| |
| /// More documentation is available in lldb::CommandObject::GetRepeatCommand, |
| /// but in short, if nullptr is returned, the previous command will be |
| /// repeated, and if an empty string is returned, no commands will be |
| /// executed. |
| const char *GetRepeatCommand(Args ¤t_command_args, |
| uint32_t index) override { |
| if (!m_auto_repeat_command) |
| return nullptr; |
| else |
| return m_auto_repeat_command->c_str(); |
| } |
| |
| protected: |
| bool DoExecute(Args &command, CommandReturnObject &result) override { |
| SBCommandReturnObject sb_return(result); |
| SBCommandInterpreter sb_interpreter(&m_interpreter); |
| SBDebugger debugger_sb(m_interpreter.GetDebugger().shared_from_this()); |
| bool ret = m_backend->DoExecute( |
| debugger_sb, command.GetArgumentVector(), sb_return); |
| return ret; |
| } |
| std::shared_ptr<lldb::SBCommandPluginInterface> m_backend; |
| llvm::Optional<std::string> m_auto_repeat_command; |
| }; |
| |
| SBCommandInterpreter::SBCommandInterpreter(CommandInterpreter *interpreter) |
| : m_opaque_ptr(interpreter) { |
| LLDB_RECORD_CONSTRUCTOR(SBCommandInterpreter, |
| (lldb_private::CommandInterpreter *), interpreter); |
| |
| } |
| |
| SBCommandInterpreter::SBCommandInterpreter(const SBCommandInterpreter &rhs) |
| : m_opaque_ptr(rhs.m_opaque_ptr) { |
| LLDB_RECORD_CONSTRUCTOR(SBCommandInterpreter, |
| (const lldb::SBCommandInterpreter &), rhs); |
| } |
| |
| SBCommandInterpreter::~SBCommandInterpreter() = default; |
| |
| const SBCommandInterpreter &SBCommandInterpreter:: |
| operator=(const SBCommandInterpreter &rhs) { |
| LLDB_RECORD_METHOD( |
| const lldb::SBCommandInterpreter &, |
| SBCommandInterpreter, operator=,(const lldb::SBCommandInterpreter &), |
| rhs); |
| |
| m_opaque_ptr = rhs.m_opaque_ptr; |
| return LLDB_RECORD_RESULT(*this); |
| } |
| |
| bool SBCommandInterpreter::IsValid() const { |
| LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreter, IsValid); |
| return this->operator bool(); |
| } |
| SBCommandInterpreter::operator bool() const { |
| LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreter, operator bool); |
| |
| return m_opaque_ptr != nullptr; |
| } |
| |
| bool SBCommandInterpreter::CommandExists(const char *cmd) { |
| LLDB_RECORD_METHOD(bool, SBCommandInterpreter, CommandExists, (const char *), |
| cmd); |
| |
| return (((cmd != nullptr) && IsValid()) ? m_opaque_ptr->CommandExists(cmd) |
| : false); |
| } |
| |
| bool SBCommandInterpreter::AliasExists(const char *cmd) { |
| LLDB_RECORD_METHOD(bool, SBCommandInterpreter, AliasExists, (const char *), |
| cmd); |
| |
| return (((cmd != nullptr) && IsValid()) ? m_opaque_ptr->AliasExists(cmd) |
| : false); |
| } |
| |
| bool SBCommandInterpreter::IsActive() { |
| LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, IsActive); |
| |
| return (IsValid() ? m_opaque_ptr->IsActive() : false); |
| } |
| |
| bool SBCommandInterpreter::WasInterrupted() const { |
| LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreter, WasInterrupted); |
| |
| return (IsValid() ? m_opaque_ptr->WasInterrupted() : false); |
| } |
| |
| const char *SBCommandInterpreter::GetIOHandlerControlSequence(char ch) { |
| LLDB_RECORD_METHOD(const char *, SBCommandInterpreter, |
| GetIOHandlerControlSequence, (char), ch); |
| |
| return (IsValid() |
| ? m_opaque_ptr->GetDebugger() |
| .GetTopIOHandlerControlSequence(ch) |
| .GetCString() |
| : nullptr); |
| } |
| |
| lldb::ReturnStatus |
| SBCommandInterpreter::HandleCommand(const char *command_line, |
| SBCommandReturnObject &result, |
| bool add_to_history) { |
| LLDB_RECORD_METHOD(lldb::ReturnStatus, SBCommandInterpreter, HandleCommand, |
| (const char *, lldb::SBCommandReturnObject &, bool), |
| command_line, result, add_to_history); |
| |
| SBExecutionContext sb_exe_ctx; |
| return HandleCommand(command_line, sb_exe_ctx, result, add_to_history); |
| } |
| |
| lldb::ReturnStatus SBCommandInterpreter::HandleCommand( |
| const char *command_line, SBExecutionContext &override_context, |
| SBCommandReturnObject &result, bool add_to_history) { |
| LLDB_RECORD_METHOD(lldb::ReturnStatus, SBCommandInterpreter, HandleCommand, |
| (const char *, lldb::SBExecutionContext &, |
| lldb::SBCommandReturnObject &, bool), |
| command_line, override_context, result, add_to_history); |
| |
| result.Clear(); |
| if (command_line && IsValid()) { |
| result.ref().SetInteractive(false); |
| auto do_add_to_history = add_to_history ? eLazyBoolYes : eLazyBoolNo; |
| if (override_context.get()) |
| m_opaque_ptr->HandleCommand(command_line, do_add_to_history, |
| override_context.get()->Lock(true), |
| result.ref()); |
| else |
| m_opaque_ptr->HandleCommand(command_line, do_add_to_history, |
| result.ref()); |
| } else { |
| result->AppendError( |
| "SBCommandInterpreter or the command line is not valid"); |
| } |
| |
| return result.GetStatus(); |
| } |
| |
| void SBCommandInterpreter::HandleCommandsFromFile( |
| lldb::SBFileSpec &file, lldb::SBExecutionContext &override_context, |
| lldb::SBCommandInterpreterRunOptions &options, |
| lldb::SBCommandReturnObject result) { |
| LLDB_RECORD_METHOD(void, SBCommandInterpreter, HandleCommandsFromFile, |
| (lldb::SBFileSpec &, lldb::SBExecutionContext &, |
| lldb::SBCommandInterpreterRunOptions &, |
| lldb::SBCommandReturnObject), |
| file, override_context, options, result); |
| |
| if (!IsValid()) { |
| result->AppendError("SBCommandInterpreter is not valid."); |
| return; |
| } |
| |
| if (!file.IsValid()) { |
| SBStream s; |
| file.GetDescription(s); |
| result->AppendErrorWithFormat("File is not valid: %s.", s.GetData()); |
| } |
| |
| FileSpec tmp_spec = file.ref(); |
| if (override_context.get()) |
| m_opaque_ptr->HandleCommandsFromFile(tmp_spec, |
| override_context.get()->Lock(true), |
| options.ref(), |
| result.ref()); |
| |
| else |
| m_opaque_ptr->HandleCommandsFromFile(tmp_spec, options.ref(), result.ref()); |
| } |
| |
| int SBCommandInterpreter::HandleCompletion( |
| const char *current_line, const char *cursor, const char *last_char, |
| int match_start_point, int max_return_elements, SBStringList &matches) { |
| LLDB_RECORD_METHOD(int, SBCommandInterpreter, HandleCompletion, |
| (const char *, const char *, const char *, int, int, |
| lldb::SBStringList &), |
| current_line, cursor, last_char, match_start_point, |
| max_return_elements, matches); |
| |
| SBStringList dummy_descriptions; |
| return HandleCompletionWithDescriptions( |
| current_line, cursor, last_char, match_start_point, max_return_elements, |
| matches, dummy_descriptions); |
| } |
| |
| int SBCommandInterpreter::HandleCompletionWithDescriptions( |
| const char *current_line, const char *cursor, const char *last_char, |
| int match_start_point, int max_return_elements, SBStringList &matches, |
| SBStringList &descriptions) { |
| LLDB_RECORD_METHOD(int, SBCommandInterpreter, |
| HandleCompletionWithDescriptions, |
| (const char *, const char *, const char *, int, int, |
| lldb::SBStringList &, lldb::SBStringList &), |
| current_line, cursor, last_char, match_start_point, |
| max_return_elements, matches, descriptions); |
| |
| // Sanity check the arguments that are passed in: cursor & last_char have to |
| // be within the current_line. |
| if (current_line == nullptr || cursor == nullptr || last_char == nullptr) |
| return 0; |
| |
| if (cursor < current_line || last_char < current_line) |
| return 0; |
| |
| size_t current_line_size = strlen(current_line); |
| if (cursor - current_line > static_cast<ptrdiff_t>(current_line_size) || |
| last_char - current_line > static_cast<ptrdiff_t>(current_line_size)) |
| return 0; |
| |
| if (!IsValid()) |
| return 0; |
| |
| lldb_private::StringList lldb_matches, lldb_descriptions; |
| CompletionResult result; |
| CompletionRequest request(current_line, cursor - current_line, result); |
| m_opaque_ptr->HandleCompletion(request); |
| result.GetMatches(lldb_matches); |
| result.GetDescriptions(lldb_descriptions); |
| |
| // Make the result array indexed from 1 again by adding the 'common prefix' |
| // of all completions as element 0. This is done to emulate the old API. |
| if (request.GetParsedLine().GetArgumentCount() == 0) { |
| // If we got an empty string, insert nothing. |
| lldb_matches.InsertStringAtIndex(0, ""); |
| lldb_descriptions.InsertStringAtIndex(0, ""); |
| } else { |
| // Now figure out if there is a common substring, and if so put that in |
| // element 0, otherwise put an empty string in element 0. |
| std::string command_partial_str = request.GetCursorArgumentPrefix().str(); |
| |
| std::string common_prefix = lldb_matches.LongestCommonPrefix(); |
| const size_t partial_name_len = command_partial_str.size(); |
| common_prefix.erase(0, partial_name_len); |
| |
| // If we matched a unique single command, add a space... Only do this if |
| // the completer told us this was a complete word, however... |
| if (lldb_matches.GetSize() == 1) { |
| char quote_char = request.GetParsedArg().GetQuoteChar(); |
| common_prefix = |
| Args::EscapeLLDBCommandArgument(common_prefix, quote_char); |
| if (request.GetParsedArg().IsQuoted()) |
| common_prefix.push_back(quote_char); |
| common_prefix.push_back(' '); |
| } |
| lldb_matches.InsertStringAtIndex(0, common_prefix.c_str()); |
| lldb_descriptions.InsertStringAtIndex(0, ""); |
| } |
| |
| SBStringList temp_matches_list(&lldb_matches); |
| matches.AppendList(temp_matches_list); |
| SBStringList temp_descriptions_list(&lldb_descriptions); |
| descriptions.AppendList(temp_descriptions_list); |
| return result.GetNumberOfResults(); |
| } |
| |
| int SBCommandInterpreter::HandleCompletionWithDescriptions( |
| const char *current_line, uint32_t cursor_pos, int match_start_point, |
| int max_return_elements, SBStringList &matches, |
| SBStringList &descriptions) { |
| LLDB_RECORD_METHOD(int, SBCommandInterpreter, |
| HandleCompletionWithDescriptions, |
| (const char *, uint32_t, int, int, lldb::SBStringList &, |
| lldb::SBStringList &), |
| current_line, cursor_pos, match_start_point, |
| max_return_elements, matches, descriptions); |
| |
| const char *cursor = current_line + cursor_pos; |
| const char *last_char = current_line + strlen(current_line); |
| return HandleCompletionWithDescriptions( |
| current_line, cursor, last_char, match_start_point, max_return_elements, |
| matches, descriptions); |
| } |
| |
| int SBCommandInterpreter::HandleCompletion(const char *current_line, |
| uint32_t cursor_pos, |
| int match_start_point, |
| int max_return_elements, |
| lldb::SBStringList &matches) { |
| LLDB_RECORD_METHOD(int, SBCommandInterpreter, HandleCompletion, |
| (const char *, uint32_t, int, int, lldb::SBStringList &), |
| current_line, cursor_pos, match_start_point, |
| max_return_elements, matches); |
| |
| const char *cursor = current_line + cursor_pos; |
| const char *last_char = current_line + strlen(current_line); |
| return HandleCompletion(current_line, cursor, last_char, match_start_point, |
| max_return_elements, matches); |
| } |
| |
| bool SBCommandInterpreter::HasCommands() { |
| LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasCommands); |
| |
| return (IsValid() ? m_opaque_ptr->HasCommands() : false); |
| } |
| |
| bool SBCommandInterpreter::HasAliases() { |
| LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasAliases); |
| |
| return (IsValid() ? m_opaque_ptr->HasAliases() : false); |
| } |
| |
| bool SBCommandInterpreter::HasAliasOptions() { |
| LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasAliasOptions); |
| |
| return (IsValid() ? m_opaque_ptr->HasAliasOptions() : false); |
| } |
| |
| SBProcess SBCommandInterpreter::GetProcess() { |
| LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBCommandInterpreter, GetProcess); |
| |
| SBProcess sb_process; |
| ProcessSP process_sp; |
| if (IsValid()) { |
| TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget()); |
| if (target_sp) { |
| std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); |
| process_sp = target_sp->GetProcessSP(); |
| sb_process.SetSP(process_sp); |
| } |
| } |
| |
| return LLDB_RECORD_RESULT(sb_process); |
| } |
| |
| SBDebugger SBCommandInterpreter::GetDebugger() { |
| LLDB_RECORD_METHOD_NO_ARGS(lldb::SBDebugger, SBCommandInterpreter, |
| GetDebugger); |
| |
| SBDebugger sb_debugger; |
| if (IsValid()) |
| sb_debugger.reset(m_opaque_ptr->GetDebugger().shared_from_this()); |
| |
| return LLDB_RECORD_RESULT(sb_debugger); |
| } |
| |
| bool SBCommandInterpreter::GetPromptOnQuit() { |
| LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, GetPromptOnQuit); |
| |
| return (IsValid() ? m_opaque_ptr->GetPromptOnQuit() : false); |
| } |
| |
| void SBCommandInterpreter::SetPromptOnQuit(bool b) { |
| LLDB_RECORD_METHOD(void, SBCommandInterpreter, SetPromptOnQuit, (bool), b); |
| |
| if (IsValid()) |
| m_opaque_ptr->SetPromptOnQuit(b); |
| } |
| |
| void SBCommandInterpreter::AllowExitCodeOnQuit(bool allow) { |
| LLDB_RECORD_METHOD(void, SBCommandInterpreter, AllowExitCodeOnQuit, (bool), |
| allow); |
| |
| if (m_opaque_ptr) |
| m_opaque_ptr->AllowExitCodeOnQuit(allow); |
| } |
| |
| bool SBCommandInterpreter::HasCustomQuitExitCode() { |
| LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandInterpreter, HasCustomQuitExitCode); |
| |
| bool exited = false; |
| if (m_opaque_ptr) |
| m_opaque_ptr->GetQuitExitCode(exited); |
| return exited; |
| } |
| |
| int SBCommandInterpreter::GetQuitStatus() { |
| LLDB_RECORD_METHOD_NO_ARGS(int, SBCommandInterpreter, GetQuitStatus); |
| |
| bool exited = false; |
| return (m_opaque_ptr ? m_opaque_ptr->GetQuitExitCode(exited) : 0); |
| } |
| |
| void SBCommandInterpreter::ResolveCommand(const char *command_line, |
| SBCommandReturnObject &result) { |
| LLDB_RECORD_METHOD(void, SBCommandInterpreter, ResolveCommand, |
| (const char *, lldb::SBCommandReturnObject &), |
| command_line, result); |
| |
| result.Clear(); |
| if (command_line && IsValid()) { |
| m_opaque_ptr->ResolveCommand(command_line, result.ref()); |
| } else { |
| result->AppendError( |
| "SBCommandInterpreter or the command line is not valid"); |
| } |
| } |
| |
| CommandInterpreter *SBCommandInterpreter::get() { return m_opaque_ptr; } |
| |
| CommandInterpreter &SBCommandInterpreter::ref() { |
| assert(m_opaque_ptr); |
| return *m_opaque_ptr; |
| } |
| |
| void SBCommandInterpreter::reset( |
| lldb_private::CommandInterpreter *interpreter) { |
| m_opaque_ptr = interpreter; |
| } |
| |
| void SBCommandInterpreter::SourceInitFileInHomeDirectory( |
| SBCommandReturnObject &result) { |
| LLDB_RECORD_METHOD(void, SBCommandInterpreter, SourceInitFileInHomeDirectory, |
| (lldb::SBCommandReturnObject &), result); |
| |
| result.Clear(); |
| if (IsValid()) { |
| TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget()); |
| std::unique_lock<std::recursive_mutex> lock; |
| if (target_sp) |
| lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex()); |
| m_opaque_ptr->SourceInitFileHome(result.ref()); |
| } else { |
| result->AppendError("SBCommandInterpreter is not valid"); |
| } |
| } |
| |
| void SBCommandInterpreter::SourceInitFileInHomeDirectory( |
| SBCommandReturnObject &result, bool is_repl) { |
| LLDB_RECORD_METHOD(void, SBCommandInterpreter, SourceInitFileInHomeDirectory, |
| (lldb::SBCommandReturnObject &, bool), result, is_repl); |
| |
| result.Clear(); |
| if (IsValid()) { |
| TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget()); |
| std::unique_lock<std::recursive_mutex> lock; |
| if (target_sp) |
| lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex()); |
| m_opaque_ptr->SourceInitFileHome(result.ref(), is_repl); |
| } else { |
| result->AppendError("SBCommandInterpreter is not valid"); |
| } |
| } |
| |
| void SBCommandInterpreter::SourceInitFileInCurrentWorkingDirectory( |
| SBCommandReturnObject &result) { |
| LLDB_RECORD_METHOD(void, SBCommandInterpreter, |
| SourceInitFileInCurrentWorkingDirectory, |
| (lldb::SBCommandReturnObject &), result); |
| |
| result.Clear(); |
| if (IsValid()) { |
| TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget()); |
| std::unique_lock<std::recursive_mutex> lock; |
| if (target_sp) |
| lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex()); |
| m_opaque_ptr->SourceInitFileCwd(result.ref()); |
| } else { |
| result->AppendError("SBCommandInterpreter is not valid"); |
| } |
| } |
| |
| SBBroadcaster SBCommandInterpreter::GetBroadcaster() { |
| LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBroadcaster, SBCommandInterpreter, |
| GetBroadcaster); |
| |
| |
| SBBroadcaster broadcaster(m_opaque_ptr, false); |
| |
| |
| return LLDB_RECORD_RESULT(broadcaster); |
| } |
| |
| const char *SBCommandInterpreter::GetBroadcasterClass() { |
| LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBCommandInterpreter, |
| GetBroadcasterClass); |
| |
| return CommandInterpreter::GetStaticBroadcasterClass().AsCString(); |
| } |
| |
| const char *SBCommandInterpreter::GetArgumentTypeAsCString( |
| const lldb::CommandArgumentType arg_type) { |
| LLDB_RECORD_STATIC_METHOD(const char *, SBCommandInterpreter, |
| GetArgumentTypeAsCString, |
| (const lldb::CommandArgumentType), arg_type); |
| |
| return CommandObject::GetArgumentTypeAsCString(arg_type); |
| } |
| |
| const char *SBCommandInterpreter::GetArgumentDescriptionAsCString( |
| const lldb::CommandArgumentType arg_type) { |
| LLDB_RECORD_STATIC_METHOD(const char *, SBCommandInterpreter, |
| GetArgumentDescriptionAsCString, |
| (const lldb::CommandArgumentType), arg_type); |
| |
| return CommandObject::GetArgumentDescriptionAsCString(arg_type); |
| } |
| |
| bool SBCommandInterpreter::EventIsCommandInterpreterEvent( |
| const lldb::SBEvent &event) { |
| LLDB_RECORD_STATIC_METHOD(bool, SBCommandInterpreter, |
| EventIsCommandInterpreterEvent, |
| (const lldb::SBEvent &), event); |
| |
| return event.GetBroadcasterClass() == |
| SBCommandInterpreter::GetBroadcasterClass(); |
| } |
| |
| bool SBCommandInterpreter::SetCommandOverrideCallback( |
| const char *command_name, lldb::CommandOverrideCallback callback, |
| void *baton) { |
| LLDB_RECORD_DUMMY(bool, SBCommandInterpreter, SetCommandOverrideCallback, |
| (const char *, lldb::CommandOverrideCallback, void *), |
| command_name, callback, baton); |
| |
| if (command_name && command_name[0] && IsValid()) { |
| llvm::StringRef command_name_str = command_name; |
| CommandObject *cmd_obj = |
| m_opaque_ptr->GetCommandObjectForCommand(command_name_str); |
| if (cmd_obj) { |
| assert(command_name_str.empty()); |
| cmd_obj->SetOverrideCallback(callback, baton); |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| lldb::SBCommand SBCommandInterpreter::AddMultiwordCommand(const char *name, |
| const char *help) { |
| LLDB_RECORD_METHOD(lldb::SBCommand, SBCommandInterpreter, AddMultiwordCommand, |
| (const char *, const char *), name, help); |
| |
| lldb::CommandObjectSP new_command_sp( |
| new CommandObjectMultiword(*m_opaque_ptr, name, help)); |
| new_command_sp->GetAsMultiwordCommand()->SetRemovable(true); |
| Status add_error = m_opaque_ptr->AddUserCommand(name, new_command_sp, true); |
| if (add_error.Success()) |
| return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp)); |
| return LLDB_RECORD_RESULT(lldb::SBCommand()); |
| } |
| |
| lldb::SBCommand SBCommandInterpreter::AddCommand( |
| const char *name, lldb::SBCommandPluginInterface *impl, const char *help) { |
| LLDB_RECORD_METHOD( |
| lldb::SBCommand, SBCommandInterpreter, AddCommand, |
| (const char *, lldb::SBCommandPluginInterface *, const char *), name, |
| impl, help); |
| |
| return LLDB_RECORD_RESULT(AddCommand(name, impl, help, /*syntax=*/nullptr, |
| /*auto_repeat_command=*/"")) |
| } |
| |
| lldb::SBCommand |
| SBCommandInterpreter::AddCommand(const char *name, |
| lldb::SBCommandPluginInterface *impl, |
| const char *help, const char *syntax) { |
| LLDB_RECORD_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand, |
| (const char *, lldb::SBCommandPluginInterface *, |
| const char *, const char *), |
| name, impl, help, syntax); |
| return LLDB_RECORD_RESULT( |
| AddCommand(name, impl, help, syntax, /*auto_repeat_command=*/"")) |
| } |
| |
| lldb::SBCommand SBCommandInterpreter::AddCommand( |
| const char *name, lldb::SBCommandPluginInterface *impl, const char *help, |
| const char *syntax, const char *auto_repeat_command) { |
| LLDB_RECORD_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand, |
| (const char *, lldb::SBCommandPluginInterface *, |
| const char *, const char *, const char *), |
| name, impl, help, syntax, auto_repeat_command); |
| |
| lldb::CommandObjectSP new_command_sp; |
| new_command_sp = std::make_shared<CommandPluginInterfaceImplementation>( |
| *m_opaque_ptr, name, impl, help, syntax, /*flags=*/0, |
| auto_repeat_command); |
| |
| Status add_error = m_opaque_ptr->AddUserCommand(name, new_command_sp, true); |
| if (add_error.Success()) |
| return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp)); |
| return LLDB_RECORD_RESULT(lldb::SBCommand()); |
| } |
| |
| SBCommand::SBCommand() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommand); } |
| |
| SBCommand::SBCommand(lldb::CommandObjectSP cmd_sp) : m_opaque_sp(cmd_sp) {} |
| |
| bool SBCommand::IsValid() { |
| LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommand, IsValid); |
| return this->operator bool(); |
| } |
| SBCommand::operator bool() const { |
| LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommand, operator bool); |
| |
| return m_opaque_sp.get() != nullptr; |
| } |
| |
| const char *SBCommand::GetName() { |
| LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommand, GetName); |
| |
| return (IsValid() ? ConstString(m_opaque_sp->GetCommandName()).AsCString() : nullptr); |
| } |
| |
| const char *SBCommand::GetHelp() { |
| LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommand, GetHelp); |
| |
| return (IsValid() ? ConstString(m_opaque_sp->GetHelp()).AsCString() |
| : nullptr); |
| } |
| |
| const char *SBCommand::GetHelpLong() { |
| LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommand, GetHelpLong); |
| |
| return (IsValid() ? ConstString(m_opaque_sp->GetHelpLong()).AsCString() |
| : nullptr); |
| } |
| |
| void SBCommand::SetHelp(const char *help) { |
| LLDB_RECORD_METHOD(void, SBCommand, SetHelp, (const char *), help); |
| |
| if (IsValid()) |
| m_opaque_sp->SetHelp(help); |
| } |
| |
| void SBCommand::SetHelpLong(const char *help) { |
| LLDB_RECORD_METHOD(void, SBCommand, SetHelpLong, (const char *), help); |
| |
| if (IsValid()) |
| m_opaque_sp->SetHelpLong(help); |
| } |
| |
| lldb::SBCommand SBCommand::AddMultiwordCommand(const char *name, |
| const char *help) { |
| LLDB_RECORD_METHOD(lldb::SBCommand, SBCommand, AddMultiwordCommand, |
| (const char *, const char *), name, help); |
| |
| if (!IsValid()) |
| return LLDB_RECORD_RESULT(lldb::SBCommand()); |
| if (!m_opaque_sp->IsMultiwordObject()) |
| return LLDB_RECORD_RESULT(lldb::SBCommand()); |
| CommandObjectMultiword *new_command = new CommandObjectMultiword( |
| m_opaque_sp->GetCommandInterpreter(), name, help); |
| new_command->SetRemovable(true); |
| lldb::CommandObjectSP new_command_sp(new_command); |
| if (new_command_sp && m_opaque_sp->LoadSubCommand(name, new_command_sp)) |
| return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp)); |
| return LLDB_RECORD_RESULT(lldb::SBCommand()); |
| } |
| |
| lldb::SBCommand SBCommand::AddCommand(const char *name, |
| lldb::SBCommandPluginInterface *impl, |
| const char *help) { |
| LLDB_RECORD_METHOD( |
| lldb::SBCommand, SBCommand, AddCommand, |
| (const char *, lldb::SBCommandPluginInterface *, const char *), name, |
| impl, help); |
| return LLDB_RECORD_RESULT(AddCommand(name, impl, help, /*syntax=*/nullptr, |
| /*auto_repeat_command=*/"")) |
| } |
| |
| lldb::SBCommand SBCommand::AddCommand(const char *name, |
| lldb::SBCommandPluginInterface *impl, |
| const char *help, const char *syntax) { |
| LLDB_RECORD_METHOD(lldb::SBCommand, SBCommand, AddCommand, |
| (const char *, lldb::SBCommandPluginInterface *, |
| const char *, const char *), |
| name, impl, help, syntax); |
| return LLDB_RECORD_RESULT( |
| AddCommand(name, impl, help, syntax, /*auto_repeat_command=*/"")) |
| } |
| |
| lldb::SBCommand SBCommand::AddCommand(const char *name, |
| lldb::SBCommandPluginInterface *impl, |
| const char *help, const char *syntax, |
| const char *auto_repeat_command) { |
| LLDB_RECORD_METHOD(lldb::SBCommand, SBCommand, AddCommand, |
| (const char *, lldb::SBCommandPluginInterface *, |
| const char *, const char *, const char *), |
| name, impl, help, syntax, auto_repeat_command); |
| |
| if (!IsValid()) |
| return LLDB_RECORD_RESULT(lldb::SBCommand()); |
| if (!m_opaque_sp->IsMultiwordObject()) |
| return LLDB_RECORD_RESULT(lldb::SBCommand()); |
| lldb::CommandObjectSP new_command_sp; |
| new_command_sp = std::make_shared<CommandPluginInterfaceImplementation>( |
| m_opaque_sp->GetCommandInterpreter(), name, impl, help, syntax, |
| /*flags=*/0, auto_repeat_command); |
| if (new_command_sp && m_opaque_sp->LoadSubCommand(name, new_command_sp)) |
| return LLDB_RECORD_RESULT(lldb::SBCommand(new_command_sp)); |
| return LLDB_RECORD_RESULT(lldb::SBCommand()); |
| } |
| |
| uint32_t SBCommand::GetFlags() { |
| LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBCommand, GetFlags); |
| |
| return (IsValid() ? m_opaque_sp->GetFlags().Get() : 0); |
| } |
| |
| void SBCommand::SetFlags(uint32_t flags) { |
| LLDB_RECORD_METHOD(void, SBCommand, SetFlags, (uint32_t), flags); |
| |
| if (IsValid()) |
| m_opaque_sp->GetFlags().Set(flags); |
| } |
| |
| namespace lldb_private { |
| namespace repro { |
| |
| template <> void RegisterMethods<SBCommandInterpreter>(Registry &R) { |
| LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreter, |
| (lldb_private::CommandInterpreter *)); |
| LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreter, |
| (const lldb::SBCommandInterpreter &)); |
| LLDB_REGISTER_METHOD( |
| const lldb::SBCommandInterpreter &, |
| SBCommandInterpreter, operator=,(const lldb::SBCommandInterpreter &)); |
| LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, IsValid, ()); |
| LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, operator bool, ()); |
| LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, CommandExists, |
| (const char *)); |
| LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, AliasExists, |
| (const char *)); |
| LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, IsActive, ()); |
| LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, WasInterrupted, ()); |
| LLDB_REGISTER_METHOD(const char *, SBCommandInterpreter, |
| GetIOHandlerControlSequence, (char)); |
| LLDB_REGISTER_METHOD(lldb::ReturnStatus, SBCommandInterpreter, |
| HandleCommand, |
| (const char *, lldb::SBCommandReturnObject &, bool)); |
| LLDB_REGISTER_METHOD(lldb::ReturnStatus, SBCommandInterpreter, |
| HandleCommand, |
| (const char *, lldb::SBExecutionContext &, |
| lldb::SBCommandReturnObject &, bool)); |
| LLDB_REGISTER_METHOD(void, SBCommandInterpreter, HandleCommandsFromFile, |
| (lldb::SBFileSpec &, lldb::SBExecutionContext &, |
| lldb::SBCommandInterpreterRunOptions &, |
| lldb::SBCommandReturnObject)); |
| LLDB_REGISTER_METHOD(int, SBCommandInterpreter, HandleCompletion, |
| (const char *, const char *, const char *, int, int, |
| lldb::SBStringList &)); |
| LLDB_REGISTER_METHOD(int, SBCommandInterpreter, |
| HandleCompletionWithDescriptions, |
| (const char *, const char *, const char *, int, int, |
| lldb::SBStringList &, lldb::SBStringList &)); |
| LLDB_REGISTER_METHOD(int, SBCommandInterpreter, |
| HandleCompletionWithDescriptions, |
| (const char *, uint32_t, int, int, |
| lldb::SBStringList &, lldb::SBStringList &)); |
| LLDB_REGISTER_METHOD( |
| int, SBCommandInterpreter, HandleCompletion, |
| (const char *, uint32_t, int, int, lldb::SBStringList &)); |
| LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasCommands, ()); |
| LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasAliases, ()); |
| LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasAliasOptions, ()); |
| LLDB_REGISTER_METHOD(lldb::SBProcess, SBCommandInterpreter, GetProcess, ()); |
| LLDB_REGISTER_METHOD(lldb::SBDebugger, SBCommandInterpreter, GetDebugger, |
| ()); |
| LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, GetPromptOnQuit, ()); |
| LLDB_REGISTER_METHOD(void, SBCommandInterpreter, SetPromptOnQuit, (bool)); |
| LLDB_REGISTER_METHOD(void, SBCommandInterpreter, AllowExitCodeOnQuit, |
| (bool)); |
| LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasCustomQuitExitCode, ()); |
| LLDB_REGISTER_METHOD(int, SBCommandInterpreter, GetQuitStatus, ()); |
| LLDB_REGISTER_METHOD(void, SBCommandInterpreter, ResolveCommand, |
| (const char *, lldb::SBCommandReturnObject &)); |
| LLDB_REGISTER_METHOD(void, SBCommandInterpreter, |
| SourceInitFileInHomeDirectory, |
| (lldb::SBCommandReturnObject &)); |
| LLDB_REGISTER_METHOD(void, SBCommandInterpreter, |
| SourceInitFileInHomeDirectory, |
| (lldb::SBCommandReturnObject &, bool)); |
| LLDB_REGISTER_METHOD(void, SBCommandInterpreter, |
| SourceInitFileInCurrentWorkingDirectory, |
| (lldb::SBCommandReturnObject &)); |
| LLDB_REGISTER_METHOD(lldb::SBBroadcaster, SBCommandInterpreter, |
| GetBroadcaster, ()); |
| LLDB_REGISTER_STATIC_METHOD(const char *, SBCommandInterpreter, |
| GetBroadcasterClass, ()); |
| LLDB_REGISTER_STATIC_METHOD(const char *, SBCommandInterpreter, |
| GetArgumentTypeAsCString, |
| (const lldb::CommandArgumentType)); |
| LLDB_REGISTER_STATIC_METHOD(const char *, SBCommandInterpreter, |
| GetArgumentDescriptionAsCString, |
| (const lldb::CommandArgumentType)); |
| LLDB_REGISTER_STATIC_METHOD(bool, SBCommandInterpreter, |
| EventIsCommandInterpreterEvent, |
| (const lldb::SBEvent &)); |
| LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommandInterpreter, |
| AddMultiwordCommand, (const char *, const char *)); |
| LLDB_REGISTER_METHOD( |
| lldb::SBCommand, SBCommandInterpreter, AddCommand, |
| (const char *, lldb::SBCommandPluginInterface *, const char *)); |
| LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand, |
| (const char *, lldb::SBCommandPluginInterface *, |
| const char *, const char *)); |
| LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand, |
| (const char *, lldb::SBCommandPluginInterface *, |
| const char *, const char *, const char *)); |
| LLDB_REGISTER_CONSTRUCTOR(SBCommand, ()); |
| LLDB_REGISTER_METHOD(bool, SBCommand, IsValid, ()); |
| LLDB_REGISTER_METHOD_CONST(bool, SBCommand, operator bool, ()); |
| LLDB_REGISTER_METHOD(const char *, SBCommand, GetName, ()); |
| LLDB_REGISTER_METHOD(const char *, SBCommand, GetHelp, ()); |
| LLDB_REGISTER_METHOD(const char *, SBCommand, GetHelpLong, ()); |
| LLDB_REGISTER_METHOD(void, SBCommand, SetHelp, (const char *)); |
| LLDB_REGISTER_METHOD(void, SBCommand, SetHelpLong, (const char *)); |
| LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommand, AddMultiwordCommand, |
| (const char *, const char *)); |
| LLDB_REGISTER_METHOD( |
| lldb::SBCommand, SBCommand, AddCommand, |
| (const char *, lldb::SBCommandPluginInterface *, const char *)); |
| LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommand, AddCommand, |
| (const char *, lldb::SBCommandPluginInterface *, |
| const char *, const char *)); |
| LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommand, AddCommand, |
| (const char *, lldb::SBCommandPluginInterface *, |
| const char *, const char *, const char *)); |
| LLDB_REGISTER_METHOD(uint32_t, SBCommand, GetFlags, ()); |
| LLDB_REGISTER_METHOD(void, SBCommand, SetFlags, (uint32_t)); |
| } |
| } |
| } |
