diff options
Diffstat (limited to 'contrib/llvm/tools/lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp')
| -rw-r--r-- | contrib/llvm/tools/lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp | 1052 |
1 files changed, 0 insertions, 1052 deletions
diff --git a/contrib/llvm/tools/lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp b/contrib/llvm/tools/lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp deleted file mode 100644 index 29dd037efd86..000000000000 --- a/contrib/llvm/tools/lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp +++ /dev/null @@ -1,1052 +0,0 @@ -//===-- PythonDataObjects.cpp -----------------------------------*- C++ -*-===// -// -// 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 -// -//===----------------------------------------------------------------------===// - -#ifdef LLDB_DISABLE_PYTHON - -// Python is disabled in this build - -#else - -#include "PythonDataObjects.h" -#include "ScriptInterpreterPython.h" - -#include "lldb/Host/File.h" -#include "lldb/Host/FileSystem.h" -#include "lldb/Interpreter/ScriptInterpreter.h" -#include "lldb/Utility/Stream.h" - -#include "llvm/ADT/StringSwitch.h" -#include "llvm/Support/ConvertUTF.h" -#include "llvm/Support/Errno.h" - -#include <stdio.h> - -using namespace lldb_private; -using namespace lldb; - -void StructuredPythonObject::Dump(Stream &s, bool pretty_print) const { - s << "Python Obj: 0x" << GetValue(); -} - -// PythonObject - -void PythonObject::Dump(Stream &strm) const { - if (m_py_obj) { - FILE *file = llvm::sys::RetryAfterSignal(nullptr, ::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 (PythonBoolean::Check(m_py_obj)) - return PyObjectType::Boolean; - 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('.'); - 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('.'); - 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::Boolean: - return PythonBoolean(PyRefType::Borrowed, m_py_obj) - .CreateStructuredBoolean(); - 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() {} - -bool PythonBytes::Check(PyObject *py_obj) { - if (!py_obj) - return false; - return PyBytes_Check(py_obj); -} - -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; - return PyByteArray_Check(py_obj); -} - -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(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; - const char *data; - -#if PY_MAJOR_VERSION >= 3 - data = PyUnicode_AsUTF8AndSize(m_py_obj, &size); -#else - char *c; - PyString_AsStringAndSize(m_py_obj, &c, &size); - data = c; -#endif - return llvm::StringRef(data, 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(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"); - - int overflow = 0; - int64_t result = PyLong_AsLongLongAndOverflow(m_py_obj, &overflow); - if (overflow != 0) { - // We got an integer that overflows, like 18446744072853913392L we can't - // use PyLong_AsLongLong() as it will return 0xffffffffffffffff. If we - // use the unsigned long long it will work as expected. - const uint64_t uval = PyLong_AsUnsignedLongLong(m_py_obj); - result = static_cast<int64_t>(uval); - } - return result; - } - 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; -} - -// PythonBoolean - -PythonBoolean::PythonBoolean(PyRefType type, PyObject *py_obj) - : PythonObject() { - Reset(type, py_obj); // Use "Reset()" to ensure that py_obj is a boolean type -} - -PythonBoolean::PythonBoolean(bool value) { - SetValue(value); -} - -bool PythonBoolean::Check(PyObject *py_obj) { - return py_obj ? PyBool_Check(py_obj) : false; -} - -void PythonBoolean::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 (!PythonBoolean::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()); -} - -bool PythonBoolean::GetValue() const { - return m_py_obj ? PyObject_IsTrue(m_py_obj) : false; -} - -void PythonBoolean::SetValue(bool value) { - PythonObject::Reset(PyRefType::Owned, PyBool_FromLong(value)); -} - -StructuredData::BooleanSP PythonBoolean::CreateStructuredBoolean() const { - StructuredData::BooleanSP result(new StructuredData::Boolean); - result->SetValue(GetValue()); - 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() {} - -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(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() {} - -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() {} - -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() {} - -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, 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); - PythonObject im_self = GetAttributeValue("im_self"); - if (im_self.IsValid() && !im_self.IsNone()) - result.is_bound_method = true; - } else { - // see if this is a callable object with an __call__ method - if (!PyFunction_Check(py_func_obj)) { - PythonObject __call__ = GetAttributeValue("__call__"); - if (__call__.IsValid()) { - auto __callable__ = __call__.AsType<PythonCallable>(); - if (__callable__.IsValid()) { - py_func_obj = PyMethod_GET_FUNCTION(__callable__.get()); - PythonObject im_self = GetAttributeValue("im_self"); - if (im_self.IsValid() && !im_self.IsNone()) - result.is_bound_method = true; - } - } - } - } - - 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; - FileSystem::Instance().Open(file, FileSpec(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()) - .Case("r", File::eOpenOptionRead) - .Case("w", File::eOpenOptionWrite) - .Case("a", File::eOpenOptionWrite | 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::eOpenOptionAppend | 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 |