1/****************************************************************************
2**
3** Copyright (C) 2016 The Qt Company Ltd.
4** Contact: https://www.qt.io/licensing/
5**
6** This file is part of the tools applications of the Qt Toolkit.
7**
8** $QT_BEGIN_LICENSE:GPL-EXCEPT$
9** Commercial License Usage
10** Licensees holding valid commercial Qt licenses may use this file in
11** accordance with the commercial license agreement provided with the
12** Software or, alternatively, in accordance with the terms contained in
13** a written agreement between you and The Qt Company. For licensing terms
14** and conditions see https://www.qt.io/terms-conditions. For further
15** information use the contact form at https://www.qt.io/contact-us.
16**
17** GNU General Public License Usage
18** Alternatively, this file may be used under the terms of the GNU
19** General Public License version 3 as published by the Free Software
20** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
21** included in the packaging of this file. Please review the following
22** information to ensure the GNU General Public License requirements will
23** be met: https://www.gnu.org/licenses/gpl-3.0.html.
24**
25** $QT_END_LICENSE$
26**
27****************************************************************************/
28
29#ifndef MOC_H
30#define MOC_H
31
32#include "parser.h"
33#include <qstringlist.h>
34#include <qmap.h>
35#include <qpair.h>
36#include <qjsondocument.h>
37#include <qjsonarray.h>
38#include <qjsonobject.h>
39#include <stdio.h>
40#include <ctype.h>
41
42QT_BEGIN_NAMESPACE
43
44struct QMetaObject;
45
46struct Type
47{
48 enum ReferenceType { NoReference, Reference, RValueReference, Pointer };
49
50 inline Type() : isVolatile(false), isScoped(false), firstToken(NOTOKEN), referenceType(NoReference) {}
51 inline explicit Type(const QByteArray &_name)
52 : name(_name), rawName(name), isVolatile(false), isScoped(false), firstToken(NOTOKEN), referenceType(NoReference) {}
53 QByteArray name;
54 //When used as a return type, the type name may be modified to remove the references.
55 // rawName is the type as found in the function signature
56 QByteArray rawName;
57 uint isVolatile : 1;
58 uint isScoped : 1;
59 Token firstToken;
60 ReferenceType referenceType;
61};
62Q_DECLARE_TYPEINFO(Type, Q_MOVABLE_TYPE);
63
64struct ClassDef;
65struct EnumDef
66{
67 QByteArray name;
68 QByteArray enumName;
69 QVector<QByteArray> values;
70 bool isEnumClass; // c++11 enum class
71 EnumDef() : isEnumClass(false) {}
72 QJsonObject toJson(const ClassDef &cdef) const;
73};
74Q_DECLARE_TYPEINFO(EnumDef, Q_MOVABLE_TYPE);
75
76struct ArgumentDef
77{
78 ArgumentDef() : isDefault(false) {}
79 Type type;
80 QByteArray rightType, normalizedType, name;
81 QByteArray typeNameForCast; // type name to be used in cast from void * in metacall
82 bool isDefault;
83
84 QJsonObject toJson() const;
85};
86Q_DECLARE_TYPEINFO(ArgumentDef, Q_MOVABLE_TYPE);
87
88struct FunctionDef
89{
90 Type type;
91 QVector<ArgumentDef> arguments;
92 QByteArray normalizedType;
93 QByteArray tag;
94 QByteArray name;
95 QByteArray inPrivateClass;
96
97 enum Access { Private, Protected, Public };
98 Access access = Private;
99 int revision = 0;
100
101 bool isConst = false;
102 bool isVirtual = false;
103 bool isStatic = false;
104 bool inlineCode = false;
105 bool wasCloned = false;
106
107 bool returnTypeIsVolatile = false;
108
109 bool isCompat = false;
110 bool isInvokable = false;
111 bool isScriptable = false;
112 bool isSlot = false;
113 bool isSignal = false;
114 bool isPrivateSignal = false;
115 bool isConstructor = false;
116 bool isDestructor = false;
117 bool isAbstract = false;
118
119 QJsonObject toJson() const;
120 static void accessToJson(QJsonObject *obj, Access acs);
121};
122Q_DECLARE_TYPEINFO(FunctionDef, Q_MOVABLE_TYPE);
123
124struct PropertyDef
125{
126 bool stdCppSet() const {
127 QByteArray s("set");
128 s += toupper(c: name[0]);
129 s += name.mid(index: 1);
130 return (s == write);
131 }
132
133 QByteArray name, type, member, read, write, reset, designable, scriptable, editable, stored, user, notify, inPrivateClass;
134 int notifyId = -1; // -1 means no notifyId, >= 0 means signal defined in this class, < -1 means signal not defined in this class
135 enum Specification { ValueSpec, ReferenceSpec, PointerSpec };
136 Specification gspec = ValueSpec;
137 int revision = 0;
138 bool constant = false;
139 bool final = false;
140 bool required = false;
141
142 QJsonObject toJson() const;
143};
144Q_DECLARE_TYPEINFO(PropertyDef, Q_MOVABLE_TYPE);
145
146
147struct ClassInfoDef
148{
149 QByteArray name;
150 QByteArray value;
151};
152Q_DECLARE_TYPEINFO(ClassInfoDef, Q_MOVABLE_TYPE);
153
154struct BaseDef {
155 QByteArray classname;
156 QByteArray qualified;
157 QVector<ClassInfoDef> classInfoList;
158 QMap<QByteArray, bool> enumDeclarations;
159 QVector<EnumDef> enumList;
160 QMap<QByteArray, QByteArray> flagAliases;
161 int begin = 0;
162 int end = 0;
163};
164
165struct ClassDef : BaseDef {
166 QVector<QPair<QByteArray, FunctionDef::Access> > superclassList;
167
168 struct Interface
169 {
170 Interface() {} // for QVector, don't use
171 inline explicit Interface(const QByteArray &_className)
172 : className(_className) {}
173 QByteArray className;
174 QByteArray interfaceId;
175 };
176 QVector<QVector<Interface> >interfaceList;
177
178 struct PluginData {
179 QByteArray iid;
180 QByteArray uri;
181 QMap<QString, QJsonArray> metaArgs;
182 QJsonDocument metaData;
183 } pluginData;
184
185 QVector<FunctionDef> constructorList;
186 QVector<FunctionDef> signalList, slotList, methodList, publicList;
187 QVector<QByteArray> nonClassSignalList;
188 QVector<PropertyDef> propertyList;
189 int notifyableProperties = 0;
190 int revisionedMethods = 0;
191 int revisionedProperties = 0;
192
193 bool hasQObject = false;
194 bool hasQGadget = false;
195 bool hasQNamespace = false;
196
197 QJsonObject toJson() const;
198};
199Q_DECLARE_TYPEINFO(ClassDef, Q_MOVABLE_TYPE);
200Q_DECLARE_TYPEINFO(ClassDef::Interface, Q_MOVABLE_TYPE);
201
202struct NamespaceDef : BaseDef {
203 bool hasQNamespace = false;
204 bool doGenerate = false;
205};
206Q_DECLARE_TYPEINFO(NamespaceDef, Q_MOVABLE_TYPE);
207
208class Moc : public Parser
209{
210public:
211 Moc()
212 : noInclude(false), mustIncludeQPluginH(false)
213 {}
214
215 QByteArray filename;
216
217 bool noInclude;
218 bool mustIncludeQPluginH;
219 QByteArray includePath;
220 QVector<QByteArray> includeFiles;
221 QVector<ClassDef> classList;
222 QMap<QByteArray, QByteArray> interface2IdMap;
223 QVector<QByteArray> metaTypes;
224 // map from class name to fully qualified name
225 QHash<QByteArray, QByteArray> knownQObjectClasses;
226 QHash<QByteArray, QByteArray> knownGadgets;
227 QMap<QString, QJsonArray> metaArgs;
228 QVector<QString> parsedPluginMetadataFiles;
229
230 void parse();
231 void generate(FILE *out, FILE *jsonOutput);
232
233 bool parseClassHead(ClassDef *def);
234 inline bool inClass(const ClassDef *def) const {
235 return index > def->begin && index < def->end - 1;
236 }
237
238 inline bool inNamespace(const NamespaceDef *def) const {
239 return index > def->begin && index < def->end - 1;
240 }
241
242 Type parseType();
243
244 bool parseEnum(EnumDef *def);
245
246 bool parseFunction(FunctionDef *def, bool inMacro = false);
247 bool parseMaybeFunction(const ClassDef *cdef, FunctionDef *def);
248
249 void parseSlots(ClassDef *def, FunctionDef::Access access);
250 void parseSignals(ClassDef *def);
251 void parseProperty(ClassDef *def);
252 void parsePluginData(ClassDef *def);
253 void createPropertyDef(PropertyDef &def);
254 void parseEnumOrFlag(BaseDef *def, bool isFlag);
255 void parseFlag(BaseDef *def);
256 void parseClassInfo(BaseDef *def);
257 void parseInterfaces(ClassDef *def);
258 void parseDeclareInterface();
259 void parseDeclareMetatype();
260 void parseSlotInPrivate(ClassDef *def, FunctionDef::Access access);
261 void parsePrivateProperty(ClassDef *def);
262
263 void parseFunctionArguments(FunctionDef *def);
264
265 QByteArray lexemUntil(Token);
266 bool until(Token);
267
268 // test for Q_INVOCABLE, Q_SCRIPTABLE, etc. and set the flags
269 // in FunctionDef accordingly
270 bool testFunctionAttribute(FunctionDef *def);
271 bool testFunctionAttribute(Token tok, FunctionDef *def);
272 bool testFunctionRevision(FunctionDef *def);
273
274 bool skipCxxAttributes();
275
276 void checkSuperClasses(ClassDef *def);
277 void checkProperties(ClassDef* cdef);
278};
279
280inline QByteArray noRef(const QByteArray &type)
281{
282 if (type.endsWith(c: '&')) {
283 if (type.endsWith(c: "&&"))
284 return type.left(len: type.length()-2);
285 return type.left(len: type.length()-1);
286 }
287 return type;
288}
289
290QT_END_NAMESPACE
291
292#endif // MOC_H
293

source code of qtbase/src/tools/moc/moc.h