190fadcdb2
Win32 API calls that are Unicode aware require wide character strings, but LLDB uses UTF8 everywhere. This patch does conversions wherever necessary when passing strings into and out of Win32 API calls. Patch by Cameron Differential Revision: http://reviews.llvm.org/D17107 Reviewed By: zturner, amccarth llvm-svn: 264074
1280 lines
32 KiB
C++
1280 lines
32 KiB
C++
//===-- PythonDataObjects.cpp ------------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifdef LLDB_DISABLE_PYTHON
|
|
|
|
// Python is disabled in this build
|
|
|
|
#else
|
|
|
|
#include "lldb-python.h"
|
|
#include "PythonDataObjects.h"
|
|
#include "ScriptInterpreterPython.h"
|
|
|
|
#include "lldb/Core/Stream.h"
|
|
#include "lldb/Host/File.h"
|
|
#include "lldb/Host/FileSystem.h"
|
|
#include "lldb/Interpreter/ScriptInterpreter.h"
|
|
|
|
#include "llvm/Support/ConvertUTF.h"
|
|
|
|
#include <stdio.h>
|
|
|
|
#include "llvm/ADT/StringSwitch.h"
|
|
|
|
using namespace lldb_private;
|
|
using namespace lldb;
|
|
|
|
void
|
|
StructuredPythonObject::Dump(Stream &s) const
|
|
{
|
|
s << "Python Obj: 0x" << GetValue();
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// PythonObject
|
|
//----------------------------------------------------------------------
|
|
|
|
void
|
|
PythonObject::Dump(Stream &strm) const
|
|
{
|
|
if (m_py_obj)
|
|
{
|
|
FILE *file = ::tmpfile();
|
|
if (file)
|
|
{
|
|
::PyObject_Print (m_py_obj, file, 0);
|
|
const long length = ftell (file);
|
|
if (length)
|
|
{
|
|
::rewind(file);
|
|
std::vector<char> file_contents (length,'\0');
|
|
const size_t length_read = ::fread (file_contents.data(), 1, file_contents.size(), file);
|
|
if (length_read > 0)
|
|
strm.Write (file_contents.data(), length_read);
|
|
}
|
|
::fclose (file);
|
|
}
|
|
}
|
|
else
|
|
strm.PutCString ("NULL");
|
|
}
|
|
|
|
PyObjectType
|
|
PythonObject::GetObjectType() const
|
|
{
|
|
if (!IsAllocated())
|
|
return PyObjectType::None;
|
|
|
|
if (PythonModule::Check(m_py_obj))
|
|
return PyObjectType::Module;
|
|
if (PythonList::Check(m_py_obj))
|
|
return PyObjectType::List;
|
|
if (PythonTuple::Check(m_py_obj))
|
|
return PyObjectType::Tuple;
|
|
if (PythonDictionary::Check(m_py_obj))
|
|
return PyObjectType::Dictionary;
|
|
if (PythonString::Check(m_py_obj))
|
|
return PyObjectType::String;
|
|
#if PY_MAJOR_VERSION >= 3
|
|
if (PythonBytes::Check(m_py_obj))
|
|
return PyObjectType::Bytes;
|
|
#endif
|
|
if (PythonByteArray::Check(m_py_obj))
|
|
return PyObjectType::ByteArray;
|
|
if (PythonInteger::Check(m_py_obj))
|
|
return PyObjectType::Integer;
|
|
if (PythonFile::Check(m_py_obj))
|
|
return PyObjectType::File;
|
|
if (PythonCallable::Check(m_py_obj))
|
|
return PyObjectType::Callable;
|
|
return PyObjectType::Unknown;
|
|
}
|
|
|
|
PythonString
|
|
PythonObject::Repr() const
|
|
{
|
|
if (!m_py_obj)
|
|
return PythonString();
|
|
PyObject *repr = PyObject_Repr(m_py_obj);
|
|
if (!repr)
|
|
return PythonString();
|
|
return PythonString(PyRefType::Owned, repr);
|
|
}
|
|
|
|
PythonString
|
|
PythonObject::Str() const
|
|
{
|
|
if (!m_py_obj)
|
|
return PythonString();
|
|
PyObject *str = PyObject_Str(m_py_obj);
|
|
if (!str)
|
|
return PythonString();
|
|
return PythonString(PyRefType::Owned, str);
|
|
}
|
|
|
|
PythonObject
|
|
PythonObject::ResolveNameWithDictionary(llvm::StringRef name, const PythonDictionary &dict)
|
|
{
|
|
size_t dot_pos = name.find_first_of('.');
|
|
llvm::StringRef piece = name.substr(0, dot_pos);
|
|
PythonObject result = dict.GetItemForKey(PythonString(piece));
|
|
if (dot_pos == llvm::StringRef::npos)
|
|
{
|
|
// There was no dot, we're done.
|
|
return result;
|
|
}
|
|
|
|
// There was a dot. The remaining portion of the name should be looked up in
|
|
// the context of the object that was found in the dictionary.
|
|
return result.ResolveName(name.substr(dot_pos + 1));
|
|
}
|
|
|
|
PythonObject
|
|
PythonObject::ResolveName(llvm::StringRef name) const
|
|
{
|
|
// Resolve the name in the context of the specified object. If,
|
|
// for example, `this` refers to a PyModule, then this will look for
|
|
// `name` in this module. If `this` refers to a PyType, then it will
|
|
// resolve `name` as an attribute of that type. If `this` refers to
|
|
// an instance of an object, then it will resolve `name` as the value
|
|
// of the specified field.
|
|
//
|
|
// This function handles dotted names so that, for example, if `m_py_obj`
|
|
// refers to the `sys` module, and `name` == "path.append", then it
|
|
// will find the function `sys.path.append`.
|
|
|
|
size_t dot_pos = name.find_first_of('.');
|
|
if (dot_pos == llvm::StringRef::npos)
|
|
{
|
|
// No dots in the name, we should be able to find the value immediately
|
|
// as an attribute of `m_py_obj`.
|
|
return GetAttributeValue(name);
|
|
}
|
|
|
|
// Look up the first piece of the name, and resolve the rest as a child of that.
|
|
PythonObject parent = ResolveName(name.substr(0, dot_pos));
|
|
if (!parent.IsAllocated())
|
|
return PythonObject();
|
|
|
|
// Tail recursion.. should be optimized by the compiler
|
|
return parent.ResolveName(name.substr(dot_pos + 1));
|
|
}
|
|
|
|
bool
|
|
PythonObject::HasAttribute(llvm::StringRef attr) const
|
|
{
|
|
if (!IsValid())
|
|
return false;
|
|
PythonString py_attr(attr);
|
|
return !!PyObject_HasAttr(m_py_obj, py_attr.get());
|
|
}
|
|
|
|
PythonObject
|
|
PythonObject::GetAttributeValue(llvm::StringRef attr) const
|
|
{
|
|
if (!IsValid())
|
|
return PythonObject();
|
|
|
|
PythonString py_attr(attr);
|
|
if (!PyObject_HasAttr(m_py_obj, py_attr.get()))
|
|
return PythonObject();
|
|
|
|
return PythonObject(PyRefType::Owned,
|
|
PyObject_GetAttr(m_py_obj, py_attr.get()));
|
|
}
|
|
|
|
bool
|
|
PythonObject::IsNone() const
|
|
{
|
|
return m_py_obj == Py_None;
|
|
}
|
|
|
|
bool
|
|
PythonObject::IsValid() const
|
|
{
|
|
return m_py_obj != nullptr;
|
|
}
|
|
|
|
bool
|
|
PythonObject::IsAllocated() const
|
|
{
|
|
return IsValid() && !IsNone();
|
|
}
|
|
|
|
StructuredData::ObjectSP
|
|
PythonObject::CreateStructuredObject() const
|
|
{
|
|
switch (GetObjectType())
|
|
{
|
|
case PyObjectType::Dictionary:
|
|
return PythonDictionary(PyRefType::Borrowed, m_py_obj).CreateStructuredDictionary();
|
|
case PyObjectType::Integer:
|
|
return PythonInteger(PyRefType::Borrowed, m_py_obj).CreateStructuredInteger();
|
|
case PyObjectType::List:
|
|
return PythonList(PyRefType::Borrowed, m_py_obj).CreateStructuredArray();
|
|
case PyObjectType::String:
|
|
return PythonString(PyRefType::Borrowed, m_py_obj).CreateStructuredString();
|
|
case PyObjectType::Bytes:
|
|
return PythonBytes(PyRefType::Borrowed, m_py_obj).CreateStructuredString();
|
|
case PyObjectType::ByteArray:
|
|
return PythonByteArray(PyRefType::Borrowed, m_py_obj).CreateStructuredString();
|
|
case PyObjectType::None:
|
|
return StructuredData::ObjectSP();
|
|
default:
|
|
return StructuredData::ObjectSP(new StructuredPythonObject(m_py_obj));
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// PythonString
|
|
//----------------------------------------------------------------------
|
|
PythonBytes::PythonBytes() : PythonObject()
|
|
{
|
|
}
|
|
|
|
PythonBytes::PythonBytes(llvm::ArrayRef<uint8_t> bytes) : PythonObject()
|
|
{
|
|
SetBytes(bytes);
|
|
}
|
|
|
|
PythonBytes::PythonBytes(const uint8_t *bytes, size_t length) : PythonObject()
|
|
{
|
|
SetBytes(llvm::ArrayRef<uint8_t>(bytes, length));
|
|
}
|
|
|
|
PythonBytes::PythonBytes(PyRefType type, PyObject *py_obj) : PythonObject()
|
|
{
|
|
Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a string
|
|
}
|
|
|
|
PythonBytes::PythonBytes(const PythonBytes &object) : PythonObject(object)
|
|
{
|
|
}
|
|
|
|
PythonBytes::~PythonBytes()
|
|
{
|
|
}
|
|
|
|
bool
|
|
PythonBytes::Check(PyObject *py_obj)
|
|
{
|
|
if (!py_obj)
|
|
return false;
|
|
if (PyBytes_Check(py_obj))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
void
|
|
PythonBytes::Reset(PyRefType type, PyObject *py_obj)
|
|
{
|
|
// Grab the desired reference type so that if we end up rejecting
|
|
// `py_obj` it still gets decremented if necessary.
|
|
PythonObject result(type, py_obj);
|
|
|
|
if (!PythonBytes::Check(py_obj))
|
|
{
|
|
PythonObject::Reset();
|
|
return;
|
|
}
|
|
|
|
// Calling PythonObject::Reset(const PythonObject&) will lead to stack overflow since it calls
|
|
// back into the virtual implementation.
|
|
PythonObject::Reset(PyRefType::Borrowed, result.get());
|
|
}
|
|
|
|
llvm::ArrayRef<uint8_t>
|
|
PythonBytes::GetBytes() const
|
|
{
|
|
if (!IsValid())
|
|
return llvm::ArrayRef<uint8_t>();
|
|
|
|
Py_ssize_t size;
|
|
char *c;
|
|
|
|
PyBytes_AsStringAndSize(m_py_obj, &c, &size);
|
|
return llvm::ArrayRef<uint8_t>(reinterpret_cast<uint8_t *>(c), size);
|
|
}
|
|
|
|
size_t
|
|
PythonBytes::GetSize() const
|
|
{
|
|
if (!IsValid())
|
|
return 0;
|
|
return PyBytes_Size(m_py_obj);
|
|
}
|
|
|
|
void
|
|
PythonBytes::SetBytes(llvm::ArrayRef<uint8_t> bytes)
|
|
{
|
|
const char *data = reinterpret_cast<const char *>(bytes.data());
|
|
PyObject *py_bytes = PyBytes_FromStringAndSize(data, bytes.size());
|
|
PythonObject::Reset(PyRefType::Owned, py_bytes);
|
|
}
|
|
|
|
StructuredData::StringSP
|
|
PythonBytes::CreateStructuredString() const
|
|
{
|
|
StructuredData::StringSP result(new StructuredData::String);
|
|
Py_ssize_t size;
|
|
char *c;
|
|
PyBytes_AsStringAndSize(m_py_obj, &c, &size);
|
|
result->SetValue(std::string(c, size));
|
|
return result;
|
|
}
|
|
|
|
PythonByteArray::PythonByteArray(llvm::ArrayRef<uint8_t> bytes) : PythonByteArray(bytes.data(), bytes.size())
|
|
{
|
|
}
|
|
|
|
PythonByteArray::PythonByteArray(const uint8_t *bytes, size_t length)
|
|
{
|
|
const char *str = reinterpret_cast<const char *>(bytes);
|
|
Reset(PyRefType::Owned, PyByteArray_FromStringAndSize(str, length));
|
|
}
|
|
|
|
PythonByteArray::PythonByteArray(PyRefType type, PyObject *o)
|
|
{
|
|
Reset(type, o);
|
|
}
|
|
|
|
PythonByteArray::PythonByteArray(const PythonBytes &object) : PythonObject(object)
|
|
{
|
|
}
|
|
|
|
PythonByteArray::~PythonByteArray()
|
|
{
|
|
}
|
|
|
|
bool
|
|
PythonByteArray::Check(PyObject *py_obj)
|
|
{
|
|
if (!py_obj)
|
|
return false;
|
|
if (PyByteArray_Check(py_obj))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
void
|
|
PythonByteArray::Reset(PyRefType type, PyObject *py_obj)
|
|
{
|
|
// Grab the desired reference type so that if we end up rejecting
|
|
// `py_obj` it still gets decremented if necessary.
|
|
PythonObject result(type, py_obj);
|
|
|
|
if (!PythonByteArray::Check(py_obj))
|
|
{
|
|
PythonObject::Reset();
|
|
return;
|
|
}
|
|
|
|
// Calling PythonObject::Reset(const PythonObject&) will lead to stack overflow since it calls
|
|
// back into the virtual implementation.
|
|
PythonObject::Reset(PyRefType::Borrowed, result.get());
|
|
}
|
|
|
|
llvm::ArrayRef<uint8_t>
|
|
PythonByteArray::GetBytes() const
|
|
{
|
|
if (!IsValid())
|
|
return llvm::ArrayRef<uint8_t>();
|
|
|
|
char *c = PyByteArray_AsString(m_py_obj);
|
|
size_t size = GetSize();
|
|
return llvm::ArrayRef<uint8_t>(reinterpret_cast<uint8_t *>(c), size);
|
|
}
|
|
|
|
size_t
|
|
PythonByteArray::GetSize() const
|
|
{
|
|
if (!IsValid())
|
|
return 0;
|
|
|
|
return PyByteArray_Size(m_py_obj);
|
|
}
|
|
|
|
StructuredData::StringSP
|
|
PythonByteArray::CreateStructuredString() const
|
|
{
|
|
StructuredData::StringSP result(new StructuredData::String);
|
|
llvm::ArrayRef<uint8_t> bytes = GetBytes();
|
|
const char *str = reinterpret_cast<const char *>(bytes.data());
|
|
result->SetValue(std::string(str, bytes.size()));
|
|
return result;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// PythonString
|
|
//----------------------------------------------------------------------
|
|
|
|
PythonString::PythonString(PyRefType type, PyObject *py_obj)
|
|
: PythonObject()
|
|
{
|
|
Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a string
|
|
}
|
|
|
|
PythonString::PythonString(const PythonString &object)
|
|
: PythonObject(object)
|
|
{
|
|
}
|
|
|
|
PythonString::PythonString(llvm::StringRef string)
|
|
: PythonObject()
|
|
{
|
|
SetString(string);
|
|
}
|
|
|
|
PythonString::PythonString(const char *string)
|
|
: PythonObject()
|
|
{
|
|
SetString(llvm::StringRef(string));
|
|
}
|
|
|
|
PythonString::PythonString()
|
|
: PythonObject()
|
|
{
|
|
}
|
|
|
|
PythonString::~PythonString ()
|
|
{
|
|
}
|
|
|
|
bool
|
|
PythonString::Check(PyObject *py_obj)
|
|
{
|
|
if (!py_obj)
|
|
return false;
|
|
|
|
if (PyUnicode_Check(py_obj))
|
|
return true;
|
|
#if PY_MAJOR_VERSION < 3
|
|
if (PyString_Check(py_obj))
|
|
return true;
|
|
#endif
|
|
return false;
|
|
}
|
|
|
|
void
|
|
PythonString::Reset(PyRefType type, PyObject *py_obj)
|
|
{
|
|
// Grab the desired reference type so that if we end up rejecting
|
|
// `py_obj` it still gets decremented if necessary.
|
|
PythonObject result(type, py_obj);
|
|
|
|
if (!PythonString::Check(py_obj))
|
|
{
|
|
PythonObject::Reset();
|
|
return;
|
|
}
|
|
#if PY_MAJOR_VERSION < 3
|
|
// In Python 2, Don't store PyUnicode objects directly, because we need
|
|
// access to their underlying character buffers which Python 2 doesn't
|
|
// provide.
|
|
if (PyUnicode_Check(py_obj))
|
|
result.Reset(PyRefType::Owned, PyUnicode_AsUTF8String(result.get()));
|
|
#endif
|
|
// Calling PythonObject::Reset(const PythonObject&) will lead to stack overflow since it calls
|
|
// back into the virtual implementation.
|
|
PythonObject::Reset(PyRefType::Borrowed, result.get());
|
|
}
|
|
|
|
llvm::StringRef
|
|
PythonString::GetString() const
|
|
{
|
|
if (!IsValid())
|
|
return llvm::StringRef();
|
|
|
|
Py_ssize_t size;
|
|
char *c;
|
|
|
|
#if PY_MAJOR_VERSION >= 3
|
|
c = PyUnicode_AsUTF8AndSize(m_py_obj, &size);
|
|
#else
|
|
PyString_AsStringAndSize(m_py_obj, &c, &size);
|
|
#endif
|
|
return llvm::StringRef(c, size);
|
|
}
|
|
|
|
size_t
|
|
PythonString::GetSize() const
|
|
{
|
|
if (IsValid())
|
|
{
|
|
#if PY_MAJOR_VERSION >= 3
|
|
return PyUnicode_GetSize(m_py_obj);
|
|
#else
|
|
return PyString_Size(m_py_obj);
|
|
#endif
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
PythonString::SetString (llvm::StringRef string)
|
|
{
|
|
#if PY_MAJOR_VERSION >= 3
|
|
PyObject *unicode = PyUnicode_FromStringAndSize(string.data(), string.size());
|
|
PythonObject::Reset(PyRefType::Owned, unicode);
|
|
#else
|
|
PyObject *str = PyString_FromStringAndSize(string.data(), string.size());
|
|
PythonObject::Reset(PyRefType::Owned, str);
|
|
#endif
|
|
}
|
|
|
|
StructuredData::StringSP
|
|
PythonString::CreateStructuredString() const
|
|
{
|
|
StructuredData::StringSP result(new StructuredData::String);
|
|
result->SetValue(GetString());
|
|
return result;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// PythonInteger
|
|
//----------------------------------------------------------------------
|
|
|
|
PythonInteger::PythonInteger()
|
|
: PythonObject()
|
|
{
|
|
|
|
}
|
|
|
|
PythonInteger::PythonInteger(PyRefType type, PyObject *py_obj)
|
|
: PythonObject()
|
|
{
|
|
Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a integer type
|
|
}
|
|
|
|
PythonInteger::PythonInteger(const PythonInteger &object)
|
|
: PythonObject(object)
|
|
{
|
|
}
|
|
|
|
PythonInteger::PythonInteger(int64_t value)
|
|
: PythonObject()
|
|
{
|
|
SetInteger(value);
|
|
}
|
|
|
|
|
|
PythonInteger::~PythonInteger ()
|
|
{
|
|
}
|
|
|
|
bool
|
|
PythonInteger::Check(PyObject *py_obj)
|
|
{
|
|
if (!py_obj)
|
|
return false;
|
|
|
|
#if PY_MAJOR_VERSION >= 3
|
|
// Python 3 does not have PyInt_Check. There is only one type of
|
|
// integral value, long.
|
|
return PyLong_Check(py_obj);
|
|
#else
|
|
return PyLong_Check(py_obj) || PyInt_Check(py_obj);
|
|
#endif
|
|
}
|
|
|
|
void
|
|
PythonInteger::Reset(PyRefType type, PyObject *py_obj)
|
|
{
|
|
// Grab the desired reference type so that if we end up rejecting
|
|
// `py_obj` it still gets decremented if necessary.
|
|
PythonObject result(type, py_obj);
|
|
|
|
if (!PythonInteger::Check(py_obj))
|
|
{
|
|
PythonObject::Reset();
|
|
return;
|
|
}
|
|
|
|
#if PY_MAJOR_VERSION < 3
|
|
// Always store this as a PyLong, which makes interoperability between
|
|
// Python 2.x and Python 3.x easier. This is only necessary in 2.x,
|
|
// since 3.x doesn't even have a PyInt.
|
|
if (PyInt_Check(py_obj))
|
|
{
|
|
// Since we converted the original object to a different type, the new
|
|
// object is an owned object regardless of the ownership semantics requested
|
|
// by the user.
|
|
result.Reset(PyRefType::Owned, PyLong_FromLongLong(PyInt_AsLong(py_obj)));
|
|
}
|
|
#endif
|
|
|
|
assert(PyLong_Check(result.get()) && "Couldn't get a PyLong from this PyObject");
|
|
|
|
// Calling PythonObject::Reset(const PythonObject&) will lead to stack overflow since it calls
|
|
// back into the virtual implementation.
|
|
PythonObject::Reset(PyRefType::Borrowed, result.get());
|
|
}
|
|
|
|
int64_t
|
|
PythonInteger::GetInteger() const
|
|
{
|
|
if (m_py_obj)
|
|
{
|
|
assert(PyLong_Check(m_py_obj) && "PythonInteger::GetInteger has a PyObject that isn't a PyLong");
|
|
|
|
return PyLong_AsLongLong(m_py_obj);
|
|
}
|
|
return UINT64_MAX;
|
|
}
|
|
|
|
void
|
|
PythonInteger::SetInteger(int64_t value)
|
|
{
|
|
PythonObject::Reset(PyRefType::Owned, PyLong_FromLongLong(value));
|
|
}
|
|
|
|
StructuredData::IntegerSP
|
|
PythonInteger::CreateStructuredInteger() const
|
|
{
|
|
StructuredData::IntegerSP result(new StructuredData::Integer);
|
|
result->SetValue(GetInteger());
|
|
return result;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// PythonList
|
|
//----------------------------------------------------------------------
|
|
|
|
PythonList::PythonList(PyInitialValue value)
|
|
: PythonObject()
|
|
{
|
|
if (value == PyInitialValue::Empty)
|
|
Reset(PyRefType::Owned, PyList_New(0));
|
|
}
|
|
|
|
PythonList::PythonList(int list_size)
|
|
: PythonObject()
|
|
{
|
|
Reset(PyRefType::Owned, PyList_New(list_size));
|
|
}
|
|
|
|
PythonList::PythonList(PyRefType type, PyObject *py_obj)
|
|
: PythonObject()
|
|
{
|
|
Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a list
|
|
}
|
|
|
|
PythonList::PythonList(const PythonList &list)
|
|
: PythonObject(list)
|
|
{
|
|
}
|
|
|
|
PythonList::~PythonList ()
|
|
{
|
|
}
|
|
|
|
bool
|
|
PythonList::Check(PyObject *py_obj)
|
|
{
|
|
if (!py_obj)
|
|
return false;
|
|
return PyList_Check(py_obj);
|
|
}
|
|
|
|
void
|
|
PythonList::Reset(PyRefType type, PyObject *py_obj)
|
|
{
|
|
// Grab the desired reference type so that if we end up rejecting
|
|
// `py_obj` it still gets decremented if necessary.
|
|
PythonObject result(type, py_obj);
|
|
|
|
if (!PythonList::Check(py_obj))
|
|
{
|
|
PythonObject::Reset();
|
|
return;
|
|
}
|
|
|
|
// Calling PythonObject::Reset(const PythonObject&) will lead to stack overflow since it calls
|
|
// back into the virtual implementation.
|
|
PythonObject::Reset(PyRefType::Borrowed, result.get());
|
|
}
|
|
|
|
uint32_t
|
|
PythonList::GetSize() const
|
|
{
|
|
if (IsValid())
|
|
return PyList_GET_SIZE(m_py_obj);
|
|
return 0;
|
|
}
|
|
|
|
PythonObject
|
|
PythonList::GetItemAtIndex(uint32_t index) const
|
|
{
|
|
if (IsValid())
|
|
return PythonObject(PyRefType::Borrowed, PyList_GetItem(m_py_obj, index));
|
|
return PythonObject();
|
|
}
|
|
|
|
void
|
|
PythonList::SetItemAtIndex(uint32_t index, const PythonObject &object)
|
|
{
|
|
if (IsAllocated() && object.IsValid())
|
|
{
|
|
// PyList_SetItem is documented to "steal" a reference, so we need to
|
|
// convert it to an owned reference by incrementing it.
|
|
Py_INCREF(object.get());
|
|
PyList_SetItem(m_py_obj, index, object.get());
|
|
}
|
|
}
|
|
|
|
void
|
|
PythonList::AppendItem(const PythonObject &object)
|
|
{
|
|
if (IsAllocated() && object.IsValid())
|
|
{
|
|
// `PyList_Append` does *not* steal a reference, so do not call `Py_INCREF`
|
|
// here like we do with `PyList_SetItem`.
|
|
PyList_Append(m_py_obj, object.get());
|
|
}
|
|
}
|
|
|
|
StructuredData::ArraySP
|
|
PythonList::CreateStructuredArray() const
|
|
{
|
|
StructuredData::ArraySP result(new StructuredData::Array);
|
|
uint32_t count = GetSize();
|
|
for (uint32_t i = 0; i < count; ++i)
|
|
{
|
|
PythonObject obj = GetItemAtIndex(i);
|
|
result->AddItem(obj.CreateStructuredObject());
|
|
}
|
|
return result;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// PythonTuple
|
|
//----------------------------------------------------------------------
|
|
|
|
PythonTuple::PythonTuple(PyInitialValue value)
|
|
: PythonObject()
|
|
{
|
|
if (value == PyInitialValue::Empty)
|
|
Reset(PyRefType::Owned, PyTuple_New(0));
|
|
}
|
|
|
|
PythonTuple::PythonTuple(int tuple_size)
|
|
: PythonObject()
|
|
{
|
|
Reset(PyRefType::Owned, PyTuple_New(tuple_size));
|
|
}
|
|
|
|
PythonTuple::PythonTuple(PyRefType type, PyObject *py_obj)
|
|
: PythonObject()
|
|
{
|
|
Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a tuple
|
|
}
|
|
|
|
PythonTuple::PythonTuple(const PythonTuple &tuple)
|
|
: PythonObject(tuple)
|
|
{
|
|
}
|
|
|
|
PythonTuple::PythonTuple(std::initializer_list<PythonObject> objects)
|
|
{
|
|
m_py_obj = PyTuple_New(objects.size());
|
|
|
|
uint32_t idx = 0;
|
|
for (auto object : objects)
|
|
{
|
|
if (object.IsValid())
|
|
SetItemAtIndex(idx, object);
|
|
idx++;
|
|
}
|
|
}
|
|
|
|
PythonTuple::PythonTuple(std::initializer_list<PyObject*> objects)
|
|
{
|
|
m_py_obj = PyTuple_New(objects.size());
|
|
|
|
uint32_t idx = 0;
|
|
for (auto py_object : objects)
|
|
{
|
|
PythonObject object(PyRefType::Borrowed, py_object);
|
|
if (object.IsValid())
|
|
SetItemAtIndex(idx, object);
|
|
idx++;
|
|
}
|
|
}
|
|
|
|
PythonTuple::~PythonTuple()
|
|
{
|
|
}
|
|
|
|
bool
|
|
PythonTuple::Check(PyObject *py_obj)
|
|
{
|
|
if (!py_obj)
|
|
return false;
|
|
return PyTuple_Check(py_obj);
|
|
}
|
|
|
|
void
|
|
PythonTuple::Reset(PyRefType type, PyObject *py_obj)
|
|
{
|
|
// Grab the desired reference type so that if we end up rejecting
|
|
// `py_obj` it still gets decremented if necessary.
|
|
PythonObject result(type, py_obj);
|
|
|
|
if (!PythonTuple::Check(py_obj))
|
|
{
|
|
PythonObject::Reset();
|
|
return;
|
|
}
|
|
|
|
// Calling PythonObject::Reset(const PythonObject&) will lead to stack overflow since it calls
|
|
// back into the virtual implementation.
|
|
PythonObject::Reset(PyRefType::Borrowed, result.get());
|
|
}
|
|
|
|
uint32_t
|
|
PythonTuple::GetSize() const
|
|
{
|
|
if (IsValid())
|
|
return PyTuple_GET_SIZE(m_py_obj);
|
|
return 0;
|
|
}
|
|
|
|
PythonObject
|
|
PythonTuple::GetItemAtIndex(uint32_t index) const
|
|
{
|
|
if (IsValid())
|
|
return PythonObject(PyRefType::Borrowed, PyTuple_GetItem(m_py_obj, index));
|
|
return PythonObject();
|
|
}
|
|
|
|
void
|
|
PythonTuple::SetItemAtIndex(uint32_t index, const PythonObject &object)
|
|
{
|
|
if (IsAllocated() && object.IsValid())
|
|
{
|
|
// PyTuple_SetItem is documented to "steal" a reference, so we need to
|
|
// convert it to an owned reference by incrementing it.
|
|
Py_INCREF(object.get());
|
|
PyTuple_SetItem(m_py_obj, index, object.get());
|
|
}
|
|
}
|
|
|
|
StructuredData::ArraySP
|
|
PythonTuple::CreateStructuredArray() const
|
|
{
|
|
StructuredData::ArraySP result(new StructuredData::Array);
|
|
uint32_t count = GetSize();
|
|
for (uint32_t i = 0; i < count; ++i)
|
|
{
|
|
PythonObject obj = GetItemAtIndex(i);
|
|
result->AddItem(obj.CreateStructuredObject());
|
|
}
|
|
return result;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// PythonDictionary
|
|
//----------------------------------------------------------------------
|
|
|
|
PythonDictionary::PythonDictionary(PyInitialValue value)
|
|
: PythonObject()
|
|
{
|
|
if (value == PyInitialValue::Empty)
|
|
Reset(PyRefType::Owned, PyDict_New());
|
|
}
|
|
|
|
PythonDictionary::PythonDictionary(PyRefType type, PyObject *py_obj)
|
|
: PythonObject()
|
|
{
|
|
Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a dictionary
|
|
}
|
|
|
|
PythonDictionary::PythonDictionary(const PythonDictionary &object)
|
|
: PythonObject(object)
|
|
{
|
|
}
|
|
|
|
PythonDictionary::~PythonDictionary ()
|
|
{
|
|
}
|
|
|
|
bool
|
|
PythonDictionary::Check(PyObject *py_obj)
|
|
{
|
|
if (!py_obj)
|
|
return false;
|
|
|
|
return PyDict_Check(py_obj);
|
|
}
|
|
|
|
void
|
|
PythonDictionary::Reset(PyRefType type, PyObject *py_obj)
|
|
{
|
|
// Grab the desired reference type so that if we end up rejecting
|
|
// `py_obj` it still gets decremented if necessary.
|
|
PythonObject result(type, py_obj);
|
|
|
|
if (!PythonDictionary::Check(py_obj))
|
|
{
|
|
PythonObject::Reset();
|
|
return;
|
|
}
|
|
|
|
// Calling PythonObject::Reset(const PythonObject&) will lead to stack overflow since it calls
|
|
// back into the virtual implementation.
|
|
PythonObject::Reset(PyRefType::Borrowed, result.get());
|
|
}
|
|
|
|
uint32_t
|
|
PythonDictionary::GetSize() const
|
|
{
|
|
if (IsValid())
|
|
return PyDict_Size(m_py_obj);
|
|
return 0;
|
|
}
|
|
|
|
PythonList
|
|
PythonDictionary::GetKeys() const
|
|
{
|
|
if (IsValid())
|
|
return PythonList(PyRefType::Owned, PyDict_Keys(m_py_obj));
|
|
return PythonList(PyInitialValue::Invalid);
|
|
}
|
|
|
|
PythonObject
|
|
PythonDictionary::GetItemForKey(const PythonObject &key) const
|
|
{
|
|
if (IsAllocated() && key.IsValid())
|
|
return PythonObject(PyRefType::Borrowed, PyDict_GetItem(m_py_obj, key.get()));
|
|
return PythonObject();
|
|
}
|
|
|
|
void
|
|
PythonDictionary::SetItemForKey(const PythonObject &key, const PythonObject &value)
|
|
{
|
|
if (IsAllocated() && key.IsValid() && value.IsValid())
|
|
PyDict_SetItem(m_py_obj, key.get(), value.get());
|
|
}
|
|
|
|
StructuredData::DictionarySP
|
|
PythonDictionary::CreateStructuredDictionary() const
|
|
{
|
|
StructuredData::DictionarySP result(new StructuredData::Dictionary);
|
|
PythonList keys(GetKeys());
|
|
uint32_t num_keys = keys.GetSize();
|
|
for (uint32_t i = 0; i < num_keys; ++i)
|
|
{
|
|
PythonObject key = keys.GetItemAtIndex(i);
|
|
PythonObject value = GetItemForKey(key);
|
|
StructuredData::ObjectSP structured_value = value.CreateStructuredObject();
|
|
result->AddItem(key.Str().GetString(), structured_value);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
PythonModule::PythonModule() : PythonObject()
|
|
{
|
|
}
|
|
|
|
PythonModule::PythonModule(PyRefType type, PyObject *py_obj)
|
|
{
|
|
Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a module
|
|
}
|
|
|
|
PythonModule::PythonModule(const PythonModule &dict) : PythonObject(dict)
|
|
{
|
|
}
|
|
|
|
PythonModule::~PythonModule()
|
|
{
|
|
}
|
|
|
|
PythonModule
|
|
PythonModule::BuiltinsModule()
|
|
{
|
|
#if PY_MAJOR_VERSION >= 3
|
|
return AddModule("builtins");
|
|
#else
|
|
return AddModule("__builtin__");
|
|
#endif
|
|
}
|
|
|
|
PythonModule
|
|
PythonModule::MainModule()
|
|
{
|
|
return AddModule("__main__");
|
|
}
|
|
|
|
PythonModule
|
|
PythonModule::AddModule(llvm::StringRef module)
|
|
{
|
|
std::string str = module.str();
|
|
return PythonModule(PyRefType::Borrowed, PyImport_AddModule(str.c_str()));
|
|
}
|
|
|
|
|
|
PythonModule
|
|
PythonModule::ImportModule(llvm::StringRef module)
|
|
{
|
|
std::string str = module.str();
|
|
return PythonModule(PyRefType::Owned, PyImport_ImportModule(str.c_str()));
|
|
}
|
|
|
|
bool
|
|
PythonModule::Check(PyObject *py_obj)
|
|
{
|
|
if (!py_obj)
|
|
return false;
|
|
|
|
return PyModule_Check(py_obj);
|
|
}
|
|
|
|
void
|
|
PythonModule::Reset(PyRefType type, PyObject *py_obj)
|
|
{
|
|
// Grab the desired reference type so that if we end up rejecting
|
|
// `py_obj` it still gets decremented if necessary.
|
|
PythonObject result(type, py_obj);
|
|
|
|
if (!PythonModule::Check(py_obj))
|
|
{
|
|
PythonObject::Reset();
|
|
return;
|
|
}
|
|
|
|
// Calling PythonObject::Reset(const PythonObject&) will lead to stack overflow since it calls
|
|
// back into the virtual implementation.
|
|
PythonObject::Reset(PyRefType::Borrowed, result.get());
|
|
}
|
|
|
|
PythonDictionary
|
|
PythonModule::GetDictionary() const
|
|
{
|
|
return PythonDictionary(PyRefType::Borrowed, PyModule_GetDict(m_py_obj));
|
|
}
|
|
|
|
PythonCallable::PythonCallable() : PythonObject()
|
|
{
|
|
}
|
|
|
|
PythonCallable::PythonCallable(PyRefType type, PyObject *py_obj)
|
|
{
|
|
Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a callable
|
|
}
|
|
|
|
PythonCallable::PythonCallable(const PythonCallable &callable)
|
|
: PythonObject(callable)
|
|
{
|
|
}
|
|
|
|
PythonCallable::~PythonCallable()
|
|
{
|
|
}
|
|
|
|
bool
|
|
PythonCallable::Check(PyObject *py_obj)
|
|
{
|
|
if (!py_obj)
|
|
return false;
|
|
|
|
return PyCallable_Check(py_obj);
|
|
}
|
|
|
|
void
|
|
PythonCallable::Reset(PyRefType type, PyObject *py_obj)
|
|
{
|
|
// Grab the desired reference type so that if we end up rejecting
|
|
// `py_obj` it still gets decremented if necessary.
|
|
PythonObject result(type, py_obj);
|
|
|
|
if (!PythonCallable::Check(py_obj))
|
|
{
|
|
PythonObject::Reset();
|
|
return;
|
|
}
|
|
|
|
// Calling PythonObject::Reset(const PythonObject&) will lead to stack overflow since it calls
|
|
// back into the virtual implementation.
|
|
PythonObject::Reset(PyRefType::Borrowed, result.get());
|
|
}
|
|
|
|
|
|
PythonCallable::ArgInfo
|
|
PythonCallable::GetNumArguments() const
|
|
{
|
|
ArgInfo result = { 0, false, false };
|
|
if (!IsValid())
|
|
return result;
|
|
|
|
PyObject *py_func_obj = m_py_obj;
|
|
if (PyMethod_Check(py_func_obj))
|
|
py_func_obj = PyMethod_GET_FUNCTION(py_func_obj);
|
|
|
|
if (!py_func_obj)
|
|
return result;
|
|
|
|
PyCodeObject* code = (PyCodeObject*)PyFunction_GET_CODE(py_func_obj);
|
|
if (!code)
|
|
return result;
|
|
|
|
result.count = code->co_argcount;
|
|
result.has_varargs = !!(code->co_flags & CO_VARARGS);
|
|
result.has_kwargs = !!(code->co_flags & CO_VARKEYWORDS);
|
|
return result;
|
|
}
|
|
|
|
PythonObject
|
|
PythonCallable::operator ()()
|
|
{
|
|
return PythonObject(PyRefType::Owned,
|
|
PyObject_CallObject(m_py_obj, nullptr));
|
|
}
|
|
|
|
PythonObject
|
|
PythonCallable::operator ()(std::initializer_list<PyObject*> args)
|
|
{
|
|
PythonTuple arg_tuple(args);
|
|
return PythonObject(PyRefType::Owned,
|
|
PyObject_CallObject(m_py_obj, arg_tuple.get()));
|
|
}
|
|
|
|
PythonObject
|
|
PythonCallable::operator ()(std::initializer_list<PythonObject> args)
|
|
{
|
|
PythonTuple arg_tuple(args);
|
|
return PythonObject(PyRefType::Owned,
|
|
PyObject_CallObject(m_py_obj, arg_tuple.get()));
|
|
}
|
|
|
|
PythonFile::PythonFile()
|
|
: PythonObject()
|
|
{
|
|
}
|
|
|
|
PythonFile::PythonFile(File &file, const char *mode)
|
|
{
|
|
Reset(file, mode);
|
|
}
|
|
|
|
PythonFile::PythonFile(const char *path, const char *mode)
|
|
{
|
|
lldb_private::File file(path, GetOptionsFromMode(mode));
|
|
Reset(file, mode);
|
|
}
|
|
|
|
PythonFile::PythonFile(PyRefType type, PyObject *o)
|
|
{
|
|
Reset(type, o);
|
|
}
|
|
|
|
PythonFile::~PythonFile()
|
|
{
|
|
}
|
|
|
|
bool
|
|
PythonFile::Check(PyObject *py_obj)
|
|
{
|
|
#if PY_MAJOR_VERSION < 3
|
|
return PyFile_Check(py_obj);
|
|
#else
|
|
// In Python 3, there is no `PyFile_Check`, and in fact PyFile is not even a
|
|
// first-class object type anymore. `PyFile_FromFd` is just a thin wrapper
|
|
// over `io.open()`, which returns some object derived from `io.IOBase`.
|
|
// As a result, the only way to detect a file in Python 3 is to check whether
|
|
// it inherits from `io.IOBase`. Since it is possible for non-files to also
|
|
// inherit from `io.IOBase`, we additionally verify that it has the `fileno`
|
|
// attribute, which should guarantee that it is backed by the file system.
|
|
PythonObject io_module(PyRefType::Owned, PyImport_ImportModule("io"));
|
|
PythonDictionary io_dict(PyRefType::Borrowed, PyModule_GetDict(io_module.get()));
|
|
PythonObject io_base_class = io_dict.GetItemForKey(PythonString("IOBase"));
|
|
|
|
PythonObject object_type(PyRefType::Owned, PyObject_Type(py_obj));
|
|
|
|
if (1 != PyObject_IsSubclass(object_type.get(), io_base_class.get()))
|
|
return false;
|
|
if (!object_type.HasAttribute("fileno"))
|
|
return false;
|
|
|
|
return true;
|
|
#endif
|
|
}
|
|
|
|
void
|
|
PythonFile::Reset(PyRefType type, PyObject *py_obj)
|
|
{
|
|
// Grab the desired reference type so that if we end up rejecting
|
|
// `py_obj` it still gets decremented if necessary.
|
|
PythonObject result(type, py_obj);
|
|
|
|
if (!PythonFile::Check(py_obj))
|
|
{
|
|
PythonObject::Reset();
|
|
return;
|
|
}
|
|
|
|
// Calling PythonObject::Reset(const PythonObject&) will lead to stack
|
|
// overflow since it calls back into the virtual implementation.
|
|
PythonObject::Reset(PyRefType::Borrowed, result.get());
|
|
}
|
|
|
|
void
|
|
PythonFile::Reset(File &file, const char *mode)
|
|
{
|
|
if (!file.IsValid())
|
|
{
|
|
Reset();
|
|
return;
|
|
}
|
|
|
|
char *cmode = const_cast<char *>(mode);
|
|
#if PY_MAJOR_VERSION >= 3
|
|
Reset(PyRefType::Owned,
|
|
PyFile_FromFd(file.GetDescriptor(), nullptr, cmode, -1, nullptr, "ignore", nullptr, 0));
|
|
#else
|
|
// Read through the Python source, doesn't seem to modify these strings
|
|
Reset(PyRefType::Owned,
|
|
PyFile_FromFile(file.GetStream(), const_cast<char *>(""), cmode, nullptr));
|
|
#endif
|
|
}
|
|
|
|
uint32_t
|
|
PythonFile::GetOptionsFromMode(llvm::StringRef mode)
|
|
{
|
|
if (mode.empty())
|
|
return 0;
|
|
|
|
return llvm::StringSwitch<uint32_t>(mode.str().c_str())
|
|
.Case("r", File::eOpenOptionRead)
|
|
.Case("w", File::eOpenOptionWrite)
|
|
.Case("a", File::eOpenOptionAppend|File::eOpenOptionCanCreate)
|
|
.Case("r+", File::eOpenOptionRead|File::eOpenOptionWrite)
|
|
.Case("w+", File::eOpenOptionRead|File::eOpenOptionWrite|File::eOpenOptionCanCreate|File::eOpenOptionTruncate)
|
|
.Case("a+", File::eOpenOptionRead|File::eOpenOptionWrite|File::eOpenOptionCanCreate)
|
|
.Default(0);
|
|
}
|
|
|
|
bool
|
|
PythonFile::GetUnderlyingFile(File &file) const
|
|
{
|
|
if (!IsValid())
|
|
return false;
|
|
|
|
file.Close();
|
|
// We don't own the file descriptor returned by this function, make sure the
|
|
// File object knows about that.
|
|
file.SetDescriptor(PyObject_AsFileDescriptor(m_py_obj), false);
|
|
PythonString py_mode = GetAttributeValue("mode").AsType<PythonString>();
|
|
file.SetOptions(PythonFile::GetOptionsFromMode(py_mode.GetString()));
|
|
return file.IsValid();
|
|
}
|
|
|
|
|
|
#endif
|