| /**************************************************************************** | |
| ** | |
| ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). | |
| ** All rights reserved. | |
| ** Contact: Nokia Corporation (qt-info@nokia.com) | |
| ** | |
| ** This file is part of the tools applications of the Qt Toolkit. | |
| ** | |
| ** $QT_BEGIN_LICENSE:LGPL$ | |
| ** GNU Lesser General Public License Usage | |
| ** This file may be used under the terms of the GNU Lesser General Public | |
| ** License version 2.1 as published by the Free Software Foundation and | |
| ** appearing in the file LICENSE.LGPL included in the packaging of this | |
| ** file. Please review the following information to ensure the GNU Lesser | |
| ** General Public License version 2.1 requirements will be met: | |
| ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. | |
| ** | |
| ** In addition, as a special exception, Nokia gives you certain additional | |
| ** rights. These rights are described in the Nokia Qt LGPL Exception | |
| ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. | |
| ** | |
| ** GNU General Public License Usage | |
| ** Alternatively, this file may be used under the terms of the GNU General | |
| ** Public License version 3.0 as published by the Free Software Foundation | |
| ** and appearing in the file LICENSE.GPL included in the packaging of this | |
| ** file. Please review the following information to ensure the GNU General | |
| ** Public License version 3.0 requirements will be met: | |
| ** http://www.gnu.org/copyleft/gpl.html. | |
| ** | |
| ** Other Usage | |
| ** Alternatively, this file may be used in accordance with the terms and | |
| ** conditions contained in a signed written agreement between you and Nokia. | |
| ** | |
| ** | |
| ** | |
| ** | |
| ** | |
| ** $QT_END_LICENSE$ | |
| ** | |
| ****************************************************************************/ | |
| #include "generator.h" | |
| #include "outputrevision.h" | |
| #include "utils.h" | |
| #include <QtCore/qmetatype.h> | |
| #include <stdio.h> | |
| #include <private/qmetaobject_p.h> //for the flags. | |
| QT_BEGIN_NAMESPACE | |
| uint qvariant_nameToType(const char* name) | |
| { | |
| if (!name) | |
| return 0; | |
| if (strcmp(name, "QVariant") == 0) | |
| return 0xffffffff; | |
| if (strcmp(name, "QCString") == 0) | |
| return QMetaType::QByteArray; | |
| if (strcmp(name, "Q_LLONG") == 0) | |
| return QMetaType::LongLong; | |
| if (strcmp(name, "Q_ULLONG") == 0) | |
| return QMetaType::ULongLong; | |
| if (strcmp(name, "QIconSet") == 0) | |
| return QMetaType::QIcon; | |
| uint tp = QMetaType::type(name); | |
| return tp < QMetaType::User ? tp : 0; | |
| } | |
| /* | |
| Returns true if the type is a QVariant types. | |
| */ | |
| bool isVariantType(const char* type) | |
| { | |
| return qvariant_nameToType(type) != 0; | |
| } | |
| /*! | |
| Returns true if the type is qreal. | |
| */ | |
| static bool isQRealType(const char *type) | |
| { | |
| return strcmp(type, "qreal") == 0; | |
| } | |
| Generator::Generator(ClassDef *classDef, const QList<QByteArray> &metaTypes, FILE *outfile) | |
| : out(outfile), cdef(classDef), metaTypes(metaTypes) | |
| { | |
| if (cdef->superclassList.size()) | |
| purestSuperClass = cdef->superclassList.first().first; | |
| } | |
| static inline int lengthOfEscapeSequence(const QByteArray &s, int i) | |
| { | |
| if (s.at(i) != '\\' || i >= s.length() - 1) | |
| return 1; | |
| const int startPos = i; | |
| ++i; | |
| char ch = s.at(i); | |
| if (ch == 'x') { | |
| ++i; | |
| while (i < s.length() && is_hex_char(s.at(i))) | |
| ++i; | |
| } else if (is_octal_char(ch)) { | |
| while (i < startPos + 4 | |
| && i < s.length() | |
| && is_octal_char(s.at(i))) { | |
| ++i; | |
| } | |
| } else { // single character escape sequence | |
| i = qMin(i + 1, s.length()); | |
| } | |
| return i - startPos; | |
| } | |
| int Generator::strreg(const char *s) | |
| { | |
| int idx = 0; | |
| if (!s) | |
| s = ""; | |
| for (int i = 0; i < strings.size(); ++i) { | |
| const QByteArray &str = strings.at(i); | |
| if (str == s) | |
| return idx; | |
| idx += str.length() + 1; | |
| for (int i = 0; i < str.length(); ++i) { | |
| if (str.at(i) == '\\') { | |
| int cnt = lengthOfEscapeSequence(str, i) - 1; | |
| idx -= cnt; | |
| i += cnt; | |
| } | |
| } | |
| } | |
| strings.append(s); | |
| return idx; | |
| } | |
| void Generator::generateCode() | |
| { | |
| bool isQt = (cdef->classname == "Qt"); | |
| bool isQObject = (cdef->classname == "QObject"); | |
| bool isConstructible = !cdef->constructorList.isEmpty(); | |
| // | |
| // build the data array | |
| // | |
| int i = 0; | |
| // filter out undeclared enumerators and sets | |
| { | |
| QList<EnumDef> enumList; | |
| for (i = 0; i < cdef->enumList.count(); ++i) { | |
| EnumDef def = cdef->enumList.at(i); | |
| if (cdef->enumDeclarations.contains(def.name)) { | |
| enumList += def; | |
| } | |
| QByteArray alias = cdef->flagAliases.value(def.name); | |
| if (cdef->enumDeclarations.contains(alias)) { | |
| def.name = alias; | |
| enumList += def; | |
| } | |
| } | |
| cdef->enumList = enumList; | |
| } | |
| QByteArray qualifiedClassNameIdentifier = cdef->qualified; | |
| qualifiedClassNameIdentifier.replace(':', '_'); | |
| int index = 14; | |
| fprintf(out, "static const uint qt_meta_data_%s[] = {\n", qualifiedClassNameIdentifier.constData()); | |
| fprintf(out, "\n // content:\n"); | |
| fprintf(out, " %4d, // revision\n", 5); | |
| fprintf(out, " %4d, // classname\n", strreg(cdef->qualified)); | |
| fprintf(out, " %4d, %4d, // classinfo\n", cdef->classInfoList.count(), cdef->classInfoList.count() ? index : 0); | |
| index += cdef->classInfoList.count() * 2; | |
| int methodCount = cdef->signalList.count() + cdef->slotList.count() + cdef->methodList.count(); | |
| fprintf(out, " %4d, %4d, // methods\n", methodCount, methodCount ? index : 0); | |
| index += methodCount * 5; | |
| if (cdef->revisionedMethods) | |
| index += methodCount; | |
| fprintf(out, " %4d, %4d, // properties\n", cdef->propertyList.count(), cdef->propertyList.count() ? index : 0); | |
| index += cdef->propertyList.count() * 3; | |
| if(cdef->notifyableProperties) | |
| index += cdef->propertyList.count(); | |
| if (cdef->revisionedProperties) | |
| index += cdef->propertyList.count(); | |
| fprintf(out, " %4d, %4d, // enums/sets\n", cdef->enumList.count(), cdef->enumList.count() ? index : 0); | |
| int enumsIndex = index; | |
| for (i = 0; i < cdef->enumList.count(); ++i) | |
| index += 4 + (cdef->enumList.at(i).values.count() * 2); | |
| fprintf(out, " %4d, %4d, // constructors\n", isConstructible ? cdef->constructorList.count() : 0, | |
| isConstructible ? index : 0); | |
| fprintf(out, " %4d, // flags\n", 0); | |
| fprintf(out, " %4d, // signalCount\n", cdef->signalList.count()); | |
| // | |
| // Build classinfo array | |
| // | |
| generateClassInfos(); | |
| // | |
| // Build signals array first, otherwise the signal indices would be wrong | |
| // | |
| generateFunctions(cdef->signalList, "signal", MethodSignal); | |
| // | |
| // Build slots array | |
| // | |
| generateFunctions(cdef->slotList, "slot", MethodSlot); | |
| // | |
| // Build method array | |
| // | |
| generateFunctions(cdef->methodList, "method", MethodMethod); | |
| // | |
| // Build method version arrays | |
| // | |
| if (cdef->revisionedMethods) { | |
| generateFunctionRevisions(cdef->signalList, "signal"); | |
| generateFunctionRevisions(cdef->slotList, "slot"); | |
| generateFunctionRevisions(cdef->methodList, "method"); | |
| } | |
| // | |
| // Build property array | |
| // | |
| generateProperties(); | |
| // | |
| // Build enums array | |
| // | |
| generateEnums(enumsIndex); | |
| // | |
| // Build constructors array | |
| // | |
| if (isConstructible) | |
| generateFunctions(cdef->constructorList, "constructor", MethodConstructor); | |
| // | |
| // Terminate data array | |
| // | |
| fprintf(out, "\n 0 // eod\n};\n\n"); | |
| // | |
| // Build stringdata array | |
| // | |
| fprintf(out, "static const char qt_meta_stringdata_%s[] = {\n", qualifiedClassNameIdentifier.constData()); | |
| fprintf(out, " \""); | |
| int col = 0; | |
| int len = 0; | |
| for (i = 0; i < strings.size(); ++i) { | |
| QByteArray s = strings.at(i); | |
| len = s.length(); | |
| if (col && col + len >= 72) { | |
| fprintf(out, "\"\n \""); | |
| col = 0; | |
| } else if (len && s.at(0) >= '0' && s.at(0) <= '9') { | |
| fprintf(out, "\"\""); | |
| len += 2; | |
| } | |
| int idx = 0; | |
| while (idx < s.length()) { | |
| if (idx > 0) { | |
| col = 0; | |
| fprintf(out, "\"\n \""); | |
| } | |
| int spanLen = qMin(70, s.length() - idx); | |
| // don't cut escape sequences at the end of a line | |
| int backSlashPos = s.lastIndexOf('\\', idx + spanLen - 1); | |
| if (backSlashPos >= idx) { | |
| int escapeLen = lengthOfEscapeSequence(s, backSlashPos); | |
| spanLen = qBound(spanLen, backSlashPos + escapeLen - idx, s.length() - idx); | |
| } | |
| fwrite(s.constData() + idx, 1, spanLen, out); | |
| idx += spanLen; | |
| col += spanLen; | |
| } | |
| fputs("\\0", out); | |
| col += len + 2; | |
| } | |
| fprintf(out, "\"\n};\n\n"); | |
| // | |
| // Generate internal qt_static_metacall() function | |
| // | |
| if (isConstructible) | |
| generateStaticMetacall(qualifiedClassNameIdentifier); | |
| // | |
| // Build extra array | |
| // | |
| QList<QByteArray> extraList; | |
| for (int i = 0; i < cdef->propertyList.count(); ++i) { | |
| const PropertyDef &p = cdef->propertyList.at(i); | |
| if (!isVariantType(p.type) && !metaTypes.contains(p.type) && !p.type.contains('*') && | |
| !p.type.contains('<') && !p.type.contains('>')) { | |
| int s = p.type.lastIndexOf("::"); | |
| if (s > 0) { | |
| QByteArray scope = p.type.left(s); | |
| if (scope != "Qt" && scope != cdef->classname && !extraList.contains(scope)) | |
| extraList += scope; | |
| } | |
| } | |
| } | |
| if (!extraList.isEmpty()) { | |
| fprintf(out, "#ifdef Q_NO_DATA_RELOCATION\n"); | |
| fprintf(out, "static const QMetaObjectAccessor qt_meta_extradata_%s[] = {\n ", qualifiedClassNameIdentifier.constData()); | |
| for (int i = 0; i < extraList.count(); ++i) { | |
| fprintf(out, " %s::getStaticMetaObject,\n", extraList.at(i).constData()); | |
| } | |
| fprintf(out, "#else\n"); | |
| fprintf(out, "static const QMetaObject *qt_meta_extradata_%s[] = {\n ", qualifiedClassNameIdentifier.constData()); | |
| for (int i = 0; i < extraList.count(); ++i) { | |
| fprintf(out, " &%s::staticMetaObject,\n", extraList.at(i).constData()); | |
| } | |
| fprintf(out, "#endif //Q_NO_DATA_RELOCATION\n"); | |
| fprintf(out, " 0\n};\n\n"); | |
| } | |
| if (isConstructible || !extraList.isEmpty()) { | |
| fprintf(out, "static const QMetaObjectExtraData qt_meta_extradata2_%s = {\n ", | |
| qualifiedClassNameIdentifier.constData()); | |
| if (extraList.isEmpty()) | |
| fprintf(out, "0, "); | |
| else | |
| fprintf(out, "qt_meta_extradata_%s, ", qualifiedClassNameIdentifier.constData()); | |
| if (!isConstructible) | |
| fprintf(out, "0"); | |
| else | |
| fprintf(out, "%s_qt_static_metacall", qualifiedClassNameIdentifier.constData()); | |
| fprintf(out, " \n};\n\n"); | |
| } | |
| // | |
| // Finally create and initialize the static meta object | |
| // | |
| if (isQt) | |
| fprintf(out, "const QMetaObject QObject::staticQtMetaObject = {\n"); | |
| else | |
| fprintf(out, "const QMetaObject %s::staticMetaObject = {\n", cdef->qualified.constData()); | |
| if (isQObject) | |
| fprintf(out, " { 0, "); | |
| else if (cdef->superclassList.size()) | |
| fprintf(out, " { &%s::staticMetaObject, ", purestSuperClass.constData()); | |
| else | |
| fprintf(out, " { 0, "); | |
| fprintf(out, "qt_meta_stringdata_%s,\n qt_meta_data_%s, ", | |
| qualifiedClassNameIdentifier.constData(), qualifiedClassNameIdentifier.constData()); | |
| if (!isConstructible && extraList.isEmpty()) | |
| fprintf(out, "0 }\n"); | |
| else | |
| fprintf(out, "&qt_meta_extradata2_%s }\n", qualifiedClassNameIdentifier.constData()); | |
| fprintf(out, "};\n"); | |
| if(isQt) | |
| return; | |
| // | |
| // Generate static meta object accessor (needed for symbian, because DLLs do not support data imports. | |
| // | |
| fprintf(out, "\n#ifdef Q_NO_DATA_RELOCATION\n"); | |
| fprintf(out, "const QMetaObject &%s::getStaticMetaObject() { return staticMetaObject; }\n", cdef->qualified.constData()); | |
| fprintf(out, "#endif //Q_NO_DATA_RELOCATION\n"); | |
| if (!cdef->hasQObject) | |
| return; | |
| fprintf(out, "\nconst QMetaObject *%s::metaObject() const\n{\n return QObject::d_ptr->metaObject ? QObject::d_ptr->metaObject : &staticMetaObject;\n}\n", | |
| cdef->qualified.constData()); | |
| // | |
| // Generate smart cast function | |
| // | |
| fprintf(out, "\nvoid *%s::qt_metacast(const char *_clname)\n{\n", cdef->qualified.constData()); | |
| fprintf(out, " if (!_clname) return 0;\n"); | |
| fprintf(out, " if (!strcmp(_clname, qt_meta_stringdata_%s))\n" | |
| " return static_cast<void*>(const_cast< %s*>(this));\n", | |
| qualifiedClassNameIdentifier.constData(), cdef->classname.constData()); | |
| for (int i = 1; i < cdef->superclassList.size(); ++i) { // for all superclasses but the first one | |
| if (cdef->superclassList.at(i).second == FunctionDef::Private) | |
| continue; | |
| const char *cname = cdef->superclassList.at(i).first; | |
| fprintf(out, " if (!strcmp(_clname, \"%s\"))\n return static_cast< %s*>(const_cast< %s*>(this));\n", | |
| cname, cname, cdef->classname.constData()); | |
| } | |
| for (int i = 0; i < cdef->interfaceList.size(); ++i) { | |
| const QList<ClassDef::Interface> &iface = cdef->interfaceList.at(i); | |
| for (int j = 0; j < iface.size(); ++j) { | |
| fprintf(out, " if (!strcmp(_clname, %s))\n return ", iface.at(j).interfaceId.constData()); | |
| for (int k = j; k >= 0; --k) | |
| fprintf(out, "static_cast< %s*>(", iface.at(k).className.constData()); | |
| fprintf(out, "const_cast< %s*>(this)%s;\n", | |
| cdef->classname.constData(), QByteArray(j+1, ')').constData()); | |
| } | |
| } | |
| if (!purestSuperClass.isEmpty() && !isQObject) { | |
| QByteArray superClass = purestSuperClass; | |
| // workaround for VC6 | |
| if (superClass.contains("::")) { | |
| fprintf(out, " typedef %s QMocSuperClass;\n", superClass.constData()); | |
| superClass = "QMocSuperClass"; | |
| } | |
| fprintf(out, " return %s::qt_metacast(_clname);\n", superClass.constData()); | |
| } else { | |
| fprintf(out, " return 0;\n"); | |
| } | |
| fprintf(out, "}\n"); | |
| // | |
| // Generate internal qt_metacall() function | |
| // | |
| generateMetacall(); | |
| // | |
| // Generate internal signal functions | |
| // | |
| for (int signalindex = 0; signalindex < cdef->signalList.size(); ++signalindex) | |
| generateSignal(&cdef->signalList[signalindex], signalindex); | |
| } | |
| void Generator::generateClassInfos() | |
| { | |
| if (cdef->classInfoList.isEmpty()) | |
| return; | |
| fprintf(out, "\n // classinfo: key, value\n"); | |
| for (int i = 0; i < cdef->classInfoList.size(); ++i) { | |
| const ClassInfoDef &c = cdef->classInfoList.at(i); | |
| fprintf(out, " %4d, %4d,\n", strreg(c.name), strreg(c.value)); | |
| } | |
| } | |
| void Generator::generateFunctions(QList<FunctionDef>& list, const char *functype, int type) | |
| { | |
| if (list.isEmpty()) | |
| return; | |
| fprintf(out, "\n // %ss: signature, parameters, type, tag, flags\n", functype); | |
| for (int i = 0; i < list.count(); ++i) { | |
| const FunctionDef &f = list.at(i); | |
| QByteArray sig = f.name + '('; | |
| QByteArray arguments; | |
| for (int j = 0; j < f.arguments.count(); ++j) { | |
| const ArgumentDef &a = f.arguments.at(j); | |
| if (j) { | |
| sig += ","; | |
| arguments += ","; | |
| } | |
| sig += a.normalizedType; | |
| arguments += a.name; | |
| } | |
| sig += ')'; | |
| unsigned char flags = type; | |
| if (f.access == FunctionDef::Private) | |
| flags |= AccessPrivate; | |
| else if (f.access == FunctionDef::Public) | |
| flags |= AccessPublic; | |
| else if (f.access == FunctionDef::Protected) | |
| flags |= AccessProtected; | |
| if (f.access == FunctionDef::Private) | |
| flags |= AccessPrivate; | |
| else if (f.access == FunctionDef::Public) | |
| flags |= AccessPublic; | |
| else if (f.access == FunctionDef::Protected) | |
| flags |= AccessProtected; | |
| if (f.isCompat) | |
| flags |= MethodCompatibility; | |
| if (f.wasCloned) | |
| flags |= MethodCloned; | |
| if (f.isScriptable) | |
| flags |= MethodScriptable; | |
| if (f.revision > 0) | |
| flags |= MethodRevisioned; | |
| fprintf(out, " %4d, %4d, %4d, %4d, 0x%02x,\n", strreg(sig), | |
| strreg(arguments), strreg(f.normalizedType), strreg(f.tag), flags); | |
| } | |
| } | |
| void Generator::generateFunctionRevisions(QList<FunctionDef>& list, const char *functype) | |
| { | |
| if (list.count()) | |
| fprintf(out, "\n // %ss: revision\n", functype); | |
| for (int i = 0; i < list.count(); ++i) { | |
| const FunctionDef &f = list.at(i); | |
| fprintf(out, " %4d,\n", f.revision); | |
| } | |
| } | |
| void Generator::generateProperties() | |
| { | |
| // | |
| // Create meta data | |
| // | |
| if (cdef->propertyList.count()) | |
| fprintf(out, "\n // properties: name, type, flags\n"); | |
| for (int i = 0; i < cdef->propertyList.count(); ++i) { | |
| const PropertyDef &p = cdef->propertyList.at(i); | |
| uint flags = Invalid; | |
| if (!isVariantType(p.type)) { | |
| flags |= EnumOrFlag; | |
| } else if (!isQRealType(p.type)) { | |
| flags |= qvariant_nameToType(p.type) << 24; | |
| } | |
| if (!p.read.isEmpty()) | |
| flags |= Readable; | |
| if (!p.write.isEmpty()) { | |
| flags |= Writable; | |
| if (p.stdCppSet()) | |
| flags |= StdCppSet; | |
| } | |
| if (!p.reset.isEmpty()) | |
| flags |= Resettable; | |
| // if (p.override) | |
| // flags |= Override; | |
| if (p.designable.isEmpty()) | |
| flags |= ResolveDesignable; | |
| else if (p.designable != "false") | |
| flags |= Designable; | |
| if (p.scriptable.isEmpty()) | |
| flags |= ResolveScriptable; | |
| else if (p.scriptable != "false") | |
| flags |= Scriptable; | |
| if (p.stored.isEmpty()) | |
| flags |= ResolveStored; | |
| else if (p.stored != "false") | |
| flags |= Stored; | |
| if (p.editable.isEmpty()) | |
| flags |= ResolveEditable; | |
| else if (p.editable != "false") | |
| flags |= Editable; | |
| if (p.user.isEmpty()) | |
| flags |= ResolveUser; | |
| else if (p.user != "false") | |
| flags |= User; | |
| if (p.notifyId != -1) | |
| flags |= Notify; | |
| if (p.revision > 0) | |
| flags |= Revisioned; | |
| if (p.constant) | |
| flags |= Constant; | |
| if (p.final) | |
| flags |= Final; | |
| fprintf(out, " %4d, %4d, ", | |
| strreg(p.name), | |
| strreg(p.type)); | |
| if (!(flags >> 24) && isQRealType(p.type)) | |
| fprintf(out, "(QMetaType::QReal << 24) | "); | |
| fprintf(out, "0x%.8x,\n", flags); | |
| } | |
| if(cdef->notifyableProperties) { | |
| fprintf(out, "\n // properties: notify_signal_id\n"); | |
| for (int i = 0; i < cdef->propertyList.count(); ++i) { | |
| const PropertyDef &p = cdef->propertyList.at(i); | |
| if(p.notifyId == -1) | |
| fprintf(out, " %4d,\n", | |
| 0); | |
| else | |
| fprintf(out, " %4d,\n", | |
| p.notifyId); | |
| } | |
| } | |
| if (cdef->revisionedProperties) { | |
| fprintf(out, "\n // properties: revision\n"); | |
| for (int i = 0; i < cdef->propertyList.count(); ++i) { | |
| const PropertyDef &p = cdef->propertyList.at(i); | |
| fprintf(out, " %4d,\n", p.revision); | |
| } | |
| } | |
| } | |
| void Generator::generateEnums(int index) | |
| { | |
| if (cdef->enumDeclarations.isEmpty()) | |
| return; | |
| fprintf(out, "\n // enums: name, flags, count, data\n"); | |
| index += 4 * cdef->enumList.count(); | |
| int i; | |
| for (i = 0; i < cdef->enumList.count(); ++i) { | |
| const EnumDef &e = cdef->enumList.at(i); | |
| fprintf(out, " %4d, 0x%.1x, %4d, %4d,\n", | |
| strreg(e.name), | |
| cdef->enumDeclarations.value(e.name) ? 1 : 0, | |
| e.values.count(), | |
| index); | |
| index += e.values.count() * 2; | |
| } | |
| fprintf(out, "\n // enum data: key, value\n"); | |
| for (i = 0; i < cdef->enumList.count(); ++i) { | |
| const EnumDef &e = cdef->enumList.at(i); | |
| for (int j = 0; j < e.values.count(); ++j) { | |
| const QByteArray &val = e.values.at(j); | |
| fprintf(out, " %4d, uint(%s::%s),\n", | |
| strreg(val), | |
| cdef->qualified.constData(), | |
| val.constData()); | |
| } | |
| } | |
| } | |
| void Generator::generateMetacall() | |
| { | |
| bool isQObject = (cdef->classname == "QObject"); | |
| fprintf(out, "\nint %s::qt_metacall(QMetaObject::Call _c, int _id, void **_a)\n{\n", | |
| cdef->qualified.constData()); | |
| if (!purestSuperClass.isEmpty() && !isQObject) { | |
| QByteArray superClass = purestSuperClass; | |
| // workaround for VC6 | |
| if (superClass.contains("::")) { | |
| fprintf(out, " typedef %s QMocSuperClass;\n", superClass.constData()); | |
| superClass = "QMocSuperClass"; | |
| } | |
| fprintf(out, " _id = %s::qt_metacall(_c, _id, _a);\n", superClass.constData()); | |
| } | |
| fprintf(out, " if (_id < 0)\n return _id;\n"); | |
| fprintf(out, " "); | |
| bool needElse = false; | |
| QList<FunctionDef> methodList; | |
| methodList += cdef->signalList; | |
| methodList += cdef->slotList; | |
| methodList += cdef->methodList; | |
| if (methodList.size()) { | |
| needElse = true; | |
| fprintf(out, "if (_c == QMetaObject::InvokeMetaMethod) {\n "); | |
| fprintf(out, "switch (_id) {\n"); | |
| for (int methodindex = 0; methodindex < methodList.size(); ++methodindex) { | |
| const FunctionDef &f = methodList.at(methodindex); | |
| fprintf(out, " case %d: ", methodindex); | |
| if (f.normalizedType.size()) | |
| fprintf(out, "{ %s _r = ", noRef(f.normalizedType).constData()); | |
| if (f.inPrivateClass.size()) | |
| fprintf(out, "%s->", f.inPrivateClass.constData()); | |
| fprintf(out, "%s(", f.name.constData()); | |
| int offset = 1; | |
| for (int j = 0; j < f.arguments.count(); ++j) { | |
| const ArgumentDef &a = f.arguments.at(j); | |
| if (j) | |
| fprintf(out, ","); | |
| fprintf(out, "(*reinterpret_cast< %s>(_a[%d]))",a.typeNameForCast.constData(), offset++); | |
| } | |
| fprintf(out, ");"); | |
| if (f.normalizedType.size()) | |
| fprintf(out, "\n if (_a[0]) *reinterpret_cast< %s*>(_a[0]) = _r; } ", | |
| noRef(f.normalizedType).constData()); | |
| fprintf(out, " break;\n"); | |
| } | |
| fprintf(out, " default: ;\n"); | |
| fprintf(out, " }\n"); | |
| } | |
| if (methodList.size()) | |
| fprintf(out, " _id -= %d;\n }", methodList.size()); | |
| if (cdef->propertyList.size()) { | |
| bool needGet = false; | |
| bool needTempVarForGet = false; | |
| bool needSet = false; | |
| bool needReset = false; | |
| bool needDesignable = false; | |
| bool needScriptable = false; | |
| bool needStored = false; | |
| bool needEditable = false; | |
| bool needUser = false; | |
| for (int i = 0; i < cdef->propertyList.size(); ++i) { | |
| const PropertyDef &p = cdef->propertyList.at(i); | |
| needGet |= !p.read.isEmpty(); | |
| if (!p.read.isEmpty()) | |
| needTempVarForGet |= (p.gspec != PropertyDef::PointerSpec | |
| && p.gspec != PropertyDef::ReferenceSpec); | |
| needSet |= !p.write.isEmpty(); | |
| needReset |= !p.reset.isEmpty(); | |
| needDesignable |= p.designable.endsWith(')'); | |
| needScriptable |= p.scriptable.endsWith(')'); | |
| needStored |= p.stored.endsWith(')'); | |
| needEditable |= p.editable.endsWith(')'); | |
| needUser |= p.user.endsWith(')'); | |
| } | |
| fprintf(out, "\n#ifndef QT_NO_PROPERTIES\n "); | |
| if (needElse) | |
| fprintf(out, " else "); | |
| fprintf(out, "if (_c == QMetaObject::ReadProperty) {\n"); | |
| if (needGet) { | |
| if (needTempVarForGet) | |
| fprintf(out, " void *_v = _a[0];\n"); | |
| fprintf(out, " switch (_id) {\n"); | |
| for (int propindex = 0; propindex < cdef->propertyList.size(); ++propindex) { | |
| const PropertyDef &p = cdef->propertyList.at(propindex); | |
| if (p.read.isEmpty()) | |
| continue; | |
| QByteArray prefix; | |
| if (p.inPrivateClass.size()) { | |
| prefix = p.inPrivateClass; | |
| prefix.append("->"); | |
| } | |
| if (p.gspec == PropertyDef::PointerSpec) | |
| fprintf(out, " case %d: _a[0] = const_cast<void*>(reinterpret_cast<const void*>(%s%s())); break;\n", | |
| propindex, prefix.constData(), p.read.constData()); | |
| else if (p.gspec == PropertyDef::ReferenceSpec) | |
| fprintf(out, " case %d: _a[0] = const_cast<void*>(reinterpret_cast<const void*>(&%s%s())); break;\n", | |
| propindex, prefix.constData(), p.read.constData()); | |
| else if (cdef->enumDeclarations.value(p.type, false)) | |
| fprintf(out, " case %d: *reinterpret_cast<int*>(_v) = QFlag(%s%s()); break;\n", | |
| propindex, prefix.constData(), p.read.constData()); | |
| else | |
| fprintf(out, " case %d: *reinterpret_cast< %s*>(_v) = %s%s(); break;\n", | |
| propindex, p.type.constData(), prefix.constData(), p.read.constData()); | |
| } | |
| fprintf(out, " }\n"); | |
| } | |
| fprintf(out, | |
| " _id -= %d;\n" | |
| " }", cdef->propertyList.count()); | |
| fprintf(out, " else "); | |
| fprintf(out, "if (_c == QMetaObject::WriteProperty) {\n"); | |
| if (needSet) { | |
| fprintf(out, " void *_v = _a[0];\n"); | |
| fprintf(out, " switch (_id) {\n"); | |
| for (int propindex = 0; propindex < cdef->propertyList.size(); ++propindex) { | |
| const PropertyDef &p = cdef->propertyList.at(propindex); | |
| if (p.write.isEmpty()) | |
| continue; | |
| QByteArray prefix; | |
| if (p.inPrivateClass.size()) { | |
| prefix = p.inPrivateClass; | |
| prefix.append("->"); | |
| } | |
| if (cdef->enumDeclarations.value(p.type, false)) { | |
| fprintf(out, " case %d: %s%s(QFlag(*reinterpret_cast<int*>(_v))); break;\n", | |
| propindex, prefix.constData(), p.write.constData()); | |
| } else { | |
| fprintf(out, " case %d: %s%s(*reinterpret_cast< %s*>(_v)); break;\n", | |
| propindex, prefix.constData(), p.write.constData(), p.type.constData()); | |
| } | |
| } | |
| fprintf(out, " }\n"); | |
| } | |
| fprintf(out, | |
| " _id -= %d;\n" | |
| " }", cdef->propertyList.count()); | |
| fprintf(out, " else "); | |
| fprintf(out, "if (_c == QMetaObject::ResetProperty) {\n"); | |
| if (needReset) { | |
| fprintf(out, " switch (_id) {\n"); | |
| for (int propindex = 0; propindex < cdef->propertyList.size(); ++propindex) { | |
| const PropertyDef &p = cdef->propertyList.at(propindex); | |
| if (!p.reset.endsWith(')')) | |
| continue; | |
| QByteArray prefix; | |
| if (p.inPrivateClass.size()) { | |
| prefix = p.inPrivateClass; | |
| prefix.append("->"); | |
| } | |
| fprintf(out, " case %d: %s%s; break;\n", | |
| propindex, prefix.constData(), p.reset.constData()); | |
| } | |
| fprintf(out, " }\n"); | |
| } | |
| fprintf(out, | |
| " _id -= %d;\n" | |
| " }", cdef->propertyList.count()); | |
| fprintf(out, " else "); | |
| fprintf(out, "if (_c == QMetaObject::QueryPropertyDesignable) {\n"); | |
| if (needDesignable) { | |
| fprintf(out, " bool *_b = reinterpret_cast<bool*>(_a[0]);\n"); | |
| fprintf(out, " switch (_id) {\n"); | |
| for (int propindex = 0; propindex < cdef->propertyList.size(); ++propindex) { | |
| const PropertyDef &p = cdef->propertyList.at(propindex); | |
| if (!p.designable.endsWith(')')) | |
| continue; | |
| fprintf(out, " case %d: *_b = %s; break;\n", | |
| propindex, p.designable.constData()); | |
| } | |
| fprintf(out, " }\n"); | |
| } | |
| fprintf(out, | |
| " _id -= %d;\n" | |
| " }", cdef->propertyList.count()); | |
| fprintf(out, " else "); | |
| fprintf(out, "if (_c == QMetaObject::QueryPropertyScriptable) {\n"); | |
| if (needScriptable) { | |
| fprintf(out, " bool *_b = reinterpret_cast<bool*>(_a[0]);\n"); | |
| fprintf(out, " switch (_id) {\n"); | |
| for (int propindex = 0; propindex < cdef->propertyList.size(); ++propindex) { | |
| const PropertyDef &p = cdef->propertyList.at(propindex); | |
| if (!p.scriptable.endsWith(')')) | |
| continue; | |
| fprintf(out, " case %d: *_b = %s; break;\n", | |
| propindex, p.scriptable.constData()); | |
| } | |
| fprintf(out, " }\n"); | |
| } | |
| fprintf(out, | |
| " _id -= %d;\n" | |
| " }", cdef->propertyList.count()); | |
| fprintf(out, " else "); | |
| fprintf(out, "if (_c == QMetaObject::QueryPropertyStored) {\n"); | |
| if (needStored) { | |
| fprintf(out, " bool *_b = reinterpret_cast<bool*>(_a[0]);\n"); | |
| fprintf(out, " switch (_id) {\n"); | |
| for (int propindex = 0; propindex < cdef->propertyList.size(); ++propindex) { | |
| const PropertyDef &p = cdef->propertyList.at(propindex); | |
| if (!p.stored.endsWith(')')) | |
| continue; | |
| fprintf(out, " case %d: *_b = %s; break;\n", | |
| propindex, p.stored.constData()); | |
| } | |
| fprintf(out, " }\n"); | |
| } | |
| fprintf(out, | |
| " _id -= %d;\n" | |
| " }", cdef->propertyList.count()); | |
| fprintf(out, " else "); | |
| fprintf(out, "if (_c == QMetaObject::QueryPropertyEditable) {\n"); | |
| if (needEditable) { | |
| fprintf(out, " bool *_b = reinterpret_cast<bool*>(_a[0]);\n"); | |
| fprintf(out, " switch (_id) {\n"); | |
| for (int propindex = 0; propindex < cdef->propertyList.size(); ++propindex) { | |
| const PropertyDef &p = cdef->propertyList.at(propindex); | |
| if (!p.editable.endsWith(')')) | |
| continue; | |
| fprintf(out, " case %d: *_b = %s; break;\n", | |
| propindex, p.editable.constData()); | |
| } | |
| fprintf(out, " }\n"); | |
| } | |
| fprintf(out, | |
| " _id -= %d;\n" | |
| " }", cdef->propertyList.count()); | |
| fprintf(out, " else "); | |
| fprintf(out, "if (_c == QMetaObject::QueryPropertyUser) {\n"); | |
| if (needUser) { | |
| fprintf(out, " bool *_b = reinterpret_cast<bool*>(_a[0]);\n"); | |
| fprintf(out, " switch (_id) {\n"); | |
| for (int propindex = 0; propindex < cdef->propertyList.size(); ++propindex) { | |
| const PropertyDef &p = cdef->propertyList.at(propindex); | |
| if (!p.user.endsWith(')')) | |
| continue; | |
| fprintf(out, " case %d: *_b = %s; break;\n", | |
| propindex, p.user.constData()); | |
| } | |
| fprintf(out, " }\n"); | |
| } | |
| fprintf(out, | |
| " _id -= %d;\n" | |
| " }", cdef->propertyList.count()); | |
| fprintf(out, "\n#endif // QT_NO_PROPERTIES"); | |
| } | |
| if (methodList.size() || cdef->signalList.size() || cdef->propertyList.size()) | |
| fprintf(out, "\n "); | |
| fprintf(out,"return _id;\n}\n"); | |
| } | |
| void Generator::generateStaticMetacall(const QByteArray &prefix) | |
| { | |
| bool isQObject = (cdef->classname == "QObject"); | |
| fprintf(out, "static int %s_qt_static_metacall(QMetaObject::Call _c, int _id, void **_a)\n{\n", | |
| prefix.constData()); | |
| fprintf(out, " if (_c == QMetaObject::CreateInstance) {\n"); | |
| fprintf(out, " switch (_id) {\n"); | |
| for (int ctorindex = 0; ctorindex < cdef->constructorList.count(); ++ctorindex) { | |
| fprintf(out, " case %d: { %s *_r = new %s(", ctorindex, | |
| cdef->qualified.constData(), cdef->qualified.constData()); | |
| const FunctionDef &f = cdef->constructorList.at(ctorindex); | |
| int offset = 1; | |
| for (int j = 0; j < f.arguments.count(); ++j) { | |
| const ArgumentDef &a = f.arguments.at(j); | |
| if (j) | |
| fprintf(out, ","); | |
| fprintf(out, "(*reinterpret_cast< %s>(_a[%d]))", a.typeNameForCast.constData(), offset++); | |
| } | |
| fprintf(out, ");\n"); | |
| fprintf(out, " if (_a[0]) *reinterpret_cast<QObject**>(_a[0]) = _r; } break;\n"); | |
| } | |
| fprintf(out, " }\n"); | |
| fprintf(out, " _id -= %d;\n", cdef->constructorList.count()); | |
| fprintf(out, " return _id;\n"); | |
| fprintf(out, " }\n"); | |
| if (!isQObject) | |
| fprintf(out, " _id = %s::staticMetaObject.superClass()->static_metacall(_c, _id, _a);\n", cdef->qualified.constData()); | |
| fprintf(out, " if (_id < 0)\n return _id;\n"); | |
| fprintf(out, " return _id;\n"); | |
| fprintf(out, "}\n\n"); | |
| } | |
| void Generator::generateSignal(FunctionDef *def,int index) | |
| { | |
| if (def->wasCloned || def->isAbstract) | |
| return; | |
| fprintf(out, "\n// SIGNAL %d\n%s %s::%s(", | |
| index, def->type.name.constData(), cdef->qualified.constData(), def->name.constData()); | |
| QByteArray thisPtr = "this"; | |
| const char *constQualifier = ""; | |
| if (def->isConst) { | |
| thisPtr = "const_cast< "; | |
| thisPtr += cdef->qualified; | |
| thisPtr += " *>(this)"; | |
| constQualifier = "const"; | |
| } | |
| if (def->arguments.isEmpty() && def->normalizedType.isEmpty()) { | |
| fprintf(out, ")%s\n{\n" | |
| " QMetaObject::activate(%s, &staticMetaObject, %d, 0);\n" | |
| "}\n", constQualifier, thisPtr.constData(), index); | |
| return; | |
| } | |
| int offset = 1; | |
| for (int j = 0; j < def->arguments.count(); ++j) { | |
| const ArgumentDef &a = def->arguments.at(j); | |
| if (j) | |
| fprintf(out, ", "); | |
| fprintf(out, "%s _t%d%s", a.type.name.constData(), offset++, a.rightType.constData()); | |
| } | |
| fprintf(out, ")%s\n{\n", constQualifier); | |
| if (def->type.name.size() && def->normalizedType.size()) | |
| fprintf(out, " %s _t0;\n", noRef(def->normalizedType).constData()); | |
| fprintf(out, " void *_a[] = { "); | |
| if (def->normalizedType.isEmpty()) { | |
| fprintf(out, "0"); | |
| } else { | |
| if (def->returnTypeIsVolatile) | |
| fprintf(out, "const_cast<void*>(reinterpret_cast<const volatile void*>(&_t0))"); | |
| else | |
| fprintf(out, "const_cast<void*>(reinterpret_cast<const void*>(&_t0))"); | |
| } | |
| int i; | |
| for (i = 1; i < offset; ++i) | |
| if (def->arguments.at(i - 1).type.isVolatile) | |
| fprintf(out, ", const_cast<void*>(reinterpret_cast<const volatile void*>(&_t%d))", i); | |
| else | |
| fprintf(out, ", const_cast<void*>(reinterpret_cast<const void*>(&_t%d))", i); | |
| fprintf(out, " };\n"); | |
| fprintf(out, " QMetaObject::activate(%s, &staticMetaObject, %d, _a);\n", thisPtr.constData(), index); | |
| if (def->normalizedType.size()) | |
| fprintf(out, " return _t0;\n"); | |
| fprintf(out, "}\n"); | |
| } | |
| // | |
| // Functions used when generating QMetaObject directly | |
| // | |
| // Much of this code is copied from the corresponding | |
| // C++ code-generating functions; we can change the | |
| // two generators so that more of the code is shared. | |
| // The key difference from the C++ code generator is | |
| // that instead of calling fprintf(), we append bytes | |
| // to a buffer. | |
| // | |
| QMetaObject *Generator::generateMetaObject(bool ignoreProperties) | |
| { | |
| // | |
| // build the data array | |
| // | |
| // filter out undeclared enumerators and sets | |
| { | |
| QList<EnumDef> enumList; | |
| for (int i = 0; i < cdef->enumList.count(); ++i) { | |
| EnumDef def = cdef->enumList.at(i); | |
| if (cdef->enumDeclarations.contains(def.name)) { | |
| enumList += def; | |
| } | |
| QByteArray alias = cdef->flagAliases.value(def.name); | |
| if (cdef->enumDeclarations.contains(alias)) { | |
| def.name = alias; | |
| enumList += def; | |
| } | |
| } | |
| cdef->enumList = enumList; | |
| } | |
| int index = 10; | |
| meta_data | |
| << 1 // revision | |
| << strreg(cdef->qualified) // classname | |
| << cdef->classInfoList.count() << (cdef->classInfoList.count() ? index : 0) // classinfo | |
| ; | |
| index += cdef->classInfoList.count() * 2; | |
| int methodCount = cdef->signalList.count() + cdef->slotList.count() + cdef->methodList.count(); | |
| meta_data << methodCount << (methodCount ? index : 0); // methods | |
| index += methodCount * 5; | |
| if (!ignoreProperties) { | |
| meta_data << cdef->propertyList.count() << (cdef->propertyList.count() ? index : 0); // properties | |
| index += cdef->propertyList.count() * 3; | |
| } else { | |
| meta_data << 0 << 0; // properties | |
| } | |
| meta_data << cdef->enumList.count() << (cdef->enumList.count() ? index : 0); // enums/sets | |
| // | |
| // Build classinfo array | |
| // | |
| _generateClassInfos(); | |
| // | |
| // Build signals array first, otherwise the signal indices would be wrong | |
| // | |
| _generateFunctions(cdef->signalList, MethodSignal); | |
| // | |
| // Build slots array | |
| // | |
| _generateFunctions(cdef->slotList, MethodSlot); | |
| // | |
| // Build method array | |
| // | |
| _generateFunctions(cdef->methodList, MethodMethod); | |
| // | |
| // Build property array | |
| // | |
| if (!ignoreProperties) | |
| _generateProperties(); | |
| // | |
| // Build enums array | |
| // | |
| _generateEnums(index); | |
| // | |
| // Terminate data array | |
| // | |
| meta_data << 0; | |
| // | |
| // Build stringdata array | |
| // | |
| QVector<char> string_data; | |
| for (int i = 0; i < strings.size(); ++i) { | |
| const char *s = strings.at(i).constData(); | |
| char c; | |
| do { | |
| c = *(s++); | |
| string_data << c; | |
| } while (c != '\0'); | |
| } | |
| // | |
| // Finally create and initialize the static meta object | |
| // | |
| const int meta_object_offset = 0; | |
| const int meta_object_size = sizeof(QMetaObject); | |
| const int meta_data_offset = meta_object_offset + meta_object_size; | |
| const int meta_data_size = meta_data.count() * sizeof(uint); | |
| const int string_data_offset = meta_data_offset + meta_data_size; | |
| const int string_data_size = string_data.count(); | |
| const int total_size = string_data_offset + string_data_size; | |
| char *blob = new char[total_size]; | |
| char *string_data_output = blob + string_data_offset; | |
| const char *string_data_src = string_data.constData(); | |
| for (int i = 0; i < string_data.count(); ++i) | |
| string_data_output[i] = string_data_src[i]; | |
| uint *meta_data_output = reinterpret_cast<uint *>(blob + meta_data_offset); | |
| const uint *meta_data_src = meta_data.constData(); | |
| for (int i = 0; i < meta_data.count(); ++i) | |
| meta_data_output[i] = meta_data_src[i]; | |
| QMetaObject *meta_object = new (blob + meta_object_offset)QMetaObject; | |
| meta_object->d.superdata = 0; | |
| meta_object->d.stringdata = string_data_output; | |
| meta_object->d.data = meta_data_output; | |
| meta_object->d.extradata = 0; | |
| return meta_object; | |
| } | |
| void Generator::_generateClassInfos() | |
| { | |
| for (int i = 0; i < cdef->classInfoList.size(); ++i) { | |
| const ClassInfoDef &c = cdef->classInfoList.at(i); | |
| meta_data << strreg(c.name) << strreg(c.value); | |
| } | |
| } | |
| void Generator::_generateFunctions(QList<FunctionDef> &list, int type) | |
| { | |
| for (int i = 0; i < list.count(); ++i) { | |
| const FunctionDef &f = list.at(i); | |
| QByteArray sig = f.name + '('; | |
| QByteArray arguments; | |
| for (int j = 0; j < f.arguments.count(); ++j) { | |
| const ArgumentDef &a = f.arguments.at(j); | |
| if (j) { | |
| sig += ','; | |
| arguments += ','; | |
| } | |
| sig += a.normalizedType; | |
| arguments += a.name; | |
| } | |
| sig += ')'; | |
| char flags = type; | |
| if (f.access == FunctionDef::Private) | |
| flags |= AccessPrivate; | |
| else if (f.access == FunctionDef::Public) | |
| flags |= AccessPublic; | |
| else if (f.access == FunctionDef::Protected) | |
| flags |= AccessProtected; | |
| if (f.access == FunctionDef::Private) | |
| flags |= AccessPrivate; | |
| else if (f.access == FunctionDef::Public) | |
| flags |= AccessPublic; | |
| else if (f.access == FunctionDef::Protected) | |
| flags |= AccessProtected; | |
| if (f.isCompat) | |
| flags |= MethodCompatibility; | |
| if (f.wasCloned) | |
| flags |= MethodCloned; | |
| if (f.isScriptable) | |
| flags |= MethodScriptable; | |
| meta_data << strreg(sig) | |
| << strreg(arguments) | |
| << strreg(f.normalizedType) | |
| << strreg(f.tag) | |
| << flags; | |
| } | |
| } | |
| void Generator::_generateEnums(int index) | |
| { | |
| index += 4 * cdef->enumList.count(); | |
| int i; | |
| for (i = 0; i < cdef->enumList.count(); ++i) { | |
| const EnumDef &e = cdef->enumList.at(i); | |
| meta_data << strreg(e.name) << (cdef->enumDeclarations.value(e.name) ? 1 : 0) | |
| << e.values.count() << index; | |
| index += e.values.count() * 2; | |
| } | |
| for (i = 0; i < cdef->enumList.count(); ++i) { | |
| const EnumDef &e = cdef->enumList.at(i); | |
| for (int j = 0; j < e.values.count(); ++j) { | |
| const QByteArray &val = e.values.at(j); | |
| meta_data << strreg(val) << 0; // we don't know the value itself | |
| } | |
| } | |
| } | |
| void Generator::_generateProperties() | |
| { | |
| // | |
| // specify get function, for compatibiliy we accept functions | |
| // returning pointers, or const char * for QByteArray. | |
| // | |
| for (int i = 0; i < cdef->propertyList.count(); ++i) { | |
| PropertyDef &p = cdef->propertyList[i]; | |
| if (p.read.isEmpty()) | |
| continue; | |
| for (int j = 0; j < cdef->publicList.count(); ++j) { | |
| const FunctionDef &f = cdef->publicList.at(j); | |
| if (f.name != p.read) | |
| continue; | |
| if (!f.isConst) // get functions must be const | |
| continue; | |
| if (f.arguments.size()) // and must not take any arguments | |
| continue; | |
| PropertyDef::Specification spec = PropertyDef::ValueSpec; | |
| QByteArray tmp = f.normalizedType; | |
| if (p.type == "QByteArray" && tmp == "const char *") | |
| tmp = "QByteArray"; | |
| if (tmp.left(6) == "const ") | |
| tmp = tmp.mid(6); | |
| if (p.type != tmp && tmp.endsWith('*')) { | |
| tmp.chop(1); | |
| spec = PropertyDef::PointerSpec; | |
| } else if (f.type.name.endsWith('&')) { // raw type, not normalized type | |
| spec = PropertyDef::ReferenceSpec; | |
| } | |
| if (p.type != tmp) | |
| continue; | |
| p.gspec = spec; | |
| break; | |
| } | |
| } | |
| // | |
| // Create meta data | |
| // | |
| for (int i = 0; i < cdef->propertyList.count(); ++i) { | |
| const PropertyDef &p = cdef->propertyList.at(i); | |
| uint flags = Invalid; | |
| if (!isVariantType(p.type)) { | |
| flags |= EnumOrFlag; | |
| } else { | |
| flags |= qvariant_nameToType(p.type) << 24; | |
| } | |
| if (!p.read.isEmpty()) | |
| flags |= Readable; | |
| if (!p.write.isEmpty()) { | |
| flags |= Writable; | |
| if (p.stdCppSet()) | |
| flags |= StdCppSet; | |
| } | |
| if (!p.reset.isEmpty()) | |
| flags |= Resettable; | |
| // if (p.override) | |
| // flags |= Override; | |
| if (p.designable.isEmpty()) | |
| flags |= ResolveDesignable; | |
| else if (p.designable != "false") | |
| flags |= Designable; | |
| if (p.scriptable.isEmpty()) | |
| flags |= ResolveScriptable; | |
| else if (p.scriptable != "false") | |
| flags |= Scriptable; | |
| if (p.stored.isEmpty()) | |
| flags |= ResolveStored; | |
| else if (p.stored != "false") | |
| flags |= Stored; | |
| if (p.editable.isEmpty()) | |
| flags |= ResolveEditable; | |
| else if (p.editable != "false") | |
| flags |= Editable; | |
| if (p.user.isEmpty()) | |
| flags |= ResolveUser; | |
| else if (p.user != "false") | |
| flags |= User; | |
| meta_data << strreg(p.name) << strreg(p.type) << flags; | |
| } | |
| } | |
| QT_END_NAMESPACE |