CPPEnum.cxx

Go to the documentation of this file.

// Bindings
#include "cpyrt.h"
 
using namespace cppjit;
#include "CPPEnum.h"
#include "PyStrings.h"
#include "TypeManip.h"
#include "Utility.h"
#include <unordered_map>
 
//- private helpers ----------------------------------------------------------
static PyObject* pytype_from_enum_type(const std::string& enum_type) {
  if (enum_type == "char")
    return (PyObject*)&PyUnicode_Type;
  else if (enum_type == "bool")
    return (PyObject*)&PyLong_Type; // can't use PyBool_Type as base
  else if (strstr("long", enum_type.c_str()))
    return (PyObject*)&PyLong_Type;
  return (PyObject*)&PyLong_Type; // covers most cases
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::pyval_from_enum(const std::string& enum_type, PyObject* pytype,
                                 PyObject* btype,
                                 interop::TCppScope_t enum_constant) {
  long long llval = interop::GetEnumDataValue(enum_constant);
 
  if (enum_type == "bool" && !(pytype && btype)) {
    // no enum class to instantiate; the singletons can not carry attributes
    PyObject* result = (bool)llval ? Py_True : Py_False;
    Py_INCREF(result);
    return result;
  }
 
  PyObject* bval;
  if (enum_type == "char") {
    char val = (char)llval;
    bval = PyUnicode_FromOrdinal((int)val);
  } else if (enum_type == "int" || enum_type == "unsigned int")
    bval = PyLong_FromLong((long)llval);
  else
    bval = PyLong_FromLongLong(llval);
 
  if (!bval)
    return nullptr; // e.g. when out of range for small integers
 
  if (pytype && btype) {
    PyObject* args = PyTuple_New(1);
    PyTuple_SET_ITEM(args, 0, bval);
    bval = ((PyTypeObject*)btype)->tp_new((PyTypeObject*)pytype, args, nullptr);
    Py_DECREF(args);
  }
  return bval;
}
 
//- enum methods -------------------------------------------------------------
static int enum_setattro(PyObject* /* pyclass */, PyObject* /* pyname */,
                         PyObject* /* pyval */) {
  // Helper to make enums read-only.
  PyErr_SetString(PyExc_TypeError, "enum values are read-only");
  return -1;
}
 
//----------------------------------------------------------------------------
static PyObject* enum_repr(PyObject* self) {
  using namespace cppjit::cpyrt;
 
  PyObject* kls_scope =
      PyObject_GetAttr((PyObject*)Py_TYPE(self), PyStrings::gThisModule);
  if (!kls_scope)
    PyErr_Clear();
  PyObject* kls_cppname =
      PyObject_GetAttr((PyObject*)Py_TYPE(self), PyStrings::gCppName);
  if (!kls_cppname)
    PyErr_Clear();
  PyObject* obj_cppname = PyObject_GetAttr(self, PyStrings::gCppName);
  if (!obj_cppname)
    PyErr_Clear();
  PyObject* obj_str = Py_TYPE(self)->tp_str(self);
 
  PyObject* repr = nullptr;
  if (kls_cppname && obj_cppname && obj_str) {
    const std::string resolved =
        interop::ResolveEnum(PyLong_AsVoidPtr(kls_scope));
    repr = PyUnicode_FromFormat("(%s::%s) : (%s) %s",
                                PyUnicode_AsUTF8(kls_cppname),
                                PyUnicode_AsUTF8(obj_cppname), resolved.c_str(),
                                PyUnicode_AsUTF8(obj_str));
  }
  Py_XDECREF(obj_cppname);
  Py_XDECREF(kls_cppname);
 
  if (repr) {
    Py_DECREF(obj_str);
    return repr;
  }
 
  return obj_str;
}
 
//----------------------------------------------------------------------------
// TODO: factor the following lookup with similar codes in Convertes and
// TemplateProxy.cxx
 
static std::unordered_map<std::string, std::string> gCTypesNames = {
    {"bool", "c_bool"},
    {"char", "c_char"},
    {"wchar_t", "c_wchar"},
    {"std::byte", "c_byte"},
    {"int8_t", "c_byte"},
    {"uint8_t", "c_ubyte"},
    {"short", "c_short"},
    {"int16_t", "c_int16"},
    {"unsigned short", "c_ushort"},
    {"uint16_t", "c_uint16"},
    {"int", "c_int"},
    {"unsigned int", "c_uint"},
    {"long", "c_long"},
    {"unsigned long", "c_ulong"},
    {"long long", "c_longlong"},
    {"unsigned long long", "c_ulonglong"}};
 
// Both GetCTypesType and GetCTypesPtrType, rely on the ctypes module itself
// caching the types (thus also making them unique), so no ref-count is needed.
// Further, by keeping a ref-count on the module, it won't be off-loaded until
// the 2nd cleanup cycle.
static PyTypeObject* GetCTypesType(const std::string& cppname) {
  static PyObject* ctmod = PyImport_ImportModule("ctypes"); // ref-count kept
  if (!ctmod)
    return nullptr;
 
  auto nn = gCTypesNames.find(cppname);
  if (nn == gCTypesNames.end()) {
    PyErr_Format(PyExc_TypeError, "Can not find ctypes type for \"%s\"",
                 cppname.c_str());
    return nullptr;
  }
 
  return (PyTypeObject*)PyObject_GetAttrString(ctmod, nn->second.c_str());
}
 
static PyObject* enum_ctype(PyObject* cls, PyObject* args, PyObject* kwds) {
  PyObject* pyres = PyObject_GetAttr(cls, cpyrt::PyStrings::gUnderlying);
  if (!pyres)
    PyErr_Clear();
 
  std::string underlying = pyres ? PyUnicode_AsUTF8(pyres) : "int";
  PyTypeObject* ct = GetCTypesType(underlying);
  if (!ct)
    return nullptr;
 
  return PyType_Type.tp_call((PyObject*)ct, args, kwds);
}
 
//- creation -----------------------------------------------------------------
cpyrt::CPPEnum* cpyrt::CPPEnum_New(const std::string& name,
                                   interop::TCppScope_t scope) {
  // Create a new enum type based on the actual C++ type. Enum values are added
  // to the type but may also live in the enclosing scope.
 
  CPPEnum* pyenum = nullptr;
 
  interop::TCppScope_t etype = scope;
  const std::string& ename = interop::GetScopedFinalName(scope);
  if (etype) {
    // create new enum type with labeled values in place, with a meta-class
    // to make sure the enum values are read-only
    const std::string& resolved = interop::ResolveEnum(etype);
    PyObject* pyside_type = pytype_from_enum_type(resolved);
    PyObject* pymetabases = PyTuple_New(1);
    PyObject* btype = (PyObject*)Py_TYPE(pyside_type);
    Py_INCREF(btype);
    PyTuple_SET_ITEM(pymetabases, 0, btype);
 
    PyObject* args =
        Py_BuildValue((char*)"sO{}", (name + "_meta").c_str(), pymetabases);
    Py_DECREF(pymetabases);
    PyObject* pymeta = PyType_Type.tp_new(Py_TYPE(pyside_type), args, nullptr);
    Py_DECREF(args);
 
    // prepare the base class
    PyObject* pybases = PyTuple_New(1);
    Py_INCREF(pyside_type);
    PyTuple_SET_ITEM(pybases, 0, (PyObject*)pyside_type);
 
    // create the __cpp_name__ for templates
    PyObject* dct = PyDict_New();
    PyObject* pycppname = PyUnicode_FromString(ename.c_str());
    PyObject* pycppscope = PyLong_FromVoidPtr(etype.data);
    PyDict_SetItem(dct, PyStrings::gCppName, pycppname);
    PyDict_SetItem(dct, PyStrings::gThisModule, pycppscope);
    Py_DECREF(pycppname);
    PyObject* pyresolved = PyUnicode_FromString(resolved.c_str());
    PyDict_SetItem(dct, PyStrings::gUnderlying, pyresolved);
    Py_DECREF(pyresolved);
 
    // add the __module__ to allow pickling
    std::string modname = TypeManip::extract_namespace(ename);
    TypeManip::cppscope_to_pyscope(modname); // :: -> .
    if (!modname.empty())
      modname = "." + modname;
    PyObject* pymodname =
        PyUnicode_FromString(("cppjit.gbl" + modname).c_str());
    PyDict_SetItem(dct, PyStrings::gModule, pymodname);
    Py_DECREF(pymodname);
 
    // create the actual enum class
    args = Py_BuildValue((char*)"sOO", name.c_str(), pybases, dct);
    Py_DECREF(pybases);
    Py_DECREF(dct);
    pyenum =
        ((PyTypeObject*)pymeta)->tp_new((PyTypeObject*)pymeta, args, nullptr);
 
    // add pythonizations
    Utility::AddToClass((PyObject*)Py_TYPE(pyenum), "__ctype__",
                        (PyCFunction)enum_ctype, METH_VARARGS | METH_KEYWORDS);
    ((PyTypeObject*)pyenum)->tp_repr = enum_repr;
    ((PyTypeObject*)pyenum)->tp_str = ((PyTypeObject*)pyside_type)->tp_repr;
 
    // collect the enum values
    std::vector<interop::TCppScope_t> econstants =
        interop::GetEnumConstants(etype);
    bool values_ok = true;
    for (auto econstant : econstants) {
      PyObject* val = pyval_from_enum(resolved, pyenum, pyside_type, econstant);
      if (!val) {
        values_ok = false;
        break;
      }
      const std::string& dname = interop::GetFinalName(econstant);
      PyObject* pydname = PyUnicode_FromString(dname.c_str());
      PyObject_SetAttr(pyenum, pydname, val);
      Py_DECREF(pydname);
      PyObject* pydcppname = PyUnicode_FromString(
          (ename.empty() ? dname : (ename + "::" + dname)).c_str());
      PyObject_SetAttr(val, PyStrings::gCppName, pydcppname);
      Py_DECREF(pydcppname);
      Py_DECREF(val);
    }
 
    // disable writing onto enum values
    ((PyTypeObject*)pymeta)->tp_setattro = enum_setattro;
 
    // final cleanup
    Py_DECREF(args);
    Py_DECREF(pymeta);
 
    if (!values_ok) {
      if (!PyErr_Occurred())
        PyErr_SetString(PyExc_ValueError,
                        "could not set some of the enum values");
      Py_DECREF(pyenum);
      return nullptr;
    }
 
  } else {
    // presumably not a class enum; simply pretend int
    Py_INCREF(&PyLong_Type);
    pyenum = (PyObject*)&PyLong_Type;
  }
 
  return pyenum;
}