diff options
Diffstat (limited to 'source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp')
| -rw-r--r-- | source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp | 1069 |
1 files changed, 1069 insertions, 0 deletions
diff --git a/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp b/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp new file mode 100644 index 0000000000000..3107677ee9480 --- /dev/null +++ b/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp @@ -0,0 +1,1069 @@ +//===-- 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/Interpreter/ScriptInterpreter.h" + +#include <stdio.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 (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::None: + return StructuredData::ObjectSP(); + default: + return StructuredData::ObjectSP(new StructuredPythonObject(m_py_obj)); + } +} + +//---------------------------------------------------------------------- +// 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) +{ + FILE *fp = nullptr; + fp = fopen(path, mode); + lldb_private::File file(fp, true); + 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 +} + +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); + return file.IsValid(); +} + + +#endif |