| //===----------------------------------------------------------------------===// |
| // |
| // 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-python.h" |
| |
| #include "lldb/API/SBCommandReturnObject.h" |
| #include "lldb/Core/Debugger.h" |
| #include "lldb/Core/PluginManager.h" |
| #include "lldb/Interpreter/CommandReturnObject.h" |
| #include "lldb/Target/ExecutionContext.h" |
| #include "lldb/Utility/Args.h" |
| #include "lldb/Utility/ScriptedMetadata.h" |
| #include "lldb/lldb-enumerations.h" |
| |
| #include "../SWIGPythonBridge.h" |
| #include "../ScriptInterpreterPythonImpl.h" |
| #include "ScriptedCommandPythonInterface.h" |
| |
| using namespace lldb; |
| using namespace lldb_private; |
| using namespace lldb_private::python; |
| using Locker = ScriptInterpreterPythonImpl::Locker; |
| |
| ScriptedCommandPythonInterface::ScriptedCommandPythonInterface( |
| ScriptInterpreterPythonImpl &interpreter) |
| : ScriptedCommandInterface(), ScriptedPythonInterface(interpreter) {} |
| |
| llvm::Expected<StructuredData::GenericSP> |
| ScriptedCommandPythonInterface::CreatePluginObject( |
| llvm::StringRef class_name, lldb::DebuggerSP debugger_sp) { |
| if (class_name.empty()) |
| return llvm::createStringError("empty class name"); |
| |
| if (!debugger_sp) |
| return llvm::createStringError("invalid Debugger pointer"); |
| |
| m_debugger_sp = debugger_sp; |
| ScriptedMetadata scripted_metadata(class_name, |
| StructuredData::DictionarySP()); |
| return ScriptedPythonInterface::CreatePluginObject( |
| scripted_metadata, /*script_obj=*/nullptr, debugger_sp); |
| } |
| |
| bool ScriptedCommandPythonInterface::RunRawCommand( |
| llvm::StringRef args, ScriptedCommandSynchronicity synchronicity, |
| CommandReturnObject &cmd_retobj, Status &error, |
| const ExecutionContext &exe_ctx) { |
| lldb::DebuggerSP debugger_sp = m_debugger_sp; |
| if (!debugger_sp) { |
| error = Status::FromErrorString("invalid Debugger pointer"); |
| return false; |
| } |
| lldb::ExecutionContextRefSP exe_ctx_ref_sp(new ExecutionContextRef(exe_ctx)); |
| |
| // Outer Locker sets up the session (with conditional NoSTDIN for |
| // interactive commands and TearDownSession on exit) that Dispatch's inner |
| // Locker doesn't provide. Nesting is only safe because Dispatch's own |
| // Locker never requests InitSession itself. |
| Locker py_lock(&m_interpreter, |
| Locker::AcquireLock | Locker::InitSession | |
| (cmd_retobj.GetInteractive() ? 0 : Locker::NoSTDIN), |
| Locker::FreeLock | Locker::TearDownSession); |
| ScriptInterpreterPythonImpl::SynchronicityHandler synch_handler( |
| debugger_sp, synchronicity); |
| |
| std::string args_str = args.str(); |
| Dispatch("__call__", error, debugger_sp, args_str.c_str(), exe_ctx_ref_sp, |
| &cmd_retobj); |
| |
| if (!error.Success() || cmd_retobj.GetStatus() == eReturnStatusFailed) |
| return false; |
| |
| return true; |
| } |
| |
| bool ScriptedCommandPythonInterface::RunParsedCommand( |
| Args &args, ScriptedCommandSynchronicity synchronicity, |
| CommandReturnObject &cmd_retobj, Status &error, |
| const ExecutionContext &exe_ctx) { |
| lldb::DebuggerSP debugger_sp = m_debugger_sp; |
| if (!debugger_sp) { |
| error = Status::FromErrorString("invalid Debugger pointer"); |
| return false; |
| } |
| lldb::ExecutionContextRefSP exe_ctx_ref_sp(new ExecutionContextRef(exe_ctx)); |
| |
| Locker py_lock(&m_interpreter, |
| Locker::AcquireLock | Locker::InitSession | |
| (cmd_retobj.GetInteractive() ? 0 : Locker::NoSTDIN), |
| Locker::FreeLock | Locker::TearDownSession); |
| ScriptInterpreterPythonImpl::SynchronicityHandler synch_handler( |
| debugger_sp, synchronicity); |
| |
| StructuredData::ArraySP args_arr_sp(new StructuredData::Array()); |
| for (const Args::ArgEntry &entry : args) |
| args_arr_sp->AddStringItem(entry.ref()); |
| StructuredDataImpl args_impl(args_arr_sp); |
| |
| Dispatch("__call__", error, debugger_sp, args_impl, exe_ctx_ref_sp, |
| &cmd_retobj); |
| |
| if (!error.Success() || cmd_retobj.GetStatus() == eReturnStatusFailed) |
| return false; |
| |
| return true; |
| } |
| |
| std::optional<std::string> |
| ScriptedCommandPythonInterface::GetRepeatCommand(Args &args) { |
| std::string command; |
| args.GetQuotedCommandString(command); |
| Status error; |
| StructuredData::ObjectSP obj = |
| Dispatch("get_repeat_command", error, command.c_str()); |
| if (!ScriptedInterface::CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, obj, |
| error)) |
| return {}; |
| return obj->GetStringValue().str(); |
| } |
| |
| StructuredData::DictionarySP |
| ScriptedCommandPythonInterface::HandleArgumentCompletion( |
| std::vector<std::string> &args, size_t args_pos, size_t char_in_arg) { |
| Status error; |
| StructuredData::ObjectSP obj = Dispatch("handle_argument_completion", error, |
| args, args_pos, char_in_arg); |
| if (!ScriptedInterface::CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, obj, |
| error)) |
| return {}; |
| StructuredData::DictionarySP dict_sp(new StructuredData::Dictionary(obj)); |
| if (dict_sp->GetType() == lldb::eStructuredDataTypeInvalid) |
| return {}; |
| return dict_sp; |
| } |
| |
| StructuredData::DictionarySP |
| ScriptedCommandPythonInterface::HandleOptionArgumentCompletion( |
| llvm::StringRef &long_option, size_t char_in_arg) { |
| Status error; |
| std::string long_option_str = long_option.str(); |
| StructuredData::ObjectSP obj = |
| Dispatch("handle_option_argument_completion", error, |
| long_option_str.c_str(), char_in_arg); |
| if (!ScriptedInterface::CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, obj, |
| error)) |
| return {}; |
| |
| // A boolean return means: True means completion handled but no |
| // completions; False means completion not handled (fall back to default). |
| if (obj->GetType() == lldb::eStructuredDataTypeBoolean) { |
| if (!obj->GetBooleanValue()) |
| return {}; |
| StructuredData::DictionarySP dict_sp(new StructuredData::Dictionary()); |
| dict_sp->AddBooleanItem("no-completion", true); |
| return dict_sp; |
| } |
| |
| StructuredData::DictionarySP dict_sp(new StructuredData::Dictionary(obj)); |
| if (dict_sp->GetType() == lldb::eStructuredDataTypeInvalid) |
| return {}; |
| return dict_sp; |
| } |
| |
| bool ScriptedCommandPythonInterface::GetShortHelp(std::string &dest) { |
| dest.clear(); |
| Status error; |
| StructuredData::ObjectSP obj = Dispatch("get_short_help", error); |
| if (!ScriptedInterface::CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, obj, |
| error)) |
| return false; |
| dest = obj->GetStringValue().str(); |
| return !dest.empty(); |
| } |
| |
| bool ScriptedCommandPythonInterface::GetLongHelp(std::string &dest) { |
| dest.clear(); |
| Status error; |
| StructuredData::ObjectSP obj = Dispatch("get_long_help", error); |
| if (!ScriptedInterface::CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, obj, |
| error)) |
| return false; |
| dest = obj->GetStringValue().str(); |
| return !dest.empty(); |
| } |
| |
| uint32_t ScriptedCommandPythonInterface::GetFlags() { |
| Status error; |
| StructuredData::ObjectSP obj = Dispatch("get_flags", error); |
| if (!ScriptedInterface::CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, obj, |
| error)) |
| return 0; |
| return static_cast<uint32_t>(obj->GetUnsignedIntegerValue()); |
| } |
| |
| StructuredData::ObjectSP |
| ScriptedCommandPythonInterface::GetOptionsDefinition() { |
| Status error; |
| return Dispatch("get_options_definition", error); |
| } |
| |
| StructuredData::ObjectSP |
| ScriptedCommandPythonInterface::GetArgumentsDefinition() { |
| Status error; |
| return Dispatch("get_args_definition", error); |
| } |
| |
| void ScriptedCommandPythonInterface::OptionParsingStarted() { |
| Status error; |
| Dispatch("option_parsing_started", error); |
| } |
| |
| bool ScriptedCommandPythonInterface::SetOptionValue(ExecutionContext *exe_ctx, |
| llvm::StringRef long_option, |
| llvm::StringRef value) { |
| lldb::ExecutionContextRefSP exe_ctx_ref_sp; |
| if (exe_ctx) |
| exe_ctx_ref_sp = std::make_shared<ExecutionContextRef>(exe_ctx); |
| Status error; |
| std::string long_option_str = long_option.str(); |
| std::string value_str = value.str(); |
| StructuredData::ObjectSP obj = |
| Dispatch("set_option_value", error, exe_ctx_ref_sp, |
| long_option_str.c_str(), value_str.c_str()); |
| if (!ScriptedInterface::CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, obj, |
| error)) |
| return false; |
| return obj->GetBooleanValue(); |
| } |
| |
| void ScriptedCommandPythonInterface::Initialize() { |
| const std::vector<llvm::StringRef> ci_usages = { |
| "command script add -c <ClassName> <cmd>", |
| "command script add -p <ClassName> <cmd>"}; |
| const std::vector<llvm::StringRef> api_usages = {}; |
| PluginManager::RegisterPlugin( |
| GetPluginNameStatic(), |
| "Implement a raw or parsed custom command backed by a Python class.", |
| CreateInstance, eScriptedExtensionScriptedCommand, eScriptLanguagePython, |
| ScriptedInterfaceUsages(ci_usages, api_usages)); |
| } |
| |
| void ScriptedCommandPythonInterface::Terminate() { |
| PluginManager::UnregisterPlugin(CreateInstance); |
| } |
