consistent macro naming throughout the project

.travis.yml

@@ -16,7 +16,7 @@ matrix:
       compiler: gcc-4.8
       compiler: gcc-4.8
       script:
       script:
         - pyvenv-3.5 venv
         - pyvenv-3.5 venv
-        - cmake -DPYBIND_PYTHON_VERSION=3.5 -DPYTHON_INCLUDE_DIR:PATH=/usr/include/python3.5m -DPYTHON_LIBRARY:FILEPATH=/usr/lib/x86_64-linux-gnu/libpython3.5m.so -DPYTHON_EXECUTABLE:FILEPATH=`pwd`/venv/bin/python3.5 -DCMAKE_CXX_COMPILER=g++-4.8
+        - cmake -DPYBIND11_PYTHON_VERSION=3.5 -DPYTHON_INCLUDE_DIR:PATH=/usr/include/python3.5m -DPYTHON_LIBRARY:FILEPATH=/usr/lib/x86_64-linux-gnu/libpython3.5m.so -DPYTHON_EXECUTABLE:FILEPATH=`pwd`/venv/bin/python3.5 -DCMAKE_CXX_COMPILER=g++-4.8
         - make -j 2
         - make -j 2
         - source venv/bin/activate
         - source venv/bin/activate
         - pip install numpy
         - pip install numpy
@@ -24,6 +24,6 @@ matrix:
     - os: osx
     - os: osx
       compiler: clang
       compiler: clang
       script:
       script:
-        - cmake -DPYBIND_PYTHON_VERSION=2.7
+        - cmake -DPYBIND11_PYTHON_VERSION=2.7
         - make -j 2
         - make -j 2
         - CTEST_OUTPUT_ON_FAILURE=TRUE make test
         - CTEST_OUTPUT_ON_FAILURE=TRUE make test

CMakeLists.txt

@@ -10,7 +10,7 @@ cmake_minimum_required(VERSION 2.8)
 project(pybind11)
 project(pybind11)
 
 
 # Add a CMake parameter for choosing a desired Python version
 # Add a CMake parameter for choosing a desired Python version
-set(PYBIND_PYTHON_VERSION "" CACHE STRING "Python version to use for compiling the example application")
+set(PYBIND11_PYTHON_VERSION "" CACHE STRING "Python version to use for compiling the example application")
 
 
 # Set a default build configuration if none is specified. 'MinSizeRel' produces the smallest binaries
 # Set a default build configuration if none is specified. 'MinSizeRel' produces the smallest binaries
 if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
 if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
@@ -22,8 +22,8 @@ endif()
 string(TOUPPER "${CMAKE_BUILD_TYPE}" U_CMAKE_BUILD_TYPE)
 string(TOUPPER "${CMAKE_BUILD_TYPE}" U_CMAKE_BUILD_TYPE)
 
 
 set(Python_ADDITIONAL_VERSIONS 3.4 3.5 3.6)
 set(Python_ADDITIONAL_VERSIONS 3.4 3.5 3.6)
-find_package(PythonLibs ${PYBIND_PYTHON_VERSION} REQUIRED)
-find_package(PythonInterp ${PYBIND_PYTHON_VERSION} REQUIRED)
+find_package(PythonLibs ${PYBIND11_PYTHON_VERSION} REQUIRED)
+find_package(PythonInterp ${PYBIND11_PYTHON_VERSION} REQUIRED)
 
 
 if (UNIX)
 if (UNIX)
   # Enable C++11 mode
   # Enable C++11 mode

docs/advanced.rst

@@ -45,7 +45,7 @@ to Python.
 
 
     #include <pybind11/operators.h>
     #include <pybind11/operators.h>
 
 
-    PYBIND_PLUGIN(example) {
+    PYBIND11_PLUGIN(example) {
         py::module m("example", "pybind11 example plugin");
         py::module m("example", "pybind11 example plugin");
 
 
         py::class_<Vector2>(m, "Vector2")
         py::class_<Vector2>(m, "Vector2")
@@ -127,7 +127,7 @@ trivial to generate binding code for both of these functions.
 
 
     #include <pybind11/functional.h>
     #include <pybind11/functional.h>
 
 
-    PYBIND_PLUGIN(example) {
+    PYBIND11_PLUGIN(example) {
         py::module m("example", "pybind11 example plugin");
         py::module m("example", "pybind11 example plugin");
 
 
         m.def("func_arg", &func_arg);
         m.def("func_arg", &func_arg);
@@ -199,7 +199,7 @@ Normally, the binding code for these classes would look as follows:
 
 
 .. code-block:: cpp
 .. code-block:: cpp
 
 
-    PYBIND_PLUGIN(example) {
+    PYBIND11_PLUGIN(example) {
         py::module m("example", "pybind11 example plugin");
         py::module m("example", "pybind11 example plugin");
 
 
         py::class_<Animal> animal(m, "Animal");
         py::class_<Animal> animal(m, "Animal");
@@ -230,7 +230,7 @@ helper class that is defined as follows:
 
 
         /* Trampoline (need one for each virtual function) */
         /* Trampoline (need one for each virtual function) */
         std::string go(int n_times) {
         std::string go(int n_times) {
-            PYBIND_OVERLOAD_PURE(
+            PYBIND11_OVERLOAD_PURE(
                 std::string, /* Return type */
                 std::string, /* Return type */
                 Animal,      /* Parent class */
                 Animal,      /* Parent class */
                 go,          /* Name of function */
                 go,          /* Name of function */
@@ -239,15 +239,15 @@ helper class that is defined as follows:
         }
         }
     };
     };
 
 
-The macro :func:`PYBIND_OVERLOAD_PURE` should be used for pure virtual
-functions, and :func:`PYBIND_OVERLOAD` should be used for functions which have
+The macro :func:`PYBIND11_OVERLOAD_PURE` should be used for pure virtual
+functions, and :func:`PYBIND11_OVERLOAD` should be used for functions which have
 a default implementation. The binding code also needs a few minor adaptations
 a default implementation. The binding code also needs a few minor adaptations
 (highlighted):
 (highlighted):
 
 
 .. code-block:: cpp
 .. code-block:: cpp
     :emphasize-lines: 4,6,7
     :emphasize-lines: 4,6,7
 
 
-    PYBIND_PLUGIN(example) {
+    PYBIND11_PLUGIN(example) {
         py::module m("example", "pybind11 example plugin");
         py::module m("example", "pybind11 example plugin");
 
 
         py::class_<PyAnimal> animal(m, "Animal");
         py::class_<PyAnimal> animal(m, "Animal");
@@ -375,7 +375,7 @@ See below for an example that uses the
         Internal internal;
         Internal internal;
     };
     };
 
 
-    PYBIND_PLUGIN(example) {
+    PYBIND11_PLUGIN(example) {
         py::module m("example", "pybind11 example plugin");
         py::module m("example", "pybind11 example plugin");
 
 
         py::class_<Example>(m, "Example")
         py::class_<Example>(m, "Example")
@@ -441,7 +441,7 @@ be declared at the top level before any binding code:
 
 
 .. code-block:: cpp
 .. code-block:: cpp
 
 
-    PYBIND_DECLARE_HOLDER_TYPE(T, std::shared_ptr<T>);
+    PYBIND11_DECLARE_HOLDER_TYPE(T, std::shared_ptr<T>);
 
 
 .. seealso::
 .. seealso::
 
 

docs/basics.rst

@@ -87,7 +87,7 @@ a file named :file:`example.cpp` with the following contents:
 
 
     namespace py = pybind11;
     namespace py = pybind11;
 
 
-    PYBIND_PLUGIN(example) {
+    PYBIND11_PLUGIN(example) {
         py::module m("example", "pybind11 example plugin");
         py::module m("example", "pybind11 example plugin");
 
 
         m.def("add", &add, "A function which adds two numbers");
         m.def("add", &add, "A function which adds two numbers");
@@ -95,7 +95,7 @@ a file named :file:`example.cpp` with the following contents:
         return m.ptr();
         return m.ptr();
     }
     }
 
 
-The :func:`PYBIND_PLUGIN` macro creates a function that will be called when an
+The :func:`PYBIND11_PLUGIN` macro creates a function that will be called when an
 ``import`` statement is issued from within Python. The next line creates a
 ``import`` statement is issued from within Python. The next line creates a
 module named ``example`` (with the supplied docstring). The method
 module named ``example`` (with the supplied docstring). The method
 :func:`module::def` generates binding code that exposes the
 :func:`module::def` generates binding code that exposes the

docs/classes.rst

@@ -27,7 +27,7 @@ The binding code for ``Pet`` looks as follows:
 
 
     namespace py = pybind11;
     namespace py = pybind11;
 
 
-    PYBIND_PLUGIN(example) {
+    PYBIND11_PLUGIN(example) {
         py::module m("example", "pybind11 example plugin");
         py::module m("example", "pybind11 example plugin");
 
 
         py::class_<Pet>(m, "Pet")
         py::class_<Pet>(m, "Pet")

docs/reference.rst

@@ -12,7 +12,7 @@ Reference
 Macros
 Macros
 ======
 ======
 
 
-.. function:: PYBIND_PLUGIN(const char *name)
+.. function:: PYBIND11_PLUGIN(const char *name)
 
 
     This macro creates the entry point that will be invoked when the Python
     This macro creates the entry point that will be invoked when the Python
     interpreter imports a plugin library. Please create a
     interpreter imports a plugin library. Please create a
@@ -21,7 +21,7 @@ Macros
 
 
     .. code-block:: cpp
     .. code-block:: cpp
 
 
-        PYBIND_PLUGIN(example) {
+        PYBIND11_PLUGIN(example) {
             pybind11::module m("example", "pybind11 example plugin");
             pybind11::module m("example", "pybind11 example plugin");
             /// Set up bindings here
             /// Set up bindings here
             return m.ptr();
             return m.ptr();

example/example.cpp

@@ -22,7 +22,7 @@ void init_ex10(py::module &);
 void init_ex11(py::module &);
 void init_ex11(py::module &);
 void init_ex12(py::module &);
 void init_ex12(py::module &);
 
 
-PYBIND_PLUGIN(example) {
+PYBIND11_PLUGIN(example) {
     py::module m("example", "pybind example plugin");
     py::module m("example", "pybind example plugin");
 
 
     init_ex1(m);
     init_ex1(m);

example/example12.cpp

@@ -39,7 +39,7 @@ public:
 
 
     virtual int run(int value) {
     virtual int run(int value) {
         /* Generate wrapping code that enables native function overloading */
         /* Generate wrapping code that enables native function overloading */
-        PYBIND_OVERLOAD(
+        PYBIND11_OVERLOAD(
             int,        /* Return type */
             int,        /* Return type */
             Example12,  /* Parent class */
             Example12,  /* Parent class */
             run,        /* Name of function */
             run,        /* Name of function */
@@ -48,7 +48,7 @@ public:
     }
     }
 
 
     virtual void pure_virtual() {
     virtual void pure_virtual() {
-        PYBIND_OVERLOAD_PURE(
+        PYBIND11_OVERLOAD_PURE(
             void,         /* Return type */
             void,         /* Return type */
             Example12,    /* Parent class */
             Example12,    /* Parent class */
             pure_virtual  /* Name of function */
             pure_virtual  /* Name of function */

example/example8.cpp

@@ -32,7 +32,7 @@ private:
 };
 };
 
 
 /// Make pybind aware of the ref-counted wrapper type
 /// Make pybind aware of the ref-counted wrapper type
-PYBIND_DECLARE_HOLDER_TYPE(T, ref<T>);
+PYBIND11_DECLARE_HOLDER_TYPE(T, ref<T>);
 
 
 Object *make_object_1() { return new MyObject(1); }
 Object *make_object_1() { return new MyObject(1); }
 ref<Object> make_object_2() { return new MyObject(2); }
 ref<Object> make_object_2() { return new MyObject(2); }

include/pybind11/cast.h

@@ -25,9 +25,9 @@ NAMESPACE_BEGIN(detail)
 #endif
 #endif
 
 
 #if PY_MAJOR_VERSION >= 3
 #if PY_MAJOR_VERSION >= 3
-#define PYBIND_AS_STRING PyBytes_AsString
+#define PYBIND11_AS_STRING PyBytes_AsString
 #else
 #else
-#define PYBIND_AS_STRING PyString_AsString
+#define PYBIND11_AS_STRING PyString_AsString
 #endif
 #endif
 
 
 /** Linked list descriptor type for function signatures (produces smaller binaries
 /** Linked list descriptor type for function signatures (produces smaller binaries
@@ -214,7 +214,7 @@ protected:
     object temp;
     object temp;
 };
 };
 
 
-#define PYBIND_TYPE_CASTER(type, py_name) \
+#define PYBIND11_TYPE_CASTER(type, py_name) \
     protected: \
     protected: \
         type value; \
         type value; \
     public: \
     public: \
@@ -225,7 +225,7 @@ protected:
         operator type*() { return &value; } \
         operator type*() { return &value; } \
         operator type&() { return value; } \
         operator type&() { return value; } \
 
 
-#define PYBIND_TYPE_CASTER_NUMBER(type, py_type, from_type, to_pytype) \
+#define PYBIND11_TYPE_CASTER_NUMBER(type, py_type, from_type, to_pytype) \
     template <> class type_caster<type> { \
     template <> class type_caster<type> { \
     public: \
     public: \
         bool load(PyObject *src, bool) { \
         bool load(PyObject *src, bool) { \
@@ -244,7 +244,7 @@ protected:
         static PyObject *cast(type src, return_value_policy /* policy */, PyObject * /* parent */) { \
         static PyObject *cast(type src, return_value_policy /* policy */, PyObject * /* parent */) { \
             return to_pytype((py_type) src); \
             return to_pytype((py_type) src); \
         } \
         } \
-        PYBIND_TYPE_CASTER(type, #type); \
+        PYBIND11_TYPE_CASTER(type, #type); \
     };
     };
 
 
 #if PY_MAJOR_VERSION >= 3
 #if PY_MAJOR_VERSION >= 3
@@ -266,27 +266,27 @@ inline unsigned PY_LONG_LONG PyLong_AsUnsignedLongLong_Fixed(PyObject *o) {
 }
 }
 #endif
 #endif
 
 
-PYBIND_TYPE_CASTER_NUMBER(int8_t, long, PyLong_AsLong, PyLong_FromLong)
-PYBIND_TYPE_CASTER_NUMBER(uint8_t, unsigned long, PyLong_AsUnsignedLong, PyLong_FromUnsignedLong)
-PYBIND_TYPE_CASTER_NUMBER(int16_t, long, PyLong_AsLong, PyLong_FromLong)
-PYBIND_TYPE_CASTER_NUMBER(uint16_t, unsigned long, PyLong_AsUnsignedLong, PyLong_FromUnsignedLong)
-PYBIND_TYPE_CASTER_NUMBER(int32_t, long, PyLong_AsLong, PyLong_FromLong)
-PYBIND_TYPE_CASTER_NUMBER(uint32_t, unsigned long, PyLong_AsUnsignedLong, PyLong_FromUnsignedLong)
-PYBIND_TYPE_CASTER_NUMBER(int64_t, PY_LONG_LONG, PyLong_AsLongLong_Fixed, PyLong_FromLongLong)
-PYBIND_TYPE_CASTER_NUMBER(uint64_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong_Fixed, PyLong_FromUnsignedLongLong)
+PYBIND11_TYPE_CASTER_NUMBER(int8_t, long, PyLong_AsLong, PyLong_FromLong)
+PYBIND11_TYPE_CASTER_NUMBER(uint8_t, unsigned long, PyLong_AsUnsignedLong, PyLong_FromUnsignedLong)
+PYBIND11_TYPE_CASTER_NUMBER(int16_t, long, PyLong_AsLong, PyLong_FromLong)
+PYBIND11_TYPE_CASTER_NUMBER(uint16_t, unsigned long, PyLong_AsUnsignedLong, PyLong_FromUnsignedLong)
+PYBIND11_TYPE_CASTER_NUMBER(int32_t, long, PyLong_AsLong, PyLong_FromLong)
+PYBIND11_TYPE_CASTER_NUMBER(uint32_t, unsigned long, PyLong_AsUnsignedLong, PyLong_FromUnsignedLong)
+PYBIND11_TYPE_CASTER_NUMBER(int64_t, PY_LONG_LONG, PyLong_AsLongLong_Fixed, PyLong_FromLongLong)
+PYBIND11_TYPE_CASTER_NUMBER(uint64_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong_Fixed, PyLong_FromUnsignedLongLong)
 
 
 #if defined(__APPLE__) // size_t/ssize_t are separate types on Mac OS X
 #if defined(__APPLE__) // size_t/ssize_t are separate types on Mac OS X
 #if PY_MAJOR_VERSION >= 3
 #if PY_MAJOR_VERSION >= 3
-PYBIND_TYPE_CASTER_NUMBER(ssize_t, Py_ssize_t, PyLong_AsSsize_t, PyLong_FromSsize_t)
-PYBIND_TYPE_CASTER_NUMBER(size_t, size_t, PyLong_AsSize_t, PyLong_FromSize_t)
+PYBIND11_TYPE_CASTER_NUMBER(ssize_t, Py_ssize_t, PyLong_AsSsize_t, PyLong_FromSsize_t)
+PYBIND11_TYPE_CASTER_NUMBER(size_t, size_t, PyLong_AsSize_t, PyLong_FromSize_t)
 #else
 #else
-PYBIND_TYPE_CASTER_NUMBER(ssize_t, PY_LONG_LONG, PyLong_AsLongLong_Fixed, PyLong_FromLongLong)
-PYBIND_TYPE_CASTER_NUMBER(size_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong_Fixed, PyLong_FromUnsignedLongLong)
+PYBIND11_TYPE_CASTER_NUMBER(ssize_t, PY_LONG_LONG, PyLong_AsLongLong_Fixed, PyLong_FromLongLong)
+PYBIND11_TYPE_CASTER_NUMBER(size_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong_Fixed, PyLong_FromUnsignedLongLong)
 #endif
 #endif
 #endif
 #endif
 
 
-PYBIND_TYPE_CASTER_NUMBER(float, double, PyFloat_AsDouble, PyFloat_FromDouble)
-PYBIND_TYPE_CASTER_NUMBER(double, double, PyFloat_AsDouble, PyFloat_FromDouble)
+PYBIND11_TYPE_CASTER_NUMBER(float, double, PyFloat_AsDouble, PyFloat_FromDouble)
+PYBIND11_TYPE_CASTER_NUMBER(double, double, PyFloat_AsDouble, PyFloat_FromDouble)
 
 
 template <> class type_caster<void_type> {
 template <> class type_caster<void_type> {
 public:
 public:
@@ -295,7 +295,7 @@ public:
         Py_INCREF(Py_None);
         Py_INCREF(Py_None);
         return Py_None;
         return Py_None;
     }
     }
-    PYBIND_TYPE_CASTER(void_type, "None");
+    PYBIND11_TYPE_CASTER(void_type, "None");
 };
 };
 
 
 template <> class type_caster<void> : public type_caster<void_type> {
 template <> class type_caster<void> : public type_caster<void_type> {
@@ -313,7 +313,7 @@ public:
         Py_INCREF(result);
         Py_INCREF(result);
         return result;
         return result;
     }
     }
-    PYBIND_TYPE_CASTER(bool, "bool");
+    PYBIND11_TYPE_CASTER(bool, "bool");
 };
 };
 
 
 template <> class type_caster<std::string> {
 template <> class type_caster<std::string> {
@@ -325,7 +325,7 @@ public:
         object temp(PyUnicode_AsUTF8String(src), false);
         object temp(PyUnicode_AsUTF8String(src), false);
         const char *ptr = nullptr;
         const char *ptr = nullptr;
         if (temp)
         if (temp)
-            ptr = PYBIND_AS_STRING(temp.ptr());
+            ptr = PYBIND11_AS_STRING(temp.ptr());
         if (!ptr) { PyErr_Clear(); return false; }
         if (!ptr) { PyErr_Clear(); return false; }
         value = ptr;
         value = ptr;
         return true;
         return true;
@@ -333,7 +333,7 @@ public:
     static PyObject *cast(const std::string &src, return_value_policy /* policy */, PyObject * /* parent */) {
     static PyObject *cast(const std::string &src, return_value_policy /* policy */, PyObject * /* parent */) {
         return PyUnicode_FromString(src.c_str());
         return PyUnicode_FromString(src.c_str());
     }
     }
-    PYBIND_TYPE_CASTER(std::string, "str");
+    PYBIND11_TYPE_CASTER(std::string, "str");
 };
 };
 
 
 template <> class type_caster<char> {
 template <> class type_caster<char> {
@@ -345,7 +345,7 @@ public:
         object temp(PyUnicode_AsUTF8String(src), false);
         object temp(PyUnicode_AsUTF8String(src), false);
         const char *ptr = nullptr;
         const char *ptr = nullptr;
         if (temp)
         if (temp)
-            ptr = PYBIND_AS_STRING(temp.ptr());
+            ptr = PYBIND11_AS_STRING(temp.ptr());
         if (!ptr) { PyErr_Clear(); return false; }
         if (!ptr) { PyErr_Clear(); return false; }
         value = ptr;
         value = ptr;
         return true;
         return true;
@@ -527,7 +527,7 @@ protected:
     holder_type holder;
     holder_type holder;
 };
 };
 
 
-#define PYBIND_DECLARE_HOLDER_TYPE(type, holder_type) \
+#define PYBIND11_DECLARE_HOLDER_TYPE(type, holder_type) \
     namespace pybind11 { namespace detail { \
     namespace pybind11 { namespace detail { \
     template <typename type> class type_caster<holder_type> \
     template <typename type> class type_caster<holder_type> \
         : public type_caster_holder<type, holder_type> { }; \
         : public type_caster_holder<type, holder_type> { }; \
@@ -543,24 +543,24 @@ public:
         src.inc_ref();
         src.inc_ref();
         return (PyObject *) src.ptr();
         return (PyObject *) src.ptr();
     }
     }
-    PYBIND_TYPE_CASTER(handle, "handle");
+    PYBIND11_TYPE_CASTER(handle, "handle");
 };
 };
 
 
-#define PYBIND_TYPE_CASTER_PYTYPE(name) \
+#define PYBIND11_TYPE_CASTER_PYTYPE(name) \
     template <> class type_caster<name> { \
     template <> class type_caster<name> { \
     public: \
     public: \
         bool load(PyObject *src, bool) { value = name(src, true); return true; } \
         bool load(PyObject *src, bool) { value = name(src, true); return true; } \
         static PyObject *cast(const name &src, return_value_policy /* policy */, PyObject * /* parent */) { \
         static PyObject *cast(const name &src, return_value_policy /* policy */, PyObject * /* parent */) { \
             src.inc_ref(); return (PyObject *) src.ptr(); \
             src.inc_ref(); return (PyObject *) src.ptr(); \
         } \
         } \
-        PYBIND_TYPE_CASTER(name, #name); \
+        PYBIND11_TYPE_CASTER(name, #name); \
     };
     };
 
 
-PYBIND_TYPE_CASTER_PYTYPE(object)  PYBIND_TYPE_CASTER_PYTYPE(buffer)
-PYBIND_TYPE_CASTER_PYTYPE(capsule) PYBIND_TYPE_CASTER_PYTYPE(dict)
-PYBIND_TYPE_CASTER_PYTYPE(float_)  PYBIND_TYPE_CASTER_PYTYPE(int_)
-PYBIND_TYPE_CASTER_PYTYPE(list)    PYBIND_TYPE_CASTER_PYTYPE(slice)
-PYBIND_TYPE_CASTER_PYTYPE(tuple)   PYBIND_TYPE_CASTER_PYTYPE(function)
+PYBIND11_TYPE_CASTER_PYTYPE(object)  PYBIND11_TYPE_CASTER_PYTYPE(buffer)
+PYBIND11_TYPE_CASTER_PYTYPE(capsule) PYBIND11_TYPE_CASTER_PYTYPE(dict)
+PYBIND11_TYPE_CASTER_PYTYPE(float_)  PYBIND11_TYPE_CASTER_PYTYPE(int_)
+PYBIND11_TYPE_CASTER_PYTYPE(list)    PYBIND11_TYPE_CASTER_PYTYPE(slice)
+PYBIND11_TYPE_CASTER_PYTYPE(tuple)   PYBIND11_TYPE_CASTER_PYTYPE(function)
 
 
 NAMESPACE_END(detail)
 NAMESPACE_END(detail)
 
 

include/pybind11/common.h

@@ -16,11 +16,11 @@
 #define NAMESPACE_END(name) }
 #define NAMESPACE_END(name) }
 #endif
 #endif
 
 
-#if !defined(PYBIND_EXPORT)
+#if !defined(PYBIND11_EXPORT)
 #if defined(WIN32) || defined(_WIN32)
 #if defined(WIN32) || defined(_WIN32)
-#define PYBIND_EXPORT __declspec(dllexport)
+#define PYBIND11_EXPORT __declspec(dllexport)
 #else
 #else
-#define PYBIND_EXPORT __attribute__ ((visibility("default")))
+#define PYBIND11_EXPORT __attribute__ ((visibility("default")))
 #endif
 #endif
 #endif
 #endif
 
 
@@ -61,11 +61,11 @@
 #endif
 #endif
 
 
 #if PY_MAJOR_VERSION >= 3
 #if PY_MAJOR_VERSION >= 3
-#define PYBIND_PLUGIN(name) \
-    extern "C" PYBIND_EXPORT PyObject *PyInit_##name()
+#define PYBIND11_PLUGIN(name) \
+    extern "C" PYBIND11_EXPORT PyObject *PyInit_##name()
 #else
 #else
-#define PYBIND_PLUGIN(name) \
-    extern "C" PYBIND_EXPORT PyObject *init##name()
+#define PYBIND11_PLUGIN(name) \
+    extern "C" PYBIND11_EXPORT PyObject *init##name()
 #endif
 #endif
 
 
 NAMESPACE_BEGIN(pybind11)
 NAMESPACE_BEGIN(pybind11)
@@ -93,10 +93,10 @@ enum class return_value_policy : int {
 
 
 /// Format strings for basic number types
 /// Format strings for basic number types
 template <typename type> struct format_descriptor { };
 template <typename type> struct format_descriptor { };
-#define PYBIND_DECL_FMT(t, n) template<> struct format_descriptor<t> { static std::string value() { return n; }; };
-PYBIND_DECL_FMT(int8_t,  "b"); PYBIND_DECL_FMT(uint8_t,  "B"); PYBIND_DECL_FMT(int16_t, "h"); PYBIND_DECL_FMT(uint16_t, "H");
-PYBIND_DECL_FMT(int32_t, "i"); PYBIND_DECL_FMT(uint32_t, "I"); PYBIND_DECL_FMT(int64_t, "q"); PYBIND_DECL_FMT(uint64_t, "Q");
-PYBIND_DECL_FMT(float,   "f"); PYBIND_DECL_FMT(double,   "d"); PYBIND_DECL_FMT(bool,    "?");
+#define PYBIND11_DECL_FMT(t, n) template<> struct format_descriptor<t> { static std::string value() { return n; }; };
+PYBIND11_DECL_FMT(int8_t,  "b"); PYBIND11_DECL_FMT(uint8_t,  "B"); PYBIND11_DECL_FMT(int16_t, "h"); PYBIND11_DECL_FMT(uint16_t, "H");
+PYBIND11_DECL_FMT(int32_t, "i"); PYBIND11_DECL_FMT(uint32_t, "I"); PYBIND11_DECL_FMT(int64_t, "q"); PYBIND11_DECL_FMT(uint64_t, "Q");
+PYBIND11_DECL_FMT(float,   "f"); PYBIND11_DECL_FMT(double,   "d"); PYBIND11_DECL_FMT(bool,    "?");
 
 
 /// Information record describing a Python buffer object
 /// Information record describing a Python buffer object
 struct buffer_info {
 struct buffer_info {

include/pybind11/complex.h

@@ -14,8 +14,8 @@
 
 
 NAMESPACE_BEGIN(pybind11)
 NAMESPACE_BEGIN(pybind11)
 
 
-PYBIND_DECL_FMT(std::complex<float>, "Zf");
-PYBIND_DECL_FMT(std::complex<double>, "Zd");
+PYBIND11_DECL_FMT(std::complex<float>, "Zf");
+PYBIND11_DECL_FMT(std::complex<double>, "Zd");
 
 
 NAMESPACE_BEGIN(detail)
 NAMESPACE_BEGIN(detail)
 template <typename T> class type_caster<std::complex<T>> {
 template <typename T> class type_caster<std::complex<T>> {
@@ -34,7 +34,7 @@ public:
         return PyComplex_FromDoubles((double) src.real(), (double) src.imag());
         return PyComplex_FromDoubles((double) src.real(), (double) src.imag());
     }
     }
 
 
-    PYBIND_TYPE_CASTER(std::complex<T>, "complex");
+    PYBIND11_TYPE_CASTER(std::complex<T>, "complex");
 };
 };
 NAMESPACE_END(detail)
 NAMESPACE_END(detail)
 NAMESPACE_END(pybind11)
 NAMESPACE_END(pybind11)

include/pybind11/functional.h

@@ -39,7 +39,7 @@ public:
     }
     }
 
 
 
 
-    PYBIND_TYPE_CASTER(type, detail::descr("function<") +
+    PYBIND11_TYPE_CASTER(type, detail::descr("function<") +
             type_caster<std::tuple<Args...>>::name() + detail::descr(" -> ") +
             type_caster<std::tuple<Args...>>::name() + detail::descr(" -> ") +
             type_caster<typename decay<Return>::type>::name() +
             type_caster<typename decay<Return>::type>::name() +
             detail::descr(">"));
             detail::descr(">"));

include/pybind11/numpy.h

@@ -76,7 +76,7 @@ public:
         PyObject *(*PyArray_FromAny) (PyObject *, PyObject *, int, int, int, PyObject *);
         PyObject *(*PyArray_FromAny) (PyObject *, PyObject *, int, int, int, PyObject *);
     };
     };
 
 
-    PYBIND_OBJECT_DEFAULT(array, buffer, lookup_api().PyArray_Check)
+    PYBIND11_OBJECT_DEFAULT(array, buffer, lookup_api().PyArray_Check)
 
 
     template <typename Type> array(size_t size, const Type *ptr) {
     template <typename Type> array(size_t size, const Type *ptr) {
         API& api = lookup_api();
         API& api = lookup_api();
@@ -126,7 +126,7 @@ protected:
 
 
 template <typename T> class array_t : public array {
 template <typename T> class array_t : public array {
 public:
 public:
-    PYBIND_OBJECT_CVT(array_t, array, is_non_null, m_ptr = ensure(m_ptr));
+    PYBIND11_OBJECT_CVT(array_t, array, is_non_null, m_ptr = ensure(m_ptr));
     array_t() : array() { }
     array_t() : array() { }
     static bool is_non_null(PyObject *ptr) { return ptr != nullptr; }
     static bool is_non_null(PyObject *ptr) { return ptr != nullptr; }
     PyObject *ensure(PyObject *ptr) {
     PyObject *ensure(PyObject *ptr) {
@@ -150,15 +150,15 @@ DECL_FMT(std::complex<double>, NPY_CDOUBLE);
 
 
 
 
 NAMESPACE_BEGIN(detail)
 NAMESPACE_BEGIN(detail)
-PYBIND_TYPE_CASTER_PYTYPE(array)
-PYBIND_TYPE_CASTER_PYTYPE(array_t<int8_t>)  PYBIND_TYPE_CASTER_PYTYPE(array_t<uint8_t>)
-PYBIND_TYPE_CASTER_PYTYPE(array_t<int16_t>) PYBIND_TYPE_CASTER_PYTYPE(array_t<uint16_t>)
-PYBIND_TYPE_CASTER_PYTYPE(array_t<int32_t>) PYBIND_TYPE_CASTER_PYTYPE(array_t<uint32_t>)
-PYBIND_TYPE_CASTER_PYTYPE(array_t<int64_t>) PYBIND_TYPE_CASTER_PYTYPE(array_t<uint64_t>)
-PYBIND_TYPE_CASTER_PYTYPE(array_t<float>)   PYBIND_TYPE_CASTER_PYTYPE(array_t<double>)
-PYBIND_TYPE_CASTER_PYTYPE(array_t<std::complex<float>>)
-PYBIND_TYPE_CASTER_PYTYPE(array_t<std::complex<double>>)
-PYBIND_TYPE_CASTER_PYTYPE(array_t<bool>)
+PYBIND11_TYPE_CASTER_PYTYPE(array)
+PYBIND11_TYPE_CASTER_PYTYPE(array_t<int8_t>)  PYBIND11_TYPE_CASTER_PYTYPE(array_t<uint8_t>)
+PYBIND11_TYPE_CASTER_PYTYPE(array_t<int16_t>) PYBIND11_TYPE_CASTER_PYTYPE(array_t<uint16_t>)
+PYBIND11_TYPE_CASTER_PYTYPE(array_t<int32_t>) PYBIND11_TYPE_CASTER_PYTYPE(array_t<uint32_t>)
+PYBIND11_TYPE_CASTER_PYTYPE(array_t<int64_t>) PYBIND11_TYPE_CASTER_PYTYPE(array_t<uint64_t>)
+PYBIND11_TYPE_CASTER_PYTYPE(array_t<float>)   PYBIND11_TYPE_CASTER_PYTYPE(array_t<double>)
+PYBIND11_TYPE_CASTER_PYTYPE(array_t<std::complex<float>>)
+PYBIND11_TYPE_CASTER_PYTYPE(array_t<std::complex<double>>)
+PYBIND11_TYPE_CASTER_PYTYPE(array_t<bool>)
 
 
 template <typename Func, typename Return, typename... Args>
 template <typename Func, typename Return, typename... Args>
 struct vectorize_helper {
 struct vectorize_helper {

include/pybind11/operators.h

@@ -59,7 +59,7 @@ template <op_id id, op_type ot, typename L, typename R> struct op_ {
     }
     }
 };
 };
 
 
-#define PYBIND_BINARY_OPERATOR(id, rid, op, expr)                                      \
+#define PYBIND11_BINARY_OPERATOR(id, rid, op, expr)                                      \
 template <typename B, typename L, typename R> struct op_impl<op_##id, op_l, B, L, R> { \
 template <typename B, typename L, typename R> struct op_impl<op_##id, op_l, B, L, R> { \
     static char const* name() { return "__" #id "__"; }                                \
     static char const* name() { return "__" #id "__"; }                                \
     static auto execute(const L &l, const R &r) -> decltype(expr) { return (expr); }   \
     static auto execute(const L &l, const R &r) -> decltype(expr) { return (expr); }   \
@@ -80,7 +80,7 @@ template <typename T> op_<op_##id, op_r, T, self_t> op(const T &, const self_t &
     return op_<op_##id, op_r, T, self_t>();                                            \
     return op_<op_##id, op_r, T, self_t>();                                            \
 };
 };
 
 
-#define PYBIND_INPLACE_OPERATOR(id, op, expr)                                          \
+#define PYBIND11_INPLACE_OPERATOR(id, op, expr)                                          \
 template <typename B, typename L, typename R> struct op_impl<op_##id, op_l, B, L, R> { \
 template <typename B, typename L, typename R> struct op_impl<op_##id, op_l, B, L, R> { \
     static char const* name() { return "__" #id "__"; }                                \
     static char const* name() { return "__" #id "__"; }                                \
     static auto execute(L &l, const R &r) -> decltype(expr) { return expr; }           \
     static auto execute(L &l, const R &r) -> decltype(expr) { return expr; }           \
@@ -90,7 +90,7 @@ template <typename T> op_<op_##id, op_l, self_t, T> op(const self_t &, const T &
     return op_<op_##id, op_l, self_t, T>();                                            \
     return op_<op_##id, op_l, self_t, T>();                                            \
 };
 };
 
 
-#define PYBIND_UNARY_OPERATOR(id, op, expr)                                            \
+#define PYBIND11_UNARY_OPERATOR(id, op, expr)                                            \
 template <typename B, typename L> struct op_impl<op_##id, op_u, B, L, undefined_t> {   \
 template <typename B, typename L> struct op_impl<op_##id, op_u, B, L, undefined_t> {   \
     static char const* name() { return "__" #id "__"; }                                \
     static char const* name() { return "__" #id "__"; }                                \
     static auto execute(const L &l) -> decltype(expr) { return expr; }                 \
     static auto execute(const L &l) -> decltype(expr) { return expr; }                 \
@@ -100,48 +100,48 @@ inline op_<op_##id, op_u, self_t, undefined_t> op(const self_t &) {
     return op_<op_##id, op_u, self_t, undefined_t>();                                  \
     return op_<op_##id, op_u, self_t, undefined_t>();                                  \
 };
 };
 
 
-PYBIND_BINARY_OPERATOR(sub,       rsub,         operator-,    l - r)
-PYBIND_BINARY_OPERATOR(add,       radd,         operator+,    l + r)
-PYBIND_BINARY_OPERATOR(mul,       rmul,         operator*,    l * r)
+PYBIND11_BINARY_OPERATOR(sub,       rsub,         operator-,    l - r)
+PYBIND11_BINARY_OPERATOR(add,       radd,         operator+,    l + r)
+PYBIND11_BINARY_OPERATOR(mul,       rmul,         operator*,    l * r)
 #if PY_MAJOR_VERSION >= 3
 #if PY_MAJOR_VERSION >= 3
-PYBIND_BINARY_OPERATOR(truediv,   rtruediv,     operator/,    l / r)
+PYBIND11_BINARY_OPERATOR(truediv,   rtruediv,     operator/,    l / r)
 #else
 #else
-PYBIND_BINARY_OPERATOR(div,       rdiv,         operator/,    l / r)
+PYBIND11_BINARY_OPERATOR(div,       rdiv,         operator/,    l / r)
 #endif
 #endif
-PYBIND_BINARY_OPERATOR(mod,       rmod,         operator%,    l % r)
-PYBIND_BINARY_OPERATOR(lshift,    rlshift,      operator<<,   l << r)
-PYBIND_BINARY_OPERATOR(rshift,    rrshift,      operator>>,   l >> r)
-PYBIND_BINARY_OPERATOR(and,       rand,         operator&,    l & r)
-PYBIND_BINARY_OPERATOR(xor,       rxor,         operator^,    l ^ r)
-PYBIND_BINARY_OPERATOR(eq,        eq,           operator==,   l == r)
-PYBIND_BINARY_OPERATOR(ne,        ne,           operator!=,   l != r)
-PYBIND_BINARY_OPERATOR(or,        ror,          operator|,    l | r)
-PYBIND_BINARY_OPERATOR(gt,        lt,           operator>,    l > r)
-PYBIND_BINARY_OPERATOR(ge,        le,           operator>=,   l >= r)
-PYBIND_BINARY_OPERATOR(lt,        gt,           operator<,    l < r)
-PYBIND_BINARY_OPERATOR(le,        ge,           operator<=,   l <= r)
-//PYBIND_BINARY_OPERATOR(pow,       rpow,         pow,          std::pow(l,  r))
-PYBIND_INPLACE_OPERATOR(iadd,     operator+=,   l += r)
-PYBIND_INPLACE_OPERATOR(isub,     operator-=,   l -= r)
-PYBIND_INPLACE_OPERATOR(imul,     operator*=,   l *= r)
-PYBIND_INPLACE_OPERATOR(idiv,     operator/=,   l /= r)
-PYBIND_INPLACE_OPERATOR(imod,     operator%=,   l %= r)
-PYBIND_INPLACE_OPERATOR(ilshift,  operator<<=,  l <<= r)
-PYBIND_INPLACE_OPERATOR(irshift,  operator>>=,  l >>= r)
-PYBIND_INPLACE_OPERATOR(iand,     operator&=,   l &= r)
-PYBIND_INPLACE_OPERATOR(ixor,     operator^=,   l ^= r)
-PYBIND_INPLACE_OPERATOR(ior,      operator|=,   l |= r)
-PYBIND_UNARY_OPERATOR(neg,        operator-,    -l)
-PYBIND_UNARY_OPERATOR(pos,        operator+,    +l)
-PYBIND_UNARY_OPERATOR(abs,        abs,          std::abs(l))
-PYBIND_UNARY_OPERATOR(invert,     operator~,    ~l)
-PYBIND_UNARY_OPERATOR(bool,       operator!,    !!l)
-PYBIND_UNARY_OPERATOR(int,        int_,         (int) l)
-PYBIND_UNARY_OPERATOR(float,      float_,       (double) l)
-
-#undef PYBIND_BINARY_OPERATOR
-#undef PYBIND_INPLACE_OPERATOR
-#undef PYBIND_UNARY_OPERATOR
+PYBIND11_BINARY_OPERATOR(mod,       rmod,         operator%,    l % r)
+PYBIND11_BINARY_OPERATOR(lshift,    rlshift,      operator<<,   l << r)
+PYBIND11_BINARY_OPERATOR(rshift,    rrshift,      operator>>,   l >> r)
+PYBIND11_BINARY_OPERATOR(and,       rand,         operator&,    l & r)
+PYBIND11_BINARY_OPERATOR(xor,       rxor,         operator^,    l ^ r)
+PYBIND11_BINARY_OPERATOR(eq,        eq,           operator==,   l == r)
+PYBIND11_BINARY_OPERATOR(ne,        ne,           operator!=,   l != r)
+PYBIND11_BINARY_OPERATOR(or,        ror,          operator|,    l | r)
+PYBIND11_BINARY_OPERATOR(gt,        lt,           operator>,    l > r)
+PYBIND11_BINARY_OPERATOR(ge,        le,           operator>=,   l >= r)
+PYBIND11_BINARY_OPERATOR(lt,        gt,           operator<,    l < r)
+PYBIND11_BINARY_OPERATOR(le,        ge,           operator<=,   l <= r)
+//PYBIND11_BINARY_OPERATOR(pow,       rpow,         pow,          std::pow(l,  r))
+PYBIND11_INPLACE_OPERATOR(iadd,     operator+=,   l += r)
+PYBIND11_INPLACE_OPERATOR(isub,     operator-=,   l -= r)
+PYBIND11_INPLACE_OPERATOR(imul,     operator*=,   l *= r)
+PYBIND11_INPLACE_OPERATOR(idiv,     operator/=,   l /= r)
+PYBIND11_INPLACE_OPERATOR(imod,     operator%=,   l %= r)
+PYBIND11_INPLACE_OPERATOR(ilshift,  operator<<=,  l <<= r)
+PYBIND11_INPLACE_OPERATOR(irshift,  operator>>=,  l >>= r)
+PYBIND11_INPLACE_OPERATOR(iand,     operator&=,   l &= r)
+PYBIND11_INPLACE_OPERATOR(ixor,     operator^=,   l ^= r)
+PYBIND11_INPLACE_OPERATOR(ior,      operator|=,   l |= r)
+PYBIND11_UNARY_OPERATOR(neg,        operator-,    -l)
+PYBIND11_UNARY_OPERATOR(pos,        operator+,    +l)
+PYBIND11_UNARY_OPERATOR(abs,        abs,          std::abs(l))
+PYBIND11_UNARY_OPERATOR(invert,     operator~,    ~l)
+PYBIND11_UNARY_OPERATOR(bool,       operator!,    !!l)
+PYBIND11_UNARY_OPERATOR(int,        int_,         (int) l)
+PYBIND11_UNARY_OPERATOR(float,      float_,       (double) l)
+
+#undef PYBIND11_BINARY_OPERATOR
+#undef PYBIND11_INPLACE_OPERATOR
+#undef PYBIND11_UNARY_OPERATOR
 NAMESPACE_END(detail)
 NAMESPACE_END(detail)
 
 
 using detail::self;
 using detail::self;

include/pybind11/pybind11.h

@@ -429,7 +429,7 @@ private:
 
 
 class module : public object {
 class module : public object {
 public:
 public:
-    PYBIND_OBJECT_DEFAULT(module, object, PyModule_Check)
+    PYBIND11_OBJECT_DEFAULT(module, object, PyModule_Check)
 
 
     module(const char *name, const char *doc = nullptr) {
     module(const char *name, const char *doc = nullptr) {
 #if PY_MAJOR_VERSION >= 3
 #if PY_MAJOR_VERSION >= 3
@@ -476,7 +476,7 @@ NAMESPACE_BEGIN(detail)
 /// Basic support for creating new Python heap types
 /// Basic support for creating new Python heap types
 class custom_type : public object {
 class custom_type : public object {
 public:
 public:
-    PYBIND_OBJECT_DEFAULT(custom_type, object, PyType_Check)
+    PYBIND11_OBJECT_DEFAULT(custom_type, object, PyType_Check)
 
 
     custom_type(object &scope, const char *name_, const std::type_info *tinfo,
     custom_type(object &scope, const char *name_, const std::type_info *tinfo,
                 size_t type_size, size_t instance_size,
                 size_t type_size, size_t instance_size,
@@ -667,7 +667,7 @@ template <typename type, typename holder_type = std::unique_ptr<type>> class cla
 public:
 public:
     typedef detail::instance<type, holder_type> instance_type;
     typedef detail::instance<type, holder_type> instance_type;
 
 
-    PYBIND_OBJECT(class_, detail::custom_type, PyType_Check)
+    PYBIND11_OBJECT(class_, detail::custom_type, PyType_Check)
 
 
     class_(object &scope, const char *name, const char *doc = nullptr)
     class_(object &scope, const char *name, const char *doc = nullptr)
         : detail::custom_type(scope, name, &typeid(type), sizeof(type),
         : detail::custom_type(scope, name, &typeid(type), sizeof(type),
@@ -925,18 +925,18 @@ inline function get_overload(const void *this_ptr, const char *name)  {
     return overload;
     return overload;
 }
 }
 
 
-#define PYBIND_OVERLOAD_INT(ret_type, class_name, name, ...) { \
+#define PYBIND11_OVERLOAD_INT(ret_type, class_name, name, ...) { \
         pybind11::gil_scoped_acquire gil; \
         pybind11::gil_scoped_acquire gil; \
         pybind11::function overload = pybind11::get_overload(this, #name); \
         pybind11::function overload = pybind11::get_overload(this, #name); \
         if (overload) \
         if (overload) \
             return overload.call(__VA_ARGS__).cast<ret_type>();  }
             return overload.call(__VA_ARGS__).cast<ret_type>();  }
 
 
-#define PYBIND_OVERLOAD(ret_type, class_name, name, ...) \
-    PYBIND_OVERLOAD_INT(ret_type, class_name, name, __VA_ARGS__) \
+#define PYBIND11_OVERLOAD(ret_type, class_name, name, ...) \
+    PYBIND11_OVERLOAD_INT(ret_type, class_name, name, __VA_ARGS__) \
     return class_name::name(__VA_ARGS__)
     return class_name::name(__VA_ARGS__)
 
 
-#define PYBIND_OVERLOAD_PURE(ret_type, class_name, name, ...) \
-    PYBIND_OVERLOAD_INT(ret_type, class_name, name, __VA_ARGS__) \
+#define PYBIND11_OVERLOAD_PURE(ret_type, class_name, name, ...) \
+    PYBIND11_OVERLOAD_INT(ret_type, class_name, name, __VA_ARGS__) \
     throw std::runtime_error("Tried to call pure virtual function \"" #name "\"");
     throw std::runtime_error("Tried to call pure virtual function \"" #name "\"");
 
 
 NAMESPACE_END(pybind11)
 NAMESPACE_END(pybind11)

include/pybind11/pytypes.h

@@ -195,7 +195,7 @@ inline detail::accessor handle::operator[](const char *key) { return detail::acc
 inline detail::accessor handle::attr(handle key) { return detail::accessor(ptr(), key.ptr(), true); }
 inline detail::accessor handle::attr(handle key) { return detail::accessor(ptr(), key.ptr(), true); }
 inline detail::accessor handle::attr(const char *key) { return detail::accessor(ptr(), key, true); }
 inline detail::accessor handle::attr(const char *key) { return detail::accessor(ptr(), key, true); }
 
 
-#define PYBIND_OBJECT_CVT(Name, Parent, CheckFun, CvtStmt) \
+#define PYBIND11_OBJECT_CVT(Name, Parent, CheckFun, CvtStmt) \
     Name(const handle &h, bool borrowed) : Parent(h, borrowed) { CvtStmt; } \
     Name(const handle &h, bool borrowed) : Parent(h, borrowed) { CvtStmt; } \
     Name(const object& o): Parent(o) { CvtStmt; } \
     Name(const object& o): Parent(o) { CvtStmt; } \
     Name(object&& o): Parent(std::move(o)) { CvtStmt; } \
     Name(object&& o): Parent(std::move(o)) { CvtStmt; } \
@@ -203,16 +203,16 @@ inline detail::accessor handle::attr(const char *key) { return detail::accessor(
     Name& operator=(object& o) { return static_cast<Name&>(object::operator=(o)); CvtStmt; } \
     Name& operator=(object& o) { return static_cast<Name&>(object::operator=(o)); CvtStmt; } \
     bool check() const { return m_ptr != nullptr && (bool) CheckFun(m_ptr); }
     bool check() const { return m_ptr != nullptr && (bool) CheckFun(m_ptr); }
 
 
-#define PYBIND_OBJECT(Name, Parent, CheckFun) \
-    PYBIND_OBJECT_CVT(Name, Parent, CheckFun, )
+#define PYBIND11_OBJECT(Name, Parent, CheckFun) \
+    PYBIND11_OBJECT_CVT(Name, Parent, CheckFun, )
 
 
-#define PYBIND_OBJECT_DEFAULT(Name, Parent, CheckFun) \
-    PYBIND_OBJECT(Name, Parent, CheckFun) \
+#define PYBIND11_OBJECT_DEFAULT(Name, Parent, CheckFun) \
+    PYBIND11_OBJECT(Name, Parent, CheckFun) \
     Name() : Parent() { }
     Name() : Parent() { }
 
 
 class str : public object {
 class str : public object {
 public:
 public:
-    PYBIND_OBJECT_DEFAULT(str, object, PyUnicode_Check)
+    PYBIND11_OBJECT_DEFAULT(str, object, PyUnicode_Check)
     str(const char *s) : object(PyUnicode_FromString(s), false) { }
     str(const char *s) : object(PyUnicode_FromString(s), false) { }
     operator const char *() const {
     operator const char *() const {
 #if PY_MAJOR_VERSION >= 3
 #if PY_MAJOR_VERSION >= 3
@@ -241,13 +241,13 @@ inline pybind11::str handle::str() const {
 
 
 class bool_ : public object {
 class bool_ : public object {
 public:
 public:
-    PYBIND_OBJECT_DEFAULT(bool_, object, PyBool_Check)
+    PYBIND11_OBJECT_DEFAULT(bool_, object, PyBool_Check)
     operator bool() const { return m_ptr && PyLong_AsLong(m_ptr) != 0; }
     operator bool() const { return m_ptr && PyLong_AsLong(m_ptr) != 0; }
 };
 };
 
 
 class int_ : public object {
 class int_ : public object {
 public:
 public:
-    PYBIND_OBJECT_DEFAULT(int_, object, PyLong_Check)
+    PYBIND11_OBJECT_DEFAULT(int_, object, PyLong_Check)
     int_(int value) : object(PyLong_FromLong((long) value), false) { }
     int_(int value) : object(PyLong_FromLong((long) value), false) { }
     int_(size_t value) : object(PyLong_FromSize_t(value), false) { }
     int_(size_t value) : object(PyLong_FromSize_t(value), false) { }
 #if !defined(WIN32) || defined(_WIN64)
 #if !defined(WIN32) || defined(_WIN64)
@@ -258,7 +258,7 @@ public:
 
 
 class float_ : public object {
 class float_ : public object {
 public:
 public:
-    PYBIND_OBJECT_DEFAULT(float_, object, PyFloat_Check)
+    PYBIND11_OBJECT_DEFAULT(float_, object, PyFloat_Check)
     float_(float value) : object(PyFloat_FromDouble((double) value), false) { }
     float_(float value) : object(PyFloat_FromDouble((double) value), false) { }
     float_(double value) : object(PyFloat_FromDouble((double) value), false) { }
     float_(double value) : object(PyFloat_FromDouble((double) value), false) { }
     operator float() const { return (float) PyFloat_AsDouble(m_ptr); }
     operator float() const { return (float) PyFloat_AsDouble(m_ptr); }
@@ -267,7 +267,7 @@ public:
 
 
 class slice : public object {
 class slice : public object {
 public:
 public:
-    PYBIND_OBJECT_DEFAULT(slice, object, PySlice_Check)
+    PYBIND11_OBJECT_DEFAULT(slice, object, PySlice_Check)
     slice(ssize_t start_, ssize_t stop_, ssize_t step_) {
     slice(ssize_t start_, ssize_t stop_, ssize_t step_) {
         int_ start(start_), stop(stop_), step(step_);
         int_ start(start_), stop(stop_), step(step_);
         m_ptr = PySlice_New(start.ptr(), stop.ptr(), step.ptr());
         m_ptr = PySlice_New(start.ptr(), stop.ptr(), step.ptr());
@@ -285,7 +285,7 @@ public:
 
 
 class capsule : public object {
 class capsule : public object {
 public:
 public:
-    PYBIND_OBJECT_DEFAULT(capsule, object, PyCapsule_CheckExact)
+    PYBIND11_OBJECT_DEFAULT(capsule, object, PyCapsule_CheckExact)
     capsule(PyObject *obj, bool borrowed) : object(obj, borrowed) { }
     capsule(PyObject *obj, bool borrowed) : object(obj, borrowed) { }
     capsule(void *value, void (*destruct)(PyObject *) = nullptr) : object(PyCapsule_New(value, nullptr, destruct), false) { }
     capsule(void *value, void (*destruct)(PyObject *) = nullptr) : object(PyCapsule_New(value, nullptr, destruct), false) { }
     template <typename T> operator T *() const {
     template <typename T> operator T *() const {
@@ -297,7 +297,7 @@ public:
 
 
 class tuple : public object {
 class tuple : public object {
 public:
 public:
-    PYBIND_OBJECT_DEFAULT(tuple, object, PyTuple_Check)
+    PYBIND11_OBJECT_DEFAULT(tuple, object, PyTuple_Check)
     tuple(size_t size) : object(PyTuple_New((Py_ssize_t) size), false) { }
     tuple(size_t size) : object(PyTuple_New((Py_ssize_t) size), false) { }
     size_t size() const { return (size_t) PyTuple_Size(m_ptr); }
     size_t size() const { return (size_t) PyTuple_Size(m_ptr); }
     detail::tuple_accessor operator[](size_t index) { return detail::tuple_accessor(ptr(), index); }
     detail::tuple_accessor operator[](size_t index) { return detail::tuple_accessor(ptr(), index); }
@@ -305,7 +305,7 @@ public:
 
 
 class dict : public object {
 class dict : public object {
 public:
 public:
-    PYBIND_OBJECT(dict, object, PyDict_Check)
+    PYBIND11_OBJECT(dict, object, PyDict_Check)
     dict() : object(PyDict_New(), false) { }
     dict() : object(PyDict_New(), false) { }
     size_t size() const { return (size_t) PyDict_Size(m_ptr); }
     size_t size() const { return (size_t) PyDict_Size(m_ptr); }
     detail::dict_iterator begin() { return (++detail::dict_iterator(ptr(), 0)); }
     detail::dict_iterator begin() { return (++detail::dict_iterator(ptr(), 0)); }
@@ -314,7 +314,7 @@ public:
 
 
 class list : public object {
 class list : public object {
 public:
 public:
-    PYBIND_OBJECT(list, object, PyList_Check)
+    PYBIND11_OBJECT(list, object, PyList_Check)
     list(size_t size = 0) : object(PyList_New((ssize_t) size), false) { }
     list(size_t size = 0) : object(PyList_New((ssize_t) size), false) { }
     size_t size() const { return (size_t) PyList_Size(m_ptr); }
     size_t size() const { return (size_t) PyList_Size(m_ptr); }
     detail::list_iterator begin() { return detail::list_iterator(ptr(), 0); }
     detail::list_iterator begin() { return detail::list_iterator(ptr(), 0); }
@@ -325,7 +325,7 @@ public:
 
 
 class function : public object {
 class function : public object {
 public:
 public:
-    PYBIND_OBJECT_DEFAULT(function, object, PyFunction_Check)
+    PYBIND11_OBJECT_DEFAULT(function, object, PyFunction_Check)
 
 
     bool is_cpp_function() {
     bool is_cpp_function() {
         PyObject *ptr = m_ptr;
         PyObject *ptr = m_ptr;
@@ -343,7 +343,7 @@ public:
 
 
 class buffer : public object {
 class buffer : public object {
 public:
 public:
-    PYBIND_OBJECT_DEFAULT(buffer, object, PyObject_CheckBuffer)
+    PYBIND11_OBJECT_DEFAULT(buffer, object, PyObject_CheckBuffer)
 
 
     buffer_info request(bool writable = false) {
     buffer_info request(bool writable = false) {
         int flags = PyBUF_STRIDES | PyBUF_FORMAT;
         int flags = PyBUF_STRIDES | PyBUF_FORMAT;

include/pybind11/stl.h

@@ -54,7 +54,7 @@ public:
         }
         }
         return list;
         return list;
     }
     }
-    PYBIND_TYPE_CASTER(type, detail::descr("list<") + value_conv::name() + detail::descr(">"));
+    PYBIND11_TYPE_CASTER(type, detail::descr("list<") + value_conv::name() + detail::descr(">"));
 };
 };
 
 
 template <typename Key, typename Value> struct type_caster<std::map<Key, Value>> {
 template <typename Key, typename Value> struct type_caster<std::map<Key, Value>> {
@@ -97,7 +97,7 @@ public:
         return dict;
         return dict;
     }
     }
 
 
-    PYBIND_TYPE_CASTER(type, detail::descr("dict<") + key_conv::name() + detail::descr(", ") + value_conv::name() + detail::descr(">"));
+    PYBIND11_TYPE_CASTER(type, detail::descr("dict<") + key_conv::name() + detail::descr(", ") + value_conv::name() + detail::descr(">"));
 };
 };
 
 
 NAMESPACE_END(detail)
 NAMESPACE_END(detail)