1berry/qtbase
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use QList instead of QVector in moc

Browse Source 
Task-number: QTBUG-84469
Change-Id: Id95a656e6277a7c348c02c3267a45ac176c1643b
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
This commit is contained in:
Jarek Kobus 2020-06-22 14:10:12 +02:00
parent 95a5cd71b6
commit 670c5bd140
5 changed files with 75 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
src/tools/moc/generator.cpp
View File

@ -80,12 +80,19 @@ QT_FOR_EACH_STATIC_TYPE(RETURN_METATYPENAME_STRING)
return nullptr; return nullptr;
} }
Generator::Generator(ClassDef *classDef, const QVector<QByteArray> &metaTypes, const QHash<QByteArray, QByteArray> &knownQObjectClasses, const QHash<QByteArray, QByteArray> &knownGadgets, FILE *outfile, bool requireCompleteTypes) Generator::Generator(ClassDef *classDef, const QList<QByteArray> &metaTypes,
: out(outfile), cdef(classDef), metaTypes(metaTypes), knownQObjectClasses(knownQObjectClasses) const QHash<QByteArray, QByteArray> &knownQObjectClasses,
, knownGadgets(knownGadgets), requireCompleteTypes(requireCompleteTypes) const QHash<QByteArray, QByteArray> &knownGadgets, FILE *outfile,
{ bool requireCompleteTypes)
if (cdef->superclassList.size()) : out(outfile),
purestSuperClass = cdef->superclassList.constFirst().first; cdef(classDef),
metaTypes(metaTypes),
knownQObjectClasses(knownQObjectClasses),
knownGadgets(knownGadgets),
requireCompleteTypes(requireCompleteTypes)
{
if (cdef->superclassList.size())
purestSuperClass = cdef->superclassList.constFirst().first;
} }
static inline int lengthOfEscapeSequence(const QByteArray &s, int i) static inline int lengthOfEscapeSequence(const QByteArray &s, int i)
@ -127,7 +134,7 @@ int Generator::stridx(const QByteArray &s)
// Returns the sum of all parameters (including return type) for the given // Returns the sum of all parameters (including return type) for the given
// \a list of methods. This is needed for calculating the size of the methods' // \a list of methods. This is needed for calculating the size of the methods'
// parameter type/name meta-data. // parameter type/name meta-data.
static int aggregateParameterCount(const QVector<FunctionDef> &list) static int aggregateParameterCount(const QList<FunctionDef> &list)
{ {
int sum = 0; int sum = 0;
for (int i = 0; i < list.count(); ++i) for (int i = 0; i < list.count(); ++i)
@ -150,22 +157,22 @@ bool Generator::registerableMetaType(const QByteArray &propertyType)
return true; return true;
} }
static const QVector<QByteArray> smartPointers = QVector<QByteArray>() static const QList<QByteArray> smartPointers = QList<QByteArray>()
#define STREAM_SMART_POINTER(SMART_POINTER) << #SMART_POINTER #define STREAM_SMART_POINTER(SMART_POINTER) << #SMART_POINTER
QT_FOR_EACH_AUTOMATIC_TEMPLATE_SMART_POINTER(STREAM_SMART_POINTER) QT_FOR_EACH_AUTOMATIC_TEMPLATE_SMART_POINTER(STREAM_SMART_POINTER)
#undef STREAM_SMART_POINTER #undef STREAM_SMART_POINTER
; ;
for (const QByteArray &smartPointer : smartPointers) { for (const QByteArray &smartPointer : smartPointers) {
if (propertyType.startsWith(smartPointer + "<") && !propertyType.endsWith("&")) if (propertyType.startsWith(smartPointer + "<") && !propertyType.endsWith("&"))
return knownQObjectClasses.contains(propertyType.mid(smartPointer.size() + 1, propertyType.size() - smartPointer.size() - 1 - 1)); return knownQObjectClasses.contains(propertyType.mid(smartPointer.size() + 1, propertyType.size() - smartPointer.size() - 1 - 1));
} }
static const QVector<QByteArray> oneArgTemplates = QVector<QByteArray>() static const QList<QByteArray> oneArgTemplates = QList<QByteArray>()
#define STREAM_1ARG_TEMPLATE(TEMPLATENAME) << #TEMPLATENAME #define STREAM_1ARG_TEMPLATE(TEMPLATENAME) << #TEMPLATENAME
QT_FOR_EACH_AUTOMATIC_TEMPLATE_1ARG(STREAM_1ARG_TEMPLATE) QT_FOR_EACH_AUTOMATIC_TEMPLATE_1ARG(STREAM_1ARG_TEMPLATE)
#undef STREAM_1ARG_TEMPLATE #undef STREAM_1ARG_TEMPLATE
; ;
for (const QByteArray &oneArgTemplateType : oneArgTemplates) { for (const QByteArray &oneArgTemplateType : oneArgTemplates) {
if (propertyType.startsWith(oneArgTemplateType + "<") && propertyType.endsWith(">")) { if (propertyType.startsWith(oneArgTemplateType + "<") && propertyType.endsWith(">")) {
const int argumentSize = propertyType.size() - oneArgTemplateType.size() - 1 const int argumentSize = propertyType.size() - oneArgTemplateType.size() - 1
@ -199,7 +206,7 @@ void Generator::generateCode()
// filter out undeclared enumerators and sets // filter out undeclared enumerators and sets
{ {
QVector<EnumDef> enumList; QList<EnumDef> enumList;
for (int i = 0; i < cdef->enumList.count(); ++i) { for (int i = 0; i < cdef->enumList.count(); ++i) {
EnumDef def = cdef->enumList.at(i); EnumDef def = cdef->enumList.at(i);
if (cdef->enumDeclarations.contains(def.name)) { if (cdef->enumDeclarations.contains(def.name)) {
@ -455,7 +462,7 @@ void Generator::generateCode()
// //
// Build extra array // Build extra array
// //
QVector<QByteArray> extraList; QList<QByteArray> extraList;
QMultiHash<QByteArray, QByteArray> knownExtraMetaObject = knownGadgets; QMultiHash<QByteArray, QByteArray> knownExtraMetaObject = knownGadgets;
knownExtraMetaObject.unite(knownQObjectClasses); knownExtraMetaObject.unite(knownQObjectClasses);
@ -574,7 +581,8 @@ void Generator::generateCode()
fprintf(out, "%s%s", needsComma ? ", " : "", p.type.data()); fprintf(out, "%s%s", needsComma ? ", " : "", p.type.data());
needsComma = true; needsComma = true;
} }
for (const QVector<FunctionDef> &methodContainer: {cdef->signalList, cdef->slotList, cdef->methodList} ) { for (const QList<FunctionDef> &methodContainer :
{ cdef->signalList, cdef->slotList, cdef->methodList }) {
for (int i = 0; i< methodContainer.count(); ++i) { for (int i = 0; i< methodContainer.count(); ++i) {
const FunctionDef& fdef = methodContainer.at(i); const FunctionDef& fdef = methodContainer.at(i);
fprintf(out, "%s%s", needsComma ? ", " : "", fdef.type.name.data()); fprintf(out, "%s%s", needsComma ? ", " : "", fdef.type.name.data());
@ -621,7 +629,7 @@ void Generator::generateCode()
cname, cname); cname, cname);
} }
for (int i = 0; i < cdef->interfaceList.size(); ++i) { for (int i = 0; i < cdef->interfaceList.size(); ++i) {
const QVector<ClassDef::Interface> &iface = cdef->interfaceList.at(i); const QList<ClassDef::Interface> &iface = cdef->interfaceList.at(i);
for (int j = 0; j < iface.size(); ++j) { for (int j = 0; j < iface.size(); ++j) {
fprintf(out, " if (!strcmp(_clname, %s))\n return ", iface.at(j).interfaceId.constData()); fprintf(out, " if (!strcmp(_clname, %s))\n return ", iface.at(j).interfaceId.constData());
for (int k = j; k >= 0; --k) for (int k = j; k >= 0; --k)
@ -695,7 +703,7 @@ void Generator::generateClassInfos()
} }
} }
void Generator::registerFunctionStrings(const QVector<FunctionDef>& list) void Generator::registerFunctionStrings(const QList<FunctionDef> &list)
{ {
for (int i = 0; i < list.count(); ++i) { for (int i = 0; i < list.count(); ++i) {
const FunctionDef &f = list.at(i); const FunctionDef &f = list.at(i);
@ -715,13 +723,14 @@ void Generator::registerFunctionStrings(const QVector<FunctionDef>& list)
} }
} }
void Generator::registerByteArrayVector(const QVector<QByteArray> &list) void Generator::registerByteArrayVector(const QList<QByteArray> &list)
{ {
for (const QByteArray &ba : list) for (const QByteArray &ba : list)
strreg(ba); strreg(ba);
} }
void Generator::generateFunctions(const QVector<FunctionDef>& list, const char *functype, int type, int &paramsIndex, int &initialMetatypeOffset) void Generator::generateFunctions(const QList<FunctionDef> &list, const char *functype, int type,
int &paramsIndex, int &initialMetatypeOffset)
{ {
if (list.isEmpty()) if (list.isEmpty())
return; return;
@ -769,7 +778,7 @@ void Generator::generateFunctions(const QVector<FunctionDef>& list, const char *
} }
} }
void Generator::generateFunctionRevisions(const QVector<FunctionDef>& list, const char *functype) void Generator::generateFunctionRevisions(const QList<FunctionDef> &list, const char *functype)
{ {
if (list.count()) if (list.count())
fprintf(out, "\n // %ss: revision\n", functype); fprintf(out, "\n // %ss: revision\n", functype);
@ -779,7 +788,7 @@ void Generator::generateFunctionRevisions(const QVector<FunctionDef>& list, cons
} }
} }
void Generator::generateFunctionParameters(const QVector<FunctionDef>& list, const char *functype) void Generator::generateFunctionParameters(const QList<FunctionDef> &list, const char *functype)
{ {
if (list.isEmpty()) if (list.isEmpty())
return; return;
@ -968,7 +977,7 @@ void Generator::generateMetacall()
bool needElse = false; bool needElse = false;
QVector<FunctionDef> methodList; QList<FunctionDef> methodList;
methodList += cdef->signalList; methodList += cdef->signalList;
methodList += cdef->slotList; methodList += cdef->slotList;
methodList += cdef->methodList; methodList += cdef->methodList;
@ -1031,7 +1040,8 @@ QMultiMap<QByteArray, int> Generator::automaticPropertyMetaTypesHelper()
return automaticPropertyMetaTypes; return automaticPropertyMetaTypes;
} }
QMap<int, QMultiMap<QByteArray, int> > Generator::methodsWithAutomaticTypesHelper(const QVector<FunctionDef> &methodList) QMap<int, QMultiMap<QByteArray, int>>
Generator::methodsWithAutomaticTypesHelper(const QList<FunctionDef> &methodList)
{ {
QMap<int, QMultiMap<QByteArray, int> > methodsWithAutomaticTypes; QMap<int, QMultiMap<QByteArray, int> > methodsWithAutomaticTypes;
for (int i = 0; i < methodList.size(); ++i) { for (int i = 0; i < methodList.size(); ++i) {
@ -1085,7 +1095,7 @@ void Generator::generateStaticMetacall()
isUsed_a = true; isUsed_a = true;
} }
QVector<FunctionDef> methodList; QList<FunctionDef> methodList;
methodList += cdef->signalList; methodList += cdef->signalList;
methodList += cdef->slotList; methodList += cdef->slotList;
methodList += cdef->methodList; methodList += cdef->methodList;

26
src/tools/moc/generator.h
View File

@ -37,19 +37,24 @@ class Generator
{ {
FILE *out; FILE *out;
ClassDef *cdef; ClassDef *cdef;
QVector<uint> meta_data; QList<uint> meta_data;
public: public:
Generator(ClassDef *classDef, const QVector<QByteArray> &metaTypes, const QHash<QByteArray, QByteArray> &knownQObjectClasses, const QHash<QByteArray, QByteArray> &knownGadgets, FILE *outfile = nullptr, bool requireCompleteTypes = false); Generator(ClassDef *classDef, const QList<QByteArray> &metaTypes,
const QHash<QByteArray, QByteArray> &knownQObjectClasses,
const QHash<QByteArray, QByteArray> &knownGadgets, FILE *outfile = nullptr,
bool requireCompleteTypes = false);
void generateCode(); void generateCode();
private: private:
bool registerableMetaType(const QByteArray &propertyType); bool registerableMetaType(const QByteArray &propertyType);
void registerClassInfoStrings(); void registerClassInfoStrings();
void generateClassInfos(); void generateClassInfos();
void registerFunctionStrings(const QVector<FunctionDef> &list); void registerFunctionStrings(const QList<FunctionDef> &list);
void registerByteArrayVector(const QVector<QByteArray> &list); void registerByteArrayVector(const QList<QByteArray> &list);
void generateFunctions(const QVector<FunctionDef> &list, const char *functype, int type, int &paramsIndex, int &initialMetatypeOffset); void generateFunctions(const QList<FunctionDef> &list, const char *functype, int type,
void generateFunctionRevisions(const QVector<FunctionDef> &list, const char *functype); int &paramsIndex, int &initialMetatypeOffset);
void generateFunctionParameters(const QVector<FunctionDef> &list, const char *functype); void generateFunctionRevisions(const QList<FunctionDef> &list, const char *functype);
void generateFunctionParameters(const QList<FunctionDef> &list, const char *functype);
void generateTypeInfo(const QByteArray &typeName, bool allowEmptyName = false); void generateTypeInfo(const QByteArray &typeName, bool allowEmptyName = false);
void registerEnumStrings(); void registerEnumStrings();
void generateEnums(int index); void generateEnums(int index);
@ -61,13 +66,14 @@ private:
void generateQPropertyApi(); void generateQPropertyApi();
void generatePluginMetaData(); void generatePluginMetaData();
QMultiMap<QByteArray, int> automaticPropertyMetaTypesHelper(); QMultiMap<QByteArray, int> automaticPropertyMetaTypesHelper();
QMap<int, QMultiMap<QByteArray, int> > methodsWithAutomaticTypesHelper(const QVector<FunctionDef> &methodList); QMap<int, QMultiMap<QByteArray, int>>
methodsWithAutomaticTypesHelper(const QList<FunctionDef> &methodList);
void strreg(const QByteArray &); // registers a string void strreg(const QByteArray &); // registers a string
int stridx(const QByteArray &); // returns a string's id int stridx(const QByteArray &); // returns a string's id
QVector<QByteArray> strings; QList<QByteArray> strings;
QByteArray purestSuperClass; QByteArray purestSuperClass;
QVector<QByteArray> metaTypes; QList<QByteArray> metaTypes;
QHash<QByteArray, QByteArray> knownQObjectClasses; QHash<QByteArray, QByteArray> knownQObjectClasses;
QHash<QByteArray, QByteArray> knownGadgets; QHash<QByteArray, QByteArray> knownGadgets;
bool requireCompleteTypes; bool requireCompleteTypes;

14
src/tools/moc/moc.cpp
View File

@ -607,7 +607,7 @@ bool Moc::parseMaybeQProperty(ClassDef *def)
void Moc::parse() void Moc::parse()
{ {
QVector<NamespaceDef> namespaceList; QList<NamespaceDef> namespaceList;
bool templateClass = false; bool templateClass = false;
while (hasNext()) { while (hasNext()) {
Token t = next(); Token t = next();
@ -1008,7 +1008,7 @@ void Moc::parse()
} }
} }
static bool any_type_contains(const QVector<PropertyDef> &properties, const QByteArray &pattern) static bool any_type_contains(const QList<PropertyDef> &properties, const QByteArray &pattern)
{ {
for (const auto &p : properties) { for (const auto &p : properties) {
if (p.type.contains(pattern)) if (p.type.contains(pattern))
@ -1017,7 +1017,7 @@ static bool any_type_contains(const QVector<PropertyDef> &properties, const QByt
return false; return false;
} }
static bool any_arg_contains(const QVector<FunctionDef> &functions, const QByteArray &pattern) static bool any_arg_contains(const QList<FunctionDef> &functions, const QByteArray &pattern)
{ {
for (const auto &f : functions) { for (const auto &f : functions) {
for (const auto &arg : f.arguments) { for (const auto &arg : f.arguments) {
@ -1042,7 +1042,7 @@ static QByteArrayList make_candidates()
return result; return result;
} }
static QByteArrayList requiredQtContainers(const QVector<ClassDef> &classes) static QByteArrayList requiredQtContainers(const QList<ClassDef> &classes)
{ {
static const QByteArrayList candidates = make_candidates(); static const QByteArrayList candidates = make_candidates();
@ -1608,7 +1608,7 @@ void Moc::parseInterfaces(ClassDef *def)
{ {
next(LPAREN); next(LPAREN);
while (test(IDENTIFIER)) { while (test(IDENTIFIER)) {
QVector<ClassDef::Interface> iface; QList<ClassDef::Interface> iface;
iface += ClassDef::Interface(lexem()); iface += ClassDef::Interface(lexem());
while (test(SCOPE)) { while (test(SCOPE)) {
iface.last().className += lexem(); iface.last().className += lexem();
@ -1966,7 +1966,7 @@ QJsonObject ClassDef::toJson() const
if (classInfos.size()) if (classInfos.size())
cls[QLatin1String("classInfos")] = classInfos; cls[QLatin1String("classInfos")] = classInfos;
const auto appendFunctions = [&cls](const QString &type, const QVector<FunctionDef> &funcs) { const auto appendFunctions = [&cls](const QString &type, const QList<FunctionDef> &funcs) {
QJsonArray jsonFuncs; QJsonArray jsonFuncs;
for (const FunctionDef &fdef: funcs) for (const FunctionDef &fdef: funcs)
@ -2017,7 +2017,7 @@ QJsonObject ClassDef::toJson() const
cls[QLatin1String("enums")] = enums; cls[QLatin1String("enums")] = enums;
QJsonArray ifaces; QJsonArray ifaces;
for (const QVector<Interface> &ifaceList: interfaceList) { for (const QList<Interface> &ifaceList : interfaceList) {
QJsonArray jsonList; QJsonArray jsonList;
for (const Interface &iface: ifaceList) { for (const Interface &iface: ifaceList) {
QJsonObject ifaceJson; QJsonObject ifaceJson;

32
src/tools/moc/moc.h
View File

@ -67,7 +67,7 @@ struct EnumDef
{ {
QByteArray name; QByteArray name;
QByteArray enumName; QByteArray enumName;
QVector<QByteArray> values; QList<QByteArray> values;
bool isEnumClass; // c++11 enum class bool isEnumClass; // c++11 enum class
EnumDef() : isEnumClass(false) {} EnumDef() : isEnumClass(false) {}
QJsonObject toJson(const ClassDef &cdef) const; QJsonObject toJson(const ClassDef &cdef) const;
@ -89,7 +89,7 @@ Q_DECLARE_TYPEINFO(ArgumentDef, Q_MOVABLE_TYPE);
struct FunctionDef struct FunctionDef
{ {
Type type; Type type;
QVector<ArgumentDef> arguments; QList<ArgumentDef> arguments;
QByteArray normalizedType; QByteArray normalizedType;
QByteArray tag; QByteArray tag;
QByteArray name; QByteArray name;
@ -168,26 +168,26 @@ Q_DECLARE_TYPEINFO(ClassInfoDef, Q_MOVABLE_TYPE);
struct BaseDef { struct BaseDef {
QByteArray classname; QByteArray classname;
QByteArray qualified; QByteArray qualified;
QVector<ClassInfoDef> classInfoList; QList<ClassInfoDef> classInfoList;
QMap<QByteArray, bool> enumDeclarations; QMap<QByteArray, bool> enumDeclarations;
QVector<EnumDef> enumList; QList<EnumDef> enumList;
QMap<QByteArray, QByteArray> flagAliases; QMap<QByteArray, QByteArray> flagAliases;
int begin = 0; int begin = 0;
int end = 0; int end = 0;
}; };
struct ClassDef : BaseDef { struct ClassDef : BaseDef {
QVector<QPair<QByteArray, FunctionDef::Access> > superclassList; QList<QPair<QByteArray, FunctionDef::Access>> superclassList;
struct Interface struct Interface
{ {
Interface() {} // for QVector, don't use Interface() { } // for QList, don't use
inline explicit Interface(const QByteArray &_className) inline explicit Interface(const QByteArray &_className)
: className(_className) {} : className(_className) {}
QByteArray className; QByteArray className;
QByteArray interfaceId; QByteArray interfaceId;
}; };
QVector<QVector<Interface> >interfaceList; QList<QList<Interface>> interfaceList;
struct PluginData { struct PluginData {
QByteArray iid; QByteArray iid;
@ -196,11 +196,11 @@ struct ClassDef : BaseDef {
QJsonDocument metaData; QJsonDocument metaData;
} pluginData; } pluginData;
QVector<FunctionDef> constructorList; QList<FunctionDef> constructorList;
QVector<FunctionDef> signalList, slotList, methodList, publicList; QList<FunctionDef> signalList, slotList, methodList, publicList;
QVector<QByteArray> nonClassSignalList; QList<QByteArray> nonClassSignalList;
QVector<PropertyDef> propertyList; QList<PropertyDef> propertyList;
QVector<PrivateQPropertyDef> privateQProperties; QList<PrivateQPropertyDef> privateQProperties;
QHash<QByteArray, bool> qPropertyMembersMaybeWithNotifier; QHash<QByteArray, bool> qPropertyMembersMaybeWithNotifier;
int revisionedMethods = 0; int revisionedMethods = 0;
@ -232,15 +232,15 @@ public:
bool mustIncludeQPluginH; bool mustIncludeQPluginH;
bool requireCompleteTypes; bool requireCompleteTypes;
QByteArray includePath; QByteArray includePath;
QVector<QByteArray> includeFiles; QList<QByteArray> includeFiles;
QVector<ClassDef> classList; QList<ClassDef> classList;
QMap<QByteArray, QByteArray> interface2IdMap; QMap<QByteArray, QByteArray> interface2IdMap;
QVector<QByteArray> metaTypes; QList<QByteArray> metaTypes;
// map from class name to fully qualified name // map from class name to fully qualified name
QHash<QByteArray, QByteArray> knownQObjectClasses; QHash<QByteArray, QByteArray> knownQObjectClasses;
QHash<QByteArray, QByteArray> knownGadgets; QHash<QByteArray, QByteArray> knownGadgets;
QMap<QString, QJsonArray> metaArgs; QMap<QString, QJsonArray> metaArgs;
QVector<QString> parsedPluginMetadataFiles; QList<QString> parsedPluginMetadataFiles;
void parse(); void parse();
void generate(FILE *out, FILE *jsonOutput); void generate(FILE *out, FILE *jsonOutput);

2
src/tools/moc/symbols.h
View File

@ -120,7 +120,7 @@ struct Symbol
}; };
Q_DECLARE_TYPEINFO(Symbol, Q_MOVABLE_TYPE); Q_DECLARE_TYPEINFO(Symbol, Q_MOVABLE_TYPE);
typedef QVector<Symbol> Symbols; typedef QList<Symbol> Symbols;
struct SafeSymbols { struct SafeSymbols {
Symbols symbols; Symbols symbols;