1 files changed, 75 insertions, 75 deletions

diff --git a/sources/shiboken2/libshiboken/sbkenum.cpp b/sources/shiboken2/libshiboken/sbkenum.cpp
index 26b40c3cb..75054ab71 100644
--- a/sources/shiboken2/libshiboken/sbkenum.cpp
+++ b/sources/shiboken2/libshiboken/sbkenum.cpp
@@ -49,18 +49,18 @@
 #include <cstring>
 #include <vector>
 
-#define SBK_ENUM(ENUM) reinterpret_cast<SbkEnumObject*>(ENUM)
+#define SBK_ENUM(ENUM) reinterpret_cast<SbkEnumObject *>(ENUM)
 #define SBK_TYPE_CHECK(o) (strcmp(Py_TYPE(Py_TYPE(o))->tp_name, "Shiboken.EnumType") == 0)
-typedef PyObject* (*enum_func)(PyObject*, PyObject*);
+typedef PyObject *(*enum_func)(PyObject *, PyObject *);
 
 extern "C"
 {
 
 struct SbkEnumTypePrivate
 {
-    SbkConverter** converterPtr;
-    SbkConverter* converter;
-    const char* cppName;
+    SbkConverter **converterPtr;
+    SbkConverter *converter;
+    const char *cppName;
 };
 
 struct SbkEnumType
@@ -72,10 +72,10 @@ struct SbkEnumObject
 {
     PyObject_HEAD
     long ob_value;
-    PyObject* ob_name;
+    PyObject *ob_name;
 };
 
-static PyObject* SbkEnumObject_repr(PyObject* self)
+static PyObject *SbkEnumObject_repr(PyObject *self)
 {
     const SbkEnumObject *enumObj = SBK_ENUM(self);
     if (enumObj->ob_name)
@@ -84,7 +84,7 @@ static PyObject* SbkEnumObject_repr(PyObject* self)
         return Shiboken::String::fromFormat("%s(%ld)", (Py_TYPE(self))->tp_name, enumObj->ob_value);
 }
 
-static PyObject* SbkEnumObject_name(PyObject* self, void*)
+static PyObject *SbkEnumObject_name(PyObject *self, void *)
 {
     SbkEnumObject *enum_self = SBK_ENUM(self);
 
@@ -95,27 +95,27 @@ static PyObject* SbkEnumObject_name(PyObject* self, void*)
     return enum_self->ob_name;
 }
 
-static PyObject* SbkEnum_tp_new(PyTypeObject *type, PyObject *args, PyObject *)
+static PyObject *SbkEnum_tp_new(PyTypeObject *type, PyObject *args, PyObject *)
 {
     long itemValue = 0;
     if (!PyArg_ParseTuple(args, "|l:__new__", &itemValue))
         return 0;
 
-    SbkEnumObject* self = PyObject_New(SbkEnumObject, type);
+    SbkEnumObject *self = PyObject_New(SbkEnumObject, type);
     if (!self)
         return 0;
     self->ob_value = itemValue;
-    PyObject* item = Shiboken::Enum::getEnumItemFromValue(type, itemValue);
+    PyObject *item = Shiboken::Enum::getEnumItemFromValue(type, itemValue);
     if (item) {
         self->ob_name = SbkEnumObject_name(item, 0);
         Py_XDECREF(item);
     } else {
         self->ob_name = 0;
     }
-    return reinterpret_cast<PyObject*>(self);
+    return reinterpret_cast<PyObject *>(self);
 }
 
-static PyObject* enum_op(enum_func f, PyObject *a, PyObject *b) {
+static PyObject *enum_op(enum_func f, PyObject *a, PyObject *b) {
     PyObject *valA = a;
     PyObject *valB = b;
     PyObject *result = nullptr;
@@ -160,54 +160,54 @@ static PyObject* enum_op(enum_func f, PyObject *a, PyObject *b) {
  *   Thus calling PyInt_FromLong() will result in calling PyLong_FromLong in
  *   Py3k.
  */
-static PyObject* enum_int(PyObject* v)
+static PyObject *enum_int(PyObject *v)
 {
     return PyInt_FromLong(SBK_ENUM(v)->ob_value);
 }
 
-static PyObject* enum_and(PyObject* self, PyObject* b)
+static PyObject *enum_and(PyObject *self, PyObject *b)
 {
     return enum_op(PyNumber_And, self, b);
 }
 
-static PyObject* enum_or(PyObject* self, PyObject* b)
+static PyObject *enum_or(PyObject *self, PyObject *b)
 {
 return enum_op(PyNumber_Or, self, b);
 }
 
-static PyObject* enum_xor(PyObject* self, PyObject* b)
+static PyObject *enum_xor(PyObject *self, PyObject *b)
 {
     return enum_op(PyNumber_Xor, self, b);
 }
 
-static int enum_bool(PyObject* v)
+static int enum_bool(PyObject *v)
 {
     return (SBK_ENUM(v)->ob_value > 0);
 }
 
-static PyObject* enum_add(PyObject* self, PyObject* v)
+static PyObject *enum_add(PyObject *self, PyObject *v)
 {
     return enum_op(PyNumber_Add, self, v);
 }
 
-static PyObject* enum_subtract(PyObject* self, PyObject* v)
+static PyObject *enum_subtract(PyObject *self, PyObject *v)
 {
     return enum_op(PyNumber_Subtract, self, v);
 }
 
-static PyObject* enum_multiply(PyObject* self, PyObject* v)
+static PyObject *enum_multiply(PyObject *self, PyObject *v)
 {
 return enum_op(PyNumber_Multiply, self, v);
 }
 
 #ifndef IS_PY3K
-static PyObject* enum_divide(PyObject* self, PyObject* v)
+static PyObject *enum_divide(PyObject *self, PyObject *v)
 {
     return enum_op(PyNumber_Divide, self, v);
 }
 #endif
 
-static PyObject* enum_richcompare(PyObject* self, PyObject* other, int op)
+static PyObject *enum_richcompare(PyObject *self, PyObject *other, int op)
 {
     PyObject *valA = self;
     PyObject *valB = other;
@@ -246,21 +246,21 @@ static PyObject* enum_richcompare(PyObject* self, PyObject* other, int op)
     return result;
 }
 
-static Py_hash_t enum_hash(PyObject* pyObj)
+static Py_hash_t enum_hash(PyObject *pyObj)
 {
-    Py_hash_t val = reinterpret_cast<SbkEnumObject*>(pyObj)->ob_value;
+    Py_hash_t val = reinterpret_cast<SbkEnumObject *>(pyObj)->ob_value;
     if (val == -1)
         val = -2;
     return val;
 }
 
 static PyGetSetDef SbkEnumGetSetList[] = {
-    {const_cast<char*>("name"), &SbkEnumObject_name, 0, 0, 0},
+    {const_cast<char *>("name"), &SbkEnumObject_name, nullptr, nullptr, nullptr},
     {0, 0, 0, 0, 0} // Sentinel
 };
 
-static void SbkEnumTypeDealloc(PyObject* pyObj);
-static PyObject* SbkEnumTypeTpNew(PyTypeObject* metatype, PyObject* args, PyObject* kwds);
+static void SbkEnumTypeDealloc(PyObject *pyObj);
+static PyObject *SbkEnumTypeTpNew(PyTypeObject *metatype, PyObject *args, PyObject *kwds);
 
 static PyType_Slot SbkEnumType_Type_slots[] = {
     {Py_tp_dealloc, (void *)SbkEnumTypeDealloc},
@@ -308,9 +308,9 @@ PyTypeObject *SbkEnumType_TypeF(void)
     return type;
 }
 
-void SbkEnumTypeDealloc(PyObject* pyObj)
+void SbkEnumTypeDealloc(PyObject *pyObj)
 {
-    SbkEnumType* sbkType = reinterpret_cast<SbkEnumType*>(pyObj);
+    auto sbkType = reinterpret_cast<SbkEnumType *>(pyObj);
 
     PyObject_GC_UnTrack(pyObj);
 #ifndef Py_LIMITED_API
@@ -324,13 +324,13 @@ void SbkEnumTypeDealloc(PyObject* pyObj)
 #endif
 }
 
-PyObject* SbkEnumTypeTpNew(PyTypeObject* metatype, PyObject* args, PyObject* kwds)
+PyObject *SbkEnumTypeTpNew(PyTypeObject *metatype, PyObject *args, PyObject *kwds)
 {
     newfunc type_new = reinterpret_cast<newfunc>(PyType_GetSlot(&PyType_Type, Py_tp_new));
-    SbkEnumType *newType = reinterpret_cast<SbkEnumType*>(type_new(metatype, args, kwds));
+    auto newType = reinterpret_cast<SbkEnumType *>(type_new(metatype, args, kwds));
     if (!newType)
         return 0;
-    return reinterpret_cast<PyObject*>(newType);
+    return reinterpret_cast<PyObject *>(newType);
 }
 
 } // extern "C"
@@ -340,15 +340,15 @@ namespace Shiboken {
 class DeclaredEnumTypes
 {
 public:
-    DeclaredEnumTypes(const DeclaredEnumTypes&) = delete;
-    DeclaredEnumTypes(DeclaredEnumTypes&&) = delete;
-    DeclaredEnumTypes& operator=(const DeclaredEnumTypes&) = delete;
-    DeclaredEnumTypes& operator=(DeclaredEnumTypes&&) = delete;
+    DeclaredEnumTypes(const DeclaredEnumTypes &) = delete;
+    DeclaredEnumTypes(DeclaredEnumTypes &&) = delete;
+    DeclaredEnumTypes &operator=(const DeclaredEnumTypes &) = delete;
+    DeclaredEnumTypes &operator=(DeclaredEnumTypes &&) = delete;
 
     DeclaredEnumTypes();
     ~DeclaredEnumTypes();
-    static DeclaredEnumTypes& instance();
-    void addEnumType(PyTypeObject* type);
+    static DeclaredEnumTypes &instance();
+    void addEnumType(PyTypeObject *type);
 
 private:
     std::vector<PyTypeObject *> m_enumTypes;
@@ -356,16 +356,16 @@ private:
 
 namespace Enum {
 
-bool check(PyObject* pyObj)
+bool check(PyObject *pyObj)
 {
     return Py_TYPE(Py_TYPE(pyObj)) == SbkEnumType_TypeF();
 }
 
-PyObject* getEnumItemFromValue(PyTypeObject* enumType, long itemValue)
+PyObject *getEnumItemFromValue(PyTypeObject *enumType, long itemValue)
 {
     PyObject *key, *value;
     Py_ssize_t pos = 0;
-    PyObject *values = PyDict_GetItemString(enumType->tp_dict, const_cast<char*>("values"));
+    PyObject *values = PyDict_GetItemString(enumType->tp_dict, const_cast<char *>("values"));
 
     while (PyDict_Next(values, &pos, &key, &value)) {
         SbkEnumObject *obj = reinterpret_cast<SbkEnumObject *>(value);
@@ -377,19 +377,19 @@ PyObject* getEnumItemFromValue(PyTypeObject* enumType, long itemValue)
     return 0;
 }
 
-static PyTypeObject* createEnum(const char* fullName, const char* cppName,
-                                const char* /* shortName */,
-                                PyTypeObject* flagsType)
+static PyTypeObject *createEnum(const char *fullName, const char *cppName,
+                                const char */* shortName */,
+                                PyTypeObject *flagsType)
 {
-    PyTypeObject* enumType = newTypeWithName(fullName, cppName, flagsType);
+    PyTypeObject *enumType = newTypeWithName(fullName, cppName, flagsType);
     if (PyType_Ready(enumType) < 0)
         return 0;
     return enumType;
 }
 
-PyTypeObject* createGlobalEnum(PyObject* module, const char* name, const char* fullName, const char* cppName, PyTypeObject* flagsType)
+PyTypeObject *createGlobalEnum(PyObject *module, const char *name, const char *fullName, const char *cppName, PyTypeObject *flagsType)
 {
-    PyTypeObject* enumType = createEnum(fullName, cppName, name, flagsType);
+    PyTypeObject *enumType = createEnum(fullName, cppName, name, flagsType);
     if (enumType && PyModule_AddObject(module, name, reinterpret_cast<PyObject *>(enumType)) < 0)
         return 0;
     if (flagsType && PyModule_AddObject(module, PepType_GetNameStr(flagsType),
@@ -398,9 +398,9 @@ PyTypeObject* createGlobalEnum(PyObject* module, const char* name, const char* f
     return enumType;
 }
 
-PyTypeObject* createScopedEnum(SbkObjectType* scope, const char* name, const char* fullName, const char* cppName, PyTypeObject* flagsType)
+PyTypeObject *createScopedEnum(SbkObjectType *scope, const char *name, const char *fullName, const char *cppName, PyTypeObject *flagsType)
 {
-    PyTypeObject* enumType = createEnum(fullName, cppName, name, flagsType);
+    PyTypeObject *enumType = createEnum(fullName, cppName, name, flagsType);
     if (enumType && PyDict_SetItemString(reinterpret_cast<PyTypeObject *>(scope)->tp_dict, name,
             reinterpret_cast<PyObject *>(enumType)) < 0)
         return nullptr;
@@ -411,18 +411,18 @@ PyTypeObject* createScopedEnum(SbkObjectType* scope, const char* name, const cha
     return enumType;
 }
 
-static PyObject* createEnumItem(PyTypeObject* enumType, const char* itemName, long itemValue)
+static PyObject *createEnumItem(PyTypeObject *enumType, const char *itemName, long itemValue)
 {
-    PyObject* enumItem = newItem(enumType, itemValue, itemName);
+    PyObject *enumItem = newItem(enumType, itemValue, itemName);
     if (PyDict_SetItemString(enumType->tp_dict, itemName, enumItem) < 0)
         return 0;
     Py_DECREF(enumItem);
     return enumItem;
 }
 
-bool createGlobalEnumItem(PyTypeObject* enumType, PyObject* module, const char* itemName, long itemValue)
+bool createGlobalEnumItem(PyTypeObject *enumType, PyObject *module, const char *itemName, long itemValue)
 {
-    PyObject* enumItem = createEnumItem(enumType, itemName, itemValue);
+    PyObject *enumItem = createEnumItem(enumType, itemName, itemValue);
     if (enumItem) {
         if (PyModule_AddObject(module, itemName, enumItem) < 0)
             return false;
@@ -449,7 +449,7 @@ bool createScopedEnumItem(PyTypeObject *enumType, PyTypeObject *scope,
     return false;
 }
 
-bool createScopedEnumItem(PyTypeObject* enumType, SbkObjectType* scope, const char* itemName, long itemValue)
+bool createScopedEnumItem(PyTypeObject *enumType, SbkObjectType *scope, const char *itemName, long itemValue)
 {
     return createScopedEnumItem(enumType, reinterpret_cast<PyTypeObject *>(scope), itemName, itemValue);
 }
@@ -458,12 +458,12 @@ PyObject *
 newItem(PyTypeObject *enumType, long itemValue, const char *itemName)
 {
     bool newValue = true;
-    SbkEnumObject* enumObj;
+    SbkEnumObject *enumObj;
     if (!itemName) {
-        enumObj = reinterpret_cast<SbkEnumObject*>(
+        enumObj = reinterpret_cast<SbkEnumObject *>(
                       getEnumItemFromValue(enumType, itemValue));
         if (enumObj)
-            return reinterpret_cast<PyObject*>(enumObj);
+            return reinterpret_cast<PyObject *>(enumObj);
 
         newValue = false;
     }
@@ -476,16 +476,16 @@ newItem(PyTypeObject *enumType, long itemValue, const char *itemName)
     enumObj->ob_value = itemValue;
 
     if (newValue) {
-        PyObject* values = PyDict_GetItemString(enumType->tp_dict, const_cast<char*>("values"));
+        PyObject *values = PyDict_GetItemString(enumType->tp_dict, const_cast<char *>("values"));
         if (!values) {
             values = PyDict_New();
-            PyDict_SetItemString(enumType->tp_dict, const_cast<char*>("values"), values);
+            PyDict_SetItemString(enumType->tp_dict, const_cast<char *>("values"), values);
             Py_DECREF(values); // ^ values still alive, because setitemstring incref it
         }
-        PyDict_SetItemString(values, itemName, reinterpret_cast<PyObject*>(enumObj));
+        PyDict_SetItemString(values, itemName, reinterpret_cast<PyObject *>(enumObj));
     }
 
-    return reinterpret_cast<PyObject*>(enumObj);
+    return reinterpret_cast<PyObject *>(enumObj);
 }
 
 static PyType_Slot SbkNewType_slots[] = {
@@ -581,8 +581,8 @@ copyNumberMethods(PyTypeObject *flagsType,
 }
 
 PyTypeObject *
-newTypeWithName(const char* name,
-                const char* cppName,
+newTypeWithName(const char *name,
+                const char *cppName,
                 PyTypeObject *numbers_fromFlag)
 {
     // Careful: PyType_FromSpec does not allocate the string.
@@ -606,40 +606,40 @@ newTypeWithName(const char* name,
     Py_TYPE(type) = SbkEnumType_TypeF();
     Py_INCREF(Py_TYPE(type));
 
-    SbkEnumType* enumType = reinterpret_cast<SbkEnumType*>(type);
+    SbkEnumType *enumType = reinterpret_cast<SbkEnumType *>(type);
     PepType_SETP(enumType)->cppName = cppName;
     PepType_SETP(enumType)->converterPtr = &PepType_SETP(enumType)->converter;
     DeclaredEnumTypes::instance().addEnumType(type);
     return type;
 }
 
-const char* getCppName(PyTypeObject* enumType)
+const char *getCppName(PyTypeObject *enumType)
 {
     assert(Py_TYPE(enumType) == SbkEnumType_TypeF());
-    return PepType_SETP(reinterpret_cast<SbkEnumType*>(enumType))->cppName;
+    return PepType_SETP(reinterpret_cast<SbkEnumType *>(enumType))->cppName;
 }
 
-long int getValue(PyObject* enumItem)
+long int getValue(PyObject *enumItem)
 {
     assert(Shiboken::Enum::check(enumItem));
-    return reinterpret_cast<SbkEnumObject*>(enumItem)->ob_value;
+    return reinterpret_cast<SbkEnumObject *>(enumItem)->ob_value;
 }
 
-void setTypeConverter(PyTypeObject* enumType, SbkConverter* converter)
+void setTypeConverter(PyTypeObject *enumType, SbkConverter *converter)
 {
-    //reinterpret_cast<SbkEnumType*>(enumType)->converter = converter;
+    //reinterpret_cast<SbkEnumType *>(enumType)->converter = converter;
     *PepType_SGTP(enumType)->converter = converter;
 }
 
-SbkConverter* getTypeConverter(PyTypeObject* enumType)
+SbkConverter *getTypeConverter(PyTypeObject *enumType)
 {
-    //return reinterpret_cast<SbkEnumType*>(enumType)->converter;
+    //return reinterpret_cast<SbkEnumType *>(enumType)->converter;
     return *PepType_SGTP(enumType)->converter;
 }
 
 } // namespace Enum
 
-DeclaredEnumTypes& DeclaredEnumTypes::instance()
+DeclaredEnumTypes &DeclaredEnumTypes::instance()
 {
     static DeclaredEnumTypes me;
     return me;
@@ -662,7 +662,7 @@ DeclaredEnumTypes::~DeclaredEnumTypes()
     m_enumTypes.clear();
 }
 
-void DeclaredEnumTypes::addEnumType(PyTypeObject* type)
+void DeclaredEnumTypes::addEnumType(PyTypeObject *type)
 {
     m_enumTypes.push_back(type);
 }