minimal updates to cppyy frontend to make new cppyy work

Author: aaronj0

bindings/pyroot/cppyy/cppyy/python/cppyy/__init__.py

@@ -50,11 +50,21 @@
     'set_debug',              # enable/disable debug output
     ]
 
-import ctypes
-import os
-import sys
-import sysconfig
-import warnings
+from ._version import __version__
+
+import ctypes, os, sys, sysconfig, warnings
+
+if not 'CLING_STANDARD_PCH' in os.environ:
+    def _set_pch():
+        try:
+            import cppyy_backend as cpb
+            local_pch = os.path.join(os.path.dirname(__file__), 'allDict.cxx.pch.'+str(cpb.__version__))
+            if os.path.exists(local_pch):
+                os.putenv('CLING_STANDARD_PCH', local_pch)
+                os.environ['CLING_STANDARD_PCH'] = local_pch
+        except (ImportError, AttributeError):
+            pass
+    _set_pch(); del _set_pch
 
 try:
     import __pypy__
@@ -63,9 +73,6 @@
 except ImportError:
     ispypy = False
 
-from . import _typemap
-from ._version import __version__
-
 # import separately instead of in the above try/except block for easier to
 # understand tracebacks
 if ispypy:
@@ -79,7 +86,17 @@
 sys.modules['cppyy.gbl.std'] = gbl.std
 
 
+#- force creation of std.exception -------------------------------------------------------
+_e = gbl.std.exception
+
+
+#- enable auto-loading -------------------------------------------------------
+try:    gbl.cling.runtime.gCling.EnableAutoLoading()
+except: pass
+
+
 #- external typemap ----------------------------------------------------------
+from . import _typemap
 _typemap.initialize(_backend)               # also creates (u)int8_t mapper
 
 try:
@@ -113,15 +130,18 @@ def tuple_getitem(self, idx, get=cppyy.gbl.std.get):
             raise IndexError(idx)
         pyclass.__getitem__ = tuple_getitem
 
-  # pythonization of std::string; placed here because it's simpler to write the
+  # pythonization of std::basic_string<char>; placed here because it's simpler to write the
   # custom "npos" object (to allow easy result checking of find/rfind) in Python
-    elif pyclass.__cpp_name__ == "std::string":
-        class NPOS(0x3000000 <= sys.hexversion and int or long):
+    elif pyclass.__cpp_name__ == "std::basic_string<char>":
+        class NPOS(int):
+            def __init__(self, npos):
+                self.__cpp_npos = npos
             def __eq__(self, other):
-                return other == -1 or  int(self) == other
+                return other == -1 or  other == self.__cpp_npos
             def __ne__(self, other):
-                return other != -1 and int(self) != other
-        del pyclass.__class__.npos          # drop b/c is const data
+                return other != -1 and other != self.__cpp_npos
+        if hasattr(pyclass.__class__, 'npos'):
+            del pyclass.__class__.npos          # drop b/c is const data
         pyclass.npos = NPOS(pyclass.npos)
 
     return True
@@ -158,24 +178,24 @@ def __getitem__(self, cls):
                 return py_make_smartptr(cls, self.ptrcls)
         except AttributeError:
             pass
-        if isinstance(cls, str) and not cls in ('int', 'float'):
+        if type(cls) == str and not cls in ('int', 'float'):
             return py_make_smartptr(getattr(gbl, cls), self.ptrcls)
         return self.maker[cls]
 
-gbl.std.make_shared = make_smartptr(gbl.std.shared_ptr, gbl.std.make_shared)
-gbl.std.make_unique = make_smartptr(gbl.std.unique_ptr, gbl.std.make_unique)
+# gbl.std.make_shared = make_smartptr(gbl.std.shared_ptr, gbl.std.make_shared)
+# gbl.std.make_unique = make_smartptr(gbl.std.unique_ptr, gbl.std.make_unique)
 del make_smartptr
 
 
 #--- interface to Cling ------------------------------------------------------
 class _stderr_capture(object):
     def __init__(self):
-        self._capture = not gbl.gDebug and True or False
-        self.err = ""
+       self._capture = not gbl.Cpp.IsDebugOutputEnabled()
+       self.err = ""
 
     def __enter__(self):
         if self._capture:
-            _begin_capture_stderr()
+           _begin_capture_stderr()
         return self
 
     def __exit__(self, tp, val, trace):
@@ -200,32 +220,39 @@ def _cling_report(msg, errcode, msg_is_error=False):
 def cppdef(src):
     """Declare C++ source <src> to Cling."""
     with _stderr_capture() as err:
-        errcode = gbl.gInterpreter.Declare(src)
-    _cling_report(err.err, int(not errcode), msg_is_error=True)
+        errcode = gbl.Cpp.Declare(src, False)
+    if not errcode == 0 or err.err:
+        if 'warning' in err.err.lower() and not 'error' in err.err.lower():
+            warnings.warn(err.err, SyntaxWarning)
+            return True
+        raise SyntaxError('Failed to parse the given C++ code%s' % err.err)
     return True
 
 def cppexec(stmt):
     """Execute C++ statement <stmt> in Cling's global scope."""
     if stmt and stmt[-1] != ';':
         stmt += ';'
 
-  # capture stderr, but note that ProcessLine could legitimately be writing to
+  # capture stderr, but note that Process could legitimately be writing to
   # std::cerr, in which case the captured output needs to be printed as normal
     with _stderr_capture() as err:
         errcode = ctypes.c_int(0)
         try:
-            gbl.gInterpreter.ProcessLine(stmt, ctypes.pointer(errcode))
+            errcode = gbl.Cpp.Process(stmt)
         except Exception as e:
             sys.stderr.write("%s\n\n" % str(e))
-            if not errcode.value:
-                errcode.value = 1
+            if not errcode.value: errcode.value = 1
 
-    _cling_report(err.err, errcode.value)
-    if err.err and err.err[1:] != '\n':
+    if not errcode == 0:
+        raise SyntaxError('Failed to parse the given C++ code%s' % err.err)
+    elif err.err and err.err[1:] != '\n':
         sys.stderr.write(err.err[1:])
 
     return True
 
+def evaluate(input, HadError = _backend.nullptr):
+    return gbl.Cpp.Evaluate(input, HadError)
+
 def macro(cppm):
     """Attempt to evalute a C/C++ pre-processor macro as a constant"""
 
@@ -243,43 +270,35 @@ def macro(cppm):
 def load_library(name):
     """Explicitly load a shared library."""
     with _stderr_capture() as err:
-        gSystem = gbl.gSystem
-        if name[:3] != 'lib':
-            if not gSystem.FindDynamicLibrary(gbl.TString(name), True) and\
-                   gSystem.FindDynamicLibrary(gbl.TString('lib'+name), True):
-                name = 'lib'+name
-        sc = gSystem.Load(name)
-    if sc == -1:
-      # special case for Windows as of python3.8: use winmode=0, otherwise the default
-      # will not consider regular search paths (such as $PATH)
-        if 0x3080000 <= sys.hexversion and 'win32' in sys.platform and os.path.isabs(name):
-            return ctypes.CDLL(name, ctypes.RTLD_GLOBAL, winmode=0)  # raises on error
-        raise RuntimeError('Unable to load library "%s"%s' % (name, err.err))
+        result = gbl.Cpp.LoadLibrary(name, True)
+    if result == False:
+        raise RuntimeError('Could not load library "%s": %s' % (name, err.err))
+
     return True
 
 def include(header):
     """Load (and JIT) header file <header> into Cling."""
     with _stderr_capture() as err:
-        errcode = gbl.gInterpreter.Declare('#include "%s"' % header)
-    if not errcode:
+        errcode = gbl.Cpp.Declare('#include "%s"' % header, False)
+    if not errcode == 0:
         raise ImportError('Failed to load header file "%s"%s' % (header, err.err))
     return True
 
 def c_include(header):
     """Load (and JIT) header file <header> into Cling."""
     with _stderr_capture() as err:
-        errcode = gbl.gInterpreter.Declare("""extern "C" {
-#include "%s"
-}""" % header)
-    if not errcode:
+        errcode = gbl.Cpp.Declare("""extern "C" {
+                                    #include "%s"
+                                    }""" % header, False)
+    if not errcode == 0:
         raise ImportError('Failed to load header file "%s"%s' % (header, err.err))
     return True
 
 def add_include_path(path):
     """Add a path to the include paths available to Cling."""
     if not os.path.isdir(path):
         raise OSError('No such directory: %s' % path)
-    gbl.gInterpreter.AddIncludePath(path)
+    gbl.Cpp.AddIncludePath(path)
 
 def add_library_path(path):
     """Add a path to the library search paths available to Cling."""
@@ -319,23 +338,22 @@ def add_library_path(path):
             else:
                 import pkg_resources as pr
 
-                d = pr.get_distribution('CPyCppyy')
-                for line in d.get_metadata_lines('RECORD'):
-                    if 'API.h' in line:
-                        ape = os.path.join(d.location, line[0:line.find(',')])
-                        break
-                del line, d, pr
+            d = pr.get_distribution('CPyCppyy')
+            for line in d.get_metadata_lines('RECORD'):
+                if 'API.h' in line:
+                    part = line[0:line.find(',')]
 
+            ape = os.path.join(d.location, part)
             if os.path.exists(ape):
                 apipath_extra = os.path.dirname(os.path.dirname(ape))
-            del ape
+
+            del part, d, pr
         except Exception:
             pass
 
     if apipath_extra is None:
         ldversion = sysconfig.get_config_var('LDVERSION')
-        if not ldversion:
-            ldversion = sys.version[:3]
+        if not ldversion: ldversion = sys.version[:3]
 
         apipath_extra = os.path.join(os.path.dirname(apipath), 'site', 'python'+ldversion)
         if not os.path.exists(os.path.join(apipath_extra, 'CPyCppyy')):
@@ -361,9 +379,7 @@ def add_library_path(path):
 
     if apipath_extra.lower() != 'none':
         if not os.path.exists(os.path.join(apipath_extra, 'CPyCppyy')):
-            warnings.warn("CPyCppyy API not found (tried: %s); "
-                          "set CPPYY_API_PATH envar to the 'CPyCppyy' API directory to fix"
-                          % apipath_extra)
+            warnings.warn("CPyCppyy API not found (tried: %s); set CPPYY_API_PATH envar to the 'CPyCppyy' API directory to fix" % apipath_extra)
         else:
             add_include_path(apipath_extra)
 
@@ -372,38 +388,30 @@ def add_library_path(path):
 if os.getenv('CONDA_PREFIX'):
   # MacOS, Linux
     include_path = os.path.join(os.getenv('CONDA_PREFIX'), 'include')
-    if os.path.exists(include_path):
-        add_include_path(include_path)
+    if os.path.exists(include_path): add_include_path(include_path)
 
   # Windows
     include_path = os.path.join(os.getenv('CONDA_PREFIX'), 'Library', 'include')
-    if os.path.exists(include_path):
-        add_include_path(include_path)
+    if os.path.exists(include_path): add_include_path(include_path)
 
-# assuming that we are in PREFIX/lib/python/site-packages/cppyy,
-# add PREFIX/include to the search path
-include_path = os.path.abspath(
-        os.path.join(os.path.dirname(__file__), *(4*[os.path.pardir]+['include'])))
-if os.path.exists(include_path):
-    add_include_path(include_path)
+# assuming that we are in PREFIX/lib/python/site-packages/cppyy, add PREFIX/include to the search path
+include_path = os.path.abspath(os.path.join(os.path.dirname(__file__), *(4*[os.path.pardir]+['include'])))
+if os.path.exists(include_path): add_include_path(include_path)
 
 del include_path, apipath, ispypy
 
 def add_autoload_map(fname):
     """Add the entries from a autoload (.rootmap) file to Cling."""
     if not os.path.isfile(fname):
         raise OSError("no such file: %s" % fname)
-    gbl.gInterpreter.LoadLibraryMap(fname)
+    gbl.cling.runtime.gCling.LoadLibraryMap(fname)
 
 def set_debug(enable=True):
     """Enable/disable debug output."""
-    if enable:
-        gbl.gDebug = 10
-    else:
-        gbl.gDebug =  0
+    gbl.Cpp.EnableDebugOutput(enable)
 
 def _get_name(tt):
-    if isinstance(tt, str):
+    if type(tt) == str:
         return tt
     try:
         ttname = tt.__cpp_name__
@@ -414,15 +422,15 @@ def _get_name(tt):
 _sizes = {}
 def sizeof(tt):
     """Returns the storage size (in chars) of C++ type <tt>."""
-    if not isinstance(tt, type) and not isinstance(tt, str):
+    if not isinstance(tt, type) and not type(tt) == str:
         tt = type(tt)
     try:
         return _sizes[tt]
     except KeyError:
         try:
             sz = ctypes.sizeof(tt)
         except TypeError:
-            sz = gbl.gInterpreter.ProcessLine("sizeof(%s);" % (_get_name(tt),))
+            sz = gbl.Cpp.Evaluate("sizeof(%s)" % (_get_name(tt),), nullptr)
         _sizes[tt] = sz
         return sz
 
@@ -435,7 +443,7 @@ def typeid(tt):
         return _typeids[tt]
     except KeyError:
         tidname = 'typeid_'+str(len(_typeids))
-        gbl.gInterpreter.ProcessLine(
+        cppexec(
             "namespace _cppyy_internal { auto* %s = &typeid(%s); }" %\
             (tidname, _get_name(tt),))
         tid = getattr(gbl._cppyy_internal, tidname)
@@ -445,9 +453,15 @@ def typeid(tt):
 def multi(*bases):      # after six, see also _typemap.py
     """Resolve metaclasses for multiple inheritance."""
   # contruct a "no conflict" meta class; the '_meta' is needed by convention
-    nc_meta = type.__new__(
-            type, 'cppyy_nc_meta', tuple(type(b) for b in bases if type(b) is not type), {})
+    nc_meta = type.__new__(type, 'cppyy_nc_meta', tuple(type(b) for b in bases if type(b) is not type), {})
     class faux_meta(type):
-        def __new__(mcs, name, this_bases, d):
+        def __new__(cls, name, this_bases, d):
             return nc_meta(name, bases, d)
     return type.__new__(faux_meta, 'faux_meta', (), {})
+
+
+#- workaround (TODO: may not be needed with Clang9) --------------------------
+if 'win32' in sys.platform:
+    cppdef("""template<>
+    std::basic_ostream<char, std::char_traits<char>>& __cdecl std::endl<char, std::char_traits<char>>(
+        std::basic_ostream<char, std::char_traits<char>>&);""")