Merge branch 'dev' into wip/clangwip/clang

Change-Id: I15c4a582788d1ab5aa5f8dbabbd89e75d5449ffd

14 files changed, 193 insertions, 160 deletions

diff --git a/ApiExtractor/apiextractor.cpp b/ApiExtractor/apiextractor.cpp
index 92107de..371ccf5 100644
--- a/ApiExtractor/apiextractor.cpp
+++ b/ApiExtractor/apiextractor.cpp
@@ -113,14 +113,9 @@ void ApiExtractor::setSilent ( bool value )
     ReportHandler::setSilent(value);
 }
 
-void ApiExtractor::setApiVersion(double version)
+bool ApiExtractor::setApiVersion(const QString& package, const QString &version)
 {
-    TypeDatabase::instance()->setApiVersion(QLatin1String("*"), QByteArray::number(version));
-}
-
-void ApiExtractor::setApiVersion(const QString& package, const QByteArray& version)
-{
-    TypeDatabase::instance()->setApiVersion(package, version);
+    return TypeDatabase::instance()->setApiVersion(package, version);
 }
 
 void ApiExtractor::setDropTypeEntries(QString dropEntries)
diff --git a/ApiExtractor/apiextractor.h b/ApiExtractor/apiextractor.h
index 85f5152..1080ff5 100644
--- a/ApiExtractor/apiextractor.h
+++ b/ApiExtractor/apiextractor.h
@@ -71,8 +71,7 @@ public:
     void addIncludePath(const QStringList& paths);
     QStringList includePaths() const { return m_includePaths; }
     void setLogDirectory(const QString& logDir);
-    APIEXTRACTOR_DEPRECATED(void setApiVersion(double version));
-    void setApiVersion(const QString& package, const QByteArray& version);
+    bool setApiVersion(const QString& package, const QString& version);
     void setDropTypeEntries(QString dropEntries);
 
     AbstractMetaEnumList globalEnums() const;
diff --git a/ApiExtractor/tests/testutil.h b/ApiExtractor/tests/testutil.h
index ad2e3a7..d4eb2fd 100644
--- a/ApiExtractor/tests/testutil.h
+++ b/ApiExtractor/tests/testutil.h
@@ -42,8 +42,8 @@ namespace TestUtil
     {
         ReportHandler::setSilent(silent);
         TypeDatabase* td = TypeDatabase::instance(true);
-        if (apiVersion)
-            td->setApiVersion(QLatin1String("*"), apiVersion);
+        if (apiVersion && !td->setApiVersion(QLatin1String("*"), QLatin1String(apiVersion)))
+            return Q_NULLPTR;
         td->setDropTypeEntries(dropTypeEntries);
         QBuffer buffer;
         // parse typesystem
diff --git a/ApiExtractor/typedatabase.cpp b/ApiExtractor/typedatabase.cpp
index c80efca..c6f42af 100644
--- a/ApiExtractor/typedatabase.cpp
+++ b/ApiExtractor/typedatabase.cpp
@@ -32,15 +32,28 @@
 
 #include <QtCore/QFile>
 #include <QtCore/QDir>
+#include <QtCore/QPair>
+#include <QtCore/QVector>
+#include <QtCore/QRegularExpression>
+#include <QtCore/QVersionNumber>
 #include <QtCore/QXmlStreamReader>
 #include "reporthandler.h"
 // #include <tr1/tuple>
 #include <algorithm>
 
 // package -> api-version
-typedef QMap<QString, QByteArray> ApiVersionMap;
 
-Q_GLOBAL_STATIC(ApiVersionMap, apiVersions)
+static QString wildcardToRegExp(QString w)
+{
+    w.replace(QLatin1Char('?'), QLatin1Char('.'));
+    w.replace(QLatin1Char('*'), QStringLiteral(".*"));
+    return w;
+}
+
+typedef QPair<QRegularExpression, QVersionNumber> ApiVersion;
+typedef QVector<ApiVersion> ApiVersions;
+
+Q_GLOBAL_STATIC(ApiVersions, apiVersions)
 
 TypeDatabase::TypeDatabase() : m_suppressWarnings(true)
 {
@@ -525,46 +538,39 @@ int getMaxTypeIndex()
     return maxTypeIndex;
 }
 
-void TypeDatabase::setApiVersion(const QString& package, const QByteArray& version)
+bool TypeDatabase::setApiVersion(const QString& packageWildcardPattern, const QString &version)
 {
-    (*apiVersions())[package.trimmed()] = version.trimmed();
-}
-
-/**
- * Returns -1, 0 or 1 if v1 is less, equal or greater than v2
- */
-static int versionCheck(const QByteArray& v1, const QByteArray& v2)
-{
-    if (v1.isEmpty() || v2.isEmpty())
-        return 0;
-
-    QList<QByteArray> v1Components = v1.split('.');
-    QList<QByteArray> v2Components = v2.split('.');
-    int numComponents = qMax(v1Components.count(), v2Components.count());
-    while (v1Components.count() < numComponents)
-        v1Components.append("0");
-    while (v2Components.count() < numComponents)
-        v2Components.append("0");
-
-    for (int i = 0, max = v1Components.count(); i < max; ++i) {
-        int v1Comp = v1Components[i].toInt();
-        int v2Comp = v2Components[i].toInt();
-        if (v1Comp > v2Comp)
-            return 1;
-        else if (v1Comp < v2Comp)
-            return -1;
+    const QString packagePattern = wildcardToRegExp(packageWildcardPattern.trimmed());
+    const QVersionNumber versionNumber = QVersionNumber::fromString(version);
+    if (versionNumber.isNull())
+        return false;
+    ApiVersions &versions = *apiVersions();
+    for (int i = 0, size = versions.size(); i < size; ++i) {
+        if (versions.at(i).first.pattern() == packagePattern) {
+            versions[i].second = versionNumber;
+            return true;
+        }
     }
-    return 0;
+    const QRegularExpression packageRegex(packagePattern);
+    if (!packageRegex.isValid())
+        return false;
+    versions.append(qMakePair(packageRegex, versionNumber));
+    return true;
 }
 
-bool TypeDatabase::checkApiVersion(const QString& package, const QByteArray& version) const
+bool TypeDatabase::checkApiVersion(const QString& package, const QString& version) const
 {
-    ApiVersionMap* vMap = apiVersions();
-    ApiVersionMap::const_iterator it = vMap->begin();
-    for (; it != vMap->end(); ++it) {
-        QRegExp regex(it.key(), Qt::CaseSensitive, QRegExp::Wildcard);
-        if (regex.exactMatch(package))
-            return versionCheck(it.value(), version) >= 0;
+    const QVersionNumber versionNumber = QVersionNumber::fromString(version);
+    if (versionNumber.isNull()) {
+        qCWarning(lcShiboken).noquote().nospace()
+            << "checkApiVersion: Invalid version \"" << version << "\" specified for package "
+            << package << '.';
+        return false;
+    }
+    const ApiVersions &versions = *apiVersions();
+    for (int i = 0, size = versions.size(); i < size; ++i) {
+        if (versions.at(i).first.match(package).hasMatch())
+            return versions.at(i).second >= versionNumber;
     }
     return false;
 }
diff --git a/ApiExtractor/typedatabase.h b/ApiExtractor/typedatabase.h
index cf5028d..b28fc9b 100644
--- a/ApiExtractor/typedatabase.h
+++ b/ApiExtractor/typedatabase.h
@@ -136,9 +136,9 @@ public:
     bool parseFile(const QString &filename, bool generate = true);
     bool parseFile(QIODevice* device, bool generate = true);
 
-    void setApiVersion(const QString& package, const QByteArray& version);
+    bool setApiVersion(const QString& package, const QString& version);
 
-    bool checkApiVersion(const QString& package, const QByteArray& version) const;
+    bool checkApiVersion(const QString& package, const QString &version) const;
 
     bool hasDroppedTypeEntries() const { return !m_dropTypeEntries.isEmpty(); }
 
diff --git a/ApiExtractor/typesystem.cpp b/ApiExtractor/typesystem.cpp
index b93b761..f63f591 100644
--- a/ApiExtractor/typesystem.cpp
+++ b/ApiExtractor/typesystem.cpp
@@ -594,7 +594,7 @@ bool Handler::startElement(const QStringRef &n, const QXmlStreamAttributes &atts
 
     if (!m_defaultPackage.isEmpty() && atts.hasAttribute(sinceAttribute())) {
         TypeDatabase* td = TypeDatabase::instance();
-        if (!td->checkApiVersion(m_defaultPackage, atts.value(sinceAttribute()).toUtf8())) {
+        if (!td->checkApiVersion(m_defaultPackage, atts.value(sinceAttribute()).toString())) {
             ++m_ignoreDepth;
             return true;
         }
diff --git a/generator/generator.cpp b/generator/generator.cpp
index e4d27c0..d7f98a9 100644
--- a/generator/generator.cpp
+++ b/generator/generator.cpp
@@ -578,10 +578,9 @@ QString Generator::minimalConstructor(const AbstractMetaType* type) const
     }
 
     if (type->isNativePointer())
-        return QString::fromLatin1("((%1*)0)").arg(type->typeEntry()->qualifiedCppName());
-
+        return QLatin1String("static_cast<") + type->typeEntry()->qualifiedCppName() + QLatin1String(" *>(0)");
     if (Generator::isPointer(type))
-        return QString::fromLatin1("((::%1*)0)").arg(type->typeEntry()->qualifiedCppName());
+        return QLatin1String("static_cast< ::") + type->typeEntry()->qualifiedCppName() + QLatin1String(" *>(0)");
 
     if (type->typeEntry()->isComplex()) {
         const ComplexTypeEntry* cType = reinterpret_cast<const ComplexTypeEntry*>(type->typeEntry());
@@ -602,11 +601,17 @@ QString Generator::minimalConstructor(const TypeEntry* type) const
     if (!type)
         return QString();
 
-    if (type->isCppPrimitive())
-        return QString::fromLatin1("((%1)0)").arg(type->qualifiedCppName());
+    if (type->isCppPrimitive()) {
+        const QString &name = type->qualifiedCppName();
+        return name == QLatin1String("bool")
+            ? QLatin1String("false") : name + QLatin1String("(0)");
+    }
+
+    if (type->isEnum())
+        return QLatin1String("static_cast< ::") + type->qualifiedCppName() + QLatin1String(">(0)");
 
-    if (type->isEnum() || type->isFlags())
-        return QString::fromLatin1("((::%1)0)").arg(type->qualifiedCppName());
+    if (type->isFlags())
+        return type->qualifiedCppName() + QLatin1String("(0)");
 
     if (type->isPrimitive()) {
         QString ctor = reinterpret_cast<const PrimitiveTypeEntry*>(type)->defaultConstructor();
diff --git a/generator/main.cpp b/generator/main.cpp
index ac8f77f..874540e 100644
--- a/generator/main.cpp
+++ b/generator/main.cpp
@@ -341,6 +341,12 @@ static inline void errorPrint(const QString& s)
         << "\nCommand line: " << qPrintable(arguments.join(QLatin1Char(' '))) << '\n';
 }
 
+static QString msgInvalidVersion(const QString &package, const QString &version)
+{
+    return QLatin1String("Invalid version \"") + version
+        + QLatin1String("\" specified for package ") + package + QLatin1Char('.');
+}
+
 int main(int argc, char *argv[])
 {
     QElapsedTimer timer;
@@ -439,7 +445,10 @@ int main(int argc, char *argv[])
             // avoid constFirst to stay Qt 5.5 compatible
             package = parts.count() == 1 ? QLatin1String("*") : parts.first();
             version = parts.last();
-            extractor.setApiVersion(package, version.toUtf8());
+            if (!extractor.setApiVersion(package, version)) {
+                errorPrint(msgInvalidVersion(package, version));
+                return EXIT_FAILURE;
+            }
         }
     }
 
diff --git a/generator/shiboken2/cppgenerator.cpp b/generator/shiboken2/cppgenerator.cpp
index f0c2fe4..f5bcdce 100644
--- a/generator/shiboken2/cppgenerator.cpp
+++ b/generator/shiboken2/cppgenerator.cpp
@@ -2229,8 +2229,8 @@ void CppGenerator::writePythonToCppTypeConversion(QTextStream& s,
     if (!defaultValue.isEmpty())
         s << '{' << endl << INDENT;
 
-    s << "if (Shiboken::Conversions::isImplicitConversion((SbkObjectType*)";
-    s << cpythonTypeNameExt(type) << ", " << pythonToCppFunc << "))" << endl;
+    s << "if (Shiboken::Conversions::isImplicitConversion(reinterpret_cast<const SbkObjectType *>("
+        << cpythonTypeNameExt(type) << "), " << pythonToCppFunc << "))" << endl;
     {
         Indentation indent(INDENT);
         s << INDENT << pythonToCppFunc << '(' << pyIn << ", &" << cppOutAux << ");" << endl;
@@ -3207,8 +3207,8 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f
                 && !injectedCodeHasReturnValueAttribution(func, TypeSystem::TargetLangCode)) {
                 s << INDENT << PYTHON_RETURN_VAR " = ";
                 if (isObjectTypeUsedAsValueType(func->type())) {
-                    s << "Shiboken::Object::newObject((SbkObjectType*)" << cpythonTypeNameExt(func->type()->typeEntry());
-                    s << ", " << CPP_RETURN_VAR << ", true, true)";
+                    s << "Shiboken::Object::newObject(reinterpret_cast<SbkObjectType *>(" << cpythonTypeNameExt(func->type()->typeEntry())
+                        << "), " << CPP_RETURN_VAR << ", true, true)";
                 } else {
                     writeToPythonConversion(s, func->type(), func->ownerClass(), QLatin1String(CPP_RETURN_VAR));
                 }
@@ -3503,9 +3503,9 @@ void CppGenerator::writeExtendedConverterInitialization(QTextStream& s, const Ty
 {
     s << INDENT << "// Extended implicit conversions for " << externalType->qualifiedTargetLangName() << '.' << endl;
     foreach (const AbstractMetaClass* sourceClass, conversions) {
-        QString converterVar = QString::fromLatin1("(SbkObjectType*)%1[%2]")
-                                  .arg(cppApiVariableName(externalType->targetLangPackage()),
-                                       getTypeIndexVariableName(externalType));
+        const QString converterVar = QLatin1String("reinterpret_cast<SbkObjectType *>(")
+            + cppApiVariableName(externalType->targetLangPackage()) + QLatin1Char('[')
+            + getTypeIndexVariableName(externalType) + QLatin1String("])");
         QString sourceTypeName = fixedCppTypeName(sourceClass->typeEntry());
         QString targetTypeName = fixedCppTypeName(externalType);
         QString toCpp = pythonToCppFunctionName(sourceTypeName, targetTypeName);
@@ -4028,10 +4028,10 @@ void CppGenerator::writeGetterFunction(QTextStream &s,
                     << CPP_SELF_VAR << ")) {\n";
         {
             Indentation indent(INDENT);
-            s << INDENT << "pyOut = (PyObject*)Shiboken::Object::findColocatedChild("
-                        << "(SbkObject*)self , (SbkObjectType*)"
+            s << INDENT << "pyOut = reinterpret_cast<PyObject *>(Shiboken::Object::findColocatedChild("
+                        << "reinterpret_cast<SbkObject *>(self), reinterpret_cast<const SbkObjectType *>("
                         << cpythonTypeNameExt(fieldType)
-                        << ");" << "\n";
+                        << ")));\n";
             s << INDENT << "if (pyOut) {Py_IncRef(pyOut); return pyOut;}\n";
         }
         s << INDENT << "}\n";
@@ -4046,8 +4046,8 @@ void CppGenerator::writeGetterFunction(QTextStream &s,
         s << INDENT << "}\n";
         // Create and register new wrapper
         s << INDENT << "pyOut = ";
-        s << "Shiboken::Object::newObject((SbkObjectType*)" << cpythonTypeNameExt(fieldType);
-        s << ", " << cppField << ", false, true);" << endl;
+        s << "Shiboken::Object::newObject(reinterpret_cast<SbkObjectType *>(" << cpythonTypeNameExt(fieldType)
+            << "), " << cppField << ", false, true);" << endl;
         s << INDENT << "Shiboken::Object::setParent(" PYTHON_SELF_VAR ", pyOut)";
     } else {
         s << INDENT << "pyOut = ";
@@ -4357,8 +4357,8 @@ void CppGenerator::writeEnumInitialization(QTextStream& s, const AbstractMetaEnu
                 {
                     Indentation indent(INDENT);
                     s << INDENT << "PyObject* anonEnumItem = PyInt_FromLong(" << enumValueText << ");" << endl;
-                    s << INDENT << "if (PyDict_SetItemString(((SbkObjectType*)" << enclosingObjectVariable;
-                    s << ")->super.ht_type.tp_dict, \"" << enumValue->name() << "\", anonEnumItem) < 0)" << endl;
+                    s << INDENT << "if (PyDict_SetItemString(reinterpret_cast<SbkObjectType *>(" << enclosingObjectVariable
+                        << ")->super.ht_type.tp_dict, \"" << enumValue->name() << "\", anonEnumItem) < 0)" << endl;
                     {
                         Indentation indent(INDENT);
                         s << INDENT << "return " << m_currentErrorCode << ';' << endl;
@@ -4677,7 +4677,7 @@ void CppGenerator::writeClassRegister(QTextStream &s,
 
         // Base type
         if (metaClass->baseClass()) {
-            s << ", (SbkObjectType*)" << cpythonTypeNameExt(metaClass->baseClass()->typeEntry());
+            s << ", reinterpret_cast<SbkObjectType *>(" << cpythonTypeNameExt(metaClass->baseClass()->typeEntry()) << ')';
             // The other base types
             if (metaClass->baseClassNames().size() > 1)
                 s << ", " << pyTypeBasesVariable;
diff --git a/generator/shiboken2/shibokengenerator.cpp b/generator/shiboken2/shibokengenerator.cpp
index ca98441..be39143 100644
--- a/generator/shiboken2/shibokengenerator.cpp
+++ b/generator/shiboken2/shibokengenerator.cpp
@@ -558,16 +558,18 @@ QString ShibokenGenerator::cpythonWrapperCPtr(const AbstractMetaType *metaType,
 {
     if (!ShibokenGenerator::isWrapperType(metaType->typeEntry()))
         return QString();
-    return QStringLiteral("((::%1*)Shiboken::Conversions::cppPointer(%2, (SbkObject*)%3))")
-              .arg(metaType->cppSignature(), cpythonTypeNameExt(metaType), argName);
+    return QLatin1String("reinterpret_cast< ::") + metaType->cppSignature()
+        + QLatin1String(" *>(Shiboken::Conversions::cppPointer(") + cpythonTypeNameExt(metaType)
+        + QLatin1String(", reinterpret_cast<SbkObject *>(") + argName + QLatin1String(")))");
 }
 
 QString ShibokenGenerator::cpythonWrapperCPtr(const TypeEntry* type, QString argName)
 {
     if (!ShibokenGenerator::isWrapperType(type))
         return QString();
-    return QStringLiteral("((::%1*)Shiboken::Conversions::cppPointer(%2, (SbkObject*)%3))")
-              .arg(type->qualifiedCppName(), cpythonTypeNameExt(type), argName);
+    return QLatin1String("reinterpret_cast< ::") + type->qualifiedCppName()
+        + QLatin1String(" *>(Shiboken::Conversions::cppPointer(") + cpythonTypeNameExt(type)
+        + QLatin1String(", reinterpret_cast<SbkObject *>(") + argName + QLatin1String(")))");
 }
 
 QString ShibokenGenerator::getFunctionReturnType(const AbstractMetaFunction* func, Options) const
@@ -1080,12 +1082,15 @@ QString ShibokenGenerator::cpythonCheckFunction(const AbstractMetaType* metaType
             || type == ContainerTypeEntry::SetContainer
             || type == ContainerTypeEntry::QueueContainer) {
             const AbstractMetaType* type = metaType->instantiations().first();
-            if (isPointerToWrapperType(type))
+            if (isPointerToWrapperType(type)) {
                 typeCheck += QString::fromLatin1("checkSequenceTypes(%1, ").arg(cpythonTypeNameExt(type));
-            else if (isWrapperType(type))
-                typeCheck += QString::fromLatin1("convertibleSequenceTypes((SbkObjectType*)%1, ").arg(cpythonTypeNameExt(type));
-            else
+            } else if (isWrapperType(type)) {
+                typeCheck += QLatin1String("convertibleSequenceTypes(reinterpret_cast<const SbkObjectType *>(");
+                typeCheck += cpythonTypeNameExt(type);
+                typeCheck += QLatin1String("), ");
+            } else {
                 typeCheck += QString::fromLatin1("convertibleSequenceTypes(%1, ").arg(converterObject(type));
+            }
         } else if (type == ContainerTypeEntry::MapContainer
             || type == ContainerTypeEntry::MultiMapContainer
             || type == ContainerTypeEntry::HashContainer
@@ -1171,11 +1176,13 @@ QString ShibokenGenerator::cpythonIsConvertibleFunction(const TypeEntry* type,
                                                         bool /* checkExact */)
 {
     if (isWrapperType(type)) {
-        QString isConv = (type->isValue() && !isValueTypeWithCopyConstructorOnly(type))
+        QString result = QLatin1String("Shiboken::Conversions::");
+        result += (type->isValue() && !isValueTypeWithCopyConstructorOnly(type))
                          ? QLatin1String("isPythonToCppValueConvertible")
                          : QLatin1String("isPythonToCppPointerConvertible");
-        return QString::fromLatin1("Shiboken::Conversions::%1((SbkObjectType*)%2, ")
-                  .arg(isConv, cpythonTypeNameExt(type));
+        result += QLatin1String("(reinterpret_cast<SbkObjectType *>(")
+            + cpythonTypeNameExt(type) + QLatin1String("), ");
+        return result;
     }
     return QString::fromLatin1("Shiboken::Conversions::isPythonToCppConvertible(%1, ")
               .arg(converterObject(type));
@@ -1194,15 +1201,16 @@ QString ShibokenGenerator::cpythonIsConvertibleFunction(const AbstractMetaType*
     }
 
     if (isWrapperType(metaType)) {
-        QString isConv;
+        QString result = QLatin1String("Shiboken::Conversions::");
         if (isPointer(metaType) || isValueTypeWithCopyConstructorOnly(metaType))
-            isConv = QLatin1String("isPythonToCppPointerConvertible");
+            result += QLatin1String("isPythonToCppPointerConvertible");
         else if (metaType->referenceType() == LValueReference)
-            isConv = QLatin1String("isPythonToCppReferenceConvertible");
+            result += QLatin1String("isPythonToCppReferenceConvertible");
         else
-            isConv = QLatin1String("isPythonToCppValueConvertible");
-        return QStringLiteral("Shiboken::Conversions::%1((SbkObjectType*)%2, ")
-                  .arg(isConv, cpythonTypeNameExt(metaType));
+            result += QLatin1String("isPythonToCppValueConvertible");
+        result += QLatin1String("(reinterpret_cast<const SbkObjectType *>(")
+            + cpythonTypeNameExt(metaType) + QLatin1String("), ");
+        return result;
     }
     return QStringLiteral("Shiboken::Conversions::isPythonToCppConvertible(%1, ")
               .arg(converterObject(metaType));
@@ -1215,16 +1223,18 @@ QString ShibokenGenerator::cpythonIsConvertibleFunction(const AbstractMetaArgume
 
 QString ShibokenGenerator::cpythonToCppConversionFunction(const AbstractMetaClass* metaClass)
 {
-    return QStringLiteral("Shiboken::Conversions::pythonToCppPointer((SbkObjectType*)%1, ")
-              .arg(cpythonTypeNameExt(metaClass->typeEntry()));
+    return QLatin1String("Shiboken::Conversions::pythonToCppPointer(reinterpret_cast<SbkObjectType *>(")
+        + cpythonTypeNameExt(metaClass->typeEntry()) + QLatin1String("), ");
 }
+
 QString ShibokenGenerator::cpythonToCppConversionFunction(const AbstractMetaType *type,
                                                           const AbstractMetaClass * /* context */)
 {
     if (isWrapperType(type)) {
-        return QStringLiteral("Shiboken::Conversions::pythonToCpp%1((SbkObjectType*)%2, ")
-                  .arg(isPointer(type) ? QLatin1String("Pointer") : QLatin1String("Copy"))
-                  .arg(cpythonTypeNameExt(type));
+        return QLatin1String("Shiboken::Conversions::pythonToCpp")
+            + (isPointer(type) ? QLatin1String("Pointer") : QLatin1String("Copy"))
+            + QLatin1String("(reinterpret_cast<SbkObjectType *>(")
+            + cpythonTypeNameExt(type) + QLatin1String("), ");
     }
     return QStringLiteral("Shiboken::Conversions::pythonToCppCopy(%1, ")
               .arg(converterObject(type));
@@ -1241,9 +1251,12 @@ QString ShibokenGenerator::cpythonToPythonConversionFunction(const AbstractMetaT
             conversion = QLatin1String("copy");
         else
             conversion = QLatin1String("pointer");
-        return QStringLiteral("Shiboken::Conversions::%1ToPython((SbkObjectType*)%2, %3")
-                  .arg(conversion, cpythonTypeNameExt(type),
-                       conversion == QLatin1String("pointer") ? QString() : QLatin1String("&"));
+        QString result = QLatin1String("Shiboken::Conversions::") + conversion
+            + QLatin1String("ToPython(reinterpret_cast<const SbkObjectType *>(")
+            + cpythonTypeNameExt(type) + QLatin1String("), ");
+        if (conversion != QLatin1String("pointer"))
+            result += QLatin1Char('&');
+        return result;
     }
     return QStringLiteral("Shiboken::Conversions::copyToPython(%1, %2")
               .arg(converterObject(type),
@@ -1258,14 +1271,13 @@ QString ShibokenGenerator::cpythonToPythonConversionFunction(const AbstractMetaC
 QString ShibokenGenerator::cpythonToPythonConversionFunction(const TypeEntry* type)
 {
     if (isWrapperType(type)) {
-        QString conversion;
-        if (type->isValue())
-            conversion = QLatin1String("copy");
-        else
-            conversion = QLatin1String("pointer");
-        return QStringLiteral("Shiboken::Conversions::%1ToPython((SbkObjectType*)%2, %3")
-                  .arg(conversion, cpythonTypeNameExt(type),
-                       conversion == QLatin1String("pointer") ? QString() : QLatin1String("&"));
+        const QString conversion = type->isValue() ? QLatin1String("copy") : QLatin1String("pointer");
+         QString result = QLatin1String("Shiboken::Conversions::") + conversion
+             + QLatin1String("ToPython(reinterpret_cast<const SbkObjectType *>(") + cpythonTypeNameExt(type)
+             + QLatin1String("), ");
+         if (conversion != QLatin1String("pointer"))
+             result += QLatin1Char('&');
+        return result;
     }
 
     return QStringLiteral("Shiboken::Conversions::copyToPython(%1, &").arg(converterObject(type));
diff --git a/libshiboken/basewrapper.cpp b/libshiboken/basewrapper.cpp
index d82297d..b3f99a8 100644
--- a/libshiboken/basewrapper.cpp
+++ b/libshiboken/basewrapper.cpp
@@ -1105,8 +1105,8 @@ bool isValid(PyObject* pyObj, bool throwPyError)
     return isValid(reinterpret_cast<SbkObject*>(pyObj), throwPyError);
 }
 
-SbkObject *findColocatedChild(SbkObject* wrapper,
-                              SbkObjectType* instanceType)
+SbkObject *findColocatedChild(SbkObject *wrapper,
+                              const SbkObjectType *instanceType)
 {
     // Degenerate case, wrapper is the correct wrapper.
     if (reinterpret_cast<const void *>(Py_TYPE(wrapper)) == reinterpret_cast<const void *>(instanceType))
diff --git a/libshiboken/basewrapper.h b/libshiboken/basewrapper.h
index 3404198..002337f 100644
--- a/libshiboken/basewrapper.h
+++ b/libshiboken/basewrapper.h
@@ -254,8 +254,8 @@ LIBSHIBOKEN_API Py_hash_t   hash(PyObject* pyObj);
 /**
  * Find a child of given wrapper having same address having the specified type.
  */
-LIBSHIBOKEN_API SbkObject *findColocatedChild(SbkObject* wrapper,
-                                              SbkObjectType* instanceType);
+LIBSHIBOKEN_API SbkObject *findColocatedChild(SbkObject *wrapper,
+                                              const SbkObjectType *instanceType);
 
 /**
  *  Bind a C++ object to Python.
diff --git a/libshiboken/sbkconverter.cpp b/libshiboken/sbkconverter.cpp
index 17af66e..e7e9995 100644
--- a/libshiboken/sbkconverter.cpp
+++ b/libshiboken/sbkconverter.cpp
@@ -169,12 +169,12 @@ void addPythonToCppValueConversion(SbkObjectType* type,
     addPythonToCppValueConversion(type->d->converter, pythonToCppFunc, isConvertibleToCppFunc);
 }
 
-PyObject* pointerToPython(SbkObjectType* type, const void* cppIn)
+PyObject* pointerToPython(const SbkObjectType *type, const void *cppIn)
 {
     return pointerToPython(type->d->converter, cppIn);
 }
 
-PyObject* pointerToPython(SbkConverter* converter, const void* cppIn)
+PyObject* pointerToPython(const SbkConverter *converter, const void *cppIn)
 {
     assert(converter);
     if (!cppIn)
@@ -187,12 +187,12 @@ PyObject* pointerToPython(SbkConverter* converter, const void* cppIn)
     return converter->pointerToPython(cppIn);
 }
 
-PyObject* referenceToPython(SbkObjectType* type, const void* cppIn)
+PyObject* referenceToPython(const SbkObjectType *type, const void *cppIn)
 {
     return referenceToPython(type->d->converter, cppIn);
 }
 
-PyObject* referenceToPython(SbkConverter* converter, const void* cppIn)
+PyObject* referenceToPython(const SbkConverter *converter, const void *cppIn)
 {
     assert(cppIn);
 
@@ -209,7 +209,7 @@ PyObject* referenceToPython(SbkConverter* converter, const void* cppIn)
     return converter->pointerToPython(cppIn);
 }
 
-static inline PyObject* CopyCppToPython(SbkConverter* converter, const void* cppIn)
+static inline PyObject* CopyCppToPython(const SbkConverter *converter, const void *cppIn)
 {
     if (!cppIn)
         Py_RETURN_NONE;
@@ -220,42 +220,42 @@ static inline PyObject* CopyCppToPython(SbkConverter* converter, const void* cpp
     }
     return converter->copyToPython(cppIn);
 }
-PyObject* copyToPython(SbkObjectType* type, const void* cppIn)
+PyObject* copyToPython(const SbkObjectType *type, const void *cppIn)
 {
     return CopyCppToPython(type->d->converter, cppIn);
 }
-PyObject* copyToPython(SbkConverter* converter, const void* cppIn)
+PyObject* copyToPython(const SbkConverter *converter, const void *cppIn)
 {
     return CopyCppToPython(converter, cppIn);
 }
 
-PythonToCppFunc isPythonToCppPointerConvertible(SbkObjectType* type, PyObject* pyIn)
+PythonToCppFunc isPythonToCppPointerConvertible(const 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(const SbkConverter *converter, PyObject *pyIn)
 {
     assert(pyIn);
-    ToCppConversionList& convs = converter->toCppConversions;
-    for (ToCppConversionList::iterator conv = convs.begin(); conv != convs.end(); ++conv) {
+    const ToCppConversionList& convs = converter->toCppConversions;
+    for (ToCppConversionList::const_iterator conv = convs.begin(), end = convs.end(); conv != end; ++conv) {
         PythonToCppFunc toCppFunc = 0;
         if ((toCppFunc = (*conv).first(pyIn)))
             return toCppFunc;
     }
     return 0;
 }
-PythonToCppFunc isPythonToCppValueConvertible(SbkObjectType* type, PyObject* pyIn)
+PythonToCppFunc isPythonToCppValueConvertible(const SbkObjectType *type, PyObject *pyIn)
 {
     return IsPythonToCppConvertible(type->d->converter, pyIn);
 }
-PythonToCppFunc isPythonToCppConvertible(SbkConverter* converter, PyObject* pyIn)
+PythonToCppFunc isPythonToCppConvertible(const SbkConverter *converter, PyObject *pyIn)
 {
     return IsPythonToCppConvertible(converter, pyIn);
 }
 
-PythonToCppFunc isPythonToCppReferenceConvertible(SbkObjectType* type, PyObject* pyIn)
+PythonToCppFunc isPythonToCppReferenceConvertible(const SbkObjectType *type, PyObject *pyIn)
 {
     if (pyIn != Py_None) {
         PythonToCppFunc toCpp = isPythonToCppPointerConvertible(type, pyIn);
@@ -292,7 +292,7 @@ void pythonToCppPointer(SbkObjectType* type, PyObject* pyIn, void* cppOut)
         : cppPointer(reinterpret_cast<PyTypeObject *>(type), reinterpret_cast<SbkObject *>(pyIn));
 }
 
-void pythonToCppPointer(SbkConverter* converter, PyObject* pyIn, void* cppOut)
+void pythonToCppPointer(const SbkConverter *converter, PyObject *pyIn, void *cppOut)
 {
     assert(converter);
     assert(pyIn);
@@ -302,7 +302,7 @@ void pythonToCppPointer(SbkConverter* converter, PyObject* pyIn, void* cppOut)
         : cppPointer(reinterpret_cast<PyTypeObject *>(converter->pythonType), reinterpret_cast<SbkObject *>(pyIn));
 }
 
-static void _pythonToCppCopy(SbkConverter* converter, PyObject* pyIn, void* cppOut)
+static void _pythonToCppCopy(const SbkConverter *converter, PyObject *pyIn, void *cppOut)
 {
     assert(converter);
     assert(pyIn);
@@ -312,18 +312,18 @@ static void _pythonToCppCopy(SbkConverter* converter, PyObject* pyIn, void* cppO
         toCpp(pyIn, cppOut);
 }
 
-void pythonToCppCopy(SbkObjectType* type, PyObject* pyIn, void* cppOut)
+void pythonToCppCopy(const SbkObjectType *type, PyObject *pyIn, void *cppOut)
 {
     assert(type);
     _pythonToCppCopy(type->d->converter, pyIn, cppOut);
 }
 
-void pythonToCppCopy(SbkConverter* converter, PyObject* pyIn, void* cppOut)
+void pythonToCppCopy(const SbkConverter *converter, PyObject *pyIn, void *cppOut)
 {
     _pythonToCppCopy(converter, pyIn, cppOut);
 }
 
-bool isImplicitConversion(SbkObjectType* type, PythonToCppFunc toCppFunc)
+bool isImplicitConversion(const SbkObjectType *type, PythonToCppFunc toCppFunc)
 {
     // This is the Object Type or Value Type conversion that only
     // retrieves the C++ pointer held in the Python wrapper.
@@ -381,7 +381,7 @@ bool checkSequenceTypes(PyTypeObject* type, PyObject* pyIn)
     }
     return true;
 }
-bool convertibleSequenceTypes(SbkConverter* converter, PyObject* pyIn)
+bool convertibleSequenceTypes(const SbkConverter *converter, PyObject *pyIn)
 {
     assert(converter);
     assert(pyIn);
@@ -394,7 +394,7 @@ bool convertibleSequenceTypes(SbkConverter* converter, PyObject* pyIn)
     }
     return true;
 }
-bool convertibleSequenceTypes(SbkObjectType* type, PyObject* pyIn)
+bool convertibleSequenceTypes(const SbkObjectType *type, PyObject *pyIn)
 {
     assert(type);
     return convertibleSequenceTypes(type->d->converter, pyIn);
@@ -415,7 +415,9 @@ bool checkPairTypes(PyTypeObject* firstType, PyTypeObject* secondType, PyObject*
         return false;
     return true;
 }
-bool convertiblePairTypes(SbkConverter* firstConverter, bool firstCheckExact, SbkConverter* secondConverter, bool secondCheckExact, PyObject* pyIn)
+bool convertiblePairTypes(const SbkConverter *firstConverter, bool firstCheckExact,
+                          const SbkConverter *secondConverter, bool secondCheckExact,
+                          PyObject *pyIn)
 {
     assert(firstConverter);
     assert(secondConverter);
@@ -462,7 +464,8 @@ bool checkDictTypes(PyTypeObject* keyType, PyTypeObject* valueType, PyObject* py
     return true;
 }
 
-bool convertibleDictTypes(SbkConverter* keyConverter, bool keyCheckExact, SbkConverter* valueConverter, bool valueCheckExact, PyObject* pyIn)
+bool convertibleDictTypes(const SbkConverter * keyConverter, bool keyCheckExact, const SbkConverter *valueConverter,
+                          bool valueCheckExact, PyObject *pyIn)
 {
     assert(keyConverter);
     assert(valueConverter);
@@ -489,7 +492,7 @@ bool convertibleDictTypes(SbkConverter* keyConverter, bool keyCheckExact, SbkCon
     return true;
 }
 
-PyTypeObject* getPythonTypeObject(SbkConverter* converter)
+PyTypeObject* getPythonTypeObject(const SbkConverter *converter)
 {
     if (converter)
         return converter->pythonType;
@@ -501,18 +504,18 @@ PyTypeObject* getPythonTypeObject(const char* typeName)
     return getPythonTypeObject(getConverter(typeName));
 }
 
-bool pythonTypeIsValueType(SbkConverter* converter)
+bool pythonTypeIsValueType(const SbkConverter *converter)
 {
     assert(converter);
     return converter->pointerToPython && converter->copyToPython;
 }
 
-bool pythonTypeIsObjectType(SbkConverter* converter)
+bool pythonTypeIsObjectType(const SbkConverter *converter)
 {
     return converter->pointerToPython && !converter->copyToPython;
 }
 
-bool pythonTypeIsWrapperType(SbkConverter* converter)
+bool pythonTypeIsWrapperType(const SbkConverter *converter)
 {
     return converter->pointerToPython;
 }
diff --git a/libshiboken/sbkconverter.h b/libshiboken/sbkconverter.h
index 9308013..7489b93 100644
--- a/libshiboken/sbkconverter.h
+++ b/libshiboken/sbkconverter.h
@@ -190,8 +190,8 @@ LIBSHIBOKEN_API void addPythonToCppValueConversion(SbkObjectType* type,
  *      TYPE* var;
  *      PyObject* pyVar = pointerToPython(SBKTYPE, &var);
  */
-LIBSHIBOKEN_API PyObject* pointerToPython(SbkObjectType* type, const void* cppIn);
-LIBSHIBOKEN_API PyObject* pointerToPython(SbkConverter* converter, const void* cppIn);
+LIBSHIBOKEN_API PyObject* pointerToPython(const 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,
@@ -202,8 +202,8 @@ LIBSHIBOKEN_API PyObject* pointerToPython(SbkConverter* converter, const void* c
  *      TYPE& var = SOMETHING;
  *      PyObject* pyVar = referenceToPython(SBKTYPE, &var);
  */
-LIBSHIBOKEN_API PyObject* referenceToPython(SbkObjectType* type, const void* cppIn);
-LIBSHIBOKEN_API PyObject* referenceToPython(SbkConverter* converter, const void* cppIn);
+LIBSHIBOKEN_API PyObject* referenceToPython(const 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.
@@ -212,8 +212,8 @@ LIBSHIBOKEN_API PyObject* referenceToPython(SbkConverter* converter, const void*
  *      TYPE var;
  *      PyObject* pyVar = copyToPython(SBKTYPE, &var);
  */
-LIBSHIBOKEN_API PyObject* copyToPython(SbkObjectType* type, const void* cppIn);
-LIBSHIBOKEN_API PyObject* copyToPython(SbkConverter* converter, const void* cppIn);
+LIBSHIBOKEN_API PyObject* copyToPython(const SbkObjectType *type, const void *cppIn);
+LIBSHIBOKEN_API PyObject* copyToPython(const SbkConverter *converter, const void *cppIn);
 
 // Python -> C++ ---------------------------------------------------------------------------
 
@@ -221,7 +221,7 @@ LIBSHIBOKEN_API PyObject* copyToPython(SbkConverter* converter, const void* cppI
  *  Returns a Python to C++ conversion function if the Python object is convertible to a C++ pointer.
  *  It returns NULL if the Python object is not convertible to \p type.
  */
-LIBSHIBOKEN_API PythonToCppFunc isPythonToCppPointerConvertible(SbkObjectType* type, PyObject* pyIn);
+LIBSHIBOKEN_API PythonToCppFunc isPythonToCppPointerConvertible(const SbkObjectType *type, PyObject *pyIn);
 
 /**
  *  Returns a Python to C++ conversion function if the Python object is convertible to a C++ value.
@@ -229,7 +229,7 @@ LIBSHIBOKEN_API PythonToCppFunc isPythonToCppPointerConvertible(SbkObjectType* t
  *  convert the object to the expected \p type.
  *  It returns NULL if the Python object is not convertible to \p type.
  */
-LIBSHIBOKEN_API PythonToCppFunc isPythonToCppValueConvertible(SbkObjectType* type, PyObject* pyIn);
+LIBSHIBOKEN_API PythonToCppFunc isPythonToCppValueConvertible(const SbkObjectType *type, PyObject *pyIn);
 
 /**
  *  Returns a Python to C++ conversion function if the Python object is convertible to a C++ reference.
@@ -237,10 +237,10 @@ LIBSHIBOKEN_API PythonToCppFunc isPythonToCppValueConvertible(SbkObjectType* typ
  *  or a new C++ value if it must be a implicit conversion.
  *  It returns NULL if the Python object is not convertible to \p type.
  */
-LIBSHIBOKEN_API PythonToCppFunc isPythonToCppReferenceConvertible(SbkObjectType* type, PyObject* pyIn);
+LIBSHIBOKEN_API PythonToCppFunc isPythonToCppReferenceConvertible(const SbkObjectType *type, PyObject *pyIn);
 
 /// This is the same as isPythonToCppValueConvertible function.
-LIBSHIBOKEN_API PythonToCppFunc isPythonToCppConvertible(SbkConverter* converter, PyObject* pyIn);
+LIBSHIBOKEN_API PythonToCppFunc isPythonToCppConvertible(const SbkConverter *converter, PyObject *pyIn);
 
 /**
  *  Returns the C++ pointer for the \p pyIn object cast to the type passed via \p desiredType.
@@ -251,11 +251,11 @@ 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(SbkConverter* converter, 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.
-LIBSHIBOKEN_API void pythonToCppCopy(SbkObjectType* type, PyObject* pyIn, void* cppOut);
-LIBSHIBOKEN_API void pythonToCppCopy(SbkConverter* converter, PyObject* pyIn, void* cppOut);
+LIBSHIBOKEN_API void pythonToCppCopy(const SbkObjectType *type, PyObject *pyIn, void *cppOut);
+LIBSHIBOKEN_API void pythonToCppCopy(const SbkConverter *converter, PyObject *pyIn, void *cppOut);
 
 /**
  *  Helper function returned by generated convertible checking functions
@@ -268,7 +268,7 @@ LIBSHIBOKEN_API void nonePythonToCppNullPtr(PyObject*, void* cppOut);
  *  It is used when C++ expects a reference argument, so it may be the same object received
  *  from Python, or another created through implicit conversion.
  */
-LIBSHIBOKEN_API bool isImplicitConversion(SbkObjectType* type, PythonToCppFunc toCpp);
+LIBSHIBOKEN_API bool isImplicitConversion(const 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);
@@ -283,37 +283,41 @@ LIBSHIBOKEN_API SbkConverter* primitiveTypeConverter(int index);
 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(SbkConverter* converter, PyObject* pyIn);
+LIBSHIBOKEN_API bool convertibleSequenceTypes(const SbkConverter *converter, PyObject *pyIn);
 
 /// Returns true if a Python sequence is comprised of objects of a type convertible to \p type.
-LIBSHIBOKEN_API bool convertibleSequenceTypes(SbkObjectType* type, PyObject* pyIn);
+LIBSHIBOKEN_API bool convertibleSequenceTypes(const 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);
 
 /// Returns true if a Python sequence can be converted to a C++ pair.
-LIBSHIBOKEN_API bool convertiblePairTypes(SbkConverter* firstConverter, bool firstCheckExact, SbkConverter* secondConverter, bool secondCheckExact, PyObject* pyIn);
+LIBSHIBOKEN_API bool convertiblePairTypes(const SbkConverter *firstConverter, bool firstCheckExact,
+                                          const SbkConverter *secondConverter, bool secondCheckExact,
+                                          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);
 
 /// Returns true if a Python dictionary can be converted to a C++ hash or map.
-LIBSHIBOKEN_API bool convertibleDictTypes(SbkConverter* keyConverter, bool keyCheckExact, SbkConverter* valueConverter, bool valueCheckExact, PyObject* pyIn);
+LIBSHIBOKEN_API bool convertibleDictTypes(const SbkConverter *keyConverter, bool keyCheckExact,
+                                          const SbkConverter *valueConverter, bool valueCheckExact,
+                                          PyObject *pyIn);
 
 /// Returns the Python type object associated with the given \p converter.
-LIBSHIBOKEN_API PyTypeObject* getPythonTypeObject(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);
 
 /// Returns true if the Python type associated with the converter is a value type.
-LIBSHIBOKEN_API bool pythonTypeIsValueType(SbkConverter* converter);
+LIBSHIBOKEN_API bool pythonTypeIsValueType(const SbkConverter *converter);
 
 /// Returns true if the Python type associated with the converter is an object type.
-LIBSHIBOKEN_API bool pythonTypeIsObjectType(SbkConverter* converter);
+LIBSHIBOKEN_API bool pythonTypeIsObjectType(const SbkConverter *converter);
 
 /// Returns true if the Python type associated with the converter is a wrapper type.
-LIBSHIBOKEN_API bool pythonTypeIsWrapperType(SbkConverter* converter);
+LIBSHIBOKEN_API bool pythonTypeIsWrapperType(const SbkConverter *converter);
 
 #define SBK_PY_LONG_LONG_IDX            0
 // Qt5: name collision in QtCore after QBool is replaced by bool