Revision control
++ // 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