QtQuick: Fix string related warnings, single character strings.

- Fix warnings about truncation from size_t to int (MSVC 2010,
  64bit).
- Remove single character strings.

Change-Id: Iaf4406e4e04d55d2d8b762f3433269868842a6f9
Reviewed-by: Roberto Raggi <roberto.raggi@nokia.com>

20 files changed, 179 insertions, 179 deletions

diff --git a/src/qml/qml/qqml.h b/src/qml/qml/qqml.h
index 5b500e0814..1dbca44a08 100644
--- a/src/qml/qml/qqml.h
+++ b/src/qml/qml/qqml.h
@@ -95,7 +95,7 @@ int qmlRegisterType()
     QByteArray name(T::staticMetaObject.className());
 
     QByteArray pointerName(name + '*');
-    QByteArray listName("QQmlListProperty<" + name + ">");
+    QByteArray listName("QQmlListProperty<" + name + '>');
 
     QQmlPrivate::RegisterType type = {
         0, 
@@ -131,7 +131,7 @@ int qmlRegisterUncreatableType(const char *uri, int versionMajor, int versionMin
     QByteArray name(T::staticMetaObject.className());
 
     QByteArray pointerName(name + '*');
-    QByteArray listName("QQmlListProperty<" + name + ">");
+    QByteArray listName("QQmlListProperty<" + name + '>');
 
     QQmlPrivate::RegisterType type = {
         0,
@@ -165,7 +165,7 @@ int qmlRegisterType(const char *uri, int versionMajor, int versionMinor, const c
     QByteArray name(T::staticMetaObject.className());
 
     QByteArray pointerName(name + '*');
-    QByteArray listName("QQmlListProperty<" + name + ">");
+    QByteArray listName("QQmlListProperty<" + name + '>');
 
     QQmlPrivate::RegisterType type = {
         0, 
@@ -199,7 +199,7 @@ int qmlRegisterType(const char *uri, int versionMajor, int versionMinor, const c
     QByteArray name(T::staticMetaObject.className());
 
     QByteArray pointerName(name + '*');
-    QByteArray listName("QQmlListProperty<" + name + ">");
+    QByteArray listName("QQmlListProperty<" + name + '>');
 
     QQmlPrivate::RegisterType type = {
         1,
@@ -233,7 +233,7 @@ int qmlRegisterRevision(const char *uri, int versionMajor, int versionMinor)
     QByteArray name(T::staticMetaObject.className());
 
     QByteArray pointerName(name + '*');
-    QByteArray listName("QQmlListProperty<" + name + ">");
+    QByteArray listName("QQmlListProperty<" + name + '>');
 
     QQmlPrivate::RegisterType type = {
         1,
@@ -268,7 +268,7 @@ int qmlRegisterExtendedType()
     QByteArray name(T::staticMetaObject.className());
 
     QByteArray pointerName(name + '*');
-    QByteArray listName("QQmlListProperty<" + name + ">");
+    QByteArray listName("QQmlListProperty<" + name + '>');
 
     QQmlPrivate::RegisterType type = {
         0, 
@@ -303,7 +303,7 @@ int qmlRegisterExtendedType(const char *uri, int versionMajor, int versionMinor,
     QByteArray name(T::staticMetaObject.className());
 
     QByteArray pointerName(name + '*');
-    QByteArray listName("QQmlListProperty<" + name + ">");
+    QByteArray listName("QQmlListProperty<" + name + '>');
 
     QQmlAttachedPropertiesFunc attached = QQmlPrivate::attachedPropertiesFunc<E>();
     const QMetaObject * attachedMetaObject = QQmlPrivate::attachedPropertiesMetaObject<E>(); 
@@ -344,7 +344,7 @@ int qmlRegisterInterface(const char *typeName)
     QByteArray name(typeName);
 
     QByteArray pointerName(name + '*');
-    QByteArray listName("QQmlListProperty<" + name + ">");
+    QByteArray listName("QQmlListProperty<" + name + '>');
 
     QQmlPrivate::RegisterInterface qmlInterface = {
         0,
@@ -365,7 +365,7 @@ int qmlRegisterCustomType(const char *uri, int versionMajor, int versionMinor,
     QByteArray name(T::staticMetaObject.className());
 
     QByteArray pointerName(name + '*');
-    QByteArray listName("QQmlListProperty<" + name + ">");
+    QByteArray listName("QQmlListProperty<" + name + '>');
 
     QQmlPrivate::RegisterType type = {
         0, 
diff --git a/src/qml/qml/qqmlaccessors_p.h b/src/qml/qml/qqmlaccessors_p.h
index 7558ab3e35..5685869f73 100644
--- a/src/qml/qml/qqmlaccessors_p.h
+++ b/src/qml/qml/qqmlaccessors_p.h
@@ -142,7 +142,7 @@ QQmlAccessorProperties::Properties::property(const char *name)
     if (count == 0)
         return 0;
 
-    unsigned int length = strlen(name);
+    const unsigned int length = (unsigned int)strlen(name);
 
     Q_ASSERT(length);
 
diff --git a/src/qml/qml/qqmlbinding.cpp b/src/qml/qml/qqmlbinding.cpp
index d60a1b461f..1e25c15b09 100644
--- a/src/qml/qml/qqmlbinding.cpp
+++ b/src/qml/qml/qqmlbinding.cpp
@@ -279,7 +279,7 @@ QString QQmlBinding::expressionIdentifier(QQmlJavaScriptExpression *e)
 {
     QQmlBinding *This = static_cast<QQmlBinding *>(e);
 
-    return QLatin1String("\"") + QString::fromUtf8(This->m_expression) + QLatin1String("\"");
+    return QLatin1Char('"') + QString::fromUtf8(This->m_expression) + QLatin1Char('"');
 }
 
 void QQmlBinding::expressionChanged(QQmlJavaScriptExpression *e)
diff --git a/src/qml/qml/qqmlboundsignal.cpp b/src/qml/qml/qqmlboundsignal.cpp
index 8b3a39c12e..17237d4b78 100644
--- a/src/qml/qml/qqmlboundsignal.cpp
+++ b/src/qml/qml/qqmlboundsignal.cpp
@@ -104,7 +104,7 @@ QQmlBoundSignalExpression::~QQmlBoundSignalExpression()
 QString QQmlBoundSignalExpression::expressionIdentifier(QQmlJavaScriptExpression *e)
 {
     QQmlBoundSignalExpression *This = static_cast<QQmlBoundSignalExpression *>(e);
-    return QLatin1String("\"") + This->m_expression + QLatin1String("\"");
+    return QLatin1Char('"') + This->m_expression + QLatin1Char('"');
 }
 
 void QQmlBoundSignalExpression::expressionChanged(QQmlJavaScriptExpression *)
diff --git a/src/qml/qml/qqmlcompileddata.cpp b/src/qml/qml/qqmlcompileddata.cpp
index 6a68784219..6e6da6ae0d 100644
--- a/src/qml/qml/qqmlcompileddata.cpp
+++ b/src/qml/qml/qqmlcompileddata.cpp
@@ -66,7 +66,7 @@ int QQmlCompiledData::pack(const char *data, size_t size)
     }
 
     int rv = packData.size();
-    packData.append(data, size);
+    packData.append(data, int(size));
     return rv;
 }
 
diff --git a/src/qml/qml/qqmlcompiler.cpp b/src/qml/qml/qqmlcompiler.cpp
index d5775b63f4..2275b559b5 100644
--- a/src/qml/qml/qqmlcompiler.cpp
+++ b/src/qml/qml/qqmlcompiler.cpp
@@ -2895,7 +2895,7 @@ bool QQmlCompiler::buildDynamicMeta(QQmlScript::Object *obj, DynamicMetaMode mod
                     propertyType = QMetaType::QObjectStar;
                 } else {
                     readonly = true;
-                    customTypeName = QByteArray("QQmlListProperty<") + customTypeName + QByteArray(">");
+                    customTypeName = QByteArrayLiteral("QQmlListProperty<") + customTypeName + '>';
                     propertyType = qMetaTypeId<QQmlListProperty<QObject> >();
                 }
 
@@ -2920,7 +2920,7 @@ bool QQmlCompiler::buildDynamicMeta(QQmlScript::Object *obj, DynamicMetaMode mod
                                 readonly?QFastMetaBuilder::None:QFastMetaBuilder::Writable,
                                 effectivePropertyIndex);
 
-            p->changedNameRef = builder.newString(p->name.utf8length() + strlen("Changed"));
+            p->changedNameRef = builder.newString(p->name.utf8length() + Changed_string.size());
             builder.setSignal(effectivePropertyIndex, p->changedNameRef, paramIndex);
             paramIndex++;
 
@@ -2945,7 +2945,7 @@ bool QQmlCompiler::buildDynamicMeta(QQmlScript::Object *obj, DynamicMetaMode mod
                                         p->isReadOnly?QFastMetaBuilder::None:QFastMetaBuilder::Writable,
                                         effectivePropertyIndex);
 
-                    p->changedNameRef = builder.newString(p->name.utf8length() + strlen("Changed"));
+                    p->changedNameRef = builder.newString(p->name.utf8length() + Changed_string.size());
                     builder.setSignal(effectivePropertyIndex, p->changedNameRef, paramIndex);
                     paramIndex++;
 
@@ -2966,7 +2966,7 @@ bool QQmlCompiler::buildDynamicMeta(QQmlScript::Object *obj, DynamicMetaMode mod
                     }
                     // Even if we aren't resolving the alias, we need a fake signal so that the 
                     // metaobject remains consistent across the resolve and non-resolve alias runs
-                    p->changedNameRef = builder.newString(p->name.utf8length() + strlen("Changed"));
+                    p->changedNameRef = builder.newString(p->name.utf8length() + Changed_string.size());
                     builder.setSignal(effectivePropertyIndex, p->changedNameRef, paramIndex);
                     paramIndex++;
                     effectivePropertyIndex++;
@@ -2979,7 +2979,7 @@ bool QQmlCompiler::buildDynamicMeta(QQmlScript::Object *obj, DynamicMetaMode mod
     // Reserve default property
     QFastMetaBuilder::StringRef defPropRef;
     if (defaultProperty) {
-        defPropRef = builder.newString(strlen("DefaultProperty"));
+        defPropRef = builder.newString(int(sizeof("DefaultProperty")) - 1);
         builder.setClassInfo(0, defPropRef, defaultProperty->nameRef);
     }
 
@@ -3036,7 +3036,7 @@ bool QQmlCompiler::buildDynamicMeta(QQmlScript::Object *obj, DynamicMetaMode mod
                 QString funcScript;
                 int namesSize = 0;
                 if (paramCount) namesSize += s->parameterNamesLength() + (paramCount - 1 /* commas */);
-                funcScript.reserve(strlen("(function ") + s->name.length() + 1 /* lparen */ +
+                funcScript.reserve(int(sizeof("(function ")) - 1  + s->name.length() + 1 /* lparen */ +
                         namesSize + 1 /* rparen */ + s->body.length() + 1 /* rparen */);
                 funcScript = QLatin1String("(function ") + s->name.toString() + QLatin1Char('(');
                 for (int jj = 0; jj < paramCount; ++jj) {
@@ -3647,9 +3647,9 @@ void QQmlCompiler::dumpStats()
                 output.append("            ");
             }
 
-            output.append("(");
+            output.append('(');
             output.append(QByteArray::number(stat.optimizedBindings.at(ii).start.line));
-            output.append(":");
+            output.append(':');
             output.append(QByteArray::number(stat.optimizedBindings.at(ii).start.column));
             output.append(") ");
         }
@@ -3662,13 +3662,13 @@ void QQmlCompiler::dumpStats()
         QByteArray output;
         for (int ii = 0; ii < stat.sharedBindings.count(); ++ii) {
             if (0 == (ii % 10)) {
-                if (ii) output.append("\n");
+                if (ii) output.append('\n');
                 output.append("            ");
             }
 
-            output.append("(");
+            output.append('(');
             output.append(QByteArray::number(stat.sharedBindings.at(ii).start.line));
-            output.append(":");
+            output.append(':');
             output.append(QByteArray::number(stat.sharedBindings.at(ii).start.column));
             output.append(") ");
         }
@@ -3681,13 +3681,13 @@ void QQmlCompiler::dumpStats()
         QByteArray output;
         for (int ii = 0; ii < stat.scriptBindings.count(); ++ii) {
             if (0 == (ii % 10)) {
-                if (ii) output.append("\n");
+                if (ii) output.append('\n');
                 output.append("            ");
             }
 
-            output.append("(");
+            output.append('(');
             output.append(QByteArray::number(stat.scriptBindings.at(ii).start.line));
-            output.append(":");
+            output.append(':');
             output.append(QByteArray::number(stat.scriptBindings.at(ii).start.column));
             output.append(") ");
         }
diff --git a/src/qml/qml/qqmlengine.cpp b/src/qml/qml/qqmlengine.cpp
index 107e0b5fed..849c83d466 100644
--- a/src/qml/qml/qqmlengine.cpp
+++ b/src/qml/qml/qqmlengine.cpp
@@ -1770,7 +1770,7 @@ QQmlPropertyCache *QQmlEnginePrivate::createCache(QQmlType *type, int minorVersi
     if (overloadError) {
         if (hasCopied) raw->release();
 
-        error.setDescription(QLatin1String("Type ") + type->qmlTypeName() + QLatin1String(" ") + QString::number(type->majorVersion()) + QLatin1String(".") + QString::number(minorVersion) + QLatin1String(" contains an illegal property \"") + overloadName + QLatin1String("\".  This is an error in the type's implementation."));
+        error.setDescription(QLatin1String("Type ") + type->qmlTypeName() + QLatin1Char(' ') + QString::number(type->majorVersion()) + QLatin1Char('.') + QString::number(minorVersion) + QLatin1String(" contains an illegal property \"") + overloadName + QLatin1String("\".  This is an error in the type's implementation."));
         return 0;
     }
 
diff --git a/src/qml/qml/qqmlexpression.cpp b/src/qml/qml/qqmlexpression.cpp
index c333df1d02..89aa6b3906 100644
--- a/src/qml/qml/qqmlexpression.cpp
+++ b/src/qml/qml/qqmlexpression.cpp
@@ -555,7 +555,7 @@ void QQmlExpressionPrivate::expressionChanged()
 QString QQmlExpressionPrivate::expressionIdentifier(QQmlJavaScriptExpression *e)
 {
     QQmlExpressionPrivate *This = static_cast<QQmlExpressionPrivate *>(e);
-    return QLatin1String("\"") + This->expression + QLatin1String("\"");
+    return QLatin1Char('"') + This->expression + QLatin1Char('"');
 }
 
 QT_END_NAMESPACE
diff --git a/src/qml/qml/qqmlimport.cpp b/src/qml/qml/qqmlimport.cpp
index d300c38aba..610257de38 100644
--- a/src/qml/qml/qqmlimport.cpp
+++ b/src/qml/qml/qqmlimport.cpp
@@ -339,10 +339,10 @@ bool QQmlImports::resolveType(const QString& type,
         if (d->resolveType(type,vmaj,vmin,type_return,url_return, errors)) {
             if (qmlImportTrace()) {
 #define RESOLVE_TYPE_DEBUG qDebug().nospace() << "QQmlImports(" << qPrintable(baseUrl().toString()) \
-                                              << ")" << "::resolveType: " << type << " => "
+                                              << ')' << "::resolveType: " << type << " => "
 
                 if (type_return && *type_return && url_return && !url_return->isEmpty())
-                    RESOLVE_TYPE_DEBUG << (*type_return)->typeName() << " " << *url_return;
+                    RESOLVE_TYPE_DEBUG << (*type_return)->typeName() << ' ' << *url_return;
                 if (type_return && *type_return)
                     RESOLVE_TYPE_DEBUG << (*type_return)->typeName();
                 if (url_return && !url_return->isEmpty())
@@ -1053,8 +1053,8 @@ bool QQmlImports::addImport(QQmlImportDatabase *importDb,
     Q_ASSERT(errors);
 
     if (qmlImportTrace())
-        qDebug().nospace() << "QQmlImports(" << qPrintable(baseUrl().toString()) << ")" << "::addImport: "
-                           << uri << " " << vmaj << '.' << vmin << " "
+        qDebug().nospace() << "QQmlImports(" << qPrintable(baseUrl().toString()) << ')' << "::addImport: "
+                           << uri << ' ' << vmaj << '.' << vmin << ' '
                            << (importType==QQmlScript::Import::Library? "Library" : "File")
                            << " as " << prefix;
 
diff --git a/src/qml/qml/qqmlproperty.cpp b/src/qml/qml/qqmlproperty.cpp
index 111a99bd98..224d6a6bd5 100644
--- a/src/qml/qml/qqmlproperty.cpp
+++ b/src/qml/qml/qqmlproperty.cpp
@@ -1714,7 +1714,7 @@ bool QQmlProperty::connectNotifySignal(QObject *dest, const char *slot) const
 
     QMetaProperty prop = d->object->metaObject()->property(d->core.coreIndex);
     if (prop.hasNotifySignal()) {
-        QByteArray signal(QByteArray("2") + prop.notifySignal().methodSignature());
+        QByteArray signal('2' + prop.notifySignal().methodSignature());
         return QObject::connect(d->object, signal.constData(), dest, slot);
     } else  {
         return false;
diff --git a/src/qml/qml/qqmltypeloader.cpp b/src/qml/qml/qqmltypeloader.cpp
index 4b5aa6cd32..74a535fce0 100644
--- a/src/qml/qml/qqmltypeloader.cpp
+++ b/src/qml/qml/qqmltypeloader.cpp
@@ -1499,7 +1499,7 @@ const QQmlDirParser *QQmlTypeLoader::qmlDirParser(const QString &filePath,
                 if (QQmlBundle::isBundleHeader(data.constData(), data.length())) {
                     QString id = bundleIdForQmldir(filePath, uriHint);
 
-                    QString bundleUrl = QLatin1String("bundle://") + id + QLatin1String("/");
+                    QString bundleUrl = QLatin1String("bundle://") + id + QLatin1Char('/');
                     qmldirParser->adjustedUrl = bundleUrl;
 
                     QUrl url(bundleUrl + QLatin1String("qmldir"));
diff --git a/src/qml/qml/qqmlxmlhttprequest.cpp b/src/qml/qml/qqmlxmlhttprequest.cpp
index e829b8b072..21d9c0e700 100644
--- a/src/qml/qml/qqmlxmlhttprequest.cpp
+++ b/src/qml/qml/qqmlxmlhttprequest.cpp
@@ -1163,7 +1163,7 @@ void QQmlXMLHttpRequest::requestFromUrl(const QUrl &url)
     }
 
     if (xhrDump()) {
-        qWarning().nospace() << "XMLHttpRequest: " << qPrintable(m_method) << " " << qPrintable(url.toString());
+        qWarning().nospace() << "XMLHttpRequest: " << qPrintable(m_method) << ' ' << qPrintable(url.toString());
         if (!m_data.isEmpty()) {
             qWarning().nospace() << "                " 
                                  << qPrintable(QString::fromUtf8(m_data));
@@ -1292,7 +1292,7 @@ void QQmlXMLHttpRequest::error(QNetworkReply::NetworkError error)
 
     if (xhrDump()) {
         qWarning().nospace() << "XMLHttpRequest: ERROR " << qPrintable(m_url.toString());
-        qWarning().nospace() << "    " << error << " " << errorToString(error) << " " << m_statusText;
+        qWarning().nospace() << "    " << error << ' ' << errorToString(error) << ' ' << m_statusText;
     }
 
     if (error == QNetworkReply::ContentAccessDenied ||
diff --git a/src/qml/qml/v4/qv4bindings.cpp b/src/qml/qml/v4/qv4bindings.cpp
index 896bf21538..2c60883207 100644
--- a/src/qml/qml/v4/qv4bindings.cpp
+++ b/src/qml/qml/v4/qv4bindings.cpp
@@ -386,7 +386,7 @@ void QV4Bindings::run(Binding *binding, QQmlPropertyPrivate::WriteFlags flags)
             Q_ASSERT(vt);
 
             name = QLatin1String(binding->target->metaObject()->property(binding->property & 0xFFFF).name());
-            name.append(QLatin1String("."));
+            name.append(QLatin1Char('.'));
             name.append(QLatin1String(vt->metaObject()->property(binding->property >> 24).name()));
         } else {
             name = QLatin1String(binding->target->metaObject()->property(binding->property).name());
@@ -598,7 +598,7 @@ static void testBindingResult(const QString &binding, int line, int column,
         iserror = true;
 
     if (iserror) {
-        qWarning().nospace() << "QV4: Optimization error @" << context->url.toString().toUtf8().constData() << ":" << line << ":" << column;
+        qWarning().nospace() << "QV4: Optimization error @" << context->url.toString().toUtf8().constData() << ':' << line << ':' << column;
 
         qWarning().nospace() << "    Binding:  " << binding;
         qWarning().nospace() << "    QtScript: " << qtscriptResult.constData();
@@ -615,7 +615,7 @@ static void testBindingException(const QString &binding, int line, int column,
 
     if (!expression.hasError()) {
         QByteArray qtscriptResult = testResultToString(value, isUndefined);
-        qWarning().nospace() << "QV4: Optimization error @" << context->url.toString().toUtf8().constData() << ":" << line << ":" << column;
+        qWarning().nospace() << "QV4: Optimization error @" << context->url.toString().toUtf8().constData() << ':' << line << ':' << column;
         qWarning().nospace() << "    Binding:  " << binding;
         qWarning().nospace() << "    QtScript: " << qtscriptResult.constData();
         qWarning().nospace() << "    V4:       exception";
diff --git a/src/qml/qml/v4/qv4compiler.cpp b/src/qml/qml/v4/qv4compiler.cpp
index dc7759d45a..783e147ba0 100644
--- a/src/qml/qml/v4/qv4compiler.cpp
+++ b/src/qml/qml/v4/qv4compiler.cpp
@@ -763,7 +763,7 @@ void QV4CompilerPrivate::visitBinop(IR::Binop *e)
                                  << "(`" << IR::binaryOperator(e->left->type)
                                  << "' and `"
                                  << IR::binaryOperator(e->right->type)
-                                 << "'";
+                                 << '\'';
         discard();
         return;
     }
diff --git a/src/qml/qml/v4/qv4instruction.cpp b/src/qml/qml/v4/qv4instruction.cpp
index f5e59ebc34..fccb0f7b98 100644
--- a/src/qml/qml/v4/qv4instruction.cpp
+++ b/src/qml/qml/v4/qv4instruction.cpp
@@ -84,354 +84,354 @@ void Bytecode::dump(const V4Instr *i, int address) const
     if (address != -1) {
         leading = QByteArray::number(address);
         leading.prepend(QByteArray(8 - leading.count(), ' '));
-        leading.append("\t");
+        leading.append('\t');
     }
 
 #define INSTR_DUMP qWarning().nospace() << leading.constData() 
 
     switch (instructionType(i)) {
     case V4Instr::Noop:
-        INSTR_DUMP << "\t" << "Noop";
+        INSTR_DUMP << '\t' << "Noop";
         break;
     case V4Instr::BindingId:
-        INSTR_DUMP << i->id.line << ":" << i->id.column << ":";
+        INSTR_DUMP << i->id.line << ':' << i->id.column << ':';
         break;
     case V4Instr::Subscribe:
-        INSTR_DUMP << "\t" << "Subscribe" << "\t\t" << "Object_Reg(" << i->subscribeop.reg << ") Notify_Signal(" << i->subscribeop.index << ") -> Subscribe_Slot(" << i->subscribeop.offset << ")";
+        INSTR_DUMP << '\t' << "Subscribe" << "\t\t" << "Object_Reg(" << i->subscribeop.reg << ") Notify_Signal(" << i->subscribeop.index << ") -> Subscribe_Slot(" << i->subscribeop.offset << ')';
         break;
     case V4Instr::SubscribeId:
-        INSTR_DUMP << "\t" << "SubscribeId" << "\t\t" << "Id_Offset(" << i->subscribeop.index << ") -> Subscribe_Slot(" << i->subscribeop.offset << ")";
+        INSTR_DUMP << '\t' << "SubscribeId" << "\t\t" << "Id_Offset(" << i->subscribeop.index << ") -> Subscribe_Slot(" << i->subscribeop.offset << ')';
         break;
     case V4Instr::FetchAndSubscribe:
-        INSTR_DUMP << "\t" << "FetchAndSubscribe" << "\t" << "Object_Reg(" << i->fetchAndSubscribe.reg << ") Fast_Accessor(" << i->fetchAndSubscribe.property.accessors << ") -> Output_Reg(" << i->fetchAndSubscribe.reg << ") Subscription_Slot(" <<  i->fetchAndSubscribe.subscription << ")";
+        INSTR_DUMP << '\t' << "FetchAndSubscribe" << '\t' << "Object_Reg(" << i->fetchAndSubscribe.reg << ") Fast_Accessor(" << i->fetchAndSubscribe.property.accessors << ") -> Output_Reg(" << i->fetchAndSubscribe.reg << ") Subscription_Slot(" <<  i->fetchAndSubscribe.subscription << ')';
         break;
     case V4Instr::LoadId:
-        INSTR_DUMP << "\t" << "LoadId" << "\t\t\t" << "Id_Offset(" << i->load.index << ") -> Output_Reg(" << i->load.reg << ")";
+        INSTR_DUMP << '\t' << "LoadId" << "\t\t\t" << "Id_Offset(" << i->load.index << ") -> Output_Reg(" << i->load.reg << ')';
         break;
     case V4Instr::LoadScope:
-        INSTR_DUMP << "\t" << "LoadScope" << "\t\t" << "-> Output_Reg(" << i->load.reg << ")";
+        INSTR_DUMP << '\t' << "LoadScope" << "\t\t" << "-> Output_Reg(" << i->load.reg << ')';
         break;
     case V4Instr::LoadRoot:
-        INSTR_DUMP << "\t" << "LoadRoot" << "\t\t" << "-> Output_Reg(" << i->load.reg << ")";
+        INSTR_DUMP << '\t' << "LoadRoot" << "\t\t" << "-> Output_Reg(" << i->load.reg << ')';
         break;
     case V4Instr::LoadModuleObject:
-        INSTR_DUMP << "\t" << "LoadModuleObject" << "\t\t" << ") -> Output_Reg(" << i->load.reg << ")";
+        INSTR_DUMP << '\t' << "LoadModuleObject" << "\t\t" << ") -> Output_Reg(" << i->load.reg << ')';
         break;
     case V4Instr::LoadAttached:
-        INSTR_DUMP << "\t" << "LoadAttached" << "\t\t" << "Object_Reg(" << i->attached.reg << ") Attached_Index(" << i->attached.id << ") -> Output_Reg(" << i->attached.output << ")";
+        INSTR_DUMP << '\t' << "LoadAttached" << "\t\t" << "Object_Reg(" << i->attached.reg << ") Attached_Index(" << i->attached.id << ") -> Output_Reg(" << i->attached.output << ')';
         break;
     case V4Instr::UnaryNot:
-        INSTR_DUMP << "\t" << "UnaryNot" << "\t\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "UnaryNot" << "\t\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::UnaryMinusNumber:
-        INSTR_DUMP << "\t" << "UnaryMinusNumber" << "\t\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "UnaryMinusNumber" << "\t\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::UnaryMinusInt:
-        INSTR_DUMP << "\t" << "UnaryMinusInt" << "\t\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "UnaryMinusInt" << "\t\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::UnaryPlusNumber:
-        INSTR_DUMP << "\t" << "UnaryPlusNumber" << "\t\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "UnaryPlusNumber" << "\t\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::UnaryPlusInt:
-        INSTR_DUMP << "\t" << "UnaryPlusInt" << "\t\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "UnaryPlusInt" << "\t\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::ConvertBoolToInt:
-        INSTR_DUMP << "\t" << "ConvertBoolToInt" << "\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "ConvertBoolToInt" << '\t' << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::ConvertBoolToNumber:
-        INSTR_DUMP << "\t" << "ConvertBoolToNumber" << "\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "ConvertBoolToNumber" << '\t' << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::ConvertBoolToString:
-        INSTR_DUMP << "\t" << "ConvertBoolToString" << "\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "ConvertBoolToString" << '\t' << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::ConvertBoolToVariant:
-        INSTR_DUMP << "\t" << "ConvertBoolToVariant" << "\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "ConvertBoolToVariant" << '\t' << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::ConvertBoolToVar:
-        INSTR_DUMP << "\t" << "ConvertBoolToVar" << "\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "ConvertBoolToVar" << '\t' << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::ConvertIntToBool:
-        INSTR_DUMP << "\t" << "ConvertIntToBool" << "\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "ConvertIntToBool" << '\t' << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::ConvertIntToNumber:
-        INSTR_DUMP << "\t" << "ConvertIntToNumber" << "\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "ConvertIntToNumber" << '\t' << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::ConvertIntToString:
-        INSTR_DUMP << "\t" << "ConvertIntToString" << "\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "ConvertIntToString" << '\t' << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::ConvertIntToVariant:
-        INSTR_DUMP << "\t" << "ConvertIntToVariant" << "\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "ConvertIntToVariant" << '\t' << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::ConvertIntToVar:
-        INSTR_DUMP << "\t" << "ConvertIntToVar" << "\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "ConvertIntToVar" << '\t' << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::ConvertNumberToBool:
-        INSTR_DUMP << "\t" << "ConvertNumberToBool" << "\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "ConvertNumberToBool" << '\t' << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::ConvertNumberToInt:
-        INSTR_DUMP << "\t" << "ConvertNumberToInt" << "\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "ConvertNumberToInt" << '\t' << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::ConvertNumberToString:
-        INSTR_DUMP << "\t" << "ConvertNumberToString" << "\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "ConvertNumberToString" << '\t' << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::ConvertNumberToVariant:
-        INSTR_DUMP << "\t" << "ConvertNumberToVariant" << "\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "ConvertNumberToVariant" << '\t' << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::ConvertNumberToVar:
-        INSTR_DUMP << "\t" << "ConvertNumberToVar" << "\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "ConvertNumberToVar" << '\t' << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::ConvertStringToBool:
-        INSTR_DUMP << "\t" << "ConvertStringToBool" << "\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "ConvertStringToBool" << '\t' << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::ConvertStringToInt:
-        INSTR_DUMP << "\t" << "ConvertStringToInt" << "\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "ConvertStringToInt" << '\t' << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::ConvertStringToNumber:
-        INSTR_DUMP << "\t" << "ConvertStringToNumber" << "\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "ConvertStringToNumber" << '\t' << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::ConvertStringToUrl:
-        INSTR_DUMP << "\t" << "ConvertStringToUrl" << "\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "ConvertStringToUrl" << '\t' << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::ConvertStringToColor:
-        INSTR_DUMP << "\t" << "ConvertStringToColor" << "\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "ConvertStringToColor" << '\t' << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::ConvertStringToVariant:
-        INSTR_DUMP << "\t" << "ConvertStringToVariant" << "\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "ConvertStringToVariant" << '\t' << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::ConvertStringToVar:
-        INSTR_DUMP << "\t" << "ConvertStringToVar" << "\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "ConvertStringToVar" << '\t' << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::ConvertUrlToBool:
-        INSTR_DUMP << "\t" << "ConvertUrlToBool" << "\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "ConvertUrlToBool" << '\t' << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::ConvertUrlToString:
-        INSTR_DUMP << "\t" << "ConvertUrlToString" << "\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "ConvertUrlToString" << '\t' << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::ConvertUrlToVariant:
-        INSTR_DUMP << "\t" << "ConvertUrlToVariant" << "\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "ConvertUrlToVariant" << '\t' << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::ConvertUrlToVar:
-        INSTR_DUMP << "\t" << "ConvertUrlToVar" << "\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "ConvertUrlToVar" << '\t' << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::ConvertColorToBool:
-        INSTR_DUMP << "\t" << "ConvertColorToBool" << "\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "ConvertColorToBool" << '\t' << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::ConvertColorToString:
-        INSTR_DUMP << "\t" << "ConvertColorToString" << "\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "ConvertColorToString" << '\t' << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::ConvertColorToVariant:
-        INSTR_DUMP << "\t" << "ConvertColorToVariant" << "\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "ConvertColorToVariant" << '\t' << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::ConvertColorToVar:
-        INSTR_DUMP << "\t" << "ConvertColorToVar" << "\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "ConvertColorToVar" << '\t' << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::ConvertObjectToBool:
-        INSTR_DUMP << "\t" << "ConvertObjectToBool" << "\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "ConvertObjectToBool" << '\t' << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::ConvertObjectToVariant:
-        INSTR_DUMP << "\t" << "ConvertObjectToVariant" << "\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "ConvertObjectToVariant" << '\t' << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::ConvertObjectToVar:
-        INSTR_DUMP << "\t" << "ConvertObjectToVar" << "\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "ConvertObjectToVar" << '\t' << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::ConvertNullToObject:
-        INSTR_DUMP << "\t" << "ConvertNullToObject" << "\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "ConvertNullToObject" << '\t' << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::ConvertNullToVariant:
-        INSTR_DUMP << "\t" << "ConvertNullToVariant" << "\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "ConvertNullToVariant" << '\t' << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::ConvertNullToVar:
-        INSTR_DUMP << "\t" << "ConvertNullToVar" << "\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "ConvertNullToVar" << '\t' << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::ResolveUrl:
-        INSTR_DUMP << "\t" << "ResolveUrl" << "\t\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "ResolveUrl" << "\t\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::MathSinNumber:
-        INSTR_DUMP << "\t" << "MathSinNumber" << "\t\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "MathSinNumber" << "\t\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::MathCosNumber:
-        INSTR_DUMP << "\t" << "MathCosNumber" << "\t\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "MathCosNumber" << "\t\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::MathAbsNumber:
-        INSTR_DUMP << "\t" << "MathAbsNumber" << "\t\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "MathAbsNumber" << "\t\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::MathRoundNumber:
-        INSTR_DUMP << "\t" << "MathRoundNumber" << "\t\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "MathRoundNumber" << "\t\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::MathFloorNumber:
-        INSTR_DUMP << "\t" << "MathFloorNumber" << "\t\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "MathFloorNumber" << "\t\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::MathCeilNumber:
-        INSTR_DUMP << "\t" << "MathCeilNumber" << "\t\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "MathCeilNumber" << "\t\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::MathPINumber:
-        INSTR_DUMP << "\t" << "MathPINumber" << "\t\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ")";
+        INSTR_DUMP << '\t' << "MathPINumber" << "\t\t" << "Input_Reg(" << i->unaryop.src << ") -> Output_Reg(" << i->unaryop.output << ')';
         break;
     case V4Instr::LoadNull:
-        INSTR_DUMP << "\t" << "LoadNull" << "\t\t" << "Constant(null) -> Output_Reg(" << i->null_value.reg << ")";
+        INSTR_DUMP << '\t' << "LoadNull" << "\t\t" << "Constant(null) -> Output_Reg(" << i->null_value.reg << ')';
         break;
     case V4Instr::LoadNumber:
-        INSTR_DUMP << "\t" << "LoadNumber" << "\t\t" << "Constant(" << i->number_value.value << ") -> Output_Reg(" << i->number_value.reg << ")";
+        INSTR_DUMP << '\t' << "LoadNumber" << "\t\t" << "Constant(" << i->number_value.value << ") -> Output_Reg(" << i->number_value.reg << ')';
         break;
     case V4Instr::LoadInt:
-        INSTR_DUMP << "\t" << "LoadInt" << "\t\t\t" << "Constant(" << i->int_value.value << ") -> Output_Reg(" << i->int_value.reg << ")";
+        INSTR_DUMP << '\t' << "LoadInt" << "\t\t\t" << "Constant(" << i->int_value.value << ") -> Output_Reg(" << i->int_value.reg << ')';
         break;
     case V4Instr::LoadBool:
-        INSTR_DUMP << "\t" << "LoadBool" << "\t\t" << "Constant(" << i->bool_value.value << ") -> Output_Reg(" << i->bool_value.reg << ")";
+        INSTR_DUMP << '\t' << "LoadBool" << "\t\t" << "Constant(" << i->bool_value.value << ") -> Output_Reg(" << i->bool_value.reg << ')';
         break;
     case V4Instr::LoadString:
-        INSTR_DUMP << "\t" << "LoadString" << "\t\t" << "String_DataIndex(" << i->string_value.offset << ") String_Length(" << i->string_value.length << ") -> Output_Register(" << i->string_value.reg << ")";
+        INSTR_DUMP << '\t' << "LoadString" << "\t\t" << "String_DataIndex(" << i->string_value.offset << ") String_Length(" << i->string_value.length << ") -> Output_Register(" << i->string_value.reg << ')';
         break;
     case V4Instr::EnableV4Test:
-        INSTR_DUMP << "\t" << "EnableV4Test" << "\t\t" << "String_DataIndex(" << i->string_value.offset << ") String_Length(" << i->string_value.length << ")";
+        INSTR_DUMP << '\t' << "EnableV4Test" << "\t\t" << "String_DataIndex(" << i->string_value.offset << ") String_Length(" << i->string_value.length << ')';
         break;
     case V4Instr::TestV4Store:
-        INSTR_DUMP << "\t" << "TestV4Store" << "\t\t" << "Input_Reg(" << i->storetest.reg << ") Reg_Type(" << i->storetest.regType << ")";
+        INSTR_DUMP << '\t' << "TestV4Store" << "\t\t" << "Input_Reg(" << i->storetest.reg << ") Reg_Type(" << i->storetest.regType << ')';
         break;
     case V4Instr::BitAndInt:
-        INSTR_DUMP << "\t" << "BitAndInt" << "\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ")";
+        INSTR_DUMP << '\t' << "BitAndInt" << "\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ')';
         break;
     case V4Instr::BitOrInt:
-        INSTR_DUMP << "\t" << "BitOrInt" << "\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ")";
+        INSTR_DUMP << '\t' << "BitOrInt" << "\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ')';
         break;
     case V4Instr::BitXorInt:
-        INSTR_DUMP << "\t" << "BitXorInt" << "\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ")";
+        INSTR_DUMP << '\t' << "BitXorInt" << "\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ')';
         break;
     case V4Instr::AddNumber:
-        INSTR_DUMP << "\t" << "AddNumber" << "\t\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ")";
+        INSTR_DUMP << '\t' << "AddNumber" << "\t\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ')';
         break;
     case V4Instr::AddString:
-        INSTR_DUMP << "\t" << "AddString" << "\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ")";
+        INSTR_DUMP << '\t' << "AddString" << "\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ')';
         break;
     case V4Instr::SubNumber:
-        INSTR_DUMP << "\t" << "SubNumber" << "\t\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ")";
+        INSTR_DUMP << '\t' << "SubNumber" << "\t\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ')';
         break;
     case V4Instr::MulNumber:
-        INSTR_DUMP << "\t" << "MulNumber" << "\t\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ")";
+        INSTR_DUMP << '\t' << "MulNumber" << "\t\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ')';
         break;
     case V4Instr::DivNumber:
-        INSTR_DUMP << "\t" << "DivNumber" << "\t\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ")";
+        INSTR_DUMP << '\t' << "DivNumber" << "\t\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ')';
         break;
     case V4Instr::ModNumber:
-        INSTR_DUMP << "\t" << "ModNumber" << "\t\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ")";
+        INSTR_DUMP << '\t' << "ModNumber" << "\t\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ')';
         break;
     case V4Instr::LShiftInt:
-        INSTR_DUMP << "\t" << "LShiftInt" << "\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ")";
+        INSTR_DUMP << '\t' << "LShiftInt" << "\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ')';
         break;
     case V4Instr::RShiftInt:
-        INSTR_DUMP << "\t" << "RShiftInt" << "\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ")";
+        INSTR_DUMP << '\t' << "RShiftInt" << "\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ')';
         break;
     case V4Instr::URShiftInt:
-        INSTR_DUMP << "\t" << "URShiftInt" << "\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ")";
+        INSTR_DUMP << '\t' << "URShiftInt" << "\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ')';
         break;
     case V4Instr::GtNumber:
-        INSTR_DUMP << "\t" << "GtNumber" << "\t\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ")";
+        INSTR_DUMP << '\t' << "GtNumber" << "\t\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ')';
         break;
     case V4Instr::LtNumber:
-        INSTR_DUMP << "\t" << "LtNumber" << "\t\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ")";
+        INSTR_DUMP << '\t' << "LtNumber" << "\t\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ')';
         break;
     case V4Instr::GeNumber:
-        INSTR_DUMP << "\t" << "GeNumber" << "\t\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ")";
+        INSTR_DUMP << '\t' << "GeNumber" << "\t\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ')';
         break;
     case V4Instr::LeNumber:
-        INSTR_DUMP << "\t" << "LeNumber" << "\t\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ")";
+        INSTR_DUMP << '\t' << "LeNumber" << "\t\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ')';
         break;
     case V4Instr::EqualNumber:
-        INSTR_DUMP << "\t" << "EqualNumber" << "\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ")";
+        INSTR_DUMP << '\t' << "EqualNumber" << "\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ')';
         break;
     case V4Instr::NotEqualNumber:
-        INSTR_DUMP << "\t" << "NotEqualNumber" << "\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ")";
+        INSTR_DUMP << '\t' << "NotEqualNumber" << "\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ')';
         break;
     case V4Instr::StrictEqualNumber:
-        INSTR_DUMP << "\t" << "StrictEqualNumber" << "\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ")";
+        INSTR_DUMP << '\t' << "StrictEqualNumber" << "\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ')';
         break;
     case V4Instr::StrictNotEqualNumber:
-        INSTR_DUMP << "\t" << "StrictNotEqualNumber" << "\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ")";
+        INSTR_DUMP << '\t' << "StrictNotEqualNumber" << '\t' << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ')';
         break;
     case V4Instr::GtString:
-        INSTR_DUMP << "\t" << "GtString" << "\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ")";
+        INSTR_DUMP << '\t' << "GtString" << "\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ')';
         break;
     case V4Instr::LtString:
-        INSTR_DUMP << "\t" << "LtString" << "\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ")";
+        INSTR_DUMP << '\t' << "LtString" << "\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ')';
         break;
     case V4Instr::GeString:
-        INSTR_DUMP << "\t" << "GeString" << "\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ")";
+        INSTR_DUMP << '\t' << "GeString" << "\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ')';
         break;
     case V4Instr::LeString:
-        INSTR_DUMP << "\t" << "LeString" << "\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ")";
+        INSTR_DUMP << '\t' << "LeString" << "\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ')';
         break;
     case V4Instr::EqualString:
-        INSTR_DUMP << "\t" << "EqualString" << "\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ")";
+        INSTR_DUMP << '\t' << "EqualString" << "\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ')';
         break;
     case V4Instr::NotEqualString:
-        INSTR_DUMP << "\t" << "NotEqualString" << "\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ")";
+        INSTR_DUMP << '\t' << "NotEqualString" << "\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ')';
         break;
     case V4Instr::StrictEqualString:
-        INSTR_DUMP << "\t" << "StrictEqualString" << "\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ")";
+        INSTR_DUMP << '\t' << "StrictEqualString" << '\t' << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ')';
         break;
     case V4Instr::StrictNotEqualString:
-        INSTR_DUMP << "\t" << "StrictNotEqualString" << "\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ")";
+        INSTR_DUMP << '\t' << "StrictNotEqualString" << '\t' << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ')';
         break;
     case V4Instr::EqualObject:
-        INSTR_DUMP << "\t" << "EqualObject" << "\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ")";
+        INSTR_DUMP << '\t' << "EqualObject" << "\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ')';
         break;
     case V4Instr::NotEqualObject:
-        INSTR_DUMP << "\t" << "NotEqualObject" << "\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ")";
+        INSTR_DUMP << '\t' << "NotEqualObject" << "\t\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ')';
         break;
     case V4Instr::StrictEqualObject:
-        INSTR_DUMP << "\t" << "StrictEqualObject" << "\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ")";
+        INSTR_DUMP << '\t' << "StrictEqualObject" << '\t' << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ')';
         break;
     case V4Instr::StrictNotEqualObject:
-        INSTR_DUMP << "\t" << "StrictNotEqualObject" << "\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ")";
+        INSTR_DUMP << '\t' << "StrictNotEqualObject" << '\t' << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ')';
         break;
     case V4Instr::MathMaxNumber:
-        INSTR_DUMP << "\t" << "MathMaxNumber" << "\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ")";
+        INSTR_DUMP << '\t' << "MathMaxNumber" << '\t' << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ')';
         break;
     case V4Instr::MathMinNumber:
-        INSTR_DUMP << "\t" << "MathMinNumber" << "\t" << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ")";
+        INSTR_DUMP << '\t' << "MathMinNumber" << '\t' << "Input_Reg(" << i->binaryop.left << ") Input_Reg(" << i->binaryop.right << ") -> Output_Reg(" << i->binaryop.output << ')';
         break;
     case V4Instr::NewString:
-        INSTR_DUMP << "\t" << "NewString" << "\t\t" << "Register(" << i->construct.reg << ")";
+        INSTR_DUMP << '\t' << "NewString" << "\t\t" << "Register(" << i->construct.reg << ')';
         break;
     case V4Instr::NewUrl:
-        INSTR_DUMP << "\t" << "NewUrl" << "\t\t\t" << "Register(" << i->construct.reg << ")";
+        INSTR_DUMP << '\t' << "NewUrl" << "\t\t\t" << "Register(" << i->construct.reg << ')';
         break;
     case V4Instr::CleanupRegister:
-        INSTR_DUMP << "\t" << "CleanupRegister" << "\t\t" << "Register(" << i->cleanup.reg << ")";
+        INSTR_DUMP << '\t' << "CleanupRegister" << "\t\t" << "Register(" << i->cleanup.reg << ')';
         break;
     case V4Instr::Fetch:
-        INSTR_DUMP << "\t" << "Fetch" << "\t\t\t" << "Object_Reg(" << i->fetch.reg << ") Property_Index(" << i->fetch.index << ") -> Output_Reg(" << i->fetch.reg << ")";
+        INSTR_DUMP << '\t' << "Fetch" << "\t\t\t" << "Object_Reg(" << i->fetch.reg << ") Property_Index(" << i->fetch.index << ") -> Output_Reg(" << i->fetch.reg << ')';
         break;
     case V4Instr::Store:
-        INSTR_DUMP << "\t" << "Store" << "\t\t\t" << "Input_Reg(" << i->store.reg << ") -> Object_Reg(" << i->store.output << ") Property_Index(" << i->store.index << ")";
+        INSTR_DUMP << '\t' << "Store" << "\t\t\t" << "Input_Reg(" << i->store.reg << ") -> Object_Reg(" << i->store.output << ") Property_Index(" << i->store.index << ')';
         break;
     case V4Instr::Copy:
-        INSTR_DUMP << "\t" << "Copy" << "\t\t\t" << "Input_Reg(" << i->copy.src << ") -> Output_Reg(" << i->copy.reg << ")";
+        INSTR_DUMP << '\t' << "Copy" << "\t\t\t" << "Input_Reg(" << i->copy.src << ") -> Output_Reg(" << i->copy.reg << ')';
         break;
     case V4Instr::Jump:
         if (i->jump.reg != -1) {
-            INSTR_DUMP << "\t" << "Jump" << "\t\t\t" << "Address(" << (address + size() + i->jump.count) << ") [if false == Input_Reg(" << i->jump.reg << ")]";
+            INSTR_DUMP << '\t' << "Jump" << "\t\t\t" << "Address(" << (address + size() + i->jump.count) << ") [if false == Input_Reg(" << i->jump.reg << ")]";
         } else {
-            INSTR_DUMP << "\t" << "Jump" << "\t\t\t" << "Address(" << (address + size() + i->jump.count) << ")";
+            INSTR_DUMP << '\t' << "Jump" << "\t\t\t" << "Address(" << (address + size() + i->jump.count) << ')';
         }
         break;
     case V4Instr::BranchFalse:
-        INSTR_DUMP << "\t" << "BranchFalse" << "\t\t" << "Address(" << (address + size() + i->branchop.offset) << ") [if false == Input_Reg(" << i->branchop.reg << ")]";
+        INSTR_DUMP << '\t' << "BranchFalse" << "\t\t" << "Address(" << (address + size() + i->branchop.offset) << ") [if false == Input_Reg(" << i->branchop.reg << ")]";
         break;
     case V4Instr::BranchTrue:
-        INSTR_DUMP << "\t" << "BranchTrue" << "\t\t" << "Address(" << (address + size() + i->branchop.offset) << ") [if true == Input_Reg(" << i->branchop.reg << ")]";
+        INSTR_DUMP << '\t' << "BranchTrue" << "\t\t" << "Address(" << (address + size() + i->branchop.offset) << ") [if true == Input_Reg(" << i->branchop.reg << ")]";
         break;
     case V4Instr::Branch:
-        INSTR_DUMP << "\t" << "Branch" << "\t\t\t" << "Address(" << (address + size() + i->branchop.offset) << ")";
+        INSTR_DUMP << '\t' << "Branch" << "\t\t\t" << "Address(" << (address + size() + i->branchop.offset) << ')';
         break;
     case V4Instr::Block:
-        INSTR_DUMP << "\t" << "Block" << "\t\t\t" << "Mask(" << QByteArray::number(i->blockop.block, 16).constData()  << ")";
+        INSTR_DUMP << '\t' << "Block" << "\t\t\t" << "Mask(" << QByteArray::number(i->blockop.block, 16).constData()  << ')';
         break;
     case V4Instr::Throw:
-        INSTR_DUMP << "\t" << "Throw" << "\t\t\t" << "InputReg(" << i->throwop.message  << ")";
+        INSTR_DUMP << '\t' << "Throw" << "\t\t\t" << "InputReg(" << i->throwop.message  << ')';
         break;
     default:
-        INSTR_DUMP << "\t" << "Unknown";
+        INSTR_DUMP << '\t' << "Unknown";
         break;
     }
 }
diff --git a/src/qml/qml/v4/qv4ir.cpp b/src/qml/qml/v4/qv4ir.cpp
index 45e909f54b..a111bbf6e7 100644
--- a/src/qml/qml/v4/qv4ir.cpp
+++ b/src/qml/qml/v4/qv4ir.cpp
@@ -768,7 +768,7 @@ void IRDump::basicblock(QQmlJS::IR::BasicBlock *b)
         if (ii != (b->statements.count() - 1))
             qWarning();
     }
-    qWarning().nospace() << indent() << "}";
+    qWarning().nospace() << indent() << '}';
 
     dec();
 }
@@ -790,7 +790,7 @@ void IRDump::function(QQmlJS::IR::Function *f)
     for (int ii = 0; ii < f->basicBlocks.count(); ++ii) {
         basicblock(f->basicBlocks.at(ii));
     }
-    qWarning().nospace() << indent() << "}";
+    qWarning().nospace() << indent() << '}';
 
     dec();
 }
@@ -802,25 +802,25 @@ const char *IRDump::indent()
 
 void IRDump::visitConst(QQmlJS::IR::Const *e)
 {
-    qWarning().nospace() << indent() << "Const:Expr { type: " << typeName(e->type) << ", value: " << e->value << "}";
+    qWarning().nospace() << indent() << "Const:Expr { type: " << typeName(e->type) << ", value: " << e->value << '}';
 }
 
 void IRDump::visitString(QQmlJS::IR::String *e)
 {
-    qWarning().nospace() << indent() << "String:Expr { type: " << typeName(e->type) << ", value: " << e->value << "}";
+    qWarning().nospace() << indent() << "String:Expr { type: " << typeName(e->type) << ", value: " << e->value << '}';
 }
 
 static void namedumprecur(QQmlJS::IR::Name *e, const char *indent) 
 {
     if (e->base) namedumprecur(e->base, indent);
-    qWarning().nospace() << indent << "    { type: " << typeName(e->type) << ", symbol: " << symbolname(e->symbol) << ", storage: " << storagename(e->storage) << ", id: " << e->id << "}";
+    qWarning().nospace() << indent << "    { type: " << typeName(e->type) << ", symbol: " << symbolname(e->symbol) << ", storage: " << storagename(e->storage) << ", id: " << e->id << '}';
 }
 
 void IRDump::visitName(QQmlJS::IR::Name *e)
 {
     qWarning().nospace() << indent() << "Name:Expr {";
     namedumprecur(e, indent());
-    qWarning().nospace() << indent() << "}";
+    qWarning().nospace() << indent() << '}';
 }
 
 void IRDump::visitTemp(QQmlJS::IR::Temp *e)
@@ -835,7 +835,7 @@ void IRDump::visitUnop(QQmlJS::IR::Unop *e)
     qWarning().nospace() << indent() << "    expr: {";
     expression(e->expr);
     qWarning().nospace() << indent() << "    }";
-    qWarning().nospace() << indent() << "}";
+    qWarning().nospace() << indent() << '}';
 }
 
 void IRDump::visitBinop(QQmlJS::IR::Binop *e)
@@ -852,7 +852,7 @@ void IRDump::visitBinop(QQmlJS::IR::Binop *e)
     expression(e->right);
     dec();
     qWarning().nospace() << indent() << "    }";
-    qWarning().nospace() << indent() << "}";
+    qWarning().nospace() << indent() << '}';
 }
 
 void IRDump::visitCall(QQmlJS::IR::Call *e)
@@ -865,7 +865,7 @@ void IRDump::visitExp(QQmlJS::IR::Exp *s)
 {
     qWarning().nospace() << indent() << "Exp:Stmt {";
     expression(s->expr);
-    qWarning().nospace() << indent() << "}";
+    qWarning().nospace() << indent() << '}';
 }
 
 void IRDump::visitMove(QQmlJS::IR::Move *s)
@@ -882,7 +882,7 @@ void IRDump::visitMove(QQmlJS::IR::Move *s)
     expression(s->source);
     dec();
     qWarning().nospace() << indent() << "    }";
-    qWarning().nospace() << indent() << "}";
+    qWarning().nospace() << indent() << '}';
 }
 
 void IRDump::visitJump(QQmlJS::IR::Jump *s)
@@ -898,9 +898,9 @@ void IRDump::visitCJump(QQmlJS::IR::CJump *s)
     expression(s->cond);
     dec();
     qWarning().nospace() << indent() << "    }";
-    qWarning().nospace() << indent() << "    iftrue: BasicBlock(" << s->iftrue << ")";
-    qWarning().nospace() << indent() << "    iffalse: BasicBlock(" << s->iffalse << ")";
-    qWarning().nospace() << indent() << "}";
+    qWarning().nospace() << indent() << "    iftrue: BasicBlock(" << s->iftrue << ')';
+    qWarning().nospace() << indent() << "    iffalse: BasicBlock(" << s->iffalse << ')';
+    qWarning().nospace() << indent() << '}';
 }
 
 void IRDump::visitRet(QQmlJS::IR::Ret *s)
@@ -908,7 +908,7 @@ void IRDump::visitRet(QQmlJS::IR::Ret *s)
     qWarning().nospace() << indent() << "Ret:Stmt {";
     qWarning().nospace() << indent() << "    type: " << typeName(s->type);
     expression(s->expr);
-    qWarning().nospace() << indent() << "}";
+    qWarning().nospace() << indent() << '}';
 }
 #endif
 
diff --git a/src/qml/qml/v4/qv4irbuilder.cpp b/src/qml/qml/v4/qv4irbuilder.cpp
index 82da09f485..52f0696be9 100644
--- a/src/qml/qml/v4/qv4irbuilder.cpp
+++ b/src/qml/qml/v4/qv4irbuilder.cpp
@@ -605,7 +605,7 @@ bool QV4IRBuilder::visit(AST::FieldMemberExpression *ast)
 
                     if (!found && qmlVerboseCompiler())
                         qWarning() << "*** unresolved enum:" 
-                                   << (*baseName->id + QLatin1String(".") + ast->name.toString());
+                                   << (*baseName->id + QLatin1Char('.') + ast->name.toString());
                 } else if(const QMetaObject *attachedMeta = baseName->declarativeType->attachedPropertiesType()) {
                     QQmlPropertyCache *cache = m_engine->cache(attachedMeta);
                     QQmlPropertyData *data = cache->property(name);
@@ -616,7 +616,7 @@ bool QV4IRBuilder::visit(AST::FieldMemberExpression *ast)
                     if(!data->isFinal()) {
                         if (qmlVerboseCompiler())
                             qWarning() << "*** non-final attached property:"
-                                       << (*baseName->id + QLatin1String(".") + ast->name.toString());
+                                       << (*baseName->id + QLatin1Char('.') + ast->name.toString());
                         return false; // We don't know enough about this property
                     }
 
@@ -643,7 +643,7 @@ bool QV4IRBuilder::visit(AST::FieldMemberExpression *ast)
                     }
                     if (!found && qmlVerboseCompiler())
                         qWarning() << "*** unresolved enum:"
-                                   << (*baseName->id + QLatin1String(".") + ast->name.toString());
+                                   << (*baseName->id + QLatin1Char('.') + ast->name.toString());
                 } else {
                     QQmlPropertyCache *cache = m_engine->cache(baseName->meta);
                     if (!cache) return false;
@@ -655,7 +655,7 @@ bool QV4IRBuilder::visit(AST::FieldMemberExpression *ast)
                     if (!data->isFinal()) {
                         if (qmlVerboseCompiler())
                             qWarning() << "*** non-final attached property:"
-                                       << (*baseName->id + QLatin1String(".") + ast->name.toString());
+                                       << (*baseName->id + QLatin1Char('.') + ast->name.toString());
                         return false; // We don't know enough about this property
                     }
 
@@ -699,7 +699,7 @@ bool QV4IRBuilder::visit(AST::FieldMemberExpression *ast)
                         if (!data->isFinal()) {
                             if (qmlVerboseCompiler())
                                 qWarning() << "*** non-final property access:"
-                                           << (*baseName->id + QLatin1String(".") + ast->name.toString());
+                                           << (*baseName->id + QLatin1Char('.') + ast->name.toString());
                             return false; // We don't know enough about this property
                         }
 
diff --git a/src/qml/qml/v8/qv8bindings.cpp b/src/qml/qml/v8/qv8bindings.cpp
index f4cad9aa4b..31780a3d16 100644
--- a/src/qml/qml/v8/qv8bindings.cpp
+++ b/src/qml/qml/v8/qv8bindings.cpp
@@ -174,7 +174,7 @@ void QV8Bindings::Binding::update(QQmlPropertyPrivate::WriteFlags flags)
 QString QV8Bindings::Binding::expressionIdentifier(QQmlJavaScriptExpression *e)
 {
     Binding *This = static_cast<Binding *>(e);
-    return This->parent->urlString() + QLatin1String(":") +
+    return This->parent->urlString() + QLatin1Char(':') +
            QString::number(This->instruction->line);
 }
 
diff --git a/src/qml/qml/v8/qv8contextwrapper.cpp b/src/qml/qml/v8/qv8contextwrapper.cpp
index 8a98727205..435ac69ce3 100644
--- a/src/qml/qml/v8/qv8contextwrapper.cpp
+++ b/src/qml/qml/v8/qv8contextwrapper.cpp
@@ -376,7 +376,7 @@ v8::Handle<v8::Value> QV8ContextWrapper::NullSetter(v8::Local<v8::String> proper
         return v8::Handle<v8::Value>();
     } else {
         QString error = QLatin1String("Invalid write to global property \"") + engine->toString(property) + 
-                        QLatin1String("\"");
+                        QLatin1Char('"');
         v8::ThrowException(v8::Exception::Error(engine->toString(error)));
         return v8::Handle<v8::Value>();
     }
@@ -440,7 +440,7 @@ v8::Handle<v8::Value> QV8ContextWrapper::Setter(v8::Local<v8::String> property,
         return v8::Handle<v8::Value>();
     } else {
         QString error = QLatin1String("Invalid write to global property \"") + engine->toString(property) + 
-                        QLatin1String("\"");
+                        QLatin1Char('"');
         v8::ThrowException(v8::Exception::Error(engine->toString(error)));
         return v8::Undefined();
     }
diff --git a/src/qml/qml/v8/qv8engine.cpp b/src/qml/qml/v8/qv8engine.cpp
index eeedeb5201..13d766acea 100644
--- a/src/qml/qml/v8/qv8engine.cpp
+++ b/src/qml/qml/v8/qv8engine.cpp
@@ -461,7 +461,7 @@ v8::Local<v8::Script> QV8Engine::qmlModeCompile(const char *source, int sourceLe
                                                 int lineNumber)
 {
     if (sourceLength == -1)
-        sourceLength = strlen(source);
+        sourceLength = int(strlen(source));
 
     v8::Local<v8::String> v8source = v8::String::New(source, sourceLength);
     v8::Local<v8::String> v8fileName = m_stringWrapper.toString(fileName);