[Python] Continue clingwrapper synchronization

guitargeek · guitargeek · commit 3ad939269cbf · 2025-09-16T23:54:19.000+02:00
Continue clingwrapper synchronization with upstream.
diff --git a/bindings/pyroot/cppyy/cppyy-backend/clingwrapper/src/clingwrapper.cxx b/bindings/pyroot/cppyy/cppyy-backend/clingwrapper/src/clingwrapper.cxx
@@ -52,6 +52,24 @@
 #include <cstring>
 #include <typeinfo>
 
+#if defined(__arm64__)
+#include <exception>
+#include <setjmp.h>
+#define CLING_CATCH_UNCAUGHT_                                                \
+ARMUncaughtException guard;                                                  \
+if (setjmp(gExcJumBuf) == 0) {
+#define _CLING_CATCH_UNCAUGHT                                                \
+} else {                                                                     \
+    if (!std::getenv("CPPYY_UNCAUGHT_QUIET"))                                     \
+        std::cerr << "Warning: uncaught exception in JIT is rethrown; resources may leak" \
+                  << " (suppress with \"CPPYY_UNCAUGHT_QUIET=1\")" << std::endl;\
+    std::rethrow_exception(std::current_exception());                        \
+}
+#else
+#define CLING_CATCH_UNCAUGHT_
+#define _CLING_CATCH_UNCAUGHT
+#endif
+
 // temp
 #include <iostream>
 typedef CPyCppyy::Parameter Parameter;
@@ -75,6 +93,7 @@ static const ClassRefs_t::size_type STD_HANDLE = GLOBAL_HANDLE + 1;
 
 typedef std::map<std::string, ClassRefs_t::size_type> Name2ClassRefIndex_t;
 static Name2ClassRefIndex_t g_name2classrefidx;
+
 static std::map<std::string, std::string> resolved_enum_types;
 
 namespace {
@@ -245,7 +264,7 @@ class ApplicationStarter {
 public:
     ApplicationStarter() {
     // initialize ROOT early to guarantee proper order of shutdown later on (gROOT is a
-    // macro that resolves to the ROOT::GetROOT() function call)
+    // macro that resolves to the ::CppyyLegacy::GetROOT() function call)
         (void)gROOT;
 
     // setup dummy holders for global and std namespaces
@@ -262,6 +281,13 @@ class ApplicationStarter {
         g_globalvars.push_back(nullptr);
         g_globalidx[nullptr] = 0;
 
+    // fill out the builtins
+        std::set<std::string> bi{g_builtins};
+        for (const auto& name : bi) {
+            for (const char* a : {"*", "&", "*&", "[]", "*[]"})
+                g_builtins.insert(name+a);
+        }
+
     // disable fast path if requested
         if (std::getenv("CPPYY_DISABLE_FASTPATH")) gEnableFastPath = false;
 
@@ -324,25 +350,23 @@ class ApplicationStarter {
         gInterpreter->Declare("namespace __cppyy_internal { struct Sep; }");
 
     // retrieve all initial (ROOT) C++ names in the global scope to allow filtering later
-        if (!std::getenv("CPPYY_NO_ROOT_FILTER")) {
-            gROOT->GetListOfGlobals(true);             // force initialize
-            gROOT->GetListOfGlobalFunctions(true);     // id.
-            std::set<std::string> initial;
-            Cppyy::GetAllCppNames(GLOBAL_HANDLE, initial);
-            gInitialNames = initial;
+        gROOT->GetListOfGlobals(true);             // force initialize
+        gROOT->GetListOfGlobalFunctions(true);     // id.
+        std::set<std::string> initial;
+        Cppyy::GetAllCppNames(GLOBAL_HANDLE, initial);
+        gInitialNames = initial;
 
 #ifndef WIN32
-            gRootSOs.insert("libCore.so ");
-            gRootSOs.insert("libRIO.so ");
-            gRootSOs.insert("libThread.so ");
-            gRootSOs.insert("libMathCore.so ");
+        gRootSOs.insert("libCore.so ");
+        gRootSOs.insert("libRIO.so ");
+        gRootSOs.insert("libThread.so ");
+        gRootSOs.insert("libMathCore.so ");
 #else
-            gRootSOs.insert("libCore.dll ");
-            gRootSOs.insert("libRIO.dll ");
-            gRootSOs.insert("libThread.dll ");
-            gRootSOs.insert("libMathCore.dll ");
+        gRootSOs.insert("libCore.dll ");
+        gRootSOs.insert("libRIO.dll ");
+        gRootSOs.insert("libThread.dll ");
+        gRootSOs.insert("libMathCore.dll ");
 #endif
-        }
 
     // start off with a reasonable size placeholder for wrappers
         gWrapperHolder.reserve(1024);
@@ -467,10 +491,10 @@ std::string Cppyy::ResolveName(const std::string& cppitem_name)
     if (tclean.compare(0, 9, "std::byte") == 0)
         return tclean;
 
-
 // check data types list (accept only builtins as typedefs will
 // otherwise not be resolved)
     if (IsBuiltin(tclean)) return tclean;
+
 // special case for enums
     if (IsEnum(cppitem_name))
         return ResolveEnum(cppitem_name);
@@ -699,15 +723,17 @@ Cppyy::TCppType_t Cppyy::GetActualClass(TCppType_t klass, TCppObject_t obj)
     // if the raw name is the empty string (no guarantees that this is so as truly, the
     // address is corrupt, but it is common to be empty), then there is no accessible RTTI
     // and getting the unmangled name will crash ...
-        if (!raw)
+
+    // a common case are the i/o stream objects b/c these are pulled in from libCling
+        if (!raw || (strstr(cr->GetName(), "std::basic_") && strstr(cr->GetName(), "stream")) || raw[0] == '\0')
             return klass;
     } catch (std::bad_typeid) {
         return klass;        // can't risk passing to ROOT/meta as it may do RTTI
     }
 #endif
 
     TClass* clActual = cr->GetActualClass((void*)obj);
-    // The additional check using TClass::GetClassInfo is to prevent returning classes of which the Interpreter has no info
+    // The additional check using TClass::GetClassInfo is to prevent returning classes of which the Interpreter has no info (see https://github.com/root-project/root/pull/16177)
     if (clActual && clActual != cr.GetClass() && clActual->GetClassInfo()) {
         auto itt = g_name2classrefidx.find(clActual->GetName());
         if (itt != g_name2classrefidx.end())
@@ -733,7 +759,6 @@ size_t Cppyy::SizeOf(const std::string& type_name)
     return SizeOf(GetScope(type_name));
 }
 
-
 bool Cppyy::IsBuiltin(const std::string& type_name)
 {
     if (g_builtins.find(type_name) != g_builtins.end())
@@ -756,7 +781,7 @@ bool Cppyy::IsComplete(const std::string& type_name)
 
     int oldEIL = gErrorIgnoreLevel;
     gErrorIgnoreLevel = 3000;
-    TClass* klass = TClass::GetClass(TClassEdit::ShortType(type_name.c_str(), 1).c_str());
+    TClass* klass = TClass::GetClass(type_name.c_str());
     if (klass && klass->GetClassInfo())     // works for normal case w/ dict
         b = gInterpreter->ClassInfo_IsLoaded(klass->GetClassInfo());
     else {    // special case for forward declared classes
@@ -802,11 +827,11 @@ void Cppyy::Destruct(TCppType_t type, TCppObject_t instance)
         else {
             auto ib = sHasOperatorDelete.find(type);
             if (ib == sHasOperatorDelete.end()) {
-               TFunction *f = (TFunction *)cr->GetMethodAllAny("operator delete");
-               sHasOperatorDelete[type] = (bool)(f && (f->Property() & kIsPublic));
-               ib = sHasOperatorDelete.find(type);
+                TFunction *f = (TFunction *)cr->GetMethodAllAny("operator delete");
+                sHasOperatorDelete[type] = (bool)(f && (f->Property() & kIsPublic));
+                ib = sHasOperatorDelete.find(type);
             }
-            ib->second ? cr->Destructor((void *)instance) : ::operator delete((void *)instance);
+            ib->second ? cr->Destructor((void*)instance) : ::operator delete((void*)instance);
         }
     }
 }
@@ -869,7 +894,8 @@ bool copy_args(Parameter* args, size_t nargs, void** vargs)
 }
 
 static inline
-void release_args(Parameter* args, size_t nargs) {
+void release_args(Parameter* args, size_t nargs)
+{
     for (size_t i = 0; i < nargs; ++i) {
         if (args[i].fTypeCode == 'X')
             free(args[i].fValue.fVoidp);
@@ -1106,15 +1132,19 @@ bool Cppyy::IsAbstract(TCppType_t klass)
 bool Cppyy::IsEnum(const std::string& type_name)
 {
     if (type_name.empty()) return false;
+
+    if (type_name.rfind("enum ", 0) == 0)
+        return true;    // by definition (C-style)
+
     std::string tn_short = TClassEdit::ShortType(type_name.c_str(), 1);
     if (tn_short.empty()) return false;
     return gInterpreter->ClassInfo_IsEnum(tn_short.c_str());
 }
 
-bool Cppyy::IsAggregate(TCppType_t klass)
+bool Cppyy::IsAggregate(TCppType_t type)
 {
-// Test if this type is an aggregate type
-    TClassRef& cr = type_from_handle(klass);
+// Test if this type is a "plain old data" type
+    TClassRef& cr = type_from_handle(type);
     if (cr.GetClass())
         return cr->ClassProperty() & kClassIsAggregate;
     return false;
@@ -1183,7 +1213,7 @@ static inline
 void cond_add(Cppyy::TCppScope_t scope, const std::string& ns_scope,
     std::set<std::string>& cppnames, const char* name, bool nofilter = false)
 {
-    if (!name || name[0] == '_' || strstr(name, ".h") != 0 || strncmp(name, "operator", 8) == 0)
+    if (!name || strstr(name, ".h") != 0)
         return;
 
     if (scope == GLOBAL_HANDLE) {
@@ -1252,23 +1282,21 @@ void Cppyy::GetAllCppNames(TCppScope_t scope, std::set<std::string>& cppnames)
 
 // add functions
     coll = (scope == GLOBAL_HANDLE) ?
-        gROOT->GetListOfGlobalFunctions() : cr->GetListOfMethods();
+        gROOT->GetListOfGlobalFunctions(true) : cr->GetListOfMethods(true);
     {
         TIter itr{coll};
         TFunction* obj = nullptr;
         while ((obj = (TFunction*)itr.Next())) {
             const char* nm = obj->GetName();
         // skip templated functions, adding only the un-instantiated ones
-            if (nm && nm[0] != '_' && strstr(nm, "<") == 0 && strncmp(nm, "operator", 8) != 0) {
-                if (gInitialNames.find(nm) == gInitialNames.end())
-                    cppnames.insert(nm);
-            }
+            if (nm && gInitialNames.find(nm) == gInitialNames.end())
+                cppnames.insert(nm);
         }
     }
 
 // add uninstantiated templates
     coll = (scope == GLOBAL_HANDLE) ?
-        gROOT->GetListOfFunctionTemplates() : cr->GetListOfFunctionTemplates();
+        gROOT->GetListOfFunctionTemplates() : cr->GetListOfFunctionTemplates(true);
     FILL_COLL(TFunctionTemplate, kIsPrivate | kIsProtected)
 
 // add (global) data members
@@ -1350,7 +1378,7 @@ std::string Cppyy::GetScopedFinalName(TCppType_t klass)
             return std::string("std::")+cr->GetName();
         return cr->GetName();
     }
-    return "";
+    return "<unknown>";
 }
 
 bool Cppyy::HasVirtualDestructor(TCppType_t klass)
@@ -1512,10 +1540,8 @@ bool Cppyy::GetSmartPtrInfo(
         TClassRef& cr = type_from_handle(GetScope(tname));
         if (cr.GetClass()) {
             TFunction* func = cr->GetMethod("operator->", "");
-            if (!func) {
-                gInterpreter->UpdateListOfMethods(cr.GetClass());
+            if (!func)
                 func = cr->GetMethod("operator->", "");
-            }
             if (func) {
                if (deref) *deref = (TCppMethod_t)new_CallWrapper(func);
                if (raw) *raw = GetScope(TClassEdit::ShortType(
@@ -2483,3 +2509,5 @@ long long Cppyy::GetEnumDataValue(TCppEnum_t etype, TCppIndex_t idata)
      TEnumConstant* ecst = (TEnumConstant*)((TEnum*)etype)->GetConstants()->At((int)idata);
      return (long long)ecst->GetValue();
 }
+
+
diff --git a/bindings/pyroot/cppyy/patches/cppyy-Enable-testsuite.patch b/bindings/pyroot/cppyy/patches/cppyy-Enable-testsuite.patch
@@ -1,53 +1,3 @@
-From 7eafbaa8ad7a17ac9fe860982bd168c5d3c05589 Mon Sep 17 00:00:00 2001
-From: Aaron Jomy <aaronjomyjoseph@gmail.com>
-Date: Thu, 27 Mar 2025 11:31:02 +0100
-Subject: [PATCH 1/2] [cppyy] Drop genreflex in favour of rootcling for test
- dictionaries
-
-This patch modifies upstream cppyy's test suite to use rootcling for
-dictionary generation, and also marks all tests that regress or crash
-on ROOT. This heavily simplifies the MakeFile, which will be dropped
-subsequently in favour of CMake that adds this to ROOTs ctest executable.
----
- bindings/pyroot/cppyy/cppyy/test/Makefile | 14 ++++++++------
- 1 file changed, 8 insertions(+), 6 deletions(-)
-
-diff --git a/bindings/pyroot/cppyy/cppyy/test/Makefile b/bindings/pyroot/cppyy/cppyy/test/Makefile
-index 0d13d38c22..c40442fab0 100644
---- a/bindings/pyroot/cppyy/cppyy/test/Makefile
-+++ b/bindings/pyroot/cppyy/cppyy/test/Makefile
-@@ -16,20 +16,22 @@ dicts = advancedcppDict.so \
- 
- all : $(dicts)
- 
--genreflex_flags := $(shell genreflex --cppflags)
--cppflags=$(shell cling-config --cppflags) $(genreflex_flags) -O3 -fPIC -I$(shell python -c 'import sysconfig as sc; print(sc.get_config_var("INCLUDEPY"))') -Wno-register
--
-+cppflags=$(shell root-config --cflags) -O3 -fPIC -I$(shell python -c 'import sysconfig as sc; print(sc.get_config_var("INCLUDEPY"))') -Wno-register
- PLATFORM := $(shell uname -s)
- ifeq ($(PLATFORM),Darwin)
-   cppflags+=-dynamiclib -undefined dynamic_lookup -Wno-delete-non-virtual-dtor
- endif
- 
-+# For these tests, the rootcling invocation looks like the following:
-+# rootcling advancedcpp_rflx.cpp --rmf advancedcppDict.rootmap --rml advancedCppDict.so advancedcpp.h advancedcpp.xml
-+%_rflx.cpp: %.h %.xml
-+	rootcling $@ --rmf $*Dict.rootmap --rml $*Dict.so $^
-+
-+# Compiling the test dictionaries to shared libs:
-+# g++ $(cppflags) -shared -o advancedcppDict.so advancedcpp_rflx.cpp advancedcpp.cxx
- %Dict.so: %_rflx.cpp %.cxx
- 	$(CXX) $(cppflags) -shared -o $@ $^
- 
--%_rflx.cpp: %.h %.xml
--	genreflex $< --selection=$*.xml --rootmap=$*Dict.rootmap --rootmap-lib=$*Dict.so
--
- .PHONY: test clean
- 
- test:
--- 
-2.43.0
-
 From 23d7c1353eb0bdd88f0e83a3c7a6c8b177e98700 Mon Sep 17 00:00:00 2001
 From: Aaron Jomy <aaronjomyjoseph@gmail.com>
 Date: Thu, 27 Mar 2025 11:32:57 +0100
diff --git a/bindings/pyroot/cppyy/sync-upstream b/bindings/pyroot/cppyy/sync-upstream
@@ -4,19 +4,22 @@
 
 # We will keep our own CMakeLists.txt files
 
+mv cppyy-backend/CMakeLists.txt cppyy-backend_CMakeLists.txt
 mv CPyCppyy/CMakeLists.txt CPyCppyy_CMakeLists.txt
 mv cppyy/CMakeLists.txt cppyy_CMakeLists.txt
 mv cppyy/test/CMakeLists.txt cppyy_test_CMakeLists.txt
 
 rm -rf CPyCppyy
 rm -rf cppyy
+rm -rf cppyy-backend
 
 # If we want to clone specific branches:
 # git clone --depth 1 --branch CPyCppyy-1.13.0 https://github.com/wlav/CPyCppyy.git
 # git clone --depth 1 --branch cppyy-3.5.0 https://github.com/wlav/cppyy.git
 
 git clone https://github.com/wlav/CPyCppyy.git
 git clone https://github.com/wlav/cppyy.git
+git clone https://github.com/wlav/cppyy-backend.git
 
 rebase_topic () {
   git rebase sync $1 && git branch -D sync && git checkout -b sync
@@ -51,16 +54,54 @@ git checkout -b sync
 
 rebase_topic guitargeek/concurrency_tests_gil
 
+rm test/Makefile
+
+cd ../
+
+cd cppyy-backend/
+
+git reset --hard 8928218a6c95dcd02627a402ee4ed09cb138db17
+
+git remote rename origin wlav
+
+git remote add guitargeek https://github.com/guitargeek/cppyy-backend.git
+git fetch guitargeek
+
+git checkout -b sync
+
+rebase_topic guitargeek/root_patches # https://github.com/wlav/cppyy-backend/pull/37
+
+sed '/C-linkage wrappers/,$d' clingwrapper/src/clingwrapper.cxx > clingwrapper/src/clingwrapper.cxx.no_c_api
+
+mv clingwrapper/src/clingwrapper.cxx.no_c_api clingwrapper/src/clingwrapper.cxx
+
+rm -rf .circleci/
+rm -rf .github/
+rm .gitignore
+rm README.rst
+rm circleci.py
+rm -rf cling/
+rm clingwrapper/MANIFEST.in
+rm clingwrapper/README.rst
+rm clingwrapper/pyproject.toml
+rm clingwrapper/setup.cfg
+rm clingwrapper/setup.py
+rm clingwrapper/src/capi.h
+rm clingwrapper/src/clingwrapper.h
+rm clingwrapper/src/cppyy.h
+
 cd ../
 
 rm -rf CPyCppyy/.git
 rm -rf cppyy/.git
+rm -rf cppyy-backend/.git
 
 # Move back CMakeLists.txt files
 
 mv CPyCppyy_CMakeLists.txt CPyCppyy/CMakeLists.txt
 mv cppyy_CMakeLists.txt cppyy/CMakeLists.txt
 mv cppyy_test_CMakeLists.txt cppyy/test/CMakeLists.txt
+mv cppyy-backend_CMakeLists.txt cppyy-backend/CMakeLists.txt
 
 # Apply patches (they were created with git format-patch -1 HEAD)
 # Alternatively, one can also use "git am" to create individual commits
