Merge remote-tracking branch 'origin/5.12' into 5.13

Change-Id: Ia09beccd944e1276caa6aecbeb248e69917b7115

50 files changed, 1842 insertions, 1841 deletions

diff --git a/sources/shiboken2/ApiExtractor/abstractmetabuilder.cpp b/sources/shiboken2/ApiExtractor/abstractmetabuilder.cpp
index 170a8e1d4..d3a232546 100644
--- a/sources/shiboken2/ApiExtractor/abstractmetabuilder.cpp
+++ b/sources/shiboken2/ApiExtractor/abstractmetabuilder.cpp
@@ -62,7 +62,7 @@ static QString stripTemplateArgs(const QString &name)
     return pos < 0 ? name : name.left(pos);
 }
 
-static QStringList parseTemplateType(const QString& name) {
+static QStringList parseTemplateType(const QString &name) {
     int n = name.indexOf(QLatin1Char('<'));
     if (n <= 0) {
         // If name starts with '<' or contains an unmatched (i.e. any) '>', we
@@ -164,7 +164,7 @@ AbstractMetaEnumList AbstractMetaBuilder::globalEnums() const
 AbstractMetaEnum *AbstractMetaBuilder::findEnum(const TypeEntry *typeEntry) const
 {
     if (typeEntry && typeEntry->isFlags())
-        typeEntry = static_cast<const FlagsTypeEntry*>(typeEntry)->originator();
+        typeEntry = static_cast<const FlagsTypeEntry *>(typeEntry)->originator();
     return d->m_enums.value(typeEntry);
 }
 
@@ -179,7 +179,7 @@ void AbstractMetaBuilderPrivate::checkFunctionModifications()
         if (!entry->isComplex() || entry->codeGeneration() == TypeEntry::GenerateNothing)
             continue;
 
-        const ComplexTypeEntry* centry = static_cast<const ComplexTypeEntry*>(entry);
+        auto centry = static_cast<const ComplexTypeEntry *>(entry);
 
         if (!(centry->codeGeneration() & TypeEntry::GenerateTargetLang))
             continue;
@@ -226,7 +226,7 @@ void AbstractMetaBuilderPrivate::checkFunctionModifications()
 AbstractMetaClass *AbstractMetaBuilderPrivate::argumentToClass(const ArgumentModelItem &argument,
                                                                AbstractMetaClass *currentClass)
 {
-    AbstractMetaClass* returned = 0;
+    AbstractMetaClass *returned = nullptr;
     AbstractMetaType *type = translateType(argument->type(), currentClass);
     if (type && type->typeEntry() && type->typeEntry()->isComplex()) {
         const TypeEntry *entry = type->typeEntry();
@@ -306,7 +306,7 @@ void AbstractMetaBuilderPrivate::traverseOperatorFunction(const FunctionModelIte
             // Strip away first argument, since that is the containing object
             AbstractMetaArgumentList arguments = metaFunction->arguments();
             if (firstArgumentIsSelf || unaryOperator) {
-                AbstractMetaArgument* first = arguments.takeFirst();
+                AbstractMetaArgument *first = arguments.takeFirst();
                 if (!unaryOperator && first->type()->indirections())
                     metaFunction->setPointerOperator(true);
                 delete first;
@@ -317,7 +317,7 @@ void AbstractMetaBuilderPrivate::traverseOperatorFunction(const FunctionModelIte
                 // must be an reverse operator (e.g. CLASS::operator(TYPE, CLASS)).
                 // All operator overloads that operate over a class are already
                 // being added as member functions of that class by the API Extractor.
-                AbstractMetaArgument* last = arguments.takeLast();
+                AbstractMetaArgument *last = arguments.takeLast();
                 if (last->type()->indirections())
                     metaFunction->setPointerOperator(true);
                 delete last;
@@ -479,11 +479,11 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom)
         if (func->accessPolicy() != CodeModel::Public || func->name().startsWith(QLatin1String("operator")))
             continue;
 
-        FunctionTypeEntry* funcEntry = types->findFunctionType(func->name());
+        FunctionTypeEntry *funcEntry = types->findFunctionType(func->name());
         if (!funcEntry || !funcEntry->generateCode())
             continue;
 
-        AbstractMetaFunction* metaFunc = traverseFunction(func, nullptr);
+        AbstractMetaFunction *metaFunc = traverseFunction(func, nullptr);
         if (!metaFunc)
             continue;
 
@@ -551,11 +551,11 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom)
                     << QStringLiteral("type '%1' is specified in typesystem, but not defined. This could potentially lead to compilation errors.")
                                       .arg(entry->qualifiedCppName());
             } else if (entry->generateCode() && entry->type() == TypeEntry::FunctionType) {
-                const FunctionTypeEntry* fte = static_cast<const FunctionTypeEntry*>(entry);
+                auto fte = static_cast<const FunctionTypeEntry *>(entry);
                 const QStringList &signatures = fte->signatures();
                 for (const QString &signature : signatures) {
                     bool ok = false;
-                    for (AbstractMetaFunction* func : qAsConst(m_globalFunctions)) {
+                    for (AbstractMetaFunction *func : qAsConst(m_globalFunctions)) {
                         if (signature == func->minimalSignature()) {
                             ok = true;
                             break;
@@ -642,7 +642,7 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom)
     // sort all classes topologically
     m_metaClasses = classesTopologicalSorted(m_metaClasses);
 
-    for (AbstractMetaClass* cls : qAsConst(m_metaClasses)) {
+    for (AbstractMetaClass *cls : qAsConst(m_metaClasses)) {
 //         setupEquals(cls);
 //         setupComparable(cls);
         setupClonable(cls);
@@ -662,7 +662,7 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom)
     // Functions added to the module on the type system.
     const AddedFunctionList &globalUserFunctions = types->globalUserFunctions();
     for (const AddedFunctionPtr &addedFunc : globalUserFunctions) {
-        AbstractMetaFunction* metaFunc = traverseFunction(addedFunc);
+        AbstractMetaFunction *metaFunc = traverseFunction(addedFunc);
         if (Q_UNLIKELY(!metaFunc)) {
             qFatal("Unable to traverse added global function \"%s\".",
                    qPrintable(addedFunc->name()));
@@ -706,7 +706,7 @@ bool AbstractMetaBuilder::build(const QByteArrayList &arguments,
     return true;
 }
 
-void AbstractMetaBuilder::setLogDirectory(const QString& logDir)
+void AbstractMetaBuilder::setLogDirectory(const QString &logDir)
 {
     d->m_logDirectory = logDir;
     if (!d->m_logDirectory.endsWith(QDir::separator()))
@@ -725,7 +725,7 @@ void AbstractMetaBuilderPrivate::addAbstractMetaClass(AbstractMetaClass *cls,
     } else {
         m_metaClasses << cls;
         if (cls->typeEntry()->designatedInterface()) {
-            AbstractMetaClass* interface = cls->extractInterface();
+            AbstractMetaClass *interface = cls->extractInterface();
             m_metaClasses << interface;
             if (ReportHandler::isDebug(ReportHandler::SparseDebug))
                 qCDebug(lcShiboken) << QStringLiteral(" -> interface '%1'").arg(interface->name());
@@ -784,7 +784,7 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseNamespace(const FileModel
 
     const ClassList &classes = namespaceItem->classes();
     for (const ClassModelItem &cls : classes) {
-        AbstractMetaClass* mjc = traverseClass(dom, cls, metaClass);
+        AbstractMetaClass *mjc = traverseClass(dom, cls, metaClass);
         if (mjc) {
             metaClass->addInnerClass(mjc);
             mjc->setEnclosingClass(metaClass);
@@ -806,7 +806,7 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseNamespace(const FileModel
 
     // Traverse namespaces recursively
     for (const NamespaceModelItem &ni : namespaceItem->namespaces()) {
-        AbstractMetaClass* mjc = traverseNamespace(dom, ni);
+        AbstractMetaClass *mjc = traverseNamespace(dom, ni);
         if (mjc) {
             metaClass->addInnerClass(mjc);
             mjc->setEnclosingClass(metaClass);
@@ -827,7 +827,7 @@ AbstractMetaEnum *AbstractMetaBuilderPrivate::traverseEnum(const EnumModelItem &
 {
     QString qualifiedName = enumItem->qualifiedName().join(colonColon());
 
-    TypeEntry* typeEntry = 0;
+    TypeEntry *typeEntry = nullptr;
     if (enumItem->accessPolicy() == CodeModel::Private) {
         QStringList names = enumItem->qualifiedName();
         const QString &enumName = names.constLast();
@@ -841,7 +841,7 @@ AbstractMetaEnum *AbstractMetaBuilderPrivate::traverseEnum(const EnumModelItem &
     } else {
         QStringList tmpQualifiedName = enumItem->qualifiedName();
         const EnumeratorList &enums = enumItem->enumerators();
-        for (const EnumeratorModelItem& enumValue : enums) {
+        for (const EnumeratorModelItem &enumValue : enums) {
             tmpQualifiedName.removeLast();
             tmpQualifiedName << enumValue->name();
             qualifiedName = tmpQualifiedName.join(colonColon());
@@ -964,11 +964,11 @@ AbstractMetaEnum *AbstractMetaBuilderPrivate::traverseEnum(const EnumModelItem &
     return metaEnum;
 }
 
-AbstractMetaClass* AbstractMetaBuilderPrivate::traverseTypeDef(const FileModelItem &dom,
+AbstractMetaClass *AbstractMetaBuilderPrivate::traverseTypeDef(const FileModelItem &dom,
                                                                const TypeDefModelItem &typeDef,
                                                                AbstractMetaClass *currentClass)
 {
-    TypeDatabase* types = TypeDatabase::instance();
+    TypeDatabase *types = TypeDatabase::instance();
     QString className = stripTemplateArgs(typeDef->name());
 
     QString fullClassName = className;
@@ -981,7 +981,7 @@ AbstractMetaClass* AbstractMetaBuilderPrivate::traverseTypeDef(const FileModelIt
     // If this is the alias for a primitive type
     // we store the aliased type on the alias
     // TypeEntry
-    PrimitiveTypeEntry* ptype = types->findPrimitiveType(className);
+    PrimitiveTypeEntry *ptype = types->findPrimitiveType(className);
     if (ptype) {
         QString typeDefName = typeDef->type().qualifiedName()[0];
         ptype->setReferencedTypeEntry(types->findPrimitiveType(typeDefName));
@@ -990,7 +990,7 @@ AbstractMetaClass* AbstractMetaBuilderPrivate::traverseTypeDef(const FileModelIt
 
 
     // If we haven't specified anything for the typedef, then we don't care
-    ComplexTypeEntry* type = types->findComplexType(fullClassName);
+    ComplexTypeEntry *type = types->findComplexType(fullClassName);
     if (!type)
         return 0;
 
@@ -1038,7 +1038,7 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseClass(const FileModelItem
                           + colonColon() + fullClassName;
     }
 
-    ComplexTypeEntry* type = TypeDatabase::instance()->findComplexType(fullClassName);
+    ComplexTypeEntry *type = TypeDatabase::instance()->findComplexType(fullClassName);
     AbstractMetaBuilder::RejectReason reason = AbstractMetaBuilder::NoReason;
 
     if (TypeDatabase::instance()->isClassRejected(fullClassName)) {
@@ -1138,13 +1138,13 @@ void AbstractMetaBuilderPrivate::traverseScopeMembers(ScopeModelItem item,
 
     // Inner classes
     const ClassList &innerClasses = item->classes();
-    for (const ClassModelItem& ci : innerClasses)
+    for (const ClassModelItem &ci : innerClasses)
         traverseClassMembers(ci);
 }
 
 void AbstractMetaBuilderPrivate::traverseClassMembers(ClassModelItem item)
 {
-    AbstractMetaClass* metaClass = m_itemToClass.value(item.data());
+    AbstractMetaClass *metaClass = m_itemToClass.value(item.data());
     if (!metaClass)
         return;
 
@@ -1154,7 +1154,7 @@ void AbstractMetaBuilderPrivate::traverseClassMembers(ClassModelItem item)
 
 void AbstractMetaBuilderPrivate::traverseNamespaceMembers(NamespaceModelItem item)
 {
-    AbstractMetaClass* metaClass = m_itemToClass.value(item.data());
+    AbstractMetaClass *metaClass = m_itemToClass.value(item.data());
     if (!metaClass)
         return;
 
@@ -1240,7 +1240,7 @@ void AbstractMetaBuilderPrivate::traverseFields(const ScopeModelItem &scope_item
 {
     const VariableList &variables = scope_item->variables();
     for (const VariableModelItem &field : variables) {
-        AbstractMetaField* metaField = traverseField(field, metaClass);
+        AbstractMetaField *metaField = traverseField(field, metaClass);
 
         if (metaField && !metaField->isModifiedRemoved()) {
             metaField->setOriginalAttributes(metaField->attributes());
@@ -1269,7 +1269,7 @@ void AbstractMetaBuilderPrivate::fixReturnTypeOfConversionOperator(AbstractMetaF
     if (!metaFunction->isConversionOperator())
         return;
 
-    TypeDatabase* types = TypeDatabase::instance();
+    TypeDatabase *types = TypeDatabase::instance();
     static const QRegularExpression operatorRegExp(QStringLiteral("^operator "));
     Q_ASSERT(operatorRegExp.isValid());
     QString castTo = metaFunction->name().remove(operatorRegExp).trimmed();
@@ -1279,22 +1279,22 @@ void AbstractMetaBuilderPrivate::fixReturnTypeOfConversionOperator(AbstractMetaF
     if (castTo.startsWith(QLatin1String("const ")))
         castTo.remove(0, 6);
 
-    TypeEntry* retType = types->findType(castTo);
+    TypeEntry *retType = types->findType(castTo);
     if (!retType)
         return;
 
-    AbstractMetaType* metaType = new AbstractMetaType;
+    AbstractMetaType *metaType = new AbstractMetaType;
     metaType->setTypeEntry(retType);
     metaFunction->replaceType(metaType);
 }
 
-static bool _compareAbstractMetaTypes(const AbstractMetaType* type, const AbstractMetaType* other)
+static bool _compareAbstractMetaTypes(const AbstractMetaType *type, const AbstractMetaType *other)
 {
     return (type != nullptr) == (other != nullptr)
         && (type == nullptr || *type == *other);
 }
 
-static bool _compareAbstractMetaFunctions(const AbstractMetaFunction* func, const AbstractMetaFunction* other)
+static bool _compareAbstractMetaFunctions(const AbstractMetaFunction *func, const AbstractMetaFunction *other)
 {
     if (!func && !other)
         return true;
@@ -1377,14 +1377,14 @@ void AbstractMetaBuilderPrivate::traverseFunctions(ScopeModelItem scopeItem,
                 *metaFunction += AbstractMetaAttributes::PropertyReader;
                 metaFunction->setPropertySpec(read);
             }
-        } else if (QPropertySpec* write = metaClass->propertySpecForWrite(metaFunction->name())) {
+        } else if (QPropertySpec *write = metaClass->propertySpecForWrite(metaFunction->name())) {
             // Property setter must be in the form "void name(<type>)"
             // make sure the function was created with all aguments, some argument can be missing during the pareser because of errors on typesystem
             if ((!metaFunction->type()) && (metaFunction->arguments().size() == 1) && (write->type() == metaFunction->arguments().at(0)->type()->typeEntry())) {
                 *metaFunction += AbstractMetaAttributes::PropertyWriter;
                 metaFunction->setPropertySpec(write);
             }
-        } else if (QPropertySpec* reset = metaClass->propertySpecForReset(metaFunction->name())) {
+        } else if (QPropertySpec *reset = metaClass->propertySpecForReset(metaFunction->name())) {
             // Property resetter must be in the form "void name()"
             if ((!metaFunction->type()) && metaFunction->arguments().isEmpty()) {
                 *metaFunction += AbstractMetaAttributes::PropertyResetter;
diff --git a/sources/shiboken2/ApiExtractor/abstractmetalang.cpp b/sources/shiboken2/ApiExtractor/abstractmetalang.cpp
index 512efef58..7bcad504d 100644
--- a/sources/shiboken2/ApiExtractor/abstractmetalang.cpp
+++ b/sources/shiboken2/ApiExtractor/abstractmetalang.cpp
@@ -963,7 +963,7 @@ QString AbstractMetaFunction::debugSignature() const
     return result;
 }
 
-FunctionModificationList AbstractMetaFunction::modifications(const AbstractMetaClass* implementor) const
+FunctionModificationList AbstractMetaFunction::modifications(const AbstractMetaClass *implementor) const
 {
     if (!m_addedFunction.isNull())
         return m_addedFunction->modifications;
@@ -1042,7 +1042,7 @@ bool AbstractMetaFunction::hasSignatureModifications() const
     return false;
 }
 
-bool AbstractMetaFunction::isConversionOperator(const QString& funcName)
+bool AbstractMetaFunction::isConversionOperator(const QString &funcName)
 {
     static const QRegularExpression opRegEx(QStringLiteral("^operator(?:\\s+(?:const|volatile))?\\s+(\\w+\\s*)&?$"));
     Q_ASSERT(opRegEx.isValid());
@@ -1107,7 +1107,7 @@ bool AbstractMetaFunction::generateExceptionHandling() const
     return result;
 }
 
-bool AbstractMetaFunction::isOperatorOverload(const QString& funcName)
+bool AbstractMetaFunction::isOperatorOverload(const QString &funcName)
 {
     if (isConversionOperator(funcName))
         return true;
@@ -1679,7 +1679,7 @@ bool AbstractMetaClass::hasFunction(const QString &str) const
     return findFunction(str);
 }
 
-const AbstractMetaFunction* AbstractMetaClass::findFunction(const QString& functionName) const
+const AbstractMetaFunction *AbstractMetaClass::findFunction(const QString &functionName) const
 {
     return AbstractMetaFunction::find(m_functions, functionName);
 }
@@ -1732,7 +1732,7 @@ QPropertySpec *AbstractMetaClass::propertySpecForReset(const QString &name) cons
     return 0;
 }
 
-typedef QHash<const AbstractMetaClass*, AbstractMetaTypeList> AbstractMetaClassBaseTemplateInstantiationsMap;
+typedef QHash<const AbstractMetaClass *, AbstractMetaTypeList> AbstractMetaClassBaseTemplateInstantiationsMap;
 Q_GLOBAL_STATIC(AbstractMetaClassBaseTemplateInstantiationsMap, metaClassBaseTemplateInstantiations);
 
 bool AbstractMetaClass::hasTemplateBaseClassInstantiations() const
@@ -1749,7 +1749,7 @@ AbstractMetaTypeList AbstractMetaClass::templateBaseClassInstantiations() const
     return metaClassBaseTemplateInstantiations()->value(this);
 }
 
-void AbstractMetaClass::setTemplateBaseClassInstantiations(AbstractMetaTypeList& instantiations)
+void AbstractMetaClass::setTemplateBaseClassInstantiations(AbstractMetaTypeList &instantiations)
 {
     if (!templateBaseClass())
         return;
@@ -2018,20 +2018,20 @@ void AbstractMetaClass::addDefaultConstructor()
 
 void AbstractMetaClass::addDefaultCopyConstructor(bool isPrivate)
 {
-    AbstractMetaFunction* f = new AbstractMetaFunction;
+    auto f = new AbstractMetaFunction;
     f->setOriginalName(name());
     f->setName(name());
     f->setOwnerClass(this);
     f->setFunctionType(AbstractMetaFunction::CopyConstructorFunction);
     f->setDeclaringClass(this);
 
-    AbstractMetaType* argType = new AbstractMetaType;
+    auto argType = new AbstractMetaType;
     argType->setTypeEntry(typeEntry());
     argType->setReferenceType(LValueReference);
     argType->setConstant(true);
     argType->setTypeUsagePattern(AbstractMetaType::ValuePattern);
 
-    AbstractMetaArgument* arg = new AbstractMetaArgument;
+    auto arg = new AbstractMetaArgument;
     arg->setType(argType);
     arg->setName(name());
     f->addArgument(arg);
@@ -2647,9 +2647,9 @@ AbstractMetaClass *AbstractMetaClass::findClass(const AbstractMetaClassList &cla
 }
 
 AbstractMetaClass *AbstractMetaClass::findClass(const AbstractMetaClassList &classes,
-                                                const TypeEntry* typeEntry)
+                                                const TypeEntry *typeEntry)
 {
-    for (AbstractMetaClass* c : classes) {
+    for (AbstractMetaClass *c : classes) {
         if (c->typeEntry() == typeEntry)
             return c;
     }
diff --git a/sources/shiboken2/ApiExtractor/typedatabase.h b/sources/shiboken2/ApiExtractor/typedatabase.h
index 7f1b2a3fc..df614e644 100644
--- a/sources/shiboken2/ApiExtractor/typedatabase.h
+++ b/sources/shiboken2/ApiExtractor/typedatabase.h
@@ -72,30 +72,30 @@ public:
     * \param newInstance This parameter is useful just for unit testing, because singletons causes
     *                    too many side effects on unit testing.
     */
-    static TypeDatabase* instance(bool newInstance = false);
+    static TypeDatabase *instance(bool newInstance = false);
 
     static QString normalizedSignature(const QString &signature);
 
     QStringList requiredTargetImports() const;
 
-    void addRequiredTargetImport(const QString& moduleName);
+    void addRequiredTargetImport(const QString &moduleName);
 
-    void addTypesystemPath(const QString& typesystem_paths);
+    void addTypesystemPath(const QString &typesystem_paths);
 
-    IncludeList extraIncludes(const QString& className) const;
+    IncludeList extraIncludes(const QString &className) const;
 
-    PrimitiveTypeEntry* findPrimitiveType(const QString& name) const;
-    ComplexTypeEntry* findComplexType(const QString& name) const;
-    ObjectTypeEntry* findObjectType(const QString& name) const;
-    NamespaceTypeEntryList findNamespaceTypes(const QString& name) const;
-    NamespaceTypeEntry *findNamespaceType(const QString& name, const QString &fileName = QString()) const;
-    ContainerTypeEntry* findContainerType(const QString& name) const;
-    FunctionTypeEntry* findFunctionType(const QString& name) const;
+    PrimitiveTypeEntry *findPrimitiveType(const QString &name) const;
+    ComplexTypeEntry *findComplexType(const QString &name) const;
+    ObjectTypeEntry *findObjectType(const QString &name) const;
+    NamespaceTypeEntryList findNamespaceTypes(const QString &name) const;
+    NamespaceTypeEntry *findNamespaceType(const QString &name, const QString &fileName = QString()) const;
+    ContainerTypeEntry *findContainerType(const QString &name) const;
+    FunctionTypeEntry *findFunctionType(const QString &name) const;
     const TypeSystemTypeEntry *findTypeSystemType(const QString &name) const;
     const TypeSystemTypeEntry *defaultTypeSystemType() const;
     QString defaultPackageName() const;
 
-    TypeEntry* findType(const QString& name) const;
+    TypeEntry *findType(const QString &name) const;
 
     const TypeEntryMultiMap &entries() const { return m_entries; }
     const TypedefEntryMap  &typedefEntries() const { return m_typedefEntries; }
@@ -105,59 +105,59 @@ public:
     ContainerTypeEntryList containerTypes() const;
 
     void addRejection(const TypeRejection &);
-    bool isClassRejected(const QString& className, QString *reason = nullptr) const;
-    bool isFunctionRejected(const QString& className, const QString& functionName,
+    bool isClassRejected(const QString &className, QString *reason = nullptr) const;
+    bool isFunctionRejected(const QString &className, const QString &functionName,
                             QString *reason = nullptr) const;
-    bool isFieldRejected(const QString& className, const QString& fieldName,
+    bool isFieldRejected(const QString &className, const QString &fieldName,
                          QString *reason = nullptr) const;
-    bool isEnumRejected(const QString& className, const QString& enumName,
+    bool isEnumRejected(const QString &className, const QString &enumName,
                         QString *reason = nullptr) const;
-    bool isArgumentTypeRejected(const QString& className, const QString& typeName,
+    bool isArgumentTypeRejected(const QString &className, const QString &typeName,
                                 QString *reason = nullptr) const;
-    bool isReturnTypeRejected(const QString& className, const QString& typeName,
+    bool isReturnTypeRejected(const QString &className, const QString &typeName,
                               QString *reason = nullptr) const;
 
-    bool addType(TypeEntry* e, QString *errorMessage = nullptr);
+    bool addType(TypeEntry *e, QString *errorMessage = nullptr);
     void addTypeSystemType(const TypeSystemTypeEntry *e);
 
-    FlagsTypeEntry* findFlagsType(const QString& name) const;
-    void addFlagsType(FlagsTypeEntry* fte);
+    FlagsTypeEntry *findFlagsType(const QString &name) const;
+    void addFlagsType(FlagsTypeEntry *fte);
 
-    TemplateEntry *findTemplate(const QString& name) const { return m_templates[name]; }
+    TemplateEntry *findTemplate(const QString &name) const { return m_templates[name]; }
 
-    void addTemplate(TemplateEntry* t);
+    void addTemplate(TemplateEntry *t);
 
     AddedFunctionList globalUserFunctions() const { return m_globalUserFunctions; }
 
     void addGlobalUserFunctions(const AddedFunctionList &functions);
 
-    AddedFunctionList findGlobalUserFunctions(const QString& name) const;
+    AddedFunctionList findGlobalUserFunctions(const QString &name) const;
 
     void addGlobalUserFunctionModifications(const FunctionModificationList &functionModifications);
 
-    FunctionModificationList functionModifications(const QString& signature) const;
+    FunctionModificationList functionModifications(const QString &signature) const;
 
     void setSuppressWarnings(bool on) { m_suppressWarnings = on; }
 
     bool addSuppressedWarning(const QString &warning, QString *errorMessage);
 
-    bool isSuppressedWarning(const QString& s) const;
+    bool isSuppressedWarning(const QString &s) const;
 
     static QString globalNamespaceClassName(const TypeEntry *te);
 
     bool parseFile(const QString &filename, bool generate = true);
     bool parseFile(const QString &filename, const QString &currentPath, bool generate);
 
-    bool parseFile(QIODevice* device, bool generate = true);
+    bool parseFile(QIODevice *device, bool generate = true);
 
-    static bool setApiVersion(const QString& package, const QString& version);
+    static bool setApiVersion(const QString &package, const QString &version);
     static void clearApiVersions();
 
     static bool checkApiVersion(const QString &package, const QVersionNumber &version);
 
     bool hasDroppedTypeEntries() const { return !m_dropTypeEntries.isEmpty(); }
 
-    bool shouldDropTypeEntry(const QString& fullTypeName) const;
+    bool shouldDropTypeEntry(const QString &fullTypeName) const;
 
     void setDropTypeEntries(QStringList dropTypeEntries);
 
diff --git a/sources/shiboken2/ApiExtractor/typesystem.cpp b/sources/shiboken2/ApiExtractor/typesystem.cpp
index 344313e87..b4c94695d 100644
--- a/sources/shiboken2/ApiExtractor/typesystem.cpp
+++ b/sources/shiboken2/ApiExtractor/typesystem.cpp
@@ -3384,7 +3384,7 @@ AddedFunction::AddedFunction(QString signature, const QString &returnType) :
             if (!arg.name.isEmpty())
                 m_arguments.append({argumentName, arg});
             // end of parameters...
-            if (signature[endPos] == QLatin1Char(')'))
+            if (endPos >= signatureLength || signature[endPos] == QLatin1Char(')'))
                 break;
         }
         // is const?
diff --git a/sources/shiboken2/generator/generator.cpp b/sources/shiboken2/generator/generator.cpp
index 49064a6a5..6da9fd933 100644
--- a/sources/shiboken2/generator/generator.cpp
+++ b/sources/shiboken2/generator/generator.cpp
@@ -153,7 +153,7 @@ QString DefaultValue::constructorParameter() const
 
 struct Generator::GeneratorPrivate
 {
-    const ApiExtractor* apiextractor = nullptr;
+    const ApiExtractor *apiextractor = nullptr;
     QString outDir;
     // License comment
     QString licenseComment;
@@ -174,7 +174,7 @@ Generator::~Generator()
     delete m_d;
 }
 
-bool Generator::setup(const ApiExtractor& extractor)
+bool Generator::setup(const ApiExtractor &extractor)
 {
     m_d->apiextractor = &extractor;
     const auto moduleEntry = TypeDatabase::instance()->defaultTypeSystemType();
@@ -188,7 +188,7 @@ bool Generator::setup(const ApiExtractor& extractor)
     return doSetup();
 }
 
-QString Generator::getSimplifiedContainerTypeName(const AbstractMetaType* type)
+QString Generator::getSimplifiedContainerTypeName(const AbstractMetaType *type)
 {
     const QString signature = type->cppSignature();
     if (!type->typeEntry()->isContainer() && !type->typeEntry()->isSmartPointer())
@@ -217,7 +217,7 @@ void Generator::addInstantiatedContainersAndSmartPointers(const AbstractMetaType
     if (!type)
         return;
     const AbstractMetaTypeList &instantiations = type->instantiations();
-    for (const AbstractMetaType* t : instantiations)
+    for (const AbstractMetaType *t : instantiations)
         addInstantiatedContainersAndSmartPointers(t, context);
     const auto typeEntry = type->typeEntry();
     const bool isContainer = typeEntry->isContainer();
@@ -298,7 +298,7 @@ QVector<const AbstractMetaType *> Generator::instantiatedContainers() const
     return m_d->instantiatedContainers;
 }
 
-QVector<const AbstractMetaType*> Generator::instantiatedSmartPointers() const
+QVector<const AbstractMetaType *> Generator::instantiatedSmartPointers() const
 {
     return m_d->instantiatedSmartPointers;
 }
@@ -343,12 +343,12 @@ ContainerTypeEntryList Generator::containerTypes() const
     return m_d->apiextractor->containerTypes();
 }
 
-const AbstractMetaEnum* Generator::findAbstractMetaEnum(const TypeEntry* typeEntry) const
+const AbstractMetaEnum *Generator::findAbstractMetaEnum(const TypeEntry *typeEntry) const
 {
     return m_d->apiextractor->findAbstractMetaEnum(typeEntry);
 }
 
-const AbstractMetaEnum* Generator::findAbstractMetaEnum(const AbstractMetaType* metaType) const
+const AbstractMetaEnum *Generator::findAbstractMetaEnum(const AbstractMetaType *metaType) const
 {
     return m_d->apiextractor->findAbstractMetaEnum(metaType->typeEntry());
 }
@@ -358,7 +358,7 @@ QString Generator::licenseComment() const
     return m_d->licenseComment;
 }
 
-void Generator::setLicenseComment(const QString& licenseComment)
+void Generator::setLicenseComment(const QString &licenseComment)
 {
     m_d->licenseComment = licenseComment;
 }
@@ -440,12 +440,12 @@ bool Generator::generate()
     return finishGeneration();
 }
 
-bool Generator::shouldGenerateTypeEntry(const TypeEntry* type) const
+bool Generator::shouldGenerateTypeEntry(const TypeEntry *type) const
 {
     return type->codeGeneration() & TypeEntry::GenerateTargetLang;
 }
 
-bool Generator::shouldGenerate(const AbstractMetaClass* metaClass) const
+bool Generator::shouldGenerate(const AbstractMetaClass *metaClass) const
 {
     return shouldGenerateTypeEntry(metaClass->typeEntry());
 }
@@ -490,7 +490,7 @@ void Generator::replaceTemplateVariables(QString &code, const AbstractMetaFuncti
     }
 }
 
-QTextStream& formatCode(QTextStream &s, const QString& code, Indentor &indentor)
+QTextStream &formatCode(QTextStream &s, const QString &code, Indentor &indentor)
 {
     // detect number of spaces before the first character
     const QStringList lst(code.split(QLatin1Char('\n')));
@@ -527,7 +527,7 @@ QTextStream& formatCode(QTextStream &s, const QString& code, Indentor &indentor)
     return s;
 }
 
-AbstractMetaFunctionList Generator::implicitConversions(const TypeEntry* type) const
+AbstractMetaFunctionList Generator::implicitConversions(const TypeEntry *type) const
 {
     if (type->isValue()) {
         if (const AbstractMetaClass *metaClass = AbstractMetaClass::findClass(classes(), type))
@@ -536,52 +536,52 @@ AbstractMetaFunctionList Generator::implicitConversions(const TypeEntry* type) c
     return AbstractMetaFunctionList();
 }
 
-AbstractMetaFunctionList Generator::implicitConversions(const AbstractMetaType* metaType) const
+AbstractMetaFunctionList Generator::implicitConversions(const AbstractMetaType *metaType) const
 {
     return implicitConversions(metaType->typeEntry());
 }
 
-bool Generator::isObjectType(const TypeEntry* type)
+bool Generator::isObjectType(const TypeEntry *type)
 {
     if (type->isComplex())
         return Generator::isObjectType(static_cast<const ComplexTypeEntry *>(type));
     return type->isObject();
 }
-bool Generator::isObjectType(const ComplexTypeEntry* type)
+bool Generator::isObjectType(const ComplexTypeEntry *type)
 {
     return type->isObject();
 }
-bool Generator::isObjectType(const AbstractMetaClass* metaClass)
+bool Generator::isObjectType(const AbstractMetaClass *metaClass)
 {
     return Generator::isObjectType(metaClass->typeEntry());
 }
-bool Generator::isObjectType(const AbstractMetaType* metaType)
+bool Generator::isObjectType(const AbstractMetaType *metaType)
 {
     return isObjectType(metaType->typeEntry());
 }
 
-bool Generator::isPointer(const AbstractMetaType* type)
+bool Generator::isPointer(const AbstractMetaType *type)
 {
     return type->indirections() > 0
             || type->isNativePointer()
             || type->isValuePointer();
 }
 
-bool Generator::isCString(const AbstractMetaType* type)
+bool Generator::isCString(const AbstractMetaType *type)
 {
     return type->isNativePointer()
             && type->indirections() == 1
             && type->name() == QLatin1String("char");
 }
 
-bool Generator::isVoidPointer(const AbstractMetaType* type)
+bool Generator::isVoidPointer(const AbstractMetaType *type)
 {
     return type->isNativePointer()
             && type->indirections() == 1
             && type->name() == QLatin1String("void");
 }
 
-QString Generator::getFullTypeName(const TypeEntry* type) const
+QString Generator::getFullTypeName(const TypeEntry *type) const
 {
     QString result = type->qualifiedCppName();
     if (type->isArray())
@@ -591,7 +591,7 @@ QString Generator::getFullTypeName(const TypeEntry* type) const
     return result;
 }
 
-QString Generator::getFullTypeName(const AbstractMetaType* type) const
+QString Generator::getFullTypeName(const AbstractMetaType *type) const
 {
     if (isCString(type))
         return QLatin1String("const char*");
@@ -607,12 +607,12 @@ QString Generator::getFullTypeName(const AbstractMetaType* type) const
     return typeName + QString::fromLatin1("*").repeated(type->indirections());
 }
 
-QString Generator::getFullTypeName(const AbstractMetaClass* metaClass) const
+QString Generator::getFullTypeName(const AbstractMetaClass *metaClass) const
 {
     return QLatin1String("::") + metaClass->qualifiedCppName();
 }
 
-QString Generator::getFullTypeNameWithoutModifiers(const AbstractMetaType* type) const
+QString Generator::getFullTypeNameWithoutModifiers(const AbstractMetaType *type) const
 {
     if (isCString(type))
         return QLatin1String("const char*");
@@ -638,7 +638,7 @@ QString Generator::getFullTypeNameWithoutModifiers(const AbstractMetaType* type)
     return QLatin1String("::") + typeName;
 }
 
-DefaultValue Generator::minimalConstructor(const AbstractMetaType* type) const
+DefaultValue Generator::minimalConstructor(const AbstractMetaType *type) const
 {
     if (!type || (type->referenceType() ==  LValueReference && Generator::isObjectType(type)))
         return DefaultValue(DefaultValue::Error);
@@ -664,7 +664,7 @@ DefaultValue Generator::minimalConstructor(const AbstractMetaType* type) const
         return DefaultValue(DefaultValue::Pointer, QLatin1String("::") + type->typeEntry()->qualifiedCppName());
 
     if (type->typeEntry()->isComplex()) {
-        const ComplexTypeEntry* cType = static_cast<const ComplexTypeEntry*>(type->typeEntry());
+        auto cType = static_cast<const ComplexTypeEntry *>(type->typeEntry());
         if (cType->hasDefaultConstructor())
             return DefaultValue(DefaultValue::Custom, cType->defaultConstructor());
         auto ctor = minimalConstructor(AbstractMetaClass::findClass(classes(), cType));
@@ -679,7 +679,7 @@ DefaultValue Generator::minimalConstructor(const AbstractMetaType* type) const
     return minimalConstructor(type->typeEntry());
 }
 
-DefaultValue Generator::minimalConstructor(const TypeEntry* type) const
+DefaultValue Generator::minimalConstructor(const TypeEntry *type) const
 {
     if (!type)
         return DefaultValue(DefaultValue::Error);
@@ -706,7 +706,7 @@ DefaultValue Generator::minimalConstructor(const TypeEntry* type) const
     }
 
     if (type->isPrimitive()) {
-        QString ctor = static_cast<const PrimitiveTypeEntry*>(type)->defaultConstructor();
+        QString ctor = static_cast<const PrimitiveTypeEntry *>(type)->defaultConstructor();
         // If a non-C++ (i.e. defined by the user) primitive type does not have
         // a default constructor defined by the user, the empty constructor is
         // heuristically returned. If this is wrong the build of the generated
@@ -729,12 +729,12 @@ static QString constructorCall(const QString &qualifiedCppName, const QStringLis
         + args.join(QLatin1String(", ")) + QLatin1Char(')');
 }
 
-DefaultValue Generator::minimalConstructor(const AbstractMetaClass* metaClass) const
+DefaultValue Generator::minimalConstructor(const AbstractMetaClass *metaClass) const
 {
     if (!metaClass)
         return DefaultValue(DefaultValue::Error);
 
-    const ComplexTypeEntry* cType = static_cast<const ComplexTypeEntry*>(metaClass->typeEntry());
+    auto cType = static_cast<const ComplexTypeEntry *>(metaClass->typeEntry());
     if (cType->hasDefaultConstructor())
         return DefaultValue(DefaultValue::Custom, cType->defaultConstructor());
 
@@ -845,7 +845,7 @@ QString Generator::translateType(const AbstractMetaType *cType,
                     s = s.remove(index, constLen);
             }
         } else if (options & Generator::ExcludeConst || options & Generator::ExcludeReference) {
-            AbstractMetaType* copyType = cType->copy();
+            AbstractMetaType *copyType = cType->copy();
 
             if (options & Generator::ExcludeConst)
                 copyType->setConstant(false);
@@ -866,7 +866,7 @@ QString Generator::translateType(const AbstractMetaType *cType,
 }
 
 
-QString Generator::subDirectoryForClass(const AbstractMetaClass* clazz) const
+QString Generator::subDirectoryForClass(const AbstractMetaClass *clazz) const
 {
     return subDirectoryForPackage(clazz->package());
 }
@@ -880,10 +880,10 @@ QString Generator::subDirectoryForPackage(QString packageNameIn) const
 }
 
 template<typename T>
-static QString getClassTargetFullName_(const T* t, bool includePackageName)
+static QString getClassTargetFullName_(const T *t, bool includePackageName)
 {
     QString name = t->name();
-    const AbstractMetaClass* context = t->enclosingClass();
+    const AbstractMetaClass *context = t->enclosingClass();
     while (context) {
         name.prepend(QLatin1Char('.'));
         name.prepend(context->name());
@@ -896,12 +896,12 @@ static QString getClassTargetFullName_(const T* t, bool includePackageName)
     return name;
 }
 
-QString getClassTargetFullName(const AbstractMetaClass* metaClass, bool includePackageName)
+QString getClassTargetFullName(const AbstractMetaClass *metaClass, bool includePackageName)
 {
     return getClassTargetFullName_(metaClass, includePackageName);
 }
 
-QString getClassTargetFullName(const AbstractMetaEnum* metaEnum, bool includePackageName)
+QString getClassTargetFullName(const AbstractMetaEnum *metaEnum, bool includePackageName)
 {
     return getClassTargetFullName_(metaEnum, includePackageName);
 }
diff --git a/sources/shiboken2/generator/generator.h b/sources/shiboken2/generator/generator.h
index 04840427f..b7b002ea6 100644
--- a/sources/shiboken2/generator/generator.h
+++ b/sources/shiboken2/generator/generator.h
@@ -56,11 +56,11 @@ QT_END_NAMESPACE
 class PrimitiveTypeEntry;
 class ContainerTypeEntry;
 
-QTextStream& formatCode(QTextStream &s, const QString& code, Indentor &indentor);
+QTextStream &formatCode(QTextStream &s, const QString &code, Indentor &indentor);
 void verifyDirectoryFor(const QString &file);
 
-QString getClassTargetFullName(const AbstractMetaClass* metaClass, bool includePackageName = true);
-QString getClassTargetFullName(const AbstractMetaEnum* metaEnum, bool includePackageName = true);
+QString getClassTargetFullName(const AbstractMetaClass *metaClass, bool includePackageName = true);
+QString getClassTargetFullName(const AbstractMetaEnum *metaEnum, bool includePackageName = true);
 QString getClassTargetFullName(const AbstractMetaType *metaType, bool includePackageName = true);
 QString getFilteredCppSignatureString(QString signature);
 
@@ -202,7 +202,7 @@ public:
     Generator();
     virtual ~Generator();
 
-    bool setup(const ApiExtractor& extractor);
+    bool setup(const ApiExtractor &extractor);
 
     virtual OptionDescriptions options() const;
     virtual bool handleOption(const QString &key, const QString &value);
@@ -231,7 +231,7 @@ public:
     void setLicenseComment(const QString &licenseComment);
 
     /// Returns the generator's name. Used for cosmetic purposes.
-    virtual const char* name() const = 0;
+    virtual const char *name() const = 0;
 
     /**
      *  Retrieves the name of the currently processed module.
@@ -250,24 +250,24 @@ public:
      *   \param type a TypeEntry that is expected to be a value-type
      *   \return a list of constructors that could be used as implicit converters
      */
-    AbstractMetaFunctionList implicitConversions(const TypeEntry* type) const;
+    AbstractMetaFunctionList implicitConversions(const TypeEntry *type) const;
 
-    /// Convenience function for implicitConversions(const TypeEntry* type).
-    AbstractMetaFunctionList implicitConversions(const AbstractMetaType* metaType) const;
+    /// Convenience function for implicitConversions(const TypeEntry *type).
+    AbstractMetaFunctionList implicitConversions(const AbstractMetaType *metaType) const;
 
     /// Check if type is a pointer.
-    static bool isPointer(const AbstractMetaType* type);
+    static bool isPointer(const AbstractMetaType *type);
 
     /// Tells if the type or class is an Object (or QObject) Type.
-    static bool isObjectType(const TypeEntry* type);
-    static bool isObjectType(const ComplexTypeEntry* type);
-    static bool isObjectType(const AbstractMetaType* metaType);
-    static bool isObjectType(const AbstractMetaClass* metaClass);
+    static bool isObjectType(const TypeEntry *type);
+    static bool isObjectType(const ComplexTypeEntry *type);
+    static bool isObjectType(const AbstractMetaType *metaType);
+    static bool isObjectType(const AbstractMetaClass *metaClass);
 
-    /// Returns true if the type is a C string (const char*).
-    static bool isCString(const AbstractMetaType* type);
+    /// Returns true if the type is a C string (const char *).
+    static bool isCString(const AbstractMetaType *type);
     /// Returns true if the type is a void pointer.
-    static bool isVoidPointer(const AbstractMetaType* type);
+    static bool isVoidPointer(const AbstractMetaType *type);
 
 protected:
     /// Returns the classes, topologically ordered, used to generate the binding code.
@@ -289,10 +289,10 @@ protected:
     ContainerTypeEntryList containerTypes() const;
 
     /// Returns an AbstractMetaEnum for a given TypeEntry that is an EnumTypeEntry, or nullptr if not found.
-    const AbstractMetaEnum* findAbstractMetaEnum(const TypeEntry* typeEntry) const;
+    const AbstractMetaEnum *findAbstractMetaEnum(const TypeEntry *typeEntry) const;
 
     /// Returns an AbstractMetaEnum for a given AbstractMetaType that holds an EnumTypeEntry, or nullptr if not found.
-    const AbstractMetaEnum* findAbstractMetaEnum(const AbstractMetaType* metaType) const;
+    const AbstractMetaEnum *findAbstractMetaEnum(const AbstractMetaType *metaType) const;
 
     /// Generates a file for given AbstractMetaClass or AbstractMetaType (smart pointer case).
     bool generateFileForContext(GeneratorContext &context);
@@ -302,13 +302,13 @@ protected:
                                            const AbstractMetaClass *smartPointerClass) const;
 
     /// Returns true if the generator should generate any code for the TypeEntry.
-    bool shouldGenerateTypeEntry(const TypeEntry*) const;
+    bool shouldGenerateTypeEntry(const TypeEntry *) const;
 
     /// Returns true if the generator should generate any code for the AbstractMetaClass.
     virtual bool shouldGenerate(const AbstractMetaClass *) const;
 
     /// Returns the subdirectory used to write the binding code of an AbstractMetaClass.
-    virtual QString subDirectoryForClass(const AbstractMetaClass* clazz) const;
+    virtual QString subDirectoryForClass(const AbstractMetaClass *clazz) const;
 
     /**
     *   Translate metatypes to binding source format.
@@ -344,25 +344,25 @@ protected:
     QString packageName() const;
 
     // Returns the full name of the type.
-    QString getFullTypeName(const TypeEntry* type) const;
-    QString getFullTypeName(const AbstractMetaType* type) const;
-    QString getFullTypeName(const AbstractMetaClass* metaClass) const;
+    QString getFullTypeName(const TypeEntry *type) const;
+    QString getFullTypeName(const AbstractMetaType *type) const;
+    QString getFullTypeName(const AbstractMetaClass *metaClass) const;
 
     /**
      *  Returns the full qualified C++ name for an AbstractMetaType, but removing modifiers
      *  as 'const', '&', and '*' (except if the class is not derived from a template).
      *  This is useful for instantiated templates.
      */
-    QString getFullTypeNameWithoutModifiers(const AbstractMetaType* type) const;
+    QString getFullTypeNameWithoutModifiers(const AbstractMetaType *type) const;
 
     /**
      *   Tries to build a minimal constructor for the type.
      *   It will check first for a user defined default constructor.
      *   Returns a null string if it fails.
      */
-    DefaultValue minimalConstructor(const TypeEntry* type) const;
-    DefaultValue minimalConstructor(const AbstractMetaType* type) const;
-    DefaultValue minimalConstructor(const AbstractMetaClass* metaClass) const;
+    DefaultValue minimalConstructor(const TypeEntry *type) const;
+    DefaultValue minimalConstructor(const AbstractMetaType *type) const;
+    DefaultValue minimalConstructor(const AbstractMetaClass *metaClass) const;
 
     /**
      *   Returns the file name used to write the binding code of an AbstractMetaClass/Type.
@@ -382,7 +382,7 @@ protected:
      *   \param  s   text stream to write the generated output
      *   \param  metaClass  the class that should be generated
      */
-    virtual void generateClass(QTextStream& s, GeneratorContext &classContext) = 0;
+    virtual void generateClass(QTextStream &s, GeneratorContext &classContext) = 0;
     virtual bool finishGeneration() = 0;
 
     /**
@@ -396,8 +396,8 @@ protected:
     */
     virtual QString subDirectoryForPackage(QString packageName = QString()) const;
 
-    QVector<const AbstractMetaType*> instantiatedContainers() const;
-    QVector<const AbstractMetaType*> instantiatedSmartPointers() const;
+    QVector<const AbstractMetaType *> instantiatedContainers() const;
+    QVector<const AbstractMetaType *> instantiatedSmartPointers() const;
 
     static QString getSimplifiedContainerTypeName(const AbstractMetaType *type);
     void addInstantiatedContainersAndSmartPointers(const AbstractMetaType *type,
@@ -407,8 +407,8 @@ private:
     bool useEnumAsIntForProtectedHack(const AbstractMetaType *cType) const;
 
     struct GeneratorPrivate;
-    GeneratorPrivate* m_d;
-    void collectInstantiatedContainersAndSmartPointers(const AbstractMetaFunction* func);
+    GeneratorPrivate *m_d;
+    void collectInstantiatedContainersAndSmartPointers(const AbstractMetaFunction *func);
     void collectInstantiatedContainersAndSmartPointers(const AbstractMetaClass *metaClass);
     void collectInstantiatedContainersAndSmartPointers();
 };
diff --git a/sources/shiboken2/generator/main.cpp b/sources/shiboken2/generator/main.cpp
index ac576d657..4c84e0d47 100644
--- a/sources/shiboken2/generator/main.cpp
+++ b/sources/shiboken2/generator/main.cpp
@@ -63,7 +63,7 @@ typedef QMap<QString, QString> CommandArgumentMap;
 
 typedef Generator::OptionDescriptions OptionDescriptions;
 
-static void printOptions(QTextStream& s, const OptionDescriptions& options)
+static void printOptions(QTextStream &s, const OptionDescriptions &options)
 {
     s.setFieldAlignment(QTextStream::AlignLeft);
     for (const auto &od : options) {
@@ -82,7 +82,7 @@ static void printOptions(QTextStream& s, const OptionDescriptions& options)
     }
 }
 
-static bool processProjectFile(QFile& projectFile, QMap<QString, QString>& args)
+static bool processProjectFile(QFile &projectFile, QMap<QString, QString> &args)
 {
     QByteArray line = projectFile.readLine().trimmed();
     if (line.isEmpty() || line != "[generator-project]")
@@ -355,7 +355,7 @@ static inline void printVerAndBanner()
     std::cout << "Copyright (C) 2016 The Qt Company Ltd." << std::endl;
 }
 
-static inline void errorPrint(const QString& s)
+static inline void errorPrint(const QString &s)
 {
     QStringList arguments = QCoreApplication::arguments();
     arguments.pop_front();
diff --git a/sources/shiboken2/generator/shiboken2/cppgenerator.cpp b/sources/shiboken2/generator/shiboken2/cppgenerator.cpp
index c033b8a21..73e1a7c3e 100644
--- a/sources/shiboken2/generator/shiboken2/cppgenerator.cpp
+++ b/sources/shiboken2/generator/shiboken2/cppgenerator.cpp
@@ -81,7 +81,7 @@ static const char *typeNameOf(const T &t)
 )CPP";
 
 // utility functions
-inline AbstractMetaType* getTypeWithoutContainer(AbstractMetaType* arg)
+inline AbstractMetaType *getTypeWithoutContainer(AbstractMetaType *arg)
 {
     if (arg && arg->typeEntry()->isContainer()) {
         AbstractMetaTypeList lst = arg->instantiations();
@@ -144,25 +144,25 @@ CppGenerator::CppGenerator()
 
     // sequence protocol functions
     m_sequenceProtocol.insert(QLatin1String("__len__"),
-                              {QLatin1String("PyObject* self"),
+                              {QLatin1String("PyObject *self"),
                                QLatin1String("Py_ssize_t")});
     m_sequenceProtocol.insert(QLatin1String("__getitem__"),
-                              {QLatin1String("PyObject* self, Py_ssize_t _i"),
+                              {QLatin1String("PyObject *self, Py_ssize_t _i"),
                                QLatin1String("PyObject*")});
     m_sequenceProtocol.insert(QLatin1String("__setitem__"),
-                              {QLatin1String("PyObject* self, Py_ssize_t _i, PyObject* _value"),
+                              {QLatin1String("PyObject *self, Py_ssize_t _i, PyObject *_value"),
                                QLatin1String("int")});
     m_sequenceProtocol.insert(QLatin1String("__getslice__"),
-                              {QLatin1String("PyObject* self, Py_ssize_t _i1, Py_ssize_t _i2"),
+                              {QLatin1String("PyObject *self, Py_ssize_t _i1, Py_ssize_t _i2"),
                                QLatin1String("PyObject*")});
     m_sequenceProtocol.insert(QLatin1String("__setslice__"),
-                              {QLatin1String("PyObject* self, Py_ssize_t _i1, Py_ssize_t _i2, PyObject* _value"),
+                              {QLatin1String("PyObject *self, Py_ssize_t _i1, Py_ssize_t _i2, PyObject *_value"),
                                QLatin1String("int")});
     m_sequenceProtocol.insert(QLatin1String("__contains__"),
-                              {QLatin1String("PyObject* self, PyObject* _value"),
+                              {QLatin1String("PyObject *self, PyObject *_value"),
                                QLatin1String("int")});
     m_sequenceProtocol.insert(QLatin1String("__concat__"),
-                              {QLatin1String("PyObject* self, PyObject* _other"),
+                              {QLatin1String("PyObject *self, PyObject *_other"),
                                QLatin1String("PyObject*")});
 
     // Sequence protocol structure members names
@@ -176,13 +176,13 @@ CppGenerator::CppGenerator()
 
     // mapping protocol function
     m_mappingProtocol.insert(QLatin1String("__mlen__"),
-                             {QLatin1String("PyObject* self"),
+                             {QLatin1String("PyObject *self"),
                               QLatin1String("Py_ssize_t")});
     m_mappingProtocol.insert(QLatin1String("__mgetitem__"),
-                             {QLatin1String("PyObject* self, PyObject* _key"),
+                             {QLatin1String("PyObject *self, PyObject *_key"),
                               QLatin1String("PyObject*")});
     m_mappingProtocol.insert(QLatin1String("__msetitem__"),
-                             {QLatin1String("PyObject* self, PyObject* _key, PyObject* _value"),
+                             {QLatin1String("PyObject *self, PyObject *_key, PyObject *_value"),
                               QLatin1String("int")});
 
     // Sequence protocol structure members names
@@ -210,8 +210,8 @@ QString CppGenerator::fileNameForContext(GeneratorContext &context) const
     }
 }
 
-QVector<AbstractMetaFunctionList> CppGenerator::filterGroupedOperatorFunctions(const AbstractMetaClass* metaClass,
-                                                                             uint queryIn)
+QVector<AbstractMetaFunctionList> CppGenerator::filterGroupedOperatorFunctions(const AbstractMetaClass *metaClass,
+                                                                               uint queryIn)
 {
     // ( func_name, num_args ) => func_list
     typedef QMap<QPair<QString, int >, AbstractMetaFunctionList> ResultMap;
@@ -242,15 +242,15 @@ QVector<AbstractMetaFunctionList> CppGenerator::filterGroupedOperatorFunctions(c
     return result;
 }
 
-const AbstractMetaFunction *CppGenerator::boolCast(const AbstractMetaClass* metaClass) const
+const AbstractMetaFunction *CppGenerator::boolCast(const AbstractMetaClass *metaClass) const
 {
     if (!useIsNullAsNbNonZero())
         return nullptr;
     // TODO: This could be configurable someday
-    const AbstractMetaFunction* func = metaClass->findFunction(QLatin1String("isNull"));
+    const AbstractMetaFunction *func = metaClass->findFunction(QLatin1String("isNull"));
     if (!func || !func->type() || !func->type()->typeEntry()->isPrimitive() || !func->isPublic())
         return nullptr;
-    const PrimitiveTypeEntry* pte = static_cast<const PrimitiveTypeEntry*>(func->type()->typeEntry());
+    auto pte = static_cast<const PrimitiveTypeEntry *>(func->type()->typeEntry());
     while (pte->referencedTypeEntry())
         pte = pte->referencedTypeEntry();
     return func && func->isConstant() && pte->name() == QLatin1String("bool")
@@ -489,7 +489,7 @@ void CppGenerator::generateClass(QTextStream &s, GeneratorContext &classContext)
         if (overloads.isEmpty())
             continue;
 
-        const AbstractMetaFunction* rfunc = overloads.constFirst();
+        const AbstractMetaFunction *rfunc = overloads.constFirst();
         if (m_sequenceProtocol.contains(rfunc->name()) || m_mappingProtocol.contains(rfunc->name()))
             continue;
 
@@ -587,7 +587,7 @@ void CppGenerator::generateClass(QTextStream &s, GeneratorContext &classContext)
 
     if (const AbstractMetaFunction *f = boolCast(metaClass)) {
         ErrorCode errorCode(-1);
-        s << "static int " << cpythonBaseName(metaClass) << "___nb_bool(PyObject* self)" << endl;
+        s << "static int " << cpythonBaseName(metaClass) << "___nb_bool(PyObject *self)" << endl;
         s << '{' << endl;
         writeCppSelfDefinition(s, classContext);
         if (f->allowThread()) {
@@ -656,7 +656,7 @@ void CppGenerator::generateClass(QTextStream &s, GeneratorContext &classContext)
             if (metaField->isStatic())
                 continue;
 
-            s << INDENT << "{const_cast<char*>(\"" << metaField->name() << "\"), ";
+            s << INDENT << "{const_cast<char *>(\"" << metaField->name() << "\"), ";
             s << cpythonGetterFunctionName(metaField) << ", ";
             if (canGenerateFieldSetter(metaField))
                 s << cpythonSetterFunctionName(metaField);
@@ -707,7 +707,7 @@ void CppGenerator::generateClass(QTextStream &s, GeneratorContext &classContext)
     }
 }
 
-void CppGenerator::writeConstructorNative(QTextStream& s, const AbstractMetaFunction* func)
+void CppGenerator::writeConstructorNative(QTextStream &s, const AbstractMetaFunction *func)
 {
     Indentation indentation(INDENT);
     s << functionSignature(func, wrapperName(func->ownerClass()) + QLatin1String("::"), QString(),
@@ -715,7 +715,7 @@ void CppGenerator::writeConstructorNative(QTextStream& s, const AbstractMetaFunc
     s << " : ";
     writeFunctionCall(s, func);
     s << endl << "{" << endl;
-    const AbstractMetaArgument* lastArg = func->arguments().isEmpty() ? 0 : func->arguments().constLast();
+    const AbstractMetaArgument *lastArg = func->arguments().isEmpty() ? nullptr : func->arguments().constLast();
     writeCodeSnips(s, func->injectedCodeSnips(), TypeSystem::CodeSnipPositionBeginning, TypeSystem::NativeCode, func, lastArg);
     s << INDENT << "// ... middle" << endl;
     writeCodeSnips(s, func->injectedCodeSnips(), TypeSystem::CodeSnipPositionEnd, TypeSystem::NativeCode, func, lastArg);
@@ -727,12 +727,12 @@ void CppGenerator::writeDestructorNative(QTextStream &s, const AbstractMetaClass
     Indentation indentation(INDENT);
     s << wrapperName(metaClass) << "::~" << wrapperName(metaClass) << "()" << endl << '{' << endl;
     // kill pyobject
-    s << INDENT << "SbkObject* wrapper = Shiboken::BindingManager::instance().retrieveWrapper(this);" << endl;
+    s << INDENT << "SbkObject *wrapper = Shiboken::BindingManager::instance().retrieveWrapper(this);" << endl;
     s << INDENT << "Shiboken::Object::destroy(wrapper, this);" << endl;
     s << '}' << endl;
 }
 
-static bool allArgumentsRemoved(const AbstractMetaFunction* func)
+static bool allArgumentsRemoved(const AbstractMetaFunction *func)
 {
     if (func->arguments().isEmpty())
         return false;
@@ -744,7 +744,7 @@ static bool allArgumentsRemoved(const AbstractMetaFunction* func)
     return true;
 }
 
-QString CppGenerator::getVirtualFunctionReturnTypeName(const AbstractMetaFunction* func)
+QString CppGenerator::getVirtualFunctionReturnTypeName(const AbstractMetaFunction *func)
 {
     if (!func->type())
         return QLatin1String("\"\"");
@@ -755,12 +755,12 @@ QString CppGenerator::getVirtualFunctionReturnTypeName(const AbstractMetaFunctio
     // SbkType would return null when the type is a container.
     if (func->type()->typeEntry()->isContainer()) {
         return QLatin1Char('"')
-               + reinterpret_cast<const ContainerTypeEntry*>(func->type()->typeEntry())->typeName()
+               + reinterpret_cast<const ContainerTypeEntry *>(func->type()->typeEntry())->typeName()
                + QLatin1Char('"');
     }
 
     if (avoidProtectedHack()) {
-        const AbstractMetaEnum* metaEnum = findAbstractMetaEnum(func->type());
+        const AbstractMetaEnum *metaEnum = findAbstractMetaEnum(func->type());
         if (metaEnum && metaEnum->isProtected())
             return QLatin1Char('"') + protectedEnumSurrogateName(metaEnum) + QLatin1Char('"');
     }
@@ -771,14 +771,14 @@ QString CppGenerator::getVirtualFunctionReturnTypeName(const AbstractMetaFunctio
     return QString::fromLatin1("reinterpret_cast<PyTypeObject *>(Shiboken::SbkType< %1 >())->tp_name").arg(func->type()->typeEntry()->qualifiedCppName());
 }
 
-void CppGenerator::writeVirtualMethodNative(QTextStream&s, const AbstractMetaFunction* func)
+void CppGenerator::writeVirtualMethodNative(QTextStream &s, const AbstractMetaFunction *func)
 {
     //skip metaObject function, this will be written manually ahead
     if (usePySideExtensions() && func->ownerClass() && func->ownerClass()->isQObject() &&
         ((func->name() == QLatin1String("metaObject")) || (func->name() == QLatin1String("qt_metacall"))))
         return;
 
-    const TypeEntry* retType = func->type() ? func->type()->typeEntry() : 0;
+    const TypeEntry *retType = func->type() ? func->type()->typeEntry() : nullptr;
     const QString funcName = func->isOperatorOverload() ? pythonOperatorFunctionName(func) : func->name();
 
     QString prefix = wrapperName(func->ownerClass()) + QLatin1String("::");
@@ -841,7 +841,7 @@ void CppGenerator::writeVirtualMethodNative(QTextStream&s, const AbstractMetaFun
     //Write declaration/native injected code
     if (func->hasInjectedCode()) {
         CodeSnipList snips = func->injectedCodeSnips();
-        const AbstractMetaArgument* lastArg = func->arguments().isEmpty() ? 0 : func->arguments().constLast();
+        const AbstractMetaArgument *lastArg = func->arguments().isEmpty() ? nullptr : func->arguments().constLast();
         writeCodeSnips(s, snips, TypeSystem::CodeSnipPositionDeclaration, TypeSystem::NativeCode, func, lastArg);
         s << endl;
     }
@@ -864,7 +864,7 @@ void CppGenerator::writeVirtualMethodNative(QTextStream&s, const AbstractMetaFun
         CodeSnipList snips;
         if (func->hasInjectedCode()) {
             snips = func->injectedCodeSnips();
-            const AbstractMetaArgument* lastArg = func->arguments().isEmpty() ? 0 : func->arguments().constLast();
+            const AbstractMetaArgument *lastArg = func->arguments().isEmpty() ? nullptr : func->arguments().constLast();
             writeCodeSnips(s, snips, TypeSystem::CodeSnipPositionBeginning, TypeSystem::ShellCode, func, lastArg);
             s << endl;
         }
@@ -905,7 +905,7 @@ void CppGenerator::writeVirtualMethodNative(QTextStream&s, const AbstractMetaFun
 
             QString argConv;
             QTextStream ac(&argConv);
-            const PrimitiveTypeEntry* argType = (const PrimitiveTypeEntry*) arg->type()->typeEntry();
+            auto argType = static_cast<const PrimitiveTypeEntry *>(arg->type()->typeEntry());
             bool convert = argType->isObject()
                             || argType->isValue()
                             || arg->type()->isValuePointer()
@@ -963,9 +963,9 @@ void CppGenerator::writeVirtualMethodNative(QTextStream&s, const AbstractMetaFun
         snips = func->injectedCodeSnips();
 
         if (injectedCodeUsesPySelf(func))
-            s << INDENT << "PyObject* pySelf = BindingManager::instance().retrieveWrapper(this);" << endl;
+            s << INDENT << "PyObject *pySelf = BindingManager::instance().retrieveWrapper(this);" << endl;
 
-        const AbstractMetaArgument* lastArg = func->arguments().isEmpty() ? 0 : func->arguments().constLast();
+        const AbstractMetaArgument *lastArg = func->arguments().isEmpty() ? nullptr : func->arguments().constLast();
         writeCodeSnips(s, snips, TypeSystem::CodeSnipPositionBeginning, TypeSystem::NativeCode, func, lastArg);
         s << endl;
     }
@@ -1067,14 +1067,14 @@ void CppGenerator::writeVirtualMethodNative(QTextStream&s, const AbstractMetaFun
 
     if (func->hasInjectedCode()) {
         s << endl;
-        const AbstractMetaArgument* lastArg = func->arguments().isEmpty() ? 0 : func->arguments().constLast();
+        const AbstractMetaArgument *lastArg = func->arguments().isEmpty() ? nullptr : func->arguments().constLast();
         writeCodeSnips(s, snips, TypeSystem::CodeSnipPositionEnd, TypeSystem::NativeCode, func, lastArg);
     }
 
     if (retType) {
         s << INDENT << "return ";
         if (avoidProtectedHack() && retType->isEnum()) {
-            const AbstractMetaEnum* metaEnum = findAbstractMetaEnum(retType);
+            const AbstractMetaEnum *metaEnum = findAbstractMetaEnum(retType);
             bool isProtectedEnum = metaEnum && metaEnum->isProtected();
             if (isProtectedEnum) {
                 QString typeCast;
@@ -1085,29 +1085,29 @@ void CppGenerator::writeVirtualMethodNative(QTextStream&s, const AbstractMetaFun
             }
         }
         if (func->type()->referenceType() == LValueReference && !isPointer(func->type()))
-            s << '*';
+            s << " *";
         s << CPP_RETURN_VAR << ';' << endl;
     }
 
     s << '}' << endl << endl;
 }
 
-void CppGenerator::writeMetaObjectMethod(QTextStream& s, const AbstractMetaClass* metaClass)
+void CppGenerator::writeMetaObjectMethod(QTextStream &s, const AbstractMetaClass *metaClass)
 {
     Indentation indentation(INDENT);
     QString wrapperClassName = wrapperName(metaClass);
-    s << "const QMetaObject* " << wrapperClassName << "::metaObject() const" << endl;
+    s << "const QMetaObject *" << wrapperClassName << "::metaObject() const" << endl;
     s << '{' << endl;
     s << INDENT << "if (QObject::d_ptr->metaObject)" << endl
       << INDENT << INDENT << "return QObject::d_ptr->dynamicMetaObject();" << endl;
-    s << INDENT << "SbkObject* pySelf = Shiboken::BindingManager::instance().retrieveWrapper(this);" << endl;
+    s << INDENT << "SbkObject *pySelf = Shiboken::BindingManager::instance().retrieveWrapper(this);" << endl;
     s << INDENT << "if (pySelf == nullptr)" << endl;
     s << INDENT << INDENT << "return " << metaClass->qualifiedCppName() << "::metaObject();" << endl;
-    s << INDENT << "return PySide::SignalManager::retrieveMetaObject(reinterpret_cast<PyObject*>(pySelf));" << endl;
+    s << INDENT << "return PySide::SignalManager::retrieveMetaObject(reinterpret_cast<PyObject *>(pySelf));" << endl;
     s << '}' << endl << endl;
 
     // qt_metacall function
-    s << "int " << wrapperClassName << "::qt_metacall(QMetaObject::Call call, int id, void** args)" << endl;
+    s << "int " << wrapperClassName << "::qt_metacall(QMetaObject::Call call, int id, void **args)" << endl;
     s << "{" << endl;
 
     AbstractMetaFunction *func = nullptr;
@@ -1132,28 +1132,28 @@ void CppGenerator::writeMetaObjectMethod(QTextStream& s, const AbstractMetaClass
     writeMetaCast(s, metaClass);
 }
 
-void CppGenerator::writeMetaCast(QTextStream& s, const AbstractMetaClass* metaClass)
+void CppGenerator::writeMetaCast(QTextStream &s, const AbstractMetaClass *metaClass)
 {
     Indentation indentation(INDENT);
     QString wrapperClassName = wrapperName(metaClass);
-    s << "void* " << wrapperClassName << "::qt_metacast(const char* _clname)" << endl;
+    s << "void *" << wrapperClassName << "::qt_metacast(const char *_clname)" << endl;
     s << '{' << endl;
     s << INDENT << "if (!_clname) return {};" << endl;
-    s << INDENT << "SbkObject* pySelf = Shiboken::BindingManager::instance().retrieveWrapper(this);" << endl;
+    s << INDENT << "SbkObject *pySelf = Shiboken::BindingManager::instance().retrieveWrapper(this);" << endl;
     s << INDENT << "if (pySelf && PySide::inherits(Py_TYPE(pySelf), _clname))" << endl;
-    s << INDENT << INDENT << "return static_cast<void*>(const_cast< " << wrapperClassName << "* >(this));" << endl;
+    s << INDENT << INDENT << "return static_cast<void *>(const_cast< " << wrapperClassName << " *>(this));" << endl;
     s << INDENT << "return " << metaClass->qualifiedCppName() << "::qt_metacast(_clname);" << endl;
     s << "}" << endl << endl;
 }
 
-void CppGenerator::writeEnumConverterFunctions(QTextStream& s, const AbstractMetaEnum* metaEnum)
+void CppGenerator::writeEnumConverterFunctions(QTextStream &s, const AbstractMetaEnum *metaEnum)
 {
     if (metaEnum->isPrivate() || metaEnum->isAnonymous())
         return;
     writeEnumConverterFunctions(s, metaEnum->typeEntry());
 }
 
-void CppGenerator::writeEnumConverterFunctions(QTextStream& s, const TypeEntry* enumType)
+void CppGenerator::writeEnumConverterFunctions(QTextStream &s, const TypeEntry *enumType)
 {
     if (!enumType)
         return;
@@ -1161,16 +1161,16 @@ void CppGenerator::writeEnumConverterFunctions(QTextStream& s, const TypeEntry*
     QString enumPythonType = cpythonTypeNameExt(enumType);
     QString cppTypeName = getFullTypeName(enumType).trimmed();
     if (avoidProtectedHack()) {
-        const AbstractMetaEnum* metaEnum = findAbstractMetaEnum(enumType);
+        const AbstractMetaEnum *metaEnum = findAbstractMetaEnum(enumType);
         if (metaEnum && metaEnum->isProtected())
             cppTypeName = protectedEnumSurrogateName(metaEnum);
     }
     QString code;
     QTextStream c(&code);
-    c << INDENT << "*reinterpret_cast<" << cppTypeName << "*>(cppOut) =\n"
+    c << INDENT << "*reinterpret_cast<" << cppTypeName << " *>(cppOut) =\n"
         << INDENT << "    ";
     if (enumType->isFlags())
-        c << cppTypeName << "(QFlag(int(PySide::QFlags::getValue(reinterpret_cast<PySideQFlagsObject*>(pyIn)))))";
+        c << cppTypeName << "(QFlag(int(PySide::QFlags::getValue(reinterpret_cast<PySideQFlagsObject *>(pyIn)))))";
     else
         c << "static_cast<" << cppTypeName << ">(Shiboken::Enum::getValue(pyIn))";
     c << ';' << endl;
@@ -1186,7 +1186,7 @@ void CppGenerator::writeEnumConverterFunctions(QTextStream& s, const TypeEntry*
     c << INDENT;
     c << "return ";
     if (enumType->isFlags()) {
-        c << "reinterpret_cast<PyObject*>(PySide::QFlags::newObject(castCppIn, "
+        c << "reinterpret_cast<PyObject *>(PySide::QFlags::newObject(castCppIn, "
             << enumPythonType << "))";
     } else {
         c << "Shiboken::Enum::newItem(" << enumPythonType << ", castCppIn)";
@@ -1198,7 +1198,7 @@ void CppGenerator::writeEnumConverterFunctions(QTextStream& s, const TypeEntry*
     if (enumType->isFlags())
         return;
 
-    const FlagsTypeEntry* flags = reinterpret_cast<const EnumTypeEntry*>(enumType)->flags();
+    auto flags = reinterpret_cast<const EnumTypeEntry *>(enumType)->flags();
     if (!flags)
         return;
 
@@ -1208,7 +1208,7 @@ void CppGenerator::writeEnumConverterFunctions(QTextStream& s, const TypeEntry*
 
     code.clear();
     cppTypeName = getFullTypeName(flags).trimmed();
-    c << INDENT << "*reinterpret_cast<" << cppTypeName << "*>(cppOut) =\n"
+    c << INDENT << "*reinterpret_cast<" << cppTypeName << " *>(cppOut) =\n"
       << INDENT << "    " << cppTypeName
       << "(QFlag(int(Shiboken::Enum::getValue(pyIn))));" << endl;
 
@@ -1218,7 +1218,7 @@ void CppGenerator::writeEnumConverterFunctions(QTextStream& s, const TypeEntry*
 
     code.clear();
     c << INDENT << "Shiboken::AutoDecRef pyLong(PyNumber_Long(pyIn));" << endl;
-    c << INDENT << "*reinterpret_cast<" << cppTypeName << "*>(cppOut) =\n"
+    c << INDENT << "*reinterpret_cast<" << cppTypeName << " *>(cppOut) =\n"
       << INDENT << "    " << cppTypeName
       << "(QFlag(int(PyLong_AsLong(pyLong.object()))));" << endl;
     // PYSIDE-898: Include an additional condition to detect if the type of the
@@ -1270,7 +1270,7 @@ void CppGenerator::writeConverterFunctions(QTextStream &s, const AbstractMetaCla
     writePythonToCppFunction(s, code, sourceTypeName, targetTypeName);
 
     // "Is convertible" function for the Python object to C++ pointer conversion.
-    const QString pyTypeCheck = QLatin1String("PyObject_TypeCheck(pyIn, reinterpret_cast<PyTypeObject*>(")
+    const QString pyTypeCheck = QLatin1String("PyObject_TypeCheck(pyIn, reinterpret_cast<PyTypeObject *>(")
         + cpythonType + QLatin1String("))");
     writeIsPythonConvertibleToCppFunction(s, sourceTypeName, targetTypeName, pyTypeCheck, QString(), true);
     s << endl;
@@ -1281,9 +1281,9 @@ void CppGenerator::writeConverterFunctions(QTextStream &s, const AbstractMetaCla
     if (usePySideExtensions() && metaClass->isQObject())
     {
         c << INDENT << "return PySide::getWrapperForQObject(reinterpret_cast<"
-            << typeName << "*>(const_cast<void*>(cppIn)), " << cpythonType << ");" << endl;
+            << typeName << " *>(const_cast<void *>(cppIn)), " << cpythonType << ");" << endl;
     } else {
-        c << INDENT << "auto pyOut = reinterpret_cast<PyObject*>(Shiboken::BindingManager::instance().retrieveWrapper(cppIn));" << endl;
+        c << INDENT << "auto pyOut = reinterpret_cast<PyObject *>(Shiboken::BindingManager::instance().retrieveWrapper(cppIn));" << endl;
         c << INDENT << "if (pyOut) {" << endl;
         {
             Indentation indent(INDENT);
@@ -1300,7 +1300,7 @@ void CppGenerator::writeConverterFunctions(QTextStream &s, const AbstractMetaCla
             << INDENT << "    changedTypeName = true;\n"
             << INDENT << " }\n"
             << INDENT << "PyObject *result = Shiboken::Object::newObject(" << cpythonType
-            <<           ", const_cast<void*>(cppIn), false, /* exactType */ changedTypeName, typeName);\n"
+            <<           ", const_cast<void *>(cppIn), false, /* exactType */ changedTypeName, typeName);\n"
             << INDENT << "if (changedTypeName)\n"
             << INDENT << "    delete [] typeName;\n"
             << INDENT << "return result;";
@@ -1333,7 +1333,7 @@ void CppGenerator::writeConverterFunctions(QTextStream &s, const AbstractMetaCla
 
     c << INDENT << "return Shiboken::Object::newObject(" << cpythonType
         << ", new ::" << computedWrapperName << "(*reinterpret_cast<const "
-        << typeName << "*>(cppIn)), true, true);";
+        << typeName << " *>(cppIn)), true, true);";
     writeCppToPythonFunction(s, code, sourceTypeName, targetTypeName);
     s << endl;
 
@@ -1354,7 +1354,7 @@ void CppGenerator::writeConverterFunctions(QTextStream &s, const AbstractMetaCla
     else
         wrappedCPtrExpression = cpythonWrapperCPtr(classContext.preciseType(), pyInVariable);
 
-    c << INDENT << "*reinterpret_cast<" << typeName << "*>(cppOut) = *"
+    c << INDENT << "*reinterpret_cast<" << typeName << " *>(cppOut) = *"
         << wrappedCPtrExpression << ';';
     writePythonToCppFunction(s, code, sourceTypeName, targetTypeName);
 
@@ -1363,7 +1363,7 @@ void CppGenerator::writeConverterFunctions(QTextStream &s, const AbstractMetaCla
     s << endl;
 
     // User provided implicit conversions.
-    CustomConversion* customConversion = metaClass->typeEntry()->customConversion();
+    CustomConversion *customConversion = metaClass->typeEntry()->customConversion();
 
     // Implicit conversions.
     AbstractMetaFunctionList implicitConvs;
@@ -1378,8 +1378,8 @@ void CppGenerator::writeConverterFunctions(QTextStream &s, const AbstractMetaCla
     if (!implicitConvs.isEmpty())
         s << "// Implicit conversions." << endl;
 
-    AbstractMetaType* targetType = buildAbstractMetaTypeFromAbstractMetaClass(metaClass);
-    for (const AbstractMetaFunction* conv : qAsConst(implicitConvs)) {
+    AbstractMetaType *targetType = buildAbstractMetaTypeFromAbstractMetaClass(metaClass);
+    for (const AbstractMetaFunction *conv : qAsConst(implicitConvs)) {
         if (conv->isModifiedRemoved())
             continue;
 
@@ -1387,14 +1387,14 @@ void CppGenerator::writeConverterFunctions(QTextStream &s, const AbstractMetaCla
         QString toCppConv;
         QString toCppPreConv;
         if (conv->isConversionOperator()) {
-            const AbstractMetaClass* sourceClass = conv->ownerClass();
+            const AbstractMetaClass *sourceClass = conv->ownerClass();
             typeCheck = QStringLiteral("PyObject_TypeCheck(pyIn, %1)").arg(cpythonTypeNameExt(sourceClass->typeEntry()));
             toCppConv = QLatin1Char('*') + cpythonWrapperCPtr(sourceClass->typeEntry(), QLatin1String("pyIn"));
         } else {
             // Constructor that does implicit conversion.
             if (!conv->typeReplaced(1).isEmpty() || conv->isModifiedToArray(1))
                 continue;
-            const AbstractMetaType* sourceType = conv->arguments().constFirst()->type();
+            const AbstractMetaType *sourceType = conv->arguments().constFirst()->type();
             typeCheck = cpythonCheckFunction(sourceType);
             bool isUserPrimitiveWithoutTargetLangName = isUserPrimitive(sourceType)
                                                         && sourceType->typeEntry()->targetLangApiName() == sourceType->typeEntry()->name();
@@ -1408,7 +1408,7 @@ void CppGenerator::writeConverterFunctions(QTextStream &s, const AbstractMetaCla
             if (isWrapperType(sourceType)) {
                 typeCheck += QLatin1String("pyIn)");
                 toCppConv = (sourceType->referenceType() == LValueReference || !isPointerToWrapperType(sourceType))
-                    ? QLatin1String("*") : QString();
+                    ? QLatin1String(" *") : QString();
                 toCppConv += cpythonWrapperCPtr(sourceType->typeEntry(), QLatin1String("pyIn"));
             } else if (typeCheck.contains(QLatin1String("%in"))) {
                 typeCheck.replace(QLatin1String("%in"), QLatin1String("pyIn"));
@@ -1436,7 +1436,7 @@ void CppGenerator::writeConverterFunctions(QTextStream &s, const AbstractMetaCla
 
 
         }
-        const AbstractMetaType* sourceType = conv->isConversionOperator()
+        const AbstractMetaType *sourceType = conv->isConversionOperator()
                                              ? buildAbstractMetaTypeFromAbstractMetaClass(conv->ownerClass())
                                              : conv->arguments().constFirst()->type();
         writePythonToCppConversionFunctions(s, sourceType, targetType, typeCheck, toCppConv, toCppPreConv);
@@ -1445,11 +1445,11 @@ void CppGenerator::writeConverterFunctions(QTextStream &s, const AbstractMetaCla
     writeCustomConverterFunctions(s, customConversion);
 }
 
-void CppGenerator::writeCustomConverterFunctions(QTextStream& s, const CustomConversion* customConversion)
+void CppGenerator::writeCustomConverterFunctions(QTextStream &s, const CustomConversion *customConversion)
 {
     if (!customConversion)
         return;
-    const CustomConversion::TargetToNativeConversions& toCppConversions = customConversion->targetToNativeConversions();
+    const CustomConversion::TargetToNativeConversions &toCppConversions = customConversion->targetToNativeConversions();
     if (toCppConversions.isEmpty())
         return;
     s << "// Python to C++ conversions for type '" << customConversion->ownerType()->qualifiedCppName() << "'." << endl;
@@ -1464,7 +1464,7 @@ void CppGenerator::writeConverterRegister(QTextStream &s, const AbstractMetaClas
     if (metaClass->isNamespace())
         return;
     s << INDENT << "// Register Converter" << endl;
-    s << INDENT << "SbkConverter* converter = Shiboken::Conversions::createConverter(";
+    s << INDENT << "SbkConverter *converter = Shiboken::Conversions::createConverter(";
     s << cpythonTypeName(metaClass) << ',' << endl;
     {
         Indentation indent(INDENT);
@@ -1528,7 +1528,7 @@ void CppGenerator::writeConverterRegister(QTextStream &s, const AbstractMetaClas
     writeAddPythonToCppConversion(s, QLatin1String("converter"), toCpp, isConv);
 
     // User provided implicit conversions.
-    CustomConversion* customConversion = metaClass->typeEntry()->customConversion();
+    CustomConversion *customConversion = metaClass->typeEntry()->customConversion();
 
     // Add implicit conversions.
     AbstractMetaFunctionList implicitConvs;
@@ -1543,11 +1543,11 @@ void CppGenerator::writeConverterRegister(QTextStream &s, const AbstractMetaClas
     if (!implicitConvs.isEmpty())
         s << INDENT << "// Add implicit conversions to type converter." << endl;
 
-    AbstractMetaType* targetType = buildAbstractMetaTypeFromAbstractMetaClass(metaClass);
+    AbstractMetaType *targetType = buildAbstractMetaTypeFromAbstractMetaClass(metaClass);
     for (const AbstractMetaFunction *conv : qAsConst(implicitConvs)) {
         if (conv->isModifiedRemoved())
             continue;
-        const AbstractMetaType* sourceType;
+        const AbstractMetaType *sourceType;
         if (conv->isConversionOperator()) {
             sourceType = buildAbstractMetaTypeFromAbstractMetaClass(conv->ownerClass());
         } else {
@@ -1564,11 +1564,11 @@ void CppGenerator::writeConverterRegister(QTextStream &s, const AbstractMetaClas
     writeCustomConverterRegister(s, customConversion, QLatin1String("converter"));
 }
 
-void CppGenerator::writeCustomConverterRegister(QTextStream& s, const CustomConversion* customConversion, const QString& converterVar)
+void CppGenerator::writeCustomConverterRegister(QTextStream &s, const CustomConversion *customConversion, const QString &converterVar)
 {
     if (!customConversion)
         return;
-    const CustomConversion::TargetToNativeConversions& toCppConversions = customConversion->targetToNativeConversions();
+    const CustomConversion::TargetToNativeConversions &toCppConversions = customConversion->targetToNativeConversions();
     if (toCppConversions.isEmpty())
         return;
     s << INDENT << "// Add user defined implicit conversions to type converter." << endl;
@@ -1579,7 +1579,7 @@ void CppGenerator::writeCustomConverterRegister(QTextStream& s, const CustomConv
     }
 }
 
-void CppGenerator::writeContainerConverterFunctions(QTextStream& s, const AbstractMetaType* containerType)
+void CppGenerator::writeContainerConverterFunctions(QTextStream &s, const AbstractMetaType *containerType)
 {
     writeCppToPythonFunction(s, containerType);
     writePythonToCppConversionFunctions(s, containerType);
@@ -1588,8 +1588,8 @@ void CppGenerator::writeContainerConverterFunctions(QTextStream& s, const Abstra
 void CppGenerator::writeMethodWrapperPreamble(QTextStream &s, OverloadData &overloadData,
                                               GeneratorContext &context)
 {
-    const AbstractMetaFunction* rfunc = overloadData.referenceFunction();
-    const AbstractMetaClass* ownerClass = rfunc->ownerClass();
+    const AbstractMetaFunction *rfunc = overloadData.referenceFunction();
+    const AbstractMetaClass *ownerClass = rfunc->ownerClass();
     int minArgs = overloadData.minArgs();
     int maxArgs = overloadData.maxArgs();
     bool initPythonArguments;
@@ -1619,7 +1619,7 @@ void CppGenerator::writeMethodWrapperPreamble(QTextStream &s, OverloadData &over
         } else {
             s << context.preciseType()->cppSignature();
         }
-        s << "* cptr{};" << endl;
+        s << " *cptr{};" << endl;
 
         initPythonArguments = maxArgs > 0;
         usesNamedArguments = !ownerClass->isQObject() && overloadData.hasArgumentWithDefaultValue();
@@ -1630,7 +1630,7 @@ void CppGenerator::writeMethodWrapperPreamble(QTextStream &s, OverloadData &over
             writeCppSelfDefinition(s, rfunc, context, overloadData.hasStaticFunction());
         }
         if (!rfunc->isInplaceOperator() && overloadData.hasNonVoidReturnType())
-            s << INDENT << "PyObject* " << PYTHON_RETURN_VAR << "{};" << endl;
+            s << INDENT << "PyObject *" << PYTHON_RETURN_VAR << "{};" << endl;
 
         initPythonArguments = minArgs != maxArgs || maxArgs > 1;
         usesNamedArguments = rfunc->isCallOperator() || overloadData.hasArgumentWithDefaultValue();
@@ -1668,11 +1668,11 @@ void CppGenerator::writeConstructorWrapper(QTextStream &s, const AbstractMetaFun
     ErrorCode errorCode(-1);
     OverloadData overloadData(overloads, this);
 
-    const AbstractMetaFunction* rfunc = overloadData.referenceFunction();
-    const AbstractMetaClass* metaClass = rfunc->ownerClass();
+    const AbstractMetaFunction *rfunc = overloadData.referenceFunction();
+    const AbstractMetaClass *metaClass = rfunc->ownerClass();
 
     s << "static int" << endl;
-    s << cpythonFunctionName(rfunc) << "(PyObject* self, PyObject* args, PyObject* kwds)" << endl;
+    s << cpythonFunctionName(rfunc) << "(PyObject *self, PyObject *args, PyObject *kwds)" << endl;
     s << '{' << endl;
 
     QSet<QString> argNamesSet;
@@ -1690,19 +1690,19 @@ void CppGenerator::writeConstructorWrapper(QTextStream &s, const AbstractMetaFun
         QStringList argNamesList = argNamesSet.toList();
         std::sort(argNamesList.begin(), argNamesList.end());
         if (argNamesList.isEmpty()) {
-            s << INDENT << "const char** argNames{};" << endl;
+            s << INDENT << "const char **argNames{};" << endl;
         } else {
-            s << INDENT << "const char* argNames[] = {\""
+            s << INDENT << "const char *argNames[] = {\""
                 << argNamesList.join(QLatin1String("\", \"")) << "\"};" << endl;
         }
-        s << INDENT << "const QMetaObject* metaObject;" << endl;
+        s << INDENT << "const QMetaObject *metaObject;" << endl;
     }
 
-    s << INDENT << "SbkObject* sbkSelf = reinterpret_cast<SbkObject*>(self);" << endl;
+    s << INDENT << "SbkObject *sbkSelf = reinterpret_cast<SbkObject *>(self);" << endl;
 
     if (metaClass->isAbstract() || metaClass->baseClassNames().size() > 1) {
-        s << INDENT << "SbkObjectType* type = reinterpret_cast<SbkObjectType*>(self->ob_type);" << endl;
-        s << INDENT << "SbkObjectType* myType = reinterpret_cast<SbkObjectType*>(" << cpythonTypeNameExt(metaClass->typeEntry()) << ");" << endl;
+        s << INDENT << "SbkObjectType *type = reinterpret_cast<SbkObjectType *>(self->ob_type);" << endl;
+        s << INDENT << "SbkObjectType *myType = reinterpret_cast<SbkObjectType *>(" << cpythonTypeNameExt(metaClass->typeEntry()) << ");" << endl;
     }
 
     if (metaClass->isAbstract()) {
@@ -1827,16 +1827,16 @@ void CppGenerator::writeMethodWrapper(QTextStream &s, const AbstractMetaFunction
                                       GeneratorContext &classContext)
 {
     OverloadData overloadData(overloads, this);
-    const AbstractMetaFunction* rfunc = overloadData.referenceFunction();
+    const AbstractMetaFunction *rfunc = overloadData.referenceFunction();
 
     int maxArgs = overloadData.maxArgs();
 
-    s << "static PyObject* ";
-    s << cpythonFunctionName(rfunc) << "(PyObject* self";
+    s << "static PyObject *";
+    s << cpythonFunctionName(rfunc) << "(PyObject *self";
     if (maxArgs > 0) {
-        s << ", PyObject* " << (pythonFunctionWrapperUsesListOfArguments(overloadData) ? "args" : PYTHON_ARG);
+        s << ", PyObject *" << (pythonFunctionWrapperUsesListOfArguments(overloadData) ? "args" : PYTHON_ARG);
         if (overloadData.hasArgumentWithDefaultValue() || rfunc->isCallOperator())
-            s << ", PyObject* kwds";
+            s << ", PyObject *kwds";
     }
     s << ')' << endl << '{' << endl;
 
@@ -1868,17 +1868,17 @@ void CppGenerator::writeMethodWrapper(QTextStream &s, const AbstractMetaFunction
                 Indentation indent(INDENT);
                 s << INDENT << "&& Shiboken::Object::checkType(" << PYTHON_ARG << ")" << endl;
                 s << INDENT << "&& !PyObject_TypeCheck(" << PYTHON_ARG << ", self->ob_type)" << endl;
-                s << INDENT << "&& PyObject_HasAttrString(" << PYTHON_ARG << ", const_cast<char*>(\"" << revOpName << "\"))) {" << endl;
+                s << INDENT << "&& PyObject_HasAttrString(" << PYTHON_ARG << ", const_cast<char *>(\"" << revOpName << "\"))) {" << endl;
 
                 // This PyObject_CallMethod call will emit lots of warnings like
                 // "deprecated conversion from string constant to char *" during compilation
-                // due to the method name argument being declared as "char*" instead of "const char*"
+                // due to the method name argument being declared as "char *" instead of "const char *"
                 // issue 6952 http://bugs.python.org/issue6952
-                s << INDENT << "PyObject* revOpMethod = PyObject_GetAttrString(" << PYTHON_ARG << ", const_cast<char*>(\"" << revOpName << "\"));" << endl;
+                s << INDENT << "PyObject *revOpMethod = PyObject_GetAttrString(" << PYTHON_ARG << ", const_cast<char *>(\"" << revOpName << "\"));" << endl;
                 s << INDENT << "if (revOpMethod && PyCallable_Check(revOpMethod)) {" << endl;
                 {
                     Indentation indent(INDENT);
-                    s << INDENT << PYTHON_RETURN_VAR << " = PyObject_CallFunction(revOpMethod, const_cast<char*>(\"O\"), self);" << endl;
+                    s << INDENT << PYTHON_RETURN_VAR << " = PyObject_CallFunction(revOpMethod, const_cast<char *>(\"O\"), self);" << endl;
                     s << INDENT << "if (PyErr_Occurred() && (PyErr_ExceptionMatches(PyExc_NotImplementedError)";
                     s << " || PyErr_ExceptionMatches(PyExc_AttributeError))) {" << endl;
                     {
@@ -1927,16 +1927,16 @@ void CppGenerator::writeMethodWrapper(QTextStream &s, const AbstractMetaFunction
     s << '}' << endl << endl;
 }
 
-void CppGenerator::writeArgumentsInitializer(QTextStream& s, OverloadData& overloadData)
+void CppGenerator::writeArgumentsInitializer(QTextStream &s, OverloadData &overloadData)
 {
-    const AbstractMetaFunction* rfunc = overloadData.referenceFunction();
+    const AbstractMetaFunction *rfunc = overloadData.referenceFunction();
     s << "PyTuple_GET_SIZE(args);" << endl;
     writeUnusedVariableCast(s, QLatin1String("numArgs"));
 
     int minArgs = overloadData.minArgs();
     int maxArgs = overloadData.maxArgs();
 
-    s << INDENT << "PyObject* ";
+    s << INDENT << "PyObject *";
     s << PYTHON_ARGS << "[] = {"
         << QString(maxArgs, QLatin1Char('0')).split(QLatin1String(""), QString::SkipEmptyParts).join(QLatin1String(", "))
         << "};" << endl;
@@ -1947,7 +1947,7 @@ void CppGenerator::writeArgumentsInitializer(QTextStream& s, OverloadData& overl
         if (minArgs > maxArgs)
             minArgs = maxArgs;
 
-        s << INDENT << "PyObject* nonvarargs = PyTuple_GetSlice(args, 0, " << maxArgs << ");" << endl;
+        s << INDENT << "PyObject *nonvarargs = PyTuple_GetSlice(args, 0, " << maxArgs << ");" << endl;
         s << INDENT << "Shiboken::AutoDecRef auto_nonvarargs(nonvarargs);" << endl;
         s << INDENT << PYTHON_ARGS << '[' << maxArgs << "] = PyTuple_GetSlice(args, " << maxArgs << ", numArgs);" << endl;
         s << INDENT << "Shiboken::AutoDecRef auto_varargs(" << PYTHON_ARGS << "[" << maxArgs << "]);" << endl;
@@ -2025,10 +2025,10 @@ void CppGenerator::writeCppSelfAssigment(QTextStream &s, const GeneratorContext
 {
     static const QString pythonSelfVar = QLatin1String("self");
     if (cppSelfAsReference)
-        s << className << "& ";
+        s << className << " &";
     s << CPP_SELF_VAR << " = ";
     if (cppSelfAsReference)
-        s << '*';
+        s << " *";
     if (useWrapperClass)
         s << "static_cast<" << className << " *>(";
     if (!context.forSmartPointer())
@@ -2056,7 +2056,7 @@ void CppGenerator::writeCppSelfDefinition(QTextStream &s,
     }
 
     if (!cppSelfAsReference) {
-        s << INDENT << className << "* " << CPP_SELF_VAR << " = nullptr;" << endl;
+        s << INDENT << className << " *" << CPP_SELF_VAR << " = nullptr;" << endl;
         writeUnusedVariableCast(s, QLatin1String(CPP_SELF_VAR));
     }
 
@@ -2103,9 +2103,9 @@ void CppGenerator::writeCppSelfDefinition(QTextStream &s,
     writeCppSelfDefinition(s, context, hasStaticOverload);
 }
 
-void CppGenerator::writeErrorSection(QTextStream& s, OverloadData& overloadData)
+void CppGenerator::writeErrorSection(QTextStream &s, OverloadData &overloadData)
 {
-    const AbstractMetaFunction* rfunc = overloadData.referenceFunction();
+    const AbstractMetaFunction *rfunc = overloadData.referenceFunction();
     s << endl << INDENT << cpythonFunctionName(rfunc) << "_TypeError:" << endl;
     Indentation indentation(INDENT);
     QString funcName = fullPythonFunctionName(rfunc);
@@ -2116,7 +2116,7 @@ void CppGenerator::writeErrorSection(QTextStream& s, OverloadData& overloadData)
     s << INDENT << "return " << m_currentErrorCode << ';' << endl;
 }
 
-void CppGenerator::writeFunctionReturnErrorCheckSection(QTextStream& s, bool hasReturnValue)
+void CppGenerator::writeFunctionReturnErrorCheckSection(QTextStream &s, bool hasReturnValue)
 {
     s << INDENT << "if (PyErr_Occurred()";
     if (hasReturnValue)
@@ -2131,14 +2131,14 @@ void CppGenerator::writeFunctionReturnErrorCheckSection(QTextStream& s, bool has
     s << INDENT << '}' << endl;
 }
 
-void CppGenerator::writeInvalidPyObjectCheck(QTextStream& s, const QString& pyObj)
+void CppGenerator::writeInvalidPyObjectCheck(QTextStream &s, const QString &pyObj)
 {
     s << INDENT << "if (!Shiboken::Object::isValid(" << pyObj << "))" << endl;
     Indentation indent(INDENT);
     s << INDENT << returnStatement(m_currentErrorCode) << endl;
 }
 
-static QString pythonToCppConverterForArgumentName(const QString& argumentName)
+static QString pythonToCppConverterForArgumentName(const QString &argumentName)
 {
     static const QRegularExpression pyArgsRegex(QLatin1String(PYTHON_ARGS)
                                                 + QLatin1String(R"((\[\d+[-]?\d*\]))"));
@@ -2150,11 +2150,11 @@ static QString pythonToCppConverterForArgumentName(const QString& argumentName)
     return result;
 }
 
-void CppGenerator::writeTypeCheck(QTextStream& s, const AbstractMetaType* argType, QString argumentName, bool isNumber, QString customType, bool rejectNull)
+void CppGenerator::writeTypeCheck(QTextStream &s, const AbstractMetaType *argType, QString argumentName, bool isNumber, QString customType, bool rejectNull)
 {
     QString customCheck;
     if (!customType.isEmpty()) {
-        AbstractMetaType* metaType;
+        AbstractMetaType *metaType;
         customCheck = guessCPythonCheckFunction(customType, &metaType);
         if (metaType)
             argType = metaType;
@@ -2182,7 +2182,7 @@ void CppGenerator::writeTypeCheck(QTextStream& s, const AbstractMetaType* argTyp
     s << typeCheck;
 }
 
-static void checkTypeViability(const AbstractMetaFunction* func, const AbstractMetaType* type, int argIdx)
+static void checkTypeViability(const AbstractMetaFunction *func, const AbstractMetaType *type, int argIdx)
 {
     if (!type
         || !type->typeEntry()->isPrimitive()
@@ -2209,25 +2209,25 @@ static void checkTypeViability(const AbstractMetaFunction* func, const AbstractM
     qCWarning(lcShiboken).noquote().nospace() << message;
 }
 
-static void checkTypeViability(const AbstractMetaFunction* func)
+static void checkTypeViability(const AbstractMetaFunction *func)
 {
     if (func->isUserAdded())
         return;
-    const AbstractMetaType* type = func->type();
+    const AbstractMetaType *type = func->type();
     checkTypeViability(func, type, 0);
     for (int i = 0; i < func->arguments().count(); ++i)
         checkTypeViability(func, func->arguments().at(i)->type(), i + 1);
 }
 
-void CppGenerator::writeTypeCheck(QTextStream& s, const OverloadData* overloadData, QString argumentName)
+void CppGenerator::writeTypeCheck(QTextStream &s, const OverloadData *overloadData, QString argumentName)
 {
-    QSet<const TypeEntry*> numericTypes;
+    QSet<const TypeEntry *> numericTypes;
     const OverloadDataList &overloads = overloadData->previousOverloadData()->nextOverloadData();
     for (OverloadData *od : overloads) {
         const OverloadData::MetaFunctionList &odOverloads = od->overloads();
         for (const AbstractMetaFunction *func : odOverloads) {
             checkTypeViability(func);
-            const AbstractMetaType* argType = od->argument(func)->type();
+            const AbstractMetaType *argType = od->argument(func)->type();
             if (!argType->isPrimitive())
                 continue;
             if (ShibokenGenerator::isNumber(argType->typeEntry()))
@@ -2237,18 +2237,18 @@ void CppGenerator::writeTypeCheck(QTextStream& s, const OverloadData* overloadDa
 
     // This condition trusts that the OverloadData object will arrange for
     // PyInt type to come after the more precise numeric types (e.g. float and bool)
-    const AbstractMetaType* argType = overloadData->argType();
+    const AbstractMetaType *argType = overloadData->argType();
     bool numberType = numericTypes.count() == 1 || ShibokenGenerator::isPyInt(argType);
     QString customType = (overloadData->hasArgumentTypeReplace() ? overloadData->argumentTypeReplaced() : QString());
     bool rejectNull = shouldRejectNullPointerArgument(overloadData->referenceFunction(), overloadData->argPos());
     writeTypeCheck(s, argType, argumentName, numberType, customType, rejectNull);
 }
 
-void CppGenerator::writeArgumentConversion(QTextStream& s,
-                                           const AbstractMetaType* argType,
-                                           const QString& argName, const QString& pyArgName,
-                                           const AbstractMetaClass* context,
-                                           const QString& defaultValue,
+void CppGenerator::writeArgumentConversion(QTextStream &s,
+                                           const AbstractMetaType *argType,
+                                           const QString &argName, const QString &pyArgName,
+                                           const AbstractMetaClass *context,
+                                           const QString &defaultValue,
                                            bool castArgumentAsUnused)
 {
     if (argType->typeEntry()->isCustom() || argType->typeEntry()->isVarargs())
@@ -2260,7 +2260,7 @@ void CppGenerator::writeArgumentConversion(QTextStream& s,
         writeUnusedVariableCast(s, argName);
 }
 
-const AbstractMetaType* CppGenerator::getArgumentType(const AbstractMetaFunction* func, int argPos)
+const AbstractMetaType *CppGenerator::getArgumentType(const AbstractMetaFunction *func, int argPos)
 {
     if (argPos < 0 || argPos > func->arguments().size()) {
         qCWarning(lcShiboken).noquote().nospace()
@@ -2268,7 +2268,7 @@ const AbstractMetaType* CppGenerator::getArgumentType(const AbstractMetaFunction
         return 0;
     }
 
-    const AbstractMetaType* argType = 0;
+    const AbstractMetaType *argType = nullptr;
     QString typeReplaced = func->typeReplaced(argPos);
     if (typeReplaced.isEmpty())
         argType = (argPos == 0) ? func->type() : func->arguments().at(argPos-1)->type();
@@ -2300,14 +2300,14 @@ static inline QString arrayHandleType(const AbstractMetaTypeCList &nestedArrayTy
     return QString();
 }
 
-void CppGenerator::writePythonToCppTypeConversion(QTextStream& s,
-                                                  const AbstractMetaType* type,
-                                                  const QString& pyIn,
-                                                  const QString& cppOut,
-                                                  const AbstractMetaClass* /* context */,
-                                                  const QString& defaultValue)
+void CppGenerator::writePythonToCppTypeConversion(QTextStream &s,
+                                                  const AbstractMetaType *type,
+                                                  const QString &pyIn,
+                                                  const QString &cppOut,
+                                                  const AbstractMetaClass * /* context */,
+                                                  const QString &defaultValue)
 {
-    const TypeEntry* typeEntry = type->typeEntry();
+    const TypeEntry *typeEntry = type->typeEntry();
     if (typeEntry->isCustom() || typeEntry->isVarargs())
         return;
 
@@ -2336,7 +2336,7 @@ void CppGenerator::writePythonToCppTypeConversion(QTextStream& s,
         writeMinimalConstructorExpression(s, type, defaultValue);
         s << ';' << endl;
     } else if (avoidProtectedHack() && type->typeEntry()->isEnum()) {
-        const AbstractMetaEnum* metaEnum = findAbstractMetaEnum(type);
+        const AbstractMetaEnum *metaEnum = findAbstractMetaEnum(type);
         if (metaEnum && metaEnum->isProtected()) {
             typeName = QLatin1String("long");
             isProtectedEnum = true;
@@ -2347,11 +2347,11 @@ void CppGenerator::writePythonToCppTypeConversion(QTextStream& s,
     if (isCppPrimitiveArray) {
         s << ' ' << cppOut;
     } else if (treatAsPointer || isPointerOrObjectType) {
-        s << "* " << cppOut;
+        s << " *" << cppOut;
         if (!defaultValue.isEmpty())
             s << " = " << defaultValue;
     } else if (type->referenceType() == LValueReference && !typeEntry->isPrimitive() && isNotContainerEnumOrFlags) {
-        s << "* " << cppOut << " = &" << cppOutAux;
+        s << " *" << cppOut << " = &" << cppOutAux;
     } else {
         s << ' ' << cppOut;
         if (isProtectedEnum && avoidProtectedHack()) {
@@ -2400,7 +2400,7 @@ void CppGenerator::writePythonToCppTypeConversion(QTextStream& s,
     s << endl;
 }
 
-static void addConversionRuleCodeSnippet(CodeSnipList& snippetList, QString& rule,
+static void addConversionRuleCodeSnippet(CodeSnipList &snippetList, QString &rule,
                                          TypeSystem::Language /* conversionLanguage */,
                                          TypeSystem::Language snippetLanguage,
                                          QString outputName = QString(),
@@ -2420,7 +2420,7 @@ static void addConversionRuleCodeSnippet(CodeSnipList& snippetList, QString& rul
     snippetList << snip;
 }
 
-void CppGenerator::writeConversionRule(QTextStream& s, const AbstractMetaFunction* func, TypeSystem::Language language)
+void CppGenerator::writeConversionRule(QTextStream &s, const AbstractMetaFunction *func, TypeSystem::Language language)
 {
     CodeSnipList snippets;
     const AbstractMetaArgumentList &arguments = func->arguments();
@@ -2432,7 +2432,7 @@ void CppGenerator::writeConversionRule(QTextStream& s, const AbstractMetaFunctio
     writeCodeSnips(s, snippets, TypeSystem::CodeSnipPositionBeginning, TypeSystem::TargetLangCode, func);
 }
 
-void CppGenerator::writeConversionRule(QTextStream& s, const AbstractMetaFunction* func, TypeSystem::Language language, const QString& outputVar)
+void CppGenerator::writeConversionRule(QTextStream &s, const AbstractMetaFunction *func, TypeSystem::Language language, const QString &outputVar)
 {
     CodeSnipList snippets;
     QString rule = func->conversionRule(language, 0);
@@ -2440,7 +2440,7 @@ void CppGenerator::writeConversionRule(QTextStream& s, const AbstractMetaFunctio
     writeCodeSnips(s, snippets, TypeSystem::CodeSnipPositionAny, language, func);
 }
 
-void CppGenerator::writeNoneReturn(QTextStream& s, const AbstractMetaFunction* func, bool thereIsReturnValue)
+void CppGenerator::writeNoneReturn(QTextStream &s, const AbstractMetaFunction *func, bool thereIsReturnValue)
 {
     if (thereIsReturnValue && (!func->type() || func->argumentRemoved(0)) && !injectedCodeHasReturnValueAttribution(func)) {
         s << INDENT << PYTHON_RETURN_VAR << " = Py_None;" << endl;
@@ -2448,10 +2448,10 @@ void CppGenerator::writeNoneReturn(QTextStream& s, const AbstractMetaFunction* f
     }
 }
 
-void CppGenerator::writeOverloadedFunctionDecisor(QTextStream& s, const OverloadData& overloadData)
+void CppGenerator::writeOverloadedFunctionDecisor(QTextStream &s, const OverloadData &overloadData)
 {
     s << INDENT << "// Overloaded function decisor" << endl;
-    const AbstractMetaFunction* rfunc = overloadData.referenceFunction();
+    const AbstractMetaFunction *rfunc = overloadData.referenceFunction();
     const OverloadData::MetaFunctionList &functionOverloads = overloadData.overloadsWithoutRepetition();
     for (int i = 0; i < functionOverloads.count(); i++) {
         const auto func = functionOverloads.at(i);
@@ -2482,10 +2482,10 @@ void CppGenerator::writeOverloadedFunctionDecisor(QTextStream& s, const Overload
     s << endl;
 }
 
-void CppGenerator::writeOverloadedFunctionDecisorEngine(QTextStream& s, const OverloadData* parentOverloadData)
+void CppGenerator::writeOverloadedFunctionDecisorEngine(QTextStream &s, const OverloadData *parentOverloadData)
 {
     bool hasDefaultCall = parentOverloadData->nextArgumentHasDefaultValue();
-    const AbstractMetaFunction* referenceFunction = parentOverloadData->referenceFunction();
+    const AbstractMetaFunction *referenceFunction = parentOverloadData->referenceFunction();
 
     // If the next argument has not an argument with a default value, it is still possible
     // that one of the overloads for the current overload data has its final occurrence here.
@@ -2523,7 +2523,7 @@ void CppGenerator::writeOverloadedFunctionDecisorEngine(QTextStream& s, const Ov
         // The current overload data describes the last argument of a signature,
         // so the method can be identified right now.
         if (isLastArgument || (signatureFound && !hasDefaultCall)) {
-            const AbstractMetaFunction* func = parentOverloadData->referenceFunction();
+            const AbstractMetaFunction *func = parentOverloadData->referenceFunction();
             s << INDENT << "overloadId = " << parentOverloadData->headOverloadData()->overloads().indexOf(func);
             s << "; // " << func->minimalSignature() << endl;
             return;
@@ -2542,9 +2542,9 @@ void CppGenerator::writeOverloadedFunctionDecisorEngine(QTextStream& s, const Ov
         s << INDENT << "if (numArgs == " << numArgs << ") {" << endl;
         {
             Indentation indent(INDENT);
-            const AbstractMetaFunction* func = referenceFunction;
+            const AbstractMetaFunction *func = referenceFunction;
             for (OverloadData *overloadData : overloads) {
-                const AbstractMetaFunction* defValFunc = overloadData->getFunctionWithDefaultValue();
+                const AbstractMetaFunction *defValFunc = overloadData->getFunctionWithDefaultValue();
                 if (defValFunc) {
                     func = defValFunc;
                     break;
@@ -2561,14 +2561,14 @@ void CppGenerator::writeOverloadedFunctionDecisorEngine(QTextStream& s, const Ov
                                 && !overloadData->getFunctionWithDefaultValue()
                                 && !overloadData->findNextArgWithDefault();
 
-        const AbstractMetaFunction* refFunc = overloadData->referenceFunction();
+        const AbstractMetaFunction *refFunc = overloadData->referenceFunction();
 
         QStringList typeChecks;
 
         QString pyArgName = (usePyArgs && maxArgs > 1)
             ? pythonArgsAt(overloadData->argPos())
             : QLatin1String(PYTHON_ARG);
-        OverloadData* od = overloadData;
+        OverloadData *od = overloadData;
         int startArg = od->argPos();
         int sequenceArgCount = 0;
         while (od && !od->argType()->isVarargs()) {
@@ -2578,11 +2578,11 @@ void CppGenerator::writeOverloadedFunctionDecisorEngine(QTextStream& s, const Ov
                     pyArgName = pythonArgsAt(od->argPos());
                 QString typeCheck;
                 QTextStream tck(&typeCheck);
-                const AbstractMetaFunction* func = od->referenceFunction();
+                const AbstractMetaFunction *func = od->referenceFunction();
 
                 if (func->isConstructor() && func->arguments().count() == 1) {
-                    const AbstractMetaClass* ownerClass = func->ownerClass();
-                    const ComplexTypeEntry* baseContainerType = ownerClass->typeEntry()->baseContainerType();
+                    const AbstractMetaClass *ownerClass = func->ownerClass();
+                    const ComplexTypeEntry *baseContainerType = ownerClass->typeEntry()->baseContainerType();
                     if (baseContainerType && baseContainerType == func->arguments().constFirst()->type()->typeEntry() && isCopyable(ownerClass)) {
                         tck << '!' << cpythonCheckFunction(ownerClass->typeEntry()) << pyArgName << ')' << endl;
                         Indentation indent(INDENT);
@@ -2655,7 +2655,7 @@ void CppGenerator::writeFunctionCalls(QTextStream &s, const OverloadData &overlo
             writeSingleFunctionCall(s, overloadData, overloads.constFirst(), context);
         } else {
             for (int i = 0; i < overloads.count(); i++) {
-                const AbstractMetaFunction* func = overloads.at(i);
+                const AbstractMetaFunction *func = overloads.at(i);
                 s << INDENT << "case " << i << ": // " << func->signature() << endl;
                 s << INDENT << '{' << endl;
                 {
@@ -2705,7 +2705,7 @@ void CppGenerator::writeSingleFunctionCall(QTextStream &s,
     int removedArgs = 0;
     for (int argIdx = 0; argIdx < func->arguments().count(); ++argIdx) {
         bool hasConversionRule = !func->conversionRule(TypeSystem::NativeCode, argIdx + 1).isEmpty();
-        const AbstractMetaArgument* arg = func->arguments().at(argIdx);
+        const AbstractMetaArgument *arg = func->arguments().at(argIdx);
         if (func->argumentRemoved(argIdx + 1)) {
             if (!arg->defaultValueExpression().isEmpty()) {
                 const QString cppArgRemoved = QLatin1String(CPP_ARG_REMOVED)
@@ -2724,7 +2724,7 @@ void CppGenerator::writeSingleFunctionCall(QTextStream &s,
         }
         if (hasConversionRule)
             continue;
-        const AbstractMetaType* argType = getArgumentType(func, argIdx + 1);
+        const AbstractMetaType *argType = getArgumentType(func, argIdx + 1);
         if (!argType || (mayHaveUnunsedArguments && !injectedCodeUsesArgument(func, argIdx)))
             continue;
         int argPos = argIdx - removedArgs;
@@ -2748,72 +2748,72 @@ void CppGenerator::writeSingleFunctionCall(QTextStream &s,
     s << INDENT << '}' << endl;
 }
 
-QString CppGenerator::cppToPythonFunctionName(const QString& sourceTypeName, QString targetTypeName)
+QString CppGenerator::cppToPythonFunctionName(const QString &sourceTypeName, QString targetTypeName)
 {
     if (targetTypeName.isEmpty())
         targetTypeName = sourceTypeName;
     return QString::fromLatin1("%1_CppToPython_%2").arg(sourceTypeName, targetTypeName);
 }
 
-QString CppGenerator::pythonToCppFunctionName(const QString& sourceTypeName, const QString& targetTypeName)
+QString CppGenerator::pythonToCppFunctionName(const QString &sourceTypeName, const QString &targetTypeName)
 {
     return QString::fromLatin1("%1_PythonToCpp_%2").arg(sourceTypeName, targetTypeName);
 }
-QString CppGenerator::pythonToCppFunctionName(const AbstractMetaType* sourceType, const AbstractMetaType* targetType)
+QString CppGenerator::pythonToCppFunctionName(const AbstractMetaType *sourceType, const AbstractMetaType *targetType)
 {
     return pythonToCppFunctionName(fixedCppTypeName(sourceType), fixedCppTypeName(targetType));
 }
-QString CppGenerator::pythonToCppFunctionName(const CustomConversion::TargetToNativeConversion* toNative,
-                                              const TypeEntry* targetType)
+QString CppGenerator::pythonToCppFunctionName(const CustomConversion::TargetToNativeConversion *toNative,
+                                              const TypeEntry *targetType)
 {
     return pythonToCppFunctionName(fixedCppTypeName(toNative), fixedCppTypeName(targetType));
 }
 
-QString CppGenerator::convertibleToCppFunctionName(const QString& sourceTypeName, const QString& targetTypeName)
+QString CppGenerator::convertibleToCppFunctionName(const QString &sourceTypeName, const QString &targetTypeName)
 {
     return QString::fromLatin1("is_%1_PythonToCpp_%2_Convertible").arg(sourceTypeName, targetTypeName);
 }
-QString CppGenerator::convertibleToCppFunctionName(const AbstractMetaType* sourceType, const AbstractMetaType* targetType)
+QString CppGenerator::convertibleToCppFunctionName(const AbstractMetaType *sourceType, const AbstractMetaType *targetType)
 {
     return convertibleToCppFunctionName(fixedCppTypeName(sourceType), fixedCppTypeName(targetType));
 }
-QString CppGenerator::convertibleToCppFunctionName(const CustomConversion::TargetToNativeConversion* toNative,
-                                                   const TypeEntry* targetType)
+QString CppGenerator::convertibleToCppFunctionName(const CustomConversion::TargetToNativeConversion *toNative,
+                                                   const TypeEntry *targetType)
 {
     return convertibleToCppFunctionName(fixedCppTypeName(toNative), fixedCppTypeName(targetType));
 }
 
-void CppGenerator::writeCppToPythonFunction(QTextStream& s, const QString& code, const QString& sourceTypeName, QString targetTypeName)
+void CppGenerator::writeCppToPythonFunction(QTextStream &s, const QString &code, const QString &sourceTypeName, QString targetTypeName)
 {
     QString prettyCode;
     QTextStream c(&prettyCode);
     formatCode(c, code, INDENT);
     processCodeSnip(prettyCode);
 
-    s << "static PyObject* " << cppToPythonFunctionName(sourceTypeName, targetTypeName);
-    s << "(const void* cppIn) {" << endl;
+    s << "static PyObject *" << cppToPythonFunctionName(sourceTypeName, targetTypeName);
+    s << "(const void *cppIn) {" << endl;
     s << prettyCode;
     s << '}' << endl;
 }
 
-static void replaceCppToPythonVariables(QString& code, const QString& typeName)
+static void replaceCppToPythonVariables(QString &code, const QString &typeName)
 {
     code.prepend(QLatin1String("auto &cppInRef = *reinterpret_cast<")
-                 + typeName + QLatin1String("*>(const_cast<void *>(cppIn));\n"));
+                 + typeName + QLatin1String(" *>(const_cast<void *>(cppIn));\n"));
     code.replace(QLatin1String("%INTYPE"), typeName);
-    code.replace(QLatin1String("%OUTTYPE"), QLatin1String("PyObject*"));
+    code.replace(QLatin1String("%OUTTYPE"), QLatin1String("PyObject *"));
     code.replace(QLatin1String("%in"), QLatin1String("cppInRef"));
     code.replace(QLatin1String("%out"), QLatin1String("pyOut"));
 }
-void CppGenerator::writeCppToPythonFunction(QTextStream& s, const CustomConversion* customConversion)
+void CppGenerator::writeCppToPythonFunction(QTextStream &s, const CustomConversion *customConversion)
 {
     QString code = customConversion->nativeToTargetConversion();
     replaceCppToPythonVariables(code, getFullTypeName(customConversion->ownerType()));
     writeCppToPythonFunction(s, code, fixedCppTypeName(customConversion->ownerType()));
 }
-void CppGenerator::writeCppToPythonFunction(QTextStream& s, const AbstractMetaType* containerType)
+void CppGenerator::writeCppToPythonFunction(QTextStream &s, const AbstractMetaType *containerType)
 {
-    const CustomConversion* customConversion = containerType->typeEntry()->customConversion();
+    const CustomConversion *customConversion = containerType->typeEntry()->customConversion();
     if (!customConversion) {
         qFatal("Can't write the C++ to Python conversion function for container type '%s' - "\
                "no conversion rule was defined for it in the type system.",
@@ -2825,7 +2825,7 @@ void CppGenerator::writeCppToPythonFunction(QTextStream& s, const AbstractMetaTy
     }
     QString code = customConversion->nativeToTargetConversion();
     for (int i = 0; i < containerType->instantiations().count(); ++i) {
-        AbstractMetaType* type = containerType->instantiations().at(i);
+        AbstractMetaType *type = containerType->instantiations().at(i);
         QString typeName = getFullTypeName(type);
         if (type->isConstant())
             typeName = QLatin1String("const ") + typeName;
@@ -2836,22 +2836,22 @@ void CppGenerator::writeCppToPythonFunction(QTextStream& s, const AbstractMetaTy
     writeCppToPythonFunction(s, code, fixedCppTypeName(containerType));
 }
 
-void CppGenerator::writePythonToCppFunction(QTextStream& s, const QString& code, const QString& sourceTypeName, const QString& targetTypeName)
+void CppGenerator::writePythonToCppFunction(QTextStream &s, const QString &code, const QString &sourceTypeName, const QString &targetTypeName)
 {
     QString prettyCode;
     QTextStream c(&prettyCode);
     formatCode(c, code, INDENT);
     processCodeSnip(prettyCode);
     s << "static void " << pythonToCppFunctionName(sourceTypeName, targetTypeName);
-    s << "(PyObject* pyIn, void* cppOut) {" << endl;
+    s << "(PyObject *pyIn, void *cppOut) {" << endl;
     s << prettyCode;
     s << '}' << endl;
 }
 
-void CppGenerator::writeIsPythonConvertibleToCppFunction(QTextStream& s,
-                                                         const QString& sourceTypeName,
-                                                         const QString& targetTypeName,
-                                                         const QString& condition,
+void CppGenerator::writeIsPythonConvertibleToCppFunction(QTextStream &s,
+                                                         const QString &sourceTypeName,
+                                                         const QString &targetTypeName,
+                                                         const QString &condition,
                                                          QString pythonToCppFuncName,
                                                          bool acceptNoneAsCppNull)
 {
@@ -2859,7 +2859,7 @@ void CppGenerator::writeIsPythonConvertibleToCppFunction(QTextStream& s,
         pythonToCppFuncName = pythonToCppFunctionName(sourceTypeName, targetTypeName);
 
     s << "static PythonToCppFunc " << convertibleToCppFunctionName(sourceTypeName, targetTypeName);
-    s << "(PyObject* pyIn) {" << endl;
+    s << "(PyObject *pyIn) {" << endl;
     if (acceptNoneAsCppNull) {
         s << INDENT << "if (pyIn == Py_None)" << endl;
         Indentation indent(INDENT);
@@ -2874,9 +2874,9 @@ void CppGenerator::writeIsPythonConvertibleToCppFunction(QTextStream& s,
     s << '}' << endl;
 }
 
-void CppGenerator::writePythonToCppConversionFunctions(QTextStream& s,
-                                                       const AbstractMetaType* sourceType,
-                                                       const AbstractMetaType* targetType,
+void CppGenerator::writePythonToCppConversionFunctions(QTextStream &s,
+                                                       const AbstractMetaType *sourceType,
+                                                       const AbstractMetaType *targetType,
                                                        QString typeCheck,
                                                        QString conversion,
                                                        QString preConversion)
@@ -2891,7 +2891,7 @@ void CppGenerator::writePythonToCppConversionFunctions(QTextStream& s,
     if (!preConversion.isEmpty())
         c << INDENT << preConversion << endl;
     const QString fullTypeName = getFullTypeName(targetType->typeEntry());
-    c << INDENT << "*reinterpret_cast<" << fullTypeName << "*>(cppOut) = "
+    c << INDENT << "*reinterpret_cast<" << fullTypeName << " *>(cppOut) = "
         << fullTypeName << '(' << conversion << ");";
     QString sourceTypeName = fixedCppTypeName(sourceType);
     QString targetTypeName = fixedCppTypeName(targetType);
@@ -2904,9 +2904,9 @@ void CppGenerator::writePythonToCppConversionFunctions(QTextStream& s,
     s << endl;
 }
 
-void CppGenerator::writePythonToCppConversionFunctions(QTextStream& s,
-                                                      const CustomConversion::TargetToNativeConversion* toNative,
-                                                      const TypeEntry* targetType)
+void CppGenerator::writePythonToCppConversionFunctions(QTextStream &s,
+                                                      const CustomConversion::TargetToNativeConversion *toNative,
+                                                      const TypeEntry *targetType)
 {
     // Python to C++ conversion function.
     QString code = toNative->conversion();
@@ -2919,7 +2919,7 @@ void CppGenerator::writePythonToCppConversionFunctions(QTextStream& s,
     code.replace(QLatin1String("%OUTTYPE"), targetType->qualifiedCppName());
     code.replace(QLatin1String("%in"), QLatin1String("pyIn"));
     code.replace(QLatin1String("%out"),
-                 QLatin1String("*reinterpret_cast<") + getFullTypeName(targetType) + QLatin1String("*>(cppOut)"));
+                 QLatin1String("*reinterpret_cast<") + getFullTypeName(targetType) + QLatin1String(" *>(cppOut)"));
 
     QString sourceTypeName = fixedCppTypeName(toNative);
     QString targetTypeName = fixedCppTypeName(targetType);
@@ -2956,14 +2956,14 @@ void CppGenerator::writePythonToCppConversionFunctions(QTextStream& s,
     writeIsPythonConvertibleToCppFunction(s, sourceTypeName, targetTypeName, typeCheck);
 }
 
-void CppGenerator::writePythonToCppConversionFunctions(QTextStream& s, const AbstractMetaType* containerType)
+void CppGenerator::writePythonToCppConversionFunctions(QTextStream &s, const AbstractMetaType *containerType)
 {
-    const CustomConversion* customConversion = containerType->typeEntry()->customConversion();
+    const CustomConversion *customConversion = containerType->typeEntry()->customConversion();
     if (!customConversion) {
         //qFatal
         return;
     }
-    const CustomConversion::TargetToNativeConversions& toCppConversions = customConversion->targetToNativeConversions();
+    const CustomConversion::TargetToNativeConversions &toCppConversions = customConversion->targetToNativeConversions();
     if (toCppConversions.isEmpty()) {
         //qFatal
         return;
@@ -2973,10 +2973,10 @@ void CppGenerator::writePythonToCppConversionFunctions(QTextStream& s, const Abs
     QString code;
     QTextStream c(&code);
     c << INDENT << "auto &cppOutRef = *reinterpret_cast<"
-        << cppTypeName << "*>(cppOut);\n";
+        << cppTypeName << " *>(cppOut);\n";
     code.append(toCppConversions.constFirst()->conversion());
     for (int i = 0; i < containerType->instantiations().count(); ++i) {
-        const AbstractMetaType* type = containerType->instantiations().at(i);
+        const AbstractMetaType *type = containerType->instantiations().at(i);
         QString typeName = getFullTypeName(type);
         if (type->isValue() && isValueTypeWithCopyConstructorOnly(type)) {
             for (int pos = 0; ; ) {
@@ -2989,7 +2989,7 @@ void CppGenerator::writePythonToCppConversionFunctions(QTextStream& s, const Abs
                 rightCode.replace(varName, QLatin1Char('*') + varName);
                 code.replace(pos, code.size() - pos, rightCode);
             }
-            typeName.append(QLatin1Char('*'));
+            typeName.append(QLatin1String(" *"));
         }
         code.replace(QString::fromLatin1("%OUTTYPE_%1").arg(i), typeName);
     }
@@ -3009,7 +3009,7 @@ void CppGenerator::writePythonToCppConversionFunctions(QTextStream& s, const Abs
     s << endl;
 }
 
-void CppGenerator::writeAddPythonToCppConversion(QTextStream& s, const QString& converterVar, const QString& pythonToCppFunc, const QString& isConvertibleFunc)
+void CppGenerator::writeAddPythonToCppConversion(QTextStream &s, const QString &converterVar, const QString &pythonToCppFunc, const QString &isConvertibleFunc)
 {
     s << INDENT << "Shiboken::Conversions::addPythonToCppValueConversion(" << converterVar << ',' << endl;
     {
@@ -3020,7 +3020,7 @@ void CppGenerator::writeAddPythonToCppConversion(QTextStream& s, const QString&
     s << ");" << endl;
 }
 
-void CppGenerator::writeNamedArgumentResolution(QTextStream& s, const AbstractMetaFunction* func, bool usePyArgs)
+void CppGenerator::writeNamedArgumentResolution(QTextStream &s, const AbstractMetaFunction *func, bool usePyArgs)
 {
     const AbstractMetaArgumentList &args = OverloadData::getArgumentsWithDefaultValues(func);
     if (args.isEmpty())
@@ -3032,7 +3032,7 @@ void CppGenerator::writeNamedArgumentResolution(QTextStream& s, const AbstractMe
     s << INDENT << "if (kwds) {" << endl;
     {
         Indentation indent(INDENT);
-        s << INDENT << "PyObject* ";
+        s << INDENT << "PyObject *";
         for (const AbstractMetaArgument *arg : args) {
             int pyArgIndex = arg->argumentIndex() - OverloadData::numberOfRemovedArguments(func, arg->argumentIndex());
             QString pyArgName = usePyArgs ? pythonArgsAt(pyArgIndex) : QLatin1String(PYTHON_ARG);
@@ -3063,7 +3063,7 @@ void CppGenerator::writeNamedArgumentResolution(QTextStream& s, const AbstractMe
     s << INDENT << '}' << endl;
 }
 
-QString CppGenerator::argumentNameFromIndex(const AbstractMetaFunction* func, int argIndex, const AbstractMetaClass** wrappedClass)
+QString CppGenerator::argumentNameFromIndex(const AbstractMetaFunction *func, int argIndex, const AbstractMetaClass **wrappedClass)
 {
     *wrappedClass = 0;
     QString pyArgName;
@@ -3086,7 +3086,7 @@ QString CppGenerator::argumentNameFromIndex(const AbstractMetaFunction* func, in
         }
     } else {
         int realIndex = argIndex - 1 - OverloadData::numberOfRemovedArguments(func, argIndex - 1);
-        AbstractMetaType* argType = getTypeWithoutContainer(func->arguments().at(realIndex)->type());
+        AbstractMetaType *argType = getTypeWithoutContainer(func->arguments().at(realIndex)->type());
 
         if (argType) {
             *wrappedClass = AbstractMetaClass::findClass(classes(), argType->typeEntry());
@@ -3120,14 +3120,14 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f
         const CodeSnipList &snips = func->injectedCodeSnips();
         for (const CodeSnip &cs : snips) {
             if (cs.position == TypeSystem::CodeSnipPositionEnd) {
-                s << INDENT << "overloadId = " << func->ownerClass()->functions().indexOf(const_cast<AbstractMetaFunction* const>(func)) << ';' << endl;
+                s << INDENT << "overloadId = " << func->ownerClass()->functions().indexOf(const_cast<AbstractMetaFunction *const>(func)) << ';' << endl;
                 break;
             }
         }
     }
 
     if (func->isAbstract()) {
-        s << INDENT << "if (Shiboken::Object::hasCppWrapper(reinterpret_cast<SbkObject*>(self))) {\n";
+        s << INDENT << "if (Shiboken::Object::hasCppWrapper(reinterpret_cast<SbkObject *>(self))) {\n";
         {
             Indentation indent(INDENT);
             s << INDENT << "PyErr_SetString(PyExc_NotImplementedError, \"pure virtual method '";
@@ -3138,7 +3138,7 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f
     }
 
     // Used to provide contextual information to custom code writer function.
-    const AbstractMetaArgument* lastArg = 0;
+    const AbstractMetaArgument *lastArg = nullptr;
 
     CodeSnipList snips;
     if (func->hasInjectedCode()) {
@@ -3169,7 +3169,7 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f
         if (func->functionType() != AbstractMetaFunction::CopyConstructorFunction) {
             int removedArgs = 0;
             for (int i = 0; i < maxArgs + removedArgs; i++) {
-                const AbstractMetaArgument* arg = func->arguments().at(i);
+                const AbstractMetaArgument *arg = func->arguments().at(i);
                 bool hasConversionRule = !func->conversionRule(TypeSystem::NativeCode, arg->argumentIndex() + 1).isEmpty();
                 if (func->argumentRemoved(i + 1)) {
                     // If some argument with default value is removed from a
@@ -3207,7 +3207,7 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f
             bool otherArgsModified = false;
             bool argsClear = true;
             for (int i = func->arguments().size() - 1; i >= maxArgs + removedArgs; i--) {
-                const AbstractMetaArgument* arg = func->arguments().at(i);
+                const AbstractMetaArgument *arg = func->arguments().at(i);
                 const bool defValModified = arg->hasModifiedDefaultValueExpression();
                 bool hasConversionRule = !func->conversionRule(TypeSystem::NativeCode, arg->argumentIndex() + 1).isEmpty();
                 if (argsClear && !defValModified && !hasConversionRule)
@@ -3269,7 +3269,7 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f
                 } else {
                     QString ctorCall = className + QLatin1Char('(') + userArgs.join(QLatin1String(", ")) + QLatin1Char(')');
                     if (usePySideExtensions() && func->ownerClass()->isQObject()) {
-                        s << INDENT << "void* addr = PySide::nextQObjectMemoryAddr();" << endl;
+                        s << INDENT << "void *addr = PySide::nextQObjectMemoryAddr();" << endl;
                         uva << "if (addr) {" << endl;
                         {
                             Indentation indent(INDENT);
@@ -3318,15 +3318,15 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f
                                             : QLatin1String("reinterpret_cast<") + wrapperName(func->ownerClass())
                                               + QLatin1String(" *>(") + QLatin1String(CPP_SELF_VAR) + QLatin1Char(')');
                                         mc << wrapperName(func->ownerClass());
-                                        mc << "*>(" << selfWrapCast << ")->";
+                                        mc << " *>(" << selfWrapCast << ")->";
                                     }
                                     else {
                                         mc << methodCallClassName;
-                                        mc << "*>(" << selfVarCast << ")->";
+                                        mc << " *>(" << selfVarCast << ")->";
                                     }
                                 } else {
                                     mc << "const_cast<const ::" << methodCallClassName;
-                                    mc <<  "*>(" << selfVarCast << ")->";
+                                    mc <<  " *>(" << selfVarCast << ")->";
                                 }
                             } else {
                                 mc << selfVarCast << "->";
@@ -3342,7 +3342,7 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f
                             const auto *owner = func->ownerClass();
                             const bool directInheritance = context.metaClass() == owner;
                             mc << (directInheritance ? "static_cast" : "reinterpret_cast")
-                                << "<::" << wrapperName(owner) << "*>(" << CPP_SELF_VAR << ")->";
+                                << "<::" << wrapperName(owner) << " *>(" << CPP_SELF_VAR << ")->";
                         }
 
                         if (!func->isAbstract())
@@ -3364,7 +3364,7 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f
                                                           methodCallClassName);
                         normalCall.remove(QLatin1String("::%CLASS_NAME::"));
                         methodCall.clear();
-                        mc << "Shiboken::Object::hasCppWrapper(reinterpret_cast<SbkObject*>(self)) ? ";
+                        mc << "Shiboken::Object::hasCppWrapper(reinterpret_cast<SbkObject *>(self)) ? ";
                         mc << virtualCall << " : " <<  normalCall;
                     }
                 }
@@ -3391,7 +3391,7 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f
             } else if (func->type() && !func->isInplaceOperator()) {
                 bool writeReturnType = true;
                 if (avoidProtectedHack()) {
-                    const AbstractMetaEnum* metaEnum = findAbstractMetaEnum(func->type());
+                    const AbstractMetaEnum *metaEnum = findAbstractMetaEnum(func->type());
                     if (metaEnum) {
                         QString enumName;
                         if (metaEnum->isProtected())
@@ -3475,7 +3475,7 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f
     if (!ownership_mods.isEmpty()) {
         s << endl << INDENT << "// Ownership transferences." << endl;
         for (const ArgumentModification &arg_mod : qAsConst(ownership_mods)) {
-            const AbstractMetaClass* wrappedClass = 0;
+            const AbstractMetaClass *wrappedClass = nullptr;
             QString pyArgName = argumentNameFromIndex(func, arg_mod.index, &wrappedClass);
             if (!wrappedClass) {
                 s << "#error Invalid ownership modification for argument " << arg_mod.index << '(' << pyArgName << ')' << endl << endl;
@@ -3513,7 +3513,7 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f
                 qCWarning(lcShiboken) << "\"set\", \"add\" and \"remove\" are the only values supported by Shiboken for action attribute of reference-count tag.";
                 continue;
             }
-            const AbstractMetaClass* wrappedClass = 0;
+            const AbstractMetaClass *wrappedClass = nullptr;
 
             QString pyArgName;
             if (refCount.action == ReferenceCount::Remove) {
@@ -3531,7 +3531,7 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f
             else
                 s << INDENT << "Shiboken::Object::removeReference(";
 
-            s << "reinterpret_cast<SbkObject*>(self), \"";
+            s << "reinterpret_cast<SbkObject *>(self), \"";
             QString varName = arg_mod.referenceCounts.constFirst().varName;
             if (varName.isEmpty())
                 varName = func->minimalSignature() + QString::number(arg_mod.index);
@@ -3547,7 +3547,7 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f
     writeParentChildManagement(s, func, !hasReturnPolicy);
 }
 
-QStringList CppGenerator::getAncestorMultipleInheritance(const AbstractMetaClass* metaClass)
+QStringList CppGenerator::getAncestorMultipleInheritance(const AbstractMetaClass *metaClass)
 {
     QStringList result;
     const AbstractMetaClassList &baseClases = getBaseClasses(metaClass);
@@ -3555,13 +3555,13 @@ QStringList CppGenerator::getAncestorMultipleInheritance(const AbstractMetaClass
         for (const AbstractMetaClass *baseClass : baseClases) {
             QString offset;
             QTextStream(&offset) << "reinterpret_cast<uintptr_t>(static_cast<const "
-                << baseClass->qualifiedCppName() << "*>(class_ptr)) - base";
+                << baseClass->qualifiedCppName() << " *>(class_ptr)) - base";
             result.append(offset);
             offset.clear();
             QTextStream(&offset) << "reinterpret_cast<uintptr_t>(static_cast<const "
-                << baseClass->qualifiedCppName() << "*>(static_cast<const "
+                << baseClass->qualifiedCppName() << " *>(static_cast<const "
                 << metaClass->qualifiedCppName()
-                << "*>(static_cast<const void*>(class_ptr)))) - base";
+                << " *>(static_cast<const void *>(class_ptr)))) - base";
             result.append(offset);
         }
 
@@ -3571,7 +3571,7 @@ QStringList CppGenerator::getAncestorMultipleInheritance(const AbstractMetaClass
     return result;
 }
 
-void CppGenerator::writeMultipleInheritanceInitializerFunction(QTextStream& s, const AbstractMetaClass* metaClass)
+void CppGenerator::writeMultipleInheritanceInitializerFunction(QTextStream &s, const AbstractMetaClass *metaClass)
 {
     QString className = metaClass->qualifiedCppName();
     const QStringList ancestors = getAncestorMultipleInheritance(metaClass);
@@ -3579,14 +3579,14 @@ void CppGenerator::writeMultipleInheritanceInitializerFunction(QTextStream& s, c
     for (int i = 0; i < ancestors.size(); i++)
         s << "-1, ";
     s << "-1 };" << endl;
-    s << "int*" << endl;
-    s << multipleInheritanceInitializerFunctionName(metaClass) << "(const void* cptr)" << endl;
+    s << "int *" << endl;
+    s << multipleInheritanceInitializerFunctionName(metaClass) << "(const void *cptr)" << endl;
     s << '{' << endl;
     s << INDENT << "if (mi_offsets[0] == -1) {" << endl;
     {
         Indentation indent(INDENT);
         s << INDENT << "std::set<int> offsets;" << endl;
-        s << INDENT << "const auto* class_ptr = reinterpret_cast<const " << className << "*>(cptr);" << endl;
+        s << INDENT << "const auto *class_ptr = reinterpret_cast<const " << className << " *>(cptr);" << endl;
         s << INDENT << "const auto base = reinterpret_cast<uintptr_t>(class_ptr);" << endl;
 
         for (const QString &ancestor : ancestors)
@@ -3603,27 +3603,27 @@ void CppGenerator::writeMultipleInheritanceInitializerFunction(QTextStream& s, c
     s << '}' << endl;
 }
 
-void CppGenerator::writeSpecialCastFunction(QTextStream& s, const AbstractMetaClass* metaClass)
+void CppGenerator::writeSpecialCastFunction(QTextStream &s, const AbstractMetaClass *metaClass)
 {
     QString className = metaClass->qualifiedCppName();
-    s << "static void* " << cpythonSpecialCastFunctionName(metaClass) << "(void* obj, SbkObjectType* desiredType)\n";
+    s << "static void * " << cpythonSpecialCastFunctionName(metaClass) << "(void *obj, SbkObjectType *desiredType)\n";
     s << "{\n";
-    s << INDENT << className << "* me = reinterpret_cast< ::" << className << "*>(obj);\n";
+    s << INDENT << "auto me = reinterpret_cast< ::" << className << " *>(obj);\n";
     bool firstClass = true;
     const AbstractMetaClassList &allAncestors = getAllAncestors(metaClass);
     for (const AbstractMetaClass *baseClass : allAncestors) {
-        s << INDENT << (!firstClass ? "else " : "") << "if (desiredType == reinterpret_cast<SbkObjectType*>(" << cpythonTypeNameExt(baseClass->typeEntry()) << "))\n";
+        s << INDENT << (!firstClass ? "else " : "") << "if (desiredType == reinterpret_cast<SbkObjectType *>(" << cpythonTypeNameExt(baseClass->typeEntry()) << "))\n";
         Indentation indent(INDENT);
-        s << INDENT << "return static_cast< ::" << baseClass->qualifiedCppName() << "*>(me);\n";
+        s << INDENT << "return static_cast< ::" << baseClass->qualifiedCppName() << " *>(me);\n";
         firstClass = false;
     }
     s << INDENT << "return me;\n";
     s << "}\n\n";
 }
 
-void CppGenerator::writePrimitiveConverterInitialization(QTextStream& s, const CustomConversion* customConversion)
+void CppGenerator::writePrimitiveConverterInitialization(QTextStream &s, const CustomConversion *customConversion)
 {
-    const TypeEntry* type = customConversion->ownerType();
+    const TypeEntry *type = customConversion->ownerType();
     QString converter = converterObject(type);
     s << INDENT << "// Register converter for type '" << type->qualifiedTargetLangName() << "'." << endl;
     s << INDENT << converter << " = Shiboken::Conversions::createConverter(";
@@ -3639,30 +3639,30 @@ void CppGenerator::writePrimitiveConverterInitialization(QTextStream& s, const C
     writeCustomConverterRegister(s, customConversion, converter);
 }
 
-void CppGenerator::writeEnumConverterInitialization(QTextStream& s, const AbstractMetaEnum* metaEnum)
+void CppGenerator::writeEnumConverterInitialization(QTextStream &s, const AbstractMetaEnum *metaEnum)
 {
     if (metaEnum->isPrivate() || metaEnum->isAnonymous())
         return;
     writeEnumConverterInitialization(s, metaEnum->typeEntry());
 }
 
-void CppGenerator::writeEnumConverterInitialization(QTextStream& s, const TypeEntry* enumType)
+void CppGenerator::writeEnumConverterInitialization(QTextStream &s, const TypeEntry *enumType)
 {
     if (!enumType)
         return;
     QString enumFlagName = enumType->isFlags() ? QLatin1String("flag") : QLatin1String("enum");
     QString enumPythonType = cpythonTypeNameExt(enumType);
 
-    const FlagsTypeEntry* flags = 0;
+    const FlagsTypeEntry *flags = nullptr;
     if (enumType->isFlags())
-        flags = static_cast<const FlagsTypeEntry*>(enumType);
+        flags = static_cast<const FlagsTypeEntry *>(enumType);
 
     s << INDENT << "// Register converter for " << enumFlagName << " '" << enumType->qualifiedCppName() << "'." << endl;
     s << INDENT << '{' << endl;
     {
         Indentation indent(INDENT);
         QString typeName = fixedCppTypeName(enumType);
-        s << INDENT << "SbkConverter* converter = Shiboken::Conversions::createConverter(" << enumPythonType << ',' << endl;
+        s << INDENT << "SbkConverter *converter = Shiboken::Conversions::createConverter(" << enumPythonType << ',' << endl;
         {
             Indentation indent(INDENT);
             s << INDENT << cppToPythonFunctionName(typeName, typeName) << ");" << endl;
@@ -3714,10 +3714,10 @@ void CppGenerator::writeEnumConverterInitialization(QTextStream& s, const TypeEn
     s << INDENT << '}' << endl;
 
     if (!flags)
-        writeEnumConverterInitialization(s, static_cast<const EnumTypeEntry*>(enumType)->flags());
+        writeEnumConverterInitialization(s, static_cast<const EnumTypeEntry *>(enumType)->flags());
 }
 
-void CppGenerator::writeContainerConverterInitialization(QTextStream& s, const AbstractMetaType* type)
+void CppGenerator::writeContainerConverterInitialization(QTextStream &s, const AbstractMetaType *type)
 {
     QByteArray cppSignature = QMetaObject::normalizedSignature(type->cppSignature().toUtf8());
     s << INDENT << "// Register converter for type '" << cppSignature << "'." << endl;
@@ -3744,8 +3744,8 @@ void CppGenerator::writeContainerConverterInitialization(QTextStream& s, const A
     writeAddPythonToCppConversion(s, converterObject(type), toCpp, isConv);
 }
 
-void CppGenerator::writeExtendedConverterInitialization(QTextStream& s, const TypeEntry* externalType,
-                                                        const QVector<const AbstractMetaClass*>& conversions)
+void CppGenerator::writeExtendedConverterInitialization(QTextStream &s, const TypeEntry *externalType,
+                                                        const QVector<const AbstractMetaClass *>& conversions)
 {
     s << INDENT << "// Extended implicit conversions for " << externalType->qualifiedTargetLangName() << '.' << endl;
     for (const AbstractMetaClass *sourceClass : conversions) {
@@ -3760,14 +3760,14 @@ void CppGenerator::writeExtendedConverterInitialization(QTextStream& s, const Ty
     }
 }
 
-QString CppGenerator::multipleInheritanceInitializerFunctionName(const AbstractMetaClass* metaClass)
+QString CppGenerator::multipleInheritanceInitializerFunctionName(const AbstractMetaClass *metaClass)
 {
     return cpythonBaseName(metaClass->typeEntry()) + QLatin1String("_mi_init");
 }
 
 typedef QHash<QString, QPair<QString, QString> >::const_iterator ProtocolIt;
 
-bool CppGenerator::supportsMappingProtocol(const AbstractMetaClass* metaClass)
+bool CppGenerator::supportsMappingProtocol(const AbstractMetaClass *metaClass)
 {
     for (ProtocolIt it = m_mappingProtocol.cbegin(), end = m_mappingProtocol.cend(); it != end; ++it) {
         if (metaClass->hasFunction(it.key()))
@@ -3777,7 +3777,7 @@ bool CppGenerator::supportsMappingProtocol(const AbstractMetaClass* metaClass)
     return false;
 }
 
-bool CppGenerator::supportsNumberProtocol(const AbstractMetaClass* metaClass)
+bool CppGenerator::supportsNumberProtocol(const AbstractMetaClass *metaClass)
 {
     return metaClass->hasArithmeticOperatorOverload()
             || metaClass->hasLogicalOperatorOverload()
@@ -3785,18 +3785,18 @@ bool CppGenerator::supportsNumberProtocol(const AbstractMetaClass* metaClass)
             || hasBoolCast(metaClass);
 }
 
-bool CppGenerator::supportsSequenceProtocol(const AbstractMetaClass* metaClass)
+bool CppGenerator::supportsSequenceProtocol(const AbstractMetaClass *metaClass)
 {
     for (ProtocolIt it = m_sequenceProtocol.cbegin(), end = m_sequenceProtocol.cend(); it != end; ++it) {
         if (metaClass->hasFunction(it.key()))
             return true;
     }
 
-    const ComplexTypeEntry* baseType = metaClass->typeEntry()->baseContainerType();
+    const ComplexTypeEntry *baseType = metaClass->typeEntry()->baseContainerType();
     return baseType && baseType->isContainer();
 }
 
-bool CppGenerator::shouldGenerateGetSetList(const AbstractMetaClass* metaClass)
+bool CppGenerator::shouldGenerateGetSetList(const AbstractMetaClass *metaClass)
 {
     const AbstractMetaFieldList &fields = metaClass->fields();
     for (const AbstractMetaField *f : fields) {
@@ -3824,7 +3824,7 @@ QTextStream &operator<<(QTextStream &str, const pyTypeSlotEntry &e)
     if (e.m_function.isEmpty())
         str << NULL_PTR;
     else
-        str << "reinterpret_cast<void*>(" << e.m_function << ')';
+        str << "reinterpret_cast<void *>(" << e.m_function << ')';
     str << "},\n";
     return str;
 }
@@ -3850,7 +3850,7 @@ void CppGenerator::writeClassDefinition(QTextStream &s,
     }
 
     if (!metaClass->baseClass())
-        baseClassName = QLatin1String("reinterpret_cast<PyTypeObject*>(SbkObject_TypeF())");
+        baseClassName = QLatin1String("reinterpret_cast<PyTypeObject *>(SbkObject_TypeF())");
 
     bool onlyPrivCtor = !metaClass->hasNonPrivateConstructor();
 
@@ -3937,7 +3937,7 @@ void CppGenerator::writeClassDefinition(QTextStream &s,
     }
 
     // class or some ancestor has multiple inheritance
-    const AbstractMetaClass* miClass = getMultipleInheritingClass(metaClass);
+    const AbstractMetaClass *miClass = getMultipleInheritingClass(metaClass);
     if (miClass) {
         if (metaClass == miClass)
             writeMultipleInheritanceInitializerFunction(s, metaClass);
@@ -3951,7 +3951,7 @@ void CppGenerator::writeClassDefinition(QTextStream &s,
     if (!metaClass->typeEntry()->hashFunction().isEmpty())
         tp_hash = QLatin1Char('&') + cpythonBaseName(metaClass) + QLatin1String("_HashFunc");
 
-    const AbstractMetaFunction* callOp = metaClass->findFunction(QLatin1String("operator()"));
+    const AbstractMetaFunction *callOp = metaClass->findFunction(QLatin1String("operator()"));
     if (callOp && !callOp->isModifiedRemoved())
         tp_call = QLatin1Char('&') + cpythonFunctionName(callOp);
 
@@ -3963,7 +3963,7 @@ void CppGenerator::writeClassDefinition(QTextStream &s,
 
     QString suffix;
     if (isObjectType(metaClass))
-        suffix = QLatin1String("*");
+        suffix = QLatin1String(" *");
     const QString typePtr = QLatin1String("_") + className
         + QLatin1String("_Type");
     s << "static SbkObjectType *" << typePtr << " = nullptr;" << endl;
@@ -4021,7 +4021,7 @@ void CppGenerator::writeMappingMethods(QTextStream &s,
                                        GeneratorContext &context)
 {
     for (auto it = m_mappingProtocol.cbegin(), end = m_mappingProtocol.cend(); it != end; ++it) {
-        const AbstractMetaFunction* func = metaClass->findFunction(it.key());
+        const AbstractMetaFunction *func = metaClass->findFunction(it.key());
         if (!func)
             continue;
         QString funcName = cpythonFunctionName(func);
@@ -4034,7 +4034,7 @@ void CppGenerator::writeMappingMethods(QTextStream &s,
 
         writeCppSelfDefinition(s, func, context);
 
-        const AbstractMetaArgument* lastArg = func->arguments().isEmpty() ? 0 : func->arguments().constLast();
+        const AbstractMetaArgument *lastArg = func->arguments().isEmpty() ? nullptr : func->arguments().constLast();
         writeCodeSnips(s, snips, TypeSystem::CodeSnipPositionAny, TypeSystem::TargetLangCode, func, lastArg);
         s << '}' << endl << endl;
     }
@@ -4047,7 +4047,7 @@ void CppGenerator::writeSequenceMethods(QTextStream &s,
     bool injectedCode = false;
 
     for (auto it = m_sequenceProtocol.cbegin(), end = m_sequenceProtocol.cend(); it != end; ++it) {
-        const AbstractMetaFunction* func = metaClass->findFunction(it.key());
+        const AbstractMetaFunction *func = metaClass->findFunction(it.key());
         if (!func)
             continue;
         injectedCode = true;
@@ -4061,7 +4061,7 @@ void CppGenerator::writeSequenceMethods(QTextStream &s,
 
         writeCppSelfDefinition(s, func, context);
 
-        const AbstractMetaArgument* lastArg = func->arguments().isEmpty() ? 0 : func->arguments().constLast();
+        const AbstractMetaArgument *lastArg = func->arguments().isEmpty() ? 0 : func->arguments().constLast();
         writeCodeSnips(s, snips,TypeSystem::CodeSnipPositionAny, TypeSystem::TargetLangCode, func, lastArg);
         s << '}' << endl << endl;
     }
@@ -4070,13 +4070,13 @@ void CppGenerator::writeSequenceMethods(QTextStream &s,
         writeStdListWrapperMethods(s, context);
 }
 
-void CppGenerator::writeTypeAsSequenceDefinition(QTextStream& s, const AbstractMetaClass* metaClass)
+void CppGenerator::writeTypeAsSequenceDefinition(QTextStream &s, const AbstractMetaClass *metaClass)
 {
     bool hasFunctions = false;
     QMap<QString, QString> funcs;
     for (ProtocolIt it = m_sequenceProtocol.cbegin(), end = m_sequenceProtocol.cend(); it != end; ++it) {
         const QString &funcName = it.key();
-        const AbstractMetaFunction* func = metaClass->findFunction(funcName);
+        const AbstractMetaFunction *func = metaClass->findFunction(funcName);
         funcs[funcName] = func ? cpythonFunctionName(func).prepend(QLatin1Char('&')) : QString();
         if (!hasFunctions && func)
             hasFunctions = true;
@@ -4092,7 +4092,7 @@ void CppGenerator::writeTypeAsSequenceDefinition(QTextStream& s, const AbstractM
     }
 
     for (QHash<QString, QString>::const_iterator it = m_sqFuncs.cbegin(), end = m_sqFuncs.cend(); it != end; ++it) {
-        const QString& sqName = it.key();
+        const QString &sqName = it.key();
         if (funcs[sqName].isEmpty())
             continue;
         if (it.value() == QLatin1String("sq_slice"))
@@ -4103,13 +4103,13 @@ void CppGenerator::writeTypeAsSequenceDefinition(QTextStream& s, const AbstractM
     }
 }
 
-void CppGenerator::writeTypeAsMappingDefinition(QTextStream& s, const AbstractMetaClass* metaClass)
+void CppGenerator::writeTypeAsMappingDefinition(QTextStream &s, const AbstractMetaClass *metaClass)
 {
     bool hasFunctions = false;
     QMap<QString, QString> funcs;
     for (ProtocolIt it = m_mappingProtocol.cbegin(), end = m_mappingProtocol.cend(); it != end; ++it) {
         const QString &funcName = it.key();
-        const AbstractMetaFunction* func = metaClass->findFunction(funcName);
+        const AbstractMetaFunction *func = metaClass->findFunction(funcName);
         funcs[funcName] = func ? cpythonFunctionName(func).prepend(QLatin1Char('&')) : QLatin1String("0");
         if (!hasFunctions && func)
             hasFunctions = true;
@@ -4130,7 +4130,7 @@ void CppGenerator::writeTypeAsMappingDefinition(QTextStream& s, const AbstractMe
     }
 }
 
-void CppGenerator::writeTypeAsNumberDefinition(QTextStream& s, const AbstractMetaClass* metaClass)
+void CppGenerator::writeTypeAsNumberDefinition(QTextStream &s, const AbstractMetaClass *metaClass)
 {
     QMap<QString, QString> nb;
 
@@ -4165,7 +4165,7 @@ void CppGenerator::writeTypeAsNumberDefinition(QTextStream& s, const AbstractMet
                                            | AbstractMetaClass::BitwiseOp);
 
     for (const AbstractMetaFunctionList &opOverload : opOverloads) {
-        const AbstractMetaFunction* rfunc = opOverload[0];
+        const AbstractMetaFunction *rfunc = opOverload.at(0);
         QString opName = ShibokenGenerator::pythonOperatorFunctionName(rfunc);
         nb[opName] = cpythonFunctionName(rfunc);
     }
@@ -4208,21 +4208,21 @@ void CppGenerator::writeTypeAsNumberDefinition(QTextStream& s, const AbstractMet
     }
 }
 
-void CppGenerator::writeTpTraverseFunction(QTextStream& s, const AbstractMetaClass* metaClass)
+void CppGenerator::writeTpTraverseFunction(QTextStream &s, const AbstractMetaClass *metaClass)
 {
     QString baseName = cpythonBaseName(metaClass);
     s << "static int ";
-    s << baseName << "_traverse(PyObject* self, visitproc visit, void* arg)" << endl;
+    s << baseName << "_traverse(PyObject *self, visitproc visit, void *arg)" << endl;
     s << '{' << endl;
     s << INDENT << "return reinterpret_cast<PyTypeObject *>(SbkObject_TypeF())->tp_traverse(self, visit, arg);" << endl;
     s << '}' << endl;
 }
 
-void CppGenerator::writeTpClearFunction(QTextStream& s, const AbstractMetaClass* metaClass)
+void CppGenerator::writeTpClearFunction(QTextStream &s, const AbstractMetaClass *metaClass)
 {
     QString baseName = cpythonBaseName(metaClass);
     s << "static int ";
-    s << baseName << "_clear(PyObject* self)" << endl;
+    s << baseName << "_clear(PyObject *self)" << endl;
     s << '{' << endl;
     s << INDENT << "return reinterpret_cast<PyTypeObject *>(SbkObject_TypeF())->tp_clear(self);" << endl;
     s << '}' << endl;
@@ -4232,7 +4232,7 @@ void CppGenerator::writeCopyFunction(QTextStream &s, GeneratorContext &context)
 {
     const AbstractMetaClass *metaClass = context.metaClass();
     const QString className = chopType(cpythonTypeName(metaClass));
-    s << "static PyObject* " << className << "___copy__(PyObject* self)" << endl;
+    s << "static PyObject *" << className << "___copy__(PyObject *self)" << endl;
     s << "{" << endl;
     writeCppSelfDefinition(s, context, false, true);
     QString conversionCode;
@@ -4241,7 +4241,7 @@ void CppGenerator::writeCopyFunction(QTextStream &s, GeneratorContext &context)
     else
         conversionCode = cpythonToPythonConversionFunction(context.preciseType());
 
-    s << INDENT << "PyObject* " << PYTHON_RETURN_VAR << " = " << conversionCode;
+    s << INDENT << "PyObject *" << PYTHON_RETURN_VAR << " = " << conversionCode;
     s << CPP_SELF_VAR << ");" << endl;
     writeFunctionReturnErrorCheckSection(s);
     s << INDENT << "return " << PYTHON_RETURN_VAR << ";" << endl;
@@ -4254,19 +4254,19 @@ void CppGenerator::writeGetterFunction(QTextStream &s,
                                        GeneratorContext &context)
 {
     ErrorCode errorCode(QString::fromLatin1(NULL_PTR));
-    s << "static PyObject* " << cpythonGetterFunctionName(metaField) << "(PyObject* self, void*)" << endl;
+    s << "static PyObject *" << cpythonGetterFunctionName(metaField) << "(PyObject *self, void *)" << endl;
     s << '{' << endl;
 
     writeCppSelfDefinition(s, context);
 
-    AbstractMetaType* fieldType = metaField->type();
+    AbstractMetaType *fieldType = metaField->type();
     // Force use of pointer to return internal variable memory
     bool newWrapperSameObject = !fieldType->isConstant() && isWrapperType(fieldType) && !isPointer(fieldType);
 
     QString cppField;
     if (avoidProtectedHack() && metaField->isProtected()) {
         QTextStream(&cppField) << "static_cast<"
-            << wrapperName(metaField->enclosingClass()) << "*>("
+            << wrapperName(metaField->enclosingClass()) << " *>("
             << CPP_SELF_VAR << ")->" << protectedFieldGetterName(metaField) << "()";
     } else {
         cppField = QLatin1String(CPP_SELF_VAR) + QLatin1String("->") + metaField->name();
@@ -4281,16 +4281,16 @@ void CppGenerator::writeGetterFunction(QTextStream &s,
     } else if (avoidProtectedHack() && metaField->isProtected()) {
         s << INDENT << getFullTypeNameWithoutModifiers(fieldType);
         if (fieldType->isContainer() || fieldType->isFlags() || fieldType->isSmartPointer()) {
-            s << '&';
+            s << " &";
             cppField.prepend(QLatin1Char('*'));
         } else if ((!fieldType->isConstant() && !fieldType->isEnum() && !fieldType->isPrimitive()) || fieldType->indirections() == 1) {
-            s << '*';
+            s << " *";
         }
         s << " fieldValue = " << cppField << ';' << endl;
         cppField = QLatin1String("fieldValue");
     }
 
-    s << INDENT << "PyObject* pyOut = {};\n";
+    s << INDENT << "PyObject *pyOut = {};\n";
     if (newWrapperSameObject) {
         // Special case colocated field with same address (first field in a struct)
         s << INDENT << "if (reinterpret_cast<void *>("
@@ -4310,7 +4310,7 @@ void CppGenerator::writeGetterFunction(QTextStream &s,
         s << INDENT << "else if (Shiboken::BindingManager::instance().hasWrapper(" << cppField << ")) {" << "\n";
         {
             Indentation indent(INDENT);
-            s << INDENT << "pyOut = reinterpret_cast<PyObject*>(Shiboken::BindingManager::instance().retrieveWrapper("
+            s << INDENT << "pyOut = reinterpret_cast<PyObject *>(Shiboken::BindingManager::instance().retrieveWrapper("
                 << cppField << "));" << "\n";
             s << INDENT << "Py_IncRef(pyOut);" << "\n";
             s << INDENT << "return pyOut;" << "\n";
@@ -4336,7 +4336,7 @@ void CppGenerator::writeSetterFunction(QTextStream &s,
                                        GeneratorContext &context)
 {
     ErrorCode errorCode(0);
-    s << "static int " << cpythonSetterFunctionName(metaField) << "(PyObject* self, PyObject* pyIn, void*)" << endl;
+    s << "static int " << cpythonSetterFunctionName(metaField) << "(PyObject *self, PyObject *pyIn, void *)" << endl;
     s << '{' << endl;
 
     writeCppSelfDefinition(s, context);
@@ -4350,7 +4350,7 @@ void CppGenerator::writeSetterFunction(QTextStream &s,
     }
     s << INDENT << '}' << endl;
 
-    AbstractMetaType* fieldType = metaField->type();
+    AbstractMetaType *fieldType = metaField->type();
 
     s << INDENT << "PythonToCppFunc " << PYTHON_TO_CPP_VAR << "{nullptr};" << endl;
     s << INDENT << "if (!";
@@ -4368,10 +4368,10 @@ void CppGenerator::writeSetterFunction(QTextStream &s,
     s << INDENT;
     if (avoidProtectedHack() && metaField->isProtected()) {
         s << getFullTypeNameWithoutModifiers(fieldType);
-        s << (fieldType->indirections() == 1 ? "*" : "") << " cppOut;" << endl;
+        s << (fieldType->indirections() == 1 ? " *" : "") << " cppOut;" << endl;
         s << INDENT << PYTHON_TO_CPP_VAR << "(pyIn, &cppOut);" << endl;
         s << INDENT << "static_cast<" << wrapperName(metaField->enclosingClass())
-            << "*>(" << CPP_SELF_VAR << ")->" << protectedFieldSetterName(metaField)
+            << " *>(" << CPP_SELF_VAR << ")->" << protectedFieldSetterName(metaField)
             << "(cppOut)";
     } else if (isCppIntegralPrimitive(fieldType) || fieldType->typeEntry()->isEnum() || fieldType->typeEntry()->isFlags()) {
         s << getFullTypeNameWithoutModifiers(fieldType) << " cppOut_local = " << cppField << ';' << endl;
@@ -4381,14 +4381,14 @@ void CppGenerator::writeSetterFunction(QTextStream &s,
         if (isPointerToConst(fieldType))
             s << "const ";
         s << getFullTypeNameWithoutModifiers(fieldType);
-        s << QString::fromLatin1("*").repeated(fieldType->indirections()) << "& cppOut_ptr = ";
+        s << QString::fromLatin1(" *").repeated(fieldType->indirections()) << "& cppOut_ptr = ";
         s << cppField << ';' << endl;
         s << INDENT << PYTHON_TO_CPP_VAR << "(pyIn, &cppOut_ptr)";
     }
     s << ';' << endl << endl;
 
     if (isPointerToWrapperType(fieldType)) {
-        s << INDENT << "Shiboken::Object::keepReference(reinterpret_cast<SbkObject*>(self), \"";
+        s << INDENT << "Shiboken::Object::keepReference(reinterpret_cast<SbkObject *>(self), \"";
         s << metaField->name() << "\", pyIn);" << endl;
     }
 
@@ -4400,12 +4400,12 @@ void CppGenerator::writeRichCompareFunction(QTextStream &s, GeneratorContext &co
 {
     const AbstractMetaClass *metaClass = context.metaClass();
     QString baseName = cpythonBaseName(metaClass);
-    s << "static PyObject* ";
-    s << baseName << "_richcompare(PyObject* self, PyObject* " << PYTHON_ARG << ", int op)" << endl;
+    s << "static PyObject * ";
+    s << baseName << "_richcompare(PyObject *self, PyObject *" << PYTHON_ARG << ", int op)" << endl;
     s << '{' << endl;
     writeCppSelfDefinition(s, context, false, true);
     writeUnusedVariableCast(s, QLatin1String(CPP_SELF_VAR));
-    s << INDENT << "PyObject* " << PYTHON_RETURN_VAR << "{};" << endl;
+    s << INDENT << "PyObject *" << PYTHON_RETURN_VAR << "{};" << endl;
     s << INDENT << "PythonToCppFunc " << PYTHON_TO_CPP_VAR << ';' << endl;
     writeUnusedVariableCast(s, QLatin1String(PYTHON_TO_CPP_VAR));
     s << endl;
@@ -4415,7 +4415,7 @@ void CppGenerator::writeRichCompareFunction(QTextStream &s, GeneratorContext &co
         Indentation indent(INDENT);
         const QVector<AbstractMetaFunctionList> &groupedFuncs = filterGroupedOperatorFunctions(metaClass, AbstractMetaClass::ComparisonOp);
         for (const AbstractMetaFunctionList &overloads : groupedFuncs) {
-            const AbstractMetaFunction* rfunc = overloads[0];
+            const AbstractMetaFunction *rfunc = overloads[0];
 
             QString operatorId = ShibokenGenerator::pythonRichCompareOperatorId(rfunc);
             s << INDENT << "case " << operatorId << ':' << endl;
@@ -4436,10 +4436,10 @@ void CppGenerator::writeRichCompareFunction(QTextStream &s, GeneratorContext &co
             OverloadData overloadData(overloads, this);
             const OverloadDataList &nextOverloads = overloadData.nextOverloadData();
             for (OverloadData *od : nextOverloads) {
-                const AbstractMetaFunction* func = od->referenceFunction();
+                const AbstractMetaFunction *func = od->referenceFunction();
                 if (func->isStatic())
                     continue;
-                const AbstractMetaType* argType = getArgumentType(func, 1);
+                const AbstractMetaType *argType = getArgumentType(func, 1);
                 if (!argType)
                     continue;
                 if (!first) {
@@ -4517,12 +4517,12 @@ void CppGenerator::writeRichCompareFunction(QTextStream &s, GeneratorContext &co
     s << '}' << endl << endl;
 }
 
-void CppGenerator::writeMethodDefinitionEntry(QTextStream& s, const AbstractMetaFunctionList &overloads)
+void CppGenerator::writeMethodDefinitionEntry(QTextStream &s, const AbstractMetaFunctionList &overloads)
 {
     Q_ASSERT(!overloads.isEmpty());
     OverloadData overloadData(overloads, this);
     bool usePyArgs = pythonFunctionWrapperUsesListOfArguments(overloadData);
-    const AbstractMetaFunction* func = overloadData.referenceFunction();
+    const AbstractMetaFunction *func = overloadData.referenceFunction();
     int min = overloadData.minArgs();
     int max = overloadData.maxArgs();
 
@@ -4542,10 +4542,10 @@ void CppGenerator::writeMethodDefinitionEntry(QTextStream& s, const AbstractMeta
         s << "|METH_STATIC";
 }
 
-void CppGenerator::writeMethodDefinition(QTextStream& s, const AbstractMetaFunctionList &overloads)
+void CppGenerator::writeMethodDefinition(QTextStream &s, const AbstractMetaFunctionList &overloads)
 {
     Q_ASSERT(!overloads.isEmpty());
-    const AbstractMetaFunction* func = overloads.constFirst();
+    const AbstractMetaFunction *func = overloads.constFirst();
     if (m_tpFuncs.contains(func->name()))
         return;
 
@@ -4566,7 +4566,7 @@ static QString resolveRetOrArgType(const AbstractMetaType *someType)
     if (CppGenerator::isCString(someType)) {
         strRetArg = QLatin1String("str");
     } else if (someType->isPrimitive()) {
-        const PrimitiveTypeEntry* ptp = static_cast<const PrimitiveTypeEntry*>(someType->typeEntry());
+        auto ptp = static_cast<const PrimitiveTypeEntry *>(someType->typeEntry());
         while (ptp->referencedTypeEntry())
             ptp = ptp->referencedTypeEntry();
         strRetArg = ptp->name();
@@ -4580,7 +4580,7 @@ static QString resolveRetOrArgType(const AbstractMetaType *someType)
 void CppGenerator::writeSignatureInfo(QTextStream &s, const AbstractMetaFunctionList &overloads)
 {
     OverloadData overloadData(overloads, this);
-    const AbstractMetaFunction* rfunc = overloadData.referenceFunction();
+    const AbstractMetaFunction *rfunc = overloadData.referenceFunction();
     QString funcName = fullPythonFunctionName(rfunc);
 
     int idx = overloads.length() - 1;
@@ -4619,7 +4619,7 @@ void CppGenerator::writeSignatureInfo(QTextStream &s, const AbstractMetaFunction
     }
 }
 
-void CppGenerator::writeEnumsInitialization(QTextStream& s, AbstractMetaEnumList& enums)
+void CppGenerator::writeEnumsInitialization(QTextStream &s, AbstractMetaEnumList &enums)
 {
     if (enums.isEmpty())
         return;
@@ -4631,10 +4631,10 @@ void CppGenerator::writeEnumsInitialization(QTextStream& s, AbstractMetaEnumList
     }
 }
 
-void CppGenerator::writeEnumInitialization(QTextStream& s, const AbstractMetaEnum* cppEnum)
+void CppGenerator::writeEnumInitialization(QTextStream &s, const AbstractMetaEnum *cppEnum)
 {
-    const AbstractMetaClass* enclosingClass = getProperEnclosingClassForEnum(cppEnum);
-    const AbstractMetaClass* upper = enclosingClass ? enclosingClass->enclosingClass() : 0;
+    const AbstractMetaClass *enclosingClass = getProperEnclosingClassForEnum(cppEnum);
+    const AbstractMetaClass *upper = enclosingClass ? enclosingClass->enclosingClass() : nullptr;
     bool hasUpperEnclosingClass = upper && upper->typeEntry()->codeGeneration() != TypeEntry::GenerateForSubclass;
     const EnumTypeEntry *enumTypeEntry = cppEnum->typeEntry();
     QString enclosingObjectVariable;
@@ -4651,7 +4651,7 @@ void CppGenerator::writeEnumInitialization(QTextStream& s, const AbstractMetaEnu
 
     QString enumVarTypeObj;
     if (!cppEnum->isAnonymous()) {
-        FlagsTypeEntry* flags = enumTypeEntry->flags();
+        FlagsTypeEntry *flags = enumTypeEntry->flags();
         if (flags) {
             // The following could probably be made nicer:
             // We need 'flags->flagsName()' with the full module/class path.
@@ -4708,7 +4708,7 @@ void CppGenerator::writeEnumInitialization(QTextStream& s, const AbstractMetaEnu
                 s << INDENT << '{' << endl;
                 {
                     Indentation indent(INDENT);
-                    s << INDENT << "PyObject* anonEnumItem = PyInt_FromLong(" << enumValueText << ");" << endl;
+                    s << INDENT << "PyObject *anonEnumItem = PyInt_FromLong(" << enumValueText << ");" << endl;
                     s << INDENT << "if (PyDict_SetItemString(reinterpret_cast<PyTypeObject *>(reinterpret_cast<SbkObjectType *>(" << enclosingObjectVariable
                         << "))->tp_dict, \"" << enumValue->name() << "\", anonEnumItem) < 0)" << endl;
                     {
@@ -4757,7 +4757,7 @@ void CppGenerator::writeEnumInitialization(QTextStream& s, const AbstractMetaEnu
     s << '.' << endl << endl;
 }
 
-void CppGenerator::writeSignalInitialization(QTextStream& s, const AbstractMetaClass* metaClass)
+void CppGenerator::writeSignalInitialization(QTextStream &s, const AbstractMetaClass *metaClass)
 {
     // Try to check something and print some warnings
     const AbstractMetaFunctionList &signalFuncs = metaClass->cppSignalFunctions();
@@ -4766,7 +4766,7 @@ void CppGenerator::writeSignalInitialization(QTextStream& s, const AbstractMetaC
             continue;
         const AbstractMetaArgumentList &arguments = cppSignal->arguments();
         for (AbstractMetaArgument *arg : arguments) {
-            AbstractMetaType* metaType = arg->type();
+            AbstractMetaType *metaType = arg->type();
             const QByteArray origType =
                 QMetaObject::normalizedType(qPrintable(metaType->originalTypeDescription()));
             const QByteArray cppSig =
@@ -4783,36 +4783,36 @@ void CppGenerator::writeSignalInitialization(QTextStream& s, const AbstractMetaC
                 << metaClass->qualifiedCppName() << "::staticMetaObject);" << endl;
 }
 
-void CppGenerator::writeFlagsToLong(QTextStream& s, const AbstractMetaEnum* cppEnum)
+void CppGenerator::writeFlagsToLong(QTextStream &s, const AbstractMetaEnum *cppEnum)
 {
-    FlagsTypeEntry* flagsEntry = cppEnum->typeEntry()->flags();
+    FlagsTypeEntry *flagsEntry = cppEnum->typeEntry()->flags();
     if (!flagsEntry)
         return;
-    s << "static PyObject* " << cpythonEnumName(cppEnum) << "_long(PyObject* self)" << endl;
+    s << "static PyObject *" << cpythonEnumName(cppEnum) << "_long(PyObject *self)" << endl;
     s << "{" << endl;
     s << INDENT << "int val;" << endl;
-    AbstractMetaType* flagsType = buildAbstractMetaTypeFromTypeEntry(flagsEntry);
+    AbstractMetaType *flagsType = buildAbstractMetaTypeFromTypeEntry(flagsEntry);
     s << INDENT << cpythonToCppConversionFunction(flagsType) << "self, &val);" << endl;
     s << INDENT << "return Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<int>(), &val);" << endl;
     s << "}" << endl;
 }
 
-void CppGenerator::writeFlagsNonZero(QTextStream& s, const AbstractMetaEnum* cppEnum)
+void CppGenerator::writeFlagsNonZero(QTextStream &s, const AbstractMetaEnum *cppEnum)
 {
-    FlagsTypeEntry* flagsEntry = cppEnum->typeEntry()->flags();
+    FlagsTypeEntry *flagsEntry = cppEnum->typeEntry()->flags();
     if (!flagsEntry)
         return;
-    s << "static int " << cpythonEnumName(cppEnum) << "__nonzero(PyObject* self)" << endl;
+    s << "static int " << cpythonEnumName(cppEnum) << "__nonzero(PyObject *self)" << endl;
     s << "{" << endl;
 
     s << INDENT << "int val;" << endl;
-    AbstractMetaType* flagsType = buildAbstractMetaTypeFromTypeEntry(flagsEntry);
+    AbstractMetaType *flagsType = buildAbstractMetaTypeFromTypeEntry(flagsEntry);
     s << INDENT << cpythonToCppConversionFunction(flagsType) << "self, &val);" << endl;
     s << INDENT << "return val != 0;" << endl;
     s << "}" << endl;
 }
 
-void CppGenerator::writeFlagsMethods(QTextStream& s, const AbstractMetaEnum* cppEnum)
+void CppGenerator::writeFlagsMethods(QTextStream &s, const AbstractMetaEnum *cppEnum)
 {
     writeFlagsBinaryOperator(s, cppEnum, QLatin1String("and"), QLatin1String("&"));
     writeFlagsBinaryOperator(s, cppEnum, QLatin1String("or"), QLatin1String("|"));
@@ -4825,7 +4825,7 @@ void CppGenerator::writeFlagsMethods(QTextStream& s, const AbstractMetaEnum* cpp
     s << endl;
 }
 
-void CppGenerator::writeFlagsNumberMethodsDefinition(QTextStream& s, const AbstractMetaEnum* cppEnum)
+void CppGenerator::writeFlagsNumberMethodsDefinition(QTextStream &s, const AbstractMetaEnum *cppEnum)
 {
     QString cpythonName = cpythonEnumName(cppEnum);
 
@@ -4848,16 +4848,16 @@ void CppGenerator::writeFlagsNumberMethodsDefinition(QTextStream& s, const Abstr
     s << "};" << endl << endl;
 }
 
-void CppGenerator::writeFlagsBinaryOperator(QTextStream& s, const AbstractMetaEnum* cppEnum,
+void CppGenerator::writeFlagsBinaryOperator(QTextStream &s, const AbstractMetaEnum *cppEnum,
                                             const QString &pyOpName, const QString &cppOpName)
 {
-    FlagsTypeEntry* flagsEntry = cppEnum->typeEntry()->flags();
+    FlagsTypeEntry *flagsEntry = cppEnum->typeEntry()->flags();
     Q_ASSERT(flagsEntry);
 
-    s << "PyObject* " << cpythonEnumName(cppEnum) << "___" << pyOpName << "__(PyObject* self, PyObject* " << PYTHON_ARG << ")" << endl;
+    s << "PyObject * " << cpythonEnumName(cppEnum) << "___" << pyOpName << "__(PyObject *self, PyObject *" << PYTHON_ARG << ")" << endl;
     s << '{' << endl;
 
-    AbstractMetaType* flagsType = buildAbstractMetaTypeFromTypeEntry(flagsEntry);
+    AbstractMetaType *flagsType = buildAbstractMetaTypeFromTypeEntry(flagsEntry);
     s << INDENT << "::" << flagsEntry->originalName() << " cppResult, " << CPP_SELF_VAR << ", cppArg;" << endl;
     s << "#ifdef IS_PY3K" << endl;
     s << INDENT << CPP_SELF_VAR << " = static_cast<::" << flagsEntry->originalName()
@@ -4877,17 +4877,17 @@ void CppGenerator::writeFlagsBinaryOperator(QTextStream& s, const AbstractMetaEn
     s << '}' << endl << endl;
 }
 
-void CppGenerator::writeFlagsUnaryOperator(QTextStream& s, const AbstractMetaEnum* cppEnum,
+void CppGenerator::writeFlagsUnaryOperator(QTextStream &s, const AbstractMetaEnum *cppEnum,
                                            const QString &pyOpName,
                                            const QString &cppOpName, bool boolResult)
 {
-    FlagsTypeEntry* flagsEntry = cppEnum->typeEntry()->flags();
+    FlagsTypeEntry *flagsEntry = cppEnum->typeEntry()->flags();
     Q_ASSERT(flagsEntry);
 
-    s << "PyObject* " << cpythonEnumName(cppEnum) << "___" << pyOpName << "__(PyObject* self, PyObject* " << PYTHON_ARG << ")" << endl;
+    s << "PyObject *" << cpythonEnumName(cppEnum) << "___" << pyOpName << "__(PyObject *self, PyObject *" << PYTHON_ARG << ")" << endl;
     s << '{' << endl;
 
-    AbstractMetaType* flagsType = buildAbstractMetaTypeFromTypeEntry(flagsEntry);
+    AbstractMetaType *flagsType = buildAbstractMetaTypeFromTypeEntry(flagsEntry);
     s << INDENT << "::" << flagsEntry->originalName() << " " << CPP_SELF_VAR << ";" << endl;
     s << INDENT << cpythonToCppConversionFunction(flagsType) << "self, &" << CPP_SELF_VAR << ");" << endl;
     s << INDENT;
@@ -4928,9 +4928,9 @@ void CppGenerator::writeClassRegister(QTextStream &s,
                                       GeneratorContext &classContext,
                                       QTextStream &signatureStream)
 {
-    const ComplexTypeEntry* classTypeEntry = metaClass->typeEntry();
+    const ComplexTypeEntry *classTypeEntry = metaClass->typeEntry();
 
-    const AbstractMetaClass* enc = metaClass->enclosingClass();
+    const AbstractMetaClass *enc = metaClass->enclosingClass();
     bool hasEnclosingClass = enc && enc->typeEntry()->codeGeneration() != TypeEntry::GenerateForSubclass;
     QString enclosingObjectVariable = hasEnclosingClass ? QLatin1String("enclosingClass") : QLatin1String("module");
 
@@ -4946,20 +4946,20 @@ void CppGenerator::writeClassRegister(QTextStream &s,
         s << INDENT << '"' << line << "\"," << endl;
     s << INDENT << NULL_PTR << "}; // Sentinel" << endl << endl;
     s << "void init_" << initFunctionName;
-    s << "(PyObject* " << enclosingObjectVariable << ")" << endl;
+    s << "(PyObject *" << enclosingObjectVariable << ")" << endl;
     s << '{' << endl;
 
     // Multiple inheritance
     QString pyTypeBasesVariable = chopType(pyTypeName) + QLatin1String("_Type_bases");
     const AbstractMetaClassList baseClasses = getBaseClasses(metaClass);
     if (metaClass->baseClassNames().size() > 1) {
-        s << INDENT << "PyObject* " << pyTypeBasesVariable
+        s << INDENT << "PyObject *" << pyTypeBasesVariable
             << " = PyTuple_Pack(" << baseClasses.size() << ',' << endl;
         Indentation indent(INDENT);
         for (int i = 0, size = baseClasses.size(); i < size; ++i) {
             if (i)
                 s << "," << endl;
-            s << INDENT << "reinterpret_cast<PyObject*>("
+            s << INDENT << "reinterpret_cast<PyObject *>("
                 << cpythonTypeNameExt(baseClasses.at(i)->typeEntry()) << ')';
         }
         s << ");" << endl << endl;
@@ -5048,7 +5048,7 @@ void CppGenerator::writeClassRegister(QTextStream &s,
         s << INDENT << cpythonTypeNameExt(classTypeEntry) << endl;
     else
         s << INDENT << cpythonTypeNameExt(classContext.preciseType()) << endl;
-    s << INDENT << "    = reinterpret_cast<PyTypeObject*>(" << pyTypeName << ");" << endl;
+    s << INDENT << "    = reinterpret_cast<PyTypeObject *>(" << pyTypeName << ");" << endl;
     s << endl;
 
     // Register conversions for the type.
@@ -5062,13 +5062,13 @@ void CppGenerator::writeClassRegister(QTextStream &s,
     }
 
     // Fill multiple inheritance data, if needed.
-    const AbstractMetaClass* miClass = getMultipleInheritingClass(metaClass);
+    const AbstractMetaClass *miClass = getMultipleInheritingClass(metaClass);
     if (miClass) {
         s << INDENT << "MultipleInheritanceInitFunction func = ";
         if (miClass == metaClass) {
             s << multipleInheritanceInitializerFunctionName(miClass) << ";" << endl;
         } else {
-            s << "Shiboken::ObjectType::getMultipleInheritanceFunction(reinterpret_cast<SbkObjectType*>(";
+            s << "Shiboken::ObjectType::getMultipleInheritanceFunction(reinterpret_cast<SbkObjectType *>(";
             s << cpythonTypeNameExt(miClass->typeEntry()) << "));" << endl;
         }
         s << INDENT << "Shiboken::ObjectType::setMultipleInheritanceFunction(";
@@ -5130,7 +5130,7 @@ void CppGenerator::writeClassRegister(QTextStream &s,
 
 void CppGenerator::writeInitQtMetaTypeFunctionBody(QTextStream &s, GeneratorContext &context) const
 {
-    const AbstractMetaClass* metaClass = context.metaClass();
+    const AbstractMetaClass *metaClass = context.metaClass();
     // Gets all class name variants used on different possible scopes
     QStringList nameVariants;
     if (!context.forSmartPointer())
@@ -5138,7 +5138,7 @@ void CppGenerator::writeInitQtMetaTypeFunctionBody(QTextStream &s, GeneratorCont
     else
         nameVariants << context.preciseType()->cppSignature();
 
-    const AbstractMetaClass* enclosingClass = metaClass->enclosingClass();
+    const AbstractMetaClass *enclosingClass = metaClass->enclosingClass();
     while (enclosingClass) {
         if (enclosingClass->typeEntry()->generateCode())
             nameVariants << (enclosingClass->name() + QLatin1String("::") + nameVariants.constLast());
@@ -5194,17 +5194,17 @@ void CppGenerator::writeInitQtMetaTypeFunctionBody(QTextStream &s, GeneratorCont
     }
 }
 
-void CppGenerator::writeTypeDiscoveryFunction(QTextStream& s, const AbstractMetaClass* metaClass)
+void CppGenerator::writeTypeDiscoveryFunction(QTextStream &s, const AbstractMetaClass *metaClass)
 {
     QString polymorphicExpr = metaClass->typeEntry()->polymorphicIdValue();
 
-    s << "static void* " << cpythonBaseName(metaClass) << "_typeDiscovery(void* cptr, SbkObjectType* instanceType)\n{" << endl;
+    s << "static void *" << cpythonBaseName(metaClass) << "_typeDiscovery(void *cptr, SbkObjectType *instanceType)\n{" << endl;
 
     if (!polymorphicExpr.isEmpty()) {
         polymorphicExpr = polymorphicExpr.replace(QLatin1String("%1"),
                                                   QLatin1String(" reinterpret_cast< ::")
                                                   + metaClass->qualifiedCppName()
-                                                  + QLatin1String("*>(cptr)"));
+                                                  + QLatin1String(" *>(cptr)"));
         s << INDENT << " if (" << polymorphicExpr << ")" << endl;
         {
             Indentation indent(INDENT);
@@ -5216,11 +5216,11 @@ void CppGenerator::writeTypeDiscoveryFunction(QTextStream& s, const AbstractMeta
             if (ancestor->baseClass())
                 continue;
             if (ancestor->isPolymorphic()) {
-                s << INDENT << "if (instanceType == reinterpret_cast<SbkObjectType*>(Shiboken::SbkType< ::"
+                s << INDENT << "if (instanceType == reinterpret_cast<SbkObjectType *>(Shiboken::SbkType< ::"
                             << ancestor->qualifiedCppName() << " >()))" << endl;
                 Indentation indent(INDENT);
                 s << INDENT << "return dynamic_cast< ::" << metaClass->qualifiedCppName()
-                            << "*>(reinterpret_cast< ::"<< ancestor->qualifiedCppName() << "*>(cptr));" << endl;
+                            << " *>(reinterpret_cast< ::"<< ancestor->qualifiedCppName() << " *>(cptr));" << endl;
             } else {
                 qCWarning(lcShiboken).noquote().nospace()
                     << metaClass->qualifiedCppName() << " inherits from a non polymorphic type ("
@@ -5242,14 +5242,14 @@ QString CppGenerator::writeSmartPointerGetterCast()
 
 void CppGenerator::writeSetattroFunction(QTextStream &s, GeneratorContext &context)
 {
-    const AbstractMetaClass* metaClass = context.metaClass();
-    s << "static int " << cpythonSetattroFunctionName(metaClass) << "(PyObject* self, PyObject* name, PyObject* value)" << endl;
+    const AbstractMetaClass *metaClass = context.metaClass();
+    s << "static int " << cpythonSetattroFunctionName(metaClass) << "(PyObject *self, PyObject *name, PyObject *value)" << endl;
     s << '{' << endl;
     if (usePySideExtensions()) {
-        s << INDENT << "Shiboken::AutoDecRef pp(reinterpret_cast<PyObject*>(PySide::Property::getObject(self, name)));" << endl;
+        s << INDENT << "Shiboken::AutoDecRef pp(reinterpret_cast<PyObject *>(PySide::Property::getObject(self, name)));" << endl;
         s << INDENT << "if (!pp.isNull())" << endl;
         Indentation indent(INDENT);
-        s << INDENT << "return PySide::Property::setValue(reinterpret_cast<PySideProperty*>(pp.object()), self, value);" << endl;
+        s << INDENT << "return PySide::Property::setValue(reinterpret_cast<PySideProperty *>(pp.object()), self, value);" << endl;
     }
 
     if (context.forSmartPointer()) {
@@ -5279,10 +5279,10 @@ void CppGenerator::writeSetattroFunction(QTextStream &s, GeneratorContext &conte
 static inline QString qObjectClassName() { return QStringLiteral("QObject"); }
 static inline QString qMetaObjectClassName() { return QStringLiteral("QMetaObject"); }
 
-void CppGenerator::writeGetattroFunction(QTextStream& s, GeneratorContext &context)
+void CppGenerator::writeGetattroFunction(QTextStream &s, GeneratorContext &context)
 {
-    const AbstractMetaClass* metaClass = context.metaClass();
-    s << "static PyObject* " << cpythonGetattroFunctionName(metaClass) << "(PyObject* self, PyObject* name)" << endl;
+    const AbstractMetaClass *metaClass = context.metaClass();
+    s << "static PyObject *" << cpythonGetattroFunctionName(metaClass) << "(PyObject *self, PyObject *name)" << endl;
     s << '{' << endl;
 
     QString getattrFunc;
@@ -5301,10 +5301,10 @@ void CppGenerator::writeGetattroFunction(QTextStream& s, GeneratorContext &conte
         {
             Indentation indent(INDENT);
             s << INDENT << "// Search the method in the instance dict" << endl;
-            s << INDENT << "if (reinterpret_cast<SbkObject*>(self)->ob_dict) {" << endl;
+            s << INDENT << "if (reinterpret_cast<SbkObject *>(self)->ob_dict) {" << endl;
             {
                 Indentation indent(INDENT);
-                s << INDENT << "PyObject* meth = PyDict_GetItem(reinterpret_cast<SbkObject*>(self)->ob_dict, name);" << endl;
+                s << INDENT << "PyObject *meth = PyDict_GetItem(reinterpret_cast<SbkObject *>(self)->ob_dict, name);" << endl;
                 s << INDENT << "if (meth) {" << endl;
                 {
                     Indentation indent(INDENT);
@@ -5463,7 +5463,7 @@ bool CppGenerator::finishGeneration()
 
         const QString initFunctionName = QLatin1String("init_") + getSimpleClassInitFunctionName(cls);
 
-        s_classInitDecl << "void " << initFunctionName << "(PyObject* module);" << endl;
+        s_classInitDecl << "void " << initFunctionName << "(PyObject *module);" << endl;
 
         s_classPythonDefines << INDENT << initFunctionName;
         if (cls->enclosingClass()
@@ -5481,7 +5481,7 @@ bool CppGenerator::finishGeneration()
     for (const AbstractMetaType *metaType : smartPtrs) {
         GeneratorContext context(0, metaType, true);
         QString initFunctionName = getInitFunctionName(context);
-        s_classInitDecl << "void init_" << initFunctionName << "(PyObject* module);" << endl;
+        s_classInitDecl << "void init_" << initFunctionName << "(PyObject *module);" << endl;
         QString defineStr = QLatin1String("init_") + initFunctionName;
         defineStr += QLatin1String("(module);");
         s_classPythonDefines << INDENT << defineStr << endl;
@@ -5518,13 +5518,13 @@ bool CppGenerator::finishGeneration()
     AbstractMetaEnumList globalEnums = this->globalEnums();
     const AbstractMetaClassList &classList = classes();
     for (const AbstractMetaClass *metaClass : classList) {
-        const AbstractMetaClass* encClass = metaClass->enclosingClass();
+        const AbstractMetaClass *encClass = metaClass->enclosingClass();
         if (encClass && encClass->typeEntry()->codeGeneration() != TypeEntry::GenerateForSubclass)
             continue;
         lookForEnumsInClassesNotToBeGenerated(globalEnums, metaClass);
     }
 
-    TypeDatabase* typeDb = TypeDatabase::instance();
+    TypeDatabase *typeDb = TypeDatabase::instance();
     const TypeSystemTypeEntry *moduleEntry = typeDb->defaultTypeSystemType();
     Q_ASSERT(moduleEntry);
 
@@ -5539,13 +5539,13 @@ bool CppGenerator::finishGeneration()
     s << endl;
 
     s << "// Current module's type array." << endl;
-    s << "PyTypeObject** " << cppApiVariableName() << " = nullptr;" << endl;
+    s << "PyTypeObject **" << cppApiVariableName() << " = nullptr;" << endl;
 
     s << "// Current module's PyObject pointer." << endl;
-    s << "PyObject* " << pythonModuleObjectName() << " = nullptr;" << endl;
+    s << "PyObject *" << pythonModuleObjectName() << " = nullptr;" << endl;
 
     s << "// Current module's converter array." << endl;
-    s << "SbkConverter** " << convertersVariableName() << " = nullptr;" << endl;
+    s << "SbkConverter **" << convertersVariableName() << " = nullptr;" << endl;
 
     const CodeSnipList snips = moduleEntry->codeSnips();
 
@@ -5563,7 +5563,7 @@ bool CppGenerator::finishGeneration()
         s << INDENT << "for (int i = 0, imax = SBK_" << moduleName() << "_IDX_COUNT; i < imax; i++) {" << endl;
         {
             Indentation indentation(INDENT);
-            s << INDENT << "PyObject *pyType = reinterpret_cast<PyObject*>(" << cppApiVariableName() << "[i]);" << endl;
+            s << INDENT << "PyObject *pyType = reinterpret_cast<PyObject *>(" << cppApiVariableName() << "[i]);" << endl;
             s << INDENT << "if (pyType && PyObject_HasAttrString(pyType, \"staticMetaObject\"))"<< endl;
             {
                 Indentation indentation(INDENT);
@@ -5612,8 +5612,8 @@ bool CppGenerator::finishGeneration()
     if (!requiredModules.isEmpty())
         s << "// Required modules' type and converter arrays." << endl;
     for (const QString &requiredModule : requiredModules) {
-        s << "PyTypeObject** " << cppApiVariableName(requiredModule) << ';' << endl;
-        s << "SbkConverter** " << convertersVariableName(requiredModule) << ';' << endl;
+        s << "PyTypeObject **" << cppApiVariableName(requiredModule) << ';' << endl;
+        s << "SbkConverter **" << convertersVariableName(requiredModule) << ';' << endl;
     }
     s << endl;
 
@@ -5626,8 +5626,8 @@ bool CppGenerator::finishGeneration()
             const TypeEntry *externalType = it.key();
             s << "// Extended implicit conversions for " << externalType->qualifiedTargetLangName() << '.' << endl;
             for (const AbstractMetaClass *sourceClass : it.value()) {
-                AbstractMetaType* sourceType = buildAbstractMetaTypeFromAbstractMetaClass(sourceClass);
-                AbstractMetaType* targetType = buildAbstractMetaTypeFromTypeEntry(externalType);
+                AbstractMetaType *sourceType = buildAbstractMetaTypeFromAbstractMetaClass(sourceClass);
+                AbstractMetaType *targetType = buildAbstractMetaTypeFromTypeEntry(externalType);
                 writePythonToCppConversionFunctions(s, sourceType, targetType);
             }
         }
@@ -5694,7 +5694,7 @@ bool CppGenerator::finishGeneration()
         s << endl;
     }
 
-    for (const QString& requiredModule : requiredModules) {
+    for (const QString &requiredModule : requiredModules) {
         s << INDENT << "{" << endl;
         {
             Indentation indentation(INDENT);
@@ -5713,18 +5713,18 @@ bool CppGenerator::finishGeneration()
     int maxTypeIndex = getMaxTypeIndex() + instantiatedSmartPointers().size();
     if (maxTypeIndex) {
         s << INDENT << "// Create an array of wrapper types for the current module." << endl;
-        s << INDENT << "static PyTypeObject* cppApi[SBK_" << moduleName() << "_IDX_COUNT];" << endl;
+        s << INDENT << "static PyTypeObject *cppApi[SBK_" << moduleName() << "_IDX_COUNT];" << endl;
         s << INDENT << cppApiVariableName() << " = cppApi;" << endl << endl;
     }
 
     s << INDENT << "// Create an array of primitive type converters for the current module." << endl;
-    s << INDENT << "static SbkConverter* sbkConverters[SBK_" << moduleName() << "_CONVERTERS_IDX_COUNT" << "];" << endl;
+    s << INDENT << "static SbkConverter *sbkConverters[SBK_" << moduleName() << "_CONVERTERS_IDX_COUNT" << "];" << endl;
     s << INDENT << convertersVariableName() << " = sbkConverters;" << endl << endl;
 
     s << "#ifdef IS_PY3K" << endl;
-    s << INDENT << "PyObject* module = Shiboken::Module::create(\""  << moduleName() << "\", &moduledef);" << endl;
+    s << INDENT << "PyObject *module = Shiboken::Module::create(\""  << moduleName() << "\", &moduledef);" << endl;
     s << "#else" << endl;
-    s << INDENT << "PyObject* module = Shiboken::Module::create(\""  << moduleName() << "\", ";
+    s << INDENT << "PyObject *module = Shiboken::Module::create(\""  << moduleName() << "\", ";
     s << moduleName() << "_methods);" << endl;
     s << "#endif" << endl << endl;
 
@@ -5829,7 +5829,7 @@ bool CppGenerator::finishGeneration()
     return file.done() != FileOut::Failure;
 }
 
-static ArgumentOwner getArgumentOwner(const AbstractMetaFunction* func, int argIndex)
+static ArgumentOwner getArgumentOwner(const AbstractMetaFunction *func, int argIndex)
 {
     ArgumentOwner argOwner = func->argumentOwner(func->ownerClass(), argIndex);
     if (argOwner.index == ArgumentOwner::InvalidIndex)
@@ -5837,7 +5837,7 @@ static ArgumentOwner getArgumentOwner(const AbstractMetaFunction* func, int argI
     return argOwner;
 }
 
-bool CppGenerator::writeParentChildManagement(QTextStream& s, const AbstractMetaFunction* func, int argIndex, bool useHeuristicPolicy)
+bool CppGenerator::writeParentChildManagement(QTextStream &s, const AbstractMetaFunction *func, int argIndex, bool useHeuristicPolicy)
 {
     const int numArgs = func->arguments().count();
     bool ctorHeuristicEnabled = func->isConstructor() && useCtorHeuristic() && useHeuristicPolicy;
@@ -5852,7 +5852,7 @@ bool CppGenerator::writeParentChildManagement(QTextStream& s, const AbstractMeta
     int parentIndex = argOwner.index;
     int childIndex = argIndex;
     if (ctorHeuristicEnabled && argIndex > 0 && numArgs) {
-        AbstractMetaArgument* arg = func->arguments().at(argIndex-1);
+        AbstractMetaArgument *arg = func->arguments().at(argIndex-1);
         if (arg->name() == QLatin1String("parent") && isObjectType(arg->type())) {
             action = ArgumentOwner::Add;
             parentIndex = argIndex;
@@ -5896,7 +5896,7 @@ bool CppGenerator::writeParentChildManagement(QTextStream& s, const AbstractMeta
     return false;
 }
 
-void CppGenerator::writeParentChildManagement(QTextStream& s, const AbstractMetaFunction* func, bool useHeuristicForReturn)
+void CppGenerator::writeParentChildManagement(QTextStream &s, const AbstractMetaFunction *func, bool useHeuristicForReturn)
 {
     const int numArgs = func->arguments().count();
 
@@ -5910,7 +5910,7 @@ void CppGenerator::writeParentChildManagement(QTextStream& s, const AbstractMeta
         writeReturnValueHeuristics(s, func);
 }
 
-void CppGenerator::writeReturnValueHeuristics(QTextStream& s, const AbstractMetaFunction* func, const QString& self)
+void CppGenerator::writeReturnValueHeuristics(QTextStream &s, const AbstractMetaFunction *func, const QString &self)
 {
     AbstractMetaType *type = func->type();
     if (!useReturnValueHeuristic()
@@ -5932,7 +5932,7 @@ void CppGenerator::writeReturnValueHeuristics(QTextStream& s, const AbstractMeta
 void CppGenerator::writeHashFunction(QTextStream &s, GeneratorContext &context)
 {
     const AbstractMetaClass *metaClass = context.metaClass();
-    s << "static Py_hash_t " << cpythonBaseName(metaClass) << "_HashFunc(PyObject* self) {" << endl;
+    s << "static Py_hash_t " << cpythonBaseName(metaClass) << "_HashFunc(PyObject *self) {" << endl;
     writeCppSelfDefinition(s, context);
     s << INDENT << "return " << metaClass->typeEntry()->hashFunction() << '(';
     s << (isObjectType(metaClass) ? "" : "*") << CPP_SELF_VAR << ");" << endl;
@@ -5945,14 +5945,14 @@ void CppGenerator::writeStdListWrapperMethods(QTextStream &s, GeneratorContext &
     ErrorCode errorCode(0);
 
     // __len__
-    s << "Py_ssize_t " << cpythonBaseName(metaClass->typeEntry()) << "__len__(PyObject* self)" << endl;
+    s << "Py_ssize_t " << cpythonBaseName(metaClass->typeEntry()) << "__len__(PyObject *self)" << endl;
     s << '{' << endl;
     writeCppSelfDefinition(s, context);
     s << INDENT << "return " << CPP_SELF_VAR << "->size();" << endl;
     s << '}' << endl;
 
     // __getitem__
-    s << "PyObject* " << cpythonBaseName(metaClass->typeEntry()) << "__getitem__(PyObject* self, Py_ssize_t _i)" << endl;
+    s << "PyObject *" << cpythonBaseName(metaClass->typeEntry()) << "__getitem__(PyObject *self, Py_ssize_t _i)" << endl;
     s << '{' << endl;
     writeCppSelfDefinition(s, context);
     writeIndexError(s, QLatin1String("index out of bounds"));
@@ -5960,7 +5960,7 @@ void CppGenerator::writeStdListWrapperMethods(QTextStream &s, GeneratorContext &
     s << INDENT << metaClass->qualifiedCppName() << "::iterator _item = " << CPP_SELF_VAR << "->begin();" << endl;
     s << INDENT << "for (Py_ssize_t pos = 0; pos < _i; pos++) _item++;" << endl;
 
-    const AbstractMetaType* itemType = metaClass->templateBaseClassInstantiations().constFirst();
+    const AbstractMetaType *itemType = metaClass->templateBaseClassInstantiations().constFirst();
 
     s << INDENT << "return ";
     writeToPythonConversion(s, itemType, metaClass, QLatin1String("*_item"));
@@ -5969,7 +5969,7 @@ void CppGenerator::writeStdListWrapperMethods(QTextStream &s, GeneratorContext &
 
     // __setitem__
     ErrorCode errorCode2(-1);
-    s << "int " << cpythonBaseName(metaClass->typeEntry()) << "__setitem__(PyObject* self, Py_ssize_t _i, PyObject* pyArg)" << endl;
+    s << "int " << cpythonBaseName(metaClass->typeEntry()) << "__setitem__(PyObject *self, Py_ssize_t _i, PyObject *pyArg)" << endl;
     s << '{' << endl;
     writeCppSelfDefinition(s, context);
     writeIndexError(s, QLatin1String("list assignment index out of range"));
@@ -5993,7 +5993,7 @@ void CppGenerator::writeStdListWrapperMethods(QTextStream &s, GeneratorContext &
     s << INDENT << "return {};" << endl;
     s << '}' << endl;
 }
-void CppGenerator::writeIndexError(QTextStream& s, const QString& errorMsg)
+void CppGenerator::writeIndexError(QTextStream &s, const QString &errorMsg)
 {
     s << INDENT << "if (_i < 0 || _i >= (Py_ssize_t) " << CPP_SELF_VAR << "->size()) {" << endl;
     {
@@ -6010,7 +6010,7 @@ QString CppGenerator::writeReprFunction(QTextStream &s, GeneratorContext &contex
     QString funcName = cpythonBaseName(metaClass) + QLatin1String("__repr__");
     s << "extern \"C\"" << endl;
     s << '{' << endl;
-    s << "static PyObject* " << funcName << "(PyObject* self)" << endl;
+    s << "static PyObject *" << funcName << "(PyObject *self)" << endl;
     s << '{' << endl;
     writeCppSelfDefinition(s, context);
     s << INDENT << "QBuffer buffer;" << endl;
@@ -6028,7 +6028,7 @@ QString CppGenerator::writeReprFunction(QTextStream &s, GeneratorContext &contex
         Indentation indent(INDENT);
         s << INDENT << "str.replace(0, idx, Py_TYPE(self)->tp_name);" << endl;
     }
-    s << INDENT << "PyObject* mod = PyDict_GetItemString(Py_TYPE(self)->tp_dict, \"__module__\");" << endl;
+    s << INDENT << "PyObject *mod = PyDict_GetItemString(Py_TYPE(self)->tp_dict, \"__module__\");" << endl;
     // PYSIDE-595: The introduction of heap types has the side effect that the module name
     // is always prepended to the type name. Therefore the strchr check:
     s << INDENT << "if (mod && !strchr(str, '.'))" << endl;
diff --git a/sources/shiboken2/generator/shiboken2/cppgenerator.h b/sources/shiboken2/generator/shiboken2/cppgenerator.h
index 519e12b7b..44a04653a 100644
--- a/sources/shiboken2/generator/shiboken2/cppgenerator.h
+++ b/sources/shiboken2/generator/shiboken2/cppgenerator.h
@@ -44,38 +44,38 @@ public:
 protected:
     QString fileNameSuffix() const override;
     QString fileNameForContext(GeneratorContext &context) const override;
-    QVector<AbstractMetaFunctionList> filterGroupedOperatorFunctions(const AbstractMetaClass* metaClass,
+    QVector<AbstractMetaFunctionList> filterGroupedOperatorFunctions(const AbstractMetaClass *metaClass,
                                                                      uint query);
-    void generateClass(QTextStream& s, GeneratorContext &classContext) override;
+    void generateClass(QTextStream &s, GeneratorContext &classContext) override;
     bool finishGeneration() override;
 
 private:
-    void writeConstructorNative(QTextStream& s, const AbstractMetaFunction* func);
-    void writeDestructorNative(QTextStream& s, const AbstractMetaClass* metaClass);
+    void writeConstructorNative(QTextStream &s, const AbstractMetaFunction *func);
+    void writeDestructorNative(QTextStream &s, const AbstractMetaClass *metaClass);
 
-    QString getVirtualFunctionReturnTypeName(const AbstractMetaFunction* func);
-    void writeVirtualMethodNative(QTextStream& s, const AbstractMetaFunction* func);
+    QString getVirtualFunctionReturnTypeName(const AbstractMetaFunction *func);
+    void writeVirtualMethodNative(QTextStream &s, const AbstractMetaFunction *func);
 
-    void writeMetaObjectMethod(QTextStream& s, const AbstractMetaClass* metaClass);
-    void writeMetaCast(QTextStream& s, const AbstractMetaClass* metaClass);
+    void writeMetaObjectMethod(QTextStream &s, const AbstractMetaClass *metaClass);
+    void writeMetaCast(QTextStream &s, const AbstractMetaClass *metaClass);
 
-    void writeEnumConverterFunctions(QTextStream& s, const TypeEntry* enumType);
-    void writeEnumConverterFunctions(QTextStream& s, const AbstractMetaEnum* metaEnum);
+    void writeEnumConverterFunctions(QTextStream &s, const TypeEntry *enumType);
+    void writeEnumConverterFunctions(QTextStream &s, const AbstractMetaEnum *metaEnum);
     void writeConverterFunctions(QTextStream &s, const AbstractMetaClass *metaClass,
                                  GeneratorContext &classContext);
-    void writeCustomConverterFunctions(QTextStream& s, const CustomConversion* customConversion);
+    void writeCustomConverterFunctions(QTextStream &s, const CustomConversion *customConversion);
     void writeConverterRegister(QTextStream &s, const AbstractMetaClass *metaClass,
                                 GeneratorContext &classContext);
-    void writeCustomConverterRegister(QTextStream& s, const CustomConversion* customConversion, const QString& converterVar);
+    void writeCustomConverterRegister(QTextStream &s, const CustomConversion *customConversion, const QString &converterVar);
 
-    void writeContainerConverterFunctions(QTextStream& s, const AbstractMetaType* containerType);
+    void writeContainerConverterFunctions(QTextStream &s, const AbstractMetaType *containerType);
 
     void writeMethodWrapperPreamble(QTextStream &s, OverloadData &overloadData,
                                     GeneratorContext &context);
     void writeConstructorWrapper(QTextStream &s, const AbstractMetaFunctionList overloads, GeneratorContext &classContext);
     void writeMethodWrapper(QTextStream &s, const AbstractMetaFunctionList overloads,
                             GeneratorContext &classContext);
-    void writeArgumentsInitializer(QTextStream& s, OverloadData& overloadData);
+    void writeArgumentsInitializer(QTextStream &s, OverloadData &overloadData);
     void writeCppSelfAssigment(QTextStream &s, const GeneratorContext &context,
                                const QString &className, bool cppSelfAsReference,
                                bool useWrapperClass);
@@ -88,16 +88,16 @@ private:
                                 bool hasStaticOverload = false,
                                 bool cppSelfAsReference = false);
 
-    void writeErrorSection(QTextStream& s, OverloadData& overloadData);
-    void writeFunctionReturnErrorCheckSection(QTextStream& s, bool hasReturnValue = true);
+    void writeErrorSection(QTextStream &s, OverloadData &overloadData);
+    void writeFunctionReturnErrorCheckSection(QTextStream &s, bool hasReturnValue = true);
 
     /// Writes the check section for the validity of wrapped C++ objects.
-    void writeInvalidPyObjectCheck(QTextStream& s, const QString& pyObj);
+    void writeInvalidPyObjectCheck(QTextStream &s, const QString &pyObj);
 
-    void writeTypeCheck(QTextStream& s, const AbstractMetaType* argType, QString argumentName, bool isNumber = false, QString customType = QString(), bool rejectNull = false);
-    void writeTypeCheck(QTextStream& s, const OverloadData* overloadData, QString argumentName);
+    void writeTypeCheck(QTextStream &s, const AbstractMetaType *argType, QString argumentName, bool isNumber = false, QString customType = QString(), bool rejectNull = false);
+    void writeTypeCheck(QTextStream &s, const OverloadData *overloadData, QString argumentName);
 
-    void writeTypeDiscoveryFunction(QTextStream& s, const AbstractMetaClass* metaClass);
+    void writeTypeDiscoveryFunction(QTextStream &s, const AbstractMetaClass *metaClass);
 
     void writeSetattroFunction(QTextStream &s, GeneratorContext &context);
     void writeGetattroFunction(QTextStream &s, GeneratorContext &context);
@@ -115,10 +115,10 @@ private:
      *   \param defaultValue         an optional default value to be used instead of the conversion result
      *   \param castArgumentAsUnused if true the converted argument is cast as unused to avoid compiler warnings
      */
-    void writeArgumentConversion(QTextStream& s, const AbstractMetaType* argType,
-                                 const QString& argName, const QString& pyArgName,
-                                 const AbstractMetaClass* context = 0,
-                                 const QString& defaultValue = QString(),
+    void writeArgumentConversion(QTextStream &s, const AbstractMetaType *argType,
+                                 const QString &argName, const QString &pyArgName,
+                                 const AbstractMetaClass *context = 0,
+                                 const QString &defaultValue = QString(),
                                  bool castArgumentAsUnused = false);
 
     /**
@@ -132,19 +132,19 @@ private:
      *  \param  newType It is set to true if the type returned is a new object that must be deallocated.
      *  \return The type of the argument indicated by \p argPos.
      */
-    const AbstractMetaType* getArgumentType(const AbstractMetaFunction* func, int argPos);
+    const AbstractMetaType *getArgumentType(const AbstractMetaFunction *func, int argPos);
 
-    void writePythonToCppTypeConversion(QTextStream& s,
-                                        const AbstractMetaType* type,
-                                        const QString& pyIn,
-                                        const QString& cppOut,
-                                        const AbstractMetaClass* context = 0,
-                                        const QString& defaultValue = QString());
+    void writePythonToCppTypeConversion(QTextStream &s,
+                                        const AbstractMetaType *type,
+                                        const QString &pyIn,
+                                        const QString &cppOut,
+                                        const AbstractMetaClass *context = 0,
+                                        const QString &defaultValue = QString());
 
     /// Writes the conversion rule for arguments of regular and virtual methods.
-    void writeConversionRule(QTextStream& s, const AbstractMetaFunction* func, TypeSystem::Language language);
+    void writeConversionRule(QTextStream &s, const AbstractMetaFunction *func, TypeSystem::Language language);
     /// Writes the conversion rule for the return value of a method.
-    void writeConversionRule(QTextStream& s, const AbstractMetaFunction* func, TypeSystem::Language language, const QString& outputVar);
+    void writeConversionRule(QTextStream &s, const AbstractMetaFunction *func, TypeSystem::Language language, const QString &outputVar);
 
     /**
      *   Set the Python method wrapper return value variable to Py_None if
@@ -155,7 +155,7 @@ private:
      *   \param thereIsReturnValue indicates if the return type of any of the other overloads
      *                             for this function is different from 'void'
      */
-    void writeNoneReturn(QTextStream& s, const AbstractMetaFunction* func, bool thereIsReturnValue);
+    void writeNoneReturn(QTextStream &s, const AbstractMetaFunction *func, bool thereIsReturnValue);
 
     /**
      *   Writes the Python function wrapper overload decisor that selects which C++
@@ -163,9 +163,9 @@ private:
      *   \param s text stream to write
      *   \param overloadData the overload data describing all the possible overloads for the function/method
      */
-    void writeOverloadedFunctionDecisor(QTextStream& s, const OverloadData& overloadData);
+    void writeOverloadedFunctionDecisor(QTextStream &s, const OverloadData &overloadData);
     /// Recursive auxiliar method to the other writeOverloadedFunctionDecisor.
-    void writeOverloadedFunctionDecisorEngine(QTextStream& s, const OverloadData* parentOverloadData);
+    void writeOverloadedFunctionDecisorEngine(QTextStream &s, const OverloadData *parentOverloadData);
 
     /// Writes calls to all the possible method/function overloads.
     void writeFunctionCalls(QTextStream &s,
@@ -179,55 +179,55 @@ private:
                                  GeneratorContext &context);
 
     /// Returns the name of a C++ to Python conversion function.
-    static QString cppToPythonFunctionName(const QString& sourceTypeName, QString targetTypeName = QString());
+    static QString cppToPythonFunctionName(const QString &sourceTypeName, QString targetTypeName = QString());
 
     /// Returns the name of a Python to C++ conversion function.
-    static QString pythonToCppFunctionName(const QString& sourceTypeName, const QString& targetTypeName);
-    static QString pythonToCppFunctionName(const AbstractMetaType* sourceType, const AbstractMetaType* targetType);
-    static QString pythonToCppFunctionName(const CustomConversion::TargetToNativeConversion* toNative, const TypeEntry* targetType);
+    static QString pythonToCppFunctionName(const QString &sourceTypeName, const QString &targetTypeName);
+    static QString pythonToCppFunctionName(const AbstractMetaType *sourceType, const AbstractMetaType *targetType);
+    static QString pythonToCppFunctionName(const CustomConversion::TargetToNativeConversion *toNative, const TypeEntry *targetType);
 
     /// Returns the name of a Python to C++ convertible check function.
-    static QString convertibleToCppFunctionName(const QString& sourceTypeName, const QString& targetTypeName);
-    static QString convertibleToCppFunctionName(const AbstractMetaType* sourceType, const AbstractMetaType* targetType);
-    static QString convertibleToCppFunctionName(const CustomConversion::TargetToNativeConversion* toNative, const TypeEntry* targetType);
+    static QString convertibleToCppFunctionName(const QString &sourceTypeName, const QString &targetTypeName);
+    static QString convertibleToCppFunctionName(const AbstractMetaType *sourceType, const AbstractMetaType *targetType);
+    static QString convertibleToCppFunctionName(const CustomConversion::TargetToNativeConversion *toNative, const TypeEntry *targetType);
 
     /// Writes a C++ to Python conversion function.
-    void writeCppToPythonFunction(QTextStream& s, const QString& code, const QString& sourceTypeName, QString targetTypeName = QString());
-    void writeCppToPythonFunction(QTextStream& s, const CustomConversion* customConversion);
-    void writeCppToPythonFunction(QTextStream& s, const AbstractMetaType* containerType);
+    void writeCppToPythonFunction(QTextStream &s, const QString &code, const QString &sourceTypeName, QString targetTypeName = QString());
+    void writeCppToPythonFunction(QTextStream &s, const CustomConversion *customConversion);
+    void writeCppToPythonFunction(QTextStream &s, const AbstractMetaType *containerType);
 
     /// Writes a Python to C++ conversion function.
-    void writePythonToCppFunction(QTextStream& s, const QString& code, const QString& sourceTypeName, const QString& targetTypeName);
+    void writePythonToCppFunction(QTextStream &s, const QString &code, const QString &sourceTypeName, const QString &targetTypeName);
 
     /// Writes a Python to C++ convertible check function.
-    void writeIsPythonConvertibleToCppFunction(QTextStream& s,
-                                               const QString& sourceTypeName,
-                                               const QString& targetTypeName,
-                                               const QString& condition,
+    void writeIsPythonConvertibleToCppFunction(QTextStream &s,
+                                               const QString &sourceTypeName,
+                                               const QString &targetTypeName,
+                                               const QString &condition,
                                                QString pythonToCppFuncName = QString(),
                                                bool acceptNoneAsCppNull = false);
 
     /// Writes a pair of Python to C++ conversion and check functions.
-    void writePythonToCppConversionFunctions(QTextStream& s,
-                                             const AbstractMetaType* sourceType,
-                                             const AbstractMetaType* targetType,
+    void writePythonToCppConversionFunctions(QTextStream &s,
+                                             const AbstractMetaType *sourceType,
+                                             const AbstractMetaType *targetType,
                                              QString typeCheck = QString(),
                                              QString conversion = QString(),
                                              QString preConversion = QString());
     /// Writes a pair of Python to C++ conversion and check functions for implicit conversions.
-    void writePythonToCppConversionFunctions(QTextStream& s,
-                                             const CustomConversion::TargetToNativeConversion* toNative,
-                                             const TypeEntry* targetType);
+    void writePythonToCppConversionFunctions(QTextStream &s,
+                                             const CustomConversion::TargetToNativeConversion *toNative,
+                                             const TypeEntry *targetType);
 
     /// Writes a pair of Python to C++ conversion and check functions for instantiated container types.
-    void writePythonToCppConversionFunctions(QTextStream& s, const AbstractMetaType* containerType);
+    void writePythonToCppConversionFunctions(QTextStream &s, const AbstractMetaType *containerType);
 
-    void writeAddPythonToCppConversion(QTextStream& s, const QString& converterVar, const QString& pythonToCppFunc, const QString& isConvertibleFunc);
+    void writeAddPythonToCppConversion(QTextStream &s, const QString &converterVar, const QString &pythonToCppFunc, const QString &isConvertibleFunc);
 
-    void writeNamedArgumentResolution(QTextStream& s, const AbstractMetaFunction* func, bool usePyArgs);
+    void writeNamedArgumentResolution(QTextStream &s, const AbstractMetaFunction *func, bool usePyArgs);
 
     /// Returns a string containing the name of an argument for the given function and argument index.
-    QString argumentNameFromIndex(const AbstractMetaFunction* func, int argIndex, const AbstractMetaClass** wrappedClass);
+    QString argumentNameFromIndex(const AbstractMetaFunction *func, int argIndex, const AbstractMetaClass **wrappedClass);
     void writeMethodCall(QTextStream &s, const AbstractMetaFunction *func,
                          GeneratorContext &context, int maxArgs = 0);
 
@@ -241,25 +241,25 @@ private:
     void writeClassDefinition(QTextStream &s,
                               const AbstractMetaClass *metaClass,
                               GeneratorContext &classContext);
-    void writeMethodDefinitionEntry(QTextStream& s, const AbstractMetaFunctionList &overloads);
-    void writeMethodDefinition(QTextStream& s, const AbstractMetaFunctionList &overloads);
+    void writeMethodDefinitionEntry(QTextStream &s, const AbstractMetaFunctionList &overloads);
+    void writeMethodDefinition(QTextStream &s, const AbstractMetaFunctionList &overloads);
     void writeSignatureInfo(QTextStream &s, const AbstractMetaFunctionList &overloads);
     /// Writes the implementation of all methods part of python sequence protocol
     void writeSequenceMethods(QTextStream &s,
                               const AbstractMetaClass *metaClass,
                               GeneratorContext &context);
-    void writeTypeAsSequenceDefinition(QTextStream& s, const AbstractMetaClass* metaClass);
+    void writeTypeAsSequenceDefinition(QTextStream &s, const AbstractMetaClass *metaClass);
 
     /// Writes the PyMappingMethods structure for types that supports the python mapping protocol.
-    void writeTypeAsMappingDefinition(QTextStream& s, const AbstractMetaClass* metaClass);
+    void writeTypeAsMappingDefinition(QTextStream &s, const AbstractMetaClass *metaClass);
     void writeMappingMethods(QTextStream &s,
                              const AbstractMetaClass *metaClass,
                              GeneratorContext &context);
 
-    void writeTypeAsNumberDefinition(QTextStream& s, const AbstractMetaClass* metaClass);
+    void writeTypeAsNumberDefinition(QTextStream &s, const AbstractMetaClass *metaClass);
 
-    void writeTpTraverseFunction(QTextStream& s, const AbstractMetaClass* metaClass);
-    void writeTpClearFunction(QTextStream& s, const AbstractMetaClass* metaClass);
+    void writeTpTraverseFunction(QTextStream &s, const AbstractMetaClass *metaClass);
+    void writeTpClearFunction(QTextStream &s, const AbstractMetaClass *metaClass);
 
     void writeCopyFunction(QTextStream &s, GeneratorContext &context);
 
@@ -272,35 +272,35 @@ private:
 
     void writeRichCompareFunction(QTextStream &s, GeneratorContext &context);
 
-    void writeEnumsInitialization(QTextStream& s, AbstractMetaEnumList& enums);
-    void writeEnumInitialization(QTextStream& s, const AbstractMetaEnum* metaEnum);
+    void writeEnumsInitialization(QTextStream &s, AbstractMetaEnumList &enums);
+    void writeEnumInitialization(QTextStream &s, const AbstractMetaEnum *metaEnum);
 
-    void writeSignalInitialization(QTextStream& s, const AbstractMetaClass* metaClass);
+    void writeSignalInitialization(QTextStream &s, const AbstractMetaClass *metaClass);
 
-    void writeFlagsMethods(QTextStream& s, const AbstractMetaEnum* cppEnum);
-    void writeFlagsToLong(QTextStream& s, const AbstractMetaEnum* cppEnum);
-    void writeFlagsNonZero(QTextStream& s, const AbstractMetaEnum* cppEnum);
-    void writeFlagsNumberMethodsDefinition(QTextStream& s, const AbstractMetaEnum* cppEnum);
-    void writeFlagsBinaryOperator(QTextStream& s, const AbstractMetaEnum* cppEnum,
+    void writeFlagsMethods(QTextStream &s, const AbstractMetaEnum *cppEnum);
+    void writeFlagsToLong(QTextStream &s, const AbstractMetaEnum *cppEnum);
+    void writeFlagsNonZero(QTextStream &s, const AbstractMetaEnum *cppEnum);
+    void writeFlagsNumberMethodsDefinition(QTextStream &s, const AbstractMetaEnum *cppEnum);
+    void writeFlagsBinaryOperator(QTextStream &s, const AbstractMetaEnum *cppEnum,
                                   const QString &pyOpName, const QString &cppOpName);
-    void writeFlagsUnaryOperator(QTextStream& s, const AbstractMetaEnum* cppEnum,
+    void writeFlagsUnaryOperator(QTextStream &s, const AbstractMetaEnum *cppEnum,
                                  const QString &pyOpName, const QString &cppOpName,
                                  bool boolResult = false);
 
     /// Writes the function that registers the multiple inheritance information for the classes that need it.
-    void writeMultipleInheritanceInitializerFunction(QTextStream& s, const AbstractMetaClass* metaClass);
+    void writeMultipleInheritanceInitializerFunction(QTextStream &s, const AbstractMetaClass *metaClass);
     /// Writes the implementation of special cast functions, used when we need to cast a class with multiple inheritance.
-    void writeSpecialCastFunction(QTextStream& s, const AbstractMetaClass* metaClass);
+    void writeSpecialCastFunction(QTextStream &s, const AbstractMetaClass *metaClass);
 
-    void writePrimitiveConverterInitialization(QTextStream& s, const CustomConversion* customConversion);
-    void writeEnumConverterInitialization(QTextStream& s, const TypeEntry* enumType);
-    void writeEnumConverterInitialization(QTextStream& s, const AbstractMetaEnum* metaEnum);
-    void writeContainerConverterInitialization(QTextStream& s, const AbstractMetaType* type);
-    void writeExtendedConverterInitialization(QTextStream& s, const TypeEntry* externalType, const QVector<const AbstractMetaClass*>& conversions);
+    void writePrimitiveConverterInitialization(QTextStream &s, const CustomConversion *customConversion);
+    void writeEnumConverterInitialization(QTextStream &s, const TypeEntry *enumType);
+    void writeEnumConverterInitialization(QTextStream &s, const AbstractMetaEnum *metaEnum);
+    void writeContainerConverterInitialization(QTextStream &s, const AbstractMetaType *type);
+    void writeExtendedConverterInitialization(QTextStream &s, const TypeEntry *externalType, const QVector<const AbstractMetaClass *>& conversions);
 
-    void writeParentChildManagement(QTextStream& s, const AbstractMetaFunction* func, bool userHeuristicForReturn);
-    bool writeParentChildManagement(QTextStream& s, const AbstractMetaFunction* func, int argIndex, bool userHeuristicPolicy);
-    void writeReturnValueHeuristics(QTextStream& s, const AbstractMetaFunction* func, const QString& self = QLatin1String("self"));
+    void writeParentChildManagement(QTextStream &s, const AbstractMetaFunction *func, bool userHeuristicForReturn);
+    bool writeParentChildManagement(QTextStream &s, const AbstractMetaFunction *func, int argIndex, bool userHeuristicPolicy);
+    void writeReturnValueHeuristics(QTextStream &s, const AbstractMetaFunction *func, const QString &self = QLatin1String("self"));
     void writeInitQtMetaTypeFunctionBody(QTextStream &s, GeneratorContext &context) const;
 
     /**
@@ -309,34 +309,34 @@ private:
      *   \return name of the multiple inheritance information initializer function or
      *           an empty string if there is no multiple inheritance in its ancestry.
      */
-    QString multipleInheritanceInitializerFunctionName(const AbstractMetaClass* metaClass);
+    QString multipleInheritanceInitializerFunctionName(const AbstractMetaClass *metaClass);
 
     /// Returns a list of all classes to which the given class could be cast.
-    QStringList getAncestorMultipleInheritance(const AbstractMetaClass* metaClass);
+    QStringList getAncestorMultipleInheritance(const AbstractMetaClass *metaClass);
 
     /// Returns true if the given class supports the python number protocol
-    bool supportsNumberProtocol(const AbstractMetaClass* metaClass);
+    bool supportsNumberProtocol(const AbstractMetaClass *metaClass);
 
     /// Returns true if the given class supports the python sequence protocol
-    bool supportsSequenceProtocol(const AbstractMetaClass* metaClass);
+    bool supportsSequenceProtocol(const AbstractMetaClass *metaClass);
 
     /// Returns true if the given class supports the python mapping protocol
-    bool supportsMappingProtocol(const AbstractMetaClass* metaClass);
+    bool supportsMappingProtocol(const AbstractMetaClass *metaClass);
 
     /// Returns true if generator should produce getters and setters for the given class.
-    bool shouldGenerateGetSetList(const AbstractMetaClass* metaClass);
+    bool shouldGenerateGetSetList(const AbstractMetaClass *metaClass);
 
     void writeHashFunction(QTextStream &s, GeneratorContext &context);
 
     /// Write default implementations for sequence protocol
     void writeStdListWrapperMethods(QTextStream &s, GeneratorContext &context);
     /// Helper function for writeStdListWrapperMethods.
-    void writeIndexError(QTextStream& s, const QString& errorMsg);
+    void writeIndexError(QTextStream &s, const QString &errorMsg);
 
     QString writeReprFunction(QTextStream &s, GeneratorContext &context);
 
-    const AbstractMetaFunction *boolCast(const AbstractMetaClass* metaClass) const;
-    bool hasBoolCast(const AbstractMetaClass* metaClass) const
+    const AbstractMetaFunction *boolCast(const AbstractMetaClass *metaClass) const;
+    bool hasBoolCast(const AbstractMetaClass *metaClass) const
     { return boolCast(metaClass) != nullptr; }
 
     // Number protocol structure members names.
diff --git a/sources/shiboken2/generator/shiboken2/headergenerator.cpp b/sources/shiboken2/generator/shiboken2/headergenerator.cpp
index a55539d7c..82b2d96d6 100644
--- a/sources/shiboken2/generator/shiboken2/headergenerator.cpp
+++ b/sources/shiboken2/generator/shiboken2/headergenerator.cpp
@@ -58,7 +58,7 @@ QString HeaderGenerator::fileNameForContext(GeneratorContext &context) const
     return fileNameBase + fileNameSuffix();
 }
 
-void HeaderGenerator::writeCopyCtor(QTextStream& s, const AbstractMetaClass* metaClass) const
+void HeaderGenerator::writeCopyCtor(QTextStream &s, const AbstractMetaClass *metaClass) const
 {
     s << INDENT <<  wrapperName(metaClass) << "(const " << metaClass->qualifiedCppName() << "& self)";
     s << " : " << metaClass->qualifiedCppName() << "(self)" << endl;
@@ -66,7 +66,7 @@ void HeaderGenerator::writeCopyCtor(QTextStream& s, const AbstractMetaClass* met
     s << INDENT << "}" << endl << endl;
 }
 
-void HeaderGenerator::writeProtectedFieldAccessors(QTextStream& s, const AbstractMetaField* field) const
+void HeaderGenerator::writeProtectedFieldAccessors(QTextStream &s, const AbstractMetaField *field) const
 {
     AbstractMetaType *metaType = field->type();
     QString fieldType = metaType->cppSignature();
@@ -81,10 +81,10 @@ void HeaderGenerator::writeProtectedFieldAccessors(QTextStream& s, const Abstrac
 
     // Get function
     s << INDENT << "inline " << fieldType
-      << (useReference ? '*' : ' ')
+      << (useReference ? " *" : " ")
       << ' ' << protectedFieldGetterName(field) << "()"
       << " { return "
-      << (useReference ? '&' : ' ') << "this->" << fieldName << "; }" << endl;
+      << (useReference ? " &" : " ") << "this->" << fieldName << "; }" << endl;
 
     // Set function
     s << INDENT << "inline void " << protectedFieldSetterName(field) << '(' << fieldType << " value)"
@@ -169,8 +169,8 @@ void HeaderGenerator::generateClass(QTextStream &s, GeneratorContext &classConte
         if ((!avoidProtectedHack() || !metaClass->hasPrivateDestructor())
             && usePySideExtensions() && metaClass->isQObject()) {
             s << "public:\n";
-            s << INDENT << "int qt_metacall(QMetaObject::Call call, int id, void** args) override;" << endl;
-            s << INDENT << "void* qt_metacast(const char* _clname) override;" << endl;
+            s << INDENT << "int qt_metacall(QMetaObject::Call call, int id, void **args) override;" << endl;
+            s << INDENT << "void *qt_metacast(const char *_clname) override;" << endl;
         }
 
         if (!m_inheritedOverloads.isEmpty()) {
@@ -205,7 +205,7 @@ void HeaderGenerator::generateClass(QTextStream &s, GeneratorContext &classConte
     s << "#endif // SBK_" << outerHeaderGuard << "_H" << endl << endl;
 }
 
-void HeaderGenerator::writeFunction(QTextStream& s, const AbstractMetaFunction* func)
+void HeaderGenerator::writeFunction(QTextStream &s, const AbstractMetaFunction *func)
 {
 
     // do not write copy ctors here.
@@ -228,9 +228,9 @@ void HeaderGenerator::writeFunction(QTextStream& s, const AbstractMetaFunction*
         const AbstractMetaArgumentList &arguments = func->arguments();
         for (const AbstractMetaArgument *arg : arguments) {
             QString argName = arg->name();
-            const TypeEntry* enumTypeEntry = 0;
+            const TypeEntry *enumTypeEntry = nullptr;
             if (arg->type()->isFlags())
-                enumTypeEntry = static_cast<const FlagsTypeEntry*>(arg->type()->typeEntry())->originator();
+                enumTypeEntry = static_cast<const FlagsTypeEntry *>(arg->type()->typeEntry())->originator();
             else if (arg->type()->isEnum())
                 enumTypeEntry = arg->type()->typeEntry();
             if (enumTypeEntry)
@@ -284,7 +284,7 @@ void HeaderGenerator::writeFunction(QTextStream& s, const AbstractMetaFunction*
     }
 }
 
-static void _writeTypeIndexValue(QTextStream& s, const QString& variableName,
+static void _writeTypeIndexValue(QTextStream &s, const QString &variableName,
                                  int typeIndex)
 {
     s << "    ";
@@ -294,15 +294,15 @@ static void _writeTypeIndexValue(QTextStream& s, const QString& variableName,
     s << " = " << typeIndex;
 }
 
-static inline void _writeTypeIndexValueLine(QTextStream& s,
-                                            const QString& variableName,
+static inline void _writeTypeIndexValueLine(QTextStream &s,
+                                            const QString &variableName,
                                             int typeIndex)
 {
     _writeTypeIndexValue(s, variableName, typeIndex);
     s << ",\n";
 }
 
-void HeaderGenerator::writeTypeIndexValueLine(QTextStream& s, const TypeEntry* typeEntry)
+void HeaderGenerator::writeTypeIndexValueLine(QTextStream &s, const TypeEntry *typeEntry)
 {
     if (!typeEntry || !typeEntry->generateCode())
         return;
@@ -310,7 +310,7 @@ void HeaderGenerator::writeTypeIndexValueLine(QTextStream& s, const TypeEntry* t
     const int typeIndex = typeEntry->sbkIndex();
     _writeTypeIndexValueLine(s, getTypeIndexVariableName(typeEntry), typeIndex);
     if (typeEntry->isComplex()) {
-        const ComplexTypeEntry* cType = static_cast<const ComplexTypeEntry*>(typeEntry);
+        const ComplexTypeEntry *cType = static_cast<const ComplexTypeEntry *>(typeEntry);
         if (cType->baseContainerType()) {
             const AbstractMetaClass *metaClass = AbstractMetaClass::findClass(classes(), cType);
             if (metaClass->templateBaseClass())
@@ -318,13 +318,13 @@ void HeaderGenerator::writeTypeIndexValueLine(QTextStream& s, const TypeEntry* t
         }
     }
     if (typeEntry->isEnum()) {
-        const EnumTypeEntry* ete = static_cast<const EnumTypeEntry*>(typeEntry);
+        auto ete = static_cast<const EnumTypeEntry *>(typeEntry);
         if (ete->flags())
             writeTypeIndexValueLine(s, ete->flags());
     }
 }
 
-void HeaderGenerator::writeTypeIndexValueLines(QTextStream& s, const AbstractMetaClass* metaClass)
+void HeaderGenerator::writeTypeIndexValueLines(QTextStream &s, const AbstractMetaClass *metaClass)
 {
     if (!metaClass->typeEntry()->generateCode())
         return;
@@ -383,7 +383,7 @@ bool HeaderGenerator::finishGeneration()
     AbstractMetaEnumList globalEnums = this->globalEnums();
     AbstractMetaClassList classList = classes();
 
-    std::sort(classList.begin(), classList.end(), [](AbstractMetaClass *a, AbstractMetaClass* b) {
+    std::sort(classList.begin(), classList.end(), [](AbstractMetaClass *a, AbstractMetaClass *b) {
         return a->typeEntry()->sbkIndex() < b->typeEntry()->sbkIndex();
     });
 
@@ -413,11 +413,11 @@ bool HeaderGenerator::finishGeneration()
     macrosStream << "\n};\n";
 
     macrosStream << "// This variable stores all Python types exported by this module." << endl;
-    macrosStream << "extern PyTypeObject** " << cppApiVariableName() << ';' << endl << endl;
+    macrosStream << "extern PyTypeObject **" << cppApiVariableName() << ';' << endl << endl;
     macrosStream << "// This variable stores the Python module object exported by this module." << endl;
-    macrosStream << "extern PyObject* " << pythonModuleObjectName() << ';' << endl << endl;
+    macrosStream << "extern PyObject *" << pythonModuleObjectName() << ';' << endl << endl;
     macrosStream << "// This variable stores all type converters exported by this module." << endl;
-    macrosStream << "extern SbkConverter** " << convertersVariableName() << ';' << endl << endl;
+    macrosStream << "extern SbkConverter **" << convertersVariableName() << ';' << endl << endl;
 
     // TODO-CONVERTER ------------------------------------------------------------------------------
     // Using a counter would not do, a fix must be made to APIExtractor's getTypeIndex().
@@ -467,14 +467,14 @@ bool HeaderGenerator::finishGeneration()
             continue;
 
         //Includes
-        const TypeEntry* classType = metaClass->typeEntry();
+        const TypeEntry *classType = metaClass->typeEntry();
         includes << classType->include();
 
         const AbstractMetaEnumList &enums = metaClass->enums();
         for (const AbstractMetaEnum *cppEnum : enums) {
             if (cppEnum->isAnonymous() || cppEnum->isPrivate())
                 continue;
-            EnumTypeEntry* enumType = cppEnum->typeEntry();
+            EnumTypeEntry *enumType = cppEnum->typeEntry();
             includes << enumType->include();
             writeProtectedEnumSurrogate(protEnumsSurrogates, cppEnum);
             writeSbkTypeFunction(typeFunctions, cppEnum);
@@ -497,7 +497,7 @@ bool HeaderGenerator::finishGeneration()
     QString includeShield(QLatin1String("SBK_") + moduleName().toUpper() + QLatin1String("_PYTHON_H"));
 
     FileOut file(moduleHeaderFileName);
-    QTextStream& s = file.stream;
+    QTextStream &s = file.stream;
     // write license comment
     s << licenseComment() << endl << endl;
 
@@ -558,13 +558,13 @@ bool HeaderGenerator::finishGeneration()
     return file.done() != FileOut::Failure;
 }
 
-void HeaderGenerator::writeProtectedEnumSurrogate(QTextStream& s, const AbstractMetaEnum* cppEnum)
+void HeaderGenerator::writeProtectedEnumSurrogate(QTextStream &s, const AbstractMetaEnum *cppEnum)
 {
     if (avoidProtectedHack() && cppEnum->isProtected())
         s << "enum " << protectedEnumSurrogateName(cppEnum) << " {};" << endl;
 }
 
-void HeaderGenerator::writeSbkTypeFunction(QTextStream& s, const AbstractMetaEnum* cppEnum)
+void HeaderGenerator::writeSbkTypeFunction(QTextStream &s, const AbstractMetaEnum *cppEnum)
 {
     QString enumName;
     if (avoidProtectedHack() && cppEnum->isProtected()) {
@@ -575,29 +575,29 @@ void HeaderGenerator::writeSbkTypeFunction(QTextStream& s, const AbstractMetaEnu
             enumName = cppEnum->enclosingClass()->qualifiedCppName() + QLatin1String("::") + enumName;
     }
 
-    s << "template<> inline PyTypeObject* SbkType< ::" << enumName << " >() ";
+    s << "template<> inline PyTypeObject *SbkType< ::" << enumName << " >() ";
     s << "{ return " << cpythonTypeNameExt(cppEnum->typeEntry()) << "; }\n";
 
-    FlagsTypeEntry* flag = cppEnum->typeEntry()->flags();
+    FlagsTypeEntry *flag = cppEnum->typeEntry()->flags();
     if (flag) {
-        s <<  "template<> inline PyTypeObject* SbkType< ::" << flag->name() << " >() "
+        s <<  "template<> inline PyTypeObject *SbkType< ::" << flag->name() << " >() "
           << "{ return " << cpythonTypeNameExt(flag) << "; }\n";
     }
 }
 
-void HeaderGenerator::writeSbkTypeFunction(QTextStream& s, const AbstractMetaClass* cppClass)
+void HeaderGenerator::writeSbkTypeFunction(QTextStream &s, const AbstractMetaClass *cppClass)
 {
-    s <<  "template<> inline PyTypeObject* SbkType< ::" << cppClass->qualifiedCppName() << " >() "
-      <<  "{ return reinterpret_cast<PyTypeObject*>(" << cpythonTypeNameExt(cppClass->typeEntry()) << "); }\n";
+    s <<  "template<> inline PyTypeObject *SbkType< ::" << cppClass->qualifiedCppName() << " >() "
+      <<  "{ return reinterpret_cast<PyTypeObject *>(" << cpythonTypeNameExt(cppClass->typeEntry()) << "); }\n";
 }
 
 void HeaderGenerator::writeSbkTypeFunction(QTextStream &s, const AbstractMetaType *metaType)
 {
-    s <<  "template<> inline PyTypeObject* SbkType< ::" << metaType->cppSignature() << " >() "
-      <<  "{ return reinterpret_cast<PyTypeObject*>(" << cpythonTypeNameExt(metaType) << "); }\n";
+    s <<  "template<> inline PyTypeObject *SbkType< ::" << metaType->cppSignature() << " >() "
+      <<  "{ return reinterpret_cast<PyTypeObject *>(" << cpythonTypeNameExt(metaType) << "); }\n";
 }
 
-void HeaderGenerator::writeInheritedOverloads(QTextStream& s)
+void HeaderGenerator::writeInheritedOverloads(QTextStream &s)
 {
     for (const AbstractMetaFunction *func : qAsConst(m_inheritedOverloads)) {
         s << INDENT << "inline ";
@@ -608,9 +608,9 @@ void HeaderGenerator::writeInheritedOverloads(QTextStream& s)
         const AbstractMetaArgumentList &arguments = func->arguments();
         for (const AbstractMetaArgument *arg : arguments) {
             QString argName = arg->name();
-            const TypeEntry* enumTypeEntry = 0;
+            const TypeEntry *enumTypeEntry = nullptr;
             if (arg->type()->isFlags())
-                enumTypeEntry = static_cast<const FlagsTypeEntry*>(arg->type()->typeEntry())->originator();
+                enumTypeEntry = static_cast<const FlagsTypeEntry *>(arg->type()->typeEntry())->originator();
             else if (arg->type()->isEnum())
                 enumTypeEntry = arg->type()->typeEntry();
             if (enumTypeEntry)
diff --git a/sources/shiboken2/generator/shiboken2/headergenerator.h b/sources/shiboken2/generator/shiboken2/headergenerator.h
index f59e0fd9a..5f59dd13a 100644
--- a/sources/shiboken2/generator/shiboken2/headergenerator.h
+++ b/sources/shiboken2/generator/shiboken2/headergenerator.h
@@ -48,22 +48,22 @@ public:
 protected:
     QString fileNameSuffix() const override;
     QString fileNameForContext(GeneratorContext &context) const override;
-    void generateClass(QTextStream& s, GeneratorContext &classContext) override;
+    void generateClass(QTextStream &s, GeneratorContext &classContext) override;
     bool finishGeneration() override;
 
 private:
-    void writeCopyCtor(QTextStream &s, const AbstractMetaClass* metaClass) const;
-    void writeProtectedFieldAccessors(QTextStream& s, const AbstractMetaField* field) const;
-    void writeFunction(QTextStream& s, const AbstractMetaFunction* func);
-    void writeSbkTypeFunction(QTextStream& s, const AbstractMetaEnum* cppEnum);
-    void writeSbkTypeFunction(QTextStream& s, const AbstractMetaClass* cppClass);
+    void writeCopyCtor(QTextStream &s, const AbstractMetaClass *metaClass) const;
+    void writeProtectedFieldAccessors(QTextStream &s, const AbstractMetaField *field) const;
+    void writeFunction(QTextStream &s, const AbstractMetaFunction *func);
+    void writeSbkTypeFunction(QTextStream &s, const AbstractMetaEnum *cppEnum);
+    void writeSbkTypeFunction(QTextStream &s, const AbstractMetaClass *cppClass);
     void writeSbkTypeFunction(QTextStream &s, const AbstractMetaType *metaType);
-    void writeTypeIndexValueLine(QTextStream& s, const TypeEntry* typeEntry);
-    void writeTypeIndexValueLines(QTextStream& s, const AbstractMetaClass* metaClass);
-    void writeProtectedEnumSurrogate(QTextStream& s, const AbstractMetaEnum* cppEnum);
-    void writeInheritedOverloads(QTextStream& s);
+    void writeTypeIndexValueLine(QTextStream &s, const TypeEntry *typeEntry);
+    void writeTypeIndexValueLines(QTextStream &s, const AbstractMetaClass *metaClass);
+    void writeProtectedEnumSurrogate(QTextStream &s, const AbstractMetaEnum *cppEnum);
+    void writeInheritedOverloads(QTextStream &s);
 
-    QSet<const AbstractMetaFunction*> m_inheritedOverloads;
+    QSet<const AbstractMetaFunction *> m_inheritedOverloads;
 };
 
 #endif // HEADERGENERATOR_H
diff --git a/sources/shiboken2/generator/shiboken2/overloaddata.cpp b/sources/shiboken2/generator/shiboken2/overloaddata.cpp
index becd66879..89c73576e 100644
--- a/sources/shiboken2/generator/shiboken2/overloaddata.cpp
+++ b/sources/shiboken2/generator/shiboken2/overloaddata.cpp
@@ -40,7 +40,7 @@
 static const TypeEntry *getReferencedTypeEntry(const TypeEntry *typeEntry)
 {
     if (typeEntry->isPrimitive()) {
-        const PrimitiveTypeEntry* pte = dynamic_cast<const PrimitiveTypeEntry*>(typeEntry);
+        auto pte = dynamic_cast<const PrimitiveTypeEntry *>(typeEntry);
         while (pte->referencedTypeEntry())
             pte = pte->referencedTypeEntry();
         typeEntry = pte;
@@ -48,9 +48,9 @@ static const TypeEntry *getReferencedTypeEntry(const TypeEntry *typeEntry)
     return typeEntry;
 }
 
-static QString getTypeName(const AbstractMetaType* type)
+static QString getTypeName(const AbstractMetaType *type)
 {
-    const TypeEntry* typeEntry = getReferencedTypeEntry(type->typeEntry());
+    const TypeEntry *typeEntry = getReferencedTypeEntry(type->typeEntry());
     QString typeName = typeEntry->name();
     if (typeEntry->isContainer()) {
         QStringList types;
@@ -64,12 +64,12 @@ static QString getTypeName(const AbstractMetaType* type)
     return typeName;
 }
 
-static QString getTypeName(const OverloadData* ov)
+static QString getTypeName(const OverloadData *ov)
 {
     return ov->hasArgumentTypeReplace() ? ov->argumentTypeReplaced() : getTypeName(ov->argType());
 }
 
-static bool typesAreEqual(const AbstractMetaType* typeA, const AbstractMetaType* typeB)
+static bool typesAreEqual(const AbstractMetaType *typeA, const AbstractMetaType *typeB)
 {
     if (typeA->typeEntry() == typeB->typeEntry()) {
         if (typeA->isContainer() || typeA->isSmartPointer()) {
@@ -100,7 +100,7 @@ struct OverloadSortData
      * a OverloadData. This is done to express type dependencies that could
      * or could not appear in overloaded signatures not processed yet.
      */
-    void mapType(const QString& typeName)
+    void mapType(const QString &typeName)
     {
         if (map.contains(typeName))
             return;
@@ -110,7 +110,7 @@ struct OverloadSortData
         counter++;
     }
 
-    void mapType(OverloadData* overloadData)
+    void mapType(OverloadData *overloadData)
     {
         QString typeName = getTypeName(overloadData);
         map[typeName] = counter;
@@ -122,7 +122,7 @@ struct OverloadSortData
 
     int counter = 0;
     QHash<QString, int> map;                // typeName -> id
-    QHash<int, OverloadData*> reverseMap;   // id -> OverloadData;
+    QHash<int, OverloadData *> reverseMap;   // id -> OverloadData;
 };
 
 /**
@@ -130,10 +130,10 @@ struct OverloadSortData
  * an instantiation taken either from an implicit conversion expressed by the function argument,
  * or from the string argument implicitConvTypeName.
  */
-static QString getImplicitConversionTypeName(const AbstractMetaType* containerType,
-                                             const AbstractMetaType* instantiation,
-                                             const AbstractMetaFunction* function,
-                                             const QString& implicitConvTypeName = QString())
+static QString getImplicitConversionTypeName(const AbstractMetaType *containerType,
+                                             const AbstractMetaType *instantiation,
+                                             const AbstractMetaFunction *function,
+                                             const QString &implicitConvTypeName = QString())
 {
     QString impConv;
     if (!implicitConvTypeName.isEmpty())
@@ -267,7 +267,7 @@ void OverloadData::sortNextOverloads()
     // Create the graph of type dependencies based on implicit conversions.
     Graph graph(sortData.reverseMap.count());
     // All C++ primitive types, add any forgotten type AT THE END OF THIS LIST!
-    const char* primitiveTypes[] = {"int",
+    const char *primitiveTypes[] = {"int",
                                     "unsigned int",
                                     "long",
                                     "unsigned long",
@@ -280,7 +280,7 @@ void OverloadData::sortNextOverloads()
                                     "double",
                                     "const char*"
                                     };
-    const int numPrimitives = sizeof(primitiveTypes)/sizeof(const char*);
+    const int numPrimitives = sizeof(primitiveTypes)/sizeof(const char *);
     bool hasPrimitive[numPrimitives];
     for (int i = 0; i < numPrimitives; ++i)
         hasPrimitive[i] = sortData.map.contains(QLatin1String(primitiveTypes[i]));
@@ -293,7 +293,7 @@ void OverloadData::sortNextOverloads()
     MetaFunctionList involvedConversions;
 
     for (OverloadData *ov : qAsConst(m_nextOverloadData)) {
-        const AbstractMetaType* targetType = ov->argType();
+        const AbstractMetaType *targetType = ov->argType();
         const QString targetTypeEntryName(getTypeName(ov));
         int targetTypeId = sortData.map[targetTypeEntryName];
 
@@ -404,7 +404,7 @@ void OverloadData::sortNextOverloads()
         graph.addEdge(sortData.map[QLatin1String("QString")], sortData.map[QLatin1String("QByteArray")]);
 
     for (OverloadData *ov : qAsConst(m_nextOverloadData)) {
-        const AbstractMetaType* targetType = ov->argType();
+        const AbstractMetaType *targetType = ov->argType();
         if (!targetType->isEnum())
             continue;
 
@@ -462,11 +462,11 @@ void OverloadData::sortNextOverloads()
  *
  * Given these two overloads, there will be the following graph:
  *
- *   addStuff - double - PyObject*
+ *   addStuff - double - PyObject *
  *                    \- int
  *
  */
-OverloadData::OverloadData(const AbstractMetaFunctionList& overloads, const ShibokenGenerator* generator)
+OverloadData::OverloadData(const AbstractMetaFunctionList &overloads, const ShibokenGenerator *generator)
     : m_minArgs(256), m_maxArgs(0), m_argPos(-1), m_argType(0),
     m_headOverloadData(this), m_previousOverloadData(0), m_generator(generator)
 {
@@ -477,7 +477,7 @@ OverloadData::OverloadData(const AbstractMetaFunctionList& overloads, const Shib
             m_minArgs = argSize;
         else if (m_maxArgs < argSize)
             m_maxArgs = argSize;
-        OverloadData* currentOverloadData = this;
+        OverloadData *currentOverloadData = this;
         const AbstractMetaArgumentList &arguments = func->arguments();
         for (const AbstractMetaArgument *arg : arguments) {
             if (func->argumentRemoved(arg->argumentIndex() + 1))
@@ -495,8 +495,8 @@ OverloadData::OverloadData(const AbstractMetaFunctionList& overloads, const Shib
         m_headOverloadData->m_minArgs = maxArgs();
 }
 
-OverloadData::OverloadData(OverloadData* headOverloadData, const AbstractMetaFunction* func,
-                                 const AbstractMetaType* argType, int argPos)
+OverloadData::OverloadData(OverloadData *headOverloadData, const AbstractMetaFunction *func,
+                                 const AbstractMetaType *argType, int argPos)
     : m_minArgs(256), m_maxArgs(0), m_argPos(argPos), m_argType(argType),
       m_headOverloadData(headOverloadData), m_previousOverloadData(nullptr),
       m_generator(nullptr)
@@ -505,7 +505,7 @@ OverloadData::OverloadData(OverloadData* headOverloadData, const AbstractMetaFun
         this->addOverload(func);
 }
 
-void OverloadData::addOverload(const AbstractMetaFunction* func)
+void OverloadData::addOverload(const AbstractMetaFunction *func)
 {
     int origNumArgs = func->arguments().size();
     int removed = numberOfRemovedArguments(func);
@@ -530,11 +530,11 @@ void OverloadData::addOverload(const AbstractMetaFunction* func)
     m_overloads.append(func);
 }
 
-OverloadData* OverloadData::addOverloadData(const AbstractMetaFunction* func,
-                                            const AbstractMetaArgument* arg)
+OverloadData *OverloadData::addOverloadData(const AbstractMetaFunction *func,
+                                            const AbstractMetaArgument *arg)
 {
-    const AbstractMetaType* argType = arg->type();
-    OverloadData* overloadData = 0;
+    const AbstractMetaType *argType = arg->type();
+    OverloadData *overloadData = nullptr;
     if (!func->isOperatorOverload()) {
         for (OverloadData *tmp : qAsConst(m_nextOverloadData)) {
             // TODO: 'const char *', 'char *' and 'char' will have the same TypeEntry?
@@ -604,7 +604,7 @@ bool OverloadData::hasAllowThread() const
     return false;
 }
 
-bool OverloadData::hasStaticFunction(const AbstractMetaFunctionList& overloads)
+bool OverloadData::hasStaticFunction(const AbstractMetaFunctionList &overloads)
 {
     for (const AbstractMetaFunction *func : qAsConst(overloads)) {
         if (func->isStatic())
@@ -622,7 +622,7 @@ bool OverloadData::hasStaticFunction() const
     return false;
 }
 
-bool OverloadData::hasInstanceFunction(const AbstractMetaFunctionList& overloads)
+bool OverloadData::hasInstanceFunction(const AbstractMetaFunctionList &overloads)
 {
     for (const AbstractMetaFunction *func : qAsConst(overloads)) {
         if (!func->isStatic())
@@ -640,7 +640,7 @@ bool OverloadData::hasInstanceFunction() const
     return false;
 }
 
-bool OverloadData::hasStaticAndInstanceFunctions(const AbstractMetaFunctionList& overloads)
+bool OverloadData::hasStaticAndInstanceFunctions(const AbstractMetaFunctionList &overloads)
 {
     return OverloadData::hasStaticFunction(overloads) && OverloadData::hasInstanceFunction(overloads);
 }
@@ -650,12 +650,12 @@ bool OverloadData::hasStaticAndInstanceFunctions() const
     return OverloadData::hasStaticFunction() && OverloadData::hasInstanceFunction();
 }
 
-const AbstractMetaFunction* OverloadData::referenceFunction() const
+const AbstractMetaFunction *OverloadData::referenceFunction() const
 {
     return m_overloads.constFirst();
 }
 
-const AbstractMetaArgument* OverloadData::argument(const AbstractMetaFunction* func) const
+const AbstractMetaArgument *OverloadData::argument(const AbstractMetaFunction *func) const
 {
     if (isHeadOverloadData() || !m_overloads.contains(func))
         return 0;
@@ -672,7 +672,7 @@ const AbstractMetaArgument* OverloadData::argument(const AbstractMetaFunction* f
     return func->arguments().at(m_argPos + removed);
 }
 
-OverloadDataList OverloadData::overloadDataOnPosition(OverloadData* overloadData, int argPos) const
+OverloadDataList OverloadData::overloadDataOnPosition(OverloadData *overloadData, int argPos) const
 {
     OverloadDataList overloadDataList;
     if (overloadData->argPos() == argPos) {
@@ -701,27 +701,27 @@ bool OverloadData::nextArgumentHasDefaultValue() const
     return false;
 }
 
-static OverloadData* _findNextArgWithDefault(OverloadData* overloadData)
+static OverloadData *_findNextArgWithDefault(OverloadData *overloadData)
 {
     if (overloadData->getFunctionWithDefaultValue())
         return overloadData;
 
-    OverloadData* result = 0;
+    OverloadData *result = nullptr;
     const OverloadDataList &data = overloadData->nextOverloadData();
     for (OverloadData *odata : data) {
-        OverloadData* tmp = _findNextArgWithDefault(odata);
+        OverloadData *tmp = _findNextArgWithDefault(odata);
         if (!result || (tmp && result->argPos() > tmp->argPos()))
             result = tmp;
     }
     return result;
 }
 
-OverloadData* OverloadData::findNextArgWithDefault()
+OverloadData *OverloadData::findNextArgWithDefault()
 {
     return _findNextArgWithDefault(this);
 }
 
-bool OverloadData::isFinalOccurrence(const AbstractMetaFunction* func) const
+bool OverloadData::isFinalOccurrence(const AbstractMetaFunction *func) const
 {
     for (const OverloadData *pd : m_nextOverloadData) {
         if (pd->overloads().contains(func))
@@ -746,7 +746,7 @@ OverloadData::MetaFunctionList OverloadData::overloadsWithoutRepetition() const
     return overloads;
 }
 
-const AbstractMetaFunction* OverloadData::getFunctionWithDefaultValue() const
+const AbstractMetaFunction *OverloadData::getFunctionWithDefaultValue() const
 {
     for (const AbstractMetaFunction *func : m_overloads) {
         int removedArgs = 0;
@@ -787,7 +787,7 @@ QVector<int> OverloadData::invalidArgumentLengths() const
     return invalidArgLengths;
 }
 
-int OverloadData::numberOfRemovedArguments(const AbstractMetaFunction* func, int finalArgPos)
+int OverloadData::numberOfRemovedArguments(const AbstractMetaFunction *func, int finalArgPos)
 {
     int removed = 0;
     if (finalArgPos < 0) {
@@ -804,7 +804,7 @@ int OverloadData::numberOfRemovedArguments(const AbstractMetaFunction* func, int
     return removed;
 }
 
-QPair<int, int> OverloadData::getMinMaxArguments(const AbstractMetaFunctionList& overloads)
+QPair<int, int> OverloadData::getMinMaxArguments(const AbstractMetaFunctionList &overloads)
 {
     int minArgs = 10000;
     int maxArgs = 0;
@@ -827,7 +827,7 @@ QPair<int, int> OverloadData::getMinMaxArguments(const AbstractMetaFunctionList&
     return {minArgs, maxArgs};
 }
 
-bool OverloadData::isSingleArgument(const AbstractMetaFunctionList& overloads)
+bool OverloadData::isSingleArgument(const AbstractMetaFunctionList &overloads)
 {
     bool singleArgument = true;
     for (const AbstractMetaFunction *func : overloads) {
@@ -863,7 +863,7 @@ QString OverloadData::dumpGraph() const
     QString result;
     QTextStream s(&result);
     if (m_argPos == -1) {
-        const AbstractMetaFunction* rfunc = referenceFunction();
+        const AbstractMetaFunction *rfunc = referenceFunction();
         s << "digraph OverloadedFunction {" << endl;
         s << INDENT << "graph [fontsize=12 fontname=freemono labelloc=t splines=true overlap=false rankdir=LR];" << endl;
 
@@ -964,7 +964,7 @@ QString OverloadData::dumpGraph() const
 
         // Show default values (original and modified) for various functions
         for (const AbstractMetaFunction *func : m_overloads) {
-            const AbstractMetaArgument* arg = argument(func);
+            const AbstractMetaArgument *arg = argument(func);
             if (!arg)
                 continue;
             QString argDefault = ShibokenGenerator::getDefaultValue(func, arg);
@@ -989,7 +989,7 @@ QString OverloadData::dumpGraph() const
     return result;
 }
 
-int OverloadData::functionNumber(const AbstractMetaFunction* func) const
+int OverloadData::functionNumber(const AbstractMetaFunction *func) const
 {
     return m_headOverloadData->m_overloads.indexOf(func);
 }
@@ -1010,7 +1010,7 @@ QString OverloadData::argumentTypeReplaced() const
     return m_argTypeReplaced;
 }
 
-bool OverloadData::hasArgumentWithDefaultValue(const AbstractMetaFunctionList& overloads)
+bool OverloadData::hasArgumentWithDefaultValue(const AbstractMetaFunctionList &overloads)
 {
     if (OverloadData::getMinMaxArguments(overloads).second == 0)
         return false;
@@ -1032,7 +1032,7 @@ bool OverloadData::hasArgumentWithDefaultValue() const
     return false;
 }
 
-bool OverloadData::hasArgumentWithDefaultValue(const AbstractMetaFunction* func)
+bool OverloadData::hasArgumentWithDefaultValue(const AbstractMetaFunction *func)
 {
     const AbstractMetaArgumentList &arguments = func->arguments();
     for (const AbstractMetaArgument *arg : arguments) {
@@ -1044,7 +1044,7 @@ bool OverloadData::hasArgumentWithDefaultValue(const AbstractMetaFunction* func)
     return false;
 }
 
-AbstractMetaArgumentList OverloadData::getArgumentsWithDefaultValues(const AbstractMetaFunction* func)
+AbstractMetaArgumentList OverloadData::getArgumentsWithDefaultValues(const AbstractMetaFunction *func)
 {
     AbstractMetaArgumentList args;
     const AbstractMetaArgumentList &arguments = func->arguments();
diff --git a/sources/shiboken2/generator/shiboken2/overloaddata.h b/sources/shiboken2/generator/shiboken2/overloaddata.h
index 4759ca9c3..c9304d461 100644
--- a/sources/shiboken2/generator/shiboken2/overloaddata.h
+++ b/sources/shiboken2/generator/shiboken2/overloaddata.h
@@ -45,14 +45,14 @@ class OverloadData
 public:
     typedef QVector<const AbstractMetaFunction *> MetaFunctionList;
 
-    OverloadData(const AbstractMetaFunctionList& overloads, const ShibokenGenerator* generator);
+    OverloadData(const AbstractMetaFunctionList &overloads, const ShibokenGenerator *generator);
     ~OverloadData();
 
     int minArgs() const { return m_headOverloadData->m_minArgs; }
     int maxArgs() const { return m_headOverloadData->m_maxArgs; }
     int argPos() const { return m_argPos; }
 
-    const AbstractMetaType* argType() const { return m_argType; }
+    const AbstractMetaType *argType() const { return m_argType; }
 
     /// Returns a string list containing all the possible return types (including void) for the current OverloadData.
     QStringList returnTypes() const;
@@ -70,49 +70,49 @@ public:
     bool hasStaticFunction() const;
 
     /// Returns true if any of the overloads passed as argument is static.
-    static bool hasStaticFunction(const AbstractMetaFunctionList& overloads);
+    static bool hasStaticFunction(const AbstractMetaFunctionList &overloads);
 
     /// Returns true if any of the overloads for the current OverloadData is not static.
     bool hasInstanceFunction() const;
 
     /// Returns true if any of the overloads passed as argument is not static.
-    static bool hasInstanceFunction(const AbstractMetaFunctionList& overloads);
+    static bool hasInstanceFunction(const AbstractMetaFunctionList &overloads);
 
     /// Returns true if among the overloads for the current OverloadData there are static and non-static methods altogether.
     bool hasStaticAndInstanceFunctions() const;
 
     /// Returns true if among the overloads passed as argument there are static and non-static methods altogether.
-    static bool hasStaticAndInstanceFunctions(const AbstractMetaFunctionList& overloads);
+    static bool hasStaticAndInstanceFunctions(const AbstractMetaFunctionList &overloads);
 
-    const AbstractMetaFunction* referenceFunction() const;
-    const AbstractMetaArgument* argument(const AbstractMetaFunction* func) const;
+    const AbstractMetaFunction *referenceFunction() const;
+    const AbstractMetaArgument *argument(const AbstractMetaFunction *func) const;
     OverloadDataList overloadDataOnPosition(int argPos) const;
 
     bool isHeadOverloadData() const { return this == m_headOverloadData; }
 
     /// Returns the root OverloadData object that represents all the overloads.
-    OverloadData* headOverloadData() const { return m_headOverloadData; }
+    OverloadData *headOverloadData() const { return m_headOverloadData; }
 
     /// Returns the function that has a default value at the current OverloadData argument position, otherwise returns null.
-    const AbstractMetaFunction* getFunctionWithDefaultValue() const;
+    const AbstractMetaFunction *getFunctionWithDefaultValue() const;
 
     bool nextArgumentHasDefaultValue() const;
     /// Returns the nearest occurrence, including this instance, of an argument with a default value.
-    OverloadData* findNextArgWithDefault();
-    bool isFinalOccurrence(const AbstractMetaFunction* func) const;
+    OverloadData *findNextArgWithDefault();
+    bool isFinalOccurrence(const AbstractMetaFunction *func) const;
 
     /// Returns the list of overloads removing repeated constant functions (ex.: "foo()" and "foo()const", the second is removed).
     MetaFunctionList overloadsWithoutRepetition() const;
-    const MetaFunctionList& overloads() const { return m_overloads; }
+    const MetaFunctionList &overloads() const { return m_overloads; }
     OverloadDataList nextOverloadData() const { return m_nextOverloadData; }
-    OverloadData* previousOverloadData() const { return m_previousOverloadData; }
+    OverloadData *previousOverloadData() const { return m_previousOverloadData; }
 
     QVector<int> invalidArgumentLengths() const;
 
-    static int numberOfRemovedArguments(const AbstractMetaFunction* func, int finalArgPos = -1);
-    static QPair<int, int> getMinMaxArguments(const AbstractMetaFunctionList& overloads);
+    static int numberOfRemovedArguments(const AbstractMetaFunction *func, int finalArgPos = -1);
+    static QPair<int, int> getMinMaxArguments(const AbstractMetaFunctionList &overloads);
     /// Returns true if all overloads have no more than one argument.
-    static bool isSingleArgument(const AbstractMetaFunctionList& overloads);
+    static bool isSingleArgument(const AbstractMetaFunctionList &overloads);
 
     void dumpGraph(const QString &filename) const;
     QString dumpGraph() const;
@@ -121,39 +121,39 @@ public:
     QString argumentTypeReplaced() const;
 
     bool hasArgumentWithDefaultValue() const;
-    static bool hasArgumentWithDefaultValue(const AbstractMetaFunctionList& overloads);
-    static bool hasArgumentWithDefaultValue(const AbstractMetaFunction* func);
+    static bool hasArgumentWithDefaultValue(const AbstractMetaFunctionList &overloads);
+    static bool hasArgumentWithDefaultValue(const AbstractMetaFunction *func);
 
     /// Returns a list of function arguments which have default values and were not removed.
-    static AbstractMetaArgumentList getArgumentsWithDefaultValues(const AbstractMetaFunction* func);
+    static AbstractMetaArgumentList getArgumentsWithDefaultValues(const AbstractMetaFunction *func);
 
 #ifndef QT_NO_DEBUG_STREAM
     void formatDebug(QDebug &) const;
 #endif
 
 private:
-    OverloadData(OverloadData* headOverloadData, const AbstractMetaFunction* func,
-                 const AbstractMetaType* argType, int argPos);
+    OverloadData(OverloadData *headOverloadData, const AbstractMetaFunction *func,
+                 const AbstractMetaType *argType, int argPos);
 
-    void addOverload(const AbstractMetaFunction* func);
-    OverloadData* addOverloadData(const AbstractMetaFunction* func, const AbstractMetaArgument* arg);
+    void addOverload(const AbstractMetaFunction *func);
+    OverloadData *addOverloadData(const AbstractMetaFunction *func, const AbstractMetaArgument *arg);
 
     void sortNextOverloads();
 
-    int functionNumber(const AbstractMetaFunction* func) const;
-    OverloadDataList overloadDataOnPosition(OverloadData* overloadData, int argPos) const;
+    int functionNumber(const AbstractMetaFunction *func) const;
+    OverloadDataList overloadDataOnPosition(OverloadData *overloadData, int argPos) const;
 
     int m_minArgs;
     int m_maxArgs;
     int m_argPos;
-    const AbstractMetaType* m_argType;
+    const AbstractMetaType *m_argType;
     QString m_argTypeReplaced;
     MetaFunctionList m_overloads;
 
-    OverloadData* m_headOverloadData;
+    OverloadData *m_headOverloadData;
     OverloadDataList m_nextOverloadData;
-    OverloadData* m_previousOverloadData;
-    const ShibokenGenerator* m_generator;
+    OverloadData *m_previousOverloadData;
+    const ShibokenGenerator *m_generator;
 };
 
 #ifndef QT_NO_DEBUG_STREAM
diff --git a/sources/shiboken2/generator/shiboken2/shibokengenerator.cpp b/sources/shiboken2/generator/shiboken2/shibokengenerator.cpp
index 2b3b20c75..9ed175af4 100644
--- a/sources/shiboken2/generator/shiboken2/shibokengenerator.cpp
+++ b/sources/shiboken2/generator/shiboken2/shibokengenerator.cpp
@@ -62,7 +62,7 @@ const char *SMART_POINTER_GETTER = "kSmartPointerGetter";
 
 const char *CONV_RULE_OUT_VAR_SUFFIX = "_out";
 const char *BEGIN_ALLOW_THREADS =
-    "PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS";
+    "PyThreadState *_save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS";
 const char *END_ALLOW_THREADS = "PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS";
 
 //static void dumpFunction(AbstractMetaFunctionList lst);
@@ -277,15 +277,15 @@ void ShibokenGenerator::initKnownPythonTypes()
         << QLatin1String("PyObject*") << QLatin1String("PyObject *") << QLatin1String("PyTupleObject*");
 }
 
-QString ShibokenGenerator::translateTypeForWrapperMethod(const AbstractMetaType* cType,
-                                                         const AbstractMetaClass* context,
+QString ShibokenGenerator::translateTypeForWrapperMethod(const AbstractMetaType *cType,
+                                                         const AbstractMetaClass *context,
                                                          Options options) const
 {
     if (cType->isArray())
         return translateTypeForWrapperMethod(cType->arrayElementType(), context, options) + QLatin1String("[]");
 
     if (avoidProtectedHack() && cType->isEnum()) {
-        const AbstractMetaEnum* metaEnum = findAbstractMetaEnum(cType);
+        const AbstractMetaEnum *metaEnum = findAbstractMetaEnum(cType);
         if (metaEnum && metaEnum->isProtected())
             return protectedEnumSurrogateName(metaEnum);
     }
@@ -293,7 +293,7 @@ QString ShibokenGenerator::translateTypeForWrapperMethod(const AbstractMetaType*
     return translateType(cType, context, options);
 }
 
-bool ShibokenGenerator::shouldGenerateCppWrapper(const AbstractMetaClass* metaClass) const
+bool ShibokenGenerator::shouldGenerateCppWrapper(const AbstractMetaClass *metaClass) const
 {
     if (metaClass->isNamespace() || (metaClass->attributes() & AbstractMetaAttributes::FinalCppClass))
         return false;
@@ -320,7 +320,7 @@ bool ShibokenGenerator::shouldGenerateCppWrapper(const AbstractMetaClass* metaCl
     return result;
 }
 
-void ShibokenGenerator::lookForEnumsInClassesNotToBeGenerated(AbstractMetaEnumList& enumList, const AbstractMetaClass* metaClass)
+void ShibokenGenerator::lookForEnumsInClassesNotToBeGenerated(AbstractMetaEnumList &enumList, const AbstractMetaClass *metaClass)
 {
     if (!metaClass)
         return;
@@ -330,14 +330,14 @@ void ShibokenGenerator::lookForEnumsInClassesNotToBeGenerated(AbstractMetaEnumLi
         for (const AbstractMetaEnum *metaEnum : enums) {
             if (metaEnum->isPrivate() || metaEnum->typeEntry()->codeGeneration() == TypeEntry::GenerateForSubclass)
                 continue;
-            if (!enumList.contains(const_cast<AbstractMetaEnum*>(metaEnum)))
-                enumList.append(const_cast<AbstractMetaEnum*>(metaEnum));
+            if (!enumList.contains(const_cast<AbstractMetaEnum *>(metaEnum)))
+                enumList.append(const_cast<AbstractMetaEnum *>(metaEnum));
         }
         lookForEnumsInClassesNotToBeGenerated(enumList, metaClass->enclosingClass());
     }
 }
 
-static const AbstractMetaClass* getProperEnclosingClass(const AbstractMetaClass* metaClass)
+static const AbstractMetaClass *getProperEnclosingClass(const AbstractMetaClass *metaClass)
 {
     if (!metaClass)
         return 0;
@@ -348,12 +348,12 @@ static const AbstractMetaClass* getProperEnclosingClass(const AbstractMetaClass*
     return getProperEnclosingClass(metaClass->enclosingClass());
 }
 
-const AbstractMetaClass* ShibokenGenerator::getProperEnclosingClassForEnum(const AbstractMetaEnum* metaEnum)
+const AbstractMetaClass *ShibokenGenerator::getProperEnclosingClassForEnum(const AbstractMetaEnum *metaEnum)
 {
     return getProperEnclosingClass(metaEnum->enclosingClass());
 }
 
-QString ShibokenGenerator::wrapperName(const AbstractMetaClass* metaClass) const
+QString ShibokenGenerator::wrapperName(const AbstractMetaClass *metaClass) const
 {
     if (shouldGenerateCppWrapper(metaClass)) {
         QString result = metaClass->name();
@@ -403,22 +403,22 @@ QString ShibokenGenerator::fullPythonFunctionName(const AbstractMetaFunction *fu
     return funcName;
 }
 
-QString ShibokenGenerator::protectedEnumSurrogateName(const AbstractMetaEnum* metaEnum)
+QString ShibokenGenerator::protectedEnumSurrogateName(const AbstractMetaEnum *metaEnum)
 {
     return metaEnum->fullName().replace(QLatin1Char('.'), QLatin1Char('_')).replace(QLatin1String("::"), QLatin1String("_")) + QLatin1String("_Surrogate");
 }
 
-QString ShibokenGenerator::protectedFieldGetterName(const AbstractMetaField* field)
+QString ShibokenGenerator::protectedFieldGetterName(const AbstractMetaField *field)
 {
     return QStringLiteral("protected_%1_getter").arg(field->name());
 }
 
-QString ShibokenGenerator::protectedFieldSetterName(const AbstractMetaField* field)
+QString ShibokenGenerator::protectedFieldSetterName(const AbstractMetaField *field)
 {
     return QStringLiteral("protected_%1_setter").arg(field->name());
 }
 
-QString ShibokenGenerator::cpythonFunctionName(const AbstractMetaFunction* func)
+QString ShibokenGenerator::cpythonFunctionName(const AbstractMetaFunction *func)
 {
     QString result;
 
@@ -442,35 +442,35 @@ QString ShibokenGenerator::cpythonFunctionName(const AbstractMetaFunction* func)
     return result;
 }
 
-QString ShibokenGenerator::cpythonMethodDefinitionName(const AbstractMetaFunction* func)
+QString ShibokenGenerator::cpythonMethodDefinitionName(const AbstractMetaFunction *func)
 {
     if (!func->ownerClass())
         return QString();
     return QStringLiteral("%1Method_%2").arg(cpythonBaseName(func->ownerClass()->typeEntry()), func->name());
 }
 
-QString ShibokenGenerator::cpythonGettersSettersDefinitionName(const AbstractMetaClass* metaClass)
+QString ShibokenGenerator::cpythonGettersSettersDefinitionName(const AbstractMetaClass *metaClass)
 {
     return cpythonBaseName(metaClass) + QLatin1String("_getsetlist");
 }
 
-QString ShibokenGenerator::cpythonSetattroFunctionName(const AbstractMetaClass* metaClass)
+QString ShibokenGenerator::cpythonSetattroFunctionName(const AbstractMetaClass *metaClass)
 {
     return cpythonBaseName(metaClass) + QLatin1String("_setattro");
 }
 
 
-QString ShibokenGenerator::cpythonGetattroFunctionName(const AbstractMetaClass* metaClass)
+QString ShibokenGenerator::cpythonGetattroFunctionName(const AbstractMetaClass *metaClass)
 {
     return cpythonBaseName(metaClass) + QLatin1String("_getattro");
 }
 
-QString ShibokenGenerator::cpythonGetterFunctionName(const AbstractMetaField* metaField)
+QString ShibokenGenerator::cpythonGetterFunctionName(const AbstractMetaField *metaField)
 {
     return QStringLiteral("%1_get_%2").arg(cpythonBaseName(metaField->enclosingClass()), metaField->name());
 }
 
-QString ShibokenGenerator::cpythonSetterFunctionName(const AbstractMetaField* metaField)
+QString ShibokenGenerator::cpythonSetterFunctionName(const AbstractMetaField *metaField)
 {
     return QStringLiteral("%1_set_%2").arg(cpythonBaseName(metaField->enclosingClass()), metaField->name());
 }
@@ -484,7 +484,7 @@ static QString cpythonEnumFlagsName(const QString &moduleName,
 }
 
 // Return the scope for fully qualifying the enumeration including trailing "::".
-static QString searchForEnumScope(const AbstractMetaClass* metaClass, const QString& value)
+static QString searchForEnumScope(const AbstractMetaClass *metaClass, const QString &value)
 {
     if (!metaClass)
         return QString();
@@ -587,7 +587,7 @@ QString ShibokenGenerator::guessScopeForDefaultValue(const AbstractMetaFunction
 
     QString prefix;
     if (arg->type()->isEnum()) {
-        if (const AbstractMetaEnum* metaEnum = findAbstractMetaEnum(arg->type()))
+        if (const AbstractMetaEnum *metaEnum = findAbstractMetaEnum(arg->type()))
             prefix = resolveScopePrefix(metaEnum, value);
     } else if (arg->type()->isFlags()) {
         value = guessScopeForDefaultFlagsValue(func, arg, value);
@@ -626,7 +626,7 @@ QString ShibokenGenerator::guessScopeForDefaultValue(const AbstractMetaFunction
     return value;
 }
 
-QString ShibokenGenerator::cpythonEnumName(const EnumTypeEntry* enumEntry)
+QString ShibokenGenerator::cpythonEnumName(const EnumTypeEntry *enumEntry)
 {
     QString p = enumEntry->targetLangPackage();
     p.replace(QLatin1Char('.'), QLatin1Char('_'));
@@ -638,7 +638,7 @@ QString ShibokenGenerator::cpythonEnumName(const AbstractMetaEnum *metaEnum)
     return cpythonEnumName(metaEnum->typeEntry());
 }
 
-QString ShibokenGenerator::cpythonFlagsName(const FlagsTypeEntry* flagsEntry)
+QString ShibokenGenerator::cpythonFlagsName(const FlagsTypeEntry *flagsEntry)
 {
     QString p = flagsEntry->targetLangPackage();
     p.replace(QLatin1Char('.'), QLatin1Char('_'));
@@ -653,12 +653,12 @@ QString ShibokenGenerator::cpythonFlagsName(const AbstractMetaEnum *metaEnum)
     return cpythonFlagsName(flags);
 }
 
-QString ShibokenGenerator::cpythonSpecialCastFunctionName(const AbstractMetaClass* metaClass)
+QString ShibokenGenerator::cpythonSpecialCastFunctionName(const AbstractMetaClass *metaClass)
 {
     return cpythonBaseName(metaClass->typeEntry()) + QLatin1String("SpecialCastFunction");
 }
 
-QString ShibokenGenerator::cpythonWrapperCPtr(const AbstractMetaClass* metaClass,
+QString ShibokenGenerator::cpythonWrapperCPtr(const AbstractMetaClass *metaClass,
                                               const QString &argName)
 {
     return cpythonWrapperCPtr(metaClass->typeEntry(), argName);
@@ -674,7 +674,7 @@ QString ShibokenGenerator::cpythonWrapperCPtr(const AbstractMetaType *metaType,
         + QLatin1String(", reinterpret_cast<SbkObject *>(") + argName + QLatin1String(")))");
 }
 
-QString ShibokenGenerator::cpythonWrapperCPtr(const TypeEntry* type,
+QString ShibokenGenerator::cpythonWrapperCPtr(const TypeEntry *type,
                                               const QString &argName)
 {
     if (!ShibokenGenerator::isWrapperType(type))
@@ -684,31 +684,31 @@ QString ShibokenGenerator::cpythonWrapperCPtr(const TypeEntry* type,
         + QLatin1String(", reinterpret_cast<SbkObject *>(") + argName + QLatin1String(")))");
 }
 
-void ShibokenGenerator::writeToPythonConversion(QTextStream & s, const AbstractMetaType* type,
+void ShibokenGenerator::writeToPythonConversion(QTextStream & s, const AbstractMetaType *type,
                                                 const AbstractMetaClass * /* context */,
-                                                const QString& argumentName)
+                                                const QString &argumentName)
 {
     s << cpythonToPythonConversionFunction(type) << argumentName << ')';
 }
 
-void ShibokenGenerator::writeToCppConversion(QTextStream& s, const AbstractMetaClass* metaClass,
-                                             const QString& inArgName, const QString& outArgName)
+void ShibokenGenerator::writeToCppConversion(QTextStream &s, const AbstractMetaClass *metaClass,
+                                             const QString &inArgName, const QString &outArgName)
 {
     s << cpythonToCppConversionFunction(metaClass) << inArgName << ", &" << outArgName << ')';
 }
 
-void ShibokenGenerator::writeToCppConversion(QTextStream& s, const AbstractMetaType* type, const AbstractMetaClass* context,
-                                             const QString& inArgName, const QString& outArgName)
+void ShibokenGenerator::writeToCppConversion(QTextStream &s, const AbstractMetaType *type, const AbstractMetaClass *context,
+                                             const QString &inArgName, const QString &outArgName)
 {
     s << cpythonToCppConversionFunction(type, context) << inArgName << ", &" << outArgName << ')';
 }
 
-bool ShibokenGenerator::shouldRejectNullPointerArgument(const AbstractMetaFunction* func, int argIndex)
+bool ShibokenGenerator::shouldRejectNullPointerArgument(const AbstractMetaFunction *func, int argIndex)
 {
     if (argIndex < 0 || argIndex >= func->arguments().count())
         return false;
 
-    const AbstractMetaArgument* arg = func->arguments().at(argIndex);
+    const AbstractMetaArgument *arg = func->arguments().at(argIndex);
     if (isValueTypeWithCopyConstructorOnly(arg->type()))
         return true;
 
@@ -728,7 +728,7 @@ bool ShibokenGenerator::shouldRejectNullPointerArgument(const AbstractMetaFuncti
     return false;
 }
 
-QString ShibokenGenerator::getFormatUnitString(const AbstractMetaFunction* func, bool incRef) const
+QString ShibokenGenerator::getFormatUnitString(const AbstractMetaFunction *func, bool incRef) const
 {
     QString result;
     const char objType = (incRef ? 'O' : 'N');
@@ -772,19 +772,19 @@ QString ShibokenGenerator::getFormatUnitString(const AbstractMetaFunction* func,
     return result;
 }
 
-QString ShibokenGenerator::cpythonBaseName(const AbstractMetaType* type)
+QString ShibokenGenerator::cpythonBaseName(const AbstractMetaType *type)
 {
     if (isCString(type))
         return QLatin1String("PyString");
     return cpythonBaseName(type->typeEntry());
 }
 
-QString ShibokenGenerator::cpythonBaseName(const AbstractMetaClass* metaClass)
+QString ShibokenGenerator::cpythonBaseName(const AbstractMetaClass *metaClass)
 {
     return cpythonBaseName(metaClass->typeEntry());
 }
 
-QString ShibokenGenerator::cpythonBaseName(const TypeEntry* type)
+QString ShibokenGenerator::cpythonBaseName(const TypeEntry *type)
 {
     QString baseName;
     if (ShibokenGenerator::isWrapperType(type) || type->isNamespace()) { // && type->referenceType() == NoReference) {
@@ -834,28 +834,28 @@ QString ShibokenGenerator::cpythonBaseName(const TypeEntry* type)
     return baseName.replace(QLatin1String("::"), QLatin1String("_"));
 }
 
-QString ShibokenGenerator::cpythonTypeName(const AbstractMetaClass* metaClass)
+QString ShibokenGenerator::cpythonTypeName(const AbstractMetaClass *metaClass)
 {
     return cpythonTypeName(metaClass->typeEntry());
 }
 
-QString ShibokenGenerator::cpythonTypeName(const TypeEntry* type)
+QString ShibokenGenerator::cpythonTypeName(const TypeEntry *type)
 {
     return cpythonBaseName(type) + QLatin1String("_TypeF()");
 }
 
-QString ShibokenGenerator::cpythonTypeNameExt(const TypeEntry* type)
+QString ShibokenGenerator::cpythonTypeNameExt(const TypeEntry *type)
 {
     return cppApiVariableName(type->targetLangPackage()) + QLatin1Char('[')
             + getTypeIndexVariableName(type) + QLatin1Char(']');
 }
 
-QString ShibokenGenerator::converterObject(const AbstractMetaType* type)
+QString ShibokenGenerator::converterObject(const AbstractMetaType *type)
 {
     if (isCString(type))
-        return QLatin1String("Shiboken::Conversions::PrimitiveTypeConverter<const char*>()");
+        return QLatin1String("Shiboken::Conversions::PrimitiveTypeConverter<const char *>()");
     if (isVoidPointer(type))
-        return QLatin1String("Shiboken::Conversions::PrimitiveTypeConverter<void*>()");
+        return QLatin1String("Shiboken::Conversions::PrimitiveTypeConverter<void *>()");
     const AbstractMetaTypeCList nestedArrayTypes = type->nestedArrayTypes();
     if (!nestedArrayTypes.isEmpty() && nestedArrayTypes.constLast()->isCppPrimitive()) {
         return QStringLiteral("Shiboken::Conversions::ArrayTypeConverter<")
@@ -870,7 +870,7 @@ QString ShibokenGenerator::converterObject(const AbstractMetaType* type)
     return converterObject(type->typeEntry());
 }
 
-QString ShibokenGenerator::converterObject(const TypeEntry* type)
+QString ShibokenGenerator::converterObject(const TypeEntry *type)
 {
     if (isCppPrimitive(type))
         return QString::fromLatin1("Shiboken::Conversions::PrimitiveTypeConverter<%1>()").arg(type->qualifiedCppName());
@@ -883,7 +883,7 @@ QString ShibokenGenerator::converterObject(const TypeEntry* type)
     }
 
     /* the typedef'd primitive types case */
-    const PrimitiveTypeEntry* pte = dynamic_cast<const PrimitiveTypeEntry*>(type);
+    const PrimitiveTypeEntry *pte = dynamic_cast<const PrimitiveTypeEntry *>(type);
     if (!pte) {
         qDebug() << "Warning: the Qt5 primitive type is unknown" << type->qualifiedCppName();
         return QString();
@@ -897,7 +897,7 @@ QString ShibokenGenerator::converterObject(const TypeEntry* type)
            + QLatin1Char('[') + getTypeIndexVariableName(type) + QLatin1Char(']');
 }
 
-QString ShibokenGenerator::cpythonTypeNameExt(const AbstractMetaType* type)
+QString ShibokenGenerator::cpythonTypeNameExt(const AbstractMetaType *type)
 {
     return cppApiVariableName(type->typeEntry()->targetLangPackage()) + QLatin1Char('[')
            + getTypeIndexVariableName(type) + QLatin1Char(']');
@@ -905,13 +905,13 @@ QString ShibokenGenerator::cpythonTypeNameExt(const AbstractMetaType* type)
 
 static inline QString unknownOperator() { return QStringLiteral("__UNKNOWN_OPERATOR__"); }
 
-QString ShibokenGenerator::fixedCppTypeName(const CustomConversion::TargetToNativeConversion* toNative)
+QString ShibokenGenerator::fixedCppTypeName(const CustomConversion::TargetToNativeConversion *toNative)
 {
     if (toNative->sourceType())
         return fixedCppTypeName(toNative->sourceType());
     return toNative->sourceTypeName();
 }
-QString ShibokenGenerator::fixedCppTypeName(const AbstractMetaType* type)
+QString ShibokenGenerator::fixedCppTypeName(const AbstractMetaType *type)
 {
     return fixedCppTypeName(type->typeEntry(), type->cppSignature());
 }
@@ -928,7 +928,7 @@ static QString _fixedCppTypeName(QString typeName)
     typeName.replace(QLatin1String("&"),  QLatin1String("REF"));
     return typeName;
 }
-QString ShibokenGenerator::fixedCppTypeName(const TypeEntry* type, QString typeName)
+QString ShibokenGenerator::fixedCppTypeName(const TypeEntry *type, QString typeName)
 {
     if (typeName.isEmpty())
         typeName = type->qualifiedCppName();
@@ -939,7 +939,7 @@ QString ShibokenGenerator::fixedCppTypeName(const TypeEntry* type, QString typeN
     return _fixedCppTypeName(typeName);
 }
 
-QString ShibokenGenerator::pythonPrimitiveTypeName(const QString& cppTypeName)
+QString ShibokenGenerator::pythonPrimitiveTypeName(const QString &cppTypeName)
 {
     QString rv = ShibokenGenerator::m_pythonPrimitiveTypeName.value(cppTypeName, QString());
     if (rv.isEmpty()) {
@@ -955,7 +955,7 @@ QString ShibokenGenerator::pythonPrimitiveTypeName(const QString& cppTypeName)
     return rv;
 }
 
-QString ShibokenGenerator::pythonPrimitiveTypeName(const PrimitiveTypeEntry* type)
+QString ShibokenGenerator::pythonPrimitiveTypeName(const PrimitiveTypeEntry *type)
 {
     while (type->basicReferencedTypeEntry())
         type = type->basicReferencedTypeEntry();
@@ -972,7 +972,7 @@ QString ShibokenGenerator::pythonOperatorFunctionName(const QString &cppOpFuncNa
     return value;
 }
 
-QString ShibokenGenerator::pythonOperatorFunctionName(const AbstractMetaFunction* func)
+QString ShibokenGenerator::pythonOperatorFunctionName(const AbstractMetaFunction *func)
 {
     QString op = pythonOperatorFunctionName(func->originalName());
     if (op == unknownOperator())
@@ -995,7 +995,7 @@ QString ShibokenGenerator::pythonRichCompareOperatorId(const QString &cppOpFuncN
     return QLatin1String("Py_") + m_pythonOperators.value(cppOpFuncName).toUpper();
 }
 
-QString ShibokenGenerator::pythonRichCompareOperatorId(const AbstractMetaFunction* func)
+QString ShibokenGenerator::pythonRichCompareOperatorId(const AbstractMetaFunction *func)
 {
     return pythonRichCompareOperatorId(func->originalName());
 }
@@ -1008,19 +1008,19 @@ bool ShibokenGenerator::isNumber(const QString &cpythonApiName)
             || cpythonApiName == QLatin1String("PyBool");
 }
 
-bool ShibokenGenerator::isNumber(const TypeEntry* type)
+bool ShibokenGenerator::isNumber(const TypeEntry *type)
 {
     if (!type->isPrimitive())
         return false;
     return isNumber(pythonPrimitiveTypeName(static_cast<const PrimitiveTypeEntry *>(type)));
 }
 
-bool ShibokenGenerator::isNumber(const AbstractMetaType* type)
+bool ShibokenGenerator::isNumber(const AbstractMetaType *type)
 {
     return isNumber(type->typeEntry());
 }
 
-bool ShibokenGenerator::isPyInt(const TypeEntry* type)
+bool ShibokenGenerator::isPyInt(const TypeEntry *type)
 {
     if (!type->isPrimitive())
         return false;
@@ -1028,39 +1028,39 @@ bool ShibokenGenerator::isPyInt(const TypeEntry* type)
         == QLatin1String("PyInt");
 }
 
-bool ShibokenGenerator::isPyInt(const AbstractMetaType* type)
+bool ShibokenGenerator::isPyInt(const AbstractMetaType *type)
 {
     return isPyInt(type->typeEntry());
 }
 
-bool ShibokenGenerator::isWrapperType(const TypeEntry* type)
+bool ShibokenGenerator::isWrapperType(const TypeEntry *type)
 {
     if (type->isComplex())
         return ShibokenGenerator::isWrapperType(static_cast<const ComplexTypeEntry *>(type));
     return type->isObject() || type->isValue() || type->isSmartPointer();
 }
-bool ShibokenGenerator::isWrapperType(const ComplexTypeEntry* type)
+bool ShibokenGenerator::isWrapperType(const ComplexTypeEntry *type)
 {
     return isObjectType(type) || type->isValue() || type->isSmartPointer();
 }
-bool ShibokenGenerator::isWrapperType(const AbstractMetaType* metaType)
+bool ShibokenGenerator::isWrapperType(const AbstractMetaType *metaType)
 {
     return isObjectType(metaType)
             || metaType->typeEntry()->isValue()
             || metaType->typeEntry()->isSmartPointer();
 }
 
-bool ShibokenGenerator::isPointerToWrapperType(const AbstractMetaType* type)
+bool ShibokenGenerator::isPointerToWrapperType(const AbstractMetaType *type)
 {
     return (isObjectType(type) && type->indirections() == 1) || type->isValuePointer();
 }
 
-bool ShibokenGenerator::isObjectTypeUsedAsValueType(const AbstractMetaType* type)
+bool ShibokenGenerator::isObjectTypeUsedAsValueType(const AbstractMetaType *type)
 {
     return type->typeEntry()->isObject() && type->referenceType() == NoReference && type->indirections() == 0;
 }
 
-bool ShibokenGenerator::isValueTypeWithCopyConstructorOnly(const AbstractMetaClass* metaClass)
+bool ShibokenGenerator::isValueTypeWithCopyConstructorOnly(const AbstractMetaClass *metaClass)
 {
     if (!metaClass || !metaClass->typeEntry()->isValue())
         return false;
@@ -1086,21 +1086,21 @@ bool ShibokenGenerator::isValueTypeWithCopyConstructorOnly(const AbstractMetaCla
     return copyConstructorFound;
 }
 
-bool ShibokenGenerator::isValueTypeWithCopyConstructorOnly(const TypeEntry* type) const
+bool ShibokenGenerator::isValueTypeWithCopyConstructorOnly(const TypeEntry *type) const
 {
     if (!type || !type->isValue())
         return false;
     return isValueTypeWithCopyConstructorOnly(AbstractMetaClass::findClass(classes(), type));
 }
 
-bool ShibokenGenerator::isValueTypeWithCopyConstructorOnly(const AbstractMetaType* type) const
+bool ShibokenGenerator::isValueTypeWithCopyConstructorOnly(const AbstractMetaType *type) const
 {
     if (!type || !type->typeEntry()->isValue())
         return false;
     return isValueTypeWithCopyConstructorOnly(type->typeEntry());
 }
 
-bool ShibokenGenerator::isUserPrimitive(const TypeEntry* type)
+bool ShibokenGenerator::isUserPrimitive(const TypeEntry *type)
 {
     if (!type->isPrimitive())
         return false;
@@ -1111,14 +1111,14 @@ bool ShibokenGenerator::isUserPrimitive(const TypeEntry* type)
            && trueType->qualifiedCppName() != QLatin1String("std::string");
 }
 
-bool ShibokenGenerator::isUserPrimitive(const AbstractMetaType* type)
+bool ShibokenGenerator::isUserPrimitive(const AbstractMetaType *type)
 {
     if (type->indirections() != 0)
         return false;
     return isUserPrimitive(type->typeEntry());
 }
 
-bool ShibokenGenerator::isCppPrimitive(const TypeEntry* type)
+bool ShibokenGenerator::isCppPrimitive(const TypeEntry *type)
 {
     if (type->isCppPrimitive())
         return true;
@@ -1130,7 +1130,7 @@ bool ShibokenGenerator::isCppPrimitive(const TypeEntry* type)
     return trueType->qualifiedCppName() == QLatin1String("std::string");
 }
 
-bool ShibokenGenerator::isCppPrimitive(const AbstractMetaType* type)
+bool ShibokenGenerator::isCppPrimitive(const AbstractMetaType *type)
 {
     if (isCString(type) || isVoidPointer(type))
         return true;
@@ -1139,17 +1139,17 @@ bool ShibokenGenerator::isCppPrimitive(const AbstractMetaType* type)
     return isCppPrimitive(type->typeEntry());
 }
 
-bool ShibokenGenerator::shouldDereferenceArgumentPointer(const AbstractMetaArgument* arg)
+bool ShibokenGenerator::shouldDereferenceArgumentPointer(const AbstractMetaArgument *arg)
 {
     return shouldDereferenceAbstractMetaTypePointer(arg->type());
 }
 
-bool ShibokenGenerator::shouldDereferenceAbstractMetaTypePointer(const AbstractMetaType* metaType)
+bool ShibokenGenerator::shouldDereferenceAbstractMetaTypePointer(const AbstractMetaType *metaType)
 {
     return metaType->referenceType() == LValueReference && isWrapperType(metaType) && !isPointer(metaType);
 }
 
-bool ShibokenGenerator::visibilityModifiedToPrivate(const AbstractMetaFunction* func)
+bool ShibokenGenerator::visibilityModifiedToPrivate(const AbstractMetaFunction *func)
 {
     const FunctionModificationList &mods = func->modifications();
     for (const FunctionModification &mod : mods) {
@@ -1159,11 +1159,11 @@ bool ShibokenGenerator::visibilityModifiedToPrivate(const AbstractMetaFunction*
     return false;
 }
 
-QString ShibokenGenerator::cpythonCheckFunction(const AbstractMetaType* metaType, bool genericNumberType)
+QString ShibokenGenerator::cpythonCheckFunction(const AbstractMetaType *metaType, bool genericNumberType)
 {
     QString customCheck;
     if (metaType->typeEntry()->isCustom()) {
-        AbstractMetaType* type;
+        AbstractMetaType *type;
         customCheck = guessCPythonCheckFunction(metaType->typeEntry()->name(), &type);
         if (type)
             metaType = type;
@@ -1189,7 +1189,7 @@ QString ShibokenGenerator::cpythonCheckFunction(const AbstractMetaType* metaType
             || type == ContainerTypeEntry::StackContainer
             || type == ContainerTypeEntry::SetContainer
             || type == ContainerTypeEntry::QueueContainer) {
-            const AbstractMetaType* type = metaType->instantiations().constFirst();
+            const AbstractMetaType *type = metaType->instantiations().constFirst();
             if (isPointerToWrapperType(type)) {
                 typeCheck += QString::fromLatin1("checkSequenceTypes(%1, ").arg(cpythonTypeNameExt(type));
             } else if (isWrapperType(type)) {
@@ -1205,8 +1205,8 @@ QString ShibokenGenerator::cpythonCheckFunction(const AbstractMetaType* metaType
             || type == ContainerTypeEntry::MultiHashContainer
             || type == ContainerTypeEntry::PairContainer) {
             QString pyType = (type == ContainerTypeEntry::PairContainer) ? QLatin1String("Pair") : QLatin1String("Dict");
-            const AbstractMetaType* firstType = metaType->instantiations().constFirst();
-            const AbstractMetaType* secondType = metaType->instantiations().constLast();
+            const AbstractMetaType *firstType = metaType->instantiations().constFirst();
+            const AbstractMetaType *secondType = metaType->instantiations().constLast();
             if (isPointerToWrapperType(firstType) && isPointerToWrapperType(secondType)) {
                 typeCheck += QString::fromLatin1("check%1Types(%2, %3, ")
                              .arg(pyType, cpythonTypeNameExt(firstType), cpythonTypeNameExt(secondType));
@@ -1223,11 +1223,11 @@ QString ShibokenGenerator::cpythonCheckFunction(const AbstractMetaType* metaType
     return cpythonCheckFunction(metaType->typeEntry(), genericNumberType);
 }
 
-QString ShibokenGenerator::cpythonCheckFunction(const TypeEntry* type, bool genericNumberType)
+QString ShibokenGenerator::cpythonCheckFunction(const TypeEntry *type, bool genericNumberType)
 {
     QString customCheck;
     if (type->isCustom()) {
-        AbstractMetaType* metaType;
+        AbstractMetaType *metaType;
         customCheck = guessCPythonCheckFunction(type->name(), &metaType);
         if (metaType)
             return cpythonCheckFunction(metaType, genericNumberType);
@@ -1250,7 +1250,7 @@ QString ShibokenGenerator::cpythonCheckFunction(const TypeEntry* type, bool gene
     return typeCheck;
 }
 
-QString ShibokenGenerator::guessCPythonCheckFunction(const QString& type, AbstractMetaType** metaType)
+QString ShibokenGenerator::guessCPythonCheckFunction(const QString &type, AbstractMetaType **metaType)
 {
     *metaType = 0;
     if (type == QLatin1String("PyTypeObject"))
@@ -1269,7 +1269,7 @@ QString ShibokenGenerator::guessCPythonCheckFunction(const QString& type, Abstra
     return type + QLatin1String("_Check");
 }
 
-QString ShibokenGenerator::cpythonIsConvertibleFunction(const TypeEntry* type,
+QString ShibokenGenerator::cpythonIsConvertibleFunction(const TypeEntry *type,
                                                         bool /* genericNumberType */,
                                                         bool /* checkExact */)
 {
@@ -1285,12 +1285,12 @@ QString ShibokenGenerator::cpythonIsConvertibleFunction(const TypeEntry* type,
     return QString::fromLatin1("Shiboken::Conversions::isPythonToCppConvertible(%1, ")
               .arg(converterObject(type));
 }
-QString ShibokenGenerator::cpythonIsConvertibleFunction(const AbstractMetaType* metaType,
+QString ShibokenGenerator::cpythonIsConvertibleFunction(const AbstractMetaType *metaType,
                                                         bool /* genericNumberType */)
 {
     QString customCheck;
     if (metaType->typeEntry()->isCustom()) {
-        AbstractMetaType* type;
+        AbstractMetaType *type;
         customCheck = guessCPythonCheckFunction(metaType->typeEntry()->name(), &type);
         if (type)
             metaType = type;
@@ -1329,7 +1329,7 @@ QString ShibokenGenerator::cpythonIsConvertibleFunction(const AbstractMetaArgume
     return cpythonIsConvertibleFunction(metaArg->type(), genericNumberType);
 }
 
-QString ShibokenGenerator::cpythonToCppConversionFunction(const AbstractMetaClass* metaClass)
+QString ShibokenGenerator::cpythonToCppConversionFunction(const AbstractMetaClass *metaClass)
 {
     return QLatin1String("Shiboken::Conversions::pythonToCppPointer(reinterpret_cast<SbkObjectType *>(")
         + cpythonTypeNameExt(metaClass->typeEntry()) + QLatin1String("), ");
@@ -1371,12 +1371,12 @@ QString ShibokenGenerator::cpythonToPythonConversionFunction(const AbstractMetaT
                    (isCString(type) || isVoidPointer(type)) ? QString() : QLatin1String("&"));
 }
 
-QString ShibokenGenerator::cpythonToPythonConversionFunction(const AbstractMetaClass* metaClass)
+QString ShibokenGenerator::cpythonToPythonConversionFunction(const AbstractMetaClass *metaClass)
 {
     return cpythonToPythonConversionFunction(metaClass->typeEntry());
 }
 
-QString ShibokenGenerator::cpythonToPythonConversionFunction(const TypeEntry* type)
+QString ShibokenGenerator::cpythonToPythonConversionFunction(const TypeEntry *type)
 {
     if (isWrapperType(type)) {
         const QString conversion = type->isValue() ? QLatin1String("copy") : QLatin1String("pointer");
@@ -1463,7 +1463,7 @@ void ShibokenGenerator::writeFunctionArguments(QTextStream &s,
     }
 }
 
-QString ShibokenGenerator::functionReturnType(const AbstractMetaFunction* func, Options options) const
+QString ShibokenGenerator::functionReturnType(const AbstractMetaFunction *func, Options options) const
 {
     QString modifiedReturnType = QString(func->typeReplaced(0));
     if (!modifiedReturnType.isEmpty() && !(options & OriginalTypeDescription))
@@ -1530,8 +1530,8 @@ void ShibokenGenerator::writeArgumentNames(QTextStream &s,
     }
 }
 
-void ShibokenGenerator::writeFunctionCall(QTextStream& s,
-                                          const AbstractMetaFunction* func,
+void ShibokenGenerator::writeFunctionCall(QTextStream &s,
+                                          const AbstractMetaFunction *func,
                                           Options options) const
 {
     if (!(options & Generator::SkipName))
@@ -1541,12 +1541,12 @@ void ShibokenGenerator::writeFunctionCall(QTextStream& s,
     s << ')';
 }
 
-void ShibokenGenerator::writeUnusedVariableCast(QTextStream& s, const QString& variableName)
+void ShibokenGenerator::writeUnusedVariableCast(QTextStream &s, const QString &variableName)
 {
     s << INDENT << "SBK_UNUSED(" << variableName<< ')' << endl;
 }
 
-AbstractMetaFunctionList ShibokenGenerator::filterFunctions(const AbstractMetaClass* metaClass)
+AbstractMetaFunctionList ShibokenGenerator::filterFunctions(const AbstractMetaClass *metaClass)
 {
     AbstractMetaFunctionList result;
     const AbstractMetaFunctionList &funcs = metaClass->functions();
@@ -1572,7 +1572,7 @@ ShibokenGenerator::ExtendedConverterData ShibokenGenerator::getExtendedConverter
         for (AbstractMetaFunction *convOp : overloads) {
             // Get only the conversion operators that return a type from another module,
             // that are value-types and were not removed in the type system.
-            const TypeEntry* convType = convOp->type()->typeEntry();
+            const TypeEntry *convType = convOp->type()->typeEntry();
             if ((convType->codeGeneration() & TypeEntry::GenerateTargetLang)
                 || !convType->isValue()
                 || convOp->isModifiedRemoved())
@@ -1585,7 +1585,7 @@ ShibokenGenerator::ExtendedConverterData ShibokenGenerator::getExtendedConverter
 
 QVector<const CustomConversion *> ShibokenGenerator::getPrimitiveCustomConversions()
 {
-    QVector<const CustomConversion*> conversions;
+    QVector<const CustomConversion *> conversions;
     const PrimitiveTypeEntryList &primitiveTypeList = primitiveTypes();
     for (const PrimitiveTypeEntry *type : primitiveTypeList) {
         if (!shouldGenerateTypeEntry(type) || !isUserPrimitive(type) || !type->customConversion())
@@ -1596,7 +1596,7 @@ QVector<const CustomConversion *> ShibokenGenerator::getPrimitiveCustomConversio
     return conversions;
 }
 
-static QString getArgumentsFromMethodCall(const QString& str)
+static QString getArgumentsFromMethodCall(const QString &str)
 {
     // It would be way nicer to be able to use a Perl like
     // regular expression that accepts temporary variables
@@ -1624,7 +1624,7 @@ static QString getArgumentsFromMethodCall(const QString& str)
     return str.mid(begin, pos-begin-1);
 }
 
-QString ShibokenGenerator::getCodeSnippets(const CodeSnipList& codeSnips,
+QString ShibokenGenerator::getCodeSnippets(const CodeSnipList &codeSnips,
                                            TypeSystem::CodeSnipPosition position,
                                            TypeSystem::Language language)
 {
@@ -1640,7 +1640,7 @@ QString ShibokenGenerator::getCodeSnippets(const CodeSnipList& codeSnips,
     }
     return code;
 }
-void ShibokenGenerator::processCodeSnip(QString& code, const AbstractMetaClass* context)
+void ShibokenGenerator::processCodeSnip(QString &code, const AbstractMetaClass *context)
 {
     if (context) {
         // Replace template variable by the Python Type object
@@ -1664,16 +1664,16 @@ void ShibokenGenerator::processCodeSnip(QString& code, const AbstractMetaClass*
     replaceTypeCheckTypeSystemVariable(code);
 }
 
-ShibokenGenerator::ArgumentVarReplacementList ShibokenGenerator::getArgumentReplacement(const AbstractMetaFunction* func,
+ShibokenGenerator::ArgumentVarReplacementList ShibokenGenerator::getArgumentReplacement(const AbstractMetaFunction *func,
                                                                                         bool usePyArgs, TypeSystem::Language language,
-                                                                                        const AbstractMetaArgument* lastArg)
+                                                                                        const AbstractMetaArgument *lastArg)
 {
     ArgumentVarReplacementList argReplacements;
     TypeSystem::Language convLang = (language == TypeSystem::TargetLangCode)
                                     ? TypeSystem::NativeCode : TypeSystem::TargetLangCode;
     int removed = 0;
     for (int i = 0; i < func->arguments().size(); ++i) {
-        const AbstractMetaArgument* arg = func->arguments().at(i);
+        const AbstractMetaArgument *arg = func->arguments().at(i);
         QString argValue;
         if (language == TypeSystem::TargetLangCode) {
             bool hasConversionRule = !func->conversionRule(convLang, i+1).isEmpty();
@@ -1686,10 +1686,10 @@ ShibokenGenerator::ArgumentVarReplacementList ShibokenGenerator::getArgumentRepl
                 argValue = QLatin1String(CPP_ARG_REMOVED) + QString::number(i);
             if (!argRemoved && argValue.isEmpty()) {
                 int argPos = i - removed;
-                const AbstractMetaType* type = arg->type();
+                const AbstractMetaType *type = arg->type();
                 QString typeReplaced = func->typeReplaced(arg->argumentIndex() + 1);
                 if (!typeReplaced.isEmpty()) {
-                    AbstractMetaType* builtType = buildAbstractMetaTypeFromString(typeReplaced);
+                    AbstractMetaType *builtType = buildAbstractMetaTypeFromString(typeReplaced);
                     if (builtType)
                         type = builtType;
                 }
@@ -1716,11 +1716,11 @@ ShibokenGenerator::ArgumentVarReplacementList ShibokenGenerator::getArgumentRepl
     return argReplacements;
 }
 
-void ShibokenGenerator::writeCodeSnips(QTextStream& s,
-                                       const CodeSnipList& codeSnips,
+void ShibokenGenerator::writeCodeSnips(QTextStream &s,
+                                       const CodeSnipList &codeSnips,
                                        TypeSystem::CodeSnipPosition position,
                                        TypeSystem::Language language,
-                                       const AbstractMetaClass* context)
+                                       const AbstractMetaClass *context)
 {
     QString code = getCodeSnippets(codeSnips, position, language);
     if (code.isEmpty())
@@ -1731,12 +1731,12 @@ void ShibokenGenerator::writeCodeSnips(QTextStream& s,
     s << INDENT << "// End of code injection" << endl;
 }
 
-void ShibokenGenerator::writeCodeSnips(QTextStream& s,
-                                       const CodeSnipList& codeSnips,
+void ShibokenGenerator::writeCodeSnips(QTextStream &s,
+                                       const CodeSnipList &codeSnips,
                                        TypeSystem::CodeSnipPosition position,
                                        TypeSystem::Language language,
-                                       const AbstractMetaFunction* func,
-                                       const AbstractMetaArgument* lastArg)
+                                       const AbstractMetaFunction *func,
+                                       const AbstractMetaArgument *lastArg)
 {
     QString code = getCodeSnippets(codeSnips, position, language);
     if (code.isEmpty())
@@ -1842,14 +1842,14 @@ void ShibokenGenerator::writeCodeSnips(QTextStream& s,
                     QString wrapperClassName = wrapperName(func->ownerClass());
                     QString cppSelfVar = avoidProtectedHack()
                                          ? QLatin1String("%CPPSELF")
-                                         : QStringLiteral("reinterpret_cast<%1*>(%CPPSELF)").arg(wrapperClassName);
+                                         : QStringLiteral("reinterpret_cast<%1 *>(%CPPSELF)").arg(wrapperClassName);
                     code.replace(pattern,
-                                 QString::fromLatin1("(Shiboken::Object::hasCppWrapper(reinterpret_cast<SbkObject*>(%1))"
+                                 QString::fromLatin1("(Shiboken::Object::hasCppWrapper(reinterpret_cast<SbkObject *>(%1))"
                                          " ? %2->::%3::%FUNCTION_NAME(%4)"
                                          " : %CPPSELF.%FUNCTION_NAME(%4))").arg(pySelf, cppSelfVar, wrapperClassName, methodCallArgs));
                 } else {
                     code.replace(pattern,
-                                 QString::fromLatin1("(Shiboken::Object::hasCppWrapper(reinterpret_cast<SbkObject*>(%1))"
+                                 QString::fromLatin1("(Shiboken::Object::hasCppWrapper(reinterpret_cast<SbkObject *>(%1))"
                                          " ? %CPPSELF->::%TYPE::%FUNCTION_NAME(%2)"
                                          " : %CPPSELF.%FUNCTION_NAME(%2))").arg(pySelf, methodCallArgs));
                 }
@@ -1892,12 +1892,12 @@ void ShibokenGenerator::writeCodeSnips(QTextStream& s,
     code.replace(QLatin1String("%ARGUMENT_NAMES"), args.join(QLatin1String(", ")));
 
     for (const ArgumentVarReplacementPair &pair : argReplacements) {
-        const AbstractMetaArgument* arg = pair.first;
+        const AbstractMetaArgument *arg = pair.first;
         int idx = arg->argumentIndex() + 1;
-        AbstractMetaType* type = arg->type();
+        AbstractMetaType *type = arg->type();
         QString typeReplaced = func->typeReplaced(arg->argumentIndex() + 1);
         if (!typeReplaced.isEmpty()) {
-            AbstractMetaType* builtType = buildAbstractMetaTypeFromString(typeReplaced);
+            AbstractMetaType *builtType = buildAbstractMetaTypeFromString(typeReplaced);
             if (builtType)
                 type = builtType;
         }
@@ -1960,7 +1960,7 @@ void ShibokenGenerator::writeCodeSnips(QTextStream& s,
 
 // Returns true if the string is an expression,
 // and false if it is a variable.
-static bool isVariable(const QString& code)
+static bool isVariable(const QString &code)
 {
     static const QRegularExpression expr(QStringLiteral("^\\s*\\*?\\s*[A-Za-z_][A-Za-z_0-9.]*\\s*(?:\\[[^\\[]+\\])*$"));
     Q_ASSERT(expr.isValid());
@@ -1970,7 +1970,7 @@ static bool isVariable(const QString& code)
 // A miniature normalizer that puts a type string into a format
 // suitable for comparison with AbstractMetaType::cppSignature()
 // result.
-static QString miniNormalizer(const QString& varType)
+static QString miniNormalizer(const QString &varType)
 {
     QString normalized = varType.trimmed();
     if (normalized.isEmpty())
@@ -1989,7 +1989,7 @@ static QString miniNormalizer(const QString& varType)
 // The position must indicate the first character after the opening '('.
 // ATTENTION: do not modify this function to trim any resulting string!
 // This must be done elsewhere.
-static QString getConverterTypeSystemVariableArgument(const QString& code, int pos)
+static QString getConverterTypeSystemVariableArgument(const QString &code, int pos)
 {
     QString arg;
     int parenthesisDepth = 0;
@@ -2013,7 +2013,7 @@ static QString getConverterTypeSystemVariableArgument(const QString& code, int p
 }
 typedef QPair<QString, QString> StringPair;
 
-void ShibokenGenerator::replaceConverterTypeSystemVariable(TypeSystemConverterVariable converterVariable, QString& code)
+void ShibokenGenerator::replaceConverterTypeSystemVariable(TypeSystemConverterVariable converterVariable, QString &code)
 {
     QVector<StringPair> replacements;
     QRegularExpressionMatchIterator rit = m_typeSystemConvRegEx[converterVariable].globalMatch(code);
@@ -2105,7 +2105,7 @@ void ShibokenGenerator::replaceConverterTypeSystemVariable(TypeSystemConverterVa
         code.replace(rep.first, rep.second);
 }
 
-bool ShibokenGenerator::injectedCodeUsesPySelf(const AbstractMetaFunction* func)
+bool ShibokenGenerator::injectedCodeUsesPySelf(const AbstractMetaFunction *func)
 {
     CodeSnipList snips = func->injectedCodeSnips(TypeSystem::CodeSnipPositionAny, TypeSystem::NativeCode);
     for (const CodeSnip &snip : qAsConst(snips)) {
@@ -2115,7 +2115,7 @@ bool ShibokenGenerator::injectedCodeUsesPySelf(const AbstractMetaFunction* func)
     return false;
 }
 
-bool ShibokenGenerator::injectedCodeCallsCppFunction(const AbstractMetaFunction* func)
+bool ShibokenGenerator::injectedCodeCallsCppFunction(const AbstractMetaFunction *func)
 {
     QString funcCall = func->originalName() + QLatin1Char('(');
     QString wrappedCtorCall;
@@ -2135,7 +2135,7 @@ bool ShibokenGenerator::injectedCodeCallsCppFunction(const AbstractMetaFunction*
     return false;
 }
 
-bool ShibokenGenerator::injectedCodeCallsPythonOverride(const AbstractMetaFunction* func)
+bool ShibokenGenerator::injectedCodeCallsPythonOverride(const AbstractMetaFunction *func)
 {
     static const QRegularExpression overrideCallRegexCheck(QStringLiteral("PyObject_Call\\s*\\(\\s*%PYTHON_METHOD_OVERRIDE\\s*,"));
     Q_ASSERT(overrideCallRegexCheck.isValid());
@@ -2147,7 +2147,7 @@ bool ShibokenGenerator::injectedCodeCallsPythonOverride(const AbstractMetaFuncti
     return false;
 }
 
-bool ShibokenGenerator::injectedCodeHasReturnValueAttribution(const AbstractMetaFunction* func, TypeSystem::Language language)
+bool ShibokenGenerator::injectedCodeHasReturnValueAttribution(const AbstractMetaFunction *func, TypeSystem::Language language)
 {
     static const QRegularExpression retValAttributionRegexCheck_native(QStringLiteral("%0\\s*=[^=]\\s*.+"));
     Q_ASSERT(retValAttributionRegexCheck_native.isValid());
@@ -2166,7 +2166,7 @@ bool ShibokenGenerator::injectedCodeHasReturnValueAttribution(const AbstractMeta
     return false;
 }
 
-bool ShibokenGenerator::injectedCodeUsesArgument(const AbstractMetaFunction* func, int argumentIndex)
+bool ShibokenGenerator::injectedCodeUsesArgument(const AbstractMetaFunction *func, int argumentIndex)
 {
     CodeSnipList snips = func->injectedCodeSnips(TypeSystem::CodeSnipPositionAny);
     const QRegularExpression argRegEx = placeHolderRegex(argumentIndex + 1);
@@ -2178,12 +2178,12 @@ bool ShibokenGenerator::injectedCodeUsesArgument(const AbstractMetaFunction* fun
     return false;
 }
 
-bool ShibokenGenerator::classNeedsGetattroFunction(const AbstractMetaClass* metaClass)
+bool ShibokenGenerator::classNeedsGetattroFunction(const AbstractMetaClass *metaClass)
 {
     return getGeneratorClassInfo(metaClass).needsGetattroFunction;
 }
 
-bool ShibokenGenerator::classNeedsGetattroFunctionImpl(const AbstractMetaClass* metaClass)
+bool ShibokenGenerator::classNeedsGetattroFunctionImpl(const AbstractMetaClass *metaClass)
 {
     if (!metaClass)
         return false;
@@ -2214,7 +2214,7 @@ bool ShibokenGenerator::classNeedsSetattroFunction(const AbstractMetaClass *meta
     return metaClass->typeEntry()->isSmartPointer();
 }
 
-AbstractMetaFunctionList ShibokenGenerator::getMethodsWithBothStaticAndNonStaticMethods(const AbstractMetaClass* metaClass)
+AbstractMetaFunctionList ShibokenGenerator::getMethodsWithBothStaticAndNonStaticMethods(const AbstractMetaClass *metaClass)
 {
     AbstractMetaFunctionList methods;
     if (metaClass) {
@@ -2237,7 +2237,7 @@ AbstractMetaFunctionList ShibokenGenerator::getMethodsWithBothStaticAndNonStatic
     return methods;
 }
 
-AbstractMetaClassList ShibokenGenerator::getBaseClasses(const AbstractMetaClass* metaClass) const
+AbstractMetaClassList ShibokenGenerator::getBaseClasses(const AbstractMetaClass *metaClass) const
 {
     AbstractMetaClassList baseClasses;
     if (metaClass) {
@@ -2257,7 +2257,7 @@ AbstractMetaClassList ShibokenGenerator::getBaseClasses(const AbstractMetaClass*
     return baseClasses;
 }
 
-const AbstractMetaClass* ShibokenGenerator::getMultipleInheritingClass(const AbstractMetaClass* metaClass)
+const AbstractMetaClass *ShibokenGenerator::getMultipleInheritingClass(const AbstractMetaClass *metaClass)
 {
     if (!metaClass || metaClass->baseClassNames().isEmpty())
         return nullptr;
@@ -2266,7 +2266,7 @@ const AbstractMetaClass* ShibokenGenerator::getMultipleInheritingClass(const Abs
     return getMultipleInheritingClass(metaClass->baseClass());
 }
 
-AbstractMetaClassList ShibokenGenerator::getAllAncestors(const AbstractMetaClass* metaClass) const
+AbstractMetaClassList ShibokenGenerator::getAllAncestors(const AbstractMetaClass *metaClass) const
 {
     AbstractMetaClassList result;
     if (metaClass) {
@@ -2279,7 +2279,7 @@ AbstractMetaClassList ShibokenGenerator::getAllAncestors(const AbstractMetaClass
     return result;
 }
 
-QString ShibokenGenerator::getModuleHeaderFileName(const QString& moduleName) const
+QString ShibokenGenerator::getModuleHeaderFileName(const QString &moduleName) const
 {
     return moduleCppPrefix(moduleName).toLower() + QLatin1String("_python.h");
 }
@@ -2316,14 +2316,14 @@ AbstractMetaType *ShibokenGenerator::buildAbstractMetaTypeFromString(QString typ
     return it.value();
 }
 
-AbstractMetaType* ShibokenGenerator::buildAbstractMetaTypeFromTypeEntry(const TypeEntry* typeEntry)
+AbstractMetaType *ShibokenGenerator::buildAbstractMetaTypeFromTypeEntry(const TypeEntry *typeEntry)
 {
     QString typeName = typeEntry->qualifiedCppName();
     if (typeName.startsWith(QLatin1String("::")))
         typeName.remove(0, 2);
     if (m_metaTypeFromStringCache.contains(typeName))
         return m_metaTypeFromStringCache.value(typeName);
-    AbstractMetaType* metaType = new AbstractMetaType;
+    AbstractMetaType *metaType = new AbstractMetaType;
     metaType->setTypeEntry(typeEntry);
     metaType->clearIndirections();
     metaType->setReferenceType(NoReference);
@@ -2332,7 +2332,7 @@ AbstractMetaType* ShibokenGenerator::buildAbstractMetaTypeFromTypeEntry(const Ty
     m_metaTypeFromStringCache.insert(typeName, metaType);
     return metaType;
 }
-AbstractMetaType* ShibokenGenerator::buildAbstractMetaTypeFromAbstractMetaClass(const AbstractMetaClass* metaClass)
+AbstractMetaType *ShibokenGenerator::buildAbstractMetaTypeFromAbstractMetaClass(const AbstractMetaClass *metaClass)
 {
     return ShibokenGenerator::buildAbstractMetaTypeFromTypeEntry(metaClass->typeEntry());
 }
@@ -2354,7 +2354,7 @@ static void dumpFunction(AbstractMetaFunctionList lst)
 }
 */
 
-static bool isGroupable(const AbstractMetaFunction* func)
+static bool isGroupable(const AbstractMetaFunction *func)
 {
     if (func->isSignal() || func->isDestructor() || (func->isModifiedRemoved() && !func->isAbstract()))
         return false;
@@ -2422,13 +2422,13 @@ ShibokenGenerator::FunctionGroups ShibokenGenerator::getFunctionGroupsImpl(const
 AbstractMetaFunctionList ShibokenGenerator::getInheritedOverloads(const AbstractMetaFunction *func, QSet<QString> *seen)
 {
     AbstractMetaFunctionList results;
-    AbstractMetaClass* basis;
+    AbstractMetaClass *basis;
     if (func->ownerClass() && (basis = func->ownerClass()->baseClass())) {
         for (; basis; basis = basis->baseClass()) {
-            const AbstractMetaFunction* inFunc = basis->findFunction(func->name());
+            const AbstractMetaFunction *inFunc = basis->findFunction(func->name());
             if (inFunc && !seen->contains(inFunc->minimalSignature())) {
                 seen->insert(inFunc->minimalSignature());
-                AbstractMetaFunction* newFunc = inFunc->copy();
+                AbstractMetaFunction *newFunc = inFunc->copy();
                 newFunc->setImplementingClass(func->implementingClass());
                 results << newFunc;
             }
@@ -2445,7 +2445,7 @@ AbstractMetaFunctionList ShibokenGenerator::getFunctionAndInheritedOverloads(con
     return results;
 }
 
-AbstractMetaFunctionList ShibokenGenerator::getFunctionOverloads(const AbstractMetaClass* scope, const QString& functionName)
+AbstractMetaFunctionList ShibokenGenerator::getFunctionOverloads(const AbstractMetaClass *scope, const QString &functionName)
 {
     AbstractMetaFunctionList lst = scope ? scope->functions() : globalFunctions();
 
@@ -2500,24 +2500,24 @@ bool ShibokenGenerator::handleOption(const QString &key, const QString & /* valu
     return false;
 }
 
-static void getCode(QStringList& code, const CodeSnipList& codeSnips)
+static void getCode(QStringList &code, const CodeSnipList &codeSnips)
 {
     for (const CodeSnip &snip : qAsConst(codeSnips))
         code.append(snip.code());
 }
 
-static void getCode(QStringList& code, const TypeEntry* type)
+static void getCode(QStringList &code, const TypeEntry *type)
 {
     getCode(code, type->codeSnips());
 
-    CustomConversion* customConversion = type->customConversion();
+    CustomConversion *customConversion = type->customConversion();
     if (!customConversion)
         return;
 
     if (!customConversion->nativeToTargetConversion().isEmpty())
         code.append(customConversion->nativeToTargetConversion());
 
-    const CustomConversion::TargetToNativeConversions& toCppConversions = customConversion->targetToNativeConversions();
+    const CustomConversion::TargetToNativeConversions &toCppConversions = customConversion->targetToNativeConversions();
     if (toCppConversions.isEmpty())
         return;
 
@@ -2556,7 +2556,7 @@ bool ShibokenGenerator::doSetup()
     return true;
 }
 
-void ShibokenGenerator::collectContainerTypesFromConverterMacros(const QString& code, bool toPythonMacro)
+void ShibokenGenerator::collectContainerTypesFromConverterMacros(const QString &code, bool toPythonMacro)
 {
     QString convMacro = toPythonMacro ? QLatin1String("%CONVERTTOPYTHON[") : QLatin1String("%CONVERTTOCPP[");
     int offset = toPythonMacro ? sizeof("%CONVERTTOPYTHON") : sizeof("%CONVERTTOCPP");
@@ -2566,7 +2566,7 @@ void ShibokenGenerator::collectContainerTypesFromConverterMacros(const QString&
         start += offset;
         if (code.at(start) != QLatin1Char('%')) {
             QString typeString = code.mid(start, end - start);
-            AbstractMetaType* type = buildAbstractMetaTypeFromString(typeString);
+            AbstractMetaType *type = buildAbstractMetaTypeFromString(typeString);
             addInstantiatedContainersAndSmartPointers(type, type->originalTypeDescription());
         }
         start = end;
@@ -2598,26 +2598,26 @@ bool ShibokenGenerator::avoidProtectedHack() const
     return m_avoidProtectedHack;
 }
 
-QString ShibokenGenerator::moduleCppPrefix(const QString& moduleName) const
+QString ShibokenGenerator::moduleCppPrefix(const QString &moduleName) const
  {
     QString result = moduleName.isEmpty() ? packageName() : moduleName;
     result.replace(QLatin1Char('.'), QLatin1Char('_'));
     return result;
 }
 
-QString ShibokenGenerator::cppApiVariableName(const QString& moduleName) const
+QString ShibokenGenerator::cppApiVariableName(const QString &moduleName) const
 {
     return QLatin1String("Sbk") + moduleCppPrefix(moduleName)
         + QLatin1String("Types");
 }
 
-QString ShibokenGenerator::pythonModuleObjectName(const QString& moduleName) const
+QString ShibokenGenerator::pythonModuleObjectName(const QString &moduleName) const
 {
     return QLatin1String("Sbk") + moduleCppPrefix(moduleName)
         + QLatin1String("ModuleObject");
 }
 
-QString ShibokenGenerator::convertersVariableName(const QString& moduleName) const
+QString ShibokenGenerator::convertersVariableName(const QString &moduleName) const
 {
     QString result = cppApiVariableName(moduleName);
     result.chop(1);
@@ -2625,7 +2625,7 @@ QString ShibokenGenerator::convertersVariableName(const QString& moduleName) con
     return result;
 }
 
-static QString processInstantiationsVariableName(const AbstractMetaType* type)
+static QString processInstantiationsVariableName(const AbstractMetaType *type)
 {
     QString res = QLatin1Char('_') + _fixedCppTypeName(type->typeEntry()->qualifiedCppName()).toUpper();
     const AbstractMetaTypeList &instantiations = type->instantiations();
@@ -2644,10 +2644,10 @@ static void appendIndexSuffix(QString *s)
     s->append(QStringLiteral("IDX"));
 }
 
-QString ShibokenGenerator::getTypeIndexVariableName(const AbstractMetaClass* metaClass, bool alternativeTemplateName)
+QString ShibokenGenerator::getTypeIndexVariableName(const AbstractMetaClass *metaClass, bool alternativeTemplateName)
 {
     if (alternativeTemplateName) {
-        const AbstractMetaClass* templateBaseClass = metaClass->templateBaseClass();
+        const AbstractMetaClass *templateBaseClass = metaClass->templateBaseClass();
         if (!templateBaseClass)
             return QString();
         QString result = QLatin1String("SBK_")
@@ -2660,10 +2660,10 @@ QString ShibokenGenerator::getTypeIndexVariableName(const AbstractMetaClass* met
     }
     return getTypeIndexVariableName(metaClass->typeEntry());
 }
-QString ShibokenGenerator::getTypeIndexVariableName(const TypeEntry* type)
+QString ShibokenGenerator::getTypeIndexVariableName(const TypeEntry *type)
 {
     if (type->isCppPrimitive()) {
-        const PrimitiveTypeEntry *trueType = static_cast<const PrimitiveTypeEntry*>(type);
+        const PrimitiveTypeEntry *trueType = static_cast<const PrimitiveTypeEntry *>(type);
         if (trueType->basicReferencedTypeEntry())
             type = trueType->basicReferencedTypeEntry();
     }
@@ -2678,7 +2678,7 @@ QString ShibokenGenerator::getTypeIndexVariableName(const TypeEntry* type)
     appendIndexSuffix(&result);
     return result;
 }
-QString ShibokenGenerator::getTypeIndexVariableName(const AbstractMetaType* type)
+QString ShibokenGenerator::getTypeIndexVariableName(const AbstractMetaType *type)
 {
     QString result = QLatin1String("SBK");
     if (type->typeEntry()->isContainer())
@@ -2693,7 +2693,7 @@ bool ShibokenGenerator::verboseErrorMessagesDisabled() const
     return m_verboseErrorMessagesDisabled;
 }
 
-bool ShibokenGenerator::pythonFunctionWrapperUsesListOfArguments(const OverloadData& overloadData)
+bool ShibokenGenerator::pythonFunctionWrapperUsesListOfArguments(const OverloadData &overloadData)
 {
     if (overloadData.referenceFunction()->isCallOperator())
         return true;
@@ -2707,7 +2707,7 @@ bool ShibokenGenerator::pythonFunctionWrapperUsesListOfArguments(const OverloadD
            || overloadData.hasArgumentWithDefaultValue();
 }
 
-QString  ShibokenGenerator::getDefaultValue(const AbstractMetaFunction* func, const AbstractMetaArgument* arg)
+QString  ShibokenGenerator::getDefaultValue(const AbstractMetaFunction *func, const AbstractMetaArgument *arg)
 {
     if (!arg->defaultValueExpression().isEmpty())
         return arg->defaultValueExpression();
@@ -2723,7 +2723,7 @@ QString  ShibokenGenerator::getDefaultValue(const AbstractMetaFunction* func, co
     return QString();
 }
 
-void ShibokenGenerator::writeMinimalConstructorExpression(QTextStream& s, const AbstractMetaType* type, const QString& defaultCtor)
+void ShibokenGenerator::writeMinimalConstructorExpression(QTextStream &s, const AbstractMetaType *type, const QString &defaultCtor)
 {
     if (!defaultCtor.isEmpty()) {
          s << " = " << defaultCtor;
@@ -2741,7 +2741,7 @@ void ShibokenGenerator::writeMinimalConstructorExpression(QTextStream& s, const
     }
 }
 
-void ShibokenGenerator::writeMinimalConstructorExpression(QTextStream& s, const TypeEntry* type, const QString& defaultCtor)
+void ShibokenGenerator::writeMinimalConstructorExpression(QTextStream &s, const TypeEntry *type, const QString &defaultCtor)
 {
     if (!defaultCtor.isEmpty()) {
          s << " = " << defaultCtor;
@@ -2759,7 +2759,7 @@ void ShibokenGenerator::writeMinimalConstructorExpression(QTextStream& s, const
     }
 }
 
-bool ShibokenGenerator::isCppIntegralPrimitive(const TypeEntry* type)
+bool ShibokenGenerator::isCppIntegralPrimitive(const TypeEntry *type)
 {
     if (!type->isCppPrimitive())
         return false;
@@ -2771,7 +2771,7 @@ bool ShibokenGenerator::isCppIntegralPrimitive(const TypeEntry* type)
         && !typeName.contains(QLatin1String("float"))
         && !typeName.contains(QLatin1String("wchar"));
 }
-bool ShibokenGenerator::isCppIntegralPrimitive(const AbstractMetaType* type)
+bool ShibokenGenerator::isCppIntegralPrimitive(const AbstractMetaType *type)
 {
     return isCppIntegralPrimitive(type->typeEntry());
 }
diff --git a/sources/shiboken2/generator/shiboken2/shibokengenerator.h b/sources/shiboken2/generator/shiboken2/shibokengenerator.h
index f5f291526..fe6a1dc37 100644
--- a/sources/shiboken2/generator/shiboken2/shibokengenerator.h
+++ b/sources/shiboken2/generator/shiboken2/shibokengenerator.h
@@ -74,16 +74,16 @@ public:
     /**
      * Helper function to find for argument default value
      */
-    static QString getDefaultValue(const AbstractMetaFunction* func, const AbstractMetaArgument* arg);
+    static QString getDefaultValue(const AbstractMetaFunction *func, const AbstractMetaArgument *arg);
 
     /// Returns a list of all ancestor classes for the given class.
-    AbstractMetaClassList getAllAncestors(const AbstractMetaClass* metaClass) const;
+    AbstractMetaClassList getAllAncestors(const AbstractMetaClass *metaClass) const;
 
 protected:
     bool doSetup() override;
 
     void writeArgumentNames(QTextStream &s,
-                            const AbstractMetaFunction* func,
+                            const AbstractMetaFunction *func,
                             Options options = NoOption) const override;
 
     /**
@@ -94,7 +94,7 @@ protected:
      *   \param options some extra options used during the parser
      */
     void writeFunctionArguments(QTextStream &s,
-                                const AbstractMetaFunction* func,
+                                const AbstractMetaFunction *func,
                                 Options options = NoOption) const override;
 
     /**
@@ -114,21 +114,21 @@ protected:
     AbstractMetaFunctionList getFunctionAndInheritedOverloads(const AbstractMetaFunction *func, QSet<QString> *seen);
 
     /// Write user's custom code snippets at class or module level.
-    void writeCodeSnips(QTextStream& s,
+    void writeCodeSnips(QTextStream &s,
                         const QVector<CodeSnip> & codeSnips,
                         TypeSystem::CodeSnipPosition position,
                         TypeSystem::Language language,
-                        const AbstractMetaClass* context = 0);
+                        const AbstractMetaClass *context = 0);
     /// Write user's custom code snippets at function level.
-    void writeCodeSnips(QTextStream& s,
+    void writeCodeSnips(QTextStream &s,
                         const QVector<CodeSnip> & codeSnips,
                         TypeSystem::CodeSnipPosition position,
                         TypeSystem::Language language,
-                        const AbstractMetaFunction* func,
-                        const AbstractMetaArgument* lastArg = 0);
+                        const AbstractMetaFunction *func,
+                        const AbstractMetaArgument *lastArg = nullptr);
 
     /// Replaces variables for the user's custom code at global or class level.
-    void processCodeSnip(QString& code, const AbstractMetaClass* context = 0);
+    void processCodeSnip(QString &code, const AbstractMetaClass *context = nullptr);
 
     /**
      *   Verifies if any of the function's code injections of the "native"
@@ -136,7 +136,7 @@ protected:
      *   \param func the function to check
      *   \return true if the function's native code snippets use "%PYSELF"
      */
-    bool injectedCodeUsesPySelf(const AbstractMetaFunction* func);
+    bool injectedCodeUsesPySelf(const AbstractMetaFunction *func);
 
     /**
      *   Verifies if any of the function's code injections makes a call
@@ -145,7 +145,7 @@ protected:
      *   \param func the function to check
      *   \return true if the function's code snippets call the wrapped C++ function
      */
-    bool injectedCodeCallsCppFunction(const AbstractMetaFunction* func);
+    bool injectedCodeCallsCppFunction(const AbstractMetaFunction *func);
 
     /**
      *   Verifies if any of the function's code injections of the "native" class makes a
@@ -154,7 +154,7 @@ protected:
      *   \param func the function to check
      *   \return true if the function's code snippets call the Python override for a C++ virtual method
      */
-    bool injectedCodeCallsPythonOverride(const AbstractMetaFunction* func);
+    bool injectedCodeCallsPythonOverride(const AbstractMetaFunction *func);
 
     /**
      *   Verifies if any of the function's code injections attributes values to
@@ -163,13 +163,13 @@ protected:
      *   \param language    the kind of code snip
      *   \return true if the function's code attributes values to "%0" or "%PYARG_0"
      */
-    bool injectedCodeHasReturnValueAttribution(const AbstractMetaFunction* func, TypeSystem::Language language = TypeSystem::TargetLangCode);
+    bool injectedCodeHasReturnValueAttribution(const AbstractMetaFunction *func, TypeSystem::Language language = TypeSystem::TargetLangCode);
 
     /**
      *   Verifies if any of the function's code injections uses the type system variable
      *   for function arguments of a given index.
      */
-    bool injectedCodeUsesArgument(const AbstractMetaFunction* func, int argumentIndex);
+    bool injectedCodeUsesArgument(const AbstractMetaFunction *func, int argumentIndex);
 
     /**
      *   Function which parse the metafunction information
@@ -177,125 +177,125 @@ protected:
      *   \param option some extra options
      *   \param arg_count the number of function arguments
      */
-    QString functionSignature(const AbstractMetaFunction* func,
+    QString functionSignature(const AbstractMetaFunction *func,
                               const QString &prepend = QString(),
                               const QString &append = QString(),
                               Options options = NoOption,
                               int arg_count = -1) const;
 
     /// Returns the top-most class that has multiple inheritance in the ancestry.
-    static const AbstractMetaClass *getMultipleInheritingClass(const AbstractMetaClass* metaClass);
+    static const AbstractMetaClass *getMultipleInheritingClass(const AbstractMetaClass *metaClass);
 
     /// Returns true if the class needs to have a getattro function.
-    bool classNeedsGetattroFunction(const AbstractMetaClass* metaClass);
+    bool classNeedsGetattroFunction(const AbstractMetaClass *metaClass);
 
     /// Returns true if the class needs to have a setattro function.
     bool classNeedsSetattroFunction(const AbstractMetaClass *metaClass);
 
     /// Returns a list of methods of the given class where each one is part of a different overload with both static and non-static method.
-    AbstractMetaFunctionList getMethodsWithBothStaticAndNonStaticMethods(const AbstractMetaClass* metaClass);
+    AbstractMetaFunctionList getMethodsWithBothStaticAndNonStaticMethods(const AbstractMetaClass *metaClass);
 
     /// Returns a list of parent classes for a given class.
-    AbstractMetaClassList getBaseClasses(const AbstractMetaClass* metaClass) const;
+    AbstractMetaClassList getBaseClasses(const AbstractMetaClass *metaClass) const;
 
-    void writeToPythonConversion(QTextStream& s, const AbstractMetaType* type,
-                                 const AbstractMetaClass* context, const QString& argumentName);
-    void writeToCppConversion(QTextStream& s, const AbstractMetaType* type, const AbstractMetaClass* context, const QString& inArgName, const QString& outArgName);
-    void writeToCppConversion(QTextStream& s, const AbstractMetaClass* metaClass, const QString& inArgName, const QString& outArgName);
+    void writeToPythonConversion(QTextStream &s, const AbstractMetaType *type,
+                                 const AbstractMetaClass *context, const QString &argumentName);
+    void writeToCppConversion(QTextStream &s, const AbstractMetaType *type, const AbstractMetaClass *context, const QString &inArgName, const QString &outArgName);
+    void writeToCppConversion(QTextStream &s, const AbstractMetaClass *metaClass, const QString &inArgName, const QString &outArgName);
 
     /// Returns true if the argument is a pointer that rejects nullptr values.
-    bool shouldRejectNullPointerArgument(const AbstractMetaFunction* func, int argIndex);
+    bool shouldRejectNullPointerArgument(const AbstractMetaFunction *func, int argIndex);
 
     /// Verifies if the class should have a C++ wrapper generated for it, instead of only a Python wrapper.
-    bool shouldGenerateCppWrapper(const AbstractMetaClass* metaClass) const;
+    bool shouldGenerateCppWrapper(const AbstractMetaClass *metaClass) const;
 
     /// Adds enums eligible for generation from classes/namespaces marked not to be generated.
-    static void lookForEnumsInClassesNotToBeGenerated(AbstractMetaEnumList& enumList, const AbstractMetaClass* metaClass);
+    static void lookForEnumsInClassesNotToBeGenerated(AbstractMetaEnumList &enumList, const AbstractMetaClass *metaClass);
     /// Returns the enclosing class for an enum, or nullptr if it should be global.
-    const AbstractMetaClass* getProperEnclosingClassForEnum(const AbstractMetaEnum* metaEnum);
+    const AbstractMetaClass *getProperEnclosingClassForEnum(const AbstractMetaEnum *metaEnum);
 
-    QString wrapperName(const AbstractMetaClass* metaClass) const;
+    QString wrapperName(const AbstractMetaClass *metaClass) const;
     QString wrapperName(const AbstractMetaType *metaType) const;
 
     QString fullPythonClassName(const AbstractMetaClass *metaClass);
     QString fullPythonFunctionName(const AbstractMetaFunction *func);
 
-    static QString protectedEnumSurrogateName(const AbstractMetaEnum* metaEnum);
-    static QString protectedFieldGetterName(const AbstractMetaField* field);
-    static QString protectedFieldSetterName(const AbstractMetaField* field);
+    static QString protectedEnumSurrogateName(const AbstractMetaEnum *metaEnum);
+    static QString protectedFieldGetterName(const AbstractMetaField *field);
+    static QString protectedFieldSetterName(const AbstractMetaField *field);
 
-    static QString pythonPrimitiveTypeName(const QString& cppTypeName);
-    static QString pythonPrimitiveTypeName(const PrimitiveTypeEntry* type);
+    static QString pythonPrimitiveTypeName(const QString &cppTypeName);
+    static QString pythonPrimitiveTypeName(const PrimitiveTypeEntry *type);
 
     static QString pythonOperatorFunctionName(const QString &cppOpFuncName);
-    static QString pythonOperatorFunctionName(const AbstractMetaFunction* func);
+    static QString pythonOperatorFunctionName(const AbstractMetaFunction *func);
     static QString pythonRichCompareOperatorId(const QString &cppOpFuncName);
-    static QString pythonRichCompareOperatorId(const AbstractMetaFunction* func);
+    static QString pythonRichCompareOperatorId(const AbstractMetaFunction *func);
 
-    static QString fixedCppTypeName(const CustomConversion::TargetToNativeConversion* toNative);
-    static QString fixedCppTypeName(const AbstractMetaType* type);
-    static QString fixedCppTypeName(const TypeEntry* type, QString typeName = QString());
+    static QString fixedCppTypeName(const CustomConversion::TargetToNativeConversion *toNative);
+    static QString fixedCppTypeName(const AbstractMetaType *type);
+    static QString fixedCppTypeName(const TypeEntry *type, QString typeName = QString());
 
     static bool isNumber(const QString &cpythonApiName);
-    static bool isNumber(const TypeEntry* type);
-    static bool isNumber(const AbstractMetaType* type);
-    static bool isPyInt(const TypeEntry* type);
-    static bool isPyInt(const AbstractMetaType* type);
+    static bool isNumber(const TypeEntry *type);
+    static bool isNumber(const AbstractMetaType *type);
+    static bool isPyInt(const TypeEntry *type);
+    static bool isPyInt(const AbstractMetaType *type);
 
     /**
      *  Returns true if the type passed has a Python wrapper for it.
      *  Although namespace has a Python wrapper, it's not considered a type.
      */
-    static bool isWrapperType(const TypeEntry* type);
-    static bool isWrapperType(const ComplexTypeEntry* type);
-    static bool isWrapperType(const AbstractMetaType* metaType);
+    static bool isWrapperType(const TypeEntry *type);
+    static bool isWrapperType(const ComplexTypeEntry *type);
+    static bool isWrapperType(const AbstractMetaType *metaType);
 
     /**
      *  Checks if the type is an Object/QObject or pointer to Value Type.
      *  In other words, tells if the type is "T*" and T has a Python wrapper.
      */
-    static bool isPointerToWrapperType(const AbstractMetaType* type);
+    static bool isPointerToWrapperType(const AbstractMetaType *type);
 
     /**
      *  Returns true if \p type is an Object Type used as a value.
      */
-    static bool isObjectTypeUsedAsValueType(const AbstractMetaType* type);
+    static bool isObjectTypeUsedAsValueType(const AbstractMetaType *type);
 
-    static bool isValueTypeWithCopyConstructorOnly(const AbstractMetaClass* metaClass);
-    bool isValueTypeWithCopyConstructorOnly(const TypeEntry* type) const;
-    bool isValueTypeWithCopyConstructorOnly(const AbstractMetaType* type) const;
+    static bool isValueTypeWithCopyConstructorOnly(const AbstractMetaClass *metaClass);
+    bool isValueTypeWithCopyConstructorOnly(const TypeEntry *type) const;
+    bool isValueTypeWithCopyConstructorOnly(const AbstractMetaType *type) const;
 
     /// Returns true if the type is a primitive but not a C++ primitive.
-    static bool isUserPrimitive(const TypeEntry* type);
-    static bool isUserPrimitive(const AbstractMetaType* type);
+    static bool isUserPrimitive(const TypeEntry *type);
+    static bool isUserPrimitive(const AbstractMetaType *type);
 
     /// Returns true if the type is a C++ primitive, a void*, a const char*, or a std::string.
-    static bool isCppPrimitive(const TypeEntry* type);
-    static bool isCppPrimitive(const AbstractMetaType* type);
+    static bool isCppPrimitive(const TypeEntry *type);
+    static bool isCppPrimitive(const AbstractMetaType *type);
 
     /// Returns true if the type is a C++ integral primitive, i.e. bool, char, int, long, and their unsigned counterparts.
-    static bool isCppIntegralPrimitive(const TypeEntry* type);
-    static bool isCppIntegralPrimitive(const AbstractMetaType* type);
+    static bool isCppIntegralPrimitive(const TypeEntry *type);
+    static bool isCppIntegralPrimitive(const AbstractMetaType *type);
 
     /// Checks if an argument type should be dereferenced by the Python method wrapper before calling the C++ method.
-    static bool shouldDereferenceArgumentPointer(const AbstractMetaArgument* arg);
+    static bool shouldDereferenceArgumentPointer(const AbstractMetaArgument *arg);
     /// Checks if a meta type should be dereferenced by the Python method wrapper passing it to C++.
-    static bool shouldDereferenceAbstractMetaTypePointer(const AbstractMetaType* metaType);
-
-    static bool visibilityModifiedToPrivate(const AbstractMetaFunction* func);
-
-    QString converterObject(const AbstractMetaType* type);
-    QString converterObject(const TypeEntry* type);
-
-    QString cpythonBaseName(const AbstractMetaClass* metaClass);
-    QString cpythonBaseName(const TypeEntry* type);
-    QString cpythonBaseName(const AbstractMetaType* type);
-    QString cpythonTypeName(const AbstractMetaClass* metaClass);
-    QString cpythonTypeName(const TypeEntry* type);
-    QString cpythonTypeNameExt(const TypeEntry* type);
-    QString cpythonTypeNameExt(const AbstractMetaType* type);
-    QString cpythonCheckFunction(const TypeEntry* type, bool genericNumberType = false);
-    QString cpythonCheckFunction(const AbstractMetaType* metaType, bool genericNumberType = false);
+    static bool shouldDereferenceAbstractMetaTypePointer(const AbstractMetaType *metaType);
+
+    static bool visibilityModifiedToPrivate(const AbstractMetaFunction *func);
+
+    QString converterObject(const AbstractMetaType *type);
+    QString converterObject(const TypeEntry *type);
+
+    QString cpythonBaseName(const AbstractMetaClass *metaClass);
+    QString cpythonBaseName(const TypeEntry *type);
+    QString cpythonBaseName(const AbstractMetaType *type);
+    QString cpythonTypeName(const AbstractMetaClass *metaClass);
+    QString cpythonTypeName(const TypeEntry *type);
+    QString cpythonTypeNameExt(const TypeEntry *type);
+    QString cpythonTypeNameExt(const AbstractMetaType *type);
+    QString cpythonCheckFunction(const TypeEntry *type, bool genericNumberType = false);
+    QString cpythonCheckFunction(const AbstractMetaType *metaType, bool genericNumberType = false);
     /**
      *  Receives the argument \p type and tries to find the appropriate AbstractMetaType for it
      *  or a custom type check.
@@ -306,28 +306,28 @@ protected:
      *  \return A custom check if \p type is a custom type, or an empty string if \p metaType
      *          receives an existing type object.
      */
-    QString guessCPythonCheckFunction(const QString& type, AbstractMetaType** metaType);
-    QString cpythonIsConvertibleFunction(const TypeEntry* type, bool genericNumberType = false, bool checkExact = false);
-    QString cpythonIsConvertibleFunction(const AbstractMetaType* metaType, bool genericNumberType = false);
-    QString cpythonIsConvertibleFunction(const AbstractMetaArgument* metaArg, bool genericNumberType = false);
-
-    QString cpythonToCppConversionFunction(const AbstractMetaClass* metaClass);
-    QString cpythonToCppConversionFunction(const AbstractMetaType* type, const AbstractMetaClass* context = 0);
-    QString cpythonToPythonConversionFunction(const AbstractMetaType* type, const AbstractMetaClass* context = 0);
-    QString cpythonToPythonConversionFunction(const AbstractMetaClass* metaClass);
-    QString cpythonToPythonConversionFunction(const TypeEntry* type);
-
-    QString cpythonFunctionName(const AbstractMetaFunction* func);
-    QString cpythonMethodDefinitionName(const AbstractMetaFunction* func);
-    QString cpythonGettersSettersDefinitionName(const AbstractMetaClass* metaClass);
-    QString cpythonGetattroFunctionName(const AbstractMetaClass* metaClass);
-    QString cpythonSetattroFunctionName(const AbstractMetaClass* metaClass);
-    QString cpythonGetterFunctionName(const AbstractMetaField* metaField);
-    QString cpythonSetterFunctionName(const AbstractMetaField* metaField);
-    QString cpythonWrapperCPtr(const AbstractMetaClass* metaClass,
+    QString guessCPythonCheckFunction(const QString &type, AbstractMetaType **metaType);
+    QString cpythonIsConvertibleFunction(const TypeEntry *type, bool genericNumberType = false, bool checkExact = false);
+    QString cpythonIsConvertibleFunction(const AbstractMetaType *metaType, bool genericNumberType = false);
+    QString cpythonIsConvertibleFunction(const AbstractMetaArgument *metaArg, bool genericNumberType = false);
+
+    QString cpythonToCppConversionFunction(const AbstractMetaClass *metaClass);
+    QString cpythonToCppConversionFunction(const AbstractMetaType *type, const AbstractMetaClass *context = 0);
+    QString cpythonToPythonConversionFunction(const AbstractMetaType *type, const AbstractMetaClass *context = 0);
+    QString cpythonToPythonConversionFunction(const AbstractMetaClass *metaClass);
+    QString cpythonToPythonConversionFunction(const TypeEntry *type);
+
+    QString cpythonFunctionName(const AbstractMetaFunction *func);
+    QString cpythonMethodDefinitionName(const AbstractMetaFunction *func);
+    QString cpythonGettersSettersDefinitionName(const AbstractMetaClass *metaClass);
+    QString cpythonGetattroFunctionName(const AbstractMetaClass *metaClass);
+    QString cpythonSetattroFunctionName(const AbstractMetaClass *metaClass);
+    QString cpythonGetterFunctionName(const AbstractMetaField *metaField);
+    QString cpythonSetterFunctionName(const AbstractMetaField *metaField);
+    QString cpythonWrapperCPtr(const AbstractMetaClass *metaClass,
                                const QString &argName = QLatin1String("self"));
     QString cpythonWrapperCPtr(const AbstractMetaType *metaType, const QString &argName);
-    QString cpythonWrapperCPtr(const TypeEntry* type, const QString &argName);
+    QString cpythonWrapperCPtr(const TypeEntry *type, const QString &argName);
 
     /// Guesses the scope to where belongs an argument's default value.
     QString guessScopeForDefaultValue(const AbstractMetaFunction *func,
@@ -336,18 +336,18 @@ protected:
                                            const AbstractMetaArgument *arg,
                                            const QString &value) const;
 
-    QString cpythonEnumName(const EnumTypeEntry* enumEntry);
-    QString cpythonEnumName(const AbstractMetaEnum* metaEnum);
+    QString cpythonEnumName(const EnumTypeEntry *enumEntry);
+    QString cpythonEnumName(const AbstractMetaEnum *metaEnum);
 
-    QString cpythonFlagsName(const FlagsTypeEntry* flagsEntry);
-    QString cpythonFlagsName(const AbstractMetaEnum* metaEnum);
+    QString cpythonFlagsName(const FlagsTypeEntry *flagsEntry);
+    QString cpythonFlagsName(const AbstractMetaEnum *metaEnum);
     /// Returns the special cast function name, the function used to proper cast class with multiple inheritance.
-    QString cpythonSpecialCastFunctionName(const AbstractMetaClass* metaClass);
+    QString cpythonSpecialCastFunctionName(const AbstractMetaClass *metaClass);
 
-    QString getFormatUnitString(const AbstractMetaFunction* func, bool incRef = false) const;
+    QString getFormatUnitString(const AbstractMetaFunction *func, bool incRef = false) const;
 
     /// Returns the file name for the module global header. If no module name is provided the current will be used.
-    QString getModuleHeaderFileName(const QString& moduleName = QString()) const;
+    QString getModuleHeaderFileName(const QString &moduleName = QString()) const;
 
     OptionDescriptions options() const override;
     bool handleOption(const QString &key, const QString &value) override;
@@ -362,18 +362,18 @@ protected:
     bool useIsNullAsNbNonZero() const;
     /// Returns true if the generated code should use the "#define protected public" hack.
     bool avoidProtectedHack() const;
-    QString cppApiVariableName(const QString& moduleName = QString()) const;
-    QString pythonModuleObjectName(const QString& moduleName = QString()) const;
-    QString convertersVariableName(const QString& moduleName = QString()) const;
+    QString cppApiVariableName(const QString &moduleName = QString()) const;
+    QString pythonModuleObjectName(const QString &moduleName = QString()) const;
+    QString convertersVariableName(const QString &moduleName = QString()) const;
     /**
      *  Returns the type index variable name for a given class. If \p alternativeTemplateName is true
      *  and the class is a typedef for a template class instantiation, it will return an alternative name
      *  made of the template class and the instantiation values, or an empty string if the class isn't
      *  derived from a template class at all.
      */
-    QString getTypeIndexVariableName(const AbstractMetaClass* metaClass, bool alternativeTemplateName = false);
-    QString getTypeIndexVariableName(const TypeEntry* type);
-    QString getTypeIndexVariableName(const AbstractMetaType* type);
+    QString getTypeIndexVariableName(const AbstractMetaClass *metaClass, bool alternativeTemplateName = false);
+    QString getTypeIndexVariableName(const TypeEntry *type);
+    QString getTypeIndexVariableName(const AbstractMetaType *type);
 
     /// Returns true if the user don't want verbose error messages on the generated bindings.
     bool verboseErrorMessagesDisabled() const;
@@ -389,16 +389,16 @@ protected:
                                                       QString *errorMessage = nullptr);
 
     /// Creates an AbstractMetaType object from a TypeEntry.
-    AbstractMetaType* buildAbstractMetaTypeFromTypeEntry(const TypeEntry* typeEntry);
+    AbstractMetaType *buildAbstractMetaTypeFromTypeEntry(const TypeEntry *typeEntry);
     /// Creates an AbstractMetaType object from an AbstractMetaClass.
-    AbstractMetaType* buildAbstractMetaTypeFromAbstractMetaClass(const AbstractMetaClass* metaClass);
+    AbstractMetaType *buildAbstractMetaTypeFromAbstractMetaClass(const AbstractMetaClass *metaClass);
 
-    void writeMinimalConstructorExpression(QTextStream& s, const AbstractMetaType* type, const QString& defaultCtor = QString());
-    void writeMinimalConstructorExpression(QTextStream& s, const TypeEntry* type, const QString& defaultCtor = QString());
+    void writeMinimalConstructorExpression(QTextStream &s, const AbstractMetaType *type, const QString &defaultCtor = QString());
+    void writeMinimalConstructorExpression(QTextStream &s, const TypeEntry *type, const QString &defaultCtor = QString());
 
-    void collectContainerTypesFromConverterMacros(const QString& code, bool toPythonMacro);
+    void collectContainerTypesFromConverterMacros(const QString &code, bool toPythonMacro);
     // verify whether the class is copyable
-    bool isCopyable(const AbstractMetaClass* metaClass);
+    bool isCopyable(const AbstractMetaClass *metaClass);
 
     void clearTpFuncs();
 
@@ -408,13 +408,13 @@ protected:
     /// Initializes a list of Python known type names.
     static void initKnownPythonTypes();
 
-    void writeFunctionCall(QTextStream& s,
-                           const AbstractMetaFunction* metaFunc,
+    void writeFunctionCall(QTextStream &s,
+                           const AbstractMetaFunction *metaFunc,
                            Options options = NoOption) const;
 
-    void writeUnusedVariableCast(QTextStream& s, const QString& variableName);
+    void writeUnusedVariableCast(QTextStream &s, const QString &variableName);
 
-    AbstractMetaFunctionList filterFunctions(const AbstractMetaClass* metaClass);
+    AbstractMetaFunctionList filterFunctions(const AbstractMetaClass *metaClass);
 
     // All data about extended converters: the type entries of the target type, and a
     // list of AbstractMetaClasses accepted as argument for the conversion.
@@ -426,7 +426,7 @@ protected:
     QVector<const CustomConversion *> getPrimitiveCustomConversions();
 
     /// Returns true if the Python wrapper for the received OverloadData must accept a list of arguments.
-    static bool pythonFunctionWrapperUsesListOfArguments(const OverloadData& overloadData);
+    static bool pythonFunctionWrapperUsesListOfArguments(const OverloadData &overloadData);
 
     Indentor INDENT;
 
@@ -446,8 +446,8 @@ private:
     static FunctionGroups getFunctionGroupsImpl(const AbstractMetaClass *scope);
     static bool classNeedsGetattroFunctionImpl(const AbstractMetaClass *metaClass);
 
-    QString translateTypeForWrapperMethod(const AbstractMetaType* cType,
-                                          const AbstractMetaClass* context,
+    QString translateTypeForWrapperMethod(const AbstractMetaType *cType,
+                                          const AbstractMetaClass *context,
                                           Options opt = NoOption) const;
 
     /**
@@ -464,8 +464,8 @@ private:
      *   \param scope scope used to search for overloads.
      *   \param functionName the function name.
      */
-    AbstractMetaFunctionList getFunctionOverloads(const AbstractMetaClass* scope,
-                                                  const QString& functionName);
+    AbstractMetaFunctionList getFunctionOverloads(const AbstractMetaClass *scope,
+                                                  const QString &functionName);
     /**
      *   Write a function argument in the C++ in the text stream \p s.
      *   This function just call \code s << argumentString(); \endcode
@@ -475,8 +475,8 @@ private:
      *   \param options some extra options.
      */
     void writeArgument(QTextStream &s,
-                       const AbstractMetaFunction* func,
-                       const AbstractMetaArgument* argument,
+                       const AbstractMetaFunction *func,
+                       const AbstractMetaArgument *argument,
                        Options options = NoOption) const;
     /**
      *   Create a QString in the C++ format to an function argument.
@@ -484,18 +484,18 @@ private:
      *   \param argument metaargument information to be parsed.
      *   \param options some extra options.
      */
-    QString argumentString(const AbstractMetaFunction* func,
-                           const AbstractMetaArgument* argument,
+    QString argumentString(const AbstractMetaFunction *func,
+                           const AbstractMetaArgument *argument,
                            Options options = NoOption) const;
 
-    QString functionReturnType(const AbstractMetaFunction* func, Options options = NoOption) const;
+    QString functionReturnType(const AbstractMetaFunction *func, Options options = NoOption) const;
 
     /// Utility function for writeCodeSnips.
-    typedef QPair<const AbstractMetaArgument*, QString> ArgumentVarReplacementPair;
+    typedef QPair<const AbstractMetaArgument *, QString> ArgumentVarReplacementPair;
     typedef QVector<ArgumentVarReplacementPair> ArgumentVarReplacementList;
-    ArgumentVarReplacementList getArgumentReplacement(const AbstractMetaFunction* func,
+    ArgumentVarReplacementList getArgumentReplacement(const AbstractMetaFunction *func,
                                                       bool usePyArgs, TypeSystem::Language language,
-                                                      const AbstractMetaArgument* lastArg);
+                                                      const AbstractMetaArgument *lastArg);
 
     /// Returns a string with the user's custom code snippets that comply with \p position and \p language.
     QString getCodeSnippets(const QVector<CodeSnip> & codeSnips,
@@ -509,31 +509,31 @@ private:
         TypeSystemToPythonFunction,
         TypeSystemConverterVariables
     };
-    void replaceConverterTypeSystemVariable(TypeSystemConverterVariable converterVariable, QString& code);
+    void replaceConverterTypeSystemVariable(TypeSystemConverterVariable converterVariable, QString &code);
 
     /// Replaces the %CONVERTTOPYTHON type system variable.
-    inline void replaceConvertToPythonTypeSystemVariable(QString& code)
+    inline void replaceConvertToPythonTypeSystemVariable(QString &code)
     {
         replaceConverterTypeSystemVariable(TypeSystemToPythonFunction, code);
     }
     /// Replaces the %CONVERTTOCPP type system variable.
-    inline void replaceConvertToCppTypeSystemVariable(QString& code)
+    inline void replaceConvertToCppTypeSystemVariable(QString &code)
     {
         replaceConverterTypeSystemVariable(TypeSystemToCppFunction, code);
     }
     /// Replaces the %ISCONVERTIBLE type system variable.
-    inline void replaceIsConvertibleToCppTypeSystemVariable(QString& code)
+    inline void replaceIsConvertibleToCppTypeSystemVariable(QString &code)
     {
         replaceConverterTypeSystemVariable(TypeSystemIsConvertibleFunction, code);
     }
     /// Replaces the %CHECKTYPE type system variable.
-    inline void replaceTypeCheckTypeSystemVariable(QString& code)
+    inline void replaceTypeCheckTypeSystemVariable(QString &code)
     {
         replaceConverterTypeSystemVariable(TypeSystemCheckFunction, code);
     }
 
     /// Return a prefix with '_' suitable for names in C++
-    QString moduleCppPrefix(const QString& moduleName = QString()) const;
+    QString moduleCppPrefix(const QString &moduleName = QString()) const;
 
     bool m_useCtorHeuristic = false;
     bool m_userReturnValueHeuristic = false;
@@ -542,7 +542,7 @@ private:
     bool m_useIsNullAsNbNonZero = false;
     bool m_avoidProtectedHack = false;
 
-    typedef QHash<QString, AbstractMetaType*> AbstractMetaTypeCache;
+    typedef QHash<QString, AbstractMetaType *> AbstractMetaTypeCache;
     AbstractMetaTypeCache m_metaTypeFromStringCache;
 
     /// Type system converter variable replacement names and regular expressions.
diff --git a/sources/shiboken2/libshiboken/autodecref.h b/sources/shiboken2/libshiboken/autodecref.h
index 72fd236de..b2f5a6325 100644
--- a/sources/shiboken2/libshiboken/autodecref.h
+++ b/sources/shiboken2/libshiboken/autodecref.h
@@ -53,21 +53,21 @@ namespace Shiboken
 struct LIBSHIBOKEN_API AutoDecRef
 {
 public:
-    AutoDecRef(const AutoDecRef&) = delete;
-    AutoDecRef(AutoDecRef&&) = delete;
-    AutoDecRef& operator=(const AutoDecRef&) = delete;
-    AutoDecRef& operator=(AutoDecRef&&) = delete;
+    AutoDecRef(const AutoDecRef &) = delete;
+    AutoDecRef(AutoDecRef &&) = delete;
+    AutoDecRef &operator=(const AutoDecRef &) = delete;
+    AutoDecRef &operator=(AutoDecRef &&) = delete;
 
     /**
      * AutoDecRef constructor.
      * \param pyobj A borrowed reference to a Python object
      */
-    explicit AutoDecRef(PyObject* pyObj) : m_pyObj(pyObj) {}
+    explicit AutoDecRef(PyObject *pyObj) : m_pyObj(pyObj) {}
     /**
      * AutoDecRef constructor.
      * \param pyobj A borrowed reference to a Python object
      */
-    explicit AutoDecRef(SbkObject* pyObj) : m_pyObj(reinterpret_cast<PyObject*>(pyObj)) {}
+    explicit AutoDecRef(SbkObject *pyObj) : m_pyObj(reinterpret_cast<PyObject *>(pyObj)) {}
 
     /// Decref the borrowed python reference
     ~AutoDecRef()
@@ -77,13 +77,13 @@ public:
 
     inline bool isNull() const { return m_pyObj == 0; }
     /// Returns the pointer of the Python object being held.
-    inline PyObject* object() { return m_pyObj; }
-    inline operator PyObject*() { return m_pyObj; }
+    inline PyObject *object() { return m_pyObj; }
+    inline operator PyObject *() { return m_pyObj; }
 #ifndef Py_LIMITED_API
-    inline operator PyTupleObject*() { return reinterpret_cast<PyTupleObject*>(m_pyObj); }
+    inline operator PyTupleObject *() { return reinterpret_cast<PyTupleObject *>(m_pyObj); }
 #endif
     inline operator bool() const { return m_pyObj != 0; }
-    inline PyObject* operator->() { return m_pyObj; }
+    inline PyObject *operator->() { return m_pyObj; }
 
     template<typename T>
     T cast()
@@ -94,13 +94,13 @@ public:
     /**
      * Decref the current borrowed python reference and borrow \p other.
      */
-    void reset(PyObject* other)
+    void reset(PyObject *other)
     {
         Py_XDECREF(m_pyObj);
         m_pyObj = other;
     }
 private:
-    PyObject* m_pyObj;
+    PyObject *m_pyObj;
 };
 
 } // namespace Shiboken
diff --git a/sources/shiboken2/libshiboken/basewrapper.cpp b/sources/shiboken2/libshiboken/basewrapper.cpp
index f38b55b56..a12d95982 100644
--- a/sources/shiboken2/libshiboken/basewrapper.cpp
+++ b/sources/shiboken2/libshiboken/basewrapper.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2016 The Qt Company Ltd.
+** Copyright (C) 2019 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of Qt for Python.
@@ -58,7 +58,7 @@
 #include "voidptr.h"
 
 namespace {
-    void _destroyParentInfo(SbkObject* obj, bool keepReference);
+    void _destroyParentInfo(SbkObject *obj, bool keepReference);
 }
 
 static void callDestructor(const Shiboken::DtorAccumulatorVisitor::DestructorEntries &dts)
@@ -73,15 +73,15 @@ static void callDestructor(const Shiboken::DtorAccumulatorVisitor::DestructorEnt
 extern "C"
 {
 
-static void SbkObjectTypeDealloc(PyObject* pyObj);
-static PyObject* SbkObjectTypeTpNew(PyTypeObject* metatype, PyObject* args, PyObject* kwds);
+static void SbkObjectTypeDealloc(PyObject *pyObj);
+static PyObject *SbkObjectTypeTpNew(PyTypeObject *metatype, PyObject *args, PyObject *kwds);
 
 // PYSIDE-908: The function PyType_Modified does not work in PySide, so we need to
 // explicitly pass __doc__. For __signature__ it _did_ actually work, because
 // it was not existing before. We add them both for clarity.
 static PyGetSetDef SbkObjectType_Type_getsetlist[] = {
-    {const_cast<char*>("__signature__"), (getter)Sbk_TypeGet___signature__},
-    {const_cast<char*>("__doc__"),       (getter)Sbk_TypeGet___doc__},
+    {const_cast<char *>("__signature__"), (getter)Sbk_TypeGet___signature__},
+    {const_cast<char *>("__doc__"),       (getter)Sbk_TypeGet___doc__},
     {nullptr}  // Sentinel
 };
 
@@ -205,7 +205,7 @@ PyTypeObject *SbkObjectType_TypeF(void)
     return type;
 }
 
-static PyObject *SbkObjectGetDict(PyObject* pObj, void *)
+static PyObject *SbkObjectGetDict(PyObject *pObj, void *)
 {
     SbkObject *obj = reinterpret_cast<SbkObject *>(pObj);
     if (!obj->ob_dict)
@@ -217,23 +217,23 @@ static PyObject *SbkObjectGetDict(PyObject* pObj, void *)
 }
 
 static PyGetSetDef SbkObjectGetSetList[] = {
-    {const_cast<char*>("__dict__"), SbkObjectGetDict, 0, 0, 0},
+    {const_cast<char *>("__dict__"), SbkObjectGetDict, 0, 0, 0},
     {0, 0, 0, 0, 0} // Sentinel
 };
 
-static int SbkObject_traverse(PyObject* self, visitproc visit, void* arg)
+static int SbkObject_traverse(PyObject *self, visitproc visit, void *arg)
 {
-    SbkObject* sbkSelf = reinterpret_cast<SbkObject*>(self);
+    SbkObject *sbkSelf = reinterpret_cast<SbkObject *>(self);
 
     //Visit children
-    Shiboken::ParentInfo* pInfo = sbkSelf->d->parentInfo;
+    Shiboken::ParentInfo *pInfo = sbkSelf->d->parentInfo;
     if (pInfo) {
         for (SbkObject *c : pInfo->children)
              Py_VISIT(c);
     }
 
     //Visit refs
-    Shiboken::RefCountMap* rInfo = sbkSelf->d->referredObjects;
+    Shiboken::RefCountMap *rInfo = sbkSelf->d->referredObjects;
     if (rInfo) {
         for (auto it = rInfo->begin(), end = rInfo->end(); it != end; ++it)
             Py_VISIT(it->second);
@@ -244,9 +244,9 @@ static int SbkObject_traverse(PyObject* self, visitproc visit, void* arg)
     return 0;
 }
 
-static int SbkObject_clear(PyObject* self)
+static int SbkObject_clear(PyObject *self)
 {
-    SbkObject* sbkSelf = reinterpret_cast<SbkObject*>(self);
+    SbkObject *sbkSelf = reinterpret_cast<SbkObject *>(self);
 
     Shiboken::Object::removeParent(sbkSelf);
 
@@ -298,10 +298,10 @@ static int mainThreadDeletionHandler(void *)
     return 0;
 }
 
-static void SbkDeallocWrapperCommon(PyObject* pyObj, bool canDelete)
+static void SbkDeallocWrapperCommon(PyObject *pyObj, bool canDelete)
 {
-    SbkObject* sbkObj = reinterpret_cast<SbkObject*>(pyObj);
-    PyTypeObject* pyType = Py_TYPE(pyObj);
+    SbkObject *sbkObj = reinterpret_cast<SbkObject *>(pyObj);
+    PyTypeObject *pyType = Py_TYPE(pyObj);
 
     // Need to decref the type if this is the dealloc func; if type
     // is subclassed, that dealloc func will decref (see subtype_dealloc
@@ -352,7 +352,7 @@ static void SbkDeallocWrapperCommon(PyObject* pyObj, bool canDelete)
             Shiboken::Object::deallocData(sbkObj, true);
             callDestructor(visitor.entries());
         } else {
-            void* cptr = sbkObj->d->cptr[0];
+            void *cptr = sbkObj->d->cptr[0];
             Shiboken::Object::deallocData(sbkObj, true);
 
             Shiboken::ThreadStateSaver threadSaver;
@@ -368,27 +368,27 @@ static void SbkDeallocWrapperCommon(PyObject* pyObj, bool canDelete)
         Py_DECREF(pyType);
 }
 
-void SbkDeallocWrapper(PyObject* pyObj)
+void SbkDeallocWrapper(PyObject *pyObj)
 {
     SbkDeallocWrapperCommon(pyObj, true);
 }
 
-void SbkDeallocQAppWrapper(PyObject* pyObj)
+void SbkDeallocQAppWrapper(PyObject *pyObj)
 {
     SbkDeallocWrapper(pyObj);
     // PYSIDE-571: make sure to create a singleton deleted qApp.
     MakeSingletonQAppWrapper(NULL);
 }
 
-void SbkDeallocWrapperWithPrivateDtor(PyObject* self)
+void SbkDeallocWrapperWithPrivateDtor(PyObject *self)
 {
     SbkDeallocWrapperCommon(self, false);
 }
 
-void SbkObjectTypeDealloc(PyObject* pyObj)
+void SbkObjectTypeDealloc(PyObject *pyObj)
 {
     SbkObjectTypePrivate *sotp = PepType_SOTP(pyObj);
-    PyTypeObject *type = reinterpret_cast<PyTypeObject*>(pyObj);
+    auto type = reinterpret_cast<PyTypeObject *>(pyObj);
 
     PyObject_GC_UnTrack(pyObj);
 #ifndef Py_LIMITED_API
@@ -411,7 +411,7 @@ void SbkObjectTypeDealloc(PyObject* pyObj)
 #endif
 }
 
-PyObject* SbkObjectTypeTpNew(PyTypeObject* metatype, PyObject* args, PyObject* kwds)
+PyObject *SbkObjectTypeTpNew(PyTypeObject *metatype, PyObject *args, PyObject *kwds)
 {
     // Check if all bases are new style before calling type.tp_new
     // Was causing gc assert errors in test_bug704.py when
@@ -422,19 +422,19 @@ PyObject* SbkObjectTypeTpNew(PyTypeObject* metatype, PyObject* args, PyObject* k
     // Before we changed to heap types, it was sufficient to remove the
     // Py_TPFLAGS_BASETYPE flag. That does not work, because PySide does
     // not respect this flag itself!
-    PyObject* name;
-    PyObject* pyBases;
-    PyObject* dict;
-    static const char* kwlist[] = { "name", "bases", "dict", 0};
+    PyObject *name;
+    PyObject *pyBases;
+    PyObject *dict;
+    static const char *kwlist[] = { "name", "bases", "dict", nullptr};
 
-    if (!PyArg_ParseTupleAndKeywords(args, kwds, "sO!O!:sbktype", (char**)kwlist,
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "sO!O!:sbktype", (char **)kwlist,
                                      &name,
                                      &PyTuple_Type, &pyBases,
                                      &PyDict_Type, &dict))
         return NULL;
 
     for (int i=0, i_max=PyTuple_GET_SIZE(pyBases); i < i_max; i++) {
-        PyObject* baseType = PyTuple_GET_ITEM(pyBases, i);
+        PyObject *baseType = PyTuple_GET_ITEM(pyBases, i);
 #ifndef IS_PY3K
         if (PyClass_Check(baseType)) {
             PyErr_Format(PyExc_TypeError, "Invalid base class used in type %s. "
@@ -450,14 +450,14 @@ PyObject* SbkObjectTypeTpNew(PyTypeObject* metatype, PyObject* args, PyObject* k
 
     // The meta type creates a new type when the Python programmer extends a wrapped C++ class.
     newfunc type_new = reinterpret_cast<newfunc>(PyType_Type.tp_new);
-    SbkObjectType *newType = reinterpret_cast<SbkObjectType*>(type_new(metatype, args, kwds));
+    SbkObjectType *newType = reinterpret_cast<SbkObjectType *>(type_new(metatype, args, kwds));
     if (!newType)
         return 0;
 
     Shiboken::ObjectType::initPrivateData(newType);
     SbkObjectTypePrivate *sotp = PepType_SOTP(newType);
 
-    const auto bases = Shiboken::getCppBaseClasses(reinterpret_cast<PyTypeObject*>(newType));
+    const auto bases = Shiboken::getCppBaseClasses(reinterpret_cast<PyTypeObject *>(newType));
     if (bases.size() == 1) {
         SbkObjectTypePrivate *parentType = PepType_SOTP(bases.front());
         sotp->mi_offsets = parentType->mi_offsets;
@@ -489,19 +489,19 @@ PyObject* SbkObjectTypeTpNew(PyTypeObject* metatype, PyObject* args, PyObject* k
             PepType_SOTP(base)->subtype_init(newType, args, kwds);
     }
 
-    return reinterpret_cast<PyObject*>(newType);
+    return reinterpret_cast<PyObject *>(newType);
 }
 
 static PyObject *_setupNew(SbkObject *self, PyTypeObject *subtype)
 {
-    Py_INCREF(reinterpret_cast<PyObject*>(subtype));
-    SbkObjectPrivate* d = new SbkObjectPrivate;
+    Py_INCREF(reinterpret_cast<PyObject *>(subtype));
+    auto d = new SbkObjectPrivate;
 
-    SbkObjectTypePrivate * sotp = PepType_SOTP(subtype);
+    SbkObjectTypePrivate *sotp = PepType_SOTP(subtype);
     int numBases = ((sotp && sotp->is_multicpp) ?
         Shiboken::getNumberOfCppBaseClasses(subtype) : 1);
-    d->cptr = new void*[numBases];
-    std::memset(d->cptr, 0, sizeof(void*) * size_t(numBases));
+    d->cptr = new void *[numBases];
+    std::memset(d->cptr, 0, sizeof(void *) *size_t(numBases));
     d->hasOwnership = 1;
     d->containsCppWrapper = 0;
     d->validCppObject = 0;
@@ -511,18 +511,18 @@ static PyObject *_setupNew(SbkObject *self, PyTypeObject *subtype)
     self->ob_dict = nullptr;
     self->weakreflist = nullptr;
     self->d = d;
-    return reinterpret_cast<PyObject*>(self);
+    return reinterpret_cast<PyObject *>(self);
 }
 
-PyObject* SbkObjectTpNew(PyTypeObject *subtype, PyObject *, PyObject *)
+PyObject *SbkObjectTpNew(PyTypeObject *subtype, PyObject *, PyObject *)
 {
     SbkObject *self = PyObject_GC_New(SbkObject, subtype);
     PyObject *res = _setupNew(self, subtype);
-    PyObject_GC_Track(reinterpret_cast<PyObject*>(self));
+    PyObject_GC_Track(reinterpret_cast<PyObject *>(self));
     return res;
 }
 
-PyObject* SbkQAppTpNew(PyTypeObject* subtype, PyObject *, PyObject *)
+PyObject *SbkQAppTpNew(PyTypeObject *subtype, PyObject *, PyObject *)
 {
     // PYSIDE-571:
     // For qApp, we need to create a singleton Python object.
@@ -542,7 +542,7 @@ PyObject* SbkQAppTpNew(PyTypeObject* subtype, PyObject *, PyObject *)
         subtype->tp_free = PyObject_Del;
     }
 #endif
-    SbkObject* self = reinterpret_cast<SbkObject*>(MakeSingletonQAppWrapper(subtype));
+    auto self = reinterpret_cast<SbkObject *>(MakeSingletonQAppWrapper(subtype));
     return self == 0 ? 0 : _setupNew(self, subtype);
 }
 
@@ -553,7 +553,7 @@ object_dealloc(PyObject *self)
 }
 
 PyObject *
-SbkDummyNew(PyTypeObject *type, PyObject*, PyObject*)
+SbkDummyNew(PyTypeObject *type, PyObject *, PyObject *)
 {
     // PYSIDE-595: Give the same error as type_call does when tp_new is NULL.
     PyErr_Format(PyExc_TypeError,
@@ -568,12 +568,12 @@ SbkDummyNew(PyTypeObject *type, PyObject*, PyObject*)
 namespace
 {
 
-void _destroyParentInfo(SbkObject* obj, bool keepReference)
+void _destroyParentInfo(SbkObject *obj, bool keepReference)
 {
-    Shiboken::ParentInfo* pInfo = obj->d->parentInfo;
+    Shiboken::ParentInfo *pInfo = obj->d->parentInfo;
     if (pInfo) {
         while(!pInfo->children.empty()) {
-            SbkObject* first = *pInfo->children.begin();
+            SbkObject *first = *pInfo->children.begin();
             // Mark child as invalid
             Shiboken::Object::invalidate(first);
             Shiboken::Object::removeParent(first, false, keepReference);
@@ -588,13 +588,13 @@ namespace Shiboken
 {
 bool walkThroughClassHierarchy(PyTypeObject *currentType, HierarchyVisitor *visitor)
 {
-    PyObject* bases = currentType->tp_bases;
+    PyObject *bases = currentType->tp_bases;
     Py_ssize_t numBases = PyTuple_GET_SIZE(bases);
     bool result = false;
     for (int i = 0; !result && i < numBases; ++i) {
-        PyTypeObject* type = reinterpret_cast<PyTypeObject*>(PyTuple_GET_ITEM(bases, i));
-        if (PyType_IsSubtype(type, reinterpret_cast<PyTypeObject*>(SbkObject_TypeF()))) {
-            SbkObjectType* sbkType = reinterpret_cast<SbkObjectType*>(type);
+        auto type = reinterpret_cast<PyTypeObject *>(PyTuple_GET_ITEM(bases, i));
+        if (PyType_IsSubtype(type, reinterpret_cast<PyTypeObject *>(SbkObject_TypeF()))) {
+            auto sbkType = reinterpret_cast<SbkObjectType *>(type);
             result = PepType_SOTP(sbkType)->is_user_type
                      ? walkThroughClassHierarchy(type, visitor) : visitor->visit(sbkType);
         }
@@ -602,10 +602,10 @@ bool walkThroughClassHierarchy(PyTypeObject *currentType, HierarchyVisitor *visi
     return result;
 }
 
-bool importModule(const char* moduleName, PyTypeObject*** cppApiPtr)
+bool importModule(const char *moduleName, PyTypeObject *** cppApiPtr)
 {
-    PyObject* sysModules = PyImport_GetModuleDict();
-    PyObject* module = PyDict_GetItemString(sysModules, moduleName);
+    PyObject *sysModules = PyImport_GetModuleDict();
+    PyObject *module = PyDict_GetItemString(sysModules, moduleName);
     if (!module) {
         module = PyImport_ImportModule(moduleName);
         if (!module)
@@ -622,11 +622,11 @@ bool importModule(const char* moduleName, PyTypeObject*** cppApiPtr)
 
 #ifdef IS_PY3K
     if (PyCapsule_CheckExact(cppApi))
-        *cppApiPtr = reinterpret_cast<PyTypeObject**>(PyCapsule_GetPointer(cppApi, 0));
+        *cppApiPtr = reinterpret_cast<PyTypeObject **>(PyCapsule_GetPointer(cppApi, 0));
 #else
     // Python 2.6 doesn't have PyCapsule API, so let's keep usign PyCObject on all Python 2.x
     if (PyCObject_Check(cppApi))
-        *cppApiPtr = reinterpret_cast<PyTypeObject**>(PyCObject_AsVoidPtr(cppApi));
+        *cppApiPtr = reinterpret_cast<PyTypeObject **>(PyCObject_AsVoidPtr(cppApi));
 #endif
     return true;
 }
@@ -651,7 +651,7 @@ bool BaseAccumulatorVisitor::visit(SbkObjectType *node)
 bool GetIndexVisitor::visit(SbkObjectType *node)
 {
     m_index++;
-    return PyType_IsSubtype(reinterpret_cast<PyTypeObject*>(node), m_desiredType);
+    return PyType_IsSubtype(reinterpret_cast<PyTypeObject *>(node), m_desiredType);
 }
 
 bool DtorAccumulatorVisitor::visit(SbkObjectType *node)
@@ -709,27 +709,27 @@ public:
 
     bool visit(SbkObjectType *node) override
     {
-        return reinterpret_cast<PyTypeObject*>(node) == m_typeToFind;
+        return reinterpret_cast<PyTypeObject *>(node) == m_typeToFind;
     }
 
 private:
     PyTypeObject *m_typeToFind;
 };
 
-std::vector<SbkObject *> splitPyObject(PyObject* pyObj)
+std::vector<SbkObject *> splitPyObject(PyObject *pyObj)
 {
     std::vector<SbkObject *> result;
     if (PySequence_Check(pyObj)) {
         AutoDecRef lst(PySequence_Fast(pyObj, "Invalid keep reference object."));
         if (!lst.isNull()) {
             for (Py_ssize_t i = 0, i_max = PySequence_Fast_GET_SIZE(lst.object()); i < i_max; ++i) {
-                PyObject* item = PySequence_Fast_GET_ITEM(lst.object(), i);
+                PyObject *item = PySequence_Fast_GET_ITEM(lst.object(), i);
                 if (Object::checkType(item))
-                    result.push_back(reinterpret_cast<SbkObject*>(item));
+                    result.push_back(reinterpret_cast<SbkObject *>(item));
             }
         }
     } else {
-        result.push_back(reinterpret_cast<SbkObject*>(pyObj));
+        result.push_back(reinterpret_cast<SbkObject *>(pyObj));
     }
     return result;
 }
@@ -744,17 +744,17 @@ inline void decRefPyObjectList(Iterator i1, Iterator i2)
 namespace ObjectType
 {
 
-bool checkType(PyTypeObject* type)
+bool checkType(PyTypeObject *type)
 {
-    return PyType_IsSubtype(type, reinterpret_cast<PyTypeObject*>(SbkObject_TypeF())) != 0;
+    return PyType_IsSubtype(type, reinterpret_cast<PyTypeObject *>(SbkObject_TypeF())) != 0;
 }
 
-bool isUserType(PyTypeObject* type)
+bool isUserType(PyTypeObject *type)
 {
     return checkType(type) && PepType_SOTP(type)->is_user_type;
 }
 
-bool canCallConstructor(PyTypeObject* myType, PyTypeObject* ctorType)
+bool canCallConstructor(PyTypeObject *myType, PyTypeObject *ctorType)
 {
     FindBaseTypeVisitor visitor(ctorType);
     if (!walkThroughClassHierarchy(myType, &visitor)) {
@@ -764,23 +764,23 @@ bool canCallConstructor(PyTypeObject* myType, PyTypeObject* ctorType)
     return true;
 }
 
-bool hasCast(SbkObjectType* type)
+bool hasCast(SbkObjectType *type)
 {
     return PepType_SOTP(type)->mi_specialcast != 0;
 }
 
-void* cast(SbkObjectType* sourceType, SbkObject* obj, PyTypeObject* targetType)
+void *cast(SbkObjectType *sourceType, SbkObject *obj, PyTypeObject *targetType)
 {
     return PepType_SOTP(sourceType)->mi_specialcast(Object::cppPointer(obj, targetType),
-        reinterpret_cast<SbkObjectType*>(targetType));
+        reinterpret_cast<SbkObjectType *>(targetType));
 }
 
-void setCastFunction(SbkObjectType* type, SpecialCastFunction func)
+void setCastFunction(SbkObjectType *type, SpecialCastFunction func)
 {
     PepType_SOTP(type)->mi_specialcast = func;
 }
 
-void setOriginalName(SbkObjectType* type, const char* name)
+void setOriginalName(SbkObjectType *type, const char *name)
 {
     SbkObjectTypePrivate *sotp = PepType_SOTP(type);
     if (sotp->original_name)
@@ -788,12 +788,12 @@ void setOriginalName(SbkObjectType* type, const char* name)
     sotp->original_name = strdup(name);
 }
 
-const char* getOriginalName(SbkObjectType* type)
+const char *getOriginalName(SbkObjectType *type)
 {
     return PepType_SOTP(type)->original_name;
 }
 
-void setTypeDiscoveryFunctionV2(SbkObjectType* type, TypeDiscoveryFuncV2 func)
+void setTypeDiscoveryFunctionV2(SbkObjectType *type, TypeDiscoveryFuncV2 func)
 {
     PepType_SOTP(type)->type_discovery = func;
 }
@@ -805,7 +805,7 @@ void copyMultipleInheritance(SbkObjectType *type, SbkObjectType *other)
     PepType_SOTP(type)->mi_specialcast = PepType_SOTP(other)->mi_specialcast;
 }
 
-void setMultipleInheritanceFunction(SbkObjectType* type, MultipleInheritanceInitFunction function)
+void setMultipleInheritanceFunction(SbkObjectType *type, MultipleInheritanceInitFunction function)
 {
     PepType_SOTP(type)->mi_init = function;
 }
@@ -815,12 +815,12 @@ MultipleInheritanceInitFunction getMultipleInheritanceFunction(SbkObjectType *ty
     return PepType_SOTP(type)->mi_init;
 }
 
-void setDestructorFunction(SbkObjectType* type, ObjectDestructor func)
+void setDestructorFunction(SbkObjectType *type, ObjectDestructor func)
 {
     PepType_SOTP(type)->cpp_dtor = func;
 }
 
-void initPrivateData(SbkObjectType* type)
+void initPrivateData(SbkObjectType *type)
 {
     PepType_SOTP(type) = new SbkObjectTypePrivate;
     memset(PepType_SOTP(type), 0, sizeof(SbkObjectTypePrivate));
@@ -872,17 +872,17 @@ introduceWrapperType(PyObject *enclosingObject,
     return PyModule_AddObject(enclosingObject, typeName, ob_type) == 0 ? type : nullptr;
 }
 
-void setSubTypeInitHook(SbkObjectType* type, SubTypeInitHook func)
+void setSubTypeInitHook(SbkObjectType *type, SubTypeInitHook func)
 {
     PepType_SOTP(type)->subtype_init = func;
 }
 
-void* getTypeUserData(SbkObjectType* type)
+void *getTypeUserData(SbkObjectType *type)
 {
     return PepType_SOTP(type)->user_data;
 }
 
-void setTypeUserData(SbkObjectType* type, void* userData, DeleteUserDataFunc d_func)
+void setTypeUserData(SbkObjectType *type, void *userData, DeleteUserDataFunc d_func)
 {
     SbkObjectTypePrivate *sotp = PepType_SOTP(type);
     sotp->user_data = userData;
@@ -895,7 +895,7 @@ SbkObjectType *typeForTypeName(const char *typeName)
     SbkObjectType *result{};
     if (typeName) {
         if (PyTypeObject *pyType = Shiboken::Conversions::getPythonTypeObject(typeName))
-            result = reinterpret_cast<SbkObjectType*>(pyType);
+            result = reinterpret_cast<SbkObjectType *>(pyType);
     }
     return result;
 }
@@ -912,25 +912,25 @@ bool hasSpecialCastFunction(SbkObjectType *sbkType)
 namespace Object
 {
 
-static void recursive_invalidate(SbkObject* self, std::set<SbkObject*>& seen);
+static void recursive_invalidate(SbkObject *self, std::set<SbkObject *>& seen);
 
-bool checkType(PyObject* pyObj)
+bool checkType(PyObject *pyObj)
 {
     return ObjectType::checkType(Py_TYPE(pyObj));
 }
 
-bool isUserType(PyObject* pyObj)
+bool isUserType(PyObject *pyObj)
 {
     return ObjectType::isUserType(Py_TYPE(pyObj));
 }
 
-Py_hash_t hash(PyObject* pyObj)
+Py_hash_t hash(PyObject *pyObj)
 {
     assert(Shiboken::Object::checkType(pyObj));
     return reinterpret_cast<Py_hash_t>(pyObj);
 }
 
-static void setSequenceOwnership(PyObject* pyObj, bool owner)
+static void setSequenceOwnership(PyObject *pyObj, bool owner)
 {
 
     bool has_length = true;
@@ -957,36 +957,36 @@ static void setSequenceOwnership(PyObject* pyObj, bool owner)
         }
     } else if (Object::checkType(pyObj)) {
         if (owner)
-            getOwnership(reinterpret_cast<SbkObject*>(pyObj));
+            getOwnership(reinterpret_cast<SbkObject *>(pyObj));
         else
-            releaseOwnership(reinterpret_cast<SbkObject*>(pyObj));
+            releaseOwnership(reinterpret_cast<SbkObject *>(pyObj));
     }
 }
 
-void setValidCpp(SbkObject* pyObj, bool value)
+void setValidCpp(SbkObject *pyObj, bool value)
 {
     pyObj->d->validCppObject = value;
 }
 
-void setHasCppWrapper(SbkObject* pyObj, bool value)
+void setHasCppWrapper(SbkObject *pyObj, bool value)
 {
     pyObj->d->containsCppWrapper = value;
 }
 
-bool hasCppWrapper(SbkObject* pyObj)
+bool hasCppWrapper(SbkObject *pyObj)
 {
     return pyObj->d->containsCppWrapper;
 }
 
-bool wasCreatedByPython(SbkObject* pyObj)
+bool wasCreatedByPython(SbkObject *pyObj)
 {
     return pyObj->d->cppObjectCreated;
 }
 
-void callCppDestructors(SbkObject* pyObj)
+void callCppDestructors(SbkObject *pyObj)
 {
     PyTypeObject *type = Py_TYPE(pyObj);
-    SbkObjectTypePrivate * sotp = PepType_SOTP(type);
+    SbkObjectTypePrivate *sotp = PepType_SOTP(type);
     if (sotp->is_multicpp) {
         Shiboken::DtorAccumulatorVisitor visitor(pyObj);
         Shiboken::walkThroughClassHierarchy(type, &visitor);
@@ -1011,12 +1011,12 @@ void callCppDestructors(SbkObject* pyObj)
     pyObj->d->validCppObject = false;
 }
 
-bool hasOwnership(SbkObject* pyObj)
+bool hasOwnership(SbkObject *pyObj)
 {
     return pyObj->d->hasOwnership;
 }
 
-void getOwnership(SbkObject* self)
+void getOwnership(SbkObject *self)
 {
     // skip if already have the ownership
     if (self->d->hasOwnership)
@@ -1035,16 +1035,16 @@ void getOwnership(SbkObject* self)
         makeValid(self); // Make the object valid again
 }
 
-void getOwnership(PyObject* pyObj)
+void getOwnership(PyObject *pyObj)
 {
     if (pyObj)
         setSequenceOwnership(pyObj, true);
 }
 
-void releaseOwnership(SbkObject* self)
+void releaseOwnership(SbkObject *self)
 {
     // skip if the ownership have already moved to c++
-    SbkObjectType* selfType = reinterpret_cast<SbkObjectType*>(Py_TYPE(self));
+    SbkObjectType *selfType = reinterpret_cast<SbkObjectType *>(Py_TYPE(self));
     if (!self->d->hasOwnership || Shiboken::Conversions::pythonTypeIsValueType(PepType_SOTP(selfType)->converter))
         return;
 
@@ -1058,35 +1058,35 @@ void releaseOwnership(SbkObject* self)
         invalidate(self); // If I do not know when this object will die We need to invalidate this to avoid use after
 }
 
-void releaseOwnership(PyObject* self)
+void releaseOwnership(PyObject *self)
 {
     setSequenceOwnership(self, false);
 }
 
 /* Needed forward declarations */
-static void recursive_invalidate(PyObject* pyobj, std::set<SbkObject*>& seen);
-static void recursive_invalidate(SbkObject* self, std::set<SbkObject*>& seen);
+static void recursive_invalidate(PyObject *pyobj, std::set<SbkObject *>& seen);
+static void recursive_invalidate(SbkObject *self, std::set<SbkObject *> &seen);
 
-void invalidate(PyObject* pyobj)
+void invalidate(PyObject *pyobj)
 {
-    std::set<SbkObject*> seen;
+    std::set<SbkObject *> seen;
     recursive_invalidate(pyobj, seen);
 }
 
-void invalidate(SbkObject* self)
+void invalidate(SbkObject *self)
 {
-    std::set<SbkObject*> seen;
+    std::set<SbkObject *> seen;
     recursive_invalidate(self, seen);
 }
 
-static void recursive_invalidate(PyObject* pyobj, std::set<SbkObject*>& seen)
+static void recursive_invalidate(PyObject *pyobj, std::set<SbkObject *> &seen)
 {
     const auto objs = splitPyObject(pyobj);
     for (SbkObject *o : objs)
         recursive_invalidate(o, seen);
 }
 
-static void recursive_invalidate(SbkObject* self, std::set<SbkObject*>& seen)
+static void recursive_invalidate(SbkObject *self, std::set<SbkObject *> &seen)
 {
     // Skip if this object not is a valid object or if it's already been seen
     if (!self || reinterpret_cast<PyObject *>(self) == Py_None || seen.find(self) != seen.end())
@@ -1115,13 +1115,13 @@ static void recursive_invalidate(SbkObject* self, std::set<SbkObject*>& seen)
 
     // If has ref to other objects invalidate all
     if (self->d->referredObjects) {
-        RefCountMap& refCountMap = *(self->d->referredObjects);
+        RefCountMap &refCountMap = *(self->d->referredObjects);
         for (auto it = refCountMap.begin(), end = refCountMap.end(); it != end; ++it)
             recursive_invalidate(it->second, seen);
     }
 }
 
-void makeValid(SbkObject* self)
+void makeValid(SbkObject *self)
 {
     // Skip if this object not is a valid object
     if (!self || reinterpret_cast<PyObject *>(self) == Py_None || self->d->validCppObject)
@@ -1138,7 +1138,7 @@ void makeValid(SbkObject* self)
 
     // If has ref to other objects make all valid again
     if (self->d->referredObjects) {
-        RefCountMap& refCountMap = *(self->d->referredObjects);
+        RefCountMap &refCountMap = *(self->d->referredObjects);
         RefCountMap::iterator iter;
         for (auto it = refCountMap.begin(), end = refCountMap.end(); it != end; ++it) {
             if (Shiboken::Object::checkType(it->second))
@@ -1147,28 +1147,28 @@ void makeValid(SbkObject* self)
     }
 }
 
-void* cppPointer(SbkObject* pyObj, PyTypeObject* desiredType)
+void *cppPointer(SbkObject *pyObj, PyTypeObject *desiredType)
 {
-    PyTypeObject* type = Py_TYPE(pyObj);
+    PyTypeObject *type = Py_TYPE(pyObj);
     int idx = 0;
-    if (PepType_SOTP(reinterpret_cast<SbkObjectType*>(type))->is_multicpp)
+    if (PepType_SOTP(reinterpret_cast<SbkObjectType *>(type))->is_multicpp)
         idx = getTypeIndexOnHierarchy(type, desiredType);
     if (pyObj->d->cptr)
         return pyObj->d->cptr[idx];
     return 0;
 }
 
-std::vector<void*> cppPointers(SbkObject* pyObj)
+std::vector<void *> cppPointers(SbkObject *pyObj)
 {
     int n = getNumberOfCppBaseClasses(Py_TYPE(pyObj));
-    std::vector<void*> ptrs(n);
+    std::vector<void *> ptrs(n);
     for (int i = 0; i < n; ++i)
         ptrs[i] = pyObj->d->cptr[i];
     return ptrs;
 }
 
 
-bool setCppPointer(SbkObject* sbkObj, PyTypeObject* desiredType, void* cptr)
+bool setCppPointer(SbkObject *sbkObj, PyTypeObject *desiredType, void *cptr)
 {
     int idx = 0;
     PyTypeObject *type = Py_TYPE(sbkObj);
@@ -1185,14 +1185,14 @@ bool setCppPointer(SbkObject* sbkObj, PyTypeObject* desiredType, void* cptr)
     return !alreadyInitialized;
 }
 
-bool isValid(PyObject* pyObj)
+bool isValid(PyObject *pyObj)
 {
     if (!pyObj || pyObj == Py_None
         || Py_TYPE(Py_TYPE(pyObj)) != SbkObjectType_TypeF()) {
         return true;
     }
 
-    SbkObjectPrivate* priv = reinterpret_cast<SbkObject*>(pyObj)->d;
+    auto priv = reinterpret_cast<SbkObject *>(pyObj)->d;
 
     if (!priv->cppObjectCreated && isUserType(pyObj)) {
         PyErr_Format(PyExc_RuntimeError, "'__init__' method of object's base class (%s) not called.",
@@ -1209,13 +1209,13 @@ bool isValid(PyObject* pyObj)
     return true;
 }
 
-bool isValid(SbkObject* pyObj, bool throwPyError)
+bool isValid(SbkObject *pyObj, bool throwPyError)
 {
     if (!pyObj)
         return false;
 
-    SbkObjectPrivate* priv = pyObj->d;
-    if (!priv->cppObjectCreated && isUserType(reinterpret_cast<PyObject*>(pyObj))) {
+    SbkObjectPrivate *priv = pyObj->d;
+    if (!priv->cppObjectCreated && isUserType(reinterpret_cast<PyObject *>(pyObj))) {
         if (throwPyError)
             PyErr_Format(PyExc_RuntimeError, "Base constructor of the object (%s) not called.",
                          Py_TYPE(pyObj)->tp_name);
@@ -1232,13 +1232,13 @@ bool isValid(SbkObject* pyObj, bool throwPyError)
     return true;
 }
 
-bool isValid(PyObject* pyObj, bool throwPyError)
+bool isValid(PyObject *pyObj, bool throwPyError)
 {
     if (!pyObj || pyObj == Py_None ||
-        !PyType_IsSubtype(Py_TYPE(pyObj), reinterpret_cast<PyTypeObject*>(SbkObject_TypeF()))) {
+        !PyType_IsSubtype(Py_TYPE(pyObj), reinterpret_cast<PyTypeObject *>(SbkObject_TypeF()))) {
         return true;
     }
-    return isValid(reinterpret_cast<SbkObject*>(pyObj), throwPyError);
+    return isValid(reinterpret_cast<SbkObject *>(pyObj), throwPyError);
 }
 
 SbkObject *findColocatedChild(SbkObject *wrapper,
@@ -1251,11 +1251,11 @@ SbkObject *findColocatedChild(SbkObject *wrapper,
     if (!(wrapper->d && wrapper->d->cptr))
         return 0;
 
-    ParentInfo* pInfo = wrapper->d->parentInfo;
+    ParentInfo *pInfo = wrapper->d->parentInfo;
     if (!pInfo)
         return 0;
 
-    ChildrenList& children = pInfo->children;
+    ChildrenList &children = pInfo->children;
 
     for (SbkObject *child : children) {
         if (!(child->d && child->d->cptr))
@@ -1270,11 +1270,11 @@ SbkObject *findColocatedChild(SbkObject *wrapper,
     return 0;
 }
 
-PyObject *newObject(SbkObjectType* instanceType,
-                    void* cptr,
+PyObject *newObject(SbkObjectType *instanceType,
+                    void *cptr,
                     bool hasOwnership,
                     bool isExactType,
-                    const char* typeName)
+                    const char *typeName)
 {
     // Try to find the exact type of cptr.
     if (!isExactType) {
@@ -1286,11 +1286,11 @@ PyObject *newObject(SbkObjectType* instanceType,
 
     bool shouldCreate = true;
     bool shouldRegister = true;
-    SbkObject* self = 0;
+    SbkObject *self = 0;
 
     // Some logic to ensure that colocated child field does not overwrite the parent
     if (BindingManager::instance().hasWrapper(cptr)) {
-        SbkObject* existingWrapper = BindingManager::instance().retrieveWrapper(cptr);
+        SbkObject *existingWrapper = BindingManager::instance().retrieveWrapper(cptr);
 
         self = findColocatedChild(existingWrapper, instanceType);
         if (self) {
@@ -1313,7 +1313,7 @@ PyObject *newObject(SbkObjectType* instanceType,
     }
 
     if (shouldCreate) {
-        self = reinterpret_cast<SbkObject*>(SbkObjectTpNew(reinterpret_cast<PyTypeObject*>(instanceType), 0, 0));
+        self = reinterpret_cast<SbkObject *>(SbkObjectTpNew(reinterpret_cast<PyTypeObject *>(instanceType), 0, 0));
         self->d->cptr[0] = cptr;
         self->d->hasOwnership = hasOwnership;
         self->d->validCppObject = 1;
@@ -1321,17 +1321,17 @@ PyObject *newObject(SbkObjectType* instanceType,
             BindingManager::instance().registerWrapper(self, cptr);
         }
     } else {
-        Py_IncRef(reinterpret_cast<PyObject*>(self));
+        Py_IncRef(reinterpret_cast<PyObject *>(self));
     }
-    return reinterpret_cast<PyObject*>(self);
+    return reinterpret_cast<PyObject *>(self);
 }
 
-void destroy(SbkObject* self)
+void destroy(SbkObject *self)
 {
     destroy(self, 0);
 }
 
-void destroy(SbkObject* self, void* cppData)
+void destroy(SbkObject *self, void *cppData)
 {
     // Skip if this is called with NULL pointer this can happen in derived classes
     if (!self)
@@ -1375,9 +1375,9 @@ void destroy(SbkObject* self, void* cppData)
     // After this point the object can be death do not use the self pointer bellow
 }
 
-void removeParent(SbkObject* child, bool giveOwnershipBack, bool keepReference)
+void removeParent(SbkObject *child, bool giveOwnershipBack, bool keepReference)
 {
-    ParentInfo* pInfo = child->d->parentInfo;
+    ParentInfo *pInfo = child->d->parentInfo;
     if (!pInfo || !pInfo->parent) {
         if (pInfo && pInfo->hasWrapperRef) {
             pInfo->hasWrapperRef = false;
@@ -1385,7 +1385,7 @@ void removeParent(SbkObject* child, bool giveOwnershipBack, bool keepReference)
         return;
     }
 
-    ChildrenList& oldBrothers = pInfo->parent->d->parentInfo->children;
+    ChildrenList &oldBrothers = pInfo->parent->d->parentInfo->children;
     // Verify if this child is part of parent list
     auto iChild = oldBrothers.find(child);
     if (iChild == oldBrothers.end())
@@ -1413,18 +1413,18 @@ void removeParent(SbkObject* child, bool giveOwnershipBack, bool keepReference)
     Py_DECREF(child);
 }
 
-void setParent(PyObject* parent, PyObject* child)
+void setParent(PyObject *parent, PyObject *child)
 {
     if (!child || child == Py_None || child == parent)
         return;
 
     /*
-     *  setParent is recursive when the child is a native Python sequence, i.e. objects not binded by Shiboken
-     *  like tuple and list.
+     * setParent is recursive when the child is a native Python sequence, i.e. objects not binded by Shiboken
+     * like tuple and list.
      *
-     *  This "limitation" exists to fix the following problem: A class multiple inherits QObject and QString,
-     *  so if you pass this class to someone that takes the ownership, we CAN'T enter in this if, but hey! QString
-     *  follows the sequence protocol.
+     * This "limitation" exists to fix the following problem: A class multiple inherits QObject and QString,
+     * so if you pass this class to someone that takes the ownership, we CAN'T enter in this if, but hey! QString
+     * follows the sequence protocol.
      */
     if (PySequence_Check(child) && !Object::checkType(child)) {
         Shiboken::AutoDecRef seq(PySequence_Fast(child, 0));
@@ -1434,8 +1434,8 @@ void setParent(PyObject* parent, PyObject* child)
     }
 
     bool parentIsNull = !parent || parent == Py_None;
-    SbkObject* parent_ = reinterpret_cast<SbkObject*>(parent);
-    SbkObject* child_ = reinterpret_cast<SbkObject*>(child);
+    auto parent_ = reinterpret_cast<SbkObject *>(parent);
+    auto child_ = reinterpret_cast<SbkObject *>(child);
 
     if (!parentIsNull) {
         if (!parent_->d->parentInfo)
@@ -1446,7 +1446,7 @@ void setParent(PyObject* parent, PyObject* child)
             return;
     }
 
-    ParentInfo* pInfo = child_->d->parentInfo;
+    ParentInfo *pInfo = child_->d->parentInfo;
     bool hasAnotherParent = pInfo && pInfo->parent && pInfo->parent != parent_;
 
     //Avoid destroy child during reparent operation
@@ -1476,7 +1476,7 @@ void setParent(PyObject* parent, PyObject* child)
     Py_DECREF(child);
 }
 
-void deallocData(SbkObject* self, bool cleanup)
+void deallocData(SbkObject *self, bool cleanup)
 {
     // Make cleanup if this is not a wrapper otherwise this will be done on wrapper destructor
     if(cleanup) {
@@ -1499,11 +1499,11 @@ void deallocData(SbkObject* self, bool cleanup)
     Py_XDECREF(self->ob_dict);
 
     // PYSIDE-571: qApp is no longer allocated.
-    if (PyObject_IS_GC(reinterpret_cast<PyObject*>(self)))
+    if (PyObject_IS_GC(reinterpret_cast<PyObject *>(self)))
         Py_TYPE(self)->tp_free(self);
 }
 
-void setTypeUserData(SbkObject* wrapper, void* userData, DeleteUserDataFunc d_func)
+void setTypeUserData(SbkObject *wrapper, void *userData, DeleteUserDataFunc d_func)
 {
     SbkObjectTypePrivate *sotp = PepType_SOTP(Py_TYPE(wrapper));
     if (sotp->user_data)
@@ -1513,7 +1513,7 @@ void setTypeUserData(SbkObject* wrapper, void* userData, DeleteUserDataFunc d_fu
     sotp->user_data = userData;
 }
 
-void* getTypeUserData(SbkObject* wrapper)
+void *getTypeUserData(SbkObject *wrapper)
 {
     return PepType_SOTP(Py_TYPE(wrapper))->user_data;
 }
@@ -1523,7 +1523,7 @@ static inline bool isNone(const PyObject *o)
     return o == nullptr || o == Py_None;
 }
 
-static void removeRefCountKey(SbkObject* self, const char *key)
+static void removeRefCountKey(SbkObject *self, const char *key)
 {
     if (self->d->referredObjects) {
         const auto iterPair = self->d->referredObjects->equal_range(key);
@@ -1534,7 +1534,7 @@ static void removeRefCountKey(SbkObject* self, const char *key)
     }
 }
 
-void keepReference(SbkObject* self, const char* key, PyObject* referredObject, bool append)
+void keepReference(SbkObject *self, const char *key, PyObject *referredObject, bool append)
 {
     if (isNone(referredObject)) {
         removeRefCountKey(self, key);
@@ -1548,7 +1548,7 @@ void keepReference(SbkObject* self, const char* key, PyObject* referredObject, b
         return;
     }
 
-    RefCountMap& refCountMap = *(self->d->referredObjects);
+    RefCountMap &refCountMap = *(self->d->referredObjects);
     const auto iterPair = refCountMap.equal_range(key);
     if (std::any_of(iterPair.first, iterPair.second,
                     [referredObject](const RefCountMap::value_type &v) { return v.second == referredObject; })) {
@@ -1564,24 +1564,24 @@ void keepReference(SbkObject* self, const char* key, PyObject* referredObject, b
     Py_INCREF(referredObject);
 }
 
-void removeReference(SbkObject* self, const char* key, PyObject* referredObject)
+void removeReference(SbkObject *self, const char *key, PyObject *referredObject)
 {
     if (!isNone(referredObject))
         removeRefCountKey(self, key);
 }
 
-void clearReferences(SbkObject* self)
+void clearReferences(SbkObject *self)
 {
     if (!self->d->referredObjects)
         return;
 
-    RefCountMap& refCountMap = *(self->d->referredObjects);
+    RefCountMap &refCountMap = *(self->d->referredObjects);
     for (auto it = refCountMap.begin(), end = refCountMap.end(); it != end; ++it)
         Py_DECREF(it->second);
     self->d->referredObjects->clear();
 }
 
-std::string info(SbkObject* self)
+std::string info(SbkObject *self)
 {
     std::ostringstream s;
 
@@ -1590,7 +1590,7 @@ std::string info(SbkObject* self)
         if (ObjectType::isUserType(Py_TYPE(self)))
             bases = getCppBaseClasses(Py_TYPE(self));
         else
-            bases.push_back(reinterpret_cast<SbkObjectType*>(Py_TYPE(self)));
+            bases.push_back(reinterpret_cast<SbkObjectType *>(Py_TYPE(self)));
 
         s << "C++ address....... ";
         for (size_t i = 0, size = bases.size(); i < size; ++i) {
@@ -1625,7 +1625,7 @@ std::string info(SbkObject* self)
     }
 
     if (self->d->referredObjects && !self->d->referredObjects->empty()) {
-        Shiboken::RefCountMap& map = *self->d->referredObjects;
+        Shiboken::RefCountMap &map = *self->d->referredObjects;
         s << "referred objects.. ";
         std::string lastKey;
         for (auto it = map.begin(), end = map.end(); it != end; ++it) {
diff --git a/sources/shiboken2/libshiboken/basewrapper.h b/sources/shiboken2/libshiboken/basewrapper.h
index 55445b026..7faf223bd 100644
--- a/sources/shiboken2/libshiboken/basewrapper.h
+++ b/sources/shiboken2/libshiboken/basewrapper.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2016 The Qt Company Ltd.
+** Copyright (C) 2019 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of Qt for Python.
@@ -57,41 +57,41 @@ struct LIBSHIBOKEN_API SbkObject
 {
     PyObject_HEAD
     /// Instance dictionary.
-    PyObject* ob_dict;
+    PyObject *ob_dict;
     /// List of weak references
-    PyObject* weakreflist;
-    SbkObjectPrivate* d;
+    PyObject *weakreflist;
+    SbkObjectPrivate *d;
 };
 
 
 /// Dealloc the python object \p pyObj and the C++ object represented by it.
-LIBSHIBOKEN_API void SbkDeallocWrapper(PyObject* pyObj);
-LIBSHIBOKEN_API void SbkDeallocQAppWrapper(PyObject* pyObj);
-LIBSHIBOKEN_API void SbkDeallocWrapperWithPrivateDtor(PyObject* self);
+LIBSHIBOKEN_API void SbkDeallocWrapper(PyObject *pyObj);
+LIBSHIBOKEN_API void SbkDeallocQAppWrapper(PyObject *pyObj);
+LIBSHIBOKEN_API void SbkDeallocWrapperWithPrivateDtor(PyObject *self);
 
 struct SbkObjectType;
 
 /// Function signature for the multiple inheritance information initializers that should be provided by classes with multiple inheritance.
-typedef int* (*MultipleInheritanceInitFunction)(const void*);
+typedef int *(*MultipleInheritanceInitFunction)(const void *);
 
 /**
  *   Special cast function is used to correctly cast an object when it's
  *   part of a multiple inheritance hierarchy.
  *   The implementation of this function is auto generated by the generator and you don't need to care about it.
  */
-typedef void* (*SpecialCastFunction)(void*, SbkObjectType*);
-typedef SbkObjectType* (*TypeDiscoveryFunc)(void*, SbkObjectType*);
-typedef void* (*TypeDiscoveryFuncV2)(void*, SbkObjectType*);
+typedef void *(*SpecialCastFunction)(void *, SbkObjectType *);
+typedef SbkObjectType *(*TypeDiscoveryFunc)(void *, SbkObjectType *);
+typedef void *(*TypeDiscoveryFuncV2)(void *, SbkObjectType *);
 
-typedef void* (*ExtendedToCppFunc)(PyObject*);        // DEPRECATED.
-typedef bool (*ExtendedIsConvertibleFunc)(PyObject*); // DEPRECATED.
+typedef void *(*ExtendedToCppFunc)(PyObject *);        // DEPRECATED.
+typedef bool (*ExtendedIsConvertibleFunc)(PyObject *); // DEPRECATED.
 
 // Used in userdata dealloc function
-typedef void (*DeleteUserDataFunc)(void*);
+typedef void (*DeleteUserDataFunc)(void *);
 
-typedef void (*ObjectDestructor)(void*);
+typedef void (*ObjectDestructor)(void *);
 
-typedef void (*SubTypeInitHook)(SbkObjectType*, PyObject*, PyObject*);
+typedef void (*SubTypeInitHook)(SbkObjectType *, PyObject *, PyObject *);
 
 extern LIBSHIBOKEN_API PyTypeObject *SbkObjectType_TypeF(void);
 extern LIBSHIBOKEN_API SbkObjectType *SbkObject_TypeF(void);
@@ -104,9 +104,9 @@ struct LIBSHIBOKEN_API SbkObjectType
     PyTypeObject type;
 };
 
-LIBSHIBOKEN_API PyObject* SbkObjectTpNew(PyTypeObject* subtype, PyObject*, PyObject*);
+LIBSHIBOKEN_API PyObject *SbkObjectTpNew(PyTypeObject *subtype, PyObject *, PyObject *);
 // the special case of a switchable singleton
-LIBSHIBOKEN_API PyObject* SbkQAppTpNew(PyTypeObject *subtype, PyObject *args, PyObject *kwds);
+LIBSHIBOKEN_API PyObject *SbkQAppTpNew(PyTypeObject *subtype, PyObject *args, PyObject *kwds);
 
 /**
  *  PYSIDE-832: Use object_dealloc instead of nullptr.
@@ -132,36 +132,36 @@ LIBSHIBOKEN_API void init();
 
 /// Delete the class T allocated on \p cptr.
 template<typename T>
-void callCppDestructor(void* cptr)
+void callCppDestructor(void *cptr)
 {
-    delete reinterpret_cast<T*>(cptr);
+    delete reinterpret_cast<T *>(cptr);
 }
 
 /**
  *  Shiboken::importModule is DEPRECATED. Use Shiboken::Module::import() instead.
  */
-SBK_DEPRECATED(LIBSHIBOKEN_API bool importModule(const char* moduleName, PyTypeObject*** cppApiPtr));
+SBK_DEPRECATED(LIBSHIBOKEN_API bool importModule(const char *moduleName, PyTypeObject *** cppApiPtr));
 
 // setErrorAboutWrongArguments now gets overload info from the signature module.
-LIBSHIBOKEN_API void        setErrorAboutWrongArguments(PyObject* args, const char* funcName);
+LIBSHIBOKEN_API void setErrorAboutWrongArguments(PyObject *args, const char *funcName);
 
 namespace ObjectType {
 
 /**
 *   Returns true if the object is an instance of a type created by the Shiboken generator.
 */
-LIBSHIBOKEN_API bool        checkType(PyTypeObject* pyObj);
+LIBSHIBOKEN_API bool checkType(PyTypeObject *pyObj);
 
 /**
 *   Returns true if this object is an instance of an user defined type derived from an Shiboken type.
 */
-LIBSHIBOKEN_API bool        isUserType(PyTypeObject* pyObj);
+LIBSHIBOKEN_API bool isUserType(PyTypeObject *pyObj);
 
 /**
 *   Returns true if the constructor of \p ctorType can be called for a instance of type \p myType.
 *   \note This function set a python error when returning false.
 */
-LIBSHIBOKEN_API bool        canCallConstructor(PyTypeObject* myType, PyTypeObject* ctorType);
+LIBSHIBOKEN_API bool canCallConstructor(PyTypeObject *myType, PyTypeObject *ctorType);
 
 /**
  *  Tells if the \p type represents an object of a class with multiple inheritance in C++.
@@ -170,27 +170,27 @@ LIBSHIBOKEN_API bool        canCallConstructor(PyTypeObject* myType, PyTypeObjec
  *  \returns    true if a call to ObjectType::cast() is needed to obtain the correct
  *              C++ pointer for Python objects of type \p type.
  */
-LIBSHIBOKEN_API bool        hasCast(SbkObjectType* type);
+LIBSHIBOKEN_API bool hasCast(SbkObjectType *type);
 /**
  *  Cast the C++ pointer held by a Python object \p obj of type \p sourceType,
  *  to a C++ pointer of a C++ class indicated by type \p targetType.
  *  \returns    The cast C++ pointer.
  */
-LIBSHIBOKEN_API void*       cast(SbkObjectType* sourceType, SbkObject* obj, PyTypeObject* targetType);
+LIBSHIBOKEN_API void *cast(SbkObjectType *sourceType, SbkObject *obj, PyTypeObject *targetType);
 /// Set the C++ cast function for \p type.
-LIBSHIBOKEN_API void        setCastFunction(SbkObjectType* type, SpecialCastFunction func);
+LIBSHIBOKEN_API void setCastFunction(SbkObjectType *type, SpecialCastFunction func);
 
-LIBSHIBOKEN_API void        setOriginalName(SbkObjectType* self, const char* name);
-LIBSHIBOKEN_API const char* getOriginalName(SbkObjectType* self);
+LIBSHIBOKEN_API void setOriginalName(SbkObjectType *self, const char *name);
+LIBSHIBOKEN_API const char *getOriginalName(SbkObjectType *self);
 
-LIBSHIBOKEN_API void setTypeDiscoveryFunctionV2(SbkObjectType* self, TypeDiscoveryFuncV2 func);
-LIBSHIBOKEN_API void        copyMultipleInheritance(SbkObjectType *self, SbkObjectType *other);
-LIBSHIBOKEN_API void        setMultipleInheritanceFunction(SbkObjectType* self, MultipleInheritanceInitFunction func);
+LIBSHIBOKEN_API void setTypeDiscoveryFunctionV2(SbkObjectType *self, TypeDiscoveryFuncV2 func);
+LIBSHIBOKEN_API void copyMultipleInheritance(SbkObjectType *self, SbkObjectType *other);
+LIBSHIBOKEN_API void setMultipleInheritanceFunction(SbkObjectType *self, MultipleInheritanceInitFunction func);
 LIBSHIBOKEN_API MultipleInheritanceInitFunction getMultipleInheritanceFunction(SbkObjectType *self);
 
-LIBSHIBOKEN_API void        setDestructorFunction(SbkObjectType* self, ObjectDestructor func);
+LIBSHIBOKEN_API void setDestructorFunction(SbkObjectType *self, ObjectDestructor func);
 
-LIBSHIBOKEN_API void        initPrivateData(SbkObjectType* self);
+LIBSHIBOKEN_API void initPrivateData(SbkObjectType *self);
 
 enum WrapperFlags
 {
@@ -232,13 +232,13 @@ LIBSHIBOKEN_API SbkObjectType *introduceWrapperType(PyObject *enclosingObject,
  *  The hook gets 3 params, they are: The new type being created, args and kwds. The last two are the very
  *  same got from tp_new.
  */
-LIBSHIBOKEN_API void        setSubTypeInitHook(SbkObjectType* self, SubTypeInitHook func);
+LIBSHIBOKEN_API void setSubTypeInitHook(SbkObjectType *self, SubTypeInitHook func);
 
 /**
  *  Get the user data previously set by Shiboken::Object::setTypeUserData
  */
-LIBSHIBOKEN_API void*       getTypeUserData(SbkObjectType* self);
-LIBSHIBOKEN_API void        setTypeUserData(SbkObjectType* self, void* userData, DeleteUserDataFunc d_func);
+LIBSHIBOKEN_API void *getTypeUserData(SbkObjectType *self);
+LIBSHIBOKEN_API void setTypeUserData(SbkObjectType *self, void *userData, DeleteUserDataFunc d_func);
 
 /**
  * Return an instance of SbkObjectType for a C++ type name as determined by
@@ -261,23 +261,23 @@ namespace Object {
 /**
  *  Returns a string with information about the internal state of the instance object, useful for debug purposes.
  */
-LIBSHIBOKEN_API std::string info(SbkObject* self);
+LIBSHIBOKEN_API std::string info(SbkObject *self);
 
 /**
 *   Returns true if the object is an instance of a type created by the Shiboken generator.
 */
-LIBSHIBOKEN_API bool        checkType(PyObject* pyObj);
+LIBSHIBOKEN_API bool checkType(PyObject *pyObj);
 
 /**
  *  Returns true if this object type is an instance of an user defined type derived from an Shiboken type.
  *  \see Shiboken::ObjectType::isUserType
  */
-LIBSHIBOKEN_API bool        isUserType(PyObject* pyObj);
+LIBSHIBOKEN_API bool isUserType(PyObject *pyObj);
 
 /**
  *  Generic function used to make ObjectType hashable, the C++ pointer is used as hash value.
  */
-LIBSHIBOKEN_API Py_hash_t   hash(PyObject* pyObj);
+LIBSHIBOKEN_API Py_hash_t hash(PyObject *pyObj);
 
 /**
  * Find a child of given wrapper having same address having the specified type.
@@ -294,101 +294,101 @@ LIBSHIBOKEN_API SbkObject *findColocatedChild(SbkObject *wrapper,
  *                    and as fallback.
  * \param typeName    If non-null, this will be used as helper to find the correct Python type for this object.
  */
-LIBSHIBOKEN_API PyObject*   newObject(SbkObjectType* instanceType,
-                                      void* cptr,
-                                      bool hasOwnership = true,
-                                      bool isExactType = false,
-                                      const char* typeName = 0);
+LIBSHIBOKEN_API PyObject *newObject(SbkObjectType *instanceType,
+                                    void *cptr,
+                                    bool hasOwnership = true,
+                                    bool isExactType = false,
+                                    const char *typeName = nullptr);
 
 /**
  *  Changes the valid flag of a PyObject, invalid objects will raise an exception when someone tries to access it.
  */
-LIBSHIBOKEN_API void        setValidCpp(SbkObject* pyObj, bool value);
+LIBSHIBOKEN_API void setValidCpp(SbkObject *pyObj, bool value);
 /**
  *  Tells shiboken the Python object \p pyObj has a C++ wrapper used to intercept virtual method calls.
  */
-LIBSHIBOKEN_API void        setHasCppWrapper(SbkObject* pyObj, bool value);
+LIBSHIBOKEN_API void setHasCppWrapper(SbkObject *pyObj, bool value);
 /**
  *  Return true if the Python object \p pyObj has a C++ wrapper used to intercept virtual method calls.
  */
-LIBSHIBOKEN_API bool        hasCppWrapper(SbkObject* pyObj);
+LIBSHIBOKEN_API bool hasCppWrapper(SbkObject *pyObj);
 
 /**
  *  Return true if the Python object was created by Python, false otherwise.
  *  \note This function was added to libshiboken only to be used by shiboken.wasCreatedByPython()
  */
-LIBSHIBOKEN_API bool        wasCreatedByPython(SbkObject* pyObj);
+LIBSHIBOKEN_API bool wasCreatedByPython(SbkObject *pyObj);
 
 /**
  *  Call the C++ object destructor and invalidates the Python object.
  *  \note This function was added to libshiboken only to be used by shiboken.delete()
  */
-LIBSHIBOKEN_API void        callCppDestructors(SbkObject* pyObj);
+LIBSHIBOKEN_API void callCppDestructors(SbkObject *pyObj);
 
 /**
  *  Return true if the Python is responsible for deleting the underlying C++ object.
  */
-LIBSHIBOKEN_API bool        hasOwnership(SbkObject* pyObj);
+LIBSHIBOKEN_API bool hasOwnership(SbkObject *pyObj);
 
 /**
  *  Sets python as responsible to delete the underlying C++ object.
  *  \note You this overload only when the PyObject can be a sequence and you want to
  *  call this function for every item in the sequence.
- *  \see getOwnership(SbkObject*)
+ *  \see getOwnership(SbkObject *)
  */
-LIBSHIBOKEN_API void        getOwnership(PyObject* pyObj);
+LIBSHIBOKEN_API void getOwnership(PyObject *pyObj);
 
 /**
  *  Sets python as responsible to delete the underlying C++ object.
  */
-LIBSHIBOKEN_API void        getOwnership(SbkObject* pyObj);
+LIBSHIBOKEN_API void getOwnership(SbkObject *pyObj);
 
 /**
  *  Release the ownership, so Python will not delete the underlying C++ object.
  *  \note You this overload only when the PyObject can be a sequence and you want to
  *  call this function for every item in the sequence.
- *  \see releaseOwnership(SbkObject*)
+ *  \see releaseOwnership(SbkObject *)
  */
-LIBSHIBOKEN_API void        releaseOwnership(PyObject* pyObj);
+LIBSHIBOKEN_API void releaseOwnership(PyObject *pyObj);
 /**
  *  Release the ownership, so Python will not delete the underlying C++ object.
  */
-LIBSHIBOKEN_API void        releaseOwnership(SbkObject* pyObj);
+LIBSHIBOKEN_API void releaseOwnership(SbkObject *pyObj);
 
 /**
  *   Get the C++ pointer of type \p desiredType from a Python object.
  */
-LIBSHIBOKEN_API void*       cppPointer(SbkObject* pyObj, PyTypeObject* desiredType);
+LIBSHIBOKEN_API void *cppPointer(SbkObject *pyObj, PyTypeObject *desiredType);
 
 /**
  *   Return a list with all C++ pointers held from a Python object.
  *   \note This function was added to libshiboken only to be used by shiboken.getCppPointer()
  */
-LIBSHIBOKEN_API std::vector<void*> cppPointers(SbkObject* pyObj);
+LIBSHIBOKEN_API std::vector<void *>cppPointers(SbkObject *pyObj);
 
 /**
  *   Set the C++ pointer of type \p desiredType of a Python object.
  */
-LIBSHIBOKEN_API bool        setCppPointer(SbkObject* sbkObj, PyTypeObject* desiredType, void* cptr);
+LIBSHIBOKEN_API bool setCppPointer(SbkObject *sbkObj, PyTypeObject *desiredType, void *cptr);
 
 /**
  * Returns false and sets a Python RuntimeError if the Python wrapper is not marked as valid.
  */
-LIBSHIBOKEN_API bool        isValid(PyObject* pyObj);
+LIBSHIBOKEN_API bool isValid(PyObject *pyObj);
 
 /**
  * Returns false if the Python wrapper is not marked as valid.
  * \param pyObj the object.
  * \param throwPyError sets a Python RuntimeError when the object isn't valid.
  */
-LIBSHIBOKEN_API bool        isValid(SbkObject* pyObj, bool throwPyError = true);
+LIBSHIBOKEN_API bool isValid(SbkObject *pyObj, bool throwPyError = true);
 
 /**
  * Returns false if the Python wrapper is not marked as valid.
  * \param pyObj the object.
  * \param throwPyError sets a Python RuntimeError when the object isn't valid.
  */
-LIBSHIBOKEN_API bool        isValid(PyObject* pyObj, bool throwPyError);
+LIBSHIBOKEN_API bool isValid(PyObject *pyObj, bool throwPyError);
 
 /**
 *   Set the parent of \p child to \p parent.
@@ -396,36 +396,36 @@ LIBSHIBOKEN_API bool        isValid(PyObject* pyObj, bool throwPyError);
 *   \param parent the parent object, if null, the child will have no parents.
 *   \param child the child.
 */
-LIBSHIBOKEN_API void        setParent(PyObject* parent, PyObject* child);
+LIBSHIBOKEN_API void setParent(PyObject *parent, PyObject *child);
 
 /**
 *   Remove this child from their parent, if any.
 *   \param child the child.
 */
-LIBSHIBOKEN_API void        removeParent(SbkObject* child, bool giveOwnershipBack = true, bool keepReferenc = false);
+LIBSHIBOKEN_API void removeParent(SbkObject *child, bool giveOwnershipBack = true, bool keepReferenc = false);
 
 /**
  * Mark the object as invalid
  */
-LIBSHIBOKEN_API void        invalidate(SbkObject* self);
+LIBSHIBOKEN_API void invalidate(SbkObject *self);
 
 /**
  * Help function can be used to invalidate a sequence of object
  **/
-LIBSHIBOKEN_API void        invalidate(PyObject* pyobj);
+LIBSHIBOKEN_API void invalidate(PyObject *pyobj);
 
 /**
  * Make the object valid again
  */
-LIBSHIBOKEN_API void        makeValid(SbkObject* self);
+LIBSHIBOKEN_API void makeValid(SbkObject *self);
 
-/// \deprecated Use destroy(SbkObject*, void*)
-SBK_DEPRECATED(LIBSHIBOKEN_API void destroy(SbkObject* self));
+/// \deprecated Use destroy(SbkObject *, void *)
+SBK_DEPRECATED(LIBSHIBOKEN_API void destroy(SbkObject *self));
 
 /**
  * Destroy any data in Shiboken structure and c++ pointer if the pyboject has the ownership
  */
-LIBSHIBOKEN_API void        destroy(SbkObject* self, void* cppData);
+LIBSHIBOKEN_API void destroy(SbkObject *self, void *cppData);
 
 /**
  *  Set user data on type of \p wrapper.
@@ -433,11 +433,11 @@ LIBSHIBOKEN_API void        destroy(SbkObject* self, void* cppData);
  *  \param userData the user data
  *  \param d_func a function used to delete the user data
  */
-LIBSHIBOKEN_API void        setTypeUserData(SbkObject* wrapper, void* userData, DeleteUserDataFunc d_func);
+LIBSHIBOKEN_API void setTypeUserData(SbkObject *wrapper, void *userData, DeleteUserDataFunc d_func);
 /**
  *  Get the user data previously set by Shiboken::Object::setTypeUserData
  */
-LIBSHIBOKEN_API void*       getTypeUserData(SbkObject* wrapper);
+LIBSHIBOKEN_API void *getTypeUserData(SbkObject *wrapper);
 
 /**
  *   Increments the reference count of the referred Python object.
@@ -451,7 +451,7 @@ LIBSHIBOKEN_API void*       getTypeUserData(SbkObject* wrapper);
  *   \param key             a key that identifies the C++ method signature and argument where the referred Object came from.
  *   \param referredObject  the object whose reference is used by the self object.
  */
-LIBSHIBOKEN_API void        keepReference(SbkObject* self, const char* key, PyObject* referredObject, bool append = false);
+LIBSHIBOKEN_API void keepReference(SbkObject *self, const char *key, PyObject *referredObject, bool append = false);
 
 /**
  *   Removes any reference previously added by keepReference function
@@ -459,7 +459,7 @@ LIBSHIBOKEN_API void        keepReference(SbkObject* self, const char* key, PyOb
  *   \param key             a key that identifies the C++ method signature and argument from where the referred Object came.
  *   \param referredObject  the object whose reference is used by the self object.
  */
-LIBSHIBOKEN_API void        removeReference(SbkObject* self, const char* key, PyObject* referredObject);
+LIBSHIBOKEN_API void removeReference(SbkObject *self, const char *key, PyObject *referredObject);
 
 } // namespace Object
 
diff --git a/sources/shiboken2/libshiboken/basewrapper_p.h b/sources/shiboken2/libshiboken/basewrapper_p.h
index f8a381078..feba6561e 100644
--- a/sources/shiboken2/libshiboken/basewrapper_p.h
+++ b/sources/shiboken2/libshiboken/basewrapper_p.h
@@ -61,7 +61,7 @@ namespace Shiboken
 typedef std::unordered_multimap<std::string, PyObject *> RefCountMap;
 
 /// Linked list of SbkBaseWrapper pointers
-typedef std::set<SbkObject*> ChildrenList;
+using ChildrenList = std::set<SbkObject *>;
 
 /// Structure used to store information about object parent and children.
 struct ParentInfo
@@ -69,7 +69,7 @@ struct ParentInfo
     /// Default ctor.
     ParentInfo() : parent(0), hasWrapperRef(false) {}
     /// Pointer to parent object.
-    SbkObject* parent;
+    SbkObject *parent;
     /// List of object children.
     ChildrenList children;
     /// has internal ref
@@ -88,7 +88,7 @@ extern "C"
 struct SbkObjectPrivate
 {
     /// Pointer to the C++ class.
-    void** cptr;
+    void ** cptr;
     /// True when Python is responsible for freeing the used memory.
     unsigned int hasOwnership : 1;
     /// This is true when the C++ class of the wrapped object has a virtual destructor AND was created by Python.
@@ -98,9 +98,9 @@ struct SbkObjectPrivate
     /// Marked as true when the object constructor was called
     unsigned int cppObjectCreated : 1;
     /// Information about the object parents and children, may be null.
-    Shiboken::ParentInfo* parentInfo;
+    Shiboken::ParentInfo *parentInfo;
     /// Manage reference count of objects that are referred to but not owned from.
-    Shiboken::RefCountMap* referredObjects;
+    Shiboken::RefCountMap *referredObjects;
 
     ~SbkObjectPrivate()
     {
@@ -121,8 +121,8 @@ struct SbkObjectPrivate
 
 struct SbkObjectTypePrivate
 {
-    SbkConverter* converter;
-    int* mi_offsets;
+    SbkConverter *converter;
+    int *mi_offsets;
     MultipleInheritanceInitFunction mi_init;
 
     /// Special cast function, null if this class doesn't have multiple inheritance.
@@ -134,16 +134,16 @@ struct SbkObjectTypePrivate
     int is_multicpp : 1;
     /// True if this type was defined by the user.
     int is_user_type : 1;
-    /// Tells is the type is a value type or an object-type, see BEHAVIOUR_* constants.
+    /// Tells is the type is a value type or an object-type, see BEHAVIOUR_ *constants.
     // TODO-CONVERTERS: to be deprecated/removed
     int type_behaviour : 2;
     int delete_in_main_thread : 1;
     /// C++ name
-    char* original_name;
+    char *original_name;
     /// Type user data
-    void* user_data;
+    void *user_data;
     DeleteUserDataFunc d_func;
-    void (*subtype_init)(SbkObjectType*, PyObject*, PyObject*);
+    void (*subtype_init)(SbkObjectType *, PyObject *, PyObject *);
 };
 
 
@@ -165,7 +165,7 @@ struct DestructorEntry
 /**
  * Utility function used to transform a PyObject that implements sequence protocol into a std::list.
  **/
-std::vector<SbkObject *> splitPyObject(PyObject* pyObj);
+std::vector<SbkObject *> splitPyObject(PyObject *pyObj);
 
 /**
 *   Visitor class used by walkOnClassHierarchy function.
@@ -211,7 +211,7 @@ private:
 class GetIndexVisitor : public HierarchyVisitor
 {
 public:
-    explicit GetIndexVisitor(PyTypeObject* desiredType) : m_desiredType(desiredType) {}
+    explicit GetIndexVisitor(PyTypeObject *desiredType) : m_desiredType(desiredType) {}
 
     bool visit(SbkObjectType *node) override;
 
@@ -248,21 +248,21 @@ private:
 */
 bool walkThroughClassHierarchy(PyTypeObject *currentType, HierarchyVisitor *visitor);
 
-inline int getTypeIndexOnHierarchy(PyTypeObject* baseType, PyTypeObject* desiredType)
+inline int getTypeIndexOnHierarchy(PyTypeObject *baseType, PyTypeObject *desiredType)
 {
     GetIndexVisitor visitor(desiredType);
     walkThroughClassHierarchy(baseType, &visitor);
     return visitor.index();
 }
 
-inline int getNumberOfCppBaseClasses(PyTypeObject* baseType)
+inline int getNumberOfCppBaseClasses(PyTypeObject *baseType)
 {
     BaseCountVisitor visitor;
     walkThroughClassHierarchy(baseType, &visitor);
     return visitor.count();
 }
 
-inline std::vector<SbkObjectType *> getCppBaseClasses(PyTypeObject* baseType)
+inline std::vector<SbkObjectType *> getCppBaseClasses(PyTypeObject *baseType)
 {
     BaseAccumulatorVisitor visitor;
     walkThroughClassHierarchy(baseType, &visitor);
@@ -275,12 +275,12 @@ namespace Object
 *   Decrements the reference counters of every object referred by self.
 *   \param self    the wrapper instance that keeps references to other objects.
 */
-void clearReferences(SbkObject* self);
+void clearReferences(SbkObject *self);
 
 /**
  * Destroy internal data
  **/
-void deallocData(SbkObject* self, bool doCleanup);
+void deallocData(SbkObject *self, bool doCleanup);
 
 } // namespace Object
 
diff --git a/sources/shiboken2/libshiboken/bindingmanager.cpp b/sources/shiboken2/libshiboken/bindingmanager.cpp
index 8a9e912fd..c526d9b2e 100644
--- a/sources/shiboken2/libshiboken/bindingmanager.cpp
+++ b/sources/shiboken2/libshiboken/bindingmanager.cpp
@@ -64,7 +64,7 @@ public:
 
     Graph() = default;
 
-    void addEdge(SbkObjectType* from, SbkObjectType* to)
+    void addEdge(SbkObjectType *from, SbkObjectType *to)
     {
         m_edges[from].push_back(to);
     }
@@ -78,7 +78,7 @@ public:
 
         for (auto i = m_edges.begin(), end = m_edges.end(); i != end; ++i) {
             auto node1 = reinterpret_cast<const PyTypeObject *>(i->first);
-            const NodeList& nodeList = i->second;
+            const NodeList &nodeList = i->second;
             for (const SbkObjectType *o : nodeList) {
                 auto node2 = reinterpret_cast<const PyTypeObject *>(o);
                 file << '"' << node2->tp_name << "\" -> \""
@@ -89,13 +89,13 @@ public:
     }
 #endif
 
-    SbkObjectType* identifyType(void** cptr, SbkObjectType* type, SbkObjectType* baseType) const
+    SbkObjectType *identifyType(void **cptr, SbkObjectType *type, SbkObjectType *baseType) const
     {
         Edges::const_iterator edgesIt = m_edges.find(type);
         if (edgesIt != m_edges.end()) {
-            const NodeList& adjNodes = m_edges.find(type)->second;
+            const NodeList &adjNodes = m_edges.find(type)->second;
             for (SbkObjectType *node : adjNodes) {
-                SbkObjectType* newType = identifyType(cptr, node, baseType);
+                SbkObjectType *newType = identifyType(cptr, node, baseType);
                 if (newType)
                     return newType;
             }
@@ -106,7 +106,7 @@ public:
         }
         if (typeFound) {
             // This "typeFound != type" is needed for backwards compatibility with old modules using a newer version of
-            // libshiboken because old versions of type_discovery function used to return a SbkObjectType* instead of
+            // libshiboken because old versions of type_discovery function used to return a SbkObjectType *instead of
             // a possible variation of the C++ instance pointer (*cptr).
             if (typeFound != type)
                 *cptr = typeFound;
@@ -118,7 +118,7 @@ public:
 
 
 #ifndef NDEBUG
-static void showWrapperMap(const WrapperMap& wrapperMap)
+static void showWrapperMap(const WrapperMap &wrapperMap)
 {
     if (Py_VerboseFlag > 0) {
         fprintf(stderr, "-------------------------------\n");
@@ -144,12 +144,12 @@ struct BindingManager::BindingManagerPrivate {
     bool destroying;
 
     BindingManagerPrivate() : destroying(false) {}
-    bool releaseWrapper(void* cptr, SbkObject* wrapper);
-    void assignWrapper(SbkObject* wrapper, const void* cptr);
+    bool releaseWrapper(void *cptr, SbkObject *wrapper);
+    void assignWrapper(SbkObject *wrapper, const void *cptr);
 
 };
 
-bool BindingManager::BindingManagerPrivate::releaseWrapper(void* cptr, SbkObject* wrapper)
+bool BindingManager::BindingManagerPrivate::releaseWrapper(void *cptr, SbkObject *wrapper)
 {
     // The wrapper argument is checked to ensure that the correct wrapper is released.
     // Returns true if the correct wrapper is found and released.
@@ -162,7 +162,7 @@ bool BindingManager::BindingManagerPrivate::releaseWrapper(void* cptr, SbkObject
     return false;
 }
 
-void BindingManager::BindingManagerPrivate::assignWrapper(SbkObject* wrapper, const void* cptr)
+void BindingManager::BindingManagerPrivate::assignWrapper(SbkObject *wrapper, const void *cptr)
 {
     assert(cptr);
     WrapperMap::iterator iter = wrapperMapper.find(cptr);
@@ -192,27 +192,27 @@ BindingManager::~BindingManager()
      * shutting down. */
     if (Py_IsInitialized()) {  // ensure the interpreter is still valid
         while (!m_d->wrapperMapper.empty()) {
-            Object::destroy(m_d->wrapperMapper.begin()->second, const_cast<void*>(m_d->wrapperMapper.begin()->first));
+            Object::destroy(m_d->wrapperMapper.begin()->second, const_cast<void *>(m_d->wrapperMapper.begin()->first));
         }
         assert(m_d->wrapperMapper.empty());
     }
     delete m_d;
 }
 
-BindingManager& BindingManager::instance() {
+BindingManager &BindingManager::instance() {
     static BindingManager singleton;
     return singleton;
 }
 
-bool BindingManager::hasWrapper(const void* cptr)
+bool BindingManager::hasWrapper(const void *cptr)
 {
     return m_d->wrapperMapper.find(cptr) != m_d->wrapperMapper.end();
 }
 
-void BindingManager::registerWrapper(SbkObject* pyObj, void* cptr)
+void BindingManager::registerWrapper(SbkObject *pyObj, void *cptr)
 {
-    SbkObjectType* instanceType = reinterpret_cast<SbkObjectType*>(Py_TYPE(pyObj));
-    SbkObjectTypePrivate* d = PepType_SOTP(instanceType);
+    auto instanceType = reinterpret_cast<SbkObjectType *>(Py_TYPE(pyObj));
+    SbkObjectTypePrivate *d = PepType_SOTP(instanceType);
 
     if (!d)
         return;
@@ -221,27 +221,27 @@ void BindingManager::registerWrapper(SbkObject* pyObj, void* cptr)
         d->mi_offsets = d->mi_init(cptr);
     m_d->assignWrapper(pyObj, cptr);
     if (d->mi_offsets) {
-        int* offset = d->mi_offsets;
+        int *offset = d->mi_offsets;
         while (*offset != -1) {
             if (*offset > 0)
-                m_d->assignWrapper(pyObj, reinterpret_cast<void*>((std::size_t) cptr + (*offset)));
+                m_d->assignWrapper(pyObj, reinterpret_cast<void *>((std::size_t) cptr + (*offset)));
             offset++;
         }
     }
 }
 
-void BindingManager::releaseWrapper(SbkObject* sbkObj)
+void BindingManager::releaseWrapper(SbkObject *sbkObj)
 {
-    SbkObjectType* sbkType = reinterpret_cast<SbkObjectType*>(Py_TYPE(sbkObj));
-    SbkObjectTypePrivate* d = PepType_SOTP(sbkType);
+    auto sbkType = reinterpret_cast<SbkObjectType *>(Py_TYPE(sbkObj));
+    SbkObjectTypePrivate *d = PepType_SOTP(sbkType);
     int numBases = ((d && d->is_multicpp) ? getNumberOfCppBaseClasses(Py_TYPE(sbkObj)) : 1);
 
-    void** cptrs = reinterpret_cast<SbkObject*>(sbkObj)->d->cptr;
+    void ** cptrs = reinterpret_cast<SbkObject *>(sbkObj)->d->cptr;
     for (int i = 0; i < numBases; ++i) {
         unsigned char *cptr = reinterpret_cast<unsigned char *>(cptrs[i]);
         m_d->releaseWrapper(cptr, sbkObj);
         if (d && d->mi_offsets) {
-            int* offset = d->mi_offsets;
+            int *offset = d->mi_offsets;
             while (*offset != -1) {
                 if (*offset > 0)
                     m_d->releaseWrapper(reinterpret_cast<void *>((std::size_t) cptr + (*offset)), sbkObj);
@@ -264,7 +264,7 @@ void BindingManager::addToDeletionInMainThread(const DestructorEntry &e)
     m_d->deleteInMainThread.push_back(e);
 }
 
-SbkObject* BindingManager::retrieveWrapper(const void* cptr)
+SbkObject *BindingManager::retrieveWrapper(const void *cptr)
 {
     WrapperMap::iterator iter = m_d->wrapperMapper.find(cptr);
     if (iter == m_d->wrapperMapper.end())
@@ -272,34 +272,34 @@ SbkObject* BindingManager::retrieveWrapper(const void* cptr)
     return iter->second;
 }
 
-PyObject* BindingManager::getOverride(const void* cptr, const char* methodName)
+PyObject *BindingManager::getOverride(const void *cptr, const char *methodName)
 {
-    SbkObject* wrapper = retrieveWrapper(cptr);
+    SbkObject *wrapper = retrieveWrapper(cptr);
     // The refcount can be 0 if the object is dieing and someone called
     // a virtual method from the destructor
     if (!wrapper || reinterpret_cast<const PyObject *>(wrapper)->ob_refcnt == 0)
         return 0;
 
     if (wrapper->ob_dict) {
-        PyObject* method = PyDict_GetItemString(wrapper->ob_dict, methodName);
+        PyObject *method = PyDict_GetItemString(wrapper->ob_dict, methodName);
         if (method) {
             Py_INCREF(reinterpret_cast<PyObject *>(method));
             return method;
         }
     }
 
-    PyObject* pyMethodName = Shiboken::String::fromCString(methodName);
+    PyObject *pyMethodName = Shiboken::String::fromCString(methodName);
     PyObject *method = PyObject_GetAttr(reinterpret_cast<PyObject *>(wrapper), pyMethodName);
 
     if (method && PyMethod_Check(method)
-        && PyMethod_GET_SELF(method) == reinterpret_cast<PyObject*>(wrapper)) {
-        PyObject* defaultMethod;
-        PyObject* mro = Py_TYPE(wrapper)->tp_mro;
+        && PyMethod_GET_SELF(method) == reinterpret_cast<PyObject *>(wrapper)) {
+        PyObject *defaultMethod;
+        PyObject *mro = Py_TYPE(wrapper)->tp_mro;
 
         // The first class in the mro (index 0) is the class being checked and it should not be tested.
         // The last class in the mro (size - 1) is the base Python object class which should not be tested also.
         for (int i = 1; i < PyTuple_GET_SIZE(mro) - 1; i++) {
-            PyTypeObject* parent = reinterpret_cast<PyTypeObject*>(PyTuple_GET_ITEM(mro, i));
+            PyTypeObject *parent = reinterpret_cast<PyTypeObject *>(PyTuple_GET_ITEM(mro, i));
             if (parent->tp_dict) {
                 defaultMethod = PyDict_GetItem(parent->tp_dict, pyMethodName);
                 if (defaultMethod && PyMethod_GET_FUNCTION(method) != defaultMethod) {
@@ -315,34 +315,34 @@ PyObject* BindingManager::getOverride(const void* cptr, const char* methodName)
     return 0;
 }
 
-void BindingManager::addClassInheritance(SbkObjectType* parent, SbkObjectType* child)
+void BindingManager::addClassInheritance(SbkObjectType *parent, SbkObjectType *child)
 {
     m_d->classHierarchy.addEdge(parent, child);
 }
 
-SbkObjectType* BindingManager::resolveType(void* cptr, SbkObjectType* type)
+SbkObjectType *BindingManager::resolveType(void *cptr, SbkObjectType *type)
 {
     return resolveType(&cptr, type);
 }
 
-SbkObjectType* BindingManager::resolveType(void** cptr, SbkObjectType* type)
+SbkObjectType *BindingManager::resolveType(void **cptr, SbkObjectType *type)
 {
-    SbkObjectType* identifiedType = m_d->classHierarchy.identifyType(cptr, type, type);
+    SbkObjectType *identifiedType = m_d->classHierarchy.identifyType(cptr, type, type);
     return identifiedType ? identifiedType : type;
 }
 
-std::set<PyObject*> BindingManager::getAllPyObjects()
+std::set<PyObject *> BindingManager::getAllPyObjects()
 {
-    std::set<PyObject*> pyObjects;
-    const WrapperMap& wrappersMap = m_d->wrapperMapper;
+    std::set<PyObject *> pyObjects;
+    const WrapperMap &wrappersMap = m_d->wrapperMapper;
     WrapperMap::const_iterator it = wrappersMap.begin();
     for (; it != wrappersMap.end(); ++it)
-        pyObjects.insert(reinterpret_cast<PyObject*>(it->second));
+        pyObjects.insert(reinterpret_cast<PyObject *>(it->second));
 
     return pyObjects;
 }
 
-void BindingManager::visitAllPyObjects(ObjectVisitor visitor, void* data)
+void BindingManager::visitAllPyObjects(ObjectVisitor visitor, void *data)
 {
     WrapperMap copy = m_d->wrapperMapper;
     for (WrapperMap::iterator it = copy.begin(); it != copy.end(); ++it) {
diff --git a/sources/shiboken2/libshiboken/bindingmanager.h b/sources/shiboken2/libshiboken/bindingmanager.h
index d03aa999a..bfcbdc79b 100644
--- a/sources/shiboken2/libshiboken/bindingmanager.h
+++ b/sources/shiboken2/libshiboken/bindingmanager.h
@@ -52,36 +52,36 @@ namespace Shiboken
 
 struct DestructorEntry;
 
-typedef void (*ObjectVisitor)(SbkObject*, void*);
+typedef void (*ObjectVisitor)(SbkObject *, void *);
 
 class LIBSHIBOKEN_API BindingManager
 {
 public:
-    BindingManager(const BindingManager&) = delete;
-    BindingManager(BindingManager&&) = delete;
-    BindingManager& operator=(const BindingManager&) = delete;
-    BindingManager& operator=(BindingManager&&) = delete;
+    BindingManager(const BindingManager &) = delete;
+    BindingManager(BindingManager &&) = delete;
+    BindingManager &operator=(const BindingManager &) = delete;
+    BindingManager &operator=(BindingManager &&) = delete;
 
-    static BindingManager& instance();
+    static BindingManager &instance();
 
     bool hasWrapper(const void *cptr);
 
-    void registerWrapper(SbkObject* pyObj, void* cptr);
-    void releaseWrapper(SbkObject* wrapper);
+    void registerWrapper(SbkObject *pyObj, void *cptr);
+    void releaseWrapper(SbkObject *wrapper);
 
     void runDeletionInMainThread();
     void addToDeletionInMainThread(const DestructorEntry &);
 
-    SbkObject* retrieveWrapper(const void* cptr);
-    PyObject* getOverride(const void* cptr, const char* methodName);
+    SbkObject *retrieveWrapper(const void *cptr);
+    PyObject *getOverride(const void *cptr, const char *methodName);
 
-    void addClassInheritance(SbkObjectType* parent, SbkObjectType* child);
+    void addClassInheritance(SbkObjectType *parent, SbkObjectType *child);
     /**
-     * \deprecated Use \fn resolveType(void**, SbkObjectType*), this version is broken when used with multiple inheritance
+     * \deprecated Use \fn resolveType(void **, SbkObjectType *), this version is broken when used with multiple inheritance
      *             because the \p cptr pointer of the discovered type may be different of the given \p cptr in case
      *             of multiple inheritance
      */
-    SBK_DEPRECATED(SbkObjectType* resolveType(void* cptr, SbkObjectType* type));
+    SBK_DEPRECATED(SbkObjectType *resolveType(void *cptr, SbkObjectType *type));
     /**
      * Try to find the correct type of *cptr knowing that it's at least of type \p type.
      * In case of multiple inheritance this function may change the contents of cptr.
@@ -89,9 +89,9 @@ public:
      * \param type type of *cptr
      * \warning This function is slow, use it only as last resort.
      */
-    SbkObjectType* resolveType(void** cptr, SbkObjectType* type);
+    SbkObjectType *resolveType(void **cptr, SbkObjectType *type);
 
-    std::set<PyObject*> getAllPyObjects();
+    std::set<PyObject *> getAllPyObjects();
 
     /**
      * Calls the function \p visitor for each object registered on binding manager.
@@ -100,14 +100,14 @@ public:
      * \param visitor function called for each object.
      * \param data user data passed as second argument to the visitor function.
      */
-    void visitAllPyObjects(ObjectVisitor visitor, void* data);
+    void visitAllPyObjects(ObjectVisitor visitor, void *data);
 
 private:
     ~BindingManager();
     BindingManager();
 
     struct BindingManagerPrivate;
-    BindingManagerPrivate* m_d;
+    BindingManagerPrivate *m_d;
 };
 
 } // namespace Shiboken
diff --git a/sources/shiboken2/libshiboken/bufferprocs_py37.cpp b/sources/shiboken2/libshiboken/bufferprocs_py37.cpp
index 84d670d21..ddb07390e 100644
--- a/sources/shiboken2/libshiboken/bufferprocs_py37.cpp
+++ b/sources/shiboken2/libshiboken/bufferprocs_py37.cpp
@@ -147,19 +147,18 @@ PyBuffer_IsContiguous(const Pep_buffer *view, char order)
 }
 
 
-void*
+void *
 PyBuffer_GetPointer(Pep_buffer *view, Py_ssize_t *indices)
 {
-    char* pointer;
     int i;
-    pointer = (char *)view->buf;
+    auto pointer = reinterpret_cast<char *>(view->buf);
     for (i = 0; i < view->ndim; i++) {
         pointer += view->strides[i]*indices[i];
         if ((view->suboffsets != NULL) && (view->suboffsets[i] >= 0)) {
-            pointer = *((char**)pointer) + view->suboffsets[i];
+            pointer = *reinterpret_cast<char **>(pointer) + view->suboffsets[i];
         }
     }
-    return (void*)pointer;
+    return pointer;
 }
 
 
@@ -221,7 +220,7 @@ PyBuffer_FromContiguous(Pep_buffer *view, void *buf, Py_ssize_t len, char fort)
         PyErr_NoMemory();
         return -1;
     }
-    for (k=0; k<view->ndim;k++) {
+    for (k=0; k<view->ndim; k++) {
         indices[k] = 0;
     }
 
diff --git a/sources/shiboken2/libshiboken/debugfreehook.cpp b/sources/shiboken2/libshiboken/debugfreehook.cpp
index c66866cf1..3d52d88dc 100644
--- a/sources/shiboken2/libshiboken/debugfreehook.cpp
+++ b/sources/shiboken2/libshiboken/debugfreehook.cpp
@@ -107,8 +107,8 @@ static int DebugAllocHook(int nAllocType, void *pvData,
 #endif // _WIN32 && _DEBUG
 
 #ifdef __GLIBC__
-static void (*lastFreeHook)(void* ptr, const void* caller);
-static void DebugFreeHook(void* ptr, const void* caller)
+static void (*lastFreeHook)(void *ptr, const void *caller);
+static void DebugFreeHook(void *ptr, const void *caller)
 {
     testPointerBeingFreed(ptr);
 
@@ -150,7 +150,7 @@ void debugInstallFreeHook(void)
 #endif
 
 #ifdef __APPLE__
-    malloc_zone_t* zone = malloc_default_zone();
+    malloc_zone_t *zone = malloc_default_zone();
     assert(zone != NULL);
     //remove the write protection from the zone struct
     if (zone->version >= 8) {
@@ -176,7 +176,7 @@ void debugRemoveFreeHook(void)
 #endif
 
 #ifdef __APPLE__
-    malloc_zone_t* zone = malloc_default_zone();
+    malloc_zone_t *zone = malloc_default_zone();
     assert(zone != NULL);
     //remove the write protection from the zone struct
     if (zone->version >= 8) {
diff --git a/sources/shiboken2/libshiboken/gilstate.h b/sources/shiboken2/libshiboken/gilstate.h
index 9da4871d1..f0ff45d59 100644
--- a/sources/shiboken2/libshiboken/gilstate.h
+++ b/sources/shiboken2/libshiboken/gilstate.h
@@ -49,10 +49,10 @@ namespace Shiboken
 class LIBSHIBOKEN_API GilState
 {
 public:
-    GilState(const GilState&) = delete;
-    GilState(GilState&&) = delete;
-    GilState& operator=(const GilState&) = delete;
-    GilState& operator=(GilState&&) = delete;
+    GilState(const GilState &) = delete;
+    GilState(GilState &&) = delete;
+    GilState &operator=(const GilState &) = delete;
+    GilState &operator=(GilState &&) = delete;
 
     GilState();
     ~GilState();
diff --git a/sources/shiboken2/libshiboken/helper.cpp b/sources/shiboken2/libshiboken/helper.cpp
index e42daff07..1a2dc7ab9 100644
--- a/sources/shiboken2/libshiboken/helper.cpp
+++ b/sources/shiboken2/libshiboken/helper.cpp
@@ -51,7 +51,7 @@ namespace Shiboken
 {
 
 // PySide-510: Changed from PySequence to PyList, which is correct.
-bool listToArgcArgv(PyObject* argList, int* argc, char*** argv, const char* defaultAppName)
+bool listToArgcArgv(PyObject *argList, int *argc, char ***argv, const char *defaultAppName)
 {
     if (!PyList_Check(argList))
         return false;
@@ -63,7 +63,7 @@ bool listToArgcArgv(PyObject* argList, int* argc, char*** argv, const char* defa
     Shiboken::AutoDecRef args(PySequence_Fast(argList, 0));
     int numArgs = int(PySequence_Fast_GET_SIZE(argList));
     for (int i = 0; i < numArgs; ++i) {
-        PyObject* item = PyList_GET_ITEM(args.object(), i);
+        PyObject *item = PyList_GET_ITEM(args.object(), i);
         if (!PyBytes_Check(item) && !PyUnicode_Check(item))
             return false;
     }
@@ -73,17 +73,17 @@ bool listToArgcArgv(PyObject* argList, int* argc, char*** argv, const char* defa
         numArgs = 1;
 
     *argc = numArgs;
-    *argv = new char*[*argc];
+    *argv = new char *[*argc];
 
     if (hasEmptyArgList) {
         // Try to get the script name
-        PyObject* globals = PyEval_GetGlobals();
-        PyObject* appName = PyDict_GetItemString(globals, "__file__");
+        PyObject *globals = PyEval_GetGlobals();
+        PyObject *appName = PyDict_GetItemString(globals, "__file__");
         (*argv)[0] = strdup(appName ? Shiboken::String::toCString(appName) : defaultAppName);
     } else {
         for (int i = 0; i < numArgs; ++i) {
-            PyObject* item = PyList_GET_ITEM(args.object(), i);
-            char* string = 0;
+            PyObject *item = PyList_GET_ITEM(args.object(), i);
+            char *string = 0;
             if (Shiboken::String::check(item)) {
                 string = strdup(Shiboken::String::toCString(item));
             }
@@ -94,17 +94,17 @@ bool listToArgcArgv(PyObject* argList, int* argc, char*** argv, const char* defa
     return true;
 }
 
-int* sequenceToIntArray(PyObject* obj, bool zeroTerminated)
+int *sequenceToIntArray(PyObject *obj, bool zeroTerminated)
 {
     AutoDecRef seq(PySequence_Fast(obj, "Sequence of ints expected"));
     if (seq.isNull())
         return 0;
 
     Py_ssize_t size = PySequence_Fast_GET_SIZE(seq.object());
-    int* array = new int[size + (zeroTerminated ? 1 : 0)];
+    int *array = new int[size + (zeroTerminated ? 1 : 0)];
 
     for (int i = 0; i < size; i++) {
-        PyObject* item = PySequence_Fast_GET_ITEM(seq.object(), i);
+        PyObject *item = PySequence_Fast_GET_ITEM(seq.object(), i);
         if (!PyInt_Check(item)) {
             PyErr_SetString(PyExc_TypeError, "Sequence of ints expected");
             delete[] array;
@@ -121,7 +121,7 @@ int* sequenceToIntArray(PyObject* obj, bool zeroTerminated)
 }
 
 
-int warning(PyObject* category, int stacklevel, const char* format, ...)
+int warning(PyObject *category, int stacklevel, const char *format, ...)
 {
     va_list args;
     va_start(args, format);
@@ -134,7 +134,7 @@ int warning(PyObject* category, int stacklevel, const char* format, ...)
 
     // check the necessary memory
     int size = vsnprintf(NULL, 0, format, args) + 1;
-    char* message = new char[size];
+    auto message = new char[size];
     int result = 0;
     if (message) {
         // format the message
diff --git a/sources/shiboken2/libshiboken/helper.h b/sources/shiboken2/libshiboken/helper.h
index 9b6d8903f..6c29ad728 100644
--- a/sources/shiboken2/libshiboken/helper.h
+++ b/sources/shiboken2/libshiboken/helper.h
@@ -60,7 +60,7 @@ namespace Shiboken
 * \note The argv array is allocated using new operator and each item is allocated using malloc.
 * \returns True on sucess, false otherwise.
 */
-LIBSHIBOKEN_API bool listToArgcArgv(PyObject* argList, int* argc, char*** argv, const char* defaultAppName = 0);
+LIBSHIBOKEN_API bool listToArgcArgv(PyObject *argList, int *argc, char ***argv, const char *defaultAppName = nullptr);
 
 /**
  * Convert a python sequence into a heap-allocated array of ints.
@@ -68,7 +68,7 @@ LIBSHIBOKEN_API bool listToArgcArgv(PyObject* argList, int* argc, char*** argv,
  * \returns The newly allocated array or NULL in case of error or empty sequence. Check with PyErr_Occurred
  *          if it was successfull.
  */
-LIBSHIBOKEN_API int* sequenceToIntArray(PyObject* obj, bool zeroTerminated = false);
+LIBSHIBOKEN_API int *sequenceToIntArray(PyObject *obj, bool zeroTerminated = false);
 
 /**
  *  Creates and automatically deallocates C++ arrays.
@@ -77,17 +77,17 @@ template<class T>
 class AutoArrayPointer
 {
     public:
-        AutoArrayPointer(const AutoArrayPointer&) = delete;
-        AutoArrayPointer(AutoArrayPointer&&) = delete;
-        AutoArrayPointer& operator=(const AutoArrayPointer&) = delete;
-        AutoArrayPointer& operator=(AutoArrayPointer&&) = delete;
+        AutoArrayPointer(const AutoArrayPointer &) = delete;
+        AutoArrayPointer(AutoArrayPointer &&) = delete;
+        AutoArrayPointer &operator=(const AutoArrayPointer &) = delete;
+        AutoArrayPointer &operator=(AutoArrayPointer &&) = delete;
 
         explicit AutoArrayPointer(int size) { data = new T[size]; }
-        T& operator[](int pos) { return data[pos]; }
-        operator T*() const { return data; }
+        T &operator[](int pos) { return data[pos]; }
+        operator T *() const { return data; }
         ~AutoArrayPointer() { delete[] data; }
     private:
-        T* data;
+        T *data;
 };
 
 typedef unsigned long long ThreadId;
@@ -97,7 +97,7 @@ LIBSHIBOKEN_API ThreadId mainThreadId();
 /**
  * An utility function used to call PyErr_WarnEx with a formatted message.
  */
-LIBSHIBOKEN_API int warning(PyObject* category, int stacklevel, const char* format, ...);
+LIBSHIBOKEN_API int warning(PyObject *category, int stacklevel, const char *format, ...);
 
 } // namespace Shiboken
 
diff --git a/sources/shiboken2/libshiboken/pep384_issue33738.cpp b/sources/shiboken2/libshiboken/pep384_issue33738.cpp
index ee085438e..c20edeefa 100644
--- a/sources/shiboken2/libshiboken/pep384_issue33738.cpp
+++ b/sources/shiboken2/libshiboken/pep384_issue33738.cpp
@@ -114,7 +114,7 @@ typedef struct _oldtypeobject {
 
 int PyIndex_Check(PyObject *obj)
 {
-    PyOldTypeObject *type = reinterpret_cast<PyOldTypeObject*>(Py_TYPE(obj));
+    PyOldTypeObject *type = reinterpret_cast<PyOldTypeObject *>(Py_TYPE(obj));
     return type->tp_as_number != NULL &&
            type->tp_as_number->nb_index != NULL;
 }
diff --git a/sources/shiboken2/libshiboken/pep384impl.cpp b/sources/shiboken2/libshiboken/pep384impl.cpp
index 9a52603dc..ac0328b6b 100644
--- a/sources/shiboken2/libshiboken/pep384impl.cpp
+++ b/sources/shiboken2/libshiboken/pep384impl.cpp
@@ -59,8 +59,8 @@ extern "C"
  * appear at the right offsets.
  */
 
-#define make_dummy_int(x)   (x * sizeof(void*))
-#define make_dummy(x)       (reinterpret_cast<void*>(make_dummy_int(x)))
+#define make_dummy_int(x)   (x * sizeof(void *))
+#define make_dummy(x)       (reinterpret_cast<void *>(make_dummy_int(x)))
 
 #ifdef Py_LIMITED_API
 datetime_struc *PyDateTimeAPI = NULL;
diff --git a/sources/shiboken2/libshiboken/python25compat.h b/sources/shiboken2/libshiboken/python25compat.h
index fc25aa3e5..b8a4950d9 100644
--- a/sources/shiboken2/libshiboken/python25compat.h
+++ b/sources/shiboken2/libshiboken/python25compat.h
@@ -48,9 +48,9 @@
  */
 
 #if PY_VERSION_HEX < 0x02060000
-#define Py_REFCNT(ob) (((PyObject*)(ob))->ob_refcnt)
-#define Py_TYPE(ob)   (((PyObject*)(ob))->ob_type)
-#define Py_SIZE(ob)   (((PyVarObject*)(ob))->ob_size)
+#define Py_REFCNT(ob) (((PyObject *)(ob))->ob_refcnt)
+#define Py_TYPE(ob)   (((PyObject *)(ob))->ob_type)
+#define Py_SIZE(ob)   (((PyVarObject *)(ob))->ob_size)
 #define PyVarObject_HEAD_INIT(type, size) \
         PyObject_HEAD_INIT(type) size,
 #define PyType_Modified(t)
@@ -90,7 +90,7 @@ typedef struct {
 #define PyBytes_Concat PyString_Concat
 #define PyBytes_Size PyString_Size
 
-inline PyObject* PyUnicode_FromString(const char* s)
+inline PyObject *PyUnicode_FromString(const char *s)
 {
     std::size_t len = std::strlen(s);
     return PyUnicode_DecodeUTF8(s, len, 0);
diff --git a/sources/shiboken2/libshiboken/sbkarrayconverter.h b/sources/shiboken2/libshiboken/sbkarrayconverter.h
index 2b82b25b4..5b26c6e3c 100644
--- a/sources/shiboken2/libshiboken/sbkarrayconverter.h
+++ b/sources/shiboken2/libshiboken/sbkarrayconverter.h
@@ -74,7 +74,7 @@ template <class T>
 class ArrayHandle
 {
     ArrayHandle(const ArrayHandle &) = delete;
-    ArrayHandle& operator=(const ArrayHandle &) = delete;
+    ArrayHandle &operator=(const ArrayHandle &) = delete;
 public:
     ArrayHandle() {}
     ~ArrayHandle() { destroy(); }
@@ -84,7 +84,7 @@ public:
 
     size_t size() const { return m_size; }
     T *data() const { return m_data; }
-    operator T*() const { return m_data; }
+    operator T *() const { return m_data; }
 
 private:
     void destroy();
@@ -108,7 +108,7 @@ public:
 
     Array2Handle() {}
 
-    operator RowType*() const { return m_rows; }
+    operator RowType *() const { return m_rows; }
 
     void setData(RowType *d) { m_rows = d; }
 
diff --git a/sources/shiboken2/libshiboken/sbkarrayconverter_p.h b/sources/shiboken2/libshiboken/sbkarrayconverter_p.h
index a5e003e9a..a7b46702b 100644
--- a/sources/shiboken2/libshiboken/sbkarrayconverter_p.h
+++ b/sources/shiboken2/libshiboken/sbkarrayconverter_p.h
@@ -46,7 +46,7 @@
 extern "C"
 {
 
-typedef PythonToCppFunc (*IsArrayConvertibleToCppFunc)(PyObject*, int dim1, int dim2);
+typedef PythonToCppFunc (*IsArrayConvertibleToCppFunc)(PyObject *, int dim1, int dim2);
 /**
  *  \internal
  *  Private structure of SbkArrayConverter.
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:
diff --git a/sources/shiboken2/libshiboken/sbkconverter.h b/sources/shiboken2/libshiboken/sbkconverter.h
index 33c33025b..2d1735f2b 100644
--- a/sources/shiboken2/libshiboken/sbkconverter.h
+++ b/sources/shiboken2/libshiboken/sbkconverter.h
@@ -77,7 +77,7 @@ struct SbkArrayConverter;
  *
  *  C++ -> Python
  */
-typedef PyObject* (*CppToPythonFunc)(const void*);
+typedef PyObject *(*CppToPythonFunc)(const void *);
 
 /**
  *  This function converts a Python object to a C++ value, it may be
@@ -90,7 +90,7 @@ typedef PyObject* (*CppToPythonFunc)(const void*);
  *
  *  Python -> C++
  */
-typedef void (*PythonToCppFunc)(PyObject*,void*);
+typedef void (*PythonToCppFunc)(PyObject *,void *);
 
 /**
  *  Checks if the Python object passed in the argument is convertible to a
@@ -101,7 +101,7 @@ typedef void (*PythonToCppFunc)(PyObject*,void*);
  *
  *  Python -> C++ ?
  */
-typedef PythonToCppFunc (*IsConvertibleToCppFunc)(PyObject*);
+typedef PythonToCppFunc (*IsConvertibleToCppFunc)(PyObject *);
 
 } // extern "C"
 
@@ -120,20 +120,20 @@ public:
         ReferenceConversion
     };
 
-    explicit SpecificConverter(const char* typeName);
+    explicit SpecificConverter(const char *typeName);
 
-    inline SbkConverter* converter() { return m_converter; }
-    inline operator SbkConverter*() const { return m_converter; }
+    inline SbkConverter *converter() { return m_converter; }
+    inline operator SbkConverter *() const { return m_converter; }
 
     inline bool isValid() { return m_type != InvalidConversion; }
     inline operator bool() const { return m_type != InvalidConversion; }
 
     inline Type conversionType() { return m_type; }
 
-    PyObject* toPython(const void* cppIn);
-    void toCpp(PyObject* pyIn, void* cppOut);
+    PyObject *toPython(const void *cppIn);
+    void toCpp(PyObject *pyIn, void *cppOut);
 private:
-    SbkConverter* m_converter;
+    SbkConverter *m_converter;
     Type m_type;
 };
 
@@ -147,7 +147,7 @@ private:
  *  \param copyToPythonFunc      Function to convert a C++ object to a Python \p type, copying the object.
  *  \returns                     The new converter referred by the wrapper \p type.
  */
-LIBSHIBOKEN_API SbkConverter* createConverter(SbkObjectType* type,
+LIBSHIBOKEN_API SbkConverter *createConverter(SbkObjectType *type,
                                               PythonToCppFunc toCppPointerConvFunc,
                                               IsConvertibleToCppFunc toCppPointerCheckFunc,
                                               CppToPythonFunc pointerToPythonFunc,
@@ -159,15 +159,15 @@ LIBSHIBOKEN_API SbkConverter* createConverter(SbkObjectType* type,
  *  \param toPythonFunc Function to convert a C++ object to a Python \p type.
  *  \returns            A new type converter.
  */
-LIBSHIBOKEN_API SbkConverter* createConverter(PyTypeObject* type, CppToPythonFunc toPythonFunc);
+LIBSHIBOKEN_API SbkConverter *createConverter(PyTypeObject *type, CppToPythonFunc toPythonFunc);
 
-LIBSHIBOKEN_API void deleteConverter(SbkConverter* converter);
+LIBSHIBOKEN_API void deleteConverter(SbkConverter *converter);
 
 /// Sets the Python object to C++ pointer conversion function.
-LIBSHIBOKEN_API void setCppPointerToPythonFunction(SbkConverter* converter, CppToPythonFunc pointerToPythonFunc);
+LIBSHIBOKEN_API void setCppPointerToPythonFunction(SbkConverter *converter, CppToPythonFunc pointerToPythonFunc);
 
 /// Sets the C++ pointer to Python object conversion functions.
-LIBSHIBOKEN_API void setPythonToCppPointerFunctions(SbkConverter* converter,
+LIBSHIBOKEN_API void setPythonToCppPointerFunctions(SbkConverter *converter,
                                                     PythonToCppFunc toCppPointerConvFunc,
                                                     IsConvertibleToCppFunc toCppPointerCheckFunc);
 
@@ -175,10 +175,10 @@ LIBSHIBOKEN_API void setPythonToCppPointerFunctions(SbkConverter* converter,
  *  Adds a new conversion of a Python object to a C++ value.
  *  This is used in copy and implicit conversions.
  */
-LIBSHIBOKEN_API void addPythonToCppValueConversion(SbkConverter* converter,
+LIBSHIBOKEN_API void addPythonToCppValueConversion(SbkConverter *converter,
                                                    PythonToCppFunc pythonToCppFunc,
                                                    IsConvertibleToCppFunc isConvertibleToCppFunc);
-LIBSHIBOKEN_API void addPythonToCppValueConversion(SbkObjectType* type,
+LIBSHIBOKEN_API void addPythonToCppValueConversion(SbkObjectType *type,
                                                    PythonToCppFunc pythonToCppFunc,
                                                    IsConvertibleToCppFunc isConvertibleToCppFunc);
 
@@ -188,11 +188,11 @@ LIBSHIBOKEN_API void addPythonToCppValueConversion(SbkObjectType* type,
  *  Retrieves the Python wrapper object for the given \p cppIn C++ pointer object.
  *  This function is used only for Value and Object Types.
  *  Example usage:
- *      TYPE* var;
- *      PyObject* pyVar = pointerToPython(SBKTYPE, &var);
+ *      TYPE *var;
+ *      PyObject *pyVar = pointerToPython(SBKTYPE, &var);
  */
-LIBSHIBOKEN_API PyObject* pointerToPython(SbkObjectType *type, const void *cppIn);
-LIBSHIBOKEN_API PyObject* pointerToPython(const SbkConverter *converter, const void *cppIn);
+LIBSHIBOKEN_API PyObject *pointerToPython(SbkObjectType *type, const void *cppIn);
+LIBSHIBOKEN_API PyObject *pointerToPython(const SbkConverter *converter, const void *cppIn);
 
 /**
  *  For the given \p cppIn C++ reference it returns the Python wrapper object,
@@ -200,21 +200,21 @@ LIBSHIBOKEN_API PyObject* pointerToPython(const SbkConverter *converter, const v
  *  for when the latter doesn't have an existing wrapper type, the C++ object
  *  is copied to Python.
  *  Example usage:
- *      TYPE& var = SOMETHING;
- *      PyObject* pyVar = referenceToPython(SBKTYPE, &var);
+ *      TYPE &var = SOMETHING;
+ *      PyObject *pyVar = referenceToPython(SBKTYPE, &var);
  */
-LIBSHIBOKEN_API PyObject* referenceToPython(SbkObjectType *type, const void *cppIn);
-LIBSHIBOKEN_API PyObject* referenceToPython(const SbkConverter *converter, const void *cppIn);
+LIBSHIBOKEN_API PyObject *referenceToPython(SbkObjectType *type, const void *cppIn);
+LIBSHIBOKEN_API PyObject *referenceToPython(const SbkConverter *converter, const void *cppIn);
 
 /**
  *  Retrieves the Python wrapper object for the given C++ value pointed by \p cppIn.
  *  This function is used only for Value Types.
  *  Example usage:
  *      TYPE var;
- *      PyObject* pyVar = copyToPython(SBKTYPE, &var);
+ *      PyObject *pyVar = copyToPython(SBKTYPE, &var);
  */
-LIBSHIBOKEN_API PyObject* copyToPython(SbkObjectType *type, const void *cppIn);
-LIBSHIBOKEN_API PyObject* copyToPython(const SbkConverter *converter, const void *cppIn);
+LIBSHIBOKEN_API PyObject *copyToPython(SbkObjectType *type, const void *cppIn);
+LIBSHIBOKEN_API PyObject *copyToPython(const SbkConverter *converter, const void *cppIn);
 
 // Python -> C++ ---------------------------------------------------------------------------
 
@@ -250,10 +250,10 @@ LIBSHIBOKEN_API PythonToCppFunc isPythonToCppConvertible(const SbkArrayConverter
  *  It differs from Shiboken::Object::cppPointer because it casts the pointer to a proper
  *  memory offset depending on the desired type.
  */
-LIBSHIBOKEN_API void* cppPointer(PyTypeObject* desiredType, SbkObject* pyIn);
+LIBSHIBOKEN_API void *cppPointer(PyTypeObject *desiredType, SbkObject *pyIn);
 
 /// Converts a Python object \p pyIn to C++ and stores the result in the C++ pointer passed in \p cppOut.
-LIBSHIBOKEN_API void pythonToCppPointer(SbkObjectType* type, PyObject* pyIn, void* cppOut);
+LIBSHIBOKEN_API void pythonToCppPointer(SbkObjectType *type, PyObject *pyIn, void *cppOut);
 LIBSHIBOKEN_API void pythonToCppPointer(const SbkConverter *converter, PyObject *pyIn, void *cppOut);
 
 /// Converts a Python object \p pyIn to C++, and copies the result in the C++ variable passed in \p cppOut.
@@ -264,7 +264,7 @@ LIBSHIBOKEN_API void pythonToCppCopy(const SbkConverter *converter, PyObject *py
  *  Helper function returned by generated convertible checking functions
  *  that returns a C++ NULL when the input Python object is None.
  */
-LIBSHIBOKEN_API void nonePythonToCppNullPtr(PyObject*, void* cppOut);
+LIBSHIBOKEN_API void nonePythonToCppNullPtr(PyObject *, void *cppOut);
 
 /**
  *  Returns true if the \p toCpp function passed is an implicit conversion of Python \p type.
@@ -274,16 +274,16 @@ LIBSHIBOKEN_API void nonePythonToCppNullPtr(PyObject*, void* cppOut);
 LIBSHIBOKEN_API bool isImplicitConversion(SbkObjectType *type, PythonToCppFunc toCpp);
 
 /// Registers a converter with a type name that may be used to retrieve the converter.
-LIBSHIBOKEN_API void registerConverterName(SbkConverter* converter, const char* typeName);
+LIBSHIBOKEN_API void registerConverterName(SbkConverter *converter, const char *typeName);
 
 /// Returns the converter for a given type name, or NULL if it wasn't registered before.
-LIBSHIBOKEN_API SbkConverter* getConverter(const char* typeName);
+LIBSHIBOKEN_API SbkConverter *getConverter(const char *typeName);
 
 /// Returns the converter for a primitive type.
-LIBSHIBOKEN_API SbkConverter* primitiveTypeConverter(int index);
+LIBSHIBOKEN_API SbkConverter *primitiveTypeConverter(int index);
 
 /// Returns true if a Python sequence is comprised of objects of the given \p type.
-LIBSHIBOKEN_API bool checkSequenceTypes(PyTypeObject* type, PyObject* pyIn);
+LIBSHIBOKEN_API bool checkSequenceTypes(PyTypeObject *type, PyObject *pyIn);
 
 /// Returns true if a Python sequence is comprised of objects of a type convertible to the one represented by the given \p converter.
 LIBSHIBOKEN_API bool convertibleSequenceTypes(const SbkConverter *converter, PyObject *pyIn);
@@ -292,7 +292,7 @@ LIBSHIBOKEN_API bool convertibleSequenceTypes(const SbkConverter *converter, PyO
 LIBSHIBOKEN_API bool convertibleSequenceTypes(SbkObjectType *type, PyObject *pyIn);
 
 /// Returns true if a Python sequence can be converted to a C++ pair.
-LIBSHIBOKEN_API bool checkPairTypes(PyTypeObject* firstType, PyTypeObject* secondType, PyObject* pyIn);
+LIBSHIBOKEN_API bool checkPairTypes(PyTypeObject *firstType, PyTypeObject *secondType, PyObject *pyIn);
 
 /// Returns true if a Python sequence can be converted to a C++ pair.
 LIBSHIBOKEN_API bool convertiblePairTypes(const SbkConverter *firstConverter, bool firstCheckExact,
@@ -300,7 +300,7 @@ LIBSHIBOKEN_API bool convertiblePairTypes(const SbkConverter *firstConverter, bo
                                           PyObject *pyIn);
 
 /// Returns true if a Python dictionary can be converted to a C++ hash or map.
-LIBSHIBOKEN_API bool checkDictTypes(PyTypeObject* keyType, PyTypeObject* valueType, PyObject* pyIn);
+LIBSHIBOKEN_API bool checkDictTypes(PyTypeObject *keyType, PyTypeObject *valueType, PyObject *pyIn);
 
 /// Returns true if a Python dictionary can be converted to a C++ hash or map.
 LIBSHIBOKEN_API bool convertibleDictTypes(const SbkConverter *keyConverter, bool keyCheckExact,
@@ -308,10 +308,10 @@ LIBSHIBOKEN_API bool convertibleDictTypes(const SbkConverter *keyConverter, bool
                                           PyObject *pyIn);
 
 /// Returns the Python type object associated with the given \p converter.
-LIBSHIBOKEN_API PyTypeObject* getPythonTypeObject(const SbkConverter *converter);
+LIBSHIBOKEN_API PyTypeObject *getPythonTypeObject(const SbkConverter *converter);
 
 /// Returns the Python type object for the given \p typeName.
-LIBSHIBOKEN_API PyTypeObject* getPythonTypeObject(const char* typeName);
+LIBSHIBOKEN_API PyTypeObject *getPythonTypeObject(const char *typeName);
 
 /// Returns true if the Python type associated with the converter is a value type.
 LIBSHIBOKEN_API bool pythonTypeIsValueType(const SbkConverter *converter);
@@ -343,25 +343,25 @@ LIBSHIBOKEN_API bool pythonTypeIsWrapperType(const SbkConverter *converter);
 #define SBK_VOIDPTR_IDX                16
 #define SBK_NULLPTR_T_IDX              17
 
-template<typename T> SbkConverter* PrimitiveTypeConverter() { return 0; }
-template<> inline SbkConverter* PrimitiveTypeConverter<PY_LONG_LONG>() { return primitiveTypeConverter(SBK_PY_LONG_LONG_IDX); }
-template<> inline SbkConverter* PrimitiveTypeConverter<bool>() { return primitiveTypeConverter(SBK_BOOL_IDX_1); }
-template<> inline SbkConverter* PrimitiveTypeConverter<char>() { return primitiveTypeConverter(SBK_CHAR_IDX); }
-template<> inline SbkConverter* PrimitiveTypeConverter<const char*>() { return primitiveTypeConverter(SBK_CONSTCHARPTR_IDX); }
-template<> inline SbkConverter* PrimitiveTypeConverter<double>() { return primitiveTypeConverter(SBK_DOUBLE_IDX); }
-template<> inline SbkConverter* PrimitiveTypeConverter<float>() { return primitiveTypeConverter(SBK_FLOAT_IDX); }
-template<> inline SbkConverter* PrimitiveTypeConverter<int>() { return primitiveTypeConverter(SBK_INT_IDX); }
-template<> inline SbkConverter* PrimitiveTypeConverter<long>() { return primitiveTypeConverter(SBK_LONG_IDX); }
-template<> inline SbkConverter* PrimitiveTypeConverter<short>() { return primitiveTypeConverter(SBK_SHORT_IDX); }
-template<> inline SbkConverter* PrimitiveTypeConverter<signed char>() { return primitiveTypeConverter(SBK_SIGNEDCHAR_IDX); }
-template<> inline SbkConverter* PrimitiveTypeConverter<std::string>() { return primitiveTypeConverter(SBK_STD_STRING_IDX); }
-template<> inline SbkConverter* PrimitiveTypeConverter<unsigned PY_LONG_LONG>() { return primitiveTypeConverter(SBK_UNSIGNEDPY_LONG_LONG_IDX); }
-template<> inline SbkConverter* PrimitiveTypeConverter<unsigned char>() { return primitiveTypeConverter(SBK_UNSIGNEDCHAR_IDX); }
-template<> inline SbkConverter* PrimitiveTypeConverter<unsigned int>() { return primitiveTypeConverter(SBK_UNSIGNEDINT_IDX); }
-template<> inline SbkConverter* PrimitiveTypeConverter<unsigned long>() { return primitiveTypeConverter(SBK_UNSIGNEDLONG_IDX); }
-template<> inline SbkConverter* PrimitiveTypeConverter<unsigned short>() { return primitiveTypeConverter(SBK_UNSIGNEDSHORT_IDX); }
-template<> inline SbkConverter* PrimitiveTypeConverter<void*>() { return primitiveTypeConverter(SBK_VOIDPTR_IDX); }
-template<> inline SbkConverter* PrimitiveTypeConverter<std::nullptr_t>() { return primitiveTypeConverter(SBK_NULLPTR_T_IDX); }
+template<typename T> SbkConverter *PrimitiveTypeConverter() { return 0; }
+template<> inline SbkConverter *PrimitiveTypeConverter<PY_LONG_LONG>() { return primitiveTypeConverter(SBK_PY_LONG_LONG_IDX); }
+template<> inline SbkConverter *PrimitiveTypeConverter<bool>() { return primitiveTypeConverter(SBK_BOOL_IDX_1); }
+template<> inline SbkConverter *PrimitiveTypeConverter<char>() { return primitiveTypeConverter(SBK_CHAR_IDX); }
+template<> inline SbkConverter *PrimitiveTypeConverter<const char *>() { return primitiveTypeConverter(SBK_CONSTCHARPTR_IDX); }
+template<> inline SbkConverter *PrimitiveTypeConverter<double>() { return primitiveTypeConverter(SBK_DOUBLE_IDX); }
+template<> inline SbkConverter *PrimitiveTypeConverter<float>() { return primitiveTypeConverter(SBK_FLOAT_IDX); }
+template<> inline SbkConverter *PrimitiveTypeConverter<int>() { return primitiveTypeConverter(SBK_INT_IDX); }
+template<> inline SbkConverter *PrimitiveTypeConverter<long>() { return primitiveTypeConverter(SBK_LONG_IDX); }
+template<> inline SbkConverter *PrimitiveTypeConverter<short>() { return primitiveTypeConverter(SBK_SHORT_IDX); }
+template<> inline SbkConverter *PrimitiveTypeConverter<signed char>() { return primitiveTypeConverter(SBK_SIGNEDCHAR_IDX); }
+template<> inline SbkConverter *PrimitiveTypeConverter<std::string>() { return primitiveTypeConverter(SBK_STD_STRING_IDX); }
+template<> inline SbkConverter *PrimitiveTypeConverter<unsigned PY_LONG_LONG>() { return primitiveTypeConverter(SBK_UNSIGNEDPY_LONG_LONG_IDX); }
+template<> inline SbkConverter *PrimitiveTypeConverter<unsigned char>() { return primitiveTypeConverter(SBK_UNSIGNEDCHAR_IDX); }
+template<> inline SbkConverter *PrimitiveTypeConverter<unsigned int>() { return primitiveTypeConverter(SBK_UNSIGNEDINT_IDX); }
+template<> inline SbkConverter *PrimitiveTypeConverter<unsigned long>() { return primitiveTypeConverter(SBK_UNSIGNEDLONG_IDX); }
+template<> inline SbkConverter *PrimitiveTypeConverter<unsigned short>() { return primitiveTypeConverter(SBK_UNSIGNEDSHORT_IDX); }
+template<> inline SbkConverter *PrimitiveTypeConverter<void *>() { return primitiveTypeConverter(SBK_VOIDPTR_IDX); }
+template<> inline SbkConverter *PrimitiveTypeConverter<std::nullptr_t>() { return primitiveTypeConverter(SBK_NULLPTR_T_IDX); }
 
 } // namespace Shiboken::Conversions
 
@@ -371,24 +371,24 @@ template<> inline SbkConverter* PrimitiveTypeConverter<std::nullptr_t>() { retur
 *   T isn't a C++ primitive type.
 *   \see SpecialCastFunction
 */
-template<typename T> PyTypeObject* SbkType() { return 0; }
+template<typename T> PyTypeObject *SbkType() { return 0; }
 
 // Below are the template specializations for C++ primitive types.
-template<> inline PyTypeObject* SbkType<PY_LONG_LONG>() { return &PyLong_Type; }
-template<> inline PyTypeObject* SbkType<bool>() { return &PyBool_Type; }
-template<> inline PyTypeObject* SbkType<char>() { return &PyInt_Type; }
-template<> inline PyTypeObject* SbkType<double>() { return &PyFloat_Type; }
-template<> inline PyTypeObject* SbkType<float>() { return &PyFloat_Type; }
-template<> inline PyTypeObject* SbkType<int>() { return &PyInt_Type; }
-template<> inline PyTypeObject* SbkType<long>() { return &PyLong_Type; }
-template<> inline PyTypeObject* SbkType<short>() { return &PyInt_Type; }
-template<> inline PyTypeObject* SbkType<signed char>() { return &PyInt_Type; }
-template<> inline PyTypeObject* SbkType<unsigned PY_LONG_LONG>() { return &PyLong_Type; }
-template<> inline PyTypeObject* SbkType<unsigned char>() { return &PyInt_Type; }
-template<> inline PyTypeObject* SbkType<unsigned int>() { return &PyLong_Type; }
-template<> inline PyTypeObject* SbkType<unsigned long>() { return &PyLong_Type; }
-template<> inline PyTypeObject* SbkType<unsigned short>() { return &PyInt_Type; }
-template<> inline PyTypeObject* SbkType<std::nullptr_t>() { return Py_TYPE(&_Py_NoneStruct); }
+template<> inline PyTypeObject *SbkType<PY_LONG_LONG>() { return &PyLong_Type; }
+template<> inline PyTypeObject *SbkType<bool>() { return &PyBool_Type; }
+template<> inline PyTypeObject *SbkType<char>() { return &PyInt_Type; }
+template<> inline PyTypeObject *SbkType<double>() { return &PyFloat_Type; }
+template<> inline PyTypeObject *SbkType<float>() { return &PyFloat_Type; }
+template<> inline PyTypeObject *SbkType<int>() { return &PyInt_Type; }
+template<> inline PyTypeObject *SbkType<long>() { return &PyLong_Type; }
+template<> inline PyTypeObject *SbkType<short>() { return &PyInt_Type; }
+template<> inline PyTypeObject *SbkType<signed char>() { return &PyInt_Type; }
+template<> inline PyTypeObject *SbkType<unsigned PY_LONG_LONG>() { return &PyLong_Type; }
+template<> inline PyTypeObject *SbkType<unsigned char>() { return &PyInt_Type; }
+template<> inline PyTypeObject *SbkType<unsigned int>() { return &PyLong_Type; }
+template<> inline PyTypeObject *SbkType<unsigned long>() { return &PyLong_Type; }
+template<> inline PyTypeObject *SbkType<unsigned short>() { return &PyInt_Type; }
+template<> inline PyTypeObject *SbkType<std::nullptr_t>() { return Py_TYPE(&_Py_NoneStruct); }
 
 } // namespace Shiboken
 
@@ -398,7 +398,7 @@ template<> inline PyTypeObject* SbkType<std::nullptr_t>() { return Py_TYPE(&_Py_
 #define SbkChar_Check(X) (SbkNumber_Check(X) || Shiboken::String::checkChar(X))
 
 struct _SbkGenericTypePrivate {
-    SbkConverter** converter;
+    SbkConverter **converter;
 };
 
 
diff --git a/sources/shiboken2/libshiboken/sbkconverter_p.h b/sources/shiboken2/libshiboken/sbkconverter_p.h
index cb968ed89..aa90094af 100644
--- a/sources/shiboken2/libshiboken/sbkconverter_p.h
+++ b/sources/shiboken2/libshiboken/sbkconverter_p.h
@@ -69,7 +69,7 @@ struct SbkConverter
      *  Python type to which the C++ value will be converted (note that the
      *  C++ type could be produced from various Python types).
      */
-    PyTypeObject*           pythonType;
+    PyTypeObject *pythonType;
     /**
      *  This function converts a C++ object to a Python object of the type
      *  indicated in pythonType. The identity of the C++ object is kept,
@@ -77,7 +77,7 @@ struct SbkConverter
      *  with the C++ instance.
      *  It is used to convert C++ pointers and references to Python objects.
      */
-    CppToPythonFunc         pointerToPython;
+    CppToPythonFunc pointerToPython;
     /**
      *  This function converts a C++ object to a Python object of the type
      *  indicated in pythonType. The identity of the object is not kept,
@@ -86,17 +86,17 @@ struct SbkConverter
      *  reference can't be traced to an object that already has a Python
      *  wrapper assigned for it.
      */
-    CppToPythonFunc         copyToPython;
+    CppToPythonFunc copyToPython;
     /**
      *  This is a special case of a Python to C++ conversion. It returns
      *  the underlying C++ pointer of a Python wrapper passed as parameter
      *  or NULL if the Python object is a None value.
      *  It comes separated from the other toCppConversions because if you
      *  have a Python object representing a Value Type the type checking
-     *  for both ValueType and ValueType* would be the same, thus the first
+     *  for both ValueType and ValueType *would be the same, thus the first
      *  check would be true and the second would never be reached.
      */
-    ToCppConversion         toCppPointerConversion;
+    ToCppConversion toCppPointerConversion;
     /**
      *  This is a list of type checking functions that return the
      *  proper Python to C++ conversion function, for the given Python
@@ -104,14 +104,14 @@ struct SbkConverter
      *  For Object Types, that never have implicit conversions, this
      *  list is always empty.
      */
-    ToCppConversionVector   toCppConversions;
+    ToCppConversionVector toCppConversions;
 };
 
 } // extern "C"
 
 template<typename T, typename MaxLimitType, bool isSigned>
 struct OverFlowCheckerBase {
-    static void formatOverFlowMessage(const MaxLimitType& value,
+    static void formatOverFlowMessage(const MaxLimitType &value,
                                       const std::string *valueAsString = 0)
     {
         std::ostringstream str;
@@ -157,7 +157,7 @@ struct OverFlowChecker;
 template<typename T, typename MaxLimitType>
 struct OverFlowChecker<T, MaxLimitType, true> :
         public OverFlowCheckerBase<T, MaxLimitType, true> {
-    static bool check(const MaxLimitType& value, PyObject *pyIn)
+    static bool check(const MaxLimitType &value, PyObject *pyIn)
     {
         std::string valueAsString;
         const bool isOverflow =
@@ -173,7 +173,7 @@ struct OverFlowChecker<T, MaxLimitType, true> :
 template<typename T, typename MaxLimitType>
 struct OverFlowChecker<T, MaxLimitType, false>
         : public OverFlowCheckerBase<T, MaxLimitType, false> {
-    static bool check(const MaxLimitType& value, PyObject *pyIn)
+    static bool check(const MaxLimitType &value, PyObject *pyIn)
     {
         std::string valueAsString;
         const bool isOverflow =
@@ -204,7 +204,7 @@ struct OverFlowChecker<double, PY_LONG_LONG, true> {
 template<>
 struct OverFlowChecker<float, PY_LONG_LONG, true> :
         public OverFlowCheckerBase<float, PY_LONG_LONG, true> {
-    static bool check(const double& value, PyObject *)
+    static bool check(const double &value, PyObject *)
     {
         const bool result = value < std::numeric_limits<float>::min()
                 || value > std::numeric_limits<float>::max();
@@ -221,12 +221,12 @@ template <typename T> struct Primitive {};
 template <typename T>
 struct OnePrimitive
 {
-    static PyObject* toPython(const void*) { return 0; }
-    static PythonToCppFunc isConvertible(PyObject*) { return 0; }
-    static void toCpp(PyObject*, void*) {}
-    static SbkConverter* createConverter()
+    static PyObject *toPython(const void *) { return nullptr; }
+    static PythonToCppFunc isConvertible(PyObject *) { return nullptr; }
+    static void toCpp(PyObject *, void *) {}
+    static SbkConverter *createConverter()
     {
-        SbkConverter* converter = Shiboken::Conversions::createConverter(Shiboken::SbkType<T>(),
+        SbkConverter *converter = Shiboken::Conversions::createConverter(Shiboken::SbkType<T>(),
                                                                          Primitive<T>::toPython);
         Shiboken::Conversions::addPythonToCppValueConversion(converter,
                                                              Primitive<T>::toCpp,
@@ -237,11 +237,11 @@ struct OnePrimitive
 template <typename T>
 struct TwoPrimitive : OnePrimitive<T>
 {
-    static PythonToCppFunc isOtherConvertible(PyObject*) { return 0; }
-    static void otherToCpp(PyObject*, void*) {}
-    static SbkConverter* createConverter()
+    static PythonToCppFunc isOtherConvertible(PyObject *) { return nullptr; }
+    static void otherToCpp(PyObject *, void *) {}
+    static SbkConverter *createConverter()
     {
-        SbkConverter* converter = OnePrimitive<T>::createConverter();
+        SbkConverter *converter = OnePrimitive<T>::createConverter();
         Shiboken::Conversions::addPythonToCppValueConversion(converter, Primitive<T>::otherToCpp, Primitive<T>::isOtherConvertible);
         return converter;
     }
@@ -252,11 +252,11 @@ struct TwoPrimitive : OnePrimitive<T>
 template <typename INT>
 struct IntPrimitive : TwoPrimitive<INT>
 {
-    static PyObject* toPython(const void* cppIn)
+    static PyObject *toPython(const void *cppIn)
     {
         return PyInt_FromLong(*reinterpret_cast<const INT *>(cppIn));
     }
-    static void toCpp(PyObject* pyIn, void* cppOut)
+    static void toCpp(PyObject *pyIn, void *cppOut)
     {
         double result = PyFloat_AS_DOUBLE(pyIn);
         // If cast to long directly it could overflow silently.
@@ -264,20 +264,20 @@ struct IntPrimitive : TwoPrimitive<INT>
             PyErr_SetObject(PyExc_OverflowError, 0);
         *reinterpret_cast<INT * >(cppOut) = static_cast<INT>(result);
     }
-    static PythonToCppFunc isConvertible(PyObject* pyIn)
+    static PythonToCppFunc isConvertible(PyObject *pyIn)
     {
         if (PyFloat_Check(pyIn))
             return toCpp;
         return 0;
     }
-    static void otherToCpp(PyObject* pyIn, void* cppOut)
+    static void otherToCpp(PyObject *pyIn, void *cppOut)
     {
         PY_LONG_LONG result = PyLong_AsLongLong(pyIn);
         if (OverFlowChecker<INT>::check(result, pyIn))
             PyErr_SetObject(PyExc_OverflowError, 0);
         *reinterpret_cast<INT * >(cppOut) = static_cast<INT>(result);
     }
-    static PythonToCppFunc isOtherConvertible(PyObject* pyIn)
+    static PythonToCppFunc isOtherConvertible(PyObject *pyIn)
     {
         if (SbkNumber_Check(pyIn))
             return otherToCpp;
@@ -294,7 +294,7 @@ template <> struct Primitive<unsigned short> : IntPrimitive<unsigned short> {};
 template <typename LONG>
 struct UnsignedLongPrimitive : IntPrimitive<LONG>
 {
-    static PyObject* toPython(const void* cppIn)
+    static PyObject *toPython(const void *cppIn)
     {
         return PyLong_FromUnsignedLong(*reinterpret_cast<const LONG *>(cppIn));
     }
@@ -307,18 +307,18 @@ template <> struct Primitive<unsigned long> : UnsignedLongPrimitive<unsigned lon
 template <>
 struct Primitive<PY_LONG_LONG> : OnePrimitive<PY_LONG_LONG>
 {
-    static PyObject* toPython(const void* cppIn)
+    static PyObject *toPython(const void *cppIn)
     {
-        return PyLong_FromLongLong(*((PY_LONG_LONG*)cppIn));
+        return PyLong_FromLongLong(*reinterpret_cast<const PY_LONG_LONG *>(cppIn));
     }
-    static void toCpp(PyObject* pyIn, void* cppOut)
+    static void toCpp(PyObject *pyIn, void *cppOut)
     {
         PY_LONG_LONG result = PyLong_AsLongLong(pyIn);
         if (OverFlowChecker<PY_LONG_LONG>::check(result, pyIn))
             PyErr_SetObject(PyExc_OverflowError, 0);
         *reinterpret_cast<PY_LONG_LONG * >(cppOut) = result;
     }
-    static PythonToCppFunc isConvertible(PyObject* pyIn)
+    static PythonToCppFunc isConvertible(PyObject *pyIn)
     {
         if (SbkNumber_Check(pyIn))
             return toCpp;
@@ -329,11 +329,11 @@ struct Primitive<PY_LONG_LONG> : OnePrimitive<PY_LONG_LONG>
 template <>
 struct Primitive<unsigned PY_LONG_LONG> : OnePrimitive<unsigned PY_LONG_LONG>
 {
-    static PyObject* toPython(const void* cppIn)
+    static PyObject *toPython(const void *cppIn)
     {
-        return PyLong_FromUnsignedLongLong(*((unsigned PY_LONG_LONG*)cppIn));
+        return PyLong_FromUnsignedLongLong(*reinterpret_cast<const unsigned PY_LONG_LONG *>(cppIn));
     }
-    static void toCpp(PyObject* pyIn, void* cppOut)
+    static void toCpp(PyObject *pyIn, void *cppOut)
     {
 #if PY_MAJOR_VERSION >= 3
         if (PyLong_Check(pyIn)) {
@@ -362,7 +362,7 @@ struct Primitive<unsigned PY_LONG_LONG> : OnePrimitive<unsigned PY_LONG_LONG>
         }
 #endif // Python 2
     }
-    static PythonToCppFunc isConvertible(PyObject* pyIn)
+    static PythonToCppFunc isConvertible(PyObject *pyIn)
     {
         if (SbkNumber_Check(pyIn))
             return toCpp;
@@ -375,25 +375,25 @@ struct Primitive<unsigned PY_LONG_LONG> : OnePrimitive<unsigned PY_LONG_LONG>
 template <typename FLOAT>
 struct FloatPrimitive : TwoPrimitive<FLOAT>
 {
-    static PyObject* toPython(const void* cppIn)
+    static PyObject *toPython(const void *cppIn)
     {
         return PyFloat_FromDouble(*reinterpret_cast<const FLOAT *>(cppIn));
     }
-    static void toCpp(PyObject* pyIn, void* cppOut)
+    static void toCpp(PyObject *pyIn, void *cppOut)
     {
         *reinterpret_cast<FLOAT *>(cppOut) = FLOAT(PyLong_AsLong(pyIn));
     }
-    static PythonToCppFunc isConvertible(PyObject* pyIn)
+    static PythonToCppFunc isConvertible(PyObject *pyIn)
     {
         if (PyInt_Check(pyIn) || PyLong_Check(pyIn))
             return toCpp;
         return 0;
     }
-    static void otherToCpp(PyObject* pyIn, void* cppOut)
+    static void otherToCpp(PyObject *pyIn, void *cppOut)
     {
         *reinterpret_cast<FLOAT *>(cppOut) = FLOAT(PyFloat_AsDouble(pyIn));
     }
-    static PythonToCppFunc isOtherConvertible(PyObject* pyIn)
+    static PythonToCppFunc isOtherConvertible(PyObject *pyIn)
     {
         if (SbkNumber_Check(pyIn))
             return otherToCpp;
@@ -408,17 +408,17 @@ template <> struct Primitive<double> : FloatPrimitive<double> {};
 template <>
 struct Primitive<bool> : OnePrimitive<bool>
 {
-    static PyObject* toPython(const void* cppIn)
+    static PyObject *toPython(const void *cppIn)
     {
         return PyBool_FromLong(*reinterpret_cast<const bool *>(cppIn));
     }
-    static PythonToCppFunc isConvertible(PyObject* pyIn)
+    static PythonToCppFunc isConvertible(PyObject *pyIn)
     {
         if (SbkNumber_Check(pyIn))
             return toCpp;
         return 0;
     }
-    static void toCpp(PyObject* pyIn, void* cppOut)
+    static void toCpp(PyObject *pyIn, void *cppOut)
     {
         *reinterpret_cast<bool *>(cppOut) = PyInt_AS_LONG(pyIn) != 0;
     }
@@ -429,32 +429,32 @@ struct Primitive<bool> : OnePrimitive<bool>
 template <typename CHAR>
 struct CharPrimitive : IntPrimitive<CHAR>
 {
-    static void toCpp(PyObject* pyIn, void* cppOut)
+    static void toCpp(PyObject *pyIn, void *cppOut)
     {
         *reinterpret_cast<CHAR *>(cppOut) = CHAR(Shiboken::String::toCString(pyIn)[0]);
     }
-    static PythonToCppFunc isConvertible(PyObject* pyIn)
+    static PythonToCppFunc isConvertible(PyObject *pyIn)
     {
         if (Shiboken::String::checkChar(pyIn))
             return toCpp;
         return 0;
     }
-    static void otherToCpp(PyObject* pyIn, void* cppOut)
+    static void otherToCpp(PyObject *pyIn, void *cppOut)
     {
         PY_LONG_LONG result = PyLong_AsLongLong(pyIn);
         if (OverFlowChecker<CHAR>::check(result, pyIn))
             PyErr_SetObject(PyExc_OverflowError, 0);
         *reinterpret_cast<CHAR *>(cppOut) = CHAR(result);
     }
-    static PythonToCppFunc isOtherConvertible(PyObject* pyIn)
+    static PythonToCppFunc isOtherConvertible(PyObject *pyIn)
     {
         if (SbkNumber_Check(pyIn))
             return otherToCpp;
         return 0;
     }
-    static SbkConverter* createConverter()
+    static SbkConverter *createConverter()
     {
-        SbkConverter* converter = IntPrimitive<CHAR>::createConverter();
+        SbkConverter *converter = IntPrimitive<CHAR>::createConverter();
         Shiboken::Conversions::addPythonToCppValueConversion(converter, CharPrimitive<CHAR>::otherToCpp, CharPrimitive<CHAR>::isOtherConvertible);
         return converter;
     }
@@ -464,8 +464,8 @@ template <> struct Primitive<signed char> : CharPrimitive<signed char> {};
 template <> struct Primitive<unsigned char> : CharPrimitive<unsigned char> {};
 template <> struct Primitive<char> : CharPrimitive<char> {
     using CharPrimitive<char>::toPython;
-    static PyObject* toPython(const void* cppIn) {
-        return Shiboken::String::fromCString((const char*)cppIn, 1);
+    static PyObject *toPython(const void *cppIn) {
+        return Shiboken::String::fromCString(reinterpret_cast<const char *>(cppIn), 1);
     }
 };
 
@@ -474,29 +474,29 @@ template <> struct Primitive<char> : CharPrimitive<char> {
 // Strings ---------------------------------------------------------------------------------
 
 template <>
-struct Primitive<const char*> : TwoPrimitive<const char*>
+struct Primitive<const char *> : TwoPrimitive<const char *>
 {
-    static PyObject* toPython(const void* cppIn)
+    static PyObject *toPython(const void *cppIn)
     {
         if (!cppIn)
             Py_RETURN_NONE;
-        return Shiboken::String::fromCString((const char*)cppIn);
+        return Shiboken::String::fromCString(reinterpret_cast<const char *>(cppIn));
     }
     static void toCpp(PyObject *, void *cppOut)
     {
-        *((const char**)cppOut) = 0;
+        *((const char **)cppOut) = 0;
     }
-    static PythonToCppFunc isConvertible(PyObject* pyIn)
+    static PythonToCppFunc isConvertible(PyObject *pyIn)
     {
         if (pyIn == Py_None)
             return toCpp;
         return 0;
     }
-    static void otherToCpp(PyObject* pyIn, void* cppOut)
+    static void otherToCpp(PyObject *pyIn, void *cppOut)
     {
-        *((const char**)cppOut) = (const char*) Shiboken::String::toCString(pyIn);
+        *reinterpret_cast<const char **>(cppOut) = Shiboken::String::toCString(pyIn);
     }
-    static PythonToCppFunc isOtherConvertible(PyObject* pyIn)
+    static PythonToCppFunc isOtherConvertible(PyObject *pyIn)
     {
         if (Shiboken::String::check(pyIn))
             return otherToCpp;
@@ -507,25 +507,25 @@ struct Primitive<const char*> : TwoPrimitive<const char*>
 template <>
 struct Primitive<std::string> : TwoPrimitive<std::string>
 {
-    static PyObject* toPython(const void* cppIn)
+    static PyObject *toPython(const void *cppIn)
     {
-        return Shiboken::String::fromCString(((std::string*)cppIn)->c_str());
+        return Shiboken::String::fromCString(reinterpret_cast<const std::string *>(cppIn)->c_str());
     }
     static void toCpp(PyObject *, void *cppOut)
     {
-        *((std::string*)cppOut) = std::string();
+        reinterpret_cast<std::string *>(cppOut)->clear();
     }
-    static PythonToCppFunc isConvertible(PyObject* pyIn)
+    static PythonToCppFunc isConvertible(PyObject *pyIn)
     {
         if (pyIn == Py_None)
             return toCpp;
         return 0;
     }
-    static void otherToCpp(PyObject* pyIn, void* cppOut)
+    static void otherToCpp(PyObject *pyIn, void *cppOut)
     {
-        *((std::string*)cppOut) = Shiboken::String::toCString(pyIn);
+        reinterpret_cast<std::string *>(cppOut)->assign(Shiboken::String::toCString(pyIn));
     }
-    static PythonToCppFunc isOtherConvertible(PyObject* pyIn)
+    static PythonToCppFunc isOtherConvertible(PyObject *pyIn)
     {
         if (Shiboken::String::check(pyIn))
             return otherToCpp;
@@ -537,25 +537,25 @@ struct Primitive<std::string> : TwoPrimitive<std::string>
 template <>
 struct Primitive<std::nullptr_t> : TwoPrimitive<std::nullptr_t>
 {
-    static PyObject* toPython(const void* cppIn)
+    static PyObject *toPython(const void *cppIn)
     {
         return Py_None;
     }
     static void toCpp(PyObject *, void *cppOut)
     {
-        *reinterpret_cast<std::nullptr_t*>(cppOut) = nullptr;
+        *reinterpret_cast<std::nullptr_t *>(cppOut) = nullptr;
     }
-    static PythonToCppFunc isConvertible(PyObject* pyIn)
+    static PythonToCppFunc isConvertible(PyObject *pyIn)
     {
         if (pyIn == Py_None)
             return toCpp;
         return nullptr;
     }
-    static void otherToCpp(PyObject* pyIn, void* cppOut)
+    static void otherToCpp(PyObject *pyIn, void *cppOut)
     {
-        *reinterpret_cast<std::nullptr_t*>(cppOut) = nullptr;
+        *reinterpret_cast<std::nullptr_t *>(cppOut) = nullptr;
     }
-    static PythonToCppFunc isOtherConvertible(PyObject* pyIn)
+    static PythonToCppFunc isOtherConvertible(PyObject *pyIn)
     {
         if (pyIn == nullptr)
             return otherToCpp;
diff --git a/sources/shiboken2/libshiboken/sbkdbg.h b/sources/shiboken2/libshiboken/sbkdbg.h
index fdaf2a27a..02ea773ac 100644
--- a/sources/shiboken2/libshiboken/sbkdbg.h
+++ b/sources/shiboken2/libshiboken/sbkdbg.h
@@ -63,20 +63,20 @@
 class BaseLogger
 {
 public:
-    BaseLogger(const BaseLogger&) = delete;
-    BaseLogger(BaseLogger&&) = delete;
-    BaseLogger& operator=(const BaseLogger&) = delete;
-    BaseLogger& operator=(BaseLogger&&) = delete;
+    BaseLogger(const BaseLogger &) = delete;
+    BaseLogger(BaseLogger &&) = delete;
+    BaseLogger &operator=(const BaseLogger &) = delete;
+    BaseLogger &operator=(BaseLogger &&) = delete;
 
-    BaseLogger(std::ostream& output, const char* function, const char* context)
+    BaseLogger(std::ostream &output, const char *function, const char *context)
         : m_stream(output), m_function(function), m_context(context) {}
     ~BaseLogger()
     {
         m_stream << std::endl;
     }
-    std::ostream& operator()() { return m_stream; };
+    std::ostream &operator()() { return m_stream; };
     template <typename T>
-    std::ostream& operator<<(const T& t)
+    std::ostream &operator<<(const T &t)
     {
         m_stream << '[';
         if (m_context[0])
@@ -84,24 +84,24 @@ public:
         return m_stream << COLOR_WHITE << m_function << COLOR_END << "] " << t;
     }
 private:
-    std::ostream& m_stream;
-    const char* m_function;
-    const char* m_context;
+    std::ostream &m_stream;
+    const char *m_function;
+    const char *m_context;
 };
 
-inline std::ostream& operator<<(std::ostream& out, PyObject* obj)
+inline std::ostream &operator<<(std::ostream &out, PyObject *obj)
 {
-    PyObject* repr = Shiboken::Object::isValid(obj, false) ? PyObject_Repr(obj) : 0;
+    PyObject *repr = Shiboken::Object::isValid(obj, false) ? PyObject_Repr(obj) : 0;
     if (repr) {
 #ifdef IS_PY3K
-        PyObject* str = PyUnicode_AsUTF8String(repr);
+        PyObject *str = PyUnicode_AsUTF8String(repr);
         Py_DECREF(repr);
         repr = str;
 #endif
         out << PyBytes_AS_STRING(repr);
         Py_DECREF(repr);
     } else {
-        out << reinterpret_cast<void*>(obj);
+        out << reinterpret_cast<void *>(obj);
     }
     return out;
 }
@@ -109,7 +109,7 @@ inline std::ostream& operator<<(std::ostream& out, PyObject* obj)
 class _SbkDbg : public BaseLogger
 {
 public:
-    _SbkDbg(const char* function, const char* context = "") : BaseLogger(std::cout, function, context) {}
+    _SbkDbg(const char *function, const char *context = "") : BaseLogger(std::cout, function, context) {}
 };
 
 #ifdef __GNUG__
@@ -122,7 +122,7 @@ public:
 
 struct SbkDbg {
     template <typename T>
-    SbkDbg& operator<<(const T&) { return *this; }
+    SbkDbg &operator<<(const T &) { return *this; }
 };
 
 #endif
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);
 }
diff --git a/sources/shiboken2/libshiboken/sbkenum.h b/sources/shiboken2/libshiboken/sbkenum.h
index c1ec7c4c1..199027836 100644
--- a/sources/shiboken2/libshiboken/sbkenum.h
+++ b/sources/shiboken2/libshiboken/sbkenum.h
@@ -57,14 +57,14 @@ struct SbkEnumTypePrivate;
 namespace Shiboken
 {
 
-inline bool isShibokenEnum(PyObject* pyObj)
+inline bool isShibokenEnum(PyObject *pyObj)
 {
     return Py_TYPE(Py_TYPE(pyObj)) == SbkEnumType_TypeF();
 }
 
 namespace Enum
 {
-    LIBSHIBOKEN_API bool check(PyObject* obj);
+    LIBSHIBOKEN_API bool check(PyObject *obj);
     /**
      *  Creates a new enum type (and its flags type, if any is given)
      *  and registers it to Python and adds it to \p module.
@@ -75,17 +75,17 @@ namespace Enum
      *  \param flagsType    Optional Python type for the flags associated with the enum.
      *  \return The new enum type or NULL if it fails.
      */
-    LIBSHIBOKEN_API PyTypeObject* createGlobalEnum(PyObject* module,
-                                                   const char* name,
-                                                   const char* fullName,
-                                                   const char* cppName,
-                                                   PyTypeObject* flagsType = 0);
+    LIBSHIBOKEN_API PyTypeObject *createGlobalEnum(PyObject *module,
+                                                   const char *name,
+                                                   const char *fullName,
+                                                   const char *cppName,
+                                                   PyTypeObject *flagsType = nullptr);
     /// This function does the same as createGlobalEnum, but adds the enum to a Shiboken type or namespace.
-    LIBSHIBOKEN_API PyTypeObject* createScopedEnum(SbkObjectType* scope,
-                                                   const char* name,
-                                                   const char* fullName,
-                                                   const char* cppName,
-                                                   PyTypeObject* flagsType = 0);
+    LIBSHIBOKEN_API PyTypeObject *createScopedEnum(SbkObjectType *scope,
+                                                   const char *name,
+                                                   const char *fullName,
+                                                   const char *cppName,
+                                                   PyTypeObject *flagsType = nullptr);
 
     /**
      *  Creates a new enum item for a given enum type and adds it to \p module.
@@ -95,25 +95,25 @@ namespace Enum
      *  \param itemValue Numerical value of the enum item.
      *  \return true if everything goes fine, false if it fails.
      */
-    LIBSHIBOKEN_API bool createGlobalEnumItem(PyTypeObject* enumType, PyObject* module, const char* itemName, long itemValue);
+    LIBSHIBOKEN_API bool createGlobalEnumItem(PyTypeObject *enumType, PyObject *module, const char *itemName, long itemValue);
     /// This function does the same as createGlobalEnumItem, but adds the enum to a Shiboken type or namespace.
     LIBSHIBOKEN_API bool createScopedEnumItem(PyTypeObject *enumType, PyTypeObject *scope,
                                               const char *itemName, long itemValue);
-    LIBSHIBOKEN_API bool createScopedEnumItem(PyTypeObject* enumType, SbkObjectType* scope, const char* itemName, long itemValue);
+    LIBSHIBOKEN_API bool createScopedEnumItem(PyTypeObject *enumType, SbkObjectType *scope, const char *itemName, long itemValue);
 
-    LIBSHIBOKEN_API PyObject* newItem(PyTypeObject* enumType, long itemValue, const char* itemName = 0);
+    LIBSHIBOKEN_API PyObject *newItem(PyTypeObject *enumType, long itemValue, const char *itemName = 0);
 
-    LIBSHIBOKEN_API PyTypeObject* newTypeWithName(const char* name, const char* cppName,
+    LIBSHIBOKEN_API PyTypeObject *newTypeWithName(const char *name, const char *cppName,
                                                   PyTypeObject *numbers_fromFlag=nullptr);
-    LIBSHIBOKEN_API const char* getCppName(PyTypeObject* type);
+    LIBSHIBOKEN_API const char *getCppName(PyTypeObject *type);
 
-    LIBSHIBOKEN_API long getValue(PyObject* enumItem);
-    LIBSHIBOKEN_API PyObject* getEnumItemFromValue(PyTypeObject* enumType, long itemValue);
+    LIBSHIBOKEN_API long getValue(PyObject *enumItem);
+    LIBSHIBOKEN_API PyObject *getEnumItemFromValue(PyTypeObject *enumType, long itemValue);
 
     /// Sets the enum's type converter.
-    LIBSHIBOKEN_API void setTypeConverter(PyTypeObject* enumType, SbkConverter* converter);
+    LIBSHIBOKEN_API void setTypeConverter(PyTypeObject *enumType, SbkConverter *converter);
     /// Returns the converter assigned to the enum \p type.
-    LIBSHIBOKEN_API SbkConverter* getTypeConverter(PyTypeObject* enumType);
+    LIBSHIBOKEN_API SbkConverter *getTypeConverter(PyTypeObject *enumType);
 }
 
 } // namespace Shiboken
diff --git a/sources/shiboken2/libshiboken/sbkmodule.cpp b/sources/shiboken2/libshiboken/sbkmodule.cpp
index a29ec38c7..7bfbf51a8 100644
--- a/sources/shiboken2/libshiboken/sbkmodule.cpp
+++ b/sources/shiboken2/libshiboken/sbkmodule.cpp
@@ -57,10 +57,10 @@ namespace Shiboken
 namespace Module
 {
 
-PyObject* import(const char* moduleName)
+PyObject *import(const char *moduleName)
 {
-    PyObject* sysModules = PyImport_GetModuleDict();
-    PyObject* module = PyDict_GetItemString(sysModules, moduleName);
+    PyObject *sysModules = PyImport_GetModuleDict();
+    PyObject *module = PyDict_GetItemString(sysModules, moduleName);
     if (module)
         Py_INCREF(module);
     else
@@ -72,37 +72,37 @@ PyObject* import(const char* moduleName)
     return module;
 }
 
-PyObject* create(const char* moduleName, void* moduleData)
+PyObject *create(const char *moduleName, void *moduleData)
 {
     Shiboken::init();
 #ifndef IS_PY3K
     return Py_InitModule(moduleName, reinterpret_cast<PyMethodDef *>(moduleData));
 #else
-    return PyModule_Create(reinterpret_cast<PyModuleDef*>(moduleData));
+    return PyModule_Create(reinterpret_cast<PyModuleDef *>(moduleData));
 #endif
 }
 
-void registerTypes(PyObject* module, PyTypeObject** types)
+void registerTypes(PyObject *module, PyTypeObject **types)
 {
     ModuleTypesMap::iterator iter = moduleTypes.find(module);
     if (iter == moduleTypes.end())
         moduleTypes.insert(std::make_pair(module, types));
 }
 
-PyTypeObject** getTypes(PyObject* module)
+PyTypeObject **getTypes(PyObject *module)
 {
     ModuleTypesMap::iterator iter = moduleTypes.find(module);
     return (iter == moduleTypes.end()) ? 0 : iter->second;
 }
 
-void registerTypeConverters(PyObject* module, SbkConverter** converters)
+void registerTypeConverters(PyObject *module, SbkConverter **converters)
 {
     ModuleConvertersMap::iterator iter = moduleConverters.find(module);
     if (iter == moduleConverters.end())
         moduleConverters.insert(std::make_pair(module, converters));
 }
 
-SbkConverter** getTypeConverters(PyObject* module)
+SbkConverter **getTypeConverters(PyObject *module)
 {
     ModuleConvertersMap::iterator iter = moduleConverters.find(module);
     return (iter == moduleConverters.end()) ? 0 : iter->second;
diff --git a/sources/shiboken2/libshiboken/sbkmodule.h b/sources/shiboken2/libshiboken/sbkmodule.h
index 659c41c4d..75eff5a79 100644
--- a/sources/shiboken2/libshiboken/sbkmodule.h
+++ b/sources/shiboken2/libshiboken/sbkmodule.h
@@ -46,7 +46,7 @@
 #if PY_MAJOR_VERSION >= 3
     #define SBK_MODULE_INIT_ERROR 0
     #define SBK_MODULE_INIT_FUNCTION_BEGIN(ModuleName) \
-        extern "C" SBK_EXPORT_MODULE PyObject* PyInit_##ModuleName() {
+        extern "C" SBK_EXPORT_MODULE PyObject *PyInit_##ModuleName() {
 
     #define SBK_MODULE_INIT_FUNCTION_END \
         return module; }
@@ -72,43 +72,43 @@ namespace Module {
  *  If the module is already imported, it increments its reference count before returning it.
  *  \returns the module specified in \p moduleName or NULL if an error occurs.
  */
-LIBSHIBOKEN_API PyObject* import(const char* moduleName);
+LIBSHIBOKEN_API PyObject *import(const char *moduleName);
 
 /**
  *  Creates a new Python module named \p moduleName using the information passed in \p moduleData.
- *  In fact, \p moduleData expects a "PyMethodDef*" object, but that's for Python 2. A void*
+ *  In fact, \p moduleData expects a "PyMethodDef *" object, but that's for Python 2. A "void*"
  *  was preferred to make this work with future Python 3 support.
  *  \returns a newly created module.
  */
-LIBSHIBOKEN_API PyObject* create(const char* moduleName, void* moduleData);
+LIBSHIBOKEN_API PyObject *create(const char *moduleName, void *moduleData);
 
 /**
  *  Registers the list of types created by \p module.
  *  \param module   Module where the types were created.
- *  \param types    Array of PyTypeObject* objects representing the types created on \p module.
+ *  \param types    Array of PyTypeObject *objects representing the types created on \p module.
  */
-LIBSHIBOKEN_API void registerTypes(PyObject* module, PyTypeObject** types);
+LIBSHIBOKEN_API void registerTypes(PyObject *module, PyTypeObject **types);
 
 /**
  *  Retrieves the array of types.
  *  \param module   Module where the types were created.
- *  \returns        A pointer to the PyTypeObject* array of types.
+ *  \returns        A pointer to the PyTypeObject *array of types.
  */
-LIBSHIBOKEN_API PyTypeObject** getTypes(PyObject* module);
+LIBSHIBOKEN_API PyTypeObject **getTypes(PyObject *module);
 
 /**
  *  Registers the list of converters created by \p module for non-wrapper types.
  *  \param module       Module where the converters were created.
- *  \param converters   Array of SbkConverter* objects representing the converters created on \p module.
+ *  \param converters   Array of SbkConverter *objects representing the converters created on \p module.
  */
-LIBSHIBOKEN_API void registerTypeConverters(PyObject* module, SbkConverter** converters);
+LIBSHIBOKEN_API void registerTypeConverters(PyObject *module, SbkConverter **converters);
 
 /**
  *  Retrieves the array of converters.
  *  \param module   Module where the converters were created.
- *  \returns        A pointer to the SbkConverter* array of converters.
+ *  \returns        A pointer to the SbkConverter *array of converters.
  */
-LIBSHIBOKEN_API SbkConverter** getTypeConverters(PyObject* module);
+LIBSHIBOKEN_API SbkConverter **getTypeConverters(PyObject *module);
 
 } } // namespace Shiboken::Module
 
diff --git a/sources/shiboken2/libshiboken/sbkstring.cpp b/sources/shiboken2/libshiboken/sbkstring.cpp
index a3ffcdabb..d3c337524 100644
--- a/sources/shiboken2/libshiboken/sbkstring.cpp
+++ b/sources/shiboken2/libshiboken/sbkstring.cpp
@@ -46,7 +46,7 @@ namespace Shiboken
 namespace String
 {
 
-bool checkType(PyTypeObject* type)
+bool checkType(PyTypeObject *type)
 {
     return type == &PyUnicode_Type
 #if PY_MAJOR_VERSION < 3
@@ -55,7 +55,7 @@ bool checkType(PyTypeObject* type)
     ;
 }
 
-bool check(PyObject* obj)
+bool check(PyObject *obj)
 {
     return obj == Py_None ||
 #if PY_MAJOR_VERSION < 3
@@ -64,17 +64,17 @@ bool check(PyObject* obj)
         PyUnicode_Check(obj);
 }
 
-bool checkChar(PyObject* pyobj)
+bool checkChar(PyObject *pyobj)
 {
     return check(pyobj) && (len(pyobj) == 1);
 }
 
-bool isConvertible(PyObject* obj)
+bool isConvertible(PyObject *obj)
 {
     return check(obj);
 }
 
-PyObject* fromCString(const char* value)
+PyObject *fromCString(const char *value)
 {
 #ifdef IS_PY3K
     return PyUnicode_FromString(value);
@@ -83,7 +83,7 @@ PyObject* fromCString(const char* value)
 #endif
 }
 
-PyObject* fromCString(const char* value, int len)
+PyObject *fromCString(const char *value, int len)
 {
 #ifdef IS_PY3K
     return PyUnicode_FromStringAndSize(value, len);
@@ -92,13 +92,13 @@ PyObject* fromCString(const char* value, int len)
 #endif
 }
 
-const char* toCString(PyObject* str, Py_ssize_t* len)
+const char *toCString(PyObject *str, Py_ssize_t *len)
 {
     if (str == Py_None)
         return NULL;
     if (PyUnicode_Check(str)) {
         if (len) {
-            // We need to encode the unicode string into utf8 to know the size of returned char*.
+            // We need to encode the unicode string into utf8 to know the size of returned char *.
             Shiboken::AutoDecRef uniStr(PyUnicode_AsUTF8String(str));
             *len = PyBytes_GET_SIZE(uniStr.object());
         }
@@ -122,10 +122,10 @@ const char* toCString(PyObject* str, Py_ssize_t* len)
     return 0;
 }
 
-bool concat(PyObject** val1, PyObject* val2)
+bool concat(PyObject **val1, PyObject *val2)
 {
     if (PyUnicode_Check(*val1) && PyUnicode_Check(val2)) {
-        PyObject* result = PyUnicode_Concat(*val1, val2);
+        PyObject *result = PyUnicode_Concat(*val1, val2);
         Py_DECREF(*val1);
         *val1 = result;
         return true;
@@ -145,11 +145,11 @@ bool concat(PyObject** val1, PyObject* val2)
     return false;
 }
 
-PyObject* fromFormat(const char* format, ...)
+PyObject *fromFormat(const char *format, ...)
 {
     va_list argp;
     va_start(argp, format);
-    PyObject* result = 0;
+    PyObject *result = nullptr;
 #ifdef IS_PY3K
     result = PyUnicode_FromFormatV(format, argp);
 #else
@@ -159,7 +159,7 @@ PyObject* fromFormat(const char* format, ...)
     return result;
 }
 
-PyObject* fromStringAndSize(const char* str, Py_ssize_t size)
+PyObject *fromStringAndSize(const char *str, Py_ssize_t size)
 {
 #ifdef IS_PY3K
     return PyUnicode_FromStringAndSize(str, size);
@@ -168,15 +168,15 @@ PyObject* fromStringAndSize(const char* str, Py_ssize_t size)
 #endif
 }
 
-int compare(PyObject* val1, const char* val2)
+int compare(PyObject *val1, const char *val2)
 {
     if (PyUnicode_Check(val1))
 #ifdef IS_PY3K
        return PyUnicode_CompareWithASCIIString(val1, val2);
 #else
     {
-        PyObject* uVal2 = PyUnicode_FromString(val2);
-        bool result =  PyUnicode_Compare(val1, uVal2);
+        PyObject *uVal2 = PyUnicode_FromString(val2);
+        bool result = PyUnicode_Compare(val1, uVal2);
         Py_XDECREF(uVal2);
         return result;
     }
@@ -187,7 +187,7 @@ int compare(PyObject* val1, const char* val2)
 
 }
 
-Py_ssize_t len(PyObject* str)
+Py_ssize_t len(PyObject *str)
 {
     if (str == Py_None)
         return 0;
diff --git a/sources/shiboken2/libshiboken/sbkstring.h b/sources/shiboken2/libshiboken/sbkstring.h
index a6b5fbeed..ec674ee7b 100644
--- a/sources/shiboken2/libshiboken/sbkstring.h
+++ b/sources/shiboken2/libshiboken/sbkstring.h
@@ -53,18 +53,18 @@ namespace Shiboken
 {
 namespace String
 {
-    LIBSHIBOKEN_API bool check(PyObject* obj);
-    LIBSHIBOKEN_API bool checkType(PyTypeObject* obj);
-    LIBSHIBOKEN_API bool checkChar(PyObject* obj);
-    LIBSHIBOKEN_API bool isConvertible(PyObject* obj);
-    LIBSHIBOKEN_API PyObject* fromCString(const char* value);
-    LIBSHIBOKEN_API PyObject* fromCString(const char* value, int len);
-    LIBSHIBOKEN_API const char* toCString(PyObject* str, Py_ssize_t* len = 0);
-    LIBSHIBOKEN_API bool concat(PyObject** val1, PyObject* val2);
-    LIBSHIBOKEN_API PyObject* fromFormat(const char* format, ...);
-    LIBSHIBOKEN_API PyObject* fromStringAndSize(const char* str, Py_ssize_t size);
-    LIBSHIBOKEN_API int compare(PyObject* val1, const char* val2);
-    LIBSHIBOKEN_API Py_ssize_t len(PyObject* str);
+    LIBSHIBOKEN_API bool check(PyObject *obj);
+    LIBSHIBOKEN_API bool checkType(PyTypeObject *obj);
+    LIBSHIBOKEN_API bool checkChar(PyObject *obj);
+    LIBSHIBOKEN_API bool isConvertible(PyObject *obj);
+    LIBSHIBOKEN_API PyObject *fromCString(const char *value);
+    LIBSHIBOKEN_API PyObject *fromCString(const char *value, int len);
+    LIBSHIBOKEN_API const char *toCString(PyObject *str, Py_ssize_t *len = 0);
+    LIBSHIBOKEN_API bool concat(PyObject **val1, PyObject *val2);
+    LIBSHIBOKEN_API PyObject *fromFormat(const char *format, ...);
+    LIBSHIBOKEN_API PyObject *fromStringAndSize(const char *str, Py_ssize_t size);
+    LIBSHIBOKEN_API int compare(PyObject *val1, const char *val2);
+    LIBSHIBOKEN_API Py_ssize_t len(PyObject *str);
 
 } // namespace String
 } // namespace Shiboken
diff --git a/sources/shiboken2/libshiboken/shibokenbuffer.cpp b/sources/shiboken2/libshiboken/shibokenbuffer.cpp
index a691a31ee..330470183 100644
--- a/sources/shiboken2/libshiboken/shibokenbuffer.cpp
+++ b/sources/shiboken2/libshiboken/shibokenbuffer.cpp
@@ -41,14 +41,14 @@
 #include <cstdlib>
 #include <cstring>
 
-bool Shiboken::Buffer::checkType(PyObject* pyObj)
+bool Shiboken::Buffer::checkType(PyObject *pyObj)
 {
     return PyObject_CheckReadBuffer(pyObj) != 0;
 }
 
-void* Shiboken::Buffer::getPointer(PyObject* pyObj, Py_ssize_t* size)
+void *Shiboken::Buffer::getPointer(PyObject *pyObj, Py_ssize_t *size)
 {
-    const void* buffer = 0;
+    const void *buffer = nullptr;
 #ifdef IS_PY3K
     Py_buffer view;
     if (PyObject_GetBuffer(pyObj, &view, PyBUF_ND) == 0) {
@@ -67,10 +67,10 @@ void* Shiboken::Buffer::getPointer(PyObject* pyObj, Py_ssize_t* size)
     if (size)
         *size = bufferSize;
 #endif
-    return const_cast<void*>(buffer);
+    return const_cast<void *>(buffer);
 }
 
-PyObject* Shiboken::Buffer::newObject(void* memory, Py_ssize_t size, Type type)
+PyObject *Shiboken::Buffer::newObject(void *memory, Py_ssize_t size, Type type)
 {
     if (size == 0)
         Py_RETURN_NONE;
@@ -93,7 +93,7 @@ PyObject* Shiboken::Buffer::newObject(void* memory, Py_ssize_t size, Type type)
 #endif
 }
 
-PyObject* Shiboken::Buffer::newObject(const void* memory, Py_ssize_t size)
+PyObject *Shiboken::Buffer::newObject(const void *memory, Py_ssize_t size)
 {
-    return newObject(const_cast<void*>(memory), size, ReadOnly);
+    return newObject(const_cast<void *>(memory), size, ReadOnly);
 }
diff --git a/sources/shiboken2/libshiboken/shibokenbuffer.h b/sources/shiboken2/libshiboken/shibokenbuffer.h
index 04a5b6dd0..8c41dad6c 100644
--- a/sources/shiboken2/libshiboken/shibokenbuffer.h
+++ b/sources/shiboken2/libshiboken/shibokenbuffer.h
@@ -58,18 +58,18 @@ namespace Buffer
      * Creates a new Python buffer pointing to a contiguous memory block at
      * \p memory of size \p size.
      */
-    LIBSHIBOKEN_API PyObject* newObject(void* memory, Py_ssize_t size, Type type);
+    LIBSHIBOKEN_API PyObject *newObject(void *memory, Py_ssize_t size, Type type);
 
     /**
      * Creates a new <b>read only</b> Python buffer pointing to a contiguous memory block at
      * \p memory of size \p size.
      */
-    LIBSHIBOKEN_API PyObject* newObject(const void* memory, Py_ssize_t size);
+    LIBSHIBOKEN_API PyObject *newObject(const void *memory, Py_ssize_t size);
 
     /**
      * Check if is ok to use \p pyObj as argument in all function under Shiboken::Buffer namespace.
      */
-    LIBSHIBOKEN_API bool checkType(PyObject* pyObj);
+    LIBSHIBOKEN_API bool checkType(PyObject *pyObj);
 
     /**
      * Returns a pointer to the memory pointed by the buffer \p pyObj, \p size is filled with the buffer
@@ -77,7 +77,7 @@ namespace Buffer
      *
      * If the \p pyObj is a non-contiguous buffer a Python error is set.
      */
-    LIBSHIBOKEN_API void* getPointer(PyObject* pyObj, Py_ssize_t* size = 0);
+    LIBSHIBOKEN_API void *getPointer(PyObject *pyObj, Py_ssize_t *size = 0);
 
 } // namespace Buffer
 } // namespace Shiboken
diff --git a/sources/shiboken2/libshiboken/signature.cpp b/sources/shiboken2/libshiboken/signature.cpp
index 8003f142a..8f9c5a459 100644
--- a/sources/shiboken2/libshiboken/signature.cpp
+++ b/sources/shiboken2/libshiboken/signature.cpp
@@ -831,7 +831,7 @@ void handler(int sig) {
     void *array[30];
     size_t size;
 
-    // get void*'s for all entries on the stack
+    // get void *'s for all entries on the stack
     size = backtrace(array, 30);
 
     // print out all the frames to stderr
@@ -1089,7 +1089,7 @@ _build_func_to_type(PyObject *obtype)
             || (check_name && PyObject_RichCompareBool(look, given, Py_EQ) != 1)) {
             PyErr_Clear();
             Shiboken::AutoDecRef cfunc(PyCFunction_NewEx(meth,
-                                     reinterpret_cast<PyObject*>(type), nullptr));
+                                     reinterpret_cast<PyObject *>(type), nullptr));
             if (cfunc.isNull())
                 return -1;
             if (meth->ml_flags & METH_STATIC)
diff --git a/sources/shiboken2/libshiboken/threadstatesaver.h b/sources/shiboken2/libshiboken/threadstatesaver.h
index ddad9b67f..10b3af12b 100644
--- a/sources/shiboken2/libshiboken/threadstatesaver.h
+++ b/sources/shiboken2/libshiboken/threadstatesaver.h
@@ -49,17 +49,17 @@ namespace Shiboken
 class LIBSHIBOKEN_API ThreadStateSaver
 {
 public:
-    ThreadStateSaver(const ThreadStateSaver&) = delete;
-    ThreadStateSaver(ThreadStateSaver&&) = delete;
-    ThreadStateSaver &operator=(const ThreadStateSaver&) = delete;
-    ThreadStateSaver &operator=(ThreadStateSaver&&) = delete;
+    ThreadStateSaver(const ThreadStateSaver &) = delete;
+    ThreadStateSaver(ThreadStateSaver &&) = delete;
+    ThreadStateSaver &operator=(const ThreadStateSaver &) = delete;
+    ThreadStateSaver &operator=(ThreadStateSaver &&) = delete;
 
     ThreadStateSaver();
     ~ThreadStateSaver();
     void save();
     void restore();
 private:
-    PyThreadState* m_threadState;
+    PyThreadState *m_threadState;
 };
 
 } // namespace Shiboken
diff --git a/sources/shiboken2/libshiboken/tmp-referencetopython/sbkconverter.cpp b/sources/shiboken2/libshiboken/tmp-referencetopython/sbkconverter.cpp
index 8e351cedd..ab205e215 100644
--- a/sources/shiboken2/libshiboken/tmp-referencetopython/sbkconverter.cpp
+++ b/sources/shiboken2/libshiboken/tmp-referencetopython/sbkconverter.cpp
@@ -46,13 +46,13 @@
 namespace Shiboken {
 namespace Conversions {
 
-static SbkConverter* createConverterObject(PyTypeObject* type,
+static SbkConverter *createConverterObject(PyTypeObject *type,
                                            PythonToCppFunc toCppPointerConvFunc,
                                            IsConvertibleToCppFunc toCppPointerCheckFunc,
                                            CppToPythonFunc pointerToPythonFunc,
                                            CppToPythonFunc copyToPythonFunc)
 {
-    SbkConverter* converter = new SbkConverter;
+    SbkConverter *converter = new SbkConverter;
     converter->pythonType = type;
 
     converter->pointerToPython = pointerToPythonFunc;
@@ -64,20 +64,20 @@ static SbkConverter* createConverterObject(PyTypeObject* type,
     return converter;
 }
 
-SbkConverter* createConverter(SbkObjectType* type,
+SbkConverter *createConverter(SbkObjectType *type,
                               PythonToCppFunc toCppPointerConvFunc,
                               IsConvertibleToCppFunc toCppPointerCheckFunc,
                               CppToPythonFunc pointerToPythonFunc,
                               CppToPythonFunc copyToPythonFunc)
 {
-    SbkConverter* converter = createConverterObject((PyTypeObject*)type,
+    SbkConverter *converter = createConverterObject(reinterpret_cast<PyTypeObject *>(type),
                                                     toCppPointerConvFunc, toCppPointerCheckFunc,
                                                     pointerToPythonFunc, copyToPythonFunc);
     type->d->converter = converter;
     return converter;
 }
 
-void deleteConverter(SbkConverter* converter)
+void deleteConverter(SbkConverter *converter)
 {
     if (converter) {
         converter->toCppConversions.clear();
@@ -85,44 +85,44 @@ void deleteConverter(SbkConverter* converter)
     }
 }
 
-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(type->d->converter, pythonToCppFunc, isConvertibleToCppFunc);
 }
 
-PyObject* pointerToPython(SbkObjectType* type, const void* cppIn)
+PyObject *pointerToPython(SbkObjectType *type, const void *cppIn)
 {
     if (!cppIn)
         Py_RETURN_NONE;
     return type->d->converter->pointerToPython(cppIn);
 }
 
-static inline PyObject* CopyCppToPython(SbkConverter* converter, const void* cppIn)
+static inline PyObject *CopyCppToPython(SbkConverter *converter, const void *cppIn)
 {
     assert(cppIn);
     return converter->copyToPython(cppIn);
 }
-PyObject* copyToPython(SbkObjectType* type, const void* cppIn)
+PyObject *copyToPython(SbkObjectType *type, const void *cppIn)
 {
     return CopyCppToPython(type->d->converter, cppIn);
 }
-PyObject* toPython(SbkConverter* converter, const void* cppIn)
+PyObject *toPython(SbkConverter *converter, const void *cppIn)
 {
     return CopyCppToPython(converter, cppIn);
 }
 
-PyObject* referenceToPython(SbkObjectType* type, const void* cppIn)
+PyObject *referenceToPython(SbkObjectType *type, const void *cppIn)
 {
     assert(cppIn);
-    PyObject* pyOut = (PyObject*)BindingManager::instance().retrieveWrapper(cppIn);
+    PyObject *pyOut = (PyObject *)BindingManager::instance().retrieveWrapper(cppIn);
     if (pyOut) {
         Py_INCREF(pyOut);
         return pyOut;
@@ -134,16 +134,16 @@ PyObject* referenceToPython(SbkObjectType* type, const void* cppIn)
     return type->d->converter->pointerToPython(cppIn);
 }
 
-PythonToCppFunc isPythonToCppPointerConvertible(SbkObjectType* type, PyObject* pyIn)
+PythonToCppFunc isPythonToCppPointerConvertible(SbkObjectType *type, PyObject *pyIn)
 {
     assert(pyIn);
     return type->d->converter->toCppPointerConversion.first(pyIn);
 }
 
-static inline PythonToCppFunc IsPythonToCppConvertible(SbkConverter* converter, PyObject* pyIn)
+static inline PythonToCppFunc IsPythonToCppConvertible(SbkConverter *converter, PyObject *pyIn)
 {
     assert(pyIn);
-    ToCppConversionList& convs = converter->toCppConversions;
+    ToCppConversionList &convs = converter->toCppConversions;
     for (ToCppConversionList::iterator conv = convs.begin(); conv != convs.end(); ++conv) {
         PythonToCppFunc toCppFunc = 0;
         if ((toCppFunc = (*conv).first(pyIn)))
@@ -151,16 +151,16 @@ static inline PythonToCppFunc IsPythonToCppConvertible(SbkConverter* converter,
     }
     return 0;
 }
-PythonToCppFunc isPythonToCppValueConvertible(SbkObjectType* type, PyObject* pyIn)
+PythonToCppFunc isPythonToCppValueConvertible(SbkObjectType *type, PyObject *pyIn)
 {
     return IsPythonToCppConvertible(type->d->converter, pyIn);
 }
-PythonToCppFunc isPythonToCppConvertible(SbkConverter* converter, PyObject* pyIn)
+PythonToCppFunc isPythonToCppConvertible(SbkConverter *converter, PyObject *pyIn)
 {
     return IsPythonToCppConvertible(converter, pyIn);
 }
 
-PythonToCppFunc isPythonToCppReferenceConvertible(SbkObjectType* type, PyObject* pyIn)
+PythonToCppFunc isPythonToCppReferenceConvertible(SbkObjectType *type, PyObject *pyIn)
 {
     if (pyIn != Py_None) {
         PythonToCppFunc toCpp = isPythonToCppPointerConvertible(type, pyIn);
@@ -170,24 +170,27 @@ 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 pythonToCppPointer(SbkObjectType* type, PyObject* pyIn, void* cppOut)
+void pythonToCppPointer(SbkObjectType *type, PyObject *pyIn, void *cppOut)
 {
     assert(pyIn);
     assert(cppOut);
-    SbkObjectType* inType = (SbkObjectType*)Py_TYPE(pyIn);
-    if (ObjectType::hasCast(inType))
-        *((void**)cppOut) = ObjectType::cast(inType, (SbkObject*)pyIn, (PyTypeObject*)type);
-    else
-        *((void**)cppOut) = Object::cppPointer((SbkObject*)pyIn, (PyTypeObject*)type);
+    SbkObjectType *inType = (SbkObjectType *)Py_TYPE(pyIn);
+    if (ObjectType::hasCast(inType)) {
+        *reinterpret_cast<void **>(cppOut) =
+            ObjectType::cast(inType, reinterpret_cast<SbkObject *>(pyIn), reinterpret_cast<PyTypeObject *>(type));
+    } else {
+        *reinterpret_cast<void **>(cppOut) =
+           Object::cppPointer(reinterpret_cast<SbkObject *>(pyIn), reinterpret_cast<PyTypeObject *>(type));
+    }
 }
 
-bool isImplicitConversion(SbkObjectType* type, PythonToCppFunc toCppFunc)
+bool isImplicitConversion(SbkObjectType *type, PythonToCppFunc toCppFunc)
 {
     // This is the Object Type or Value Type conversion that only
     // retrieves the C++ pointer held in the Python wrapper.
diff --git a/sources/shiboken2/libshiboken/tmp-referencetopython/sbkconverter.h b/sources/shiboken2/libshiboken/tmp-referencetopython/sbkconverter.h
index cc9ea7a19..3578e4039 100644
--- a/sources/shiboken2/libshiboken/tmp-referencetopython/sbkconverter.h
+++ b/sources/shiboken2/libshiboken/tmp-referencetopython/sbkconverter.h
@@ -64,7 +64,7 @@ struct SbkConverter;
  *
  *  C++ -> Python
  */
-typedef PyObject* (*CppToPythonFunc)(const void*);
+typedef PyObject *(*CppToPythonFunc)(const void *);
 
 /**
  *  This function converts a Python object to a C++ value, it may be
@@ -77,7 +77,7 @@ typedef PyObject* (*CppToPythonFunc)(const void*);
  *
  *  Python -> C++
  */
-typedef void (*PythonToCppFunc)(PyObject*,void*);
+typedef void (*PythonToCppFunc)(PyObject *,void *);
 
 /**
  *  Checks if the Python object passed in the argument is convertible to a
@@ -88,7 +88,7 @@ typedef void (*PythonToCppFunc)(PyObject*,void*);
  *
  *  Python -> C++ ?
  */
-typedef PythonToCppFunc (*IsConvertibleToCppFunc)(PyObject*);
+typedef PythonToCppFunc (*IsConvertibleToCppFunc)(PyObject *);
 
 } // extern "C"
 
@@ -105,22 +105,22 @@ namespace Conversions {
  *  \param copyToPythonFunc      Function to convert a C++ object to a Python \p type, copying the object.
  *  \returns                     The new converter referred by the wrapper \p type.
  */
-LIBSHIBOKEN_API SbkConverter* createConverter(SbkObjectType* type,
+LIBSHIBOKEN_API SbkConverter *createConverter(SbkObjectType *type,
                                               PythonToCppFunc toCppPointerConvFunc,
                                               IsConvertibleToCppFunc toCppPointerCheckFunc,
                                               CppToPythonFunc pointerToPythonFunc,
                                               CppToPythonFunc copyToPythonFunc = 0);
 
-LIBSHIBOKEN_API void deleteConverter(SbkConverter* converter);
+LIBSHIBOKEN_API void deleteConverter(SbkConverter *converter);
 
 /**
  *  Adds a new conversion of a Python object to a C++ value.
  *  This is used in copy and implicit conversions.
  */
-LIBSHIBOKEN_API void addPythonToCppValueConversion(SbkConverter* converter,
+LIBSHIBOKEN_API void addPythonToCppValueConversion(SbkConverter *converter,
                                                    PythonToCppFunc pythonToCppFunc,
                                                    IsConvertibleToCppFunc isConvertibleToCppFunc);
-LIBSHIBOKEN_API void addPythonToCppValueConversion(SbkObjectType* type,
+LIBSHIBOKEN_API void addPythonToCppValueConversion(SbkObjectType *type,
                                                    PythonToCppFunc pythonToCppFunc,
                                                    IsConvertibleToCppFunc isConvertibleToCppFunc);
 
@@ -130,19 +130,19 @@ LIBSHIBOKEN_API void addPythonToCppValueConversion(SbkObjectType* type,
  *  Retrieves the Python wrapper object for the given \p cppIn C++ pointer object.
  *  This function is used only for Value and Object Types.
  *  Example usage:
- *      TYPE* var;
- *      PyObject* pyVar = pointerToPython(SBKTYPE, &var);
+ *      TYPE *var;
+ *      PyObject *pyVar = pointerToPython(SBKTYPE, &var);
  */
-LIBSHIBOKEN_API PyObject* pointerToPython(SbkObjectType* type, const void* cppIn);
+LIBSHIBOKEN_API PyObject *pointerToPython(SbkObjectType *type, const void *cppIn);
 
 /**
  *  Retrieves the Python wrapper object for the given C++ value pointed by \p cppIn.
  *  This function is used only for Value Types.
  *  Example usage:
  *      TYPE var;
- *      PyObject* pyVar = copyToPython(SBKTYPE, &var);
+ *      PyObject *pyVar = copyToPython(SBKTYPE, &var);
  */
-LIBSHIBOKEN_API PyObject* copyToPython(SbkObjectType* type, const void* cppIn);
+LIBSHIBOKEN_API PyObject *copyToPython(SbkObjectType *type, const void *cppIn);
 
 // TODO:WRITEDOCSTRING - used only for Value Types - cppIn must point to a value
 /**
@@ -150,41 +150,41 @@ LIBSHIBOKEN_API PyObject* copyToPython(SbkObjectType* type, const void* cppIn);
  *  This function is used only for Value and Object Types.
  *  It differs from pointerToPython() for not checking for a NULL pointer.
  *  Example usage:
- *      TYPE& var = SOMETHING;
- *      PyObject* pyVar = copyToPython(SBKTYPE, &var);
+ *      TYPE &var = SOMETHING;
+ *      PyObject *pyVar = copyToPython(SBKTYPE, &var);
  */
-LIBSHIBOKEN_API PyObject* referenceToPython(SbkObjectType* type, const void* cppIn);
+LIBSHIBOKEN_API PyObject *referenceToPython(SbkObjectType *type, const void *cppIn);
 
 // TODO:WRITEDOCSTRING - used only for Primitives and Containers (and Value Types) - cppIn must point to a primitive, container or value type
 /// This is the same as copyToPython function.
-LIBSHIBOKEN_API PyObject* toPython(SbkConverter* converter, const void* cppIn);
+LIBSHIBOKEN_API PyObject *toPython(SbkConverter *converter, const void *cppIn);
 
 // Python -> C++ convertibility checks -----------------------------------------------------
 
 // TODO:WRITEDOCSTRING
-LIBSHIBOKEN_API PythonToCppFunc isPythonToCppPointerConvertible(SbkObjectType* type, PyObject* pyIn);
+LIBSHIBOKEN_API PythonToCppFunc isPythonToCppPointerConvertible(SbkObjectType *type, PyObject *pyIn);
 
 // TODO:WRITEDOCSTRING- Returns a Python to C++ conversion function if true, or NULL if false.
-LIBSHIBOKEN_API PythonToCppFunc isPythonToCppValueConvertible(SbkObjectType* type, PyObject* pyIn);
+LIBSHIBOKEN_API PythonToCppFunc isPythonToCppValueConvertible(SbkObjectType *type, PyObject *pyIn);
 
 // TODO:WRITEDOCSTRING- Returns a Python to C++ conversion function if true, or NULL if false.
-LIBSHIBOKEN_API PythonToCppFunc isPythonToCppReferenceConvertible(SbkObjectType* type, PyObject* pyIn);
+LIBSHIBOKEN_API PythonToCppFunc isPythonToCppReferenceConvertible(SbkObjectType *type, PyObject *pyIn);
 
 /// This is the same as isPythonToCppValueConvertible function.
-LIBSHIBOKEN_API PythonToCppFunc isPythonToCppConvertible(SbkConverter* converter, PyObject* pyIn);
+LIBSHIBOKEN_API PythonToCppFunc isPythonToCppConvertible(SbkConverter *converter, PyObject *pyIn);
 
 // Python -> C++ ---------------------------------------------------------------------------
 
 // TODO:WRITEDOCSTRING - function used by the generated [TYPE]_PythonToCpp_[TYPE]_PTR
-LIBSHIBOKEN_API void pythonToCppPointer(SbkObjectType* type, PyObject* pyIn, void* cppOut);
+LIBSHIBOKEN_API void pythonToCppPointer(SbkObjectType *type, PyObject *pyIn, void *cppOut);
 
 // TODO:WRITEDOCSTRING - function used by the generated isConvertible when the PyObject is None,
 // making a C++ NULL pointer the result of the toCpp function call.
 // DRAFT: When the Python object is a Py_None, it's C++ conversion is always a NULL pointer.
-LIBSHIBOKEN_API void nonePythonToCppNullPtr(PyObject*, void* cppOut);
+LIBSHIBOKEN_API void nonePythonToCppNullPtr(PyObject *, void *cppOut);
 
 // TODO:WRITEDOCSTRING - tells if \p toCpp is an implicit conversion.
-LIBSHIBOKEN_API bool isImplicitConversion(SbkObjectType* type, PythonToCppFunc toCpp);
+LIBSHIBOKEN_API bool isImplicitConversion(SbkObjectType *type, PythonToCppFunc toCpp);
 
 } } // namespace Shiboken::Conversions
 
diff --git a/sources/shiboken2/libshiboken/typespec.cpp b/sources/shiboken2/libshiboken/typespec.cpp
index a67daf12d..6dc5b00bc 100644
--- a/sources/shiboken2/libshiboken/typespec.cpp
+++ b/sources/shiboken2/libshiboken/typespec.cpp
@@ -599,17 +599,16 @@ offsetof(PyHeapTypeObject, as_sequence.sq_slice),
 PyObject *
 PyType_FromSpecWithBases(PyType_Spec *spec, PyObject *bases)
 {
-    PyHeapTypeObject *res = (PyHeapTypeObject*)PyType_GenericAlloc(&PyType_Type, 0);
+    auto res = reinterpret_cast<PyHeapTypeObject *>(PyType_GenericAlloc(&PyType_Type, 0));
     PyTypeObject *type, *base;
     PyObject *modname;
-    char *s;
-    char *res_start = (char*)res;
+    auto res_start = reinterpret_cast<char *>(res);
     PyType_Slot *slot;
 
     /* Set the type name and qualname */
-    s = (char *)strrchr(spec->name, '.'); // C++11
+    auto s = const_cast<char *>(strrchr(spec->name, '.')); // C++11
     if (s == NULL)
-        s = (char*)spec->name;
+        s = const_cast<char *>(spec->name);
     else
         s++;
 
@@ -686,7 +685,7 @@ PyType_FromSpecWithBases(PyType_Spec *spec, PyObject *bases)
         if (slot->slot == Py_tp_base || slot->slot == Py_tp_bases)
             /* Processed above */
             continue;
-        *(void**)(res_start + slotoffsets[slot->slot]) = slot->pfunc;
+        *reinterpret_cast<void **>(res_start + slotoffsets[slot->slot]) = slot->pfunc;
 
         /* need to make a copy of the docstring slot, which usually
            points to a static string literal */
@@ -746,7 +745,7 @@ PyType_FromSpecWithBases(PyType_Spec *spec, PyObject *bases)
             goto fail;
     }
 
-    return (PyObject*)res;
+    return reinterpret_cast<PyObject *>(res);
 
  fail:
     Py_DECREF(res);
@@ -770,7 +769,7 @@ PyType_GetSlot(PyTypeObject *type, int slot)
         /* Extension module requesting slot from a future version */
         return NULL;
     }
-    return  *(void**)(((char*)type) + slotoffsets[slot]);
+    return  *reinterpret_cast<void **>(reinterpret_cast<char *>(type) + slotoffsets[slot]);
 }
 
 } // extern "C"
diff --git a/sources/shiboken2/libshiboken/typespec.h b/sources/shiboken2/libshiboken/typespec.h
index 81227acac..193b654c2 100644
--- a/sources/shiboken2/libshiboken/typespec.h
+++ b/sources/shiboken2/libshiboken/typespec.h
@@ -53,19 +53,19 @@ typedef struct{
 } PyType_Slot;
 
 typedef struct{
-    const char* name;
+    const char *name;
     int basicsize;
     int itemsize;
     unsigned int flags;
     PyType_Slot *slots; /* terminated by slot==0. */
 } PyType_Spec;
 
-LIBSHIBOKEN_API PyObject *PyType_FromSpec(PyType_Spec*);
+LIBSHIBOKEN_API PyObject *PyType_FromSpec(PyType_Spec *);
 #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
-LIBSHIBOKEN_API PyObject *PyType_FromSpecWithBases(PyType_Spec*, PyObject*);
+LIBSHIBOKEN_API PyObject *PyType_FromSpecWithBases(PyType_Spec *, PyObject *);
 #endif
 #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03040000
-LIBSHIBOKEN_API void* PyType_GetSlot(PyTypeObject*, int);
+LIBSHIBOKEN_API void *PyType_GetSlot(PyTypeObject *, int);
 #endif
 
 // from typeslots.h
diff --git a/sources/shiboken2/libshiboken/voidptr.cpp b/sources/shiboken2/libshiboken/voidptr.cpp
index 5b0cb84ea..4d09adb0c 100644
--- a/sources/shiboken2/libshiboken/voidptr.cpp
+++ b/sources/shiboken2/libshiboken/voidptr.cpp
@@ -189,7 +189,7 @@ PyObject *toBytes(PyObject *self, PyObject *args)
         PyErr_SetString(PyExc_IndexError, "VoidPtr does not have a size set.");
         return nullptr;
     }
-    PyObject *bytes = PyBytes_FromStringAndSize(reinterpret_cast<const char*>(sbkObject->cptr),
+    PyObject *bytes = PyBytes_FromStringAndSize(reinterpret_cast<const char *>(sbkObject->cptr),
                                                 sbkObject->size);
     Py_XINCREF(bytes);
     return bytes;
@@ -290,17 +290,17 @@ static int SbkVoidPtrObject_getbuffer(PyObject *obj, Py_buffer *view, int flags)
 
 #if PY_VERSION_HEX < 0x03000000
 
-static Py_ssize_t SbkVoidPtrObject_readbufferproc(PyObject* self, Py_ssize_t segment, void** ptrptr)
+static Py_ssize_t SbkVoidPtrObject_readbufferproc(PyObject *self, Py_ssize_t segment, void **ptrptr)
 {
     if (segment || !Shiboken::Object::isValid(self))
         return -1;
 
     SbkVoidPtrObject *sbkObject = reinterpret_cast<SbkVoidPtrObject *>(self);
-    *ptrptr = reinterpret_cast<void*>(sbkObject->cptr);
+    *ptrptr = reinterpret_cast<void *>(sbkObject->cptr);
     return sbkObject->size;
 }
 
-static Py_ssize_t SbkVoidPtrObject_segcountproc(PyObject* self, Py_ssize_t* lenp)
+static Py_ssize_t SbkVoidPtrObject_segcountproc(PyObject *self, Py_ssize_t *lenp)
 {
     if (lenp) {
         SbkVoidPtrObject *sbkObject = reinterpret_cast<SbkVoidPtrObject *>(self);