xref: /freebsd-src/contrib/llvm-project/lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp (revision 480093f4440d54b30b3025afeac24b48f2ba7a2e)
10b57cec5SDimitry Andric //===-- PythonDataObjects.cpp -----------------------------------*- C++ -*-===//
20b57cec5SDimitry Andric //
30b57cec5SDimitry Andric // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
40b57cec5SDimitry Andric // See https://llvm.org/LICENSE.txt for license information.
50b57cec5SDimitry Andric // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
60b57cec5SDimitry Andric //
70b57cec5SDimitry Andric //===----------------------------------------------------------------------===//
80b57cec5SDimitry Andric 
9*480093f4SDimitry Andric #include "lldb/Host/Config.h"
100b57cec5SDimitry Andric 
11*480093f4SDimitry Andric #if LLDB_ENABLE_PYTHON
120b57cec5SDimitry Andric 
130b57cec5SDimitry Andric #include "PythonDataObjects.h"
140b57cec5SDimitry Andric #include "ScriptInterpreterPython.h"
150b57cec5SDimitry Andric 
160b57cec5SDimitry Andric #include "lldb/Host/File.h"
170b57cec5SDimitry Andric #include "lldb/Host/FileSystem.h"
180b57cec5SDimitry Andric #include "lldb/Interpreter/ScriptInterpreter.h"
199dba64beSDimitry Andric #include "lldb/Utility/Log.h"
200b57cec5SDimitry Andric #include "lldb/Utility/Stream.h"
210b57cec5SDimitry Andric 
220b57cec5SDimitry Andric #include "llvm/ADT/StringSwitch.h"
239dba64beSDimitry Andric #include "llvm/Support/Casting.h"
240b57cec5SDimitry Andric #include "llvm/Support/ConvertUTF.h"
250b57cec5SDimitry Andric #include "llvm/Support/Errno.h"
260b57cec5SDimitry Andric 
270b57cec5SDimitry Andric #include <stdio.h>
280b57cec5SDimitry Andric 
290b57cec5SDimitry Andric using namespace lldb_private;
300b57cec5SDimitry Andric using namespace lldb;
319dba64beSDimitry Andric using namespace lldb_private::python;
329dba64beSDimitry Andric using llvm::cantFail;
339dba64beSDimitry Andric using llvm::Error;
349dba64beSDimitry Andric using llvm::Expected;
359dba64beSDimitry Andric using llvm::Twine;
360b57cec5SDimitry Andric 
379dba64beSDimitry Andric template <> Expected<bool> python::As<bool>(Expected<PythonObject> &&obj) {
389dba64beSDimitry Andric   if (!obj)
399dba64beSDimitry Andric     return obj.takeError();
409dba64beSDimitry Andric   return obj.get().IsTrue();
419dba64beSDimitry Andric }
429dba64beSDimitry Andric 
439dba64beSDimitry Andric template <>
449dba64beSDimitry Andric Expected<long long> python::As<long long>(Expected<PythonObject> &&obj) {
459dba64beSDimitry Andric   if (!obj)
469dba64beSDimitry Andric     return obj.takeError();
479dba64beSDimitry Andric   return obj.get().AsLongLong();
489dba64beSDimitry Andric }
499dba64beSDimitry Andric 
509dba64beSDimitry Andric template <>
519dba64beSDimitry Andric Expected<std::string> python::As<std::string>(Expected<PythonObject> &&obj) {
529dba64beSDimitry Andric   if (!obj)
539dba64beSDimitry Andric     return obj.takeError();
549dba64beSDimitry Andric   PyObject *str_obj = PyObject_Str(obj.get().get());
559dba64beSDimitry Andric   if (!obj)
569dba64beSDimitry Andric     return llvm::make_error<PythonException>();
579dba64beSDimitry Andric   auto str = Take<PythonString>(str_obj);
589dba64beSDimitry Andric   auto utf8 = str.AsUTF8();
599dba64beSDimitry Andric   if (!utf8)
609dba64beSDimitry Andric     return utf8.takeError();
619dba64beSDimitry Andric   return utf8.get();
629dba64beSDimitry Andric }
639dba64beSDimitry Andric 
649dba64beSDimitry Andric void StructuredPythonObject::Serialize(llvm::json::OStream &s) const {
659dba64beSDimitry Andric   s.value(llvm::formatv("Python Obj: {0:X}", GetValue()).str());
660b57cec5SDimitry Andric }
670b57cec5SDimitry Andric 
680b57cec5SDimitry Andric // PythonObject
690b57cec5SDimitry Andric 
700b57cec5SDimitry Andric void PythonObject::Dump(Stream &strm) const {
710b57cec5SDimitry Andric   if (m_py_obj) {
720b57cec5SDimitry Andric     FILE *file = llvm::sys::RetryAfterSignal(nullptr, ::tmpfile);
730b57cec5SDimitry Andric     if (file) {
740b57cec5SDimitry Andric       ::PyObject_Print(m_py_obj, file, 0);
750b57cec5SDimitry Andric       const long length = ftell(file);
760b57cec5SDimitry Andric       if (length) {
770b57cec5SDimitry Andric         ::rewind(file);
780b57cec5SDimitry Andric         std::vector<char> file_contents(length, '\0');
790b57cec5SDimitry Andric         const size_t length_read =
800b57cec5SDimitry Andric             ::fread(file_contents.data(), 1, file_contents.size(), file);
810b57cec5SDimitry Andric         if (length_read > 0)
820b57cec5SDimitry Andric           strm.Write(file_contents.data(), length_read);
830b57cec5SDimitry Andric       }
840b57cec5SDimitry Andric       ::fclose(file);
850b57cec5SDimitry Andric     }
860b57cec5SDimitry Andric   } else
870b57cec5SDimitry Andric     strm.PutCString("NULL");
880b57cec5SDimitry Andric }
890b57cec5SDimitry Andric 
900b57cec5SDimitry Andric PyObjectType PythonObject::GetObjectType() const {
910b57cec5SDimitry Andric   if (!IsAllocated())
920b57cec5SDimitry Andric     return PyObjectType::None;
930b57cec5SDimitry Andric 
940b57cec5SDimitry Andric   if (PythonModule::Check(m_py_obj))
950b57cec5SDimitry Andric     return PyObjectType::Module;
960b57cec5SDimitry Andric   if (PythonList::Check(m_py_obj))
970b57cec5SDimitry Andric     return PyObjectType::List;
980b57cec5SDimitry Andric   if (PythonTuple::Check(m_py_obj))
990b57cec5SDimitry Andric     return PyObjectType::Tuple;
1000b57cec5SDimitry Andric   if (PythonDictionary::Check(m_py_obj))
1010b57cec5SDimitry Andric     return PyObjectType::Dictionary;
1020b57cec5SDimitry Andric   if (PythonString::Check(m_py_obj))
1030b57cec5SDimitry Andric     return PyObjectType::String;
1040b57cec5SDimitry Andric #if PY_MAJOR_VERSION >= 3
1050b57cec5SDimitry Andric   if (PythonBytes::Check(m_py_obj))
1060b57cec5SDimitry Andric     return PyObjectType::Bytes;
1070b57cec5SDimitry Andric #endif
1080b57cec5SDimitry Andric   if (PythonByteArray::Check(m_py_obj))
1090b57cec5SDimitry Andric     return PyObjectType::ByteArray;
1100b57cec5SDimitry Andric   if (PythonBoolean::Check(m_py_obj))
1110b57cec5SDimitry Andric     return PyObjectType::Boolean;
1120b57cec5SDimitry Andric   if (PythonInteger::Check(m_py_obj))
1130b57cec5SDimitry Andric     return PyObjectType::Integer;
1140b57cec5SDimitry Andric   if (PythonFile::Check(m_py_obj))
1150b57cec5SDimitry Andric     return PyObjectType::File;
1160b57cec5SDimitry Andric   if (PythonCallable::Check(m_py_obj))
1170b57cec5SDimitry Andric     return PyObjectType::Callable;
1180b57cec5SDimitry Andric   return PyObjectType::Unknown;
1190b57cec5SDimitry Andric }
1200b57cec5SDimitry Andric 
1210b57cec5SDimitry Andric PythonString PythonObject::Repr() const {
1220b57cec5SDimitry Andric   if (!m_py_obj)
1230b57cec5SDimitry Andric     return PythonString();
1240b57cec5SDimitry Andric   PyObject *repr = PyObject_Repr(m_py_obj);
1250b57cec5SDimitry Andric   if (!repr)
1260b57cec5SDimitry Andric     return PythonString();
1270b57cec5SDimitry Andric   return PythonString(PyRefType::Owned, repr);
1280b57cec5SDimitry Andric }
1290b57cec5SDimitry Andric 
1300b57cec5SDimitry Andric PythonString PythonObject::Str() const {
1310b57cec5SDimitry Andric   if (!m_py_obj)
1320b57cec5SDimitry Andric     return PythonString();
1330b57cec5SDimitry Andric   PyObject *str = PyObject_Str(m_py_obj);
1340b57cec5SDimitry Andric   if (!str)
1350b57cec5SDimitry Andric     return PythonString();
1360b57cec5SDimitry Andric   return PythonString(PyRefType::Owned, str);
1370b57cec5SDimitry Andric }
1380b57cec5SDimitry Andric 
1390b57cec5SDimitry Andric PythonObject
1400b57cec5SDimitry Andric PythonObject::ResolveNameWithDictionary(llvm::StringRef name,
1410b57cec5SDimitry Andric                                         const PythonDictionary &dict) {
1420b57cec5SDimitry Andric   size_t dot_pos = name.find('.');
1430b57cec5SDimitry Andric   llvm::StringRef piece = name.substr(0, dot_pos);
1440b57cec5SDimitry Andric   PythonObject result = dict.GetItemForKey(PythonString(piece));
1450b57cec5SDimitry Andric   if (dot_pos == llvm::StringRef::npos) {
1460b57cec5SDimitry Andric     // There was no dot, we're done.
1470b57cec5SDimitry Andric     return result;
1480b57cec5SDimitry Andric   }
1490b57cec5SDimitry Andric 
1500b57cec5SDimitry Andric   // There was a dot.  The remaining portion of the name should be looked up in
1510b57cec5SDimitry Andric   // the context of the object that was found in the dictionary.
1520b57cec5SDimitry Andric   return result.ResolveName(name.substr(dot_pos + 1));
1530b57cec5SDimitry Andric }
1540b57cec5SDimitry Andric 
1550b57cec5SDimitry Andric PythonObject PythonObject::ResolveName(llvm::StringRef name) const {
1560b57cec5SDimitry Andric   // Resolve the name in the context of the specified object.  If, for example,
1570b57cec5SDimitry Andric   // `this` refers to a PyModule, then this will look for `name` in this
1580b57cec5SDimitry Andric   // module.  If `this` refers to a PyType, then it will resolve `name` as an
1590b57cec5SDimitry Andric   // attribute of that type.  If `this` refers to an instance of an object,
1600b57cec5SDimitry Andric   // then it will resolve `name` as the value of the specified field.
1610b57cec5SDimitry Andric   //
1620b57cec5SDimitry Andric   // This function handles dotted names so that, for example, if `m_py_obj`
1630b57cec5SDimitry Andric   // refers to the `sys` module, and `name` == "path.append", then it will find
1640b57cec5SDimitry Andric   // the function `sys.path.append`.
1650b57cec5SDimitry Andric 
1660b57cec5SDimitry Andric   size_t dot_pos = name.find('.');
1670b57cec5SDimitry Andric   if (dot_pos == llvm::StringRef::npos) {
1680b57cec5SDimitry Andric     // No dots in the name, we should be able to find the value immediately as
1690b57cec5SDimitry Andric     // an attribute of `m_py_obj`.
1700b57cec5SDimitry Andric     return GetAttributeValue(name);
1710b57cec5SDimitry Andric   }
1720b57cec5SDimitry Andric 
1730b57cec5SDimitry Andric   // Look up the first piece of the name, and resolve the rest as a child of
1740b57cec5SDimitry Andric   // that.
1750b57cec5SDimitry Andric   PythonObject parent = ResolveName(name.substr(0, dot_pos));
1760b57cec5SDimitry Andric   if (!parent.IsAllocated())
1770b57cec5SDimitry Andric     return PythonObject();
1780b57cec5SDimitry Andric 
1790b57cec5SDimitry Andric   // Tail recursion.. should be optimized by the compiler
1800b57cec5SDimitry Andric   return parent.ResolveName(name.substr(dot_pos + 1));
1810b57cec5SDimitry Andric }
1820b57cec5SDimitry Andric 
1830b57cec5SDimitry Andric bool PythonObject::HasAttribute(llvm::StringRef attr) const {
1840b57cec5SDimitry Andric   if (!IsValid())
1850b57cec5SDimitry Andric     return false;
1860b57cec5SDimitry Andric   PythonString py_attr(attr);
1870b57cec5SDimitry Andric   return !!PyObject_HasAttr(m_py_obj, py_attr.get());
1880b57cec5SDimitry Andric }
1890b57cec5SDimitry Andric 
1900b57cec5SDimitry Andric PythonObject PythonObject::GetAttributeValue(llvm::StringRef attr) const {
1910b57cec5SDimitry Andric   if (!IsValid())
1920b57cec5SDimitry Andric     return PythonObject();
1930b57cec5SDimitry Andric 
1940b57cec5SDimitry Andric   PythonString py_attr(attr);
1950b57cec5SDimitry Andric   if (!PyObject_HasAttr(m_py_obj, py_attr.get()))
1960b57cec5SDimitry Andric     return PythonObject();
1970b57cec5SDimitry Andric 
1980b57cec5SDimitry Andric   return PythonObject(PyRefType::Owned,
1990b57cec5SDimitry Andric                       PyObject_GetAttr(m_py_obj, py_attr.get()));
2000b57cec5SDimitry Andric }
2010b57cec5SDimitry Andric 
2020b57cec5SDimitry Andric StructuredData::ObjectSP PythonObject::CreateStructuredObject() const {
2030b57cec5SDimitry Andric   switch (GetObjectType()) {
2040b57cec5SDimitry Andric   case PyObjectType::Dictionary:
2050b57cec5SDimitry Andric     return PythonDictionary(PyRefType::Borrowed, m_py_obj)
2060b57cec5SDimitry Andric         .CreateStructuredDictionary();
2070b57cec5SDimitry Andric   case PyObjectType::Boolean:
2080b57cec5SDimitry Andric     return PythonBoolean(PyRefType::Borrowed, m_py_obj)
2090b57cec5SDimitry Andric         .CreateStructuredBoolean();
2100b57cec5SDimitry Andric   case PyObjectType::Integer:
2110b57cec5SDimitry Andric     return PythonInteger(PyRefType::Borrowed, m_py_obj)
2120b57cec5SDimitry Andric         .CreateStructuredInteger();
2130b57cec5SDimitry Andric   case PyObjectType::List:
2140b57cec5SDimitry Andric     return PythonList(PyRefType::Borrowed, m_py_obj).CreateStructuredArray();
2150b57cec5SDimitry Andric   case PyObjectType::String:
2160b57cec5SDimitry Andric     return PythonString(PyRefType::Borrowed, m_py_obj).CreateStructuredString();
2170b57cec5SDimitry Andric   case PyObjectType::Bytes:
2180b57cec5SDimitry Andric     return PythonBytes(PyRefType::Borrowed, m_py_obj).CreateStructuredString();
2190b57cec5SDimitry Andric   case PyObjectType::ByteArray:
2200b57cec5SDimitry Andric     return PythonByteArray(PyRefType::Borrowed, m_py_obj)
2210b57cec5SDimitry Andric         .CreateStructuredString();
2220b57cec5SDimitry Andric   case PyObjectType::None:
2230b57cec5SDimitry Andric     return StructuredData::ObjectSP();
2240b57cec5SDimitry Andric   default:
2250b57cec5SDimitry Andric     return StructuredData::ObjectSP(new StructuredPythonObject(m_py_obj));
2260b57cec5SDimitry Andric   }
2270b57cec5SDimitry Andric }
2280b57cec5SDimitry Andric 
2290b57cec5SDimitry Andric // PythonString
2300b57cec5SDimitry Andric 
2319dba64beSDimitry Andric PythonBytes::PythonBytes(llvm::ArrayRef<uint8_t> bytes) { SetBytes(bytes); }
2320b57cec5SDimitry Andric 
2339dba64beSDimitry Andric PythonBytes::PythonBytes(const uint8_t *bytes, size_t length) {
2340b57cec5SDimitry Andric   SetBytes(llvm::ArrayRef<uint8_t>(bytes, length));
2350b57cec5SDimitry Andric }
2360b57cec5SDimitry Andric 
2370b57cec5SDimitry Andric bool PythonBytes::Check(PyObject *py_obj) {
2380b57cec5SDimitry Andric   if (!py_obj)
2390b57cec5SDimitry Andric     return false;
2400b57cec5SDimitry Andric   return PyBytes_Check(py_obj);
2410b57cec5SDimitry Andric }
2420b57cec5SDimitry Andric 
2430b57cec5SDimitry Andric llvm::ArrayRef<uint8_t> PythonBytes::GetBytes() const {
2440b57cec5SDimitry Andric   if (!IsValid())
2450b57cec5SDimitry Andric     return llvm::ArrayRef<uint8_t>();
2460b57cec5SDimitry Andric 
2470b57cec5SDimitry Andric   Py_ssize_t size;
2480b57cec5SDimitry Andric   char *c;
2490b57cec5SDimitry Andric 
2500b57cec5SDimitry Andric   PyBytes_AsStringAndSize(m_py_obj, &c, &size);
2510b57cec5SDimitry Andric   return llvm::ArrayRef<uint8_t>(reinterpret_cast<uint8_t *>(c), size);
2520b57cec5SDimitry Andric }
2530b57cec5SDimitry Andric 
2540b57cec5SDimitry Andric size_t PythonBytes::GetSize() const {
2550b57cec5SDimitry Andric   if (!IsValid())
2560b57cec5SDimitry Andric     return 0;
2570b57cec5SDimitry Andric   return PyBytes_Size(m_py_obj);
2580b57cec5SDimitry Andric }
2590b57cec5SDimitry Andric 
2600b57cec5SDimitry Andric void PythonBytes::SetBytes(llvm::ArrayRef<uint8_t> bytes) {
2610b57cec5SDimitry Andric   const char *data = reinterpret_cast<const char *>(bytes.data());
2629dba64beSDimitry Andric   *this = Take<PythonBytes>(PyBytes_FromStringAndSize(data, bytes.size()));
2630b57cec5SDimitry Andric }
2640b57cec5SDimitry Andric 
2650b57cec5SDimitry Andric StructuredData::StringSP PythonBytes::CreateStructuredString() const {
2660b57cec5SDimitry Andric   StructuredData::StringSP result(new StructuredData::String);
2670b57cec5SDimitry Andric   Py_ssize_t size;
2680b57cec5SDimitry Andric   char *c;
2690b57cec5SDimitry Andric   PyBytes_AsStringAndSize(m_py_obj, &c, &size);
2700b57cec5SDimitry Andric   result->SetValue(std::string(c, size));
2710b57cec5SDimitry Andric   return result;
2720b57cec5SDimitry Andric }
2730b57cec5SDimitry Andric 
2740b57cec5SDimitry Andric PythonByteArray::PythonByteArray(llvm::ArrayRef<uint8_t> bytes)
2750b57cec5SDimitry Andric     : PythonByteArray(bytes.data(), bytes.size()) {}
2760b57cec5SDimitry Andric 
2770b57cec5SDimitry Andric PythonByteArray::PythonByteArray(const uint8_t *bytes, size_t length) {
2780b57cec5SDimitry Andric   const char *str = reinterpret_cast<const char *>(bytes);
2799dba64beSDimitry Andric   *this = Take<PythonByteArray>(PyByteArray_FromStringAndSize(str, length));
2800b57cec5SDimitry Andric }
2810b57cec5SDimitry Andric 
2820b57cec5SDimitry Andric bool PythonByteArray::Check(PyObject *py_obj) {
2830b57cec5SDimitry Andric   if (!py_obj)
2840b57cec5SDimitry Andric     return false;
2850b57cec5SDimitry Andric   return PyByteArray_Check(py_obj);
2860b57cec5SDimitry Andric }
2870b57cec5SDimitry Andric 
2880b57cec5SDimitry Andric llvm::ArrayRef<uint8_t> PythonByteArray::GetBytes() const {
2890b57cec5SDimitry Andric   if (!IsValid())
2900b57cec5SDimitry Andric     return llvm::ArrayRef<uint8_t>();
2910b57cec5SDimitry Andric 
2920b57cec5SDimitry Andric   char *c = PyByteArray_AsString(m_py_obj);
2930b57cec5SDimitry Andric   size_t size = GetSize();
2940b57cec5SDimitry Andric   return llvm::ArrayRef<uint8_t>(reinterpret_cast<uint8_t *>(c), size);
2950b57cec5SDimitry Andric }
2960b57cec5SDimitry Andric 
2970b57cec5SDimitry Andric size_t PythonByteArray::GetSize() const {
2980b57cec5SDimitry Andric   if (!IsValid())
2990b57cec5SDimitry Andric     return 0;
3000b57cec5SDimitry Andric 
3010b57cec5SDimitry Andric   return PyByteArray_Size(m_py_obj);
3020b57cec5SDimitry Andric }
3030b57cec5SDimitry Andric 
3040b57cec5SDimitry Andric StructuredData::StringSP PythonByteArray::CreateStructuredString() const {
3050b57cec5SDimitry Andric   StructuredData::StringSP result(new StructuredData::String);
3060b57cec5SDimitry Andric   llvm::ArrayRef<uint8_t> bytes = GetBytes();
3070b57cec5SDimitry Andric   const char *str = reinterpret_cast<const char *>(bytes.data());
3080b57cec5SDimitry Andric   result->SetValue(std::string(str, bytes.size()));
3090b57cec5SDimitry Andric   return result;
3100b57cec5SDimitry Andric }
3110b57cec5SDimitry Andric 
3120b57cec5SDimitry Andric // PythonString
3130b57cec5SDimitry Andric 
3149dba64beSDimitry Andric Expected<PythonString> PythonString::FromUTF8(llvm::StringRef string) {
3159dba64beSDimitry Andric #if PY_MAJOR_VERSION >= 3
3169dba64beSDimitry Andric   PyObject *str = PyUnicode_FromStringAndSize(string.data(), string.size());
3179dba64beSDimitry Andric #else
3189dba64beSDimitry Andric   PyObject *str = PyString_FromStringAndSize(string.data(), string.size());
3199dba64beSDimitry Andric #endif
3209dba64beSDimitry Andric   if (!str)
3219dba64beSDimitry Andric     return llvm::make_error<PythonException>();
3229dba64beSDimitry Andric   return Take<PythonString>(str);
3230b57cec5SDimitry Andric }
3240b57cec5SDimitry Andric 
3259dba64beSDimitry Andric PythonString::PythonString(llvm::StringRef string) { SetString(string); }
3260b57cec5SDimitry Andric 
3270b57cec5SDimitry Andric bool PythonString::Check(PyObject *py_obj) {
3280b57cec5SDimitry Andric   if (!py_obj)
3290b57cec5SDimitry Andric     return false;
3300b57cec5SDimitry Andric 
3310b57cec5SDimitry Andric   if (PyUnicode_Check(py_obj))
3320b57cec5SDimitry Andric     return true;
3330b57cec5SDimitry Andric #if PY_MAJOR_VERSION < 3
3340b57cec5SDimitry Andric   if (PyString_Check(py_obj))
3350b57cec5SDimitry Andric     return true;
3360b57cec5SDimitry Andric #endif
3370b57cec5SDimitry Andric   return false;
3380b57cec5SDimitry Andric }
3390b57cec5SDimitry Andric 
3409dba64beSDimitry Andric void PythonString::Convert(PyRefType &type, PyObject *&py_obj) {
3410b57cec5SDimitry Andric #if PY_MAJOR_VERSION < 3
3420b57cec5SDimitry Andric   // In Python 2, Don't store PyUnicode objects directly, because we need
3430b57cec5SDimitry Andric   // access to their underlying character buffers which Python 2 doesn't
3440b57cec5SDimitry Andric   // provide.
3459dba64beSDimitry Andric   if (PyUnicode_Check(py_obj)) {
3469dba64beSDimitry Andric     PyObject *s = PyUnicode_AsUTF8String(py_obj);
3479dba64beSDimitry Andric     if (s == nullptr) {
3489dba64beSDimitry Andric       PyErr_Clear();
3499dba64beSDimitry Andric       if (type == PyRefType::Owned)
3509dba64beSDimitry Andric         Py_DECREF(py_obj);
3519dba64beSDimitry Andric       return;
3529dba64beSDimitry Andric     }
3539dba64beSDimitry Andric     if (type == PyRefType::Owned)
3549dba64beSDimitry Andric       Py_DECREF(py_obj);
3559dba64beSDimitry Andric     else
3569dba64beSDimitry Andric       type = PyRefType::Owned;
3579dba64beSDimitry Andric     py_obj = s;
3589dba64beSDimitry Andric   }
3590b57cec5SDimitry Andric #endif
3600b57cec5SDimitry Andric }
3610b57cec5SDimitry Andric 
3620b57cec5SDimitry Andric llvm::StringRef PythonString::GetString() const {
3639dba64beSDimitry Andric   auto s = AsUTF8();
3649dba64beSDimitry Andric   if (!s) {
3659dba64beSDimitry Andric     llvm::consumeError(s.takeError());
3669dba64beSDimitry Andric     return llvm::StringRef("");
3679dba64beSDimitry Andric   }
3689dba64beSDimitry Andric   return s.get();
3699dba64beSDimitry Andric }
3709dba64beSDimitry Andric 
3719dba64beSDimitry Andric Expected<llvm::StringRef> PythonString::AsUTF8() const {
3720b57cec5SDimitry Andric   if (!IsValid())
3739dba64beSDimitry Andric     return nullDeref();
3740b57cec5SDimitry Andric 
3750b57cec5SDimitry Andric   Py_ssize_t size;
3760b57cec5SDimitry Andric   const char *data;
3770b57cec5SDimitry Andric 
3780b57cec5SDimitry Andric #if PY_MAJOR_VERSION >= 3
3790b57cec5SDimitry Andric   data = PyUnicode_AsUTF8AndSize(m_py_obj, &size);
3800b57cec5SDimitry Andric #else
3819dba64beSDimitry Andric   char *c = NULL;
3829dba64beSDimitry Andric   int r = PyString_AsStringAndSize(m_py_obj, &c, &size);
3839dba64beSDimitry Andric   if (r < 0)
3849dba64beSDimitry Andric     c = NULL;
3850b57cec5SDimitry Andric   data = c;
3860b57cec5SDimitry Andric #endif
3879dba64beSDimitry Andric 
3889dba64beSDimitry Andric   if (!data)
3899dba64beSDimitry Andric     return exception();
3909dba64beSDimitry Andric 
3910b57cec5SDimitry Andric   return llvm::StringRef(data, size);
3920b57cec5SDimitry Andric }
3930b57cec5SDimitry Andric 
3940b57cec5SDimitry Andric size_t PythonString::GetSize() const {
3950b57cec5SDimitry Andric   if (IsValid()) {
3960b57cec5SDimitry Andric #if PY_MAJOR_VERSION >= 3
3970b57cec5SDimitry Andric     return PyUnicode_GetSize(m_py_obj);
3980b57cec5SDimitry Andric #else
3990b57cec5SDimitry Andric     return PyString_Size(m_py_obj);
4000b57cec5SDimitry Andric #endif
4010b57cec5SDimitry Andric   }
4020b57cec5SDimitry Andric   return 0;
4030b57cec5SDimitry Andric }
4040b57cec5SDimitry Andric 
4050b57cec5SDimitry Andric void PythonString::SetString(llvm::StringRef string) {
4069dba64beSDimitry Andric   auto s = FromUTF8(string);
4079dba64beSDimitry Andric   if (!s) {
4089dba64beSDimitry Andric     llvm::consumeError(s.takeError());
4099dba64beSDimitry Andric     Reset();
4109dba64beSDimitry Andric   } else {
4119dba64beSDimitry Andric     *this = std::move(s.get());
4129dba64beSDimitry Andric   }
4130b57cec5SDimitry Andric }
4140b57cec5SDimitry Andric 
4150b57cec5SDimitry Andric StructuredData::StringSP PythonString::CreateStructuredString() const {
4160b57cec5SDimitry Andric   StructuredData::StringSP result(new StructuredData::String);
4170b57cec5SDimitry Andric   result->SetValue(GetString());
4180b57cec5SDimitry Andric   return result;
4190b57cec5SDimitry Andric }
4200b57cec5SDimitry Andric 
4210b57cec5SDimitry Andric // PythonInteger
4220b57cec5SDimitry Andric 
4239dba64beSDimitry Andric PythonInteger::PythonInteger(int64_t value) { SetInteger(value); }
4240b57cec5SDimitry Andric 
4250b57cec5SDimitry Andric bool PythonInteger::Check(PyObject *py_obj) {
4260b57cec5SDimitry Andric   if (!py_obj)
4270b57cec5SDimitry Andric     return false;
4280b57cec5SDimitry Andric 
4290b57cec5SDimitry Andric #if PY_MAJOR_VERSION >= 3
4300b57cec5SDimitry Andric   // Python 3 does not have PyInt_Check.  There is only one type of integral
4310b57cec5SDimitry Andric   // value, long.
4320b57cec5SDimitry Andric   return PyLong_Check(py_obj);
4330b57cec5SDimitry Andric #else
4340b57cec5SDimitry Andric   return PyLong_Check(py_obj) || PyInt_Check(py_obj);
4350b57cec5SDimitry Andric #endif
4360b57cec5SDimitry Andric }
4370b57cec5SDimitry Andric 
4389dba64beSDimitry Andric void PythonInteger::Convert(PyRefType &type, PyObject *&py_obj) {
4390b57cec5SDimitry Andric #if PY_MAJOR_VERSION < 3
4400b57cec5SDimitry Andric   // Always store this as a PyLong, which makes interoperability between Python
4410b57cec5SDimitry Andric   // 2.x and Python 3.x easier.  This is only necessary in 2.x, since 3.x
4420b57cec5SDimitry Andric   // doesn't even have a PyInt.
4430b57cec5SDimitry Andric   if (PyInt_Check(py_obj)) {
4440b57cec5SDimitry Andric     // Since we converted the original object to a different type, the new
4450b57cec5SDimitry Andric     // object is an owned object regardless of the ownership semantics
4460b57cec5SDimitry Andric     // requested by the user.
4479dba64beSDimitry Andric     long long value = PyInt_AsLong(py_obj);
4489dba64beSDimitry Andric     PyObject *l = nullptr;
4499dba64beSDimitry Andric     if (!PyErr_Occurred())
4509dba64beSDimitry Andric       l = PyLong_FromLongLong(value);
4519dba64beSDimitry Andric     if (l == nullptr) {
4529dba64beSDimitry Andric       PyErr_Clear();
4539dba64beSDimitry Andric       if (type == PyRefType::Owned)
4549dba64beSDimitry Andric         Py_DECREF(py_obj);
4559dba64beSDimitry Andric       return;
4569dba64beSDimitry Andric     }
4579dba64beSDimitry Andric     if (type == PyRefType::Owned)
4589dba64beSDimitry Andric       Py_DECREF(py_obj);
4599dba64beSDimitry Andric     else
4609dba64beSDimitry Andric       type = PyRefType::Owned;
4619dba64beSDimitry Andric     py_obj = l;
4620b57cec5SDimitry Andric   }
4630b57cec5SDimitry Andric #endif
4640b57cec5SDimitry Andric }
4650b57cec5SDimitry Andric 
4660b57cec5SDimitry Andric int64_t PythonInteger::GetInteger() const {
4670b57cec5SDimitry Andric   if (m_py_obj) {
4680b57cec5SDimitry Andric     assert(PyLong_Check(m_py_obj) &&
4690b57cec5SDimitry Andric            "PythonInteger::GetInteger has a PyObject that isn't a PyLong");
4700b57cec5SDimitry Andric 
4710b57cec5SDimitry Andric     int overflow = 0;
4720b57cec5SDimitry Andric     int64_t result = PyLong_AsLongLongAndOverflow(m_py_obj, &overflow);
4730b57cec5SDimitry Andric     if (overflow != 0) {
4740b57cec5SDimitry Andric       // We got an integer that overflows, like 18446744072853913392L we can't
4750b57cec5SDimitry Andric       // use PyLong_AsLongLong() as it will return 0xffffffffffffffff. If we
4760b57cec5SDimitry Andric       // use the unsigned long long it will work as expected.
4770b57cec5SDimitry Andric       const uint64_t uval = PyLong_AsUnsignedLongLong(m_py_obj);
4780b57cec5SDimitry Andric       result = static_cast<int64_t>(uval);
4790b57cec5SDimitry Andric     }
4800b57cec5SDimitry Andric     return result;
4810b57cec5SDimitry Andric   }
4820b57cec5SDimitry Andric   return UINT64_MAX;
4830b57cec5SDimitry Andric }
4840b57cec5SDimitry Andric 
4850b57cec5SDimitry Andric void PythonInteger::SetInteger(int64_t value) {
4869dba64beSDimitry Andric   *this = Take<PythonInteger>(PyLong_FromLongLong(value));
4870b57cec5SDimitry Andric }
4880b57cec5SDimitry Andric 
4890b57cec5SDimitry Andric StructuredData::IntegerSP PythonInteger::CreateStructuredInteger() const {
4900b57cec5SDimitry Andric   StructuredData::IntegerSP result(new StructuredData::Integer);
4910b57cec5SDimitry Andric   result->SetValue(GetInteger());
4920b57cec5SDimitry Andric   return result;
4930b57cec5SDimitry Andric }
4940b57cec5SDimitry Andric 
4950b57cec5SDimitry Andric // PythonBoolean
4960b57cec5SDimitry Andric 
4970b57cec5SDimitry Andric PythonBoolean::PythonBoolean(bool value) {
4980b57cec5SDimitry Andric   SetValue(value);
4990b57cec5SDimitry Andric }
5000b57cec5SDimitry Andric 
5010b57cec5SDimitry Andric bool PythonBoolean::Check(PyObject *py_obj) {
5020b57cec5SDimitry Andric   return py_obj ? PyBool_Check(py_obj) : false;
5030b57cec5SDimitry Andric }
5040b57cec5SDimitry Andric 
5050b57cec5SDimitry Andric bool PythonBoolean::GetValue() const {
5060b57cec5SDimitry Andric   return m_py_obj ? PyObject_IsTrue(m_py_obj) : false;
5070b57cec5SDimitry Andric }
5080b57cec5SDimitry Andric 
5090b57cec5SDimitry Andric void PythonBoolean::SetValue(bool value) {
5109dba64beSDimitry Andric   *this = Take<PythonBoolean>(PyBool_FromLong(value));
5110b57cec5SDimitry Andric }
5120b57cec5SDimitry Andric 
5130b57cec5SDimitry Andric StructuredData::BooleanSP PythonBoolean::CreateStructuredBoolean() const {
5140b57cec5SDimitry Andric   StructuredData::BooleanSP result(new StructuredData::Boolean);
5150b57cec5SDimitry Andric   result->SetValue(GetValue());
5160b57cec5SDimitry Andric   return result;
5170b57cec5SDimitry Andric }
5180b57cec5SDimitry Andric 
5190b57cec5SDimitry Andric // PythonList
5200b57cec5SDimitry Andric 
5219dba64beSDimitry Andric PythonList::PythonList(PyInitialValue value) {
5220b57cec5SDimitry Andric   if (value == PyInitialValue::Empty)
5239dba64beSDimitry Andric     *this = Take<PythonList>(PyList_New(0));
5240b57cec5SDimitry Andric }
5250b57cec5SDimitry Andric 
5269dba64beSDimitry Andric PythonList::PythonList(int list_size) {
5279dba64beSDimitry Andric   *this = Take<PythonList>(PyList_New(list_size));
5280b57cec5SDimitry Andric }
5290b57cec5SDimitry Andric 
5300b57cec5SDimitry Andric bool PythonList::Check(PyObject *py_obj) {
5310b57cec5SDimitry Andric   if (!py_obj)
5320b57cec5SDimitry Andric     return false;
5330b57cec5SDimitry Andric   return PyList_Check(py_obj);
5340b57cec5SDimitry Andric }
5350b57cec5SDimitry Andric 
5360b57cec5SDimitry Andric uint32_t PythonList::GetSize() const {
5370b57cec5SDimitry Andric   if (IsValid())
5380b57cec5SDimitry Andric     return PyList_GET_SIZE(m_py_obj);
5390b57cec5SDimitry Andric   return 0;
5400b57cec5SDimitry Andric }
5410b57cec5SDimitry Andric 
5420b57cec5SDimitry Andric PythonObject PythonList::GetItemAtIndex(uint32_t index) const {
5430b57cec5SDimitry Andric   if (IsValid())
5440b57cec5SDimitry Andric     return PythonObject(PyRefType::Borrowed, PyList_GetItem(m_py_obj, index));
5450b57cec5SDimitry Andric   return PythonObject();
5460b57cec5SDimitry Andric }
5470b57cec5SDimitry Andric 
5480b57cec5SDimitry Andric void PythonList::SetItemAtIndex(uint32_t index, const PythonObject &object) {
5490b57cec5SDimitry Andric   if (IsAllocated() && object.IsValid()) {
5500b57cec5SDimitry Andric     // PyList_SetItem is documented to "steal" a reference, so we need to
5510b57cec5SDimitry Andric     // convert it to an owned reference by incrementing it.
5520b57cec5SDimitry Andric     Py_INCREF(object.get());
5530b57cec5SDimitry Andric     PyList_SetItem(m_py_obj, index, object.get());
5540b57cec5SDimitry Andric   }
5550b57cec5SDimitry Andric }
5560b57cec5SDimitry Andric 
5570b57cec5SDimitry Andric void PythonList::AppendItem(const PythonObject &object) {
5580b57cec5SDimitry Andric   if (IsAllocated() && object.IsValid()) {
5590b57cec5SDimitry Andric     // `PyList_Append` does *not* steal a reference, so do not call `Py_INCREF`
5600b57cec5SDimitry Andric     // here like we do with `PyList_SetItem`.
5610b57cec5SDimitry Andric     PyList_Append(m_py_obj, object.get());
5620b57cec5SDimitry Andric   }
5630b57cec5SDimitry Andric }
5640b57cec5SDimitry Andric 
5650b57cec5SDimitry Andric StructuredData::ArraySP PythonList::CreateStructuredArray() const {
5660b57cec5SDimitry Andric   StructuredData::ArraySP result(new StructuredData::Array);
5670b57cec5SDimitry Andric   uint32_t count = GetSize();
5680b57cec5SDimitry Andric   for (uint32_t i = 0; i < count; ++i) {
5690b57cec5SDimitry Andric     PythonObject obj = GetItemAtIndex(i);
5700b57cec5SDimitry Andric     result->AddItem(obj.CreateStructuredObject());
5710b57cec5SDimitry Andric   }
5720b57cec5SDimitry Andric   return result;
5730b57cec5SDimitry Andric }
5740b57cec5SDimitry Andric 
5750b57cec5SDimitry Andric // PythonTuple
5760b57cec5SDimitry Andric 
5779dba64beSDimitry Andric PythonTuple::PythonTuple(PyInitialValue value) {
5780b57cec5SDimitry Andric   if (value == PyInitialValue::Empty)
5799dba64beSDimitry Andric     *this = Take<PythonTuple>(PyTuple_New(0));
5800b57cec5SDimitry Andric }
5810b57cec5SDimitry Andric 
5829dba64beSDimitry Andric PythonTuple::PythonTuple(int tuple_size) {
5839dba64beSDimitry Andric   *this = Take<PythonTuple>(PyTuple_New(tuple_size));
5840b57cec5SDimitry Andric }
5850b57cec5SDimitry Andric 
5860b57cec5SDimitry Andric PythonTuple::PythonTuple(std::initializer_list<PythonObject> objects) {
5870b57cec5SDimitry Andric   m_py_obj = PyTuple_New(objects.size());
5880b57cec5SDimitry Andric 
5890b57cec5SDimitry Andric   uint32_t idx = 0;
5900b57cec5SDimitry Andric   for (auto object : objects) {
5910b57cec5SDimitry Andric     if (object.IsValid())
5920b57cec5SDimitry Andric       SetItemAtIndex(idx, object);
5930b57cec5SDimitry Andric     idx++;
5940b57cec5SDimitry Andric   }
5950b57cec5SDimitry Andric }
5960b57cec5SDimitry Andric 
5970b57cec5SDimitry Andric PythonTuple::PythonTuple(std::initializer_list<PyObject *> objects) {
5980b57cec5SDimitry Andric   m_py_obj = PyTuple_New(objects.size());
5990b57cec5SDimitry Andric 
6000b57cec5SDimitry Andric   uint32_t idx = 0;
6010b57cec5SDimitry Andric   for (auto py_object : objects) {
6020b57cec5SDimitry Andric     PythonObject object(PyRefType::Borrowed, py_object);
6030b57cec5SDimitry Andric     if (object.IsValid())
6040b57cec5SDimitry Andric       SetItemAtIndex(idx, object);
6050b57cec5SDimitry Andric     idx++;
6060b57cec5SDimitry Andric   }
6070b57cec5SDimitry Andric }
6080b57cec5SDimitry Andric 
6090b57cec5SDimitry Andric bool PythonTuple::Check(PyObject *py_obj) {
6100b57cec5SDimitry Andric   if (!py_obj)
6110b57cec5SDimitry Andric     return false;
6120b57cec5SDimitry Andric   return PyTuple_Check(py_obj);
6130b57cec5SDimitry Andric }
6140b57cec5SDimitry Andric 
6150b57cec5SDimitry Andric uint32_t PythonTuple::GetSize() const {
6160b57cec5SDimitry Andric   if (IsValid())
6170b57cec5SDimitry Andric     return PyTuple_GET_SIZE(m_py_obj);
6180b57cec5SDimitry Andric   return 0;
6190b57cec5SDimitry Andric }
6200b57cec5SDimitry Andric 
6210b57cec5SDimitry Andric PythonObject PythonTuple::GetItemAtIndex(uint32_t index) const {
6220b57cec5SDimitry Andric   if (IsValid())
6230b57cec5SDimitry Andric     return PythonObject(PyRefType::Borrowed, PyTuple_GetItem(m_py_obj, index));
6240b57cec5SDimitry Andric   return PythonObject();
6250b57cec5SDimitry Andric }
6260b57cec5SDimitry Andric 
6270b57cec5SDimitry Andric void PythonTuple::SetItemAtIndex(uint32_t index, const PythonObject &object) {
6280b57cec5SDimitry Andric   if (IsAllocated() && object.IsValid()) {
6290b57cec5SDimitry Andric     // PyTuple_SetItem is documented to "steal" a reference, so we need to
6300b57cec5SDimitry Andric     // convert it to an owned reference by incrementing it.
6310b57cec5SDimitry Andric     Py_INCREF(object.get());
6320b57cec5SDimitry Andric     PyTuple_SetItem(m_py_obj, index, object.get());
6330b57cec5SDimitry Andric   }
6340b57cec5SDimitry Andric }
6350b57cec5SDimitry Andric 
6360b57cec5SDimitry Andric StructuredData::ArraySP PythonTuple::CreateStructuredArray() const {
6370b57cec5SDimitry Andric   StructuredData::ArraySP result(new StructuredData::Array);
6380b57cec5SDimitry Andric   uint32_t count = GetSize();
6390b57cec5SDimitry Andric   for (uint32_t i = 0; i < count; ++i) {
6400b57cec5SDimitry Andric     PythonObject obj = GetItemAtIndex(i);
6410b57cec5SDimitry Andric     result->AddItem(obj.CreateStructuredObject());
6420b57cec5SDimitry Andric   }
6430b57cec5SDimitry Andric   return result;
6440b57cec5SDimitry Andric }
6450b57cec5SDimitry Andric 
6460b57cec5SDimitry Andric // PythonDictionary
6470b57cec5SDimitry Andric 
6489dba64beSDimitry Andric PythonDictionary::PythonDictionary(PyInitialValue value) {
6490b57cec5SDimitry Andric   if (value == PyInitialValue::Empty)
6509dba64beSDimitry Andric     *this = Take<PythonDictionary>(PyDict_New());
6510b57cec5SDimitry Andric }
6520b57cec5SDimitry Andric 
6530b57cec5SDimitry Andric bool PythonDictionary::Check(PyObject *py_obj) {
6540b57cec5SDimitry Andric   if (!py_obj)
6550b57cec5SDimitry Andric     return false;
6560b57cec5SDimitry Andric 
6570b57cec5SDimitry Andric   return PyDict_Check(py_obj);
6580b57cec5SDimitry Andric }
6590b57cec5SDimitry Andric 
6600b57cec5SDimitry Andric uint32_t PythonDictionary::GetSize() const {
6610b57cec5SDimitry Andric   if (IsValid())
6620b57cec5SDimitry Andric     return PyDict_Size(m_py_obj);
6630b57cec5SDimitry Andric   return 0;
6640b57cec5SDimitry Andric }
6650b57cec5SDimitry Andric 
6660b57cec5SDimitry Andric PythonList PythonDictionary::GetKeys() const {
6670b57cec5SDimitry Andric   if (IsValid())
6680b57cec5SDimitry Andric     return PythonList(PyRefType::Owned, PyDict_Keys(m_py_obj));
6690b57cec5SDimitry Andric   return PythonList(PyInitialValue::Invalid);
6700b57cec5SDimitry Andric }
6710b57cec5SDimitry Andric 
6720b57cec5SDimitry Andric PythonObject PythonDictionary::GetItemForKey(const PythonObject &key) const {
6739dba64beSDimitry Andric   auto item = GetItem(key);
6749dba64beSDimitry Andric   if (!item) {
6759dba64beSDimitry Andric     llvm::consumeError(item.takeError());
6760b57cec5SDimitry Andric     return PythonObject();
6770b57cec5SDimitry Andric   }
6789dba64beSDimitry Andric   return std::move(item.get());
6799dba64beSDimitry Andric }
6809dba64beSDimitry Andric 
6819dba64beSDimitry Andric Expected<PythonObject>
6829dba64beSDimitry Andric PythonDictionary::GetItem(const PythonObject &key) const {
6839dba64beSDimitry Andric   if (!IsValid())
6849dba64beSDimitry Andric     return nullDeref();
6859dba64beSDimitry Andric #if PY_MAJOR_VERSION >= 3
6869dba64beSDimitry Andric   PyObject *o = PyDict_GetItemWithError(m_py_obj, key.get());
6879dba64beSDimitry Andric   if (PyErr_Occurred())
6889dba64beSDimitry Andric     return exception();
6899dba64beSDimitry Andric #else
6909dba64beSDimitry Andric   PyObject *o = PyDict_GetItem(m_py_obj, key.get());
6919dba64beSDimitry Andric #endif
6929dba64beSDimitry Andric   if (!o)
6939dba64beSDimitry Andric     return keyError();
6949dba64beSDimitry Andric   return Retain<PythonObject>(o);
6959dba64beSDimitry Andric }
6969dba64beSDimitry Andric 
6979dba64beSDimitry Andric Expected<PythonObject> PythonDictionary::GetItem(const Twine &key) const {
6989dba64beSDimitry Andric   if (!IsValid())
6999dba64beSDimitry Andric     return nullDeref();
7009dba64beSDimitry Andric   PyObject *o = PyDict_GetItemString(m_py_obj, NullTerminated(key));
7019dba64beSDimitry Andric   if (PyErr_Occurred())
7029dba64beSDimitry Andric     return exception();
7039dba64beSDimitry Andric   if (!o)
7049dba64beSDimitry Andric     return keyError();
7059dba64beSDimitry Andric   return Retain<PythonObject>(o);
7069dba64beSDimitry Andric }
7079dba64beSDimitry Andric 
7089dba64beSDimitry Andric Error PythonDictionary::SetItem(const PythonObject &key,
7099dba64beSDimitry Andric                                 const PythonObject &value) const {
7109dba64beSDimitry Andric   if (!IsValid() || !value.IsValid())
7119dba64beSDimitry Andric     return nullDeref();
7129dba64beSDimitry Andric   int r = PyDict_SetItem(m_py_obj, key.get(), value.get());
7139dba64beSDimitry Andric   if (r < 0)
7149dba64beSDimitry Andric     return exception();
7159dba64beSDimitry Andric   return Error::success();
7169dba64beSDimitry Andric }
7179dba64beSDimitry Andric 
7189dba64beSDimitry Andric Error PythonDictionary::SetItem(const Twine &key,
7199dba64beSDimitry Andric                                 const PythonObject &value) const {
7209dba64beSDimitry Andric   if (!IsValid() || !value.IsValid())
7219dba64beSDimitry Andric     return nullDeref();
7229dba64beSDimitry Andric   int r = PyDict_SetItemString(m_py_obj, NullTerminated(key), value.get());
7239dba64beSDimitry Andric   if (r < 0)
7249dba64beSDimitry Andric     return exception();
7259dba64beSDimitry Andric   return Error::success();
7269dba64beSDimitry Andric }
7270b57cec5SDimitry Andric 
7280b57cec5SDimitry Andric void PythonDictionary::SetItemForKey(const PythonObject &key,
7290b57cec5SDimitry Andric                                      const PythonObject &value) {
7309dba64beSDimitry Andric   Error error = SetItem(key, value);
7319dba64beSDimitry Andric   if (error)
7329dba64beSDimitry Andric     llvm::consumeError(std::move(error));
7330b57cec5SDimitry Andric }
7340b57cec5SDimitry Andric 
7350b57cec5SDimitry Andric StructuredData::DictionarySP
7360b57cec5SDimitry Andric PythonDictionary::CreateStructuredDictionary() const {
7370b57cec5SDimitry Andric   StructuredData::DictionarySP result(new StructuredData::Dictionary);
7380b57cec5SDimitry Andric   PythonList keys(GetKeys());
7390b57cec5SDimitry Andric   uint32_t num_keys = keys.GetSize();
7400b57cec5SDimitry Andric   for (uint32_t i = 0; i < num_keys; ++i) {
7410b57cec5SDimitry Andric     PythonObject key = keys.GetItemAtIndex(i);
7420b57cec5SDimitry Andric     PythonObject value = GetItemForKey(key);
7430b57cec5SDimitry Andric     StructuredData::ObjectSP structured_value = value.CreateStructuredObject();
7440b57cec5SDimitry Andric     result->AddItem(key.Str().GetString(), structured_value);
7450b57cec5SDimitry Andric   }
7460b57cec5SDimitry Andric   return result;
7470b57cec5SDimitry Andric }
7480b57cec5SDimitry Andric 
7490b57cec5SDimitry Andric PythonModule PythonModule::BuiltinsModule() {
7500b57cec5SDimitry Andric #if PY_MAJOR_VERSION >= 3
7510b57cec5SDimitry Andric   return AddModule("builtins");
7520b57cec5SDimitry Andric #else
7530b57cec5SDimitry Andric   return AddModule("__builtin__");
7540b57cec5SDimitry Andric #endif
7550b57cec5SDimitry Andric }
7560b57cec5SDimitry Andric 
7570b57cec5SDimitry Andric PythonModule PythonModule::MainModule() { return AddModule("__main__"); }
7580b57cec5SDimitry Andric 
7590b57cec5SDimitry Andric PythonModule PythonModule::AddModule(llvm::StringRef module) {
7600b57cec5SDimitry Andric   std::string str = module.str();
7610b57cec5SDimitry Andric   return PythonModule(PyRefType::Borrowed, PyImport_AddModule(str.c_str()));
7620b57cec5SDimitry Andric }
7630b57cec5SDimitry Andric 
7649dba64beSDimitry Andric Expected<PythonModule> PythonModule::Import(const Twine &name) {
7659dba64beSDimitry Andric   PyObject *mod = PyImport_ImportModule(NullTerminated(name));
7669dba64beSDimitry Andric   if (!mod)
7679dba64beSDimitry Andric     return exception();
7689dba64beSDimitry Andric   return Take<PythonModule>(mod);
7699dba64beSDimitry Andric }
7709dba64beSDimitry Andric 
7719dba64beSDimitry Andric Expected<PythonObject> PythonModule::Get(const Twine &name) {
7729dba64beSDimitry Andric   if (!IsValid())
7739dba64beSDimitry Andric     return nullDeref();
7749dba64beSDimitry Andric   PyObject *dict = PyModule_GetDict(m_py_obj);
7759dba64beSDimitry Andric   if (!dict)
7769dba64beSDimitry Andric     return exception();
7779dba64beSDimitry Andric   PyObject *item = PyDict_GetItemString(dict, NullTerminated(name));
7789dba64beSDimitry Andric   if (!item)
7799dba64beSDimitry Andric     return exception();
7809dba64beSDimitry Andric   return Retain<PythonObject>(item);
7810b57cec5SDimitry Andric }
7820b57cec5SDimitry Andric 
7830b57cec5SDimitry Andric bool PythonModule::Check(PyObject *py_obj) {
7840b57cec5SDimitry Andric   if (!py_obj)
7850b57cec5SDimitry Andric     return false;
7860b57cec5SDimitry Andric 
7870b57cec5SDimitry Andric   return PyModule_Check(py_obj);
7880b57cec5SDimitry Andric }
7890b57cec5SDimitry Andric 
7900b57cec5SDimitry Andric PythonDictionary PythonModule::GetDictionary() const {
7919dba64beSDimitry Andric   if (!IsValid())
7929dba64beSDimitry Andric     return PythonDictionary();
7939dba64beSDimitry Andric   return Retain<PythonDictionary>(PyModule_GetDict(m_py_obj));
7940b57cec5SDimitry Andric }
7950b57cec5SDimitry Andric 
7960b57cec5SDimitry Andric bool PythonCallable::Check(PyObject *py_obj) {
7970b57cec5SDimitry Andric   if (!py_obj)
7980b57cec5SDimitry Andric     return false;
7990b57cec5SDimitry Andric 
8000b57cec5SDimitry Andric   return PyCallable_Check(py_obj);
8010b57cec5SDimitry Andric }
8020b57cec5SDimitry Andric 
8039dba64beSDimitry Andric #if PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 3
8049dba64beSDimitry Andric static const char get_arg_info_script[] = R"(
8059dba64beSDimitry Andric from inspect import signature, Parameter, ismethod
8069dba64beSDimitry Andric from collections import namedtuple
807*480093f4SDimitry Andric ArgInfo = namedtuple('ArgInfo', ['count', 'has_varargs'])
8089dba64beSDimitry Andric def main(f):
8099dba64beSDimitry Andric     count = 0
8109dba64beSDimitry Andric     varargs = False
8119dba64beSDimitry Andric     for parameter in signature(f).parameters.values():
8129dba64beSDimitry Andric         kind = parameter.kind
8139dba64beSDimitry Andric         if kind in (Parameter.POSITIONAL_ONLY,
8149dba64beSDimitry Andric                     Parameter.POSITIONAL_OR_KEYWORD):
8159dba64beSDimitry Andric             count += 1
8169dba64beSDimitry Andric         elif kind == Parameter.VAR_POSITIONAL:
8179dba64beSDimitry Andric             varargs = True
8189dba64beSDimitry Andric         elif kind in (Parameter.KEYWORD_ONLY,
8199dba64beSDimitry Andric                       Parameter.VAR_KEYWORD):
8209dba64beSDimitry Andric             pass
8219dba64beSDimitry Andric         else:
8229dba64beSDimitry Andric             raise Exception(f'unknown parameter kind: {kind}')
823*480093f4SDimitry Andric     return ArgInfo(count, varargs)
8249dba64beSDimitry Andric )";
8259dba64beSDimitry Andric #endif
8269dba64beSDimitry Andric 
8279dba64beSDimitry Andric Expected<PythonCallable::ArgInfo> PythonCallable::GetArgInfo() const {
8289dba64beSDimitry Andric   ArgInfo result = {};
8299dba64beSDimitry Andric   if (!IsValid())
8309dba64beSDimitry Andric     return nullDeref();
8319dba64beSDimitry Andric 
8329dba64beSDimitry Andric #if PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 3
8339dba64beSDimitry Andric 
8349dba64beSDimitry Andric   // no need to synchronize access to this global, we already have the GIL
8359dba64beSDimitry Andric   static PythonScript get_arg_info(get_arg_info_script);
8369dba64beSDimitry Andric   Expected<PythonObject> pyarginfo = get_arg_info(*this);
8379dba64beSDimitry Andric   if (!pyarginfo)
8389dba64beSDimitry Andric     return pyarginfo.takeError();
839*480093f4SDimitry Andric   long long count =
840*480093f4SDimitry Andric       cantFail(As<long long>(pyarginfo.get().GetAttribute("count")));
841*480093f4SDimitry Andric   bool has_varargs =
8429dba64beSDimitry Andric       cantFail(As<bool>(pyarginfo.get().GetAttribute("has_varargs")));
843*480093f4SDimitry Andric   result.max_positional_args = has_varargs ? ArgInfo::UNBOUNDED : count;
8449dba64beSDimitry Andric 
8459dba64beSDimitry Andric #else
846*480093f4SDimitry Andric   PyObject *py_func_obj;
8479dba64beSDimitry Andric   bool is_bound_method = false;
848*480093f4SDimitry Andric   bool is_class = false;
849*480093f4SDimitry Andric 
850*480093f4SDimitry Andric   if (PyType_Check(m_py_obj) || PyClass_Check(m_py_obj)) {
851*480093f4SDimitry Andric     auto init = GetAttribute("__init__");
852*480093f4SDimitry Andric     if (!init)
853*480093f4SDimitry Andric       return init.takeError();
854*480093f4SDimitry Andric     py_func_obj = init.get().get();
855*480093f4SDimitry Andric     is_class = true;
856*480093f4SDimitry Andric   } else {
857*480093f4SDimitry Andric     py_func_obj = m_py_obj;
858*480093f4SDimitry Andric   }
859*480093f4SDimitry Andric 
8600b57cec5SDimitry Andric   if (PyMethod_Check(py_func_obj)) {
8610b57cec5SDimitry Andric     py_func_obj = PyMethod_GET_FUNCTION(py_func_obj);
8620b57cec5SDimitry Andric     PythonObject im_self = GetAttributeValue("im_self");
8630b57cec5SDimitry Andric     if (im_self.IsValid() && !im_self.IsNone())
8649dba64beSDimitry Andric       is_bound_method = true;
8650b57cec5SDimitry Andric   } else {
8660b57cec5SDimitry Andric     // see if this is a callable object with an __call__ method
8670b57cec5SDimitry Andric     if (!PyFunction_Check(py_func_obj)) {
8680b57cec5SDimitry Andric       PythonObject __call__ = GetAttributeValue("__call__");
8690b57cec5SDimitry Andric       if (__call__.IsValid()) {
8700b57cec5SDimitry Andric         auto __callable__ = __call__.AsType<PythonCallable>();
8710b57cec5SDimitry Andric         if (__callable__.IsValid()) {
8720b57cec5SDimitry Andric           py_func_obj = PyMethod_GET_FUNCTION(__callable__.get());
8739dba64beSDimitry Andric           PythonObject im_self = __callable__.GetAttributeValue("im_self");
8740b57cec5SDimitry Andric           if (im_self.IsValid() && !im_self.IsNone())
8759dba64beSDimitry Andric             is_bound_method = true;
8760b57cec5SDimitry Andric         }
8770b57cec5SDimitry Andric       }
8780b57cec5SDimitry Andric     }
8790b57cec5SDimitry Andric   }
8800b57cec5SDimitry Andric 
8810b57cec5SDimitry Andric   if (!py_func_obj)
8820b57cec5SDimitry Andric     return result;
8830b57cec5SDimitry Andric 
8840b57cec5SDimitry Andric   PyCodeObject *code = (PyCodeObject *)PyFunction_GET_CODE(py_func_obj);
8850b57cec5SDimitry Andric   if (!code)
8860b57cec5SDimitry Andric     return result;
8870b57cec5SDimitry Andric 
888*480093f4SDimitry Andric   auto count = code->co_argcount;
889*480093f4SDimitry Andric   bool has_varargs = !!(code->co_flags & CO_VARARGS);
890*480093f4SDimitry Andric   result.max_positional_args =
891*480093f4SDimitry Andric       has_varargs ? ArgInfo::UNBOUNDED
892*480093f4SDimitry Andric                   : (count - (int)is_bound_method) - (int)is_class;
8939dba64beSDimitry Andric 
8949dba64beSDimitry Andric #endif
8959dba64beSDimitry Andric 
8960b57cec5SDimitry Andric   return result;
8970b57cec5SDimitry Andric }
8980b57cec5SDimitry Andric 
8999dba64beSDimitry Andric constexpr unsigned
9009dba64beSDimitry Andric     PythonCallable::ArgInfo::UNBOUNDED; // FIXME delete after c++17
9019dba64beSDimitry Andric 
9020b57cec5SDimitry Andric PythonObject PythonCallable::operator()() {
9030b57cec5SDimitry Andric   return PythonObject(PyRefType::Owned, PyObject_CallObject(m_py_obj, nullptr));
9040b57cec5SDimitry Andric }
9050b57cec5SDimitry Andric 
9060b57cec5SDimitry Andric PythonObject PythonCallable::
9070b57cec5SDimitry Andric operator()(std::initializer_list<PyObject *> args) {
9080b57cec5SDimitry Andric   PythonTuple arg_tuple(args);
9090b57cec5SDimitry Andric   return PythonObject(PyRefType::Owned,
9100b57cec5SDimitry Andric                       PyObject_CallObject(m_py_obj, arg_tuple.get()));
9110b57cec5SDimitry Andric }
9120b57cec5SDimitry Andric 
9130b57cec5SDimitry Andric PythonObject PythonCallable::
9140b57cec5SDimitry Andric operator()(std::initializer_list<PythonObject> args) {
9150b57cec5SDimitry Andric   PythonTuple arg_tuple(args);
9160b57cec5SDimitry Andric   return PythonObject(PyRefType::Owned,
9170b57cec5SDimitry Andric                       PyObject_CallObject(m_py_obj, arg_tuple.get()));
9180b57cec5SDimitry Andric }
9190b57cec5SDimitry Andric 
9200b57cec5SDimitry Andric bool PythonFile::Check(PyObject *py_obj) {
9219dba64beSDimitry Andric   if (!py_obj)
9229dba64beSDimitry Andric     return false;
9230b57cec5SDimitry Andric #if PY_MAJOR_VERSION < 3
9240b57cec5SDimitry Andric   return PyFile_Check(py_obj);
9250b57cec5SDimitry Andric #else
9260b57cec5SDimitry Andric   // In Python 3, there is no `PyFile_Check`, and in fact PyFile is not even a
9270b57cec5SDimitry Andric   // first-class object type anymore.  `PyFile_FromFd` is just a thin wrapper
9280b57cec5SDimitry Andric   // over `io.open()`, which returns some object derived from `io.IOBase`. As a
9290b57cec5SDimitry Andric   // result, the only way to detect a file in Python 3 is to check whether it
9309dba64beSDimitry Andric   // inherits from `io.IOBase`.
9319dba64beSDimitry Andric   auto io_module = PythonModule::Import("io");
9329dba64beSDimitry Andric   if (!io_module) {
9339dba64beSDimitry Andric     llvm::consumeError(io_module.takeError());
9340b57cec5SDimitry Andric     return false;
9359dba64beSDimitry Andric   }
9369dba64beSDimitry Andric   auto iobase = io_module.get().Get("IOBase");
9379dba64beSDimitry Andric   if (!iobase) {
9389dba64beSDimitry Andric     llvm::consumeError(iobase.takeError());
9390b57cec5SDimitry Andric     return false;
9409dba64beSDimitry Andric   }
9419dba64beSDimitry Andric   int r = PyObject_IsInstance(py_obj, iobase.get().get());
9429dba64beSDimitry Andric   if (r < 0) {
9439dba64beSDimitry Andric     llvm::consumeError(exception()); // clear the exception and log it.
9449dba64beSDimitry Andric     return false;
9459dba64beSDimitry Andric   }
9469dba64beSDimitry Andric   return !!r;
9470b57cec5SDimitry Andric #endif
9480b57cec5SDimitry Andric }
9490b57cec5SDimitry Andric 
9509dba64beSDimitry Andric namespace {
9519dba64beSDimitry Andric class GIL {
9529dba64beSDimitry Andric public:
9539dba64beSDimitry Andric   GIL() {
9549dba64beSDimitry Andric     m_state = PyGILState_Ensure();
9559dba64beSDimitry Andric     assert(!PyErr_Occurred());
9569dba64beSDimitry Andric   }
9579dba64beSDimitry Andric   ~GIL() { PyGILState_Release(m_state); }
9580b57cec5SDimitry Andric 
9599dba64beSDimitry Andric protected:
9609dba64beSDimitry Andric   PyGILState_STATE m_state;
9619dba64beSDimitry Andric };
9629dba64beSDimitry Andric } // namespace
9639dba64beSDimitry Andric 
9649dba64beSDimitry Andric const char *PythonException::toCString() const {
9659dba64beSDimitry Andric   if (!m_repr_bytes)
9669dba64beSDimitry Andric     return "unknown exception";
9679dba64beSDimitry Andric   return PyBytes_AS_STRING(m_repr_bytes);
9680b57cec5SDimitry Andric }
9690b57cec5SDimitry Andric 
9709dba64beSDimitry Andric PythonException::PythonException(const char *caller) {
9719dba64beSDimitry Andric   assert(PyErr_Occurred());
9729dba64beSDimitry Andric   m_exception_type = m_exception = m_traceback = m_repr_bytes = NULL;
9739dba64beSDimitry Andric   PyErr_Fetch(&m_exception_type, &m_exception, &m_traceback);
9749dba64beSDimitry Andric   PyErr_NormalizeException(&m_exception_type, &m_exception, &m_traceback);
9759dba64beSDimitry Andric   PyErr_Clear();
9769dba64beSDimitry Andric   if (m_exception) {
9779dba64beSDimitry Andric     PyObject *repr = PyObject_Repr(m_exception);
9789dba64beSDimitry Andric     if (repr) {
9799dba64beSDimitry Andric       m_repr_bytes = PyUnicode_AsEncodedString(repr, "utf-8", nullptr);
9809dba64beSDimitry Andric       if (!m_repr_bytes) {
9819dba64beSDimitry Andric         PyErr_Clear();
9829dba64beSDimitry Andric       }
9839dba64beSDimitry Andric       Py_XDECREF(repr);
9849dba64beSDimitry Andric     } else {
9859dba64beSDimitry Andric       PyErr_Clear();
9869dba64beSDimitry Andric     }
9879dba64beSDimitry Andric   }
9889dba64beSDimitry Andric   Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT);
9899dba64beSDimitry Andric   if (caller)
9909dba64beSDimitry Andric     LLDB_LOGF(log, "%s failed with exception: %s", caller, toCString());
9919dba64beSDimitry Andric   else
9929dba64beSDimitry Andric     LLDB_LOGF(log, "python exception: %s", toCString());
9939dba64beSDimitry Andric }
9949dba64beSDimitry Andric void PythonException::Restore() {
9959dba64beSDimitry Andric   if (m_exception_type && m_exception) {
9969dba64beSDimitry Andric     PyErr_Restore(m_exception_type, m_exception, m_traceback);
9979dba64beSDimitry Andric   } else {
9989dba64beSDimitry Andric     PyErr_SetString(PyExc_Exception, toCString());
9999dba64beSDimitry Andric   }
10009dba64beSDimitry Andric   m_exception_type = m_exception = m_traceback = NULL;
10010b57cec5SDimitry Andric }
10020b57cec5SDimitry Andric 
10039dba64beSDimitry Andric PythonException::~PythonException() {
10049dba64beSDimitry Andric   Py_XDECREF(m_exception_type);
10059dba64beSDimitry Andric   Py_XDECREF(m_exception);
10069dba64beSDimitry Andric   Py_XDECREF(m_traceback);
10079dba64beSDimitry Andric   Py_XDECREF(m_repr_bytes);
10080b57cec5SDimitry Andric }
10090b57cec5SDimitry Andric 
10109dba64beSDimitry Andric void PythonException::log(llvm::raw_ostream &OS) const { OS << toCString(); }
10119dba64beSDimitry Andric 
10129dba64beSDimitry Andric std::error_code PythonException::convertToErrorCode() const {
10139dba64beSDimitry Andric   return llvm::inconvertibleErrorCode();
10149dba64beSDimitry Andric }
10159dba64beSDimitry Andric 
10169dba64beSDimitry Andric bool PythonException::Matches(PyObject *exc) const {
10179dba64beSDimitry Andric   return PyErr_GivenExceptionMatches(m_exception_type, exc);
10189dba64beSDimitry Andric }
10199dba64beSDimitry Andric 
10209dba64beSDimitry Andric const char read_exception_script[] = R"(
10219dba64beSDimitry Andric import sys
10229dba64beSDimitry Andric from traceback import print_exception
10239dba64beSDimitry Andric if sys.version_info.major < 3:
10249dba64beSDimitry Andric   from StringIO import StringIO
10259dba64beSDimitry Andric else:
10269dba64beSDimitry Andric   from io import StringIO
10279dba64beSDimitry Andric def main(exc_type, exc_value, tb):
10289dba64beSDimitry Andric   f = StringIO()
10299dba64beSDimitry Andric   print_exception(exc_type, exc_value, tb, file=f)
10309dba64beSDimitry Andric   return f.getvalue()
10319dba64beSDimitry Andric )";
10329dba64beSDimitry Andric 
10339dba64beSDimitry Andric std::string PythonException::ReadBacktrace() const {
10349dba64beSDimitry Andric 
10359dba64beSDimitry Andric   if (!m_traceback)
10369dba64beSDimitry Andric     return toCString();
10379dba64beSDimitry Andric 
10389dba64beSDimitry Andric   // no need to synchronize access to this global, we already have the GIL
10399dba64beSDimitry Andric   static PythonScript read_exception(read_exception_script);
10409dba64beSDimitry Andric 
10419dba64beSDimitry Andric   Expected<std::string> backtrace = As<std::string>(
10429dba64beSDimitry Andric       read_exception(m_exception_type, m_exception, m_traceback));
10439dba64beSDimitry Andric 
10449dba64beSDimitry Andric   if (!backtrace) {
10459dba64beSDimitry Andric     std::string message =
10469dba64beSDimitry Andric         std::string(toCString()) + "\n" +
10479dba64beSDimitry Andric         "Traceback unavailble, an error occurred while reading it:\n";
10489dba64beSDimitry Andric     return (message + llvm::toString(backtrace.takeError()));
10499dba64beSDimitry Andric   }
10509dba64beSDimitry Andric 
10519dba64beSDimitry Andric   return std::move(backtrace.get());
10529dba64beSDimitry Andric }
10539dba64beSDimitry Andric 
10549dba64beSDimitry Andric char PythonException::ID = 0;
10559dba64beSDimitry Andric 
10569dba64beSDimitry Andric llvm::Expected<File::OpenOptions>
10579dba64beSDimitry Andric GetOptionsForPyObject(const PythonObject &obj) {
10580b57cec5SDimitry Andric #if PY_MAJOR_VERSION >= 3
10599dba64beSDimitry Andric   auto options = File::OpenOptions(0);
10609dba64beSDimitry Andric   auto readable = As<bool>(obj.CallMethod("readable"));
10619dba64beSDimitry Andric   if (!readable)
10629dba64beSDimitry Andric     return readable.takeError();
10639dba64beSDimitry Andric   auto writable = As<bool>(obj.CallMethod("writable"));
10649dba64beSDimitry Andric   if (!writable)
10659dba64beSDimitry Andric     return writable.takeError();
10669dba64beSDimitry Andric   if (readable.get())
10679dba64beSDimitry Andric     options |= File::eOpenOptionRead;
10689dba64beSDimitry Andric   if (writable.get())
10699dba64beSDimitry Andric     options |= File::eOpenOptionWrite;
10709dba64beSDimitry Andric   return options;
10719dba64beSDimitry Andric #else
10729dba64beSDimitry Andric   PythonString py_mode = obj.GetAttributeValue("mode").AsType<PythonString>();
10739dba64beSDimitry Andric   return File::GetOptionsFromMode(py_mode.GetString());
10749dba64beSDimitry Andric #endif
10759dba64beSDimitry Andric }
10769dba64beSDimitry Andric 
10779dba64beSDimitry Andric // Base class template for python files.   All it knows how to do
10789dba64beSDimitry Andric // is hold a reference to the python object and close or flush it
10799dba64beSDimitry Andric // when the File is closed.
10809dba64beSDimitry Andric namespace {
10819dba64beSDimitry Andric template <typename Base> class OwnedPythonFile : public Base {
10829dba64beSDimitry Andric public:
10839dba64beSDimitry Andric   template <typename... Args>
10849dba64beSDimitry Andric   OwnedPythonFile(const PythonFile &file, bool borrowed, Args... args)
10859dba64beSDimitry Andric       : Base(args...), m_py_obj(file), m_borrowed(borrowed) {
10869dba64beSDimitry Andric     assert(m_py_obj);
10879dba64beSDimitry Andric   }
10889dba64beSDimitry Andric 
10899dba64beSDimitry Andric   ~OwnedPythonFile() override {
10909dba64beSDimitry Andric     assert(m_py_obj);
10919dba64beSDimitry Andric     GIL takeGIL;
10929dba64beSDimitry Andric     Close();
10939dba64beSDimitry Andric     // we need to ensure the python object is released while we still
10949dba64beSDimitry Andric     // hold the GIL
10959dba64beSDimitry Andric     m_py_obj.Reset();
10969dba64beSDimitry Andric   }
10979dba64beSDimitry Andric 
10989dba64beSDimitry Andric   bool IsPythonSideValid() const {
10999dba64beSDimitry Andric     GIL takeGIL;
11009dba64beSDimitry Andric     auto closed = As<bool>(m_py_obj.GetAttribute("closed"));
11019dba64beSDimitry Andric     if (!closed) {
11029dba64beSDimitry Andric       llvm::consumeError(closed.takeError());
11039dba64beSDimitry Andric       return false;
11049dba64beSDimitry Andric     }
11059dba64beSDimitry Andric     return !closed.get();
11069dba64beSDimitry Andric   }
11079dba64beSDimitry Andric 
11089dba64beSDimitry Andric   bool IsValid() const override {
11099dba64beSDimitry Andric     return IsPythonSideValid() && Base::IsValid();
11109dba64beSDimitry Andric   }
11119dba64beSDimitry Andric 
11129dba64beSDimitry Andric   Status Close() override {
11139dba64beSDimitry Andric     assert(m_py_obj);
11149dba64beSDimitry Andric     Status py_error, base_error;
11159dba64beSDimitry Andric     GIL takeGIL;
11169dba64beSDimitry Andric     if (!m_borrowed) {
11179dba64beSDimitry Andric       auto r = m_py_obj.CallMethod("close");
11189dba64beSDimitry Andric       if (!r)
11199dba64beSDimitry Andric         py_error = Status(r.takeError());
11209dba64beSDimitry Andric     }
11219dba64beSDimitry Andric     base_error = Base::Close();
11229dba64beSDimitry Andric     if (py_error.Fail())
11239dba64beSDimitry Andric       return py_error;
11249dba64beSDimitry Andric     return base_error;
11259dba64beSDimitry Andric   };
11269dba64beSDimitry Andric 
11279dba64beSDimitry Andric   PyObject *GetPythonObject() const {
11289dba64beSDimitry Andric     assert(m_py_obj.IsValid());
11299dba64beSDimitry Andric     return m_py_obj.get();
11309dba64beSDimitry Andric   }
11319dba64beSDimitry Andric 
11329dba64beSDimitry Andric   static bool classof(const File *file) = delete;
11339dba64beSDimitry Andric 
11349dba64beSDimitry Andric protected:
11359dba64beSDimitry Andric   PythonFile m_py_obj;
11369dba64beSDimitry Andric   bool m_borrowed;
11379dba64beSDimitry Andric };
11389dba64beSDimitry Andric } // namespace
11399dba64beSDimitry Andric 
11409dba64beSDimitry Andric // A SimplePythonFile is a OwnedPythonFile that just does all I/O as
11419dba64beSDimitry Andric // a NativeFile
11429dba64beSDimitry Andric namespace {
11439dba64beSDimitry Andric class SimplePythonFile : public OwnedPythonFile<NativeFile> {
11449dba64beSDimitry Andric public:
11459dba64beSDimitry Andric   SimplePythonFile(const PythonFile &file, bool borrowed, int fd,
11469dba64beSDimitry Andric                    File::OpenOptions options)
11479dba64beSDimitry Andric       : OwnedPythonFile(file, borrowed, fd, options, false) {}
11489dba64beSDimitry Andric 
11499dba64beSDimitry Andric   static char ID;
11509dba64beSDimitry Andric   bool isA(const void *classID) const override {
11519dba64beSDimitry Andric     return classID == &ID || NativeFile::isA(classID);
11529dba64beSDimitry Andric   }
11539dba64beSDimitry Andric   static bool classof(const File *file) { return file->isA(&ID); }
11549dba64beSDimitry Andric };
11559dba64beSDimitry Andric char SimplePythonFile::ID = 0;
11569dba64beSDimitry Andric } // namespace
11579dba64beSDimitry Andric 
11589dba64beSDimitry Andric #if PY_MAJOR_VERSION >= 3
11599dba64beSDimitry Andric 
11609dba64beSDimitry Andric namespace {
11619dba64beSDimitry Andric class PythonBuffer {
11629dba64beSDimitry Andric public:
11639dba64beSDimitry Andric   PythonBuffer &operator=(const PythonBuffer &) = delete;
11649dba64beSDimitry Andric   PythonBuffer(const PythonBuffer &) = delete;
11659dba64beSDimitry Andric 
11669dba64beSDimitry Andric   static Expected<PythonBuffer> Create(PythonObject &obj,
11679dba64beSDimitry Andric                                        int flags = PyBUF_SIMPLE) {
11689dba64beSDimitry Andric     Py_buffer py_buffer = {};
11699dba64beSDimitry Andric     PyObject_GetBuffer(obj.get(), &py_buffer, flags);
11709dba64beSDimitry Andric     if (!py_buffer.obj)
11719dba64beSDimitry Andric       return llvm::make_error<PythonException>();
11729dba64beSDimitry Andric     return PythonBuffer(py_buffer);
11739dba64beSDimitry Andric   }
11749dba64beSDimitry Andric 
11759dba64beSDimitry Andric   PythonBuffer(PythonBuffer &&other) {
11769dba64beSDimitry Andric     m_buffer = other.m_buffer;
11779dba64beSDimitry Andric     other.m_buffer.obj = nullptr;
11789dba64beSDimitry Andric   }
11799dba64beSDimitry Andric 
11809dba64beSDimitry Andric   ~PythonBuffer() {
11819dba64beSDimitry Andric     if (m_buffer.obj)
11829dba64beSDimitry Andric       PyBuffer_Release(&m_buffer);
11839dba64beSDimitry Andric   }
11849dba64beSDimitry Andric 
11859dba64beSDimitry Andric   Py_buffer &get() { return m_buffer; }
11869dba64beSDimitry Andric 
11879dba64beSDimitry Andric private:
11889dba64beSDimitry Andric   // takes ownership of the buffer.
11899dba64beSDimitry Andric   PythonBuffer(const Py_buffer &py_buffer) : m_buffer(py_buffer) {}
11909dba64beSDimitry Andric   Py_buffer m_buffer;
11919dba64beSDimitry Andric };
11929dba64beSDimitry Andric } // namespace
11939dba64beSDimitry Andric 
11949dba64beSDimitry Andric // Shared methods between TextPythonFile and BinaryPythonFile
11959dba64beSDimitry Andric namespace {
11969dba64beSDimitry Andric class PythonIOFile : public OwnedPythonFile<File> {
11979dba64beSDimitry Andric public:
11989dba64beSDimitry Andric   PythonIOFile(const PythonFile &file, bool borrowed)
11999dba64beSDimitry Andric       : OwnedPythonFile(file, borrowed) {}
12009dba64beSDimitry Andric 
12019dba64beSDimitry Andric   ~PythonIOFile() override { Close(); }
12029dba64beSDimitry Andric 
12039dba64beSDimitry Andric   bool IsValid() const override { return IsPythonSideValid(); }
12049dba64beSDimitry Andric 
12059dba64beSDimitry Andric   Status Close() override {
12069dba64beSDimitry Andric     assert(m_py_obj);
12079dba64beSDimitry Andric     GIL takeGIL;
12089dba64beSDimitry Andric     if (m_borrowed)
12099dba64beSDimitry Andric       return Flush();
12109dba64beSDimitry Andric     auto r = m_py_obj.CallMethod("close");
12119dba64beSDimitry Andric     if (!r)
12129dba64beSDimitry Andric       return Status(r.takeError());
12139dba64beSDimitry Andric     return Status();
12149dba64beSDimitry Andric   }
12159dba64beSDimitry Andric 
12169dba64beSDimitry Andric   Status Flush() override {
12179dba64beSDimitry Andric     GIL takeGIL;
12189dba64beSDimitry Andric     auto r = m_py_obj.CallMethod("flush");
12199dba64beSDimitry Andric     if (!r)
12209dba64beSDimitry Andric       return Status(r.takeError());
12219dba64beSDimitry Andric     return Status();
12229dba64beSDimitry Andric   }
12239dba64beSDimitry Andric 
12249dba64beSDimitry Andric   Expected<File::OpenOptions> GetOptions() const override {
12259dba64beSDimitry Andric     GIL takeGIL;
12269dba64beSDimitry Andric     return GetOptionsForPyObject(m_py_obj);
12279dba64beSDimitry Andric   }
12289dba64beSDimitry Andric 
12299dba64beSDimitry Andric   static char ID;
12309dba64beSDimitry Andric   bool isA(const void *classID) const override {
12319dba64beSDimitry Andric     return classID == &ID || File::isA(classID);
12329dba64beSDimitry Andric   }
12339dba64beSDimitry Andric   static bool classof(const File *file) { return file->isA(&ID); }
12349dba64beSDimitry Andric };
12359dba64beSDimitry Andric char PythonIOFile::ID = 0;
12369dba64beSDimitry Andric } // namespace
12379dba64beSDimitry Andric 
12389dba64beSDimitry Andric namespace {
12399dba64beSDimitry Andric class BinaryPythonFile : public PythonIOFile {
12409dba64beSDimitry Andric protected:
12419dba64beSDimitry Andric   int m_descriptor;
12429dba64beSDimitry Andric 
12439dba64beSDimitry Andric public:
12449dba64beSDimitry Andric   BinaryPythonFile(int fd, const PythonFile &file, bool borrowed)
12459dba64beSDimitry Andric       : PythonIOFile(file, borrowed),
12469dba64beSDimitry Andric         m_descriptor(File::DescriptorIsValid(fd) ? fd
12479dba64beSDimitry Andric                                                  : File::kInvalidDescriptor) {}
12489dba64beSDimitry Andric 
12499dba64beSDimitry Andric   int GetDescriptor() const override { return m_descriptor; }
12509dba64beSDimitry Andric 
12519dba64beSDimitry Andric   Status Write(const void *buf, size_t &num_bytes) override {
12529dba64beSDimitry Andric     GIL takeGIL;
12539dba64beSDimitry Andric     PyObject *pybuffer_p = PyMemoryView_FromMemory(
12549dba64beSDimitry Andric         const_cast<char *>((const char *)buf), num_bytes, PyBUF_READ);
12559dba64beSDimitry Andric     if (!pybuffer_p)
12569dba64beSDimitry Andric       return Status(llvm::make_error<PythonException>());
12579dba64beSDimitry Andric     auto pybuffer = Take<PythonObject>(pybuffer_p);
12589dba64beSDimitry Andric     num_bytes = 0;
12599dba64beSDimitry Andric     auto bytes_written = As<long long>(m_py_obj.CallMethod("write", pybuffer));
12609dba64beSDimitry Andric     if (!bytes_written)
12619dba64beSDimitry Andric       return Status(bytes_written.takeError());
12629dba64beSDimitry Andric     if (bytes_written.get() < 0)
12639dba64beSDimitry Andric       return Status(".write() method returned a negative number!");
12649dba64beSDimitry Andric     static_assert(sizeof(long long) >= sizeof(size_t), "overflow");
12659dba64beSDimitry Andric     num_bytes = bytes_written.get();
12669dba64beSDimitry Andric     return Status();
12679dba64beSDimitry Andric   }
12689dba64beSDimitry Andric 
12699dba64beSDimitry Andric   Status Read(void *buf, size_t &num_bytes) override {
12709dba64beSDimitry Andric     GIL takeGIL;
12719dba64beSDimitry Andric     static_assert(sizeof(long long) >= sizeof(size_t), "overflow");
12729dba64beSDimitry Andric     auto pybuffer_obj =
12739dba64beSDimitry Andric         m_py_obj.CallMethod("read", (unsigned long long)num_bytes);
12749dba64beSDimitry Andric     if (!pybuffer_obj)
12759dba64beSDimitry Andric       return Status(pybuffer_obj.takeError());
12769dba64beSDimitry Andric     num_bytes = 0;
12779dba64beSDimitry Andric     if (pybuffer_obj.get().IsNone()) {
12789dba64beSDimitry Andric       // EOF
12799dba64beSDimitry Andric       num_bytes = 0;
12809dba64beSDimitry Andric       return Status();
12819dba64beSDimitry Andric     }
12829dba64beSDimitry Andric     auto pybuffer = PythonBuffer::Create(pybuffer_obj.get());
12839dba64beSDimitry Andric     if (!pybuffer)
12849dba64beSDimitry Andric       return Status(pybuffer.takeError());
12859dba64beSDimitry Andric     memcpy(buf, pybuffer.get().get().buf, pybuffer.get().get().len);
12869dba64beSDimitry Andric     num_bytes = pybuffer.get().get().len;
12879dba64beSDimitry Andric     return Status();
12889dba64beSDimitry Andric   }
12899dba64beSDimitry Andric };
12909dba64beSDimitry Andric } // namespace
12919dba64beSDimitry Andric 
12929dba64beSDimitry Andric namespace {
12939dba64beSDimitry Andric class TextPythonFile : public PythonIOFile {
12949dba64beSDimitry Andric protected:
12959dba64beSDimitry Andric   int m_descriptor;
12969dba64beSDimitry Andric 
12979dba64beSDimitry Andric public:
12989dba64beSDimitry Andric   TextPythonFile(int fd, const PythonFile &file, bool borrowed)
12999dba64beSDimitry Andric       : PythonIOFile(file, borrowed),
13009dba64beSDimitry Andric         m_descriptor(File::DescriptorIsValid(fd) ? fd
13019dba64beSDimitry Andric                                                  : File::kInvalidDescriptor) {}
13029dba64beSDimitry Andric 
13039dba64beSDimitry Andric   int GetDescriptor() const override { return m_descriptor; }
13049dba64beSDimitry Andric 
13059dba64beSDimitry Andric   Status Write(const void *buf, size_t &num_bytes) override {
13069dba64beSDimitry Andric     GIL takeGIL;
13079dba64beSDimitry Andric     auto pystring =
13089dba64beSDimitry Andric         PythonString::FromUTF8(llvm::StringRef((const char *)buf, num_bytes));
13099dba64beSDimitry Andric     if (!pystring)
13109dba64beSDimitry Andric       return Status(pystring.takeError());
13119dba64beSDimitry Andric     num_bytes = 0;
13129dba64beSDimitry Andric     auto bytes_written =
13139dba64beSDimitry Andric         As<long long>(m_py_obj.CallMethod("write", pystring.get()));
13149dba64beSDimitry Andric     if (!bytes_written)
13159dba64beSDimitry Andric       return Status(bytes_written.takeError());
13169dba64beSDimitry Andric     if (bytes_written.get() < 0)
13179dba64beSDimitry Andric       return Status(".write() method returned a negative number!");
13189dba64beSDimitry Andric     static_assert(sizeof(long long) >= sizeof(size_t), "overflow");
13199dba64beSDimitry Andric     num_bytes = bytes_written.get();
13209dba64beSDimitry Andric     return Status();
13219dba64beSDimitry Andric   }
13229dba64beSDimitry Andric 
13239dba64beSDimitry Andric   Status Read(void *buf, size_t &num_bytes) override {
13249dba64beSDimitry Andric     GIL takeGIL;
13259dba64beSDimitry Andric     size_t num_chars = num_bytes / 6;
13269dba64beSDimitry Andric     size_t orig_num_bytes = num_bytes;
13279dba64beSDimitry Andric     num_bytes = 0;
13289dba64beSDimitry Andric     if (orig_num_bytes < 6) {
13299dba64beSDimitry Andric       return Status("can't read less than 6 bytes from a utf8 text stream");
13309dba64beSDimitry Andric     }
13319dba64beSDimitry Andric     auto pystring = As<PythonString>(
13329dba64beSDimitry Andric         m_py_obj.CallMethod("read", (unsigned long long)num_chars));
13339dba64beSDimitry Andric     if (!pystring)
13349dba64beSDimitry Andric       return Status(pystring.takeError());
13359dba64beSDimitry Andric     if (pystring.get().IsNone()) {
13369dba64beSDimitry Andric       // EOF
13379dba64beSDimitry Andric       return Status();
13389dba64beSDimitry Andric     }
13399dba64beSDimitry Andric     auto stringref = pystring.get().AsUTF8();
13409dba64beSDimitry Andric     if (!stringref)
13419dba64beSDimitry Andric       return Status(stringref.takeError());
13429dba64beSDimitry Andric     num_bytes = stringref.get().size();
13439dba64beSDimitry Andric     memcpy(buf, stringref.get().begin(), num_bytes);
13449dba64beSDimitry Andric     return Status();
13459dba64beSDimitry Andric   }
13469dba64beSDimitry Andric };
13479dba64beSDimitry Andric } // namespace
13489dba64beSDimitry Andric 
13499dba64beSDimitry Andric #endif
13509dba64beSDimitry Andric 
13519dba64beSDimitry Andric llvm::Expected<FileSP> PythonFile::ConvertToFile(bool borrowed) {
13529dba64beSDimitry Andric   if (!IsValid())
13539dba64beSDimitry Andric     return llvm::createStringError(llvm::inconvertibleErrorCode(),
13549dba64beSDimitry Andric                                    "invalid PythonFile");
13559dba64beSDimitry Andric 
13569dba64beSDimitry Andric   int fd = PyObject_AsFileDescriptor(m_py_obj);
13579dba64beSDimitry Andric   if (fd < 0) {
13589dba64beSDimitry Andric     PyErr_Clear();
13599dba64beSDimitry Andric     return ConvertToFileForcingUseOfScriptingIOMethods(borrowed);
13609dba64beSDimitry Andric   }
13619dba64beSDimitry Andric   auto options = GetOptionsForPyObject(*this);
13629dba64beSDimitry Andric   if (!options)
13639dba64beSDimitry Andric     return options.takeError();
13649dba64beSDimitry Andric 
1365*480093f4SDimitry Andric   if (options.get() & File::eOpenOptionWrite) {
13669dba64beSDimitry Andric     // LLDB and python will not share I/O buffers.  We should probably
13679dba64beSDimitry Andric     // flush the python buffers now.
13689dba64beSDimitry Andric     auto r = CallMethod("flush");
13699dba64beSDimitry Andric     if (!r)
13709dba64beSDimitry Andric       return r.takeError();
1371*480093f4SDimitry Andric   }
13729dba64beSDimitry Andric 
13739dba64beSDimitry Andric   FileSP file_sp;
13749dba64beSDimitry Andric   if (borrowed) {
13759dba64beSDimitry Andric     // In this case we we don't need to retain the python
13769dba64beSDimitry Andric     // object at all.
13779dba64beSDimitry Andric     file_sp = std::make_shared<NativeFile>(fd, options.get(), false);
13789dba64beSDimitry Andric   } else {
13799dba64beSDimitry Andric     file_sp = std::static_pointer_cast<File>(
13809dba64beSDimitry Andric         std::make_shared<SimplePythonFile>(*this, borrowed, fd, options.get()));
13819dba64beSDimitry Andric   }
13829dba64beSDimitry Andric   if (!file_sp->IsValid())
13839dba64beSDimitry Andric     return llvm::createStringError(llvm::inconvertibleErrorCode(),
13849dba64beSDimitry Andric                                    "invalid File");
13859dba64beSDimitry Andric 
13869dba64beSDimitry Andric   return file_sp;
13879dba64beSDimitry Andric }
13889dba64beSDimitry Andric 
13899dba64beSDimitry Andric llvm::Expected<FileSP>
13909dba64beSDimitry Andric PythonFile::ConvertToFileForcingUseOfScriptingIOMethods(bool borrowed) {
13919dba64beSDimitry Andric 
13929dba64beSDimitry Andric   assert(!PyErr_Occurred());
13939dba64beSDimitry Andric 
13949dba64beSDimitry Andric   if (!IsValid())
13959dba64beSDimitry Andric     return llvm::createStringError(llvm::inconvertibleErrorCode(),
13969dba64beSDimitry Andric                                    "invalid PythonFile");
13979dba64beSDimitry Andric 
13989dba64beSDimitry Andric #if PY_MAJOR_VERSION < 3
13999dba64beSDimitry Andric 
14009dba64beSDimitry Andric   return llvm::createStringError(llvm::inconvertibleErrorCode(),
14019dba64beSDimitry Andric                                  "not supported on python 2");
14029dba64beSDimitry Andric 
14039dba64beSDimitry Andric #else
14049dba64beSDimitry Andric 
14059dba64beSDimitry Andric   int fd = PyObject_AsFileDescriptor(m_py_obj);
14069dba64beSDimitry Andric   if (fd < 0) {
14079dba64beSDimitry Andric     PyErr_Clear();
14089dba64beSDimitry Andric     fd = File::kInvalidDescriptor;
14099dba64beSDimitry Andric   }
14109dba64beSDimitry Andric 
14119dba64beSDimitry Andric   auto io_module = PythonModule::Import("io");
14129dba64beSDimitry Andric   if (!io_module)
14139dba64beSDimitry Andric     return io_module.takeError();
14149dba64beSDimitry Andric   auto textIOBase = io_module.get().Get("TextIOBase");
14159dba64beSDimitry Andric   if (!textIOBase)
14169dba64beSDimitry Andric     return textIOBase.takeError();
14179dba64beSDimitry Andric   auto rawIOBase = io_module.get().Get("RawIOBase");
14189dba64beSDimitry Andric   if (!rawIOBase)
14199dba64beSDimitry Andric     return rawIOBase.takeError();
14209dba64beSDimitry Andric   auto bufferedIOBase = io_module.get().Get("BufferedIOBase");
14219dba64beSDimitry Andric   if (!bufferedIOBase)
14229dba64beSDimitry Andric     return bufferedIOBase.takeError();
14239dba64beSDimitry Andric 
14249dba64beSDimitry Andric   FileSP file_sp;
14259dba64beSDimitry Andric 
14269dba64beSDimitry Andric   auto isTextIO = IsInstance(textIOBase.get());
14279dba64beSDimitry Andric   if (!isTextIO)
14289dba64beSDimitry Andric     return isTextIO.takeError();
14299dba64beSDimitry Andric   if (isTextIO.get())
14309dba64beSDimitry Andric     file_sp = std::static_pointer_cast<File>(
14319dba64beSDimitry Andric         std::make_shared<TextPythonFile>(fd, *this, borrowed));
14329dba64beSDimitry Andric 
14339dba64beSDimitry Andric   auto isRawIO = IsInstance(rawIOBase.get());
14349dba64beSDimitry Andric   if (!isRawIO)
14359dba64beSDimitry Andric     return isRawIO.takeError();
14369dba64beSDimitry Andric   auto isBufferedIO = IsInstance(bufferedIOBase.get());
14379dba64beSDimitry Andric   if (!isBufferedIO)
14389dba64beSDimitry Andric     return isBufferedIO.takeError();
14399dba64beSDimitry Andric 
14409dba64beSDimitry Andric   if (isRawIO.get() || isBufferedIO.get()) {
14419dba64beSDimitry Andric     file_sp = std::static_pointer_cast<File>(
14429dba64beSDimitry Andric         std::make_shared<BinaryPythonFile>(fd, *this, borrowed));
14439dba64beSDimitry Andric   }
14449dba64beSDimitry Andric 
14459dba64beSDimitry Andric   if (!file_sp)
14469dba64beSDimitry Andric     return llvm::createStringError(llvm::inconvertibleErrorCode(),
14479dba64beSDimitry Andric                                    "python file is neither text nor binary");
14489dba64beSDimitry Andric 
14499dba64beSDimitry Andric   if (!file_sp->IsValid())
14509dba64beSDimitry Andric     return llvm::createStringError(llvm::inconvertibleErrorCode(),
14519dba64beSDimitry Andric                                    "invalid File");
14529dba64beSDimitry Andric 
14539dba64beSDimitry Andric   return file_sp;
14549dba64beSDimitry Andric 
14559dba64beSDimitry Andric #endif
14569dba64beSDimitry Andric }
14579dba64beSDimitry Andric 
14589dba64beSDimitry Andric Expected<PythonFile> PythonFile::FromFile(File &file, const char *mode) {
14599dba64beSDimitry Andric   if (!file.IsValid())
14609dba64beSDimitry Andric     return llvm::createStringError(llvm::inconvertibleErrorCode(),
14619dba64beSDimitry Andric                                    "invalid file");
14629dba64beSDimitry Andric 
14639dba64beSDimitry Andric   if (auto *simple = llvm::dyn_cast<SimplePythonFile>(&file))
14649dba64beSDimitry Andric     return Retain<PythonFile>(simple->GetPythonObject());
14659dba64beSDimitry Andric #if PY_MAJOR_VERSION >= 3
14669dba64beSDimitry Andric   if (auto *pythonio = llvm::dyn_cast<PythonIOFile>(&file))
14679dba64beSDimitry Andric     return Retain<PythonFile>(pythonio->GetPythonObject());
14689dba64beSDimitry Andric #endif
14699dba64beSDimitry Andric 
14709dba64beSDimitry Andric   if (!mode) {
14719dba64beSDimitry Andric     auto m = file.GetOpenMode();
14729dba64beSDimitry Andric     if (!m)
14739dba64beSDimitry Andric       return m.takeError();
14749dba64beSDimitry Andric     mode = m.get();
14759dba64beSDimitry Andric   }
14769dba64beSDimitry Andric 
14779dba64beSDimitry Andric   PyObject *file_obj;
14789dba64beSDimitry Andric #if PY_MAJOR_VERSION >= 3
14799dba64beSDimitry Andric   file_obj = PyFile_FromFd(file.GetDescriptor(), nullptr, mode, -1, nullptr,
1480*480093f4SDimitry Andric                            "ignore", nullptr, /*closefd=*/0);
14810b57cec5SDimitry Andric #else
1482*480093f4SDimitry Andric   // I'd like to pass ::fflush here if the file is writable,  so that
1483*480093f4SDimitry Andric   // when the python side destructs the file object it will be flushed.
1484*480093f4SDimitry Andric   // However, this would be dangerous.    It can cause fflush to be called
1485*480093f4SDimitry Andric   // after fclose if the python program keeps a reference to the file after
1486*480093f4SDimitry Andric   // the original lldb_private::File has been destructed.
1487*480093f4SDimitry Andric   //
1488*480093f4SDimitry Andric   // It's all well and good to ask a python program not to use a closed file
1489*480093f4SDimitry Andric   // but asking a python program to make sure objects get released in a
1490*480093f4SDimitry Andric   // particular order is not safe.
1491*480093f4SDimitry Andric   //
1492*480093f4SDimitry Andric   // The tradeoff here is that if a python 2 program wants to make sure this
1493*480093f4SDimitry Andric   // file gets flushed, they'll have to do it explicitly or wait untill the
1494*480093f4SDimitry Andric   // original lldb File itself gets flushed.
1495*480093f4SDimitry Andric   file_obj = PyFile_FromFile(file.GetStream(), py2_const_cast(""),
1496*480093f4SDimitry Andric                              py2_const_cast(mode), [](FILE *) { return 0; });
14970b57cec5SDimitry Andric #endif
14989dba64beSDimitry Andric 
14999dba64beSDimitry Andric   if (!file_obj)
15009dba64beSDimitry Andric     return exception();
15019dba64beSDimitry Andric 
15029dba64beSDimitry Andric   return Take<PythonFile>(file_obj);
15030b57cec5SDimitry Andric }
15040b57cec5SDimitry Andric 
15059dba64beSDimitry Andric Error PythonScript::Init() {
15069dba64beSDimitry Andric   if (function.IsValid())
15079dba64beSDimitry Andric     return Error::success();
15080b57cec5SDimitry Andric 
15099dba64beSDimitry Andric   PythonDictionary globals(PyInitialValue::Empty);
15109dba64beSDimitry Andric   auto builtins = PythonModule::BuiltinsModule();
15119dba64beSDimitry Andric   if (Error error = globals.SetItem("__builtins__", builtins))
15129dba64beSDimitry Andric     return error;
15139dba64beSDimitry Andric   PyObject *o =
15149dba64beSDimitry Andric       PyRun_String(script, Py_file_input, globals.get(), globals.get());
15159dba64beSDimitry Andric   if (!o)
15169dba64beSDimitry Andric     return exception();
15179dba64beSDimitry Andric   Take<PythonObject>(o);
15189dba64beSDimitry Andric   auto f = As<PythonCallable>(globals.GetItem("main"));
15199dba64beSDimitry Andric   if (!f)
15209dba64beSDimitry Andric     return f.takeError();
15219dba64beSDimitry Andric   function = std::move(f.get());
15229dba64beSDimitry Andric 
15239dba64beSDimitry Andric   return Error::success();
15240b57cec5SDimitry Andric }
15250b57cec5SDimitry Andric 
15269dba64beSDimitry Andric llvm::Expected<PythonObject>
15279dba64beSDimitry Andric python::runStringOneLine(const llvm::Twine &string,
15289dba64beSDimitry Andric                          const PythonDictionary &globals,
15299dba64beSDimitry Andric                          const PythonDictionary &locals) {
15309dba64beSDimitry Andric   if (!globals.IsValid() || !locals.IsValid())
15319dba64beSDimitry Andric     return nullDeref();
15320b57cec5SDimitry Andric 
15339dba64beSDimitry Andric   PyObject *code =
15349dba64beSDimitry Andric       Py_CompileString(NullTerminated(string), "<string>", Py_eval_input);
15359dba64beSDimitry Andric   if (!code) {
15369dba64beSDimitry Andric     PyErr_Clear();
15379dba64beSDimitry Andric     code =
15389dba64beSDimitry Andric         Py_CompileString(NullTerminated(string), "<string>", Py_single_input);
15399dba64beSDimitry Andric   }
15409dba64beSDimitry Andric   if (!code)
15419dba64beSDimitry Andric     return exception();
15429dba64beSDimitry Andric   auto code_ref = Take<PythonObject>(code);
15439dba64beSDimitry Andric 
15449dba64beSDimitry Andric #if PY_MAJOR_VERSION < 3
15459dba64beSDimitry Andric   PyObject *result =
15469dba64beSDimitry Andric       PyEval_EvalCode((PyCodeObject *)code, globals.get(), locals.get());
15479dba64beSDimitry Andric #else
15489dba64beSDimitry Andric   PyObject *result = PyEval_EvalCode(code, globals.get(), locals.get());
15499dba64beSDimitry Andric #endif
15509dba64beSDimitry Andric 
15519dba64beSDimitry Andric   if (!result)
15529dba64beSDimitry Andric     return exception();
15539dba64beSDimitry Andric 
15549dba64beSDimitry Andric   return Take<PythonObject>(result);
15559dba64beSDimitry Andric }
15569dba64beSDimitry Andric 
15579dba64beSDimitry Andric llvm::Expected<PythonObject>
15589dba64beSDimitry Andric python::runStringMultiLine(const llvm::Twine &string,
15599dba64beSDimitry Andric                            const PythonDictionary &globals,
15609dba64beSDimitry Andric                            const PythonDictionary &locals) {
15619dba64beSDimitry Andric   if (!globals.IsValid() || !locals.IsValid())
15629dba64beSDimitry Andric     return nullDeref();
15639dba64beSDimitry Andric   PyObject *result = PyRun_String(NullTerminated(string), Py_file_input,
15649dba64beSDimitry Andric                                   globals.get(), locals.get());
15659dba64beSDimitry Andric   if (!result)
15669dba64beSDimitry Andric     return exception();
15679dba64beSDimitry Andric   return Take<PythonObject>(result);
15680b57cec5SDimitry Andric }
15690b57cec5SDimitry Andric 
15700b57cec5SDimitry Andric #endif
1571