aboutsummaryrefslogtreecommitdiffstats
path: root/sources/shiboken2/generator
diff options
context:
space:
mode:
Diffstat (limited to 'sources/shiboken2/generator')
-rw-r--r--sources/shiboken2/generator/generator.cpp95
-rw-r--r--sources/shiboken2/generator/generator.h14
-rw-r--r--sources/shiboken2/generator/main.cpp214
-rw-r--r--sources/shiboken2/generator/qtdoc/qtdocgenerator.cpp130
-rw-r--r--sources/shiboken2/generator/qtdoc/qtdocgenerator.h2
-rw-r--r--sources/shiboken2/generator/shiboken2/cppgenerator.cpp403
-rw-r--r--sources/shiboken2/generator/shiboken2/cppgenerator.h14
-rw-r--r--sources/shiboken2/generator/shiboken2/headergenerator.cpp55
-rw-r--r--sources/shiboken2/generator/shiboken2/headergenerator.h10
-rw-r--r--sources/shiboken2/generator/shiboken2/overloaddata.cpp123
-rw-r--r--sources/shiboken2/generator/shiboken2/overloaddata.h14
-rw-r--r--sources/shiboken2/generator/shiboken2/shibokengenerator.cpp364
-rw-r--r--sources/shiboken2/generator/shiboken2/shibokengenerator.h22
13 files changed, 876 insertions, 584 deletions
diff --git a/sources/shiboken2/generator/generator.cpp b/sources/shiboken2/generator/generator.cpp
index d7f98a90f..a8e8735bb 100644
--- a/sources/shiboken2/generator/generator.cpp
+++ b/sources/shiboken2/generator/generator.cpp
@@ -36,6 +36,7 @@
#include <QtCore/QDir>
#include <QtCore/QFile>
#include <QtCore/QFileInfo>
+#include <QtCore/QRegularExpression>
#include <QDebug>
#include <typedatabase.h>
@@ -48,18 +49,14 @@ struct Generator::GeneratorPrivate {
int numGenerated;
QStringList instantiatedContainersNames;
QStringList instantiatedSmartPointerNames;
- QList<const AbstractMetaType *> instantiatedContainers;
- QList<const AbstractMetaType *> instantiatedSmartPointers;
+ QVector<const AbstractMetaType *> instantiatedContainers;
+ QVector<const AbstractMetaType *> instantiatedSmartPointers;
};
Generator::Generator() : m_d(new GeneratorPrivate)
{
m_d->numGenerated = 0;
- m_d->instantiatedContainers = QList<const AbstractMetaType *>();
- m_d->instantiatedSmartPointers = QList<const AbstractMetaType *>();
- m_d->instantiatedContainersNames = QStringList();
- m_d->instantiatedSmartPointerNames = QStringList();
}
Generator::~Generator()
@@ -73,7 +70,7 @@ bool Generator::setup(const ApiExtractor& extractor, const QMap< QString, QStrin
TypeEntryHash allEntries = TypeDatabase::instance()->allEntries();
TypeEntry* entryFound = 0;
for (TypeEntryHash::const_iterator it = allEntries.cbegin(), end = allEntries.cend(); it != end; ++it) {
- foreach (TypeEntry *entry, it.value()) {
+ for (TypeEntry *entry : it.value()) {
if (entry->type() == TypeEntry::TypeSystemType && entry->generateCode()) {
entryFound = entry;
break;
@@ -120,7 +117,8 @@ void Generator::addInstantiatedContainersAndSmartPointers(const AbstractMetaType
{
if (!type)
return;
- foreach (const AbstractMetaType* t, type->instantiations())
+ const AbstractMetaTypeList &instantiations = type->instantiations();
+ for (const AbstractMetaType* t : instantiations)
addInstantiatedContainersAndSmartPointers(t, context);
if (!type->typeEntry()->isContainer() && !type->typeEntry()->isSmartPointer())
return;
@@ -156,7 +154,8 @@ void Generator::addInstantiatedContainersAndSmartPointers(const AbstractMetaType
void Generator::collectInstantiatedContainersAndSmartPointers(const AbstractMetaFunction *func)
{
addInstantiatedContainersAndSmartPointers(func->type(), func->signature());
- foreach (const AbstractMetaArgument* arg, func->arguments())
+ const AbstractMetaArgumentList &arguments = func->arguments();
+ for (const AbstractMetaArgument *arg : arguments)
addInstantiatedContainersAndSmartPointers(arg->type(), func->signature());
}
@@ -164,35 +163,40 @@ void Generator::collectInstantiatedContainersAndSmartPointers(const AbstractMeta
{
if (!metaClass->typeEntry()->generateCode())
return;
- foreach (const AbstractMetaFunction* func, metaClass->functions())
+ const AbstractMetaFunctionList &funcs = metaClass->functions();
+ for (const AbstractMetaFunction *func : funcs)
collectInstantiatedContainersAndSmartPointers(func);
- foreach (const AbstractMetaField* field, metaClass->fields())
+ const AbstractMetaFieldList &fields = metaClass->fields();
+ for (const AbstractMetaField *field : fields)
addInstantiatedContainersAndSmartPointers(field->type(), field->name());
- foreach (AbstractMetaClass* innerClass, metaClass->innerClasses())
+ const AbstractMetaClassList &innerClasses = metaClass->innerClasses();
+ for (AbstractMetaClass *innerClass : innerClasses)
collectInstantiatedContainersAndSmartPointers(innerClass);
}
void Generator::collectInstantiatedContainersAndSmartPointers()
{
- foreach (const AbstractMetaFunction* func, globalFunctions())
+ const AbstractMetaFunctionList &funcs = globalFunctions();
+ for (const AbstractMetaFunction *func : funcs)
collectInstantiatedContainersAndSmartPointers(func);
- foreach (const AbstractMetaClass* metaClass, classes())
+ const AbstractMetaClassList &classList = classes();
+ for (const AbstractMetaClass *metaClass : classList)
collectInstantiatedContainersAndSmartPointers(metaClass);
}
-QList<const AbstractMetaType*> Generator::instantiatedContainers() const
+QVector<const AbstractMetaType *> Generator::instantiatedContainers() const
{
return m_d->instantiatedContainers;
}
-QList<const AbstractMetaType*> Generator::instantiatedSmartPointers() const
+QVector<const AbstractMetaType*> Generator::instantiatedSmartPointers() const
{
return m_d->instantiatedSmartPointers;
}
-QMap< QString, QString > Generator::options() const
+Generator::OptionDescriptions Generator::options() const
{
- return QMap<QString, QString>();
+ return OptionDescriptions();
}
AbstractMetaClassList Generator::classes() const
@@ -215,12 +219,12 @@ AbstractMetaEnumList Generator::globalEnums() const
return m_d->apiextractor->globalEnums();
}
-QList<const PrimitiveTypeEntry*> Generator::primitiveTypes() const
+PrimitiveTypeEntryList Generator::primitiveTypes() const
{
return m_d->apiextractor->primitiveTypes();
}
-QList<const ContainerTypeEntry*> Generator::containerTypes() const
+ContainerTypeEntryList Generator::containerTypes() const
{
return m_d->apiextractor->containerTypes();
}
@@ -351,13 +355,14 @@ QString Generator::getFileNameBaseForSmartPointer(const AbstractMetaType *smartP
bool Generator::generate()
{
- foreach (AbstractMetaClass *cls, m_d->apiextractor->classes()) {
+ const AbstractMetaClassList &classList = m_d->apiextractor->classes();
+ for (AbstractMetaClass *cls : classList) {
GeneratorContext context(cls);
if (!generateFileForContext(context))
return false;
}
- foreach (const AbstractMetaType *type, instantiatedSmartPointers()) {
+ for (const AbstractMetaType *type : qAsConst(m_d->instantiatedSmartPointers)) {
AbstractMetaClass *smartPointerClass =
AbstractMetaClass::findClass(m_d->apiextractor->smartPointers(), type->name());
GeneratorContext context(smartPointerClass, type, true);
@@ -394,7 +399,8 @@ void Generator::replaceTemplateVariables(QString &code, const AbstractMetaFuncti
if (cpp_class)
code.replace(QLatin1String("%TYPE"), cpp_class->name());
- foreach (AbstractMetaArgument *arg, func->arguments())
+ const AbstractMetaArgumentList &argument = func->arguments();
+ for (AbstractMetaArgument *arg : argument)
code.replace(QLatin1Char('%') + QString::number(arg->argumentIndex() + 1), arg->name());
//template values
@@ -419,10 +425,11 @@ void Generator::replaceTemplateVariables(QString &code, const AbstractMetaFuncti
QTextStream& formatCode(QTextStream &s, const QString& code, Indentor &indentor)
{
// detect number of spaces before the first character
- QStringList lst(code.split(QLatin1Char('\n')));
- QRegExp nonSpaceRegex(QLatin1String("[^\\s]"));
+ const QStringList lst(code.split(QLatin1Char('\n')));
+ static const QRegularExpression nonSpaceRegex(QStringLiteral("[^\\s]"));
+ Q_ASSERT(nonSpaceRegex.isValid());
int spacesToRemove = 0;
- foreach(QString line, lst) {
+ for (const QString &line : lst) {
if (!line.trimmed().isEmpty()) {
spacesToRemove = line.indexOf(nonSpaceRegex);
if (spacesToRemove == -1)
@@ -431,10 +438,11 @@ QTextStream& formatCode(QTextStream &s, const QString& code, Indentor &indentor)
}
}
- static QRegExp emptyLine(QLatin1String("\\s*[\\r]?[\\n]?\\s*"));
+ static const QRegularExpression emptyLine(QStringLiteral("^\\s*[\\r]?[\\n]?\\s*$"));
+ Q_ASSERT(emptyLine.isValid());
- foreach(QString line, lst) {
- if (!line.isEmpty() && !emptyLine.exactMatch(line)) {
+ for (QString line : lst) {
+ if (!line.isEmpty() && !emptyLine.match(line).hasMatch()) {
while (line.end()->isSpace())
line.chop(1);
int limit = 0;
@@ -507,9 +515,12 @@ bool Generator::isVoidPointer(const AbstractMetaType* type)
QString Generator::getFullTypeName(const TypeEntry* type) const
{
- return type->isCppPrimitive()
- ? type->qualifiedCppName()
- : (QLatin1String("::") + type->qualifiedCppName());
+ QString result = type->qualifiedCppName();
+ if (type->isArray())
+ type = static_cast<const ArrayTypeEntry *>(type)->nestedTypeEntry();
+ if (!type->isCppPrimitive())
+ result.prepend(QLatin1String("::"));
+ return result;
}
QString Generator::getFullTypeName(const AbstractMetaType* type) const
@@ -639,9 +650,9 @@ QString Generator::minimalConstructor(const AbstractMetaClass* metaClass) const
if (cType->hasDefaultConstructor())
return cType->defaultConstructor();
- AbstractMetaFunctionList constructors = metaClass->queryFunctions(AbstractMetaClass::Constructors);
+ const AbstractMetaFunctionList &constructors = metaClass->queryFunctions(AbstractMetaClass::Constructors);
int maxArgs = 0;
- foreach (const AbstractMetaFunction* ctor, constructors) {
+ for (const AbstractMetaFunction *ctor : constructors) {
if (ctor->isUserAdded() || ctor->isPrivate() || ctor->functionType() != AbstractMetaFunction::ConstructorFunction)
continue;
@@ -656,28 +667,29 @@ QString Generator::minimalConstructor(const AbstractMetaClass* metaClass) const
QString qualifiedCppName = metaClass->typeEntry()->qualifiedCppName();
QStringList templateTypes;
- foreach (TypeEntry* templateType, metaClass->templateArguments())
+ const QVector<TypeEntry *> &templateArguments = metaClass->templateArguments();
+ for (TypeEntry *templateType : templateArguments)
templateTypes << templateType->qualifiedCppName();
// Empty constructor.
if (maxArgs == 0)
return QLatin1String("::") + qualifiedCppName + QLatin1String("()");
- QList<const AbstractMetaFunction*> candidates;
+ QVector<const AbstractMetaFunction *> candidates;
// Constructors with C++ primitive types, enums or pointers only.
// Start with the ones with fewer arguments.
for (int i = 1; i <= maxArgs; ++i) {
- foreach (const AbstractMetaFunction* ctor, constructors) {
+ for (const AbstractMetaFunction *ctor : constructors) {
if (ctor->isUserAdded() || ctor->isPrivate() || ctor->functionType() != AbstractMetaFunction::ConstructorFunction)
continue;
- AbstractMetaArgumentList arguments = ctor->arguments();
+ const AbstractMetaArgumentList &arguments = ctor->arguments();
if (arguments.size() != i)
continue;
QStringList args;
- foreach (const AbstractMetaArgument* arg, arguments) {
+ for (const AbstractMetaArgument *arg : arguments) {
const TypeEntry* type = arg->type()->typeEntry();
if (type == metaClass->typeEntry()) {
args.clear();
@@ -715,9 +727,10 @@ QString Generator::minimalConstructor(const AbstractMetaClass* metaClass) const
// Constructors with C++ primitive types, enums, pointers, value types,
// and user defined primitive types.
// Builds the minimal constructor recursively.
- foreach (const AbstractMetaFunction* ctor, candidates) {
+ for (const AbstractMetaFunction *ctor : qAsConst(candidates)) {
QStringList args;
- foreach (const AbstractMetaArgument* arg, ctor->arguments()) {
+ const AbstractMetaArgumentList &arguments = ctor->arguments();
+ for (const AbstractMetaArgument *arg : arguments) {
if (arg->type()->typeEntry() == metaClass->typeEntry()) {
args.clear();
break;
diff --git a/sources/shiboken2/generator/generator.h b/sources/shiboken2/generator/generator.h
index f734ff9d7..f0b2a5e41 100644
--- a/sources/shiboken2/generator/generator.h
+++ b/sources/shiboken2/generator/generator.h
@@ -30,6 +30,7 @@
#define GENERATOR_H
#include <abstractmetalang_typedefs.h>
+#include <typedatabase_typedefs.h>
#include <dependency.h>
#include <QtCore/QObject>
#include <QtCore/QSharedPointer>
@@ -136,6 +137,9 @@ private:
class Generator
{
public:
+ typedef QPair<QString, QString> OptionDescription;
+ typedef QVector<OptionDescription> OptionDescriptions;
+
/// Optiosn used around the generator code
enum Option {
NoOption = 0x00000000,
@@ -180,7 +184,7 @@ public:
bool setup(const ApiExtractor& extractor, const QMap<QString, QString> args);
- virtual QMap<QString, QString> options() const;
+ virtual OptionDescriptions options() const;
/// Returns the classes used to generate the binding code.
AbstractMetaClassList classes() const;
@@ -198,10 +202,10 @@ public:
AbstractMetaEnumList globalEnums() const;
/// Returns all primitive types found by APIExtractor
- QList<const PrimitiveTypeEntry*> primitiveTypes() const;
+ PrimitiveTypeEntryList primitiveTypes() const;
/// Returns all container types found by APIExtractor
- QList<const ContainerTypeEntry*> containerTypes() const;
+ ContainerTypeEntryList containerTypes() const;
/// Returns an AbstractMetaEnum for a given EnumTypeEntry, or NULL if not found.
const AbstractMetaEnum* findAbstractMetaEnum(const EnumTypeEntry* typeEntry) const;
@@ -388,8 +392,8 @@ protected:
*/
virtual QString subDirectoryForPackage(QString packageName = QString()) const;
- QList<const AbstractMetaType*> instantiatedContainers() const;
- QList<const AbstractMetaType*> instantiatedSmartPointers() const;
+ QVector<const AbstractMetaType*> instantiatedContainers() const;
+ QVector<const AbstractMetaType*> instantiatedSmartPointers() const;
static QString getSimplifiedContainerTypeName(const AbstractMetaType *type);
void addInstantiatedContainersAndSmartPointers(const AbstractMetaType *type,
diff --git a/sources/shiboken2/generator/main.cpp b/sources/shiboken2/generator/main.cpp
index 874540e54..b22919981 100644
--- a/sources/shiboken2/generator/main.cpp
+++ b/sources/shiboken2/generator/main.cpp
@@ -46,6 +46,12 @@
#define PATH_SPLITTER ":"
#endif
+static inline QString includePathOption() { return QStringLiteral("include-paths"); }
+static inline QString frameworkIncludePathOption() { return QStringLiteral("framework-include-paths"); }
+static inline QString typesystemPathOption() { return QStringLiteral("typesystem-paths"); }
+static inline QString helpOption() { return QStringLiteral("help"); }
+static const char helpHint[] = "Note: use --help or -h for more information.\n";
+
namespace {
class ArgsHandler
@@ -134,14 +140,17 @@ QString ArgsHandler::errorMessage() const
}
}
-static void printOptions(QTextStream& s, const QMap<QString, QString>& options)
+typedef Generator::OptionDescriptions OptionDescriptions;
+
+static void printOptions(QTextStream& s, const OptionDescriptions& options)
{
- QMap<QString, QString>::const_iterator it = options.constBegin();
s.setFieldAlignment(QTextStream::AlignLeft);
- for (; it != options.constEnd(); ++it) {
- s << " --";
+ for (const auto &od : options) {
+ s << ' ';
+ if (!od.first.startsWith(QLatin1Char('-')))
+ s << "--";
s.setFieldWidth(38);
- s << it.key() << it.value();
+ s << od.first << od.second;
s.setFieldWidth(0);
s << endl;
}
@@ -156,6 +165,7 @@ static bool processProjectFile(QFile& projectFile, QMap<QString, QString>& args)
return false;
QStringList includePaths;
+ QStringList frameworkIncludePaths;
QStringList typesystemPaths;
QStringList apiVersions;
@@ -176,6 +186,8 @@ static bool processProjectFile(QFile& projectFile, QMap<QString, QString>& args)
if (key == "include-path")
includePaths << QDir::toNativeSeparators(value);
+ else if (key == "framework-include-path")
+ frameworkIncludePaths << QDir::toNativeSeparators(value);
else if (key == "typesystem-path")
typesystemPaths << QDir::toNativeSeparators(value);
else if (key == "api-version")
@@ -189,10 +201,14 @@ static bool processProjectFile(QFile& projectFile, QMap<QString, QString>& args)
}
if (!includePaths.isEmpty())
- args.insert(QLatin1String("include-paths"), includePaths.join(QLatin1String(PATH_SPLITTER)));
+ args.insert(includePathOption(), includePaths.join(QLatin1String(PATH_SPLITTER)));
+
+ if (!frameworkIncludePaths.isEmpty())
+ args.insert(frameworkIncludePathOption(),
+ frameworkIncludePaths.join(QLatin1String(PATH_SPLITTER)));
if (!typesystemPaths.isEmpty())
- args.insert(QLatin1String("typesystem-paths"), typesystemPaths.join(QLatin1String(PATH_SPLITTER)));
+ args.insert(typesystemPathOption(), typesystemPaths.join(QLatin1String(PATH_SPLITTER)));
if (!apiVersions.isEmpty())
args.insert(QLatin1String("api-version"), apiVersions.join(QLatin1Char('|')));
return true;
@@ -206,7 +222,7 @@ static QMap<QString, QString> getInitializedArguments()
arguments.removeFirst();
QString projectFileName;
- foreach (const QString& arg, arguments) {
+ for (const QString &arg : qAsConst(arguments)) {
if (arg.startsWith(QLatin1String("--project-file"))) {
int split = arg.indexOf(QLatin1Char('='));
if (split > 0)
@@ -239,6 +255,55 @@ static QMap<QString, QString> getInitializedArguments()
return args;
}
+// Concatenate values of path arguments that can occur multiple times on the
+// command line.
+static void addPathOptionValue(const QString &option, const QString &value,
+ QMap<QString, QString> &args)
+{
+ const QMap<QString, QString>::iterator it = args.find(option);
+ if (it != args.end())
+ it.value().append(QLatin1String(PATH_SPLITTER) + value);
+ else
+ args.insert(option, value);
+}
+
+static void getCommandLineArg(QString arg, int &argNum, QMap<QString, QString> &args)
+{
+ if (arg.startsWith(QLatin1String("--"))) {
+ arg.remove(0, 2);
+ const int split = arg.indexOf(QLatin1Char('='));
+ if (split < 0) {
+ args.insert(arg, QString());
+ return;
+ }
+ const QString option = arg.left(split);
+ const QString value = arg.mid(split + 1).trimmed();
+ if (option == includePathOption() || option == frameworkIncludePathOption()
+ || option == typesystemPathOption()) {
+ addPathOptionValue(option, value, args);
+ } else {
+ args.insert(option, value);
+ }
+ return;
+ }
+ if (arg.startsWith(QLatin1Char('-'))) {
+ arg.remove(0, 1);
+ if (arg.startsWith(QLatin1Char('I'))) // Shorthand path arguments -I/usr/include...
+ addPathOptionValue(includePathOption(), arg.mid(1), args);
+ else if (arg.startsWith(QLatin1Char('F')))
+ addPathOptionValue(frameworkIncludePathOption(), arg.mid(1), args);
+ else if (arg.startsWith(QLatin1Char('T')))
+ addPathOptionValue(typesystemPathOption(), arg.mid(1), args);
+ else if (arg == QLatin1String("h"))
+ args.insert(helpOption(), QString());
+ else
+ args.insert(arg, QString());
+ return;
+ }
+ argNum++;
+ args.insert(QStringLiteral("arg-") + QString::number(argNum), arg);
+}
+
static QMap<QString, QString> getCommandLineArgs()
{
QMap<QString, QString> args = getInitializedArguments();
@@ -246,21 +311,9 @@ static QMap<QString, QString> getCommandLineArgs()
arguments.removeFirst();
int argNum = 0;
- foreach (const QString &carg, arguments) {
- const QString &arg = carg.trimmed();
- 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(QLatin1Char('-'))) {
- args[arg.mid(1)] = QString();
- } else {
- argNum++;
- args[QString::fromLatin1("arg-%1").arg(argNum)] = arg;
- }
- }
+ for (const QString &carg : qAsConst(arguments))
+ getCommandLineArg(carg.trimmed(), argNum, args);
+
return args;
}
@@ -286,40 +339,47 @@ void printUsage()
s << "Usage:\n "
<< "shiboken [options] header-file typesystem-file\n\n"
<< "General options:\n";
- QMap<QString, QString> generalOptions;
- 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."));
+ const QString pathSyntax = QLatin1String("<path>[" PATH_SPLITTER "<path>" PATH_SPLITTER "...]");
+ OptionDescriptions generalOptions = OptionDescriptions()
+ << qMakePair(QLatin1String("api-version=<\"package mask\">,<\"version\">"),
+ QLatin1String("Specify the supported api version used to generate the bindings"))
+ << qMakePair(QLatin1String("debug-level=[sparse|medium|full]"),
+ QLatin1String("Set the debug level"))
+ << qMakePair(QLatin1String("documentation-only"),
+ QLatin1String("Do not generates any code, just the documentation"))
+ << qMakePair(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."))
+ << qMakePair(QLatin1String("-F") + pathSyntax, QString())
+ << qMakePair(QLatin1String("framework-include-paths=") + pathSyntax,
+ QLatin1String("Framework include paths used by the C++ parser"))
+ << qMakePair(QLatin1String("generator-set=<\"generator module\">"),
+ QLatin1String("generator-set to be used. e.g. qtdoc"))
+ << qMakePair(QLatin1String("-h"), QString())
+ << qMakePair(helpOption(),
+ QLatin1String("Display this help and exit"))
+ << qMakePair(QLatin1String("-I") + pathSyntax, QString())
+ << qMakePair(QLatin1String("include-paths=") + pathSyntax,
+ QLatin1String("Include paths used by the C++ parser"))
+ << qMakePair(QLatin1String("license-file=<license-file>"),
+ QLatin1String("File used for copyright headers of generated files"))
+ << qMakePair(QLatin1String("no-suppress-warnings"),
+ QLatin1String("Show all warnings"))
+ << qMakePair(QLatin1String("output-directory=<path>"),
+ QLatin1String("The directory where the generated files will be written"))
+ << qMakePair(QLatin1String("project-file=<file>"),
+ QLatin1String("text file containing a description of the binding project. Replaces and overrides command line arguments"))
+ << qMakePair(QLatin1String("silent"),
+ QLatin1String("Avoid printing any message"))
+ << qMakePair(QLatin1String("-T") + pathSyntax, QString())
+ << qMakePair(QLatin1String("typesystem-paths=") + pathSyntax,
+ QLatin1String("Paths used when searching for typesystems"))
+ << qMakePair(QLatin1String("version"),
+ QLatin1String("Output version information and exit"));
printOptions(s, generalOptions);
const Generators generators = shibokenGenerators() + docGenerators();
- foreach (const GeneratorPtr &generator, generators) {
- QMap<QString, QString> options = generator->options();
+ for (const GeneratorPtr &generator : generators) {
+ const OptionDescriptions options = generator->options();
if (!options.isEmpty()) {
s << endl << generator->name() << " options:\n";
printOptions(s, generator->options());
@@ -437,8 +497,8 @@ int main(int argc, char *argv[])
extractor.setSuppressWarnings(false);
if (argsHandler.argExists(QLatin1String("api-version"))) {
- QStringList versions = argsHandler.removeArg(QLatin1String("api-version")).split(QLatin1Char('|'));
- foreach (const QString &fullVersion, versions) {
+ const QStringList &versions = argsHandler.removeArg(QLatin1String("api-version")).split(QLatin1Char('|'));
+ for (const QString &fullVersion : versions) {
QStringList parts = fullVersion.split(QLatin1Char(','));
QString package;
QString version;
@@ -460,11 +520,29 @@ int main(int argc, char *argv[])
extractor.addTypesystemSearchPath(path.split(QLatin1String(PATH_SPLITTER)));
path = argsHandler.removeArg(QLatin1String("include-paths"));
- if (!path.isEmpty())
- extractor.addIncludePath(path.split(QLatin1String(PATH_SPLITTER)));
+ if (!path.isEmpty()) {
+ const QStringList includePathListList = path.split(QLatin1String(PATH_SPLITTER));
+ for (const QString &s : qAsConst(includePathListList)) {
+ const bool isFramework = false;
+ extractor.addIncludePath(HeaderPath(s, isFramework));
+ }
+ }
+
+ path = argsHandler.removeArg(QLatin1String("framework-include-paths"));
+ if (!path.isEmpty()) {
+ const QStringList frameworkPathList = path.split(QLatin1String(PATH_SPLITTER));
+ const bool isFramework = true;
+ for (const QString &s : qAsConst(frameworkPathList)) {
+ extractor.addIncludePath(HeaderPath(s, isFramework));
+ }
+ }
QString cppFileName = argsHandler.removeArg(QLatin1String("arg-1"));
QString typeSystemFileName = argsHandler.removeArg(QLatin1String("arg-2"));
+ QString messagePrefix = QFileInfo(typeSystemFileName).baseName();
+ if (messagePrefix.startsWith(QLatin1String("typesystem_")))
+ messagePrefix.remove(0, 11);
+ ReportHandler::setPrefix(QLatin1Char('(') + messagePrefix + QLatin1Char(')'));
/* Make sure to remove the project file's arguments (if any) and
* --project-file, also the arguments of each generator before
@@ -478,18 +556,20 @@ int main(int argc, char *argv[])
for ( ; it != projectFileArgs.constEnd(); ++it)
argsHandler.removeArg(it.key());
}
- foreach (const GeneratorPtr &generator, generators) {
- QMap<QString, QString> options = generator->options();
- if (!options.isEmpty()) {
- QMap<QString, QString>::const_iterator it = options.constBegin();
- for ( ; it != options.constEnd(); ++it)
- argsHandler.removeArg(it.key());
- }
+ for (const GeneratorPtr &generator : qAsConst(generators)) {
+ const OptionDescriptions &options = generator->options();
+ for (const auto &od : options)
+ argsHandler.removeArg(od.first);
}
if (!argsHandler.noArgs()) {
errorPrint(argsHandler.errorMessage());
- std::cout << "Note: use --help option for more information." << std::endl;
+ std::cout << helpHint;
+ return EXIT_FAILURE;
+ }
+
+ if (typeSystemFileName.isEmpty()) {
+ std::cout << "You must specify a Type System file." << std::endl << helpHint;
return EXIT_FAILURE;
}
@@ -505,7 +585,7 @@ int main(int argc, char *argv[])
qCDebug(lcShiboken) << extractor;
- foreach (const GeneratorPtr &g, generators) {
+ for (const GeneratorPtr &g : qAsConst(generators)) {
g->setOutputDirectory(outputDirectory);
g->setLicenseComment(licenseComment);
if (g->setup(extractor, args)) {
diff --git a/sources/shiboken2/generator/qtdoc/qtdocgenerator.cpp b/sources/shiboken2/generator/qtdoc/qtdocgenerator.cpp
index a7a176907..014b44476 100644
--- a/sources/shiboken2/generator/qtdoc/qtdocgenerator.cpp
+++ b/sources/shiboken2/generator/qtdoc/qtdocgenerator.cpp
@@ -55,7 +55,8 @@ static bool shouldSkip(const AbstractMetaFunction* func)
// Search a const clone
if (!skipable && !func->isConstant()) {
const AbstractMetaArgumentList funcArgs = func->arguments();
- foreach (AbstractMetaFunction* f, func->ownerClass()->functions()) {
+ const AbstractMetaFunctionList &ownerFunctions = func->ownerClass()->functions();
+ for (AbstractMetaFunction *f : ownerFunctions) {
if (f != func
&& f->isConstant()
&& f->name() == func->name()
@@ -202,7 +203,8 @@ QString QtXmlToSphinx::expandFunction(const QString& function)
QStringList functionSpec = function.split(QLatin1Char('.'));
QString className = functionSpec.first();
const AbstractMetaClass* metaClass = 0;
- foreach (const AbstractMetaClass* cls, m_generator->classes()) {
+ const AbstractMetaClassList &classes = m_generator->classes();
+ for (const AbstractMetaClass *cls : classes) {
if (cls->name() == className) {
metaClass = cls;
break;
@@ -224,7 +226,8 @@ QString QtXmlToSphinx::resolveContextForMethod(const QString& methodName)
QString currentClass = m_context.split(QLatin1Char('.')).last();
const AbstractMetaClass* metaClass = 0;
- foreach (const AbstractMetaClass* cls, m_generator->classes()) {
+ const AbstractMetaClassList &classes = m_generator->classes();
+ for (const AbstractMetaClass *cls : classes) {
if (cls->name() == currentClass) {
metaClass = cls;
break;
@@ -233,13 +236,14 @@ QString QtXmlToSphinx::resolveContextForMethod(const QString& methodName)
if (metaClass) {
QList<const AbstractMetaFunction*> funcList;
- foreach (const AbstractMetaFunction* func, metaClass->queryFunctionsByName(methodName)) {
+ const AbstractMetaFunctionList &methods = metaClass->queryFunctionsByName(methodName);
+ for (const AbstractMetaFunction *func : methods) {
if (methodName == func->name())
funcList.append(func);
}
const AbstractMetaClass* implementingClass = 0;
- foreach (const AbstractMetaFunction* func, funcList) {
+ for (const AbstractMetaFunction *func : qAsConst(funcList)) {
implementingClass = func->implementingClass();
if (implementingClass->name() == currentClass)
break;
@@ -300,7 +304,7 @@ QString QtXmlToSphinx::readFromLocations(const QStringList& locations, const QSt
{
QString result;
bool ok;
- foreach (QString location, locations) {
+ for (QString location : locations) {
location.append(QLatin1Char('/'));
location.append(path);
result = readFromLocation(location, identifier, &ok);
@@ -466,7 +470,8 @@ void QtXmlToSphinx::handleSnippetTag(QXmlStreamReader& reader)
if (code.isEmpty()) {
m_output << INDENT << "<Code snippet \"" << location << ':' << identifier << "\" not found>" << endl;
} else {
- foreach (const QString &line, code.split(QLatin1Char('\n'))) {
+ const QStringList lines = code.split(QLatin1Char('\n'));
+ for (const QString &line : lines) {
if (!QString(line).trimmed().isEmpty())
m_output << INDENT << line;
@@ -577,7 +582,7 @@ void QtXmlToSphinx::handleListTag(QXmlStreamReader& reader)
if (!m_currentTable.isEmpty()) {
if (listType == QLatin1String("bullet")) {
m_output << endl;
- foreach (TableCell cell, m_currentTable.first()) {
+ for (const TableCell &cell : m_currentTable.constFirst()) {
QStringList itemLines = cell.data.split(QLatin1Char('\n'));
m_output << INDENT << "* " << itemLines.first() << endl;
for (int i = 1, max = itemLines.count(); i < max; ++i)
@@ -714,8 +719,8 @@ void QtXmlToSphinx::handleRawTag(QXmlStreamReader& reader)
QString format = reader.attributes().value(QLatin1String("format")).toString();
m_output << INDENT << ".. raw:: " << format.toLower() << endl << endl;
} else if (token == QXmlStreamReader::Characters) {
- QStringList lst(reader.text().toString().split(QLatin1Char('\n')));
- foreach(QString row, lst)
+ const QStringList lst(reader.text().toString().split(QLatin1Char('\n')));
+ for (const QString &row : lst)
m_output << INDENT << INDENT << row << endl;
} else if (token == QXmlStreamReader::EndElement) {
m_output << endl << endl;
@@ -730,8 +735,8 @@ void QtXmlToSphinx::handleCodeTag(QXmlStreamReader& reader)
m_output << INDENT << "::" << endl << endl;
INDENT.indent++;
} else if (token == QXmlStreamReader::Characters) {
- QStringList lst(reader.text().toString().split(QLatin1Char('\n')));
- foreach(QString row, lst)
+ const QStringList lst(reader.text().toString().split(QLatin1Char('\n')));
+ for (const QString row : lst)
m_output << INDENT << INDENT << row << endl;
} else if (token == QXmlStreamReader::EndElement) {
m_output << endl << endl;
@@ -802,7 +807,8 @@ void QtXmlToSphinx::handleQuoteFileTag(QXmlStreamReader& reader)
if (code.isEmpty()) {
m_output << INDENT << "<Code snippet \"" << location << "\" not found>" << endl;
} else {
- foreach (QString line, code.split(QLatin1Char('\n'))) {
+ const QStringList lines = code.split(QLatin1Char('\n'));
+ for (const QString &line : lines) {
if (!QString(line).trimmed().isEmpty())
m_output << INDENT << line;
@@ -882,8 +888,8 @@ QTextStream& operator<<(QTextStream& s, const QtXmlToSphinx::Table &table)
for (int i = 0, maxI = table.count(); i < maxI; ++i) {
const QtXmlToSphinx::TableRow& row = table[i];
for (int j = 0, maxJ = std::min(row.count(), colWidths.size()); j < maxJ; ++j) {
- QStringList rowLines = row[j].data.split(QLatin1Char('\n')); // cache this would be a good idea
- foreach (QString str, rowLines)
+ const QStringList rowLines = row[j].data.split(QLatin1Char('\n')); // cache this would be a good idea
+ for (const QString &str : rowLines)
colWidths[j] = std::max(colWidths[j], str.count());
rowHeights[i] = std::max(rowHeights[i], row[j].data.count(QLatin1Char('\n')) + 1);
}
@@ -1018,16 +1024,16 @@ void QtDocGenerator::writeFormatedText(QTextStream& s, const Documentation& doc,
QtXmlToSphinx x(this, doc.value(), metaClassName);
s << x;
} else {
- QStringList lines = doc.value().split(QLatin1Char('\n'));
+ const QStringList lines = doc.value().split(QLatin1Char('\n'));
QRegExp regex(QLatin1String("\\S")); // non-space character
int typesystemIndentation = std::numeric_limits<int>().max();
// check how many spaces must be removed from the begining of each line
- foreach (QString line, lines) {
+ for (const QString &line : lines) {
int idx = line.indexOf(regex);
if (idx >= 0)
typesystemIndentation = qMin(typesystemIndentation, idx);
}
- foreach (QString line, lines)
+ for (QString line : lines)
s << INDENT << line.remove(0, typesystemIndentation) << endl;
}
@@ -1037,7 +1043,7 @@ void QtDocGenerator::writeFormatedText(QTextStream& s, const Documentation& doc,
static void writeInheritedByList(QTextStream& s, const AbstractMetaClass* metaClass, const AbstractMetaClassList& allClasses)
{
AbstractMetaClassList res;
- foreach (AbstractMetaClass* c, allClasses) {
+ for (AbstractMetaClass *c : allClasses) {
if (c != metaClass && c->inheritsFrom(metaClass))
res << c;
}
@@ -1047,7 +1053,7 @@ static void writeInheritedByList(QTextStream& s, const AbstractMetaClass* metaCl
s << "**Inherited by:** ";
QStringList classes;
- foreach (AbstractMetaClass* c, res)
+ for (AbstractMetaClass *c : qAsConst(res))
classes << QLatin1String(":ref:`") + getClassTargetFullName(c, false) + QLatin1Char('`');
s << classes.join(QLatin1String(", ")) << endl << endl;
}
@@ -1098,7 +1104,7 @@ void QtDocGenerator::generateClass(QTextStream &s, GeneratorContext &classContex
writeFields(s, metaClass);
- foreach (AbstractMetaFunction* func, functionList) {
+ for (AbstractMetaFunction *func : qAsConst(functionList)) {
if (shouldSkip(func))
continue;
@@ -1121,7 +1127,8 @@ void QtDocGenerator::writeFunctionList(QTextStream& s, const AbstractMetaClass*
QStringList slotList;
QStringList staticFunctionList;
- foreach (AbstractMetaFunction* func, cppClass->functions()) {
+ const AbstractMetaFunctionList &classFunctions = cppClass->functions();
+ for (AbstractMetaFunction *func : classFunctions) {
if (shouldSkip(func))
continue;
@@ -1180,7 +1187,7 @@ void QtDocGenerator::writeFunctionBlock(QTextStream& s, const QString& title, QS
s << ".. container:: function_list" << endl << endl;
Indentation indentation(INDENT);
- foreach (QString func, functions)
+ for (const QString &func : qAsConst(functions))
s << '*' << INDENT << func << endl;
s << endl << endl;
@@ -1191,7 +1198,8 @@ void QtDocGenerator::writeEnums(QTextStream& s, const AbstractMetaClass* cppClas
{
static const QString section_title = QLatin1String(".. attribute:: ");
- foreach (AbstractMetaEnum* en, cppClass->enums()) {
+ const AbstractMetaEnumList &enums = cppClass->enums();
+ for (AbstractMetaEnum *en : enums) {
s << section_title << getClassTargetFullName(cppClass) << '.' << en->name() << endl << endl;
writeFormatedText(s, en->documentation(), cppClass);
@@ -1205,7 +1213,8 @@ void QtDocGenerator::writeFields(QTextStream& s, const AbstractMetaClass* cppCla
{
static const QString section_title = QLatin1String(".. attribute:: ");
- foreach (AbstractMetaField* field, cppClass->fields()) {
+ const AbstractMetaFieldList &fields = cppClass->fields();
+ for (AbstractMetaField *field : fields) {
s << section_title << getClassTargetFullName(cppClass) << "." << field->name() << endl << endl;
//TODO: request for member ‘documentation’ is ambiguous
writeFormatedText(s, field->AbstractMetaAttributes::documentation(), cppClass);
@@ -1217,12 +1226,12 @@ void QtDocGenerator::writeConstructors(QTextStream& s, const AbstractMetaClass*
static const QString sectionTitle = QLatin1String(".. class:: ");
static const QString sectionTitleSpace = QString(sectionTitle.size(), QLatin1Char(' '));
- AbstractMetaFunctionList lst = cppClass->queryFunctions(AbstractMetaClass::Constructors | AbstractMetaClass::Visible);
+ const AbstractMetaFunctionList lst = cppClass->queryFunctions(AbstractMetaClass::Constructors | AbstractMetaClass::Visible);
bool first = true;
QHash<QString, AbstractMetaArgument*> arg_map;
- foreach(AbstractMetaFunction* func, lst) {
+ for (AbstractMetaFunction *func : lst) {
if (func->isModifiedRemoved())
continue;
@@ -1233,8 +1242,8 @@ void QtDocGenerator::writeConstructors(QTextStream& s, const AbstractMetaClass*
s << sectionTitleSpace;
}
writeFunction(s, false, cppClass, func);
- foreach(AbstractMetaArgument* arg, func->arguments())
- {
+ const AbstractMetaArgumentList &arguments = func->arguments();
+ for (AbstractMetaArgument *arg : arguments) {
if (!arg_map.contains(arg->name())) {
arg_map.insert(arg->name(), arg);
}
@@ -1243,16 +1252,15 @@ void QtDocGenerator::writeConstructors(QTextStream& s, const AbstractMetaClass*
s << endl;
- foreach (AbstractMetaArgument* arg, arg_map.values()) {
+ for (QHash<QString, AbstractMetaArgument*>::const_iterator it = arg_map.cbegin(), end = arg_map.cend(); it != end; ++it) {
Indentation indentation(INDENT);
- writeParamerteType(s, cppClass, arg);
+ writeParamerteType(s, cppClass, it.value());
}
s << endl;
- foreach (AbstractMetaFunction* func, lst) {
+ for (AbstractMetaFunction *func : lst)
writeFormatedText(s, func->documentation(), cppClass);
- }
}
QString QtDocGenerator::parseArgDocStyle(const AbstractMetaClass* cppClass, const AbstractMetaFunction* func)
@@ -1260,7 +1268,8 @@ QString QtDocGenerator::parseArgDocStyle(const AbstractMetaClass* cppClass, cons
QString ret;
int optArgs = 0;
- foreach (AbstractMetaArgument* arg, func->arguments()) {
+ const AbstractMetaArgumentList &arguments = func->arguments();
+ for (AbstractMetaArgument *arg : arguments) {
if (func->argumentRemoved(arg->argumentIndex() + 1))
continue;
@@ -1311,7 +1320,7 @@ void QtDocGenerator::writeDocSnips(QTextStream &s,
invalidStrings << QLatin1String("*") << QLatin1String("//") << QLatin1String("/*") << QLatin1String("*/");
- foreach (CodeSnip snip, codeSnips) {
+ for (const CodeSnip &snip : codeSnips) {
if ((snip.position != position) ||
!(snip.language & language))
continue;
@@ -1325,14 +1334,13 @@ void QtDocGenerator::writeDocSnips(QTextStream &s,
break;
QString codeBlock = code.mid(startBlock, endBlock - startBlock);
- QStringList rows = codeBlock.split(QLatin1Char('\n'));
+ const QStringList rows = codeBlock.split(QLatin1Char('\n'));
int currenRow = 0;
int offset = 0;
- foreach(QString row, rows) {
- foreach(QString invalidString, invalidStrings) {
- row = row.remove(invalidString);
- }
+ for (QString row : rows) {
+ for (const QString &invalidString : qAsConst(invalidStrings))
+ row.remove(invalidString);
if (row.trimmed().size() == 0) {
if (currenRow == 0)
@@ -1370,7 +1378,8 @@ bool QtDocGenerator::writeInjectDocumentation(QTextStream& s,
Indentation indentation(INDENT);
bool didSomething = false;
- foreach (DocModification mod, cppClass->typeEntry()->docModifications()) {
+ const DocModificationList &mods = cppClass->typeEntry()->docModifications();
+ for (const DocModification &mod : mods) {
if (mod.mode() == mode) {
bool modOk = func ? mod.signature() == func->minimalSignature() : mod.signature().isEmpty();
@@ -1473,7 +1482,8 @@ void QtDocGenerator::writeFunctionParametersType(QTextStream& s, const AbstractM
Indentation indentation(INDENT);
s << endl;
- foreach (AbstractMetaArgument* arg, func->arguments()) {
+ const AbstractMetaArgumentList &funcArgs = func->arguments();
+ for (AbstractMetaArgument *arg : funcArgs) {
if (func->argumentRemoved(arg->argumentIndex() + 1))
continue;
@@ -1485,8 +1495,9 @@ void QtDocGenerator::writeFunctionParametersType(QTextStream& s, const AbstractM
QString retType;
// check if the return type was modified
- foreach (FunctionModification mod, func->modifications()) {
- foreach (ArgumentModification argMod, mod.argument_mods) {
+ const FunctionModificationList &mods = func->modifications();
+ for (const FunctionModification &mod : mods) {
+ for (const ArgumentModification &argMod : mod.argument_mods) {
if (argMod.index == 0) {
retType = argMod.modified_type;
break;
@@ -1526,7 +1537,7 @@ static void writeFancyToc(QTextStream& s, const QStringList& items, int cols = 4
TocMap tocMap;
QChar Q = QLatin1Char('Q');
QChar idx;
- foreach (QString item, items) {
+ for (QString item : items) {
if (item.isEmpty())
continue;
if (item.startsWith(Q) && item.length() > 1)
@@ -1551,7 +1562,7 @@ static void writeFancyToc(QTextStream& s, const QStringList& items, int cols = 4
ss << "**" << it.key() << "**" << endl << endl;
i += 2; // a letter title is equivalent to two entries in space
- foreach (QString item, it.value()) {
+ for (const QString &item : qAsConst(it.value())) {
ss << "* :doc:`" << item << "`" << endl;
++i;
@@ -1628,7 +1639,7 @@ bool QtDocGenerator::finishGeneration()
s << INDENT << ".. toctree::" << endl;
Indentation deeperIndentation(INDENT);
s << INDENT << ":maxdepth: 1" << endl << endl;
- foreach (QString className, it.value())
+ for (const QString &className : qAsConst(it.value()))
s << INDENT << className << endl;
s << endl << endl;
}
@@ -1686,19 +1697,18 @@ bool QtDocGenerator::doSetup(const QMap<QString, QString>& args)
}
-QMap<QString, QString> QtDocGenerator::options() const
+Generator::OptionDescriptions QtDocGenerator::options() const
{
- QMap<QString, QString> options;
- options.insert(QLatin1String("doc-parser"),
- QLatin1String("The documentation parser used to interpret the documentation input files (qdoc3|doxygen)"));
- options.insert(QLatin1String("library-source-dir"),
- QLatin1String("Directory where library source code is located"));
- options.insert(QLatin1String("documentation-data-dir"),
- QLatin1String("Directory with XML files generated by documentation tool (qdoc3 or Doxygen)"));
- options.insert(QLatin1String("documentation-code-snippets-dir"),
- QLatin1String("Directory used to search code snippets used by the documentation"));
- options.insert(QLatin1String("documentation-extra-sections-dir"),
- QLatin1String("Directory used to search for extra documentation sections"));
- return options;
+ return OptionDescriptions()
+ << qMakePair(QLatin1String("doc-parser"),
+ QLatin1String("The documentation parser used to interpret the documentation input files (qdoc3|doxygen)"))
+ << qMakePair(QLatin1String("documentation-code-snippets-dir"),
+ QLatin1String("Directory used to search code snippets used by the documentation"))
+ << qMakePair(QLatin1String("documentation-data-dir"),
+ QLatin1String("Directory with XML files generated by documentation tool (qdoc3 or Doxygen)"))
+ << qMakePair(QLatin1String("documentation-extra-sections-dir"),
+ QLatin1String("Directory used to search for extra documentation sections"))
+ << qMakePair(QLatin1String("library-source-dir"),
+ QLatin1String("Directory where library source code is located"));
}
diff --git a/sources/shiboken2/generator/qtdoc/qtdocgenerator.h b/sources/shiboken2/generator/qtdoc/qtdocgenerator.h
index fa8524b21..6ba9e7907 100644
--- a/sources/shiboken2/generator/qtdoc/qtdocgenerator.h
+++ b/sources/shiboken2/generator/qtdoc/qtdocgenerator.h
@@ -186,7 +186,7 @@ public:
return "QtDocGenerator";
}
- QMap<QString, QString> options() const;
+ OptionDescriptions options() const;
QStringList codeSnippetDirs() const
{
diff --git a/sources/shiboken2/generator/shiboken2/cppgenerator.cpp b/sources/shiboken2/generator/shiboken2/cppgenerator.cpp
index a2b497132..74861e3d4 100644
--- a/sources/shiboken2/generator/shiboken2/cppgenerator.cpp
+++ b/sources/shiboken2/generator/shiboken2/cppgenerator.cpp
@@ -36,6 +36,7 @@
#include <QtCore/QDir>
#include <QtCore/QMetaObject>
+#include <QtCore/QRegularExpression>
#include <QtCore/QTextStream>
#include <QtCore/QDebug>
#include <QMetaType>
@@ -153,13 +154,15 @@ QString CppGenerator::fileNameForContext(GeneratorContext &context) const
}
}
-QList<AbstractMetaFunctionList> CppGenerator::filterGroupedOperatorFunctions(const AbstractMetaClass* metaClass,
+QVector<AbstractMetaFunctionList> CppGenerator::filterGroupedOperatorFunctions(const AbstractMetaClass* metaClass,
uint queryIn)
{
// ( func_name, num_args ) => func_list
- QMap<QPair<QString, int >, AbstractMetaFunctionList> results;
+ typedef QMap<QPair<QString, int >, AbstractMetaFunctionList> ResultMap;
+ ResultMap results;
const AbstractMetaClass::OperatorQueryOptions query(queryIn);
- foreach (AbstractMetaFunction* func, metaClass->operatorOverloads(query)) {
+ const AbstractMetaFunctionList &funcs = metaClass->operatorOverloads(query);
+ for (AbstractMetaFunction *func : funcs) {
if (func->isModifiedRemoved()
|| func->usesRValueReferences()
|| func->name() == QLatin1String("operator[]")
@@ -176,7 +179,11 @@ QList<AbstractMetaFunctionList> CppGenerator::filterGroupedOperatorFunctions(con
QPair<QString, int > op(func->name(), args);
results[op].append(func);
}
- return results.values();
+ QVector<AbstractMetaFunctionList> result;
+ result.reserve(results.size());
+ for (ResultMap::const_iterator it = results.cbegin(), end = results.cend(); it != end; ++it)
+ result.append(it.value());
+ return result;
}
bool CppGenerator::hasBoolCast(const AbstractMetaClass* metaClass) const
@@ -203,6 +210,13 @@ static const char includeQDebug[] =
"#endif\n"
"#include <QDebug>\n";
+static QString chopType(QString s)
+{
+ if (s.endsWith(QLatin1String("_Type")))
+ s.chop(5);
+ return s;
+}
+
/*!
Function used to write the class generated binding code on the buffer
\param s the output buffer
@@ -252,7 +266,8 @@ void CppGenerator::generateClass(QTextStream &s, GeneratorContext &classContext)
s << endl << "// main header" << endl << "#include \"" << headerfile << '"' << endl;
s << endl << "// inner classes" << endl;
- foreach (AbstractMetaClass* innerClass, metaClass->innerClasses()) {
+ const AbstractMetaClassList &innerClasses = metaClass->innerClasses();
+ for (AbstractMetaClass *innerClass : innerClasses) {
GeneratorContext innerClassContext(innerClass);
if (shouldGenerate(innerClass)) {
QString headerfile = fileNameForContext(innerClassContext);
@@ -262,16 +277,16 @@ void CppGenerator::generateClass(QTextStream &s, GeneratorContext &classContext)
}
AbstractMetaEnumList classEnums = metaClass->enums();
- foreach (AbstractMetaClass* innerClass, metaClass->innerClasses())
+ for (AbstractMetaClass *innerClass : innerClasses)
lookForEnumsInClassesNotToBeGenerated(classEnums, innerClass);
//Extra includes
s << endl << "// Extra includes" << endl;
- QList<Include> includes = metaClass->typeEntry()->extraIncludes();
- foreach (AbstractMetaEnum* cppEnum, classEnums)
+ QVector<Include> includes = metaClass->typeEntry()->extraIncludes();
+ for (AbstractMetaEnum *cppEnum : qAsConst(classEnums))
includes.append(cppEnum->typeEntry()->extraIncludes());
qSort(includes.begin(), includes.end());
- foreach (const Include &inc, includes)
+ for (const Include &inc : qAsConst(includes))
s << inc.toString() << endl;
s << endl;
@@ -324,7 +339,8 @@ void CppGenerator::generateClass(QTextStream &s, GeneratorContext &classContext)
s << "}\n\n";
}
- foreach (const AbstractMetaFunction* func, filterFunctions(metaClass)) {
+ const AbstractMetaFunctionList &funcs = filterFunctions(metaClass);
+ for (const AbstractMetaFunction *func : funcs) {
if ((func->isPrivate() && !visibilityModifiedToPrivate(func))
|| (func->isModifiedRemoved() && !func->isAbstract()))
continue;
@@ -357,7 +373,7 @@ void CppGenerator::generateClass(QTextStream &s, GeneratorContext &classContext)
for (FunctionGroupMapIt it = functionGroups.cbegin(), end = functionGroups.cend(); it != end; ++it) {
AbstractMetaFunctionList overloads;
QSet<QString> seenSignatures;
- foreach (AbstractMetaFunction* func, it.value()) {
+ for (AbstractMetaFunction *func : it.value()) {
if (!func->isAssignmentOperator()
&& !func->usesRValueReferences()
&& !func->isCastOperator()
@@ -434,8 +450,7 @@ void CppGenerator::generateClass(QTextStream &s, GeneratorContext &classContext)
}
}
- QString className = cpythonTypeName(metaClass);
- className.remove(QRegExp(QLatin1String("_Type$")));
+ const QString className = chopType(cpythonTypeName(metaClass));
if (metaClass->typeEntry()->isValue() || metaClass->typeEntry()->isSmartPointer()) {
writeCopyFunction(s, classContext);
@@ -484,15 +499,15 @@ void CppGenerator::generateClass(QTextStream &s, GeneratorContext &classContext)
}
if (supportsNumberProtocol(metaClass) && !metaClass->typeEntry()->isSmartPointer()) {
- QList<AbstractMetaFunctionList> opOverloads = filterGroupedOperatorFunctions(
+ const QVector<AbstractMetaFunctionList> opOverloads = filterGroupedOperatorFunctions(
metaClass,
AbstractMetaClass::ArithmeticOp
| AbstractMetaClass::LogicalOp
| AbstractMetaClass::BitwiseOp);
- foreach (const AbstractMetaFunctionList &allOverloads, opOverloads) {
+ for (const AbstractMetaFunctionList &allOverloads : opOverloads) {
AbstractMetaFunctionList overloads;
- foreach (AbstractMetaFunction* func, allOverloads) {
+ for (AbstractMetaFunction *func : allOverloads) {
if (!func->isModifiedRemoved()
&& !func->isPrivate()
&& (func->ownerClass() == func->implementingClass() || func->isAbstract()))
@@ -521,7 +536,8 @@ void CppGenerator::generateClass(QTextStream &s, GeneratorContext &classContext)
}
if (shouldGenerateGetSetList(metaClass) && !classContext.forSmartPointer()) {
- foreach (const AbstractMetaField* metaField, metaClass->fields()) {
+ const AbstractMetaFieldList &fields = metaClass->fields();
+ for (const AbstractMetaField *metaField : fields) {
if (metaField->isStatic())
continue;
writeGetterFunction(s, metaField, classContext);
@@ -532,7 +548,7 @@ void CppGenerator::generateClass(QTextStream &s, GeneratorContext &classContext)
s << "// Getters and Setters for " << metaClass->name() << endl;
s << "static PyGetSetDef " << cpythonGettersSettersDefinitionName(metaClass) << "[] = {" << endl;
- foreach (const AbstractMetaField* metaField, metaClass->fields()) {
+ for (const AbstractMetaField *metaField : fields) {
if (metaField->isStatic())
continue;
@@ -562,7 +578,7 @@ void CppGenerator::generateClass(QTextStream &s, GeneratorContext &classContext)
writeTypeDiscoveryFunction(s, metaClass);
- foreach (AbstractMetaEnum* cppEnum, classEnums) {
+ for (AbstractMetaEnum *cppEnum : qAsConst(classEnums)) {
if (cppEnum->isAnonymous() || cppEnum->isPrivate())
continue;
@@ -614,7 +630,8 @@ static bool allArgumentsRemoved(const AbstractMetaFunction* func)
{
if (func->arguments().isEmpty())
return false;
- foreach (const AbstractMetaArgument* arg, func->arguments()) {
+ const AbstractMetaArgumentList &arguments = func->arguments();
+ for (const AbstractMetaArgument *arg : arguments) {
if (!func->argumentRemoved(arg->argumentIndex() + 1))
return false;
}
@@ -666,19 +683,24 @@ void CppGenerator::writeVirtualMethodNative(QTextStream&s, const AbstractMetaFun
QString defaultReturnExpr;
if (retType) {
- foreach (const FunctionModification &mod, func->modifications()) {
- foreach (const ArgumentModification &argMod, mod.argument_mods) {
+ const FunctionModificationList &mods = func->modifications();
+ for (const FunctionModification &mod : mods) {
+ for (const ArgumentModification &argMod : mod.argument_mods) {
if (argMod.index == 0 && !argMod.replacedDefaultExpression.isEmpty()) {
- QRegExp regex(QLatin1String("%(\\d+)"));
+ static const QRegularExpression regex(QStringLiteral("%(\\d+)"));
+ Q_ASSERT(regex.isValid());
defaultReturnExpr = argMod.replacedDefaultExpression;
- int offset = 0;
- while ((offset = regex.indexIn(defaultReturnExpr, offset)) != -1) {
- int argId = regex.cap(1).toInt() - 1;
+ for (int offset = 0; ; ) {
+ const QRegularExpressionMatch match = regex.match(defaultReturnExpr, offset);
+ if (!match.hasMatch())
+ break;
+ const int argId = match.capturedRef(1).toInt() - 1;
if (argId < 0 || argId > func->arguments().count()) {
qCWarning(lcShiboken) << "The expression used in return value contains an invalid index.";
break;
}
- defaultReturnExpr.replace(regex.cap(0), func->arguments()[argId]->name());
+ defaultReturnExpr.replace(match.captured(0), func->arguments()[argId]->name());
+ offset = match.capturedStart(1);
}
}
}
@@ -764,7 +786,8 @@ void CppGenerator::writeVirtualMethodNative(QTextStream&s, const AbstractMetaFun
s << "PyTuple_New(0));" << endl;
} else {
QStringList argConversions;
- foreach (const AbstractMetaArgument* arg, func->arguments()) {
+ const AbstractMetaArgumentList &arguments = func->arguments();
+ for (const AbstractMetaArgument *arg : arguments) {
if (func->argumentRemoved(arg->argumentIndex() + 1))
continue;
@@ -810,8 +833,9 @@ void CppGenerator::writeVirtualMethodNative(QTextStream&s, const AbstractMetaFun
bool invalidateReturn = false;
QSet<int> invalidateArgs;
- foreach (const FunctionModification &funcMod, func->modifications()) {
- foreach (const ArgumentModification &argMod, funcMod.argument_mods) {
+ const FunctionModificationList &mods = func->modifications();
+ for (const FunctionModification &funcMod : mods) {
+ for (const ArgumentModification &argMod : funcMod.argument_mods) {
if (argMod.resetAfterUse && !invalidateArgs.contains(argMod.index)) {
invalidateArgs.insert(argMod.index);
s << INDENT << "bool invalidateArg" << argMod.index;
@@ -908,7 +932,7 @@ void CppGenerator::writeVirtualMethodNative(QTextStream&s, const AbstractMetaFun
Indentation indentation(INDENT);
s << INDENT << "Shiboken::Object::releaseOwnership(" << PYTHON_RETURN_VAR ".object());" << endl;
}
- foreach (int argIndex, invalidateArgs) {
+ for (int argIndex : qAsConst(invalidateArgs)) {
s << INDENT << "if (invalidateArg" << argIndex << ')' << endl;
Indentation indentation(INDENT);
s << INDENT << "Shiboken::Object::invalidate(PyTuple_GET_ITEM(" PYTHON_ARGS ", ";
@@ -916,8 +940,9 @@ void CppGenerator::writeVirtualMethodNative(QTextStream&s, const AbstractMetaFun
}
- foreach (const FunctionModification &funcMod, func->modifications()) {
- foreach (const ArgumentModification &argMod, funcMod.argument_mods) {
+ const FunctionModificationList &funcMods = func->modifications();
+ for (const FunctionModification &funcMod : funcMods) {
+ for (const ArgumentModification &argMod : funcMod.argument_mods) {
if (argMod.ownerships.contains(TypeSystem::NativeCode)
&& argMod.index == 0 && argMod.ownerships[TypeSystem::NativeCode] == TypeSystem::CppOwnership) {
s << INDENT << "if (Shiboken::Object::checkType(" PYTHON_RETURN_VAR "))" << endl;
@@ -1090,11 +1115,12 @@ void CppGenerator::writeConverterFunctions(QTextStream &s, const AbstractMetaCla
s << "// Type conversion functions." << endl << endl;
AbstractMetaEnumList classEnums = metaClass->enums();
- foreach (AbstractMetaClass* innerClass, metaClass->innerClasses())
+ const AbstractMetaClassList &innerClasses = metaClass->innerClasses();
+ for (AbstractMetaClass *innerClass : innerClasses)
lookForEnumsInClassesNotToBeGenerated(classEnums, innerClass);
if (!classEnums.isEmpty())
s << "// Python to C++ enum conversion." << endl;
- foreach (const AbstractMetaEnum* metaEnum, classEnums)
+ for (const AbstractMetaEnum *metaEnum : qAsConst(classEnums))
writeEnumConverterFunctions(s, metaEnum);
if (metaClass->isNamespace())
@@ -1204,7 +1230,8 @@ void CppGenerator::writeConverterFunctions(QTextStream &s, const AbstractMetaCla
// Implicit conversions.
AbstractMetaFunctionList implicitConvs;
if (!customConversion || !customConversion->replaceOriginalTargetToNativeConversions()) {
- foreach (AbstractMetaFunction* func, implicitConversions(metaClass->typeEntry())) {
+ const AbstractMetaFunctionList &allImplicitConvs = implicitConversions(metaClass->typeEntry());
+ for (AbstractMetaFunction *func : allImplicitConvs) {
if (!func->isUserAdded())
implicitConvs << func;
}
@@ -1214,7 +1241,7 @@ void CppGenerator::writeConverterFunctions(QTextStream &s, const AbstractMetaCla
s << "// Implicit conversions." << endl;
AbstractMetaType* targetType = buildAbstractMetaTypeFromAbstractMetaClass(metaClass);
- foreach (const AbstractMetaFunction* conv, implicitConvs) {
+ for (const AbstractMetaFunction* conv : qAsConst(implicitConvs)) {
if (conv->isModifiedRemoved())
continue;
@@ -1288,7 +1315,7 @@ void CppGenerator::writeCustomConverterFunctions(QTextStream& s, const CustomCon
if (toCppConversions.isEmpty())
return;
s << "// Python to C++ conversions for type '" << customConversion->ownerType()->qualifiedCppName() << "'." << endl;
- foreach (CustomConversion::TargetToNativeConversion* toNative, toCppConversions)
+ for (CustomConversion::TargetToNativeConversion *toNative : toCppConversions)
writePythonToCppConversionFunctions(s, toNative, customConversion->ownerType());
s << endl;
}
@@ -1368,7 +1395,8 @@ void CppGenerator::writeConverterRegister(QTextStream &s, const AbstractMetaClas
// Add implicit conversions.
AbstractMetaFunctionList implicitConvs;
if (!customConversion || !customConversion->replaceOriginalTargetToNativeConversions()) {
- foreach (AbstractMetaFunction* func, implicitConversions(metaClass->typeEntry())) {
+ const AbstractMetaFunctionList &allImplicitConvs = implicitConversions(metaClass->typeEntry());
+ for (AbstractMetaFunction *func : allImplicitConvs) {
if (!func->isUserAdded())
implicitConvs << func;
}
@@ -1378,7 +1406,7 @@ void CppGenerator::writeConverterRegister(QTextStream &s, const AbstractMetaClas
s << INDENT << "// Add implicit conversions to type converter." << endl;
AbstractMetaType* targetType = buildAbstractMetaTypeFromAbstractMetaClass(metaClass);
- foreach (const AbstractMetaFunction* conv, implicitConvs) {
+ for (const AbstractMetaFunction *conv : qAsConst(implicitConvs)) {
if (conv->isModifiedRemoved())
continue;
const AbstractMetaType* sourceType;
@@ -1406,7 +1434,7 @@ void CppGenerator::writeCustomConverterRegister(QTextStream& s, const CustomConv
if (toCppConversions.isEmpty())
return;
s << INDENT << "// Add user defined implicit conversions to type converter." << endl;
- foreach (CustomConversion::TargetToNativeConversion* toNative, toCppConversions) {
+ for (CustomConversion::TargetToNativeConversion *toNative : toCppConversions) {
QString toCpp = pythonToCppFunctionName(toNative, customConversion->ownerType());
QString isConv = convertibleToCppFunctionName(toNative, customConversion->ownerType());
writeAddPythonToCppConversion(s, converterVar, toCpp, isConv);
@@ -1516,8 +1544,10 @@ void CppGenerator::writeConstructorWrapper(QTextStream &s, const AbstractMetaFun
QSet<QString> argNamesSet;
if (usePySideExtensions() && metaClass->isQObject()) {
// Write argNames variable with all known argument names.
- foreach (const AbstractMetaFunction* func, overloadData.overloads()) {
- foreach (const AbstractMetaArgument* arg, func->arguments()) {
+ const OverloadData::MetaFunctionList &overloads = overloadData.overloads();
+ for (const AbstractMetaFunction *func : overloads) {
+ const AbstractMetaArgumentList &arguments = func->arguments();
+ for (const AbstractMetaArgument *arg : arguments) {
if (arg->defaultValueExpression().isEmpty() || func->argumentRemoved(arg->argumentIndex() + 1))
continue;
argNamesSet << arg->name();
@@ -1621,8 +1651,9 @@ void CppGenerator::writeConstructorWrapper(QTextStream &s, const AbstractMetaFun
// Constructor code injections, position=end
bool hasCodeInjectionsAtEnd = false;
- foreach(AbstractMetaFunction* func, overloads) {
- foreach (const CodeSnip &cs, func->injectedCodeSnips()) {
+ for (AbstractMetaFunction *func : overloads) {
+ const CodeSnipList &injectedCodeSnips = func->injectedCodeSnips();
+ for (const CodeSnip &cs : injectedCodeSnips) {
if (cs.position == TypeSystem::CodeSnipPositionEnd) {
hasCodeInjectionsAtEnd = true;
break;
@@ -1632,9 +1663,10 @@ void CppGenerator::writeConstructorWrapper(QTextStream &s, const AbstractMetaFun
if (hasCodeInjectionsAtEnd) {
// FIXME: C++ arguments are not available in code injection on constructor when position = end.
s << INDENT << "switch(overloadId) {" << endl;
- foreach(AbstractMetaFunction* func, overloads) {
+ for (AbstractMetaFunction *func : overloads) {
Indentation indent(INDENT);
- foreach (const CodeSnip &cs, func->injectedCodeSnips()) {
+ const CodeSnipList &injectedCodeSnips = func->injectedCodeSnips();
+ for (const CodeSnip &cs : injectedCodeSnips) {
if (cs.position == TypeSystem::CodeSnipPositionEnd) {
s << INDENT << "case " << metaClass->functions().indexOf(func) << ':' << endl;
s << INDENT << '{' << endl;
@@ -1812,10 +1844,10 @@ void CppGenerator::writeArgumentsInitializer(QTextStream& s, OverloadData& overl
s << INDENT << '}';
}
}
- QList<int> invalidArgsLength = overloadData.invalidArgumentLengths();
+ const QVector<int> invalidArgsLength = overloadData.invalidArgumentLengths();
if (!invalidArgsLength.isEmpty()) {
QStringList invArgsLen;
- foreach (int i, invalidArgsLength)
+ for (int i : qAsConst(invalidArgsLength))
invArgsLen << QStringLiteral("numArgs == %1").arg(i);
if (usesNamedArguments && (!ownerClassIsQObject || minArgs > 0))
s << " else ";
@@ -1943,9 +1975,11 @@ void CppGenerator::writeErrorSection(QTextStream& s, OverloadData& overloadData)
s << INDENT << "Shiboken::setErrorAboutWrongArguments(" << argsVar << ", \"" << funcName << "\", 0);" << endl;
} else {
QStringList overloadSignatures;
- foreach (const AbstractMetaFunction* f, overloadData.overloads()) {
+ const OverloadData::MetaFunctionList &overloads = overloadData.overloads();
+ for (const AbstractMetaFunction *f : overloads) {
QStringList args;
- foreach(AbstractMetaArgument* arg, f->arguments()) {
+ const AbstractMetaArgumentList &arguments = f->arguments();
+ for (AbstractMetaArgument *arg : arguments) {
QString strArg;
AbstractMetaType* argType = arg->type();
if (isCString(argType)) {
@@ -1961,7 +1995,9 @@ void CppGenerator::writeErrorSection(QTextStream& s, OverloadData& overloadData)
strArg = QLatin1String("1-unicode");
} else {
strArg = ptp->name();
- strArg.remove(QRegExp(QLatin1String("^signed\\s+")));
+ static const QRegularExpression regex(QStringLiteral("^signed\\s+"));
+ Q_ASSERT(regex.isValid());
+ strArg.remove(regex);
if (strArg == QLatin1String("double"))
strArg = QLatin1String("float");
}
@@ -2043,9 +2079,13 @@ void CppGenerator::writeInvalidPyObjectCheck(QTextStream& s, const QString& pyOb
static QString pythonToCppConverterForArgumentName(const QString& argumentName)
{
- static QRegExp pyArgsRegex(QLatin1String(PYTHON_ARGS"(\\[\\d+[-]?\\d*\\])"));
- pyArgsRegex.indexIn(argumentName);
- return QLatin1String(PYTHON_TO_CPP_VAR) + pyArgsRegex.cap(1);
+ static const QRegularExpression pyArgsRegex(QLatin1String(PYTHON_ARGS"(\\[\\d+[-]?\\d*\\])"));
+ Q_ASSERT(pyArgsRegex.isValid());
+ const QRegularExpressionMatch match = pyArgsRegex.match(argumentName);
+ QString result = QLatin1String(PYTHON_TO_CPP_VAR);
+ if (match.hasMatch())
+ result += match.captured(1);
+ return result;
}
void CppGenerator::writeTypeCheck(QTextStream& s, const AbstractMetaType* argType, QString argumentName, bool isNumber, QString customType, bool rejectNull)
@@ -2085,20 +2125,26 @@ static void checkTypeViability(const AbstractMetaFunction* func, const AbstractM
if (!type
|| !type->typeEntry()->isPrimitive()
|| type->indirections() == 0
+ || (type->indirections() == 1 && type->typeUsagePattern() == AbstractMetaType::NativePointerAsArrayPattern)
|| ShibokenGenerator::isCString(type)
|| func->argumentRemoved(argIdx)
|| !func->typeReplaced(argIdx).isEmpty()
|| !func->conversionRule(TypeSystem::All, argIdx).isEmpty()
|| func->hasInjectedCode())
return;
- QString prefix;
+ QString message;
+ QTextStream str(&message);
+ str << "There's no user provided way (conversion rule, argument"
+ " removal, custom code, etc) to handle the primitive ";
+ if (argIdx == 0)
+ str << "return type '" << type->cppSignature() << '\'';
+ else
+ str << "type '" << type->cppSignature() << "' of argument " << argIdx;
+ str << " in function '";
if (func->ownerClass())
- 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'.")
- .arg(argIdx == 0 ? QStringLiteral("return") : QStringLiteral("argument"),
- type->cppSignature(), prefix, func->signature());
+ str << func->ownerClass()->qualifiedCppName() << "::";
+ str << func->signature() << "'.";
+ qCWarning(lcShiboken).noquote().nospace() << message;
}
static void checkTypeViability(const AbstractMetaFunction* func)
@@ -2114,9 +2160,10 @@ static void checkTypeViability(const AbstractMetaFunction* func)
void CppGenerator::writeTypeCheck(QTextStream& s, const OverloadData* overloadData, QString argumentName)
{
QSet<const TypeEntry*> numericTypes;
-
- foreach (OverloadData* od, overloadData->previousOverloadData()->nextOverloadData()) {
- foreach (const AbstractMetaFunction* func, od->overloads()) {
+ const OverloadDataList &overloads = overloadData->previousOverloadData()->nextOverloadData();
+ for (OverloadData *od : overloads) {
+ const OverloadData::MetaFunctionList &odOverloads = od->overloads();
+ for (const AbstractMetaFunction *func : odOverloads) {
checkTypeViability(func);
const AbstractMetaType* argType = od->argument(func)->type();
if (!argType->isPrimitive())
@@ -2174,6 +2221,23 @@ const AbstractMetaType* CppGenerator::getArgumentType(const AbstractMetaFunction
return argType;
}
+static inline QString arrayHandleType(const AbstractMetaTypeCList &nestedArrayTypes)
+{
+ switch (nestedArrayTypes.size()) {
+ case 1:
+ return QStringLiteral("Shiboken::Conversions::ArrayHandle<")
+ + nestedArrayTypes.constLast()->minimalSignature()
+ + QLatin1Char('>');
+ case 2:
+ return QStringLiteral("Shiboken::Conversions::Array2Handle<")
+ + nestedArrayTypes.constLast()->minimalSignature()
+ + QStringLiteral(", ")
+ + QString::number(nestedArrayTypes.constFirst()->arrayElementCount())
+ + QLatin1Char('>');
+ }
+ return QString();
+}
+
void CppGenerator::writePythonToCppTypeConversion(QTextStream& s,
const AbstractMetaType* type,
const QString& pyIn,
@@ -2195,7 +2259,13 @@ void CppGenerator::writePythonToCppTypeConversion(QTextStream& s,
&& !isCppPrimitive(type)
&& isNotContainerEnumOrFlags
&& !(treatAsPointer || isPointerOrObjectType);
- QString typeName = getFullTypeNameWithoutModifiers(type);
+
+ const AbstractMetaTypeCList nestedArrayTypes = type->nestedArrayTypes();
+ const bool isCppPrimitiveArray = !nestedArrayTypes.isEmpty()
+ && nestedArrayTypes.constLast()->isCppPrimitive();
+ QString typeName = isCppPrimitiveArray
+ ? arrayHandleType(nestedArrayTypes)
+ : getFullTypeNameWithoutModifiers(type);
bool isProtectedEnum = false;
@@ -2212,7 +2282,9 @@ void CppGenerator::writePythonToCppTypeConversion(QTextStream& s,
}
s << INDENT << typeName;
- if (treatAsPointer || isPointerOrObjectType) {
+ if (isCppPrimitiveArray) {
+ s << ' ' << cppOut;
+ } else if (treatAsPointer || isPointerOrObjectType) {
s << "* " << cppOut;
if (!defaultValue.isEmpty())
s << " = " << defaultValue;
@@ -2289,7 +2361,8 @@ static void addConversionRuleCodeSnippet(CodeSnipList& snippetList, QString& rul
void CppGenerator::writeConversionRule(QTextStream& s, const AbstractMetaFunction* func, TypeSystem::Language language)
{
CodeSnipList snippets;
- foreach (AbstractMetaArgument* arg, func->arguments()) {
+ const AbstractMetaArgumentList &arguments = func->arguments();
+ for (AbstractMetaArgument *arg : arguments) {
QString rule = func->conversionRule(language, arg->argumentIndex() + 1);
addConversionRuleCodeSnippet(snippets, rule, language, TypeSystem::TargetLangCode,
arg->name(), arg->name());
@@ -2317,7 +2390,7 @@ void CppGenerator::writeOverloadedFunctionDecisor(QTextStream& s, const Overload
{
s << INDENT << "// Overloaded function decisor" << endl;
const AbstractMetaFunction* rfunc = overloadData.referenceFunction();
- QList<const AbstractMetaFunction*> functionOverloads = overloadData.overloadsWithoutRepetition();
+ const OverloadData::MetaFunctionList &functionOverloads = overloadData.overloadsWithoutRepetition();
for (int i = 0; i < functionOverloads.count(); i++)
s << INDENT << "// " << i << ": " << functionOverloads.at(i)->minimalSignature() << endl;
writeOverloadedFunctionDecisorEngine(s, &overloadData);
@@ -2351,7 +2424,8 @@ void CppGenerator::writeOverloadedFunctionDecisorEngine(QTextStream& s, const Ov
// variable to be used further on this method on the conditional that identifies default
// method calls.
if (!hasDefaultCall) {
- foreach (const AbstractMetaFunction* func, parentOverloadData->overloads()) {
+ const OverloadData::MetaFunctionList &overloads = parentOverloadData->overloads();
+ for (const AbstractMetaFunction *func : overloads) {
if (parentOverloadData->isFinalOccurrence(func)) {
referenceFunction = func;
hasDefaultCall = true;
@@ -2392,6 +2466,7 @@ void CppGenerator::writeOverloadedFunctionDecisorEngine(QTextStream& s, const Ov
// If the next argument has a default value the decisor can perform a method call;
// it just need to check if the number of arguments received from Python are equal
// to the number of parameters preceding the argument with the default value.
+ const OverloadDataList &overloads = parentOverloadData->nextOverloadData();
if (hasDefaultCall) {
isFirst = false;
int numArgs = parentOverloadData->argPos() + 1;
@@ -2399,7 +2474,7 @@ void CppGenerator::writeOverloadedFunctionDecisorEngine(QTextStream& s, const Ov
{
Indentation indent(INDENT);
const AbstractMetaFunction* func = referenceFunction;
- foreach (OverloadData* overloadData, parentOverloadData->nextOverloadData()) {
+ for (OverloadData *overloadData : overloads) {
const AbstractMetaFunction* defValFunc = overloadData->getFunctionWithDefaultValue();
if (defValFunc) {
func = defValFunc;
@@ -2412,7 +2487,7 @@ void CppGenerator::writeOverloadedFunctionDecisorEngine(QTextStream& s, const Ov
s << INDENT << '}';
}
- foreach (OverloadData* overloadData, parentOverloadData->nextOverloadData()) {
+ for (OverloadData *overloadData : overloads) {
bool signatureFound = overloadData->overloads().size() == 1
&& !overloadData->getFunctionWithDefaultValue()
&& !overloadData->findNextArgWithDefault();
@@ -2501,7 +2576,7 @@ void CppGenerator::writeOverloadedFunctionDecisorEngine(QTextStream& s, const Ov
void CppGenerator::writeFunctionCalls(QTextStream &s, const OverloadData &overloadData,
GeneratorContext &context)
{
- QList<const AbstractMetaFunction*> overloads = overloadData.overloadsWithoutRepetition();
+ const OverloadData::MetaFunctionList &overloads = overloadData.overloadsWithoutRepetition();
s << INDENT << "// Call function/method" << endl;
s << INDENT << (overloads.count() > 1 ? "switch (overloadId) " : "") << '{' << endl;
{
@@ -2823,16 +2898,17 @@ void CppGenerator::writePythonToCppConversionFunctions(QTextStream& s, const Abs
const AbstractMetaType* type = containerType->instantiations().at(i);
QString typeName = getFullTypeName(type);
if (type->isValue() && isValueTypeWithCopyConstructorOnly(type)) {
- static QRegExp regex(QLatin1String(CONVERTTOCPP_REGEX));
- int pos = 0;
- while ((pos = regex.indexIn(code, pos)) != -1) {
- pos += regex.matchedLength();
- QStringList list = regex.capturedTexts();
- QString varName = list.at(1);
- QString leftCode = code.left(pos);
+ static const QRegularExpression regex(QLatin1String(CONVERTTOCPP_REGEX));
+ Q_ASSERT(regex.isValid());
+ for (int pos = 0; ; ) {
+ const QRegularExpressionMatch match = regex.match(code, pos);
+ if (!match.hasMatch())
+ break;
+ pos = match.capturedEnd();
+ const QString varName = match.captured(1);
QString rightCode = code.mid(pos);
rightCode.replace(varName, QLatin1Char('*') + varName);
- code = leftCode + rightCode;
+ code.replace(pos, code.size() - pos, rightCode);
}
typeName.append(QLatin1Char('*'));
}
@@ -2867,7 +2943,7 @@ void CppGenerator::writeAddPythonToCppConversion(QTextStream& s, const QString&
void CppGenerator::writeNamedArgumentResolution(QTextStream& s, const AbstractMetaFunction* func, bool usePyArgs)
{
- AbstractMetaArgumentList args = OverloadData::getArgumentsWithDefaultValues(func);
+ const AbstractMetaArgumentList &args = OverloadData::getArgumentsWithDefaultValues(func);
if (args.isEmpty())
return;
@@ -2878,7 +2954,7 @@ void CppGenerator::writeNamedArgumentResolution(QTextStream& s, const AbstractMe
{
Indentation indent(INDENT);
s << INDENT << "PyObject* ";
- foreach (const AbstractMetaArgument* arg, args) {
+ for (const AbstractMetaArgument *arg : args) {
int pyArgIndex = arg->argumentIndex() - OverloadData::numberOfRemovedArguments(func, arg->argumentIndex());
QString pyArgName = usePyArgs
? QString::fromLatin1(PYTHON_ARGS "[%1]").arg(pyArgIndex)
@@ -2953,7 +3029,8 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f
{
s << INDENT << "// " << func->minimalSignature() << (func->isReverseOperator() ? " [reverse operator]": "") << endl;
if (func->isConstructor()) {
- foreach (const CodeSnip &cs, func->injectedCodeSnips()) {
+ const CodeSnipList &snips = func->injectedCodeSnips();
+ for (const CodeSnip &cs : snips) {
if (cs.position == TypeSystem::CodeSnipPositionEnd) {
s << INDENT << "overloadId = " << func->ownerClass()->functions().indexOf(const_cast<AbstractMetaFunction* const>(func)) << ';' << endl;
break;
@@ -3255,11 +3332,12 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f
bool hasReturnPolicy = false;
// Ownership transference between C++ and Python.
- QList<ArgumentModification> ownership_mods;
+ QVector<ArgumentModification> ownership_mods;
// Python object reference management.
- QList<ArgumentModification> refcount_mods;
- foreach (const FunctionModification &func_mod, func->modifications()) {
- foreach (const ArgumentModification &arg_mod, func_mod.argument_mods) {
+ QVector<ArgumentModification> refcount_mods;
+ const FunctionModificationList &funcMods = func->modifications();
+ for (const FunctionModification &func_mod : funcMods) {
+ for (const ArgumentModification &arg_mod : func_mod.argument_mods) {
if (!arg_mod.ownerships.isEmpty() && arg_mod.ownerships.contains(TypeSystem::TargetLangCode))
ownership_mods.append(arg_mod);
else if (!arg_mod.referenceCounts.isEmpty())
@@ -3273,7 +3351,7 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f
if (!ownership_mods.isEmpty()) {
s << endl << INDENT << "// Ownership transferences." << endl;
- foreach (const ArgumentModification &arg_mod, ownership_mods) {
+ for (const ArgumentModification &arg_mod : qAsConst(ownership_mods)) {
const AbstractMetaClass* wrappedClass = 0;
QString pyArgName = argumentNameFromIndex(func, arg_mod.index, &wrappedClass);
if (!wrappedClass) {
@@ -3304,7 +3382,7 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f
}
} else if (!refcount_mods.isEmpty()) {
- foreach (const ArgumentModification &arg_mod, refcount_mods) {
+ for (const ArgumentModification &arg_mod : qAsConst(refcount_mods)) {
ReferenceCount refCount = arg_mod.referenceCounts.first();
if (refCount.action != ReferenceCount::Set
&& refCount.action != ReferenceCount::Remove
@@ -3349,15 +3427,15 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f
QStringList CppGenerator::getAncestorMultipleInheritance(const AbstractMetaClass* metaClass)
{
QStringList result;
- AbstractMetaClassList baseClases = getBaseClasses(metaClass);
+ const AbstractMetaClassList &baseClases = getBaseClasses(metaClass);
if (!baseClases.isEmpty()) {
- foreach (const AbstractMetaClass* baseClass, baseClases) {
+ for (const AbstractMetaClass *baseClass : baseClases) {
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)
+ for (const AbstractMetaClass *baseClass : baseClases)
result.append(getAncestorMultipleInheritance(baseClass));
}
return result;
@@ -3366,7 +3444,7 @@ QStringList CppGenerator::getAncestorMultipleInheritance(const AbstractMetaClass
void CppGenerator::writeMultipleInheritanceInitializerFunction(QTextStream& s, const AbstractMetaClass* metaClass)
{
QString className = metaClass->qualifiedCppName();
- QStringList ancestors = getAncestorMultipleInheritance(metaClass);
+ const QStringList ancestors = getAncestorMultipleInheritance(metaClass);
s << "static int mi_offsets[] = { ";
for (int i = 0; i < ancestors.size(); i++)
s << "-1, ";
@@ -3382,7 +3460,7 @@ void CppGenerator::writeMultipleInheritanceInitializerFunction(QTextStream& s, c
s << INDENT << "const " << className << "* class_ptr = reinterpret_cast<const " << className << "*>(cptr);" << endl;
s << INDENT << "size_t base = (size_t) class_ptr;" << endl;
- foreach (const QString &ancestor, ancestors)
+ for (const QString &ancestor : ancestors)
s << INDENT << "offsets.insert(" << ancestor << ");" << endl;
s << endl;
@@ -3410,7 +3488,8 @@ void CppGenerator::writeSpecialCastFunction(QTextStream& s, const AbstractMetaCl
s << "{\n";
s << INDENT << className << "* me = reinterpret_cast< ::" << className << "*>(obj);\n";
bool firstClass = true;
- foreach (const AbstractMetaClass* baseClass, getAllAncestors(metaClass)) {
+ const AbstractMetaClassList &allAncestors = getAllAncestors(metaClass);
+ for (const AbstractMetaClass *baseClass : allAncestors) {
s << INDENT << (!firstClass ? "else " : "") << "if (desiredType == reinterpret_cast<SbkObjectType*>(" << cpythonTypeNameExt(baseClass->typeEntry()) << "))\n";
Indentation indent(INDENT);
s << INDENT << "return static_cast< ::" << baseClass->qualifiedCppName() << "*>(me);\n";
@@ -3528,10 +3607,11 @@ void CppGenerator::writeContainerConverterInitialization(QTextStream& s, const A
writeAddPythonToCppConversion(s, converterObject(type), toCpp, isConv);
}
-void CppGenerator::writeExtendedConverterInitialization(QTextStream& s, const TypeEntry* externalType, const QList<const AbstractMetaClass*>& conversions)
+void CppGenerator::writeExtendedConverterInitialization(QTextStream& s, const TypeEntry* externalType,
+ const QVector<const AbstractMetaClass*>& conversions)
{
s << INDENT << "// Extended implicit conversions for " << externalType->qualifiedTargetLangName() << '.' << endl;
- foreach (const AbstractMetaClass* sourceClass, conversions) {
+ for (const AbstractMetaClass *sourceClass : conversions) {
const QString converterVar = QLatin1String("reinterpret_cast<SbkObjectType *>(")
+ cppApiVariableName(externalType->targetLangPackage()) + QLatin1Char('[')
+ getTypeIndexVariableName(externalType) + QLatin1String("])");
@@ -3586,7 +3666,8 @@ bool CppGenerator::supportsSequenceProtocol(const AbstractMetaClass* metaClass)
bool CppGenerator::shouldGenerateGetSetList(const AbstractMetaClass* metaClass)
{
- foreach (AbstractMetaField* f, metaClass->fields()) {
+ const AbstractMetaFieldList &fields = metaClass->fields();
+ for (const AbstractMetaField *f : fields) {
if (!f->isStatic())
return true;
}
@@ -3604,11 +3685,11 @@ void CppGenerator::writeClassDefinition(QTextStream &s,
QString tp_hash(QLatin1Char('0'));
QString tp_call = tp_hash;
QString cppClassName = metaClass->qualifiedCppName();
- QString className = cpythonTypeName(metaClass);
- className.remove(QRegExp(QLatin1String("_Type$")));
+ const QString className = chopType(cpythonTypeName(metaClass));
QString baseClassName(QLatin1Char('0'));
AbstractMetaFunctionList ctors;
- foreach (AbstractMetaFunction* f, metaClass->queryFunctions(AbstractMetaClass::Constructors)) {
+ const AbstractMetaFunctionList &allCtors = metaClass->queryFunctions(AbstractMetaClass::Constructors);
+ for (AbstractMetaFunction *f : allCtors) {
if (!f->isPrivate() && !f->isModifiedRemoved() && !classContext.forSmartPointer())
ctors.append(f);
}
@@ -3679,7 +3760,8 @@ void CppGenerator::writeClassDefinition(QTextStream &s,
// search for special functions
ShibokenGenerator::clearTpFuncs();
- foreach (AbstractMetaFunction* func, metaClass->functions()) {
+ const AbstractMetaFunctionList &funcs = metaClass->functions();
+ for (AbstractMetaFunction *func : funcs) {
if (m_tpFuncs.contains(func->name()))
m_tpFuncs[func->name()] = cpythonFunctionName(func);
}
@@ -3936,13 +4018,13 @@ void CppGenerator::writeTypeAsNumberDefinition(QTextStream& s, const AbstractMet
nb.insert(QLatin1String("__ixor__"), QString());
nb.insert(QLatin1String("__ior__"), QString());
- QList<AbstractMetaFunctionList> opOverloads =
+ const QVector<AbstractMetaFunctionList> opOverloads =
filterGroupedOperatorFunctions(metaClass,
AbstractMetaClass::ArithmeticOp
| AbstractMetaClass::LogicalOp
| AbstractMetaClass::BitwiseOp);
- foreach (const AbstractMetaFunctionList &opOverload, opOverloads) {
+ for (const AbstractMetaFunctionList &opOverload : opOverloads) {
const AbstractMetaFunction* rfunc = opOverload[0];
QString opName = ShibokenGenerator::pythonOperatorFunctionName(rfunc);
nb[opName] = cpythonFunctionName(rfunc);
@@ -4001,8 +4083,7 @@ void CppGenerator::writeTpClearFunction(QTextStream& s, const AbstractMetaClass*
void CppGenerator::writeCopyFunction(QTextStream &s, GeneratorContext &context)
{
const AbstractMetaClass *metaClass = context.metaClass();
- QString className = cpythonTypeName(metaClass);
- className.remove(QRegExp(QLatin1String("_Type$")));
+ const QString className = chopType(cpythonTypeName(metaClass));
s << "static PyObject* " << className << "___copy__(PyObject* " PYTHON_SELF_VAR ")" << endl;
s << "{" << endl;
writeCppSelfDefinition(s, context, false, true);
@@ -4181,7 +4262,8 @@ void CppGenerator::writeRichCompareFunction(QTextStream &s, GeneratorContext &co
s << INDENT << "switch (op) {" << endl;
{
Indentation indent(INDENT);
- foreach (const AbstractMetaFunctionList &overloads, filterGroupedOperatorFunctions(metaClass, AbstractMetaClass::ComparisonOp)) {
+ const QVector<AbstractMetaFunctionList> &groupedFuncs = filterGroupedOperatorFunctions(metaClass, AbstractMetaClass::ComparisonOp);
+ for (const AbstractMetaFunctionList &overloads : groupedFuncs) {
const AbstractMetaFunction* rfunc = overloads[0];
QString operatorId = ShibokenGenerator::pythonRichCompareOperatorId(rfunc);
@@ -4193,7 +4275,7 @@ void CppGenerator::writeRichCompareFunction(QTextStream &s, GeneratorContext &co
op = op.right(op.size() - QLatin1String("operator").size());
int alternativeNumericTypes = 0;
- foreach (const AbstractMetaFunction* func, overloads) {
+ for (const AbstractMetaFunction *func : overloads) {
if (!func->isStatic() &&
ShibokenGenerator::isNumber(func->arguments()[0]->type()->typeEntry()))
alternativeNumericTypes++;
@@ -4201,7 +4283,8 @@ void CppGenerator::writeRichCompareFunction(QTextStream &s, GeneratorContext &co
bool first = true;
OverloadData overloadData(overloads, this);
- foreach (OverloadData* od, overloadData.nextOverloadData()) {
+ const OverloadDataList &nextOverloads = overloadData.nextOverloadData();
+ for (OverloadData *od : nextOverloads) {
const AbstractMetaFunction* func = od->referenceFunction();
if (func->isStatic())
continue;
@@ -4349,18 +4432,10 @@ void CppGenerator::writeSignatureInfo(QTextStream &s, const AbstractMetaFunction
int idx = overloads.length() - 1;
bool multiple = idx > 0;
-// after merging, the #if may be removed!
-#if QT_VERSION >= QT_VERSION_CHECK(5, 7, 0)
for (const AbstractMetaFunction *f : overloads) {
QStringList args;
const AbstractMetaArgumentList &arguments = f->arguments();
- for (AbstractMetaArgument *arg : arguments) {
-#else
- foreach (const AbstractMetaFunction *f, overloads) {
- QStringList args;
- const AbstractMetaArgumentList &arguments = f->arguments();
- foreach (const AbstractMetaArgument *arg, arguments) {
-#endif
+ for (const AbstractMetaArgument *arg : arguments) {
QString strArg = resolveRetOrArgType(arg->type());
if (!arg->defaultValueExpression().isEmpty()) {
strArg += QLatin1Char('=');
@@ -4378,9 +4453,8 @@ void CppGenerator::writeSignatureInfo(QTextStream &s, const AbstractMetaFunction
// now calculate the return type.
s << funcName << '(' << args.join(QLatin1Char(',')) << ')';
AbstractMetaType *returnType = getTypeWithoutContainer(f->type());
- if (returnType) {
+ if (returnType)
s << "->" << resolveRetOrArgType(returnType);
- }
s << endl;
}
}
@@ -4390,7 +4464,7 @@ void CppGenerator::writeEnumsInitialization(QTextStream& s, AbstractMetaEnumList
if (enums.isEmpty())
return;
s << INDENT << "// Initialization of enums." << endl << endl;
- foreach (const AbstractMetaEnum* cppEnum, enums) {
+ for (const AbstractMetaEnum *cppEnum : qAsConst(enums)) {
if (cppEnum->isPrivate())
continue;
writeEnumInitialization(s, cppEnum);
@@ -4441,7 +4515,8 @@ void CppGenerator::writeEnumInitialization(QTextStream& s, const AbstractMetaEnu
}
}
- foreach (const AbstractMetaEnumValue* enumValue, cppEnum->values()) {
+ const AbstractMetaEnumValueList &enumValues = cppEnum->values();
+ for (const AbstractMetaEnumValue *enumValue : enumValues) {
if (cppEnum->typeEntry()->isEnumValueRejected(enumValue->name()))
continue;
@@ -4500,10 +4575,12 @@ void CppGenerator::writeEnumInitialization(QTextStream& s, const AbstractMetaEnu
void CppGenerator::writeSignalInitialization(QTextStream& s, const AbstractMetaClass* metaClass)
{
// Try to check something and print some warnings
- foreach (const AbstractMetaFunction* cppSignal, metaClass->cppSignalFunctions()) {
+ const AbstractMetaFunctionList &signalFuncs = metaClass->cppSignalFunctions();
+ for (const AbstractMetaFunction *cppSignal : signalFuncs) {
if (cppSignal->declaringClass() != metaClass)
continue;
- foreach (AbstractMetaArgument* arg, cppSignal->arguments()) {
+ const AbstractMetaArgumentList &arguments = cppSignal->arguments();
+ for (AbstractMetaArgument *arg : arguments) {
AbstractMetaType* metaType = arg->type();
const QByteArray origType =
QMetaObject::normalizedType(qPrintable(metaType->originalTypeDescription()));
@@ -4704,9 +4781,8 @@ void CppGenerator::writeClassRegister(QTextStream &s,
s << "// Multiple signatures have their index \"n:\" in front." << endl;
s << "const char " << initFunctionName << "_SignaturesString[] = \"\"" << endl;
QString line;
- while (signatureStream.readLineInto(&line)) {
+ while (signatureStream.readLineInto(&line))
s << INDENT << '"' << line << "\\n\"" << endl;
- }
s << ';' << endl << endl;
s << "void init_" << initFunctionName;
s << "(PyObject* " << enclosingObjectVariable << ")" << endl;
@@ -4747,7 +4823,7 @@ void CppGenerator::writeClassRegister(QTextStream &s,
if (metaClass->baseClassNames().size() > 1) {
s << INDENT << "PyObject* " << pyTypeBasesVariable << " = PyTuple_Pack(" << baseClasses.size() << ',' << endl;
QStringList bases;
- foreach (const AbstractMetaClass* base, baseClasses)
+ for (const AbstractMetaClass *base : baseClasses)
bases << QLatin1String("(PyObject*)") + cpythonTypeNameExt(base->typeEntry());
Indentation indent(INDENT);
QString separator;
@@ -4842,7 +4918,8 @@ void CppGenerator::writeClassRegister(QTextStream &s,
}
AbstractMetaEnumList classEnums = metaClass->enums();
- foreach (AbstractMetaClass* innerClass, metaClass->innerClasses())
+ const AbstractMetaClassList &innerClasses = metaClass->innerClasses();
+ for (AbstractMetaClass *innerClass : innerClasses)
lookForEnumsInClassesNotToBeGenerated(classEnums, innerClass);
ErrorCode errorCode(QString::null);
@@ -4852,7 +4929,8 @@ void CppGenerator::writeClassRegister(QTextStream &s,
writeSignalInitialization(s, metaClass);
// Write static fields
- foreach (const AbstractMetaField* field, metaClass->fields()) {
+ const AbstractMetaFieldList &fields = metaClass->fields();
+ for (const AbstractMetaField *field : fields) {
if (!field->isStatic())
continue;
s << INDENT << QLatin1String("PyDict_SetItemString(") + cpythonTypeName(metaClass) + QLatin1String(".super.ht_type.tp_dict, \"");
@@ -4912,7 +4990,8 @@ void CppGenerator::writeInitQtMetaTypeFunctionBody(QTextStream &s, GeneratorCont
bool canBeValue = false;
if (!isObjectType(metaClass)) {
// check if there's a empty ctor
- foreach (AbstractMetaFunction* func, metaClass->functions()) {
+ const AbstractMetaFunctionList &funcs = metaClass->functions();
+ for (AbstractMetaFunction *func : funcs) {
if (func->isConstructor() && !func->arguments().count()) {
canBeValue = true;
break;
@@ -4921,7 +5000,7 @@ void CppGenerator::writeInitQtMetaTypeFunctionBody(QTextStream &s, GeneratorCont
}
if (canBeValue) {
- foreach (const QString &name, nameVariants) {
+ for (const QString &name : qAsConst(nameVariants)) {
if (name == QLatin1String("iterator")) {
qCWarning(lcShiboken).noquote().nospace()
<< QString::fromLatin1("%1:%2 FIXME:\n"
@@ -4935,9 +5014,10 @@ void CppGenerator::writeInitQtMetaTypeFunctionBody(QTextStream &s, GeneratorCont
}
}
- foreach (AbstractMetaEnum* metaEnum, metaClass->enums()) {
+ const AbstractMetaEnumList &enums = metaClass->enums();
+ for (AbstractMetaEnum *metaEnum : enums) {
if (!metaEnum->isPrivate() && !metaEnum->isAnonymous()) {
- foreach (const QString &name, nameVariants)
+ for (const QString &name : qAsConst(nameVariants))
s << INDENT << "qRegisterMetaType< ::" << metaEnum->typeEntry()->qualifiedCppName() << " >(\"" << name << "::" << metaEnum->name() << "\");" << endl;
if (metaEnum->typeEntry()->flags()) {
@@ -4965,8 +5045,8 @@ void CppGenerator::writeTypeDiscoveryFunction(QTextStream& s, const AbstractMeta
s << INDENT << "return cptr;" << endl;
}
} else if (metaClass->isPolymorphic()) {
- AbstractMetaClassList ancestors = getAllAncestors(metaClass);
- foreach (AbstractMetaClass* ancestor, ancestors) {
+ const AbstractMetaClassList &ancestors = getAllAncestors(metaClass);
+ for (AbstractMetaClass *ancestor : ancestors) {
if (ancestor->baseClass())
continue;
if (ancestor->isPolymorphic()) {
@@ -5077,7 +5157,8 @@ void CppGenerator::writeGetattroFunction(QTextStream& s, GeneratorContext &conte
}
s << INDENT << '}' << endl;
- foreach (const AbstractMetaFunction* func, getMethodsWithBothStaticAndNonStaticMethods(metaClass)) {
+ const AbstractMetaFunctionList &funcs = getMethodsWithBothStaticAndNonStaticMethods(metaClass);
+ for (const AbstractMetaFunction *func : funcs) {
QString defName = cpythonMethodDefinitionName(func);
s << INDENT << "static PyMethodDef non_static_" << defName << " = {" << endl;
{
@@ -5172,7 +5253,7 @@ bool CppGenerator::finishGeneration()
const FunctionGroupMap &functionGroups = getFunctionGroups();
for (FunctionGroupMapIt it = functionGroups.cbegin(), end = functionGroups.cend(); it != end; ++it) {
AbstractMetaFunctionList overloads;
- foreach (AbstractMetaFunction* func, it.value()) {
+ for (AbstractMetaFunction *func : it.value()) {
if (!func->isModifiedRemoved()) {
overloads.append(func);
if (func->typeEntry())
@@ -5203,7 +5284,7 @@ bool CppGenerator::finishGeneration()
}
const AbstractMetaClassList lst = classesTopologicalSorted(additionalDependencies);
- foreach (const AbstractMetaClass* cls, lst) {
+ for (const AbstractMetaClass *cls : lst){
if (!shouldGenerate(cls))
continue;
@@ -5219,7 +5300,8 @@ bool CppGenerator::finishGeneration()
}
// Initialize smart pointer types.
- foreach (const AbstractMetaType *metaType, instantiatedSmartPointers()) {
+ const QVector<const AbstractMetaType *> &smartPtrs = instantiatedSmartPointers();
+ for (const AbstractMetaType *metaType : smartPtrs) {
GeneratorContext context(0, metaType, true);
QString initFunctionName = getInitFunctionName(context);
s_classInitDecl << "void init_" << initFunctionName << "(PyObject* module);" << endl;
@@ -5255,13 +5337,14 @@ bool CppGenerator::finishGeneration()
}
s << "#include \"" << getModuleHeaderFileName() << '"' << endl << endl;
- foreach (const Include& include, includes)
+ for (const Include &include : qAsConst(includes))
s << include;
s << endl;
// Global enums
AbstractMetaEnumList globalEnums = this->globalEnums();
- foreach (const AbstractMetaClass* metaClass, classes()) {
+ const AbstractMetaClassList &classList = classes();
+ for (const AbstractMetaClass *metaClass : classList) {
const AbstractMetaClass* encClass = metaClass->enclosingClass();
if (encClass && encClass->typeEntry()->codeGeneration() != TypeEntry::GenerateForSubclass)
continue;
@@ -5273,13 +5356,13 @@ bool CppGenerator::finishGeneration()
//Extra includes
s << endl << "// Extra includes" << endl;
- QList<Include> extraIncludes;
+ QVector<Include> extraIncludes;
if (moduleEntry)
extraIncludes = moduleEntry->extraIncludes();
- foreach (AbstractMetaEnum* cppEnum, globalEnums)
+ for (AbstractMetaEnum *cppEnum : qAsConst(globalEnums))
extraIncludes.append(cppEnum->typeEntry()->extraIncludes());
qSort(extraIncludes.begin(), extraIncludes.end());
- foreach (const Include& inc, extraIncludes)
+ for (const Include &inc : qAsConst(extraIncludes))
s << inc;
s << endl;
@@ -5334,7 +5417,7 @@ bool CppGenerator::finishGeneration()
s << "// Enum definitions ";
s << "------------------------------------------------------------" << endl;
- foreach (const AbstractMetaEnum* cppEnum, globalEnums) {
+ for (const AbstractMetaEnum *cppEnum : qAsConst(globalEnums)) {
if (cppEnum->isAnonymous() || cppEnum->isPrivate())
continue;
writeEnumConverterFunctions(s, cppEnum);
@@ -5350,10 +5433,10 @@ bool CppGenerator::finishGeneration()
}
}
- QStringList requiredModules = typeDb->requiredTargetImports();
+ const QStringList &requiredModules = typeDb->requiredTargetImports();
if (!requiredModules.isEmpty())
s << "// Required modules' type and converter arrays." << endl;
- foreach (const QString& requiredModule, requiredModules) {
+ for (const QString &requiredModule : requiredModules) {
s << "PyTypeObject** " << cppApiVariableName(requiredModule) << ';' << endl;
s << "SbkConverter** " << convertersVariableName(requiredModule) << ';' << endl;
}
@@ -5367,7 +5450,7 @@ bool CppGenerator::finishGeneration()
for (ExtendedConverterData::const_iterator it = extendedConverters.cbegin(), end = extendedConverters.cend(); it != end; ++it) {
const TypeEntry *externalType = it.key();
s << "// Extended implicit conversions for " << externalType->qualifiedTargetLangName() << '.' << endl;
- foreach (const AbstractMetaClass* sourceClass, extendedConverters[externalType]) {
+ for (const AbstractMetaClass *sourceClass : it.value()) {
AbstractMetaType* sourceType = buildAbstractMetaTypeFromAbstractMetaClass(sourceClass);
AbstractMetaType* targetType = buildAbstractMetaTypeFromTypeEntry(externalType);
writePythonToCppConversionFunctions(s, sourceType, targetType);
@@ -5375,10 +5458,10 @@ bool CppGenerator::finishGeneration()
}
}
- QList<const CustomConversion*> typeConversions = getPrimitiveCustomConversions();
+ const QVector<const CustomConversion *> &typeConversions = getPrimitiveCustomConversions();
if (!typeConversions.isEmpty()) {
s << endl << "// Primitive Type converters." << endl << endl;
- foreach (const CustomConversion* conversion, typeConversions) {
+ for (const CustomConversion *conversion : typeConversions) {
s << "// C++ to Python conversion for type '" << conversion->ownerType()->qualifiedCppName() << "'." << endl;
writeCppToPythonFunction(s, conversion);
writeCustomConverterFunctions(s, conversion);
@@ -5386,10 +5469,10 @@ bool CppGenerator::finishGeneration()
s << endl;
}
- QList<const AbstractMetaType*> containers = instantiatedContainers();
+ const QVector<const AbstractMetaType *> &containers = instantiatedContainers();
if (!containers.isEmpty()) {
s << "// Container Type converters." << endl << endl;
- foreach (const AbstractMetaType* container, containers) {
+ for (const AbstractMetaType *container : containers) {
s << "// C++ to Python conversion for type '" << container->cppSignature() << "'." << endl;
writeContainerConverterFunctions(s, container);
}
@@ -5426,7 +5509,7 @@ bool CppGenerator::finishGeneration()
s << endl;
}
- foreach (const QString& requiredModule, typeDb->requiredTargetImports()) {
+ for (const QString& requiredModule : requiredModules) {
s << INDENT << "{" << endl;
{
Indentation indentation(INDENT);
@@ -5468,7 +5551,7 @@ bool CppGenerator::finishGeneration()
if (!typeConversions.isEmpty()) {
s << endl;
- foreach (const CustomConversion* conversion, typeConversions) {
+ for (const CustomConversion *conversion : typeConversions) {
writePrimitiveConverterInitialization(s, conversion);
s << endl;
}
@@ -5476,7 +5559,7 @@ bool CppGenerator::finishGeneration()
if (!containers.isEmpty()) {
s << endl;
- foreach (const AbstractMetaType* container, containers) {
+ for (const AbstractMetaType *container : containers) {
writeContainerConverterInitialization(s, container);
s << endl;
}
@@ -5493,7 +5576,8 @@ bool CppGenerator::finishGeneration()
writeEnumsInitialization(s, globalEnums);
s << INDENT << "// Register primitive types converters." << endl;
- foreach(const PrimitiveTypeEntry* pte, primitiveTypes()) {
+ const PrimitiveTypeEntryList &primitiveTypeList = primitiveTypes();
+ for (const PrimitiveTypeEntry *pte : primitiveTypeList) {
if (!pte->generateCode() || !pte->isCppPrimitive())
continue;
const TypeEntry *referencedType = pte->basicReferencedTypeEntry();
@@ -5534,7 +5618,7 @@ bool CppGenerator::finishGeneration()
}
if (usePySideExtensions()) {
- foreach (AbstractMetaEnum* metaEnum, globalEnums)
+ for (AbstractMetaEnum *metaEnum : qAsConst(globalEnums))
if (!metaEnum->isAnonymous()) {
s << INDENT << "qRegisterMetaType< ::" << metaEnum->typeEntry()->qualifiedCppName() << " >(\"" << metaEnum->name() << "\");" << endl;
}
@@ -5547,9 +5631,8 @@ bool CppGenerator::finishGeneration()
s << "// Multiple signatures have their index \"n:\" in front." << endl;
s << "const char " << moduleName() << "_SignaturesString[] = \"\"" << endl;
QString line;
- while (signatureStream.readLineInto(&line)) {
+ while (signatureStream.readLineInto(&line))
s << INDENT << '"' << line << "\\n\"" << endl;
- }
s << ';' << endl;
// finish the rest of __signature__ initialization.
s << INDENT << "FinishSignatureInitialization(module, " << moduleName()
diff --git a/sources/shiboken2/generator/shiboken2/cppgenerator.h b/sources/shiboken2/generator/shiboken2/cppgenerator.h
index 4877a1694..cce1842ab 100644
--- a/sources/shiboken2/generator/shiboken2/cppgenerator.h
+++ b/sources/shiboken2/generator/shiboken2/cppgenerator.h
@@ -39,12 +39,12 @@ class CppGenerator : public ShibokenGenerator
public:
CppGenerator();
protected:
- QString fileNamePrefix() const;
- QString fileNameForContext(GeneratorContext &context) const;
- QList<AbstractMetaFunctionList> filterGroupedOperatorFunctions(const AbstractMetaClass* metaClass,
- uint query);
- void generateClass(QTextStream& s, GeneratorContext &classContext);
- bool finishGeneration();
+ QString fileNamePrefix() const override;
+ QString fileNameForContext(GeneratorContext &context) const override;
+ QVector<AbstractMetaFunctionList> filterGroupedOperatorFunctions(const AbstractMetaClass* metaClass,
+ uint query);
+ void generateClass(QTextStream& s, GeneratorContext &classContext) override;
+ bool finishGeneration() override;
private:
void writeConstructorNative(QTextStream& s, const AbstractMetaFunction* func);
@@ -291,7 +291,7 @@ private:
void writeEnumConverterInitialization(QTextStream& s, const TypeEntry* enumType);
void writeEnumConverterInitialization(QTextStream& s, const AbstractMetaEnum* metaEnum);
void writeContainerConverterInitialization(QTextStream& s, const AbstractMetaType* type);
- void writeExtendedConverterInitialization(QTextStream& s, const TypeEntry* externalType, const QList<const AbstractMetaClass*>& conversions);
+ void writeExtendedConverterInitialization(QTextStream& s, const TypeEntry* externalType, const QVector<const AbstractMetaClass*>& conversions);
void writeParentChildManagement(QTextStream& s, const AbstractMetaFunction* func, bool userHeuristicForReturn);
bool writeParentChildManagement(QTextStream& s, const AbstractMetaFunction* func, int argIndex, bool userHeuristicPolicy);
diff --git a/sources/shiboken2/generator/shiboken2/headergenerator.cpp b/sources/shiboken2/generator/shiboken2/headergenerator.cpp
index 7158c370b..a41139381 100644
--- a/sources/shiboken2/generator/shiboken2/headergenerator.cpp
+++ b/sources/shiboken2/generator/shiboken2/headergenerator.cpp
@@ -35,7 +35,6 @@
#include <QtCore/QDir>
#include <QtCore/QTextStream>
#include <QtCore/QVariant>
-#include <QtCore/QRegExp>
#include <QtCore/QDebug>
QString HeaderGenerator::fileNamePrefix() const
@@ -140,14 +139,16 @@ void HeaderGenerator::generateClass(QTextStream &s, GeneratorContext &classConte
s << endl << '{' << endl << "public:" << endl;
bool hasVirtualFunction = false;
- foreach (AbstractMetaFunction *func, filterFunctions(metaClass)) {
+ const AbstractMetaFunctionList &funcs = filterFunctions(metaClass);
+ for (AbstractMetaFunction *func : funcs) {
if (func->isVirtual())
hasVirtualFunction = true;
writeFunction(s, func);
}
if (avoidProtectedHack() && metaClass->hasProtectedFields()) {
- foreach (AbstractMetaField* field, metaClass->fields()) {
+ const AbstractMetaFieldList &fields = metaClass->fields();
+ for (AbstractMetaField *field : fields) {
if (!field->isProtected())
continue;
writeProtectedFieldAccessors(s, field);
@@ -228,7 +229,8 @@ void HeaderGenerator::writeFunction(QTextStream& s, const AbstractMetaFunction*
s << func->ownerClass()->qualifiedCppName() << "::";
s << func->originalName() << '(';
QStringList args;
- foreach (const AbstractMetaArgument* arg, func->arguments()) {
+ const AbstractMetaArgumentList &arguments = func->arguments();
+ for (const AbstractMetaArgument *arg : arguments) {
QString argName = arg->name();
const TypeEntry* enumTypeEntry = 0;
if (arg->type()->isFlags())
@@ -264,7 +266,8 @@ void HeaderGenerator::writeFunction(QTextStream& s, const AbstractMetaFunction*
s << functionSignature(func, QString(), QString(), virtualOption) << ';' << endl;
// Check if this method hide other methods in base classes
- foreach (const AbstractMetaFunction* f, func->ownerClass()->functions()) {
+ const AbstractMetaFunctionList &ownerFuncs = func->ownerClass()->functions();
+ for (const AbstractMetaFunction *f : ownerFuncs) {
if (f != func
&& !f->isConstructor()
&& !f->isPrivate()
@@ -317,7 +320,8 @@ void HeaderGenerator::writeTypeIndexDefine(QTextStream& s, const AbstractMetaCla
if (!metaClass->typeEntry()->generateCode())
return;
writeTypeIndexDefineLine(s, metaClass->typeEntry());
- foreach (const AbstractMetaEnum* metaEnum, metaClass->enums()) {
+ const AbstractMetaEnumList &enums = metaClass->enums();
+ for (const AbstractMetaEnum *metaEnum : enums) {
if (metaEnum->isPrivate())
continue;
writeTypeIndexDefineLine(s, metaEnum->typeEntry());
@@ -341,18 +345,20 @@ bool HeaderGenerator::finishGeneration()
macrosStream << "// Type indices" << endl;
AbstractMetaEnumList globalEnums = this->globalEnums();
- foreach (const AbstractMetaClass* metaClass, classes()) {
+ const AbstractMetaClassList &classList = classes();
+ for (const AbstractMetaClass *metaClass : classList) {
writeTypeIndexDefine(macrosStream, metaClass);
lookForEnumsInClassesNotToBeGenerated(globalEnums, metaClass);
}
- foreach (const AbstractMetaEnum* metaEnum, globalEnums)
+ for (const AbstractMetaEnum *metaEnum : qAsConst(globalEnums))
writeTypeIndexDefineLine(macrosStream, metaEnum->typeEntry());
// Write the smart pointer define indexes.
int smartPointerCountIndex = getMaxTypeIndex();
int smartPointerCount = 0;
- foreach (const AbstractMetaType *metaType, instantiatedSmartPointers()) {
+ const QVector<const AbstractMetaType *> &instantiatedSmartPtrs = instantiatedSmartPointers();
+ for (const AbstractMetaType *metaType : instantiatedSmartPtrs) {
QString variableName = getTypeIndexVariableName(metaType);
macrosStream << "#define ";
macrosStream.setFieldWidth(60);
@@ -378,9 +384,9 @@ bool HeaderGenerator::finishGeneration()
// TODO-CONVERTER ------------------------------------------------------------------------------
// Using a counter would not do, a fix must be made to APIExtractor's getTypeIndex().
macrosStream << "// Converter indices" << endl;
- QList<const PrimitiveTypeEntry*> primitives = primitiveTypes();
+ const PrimitiveTypeEntryList &primitives = primitiveTypes();
int pCount = 0;
- foreach (const PrimitiveTypeEntry* ptype, primitives) {
+ for (const PrimitiveTypeEntry *ptype : primitives) {
/* Note: do not generate indices for typedef'd primitive types
* as they'll use the primitive type converters instead, so we
* don't need to create any other.
@@ -391,7 +397,8 @@ bool HeaderGenerator::finishGeneration()
_writeTypeIndexDefineLine(macrosStream, getTypeIndexVariableName(ptype), pCount++);
}
- foreach (const AbstractMetaType* container, instantiatedContainers()) {
+ const QVector<const AbstractMetaType *> &containers = instantiatedContainers();
+ for (const AbstractMetaType *container : containers) {
//_writeTypeIndexDefineLine(macrosStream, getTypeIndexVariableName(container), pCount);
// DEBUG
QString variableName = getTypeIndexVariableName(container);
@@ -412,7 +419,7 @@ bool HeaderGenerator::finishGeneration()
// TODO-CONVERTER ------------------------------------------------------------------------------
macrosStream << "// Macros for type check" << endl;
- foreach (const AbstractMetaEnum* cppEnum, globalEnums) {
+ for (const AbstractMetaEnum *cppEnum : globalEnums) {
if (cppEnum->isAnonymous() || cppEnum->isPrivate())
continue;
includes << cppEnum->typeEntry()->include();
@@ -420,7 +427,7 @@ bool HeaderGenerator::finishGeneration()
writeSbkTypeFunction(typeFunctions, cppEnum);
}
- foreach (AbstractMetaClass* metaClass, classes()) {
+ for (AbstractMetaClass *metaClass : classList) {
if (!shouldGenerate(metaClass))
continue;
@@ -428,7 +435,8 @@ bool HeaderGenerator::finishGeneration()
const TypeEntry* classType = metaClass->typeEntry();
includes << classType->include();
- foreach (const AbstractMetaEnum* cppEnum, metaClass->enums()) {
+ const AbstractMetaEnumList &enums = metaClass->enums();
+ for (const AbstractMetaEnum *cppEnum : enums) {
if (cppEnum->isAnonymous() || cppEnum->isPrivate())
continue;
EnumTypeEntry* enumType = cppEnum->typeEntry();
@@ -441,7 +449,7 @@ bool HeaderGenerator::finishGeneration()
writeSbkTypeFunction(typeFunctions, metaClass);
}
- foreach (const AbstractMetaType *metaType, instantiatedSmartPointers()) {
+ for (const AbstractMetaType *metaType : instantiatedSmartPtrs) {
const TypeEntry *classType = metaType->typeEntry();
includes << classType->include();
writeSbkTypeFunction(typeFunctions, metaType);
@@ -477,25 +485,27 @@ bool HeaderGenerator::finishGeneration()
QStringList requiredTargetImports = TypeDatabase::instance()->requiredTargetImports();
if (!requiredTargetImports.isEmpty()) {
s << "// Module Includes" << endl;
- foreach (const QString& requiredModule, requiredTargetImports)
+ for (const QString &requiredModule : qAsConst(requiredTargetImports))
s << "#include <" << getModuleHeaderFileName(requiredModule) << ">" << endl;
s << endl;
}
s << "// Binded library includes" << endl;
- foreach (const Include& include, includes)
+ for (const Include &include : qAsConst(includes))
s << include;
if (!primitiveTypes().isEmpty()) {
s << "// Conversion Includes - Primitive Types" << endl;
- foreach (const PrimitiveTypeEntry* ptype, primitiveTypes())
+ const PrimitiveTypeEntryList &primitiveTypeList = primitiveTypes();
+ for (const PrimitiveTypeEntry *ptype : primitiveTypeList)
s << ptype->include();
s << endl;
}
if (!containerTypes().isEmpty()) {
s << "// Conversion Includes - Container Types" << endl;
- foreach (const ContainerTypeEntry* ctype, containerTypes())
+ const ContainerTypeEntryList &containerTypeList = containerTypes();
+ for (const ContainerTypeEntry *ctype : containerTypeList)
s << ctype->include();
s << endl;
}
@@ -560,13 +570,14 @@ void HeaderGenerator::writeSbkTypeFunction(QTextStream &s, const AbstractMetaTyp
void HeaderGenerator::writeInheritedOverloads(QTextStream& s)
{
- foreach (const AbstractMetaFunction* func, m_inheritedOverloads) {
+ for (const AbstractMetaFunction *func : qAsConst(m_inheritedOverloads)) {
s << INDENT << "inline ";
s << functionSignature(func, QString(), QString(), Generator::EnumAsInts|Generator::OriginalTypeDescription) << " { ";
s << (func->type() ? "return " : "");
s << func->ownerClass()->qualifiedCppName() << "::" << func->originalName() << '(';
QStringList args;
- foreach (const AbstractMetaArgument* arg, func->arguments()) {
+ const AbstractMetaArgumentList &arguments = func->arguments();
+ for (const AbstractMetaArgument *arg : arguments) {
QString argName = arg->name();
const TypeEntry* enumTypeEntry = 0;
if (arg->type()->isFlags())
diff --git a/sources/shiboken2/generator/shiboken2/headergenerator.h b/sources/shiboken2/generator/shiboken2/headergenerator.h
index 72dcbf69f..d9dc8ffe8 100644
--- a/sources/shiboken2/generator/shiboken2/headergenerator.h
+++ b/sources/shiboken2/generator/shiboken2/headergenerator.h
@@ -41,12 +41,12 @@ class AbstractMetaFunction;
class HeaderGenerator : public ShibokenGenerator
{
public:
- QMap<QString, QString> options() const { return QMap<QString, QString>(); }
+ OptionDescriptions options() const override { return OptionDescriptions(); }
protected:
- QString fileNamePrefix() const;
- QString fileNameForContext(GeneratorContext &context) const;
- void generateClass(QTextStream& s, GeneratorContext &classContext);
- bool finishGeneration();
+ QString fileNamePrefix() const override;
+ QString fileNameForContext(GeneratorContext &context) const override;
+ void generateClass(QTextStream& s, GeneratorContext &classContext) override;
+ bool finishGeneration() override;
private:
void writeCopyCtor(QTextStream &s, const AbstractMetaClass* metaClass) const;
diff --git a/sources/shiboken2/generator/shiboken2/overloaddata.cpp b/sources/shiboken2/generator/shiboken2/overloaddata.cpp
index 8731fe911..876185cbe 100644
--- a/sources/shiboken2/generator/shiboken2/overloaddata.cpp
+++ b/sources/shiboken2/generator/shiboken2/overloaddata.cpp
@@ -53,7 +53,8 @@ static QString getTypeName(const AbstractMetaType* type)
QString typeName = typeEntry->name();
if (typeEntry->isContainer()) {
QStringList types;
- foreach (const AbstractMetaType* cType, type->instantiations()) {
+ const AbstractMetaTypeList &instantiations = type->instantiations();
+ for (const AbstractMetaType *cType : instantiations) {
const TypeEntry *typeEntry = getReferencedTypeEntry(cType->typeEntry());
types << typeEntry->name();
}
@@ -144,7 +145,8 @@ static QString getImplicitConversionTypeName(const AbstractMetaType* containerTy
impConv = getTypeName(function->arguments().first()->type());
QStringList types;
- foreach (const AbstractMetaType* otherType, containerType->instantiations())
+ const AbstractMetaTypeList &instantiations = containerType->instantiations();
+ for (const AbstractMetaType *otherType : instantiations)
types << (otherType == instantiation ? impConv : getTypeName(otherType));
const ContainerTypeEntry* containerTypeEntry = dynamic_cast<const ContainerTypeEntry*>(containerType->typeEntry());
@@ -153,7 +155,7 @@ static QString getImplicitConversionTypeName(const AbstractMetaType* containerTy
}
static QString msgCyclicDependency(const QString &funcName, const QString &graphName,
- const QList<const AbstractMetaFunction *> &involvedConversions)
+ const OverloadData::MetaFunctionList &involvedConversions)
{
QString result;
QTextStream str(&result);
@@ -209,7 +211,7 @@ void OverloadData::sortNextOverloads()
<< QLatin1String("long");
// sort the children overloads
- foreach(OverloadData *ov, m_nextOverloadData)
+ for (OverloadData *ov : m_nextOverloadData)
ov->sortNextOverloads();
if (m_nextOverloadData.size() <= 1)
@@ -218,7 +220,7 @@ void OverloadData::sortNextOverloads()
// Populates the OverloadSortData object containing map and reverseMap, to map type names to ids,
// these ids will be used by the topological sort algorithm, because is easier and faster to work
// with graph sorting using integers.
- foreach(OverloadData* ov, m_nextOverloadData) {
+ for (OverloadData *ov : m_nextOverloadData) {
sortData.mapType(ov);
const QString typeName(getTypeName(ov));
@@ -240,7 +242,8 @@ void OverloadData::sortNextOverloads()
qstringIndex = sortData.lastProcessedItemId();
}
- foreach (const AbstractMetaType* instantiation, ov->argType()->instantiations()) {
+ const AbstractMetaTypeList &instantiations = ov->argType()->instantiations();
+ for (const AbstractMetaType *instantiation : instantiations) {
// Add dependencies for type instantiation of container.
QString typeName = getTypeName(instantiation);
sortData.mapType(typeName);
@@ -251,10 +254,11 @@ void OverloadData::sortNextOverloads()
// as Point must come before the PointF instantiation, or else list<Point> will never
// be called. In the case of primitive types, list<double> must come before list<int>.
if (instantiation->isPrimitive() && (signedIntegerPrimitives.contains(instantiation->name()))) {
- foreach (const QString& primitive, nonIntegerPrimitives)
+ for (const QString &primitive : qAsConst(nonIntegerPrimitives))
sortData.mapType(getImplicitConversionTypeName(ov->argType(), instantiation, 0, primitive));
} else {
- foreach (const AbstractMetaFunction* function, m_generator->implicitConversions(instantiation))
+ const AbstractMetaFunctionList &funcs = m_generator->implicitConversions(instantiation);
+ for (const AbstractMetaFunction *function : funcs)
sortData.mapType(getImplicitConversionTypeName(ov->argType(), instantiation, function));
}
}
@@ -287,15 +291,16 @@ void OverloadData::sortNextOverloads()
QStringList classesWithIntegerImplicitConversion;
- QList<const AbstractMetaFunction *> involvedConversions;
+ MetaFunctionList involvedConversions;
- foreach(OverloadData* ov, m_nextOverloadData) {
+ for (OverloadData *ov : m_nextOverloadData) {
const AbstractMetaType* targetType = ov->argType();
const QString targetTypeEntryName(getTypeName(ov));
int targetTypeId = sortData.map[targetTypeEntryName];
// Process implicit conversions
- foreach(AbstractMetaFunction* function, m_generator->implicitConversions(targetType)) {
+ const AbstractMetaFunctionList &functions = m_generator->implicitConversions(targetType);
+ for (AbstractMetaFunction *function : functions) {
QString convertibleType;
if (function->isConversionOperator())
convertibleType = function->ownerClass()->typeEntry()->name();
@@ -320,7 +325,8 @@ void OverloadData::sortNextOverloads()
// Process inheritance relationships
if (targetType->isValue() || targetType->isObject()) {
const AbstractMetaClass *metaClass = AbstractMetaClass::findClass(m_generator->classes(), targetType->typeEntry());
- foreach (const AbstractMetaClass* ancestor, m_generator->getAllAncestors(metaClass)) {
+ const AbstractMetaClassList &ancestors = m_generator->getAllAncestors(metaClass);
+ for (const AbstractMetaClass *ancestor : ancestors) {
QString ancestorTypeName = ancestor->typeEntry()->name();
if (!sortData.map.contains(ancestorTypeName))
continue;
@@ -331,7 +337,8 @@ void OverloadData::sortNextOverloads()
}
// Process template instantiations
- foreach (const AbstractMetaType* instantiation, targetType->instantiations()) {
+ const AbstractMetaTypeList &instantiations = targetType->instantiations();
+ for (const AbstractMetaType *instantiation : instantiations) {
if (sortData.map.contains(getTypeName(instantiation))) {
int convertible = sortData.map[getTypeName(instantiation)];
@@ -339,14 +346,15 @@ void OverloadData::sortNextOverloads()
graph.addEdge(convertible, targetTypeId);
if (instantiation->isPrimitive() && (signedIntegerPrimitives.contains(instantiation->name()))) {
- foreach (const QString& primitive, nonIntegerPrimitives) {
+ for (const QString &primitive : qAsConst(nonIntegerPrimitives)) {
QString convertibleTypeName = getImplicitConversionTypeName(ov->argType(), instantiation, 0, primitive);
if (!graph.containsEdge(targetTypeId, sortData.map[convertibleTypeName])) // Avoid cyclic dependency.
graph.addEdge(sortData.map[convertibleTypeName], targetTypeId);
}
} else {
- foreach (const AbstractMetaFunction* function, m_generator->implicitConversions(instantiation)) {
+ const AbstractMetaFunctionList &funcs = m_generator->implicitConversions(instantiation);
+ for (const AbstractMetaFunction *function : funcs) {
QString convertibleTypeName = getImplicitConversionTypeName(ov->argType(), instantiation, function);
if (!graph.containsEdge(targetTypeId, sortData.map[convertibleTypeName])) { // Avoid cyclic dependency.
graph.addEdge(sortData.map[convertibleTypeName], targetTypeId);
@@ -396,22 +404,22 @@ void OverloadData::sortNextOverloads()
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) {
+ for (OverloadData *ov : m_nextOverloadData) {
const AbstractMetaType* targetType = ov->argType();
if (!targetType->isEnum())
continue;
QString targetTypeEntryName = getTypeName(targetType);
// Enum values must precede types implicitly convertible from "int" or "unsigned int".
- foreach (const QString& implicitFromInt, classesWithIntegerImplicitConversion)
+ for (const QString &implicitFromInt : qAsConst(classesWithIntegerImplicitConversion))
graph.addEdge(sortData.map[targetTypeEntryName], sortData.map[implicitFromInt]);
}
// Special case for double(int i) (not tracked by m_generator->implicitConversions
- foreach (const QString& signedIntegerName, signedIntegerPrimitives) {
+ for (const QString &signedIntegerName : qAsConst(signedIntegerPrimitives)) {
if (sortData.map.contains(signedIntegerName)) {
- foreach (const QString& nonIntegerName, nonIntegerPrimitives) {
+ for (const QString &nonIntegerName : qAsConst(nonIntegerPrimitives)) {
if (sortData.map.contains(nonIntegerName))
graph.addEdge(sortData.map[nonIntegerName], sortData.map[signedIntegerName]);
}
@@ -419,7 +427,7 @@ void OverloadData::sortNextOverloads()
}
// sort the overloads topologically based on the dependency graph.
- QLinkedList<int> unmappedResult = graph.topologicalSort();
+ const QLinkedList<int> unmappedResult = graph.topologicalSort();
if (unmappedResult.isEmpty()) {
QString funcName = referenceFunction()->name();
if (referenceFunction()->ownerClass())
@@ -436,7 +444,7 @@ void OverloadData::sortNextOverloads()
}
m_nextOverloadData.clear();
- foreach(int i, unmappedResult) {
+ for (int i : unmappedResult) {
if (!sortData.reverseMap[i])
continue;
m_nextOverloadData << sortData.reverseMap[i];
@@ -464,7 +472,7 @@ OverloadData::OverloadData(const AbstractMetaFunctionList& overloads, const Shib
: m_minArgs(256), m_maxArgs(0), m_argPos(-1), m_argType(0),
m_headOverloadData(this), m_previousOverloadData(0), m_generator(generator)
{
- foreach (const AbstractMetaFunction* func, overloads) {
+ for (const AbstractMetaFunction *func : overloads) {
m_overloads.append(func);
int argSize = func->arguments().size() - numberOfRemovedArguments(func);
if (m_minArgs > argSize)
@@ -472,7 +480,8 @@ OverloadData::OverloadData(const AbstractMetaFunctionList& overloads, const Shib
else if (m_maxArgs < argSize)
m_maxArgs = argSize;
OverloadData* currentOverloadData = this;
- foreach (const AbstractMetaArgument* arg, func->arguments()) {
+ const AbstractMetaArgumentList &arguments = func->arguments();
+ for (const AbstractMetaArgument *arg : arguments) {
if (func->argumentRemoved(arg->argumentIndex() + 1))
continue;
currentOverloadData = currentOverloadData->addOverloadData(func, arg);
@@ -528,7 +537,7 @@ OverloadData* OverloadData::addOverloadData(const AbstractMetaFunction* func,
const AbstractMetaType* argType = arg->type();
OverloadData* overloadData = 0;
if (!func->isOperatorOverload()) {
- foreach (OverloadData* tmp, m_nextOverloadData) {
+ for (OverloadData *tmp : qAsConst(m_nextOverloadData)) {
// TODO: 'const char *', 'char *' and 'char' will have the same TypeEntry?
// If an argument have a type replacement, then we should create a new overloaddata
@@ -560,7 +569,7 @@ OverloadData* OverloadData::addOverloadData(const AbstractMetaFunction* func,
QStringList OverloadData::returnTypes() const
{
QSet<QString> retTypes;
- foreach (const AbstractMetaFunction* func, m_overloads) {
+ for (const AbstractMetaFunction *func : m_overloads) {
if (!func->typeReplaced(0).isEmpty())
retTypes << func->typeReplaced(0);
else if (func->type() && !func->argumentRemoved(0))
@@ -579,7 +588,7 @@ bool OverloadData::hasNonVoidReturnType() const
bool OverloadData::hasVarargs() const
{
- foreach (const AbstractMetaFunction* func, m_overloads) {
+ for (const AbstractMetaFunction *func : m_overloads) {
AbstractMetaArgumentList args = func->arguments();
if (args.size() > 1 && args.last()->type()->isVarargs())
return true;
@@ -589,7 +598,7 @@ bool OverloadData::hasVarargs() const
bool OverloadData::hasAllowThread() const
{
- foreach (const AbstractMetaFunction* func, m_overloads) {
+ for (const AbstractMetaFunction *func : m_overloads) {
if (func->allowThread())
return true;
}
@@ -598,7 +607,7 @@ bool OverloadData::hasAllowThread() const
bool OverloadData::hasStaticFunction(const AbstractMetaFunctionList& overloads)
{
- foreach (const AbstractMetaFunction* func, overloads) {
+ for (const AbstractMetaFunction *func : qAsConst(overloads)) {
if (func->isStatic())
return true;
}
@@ -607,7 +616,7 @@ bool OverloadData::hasStaticFunction(const AbstractMetaFunctionList& overloads)
bool OverloadData::hasStaticFunction() const
{
- foreach (const AbstractMetaFunction* func, m_overloads) {
+ for (const AbstractMetaFunction *func : m_overloads) {
if (func->isStatic())
return true;
}
@@ -616,7 +625,7 @@ bool OverloadData::hasStaticFunction() const
bool OverloadData::hasInstanceFunction(const AbstractMetaFunctionList& overloads)
{
- foreach (const AbstractMetaFunction* func, overloads) {
+ for (const AbstractMetaFunction *func : qAsConst(overloads)) {
if (!func->isStatic())
return true;
}
@@ -625,7 +634,7 @@ bool OverloadData::hasInstanceFunction(const AbstractMetaFunctionList& overloads
bool OverloadData::hasInstanceFunction() const
{
- foreach (const AbstractMetaFunction* func, m_overloads) {
+ for (const AbstractMetaFunction *func : m_overloads) {
if (!func->isStatic())
return true;
}
@@ -670,7 +679,8 @@ OverloadDataList OverloadData::overloadDataOnPosition(OverloadData* overloadData
if (overloadData->argPos() == argPos) {
overloadDataList.append(overloadData);
} else if (overloadData->argPos() < argPos) {
- foreach (OverloadData* pd, overloadData->nextOverloadData())
+ const OverloadDataList &data = overloadData->nextOverloadData();
+ for (OverloadData *pd : data)
overloadDataList += overloadDataOnPosition(pd, argPos);
}
return overloadDataList;
@@ -685,7 +695,7 @@ OverloadDataList OverloadData::overloadDataOnPosition(int argPos) const
bool OverloadData::nextArgumentHasDefaultValue() const
{
- foreach (OverloadData* overloadData, m_nextOverloadData) {
+ for (OverloadData *overloadData : m_nextOverloadData) {
if (overloadData->getFunctionWithDefaultValue())
return true;
}
@@ -698,7 +708,8 @@ static OverloadData* _findNextArgWithDefault(OverloadData* overloadData)
return overloadData;
OverloadData* result = 0;
- foreach (OverloadData* odata, overloadData->nextOverloadData()) {
+ const OverloadDataList &data = overloadData->nextOverloadData();
+ for (OverloadData *odata : data) {
OverloadData* tmp = _findNextArgWithDefault(odata);
if (!result || (tmp && result->argPos() > tmp->argPos()))
result = tmp;
@@ -713,20 +724,20 @@ OverloadData* OverloadData::findNextArgWithDefault()
bool OverloadData::isFinalOccurrence(const AbstractMetaFunction* func) const
{
- foreach (const OverloadData* pd, m_nextOverloadData) {
+ for (const OverloadData *pd : m_nextOverloadData) {
if (pd->overloads().contains(func))
return false;
}
return true;
}
-QList<const AbstractMetaFunction*> OverloadData::overloadsWithoutRepetition() const
+OverloadData::MetaFunctionList OverloadData::overloadsWithoutRepetition() const
{
- QList<const AbstractMetaFunction*> overloads = m_overloads;
- foreach (const AbstractMetaFunction* func, m_overloads) {
+ MetaFunctionList overloads = m_overloads;
+ for (const AbstractMetaFunction *func : m_overloads) {
if (func->minimalSignature().endsWith(QLatin1String("const")))
continue;
- foreach (const AbstractMetaFunction* f, overloads) {
+ for (const AbstractMetaFunction *f : qAsConst(overloads)) {
if ((func->minimalSignature() + QLatin1String("const")) == f->minimalSignature()) {
overloads.removeOne(f);
break;
@@ -738,7 +749,7 @@ QList<const AbstractMetaFunction*> OverloadData::overloadsWithoutRepetition() co
const AbstractMetaFunction* OverloadData::getFunctionWithDefaultValue() const
{
- foreach (const AbstractMetaFunction* func, m_overloads) {
+ for (const AbstractMetaFunction *func : m_overloads) {
int removedArgs = 0;
for (int i = 0; i <= m_argPos + removedArgs; i++) {
if (func->argumentRemoved(i + 1))
@@ -750,11 +761,11 @@ const AbstractMetaFunction* OverloadData::getFunctionWithDefaultValue() const
return 0;
}
-QList<int> OverloadData::invalidArgumentLengths() const
+QVector<int> OverloadData::invalidArgumentLengths() const
{
QSet<int> validArgLengths;
- foreach (const AbstractMetaFunction* func, m_headOverloadData->m_overloads) {
+ for (const AbstractMetaFunction *func : qAsConst(m_headOverloadData->m_overloads)) {
const AbstractMetaArgumentList args = func->arguments();
int offset = 0;
for (int i = 0; i < args.size(); ++i) {
@@ -768,7 +779,7 @@ QList<int> OverloadData::invalidArgumentLengths() const
validArgLengths << args.size() - offset;
}
- QList<int> invalidArgLengths;
+ QVector<int> invalidArgLengths;
for (int i = minArgs() + 1; i < maxArgs(); i++) {
if (!validArgLengths.contains(i))
invalidArgLengths.append(i);
@@ -821,7 +832,7 @@ QPair<int, int> OverloadData::getMinMaxArguments(const AbstractMetaFunctionList&
bool OverloadData::isSingleArgument(const AbstractMetaFunctionList& overloads)
{
bool singleArgument = true;
- foreach (const AbstractMetaFunction* func, overloads) {
+ for (const AbstractMetaFunction *func : overloads) {
if (func->arguments().size() - numberOfRemovedArguments(func) != 1) {
singleArgument = false;
break;
@@ -859,7 +870,7 @@ QString OverloadData::dumpGraph() const
// Shows all function signatures
s << "legend [fontsize=9 fontname=freemono shape=rect label=\"";
- foreach (const AbstractMetaFunction* func, overloads()) {
+ for (const AbstractMetaFunction *func : m_overloads) {
s << "f" << functionNumber(func) << " : ";
if (func->type())
s << toHtml(func->type()->cppSignature());
@@ -893,7 +904,7 @@ QString OverloadData::dumpGraph() const
s << "</td></tr>";
// Shows type changes for all function signatures
- foreach (const AbstractMetaFunction* func, overloads()) {
+ for (const AbstractMetaFunction *func : m_overloads) {
if (func->typeReplaced(0).isEmpty())
continue;
s << "<tr><td bgcolor=\"gray\" align=\"right\">f" << functionNumber(func);
@@ -916,13 +927,13 @@ QString OverloadData::dumpGraph() const
// Overloads for the signature to present point
s << "<tr><td bgcolor=\"gray\" align=\"right\">overloads</td><td bgcolor=\"gray\" align=\"left\">";
- foreach (const AbstractMetaFunction* func, overloads())
+ for (const AbstractMetaFunction *func : m_overloads)
s << 'f' << functionNumber(func) << ' ';
s << "</td></tr>";
s << "</table>> ];" << endl;
- foreach (const OverloadData* pd, nextOverloadData())
+ for (const OverloadData *pd : m_nextOverloadData)
s << indent << '"' << rfunc->name() << "\" -> " << pd->dumpGraph();
s << "}" << endl;
@@ -948,12 +959,12 @@ QString OverloadData::dumpGraph() const
// Overloads for the signature to present point
s << "<tr><td bgcolor=\"gray\" align=\"right\">overloads</td><td bgcolor=\"gray\" align=\"left\">";
- foreach (const AbstractMetaFunction* func, overloads())
+ for (const AbstractMetaFunction *func : m_overloads)
s << 'f' << functionNumber(func) << ' ';
s << "</td></tr>";
// Show default values (original and modified) for various functions
- foreach (const AbstractMetaFunction* func, overloads()) {
+ for (const AbstractMetaFunction *func : m_overloads) {
const AbstractMetaArgument* arg = argument(func);
if (!arg)
continue;
@@ -973,7 +984,7 @@ QString OverloadData::dumpGraph() const
s << "</table>>];" << endl;
- foreach (const OverloadData* pd, nextOverloadData())
+ for (const OverloadData *pd : m_nextOverloadData)
s << indent << argId << " -> " << pd->dumpGraph();
}
return result;
@@ -1004,7 +1015,7 @@ bool OverloadData::hasArgumentWithDefaultValue(const AbstractMetaFunctionList& o
{
if (OverloadData::getMinMaxArguments(overloads).second == 0)
return false;
- foreach (const AbstractMetaFunction* func, overloads) {
+ for (const AbstractMetaFunction *func : overloads) {
if (hasArgumentWithDefaultValue(func))
return true;
}
@@ -1015,7 +1026,7 @@ bool OverloadData::hasArgumentWithDefaultValue() const
{
if (maxArgs() == 0)
return false;
- foreach (const AbstractMetaFunction* func, overloads()) {
+ for (const AbstractMetaFunction *func : m_overloads) {
if (hasArgumentWithDefaultValue(func))
return true;
}
@@ -1024,7 +1035,8 @@ bool OverloadData::hasArgumentWithDefaultValue() const
bool OverloadData::hasArgumentWithDefaultValue(const AbstractMetaFunction* func)
{
- foreach (const AbstractMetaArgument* arg, func->arguments()) {
+ const AbstractMetaArgumentList &arguments = func->arguments();
+ for (const AbstractMetaArgument *arg : arguments) {
if (func->argumentRemoved(arg->argumentIndex() + 1))
continue;
if (!ShibokenGenerator::getDefaultValue(func, arg).isEmpty())
@@ -1036,7 +1048,8 @@ bool OverloadData::hasArgumentWithDefaultValue(const AbstractMetaFunction* func)
AbstractMetaArgumentList OverloadData::getArgumentsWithDefaultValues(const AbstractMetaFunction* func)
{
AbstractMetaArgumentList args;
- foreach (AbstractMetaArgument* arg, func->arguments()) {
+ const AbstractMetaArgumentList &arguments = func->arguments();
+ for (AbstractMetaArgument *arg : arguments) {
if (ShibokenGenerator::getDefaultValue(func, arg).isEmpty()
|| func->argumentRemoved(arg->argumentIndex() + 1))
continue;
diff --git a/sources/shiboken2/generator/shiboken2/overloaddata.h b/sources/shiboken2/generator/shiboken2/overloaddata.h
index 959b96d0b..2d815f6bb 100644
--- a/sources/shiboken2/generator/shiboken2/overloaddata.h
+++ b/sources/shiboken2/generator/shiboken2/overloaddata.h
@@ -30,19 +30,21 @@
#define OVERLOADDATA_H
#include <abstractmetalang_typedefs.h>
-#include <QtCore/QList>
#include <QtCore/QBitArray>
+#include <QtCore/QVector>
QT_FORWARD_DECLARE_CLASS(QDebug)
class ShibokenGenerator;
class OverloadData;
-typedef QList<OverloadData*> OverloadDataList;
+typedef QVector<OverloadData *> OverloadDataList;
class OverloadData
{
public:
+ typedef QVector<const AbstractMetaFunction *> MetaFunctionList;
+
OverloadData(const AbstractMetaFunctionList& overloads, const ShibokenGenerator* generator);
~OverloadData();
@@ -100,12 +102,12 @@ public:
bool isFinalOccurrence(const AbstractMetaFunction* func) const;
/// Returns the list of overloads removing repeated constant functions (ex.: "foo()" and "foo()const", the second is removed).
- QList<const AbstractMetaFunction*> overloadsWithoutRepetition() const;
- const QList<const AbstractMetaFunction*>& overloads() const { return m_overloads; }
+ MetaFunctionList overloadsWithoutRepetition() const;
+ const MetaFunctionList& overloads() const { return m_overloads; }
OverloadDataList nextOverloadData() const { return m_nextOverloadData; }
OverloadData* previousOverloadData() const { return m_previousOverloadData; }
- QList<int> invalidArgumentLengths() const;
+ QVector<int> invalidArgumentLengths() const;
static int numberOfRemovedArguments(const AbstractMetaFunction* func, int finalArgPos = -1);
static QPair<int, int> getMinMaxArguments(const AbstractMetaFunctionList& overloads);
@@ -146,7 +148,7 @@ private:
int m_argPos;
const AbstractMetaType* m_argType;
QString m_argTypeReplaced;
- QList<const AbstractMetaFunction*> m_overloads;
+ MetaFunctionList m_overloads;
OverloadData* m_headOverloadData;
OverloadDataList m_nextOverloadData;
diff --git a/sources/shiboken2/generator/shiboken2/shibokengenerator.cpp b/sources/shiboken2/generator/shiboken2/shibokengenerator.cpp
index 670659854..530d9b143 100644
--- a/sources/shiboken2/generator/shiboken2/shibokengenerator.cpp
+++ b/sources/shiboken2/generator/shiboken2/shibokengenerator.cpp
@@ -35,6 +35,7 @@
#include <QtCore/QDir>
#include <QtCore/QDebug>
+#include <QtCore/QRegularExpression>
#include <limits>
#include <memory>
@@ -54,6 +55,11 @@ QHash<QString, QString> ShibokenGenerator::m_formatUnits = QHash<QString, QStrin
QHash<QString, QString> ShibokenGenerator::m_tpFuncs = QHash<QString, QString>();
QStringList ShibokenGenerator::m_knownPythonTypes = QStringList();
+static QRegularExpression placeHolderRegex(int index)
+{
+ return QRegularExpression(QLatin1Char('%') + QString::number(index) + QStringLiteral("\\b"));
+}
+
static QString resolveScopePrefix(const AbstractMetaClass* scope, const QString& value)
{
if (!scope)
@@ -87,10 +93,10 @@ ShibokenGenerator::ShibokenGenerator() : Generator()
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));
+ m_typeSystemConvRegEx[TypeSystemCheckFunction] = QRegularExpression(QLatin1String(CHECKTYPE_REGEX));
+ m_typeSystemConvRegEx[TypeSystemIsConvertibleFunction] = QRegularExpression(QLatin1String(ISCONVERTIBLE_REGEX));
+ m_typeSystemConvRegEx[TypeSystemToPythonFunction] = QRegularExpression(QLatin1String(CONVERTTOPYTHON_REGEX));
+ m_typeSystemConvRegEx[TypeSystemToCppFunction] = QRegularExpression(QLatin1String(CONVERTTOCPP_REGEX));
}
ShibokenGenerator::~ShibokenGenerator()
@@ -115,36 +121,34 @@ void ShibokenGenerator::initPrimitiveTypesCorrespondences()
// PyBool
m_pythonPrimitiveTypeName.insert(QLatin1String("bool"), QLatin1String("PyBool"));
+ const char *charTypes[] = {
+ "char", "signed char", "unsigned char"
+ };
+ for (const char *charType : charTypes)
+ m_pythonPrimitiveTypeName.insert(QLatin1String(charType), QStringLiteral("SbkChar"));
+
// 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"));
+ const char *intTypes[] = {
+ "int", "signed int", "uint", "unsigned int",
+ "short", "ushort", "signed short", "signed short int",
+ "unsigned short", "unsigned short", "unsigned short int",
+ "long"
+ };
+ for (const char *intType : intTypes)
+ m_pythonPrimitiveTypeName.insert(QLatin1String(intType), QStringLiteral("PyInt"));
// PyFloat
m_pythonPrimitiveTypeName.insert(QLatin1String("double"), QLatin1String("PyFloat"));
m_pythonPrimitiveTypeName.insert(QLatin1String("float"), QLatin1String("PyFloat"));
// 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"));
+ const char *longTypes[] = {
+ "unsigned long", "signed long", "ulong", "unsigned long int",
+ "long long", "__int64",
+ "unsigned long long", "unsigned __int64", "size_t"
+ };
+ for (const char *longType : longTypes)
+ m_pythonPrimitiveTypeName.insert(QLatin1String(longType), QStringLiteral("PyLong"));
// Python operators
m_pythonOperators.clear();
@@ -243,7 +247,8 @@ bool ShibokenGenerator::shouldGenerateCppWrapper(const AbstractMetaClass* metaCl
if (!result && metaClass->hasProtectedFunctions()) {
int protectedFunctions = 0;
int protectedOperators = 0;
- foreach (const AbstractMetaFunction* func, metaClass->functions()) {
+ const AbstractMetaFunctionList &funcs = metaClass->functions();
+ for (const AbstractMetaFunction *func : funcs) {
if (!func->isProtected() || func->isSignal() || func->isModifiedRemoved())
continue;
else if (func->isOperatorOverload())
@@ -265,7 +270,8 @@ void ShibokenGenerator::lookForEnumsInClassesNotToBeGenerated(AbstractMetaEnumLi
return;
if (metaClass->typeEntry()->codeGeneration() == TypeEntry::GenerateForSubclass) {
- foreach (const AbstractMetaEnum* metaEnum, metaClass->enums()) {
+ const AbstractMetaEnumList &enums = metaClass->enums();
+ for (const AbstractMetaEnum *metaEnum : enums) {
if (metaEnum->isPrivate() || metaEnum->typeEntry()->codeGeneration() == TypeEntry::GenerateForSubclass)
continue;
if (!enumList.contains(const_cast<AbstractMetaEnum*>(metaEnum)))
@@ -415,9 +421,10 @@ static QString searchForEnumScope(const AbstractMetaClass* metaClass, const QStr
if (!metaClass)
return QString();
-
- foreach (const AbstractMetaEnum* metaEnum, metaClass->enums()) {
- foreach (const AbstractMetaEnumValue* enumValue, metaEnum->values()) {
+ const AbstractMetaEnumList &enums = metaClass->enums();
+ for (const AbstractMetaEnum* metaEnum : enums) {
+ const AbstractMetaEnumValueList &values = metaEnum->values();
+ for (const AbstractMetaEnumValue *enumValue : values) {
if (enumValueName == enumValue->name())
return metaClass->qualifiedCppName();
}
@@ -444,7 +451,14 @@ QString ShibokenGenerator::guessScopeForDefaultValue(const AbstractMetaFunction*
if (isPointer(arg->type()))
return value;
- static QRegExp enumValueRegEx(QLatin1String("^([A-Za-z_]\\w*)?$"));
+ static const QRegularExpression enumValueRegEx(QStringLiteral("^([A-Za-z_]\\w*)?$"));
+ Q_ASSERT(enumValueRegEx.isValid());
+ // Do not qualify macros by class name, eg QSGGeometry(..., int t = GL_UNSIGNED_SHORT);
+ static const QRegularExpression macroRegEx(QStringLiteral("^[A-Z_][A-Z0-9_]*$"));
+ Q_ASSERT(macroRegEx.isValid());
+ if (arg->type()->isPrimitive() && macroRegEx.match(value).hasMatch())
+ return value;
+
QString prefix;
QString suffix;
@@ -453,8 +467,9 @@ QString ShibokenGenerator::guessScopeForDefaultValue(const AbstractMetaFunction*
if (metaEnum)
prefix = resolveScopePrefix(metaEnum->enclosingClass(), value);
} else if (arg->type()->isFlags()) {
- static QRegExp numberRegEx(QLatin1String("^\\d+$")); // Numbers to flags
- if (numberRegEx.exactMatch(value)) {
+ static const QRegularExpression numberRegEx(QStringLiteral("^\\d+$")); // Numbers to flags
+ Q_ASSERT(numberRegEx.isValid());
+ if (numberRegEx.match(value).hasMatch()) {
QString typeName = translateTypeForWrapperMethod(arg->type(), func->implementingClass());
if (arg->type()->isConstant())
typeName.remove(0, sizeof("const ") / sizeof(char) - 1);
@@ -472,16 +487,18 @@ QString ShibokenGenerator::guessScopeForDefaultValue(const AbstractMetaFunction*
suffix = QLatin1Char(')');
}
- 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(QLatin1Char('|'));
+ static const QRegularExpression enumCombinationRegEx(QStringLiteral("^([A-Za-z_][\\w:]*)\\(([^,\\(\\)]*)\\)$")); // FlagName(EnumItem|EnumItem|...)
+ Q_ASSERT(enumCombinationRegEx.isValid());
+ const QRegularExpressionMatch match = enumCombinationRegEx.match(value);
+ if (prefix.isEmpty() && match.hasMatch()) {
+ QString flagName = match.captured(1);
+ QStringList enumItems = match.captured(2).split(QLatin1Char('|'));
QString scope = searchForEnumScope(func->implementingClass(), enumItems.first());
if (!scope.isEmpty())
scope.append(QLatin1String("::"));
QStringList fixedEnumItems;
- foreach (const QString& enumItem, enumItems)
+ for (const QString &enumItem : qAsConst(enumItems))
fixedEnumItems << QString(scope + enumItem);
if (!fixedEnumItems.isEmpty()) {
@@ -492,16 +509,19 @@ QString ShibokenGenerator::guessScopeForDefaultValue(const AbstractMetaFunction*
}
} else if (arg->type()->typeEntry()->isValue()) {
const AbstractMetaClass *metaClass = AbstractMetaClass::findClass(classes(), arg->type()->typeEntry());
- if (enumValueRegEx.exactMatch(value)&& value != QLatin1String("NULL"))
+ if (enumValueRegEx.match(value).hasMatch() && value != QLatin1String("NULL"))
prefix = resolveScopePrefix(metaClass, value);
} else if (arg->type()->isPrimitive() && arg->type()->name() == QLatin1String("int")) {
- if (enumValueRegEx.exactMatch(value) && func->implementingClass())
+ if (enumValueRegEx.match(value).hasMatch() && func->implementingClass())
prefix = resolveScopePrefix(func->implementingClass(), value);
} else if(arg->type()->isPrimitive()) {
- 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()) {
+ static const QRegularExpression unknowArgumentRegEx(QStringLiteral("^(?:[A-Za-z_][\\w:]*\\()?([A-Za-z_]\\w*)(?:\\))?$")); // [PrimitiveType(] DESIREDNAME [)]
+ Q_ASSERT(unknowArgumentRegEx.isValid());
+ const QRegularExpressionMatch match = unknowArgumentRegEx.match(value);
+ if (match.hasMatch() && func->implementingClass()) {
+ const AbstractMetaFieldList &fields = func->implementingClass()->fields();
+ for (const AbstractMetaField *field : fields) {
+ if (match.captured(1).trimmed() == field->name()) {
QString fieldName = field->name();
if (field->isStatic()) {
prefix = resolveScopePrefix(func->implementingClass(), value);
@@ -510,7 +530,7 @@ QString ShibokenGenerator::guessScopeForDefaultValue(const AbstractMetaFunction*
} else {
fieldName.prepend(QLatin1String(CPP_SELF_VAR "->"));
}
- value.replace(unknowArgumentRegEx.cap(1), fieldName);
+ value.replace(match.captured(1), fieldName);
break;
}
}
@@ -622,8 +642,9 @@ bool ShibokenGenerator::shouldRejectNullPointerArgument(const AbstractMetaFuncti
return false;
if (func->argumentRemoved(argIndex + 1))
return false;
- foreach (const FunctionModification &funcMod, func->modifications()) {
- foreach (const ArgumentModification &argMod, funcMod.argument_mods) {
+ const FunctionModificationList &mods = func->modifications();
+ for (const FunctionModification &funcMod : mods) {
+ for (const ArgumentModification &argMod : funcMod.argument_mods) {
if (argMod.index == argIndex + 1 && argMod.noNullPointers)
return true;
}
@@ -635,7 +656,8 @@ QString ShibokenGenerator::getFormatUnitString(const AbstractMetaFunction* func,
{
QString result;
const char objType = (incRef ? 'O' : 'N');
- foreach (const AbstractMetaArgument* arg, func->arguments()) {
+ const AbstractMetaArgumentList &arguments = func->arguments();
+ for (const AbstractMetaArgument *arg : arguments) {
if (func->argumentRemoved(arg->argumentIndex() + 1))
continue;
@@ -758,6 +780,13 @@ QString ShibokenGenerator::converterObject(const AbstractMetaType* type)
return QLatin1String("Shiboken::Conversions::PrimitiveTypeConverter<const char*>()");
if (isVoidPointer(type))
return QLatin1String("Shiboken::Conversions::PrimitiveTypeConverter<void*>()");
+ const AbstractMetaTypeCList nestedArrayTypes = type->nestedArrayTypes();
+ if (!nestedArrayTypes.isEmpty() && nestedArrayTypes.constLast()->isCppPrimitive()) {
+ return QStringLiteral("Shiboken::Conversions::ArrayTypeConverter<")
+ + nestedArrayTypes.constLast()->minimalSignature()
+ + QLatin1String(">(") + QString::number(nestedArrayTypes.size())
+ + QLatin1Char(')');
+ }
if (type->typeEntry()->isContainer()) {
return convertersVariableName(type->typeEntry()->targetLangPackage())
+ QLatin1Char('[') + getTypeIndexVariableName(type) + QLatin1Char(']');
@@ -983,6 +1012,8 @@ bool ShibokenGenerator::isValueTypeWithCopyConstructorOnly(const AbstractMetaCla
{
if (!metaClass || !metaClass->typeEntry()->isValue())
return false;
+ if ((metaClass->attributes() & AbstractMetaAttributes::HasRejectedConstructor) != 0)
+ return false;
AbstractMetaFunctionList ctors = metaClass->queryFunctions(AbstractMetaClass::Constructors);
if (ctors.count() != 1)
return false;
@@ -1054,7 +1085,8 @@ bool ShibokenGenerator::shouldDereferenceAbstractMetaTypePointer(const AbstractM
bool ShibokenGenerator::visibilityModifiedToPrivate(const AbstractMetaFunction* func)
{
- foreach (const FunctionModification &mod, func->modifications()) {
+ const FunctionModificationList &mods = func->modifications();
+ for (const FunctionModification &mod : mods) {
if (mod.modifiers & Modification::Private)
return true;
}
@@ -1208,8 +1240,8 @@ QString ShibokenGenerator::cpythonIsConvertibleFunction(const AbstractMetaType*
return customCheck;
}
+ QString result = QLatin1String("Shiboken::Conversions::");
if (isWrapperType(metaType)) {
- QString result = QLatin1String("Shiboken::Conversions::");
if (isPointer(metaType) || isValueTypeWithCopyConstructorOnly(metaType))
result += QLatin1String("isPythonToCppPointerConvertible");
else if (metaType->referenceType() == LValueReference)
@@ -1220,8 +1252,18 @@ QString ShibokenGenerator::cpythonIsConvertibleFunction(const AbstractMetaType*
+ cpythonTypeNameExt(metaType) + QLatin1String("), ");
return result;
}
- return QStringLiteral("Shiboken::Conversions::isPythonToCppConvertible(%1, ")
- .arg(converterObject(metaType));
+ result += QLatin1String("isPythonToCppConvertible(") + converterObject(metaType);
+ // Write out array sizes if known
+ const AbstractMetaTypeCList nestedArrayTypes = metaType->nestedArrayTypes();
+ if (!nestedArrayTypes.isEmpty() && nestedArrayTypes.constLast()->isCppPrimitive()) {
+ const int dim1 = metaType->arrayElementCount();
+ const int dim2 = nestedArrayTypes.constFirst()->isArray()
+ ? nestedArrayTypes.constFirst()->arrayElementCount() : -1;
+ result += QLatin1String(", ") + QString::number(dim1)
+ + QLatin1String(", ") + QString::number(dim2);
+ }
+ result += QLatin1String(", ");
+ return result;
}
QString ShibokenGenerator::cpythonIsConvertibleFunction(const AbstractMetaArgument *metaArg, bool genericNumberType)
@@ -1306,12 +1348,14 @@ QString ShibokenGenerator::argumentString(const AbstractMetaFunction *func,
arg = modified_type.replace(QLatin1Char('$'), QLatin1Char('.'));
if (!(options & Generator::SkipName)) {
- arg += QLatin1Char(' ');
- arg += argument->name();
+ // "int a", "int a[]"
+ const int arrayPos = arg.indexOf(QLatin1Char('['));
+ if (arrayPos != -1)
+ arg.insert(arrayPos, QLatin1Char(' ') + argument->name());
+ else
+ arg.append(QLatin1Char(' ') + argument->name());
}
- QList<ReferenceCount> referenceCounts;
- referenceCounts = func->referenceCounts(func->implementingClass(), argument->argumentIndex() + 1);
if ((options & Generator::SkipDefaultValues) != Generator::SkipDefaultValues &&
!argument->originalDefaultValueExpression().isEmpty())
{
@@ -1445,7 +1489,8 @@ void ShibokenGenerator::writeUnusedVariableCast(QTextStream& s, const QString& v
AbstractMetaFunctionList ShibokenGenerator::filterFunctions(const AbstractMetaClass* metaClass)
{
AbstractMetaFunctionList result;
- foreach (AbstractMetaFunction *func, metaClass->functions()) {
+ const AbstractMetaFunctionList &funcs = metaClass->functions();
+ for (AbstractMetaFunction *func : funcs) {
if (func->isSignal() || func->isDestructor() || func->usesRValueReferences()
|| (func->isModifiedRemoved() && !func->isAbstract()
&& (!avoidProtectedHack() || !func->isProtected())))
@@ -1458,11 +1503,13 @@ AbstractMetaFunctionList ShibokenGenerator::filterFunctions(const AbstractMetaCl
ShibokenGenerator::ExtendedConverterData ShibokenGenerator::getExtendedConverters() const
{
ExtendedConverterData extConvs;
- foreach (const AbstractMetaClass* metaClass, classes()) {
+ const AbstractMetaClassList &classList = classes();
+ for (const AbstractMetaClass *metaClass : classList) {
// Use only the classes for the current module.
if (!shouldGenerate(metaClass))
continue;
- foreach (AbstractMetaFunction* convOp, metaClass->operatorOverloads(AbstractMetaClass::ConversionOp)) {
+ const AbstractMetaFunctionList &overloads = metaClass->operatorOverloads(AbstractMetaClass::ConversionOp);
+ for (AbstractMetaFunction *convOp : overloads) {
// Get only the conversion operators that return a type from another module,
// that are value-types and were not removed in the type system.
const TypeEntry* convType = convOp->type()->typeEntry();
@@ -1476,10 +1523,11 @@ ShibokenGenerator::ExtendedConverterData ShibokenGenerator::getExtendedConverter
return extConvs;
}
-QList<const CustomConversion*> ShibokenGenerator::getPrimitiveCustomConversions()
+QVector<const CustomConversion *> ShibokenGenerator::getPrimitiveCustomConversions()
{
- QList<const CustomConversion*> conversions;
- foreach (const PrimitiveTypeEntry* type, primitiveTypes()) {
+ QVector<const CustomConversion*> conversions;
+ const PrimitiveTypeEntryList &primitiveTypeList = primitiveTypes();
+ for (const PrimitiveTypeEntry *type : primitiveTypeList) {
if (!shouldGenerateTypeEntry(type) || !isUserPrimitive(type) || !type->customConversion())
continue;
@@ -1522,7 +1570,7 @@ QString ShibokenGenerator::getCodeSnippets(const CodeSnipList& codeSnips,
{
QString code;
QTextStream c(&code);
- foreach (const CodeSnip &snip, codeSnips) {
+ for (const CodeSnip &snip : codeSnips) {
if ((position != TypeSystem::CodeSnipPositionAny && snip.position != position) || !(snip.language & language))
continue;
QString snipCode;
@@ -1623,6 +1671,17 @@ void ShibokenGenerator::writeCodeSnips(QTextStream& s,
s << INDENT << "// End of code injection" << endl;
}
+static QString msgWrongIndex(const char *varName, const QString &capture, const AbstractMetaFunction *func)
+{
+ QString result;
+ QTextStream str(&result);
+ str << "Wrong index for " << varName << " variable (" << capture << ") on ";
+ if (const AbstractMetaClass *c = func->implementingClass())
+ str << c->name() << "::";
+ str << func->signature();
+ return result;
+}
+
void ShibokenGenerator::writeCodeSnips(QTextStream& s,
const CodeSnipList& codeSnips,
TypeSystem::CodeSnipPosition position,
@@ -1647,15 +1706,18 @@ void ShibokenGenerator::writeCodeSnips(QTextStream& s,
// Replace %PYARG_# variables.
code.replace(QLatin1String("%PYARG_0"), QLatin1String(PYTHON_RETURN_VAR));
- static QRegExp pyArgsRegex(QLatin1String("%PYARG_(\\d+)"));
+ static const QRegularExpression pyArgsRegex(QStringLiteral("%PYARG_(\\d+)"));
+ Q_ASSERT(pyArgsRegex.isValid());
if (language == TypeSystem::TargetLangCode) {
if (usePyArgs) {
code.replace(pyArgsRegex, QLatin1String(PYTHON_ARGS"[\\1-1]"));
} else {
- static QRegExp pyArgsRegexCheck(QLatin1String("%PYARG_([2-9]+)"));
- if (pyArgsRegexCheck.indexIn(code) != -1) {
+ static const QRegularExpression pyArgsRegexCheck(QStringLiteral("%PYARG_([2-9]+)"));
+ Q_ASSERT(pyArgsRegexCheck.isValid());
+ const QRegularExpressionMatch match = pyArgsRegexCheck.match(code);
+ if (match.hasMatch()) {
qCWarning(lcShiboken).noquote().nospace()
- << "Wrong index for %PYARG variable (" << pyArgsRegexCheck.cap(1) << ") on " << func->signature();
+ << msgWrongIndex("%PYARG", match.captured(1), func);
return;
}
code.replace(QLatin1String("%PYARG_1"), QLatin1String(PYTHON_ARG));
@@ -1663,25 +1725,27 @@ void ShibokenGenerator::writeCodeSnips(QTextStream& s,
} else {
// Replaces the simplest case of attribution to a
// Python argument on the binding virtual method.
- static QRegExp pyArgsAttributionRegex(QLatin1String("%PYARG_(\\d+)\\s*=[^=]\\s*([^;]+)"));
+ static const QRegularExpression pyArgsAttributionRegex(QStringLiteral("%PYARG_(\\d+)\\s*=[^=]\\s*([^;]+)"));
+ Q_ASSERT(pyArgsAttributionRegex.isValid());
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()) {
+ const AbstractMetaArgumentList &arguments = func->arguments();
+ for (const AbstractMetaArgument *arg : arguments) {
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(QLatin1String("%ARG(\\d+)_TYPE"));
- while ((pos = cppArgTypeRegexCheck.indexIn(code, pos)) != -1) {
+ static const QRegularExpression cppArgTypeRegexCheck(QStringLiteral("%ARG(\\d+)_TYPE"));
+ Q_ASSERT(cppArgTypeRegexCheck.isValid());
+ QRegularExpressionMatchIterator rit = cppArgTypeRegexCheck.globalMatch(code);
+ while (rit.hasNext()) {
+ QRegularExpressionMatch match = rit.next();
qCWarning(lcShiboken).noquote().nospace()
- << "Wrong index for %ARG#_TYPE variable (" << cppArgTypeRegexCheck.cap(1)
- << ") on " << func->signature();
- pos += cppArgTypeRegexCheck.matchedLength();
+ << msgWrongIndex("%ARG#_TYPE", match.captured(1), func);
}
// Replace template variable for return variable name.
@@ -1762,17 +1826,17 @@ void ShibokenGenerator::writeCodeSnips(QTextStream& s,
// Replaces template %ARGUMENT_NAMES and %# variables by argument variables and values.
// Replaces template variables %# for individual arguments.
- ArgumentVarReplacementList argReplacements = getArgumentReplacement(func, usePyArgs, language, lastArg);
+ const ArgumentVarReplacementList &argReplacements = getArgumentReplacement(func, usePyArgs, language, lastArg);
QStringList args;
- foreach (const ArgumentVarReplacementPair &pair, argReplacements) {
+ for (const ArgumentVarReplacementPair &pair : argReplacements) {
if (pair.second.startsWith(QLatin1String(CPP_ARG_REMOVED)))
continue;
args << pair.second;
}
code.replace(QLatin1String("%ARGUMENT_NAMES"), args.join(QLatin1String(", ")));
- foreach (const ArgumentVarReplacementPair &pair, argReplacements) {
+ for (const ArgumentVarReplacementPair &pair : argReplacements) {
const AbstractMetaArgument* arg = pair.first;
int idx = arg->argumentIndex() + 1;
AbstractMetaType* type = arg->type();
@@ -1789,7 +1853,7 @@ void ShibokenGenerator::writeCodeSnips(QTextStream& s,
if (type->referenceType() == LValueReference || isPointer(type))
code.replace(QString::fromLatin1("%%1.").arg(idx), replacement + QLatin1String("->"));
}
- code.replace(QRegExp(QString::fromLatin1("%%1\\b").arg(idx)), pair.second);
+ code.replace(placeHolderRegex(idx), pair.second);
}
if (language == TypeSystem::NativeCode) {
@@ -1811,7 +1875,8 @@ void ShibokenGenerator::writeCodeSnips(QTextStream& s,
// dispatcher.
bool hasProtectedOverload = false;
if (func->isUserAdded()) {
- foreach (const AbstractMetaFunction* f, getFunctionOverloads(func->ownerClass(), func->name()))
+ const AbstractMetaFunctionList &funcs = getFunctionOverloads(func->ownerClass(), func->name());
+ for (const AbstractMetaFunction *f : funcs)
hasProtectedOverload |= f->isProtected();
}
@@ -1842,8 +1907,9 @@ void ShibokenGenerator::writeCodeSnips(QTextStream& s,
// and false if it is a variable.
static bool isVariable(const QString& code)
{
- static QRegExp expr(QLatin1String("\\s*\\*?\\s*[A-Za-z_][A-Za-z_0-9.]*\\s*(?:\\[[^\\[]+\\])*"));
- return expr.exactMatch(code.trimmed());
+ static const QRegularExpression expr(QStringLiteral("^\\s*\\*?\\s*[A-Za-z_][A-Za-z_0-9.]*\\s*(?:\\[[^\\[]+\\])*$"));
+ Q_ASSERT(expr.isValid());
+ return expr.match(code.trimmed()).hasMatch();
}
// A miniature normalizer that puts a type string into a format
@@ -1893,12 +1959,11 @@ static QString getConverterTypeSystemVariableArgument(const QString& code, int p
typedef QPair<QString, QString> StringPair;
void ShibokenGenerator::replaceConverterTypeSystemVariable(TypeSystemConverterVariable converterVariable, QString& code)
{
- QRegExp& regex = m_typeSystemConvRegEx[converterVariable];
- int pos = 0;
- QList<StringPair> replacements;
- while ((pos = regex.indexIn(code, pos)) != -1) {
- pos += regex.matchedLength();
- QStringList list = regex.capturedTexts();
+ QVector<StringPair> replacements;
+ QRegularExpressionMatchIterator rit = m_typeSystemConvRegEx[converterVariable].globalMatch(code);
+ while (rit.hasNext()) {
+ const QRegularExpressionMatch match = rit.next();
+ const QStringList list = match.capturedTexts();
QString conversionString = list.first();
QString conversionTypeName = list.last();
const AbstractMetaType* conversionType = buildAbstractMetaTypeFromString(conversionTypeName);
@@ -1912,7 +1977,7 @@ void ShibokenGenerator::replaceConverterTypeSystemVariable(TypeSystemConverterVa
QTextStream c(&conversion);
switch (converterVariable) {
case TypeSystemToCppFunction: {
- int end = pos - list.first().count();
+ int end = match.capturedStart();
int start = end;
while (start > 0 && code.at(start) != QLatin1Char('\n'))
--start;
@@ -1941,7 +2006,7 @@ void ShibokenGenerator::replaceConverterTypeSystemVariable(TypeSystemConverterVa
} else {
prefix = QLatin1Char('&');
}
- QString arg = getConverterTypeSystemVariableArgument(code, pos);
+ QString arg = getConverterTypeSystemVariableArgument(code, match.capturedEnd());
conversionString += arg;
c << arg << ", " << prefix << '(' << varName << ')';
break;
@@ -1961,7 +2026,7 @@ void ShibokenGenerator::replaceConverterTypeSystemVariable(TypeSystemConverterVa
if (conversion.isEmpty())
conversion = cpythonToPythonConversionFunction(conversionType);
default: {
- QString arg = getConverterTypeSystemVariableArgument(code, pos);
+ QString arg = getConverterTypeSystemVariableArgument(code, match.capturedEnd());
conversionString += arg;
if (converterVariable == TypeSystemToPythonFunction && !isVariable(arg)) {
qFatal(qPrintable(QString::fromLatin1("Only variables are acceptable as argument to %%CONVERTTOPYTHON type system variable on code snippet: '%1'")
@@ -1977,14 +2042,14 @@ void ShibokenGenerator::replaceConverterTypeSystemVariable(TypeSystemConverterVa
}
replacements.append(qMakePair(conversionString, conversion));
}
- foreach (const StringPair &rep, replacements)
+ for (const StringPair &rep : qAsConst(replacements))
code.replace(rep.first, rep.second);
}
bool ShibokenGenerator::injectedCodeUsesCppSelf(const AbstractMetaFunction* func)
{
CodeSnipList snips = func->injectedCodeSnips(TypeSystem::CodeSnipPositionAny, TypeSystem::TargetLangCode);
- foreach (const CodeSnip &snip, snips) {
+ for (const CodeSnip &snip : qAsConst(snips)) {
if (snip.code().contains(QLatin1String("%CPPSELF")))
return true;
}
@@ -1994,7 +2059,7 @@ bool ShibokenGenerator::injectedCodeUsesCppSelf(const AbstractMetaFunction* func
bool ShibokenGenerator::injectedCodeUsesPySelf(const AbstractMetaFunction* func)
{
CodeSnipList snips = func->injectedCodeSnips(TypeSystem::CodeSnipPositionAny, TypeSystem::NativeCode);
- foreach (const CodeSnip &snip, snips) {
+ for (const CodeSnip &snip : qAsConst(snips)) {
if (snip.code().contains(QLatin1String("%PYSELF")))
return true;
}
@@ -2010,7 +2075,7 @@ bool ShibokenGenerator::injectedCodeCallsCppFunction(const AbstractMetaFunction*
wrappedCtorCall = QStringLiteral("new %1(").arg(wrapperName(func->ownerClass()));
}
CodeSnipList snips = func->injectedCodeSnips(TypeSystem::CodeSnipPositionAny, TypeSystem::TargetLangCode);
- foreach (const CodeSnip &snip, snips) {
+ for (const CodeSnip &snip : qAsConst(snips)) {
if (snip.code().contains(QLatin1String("%FUNCTION_NAME(")) || snip.code().contains(funcCall)
|| (func->isConstructor()
&& ((func->ownerClass()->isPolymorphic() && snip.code().contains(wrappedCtorCall))
@@ -2023,10 +2088,11 @@ bool ShibokenGenerator::injectedCodeCallsCppFunction(const AbstractMetaFunction*
bool ShibokenGenerator::injectedCodeCallsPythonOverride(const AbstractMetaFunction* func)
{
- static QRegExp overrideCallRegexCheck(QLatin1String("PyObject_Call\\s*\\(\\s*%PYTHON_METHOD_OVERRIDE\\s*,"));
+ static const QRegularExpression overrideCallRegexCheck(QStringLiteral("PyObject_Call\\s*\\(\\s*%PYTHON_METHOD_OVERRIDE\\s*,"));
+ Q_ASSERT(overrideCallRegexCheck.isValid());
CodeSnipList snips = func->injectedCodeSnips(TypeSystem::CodeSnipPositionAny, TypeSystem::NativeCode);
- foreach (const CodeSnip &snip, snips) {
- if (overrideCallRegexCheck.indexIn(snip.code()) != -1)
+ for (const CodeSnip &snip : qAsConst(snips)) {
+ if (snip.code().contains(overrideCallRegexCheck))
return true;
}
return false;
@@ -2034,15 +2100,17 @@ bool ShibokenGenerator::injectedCodeCallsPythonOverride(const AbstractMetaFuncti
bool ShibokenGenerator::injectedCodeHasReturnValueAttribution(const AbstractMetaFunction* func, TypeSystem::Language language)
{
- static QRegExp retValAttributionRegexCheck_native(QLatin1String("%0\\s*=[^=]\\s*.+"));
- static QRegExp retValAttributionRegexCheck_target(QLatin1String("%PYARG_0\\s*=[^=]\\s*.+"));
+ static const QRegularExpression retValAttributionRegexCheck_native(QStringLiteral("%0\\s*=[^=]\\s*.+"));
+ Q_ASSERT(retValAttributionRegexCheck_native.isValid());
+ static const QRegularExpression retValAttributionRegexCheck_target(QStringLiteral("%PYARG_0\\s*=[^=]\\s*.+"));
+ Q_ASSERT(retValAttributionRegexCheck_target.isValid());
CodeSnipList snips = func->injectedCodeSnips(TypeSystem::CodeSnipPositionAny, language);
- foreach (const CodeSnip &snip, snips) {
+ for (const CodeSnip &snip : qAsConst(snips)) {
if (language == TypeSystem::TargetLangCode) {
- if (retValAttributionRegexCheck_target.indexIn(snip.code()) != -1)
+ if (snip.code().contains(retValAttributionRegexCheck_target))
return true;
} else {
- if (retValAttributionRegexCheck_native.indexIn(snip.code()) != -1)
+ if (snip.code().contains(retValAttributionRegexCheck_native))
return true;
}
}
@@ -2052,11 +2120,10 @@ bool ShibokenGenerator::injectedCodeHasReturnValueAttribution(const AbstractMeta
bool ShibokenGenerator::injectedCodeUsesArgument(const AbstractMetaFunction* func, int argumentIndex)
{
CodeSnipList snips = func->injectedCodeSnips(TypeSystem::CodeSnipPositionAny);
- foreach (const CodeSnip &snip, snips) {
+ const QRegularExpression argRegEx = placeHolderRegex(argumentIndex + 1);
+ for (const CodeSnip &snip : qAsConst(snips)) {
QString code = snip.code();
- if (code.contains(QLatin1String("%ARGUMENT_NAMES")))
- return true;
- if (code.contains(QRegExp(QStringLiteral("%%1\\b").arg(argumentIndex + 1))))
+ if (code.contains(QLatin1String("%ARGUMENT_NAMES")) || code.contains(argRegEx))
return true;
}
return false;
@@ -2083,7 +2150,7 @@ bool ShibokenGenerator::classNeedsGetattroFunction(const AbstractMetaClass* meta
const FunctionGroupMap &functionGroup = getFunctionGroups(metaClass);
for (FunctionGroupMapIt it = functionGroup.cbegin(), end = functionGroup.cend(); it != end; ++it) {
AbstractMetaFunctionList overloads;
- foreach (AbstractMetaFunction* func, it.value()) {
+ for (AbstractMetaFunction *func : qAsConst(it.value())) {
if (func->isAssignmentOperator() || func->isCastOperator() || func->isModifiedRemoved()
|| func->isPrivate() || func->ownerClass() != func->implementingClass()
|| func->isConstructor() || func->isOperatorOverload())
@@ -2114,7 +2181,7 @@ AbstractMetaFunctionList ShibokenGenerator::getMethodsWithBothStaticAndNonStatic
const FunctionGroupMap &functionGroups = getFunctionGroups(metaClass);
for (FunctionGroupMapIt it = functionGroups.cbegin(), end = functionGroups.cend(); it != end; ++it) {
AbstractMetaFunctionList overloads;
- foreach (AbstractMetaFunction* func, it.value()) {
+ for (AbstractMetaFunction *func : qAsConst(it.value())) {
if (func->isAssignmentOperator() || func->isCastOperator() || func->isModifiedRemoved()
|| func->isPrivate() || func->ownerClass() != func->implementingClass()
|| func->isConstructor() || func->isOperatorOverload())
@@ -2134,7 +2201,8 @@ AbstractMetaClassList ShibokenGenerator::getBaseClasses(const AbstractMetaClass*
{
AbstractMetaClassList baseClasses;
if (metaClass) {
- foreach (const QString &parent, metaClass->baseClassNames()) {
+ const QStringList &baseClassNames = metaClass->baseClassNames();
+ for (const QString &parent : baseClassNames) {
AbstractMetaClass *clazz = AbstractMetaClass::findClass(classes(), parent);
if (clazz)
baseClasses << clazz;
@@ -2157,7 +2225,7 @@ AbstractMetaClassList ShibokenGenerator::getAllAncestors(const AbstractMetaClass
AbstractMetaClassList result;
if (metaClass) {
AbstractMetaClassList baseClasses = getBaseClasses(metaClass);
- foreach (AbstractMetaClass* base, baseClasses) {
+ for (AbstractMetaClass *base : qAsConst(baseClasses)) {
result.append(base);
result.append(getAllAncestors(base));
}
@@ -2268,7 +2336,7 @@ AbstractMetaType* ShibokenGenerator::buildAbstractMetaTypeFromString(QString typ
metaType->setReferenceType(refType);
metaType->setConstant(isConst);
metaType->setTypeUsagePattern(AbstractMetaType::ContainerPattern);
- foreach (const QString& instantiation, instantiatedTypes) {
+ for (const QString &instantiation : qAsConst(instantiatedTypes)) {
AbstractMetaType* tmplArgType = buildAbstractMetaTypeFromString(instantiation);
metaType->addInstantiation(tmplArgType);
}
@@ -2303,7 +2371,7 @@ AbstractMetaType* ShibokenGenerator::buildAbstractMetaTypeFromAbstractMetaClass(
static void dumpFunction(AbstractMetaFunctionList lst)
{
qDebug() << "DUMP FUNCTIONS: ";
- foreach (AbstractMetaFunction *func, lst)
+ for (AbstractMetaFunction *func : qAsConst(lst))
qDebug() << "*" << func->ownerClass()->name()
<< func->signature()
<< "Private: " << func->isPrivate()
@@ -2331,7 +2399,7 @@ QMap< QString, AbstractMetaFunctionList > ShibokenGenerator::getFunctionGroups(c
AbstractMetaFunctionList lst = scope ? scope->functions() : globalFunctions();
QMap<QString, AbstractMetaFunctionList> results;
- foreach (AbstractMetaFunction* func, lst) {
+ for (AbstractMetaFunction *func : qAsConst(lst)) {
if (isGroupable(func))
results[func->name()].append(func);
}
@@ -2370,7 +2438,7 @@ AbstractMetaFunctionList ShibokenGenerator::getFunctionOverloads(const AbstractM
AbstractMetaFunctionList results;
QSet<QString> seenSignatures;
- foreach (AbstractMetaFunction* func, lst) {
+ for (AbstractMetaFunction *func : qAsConst(lst)) {
if (func->name() != functionName)
continue;
if (isGroupable(func)) {
@@ -2387,9 +2455,10 @@ QPair< int, int > ShibokenGenerator::getMinMaxArguments(const AbstractMetaFuncti
int minArgs = std::numeric_limits<int>::max();
int maxArgs = 0;
- foreach (const AbstractMetaFunction* func, overloads) {
+ for (const AbstractMetaFunction* func : qAsConst(overloads)) {
int numArgs = 0;
- foreach (const AbstractMetaArgument* arg, func->arguments()) {
+ const AbstractMetaArgumentList &arguments = func->arguments();
+ for (const AbstractMetaArgument *arg : arguments) {
if (!func->argumentRemoved(arg->argumentIndex() + 1))
numArgs++;
}
@@ -2399,27 +2468,26 @@ QPair< int, int > ShibokenGenerator::getMinMaxArguments(const AbstractMetaFuncti
return qMakePair(minArgs, maxArgs);
}
-QMap<QString, QString> ShibokenGenerator::options() const
+Generator::OptionDescriptions ShibokenGenerator::options() const
{
- QMap<QString, QString> opts(Generator::options());
- 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;
+ return OptionDescriptions()
+ << qMakePair(QLatin1String(AVOID_PROTECTED_HACK),
+ QLatin1String("Avoid the use of the '#define protected public' hack."))
+ << qMakePair(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."))
+ << qMakePair(QLatin1String(PARENT_CTOR_HEURISTIC),
+ QLatin1String("Enable heuristics to detect parent relationship on constructors."))
+ << qMakePair(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."))
+ << qMakePair(QLatin1String(RETURN_VALUE_HEURISTIC),
+ QLatin1String("Enable heuristics to detect parent relationship on return values (USE WITH CAUTION!)"))
+ << qMakePair(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"));
}
static void getCode(QStringList& code, const CodeSnipList& codeSnips)
{
- foreach (const CodeSnip& snip, codeSnips)
+ for (const CodeSnip &snip : qAsConst(codeSnips))
code.append(snip.code());
}
@@ -2438,7 +2506,7 @@ static void getCode(QStringList& code, const TypeEntry* type)
if (toCppConversions.isEmpty())
return;
- foreach (CustomConversion::TargetToNativeConversion* toNative, toCppConversions)
+ for (CustomConversion::TargetToNativeConversion *toNative : qAsConst(toCppConversions))
code.append(toNative->conversion());
}
@@ -2453,20 +2521,23 @@ bool ShibokenGenerator::doSetup(const QMap<QString, QString>& args)
TypeDatabase* td = TypeDatabase::instance();
QStringList snips;
- foreach (const PrimitiveTypeEntry* type, primitiveTypes())
+ const PrimitiveTypeEntryList &primitiveTypeList = primitiveTypes();
+ for (const PrimitiveTypeEntry *type : primitiveTypeList)
getCode(snips, type);
- foreach (const ContainerTypeEntry* type, containerTypes())
+ const ContainerTypeEntryList &containerTypeList = containerTypes();
+ for (const ContainerTypeEntry *type : containerTypeList)
getCode(snips, type);
- foreach (const AbstractMetaClass* metaClass, classes())
+ const AbstractMetaClassList &classList = classes();
+ for (const AbstractMetaClass *metaClass : classList)
getCode(snips, metaClass->typeEntry());
getCode(snips, td->findType(packageName()));
const FunctionGroupMap &functionGroups = getFunctionGroups();
for (FunctionGroupMapIt it = functionGroups.cbegin(), end = functionGroups.cend(); it != end; ++it) {
- foreach (AbstractMetaFunction* func, it.value())
+ for (AbstractMetaFunction *func : it.value())
getCode(snips, func->injectedCodeSnips());
}
- foreach (const QString& code, snips) {
+ for (const QString &code : qAsConst(snips)) {
collectContainerTypesFromConverterMacros(code, true);
collectContainerTypesFromConverterMacros(code, false);
}
@@ -2536,7 +2607,8 @@ QString ShibokenGenerator::convertersVariableName(const QString& moduleName) con
static QString processInstantiationsVariableName(const AbstractMetaType* type)
{
QString res = QLatin1Char('_') + _fixedCppTypeName(type->typeEntry()->qualifiedCppName()).toUpper();
- foreach (const AbstractMetaType* instantiation, type->instantiations()) {
+ const AbstractMetaTypeList &instantiations = type->instantiations();
+ for (const AbstractMetaType *instantiation : instantiations) {
res += instantiation->isContainer()
? processInstantiationsVariableName(instantiation)
: QLatin1Char('_') + _fixedCppTypeName(instantiation->cppSignature()).toUpper();
@@ -2551,7 +2623,8 @@ QString ShibokenGenerator::getTypeIndexVariableName(const AbstractMetaClass* met
return QString();
QString base = _fixedCppTypeName(templateBaseClass->typeEntry()->qualifiedCppName()).toUpper();
QString instantiations;
- foreach (const AbstractMetaType* instantiation, metaClass->templateBaseClassInstantiations())
+ const AbstractMetaTypeList &templateBaseClassInstantiations = metaClass->templateBaseClassInstantiations();
+ for (const AbstractMetaType *instantiation : templateBaseClassInstantiations)
instantiations += processInstantiationsVariableName(instantiation);
return QString::fromLatin1("SBK_%1%2_IDX").arg(base, instantiations);
}
@@ -2615,8 +2688,9 @@ QString ShibokenGenerator::getDefaultValue(const AbstractMetaFunction* func, co
return arg->defaultValueExpression();
//Check modifications
- foreach(FunctionModification m, func->modifications()) {
- foreach(ArgumentModification am, m.argument_mods) {
+ const FunctionModificationList &mods = func->modifications();
+ for (const FunctionModification &m : mods) {
+ for (const ArgumentModification &am : m.argument_mods) {
if (am.index == (arg->argumentIndex() + 1))
return am.replacedDefaultExpression;
}
diff --git a/sources/shiboken2/generator/shiboken2/shibokengenerator.h b/sources/shiboken2/generator/shiboken2/shibokengenerator.h
index d36962cf1..a8a270612 100644
--- a/sources/shiboken2/generator/shiboken2/shibokengenerator.h
+++ b/sources/shiboken2/generator/shiboken2/shibokengenerator.h
@@ -56,6 +56,8 @@
#include "typesystem.h"
+#include <QtCore/QRegularExpression>
+
class DocParser;
class CodeSnip;
class OverloadData;
@@ -132,7 +134,7 @@ public:
void writeArgumentNames(QTextStream &s,
const AbstractMetaFunction* func,
- Options options = NoOption) const;
+ Options options = NoOption) const override;
/**
* Function used to write the fucntion arguments on the class buffer.
@@ -143,32 +145,32 @@ public:
*/
void writeFunctionArguments(QTextStream &s,
const AbstractMetaFunction* func,
- Options options = NoOption) const;
+ Options options = NoOption) const override;
QString functionReturnType(const AbstractMetaFunction* func, Options options = NoOption) const;
/// Utility function for writeCodeSnips.
typedef QPair<const AbstractMetaArgument*, QString> ArgumentVarReplacementPair;
- typedef QList<ArgumentVarReplacementPair> ArgumentVarReplacementList;
+ typedef QVector<ArgumentVarReplacementPair> ArgumentVarReplacementList;
ArgumentVarReplacementList getArgumentReplacement(const AbstractMetaFunction* func,
bool usePyArgs, TypeSystem::Language language,
const AbstractMetaArgument* lastArg);
/// Write user's custom code snippets at class or module level.
void writeCodeSnips(QTextStream& s,
- const QList<CodeSnip>& codeSnips,
+ const QVector<CodeSnip> & codeSnips,
TypeSystem::CodeSnipPosition position,
TypeSystem::Language language,
const AbstractMetaClass* context = 0);
/// Write user's custom code snippets at function level.
void writeCodeSnips(QTextStream& s,
- const QList<CodeSnip>& codeSnips,
+ const QVector<CodeSnip> & codeSnips,
TypeSystem::CodeSnipPosition position,
TypeSystem::Language language,
const AbstractMetaFunction* func,
const AbstractMetaArgument* lastArg = 0);
/// Returns a string with the user's custom code snippets that comply with \p position and \p language.
- QString getCodeSnippets(const QList<CodeSnip>& codeSnips, TypeSystem::CodeSnipPosition position, TypeSystem::Language language);
+ QString getCodeSnippets(const QVector<CodeSnip> & codeSnips, TypeSystem::CodeSnipPosition position, TypeSystem::Language language);
/// Replaces variables for the user's custom code at global or class level.
void processCodeSnip(QString& code, const AbstractMetaClass* context = 0);
@@ -428,7 +430,7 @@ public:
QString extendedIsConvertibleFunctionName(const TypeEntry* targetType) const;
QString extendedToCppFunctionName(const TypeEntry* targetType) const;
- QMap< QString, QString > options() const;
+ OptionDescriptions options() const override;
/// Returns true if the user enabled the so called "parent constructor heuristic".
bool useCtorHeuristic() const;
@@ -513,12 +515,12 @@ protected:
// All data about extended converters: the type entries of the target type, and a
// list of AbstractMetaClasses accepted as argument for the conversion.
- typedef QHash<const TypeEntry*, QList<const AbstractMetaClass*> > ExtendedConverterData;
+ typedef QHash<const TypeEntry *, QVector<const AbstractMetaClass *> > ExtendedConverterData;
/// Returns all extended conversions for the current module.
ExtendedConverterData getExtendedConverters() const;
/// Returns a list of converters for the non wrapper types of the current module.
- QList<const CustomConversion*> getPrimitiveCustomConversions();
+ QVector<const CustomConversion *> getPrimitiveCustomConversions();
/// Returns true if the Python wrapper for the received OverloadData must accept a list of arguments.
static bool pythonFunctionWrapperUsesListOfArguments(const OverloadData& overloadData);
@@ -549,7 +551,7 @@ private:
/// Type system converter variable replacement names and regular expressions.
QString m_typeSystemConvName[TypeSystemConverterVariables];
- QRegExp m_typeSystemConvRegEx[TypeSystemConverterVariables];
+ QRegularExpression m_typeSystemConvRegEx[TypeSystemConverterVariables];
};
#endif // SHIBOKENGENERATOR_H
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-01 10:52:54 +0000