27b6a4e63a
Many SB classes have public constructors or methods involving types that are private. Some are more obvious (e.g. containing lldb_private in the name) than others (lldb::FooSP is usually std::shared_pointer<lldb_private::Foo>). This commit explicitly does not address FileSP, so I'm leaving that one alone for now. Some of these were for other SB classes to use and should have been made protected/private with a friend class entry added. Some of these were public for some of the swig python helpers to use. I put all of those functions into a class and made them static methods. The relevant SB classes mark that class as a friend so they can access those private/protected members. I've also removed an outdated SBStructuredData test (can you guess which constructor it was using?) and updated the other relevant tests. Differential Revision: https://reviews.llvm.org/D150157
138 lines
4.4 KiB
C++
138 lines
4.4 KiB
C++
//===-- ScriptedPythonInterface.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/Host/Config.h"
|
|
#include "lldb/Utility/Log.h"
|
|
#include "lldb/lldb-enumerations.h"
|
|
|
|
#if LLDB_ENABLE_PYTHON
|
|
|
|
// LLDB Python header must be included first
|
|
#include "lldb-python.h"
|
|
|
|
#include "ScriptInterpreterPythonImpl.h"
|
|
#include "ScriptedPythonInterface.h"
|
|
#include <optional>
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
ScriptedPythonInterface::ScriptedPythonInterface(
|
|
ScriptInterpreterPythonImpl &interpreter)
|
|
: ScriptedInterface(), m_interpreter(interpreter) {}
|
|
|
|
template <>
|
|
StructuredData::ArraySP
|
|
ScriptedPythonInterface::ExtractValueFromPythonObject<StructuredData::ArraySP>(
|
|
python::PythonObject &p, Status &error) {
|
|
python::PythonList result_list(python::PyRefType::Borrowed, p.get());
|
|
return result_list.CreateStructuredArray();
|
|
}
|
|
|
|
template <>
|
|
StructuredData::DictionarySP
|
|
ScriptedPythonInterface::ExtractValueFromPythonObject<
|
|
StructuredData::DictionarySP>(python::PythonObject &p, Status &error) {
|
|
python::PythonDictionary result_dict(python::PyRefType::Borrowed, p.get());
|
|
return result_dict.CreateStructuredDictionary();
|
|
}
|
|
|
|
template <>
|
|
Status ScriptedPythonInterface::ExtractValueFromPythonObject<Status>(
|
|
python::PythonObject &p, Status &error) {
|
|
if (lldb::SBError *sb_error = reinterpret_cast<lldb::SBError *>(
|
|
python::LLDBSWIGPython_CastPyObjectToSBError(p.get())))
|
|
return m_interpreter.GetStatusFromSBError(*sb_error);
|
|
else
|
|
error.SetErrorString("Couldn't cast lldb::SBError to lldb::Status.");
|
|
|
|
return {};
|
|
}
|
|
|
|
template <>
|
|
lldb::DataExtractorSP
|
|
ScriptedPythonInterface::ExtractValueFromPythonObject<lldb::DataExtractorSP>(
|
|
python::PythonObject &p, Status &error) {
|
|
lldb::SBData *sb_data = reinterpret_cast<lldb::SBData *>(
|
|
python::LLDBSWIGPython_CastPyObjectToSBData(p.get()));
|
|
|
|
if (!sb_data) {
|
|
error.SetErrorString(
|
|
"Couldn't cast lldb::SBData to lldb::DataExtractorSP.");
|
|
return nullptr;
|
|
}
|
|
|
|
return m_interpreter.GetDataExtractorFromSBData(*sb_data);
|
|
}
|
|
|
|
template <>
|
|
lldb::BreakpointSP
|
|
ScriptedPythonInterface::ExtractValueFromPythonObject<lldb::BreakpointSP>(
|
|
python::PythonObject &p, Status &error) {
|
|
lldb::SBBreakpoint *sb_breakpoint = reinterpret_cast<lldb::SBBreakpoint *>(
|
|
python::LLDBSWIGPython_CastPyObjectToSBBreakpoint(p.get()));
|
|
|
|
if (!sb_breakpoint) {
|
|
error.SetErrorString(
|
|
"Couldn't cast lldb::SBBreakpoint to lldb::BreakpointSP.");
|
|
return nullptr;
|
|
}
|
|
|
|
return m_interpreter.GetOpaqueTypeFromSBBreakpoint(*sb_breakpoint);
|
|
}
|
|
|
|
template <>
|
|
lldb::ProcessAttachInfoSP ScriptedPythonInterface::ExtractValueFromPythonObject<
|
|
lldb::ProcessAttachInfoSP>(python::PythonObject &p, Status &error) {
|
|
lldb::SBAttachInfo *sb_attach_info = reinterpret_cast<lldb::SBAttachInfo *>(
|
|
python::LLDBSWIGPython_CastPyObjectToSBAttachInfo(p.get()));
|
|
|
|
if (!sb_attach_info) {
|
|
error.SetErrorString(
|
|
"Couldn't cast lldb::SBAttachInfo to lldb::ProcessAttachInfoSP.");
|
|
return nullptr;
|
|
}
|
|
|
|
return m_interpreter.GetOpaqueTypeFromSBAttachInfo(*sb_attach_info);
|
|
}
|
|
|
|
template <>
|
|
lldb::ProcessLaunchInfoSP ScriptedPythonInterface::ExtractValueFromPythonObject<
|
|
lldb::ProcessLaunchInfoSP>(python::PythonObject &p, Status &error) {
|
|
lldb::SBLaunchInfo *sb_launch_info = reinterpret_cast<lldb::SBLaunchInfo *>(
|
|
python::LLDBSWIGPython_CastPyObjectToSBLaunchInfo(p.get()));
|
|
|
|
if (!sb_launch_info) {
|
|
error.SetErrorString(
|
|
"Couldn't cast lldb::SBLaunchInfo to lldb::ProcessLaunchInfoSP.");
|
|
return nullptr;
|
|
}
|
|
|
|
return m_interpreter.GetOpaqueTypeFromSBLaunchInfo(*sb_launch_info);
|
|
}
|
|
|
|
template <>
|
|
std::optional<MemoryRegionInfo>
|
|
ScriptedPythonInterface::ExtractValueFromPythonObject<
|
|
std::optional<MemoryRegionInfo>>(python::PythonObject &p, Status &error) {
|
|
|
|
lldb::SBMemoryRegionInfo *sb_mem_reg_info =
|
|
reinterpret_cast<lldb::SBMemoryRegionInfo *>(
|
|
python::LLDBSWIGPython_CastPyObjectToSBMemoryRegionInfo(p.get()));
|
|
|
|
if (!sb_mem_reg_info) {
|
|
error.SetErrorString(
|
|
"Couldn't cast lldb::SBMemoryRegionInfo to lldb::MemoryRegionInfoSP.");
|
|
return {};
|
|
}
|
|
|
|
return m_interpreter.GetOpaqueTypeFromSBMemoryRegionInfo(*sb_mem_reg_info);
|
|
}
|
|
|
|
#endif
|