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, 15 insertions, 15 deletions

diff --git a/sources/pyside2/libpyside/pysidemetafunction.cpp b/sources/pyside2/libpyside/pysidemetafunction.cpp
index 4cdc7ec16..346117201 100644
--- a/sources/pyside2/libpyside/pysidemetafunction.cpp
+++ b/sources/pyside2/libpyside/pysidemetafunction.cpp
@@ -49,13 +49,13 @@ extern "C"
 
 struct PySideMetaFunctionPrivate
 {
-    QObject* qobject;
+    QObject *qobject;
     int methodIndex;
 };
 
 //methods
-static void         functionFree(void*);
-static PyObject*    functionCall(PyObject*, PyObject*, PyObject*);
+static void functionFree(void *);
+static PyObject *functionCall(PyObject *, PyObject *, PyObject *);
 
 static PyType_Slot PySideMetaFunctionType_slots[] = {
     {Py_tp_call, (void *)functionCall},
@@ -83,15 +83,15 @@ PyTypeObject *PySideMetaFunctionTypeF(void)
 
 void functionFree(void *self)
 {
-    PySideMetaFunction* function = reinterpret_cast<PySideMetaFunction*>(self);
+    PySideMetaFunction *function = reinterpret_cast<PySideMetaFunction *>(self);
     delete function->d;
 }
 
 PyObject *functionCall(PyObject *self, PyObject *args, PyObject * /* kw */)
 {
-    PySideMetaFunction* function = reinterpret_cast<PySideMetaFunction*>(self);
+    PySideMetaFunction *function = reinterpret_cast<PySideMetaFunction *>(self);
 
-    PyObject* retVal;
+    PyObject *retVal;
     if (!PySide::MetaFunction::call(function->d->qobject, function->d->methodIndex, args, &retVal))
         return 0;
     return retVal;
@@ -101,7 +101,7 @@ PyObject *functionCall(PyObject *self, PyObject *args, PyObject * /* kw */)
 
 namespace PySide { namespace MetaFunction {
 
-void init(PyObject* module)
+void init(PyObject *module)
 {
     if (PyType_Ready(PySideMetaFunctionTypeF()) < 0)
         return;
@@ -109,7 +109,7 @@ void init(PyObject* module)
     PyModule_AddObject(module, "MetaFunction", reinterpret_cast<PyObject *>(PySideMetaFunctionTypeF()));
 }
 
-PySideMetaFunction* newObject(QObject* source, int methodIndex)
+PySideMetaFunction *newObject(QObject *source, int methodIndex)
 {
     if (methodIndex >= source->metaObject()->methodCount())
         return 0;
@@ -117,7 +117,7 @@ PySideMetaFunction* newObject(QObject* source, int methodIndex)
     QMetaMethod method = source->metaObject()->method(methodIndex);
     if ((method.methodType() == QMetaMethod::Slot) ||
         (method.methodType() == QMetaMethod::Method)) {
-        PySideMetaFunction* function = PyObject_New(PySideMetaFunction, PySideMetaFunctionTypeF());
+        PySideMetaFunction *function = PyObject_New(PySideMetaFunction, PySideMetaFunctionTypeF());
         function->d = new PySideMetaFunctionPrivate();
         function->d->qobject = source;
         function->d->methodIndex = methodIndex;
@@ -126,7 +126,7 @@ PySideMetaFunction* newObject(QObject* source, int methodIndex)
     return 0;
 }
 
-bool call(QObject* self, int methodIndex, PyObject* args, PyObject** retVal)
+bool call(QObject *self, int methodIndex, PyObject *args, PyObject **retVal)
 {
 
     QMetaMethod method = self->metaObject()->method(methodIndex);
@@ -150,11 +150,11 @@ bool call(QObject* self, int methodIndex, PyObject* args, PyObject** retVal)
         return false;
     }
 
-    QVariant* methValues = new QVariant[numArgs];
-    void** methArgs = new void*[numArgs];
+    QVariant *methValues = new QVariant[numArgs];
+    void **methArgs = new void *[numArgs];
 
     // Prepare room for return type
-    const char* returnType = method.typeName();
+    const char *returnType = method.typeName();
     if (returnType && std::strcmp("void", returnType))
         argTypes.prepend(returnType);
     else
@@ -162,7 +162,7 @@ bool call(QObject* self, int methodIndex, PyObject* args, PyObject** retVal)
 
     int i;
     for (i = 0; i < numArgs; ++i) {
-        const QByteArray& typeName = argTypes[i];
+        const QByteArray &typeName = argTypes.at(i);
         // This must happen only when the method hasn't return type.
         if (typeName.isEmpty()) {
             methArgs[i] = 0;
@@ -204,7 +204,7 @@ bool call(QObject* self, int methodIndex, PyObject* args, PyObject** retVal)
 
         if (retVal) {
             if (methArgs[0]) {
-                static SbkConverter* qVariantTypeConverter = Shiboken::Conversions::getConverter("QVariant");
+                static SbkConverter *qVariantTypeConverter = Shiboken::Conversions::getConverter("QVariant");
                 Q_ASSERT(qVariantTypeConverter);
                 *retVal = Shiboken::Conversions::copyToPython(qVariantTypeConverter, &methValues[0]);
             } else {