aboutsummaryrefslogtreecommitdiffstats
path: root/sources/shiboken6/ApiExtractor/abstractmetabuilder_p.h
diff options
context:
space:
mode:
Diffstat (limited to 'sources/shiboken6/ApiExtractor/abstractmetabuilder_p.h')
-rw-r--r--sources/shiboken6/ApiExtractor/abstractmetabuilder_p.h238
1 files changed, 134 insertions, 104 deletions
diff --git a/sources/shiboken6/ApiExtractor/abstractmetabuilder_p.h b/sources/shiboken6/ApiExtractor/abstractmetabuilder_p.h
index 6256d078c..d7aaba5b0 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetabuilder_p.h
+++ b/sources/shiboken6/ApiExtractor/abstractmetabuilder_p.h
@@ -1,30 +1,5 @@
-/****************************************************************************
-**
-** Copyright (C) 2017 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of Qt for Python.
-**
-** $QT_BEGIN_LICENSE:GPL-EXCEPT$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3 as published by the Free Software
-** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
+// Copyright (C) 2017 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
#ifndef ABSTRACTMETABUILDER_P_H
#define ABSTRACTMETABUILDER_P_H
@@ -35,24 +10,38 @@
#include "abstractmetalang.h"
#include "abstractmetatype.h"
#include "include.h"
-#include "modifications.h"
#include "typeparser.h"
+#include "modifications_typedefs.h"
+#include "typesystem_typedefs.h"
-#include <QSet>
-#include <QFileInfo>
-#include <QList>
+#include <QtCore/QFileInfo>
+#include <QtCore/QList>
+#include <QtCore/QMap>
+#include <QtCore/QMultiHash>
+#include <QtCore/QSet>
#include <optional>
+#include <set>
class TypeDatabase;
+struct RejectEntry
+{
+ AbstractMetaBuilder::RejectReason reason;
+ QString signature;
+ QString sortkey;
+ QString message;
+};
+
+bool operator<(const RejectEntry &re1, const RejectEntry &re2);
+
class AbstractMetaBuilderPrivate
{
public:
struct TypeClassEntry
{
AbstractMetaType type;
- const AbstractMetaClass *klass;
+ AbstractMetaClassCPtr klass;
};
using TranslateTypeFlags = AbstractMetaBuilder::TranslateTypeFlags;
@@ -60,74 +49,88 @@ public:
Q_DISABLE_COPY(AbstractMetaBuilderPrivate)
AbstractMetaBuilderPrivate();
- ~AbstractMetaBuilderPrivate();
static FileModelItem buildDom(QByteArrayList arguments,
bool addCompilerSupportArguments,
LanguageLevel level,
unsigned clangFlags);
- void traverseDom(const FileModelItem &dom);
+ void traverseDom(const FileModelItem &dom, ApiExtractorFlags flags);
void dumpLog() const;
- static AbstractMetaClassList classesTopologicalSorted(const AbstractMetaClassList &classList,
- const Dependencies &additionalDependencies = {});
+
+ static AbstractMetaClassList
+ classesTopologicalSorted(const AbstractMetaClassList &classList,
+ const Dependencies &additionalDependencies = {});
+ static AbstractMetaClassCList
+ classesTopologicalSorted(const AbstractMetaClassCList &classList,
+ const Dependencies &additionalDependencies = {});
+
NamespaceModelItem popScope() { return m_scopes.takeLast(); }
void pushScope(const NamespaceModelItem &item);
NamespaceModelItem currentScope() const { return m_scopes.constLast(); }
- AbstractMetaClass *argumentToClass(const ArgumentModelItem &,
- const AbstractMetaClass *currentClass);
+ AbstractMetaClassPtr argumentToClass(const ArgumentModelItem &,
+ const AbstractMetaClassCPtr &currentClass);
- void addAbstractMetaClass(AbstractMetaClass *cls, const _CodeModelItem *item);
- AbstractMetaClass *traverseTypeDef(const FileModelItem &dom,
+ void addAbstractMetaClass(const AbstractMetaClassPtr &cls, const _CodeModelItem *item);
+ AbstractMetaClassPtr traverseTypeDef(const FileModelItem &dom,
const TypeDefModelItem &typeDef,
- AbstractMetaClass *currentClass);
+ const AbstractMetaClassPtr &currentClass);
+ AbstractMetaClassPtr traverseTypeDefHelper(const FileModelItem &dom,
+ const TypeDefModelItem &typeDef,
+ const AbstractMetaClassPtr &currentClass);
void traverseTypesystemTypedefs();
- AbstractMetaClass *traverseClass(const FileModelItem &dom,
+ AbstractMetaClassPtr traverseClass(const FileModelItem &dom,
const ClassModelItem &item,
- AbstractMetaClass *currentClass);
- void traverseScopeMembers(const ScopeModelItem &item, AbstractMetaClass *metaClass);
+ const AbstractMetaClassPtr &currentClass);
+ void traverseScopeMembers(const ScopeModelItem &item,
+ const AbstractMetaClassPtr &metaClass);
void traverseClassMembers(const ClassModelItem &scopeItem);
- void traverseUsingMembers(AbstractMetaClass *metaClass);
+ void traverseUsingMembers(const AbstractMetaClassPtr &metaClass) const;
void traverseNamespaceMembers(const NamespaceModelItem &scopeItem);
- bool setupInheritance(AbstractMetaClass *metaClass);
- AbstractMetaClass *traverseNamespace(const FileModelItem &dom,
+ bool setupInheritance(const AbstractMetaClassPtr &metaClass);
+ AbstractMetaClassPtr traverseNamespace(const FileModelItem &dom,
const NamespaceModelItem &item);
std::optional<AbstractMetaEnum> traverseEnum(const EnumModelItem &item,
- AbstractMetaClass *enclosing,
+ const AbstractMetaClassPtr &enclosing,
const QSet<QString> &enumsDeclarations);
- void traverseEnums(const ScopeModelItem &item, AbstractMetaClass *parent,
+ void traverseEnums(const ScopeModelItem &item, const AbstractMetaClassPtr &parent,
const QStringList &enumsDeclarations);
AbstractMetaFunctionRawPtrList classFunctionList(const ScopeModelItem &scopeItem,
AbstractMetaClass::Attributes *constructorAttributes,
- AbstractMetaClass *currentClass);
- void traverseFunctions(ScopeModelItem item, AbstractMetaClass *parent);
+ const AbstractMetaClassPtr &currentClass);
+ void traverseFunctions(const ScopeModelItem& item,
+ const AbstractMetaClassPtr &parent);
static void applyFunctionModifications(AbstractMetaFunction *func);
- void traverseFields(const ScopeModelItem &item, AbstractMetaClass *parent);
+ void traverseFields(const ScopeModelItem &item, const AbstractMetaClassPtr &parent);
bool traverseStreamOperator(const FunctionModelItem &functionItem,
- AbstractMetaClass *currentClass);
+ const AbstractMetaClassPtr &currentClass);
void traverseOperatorFunction(const FunctionModelItem &item,
- AbstractMetaClass *currentClass);
+ const AbstractMetaClassPtr &currentClass);
AbstractMetaFunction *traverseAddedFunctionHelper(const AddedFunctionPtr &addedFunc,
- AbstractMetaClass *metaClass,
+ const AbstractMetaClassPtr &metaClass,
QString *errorMessage);
bool traverseAddedGlobalFunction(const AddedFunctionPtr &addedFunc,
QString *errorMessage);
bool traverseAddedMemberFunction(const AddedFunctionPtr &addedFunc,
- AbstractMetaClass *metaClass,
+ const AbstractMetaClassPtr &metaClass,
QString *errorMessage);
- AbstractMetaFunction *traverseFunction(const FunctionModelItem &function,
- AbstractMetaClass *currentClass);
+ void rejectFunction(const FunctionModelItem &functionItem,
+ const AbstractMetaClassPtr &currentClass,
+ AbstractMetaBuilder::RejectReason reason,
+ const QString &rejectReason);
+ AbstractMetaFunction *traverseFunction(const FunctionModelItem &function,
+ const AbstractMetaClassPtr &currentClass);
std::optional<AbstractMetaField> traverseField(const VariableModelItem &field,
- const AbstractMetaClass *cls);
- void checkFunctionModifications();
+ const AbstractMetaClassCPtr &cls);
+ void checkFunctionModifications() const;
void registerHashFunction(const FunctionModelItem &functionItem,
- AbstractMetaClass *currentClass);
+ const AbstractMetaClassPtr &currentClass);
void registerToStringCapabilityIn(const NamespaceModelItem &namespaceItem);
void registerToStringCapability(const FunctionModelItem &functionItem,
- AbstractMetaClass *currentClass);
+ const AbstractMetaClassPtr &currentClass);
/**
* A conversion operator function should not have its owner class as
@@ -141,45 +144,67 @@ public:
*/
static void fixReturnTypeOfConversionOperator(AbstractMetaFunction *metaFunction);
- void parseQ_Properties(AbstractMetaClass *metaClass, const QStringList &declarations);
- void setupEquals(AbstractMetaClass *metaClass);
- void setupComparable(AbstractMetaClass *metaClass);
- static void setupClonable(AbstractMetaClass *cls);
- void setupExternalConversion(AbstractMetaClass *cls);
- static void setupFunctionDefaults(AbstractMetaFunction *metaFunction,
- AbstractMetaClass *metaClass);
-
- static QString fixDefaultValue(const ArgumentModelItem &item,
- const AbstractMetaType &type,
- const AbstractMetaClass *,
- int argumentIndex);
+ void parseQ_Properties(const AbstractMetaClassPtr &metaClass,
+ const QStringList &declarations);
+ void setupEquals(const AbstractMetaClassPtr &metaClass);
+ void setupComparable(const AbstractMetaClassPtr &metaClass);
+ void setupExternalConversion(const AbstractMetaClassCPtr &cls);
+
+ static bool isQualifiedCppIdentifier(QStringView e);
+ QString fixDefaultValue(QString expr, const AbstractMetaType &type,
+ const AbstractMetaClassCPtr &) const;
+ QString fixSimpleDefaultValue(QStringView expr,
+ const AbstractMetaClassCPtr &klass) const;
+
+ QString fixEnumDefault(const AbstractMetaType &type, const QString &expr,
+ const AbstractMetaClassCPtr &) const;
+ /// Qualify a static field name for default value expressions
+ static QString qualifyStaticField(const AbstractMetaClassCPtr &c, QStringView field);
+
std::optional<AbstractMetaType>
- translateType(const TypeInfo &type, const AbstractMetaClass *currentClass,
+ translateType(const TypeInfo &type, const AbstractMetaClassCPtr &currentClass,
TranslateTypeFlags flags = {}, QString *errorMessage = nullptr);
static std::optional<AbstractMetaType>
- translateTypeStatic(const TypeInfo &type, const AbstractMetaClass *current,
+ translateTypeStatic(const TypeInfo &type, const AbstractMetaClassCPtr &current,
AbstractMetaBuilderPrivate *d = nullptr, TranslateTypeFlags flags = {},
QString *errorMessageIn = nullptr);
- static TypeEntries findTypeEntriesHelper(const QString &qualifiedName, const QString &name,
- const AbstractMetaClass *currentClass = nullptr,
- AbstractMetaBuilderPrivate *d = nullptr);
- static TypeEntries findTypeEntries(const QString &qualifiedName, const QString &name,
- const AbstractMetaClass *currentClass = nullptr,
- AbstractMetaBuilderPrivate *d = nullptr,
- QString *errorMessage = nullptr);
+ static TypeEntryCList findTypeEntriesHelper(const QString &qualifiedName, const QString &name,
+ TranslateTypeFlags flags = {},
+ const AbstractMetaClassCPtr &currentClass = {},
+ AbstractMetaBuilderPrivate *d = nullptr);
+ static TypeEntryCList findTypeEntries(const QString &qualifiedName, const QString &name,
+ TranslateTypeFlags flags = {},
+ const AbstractMetaClassCPtr &currentClass = {},
+ AbstractMetaBuilderPrivate *d = nullptr,
+ QString *errorMessage = nullptr);
qint64 findOutValueFromString(const QString &stringValue, bool &ok);
- AbstractMetaClass *findTemplateClass(const QString& name, const AbstractMetaClass *context,
- TypeInfo *info = Q_NULLPTR,
- ComplexTypeEntry **baseContainerType = Q_NULLPTR) const;
- AbstractMetaClassList getBaseClasses(const AbstractMetaClass *metaClass) const;
+ AbstractMetaClassPtr findTemplateClass(const QString& name, const AbstractMetaClassCPtr &context,
+ TypeInfo *info = nullptr,
+ ComplexTypeEntryPtr *baseContainerType = nullptr) const;
+ AbstractMetaClassCList getBaseClasses(const AbstractMetaClassCPtr &metaClass) const;
- static bool inheritTemplate(AbstractMetaClass *subclass,
- const AbstractMetaClass *templateClass,
+ static bool inheritTemplate(const AbstractMetaClassPtr &subclass,
+ const AbstractMetaClassCPtr &templateClass,
const TypeInfo &info);
- void inheritTemplateFunctions(AbstractMetaClass *subclass);
- std::optional<AbstractMetaType>
+ static bool inheritTemplate(const AbstractMetaClassPtr &subclass,
+ const AbstractMetaClassCPtr &templateClass,
+ const AbstractMetaTypeList &templateTypes,
+ InheritTemplateFlags flags = {});
+
+ static AbstractMetaFunctionPtr
+ inheritTemplateFunction(const AbstractMetaFunctionCPtr &function,
+ const AbstractMetaTypeList &templateTypes);
+
+ static AbstractMetaFunctionPtr
+ inheritTemplateMember(const AbstractMetaFunctionCPtr &function,
+ const AbstractMetaTypeList &templateTypes,
+ const AbstractMetaClassCPtr &templateClass,
+ const AbstractMetaClassPtr &subclass);
+
+ static void inheritTemplateFunctions(const AbstractMetaClassPtr &subclass);
+ static std::optional<AbstractMetaType>
inheritTemplateType(const AbstractMetaTypeList &templateTypes,
const AbstractMetaType &metaType);
@@ -187,30 +212,31 @@ public:
static bool isEnum(const FileModelItem &dom, const QStringList &qualifiedName);
void sortLists();
- static AbstractMetaArgumentList reverseList(const AbstractMetaArgumentList &list);
- void setInclude(TypeEntry *te, const QString &path) const;
+ void setInclude(const TypeEntryPtr &te, const QString &path) const;
static void fixArgumentNames(AbstractMetaFunction *func, const FunctionModificationList &mods);
- void fillAddedFunctions(AbstractMetaClass *metaClass);
- const AbstractMetaClass *resolveTypeSystemTypeDef(const AbstractMetaType &t) const;
+ void fillAddedFunctions(const AbstractMetaClassPtr &metaClass);
+ AbstractMetaClassCPtr resolveTypeSystemTypeDef(const AbstractMetaType &t) const;
+
+ void fixSmartPointers();
- AbstractMetaBuilder *q;
+ AbstractMetaBuilder *q = nullptr;
AbstractMetaClassList m_metaClasses;
AbstractMetaClassList m_templates;
AbstractMetaClassList m_smartPointers;
- QHash<const _CodeModelItem *, AbstractMetaClass *> m_itemToClass;
- QHash<const AbstractMetaClass *, const _CodeModelItem *> m_classToItem;
+ QHash<const _CodeModelItem *, AbstractMetaClassPtr > m_itemToClass;
+ QHash<AbstractMetaClassCPtr, const _CodeModelItem *> m_classToItem;
AbstractMetaFunctionCList m_globalFunctions;
AbstractMetaEnumList m_globalEnums;
- using RejectMap = QMap<QString, AbstractMetaBuilder::RejectReason>;
+ using RejectSet = std::set<RejectEntry>;
- RejectMap m_rejectedClasses;
- RejectMap m_rejectedEnums;
- RejectMap m_rejectedFunctions;
- RejectMap m_rejectedFields;
+ RejectSet m_rejectedClasses;
+ RejectSet m_rejectedEnums;
+ RejectSet m_rejectedFunctions;
+ RejectSet m_rejectedFields;
- QHash<const TypeEntry *, AbstractMetaEnum> m_enums;
+ QHash<TypeEntryCPtr, AbstractMetaEnum> m_enums;
QList<NamespaceModelItem> m_scopes;
@@ -218,8 +244,12 @@ public:
QFileInfoList m_globalHeaders;
QStringList m_headerPaths;
mutable QHash<QString, Include> m_resolveIncludeHash;
+ QMultiHash<QString, QString> m_typedefTargetToName;
QList<TypeClassEntry> m_typeSystemTypeDefs; // look up metatype->class for type system typedefs
+ ApiExtractorFlags m_apiExtractorFlags;
bool m_skipDeprecated = false;
+ static bool m_useGlobalHeader;
+ static bool m_codeModelTestMode;
};
#endif // ABSTRACTMETBUILDER_P_H
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-26 15:09:26 +0000