moc.h - mozsearch

Enable keyboard shortcuts

Revision control

Copy as Markdown

// Copyright (C) 2016 The Qt Company Ltd.

// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0

#ifndef MOC_H

#define MOC_H

// -- QtScxml

#include <QtCore/qjsonarray.h>

#include <QtCore/qjsondocument.h>

#include <QtCore/qmap.h>

#include <QtCore/qpair.h>

#include <QtCore/qtmocconstants.h>

// -- QtScxml

#include <private/qtools_p.h>

QT_BEGIN_NAMESPACE

struct QMetaObject;

enum class TypeTag : uchar {

    None,

    HasStruct = 0x01,

    HasClass = 0x02,

    HasEnum = 0x04,

};

Q_DECLARE_FLAGS(TypeTags, TypeTag)

Q_DECLARE_OPERATORS_FOR_FLAGS(TypeTags)

struct Type

    enum ReferenceType { NoReference, Reference, RValueReference, Pointer };

    inline Type() : isVolatile(false), isScoped(false), /* firstToken(NOTOKEN) -- QtScxml ,*/ referenceType(NoReference) {}

    inline explicit Type(const QByteArray &_name)

        : name(_name), rawName(name), isVolatile(false), isScoped(false), /* firstToken(NOTOKEN) -- QtScxml ,*/ referenceType(NoReference) {}

    QByteArray name;

    //When used as a return type, the type name may be modified to remove the references.

    // rawName is the type as found in the function signature

    QByteArray rawName;

    uint isVolatile : 1;

    uint isScoped : 1;

    TypeTags typeTag;

#if 0 // -- QtScxml

    Token firstToken;

#endif // -- QtScxml

    ReferenceType referenceType;

};

Q_DECLARE_TYPEINFO(Type, Q_RELOCATABLE_TYPE);

struct ClassDef;

struct EnumDef

    QByteArray name;

    QByteArray enumName;

    QByteArray type;

    QList<QByteArray> values;

    QFlags<QtMocConstants::EnumFlags> flags = {};

    QJsonObject toJson(const ClassDef &cdef) const;

    QByteArray qualifiedType(const ClassDef *cdef) const;

    int lineNumber = 0;

};

Q_DECLARE_TYPEINFO(EnumDef, Q_RELOCATABLE_TYPE);

struct ArgumentDef

    ArgumentDef() : isDefault(false) {}

    Type type;

    QByteArray rightType, normalizedType, name;

    bool isDefault;

    QJsonObject toJson() const;

};

Q_DECLARE_TYPEINFO(ArgumentDef, Q_RELOCATABLE_TYPE);

struct FunctionDef

    Type type;

    QList<ArgumentDef> arguments;

    QByteArray normalizedType;

    QByteArray tag;

    QByteArray name;

    QByteArray inPrivateClass;

    enum Access { Private, Protected, Public };

    Access access = Private;

    int revision = 0;

    int lineNumber = 0;

    bool isConst = false;

    bool isVirtual = false;

    bool isStatic = false;

    bool inlineCode = false;

    bool wasCloned = false;

#if 0 // -- QtScxml

    bool returnTypeIsVolatile = false;

#endif // -- QtScxml

    bool isCompat = false;

    bool isInvokable = false;

    bool isScriptable = false;

    bool isSlot = false;

    bool isSignal = false;

    bool isPrivateSignal = false;

    bool isConstructor = false;

    bool isDestructor = false;

    bool isAbstract = false;

    bool isRawSlot = false;

    QJsonObject toJson(int index) const;

    static void accessToJson(QJsonObject *obj, Access acs);

// -- QtScxml

    QByteArray mangledName;

    const char *implementation = nullptr;

// -- QtScxml

};

Q_DECLARE_TYPEINFO(FunctionDef, Q_RELOCATABLE_TYPE);

struct PropertyDef

    bool stdCppSet() const {

        if (name.isEmpty())

            return false;

        QByteArray s("set");

        s += QtMiscUtils::toAsciiUpper(name[0]);

        s += name.mid(1);

        return (s == write);

    QByteArray name, type, member, read, write, bind, reset, designable, scriptable, stored, user, notify, inPrivateClass;

    int notifyId = -1; // -1 means no notifyId, >= 0 means signal defined in this class, < -1 means signal not defined in this class

    enum Specification  { ValueSpec, ReferenceSpec, PointerSpec };

    Specification gspec = ValueSpec;

    int revision = 0;

    TypeTags typeTag;

    bool constant = false;

    bool final = false;

    bool virtual_ = false;

    bool override = false;

    bool required = false;

    int relativeIndex = -1; // property index in current metaobject

    int lineNumber = 0;

    qsizetype location = -1; // token index, used for error reporting

    QJsonObject toJson() const;

// -- QtScxml

    QByteArray mangledName;

// -- QtScxml

};

Q_DECLARE_TYPEINFO(PropertyDef, Q_RELOCATABLE_TYPE);

struct PrivateQPropertyDef

    Type type;

    QByteArray name;

    QByteArray setter;

    QByteArray accessor;

    QByteArray storage;

};

Q_DECLARE_TYPEINFO(PrivateQPropertyDef, Q_RELOCATABLE_TYPE);

struct ClassInfoDef

    QByteArray name;

    QByteArray value;

};

Q_DECLARE_TYPEINFO(ClassInfoDef, Q_RELOCATABLE_TYPE);

struct BaseDef {

    QByteArray classname;

    QByteArray qualified;

    QList<ClassInfoDef> classInfoList;

    QMap<QByteArray, QFlags<QtMocConstants::EnumFlags>> enumDeclarations;

    QList<EnumDef> enumList;

    QMap<QByteArray, QByteArray> flagAliases;

    qsizetype begin = 0;

    qsizetype end = 0;

    qsizetype lineNumber = 0;

};

struct SuperClass {

    QByteArray classname;

    QByteArray qualified;

    FunctionDef::Access access;

};

Q_DECLARE_TYPEINFO(SuperClass, Q_RELOCATABLE_TYPE);

struct ClassDef : BaseDef {

    QList<SuperClass> superclassList;

    struct Interface

        Interface() { } // for QList, don't use

        inline explicit Interface(const QByteArray &_className)

            : className(_className) {}

        QByteArray className;

        QByteArray interfaceId;

};

    QList<QList<Interface>> interfaceList;

    struct PluginData {

        QByteArray iid;

        QByteArray uri;

        QMap<QString, QJsonArray> metaArgs;

        QJsonDocument metaData;

    } pluginData;

    QList<FunctionDef> constructorList;

    QList<FunctionDef> signalList, slotList, methodList, publicList;

    QList<QByteArray> nonClassSignalList;

    QList<PropertyDef> propertyList;

    QSet<QByteArray> allEnumNames;

    int revisionedMethods = 0;

    bool hasQObject = false;

    bool hasQGadget = false;

    bool hasQNamespace = false;

    bool requireCompleteMethodTypes = false;

    bool isFinal = false;

    QJsonObject toJson() const;

};

Q_DECLARE_TYPEINFO(ClassDef, Q_RELOCATABLE_TYPE);

Q_DECLARE_TYPEINFO(ClassDef::Interface, Q_RELOCATABLE_TYPE);

struct NamespaceDef : BaseDef {

    bool hasQNamespace = false;

    bool doGenerate = false;

};

Q_DECLARE_TYPEINFO(NamespaceDef, Q_RELOCATABLE_TYPE);

#if 0 // -- QtScxml

class Moc : public Parser

public:

    enum PropertyMode { Named, Anonymous };

    Moc()

        : noInclude(false), mustIncludeQPluginH(false), requireCompleteTypes(false)

{}

    QByteArray filename;

    bool noInclude;

    bool mustIncludeQPluginH;

    bool requireCompleteTypes;

    QByteArray includePath;

    QList<QByteArray> includeFiles;

    QList<ClassDef> classList;

    QMap<QByteArray, QByteArray> interface2IdMap;

    QList<QByteArray> metaTypes;

    // map from class name to fully qualified name

    QHash<QByteArray, QByteArray> knownQObjectClasses;

    QHash<QByteArray, QByteArray> knownGadgets;

    QMap<QString, QJsonArray> metaArgs;

    QList<QString> parsedPluginMetadataFiles;

    void parse();

    QByteArrayView strippedFileName() const;

    void generate(FILE *out, FILE *jsonOutput);

    bool parseClassHead(ClassDef *def);

    inline bool inClass(const ClassDef *def) const {

        return index > def->begin && index < def->end - 1;

    inline bool inNamespace(const NamespaceDef *def) const {

        return index > def->begin && index < def->end - 1;

    const QByteArray &toFullyQualified(const QByteArray &name) const noexcept;

    void prependNamespaces(BaseDef &def, const QList<NamespaceDef> &namespaceList) const;

    Type parseType();

    bool parseEnum(EnumDef *def, ClassDef *containingClass);

    bool parseFunction(FunctionDef *def, bool inMacro = false);

    bool parseMaybeFunction(const ClassDef *cdef, FunctionDef *def);

    void parseSlots(ClassDef *def, FunctionDef::Access access);

    void parseSignals(ClassDef *def);

    void parseProperty(ClassDef *def, PropertyMode mode);

    void parsePluginData(ClassDef *def);

    void createPropertyDef(PropertyDef &def, int propertyIndex, PropertyMode mode);

    void parsePropertyAttributes(PropertyDef &propDef);

    void parseEnumOrFlag(BaseDef *def, QtMocConstants::EnumFlags flags);

    void parseFlag(BaseDef *def);

    enum class EncounteredQmlMacro {Yes, No};

    EncounteredQmlMacro parseClassInfo(BaseDef *def);

    void parseClassInfo(ClassDef *def);

    void parseInterfaces(ClassDef *def);

    void parseDeclareInterface();

    void parseDeclareMetatype();

    void parseMocInclude();

    void parseSlotInPrivate(ClassDef *def, FunctionDef::Access access);

    QByteArray parsePropertyAccessor();

    void parsePrivateProperty(ClassDef *def, PropertyMode mode);

    void parseFunctionArguments(FunctionDef *def);

    QByteArray lexemUntil(Token);

    bool until(Token);

    // test for Q_INVOKABLE, Q_SCRIPTABLE, etc. and set the flags

    // in FunctionDef accordingly

    bool testFunctionAttribute(FunctionDef *def);

    bool testFunctionAttribute(Token tok, FunctionDef *def);

    bool testFunctionRevision(FunctionDef *def);

    QTypeRevision parseRevision();

    bool skipCxxAttributes();

    void checkSuperClasses(ClassDef *def);

    void checkProperties(ClassDef* cdef);

    bool testForFunctionModifiers(FunctionDef *def);

    void checkListSizes(const ClassDef &def);

};

#endif // -- QtScxml

inline QByteArray noRef(const QByteArray &type)

    if (type.endsWith('&')) {

        if (type.endsWith("&&"))

            return type.left(type.size()-2);

        return type.left(type.size()-1);

    return type;

QT_END_NAMESPACE

#endif // MOC_H