Get rid of qt mode

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

5 files changed, 10 insertions, 218 deletions

diff --git a/tools/qscxmlc/data.t b/tools/qscxmlc/data.t
index b26f451..afb5a64 100644
--- a/tools/qscxmlc/data.t
+++ b/tools/qscxmlc/data.t
@@ -40,7 +40,6 @@ struct ${classname}::Data: private QScxmlTableData {
     { return theStateMachineTable; }
 
     QScxmlInvokableServiceFactory *serviceFactory(int id) const Q_DECL_OVERRIDE Q_DECL_FINAL;
-    int signalIndexForEvent(const QString &event) const Q_DECL_OVERRIDE Q_DECL_FINAL;
 
     ${classname} &stateMachine;
     ${dataModelField}
@@ -55,8 +54,6 @@ struct ${classname}::Data: private QScxmlTableData {
         QArrayData data[${stringCount}];
         qunicodechar stringdata[${stringdataSize}];
     } strings;
-
-    static std::vector<QString> outgoingEvents;
 };
 
 ${classname}::${classname}(QObject *parent)
@@ -72,20 +69,6 @@ QScxmlInvokableServiceFactory *${classname}::Data::serviceFactory(int id) const
 ${serviceFactories}
 }
 
-std::vector<QString> ${classname}::Data::outgoingEvents = {
-${outgoingEvents}
-};
-
-int ${classname}::Data::signalIndexForEvent(const QString &event) const
-{
-    auto it = std::lower_bound(outgoingEvents.begin(), outgoingEvents.end(), event);
-    if (it != outgoingEvents.end() && *it == event) {
-        return int(std::distance(outgoingEvents.begin(), it));
-    } else {
-        return -1;
-    }
-}
-
 qint32 ${classname}::Data::theInstructions[] = {
 ${theInstructions}
 };
@@ -119,5 +102,3 @@ ${uniLits}
 const qint32 ${classname}::Data::theStateMachineTable[] = ${theStateMachineTable};
 
 ${metaObject}
-${getters}
-${slots}
diff --git a/tools/qscxmlc/decl.t b/tools/qscxmlc/decl.t
index b0963e4..7c27f1d 100644
--- a/tools/qscxmlc/decl.t
+++ b/tools/qscxmlc/decl.t
@@ -9,11 +9,6 @@ public:
     ${classname}(QObject *parent = 0);
     ~${classname}();
 
-${getters}
-signals:
-${signals}
-public slots:
-${slots}
 private:
     struct Data;
     friend struct Data;
diff --git a/tools/qscxmlc/qscxmlc.cpp b/tools/qscxmlc/qscxmlc.cpp
index 2198592..47db6fb 100644
--- a/tools/qscxmlc/qscxmlc.cpp
+++ b/tools/qscxmlc/qscxmlc.cpp
@@ -124,13 +124,6 @@ int run(const QStringList &arguments)
     QCommandLineOption optionClassName(QLatin1String("classname"),
                        QCoreApplication::translate("main", "Generate <name> for state machine class name."),
                        QCoreApplication::translate("main", "name"));
-    QCommandLineOption optionQtMode(QLatin1String("qt-mode"),
-                       QCoreApplication::translate("main", "Enables or disables Qt mode. "
-                                                           "In order to unconditionally enable qt-mode, specify \"yes\". "
-                                                           "To unconditionally disable qt-mode, specify \"no\". "
-                                                           "To read the setting from the input file, specify \"from-input\". "
-                                                           "The default is \"from-input\"."),
-                       QCoreApplication::translate("main", "mode"), QLatin1String("from-input"));
 
     cmdParser.addPositionalArgument(QLatin1String("input"),
                        QCoreApplication::translate("main", "Input SCXML file."));
@@ -140,7 +133,6 @@ int run(const QStringList &arguments)
     cmdParser.addOption(optionOutputHeaderName);
     cmdParser.addOption(optionOutputSourceName);
     cmdParser.addOption(optionClassName);
-    cmdParser.addOption(optionQtMode);
 
     cmdParser.process(arguments);
 
@@ -167,21 +159,6 @@ int run(const QStringList &arguments)
     QString outHFileName = cmdParser.value(optionOutputHeaderName);
     QString outCppFileName = cmdParser.value(optionOutputSourceName);
     QString mainClassName = cmdParser.value(optionClassName);
-    QString qtModeName = cmdParser.value(optionQtMode);
-
-    QScxmlParser::QtMode qtMode = QScxmlParser::QtModeFromInputFile;
-
-    if (qtModeName == QLatin1String("yes")) {
-        qtMode = QScxmlParser::QtModeEnabled;
-    } else if (qtModeName == QLatin1String("no")) {
-        qtMode = QScxmlParser::QtModeDisabled;
-    } else if (qtModeName == QLatin1String("from-input")) {
-        qtMode = QScxmlParser::QtModeFromInputFile;
-    } else {
-        errs << QCoreApplication::translate("main", "Error: unexpected value for qt-mode option: %1")
-                .arg(qtModeName) << endl;
-        cmdParser.showHelp(CommandLineArgumentsError);
-    }
 
     if (outFileName.isEmpty())
         outFileName = QFileInfo(scxmlFileName).baseName();
@@ -199,7 +176,6 @@ int run(const QStringList &arguments)
     QXmlStreamReader reader(&file);
     QScxmlParser parser(&reader);
     parser.setFileName(file.fileName());
-    parser.setQtMode(qtMode);
     parser.parse();
     if (!parser.errors().isEmpty()) {
         foreach (const QScxmlError &error, parser.errors()) {
diff --git a/tools/qscxmlc/scxmlcppdumper.cpp b/tools/qscxmlc/scxmlcppdumper.cpp
index d13b18e..4d0e795 100644
--- a/tools/qscxmlc/scxmlcppdumper.cpp
+++ b/tools/qscxmlc/scxmlcppdumper.cpp
@@ -188,8 +188,7 @@ static void generateList(QString &out, std::function<QString(int)> next)
         out += line;
 }
 
-void generateTables(const GeneratedTableData &td, const QStringList &outgoingEvents,
-                    Replacements &replacements, bool useCxx11)
+void generateTables(const GeneratedTableData &td, Replacements &replacements)
 {
     { // instructions
         auto instr = td.theInstructions;
@@ -307,16 +306,6 @@ void generateTables(const GeneratedTableData &td, const QStringList &outgoingEve
         replacements[QStringLiteral("uniLits")] = out;
         replacements[QStringLiteral("stringdataSize")] = QString::number(ucharCount + 1);
     }
-
-    {
-        QStringList items;
-        foreach (const QString &event, outgoingEvents) {
-            items += QStringLiteral("QString({static_cast<QStringData*>(strings.data + %1)})")
-                    .arg(td.theStrings.indexOf(event));
-        }
-        replacements[QStringLiteral("outgoingEvents")] = createContainer(
-                    QStringLiteral("std::vector"), QStringLiteral("QString"), items, useCxx11);
-    }
 }
 
 void generateCppDataModelEvaluators(const GeneratedTableData::DataModelInfo &info,
@@ -470,7 +459,6 @@ void CppDumper::dump(TranslationUnit *unit)
                                    finalize, m_translationUnit->useCxx11);
         });
         classNames.append(mangleIdentifier(classnameForDocument.value(doc)));
-        std::sort(metaDataInfo->outgoingEvents.begin(), metaDataInfo->outgoingEvents.end());
     }
 
     const QString headerName = QFileInfo(m_translationUnit->outHFileName).fileName();
@@ -522,13 +510,9 @@ void CppDumper::writeHeaderStart(const QString &headerGuard, const QStringList &
 
 void CppDumper::writeClass(const QString &className, const GeneratedTableData::MetaDataInfo &info)
 {
-    const bool qtMode = m_translationUnit->mainDocument->qtMode;
     Replacements r;
     r[QStringLiteral("classname")] = className;
-    r[QStringLiteral("properties")] = generatePropertyDecls(info, qtMode);
-    r[QStringLiteral("signals")] = qtMode ? generateSignalDecls(info) : QString();
-    r[QStringLiteral("slots")] = qtMode ? generateSlotDecls(info) : QString();
-    r[QStringLiteral("getters")] = qtMode ? generateGetterDecls(info) : QString();
+    r[QStringLiteral("properties")] = generatePropertyDecls(info);
     genTemplate(h, QStringLiteral(":/decl.t"), r);
 }
 
@@ -597,8 +581,6 @@ void CppDumper::writeImplBody(const GeneratedTableData &table,
                               const QStringList &factory,
                               const GeneratedTableData::MetaDataInfo &info)
 {
-    const bool qtMode = m_translationUnit->mainDocument->qtMode;
-
     QString dataModelField, dataModelInitialization;
     switch (doc->root->dataModel) {
     case DocumentModel::Scxml::NullDataModel:
@@ -637,15 +619,13 @@ void CppDumper::writeImplBody(const GeneratedTableData &table,
     r[QStringLiteral("classname")] = className;
     r[QStringLiteral("name")] = name;
     r[QStringLiteral("initialSetup")] = QString::number(table.initialSetup());
-    generateTables(table, info.outgoingEvents, r, m_translationUnit->useCxx11);
+    generateTables(table, r);
     r[QStringLiteral("dataModelField")] = dataModelField;
     r[QStringLiteral("dataModelInitialization")] = dataModelInitialization;
     r[QStringLiteral("theStateMachineTable")] =
             GeneratedTableData::toString(table.stateMachineTable());
-    r[QStringLiteral("metaObject")] = generateMetaObject(className, info, qtMode);
+    r[QStringLiteral("metaObject")] = generateMetaObject(className, info);
     r[QStringLiteral("serviceFactories")] = serviceFactories;
-    r[QStringLiteral("slots")] = qtMode ? generateSlotDefs(className, info) : QString();
-    r[QStringLiteral("getters")] = qtMode ? generateGetterDefs(className, info) : QString();
     genTemplate(cpp, QStringLiteral(":/data.t"), r);
 }
 
@@ -721,99 +701,23 @@ QString CppDumper::mangleIdentifier(const QString &str)
     return mangled;
 }
 
-QString CppDumper::generatePropertyDecls(const GeneratedTableData::MetaDataInfo &info, bool qtMode)
+QString CppDumper::generatePropertyDecls(const GeneratedTableData::MetaDataInfo &info)
 {
     QString decls;
 
     foreach (const QString &stateName, info.stateNames) {
         if (!stateName.isEmpty()) {
             const QString decl = QString::fromLatin1(
-                        qtMode ? "    Q_PROPERTY(bool %1 READ %2 NOTIFY %2Changed)\n" :
                                  "    Q_PROPERTY(bool %1 NOTIFY %2Changed)\n");
             decls += decl.arg(stateName, mangleIdentifier(stateName));
         }
     }
 
-    QString namespacePrefix;
-    if (!m_translationUnit->namespaceName.isEmpty()) {
-        namespacePrefix = QStringLiteral("::%1").arg(m_translationUnit->namespaceName);
-    }
-
-    return decls;
-}
-
-QString CppDumper::generateSignalDecls(const GeneratedTableData::MetaDataInfo &info)
-{
-    QString decls;
-
-    foreach (const QString &stateName, info.stateNames) {
-        decls += QStringLiteral("    void %1Changed(bool active);\n")
-                .arg(mangleIdentifier(stateName));
-    }
-
-    foreach (const QString &eventName, info.outgoingEvents) {
-        decls += QStringLiteral("    void %1(const QVariant &data);\n")
-                .arg(mangleIdentifier(eventName));
-    }
-
-    return decls;
-}
-
-QString CppDumper::generateSlotDecls(const GeneratedTableData::MetaDataInfo &info)
-{
-    QString decls;
-
-    foreach (const QString &eventName, info.incomingEvents) {
-        decls += QStringLiteral("    void %1(const QVariant &data = QVariant());\n")
-                .arg(mangleIdentifier(eventName));
-    }
-
-    return decls;
-}
-
-QString CppDumper::generateSlotDefs(const QString &className,
-                                    const GeneratedTableData::MetaDataInfo &info)
-{
-    QString defs;
-
-    foreach (const QString &eventName, info.incomingEvents) {
-        const auto mangledName = mangleIdentifier(eventName);
-        defs += QStringLiteral("void %1::%2(const QVariant &data)\n").arg(className, mangledName);
-        defs += QStringLiteral("{ submitEvent(QStringLiteral(\"%1\"), data); }\n\n").arg(eventName);
-    }
-
-    return defs;
-}
-
-QString CppDumper::generateGetterDecls(const GeneratedTableData::MetaDataInfo &info)
-{
-    QString decls;
-
-    foreach (const QString &stateName, info.stateNames) {
-        decls += QStringLiteral("    bool %1() const;\n").arg(mangleIdentifier(stateName));
-    }
-
     return decls;
 }
 
-QString CppDumper::generateGetterDefs(const QString &className,
-                                      const GeneratedTableData::MetaDataInfo &info)
-{
-    QString defs;
-
-    int stateIndex = 0;
-    foreach (const QString &stateName, info.stateNames) {
-        defs += QStringLiteral("bool %1::%2() const\n").arg(className, mangleIdentifier(stateName));
-        defs += QStringLiteral("{ return isActive(%1); }\n\n").arg(stateIndex);
-        ++stateIndex;
-    }
-
-    return defs;
-}
-
 QString CppDumper::generateMetaObject(const QString &className,
-                                      const GeneratedTableData::MetaDataInfo &info,
-                                      bool m_qtMode)
+                                      const GeneratedTableData::MetaDataInfo &info)
 {
     ClassDef classDef;
     classDef.classname = className.toUtf8();
@@ -836,9 +740,8 @@ QString CppDumper::generateMetaObject(const QString &className,
         signal.name = mangledStateName + "Changed";
         signal.access = FunctionDef::Public;
         signal.isSignal = true;
-        if (!m_qtMode) {
-            signal.implementation = "QMetaObject::activate(_o, &staticMetaObject, %d, _a);";
-        }
+        signal.implementation = "QMetaObject::activate(_o, &staticMetaObject, %d, _a);";
+
         ArgumentDef arg;
         arg.type.name = "bool";
         arg.type.rawName = arg.type.name;
@@ -864,60 +767,6 @@ QString CppDumper::generateMetaObject(const QString &className,
     QHash<QByteArray, QByteArray> knownQObjectClasses;
     knownQObjectClasses.insert(QByteArray("QScxmlStateMachine"), QByteArray());
 
-    // Event signals:
-    foreach (const QString &signalName, info.outgoingEvents) {
-        FunctionDef signal;
-        signal.type.name = "void";
-        signal.type.rawName = signal.type.name;
-        signal.normalizedType = signal.type.name;
-        signal.name = signalName.toUtf8();
-        signal.access = FunctionDef::Public;
-        signal.isSignal = true;
-
-        ArgumentDef arg;
-        arg.type.name = "const QVariant &";
-        arg.type.rawName = arg.type.name;
-        arg.normalizedType = "QVariant";
-        arg.name = "data";
-        arg.typeNameForCast = arg.normalizedType + "*";
-        signal.arguments << arg;
-
-        classDef.signalList << signal;
-    }
-
-    // event slots:
-    foreach (const QString &eventName, info.incomingEvents) {
-        FunctionDef slot;
-        slot.type.name = "void";
-        slot.type.rawName = slot.type.name;
-        slot.normalizedType = slot.type.name;
-        slot.name = eventName.toUtf8();
-        slot.access = FunctionDef::Public;
-        slot.isSlot = true;
-
-        ArgumentDef arg;
-        arg.type.name = "const QVariant &";
-        arg.type.rawName = arg.type.name;
-        arg.normalizedType = "QVariant";
-        arg.name = "data";
-        arg.typeNameForCast = arg.normalizedType + "*";
-        slot.arguments << arg;
-
-        classDef.slotList << slot;
-    }
-
-    foreach (const QString &eventName, info.incomingEvents) {
-        FunctionDef slot;
-        slot.type.name = "void";
-        slot.type.rawName = slot.type.name;
-        slot.normalizedType = slot.type.name;
-        slot.name = eventName.toUtf8();
-        slot.access = FunctionDef::Public;
-        slot.isSlot = true;
-
-        classDef.slotList << slot;
-    }
-
     QBuffer buf;
     buf.open(QIODevice::WriteOnly);
     Generator(&classDef, QList<QByteArray>(), knownQObjectClasses,
diff --git a/tools/qscxmlc/scxmlcppdumper.h b/tools/qscxmlc/scxmlcppdumper.h
index 981499f..e1abfc2 100644
--- a/tools/qscxmlc/scxmlcppdumper.h
+++ b/tools/qscxmlc/scxmlcppdumper.h
@@ -80,18 +80,9 @@ private:
     QString mangleIdentifier(const QString &str);
 
 private:
-    QString generatePropertyDecls(const QScxmlInternal::GeneratedTableData::MetaDataInfo &info,
-                                  bool qtMode);
-    QString generateSignalDecls(const QScxmlInternal::GeneratedTableData::MetaDataInfo &info);
-    QString generateSlotDecls(const QScxmlInternal::GeneratedTableData::MetaDataInfo &info);
-    QString generateSlotDefs(const QString &className,
-                             const QScxmlInternal::GeneratedTableData::MetaDataInfo &info);
-    QString generateGetterDecls(const QScxmlInternal::GeneratedTableData::MetaDataInfo &info);
-    QString generateGetterDefs(const QString &className,
-                               const QScxmlInternal::GeneratedTableData::MetaDataInfo &info);
+    QString generatePropertyDecls(const QScxmlInternal::GeneratedTableData::MetaDataInfo &info);
     QString generateMetaObject(const QString &className,
-                               const QScxmlInternal::GeneratedTableData::MetaDataInfo &info,
-                               bool m_qtMode);
+                               const QScxmlInternal::GeneratedTableData::MetaDataInfo &info);
 
     QTextStream &h;
     QTextStream &cpp;