Renamed a lot of Shiboken things with "Py" prefix to use "Sbk" prefix.

To avoid confusion of Python stuff with Shiboken generated stuff.
For example: a C++ class called "String" would have the PyString_Type
wrapper generated for it, mixing with the proper Python PyString_Type;
now the generate code will have things like SbkString_Type, SbkString_New,
SbkString_someMethod, and so on.

PyBaseWrapper and its variants were renamed to SbkBaseWrapper.

PyType<T>() is now SbkType<T>()

PyEnumObject was renamed to SbkEnumObject.

7 files changed, 85 insertions, 83 deletions

diff --git a/libshiboken/basewrapper.cpp b/libshiboken/basewrapper.cpp
index 3a2bc9964..6653c8ab5 100644
--- a/libshiboken/basewrapper.cpp
+++ b/libshiboken/basewrapper.cpp
@@ -39,7 +39,7 @@
 namespace Shiboken
 {
 
-void removeParent(PyBaseWrapper* child)
+void removeParent(SbkBaseWrapper* child)
 {
     if (child->parentInfo->parent) {
         ShiboChildrenList& oldBrothers = child->parentInfo->parent->parentInfo->children;
@@ -56,8 +56,8 @@ void setParent(PyObject* parent, PyObject* child)
 
     bool parentIsNull = !parent || parent == Py_None;
 
-    PyBaseWrapper* parent_ = reinterpret_cast<PyBaseWrapper*>(parent);
-    PyBaseWrapper* child_ = reinterpret_cast<PyBaseWrapper*>(child);
+    SbkBaseWrapper* parent_ = reinterpret_cast<SbkBaseWrapper*>(parent);
+    SbkBaseWrapper* child_ = reinterpret_cast<SbkBaseWrapper*>(child);
     if (!child_->parentInfo)
         child_->parentInfo = new ShiboParentInfo;
 
@@ -84,13 +84,13 @@ void setParent(PyObject* parent, PyObject* child)
     }
 }
 
-static void _destroyParentInfo(PyBaseWrapper* obj, bool removeFromParent)
+static void _destroyParentInfo(SbkBaseWrapper* obj, bool removeFromParent)
 {
     if (removeFromParent && obj->parentInfo->parent)
         removeParent(obj);
     ShiboChildrenList::iterator it = obj->parentInfo->children.begin();
     for (; it != obj->parentInfo->children.end(); ++it) {
-        PyBaseWrapper*& child = *it;
+        SbkBaseWrapper*& child = *it;
         _destroyParentInfo(child, false);
         Py_DECREF(child);
     }
@@ -98,13 +98,13 @@ static void _destroyParentInfo(PyBaseWrapper* obj, bool removeFromParent)
     obj->parentInfo = 0;
 }
 
-void destroyParentInfo(PyBaseWrapper* obj, bool removeFromParent)
+void destroyParentInfo(SbkBaseWrapper* obj, bool removeFromParent)
 {
     BindingManager::instance().invalidateWrapper(obj);
     _destroyParentInfo(obj, removeFromParent);
 }
 
-PyObject* PyBaseWrapper_New(PyTypeObject* instanceType,
+PyObject* SbkBaseWrapper_New(PyTypeObject* instanceType,
                             const void* cptr,
                             unsigned int hasOwnership,
                             unsigned int containsCppWrapper)
@@ -113,7 +113,7 @@ PyObject* PyBaseWrapper_New(PyTypeObject* instanceType,
         return 0;
 
     ShiboTypeObject* const& instanceType_ = reinterpret_cast<ShiboTypeObject*>(instanceType);
-    PyBaseWrapper* self = (PyBaseWrapper*)instanceType_->pytype.tp_alloc((PyTypeObject*) instanceType, 0);
+    SbkBaseWrapper* self = (SbkBaseWrapper*)instanceType_->pytype.tp_alloc((PyTypeObject*) instanceType, 0);
 
     self->cptr = const_cast<void*>(cptr);
     self->hasOwnership = hasOwnership;
@@ -139,16 +139,16 @@ PyObject* PyBaseWrapper_New(PyTypeObject* instanceType,
 
 bool cppObjectIsInvalid(PyObject* wrapper)
 {
-    if (wrapper == Py_None || ((Shiboken::PyBaseWrapper*)wrapper)->validCppObject)
+    if (wrapper == Py_None || ((Shiboken::SbkBaseWrapper*)wrapper)->validCppObject)
         return false;
     PyErr_SetString(PyExc_RuntimeError, "internal C++ object already deleted.");
     return true;
 }
 
-void PyBaseWrapper_Dealloc_PrivateDtor(PyObject* self)
+void SbkBaseWrapper_Dealloc_PrivateDtor(PyObject* self)
 {
     BindingManager::instance().releaseWrapper(self);
-    Py_TYPE(((PyBaseWrapper*)self))->tp_free((PyObject*)self);
+    Py_TYPE(((SbkBaseWrapper*)self))->tp_free((PyObject*)self);
 }
 
 } // namespace Shiboken
diff --git a/libshiboken/basewrapper.h b/libshiboken/basewrapper.h
index a9279ef6c..9187a775b 100644
--- a/libshiboken/basewrapper.h
+++ b/libshiboken/basewrapper.h
@@ -42,10 +42,10 @@
 namespace Shiboken
 {
 
-struct PyBaseWrapper;
+struct SbkBaseWrapper;
 
-/// Linked list of PyBaseWrapper pointers
-typedef std::list<PyBaseWrapper*> ShiboChildrenList;
+/// Linked list of SbkBaseWrapper pointers
+typedef std::list<SbkBaseWrapper*> ShiboChildrenList;
 
 /// Struct used to store information about object parent and children.
 struct LIBSHIBOKEN_API ShiboParentInfo
@@ -53,7 +53,7 @@ struct LIBSHIBOKEN_API ShiboParentInfo
     /// Default ctor.
     ShiboParentInfo() : parent(0) {}
     /// Pointer to parent object.
-    PyBaseWrapper* parent;
+    SbkBaseWrapper* parent;
     /// List of object children.
     ShiboChildrenList children;
 };
@@ -81,7 +81,7 @@ struct LIBSHIBOKEN_API ShiboTypeObject
 };
 
 /// Base Python object for all the wrapped C++ classes.
-struct LIBSHIBOKEN_API PyBaseWrapper
+struct LIBSHIBOKEN_API SbkBaseWrapper
 {
     PyObject_HEAD
     /// Pointer to the C++ class.
@@ -110,32 +110,32 @@ LIBSHIBOKEN_API void setParent(PyObject* parent, PyObject* child);
 *   Remove this child from their parent, if any.
 *   \param child the child.
 */
-LIBSHIBOKEN_API void removeParent(PyBaseWrapper* child);
+LIBSHIBOKEN_API void removeParent(SbkBaseWrapper* child);
 
 /**
-* \internal This is an internal function called by PyBaseWrapper_Dealloc, it's exported just for techinical reasons.
+* \internal This is an internal function called by SbkBaseWrapper_Dealloc, it's exported just for techinical reasons.
 * \note Do not call this function inside your bindings.
 */
-LIBSHIBOKEN_API void destroyParentInfo(PyBaseWrapper* obj, bool removeFromParent = true);
+LIBSHIBOKEN_API void destroyParentInfo(SbkBaseWrapper* obj, bool removeFromParent = true);
 
 
 /**
- * Shiboken_TypeCheck macro performs a type check using the values registered with PyType<>() template.
+ * Shiboken_TypeCheck macro performs a type check using the values registered with SbkType<>() template.
  */
-#define Shiboken_TypeCheck(pyobj, type) (PyObject_TypeCheck(pyobj, PyType<type>()))
+#define Shiboken_TypeCheck(pyobj, type) (PyObject_TypeCheck(pyobj, SbkType<type>()))
 
-#define PyBaseWrapper_Check(op) PyObject_TypeCheck(op, &Shiboken::PyBaseWrapper_Type)
-#define PyBaseWrapper_CheckExact(op) ((op)->ob_type == &Shiboken::PyBaseWrapper_Type)
+#define SbkBaseWrapper_Check(op) PyObject_TypeCheck(op, &Shiboken::SbkBaseWrapper_Type)
+#define SbkBaseWrapper_CheckExact(op) ((op)->ob_type == &Shiboken::SbkBaseWrapper_Type)
 
-#define PyBaseWrapper_cptr(pyobj)                   (((Shiboken::PyBaseWrapper*)pyobj)->cptr)
-#define PyBaseWrapper_setCptr(pyobj,c)              (((Shiboken::PyBaseWrapper*)pyobj)->cptr = c)
-#define PyBaseWrapper_hasOwnership(pyobj)           (((Shiboken::PyBaseWrapper*)pyobj)->hasOwnership)
-#define PyBaseWrapper_setOwnership(pyobj,o)         (((Shiboken::PyBaseWrapper*)pyobj)->hasOwnership = o)
-#define PyBaseWrapper_hasParentInfo(pyobj)          (((Shiboken::PyBaseWrapper*)pyobj)->parentInfo)
-#define PyBaseWrapper_containsCppWrapper(pyobj)     (((Shiboken::PyBaseWrapper*)pyobj)->containsCppWrapper)
-#define PyBaseWrapper_setContainsCppWrapper(pyobj,o)(((Shiboken::PyBaseWrapper*)pyobj)->containsCppWrapper= o)
-#define PyBaseWrapper_validCppObject(pyobj)         (((Shiboken::PyBaseWrapper*)pyobj)->validCppObject)
-#define PyBaseWrapper_setValidCppObject(pyobj,v)    (((Shiboken::PyBaseWrapper*)pyobj)->validCppObject = v)
+#define SbkBaseWrapper_cptr(pyobj)                   (((Shiboken::SbkBaseWrapper*)pyobj)->cptr)
+#define SbkBaseWrapper_setCptr(pyobj,c)              (((Shiboken::SbkBaseWrapper*)pyobj)->cptr = c)
+#define SbkBaseWrapper_hasOwnership(pyobj)           (((Shiboken::SbkBaseWrapper*)pyobj)->hasOwnership)
+#define SbkBaseWrapper_setOwnership(pyobj,o)         (((Shiboken::SbkBaseWrapper*)pyobj)->hasOwnership = o)
+#define SbkBaseWrapper_hasParentInfo(pyobj)          (((Shiboken::SbkBaseWrapper*)pyobj)->parentInfo)
+#define SbkBaseWrapper_containsCppWrapper(pyobj)     (((Shiboken::SbkBaseWrapper*)pyobj)->containsCppWrapper)
+#define SbkBaseWrapper_setContainsCppWrapper(pyobj,o)(((Shiboken::SbkBaseWrapper*)pyobj)->containsCppWrapper= o)
+#define SbkBaseWrapper_validCppObject(pyobj)         (((Shiboken::SbkBaseWrapper*)pyobj)->validCppObject)
+#define SbkBaseWrapper_setValidCppObject(pyobj,v)    (((Shiboken::SbkBaseWrapper*)pyobj)->validCppObject = v)
 
 /* The #defines below were taken from Cython-generated code to allow shiboken to be used with python2.5.
  * Maybe not all of these defines are useful to us, time will tell which ones are really needed or not.
@@ -186,27 +186,28 @@ typedef struct {
 #endif
 
 LIBSHIBOKEN_API PyAPI_FUNC(PyObject*)
-PyBaseWrapper_New(PyTypeObject* instanceType,
-                  const void *cptr,
-                  unsigned int hasOwnership = 1,
-                  unsigned int containsCppWrapper = 0);
+SbkBaseWrapper_New(PyTypeObject* instanceType,
+                   const void *cptr,
+                   unsigned int hasOwnership = 1,
+                   unsigned int containsCppWrapper = 0);
 
 /// Returns true and sets a Python RuntimeError if the Python wrapper is not marked as valid.
 LIBSHIBOKEN_API bool cppObjectIsInvalid(PyObject* wrapper);
 
 template <typename T>
-void PyBaseWrapper_Dealloc(PyObject* self)
+void SbkBaseWrapper_Dealloc(PyObject* self)
 {
     BindingManager::instance().releaseWrapper(self);
-    if (PyBaseWrapper_hasOwnership(self))
-        delete ((T*)PyBaseWrapper_cptr(self));
-    if (PyBaseWrapper_hasParentInfo(self))
-        destroyParentInfo(reinterpret_cast<PyBaseWrapper*>(self));
-    Py_TYPE(((PyBaseWrapper*)self))->tp_free((PyObject*)self);
+    if (SbkBaseWrapper_hasOwnership(self))
+        delete ((T*)SbkBaseWrapper_cptr(self));
+    if (SbkBaseWrapper_hasParentInfo(self))
+        destroyParentInfo(reinterpret_cast<SbkBaseWrapper*>(self));
+    Py_TYPE(((SbkBaseWrapper*)self))->tp_free((PyObject*)self);
 }
 
-LIBSHIBOKEN_API PyAPI_FUNC(void) PyBaseWrapper_Dealloc_PrivateDtor(PyObject* self);
+LIBSHIBOKEN_API PyAPI_FUNC(void) SbkBaseWrapper_Dealloc_PrivateDtor(PyObject* self);
 
 } // namespace Shiboken
 
 #endif // BASEWRAPPER_H
+
diff --git a/libshiboken/bindingmanager.cpp b/libshiboken/bindingmanager.cpp
index 5788b1108..6b08829e7 100644
--- a/libshiboken/bindingmanager.cpp
+++ b/libshiboken/bindingmanager.cpp
@@ -86,7 +86,7 @@ void BindingManager::assignWrapper(PyObject* wrapper, const void* cptr)
 
 void BindingManager::releaseWrapper(PyObject* wrapper)
 {
-    void* cptr = PyBaseWrapper_cptr(wrapper);
+    void* cptr = SbkBaseWrapper_cptr(wrapper);
     m_d->releaseWrapper(cptr);
     if (((ShiboTypeObject*) wrapper->ob_type)->mi_offsets) {
         int* offset = ((ShiboTypeObject*) wrapper->ob_type)->mi_offsets;
@@ -138,14 +138,14 @@ PyObject* BindingManager::getOverride(const void* cptr, const char* methodName)
     return 0;
 }
 
-void BindingManager::invalidateWrapper(PyBaseWrapper* wrapper)
+void BindingManager::invalidateWrapper(SbkBaseWrapper* wrapper)
 {
-    if (!PyBaseWrapper_validCppObject(wrapper))
+    if (!SbkBaseWrapper_validCppObject(wrapper))
         return;
-    PyBaseWrapper_setValidCppObject(wrapper, false);
-    PyBaseWrapper_setOwnership(wrapper, false);
+    SbkBaseWrapper_setValidCppObject(wrapper, false);
+    SbkBaseWrapper_setOwnership(wrapper, false);
     // If it is a parent invalidate all children.
-    if (PyBaseWrapper_hasParentInfo(wrapper)) {
+    if (SbkBaseWrapper_hasParentInfo(wrapper)) {
         ShiboChildrenList::iterator it = wrapper->parentInfo->children.begin();
         for (; it != wrapper->parentInfo->children.end(); ++it)
             invalidateWrapper(*it);
@@ -160,13 +160,13 @@ void BindingManager::invalidateWrapper(const void* cptr)
         invalidateWrapper(iter->second);
 }
 
-void BindingManager::transferOwnershipToCpp(PyBaseWrapper* wrapper)
+void BindingManager::transferOwnershipToCpp(SbkBaseWrapper* wrapper)
 {
     if (wrapper->parentInfo)
         Shiboken::removeParent(wrapper);
 
-    if (PyBaseWrapper_containsCppWrapper(wrapper))
-        PyBaseWrapper_setOwnership(wrapper, false);
+    if (SbkBaseWrapper_containsCppWrapper(wrapper))
+        SbkBaseWrapper_setOwnership(wrapper, false);
     else
         invalidateWrapper(wrapper);
 }
diff --git a/libshiboken/bindingmanager.h b/libshiboken/bindingmanager.h
index 602066f91..05e115412 100644
--- a/libshiboken/bindingmanager.h
+++ b/libshiboken/bindingmanager.h
@@ -41,7 +41,7 @@
 namespace Shiboken
 {
 
-struct PyBaseWrapper;
+struct SbkBaseWrapper;
 
 class LIBSHIBOKEN_API BindingManager
 {
@@ -55,21 +55,21 @@ public:
     PyObject* getOverride(const void* cptr, const char* methodName);
 
     /// Invalidate the Python wrapper and removes the relations from C++ pointers to the Python wrapper.
-    void invalidateWrapper(PyBaseWrapper* wrapper);
-    /// Convenience method to call invalidateWrapper with a properly cast PyBaseWrapper.
+    void invalidateWrapper(SbkBaseWrapper* wrapper);
+    /// Convenience method to call invalidateWrapper with a properly cast SbkBaseWrapper.
     inline void invalidateWrapper(PyObject* wrapper)
     {
-        invalidateWrapper(reinterpret_cast<PyBaseWrapper*>(wrapper));
+        invalidateWrapper(reinterpret_cast<SbkBaseWrapper*>(wrapper));
     }
     /// Convenience method to invalidate the Python wrapper for a C++ wrapped object. Do nothing if C++ pointer has no Python wrapper.
     void invalidateWrapper(const void* cptr);
 
     /// Transfers the ownership of a Python wrapper to C++.
-    void transferOwnershipToCpp(PyBaseWrapper* wrapper);
-    /// Convenience method to call transferOwnershipToCpp with a properly cast PyBaseWrapper.
+    void transferOwnershipToCpp(SbkBaseWrapper* wrapper);
+    /// Convenience method to call transferOwnershipToCpp with a properly cast SbkBaseWrapper.
     inline void transferOwnershipToCpp(PyObject* wrapper)
     {
-        transferOwnershipToCpp(reinterpret_cast<PyBaseWrapper*>(wrapper));
+        transferOwnershipToCpp(reinterpret_cast<SbkBaseWrapper*>(wrapper));
     }
 
 private:
@@ -86,3 +86,4 @@ private:
 } // namespace Shiboken
 
 #endif // BINDINGMANAGER_H
+
diff --git a/libshiboken/conversions.h b/libshiboken/conversions.h
index ce32eff5d..b33d4e748 100644
--- a/libshiboken/conversions.h
+++ b/libshiboken/conversions.h
@@ -54,7 +54,7 @@ namespace Shiboken
 *   \see SpecialCastFunction
 */
 template<typename T>
-inline PyTypeObject* PyType()
+inline PyTypeObject* SbkType()
 {
     assert(false); // This *SHOULD* never be called.
     return 0;
@@ -68,7 +68,7 @@ struct ConverterBase
 {
     static PyObject* createWrapper(const T* cppobj)
     {
-        return Shiboken::PyBaseWrapper_New(PyType<T>(), cppobj);;
+        return Shiboken::SbkBaseWrapper_New(SbkType<T>(), cppobj);;
     }
     static T* copyCppObject(const T& cppobj) { return 0; }
     static bool isConvertible(PyObject* pyobj) { return pyobj == Py_None; }
@@ -104,8 +104,8 @@ struct ConverterBase<T*> : ConverterBase<T>
             return 0;
         ShiboTypeObject* shiboType = reinterpret_cast<ShiboTypeObject*>(pyobj->ob_type);
         if (shiboType->mi_specialcast)
-            return (T*) shiboType->mi_specialcast(pyobj, reinterpret_cast<ShiboTypeObject*>(PyType<T>()));
-        return (T*) ((Shiboken::PyBaseWrapper*) pyobj)->cptr;
+            return (T*) shiboType->mi_specialcast(pyobj, reinterpret_cast<ShiboTypeObject*>(SbkType<T>()));
+        return (T*) ((Shiboken::SbkBaseWrapper*) pyobj)->cptr;
     }
 };
 
@@ -128,7 +128,7 @@ struct Converter<T*> : Converter<T>
     static T* toCpp(PyObject* pyobj)
     {
         if (Shiboken_TypeCheck(pyobj, T))
-            return (T*) ((Shiboken::PyBaseWrapper*) pyobj)->cptr;
+            return (T*) ((Shiboken::SbkBaseWrapper*) pyobj)->cptr;
         else if (Converter<T>::isConvertible(pyobj))
             return Converter<T>::copyCppObject(Converter<T>::toCpp(pyobj));
         return 0;
@@ -269,11 +269,11 @@ struct Converter_CppEnum
 {
     static PyObject* createWrapper(CppEnum cppobj)
     {
-        return PyEnumObject_New(PyType<CppEnum>(), (long)cppobj);
+        return SbkEnumObject_New(SbkType<CppEnum>(), (long)cppobj);
     }
     static CppEnum toCpp(PyObject* pyobj)
     {
-        return (CppEnum) ((Shiboken::PyEnumObject*)pyobj)->ob_ival;
+        return (CppEnum) ((Shiboken::SbkEnumObject*)pyobj)->ob_ival;
     }
     static PyObject* toPython(CppEnum cppenum)
     {
diff --git a/libshiboken/pyenum.cpp b/libshiboken/pyenum.cpp
index be15496a5..3a223ef08 100644
--- a/libshiboken/pyenum.cpp
+++ b/libshiboken/pyenum.cpp
@@ -38,24 +38,24 @@ namespace Shiboken
 {
 
 PyObject*
-PyEnumObject_New(PyTypeObject *type, long item_value, PyObject* item_name)
+SbkEnumObject_New(PyTypeObject *type, long item_value, PyObject* item_name)
 {
     if (!item_name)
         item_name = PyString_FromString("");
-    PyEnumObject* enum_obj = (PyEnumObject*) type->tp_alloc(type, 0);
+    SbkEnumObject* enum_obj = (SbkEnumObject*) type->tp_alloc(type, 0);
     enum_obj->ob_name = item_name;
     enum_obj->ob_ival = item_value;
     return (PyObject*) enum_obj;
 }
 
 PyObject*
-PyEnumObject_New(PyTypeObject *type, long item_value, const char* item_name)
+SbkEnumObject_New(PyTypeObject *type, long item_value, const char* item_name)
 {
     PyObject* py_item_name = 0;
     if (item_name)
         py_item_name = PyString_FromString(item_name);
 
-    PyObject* enum_obj = PyEnumObject_New(type, item_value, py_item_name);
+    PyObject* enum_obj = SbkEnumObject_New(type, item_value, py_item_name);
     if (!enum_obj) {
         Py_XDECREF(py_item_name);
         return 0;
@@ -77,7 +77,7 @@ extern "C"
 {
 
 PyObject*
-PyEnumObject_NonExtensibleNew(PyTypeObject *type, PyObject *args, PyObject *kwds)
+SbkEnumObject_NonExtensibleNew(PyTypeObject *type, PyObject *args, PyObject *kwds)
 {
     PyErr_SetString(PyExc_TypeError, "enum is not extensible");
     return 0;
@@ -85,19 +85,19 @@ PyEnumObject_NonExtensibleNew(PyTypeObject *type, PyObject *args, PyObject *kwds
 
 
 PyObject*
-PyEnumObject_repr(PyObject* self)
+SbkEnumObject_repr(PyObject* self)
 {
     return PyString_FromFormat("<enum-item %s.%s (%ld)>",
                                self->ob_type->tp_name,
-                               PyString_AS_STRING(((PyEnumObject*)self)->ob_name),
-                               ((PyEnumObject*)self)->ob_ival);
+                               PyString_AS_STRING(((SbkEnumObject*)self)->ob_name),
+                               ((SbkEnumObject*)self)->ob_ival);
 }
 
 PyObject*
-PyEnumObject_name(PyObject* self)
+SbkEnumObject_name(PyObject* self)
 {
-    Py_INCREF(((PyEnumObject*)self)->ob_name);
-    return ((PyEnumObject*)self)->ob_name;
+    Py_INCREF(((SbkEnumObject*)self)->ob_name);
+    return ((SbkEnumObject*)self)->ob_name;
 }
 
 } // extern "C"
diff --git a/libshiboken/pyenum.h b/libshiboken/pyenum.h
index 18dc6730c..4e7d6bf20 100644
--- a/libshiboken/pyenum.h
+++ b/libshiboken/pyenum.h
@@ -48,18 +48,18 @@ typedef struct {
     PyObject_HEAD
     long ob_ival;
     PyObject* ob_name;
-} PyEnumObject;
+} SbkEnumObject;
 
-LIBSHIBOKEN_API PyAPI_FUNC(PyObject*) PyEnumObject_repr(PyObject* self);
-LIBSHIBOKEN_API PyAPI_FUNC(PyObject*) PyEnumObject_name(PyObject* self);
-LIBSHIBOKEN_API PyAPI_FUNC(PyObject*) PyEnumObject_NonExtensibleNew(PyTypeObject* type, PyObject* args, PyObject* kwds);
+LIBSHIBOKEN_API PyAPI_FUNC(PyObject*) SbkEnumObject_repr(PyObject* self);
+LIBSHIBOKEN_API PyAPI_FUNC(PyObject*) SbkEnumObject_name(PyObject* self);
+LIBSHIBOKEN_API PyAPI_FUNC(PyObject*) SbkEnumObject_NonExtensibleNew(PyTypeObject* type, PyObject* args, PyObject* kwds);
 
 } // extern "C"
 
-LIBSHIBOKEN_API PyObject* PyEnumObject_New(PyTypeObject *instanceType,
+LIBSHIBOKEN_API PyObject* SbkEnumObject_New(PyTypeObject *instanceType,
                            long item_value,
                            const char* item_name);
-LIBSHIBOKEN_API PyObject* PyEnumObject_New(PyTypeObject *instanceType,
+LIBSHIBOKEN_API PyObject* SbkEnumObject_New(PyTypeObject *instanceType,
                            long item_value,
                            PyObject* item_name = 0);