Cleanup pointer whitespace everywhere

Among other files to fix, basewrapper.(cpp|h) was full of uncommon
pointer whitespace. After fixing that, I could not resist and fixed
also libshiboken, generators, and after acceptance also PySide.

Most of the time, this regex worked fine

   (\w\w+)([*&]+)[ ]*(?![&*]*[/=])

replaced with

    \1 \2

but everything was checked by hand.

I did not touch the shiboken tests which are quite hairy.

It turned out that inserting a space between a variable and asterisk
causes a crash of shiboken, if the same line contains "CONVERTTOCPP".
This was temporarily fixed by adding another space after it.
Example..

sources/pyside2/PySide2/glue/qtcore.cpp line 977

    QByteArray * cppSelf = %CONVERTTOCPP[QByteArray *](obj);
    //XXX      /|\ omitting this space crashes shiboken!

cppgenerator.cpp was special, since it was modified to _generate_
correct pointer whitespace. This caused a few testcases to fail,
which had to be adjusted, again. This was difficult since some
internal names must end on "*" and generated code normally not.
Removing the last errors involved binary search on path sets...

Apply C++ 11 fixits to the changed code, where applicable.

Done-with: Friedemann.Kleint@qt.io
Task-number: PYSIDE-1037
Change-Id: I4ac070f52c5efb296c05d581c9d46e6f397a6c81
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Friedemann Kleint <Friedemann.Kleint@qt.io>
 
 

1 files changed, 39 insertions, 39 deletions

diff --git a/sources/shiboken2/libshiboken/sbkconverter.cpp b/sources/shiboken2/libshiboken/sbkconverter.cpp
index 4f6ebf65f..15afd5933 100644
--- a/sources/shiboken2/libshiboken/sbkconverter.cpp
+++ b/sources/shiboken2/libshiboken/sbkconverter.cpp
@@ -49,7 +49,7 @@
 
 #include <unordered_map>
 
-static SbkConverter** PrimitiveTypeConverters;
+static SbkConverter **PrimitiveTypeConverters;
 
 typedef std::unordered_map<std::string, SbkConverter *> ConvertersMap;
 static ConvertersMap converters;
@@ -61,11 +61,11 @@ void initArrayConverters();
 
 void init()
 {
-    static SbkConverter* primitiveTypeConverters[] = {
+    static SbkConverter *primitiveTypeConverters[] = {
         Primitive<PY_LONG_LONG>::createConverter(),
         Primitive<bool>::createConverter(),
         Primitive<char>::createConverter(),
-        Primitive<const char*>::createConverter(),
+        Primitive<const char *>::createConverter(),
         Primitive<double>::createConverter(),
         Primitive<float>::createConverter(),
         Primitive<int>::createConverter(),
@@ -112,7 +112,7 @@ SbkConverter *createConverterObject(PyTypeObject *type,
                                            CppToPythonFunc pointerToPythonFunc,
                                            CppToPythonFunc copyToPythonFunc)
 {
-    SbkConverter* converter = new SbkConverter;
+    auto converter = new SbkConverter;
     converter->pythonType = type;
     // PYSIDE-595: All types are heaptypes now, so provide reference.
     Py_XINCREF(type);
@@ -127,7 +127,7 @@ SbkConverter *createConverterObject(PyTypeObject *type,
     return converter;
 }
 
-SbkConverter* createConverter(SbkObjectType* type,
+SbkConverter *createConverter(SbkObjectType *type,
                               PythonToCppFunc toCppPointerConvFunc,
                               IsConvertibleToCppFunc toCppPointerCheckFunc,
                               CppToPythonFunc pointerToPythonFunc,
@@ -141,12 +141,12 @@ SbkConverter* createConverter(SbkObjectType* type,
     return converter;
 }
 
-SbkConverter* createConverter(PyTypeObject* type, CppToPythonFunc toPythonFunc)
+SbkConverter *createConverter(PyTypeObject *type, CppToPythonFunc toPythonFunc)
 {
     return createConverterObject(type, 0, 0, 0, toPythonFunc);
 }
 
-void deleteConverter(SbkConverter* converter)
+void deleteConverter(SbkConverter *converter)
 {
     if (converter) {
         converter->toCppConversions.clear();
@@ -154,37 +154,37 @@ void deleteConverter(SbkConverter* converter)
     }
 }
 
-void setCppPointerToPythonFunction(SbkConverter* converter, CppToPythonFunc pointerToPythonFunc)
+void setCppPointerToPythonFunction(SbkConverter *converter, CppToPythonFunc pointerToPythonFunc)
 {
     converter->pointerToPython = pointerToPythonFunc;
 }
 
-void setPythonToCppPointerFunctions(SbkConverter* converter,
+void setPythonToCppPointerFunctions(SbkConverter *converter,
                                     PythonToCppFunc toCppPointerConvFunc,
                                     IsConvertibleToCppFunc toCppPointerCheckFunc)
 {
     converter->toCppPointerConversion = std::make_pair(toCppPointerCheckFunc, toCppPointerConvFunc);
 }
 
-void addPythonToCppValueConversion(SbkConverter* converter,
+void addPythonToCppValueConversion(SbkConverter *converter,
                                    PythonToCppFunc pythonToCppFunc,
                                    IsConvertibleToCppFunc isConvertibleToCppFunc)
 {
     converter->toCppConversions.push_back(std::make_pair(isConvertibleToCppFunc, pythonToCppFunc));
 }
-void addPythonToCppValueConversion(SbkObjectType* type,
+void addPythonToCppValueConversion(SbkObjectType *type,
                                    PythonToCppFunc pythonToCppFunc,
                                    IsConvertibleToCppFunc isConvertibleToCppFunc)
 {
     addPythonToCppValueConversion(PepType_SOTP(type)->converter, pythonToCppFunc, isConvertibleToCppFunc);
 }
 
-PyObject* pointerToPython(SbkObjectType *type, const void *cppIn)
+PyObject *pointerToPython(SbkObjectType *type, const void *cppIn)
 {
     return pointerToPython(PepType_SOTP(type)->converter, cppIn);
 }
 
-PyObject* pointerToPython(const SbkConverter *converter, const void *cppIn)
+PyObject *pointerToPython(const SbkConverter *converter, const void *cppIn)
 {
     assert(converter);
     if (!cppIn)
@@ -197,12 +197,12 @@ PyObject* pointerToPython(const SbkConverter *converter, const void *cppIn)
     return converter->pointerToPython(cppIn);
 }
 
-PyObject* referenceToPython(SbkObjectType *type, const void *cppIn)
+PyObject *referenceToPython(SbkObjectType *type, const void *cppIn)
 {
     return referenceToPython(PepType_SOTP(type)->converter, cppIn);
 }
 
-PyObject* referenceToPython(const SbkConverter *converter, const void *cppIn)
+PyObject *referenceToPython(const SbkConverter *converter, const void *cppIn)
 {
     assert(cppIn);
 
@@ -219,7 +219,7 @@ PyObject* referenceToPython(const SbkConverter *converter, const void *cppIn)
     return converter->pointerToPython(cppIn);
 }
 
-static inline PyObject* CopyCppToPython(const SbkConverter *converter, const void *cppIn)
+static inline PyObject *CopyCppToPython(const SbkConverter *converter, const void *cppIn)
 {
     if (!cppIn)
         Py_RETURN_NONE;
@@ -230,11 +230,11 @@ static inline PyObject* CopyCppToPython(const SbkConverter *converter, const voi
     }
     return converter->copyToPython(cppIn);
 }
-PyObject* copyToPython(SbkObjectType *type, const void *cppIn)
+PyObject *copyToPython(SbkObjectType *type, const void *cppIn)
 {
     return CopyCppToPython(PepType_SOTP(type)->converter, cppIn);
 }
-PyObject* copyToPython(const SbkConverter *converter, const void *cppIn)
+PyObject *copyToPython(const SbkConverter *converter, const void *cppIn)
 {
     return CopyCppToPython(converter, cppIn);
 }
@@ -284,13 +284,13 @@ PythonToCppFunc isPythonToCppReferenceConvertible(SbkObjectType *type, PyObject
     return isPythonToCppValueConvertible(type, pyIn);
 }
 
-void nonePythonToCppNullPtr(PyObject*, void* cppOut)
+void nonePythonToCppNullPtr(PyObject *, void *cppOut)
 {
     assert(cppOut);
-    *((void**)cppOut) = 0;
+    *reinterpret_cast<void **>(cppOut) = nullptr;
 }
 
-void* cppPointer(PyTypeObject* desiredType, SbkObject* pyIn)
+void *cppPointer(PyTypeObject *desiredType, SbkObject *pyIn)
 {
     assert(pyIn);
     if (!ObjectType::checkType(desiredType))
@@ -301,7 +301,7 @@ void* cppPointer(PyTypeObject* desiredType, SbkObject* pyIn)
     return Object::cppPointer(pyIn, desiredType);
 }
 
-void pythonToCppPointer(SbkObjectType* type, PyObject* pyIn, void* cppOut)
+void pythonToCppPointer(SbkObjectType *type, PyObject *pyIn, void *cppOut)
 {
     assert(type);
     assert(pyIn);
@@ -365,14 +365,14 @@ bool isImplicitConversion(SbkObjectType *type, PythonToCppFunc toCppFunc)
     return toCppFunc != (*conv).second;
 }
 
-void registerConverterName(SbkConverter* converter , const char* typeName)
+void registerConverterName(SbkConverter *converter , const char *typeName)
 {
     ConvertersMap::iterator iter = converters.find(typeName);
     if (iter == converters.end())
         converters.insert(std::make_pair(typeName, converter));
 }
 
-SbkConverter* getConverter(const char* typeName)
+SbkConverter *getConverter(const char *typeName)
 {
     ConvertersMap::const_iterator it = converters.find(typeName);
     if (it != converters.end())
@@ -382,12 +382,12 @@ SbkConverter* getConverter(const char* typeName)
     return 0;
 }
 
-SbkConverter* primitiveTypeConverter(int index)
+SbkConverter *primitiveTypeConverter(int index)
 {
     return PrimitiveTypeConverters[index];
 }
 
-bool checkSequenceTypes(PyTypeObject* type, PyObject* pyIn)
+bool checkSequenceTypes(PyTypeObject *type, PyObject *pyIn)
 {
     assert(type);
     assert(pyIn);
@@ -422,7 +422,7 @@ bool convertibleSequenceTypes(SbkObjectType *type, PyObject *pyIn)
     return convertibleSequenceTypes(PepType_SOTP(type)->converter, pyIn);
 }
 
-bool checkPairTypes(PyTypeObject* firstType, PyTypeObject* secondType, PyObject* pyIn)
+bool checkPairTypes(PyTypeObject *firstType, PyTypeObject *secondType, PyObject *pyIn)
 {
     assert(firstType);
     assert(secondType);
@@ -466,7 +466,7 @@ bool convertiblePairTypes(const SbkConverter *firstConverter, bool firstCheckExa
     return true;
 }
 
-bool checkDictTypes(PyTypeObject* keyType, PyTypeObject* valueType, PyObject* pyIn)
+bool checkDictTypes(PyTypeObject *keyType, PyTypeObject *valueType, PyObject *pyIn)
 {
     assert(keyType);
     assert(valueType);
@@ -474,8 +474,8 @@ bool checkDictTypes(PyTypeObject* keyType, PyTypeObject* valueType, PyObject* py
     if (!PyDict_Check(pyIn))
         return false;
 
-    PyObject* key;
-    PyObject* value;
+    PyObject *key;
+    PyObject *value;
     Py_ssize_t pos = 0;
     while (PyDict_Next(pyIn, &pos, &key, &value)) {
         if (!PyObject_TypeCheck(key, keyType))
@@ -486,7 +486,7 @@ bool checkDictTypes(PyTypeObject* keyType, PyTypeObject* valueType, PyObject* py
     return true;
 }
 
-bool convertibleDictTypes(const SbkConverter * keyConverter, bool keyCheckExact, const SbkConverter *valueConverter,
+bool convertibleDictTypes(const SbkConverter *keyConverter, bool keyCheckExact, const SbkConverter *valueConverter,
                           bool valueCheckExact, PyObject *pyIn)
 {
     assert(keyConverter);
@@ -494,8 +494,8 @@ bool convertibleDictTypes(const SbkConverter * keyConverter, bool keyCheckExact,
     assert(pyIn);
     if (!PyDict_Check(pyIn))
         return false;
-    PyObject* key;
-    PyObject* value;
+    PyObject *key;
+    PyObject *value;
     Py_ssize_t pos = 0;
     while (PyDict_Next(pyIn, &pos, &key, &value)) {
         if (keyCheckExact) {
@@ -514,14 +514,14 @@ bool convertibleDictTypes(const SbkConverter * keyConverter, bool keyCheckExact,
     return true;
 }
 
-PyTypeObject* getPythonTypeObject(const SbkConverter *converter)
+PyTypeObject *getPythonTypeObject(const SbkConverter *converter)
 {
     if (converter)
         return converter->pythonType;
     return 0;
 }
 
-PyTypeObject* getPythonTypeObject(const char* typeName)
+PyTypeObject *getPythonTypeObject(const char *typeName)
 {
     return getPythonTypeObject(getConverter(typeName));
 }
@@ -545,7 +545,7 @@ bool pythonTypeIsWrapperType(const SbkConverter *converter)
     return converter->pointerToPython != 0;
 }
 
-SpecificConverter::SpecificConverter(const char* typeName)
+SpecificConverter::SpecificConverter(const char *typeName)
     : m_type(InvalidConversion)
 {
     m_converter = getConverter(typeName);
@@ -562,13 +562,13 @@ SpecificConverter::SpecificConverter(const char* typeName)
     }
 }
 
-PyObject* SpecificConverter::toPython(const void* cppIn)
+PyObject *SpecificConverter::toPython(const void *cppIn)
 {
     switch (m_type) {
     case CopyConversion:
         return copyToPython(m_converter, cppIn);
     case PointerConversion:
-        return pointerToPython(m_converter, *((const void**)cppIn));
+        return pointerToPython(m_converter, *((const void **)cppIn));
     case ReferenceConversion:
         return referenceToPython(m_converter, cppIn);
     default:
@@ -577,7 +577,7 @@ PyObject* SpecificConverter::toPython(const void* cppIn)
     return 0;
 }
 
-void SpecificConverter::toCpp(PyObject* pyIn, void* cppOut)
+void SpecificConverter::toCpp(PyObject *pyIn, void *cppOut)
 {
     switch (m_type) {
     case CopyConversion: