qiurui
/
qtdeclarative
mirror of https://github.com/qt/qtdeclarative.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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>
This commit is contained in:
Friedemann Kleint 2012-05-14 13:50:46 +02:00 committed by Qt by Nokia
parent a1151929ff
commit fd5c099eea
30 changed files with 215 additions and 216 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/qml/debugger/qqmldebugserver.cpp
View File

@ -469,7 +469,7 @@ void QQmlDebugServer::receiveMessage(const QByteArray &message)
QReadLocker lock(&d->pluginsLock);
QHash<QString, QQmlDebugService *>::Iterator iter = d->plugins.find(name);
if (iter == d->plugins.end()) {
qWarning() << "QML Debugger: Message received for missing plugin" << name << ".";
qWarning() << "QML Debugger: Message received for missing plugin" << name << '.';
} else {
(*iter)->messageReceived(message);

2
src/qml/debugger/qv8debugservice.cpp
View File

@ -173,7 +173,7 @@ void QV8DebugService::signalEmitted(const QString &signal)
//Parse just the name and remove the class info
//Normalize to Lower case.
QString signalName = signal.left(signal.indexOf(QLatin1String("("))).toLower();
QString signalName = signal.left(signal.indexOf(QLatin1Char('('))).toLower();
foreach (const QString &signal, d->breakOnSignals) {
if (signal == signalName) {

18
src/qml/qml/qqml.h
View File

@ -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,

2
src/qml/qml/qqmlaccessors_p.h
View File

@ -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);

2
src/qml/qml/qqmlbinding.cpp
View File

@ -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)

2
src/qml/qml/qqmlboundsignal.cpp
View File

@ -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 *)

2
src/qml/qml/qqmlcompileddata.cpp
View File

@ -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;
}

28
src/qml/qml/qqmlcompiler.cpp
View File

@ -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(") ");
}

2
src/qml/qml/qqmlengine.cpp
View File

@ -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;
}

2
src/qml/qml/qqmlexpression.cpp
View File

@ -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

8
src/qml/qml/qqmlimport.cpp
View File

@ -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;

2
src/qml/qml/qqmlproperty.cpp
View File

@ -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;

2
src/qml/qml/qqmltypeloader.cpp
View File

@ -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"));

4
src/qml/qml/qqmlxmlhttprequest.cpp
View File

@ -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 ||

6
src/qml/qml/v4/qv4bindings.cpp
View File

@ -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";

2
src/qml/qml/v4/qv4compiler.cpp
View File

@ -763,7 +763,7 @@ void QV4CompilerPrivate::visitBinop(IR::Binop *e)
<< "(`" << IR::binaryOperator(e->left->type)
<< "' and `"
<< IR::binaryOperator(e->right->type)
<< "'";
<< '\'';
discard();
return;
}

230
src/qml/qml/v4/qv4instruction.cpp
View File

@ -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;
}
}

28
src/qml/qml/v4/qv4ir.cpp
View File

@ -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

10
src/qml/qml/v4/qv4irbuilder.cpp
View File

@ -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
}

2
src/qml/qml/v8/qv8bindings.cpp
View File

@ -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);
}

4
src/qml/qml/v8/qv8contextwrapper.cpp
View File

@ -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();
}

2
src/qml/qml/v8/qv8engine.cpp
View File

@ -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);

2
src/quick/items/context2d/qquickcontext2d.cpp
View File

@ -194,7 +194,7 @@ QFont qt_font_from_string(const QString& fontString) {
QFont font;
// ### this is simplified and incomplete
// ### TODO:get code from Qt webkit
QStringList tokens = fontString.split(QLatin1String(" "));
const QStringList tokens = fontString.split(QLatin1Char(' '));
foreach (const QString &token, tokens) {
if (token == QLatin1String("italic"))
font.setItalic(true);

3
src/quick/items/qquickshadereffect.cpp
View File

@ -243,8 +243,7 @@ void QQuickShaderEffectCommon::connectPropertySignals(QQuickItem *item, Key::Sha
QMetaProperty mp = item->metaObject()->property(pi);
if (!mp.hasNotifySignal())
qWarning("QQuickShaderEffect: property '%s' does not have notification method!", d.name.constData());
QByteArray signalName("2");
signalName.append(mp.notifySignal().methodSignature());
const QByteArray signalName = '2' + mp.notifySignal().methodSignature();
QSignalMapper *mapper = signalMappers[shaderType].at(i);
QObject::connect(item, signalName, mapper, SLOT(map()));
QObject::connect(mapper, SIGNAL(mapped(int)), item, SLOT(propertyChanged(int)));

12
src/quick/scenegraph/coreapi/qsgnode.cpp
View File

@ -1193,7 +1193,7 @@ QDebug operator<<(QDebug d, const QSGGeometryNode *n)
d << "effect=" << n->material() << "type=" << n->material()->type();
d << ")";
d << ')';
#ifdef QML_RUNTIME_TESTING
d << n->description;
#endif
@ -1214,7 +1214,7 @@ QDebug operator<<(QDebug d, const QSGClipNode *n)
d << "is rect?" << (n->isRectangular() ? "yes" : "no");
d << ")";
d << ')';
#ifdef QML_RUNTIME_TESTING
d << n->description;
#endif
@ -1241,7 +1241,7 @@ QDebug operator<<(QDebug d, const QSGTransformNode *n)
d << n->description;
#endif
d << "dirty=" << hex << (int) n->dirtyState() << dec << (n->isSubtreeBlocked() ? "*BLOCKED*" : "");
d << ")";
d << ')';
return d;
}
@ -1260,7 +1260,7 @@ QDebug operator<<(QDebug d, const QSGOpacityNode *n)
d << n->description;
#endif
d << "dirty=" << hex << (int) n->dirtyState() << dec;
d << ")";
d << ')';
return d;
}
@ -1276,7 +1276,7 @@ QDebug operator<<(QDebug d, const QSGRootNode *n)
#ifdef QML_RUNTIME_TESTING
d << n->description;
#endif
d << ")";
d << ')';
return d;
}
@ -1312,7 +1312,7 @@ QDebug operator<<(QDebug d, const QSGNode *n)
#ifdef QML_RUNTIME_TESTING
d << n->description;
#endif
d << ")";
d << ')';
break;
}
return d;

2
src/quick/scenegraph/qsgcontext.cpp
View File

@ -310,7 +310,7 @@ QSGDistanceFieldGlyphCache *QSGContext::distanceFieldGlyphCache(const QRawFont &
if (font.style() != QFont::StyleNormal)
keyName += QByteArray(" I");
if (font.weight() != QFont::Normal)
keyName += " " + QByteArray::number(font.weight());
keyName += ' ' + QByteArray::number(font.weight());
keyName += QByteArray(" DF");
QPlatformSharedGraphicsCache *sharedGraphicsCache =
platformIntegration->createPlatformSharedGraphicsCache(keyName);

2
src/quick/scenegraph/qsgshareddistancefieldglyphcache.cpp
View File

@ -401,7 +401,7 @@ void QSGSharedDistanceFieldGlyphCache::saveTexture(GLuint textureId, int width,
for (int i=0; i<width*height; ++i)
dest[i] = qRgba(0xff, 0xff, 0xff, data[i]);
QByteArray fileName = m_cacheId + " " + QByteArray::number(textureId);
QByteArray fileName = m_cacheId + ' ' + QByteArray::number(textureId);
fileName = fileName.replace('/', '_').replace(' ', '_') + ".png";
image.save(QString::fromLocal8Bit(fileName));

8
src/quick/util/qquickchangeset.cpp
View File

@ -457,22 +457,22 @@ QDebug operator <<(QDebug debug, const QQuickChangeSet &set)
foreach (const QQuickChangeSet::Remove &remove, set.removes()) debug << remove;
foreach (const QQuickChangeSet::Insert &insert, set.inserts()) debug << insert;
foreach (const QQuickChangeSet::Change &change, set.changes()) debug << change;
return debug.nospace() << ")";
return debug.nospace() << ')';
}
QDebug operator <<(QDebug debug, const QQuickChangeSet::Remove &remove)
{
return (debug.nospace() << "Remove(" << remove.index << "," << remove.count << "," << remove.moveId << ")").space();
return (debug.nospace() << "Remove(" << remove.index << ',' << remove.count << ',' << remove.moveId << ')').space();
}
QDebug operator <<(QDebug debug, const QQuickChangeSet::Insert &insert)
{
return (debug.nospace() << "Insert(" << insert.index << "," << insert.count << "," << insert.moveId << ")").space();
return (debug.nospace() << "Insert(" << insert.index << ',' << insert.count << ',' << insert.moveId << ')').space();
}
QDebug operator <<(QDebug debug, const QQuickChangeSet::Change &change)
{
return (debug.nospace() << "Change(" << change.index << "," << change.count << ")").space();
return (debug.nospace() << "Change(" << change.index << ',' << change.count << ')').space();
}
QT_END_NAMESPACE

2
src/quick/util/qquickfontloader.cpp
View File

@ -243,7 +243,7 @@ void QQuickFontLoader::updateFontInfo(const QString& name, QQuickFontLoader::Sta
}
if (status != d->status) {
if (status == Error)
qmlInfo(this) << "Cannot load font: \"" << d->url.toString() << "\"";
qmlInfo(this) << "Cannot load font: \"" << d->url.toString() << '"';
d->status = status;
emit statusChanged();
}

38
src/quick/util/qquicklistcompositor.cpp
View File

@ -1136,17 +1136,17 @@ QDebug operator <<(QDebug debug, const QQuickListCompositor::Range &range)
{
(debug.nospace()
<< "Range("
<< range.list) << " "
<< range.index << " "
<< range.count << " "
<< (range.isUnresolved() ? "U" : "0")
<< (range.append() ? "A" : "0")
<< (range.prepend() ? "P" : "0");
<< range.list) << ' '
<< range.index << ' '
<< range.count << ' '
<< (range.isUnresolved() ? 'U' : '0')
<< (range.append() ? 'A' : '0')
<< (range.prepend() ? 'P' : '0');
for (int i = QQuickListCompositor::MaximumGroupCount - 1; i >= 2; --i)
debug << (range.inGroup(i) ? "1" : "0");
debug << (range.inGroup(i) ? '1' : '0');
return (debug
<< (range.inGroup(QQuickListCompositor::Default) ? "D" : "0")
<< (range.inGroup(QQuickListCompositor::Cache) ? "C" : "0"));
<< (range.inGroup(QQuickListCompositor::Default) ? 'D' : '0')
<< (range.inGroup(QQuickListCompositor::Cache) ? 'C' : '0'));
}
static void qt_print_indexes(QDebug &debug, int count, const int *indexes)
@ -1159,21 +1159,21 @@ QDebug operator <<(QDebug debug, const QQuickListCompositor::iterator &it)
{
(debug.nospace() << "iterator(" << it.group).space() << "offset:" << it.offset;
qt_print_indexes(debug, it.groupCount, it.index);
return ((debug << **it).nospace() << ")").space();
return ((debug << **it).nospace() << ')').space();
}
static QDebug qt_print_change(QDebug debug, const char *name, const QQuickListCompositor::Change &change)
{
debug.nospace() << name << "(" << change.moveId << " " << change.count << " ";
debug.nospace() << name << '(' << change.moveId << ' ' << change.count << ' ';
for (int i = QQuickListCompositor::MaximumGroupCount - 1; i >= 2; --i)
debug << (change.inGroup(i) ? "1" : "0");
debug << (change.inGroup(QQuickListCompositor::Default) ? "D" : "0")
<< (change.inGroup(QQuickListCompositor::Cache) ? "C" : "0");
debug << (change.inGroup(i) ? '1' : '0');
debug << (change.inGroup(QQuickListCompositor::Default) ? 'D' : '0')
<< (change.inGroup(QQuickListCompositor::Cache) ? 'C' : '0');
int i = QQuickListCompositor::MaximumGroupCount - 1;
for (; i >= 0 && !change.inGroup(i); --i) {}
for (; i >= 0; --i)
debug << " " << change.index[i];
return (debug << ")").maybeSpace();
debug << ' ' << change.index[i];
return (debug << ')').maybeSpace();
}
QDebug operator <<(QDebug debug, const QQuickListCompositor::Change &change)
@ -1199,16 +1199,16 @@ QDebug operator <<(QDebug debug, const QQuickListCompositor &list)
debug.nospace() << "QQuickListCompositor(";
qt_print_indexes(debug, list.m_groupCount, list.m_end.index);
for (QQuickListCompositor::Range *range = list.m_ranges.next; range != &list.m_ranges; range = range->next) {
(debug << "\n").space();
(debug << '\n').space();
qt_print_indexes(debug, list.m_groupCount, indexes);
debug << " " << *range;
debug << ' ' << *range;
for (int i = 0; i < list.m_groupCount; ++i) {
if (range->inGroup(i))
indexes[i] += range->count;
}
}
return (debug << ")").maybeSpace();
return (debug << ')').maybeSpace();
}
QT_END_NAMESPACE