Bump up CPyCppyy to latest upstream status

include/CPyCppyy/DispatchPtr.h

@@ -64,7 +64,7 @@ class CPYCPPYY_CLASS_EXTERN DispatchPtr {
     }
 
 private:
-    PyObject* Get() const;
+    PyObject* Get(bool borrowed=true) const;
 
 private:
     PyObject* fPyHardRef;

pyproject.toml

@@ -1,2 +1,2 @@
 [build-system]
-requires = ["cppyy-cling==6.28.0", "cppyy-backend==1.14.11", "setuptools", "wheel"]
+requires = ["cppyy-cling==6.32.8", "cppyy-backend==1.15.3", "setuptools", "wheel"]

setup.py

@@ -9,7 +9,7 @@
 except ImportError:
     has_wheel = False
 
-requirements = ['cppyy-cling==6.28.0', 'cppyy-backend==1.14.11']
+requirements = ['cppyy-cling==6.32.8', 'cppyy-backend==1.15.3']
 setup_requirements = ['wheel']
 if 'build' in sys.argv or 'install' in sys.argv:
     setup_requirements += requirements
@@ -80,7 +80,7 @@ def build_extension(self, ext):
 
 setup(
     name='CPyCppyy',
-    version='1.12.13',
+    version='1.13.0',
     description='Cling-based Python-C++ bindings for CPython',
     long_description=long_description,
 

src/API.cxx

@@ -430,7 +430,16 @@ void CPyCppyy::ExecScript(const std::string& name, const std::vector<std::string
                           << std::endl;
             }
          };
+
+#if PY_VERSION_HEX < 0x30d00f0
          WideStringListAppendHelper(&fConfig.argv, Py_GetProgramName());
+#else
+         PyObject* progname = PySys_GetObject("executable");    // borrowed
+         wchar_t buf[4096];
+         Py_ssize_t sz = CPyCppyy_PyUnicode_AsWideChar(progname, buf, 4095);
+         if (0 < sz)
+             WideStringListAppendHelper(&fConfig.argv, buf);
+#endif
          for (const auto &iarg : argv2) {
             WideStringListAppendHelper(&fConfig.argv, iarg.c_str());
          }

src/CPPDataMember.cxx

@@ -313,6 +313,9 @@ PyTypeObject CPPDataMember_Type = {
 #if PY_VERSION_HEX >= 0x030c0000
     , 0                           // tp_watched
 #endif
+#if PY_VERSION_HEX >= 0x030d0000
+    , 0                           // tp_versions_used
+#endif
 };
 
 } // namespace CPyCppyy

src/CPPEnum.cxx

@@ -32,12 +32,19 @@ PyObject* CPyCppyy::pyval_from_enum(const std::string& enum_type, PyObject* pyty
     PyObject* bval;
     if (enum_type == "char") {
         char val = (char)llval;
+#if PY_VERSION_HEX < 0x03000000
         bval = CPyCppyy_PyText_FromStringAndSize(&val, 1);
+#else
+        bval = PyUnicode_FromOrdinal((int)val);
+#endif
     } else if (enum_type == "int" || enum_type == "unsigned int")
         bval = PyInt_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);
@@ -136,7 +143,7 @@ static PyObject* enum_ctype(PyObject* cls, PyObject* args, PyObject* kwds)
 CPyCppyy::CPPEnum* CPyCppyy::CPPEnum_New(const std::string& name, Cppyy::TCppScope_t scope)
 {
 // Create a new enum type based on the actual C++ type. Enum values are added to
-// the type by may also live in the enclosing scope.
+// the type but may also live in the enclosing scope.
 
     CPPEnum* pyenum = nullptr;
 
@@ -195,8 +202,13 @@ CPyCppyy::CPPEnum* CPyCppyy::CPPEnum_New(const std::string& name, Cppyy::TCppSco
 
     // collect the enum values
         std::vector<Cppyy::TCppScope_t> econstants = Cppyy::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;
+            }
             PyObject* pydname = CPyCppyy_PyText_FromString(Cppyy::GetFinalName(econstant).c_str());
             PyObject_SetAttr(pyenum, pydname, val);
             PyObject_SetAttr(val, PyStrings::gCppName, pydname);
@@ -211,6 +223,13 @@ CPyCppyy::CPPEnum* CPyCppyy::CPPEnum_New(const std::string& name, Cppyy::TCppSco
         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(&PyInt_Type);

src/CPPExcInstance.cxx

@@ -288,6 +288,9 @@ PyTypeObject CPPExcInstance_Type = {
 #if PY_VERSION_HEX >= 0x030c0000
     , 0                            // tp_watched
 #endif
+#if PY_VERSION_HEX >= 0x030d0000
+    , 0                            // tp_versions_used
+#endif
 };
 
 } // namespace CPyCppyy

src/CPPInstance.cxx

@@ -441,7 +441,7 @@ static int op_clear(CPPInstance* pyobj)
 // Garbage collector clear of held python member objects; this is a good time
 // to safely remove this object from the memory regulator.
     if (pyobj->fFlags & CPPInstance::kIsRegulated)
-        MemoryRegulator::UnregisterPyObject(pyobj, (PyObject*)Py_TYPE((PyObject*)pyobj));;
+        MemoryRegulator::UnregisterPyObject(pyobj, (PyObject*)Py_TYPE((PyObject*)pyobj));
 
     return 0;
 }
@@ -1102,6 +1102,9 @@ PyTypeObject CPPInstance_Type = {
 #if PY_VERSION_HEX >= 0x030c0000
     , 0                           // tp_watched
 #endif
+#if PY_VERSION_HEX >= 0x030d0000
+    , 0                           // tp_versions_used
+#endif
 };
 
 } // namespace CPyCppyy

src/CPPInstance.h

@@ -27,20 +27,21 @@ class CPPInstance {
 public:
     enum EFlags {
         kDefault     = 0x0000,
-        kNoWrapConv  = 0x0001,
-        kIsOwner     = 0x0002,
-        kIsExtended  = 0x0004,
-        kIsReference = 0x0008,
-        kIsRValue    = 0x0010,
-        kIsLValue    = 0x0020,
-        kIsValue     = 0x0040,
-        kIsPtrPtr    = 0x0080,
-        kIsArray     = 0x0100,
-        kIsSmartPtr  = 0x0200,
-        kNoMemReg    = 0x0400,
-        kHasLifeLine = 0x0800,
-        kIsRegulated = 0x1000,
-        kIsActual    = 0x2000 };
+        kNoWrapConv  = 0x0001,    // use type as-is (eg. no smart ptr wrap)
+        kIsOwner     = 0x0002,    // Python instance owns C++ object/memory
+        kIsExtended  = 0x0004,    // has extended data
+        kIsValue     = 0x0008,    // was created from a by-value return
+        kIsReference = 0x0010,    // represents one indirection
+        kIsArray     = 0x0020,    // represents an array of objects
+        kIsSmartPtr  = 0x0040,    // is or embeds a smart pointer
+        kIsPtrPtr    = 0x0080,    // represents two indirections
+        kIsRValue    = 0x0100,    // can be used as an r-value
+        kIsLValue    = 0x0200,    // can be used as an l-value
+        kNoMemReg    = 0x0400,    // do not register with memory regulator
+        kIsRegulated = 0x0800,    // is registered with memory regulator
+        kIsActual    = 0x1000,    // has been downcasted to actual type
+        kHasLifeLine = 0x2000,    // has a life line set
+    };
 
 public:                 // public, as the python C-API works with C structs
     PyObject_HEAD

src/CPPMethod.cxx

@@ -615,15 +615,30 @@ PyObject* CPyCppyy::CPPMethod::GetArgDefault(int iarg, bool silent)
         PyObject* gdct = *dctptr;
         PyObject* scope = nullptr;
 
-        if (defvalue.find("::") != std::string::npos) {
-        // try to tickle scope creation, just in case
-            scope = CreateScopeProxy(defvalue.substr(0, defvalue.rfind('(')));
-            if (!scope) PyErr_Clear();
-
-        // rename '::' -> '.'
-            TypeManip::cppscope_to_pyscope(defvalue);
+        if (defvalue.rfind('(') != std::string::npos) {    // constructor-style call
+        // try to tickle scope creation, just in case, first look in the scope where
+        // the function lives, then in the global scope
+            std::string possible_scope = defvalue.substr(0, defvalue.rfind('('));
+            if (!Cppyy::IsBuiltin(possible_scope)) {
+                std::string cand_scope = Cppyy::GetScopedFinalName(fScope)+"::"+possible_scope;
+                scope = CreateScopeProxy(cand_scope);
+                if (!scope) {
+                    PyErr_Clear();
+                // search within the global scope instead
+                    scope = CreateScopeProxy(possible_scope);
+                    if (!scope) PyErr_Clear();
+                } else {
+                // re-scope the scope; alternatively, the expression could be
+                // compiled in the dictionary of the function's namespace, but
+                // that would affect arguments passed to the constructor, too
+                    defvalue = cand_scope + defvalue.substr(defvalue.rfind('('), std::string::npos);
+                }
+            }
         }
 
+    // replace '::' -> '.'
+        TypeManip::cppscope_to_pyscope(defvalue);
+
         if (!scope) {
         // a couple of common cases that python doesn't like (technically, 'L' is okay with older
         // pythons, but C long will always fit in Python int, so no need to bother)
@@ -960,13 +975,6 @@ PyObject* CPyCppyy::CPPMethod::Execute(void* self, ptrdiff_t offset, CallContext
         result = ExecuteProtected(self, offset, ctxt);
     }
 
-// TODO: the following is dreadfully slow and dead-locks on Apache: revisit
-// raising exceptions through callbacks by using magic returns
-//    if (result && Utility::PyErr_Occurred_WithGIL()) {
-//    // can happen in the case of a CINT error: trigger exception processing
-//        Py_DECREF(result);
-//        result = 0;
-//    } else if (!result && PyErr_Occurred())
     if (!result && PyErr_Occurred())
         SetPyError_(0);
 

src/CPPOverload.cxx

@@ -697,7 +697,7 @@ static PyObject* mp_call(CPPOverload* pymeth, PyObject* args, PyObject* kwds)
                 continue;    // did not set implicit conversion, so don't try again
 
             PyObject* result = methods[i]->Call(im_self, args, nargsf, kwds, &ctxt);
-            if (result != 0) {
+            if (result) {
             // success: update the dispatch map for subsequent calls
                 if (!memoized_pc)
                     dispatchMap.push_back(std::make_pair(sighash, methods[i]));
@@ -1055,6 +1055,9 @@ PyTypeObject CPPOverload_Type = {
 #if PY_VERSION_HEX >= 0x030c0000
     , 0                                // tp_watched
 #endif
+#if PY_VERSION_HEX >= 0x030d0000
+    , 0                                // tp_versions_used
+#endif
 };
 
 } // namespace CPyCppyy

src/CPPScope.cxx

@@ -474,12 +474,14 @@ static PyObject* meta_getattro(PyObject* pyclass, PyObject* pyname)
     // try all outstanding using namespaces in turn to find the attribute (will cache
     // locally later; TODO: doing so may cause pathological cases)
         for (auto pyref : *klass->fImp.fUsing) {
-            PyObject* pyuscope = PyWeakref_GetObject(pyref);
+            PyObject* pyuscope = CPyCppyy_GetWeakRef(pyref);
             if (pyuscope) {
                 attr = PyObject_GetAttr(pyuscope, pyname);
-                if (attr) break;
-                PyErr_Clear();
+                if (!attr) PyErr_Clear();
+                Py_DECREF(pyuscope);
             }
+            if (attr)
+                break;
         }
     }
 
@@ -702,6 +704,9 @@ PyTypeObject CPPScope_Type = {
 #if PY_VERSION_HEX >= 0x030c0000
     , 0                           // tp_watched
 #endif
+#if PY_VERSION_HEX >= 0x030d0000
+    , 0                           // tp_versions_used
+#endif
 };
 
 } // namespace CPyCppyy

src/CPyCppyy.h

@@ -351,8 +351,26 @@ inline PyObject* CPyCppyy_tp_call(PyObject* cb, PyObject* args, size_t, PyObject
 }
 #endif
 
+// weakref forced strong reference
+#if PY_VERSION_HEX < 0x30d0000
+static inline PyObject* CPyCppyy_GetWeakRef(PyObject* ref) {
+    PyObject* pyobject = PyWeakref_GetObject(ref);
+    if (!pyobject || pyobject == Py_None)
+        return nullptr;
+    Py_INCREF(pyobject);
+    return pyobject;
+}
+#else
+static inline PyObject* CPyCppyy_GetWeakRef(PyObject* ref) {
+    PyObject* pyobject = nullptr;
+    if (PyWeakref_GetRef(ref, &pyobject) != -1)
+        return pyobject;
+    return nullptr;
+}
+#endif
+
 // Py_TYPE as inline function
-#if PY_VERSION_HEX < 0x030900A4 && !defined(Py_SET_TYPE)
+#if PY_VERSION_HEX < 0x03090000 && !defined(Py_SET_TYPE)
 static inline
 void _Py_SET_TYPE(PyObject *ob, PyTypeObject *type) { ob->ob_type = type; }
 #define Py_SET_TYPE(ob, type) _Py_SET_TYPE((PyObject*)(ob), type)

src/CPyCppyyModule.cxx

@@ -164,6 +164,9 @@ static PyTypeObject PyNullPtr_t_Type = {
 #if PY_VERSION_HEX >= 0x030c0000
     , 0                  // tp_watched
 #endif
+#if PY_VERSION_HEX >= 0x030d0000
+    , 0                  // tp_versions_used
+#endif
 };
 
 
@@ -204,19 +207,30 @@ static PyTypeObject PyDefault_t_Type = {
 #if PY_VERSION_HEX >= 0x030c0000
     , 0                 // tp_watched
 #endif
+#if PY_VERSION_HEX >= 0x030d0000
+    , 0                 // tp_versions_used
+#endif
 };
 
 namespace {
 
-PyObject _CPyCppyy_NullPtrStruct = {
-    _PyObject_EXTRA_INIT
-    1, &PyNullPtr_t_Type
-};
+PyObject _CPyCppyy_NullPtrStruct = {_PyObject_EXTRA_INIT
+// In 3.12.0-beta this field was changed from a ssize_t to a union
+#if PY_VERSION_HEX >= 0x30c00b1
+                                    {1},
+#else
+                                    1,
+#endif
+                                    &PyNullPtr_t_Type};
 
-PyObject _CPyCppyy_DefaultStruct = {
-    _PyObject_EXTRA_INIT
-    1, &PyDefault_t_Type
-};
+PyObject _CPyCppyy_DefaultStruct = {_PyObject_EXTRA_INIT
+// In 3.12.0-beta this field was changed from a ssize_t to a union
+#if PY_VERSION_HEX >= 0x30c00b1
+                                    {1},
+#else
+                                    1,
+#endif
+                                    &PyDefault_t_Type};
 
 // TODO: refactor with Converters.cxx
 struct CPyCppyy_tagCDataObject {       // non-public (but stable)
@@ -236,10 +250,15 @@ namespace CPyCppyy {
     PyObject* gSegvException = nullptr;
     PyObject* gIllException  = nullptr;
     PyObject* gAbrtException = nullptr;
-    std::map<std::string, std::vector<PyObject*>> gPythonizations;
-    std::set<Cppyy::TCppScope_t> gPinnedTypes;
+    std::set<Cppyy::TCppType_t> gPinnedTypes;
     std::ostringstream gCapturedError;
     std::streambuf* gOldErrorBuffer = nullptr;
+
+    std::map<std::string, std::vector<PyObject*>> &pythonizations()
+    {
+       static std::map<std::string, std::vector<PyObject*>> pyzMap;
+       return pyzMap;
+    }
 }
 
 
@@ -837,7 +856,7 @@ static PyObject* AddPythonization(PyObject*, PyObject* args)
     }
 
     Py_INCREF(pythonizor);
-    gPythonizations[scope].push_back(pythonizor);
+    pythonizations()[scope].push_back(pythonizor);
 
     Py_RETURN_NONE;
 }
@@ -851,8 +870,9 @@ static PyObject* RemovePythonization(PyObject*, PyObject* args)
     if (!PyArg_ParseTuple(args, const_cast<char*>("Os"), &pythonizor, &scope))
         return nullptr;
 
-    auto p1 = gPythonizations.find(scope);
-    if (p1 != gPythonizations.end()) {
+    auto &pyzMap = pythonizations();
+    auto p1 = pyzMap.find(scope);
+    if (p1 != pyzMap.end()) {
         auto p2 = std::find(p1->second.begin(), p1->second.end(), pythonizor);
         if (p2 != p1->second.end()) {
             p1->second.erase(p2);