Author: Wim Lavrijsen <[email protected]>
Branch:
Changeset: r91932:992156d58504
Date: 2017-07-19 13:29 -0700
http://bitbucket.org/pypy/pypy/changeset/992156d58504/
Log: merged cppyy-packaging; renaming cppyy -> _cppyy
diff too long, truncating to 2000 out of 4103 lines
diff --git a/.hgignore b/.hgignore
--- a/.hgignore
+++ b/.hgignore
@@ -25,16 +25,17 @@
^pypy/module/cpyext/test/.+\.manifest$
^pypy/module/test_lib_pypy/ctypes_tests/.+\.o$
^pypy/module/test_lib_pypy/ctypes_tests/_ctypes_test\.o$
-^pypy/module/cppyy/src/.+\.o$
-^pypy/module/cppyy/bench/.+\.so$
-^pypy/module/cppyy/bench/.+\.root$
-^pypy/module/cppyy/bench/.+\.d$
-^pypy/module/cppyy/src/.+\.errors$
-^pypy/module/cppyy/test/.+_rflx\.cpp$
-^pypy/module/cppyy/test/.+\.so$
-^pypy/module/cppyy/test/.+\.rootmap$
-^pypy/module/cppyy/test/.+\.exe$
-^pypy/module/cppyy/test/.+_cint.h$
+^pypy/module/_cppyy/src/.+\.o$
+^pypy/module/_cppyy/bench/.+\.so$
+^pypy/module/_cppyy/bench/.+\.root$
+^pypy/module/_cppyy/bench/.+\.d$
+^pypy/module/_cppyy/src/.+\.errors$
+^pypy/module/_cppyy/test/.+_rflx\.cpp$
+^pypy/module/_cppyy/test/.+\.so$
+^pypy/module/_cppyy/test/.+\.rootmap$
+^pypy/module/_cppyy/test/.+\.exe$
+^pypy/module/_cppyy/test/.+_cint.h$
+^pypy/module/_cppyy/.+/*\.pcm$
^pypy/module/test_lib_pypy/cffi_tests/__pycache__.+$
^pypy/doc/.+\.html$
^pypy/doc/config/.+\.rst$
@@ -88,6 +89,3 @@
^release/
^rpython/_cache$
-pypy/module/cppyy/.+/*\.pcm
-
-
diff --git a/pypy/config/pypyoption.py b/pypy/config/pypyoption.py
--- a/pypy/config/pypyoption.py
+++ b/pypy/config/pypyoption.py
@@ -36,7 +36,7 @@
"cStringIO", "thread", "itertools", "pyexpat", "_ssl", "cpyext", "array",
"binascii", "_multiprocessing", '_warnings', "_collections",
"_multibytecodec", "micronumpy", "_continuation", "_cffi_backend",
- "_csv", "cppyy", "_pypyjson", "_jitlog"
+ "_csv", "_cppyy", "_pypyjson", "_jitlog"
])
from rpython.jit.backend import detect_cpu
@@ -67,8 +67,8 @@
if name in translation_modules:
translation_modules.remove(name)
- if "cppyy" in working_modules:
- working_modules.remove("cppyy") # not tested on win32
+ if "_cppyy" in working_modules:
+ working_modules.remove("_cppyy") # not tested on win32
if "faulthandler" in working_modules:
working_modules.remove("faulthandler") # missing details
@@ -79,8 +79,8 @@
working_modules.remove('fcntl') # LOCK_NB not defined
working_modules.remove("_minimal_curses")
working_modules.remove("termios")
- if "cppyy" in working_modules:
- working_modules.remove("cppyy") # depends on ctypes
+ if "_cppyy" in working_modules:
+ working_modules.remove("_cppyy") # depends on ctypes
#if sys.platform.startswith("linux"):
# _mach = os.popen('uname -m', 'r').read().strip()
@@ -92,7 +92,7 @@
'_multiprocessing': [('objspace.usemodules.time', True),
('objspace.usemodules.thread', True)],
'cpyext': [('objspace.usemodules.array', True)],
- 'cppyy': [('objspace.usemodules.cpyext', True)],
+ '_cppyy': [('objspace.usemodules.cpyext', True)],
'faulthandler': [('objspace.usemodules._vmprof', True)],
}
module_suggests = {
diff --git a/pypy/doc/cppyy.rst b/pypy/doc/cppyy.rst
deleted file mode 100644
--- a/pypy/doc/cppyy.rst
+++ /dev/null
@@ -1,672 +0,0 @@
-cppyy: C++ bindings for PyPy
-============================
-
-The cppyy module delivers dynamic Python-C++ bindings.
-It is designed for automation, high performance, scale, interactivity, and
-handling all of modern C++ (11, 14, etc.).
-It is based on `Cling`_ which, through `LLVM`_/`clang`_, provides C++
-reflection and interactivity.
-Reflection information is extracted from C++ header files.
-Cppyy itself is built into PyPy (an alternative exists for CPython), but
-it requires a `backend`_, installable through pip, to interface with Cling.
-
-.. _Cling: https://root.cern.ch/cling
-.. _LLVM: http://llvm.org/
-.. _clang: http://clang.llvm.org/
-.. _backend: https://pypi.python.org/pypi/PyPy-cppyy-backend
-
-
-Installation
-------------
-
-This assumes PyPy2.7 v5.7 or later; earlier versions use a Reflex-based cppyy
-module, which is no longer supported.
-Both the tooling and user-facing Python codes are very backwards compatible,
-however.
-Further dependencies are cmake (for general build), Python2.7 (for LLVM), and
-a modern C++ compiler (one that supports at least C++11).
-
-Assuming you have a recent enough version of PyPy installed, use pip to
-complete the installation of cppyy::
-
- $ MAKE_NPROCS=4 pypy-c -m pip install --verbose PyPy-cppyy-backend
-
-Set the number of parallel builds ('4' in this example, through the MAKE_NPROCS
-environment variable) to a number appropriate for your machine.
-The building process may take quite some time as it includes a customized
-version of LLVM as part of Cling, which is why --verbose is recommended so that
-you can see the build progress.
-
-The default installation will be under
-$PYTHONHOME/site-packages/cppyy_backend/lib,
-which needs to be added to your dynamic loader path (LD_LIBRARY_PATH).
-If you need the dictionary and class map generation tools (used in the examples
-below), you need to add $PYTHONHOME/site-packages/cppyy_backend/bin to your
-executable path (PATH).
-
-
-Basic bindings example
-----------------------
-
-These examples assume that cppyy_backend is pointed to by the environment
-variable CPPYYHOME, and that CPPYYHOME/lib is added to LD_LIBRARY_PATH and
-CPPYYHOME/bin to PATH.
-
-Let's first test with a trivial example whether all packages are properly
-installed and functional.
-Create a C++ header file with some class in it (all functions are made inline
-for convenience; if you have out-of-line code, link with it as appropriate)::
-
- $ cat MyClass.h
- class MyClass {
- public:
- MyClass(int i = -99) : m_myint(i) {}
-
- int GetMyInt() { return m_myint; }
- void SetMyInt(int i) { m_myint = i; }
-
- public:
- int m_myint;
- };
-
-Then, generate the bindings using ``genreflex`` (installed under
-cppyy_backend/bin in site_packages), and compile the code::
-
- $ genreflex MyClass.h
- $ g++ -std=c++11 -fPIC -rdynamic -O2 -shared -I$CPPYYHOME/include
MyClass_rflx.cpp -o libMyClassDict.so -L$CPPYYHOME/lib -lCling
-
-Next, make sure that the library can be found through the dynamic lookup path
-(the ``LD_LIBRARY_PATH`` environment variable on Linux, ``PATH`` on Windows),
-for example by adding ".".
-Now you're ready to use the bindings.
-Since the bindings are designed to look pythonistic, it should be
-straightforward::
-
- $ pypy-c
- >>>> import cppyy
- >>>> cppyy.load_reflection_info("libMyClassDict.so")
- <CPPLibrary object at 0xb6fd7c4c>
- >>>> myinst = cppyy.gbl.MyClass(42)
- >>>> print myinst.GetMyInt()
- 42
- >>>> myinst.SetMyInt(33)
- >>>> print myinst.m_myint
- 33
- >>>> myinst.m_myint = 77
- >>>> print myinst.GetMyInt()
- 77
- >>>> help(cppyy.gbl.MyClass) # shows that normal python introspection
works
-
-That's all there is to it!
-
-
-Automatic class loader
-----------------------
-
-There is one big problem in the code above, that prevents its use in a (large
-scale) production setting: the explicit loading of the reflection library.
-Clearly, if explicit load statements such as these show up in code downstream
-from the ``MyClass`` package, then that prevents the ``MyClass`` author from
-repackaging or even simply renaming the dictionary library.
-
-The solution is to make use of an automatic class loader, so that downstream
-code never has to call ``load_reflection_info()`` directly.
-The class loader makes use of so-called rootmap files, which ``genreflex``
-can produce.
-These files contain the list of available C++ classes and specify the library
-that needs to be loaded for their use (as an aside, this listing allows for a
-cross-check to see whether reflection info is generated for all classes that
-you expect).
-By convention, the rootmap files should be located next to the reflection info
-libraries, so that they can be found through the normal shared library search
-path.
-They can be concatenated together, or consist of a single rootmap file per
-library.
-For example::
-
- $ genreflex MyClass.h --rootmap=libMyClassDict.rootmap
--rootmap-lib=libMyClassDict.so
- $ g++ -std=c++11 -fPIC -rdynamic -O2 -shared -I$CPPYYHOME/include
MyClass_rflx.cpp -o libMyClassDict.so -L$CPPYYHOME/lib -lCling
-
-where the first option (``--rootmap``) specifies the output file name, and the
-second option (``--rootmap-lib``) the name of the reflection library where
-``MyClass`` will live.
-It is necessary to provide that name explicitly, since it is only in the
-separate linking step where this name is fixed.
-If the second option is not given, the library is assumed to be libMyClass.so,
-a name that is derived from the name of the header file.
-
-With the rootmap file in place, the above example can be rerun without explicit
-loading of the reflection info library::
-
- $ pypy-c
- >>>> import cppyy
- >>>> myinst = cppyy.gbl.MyClass(42)
- >>>> print myinst.GetMyInt()
- 42
- >>>> # etc. ...
-
-As a caveat, note that the class loader is currently limited to classes only.
-
-
-Advanced example
-----------------
-
-The following snippet of C++ is very contrived, to allow showing that such
-pathological code can be handled and to show how certain features play out in
-practice::
-
- $ cat MyAdvanced.h
- #include <string>
-
- class Base1 {
- public:
- Base1(int i) : m_i(i) {}
- virtual ~Base1() {}
- int m_i;
- };
-
- class Base2 {
- public:
- Base2(double d) : m_d(d) {}
- virtual ~Base2() {}
- double m_d;
- };
-
- class C;
-
- class Derived : public virtual Base1, public virtual Base2 {
- public:
- Derived(const std::string& name, int i, double d) : Base1(i),
Base2(d), m_name(name) {}
- virtual C* gimeC() { return (C*)0; }
- std::string m_name;
- };
-
- Base2* BaseFactory(const std::string& name, int i, double d) {
- return new Derived(name, i, d);
- }
-
-This code is still only in a header file, with all functions inline, for
-convenience of the example.
-If the implementations live in a separate source file or shared library, the
-only change needed is to link those in when building the reflection library.
-
-If you were to run ``genreflex`` like above in the basic example, you will
-find that not all classes of interest will be reflected, nor will be the
-global factory function.
-In particular, ``std::string`` will be missing, since it is not defined in
-this header file, but in a header file that is included.
-In practical terms, general classes such as ``std::string`` should live in a
-core reflection set, but for the moment assume we want to have it in the
-reflection library that we are building for this example.
-
-The ``genreflex`` script can be steered using a so-called `selection file`_
-(see "Generating Reflex Dictionaries")
-which is a simple XML file specifying, either explicitly or by using a
-pattern, which classes, variables, namespaces, etc. to select from the given
-header file.
-With the aid of a selection file, a large project can be easily managed:
-simply ``#include`` all relevant headers into a single header file that is
-handed to ``genreflex``.
-In fact, if you hand multiple header files to ``genreflex``, then a selection
-file is almost obligatory: without it, only classes from the last header will
-be selected.
-Then, apply a selection file to pick up all the relevant classes.
-For our purposes, the following rather straightforward selection will do
-(the name ``lcgdict`` for the root is historical, but required)::
-
- $ cat MyAdvanced.xml
- <lcgdict>
- <class pattern="Base?" />
- <class name="Derived" />
- <class name="std::string" />
- <function name="BaseFactory" />
- </lcgdict>
-
-.. _selection file: https://root.cern.ch/how/how-use-reflex
-
-Now the reflection info can be generated and compiled::
-
- $ genreflex MyAdvanced.h --selection=MyAdvanced.xml
- $ g++ -std=c++11 -fPIC -rdynamic -O2 -shared -I$CPPYYHOME/include
MyAdvanced_rflx.cpp -o libAdvExDict.so -L$CPPYYHOME/lib -lCling
-
-and subsequently be used from PyPy::
-
- >>>> import cppyy
- >>>> cppyy.load_reflection_info("libAdvExDict.so")
- <CPPLibrary object at 0x00007fdb48fc8120>
- >>>> d = cppyy.gbl.BaseFactory("name", 42, 3.14)
- >>>> type(d)
- <class '__main__.Derived'>
- >>>> isinstance(d, cppyy.gbl.Base1)
- True
- >>>> isinstance(d, cppyy.gbl.Base2)
- True
- >>>> d.m_i, d.m_d
- (42, 3.14)
- >>>> d.m_name == "name"
- True
- >>>>
-
-Again, that's all there is to it!
-
-A couple of things to note, though.
-If you look back at the C++ definition of the ``BaseFactory`` function,
-you will see that it declares the return type to be a ``Base2``, yet the
-bindings return an object of the actual type ``Derived``?
-This choice is made for a couple of reasons.
-First, it makes method dispatching easier: if bound objects are always their
-most derived type, then it is easy to calculate any offsets, if necessary.
-Second, it makes memory management easier: the combination of the type and
-the memory address uniquely identifies an object.
-That way, it can be recycled and object identity can be maintained if it is
-entered as a function argument into C++ and comes back to PyPy as a return
-value.
-Last, but not least, casting is decidedly unpythonistic.
-By always providing the most derived type known, casting becomes unnecessary.
-For example, the data member of ``Base2`` is simply directly available.
-Note also that the unreflected ``gimeC`` method of ``Derived`` does not
-preclude its use.
-It is only the ``gimeC`` method that is unusable as long as class ``C`` is
-unknown to the system.
-
-
-Features
---------
-
-The following is not meant to be an exhaustive list, since cppyy is still
-under active development.
-Furthermore, the intention is that every feature is as natural as possible on
-the python side, so if you find something missing in the list below, simply
-try it out.
-It is not always possible to provide exact mapping between python and C++
-(active memory management is one such case), but by and large, if the use of a
-feature does not strike you as obvious, it is more likely to simply be a bug.
-That is a strong statement to make, but also a worthy goal.
-For the C++ side of the examples, refer to this :doc:`example code
<cppyy_example>`, which was
-bound using::
-
- $ genreflex example.h --deep --rootmap=libexampleDict.rootmap
--rootmap-lib=libexampleDict.so
- $ g++ -std=c++11 -fPIC -rdynamic -O2 -shared -I$CPPYYHOME/include
example_rflx.cpp -o libexampleDict.so -L$CPPYYHOME/lib -lCling
-
-* **abstract classes**: Are represented as python classes, since they are
- needed to complete the inheritance hierarchies, but will raise an exception
- if an attempt is made to instantiate from them.
- Example::
-
- >>>> from cppyy.gbl import AbstractClass, ConcreteClass
- >>>> a = AbstractClass()
- Traceback (most recent call last):
- File "<console>", line 1, in <module>
- TypeError: cannot instantiate abstract class 'AbstractClass'
- >>>> issubclass(ConcreteClass, AbstractClass)
- True
- >>>> c = ConcreteClass()
- >>>> isinstance(c, AbstractClass)
- True
- >>>>
-
-* **arrays**: Supported for builtin data types only, as used from module
- ``array``.
- Out-of-bounds checking is limited to those cases where the size is known at
- compile time (and hence part of the reflection info).
- Example::
-
- >>>> from cppyy.gbl import ConcreteClass
- >>>> from array import array
- >>>> c = ConcreteClass()
- >>>> c.array_method(array('d', [1., 2., 3., 4.]), 4)
- 1 2 3 4
- >>>>
-
-* **builtin data types**: Map onto the expected equivalent python types, with
- the caveat that there may be size differences, and thus it is possible that
- exceptions are raised if an overflow is detected.
-
-* **casting**: Is supposed to be unnecessary.
- Object pointer returns from functions provide the most derived class known
- in the hierarchy of the object being returned.
- This is important to preserve object identity as well as to make casting,
- a pure C++ feature after all, superfluous.
- Example::
-
- >>>> from cppyy.gbl import AbstractClass, ConcreteClass
- >>>> c = ConcreteClass()
- >>>> ConcreteClass.show_autocast.__doc__
- 'AbstractClass* ConcreteClass::show_autocast()'
- >>>> d = c.show_autocast()
- >>>> type(d)
- <class '__main__.ConcreteClass'>
- >>>>
-
- However, if need be, you can perform C++-style reinterpret_casts (i.e.
- without taking offsets into account), by taking and rebinding the address
- of an object::
-
- >>>> from cppyy import addressof, bind_object
- >>>> e = bind_object(addressof(d), AbstractClass)
- >>>> type(e)
- <class '__main__.AbstractClass'>
- >>>>
-
-* **classes and structs**: Get mapped onto python classes, where they can be
- instantiated as expected.
- If classes are inner classes or live in a namespace, their naming and
- location will reflect that.
- Example::
-
- >>>> from cppyy.gbl import ConcreteClass, Namespace
- >>>> ConcreteClass == Namespace.ConcreteClass
- False
- >>>> n = Namespace.ConcreteClass.NestedClass()
- >>>> type(n)
- <class '__main__.Namespace::ConcreteClass::NestedClass'>
- >>>>
-
-* **data members**: Public data members are represented as python properties
- and provide read and write access on instances as expected.
- Private and protected data members are not accessible.
- Example::
-
- >>>> from cppyy.gbl import ConcreteClass
- >>>> c = ConcreteClass()
- >>>> c.m_int
- 42
- >>>>
-
-* **default arguments**: C++ default arguments work as expected, but python
- keywords are not supported.
- It is technically possible to support keywords, but for the C++ interface,
- the formal argument names have no meaning and are not considered part of the
- API, hence it is not a good idea to use keywords.
- Example::
-
- >>>> from cppyy.gbl import ConcreteClass
- >>>> c = ConcreteClass() # uses default argument
- >>>> c.m_int
- 42
- >>>> c = ConcreteClass(13)
- >>>> c.m_int
- 13
- >>>>
-
-* **doc strings**: The doc string of a method or function contains the C++
- arguments and return types of all overloads of that name, as applicable.
- Example::
-
- >>>> from cppyy.gbl import ConcreteClass
- >>>> print ConcreteClass.array_method.__doc__
- void ConcreteClass::array_method(int*, int)
- void ConcreteClass::array_method(double*, int)
- >>>>
-
-* **enums**: Are translated as ints with no further checking.
-
-* **functions**: Work as expected and live in their appropriate namespace
- (which can be the global one, ``cppyy.gbl``).
-
-* **inheritance**: All combinations of inheritance on the C++ (single,
- multiple, virtual) are supported in the binding.
- However, new python classes can only use single inheritance from a bound C++
- class.
- Multiple inheritance would introduce two "this" pointers in the binding.
- This is a current, not a fundamental, limitation.
- The C++ side will not see any overridden methods on the python side, as
- cross-inheritance is planned but not yet supported.
- Example::
-
- >>>> from cppyy.gbl import ConcreteClass
- >>>> help(ConcreteClass)
- Help on class ConcreteClass in module __main__:
-
- class ConcreteClass(AbstractClass)
- | Method resolution order:
- | ConcreteClass
- | AbstractClass
- | cppyy.CPPObject
- | __builtin__.CPPInstance
- | __builtin__.object
- |
- | Methods defined here:
- |
- | ConcreteClass(self, *args)
- | ConcreteClass::ConcreteClass(const ConcreteClass&)
- | ConcreteClass::ConcreteClass(int)
- | ConcreteClass::ConcreteClass()
- |
- etc. ....
-
-* **memory**: C++ instances created by calling their constructor from python
- are owned by python.
- You can check/change the ownership with the _python_owns flag that every
- bound instance carries.
- Example::
-
- >>>> from cppyy.gbl import ConcreteClass
- >>>> c = ConcreteClass()
- >>>> c._python_owns # True: object created in Python
- True
- >>>>
-
-* **methods**: Are represented as python methods and work as expected.
- They are first class objects and can be bound to an instance.
- Virtual C++ methods work as expected.
- To select a specific virtual method, do like with normal python classes
- that override methods: select it from the class that you need, rather than
- calling the method on the instance.
- To select a specific overload, use the __dispatch__ special function, which
- takes the name of the desired method and its signature (which can be
- obtained from the doc string) as arguments.
-
-* **namespaces**: Are represented as python classes.
- Namespaces are more open-ended than classes, so sometimes initial access may
- result in updates as data and functions are looked up and constructed
- lazily.
- Thus the result of ``dir()`` on a namespace shows the classes available,
- even if they may not have been created yet.
- It does not show classes that could potentially be loaded by the class
- loader.
- Once created, namespaces are registered as modules, to allow importing from
- them.
- Namespace currently do not work with the class loader.
- Fixing these bootstrap problems is on the TODO list.
- The global namespace is ``cppyy.gbl``.
-
-* **NULL**: Is represented as ``cppyy.gbl.nullptr``.
- In C++11, the keyword ``nullptr`` is used to represent ``NULL``.
- For clarity of intent, it is recommended to use this instead of ``None``
- (or the integer ``0``, which can serve in some cases), as ``None`` is better
- understood as ``void`` in C++.
-
-* **operator conversions**: If defined in the C++ class and a python
- equivalent exists (i.e. all builtin integer and floating point types, as well
- as ``bool``), it will map onto that python conversion.
- Note that ``char*`` is mapped onto ``__str__``.
- Example::
-
- >>>> from cppyy.gbl import ConcreteClass
- >>>> print ConcreteClass()
- Hello operator const char*!
- >>>>
-
-* **operator overloads**: If defined in the C++ class and if a python
- equivalent is available (not always the case, think e.g. of ``operator||``),
- then they work as expected.
- Special care needs to be taken for global operator overloads in C++: first,
- make sure that they are actually reflected, especially for the global
- overloads for ``operator==`` and ``operator!=`` of STL vector iterators in
- the case of gcc (note that they are not needed to iterate over a vector).
- Second, make sure that reflection info is loaded in the proper order.
- I.e. that these global overloads are available before use.
-
-* **pointers**: For builtin data types, see arrays.
- For objects, a pointer to an object and an object looks the same, unless
- the pointer is a data member.
- In that case, assigning to the data member will cause a copy of the pointer
- and care should be taken about the object's life time.
- If a pointer is a global variable, the C++ side can replace the underlying
- object and the python side will immediately reflect that.
-
-* **PyObject***: Arguments and return types of ``PyObject*`` can be used, and
- passed on to CPython API calls.
- Since these CPython-like objects need to be created and tracked (this all
- happens through ``cpyext``) this interface is not particularly fast.
-
-* **static data members**: Are represented as python property objects on the
- class and the meta-class.
- Both read and write access is as expected.
-
-* **static methods**: Are represented as python's ``staticmethod`` objects
- and can be called both from the class as well as from instances.
-
-* **strings**: The std::string class is considered a builtin C++ type and
- mixes quite well with python's str.
- Python's str can be passed where a ``const char*`` is expected, and an str
- will be returned if the return type is ``const char*``.
-
-* **templated classes**: Are represented in a meta-class style in python.
- This may look a little bit confusing, but conceptually is rather natural.
- For example, given the class ``std::vector<int>``, the meta-class part would
- be ``std.vector``.
- Then, to get the instantiation on ``int``, do ``std.vector(int)`` and to
- create an instance of that class, do ``std.vector(int)()``::
-
- >>>> import cppyy
- >>>> cppyy.load_reflection_info('libexampleDict.so')
- >>>> cppyy.gbl.std.vector # template metatype
- <cppyy.CppyyTemplateType object at 0x00007fcdd330f1a0>
- >>>> cppyy.gbl.std.vector(int) # instantiates template -> class
- <class '__main__.std::vector<int>'>
- >>>> cppyy.gbl.std.vector(int)() # instantiates class -> object
- <__main__.std::vector<int> object at 0x00007fe480ba4bc0>
- >>>>
-
- Note that templates can be build up by handing actual types to the class
- instantiation (as done in this vector example), or by passing in the list of
- template arguments as a string.
- The former is a lot easier to work with if you have template instantiations
- using classes that themselves are templates in the arguments (think e.g a
- vector of vectors).
- All template classes must already exist in the loaded reflection info, they
- do not work (yet) with the class loader.
-
- For compatibility with other bindings generators, use of square brackets
- instead of parenthesis to instantiate templates is supported as well.
-
-* **templated functions**: Automatically participate in overloading and are
- used in the same way as other global functions.
-
-* **templated methods**: For now, require an explicit selection of the
- template parameters.
- This will be changed to allow them to participate in overloads as expected.
-
-* **typedefs**: Are simple python references to the actual classes to which
- they refer.
-
-* **unary operators**: Are supported if a python equivalent exists, and if the
- operator is defined in the C++ class.
-
-You can always find more detailed examples and see the full of supported
-features by looking at the tests in pypy/module/cppyy/test.
-
-If a feature or reflection info is missing, this is supposed to be handled
-gracefully.
-In fact, there are unit tests explicitly for this purpose (even as their use
-becomes less interesting over time, as the number of missing features
-decreases).
-Only when a missing feature is used, should there be an exception.
-For example, if no reflection info is available for a return type, then a
-class that has a method with that return type can still be used.
-Only that one specific method can not be used.
-
-
-Templates
----------
-
-Templates can be automatically instantiated, assuming the appropriate header
-files have been loaded or are accessible to the class loader.
-This is the case for example for all of STL.
-For example::
-
- $ cat MyTemplate.h
- #include <vector>
-
- class MyClass {
- public:
- MyClass(int i = -99) : m_i(i) {}
- MyClass(const MyClass& s) : m_i(s.m_i) {}
- MyClass& operator=(const MyClass& s) { m_i = s.m_i; return *this; }
- ~MyClass() {}
- int m_i;
- };
-
-Run the normal ``genreflex`` and compilation steps::
-
- $ genreflex MyTemplate.h --selection=MyTemplate.xml
- $ g++ -std=c++11 -fPIC -rdynamic -O2 -shared -I$CPPYYHOME/include
MyTemplate_rflx.cpp -o libTemplateDict.so -L$CPPYYHOME/lib -lCling
-
-Subsequent use should be as expected.
-Note the meta-class style of "instantiating" the template::
-
- >>>> import cppyy
- >>>> cppyy.load_reflection_info("libTemplateDict.so")
- >>>> std = cppyy.gbl.std
- >>>> MyClass = cppyy.gbl.MyClass
- >>>> v = std.vector(MyClass)()
- >>>> v += [MyClass(1), MyClass(2), MyClass(3)]
- >>>> for m in v:
- .... print m.m_i,
- ....
- 1 2 3
- >>>>
-
-The arguments to the template instantiation can either be a string with the
-full list of arguments, or the explicit classes.
-The latter makes for easier code writing if the classes passed to the
-instantiation are themselves templates.
-
-
-The fast lane
--------------
-
-By default, cppyy will use direct function pointers through `CFFI`_ whenever
-possible. If this causes problems for you, you can disable it by setting the
-CPPYY_DISABLE_FASTPATH environment variable.
-
-.. _CFFI: https://cffi.readthedocs.io/en/latest/
-
-
-CPython
--------
-
-Most of the ideas in cppyy come originally from the `PyROOT`_ project, which
-contains a CPython-based cppyy.py module (with similar dependencies as the
-one that comes with PyPy).
-A standalone pip-installable version is planned, but for now you can install
-ROOT through your favorite distribution installer (available in the science
-section).
-
-.. _PyROOT: https://root.cern.ch/pyroot
-
-There are a couple of minor differences between the two versions of cppyy
-(the CPython version has a few more features).
-Work is on-going to integrate the nightly tests of both to make sure their
-feature sets are equalized.
-
-
-Python3
--------
-
-The CPython version of cppyy supports Python3, assuming your packager has
-build the backend for it.
-The cppyy module has not been tested with the `Py3k`_ version of PyPy.
-Note that the generated reflection information (from ``genreflex``) is fully
-independent of Python, and does not need to be rebuild when switching versions
-or interpreters.
-
-.. _Py3k: https://bitbucket.org/pypy/pypy/src/py3k
-
-
-.. toctree::
- :hidden:
-
- cppyy_example
diff --git a/pypy/doc/extending.rst b/pypy/doc/extending.rst
--- a/pypy/doc/extending.rst
+++ b/pypy/doc/extending.rst
@@ -61,29 +61,23 @@
.. _libffi: http://sourceware.org/libffi/
-Cling and cppyy
----------------
+cppyy
+-----
-The builtin :doc:`cppyy <cppyy>` module uses reflection information, provided
by
-`Cling`_ (which needs to be `installed separately`_), of C/C++ code to
-automatically generate bindings at runtime.
-In Python, classes and functions are always runtime structures, so when they
-are generated matters not for performance.
-However, if the backend itself is capable of dynamic behavior, it is a much
-better functional match, allowing tighter integration and more natural
-language mappings.
+For C++, `cppyy`_ is an automated bindings generator available for both
+PyPy and CPython.
+``cppyy`` relies on declarations from C++ header files to dynamically
+construct Python equivalent classes, functions, variables, etc.
+It is designed for use by large scale programs and supports modern C++.
+With PyPy, it leverages the built-in ``_cppyy`` module, allowing the JIT to
+remove most of the cross-language overhead.
-The :doc:`cppyy <cppyy>` module is written in RPython, thus PyPy's JIT is able
to remove
-most cross-language call overhead.
+To install, run ``pip install cppyy``.
+Further details are available in the `full documentation`_.
-:doc:Full details are `available here <cppyy>`.
+.. _cppyy: http://cppyy.readthedocs.org/
+.. _`full documentation`: http://cppyy.readthedocs.org/
-.. _installed separately: https://pypi.python.org/pypi/PyPy-cppyy-backend
-.. _Cling: https://root.cern.ch/cling
-
-.. toctree::
-
- cppyy
RPython Mixed Modules
---------------------
diff --git a/pypy/doc/whatsnew-head.rst b/pypy/doc/whatsnew-head.rst
--- a/pypy/doc/whatsnew-head.rst
+++ b/pypy/doc/whatsnew-head.rst
@@ -25,3 +25,8 @@
.. branch: cpyext-hash_notimpl
If ``tp_hash`` is ``PyObject_HashNotImplemented``, set
``obj.__dict__['__hash__']`` to None
+
+.. branch: cppyy-packaging
+
+Renaming of ``cppyy`` to ``_cppyy``.
+The former is now an external package installable with ``pip install cppyy``.
diff --git a/pypy/module/cppyy/__init__.py b/pypy/module/_cppyy/__init__.py
rename from pypy/module/cppyy/__init__.py
rename to pypy/module/_cppyy/__init__.py
--- a/pypy/module/cppyy/__init__.py
+++ b/pypy/module/_cppyy/__init__.py
@@ -33,11 +33,11 @@
# pythonization functions may be written in RPython, but the interp2app
# code generation is not, so give it a chance to run now
- from pypy.module.cppyy import capi
+ from pypy.module._cppyy import capi
capi.register_pythonizations(space)
def startup(self, space):
- from pypy.module.cppyy import capi
+ from pypy.module._cppyy import capi
capi.verify_backend(space) # may raise ImportError
space.call_method(self, '_init_pythonify')
diff --git a/pypy/module/cppyy/backend/create_cppyy_package.py
b/pypy/module/_cppyy/backend/create_cppyy_package.py
rename from pypy/module/cppyy/backend/create_cppyy_package.py
rename to pypy/module/_cppyy/backend/create_cppyy_package.py
diff --git a/pypy/module/cppyy/bench/Makefile
b/pypy/module/_cppyy/bench/Makefile
rename from pypy/module/cppyy/bench/Makefile
rename to pypy/module/_cppyy/bench/Makefile
diff --git a/pypy/module/cppyy/bench/bench02.cxx
b/pypy/module/_cppyy/bench/bench02.cxx
rename from pypy/module/cppyy/bench/bench02.cxx
rename to pypy/module/_cppyy/bench/bench02.cxx
diff --git a/pypy/module/cppyy/bench/bench02.h
b/pypy/module/_cppyy/bench/bench02.h
rename from pypy/module/cppyy/bench/bench02.h
rename to pypy/module/_cppyy/bench/bench02.h
diff --git a/pypy/module/cppyy/bench/bench02.xml
b/pypy/module/_cppyy/bench/bench02.xml
rename from pypy/module/cppyy/bench/bench02.xml
rename to pypy/module/_cppyy/bench/bench02.xml
diff --git a/pypy/module/cppyy/bench/hsimple.C
b/pypy/module/_cppyy/bench/hsimple.C
rename from pypy/module/cppyy/bench/hsimple.C
rename to pypy/module/_cppyy/bench/hsimple.C
diff --git a/pypy/module/cppyy/bench/hsimple.py
b/pypy/module/_cppyy/bench/hsimple.py
rename from pypy/module/cppyy/bench/hsimple.py
rename to pypy/module/_cppyy/bench/hsimple.py
diff --git a/pypy/module/cppyy/bench/hsimple_rflx.py
b/pypy/module/_cppyy/bench/hsimple_rflx.py
rename from pypy/module/cppyy/bench/hsimple_rflx.py
rename to pypy/module/_cppyy/bench/hsimple_rflx.py
diff --git a/pypy/module/cppyy/capi/__init__.py
b/pypy/module/_cppyy/capi/__init__.py
rename from pypy/module/cppyy/capi/__init__.py
rename to pypy/module/_cppyy/capi/__init__.py
--- a/pypy/module/cppyy/capi/__init__.py
+++ b/pypy/module/_cppyy/capi/__init__.py
@@ -9,10 +9,10 @@
# the selection of the desired backend (default is Reflex).
# choose C-API access method:
-from pypy.module.cppyy.capi.loadable_capi import *
-#from pypy.module.cppyy.capi.builtin_capi import *
+from pypy.module._cppyy.capi.loadable_capi import *
+#from pypy.module._cppyy.capi.builtin_capi import *
-from pypy.module.cppyy.capi.capi_types import C_OBJECT,\
+from pypy.module._cppyy.capi.capi_types import C_OBJECT,\
C_NULL_TYPE, C_NULL_OBJECT
def direct_ptradd(ptr, offset):
diff --git a/pypy/module/cppyy/capi/builtin_capi.py
b/pypy/module/_cppyy/capi/builtin_capi.py
rename from pypy/module/cppyy/capi/builtin_capi.py
rename to pypy/module/_cppyy/capi/builtin_capi.py
--- a/pypy/module/cppyy/capi/builtin_capi.py
+++ b/pypy/module/_cppyy/capi/builtin_capi.py
@@ -4,7 +4,7 @@
import cling_capi as backend
-from pypy.module.cppyy.capi.capi_types import C_SCOPE, C_TYPE, C_OBJECT,\
+from pypy.module._cppyy.capi.capi_types import C_SCOPE, C_TYPE, C_OBJECT,\
C_METHOD, C_INDEX, C_INDEX_ARRAY, WLAVC_INDEX, C_FUNC_PTR
identify = backend.identify
diff --git a/pypy/module/cppyy/capi/capi_types.py
b/pypy/module/_cppyy/capi/capi_types.py
rename from pypy/module/cppyy/capi/capi_types.py
rename to pypy/module/_cppyy/capi/capi_types.py
diff --git a/pypy/module/cppyy/capi/cling_capi.py
b/pypy/module/_cppyy/capi/cling_capi.py
rename from pypy/module/cppyy/capi/cling_capi.py
rename to pypy/module/_cppyy/capi/cling_capi.py
--- a/pypy/module/cppyy/capi/cling_capi.py
+++ b/pypy/module/_cppyy/capi/cling_capi.py
@@ -11,7 +11,7 @@
from rpython.rlib import jit, libffi, rdynload
from pypy.module._rawffi.array import W_ArrayInstance
-from pypy.module.cppyy.capi.capi_types import C_OBJECT
+from pypy.module._cppyy.capi.capi_types import C_OBJECT
__all__ = ['identify', 'std_string_name', 'eci', 'c_load_dictionary']
@@ -99,7 +99,7 @@
def stdstring_c_str(space, w_self):
"""Return a python string taking into account \0"""
- from pypy.module.cppyy import interp_cppyy
+ from pypy.module._cppyy import interp_cppyy
cppstr = space.interp_w(interp_cppyy.W_CPPInstance, w_self,
can_be_None=False)
return space.wrap(c_stdstring2charp(space, cppstr._rawobject))
@@ -112,12 +112,12 @@
W_AbstractSeqIterObject.__init__(self, w_vector)
# TODO: this should live in rpythonize.py or something so that the
# imports can move to the top w/o getting circles
- from pypy.module.cppyy import interp_cppyy
+ from pypy.module._cppyy import interp_cppyy
assert isinstance(w_vector, interp_cppyy.W_CPPInstance)
vector = space.interp_w(interp_cppyy.W_CPPInstance, w_vector)
self.overload = vector.cppclass.get_overload("__getitem__")
- from pypy.module.cppyy import capi
+ from pypy.module._cppyy import capi
v_type = capi.c_stdvector_valuetype(space, vector.cppclass.name)
v_size = capi.c_stdvector_valuesize(space, vector.cppclass.name)
@@ -131,7 +131,7 @@
self.data = rffi.cast(rffi.VOIDP, space.uint_w(arr.getbuffer(space)))
- from pypy.module.cppyy import converter
+ from pypy.module._cppyy import converter
self.converter = converter.get_converter(space, v_type, '')
self.len =
space.uint_w(vector.cppclass.get_overload("size").call(w_vector, []))
self.stride = v_size
@@ -143,7 +143,7 @@
self.w_seq = None
raise OperationError(space.w_StopIteration, space.w_None)
try:
- from pypy.module.cppyy import capi # TODO: refector
+ from pypy.module._cppyy import capi # TODO: refector
offset = capi.direct_ptradd(rffi.cast(C_OBJECT, self.data),
self.index*self.stride)
w_item = self.converter.from_memory(space, space.w_None,
space.w_None, offset)
except OperationError as e:
@@ -186,7 +186,7 @@
_method_alias(space, w_pycppclass, "__str__", "c_str")
if "vector" in name[:11]: # len('std::vector') == 11
- from pypy.module.cppyy import capi
+ from pypy.module._cppyy import capi
v_type = capi.c_stdvector_valuetype(space, name)
if v_type:
space.setattr(w_pycppclass, space.wrap("value_type"),
space.wrap(v_type))
diff --git a/pypy/module/cppyy/capi/loadable_capi.py
b/pypy/module/_cppyy/capi/loadable_capi.py
rename from pypy/module/cppyy/capi/loadable_capi.py
rename to pypy/module/_cppyy/capi/loadable_capi.py
--- a/pypy/module/cppyy/capi/loadable_capi.py
+++ b/pypy/module/_cppyy/capi/loadable_capi.py
@@ -9,9 +9,9 @@
from pypy.module._cffi_backend import ctypefunc, ctypeprim, cdataobj, misc
from pypy.module._cffi_backend import newtype
-from pypy.module.cppyy import ffitypes
+from pypy.module._cppyy import ffitypes
-from pypy.module.cppyy.capi.capi_types import C_SCOPE, C_TYPE, C_OBJECT,\
+from pypy.module._cppyy.capi.capi_types import C_SCOPE, C_TYPE, C_OBJECT,\
C_METHOD, C_INDEX, C_INDEX_ARRAY, WLAVC_INDEX, C_FUNC_PTR
@@ -599,7 +599,7 @@
def stdstring_c_str(space, w_self):
"""Return a python string taking into account \0"""
- from pypy.module.cppyy import interp_cppyy
+ from pypy.module._cppyy import interp_cppyy
cppstr = space.interp_w(interp_cppyy.W_CPPInstance, w_self,
can_be_None=False)
return space.newtext(c_stdstring2charp(space, cppstr._rawobject))
diff --git a/pypy/module/cppyy/converter.py b/pypy/module/_cppyy/converter.py
rename from pypy/module/cppyy/converter.py
rename to pypy/module/_cppyy/converter.py
--- a/pypy/module/cppyy/converter.py
+++ b/pypy/module/_cppyy/converter.py
@@ -9,7 +9,7 @@
from pypy.module._rawffi.interp_rawffi import letter2tp
from pypy.module._rawffi.array import W_Array, W_ArrayInstance
-from pypy.module.cppyy import helper, capi, ffitypes
+from pypy.module._cppyy import helper, capi, ffitypes
# Converter objects are used to translate between RPython and C++. They are
# defined by the type name for which they provide conversion. Uses are for
@@ -22,7 +22,7 @@
def get_rawobject(space, w_obj):
- from pypy.module.cppyy.interp_cppyy import W_CPPInstance
+ from pypy.module._cppyy.interp_cppyy import W_CPPInstance
cppinstance = space.interp_w(W_CPPInstance, w_obj, can_be_None=True)
if cppinstance:
rawobject = cppinstance.get_rawobject()
@@ -31,14 +31,14 @@
return capi.C_NULL_OBJECT
def set_rawobject(space, w_obj, address):
- from pypy.module.cppyy.interp_cppyy import W_CPPInstance
+ from pypy.module._cppyy.interp_cppyy import W_CPPInstance
cppinstance = space.interp_w(W_CPPInstance, w_obj, can_be_None=True)
if cppinstance:
assert lltype.typeOf(cppinstance._rawobject) == capi.C_OBJECT
cppinstance._rawobject = rffi.cast(capi.C_OBJECT, address)
def get_rawobject_nonnull(space, w_obj):
- from pypy.module.cppyy.interp_cppyy import W_CPPInstance
+ from pypy.module._cppyy.interp_cppyy import W_CPPInstance
cppinstance = space.interp_w(W_CPPInstance, w_obj, can_be_None=True)
if cppinstance:
cppinstance._nullcheck()
@@ -56,7 +56,7 @@
except Exception:
pass
# None or nullptr
- from pypy.module.cppyy import interp_cppyy
+ from pypy.module._cppyy import interp_cppyy
return space.is_true(space.is_(w_obj, space.w_None)) or \
space.is_true(space.is_(w_obj, interp_cppyy.get_nullptr(space)))
@@ -104,18 +104,18 @@
"no converter available for '%s'", self.name)
def cffi_type(self, space):
- from pypy.module.cppyy.interp_cppyy import FastCallNotPossible
+ from pypy.module._cppyy.interp_cppyy import FastCallNotPossible
raise FastCallNotPossible
def convert_argument(self, space, w_obj, address, call_local):
self._is_abstract(space)
def convert_argument_libffi(self, space, w_obj, address, call_local):
- from pypy.module.cppyy.interp_cppyy import FastCallNotPossible
+ from pypy.module._cppyy.interp_cppyy import FastCallNotPossible
raise FastCallNotPossible
def default_argument_libffi(self, space, address):
- from pypy.module.cppyy.interp_cppyy import FastCallNotPossible
+ from pypy.module._cppyy.interp_cppyy import FastCallNotPossible
raise FastCallNotPossible
def from_memory(self, space, w_obj, w_pycppclass, offset):
@@ -362,7 +362,7 @@
return state.c_voidp
def convert_argument_libffi(self, space, w_obj, address, call_local):
- from pypy.module.cppyy.interp_cppyy import FastCallNotPossible
+ from pypy.module._cppyy.interp_cppyy import FastCallNotPossible
raise FastCallNotPossible
class DoubleConverter(ffitypes.typeid(rffi.DOUBLE), FloatTypeConverterMixin,
TypeConverter):
@@ -442,7 +442,7 @@
address = self._get_raw_address(space, w_obj, offset)
ptrval = rffi.cast(rffi.ULONG, rffi.cast(rffi.VOIDPP, address)[0])
if ptrval == 0:
- from pypy.module.cppyy import interp_cppyy
+ from pypy.module._cppyy import interp_cppyy
return interp_cppyy.get_nullptr(space)
arr = space.interp_w(W_Array, letter2tp(space, 'P'))
return arr.fromaddress(space, ptrval, sys.maxint)
@@ -488,12 +488,12 @@
typecode = 'V'
def __init__(self, space, cppclass):
- from pypy.module.cppyy.interp_cppyy import W_CPPClass
+ from pypy.module._cppyy.interp_cppyy import W_CPPClass
assert isinstance(cppclass, W_CPPClass)
self.cppclass = cppclass
def _unwrap_object(self, space, w_obj):
- from pypy.module.cppyy.interp_cppyy import W_CPPInstance
+ from pypy.module._cppyy.interp_cppyy import W_CPPInstance
if isinstance(w_obj, W_CPPInstance):
if capi.c_is_subtype(space, w_obj.cppclass, self.cppclass):
rawobject = w_obj.get_rawobject()
@@ -521,12 +521,12 @@
class InstanceConverter(InstanceRefConverter):
def convert_argument_libffi(self, space, w_obj, address, call_local):
- from pypy.module.cppyy.interp_cppyy import FastCallNotPossible
+ from pypy.module._cppyy.interp_cppyy import FastCallNotPossible
raise FastCallNotPossible # TODO: by-value is a jit_libffi
special case
def from_memory(self, space, w_obj, w_pycppclass, offset):
address = rffi.cast(capi.C_OBJECT, self._get_raw_address(space, w_obj,
offset))
- from pypy.module.cppyy import interp_cppyy
+ from pypy.module._cppyy import interp_cppyy
return interp_cppyy.wrap_cppobject(space, address, self.cppclass,
do_cast=False)
def to_memory(self, space, w_obj, w_value, offset):
@@ -547,7 +547,7 @@
def from_memory(self, space, w_obj, w_pycppclass, offset):
address = rffi.cast(capi.C_OBJECT, self._get_raw_address(space, w_obj,
offset))
- from pypy.module.cppyy import interp_cppyy
+ from pypy.module._cppyy import interp_cppyy
return interp_cppyy.wrap_cppobject(space, address, self.cppclass,
do_cast=False)
def to_memory(self, space, w_obj, w_value, offset):
@@ -570,30 +570,30 @@
def convert_argument_libffi(self, space, w_obj, address, call_local):
# TODO: finalize_call not yet called for fast call (see
interp_cppyy.py)
- from pypy.module.cppyy.interp_cppyy import FastCallNotPossible
+ from pypy.module._cppyy.interp_cppyy import FastCallNotPossible
raise FastCallNotPossible
def finalize_call(self, space, w_obj, call_local):
- from pypy.module.cppyy.interp_cppyy import W_CPPInstance
+ from pypy.module._cppyy.interp_cppyy import W_CPPInstance
assert isinstance(w_obj, W_CPPInstance)
r = rffi.cast(rffi.VOIDPP, call_local)
w_obj._rawobject = rffi.cast(capi.C_OBJECT, r[0])
def from_memory(self, space, w_obj, w_pycppclass, offset):
address = rffi.cast(capi.C_OBJECT, self._get_raw_address(space, w_obj,
offset))
- from pypy.module.cppyy import interp_cppyy
+ from pypy.module._cppyy import interp_cppyy
return interp_cppyy.wrap_cppobject(space, address, self.cppclass,
do_cast=False, is_ref=True)
class StdStringConverter(InstanceConverter):
def __init__(self, space, extra):
- from pypy.module.cppyy import interp_cppyy
+ from pypy.module._cppyy import interp_cppyy
cppclass = interp_cppyy.scope_byname(space, capi.std_string_name)
InstanceConverter.__init__(self, space, cppclass)
def _unwrap_object(self, space, w_obj):
- from pypy.module.cppyy.interp_cppyy import W_CPPInstance
+ from pypy.module._cppyy.interp_cppyy import W_CPPInstance
if isinstance(w_obj, W_CPPInstance):
arg = InstanceConverter._unwrap_object(self, space, w_obj)
return capi.c_stdstring2stdstring(space, arg)
@@ -604,7 +604,7 @@
try:
address = rffi.cast(capi.C_OBJECT, self._get_raw_address(space,
w_obj, offset))
assign = self.cppclass.get_overload("__assign__")
- from pypy.module.cppyy import interp_cppyy
+ from pypy.module._cppyy import interp_cppyy
assign.call(
interp_cppyy.wrap_cppobject(space, address, self.cppclass,
do_cast=False), [w_value])
except Exception:
@@ -619,7 +619,7 @@
typecode = 'V'
def __init__(self, space, extra):
- from pypy.module.cppyy import interp_cppyy
+ from pypy.module._cppyy import interp_cppyy
cppclass = interp_cppyy.scope_byname(space, capi.std_string_name)
InstancePtrConverter.__init__(self, space, cppclass)
@@ -642,7 +642,7 @@
def convert_argument_libffi(self, space, w_obj, address, call_local):
# TODO: free_argument not yet called for fast call (see
interp_cppyy.py)
- from pypy.module.cppyy.interp_cppyy import FastCallNotPossible
+ from pypy.module._cppyy.interp_cppyy import FastCallNotPossible
raise FastCallNotPossible
# proposed implementation:
@@ -709,11 +709,11 @@
# 3) TODO: accept ref as pointer
# 4) generalized cases (covers basically all user classes)
- from pypy.module.cppyy import interp_cppyy
+ from pypy.module._cppyy import interp_cppyy
cppclass = interp_cppyy.scope_byname(space, clean_name)
if cppclass:
# type check for the benefit of the annotator
- from pypy.module.cppyy.interp_cppyy import W_CPPClass
+ from pypy.module._cppyy.interp_cppyy import W_CPPClass
cppclass = space.interp_w(W_CPPClass, cppclass, can_be_None=False)
if compound == "*":
return InstancePtrConverter(space, cppclass)
@@ -874,12 +874,12 @@
class TStringConverter(InstanceConverter):
def __init__(self, space, extra):
- from pypy.module.cppyy import interp_cppyy
+ from pypy.module._cppyy import interp_cppyy
cppclass = interp_cppyy.scope_byname(space, "TString")
InstanceConverter.__init__(self, space, cppclass)
def _unwrap_object(self, space, w_obj):
- from pypy.module.cppyy import interp_cppyy
+ from pypy.module._cppyy import interp_cppyy
if isinstance(w_obj, interp_cppyy.W_CPPInstance):
arg = InstanceConverter._unwrap_object(self, space, w_obj)
return capi.backend.c_TString2TString(space, arg)
diff --git a/pypy/module/cppyy/executor.py b/pypy/module/_cppyy/executor.py
rename from pypy/module/cppyy/executor.py
rename to pypy/module/_cppyy/executor.py
--- a/pypy/module/cppyy/executor.py
+++ b/pypy/module/_cppyy/executor.py
@@ -8,7 +8,7 @@
from pypy.module._rawffi.interp_rawffi import unpack_simple_shape
from pypy.module._rawffi.array import W_Array, W_ArrayInstance
-from pypy.module.cppyy import helper, capi, ffitypes
+from pypy.module._cppyy import helper, capi, ffitypes
# Executor objects are used to dispatch C++ methods. They are defined by their
# return type only: arguments are converted by Converter objects, and Executors
@@ -31,7 +31,7 @@
pass
def cffi_type(self, space):
- from pypy.module.cppyy.interp_cppyy import FastCallNotPossible
+ from pypy.module._cppyy.interp_cppyy import FastCallNotPossible
raise FastCallNotPossible
def execute(self, space, cppmethod, cppthis, num_args, args):
@@ -39,7 +39,7 @@
"return type not available or supported")
def execute_libffi(self, space, cif_descr, funcaddr, buffer):
- from pypy.module.cppyy.interp_cppyy import FastCallNotPossible
+ from pypy.module._cppyy.interp_cppyy import FastCallNotPossible
raise FastCallNotPossible
@@ -58,7 +58,7 @@
ptrval = rffi.cast(rffi.ULONG, lresult)
arr = space.interp_w(W_Array, unpack_simple_shape(space,
space.newtext(self.typecode)))
if ptrval == 0:
- from pypy.module.cppyy import interp_cppyy
+ from pypy.module._cppyy import interp_cppyy
return interp_cppyy.get_nullptr(space)
return arr.fromaddress(space, ptrval, sys.maxint)
@@ -138,7 +138,7 @@
class ConstructorExecutor(FunctionExecutor):
def execute(self, space, cppmethod, cpptype, num_args, args):
- from pypy.module.cppyy import interp_cppyy
+ from pypy.module._cppyy import interp_cppyy
newthis = capi.c_constructor(space, cppmethod, cpptype, num_args, args)
assert lltype.typeOf(newthis) == capi.C_OBJECT
return space.newlong(rffi.cast(rffi.LONG, newthis)) # really want
ptrdiff_t here
@@ -156,7 +156,7 @@
return state.c_voidp
def execute(self, space, cppmethod, cppthis, num_args, args):
- from pypy.module.cppyy import interp_cppyy
+ from pypy.module._cppyy import interp_cppyy
long_result = capi.c_call_l(space, cppmethod, cppthis, num_args, args)
ptr_result = rffi.cast(capi.C_OBJECT, long_result)
pyres = interp_cppyy.wrap_cppobject(space, ptr_result, self.cppclass)
@@ -165,34 +165,34 @@
def execute_libffi(self, space, cif_descr, funcaddr, buffer):
jit_libffi.jit_ffi_call(cif_descr, funcaddr, buffer)
result = rffi.ptradd(buffer, cif_descr.exchange_result)
- from pypy.module.cppyy import interp_cppyy
+ from pypy.module._cppyy import interp_cppyy
ptr_result = rffi.cast(capi.C_OBJECT, rffi.cast(rffi.VOIDPP,
result)[0])
return interp_cppyy.wrap_cppobject(space, ptr_result, self.cppclass)
class InstancePtrPtrExecutor(InstancePtrExecutor):
def execute(self, space, cppmethod, cppthis, num_args, args):
- from pypy.module.cppyy import interp_cppyy
+ from pypy.module._cppyy import interp_cppyy
voidp_result = capi.c_call_r(space, cppmethod, cppthis, num_args, args)
ref_address = rffi.cast(rffi.VOIDPP, voidp_result)
ptr_result = rffi.cast(capi.C_OBJECT, ref_address[0])
return interp_cppyy.wrap_cppobject(space, ptr_result, self.cppclass)
def execute_libffi(self, space, cif_descr, funcaddr, buffer):
- from pypy.module.cppyy.interp_cppyy import FastCallNotPossible
+ from pypy.module._cppyy.interp_cppyy import FastCallNotPossible
raise FastCallNotPossible
class InstanceExecutor(InstancePtrExecutor):
def execute(self, space, cppmethod, cppthis, num_args, args):
- from pypy.module.cppyy import interp_cppyy
+ from pypy.module._cppyy import interp_cppyy
long_result = capi.c_call_o(space, cppmethod, cppthis, num_args, args,
self.cppclass)
ptr_result = rffi.cast(capi.C_OBJECT, long_result)
return interp_cppyy.wrap_cppobject(space, ptr_result, self.cppclass,
do_cast=False, python_owns=True,
fresh=True)
def execute_libffi(self, space, cif_descr, funcaddr, buffer):
- from pypy.module.cppyy.interp_cppyy import FastCallNotPossible
+ from pypy.module._cppyy.interp_cppyy import FastCallNotPossible
raise FastCallNotPossible
@@ -205,13 +205,13 @@
return space.newbytes(pystr)
def execute_libffi(self, space, cif_descr, funcaddr, buffer):
- from pypy.module.cppyy.interp_cppyy import FastCallNotPossible
+ from pypy.module._cppyy.interp_cppyy import FastCallNotPossible
raise FastCallNotPossible
class StdStringRefExecutor(InstancePtrExecutor):
def __init__(self, space, cppclass):
- from pypy.module.cppyy import interp_cppyy
+ from pypy.module._cppyy import interp_cppyy
cppclass = interp_cppyy.scope_byname(space, capi.std_string_name)
InstancePtrExecutor.__init__(self, space, cppclass)
@@ -277,11 +277,11 @@
pass
# 3) types/classes, either by ref/ptr or by value
- from pypy.module.cppyy import interp_cppyy
+ from pypy.module._cppyy import interp_cppyy
cppclass = interp_cppyy.scope_byname(space, clean_name)
if cppclass:
# type check for the benefit of the annotator
- from pypy.module.cppyy.interp_cppyy import W_CPPClass
+ from pypy.module._cppyy.interp_cppyy import W_CPPClass
cppclass = space.interp_w(W_CPPClass, cppclass, can_be_None=False)
if compound == '':
return InstanceExecutor(space, cppclass)
diff --git a/pypy/module/cppyy/ffitypes.py b/pypy/module/_cppyy/ffitypes.py
rename from pypy/module/cppyy/ffitypes.py
rename to pypy/module/_cppyy/ffitypes.py
--- a/pypy/module/cppyy/ffitypes.py
+++ b/pypy/module/_cppyy/ffitypes.py
@@ -82,12 +82,13 @@
value = rffi.cast(rffi.CHAR, space.c_int_w(w_value))
else:
- value = space.bytes_w(w_value)
+ value = space.text_w(w_value)
+ if len(value) != 1:
+ raise oefmt(space.w_ValueError,
+ "char expected, got string of size %d", len(value))
+ value = rffi.cast(rffi.CHAR, value[0])
- if len(value) != 1:
- raise oefmt(space.w_ValueError,
- "char expected, got string of size %d", len(value))
- return value[0] # turn it into a "char" to the annotator
+ return value # turn it into a "char" to the annotator
def cffi_type(self, space):
state = space.fromcache(State)
diff --git a/pypy/module/cppyy/genreflex-methptrgetter.patch
b/pypy/module/_cppyy/genreflex-methptrgetter.patch
rename from pypy/module/cppyy/genreflex-methptrgetter.patch
rename to pypy/module/_cppyy/genreflex-methptrgetter.patch
diff --git a/pypy/module/cppyy/helper.py b/pypy/module/_cppyy/helper.py
rename from pypy/module/cppyy/helper.py
rename to pypy/module/_cppyy/helper.py
--- a/pypy/module/cppyy/helper.py
+++ b/pypy/module/_cppyy/helper.py
@@ -64,7 +64,7 @@
_operator_mappings = {}
def map_operator_name(space, cppname, nargs, result_type):
- from pypy.module.cppyy import capi
+ from pypy.module._cppyy import capi
if cppname[0:8] == "operator":
op = cppname[8:].strip(' ')
diff --git a/pypy/module/cppyy/include/capi.h
b/pypy/module/_cppyy/include/capi.h
rename from pypy/module/cppyy/include/capi.h
rename to pypy/module/_cppyy/include/capi.h
diff --git a/pypy/module/cppyy/include/clingcwrapper.h
b/pypy/module/_cppyy/include/clingcwrapper.h
rename from pypy/module/cppyy/include/clingcwrapper.h
rename to pypy/module/_cppyy/include/clingcwrapper.h
diff --git a/pypy/module/cppyy/include/cpp_cppyy.h
b/pypy/module/_cppyy/include/cpp_cppyy.h
rename from pypy/module/cppyy/include/cpp_cppyy.h
rename to pypy/module/_cppyy/include/cpp_cppyy.h
diff --git a/pypy/module/cppyy/include/cppyy.h
b/pypy/module/_cppyy/include/cppyy.h
rename from pypy/module/cppyy/include/cppyy.h
rename to pypy/module/_cppyy/include/cppyy.h
diff --git a/pypy/module/cppyy/interp_cppyy.py
b/pypy/module/_cppyy/interp_cppyy.py
rename from pypy/module/cppyy/interp_cppyy.py
rename to pypy/module/_cppyy/interp_cppyy.py
--- a/pypy/module/cppyy/interp_cppyy.py
+++ b/pypy/module/_cppyy/interp_cppyy.py
@@ -1,4 +1,4 @@
-import pypy.module.cppyy.capi as capi
+import pypy.module._cppyy.capi as capi
from pypy.interpreter.error import OperationError, oefmt
from pypy.interpreter.gateway import interp2app, unwrap_spec
@@ -12,7 +12,7 @@
from rpython.rlib.objectmodel import we_are_translated, keepalive_until_here
from pypy.module._cffi_backend import ctypefunc
-from pypy.module.cppyy import converter, executor, ffitypes, helper
+from pypy.module._cppyy import converter, executor, ffitypes, helper
class FastCallNotPossible(Exception):
diff --git a/pypy/module/cppyy/pythonify.py b/pypy/module/_cppyy/pythonify.py
rename from pypy/module/cppyy/pythonify.py
rename to pypy/module/_cppyy/pythonify.py
--- a/pypy/module/cppyy/pythonify.py
+++ b/pypy/module/_cppyy/pythonify.py
@@ -1,5 +1,5 @@
# NOT_RPYTHON
-# do not load cppyy here, see _init_pythonify()
+# do not load _cppyy here, see _init_pythonify()
import types
import sys
@@ -35,8 +35,8 @@
def _arg_to_str(self, arg):
if arg == str:
- import cppyy
- arg = cppyy._std_string_name()
+ import _cppyy
+ arg = _cppyy._std_string_name()
elif type(arg) != str:
arg = arg.__name__
return arg
@@ -99,8 +99,8 @@
else:
d = dict()
def cpp_proxy_loader(cls):
- import cppyy
- cpp_proxy = cppyy._scope_byname(cls.__name__ != '::' and
cls.__name__ or '')
+ import _cppyy
+ cpp_proxy = _cppyy._scope_byname(cls.__name__ != '::' and
cls.__name__ or '')
del cls.__class__._cpp_proxy
cls._cpp_proxy = cpp_proxy
return cpp_proxy
@@ -126,7 +126,7 @@
setattr(metans, dm_name, cppdm)
modname = pycppns.__name__.replace('::', '.')
- sys.modules['cppyy.gbl.'+modname] = pycppns
+ sys.modules['_cppyy.gbl.'+modname] = pycppns
return pycppns
def _drop_cycles(bases):
@@ -141,8 +141,8 @@
def make_new(class_name):
def __new__(cls, *args):
# create a place-holder only as there may be a derived class defined
- import cppyy
- instance = cppyy.bind_object(0, class_name, True)
+ import _cppyy
+ instance = _cppyy.bind_object(0, class_name, True)
if not instance.__class__ is cls:
instance.__class__ = cls # happens for derived class
return instance
@@ -202,8 +202,8 @@
# the call to register will add back-end specific pythonizations and thus
# needs to run first, so that the generic pythonizations can use them
- import cppyy
- cppyy._register_class(pycppclass)
+ import _cppyy
+ _cppyy._register_class(pycppclass)
_pythonize(pycppclass)
return pycppclass
@@ -212,18 +212,18 @@
def get_pycppitem(scope, name):
- import cppyy
+ import _cppyy
# resolve typedefs/aliases
full_name = (scope == gbl) and name or (scope.__name__+'::'+name)
- true_name = cppyy._resolve_name(full_name)
+ true_name = _cppyy._resolve_name(full_name)
if true_name != full_name:
return get_pycppclass(true_name)
pycppitem = None
# classes
- cppitem = cppyy._scope_byname(true_name)
+ cppitem = _cppyy._scope_byname(true_name)
if cppitem:
if cppitem.is_namespace():
pycppitem = make_cppnamespace(scope, true_name, cppitem)
@@ -233,7 +233,7 @@
# templates
if not cppitem:
- cppitem = cppyy._template_byname(true_name)
+ cppitem = _cppyy._template_byname(true_name)
if cppitem:
pycppitem = make_cpptemplatetype(scope, name)
setattr(scope, name, pycppitem)
@@ -323,7 +323,7 @@
# general note: use 'in pyclass.__dict__' rather than 'hasattr' to prevent
# adding pythonizations multiple times in derived classes
- import cppyy
+ import _cppyy
# map __eq__/__ne__ through a comparison to None
if '__eq__' in pyclass.__dict__:
@@ -362,8 +362,8 @@
# also the fallback on the indexed __getitem__, but that is slower)
if not 'vector' in pyclass.__name__[:11] and \
('begin' in pyclass.__dict__ and 'end' in pyclass.__dict__):
- if cppyy._scope_byname(pyclass.__name__+'::iterator') or \
- cppyy._scope_byname(pyclass.__name__+'::const_iterator'):
+ if _cppyy._scope_byname(pyclass.__name__+'::iterator') or \
+ _cppyy._scope_byname(pyclass.__name__+'::const_iterator'):
def __iter__(self):
i = self.begin()
while i != self.end():
@@ -383,7 +383,7 @@
pyclass.__getitem__ = python_style_getitem
# string comparisons
- if pyclass.__name__ == cppyy._std_string_name():
+ if pyclass.__name__ == _cppyy._std_string_name():
def eq(self, other):
if type(other) == pyclass:
return self.c_str() == other.c_str()
@@ -410,29 +410,29 @@
try:
return _loaded_dictionaries[name]
except KeyError:
- import cppyy
- lib = cppyy._load_dictionary(name)
+ import _cppyy
+ lib = _cppyy._load_dictionary(name)
_loaded_dictionaries[name] = lib
return lib
def _init_pythonify():
- # cppyy should not be loaded at the module level, as that will trigger a
- # call to space.getbuiltinmodule(), which will cause cppyy to be loaded
- # at pypy-c startup, rather than on the "import cppyy" statement
- import cppyy
+ # _cppyy should not be loaded at the module level, as that will trigger a
+ # call to space.getbuiltinmodule(), which will cause _cppyy to be loaded
+ # at pypy-c startup, rather than on the "import _cppyy" statement
+ import _cppyy
# root of all proxy classes: CPPInstance in pythonify exists to combine the
# CPPClass meta class with the interp-level CPPInstanceBase
global CPPInstance
- class CPPInstance(cppyy.CPPInstanceBase):
+ class CPPInstance(_cppyy.CPPInstanceBase):
__metaclass__ = CPPClass
pass
# class generator callback
- cppyy._set_class_generator(clgen_callback)
+ _cppyy._set_class_generator(clgen_callback)
# function generator callback
- cppyy._set_function_generator(fngen_callback)
+ _cppyy._set_function_generator(fngen_callback)
# user interface objects (note the two-step of not calling scope_byname
here:
# creation of global functions may cause the creation of classes in the
global
@@ -450,14 +450,14 @@
setattr(gbl, 'internal_enum_type_t', int)
# install nullptr as a unique reference
- setattr(gbl, 'nullptr', cppyy._get_nullptr())
+ setattr(gbl, 'nullptr', _cppyy._get_nullptr())
# install for user access
- cppyy.gbl = gbl
+ _cppyy.gbl = gbl
# install as modules to allow importing from
- sys.modules['cppyy.gbl'] = gbl
- sys.modules['cppyy.gbl.std'] = gbl.std
+ sys.modules['_cppyy.gbl'] = gbl
+ sys.modules['_cppyy.gbl.std'] = gbl.std
# user-defined pythonizations interface
_pythonizations = {}
diff --git a/pypy/module/cppyy/src/callcontext.h
b/pypy/module/_cppyy/src/callcontext.h
rename from pypy/module/cppyy/src/callcontext.h
rename to pypy/module/_cppyy/src/callcontext.h
diff --git a/pypy/module/cppyy/src/clingcwrapper.cxx
b/pypy/module/_cppyy/src/clingcwrapper.cxx
rename from pypy/module/cppyy/src/clingcwrapper.cxx
rename to pypy/module/_cppyy/src/clingcwrapper.cxx
diff --git a/pypy/module/cppyy/src/dummy_backend.cxx
b/pypy/module/_cppyy/src/dummy_backend.cxx
rename from pypy/module/cppyy/src/dummy_backend.cxx
rename to pypy/module/_cppyy/src/dummy_backend.cxx
diff --git a/pypy/module/cppyy/test/Makefile b/pypy/module/_cppyy/test/Makefile
rename from pypy/module/cppyy/test/Makefile
rename to pypy/module/_cppyy/test/Makefile
diff --git a/pypy/module/cppyy/test/__init__.py
b/pypy/module/_cppyy/test/__init__.py
rename from pypy/module/cppyy/test/__init__.py
rename to pypy/module/_cppyy/test/__init__.py
diff --git a/pypy/module/cppyy/test/advancedcpp.cxx
b/pypy/module/_cppyy/test/advancedcpp.cxx
rename from pypy/module/cppyy/test/advancedcpp.cxx
rename to pypy/module/_cppyy/test/advancedcpp.cxx
diff --git a/pypy/module/cppyy/test/advancedcpp.h
b/pypy/module/_cppyy/test/advancedcpp.h
rename from pypy/module/cppyy/test/advancedcpp.h
rename to pypy/module/_cppyy/test/advancedcpp.h
diff --git a/pypy/module/cppyy/test/advancedcpp.xml
b/pypy/module/_cppyy/test/advancedcpp.xml
rename from pypy/module/cppyy/test/advancedcpp.xml
rename to pypy/module/_cppyy/test/advancedcpp.xml
diff --git a/pypy/module/cppyy/test/advancedcpp2.cxx
b/pypy/module/_cppyy/test/advancedcpp2.cxx
rename from pypy/module/cppyy/test/advancedcpp2.cxx
rename to pypy/module/_cppyy/test/advancedcpp2.cxx
diff --git a/pypy/module/cppyy/test/advancedcpp2.h
b/pypy/module/_cppyy/test/advancedcpp2.h
rename from pypy/module/cppyy/test/advancedcpp2.h
rename to pypy/module/_cppyy/test/advancedcpp2.h
diff --git a/pypy/module/cppyy/test/advancedcpp2.xml
b/pypy/module/_cppyy/test/advancedcpp2.xml
rename from pypy/module/cppyy/test/advancedcpp2.xml
rename to pypy/module/_cppyy/test/advancedcpp2.xml
diff --git a/pypy/module/cppyy/test/advancedcpp2_LinkDef.h
b/pypy/module/_cppyy/test/advancedcpp2_LinkDef.h
rename from pypy/module/cppyy/test/advancedcpp2_LinkDef.h
rename to pypy/module/_cppyy/test/advancedcpp2_LinkDef.h
diff --git a/pypy/module/cppyy/test/advancedcpp_LinkDef.h
b/pypy/module/_cppyy/test/advancedcpp_LinkDef.h
rename from pypy/module/cppyy/test/advancedcpp_LinkDef.h
rename to pypy/module/_cppyy/test/advancedcpp_LinkDef.h
diff --git a/pypy/module/cppyy/test/bench1.cxx
b/pypy/module/_cppyy/test/bench1.cxx
rename from pypy/module/cppyy/test/bench1.cxx
rename to pypy/module/_cppyy/test/bench1.cxx
diff --git a/pypy/module/cppyy/test/bench1.py
b/pypy/module/_cppyy/test/bench1.py
rename from pypy/module/cppyy/test/bench1.py
rename to pypy/module/_cppyy/test/bench1.py
diff --git a/pypy/module/cppyy/test/conftest.py
b/pypy/module/_cppyy/test/conftest.py
rename from pypy/module/cppyy/test/conftest.py
rename to pypy/module/_cppyy/test/conftest.py
--- a/pypy/module/cppyy/test/conftest.py
+++ b/pypy/module/_cppyy/test/conftest.py
@@ -3,7 +3,7 @@
@py.test.mark.tryfirst
def pytest_runtest_setup(item):
if py.path.local.sysfind('genreflex') is None:
- import pypy.module.cppyy.capi.loadable_capi as lcapi
+ import pypy.module._cppyy.capi.loadable_capi as lcapi
if 'dummy' in lcapi.reflection_library:
# run only tests that are covered by the dummy backend and tests
# that do not rely on reflex
@@ -30,7 +30,7 @@
def pytest_configure(config):
if py.path.local.sysfind('genreflex') is None:
- import pypy.module.cppyy.capi.loadable_capi as lcapi
+ import pypy.module._cppyy.capi.loadable_capi as lcapi
try:
import ctypes
ctypes.CDLL(lcapi.reflection_library)
diff --git a/pypy/module/cppyy/test/crossing.cxx
b/pypy/module/_cppyy/test/crossing.cxx
rename from pypy/module/cppyy/test/crossing.cxx
rename to pypy/module/_cppyy/test/crossing.cxx
diff --git a/pypy/module/cppyy/test/crossing.h
b/pypy/module/_cppyy/test/crossing.h
rename from pypy/module/cppyy/test/crossing.h
rename to pypy/module/_cppyy/test/crossing.h
diff --git a/pypy/module/cppyy/test/crossing.xml
b/pypy/module/_cppyy/test/crossing.xml
rename from pypy/module/cppyy/test/crossing.xml
rename to pypy/module/_cppyy/test/crossing.xml
diff --git a/pypy/module/cppyy/test/crossing_LinkDef.h
b/pypy/module/_cppyy/test/crossing_LinkDef.h
rename from pypy/module/cppyy/test/crossing_LinkDef.h
rename to pypy/module/_cppyy/test/crossing_LinkDef.h
diff --git a/pypy/module/cppyy/test/datatypes.cxx
b/pypy/module/_cppyy/test/datatypes.cxx
rename from pypy/module/cppyy/test/datatypes.cxx
rename to pypy/module/_cppyy/test/datatypes.cxx
diff --git a/pypy/module/cppyy/test/datatypes.h
b/pypy/module/_cppyy/test/datatypes.h
rename from pypy/module/cppyy/test/datatypes.h
rename to pypy/module/_cppyy/test/datatypes.h
diff --git a/pypy/module/cppyy/test/datatypes.xml
b/pypy/module/_cppyy/test/datatypes.xml
rename from pypy/module/cppyy/test/datatypes.xml
rename to pypy/module/_cppyy/test/datatypes.xml
diff --git a/pypy/module/cppyy/test/datatypes_LinkDef.h
b/pypy/module/_cppyy/test/datatypes_LinkDef.h
rename from pypy/module/cppyy/test/datatypes_LinkDef.h
rename to pypy/module/_cppyy/test/datatypes_LinkDef.h
diff --git a/pypy/module/cppyy/test/example01.cxx
b/pypy/module/_cppyy/test/example01.cxx
rename from pypy/module/cppyy/test/example01.cxx
rename to pypy/module/_cppyy/test/example01.cxx
diff --git a/pypy/module/cppyy/test/example01.h
b/pypy/module/_cppyy/test/example01.h
rename from pypy/module/cppyy/test/example01.h
rename to pypy/module/_cppyy/test/example01.h
diff --git a/pypy/module/cppyy/test/example01.xml
b/pypy/module/_cppyy/test/example01.xml
rename from pypy/module/cppyy/test/example01.xml
rename to pypy/module/_cppyy/test/example01.xml
diff --git a/pypy/module/cppyy/test/example01_LinkDef.h
b/pypy/module/_cppyy/test/example01_LinkDef.h
rename from pypy/module/cppyy/test/example01_LinkDef.h
rename to pypy/module/_cppyy/test/example01_LinkDef.h
diff --git a/pypy/module/cppyy/test/fragile.cxx
b/pypy/module/_cppyy/test/fragile.cxx
rename from pypy/module/cppyy/test/fragile.cxx
rename to pypy/module/_cppyy/test/fragile.cxx
diff --git a/pypy/module/cppyy/test/fragile.h
b/pypy/module/_cppyy/test/fragile.h
rename from pypy/module/cppyy/test/fragile.h
rename to pypy/module/_cppyy/test/fragile.h
diff --git a/pypy/module/cppyy/test/fragile.xml
b/pypy/module/_cppyy/test/fragile.xml
rename from pypy/module/cppyy/test/fragile.xml
rename to pypy/module/_cppyy/test/fragile.xml
diff --git a/pypy/module/cppyy/test/fragile_LinkDef.h
b/pypy/module/_cppyy/test/fragile_LinkDef.h
rename from pypy/module/cppyy/test/fragile_LinkDef.h
rename to pypy/module/_cppyy/test/fragile_LinkDef.h
diff --git a/pypy/module/cppyy/test/iotypes.cxx
b/pypy/module/_cppyy/test/iotypes.cxx
rename from pypy/module/cppyy/test/iotypes.cxx
rename to pypy/module/_cppyy/test/iotypes.cxx
diff --git a/pypy/module/cppyy/test/iotypes.h
b/pypy/module/_cppyy/test/iotypes.h
rename from pypy/module/cppyy/test/iotypes.h
rename to pypy/module/_cppyy/test/iotypes.h
diff --git a/pypy/module/cppyy/test/iotypes.xml
b/pypy/module/_cppyy/test/iotypes.xml
rename from pypy/module/cppyy/test/iotypes.xml
rename to pypy/module/_cppyy/test/iotypes.xml
diff --git a/pypy/module/cppyy/test/iotypes_LinkDef.h
b/pypy/module/_cppyy/test/iotypes_LinkDef.h
rename from pypy/module/cppyy/test/iotypes_LinkDef.h
rename to pypy/module/_cppyy/test/iotypes_LinkDef.h
diff --git a/pypy/module/cppyy/test/operators.cxx
b/pypy/module/_cppyy/test/operators.cxx
rename from pypy/module/cppyy/test/operators.cxx
rename to pypy/module/_cppyy/test/operators.cxx
diff --git a/pypy/module/cppyy/test/operators.h
b/pypy/module/_cppyy/test/operators.h
rename from pypy/module/cppyy/test/operators.h
rename to pypy/module/_cppyy/test/operators.h
diff --git a/pypy/module/cppyy/test/operators.xml
b/pypy/module/_cppyy/test/operators.xml
rename from pypy/module/cppyy/test/operators.xml
rename to pypy/module/_cppyy/test/operators.xml
diff --git a/pypy/module/cppyy/test/operators_LinkDef.h
b/pypy/module/_cppyy/test/operators_LinkDef.h
rename from pypy/module/cppyy/test/operators_LinkDef.h
rename to pypy/module/_cppyy/test/operators_LinkDef.h
diff --git a/pypy/module/cppyy/test/overloads.cxx
b/pypy/module/_cppyy/test/overloads.cxx
rename from pypy/module/cppyy/test/overloads.cxx
rename to pypy/module/_cppyy/test/overloads.cxx
diff --git a/pypy/module/cppyy/test/overloads.h
b/pypy/module/_cppyy/test/overloads.h
rename from pypy/module/cppyy/test/overloads.h
rename to pypy/module/_cppyy/test/overloads.h
diff --git a/pypy/module/cppyy/test/overloads.xml
b/pypy/module/_cppyy/test/overloads.xml
rename from pypy/module/cppyy/test/overloads.xml
rename to pypy/module/_cppyy/test/overloads.xml
diff --git a/pypy/module/cppyy/test/overloads_LinkDef.h
b/pypy/module/_cppyy/test/overloads_LinkDef.h
rename from pypy/module/cppyy/test/overloads_LinkDef.h
rename to pypy/module/_cppyy/test/overloads_LinkDef.h
diff --git a/pypy/module/cppyy/test/simple_class.C
b/pypy/module/_cppyy/test/simple_class.C
rename from pypy/module/cppyy/test/simple_class.C
rename to pypy/module/_cppyy/test/simple_class.C
diff --git a/pypy/module/cppyy/test/std_streams.cxx
b/pypy/module/_cppyy/test/std_streams.cxx
rename from pypy/module/cppyy/test/std_streams.cxx
rename to pypy/module/_cppyy/test/std_streams.cxx
diff --git a/pypy/module/cppyy/test/std_streams.h
b/pypy/module/_cppyy/test/std_streams.h
rename from pypy/module/cppyy/test/std_streams.h
rename to pypy/module/_cppyy/test/std_streams.h
diff --git a/pypy/module/cppyy/test/std_streams.xml
b/pypy/module/_cppyy/test/std_streams.xml
rename from pypy/module/cppyy/test/std_streams.xml
rename to pypy/module/_cppyy/test/std_streams.xml
diff --git a/pypy/module/cppyy/test/std_streams_LinkDef.h
b/pypy/module/_cppyy/test/std_streams_LinkDef.h
rename from pypy/module/cppyy/test/std_streams_LinkDef.h
rename to pypy/module/_cppyy/test/std_streams_LinkDef.h
diff --git a/pypy/module/cppyy/test/stltypes.cxx
b/pypy/module/_cppyy/test/stltypes.cxx
rename from pypy/module/cppyy/test/stltypes.cxx
rename to pypy/module/_cppyy/test/stltypes.cxx
diff --git a/pypy/module/cppyy/test/stltypes.h
b/pypy/module/_cppyy/test/stltypes.h
rename from pypy/module/cppyy/test/stltypes.h
rename to pypy/module/_cppyy/test/stltypes.h
diff --git a/pypy/module/cppyy/test/stltypes.xml
b/pypy/module/_cppyy/test/stltypes.xml
rename from pypy/module/cppyy/test/stltypes.xml
rename to pypy/module/_cppyy/test/stltypes.xml
diff --git a/pypy/module/cppyy/test/stltypes_LinkDef.h
b/pypy/module/_cppyy/test/stltypes_LinkDef.h
rename from pypy/module/cppyy/test/stltypes_LinkDef.h
rename to pypy/module/_cppyy/test/stltypes_LinkDef.h
diff --git a/pypy/module/cppyy/test/support.py
b/pypy/module/_cppyy/test/support.py
rename from pypy/module/cppyy/test/support.py
rename to pypy/module/_cppyy/test/support.py
--- a/pypy/module/cppyy/test/support.py
+++ b/pypy/module/_cppyy/test/support.py
@@ -6,7 +6,7 @@
def setup_make(targetname):
if sys.platform == 'win32':
py.test.skip("win32 not supported so far")
- import pypy.module.cppyy.capi.loadable_capi as lcapi
+ import pypy.module._cppyy.capi.loadable_capi as lcapi
popen = subprocess.Popen(["make", targetname], cwd=str(currpath),
stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
stdout, _ = popen.communicate()
diff --git a/pypy/module/cppyy/test/test_aclassloader.py
b/pypy/module/_cppyy/test/test_aclassloader.py
rename from pypy/module/cppyy/test/test_aclassloader.py
rename to pypy/module/_cppyy/test/test_aclassloader.py
--- a/pypy/module/cppyy/test/test_aclassloader.py
+++ b/pypy/module/_cppyy/test/test_aclassloader.py
@@ -12,17 +12,17 @@
class AppTestACLASSLOADER:
- spaceconfig = dict(usemodules=['cppyy', '_rawffi', 'itertools'])
+ spaceconfig = dict(usemodules=['_cppyy', '_rawffi', 'itertools'])
def setup_class(cls):
cls.space.appexec([], """():
- import cppyy""")
+ import _cppyy""")
def test01_class_autoloading(self):
"""Test whether a class can be found through .rootmap."""
- import cppyy
- example01_class = cppyy.gbl.example01
+ import _cppyy
+ example01_class = _cppyy.gbl.example01
assert example01_class
- cl2 = cppyy.gbl.example01
+ cl2 = _cppyy.gbl.example01
assert cl2
assert example01_class is cl2
diff --git a/pypy/module/cppyy/test/test_advancedcpp.py
b/pypy/module/_cppyy/test/test_advancedcpp.py
rename from pypy/module/cppyy/test/test_advancedcpp.py
rename to pypy/module/_cppyy/test/test_advancedcpp.py
--- a/pypy/module/cppyy/test/test_advancedcpp.py
+++ b/pypy/module/_cppyy/test/test_advancedcpp.py
@@ -1,11 +1,9 @@
import py, os, sys
-from pypy.module.cppyy import capi
-
-
currpath = py.path.local(__file__).dirpath()
test_dct = str(currpath.join("advancedcppDict.so"))
+
def setup_module(mod):
if sys.platform == 'win32':
py.test.skip("win32 not supported so far")
@@ -15,21 +13,20 @@
raise OSError("'make' failed (see stderr)")
class AppTestADVANCEDCPP:
- spaceconfig = dict(usemodules=['cppyy', '_rawffi', 'itertools'])
+ spaceconfig = dict(usemodules=['_cppyy', '_rawffi', 'itertools'])
def setup_class(cls):
cls.w_test_dct = cls.space.newtext(test_dct)
- cls.w_capi_identity = cls.space.newtext(capi.identify())
cls.w_advanced = cls.space.appexec([], """():
- import cppyy
- return cppyy.load_reflection_info(%r)""" % (test_dct, ))
+ import _cppyy
+ return _cppyy.load_reflection_info(%r)""" % (test_dct, ))
def test01_default_arguments(self):
"""Test usage of default arguments"""
- import cppyy
+ import _cppyy
def test_defaulter(n, t):
- defaulter = getattr(cppyy.gbl, '%s_defaulter' % n)
+ defaulter = getattr(_cppyy.gbl, '%s_defaulter' % n)
d = defaulter()
assert d.m_a == t(11)
@@ -68,9 +65,9 @@
def test02_simple_inheritance(self):
"""Test binding of a basic inheritance structure"""
- import cppyy
- base_class = cppyy.gbl.base_class
- derived_class = cppyy.gbl.derived_class
+ import _cppyy
+ base_class = _cppyy.gbl.base_class
+ derived_class = _cppyy.gbl.derived_class
assert issubclass(derived_class, base_class)
assert not issubclass(base_class, derived_class)
@@ -122,8 +119,8 @@
def test03_namespaces(self):
"""Test access to namespaces and inner classes"""
- import cppyy
- gbl = cppyy.gbl
+ import _cppyy
+ gbl = _cppyy.gbl
assert gbl.a_ns is gbl.a_ns
assert gbl.a_ns.d_ns is gbl.a_ns.d_ns
@@ -149,10 +146,10 @@
def test03a_namespace_lookup_on_update(self):
"""Test whether namespaces can be shared across dictionaries."""
- import cppyy
- gbl = cppyy.gbl
+ import _cppyy
+ gbl = _cppyy.gbl
- lib2 = cppyy.load_reflection_info("advancedcpp2Dict.so")
+ lib2 = _cppyy.load_reflection_info("advancedcpp2Dict.so")
assert gbl.a_ns is gbl.a_ns
assert gbl.a_ns.d_ns is gbl.a_ns.d_ns
@@ -178,8 +175,8 @@
def test04_template_types(self):
"""Test bindings of templated types"""
- import cppyy
- gbl = cppyy.gbl
+ import _cppyy
+ gbl = _cppyy.gbl
assert gbl.T1 is gbl.T1
assert gbl.T2 is gbl.T2
@@ -244,8 +241,8 @@
def test05_abstract_classes(self):
"""Test non-instatiatability of abstract classes"""
- import cppyy
- gbl = cppyy.gbl
+ import _cppyy
+ gbl = _cppyy.gbl
raises(TypeError, gbl.a_class)
raises(TypeError, gbl.some_abstract_class)
@@ -259,12 +256,12 @@
def test06_datamembers(self):
"""Test data member access when using virtual inheritence"""
- import cppyy
- a_class = cppyy.gbl.a_class
- b_class = cppyy.gbl.b_class
- c_class_1 = cppyy.gbl.c_class_1
- c_class_2 = cppyy.gbl.c_class_2
- d_class = cppyy.gbl.d_class
+ import _cppyy
+ a_class = _cppyy.gbl.a_class
+ b_class = _cppyy.gbl.b_class
+ c_class_1 = _cppyy.gbl.c_class_1
+ c_class_2 = _cppyy.gbl.c_class_2
+ d_class = _cppyy.gbl.d_class
assert issubclass(b_class, a_class)
assert issubclass(c_class_1, a_class)
@@ -353,8 +350,8 @@
def test07_pass_by_reference(self):
"""Test reference passing when using virtual inheritance"""
- import cppyy
- gbl = cppyy.gbl
+ import _cppyy
+ gbl = _cppyy.gbl
b_class = gbl.b_class
c_class = gbl.c_class_2
d_class = gbl.d_class
@@ -386,71 +383,71 @@
def test08_void_pointer_passing(self):
"""Test passing of variants of void pointer arguments"""
- import cppyy
- pointer_pass = cppyy.gbl.pointer_pass
- some_concrete_class = cppyy.gbl.some_concrete_class
+ import _cppyy
+ pointer_pass = _cppyy.gbl.pointer_pass
+ some_concrete_class = _cppyy.gbl.some_concrete_class
pp = pointer_pass()
o = some_concrete_class()
- assert cppyy.addressof(o) == pp.gime_address_ptr(o)
- assert cppyy.addressof(o) == pp.gime_address_ptr_ptr(o)
- assert cppyy.addressof(o) == pp.gime_address_ptr_ref(o)
+ assert _cppyy.addressof(o) == pp.gime_address_ptr(o)
+ assert _cppyy.addressof(o) == pp.gime_address_ptr_ptr(o)
+ assert _cppyy.addressof(o) == pp.gime_address_ptr_ref(o)
import array
- addressofo = array.array('l', [cppyy.addressof(o)])
+ addressofo = array.array('l', [_cppyy.addressof(o)])
assert addressofo.buffer_info()[0] ==
pp.gime_address_ptr_ptr(addressofo)
assert 0 == pp.gime_address_ptr(0)
assert 0 == pp.gime_address_ptr(None)
- ptr = cppyy.bind_object(0, some_concrete_class)
- assert cppyy.addressof(ptr) == 0
+ ptr = _cppyy.bind_object(0, some_concrete_class)
+ assert _cppyy.addressof(ptr) == 0
pp.set_address_ptr_ref(ptr)
- assert cppyy.addressof(ptr) == 0x1234
+ assert _cppyy.addressof(ptr) == 0x1234
pp.set_address_ptr_ptr(ptr)
- assert cppyy.addressof(ptr) == 0x4321
+ assert _cppyy.addressof(ptr) == 0x4321
def test09_opaque_pointer_passing(self):
"""Test passing around of opaque pointers"""
- import cppyy
- some_concrete_class = cppyy.gbl.some_concrete_class
+ import _cppyy
+ some_concrete_class = _cppyy.gbl.some_concrete_class
o = some_concrete_class()
# TODO: figure out the PyPy equivalent of CObject (may have to do this
# through the C-API from C++)
_______________________________________________
pypy-commit mailing list
[email protected]
https://mail.python.org/mailman/listinfo/pypy-commit
