Executors.cxx

Go to the documentation of this file.

// Bindings
#include "cpyrt.h"
 
using namespace cppjit;
#include "CPPInstance.h"
#include "DeclareExecutors.h"
#include "LowLevelViews.h"
#include "ProxyWrappers.h"
#include "PyStrings.h"
#include "TypeManip.h"
#include "Utility.h"
#include "cppjit_interop.h"
 
// Standard
#include <complex>
#include <cstring>
#include <map>
#include <new>
#include <sstream>
#include <sys/types.h>
#include <utility>
 
//- data _____________________________________________________________________
namespace cppjit::cpyrt {
typedef std::unordered_map<std::string, ef_t> ExecFactories_t;
static ExecFactories_t gExecFactories;
 
extern PyObject* gNullPtrObject;
 
extern std::set<std::string> gIteratorTypes;
} // namespace cppjit::cpyrt
 
//- helpers ------------------------------------------------------------------
namespace {
 
#ifdef WITH_THREAD
class GILControl {
public:
  GILControl() : fSave(PyEval_SaveThread()) {}
  ~GILControl() { PyEval_RestoreThread(fSave); }
 
private:
  PyThreadState* fSave;
};
#endif
 
} // unnamed namespace
 
#ifdef WITH_THREAD
#define CPPJIT_IMPL_GILCALL(rtype, tcode)                                      \
  static inline rtype GILCall##tcode(interop::TCppMethod_t method,             \
                                     interop::TCppObject_t self,               \
                                     cpyrt::CallContext* ctxt) {               \
    if (!ReleasesGIL(ctxt))                                                    \
      return interop::Call##tcode(method, self, ctxt->GetEncodedSize(),        \
                                  ctxt->GetArgs());                            \
    GILControl gc{};                                                           \
    return interop::Call##tcode(method, self, ctxt->GetEncodedSize(),          \
                                ctxt->GetArgs());                              \
  }
#else
#define CPPJIT_IMPL_GILCALL(rtype, tcode)                                      \
  static inline rtype GILCall##tcode(interop::TCppMethod_t method,             \
                                     interop::TCppObject_t self,               \
                                     cpyrt::CallContext* ctxt) {               \
    return interop::Call##tcode(method, self, ctxt->GetEncodedSize(),          \
                                ctxt->GetArgs());                              \
  }
#endif
 
// clang-format off
CPPJIT_IMPL_GILCALL(void,           V)
CPPJIT_IMPL_GILCALL(unsigned char,  B)
CPPJIT_IMPL_GILCALL(char,           C)
CPPJIT_IMPL_GILCALL(short,          H)
CPPJIT_IMPL_GILCALL(int,            I)
CPPJIT_IMPL_GILCALL(long,           L)
CPPJIT_IMPL_GILCALL(PY_LONG_LONG,   LL)
CPPJIT_IMPL_GILCALL(float,          F)
CPPJIT_IMPL_GILCALL(double,         D)
CPPJIT_IMPL_GILCALL(PY_LONG_DOUBLE, LD)
CPPJIT_IMPL_GILCALL(void*,          R)
// clang-format on
 
static inline interop::TCppObject_t GILCallO(interop::TCppMethod_t method,
                                             interop::TCppObject_t self,
                                             cpyrt::CallContext* ctxt,
                                             interop::TCppScope_t klass) {
  interop::TCppType_t klass_ty = interop::GetTypeFromScope(klass);
#ifdef WITH_THREAD
  if (!ReleasesGIL(ctxt))
#endif
    return interop::CallO(method, self, ctxt->GetEncodedSize(), ctxt->GetArgs(),
                          klass_ty);
#ifdef WITH_THREAD
  GILControl gc{};
  return interop::CallO(method, self, ctxt->GetEncodedSize(), ctxt->GetArgs(),
                        klass_ty);
#endif
}
 
static inline interop::TCppObject_t
GILCallConstructor(interop::TCppMethod_t method, interop::TCppScope_t klass,
                   cpyrt::CallContext* ctxt) {
#ifdef WITH_THREAD
  if (!ReleasesGIL(ctxt))
#endif
    return interop::CallConstructor(method, klass, ctxt->GetEncodedSize(),
                                    ctxt->GetArgs());
#ifdef WITH_THREAD
  GILControl gc{};
  return interop::CallConstructor(method, klass, ctxt->GetEncodedSize(),
                                  ctxt->GetArgs());
#endif
}
 
static inline PyObject* cpyrt_PyText_FromLong(long cl) {
  // python chars are range(256)
  if (cl < -256 || cl > 255) {
    PyErr_SetString(PyExc_ValueError, "char conversion out of range");
    return nullptr;
  }
  int c = (int)cl;
  if (c < 0)
    return PyUnicode_FromFormat("%c", 256 - std::abs(c));
  return PyUnicode_FromFormat("%c", c);
}
 
static inline PyObject* cpyrt_PyText_FromULong(unsigned long uc) {
  // TODO: range check here?
  if (255 < uc) {
    PyErr_SetString(PyExc_ValueError, "char conversion out of range");
    return nullptr;
  }
  int c = (int)uc;
  return PyUnicode_FromFormat("%c", c);
}
 
static inline PyObject* cpyrt_PyBool_FromLong(long b) {
  PyObject* result = (bool)b ? Py_True : Py_False;
  Py_INCREF(result);
  return result;
}
 
//- base executor implementation ---------------------------------------------
cpyrt::Executor::~Executor() { /* empty */ }
 
//- executors for built-ins --------------------------------------------------
PyObject* cpyrt::BoolExecutor::Execute(interop::TCppMethod_t method,
                                       interop::TCppObject_t self,
                                       CallContext* ctxt) {
  // execute <method> with argument <self, ctxt>, construct python bool return
  // value
  bool retval = GILCallB(method, self, ctxt);
  PyObject* result = retval ? Py_True : Py_False;
  Py_INCREF(result);
  return result;
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::BoolConstRefExecutor::Execute(interop::TCppMethod_t method,
                                               interop::TCppObject_t self,
                                               CallContext* ctxt) {
  // execute <method> with argument <self, ctxt>, construct python bool return
  // value
  return cpyrt_PyBool_FromLong(*((bool*)GILCallR(method, self, ctxt)));
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::CharExecutor::Execute(interop::TCppMethod_t method,
                                       interop::TCppObject_t self,
                                       CallContext* ctxt) {
  // execute <method with argument <self, ctxt>, construct python string return
  // value with the single char
  return cpyrt_PyText_FromLong((int)GILCallC(method, self, ctxt));
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::CharConstRefExecutor::Execute(interop::TCppMethod_t method,
                                               interop::TCppObject_t self,
                                               CallContext* ctxt) {
  // execute <method> with argument <self, ctxt>, construct python string return
  // value with the single char
  return cpyrt_PyText_FromLong(*((char*)GILCallR(method, self, ctxt)));
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::UCharExecutor::Execute(interop::TCppMethod_t method,
                                        interop::TCppObject_t self,
                                        CallContext* ctxt) {
  // execute <method> with argument <self, args>, construct python string return
  // value with the single char
  return cpyrt_PyText_FromLong((unsigned char)GILCallB(method, self, ctxt));
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::UCharConstRefExecutor::Execute(interop::TCppMethod_t method,
                                                interop::TCppObject_t self,
                                                CallContext* ctxt) {
  // execute <method> with argument <self, ctxt>, construct python string return
  // value with the single char from the pointer return
  return cpyrt_PyText_FromLong(*((unsigned char*)GILCallR(method, self, ctxt)));
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::Int8ConstRefExecutor::Execute(interop::TCppMethod_t method,
                                               interop::TCppObject_t self,
                                               CallContext* ctxt) {
  return PyLong_FromLong(*((int8_t*)GILCallR(method, self, ctxt)));
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::UInt8ConstRefExecutor::Execute(interop::TCppMethod_t method,
                                                interop::TCppObject_t self,
                                                CallContext* ctxt) {
  return PyLong_FromLong(*((uint8_t*)GILCallR(method, self, ctxt)));
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::WCharExecutor::Execute(interop::TCppMethod_t method,
                                        interop::TCppObject_t self,
                                        CallContext* ctxt) {
  // execute <method> with argument <self, args>, construct python string return
  // value with the single wide char
  wchar_t res = (wchar_t)GILCallL(method, self, ctxt);
  return PyUnicode_FromWideChar(&res, 1);
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::Char16Executor::Execute(interop::TCppMethod_t method,
                                         interop::TCppObject_t self,
                                         CallContext* ctxt) {
  // execute <method> with argument <self, args>, construct python string return
  // value with the single char16
  char16_t res = (char16_t)GILCallL(method, self, ctxt);
  return PyUnicode_DecodeUTF16((const char*)&res, sizeof(char16_t), nullptr,
                               nullptr);
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::Char32Executor::Execute(interop::TCppMethod_t method,
                                         interop::TCppObject_t self,
                                         CallContext* ctxt) {
  // execute <method> with argument <self, args>, construct python string return
  // value with the single char32
  char32_t res = (char32_t)GILCallL(method, self, ctxt);
  return PyUnicode_DecodeUTF32((const char*)&res, sizeof(char32_t), nullptr,
                               nullptr);
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::IntExecutor::Execute(interop::TCppMethod_t method,
                                      interop::TCppObject_t self,
                                      CallContext* ctxt) {
  // execute <method> with argument <self, ctxt>, construct python int return
  // value
  return PyLong_FromLong((int)GILCallI(method, self, ctxt));
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::Int8Executor::Execute(interop::TCppMethod_t method,
                                       interop::TCppObject_t self,
                                       CallContext* ctxt) {
  // execute <method> with argument <self, ctxt>, construct python int return
  // value
  return PyLong_FromLong((int8_t)GILCallC(method, self, ctxt));
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::UInt8Executor::Execute(interop::TCppMethod_t method,
                                        interop::TCppObject_t self,
                                        CallContext* ctxt) {
  // execute <method> with argument <self, ctxt>, construct python int return
  // value
  return PyLong_FromLong((uint8_t)GILCallB(method, self, ctxt));
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::ShortExecutor::Execute(interop::TCppMethod_t method,
                                        interop::TCppObject_t self,
                                        CallContext* ctxt) {
  // execute <method> with argument <self, ctxt>, construct python int return
  // value
  return PyLong_FromLong((short)GILCallH(method, self, ctxt));
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::LongExecutor::Execute(interop::TCppMethod_t method,
                                       interop::TCppObject_t self,
                                       CallContext* ctxt) {
  // execute <method> with argument <self, ctxt>, construct python long return
  // value
  return PyLong_FromLong((long)GILCallL(method, self, ctxt));
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::ULongExecutor::Execute(interop::TCppMethod_t method,
                                        interop::TCppObject_t self,
                                        CallContext* ctxt) {
  // execute <method> with argument <self, ctxt>, construct python unsigned long
  // return value
  return PyLong_FromUnsignedLong((unsigned long)GILCallLL(method, self, ctxt));
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::LongLongExecutor::Execute(interop::TCppMethod_t method,
                                           interop::TCppObject_t self,
                                           CallContext* ctxt) {
  // execute <method> with argument <self, ctxt>, construct python long long
  // return value
  PY_LONG_LONG result = GILCallLL(method, self, ctxt);
  return PyLong_FromLongLong(result);
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::ULongLongExecutor::Execute(interop::TCppMethod_t method,
                                            interop::TCppObject_t self,
                                            CallContext* ctxt) {
  // execute <method> with argument <self, ctxt>, construct python unsigned long
  // long return value
  PY_ULONG_LONG result = (PY_ULONG_LONG)GILCallLL(method, self, ctxt);
  return PyLong_FromUnsignedLongLong(result);
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::FloatExecutor::Execute(interop::TCppMethod_t method,
                                        interop::TCppObject_t self,
                                        CallContext* ctxt) {
  // execute <method> with argument <self, ctxt>, construct python float return
  // value
  return PyFloat_FromDouble((double)GILCallF(method, self, ctxt));
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::DoubleExecutor::Execute(interop::TCppMethod_t method,
                                         interop::TCppObject_t self,
                                         CallContext* ctxt) {
  // execute <method> with argument <self, ctxt>, construct python float return
  // value
  return PyFloat_FromDouble((double)GILCallD(method, self, ctxt));
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::LongDoubleExecutor::Execute(interop::TCppMethod_t method,
                                             interop::TCppObject_t self,
                                             CallContext* ctxt) {
  // execute <method> with argument <self, ctxt>, construct python float return
  // value
  return PyFloat_FromDouble((double)GILCallLD(method, self, ctxt));
}
 
//----------------------------------------------------------------------------
bool cpyrt::RefExecutor::SetAssignable(PyObject* pyobject) {
  // prepare "buffer" for by-ref returns, used with __setitem__
  if (pyobject) {
    Py_INCREF(pyobject);
    fAssignable = pyobject;
    return true;
  }
 
  fAssignable = nullptr;
  return false;
}
 
//----------------------------------------------------------------------------
#define CPPJIT_IMPL_REFEXEC(name, type, stype, F1, F2)                         \
  PyObject* cpyrt::name##RefExecutor::Execute(interop::TCppMethod_t method,    \
                                              interop::TCppObject_t self,      \
                                              CallContext* ctxt) {             \
    type* ref = (type*)GILCallR(method, self, ctxt);                           \
    if (!ref) { /* can happen if wrapper compilation fails */                  \
      PyErr_SetString(PyExc_ReferenceError,                                    \
                      "attempt to access a null-pointer");                     \
      return nullptr;                                                          \
    }                                                                          \
    if (!fAssignable)                                                          \
      return F1((stype) * ref);                                                \
    else {                                                                     \
      *ref = (type)F2(fAssignable);                                            \
      Py_DECREF(fAssignable);                                                  \
      fAssignable = nullptr;                                                   \
      if (*ref == (type) - 1 && PyErr_Occurred())                              \
        return nullptr;                                                        \
      Py_INCREF(Py_None);                                                      \
      return Py_None;                                                          \
    }                                                                          \
  }
 
// clang-format off
CPPJIT_IMPL_REFEXEC(Bool,       bool,           long,           cpyrt_PyBool_FromLong,    PyLong_AsLong)
CPPJIT_IMPL_REFEXEC(Char,       char,           long,           cpyrt_PyText_FromLong,    PyLong_AsLong)
CPPJIT_IMPL_REFEXEC(UChar,      unsigned char,  unsigned long,  cpyrt_PyText_FromULong,   PyLongOrInt_AsULong)
CPPJIT_IMPL_REFEXEC(Int8,       int8_t,         long,           PyLong_FromLong,              PyLong_AsLong)
CPPJIT_IMPL_REFEXEC(UInt8,      uint8_t,        unsigned long,  PyLong_FromLong,              PyLongOrInt_AsULong)
CPPJIT_IMPL_REFEXEC(Short,      short,          long,           PyLong_FromLong,              PyLong_AsLong)
CPPJIT_IMPL_REFEXEC(UShort,     unsigned short, unsigned long,  PyLong_FromLong,              PyLongOrInt_AsULong)
CPPJIT_IMPL_REFEXEC(Int,        int,            long,           PyLong_FromLong,              PyLong_AsLong)
CPPJIT_IMPL_REFEXEC(UInt,       unsigned int,   unsigned long,  PyLong_FromUnsignedLong,     PyLongOrInt_AsULong)
CPPJIT_IMPL_REFEXEC(Long,       long,           long,           PyLong_FromLong,             PyLong_AsLong)
CPPJIT_IMPL_REFEXEC(ULong,      unsigned long,  unsigned long,  PyLong_FromUnsignedLong,     PyLongOrInt_AsULong)
CPPJIT_IMPL_REFEXEC(LongLong,   PY_LONG_LONG,   PY_LONG_LONG,   PyLong_FromLongLong,         PyLong_AsLongLong)
CPPJIT_IMPL_REFEXEC(ULongLong,  PY_ULONG_LONG,  PY_ULONG_LONG,  PyLong_FromUnsignedLongLong, PyLongOrInt_AsULong64)
CPPJIT_IMPL_REFEXEC(Float,      float,          double,         PyFloat_FromDouble,          PyFloat_AsDouble)
CPPJIT_IMPL_REFEXEC(Double,     double,         double,         PyFloat_FromDouble,          PyFloat_AsDouble)
CPPJIT_IMPL_REFEXEC(LongDouble, PY_LONG_DOUBLE, PY_LONG_DOUBLE, PyFloat_FromDouble,          PyFloat_AsDouble)
// clang-format on
 
template <typename T>
static inline PyObject* PyComplex_FromComplex(const std::complex<T>& c) {
  return PyComplex_FromDoubles(c.real(), c.imag());
}
 
template <typename T>
static inline std::complex<T> PyComplex_AsComplex(PyObject* pycplx) {
  Py_complex cplx = PyComplex_AsCComplex(pycplx);
  return std::complex<T>(cplx.real, cplx.imag);
}
 
CPPJIT_IMPL_REFEXEC(ComplexD, std::complex<double>, std::complex<double>,
                    PyComplex_FromComplex<double>, PyComplex_AsComplex<double>)
 
//----------------------------------------------------------------------------
PyObject* cpyrt::STLStringRefExecutor::Execute(interop::TCppMethod_t method,
                                               interop::TCppObject_t self,
                                               CallContext* ctxt) {
  // execute <method> with argument <self, ctxt>, return python string return
  // value
  std::string* result = (std::string*)GILCallR(method, self, ctxt);
  if (!fAssignable) {
    return PyUnicode_FromStringAndSize(result->c_str(), result->size());
  }
 
  if (!PyUnicode_Check(fAssignable)) {
    PyErr_Format(PyExc_TypeError, "wrong type in assignment (string expected)");
    return nullptr;
  }
 
  *result = std::string(PyUnicode_AsUTF8(fAssignable),
                        PyUnicode_GET_LENGTH(fAssignable));
 
  Py_DECREF(fAssignable);
  fAssignable = nullptr;
 
  Py_RETURN_NONE;
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::VoidExecutor::Execute(interop::TCppMethod_t method,
                                       interop::TCppObject_t self,
                                       CallContext* ctxt) {
  // execute <method> with argument <self, ctxt>, return None
  GILCallV(method, self, ctxt);
  if (PyErr_Occurred())
    return nullptr;
  Py_RETURN_NONE;
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::CStringExecutor::Execute(interop::TCppMethod_t method,
                                          interop::TCppObject_t self,
                                          CallContext* ctxt) {
  // execute <method> with argument <self, ctxt>, construct python string return
  // value
  char* result = (char*)GILCallR(method, self, ctxt);
  if (!result) {
    Py_INCREF(PyStrings::gEmptyString);
    return PyStrings::gEmptyString;
  }
 
  return PyUnicode_FromString(result);
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::CStringRefExecutor::Execute(interop::TCppMethod_t method,
                                             interop::TCppObject_t self,
                                             CallContext* ctxt) {
  // execute <method> with argument <self, ctxt>, construct python string return
  // value
  char** result = (char**)GILCallR(method, self, ctxt);
  if (!result || !*result) {
    Py_INCREF(PyStrings::gEmptyString);
    return PyStrings::gEmptyString;
  }
 
  return PyUnicode_FromString(*result);
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::WCStringExecutor::Execute(interop::TCppMethod_t method,
                                           interop::TCppObject_t self,
                                           CallContext* ctxt) {
  // execute <method> with argument <self, ctxt>, construct python unicode
  // return value
  wchar_t* result = (wchar_t*)GILCallR(method, self, ctxt);
  if (!result) {
    wchar_t w = L'\0';
    return PyUnicode_FromWideChar(&w, 0);
  }
 
  return PyUnicode_FromWideChar(result, wcslen(result));
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::CString16Executor::Execute(interop::TCppMethod_t method,
                                            interop::TCppObject_t self,
                                            CallContext* ctxt) {
  // execute <method> with argument <self, ctxt>, construct python unicode
  // return value
  char16_t* result = (char16_t*)GILCallR(method, self, ctxt);
  if (!result) {
    char16_t w = u'\0';
    return PyUnicode_DecodeUTF16((const char*)&w, 0, nullptr, nullptr);
  }
 
  return PyUnicode_DecodeUTF16((const char*)result,
                               std::char_traits<char16_t>::length(result) *
                                   sizeof(char16_t),
                               nullptr, nullptr);
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::CString32Executor::Execute(interop::TCppMethod_t method,
                                            interop::TCppObject_t self,
                                            CallContext* ctxt) {
  // execute <method> with argument <self, ctxt>, construct python unicode
  // return value
  char32_t* result = (char32_t*)GILCallR(method, self, ctxt);
  if (!result) {
    char32_t w = U'\0';
    return PyUnicode_DecodeUTF32((const char*)&w, 0, nullptr, nullptr);
  }
 
  return PyUnicode_DecodeUTF32((const char*)result,
                               std::char_traits<char32_t>::length(result) *
                                   sizeof(char32_t),
                               nullptr, nullptr);
}
 
//- pointer/array executors --------------------------------------------------
PyObject* cpyrt::VoidArrayExecutor::Execute(interop::TCppMethod_t method,
                                            interop::TCppObject_t self,
                                            CallContext* ctxt) {
  // execute <method> with argument <self, ctxt>, construct python long return
  // value
  intptr_t* result = (intptr_t*)GILCallR(method, self, ctxt);
  if (!result) {
    Py_INCREF(gNullPtrObject);
    return gNullPtrObject;
  }
  return CreatePointerView(result, fShape);
}
 
//----------------------------------------------------------------------------
#define CPPJIT_IMPL_ARRAY_EXEC(name, type, suffix)                             \
  PyObject* cpyrt::name##ArrayExecutor::Execute(interop::TCppMethod_t method,  \
                                                interop::TCppObject_t self,    \
                                                CallContext* ctxt) {           \
    return CreateLowLevelView##suffix((type*)GILCallR(method, self, ctxt),     \
                                      fShape);                                 \
  }
 
// clang-format off
CPPJIT_IMPL_ARRAY_EXEC(Bool,     bool,                    )
CPPJIT_IMPL_ARRAY_EXEC(SChar,    signed char,             )
CPPJIT_IMPL_ARRAY_EXEC(UChar,    unsigned char,           )
CPPJIT_IMPL_ARRAY_EXEC(Byte,     std::byte,               )
CPPJIT_IMPL_ARRAY_EXEC(Int8,     int8_t,               _i8)
CPPJIT_IMPL_ARRAY_EXEC(UInt8,    uint8_t,              _i8)
CPPJIT_IMPL_ARRAY_EXEC(Short,    short,                   )
CPPJIT_IMPL_ARRAY_EXEC(UShort,   unsigned short,          )
CPPJIT_IMPL_ARRAY_EXEC(Int,      int,                     )
CPPJIT_IMPL_ARRAY_EXEC(UInt,     unsigned int,            )
CPPJIT_IMPL_ARRAY_EXEC(Long,     long,                    )
CPPJIT_IMPL_ARRAY_EXEC(ULong,    unsigned long,           )
CPPJIT_IMPL_ARRAY_EXEC(LLong,    long long,               )
CPPJIT_IMPL_ARRAY_EXEC(ULLong,   unsigned long long,      )
CPPJIT_IMPL_ARRAY_EXEC(Float,    float,                   )
CPPJIT_IMPL_ARRAY_EXEC(Double,   double,                  )
CPPJIT_IMPL_ARRAY_EXEC(LDouble,  long double,             )
CPPJIT_IMPL_ARRAY_EXEC(ComplexF, std::complex<float>,     )
CPPJIT_IMPL_ARRAY_EXEC(ComplexD, std::complex<double>,    )
CPPJIT_IMPL_ARRAY_EXEC(ComplexI, std::complex<int>,       )
CPPJIT_IMPL_ARRAY_EXEC(ComplexL, std::complex<long>,      )
// clang-format on
 
//- special cases ------------------------------------------------------------
#define CPPJIT_COMPLEX_EXEC(code, type)                                        \
  PyObject* cpyrt::Complex##code##Executor::Execute(                           \
      interop::TCppMethod_t method, interop::TCppObject_t self,                \
      CallContext* ctxt) {                                                     \
    static interop::TCppScope_t scopeid =                                      \
        interop::GetScope("std::complex<" #type ">");                          \
    std::complex<type>* result =                                               \
        (std::complex<type>*)GILCallO(method, self, ctxt, scopeid).data;       \
    if (!result) {                                                             \
      PyErr_SetString(PyExc_ValueError,                                        \
                      "NULL result where temporary expected");                 \
      return nullptr;                                                          \
    }                                                                          \
                                                                               \
    PyObject* pyres = PyComplex_FromDoubles(result->real(), result->imag());   \
    ::operator delete(result); /* interop::CallO calls ::operator new */       \
    return pyres;                                                              \
  }
 
CPPJIT_COMPLEX_EXEC(D, double)
 
//----------------------------------------------------------------------------
PyObject* cpyrt::STLStringExecutor::Execute(interop::TCppMethod_t method,
                                            interop::TCppObject_t self,
                                            CallContext* ctxt) {
  // execute <method> with argument <self, ctxt>, construct python string return
  // value
 
  // TODO: make use of GILLCallS (?!)
  static interop::TCppScope_t sSTLStringScope =
      interop::GetFullScope("std::string");
  std::string* result =
      (std::string*)GILCallO(method, self, ctxt, sSTLStringScope).data;
  if (!result) {
    Py_INCREF(PyStrings::gEmptyString);
    return PyStrings::gEmptyString;
  }
  if (PyErr_Occurred()) {
    delete result;
    return nullptr;
  }
 
  PyObject* pyresult =
      PyUnicode_FromStringAndSize(result->c_str(), result->size());
  delete result; // interop::CallO allocates and constructs a string, so it must
                 // be properly destroyed
 
  return pyresult;
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::STLWStringExecutor::Execute(interop::TCppMethod_t method,
                                             interop::TCppObject_t self,
                                             CallContext* ctxt) {
  // execute <method> with argument <self, ctxt>, construct python string return
  // value
  static interop::TCppScope_t sSTLWStringScope =
      interop::GetFullScope("std::wstring");
  std::wstring* result =
      (std::wstring*)GILCallO(method, self, ctxt, sSTLWStringScope).data;
  if (!result) {
    wchar_t w = L'\0';
    return PyUnicode_FromWideChar(&w, 0);
  }
 
  PyObject* pyresult = PyUnicode_FromWideChar(result->c_str(), result->size());
  delete result; // interop::CallO allocates and constructs a string, so it must
                 // be properly destroyed
 
  return pyresult;
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::InstancePtrExecutor::Execute(interop::TCppMethod_t method,
                                              interop::TCppObject_t self,
                                              CallContext* ctxt) {
  // execute <method> with argument <self, ctxt>, construct python proxy object
  // return value
  return BindCppObject((void*)GILCallR(method, self, ctxt), fClass);
}
 
//----------------------------------------------------------------------------
cpyrt::InstanceExecutor::InstanceExecutor(interop::TCppScope_t klass)
    : fClass(klass), fFlags(CPPInstance::kIsValue | CPPInstance::kIsOwner) {
  /* empty */
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::InstanceExecutor::Execute(interop::TCppMethod_t method,
                                           interop::TCppObject_t self,
                                           CallContext* ctxt) {
  // execution will bring a temporary in existence
  interop::TCppObject_t value = GILCallO(method, self, ctxt, fClass);
 
  if (!value) {
    if (!PyErr_Occurred()) // callee may have set a python error itself
      PyErr_Format(PyExc_ValueError,
                   "cannot allocate the temporary returned by '%s': the size "
                   "of its return type is unknown",
                   interop::GetMethodSignature(method, true).c_str());
    return nullptr;
  }
 
  // the result can then be bound
  PyObject* pyobj = BindCppObjectNoCast(value, fClass, fFlags);
  if (!pyobj)
    return nullptr;
 
  // python ref counting will now control this object's life span; it will be
  // deleted b/c it is marked as a by-value object owned by python (from fFlags)
  return pyobj;
}
 
//----------------------------------------------------------------------------
cpyrt::IteratorExecutor::IteratorExecutor(interop::TCppScope_t klass)
    : InstanceExecutor(klass) {
  fFlags |= CPPInstance::kNoMemReg |
            CPPInstance::kNoWrapConv; // adds to flags from base class
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::InstanceRefExecutor::Execute(interop::TCppMethod_t method,
                                              interop::TCppObject_t self,
                                              CallContext* ctxt) {
  // executor binds the result to the left-hand side, overwriting if an old
  // object
  PyObject* result = BindCppObject((void*)GILCallR(method, self, ctxt), fClass);
  if (!result || !fAssignable)
    return result;
  else {
    // this generic code is quite slow compared to its C++ equivalent ...
    PyObject* assign = PyObject_GetAttr(result, PyStrings::gAssign);
    if (!assign) {
      PyErr_Clear();
      PyObject* descr = PyObject_Str(result);
      if (descr && PyUnicode_CheckExact(descr)) {
        PyErr_Format(PyExc_TypeError, "cannot assign to return object (%s)",
                     PyUnicode_AsUTF8(descr));
      } else {
        PyErr_SetString(PyExc_TypeError, "cannot assign to result");
      }
      Py_XDECREF(descr);
      Py_DECREF(result);
      Py_DECREF(fAssignable);
      fAssignable = nullptr;
      return nullptr;
    }
 
    PyObject* res2 =
        PyObject_CallFunction(assign, const_cast<char*>("O"), fAssignable);
 
    Py_DECREF(assign);
    Py_DECREF(result);
    Py_DECREF(fAssignable);
    fAssignable = nullptr;
 
    if (res2) {
      Py_DECREF(res2); // typically, *this from operator=()
      Py_RETURN_NONE;
    }
 
    return nullptr;
  }
}
 
//----------------------------------------------------------------------------
static inline PyObject* SetInstanceCheckError(PyObject* pyobj) {
  PyObject* pystr = PyObject_Str(pyobj);
  if (pystr) {
    PyErr_Format(PyExc_TypeError, "C++ object expected, got %s",
                 PyUnicode_AsUTF8(pystr));
    Py_DECREF(pystr);
  } else
    PyErr_SetString(PyExc_TypeError, "C++ object expected");
  return nullptr;
}
 
PyObject* cpyrt::InstancePtrPtrExecutor::Execute(interop::TCppMethod_t method,
                                                 interop::TCppObject_t self,
                                                 CallContext* ctxt) {
  // execute <method> with argument <self, ctxt>, construct python C++ proxy
  // object return ptr value
  if (fAssignable && !CPPInstance_Check(fAssignable))
    return SetInstanceCheckError(fAssignable);
 
  void** result = (void**)GILCallR(method, self, ctxt);
  if (!fAssignable)
    return BindCppObject((void*)result, fClass,
                         CPPInstance::kIsPtrPtr | CPPInstance::kIsReference);
 
  CPPInstance* cppinst = (CPPInstance*)fAssignable;
  *result = cppinst->GetObject();
 
  Py_DECREF(fAssignable);
  fAssignable = nullptr;
 
  Py_RETURN_NONE;
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::InstancePtrRefExecutor::Execute(interop::TCppMethod_t method,
                                                 interop::TCppObject_t self,
                                                 CallContext* ctxt) {
  // execute <method> with argument <self, ctxt>, construct python C++ proxy
  // object ignoring ref) return ptr value
  if (fAssignable && !CPPInstance_Check(fAssignable))
    return SetInstanceCheckError(fAssignable);
 
  void** result = (void**)GILCallR(method, self, ctxt);
  if (!fAssignable)
    return BindCppObject(*result, fClass);
 
  CPPInstance* cppinst = (CPPInstance*)fAssignable;
  *result = cppinst->GetObject();
 
  Py_DECREF(fAssignable);
  fAssignable = nullptr;
 
  Py_RETURN_NONE;
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::InstanceArrayExecutor::Execute(interop::TCppMethod_t method,
                                                interop::TCppObject_t self,
                                                CallContext* ctxt) {
  // execute <method> with argument <self, ctxt>, construct TupleOfInstances
  // from return value
  return BindCppObjectArray((void*)GILCallR(method, self, ctxt), fClass,
                            {fSize});
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::ConstructorExecutor::Execute(interop::TCppMethod_t method,
                                              interop::TCppObject_t klass,
                                              CallContext* ctxt) {
  // package return address in PyObject* for caller to handle appropriately (see
  // CPPConstructor for the actual build of the PyObject)
  return (PyObject*)GILCallConstructor(method, interop::TCppScope_t(klass.data),
                                       ctxt)
      .data;
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::PyObjectExecutor::Execute(interop::TCppMethod_t method,
                                           interop::TCppObject_t self,
                                           CallContext* ctxt) {
  // execute <method> with argument <self, ctxt>, return python object
  return (PyObject*)GILCallR(method, self, ctxt);
}
 
//----------------------------------------------------------------------------
PyObject* cpyrt::FunctionPointerExecutor::Execute(interop::TCppMethod_t method,
                                                  interop::TCppObject_t self,
                                                  CallContext* ctxt) {
  // execute <method> with argument <self, ctxt>, return std::function from func
  // ptr
 
  // A function pointer in clang is represented by a Type, not a FunctionDecl
  // and it's not possible to get the latter from the former: the backend will
  // need to support both. Since that is far in the future, we'll use a
  // std::function instead.
  void* address = (void*)GILCallR(method, self, ctxt);
  if (address)
    return Utility::FuncPtr2StdFunction(fRetType, fSignature, address);
 
  // There's currently now way to return a typed function nullptr, but given
  // that this is a return value (thus can not be set) and overloading function
  // based on function pointer return type is likely uncommon ...
  Py_INCREF(gNullPtrObject);
  return gNullPtrObject;
}
 
//- factories ----------------------------------------------------------------
cpyrt::Executor* cpyrt::CreateExecutor(const std::string& fullType,
                                       cdims_t dims) {
  // The matching of the fulltype to an executor factory goes through up to 4
  // levels:
  //   1) full, qualified match
  //   2) drop '&' as by ref/full type is often pretty much the same python-wise
  //   3) C++ classes, either by ref/ptr or by value
  //   4) additional special case for enums
  //
  // If all fails, void is used, which will cause the return type to be ignored
  // on use
 
  if (fullType.empty())
    return nullptr;
 
  // an exactly matching executor is best
  ExecFactories_t::iterator h = gExecFactories.find(fullType);
  if (h != gExecFactories.end())
    return (h->second)(dims);
 
  // resolve typedefs etc.
  const std::string resolvedType = interop::ResolveName(fullType);
 
  // a full, qualified matching executor is preferred
  if (resolvedType != fullType) {
    h = gExecFactories.find(resolvedType);
    if (h != gExecFactories.end())
      return (h->second)(dims);
  }
 
  //-- nothing? ok, collect information about the type and possible
  // qualifiers/decorators
  bool isConst = strncmp(resolvedType.c_str(), "const", 5) == 0;
  const std::string& cpd = TypeManip::compound(resolvedType);
  std::string realType = TypeManip::clean_type(resolvedType, false);
 
  // accept unqualified type (as python does not know about qualifiers)
  h = gExecFactories.find(realType + cpd);
  if (h != gExecFactories.end())
    return (h->second)(dims);
 
  // drop const, as that is mostly meaningless to python (with the exception
  // of c-strings, but those are specialized in the converter map)
  if (isConst) {
    realType = TypeManip::remove_const(realType);
    h = gExecFactories.find(realType + cpd);
    if (h != gExecFactories.end())
      return (h->second)(dims);
  }
 
  // simple array types
  if (!cpd.empty() && (std::string::size_type)std::count(cpd.begin(), cpd.end(),
                                                         '*') == cpd.size()) {
    h = gExecFactories.find(realType + " ptr");
    if (h != gExecFactories.end())
      return (h->second)((!dims || dims.ndim() < (dim_t)cpd.size())
                             ? dims_t(cpd.size())
                             : dims);
  }
 
  //-- still nothing? try pointer instead of array (for builtins)
  if (cpd == "[]") {
    h = gExecFactories.find(realType + "*");
    if (h != gExecFactories.end())
      return (h->second)(dims);
  }
 
  // C++ classes and special cases
  Executor* result = 0;
  if (interop::TCppScope_t klass = interop::GetFullScope(realType)) {
    if (Utility::IsSTLIterator(realType) ||
        gIteratorTypes.find(fullType) != gIteratorTypes.end()) {
      if (cpd == "")
        return new IteratorExecutor(klass);
    }
 
    if (cpd == "")
      result = new InstanceExecutor(klass);
    else if (cpd == "&")
      result = new InstanceRefExecutor(klass);
    else if (cpd == "**" || cpd == "*[]" || cpd == "&*")
      result = new InstancePtrPtrExecutor(klass);
    else if (cpd == "*&")
      result = new InstancePtrRefExecutor(klass);
    else if (cpd == "[]") {
      Py_ssize_t asize = TypeManip::array_size(resolvedType);
      if (0 < asize)
        result = new InstanceArrayExecutor(klass, asize);
      else
        result = new InstancePtrRefExecutor(klass);
    } else
      result = new InstancePtrExecutor(klass);
  } else if (resolvedType.find("(*)") != std::string::npos ||
             (resolvedType.find("::*)") != std::string::npos)) {
    // this is a function pointer
    // TODO: find better way of finding the type
    auto pos1 = resolvedType.find('(');
    auto pos2 = resolvedType.find("*)");
    auto pos3 = resolvedType.rfind(')');
    result = new FunctionPointerExecutor(
        resolvedType.substr(0, pos1),
        resolvedType.substr(pos2 + 2, pos3 - pos2 - 1));
  } else {
    // unknown: void* may work ("user knows best"), void will fail on use of
    // return value
    h = (cpd == "") ? gExecFactories.find("void")
                    : gExecFactories.find("void ptr");
  }
 
  if (!result && h != gExecFactories.end())
    // executor factory available, use it to create executor
    result = (h->second)(dims);
 
  return result; // may still be null
}
 
cpyrt::Executor* cpyrt::CreateExecutor(interop::TCppType_t type, cdims_t dims) {
  // The matching of the fulltype to an executor factory goes through up to 4
  // levels:
  //   1) full, qualified match
  //   2) drop '&' as by ref/full type is often pretty much the same python-wise
  //   3) C++ classes, either by ref/ptr or by value
  //   4) additional special case for enums
  //
  // If all fails, void is used, which will cause the return type to be ignored
  // on use
 
  // an exactly matching executor is best
  std::string fullType = interop::GetTypeAsString(type);
  if (fullType.size() >= 2 &&
      fullType.compare(fullType.size() - 2, 2, " &") == 0)
    fullType = fullType.substr(0, fullType.size() - 2) + "&";
 
  ExecFactories_t::iterator h = gExecFactories.find(fullType);
  if (h != gExecFactories.end())
    return (h->second)(dims);
 
  // resolve typedefs etc.
  interop::TCppType_t resolvedType = interop::ResolveType(type);
  {
    // if resolvedType is a reference to enum
    // then it should be reduced to reference
    // to the underlying interger
    resolvedType = interop::ResolveEnumReferenceType(resolvedType);
    // similarly for pointers
    resolvedType = interop::ResolveEnumPointerType(resolvedType);
  }
  // FIXME: avoid string comparisons and parsing
  std::string resolvedTypeStr = interop::GetTypeAsString(resolvedType);
  if (interop::IsFunctionPointerType(resolvedType)) {
    resolvedTypeStr.erase(
        std::remove(resolvedTypeStr.begin(), resolvedTypeStr.end(), ' '),
        resolvedTypeStr.end());
    if (resolvedTypeStr.rfind("(void)") != std::string::npos)
      resolvedTypeStr =
          resolvedTypeStr.substr(0, resolvedTypeStr.size() - 6) + "()";
  }
 
  // a full, qualified matching executor is preferred
  if (resolvedTypeStr != fullType) {
    h = gExecFactories.find(resolvedTypeStr);
    if (h != gExecFactories.end())
      return (h->second)(dims);
  }
 
  //-- nothing? ok, collect information about the type and possible
  // qualifiers/decorators
  bool isConst = strncmp(resolvedTypeStr.c_str(), "const", 5) == 0;
  const std::string& cpd = TypeManip::compound(resolvedTypeStr);
  interop::TCppType_t realType = interop::IsFunctionPointerType(resolvedType)
                                     ? resolvedType
                                     : interop::GetRealType(resolvedType);
  std::string realTypeStr = interop::IsFunctionPointerType(resolvedType)
                                ? resolvedTypeStr
                                : interop::GetTypeAsString(realType);
  const std::string compounded = cpd.empty() ? realTypeStr : realTypeStr + cpd;
 
  // accept unqualified type (as python does not know about qualifiers)
  h = gExecFactories.find(compounded);
  if (h != gExecFactories.end())
    return (h->second)(dims);
 
  // drop const, as that is mostly meaningless to python (with the exception
  // of c-strings, but those are specialized in the converter map)
  if (isConst) {
    realTypeStr = TypeManip::remove_const(realTypeStr);
    h = gExecFactories.find(compounded);
    if (h != gExecFactories.end())
      return (h->second)(dims);
  }
 
  // simple array types
  if (!cpd.empty() && (std::string::size_type)std::count(cpd.begin(), cpd.end(),
                                                         '*') == cpd.size()) {
    h = gExecFactories.find(realTypeStr + " ptr");
    if (h != gExecFactories.end())
      return (h->second)((!dims || dims.ndim() < (dim_t)cpd.size())
                             ? dims_t(cpd.size())
                             : dims);
  }
 
  //-- still nothing? try pointer instead of array (for builtins)
  if (cpd == "[]") {
    h = gExecFactories.find(realTypeStr + "*");
    if (h != gExecFactories.end())
      return (h->second)(dims);
  }
 
  // C++ classes and special cases
  Executor* result = 0;
  if (interop::IsClassType(realType)) {
    interop::TCppScope_t klass = interop::GetScopeFromType(realType);
    if (resolvedTypeStr.find("iterator") != std::string::npos ||
        gIteratorTypes.find(fullType) != gIteratorTypes.end()) {
      if (cpd == "")
        return new IteratorExecutor(klass);
    }
 
    if (cpd == "")
      result = new InstanceExecutor(klass);
    else if (cpd == "&")
      result = new InstanceRefExecutor(klass);
    else if (cpd == "**" || cpd == "*[]" || cpd == "&*")
      result = new InstancePtrPtrExecutor(klass);
    else if (cpd == "*&")
      result = new InstancePtrRefExecutor(klass);
    else if (cpd == "[]") {
      Py_ssize_t asize = TypeManip::array_size(resolvedTypeStr);
      if (0 < asize)
        result = new InstanceArrayExecutor(klass, asize);
      else
        result = new InstancePtrRefExecutor(klass);
    } else
      result = new InstancePtrExecutor(klass);
  } else if (realTypeStr.find("(*)") != std::string::npos ||
             (realTypeStr.find("::*)") != std::string::npos)) {
    // this is a function pointer
    // TODO: find better way of finding the type
    auto pos1 = realTypeStr.find('(');
    auto pos2 = realTypeStr.find("*)");
    auto pos3 = realTypeStr.rfind(')');
    result = new FunctionPointerExecutor(
        realTypeStr.substr(0, pos1),
        realTypeStr.substr(pos2 + 2, pos3 - pos2 - 1));
  } else {
    // unknown: void* may work ("user knows best"), void will fail on use of
    // return value
    h = (cpd == "") ? gExecFactories.find("void")
                    : gExecFactories.find("void ptr");
  }
 
  if (!result && h != gExecFactories.end())
    // executor factory available, use it to create executor
    result = (h->second)(dims);
 
  return result; // may still be null
}
 
//----------------------------------------------------------------------------
CPYRT_EXPORT
void cpyrt::DestroyExecutor(Executor* p) {
  if (p && p->HasState())
    delete p; // state-less executors are always shared
}
 
//----------------------------------------------------------------------------
CPYRT_EXPORT
bool cpyrt::RegisterExecutor(const std::string& name, ef_t fac) {
  // register a custom executor
  auto f = gExecFactories.find(name);
  if (f != gExecFactories.end())
    return false;
 
  gExecFactories[name] = fac;
  return true;
}
 
//----------------------------------------------------------------------------
CPYRT_EXPORT
bool cpyrt::RegisterExecutorAlias(const std::string& name,
                                  const std::string& target) {
  // register a custom executor that is a reference to an existing converter
  auto f = gExecFactories.find(name);
  if (f != gExecFactories.end())
    return false;
 
  auto t = gExecFactories.find(target);
  if (t == gExecFactories.end())
    return false;
 
  gExecFactories[name] = t->second;
  return true;
}
 
//----------------------------------------------------------------------------
CPYRT_EXPORT
bool cpyrt::UnregisterExecutor(const std::string& name) {
  // remove a custom executor
  auto f = gExecFactories.find(name);
  if (f != gExecFactories.end()) {
    gExecFactories.erase(f);
    return true;
  }
  return false;
}
 
//----------------------------------------------------------------------------
CPYRT_EXPORT
void* cpyrt::CallVoidP(interop::TCppMethod_t meth, interop::TCppObject_t obj,
                       CallContext* ctxt) {
  return GILCallR(meth, obj, ctxt);
}
 
//----------------------------------------------------------------------------
namespace {
 
using namespace cppjit::cpyrt;
 
#define WSTRING1 "std::basic_string<wchar_t>"
#define WSTRING2                                                               \
  "std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_"  \
  "t>>"
 
//-- aliasing special case: C complex (is binary compatible with C++
// std::complex)
#ifndef _WIN32
#define CCOMPLEX_D "_Complex double"
#define CCOMPLEX_F "_Complex float"
#else
#define CCOMPLEX_D "_C_double_complex"
#define CCOMPLEX_F "_C_float_complex"
#endif
 
struct InitExecFactories_t {
public:
  InitExecFactories_t() {
    // load all executor factories in the global map 'gExecFactories'
    cpyrt::ExecFactories_t& gf = gExecFactories;
 
    // factories for built-ins
    gf["bool"] = (ef_t) + [](cdims_t) {
      static BoolExecutor e{};
      return &e;
    };
    gf["bool&"] = (ef_t) + [](cdims_t) { return new BoolRefExecutor{}; };
    gf["const bool&"] = (ef_t) + [](cdims_t) {
      static BoolConstRefExecutor e{};
      return &e;
    };
    gf["char"] = (ef_t) + [](cdims_t) {
      static CharExecutor e{};
      return &e;
    };
    gf["signed char"] = gf["char"];
    gf["unsigned char"] = (ef_t) + [](cdims_t) {
      static UCharExecutor e{};
      return &e;
    };
    gf["char&"] = (ef_t) + [](cdims_t) { return new CharRefExecutor{}; };
    gf["signed char&"] = gf["char&"];
    gf["unsigned char&"] =
        (ef_t) + [](cdims_t) { return new UCharRefExecutor{}; };
    gf["const char&"] = (ef_t) + [](cdims_t) {
      static CharConstRefExecutor e{};
      return &e;
    };
    gf["const signed char&"] = gf["const char&"];
    gf["const unsigned char&"] = (ef_t) + [](cdims_t) {
      static UCharConstRefExecutor e{};
      return &e;
    };
    gf["wchar_t"] = (ef_t) + [](cdims_t) {
      static WCharExecutor e{};
      return &e;
    };
    gf["char16_t"] = (ef_t) + [](cdims_t) {
      static Char16Executor e{};
      return &e;
    };
    gf["char32_t"] = (ef_t) + [](cdims_t) {
      static Char32Executor e{};
      return &e;
    };
    gf["int8_t"] = (ef_t) + [](cdims_t) {
      static Int8Executor e{};
      return &e;
    };
    gf["int8_t&"] = (ef_t) + [](cdims_t) { return new Int8RefExecutor{}; };
    gf["const int8_t&"] = (ef_t) + [](cdims_t) {
      static Int8ConstRefExecutor e{};
      return &e;
    };
    gf["uint8_t"] = (ef_t) + [](cdims_t) {
      static UInt8Executor e{};
      return &e;
    };
    gf["uint8_t&"] = (ef_t) + [](cdims_t) { return new UInt8RefExecutor{}; };
    gf["const uint8_t&"] = (ef_t) + [](cdims_t) {
      static UInt8ConstRefExecutor e{};
      return &e;
    };
    gf["short"] = (ef_t) + [](cdims_t) {
      static ShortExecutor e{};
      return &e;
    };
    gf["short&"] = (ef_t) + [](cdims_t) { return new ShortRefExecutor{}; };
    gf["int"] = (ef_t) + [](cdims_t) {
      static IntExecutor e{};
      return &e;
    };
    gf["int&"] = (ef_t) + [](cdims_t) { return new IntRefExecutor{}; };
    gf["unsigned short"] = gf["int"];
    gf["unsigned short&"] =
        (ef_t) + [](cdims_t) { return new UShortRefExecutor{}; };
    gf["unsigned long"] = (ef_t) + [](cdims_t) {
      static ULongExecutor e{};
      return &e;
    };
    gf["unsigned long&"] =
        (ef_t) + [](cdims_t) { return new ULongRefExecutor{}; };
    gf["unsigned int"] = gf["unsigned long"];
    gf["unsigned int&"] =
        (ef_t) + [](cdims_t) { return new UIntRefExecutor{}; };
    gf["long"] = (ef_t) + [](cdims_t) {
      static LongExecutor e{};
      return &e;
    };
    gf["long&"] = (ef_t) + [](cdims_t) { return new LongRefExecutor{}; };
    gf["unsigned long"] = (ef_t) + [](cdims_t) {
      static ULongExecutor e{};
      return &e;
    };
    gf["unsigned long&"] =
        (ef_t) + [](cdims_t) { return new ULongRefExecutor{}; };
    gf["long long"] = (ef_t) + [](cdims_t) {
      static LongLongExecutor e{};
      return &e;
    };
    gf["long long&"] =
        (ef_t) + [](cdims_t) { return new LongLongRefExecutor{}; };
    gf["unsigned long long"] = (ef_t) + [](cdims_t) {
      static ULongLongExecutor e{};
      return &e;
    };
    gf["unsigned long long&"] =
        (ef_t) + [](cdims_t) { return new ULongLongRefExecutor{}; };
 
    gf["float"] = (ef_t) + [](cdims_t) {
      static FloatExecutor e{};
      return &e;
    };
    gf["float&"] = (ef_t) + [](cdims_t) { return new FloatRefExecutor{}; };
    gf["double"] = (ef_t) + [](cdims_t) {
      static DoubleExecutor e{};
      return &e;
    };
    gf["double&"] = (ef_t) + [](cdims_t) { return new DoubleRefExecutor{}; };
    gf["long double"] = (ef_t) + [](cdims_t) {
      static LongDoubleExecutor e{};
      return &e;
    }; // TODO: lost precision
    gf["long double&"] =
        (ef_t) + [](cdims_t) { return new LongDoubleRefExecutor{}; };
    gf["std::complex<double>"] = (ef_t) + [](cdims_t) {
      static ComplexDExecutor e{};
      return &e;
    };
    gf["std::complex<double>&"] =
        (ef_t) + [](cdims_t) { return new ComplexDRefExecutor{}; };
    gf["void"] = (ef_t) + [](cdims_t) {
      static VoidExecutor e{};
      return &e;
    };
 
    // pointer/array factories
    gf["void ptr"] =
        (ef_t) + [](cdims_t d) { return new VoidArrayExecutor{d}; };
    gf["bool ptr"] =
        (ef_t) + [](cdims_t d) { return new BoolArrayExecutor{d}; };
    gf["unsigned char ptr"] =
        (ef_t) + [](cdims_t d) { return new UCharArrayExecutor{d}; };
    gf["const unsigned char ptr"] = gf["unsigned char ptr"];
    gf["std::byte ptr"] =
        (ef_t) + [](cdims_t d) { return new ByteArrayExecutor{d}; };
    gf["const std::byte ptr"] = gf["std::byte ptr"];
    gf["int8_t ptr"] =
        (ef_t) + [](cdims_t d) { return new Int8ArrayExecutor{d}; };
    gf["uint8_t ptr"] =
        (ef_t) + [](cdims_t d) { return new UInt8ArrayExecutor{d}; };
    gf["short ptr"] =
        (ef_t) + [](cdims_t d) { return new ShortArrayExecutor{d}; };
    gf["unsigned short ptr"] =
        (ef_t) + [](cdims_t d) { return new UShortArrayExecutor{d}; };
    gf["int ptr"] = (ef_t) + [](cdims_t d) { return new IntArrayExecutor{d}; };
    gf["unsigned int ptr"] =
        (ef_t) + [](cdims_t d) { return new UIntArrayExecutor{d}; };
    gf["long ptr"] =
        (ef_t) + [](cdims_t d) { return new LongArrayExecutor{d}; };
    gf["unsigned long ptr"] =
        (ef_t) + [](cdims_t d) { return new ULongArrayExecutor{d}; };
    gf["long long ptr"] =
        (ef_t) + [](cdims_t d) { return new LLongArrayExecutor{d}; };
    gf["unsigned long long ptr"] =
        (ef_t) + [](cdims_t d) { return new ULLongArrayExecutor{d}; };
    gf["float ptr"] =
        (ef_t) + [](cdims_t d) { return new FloatArrayExecutor{d}; };
    gf["double ptr"] =
        (ef_t) + [](cdims_t d) { return new DoubleArrayExecutor{d}; };
    gf["long double ptr"] =
        (ef_t) + [](cdims_t d) { return new LDoubleArrayExecutor{d}; };
    gf["std::complex<float> ptr"] =
        (ef_t) + [](cdims_t d) { return new ComplexFArrayExecutor{d}; };
    gf["std::complex<double> ptr"] =
        (ef_t) + [](cdims_t d) { return new ComplexDArrayExecutor{d}; };
    gf["std::complex<int> ptr"] =
        (ef_t) + [](cdims_t d) { return new ComplexIArrayExecutor{d}; };
    gf["std::complex<long> ptr"] =
        (ef_t) + [](cdims_t d) { return new ComplexLArrayExecutor{d}; };
 
    // aliases
    gf["internal_enum_type_t"] = gf["int"];
    gf["internal_enum_type_t&"] = gf["int&"];
    gf["internal_enum_type_t ptr"] = gf["int ptr"];
    gf["std::byte"] = gf["uint8_t"];
    gf["std::byte&"] = gf["uint8_t&"];
    gf["const std::byte&"] = gf["const uint8_t&"];
    gf["const byte&"] = gf["const uint8_t&"];
    gf["std::int8_t"] = gf["int8_t"];
    gf["std::int8_t&"] = gf["int8_t&"];
    gf["const std::int8_t&"] = gf["const int8_t&"];
    gf["std::int8_t ptr"] = gf["int8_t ptr"];
    gf["std::uint8_t"] = gf["uint8_t"];
    gf["std::uint8_t&"] = gf["uint8_t&"];
    gf["const std::uint8_t&"] = gf["const uint8_t&"];
    gf["std::uint8_t ptr"] = gf["uint8_t ptr"];
#ifdef _WIN32
    gf["__int64"] = gf["long long"];
    gf["__int64&"] = gf["long long&"];
    gf["__int64 ptr"] = gf["long long ptr"];
    gf["unsigned __int64"] = gf["unsigned long long"];
    gf["unsigned __int64&"] = gf["unsigned long long&"];
    gf["unsigned __int64 ptr"] = gf["unsigned long long ptr"];
#endif
    gf[CCOMPLEX_D] = gf["std::complex<double>"];
    gf[CCOMPLEX_D "&"] = gf["std::complex<double>&"];
    gf[CCOMPLEX_F " ptr"] = gf["std::complex<float> ptr"];
    gf[CCOMPLEX_D " ptr"] = gf["std::complex<double> ptr"];
 
    // We always need these executors when cppjit is based on an unpatched
    // ROOT, because the "long long" types are always converted to Long64_t
    // and ULong64_t already at the ROOT Meta level.
    // See
    // https://github.com/root-project/root/issues/15872#issuecomment-2174092763
    gf["Long64_t"] = gf["long long"];
    gf["Long64_t&"] = gf["long long&"];
    gf["Long64_t ptr"] = gf["long long ptr"];
    gf["ULong64_t"] = gf["unsigned long long"];
    gf["ULong64_t&"] = gf["unsigned long long&"];
    gf["ULong64_t ptr"] = gf["unsigned long long ptr"];
 
    // factories for special cases
    gf["const char*"] = (ef_t) + [](cdims_t) {
      static CStringExecutor e{};
      return &e;
    };
    gf["char*"] = gf["const char*"];
    gf["const char*&"] = (ef_t) + [](cdims_t) {
      static CStringRefExecutor e{};
      return &e;
    };
    gf["char*&"] = gf["const char*&"];
    gf["const signed char*"] = gf["const char*"];
    // gf["signed char*"] =                gf["char*"];
    gf["signed char ptr"] =
        (ef_t) + [](cdims_t d) { return new SCharArrayExecutor{d}; };
    gf["wchar_t*"] = (ef_t) + [](cdims_t) {
      static WCStringExecutor e{};
      return &e;
    };
    gf["char16_t*"] = (ef_t) + [](cdims_t) {
      static CString16Executor e{};
      return &e;
    };
    gf["char32_t*"] = (ef_t) + [](cdims_t) {
      static CString32Executor e{};
      return &e;
    };
    gf["std::basic_string<char>"] = (ef_t) + [](cdims_t) {
      static STLStringExecutor e{};
      return &e;
    };
    gf["std::basic_string<char>&"] =
        (ef_t) + [](cdims_t) { return new STLStringRefExecutor{}; };
    gf["std::basic_string<wchar_t>"] = (ef_t) + [](cdims_t) {
      static STLWStringExecutor e{};
      return &e;
    };
    gf[WSTRING1] = gf["std::basic_string<wchar_t>"];
    gf[WSTRING2] = gf["std::basic_string<wchar_t>"];
    gf["__init__"] = (ef_t) + [](cdims_t) {
      static ConstructorExecutor e{};
      return &e;
    };
    gf["PyObject*"] = (ef_t) + [](cdims_t) {
      static PyObjectExecutor e{};
      return &e;
    };
    gf["_object*"] = gf["PyObject*"];
    gf["FILE*"] = gf["void ptr"];
  }
} initExecvFactories_;
 
} // unnamed namespace