aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorFriedemann Kleint <Friedemann.Kleint@qt.io>2016-09-16 14:26:15 +0200
committerFriedemann Kleint <Friedemann.Kleint@qt.io>2016-09-19 13:25:42 +0000
commit4036825eed09710e1f24abe71e879cc0031b4253 (patch)
tree453fa5961168721abab5eefafccf7454b95bdd23
parentdd77b1b31f075d7bd39622ba431f3391037d2f05 (diff)
Compile with QT_NO_CAST_FROM_ASCII, QT_NO_CAST_TO_ASCII
Add the define in CMakeLists.txt to enforce it in the module. Change-Id: I233e85b66c694f8242c1aec013ec8e69a73212fd Reviewed-by: Lars Knoll <lars.knoll@qt.io>
Diffstat
-rw-r--r--ApiExtractor/abstractmetabuilder.cpp291
-rw-r--r--ApiExtractor/abstractmetalang.cpp161
-rw-r--r--ApiExtractor/abstractmetalang.h12
-rw-r--r--ApiExtractor/apiextractor.cpp11
-rw-r--r--ApiExtractor/asttoxml.cpp32
-rw-r--r--ApiExtractor/include.cpp6
-rw-r--r--ApiExtractor/parser/binder.cpp52
-rw-r--r--ApiExtractor/parser/codemodel.cpp10
-rw-r--r--ApiExtractor/parser/declarator_compiler.cpp4
-rw-r--r--ApiExtractor/parser/dumptree.cpp3
-rw-r--r--ApiExtractor/parser/lexer.cpp14
-rw-r--r--ApiExtractor/parser/name_compiler.cpp10
-rw-r--r--ApiExtractor/parser/name_compiler.h2
-rw-r--r--ApiExtractor/parser/parser.cpp90
-rw-r--r--ApiExtractor/parser/type_compiler.cpp4
-rw-r--r--ApiExtractor/reporthandler.cpp4
-rw-r--r--ApiExtractor/typedatabase.cpp53
-rw-r--r--ApiExtractor/typedatabase.h2
-rw-r--r--ApiExtractor/typeparser.cpp32
-rw-r--r--ApiExtractor/typesystem.cpp991
-rw-r--r--ApiExtractor/typesystem.h54
-rw-r--r--CMakeLists.txt2
-rw-r--r--generator/generator.cpp102
-rw-r--r--generator/main.cpp142
-rw-r--r--generator/qtdoc/qtdocgenerator.h2
-rw-r--r--generator/shiboken2/cppgenerator.cpp986
-rw-r--r--generator/shiboken2/cppgenerator.h4
-rw-r--r--generator/shiboken2/headergenerator.cpp31
-rw-r--r--generator/shiboken2/overloaddata.cpp81
-rw-r--r--generator/shiboken2/shibokengenerator.cpp808
-rw-r--r--generator/shiboken2/shibokengenerator.h6
31 files changed, 2085 insertions, 1917 deletions
diff --git a/ApiExtractor/abstractmetabuilder.cpp b/ApiExtractor/abstractmetabuilder.cpp
index 9fc035d..ca76b80 100644
--- a/ApiExtractor/abstractmetabuilder.cpp
+++ b/ApiExtractor/abstractmetabuilder.cpp
@@ -49,18 +49,20 @@
#include "graph.h"
#include <QTemporaryFile>
+static inline QString colonColon() { return QStringLiteral("::"); }
+
static QString stripTemplateArgs(const QString &name)
{
- int pos = name.indexOf('<');
+ int pos = name.indexOf(QLatin1Char('<'));
return pos < 0 ? name : name.left(pos);
}
static QStringList parseTemplateType(const QString& name) {
- int n = name.indexOf('<');
+ int n = name.indexOf(QLatin1Char('<'));
if (n <= 0) {
// If name starts with '<' or contains an unmatched (i.e. any) '>', we
// reject it
- if (n == 0 || name.count(">"))
+ if (n == 0 || name.count(QLatin1Char('>')))
return QStringList();
// Doesn't look like a template instantiation; just return the name
return QStringList() << name;
@@ -81,12 +83,12 @@ static QStringList parseTemplateType(const QString& name) {
// Consume balanced '<'/'>' within a single argument so that we won't
// split on ',' as part of a single argument which is itself a
// multi-argument template type
- if (name[i] == '<') {
+ if (name[i] == QLatin1Char('<')) {
++depth;
- } else if (name[i] == '>') {
+ } else if (name[i] == QLatin1Char('>')) {
if (--depth == 0)
break;
- } else if (name[i] == ',' && depth == 1) {
+ } else if (name[i] == QLatin1Char(',') && depth == 1) {
// Encountered ',' in template argument list that is not within
// another template name; add current argument to result and start
// working on the next argument
@@ -104,7 +106,9 @@ static QStringList parseTemplateType(const QString& name) {
return result;
}
-AbstractMetaBuilder::AbstractMetaBuilder() : m_currentClass(0), m_logDirectory(QString('.')+QDir::separator())
+AbstractMetaBuilder::AbstractMetaBuilder()
+ : m_currentClass(0),
+ m_logDirectory(QLatin1String(".") + QDir::separator())
{
}
@@ -135,7 +139,7 @@ void AbstractMetaBuilder::checkFunctionModifications()
QString signature = modification.signature;
QString name = signature.trimmed();
- name = name.mid(0, signature.indexOf("("));
+ name = name.mid(0, signature.indexOf(QLatin1Char('(')));
AbstractMetaClass* clazz = m_metaClasses.findClass(centry->qualifiedCppName());
if (!clazz)
@@ -150,8 +154,10 @@ void AbstractMetaBuilder::checkFunctionModifications()
break;
}
- if (function->originalName() == name)
- possibleSignatures.append(function->minimalSignature() + " in " + function->implementingClass()->name());
+ if (function->originalName() == name) {
+ possibleSignatures.append(function->minimalSignature() + QLatin1String(" in ")
+ + function->implementingClass()->name());
+ }
}
if (!found) {
@@ -196,7 +202,7 @@ void AbstractMetaBuilder::registerToStringCapability(FunctionModelItem function_
{
ArgumentList arguments = function_item->arguments();
if (arguments.size() == 2) {
- if (arguments.at(0)->type().toString() == "QDebug") {
+ if (arguments.at(0)->type().toString() == QLatin1String("QDebug")) {
ArgumentModelItem arg = arguments.at(1);
if (AbstractMetaClass *cls = argumentToClass(arg)) {
if (arg->type().indirections() < 2)
@@ -341,7 +347,7 @@ void AbstractMetaBuilder::fixQObjectForScope(TypeDatabase *types,
NamespaceModelItem scope)
{
foreach (ClassModelItem item, scope->classes()) {
- QString qualifiedName = item->qualifiedName().join("::");
+ QString qualifiedName = item->qualifiedName().join(colonColon());
TypeEntry* entry = types->findType(qualifiedName);
if (entry) {
if (isQObject(qualifiedName) && entry->isComplex())
@@ -400,7 +406,7 @@ bool AbstractMetaBuilder::build(QIODevice* input)
ReportHandler::setProgressReference(typeValues);
foreach (ClassModelItem item, typeValues) {
- ReportHandler::progress("Generating class model...");
+ ReportHandler::progress(QLatin1String("Generating class model..."));
AbstractMetaClass *cls = traverseClass(item);
if (!cls)
continue;
@@ -411,7 +417,7 @@ bool AbstractMetaBuilder::build(QIODevice* input)
// We need to know all global enums
ReportHandler::setProgressReference(m_dom->enumMap());
foreach (EnumModelItem item, m_dom->enums()) {
- ReportHandler::progress("Generating enum model...");
+ ReportHandler::progress(QLatin1String("Generating enum model..."));
AbstractMetaEnum *metaEnum = traverseEnum(item, 0, QSet<QString>());
if (metaEnum) {
if (metaEnum->typeEntry()->generateCode())
@@ -427,7 +433,7 @@ bool AbstractMetaBuilder::build(QIODevice* input)
ReportHandler::setProgressReference(namespaceMap);
foreach (NamespaceModelItem item, namespaceTypeValues) {
- ReportHandler::progress("Generating namespace model...");
+ ReportHandler::progress(QLatin1String("Generating namespace model..."));
AbstractMetaClass *metaClass = traverseNamespace(item);
if (metaClass)
m_metaClasses << metaClass;
@@ -438,7 +444,7 @@ bool AbstractMetaBuilder::build(QIODevice* input)
TypeAliasList typeAliases = m_dom->typeAliases();
ReportHandler::setProgressReference(typeAliases);
foreach (TypeAliasModelItem typeAlias, typeAliases) {
- ReportHandler::progress("Resolving typedefs...");
+ ReportHandler::progress(QLatin1String("Resolving typedefs..."));
AbstractMetaClass* cls = traverseTypeAlias(typeAlias);
addAbstractMetaClass(cls);
}
@@ -453,7 +459,7 @@ bool AbstractMetaBuilder::build(QIODevice* input)
// Global functions
foreach (FunctionModelItem func, m_dom->functions()) {
- if (func->accessPolicy() != CodeModel::Public || func->name().startsWith("operator"))
+ if (func->accessPolicy() != CodeModel::Public || func->name().startsWith(QLatin1String("operator")))
continue;
FunctionTypeEntry* funcEntry = types->findFunctionType(func->name());
@@ -481,14 +487,14 @@ bool AbstractMetaBuilder::build(QIODevice* input)
ReportHandler::setProgressReference(m_metaClasses);
foreach (AbstractMetaClass* cls, m_metaClasses) {
- ReportHandler::progress("Fixing class inheritance...");
+ ReportHandler::progress(QLatin1String("Fixing class inheritance..."));
if (!cls->isInterface() && !cls->isNamespace())
setupInheritance(cls);
}
ReportHandler::setProgressReference(m_metaClasses);
foreach (AbstractMetaClass* cls, m_metaClasses) {
- ReportHandler::progress("Detecting inconsistencies in class model...");
+ ReportHandler::progress(QLatin1String("Detecting inconsistencies in class model..."));
cls->fixFunctions();
if (!cls->typeEntry()) {
@@ -506,10 +512,10 @@ bool AbstractMetaBuilder::build(QIODevice* input)
}
if (cls->isAbstract() && !cls->isInterface())
- cls->typeEntry()->setLookupName(cls->typeEntry()->targetLangName() + "$ConcreteWrapper");
+ cls->typeEntry()->setLookupName(cls->typeEntry()->targetLangName() + QLatin1String("$ConcreteWrapper"));
}
TypeEntryHash allEntries = types->allEntries();
- ReportHandler::progress("Detecting inconsistencies in typesystem...");
+ ReportHandler::progress(QLatin1String("Detecting inconsistencies in typesystem..."));
foreach (QList<TypeEntry*> entries, allEntries) {
foreach (TypeEntry* entry, entries) {
@@ -569,39 +575,40 @@ bool AbstractMetaBuilder::build(QIODevice* input)
}
{
- FunctionList hashFunctions = m_dom->findFunctions("qHash");
+ FunctionList hashFunctions = m_dom->findFunctions(QLatin1String("qHash"));
foreach (FunctionModelItem item, hashFunctions)
registerHashFunction(item);
}
{
- FunctionList hashFunctions = m_dom->findFunctions("operator<<");
+ FunctionList hashFunctions = m_dom->findFunctions(QLatin1String("operator<<"));
foreach (FunctionModelItem item, hashFunctions)
registerToStringCapability(item);
}
{
- FunctionList binaryOperators = m_dom->findFunctions("operator==")
- + m_dom->findFunctions("operator!=")
- + m_dom->findFunctions("operator<=")
- + m_dom->findFunctions("operator>=")
- + m_dom->findFunctions("operator<")
- + m_dom->findFunctions("operator+")
- + m_dom->findFunctions("operator/")
- + m_dom->findFunctions("operator*")
- + m_dom->findFunctions("operator-")
- + m_dom->findFunctions("operator&")
- + m_dom->findFunctions("operator|")
- + m_dom->findFunctions("operator^")
- + m_dom->findFunctions("operator~")
- + m_dom->findFunctions("operator>");
+ FunctionList binaryOperators = m_dom->findFunctions(QLatin1String("operator=="))
+ + m_dom->findFunctions(QLatin1String("operator!="))
+ + m_dom->findFunctions(QLatin1String("operator<="))
+ + m_dom->findFunctions(QLatin1String("operator>="))
+ + m_dom->findFunctions(QLatin1String("operator<"))
+ + m_dom->findFunctions(QLatin1String("operator+"))
+ + m_dom->findFunctions(QLatin1String("operator/"))
+ + m_dom->findFunctions(QLatin1String("operator*"))
+ + m_dom->findFunctions(QLatin1String("operator-"))
+ + m_dom->findFunctions(QLatin1String("operator&"))
+ + m_dom->findFunctions(QLatin1String("operator|"))
+ + m_dom->findFunctions(QLatin1String("operator^"))
+ + m_dom->findFunctions(QLatin1String("operator~"))
+ + m_dom->findFunctions(QLatin1String("operator>"));
foreach (FunctionModelItem item, binaryOperators)
traverseOperatorFunction(item);
}
{
- FunctionList streamOperators = m_dom->findFunctions("operator<<") + m_dom->findFunctions("operator>>");
+ FunctionList streamOperators = m_dom->findFunctions(QLatin1String("operator<<"))
+ + m_dom->findFunctions(QLatin1String("operator>>"));
foreach (FunctionModelItem item, streamOperators)
traverseStreamOperator(item);
}
@@ -670,7 +677,9 @@ void AbstractMetaBuilder::addAbstractMetaClass(AbstractMetaClass *cls)
AbstractMetaClass* AbstractMetaBuilder::traverseNamespace(NamespaceModelItem namespaceItem)
{
- QString namespaceName = (!m_namespacePrefix.isEmpty() ? m_namespacePrefix + "::" : QString()) + namespaceItem->name();
+ QString namespaceName =
+ (!m_namespacePrefix.isEmpty() ? m_namespacePrefix + colonColon() : QString())
+ + namespaceItem->name();
NamespaceTypeEntry *type = TypeDatabase::instance()->findNamespaceType(namespaceName);
if (TypeDatabase::instance()->isClassRejected(namespaceName)) {
@@ -699,7 +708,7 @@ AbstractMetaClass* AbstractMetaBuilder::traverseNamespace(NamespaceModelItem nam
traverseEnums(model_dynamic_cast<ScopeModelItem>(namespaceItem), metaClass, namespaceItem->enumsDeclarations());
pushScope(model_dynamic_cast<ScopeModelItem>(namespaceItem));
- m_namespacePrefix = currentScope()->qualifiedName().join("::");
+ m_namespacePrefix = currentScope()->qualifiedName().join(colonColon());
ClassList classes = namespaceItem->classes();
foreach (ClassModelItem cls, classes) {
@@ -740,7 +749,7 @@ AbstractMetaClass* AbstractMetaBuilder::traverseNamespace(NamespaceModelItem nam
m_currentClass = 0;
popScope();
- m_namespacePrefix = currentScope()->qualifiedName().join("::");
+ m_namespacePrefix = currentScope()->qualifiedName().join(colonColon());
if (!type->include().isValid())
setInclude(type, namespaceItem->fileName());
@@ -815,7 +824,7 @@ int AbstractMetaBuilder::figureOutEnumValue(const QString &stringValue,
if (stringValue.isEmpty())
return oldValuevalue;
- QStringList stringValues = stringValue.split("|");
+ QStringList stringValues = stringValue.split(QLatin1Char('|'));
int returnValue = 0;
@@ -845,7 +854,7 @@ int AbstractMetaBuilder::figureOutEnumValue(const QString &stringValue,
if (metaEnum) {
v = findOutValueFromString(s, matched);
if (!matched) {
- QString enclosingClass = QString(metaEnum->enclosingClass() ? metaEnum->enclosingClass()->name() + "::" : QString());
+ QString enclosingClass = QString(metaEnum->enclosingClass() ? metaEnum->enclosingClass()->name() + colonColon() : QString());
qCWarning(lcShiboken).noquote().nospace()
<< "unhandled enum value: " << s << " in "
<< enclosingClass << metaEnum->name() << " from header '"
@@ -861,14 +870,14 @@ int AbstractMetaBuilder::figureOutEnumValue(const QString &stringValue,
}
if (!matched) {
- QString warn = QString("unmatched enum %1").arg(stringValue);
+ QString warn = QStringLiteral("unmatched enum %1").arg(stringValue);
if (metaFunction) {
- warn += QString(" when parsing default value of '%1' in class '%2'")
- .arg(metaFunction->name())
- .arg(metaFunction->implementingClass()->name());
+ warn += QStringLiteral(" when parsing default value of '%1' in class '%2'")
+ .arg(metaFunction->name(), metaFunction->implementingClass()->name());
}
- warn += " from header '" + metaEnum->typeEntry()->include().name() + "'";
+ warn += QLatin1String(" from header '") + metaEnum->typeEntry()->include().name()
+ + QLatin1Char('\'');
qCWarning(lcShiboken).noquote().nospace() << warn;
returnValue = oldValuevalue;
@@ -949,7 +958,7 @@ void AbstractMetaBuilder::figureOutDefaultEnumArguments()
AbstractMetaEnum* AbstractMetaBuilder::traverseEnum(EnumModelItem enumItem, AbstractMetaClass* enclosing, const QSet<QString> &enumsDeclarations)
{
- QString qualifiedName = enumItem->qualifiedName().join("::");
+ QString qualifiedName = enumItem->qualifiedName().join(colonColon());
TypeEntry* typeEntry = 0;
if (enumItem->accessPolicy() == CodeModel::Private) {
@@ -957,7 +966,7 @@ AbstractMetaEnum* AbstractMetaBuilder::traverseEnum(EnumModelItem enumItem, Abst
QString enumName = names.last();
QString nspace;
if (names.size() > 1)
- nspace = QStringList(names.mid(0, names.size() - 1)).join("::");
+ nspace = QStringList(names.mid(0, names.size() - 1)).join(colonColon());
typeEntry = new EnumTypeEntry(nspace, enumName, 0);
TypeDatabase::instance()->addType(typeEntry);
} else if (!enumItem->isAnonymous()) {
@@ -967,7 +976,7 @@ AbstractMetaEnum* AbstractMetaBuilder::traverseEnum(EnumModelItem enumItem, Abst
foreach (const EnumeratorModelItem& enumValue, enumItem->enumerators()) {
tmpQualifiedName.removeLast();
tmpQualifiedName << enumValue->name();
- qualifiedName = tmpQualifiedName.join("::");
+ qualifiedName = tmpQualifiedName.join(colonColon());
typeEntry = TypeDatabase::instance()->findType(qualifiedName);
if (typeEntry)
break;
@@ -1036,7 +1045,7 @@ AbstractMetaEnum* AbstractMetaBuilder::traverseEnum(EnumModelItem enumItem, Abst
// Add into global register...
if (enclosing)
- m_enumValues[enclosing->name() + "::" + metaEnumValue->name()] = metaEnumValue;
+ m_enumValues[enclosing->name() + colonColon() + metaEnumValue->name()] = metaEnumValue;
else
m_enumValues[metaEnumValue->name()] = metaEnumValue;
}
@@ -1053,7 +1062,7 @@ AbstractMetaEnum* AbstractMetaBuilder::traverseEnum(EnumModelItem enumItem, Abst
QString name;
if (enclosing) {
name += enclosing->name();
- name += "::";
+ name += colonColon();
}
name += e->name();
EnumValueTypeEntry* enumValue = new EnumValueTypeEntry(name, e->value(), static_cast<EnumTypeEntry*>(typeEntry), typeEntry->version());
@@ -1072,7 +1081,7 @@ AbstractMetaClass* AbstractMetaBuilder::traverseTypeAlias(TypeAliasModelItem typ
// we have an inner class
if (m_currentClass) {
fullClassName = stripTemplateArgs(m_currentClass->typeEntry()->qualifiedCppName())
- + "::" + fullClassName;
+ + colonColon() + fullClassName;
}
// If this is the alias for a primitive type
@@ -1092,12 +1101,12 @@ AbstractMetaClass* AbstractMetaBuilder::traverseTypeAlias(TypeAliasModelItem typ
return 0;
if (type->isObject())
- static_cast<ObjectTypeEntry *>(type)->setQObject(isQObject(stripTemplateArgs(typeAlias->type().qualifiedName().join("::"))));
+ static_cast<ObjectTypeEntry *>(type)->setQObject(isQObject(stripTemplateArgs(typeAlias->type().qualifiedName().join(colonColon()))));
AbstractMetaClass *metaClass = createMetaClass();
metaClass->setTypeAlias(true);
metaClass->setTypeEntry(type);
- metaClass->setBaseClassNames(QStringList() << typeAlias->type().qualifiedName().join("::"));
+ metaClass->setBaseClassNames(QStringList() << typeAlias->type().qualifiedName().join(colonColon()));
*metaClass += AbstractMetaAttributes::Public;
// Set the default include file name
@@ -1117,16 +1126,16 @@ AbstractMetaClass* AbstractMetaBuilder::traverseClass(ClassModelItem classItem)
// we have inner an class
if (m_currentClass) {
fullClassName = stripTemplateArgs(m_currentClass->typeEntry()->qualifiedCppName())
- + "::" + fullClassName;
+ + colonColon() + fullClassName;
}
ComplexTypeEntry* type = TypeDatabase::instance()->findComplexType(fullClassName);
RejectReason reason = NoReason;
- if (fullClassName == "QMetaTypeId") {
+ if (fullClassName == QLatin1String("QMetaTypeId")) {
// QtScript: record which types have been declared
- int lpos = classItem->name().indexOf('<');
- int rpos = classItem->name().lastIndexOf('>');
+ int lpos = classItem->name().indexOf(QLatin1Char('<'));
+ int rpos = classItem->name().lastIndexOf(QLatin1Char('>'));
if ((lpos != -1) && (rpos != -1)) {
QString declaredTypename = classItem->name().mid(lpos + 1, rpos - lpos - 1);
m_qmetatypeDeclaredTypenames.insert(declaredTypename);
@@ -1241,7 +1250,7 @@ AbstractMetaClass* AbstractMetaBuilder::currentTraversedClass(ScopeModelItem ite
// This is an inner class
if (m_currentClass)
- fullClassName = stripTemplateArgs(m_currentClass->typeEntry()->qualifiedCppName()) + "::" + fullClassName;
+ fullClassName = stripTemplateArgs(m_currentClass->typeEntry()->qualifiedCppName()) + colonColon() + fullClassName;
AbstractMetaClass* metaClass = m_metaClasses.findClass(fullClassName);
if (!metaClass)
@@ -1300,7 +1309,7 @@ AbstractMetaField* AbstractMetaBuilder::traverseField(VariableModelItem field, c
return 0;
if (TypeDatabase::instance()->isFieldRejected(className, fieldName)) {
- m_rejectedFields.insert(className + "::" + fieldName, GenerationDisabled);
+ m_rejectedFields.insert(className + colonColon() + fieldName, GenerationDisabled);
return 0;
}
@@ -1314,7 +1323,7 @@ AbstractMetaField* AbstractMetaBuilder::traverseField(VariableModelItem field, c
AbstractMetaType *metaType = translateType(fieldType, &ok);
if (!metaType || !ok) {
- const QString type = TypeInfo::resolveType(fieldType, currentScope()->toItem()).qualifiedName().join(QLatin1String("::"));
+ const QString type = TypeInfo::resolveType(fieldType, currentScope()->toItem()).qualifiedName().join(colonColon());
qCWarning(lcShiboken).noquote().nospace()
<< QStringLiteral("skipping field '%1::%2' with unmatched type '%3'")
.arg(m_currentClass->name(), fieldName, type);
@@ -1362,7 +1371,7 @@ void AbstractMetaBuilder::setupFunctionDefaults(AbstractMetaFunction* metaFuncti
// to function properly. Such as function modifications
metaFunction->setImplementingClass(metaClass);
- if (metaFunction->name() == "operator_equal")
+ if (metaFunction->name() == QLatin1String("operator_equal"))
metaClass->setHasEqualsOperator(true);
if (!metaFunction->isFinalInTargetLang()
@@ -1378,11 +1387,11 @@ void AbstractMetaBuilder::fixReturnTypeOfConversionOperator(AbstractMetaFunction
return;
TypeDatabase* types = TypeDatabase::instance();
- QString castTo = metaFunction->name().remove(QRegExp("^operator ")).trimmed();
+ QString castTo = metaFunction->name().remove(QRegExp(QLatin1String("^operator "))).trimmed();
- if (castTo.endsWith('&'))
+ if (castTo.endsWith(QLatin1Char('&')))
castTo.chop(1);
- if (castTo.startsWith("const "))
+ if (castTo.startsWith(QLatin1String("const ")))
castTo.remove(0, 6);
TypeEntry* retType = types->findType(castTo);
@@ -1435,7 +1444,8 @@ static bool _fixFunctionModelItemType(TypeInfo& type, const AbstractMetaClass* m
QStringList templateTypes;
foreach (TypeEntry* templateType, metaClass->templateArguments())
templateTypes << templateType->qualifiedCppName();
- QString fixedTypeName = QString("%1<%2 >").arg(metaClass->typeEntry()->qualifiedCppName()).arg(templateTypes.join(", "));
+ QString fixedTypeName = metaClass->typeEntry()->qualifiedCppName() + QLatin1Char('<')
+ + templateTypes.join(QLatin1String(", ")) + QLatin1String(" >");
type.setQualifiedName(QStringList(fixedTypeName));
return true;
}
@@ -1624,7 +1634,7 @@ bool AbstractMetaBuilder::setupInheritance(AbstractMetaClass *metaClass)
QStringList baseClasses = metaClass->baseClassNames();
// we only support our own containers and ONLY if there is only one baseclass
- if (baseClasses.size() == 1 && baseClasses.first().contains('<')) {
+ if (baseClasses.size() == 1 && baseClasses.first().contains(QLatin1Char('<'))) {
TypeParser::Info info;
ComplexTypeEntry* baseContainerType;
AbstractMetaClass* templ = findTemplateClass(baseClasses.first(), metaClass, &info, &baseContainerType);
@@ -1845,7 +1855,7 @@ void AbstractMetaBuilder::fixArgumentNames(AbstractMetaFunction* func)
int i = 1;
foreach (AbstractMetaArgument* arg, func->arguments()) {
if (arg->name().isEmpty())
- arg->setName("arg__" + QString::number(i), false);
+ arg->setName(QLatin1String("arg__") + QString::number(i), false);
++i;
}
}
@@ -1855,7 +1865,7 @@ static QString functionSignature(FunctionModelItem functionItem)
QStringList args;
foreach (ArgumentModelItem arg, functionItem->arguments())
args << arg->type().toString();
- return QString("%1(%2)").arg(functionItem->name(), args.join(","));
+ return functionItem->name() + QLatin1Char('(') + args.join(QLatin1Char(',')) + QLatin1Char(')');
}
AbstractMetaFunction* AbstractMetaBuilder::traverseFunction(FunctionModelItem functionItem)
@@ -1866,11 +1876,11 @@ AbstractMetaFunction* AbstractMetaBuilder::traverseFunction(FunctionModelItem fu
className = m_currentClass->typeEntry()->qualifiedCppName();
if (TypeDatabase::instance()->isFunctionRejected(className, functionName)) {
- m_rejectedFunctions.insert(className + "::" + functionName, GenerationDisabled);
+ m_rejectedFunctions.insert(className + colonColon() + functionName, GenerationDisabled);
return 0;
}
else if (TypeDatabase::instance()->isFunctionRejected(className, functionSignature(functionItem))) {
- m_rejectedFunctions.insert(className + "::" + functionName, GenerationDisabled);
+ m_rejectedFunctions.insert(className + colonColon() + functionName, GenerationDisabled);
return 0;
}
@@ -1917,12 +1927,12 @@ AbstractMetaFunction* AbstractMetaBuilder::traverseFunction(FunctionModelItem fu
QString strippedClassName = className;
- int cc_pos = strippedClassName.lastIndexOf("::");
+ int cc_pos = strippedClassName.lastIndexOf(colonColon());
if (cc_pos > 0)
strippedClassName = strippedClassName.mid(cc_pos + 2);
TypeInfo functionType = functionItem->type();
- if (functionName.startsWith('~')) {
+ if (functionName.startsWith(QLatin1Char('~'))) {
metaFunction->setFunctionType(AbstractMetaFunction::DestructorFunction);
metaFunction->setInvalid(true);
} else if (stripTemplateArgs(functionName) == strippedClassName) {
@@ -1938,7 +1948,7 @@ AbstractMetaFunction* AbstractMetaBuilder::traverseFunction(FunctionModelItem fu
qCWarning(lcShiboken).noquote().nospace()
<< QStringLiteral("skipping function '%1::%2', unmatched return type '%3'")
.arg(className, functionItem->name(), functionItem->type().toString());
- m_rejectedFunctions[className + "::" + functionName] =
+ m_rejectedFunctions[className + colonColon() + functionName] =
UnmatchedReturnType;
metaFunction->setInvalid(true);
return metaFunction;
@@ -1957,7 +1967,7 @@ AbstractMetaFunction* AbstractMetaBuilder::traverseFunction(FunctionModelItem fu
if (arguments.size() == 1) {
ArgumentModelItem arg = arguments.at(0);
TypeInfo type = arg->type();
- if (type.qualifiedName().first() == "void" && type.indirections() == 0)
+ if (type.qualifiedName().first() == QLatin1String("void") && type.indirections() == 0)
delete arguments.takeFirst();
}
@@ -1973,7 +1983,7 @@ AbstractMetaFunction* AbstractMetaBuilder::traverseFunction(FunctionModelItem fu
qCWarning(lcShiboken).noquote().nospace()
<< QStringLiteral("skipping function '%1::%2', unmatched parameter type '%3'")
.arg(className, functionItem->name(), arg->type().toString());
- m_rejectedFunctions[className + "::" + functionName] =
+ m_rejectedFunctions[className + colonColon() + functionName] =
UnmatchedArgumentType;
metaFunction->setInvalid(true);
return metaFunction;
@@ -2014,7 +2024,7 @@ AbstractMetaFunction* AbstractMetaBuilder::traverseFunction(FunctionModelItem fu
metaArg->setOriginalDefaultValueExpression(expr);
if (metaFunction->removedDefaultExpression(m_currentClass, i + 1)) {
- expr = "";
+ expr.clear();
} else if (!replacedExpression.isEmpty()) {
expr = replacedExpression;
}
@@ -2051,7 +2061,7 @@ AbstractMetaType* AbstractMetaBuilder::translateType(double vr, const AddedFunct
QString typeName = typeInfo.name;
- if (typeName == "void")
+ if (typeName == QLatin1String("void"))
return 0;
type = typeDb->findType(typeName);
@@ -2059,7 +2069,7 @@ AbstractMetaType* AbstractMetaBuilder::translateType(double vr, const AddedFunct
// test if the type is a template, like a container
bool isTemplate = false;
QStringList templateArgs;
- if (!type && typeInfo.name.contains('<')) {
+ if (!type && typeInfo.name.contains(QLatin1Char('<'))) {
const QStringList& parsedType = parseTemplateType(typeInfo.name);
if (parsedType.isEmpty()) {
qCWarning(lcShiboken).noquote().nospace()
@@ -2075,19 +2085,19 @@ AbstractMetaType* AbstractMetaBuilder::translateType(double vr, const AddedFunct
SingleTypeEntryHash entries = typeDb->entries();
foreach (QString candidate, entries.keys()) {
// Let's try to find the type in different scopes.
- if (candidate.endsWith("::"+typeName))
+ if (candidate.endsWith(colonColon() + typeName))
candidates << candidate;
}
- QString msg = QString("Type '%1' wasn't found in the type database.\n").arg(typeName);
+ QString msg = QStringLiteral("Type '%1' wasn't found in the type database.\n").arg(typeName);
if (candidates.isEmpty())
- qFatal(qPrintable(QString(msg + "Declare it in the type system using the proper <*-type> tag.")), NULL);
+ qFatal(qPrintable(QString(msg + QLatin1String("Declare it in the type system using the proper <*-type> tag."))), NULL);
- msg += "Remember to inform the full qualified name for the type you want to use.\nCandidates are:\n";
+ msg += QLatin1String("Remember to inform the full qualified name for the type you want to use.\nCandidates are:\n");
candidates.sort();
foreach (const QString& candidate, candidates) {
- msg += " " + candidate + "\n";
+ msg += QLatin1String(" ") + candidate + QLatin1Char('\n');
}
qFatal(qPrintable(msg), NULL);
}
@@ -2111,9 +2121,9 @@ AbstractMetaType* AbstractMetaBuilder::translateType(double vr, const AddedFunct
static const TypeEntry* findTypeEntryUsingContext(const AbstractMetaClass* metaClass, const QString& qualifiedName)
{
const TypeEntry* type = 0;
- QStringList context = metaClass->qualifiedCppName().split("::");
+ QStringList context = metaClass->qualifiedCppName().split(colonColon());
while(!type && (context.size() > 0) ) {
- type = TypeDatabase::instance()->findType(context.join("::") + "::" + qualifiedName);
+ type = TypeDatabase::instance()->findType(context.join(colonColon()) + colonColon() + qualifiedName);
context.removeLast();
}
return type;
@@ -2146,7 +2156,7 @@ AbstractMetaType* AbstractMetaBuilder::translateType(const TypeInfo& _typei, boo
int i = m_scopes.size() - 1;
while (i >= 0) {
typei = TypeInfo::resolveType(_typei, m_scopes.at(i--)->toItem());
- if (typei.qualifiedName().join("::") != _typei.qualifiedName().join("::"))
+ if (typei.qualifiedName().join(colonColon()) != _typei.qualifiedName().join(colonColon()))
break;
}
@@ -2212,15 +2222,15 @@ AbstractMetaType* AbstractMetaBuilder::translateType(const TypeInfo& _typei, boo
return 0;
}
- QString qualifiedName = qualifierList.join("::");
+ QString qualifiedName = qualifierList.join(colonColon());
QString name = qualifierList.takeLast();
// 3. Special case 'void' type
- if (name == "void" && !typeInfo.indirections)
+ if (name == QLatin1String("void") && !typeInfo.indirections)
return 0;
// 4. Special case QFlags (include instantiation in name)
- if (qualifiedName == "QFlags")
+ if (qualifiedName == QLatin1String("QFlags"))
qualifiedName = typeInfo.toString();
const TypeEntry *type = 0;
@@ -2267,19 +2277,19 @@ AbstractMetaType* AbstractMetaBuilder::translateType(const TypeInfo& _typei, boo
if (!type && !TypeDatabase::instance()->isClassRejected(qualifiedName) && m_currentClass && resolveScope) {
QStringList contexts;
contexts.append(m_currentClass->qualifiedCppName());
- contexts.append(currentScope()->qualifiedName().join("::"));
+ contexts.append(currentScope()->qualifiedName().join(colonColon()));
TypeInfo info = typei;
bool subclassesDone = false;
while (!contexts.isEmpty() && !type) {
- type = TypeDatabase::instance()->findType(contexts.at(0) + "::" + qualifiedName);
+ type = TypeDatabase::instance()->findType(contexts.at(0) + colonColon() + qualifiedName);
contexts.pop_front();
// 10. Last resort: Special cased prefix of Qt namespace since the meta object implicitly inherits this, so
// enum types from there may be addressed without any scope resolution in properties.
if (!contexts.size() && !subclassesDone) {
- contexts << "Qt";
+ contexts << QLatin1String("Qt");
subclassesDone = true;
}
}
@@ -2311,7 +2321,7 @@ AbstractMetaType* AbstractMetaBuilder::translateType(const TypeInfo& _typei, boo
info.setIndirections(ta.indirections);
info.setFunctionPointer(false);
- info.setQualifiedName(ta.instantiationName().split("::"));
+ info.setQualifiedName(ta.instantiationName().split(colonColon()));
AbstractMetaType* targType = translateType(info, ok);
if (!(*ok)) {
@@ -2338,14 +2348,14 @@ int AbstractMetaBuilder::findOutValueFromString(const QString& stringValue, bool
if (ok)
return value;
- if (stringValue == "true" || stringValue == "false") {
+ if (stringValue == QLatin1String("true") || stringValue == QLatin1String("false")) {
ok = true;
- return (stringValue == "true");
+ return (stringValue == QLatin1String("true"));
}
// This is a very lame way to handle expression evaluation,
// but it is not critical and will do for the time being.
- static QRegExp variableNameRegExp("^[a-zA-Z_][a-zA-Z0-9_]*$");
+ static QRegExp variableNameRegExp(QLatin1String("^[a-zA-Z_][a-zA-Z0-9_]*$"));
if (!variableNameRegExp.exactMatch(stringValue)) {
ok = true;
return 0;
@@ -2385,14 +2395,14 @@ QString AbstractMetaBuilder::fixDefaultValue(ArgumentModelItem item, AbstractMet
QString expr = item->defaultValueExpression();
if (type) {
if (type->isPrimitive()) {
- if (type->name() == "boolean") {
- if (expr != "false" && expr != "true") {
+ if (type->name() == QLatin1String("boolean")) {
+ if (expr != QLatin1String("false") && expr != QLatin1String("true")) {
bool ok = false;
int number = expr.toInt(&ok);
if (ok && number)
- expr = "true";
+ expr = QLatin1String("true");
else
- expr = "false";
+ expr = QLatin1String("false");
}
} else {
// This can be an enum or flag so I need to delay the
@@ -2402,34 +2412,34 @@ QString AbstractMetaBuilder::fixDefaultValue(ArgumentModelItem item, AbstractMet
} else if (type->isFlags() || type->isEnum()) {
bool isNumber;
expr.toInt(&isNumber);
- if (!isNumber && expr.indexOf("::") < 0) {
+ if (!isNumber && expr.indexOf(colonColon()) < 0) {
// Add the enum/flag scope to default value, making it usable
// from other contexts beside its owner class hierarchy
- QRegExp typeRegEx("[^<]*[<]([^:]*::).*");
+ QRegExp typeRegEx(QLatin1String("[^<]*[<]([^:]*::).*"));
typeRegEx.indexIn(type->minimalSignature());
expr = typeRegEx.cap(1) + expr;
}
- } else if (type->isContainer() && expr.contains('<')) {
- QRegExp typeRegEx("[^<]*<(.*)>");
+ } else if (type->isContainer() && expr.contains(QLatin1Char('<'))) {
+ QRegExp typeRegEx(QLatin1String("[^<]*<(.*)>"));
typeRegEx.indexIn(type->minimalSignature());
- QRegExp defaultRegEx("([^<]*<).*(>[^>]*)");
+ QRegExp defaultRegEx(QLatin1String("([^<]*<).*(>[^>]*)"));
defaultRegEx.indexIn(expr);
expr = defaultRegEx.cap(1) + typeRegEx.cap(1) + defaultRegEx.cap(2);
} else {
// Here the default value is supposed to be a constructor,
// a class field, or a constructor receiving a class field
- QRegExp defaultRegEx("([^\\(]*\\(|)([^\\)]*)(\\)|)");
+ QRegExp defaultRegEx(QLatin1String("([^\\(]*\\(|)([^\\)]*)(\\)|)"));
defaultRegEx.indexIn(expr);
QString defaultValueCtorName = defaultRegEx.cap(1);
- if (defaultValueCtorName.endsWith('('))
+ if (defaultValueCtorName.endsWith(QLatin1Char('(')))
defaultValueCtorName.chop(1);
// Fix the scope for constructor using the already
// resolved argument type as a reference.
// The following regular expression extracts any
// use of namespaces/scopes from the type string.
- QRegExp typeRegEx("^(?:const[\\s]+|)([\\w:]*::|)([A-Za-z_]\\w*)\\s*[&\\*]?$");
+ QRegExp typeRegEx(QLatin1String("^(?:const[\\s]+|)([\\w:]*::|)([A-Za-z_]\\w*)\\s*[&\\*]?$"));
typeRegEx.indexIn(type->minimalSignature());
QString typeNamespace = typeRegEx.cap(1);
@@ -2441,7 +2451,8 @@ QString AbstractMetaBuilder::fixDefaultValue(ArgumentModelItem item, AbstractMet
if (implementingClass) {
foreach (const AbstractMetaField* field, implementingClass->fields()) {
if (defaultRegEx.cap(2) == field->name()) {
- expr = defaultRegEx.cap(1) + implementingClass->name() + "::" + defaultRegEx.cap(2) + defaultRegEx.cap(3);
+ expr = defaultRegEx.cap(1) + implementingClass->name()
+ + colonColon() + defaultRegEx.cap(2) + defaultRegEx.cap(3);
break;
}
}
@@ -2460,13 +2471,13 @@ QString AbstractMetaBuilder::fixDefaultValue(ArgumentModelItem item, AbstractMet
bool AbstractMetaBuilder::isQObject(const QString& qualifiedName)
{
- if (qualifiedName == "QObject")
+ if (qualifiedName == QLatin1String("QObject"))
return true;
ClassModelItem classItem = m_dom->findClass(qualifiedName);
if (!classItem) {
- QStringList names = qualifiedName.split(QLatin1String("::"));
+ QStringList names = qualifiedName.split(colonColon());
NamespaceModelItem ns = model_dynamic_cast<NamespaceModelItem>(m_dom);
for (int i = 0; i < names.size() - 1 && ns; ++i)
ns = ns->namespaceMap().value(names.at(i));
@@ -2474,7 +2485,7 @@ bool AbstractMetaBuilder::isQObject(const QString& qualifiedName)
classItem = ns->findClass(names.at(names.size() - 1));
}
- bool isqobject = classItem && classItem->extendsClass("QObject");
+ bool isqobject = classItem && classItem->extendsClass(QLatin1String("QObject"));
if (classItem && !isqobject) {
QStringList baseClasses = classItem->baseClasses();
@@ -2505,13 +2516,13 @@ AbstractMetaClass* AbstractMetaBuilder::findTemplateClass(const QString& name, c
TypeDatabase* types = TypeDatabase::instance();
- QStringList scope = context->typeEntry()->qualifiedCppName().split("::");
+ QStringList scope = context->typeEntry()->qualifiedCppName().split(colonColon());
scope.removeLast();
for (int i = scope.size(); i >= 0; --i) {
- QString prefix = i > 0 ? QStringList(scope.mid(0, i)).join("::") + "::" : QString();
+ QString prefix = i > 0 ? QStringList(scope.mid(0, i)).join(colonColon()) + colonColon() : QString();
QString completeName = prefix + name;
*info = TypeParser::parse(completeName);
- QString qualifiedName = info->qualified_name.join("::");
+ QString qualifiedName = info->qualified_name.join(colonColon());
AbstractMetaClass* templ = 0;
foreach (AbstractMetaClass *c, m_templates) {
@@ -2539,7 +2550,7 @@ AbstractMetaClassList AbstractMetaBuilder::getBaseClasses(const AbstractMetaClas
AbstractMetaClassList baseClasses;
foreach (const QString& parent, metaClass->baseClassNames()) {
AbstractMetaClass* cls = 0;
- if (parent.contains('<'))
+ if (parent.contains(QLatin1Char('<')))
cls = findTemplateClass(parent, metaClass);
else
cls = m_metaClasses.findClass(parent);
@@ -2577,7 +2588,7 @@ AbstractMetaType* AbstractMetaBuilder::inheritTemplateType(const QList<AbstractM
// If the template is intantiated with void we special case this as rejecting the functions that use this
// parameter from the instantiation.
- if (templateTypes.size() <= tae->ordinal() || templateTypes.at(tae->ordinal())->typeEntry()->name() == "void") {
+ if (templateTypes.size() <= tae->ordinal() || templateTypes.at(tae->ordinal())->typeEntry()->name() == QLatin1String("void")) {
if (ok)
*ok = false;
return 0;
@@ -2626,12 +2637,12 @@ bool AbstractMetaBuilder::inheritTemplate(AbstractMetaClass* subclass,
}
foreach (const TypeParser::Info &i, targs) {
- QString typeName = i.qualified_name.join("::");
+ QString typeName = i.qualified_name.join(colonColon());
QStringList possibleNames;
- possibleNames << subclass->qualifiedCppName() + "::" + typeName;
- possibleNames << templateClass->qualifiedCppName() + "::" + typeName;
+ possibleNames << subclass->qualifiedCppName() + colonColon() + typeName;
+ possibleNames << templateClass->qualifiedCppName() + colonColon() + typeName;
if (subclass->enclosingClass())
- possibleNames << subclass->enclosingClass()->qualifiedCppName() + "::" + typeName;
+ possibleNames << subclass->enclosingClass()->qualifiedCppName() + colonColon() + typeName;
possibleNames << typeName;
TypeDatabase* typeDb = TypeDatabase::instance();
@@ -2771,9 +2782,9 @@ void AbstractMetaBuilder::parseQ_Property(AbstractMetaClass* metaClass, const QS
AbstractMetaType* type = 0;
QString scope;
for (int j = qualifiedScopeName.size(); j >= 0; --j) {
- scope = j > 0 ? QStringList(qualifiedScopeName.mid(0, j)).join("::") + "::" : QString();
+ scope = j > 0 ? QStringList(qualifiedScopeName.mid(0, j)).join(colonColon()) + colonColon() : QString();
TypeInfo info;
- info.setQualifiedName((scope + l.at(0)).split("::"));
+ info.setQualifiedName((scope + l.at(0)).split(colonColon()));
type = translateType(info, &ok);
if (type && ok)
@@ -2815,7 +2826,7 @@ static AbstractMetaFunction* findCopyCtor(AbstractMetaClass* cls)
functions << cls->queryFunctions(AbstractMetaClass::Visible);
foreach (AbstractMetaFunction* f, functions) {
- if (f->isConstructor() || f->name() == "operator=") {
+ if (f->isConstructor() || f->name() == QLatin1String("operator=")) {
AbstractMetaArgumentList arguments = f->arguments();
if (arguments.size() == 1) {
if (cls->typeEntry()->qualifiedCppName() == arguments.at(0)->type()->typeEntry()->qualifiedCppName())
@@ -2885,7 +2896,7 @@ static void writeRejectLogFile(const QString &name,
for (int reason = 0; reason < AbstractMetaBuilder::NoReason; ++reason) {
- s << QString(72, '*') << endl;
+ s << QString(72, QLatin1Char('*')) << endl;
switch (reason) {
case AbstractMetaBuilder::NotInTypeSystem:
s << "Not in type system";
@@ -2923,7 +2934,7 @@ static void writeRejectLogFile(const QString &name,
s << " - " << it.key() << endl;
}
- s << QString(72, '*') << endl << endl;
+ s << QString(72, QLatin1Char('*')) << endl << endl;
}
}
@@ -2931,10 +2942,10 @@ static void writeRejectLogFile(const QString &name,
void AbstractMetaBuilder::dumpLog()
{
- writeRejectLogFile(m_logDirectory + "mjb_rejected_classes.log", m_rejectedClasses);
- writeRejectLogFile(m_logDirectory + "mjb_rejected_enums.log", m_rejectedEnums);
- writeRejectLogFile(m_logDirectory + "mjb_rejected_functions.log", m_rejectedFunctions);
- writeRejectLogFile(m_logDirectory + "mjb_rejected_fields.log", m_rejectedFields);
+ writeRejectLogFile(m_logDirectory + QLatin1String("mjb_rejected_classes.log"), m_rejectedClasses);
+ writeRejectLogFile(m_logDirectory + QLatin1String("mjb_rejected_enums.log"), m_rejectedEnums);
+ writeRejectLogFile(m_logDirectory + QLatin1String("mjb_rejected_functions.log"), m_rejectedFunctions);
+ writeRejectLogFile(m_logDirectory + QLatin1String("mjb_rejected_fields.log"), m_rejectedFields);
}
AbstractMetaClassList AbstractMetaBuilder::classesTopologicalSorted(const AbstractMetaClass* cppClass) const
@@ -2957,8 +2968,8 @@ AbstractMetaClassList AbstractMetaBuilder::classesTopologicalSorted(const Abstra
Graph graph(map.count());
// TODO choose a better name to these regexs
- QRegExp regex1("\\(.*\\)");
- QRegExp regex2("::.*");
+ QRegExp regex1(QLatin1String("\\(.*\\)"));
+ QRegExp regex2(QLatin1String("::.*"));
foreach (AbstractMetaClass* clazz, classList) {
if (clazz->enclosingClass() && map.contains(clazz->enclosingClass()->qualifiedCppName()))
graph.addEdge(map[clazz->enclosingClass()->qualifiedCppName()], map[clazz->qualifiedCppName()]);
@@ -2978,18 +2989,18 @@ AbstractMetaClassList AbstractMetaBuilder::classesTopologicalSorted(const Abstra
// check methods with default args
QString defaultExpression = arg->originalDefaultValueExpression();
if (!defaultExpression.isEmpty()) {
- if ((defaultExpression == "0") && (arg->type()->isValue()))
+ if (defaultExpression == QLatin1String("0") && arg->type()->isValue())
defaultExpression = arg->type()->name();
- defaultExpression.replace(regex1, "");
- defaultExpression.replace(regex2, "");
+ defaultExpression.remove(regex1);
+ defaultExpression.remove(regex2);
}
if (!defaultExpression.isEmpty()) {
- QString exprClassName = clazz->qualifiedCppName() + "::" + defaultExpression;
+ QString exprClassName = clazz->qualifiedCppName() + colonColon() + defaultExpression;
if (!map.contains(exprClassName)) {
bool found = false;
foreach(AbstractMetaClass* baseClass, bases) {
- exprClassName = baseClass->qualifiedCppName() + "::" + defaultExpression;
+ exprClassName = baseClass->qualifiedCppName() + colonColon() + defaultExpression;
if (map.contains(exprClassName)) {
found = true;
break;
diff --git a/ApiExtractor/abstractmetalang.cpp b/ApiExtractor/abstractmetalang.cpp
index 290fae2..2a59d69 100644
--- a/ApiExtractor/abstractmetalang.cpp
+++ b/ApiExtractor/abstractmetalang.cpp
@@ -86,27 +86,27 @@ QString AbstractMetaType::cppSignature() const
{
if (m_cachedCppSignature.isEmpty()) {
if (isConstant())
- m_cachedCppSignature += "const ";
+ m_cachedCppSignature += QLatin1String("const ");
m_cachedCppSignature += typeEntry()->qualifiedCppName();
if (hasInstantiationInCpp()) {
AbstractMetaTypeList types = instantiations();
- m_cachedCppSignature += "<";
+ m_cachedCppSignature += QLatin1Char('<');
for (int i = 0; i < types.count(); ++i) {
if (i > 0)
- m_cachedCppSignature += ", ";
+ m_cachedCppSignature += QLatin1String(", ");
m_cachedCppSignature += types[i]->cppSignature();
}
- m_cachedCppSignature += " >";
+ m_cachedCppSignature += QLatin1String(" >");
}
if (actualIndirections()) {
- m_cachedCppSignature += ' ';
+ m_cachedCppSignature += QLatin1Char(' ');
if (indirections())
- m_cachedCppSignature += QString(indirections(), '*');
+ m_cachedCppSignature += QString(indirections(), QLatin1Char('*'));
if (isReference())
- m_cachedCppSignature += '&';
+ m_cachedCppSignature += QLatin1Char('&');
}
}
return m_cachedCppSignature;
@@ -278,16 +278,20 @@ bool AbstractMetaFunction::needsSuppressUncheckedWarning() const
QString AbstractMetaFunction::marshalledName() const
{
- QString returned = "__qt_" + name();
+ QString returned = QLatin1String("__qt_") + name();
AbstractMetaArgumentList arguments = this->arguments();
foreach (const AbstractMetaArgument *arg, arguments) {
- returned += "_";
- if (arg->type()->isNativePointer())
- returned += "nativepointer";
- else if (arg->type()->isIntegerEnum() || arg->type()->isIntegerFlags())
- returned += "int";
- else
- returned += arg->type()->name().replace("[]", "_3").replace(".", "_");
+ returned += QLatin1Char('_');
+ if (arg->type()->isNativePointer()) {
+ returned += QLatin1String("nativepointer");
+ } else if (arg->type()->isIntegerEnum() || arg->type()->isIntegerFlags()) {
+ returned += QLatin1String("int");
+ } else {
+ QString a = arg->type()->name();
+ a.replace(QLatin1String("[]"), QLatin1String("_3"));
+ a.replace(QLatin1Char('.'), QLatin1Char('_'));
+ returned += a;
+ }
}
return returned;
}
@@ -400,15 +404,16 @@ QStringList AbstractMetaFunction::introspectionCompatibleSignatures(const QStrin
{
AbstractMetaArgumentList arguments = this->arguments();
if (arguments.size() == resolvedArguments.size()) {
- return (QStringList() << TypeDatabase::normalizedSignature((name() + "(" + resolvedArguments.join(",") + ")").toUtf8().constData()));
+ QString signature = name() + QLatin1Char('(') + resolvedArguments.join(QLatin1Char(',')) + QLatin1Char(')');
+ return QStringList(TypeDatabase::normalizedSignature(signature.toUtf8().constData()));
} else {
QStringList returned;
AbstractMetaArgument *argument = arguments.at(resolvedArguments.size());
- QStringList minimalTypeSignature = argument->type()->minimalSignature().split("::");
+ QStringList minimalTypeSignature = argument->type()->minimalSignature().split(QLatin1String("::"));
for (int i = 0; i < minimalTypeSignature.size(); ++i) {
returned += introspectionCompatibleSignatures(QStringList(resolvedArguments)
- << QStringList(minimalTypeSignature.mid(minimalTypeSignature.size() - i - 1)).join("::"));
+ << QStringList(minimalTypeSignature.mid(minimalTypeSignature.size() - i - 1)).join(QLatin1String("::")));
}
return returned;
@@ -420,22 +425,22 @@ QString AbstractMetaFunction::signature() const
if (m_cachedSignature.isEmpty()) {
m_cachedSignature = m_originalName;
- m_cachedSignature += '(';
+ m_cachedSignature += QLatin1Char('(');
for (int i = 0; i < m_arguments.count(); ++i) {
if (i > 0)
- m_cachedSignature += ", ";
+ m_cachedSignature += QLatin1String(", ");
AbstractMetaArgument *a = m_arguments.at(i);
m_cachedSignature += a->type()->cppSignature();
// We need to have the argument names in the qdoc files
- m_cachedSignature += ' ';
+ m_cachedSignature += QLatin1Char(' ');
m_cachedSignature += a->name();
}
- m_cachedSignature += ")";
+ m_cachedSignature += QLatin1Char(')');
if (isConstant())
- m_cachedSignature += " const";
+ m_cachedSignature += QLatin1String(" const");
}
return m_cachedSignature;
}
@@ -616,7 +621,7 @@ QString AbstractMetaFunction::argumentReplaced(int key) const
}
}
- return "";
+ return QString();
}
// FIXME If we remove a arg. in the method at the base class, it will not reflect here.
@@ -750,20 +755,20 @@ QString AbstractMetaFunction::minimalSignature() const
if (!m_cachedMinimalSignature.isEmpty())
return m_cachedMinimalSignature;
- QString minimalSignature = originalName() + "(";
+ QString minimalSignature = originalName() + QLatin1Char('(');
AbstractMetaArgumentList arguments = this->arguments();
for (int i = 0; i < arguments.count(); ++i) {
AbstractMetaType *t = arguments.at(i)->type();
if (i > 0)
- minimalSignature += ",";
+ minimalSignature += QLatin1Char(',');
minimalSignature += t->minimalSignature();
}
- minimalSignature += ")";
+ minimalSignature += QLatin1Char(')');
if (isConstant())
- minimalSignature += "const";
+ minimalSignature += QLatin1String("const");
minimalSignature = TypeDatabase::normalizedSignature(minimalSignature.toLocal8Bit().constData());
m_cachedMinimalSignature = minimalSignature;
@@ -805,7 +810,7 @@ QString AbstractMetaFunction::argumentName(int index, bool create, const Abstrac
bool AbstractMetaFunction::isCallOperator() const
{
- return m_name == "operator()";
+ return m_name == QLatin1String("operator()");
}
bool AbstractMetaFunction::hasInjectedCode() const
@@ -850,7 +855,7 @@ bool AbstractMetaFunction::hasSignatureModifications() const
bool AbstractMetaFunction::isConversionOperator(QString funcName)
{
- static QRegExp opRegEx("^operator(?:\\s+(?:const|volatile))?\\s+(\\w+\\s*)&?$");
+ static QRegExp opRegEx(QLatin1String("^operator(?:\\s+(?:const|volatile))?\\s+(\\w+\\s*)&?$"));
return opRegEx.indexIn(funcName) > -1;
}
@@ -859,17 +864,17 @@ bool AbstractMetaFunction::isOperatorOverload(QString funcName)
if (isConversionOperator(funcName))
return true;
- static QRegExp opRegEx("^operator([+\\-\\*/%=&\\|\\^\\<>!][=]?"
+ static QRegExp opRegEx(QLatin1String("^operator([+\\-\\*/%=&\\|\\^\\<>!][=]?"
"|\\+\\+|\\-\\-|&&|\\|\\||<<[=]?|>>[=]?|~"
"|\\[\\]|\\s+delete\\[?\\]?"
"|\\(\\)"
- "|\\s+new\\[?\\]?)$");
+ "|\\s+new\\[?\\]?)$"));
return opRegEx.indexIn(funcName) > -1;
}
bool AbstractMetaFunction::isCastOperator() const
{
- return originalName().startsWith("operator ");
+ return originalName().startsWith(QLatin1String("operator "));
}
bool AbstractMetaFunction::isArithmeticOperator() const
@@ -880,15 +885,15 @@ bool AbstractMetaFunction::isArithmeticOperator() const
QString name = originalName();
// It's a dereference operator!
- if (name == "operator*" && m_arguments.isEmpty())
+ if (name == QLatin1String("operator*") && m_arguments.isEmpty())
return false;
- return name == "operator+" || name == "operator+="
- || name == "operator-" || name == "operator-="
- || name == "operator*" || name == "operator*="
- || name == "operator/" || name == "operator/="
- || name == "operator%" || name == "operator%="
- || name == "operator++" || name == "operator--";
+ return name == QLatin1String("operator+") || name == QLatin1String("operator+=")
+ || name == QLatin1String("operator-") || name == QLatin1String("operator-=")
+ || name == QLatin1String("operator*") || name == QLatin1String("operator*=")
+ || name == QLatin1String("operator/") || name == QLatin1String("operator/=")
+ || name == QLatin1String("operator%") || name == QLatin1String("operator%=")
+ || name == QLatin1String("operator++") || name == QLatin1String("operator--");
}
bool AbstractMetaFunction::isBitwiseOperator() const
@@ -897,12 +902,12 @@ bool AbstractMetaFunction::isBitwiseOperator() const
return false;
QString name = originalName();
- return name == "operator<<" || name == "operator<<="
- || name == "operator>>" || name == "operator>>="
- || name == "operator&" || name == "operator&="
- || name == "operator|" || name == "operator|="
- || name == "operator^" || name == "operator^="
- || name == "operator~";
+ return name == QLatin1String("operator<<") || name == QLatin1String("operator<<=")
+ || name == QLatin1String("operator>>") || name == QLatin1String("operator>>=")
+ || name == QLatin1String("operator&") || name == QLatin1String("operator&=")
+ || name == QLatin1String("operator|") || name == QLatin1String("operator|=")
+ || name == QLatin1String("operator^") || name == QLatin1String("operator^=")
+ || name == QLatin1String("operator~");
}
bool AbstractMetaFunction::isComparisonOperator() const
@@ -911,9 +916,9 @@ bool AbstractMetaFunction::isComparisonOperator() const
return false;
QString name = originalName();
- return name == "operator<" || name == "operator<="
- || name == "operator>" || name == "operator>="
- || name == "operator==" || name == "operator!=";
+ return name == QLatin1String("operator<") || name == QLatin1String("operator<=")
+ || name == QLatin1String("operator>") || name == QLatin1String("operator>=")
+ || name == QLatin1String("operator==") || name == QLatin1String("operator!=");
}
bool AbstractMetaFunction::isLogicalOperator() const
@@ -922,9 +927,9 @@ bool AbstractMetaFunction::isLogicalOperator() const
return false;
QString name = originalName();
- return name == "operator!"
- || name == "operator&&"
- || name == "operator||";
+ return name == QLatin1String("operator!")
+ || name == QLatin1String("operator&&")
+ || name == QLatin1String("operator||");
}
bool AbstractMetaFunction::isSubscriptOperator() const
@@ -932,7 +937,7 @@ bool AbstractMetaFunction::isSubscriptOperator() const
if (!isOperatorOverload())
return false;
- return originalName() == "operator[]";
+ return originalName() == QLatin1String("operator[]");
}
bool AbstractMetaFunction::isAssignmentOperator() const
@@ -940,7 +945,7 @@ bool AbstractMetaFunction::isAssignmentOperator() const
if (!isOperatorOverload())
return false;
- return originalName() == "operator=";
+ return originalName() == QLatin1String("operator=");
}
bool AbstractMetaFunction::isOtherOperator() const
@@ -980,11 +985,11 @@ bool AbstractMetaFunction::isInplaceOperator() const
return false;
QString name = originalName();
- return name == "operator+=" || name == "operator&="
- || name == "operator-=" || name == "operator|="
- || name == "operator*=" || name == "operator^="
- || name == "operator/=" || name == "operator<<="
- || name == "operator%=" || name == "operator>>=";
+ return name == QLatin1String("operator+=") || name == QLatin1String("operator&=")
+ || name == QLatin1String("operator-=") || name == QLatin1String("operator|=")
+ || name == QLatin1String("operator*=") || name == QLatin1String("operator^=")
+ || name == QLatin1String("operator/=") || name == QLatin1String("operator<<=")
+ || name == QLatin1String("operator%=") || name == QLatin1String("operator>>=");
}
bool AbstractMetaFunction::isVirtual() const
@@ -1026,33 +1031,33 @@ QString AbstractMetaFunction::targetLangSignature(bool minimal) const
if (!minimal) {
// Return type
if (type())
- s += type()->name() + " ";
+ s += type()->name() + QLatin1Char(' ');
else
- s += "void ";
+ s += QLatin1String("void ");
}
s += modifiedName();
- s += "(";
+ s += QLatin1Char('(');
int j = 0;
for (int i = 0; i < m_arguments.size(); ++i) {
if (argumentRemoved(i + 1))
continue;
if (j) {
- s += ",";
+ s += QLatin1Char(',');
if (!minimal)
s += QLatin1Char(' ');
}
s += m_arguments.at(i)->type()->name();
if (!minimal) {
- s += " ";
+ s += QLatin1Char(' ');
s += m_arguments.at(i)->name();
}
++j;
}
- s += ")";
+ s += QLatin1Char(')');
return s;
}
@@ -1435,7 +1440,7 @@ bool AbstractMetaClass::hasFieldAccessors() const
bool AbstractMetaClass::hasDefaultToStringFunction() const
{
- foreach (AbstractMetaFunction *f, queryFunctionsByName("toString")) {
+ foreach (AbstractMetaFunction *f, queryFunctionsByName(QLatin1String("toString"))) {
if (!f->actualMinimumArgumentCount())
return true;
}
@@ -1444,7 +1449,7 @@ bool AbstractMetaClass::hasDefaultToStringFunction() const
void AbstractMetaClass::addFunction(AbstractMetaFunction *function)
{
- Q_ASSERT(!function->signature().startsWith("("));
+ Q_ASSERT(!function->signature().startsWith(QLatin1Char('(')));
function->setOwnerClass(this);
if (!function->isDestructor())
@@ -1474,7 +1479,7 @@ bool AbstractMetaClass::hasSignal(const AbstractMetaFunction *other) const
QString AbstractMetaClass::name() const
{
- return QString(m_typeEntry->targetLangName()).split("::").last();
+ return QString(m_typeEntry->targetLangName()).split(QLatin1String("::")).last();
}
void AbstractMetaClass::setBaseClass(AbstractMetaClass *baseClass)
@@ -1694,7 +1699,7 @@ const AbstractMetaFunction *AbstractMetaField::setter() const
{
if (!m_setter) {
m_setter = createXetter(this,
- "set" + upCaseFirst(name()),
+ QLatin1String("set") + upCaseFirst(name()),
AbstractMetaAttributes::SetterFunction);
AbstractMetaArgumentList arguments;
AbstractMetaArgument *argument = new AbstractMetaArgument;
@@ -2153,8 +2158,8 @@ void AbstractMetaClass::fixFunctions()
}
if (f->visibility() != sf->visibility()) {
- QString warn = QString("visibility of function '%1' modified in class '%2'")
- .arg(f->name()).arg(name());
+ QString warn = QStringLiteral("visibility of function '%1' modified in class '%2'")
+ .arg(f->name(), name());
qCWarning(lcShiboken).noquote().nospace() << warn;
#if 0
// If new visibility is private, we can't
@@ -2299,23 +2304,23 @@ QString AbstractMetaType::minimalSignature() const
{
QString minimalSignature;
if (isConstant())
- minimalSignature += "const ";
+ minimalSignature += QLatin1String("const ");
minimalSignature += typeEntry()->qualifiedCppName();
if (hasInstantiations()) {
AbstractMetaTypeList instantiations = this->instantiations();
- minimalSignature += "< ";
+ minimalSignature += QLatin1String("< ");
for (int i = 0; i < instantiations.size(); ++i) {
if (i > 0)
- minimalSignature += ",";
+ minimalSignature += QLatin1Char(',');
minimalSignature += instantiations[i]->minimalSignature();
}
- minimalSignature += " >";
+ minimalSignature += QLatin1String(" >");
}
for (int j = 0; j < indirections(); ++j)
- minimalSignature += "*";
+ minimalSignature += QLatin1Char('*');
if (isReference())
- minimalSignature += "&";
+ minimalSignature += QLatin1Char('&');
return minimalSignature;
}
@@ -2336,7 +2341,7 @@ AbstractMetaEnum *AbstractMetaClassList::findEnum(const EnumTypeEntry *entry) co
Q_ASSERT(entry->isEnum());
QString qualifiedName = entry->qualifiedCppName();
- int pos = qualifiedName.lastIndexOf("::");
+ int pos = qualifiedName.lastIndexOf(QLatin1String("::"));
QString enumName;
QString className;
diff --git a/ApiExtractor/abstractmetalang.h b/ApiExtractor/abstractmetalang.h
index 763b457..656d4e2 100644
--- a/ApiExtractor/abstractmetalang.h
+++ b/ApiExtractor/abstractmetalang.h
@@ -326,7 +326,7 @@ public:
QString name() const
{
if (m_name.isNull())
- m_name = m_typeEntry->targetLangName().split("::").last();
+ m_name = m_typeEntry->targetLangName().split(QLatin1String("::")).constLast();
return m_name;
}
QString fullName() const
@@ -708,8 +708,8 @@ public:
QString toString() const
{
- return type()->name() + " " + AbstractMetaVariable::name() +
- (m_expression.isEmpty() ? "" : " = " + m_expression);
+ return type()->name() + QLatin1Char(' ') + AbstractMetaVariable::name() +
+ (m_expression.isEmpty() ? QString() : QLatin1String(" = ") + m_expression);
}
int argumentIndex() const
@@ -1299,7 +1299,7 @@ public:
QString fullName() const
{
- return package() + "." + qualifier() + "." + name();
+ return package() + QLatin1Char('.') + qualifier() + QLatin1Char('.') + name();
}
// Has the enum been declared inside a Q_ENUMS() macro in its enclosing class?
@@ -1559,7 +1559,7 @@ public:
QString fullName() const
{
- return package() + "." + name();
+ return package() + QLatin1Char('.') + name();
}
/**
@@ -1627,7 +1627,7 @@ public:
bool isQtNamespace() const
{
- return isNamespace() && name() == "Qt";
+ return isNamespace() && name() == QLatin1String("Qt");
}
QString qualifiedCppName() const
diff --git a/ApiExtractor/apiextractor.cpp b/ApiExtractor/apiextractor.cpp
index a29a38d..e4a3e31 100644
--- a/ApiExtractor/apiextractor.cpp
+++ b/ApiExtractor/apiextractor.cpp
@@ -44,7 +44,7 @@ ApiExtractor::ApiExtractor() : m_builder(0)
if (!qrcInitialized)
Q_INIT_RESOURCE(generator);
// Environment TYPESYSTEMPATH
- QString envTypesystemPaths = getenv("TYPESYSTEMPATH");
+ QString envTypesystemPaths = QFile::decodeName(getenv("TYPESYSTEMPATH"));
if (!envTypesystemPaths.isEmpty())
TypeDatabase::instance()->addTypesystemPath(envTypesystemPaths);
}
@@ -107,7 +107,7 @@ void ApiExtractor::setSilent ( bool value )
void ApiExtractor::setApiVersion(double version)
{
- TypeDatabase::instance()->setApiVersion("*", QByteArray::number(version));
+ TypeDatabase::instance()->setApiVersion(QLatin1String("*"), QByteArray::number(version));
}
void ApiExtractor::setApiVersion(const QString& package, const QByteArray& version)
@@ -117,8 +117,8 @@ void ApiExtractor::setApiVersion(const QString& package, const QByteArray& versi
void ApiExtractor::setDropTypeEntries(QString dropEntries)
{
- dropEntries.remove(' ');
- QStringList entries = dropEntries.split(';');
+ dropEntries.remove(QLatin1Char(' '));
+ QStringList entries = dropEntries.split(QLatin1Char(';'));
TypeDatabase::instance()->setDropTypeEntries(entries);
}
@@ -269,7 +269,8 @@ static bool preprocess(const QString& sourceFile,
const char *ppconfig = ":/trolltech/generator/pp-qt-configuration";
- QFile file(ppconfig);
+ const QString fileName = QLatin1String(ppconfig);
+ QFile file(fileName);
if (!file.open(QFile::ReadOnly)) {
std::cerr << "Preprocessor configuration file not found " << ppconfig << std::endl;
return false;
diff --git a/ApiExtractor/asttoxml.cpp b/ApiExtractor/asttoxml.cpp
index 1ad0eb0..1dc2526 100644
--- a/ApiExtractor/asttoxml.cpp
+++ b/ApiExtractor/asttoxml.cpp
@@ -61,7 +61,7 @@ void astToXML(QString name)
QXmlStreamWriter s(&outputFile);
s.setAutoFormatting(true);
- s.writeStartElement("code");
+ s.writeStartElement(QLatin1String("code"));
QHash<QString, NamespaceModelItem> namespaceMap = dom->namespaceMap();
foreach (NamespaceModelItem item, namespaceMap.values())
@@ -77,8 +77,8 @@ void astToXML(QString name)
void writeOutNamespace(QXmlStreamWriter &s, NamespaceModelItem &item)
{
- s.writeStartElement("namespace");
- s.writeAttribute("name", item->name());
+ s.writeStartElement(QLatin1String("namespace"));
+ s.writeAttribute(QLatin1String("name"), item->name());
QHash<QString, NamespaceModelItem> namespaceMap = item->namespaceMap();
foreach (NamespaceModelItem item, namespaceMap.values())
@@ -97,15 +97,15 @@ void writeOutNamespace(QXmlStreamWriter &s, NamespaceModelItem &item)
void writeOutEnum(QXmlStreamWriter &s, EnumModelItem &item)
{
- QString qualifiedName = item->qualifiedName().join("::");
- s.writeStartElement("enum");
- s.writeAttribute("name", qualifiedName);
+ QString qualifiedName = item->qualifiedName().join(QLatin1String("::"));
+ s.writeStartElement(QLatin1String("enum"));
+ s.writeAttribute(QLatin1String("name"), qualifiedName);
EnumeratorList enumList = item->enumerators();
for (int i = 0; i < enumList.size() ; i++) {
- s.writeStartElement("enumerator");
+ s.writeStartElement(QLatin1String("enumerator"));
if (!enumList[i]->value().isEmpty())
- s.writeAttribute("value", enumList[i]->value());
+ s.writeAttribute(QLatin1String("value"), enumList[i]->value());
s.writeCharacters(enumList[i]->name());
s.writeEndElement();
@@ -115,14 +115,14 @@ void writeOutEnum(QXmlStreamWriter &s, EnumModelItem &item)
void writeOutFunction(QXmlStreamWriter &s, FunctionModelItem &item)
{
- QString qualifiedName = item->qualifiedName().join("::");
- s.writeStartElement("function");
- s.writeAttribute("name", qualifiedName);
+ QString qualifiedName = item->qualifiedName().join(QLatin1String("::"));
+ s.writeStartElement(QLatin1String("function"));
+ s.writeAttribute(QLatin1String("name"), qualifiedName);
ArgumentList arguments = item->arguments();
for (int i = 0; i < arguments.size() ; i++) {
- s.writeStartElement("argument");
- s.writeAttribute("type", arguments[i]->type().qualifiedName().join("::"));
+ s.writeStartElement(QLatin1String("argument"));
+ s.writeAttribute(QLatin1String("type"), arguments[i]->type().qualifiedName().join(QLatin1String("::")));
s.writeEndElement();
}
s.writeEndElement();
@@ -130,9 +130,9 @@ void writeOutFunction(QXmlStreamWriter &s, FunctionModelItem &item)
void writeOutClass(QXmlStreamWriter &s, ClassModelItem &item)
{
- QString qualifiedName = item->qualifiedName().join("::");
- s.writeStartElement("class");
- s.writeAttribute("name", qualifiedName);
+ QString qualifiedName = item->qualifiedName().join(QLatin1String("::"));
+ s.writeStartElement(QLatin1String("class"));
+ s.writeAttribute(QLatin1String("name"), qualifiedName);
QHash<QString, EnumModelItem> enumMap = item->enumMap();
foreach (EnumModelItem item, enumMap.values())
diff --git a/ApiExtractor/include.cpp b/ApiExtractor/include.cpp
index a925006..6aac7e1 100644
--- a/ApiExtractor/include.cpp
+++ b/ApiExtractor/include.cpp
@@ -28,11 +28,11 @@
QString Include::toString() const
{
if (m_type == IncludePath)
- return "#include <" + m_name + '>';
+ return QLatin1String("#include <") + m_name + QLatin1Char('>');
else if (m_type == LocalPath)
- return "#include \"" + m_name + "\"";
+ return QLatin1String("#include \"") + m_name + QLatin1Char('"');
else
- return "import " + m_name + ";";
+ return QLatin1String("import ") + m_name + QLatin1Char(';');
}
uint qHash(const Include& inc)
diff --git a/ApiExtractor/parser/binder.cpp b/ApiExtractor/parser/binder.cpp
index d1bb3e4..ecfde91 100644
--- a/ApiExtractor/parser/binder.cpp
+++ b/ApiExtractor/parser/binder.cpp
@@ -45,13 +45,13 @@ Binder::Binder(CodeModel *__model, LocationManager &__location, Control *__contr
name_cc(this),
decl_cc(this)
{
- _M_qualified_types["char"] = QString();
- _M_qualified_types["double"] = QString();
- _M_qualified_types["float"] = QString();
- _M_qualified_types["int"] = QString();
- _M_qualified_types["long"] = QString();
- _M_qualified_types["short"] = QString();
- _M_qualified_types["void"] = QString();
+ _M_qualified_types.insert(QLatin1String("char"), QString());
+ _M_qualified_types.insert(QLatin1String("double"), QString());
+ _M_qualified_types.insert(QLatin1String("float"), QString());
+ _M_qualified_types.insert(QLatin1String("int"), QString());
+ _M_qualified_types.insert(QLatin1String("long"), QString());
+ _M_qualified_types.insert(QLatin1String("short"), QString());
+ _M_qualified_types.insert(QLatin1String("void"), QString());
}
Binder::~Binder()
@@ -527,7 +527,7 @@ void Binder::visitTypedef(TypedefAST *node)
typeAlias->setName(alias_name);
typeAlias->setType(qualifyType(typeInfo, currentScope()->qualifiedName()));
typeAlias->setScope(typedefScope->qualifiedName());
- _M_qualified_types[typeAlias->qualifiedName().join(".")] = QString();
+ _M_qualified_types[typeAlias->qualifiedName().join(QLatin1Char('.'))] = QString();
currentScope()->addTypeAlias(typeAlias);
} while (it != end);
}
@@ -580,7 +580,7 @@ void Binder::visitForwardDeclarationSpecifier(ForwardDeclarationSpecifierAST *no
return;
ScopeModelItem scope = currentScope();
- _M_qualified_types[(scope->qualifiedName() + name_cc.qualifiedName()).join(".")] = QString();
+ _M_qualified_types[(scope->qualifiedName() + name_cc.qualifiedName()).join(QLatin1Char('.'))] = QString();
}
void Binder::visitClassSpecifier(ClassSpecifierAST *node)
@@ -604,8 +604,8 @@ void Binder::visitClassSpecifier(ClassSpecifierAST *node)
QStringList baseClasses = class_cc.baseClasses();
TypeInfo info;
for (int i = 0; i < baseClasses.size(); ++i) {
- info.setQualifiedName(baseClasses.at(i).split("::"));
- baseClasses[i] = qualifyType(info, scope->qualifiedName()).qualifiedName().join("::");
+ info.setQualifiedName(baseClasses.at(i).split(QLatin1String("::")));
+ baseClasses[i] = qualifyType(info, scope->qualifiedName()).qualifiedName().join(QLatin1String("::"));
}
_M_current_class->setBaseClasses(baseClasses);
@@ -614,15 +614,15 @@ void Binder::visitClassSpecifier(ClassSpecifierAST *node)
if (!_M_current_template_parameters.isEmpty()) {
QString name = _M_current_class->name();
- name += "<";
+ name += QLatin1Char('<');
for (int i = 0; i < _M_current_template_parameters.size(); ++i) {
if (i > 0)
- name += ",";
+ name += QLatin1Char(',');
name += _M_current_template_parameters.at(i)->name();
}
- name += ">";
+ name += QLatin1Char('>');
_M_current_class->setName(name);
}
@@ -630,7 +630,7 @@ void Binder::visitClassSpecifier(ClassSpecifierAST *node)
CodeModel::FunctionType oldFunctionType = changeCurrentFunctionType(CodeModel::Normal);
_M_current_class->setScope(scope->qualifiedName());
- _M_qualified_types[_M_current_class->qualifiedName().join(".")] = QString();
+ _M_qualified_types[_M_current_class->qualifiedName().join(QLatin1Char('.'))] = QString();
scope->addClass(_M_current_class);
@@ -666,7 +666,7 @@ void Binder::visitEnumSpecifier(EnumSpecifierAST *node)
bool isAnonymous = name.isEmpty();
if (isAnonymous) {
// anonymous enum
- QString key = _M_context.join("::");
+ QString key = _M_context.join(QLatin1String("::"));
int current = ++_M_anonymous_enums[key];
name += QLatin1String("enum_");
name += QString::number(current);
@@ -679,7 +679,7 @@ void Binder::visitEnumSpecifier(EnumSpecifierAST *node)
_M_current_enum->setAnonymous(isAnonymous);
_M_current_enum->setScope(enumScope->qualifiedName());
- _M_qualified_types[_M_current_enum->qualifiedName().join(".")] = QString();
+ _M_qualified_types[_M_current_enum->qualifiedName().join(QLatin1Char('.'))] = QString();
enumScope->addEnum(_M_current_enum);
@@ -690,10 +690,10 @@ void Binder::visitEnumSpecifier(EnumSpecifierAST *node)
static QString strip_preprocessor_lines(const QString &name)
{
- QStringList lst = name.split("\n");
+ QStringList lst = name.split(QLatin1Char('\n'));
QString s;
for (int i = 0; i < lst.size(); ++i) {
- if (!lst.at(i).startsWith('#'))
+ if (!lst.at(i).startsWith(QLatin1Char('#')))
s += lst.at(i);
}
return s.trimmed();
@@ -709,9 +709,11 @@ void Binder::visitEnumerator(EnumeratorAST *node)
if (ExpressionAST *expr = node->expression) {
const Token &start_token = _M_token_stream->token((int) expr->start_token);
const Token &end_token = _M_token_stream->token((int) expr->end_token);
-
- e->setValue(strip_preprocessor_lines(QString::fromUtf8(&start_token.text[start_token.position],
- (int)(end_token.position - start_token.position)).trimmed()).remove(' '));
+ const QString token = QString::fromUtf8(&start_token.text[start_token.position],
+ (int)(end_token.position - start_token.position));
+ QString lines = strip_preprocessor_lines(token.trimmed());
+ lines.remove(QLatin1Char(' '));
+ e->setValue(lines);
}
_M_current_enum->addEnumerator(e);
@@ -727,7 +729,7 @@ void Binder::visitQEnums(QEnumsAST *node)
const Token &start = _M_token_stream->token((int) node->start_token);
const Token &end = _M_token_stream->token((int) node->end_token);
QStringList enum_list = QString::fromLatin1(start.text + start.position,
- end.position - start.position).split(' ');
+ end.position - start.position).split(QLatin1Char(' '));
ScopeModelItem scope = currentScope();
for (int i = 0; i < enum_list.size(); ++i)
@@ -818,12 +820,12 @@ TypeInfo Binder::qualifyType(const TypeInfo &type, const QStringList &context) c
if (!context.size()) {
// ### We can assume that this means global namespace for now...
return type;
- } else if (_M_qualified_types.contains(type.qualifiedName().join("."))) {
+ } else if (_M_qualified_types.contains(type.qualifiedName().join(QLatin1Char('.')))) {
return type;
} else {
QStringList expanded = context;
expanded << type.qualifiedName();
- if (_M_qualified_types.contains(expanded.join("."))) {
+ if (_M_qualified_types.contains(expanded.join(QLatin1Char('.')))) {
TypeInfo modified_type = type;
modified_type.setQualifiedName(expanded);
return modified_type;
diff --git a/ApiExtractor/parser/codemodel.cpp b/ApiExtractor/parser/codemodel.cpp
index 7e3468a..346bc11 100644
--- a/ApiExtractor/parser/codemodel.cpp
+++ b/ApiExtractor/parser/codemodel.cpp
@@ -152,7 +152,7 @@ QString TypeInfo::toString() const
{
QString tmp;
- tmp += m_qualifiedName.join("::");
+ tmp += m_qualifiedName.join(QLatin1String("::"));
if (isConstant())
tmp += QLatin1String(" const");
@@ -173,13 +173,13 @@ QString TypeInfo::toString() const
tmp += m_arguments.at(i).toString();
}
- tmp += QLatin1String(")");
+ tmp += QLatin1Char(')');
}
foreach(QString elt, arrayElements()) {
- tmp += QLatin1String("[");
+ tmp += QLatin1Char('[');
tmp += elt;
- tmp += QLatin1String("]");
+ tmp += QLatin1Char(']');
}
return tmp;
@@ -415,7 +415,7 @@ EnumList _ScopeModelItem::enums() const
void _ScopeModelItem::addClass(ClassModelItem item)
{
QString name = item->name();
- int idx = name.indexOf("<");
+ int idx = name.indexOf(QLatin1Char('<'));
if (idx > 0)
_M_classes.insert(name.left(idx), item);
_M_classes.insert(name, item);
diff --git a/ApiExtractor/parser/declarator_compiler.cpp b/ApiExtractor/parser/declarator_compiler.cpp
index 2beef6d..acbf058 100644
--- a/ApiExtractor/parser/declarator_compiler.cpp
+++ b/ApiExtractor/parser/declarator_compiler.cpp
@@ -129,11 +129,11 @@ void DeclaratorCompiler::visitParameterDeclaration(ParameterDeclarationAST *node
p.defaultValueExpression = QString();
QString source = QString::fromUtf8(&start.text[start.position], length).trimmed();
- QStringList list = source.split("\n");
+ QStringList list = source.split(QLatin1Char('\n'));
for (int i = 0; i < list.size(); ++i) {
- if (!list.at(i).startsWith("#"))
+ if (!list.at(i).startsWith(QLatin1Char('#')))
p.defaultValueExpression += list.at(i).trimmed();
}
diff --git a/ApiExtractor/parser/dumptree.cpp b/ApiExtractor/parser/dumptree.cpp
index d65b232..2e393c9 100644
--- a/ApiExtractor/parser/dumptree.cpp
+++ b/ApiExtractor/parser/dumptree.cpp
@@ -113,8 +113,9 @@ void DumpTree::visit(AST *node)
{
static int indent = 0;
+
if (node)
- qDebug() << QString(indent * 2, ' ').toLatin1().constData() << names[node->kind]
+ qDebug() << QByteArray(indent * 2, ' ').constData() << names[node->kind]
<< '[' << node->start_token << ", " << node->end_token << ']';
++indent;
diff --git a/ApiExtractor/parser/lexer.cpp b/ApiExtractor/parser/lexer.cpp
index 412b2e4..5b555fc 100644
--- a/ApiExtractor/parser/lexer.cpp
+++ b/ApiExtractor/parser/lexer.cpp
@@ -75,7 +75,7 @@ void LocationManager::extract_line(int offset, int *line, QString *filename) con
Q_ASSERT(*cursor == '"');
++cursor;
- *filename = buffer;
+ *filename = QLatin1String(buffer);
*line = l;
// printf("filename: %s line: %d\n", buffer, line);
}
@@ -224,7 +224,7 @@ void Lexer::scan_preprocessor()
++cursor;
if (*cursor != '\n')
- reportError("expected newline");
+ reportError(QLatin1String("expected newline"));
}
void Lexer::scan_char_constant()
@@ -234,7 +234,7 @@ void Lexer::scan_char_constant()
++cursor;
while (*cursor && *cursor != '\'') {
if (*cursor == '\n')
- reportError("did not expect newline");
+ reportError(QLatin1String("did not expect newline"));
if (*cursor == '\\')
++cursor;
@@ -242,7 +242,7 @@ void Lexer::scan_char_constant()
}
if (*cursor != '\'')
- reportError("expected \'");
+ reportError(QLatin1String("expected \'"));
++cursor;
@@ -259,7 +259,7 @@ void Lexer::scan_string_constant()
++cursor;
while (*cursor && *cursor != '"') {
if (*cursor == '\n')
- reportError("did not expect newline");
+ reportError(QLatin1String("did not expect newline"));
if (*cursor == '\\')
++cursor;
@@ -267,7 +267,7 @@ void Lexer::scan_string_constant()
}
if (*cursor != '"')
- reportError("expected \"");
+ reportError(QLatin1String("expected \""));
++cursor;
@@ -687,7 +687,7 @@ void Lexer::scan_EOF()
void Lexer::scan_invalid_input()
{
- QString errmsg("invalid input: %1");
+ QString errmsg(QLatin1String("invalid input: %1"));
reportError(errmsg);
++cursor;
}
diff --git a/ApiExtractor/parser/name_compiler.cpp b/ApiExtractor/parser/name_compiler.cpp
index 52e783a..90a0d15 100644
--- a/ApiExtractor/parser/name_compiler.cpp
+++ b/ApiExtractor/parser/name_compiler.cpp
@@ -102,7 +102,7 @@ void NameCompiler::visitTemplateArgument(TemplateArgumentAST *node)
decl_cc.run(node->type_id->declarator);
if (type_cc.isConstant())
- _M_name.last() += "const ";
+ _M_name.last() += QLatin1String("const ");
QStringList q = type_cc.qualifiedName();
@@ -120,14 +120,14 @@ void NameCompiler::visitTemplateArgument(TemplateArgumentAST *node)
}
}
- _M_name.last() += q.join("::");
+ _M_name.last() += q.join(QLatin1String("::"));
if (decl_cc.isReference())
- _M_name.last() += "&";
+ _M_name.last() += QLatin1Char('&');
if (decl_cc.indirection())
- _M_name.last() += QString(decl_cc.indirection(), '*');
+ _M_name.last() += QString(decl_cc.indirection(), QLatin1Char('*'));
- _M_name.last() += QLatin1String(",");
+ _M_name.last() += QLatin1Char(',');
}
}
diff --git a/ApiExtractor/parser/name_compiler.h b/ApiExtractor/parser/name_compiler.h
index 1acd0b4..8b9ed30 100644
--- a/ApiExtractor/parser/name_compiler.h
+++ b/ApiExtractor/parser/name_compiler.h
@@ -45,7 +45,7 @@ public:
}
QString name() const {
- return _M_name.join("::");
+ return _M_name.join(QLatin1String("::"));
}
QStringList qualifiedName() const {
return _M_name;
diff --git a/ApiExtractor/parser/parser.cpp b/ApiExtractor/parser/parser.cpp
index 7d8bd3f..c0fa22d 100644
--- a/ApiExtractor/parser/parser.cpp
+++ b/ApiExtractor/parser/parser.cpp
@@ -143,12 +143,12 @@ void Parser::tokenRequiredError(int token)
{
QString err;
- err += "expected token ";
- err += "``";
- err += token_name(token);
- err += "'' found ``";
- err += token_name(token_stream.lookAhead());
- err += "''";
+ err += QLatin1String("expected token ");
+ err += QLatin1String("``");
+ err += QLatin1String(token_name(token));
+ err += QLatin1String("'' found ``");
+ err += QLatin1String(token_name(token_stream.lookAhead()));
+ err += QLatin1String("''");
reportError(err);
}
@@ -157,10 +157,10 @@ void Parser::syntaxError()
{
QString err;
- err += "unexpected token ";
- err += "``";
- err += token_name(token_stream.lookAhead());
- err += "''";
+ err += QLatin1String("unexpected token ");
+ err += QLatin1String("``");
+ err += QLatin1String(token_name(token_stream.lookAhead()));
+ err += QLatin1String("''");
reportError(err);
}
@@ -489,7 +489,7 @@ bool Parser::parseLinkageSpecification(DeclarationAST *&node)
if (token_stream.lookAhead() == '{')
parseLinkageBody(ast->linkage_body);
else if (!parseDeclaration(ast->declaration))
- reportError(("Declaration syntax error"));
+ reportError(QLatin1String("Declaration syntax error"));
UPDATE_POS(ast, start, token_stream.cursor());
node = ast;
@@ -528,7 +528,7 @@ bool Parser::parseLinkageBody(LinkageBodyAST *&node)
}
if (token_stream.lookAhead() != '}')
- reportError(("} expected"));
+ reportError(QLatin1String("} expected"));
else
token_stream.nextToken();
@@ -566,11 +566,11 @@ bool Parser::parseNamespace(DeclarationAST *&node)
node = ast;
return true;
} else {
- reportError(("namespace expected"));
+ reportError(QLatin1String("namespace expected"));
return false;
}
} else if (token_stream.lookAhead() != '{') {
- reportError(("{ expected"));
+ reportError(QLatin1String("{ expected"));
return false;
}
@@ -619,7 +619,7 @@ bool Parser::parseUsingDirective(DeclarationAST *&node)
NameAST *name = 0;
if (!parseName(name)) {
- reportError(("Namespace name expected"));
+ reportError(QLatin1String("Namespace name expected"));
return false;
}
@@ -703,7 +703,7 @@ bool Parser::parseTypedef(DeclarationAST *&node)
TypeSpecifierAST *spec = 0;
if (!parseTypeSpecifierOrClassSpec(spec)) {
- reportError(("Need a type specifier to declare"));
+ reportError(QLatin1String("Need a type specifier to declare"));
return false;
}
@@ -771,7 +771,7 @@ bool Parser::parseTemplateDeclaration(DeclarationAST *&node)
DeclarationAST *declaration = 0;
if (!parseDeclaration(declaration))
- reportError(("expected a declaration"));
+ reportError(QLatin1String("expected a declaration"));
TemplateDeclarationAST *ast = CreateNode<TemplateDeclarationAST>(_M_pool);
ast->exported = exported;
@@ -1071,7 +1071,7 @@ bool Parser::parseDeclarator(DeclaratorAST *&node)
token_stream.nextToken();
if (!parseConstantExpression(ast->bit_expression))
- reportError(("Constant expression expected"));
+ reportError(QLatin1String("Constant expression expected"));
goto update_pos;
}
@@ -1138,7 +1138,7 @@ bool Parser::parseDeclarator(DeclaratorAST *&node)
if (skipParen) {
if (token_stream.lookAhead() != ')')
- reportError(("')' expected"));
+ reportError(QLatin1String("')' expected"));
else
token_stream.nextToken();
}
@@ -1182,7 +1182,7 @@ bool Parser::parseAbstractDeclarator(DeclaratorAST *&node)
token_stream.nextToken();
if (!parseConstantExpression(ast->bit_expression)) {
ast->bit_expression = 0;
- reportError(("Constant expression expected"));
+ reportError(QLatin1String("Constant expression expected"));
}
goto update_pos;
}
@@ -1567,7 +1567,7 @@ bool Parser::parseParameterDeclaration(ParameterDeclarationAST *&node)
if (token_stream.lookAhead() == '=') {
token_stream.nextToken();
if (!parseLogicalOrExpression(expr, true))
- reportError(("Expression expected"));
+ reportError(QLatin1String("Expression expected"));
}
ParameterDeclarationAST *ast = CreateNode<ParameterDeclarationAST>(_M_pool);
@@ -1591,7 +1591,7 @@ bool Parser::parse_Attribute__()
parseExpression(expr);
if (token_stream.lookAhead() != ')') {
- reportError(("')' expected"));
+ reportError(QLatin1String("')' expected"));
return false;
} else {
token_stream.nextToken();
@@ -1829,7 +1829,7 @@ bool Parser::parseCtorInitializer(CtorInitializerAST *&node)
ast->colon = start;
if (!parseMemInitializerList(ast->member_initializers))
- reportError(("Member initializers expected"));
+ reportError(QLatin1String("Member initializers expected"));
UPDATE_POS(ast, start, token_stream.cursor());
node = ast;
@@ -1915,7 +1915,7 @@ bool Parser::parseEnumerator(EnumeratorAST *&node)
token_stream.nextToken();
if (!parseConstantExpression(ast->expression))
- reportError(("Constant expression expected"));
+ reportError(QLatin1String("Constant expression expected"));
}
UPDATE_POS(ast, start, token_stream.cursor());
@@ -1968,7 +1968,7 @@ bool Parser::parseBaseClause(BaseClauseAST *&node)
token_stream.nextToken();
if (!parseBaseSpecifier(baseSpec)) {
- reportError(("Base class specifier expected"));
+ reportError(QLatin1String("Base class specifier expected"));
break;
}
ast->base_specifiers = snoc(ast->base_specifiers, baseSpec, _M_pool);
@@ -1994,7 +1994,7 @@ bool Parser::parseInitializer(InitializerAST *&node)
token_stream.nextToken();
if (!parseInitializerClause(ast->initializer_clause))
- reportError(("Initializer clause expected"));
+ reportError(QLatin1String("Initializer clause expected"));
} else if (tk == '(') {
token_stream.nextToken();
@@ -2035,7 +2035,7 @@ bool Parser::parseMemInitializer(MemInitializerAST *&node)
NameAST *initId = 0;
if (!parseName(initId, true)) {
- reportError(("Identifier expected"));
+ reportError(QLatin1String("Identifier expected"));
return false;
}
@@ -2067,7 +2067,7 @@ bool Parser::parseTypeIdList(const ListNode<TypeIdAST*> *&node)
if (parseTypeId(typeId)) {
node = snoc(node, typeId, _M_pool);
} else {
- reportError(("Type id expected"));
+ reportError(QLatin1String("Type id expected"));
break;
}
}
@@ -2106,7 +2106,7 @@ bool Parser::parseBaseSpecifier(BaseSpecifierAST *&node)
}
if (!parseName(ast->name, true))
- reportError(("Class name expected"));
+ reportError(QLatin1String("Class name expected"));
UPDATE_POS(ast, start, token_stream.cursor());
node = ast;
@@ -2127,10 +2127,10 @@ bool Parser::parseInitializerClause(InitializerClauseAST *&node)
if (skip('{', '}'))
token_stream.nextToken();
else
- reportError(("} missing"));
+ reportError(QLatin1String("} missing"));
} else {
if (!parseAssignmentExpression(ast->expression))
- reportError(("Expression expected"));
+ reportError(QLatin1String("Expression expected"));
}
UPDATE_POS(ast, start, token_stream.cursor());
@@ -2439,14 +2439,14 @@ bool Parser::parseWhileStatement(StatementAST *&node)
ConditionAST *cond = 0;
if (!parseCondition(cond)) {
- reportError(("condition expected"));
+ reportError(QLatin1String("condition expected"));
return false;
}
ADVANCE(')', ")");
StatementAST *body = 0;
if (!parseStatement(body)) {
- reportError(("statement expected"));
+ reportError(QLatin1String("statement expected"));
return false;
}
@@ -2468,7 +2468,7 @@ bool Parser::parseDoStatement(StatementAST *&node)
StatementAST *body = 0;
if (!parseStatement(body)) {
- reportError(("statement expected"));
+ reportError(QLatin1String("statement expected"));
//return false;
}
@@ -2477,7 +2477,7 @@ bool Parser::parseDoStatement(StatementAST *&node)
ExpressionAST *expr = 0;
if (!parseCommaExpression(expr)) {
- reportError(("expression expected"));
+ reportError(QLatin1String("expression expected"));
//return false;
}
@@ -2503,7 +2503,7 @@ bool Parser::parseForStatement(StatementAST *&node)
StatementAST *init = 0;
if (!parseForInitStatement(init)) {
- reportError(("for initialization expected"));
+ reportError(QLatin1String("for initialization expected"));
return false;
}
@@ -2584,14 +2584,14 @@ bool Parser::parseIfStatement(StatementAST *&node)
ConditionAST *cond = 0;
if (!parseCondition(cond)) {
- reportError(("condition expected"));
+ reportError(QLatin1String("condition expected"));
return false;
}
ADVANCE(')', ")");
StatementAST *stmt = 0;
if (!parseStatement(stmt)) {
- reportError(("statement expected"));
+ reportError(QLatin1String("statement expected"));
return false;
}
@@ -2602,7 +2602,7 @@ bool Parser::parseIfStatement(StatementAST *&node)
token_stream.nextToken();
if (!parseStatement(ast->else_statement)) {
- reportError(("statement expected"));
+ reportError(QLatin1String("statement expected"));
return false;
}
}
@@ -2622,7 +2622,7 @@ bool Parser::parseSwitchStatement(StatementAST *&node)
ConditionAST *cond = 0;
if (!parseCondition(cond)) {
- reportError(("condition expected"));
+ reportError(QLatin1String("condition expected"));
return false;
}
ADVANCE(')', ")");
@@ -2664,13 +2664,13 @@ bool Parser::parseLabeledStatement(StatementAST *&node)
token_stream.nextToken();
ExpressionAST *expr = 0;
if (!parseConstantExpression(expr)) {
- reportError(("expression expected"));
+ reportError(QLatin1String("expression expected"));
} else if (token_stream.lookAhead() == Token_ellipsis) {
token_stream.nextToken();
ExpressionAST *expr2 = 0;
if (!parseConstantExpression(expr2))
- reportError(("expression expected"));
+ reportError(QLatin1String("expression expected"));
}
ADVANCE(':', ":");
@@ -2753,7 +2753,7 @@ bool Parser::parseNamespaceAliasDefinition(DeclarationAST *&node)
ADVANCE('=', "=");
if (!parseName(ast->alias_name))
- reportError(("Namespace name expected"));
+ reportError(QLatin1String("Namespace name expected"));
ADVANCE(';', ";");
@@ -3032,7 +3032,7 @@ bool Parser::parseTryBlockStatement(StatementAST *&node)
}
if (token_stream.lookAhead() != Token_catch) {
- reportError(("catch expected"));
+ reportError(QLatin1String("catch expected"));
return false;
}
@@ -3043,7 +3043,7 @@ bool Parser::parseTryBlockStatement(StatementAST *&node)
if (token_stream.lookAhead() == Token_ellipsis) {
token_stream.nextToken();
} else if (!parseCondition(cond, false)) {
- reportError(("condition expected"));
+ reportError(QLatin1String("condition expected"));
return false;
}
ADVANCE(')', ")");
diff --git a/ApiExtractor/parser/type_compiler.cpp b/ApiExtractor/parser/type_compiler.cpp
index 93322bd..6f4b274 100644
--- a/ApiExtractor/parser/type_compiler.cpp
+++ b/ApiExtractor/parser/type_compiler.cpp
@@ -82,8 +82,8 @@ void TypeCompiler::visitSimpleTypeSpecifier(SimpleTypeSpecifierAST *node)
QString current_item;
do {
std::size_t token = it->element;
- current_item += token_name(_M_token_stream->kind(token));
- current_item += " ";
+ current_item += QLatin1String(token_name(_M_token_stream->kind(token)));
+ current_item += QLatin1Char(' ');
it = it->next;
} while (it != end);
_M_type += current_item.trimmed();
diff --git a/ApiExtractor/reporthandler.cpp b/ApiExtractor/reporthandler.cpp
index f3569dc..3117a43 100644
--- a/ApiExtractor/reporthandler.cpp
+++ b/ApiExtractor/reporthandler.cpp
@@ -134,9 +134,9 @@ void ReportHandler::progress(const QString& str, ...)
m_step++;
if (m_step >= m_step_size) {
if (m_step_warning == 0) {
- m_progressBuffer = "[" COLOR_GREEN "OK" COLOR_END "]\n";
+ m_progressBuffer = QLatin1String("[" COLOR_GREEN "OK" COLOR_END "]\n");
} else {
- m_progressBuffer = "[" COLOR_YELLOW "WARNING" COLOR_END "]\n";
+ m_progressBuffer = QLatin1String("[" COLOR_YELLOW "WARNING" COLOR_END "]\n");
}
printProgress();
m_step_warning = 0;
diff --git a/ApiExtractor/typedatabase.cpp b/ApiExtractor/typedatabase.cpp
index ce483b4..734f832 100644
--- a/ApiExtractor/typedatabase.cpp
+++ b/ApiExtractor/typedatabase.cpp
@@ -55,17 +55,19 @@ TypeDatabase* TypeDatabase::instance(bool newInstance)
QString TypeDatabase::normalizedSignature(const char* signature)
{
- QString normalized = QMetaObject::normalizedSignature(signature);
+ QString normalized = QLatin1String(QMetaObject::normalizedSignature(signature));
- if (!instance() || !QString(signature).contains("unsigned"))
+ if (!instance() || !QByteArray(signature).contains("unsigned"))
return normalized;
QStringList types;
- types << "char" << "short" << "int" << "long";
+ types << QLatin1String("char") << QLatin1String("short")
+ << QLatin1String("int") << QLatin1String("long");
foreach (const QString& type, types) {
- if (instance()->findType(QString("u%1").arg(type)))
+ if (instance()->findType(QLatin1Char('u') + type))
continue;
- normalized.replace(QRegExp(QString("\\bu%1\\b").arg(type)), QString("unsigned %1").arg(type));
+ const QString pattern = QLatin1String("\\bu") + type + QLatin1String("\\b");
+ normalized.replace(QRegExp(pattern), QLatin1String("unsigned ") + type);
}
return normalized;
@@ -85,11 +87,11 @@ void TypeDatabase::addRequiredTargetImport(const QString& moduleName)
void TypeDatabase::addTypesystemPath(const QString& typesystem_paths)
{
#if defined(Q_OS_WIN32)
- char* path_splitter = const_cast<char*>(";");
+ const char path_splitter = ';';
#else
- char* path_splitter = const_cast<char*>(":");
+ const char path_splitter = ':';
#endif
- m_typesystemPaths += typesystem_paths.split(path_splitter);
+ m_typesystemPaths += typesystem_paths.split(QLatin1Char(path_splitter));
}
IncludeList TypeDatabase::extraIncludes(const QString& className) const
@@ -105,7 +107,7 @@ ContainerTypeEntry* TypeDatabase::findContainerType(const QString &name) const
{
QString template_name = name;
- int pos = name.indexOf('<');
+ int pos = name.indexOf(QLatin1Char('<'));
if (pos > 0)
template_name = name.left(pos);
@@ -206,10 +208,12 @@ bool TypeDatabase::isClassRejected(const QString& className) const
if (!m_rebuildClasses.isEmpty())
return !m_rebuildClasses.contains(className);
- foreach (const TypeRejection& r, m_rejections)
- if (r.class_name == className && r.function_name == "*" && r.field_name == "*" && r.enum_name == "*")
- return true;
-
+ foreach (const TypeRejection& r, m_rejections) {
+ if (r.class_name == className && r.function_name == QLatin1String("*")
+ && r.field_name == QLatin1String("*") && r.enum_name == QLatin1String("*")) {
+ return true;
+ }
+ }
return false;
}
@@ -217,7 +221,7 @@ bool TypeDatabase::isEnumRejected(const QString& className, const QString& enumN
{
foreach (const TypeRejection& r, m_rejections) {
if (r.enum_name == enumName
- && (r.class_name == className || r.class_name == "*")) {
+ && (r.class_name == className || r.class_name == QLatin1String("*"))) {
return true;
}
}
@@ -229,7 +233,7 @@ bool TypeDatabase::isFunctionRejected(const QString& className, const QString& f
{
foreach (const TypeRejection& r, m_rejections)
if (r.function_name == functionName &&
- (r.class_name == className || r.class_name == "*"))
+ (r.class_name == className || r.class_name == QLatin1String("*")))
return true;
return false;
}
@@ -239,7 +243,7 @@ bool TypeDatabase::isFieldRejected(const QString& className, const QString& fiel
{
foreach (const TypeRejection& r, m_rejections)
if (r.field_name == fieldName &&
- (r.class_name == className || r.class_name == "*"))
+ (r.class_name == className || r.class_name == QLatin1String("*")))
return true;
return false;
}
@@ -296,19 +300,20 @@ bool TypeDatabase::isSuppressedWarning(const QString& s) const
return false;
foreach (const QString &_warning, m_suppressedWarnings) {
- QString warning(QString(_warning).replace("\\*", "&place_holder_for_asterisk;"));
+ QString warning = _warning;
+ warning.replace(QLatin1String("\\*"), QLatin1String("&place_holder_for_asterisk;"));
- QStringList segs = warning.split("*", QString::SkipEmptyParts);
+ QStringList segs = warning.split(QLatin1Char('*'), QString::SkipEmptyParts);
if (!segs.size())
continue;
int i = 0;
- int pos = s.indexOf(QString(segs.at(i++)).replace("&place_holder_for_asterisk;", "*"));
+ int pos = s.indexOf(QString(segs.at(i++)).replace(QLatin1String("&place_holder_for_asterisk;"), QLatin1String("*")));
//qDebug() << "s == " << s << ", warning == " << segs;
while (pos != -1) {
if (i == segs.size())
return true;
- pos = s.indexOf(QString(segs.at(i++)).replace("&place_holder_for_asterisk;", "*"), pos);
+ pos = s.indexOf(QString(segs.at(i++)).replace(QLatin1String("&place_holder_for_asterisk;"), QLatin1String("*")), pos);
}
}
@@ -318,10 +323,10 @@ bool TypeDatabase::isSuppressedWarning(const QString& s) const
QString TypeDatabase::modifiedTypesystemFilepath(const QString& tsFile) const
{
if (!QFile::exists(tsFile)) {
- int idx = tsFile.lastIndexOf('/');
+ int idx = tsFile.lastIndexOf(QLatin1Char('/'));
QString fileName = idx >= 0 ? tsFile.right(tsFile.length() - idx - 1) : tsFile;
foreach (const QString &path, m_typesystemPaths) {
- QString filepath(path + '/' + fileName);
+ QString filepath(path + QLatin1Char('/') + fileName);
if (QFile::exists(filepath))
return filepath;
}
@@ -338,7 +343,7 @@ bool TypeDatabase::parseFile(const QString &filename, bool generate)
QFile file(filepath);
if (!file.exists()) {
qCWarning(lcShiboken).noquote().nospace()
- << "Can't find " << filename << ", typesystem paths: " << m_typesystemPaths.join(", ");
+ << "Can't find " << filename << ", typesystem paths: " << m_typesystemPaths.join(QLatin1String(", "));
return false;
}
@@ -357,7 +362,7 @@ bool TypeDatabase::parseFile(const QString &filename, bool generate)
bool TypeDatabase::parseFile(QIODevice* device, bool generate)
{
if (m_apiVersion) // backwards compatibility with deprecated API
- setApiVersion("*", QByteArray::number(m_apiVersion));
+ setApiVersion(QLatin1String("*"), QByteArray::number(m_apiVersion));
QXmlInputSource source(device);
QXmlSimpleReader reader;
diff --git a/ApiExtractor/typedatabase.h b/ApiExtractor/typedatabase.h
index 116e0ed..fe90a35 100644
--- a/ApiExtractor/typedatabase.h
+++ b/ApiExtractor/typedatabase.h
@@ -167,7 +167,7 @@ public:
static QString globalNamespaceClassName(const TypeEntry *te);
QString filename() const
{
- return "typesystem.txt";
+ return QLatin1String("typesystem.txt");
}
QString modifiedTypesystemFilepath(const QString& tsFile) const;
diff --git a/ApiExtractor/typeparser.cpp b/ApiExtractor/typeparser.cpp
index 86b4c8b..c0ca2b1 100644
--- a/ApiExtractor/typeparser.cpp
+++ b/ApiExtractor/typeparser.cpp
@@ -71,7 +71,7 @@ Scanner::Token Scanner::nextToken()
Token tok = NoToken;
// remove whitespace
- while (m_pos < m_length && m_chars[m_pos] == ' ')
+ while (m_pos < m_length && m_chars[m_pos] == QLatin1Char(' '))
++m_pos;
m_tokenStart = m_pos;
@@ -97,7 +97,7 @@ Scanner::Token Scanner::nextToken()
++m_pos;
break;
default:
- if (c.isLetterOrNumber() || c == '_')
+ if (c.isLetterOrNumber() || c == QLatin1Char('_'))
tok = Identifier;
else
qFatal("Unrecognized character in lexer: %c", c.toLatin1());
@@ -111,7 +111,7 @@ Scanner::Token Scanner::nextToken()
}
if (tok == Identifier) {
- if (c.isLetterOrNumber() || c == '_')
+ if (c.isLetterOrNumber() || c == QLatin1Char('_'))
++m_pos;
else
break;
@@ -119,11 +119,11 @@ Scanner::Token Scanner::nextToken()
}
if (tok == Identifier && m_pos - m_tokenStart == 5) {
- if (m_chars[m_tokenStart] == 'c'
- && m_chars[m_tokenStart + 1] == 'o'
- && m_chars[m_tokenStart + 2] == 'n'
- && m_chars[m_tokenStart + 3] == 's'
- && m_chars[m_tokenStart + 4] == 't')
+ if (m_chars[m_tokenStart] == QLatin1Char('c')
+ && m_chars[m_tokenStart + 1] == QLatin1Char('o')
+ && m_chars[m_tokenStart + 2] == QLatin1Char('n')
+ && m_chars[m_tokenStart + 3] == QLatin1Char('s')
+ && m_chars[m_tokenStart + 4] == QLatin1Char('t'))
tok = ConstToken;
}
@@ -209,7 +209,7 @@ TypeParser::Info TypeParser::parse(const QString &str)
stack.top()->qualified_name << scanner.identifier();
colon_prefix = false;
} else {
- stack.top()->qualified_name.last().append(" " + scanner.identifier());
+ stack.top()->qualified_name.last().append(QLatin1Char(' ') + scanner.identifier());
}
break;
@@ -235,12 +235,12 @@ TypeParser::Info TypeParser::parse(const QString &str)
QString TypeParser::Info::instantiationName() const
{
- QString s(qualified_name.join("::"));
+ QString s(qualified_name.join(QLatin1String("::")));
if (!template_instantiations.isEmpty()) {
QStringList insts;
foreach (Info info, template_instantiations)
insts << info.toString();
- s += QString("< %1 >").arg(insts.join(", "));
+ s += QLatin1String("< ") + insts.join(QLatin1String(", ")) + QLatin1String(" >");
}
return s;
@@ -250,12 +250,14 @@ QString TypeParser::Info::toString() const
{
QString s;
- if (is_constant) s += "const ";
+ if (is_constant)
+ s += QLatin1String("const ");
s += instantiationName();
for (int i = 0; i < arrays.size(); ++i)
- s += "[" + arrays.at(i) + "]";
- s += QString(indirections, '*');
- if (is_reference) s += '&';
+ s += QLatin1Char('[') + arrays.at(i) + QLatin1Char(']');
+ s += QString(indirections, QLatin1Char('*'));
+ if (is_reference)
+ s += QLatin1Char('&');
return s;
}
diff --git a/ApiExtractor/typesystem.cpp b/ApiExtractor/typesystem.cpp
index 5c115dd..a2a07a9 100644
--- a/ApiExtractor/typesystem.cpp
+++ b/ApiExtractor/typesystem.cpp
@@ -44,50 +44,50 @@ Handler::Handler(TypeDatabase* database, bool generate)
m_currentDroppedEntryDepth = 0;
m_ignoreDepth = 0;
- tagNames["rejection"] = StackElement::Rejection;
- tagNames["custom-type"] = StackElement::CustomTypeEntry;
- tagNames["primitive-type"] = StackElement::PrimitiveTypeEntry;
- tagNames["container-type"] = StackElement::ContainerTypeEntry;
- tagNames["object-type"] = StackElement::ObjectTypeEntry;
- tagNames["value-type"] = StackElement::ValueTypeEntry;
- tagNames["interface-type"] = StackElement::InterfaceTypeEntry;
- tagNames["namespace-type"] = StackElement::NamespaceTypeEntry;
- tagNames["enum-type"] = StackElement::EnumTypeEntry;
- tagNames["function"] = StackElement::FunctionTypeEntry;
- tagNames["extra-includes"] = StackElement::ExtraIncludes;
- tagNames["include"] = StackElement::Include;
- tagNames["inject-code"] = StackElement::InjectCode;
- tagNames["modify-function"] = StackElement::ModifyFunction;
- tagNames["modify-field"] = StackElement::ModifyField;
- tagNames["access"] = StackElement::Access;
- tagNames["remove"] = StackElement::Removal;
- tagNames["rename"] = StackElement::Rename;
- tagNames["typesystem"] = StackElement::Root;
- tagNames["custom-constructor"] = StackElement::CustomMetaConstructor;
- tagNames["custom-destructor"] = StackElement::CustomMetaDestructor;
- tagNames["argument-map"] = StackElement::ArgumentMap;
- tagNames["suppress-warning"] = StackElement::SuppressedWarning;
- tagNames["load-typesystem"] = StackElement::LoadTypesystem;
- tagNames["define-ownership"] = StackElement::DefineOwnership;
- tagNames["replace-default-expression"] = StackElement::ReplaceDefaultExpression;
- tagNames["reject-enum-value"] = StackElement::RejectEnumValue;
- tagNames["replace-type"] = StackElement::ReplaceType;
- tagNames["conversion-rule"] = StackElement::ConversionRule;
- tagNames["native-to-target"] = StackElement::NativeToTarget;
- tagNames["target-to-native"] = StackElement::TargetToNative;
- tagNames["add-conversion"] = StackElement::AddConversion;
- tagNames["modify-argument"] = StackElement::ModifyArgument;
- tagNames["remove-argument"] = StackElement::RemoveArgument;
- tagNames["remove-default-expression"] = StackElement::RemoveDefaultExpression;
- tagNames["template"] = StackElement::Template;
- tagNames["insert-template"] = StackElement::TemplateInstanceEnum;
- tagNames["replace"] = StackElement::Replace;
- tagNames["no-null-pointer"] = StackElement::NoNullPointers;
- tagNames["reference-count"] = StackElement::ReferenceCount;
- tagNames["parent"] = StackElement::ParentOwner;
- tagNames["inject-documentation"] = StackElement::InjectDocumentation;
- tagNames["modify-documentation"] = StackElement::ModifyDocumentation;
- tagNames["add-function"] = StackElement::AddFunction;
+ tagNames.insert(QLatin1String("rejection"), StackElement::Rejection);
+ tagNames.insert(QLatin1String("custom-type"), StackElement::CustomTypeEntry);
+ tagNames.insert(QLatin1String("primitive-type"), StackElement::PrimitiveTypeEntry);
+ tagNames.insert(QLatin1String("container-type"), StackElement::ContainerTypeEntry);
+ tagNames.insert(QLatin1String("object-type"), StackElement::ObjectTypeEntry);
+ tagNames.insert(QLatin1String("value-type"), StackElement::ValueTypeEntry);
+ tagNames.insert(QLatin1String("interface-type"), StackElement::InterfaceTypeEntry);
+ tagNames.insert(QLatin1String("namespace-type"), StackElement::NamespaceTypeEntry);
+ tagNames.insert(QLatin1String("enum-type"), StackElement::EnumTypeEntry);
+ tagNames.insert(QLatin1String("function"), StackElement::FunctionTypeEntry);
+ tagNames.insert(QLatin1String("extra-includes"), StackElement::ExtraIncludes);
+ tagNames.insert(QLatin1String("include"), StackElement::Include);
+ tagNames.insert(QLatin1String("inject-code"), StackElement::InjectCode);
+ tagNames.insert(QLatin1String("modify-function"), StackElement::ModifyFunction);
+ tagNames.insert(QLatin1String("modify-field"), StackElement::ModifyField);
+ tagNames.insert(QLatin1String("access"), StackElement::Access);
+ tagNames.insert(QLatin1String("remove"), StackElement::Removal);
+ tagNames.insert(QLatin1String("rename"), StackElement::Rename);
+ tagNames.insert(QLatin1String("typesystem"), StackElement::Root);
+ tagNames.insert(QLatin1String("custom-constructor"), StackElement::CustomMetaConstructor);
+ tagNames.insert(QLatin1String("custom-destructor"), StackElement::CustomMetaDestructor);
+ tagNames.insert(QLatin1String("argument-map"), StackElement::ArgumentMap);
+ tagNames.insert(QLatin1String("suppress-warning"), StackElement::SuppressedWarning);
+ tagNames.insert(QLatin1String("load-typesystem"), StackElement::LoadTypesystem);
+ tagNames.insert(QLatin1String("define-ownership"), StackElement::DefineOwnership);
+ tagNames.insert(QLatin1String("replace-default-expression"), StackElement::ReplaceDefaultExpression);
+ tagNames.insert(QLatin1String("reject-enum-value"), StackElement::RejectEnumValue);
+ tagNames.insert(QLatin1String("replace-type"), StackElement::ReplaceType);
+ tagNames.insert(QLatin1String("conversion-rule"), StackElement::ConversionRule);
+ tagNames.insert(QLatin1String("native-to-target"), StackElement::NativeToTarget);
+ tagNames.insert(QLatin1String("target-to-native"), StackElement::TargetToNative);
+ tagNames.insert(QLatin1String("add-conversion"), StackElement::AddConversion);
+ tagNames.insert(QLatin1String("modify-argument"), StackElement::ModifyArgument);
+ tagNames.insert(QLatin1String("remove-argument"), StackElement::RemoveArgument);
+ tagNames.insert(QLatin1String("remove-default-expression"), StackElement::RemoveDefaultExpression);
+ tagNames.insert(QLatin1String("template"), StackElement::Template);
+ tagNames.insert(QLatin1String("insert-template"), StackElement::TemplateInstanceEnum);
+ tagNames.insert(QLatin1String("replace"), StackElement::Replace);
+ tagNames.insert(QLatin1String("no-null-pointer"), StackElement::NoNullPointers);
+ tagNames.insert(QLatin1String("reference-count"), StackElement::ReferenceCount);
+ tagNames.insert(QLatin1String("parent"), StackElement::ParentOwner);
+ tagNames.insert(QLatin1String("inject-documentation"), StackElement::InjectDocumentation);
+ tagNames.insert(QLatin1String("modify-documentation"), StackElement::ModifyDocumentation);
+ tagNames.insert(QLatin1String("add-function"), StackElement::AddFunction);
}
bool Handler::error(const QXmlParseException &e)
@@ -152,7 +152,7 @@ bool Handler::endElement(const QString &, const QString &localName, const QStrin
}
QString tagName = localName.toLower();
- if (tagName == "import-file")
+ if (tagName == QLatin1String("import-file"))
return true;
if (!m_current)
@@ -190,14 +190,14 @@ bool Handler::endElement(const QString &, const QString &localName, const QStrin
case StackElement::AddConversion: {
CustomConversion* customConversion = static_cast<TypeEntry*>(m_current->entry)->customConversion();
if (!customConversion) {
- m_error = "CustomConversion object is missing.";
+ m_error = QLatin1String("CustomConversion object is missing.");
return false;
}
QString code = m_contextStack.top()->codeSnips.takeLast().code();
if (m_current->type == StackElement::AddConversion) {
if (customConversion->targetToNativeConversions().isEmpty()) {
- m_error = "CustomConversion's target to native conversions missing.";
+ m_error = QLatin1String("CustomConversion's target to native conversions missing.");
return false;
}
customConversion->targetToNativeConversions().last()->setConversion(code);
@@ -338,26 +338,26 @@ bool Handler::characters(const QString &ch)
bool Handler::importFileElement(const QXmlAttributes &atts)
{
- QString fileName = atts.value("name");
+ QString fileName = atts.value(QLatin1String("name"));
if (fileName.isEmpty()) {
- m_error = "Required attribute 'name' missing for include-file tag.";
+ m_error = QLatin1String("Required attribute 'name' missing for include-file tag.");
return false;
}
QFile file(fileName);
if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
- file.setFileName(":/trolltech/generator/" + fileName);
+ file.setFileName(QLatin1String(":/trolltech/generator/") + fileName);
if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
- m_error = QString("Could not open file: '%1'").arg(fileName);
+ m_error = QString::fromLatin1("Could not open file: '%1'").arg(QDir::toNativeSeparators(fileName));
return false;
}
}
- QString quoteFrom = atts.value("quote-after-line");
+ QString quoteFrom = atts.value(QLatin1String("quote-after-line"));
bool foundFromOk = quoteFrom.isEmpty();
bool from = quoteFrom.isEmpty();
- QString quoteTo = atts.value("quote-before-line");
+ QString quoteTo = atts.value(QLatin1String("quote-before-line"));
bool foundToOk = quoteTo.isEmpty();
bool to = true;
@@ -370,22 +370,24 @@ bool Handler::importFileElement(const QXmlAttributes &atts)
break;
}
if (from && to)
- characters(line + "\n");
+ characters(line + QLatin1Char('\n'));
if (!from && line.contains(quoteFrom)) {
from = true;
foundFromOk = true;
}
}
if (!foundFromOk || !foundToOk) {
- QString fromError = QString("Could not find quote-after-line='%1' in file '%2'.").arg(quoteFrom).arg(fileName);
- QString toError = QString("Could not find quote-before-line='%1' in file '%2'.").arg(quoteTo).arg(fileName);
+ QString fromError = QStringLiteral("Could not find quote-after-line='%1' in file '%2'.")
+ .arg(quoteFrom, fileName);
+ QString toError = QStringLiteral("Could not find quote-before-line='%1' in file '%2'.")
+ .arg(quoteTo, fileName);
if (!foundToOk)
m_error = toError;
if (!foundFromOk)
m_error = fromError;
if (!foundFromOk && !foundToOk)
- m_error = fromError + " " + toError;
+ m_error = fromError + QLatin1Char(' ') + toError;
return false;
}
@@ -395,13 +397,14 @@ bool Handler::importFileElement(const QXmlAttributes &atts)
bool Handler::convertBoolean(const QString &_value, const QString &attributeName, bool defaultValue)
{
QString value = _value.toLower();
- if (value == "true" || value == "yes")
+ if (value == QLatin1String("true") || value == QLatin1String("yes"))
return true;
- else if (value == "false" || value == "no")
+ else if (value == QLatin1String("false") || value == QLatin1String("no"))
return false;
else {
- QString warn = QString("Boolean value '%1' not supported in attribute '%2'. Use 'yes' or 'no'. Defaulting to '%3'.")
- .arg(value).arg(attributeName).arg(defaultValue ? "yes" : "no");
+ QString warn = QStringLiteral("Boolean value '%1' not supported in attribute '%2'. Use 'yes' or 'no'. Defaulting to '%3'.")
+ .arg(value, attributeName,
+ defaultValue ? QLatin1String("yes") : QLatin1String("no"));
qCWarning(lcShiboken).noquote().nospace() << warn;
return defaultValue;
@@ -436,20 +439,19 @@ static QString getNamePrefix(StackElement* element)
{
QStringList names;
getNamePrefixRecursive(element, names);
- return names.join(".");
+ return names.join(QLatin1Char('.'));
}
// Returns empty string if there's no error.
static QString checkSignatureError(const QString& signature, const QString& tag)
{
- QString funcName = signature.left(signature.indexOf('(')).trimmed();
- static QRegExp whiteSpace("\\s");
- if (!funcName.startsWith("operator ") && funcName.contains(whiteSpace)) {
- return QString("Error in <%1> tag signature attribute '%2'.\n"
- "White spaces aren't allowed in function names, "
- "and return types should not be part of the signature.")
- .arg(tag)
- .arg(signature);
+ QString funcName = signature.left(signature.indexOf(QLatin1Char('('))).trimmed();
+ static QRegExp whiteSpace(QLatin1String("\\s"));
+ if (!funcName.startsWith(QLatin1String("operator ")) && funcName.contains(whiteSpace)) {
+ return QStringLiteral("Error in <%1> tag signature attribute '%2'.\n"
+ "White spaces aren't allowed in function names, "
+ "and return types should not be part of the signature.")
+ .arg(tag, signature);
}
return QString();
}
@@ -462,9 +464,9 @@ bool Handler::startElement(const QString &, const QString &n,
return true;
}
- if (!m_defaultPackage.isEmpty() && atts.index("since") != -1) {
+ if (!m_defaultPackage.isEmpty() && atts.index(QLatin1String("since")) != -1) {
TypeDatabase* td = TypeDatabase::instance();
- if (!td->checkApiVersion(m_defaultPackage, atts.value("since").toUtf8())) {
+ if (!td->checkApiVersion(m_defaultPackage, atts.value(QLatin1String("since")).toUtf8())) {
++m_ignoreDepth;
return true;
}
@@ -472,11 +474,11 @@ bool Handler::startElement(const QString &, const QString &n,
QString tagName = n.toLower();
- if (tagName == "import-file")
+ if (tagName == QLatin1String("import-file"))
return importFileElement(atts);
if (!tagNames.contains(tagName)) {
- m_error = QString("Unknown tag name: '%1'").arg(tagName);
+ m_error = QStringLiteral("Unknown tag name: '%1'").arg(tagName);
return false;
}
@@ -502,71 +504,71 @@ bool Handler::startElement(const QString &, const QString &n,
if (element->type & StackElement::TypeEntryMask) {
QHash<QString, QString> attributes;
- attributes["name"] = QString();
- attributes["since"] = QString("0");
- attributes["revision"] = QString("0");
+ attributes.insert(QLatin1String("name"), QString());
+ attributes.insert(QLatin1String("revision"), QLatin1String("0"));
+ attributes.insert(QLatin1String("since"), QLatin1String("0"));
switch (element->type) {
case StackElement::PrimitiveTypeEntry:
- attributes["target-lang-name"] = QString();
- attributes["target-lang-api-name"] = QString();
- attributes["preferred-conversion"] = "yes";
- attributes["preferred-target-lang-type"] = "yes";
- attributes["default-constructor"] = QString();
+ attributes.insert(QLatin1String("target-lang-name"), QString());
+ attributes.insert(QLatin1String("target-lang-api-name"), QString());
+ attributes.insert(QLatin1String("preferred-conversion"), QLatin1String("yes"));
+ attributes.insert(QLatin1String("preferred-target-lang-type"), QLatin1String("yes"));
+ attributes.insert(QLatin1String("default-constructor"), QString());
break;
case StackElement::ContainerTypeEntry:
- attributes["type"] = QString();
+ attributes.insert(QLatin1String("type"), QString());
break;
case StackElement::EnumTypeEntry:
- attributes["flags"] = QString();
- attributes["flags-revision"] = QString();
- attributes["upper-bound"] = QString();
- attributes["lower-bound"] = QString();
- attributes["force-integer"] = "no";
- attributes["extensible"] = "no";
- attributes["identified-by-value"] = QString();
+ attributes.insert(QLatin1String("flags"), QString());
+ attributes.insert(QLatin1String("flags-revision"), QString());
+ attributes.insert(QLatin1String("upper-bound"), QString());
+ attributes.insert(QLatin1String("lower-bound"), QString());
+ attributes.insert(QLatin1String("force-integer"), QLatin1String("no"));
+ attributes.insert(QLatin1String("extensible"), QLatin1String("no"));
+ attributes.insert(QLatin1String("identified-by-value"), QString());
break;
case StackElement::ValueTypeEntry:
- attributes["default-constructor"] = QString();
+ attributes.insert(QLatin1String("default-constructor"), QString());
// fall throooough
case StackElement::ObjectTypeEntry:
- attributes["force-abstract"] = QString("no");
- attributes["deprecated"] = QString("no");
- attributes["hash-function"] = QString("");
- attributes["stream"] = QString("no");
+ attributes.insert(QLatin1String("force-abstract"), QLatin1String("no"));
+ attributes.insert(QLatin1String("deprecated"), QLatin1String("no"));
+ attributes.insert(QLatin1String("hash-function"), QString());
+ attributes.insert(QLatin1String("stream"), QLatin1String("no"));
// fall throooough
case StackElement::InterfaceTypeEntry:
- attributes["default-superclass"] = m_defaultSuperclass;
- attributes["polymorphic-id-expression"] = QString();
- attributes["delete-in-main-thread"] = QString("no");
- attributes["held-type"] = QString();
- attributes["copyable"] = QString();
+ attributes[QLatin1String("default-superclass")] = m_defaultSuperclass;
+ attributes.insert(QLatin1String("polymorphic-id-expression"), QString());
+ attributes.insert(QLatin1String("delete-in-main-thread"), QLatin1String("no"));
+ attributes.insert(QLatin1String("held-type"), QString());
+ attributes.insert(QLatin1String("copyable"), QString());
// fall through
case StackElement::NamespaceTypeEntry:
- attributes["target-lang-name"] = QString();
- attributes["package"] = m_defaultPackage;
- attributes["expense-cost"] = "1";
- attributes["expense-limit"] = "none";
- attributes["polymorphic-base"] = QString("no");
- attributes["generate"] = QString("yes");
- attributes["target-type"] = QString();
- attributes["generic-class"] = QString("no");
+ attributes.insert(QLatin1String("target-lang-name"), QString());
+ attributes[QLatin1String("package")] = m_defaultPackage;
+ attributes.insert(QLatin1String("expense-cost"), QLatin1String("1"));
+ attributes.insert(QLatin1String("expense-limit"), QLatin1String("none"));
+ attributes.insert(QLatin1String("polymorphic-base"), QLatin1String("no"));
+ attributes.insert(QLatin1String("generate"), QLatin1String("yes"));
+ attributes.insert(QLatin1String("target-type"), QString());
+ attributes.insert(QLatin1String("generic-class"), QLatin1String("no"));
break;
case StackElement::FunctionTypeEntry:
- attributes["signature"] = QString();
- attributes["rename"] = QString();
+ attributes.insert(QLatin1String("signature"), QString());
+ attributes.insert(QLatin1String("rename"), QString());
break;
default:
{ } // nada
};
fetchAttributeValues(tagName, atts, &attributes);
- QString name = attributes["name"];
- double since = attributes["since"].toDouble();
+ QString name = attributes[QLatin1String("name")];
+ double since = attributes[QLatin1String("since")].toDouble();
if (m_database->hasDroppedTypeEntries()) {
- QString identifier = getNamePrefix(element) + '.';
- identifier += (element->type == StackElement::FunctionTypeEntry ? attributes["signature"] : name);
+ QString identifier = getNamePrefix(element) + QLatin1Char('.');
+ identifier += (element->type == StackElement::FunctionTypeEntry ? attributes[QLatin1String("signature")] : name);
if (m_database->shouldDropTypeEntry(identifier)) {
m_currentDroppedEntry = element;
m_currentDroppedEntryDepth = 1;
@@ -581,23 +583,24 @@ bool Handler::startElement(const QString &, const QString &n,
// The top level tag 'function' has only the 'signature' tag
// and we should extract the 'name' value from it.
if (element->type == StackElement::FunctionTypeEntry) {
- QString signature = attributes["signature"];
- name = signature.left(signature.indexOf('(')).trimmed();
- QString errorString = checkSignatureError(signature, "function");
+ QString signature = attributes[QLatin1String("signature")];
+ name = signature.left(signature.indexOf(QLatin1Char('('))).trimmed();
+ QString errorString = checkSignatureError(signature, QLatin1String("function"));
if (!errorString.isEmpty()) {
m_error = errorString;
return false;
}
- QString rename = attributes["rename"];
+ QString rename = attributes[QLatin1String("rename")];
if (!rename.isEmpty()) {
- static QRegExp functionNameRegExp("^[a-zA-Z_][a-zA-Z0-9_]*$");
+ static QRegExp functionNameRegExp(QLatin1String("^[a-zA-Z_][a-zA-Z0-9_]*$"));
if (!functionNameRegExp.exactMatch(rename)) {
- m_error = "can not rename '" + signature + "', '" + rename + "' is not a valid function name";
+ m_error = QLatin1String("can not rename '") + signature + QLatin1String("', '")
+ + rename + QLatin1String("' is not a valid function name");
return false;
}
FunctionModification mod(since);
mod.signature = signature;
- mod.renamedToName = attributes["rename"];
+ mod.renamedToName = attributes[QLatin1String("rename")];
mod.modifiers |= Modification::Rename;
m_contextStack.top()->functionMods << mod;
}
@@ -616,9 +619,9 @@ bool Handler::startElement(const QString &, const QString &n,
if (element->type == StackElement::EnumTypeEntry) {
if (name.isEmpty()) {
- name = attributes["identified-by-value"];
- } else if (!attributes["identified-by-value"].isEmpty()) {
- m_error = "can't specify both 'name' and 'identified-by-value' attributes";
+ name = attributes[QLatin1String("identified-by-value")];
+ } else if (!attributes[QLatin1String("identified-by-value")].isEmpty()) {
+ m_error = QLatin1String("can't specify both 'name' and 'identified-by-value' attributes");
return false;
}
}
@@ -626,12 +629,12 @@ bool Handler::startElement(const QString &, const QString &n,
// Fix type entry name using nesting information.
if (element->type & StackElement::TypeEntryMask
&& element->parent && element->parent->type != StackElement::Root) {
- name = element->parent->entry->name() + "::" + name;
+ name = element->parent->entry->name() + QLatin1String("::") + name;
}
if (name.isEmpty()) {
- m_error = "no 'name' attribute specified";
+ m_error = QLatin1String("no 'name' attribute specified");
return false;
}
@@ -640,11 +643,11 @@ bool Handler::startElement(const QString &, const QString &n,
element->entry = new TypeEntry(name, TypeEntry::CustomType, since);
break;
case StackElement::PrimitiveTypeEntry: {
- QString targetLangName = attributes["target-lang-name"];
- QString targetLangApiName = attributes["target-lang-api-name"];
- QString preferredConversion = attributes["preferred-conversion"].toLower();
- QString preferredTargetLangType = attributes["preferred-target-lang-type"].toLower();
- QString defaultConstructor = attributes["default-constructor"];
+ QString targetLangName = attributes[QLatin1String("target-lang-name")];
+ QString targetLangApiName = attributes[QLatin1String("target-lang-api-name")];
+ QString preferredConversion = attributes[QLatin1String("preferred-conversion")].toLower();
+ QString preferredTargetLangType = attributes[QLatin1String("preferred-target-lang-type")].toLower();
+ QString defaultConstructor = attributes[QLatin1String("default-constructor")];
if (targetLangName.isEmpty())
targetLangName = name;
@@ -659,10 +662,10 @@ bool Handler::startElement(const QString &, const QString &n,
type->setDefaultConstructor(defaultConstructor);
bool preferred;
- preferred = convertBoolean(preferredConversion, "preferred-conversion", true);
+ preferred = convertBoolean(preferredConversion, QLatin1String("preferred-conversion"), true);
type->setPreferredConversion(preferred);
preferred = convertBoolean(preferredTargetLangType,
- "preferred-target-lang-type", true);
+ QLatin1String("preferred-target-lang-type"), true);
type->setPreferredTargetLangType(preferred);
element->entry = type;
@@ -670,14 +673,14 @@ bool Handler::startElement(const QString &, const QString &n,
break;
case StackElement::ContainerTypeEntry: {
- QString typeName = attributes["type"];
+ QString typeName = attributes[QLatin1String("type")];
ContainerTypeEntry::Type containerType =
ContainerTypeEntry::containerTypeFromString(typeName);
if (typeName.isEmpty()) {
- m_error = "no 'type' attribute specified";
+ m_error = QLatin1String("no 'type' attribute specified");
return false;
} else if (containerType == ContainerTypeEntry::NoContainer) {
- m_error = "there is no container of type " + typeName;
+ m_error = QLatin1String("there is no container of type ") + typeName;
return false;
}
@@ -693,36 +696,36 @@ bool Handler::startElement(const QString &, const QString &n,
m_currentEnum = new EnumTypeEntry(QString(), name, since);
else
m_currentEnum =
- new EnumTypeEntry(QStringList(names.mid(0, names.size() - 1)).join("::"),
+ new EnumTypeEntry(QStringList(names.mid(0, names.size() - 1)).join(QLatin1String("::")),
names.last(), since);
- m_currentEnum->setAnonymous(!attributes["identified-by-value"].isEmpty());
+ m_currentEnum->setAnonymous(!attributes[QLatin1String("identified-by-value")].isEmpty());
element->entry = m_currentEnum;
m_currentEnum->setCodeGeneration(m_generate);
m_currentEnum->setTargetLangPackage(m_defaultPackage);
- m_currentEnum->setUpperBound(attributes["upper-bound"]);
- m_currentEnum->setLowerBound(attributes["lower-bound"]);
- m_currentEnum->setForceInteger(convertBoolean(attributes["force-integer"], "force-integer", false));
- m_currentEnum->setExtensible(convertBoolean(attributes["extensible"], "extensible", false));
+ m_currentEnum->setUpperBound(attributes[QLatin1String("upper-bound")]);
+ m_currentEnum->setLowerBound(attributes[QLatin1String("lower-bound")]);
+ m_currentEnum->setForceInteger(convertBoolean(attributes[QLatin1String("force-integer")], QLatin1String("force-integer"), false));
+ m_currentEnum->setExtensible(convertBoolean(attributes[QLatin1String("extensible")], QLatin1String("extensible"), false));
// put in the flags parallel...
- QString flagName = attributes["flags"];
+ QString flagName = attributes[QLatin1String("flags")];
if (!flagName.isEmpty()) {
- FlagsTypeEntry *ftype = new FlagsTypeEntry("QFlags<" + name + ">", since);
+ FlagsTypeEntry *ftype = new FlagsTypeEntry(QLatin1String("QFlags<") + name + QLatin1Char('>'), since);
ftype->setOriginator(m_currentEnum);
// Try to get the guess the qualified flag name
- if (!flagName.contains("::") && names.count() > 1) {
+ if (!flagName.contains(QLatin1String("::")) && names.count() > 1) {
QStringList cpy(names);
cpy.removeLast();
cpy.append(flagName);
- flagName = cpy.join("::");
+ flagName = cpy.join(QLatin1String("::"));
}
ftype->setOriginalName(flagName);
ftype->setCodeGeneration(m_generate);
QString n = ftype->originalName();
- QStringList lst = n.split("::");
- if (QStringList(lst.mid(0, lst.size() - 1)).join("::") != m_currentEnum->targetLangQualifier()) {
+ QStringList lst = n.split(QLatin1String("::"));
+ if (QStringList(lst.mid(0, lst.size() - 1)).join(QLatin1String("::")) != m_currentEnum->targetLangQualifier()) {
qCWarning(lcShiboken).noquote().nospace()
<< QStringLiteral("enum %1 and flags %2 differ in qualifiers")
.arg(m_currentEnum->targetLangQualifier(), lst.constFirst());
@@ -734,7 +737,9 @@ bool Handler::startElement(const QString &, const QString &n,
m_database->addFlagsType(ftype);
m_database->addType(ftype);
- QString revision = attributes["flags-revision"].isEmpty() ? attributes["revision"] : attributes["flags-revision"];
+ QString revision = attributes[QLatin1String("flags-revision")].isEmpty()
+ ? attributes[QLatin1String("revision")]
+ : attributes[QLatin1String("flags-revision")];
setTypeRevision(ftype, revision.toInt());
}
}
@@ -742,13 +747,13 @@ bool Handler::startElement(const QString &, const QString &n,
case StackElement::InterfaceTypeEntry: {
ObjectTypeEntry *otype = new ObjectTypeEntry(name, since);
- QString targetLangName = attributes["target-lang-name"];
+ QString targetLangName = attributes[QLatin1String("target-lang-name")];
if (targetLangName.isEmpty())
targetLangName = name;
InterfaceTypeEntry *itype =
new InterfaceTypeEntry(InterfaceTypeEntry::interfaceName(targetLangName), since);
- if (!convertBoolean(attributes["generate"], "generate", true))
+ if (!convertBoolean(attributes[QLatin1String("generate")], QLatin1String("generate"), true))
itype->setCodeGeneration(TypeEntry::GenerateForSubclass);
else
itype->setCodeGeneration(m_generate);
@@ -760,7 +765,7 @@ bool Handler::startElement(const QString &, const QString &n,
case StackElement::ValueTypeEntry: {
if (!element->entry) {
ValueTypeEntry* typeEntry = new ValueTypeEntry(name, since);
- QString defaultConstructor = attributes["default-constructor"];
+ QString defaultConstructor = attributes[QLatin1String("default-constructor")];
if (!defaultConstructor.isEmpty())
typeEntry->setDefaultConstructor(defaultConstructor);
element->entry = typeEntry;
@@ -776,39 +781,39 @@ bool Handler::startElement(const QString &, const QString &n,
if (!element->entry)
element->entry = new ObjectTypeEntry(name, since);
- element->entry->setStream(attributes["stream"] == QString("yes"));
+ element->entry->setStream(attributes[QLatin1String("stream")] == QLatin1String("yes"));
ComplexTypeEntry *ctype = static_cast<ComplexTypeEntry *>(element->entry);
- ctype->setTargetLangPackage(attributes["package"]);
- ctype->setDefaultSuperclass(attributes["default-superclass"]);
- ctype->setGenericClass(convertBoolean(attributes["generic-class"], "generic-class", false));
+ ctype->setTargetLangPackage(attributes[QLatin1String("package")]);
+ ctype->setDefaultSuperclass(attributes[QLatin1String("default-superclass")]);
+ ctype->setGenericClass(convertBoolean(attributes[QLatin1String("generic-class")], QLatin1String("generic-class"), false));
- if (!convertBoolean(attributes["generate"], "generate", true))
+ if (!convertBoolean(attributes[QLatin1String("generate")], QLatin1String("generate"), true))
element->entry->setCodeGeneration(TypeEntry::GenerateForSubclass);
else
element->entry->setCodeGeneration(m_generate);
- QString targetLangName = attributes["target-lang-name"];
+ QString targetLangName = attributes[QLatin1String("target-lang-name")];
if (!targetLangName.isEmpty())
ctype->setTargetLangName(targetLangName);
// The expense policy
- QString limit = attributes["expense-limit"];
- if (!limit.isEmpty() && limit != "none") {
+ QString limit = attributes[QLatin1String("expense-limit")];
+ if (!limit.isEmpty() && limit != QLatin1String("none")) {
ExpensePolicy ep;
ep.limit = limit.toInt();
- ep.cost = attributes["expense-cost"];
+ ep.cost = attributes[QLatin1String("expense-cost")];
ctype->setExpensePolicy(ep);
}
- ctype->setIsPolymorphicBase(convertBoolean(attributes["polymorphic-base"], "polymorphic-base", false));
- ctype->setPolymorphicIdValue(attributes["polymorphic-id-expression"]);
+ ctype->setIsPolymorphicBase(convertBoolean(attributes[QLatin1String("polymorphic-base")], QLatin1String("polymorphic-base"), false));
+ ctype->setPolymorphicIdValue(attributes[QLatin1String("polymorphic-id-expression")]);
//Copyable
- if (attributes["copyable"].isEmpty())
+ if (attributes[QLatin1String("copyable")].isEmpty())
ctype->setCopyable(ComplexTypeEntry::Unknown);
else {
- if (convertBoolean(attributes["copyable"], "copyable", false))
+ if (convertBoolean(attributes[QLatin1String("copyable")], QLatin1String("copyable"), false))
ctype->setCopyable(ComplexTypeEntry::CopyableSet);
else
ctype->setCopyable(ComplexTypeEntry::NonCopyableSet);
@@ -816,46 +821,47 @@ bool Handler::startElement(const QString &, const QString &n,
}
if (element->type == StackElement::ObjectTypeEntry || element->type == StackElement::ValueTypeEntry)
- ctype->setHashFunction(attributes["hash-function"]);
+ ctype->setHashFunction(attributes[QLatin1String("hash-function")]);
- ctype->setHeldType(attributes["held-type"]);
+ ctype->setHeldType(attributes[QLatin1String("held-type")]);
if (element->type == StackElement::ObjectTypeEntry
|| element->type == StackElement::ValueTypeEntry) {
- if (convertBoolean(attributes["force-abstract"], "force-abstract", false))
+ if (convertBoolean(attributes[QLatin1String("force-abstract")], QLatin1String("force-abstract"), false))
ctype->setTypeFlags(ctype->typeFlags() | ComplexTypeEntry::ForceAbstract);
- if (convertBoolean(attributes["deprecated"], "deprecated", false))
+ if (convertBoolean(attributes[QLatin1String("deprecated")], QLatin1String("deprecated"), false))
ctype->setTypeFlags(ctype->typeFlags() | ComplexTypeEntry::Deprecated);
}
if (element->type == StackElement::InterfaceTypeEntry
|| element->type == StackElement::ValueTypeEntry
|| element->type == StackElement::ObjectTypeEntry) {
- if (convertBoolean(attributes["delete-in-main-thread"], "delete-in-main-thread", false))
+ if (convertBoolean(attributes[QLatin1String("delete-in-main-thread")], QLatin1String("delete-in-main-thread"), false))
ctype->setTypeFlags(ctype->typeFlags() | ComplexTypeEntry::DeleteInMainThread);
}
- QString targetType = attributes["target-type"];
+ QString targetType = attributes[QLatin1String("target-type")];
if (!targetType.isEmpty() && element->entry->isComplex())
static_cast<ComplexTypeEntry *>(element->entry)->setTargetType(targetType);
// ctype->setInclude(Include(Include::IncludePath, ctype->name()));
ctype = ctype->designatedInterface();
if (ctype)
- ctype->setTargetLangPackage(attributes["package"]);
+ ctype->setTargetLangPackage(attributes[QLatin1String("package")]);
}
break;
case StackElement::FunctionTypeEntry: {
- QString signature = attributes["signature"];
+ QString signature = attributes[QLatin1String("signature")];
signature = TypeDatabase::normalizedSignature(signature.toLatin1().constData());
element->entry = m_database->findType(name);
if (element->entry) {
if (element->entry->type() == TypeEntry::FunctionType) {
reinterpret_cast<FunctionTypeEntry*>(element->entry)->addSignature(signature);
} else {
- m_error = QString("%1 expected to be a function, but isn't! Maybe it was already declared as a class or something else.").arg(name);
+ m_error = QStringLiteral("%1 expected to be a function, but isn't! Maybe it was already declared as a class or something else.")
+ .arg(name);
return false;
}
} else {
@@ -870,7 +876,7 @@ bool Handler::startElement(const QString &, const QString &n,
if (element->entry) {
m_database->addType(element->entry);
- setTypeRevision(element->entry, attributes["revision"].toInt());
+ setTypeRevision(element->entry, attributes[QLatin1String("revision")].toInt());
} else {
qCWarning(lcShiboken).noquote().nospace()
<< QStringLiteral("Type: %1 was rejected by typesystem").arg(name);
@@ -879,40 +885,40 @@ bool Handler::startElement(const QString &, const QString &n,
} else if (element->type == StackElement::InjectDocumentation) {
// check the XML tag attributes
QHash<QString, QString> attributes;
- attributes["mode"] = "replace";
- attributes["format"] = "native";
- attributes["since"] = QString("0");
+ attributes.insert(QLatin1String("mode"), QLatin1String("replace"));
+ attributes.insert(QLatin1String("format"), QLatin1String("native"));
+ attributes.insert(QLatin1String("since"), QLatin1String("0"));
fetchAttributeValues(tagName, atts, &attributes);
- double since = attributes["since"].toDouble();
+ double since = attributes[QLatin1String("since")].toDouble();
const int validParent = StackElement::TypeEntryMask
| StackElement::ModifyFunction
| StackElement::ModifyField;
if (m_current->parent && m_current->parent->type & validParent) {
- QString modeName = attributes["mode"];
+ QString modeName = attributes[QLatin1String("mode")];
DocModification::Mode mode;
- if (modeName == "append") {
+ if (modeName == QLatin1String("append")) {
mode = DocModification::Append;
- } else if (modeName == "prepend") {
+ } else if (modeName == QLatin1String("prepend")) {
mode = DocModification::Prepend;
- } else if (modeName == "replace") {
+ } else if (modeName == QLatin1String("replace")) {
mode = DocModification::Replace;
} else {
- m_error = "Unknow documentation injection mode: " + modeName;
+ m_error = QLatin1String("Unknow documentation injection mode: ") + modeName;
return false;
}
static QHash<QString, TypeSystem::Language> languageNames;
if (languageNames.isEmpty()) {
- languageNames["target"] = TypeSystem::TargetLangCode;
- languageNames["native"] = TypeSystem::NativeCode;
+ languageNames[QLatin1String("target")] = TypeSystem::TargetLangCode;
+ languageNames[QLatin1String("native")] = TypeSystem::NativeCode;
}
- QString format = attributes["format"].toLower();
+ QString format = attributes[QLatin1String("format")].toLower();
TypeSystem::Language lang = languageNames.value(format, TypeSystem::NoLanguage);
if (lang == TypeSystem::NoLanguage) {
- m_error = QString("unsupported class attribute: '%1'").arg(format);
+ m_error = QStringLiteral("unsupported class attribute: '%1'").arg(format);
return false;
}
@@ -921,27 +927,27 @@ bool Handler::startElement(const QString &, const QString &n,
mod.format = lang;
m_contextStack.top()->docModifications << mod;
} else {
- m_error = "inject-documentation must be inside modify-function, "
- "modify-field or other tags that creates a type";
+ m_error = QLatin1String("inject-documentation must be inside modify-function, "
+ "modify-field or other tags that creates a type");
return false;
}
} else if (element->type == StackElement::ModifyDocumentation) {
// check the XML tag attributes
QHash<QString, QString> attributes;
- attributes["xpath"] = QString();
- attributes["since"] = QString("0");
+ attributes.insert(QLatin1String("xpath"), QString());
+ attributes.insert(QLatin1String("since"), QLatin1String("0"));
fetchAttributeValues(tagName, atts, &attributes);
- double since = attributes["since"].toDouble();
+ double since = attributes[QLatin1String("since")].toDouble();
const int validParent = StackElement::TypeEntryMask
| StackElement::ModifyFunction
| StackElement::ModifyField;
if (m_current->parent && m_current->parent->type & validParent) {
QString signature = (m_current->type & StackElement::TypeEntryMask) ? QString() : m_currentSignature;
- m_contextStack.top()->docModifications << DocModification(attributes["xpath"], signature, since);
+ m_contextStack.top()->docModifications << DocModification(attributes[QLatin1String("xpath")], signature, since);
} else {
- m_error = "modify-documentation must be inside modify-function, "
- "modify-field or other tags that creates a type";
+ m_error = QLatin1String("modify-documentation must be inside modify-function, "
+ "modify-field or other tags that creates a type");
return false;
}
} else if (element->type != StackElement::None) {
@@ -956,7 +962,7 @@ bool Handler::startElement(const QString &, const QString &n,
|| element->type == StackElement::Template;
if (!topLevel && m_current->type == StackElement::Root) {
- m_error = QString("Tag requires parent: '%1'").arg(tagName);
+ m_error = QStringLiteral("Tag requires parent: '%1'").arg(tagName);
return false;
}
@@ -964,127 +970,127 @@ bool Handler::startElement(const QString &, const QString &n,
element->entry = topElement.entry;
QHash<QString, QString> attributes;
- attributes["since"] = QString("0");
+ attributes.insert(QLatin1String("since"), QLatin1String("0"));
switch (element->type) {
case StackElement::Root:
- attributes["package"] = QString();
- attributes["default-superclass"] = QString();
+ attributes.insert(QLatin1String("package"), QString());
+ attributes.insert(QLatin1String("default-superclass"), QString());
break;
case StackElement::LoadTypesystem:
- attributes["name"] = QString();
- attributes["generate"] = "yes";
+ attributes.insert(QLatin1String("name"), QString());
+ attributes.insert(QLatin1String("generate"), QLatin1String("yes"));
break;
case StackElement::NoNullPointers:
- attributes["default-value"] = QString();
+ attributes.insert(QLatin1String("default-value"), QString());
break;
case StackElement::SuppressedWarning:
- attributes["text"] = QString();
+ attributes.insert(QLatin1String("text"), QString());
break;
case StackElement::ReplaceDefaultExpression:
- attributes["with"] = QString();
+ attributes.insert(QLatin1String("with"), QString());
break;
case StackElement::DefineOwnership:
- attributes["class"] = "target";
- attributes["owner"] = "";
+ attributes.insert(QLatin1String("class"), QLatin1String("target"));
+ attributes.insert(QLatin1String("owner"), QString());
break;
case StackElement::AddFunction:
- attributes["signature"] = QString();
- attributes["return-type"] = QString("void");
- attributes["access"] = QString("public");
- attributes["static"] = QString("no");
+ attributes.insert(QLatin1String("signature"), QString());
+ attributes.insert(QLatin1String("return-type"), QLatin1String("void"));
+ attributes.insert(QLatin1String("access"), QLatin1String("public"));
+ attributes.insert(QLatin1String("static"), QLatin1String("no"));
break;
case StackElement::ModifyFunction:
- attributes["signature"] = QString();
- attributes["access"] = QString();
- attributes["remove"] = QString();
- attributes["rename"] = QString();
- attributes["deprecated"] = QString("no");
- attributes["associated-to"] = QString();
- attributes["virtual-slot"] = QString("no");
- attributes["thread"] = QString("no");
- attributes["allow-thread"] = QString("no");
+ attributes.insert(QLatin1String("signature"), QString());
+ attributes.insert(QLatin1String("access"), QString());
+ attributes.insert(QLatin1String("remove"), QString());
+ attributes.insert(QLatin1String("rename"), QString());
+ attributes.insert(QLatin1String("deprecated"), QLatin1String("no"));
+ attributes.insert(QLatin1String("associated-to"), QString());
+ attributes.insert(QLatin1String("virtual-slot"), QLatin1String("no"));
+ attributes.insert(QLatin1String("thread"), QLatin1String("no"));
+ attributes.insert(QLatin1String("allow-thread"), QLatin1String("no"));
break;
case StackElement::ModifyArgument:
- attributes["index"] = QString();
- attributes["replace-value"] = QString();
- attributes["invalidate-after-use"] = QString("no");
+ attributes.insert(QLatin1String("index"), QString());
+ attributes.insert(QLatin1String("replace-value"), QString());
+ attributes.insert(QLatin1String("invalidate-after-use"), QLatin1String("no"));
break;
case StackElement::ModifyField:
- attributes["name"] = QString();
- attributes["write"] = "true";
- attributes["read"] = "true";
- attributes["remove"] = QString();
+ attributes.insert(QLatin1String("name"), QString());
+ attributes.insert(QLatin1String("write"), QLatin1String("true"));
+ attributes.insert(QLatin1String("read"), QLatin1String("true"));
+ attributes.insert(QLatin1String("remove"), QString());
break;
case StackElement::Access:
- attributes["modifier"] = QString();
+ attributes.insert(QLatin1String("modifier"), QString());
break;
case StackElement::Include:
- attributes["file-name"] = QString();
- attributes["location"] = QString();
+ attributes.insert(QLatin1String("file-name"), QString());
+ attributes.insert(QLatin1String("location"), QString());
break;
case StackElement::CustomMetaConstructor:
- attributes["name"] = topElement.entry->name().toLower() + "_create";
- attributes["param-name"] = "copy";
+ attributes[QLatin1String("name")] = topElement.entry->name().toLower() + QLatin1String("_create");
+ attributes.insert(QLatin1String("param-name"), QLatin1String("copy"));
break;
case StackElement::CustomMetaDestructor:
- attributes["name"] = topElement.entry->name().toLower() + "_delete";
- attributes["param-name"] = "copy";
+ attributes[QLatin1String("name")] = topElement.entry->name().toLower() + QLatin1String("_delete");
+ attributes.insert(QLatin1String("param-name"), QLatin1String("copy"));
break;
case StackElement::ReplaceType:
- attributes["modified-type"] = QString();
+ attributes.insert(QLatin1String("modified-type"), QString());
break;
case StackElement::InjectCode:
- attributes["class"] = "target";
- attributes["position"] = "beginning";
- attributes["file"] = QString();
+ attributes.insert(QLatin1String("class"), QLatin1String("target"));
+ attributes.insert(QLatin1String("position"), QLatin1String("beginning"));
+ attributes.insert(QLatin1String("file"), QString());
break;
case StackElement::ConversionRule:
- attributes["class"] = QString();
- attributes["file"] = QString();
+ attributes.insert(QLatin1String("class"), QString());
+ attributes.insert(QLatin1String("file"), QString());
break;
case StackElement::TargetToNative:
- attributes["replace"] = QString("yes");
+ attributes.insert(QLatin1String("replace"), QLatin1String("yes"));
break;
case StackElement::AddConversion:
- attributes["type"] = QString();
- attributes["check"] = QString();
+ attributes.insert(QLatin1String("type"), QString());
+ attributes.insert(QLatin1String("check"), QString());
break;
case StackElement::RejectEnumValue:
- attributes["name"] = "";
+ attributes.insert(QLatin1String("name"), QString());
break;
case StackElement::ArgumentMap:
- attributes["index"] = "1";
- attributes["meta-name"] = QString();
+ attributes.insert(QLatin1String("index"), QLatin1String("1"));
+ attributes.insert(QLatin1String("meta-name"), QString());
break;
case StackElement::Rename:
- attributes["to"] = QString();
+ attributes.insert(QLatin1String("to"), QString());
break;
case StackElement::Rejection:
- attributes["class"] = "*";
- attributes["function-name"] = "*";
- attributes["field-name"] = "*";
- attributes["enum-name"] = "*";
+ attributes.insert(QLatin1String("class"), QLatin1String("*"));
+ attributes.insert(QLatin1String("function-name"), QLatin1String("*"));
+ attributes.insert(QLatin1String("field-name"), QLatin1String("*"));
+ attributes.insert(QLatin1String("enum-name"), QLatin1String("*"));
break;
case StackElement::Removal:
- attributes["class"] = "all";
+ attributes.insert(QLatin1String("class"), QLatin1String("all"));
break;
case StackElement::Template:
- attributes["name"] = QString();
+ attributes.insert(QLatin1String("name"), QString());
break;
case StackElement::TemplateInstanceEnum:
- attributes["name"] = QString();
+ attributes.insert(QLatin1String("name"), QString());
break;
case StackElement::Replace:
- attributes["from"] = QString();
- attributes["to"] = QString();
+ attributes.insert(QLatin1String("from"), QString());
+ attributes.insert(QLatin1String("to"), QString());
break;
case StackElement::ReferenceCount:
- attributes["action"] = QString();
- attributes["variable-name"] = QString();
+ attributes.insert(QLatin1String("action"), QString());
+ attributes.insert(QLatin1String("variable-name"), QString());
break;
case StackElement::ParentOwner:
- attributes["index"] = QString();
- attributes["action"] = QString();
+ attributes.insert(QLatin1String("index"), QString());
+ attributes.insert(QLatin1String("action"), QString());
default:
{ };
};
@@ -1092,13 +1098,13 @@ bool Handler::startElement(const QString &, const QString &n,
double since = 0;
if (attributes.count() > 0) {
fetchAttributeValues(tagName, atts, &attributes);
- since = attributes["since"].toDouble();
+ since = attributes[QLatin1String("since")].toDouble();
}
switch (element->type) {
case StackElement::Root:
- m_defaultPackage = attributes["package"];
- m_defaultSuperclass = attributes["default-superclass"];
+ m_defaultPackage = attributes[QLatin1String("package")];
+ m_defaultSuperclass = attributes[QLatin1String("default-superclass")];
element->type = StackElement::Root;
{
TypeSystemTypeEntry* moduleEntry = reinterpret_cast<TypeSystemTypeEntry*>(
@@ -1108,44 +1114,44 @@ bool Handler::startElement(const QString &, const QString &n,
}
if ((m_generate == TypeEntry::GenerateForSubclass ||
- m_generate == TypeEntry::GenerateNothing) && m_defaultPackage != "")
+ m_generate == TypeEntry::GenerateNothing) && !m_defaultPackage.isEmpty())
TypeDatabase::instance()->addRequiredTargetImport(m_defaultPackage);
if (!element->entry->qualifiedCppName().isEmpty())
m_database->addType(element->entry);
break;
case StackElement::LoadTypesystem: {
- QString name = attributes["name"];
+ QString name = attributes[QLatin1String("name")];
if (name.isEmpty()) {
- m_error = "No typesystem name specified";
+ m_error = QLatin1String("No typesystem name specified");
return false;
}
- bool generateChild = (convertBoolean(attributes["generate"], "generate", true) && (m_generate == TypeEntry::GenerateAll));
+ bool generateChild = (convertBoolean(attributes[QLatin1String("generate")], QLatin1String("generate"), true) && (m_generate == TypeEntry::GenerateAll));
if (!m_database->parseFile(name, generateChild)) {
- m_error = QString("Failed to parse: '%1'").arg(name);
+ m_error = QStringLiteral("Failed to parse: '%1'").arg(name);
return false;
}
}
break;
case StackElement::RejectEnumValue: {
if (!m_currentEnum) {
- m_error = "<reject-enum-value> node must be used inside a <enum-type> node";
+ m_error = QLatin1String("<reject-enum-value> node must be used inside a <enum-type> node");
return false;
}
- QString name = attributes["name"];
+ QString name = attributes[QLatin1String("name")];
} break;
case StackElement::ReplaceType: {
if (topElement.type != StackElement::ModifyArgument) {
- m_error = "Type replacement can only be specified for argument modifications";
+ m_error = QLatin1String("Type replacement can only be specified for argument modifications");
return false;
}
- if (attributes["modified-type"].isEmpty()) {
- m_error = "Type replacement requires 'modified-type' attribute";
+ if (attributes[QLatin1String("modified-type")].isEmpty()) {
+ m_error = QLatin1String("Type replacement requires 'modified-type' attribute");
return false;
}
- m_contextStack.top()->functionMods.last().argument_mods.last().modified_type = attributes["modified-type"];
+ m_contextStack.top()->functionMods.last().argument_mods.last().modified_type = attributes[QLatin1String("modified-type")];
}
break;
case StackElement::ConversionRule: {
@@ -1153,23 +1159,23 @@ bool Handler::startElement(const QString &, const QString &n,
&& topElement.type != StackElement::ValueTypeEntry
&& topElement.type != StackElement::PrimitiveTypeEntry
&& topElement.type != StackElement::ContainerTypeEntry) {
- m_error = "Conversion rules can only be specified for argument modification, "
- "value-type, primitive-type or container-type conversion.";
+ m_error = QLatin1String("Conversion rules can only be specified for argument modification, "
+ "value-type, primitive-type or container-type conversion.");
return false;
}
static QHash<QString, TypeSystem::Language> languageNames;
if (languageNames.isEmpty()) {
- languageNames["target"] = TypeSystem::TargetLangCode;
- languageNames["native"] = TypeSystem::NativeCode;
+ languageNames[QLatin1String("target")] = TypeSystem::TargetLangCode;
+ languageNames[QLatin1String("native")] = TypeSystem::NativeCode;
}
- QString languageAttribute = attributes["class"].toLower();
+ QString languageAttribute = attributes[QLatin1String("class")].toLower();
TypeSystem::Language lang = languageNames.value(languageAttribute, TypeSystem::NoLanguage);
if (topElement.type == StackElement::ModifyArgument) {
if (lang == TypeSystem::NoLanguage) {
- m_error = QString("unsupported class attribute: '%1'").arg(lang);
+ m_error = QStringLiteral("unsupported class attribute: '%1'").arg(lang);
return false;
}
@@ -1178,13 +1184,13 @@ bool Handler::startElement(const QString &, const QString &n,
m_contextStack.top()->functionMods.last().argument_mods.last().conversion_rules.append(snip);
} else {
if (topElement.entry->hasConversionRule() || topElement.entry->hasCustomConversion()) {
- m_error = "Types can have only one conversion rule";
+ m_error = QLatin1String("Types can have only one conversion rule");
return false;
}
// The old conversion rule tag that uses a file containing the conversion
// will be kept temporarily for compatibility reasons.
- QString sourceFile = attributes["file"];
+ QString sourceFile = attributes[QLatin1String("file")];
if (!sourceFile.isEmpty()) {
if (m_generate != TypeEntry::GenerateForSubclass
&& m_generate != TypeEntry::GenerateNothing) {
@@ -1195,7 +1201,7 @@ bool Handler::startElement(const QString &, const QString &n,
QFile conversionSource(sourceFile);
if (conversionSource.open(QIODevice::ReadOnly | QIODevice::Text)) {
- topElement.entry->setConversionRule(conversionFlag + QString::fromUtf8(conversionSource.readAll()));
+ topElement.entry->setConversionRule(QLatin1String(conversionFlag) + QString::fromUtf8(conversionSource.readAll()));
} else {
qCWarning(lcShiboken).noquote().nospace()
<< "File containing conversion code for "
@@ -1212,7 +1218,7 @@ bool Handler::startElement(const QString &, const QString &n,
break;
case StackElement::NativeToTarget: {
if (topElement.type != StackElement::ConversionRule) {
- m_error = "Native to Target conversion code can only be specified for custom conversion rules.";
+ m_error = QLatin1String("Native to Target conversion code can only be specified for custom conversion rules.");
return false;
}
m_contextStack.top()->codeSnips << CodeSnip(0);
@@ -1220,24 +1226,24 @@ bool Handler::startElement(const QString &, const QString &n,
break;
case StackElement::TargetToNative: {
if (topElement.type != StackElement::ConversionRule) {
- m_error = "Target to Native conversions can only be specified for custom conversion rules.";
+ m_error = QLatin1String("Target to Native conversions can only be specified for custom conversion rules.");
return false;
}
- bool replace = attributes["replace"] == "yes";
+ bool replace = attributes[QLatin1String("replace")] == QLatin1String("yes");
static_cast<TypeEntry*>(m_current->entry)->customConversion()->setReplaceOriginalTargetToNativeConversions(replace);
}
break;
case StackElement::AddConversion: {
if (topElement.type != StackElement::TargetToNative) {
- m_error = "Target to Native conversions can only be added inside 'target-to-native' tags.";
+ m_error = QLatin1String("Target to Native conversions can only be added inside 'target-to-native' tags.");
return false;
}
- QString sourceTypeName = attributes["type"];
+ QString sourceTypeName = attributes[QLatin1String("type")];
if (sourceTypeName.isEmpty()) {
- m_error = "Target to Native conversions must specify the input type with the 'type' attribute.";
+ m_error = QLatin1String("Target to Native conversions must specify the input type with the 'type' attribute.");
return false;
}
- QString typeCheck = attributes["check"];
+ QString typeCheck = attributes[QLatin1String("check")];
static_cast<TypeEntry*>(m_current->entry)->customConversion()->addTargetToNativeConversion(sourceTypeName, typeCheck);
m_contextStack.top()->codeSnips << CodeSnip(0);
}
@@ -1251,76 +1257,76 @@ bool Handler::startElement(const QString &, const QString &n,
return false;
}
- QString index = attributes["index"];
- if (index == "return")
- index = "0";
- else if (index == "this")
- index = "-1";
+ QString index = attributes[QLatin1String("index")];
+ if (index == QLatin1String("return"))
+ index = QLatin1String("0");
+ else if (index == QLatin1String("this"))
+ index = QLatin1String("-1");
bool ok = false;
int idx = index.toInt(&ok);
if (!ok) {
- m_error = QString("Cannot convert '%1' to integer").arg(index);
+ m_error = QStringLiteral("Cannot convert '%1' to integer").arg(index);
return false;
}
- QString replace_value = attributes["replace-value"];
+ QString replace_value = attributes[QLatin1String("replace-value")];
if (!replace_value.isEmpty() && idx) {
- m_error = QString("replace-value is only supported for return values (index=0).");
+ m_error = QLatin1String("replace-value is only supported for return values (index=0).");
return false;
}
ArgumentModification argumentModification = ArgumentModification(idx, since);
argumentModification.replace_value = replace_value;
- argumentModification.resetAfterUse = convertBoolean(attributes["invalidate-after-use"], "invalidate-after-use", false);
+ argumentModification.resetAfterUse = convertBoolean(attributes[QLatin1String("invalidate-after-use")], QLatin1String("invalidate-after-use"), false);
m_contextStack.top()->functionMods.last().argument_mods.append(argumentModification);
}
break;
case StackElement::NoNullPointers: {
if (topElement.type != StackElement::ModifyArgument) {
- m_error = "no-null-pointer requires argument modification as parent";
+ m_error = QLatin1String("no-null-pointer requires argument modification as parent");
return false;
}
m_contextStack.top()->functionMods.last().argument_mods.last().noNullPointers = true;
if (!m_contextStack.top()->functionMods.last().argument_mods.last().index)
- m_contextStack.top()->functionMods.last().argument_mods.last().nullPointerDefaultValue = attributes["default-value"];
- else if (!attributes["default-value"].isEmpty())
+ m_contextStack.top()->functionMods.last().argument_mods.last().nullPointerDefaultValue = attributes[QLatin1String("default-value")];
+ else if (!attributes[QLatin1String("default-value")].isEmpty())
qCWarning(lcShiboken) << "default values for null pointer guards are only effective for return values";
}
break;
case StackElement::DefineOwnership: {
if (topElement.type != StackElement::ModifyArgument) {
- m_error = "define-ownership requires argument modification as parent";
+ m_error = QLatin1String("define-ownership requires argument modification as parent");
return false;
}
static QHash<QString, TypeSystem::Language> languageNames;
if (languageNames.isEmpty()) {
- languageNames["target"] = TypeSystem::TargetLangCode;
- languageNames["native"] = TypeSystem::NativeCode;
+ languageNames[QLatin1String("target")] = TypeSystem::TargetLangCode;
+ languageNames[QLatin1String("native")] = TypeSystem::NativeCode;
}
- QString classAttribute = attributes["class"].toLower();
+ QString classAttribute = attributes[QLatin1String("class")].toLower();
TypeSystem::Language lang = languageNames.value(classAttribute, TypeSystem::NoLanguage);
if (lang == TypeSystem::NoLanguage) {
- m_error = QString("unsupported class attribute: '%1'").arg(classAttribute);
+ m_error = QStringLiteral("unsupported class attribute: '%1'").arg(classAttribute);
return false;
}
static QHash<QString, TypeSystem::Ownership> ownershipNames;
if (ownershipNames.isEmpty()) {
- ownershipNames["target"] = TypeSystem::TargetLangOwnership;
- ownershipNames["c++"] = TypeSystem::CppOwnership;
- ownershipNames["default"] = TypeSystem::DefaultOwnership;
+ ownershipNames[QLatin1String("target")] = TypeSystem::TargetLangOwnership;
+ ownershipNames[QLatin1String("c++")] = TypeSystem::CppOwnership;
+ ownershipNames[QLatin1String("default")] = TypeSystem::DefaultOwnership;
}
- QString ownershipAttribute = attributes["owner"].toLower();
+ QString ownershipAttribute = attributes[QLatin1String("owner")].toLower();
TypeSystem::Ownership owner = ownershipNames.value(ownershipAttribute, TypeSystem::InvalidOwnership);
if (owner == TypeSystem::InvalidOwnership) {
- m_error = QString("unsupported owner attribute: '%1'").arg(ownershipAttribute);
+ m_error = QStringLiteral("unsupported owner attribute: '%1'").arg(ownershipAttribute);
return false;
}
@@ -1328,31 +1334,31 @@ bool Handler::startElement(const QString &, const QString &n,
}
break;
case StackElement::SuppressedWarning:
- if (attributes["text"].isEmpty())
+ if (attributes[QLatin1String("text")].isEmpty())
qCWarning(lcShiboken) << "Suppressed warning with no text specified";
else
- m_database->addSuppressedWarning(attributes["text"]);
+ m_database->addSuppressedWarning(attributes[QLatin1String("text")]);
break;
case StackElement::ArgumentMap: {
if (!(topElement.type & StackElement::CodeSnipMask)) {
- m_error = "Argument maps requires code injection as parent";
+ m_error = QLatin1String("Argument maps requires code injection as parent");
return false;
}
bool ok;
- int pos = attributes["index"].toInt(&ok);
+ int pos = attributes[QLatin1String("index")].toInt(&ok);
if (!ok) {
- m_error = QString("Can't convert position '%1' to integer")
- .arg(attributes["position"]);
+ m_error = QStringLiteral("Can't convert position '%1' to integer")
+ .arg(attributes[QLatin1String("position")]);
return false;
}
if (pos <= 0) {
- m_error = QString("Argument position %1 must be a positive number").arg(pos);
+ m_error = QStringLiteral("Argument position %1 must be a positive number").arg(pos);
return false;
}
- QString meta_name = attributes["meta-name"];
+ QString meta_name = attributes[QLatin1String("meta-name")];
if (meta_name.isEmpty())
qCWarning(lcShiboken) << "Empty meta name in argument map";
@@ -1367,20 +1373,20 @@ bool Handler::startElement(const QString &, const QString &n,
break;
case StackElement::Removal: {
if (topElement.type != StackElement::ModifyFunction) {
- m_error = "Function modification parent required";
+ m_error = QLatin1String("Function modification parent required");
return false;
}
static QHash<QString, TypeSystem::Language> languageNames;
if (languageNames.isEmpty()) {
- languageNames["target"] = TypeSystem::TargetLangAndNativeCode;
- languageNames["all"] = TypeSystem::All;
+ languageNames.insert(QLatin1String("target"), TypeSystem::TargetLangAndNativeCode);
+ languageNames.insert(QLatin1String("all"), TypeSystem::All);
}
- QString languageAttribute = attributes["class"].toLower();
+ QString languageAttribute = attributes[QLatin1String("class")].toLower();
TypeSystem::Language lang = languageNames.value(languageAttribute, TypeSystem::NoLanguage);
if (lang == TypeSystem::NoLanguage) {
- m_error = QString("unsupported class attribute: '%1'").arg(languageAttribute);
+ m_error = QStringLiteral("unsupported class attribute: '%1'").arg(languageAttribute);
return false;
}
@@ -1392,7 +1398,7 @@ bool Handler::startElement(const QString &, const QString &n,
if (topElement.type != StackElement::ModifyField
&& topElement.type != StackElement::ModifyFunction
&& topElement.type != StackElement::ModifyArgument) {
- m_error = "Function, field or argument modification parent required";
+ m_error = QLatin1String("Function, field or argument modification parent required");
return false;
}
@@ -1404,10 +1410,10 @@ bool Handler::startElement(const QString &, const QString &n,
QString modifier;
if (element->type == StackElement::Rename) {
- modifier = "rename";
- QString renamed_to = attributes["to"];
+ modifier = QLatin1String("rename");
+ QString renamed_to = attributes[QLatin1String("to")];
if (renamed_to.isEmpty()) {
- m_error = "Rename modifier requires 'to' attribute";
+ m_error = QLatin1String("Rename modifier requires 'to' attribute");
return false;
}
@@ -1418,27 +1424,27 @@ bool Handler::startElement(const QString &, const QString &n,
else
m_contextStack.top()->functionMods.last().argument_mods.last().renamed_to = renamed_to;
} else
- modifier = attributes["modifier"].toLower();
+ modifier = attributes[QLatin1String("modifier")].toLower();
if (modifier.isEmpty()) {
- m_error = "No access modification specified";
+ m_error = QLatin1String("No access modification specified");
return false;
}
static QHash<QString, FunctionModification::Modifiers> modifierNames;
if (modifierNames.isEmpty()) {
- modifierNames["private"] = Modification::Private;
- modifierNames["public"] = Modification::Public;
- modifierNames["protected"] = Modification::Protected;
- modifierNames["friendly"] = Modification::Friendly;
- modifierNames["rename"] = Modification::Rename;
- modifierNames["final"] = Modification::Final;
- modifierNames["non-final"] = Modification::NonFinal;
+ modifierNames[QLatin1String("private")] = Modification::Private;
+ modifierNames[QLatin1String("public")] = Modification::Public;
+ modifierNames[QLatin1String("protected")] = Modification::Protected;
+ modifierNames[QLatin1String("friendly")] = Modification::Friendly;
+ modifierNames[QLatin1String("rename")] = Modification::Rename;
+ modifierNames[QLatin1String("final")] = Modification::Final;
+ modifierNames[QLatin1String("non-final")] = Modification::NonFinal;
}
if (!modifierNames.contains(modifier)) {
- m_error = QString("Unknown access modifier: '%1'").arg(modifier);
+ m_error = QStringLiteral("Unknown access modifier: '%1'").arg(modifier);
return false;
}
@@ -1448,7 +1454,7 @@ bool Handler::startElement(const QString &, const QString &n,
break;
case StackElement::RemoveArgument:
if (topElement.type != StackElement::ModifyArgument) {
- m_error = "Removing argument requires argument modification as parent";
+ m_error = QLatin1String("Removing argument requires argument modification as parent");
return false;
}
@@ -1456,21 +1462,21 @@ bool Handler::startElement(const QString &, const QString &n,
break;
case StackElement::ModifyField: {
- QString name = attributes["name"];
+ QString name = attributes[QLatin1String("name")];
if (name.isEmpty())
break;
FieldModification fm;
fm.name = name;
fm.modifiers = 0;
- if (!convertRemovalAttribute(attributes["remove"], fm, m_error))
+ if (!convertRemovalAttribute(attributes[QLatin1String("remove")], fm, m_error))
return false;
- QString read = attributes["read"];
- QString write = attributes["write"];
+ QString read = attributes[QLatin1String("read")];
+ QString write = attributes[QLatin1String("write")];
- if (read == "true") fm.modifiers |= FieldModification::Readable;
- if (write == "true") fm.modifiers |= FieldModification::Writable;
+ if (read == QLatin1String("true")) fm.modifiers |= FieldModification::Readable;
+ if (write == QLatin1String("true")) fm.modifiers |= FieldModification::Writable;
m_contextStack.top()->fieldMods << fm;
}
@@ -1481,27 +1487,27 @@ bool Handler::startElement(const QString &, const QString &n,
", was=%1").arg(topElement.type, 0, 16);
return false;
}
- QString signature = attributes["signature"];
+ QString signature = attributes[QLatin1String("signature")];
signature = TypeDatabase::normalizedSignature(signature.toLocal8Bit().constData());
if (signature.isEmpty()) {
- m_error = "No signature for the added function";
+ m_error = QLatin1String("No signature for the added function");
return false;
}
- QString errorString = checkSignatureError(signature, "add-function");
+ QString errorString = checkSignatureError(signature, QLatin1String("add-function"));
if (!errorString.isEmpty()) {
m_error = errorString;
return false;
}
- AddedFunction func(signature, attributes["return-type"], since);
- func.setStatic(attributes["static"] == "yes");
- if (!signature.contains("("))
- signature += "()";
+ AddedFunction func(signature, attributes[QLatin1String("return-type")], since);
+ func.setStatic(attributes[QLatin1String("static")] == QLatin1String("yes"));
+ if (!signature.contains(QLatin1Char('(')))
+ signature += QLatin1String("()");
m_currentSignature = signature;
- QString access = attributes["access"].toLower();
+ QString access = attributes[QLatin1String("access")].toLower();
if (!access.isEmpty()) {
if (access == QLatin1String("protected")) {
func.setAccess(AddedFunction::Protected);
@@ -1526,15 +1532,15 @@ bool Handler::startElement(const QString &, const QString &n,
", was=%1").arg(topElement.type, 0, 16);
return false;
}
- QString signature = attributes["signature"];
+ QString signature = attributes[QLatin1String("signature")];
signature = TypeDatabase::normalizedSignature(signature.toLocal8Bit().constData());
if (signature.isEmpty()) {
- m_error = "No signature for modified function";
+ m_error = QLatin1String("No signature for modified function");
return false;
}
- QString errorString = checkSignatureError(signature, "modify-function");
+ QString errorString = checkSignatureError(signature, QLatin1String("modify-function"));
if (!errorString.isEmpty()) {
m_error = errorString;
return false;
@@ -1543,7 +1549,7 @@ bool Handler::startElement(const QString &, const QString &n,
FunctionModification mod(since);
m_currentSignature = mod.signature = signature;
- QString access = attributes["access"].toLower();
+ QString access = attributes[QLatin1String("access")].toLower();
if (!access.isEmpty()) {
if (access == QLatin1String("private"))
mod.modifiers |= Modification::Private;
@@ -1561,56 +1567,56 @@ bool Handler::startElement(const QString &, const QString &n,
}
}
- if (convertBoolean(attributes["deprecated"], "deprecated", false))
+ if (convertBoolean(attributes[QLatin1String("deprecated")], QLatin1String("deprecated"), false))
mod.modifiers |= Modification::Deprecated;
- if (!convertRemovalAttribute(attributes["remove"], mod, m_error))
+ if (!convertRemovalAttribute(attributes[QLatin1String("remove")], mod, m_error))
return false;
- QString rename = attributes["rename"];
+ QString rename = attributes[QLatin1String("rename")];
if (!rename.isEmpty()) {
mod.renamedToName = rename;
mod.modifiers |= Modification::Rename;
}
- QString association = attributes["associated-to"];
+ QString association = attributes[QLatin1String("associated-to")];
if (!association.isEmpty())
mod.association = association;
- mod.setIsThread(convertBoolean(attributes["thread"], "thread", false));
- mod.setAllowThread(convertBoolean(attributes["allow-thread"], "allow-thread", false));
+ mod.setIsThread(convertBoolean(attributes[QLatin1String("thread")], QLatin1String("thread"), false));
+ mod.setAllowThread(convertBoolean(attributes[QLatin1String("allow-thread")], QLatin1String("allow-thread"), false));
- mod.modifiers |= (convertBoolean(attributes["virtual-slot"], "virtual-slot", false) ? Modification::VirtualSlot : 0);
+ mod.modifiers |= (convertBoolean(attributes[QLatin1String("virtual-slot")], QLatin1String("virtual-slot"), false) ? Modification::VirtualSlot : 0);
m_contextStack.top()->functionMods << mod;
}
break;
case StackElement::ReplaceDefaultExpression:
if (!(topElement.type & StackElement::ModifyArgument)) {
- m_error = "Replace default expression only allowed as child of argument modification";
+ m_error = QLatin1String("Replace default expression only allowed as child of argument modification");
return false;
}
- if (attributes["with"].isEmpty()) {
- m_error = "Default expression replaced with empty string. Use remove-default-expression instead.";
+ if (attributes[QLatin1String("with")].isEmpty()) {
+ m_error = QLatin1String("Default expression replaced with empty string. Use remove-default-expression instead.");
return false;
}
- m_contextStack.top()->functionMods.last().argument_mods.last().replacedDefaultExpression = attributes["with"];
+ m_contextStack.top()->functionMods.last().argument_mods.last().replacedDefaultExpression = attributes[QLatin1String("with")];
break;
case StackElement::RemoveDefaultExpression:
m_contextStack.top()->functionMods.last().argument_mods.last().removedDefaultExpression = true;
break;
case StackElement::CustomMetaConstructor:
case StackElement::CustomMetaDestructor: {
- CustomFunction *func = new CustomFunction(attributes["name"]);
- func->paramName = attributes["param-name"];
+ CustomFunction *func = new CustomFunction(attributes[QLatin1String("name")]);
+ func->paramName = attributes[QLatin1String("param-name")];
element->value.customFunction = func;
}
break;
case StackElement::ReferenceCount: {
if (topElement.type != StackElement::ModifyArgument) {
- m_error = "reference-count must be child of modify-argument";
+ m_error = QLatin1String("reference-count must be child of modify-argument");
return false;
}
@@ -1618,19 +1624,19 @@ bool Handler::startElement(const QString &, const QString &n,
static QHash<QString, ReferenceCount::Action> actions;
if (actions.isEmpty()) {
- actions["add"] = ReferenceCount::Add;
- actions["add-all"] = ReferenceCount::AddAll;
- actions["remove"] = ReferenceCount::Remove;
- actions["set"] = ReferenceCount::Set;
- actions["ignore"] = ReferenceCount::Ignore;
+ actions[QLatin1String("add")] = ReferenceCount::Add;
+ actions[QLatin1String("add-all")] = ReferenceCount::AddAll;
+ actions[QLatin1String("remove")] = ReferenceCount::Remove;
+ actions[QLatin1String("set")] = ReferenceCount::Set;
+ actions[QLatin1String("ignore")] = ReferenceCount::Ignore;
}
- rc.action = actions.value(attributes["action"].toLower(), ReferenceCount::Invalid);
- rc.varName = attributes["variable-name"];
+ rc.action = actions.value(attributes[QLatin1String("action")].toLower(), ReferenceCount::Invalid);
+ rc.varName = attributes[QLatin1String("variable-name")];
if (rc.action == ReferenceCount::Invalid) {
- m_error = "unrecognized value for action attribute. supported actions:";
+ m_error = QLatin1String("unrecognized value for action attribute. supported actions:");
foreach (QString action, actions.keys())
- m_error += " " + action;
+ m_error += QLatin1Char(' ') + action;
}
m_contextStack.top()->functionMods.last().argument_mods.last().referenceCounts.append(rc);
@@ -1639,34 +1645,34 @@ bool Handler::startElement(const QString &, const QString &n,
case StackElement::ParentOwner: {
if (topElement.type != StackElement::ModifyArgument) {
- m_error = "parent-policy must be child of modify-argument";
+ m_error = QLatin1String("parent-policy must be child of modify-argument");
return false;
}
ArgumentOwner ao;
- QString index = attributes["index"];
- if (index == "return")
- index = "0";
- else if (index == "this")
- index = "-1";
+ QString index = attributes[QLatin1String("index")];
+ if (index == QLatin1String("return"))
+ index = QLatin1String("0");
+ else if (index == QLatin1String("this"))
+ index = QLatin1String("-1");
bool ok = false;
int idx = index.toInt(&ok);
if (!ok) {
- m_error = QString("Cannot convert '%1' to integer").arg(index);
+ m_error = QStringLiteral("Cannot convert '%1' to integer").arg(index);
return false;
}
static QHash<QString, ArgumentOwner::Action> actions;
if (actions.isEmpty()) {
- actions["add"] = ArgumentOwner::Add;
- actions["remove"] = ArgumentOwner::Remove;
+ actions[QLatin1String("add")] = ArgumentOwner::Add;
+ actions[QLatin1String("remove")] = ArgumentOwner::Remove;
}
- ao.action = actions.value(attributes["action"].toLower(), ArgumentOwner::Invalid);
+ ao.action = actions.value(attributes[QLatin1String("action")].toLower(), ArgumentOwner::Invalid);
if (!ao.action) {
- m_error = QString("Invalid parent actionr");
+ m_error = QLatin1String("Invalid parent actionr");
return false;
}
ao.index = idx;
@@ -1680,43 +1686,43 @@ bool Handler::startElement(const QString &, const QString &n,
&& (topElement.type != StackElement::AddFunction)
&& (topElement.type != StackElement::ModifyFunction)
&& (topElement.type != StackElement::Root)) {
- m_error = "wrong parent type for code injection";
+ m_error = QLatin1String("wrong parent type for code injection");
return false;
}
static QHash<QString, TypeSystem::Language> languageNames;
if (languageNames.isEmpty()) {
- languageNames["target"] = TypeSystem::TargetLangCode; // em algum lugar do cpp
- languageNames["native"] = TypeSystem::NativeCode; // em algum lugar do cpp
- languageNames["shell"] = TypeSystem::ShellCode; // coloca no header, mas antes da declaracao da classe
- languageNames["shell-declaration"] = TypeSystem::ShellDeclaration; // coloca no header, dentro da declaracao da classe
- languageNames["library-initializer"] = TypeSystem::PackageInitializer;
- languageNames["destructor-function"] = TypeSystem::DestructorFunction;
- languageNames["constructors"] = TypeSystem::Constructors;
- languageNames["interface"] = TypeSystem::Interface;
+ languageNames[QLatin1String("target")] = TypeSystem::TargetLangCode; // em algum lugar do cpp
+ languageNames[QLatin1String("native")] = TypeSystem::NativeCode; // em algum lugar do cpp
+ languageNames[QLatin1String("shell")] = TypeSystem::ShellCode; // coloca no header, mas antes da declaracao da classe
+ languageNames[QLatin1String("shell-declaration")] = TypeSystem::ShellDeclaration; // coloca no header, dentro da declaracao da classe
+ languageNames[QLatin1String("library-initializer")] = TypeSystem::PackageInitializer;
+ languageNames[QLatin1String("destructor-function")] = TypeSystem::DestructorFunction;
+ languageNames[QLatin1String("constructors")] = TypeSystem::Constructors;
+ languageNames[QLatin1String("interface")] = TypeSystem::Interface;
}
- QString className = attributes["class"].toLower();
+ QString className = attributes[QLatin1String("class")].toLower();
if (!languageNames.contains(className)) {
- m_error = QString("Invalid class specifier: '%1'").arg(className);
+ m_error = QStringLiteral("Invalid class specifier: '%1'").arg(className);
return false;
}
static QHash<QString, CodeSnip::Position> positionNames;
if (positionNames.isEmpty()) {
- positionNames["beginning"] = CodeSnip::Beginning;
- positionNames["end"] = CodeSnip::End;
+ positionNames[QLatin1String("beginning")] = CodeSnip::Beginning;
+ positionNames[QLatin1String("end")] = CodeSnip::End;
// QtScript
- positionNames["declaration"] = CodeSnip::Declaration;
- positionNames["prototype-initialization"] = CodeSnip::PrototypeInitialization;
- positionNames["constructor-initialization"] = CodeSnip::ConstructorInitialization;
- positionNames["constructor"] = CodeSnip::Constructor;
+ positionNames[QLatin1String("declaration")] = CodeSnip::Declaration;
+ positionNames[QLatin1String("prototype-initialization")] = CodeSnip::PrototypeInitialization;
+ positionNames[QLatin1String("constructor-initialization")] = CodeSnip::ConstructorInitialization;
+ positionNames[QLatin1String("constructor")] = CodeSnip::Constructor;
}
- QString position = attributes["position"].toLower();
+ QString position = attributes[QLatin1String("position")].toLower();
if (!positionNames.contains(position)) {
- m_error = QString("Invalid position: '%1'").arg(position);
+ m_error = QStringLiteral("Invalid position: '%1'").arg(position);
return false;
}
@@ -1725,7 +1731,7 @@ bool Handler::startElement(const QString &, const QString &n,
snip.position = positionNames[position];
bool in_file = false;
- QString file_name = attributes["file"];
+ QString file_name = attributes[QLatin1String("file")];
//Handler constructor....
if (m_generate != TypeEntry::GenerateForSubclass &&
@@ -1734,11 +1740,14 @@ bool Handler::startElement(const QString &, const QString &n,
if (QFile::exists(file_name)) {
QFile codeFile(file_name);
if (codeFile.open(QIODevice::Text | QIODevice::ReadOnly)) {
- QString content = QString::fromUtf8(codeFile.readAll());
- content.prepend("// ========================================================================\n"
- "// START of custom code block [file: " + file_name + "]\n");
- content.append("\n// END of custom code block [file: " + file_name + "]\n"
- "// ========================================================================\n");
+ QString content = QLatin1String("// ========================================================================\n"
+ "// START of custom code block [file: ");
+ content += file_name;
+ content += QLatin1String("]\n");
+ content += QString::fromUtf8(codeFile.readAll());
+ content += QLatin1String("\n// END of custom code block [file: ");
+ content += file_name;
+ content += QLatin1String("]\n// ========================================================================\n");
snip.addCode(content);
in_file = true;
}
@@ -1750,14 +1759,14 @@ bool Handler::startElement(const QString &, const QString &n,
}
if (snip.language == TypeSystem::Interface && topElement.type != StackElement::InterfaceTypeEntry) {
- m_error = "Interface code injections must be direct child of an interface type entry";
+ m_error = QLatin1String("Interface code injections must be direct child of an interface type entry");
return false;
}
if (topElement.type == StackElement::ModifyFunction || topElement.type == StackElement::AddFunction) {
FunctionModification mod = m_contextStack.top()->functionMods.last();
if (snip.language == TypeSystem::ShellDeclaration) {
- m_error = "no function implementation in shell declaration in which to inject code";
+ m_error = QLatin1String("no function implementation in shell declaration in which to inject code");
return false;
}
@@ -1774,22 +1783,22 @@ bool Handler::startElement(const QString &, const QString &n,
}
break;
case StackElement::Include: {
- QString location = attributes["location"].toLower();
+ QString location = attributes[QLatin1String("location")].toLower();
static QHash<QString, Include::IncludeType> locationNames;
if (locationNames.isEmpty()) {
- locationNames["global"] = Include::IncludePath;
- locationNames["local"] = Include::LocalPath;
- locationNames["target"] = Include::TargetLangImport;
+ locationNames[QLatin1String("global")] = Include::IncludePath;
+ locationNames[QLatin1String("local")] = Include::LocalPath;
+ locationNames[QLatin1String("target")] = Include::TargetLangImport;
}
if (!locationNames.contains(location)) {
- m_error = QString("Location not recognized: '%1'").arg(location);
+ m_error = QStringLiteral("Location not recognized: '%1'").arg(location);
return false;
}
Include::IncludeType loc = locationNames[location];
- Include inc(loc, attributes["file-name"]);
+ Include inc(loc, attributes[QLatin1String("file-name")]);
ComplexTypeEntry *ctype = static_cast<ComplexTypeEntry *>(element->entry);
if (topElement.type & (StackElement::ComplexTypeEntryMask | StackElement::PrimitiveTypeEntry)) {
@@ -1797,7 +1806,7 @@ bool Handler::startElement(const QString &, const QString &n,
} else if (topElement.type == StackElement::ExtraIncludes) {
element->entry->addExtraInclude(inc);
} else {
- m_error = "Only supported parent tags are primitive-type, complex types or extra-includes";
+ m_error = QLatin1String("Only supported parent tags are primitive-type, complex types or extra-includes");
return false;
}
@@ -1811,20 +1820,20 @@ bool Handler::startElement(const QString &, const QString &n,
}
break;
case StackElement::Rejection: {
- QString cls = attributes["class"];
- QString function = attributes["function-name"];
- QString field = attributes["field-name"];
- QString enum_ = attributes["enum-name"];
- if (cls == "*" && function == "*" && field == "*" && enum_ == "*") {
- m_error = "bad reject entry, neither 'class', 'function-name' nor "
- "'field' specified";
+ QString cls = attributes[QLatin1String("class")];
+ QString function = attributes[QLatin1String("function-name")];
+ QString field = attributes[QLatin1String("field-name")];
+ QString enum_ = attributes[QLatin1String("enum-name")];
+ if (cls == QLatin1String("*") && function == QLatin1String("*") && field == QLatin1String("*") && enum_ == QLatin1String("*")) {
+ m_error = QLatin1String("bad reject entry, neither 'class', 'function-name' nor "
+ "'field' specified");
return false;
}
m_database->addRejection(cls, function, field, enum_);
}
break;
case StackElement::Template:
- element->value.templateEntry = new TemplateEntry(attributes["name"], since);
+ element->value.templateEntry = new TemplateEntry(attributes[QLatin1String("name")], since);
break;
case StackElement::TemplateInstanceEnum:
if (!(topElement.type & StackElement::CodeSnipMask) &&
@@ -1834,18 +1843,18 @@ bool Handler::startElement(const QString &, const QString &n,
(topElement.type != StackElement::NativeToTarget) &&
(topElement.type != StackElement::AddConversion) &&
(topElement.type != StackElement::ConversionRule)) {
- m_error = "Can only insert templates into code snippets, templates, custom-constructors, "\
- "custom-destructors, conversion-rule, native-to-target or add-conversion tags.";
+ m_error = QLatin1String("Can only insert templates into code snippets, templates, custom-constructors, "\
+ "custom-destructors, conversion-rule, native-to-target or add-conversion tags.");
return false;
}
- element->value.templateInstance = new TemplateInstance(attributes["name"], since);
+ element->value.templateInstance = new TemplateInstance(attributes[QLatin1String("name")], since);
break;
case StackElement::Replace:
if (topElement.type != StackElement::TemplateInstanceEnum) {
- m_error = "Can only insert replace rules into insert-template.";
+ m_error = QLatin1String("Can only insert replace rules into insert-template.");
return false;
}
- element->parent->value.templateInstance->addReplaceRule(attributes["from"], attributes["to"]);
+ element->parent->value.templateInstance->addReplaceRule(attributes[QLatin1String("from")], attributes[QLatin1String("to")]);
break;
default:
break; // nada
@@ -1889,10 +1898,10 @@ CodeSnipList TypeEntry::codeSnips() const
QString Modification::accessModifierString() const
{
- if (isPrivate()) return "private";
- if (isProtected()) return "protected";
- if (isPublic()) return "public";
- if (isFriendly()) return "friendly";
+ if (isPrivate()) return QLatin1String("private");
+ if (isProtected()) return QLatin1String("protected");
+ if (isPublic()) return QLatin1String("public");
+ if (isFriendly()) return QLatin1String("friendly");
return QString();
}
@@ -1947,18 +1956,18 @@ QString ContainerTypeEntry::targetLangName() const
{
switch (m_type) {
- case StringListContainer: return "QStringList";
- case ListContainer: return "QList";
- case LinkedListContainer: return "QLinkedList";
- case VectorContainer: return "QVector";
- case StackContainer: return "QStack";
- case QueueContainer: return "QQueue";
- case SetContainer: return "QSet";
- case MapContainer: return "QMap";
- case MultiMapContainer: return "QMultiMap";
- case HashContainer: return "QHash";
- case MultiHashContainer: return "QMultiHash";
- case PairContainer: return "QPair";
+ case StringListContainer: return QLatin1String("QStringList");
+ case ListContainer: return QLatin1String("QList");
+ case LinkedListContainer: return QLatin1String("QLinkedList");
+ case VectorContainer: return QLatin1String("QVector");
+ case StackContainer: return QLatin1String("QStack");
+ case QueueContainer: return QLatin1String("QQueue");
+ case SetContainer: return QLatin1String("QSet");
+ case MapContainer: return QLatin1String("QMap");
+ case MultiMapContainer: return QLatin1String("QMultiMap");
+ case HashContainer: return QLatin1String("QHash");
+ case MultiHashContainer: return QLatin1String("QMultiHash");
+ case PairContainer: return QLatin1String("QPair");
default:
qWarning("bad type... %d", m_type);
break;
@@ -1969,7 +1978,7 @@ QString ContainerTypeEntry::targetLangName() const
QString ContainerTypeEntry::qualifiedCppName() const
{
if (m_type == StringListContainer)
- return "QStringList";
+ return QLatin1String("QStringList");
return ComplexTypeEntry::qualifiedCppName();
}
@@ -1984,12 +1993,12 @@ QString EnumTypeEntry::targetLangQualifier() const
QString EnumTypeEntry::targetLangApiName() const
{
- return "jint";
+ return QLatin1String("jint");
}
QString FlagsTypeEntry::targetLangApiName() const
{
- return "jint";
+ return QLatin1String("jint");
}
void EnumTypeEntry::addEnumValueRedirection(const QString &rejected, const QString &usedValue)
@@ -2007,7 +2016,8 @@ QString EnumTypeEntry::enumValueRedirection(const QString &value) const
QString FlagsTypeEntry::qualifiedTargetLangName() const
{
- return targetLangPackage() + "." + m_enum->targetLangQualifier() + "." + targetLangName();
+ return targetLangPackage() + QLatin1Char('.') + m_enum->targetLangQualifier()
+ + QLatin1Char('.') + targetLangName();
}
/*!
@@ -2016,8 +2026,10 @@ QString FlagsTypeEntry::qualifiedTargetLangName() const
*/
QString fixCppTypeName(const QString &name)
{
- if (name == "long long") return "qint64";
- else if (name == "unsigned long long") return "quint64";
+ if (name == QLatin1String("long long"))
+ return QLatin1String("qint64");
+ else if (name == QLatin1String("unsigned long long"))
+ return QLatin1String("quint64");
return name;
}
@@ -2029,7 +2041,8 @@ QString TemplateInstance::expandCode() const
foreach (QString key, replaceRules.keys())
res.replace(key, replaceRules[key]);
- return "// TEMPLATE - " + m_name + " - START" + res + "// TEMPLATE - " + m_name + " - END";
+ return QLatin1String("// TEMPLATE - ") + m_name + QLatin1String(" - START")
+ + res + QLatin1String("// TEMPLATE - ") + m_name + QLatin1String(" - END");
} else {
qCWarning(lcShiboken).noquote().nospace()
<< "insert-template referring to non-existing template '" << m_name << '\'';
@@ -2124,14 +2137,14 @@ bool FunctionModification::operator==(const FunctionModification& other) const
static AddedFunction::TypeInfo parseType(const QString& signature, int startPos = 0, int* endPos = 0)
{
AddedFunction::TypeInfo result;
- QRegExp regex("\\w");
+ QRegExp regex(QLatin1String("\\w"));
int length = signature.length();
int start = signature.indexOf(regex, startPos);
if (start == -1) {
- if (signature.mid(startPos + 1, 3) == "...") { // varargs
+ if (signature.midRef(startPos + 1, 3) == QLatin1String("...")) { // varargs
if (endPos)
*endPos = startPos + 4;
- result.name = "...";
+ result.name = QLatin1String("...");
} else { // error
if (endPos)
*endPos = length;
@@ -2145,13 +2158,13 @@ static AddedFunction::TypeInfo parseType(const QString& signature, int startPos
int i = start;
for (; i < length; ++i) {
c = signature[i];
- if (c == '<')
+ if (c == QLatin1Char('<'))
cantStop++;
- if (c == '>')
+ if (c == QLatin1Char('>'))
cantStop--;
if (cantStop < 0)
break; // FIXME: report error?
- if ((c == ')' || c == ',') && !cantStop)
+ if ((c == QLatin1Char(')') || c == QLatin1Char(',')) && !cantStop)
break;
paramString += signature[i];
}
@@ -2159,26 +2172,26 @@ static AddedFunction::TypeInfo parseType(const QString& signature, int startPos
*endPos = i;
// Check default value
- if (paramString.contains('=')) {
- QStringList lst = paramString.split('=');
+ if (paramString.contains(QLatin1Char('='))) {
+ QStringList lst = paramString.split(QLatin1Char('='));
paramString = lst[0].trimmed();
result.defaultValue = lst[1].trimmed();
}
// check constness
- if (paramString.startsWith("const ")) {
+ if (paramString.startsWith(QLatin1String("const "))) {
result.isConstant = true;
paramString.remove(0, sizeof("const")/sizeof(char));
paramString = paramString.trimmed();
}
// check reference
- if (paramString.endsWith("&")) {
+ if (paramString.endsWith(QLatin1Char('&'))) {
result.isReference = true;
paramString.chop(1);
paramString = paramString.trimmed();
}
// check Indirections
- while (paramString.endsWith("*")) {
+ while (paramString.endsWith(QLatin1Char('*'))) {
result.indirections++;
paramString.chop(1);
paramString = paramString.trimmed();
@@ -2193,7 +2206,7 @@ AddedFunction::AddedFunction(QString signature, QString returnType, double vr) :
Q_ASSERT(!returnType.isEmpty());
m_returnType = parseType(returnType);
signature = signature.trimmed();
- int endPos = signature.indexOf('(');
+ int endPos = signature.indexOf(QLatin1Char('('));
if (endPos < 0) {
m_isConst = false;
m_name = signature;
@@ -2205,11 +2218,11 @@ AddedFunction::AddedFunction(QString signature, QString returnType, double vr) :
if (!arg.name.isEmpty())
m_arguments.append(arg);
// end of parameters...
- if (signature[endPos] == ')')
+ if (signature[endPos] == QLatin1Char(')'))
break;
}
// is const?
- m_isConst = signature.right(signatureLength - endPos).contains("const");
+ m_isConst = signature.right(signatureLength - endPos).contains(QLatin1String("const"));
}
}
@@ -2259,32 +2272,32 @@ QString ContainerTypeEntry::typeName() const
{
switch(m_type) {
case LinkedListContainer:
- return "linked-list";
+ return QLatin1String("linked-list");
case ListContainer:
- return "list";
+ return QLatin1String("list");
case StringListContainer:
- return "string-list";
+ return QLatin1String("string-list");
case VectorContainer:
- return "vector";
+ return QLatin1String("vector");
case StackContainer:
- return "stack";
+ return QLatin1String("stack");
case QueueContainer:
- return "queue";
+ return QLatin1String("queue");
case SetContainer:
- return "set";
+ return QLatin1String("set");
case MapContainer:
- return "map";
+ return QLatin1String("map");
case MultiMapContainer:
- return "multi-map";
+ return QLatin1String("multi-map");
case HashContainer:
- return "hash";
+ return QLatin1String("hash");
case MultiHashContainer:
- return "multi-hash";
+ return QLatin1String("multi-hash");
case PairContainer:
- return "pair";
+ return QLatin1String("pair");
case NoContainer:
default:
- return "?";
+ return QLatin1String("?");
}
}
diff --git a/ApiExtractor/typesystem.h b/ApiExtractor/typesystem.h
index 1b7f036..6c1d9b4 100644
--- a/ApiExtractor/typesystem.h
+++ b/ApiExtractor/typesystem.h
@@ -843,7 +843,7 @@ public:
QString pkg = targetLangPackage();
if (pkg.isEmpty())
return targetLangName();
- return pkg + '.' + targetLangName();
+ return pkg + QLatin1Char('.') + targetLangName();
}
virtual InterfaceTypeEntry *designatedInterface() const
@@ -955,13 +955,13 @@ public:
/// TODO-CONVERTER: mark as deprecated
bool hasNativeConversionRule() const
{
- return m_conversionRule.startsWith(NATIVE_CONVERSION_RULE_FLAG);
+ return m_conversionRule.startsWith(QLatin1String(NATIVE_CONVERSION_RULE_FLAG));
}
/// TODO-CONVERTER: mark as deprecated
bool hasTargetConversionRule() const
{
- return m_conversionRule.startsWith(TARGET_CONVERSION_RULE_FLAG);
+ return m_conversionRule.startsWith(QLatin1String(TARGET_CONVERSION_RULE_FLAG));
}
bool isCppPrimitive() const;
@@ -1001,13 +1001,13 @@ public:
class VoidTypeEntry : public TypeEntry
{
public:
- VoidTypeEntry() : TypeEntry("void", VoidType, 0) { }
+ VoidTypeEntry() : TypeEntry(QLatin1String("void"), VoidType, 0) { }
};
class VarargsTypeEntry : public TypeEntry
{
public:
- VarargsTypeEntry() : TypeEntry("...", VarargsType, 0) { }
+ VarargsTypeEntry() : TypeEntry(QLatin1String("..."), VarargsType, 0) { }
};
class TemplateArgumentEntry : public TypeEntry
@@ -1035,7 +1035,7 @@ class ArrayTypeEntry : public TypeEntry
{
public:
ArrayTypeEntry(const TypeEntry *nested_type, double vr)
- : TypeEntry("Array", ArrayType, vr), m_nestedType(nested_type)
+ : TypeEntry(QLatin1String("Array"), ArrayType, vr), m_nestedType(nested_type)
{
Q_ASSERT(m_nestedType);
}
@@ -1051,14 +1051,14 @@ public:
QString targetLangName() const
{
- return m_nestedType->targetLangName() + "[]";
+ return m_nestedType->targetLangName() + QLatin1String("[]");
}
QString targetLangApiName() const
{
if (m_nestedType->isPrimitive())
- return m_nestedType->targetLangApiName() + "Array";
+ return m_nestedType->targetLangApiName() + QLatin1String("Array");
else
- return "jobjectArray";
+ return QLatin1String("jobjectArray");
}
private:
@@ -1211,9 +1211,9 @@ public:
QString qualifier = targetLangQualifier();
if (!pkg.isEmpty())
- qualifiedName += pkg + '.';
+ qualifiedName += pkg + QLatin1Char('.');
if (!qualifier.isEmpty())
- qualifiedName += qualifier + '.';
+ qualifiedName += qualifier + QLatin1Char('.');
qualifiedName += targetLangName();
return qualifiedName;
@@ -1422,14 +1422,13 @@ public:
};
ComplexTypeEntry(const QString &name, Type t, double vr)
- : TypeEntry(QString(name).replace(".*::", ""), t, vr),
+ : TypeEntry(QString(name).replace(QLatin1String(".*::"), QString()), t, vr),
m_qualifiedCppName(name),
m_qobject(false),
m_polymorphicBase(false),
m_genericClass(false),
m_typeFlags(0),
m_copyableFlag(Unknown),
- m_hashFunction(""),
m_baseContainerType(0)
{
}
@@ -1711,18 +1710,18 @@ public:
{
static QHash<QString, Type> m_stringToContainerType;
if (m_stringToContainerType.isEmpty()) {
- m_stringToContainerType["list"] = ListContainer;
- m_stringToContainerType["string-list"] = StringListContainer;
- m_stringToContainerType["linked-list"] = LinkedListContainer;
- m_stringToContainerType["vector"] = VectorContainer;
- m_stringToContainerType["stack"] = StackContainer;
- m_stringToContainerType["queue"] = QueueContainer;
- m_stringToContainerType["set"] = SetContainer;
- m_stringToContainerType["map"] = MapContainer;
- m_stringToContainerType["multi-map"] = MultiMapContainer;
- m_stringToContainerType["hash"] = HashContainer;
- m_stringToContainerType["multi-hash"] = MultiHashContainer;
- m_stringToContainerType["pair"] = PairContainer;
+ m_stringToContainerType.insert(QLatin1String("list"), ListContainer);
+ m_stringToContainerType.insert(QLatin1String("string-list"), StringListContainer);
+ m_stringToContainerType.insert(QLatin1String("linked-list"), LinkedListContainer);
+ m_stringToContainerType.insert(QLatin1String("vector"), VectorContainer);
+ m_stringToContainerType.insert(QLatin1String("stack"), StackContainer);
+ m_stringToContainerType.insert(QLatin1String("queue"), QueueContainer);
+ m_stringToContainerType.insert(QLatin1String("set"), SetContainer);
+ m_stringToContainerType.insert(QLatin1String("map"), MapContainer);
+ m_stringToContainerType.insert(QLatin1String("multi-map"), MultiMapContainer);
+ m_stringToContainerType.insert(QLatin1String("hash"), HashContainer);
+ m_stringToContainerType.insert(QLatin1String("multi-hash"), MultiHashContainer);
+ m_stringToContainerType.insert(QLatin1String("pair"), PairContainer);
}
return m_stringToContainerType.value(typeName, NoContainer);
}
@@ -1824,7 +1823,7 @@ public:
static QString interfaceName(const QString &name)
{
- return name + "Interface";
+ return name + QLatin1String("Interface");
}
ObjectTypeEntry *origin() const
@@ -1842,7 +1841,8 @@ public:
}
virtual QString qualifiedCppName() const
{
- return ComplexTypeEntry::qualifiedCppName().left(ComplexTypeEntry::qualifiedCppName().length() - interfaceName("").length());
+ const int len = ComplexTypeEntry::qualifiedCppName().length() - interfaceName(QString()).length();
+ return ComplexTypeEntry::qualifiedCppName().left(len);
}
private:
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 56185f2..96fa61e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -111,6 +111,8 @@ else()
endif()
endif()
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D QT_NO_CAST_FROM_ASCII -D QT_NO_CAST_TO_ASCII")
+
set(LIB_SUFFIX "" CACHE STRING "Define suffix of directory name (32/64)" )
set(LIB_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/lib${LIB_SUFFIX}" CACHE PATH "The subdirectory relative to the install prefix where libraries will be installed (default is /lib${LIB_SUFFIX})" FORCE)
diff --git a/generator/generator.cpp b/generator/generator.cpp
index 122af70..75a6a01 100644
--- a/generator/generator.cpp
+++ b/generator/generator.cpp
@@ -89,7 +89,7 @@ QString Generator::getSimplifiedContainerTypeName(const AbstractMetaType* type)
typeName.remove(0, sizeof("const ") / sizeof(char) - 1);
if (type->isReference())
typeName.chop(1);
- while (typeName.endsWith('*') || typeName.endsWith(' '))
+ while (typeName.endsWith(QLatin1Char('*')) || typeName.endsWith(QLatin1Char(' ')))
typeName.chop(1);
return typeName;
}
@@ -219,7 +219,7 @@ QString Generator::packageName() const
QString Generator::moduleName() const
{
QString& pkgName = m_d->packageName;
- return QString(pkgName).remove(0, pkgName.lastIndexOf('.') + 1);
+ return QString(pkgName).remove(0, pkgName.lastIndexOf(QLatin1Char('.')) + 1);
}
QString Generator::outputDirectory() const
@@ -249,7 +249,7 @@ bool Generator::generate()
if (ReportHandler::isDebug(ReportHandler::SparseDebug))
qCDebug(lcShiboken) << "generating: " << fileName;
- FileOut fileOut(outputDirectory() + '/' + subDirectoryForClass(cls) + '/' + fileName);
+ FileOut fileOut(outputDirectory() + QLatin1Char('/') + subDirectoryForClass(cls) + QLatin1Char('/') + fileName);
generateClass(fileOut.stream, cls);
if (fileOut.done() == FileOut::Failure)
@@ -284,35 +284,35 @@ void Generator::replaceTemplateVariables(QString &code, const AbstractMetaFuncti
{
const AbstractMetaClass *cpp_class = func->ownerClass();
if (cpp_class)
- code.replace("%TYPE", cpp_class->name());
+ code.replace(QLatin1String("%TYPE"), cpp_class->name());
foreach (AbstractMetaArgument *arg, func->arguments())
- code.replace("%" + QString::number(arg->argumentIndex() + 1), arg->name());
+ code.replace(QLatin1Char('%') + QString::number(arg->argumentIndex() + 1), arg->name());
//template values
- code.replace("%RETURN_TYPE", translateType(func->type(), cpp_class));
- code.replace("%FUNCTION_NAME", func->originalName());
+ code.replace(QLatin1String("%RETURN_TYPE"), translateType(func->type(), cpp_class));
+ code.replace(QLatin1String("%FUNCTION_NAME"), func->originalName());
- if (code.contains("%ARGUMENT_NAMES")) {
+ if (code.contains(QLatin1String("%ARGUMENT_NAMES"))) {
QString str;
QTextStream aux_stream(&str);
writeArgumentNames(aux_stream, func, Generator::SkipRemovedArguments);
- code.replace("%ARGUMENT_NAMES", str);
+ code.replace(QLatin1String("%ARGUMENT_NAMES"), str);
}
- if (code.contains("%ARGUMENTS")) {
+ if (code.contains(QLatin1String("%ARGUMENTS"))) {
QString str;
QTextStream aux_stream(&str);
writeFunctionArguments(aux_stream, func, Options(SkipDefaultValues) | SkipRemovedArguments);
- code.replace("%ARGUMENTS", str);
+ code.replace(QLatin1String("%ARGUMENTS"), str);
}
}
QTextStream& formatCode(QTextStream &s, const QString& code, Indentor &indentor)
{
// detect number of spaces before the first character
- QStringList lst(code.split("\n"));
- QRegExp nonSpaceRegex("[^\\s]");
+ QStringList lst(code.split(QLatin1Char('\n')));
+ QRegExp nonSpaceRegex(QLatin1String("[^\\s]"));
int spacesToRemove = 0;
foreach(QString line, lst) {
if (!line.trimmed().isEmpty()) {
@@ -323,7 +323,7 @@ QTextStream& formatCode(QTextStream &s, const QString& code, Indentor &indentor)
}
}
- static QRegExp emptyLine("\\s*[\\r]?[\\n]?\\s*");
+ static QRegExp emptyLine(QLatin1String("\\s*[\\r]?[\\n]?\\s*"));
foreach(QString line, lst) {
if (!line.isEmpty() && !emptyLine.exactMatch(line)) {
@@ -388,48 +388,50 @@ bool Generator::isCString(const AbstractMetaType* type)
{
return type->isNativePointer()
&& type->indirections() == 1
- && type->name() == "char";
+ && type->name() == QLatin1String("char");
}
bool Generator::isVoidPointer(const AbstractMetaType* type)
{
return type->isNativePointer()
&& type->indirections() == 1
- && type->name() == "void";
+ && type->name() == QLatin1String("void");
}
QString Generator::getFullTypeName(const TypeEntry* type) const
{
- return QString("%1%2").arg(type->isCppPrimitive() ? "" : "::").arg(type->qualifiedCppName());
+ return type->isCppPrimitive()
+ ? type->qualifiedCppName()
+ : (QLatin1String("::") + type->qualifiedCppName());
}
QString Generator::getFullTypeName(const AbstractMetaType* type) const
{
if (isCString(type))
- return "const char*";
+ return QLatin1String("const char*");
if (isVoidPointer(type))
- return "void*";
+ return QLatin1String("void*");
if (type->typeEntry()->isContainer())
- return QString("::%1").arg(type->cppSignature());
+ return QLatin1String("::") + type->cppSignature();
QString typeName;
if (type->typeEntry()->isComplex() && type->hasInstantiations())
typeName = getFullTypeNameWithoutModifiers(type);
else
typeName = getFullTypeName(type->typeEntry());
- return typeName + QString("*").repeated(type->indirections());
+ return typeName + QString::fromLatin1("*").repeated(type->indirections());
}
QString Generator::getFullTypeName(const AbstractMetaClass* metaClass) const
{
- return QString("::%1").arg(metaClass->qualifiedCppName());
+ return QLatin1String("::") + metaClass->qualifiedCppName();
}
QString Generator::getFullTypeNameWithoutModifiers(const AbstractMetaType* type) const
{
if (isCString(type))
- return "const char*";
+ return QLatin1String("const char*");
if (isVoidPointer(type))
- return "void*";
+ return QLatin1String("void*");
if (!type->hasInstantiations())
return getFullTypeName(type->typeEntry());
QString typeName = type->cppSignature();
@@ -437,9 +439,9 @@ QString Generator::getFullTypeNameWithoutModifiers(const AbstractMetaType* type)
typeName.remove(0, sizeof("const ") / sizeof(char) - 1);
if (type->isReference())
typeName.chop(1);
- while (typeName.endsWith('*') || typeName.endsWith(' '))
+ while (typeName.endsWith(QLatin1Char('*')) || typeName.endsWith(QLatin1Char(' ')))
typeName.chop(1);
- return QString("::%1").arg(typeName);
+ return QLatin1String("::") + typeName;
}
QString Generator::minimalConstructor(const AbstractMetaType* type) const
@@ -449,22 +451,22 @@ QString Generator::minimalConstructor(const AbstractMetaType* type) const
if (type->isContainer()) {
QString ctor = type->cppSignature();
- if (ctor.endsWith("*"))
- return QString("0");
- if (ctor.startsWith("const "))
+ if (ctor.endsWith(QLatin1Char('*')))
+ return QLatin1String("0");
+ if (ctor.startsWith(QLatin1String("const ")))
ctor.remove(0, sizeof("const ") / sizeof(char) - 1);
- if (ctor.endsWith("&")) {
+ if (ctor.endsWith(QLatin1Char('&'))) {
ctor.chop(1);
ctor = ctor.trimmed();
}
- return QString("::%1()").arg(ctor);
+ return QLatin1String("::") + ctor + QLatin1String("()");
}
if (type->isNativePointer())
- return QString("((%1*)0)").arg(type->typeEntry()->qualifiedCppName());
+ return QString::fromLatin1("((%1*)0)").arg(type->typeEntry()->qualifiedCppName());
if (Generator::isPointer(type))
- return QString("((::%1*)0)").arg(type->typeEntry()->qualifiedCppName());
+ return QString::fromLatin1("((::%1*)0)").arg(type->typeEntry()->qualifiedCppName());
if (type->typeEntry()->isComplex()) {
const ComplexTypeEntry* cType = reinterpret_cast<const ComplexTypeEntry*>(type->typeEntry());
@@ -486,10 +488,10 @@ QString Generator::minimalConstructor(const TypeEntry* type) const
return QString();
if (type->isCppPrimitive())
- return QString("((%1)0)").arg(type->qualifiedCppName());
+ return QString::fromLatin1("((%1)0)").arg(type->qualifiedCppName());
if (type->isEnum() || type->isFlags())
- return QString("((::%1)0)").arg(type->qualifiedCppName());
+ return QString::fromLatin1("((::%1)0)").arg(type->qualifiedCppName());
if (type->isPrimitive()) {
QString ctor = reinterpret_cast<const PrimitiveTypeEntry*>(type)->defaultConstructor();
@@ -497,7 +499,9 @@ QString Generator::minimalConstructor(const TypeEntry* type) const
// a default constructor defined by the user, the empty constructor is
// heuristically returned. If this is wrong the build of the generated
// bindings will tell.
- return (ctor.isEmpty()) ? QString("::%1()").arg(type->qualifiedCppName()) : ctor;
+ return ctor.isEmpty()
+ ? (QLatin1String("::") + type->qualifiedCppName() + QLatin1String("()"))
+ : ctor;
}
if (type->isComplex())
@@ -533,11 +537,10 @@ QString Generator::minimalConstructor(const AbstractMetaClass* metaClass) const
QStringList templateTypes;
foreach (TypeEntry* templateType, metaClass->templateArguments())
templateTypes << templateType->qualifiedCppName();
- QString fixedTypeName = QString("%1<%2 >").arg(qualifiedCppName).arg(templateTypes.join(", "));
// Empty constructor.
if (maxArgs == 0)
- return QString("::%1()").arg(qualifiedCppName);
+ return QLatin1String("::") + qualifiedCppName + QLatin1String("()");
QList<const AbstractMetaFunction*> candidates;
@@ -582,7 +585,7 @@ QString Generator::minimalConstructor(const AbstractMetaClass* metaClass) const
}
if (!args.isEmpty())
- return QString("::%1(%2)").arg(qualifiedCppName).arg(args.join(", "));
+ return QString::fromLatin1("::%1(%2)").arg(qualifiedCppName, args.join(QLatin1String(", ")));
candidates << ctor;
}
@@ -606,8 +609,7 @@ QString Generator::minimalConstructor(const AbstractMetaClass* metaClass) const
args << argValue;
}
if (!args.isEmpty()) {
- return QString("::%1(%2)").arg(qualifiedCppName)
- .arg(args.join(", "));
+ return QString::fromLatin1("::%1(%2)").arg(qualifiedCppName, args.join(QLatin1String(", ")));
}
}
@@ -628,20 +630,20 @@ QString Generator::translateType(const AbstractMetaType *cType,
}
if (!cType) {
- s = "void";
+ s = QLatin1String("void");
} else if (cType->isArray()) {
- s = translateType(cType->arrayElementType(), context, options) + "[]";
+ s = translateType(cType->arrayElementType(), context, options) + QLatin1String("[]");
} else if (options & Generator::EnumAsInts && (cType->isEnum() || cType->isFlags())) {
- s = "int";
+ s = QLatin1String("int");
} else {
if (options & Generator::OriginalName) {
s = cType->originalTypeDescription().trimmed();
- if ((options & Generator::ExcludeReference) && s.endsWith("&"))
+ if ((options & Generator::ExcludeReference) && s.endsWith(QLatin1Char('&')))
s = s.left(s.size()-1);
// remove only the last const (avoid remove template const)
if (options & Generator::ExcludeConst) {
- int index = s.lastIndexOf("const");
+ int index = s.lastIndexOf(QLatin1String("const"));
if (index >= (s.size() - (constLen + 1))) // (VarType const) or (VarType const[*|&])
s = s.remove(index, constLen);
@@ -657,7 +659,7 @@ QString Generator::translateType(const AbstractMetaType *cType,
s = copyType->cppSignature();
if (!copyType->typeEntry()->isVoid() && !copyType->typeEntry()->isCppPrimitive())
- s.prepend("::");
+ s.prepend(QLatin1String("::"));
delete copyType;
} else {
s = cType->cppSignature();
@@ -677,7 +679,7 @@ QString Generator::subDirectoryForPackage(QString packageName) const
{
if (packageName.isEmpty())
packageName = m_d->packageName;
- return QString(packageName).replace(".", QDir::separator());
+ return QString(packageName).replace(QLatin1Char('.'), QDir::separator());
}
template<typename T>
@@ -686,12 +688,12 @@ static QString getClassTargetFullName_(const T* t, bool includePackageName)
QString name = t->name();
const AbstractMetaClass* context = t->enclosingClass();
while (context) {
- name.prepend('.');
+ name.prepend(QLatin1Char('.'));
name.prepend(context->name());
context = context->enclosingClass();
}
if (includePackageName) {
- name.prepend('.');
+ name.prepend(QLatin1Char('.'));
name.prepend(t->package());
}
return name;
diff --git a/generator/main.cpp b/generator/main.cpp
index f38807a..17034dd 100644
--- a/generator/main.cpp
+++ b/generator/main.cpp
@@ -141,12 +141,12 @@ static bool processProjectFile(QFile& projectFile, QMap<QString, QString>& args)
if (line.isEmpty())
continue;
- int split = line.indexOf("=");
- QString key;
+ int split = line.indexOf('=');
+ QByteArray key;
QString value;
if (split > 0) {
key = line.left(split - 1).trimmed();
- value = line.mid(split + 1).trimmed();
+ value = QString::fromUtf8(line.mid(split + 1).trimmed());
} else {
key = line;
}
@@ -158,20 +158,20 @@ static bool processProjectFile(QFile& projectFile, QMap<QString, QString>& args)
else if (key == "api-version")
apiVersions << value;
else if (key == "header-file")
- args["arg-1"] = value;
+ args.insert(QLatin1String("arg-1"), value);
else if (key == "typesystem-file")
- args["arg-2"] = value;
+ args.insert(QLatin1String("arg-2"), value);
else
- args[key] = value;
+ args.insert(QString::fromUtf8(key), value);
}
if (!includePaths.isEmpty())
- args["include-paths"] = includePaths.join(PATH_SPLITTER);
+ args.insert(QLatin1String("include-paths"), includePaths.join(QLatin1String(PATH_SPLITTER)));
if (!typesystemPaths.isEmpty())
- args["typesystem-paths"] = typesystemPaths.join(PATH_SPLITTER);
+ args.insert(QLatin1String("typesystem-paths"), typesystemPaths.join(QLatin1String(PATH_SPLITTER)));
if (!apiVersions.isEmpty())
- args["api-version"] = apiVersions.join("|");
+ args.insert(QLatin1String("api-version"), apiVersions.join(QLatin1Char('|')));
return true;
}
@@ -184,8 +184,8 @@ static QMap<QString, QString> getInitializedArguments()
QString projectFileName;
foreach (const QString& arg, arguments) {
- if (arg.startsWith("--project-file")) {
- int split = arg.indexOf("=");
+ if (arg.startsWith(QLatin1String("--project-file"))) {
+ int split = arg.indexOf(QLatin1Char('='));
if (split > 0)
projectFileName = arg.mid(split + 1).trimmed();
break;
@@ -225,17 +225,17 @@ static QMap<QString, QString> getCommandLineArgs()
int argNum = 0;
foreach (QString arg, arguments) {
arg = arg.trimmed();
- if (arg.startsWith("--")) {
- int split = arg.indexOf("=");
+ if (arg.startsWith(QLatin1String("--"))) {
+ int split = arg.indexOf(QLatin1Char('='));
if (split > 0)
args[arg.mid(2).left(split-2)] = arg.mid(split + 1).trimmed();
else
args[arg.mid(2)] = QString();
- } else if (arg.startsWith("-")) {
+ } else if (arg.startsWith(QLatin1Char('-'))) {
args[arg.mid(1)] = QString();
} else {
argNum++;
- args[QString("arg-%1").arg(argNum)] = arg;
+ args[QString::fromLatin1("arg-%1").arg(argNum)] = arg;
}
}
return args;
@@ -248,20 +248,34 @@ void printUsage(const Generators& generators)
<< "shiboken [options] header-file typesystem-file\n\n"
<< "General options:\n";
QMap<QString, QString> generalOptions;
- generalOptions.insert("project-file=<file>", "text file containing a description of the binding project. Replaces and overrides command line arguments");
- generalOptions.insert("debug-level=[sparse|medium|full]", "Set the debug level");
- generalOptions.insert("silent", "Avoid printing any message");
- generalOptions.insert("help", "Display this help and exit");
- generalOptions.insert("no-suppress-warnings", "Show all warnings");
- generalOptions.insert("output-directory=<path>", "The directory where the generated files will be written");
- generalOptions.insert("include-paths=<path>[" PATH_SPLITTER "<path>" PATH_SPLITTER "...]", "Include paths used by the C++ parser");
- generalOptions.insert("typesystem-paths=<path>[" PATH_SPLITTER "<path>" PATH_SPLITTER "...]", "Paths used when searching for typesystems");
- generalOptions.insert("documentation-only", "Do not generates any code, just the documentation");
- generalOptions.insert("license-file=<license-file>", "File used for copyright headers of generated files");
- generalOptions.insert("version", "Output version information and exit");
- generalOptions.insert("generator-set=<\"generator module\">", "generator-set to be used. e.g. qtdoc");
- generalOptions.insert("api-version=<\"package mask\">,<\"version\">", "Specify the supported api version used to generate the bindings");
- generalOptions.insert("drop-type-entries=\"<TypeEntry0>[;TypeEntry1;...]\"", "Semicolon separated list of type system entries (classes, namespaces, global functions and enums) to be dropped from generation.");
+ generalOptions.insert(QLatin1String("project-file=<file>"),
+ QLatin1String("text file containing a description of the binding project. Replaces and overrides command line arguments"));
+ generalOptions.insert(QLatin1String("debug-level=[sparse|medium|full]"),
+ QLatin1String("Set the debug level"));
+ generalOptions.insert(QLatin1String("silent"),
+ QLatin1String("Avoid printing any message"));
+ generalOptions.insert(QLatin1String("help"),
+ QLatin1String("Display this help and exit"));
+ generalOptions.insert(QLatin1String("no-suppress-warnings"),
+ QLatin1String("Show all warnings"));
+ generalOptions.insert(QLatin1String("output-directory=<path>"),
+ QLatin1String("The directory where the generated files will be written"));
+ generalOptions.insert(QLatin1String("include-paths=<path>[" PATH_SPLITTER "<path>" PATH_SPLITTER "...]"),
+ QLatin1String("Include paths used by the C++ parser"));
+ generalOptions.insert(QLatin1String("typesystem-paths=<path>[" PATH_SPLITTER "<path>" PATH_SPLITTER "...]"),
+ QLatin1String("Paths used when searching for typesystems"));
+ generalOptions.insert(QLatin1String("documentation-only"),
+ QLatin1String("Do not generates any code, just the documentation"));
+ generalOptions.insert(QLatin1String("license-file=<license-file>"),
+ QLatin1String("File used for copyright headers of generated files"));
+ generalOptions.insert(QLatin1String("version"),
+ QLatin1String("Output version information and exit"));
+ generalOptions.insert(QLatin1String("generator-set=<\"generator module\">"),
+ QLatin1String("generator-set to be used. e.g. qtdoc"));
+ generalOptions.insert(QLatin1String("api-version=<\"package mask\">,<\"version\">"),
+ QLatin1String("Specify the supported api version used to generate the bindings"));
+ generalOptions.insert(QLatin1String("drop-type-entries=\"<TypeEntry0>[;TypeEntry1;...]\""),
+ QLatin1String("Semicolon separated list of type system entries (classes, namespaces, global functions and enums) to be dropped from generation."));
printOptions(s, generalOptions);
foreach (const GeneratorPtr &generator, generators) {
@@ -302,53 +316,53 @@ int main(int argc, char *argv[])
ArgsHandler argsHandler(args);
Generators generators;
- if (argsHandler.argExistsRemove("version")) {
+ if (argsHandler.argExistsRemove(QLatin1String("version"))) {
printVerAndBanner();
return EXIT_SUCCESS;
}
- QString generatorSet = argsHandler.removeArg("generator-set");
- // Also check "generatorSet" command line argument for backward compatibility.
+ QString generatorSet = argsHandler.removeArg(QLatin1String("generator-set"));
+ // Also check QLatin1String("generatorSet") command line argument for backward compatibility.
if (generatorSet.isEmpty())
- generatorSet = argsHandler.removeArg("generatorSet");
+ generatorSet = argsHandler.removeArg(QLatin1String("generatorSet"));
// Pre-defined generator sets.
- if (generatorSet == "qtdoc") {
+ if (generatorSet == QLatin1String("qtdoc")) {
#ifndef DOCSTRINGS_ENABLED
- errorPrint("shiboken: Doc strings extractions was not enabled in this shiboken build.");
+ errorPrint(QLatin1String("shiboken: Doc strings extractions was not enabled in this shiboken build."));
return EXIT_FAILURE;
#else
generators << new QtDocGenerator;
#endif
- } else if (generatorSet.isEmpty() || generatorSet == "shiboken") {
+ } else if (generatorSet.isEmpty() || generatorSet == QLatin1String("shiboken")) {
generators << GeneratorPtr(new CppGenerator) << GeneratorPtr(new HeaderGenerator);
} else {
- errorPrint("shiboken: Unknown generator set, try \"shiboken\" or \"qtdoc\".");
+ errorPrint(QLatin1String("shiboken: Unknown generator set, try \"shiboken\" or \"qtdoc\"."));
return EXIT_FAILURE;
}
- if (argsHandler.argExistsRemove("help")) {
+ if (argsHandler.argExistsRemove(QLatin1String("help"))) {
printUsage(generators);
return EXIT_SUCCESS;
}
QString licenseComment;
- QString licenseFileName = argsHandler.removeArg("license-file");
+ QString licenseFileName = argsHandler.removeArg(QLatin1String("license-file"));
if (!licenseFileName.isEmpty()) {
if (QFile::exists(licenseFileName)) {
QFile licenseFile(licenseFileName);
if (licenseFile.open(QIODevice::ReadOnly))
- licenseComment = licenseFile.readAll();
+ licenseComment = QString::fromUtf8(licenseFile.readAll());
} else {
- errorPrint(QString("Couldn't find the file containing the license heading: %1").
- arg(qPrintable(licenseFileName)));
+ errorPrint(QStringLiteral("Couldn't find the file containing the license heading: %1").
+ arg(licenseFileName));
return EXIT_FAILURE;
}
}
- QString outputDirectory = argsHandler.removeArg("output-directory");
+ QString outputDirectory = argsHandler.removeArg(QLatin1String("output-directory"));
if (outputDirectory.isEmpty())
- outputDirectory = "out";
+ outputDirectory = QLatin1String("out");
if (!QDir(outputDirectory).exists()) {
if (!QDir().mkpath(outputDirectory)) {
@@ -362,53 +376,53 @@ int main(int argc, char *argv[])
ApiExtractor extractor;
extractor.setLogDirectory(outputDirectory);
- if (argsHandler.argExistsRemove("silent")) {
+ if (argsHandler.argExistsRemove(QLatin1String("silent"))) {
extractor.setSilent(true);
} else {
- QString level = argsHandler.removeArg("debug-level");
+ QString level = argsHandler.removeArg(QLatin1String("debug-level"));
if (!level.isEmpty()) {
- if (level == "sparse")
+ if (level == QLatin1String("sparse"))
extractor.setDebugLevel(ReportHandler::SparseDebug);
- else if (level == "medium")
+ else if (level == QLatin1String("medium"))
extractor.setDebugLevel(ReportHandler::MediumDebug);
- else if (level == "full")
+ else if (level == QLatin1String("full"))
extractor.setDebugLevel(ReportHandler::FullDebug);
}
}
- if (argsHandler.argExistsRemove("no-suppress-warnings"))
+ if (argsHandler.argExistsRemove(QLatin1String("no-suppress-warnings")))
extractor.setSuppressWarnings(false);
- if (argsHandler.argExists("api-version")) {
- QStringList versions = argsHandler.removeArg("api-version").split("|");
+ if (argsHandler.argExists(QLatin1String("api-version"))) {
+ QStringList versions = argsHandler.removeArg(QLatin1String("api-version")).split(QLatin1Char('|'));
foreach (QString fullVersion, versions) {
- QStringList parts = fullVersion.split(",");
+ QStringList parts = fullVersion.split(QLatin1Char(','));
QString package;
QString version;
- package = parts.count() == 1 ? "*" : parts.first();
+ package = parts.count() == 1 ? QLatin1String("*") : parts.constFirst();
version = parts.last();
extractor.setApiVersion(package, version.toUtf8());
}
}
- if (argsHandler.argExists("drop-type-entries"))
- extractor.setDropTypeEntries(argsHandler.removeArg("drop-type-entries"));
+ if (argsHandler.argExists(QLatin1String("drop-type-entries")))
+ extractor.setDropTypeEntries(argsHandler.removeArg(QLatin1String("drop-type-entries")));
- QString path = argsHandler.removeArg("typesystem-paths");
+ QString path = argsHandler.removeArg(QLatin1String("typesystem-paths"));
if (!path.isEmpty())
- extractor.addTypesystemSearchPath(path.split(PATH_SPLITTER));
+ extractor.addTypesystemSearchPath(path.split(QLatin1String(PATH_SPLITTER)));
- path = argsHandler.removeArg("include-paths");
+ path = argsHandler.removeArg(QLatin1String("include-paths"));
if (!path.isEmpty())
- extractor.addIncludePath(path.split(PATH_SPLITTER));
+ extractor.addIncludePath(path.split(QLatin1String(PATH_SPLITTER)));
- QString cppFileName = argsHandler.removeArg("arg-1");
- QString typeSystemFileName = argsHandler.removeArg("arg-2");
+ QString cppFileName = argsHandler.removeArg(QLatin1String("arg-1"));
+ QString typeSystemFileName = argsHandler.removeArg(QLatin1String("arg-2"));
/* Make sure to remove the project file's arguments (if any) and
* --project-file, also the arguments of each generator before
* checking if there isn't any existing arguments in argsHandler.
*/
- argsHandler.removeArg("project-file");
+ argsHandler.removeArg(QLatin1String("project-file"));
QMap<QString, QString> projectFileArgs = getInitializedArguments();
if (!projectFileArgs.isEmpty()) {
QMap<QString, QString>::const_iterator it =
@@ -426,7 +440,7 @@ int main(int argc, char *argv[])
}
if (!argsHandler.noArgs()) {
- errorPrint("shiboken: Called with wrong arguments.");
+ errorPrint(QLatin1String("shiboken: Called with wrong arguments."));
std::cout << "Note: use --help option for more information." << std::endl;
return EXIT_FAILURE;
}
diff --git a/generator/qtdoc/qtdocgenerator.h b/generator/qtdoc/qtdocgenerator.h
index 36c372d..5669bf5 100644
--- a/generator/qtdoc/qtdocgenerator.h
+++ b/generator/qtdoc/qtdocgenerator.h
@@ -47,7 +47,7 @@ public:
QString data;
TableCell(const QString& text = QString()) : rowSpan(0), colSpan(0), data(text) {}
- TableCell(const char* text) : rowSpan(0), colSpan(0), data(text) {}
+ TableCell(const char* text) : rowSpan(0), colSpan(0), data(QLatin1String(text)) {}
};
typedef QList<TableCell> TableRow;
diff --git a/generator/shiboken2/cppgenerator.cpp b/generator/shiboken2/cppgenerator.cpp
index 2f3ffef..35ef231 100644
--- a/generator/shiboken2/cppgenerator.cpp
+++ b/generator/shiboken2/cppgenerator.cpp
@@ -34,7 +34,7 @@
QHash<QString, QString> CppGenerator::m_nbFuncs = QHash<QString, QString>();
QHash<QString, QString> CppGenerator::m_sqFuncs = QHash<QString, QString>();
QHash<QString, QString> CppGenerator::m_mpFuncs = QHash<QString, QString>();
-QString CppGenerator::m_currentErrorCode("0");
+QString CppGenerator::m_currentErrorCode(QLatin1String("0"));
// utility functions
inline AbstractMetaType* getTypeWithoutContainer(AbstractMetaType* arg)
@@ -51,64 +51,85 @@ inline AbstractMetaType* getTypeWithoutContainer(AbstractMetaType* arg)
CppGenerator::CppGenerator()
{
// Number protocol structure members names
- m_nbFuncs["__add__"] = "nb_add";
- m_nbFuncs["__sub__"] = "nb_subtract";
- m_nbFuncs["__mul__"] = "nb_multiply";
- m_nbFuncs["__div__"] = "nb_divide";
- m_nbFuncs["__mod__"] = "nb_remainder";
- m_nbFuncs["__neg__"] = "nb_negative";
- m_nbFuncs["__pos__"] = "nb_positive";
- m_nbFuncs["__invert__"] = "nb_invert";
- m_nbFuncs["__lshift__"] = "nb_lshift";
- m_nbFuncs["__rshift__"] = "nb_rshift";
- m_nbFuncs["__and__"] = "nb_and";
- m_nbFuncs["__xor__"] = "nb_xor";
- m_nbFuncs["__or__"] = "nb_or";
- m_nbFuncs["__iadd__"] = "nb_inplace_add";
- m_nbFuncs["__isub__"] = "nb_inplace_subtract";
+ m_nbFuncs.insert(QLatin1String("__add__"), QLatin1String("nb_add"));
+ m_nbFuncs.insert(QLatin1String("__sub__"), QLatin1String("nb_subtract"));
+ m_nbFuncs.insert(QLatin1String("__mul__"), QLatin1String("nb_multiply"));
+ m_nbFuncs.insert(QLatin1String("__div__"), QLatin1String("nb_divide"));
+ m_nbFuncs.insert(QLatin1String("__mod__"), QLatin1String("nb_remainder"));
+ m_nbFuncs.insert(QLatin1String("__neg__"), QLatin1String("nb_negative"));
+ m_nbFuncs.insert(QLatin1String("__pos__"), QLatin1String("nb_positive"));
+ m_nbFuncs.insert(QLatin1String("__invert__"), QLatin1String("nb_invert"));
+ m_nbFuncs.insert(QLatin1String("__lshift__"), QLatin1String("nb_lshift"));
+ m_nbFuncs.insert(QLatin1String("__rshift__"), QLatin1String("nb_rshift"));
+ m_nbFuncs.insert(QLatin1String("__and__"), QLatin1String("nb_and"));
+ m_nbFuncs.insert(QLatin1String("__xor__"), QLatin1String("nb_xor"));
+ m_nbFuncs.insert(QLatin1String("__or__"), QLatin1String("nb_or"));
+ m_nbFuncs.insert(QLatin1String("__iadd__"), QLatin1String("nb_inplace_add"));
+ m_nbFuncs.insert(QLatin1String("__isub__"), QLatin1String("nb_inplace_subtract"));
m_nbFuncs.insert(QLatin1String("__imul__"), QLatin1String("nb_inplace_multiply"));
m_nbFuncs.insert(QLatin1String("__idiv__"), QLatin1String("nb_inplace_divide"));
m_nbFuncs.insert(QLatin1String("__imod__"), QLatin1String("nb_inplace_remainder"));
- m_nbFuncs["__ilshift__"] = "nb_inplace_lshift";
- m_nbFuncs["__irshift__"] = "nb_inplace_rshift";
- m_nbFuncs["__iand__"] = "nb_inplace_and";
- m_nbFuncs["__ixor__"] = "nb_inplace_xor";
- m_nbFuncs["__ior__"] = "nb_inplace_or";
- m_nbFuncs["bool"] = "nb_nonzero";
+ m_nbFuncs.insert(QLatin1String("__ilshift__"), QLatin1String("nb_inplace_lshift"));
+ m_nbFuncs.insert(QLatin1String("__irshift__"), QLatin1String("nb_inplace_rshift"));
+ m_nbFuncs.insert(QLatin1String("__iand__"), QLatin1String("nb_inplace_and"));
+ m_nbFuncs.insert(QLatin1String("__ixor__"), QLatin1String("nb_inplace_xor"));
+ m_nbFuncs.insert(QLatin1String("__ior__"), QLatin1String("nb_inplace_or"));
+ m_nbFuncs.insert(QLatin1String("bool"), QLatin1String("nb_nonzero"));
// sequence protocol functions
typedef QPair<QString, QString> StrPair;
- m_sequenceProtocol.insert("__len__", StrPair("PyObject* " PYTHON_SELF_VAR, "Py_ssize_t"));
- m_sequenceProtocol.insert("__getitem__", StrPair("PyObject* " PYTHON_SELF_VAR ", Py_ssize_t _i", "PyObject*"));
- m_sequenceProtocol.insert("__setitem__", StrPair("PyObject* " PYTHON_SELF_VAR ", Py_ssize_t _i, PyObject* _value", "int"));
- m_sequenceProtocol.insert("__getslice__", StrPair("PyObject* " PYTHON_SELF_VAR ", Py_ssize_t _i1, Py_ssize_t _i2", "PyObject*"));
- m_sequenceProtocol.insert("__setslice__", StrPair("PyObject* " PYTHON_SELF_VAR ", Py_ssize_t _i1, Py_ssize_t _i2, PyObject* _value", "int"));
- m_sequenceProtocol.insert("__contains__", StrPair("PyObject* " PYTHON_SELF_VAR ", PyObject* _value", "int"));
- m_sequenceProtocol.insert("__concat__", StrPair("PyObject* " PYTHON_SELF_VAR ", PyObject* _other", "PyObject*"));
+ m_sequenceProtocol.insert(QLatin1String("__len__"),
+ StrPair(QLatin1String("PyObject* " PYTHON_SELF_VAR), QLatin1String("Py_ssize_t")));
+ m_sequenceProtocol.insert(QLatin1String("__getitem__"),
+ StrPair(QLatin1String("PyObject* " PYTHON_SELF_VAR ", Py_ssize_t _i"),
+ QLatin1String("PyObject*")));
+ m_sequenceProtocol.insert(QLatin1String("__setitem__"),
+ StrPair(QLatin1String("PyObject* " PYTHON_SELF_VAR ", Py_ssize_t _i, PyObject* _value"),
+ QLatin1String("int")));
+ m_sequenceProtocol.insert(QLatin1String("__getslice__"),
+ StrPair(QLatin1String("PyObject* " PYTHON_SELF_VAR ", Py_ssize_t _i1, Py_ssize_t _i2"),
+ QLatin1String("PyObject*")));
+ m_sequenceProtocol.insert(QLatin1String("__setslice__"),
+ StrPair(QLatin1String("PyObject* " PYTHON_SELF_VAR ", Py_ssize_t _i1, Py_ssize_t _i2, PyObject* _value"),
+ QLatin1String("int")));
+ m_sequenceProtocol.insert(QLatin1String("__contains__"),
+ StrPair(QLatin1String("PyObject* " PYTHON_SELF_VAR ", PyObject* _value"),
+ QLatin1String("int")));
+ m_sequenceProtocol.insert(QLatin1String("__concat__"),
+ StrPair(QLatin1String("PyObject* " PYTHON_SELF_VAR ", PyObject* _other"),
+ QLatin1String("PyObject*")));
// Sequence protocol structure members names
- m_sqFuncs["__concat__"] = "sq_concat";
- m_sqFuncs["__contains__"] = "sq_contains";
- m_sqFuncs["__getitem__"] = "sq_item";
- m_sqFuncs["__getslice__"] = "sq_slice";
- m_sqFuncs["__len__"] = "sq_length";
- m_sqFuncs["__setitem__"] = "sq_ass_item";
- m_sqFuncs["__setslice__"] = "sq_ass_slice";
+ m_sqFuncs.insert(QLatin1String("__concat__"), QLatin1String("sq_concat"));
+ m_sqFuncs.insert(QLatin1String("__contains__"), QLatin1String("sq_contains"));
+ m_sqFuncs.insert(QLatin1String("__getitem__"), QLatin1String("sq_item"));
+ m_sqFuncs.insert(QLatin1String("__getslice__"), QLatin1String("sq_slice"));
+ m_sqFuncs.insert(QLatin1String("__len__"), QLatin1String("sq_length"));
+ m_sqFuncs.insert(QLatin1String("__setitem__"), QLatin1String("sq_ass_item"));
+ m_sqFuncs.insert(QLatin1String("__setslice__"), QLatin1String("sq_ass_slice"));
// mapping protocol function
- m_mappingProtocol.insert("__mlen__", StrPair("PyObject* " PYTHON_SELF_VAR, "Py_ssize_t"));
- m_mappingProtocol.insert("__mgetitem__", StrPair("PyObject* " PYTHON_SELF_VAR ", PyObject* _key", "PyObject*"));
- m_mappingProtocol.insert("__msetitem__", StrPair("PyObject* " PYTHON_SELF_VAR ", PyObject* _key, PyObject* _value", "int"));
+ m_mappingProtocol.insert(QLatin1String("__mlen__"),
+ StrPair(QLatin1String("PyObject* " PYTHON_SELF_VAR),
+ QLatin1String("Py_ssize_t")));
+ m_mappingProtocol.insert(QLatin1String("__mgetitem__"),
+ StrPair(QLatin1String("PyObject* " PYTHON_SELF_VAR ", PyObject* _key"),
+ QLatin1String("PyObject*")));
+ m_mappingProtocol.insert(QLatin1String("__msetitem__"),
+ StrPair(QLatin1String("PyObject* " PYTHON_SELF_VAR ", PyObject* _key, PyObject* _value"),
+ QLatin1String("int")));
// Sequence protocol structure members names
- m_mpFuncs["__mlen__"] = "mp_length";
- m_mpFuncs["__mgetitem__"] = "mp_subscript";
- m_mpFuncs["__msetitem__"] = "mp_ass_subscript";
+ m_mpFuncs.insert(QLatin1String("__mlen__"), QLatin1String("mp_length"));
+ m_mpFuncs.insert(QLatin1String("__mgetitem__"), QLatin1String("mp_subscript"));
+ m_mpFuncs.insert(QLatin1String("__msetitem__"), QLatin1String("mp_ass_subscript"));
}
QString CppGenerator::fileNameForClass(const AbstractMetaClass *metaClass) const
{
- return metaClass->qualifiedCppName().toLower().replace("::", "_") + QLatin1String("_wrapper.cpp");
+ QString result = metaClass->qualifiedCppName().toLower();
+ result.replace(QLatin1String("::"), QLatin1String("_"));
+ return result + QLatin1String("_wrapper.cpp");
}
QList<AbstractMetaFunctionList> CppGenerator::filterGroupedOperatorFunctions(const AbstractMetaClass* metaClass,
@@ -117,7 +138,7 @@ QList<AbstractMetaFunctionList> CppGenerator::filterGroupedOperatorFunctions(con
// ( func_name, num_args ) => func_list
QMap<QPair<QString, int >, AbstractMetaFunctionList> results;
foreach (AbstractMetaFunction* func, metaClass->operatorOverloads(query)) {
- if (func->isModifiedRemoved() || func->name() == "operator[]" || func->name() == "operator->")
+ if (func->isModifiedRemoved() || func->name() == QLatin1String("operator[]") || func->name() == QLatin1String("operator->"))
continue;
int args;
if (func->isComparisonOperator()) {
@@ -136,13 +157,13 @@ bool CppGenerator::hasBoolCast(const AbstractMetaClass* metaClass) const
if (!useIsNullAsNbNonZero())
return false;
// TODO: This could be configurable someday
- const AbstractMetaFunction* func = metaClass->findFunction("isNull");
+ const AbstractMetaFunction* func = metaClass->findFunction(QLatin1String("isNull"));
if (!func || !func->type() || !func->type()->typeEntry()->isPrimitive() || !func->isPublic())
return false;
const PrimitiveTypeEntry* pte = static_cast<const PrimitiveTypeEntry*>(func->type()->typeEntry());
while (pte->aliasedTypeEntry())
pte = pte->aliasedTypeEntry();
- return func && func->isConstant() && pte->name() == "bool" && func->arguments().isEmpty();
+ return func && func->isConstant() && pte->name() == QLatin1String("bool") && func->arguments().isEmpty();
}
/*!
@@ -189,12 +210,12 @@ void CppGenerator::generateClass(QTextStream &s, const AbstractMetaClass *metaCl
s << "#include \"" << getModuleHeaderFileName() << '"' << endl << endl;
QString headerfile = fileNameForClass(metaClass);
- headerfile.replace(".cpp", ".h");
+ headerfile.replace(QLatin1String(".cpp"), QLatin1String(".h"));
s << "#include \"" << headerfile << '"' << endl;
foreach (AbstractMetaClass* innerClass, metaClass->innerClasses()) {
if (shouldGenerate(innerClass)) {
QString headerfile = fileNameForClass(innerClass);
- headerfile.replace(".cpp", ".h");
+ headerfile.replace(QLatin1String(".cpp"), QLatin1String(".h"));
s << "#include \"" << headerfile << '"' << endl;
}
}
@@ -286,7 +307,7 @@ void CppGenerator::generateClass(QTextStream &s, const AbstractMetaClass *metaCl
&& !func->isModifiedRemoved()
&& (!func->isPrivate() || func->functionType() == AbstractMetaFunction::EmptyFunction)
&& func->ownerClass() == func->implementingClass()
- && (func->name() != "qt_metacall"))
+ && (func->name() != QLatin1String("qt_metacall")))
overloads.append(func);
}
@@ -300,7 +321,7 @@ void CppGenerator::generateClass(QTextStream &s, const AbstractMetaClass *metaCl
if (rfunc->isConstructor())
writeConstructorWrapper(s, overloads);
// call operators
- else if (rfunc->name() == "operator()")
+ else if (rfunc->name() == QLatin1String("operator()"))
writeMethodWrapper(s, overloads);
else if (!rfunc->isOperatorOverload()) {
writeMethodWrapper(s, overloads);
@@ -315,7 +336,8 @@ void CppGenerator::generateClass(QTextStream &s, const AbstractMetaClass *metaCl
}
}
- QString className = cpythonTypeName(metaClass).replace(QRegExp("_Type$"), "");
+ QString className = cpythonTypeName(metaClass);
+ className.remove(QRegExp(QLatin1String("_Type$")));
if (metaClass->typeEntry()->isValue())
writeCopyFunction(s, metaClass);
@@ -332,7 +354,7 @@ void CppGenerator::generateClass(QTextStream &s, const AbstractMetaClass *metaCl
s << "};" << endl << endl;
// Write tp_getattro function
- if (usePySideExtensions() && metaClass->qualifiedCppName() == "QObject") {
+ if (usePySideExtensions() && metaClass->qualifiedCppName() == QLatin1String("QObject")) {
writeGetattroFunction(s, metaClass);
s << endl;
writeSetattroFunction(s, metaClass);
@@ -410,7 +432,7 @@ void CppGenerator::generateClass(QTextStream &s, const AbstractMetaClass *metaCl
bool hasSetter = !metaField->type()->isConstant();
s << INDENT << "{const_cast<char*>(\"" << metaField->name() << "\"), ";
s << cpythonGetterFunctionName(metaField);
- s << ", " << (hasSetter ? cpythonSetterFunctionName(metaField) : "0");
+ s << ", " << (hasSetter ? cpythonSetterFunctionName(metaField) : QLatin1String("0"));
s << "}," << endl;
}
s << INDENT << "{0} // Sentinel" << endl;
@@ -459,7 +481,7 @@ void CppGenerator::generateClass(QTextStream &s, const AbstractMetaClass *metaCl
void CppGenerator::writeConstructorNative(QTextStream& s, const AbstractMetaFunction* func)
{
Indentation indentation(INDENT);
- s << functionSignature(func, wrapperName(func->ownerClass()) + "::", "",
+ s << functionSignature(func, wrapperName(func->ownerClass()) + QLatin1String("::"), QString(),
OriginalTypeDescription | SkipDefaultValues);
s << " : ";
writeFunctionCall(s, func);
@@ -495,40 +517,43 @@ static bool allArgumentsRemoved(const AbstractMetaFunction* func)
QString CppGenerator::getVirtualFunctionReturnTypeName(const AbstractMetaFunction* func)
{
if (!func->type())
- return "\"\"";
+ return QLatin1String("\"\"");
if (!func->typeReplaced(0).isEmpty())
- return '"' + func->typeReplaced(0) + '"';
+ return QLatin1Char('"') + func->typeReplaced(0) + QLatin1Char('"');
// SbkType would return null when the type is a container.
- if (func->type()->typeEntry()->isContainer())
- return '"' + reinterpret_cast<const ContainerTypeEntry*>(func->type()->typeEntry())->typeName() + '"';
+ if (func->type()->typeEntry()->isContainer()) {
+ return QLatin1Char('"')
+ + reinterpret_cast<const ContainerTypeEntry*>(func->type()->typeEntry())->typeName()
+ + QLatin1Char('"');
+ }
if (avoidProtectedHack()) {
const AbstractMetaEnum* metaEnum = findAbstractMetaEnum(func->type());
if (metaEnum && metaEnum->isProtected())
- return '"' + protectedEnumSurrogateName(metaEnum) + '"';
+ return QLatin1Char('"') + protectedEnumSurrogateName(metaEnum) + QLatin1Char('"');
}
if (func->type()->isPrimitive())
- return '"' + func->type()->name() + '"';
+ return QLatin1Char('"') + func->type()->name() + QLatin1Char('"');
- return QString("Shiboken::SbkType< %1 >()->tp_name").arg(func->type()->typeEntry()->qualifiedCppName());
+ return QString::fromLatin1("Shiboken::SbkType< %1 >()->tp_name").arg(func->type()->typeEntry()->qualifiedCppName());
}
void CppGenerator::writeVirtualMethodNative(QTextStream&s, const AbstractMetaFunction* func)
{
//skip metaObject function, this will be written manually ahead
if (usePySideExtensions() && func->ownerClass() && func->ownerClass()->isQObject() &&
- ((func->name() == "metaObject") || (func->name() == "qt_metacall")))
+ ((func->name() == QLatin1String("metaObject")) || (func->name() == QLatin1String("qt_metacall"))))
return;
const TypeEntry* retType = func->type() ? func->type()->typeEntry() : 0;
const QString funcName = func->isOperatorOverload() ? pythonOperatorFunctionName(func) : func->name();
- QString prefix = QString("%1::").arg(wrapperName(func->ownerClass()));
- s << functionSignature(func, prefix, "", Generator::SkipDefaultValues|Generator::OriginalTypeDescription) << endl;
- s << '{' << endl;
+ QString prefix = wrapperName(func->ownerClass()) + QLatin1String("::");
+ s << functionSignature(func, prefix, QString(), Generator::SkipDefaultValues|Generator::OriginalTypeDescription)
+ << endl << '{' << endl;
Indentation indentation(INDENT);
@@ -537,7 +562,7 @@ void CppGenerator::writeVirtualMethodNative(QTextStream&s, const AbstractMetaFun
foreach (FunctionModification mod, func->modifications()) {
foreach (ArgumentModification argMod, mod.argument_mods) {
if (argMod.index == 0 && !argMod.replacedDefaultExpression.isEmpty()) {
- QRegExp regex("%(\\d+)");
+ QRegExp regex(QLatin1String("%(\\d+)"));
defaultReturnExpr = argMod.replacedDefaultExpression;
int offset = 0;
while ((offset = regex.indexIn(defaultReturnExpr, offset)) != -1) {
@@ -554,7 +579,7 @@ void CppGenerator::writeVirtualMethodNative(QTextStream&s, const AbstractMetaFun
if (defaultReturnExpr.isEmpty())
defaultReturnExpr = minimalConstructor(func->type());
if (defaultReturnExpr.isEmpty()) {
- QString errorMsg = QString(MIN_CTOR_ERROR_MSG).arg(func->type()->cppSignature());
+ QString errorMsg = QString::fromLatin1(MIN_CTOR_ERROR_MSG).arg(func->type()->cppSignature());
qCWarning(lcShiboken).noquote().nospace() << errorMsg;
s << endl << INDENT << "#error " << errorMsg << endl;
}
@@ -605,7 +630,7 @@ void CppGenerator::writeVirtualMethodNative(QTextStream&s, const AbstractMetaFun
s << INDENT << "PyErr_SetString(PyExc_NotImplementedError, \"pure virtual method '";
s << func->ownerClass()->name() << '.' << funcName;
s << "()' not implemented.\");" << endl;
- s << INDENT << "return " << (retType ? defaultReturnExpr : "");
+ s << INDENT << "return " << (retType ? defaultReturnExpr : QString());
} else {
s << INDENT << "gil.release();" << endl;
s << INDENT << "return this->::" << func->implementingClass()->qualifiedCppName() << "::";
@@ -650,7 +675,7 @@ void CppGenerator::writeVirtualMethodNative(QTextStream&s, const AbstractMetaFun
ac << INDENT;
if (!func->conversionRule(TypeSystem::TargetLangCode, arg->argumentIndex() + 1).isEmpty()) {
// Has conversion rule.
- ac << QString("%1" CONV_RULE_OUT_VAR_SUFFIX).arg(arg->name());
+ ac << arg->name() + QLatin1String(CONV_RULE_OUT_VAR_SUFFIX);
} else {
QString argName = arg->name();
if (convert)
@@ -663,7 +688,7 @@ void CppGenerator::writeVirtualMethodNative(QTextStream&s, const AbstractMetaFun
}
s << "Py_BuildValue(\"(" << getFormatUnitString(func, false) << ")\"," << endl;
- s << argConversions.join(",\n") << endl;
+ s << argConversions.join(QLatin1String(",\n")) << endl;
s << INDENT << "));" << endl;
}
@@ -711,7 +736,7 @@ void CppGenerator::writeVirtualMethodNative(QTextStream&s, const AbstractMetaFun
if (invalidateReturn)
s << INDENT << "bool invalidateArg0 = " PYTHON_RETURN_VAR "->ob_refcnt == 1;" << endl;
- if (func->typeReplaced(0) != "PyObject") {
+ if (func->typeReplaced(0) != QLatin1String("PyObject")) {
s << INDENT << "// Check return type" << endl;
s << INDENT;
@@ -733,7 +758,7 @@ void CppGenerator::writeVirtualMethodNative(QTextStream&s, const AbstractMetaFun
s << INDENT << "// Check return type" << endl;
s << INDENT << "bool typeIsValid = ";
- writeTypeCheck(s, func->type(), PYTHON_RETURN_VAR,
+ writeTypeCheck(s, func->type(), QLatin1String(PYTHON_RETURN_VAR),
isNumber(func->type()->typeEntry()), func->typeReplaced(0));
s << ';' << endl;
s << INDENT << "if (!typeIsValid";
@@ -754,9 +779,10 @@ void CppGenerator::writeVirtualMethodNative(QTextStream&s, const AbstractMetaFun
if (!func->conversionRule(TypeSystem::NativeCode, 0).isEmpty()) {
// Has conversion rule.
- writeConversionRule(s, func, TypeSystem::NativeCode, CPP_RETURN_VAR);
+ writeConversionRule(s, func, TypeSystem::NativeCode, QLatin1String(CPP_RETURN_VAR));
} else if (!injectedCodeHasReturnValueAttribution(func, TypeSystem::NativeCode)) {
- writePythonToCppTypeConversion(s, func->type(), PYTHON_RETURN_VAR, CPP_RETURN_VAR, func->implementingClass());
+ writePythonToCppTypeConversion(s, func->type(), QLatin1String(PYTHON_RETURN_VAR),
+ QLatin1String(CPP_RETURN_VAR), func->implementingClass());
}
}
}
@@ -799,8 +825,8 @@ void CppGenerator::writeVirtualMethodNative(QTextStream&s, const AbstractMetaFun
if (isProtectedEnum) {
QString typeCast;
if (metaEnum->enclosingClass())
- typeCast += QString("::%1").arg(metaEnum->enclosingClass()->qualifiedCppName());
- typeCast += QString("::%1").arg(metaEnum->name());
+ typeCast += QLatin1String("::") + metaEnum->enclosingClass()->qualifiedCppName();
+ typeCast += QLatin1String("::") + metaEnum->name();
s << '(' << typeCast << ')';
}
}
@@ -832,7 +858,7 @@ void CppGenerator::writeMetaObjectMethod(QTextStream& s, const AbstractMetaClass
s << "{" << endl;
AbstractMetaFunction *func = NULL;
- AbstractMetaFunctionList list = metaClass->queryFunctionsByName("qt_metacall");
+ AbstractMetaFunctionList list = metaClass->queryFunctionsByName(QLatin1String("qt_metacall"));
if (list.size() == 1)
func = list[0];
@@ -878,7 +904,7 @@ void CppGenerator::writeEnumConverterFunctions(QTextStream& s, const TypeEntry*
{
if (!enumType)
return;
- QString enumFlagName = enumType->isFlags() ? "flag" : "enum";
+ QString enumFlagName = enumType->isFlags() ? QLatin1String("flag") : QLatin1String("enum");
QString typeName = fixedCppTypeName(enumType);
QString enumPythonType = cpythonTypeNameExt(enumType);
QString cppTypeName = getFullTypeName(enumType).trimmed();
@@ -897,7 +923,7 @@ void CppGenerator::writeEnumConverterFunctions(QTextStream& s, const TypeEntry*
c << ';' << endl;
writePythonToCppFunction(s, code, typeName, typeName);
- QString pyTypeCheck = QString("PyObject_TypeCheck(pyIn, %1)").arg(enumPythonType);
+ QString pyTypeCheck = QStringLiteral("PyObject_TypeCheck(pyIn, %1)").arg(enumPythonType);
writeIsPythonConvertibleToCppFunction(s, typeName, typeName, pyTypeCheck);
code.clear();
@@ -938,8 +964,9 @@ void CppGenerator::writeEnumConverterFunctions(QTextStream& s, const TypeEntry*
c << INDENT << "Shiboken::AutoDecRef pyLong(PyNumber_Long(pyIn));" << endl;
c << INDENT << "*((" << cppTypeName << "*)cppOut) = " << cppTypeName;
c << "(QFlag((int)PyLong_AsLong(pyLong.object())));" << endl;
- writePythonToCppFunction(s, code, "number", flagsTypeName);
- writeIsPythonConvertibleToCppFunction(s, "number", flagsTypeName, "PyNumber_Check(pyIn)");
+ writePythonToCppFunction(s, code, QLatin1String("number"), flagsTypeName);
+ writeIsPythonConvertibleToCppFunction(s, QLatin1String("number"), flagsTypeName,
+ QLatin1String("PyNumber_Check(pyIn)"));
}
void CppGenerator::writeConverterFunctions(QTextStream& s, const AbstractMetaClass* metaClass)
@@ -964,14 +991,14 @@ void CppGenerator::writeConverterFunctions(QTextStream& s, const AbstractMetaCla
s << "// Python to C++ pointer conversion - returns the C++ object of the Python wrapper (keeps object identity)." << endl;
QString sourceTypeName = metaClass->name();
- QString targetTypeName = QString("%1_PTR").arg(metaClass->name());
+ QString targetTypeName = metaClass->name() + QLatin1String("_PTR");
QString code;
QTextStream c(&code);
c << INDENT << "Shiboken::Conversions::pythonToCppPointer(&" << cpythonType << ", pyIn, cppOut);";
writePythonToCppFunction(s, code, sourceTypeName, targetTypeName);
// "Is convertible" function for the Python object to C++ pointer conversion.
- QString pyTypeCheck = QString("PyObject_TypeCheck(pyIn, (PyTypeObject*)&%1)").arg(cpythonType);
+ QString pyTypeCheck = QStringLiteral("PyObject_TypeCheck(pyIn, (PyTypeObject*)&%1)").arg(cpythonType);
writeIsPythonConvertibleToCppFunction(s, sourceTypeName, targetTypeName, pyTypeCheck, QString(), true);
s << endl;
@@ -1005,8 +1032,9 @@ void CppGenerator::writeConverterFunctions(QTextStream& s, const AbstractMetaCla
// Always copies C++ value (not pointer, and not reference) to a new Python wrapper.
s << endl << "// C++ to Python copy conversion." << endl;
- sourceTypeName = QString("%1_COPY").arg(metaClass->name());
targetTypeName = metaClass->name();
+ sourceTypeName = targetTypeName + QLatin1String("_COPY");
+
code.clear();
c << INDENT << "return Shiboken::Object::newObject(&" << cpythonType << ", new ::" << wrapperName(metaClass);
c << "(*((" << typeName << "*)cppIn)), true, true);";
@@ -1016,9 +1044,10 @@ void CppGenerator::writeConverterFunctions(QTextStream& s, const AbstractMetaCla
// Python to C++ copy conversion.
s << "// Python to C++ copy conversion." << endl;
sourceTypeName = metaClass->name();
- targetTypeName = QString("%1_COPY").arg(sourceTypeName);
+ targetTypeName = QStringLiteral("%1_COPY").arg(sourceTypeName);
code.clear();
- c << INDENT << "*((" << typeName << "*)cppOut) = *" << cpythonWrapperCPtr(metaClass->typeEntry(), "pyIn") << ';';
+ c << INDENT << "*((" << typeName << "*)cppOut) = *"
+ << cpythonWrapperCPtr(metaClass->typeEntry(), QLatin1String("pyIn")) << ';';
writePythonToCppFunction(s, code, sourceTypeName, targetTypeName);
// "Is convertible" function for the Python object to C++ value copy conversion.
@@ -1050,9 +1079,8 @@ void CppGenerator::writeConverterFunctions(QTextStream& s, const AbstractMetaCla
QString toCppPreConv;
if (conv->isConversionOperator()) {
const AbstractMetaClass* sourceClass = conv->ownerClass();
- typeCheck = QString("PyObject_TypeCheck(pyIn, %1)").arg(cpythonTypeNameExt(sourceClass->typeEntry()));
- toCppConv = QString("*%1").arg(cpythonWrapperCPtr(sourceClass->typeEntry(), "pyIn"));
-
+ typeCheck = QStringLiteral("PyObject_TypeCheck(pyIn, %1)").arg(cpythonTypeNameExt(sourceClass->typeEntry()));
+ toCppConv = QLatin1Char('*') + cpythonWrapperCPtr(sourceClass->typeEntry(), QLatin1String("pyIn"));
} else {
// Constructor that does implicit conversion.
if (!conv->typeReplaced(1).isEmpty())
@@ -1066,18 +1094,18 @@ void CppGenerator::writeConverterFunctions(QTextStream& s, const AbstractMetaCla
&& !sourceType->typeEntry()->isEnum()
&& !sourceType->typeEntry()->isFlags()
&& !sourceType->typeEntry()->isContainer()) {
- typeCheck += '(';
+ typeCheck += QLatin1Char('(');
}
if (isWrapperType(sourceType)) {
- typeCheck = QString("%1pyIn)").arg(typeCheck);
- toCppConv = QString("%1%2")
- .arg((sourceType->isReference() || !isPointerToWrapperType(sourceType)) ? "*" : "")
- .arg(cpythonWrapperCPtr(sourceType->typeEntry(), "pyIn"));
- } else if (typeCheck.contains("%in")) {
- typeCheck.replace("%in", "pyIn");
- typeCheck = QString("%1)").arg(typeCheck);
+ typeCheck += QLatin1String("pyIn)");
+ toCppConv = (sourceType->isReference() || !isPointerToWrapperType(sourceType))
+ ? QLatin1String("*") : QString();
+ toCppConv += cpythonWrapperCPtr(sourceType->typeEntry(), QLatin1String("pyIn"));
+ } else if (typeCheck.contains(QLatin1String("%in"))) {
+ typeCheck.replace(QLatin1String("%in"), QLatin1String("pyIn"));
+ typeCheck.append(QLatin1Char(')'));
} else {
- typeCheck = QString("%1pyIn)").arg(typeCheck);
+ typeCheck += QLatin1String("pyIn)");
}
if (isUserPrimitive(sourceType)
@@ -1089,12 +1117,12 @@ void CppGenerator::writeConverterFunctions(QTextStream& s, const AbstractMetaCla
pc << INDENT << getFullTypeNameWithoutModifiers(sourceType) << " cppIn";
writeMinimalConstructorExpression(pc, sourceType);
pc << ';' << endl;
- writeToCppConversion(pc, sourceType, 0, "pyIn", "cppIn");
+ writeToCppConversion(pc, sourceType, 0, QLatin1String("pyIn"), QLatin1String("cppIn"));
pc << ';';
- toCppConv.append("cppIn");
+ toCppConv.append(QLatin1String("cppIn"));
} else if (!isWrapperType(sourceType)) {
QTextStream tcc(&toCppConv);
- writeToCppConversion(tcc, sourceType, metaClass, "pyIn", "/*BOZO-1061*/");
+ writeToCppConversion(tcc, sourceType, metaClass, QLatin1String("pyIn"), QLatin1String("/*BOZO-1061*/"));
}
@@ -1131,14 +1159,14 @@ void CppGenerator::writeConverterRegister(QTextStream& s, const AbstractMetaClas
{
Indentation indent(INDENT);
QString sourceTypeName = metaClass->name();
- QString targetTypeName = QString("%1_PTR").arg(metaClass->name());
+ QString targetTypeName = sourceTypeName + QLatin1String("_PTR");
s << INDENT << pythonToCppFunctionName(sourceTypeName, targetTypeName) << ',' << endl;
s << INDENT << convertibleToCppFunctionName(sourceTypeName, targetTypeName) << ',' << endl;
std::swap(targetTypeName, sourceTypeName);
s << INDENT << cppToPythonFunctionName(sourceTypeName, targetTypeName);
if (metaClass->typeEntry()->isValue()) {
s << ',' << endl;
- sourceTypeName = QString("%1_COPY").arg(metaClass->name());
+ sourceTypeName = metaClass->name() + QLatin1String("_COPY");
s << INDENT << cppToPythonFunctionName(sourceTypeName, targetTypeName);
}
}
@@ -1146,9 +1174,9 @@ void CppGenerator::writeConverterRegister(QTextStream& s, const AbstractMetaClas
s << endl;
- QStringList cppSignature = metaClass->qualifiedCppName().split("::", QString::SkipEmptyParts);
+ QStringList cppSignature = metaClass->qualifiedCppName().split(QLatin1String("::"), QString::SkipEmptyParts);
while (!cppSignature.isEmpty()) {
- QString signature = cppSignature.join("::");
+ QString signature = cppSignature.join(QLatin1String("::"));
s << INDENT << "Shiboken::Conversions::registerConverterName(converter, \"" << signature << "\");" << endl;
s << INDENT << "Shiboken::Conversions::registerConverterName(converter, \"" << signature << "*\");" << endl;
s << INDENT << "Shiboken::Conversions::registerConverterName(converter, \"" << signature << "&\");" << endl;
@@ -1170,10 +1198,10 @@ void CppGenerator::writeConverterRegister(QTextStream& s, const AbstractMetaClas
// Python to C++ copy (value, not pointer neither reference) conversion.
s << INDENT << "// Add Python to C++ copy (value, not pointer neither reference) conversion to type converter." << endl;
QString sourceTypeName = metaClass->name();
- QString targetTypeName = QString("%1_COPY").arg(metaClass->name());
+ QString targetTypeName = sourceTypeName + QLatin1String("_COPY");
QString toCpp = pythonToCppFunctionName(sourceTypeName, targetTypeName);
QString isConv = convertibleToCppFunctionName(sourceTypeName, targetTypeName);
- writeAddPythonToCppConversion(s, "converter", toCpp, isConv);
+ writeAddPythonToCppConversion(s, QLatin1String("converter"), toCpp, isConv);
// User provided implicit conversions.
CustomConversion* customConversion = metaClass->typeEntry()->customConversion();
@@ -1205,10 +1233,10 @@ void CppGenerator::writeConverterRegister(QTextStream& s, const AbstractMetaClas
}
QString toCpp = pythonToCppFunctionName(sourceType, targetType);
QString isConv = convertibleToCppFunctionName(sourceType, targetType);
- writeAddPythonToCppConversion(s, "converter", toCpp, isConv);
+ writeAddPythonToCppConversion(s, QLatin1String("converter"), toCpp, isConv);
}
- writeCustomConverterRegister(s, customConversion, "converter");
+ writeCustomConverterRegister(s, customConversion, QLatin1String("converter"));
}
void CppGenerator::writeCustomConverterRegister(QTextStream& s, const CustomConversion* customConversion, const QString& converterVar)
@@ -1284,9 +1312,9 @@ void CppGenerator::writeMethodWrapperPreamble(QTextStream& s, OverloadData& over
s << INDENT << "int overloadId = -1;" << endl;
s << INDENT << "PythonToCppFunc " PYTHON_TO_CPP_VAR;
if (pythonFunctionWrapperUsesListOfArguments(overloadData))
- s << "[] = { 0" << QString(", 0").repeated(maxArgs-1) << " }";
+ s << "[] = { 0" << QString::fromLatin1(", 0").repeated(maxArgs-1) << " }";
s << ';' << endl;
- writeUnusedVariableCast(s, PYTHON_TO_CPP_VAR);
+ writeUnusedVariableCast(s, QLatin1String(PYTHON_TO_CPP_VAR));
}
if (usesNamedArguments && !rfunc->isCallOperator())
@@ -1325,10 +1353,12 @@ void CppGenerator::writeConstructorWrapper(QTextStream& s, const AbstractMetaFun
}
QStringList argNamesList = argNamesSet.toList();
qSort(argNamesList.begin(), argNamesList.end());
- if (argNamesList.isEmpty())
+ if (argNamesList.isEmpty()) {
s << INDENT << "const char** argNames = 0;" << endl;
- else
- s << INDENT << "const char* argNames[] = {\"" << argNamesList.join("\", \"") << "\"};" << endl;
+ } else {
+ s << INDENT << "const char* argNames[] = {\""
+ << argNamesList.join(QLatin1String("\", \"")) << "\"};" << endl;
+ }
s << INDENT << "const QMetaObject* metaObject;" << endl;
}
@@ -1481,7 +1511,7 @@ void CppGenerator::writeMethodWrapper(QTextStream& s, const AbstractMetaFunction
&& !rfunc->isCallOperator()
&& rfunc->isOperatorOverload();
if (callExtendedReverseOperator) {
- QString revOpName = ShibokenGenerator::pythonOperatorFunctionName(rfunc).insert(2, 'r');
+ QString revOpName = ShibokenGenerator::pythonOperatorFunctionName(rfunc).insert(2, QLatin1Char('r'));
if (rfunc->isBinaryOperator()) {
s << INDENT << "if (!isReverse" << endl;
{
@@ -1556,7 +1586,9 @@ void CppGenerator::writeArgumentsInitializer(QTextStream& s, OverloadData& overl
int maxArgs = overloadData.maxArgs();
s << INDENT << "PyObject* ";
- s << PYTHON_ARGS "[] = {" << QString(maxArgs, '0').split("", QString::SkipEmptyParts).join(", ") << "};" << endl;
+ s << PYTHON_ARGS "[] = {"
+ << QString(maxArgs, QLatin1Char('0')).split(QLatin1String(""), QString::SkipEmptyParts).join(QLatin1String(", "))
+ << "};" << endl;
s << endl;
if (overloadData.hasVarargs()) {
@@ -1603,12 +1635,12 @@ void CppGenerator::writeArgumentsInitializer(QTextStream& s, OverloadData& overl
if (!invalidArgsLength.isEmpty()) {
QStringList invArgsLen;
foreach (int i, invalidArgsLength)
- invArgsLen << QString("numArgs == %1").arg(i);
+ invArgsLen << QStringLiteral("numArgs == %1").arg(i);
if (usesNamedArguments && (!ownerClassIsQObject || minArgs > 0))
s << " else ";
else
s << INDENT;
- s << "if (" << invArgsLen.join(" || ") << ")" << endl;
+ s << "if (" << invArgsLen.join(QLatin1String(" || ")) << ")" << endl;
Indentation indent(INDENT);
s << INDENT << "goto " << cpythonFunctionName(rfunc) << "_TypeError;";
}
@@ -1620,7 +1652,7 @@ void CppGenerator::writeArgumentsInitializer(QTextStream& s, OverloadData& overl
else
funcName = rfunc->name();
- QString argsVar = overloadData.hasVarargs() ? "nonvarargs" : "args";
+ QString argsVar = overloadData.hasVarargs() ? QLatin1String("nonvarargs") : QLatin1String("args");
s << INDENT << "if (!";
if (usesNamedArguments)
s << "PyArg_ParseTuple(" << argsVar << ", \"|" << QByteArray(maxArgs, 'O') << ':' << funcName << '"';
@@ -1628,8 +1660,8 @@ void CppGenerator::writeArgumentsInitializer(QTextStream& s, OverloadData& overl
s << "PyArg_UnpackTuple(" << argsVar << ", \"" << funcName << "\", " << minArgs << ", " << maxArgs;
QStringList palist;
for (int i = 0; i < maxArgs; i++)
- palist << QString("&(" PYTHON_ARGS "[%1])").arg(i);
- s << ", " << palist.join(", ") << "))" << endl;
+ palist << QString::fromLatin1("&(" PYTHON_ARGS "[%1])").arg(i);
+ s << ", " << palist.join(QLatin1String(", ")) << "))" << endl;
{
Indentation indent(INDENT);
s << INDENT << "return " << m_currentErrorCode << ';' << endl;
@@ -1640,23 +1672,23 @@ void CppGenerator::writeArgumentsInitializer(QTextStream& s, OverloadData& overl
void CppGenerator::writeCppSelfDefinition(QTextStream& s, const AbstractMetaClass* metaClass, bool hasStaticOverload, bool cppSelfAsReference)
{
bool useWrapperClass = avoidProtectedHack() && metaClass->hasProtectedMembers();
- QString className = useWrapperClass ? wrapperName(metaClass) : QString("::%1").arg(metaClass->qualifiedCppName());
+ QString className = useWrapperClass
+ ? wrapperName(metaClass)
+ : (QLatin1String("::") + metaClass->qualifiedCppName());
QString cppSelfAttribution;
if (cppSelfAsReference) {
- QString cast = useWrapperClass ? QString("(%1*)").arg(className) : QString();
- cppSelfAttribution = QString("%1& %2 = *(%3%4)")
- .arg(className)
- .arg(CPP_SELF_VAR)
- .arg(cast)
- .arg(cpythonWrapperCPtr(metaClass, PYTHON_SELF_VAR));
+ QString cast = useWrapperClass ? QString::fromLatin1("(%1*)").arg(className) : QString();
+ cppSelfAttribution = QString::fromLatin1("%1& %2 = *(%3%4)")
+ .arg(className, QLatin1String(CPP_SELF_VAR), cast,
+ cpythonWrapperCPtr(metaClass, QLatin1String(PYTHON_SELF_VAR)));
} else {
s << INDENT << className << "* " CPP_SELF_VAR " = 0;" << endl;
- writeUnusedVariableCast(s, CPP_SELF_VAR);
- cppSelfAttribution = QString("%1 = %2%3")
- .arg(CPP_SELF_VAR)
- .arg(useWrapperClass ? QString("(%1*)").arg(className) : "")
- .arg(cpythonWrapperCPtr(metaClass, PYTHON_SELF_VAR));
+ writeUnusedVariableCast(s, QLatin1String(CPP_SELF_VAR));
+ cppSelfAttribution = QString::fromLatin1("%1 = %2%3")
+ .arg(QLatin1String(CPP_SELF_VAR),
+ (useWrapperClass ? QString::fromLatin1("(%1*)").arg(className) : QString()),
+ cpythonWrapperCPtr(metaClass, QLatin1String(PYTHON_SELF_VAR)));
}
// Checks if the underlying C++ object is valid.
@@ -1664,14 +1696,14 @@ void CppGenerator::writeCppSelfDefinition(QTextStream& s, const AbstractMetaClas
s << INDENT << "if (" PYTHON_SELF_VAR ") {" << endl;
{
Indentation indent(INDENT);
- writeInvalidPyObjectCheck(s, PYTHON_SELF_VAR);
+ writeInvalidPyObjectCheck(s, QLatin1String(PYTHON_SELF_VAR));
s << INDENT << cppSelfAttribution << ';' << endl;
}
s << INDENT << '}' << endl;
return;
}
- writeInvalidPyObjectCheck(s, PYTHON_SELF_VAR);
+ writeInvalidPyObjectCheck(s, QLatin1String(PYTHON_SELF_VAR));
s << INDENT << cppSelfAttribution << ';' << endl;
}
@@ -1705,7 +1737,8 @@ void CppGenerator::writeErrorSection(QTextStream& s, OverloadData& overloadData)
Indentation indentation(INDENT);
QString funcName = fullPythonFunctionName(rfunc);
- QString argsVar = pythonFunctionWrapperUsesListOfArguments(overloadData) ? "args" : PYTHON_ARG;
+ QString argsVar = pythonFunctionWrapperUsesListOfArguments(overloadData)
+ ? QLatin1String("args") : QLatin1String(PYTHON_ARG);
if (verboseErrorMessagesDisabled()) {
s << INDENT << "Shiboken::setErrorAboutWrongArguments(" << argsVar << ", \"" << funcName << "\", 0);" << endl;
} else {
@@ -1716,69 +1749,74 @@ void CppGenerator::writeErrorSection(QTextStream& s, OverloadData& overloadData)
QString strArg;
AbstractMetaType* argType = arg->type();
if (isCString(argType)) {
- strArg = "\" SBK_STR_NAME \"";
+ strArg = QLatin1String("\" SBK_STR_NAME \"");
} else if (argType->isPrimitive()) {
const PrimitiveTypeEntry* ptp = reinterpret_cast<const PrimitiveTypeEntry*>(argType->typeEntry());
while (ptp->aliasedTypeEntry())
ptp = ptp->aliasedTypeEntry();
strArg = ptp->name();
- if (strArg == "QString") {
- strArg = "unicode";
- } else if (strArg == "QChar") {
- strArg = "1-unicode";
+ if (strArg == QLatin1String("QString")) {
+ strArg = QLatin1String("unicode");
+ } else if (strArg == QLatin1String("QChar")) {
+ strArg = QLatin1String("1-unicode");
} else {
- strArg = ptp->name().replace(QRegExp("^signed\\s+"), "");
- if (strArg == "double")
- strArg = "float";
+ strArg = ptp->name();
+ strArg.remove(QRegExp(QLatin1String("^signed\\s+")));
+ if (strArg == QLatin1String("double"))
+ strArg = QLatin1String("float");
}
} else if (argType->typeEntry()->isContainer()) {
strArg = argType->fullName();
- if (strArg == "QList" || strArg == "QVector"
- || strArg == "QLinkedList" || strArg == "QStack"
- || strArg == "QQueue") {
- strArg = "list";
- } else if (strArg == "QMap" || strArg == "QHash"
- || strArg == "QMultiMap" || strArg == "QMultiHash") {
- strArg = "dict";
- } else if (strArg == "QPair") {
- strArg = "2-tuple";
+ if (strArg == QLatin1String("QList") || strArg == QLatin1String("QVector")
+ || strArg == QLatin1String("QLinkedList") || strArg == QLatin1String("QStack")
+ || strArg == QLatin1String("QQueue")) {
+ strArg = QLatin1String("list");
+ } else if (strArg == QLatin1String("QMap") || strArg == QLatin1String("QHash")
+ || strArg == QLatin1String("QMultiMap") || strArg == QLatin1String("QMultiHash")) {
+ strArg = QLatin1String("dict");
+ } else if (strArg == QLatin1String("QPair")) {
+ strArg = QLatin1String("2-tuple");
}
} else {
strArg = argType->fullName();
- if (strArg == "PyUnicode")
- strArg = "unicode";
- else if (strArg == "PyString")
- strArg = "str";
- else if (strArg == "PyBytes")
- strArg = "\" SBK_STR_NAME \"";
- else if (strArg == "PySequece")
- strArg = "list";
- else if (strArg == "PyTuple")
- strArg = "tuple";
- else if (strArg == "PyDict")
- strArg = "dict";
- else if (strArg == "PyObject")
- strArg = "object";
- else if (strArg == "PyCallable")
- strArg = "callable";
- else if (strArg == "uchar")
- strArg = "buffer"; // This depends on an inject code to be true, but if it's not true
+ if (strArg == QLatin1String("PyUnicode"))
+ strArg = QLatin1String("unicode");
+ else if (strArg == QLatin1String("PyString"))
+ strArg = QLatin1String("str");
+ else if (strArg == QLatin1String("PyBytes"))
+ strArg = QLatin1String("\" SBK_STR_NAME \"");
+ else if (strArg == QLatin1String("PySequece"))
+ strArg = QLatin1String("list");
+ else if (strArg == QLatin1String("PyTuple"))
+ strArg = QLatin1String("tuple");
+ else if (strArg == QLatin1String("PyDict"))
+ strArg = QLatin1String("dict");
+ else if (strArg == QLatin1String("PyObject"))
+ strArg = QLatin1String("object");
+ else if (strArg == QLatin1String("PyCallable"))
+ strArg = QLatin1String("callable");
+ else if (strArg == QLatin1String("uchar"))
+ strArg = QLatin1String("buffer"); // This depends on an inject code to be true, but if it's not true
// the function wont work at all, so it must be true.
}
if (!arg->defaultValueExpression().isEmpty()) {
- strArg += " = ";
+ strArg += QLatin1String(" = ");
if ((isCString(argType) || isPointerToWrapperType(argType))
- && arg->defaultValueExpression() == "0") {
- strArg += "None";
+ && arg->defaultValueExpression() == QLatin1String("0")) {
+ strArg += QLatin1String("None");
} else {
- strArg += arg->defaultValueExpression().replace("::", ".").replace("\"", "\\\"");
+ QString e = arg->defaultValueExpression();
+ e.replace(QLatin1String("::"), QLatin1String("."));
+ e.replace(QLatin1String("\""), QLatin1String("\\\""));
+ strArg += e;
}
}
args << strArg;
}
- overloadSignatures << "\""+args.join(", ")+"\"";
+ overloadSignatures << QLatin1Char('"') + args.join(QLatin1String(", ")) + QLatin1Char('"');
}
- s << INDENT << "const char* overloads[] = {" << overloadSignatures.join(", ") << ", 0};" << endl;
+ s << INDENT << "const char* overloads[] = {" << overloadSignatures.join(QLatin1String(", "))
+ << ", 0};" << endl;
s << INDENT << "Shiboken::setErrorAboutWrongArguments(" << argsVar << ", \"" << funcName << "\", overloads);" << endl;
}
s << INDENT << "return " << m_currentErrorCode << ';' << endl;
@@ -1805,9 +1843,9 @@ void CppGenerator::writeInvalidPyObjectCheck(QTextStream& s, const QString& pyOb
static QString pythonToCppConverterForArgumentName(const QString& argumentName)
{
- static QRegExp pyArgsRegex(PYTHON_ARGS"(\\[\\d+[-]?\\d*\\])");
+ static QRegExp pyArgsRegex(QLatin1String(PYTHON_ARGS"(\\[\\d+[-]?\\d*\\])"));
pyArgsRegex.indexIn(argumentName);
- return QString(PYTHON_TO_CPP_VAR"%1").arg(pyArgsRegex.cap(1));
+ return QLatin1String(PYTHON_TO_CPP_VAR) + pyArgsRegex.cap(1);
}
void CppGenerator::writeTypeCheck(QTextStream& s, const AbstractMetaType* argType, QString argumentName, bool isNumber, QString customType, bool rejectNull)
@@ -1826,18 +1864,18 @@ void CppGenerator::writeTypeCheck(QTextStream& s, const AbstractMetaType* argTyp
typeCheck = cpythonIsConvertibleFunction(argType, argType->isEnum() ? false : isNumber);
else
typeCheck = customCheck;
- typeCheck.append(QString("(%1)").arg(argumentName));
+ typeCheck.append(QString::fromLatin1("(%1)").arg(argumentName));
// TODO-CONVERTER -----------------------------------------------------------------------
if (customCheck.isEmpty() && !argType->typeEntry()->isCustom()) {
- typeCheck = QString("(%1 = %2))").arg(pythonToCppConverterForArgumentName(argumentName)).arg(typeCheck);
+ typeCheck = QString::fromLatin1("(%1 = %2))").arg(pythonToCppConverterForArgumentName(argumentName), typeCheck);
if (!isNumber && argType->typeEntry()->isCppPrimitive())
- typeCheck.prepend(QString("%1(%2) && ").arg(cpythonCheckFunction(argType)).arg(argumentName));
+ typeCheck.prepend(QString::fromLatin1("%1(%2) && ").arg(cpythonCheckFunction(argType), argumentName));
}
// TODO-CONVERTER -----------------------------------------------------------------------
if (rejectNull)
- typeCheck = QString("(%1 != Py_None && %2)").arg(argumentName).arg(typeCheck);
+ typeCheck = QString::fromLatin1("(%1 != Py_None && %2)").arg(argumentName, typeCheck);
s << typeCheck;
}
@@ -1855,7 +1893,7 @@ static void checkTypeViability(const AbstractMetaFunction* func, const AbstractM
return;
QString prefix;
if (func->ownerClass())
- prefix = QString("%1::").arg(func->ownerClass()->qualifiedCppName());
+ prefix = func->ownerClass()->qualifiedCppName() + QLatin1String("::");
qCWarning(lcShiboken).noquote().nospace()
<< QString::fromLatin1("There's no user provided way (conversion rule, argument removal, custom code, etc) "
"to handle the primitive %1 type '%2' in function '%3%4'.")
@@ -1892,7 +1930,7 @@ void CppGenerator::writeTypeCheck(QTextStream& s, const OverloadData* overloadDa
// PyInt type to come after the more precise numeric types (e.g. float and bool)
const AbstractMetaType* argType = overloadData->argType();
bool numberType = numericTypes.count() == 1 || ShibokenGenerator::isPyInt(argType);
- QString customType = (overloadData->hasArgumentTypeReplace() ? overloadData->argumentTypeReplaced() : "");
+ QString customType = (overloadData->hasArgumentTypeReplace() ? overloadData->argumentTypeReplaced() : QString());
bool rejectNull = shouldRejectNullPointerArgument(overloadData->referenceFunction(), overloadData->argPos());
writeTypeCheck(s, argType, argumentName, numberType, customType, rejectNull);
}
@@ -1947,7 +1985,7 @@ void CppGenerator::writePythonToCppTypeConversion(QTextStream& s,
if (typeEntry->isCustom() || typeEntry->isVarargs())
return;
- QString cppOutAux = QString("%1_local").arg(cppOut);
+ QString cppOutAux = cppOut + QLatin1String("_local");
bool treatAsPointer = isValueTypeWithCopyConstructorOnly(type);
bool isPointerOrObjectType = (isObjectType(type) || isPointer(type)) && !isUserPrimitive(type) && !isCppPrimitive(type);
@@ -1968,14 +2006,16 @@ void CppGenerator::writePythonToCppTypeConversion(QTextStream& s,
} else if (avoidProtectedHack() && type->typeEntry()->isEnum()) {
const AbstractMetaEnum* metaEnum = findAbstractMetaEnum(type);
if (metaEnum && metaEnum->isProtected()) {
- typeName = "long";
+ typeName = QLatin1String("long");
isProtectedEnum = true;
}
}
s << INDENT << typeName;
if (treatAsPointer || isPointerOrObjectType) {
- s << "* " << cppOut << (defaultValue.isEmpty() ? "" : QString(" = %1").arg(defaultValue));
+ s << "* " << cppOut;
+ if (!defaultValue.isEmpty())
+ s << " = " << defaultValue;
} else if (type->isReference() && !typeEntry->isPrimitive() && isNotContainerEnumOrFlags) {
s << "* " << cppOut << " = &" << cppOutAux;
} else {
@@ -2000,7 +2040,7 @@ void CppGenerator::writePythonToCppTypeConversion(QTextStream& s,
if (!defaultValue.isEmpty())
s << "if (" << pythonToCppFunc << ") ";
- QString pythonToCppCall = QString("%1(%2, &%3)").arg(pythonToCppFunc).arg(pyIn).arg(cppOut);
+ QString pythonToCppCall = QString::fromLatin1("%1(%2, &%3)").arg(pythonToCppFunc, pyIn, cppOut);
if (!mayHaveImplicitConversion) {
s << pythonToCppCall << ';' << endl;
return;
@@ -2035,10 +2075,10 @@ static void addConversionRuleCodeSnippet(CodeSnipList& snippetList, QString& rul
if (rule.isEmpty())
return;
if (snippetLanguage == TypeSystem::TargetLangCode) {
- rule.replace("%in", inputName);
- rule.replace("%out", QString("%1_out").arg(outputName));
+ rule.replace(QLatin1String("%in"), inputName);
+ rule.replace(QLatin1String("%out"), outputName + QLatin1String("_out"));
} else {
- rule.replace("%out", outputName);
+ rule.replace(QLatin1String("%out"), outputName);
}
CodeSnip snip(0, snippetLanguage);
snip.position = (snippetLanguage == TypeSystem::NativeCode) ? CodeSnip::Any : CodeSnip::Beginning;
@@ -2180,15 +2220,17 @@ void CppGenerator::writeOverloadedFunctionDecisorEngine(QTextStream& s, const Ov
const AbstractMetaFunction* refFunc = overloadData->referenceFunction();
QStringList typeChecks;
- QString pyArgName = (usePyArgs && maxArgs > 1) ? QString(PYTHON_ARGS "[%1]").arg(overloadData->argPos()) : PYTHON_ARG;
+ QString pyArgName = (usePyArgs && maxArgs > 1)
+ ? QString::fromLatin1(PYTHON_ARGS "[%1]").arg(overloadData->argPos())
+ : QLatin1String(PYTHON_ARG);
OverloadData* od = overloadData;
int startArg = od->argPos();
int sequenceArgCount = 0;
while (od && !od->argType()->isVarargs()) {
- bool typeReplacedByPyObject = od->argumentTypeReplaced() == "PyObject";
+ bool typeReplacedByPyObject = od->argumentTypeReplaced() == QLatin1String("PyObject");
if (!typeReplacedByPyObject) {
if (usePyArgs)
- pyArgName = QString(PYTHON_ARGS "[%1]").arg(od->argPos());
+ pyArgName = QString::fromLatin1(PYTHON_ARGS "[%1]").arg(od->argPos());
QString typeCheck;
QTextStream tck(&typeCheck);
const AbstractMetaFunction* func = od->referenceFunction();
@@ -2223,11 +2265,11 @@ void CppGenerator::writeOverloadedFunctionDecisorEngine(QTextStream& s, const Ov
AbstractMetaArgumentList args = refFunc->arguments();
int lastArgIsVarargs = (int) (args.size() > 1 && args.last()->type()->isVarargs());
int numArgs = args.size() - OverloadData::numberOfRemovedArguments(refFunc) - lastArgIsVarargs;
- typeChecks.prepend(QString("numArgs %1 %2").arg(lastArgIsVarargs ? ">=" : "==").arg(numArgs));
+ typeChecks.prepend(QString::fromLatin1("numArgs %1 %2").arg(lastArgIsVarargs ? QLatin1String(">=") : QLatin1String("==")).arg(numArgs));
} else if (sequenceArgCount > 1) {
- typeChecks.prepend(QString("numArgs >= %1").arg(startArg + sequenceArgCount));
+ typeChecks.prepend(QString::fromLatin1("numArgs >= %1").arg(startArg + sequenceArgCount));
} else if (refFunc->isOperatorOverload() && !refFunc->isCallOperator()) {
- typeChecks.prepend(QString("%1isReverse").arg(refFunc->isReverseOperator() ? "" : "!"));
+ typeChecks.prepend(QString::fromLatin1("%1isReverse").arg(refFunc->isReverseOperator() ? QString() : QLatin1String("!")));
}
if (isFirst) {
@@ -2286,12 +2328,14 @@ void CppGenerator::writeSingleFunctionCall(QTextStream& s, const OverloadData& o
{
if (func->isDeprecated()) {
s << INDENT << "Shiboken::warning(PyExc_DeprecationWarning, 1, \"Function: '"
- << func->signature().replace("::", ".")
+ << func->signature().replace(QLatin1String("::"), QLatin1String("."))
<< "' is marked as deprecated, please check the documentation for more information.\");" << endl;
}
if (func->functionType() == AbstractMetaFunction::EmptyFunction) {
- s << INDENT << "PyErr_Format(PyExc_TypeError, \"%s is a private method.\", \"" << func->signature().replace("::", ".") << "\");" << endl;
+ s << INDENT << "PyErr_Format(PyExc_TypeError, \"%s is a private method.\", \""
+ << func->signature().replace(QLatin1String("::"), QLatin1String("."))
+ << "\");" << endl;
s << INDENT << "return " << m_currentErrorCode << ';' << endl;
return;
}
@@ -2309,16 +2353,15 @@ void CppGenerator::writeSingleFunctionCall(QTextStream& s, const OverloadData& o
const AbstractMetaArgument* arg = func->arguments().at(argIdx);
if (func->argumentRemoved(argIdx + 1)) {
if (!arg->defaultValueExpression().isEmpty()) {
- QString cppArgRemoved = QString(CPP_ARG_REMOVED "%1").arg(argIdx);
+ QString cppArgRemoved = QString::fromLatin1(CPP_ARG_REMOVED "%1").arg(argIdx);
s << INDENT << getFullTypeName(arg->type()) << ' ' << cppArgRemoved;
s << " = " << guessScopeForDefaultValue(func, arg) << ';' << endl;
writeUnusedVariableCast(s, cppArgRemoved);
} else if (!injectCodeCallsFunc && !func->isUserAdded() && !hasConversionRule) {
// When an argument is removed from a method signature and no other means of calling
// the method are provided (as with code injection) the generator must abort.
- qFatal(qPrintable(QString("No way to call '%1::%2' with the modifications described in the type system.")
- .arg(func->ownerClass()->name())
- .arg(func->signature())), NULL);
+ qFatal(qPrintable(QString::fromLatin1("No way to call '%1::%2' with the modifications described in the type system.")
+ .arg(func->ownerClass()->name(), func->signature())), NULL);
}
removedArgs++;
continue;
@@ -2329,8 +2372,8 @@ void CppGenerator::writeSingleFunctionCall(QTextStream& s, const OverloadData& o
if (!argType || (mayHaveUnunsedArguments && !injectedCodeUsesArgument(func, argIdx)))
continue;
int argPos = argIdx - removedArgs;
- QString argName = QString(CPP_ARG"%1").arg(argPos);
- QString pyArgName = usePyArgs ? QString(PYTHON_ARGS "[%1]").arg(argPos) : PYTHON_ARG;
+ QString argName = QString::fromLatin1(CPP_ARG"%1").arg(argPos);
+ QString pyArgName = usePyArgs ? QString::fromLatin1(PYTHON_ARGS "[%1]").arg(argPos) : QLatin1String(PYTHON_ARG);
QString defaultValue = guessScopeForDefaultValue(func, arg);
writeArgumentConversion(s, argType, argName, pyArgName, func->implementingClass(), defaultValue, func->isUserAdded());
}
@@ -2353,12 +2396,12 @@ QString CppGenerator::cppToPythonFunctionName(const QString& sourceTypeName, QSt
{
if (targetTypeName.isEmpty())
targetTypeName = sourceTypeName;
- return QString("%1_CppToPython_%2").arg(sourceTypeName).arg(targetTypeName);
+ return QString::fromLatin1("%1_CppToPython_%2").arg(sourceTypeName, targetTypeName);
}
QString CppGenerator::pythonToCppFunctionName(const QString& sourceTypeName, const QString& targetTypeName)
{
- return QString("%1_PythonToCpp_%2").arg(sourceTypeName).arg(targetTypeName);
+ return QString::fromLatin1("%1_PythonToCpp_%2").arg(sourceTypeName, targetTypeName);
}
QString CppGenerator::pythonToCppFunctionName(const AbstractMetaType* sourceType, const AbstractMetaType* targetType)
{
@@ -2372,7 +2415,7 @@ QString CppGenerator::pythonToCppFunctionName(const CustomConversion::TargetToNa
QString CppGenerator::convertibleToCppFunctionName(const QString& sourceTypeName, const QString& targetTypeName)
{
- return QString("is_%1_PythonToCpp_%2_Convertible").arg(sourceTypeName).arg(targetTypeName);
+ return QString::fromLatin1("is_%1_PythonToCpp_%2_Convertible").arg(sourceTypeName, targetTypeName);
}
QString CppGenerator::convertibleToCppFunctionName(const AbstractMetaType* sourceType, const AbstractMetaType* targetType)
{
@@ -2399,11 +2442,11 @@ void CppGenerator::writeCppToPythonFunction(QTextStream& s, const QString& code,
static void replaceCppToPythonVariables(QString& code, const QString& typeName)
{
- code.prepend(QString("%1& cppInRef = *((%1*)cppIn);\n").arg(typeName));
- code.replace("%INTYPE", typeName);
- code.replace("%OUTTYPE", "PyObject*");
- code.replace("%in", "cppInRef");
- code.replace("%out", "pyOut");
+ code.prepend(QString::fromLatin1("%1& cppInRef = *((%1*)cppIn);\n").arg(typeName));
+ code.replace(QLatin1String("%INTYPE"), typeName);
+ code.replace(QLatin1String("%OUTTYPE"), QLatin1String("PyObject*"));
+ code.replace(QLatin1String("%in"), QLatin1String("cppInRef"));
+ code.replace(QLatin1String("%out"), QLatin1String("pyOut"));
}
void CppGenerator::writeCppToPythonFunction(QTextStream& s, const CustomConversion* customConversion)
{
@@ -2415,7 +2458,7 @@ void CppGenerator::writeCppToPythonFunction(QTextStream& s, const AbstractMetaTy
{
const CustomConversion* customConversion = containerType->typeEntry()->customConversion();
if (!customConversion) {
- qFatal(qPrintable(QString("Can't write the C++ to Python conversion function for container type '%1' - "\
+ qFatal(qPrintable(QString::fromLatin1("Can't write the C++ to Python conversion function for container type '%1' - "\
"no conversion rule was defined for it in the type system.")
.arg(containerType->typeEntry()->qualifiedCppName())), NULL);
}
@@ -2428,8 +2471,8 @@ void CppGenerator::writeCppToPythonFunction(QTextStream& s, const AbstractMetaTy
AbstractMetaType* type = containerType->instantiations().at(i);
QString typeName = getFullTypeName(type);
if (type->isConstant())
- typeName = "const " + typeName;
- code.replace(QString("%INTYPE_%1").arg(i), typeName);
+ typeName = QLatin1String("const ") + typeName;
+ code.replace(QString::fromLatin1("%INTYPE_%1").arg(i), typeName);
}
replaceCppToPythonVariables(code, getFullTypeNameWithoutModifiers(containerType));
processCodeSnip(code);
@@ -2487,19 +2530,18 @@ void CppGenerator::writePythonToCppConversionFunctions(QTextStream& s,
QString code;
QTextStream c(&code);
if (conversion.isEmpty())
- conversion = QString("*%1").arg(cpythonWrapperCPtr(sourceType->typeEntry(), "pyIn"));
+ conversion = QLatin1Char('*') + cpythonWrapperCPtr(sourceType->typeEntry(), QLatin1String("pyIn"));
if (!preConversion.isEmpty())
c << INDENT << preConversion << endl;
- c << INDENT << QString("*((%1*)cppOut) = %1(%2);")
- .arg(getFullTypeName(targetType->typeEntry()))
- .arg(conversion);
+ c << INDENT << QString::fromLatin1("*((%1*)cppOut) = %1(%2);")
+ .arg(getFullTypeName(targetType->typeEntry()), conversion);
QString sourceTypeName = fixedCppTypeName(sourceType);
QString targetTypeName = fixedCppTypeName(targetType);
writePythonToCppFunction(s, code, sourceTypeName, targetTypeName);
// Python to C++ convertible check function.
if (typeCheck.isEmpty())
- typeCheck = QString("PyObject_TypeCheck(pyIn, %1)").arg(sourcePyType);
+ typeCheck = QString::fromLatin1("PyObject_TypeCheck(pyIn, %1)").arg(sourcePyType);
writeIsPythonConvertibleToCppFunction(s, sourceTypeName, targetTypeName, typeCheck);
s << endl;
}
@@ -2514,11 +2556,11 @@ void CppGenerator::writePythonToCppConversionFunctions(QTextStream& s,
if (toNative->sourceType())
inType = cpythonTypeNameExt(toNative->sourceType());
else
- inType = QString("(&%1_Type)").arg(toNative->sourceTypeName());
- code.replace("%INTYPE", inType);
- code.replace("%OUTTYPE", targetType->qualifiedCppName());
- code.replace("%in", "pyIn");
- code.replace("%out", QString("*((%1*)cppOut)").arg(getFullTypeName(targetType)));
+ inType = QString::fromLatin1("(&%1_Type)").arg(toNative->sourceTypeName());
+ code.replace(QLatin1String("%INTYPE"), inType);
+ code.replace(QLatin1String("%OUTTYPE"), targetType->qualifiedCppName());
+ code.replace(QLatin1String("%in"), QLatin1String("pyIn"));
+ code.replace(QLatin1String("%out"), QString::fromLatin1("*((%1*)cppOut)").arg(getFullTypeName(targetType)));
QString sourceTypeName = fixedCppTypeName(toNative);
QString targetTypeName = fixedCppTypeName(targetType);
@@ -2528,29 +2570,29 @@ void CppGenerator::writePythonToCppConversionFunctions(QTextStream& s,
QString typeCheck = toNative->sourceTypeCheck();
if (typeCheck.isEmpty()) {
QString pyTypeName = toNative->sourceTypeName();
- if (pyTypeName == "Py_None" || pyTypeName == "PyNone")
- typeCheck = "%in == Py_None";
- else if (pyTypeName == "SbkEnumType")
- typeCheck = "Shiboken::isShibokenEnum(%in)";
- else if (pyTypeName == "SbkObject")
- typeCheck = "Shiboken::Object::checkType(%in)";
- else if (pyTypeName == "PyTypeObject")
- typeCheck = "PyType_Check(%in)";
- else if (pyTypeName == "PyObject")
- typeCheck = "PyObject_TypeCheck(%in, &PyBaseObject_Type)";
- else if (pyTypeName.startsWith("Py"))
- typeCheck= QString("%1_Check(%in)").arg(pyTypeName);
+ if (pyTypeName == QLatin1String("Py_None") || pyTypeName == QLatin1String("PyNone"))
+ typeCheck = QLatin1String("%in == Py_None");
+ else if (pyTypeName == QLatin1String("SbkEnumType"))
+ typeCheck = QLatin1String("Shiboken::isShibokenEnum(%in)");
+ else if (pyTypeName == QLatin1String("SbkObject"))
+ typeCheck = QLatin1String("Shiboken::Object::checkType(%in)");
+ else if (pyTypeName == QLatin1String("PyTypeObject"))
+ typeCheck = QLatin1String("PyType_Check(%in)");
+ else if (pyTypeName == QLatin1String("PyObject"))
+ typeCheck = QLatin1String("PyObject_TypeCheck(%in, &PyBaseObject_Type)");
+ else if (pyTypeName.startsWith(QLatin1String("Py")))
+ typeCheck = pyTypeName + QLatin1String("_Check(%in)");
}
if (typeCheck.isEmpty()) {
if (!toNative->sourceType() || toNative->sourceType()->isPrimitive()) {
- qFatal(qPrintable(QString("User added implicit conversion for C++ type '%1' must provide either an input "\
+ qFatal(qPrintable(QString::fromLatin1("User added implicit conversion for C++ type '%1' must provide either an input "\
"type check function or a non primitive type entry.")
.arg(targetType->qualifiedCppName())), NULL);
}
- typeCheck = QString("PyObject_TypeCheck(%in, %1)").arg(cpythonTypeNameExt(toNative->sourceType()));
+ typeCheck = QString::fromLatin1("PyObject_TypeCheck(%in, %1)").arg(cpythonTypeNameExt(toNative->sourceType()));
}
- typeCheck.replace("%in", "pyIn");
+ typeCheck.replace(QLatin1String("%in"), QLatin1String("pyIn"));
processCodeSnip(typeCheck);
writeIsPythonConvertibleToCppFunction(s, sourceTypeName, targetTypeName, typeCheck);
}
@@ -2571,13 +2613,13 @@ void CppGenerator::writePythonToCppConversionFunctions(QTextStream& s, const Abs
QString cppTypeName = getFullTypeNameWithoutModifiers(containerType);
QString code;
QTextStream c(&code);
- c << INDENT << QString("%1& cppOutRef = *((%1*)cppOut);").arg(cppTypeName) << endl;
+ c << INDENT << QString::fromLatin1("%1& cppOutRef = *((%1*)cppOut);").arg(cppTypeName) << endl;
code.append(toCppConversions.first()->conversion());
for (int i = 0; i < containerType->instantiations().count(); ++i) {
const AbstractMetaType* type = containerType->instantiations().at(i);
QString typeName = getFullTypeName(type);
if (type->isValue() && isValueTypeWithCopyConstructorOnly(type)) {
- static QRegExp regex(CONVERTTOCPP_REGEX);
+ static QRegExp regex(QLatin1String(CONVERTTOCPP_REGEX));
int pos = 0;
while ((pos = regex.indexIn(code, pos)) != -1) {
pos += regex.matchedLength();
@@ -2585,25 +2627,25 @@ void CppGenerator::writePythonToCppConversionFunctions(QTextStream& s, const Abs
QString varName = list.at(1);
QString leftCode = code.left(pos);
QString rightCode = code.mid(pos);
- rightCode.replace(varName, "*"+varName);
+ rightCode.replace(varName, QLatin1Char('*') + varName);
code = leftCode + rightCode;
}
- typeName.append('*');
+ typeName.append(QLatin1Char('*'));
}
- code.replace(QString("%OUTTYPE_%1").arg(i), typeName);
+ code.replace(QString::fromLatin1("%OUTTYPE_%1").arg(i), typeName);
}
- code.replace("%OUTTYPE", cppTypeName);
- code.replace("%in", "pyIn");
- code.replace("%out", "cppOutRef");
+ code.replace(QLatin1String("%OUTTYPE"), cppTypeName);
+ code.replace(QLatin1String("%in"), QLatin1String("pyIn"));
+ code.replace(QLatin1String("%out"), QLatin1String("cppOutRef"));
QString typeName = fixedCppTypeName(containerType);
writePythonToCppFunction(s, code, typeName, typeName);
// Python to C++ convertible check function.
QString typeCheck = cpythonCheckFunction(containerType);
if (typeCheck.isEmpty())
- typeCheck = "false";
+ typeCheck = QLatin1String("false");
else
- typeCheck = QString("%1pyIn)").arg(typeCheck);
+ typeCheck = QString::fromLatin1("%1pyIn)").arg(typeCheck);
writeIsPythonConvertibleToCppFunction(s, typeName, typeName, typeCheck);
s << endl;
}
@@ -2625,8 +2667,8 @@ void CppGenerator::writeNamedArgumentResolution(QTextStream& s, const AbstractMe
if (args.isEmpty())
return;
- QString pyErrString("PyErr_SetString(PyExc_TypeError, \"" + fullPythonFunctionName(func)
- + "(): got multiple values for keyword argument '%1'.\");");
+ QString pyErrString(QLatin1String("PyErr_SetString(PyExc_TypeError, \"") + fullPythonFunctionName(func)
+ + QLatin1String("(): got multiple values for keyword argument '%1'.\");"));
s << INDENT << "if (kwds) {" << endl;
{
@@ -2634,7 +2676,9 @@ void CppGenerator::writeNamedArgumentResolution(QTextStream& s, const AbstractMe
s << INDENT << "PyObject* ";
foreach (const AbstractMetaArgument* arg, args) {
int pyArgIndex = arg->argumentIndex() - OverloadData::numberOfRemovedArguments(func, arg->argumentIndex());
- QString pyArgName = usePyArgs ? QString(PYTHON_ARGS "[%1]").arg(pyArgIndex) : PYTHON_ARG;
+ QString pyArgName = usePyArgs
+ ? QString::fromLatin1(PYTHON_ARGS "[%1]").arg(pyArgIndex)
+ : QLatin1String(PYTHON_ARG);
s << "value = PyDict_GetItemString(kwds, \"" << arg->name() << "\");" << endl;
s << INDENT << "if (value && " << pyArgName << ") {" << endl;
{
@@ -2667,13 +2711,13 @@ QString CppGenerator::argumentNameFromIndex(const AbstractMetaFunction* func, in
*wrappedClass = 0;
QString pyArgName;
if (argIndex == -1) {
- pyArgName = QString(PYTHON_SELF_VAR);
+ pyArgName = QLatin1String(PYTHON_SELF_VAR);
*wrappedClass = func->implementingClass();
} else if (argIndex == 0) {
AbstractMetaType *funcType = func->type();
AbstractMetaType *returnType = getTypeWithoutContainer(funcType);
if (returnType) {
- pyArgName = PYTHON_RETURN_VAR;
+ pyArgName = QLatin1String(PYTHON_RETURN_VAR);
*wrappedClass = classes().findClass(returnType->typeEntry()->name());
} else {
QString message = QLatin1String("Invalid Argument index (0, return value) on function modification: ")
@@ -2692,9 +2736,9 @@ QString CppGenerator::argumentNameFromIndex(const AbstractMetaFunction* func, in
if (argIndex == 1
&& !func->isConstructor()
&& OverloadData::isSingleArgument(getFunctionGroups(func->implementingClass())[func->name()]))
- pyArgName = QString(PYTHON_ARG);
+ pyArgName = QLatin1String(PYTHON_ARG);
else
- pyArgName = QString(PYTHON_ARGS "[%1]").arg(argIndex - 1);
+ pyArgName = QString::fromLatin1(PYTHON_ARGS "[%1]").arg(argIndex - 1);
}
}
return pyArgName;
@@ -2765,17 +2809,17 @@ void CppGenerator::writeMethodCall(QTextStream& s, const AbstractMetaFunction* f
// If have conversion rules I will use this for removed args
if (hasConversionRule)
- userArgs << QString("%1" CONV_RULE_OUT_VAR_SUFFIX).arg(arg->name());
+ userArgs << arg->name() + QLatin1String(CONV_RULE_OUT_VAR_SUFFIX);
else if (!arg->defaultValueExpression().isEmpty())
- userArgs << QString(CPP_ARG_REMOVED "%1").arg(i);
+ userArgs << QString::fromLatin1(CPP_ARG_REMOVED "%1").arg(i);
} else {
int idx = arg->argumentIndex() - removedArgs;
bool deRef = isValueTypeWithCopyConstructorOnly(arg->type())
|| isObjectTypeUsedAsValueType(arg->type())
|| (arg->type()->isReference() && isWrapperType(arg->type()) && !isPointer(arg->type()));
QString argName = hasConversionRule
- ? QString("%1" CONV_RULE_OUT_VAR_SUFFIX).arg(arg->name())
- : QString("%1" CPP_ARG "%2").arg(deRef ? "*" : "").arg(idx);
+ ? arg->name() + QLatin1String(CONV_RULE_OUT_VAR_SUFFIX)
+ : QString::fromLatin1("%1" CPP_ARG "%2").arg(deRef ? QLatin1String("*") : QString()).arg(idx);
userArgs << argName;
}
}
@@ -2797,9 +2841,9 @@ void CppGenerator::writeMethodCall(QTextStream& s, const AbstractMetaFunction* f
argsClear = false;
otherArgsModified |= defValModified || hasConversionRule || func->argumentRemoved(i + 1);
if (hasConversionRule)
- otherArgs.prepend(QString("%1" CONV_RULE_OUT_VAR_SUFFIX).arg(arg->name()));
+ otherArgs.prepend(arg->name() + QLatin1String(CONV_RULE_OUT_VAR_SUFFIX));
else
- otherArgs.prepend(QString(CPP_ARG_REMOVED "%1").arg(i));
+ otherArgs.prepend(QString::fromLatin1(CPP_ARG_REMOVED "%1").arg(i));
}
if (otherArgsModified)
userArgs << otherArgs;
@@ -2811,14 +2855,14 @@ void CppGenerator::writeMethodCall(QTextStream& s, const AbstractMetaFunction* f
QString useVAddr;
QTextStream uva(&useVAddr);
if (func->isOperatorOverload() && !func->isCallOperator()) {
- QString firstArg("(*" CPP_SELF_VAR ")");
+ QString firstArg = QLatin1String("(*" CPP_SELF_VAR ")");
if (func->isPointerOperator())
firstArg.remove(1, 1); // remove the de-reference operator
- QString secondArg(CPP_ARG0);
+ QString secondArg = QLatin1String(CPP_ARG0);
if (!func->isUnaryOperator() && shouldDereferenceArgumentPointer(func->arguments().first())) {
- secondArg.prepend("(*");
- secondArg.append(')');
+ secondArg.prepend(QLatin1String("(*"));
+ secondArg.append(QLatin1Char(')'));
}
if (func->isUnaryOperator())
@@ -2831,7 +2875,7 @@ void CppGenerator::writeMethodCall(QTextStream& s, const AbstractMetaFunction* f
if (func->isReverseOperator())
std::swap(firstArg, secondArg);
- if (((op == "++") || (op == "--")) && !func->isReverseOperator()) {
+ if (((op == QLatin1String("++")) || (op == QLatin1String("--"))) && !func->isReverseOperator()) {
s << endl << INDENT << "for(int i=0; i < " << secondArg << "; i++, " << firstArg << op << ");" << endl;
mc << firstArg;
} else {
@@ -2848,7 +2892,7 @@ void CppGenerator::writeMethodCall(QTextStream& s, const AbstractMetaFunction* f
if (func->isCopyConstructor() && maxArgs == 1) {
mc << "new ::" << className << "(*" << CPP_ARG0 << ')';
} else {
- QString ctorCall = className + '(' + userArgs.join(", ") + ')';
+ QString ctorCall = className + QLatin1Char('(') + userArgs.join(QLatin1String(", ")) + QLatin1Char(')');
if (usePySideExtensions() && func->ownerClass()->isQObject()) {
s << INDENT << "void* addr = PySide::nextQObjectMemoryAddr();" << endl;
uva << "if (addr) {" << endl;
@@ -2905,21 +2949,21 @@ void CppGenerator::writeMethodCall(QTextStream& s, const AbstractMetaFunction* f
mc << "((::" << wrapperName(func->ownerClass()) << "*) " << CPP_SELF_VAR << ")->";
if (!func->isAbstract())
- mc << (func->isProtected() ? wrapperName(func->ownerClass()) : "::" + func->ownerClass()->qualifiedCppName()) << "::";
+ mc << (func->isProtected() ? wrapperName(func->ownerClass()) : QLatin1String("::") + func->ownerClass()->qualifiedCppName()) << "::";
mc << func->originalName() << "_protected";
}
} else {
mc << func->originalName();
}
- mc << '(' << userArgs.join(", ") << ')';
+ mc << '(' << userArgs.join(QLatin1String(", ")) << ')';
if (!func->isAbstract() && func->isVirtual()) {
mc.flush();
if (!avoidProtectedHack() || !func->isProtected()) {
QString virtualCall(methodCall);
QString normalCall(methodCall);
- virtualCall = virtualCall.replace("%CLASS_NAME", func->ownerClass()->qualifiedCppName());
- normalCall = normalCall.replace("::%CLASS_NAME::", "");
- methodCall = "";
+ virtualCall = virtualCall.replace(QLatin1String("%CLASS_NAME"), func->ownerClass()->qualifiedCppName());
+ normalCall.remove(QLatin1String("::%CLASS_NAME::"));
+ methodCall.clear();
mc << "Shiboken::Object::hasCppWrapper(reinterpret_cast<SbkObject*>(" PYTHON_SELF_VAR ")) ? ";
mc << virtualCall << " : " << normalCall;
}
@@ -2931,7 +2975,7 @@ void CppGenerator::writeMethodCall(QTextStream& s, const AbstractMetaFunction* f
s << INDENT << BEGIN_ALLOW_THREADS << endl << INDENT;
if (isCtor) {
s << (useVAddr.isEmpty() ?
- QString("cptr = %1;").arg(methodCall) : useVAddr) << endl;
+ QString::fromLatin1("cptr = %1;").arg(methodCall) : useVAddr) << endl;
} else if (func->type() && !func->isInplaceOperator()) {
bool writeReturnType = true;
if (avoidProtectedHack()) {
@@ -2942,8 +2986,8 @@ void CppGenerator::writeMethodCall(QTextStream& s, const AbstractMetaFunction* f
enumName = protectedEnumSurrogateName(metaEnum);
else
enumName = func->type()->cppSignature();
- methodCall.prepend(enumName + '(');
- methodCall.append(')');
+ methodCall.prepend(enumName + QLatin1Char('('));
+ methodCall.append(QLatin1Char(')'));
s << enumName;
writeReturnType = false;
}
@@ -2952,8 +2996,8 @@ void CppGenerator::writeMethodCall(QTextStream& s, const AbstractMetaFunction* f
s << func->type()->cppSignature();
if (isObjectTypeUsedAsValueType(func->type())) {
s << '*';
- methodCall.prepend(QString("new %1(").arg(func->type()->typeEntry()->qualifiedCppName()));
- methodCall.append(')');
+ methodCall.prepend(QString::fromLatin1("new %1(").arg(func->type()->typeEntry()->qualifiedCppName()));
+ methodCall.append(QLatin1Char(')'));
}
}
s << " " CPP_RETURN_VAR " = ";
@@ -2964,7 +3008,7 @@ void CppGenerator::writeMethodCall(QTextStream& s, const AbstractMetaFunction* f
s << INDENT << END_ALLOW_THREADS << endl;
if (!func->conversionRule(TypeSystem::TargetLangCode, 0).isEmpty()) {
- writeConversionRule(s, func, TypeSystem::TargetLangCode, PYTHON_RETURN_VAR);
+ writeConversionRule(s, func, TypeSystem::TargetLangCode, QLatin1String(PYTHON_RETURN_VAR));
} else if (!isCtor && !func->isInplaceOperator() && func->type()
&& !injectedCodeHasReturnValueAttribution(func, TypeSystem::TargetLangCode)) {
s << INDENT << PYTHON_RETURN_VAR " = ";
@@ -2972,7 +3016,7 @@ void CppGenerator::writeMethodCall(QTextStream& s, const AbstractMetaFunction* f
s << "Shiboken::Object::newObject((SbkObjectType*)" << cpythonTypeNameExt(func->type()->typeEntry());
s << ", " << CPP_RETURN_VAR << ", true, true)";
} else {
- writeToPythonConversion(s, func->type(), func->ownerClass(), CPP_RETURN_VAR);
+ writeToPythonConversion(s, func->type(), func->ownerClass(), QLatin1String(CPP_RETURN_VAR));
}
s << ';' << endl;
}
@@ -3048,7 +3092,7 @@ void CppGenerator::writeMethodCall(QTextStream& s, const AbstractMetaFunction* f
QString pyArgName;
if (refCount.action == ReferenceCount::Remove) {
- pyArgName = "Py_None";
+ pyArgName = QLatin1String("Py_None");
} else {
pyArgName = argumentNameFromIndex(func, arg_mod.index, &wrappedClass);
if (pyArgName.isEmpty()) {
@@ -3084,8 +3128,10 @@ QStringList CppGenerator::getAncestorMultipleInheritance(const AbstractMetaClass
AbstractMetaClassList baseClases = getBaseClasses(metaClass);
if (!baseClases.isEmpty()) {
foreach (const AbstractMetaClass* baseClass, baseClases) {
- result.append(QString("((size_t) static_cast<const %1*>(class_ptr)) - base").arg(baseClass->qualifiedCppName()));
- result.append(QString("((size_t) static_cast<const %1*>((%2*)((void*)class_ptr))) - base").arg(baseClass->qualifiedCppName()).arg(metaClass->qualifiedCppName()));
+ result.append(QString::fromLatin1("((size_t) static_cast<const %1*>(class_ptr)) - base")
+ .arg(baseClass->qualifiedCppName()));
+ result.append(QString::fromLatin1("((size_t) static_cast<const %1*>((%2*)((void*)class_ptr))) - base")
+ .arg(baseClass->qualifiedCppName(), metaClass->qualifiedCppName()));
}
foreach (const AbstractMetaClass* baseClass, baseClases)
result.append(getAncestorMultipleInheritance(baseClass));
@@ -3158,7 +3204,7 @@ void CppGenerator::writePrimitiveConverterInitialization(QTextStream& s, const C
s << INDENT << converter << " = Shiboken::Conversions::createConverter(";
if (type->targetLangApiName() == type->name())
s << '0';
- else if (type->targetLangApiName() == "PyObject")
+ else if (type->targetLangApiName() == QLatin1String("PyObject"))
s << "&PyBaseObject_Type";
else
s << '&' << type->targetLangApiName() << "_Type";
@@ -3179,7 +3225,7 @@ void CppGenerator::writeEnumConverterInitialization(QTextStream& s, const TypeEn
{
if (!enumType)
return;
- QString enumFlagName = enumType->isFlags() ? "flag" : "enum";
+ QString enumFlagName = enumType->isFlags() ? QLatin1String("flag") : QLatin1String("enum");
QString enumPythonType = cpythonTypeNameExt(enumType);
const FlagsTypeEntry* flags = 0;
@@ -3201,24 +3247,24 @@ void CppGenerator::writeEnumConverterInitialization(QTextStream& s, const TypeEn
QString enumTypeName = fixedCppTypeName(flags->originator());
QString toCpp = pythonToCppFunctionName(enumTypeName, typeName);
QString isConv = convertibleToCppFunctionName(enumTypeName, typeName);
- writeAddPythonToCppConversion(s, "converter", toCpp, isConv);
+ writeAddPythonToCppConversion(s, QLatin1String("converter"), toCpp, isConv);
}
QString toCpp = pythonToCppFunctionName(typeName, typeName);
QString isConv = convertibleToCppFunctionName(typeName, typeName);
- writeAddPythonToCppConversion(s, "converter", toCpp, isConv);
+ writeAddPythonToCppConversion(s, QLatin1String("converter"), toCpp, isConv);
if (flags) {
- QString toCpp = pythonToCppFunctionName("number", typeName);
- QString isConv = convertibleToCppFunctionName("number", typeName);
- writeAddPythonToCppConversion(s, "converter", toCpp, isConv);
+ QString toCpp = pythonToCppFunctionName(QLatin1String("number"), typeName);
+ QString isConv = convertibleToCppFunctionName(QLatin1String("number"), typeName);
+ writeAddPythonToCppConversion(s, QLatin1String("converter"), toCpp, isConv);
}
s << INDENT << "Shiboken::Enum::setTypeConverter(" << enumPythonType << ", converter);" << endl;
s << INDENT << "Shiboken::Enum::setTypeConverter(" << enumPythonType << ", converter);" << endl;
- QStringList cppSignature = enumType->qualifiedCppName().split("::", QString::SkipEmptyParts);
+ QStringList cppSignature = enumType->qualifiedCppName().split(QLatin1String("::"), QString::SkipEmptyParts);
while (!cppSignature.isEmpty()) {
- QString signature = cppSignature.join("::");
+ QString signature = cppSignature.join(QLatin1String("::"));
s << INDENT << "Shiboken::Conversions::registerConverterName(converter, \"";
if (flags)
s << "QFlags<";
@@ -3238,12 +3284,12 @@ void CppGenerator::writeContainerConverterInitialization(QTextStream& s, const A
s << INDENT << "// Register converter for type '" << cppSignature << "'." << endl;
QString converter = converterObject(type);
s << INDENT << converter << " = Shiboken::Conversions::createConverter(";
- if (type->typeEntry()->targetLangApiName() == "PyObject") {
+ if (type->typeEntry()->targetLangApiName() == QLatin1String("PyObject")) {
s << "&PyBaseObject_Type";
} else {
QString baseName = cpythonBaseName(type->typeEntry());
- if (baseName == "PySequence")
- baseName = "PyList";
+ if (baseName == QLatin1String("PySequence"))
+ baseName = QLatin1String("PyList");
s << '&' << baseName << "_Type";
}
QString typeName = fixedCppTypeName(type);
@@ -3263,9 +3309,9 @@ void CppGenerator::writeExtendedConverterInitialization(QTextStream& s, const Ty
{
s << INDENT << "// Extended implicit conversions for " << externalType->qualifiedTargetLangName() << '.' << endl;
foreach (const AbstractMetaClass* sourceClass, conversions) {
- QString converterVar = QString("(SbkObjectType*)%1[%2]")
- .arg(cppApiVariableName(externalType->targetLangPackage()))
- .arg(getTypeIndexVariableName(externalType));
+ QString converterVar = QString::fromLatin1("(SbkObjectType*)%1[%2]")
+ .arg(cppApiVariableName(externalType->targetLangPackage()),
+ getTypeIndexVariableName(externalType));
QString sourceTypeName = fixedCppTypeName(sourceClass->typeEntry());
QString targetTypeName = fixedCppTypeName(externalType);
QString toCpp = pythonToCppFunctionName(sourceTypeName, targetTypeName);
@@ -3278,7 +3324,7 @@ QString CppGenerator::multipleInheritanceInitializerFunctionName(const AbstractM
{
if (!hasMultipleInheritanceInAncestry(metaClass))
return QString();
- return QString("%1_mi_init").arg(cpythonBaseName(metaClass->typeEntry()));
+ return cpythonBaseName(metaClass->typeEntry()) + QLatin1String("_mi_init");
}
bool CppGenerator::supportsMappingProtocol(const AbstractMetaClass* metaClass)
@@ -3328,11 +3374,12 @@ void CppGenerator::writeClassDefinition(QTextStream& s, const AbstractMetaClass*
QString tp_init;
QString tp_new;
QString tp_dealloc;
- QString tp_hash('0');
- QString tp_call('0');
+ QString tp_hash(QLatin1Char('0'));
+ QString tp_call = tp_hash;
QString cppClassName = metaClass->qualifiedCppName();
- QString className = cpythonTypeName(metaClass).replace(QRegExp("_Type$"), "");
- QString baseClassName('0');
+ QString className = cpythonTypeName(metaClass);
+ className.remove(QRegExp(QLatin1String("_Type$")));
+ QString baseClassName(QLatin1Char('0'));
AbstractMetaFunctionList ctors;
foreach (AbstractMetaFunction* f, metaClass->queryFunctions(AbstractMetaClass::Constructors)) {
if (!f->isPrivate() && !f->isModifiedRemoved())
@@ -3340,33 +3387,33 @@ void CppGenerator::writeClassDefinition(QTextStream& s, const AbstractMetaClass*
}
if (!metaClass->baseClass())
- baseClassName = "reinterpret_cast<PyTypeObject*>(&SbkObject_Type)";
+ baseClassName = QLatin1String("reinterpret_cast<PyTypeObject*>(&SbkObject_Type)");
bool onlyPrivCtor = !metaClass->hasNonPrivateConstructor();
if (metaClass->isNamespace() || metaClass->hasPrivateDestructor()) {
- tp_flags = "Py_TPFLAGS_DEFAULT|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_GC";
+ tp_flags = QLatin1String("Py_TPFLAGS_DEFAULT|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_GC");
tp_dealloc = metaClass->hasPrivateDestructor() ?
- "SbkDeallocWrapperWithPrivateDtor" : "0";
- tp_init = "0";
+ QLatin1String("SbkDeallocWrapperWithPrivateDtor") : QLatin1String("0");
+ tp_init = QLatin1String("0");
} else {
if (onlyPrivCtor)
- tp_flags = "Py_TPFLAGS_DEFAULT|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_GC";
+ tp_flags = QLatin1String("Py_TPFLAGS_DEFAULT|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_GC");
else
- tp_flags = "Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_GC";
+ tp_flags = QLatin1String("Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_GC");
QString deallocClassName;
if (shouldGenerateCppWrapper(metaClass))
deallocClassName = wrapperName(metaClass);
else
deallocClassName = cppClassName;
- tp_dealloc = "&SbkDeallocWrapper";
- tp_init = onlyPrivCtor || ctors.isEmpty() ? "0" : cpythonFunctionName(ctors.first());
+ tp_dealloc = QLatin1String("&SbkDeallocWrapper");
+ tp_init = (onlyPrivCtor || ctors.isEmpty()) ? QLatin1String("0") : cpythonFunctionName(ctors.constFirst());
}
- QString tp_getattro('0');
- QString tp_setattro('0');
- if (usePySideExtensions() && (metaClass->qualifiedCppName() == "QObject")) {
+ QString tp_getattro(QLatin1Char('0'));
+ QString tp_setattro = tp_getattro;
+ if (usePySideExtensions() && (metaClass->qualifiedCppName() == QLatin1String("QObject"))) {
tp_getattro = cpythonGetattroFunctionName(metaClass);
tp_setattro = cpythonSetattroFunctionName(metaClass);
} else if (classNeedsGetattroFunction(metaClass)) {
@@ -3374,15 +3421,15 @@ void CppGenerator::writeClassDefinition(QTextStream& s, const AbstractMetaClass*
}
if (metaClass->hasPrivateDestructor() || onlyPrivCtor)
- tp_new = "0";
+ tp_new = QLatin1String("0");
else
- tp_new = "SbkObjectTpNew";
+ tp_new = QLatin1String("SbkObjectTpNew");
- QString tp_richcompare = QString('0');
+ QString tp_richcompare = QString(QLatin1Char('0'));
if (metaClass->hasComparisonOperatorOverload())
- tp_richcompare = cpythonBaseName(metaClass) + "_richcompare";
+ tp_richcompare = cpythonBaseName(metaClass) + QLatin1String("_richcompare");
- QString tp_getset = QString('0');
+ QString tp_getset = QString(QLatin1Char('0'));
if (shouldGenerateGetSetList(metaClass))
tp_getset = cpythonGettersSettersDefinitionName(metaClass);
@@ -3392,10 +3439,10 @@ void CppGenerator::writeClassDefinition(QTextStream& s, const AbstractMetaClass*
if (m_tpFuncs.contains(func->name()))
m_tpFuncs[func->name()] = cpythonFunctionName(func);
}
- if (m_tpFuncs["__repr__"] == "0"
+ if (m_tpFuncs[QLatin1String("__repr__")] == QLatin1String("0")
&& !metaClass->isQObject()
&& metaClass->hasToStringCapability()) {
- m_tpFuncs["__repr__"] = writeReprFunction(s, metaClass);
+ m_tpFuncs[QLatin1String("__repr__")] = writeReprFunction(s, metaClass);
}
// class or some ancestor has multiple inheritance
@@ -3408,31 +3455,31 @@ void CppGenerator::writeClassDefinition(QTextStream& s, const AbstractMetaClass*
}
if (!metaClass->typeEntry()->hashFunction().isEmpty())
- tp_hash = '&' + cpythonBaseName(metaClass) + "_HashFunc";
+ tp_hash = QLatin1Char('&') + cpythonBaseName(metaClass) + QLatin1String("_HashFunc");
- const AbstractMetaFunction* callOp = metaClass->findFunction("operator()");
+ const AbstractMetaFunction* callOp = metaClass->findFunction(QLatin1String("operator()"));
if (callOp && !callOp->isModifiedRemoved())
- tp_call = '&' + cpythonFunctionName(callOp);
+ tp_call = QLatin1Char('&') + cpythonFunctionName(callOp);
s << "// Class Definition -----------------------------------------------" << endl;
s << "extern \"C\" {" << endl;
if (supportsNumberProtocol(metaClass)) {
- s << "static PyNumberMethods " << className + "_TypeAsNumber" << ";" << endl;
+ s << "static PyNumberMethods " << className + QLatin1String("_TypeAsNumber") << ";" << endl;
s << endl;
}
if (supportsSequenceProtocol(metaClass)) {
- s << "static PySequenceMethods " << className + "_TypeAsSequence" << ";" << endl;
+ s << "static PySequenceMethods " << className + QLatin1String("_TypeAsSequence") << ";" << endl;
s << endl;
}
if (supportsMappingProtocol(metaClass)) {
- s << "static PyMappingMethods " << className + "_TypeAsMapping" << ";" << endl;
+ s << "static PyMappingMethods " << className + QLatin1String("_TypeAsMapping") << ";" << endl;
s << endl;
}
- s << "static SbkObjectType " << className + "_Type" << " = { { {" << endl;
+ s << "static SbkObjectType " << className + QLatin1String("_Type") << " = { { {" << endl;
s << INDENT << "PyVarObject_HEAD_INIT(&SbkObjectType_Type, 0)" << endl;
s << INDENT << "/*tp_name*/ \"" << getClassTargetFullName(metaClass) << "\"," << endl;
s << INDENT << "/*tp_basicsize*/ sizeof(SbkObject)," << endl;
@@ -3442,13 +3489,13 @@ void CppGenerator::writeClassDefinition(QTextStream& s, const AbstractMetaClass*
s << INDENT << "/*tp_getattr*/ 0," << endl;
s << INDENT << "/*tp_setattr*/ 0," << endl;
s << INDENT << "/*tp_compare*/ 0," << endl;
- s << INDENT << "/*tp_repr*/ " << m_tpFuncs["__repr__"] << "," << endl;
+ s << INDENT << "/*tp_repr*/ " << m_tpFuncs[QLatin1String("__repr__")] << "," << endl;
s << INDENT << "/*tp_as_number*/ 0," << endl;
s << INDENT << "/*tp_as_sequence*/ 0," << endl;
s << INDENT << "/*tp_as_mapping*/ 0," << endl;
s << INDENT << "/*tp_hash*/ " << tp_hash << ',' << endl;
s << INDENT << "/*tp_call*/ " << tp_call << ',' << endl;
- s << INDENT << "/*tp_str*/ " << m_tpFuncs["__str__"] << ',' << endl;
+ s << INDENT << "/*tp_str*/ " << m_tpFuncs[QLatin1String("__str__")] << ',' << endl;
s << INDENT << "/*tp_getattro*/ " << tp_getattro << ',' << endl;
s << INDENT << "/*tp_setattro*/ " << tp_setattro << ',' << endl;
s << INDENT << "/*tp_as_buffer*/ 0," << endl;
@@ -3458,8 +3505,8 @@ void CppGenerator::writeClassDefinition(QTextStream& s, const AbstractMetaClass*
s << INDENT << "/*tp_clear*/ " << className << "_clear," << endl;
s << INDENT << "/*tp_richcompare*/ " << tp_richcompare << ',' << endl;
s << INDENT << "/*tp_weaklistoffset*/ 0," << endl;
- s << INDENT << "/*tp_iter*/ " << m_tpFuncs["__iter__"] << ',' << endl;
- s << INDENT << "/*tp_iternext*/ " << m_tpFuncs["__next__"] << ',' << endl;
+ s << INDENT << "/*tp_iter*/ " << m_tpFuncs[QLatin1String("__iter__")] << ',' << endl;
+ s << INDENT << "/*tp_iternext*/ " << m_tpFuncs[QLatin1String("__next__")] << ',' << endl;
s << INDENT << "/*tp_methods*/ " << className << "_methods," << endl;
s << INDENT << "/*tp_members*/ 0," << endl;
s << INDENT << "/*tp_getset*/ " << tp_getset << ',' << endl;
@@ -3483,7 +3530,7 @@ void CppGenerator::writeClassDefinition(QTextStream& s, const AbstractMetaClass*
s << "};" << endl;
QString suffix;
if (isObjectType(metaClass))
- suffix = "*";
+ suffix = QLatin1String("*");
s << "} //extern" << endl;
}
@@ -3503,7 +3550,7 @@ void CppGenerator::writeMappingMethods(QTextStream& s, const AbstractMetaClass*
CodeSnipList snips = func->injectedCodeSnips(CodeSnip::Any, TypeSystem::TargetLangCode);
s << funcRetVal << ' ' << funcName << '(' << funcArgs << ')' << endl << '{' << endl;
- writeInvalidPyObjectCheck(s, PYTHON_SELF_VAR);
+ writeInvalidPyObjectCheck(s, QLatin1String(PYTHON_SELF_VAR));
writeCppSelfDefinition(s, func);
@@ -3531,7 +3578,7 @@ void CppGenerator::writeSequenceMethods(QTextStream& s, const AbstractMetaClass*
CodeSnipList snips = func->injectedCodeSnips(CodeSnip::Any, TypeSystem::TargetLangCode);
s << funcRetVal << ' ' << funcName << '(' << funcArgs << ')' << endl << '{' << endl;
- writeInvalidPyObjectCheck(s, PYTHON_SELF_VAR);
+ writeInvalidPyObjectCheck(s, QLatin1String(PYTHON_SELF_VAR));
writeCppSelfDefinition(s, func);
@@ -3550,7 +3597,7 @@ void CppGenerator::writeTypeAsSequenceDefinition(QTextStream& s, const AbstractM
QMap<QString, QString> funcs;
foreach(QString funcName, m_sequenceProtocol.keys()) {
const AbstractMetaFunction* func = metaClass->findFunction(funcName);
- funcs[funcName] = func ? cpythonFunctionName(func).prepend("&") : QString();
+ funcs[funcName] = func ? cpythonFunctionName(func).prepend(QLatin1Char('&')) : QString();
if (!hasFunctions && func)
hasFunctions = true;
}
@@ -3559,19 +3606,19 @@ void CppGenerator::writeTypeAsSequenceDefinition(QTextStream& s, const AbstractM
//use default implementation
if (!hasFunctions) {
- funcs["__len__"] = baseName + "__len__";
- funcs["__getitem__"] = baseName + "__getitem__";
- funcs["__setitem__"] = baseName + "__setitem__";
+ funcs[QLatin1String("__len__")] = baseName + QLatin1String("__len__");
+ funcs[QLatin1String("__getitem__")] = baseName + QLatin1String("__getitem__");
+ funcs[QLatin1String("__setitem__")] = baseName + QLatin1String("__setitem__");
}
s << INDENT << "memset(&" << baseName << "_TypeAsSequence, 0, sizeof(PySequenceMethods));" << endl;
foreach (const QString& sqName, m_sqFuncs.keys()) {
if (funcs[sqName].isEmpty())
continue;
- if (m_sqFuncs[sqName] == "sq_slice")
+ if (m_sqFuncs[sqName] == QLatin1String("sq_slice"))
s << "#ifndef IS_PY3K" << endl;
s << INDENT << baseName << "_TypeAsSequence." << m_sqFuncs[sqName] << " = " << funcs[sqName] << ';' << endl;
- if (m_sqFuncs[sqName] == "sq_slice")
+ if (m_sqFuncs[sqName] == QLatin1String("sq_slice"))
s << "#endif" << endl;
}
}
@@ -3582,16 +3629,16 @@ void CppGenerator::writeTypeAsMappingDefinition(QTextStream& s, const AbstractMe
QMap<QString, QString> funcs;
foreach(QString funcName, m_mappingProtocol.keys()) {
const AbstractMetaFunction* func = metaClass->findFunction(funcName);
- funcs[funcName] = func ? cpythonFunctionName(func).prepend("&") : "0";
+ funcs[funcName] = func ? cpythonFunctionName(func).prepend(QLatin1Char('&')) : QLatin1String("0");
if (!hasFunctions && func)
hasFunctions = true;
}
//use default implementation
if (!hasFunctions) {
- funcs["__mlen__"] = QString();
- funcs["__mgetitem__"] = QString();
- funcs["__msetitem__"] = QString();
+ funcs.insert(QLatin1String("__mlen__"), QString());
+ funcs.insert(QLatin1String("__mgetitem__"), QString());
+ funcs.insert(QLatin1String("__msetitem__"), QString());
}
QString baseName = cpythonBaseName(metaClass);
@@ -3607,29 +3654,29 @@ void CppGenerator::writeTypeAsNumberDefinition(QTextStream& s, const AbstractMet
{
QMap<QString, QString> nb;
- nb["__add__"] = QString();
- nb["__sub__"] = QString();
- nb["__mul__"] = QString();
- nb["__div__"] = QString();
- nb["__mod__"] = QString();
- nb["__neg__"] = QString();
- nb["__pos__"] = QString();
- nb["__invert__"] = QString();
- nb["__lshift__"] = QString();
- nb["__rshift__"] = QString();
- nb["__and__"] = QString();
- nb["__xor__"] = QString();
- nb["__or__"] = QString();
- nb["__iadd__"] = QString();
- nb["__isub__"] = QString();
- nb["__imul__"] = QString();
- nb["__idiv__"] = QString();
- nb["__imod__"] = QString();
- nb["__ilshift__"] = QString();
- nb["__irshift__"] = QString();
- nb["__iand__"] = QString();
- nb["__ixor__"] = QString();
- nb["__ior__"] = QString();
+ nb.insert(QLatin1String("__add__"), QString());
+ nb.insert(QLatin1String("__sub__"), QString());
+ nb.insert(QLatin1String("__mul__"), QString());
+ nb.insert(QLatin1String("__div__"), QString());
+ nb.insert(QLatin1String("__mod__"), QString());
+ nb.insert(QLatin1String("__neg__"), QString());
+ nb.insert(QLatin1String("__pos__"), QString());
+ nb.insert(QLatin1String("__invert__"), QString());
+ nb.insert(QLatin1String("__lshift__"), QString());
+ nb.insert(QLatin1String("__rshift__"), QString());
+ nb.insert(QLatin1String("__and__"), QString());
+ nb.insert(QLatin1String("__xor__"), QString());
+ nb.insert(QLatin1String("__or__"), QString());
+ nb.insert(QLatin1String("__iadd__"), QString());
+ nb.insert(QLatin1String("__isub__"), QString());
+ nb.insert(QLatin1String("__imul__"), QString());
+ nb.insert(QLatin1String("__idiv__"), QString());
+ nb.insert(QLatin1String("__imod__"), QString());
+ nb.insert(QLatin1String("__ilshift__"), QString());
+ nb.insert(QLatin1String("__irshift__"), QString());
+ nb.insert(QLatin1String("__iand__"), QString());
+ nb.insert(QLatin1String("__ixor__"), QString());
+ nb.insert(QLatin1String("__ior__"), QString());
QList<AbstractMetaFunctionList> opOverloads =
filterGroupedOperatorFunctions(metaClass,
@@ -3645,7 +3692,7 @@ void CppGenerator::writeTypeAsNumberDefinition(QTextStream& s, const AbstractMet
QString baseName = cpythonBaseName(metaClass);
- nb["bool"] = hasBoolCast(metaClass) ? baseName + "___nb_bool" : QString();
+ nb[QLatin1String("bool")] = hasBoolCast(metaClass) ? baseName + QLatin1String("___nb_bool") : QString();
s << INDENT << "memset(&" << baseName << "_TypeAsNumber, 0, sizeof(PyNumberMethods));" << endl;
foreach (const QString& nbName, m_nbFuncs.keys()) {
@@ -3654,10 +3701,10 @@ void CppGenerator::writeTypeAsNumberDefinition(QTextStream& s, const AbstractMet
// bool is special because the field name differs on Python 2 and 3 (nb_nonzero vs nb_bool)
// so a shiboken macro is used.
- if (nbName == "bool") {
+ if (nbName == QLatin1String("bool")) {
s << INDENT << "SBK_NB_BOOL(" << baseName << "_TypeAsNumber) = " << nb[nbName] << ';' << endl;
} else {
- bool excludeFromPy3K = nbName == "__div__" || nbName == "__idiv__";
+ bool excludeFromPy3K = nbName == QLatin1String("__div__") || nbName == QLatin1String("__idiv__");
if (excludeFromPy3K) {
s << "#ifdef IS_PY3K" << endl;
s << INDENT << "SBK_UNUSED(" << nb[nbName] << ");" << endl;
@@ -3668,8 +3715,8 @@ void CppGenerator::writeTypeAsNumberDefinition(QTextStream& s, const AbstractMet
s << "#endif" << endl;
}
}
- if (!nb["__div__"].isEmpty())
- s << INDENT << baseName << "_TypeAsNumber.nb_true_divide = " << nb["__div__"] << ';' << endl;
+ if (!nb[QLatin1String("__div__")].isEmpty())
+ s << INDENT << baseName << "_TypeAsNumber.nb_true_divide = " << nb[QLatin1String("__div__")] << ';' << endl;
}
void CppGenerator::writeTpTraverseFunction(QTextStream& s, const AbstractMetaClass* metaClass)
@@ -3694,7 +3741,8 @@ void CppGenerator::writeTpClearFunction(QTextStream& s, const AbstractMetaClass*
void CppGenerator::writeCopyFunction(QTextStream& s, const AbstractMetaClass* metaClass)
{
- QString className = cpythonTypeName(metaClass).replace(QRegExp("_Type$"), "");
+ QString className = cpythonTypeName(metaClass);
+ className.remove(QRegExp(QLatin1String("_Type$")));
s << "static PyObject* " << className << "___copy__(PyObject* " PYTHON_SELF_VAR ")" << endl;
s << "{" << endl;
writeCppSelfDefinition(s, metaClass, false, true);
@@ -3720,29 +3768,29 @@ void CppGenerator::writeGetterFunction(QTextStream& s, const AbstractMetaField*
QString cppField;
if (avoidProtectedHack() && metaField->isProtected()) {
- cppField = QString("((%1*)%2)->%3()").arg(wrapperName(metaField->enclosingClass()))
- .arg(CPP_SELF_VAR)
- .arg(protectedFieldGetterName(metaField));
+ cppField = QString::fromLatin1("((%1*)%2)->%3()")
+ .arg(wrapperName(metaField->enclosingClass()), QLatin1String(CPP_SELF_VAR),
+ protectedFieldGetterName(metaField));
} else {
- cppField = QString("%2->%3").arg(CPP_SELF_VAR).arg(metaField->name());
+ cppField = QLatin1String(CPP_SELF_VAR) + QLatin1String("->") + metaField->name();
if (newWrapperSameObject) {
- cppField.prepend("&(");
- cppField.append(')');
+ cppField.prepend(QLatin1String("&("));
+ cppField.append(QLatin1Char(')'));
}
}
if (isCppIntegralPrimitive(fieldType) || fieldType->isEnum()) {
s << INDENT << getFullTypeNameWithoutModifiers(fieldType) << " cppOut_local = " << cppField << ';' << endl;
- cppField = "cppOut_local";
+ cppField = QLatin1String("cppOut_local");
} else if (avoidProtectedHack() && metaField->isProtected()) {
s << INDENT << getFullTypeNameWithoutModifiers(fieldType);
if (fieldType->isContainer() || fieldType->isFlags()) {
s << '&';
- cppField.prepend('*');
+ cppField.prepend(QLatin1Char('*'));
} else if ((!fieldType->isConstant() && !fieldType->isEnum() && !fieldType->isPrimitive()) || fieldType->indirections() == 1) {
s << '*';
}
s << " fieldValue = " << cppField << ';' << endl;
- cppField = "fieldValue";
+ cppField = QLatin1String("fieldValue");
}
s << INDENT << "PyObject* pyOut = ";
@@ -3780,7 +3828,7 @@ void CppGenerator::writeSetterFunction(QTextStream& s, const AbstractMetaField*
s << INDENT << "PythonToCppFunc " << PYTHON_TO_CPP_VAR << ';' << endl;
s << INDENT << "if (!";
- writeTypeCheck(s, fieldType, "pyIn", isNumber(fieldType->typeEntry()));
+ writeTypeCheck(s, fieldType, QLatin1String("pyIn"), isNumber(fieldType->typeEntry()));
s << ") {" << endl;
{
Indentation indent(INDENT);
@@ -3790,22 +3838,22 @@ void CppGenerator::writeSetterFunction(QTextStream& s, const AbstractMetaField*
}
s << INDENT << '}' << endl << endl;
- QString cppField = QString("%1->%2").arg(CPP_SELF_VAR).arg(metaField->name());
+ QString cppField = QString::fromLatin1("%1->%2").arg(QLatin1String(CPP_SELF_VAR), metaField->name());
s << INDENT;
if (avoidProtectedHack() && metaField->isProtected()) {
s << getFullTypeNameWithoutModifiers(fieldType);
s << (fieldType->indirections() == 1 ? "*" : "") << " cppOut;" << endl;
s << INDENT << PYTHON_TO_CPP_VAR << "(pyIn, &cppOut);" << endl;
- s << INDENT << QString("((%1*)%2)->%3(cppOut)").arg(wrapperName(metaField->enclosingClass()))
- .arg(CPP_SELF_VAR)
- .arg(protectedFieldSetterName(metaField));
+ s << INDENT << QString::fromLatin1("((%1*)%2)->%3(cppOut)")
+ .arg(wrapperName(metaField->enclosingClass()),
+ QLatin1String(CPP_SELF_VAR), protectedFieldSetterName(metaField));
} else if (isCppIntegralPrimitive(fieldType) || fieldType->typeEntry()->isEnum() || fieldType->typeEntry()->isFlags()) {
s << getFullTypeNameWithoutModifiers(fieldType) << " cppOut_local = " << cppField << ';' << endl;
s << INDENT << PYTHON_TO_CPP_VAR << "(pyIn, &cppOut_local);" << endl;
s << INDENT << cppField << " = cppOut_local";
} else {
s << getFullTypeNameWithoutModifiers(fieldType);
- s << QString("*").repeated(fieldType->indirections()) << "& cppOut_ptr = ";
+ s << QString::fromLatin1("*").repeated(fieldType->indirections()) << "& cppOut_ptr = ";
s << cppField << ';' << endl;
s << INDENT << PYTHON_TO_CPP_VAR << "(pyIn, &cppOut_ptr)";
}
@@ -3827,10 +3875,10 @@ void CppGenerator::writeRichCompareFunction(QTextStream& s, const AbstractMetaCl
s << baseName << "_richcompare(PyObject* " PYTHON_SELF_VAR ", PyObject* " PYTHON_ARG ", int op)" << endl;
s << '{' << endl;
writeCppSelfDefinition(s, metaClass, false, true);
- writeUnusedVariableCast(s, CPP_SELF_VAR);
+ writeUnusedVariableCast(s, QLatin1String(CPP_SELF_VAR));
s << INDENT << "PyObject* " PYTHON_RETURN_VAR " = 0;" << endl;
s << INDENT << "PythonToCppFunc " PYTHON_TO_CPP_VAR << ';' << endl;
- writeUnusedVariableCast(s, PYTHON_TO_CPP_VAR);
+ writeUnusedVariableCast(s, QLatin1String(PYTHON_TO_CPP_VAR));
s << endl;
s << INDENT << "switch (op) {" << endl;
@@ -3845,7 +3893,7 @@ void CppGenerator::writeRichCompareFunction(QTextStream& s, const AbstractMetaCl
Indentation indent(INDENT);
QString op = rfunc->originalName();
- op = op.right(op.size() - QString("operator").size());
+ op = op.right(op.size() - QLatin1String("operator").size());
int alternativeNumericTypes = 0;
foreach (const AbstractMetaFunction* func, overloads) {
@@ -3870,29 +3918,31 @@ void CppGenerator::writeRichCompareFunction(QTextStream& s, const AbstractMetaCl
s << INDENT;
}
s << "if (";
- writeTypeCheck(s, argType, PYTHON_ARG, alternativeNumericTypes == 1 || isPyInt(argType));
+ writeTypeCheck(s, argType, QLatin1String(PYTHON_ARG), alternativeNumericTypes == 1 || isPyInt(argType));
s << ") {" << endl;
{
Indentation indent(INDENT);
s << INDENT << "// " << func->signature() << endl;
- writeArgumentConversion(s, argType, CPP_ARG0, PYTHON_ARG, metaClass, QString(), func->isUserAdded());
+ writeArgumentConversion(s, argType, QLatin1String(CPP_ARG0),
+ QLatin1String(PYTHON_ARG), metaClass,
+ QString(), func->isUserAdded());
// If the function is user added, use the inject code
if (func->isUserAdded()) {
CodeSnipList snips = func->injectedCodeSnips();
writeCodeSnips(s, snips, CodeSnip::Any, TypeSystem::TargetLangCode, func, func->arguments().last());
} else {
- QString expression = QString("%1%2 %3 (%4" CPP_ARG0 ")")
- .arg(func->isPointerOperator() ? "&" : "")
- .arg(CPP_SELF_VAR).arg(op)
- .arg(shouldDereferenceAbstractMetaTypePointer(argType) ? "*" : "");
+ QString expression = QString::fromLatin1("%1%2 %3 (%4" CPP_ARG0 ")")
+ .arg(func->isPointerOperator() ? QLatin1String("&") : QString(),
+ QLatin1String(CPP_SELF_VAR), op,
+ shouldDereferenceAbstractMetaTypePointer(argType) ? QLatin1String("*") : QString());
s << INDENT;
if (func->type())
s << func->type()->cppSignature() << " " CPP_RETURN_VAR " = ";
s << expression << ';' << endl;
s << INDENT << PYTHON_RETURN_VAR " = ";
if (func->type())
- writeToPythonConversion(s, func->type(), metaClass, CPP_RETURN_VAR);
+ writeToPythonConversion(s, func->type(), metaClass, QLatin1String(CPP_RETURN_VAR));
else
s << "Py_None;" << endl << INDENT << "Py_INCREF(Py_None)";
s << ';' << endl;
@@ -3902,9 +3952,10 @@ void CppGenerator::writeRichCompareFunction(QTextStream& s, const AbstractMetaCl
}
s << " else {" << endl;
- if (operatorId == "Py_EQ" || operatorId == "Py_NE") {
+ if (operatorId == QLatin1String("Py_EQ") || operatorId == QLatin1String("Py_NE")) {
Indentation indent(INDENT);
- s << INDENT << PYTHON_RETURN_VAR " = " << (operatorId == "Py_EQ" ? "Py_False" : "Py_True") << ';' << endl;
+ s << INDENT << PYTHON_RETURN_VAR " = "
+ << (operatorId == QLatin1String("Py_EQ") ? "Py_False" : "Py_True") << ';' << endl;
s << INDENT << "Py_INCREF(" PYTHON_RETURN_VAR ");" << endl;
} else {
Indentation indent(INDENT);
@@ -3994,11 +4045,11 @@ void CppGenerator::writeEnumInitialization(QTextStream& s, const AbstractMetaEnu
bool hasUpperEnclosingClass = upper && upper->typeEntry()->codeGeneration() != TypeEntry::GenerateForSubclass;
QString enclosingObjectVariable;
if (enclosingClass)
- enclosingObjectVariable = '&' + cpythonTypeName(enclosingClass);
+ enclosingObjectVariable = QLatin1Char('&') + cpythonTypeName(enclosingClass);
else if (hasUpperEnclosingClass)
- enclosingObjectVariable = "enclosingClass";
+ enclosingObjectVariable = QLatin1String("enclosingClass");
else
- enclosingObjectVariable = "module";
+ enclosingObjectVariable = QLatin1String("module");
s << INDENT << "// Initialization of ";
s << (cppEnum->isAnonymous() ? "anonymous enum identified by enum value" : "enum");
@@ -4018,7 +4069,7 @@ void CppGenerator::writeEnumInitialization(QTextStream& s, const AbstractMetaEnu
Indentation indent(INDENT);
s << INDENT << '"' << cppEnum->name() << "\"," << endl;
s << INDENT << '"' << getClassTargetFullName(cppEnum) << "\"," << endl;
- s << INDENT << '"' << (cppEnum->enclosingClass() ? cppEnum->enclosingClass()->qualifiedCppName() + "::" : "");
+ s << INDENT << '"' << (cppEnum->enclosingClass() ? (cppEnum->enclosingClass()->qualifiedCppName() + QLatin1String("::")) : QString());
s << cppEnum->name() << '"';
if (flags)
s << ',' << endl << INDENT << cpythonTypeNameExt(flags);
@@ -4037,9 +4088,9 @@ void CppGenerator::writeEnumInitialization(QTextStream& s, const AbstractMetaEnu
QString enumValueText;
if (!avoidProtectedHack() || !cppEnum->isProtected()) {
- enumValueText = "(long) ";
+ enumValueText = QLatin1String("(long) ");
if (cppEnum->enclosingClass())
- enumValueText += cppEnum->enclosingClass()->qualifiedCppName() + "::";
+ enumValueText += cppEnum->enclosingClass()->qualifiedCppName() + QLatin1String("::");
enumValueText += enumValue->name();
} else {
enumValueText += QString::number(enumValue->value());
@@ -4140,11 +4191,11 @@ void CppGenerator::writeFlagsNonZero(QTextStream& s, const AbstractMetaEnum* cpp
void CppGenerator::writeFlagsMethods(QTextStream& s, const AbstractMetaEnum* cppEnum)
{
- writeFlagsBinaryOperator(s, cppEnum, "and", "&");
- writeFlagsBinaryOperator(s, cppEnum, "or", "|");
- writeFlagsBinaryOperator(s, cppEnum, "xor", "^");
+ writeFlagsBinaryOperator(s, cppEnum, QLatin1String("and"), QLatin1String("&"));
+ writeFlagsBinaryOperator(s, cppEnum, QLatin1String("or"), QLatin1String("|"));
+ writeFlagsBinaryOperator(s, cppEnum, QLatin1String("xor"), QLatin1String("^"));
- writeFlagsUnaryOperator(s, cppEnum, "invert", "~");
+ writeFlagsUnaryOperator(s, cppEnum, QLatin1String("invert"), QLatin1String("~"));
writeFlagsToLong(s, cppEnum);
writeFlagsNonZero(s, cppEnum);
@@ -4229,7 +4280,7 @@ void CppGenerator::writeFlagsBinaryOperator(QTextStream& s, const AbstractMetaEn
s << "#endif" << endl << endl;
s << INDENT << "cppResult = " CPP_SELF_VAR " " << cppOpName << " cppArg;" << endl;
s << INDENT << "return ";
- writeToPythonConversion(s, flagsType, 0, "cppResult");
+ writeToPythonConversion(s, flagsType, 0, QLatin1String("cppResult"));
s << ';' << endl;
s << '}' << endl << endl;
}
@@ -4256,7 +4307,7 @@ void CppGenerator::writeFlagsUnaryOperator(QTextStream& s, const AbstractMetaEnu
if (boolResult)
s << "PyBool_FromLong(cppResult)";
else
- writeToPythonConversion(s, flagsType, 0, "cppResult");
+ writeToPythonConversion(s, flagsType, 0, QLatin1String("cppResult"));
s << ';' << endl;
s << '}' << endl << endl;
}
@@ -4267,10 +4318,10 @@ void CppGenerator::writeClassRegister(QTextStream& s, const AbstractMetaClass* m
const AbstractMetaClass* enc = metaClass->enclosingClass();
bool hasEnclosingClass = enc && enc->typeEntry()->codeGeneration() != TypeEntry::GenerateForSubclass;
- QString enclosingObjectVariable = hasEnclosingClass ? "enclosingClass" : "module";
+ QString enclosingObjectVariable = hasEnclosingClass ? QLatin1String("enclosingClass") : QLatin1String("module");
QString pyTypeName = cpythonTypeName(metaClass);
- s << "void init_" << metaClass->qualifiedCppName().replace("::", "_");
+ s << "void init_" << metaClass->qualifiedCppName().replace(QLatin1String("::"), QLatin1String("_"));
s << "(PyObject* " << enclosingObjectVariable << ")" << endl;
s << '{' << endl;
@@ -4300,13 +4351,13 @@ void CppGenerator::writeClassRegister(QTextStream& s, const AbstractMetaClass* m
s << endl;
// Multiple inheritance
- QString pyTypeBasesVariable = QString("%1_bases").arg(pyTypeName);
+ QString pyTypeBasesVariable = pyTypeName + QLatin1String("_bases");
const AbstractMetaClassList baseClasses = getBaseClasses(metaClass);
if (metaClass->baseClassNames().size() > 1) {
s << INDENT << "PyObject* " << pyTypeBasesVariable << " = PyTuple_Pack(" << baseClasses.size() << ',' << endl;
QStringList bases;
foreach (const AbstractMetaClass* base, baseClasses)
- bases << "(PyObject*)" + cpythonTypeNameExt(base->typeEntry());
+ bases << QLatin1String("(PyObject*)") + cpythonTypeNameExt(base->typeEntry());
Indentation indent(INDENT);
QString separator;
QTextStream sep(&separator);
@@ -4388,7 +4439,7 @@ void CppGenerator::writeClassRegister(QTextStream& s, const AbstractMetaClass* m
foreach (AbstractMetaClass* innerClass, metaClass->innerClasses())
lookForEnumsInClassesNotToBeGenerated(classEnums, innerClass);
- ErrorCode errorCode("");
+ ErrorCode errorCode(QString::null);
writeEnumsInitialization(s, classEnums);
if (metaClass->hasSignals())
@@ -4398,9 +4449,9 @@ void CppGenerator::writeClassRegister(QTextStream& s, const AbstractMetaClass* m
foreach (const AbstractMetaField* field, metaClass->fields()) {
if (!field->isStatic())
continue;
- s << INDENT << "PyDict_SetItemString(" + cpythonTypeName(metaClass) + ".super.ht_type.tp_dict, \"";
+ s << INDENT << QLatin1String("PyDict_SetItemString(") + cpythonTypeName(metaClass) + QLatin1String(".super.ht_type.tp_dict, \"");
s << field->name() << "\", ";
- writeToPythonConversion(s, field->type(), metaClass, metaClass->qualifiedCppName() + "::" + field->name());
+ writeToPythonConversion(s, field->type(), metaClass, metaClass->qualifiedCppName() + QLatin1String("::") + field->name());
s << ");" << endl;
}
s << endl;
@@ -4435,7 +4486,7 @@ void CppGenerator::writeInitQtMetaTypeFunctionBody(QTextStream& s, const Abstrac
const AbstractMetaClass* enclosingClass = metaClass->enclosingClass();
while (enclosingClass) {
if (enclosingClass->typeEntry()->generateCode())
- nameVariants << (enclosingClass->name() + "::" + nameVariants.last());
+ nameVariants << (enclosingClass->name() + QLatin1String("::") + nameVariants.last());
enclosingClass = enclosingClass->enclosingClass();
}
@@ -4455,12 +4506,12 @@ void CppGenerator::writeInitQtMetaTypeFunctionBody(QTextStream& s, const Abstrac
if (canBeValue) {
foreach (QString name, nameVariants) {
- if (name == "iterator") {
+ if (name == QLatin1String("iterator")) {
qCWarning(lcShiboken).noquote().nospace()
<< QString::fromLatin1("%1:%2 FIXME:\n"
" The code tried to qRegisterMetaType the unqualified name "
"'iterator'. This is currently fixed by a hack(ct) and needs improvement!")
- .arg(__FILE__).arg(__LINE__);
+ .arg(QFile::decodeName(__FILE__)).arg(__LINE__);
continue;
}
s << INDENT << "qRegisterMetaType< ::" << className << " >(\"" << name << "\");" << endl;
@@ -4488,7 +4539,10 @@ void CppGenerator::writeTypeDiscoveryFunction(QTextStream& s, const AbstractMeta
s << "static void* " << cpythonBaseName(metaClass) << "_typeDiscovery(void* cptr, SbkObjectType* instanceType)\n{" << endl;
if (!polymorphicExpr.isEmpty()) {
- polymorphicExpr = polymorphicExpr.replace("%1", " reinterpret_cast< ::" + metaClass->qualifiedCppName() + "*>(cptr)");
+ polymorphicExpr = polymorphicExpr.replace(QLatin1String("%1"),
+ QLatin1String(" reinterpret_cast< ::")
+ + metaClass->qualifiedCppName()
+ + QLatin1String("*>(cptr)"));
s << INDENT << " if (" << polymorphicExpr << ")" << endl;
{
Indentation indent(INDENT);
@@ -4539,11 +4593,11 @@ void CppGenerator::writeGetattroFunction(QTextStream& s, const AbstractMetaClass
QString getattrFunc;
if (usePySideExtensions() && metaClass->isQObject()) {
- AbstractMetaClass* qobjectClass = classes().findClass("QObject");
- getattrFunc = QString("PySide::getMetaDataFromQObject(%1, " PYTHON_SELF_VAR ", name)")
- .arg(cpythonWrapperCPtr(qobjectClass, PYTHON_SELF_VAR));
+ AbstractMetaClass* qobjectClass = classes().findClass(QLatin1String("QObject"));
+ getattrFunc = QString::fromLatin1("PySide::getMetaDataFromQObject(%1, " PYTHON_SELF_VAR ", name)")
+ .arg(cpythonWrapperCPtr(qobjectClass, QLatin1String(PYTHON_SELF_VAR)));
} else {
- getattrFunc = "PyObject_GenericGetAttr(" PYTHON_SELF_VAR ", name)";
+ getattrFunc = QLatin1String("PyObject_GenericGetAttr(" PYTHON_SELF_VAR ", name)");
}
if (classNeedsGetattroFunction(metaClass)) {
@@ -4635,8 +4689,8 @@ bool CppGenerator::finishGeneration()
//this is a temporary solution before new type revison implementation
//We need move QMetaObject register before QObject
AbstractMetaClassList lst = classesTopologicalSorted();
- AbstractMetaClass* klassQObject = lst.findClass("QObject");
- AbstractMetaClass* klassQMetaObject = lst.findClass("QMetaObject");
+ AbstractMetaClass* klassQObject = lst.findClass(QLatin1String("QObject"));
+ AbstractMetaClass* klassQMetaObject = lst.findClass(QLatin1String("QMetaObject"));
if (klassQObject && klassQMetaObject) {
lst.removeAll(klassQMetaObject);
int indexOf = lst.indexOf(klassQObject);
@@ -4647,19 +4701,19 @@ bool CppGenerator::finishGeneration()
if (!shouldGenerate(cls))
continue;
- s_classInitDecl << "void init_" << cls->qualifiedCppName().replace("::", "_") << "(PyObject* module);" << endl;
+ s_classInitDecl << "void init_" << cls->qualifiedCppName().replace(QLatin1String("::"), QLatin1String("_")) << "(PyObject* module);" << endl;
- QString defineStr = "init_" + cls->qualifiedCppName().replace("::", "_");
+ QString defineStr = QLatin1String("init_") + cls->qualifiedCppName().replace(QLatin1String("::"), QLatin1String("_"));
if (cls->enclosingClass() && (cls->enclosingClass()->typeEntry()->codeGeneration() != TypeEntry::GenerateForSubclass))
- defineStr += "(" + cpythonTypeNameExt(cls->enclosingClass()->typeEntry()) +"->tp_dict);";
+ defineStr += QLatin1Char('(') + cpythonTypeNameExt(cls->enclosingClass()->typeEntry()) + QLatin1String("->tp_dict);");
else
- defineStr += "(module);";
+ defineStr += QLatin1String("(module);");
s_classPythonDefines << INDENT << defineStr << endl;
}
- QString moduleFileName(outputDirectory() + "/" + subDirectoryForPackage(packageName()));
- moduleFileName += "/" + moduleName().toLower() + "_module_wrapper.cpp";
+ QString moduleFileName(outputDirectory() + QLatin1Char('/') + subDirectoryForPackage(packageName()));
+ moduleFileName += QLatin1Char('/') + moduleName().toLower() + QLatin1String("_module_wrapper.cpp");
QFile file(moduleFileName);
verifyDirectoryFor(file);
@@ -4846,7 +4900,7 @@ bool CppGenerator::finishGeneration()
s << "#endif" << endl;
s << "SBK_MODULE_INIT_FUNCTION_BEGIN(" << moduleName() << ")" << endl;
- ErrorCode errorCode("SBK_MODULE_INIT_ERROR");
+ ErrorCode errorCode(QLatin1String("SBK_MODULE_INIT_ERROR"));
// module inject-code target/beginning
if (!snips.isEmpty()) {
writeCodeSnips(s, snips, CodeSnip::Beginning, TypeSystem::TargetLangCode);
@@ -4927,9 +4981,9 @@ bool CppGenerator::finishGeneration()
if (!alias)
continue;
QString converter = converterObject(alias);
- QStringList cppSignature = pte->qualifiedCppName().split("::", QString::SkipEmptyParts);
+ QStringList cppSignature = pte->qualifiedCppName().split(QLatin1String("::"), QString::SkipEmptyParts);
while (!cppSignature.isEmpty()) {
- QString signature = cppSignature.join("::");
+ QString signature = cppSignature.join(QLatin1String("::"));
s << INDENT << "Shiboken::Conversions::registerConverterName(" << converter << ", \"" << signature << "\");" << endl;
cppSignature.removeFirst();
}
@@ -4944,7 +4998,7 @@ bool CppGenerator::finishGeneration()
foreach (AbstractMetaArgument* arg, func->arguments()) {
if (arg->type()->isContainer()) {
QString value = translateType(arg->type(), metaClass, ExcludeConst | ExcludeReference);
- if (value.startsWith("::"))
+ if (value.startsWith(QLatin1String("::")))
value.remove(0, 2);
typeResolvers << SBK_NORMALIZED_TYPE(value.toUtf8().constData());
}
@@ -5014,7 +5068,7 @@ bool CppGenerator::writeParentChildManagement(QTextStream& s, const AbstractMeta
int childIndex = argIndex;
if (ctorHeuristicEnabled && argIndex > 0 && numArgs) {
AbstractMetaArgument* arg = func->arguments().at(argIndex-1);
- if (arg->name() == "parent" && isObjectType(arg->type())) {
+ if (arg->name() == QLatin1String("parent") && isObjectType(arg->type())) {
action = ArgumentOwner::Add;
parentIndex = argIndex;
childIndex = -1;
@@ -5029,22 +5083,28 @@ bool CppGenerator::writeParentChildManagement(QTextStream& s, const AbstractMeta
<< "Argument index for parent tag out of bounds: " << func->signature();
if (action == ArgumentOwner::Remove) {
- parentVariable = "Py_None";
+ parentVariable = QLatin1String("Py_None");
} else {
- if (parentIndex == 0)
- parentVariable = PYTHON_RETURN_VAR;
- else if (parentIndex == -1)
- parentVariable = PYTHON_SELF_VAR;
- else
- parentVariable = usePyArgs ? QString(PYTHON_ARGS "[%1]").arg(QString::number(parentIndex-1)) : PYTHON_ARG;
+ if (parentIndex == 0) {
+ parentVariable = QLatin1String(PYTHON_RETURN_VAR);
+ } else if (parentIndex == -1) {
+ parentVariable = QLatin1String(PYTHON_SELF_VAR);
+ } else {
+ parentVariable = usePyArgs
+ ? QString::fromLatin1(PYTHON_ARGS "[%1]").arg(parentIndex - 1)
+ : QLatin1String(PYTHON_ARG);
+ }
}
- if (childIndex == 0)
- childVariable = PYTHON_RETURN_VAR;
- else if (childIndex == -1)
- childVariable = PYTHON_SELF_VAR;
- else
- childVariable = usePyArgs ? QString(PYTHON_ARGS "[%1]").arg(QString::number(childIndex-1)) : PYTHON_ARG;
+ if (childIndex == 0) {
+ childVariable = QLatin1String(PYTHON_RETURN_VAR);
+ } else if (childIndex == -1) {
+ childVariable = QLatin1String(PYTHON_SELF_VAR);
+ } else {
+ childVariable = usePyArgs
+ ? QString::fromLatin1(PYTHON_ARGS "[%1]").arg(childIndex - 1)
+ : QLatin1String(PYTHON_ARG);
+ }
s << INDENT << "Shiboken::Object::setParent(" << parentVariable << ", " << childVariable << ");\n";
return true;
@@ -5110,7 +5170,7 @@ void CppGenerator::writeStdListWrapperMethods(QTextStream& s, const AbstractMeta
s << "PyObject* " << cpythonBaseName(metaClass->typeEntry()) << "__getitem__(PyObject* " PYTHON_SELF_VAR ", Py_ssize_t _i)" << endl;
s << '{' << endl;
writeCppSelfDefinition(s, metaClass);
- writeIndexError(s, "index out of bounds");
+ writeIndexError(s, QLatin1String("index out of bounds"));
s << INDENT << metaClass->qualifiedCppName() << "::iterator _item = " CPP_SELF_VAR "->begin();" << endl;
s << INDENT << "for (Py_ssize_t pos = 0; pos < _i; pos++) _item++;" << endl;
@@ -5118,7 +5178,7 @@ void CppGenerator::writeStdListWrapperMethods(QTextStream& s, const AbstractMeta
const AbstractMetaType* itemType = metaClass->templateBaseClassInstantiations().first();
s << INDENT << "return ";
- writeToPythonConversion(s, itemType, metaClass, "*_item");
+ writeToPythonConversion(s, itemType, metaClass, QLatin1String("*_item"));
s << ';' << endl;
s << '}' << endl;
@@ -5127,11 +5187,11 @@ void CppGenerator::writeStdListWrapperMethods(QTextStream& s, const AbstractMeta
s << "int " << cpythonBaseName(metaClass->typeEntry()) << "__setitem__(PyObject* " PYTHON_SELF_VAR ", Py_ssize_t _i, PyObject* pyArg)" << endl;
s << '{' << endl;
writeCppSelfDefinition(s, metaClass);
- writeIndexError(s, "list assignment index out of range");
+ writeIndexError(s, QLatin1String("list assignment index out of range"));
s << INDENT << "PythonToCppFunc " << PYTHON_TO_CPP_VAR << ';' << endl;
s << INDENT << "if (!";
- writeTypeCheck(s, itemType, "pyArg", isNumber(itemType->typeEntry()));
+ writeTypeCheck(s, itemType, QLatin1String("pyArg"), isNumber(itemType->typeEntry()));
s << ") {" << endl;
{
Indentation indent(INDENT);
@@ -5140,7 +5200,7 @@ void CppGenerator::writeStdListWrapperMethods(QTextStream& s, const AbstractMeta
s << INDENT << "return -1;" << endl;
}
s << INDENT << '}' << endl;
- writeArgumentConversion(s, itemType, "cppValue", "pyArg", metaClass);
+ writeArgumentConversion(s, itemType, QLatin1String("cppValue"), QLatin1String("pyArg"), metaClass);
s << INDENT << metaClass->qualifiedCppName() << "::iterator _item = " CPP_SELF_VAR "->begin();" << endl;
s << INDENT << "for (Py_ssize_t pos = 0; pos < _i; pos++) _item++;" << endl;
@@ -5161,7 +5221,7 @@ void CppGenerator::writeIndexError(QTextStream& s, const QString& errorMsg)
QString CppGenerator::writeReprFunction(QTextStream& s, const AbstractMetaClass* metaClass)
{
- QString funcName = cpythonBaseName(metaClass) + "__repr__";
+ QString funcName = cpythonBaseName(metaClass) + QLatin1String("__repr__");
s << "extern \"C\"" << endl;
s << '{' << endl;
s << "static PyObject* " << funcName << "(PyObject* self)" << endl;
diff --git a/generator/shiboken2/cppgenerator.h b/generator/shiboken2/cppgenerator.h
index 293243f..8fa3bb7 100644
--- a/generator/shiboken2/cppgenerator.h
+++ b/generator/shiboken2/cppgenerator.h
@@ -75,7 +75,7 @@ private:
/// Writes the check section for the validity of wrapped C++ objects.
void writeInvalidPyObjectCheck(QTextStream& s, const QString& pyObj);
- void writeTypeCheck(QTextStream& s, const AbstractMetaType* argType, QString argumentName, bool isNumber = false, QString customType = "", bool rejectNull = false);
+ void writeTypeCheck(QTextStream& s, const AbstractMetaType* argType, QString argumentName, bool isNumber = false, QString customType = QString(), bool rejectNull = false);
void writeTypeCheck(QTextStream& s, const OverloadData* overloadData, QString argumentName);
void writeTypeDiscoveryFunction(QTextStream& s, const AbstractMetaClass* metaClass);
@@ -258,7 +258,7 @@ private:
void writeParentChildManagement(QTextStream& s, const AbstractMetaFunction* func, bool userHeuristicForReturn);
bool writeParentChildManagement(QTextStream& s, const AbstractMetaFunction* func, int argIndex, bool userHeuristicPolicy);
- void writeReturnValueHeuristics(QTextStream& s, const AbstractMetaFunction* func, const QString& self = PYTHON_SELF_VAR);
+ void writeReturnValueHeuristics(QTextStream& s, const AbstractMetaFunction* func, const QString& self = QLatin1String(PYTHON_SELF_VAR));
void writeInitQtMetaTypeFunctionBody(QTextStream& s, const AbstractMetaClass* metaClass) const;
/**
diff --git a/generator/shiboken2/headergenerator.cpp b/generator/shiboken2/headergenerator.cpp
index 103e1dc..d815639 100644
--- a/generator/shiboken2/headergenerator.cpp
+++ b/generator/shiboken2/headergenerator.cpp
@@ -34,7 +34,9 @@
QString HeaderGenerator::fileNameForClass(const AbstractMetaClass* metaClass) const
{
- return metaClass->qualifiedCppName().toLower().replace("::", "_") + QLatin1String("_wrapper.h");
+ QString result = metaClass->qualifiedCppName().toLower();
+ result.replace(QLatin1String("::"), QLatin1String("_"));
+ return result + QLatin1String("_wrapper.h");
}
void HeaderGenerator::writeCopyCtor(QTextStream& s, const AbstractMetaClass* metaClass) const
@@ -49,7 +51,7 @@ void HeaderGenerator::writeProtectedFieldAccessors(QTextStream& s, const Abstrac
{
AbstractMetaType *metaType = field->type();
QString fieldType = metaType->cppSignature();
- QString fieldName = field->enclosingClass()->qualifiedCppName() + "::" + field->name();
+ QString fieldName = field->enclosingClass()->qualifiedCppName() + QLatin1String("::") + field->name();
// Force use of pointer to return internal variable memory
bool useReference = (!metaType->isConstant() &&
@@ -81,7 +83,7 @@ void HeaderGenerator::generateClass(QTextStream& s, const AbstractMetaClass* met
s << licenseComment();
QString wrapperName = HeaderGenerator::wrapperName(metaClass);
- QString headerGuard = wrapperName.replace("::", "_").toUpper();
+ QString headerGuard = wrapperName.replace(QLatin1String("::"), QLatin1String("_")).toUpper();
// Header
s << "#ifndef SBK_" << headerGuard << "_H" << endl;
@@ -165,7 +167,8 @@ void HeaderGenerator::writeFunction(QTextStream& s, const AbstractMetaFunction*
if (avoidProtectedHack() && func->isProtected() && !func->isConstructor() && !func->isOperatorOverload()) {
s << INDENT << "inline " << (func->isStatic() ? "static " : "");
- s << functionSignature(func, "", "_protected", Generator::EnumAsInts|Generator::OriginalTypeDescription) << " { ";
+ s << functionSignature(func, QString(), QLatin1String("_protected"), Generator::EnumAsInts|Generator::OriginalTypeDescription)
+ << " { ";
s << (func->type() ? "return " : "");
if (!func->isAbstract())
s << func->ownerClass()->qualifiedCppName() << "::";
@@ -179,10 +182,10 @@ void HeaderGenerator::writeFunction(QTextStream& s, const AbstractMetaFunction*
else if (arg->type()->isEnum())
enumTypeEntry = arg->type()->typeEntry();
if (enumTypeEntry)
- argName = QString("%1(%2)").arg(arg->type()->cppSignature()).arg(argName);
+ argName = QString::fromLatin1("%1(%2)").arg(arg->type()->cppSignature(), argName);
args << argName;
}
- s << args.join(", ") << ')';
+ s << args.join(QLatin1String(", ")) << ')';
s << "; }" << endl;
}
@@ -204,7 +207,7 @@ void HeaderGenerator::writeFunction(QTextStream& s, const AbstractMetaFunction*
else if (!func->hasSignatureModifications())
virtualOption = Generator::NoOption;
- s << functionSignature(func, "", "", virtualOption) << ';' << endl;
+ s << functionSignature(func, QString(), QString(), virtualOption) << ';' << endl;
// Check if this method hide other methods in base classes
foreach (const AbstractMetaFunction* f, func->ownerClass()->functions()) {
@@ -292,7 +295,7 @@ bool HeaderGenerator::finishGeneration()
writeTypeIndexDefineLine(macrosStream, metaEnum->typeEntry());
macrosStream << "#define ";
macrosStream.setFieldWidth(60);
- macrosStream << "SBK_"+moduleName()+"_IDX_COUNT";
+ macrosStream << QLatin1String("SBK_") + moduleName() + QLatin1String("_IDX_COUNT");
macrosStream.setFieldWidth(0);
macrosStream << ' ' << getMaxTypeIndex() << endl << endl;
macrosStream << "// This variable stores all Python types exported by this module." << endl;
@@ -332,7 +335,7 @@ bool HeaderGenerator::finishGeneration()
// Because on win32 the compiler will not accept a zero length array.
if (pCount == 0)
pCount++;
- _writeTypeIndexDefineLine(macrosStream, QString("SBK_%1_CONVERTERS_IDX_COUNT").arg(moduleName()), pCount);
+ _writeTypeIndexDefineLine(macrosStream, QStringLiteral("SBK_%1_CONVERTERS_IDX_COUNT").arg(moduleName()), pCount);
macrosStream << endl;
// TODO-CONVERTER ------------------------------------------------------------------------------
@@ -370,7 +373,7 @@ bool HeaderGenerator::finishGeneration()
+ QDir::separator() + subDirectoryForPackage(packageName())
+ QDir::separator() + getModuleHeaderFileName());
- QString includeShield("SBK_" + moduleName().toUpper() + "_PYTHON_H");
+ QString includeShield(QLatin1String("SBK_") + moduleName().toUpper() + QLatin1String("_PYTHON_H"));
FileOut file(moduleHeaderFileName);
QTextStream& s = file.stream;
@@ -452,7 +455,7 @@ void HeaderGenerator::writeSbkTypeFunction(QTextStream& s, const AbstractMetaEnu
} else {
enumName = cppEnum->name();
if (cppEnum->enclosingClass())
- enumName = cppEnum->enclosingClass()->qualifiedCppName() + "::" + enumName;
+ enumName = cppEnum->enclosingClass()->qualifiedCppName() + QLatin1String("::") + enumName;
}
s << "template<> inline PyTypeObject* SbkType< ::" << enumName << " >() ";
@@ -475,7 +478,7 @@ void HeaderGenerator::writeInheritedOverloads(QTextStream& s)
{
foreach (const AbstractMetaFunction* func, m_inheritedOverloads) {
s << INDENT << "inline ";
- s << functionSignature(func, "", "", Generator::EnumAsInts|Generator::OriginalTypeDescription) << " { ";
+ s << functionSignature(func, QString(), QString(), Generator::EnumAsInts|Generator::OriginalTypeDescription) << " { ";
s << (func->type() ? "return " : "");
s << func->ownerClass()->qualifiedCppName() << "::" << func->originalName() << '(';
QStringList args;
@@ -487,10 +490,10 @@ void HeaderGenerator::writeInheritedOverloads(QTextStream& s)
else if (arg->type()->isEnum())
enumTypeEntry = arg->type()->typeEntry();
if (enumTypeEntry)
- argName = QString("%1(%2)").arg(arg->type()->cppSignature()).arg(argName);
+ argName = arg->type()->cppSignature() + QLatin1Char('(') + argName + QLatin1Char(')');
args << argName;
}
- s << args.join(", ") << ')';
+ s << args.join(QLatin1String(", ")) << ')';
s << "; }" << endl;
}
}
diff --git a/generator/shiboken2/overloaddata.cpp b/generator/shiboken2/overloaddata.cpp
index e767942..4906240 100644
--- a/generator/shiboken2/overloaddata.cpp
+++ b/generator/shiboken2/overloaddata.cpp
@@ -49,7 +49,7 @@ static QString getTypeName(const AbstractMetaType* type)
const TypeEntry* typeEntry = getAliasedTypeEntry(cType->typeEntry());
types << typeEntry->name();
}
- typeName += QString("<%1 >").arg(types.join(","));
+ typeName += QLatin1Char('<') + types.join(QLatin1Char(',')) + QLatin1String(" >");
}
return typeName;
}
@@ -140,7 +140,8 @@ static QString getImplicitConversionTypeName(const AbstractMetaType* containerTy
types << (otherType == instantiation ? impConv : getTypeName(otherType));
const ContainerTypeEntry* containerTypeEntry = dynamic_cast<const ContainerTypeEntry*>(containerType->typeEntry());
- return containerTypeEntry->qualifiedCppName() + '<' + types.join(", ") + " >";
+ return containerTypeEntry->qualifiedCppName() + QLatin1Char('<')
+ + types.join(QLatin1String(", ")) + QLatin1String(" >");
}
/**
@@ -170,11 +171,13 @@ void OverloadData::sortNextOverloads()
// Primitive types that are not int, long, short,
// char and their respective unsigned counterparts.
QStringList nonIntegerPrimitives;
- nonIntegerPrimitives << "float" << "double" << "bool";
+ nonIntegerPrimitives << QLatin1String("float") << QLatin1String("double")
+ << QLatin1String("bool");
// Signed integer primitive types.
QStringList signedIntegerPrimitives;
- signedIntegerPrimitives << "int" << "short" << "long";
+ signedIntegerPrimitives << QLatin1String("int") << QLatin1String("short")
+ << QLatin1String("long");
// sort the children overloads
foreach(OverloadData *ov, m_nextOverloadData)
@@ -191,19 +194,19 @@ void OverloadData::sortNextOverloads()
const QString typeName(getTypeName(ov));
- if (!checkPyObject && typeName.contains("PyObject")) {
+ if (!checkPyObject && typeName.contains(QLatin1String("PyObject"))) {
checkPyObject = true;
pyobjectIndex = sortData.lastProcessedItemId();
- } else if (!checkPySequence && typeName == "PySequence") {
+ } else if (!checkPySequence && typeName == QLatin1String("PySequence")) {
checkPySequence = true;
pySeqIndex = sortData.lastProcessedItemId();
- } else if (!checkPyBuffer && typeName == "PyBuffer") {
+ } else if (!checkPyBuffer && typeName == QLatin1String("PyBuffer")) {
checkPyBuffer = true;
pyBufferIndex = sortData.lastProcessedItemId();
- } else if (!checkQVariant && typeName == "QVariant") {
+ } else if (!checkQVariant && typeName == QLatin1String("QVariant")) {
checkQVariant = true;
qvariantIndex = sortData.lastProcessedItemId();
- } else if (!checkQString && typeName == "QString") {
+ } else if (!checkQString && typeName == QLatin1String("QString")) {
checkQString = true;
qstringIndex = sortData.lastProcessedItemId();
}
@@ -248,7 +251,7 @@ void OverloadData::sortNextOverloads()
const int numPrimitives = sizeof(primitiveTypes)/sizeof(const char*);
bool hasPrimitive[numPrimitives];
for (int i = 0; i < numPrimitives; ++i)
- hasPrimitive[i] = sortData.map.contains(primitiveTypes[i]);
+ hasPrimitive[i] = sortData.map.contains(QLatin1String(primitiveTypes[i]));
if (checkPySequence && checkPyObject)
graph.addEdge(pySeqIndex, pyobjectIndex);
@@ -268,7 +271,7 @@ void OverloadData::sortNextOverloads()
else
convertibleType = getTypeName(function->arguments().first()->type());
- if (convertibleType == "int" || convertibleType == "unsigned int")
+ if (convertibleType == QLatin1String("int") || convertibleType == QLatin1String("unsigned int"))
classesWithIntegerImplicitConversion << targetTypeEntryName;
if (!sortData.map.contains(convertibleType))
@@ -322,9 +325,9 @@ void OverloadData::sortNextOverloads()
if ((checkPySequence || checkPyObject || checkPyBuffer)
- && !targetTypeEntryName.contains("PyObject")
- && !targetTypeEntryName.contains("PyBuffer")
- && !targetTypeEntryName.contains("PySequence")) {
+ && !targetTypeEntryName.contains(QLatin1String("PyObject"))
+ && !targetTypeEntryName.contains(QLatin1String("PyBuffer"))
+ && !targetTypeEntryName.contains(QLatin1String("PySequence"))) {
if (checkPySequence) {
// PySequence will be checked after all more specific types, but before PyObject.
graph.addEdge(targetTypeId, pySeqIndex);
@@ -335,12 +338,12 @@ void OverloadData::sortNextOverloads()
// Add dependency on PyObject, so its check is the last one (too generic).
graph.addEdge(targetTypeId, pyobjectIndex);
}
- } else if (checkQVariant && targetTypeEntryName != "QVariant") {
+ } else if (checkQVariant && targetTypeEntryName != QLatin1String("QVariant")) {
if (!graph.containsEdge(qvariantIndex, targetTypeId)) // Avoid cyclic dependency.
graph.addEdge(targetTypeId, qvariantIndex);
} else if (checkQString && ShibokenGenerator::isPointer(ov->argType())
- && targetTypeEntryName != "QString"
- && targetTypeEntryName != "QByteArray"
+ && targetTypeEntryName != QLatin1String("QString")
+ && targetTypeEntryName != QLatin1String("QByteArray")
&& (!checkPyObject || targetTypeId != pyobjectIndex)) {
if (!graph.containsEdge(qstringIndex, targetTypeId)) // Avoid cyclic dependency.
graph.addEdge(targetTypeId, qstringIndex);
@@ -350,14 +353,14 @@ void OverloadData::sortNextOverloads()
// Enum values must precede primitive types.
for (int i = 0; i < numPrimitives; ++i) {
if (hasPrimitive[i])
- graph.addEdge(targetTypeId, sortData.map[primitiveTypes[i]]);
+ graph.addEdge(targetTypeId, sortData.map[QLatin1String(primitiveTypes[i])]);
}
}
}
// QByteArray args need to be checked after QString args
- if (sortData.map.contains("QString") && sortData.map.contains("QByteArray"))
- graph.addEdge(sortData.map["QString"], sortData.map["QByteArray"]);
+ if (sortData.map.contains(QLatin1String("QString")) && sortData.map.contains(QLatin1String("QByteArray")))
+ graph.addEdge(sortData.map[QLatin1String("QString")], sortData.map[QLatin1String("QByteArray")]);
foreach(OverloadData* ov, m_nextOverloadData) {
const AbstractMetaType* targetType = ov->argType();
@@ -386,10 +389,10 @@ void OverloadData::sortNextOverloads()
if (unmappedResult.isEmpty()) {
QString funcName = referenceFunction()->name();
if (referenceFunction()->ownerClass())
- funcName.prepend(referenceFunction()->ownerClass()->name() + '.');
+ funcName.prepend(referenceFunction()->ownerClass()->name() + QLatin1Char('.'));
// Dump overload graph
- QString graphName = QDir::tempPath() + '/' + funcName + ".dot";
+ QString graphName = QDir::tempPath() + QLatin1Char('/') + funcName + QLatin1String(".dot");
QHash<QString, int>::const_iterator it = sortData.map.begin();
QHash<int, QString> nodeNames;
for (; it != sortData.map.end(); ++it)
@@ -531,7 +534,7 @@ QStringList OverloadData::returnTypes() const
else if (func->type() && !func->argumentRemoved(0))
retTypes << func->type()->cppSignature();
else
- retTypes << "void";
+ retTypes << QLatin1String("void");
}
return QStringList(retTypes.toList());
}
@@ -539,7 +542,7 @@ QStringList OverloadData::returnTypes() const
bool OverloadData::hasNonVoidReturnType() const
{
QStringList retTypes = returnTypes();
- return !retTypes.contains("void") || retTypes.size() > 1;
+ return !retTypes.contains(QLatin1String("void")) || retTypes.size() > 1;
}
bool OverloadData::hasVarargs() const
@@ -689,10 +692,10 @@ QList<const AbstractMetaFunction*> OverloadData::overloadsWithoutRepetition() co
{
QList<const AbstractMetaFunction*> overloads = m_overloads;
foreach (const AbstractMetaFunction* func, m_overloads) {
- if (func->minimalSignature().endsWith("const"))
+ if (func->minimalSignature().endsWith(QLatin1String("const")))
continue;
foreach (const AbstractMetaFunction* f, overloads) {
- if ((func->minimalSignature() + "const") == f->minimalSignature()) {
+ if ((func->minimalSignature() + QLatin1String("const")) == f->minimalSignature()) {
overloads.removeOne(f);
break;
}
@@ -804,9 +807,17 @@ void OverloadData::dumpGraph(QString filename) const
}
}
+static inline QString toHtml(QString s)
+{
+ s.replace(QLatin1Char('<'), QLatin1String("&lt;"));
+ s.replace(QLatin1Char('>'), QLatin1String("&gt;"));
+ s.replace(QLatin1Char('&'), QLatin1String("&amp;"));
+ return s;
+}
+
QString OverloadData::dumpGraph() const
{
- QString indent(4, ' ');
+ QString indent(4, QLatin1Char(' '));
QString result;
QTextStream s(&result);
if (m_argPos == -1) {
@@ -819,10 +830,10 @@ QString OverloadData::dumpGraph() const
foreach (const AbstractMetaFunction* func, overloads()) {
s << "f" << functionNumber(func) << " : ";
if (func->type())
- s << func->type()->cppSignature().replace('<', "&lt;").replace('>', "&gt;");
+ s << toHtml(func->type()->cppSignature());
else
s << "void";
- s << ' ' << func->minimalSignature().replace('<', "&lt;").replace('>', "&gt;") << "\\l";
+ s << ' ' << toHtml(func->minimalSignature()) << "\\l";
}
s << "\"];" << endl;
@@ -832,7 +843,7 @@ QString OverloadData::dumpGraph() const
s << "<tr><td bgcolor=\"black\" align=\"center\" cellpadding=\"6\" colspan=\"2\"><font color=\"white\">";
if (rfunc->ownerClass())
s << rfunc->ownerClass()->name() << "::";
- s << rfunc->name().replace('<', "&lt;").replace('>', "&gt;") << "</font>";
+ s << toHtml(rfunc->name()) << "</font>";
if (rfunc->isVirtual()) {
s << "<br/><font color=\"white\" point-size=\"10\">&lt;&lt;";
if (rfunc->isAbstract())
@@ -844,7 +855,7 @@ QString OverloadData::dumpGraph() const
// Function return type
s << "<tr><td bgcolor=\"gray\" align=\"right\">original type</td><td bgcolor=\"gray\" align=\"left\">";
if (rfunc->type())
- s << rfunc->type()->cppSignature().replace('<', "&lt;").replace('>', "&gt;");
+ s << toHtml(rfunc->type()->cppSignature());
else
s << "void";
s << "</td></tr>";
@@ -855,7 +866,7 @@ QString OverloadData::dumpGraph() const
continue;
s << "<tr><td bgcolor=\"gray\" align=\"right\">f" << functionNumber(func);
s << "-type</td><td bgcolor=\"gray\" align=\"left\">";
- s << func->typeReplaced(0).replace('<', "&lt;").replace('>', "&gt;") << "</td></tr>";
+ s << toHtml(func->typeReplaced(0)) << "</td></tr>";
}
// Minimum and maximum number of arguments
@@ -884,7 +895,7 @@ QString OverloadData::dumpGraph() const
s << "}" << endl;
} else {
- QString argId = QString("arg_%1").arg((ulong)this);
+ QString argId = QLatin1String("arg_") + QString::number(quintptr(this));
s << argId << ';' << endl;
s << indent << '"' << argId << "\" [shape=\"plaintext\" style=\"filled,bold\" margin=\"0\" fontname=\"freemono\" fillcolor=\"white\" penwidth=1 ";
@@ -897,10 +908,10 @@ QString OverloadData::dumpGraph() const
// Argument type information
QString type = hasArgumentTypeReplace() ? argumentTypeReplaced() : argType()->cppSignature();
s << "<tr><td bgcolor=\"gray\" align=\"right\">type</td><td bgcolor=\"gray\" align=\"left\">";
- s << type.replace("&", "&amp;") << "</td></tr>";
+ s << toHtml(type) << "</td></tr>";
if (hasArgumentTypeReplace()) {
s << "<tr><td bgcolor=\"gray\" align=\"right\">orig. type</td><td bgcolor=\"gray\" align=\"left\">";
- s << argType()->cppSignature().replace("&", "&amp;") << "</td></tr>";
+ s << toHtml(argType()->cppSignature()) << "</td></tr>";
}
// Overloads for the signature to present point
diff --git a/generator/shiboken2/shibokengenerator.cpp b/generator/shiboken2/shibokengenerator.cpp
index f7162fd..897fc1a 100644
--- a/generator/shiboken2/shibokengenerator.cpp
+++ b/generator/shiboken2/shibokengenerator.cpp
@@ -54,12 +54,12 @@ static QString resolveScopePrefix(const AbstractMetaClass* scope, const QString&
return QString();
QString name;
- QStringList parts = scope->qualifiedCppName().split("::", QString::SkipEmptyParts);
+ QStringList parts = scope->qualifiedCppName().split(QLatin1String("::"), QString::SkipEmptyParts);
for(int i = (parts.size() - 1) ; i >= 0; i--) {
- if (!value.startsWith(parts[i] + "::"))
- name = parts[i] + "::" + name;
+ if (!value.startsWith(parts[i] + QLatin1String("::")))
+ name = parts[i] + QLatin1String("::") + name;
else
- name = "";
+ name.clear();
}
return name;
@@ -77,14 +77,14 @@ ShibokenGenerator::ShibokenGenerator() : Generator()
m_metaTypeFromStringCache = AbstractMetaTypeCache();
- m_typeSystemConvName[TypeSystemCheckFunction] = "checkType";
- m_typeSystemConvName[TypeSystemIsConvertibleFunction] = "isConvertible";
- m_typeSystemConvName[TypeSystemToCppFunction] = "toCpp";
- m_typeSystemConvName[TypeSystemToPythonFunction] = "toPython";
- m_typeSystemConvRegEx[TypeSystemCheckFunction] = QRegExp(CHECKTYPE_REGEX);
- m_typeSystemConvRegEx[TypeSystemIsConvertibleFunction] = QRegExp(ISCONVERTIBLE_REGEX);
- m_typeSystemConvRegEx[TypeSystemToPythonFunction] = QRegExp(CONVERTTOPYTHON_REGEX);
- m_typeSystemConvRegEx[TypeSystemToCppFunction] = QRegExp(CONVERTTOCPP_REGEX);
+ m_typeSystemConvName[TypeSystemCheckFunction] = QLatin1String("checkType");
+ m_typeSystemConvName[TypeSystemIsConvertibleFunction] = QLatin1String("isConvertible");
+ m_typeSystemConvName[TypeSystemToCppFunction] = QLatin1String("toCpp");
+ m_typeSystemConvName[TypeSystemToPythonFunction] = QLatin1String("toPython");
+ m_typeSystemConvRegEx[TypeSystemCheckFunction] = QRegExp(QLatin1String(CHECKTYPE_REGEX));
+ m_typeSystemConvRegEx[TypeSystemIsConvertibleFunction] = QRegExp(QLatin1String(ISCONVERTIBLE_REGEX));
+ m_typeSystemConvRegEx[TypeSystemToPythonFunction] = QRegExp(QLatin1String(CONVERTTOPYTHON_REGEX));
+ m_typeSystemConvRegEx[TypeSystemToCppFunction] = QRegExp(QLatin1String(CONVERTTOCPP_REGEX));
}
ShibokenGenerator::~ShibokenGenerator()
@@ -95,10 +95,10 @@ ShibokenGenerator::~ShibokenGenerator()
void ShibokenGenerator::clearTpFuncs()
{
- m_tpFuncs["__str__"] = QString("0");
- m_tpFuncs["__repr__"] = QString("0");
- m_tpFuncs["__iter__"] = QString("0");
- m_tpFuncs["__next__"] = QString("0");
+ m_tpFuncs.insert(QLatin1String("__str__"), QLatin1String("0"));
+ m_tpFuncs.insert(QLatin1String("__repr__"), QLatin1String("0"));
+ m_tpFuncs.insert(QLatin1String("__iter__"), QLatin1String("0"));
+ m_tpFuncs.insert(QLatin1String("__next__"), QLatin1String("0"));
}
void ShibokenGenerator::initPrimitiveTypesCorrespondences()
@@ -107,109 +107,110 @@ void ShibokenGenerator::initPrimitiveTypesCorrespondences()
m_pythonPrimitiveTypeName.clear();
// PyBool
- m_pythonPrimitiveTypeName["bool"] = "PyBool";
+ m_pythonPrimitiveTypeName.insert(QLatin1String("bool"), QLatin1String("PyBool"));
// PyInt
- m_pythonPrimitiveTypeName["char"] = "SbkChar";
- m_pythonPrimitiveTypeName["signed char"] = "SbkChar";
- m_pythonPrimitiveTypeName["unsigned char"] = "SbkChar";
- m_pythonPrimitiveTypeName["int"] = "PyInt";
- m_pythonPrimitiveTypeName["signed int"] = "PyInt";
- m_pythonPrimitiveTypeName["uint"] = "PyInt";
- m_pythonPrimitiveTypeName["unsigned int"] = "PyInt";
- m_pythonPrimitiveTypeName["short"] = "PyInt";
- m_pythonPrimitiveTypeName["ushort"] = "PyInt";
- m_pythonPrimitiveTypeName["signed short"] = "PyInt";
- m_pythonPrimitiveTypeName["signed short int"] = "PyInt";
- m_pythonPrimitiveTypeName["unsigned short"] = "PyInt";
- m_pythonPrimitiveTypeName["unsigned short int"] = "PyInt";
- m_pythonPrimitiveTypeName["long"] = "PyInt";
+ m_pythonPrimitiveTypeName.insert(QLatin1String("char"), QLatin1String("SbkChar"));
+ m_pythonPrimitiveTypeName.insert(QLatin1String("signed char"), QLatin1String("SbkChar"));
+ m_pythonPrimitiveTypeName.insert(QLatin1String("unsigned char"), QLatin1String("SbkChar"));
+ m_pythonPrimitiveTypeName.insert(QLatin1String("int"), QLatin1String("PyInt"));
+ m_pythonPrimitiveTypeName.insert(QLatin1String("signed int"), QLatin1String("PyInt"));
+ m_pythonPrimitiveTypeName.insert(QLatin1String("uint"), QLatin1String("PyInt"));
+ m_pythonPrimitiveTypeName.insert(QLatin1String("unsigned int"), QLatin1String("PyInt"));
+ m_pythonPrimitiveTypeName.insert(QLatin1String("short"), QLatin1String("PyInt"));
+ m_pythonPrimitiveTypeName.insert(QLatin1String("ushort"), QLatin1String("PyInt"));
+ m_pythonPrimitiveTypeName.insert(QLatin1String("signed short"), QLatin1String("PyInt"));
+ m_pythonPrimitiveTypeName.insert(QLatin1String("signed short int"), QLatin1String("PyInt"));
+ m_pythonPrimitiveTypeName.insert(QLatin1String("unsigned short"), QLatin1String("PyInt"));
+ m_pythonPrimitiveTypeName.insert(QLatin1String("unsigned short int"), QLatin1String("PyInt"));
+ m_pythonPrimitiveTypeName.insert(QLatin1String("long"), QLatin1String("PyInt"));
// PyFloat
- m_pythonPrimitiveTypeName["double"] = "PyFloat";
- m_pythonPrimitiveTypeName["float"] = "PyFloat";
+ m_pythonPrimitiveTypeName.insert(QLatin1String("double"), QLatin1String("PyFloat"));
+ m_pythonPrimitiveTypeName.insert(QLatin1String("float"), QLatin1String("PyFloat"));
// PyLong
- m_pythonPrimitiveTypeName["unsigned long"] = "PyLong";
- m_pythonPrimitiveTypeName["signed long"] = "PyLong";
- m_pythonPrimitiveTypeName["ulong"] = "PyLong";
- m_pythonPrimitiveTypeName["unsigned long int"] = "PyLong";
- m_pythonPrimitiveTypeName["long long"] = "PyLong";
- m_pythonPrimitiveTypeName["__int64"] = "PyLong";
- m_pythonPrimitiveTypeName["unsigned long long"] = "PyLong";
- m_pythonPrimitiveTypeName["unsigned __int64"] = "PyLong";
- m_pythonPrimitiveTypeName["size_t"] = "PyLong";
+ m_pythonPrimitiveTypeName.insert(QLatin1String("unsigned long"), QLatin1String("PyLong"));
+ m_pythonPrimitiveTypeName.insert(QLatin1String("signed long"), QLatin1String("PyLong"));
+ m_pythonPrimitiveTypeName.insert(QLatin1String("ulong"), QLatin1String("PyLong"));
+ m_pythonPrimitiveTypeName.insert(QLatin1String("unsigned long int"), QLatin1String("PyLong"));
+ m_pythonPrimitiveTypeName.insert(QLatin1String("long long"), QLatin1String("PyLong"));
+ m_pythonPrimitiveTypeName.insert(QLatin1String("__int64"), QLatin1String("PyLong"));
+ m_pythonPrimitiveTypeName.insert(QLatin1String("unsigned long long"), QLatin1String("PyLong"));
+ m_pythonPrimitiveTypeName.insert(QLatin1String("unsigned __int64"), QLatin1String("PyLong"));
+ m_pythonPrimitiveTypeName.insert(QLatin1String("size_t"), QLatin1String("PyLong"));
// Python operators
m_pythonOperators.clear();
// call operator
- m_pythonOperators["operator()"] = "call";
+ m_pythonOperators.insert(QLatin1String("operator()"), QLatin1String("call"));
// Arithmetic operators
- m_pythonOperators["operator+"] = "add";
- m_pythonOperators["operator-"] = "sub";
- m_pythonOperators["operator*"] = "mul";
- m_pythonOperators["operator/"] = "div";
- m_pythonOperators["operator%"] = "mod";
+ m_pythonOperators.insert(QLatin1String("operator+"), QLatin1String("add"));
+ m_pythonOperators.insert(QLatin1String("operator-"), QLatin1String("sub"));
+ m_pythonOperators.insert(QLatin1String("operator*"), QLatin1String("mul"));
+ m_pythonOperators.insert(QLatin1String("operator/"), QLatin1String("div"));
+ m_pythonOperators.insert(QLatin1String("operator%"), QLatin1String("mod"));
// Inplace arithmetic operators
- m_pythonOperators["operator+="] = "iadd";
- m_pythonOperators["operator-="] = "isub";
- m_pythonOperators["operator++"] = "iadd";
- m_pythonOperators["operator--"] = "isub";
- m_pythonOperators["operator*="] = "imul";
- m_pythonOperators["operator/="] = "idiv";
- m_pythonOperators["operator%="] = "imod";
+ m_pythonOperators.insert(QLatin1String("operator+="), QLatin1String("iadd"));
+ m_pythonOperators.insert(QLatin1String("operator-="), QLatin1String("isub"));
+ m_pythonOperators.insert(QLatin1String("operator++"), QLatin1String("iadd"));
+ m_pythonOperators.insert(QLatin1String("operator--"), QLatin1String("isub"));
+ m_pythonOperators.insert(QLatin1String("operator*="), QLatin1String("imul"));
+ m_pythonOperators.insert(QLatin1String("operator/="), QLatin1String("idiv"));
+ m_pythonOperators.insert(QLatin1String("operator%="), QLatin1String("imod"));
// Bitwise operators
- m_pythonOperators["operator&"] = "and";
- m_pythonOperators["operator^"] = "xor";
- m_pythonOperators["operator|"] = "or";
- m_pythonOperators["operator<<"] = "lshift";
- m_pythonOperators["operator>>"] = "rshift";
- m_pythonOperators["operator~"] = "invert";
+ m_pythonOperators.insert(QLatin1String("operator&"), QLatin1String("and"));
+ m_pythonOperators.insert(QLatin1String("operator^"), QLatin1String("xor"));
+ m_pythonOperators.insert(QLatin1String("operator|"), QLatin1String("or"));
+ m_pythonOperators.insert(QLatin1String("operator<<"), QLatin1String("lshift"));
+ m_pythonOperators.insert(QLatin1String("operator>>"), QLatin1String("rshift"));
+ m_pythonOperators.insert(QLatin1String("operator~"), QLatin1String("invert"));
// Inplace bitwise operators
- m_pythonOperators["operator&="] = "iand";
- m_pythonOperators["operator^="] = "ixor";
- m_pythonOperators["operator|="] = "ior";
- m_pythonOperators["operator<<="] = "ilshift";
- m_pythonOperators["operator>>="] = "irshift";
+ m_pythonOperators.insert(QLatin1String("operator&="), QLatin1String("iand"));
+ m_pythonOperators.insert(QLatin1String("operator^="), QLatin1String("ixor"));
+ m_pythonOperators.insert(QLatin1String("operator|="), QLatin1String("ior"));
+ m_pythonOperators.insert(QLatin1String("operator<<="), QLatin1String("ilshift"));
+ m_pythonOperators.insert(QLatin1String("operator>>="), QLatin1String("irshift"));
// Comparison operators
- m_pythonOperators["operator=="] = "eq";
- m_pythonOperators["operator!="] = "ne";
- m_pythonOperators["operator<"] = "lt";
- m_pythonOperators["operator>"] = "gt";
- m_pythonOperators["operator<="] = "le";
- m_pythonOperators["operator>="] = "ge";
+ m_pythonOperators.insert(QLatin1String("operator=="), QLatin1String("eq"));
+ m_pythonOperators.insert(QLatin1String("operator!="), QLatin1String("ne"));
+ m_pythonOperators.insert(QLatin1String("operator<"), QLatin1String("lt"));
+ m_pythonOperators.insert(QLatin1String("operator>"), QLatin1String("gt"));
+ m_pythonOperators.insert(QLatin1String("operator<="), QLatin1String("le"));
+ m_pythonOperators.insert(QLatin1String("operator>="), QLatin1String("ge"));
// Initialize format units for C++->Python->C++ conversion
m_formatUnits.clear();
- m_formatUnits.insert("char", "b");
- m_formatUnits.insert("unsigned char", "B");
- m_formatUnits.insert("int", "i");
- m_formatUnits.insert("unsigned int", "I");
- m_formatUnits.insert("short", "h");
- m_formatUnits.insert("unsigned short", "H");
- m_formatUnits.insert("long", "l");
- m_formatUnits.insert("unsigned long", "k");
- m_formatUnits.insert("long long", "L");
- m_formatUnits.insert("__int64", "L");
- m_formatUnits.insert("unsigned long long", "K");
- m_formatUnits.insert("unsigned __int64", "K");
- m_formatUnits.insert("double", "d");
- m_formatUnits.insert("float", "f");
+ m_formatUnits.insert(QLatin1String("char"), QLatin1String("b"));
+ m_formatUnits.insert(QLatin1String("unsigned char"), QLatin1String("B"));
+ m_formatUnits.insert(QLatin1String("int"), QLatin1String("i"));
+ m_formatUnits.insert(QLatin1String("unsigned int"), QLatin1String("I"));
+ m_formatUnits.insert(QLatin1String("short"), QLatin1String("h"));
+ m_formatUnits.insert(QLatin1String("unsigned short"), QLatin1String("H"));
+ m_formatUnits.insert(QLatin1String("long"), QLatin1String("l"));
+ m_formatUnits.insert(QLatin1String("unsigned long"), QLatin1String("k"));
+ m_formatUnits.insert(QLatin1String("long long"), QLatin1String("L"));
+ m_formatUnits.insert(QLatin1String("__int64"), QLatin1String("L"));
+ m_formatUnits.insert(QLatin1String("unsigned long long"), QLatin1String("K"));
+ m_formatUnits.insert(QLatin1String("unsigned __int64"), QLatin1String("K"));
+ m_formatUnits.insert(QLatin1String("double"), QLatin1String("d"));
+ m_formatUnits.insert(QLatin1String("float"), QLatin1String("f"));
}
void ShibokenGenerator::initKnownPythonTypes()
{
m_knownPythonTypes.clear();
- m_knownPythonTypes << "PyBool" << "PyInt" << "PyFloat" << "PyLong";
- m_knownPythonTypes << "PyObject" << "PyString" << "PyBuffer";
- m_knownPythonTypes << "PySequence" << "PyTuple" << "PyList" << "PyDict";
- m_knownPythonTypes << "PyObject*" << "PyObject *" << "PyTupleObject*";
+ m_knownPythonTypes << QLatin1String("PyBool") << QLatin1String("PyInt")
+ << QLatin1String("PyFloat") << QLatin1String("PyLong") << QLatin1String("PyObject")
+ << QLatin1String("PyString") << QLatin1String("PyBuffer") << QLatin1String("PySequence")
+ << QLatin1String("PyTuple") << QLatin1String("PyList") << QLatin1String("PyDict")
+ << QLatin1String("PyObject*") << QLatin1String("PyObject *") << QLatin1String("PyTupleObject*");
}
QString ShibokenGenerator::translateTypeForWrapperMethod(const AbstractMetaType* cType,
@@ -217,7 +218,7 @@ QString ShibokenGenerator::translateTypeForWrapperMethod(const AbstractMetaType*
Options options) const
{
if (cType->isArray())
- return translateTypeForWrapperMethod(cType->arrayElementType(), context, options) + "[]";
+ return translateTypeForWrapperMethod(cType->arrayElementType(), context, options) + QLatin1String("[]");
if (avoidProtectedHack() && cType->isEnum()) {
const AbstractMetaEnum* metaEnum = findAbstractMetaEnum(cType);
@@ -289,9 +290,9 @@ QString ShibokenGenerator::wrapperName(const AbstractMetaClass* metaClass) const
if (shouldGenerateCppWrapper(metaClass)) {
QString result = metaClass->name();
if (metaClass->enclosingClass()) // is a inner class
- result.replace("::", "_");
+ result.replace(QLatin1String("::"), QLatin1String("_"));
- result +="Wrapper";
+ result += QLatin1String("Wrapper");
return result;
} else {
return metaClass->qualifiedCppName();
@@ -310,24 +311,24 @@ QString ShibokenGenerator::fullPythonFunctionName(const AbstractMetaFunction* fu
if (func->isConstructor())
funcName = fullName;
else
- funcName.prepend(fullName + '.');
+ funcName.prepend(fullName + QLatin1Char('.'));
}
return funcName;
}
QString ShibokenGenerator::protectedEnumSurrogateName(const AbstractMetaEnum* metaEnum)
{
- return metaEnum->fullName().replace(".", "_").replace("::", "_") + "_Surrogate";
+ return metaEnum->fullName().replace(QLatin1Char('.'), QLatin1Char('_')).replace(QLatin1String("::"), QLatin1String("_")) + QLatin1String("_Surrogate");
}
QString ShibokenGenerator::protectedFieldGetterName(const AbstractMetaField* field)
{
- return QString("protected_%1_getter").arg(field->name());
+ return QStringLiteral("protected_%1_getter").arg(field->name());
}
QString ShibokenGenerator::protectedFieldSetterName(const AbstractMetaField* field)
{
- return QString("protected_%1_setter").arg(field->name());
+ return QStringLiteral("protected_%1_setter").arg(field->name());
}
QString ShibokenGenerator::cpythonFunctionName(const AbstractMetaFunction* func)
@@ -337,16 +338,16 @@ QString ShibokenGenerator::cpythonFunctionName(const AbstractMetaFunction* func)
if (func->ownerClass()) {
result = cpythonBaseName(func->ownerClass()->typeEntry());
if (func->isConstructor() || func->isCopyConstructor()) {
- result += "_Init";
+ result += QLatin1String("_Init");
} else {
- result += "Func_";
+ result += QLatin1String("Func_");
if (func->isOperatorOverload())
result += ShibokenGenerator::pythonOperatorFunctionName(func);
else
result += func->name();
}
} else {
- result = "Sbk" + moduleName() + "Module_" + func->name();
+ result = QLatin1String("Sbk") + moduleName() + QLatin1String("Module_") + func->name();
}
return result;
@@ -356,39 +357,39 @@ QString ShibokenGenerator::cpythonMethodDefinitionName(const AbstractMetaFunctio
{
if (!func->ownerClass())
return QString();
- return QString("%1Method_%2").arg(cpythonBaseName(func->ownerClass()->typeEntry())).arg(func->name());
+ return QStringLiteral("%1Method_%2").arg(cpythonBaseName(func->ownerClass()->typeEntry()), func->name());
}
QString ShibokenGenerator::cpythonGettersSettersDefinitionName(const AbstractMetaClass* metaClass)
{
- return QString("%1_getsetlist").arg(cpythonBaseName(metaClass));
+ return cpythonBaseName(metaClass) + QLatin1String("_getsetlist");
}
QString ShibokenGenerator::cpythonSetattroFunctionName(const AbstractMetaClass* metaClass)
{
- return QString("%1_setattro").arg(cpythonBaseName(metaClass));
+ return cpythonBaseName(metaClass) + QLatin1String("_setattro");
}
QString ShibokenGenerator::cpythonGetattroFunctionName(const AbstractMetaClass* metaClass)
{
- return QString("%1_getattro").arg(cpythonBaseName(metaClass));
+ return cpythonBaseName(metaClass) + QLatin1String("_getattro");
}
QString ShibokenGenerator::cpythonGetterFunctionName(const AbstractMetaField* metaField)
{
- return QString("%1_get_%2").arg(cpythonBaseName(metaField->enclosingClass())).arg(metaField->name());
+ return QStringLiteral("%1_get_%2").arg(cpythonBaseName(metaField->enclosingClass()), metaField->name());
}
QString ShibokenGenerator::cpythonSetterFunctionName(const AbstractMetaField* metaField)
{
- return QString("%1_set_%2").arg(cpythonBaseName(metaField->enclosingClass())).arg(metaField->name());
+ return QStringLiteral("%1_set_%2").arg(cpythonBaseName(metaField->enclosingClass()), metaField->name());
}
static QString cpythonEnumFlagsName(QString moduleName, QString qualifiedCppName)
{
- QString result = QString("Sbk%1_%2").arg(moduleName).arg(qualifiedCppName);
- result.replace("::", "_");
+ QString result = QStringLiteral("Sbk%1_%2").arg(moduleName, qualifiedCppName);
+ result.replace(QLatin1String("::"), QLatin1String("_"));
return result;
}
@@ -424,7 +425,7 @@ QString ShibokenGenerator::guessScopeForDefaultValue(const AbstractMetaFunction*
if (isPointer(arg->type()))
return value;
- static QRegExp enumValueRegEx("^([A-Za-z_]\\w*)?$");
+ static QRegExp enumValueRegEx(QLatin1String("^([A-Za-z_]\\w*)?$"));
QString prefix;
QString suffix;
@@ -433,44 +434,44 @@ QString ShibokenGenerator::guessScopeForDefaultValue(const AbstractMetaFunction*
if (metaEnum)
prefix = resolveScopePrefix(metaEnum->enclosingClass(), value);
} else if (arg->type()->isFlags()) {
- static QRegExp numberRegEx("^\\d+$"); // Numbers to flags
+ static QRegExp numberRegEx(QLatin1String("^\\d+$")); // Numbers to flags
if (numberRegEx.exactMatch(value)) {
QString typeName = translateTypeForWrapperMethod(arg->type(), func->implementingClass());
if (arg->type()->isConstant())
typeName.remove(0, sizeof("const ") / sizeof(char) - 1);
if (arg->type()->isReference())
typeName.chop(1);
- prefix = typeName + '(';
- suffix = ')';
+ prefix = typeName + QLatin1Char('(');
+ suffix = QLatin1Char(')');
}
- static QRegExp enumCombinationRegEx("^([A-Za-z_][\\w:]*)\\(([^,\\(\\)]*)\\)$"); // FlagName(EnumItem|EnumItem|...)
+ static QRegExp enumCombinationRegEx(QLatin1String("^([A-Za-z_][\\w:]*)\\(([^,\\(\\)]*)\\)$")); // FlagName(EnumItem|EnumItem|...)
if (prefix.isEmpty() && enumCombinationRegEx.indexIn(value) != -1) {
QString flagName = enumCombinationRegEx.cap(1);
- QStringList enumItems = enumCombinationRegEx.cap(2).split("|");
+ QStringList enumItems = enumCombinationRegEx.cap(2).split(QLatin1Char('|'));
QString scope = searchForEnumScope(func->implementingClass(), enumItems.first());
if (!scope.isEmpty())
- scope.append("::");
+ scope.append(QLatin1String("::"));
QStringList fixedEnumItems;
foreach (const QString& enumItem, enumItems)
fixedEnumItems << QString(scope + enumItem);
if (!fixedEnumItems.isEmpty()) {
- prefix = flagName + '(';
- value = fixedEnumItems.join("|");
- suffix = ')';
+ prefix = flagName + QLatin1Char('(');
+ value = fixedEnumItems.join(QLatin1Char('|'));
+ suffix = QLatin1Char(')');
}
}
} else if (arg->type()->typeEntry()->isValue()) {
const AbstractMetaClass* metaClass = classes().findClass(arg->type()->typeEntry());
- if (enumValueRegEx.exactMatch(value)&& value != "NULL")
+ if (enumValueRegEx.exactMatch(value)&& value != QLatin1String("NULL"))
prefix = resolveScopePrefix(metaClass, value);
- } else if (arg->type()->isPrimitive() && arg->type()->name() == "int") {
+ } else if (arg->type()->isPrimitive() && arg->type()->name() == QLatin1String("int")) {
if (enumValueRegEx.exactMatch(value) && func->implementingClass())
prefix = resolveScopePrefix(func->implementingClass(), value);
} else if(arg->type()->isPrimitive()) {
- static QRegExp unknowArgumentRegEx("^(?:[A-Za-z_][\\w:]*\\()?([A-Za-z_]\\w*)(?:\\))?$"); // [PrimitiveType(] DESIREDNAME [)]
+ static QRegExp unknowArgumentRegEx(QLatin1String("^(?:[A-Za-z_][\\w:]*\\()?([A-Za-z_]\\w*)(?:\\))?$")); // [PrimitiveType(] DESIREDNAME [)]
if (unknowArgumentRegEx.indexIn(value) != -1 && func->implementingClass()) {
foreach (const AbstractMetaField* field, func->implementingClass()->fields()) {
if (unknowArgumentRegEx.cap(1).trimmed() == field->name()) {
@@ -478,9 +479,9 @@ QString ShibokenGenerator::guessScopeForDefaultValue(const AbstractMetaFunction*
if (field->isStatic()) {
prefix = resolveScopePrefix(func->implementingClass(), value);
fieldName.prepend(prefix);
- prefix= "";
+ prefix.clear();
} else {
- fieldName.prepend(CPP_SELF_VAR "->");
+ fieldName.prepend(QLatin1String(CPP_SELF_VAR "->"));
}
value.replace(unknowArgumentRegEx.cap(1), fieldName);
break;
@@ -499,17 +500,21 @@ QString ShibokenGenerator::guessScopeForDefaultValue(const AbstractMetaFunction*
QString ShibokenGenerator::cpythonEnumName(const EnumTypeEntry* enumEntry)
{
- return cpythonEnumFlagsName(enumEntry->targetLangPackage().replace(".", "_"), enumEntry->qualifiedCppName());
+ QString p = enumEntry->targetLangPackage();
+ p.replace(QLatin1Char('.'), QLatin1Char('_'));
+ return cpythonEnumFlagsName(p, enumEntry->qualifiedCppName());
}
QString ShibokenGenerator::cpythonFlagsName(const FlagsTypeEntry* flagsEntry)
{
- return cpythonEnumFlagsName(flagsEntry->targetLangPackage().replace(".", "_"), flagsEntry->originalName());
+ QString p = flagsEntry->targetLangPackage();
+ p.replace(QLatin1Char('.'), QLatin1Char('_'));
+ return cpythonEnumFlagsName(p, flagsEntry->originalName());
}
QString ShibokenGenerator::cpythonSpecialCastFunctionName(const AbstractMetaClass* metaClass)
{
- return cpythonBaseName(metaClass->typeEntry())+"SpecialCastFunction";
+ return cpythonBaseName(metaClass->typeEntry()) + QLatin1String("SpecialCastFunction");
}
QString ShibokenGenerator::cpythonWrapperCPtr(const AbstractMetaClass* metaClass, QString argName)
@@ -526,16 +531,14 @@ QString ShibokenGenerator::cpythonWrapperCPtr(const TypeEntry* type, QString arg
{
if (!ShibokenGenerator::isWrapperType(type))
return QString();
- return QString("((::%1*)Shiboken::Conversions::cppPointer(%2, (SbkObject*)%3))")
- .arg(type->qualifiedCppName())
- .arg(cpythonTypeNameExt(type))
- .arg(argName);
+ return QStringLiteral("((::%1*)Shiboken::Conversions::cppPointer(%2, (SbkObject*)%3))")
+ .arg(type->qualifiedCppName(), cpythonTypeNameExt(type), argName);
}
QString ShibokenGenerator::getFunctionReturnType(const AbstractMetaFunction* func, Options options) const
{
if (func->ownerClass() && (func->isConstructor() || func->isCopyConstructor()))
- return func->ownerClass()->qualifiedCppName() + '*';
+ return func->ownerClass()->qualifiedCppName() + QLatin1Char('*');
return translateTypeForWrapperMethod(func->type(), func->implementingClass());
}
@@ -591,7 +594,7 @@ QString ShibokenGenerator::getFormatUnitString(const AbstractMetaFunction* func,
continue;
if (!func->typeReplaced(arg->argumentIndex() + 1).isEmpty()) {
- result += objType;
+ result += QLatin1Char(objType);
} else if (arg->type()->isQObject()
|| arg->type()->isObject()
|| arg->type()->isValue()
@@ -601,7 +604,7 @@ QString ShibokenGenerator::getFormatUnitString(const AbstractMetaFunction* func,
|| arg->type()->isFlags()
|| arg->type()->isContainer()
|| arg->type()->isReference()) {
- result += objType;
+ result += QLatin1Char(objType);
} else if (arg->type()->isPrimitive()) {
const PrimitiveTypeEntry* ptype = (const PrimitiveTypeEntry*) arg->type()->typeEntry();
if (ptype->basicAliasedTypeEntry())
@@ -609,16 +612,16 @@ QString ShibokenGenerator::getFormatUnitString(const AbstractMetaFunction* func,
if (m_formatUnits.contains(ptype->name()))
result += m_formatUnits[ptype->name()];
else
- result += objType;
+ result += QLatin1Char(objType);
} else if (isCString(arg->type())) {
- result += 'z';
+ result += QLatin1Char('z');
} else {
qCWarning(lcShiboken).noquote().nospace()
<< "Method: " << func->ownerClass()->qualifiedCppName()
<< "::" << func->signature() << " => Arg:"
<< arg->name() << "index: " << arg->argumentIndex()
<< " - cannot be handled properly. Use an inject-code to fix it!";
- result += '?';
+ result += QLatin1Char('?');
}
}
return result;
@@ -627,7 +630,7 @@ QString ShibokenGenerator::getFormatUnitString(const AbstractMetaFunction* func,
QString ShibokenGenerator::cpythonBaseName(const AbstractMetaType* type)
{
if (isCString(type))
- return QString("PyString");
+ return QLatin1String("PyString");
return cpythonBaseName(type->typeEntry());
}
@@ -640,7 +643,7 @@ QString ShibokenGenerator::cpythonBaseName(const TypeEntry* type)
{
QString baseName;
if (ShibokenGenerator::isWrapperType(type) || type->isNamespace()) { // && !type->isReference()) {
- baseName = "Sbk_" + type->name();
+ baseName = QLatin1String("Sbk_") + type->name();
} else if (type->isPrimitive()) {
const PrimitiveTypeEntry* ptype = (const PrimitiveTypeEntry*) type;
while (ptype->basicAliasedTypeEntry())
@@ -666,24 +669,24 @@ QString ShibokenGenerator::cpythonBaseName(const TypeEntry* type)
//break;
case ContainerTypeEntry::PairContainer:
//baseName = "PyTuple";
- baseName = "PySequence";
+ baseName = QLatin1String("PySequence");
break;
case ContainerTypeEntry::SetContainer:
- baseName = "PySet";
+ baseName = QLatin1String("PySet");
break;
case ContainerTypeEntry::MapContainer:
case ContainerTypeEntry::MultiMapContainer:
case ContainerTypeEntry::HashContainer:
case ContainerTypeEntry::MultiHashContainer:
- baseName = "PyDict";
+ baseName = QLatin1String("PyDict");
break;
default:
Q_ASSERT(false);
}
} else {
- baseName = "PyObject";
+ baseName = QLatin1String("PyObject");
}
- return baseName.replace("::", "_");
+ return baseName.replace(QLatin1String("::"), QLatin1String("_"));
}
QString ShibokenGenerator::cpythonTypeName(const AbstractMetaClass* metaClass)
@@ -693,63 +696,67 @@ QString ShibokenGenerator::cpythonTypeName(const AbstractMetaClass* metaClass)
QString ShibokenGenerator::cpythonTypeName(const TypeEntry* type)
{
- return cpythonBaseName(type) + "_Type";
+ return cpythonBaseName(type) + QLatin1String("_Type");
}
QString ShibokenGenerator::cpythonTypeNameExt(const TypeEntry* type)
{
- return cppApiVariableName(type->targetLangPackage()) + '[' + getTypeIndexVariableName(type) + ']';
+ return cppApiVariableName(type->targetLangPackage()) + QLatin1Char('[')
+ + getTypeIndexVariableName(type) + QLatin1Char(']');
}
QString ShibokenGenerator::converterObject(const AbstractMetaType* type)
{
if (isCString(type))
- return "Shiboken::Conversions::PrimitiveTypeConverter<const char*>()";
+ return QLatin1String("Shiboken::Conversions::PrimitiveTypeConverter<const char*>()");
if (isVoidPointer(type))
- return "Shiboken::Conversions::PrimitiveTypeConverter<void*>()";
- if (type->typeEntry()->isContainer())
- return QString("%1[%2]").arg(convertersVariableName(type->typeEntry()->targetLangPackage())).arg(getTypeIndexVariableName(type));
-
+ return QLatin1String("Shiboken::Conversions::PrimitiveTypeConverter<void*>()");
+ if (type->typeEntry()->isContainer()) {
+ return convertersVariableName(type->typeEntry()->targetLangPackage())
+ + QLatin1Char('[') + getTypeIndexVariableName(type) + QLatin1Char(']');
+ }
return converterObject(type->typeEntry());
}
QString ShibokenGenerator::converterObject(const TypeEntry* type)
{
if (isCppPrimitive(type))
- return QString("Shiboken::Conversions::PrimitiveTypeConverter<%1>()").arg(type->qualifiedCppName());
+ return QString::fromLatin1("Shiboken::Conversions::PrimitiveTypeConverter<%1>()").arg(type->qualifiedCppName());
if (isWrapperType(type) || type->isEnum() || type->isFlags())
- return QString("SBK_CONVERTER(%1)").arg(cpythonTypeNameExt(type));
+ return QString::fromLatin1("SBK_CONVERTER(%1)").arg(cpythonTypeNameExt(type));
if (type->isArray()) {
qDebug() << "Warning: no idea how to handle the Qt5 type " << type->qualifiedCppName();
- return 0;
+ return QString::null;
}
/* the typedef'd primitive types case */
const PrimitiveTypeEntry* pte = dynamic_cast<const PrimitiveTypeEntry*>(type);
if (!pte) {
qDebug() << "Warning: the Qt5 primitive type is unknown" << type->qualifiedCppName();
- return 0;
+ return QString::null;
}
if (pte->basicAliasedTypeEntry())
pte = pte->basicAliasedTypeEntry();
if (pte->isPrimitive() && !pte->isCppPrimitive() && !pte->customConversion())
- return QString("Shiboken::Conversions::PrimitiveTypeConverter<%1>()").arg(pte->qualifiedCppName());
+ return QString::fromLatin1("Shiboken::Conversions::PrimitiveTypeConverter<%1>()").arg(pte->qualifiedCppName());
- return QString("%1[%2]").arg(convertersVariableName(type->targetLangPackage())).arg(getTypeIndexVariableName(type));
+ return convertersVariableName(type->targetLangPackage())
+ + QLatin1Char('[') + getTypeIndexVariableName(type) + QLatin1Char(']');
}
QString ShibokenGenerator::cpythonTypeNameExt(const AbstractMetaType* type)
{
- return cppApiVariableName(type->typeEntry()->targetLangPackage()) + '[' + getTypeIndexVariableName(type) + ']';
+ return cppApiVariableName(type->typeEntry()->targetLangPackage()) + QLatin1Char('[')
+ + getTypeIndexVariableName(type) + QLatin1Char(']');
}
QString ShibokenGenerator::cpythonOperatorFunctionName(const AbstractMetaFunction* func)
{
if (!func->isOperatorOverload())
return QString();
- return QString("Sbk") + func->ownerClass()->name()
- + '_' + pythonOperatorFunctionName(func->originalName());
+ return QLatin1String("Sbk") + func->ownerClass()->name()
+ + QLatin1Char('_') + pythonOperatorFunctionName(func->originalName());
}
QString ShibokenGenerator::fixedCppTypeName(const CustomConversion::TargetToNativeConversion* toNative)
@@ -765,21 +772,24 @@ QString ShibokenGenerator::fixedCppTypeName(const AbstractMetaType* type)
static QString _fixedCppTypeName(QString typeName)
{
- return typeName.replace(" ", "")
- .replace(".", "_")
- .replace(",", "_")
- .replace("<", "_")
- .replace(">", "_")
- .replace("::", "_")
- .replace("*", "PTR")
- .replace("&", "REF");
+ typeName.remove(QLatin1Char(' '));
+ typeName.replace(QLatin1Char('.'), QLatin1Char('_'));
+ typeName.replace(QLatin1Char(','), QLatin1Char('_'));
+ typeName.replace(QLatin1Char('<'), QLatin1Char('_'));
+ typeName.replace(QLatin1Char('>'), QLatin1Char('_'));
+ typeName.replace(QLatin1String("::"), QLatin1String("_"));
+ typeName.replace(QLatin1String("*"), QLatin1String("PTR"));
+ typeName.replace(QLatin1String("&"), QLatin1String("REF"));
+ return typeName;
}
QString ShibokenGenerator::fixedCppTypeName(const TypeEntry* type, QString typeName)
{
if (typeName.isEmpty())
typeName = type->qualifiedCppName();
- if (!(type->codeGeneration() & TypeEntry::GenerateTargetLang))
- typeName.prepend(QString("%1_").arg(type->targetLangPackage()));
+ if (!(type->codeGeneration() & TypeEntry::GenerateTargetLang)) {
+ typeName.prepend(QLatin1Char('_'));
+ typeName.prepend(type->targetLangPackage());
+ }
return _fixedCppTypeName(typeName);
}
@@ -811,9 +821,10 @@ QString ShibokenGenerator::pythonOperatorFunctionName(QString cppOpFuncName)
QString value = m_pythonOperators.value(cppOpFuncName);
if (value.isEmpty()) {
qCWarning(lcShiboken).noquote().nospace() << "Unknown operator: " << cppOpFuncName;
- value = "UNKNOWN_OPERATOR";
+ value = QLatin1String("UNKNOWN_OPERATOR");
}
- value.prepend("__").append("__");
+ value.prepend(QLatin1String("__"));
+ value.append(QLatin1String("__"));
return value;
}
@@ -821,21 +832,21 @@ QString ShibokenGenerator::pythonOperatorFunctionName(const AbstractMetaFunction
{
QString op = pythonOperatorFunctionName(func->originalName());
if (func->arguments().isEmpty()) {
- if (op == "__sub__")
- op = QString("__neg__");
- else if (op == "__add__")
- op = QString("__pos__");
+ if (op == QLatin1String("__sub__"))
+ op = QLatin1String("__neg__");
+ else if (op == QLatin1String("__add__"))
+ op = QLatin1String("__pos__");
} else if (func->isStatic() && func->arguments().size() == 2) {
// If a operator overload function has 2 arguments and
// is static we assume that it is a reverse operator.
- op = op.insert(2, 'r');
+ op = op.insert(2, QLatin1Char('r'));
}
return op;
}
QString ShibokenGenerator::pythonRichCompareOperatorId(QString cppOpFuncName)
{
- return QString("Py_%1").arg(m_pythonOperators.value(cppOpFuncName).toUpper());
+ return QLatin1String("Py_") + m_pythonOperators.value(cppOpFuncName).toUpper();
}
QString ShibokenGenerator::pythonRichCompareOperatorId(const AbstractMetaFunction* func)
@@ -845,10 +856,10 @@ QString ShibokenGenerator::pythonRichCompareOperatorId(const AbstractMetaFunctio
bool ShibokenGenerator::isNumber(QString cpythonApiName)
{
- return cpythonApiName == "PyInt"
- || cpythonApiName == "PyFloat"
- || cpythonApiName == "PyLong"
- || cpythonApiName == "PyBool";
+ return cpythonApiName == QLatin1String("PyInt")
+ || cpythonApiName == QLatin1String("PyFloat")
+ || cpythonApiName == QLatin1String("PyLong")
+ || cpythonApiName == QLatin1String("PyBool");
}
bool ShibokenGenerator::isNumber(const TypeEntry* type)
@@ -867,7 +878,7 @@ bool ShibokenGenerator::isPyInt(const TypeEntry* type)
{
if (!type->isPrimitive())
return false;
- return pythonPrimitiveTypeName((const PrimitiveTypeEntry*) type) == "PyInt";
+ return pythonPrimitiveTypeName((const PrimitiveTypeEntry*) type) == QLatin1String("PyInt");
}
bool ShibokenGenerator::isPyInt(const AbstractMetaType* type)
@@ -938,7 +949,8 @@ bool ShibokenGenerator::isUserPrimitive(const TypeEntry* type)
const PrimitiveTypeEntry* trueType = (const PrimitiveTypeEntry*) type;
if (trueType->basicAliasedTypeEntry())
trueType = trueType->basicAliasedTypeEntry();
- return trueType->isPrimitive() && !trueType->isCppPrimitive() && trueType->qualifiedCppName() != "std::string";
+ return trueType->isPrimitive() && !trueType->isCppPrimitive()
+ && trueType->qualifiedCppName() != QLatin1String("std::string");
}
bool ShibokenGenerator::isUserPrimitive(const AbstractMetaType* type)
@@ -957,7 +969,7 @@ bool ShibokenGenerator::isCppPrimitive(const TypeEntry* type)
const PrimitiveTypeEntry* trueType = (const PrimitiveTypeEntry*) type;
if (trueType->basicAliasedTypeEntry())
trueType = trueType->basicAliasedTypeEntry();
- return trueType->qualifiedCppName() == "std::string";
+ return trueType->qualifiedCppName() == QLatin1String("std::string");
}
bool ShibokenGenerator::isCppPrimitive(const AbstractMetaType* type)
@@ -1002,12 +1014,12 @@ QString ShibokenGenerator::cpythonCheckFunction(const AbstractMetaType* metaType
if (isCppPrimitive(metaType)) {
if (isCString(metaType))
- return "Shiboken::String::check";
+ return QLatin1String("Shiboken::String::check");
if (isVoidPointer(metaType))
- return "PyObject_Check";
+ return QLatin1String("PyObject_Check");
return cpythonCheckFunction(metaType->typeEntry(), genericNumberType);
} else if (metaType->typeEntry()->isContainer()) {
- QString typeCheck = "Shiboken::Conversions::";
+ QString typeCheck = QLatin1String("Shiboken::Conversions::");
ContainerTypeEntry::Type type = ((const ContainerTypeEntry*)metaType->typeEntry())->type();
if (type == ContainerTypeEntry::ListContainer
|| type == ContainerTypeEntry::StringListContainer
@@ -1018,29 +1030,28 @@ QString ShibokenGenerator::cpythonCheckFunction(const AbstractMetaType* metaType
|| type == ContainerTypeEntry::QueueContainer) {
const AbstractMetaType* type = metaType->instantiations().first();
if (isPointerToWrapperType(type))
- typeCheck += QString("checkSequenceTypes(%1, ").arg(cpythonTypeNameExt(type));
+ typeCheck += QString::fromLatin1("checkSequenceTypes(%1, ").arg(cpythonTypeNameExt(type));
else if (isWrapperType(type))
- typeCheck += QString("convertibleSequenceTypes((SbkObjectType*)%1, ").arg(cpythonTypeNameExt(type));
+ typeCheck += QString::fromLatin1("convertibleSequenceTypes((SbkObjectType*)%1, ").arg(cpythonTypeNameExt(type));
else
- typeCheck += QString("convertibleSequenceTypes(%1, ").arg(converterObject(type));
+ typeCheck += QString::fromLatin1("convertibleSequenceTypes(%1, ").arg(converterObject(type));
} else if (type == ContainerTypeEntry::MapContainer
|| type == ContainerTypeEntry::MultiMapContainer
|| type == ContainerTypeEntry::HashContainer
|| type == ContainerTypeEntry::MultiHashContainer
|| type == ContainerTypeEntry::PairContainer) {
- QString pyType = (type == ContainerTypeEntry::PairContainer) ? "Pair" : "Dict";
+ QString pyType = (type == ContainerTypeEntry::PairContainer) ? QLatin1String("Pair") : QLatin1String("Dict");
const AbstractMetaType* firstType = metaType->instantiations().first();
const AbstractMetaType* secondType = metaType->instantiations().last();
if (isPointerToWrapperType(firstType) && isPointerToWrapperType(secondType)) {
- typeCheck += QString("check%1Types(%2, %3, ").arg(pyType)
- .arg(cpythonTypeNameExt(firstType))
- .arg(cpythonTypeNameExt(secondType));
+ typeCheck += QString::fromLatin1("check%1Types(%2, %3, ").arg(pyType)
+ .arg(cpythonTypeNameExt(firstType), cpythonTypeNameExt(secondType));
} else {
- typeCheck += QString("convertible%1Types(%2, %3, %4, %5, ").arg(pyType)
- .arg(converterObject(firstType))
- .arg(isPointerToWrapperType(firstType) ? "true" : "false")
- .arg(converterObject(secondType))
- .arg(isPointerToWrapperType(secondType) ? "true" : "false");
+ typeCheck += QString::fromLatin1("convertible%1Types(%2, %3, %4, %5, ")
+ .arg(pyType, converterObject(firstType),
+ isPointerToWrapperType(firstType) ? QLatin1String("true") : QLatin1String("false"),
+ converterObject(secondType),
+ isPointerToWrapperType(secondType) ? QLatin1String("true") : QLatin1String("false"));
}
}
return typeCheck;
@@ -1060,60 +1071,60 @@ QString ShibokenGenerator::cpythonCheckFunction(const TypeEntry* type, bool gene
}
if (type->isEnum() || type->isFlags() || isWrapperType(type))
- return QString("SbkObject_TypeCheck(%1, ").arg(cpythonTypeNameExt(type));
+ return QString::fromLatin1("SbkObject_TypeCheck(%1, ").arg(cpythonTypeNameExt(type));
else if (isCppPrimitive(type))
- return QString("%1_Check").arg(pythonPrimitiveTypeName((const PrimitiveTypeEntry*)type));
+ return pythonPrimitiveTypeName((const PrimitiveTypeEntry*)type) + QLatin1String("_Check");
QString typeCheck;
if (type->targetLangApiName() == type->name())
typeCheck = cpythonIsConvertibleFunction(type);
- else if (type->targetLangApiName() == "PyUnicode")
- typeCheck = "Shiboken::String::check";
+ else if (type->targetLangApiName() == QLatin1String("PyUnicode"))
+ typeCheck = QLatin1String("Shiboken::String::check");
else
- typeCheck = QString("%1_Check").arg(type->targetLangApiName());
+ typeCheck = type->targetLangApiName() + QLatin1String("_Check");
return typeCheck;
}
QString ShibokenGenerator::guessCPythonCheckFunction(const QString& type, AbstractMetaType** metaType)
{
*metaType = 0;
- if (type == "PyTypeObject")
- return "PyType_Check";
+ if (type == QLatin1String("PyTypeObject"))
+ return QLatin1String("PyType_Check");
- if (type == "PyBuffer")
- return "Shiboken::Buffer::checkType";
+ if (type == QLatin1String("PyBuffer"))
+ return QLatin1String("Shiboken::Buffer::checkType");
- if (type == "str")
- return "Shiboken::String::check";
+ if (type == QLatin1String("str"))
+ return QLatin1String("Shiboken::String::check");
*metaType = buildAbstractMetaTypeFromString(type);
if (*metaType && !(*metaType)->typeEntry()->isCustom())
return QString();
- return QString("%1_Check").arg(type);
+ return type + QLatin1String("_Check");
}
QString ShibokenGenerator::guessCPythonIsConvertible(const QString& type)
{
- if (type == "PyTypeObject")
- return "PyType_Check";
+ if (type == QLatin1String("PyTypeObject"))
+ return QLatin1String("PyType_Check");
AbstractMetaType* metaType = buildAbstractMetaTypeFromString(type);
if (metaType && !metaType->typeEntry()->isCustom())
return cpythonIsConvertibleFunction(metaType);
- return QString("%1_Check").arg(type);
+ return type + QLatin1String("_Check");
}
QString ShibokenGenerator::cpythonIsConvertibleFunction(const TypeEntry* type, bool genericNumberType, bool checkExact)
{
if (isWrapperType(type)) {
QString isConv = (type->isValue() && !isValueTypeWithCopyConstructorOnly(type))
- ? "isPythonToCppValueConvertible"
- : "isPythonToCppPointerConvertible";
- return QString("Shiboken::Conversions::%1((SbkObjectType*)%2, ")
- .arg(isConv).arg(cpythonTypeNameExt(type));
+ ? QLatin1String("isPythonToCppValueConvertible")
+ : QLatin1String("isPythonToCppPointerConvertible");
+ return QString::fromLatin1("Shiboken::Conversions::%1((SbkObjectType*)%2, ")
+ .arg(isConv, cpythonTypeNameExt(type));
}
- return QString("Shiboken::Conversions::isPythonToCppConvertible(%1, ")
+ return QString::fromLatin1("Shiboken::Conversions::isPythonToCppConvertible(%1, ")
.arg(converterObject(type));
}
QString ShibokenGenerator::cpythonIsConvertibleFunction(const AbstractMetaType* metaType, bool genericNumberType)
@@ -1131,31 +1142,31 @@ QString ShibokenGenerator::cpythonIsConvertibleFunction(const AbstractMetaType*
if (isWrapperType(metaType)) {
QString isConv;
if (isPointer(metaType) || isValueTypeWithCopyConstructorOnly(metaType))
- isConv = "isPythonToCppPointerConvertible";
+ isConv = QLatin1String("isPythonToCppPointerConvertible");
else if (metaType->isReference())
- isConv = "isPythonToCppReferenceConvertible";
+ isConv = QLatin1String("isPythonToCppReferenceConvertible");
else
- isConv = "isPythonToCppValueConvertible";
- return QString("Shiboken::Conversions::%1((SbkObjectType*)%2, ")
- .arg(isConv).arg(cpythonTypeNameExt(metaType));
+ isConv = QLatin1String("isPythonToCppValueConvertible");
+ return QStringLiteral("Shiboken::Conversions::%1((SbkObjectType*)%2, ")
+ .arg(isConv, cpythonTypeNameExt(metaType));
}
- return QString("Shiboken::Conversions::isPythonToCppConvertible(%1, ")
+ return QStringLiteral("Shiboken::Conversions::isPythonToCppConvertible(%1, ")
.arg(converterObject(metaType));
}
QString ShibokenGenerator::cpythonToCppConversionFunction(const AbstractMetaClass* metaClass)
{
- return QString("Shiboken::Conversions::pythonToCppPointer((SbkObjectType*)%1, ")
+ return QStringLiteral("Shiboken::Conversions::pythonToCppPointer((SbkObjectType*)%1, ")
.arg(cpythonTypeNameExt(metaClass->typeEntry()));
}
QString ShibokenGenerator::cpythonToCppConversionFunction(const AbstractMetaType* type, const AbstractMetaClass* context)
{
if (isWrapperType(type)) {
- return QString("Shiboken::Conversions::pythonToCpp%1((SbkObjectType*)%2, ")
- .arg(isPointer(type) ? "Pointer" : "Copy")
+ return QStringLiteral("Shiboken::Conversions::pythonToCpp%1((SbkObjectType*)%2, ")
+ .arg(isPointer(type) ? QLatin1String("Pointer") : QLatin1String("Copy"))
.arg(cpythonTypeNameExt(type));
}
- return QString("Shiboken::Conversions::pythonToCppCopy(%1, ")
+ return QStringLiteral("Shiboken::Conversions::pythonToCppCopy(%1, ")
.arg(converterObject(type));
}
@@ -1164,17 +1175,18 @@ QString ShibokenGenerator::cpythonToPythonConversionFunction(const AbstractMetaT
if (isWrapperType(type)) {
QString conversion;
if (type->isReference() && !(type->isValue() && type->isConstant()) && !isPointer(type))
- conversion = "reference";
+ conversion = QLatin1String("reference");
else if (type->isValue())
- conversion = "copy";
+ conversion = QLatin1String("copy");
else
- conversion = "pointer";
- return QString("Shiboken::Conversions::%1ToPython((SbkObjectType*)%2, %3")
- .arg(conversion).arg(cpythonTypeNameExt(type)).arg(conversion == "pointer" ? "" : "&");
+ conversion = QLatin1String("pointer");
+ return QStringLiteral("Shiboken::Conversions::%1ToPython((SbkObjectType*)%2, %3")
+ .arg(conversion, cpythonTypeNameExt(type),
+ conversion == QLatin1String("pointer") ? QString() : QLatin1String("&"));
}
- return QString("Shiboken::Conversions::copyToPython(%1, %2")
- .arg(converterObject(type))
- .arg((isCString(type) || isVoidPointer(type)) ? "" : "&");
+ return QStringLiteral("Shiboken::Conversions::copyToPython(%1, %2")
+ .arg(converterObject(type),
+ (isCString(type) || isVoidPointer(type)) ? QString() : QLatin1String("&"));
}
QString ShibokenGenerator::cpythonToPythonConversionFunction(const AbstractMetaClass* metaClass)
@@ -1187,14 +1199,15 @@ QString ShibokenGenerator::cpythonToPythonConversionFunction(const TypeEntry* ty
if (isWrapperType(type)) {
QString conversion;
if (type->isValue())
- conversion = "copy";
+ conversion = QLatin1String("copy");
else
- conversion = "pointer";
- return QString("Shiboken::Conversions::%1ToPython((SbkObjectType*)%2, %3")
- .arg(conversion).arg(cpythonTypeNameExt(type)).arg(conversion == "pointer" ? "" : "&");
+ conversion = QLatin1String("pointer");
+ return QStringLiteral("Shiboken::Conversions::%1ToPython((SbkObjectType*)%2, %3")
+ .arg(conversion, cpythonTypeNameExt(type),
+ conversion == QLatin1String("pointer") ? QString() : QLatin1String("&"));
}
- return QString("Shiboken::Conversions::copyToPython(%1, &").arg(converterObject(type));
+ return QStringLiteral("Shiboken::Conversions::copyToPython(%1, &").arg(converterObject(type));
}
QString ShibokenGenerator::argumentString(const AbstractMetaFunction *func,
@@ -1209,10 +1222,10 @@ QString ShibokenGenerator::argumentString(const AbstractMetaFunction *func,
if (modified_type.isEmpty())
arg = translateType(argument->type(), func->implementingClass(), options);
else
- arg = modified_type.replace('$', '.');
+ arg = modified_type.replace(QLatin1Char('$'), QLatin1Char('.'));
if (!(options & Generator::SkipName)) {
- arg += " ";
+ arg += QLatin1Char(' ');
arg += argument->name();
}
@@ -1222,14 +1235,14 @@ QString ShibokenGenerator::argumentString(const AbstractMetaFunction *func,
!argument->originalDefaultValueExpression().isEmpty())
{
QString default_value = argument->originalDefaultValueExpression();
- if (default_value == "NULL")
- default_value = NULL_VALUE;
+ if (default_value == QLatin1String("NULL"))
+ default_value = QLatin1String(NULL_VALUE);
//WORKAROUND: fix this please
- if (default_value.startsWith("new "))
+ if (default_value.startsWith(QLatin1String("new ")))
default_value.remove(0, 4);
- arg += " = " + default_value;
+ arg += QLatin1String(" = ") + default_value;
}
return arg;
@@ -1402,21 +1415,21 @@ static QString getArgumentsFromMethodCall(const QString& str)
// to count the parenthesis.
// For more information check this:
// http://perl.plover.com/yak/regex/samples/slide083.html
- static QString funcCall("%CPPSELF.%FUNCTION_NAME");
+ static QLatin1String funcCall("%CPPSELF.%FUNCTION_NAME");
int pos = str.indexOf(funcCall);
if (pos == -1)
return QString();
- pos = pos + funcCall.count();
- while (str.at(pos) == ' ' || str.at(pos) == '\t')
+ pos = pos + funcCall.size();
+ while (str.at(pos) == QLatin1Char(' ') || str.at(pos) == QLatin1Char('\t'))
++pos;
- if (str.at(pos) == '(')
+ if (str.at(pos) == QLatin1Char('('))
++pos;
int begin = pos;
int counter = 1;
while (counter != 0) {
- if (str.at(pos) == '(')
+ if (str.at(pos) == QLatin1Char('('))
++counter;
- else if (str.at(pos) == ')')
+ else if (str.at(pos) == QLatin1Char(')'))
--counter;
++pos;
}
@@ -1444,9 +1457,10 @@ void ShibokenGenerator::processCodeSnip(QString& code, const AbstractMetaClass*
if (context) {
// Replace template variable by the Python Type object
// for the class context in which the variable is used.
- code.replace("%PYTHONTYPEOBJECT", cpythonTypeName(context) + ".super.ht_type");
- code.replace("%TYPE", wrapperName(context));
- code.replace("%CPPTYPE", context->name());
+ code.replace(QLatin1String("%PYTHONTYPEOBJECT"),
+ cpythonTypeName(context) + QLatin1String(".super.ht_type"));
+ code.replace(QLatin1String("%TYPE"), wrapperName(context));
+ code.replace(QLatin1String("%CPPTYPE"), context->name());
}
// replace "toPython" converters
@@ -1478,9 +1492,9 @@ ShibokenGenerator::ArgumentVarReplacementList ShibokenGenerator::getArgumentRepl
bool argRemoved = func->argumentRemoved(i+1);
removed = removed + (int) argRemoved;
if (argRemoved && hasConversionRule)
- argValue = QString("%1" CONV_RULE_OUT_VAR_SUFFIX).arg(arg->name());
+ argValue = arg->name() + QLatin1String(CONV_RULE_OUT_VAR_SUFFIX);
else if (argRemoved || (lastArg && arg->argumentIndex() > lastArg->argumentIndex()))
- argValue = QString(CPP_ARG_REMOVED "%1").arg(i);
+ argValue = QLatin1String(CPP_ARG_REMOVED) + QString::number(i);
if (!argRemoved && argValue.isEmpty()) {
int argPos = i - removed;
const AbstractMetaType* type = arg->type();
@@ -1491,14 +1505,16 @@ ShibokenGenerator::ArgumentVarReplacementList ShibokenGenerator::getArgumentRepl
type = builtType;
}
if (type->typeEntry()->isCustom()) {
- argValue = usePyArgs ? QString(PYTHON_ARGS "[%1]").arg(argPos) : PYTHON_ARG;
+ argValue = usePyArgs
+ ? QString::fromLatin1(PYTHON_ARGS "[%1]").arg(argPos)
+ : QLatin1String(PYTHON_ARG);
} else {
argValue = hasConversionRule
- ? QString("%1" CONV_RULE_OUT_VAR_SUFFIX).arg(arg->name())
- : QString(CPP_ARG "%1").arg(argPos);
+ ? arg->name() + QLatin1String(CONV_RULE_OUT_VAR_SUFFIX)
+ : QLatin1String(CPP_ARG) + QString::number(argPos);
if (isWrapperType(type)) {
if (type->isReference() && !isPointer(type))
- argValue.prepend('*');
+ argValue.prepend(QLatin1Char('*'));
}
}
}
@@ -1549,38 +1565,38 @@ void ShibokenGenerator::writeCodeSnips(QTextStream& s,
bool usePyArgs = pythonFunctionWrapperUsesListOfArguments(od);
// Replace %PYARG_# variables.
- code.replace("%PYARG_0", PYTHON_RETURN_VAR);
+ code.replace(QLatin1String("%PYARG_0"), QLatin1String(PYTHON_RETURN_VAR));
- static QRegExp pyArgsRegex("%PYARG_(\\d+)");
+ static QRegExp pyArgsRegex(QLatin1String("%PYARG_(\\d+)"));
if (language == TypeSystem::TargetLangCode) {
if (usePyArgs) {
- code.replace(pyArgsRegex, PYTHON_ARGS"[\\1-1]");
+ code.replace(pyArgsRegex, QLatin1String(PYTHON_ARGS"[\\1-1]"));
} else {
- static QRegExp pyArgsRegexCheck("%PYARG_([2-9]+)");
+ static QRegExp pyArgsRegexCheck(QLatin1String("%PYARG_([2-9]+)"));
if (pyArgsRegexCheck.indexIn(code) != -1) {
qCWarning(lcShiboken).noquote().nospace()
<< "Wrong index for %PYARG variable (" << pyArgsRegexCheck.cap(1) << ") on " << func->signature();
return;
}
- code.replace("%PYARG_1", PYTHON_ARG);
+ code.replace(QLatin1String("%PYARG_1"), QLatin1String(PYTHON_ARG));
}
} else {
// Replaces the simplest case of attribution to a
// Python argument on the binding virtual method.
- static QRegExp pyArgsAttributionRegex("%PYARG_(\\d+)\\s*=[^=]\\s*([^;]+)");
- code.replace(pyArgsAttributionRegex, "PyTuple_SET_ITEM(" PYTHON_ARGS ", \\1-1, \\2)");
- code.replace(pyArgsRegex, "PyTuple_GET_ITEM(" PYTHON_ARGS ", \\1-1)");
+ static QRegExp pyArgsAttributionRegex(QLatin1String("%PYARG_(\\d+)\\s*=[^=]\\s*([^;]+)"));
+ code.replace(pyArgsAttributionRegex, QLatin1String("PyTuple_SET_ITEM(" PYTHON_ARGS ", \\1-1, \\2)"));
+ code.replace(pyArgsRegex, QLatin1String("PyTuple_GET_ITEM(" PYTHON_ARGS ", \\1-1)"));
}
// Replace %ARG#_TYPE variables.
foreach (const AbstractMetaArgument* arg, func->arguments()) {
- QString argTypeVar = QString("%ARG%1_TYPE").arg(arg->argumentIndex() + 1);
+ QString argTypeVar = QStringLiteral("%ARG%1_TYPE").arg(arg->argumentIndex() + 1);
QString argTypeVal = arg->type()->cppSignature();
code.replace(argTypeVar, argTypeVal);
}
int pos = 0;
- static QRegExp cppArgTypeRegexCheck("%ARG(\\d+)_TYPE");
+ static QRegExp cppArgTypeRegexCheck(QLatin1String("%ARG(\\d+)_TYPE"));
while ((pos = cppArgTypeRegexCheck.indexIn(code, pos)) != -1) {
qCWarning(lcShiboken).noquote().nospace()
<< "Wrong index for %ARG#_TYPE variable (" << cppArgTypeRegexCheck.cap(1)
@@ -1590,60 +1606,64 @@ void ShibokenGenerator::writeCodeSnips(QTextStream& s,
// Replace template variable for return variable name.
if (func->isConstructor()) {
- code.replace("%0.", QString("%1->").arg("cptr"));
- code.replace("%0", "cptr");
+ code.replace(QLatin1String("%0."), QLatin1String("cptr->"));
+ code.replace(QLatin1String("%0"), QLatin1String("cptr"));
} else if (func->type()) {
- QString returnValueOp = isPointerToWrapperType(func->type()) ? "%1->" : "%1.";
+ QString returnValueOp = isPointerToWrapperType(func->type())
+ ? QLatin1String("%1->") : QLatin1String("%1.");
if (ShibokenGenerator::isWrapperType(func->type()))
- code.replace("%0.", returnValueOp.arg(CPP_RETURN_VAR));
- code.replace("%0", CPP_RETURN_VAR);
+ code.replace(QLatin1String("%0."), returnValueOp.arg(QLatin1String(CPP_RETURN_VAR)));
+ code.replace(QLatin1String("%0"), QLatin1String(CPP_RETURN_VAR));
}
// Replace template variable for self Python object.
- QString pySelf = (language == TypeSystem::NativeCode) ? "pySelf" : PYTHON_SELF_VAR;
- code.replace("%PYSELF", pySelf);
+ QString pySelf = (language == TypeSystem::NativeCode) ? QLatin1String("pySelf") : QLatin1String(PYTHON_SELF_VAR);
+ code.replace(QLatin1String("%PYSELF"), pySelf);
// Replace template variable for a pointer to C++ of this object.
if (func->implementingClass()) {
- QString replacement = func->isStatic() ? "%1::" : "%1->";
+ QString replacement = func->isStatic() ? QLatin1String("%1::") : QLatin1String("%1->");
QString cppSelf;
if (func->isStatic())
cppSelf = func->ownerClass()->qualifiedCppName();
else if (language == TypeSystem::NativeCode)
- cppSelf = "this";
+ cppSelf = QLatin1String("this");
else
- cppSelf = CPP_SELF_VAR;
+ cppSelf = QLatin1String(CPP_SELF_VAR);
// On comparison operator CPP_SELF_VAR is always a reference.
if (func->isComparisonOperator())
- replacement = "%1.";
+ replacement = QLatin1String("%1.");
if (func->isVirtual() && !func->isAbstract() && (!avoidProtectedHack() || !func->isProtected())) {
QString methodCallArgs = getArgumentsFromMethodCall(code);
if (!methodCallArgs.isNull()) {
- if (func->name() == "metaObject") {
+ const QString pattern = QStringLiteral("%CPPSELF.%FUNCTION_NAME(%1)").arg(methodCallArgs);
+ if (func->name() == QLatin1String("metaObject")) {
QString wrapperClassName = wrapperName(func->ownerClass());
- QString cppSelfVar = avoidProtectedHack() ? QString("%CPPSELF") : QString("reinterpret_cast<%1*>(%CPPSELF)").arg(wrapperClassName);
- code.replace(QString("%CPPSELF.%FUNCTION_NAME(%1)").arg(methodCallArgs),
- QString("(Shiboken::Object::hasCppWrapper(reinterpret_cast<SbkObject*>(%1))"
+ QString cppSelfVar = avoidProtectedHack()
+ ? QLatin1String("%CPPSELF")
+ : QStringLiteral("reinterpret_cast<%1*>(%CPPSELF)").arg(wrapperClassName);
+ code.replace(pattern,
+ QString::fromLatin1("(Shiboken::Object::hasCppWrapper(reinterpret_cast<SbkObject*>(%1))"
" ? %2->::%3::%FUNCTION_NAME(%4)"
- " : %CPPSELF.%FUNCTION_NAME(%4))").arg(pySelf).arg(cppSelfVar).arg(wrapperClassName).arg(methodCallArgs));
+ " : %CPPSELF.%FUNCTION_NAME(%4))").arg(pySelf, cppSelfVar, wrapperClassName, methodCallArgs));
} else {
- code.replace(QString("%CPPSELF.%FUNCTION_NAME(%1)").arg(methodCallArgs),
- QString("(Shiboken::Object::hasCppWrapper(reinterpret_cast<SbkObject*>(%1))"
+ code.replace(pattern,
+ QString::fromLatin1("(Shiboken::Object::hasCppWrapper(reinterpret_cast<SbkObject*>(%1))"
" ? %CPPSELF->::%TYPE::%FUNCTION_NAME(%2)"
- " : %CPPSELF.%FUNCTION_NAME(%2))").arg(pySelf).arg(methodCallArgs));
+ " : %CPPSELF.%FUNCTION_NAME(%2))").arg(pySelf, methodCallArgs));
}
}
}
- code.replace("%CPPSELF.", replacement.arg(cppSelf));
- code.replace("%CPPSELF", cppSelf);
+ code.replace(QLatin1String("%CPPSELF."), replacement.arg(cppSelf));
+ code.replace(QLatin1String("%CPPSELF"), cppSelf);
- if (code.indexOf("%BEGIN_ALLOW_THREADS") > -1) {
- if (code.count("%BEGIN_ALLOW_THREADS") == code.count("%END_ALLOW_THREADS")) {
- code.replace("%BEGIN_ALLOW_THREADS", BEGIN_ALLOW_THREADS);
- code.replace("%END_ALLOW_THREADS", END_ALLOW_THREADS);
+ if (code.indexOf(QLatin1String("%BEGIN_ALLOW_THREADS")) > -1) {
+ if (code.count(QLatin1String("%BEGIN_ALLOW_THREADS")) == code.count(QLatin1String("%END_ALLOW_THREADS"))) {
+ code.replace(QLatin1String("%BEGIN_ALLOW_THREADS"), QLatin1String(BEGIN_ALLOW_THREADS));
+ code.replace(QLatin1String("%END_ALLOW_THREADS"), QLatin1String(END_ALLOW_THREADS));
} else {
qCWarning(lcShiboken) << "%BEGIN_ALLOW_THREADS and %END_ALLOW_THREADS mismatch";
}
@@ -1652,10 +1672,11 @@ void ShibokenGenerator::writeCodeSnips(QTextStream& s,
// replace template variable for the Python Type object for the
// class implementing the method in which the code snip is written
if (func->isStatic()) {
- code.replace("%PYTHONTYPEOBJECT", cpythonTypeName(func->implementingClass()) + ".super.ht_type");
+ code.replace(QLatin1String("%PYTHONTYPEOBJECT"),
+ cpythonTypeName(func->implementingClass()) + QLatin1String(".super.ht_type"));
} else {
- code.replace("%PYTHONTYPEOBJECT.", QString("%1->ob_type->").arg(pySelf));
- code.replace("%PYTHONTYPEOBJECT", QString("%1->ob_type").arg(pySelf));
+ code.replace(QLatin1String("%PYTHONTYPEOBJECT."), pySelf + QLatin1String("->ob_type->"));
+ code.replace(QLatin1String("%PYTHONTYPEOBJECT"), pySelf + QLatin1String("->ob_type"));
}
}
@@ -1665,11 +1686,11 @@ void ShibokenGenerator::writeCodeSnips(QTextStream& s,
QStringList args;
foreach (ArgumentVarReplacementPair pair, argReplacements) {
- if (pair.second.startsWith(CPP_ARG_REMOVED))
+ if (pair.second.startsWith(QLatin1String(CPP_ARG_REMOVED)))
continue;
args << pair.second;
}
- code.replace("%ARGUMENT_NAMES", args.join(", "));
+ code.replace(QLatin1String("%ARGUMENT_NAMES"), args.join(QLatin1String(", ")));
foreach (ArgumentVarReplacementPair pair, argReplacements) {
const AbstractMetaArgument* arg = pair.first;
@@ -1686,20 +1707,20 @@ void ShibokenGenerator::writeCodeSnips(QTextStream& s,
if (type->isReference() && !isPointer(type))
replacement.remove(0, 1);
if (type->isReference() || isPointer(type))
- code.replace(QString("%%1.").arg(idx), QString("%1->").arg(replacement));
+ code.replace(QString::fromLatin1("%%1.").arg(idx), replacement + QLatin1String("->"));
}
- code.replace(QRegExp(QString("%%1\\b").arg(idx)), pair.second);
+ code.replace(QRegExp(QString::fromLatin1("%%1\\b").arg(idx)), pair.second);
}
if (language == TypeSystem::NativeCode) {
// Replaces template %PYTHON_ARGUMENTS variable with a pointer to the Python tuple
// containing the converted virtual method arguments received from C++ to be passed
// to the Python override.
- code.replace("%PYTHON_ARGUMENTS", PYTHON_ARGS);
+ code.replace(QLatin1String("%PYTHON_ARGUMENTS"), QLatin1String(PYTHON_ARGS));
// replace variable %PYTHON_METHOD_OVERRIDE for a pointer to the Python method
// override for the C++ virtual method in which this piece of code was inserted
- code.replace("%PYTHON_METHOD_OVERRIDE", PYTHON_OVERRIDE_VAR);
+ code.replace(QLatin1String("%PYTHON_METHOD_OVERRIDE"), QLatin1String(PYTHON_OVERRIDE_VAR));
}
if (avoidProtectedHack()) {
@@ -1715,19 +1736,19 @@ void ShibokenGenerator::writeCodeSnips(QTextStream& s,
}
if (func->isProtected() || hasProtectedOverload) {
- code.replace("%TYPE::%FUNCTION_NAME",
- QString("%1::%2_protected")
- .arg(wrapperName(func->ownerClass()))
- .arg(func->originalName()));
- code.replace("%FUNCTION_NAME", QString("%1_protected").arg(func->originalName()));
+ code.replace(QLatin1String("%TYPE::%FUNCTION_NAME"),
+ QStringLiteral("%1::%2_protected")
+ .arg(wrapperName(func->ownerClass()), func->originalName()));
+ code.replace(QLatin1String("%FUNCTION_NAME"),
+ func->originalName() + QLatin1String("_protected"));
}
}
if (func->isConstructor() && shouldGenerateCppWrapper(func->ownerClass()))
- code.replace("%TYPE", wrapperName(func->ownerClass()));
+ code.replace(QLatin1String("%TYPE"), wrapperName(func->ownerClass()));
if (func->ownerClass())
- code.replace("%CPPTYPE", func->ownerClass()->name());
+ code.replace(QLatin1String("%CPPTYPE"), func->ownerClass()->name());
replaceTemplateVariables(code, func);
@@ -1741,7 +1762,7 @@ void ShibokenGenerator::writeCodeSnips(QTextStream& s,
// and false if it is a variable.
static bool isVariable(const QString& code)
{
- static QRegExp expr("\\s*\\*?\\s*[A-Za-z_][A-Za-z_0-9.]*\\s*(?:\\[[^\\[]+\\])*");
+ static QRegExp expr(QLatin1String("\\s*\\*?\\s*[A-Za-z_][A-Za-z_0-9.]*\\s*(?:\\[[^\\[]+\\])*"));
return expr.exactMatch(code.trimmed());
}
@@ -1753,15 +1774,16 @@ static QString miniNormalizer(const QString& varType)
QString normalized = varType.trimmed();
if (normalized.isEmpty())
return normalized;
- if (normalized.startsWith("::"))
+ if (normalized.startsWith(QLatin1String("::")))
normalized.remove(0, 2);
QString suffix;
- while (normalized.endsWith('*') || normalized.endsWith('&')) {
+ while (normalized.endsWith(QLatin1Char('*')) || normalized.endsWith(QLatin1Char('&'))) {
suffix.prepend(normalized.at(normalized.count() - 1));
normalized.chop(1);
normalized = normalized.trimmed();
}
- return QString("%1 %2").arg(normalized).arg(suffix).trimmed();
+ const QString result = normalized + QLatin1Char(' ') + suffix;
+ return result.trimmed();
}
// The position must indicate the first character after the opening '('.
// ATTENTION: do not modify this function to trim any resulting string!
@@ -1801,7 +1823,7 @@ void ShibokenGenerator::replaceConverterTypeSystemVariable(TypeSystemConverterVa
QString conversionTypeName = list.last();
const AbstractMetaType* conversionType = buildAbstractMetaTypeFromString(conversionTypeName);
if (!conversionType) {
- qFatal(qPrintable(QString("Could not find type '%1' for use in '%2' conversion. "
+ qFatal(qPrintable(QString::fromLatin1("Could not find type '%1' for use in '%2' conversion. "
"Make sure to use the full C++ name, e.g. 'Namespace::Class'.")
.arg(conversionTypeName).arg(m_typeSystemConvName[converterVariable])), NULL);
@@ -1812,7 +1834,7 @@ void ShibokenGenerator::replaceConverterTypeSystemVariable(TypeSystemConverterVa
case TypeSystemToCppFunction: {
int end = pos - list.first().count();
int start = end;
- while (start > 0 && code.at(start) != '\n')
+ while (start > 0 && code.at(start) != QLatin1Char('\n'))
--start;
while (code.at(start).isSpace())
++start;
@@ -1822,8 +1844,8 @@ void ShibokenGenerator::replaceConverterTypeSystemVariable(TypeSystemConverterVa
QString varName = list.at(1).trimmed();
if (!varType.isEmpty()) {
if (varType != conversionType->cppSignature()) {
- qFatal(qPrintable(QString("Types of receiver variable ('%1') and %CONVERTTOCPP type system variable ('%2') differ.")
- .arg(varType).arg(conversionType->cppSignature())), NULL);
+ qFatal(qPrintable(QString::fromLatin1("Types of receiver variable ('%1') and %CONVERTTOCPP type system variable ('%2') differ.")
+ .arg(varType, conversionType->cppSignature())), NULL);
}
c << getFullTypeName(conversionType) << ' ' << varName;
writeMinimalConstructorExpression(c, conversionType);
@@ -1833,11 +1855,11 @@ void ShibokenGenerator::replaceConverterTypeSystemVariable(TypeSystemConverterVa
}
c << cpythonToCppConversionFunction(conversionType);
QString prefix;
- if (varName.startsWith('*')) {
+ if (varName.startsWith(QLatin1Char('*'))) {
varName.remove(0, 1);
varName = varName.trimmed();
} else {
- prefix = '&';
+ prefix = QLatin1Char('&');
}
QString arg = getConverterTypeSystemVariableArgument(code, pos);
conversionString += arg;
@@ -1846,7 +1868,9 @@ void ShibokenGenerator::replaceConverterTypeSystemVariable(TypeSystemConverterVa
}
case TypeSystemCheckFunction:
conversion = cpythonCheckFunction(conversionType);
- if (conversionType->typeEntry()->isPrimitive() && (conversionType->typeEntry()->name() == "PyObject" || !conversion.endsWith(' '))) {
+ if (conversionType->typeEntry()->isPrimitive()
+ && (conversionType->typeEntry()->name() == QLatin1String("PyObject")
+ || !conversion.endsWith(QLatin1Char(' ')))) {
c << '(';
break;
}
@@ -1860,12 +1884,12 @@ void ShibokenGenerator::replaceConverterTypeSystemVariable(TypeSystemConverterVa
QString arg = getConverterTypeSystemVariableArgument(code, pos);
conversionString += arg;
if (converterVariable == TypeSystemToPythonFunction && !isVariable(arg)) {
- qFatal(qPrintable(QString("Only variables are acceptable as argument to %%CONVERTTOPYTHON type system variable on code snippet: '%1'")
+ qFatal(qPrintable(QString::fromLatin1("Only variables are acceptable as argument to %%CONVERTTOPYTHON type system variable on code snippet: '%1'")
.arg(code)), NULL);
}
- if (conversion.contains("%in")) {
- conversion.prepend('(');
- conversion.replace("%in", arg);
+ if (conversion.contains(QLatin1String("%in"))) {
+ conversion.prepend(QLatin1Char('('));
+ conversion.replace(QLatin1String("%in"), arg);
} else {
c << arg;
}
@@ -1881,7 +1905,7 @@ bool ShibokenGenerator::injectedCodeUsesCppSelf(const AbstractMetaFunction* func
{
CodeSnipList snips = func->injectedCodeSnips(CodeSnip::Any, TypeSystem::TargetLangCode);
foreach (CodeSnip snip, snips) {
- if (snip.code().contains("%CPPSELF"))
+ if (snip.code().contains(QLatin1String("%CPPSELF")))
return true;
}
return false;
@@ -1891,7 +1915,7 @@ bool ShibokenGenerator::injectedCodeUsesPySelf(const AbstractMetaFunction* func)
{
CodeSnipList snips = func->injectedCodeSnips(CodeSnip::Any, TypeSystem::NativeCode);
foreach (CodeSnip snip, snips) {
- if (snip.code().contains("%PYSELF"))
+ if (snip.code().contains(QLatin1String("%PYSELF")))
return true;
}
return false;
@@ -1899,18 +1923,18 @@ bool ShibokenGenerator::injectedCodeUsesPySelf(const AbstractMetaFunction* func)
bool ShibokenGenerator::injectedCodeCallsCppFunction(const AbstractMetaFunction* func)
{
- QString funcCall = QString("%1(").arg(func->originalName());
+ QString funcCall = func->originalName() + QLatin1Char('(');
QString wrappedCtorCall;
if (func->isConstructor()) {
- funcCall.prepend("new ");
- wrappedCtorCall = QString("new %1(").arg(wrapperName(func->ownerClass()));
+ funcCall.prepend(QLatin1String("new "));
+ wrappedCtorCall = QStringLiteral("new %1(").arg(wrapperName(func->ownerClass()));
}
CodeSnipList snips = func->injectedCodeSnips(CodeSnip::Any, TypeSystem::TargetLangCode);
foreach (CodeSnip snip, snips) {
- if (snip.code().contains("%FUNCTION_NAME(") || snip.code().contains(funcCall)
+ if (snip.code().contains(QLatin1String("%FUNCTION_NAME(")) || snip.code().contains(funcCall)
|| (func->isConstructor()
&& ((func->ownerClass()->isPolymorphic() && snip.code().contains(wrappedCtorCall))
- || snip.code().contains("new %TYPE(")))
+ || snip.code().contains(QLatin1String("new %TYPE("))))
)
return true;
}
@@ -1919,7 +1943,7 @@ bool ShibokenGenerator::injectedCodeCallsCppFunction(const AbstractMetaFunction*
bool ShibokenGenerator::injectedCodeCallsPythonOverride(const AbstractMetaFunction* func)
{
- static QRegExp overrideCallRegexCheck("PyObject_Call\\s*\\(\\s*%PYTHON_METHOD_OVERRIDE\\s*,");
+ static QRegExp overrideCallRegexCheck(QLatin1String("PyObject_Call\\s*\\(\\s*%PYTHON_METHOD_OVERRIDE\\s*,"));
CodeSnipList snips = func->injectedCodeSnips(CodeSnip::Any, TypeSystem::NativeCode);
foreach (CodeSnip snip, snips) {
if (overrideCallRegexCheck.indexIn(snip.code()) != -1)
@@ -1930,8 +1954,8 @@ bool ShibokenGenerator::injectedCodeCallsPythonOverride(const AbstractMetaFuncti
bool ShibokenGenerator::injectedCodeHasReturnValueAttribution(const AbstractMetaFunction* func, TypeSystem::Language language)
{
- static QRegExp retValAttributionRegexCheck_native("%0\\s*=[^=]\\s*.+");
- static QRegExp retValAttributionRegexCheck_target("%PYARG_0\\s*=[^=]\\s*.+");
+ static QRegExp retValAttributionRegexCheck_native(QLatin1String("%0\\s*=[^=]\\s*.+"));
+ static QRegExp retValAttributionRegexCheck_target(QLatin1String("%PYARG_0\\s*=[^=]\\s*.+"));
CodeSnipList snips = func->injectedCodeSnips(CodeSnip::Any, language);
foreach (CodeSnip snip, snips) {
if (language == TypeSystem::TargetLangCode) {
@@ -1950,9 +1974,9 @@ bool ShibokenGenerator::injectedCodeUsesArgument(const AbstractMetaFunction* fun
CodeSnipList snips = func->injectedCodeSnips(CodeSnip::Any);
foreach (CodeSnip snip, snips) {
QString code = snip.code();
- if (code.contains("%ARGUMENT_NAMES"))
+ if (code.contains(QLatin1String("%ARGUMENT_NAMES")))
return true;
- if (code.contains(QRegExp(QString("%%1\\b").arg(argumentIndex + 1))))
+ if (code.contains(QRegExp(QStringLiteral("%%1\\b").arg(argumentIndex + 1))))
return true;
}
return false;
@@ -2048,18 +2072,22 @@ AbstractMetaClassList ShibokenGenerator::getAllAncestors(const AbstractMetaClass
QString ShibokenGenerator::getModuleHeaderFileName(const QString& moduleName) const
{
QString result = moduleName.isEmpty() ? packageName() : moduleName;
- result.replace(".", "_");
- return QString("%1_python.h").arg(result.toLower());
+ result.replace(QLatin1Char('.'), QLatin1Char('_'));
+ return result.toLower() + QLatin1String("_python.h");
}
QString ShibokenGenerator::extendedIsConvertibleFunctionName(const TypeEntry* targetType) const
{
- return QString("ExtendedIsConvertible_%1_%2").arg(targetType->targetLangPackage().replace('.', '_')).arg(targetType->name());
+ QString p = targetType->targetLangPackage();
+ p.replace(QLatin1Char('.'), QLatin1Char('_'));
+ return QStringLiteral("ExtendedIsConvertible_%1_%2").arg(p, targetType->name());
}
QString ShibokenGenerator::extendedToCppFunctionName(const TypeEntry* targetType) const
{
- return QString("ExtendedToCpp_%1_%2").arg(targetType->targetLangPackage().replace('.', '_')).arg(targetType->name());
+ QString p = targetType->targetLangPackage();
+ p.replace(QLatin1Char('.'), QLatin1Char('_'));
+ return QStringLiteral("ExtendedToCpp_%1_%2").arg(p, targetType->name());
}
bool ShibokenGenerator::isCopyable(const AbstractMetaClass *metaClass)
@@ -2078,48 +2106,48 @@ bool ShibokenGenerator::isCopyable(const AbstractMetaClass *metaClass)
AbstractMetaType* ShibokenGenerator::buildAbstractMetaTypeFromString(QString typeSignature)
{
typeSignature = typeSignature.trimmed();
- if (typeSignature.startsWith("::"))
+ if (typeSignature.startsWith(QLatin1String("::")))
typeSignature = typeSignature.mid(2);
if (m_metaTypeFromStringCache.contains(typeSignature))
return m_metaTypeFromStringCache.value(typeSignature);
QString typeString = typeSignature;
- bool isConst = typeString.startsWith("const ");
+ bool isConst = typeString.startsWith(QLatin1String("const "));
if (isConst)
typeString.remove(0, sizeof("const ") / sizeof(char) - 1);
- bool isReference = typeString.endsWith("&");
+ bool isReference = typeString.endsWith(QLatin1Char('&'));
if (isReference) {
typeString.chop(1);
typeString = typeString.trimmed();
}
int indirections = 0;
- while (typeString.endsWith("*")) {
+ while (typeString.endsWith(QLatin1Char('*'))) {
++indirections;
typeString.chop(1);
typeString = typeString.trimmed();
}
- if (typeString.startsWith("::"))
+ if (typeString.startsWith(QLatin1String("::")))
typeString.remove(0, 2);
QString adjustedTypeName = typeString;
QStringList instantiatedTypes;
- int lpos = typeString.indexOf('<');
+ int lpos = typeString.indexOf(QLatin1Char('<'));
if (lpos > -1) {
- int rpos = typeString.lastIndexOf('>');
+ int rpos = typeString.lastIndexOf(QLatin1Char('>'));
if ((lpos != -1) && (rpos != -1)) {
QString type = typeString.mid(lpos + 1, rpos - lpos - 1);
int depth = 0;
int start = 0;
for (int i = 0; i < type.count(); ++i) {
- if (type.at(i) == '<') {
+ if (type.at(i) == QLatin1Char('<')) {
++depth;
- } else if (type.at(i) == '>') {
+ } else if (type.at(i) == QLatin1Char('>')) {
--depth;
- } else if (type.at(i) == ',' && depth == 0) {
+ } else if (type.at(i) == QLatin1Char(',') && depth == 0) {
instantiatedTypes << type.mid(start, i - start).trimmed();
start = i + 1;
}
@@ -2152,7 +2180,7 @@ AbstractMetaType* ShibokenGenerator::buildAbstractMetaTypeFromString(QString typ
AbstractMetaType* ShibokenGenerator::buildAbstractMetaTypeFromTypeEntry(const TypeEntry* typeEntry)
{
QString typeName = typeEntry->qualifiedCppName();
- if (typeName.startsWith("::"))
+ if (typeName.startsWith(QLatin1String("::")))
typeName = typeName.mid(2);
if (m_metaTypeFromStringCache.contains(typeName))
return m_metaTypeFromStringCache.value(typeName);
@@ -2192,7 +2220,7 @@ static bool isGroupable(const AbstractMetaFunction* func)
if (func->isSignal() || func->isDestructor() || (func->isModifiedRemoved() && !func->isAbstract()))
return false;
// weird operator overloads
- if (func->name() == "operator[]" || func->name() == "operator->") // FIXME: what about cast operators?
+ if (func->name() == QLatin1String("operator[]") || func->name() == QLatin1String("operator->")) // FIXME: what about cast operators?
return false;;
return true;
}
@@ -2245,12 +2273,18 @@ QPair< int, int > ShibokenGenerator::getMinMaxArguments(const AbstractMetaFuncti
QMap<QString, QString> ShibokenGenerator::options() const
{
QMap<QString, QString> opts(Generator::options());
- opts.insert(AVOID_PROTECTED_HACK, "Avoid the use of the '#define protected public' hack.");
- opts.insert(PARENT_CTOR_HEURISTIC, "Enable heuristics to detect parent relationship on constructors.");
- opts.insert(RETURN_VALUE_HEURISTIC, "Enable heuristics to detect parent relationship on return values (USE WITH CAUTION!)");
- opts.insert(ENABLE_PYSIDE_EXTENSIONS, "Enable PySide extensions, such as support for signal/slots, use this if you are creating a binding for a Qt-based library.");
- opts.insert(DISABLE_VERBOSE_ERROR_MESSAGES, "Disable verbose error messages. Turn the python code hard to debug but safe few kB on the generated bindings.");
- opts.insert(USE_ISNULL_AS_NB_NONZERO, "If a class have an isNull()const method, it will be used to compute the value of boolean casts");
+ opts.insert(QLatin1String(AVOID_PROTECTED_HACK),
+ QLatin1String("Avoid the use of the '#define protected public' hack."));
+ opts.insert(QLatin1String(PARENT_CTOR_HEURISTIC),
+ QLatin1String("Enable heuristics to detect parent relationship on constructors."));
+ opts.insert(QLatin1String(RETURN_VALUE_HEURISTIC),
+ QLatin1String("Enable heuristics to detect parent relationship on return values (USE WITH CAUTION!)"));
+ opts.insert(QLatin1String(ENABLE_PYSIDE_EXTENSIONS),
+ QLatin1String("Enable PySide extensions, such as support for signal/slots, use this if you are creating a binding for a Qt-based library."));
+ opts.insert(QLatin1String(DISABLE_VERBOSE_ERROR_MESSAGES),
+ QLatin1String("Disable verbose error messages. Turn the python code hard to debug but safe few kB on the generated bindings."));
+ opts.insert(QLatin1String(USE_ISNULL_AS_NB_NONZERO),
+ QLatin1String("If a class have an isNull()const method, it will be used to compute the value of boolean casts"));
return opts;
}
@@ -2281,12 +2315,12 @@ static void getCode(QStringList& code, const TypeEntry* type)
bool ShibokenGenerator::doSetup(const QMap<QString, QString>& args)
{
- m_useCtorHeuristic = args.contains(PARENT_CTOR_HEURISTIC);
- m_usePySideExtensions = args.contains(ENABLE_PYSIDE_EXTENSIONS);
- m_userReturnValueHeuristic = args.contains(RETURN_VALUE_HEURISTIC);
- m_verboseErrorMessagesDisabled = args.contains(DISABLE_VERBOSE_ERROR_MESSAGES);
- m_useIsNullAsNbNonZero = args.contains(USE_ISNULL_AS_NB_NONZERO);
- m_avoidProtectedHack = args.contains(AVOID_PROTECTED_HACK);
+ m_useCtorHeuristic = args.contains(QLatin1String(PARENT_CTOR_HEURISTIC));
+ m_usePySideExtensions = args.contains(QLatin1String(ENABLE_PYSIDE_EXTENSIONS));
+ m_userReturnValueHeuristic = args.contains(QLatin1String(RETURN_VALUE_HEURISTIC));
+ m_verboseErrorMessagesDisabled = args.contains(QLatin1String(DISABLE_VERBOSE_ERROR_MESSAGES));
+ m_useIsNullAsNbNonZero = args.contains(QLatin1String(USE_ISNULL_AS_NB_NONZERO));
+ m_avoidProtectedHack = args.contains(QLatin1String(AVOID_PROTECTED_HACK));
TypeDatabase* td = TypeDatabase::instance();
QStringList snips;
@@ -2312,13 +2346,13 @@ bool ShibokenGenerator::doSetup(const QMap<QString, QString>& args)
void ShibokenGenerator::collectContainerTypesFromConverterMacros(const QString& code, bool toPythonMacro)
{
- QString convMacro = toPythonMacro ? "%CONVERTTOPYTHON[" : "%CONVERTTOCPP[";
+ QString convMacro = toPythonMacro ? QLatin1String("%CONVERTTOPYTHON[") : QLatin1String("%CONVERTTOCPP[");
int offset = toPythonMacro ? sizeof("%CONVERTTOPYTHON") : sizeof("%CONVERTTOCPP");
int start = 0;
while ((start = code.indexOf(convMacro, start)) != -1) {
- int end = code.indexOf("]", start);
+ int end = code.indexOf(QLatin1Char(']'), start);
start += offset;
- if (code.at(start) != '%') {
+ if (code.at(start) != QLatin1Char('%')) {
QString typeString = code.mid(start, end - start);
AbstractMetaType* type = buildAbstractMetaTypeFromString(typeString);
addInstantiatedContainers(type);
@@ -2355,9 +2389,9 @@ bool ShibokenGenerator::avoidProtectedHack() const
QString ShibokenGenerator::cppApiVariableName(const QString& moduleName) const
{
QString result = moduleName.isEmpty() ? ShibokenGenerator::packageName() : moduleName;
- result.replace(".", "_");
- result.prepend("Sbk");
- result.append("Types");
+ result.replace(QLatin1Char('.'), QLatin1Char('_'));
+ result.prepend(QLatin1String("Sbk"));
+ result.append(QLatin1String("Types"));
return result;
}
@@ -2365,17 +2399,17 @@ QString ShibokenGenerator::convertersVariableName(const QString& moduleName) con
{
QString result = cppApiVariableName(moduleName);
result.chop(1);
- result.append("Converters");
+ result.append(QLatin1String("Converters"));
return result;
}
static QString processInstantiationsVariableName(const AbstractMetaType* type)
{
- QString res = QString("_%1").arg(_fixedCppTypeName(type->typeEntry()->qualifiedCppName()).toUpper());
+ QString res = QLatin1Char('_') + _fixedCppTypeName(type->typeEntry()->qualifiedCppName()).toUpper();
foreach (const AbstractMetaType* instantiation, type->instantiations()) {
res += instantiation->isContainer()
? processInstantiationsVariableName(instantiation)
- : QString("_%1").arg(_fixedCppTypeName(instantiation->cppSignature()).toUpper());
+ : QLatin1Char('_') + _fixedCppTypeName(instantiation->cppSignature()).toUpper();
}
return res;
}
@@ -2389,7 +2423,7 @@ QString ShibokenGenerator::getTypeIndexVariableName(const AbstractMetaClass* met
QString instantiations;
foreach (const AbstractMetaType* instantiation, metaClass->templateBaseClassInstantiations())
instantiations += processInstantiationsVariableName(instantiation);
- return QString("SBK_%1%2_IDX").arg(base).arg(instantiations);
+ return QString::fromLatin1("SBK_%1%2_IDX").arg(base, instantiations);
}
return getTypeIndexVariableName(metaClass->typeEntry());
}
@@ -2400,13 +2434,13 @@ QString ShibokenGenerator::getTypeIndexVariableName(const TypeEntry* type)
if (trueType->basicAliasedTypeEntry())
type = trueType->basicAliasedTypeEntry();
}
- return QString("SBK_%1_IDX").arg(_fixedCppTypeName(type->qualifiedCppName()).toUpper());
+ return QString::fromLatin1("SBK_%1_IDX").arg(_fixedCppTypeName(type->qualifiedCppName()).toUpper());
}
QString ShibokenGenerator::getTypeIndexVariableName(const AbstractMetaType* type)
{
- return QString("SBK%1%2_IDX")
- .arg(type->typeEntry()->isContainer() ? "_"+moduleName().toUpper() : "")
- .arg(processInstantiationsVariableName(type));
+ return QString::fromLatin1("SBK%1%2_IDX")
+ .arg(type->typeEntry()->isContainer() ? QLatin1Char('_') + moduleName().toUpper() : QString(),
+ processInstantiationsVariableName(type));
}
bool ShibokenGenerator::verboseErrorMessagesDisabled() const
@@ -2466,7 +2500,7 @@ void ShibokenGenerator::writeMinimalConstructorExpression(QTextStream& s, const
return;
QString ctor = defaultCtor.isEmpty() ? minimalConstructor(type) : defaultCtor;
if (ctor.isEmpty())
- qFatal(qPrintable(QString(MIN_CTOR_ERROR_MSG).arg(type->cppSignature())), NULL);
+ qFatal(qPrintable(QString::fromLatin1(MIN_CTOR_ERROR_MSG).arg(type->cppSignature())), NULL);
s << " = " << ctor;
}
@@ -2476,7 +2510,7 @@ void ShibokenGenerator::writeMinimalConstructorExpression(QTextStream& s, const
return;
QString ctor = defaultCtor.isEmpty() ? minimalConstructor(type) : defaultCtor;
if (ctor.isEmpty())
- qFatal(qPrintable(QString(MIN_CTOR_ERROR_MSG).arg(type->qualifiedCppName())), NULL);
+ qFatal(qPrintable(QString::fromLatin1(MIN_CTOR_ERROR_MSG).arg(type->qualifiedCppName())), NULL);
s << " = " << ctor;
}
@@ -2488,7 +2522,9 @@ bool ShibokenGenerator::isCppIntegralPrimitive(const TypeEntry* type)
if (trueType->basicAliasedTypeEntry())
trueType = trueType->basicAliasedTypeEntry();
QString typeName = trueType->qualifiedCppName();
- return !typeName.contains("double") && !typeName.contains("float") && !typeName.contains("wchar");
+ return !typeName.contains(QLatin1String("double"))
+ && !typeName.contains(QLatin1String("float"))
+ && !typeName.contains(QLatin1String("wchar"));
}
bool ShibokenGenerator::isCppIntegralPrimitive(const AbstractMetaType* type)
{
diff --git a/generator/shiboken2/shibokengenerator.h b/generator/shiboken2/shibokengenerator.h
index adeb734..b228db4 100644
--- a/generator/shiboken2/shibokengenerator.h
+++ b/generator/shiboken2/shibokengenerator.h
@@ -226,8 +226,8 @@ public:
* \param arg_count the number of function arguments
*/
QString functionSignature(const AbstractMetaFunction* func,
- QString prepend = "",
- QString append = "",
+ QString prepend = QString(),
+ QString append = QString(),
Options options = NoOption,
int arg_count = -1) const;
@@ -378,7 +378,7 @@ public:
QString cpythonSetattroFunctionName(const AbstractMetaClass* metaClass);
QString cpythonGetterFunctionName(const AbstractMetaField* metaField);
QString cpythonSetterFunctionName(const AbstractMetaField* metaField);
- QString cpythonWrapperCPtr(const AbstractMetaClass* metaClass, QString argName = PYTHON_SELF_VAR);
+ QString cpythonWrapperCPtr(const AbstractMetaClass* metaClass, QString argName = QLatin1String(PYTHON_SELF_VAR));
QString cpythonWrapperCPtr(const AbstractMetaType* metaType, QString argName);
QString cpythonWrapperCPtr(const TypeEntry* type, QString argName);
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-10 15:18:14 +0000