Prospective build fix after changes in qtbase's bootstrap library

The binary json conversion code was removed from the bootstrap library,
which broke the repc build. However the part of repc that stopped
compiling was the moc generator code, which repc doesn't use. Therefore
the easiest way to fix the build is to simply remove that code from the
build and delete code that's now unused.

Change-Id: Iee763adc978f98c9bb5bf33817e4cd0cb5d76bc9
Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>

5 files changed, 0 insertions, 1803 deletions

diff --git a/tools/repc/moc_copy/generator.cpp b/tools/repc/moc_copy/generator.cpp
deleted file mode 100644
index c418492..0000000
--- a/tools/repc/moc_copy/generator.cpp
+++ /dev/null
@@ -1,1601 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Copyright (C) 2013 Olivier Goffart <ogoffart@woboq.com>
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the tools applications of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:GPL-EXCEPT$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3 as published by the Free Software
-** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include "generator.h"
-#include "outputrevision.h"
-#include "utils.h"
-#include <QtCore/qmetatype.h>
-#include <QtCore/qjsondocument.h>
-#include <QtCore/qjsonobject.h>
-#include <QtCore/qjsonvalue.h>
-#include <QtCore/qjsonarray.h>
-#include <QtCore/qplugin.h>
-#include <stdio.h>
-
-#include <private/qmetaobject_p.h> //for the flags.
-
-QT_BEGIN_NAMESPACE
-
-uint nameToBuiltinType(const QByteArray &name)
-{
-    if (name.isEmpty())
-        return 0;
-
-    uint tp = QMetaType::type(name.constData());
-    return tp < uint(QMetaType::User) ? tp : uint(QMetaType::UnknownType);
-}
-
-/*
-  Returns \c true if the type is a built-in type.
-*/
-bool isBuiltinType(const QByteArray &type)
- {
-    int id = QMetaType::type(type.constData());
-    if (id == QMetaType::UnknownType)
-        return false;
-    return (id < QMetaType::User);
-}
-
-static const char *metaTypeEnumValueString(int type)
- {
-#define RETURN_METATYPENAME_STRING(MetaTypeName, MetaTypeId, RealType) \
-    case QMetaType::MetaTypeName: return #MetaTypeName;
-
-    switch (type) {
-QT_FOR_EACH_STATIC_TYPE(RETURN_METATYPENAME_STRING)
-    }
-#undef RETURN_METATYPENAME_STRING
-    return 0;
- }
-
-Generator::Generator(ClassDef *classDef, const QList<QByteArray> &metaTypes, const QHash<QByteArray, QByteArray> &knownQObjectClasses, const QHash<QByteArray, QByteArray> &knownGadgets, FILE *outfile)
-    : out(outfile), cdef(classDef), metaTypes(metaTypes), knownQObjectClasses(knownQObjectClasses)
-    , knownGadgets(knownGadgets)
-{
-    if (cdef->superclassList.size())
-        purestSuperClass = cdef->superclassList.constFirst().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;
-}
-
-void Generator::strreg(const QByteArray &s)
-{
-    if (!strings.contains(s))
-        strings.append(s);
-}
-
-int Generator::stridx(const QByteArray &s)
-{
-    int i = strings.indexOf(s);
-    Q_ASSERT_X(i != -1, Q_FUNC_INFO, "We forgot to register some strings");
-    return i;
-}
-
-// 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'
-// parameter type/name meta-data.
-static int aggregateParameterCount(const QVector<FunctionDef> &list)
-{
-    int sum = 0;
-    for (int i = 0; i < list.count(); ++i)
-        sum += list.at(i).arguments.count() + 1; // +1 for return type
-    return sum;
-}
-
-bool Generator::registerableMetaType(const QByteArray &propertyType)
-{
-    if (metaTypes.contains(propertyType))
-        return true;
-
-    if (propertyType.endsWith('*')) {
-        QByteArray objectPointerType = propertyType;
-        // The objects container stores class names, such as 'QState', 'QLabel' etc,
-        // not 'QState*', 'QLabel*'. The propertyType does contain the '*', so we need
-        // to chop it to find the class type in the known QObjects list.
-        objectPointerType.chop(1);
-        if (knownQObjectClasses.contains(objectPointerType))
-            return true;
-    }
-
-    static const QVector<QByteArray> smartPointers = QVector<QByteArray>()
-#define STREAM_SMART_POINTER(SMART_POINTER) << #SMART_POINTER
-        QT_FOR_EACH_AUTOMATIC_TEMPLATE_SMART_POINTER(STREAM_SMART_POINTER)
-#undef STREAM_SMART_POINTER
-        ;
-
-    for (const QByteArray &smartPointer : smartPointers) {
-        if (propertyType.startsWith(smartPointer + "<") && !propertyType.endsWith("&"))
-            return knownQObjectClasses.contains(propertyType.mid(smartPointer.size() + 1, propertyType.size() - smartPointer.size() - 1 - 1));
-    }
-
-    static const QVector<QByteArray> oneArgTemplates = QVector<QByteArray>()
-#define STREAM_1ARG_TEMPLATE(TEMPLATENAME) << #TEMPLATENAME
-      QT_FOR_EACH_AUTOMATIC_TEMPLATE_1ARG(STREAM_1ARG_TEMPLATE)
-#undef STREAM_1ARG_TEMPLATE
-    ;
-    for (const QByteArray &oneArgTemplateType : oneArgTemplates) {
-        if (propertyType.startsWith(oneArgTemplateType + "<") && propertyType.endsWith(">")) {
-            const int argumentSize = propertyType.size() - oneArgTemplateType.size() - 1
-                                     // The closing '>'
-                                     - 1
-                                     // templates inside templates have an extra whitespace char to strip.
-                                     - (propertyType.at(propertyType.size() - 2) == ' ' ? 1 : 0 );
-            const QByteArray templateArg = propertyType.mid(oneArgTemplateType.size() + 1, argumentSize);
-            return isBuiltinType(templateArg) || registerableMetaType(templateArg);
-        }
-    }
-    return false;
-}
-
-/* returns \c true if name and qualifiedName refers to the same name.
- * If qualified name is "A::B::C", it returns \c true for "C", "B::C" or "A::B::C" */
-static bool qualifiedNameEquals(const QByteArray &qualifiedName, const QByteArray &name)
-{
-    if (qualifiedName == name)
-        return true;
-    int index = qualifiedName.indexOf("::");
-    if (index == -1)
-        return false;
-    return qualifiedNameEquals(qualifiedName.mid(index+2), name);
-}
-
-void Generator::generateCode()
-{
-    bool isQt = (cdef->classname == "Qt");
-    bool isQObject = (cdef->classname == "QObject");
-    bool isConstructible = !cdef->constructorList.isEmpty();
-
-    // filter out undeclared enumerators and sets
-    {
-        QVector<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;
-    }
-
-//
-// Register all strings used in data section
-//
-    strreg(cdef->qualified);
-    registerClassInfoStrings();
-    registerFunctionStrings(cdef->signalList);
-    registerFunctionStrings(cdef->slotList);
-    registerFunctionStrings(cdef->methodList);
-    registerFunctionStrings(cdef->constructorList);
-    registerPropertyStrings();
-    registerEnumStrings();
-
-    QByteArray qualifiedClassNameIdentifier = cdef->qualified;
-    qualifiedClassNameIdentifier.replace(':', '_');
-
-//
-// Build stringdata struct
-//
-    const int constCharArraySizeLimit = 65535;
-    fprintf(out, "struct qt_meta_stringdata_%s_t {\n", qualifiedClassNameIdentifier.constData());
-    fprintf(out, "    QByteArrayData data[%d];\n", strings.size());
-    {
-        int stringDataLength = 0;
-        int stringDataCounter = 0;
-        for (int i = 0; i < strings.size(); ++i) {
-            int thisLength = strings.at(i).length() + 1;
-            stringDataLength += thisLength;
-            if (stringDataLength / constCharArraySizeLimit) {
-                // save previous stringdata and start computing the next one.
-                fprintf(out, "    char stringdata%d[%d];\n", stringDataCounter++, stringDataLength - thisLength);
-                stringDataLength = thisLength;
-            }
-        }
-        fprintf(out, "    char stringdata%d[%d];\n", stringDataCounter, stringDataLength);
-
-    }
-    fprintf(out, "};\n");
-
-    // Macro that expands into a QByteArrayData. The offset member is
-    // calculated from 1) the offset of the actual characters in the
-    // stringdata.stringdata member, and 2) the stringdata.data index of the
-    // QByteArrayData being defined. This calculation relies on the
-    // QByteArrayData::data() implementation returning simply "this + offset".
-    fprintf(out, "#define QT_MOC_LITERAL(idx, ofs, len) \\\n"
-            "    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \\\n"
-            "    qptrdiff(offsetof(qt_meta_stringdata_%s_t, stringdata0) + ofs \\\n"
-            "        - idx * sizeof(QByteArrayData)) \\\n"
-            "    )\n",
-            qualifiedClassNameIdentifier.constData());
-
-    fprintf(out, "static const qt_meta_stringdata_%s_t qt_meta_stringdata_%s = {\n",
-            qualifiedClassNameIdentifier.constData(), qualifiedClassNameIdentifier.constData());
-    fprintf(out, "    {\n");
-    {
-        int idx = 0;
-        for (int i = 0; i < strings.size(); ++i) {
-            const QByteArray &str = strings.at(i);
-            fprintf(out, "QT_MOC_LITERAL(%d, %d, %d)", i, idx, str.length());
-            if (i != strings.size() - 1)
-                fputc(',', out);
-            const QByteArray comment = str.length() > 32 ? str.left(29) + "..." : str;
-            fprintf(out, " // \"%s\"\n", comment.constData());
-            idx += str.length() + 1;
-            for (int j = 0; j < str.length(); ++j) {
-                if (str.at(j) == '\\') {
-                    int cnt = lengthOfEscapeSequence(str, j) - 1;
-                    idx -= cnt;
-                    j += cnt;
-                }
-            }
-        }
-        fprintf(out, "\n    },\n");
-    }
-
-//
-// Build stringdata array
-//
-    fprintf(out, "    \"");
-    int col = 0;
-    int len = 0;
-    int stringDataLength = 0;
-    for (int i = 0; i < strings.size(); ++i) {
-        QByteArray s = strings.at(i);
-        len = s.length();
-        stringDataLength += len + 1;
-        if (stringDataLength >= constCharArraySizeLimit) {
-            fprintf(out, "\",\n    \"");
-            stringDataLength = len + 1;
-            col = 0;
-        } else if (i)
-            fputs("\\0", out); // add \0 at the end of each string
-
-        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);
-            }
-            fprintf(out, "%.*s", spanLen, s.constData() + idx);
-            idx += spanLen;
-            col += spanLen;
-        }
-        col += len + 2;
-    }
-
-// Terminate stringdata struct
-    fprintf(out, "\"\n};\n");
-    fprintf(out, "#undef QT_MOC_LITERAL\n\n");
-
-//
-// build the data array
-//
-
-    int index = MetaObjectPrivateFieldCount;
-    fprintf(out, "static const uint qt_meta_data_%s[] = {\n", qualifiedClassNameIdentifier.constData());
-    fprintf(out, "\n // content:\n");
-    fprintf(out, "    %4d,       // revision\n", int(QMetaObjectPrivate::OutputRevision));
-    fprintf(out, "    %4d,       // classname\n", stridx(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;
-    int paramsIndex = index;
-    int totalParameterCount = aggregateParameterCount(cdef->signalList)
-            + aggregateParameterCount(cdef->slotList)
-            + aggregateParameterCount(cdef->methodList)
-            + aggregateParameterCount(cdef->constructorList);
-    index += totalParameterCount * 2 // types and parameter names
-            - methodCount // return "parameters" don't have names
-            - cdef->constructorList.count(); // "this" parameters don't have names
-
-    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 (int 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);
-
-    int flags = 0;
-    if (cdef->hasQGadget) {
-        // Ideally, all the classes could have that flag. But this broke classes generated
-        // by qdbusxml2cpp which generate code that require that we call qt_metacall for properties
-        flags |= PropertyAccessInStaticMetaCall;
-    }
-    fprintf(out, "    %4d,       // flags\n", flags);
-    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, paramsIndex);
-
-//
-// Build slots array
-//
-    generateFunctions(cdef->slotList, "slot", MethodSlot, paramsIndex);
-
-//
-// Build method array
-//
-    generateFunctions(cdef->methodList, "method", MethodMethod, paramsIndex);
-
-//
-// Build method version arrays
-//
-    if (cdef->revisionedMethods) {
-        generateFunctionRevisions(cdef->signalList, "signal");
-        generateFunctionRevisions(cdef->slotList, "slot");
-        generateFunctionRevisions(cdef->methodList, "method");
-    }
-
-//
-// Build method parameters array
-//
-    generateFunctionParameters(cdef->signalList, "signal");
-    generateFunctionParameters(cdef->slotList, "slot");
-    generateFunctionParameters(cdef->methodList, "method");
-    if (isConstructible)
-        generateFunctionParameters(cdef->constructorList, "constructor");
-
-//
-// Build property array
-//
-    generateProperties();
-
-//
-// Build enums array
-//
-    generateEnums(enumsIndex);
-
-//
-// Build constructors array
-//
-    if (isConstructible)
-        generateFunctions(cdef->constructorList, "constructor", MethodConstructor, paramsIndex);
-
-//
-// Terminate data array
-//
-    fprintf(out, "\n       0        // eod\n};\n\n");
-
-//
-// Generate internal qt_static_metacall() function
-//
-    const bool hasStaticMetaCall = !isQt &&
-            (cdef->hasQObject || !cdef->methodList.isEmpty()
-             || !cdef->propertyList.isEmpty() || !cdef->constructorList.isEmpty());
-    if (hasStaticMetaCall)
-        generateStaticMetacall();
-
-//
-// Build extra array
-//
-    QList<QByteArray> extraList;
-    QHash<QByteArray, QByteArray> knownExtraMetaObject = knownGadgets;
-    knownExtraMetaObject.unite(knownQObjectClasses);
-
-    for (int i = 0; i < cdef->propertyList.count(); ++i) {
-        const PropertyDef &p = cdef->propertyList.at(i);
-        if (isBuiltinType(p.type))
-            continue;
-
-        if (p.type.contains('*') || p.type.contains('<') || p.type.contains('>'))
-            continue;
-
-        int s = p.type.lastIndexOf("::");
-        if (s <= 0)
-            continue;
-
-        QByteArray unqualifiedScope = p.type.left(s);
-
-        // The scope may be a namespace for example, so it's only safe to include scopes that are known QObjects (QTBUG-2151)
-        QHash<QByteArray, QByteArray>::ConstIterator scopeIt;
-
-        QByteArray thisScope = cdef->qualified;
-        do {
-            int s = thisScope.lastIndexOf("::");
-            thisScope = thisScope.left(s);
-            QByteArray currentScope = thisScope.isEmpty() ? unqualifiedScope : thisScope + "::" + unqualifiedScope;
-            scopeIt = knownExtraMetaObject.constFind(currentScope);
-        } while (!thisScope.isEmpty() && scopeIt == knownExtraMetaObject.constEnd());
-
-        if (scopeIt == knownExtraMetaObject.constEnd())
-            continue;
-
-        const QByteArray &scope = *scopeIt;
-
-        if (scope == "Qt")
-            continue;
-        if (qualifiedNameEquals(cdef->qualified, scope))
-            continue;
-
-        if (!extraList.contains(scope))
-            extraList += scope;
-    }
-
-    // QTBUG-20639 - Accept non-local enums for QML signal/slot parameters.
-    // Look for any scoped enum declarations, and add those to the list
-    // of extra/related metaobjects for this object.
-    for (auto it = cdef->enumDeclarations.keyBegin(),
-         end = cdef->enumDeclarations.keyEnd(); it != end; ++it) {
-        const QByteArray &enumKey = *it;
-        int s = enumKey.lastIndexOf("::");
-        if (s > 0) {
-            QByteArray scope = enumKey.left(s);
-            if (scope != "Qt" && !qualifiedNameEquals(cdef->qualified, scope) && !extraList.contains(scope))
-                extraList += scope;
-        }
-    }
-
-    if (!extraList.isEmpty()) {
-        fprintf(out, "static const QMetaObject * const 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, "    nullptr\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, "    { nullptr, ");
-    else if (cdef->superclassList.size() && (!cdef->hasQGadget || knownGadgets.contains(purestSuperClass)))
-        fprintf(out, "    { &%s::staticMetaObject, ", purestSuperClass.constData());
-    else
-        fprintf(out, "    { nullptr, ");
-    fprintf(out, "qt_meta_stringdata_%s.data,\n"
-            "      qt_meta_data_%s, ", qualifiedClassNameIdentifier.constData(),
-            qualifiedClassNameIdentifier.constData());
-    if (hasStaticMetaCall)
-        fprintf(out, " qt_static_metacall, ");
-    else
-        fprintf(out, " nullptr, ");
-
-    if (extraList.isEmpty())
-        fprintf(out, "nullptr, ");
-    else
-        fprintf(out, "qt_meta_extradata_%s, ", qualifiedClassNameIdentifier.constData());
-    fprintf(out, "nullptr}\n};\n\n");
-
-    if(isQt)
-        return;
-
-    if (!cdef->hasQObject)
-        return;
-
-    fprintf(out, "\nconst QMetaObject *%s::metaObject() const\n{\n    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &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 nullptr;\n");
-    fprintf(out, "    if (!strcmp(_clname, qt_meta_stringdata_%s.stringdata0))\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.constData();
-        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 QVector<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;
-        fprintf(out, "    return %s::qt_metacast(_clname);\n", superClass.constData());
-    } else {
-        fprintf(out, "    return nullptr;\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);
-
-//
-// Generate plugin meta data
-//
-    generatePluginMetaData();
-}
-
-
-void Generator::registerClassInfoStrings()
-{
-    for (int i = 0; i < cdef->classInfoList.size(); ++i) {
-        const ClassInfoDef &c = cdef->classInfoList.at(i);
-        strreg(c.name);
-        strreg(c.value);
-    }
-}
-
-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", stridx(c.name), stridx(c.value));
-    }
-}
-
-void Generator::registerFunctionStrings(const QVector<FunctionDef>& list)
-{
-    for (int i = 0; i < list.count(); ++i) {
-        const FunctionDef &f = list.at(i);
-
-        strreg(f.name);
-        if (!isBuiltinType(f.normalizedType))
-            strreg(f.normalizedType);
-        strreg(f.tag);
-
-        int argsCount = f.arguments.count();
-        for (int j = 0; j < argsCount; ++j) {
-            const ArgumentDef &a = f.arguments.at(j);
-            if (!isBuiltinType(a.normalizedType))
-                strreg(a.normalizedType);
-            strreg(a.name);
-        }
-    }
-}
-
-void Generator::generateFunctions(const QVector<FunctionDef>& list, const char *functype, int type, int &paramsIndex)
-{
-    if (list.isEmpty())
-        return;
-    fprintf(out, "\n // %ss: name, argc, parameters, tag, flags\n", functype);
-
-    for (int i = 0; i < list.count(); ++i) {
-        const FunctionDef &f = list.at(i);
-
-        QByteArray comment;
-        unsigned char flags = type;
-        if (f.access == FunctionDef::Private) {
-            flags |= AccessPrivate;
-            comment.append("Private");
-        } else if (f.access == FunctionDef::Public) {
-            flags |= AccessPublic;
-            comment.append("Public");
-        } else if (f.access == FunctionDef::Protected) {
-            flags |= AccessProtected;
-            comment.append("Protected");
-        }
-        if (f.isCompat) {
-            flags |= MethodCompatibility;
-            comment.append(" | MethodCompatibility");
-        }
-        if (f.wasCloned) {
-            flags |= MethodCloned;
-            comment.append(" | MethodCloned");
-        }
-        if (f.isScriptable) {
-            flags |= MethodScriptable;
-            comment.append(" | isScriptable");
-        }
-        if (f.revision > 0) {
-            flags |= MethodRevisioned;
-            comment.append(" | MethodRevisioned");
-        }
-
-        int argc = f.arguments.count();
-        fprintf(out, "    %4d, %4d, %4d, %4d, 0x%02x /* %s */,\n",
-            stridx(f.name), argc, paramsIndex, stridx(f.tag), flags, comment.constData());
-
-        paramsIndex += 1 + argc * 2;
-    }
-}
-
-void Generator::generateFunctionRevisions(const QVector<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::generateFunctionParameters(const QVector<FunctionDef>& list, const char *functype)
-{
-    if (list.isEmpty())
-        return;
-    fprintf(out, "\n // %ss: parameters\n", functype);
-    for (int i = 0; i < list.count(); ++i) {
-        const FunctionDef &f = list.at(i);
-        fprintf(out, "    ");
-
-        // Types
-        int argsCount = f.arguments.count();
-        for (int j = -1; j < argsCount; ++j) {
-            if (j > -1)
-                fputc(' ', out);
-            const QByteArray &typeName = (j < 0) ? f.normalizedType : f.arguments.at(j).normalizedType;
-            generateTypeInfo(typeName, /*allowEmptyName=*/f.isConstructor);
-            fputc(',', out);
-        }
-
-        // Parameter names
-        for (int j = 0; j < argsCount; ++j) {
-            const ArgumentDef &arg = f.arguments.at(j);
-            fprintf(out, " %4d,", stridx(arg.name));
-        }
-
-        fprintf(out, "\n");
-    }
-}
-
-void Generator::generateTypeInfo(const QByteArray &typeName, bool allowEmptyName)
-{
-    Q_UNUSED(allowEmptyName);
-    if (isBuiltinType(typeName)) {
-        int type;
-        const char *valueString;
-        if (typeName == "qreal") {
-            type = QMetaType::UnknownType;
-            valueString = "QReal";
-        } else {
-            type = nameToBuiltinType(typeName);
-            valueString = metaTypeEnumValueString(type);
-        }
-        if (valueString) {
-            fprintf(out, "QMetaType::%s", valueString);
-        } else {
-            Q_ASSERT(type != QMetaType::UnknownType);
-            fprintf(out, "%4d", type);
-        }
-    } else {
-        Q_ASSERT(!typeName.isEmpty() || allowEmptyName);
-        fprintf(out, "0x%.8x | %d", IsUnresolvedType, stridx(typeName));
-    }
-}
-
-void Generator::registerPropertyStrings()
-{
-    for (int i = 0; i < cdef->propertyList.count(); ++i) {
-        const PropertyDef &p = cdef->propertyList.at(i);
-        strreg(p.name);
-        if (!isBuiltinType(p.type))
-            strreg(p.type);
-    }
-}
-
-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 (!isBuiltinType(p.type))
-            flags |= EnumOrFlag;
-        if (!p.member.isEmpty() && !p.constant)
-            flags |= Writable;
-        if (!p.read.isEmpty() || !p.member.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, ", stridx(p.name));
-        generateTypeInfo(p.type);
-        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::registerEnumStrings()
-{
-    for (int i = 0; i < cdef->enumList.count(); ++i) {
-        const EnumDef &e = cdef->enumList.at(i);
-        strreg(e.name);
-        for (int j = 0; j < e.values.count(); ++j)
-            strreg(e.values.at(j));
-    }
-}
-
-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);
-        int flags = 0;
-        if (cdef->enumDeclarations.value(e.name))
-            flags |= EnumIsFlag;
-        if (e.isEnumClass)
-            flags |= EnumIsScoped;
-        fprintf(out, "    %4d, 0x%.1x, %4d, %4d,\n",
-                 stridx(e.name),
-                 flags,
-                 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);
-            QByteArray code = cdef->qualified.constData();
-            if (e.isEnumClass)
-                code += "::" + e.name;
-            code += "::" + val;
-            fprintf(out, "    %4d, uint(%s),\n",
-                    stridx(val), code.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;
-        fprintf(out, "    _id = %s::qt_metacall(_c, _id, _a);\n", superClass.constData());
-    }
-
-
-    bool needElse = false;
-    QVector<FunctionDef> methodList;
-    methodList += cdef->signalList;
-    methodList += cdef->slotList;
-    methodList += cdef->methodList;
-
-    // If there are no methods or properties, we will return _id anyway, so
-    // don't emit this comparison -- it is unnecessary, and it makes coverity
-    // unhappy.
-    if (methodList.size() || cdef->propertyList.size()) {
-        fprintf(out, "    if (_id < 0)\n        return _id;\n");
-    }
-
-    fprintf(out, "    ");
-
-    if (methodList.size()) {
-        needElse = true;
-        fprintf(out, "if (_c == QMetaObject::InvokeMetaMethod) {\n");
-        fprintf(out, "        if (_id < %d)\n", methodList.size());
-        fprintf(out, "            qt_static_metacall(this, _c, _id, _a);\n");
-        fprintf(out, "        _id -= %d;\n    }", methodList.size());
-
-        fprintf(out, " else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {\n");
-        fprintf(out, "        if (_id < %d)\n", methodList.size());
-
-        if (methodsWithAutomaticTypesHelper(methodList).isEmpty())
-            fprintf(out, "            *reinterpret_cast<int*>(_a[0]) = -1;\n");
-        else
-            fprintf(out, "            qt_static_metacall(this, _c, _id, _a);\n");
-        fprintf(out, "        _id -= %d;\n    }", methodList.size());
-
-    }
-
-    if (cdef->propertyList.size()) {
-        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);
-            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 || _c == QMetaObject::WriteProperty\n"
-            "            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {\n"
-            "        qt_static_metacall(this, _c, _id, _a);\n"
-            "        _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, "        default: break;\n");
-            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, "        default: break;\n");
-            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, "        default: break;\n");
-            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, "        default: break;\n");
-            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, "        default: break;\n");
-            fprintf(out, "        }\n");
-        }
-        fprintf(out,
-                "        _id -= %d;\n"
-                "    }", cdef->propertyList.count());
-
-        fprintf(out, "\n#endif // QT_NO_PROPERTIES");
-    }
-    if (methodList.size() || cdef->propertyList.size())
-        fprintf(out, "\n    ");
-    fprintf(out,"return _id;\n}\n");
-}
-
-
-QMultiMap<QByteArray, int> Generator::automaticPropertyMetaTypesHelper()
-{
-    QMultiMap<QByteArray, int> automaticPropertyMetaTypes;
-    for (int i = 0; i < cdef->propertyList.size(); ++i) {
-        const QByteArray propertyType = cdef->propertyList.at(i).type;
-        if (registerableMetaType(propertyType) && !isBuiltinType(propertyType))
-            automaticPropertyMetaTypes.insert(propertyType, i);
-    }
-    return automaticPropertyMetaTypes;
-}
-
-QMap<int, QMultiMap<QByteArray, int> > Generator::methodsWithAutomaticTypesHelper(const QVector<FunctionDef> &methodList)
-{
-    QMap<int, QMultiMap<QByteArray, int> > methodsWithAutomaticTypes;
-    for (int i = 0; i < methodList.size(); ++i) {
-        const FunctionDef &f = methodList.at(i);
-        for (int j = 0; j < f.arguments.count(); ++j) {
-            const QByteArray argType = f.arguments.at(j).normalizedType;
-            if (registerableMetaType(argType) && !isBuiltinType(argType))
-                methodsWithAutomaticTypes[i].insert(argType, j);
-        }
-    }
-    return methodsWithAutomaticTypes;
-}
-
-void Generator::generateStaticMetacall()
-{
-    fprintf(out, "void %s::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)\n{\n",
-            cdef->qualified.constData());
-
-    bool needElse = false;
-    bool isUsed_a = false;
-
-    if (!cdef->constructorList.isEmpty()) {
-        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->classname.constData(), cdef->classname.constData());
-            const FunctionDef &f = cdef->constructorList.at(ctorindex);
-            int offset = 1;
-
-            int argsCount = f.arguments.count();
-            for (int j = 0; j < argsCount; ++j) {
-                const ArgumentDef &a = f.arguments.at(j);
-                if (j)
-                    fprintf(out, ",");
-                fprintf(out, "(*reinterpret_cast< %s>(_a[%d]))", a.typeNameForCast.constData(), offset++);
-            }
-            if (f.isPrivateSignal) {
-                if (argsCount > 0)
-                    fprintf(out, ", ");
-                fprintf(out, "%s", QByteArray("QPrivateSignal()").constData());
-            }
-            fprintf(out, ");\n");
-            fprintf(out, "            if (_a[0]) *reinterpret_cast<%s**>(_a[0]) = _r; } break;\n",
-                    cdef->hasQGadget ? "void" : "QObject");
-        }
-        fprintf(out, "        default: break;\n");
-        fprintf(out, "        }\n");
-        fprintf(out, "    }");
-        needElse = true;
-        isUsed_a = true;
-    }
-
-    QVector<FunctionDef> methodList;
-    methodList += cdef->signalList;
-    methodList += cdef->slotList;
-    methodList += cdef->methodList;
-
-    if (!methodList.isEmpty()) {
-        if (needElse)
-            fprintf(out, " else ");
-        else
-            fprintf(out, "    ");
-        fprintf(out, "if (_c == QMetaObject::InvokeMetaMethod) {\n");
-        if (cdef->hasQObject) {
-#ifndef QT_NO_DEBUG
-            fprintf(out, "        Q_ASSERT(staticMetaObject.cast(_o));\n");
-#endif
-            fprintf(out, "        %s *_t = static_cast<%s *>(_o);\n", cdef->classname.constData(), cdef->classname.constData());
-        } else {
-            fprintf(out, "        %s *_t = reinterpret_cast<%s *>(_o);\n", cdef->classname.constData(), cdef->classname.constData());
-        }
-        fprintf(out, "        Q_UNUSED(_t)\n");
-        fprintf(out, "        switch (_id) {\n");
-        for (int methodindex = 0; methodindex < methodList.size(); ++methodindex) {
-            const FunctionDef &f = methodList.at(methodindex);
-            Q_ASSERT(!f.normalizedType.isEmpty());
-            fprintf(out, "        case %d: ", methodindex);
-            if (f.normalizedType != "void")
-                fprintf(out, "{ %s _r = ", noRef(f.normalizedType).constData());
-            fprintf(out, "_t->");
-            if (f.inPrivateClass.size())
-                fprintf(out, "%s->", f.inPrivateClass.constData());
-            fprintf(out, "%s(", f.name.constData());
-            int offset = 1;
-
-            int argsCount = f.arguments.count();
-            for (int j = 0; j < argsCount; ++j) {
-                const ArgumentDef &a = f.arguments.at(j);
-                if (j)
-                    fprintf(out, ",");
-                fprintf(out, "(*reinterpret_cast< %s>(_a[%d]))",a.typeNameForCast.constData(), offset++);
-                isUsed_a = true;
-            }
-            if (f.isPrivateSignal) {
-                if (argsCount > 0)
-                    fprintf(out, ", ");
-                fprintf(out, "%s", "QPrivateSignal()");
-            }
-            fprintf(out, ");");
-            if (f.normalizedType != "void") {
-                fprintf(out, "\n            if (_a[0]) *reinterpret_cast< %s*>(_a[0]) = std::move(_r); } ",
-                        noRef(f.normalizedType).constData());
-                isUsed_a = true;
-            }
-            fprintf(out, " break;\n");
-        }
-        fprintf(out, "        default: ;\n");
-        fprintf(out, "        }\n");
-        fprintf(out, "    }");
-        needElse = true;
-
-        QMap<int, QMultiMap<QByteArray, int> > methodsWithAutomaticTypes = methodsWithAutomaticTypesHelper(methodList);
-
-        if (!methodsWithAutomaticTypes.isEmpty()) {
-            fprintf(out, " else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {\n");
-            fprintf(out, "        switch (_id) {\n");
-            fprintf(out, "        default: *reinterpret_cast<int*>(_a[0]) = -1; break;\n");
-            QMap<int, QMultiMap<QByteArray, int> >::const_iterator it = methodsWithAutomaticTypes.constBegin();
-            const QMap<int, QMultiMap<QByteArray, int> >::const_iterator end = methodsWithAutomaticTypes.constEnd();
-            for ( ; it != end; ++it) {
-                fprintf(out, "        case %d:\n", it.key());
-                fprintf(out, "            switch (*reinterpret_cast<int*>(_a[1])) {\n");
-                fprintf(out, "            default: *reinterpret_cast<int*>(_a[0]) = -1; break;\n");
-                auto jt = it->begin();
-                const auto jend = it->end();
-                while (jt != jend) {
-                    fprintf(out, "            case %d:\n", jt.value());
-                    const QByteArray &lastKey = jt.key();
-                    ++jt;
-                    if (jt == jend || jt.key() != lastKey)
-                        fprintf(out, "                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< %s >(); break;\n", lastKey.constData());
-                }
-                fprintf(out, "            }\n");
-                fprintf(out, "            break;\n");
-            }
-            fprintf(out, "        }\n");
-            fprintf(out, "    }");
-            isUsed_a = true;
-        }
-
-    }
-    if (!cdef->signalList.isEmpty()) {
-        Q_ASSERT(needElse); // if there is signal, there was method.
-        fprintf(out, " else if (_c == QMetaObject::IndexOfMethod) {\n");
-        fprintf(out, "        int *result = reinterpret_cast<int *>(_a[0]);\n");
-        fprintf(out, "        void **func = reinterpret_cast<void **>(_a[1]);\n");
-        bool anythingUsed = false;
-        for (int methodindex = 0; methodindex < cdef->signalList.size(); ++methodindex) {
-            const FunctionDef &f = cdef->signalList.at(methodindex);
-            if (f.wasCloned || !f.inPrivateClass.isEmpty() || f.isStatic)
-                continue;
-            anythingUsed = true;
-            fprintf(out, "        {\n");
-            fprintf(out, "            typedef %s (%s::*_t)(",f.type.rawName.constData() , cdef->classname.constData());
-
-            int argsCount = f.arguments.count();
-            for (int j = 0; j < argsCount; ++j) {
-                const ArgumentDef &a = f.arguments.at(j);
-                if (j)
-                    fprintf(out, ", ");
-                fprintf(out, "%s", QByteArray(a.type.name + ' ' + a.rightType).constData());
-            }
-            if (f.isPrivateSignal) {
-                if (argsCount > 0)
-                    fprintf(out, ", ");
-                fprintf(out, "%s", "QPrivateSignal");
-            }
-            if (f.isConst)
-                fprintf(out, ") const;\n");
-            else
-                fprintf(out, ");\n");
-            fprintf(out, "            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&%s::%s)) {\n",
-                    cdef->classname.constData(), f.name.constData());
-            fprintf(out, "                *result = %d;\n", methodindex);
-            fprintf(out, "                return;\n");
-            fprintf(out, "            }\n        }\n");
-        }
-        if (!anythingUsed)
-            fprintf(out, "        Q_UNUSED(result);\n        Q_UNUSED(func);\n");
-        fprintf(out, "    }");
-        needElse = true;
-    }
-
-    const QMultiMap<QByteArray, int> automaticPropertyMetaTypes = automaticPropertyMetaTypesHelper();
-
-    if (!automaticPropertyMetaTypes.isEmpty()) {
-        if (needElse)
-            fprintf(out, " else ");
-        else
-            fprintf(out, "    ");
-        fprintf(out, "if (_c == QMetaObject::RegisterPropertyMetaType) {\n");
-        fprintf(out, "        switch (_id) {\n");
-        fprintf(out, "        default: *reinterpret_cast<int*>(_a[0]) = -1; break;\n");
-        auto it = automaticPropertyMetaTypes.begin();
-        const auto end = automaticPropertyMetaTypes.end();
-        while (it != end) {
-            fprintf(out, "        case %d:\n", it.value());
-            const QByteArray &lastKey = it.key();
-            ++it;
-            if (it == end || it.key() != lastKey)
-                fprintf(out, "            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< %s >(); break;\n", lastKey.constData());
-        }
-        fprintf(out, "        }\n");
-        fprintf(out, "    }\n");
-        isUsed_a = true;
-        needElse = true;
-    }
-
-    if (!cdef->propertyList.empty()) {
-        bool needGet = false;
-        bool needTempVarForGet = false;
-        bool needSet = false;
-        bool needReset = false;
-        for (int i = 0; i < cdef->propertyList.size(); ++i) {
-            const PropertyDef &p = cdef->propertyList.at(i);
-            needGet |= !p.read.isEmpty() || !p.member.isEmpty();
-            if (!p.read.isEmpty() || !p.member.isEmpty())
-                needTempVarForGet |= (p.gspec != PropertyDef::PointerSpec
-                                      && p.gspec != PropertyDef::ReferenceSpec);
-
-            needSet |= !p.write.isEmpty() || (!p.member.isEmpty() && !p.constant);
-            needReset |= !p.reset.isEmpty();
-        }
-        fprintf(out, "\n#ifndef QT_NO_PROPERTIES\n    ");
-
-        if (needElse)
-            fprintf(out, "else ");
-        fprintf(out, "if (_c == QMetaObject::ReadProperty) {\n");
-        if (needGet) {
-            if (cdef->hasQObject) {
-#ifndef QT_NO_DEBUG
-                fprintf(out, "        Q_ASSERT(staticMetaObject.cast(_o));\n");
-#endif
-                fprintf(out, "        %s *_t = static_cast<%s *>(_o);\n", cdef->classname.constData(), cdef->classname.constData());
-            } else {
-                fprintf(out, "        %s *_t = reinterpret_cast<%s *>(_o);\n", cdef->classname.constData(), cdef->classname.constData());
-            }
-            fprintf(out, "        Q_UNUSED(_t)\n");
-            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() && p.member.isEmpty())
-                    continue;
-                QByteArray prefix = "_t->";
-                if (p.inPrivateClass.size()) {
-                    prefix += p.inPrivateClass + "->";
-                }
-                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 if (!p.read.isEmpty())
-                    fprintf(out, "        case %d: *reinterpret_cast< %s*>(_v) = %s%s(); break;\n",
-                            propindex, p.type.constData(), 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.member.constData());
-            }
-            fprintf(out, "        default: break;\n");
-            fprintf(out, "        }\n");
-        }
-
-        fprintf(out, "    }");
-
-        fprintf(out, " else ");
-        fprintf(out, "if (_c == QMetaObject::WriteProperty) {\n");
-
-        if (needSet) {
-            if (cdef->hasQObject) {
-#ifndef QT_NO_DEBUG
-                fprintf(out, "        Q_ASSERT(staticMetaObject.cast(_o));\n");
-#endif
-                fprintf(out, "        %s *_t = static_cast<%s *>(_o);\n", cdef->classname.constData(), cdef->classname.constData());
-            } else {
-                fprintf(out, "        %s *_t = reinterpret_cast<%s *>(_o);\n", cdef->classname.constData(), cdef->classname.constData());
-            }
-            fprintf(out, "        Q_UNUSED(_t)\n");
-            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.constant)
-                    continue;
-                if (p.write.isEmpty() && p.member.isEmpty())
-                    continue;
-                QByteArray prefix = "_t->";
-                if (p.inPrivateClass.size()) {
-                    prefix += p.inPrivateClass + "->";
-                }
-                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 if (!p.write.isEmpty()) {
-                    fprintf(out, "        case %d: %s%s(*reinterpret_cast< %s*>(_v)); break;\n",
-                            propindex, prefix.constData(), p.write.constData(), p.type.constData());
-                } else {
-                    fprintf(out, "        case %d:\n", propindex);
-                    fprintf(out, "            if (%s%s != *reinterpret_cast< %s*>(_v)) {\n",
-                            prefix.constData(), p.member.constData(), p.type.constData());
-                    fprintf(out, "                %s%s = *reinterpret_cast< %s*>(_v);\n",
-                            prefix.constData(), p.member.constData(), p.type.constData());
-                    if (!p.notify.isEmpty() && p.notifyId != -1) {
-                        const FunctionDef &f = cdef->signalList.at(p.notifyId);
-                        if (f.arguments.size() == 0)
-                            fprintf(out, "                Q_EMIT _t->%s();\n", p.notify.constData());
-                        else if (f.arguments.size() == 1 && f.arguments.at(0).normalizedType == p.type)
-                            fprintf(out, "                Q_EMIT _t->%s(%s%s);\n",
-                                    p.notify.constData(), prefix.constData(), p.member.constData());
-                    }
-                    fprintf(out, "            }\n");
-                    fprintf(out, "            break;\n");
-                }
-            }
-            fprintf(out, "        default: break;\n");
-            fprintf(out, "        }\n");
-        }
-
-        fprintf(out, "    }");
-
-        fprintf(out, " else ");
-        fprintf(out, "if (_c == QMetaObject::ResetProperty) {\n");
-        if (needReset) {
-            if (cdef->hasQObject) {
-#ifndef QT_NO_DEBUG
-                fprintf(out, "        Q_ASSERT(staticMetaObject.cast(_o));\n");
-#endif
-                fprintf(out, "        %s *_t = static_cast<%s *>(_o);\n", cdef->classname.constData(), cdef->classname.constData());
-            } else {
-                fprintf(out, "        %s *_t = reinterpret_cast<%s *>(_o);\n", cdef->classname.constData(), cdef->classname.constData());
-            }
-            fprintf(out, "        Q_UNUSED(_t)\n");
-            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 = "_t->";
-                if (p.inPrivateClass.size()) {
-                    prefix += p.inPrivateClass + "->";
-                }
-                fprintf(out, "        case %d: %s%s; break;\n",
-                        propindex, prefix.constData(), p.reset.constData());
-            }
-            fprintf(out, "        default: break;\n");
-            fprintf(out, "        }\n");
-        }
-        fprintf(out, "    }");
-        fprintf(out, "\n#endif // QT_NO_PROPERTIES");
-        needElse = true;
-    }
-
-    if (needElse)
-        fprintf(out, "\n");
-
-    if (methodList.isEmpty()) {
-        fprintf(out, "    Q_UNUSED(_o);\n");
-        if (cdef->constructorList.isEmpty() && automaticPropertyMetaTypes.isEmpty() && methodsWithAutomaticTypesHelper(methodList).isEmpty()) {
-            fprintf(out, "    Q_UNUSED(_id);\n");
-            fprintf(out, "    Q_UNUSED(_c);\n");
-        }
-    }
-    if (!isUsed_a)
-        fprintf(out, "    Q_UNUSED(_a);\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< " + cdef->qualified + " *>(this)";
-        constQualifier = "const";
-    }
-
-    Q_ASSERT(!def->normalizedType.isEmpty());
-    if (def->arguments.isEmpty() && def->normalizedType == "void" && !def->isPrivateSignal) {
-        fprintf(out, ")%s\n{\n"
-                "    QMetaObject::activate(%s, &staticMetaObject, %d, nullptr);\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());
-    }
-    if (def->isPrivateSignal) {
-        if (!def->arguments.isEmpty())
-            fprintf(out, ", ");
-        fprintf(out, "QPrivateSignal _t%d", offset++);
-    }
-
-    fprintf(out, ")%s\n{\n", constQualifier);
-    if (def->type.name.size() && def->normalizedType != "void") {
-        QByteArray returnType = noRef(def->normalizedType);
-        fprintf(out, "    %s _t0{};\n", returnType.constData());
-    }
-
-    fprintf(out, "    void *_a[] = { ");
-    if (def->normalizedType == "void") {
-        fprintf(out, "nullptr");
-    } 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 (i <= def->arguments.count() && 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 != "void")
-        fprintf(out, "    return _t0;\n");
-    fprintf(out, "}\n");
-}
-
-static void writePluginMetaData(FILE *out, const QJsonObject &data)
-{
-    const QJsonDocument doc(data);
-
-    fputs("\nQT_PLUGIN_METADATA_SECTION\n"
-          "static const unsigned char qt_pluginMetaData[] = {\n"
-          "    'Q', 'T', 'M', 'E', 'T', 'A', 'D', 'A', 'T', 'A', ' ', ' ',\n   ", out);
-#if 0
-    fprintf(out, "\"%s\";\n", doc.toJson().constData());
-#else
-    const QByteArray binary = doc.toBinaryData();
-    const int last = binary.size() - 1;
-    for (int i = 0; i < last; ++i) {
-        uchar c = (uchar)binary.at(i);
-        if (c < 0x20 || c >= 0x7f)
-            fprintf(out, " 0x%02x,", c);
-        else if (c == '\'' || c == '\\')
-            fprintf(out, " '\\%c',", c);
-        else
-            fprintf(out, " '%c', ", c);
-        if (!((i + 1) % 8))
-            fputs("\n   ", out);
-    }
-    fprintf(out, " 0x%02x\n};\n", (uchar)binary.at(last));
-#endif
-}
-
-void Generator::generatePluginMetaData()
-{
-    if (cdef->pluginData.iid.isEmpty())
-        return;
-
-    // Write plugin meta data #ifdefed QT_NO_DEBUG with debug=false,
-    // true, respectively.
-
-    QJsonObject data;
-    const QString debugKey = QStringLiteral("debug");
-    data.insert(QStringLiteral("IID"), QLatin1String(cdef->pluginData.iid.constData()));
-    data.insert(QStringLiteral("className"), QLatin1String(cdef->classname.constData()));
-    data.insert(QStringLiteral("version"), (int)QT_VERSION);
-    data.insert(debugKey, QJsonValue(false));
-    data.insert(QStringLiteral("MetaData"), cdef->pluginData.metaData.object());
-
-    // Add -M args from the command line:
-    for (auto it = cdef->pluginData.metaArgs.cbegin(), end = cdef->pluginData.metaArgs.cend(); it != end; ++it)
-        data.insert(it.key(), it.value());
-
-    fputs("\nQT_PLUGIN_METADATA_SECTION const uint qt_section_alignment_dummy = 42;\n\n"
-          "#ifdef QT_NO_DEBUG\n", out);
-    writePluginMetaData(out, data);
-
-    fputs("\n#else // QT_NO_DEBUG\n", out);
-
-    data.remove(debugKey);
-    data.insert(debugKey, QJsonValue(true));
-    writePluginMetaData(out, data);
-
-    fputs("#endif // QT_NO_DEBUG\n\n", out);
-
-    // 'Use' all namespaces.
-    int pos = cdef->qualified.indexOf("::");
-    for ( ; pos != -1 ; pos = cdef->qualified.indexOf("::", pos + 2) )
-        fprintf(out, "using namespace %s;\n", cdef->qualified.left(pos).constData());
-    fprintf(out, "QT_MOC_EXPORT_PLUGIN(%s, %s)\n\n",
-            cdef->qualified.constData(), cdef->classname.constData());
-}
-
-QT_END_NAMESPACE
diff --git a/tools/repc/moc_copy/generator.h b/tools/repc/moc_copy/generator.h
deleted file mode 100644
index 3833148..0000000
--- a/tools/repc/moc_copy/generator.h
+++ /dev/null
@@ -1,75 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the tools applications of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:GPL-EXCEPT$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3 as published by the Free Software
-** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef GENERATOR_H
-#define GENERATOR_H
-
-#include "moc.h"
-
-QT_BEGIN_NAMESPACE
-
-class Generator
-{
-    FILE *out;
-    ClassDef *cdef;
-    QVector<uint> meta_data;
-public:
-    Generator(ClassDef *classDef, const QList<QByteArray> &metaTypes, const QHash<QByteArray, QByteArray> &knownQObjectClasses, const QHash<QByteArray, QByteArray> &knownGadgets, FILE *outfile = 0);
-    void generateCode();
-private:
-    bool registerableMetaType(const QByteArray &propertyType);
-    void registerClassInfoStrings();
-    void generateClassInfos();
-    void registerFunctionStrings(const QVector<FunctionDef> &list);
-    void generateFunctions(const QVector<FunctionDef> &list, const char *functype, int type, int &paramsIndex);
-    void generateFunctionRevisions(const QVector<FunctionDef> &list, const char *functype);
-    void generateFunctionParameters(const QVector<FunctionDef> &list, const char *functype);
-    void generateTypeInfo(const QByteArray &typeName, bool allowEmptyName = false);
-    void registerEnumStrings();
-    void generateEnums(int index);
-    void registerPropertyStrings();
-    void generateProperties();
-    void generateMetacall();
-    void generateStaticMetacall();
-    void generateSignal(FunctionDef *def, int index);
-    void generatePluginMetaData();
-    QMultiMap<QByteArray, int> automaticPropertyMetaTypesHelper();
-    QMap<int, QMultiMap<QByteArray, int> > methodsWithAutomaticTypesHelper(const QVector<FunctionDef> &methodList);
-
-    void strreg(const QByteArray &); // registers a string
-    int stridx(const QByteArray &); // returns a string's id
-    QList<QByteArray> strings;
-    QByteArray purestSuperClass;
-    QList<QByteArray> metaTypes;
-    QHash<QByteArray, QByteArray> knownQObjectClasses;
-    QHash<QByteArray, QByteArray> knownGadgets;
-};
-
-QT_END_NAMESPACE
-
-#endif // GENERATOR_H
diff --git a/tools/repc/moc_copy/moc.cpp b/tools/repc/moc_copy/moc.cpp
index 36d84a6..49eb3be 100644
--- a/tools/repc/moc_copy/moc.cpp
+++ b/tools/repc/moc_copy/moc.cpp
@@ -28,7 +28,6 @@
 ****************************************************************************/
 
 #include "moc.h"
-#include "generator.h"
 #include "qdatetime.h"
 #include "utils.h"
 #include "outputrevision.h"
@@ -914,129 +913,6 @@ void Moc::parse()
     }
 }
 
-static bool any_type_contains(const QVector<PropertyDef> &properties, const QByteArray &pattern)
-{
-    for (const auto &p : properties) {
-        if (p.type.contains(pattern))
-            return true;
-    }
-    return false;
-}
-
-static bool any_arg_contains(const QVector<FunctionDef> &functions, const QByteArray &pattern)
-{
-    for (const auto &f : functions) {
-        for (const auto &arg : f.arguments) {
-            if (arg.normalizedType.contains(pattern))
-                return true;
-        }
-    }
-    return false;
-}
-
-static QByteArrayList make_candidates()
-{
-    QByteArrayList result;
-    result
-#define STREAM_SMART_POINTER(SMART_POINTER) << #SMART_POINTER
-        QT_FOR_EACH_AUTOMATIC_TEMPLATE_SMART_POINTER(STREAM_SMART_POINTER)
-#undef STREAM_SMART_POINTER
-#define STREAM_1ARG_TEMPLATE(TEMPLATENAME) << #TEMPLATENAME
-        QT_FOR_EACH_AUTOMATIC_TEMPLATE_1ARG(STREAM_1ARG_TEMPLATE)
-#undef STREAM_1ARG_TEMPLATE
-        ;
-    return result;
-}
-
-static QByteArrayList requiredQtContainers(const QVector<ClassDef> &classes)
-{
-    static const QByteArrayList candidates = make_candidates();
-
-    QByteArrayList required;
-    required.reserve(candidates.size());
-
-    for (const auto &candidate : candidates) {
-        const QByteArray pattern = candidate + '<';
-
-        for (const auto &c : classes) {
-            if (any_type_contains(c.propertyList, pattern) ||
-                    any_arg_contains(c.slotList, pattern) ||
-                    any_arg_contains(c.signalList, pattern) ||
-                    any_arg_contains(c.methodList, pattern)) {
-                required.push_back(candidate);
-                break;
-            }
-        }
-    }
-
-    return required;
-}
-
-void Moc::generate(FILE *out)
-{
-    QByteArray fn = filename;
-    int i = filename.length()-1;
-    while (i > 0 && filename.at(i - 1) != '/' && filename.at(i - 1) != '\\')
-        --i;                                // skip path
-    if (i >= 0)
-        fn = filename.mid(i);
-    fprintf(out, "/****************************************************************************\n"
-            "** Meta object code from reading C++ file '%s'\n**\n" , fn.constData());
-    fprintf(out, "** Created by: The Qt Meta Object Compiler version %d (Qt %s)\n**\n" , mocOutputRevision, QT_VERSION_STR);
-    fprintf(out, "** WARNING! All changes made in this file will be lost!\n"
-            "*****************************************************************************/\n\n");
-
-
-    if (!noInclude) {
-        if (includePath.size() && !includePath.endsWith('/'))
-            includePath += '/';
-        for (int i = 0; i < includeFiles.size(); ++i) {
-            QByteArray inc = includeFiles.at(i);
-            if (inc.at(0) != '<' && inc.at(0) != '"') {
-                if (includePath.size() && includePath != "./")
-                    inc.prepend(includePath);
-                inc = '\"' + inc + '\"';
-            }
-            fprintf(out, "#include %s\n", inc.constData());
-        }
-    }
-    if (classList.size() && classList.constFirst().classname == "Qt")
-        fprintf(out, "#include <QtCore/qobject.h>\n");
-
-    fprintf(out, "#include <QtCore/qbytearray.h>\n"); // For QByteArrayData
-    fprintf(out, "#include <QtCore/qmetatype.h>\n");  // For QMetaType::Type
-    if (mustIncludeQPluginH)
-        fprintf(out, "#include <QtCore/qplugin.h>\n");
-
-    const auto qtContainers = requiredQtContainers(classList);
-    for (const QByteArray &qtContainer : qtContainers)
-        fprintf(out, "#include <QtCore/%s>\n", qtContainer.constData());
-
-
-    fprintf(out, "#if !defined(Q_MOC_OUTPUT_REVISION)\n"
-            "#error \"The header file '%s' doesn't include <QObject>.\"\n", fn.constData());
-    fprintf(out, "#elif Q_MOC_OUTPUT_REVISION != %d\n", mocOutputRevision);
-    fprintf(out, "#error \"This file was generated using the moc from %s."
-            " It\"\n#error \"cannot be used with the include files from"
-            " this version of Qt.\"\n#error \"(The moc has changed too"
-            " much.)\"\n", QT_VERSION_STR);
-    fprintf(out, "#endif\n\n");
-
-    fprintf(out, "QT_BEGIN_MOC_NAMESPACE\n");
-    fprintf(out, "QT_WARNING_PUSH\n");
-    fprintf(out, "QT_WARNING_DISABLE_DEPRECATED\n");
-
-    fputs("", out);
-    for (i = 0; i < classList.size(); ++i) {
-        Generator generator(&classList[i], metaTypes, knownQObjectClasses, knownGadgets, out);
-        generator.generateCode();
-    }
-    fputs("", out);
-
-    fprintf(out, "QT_WARNING_POP\n");
-    fprintf(out, "QT_END_MOC_NAMESPACE\n");
-}
-
 void Moc::parseSlots(ClassDef *def, FunctionDef::Access access)
 {
     int defaultRevision = -1;
diff --git a/tools/repc/moc_copy/moc.h b/tools/repc/moc_copy/moc.h
index 6040f94..de10b90 100644
--- a/tools/repc/moc_copy/moc.h
+++ b/tools/repc/moc_copy/moc.h
@@ -215,7 +215,6 @@ public:
     QMap<QString, QJsonArray> metaArgs;
 
     void parse();
-    void generate(FILE *out);
 
     bool parseClassHead(ClassDef *def);
     inline bool inClass(const ClassDef *def) const {
diff --git a/tools/repc/moc_copy/moc.pri b/tools/repc/moc_copy/moc.pri
index 6d0ca8a..a6546b8 100644
--- a/tools/repc/moc_copy/moc.pri
+++ b/tools/repc/moc_copy/moc.pri
@@ -7,10 +7,8 @@ HEADERS += $$PWD/moc.h \
            $$PWD/symbols.h \
            $$PWD/token.h \
            $$PWD/utils.h \
-           $$PWD/generator.h \
            $$PWD/outputrevision.h
 SOURCES += $$PWD/moc.cpp \
            $$PWD/preprocessor.cpp \
-           $$PWD/generator.cpp \
            $$PWD/parser.cpp \
            $$PWD/token.cpp