Don't generate empty switch statements for C++ data models

Some compilers will complain about them.

Change-Id: I82bee601480e43ce00657d609d30179fe17e6bdb
Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>

2 files changed, 55 insertions, 44 deletions

diff --git a/tools/qscxmlc/cppdatamodel.t b/tools/qscxmlc/cppdatamodel.t
index 524571b..2ca5b16 100644
--- a/tools/qscxmlc/cppdatamodel.t
+++ b/tools/qscxmlc/cppdatamodel.t
@@ -1,42 +1,34 @@
 QString ${datamodel}::evaluateToString(QScxmlExecutableContent::EvaluatorId id, bool *ok)
 {
     *ok = true;
-    switch (id) {
-${evaluateToStringCases}    default:
-        Q_UNREACHABLE();
-        *ok = false;
-        return QString();
-    }
+${evaluateToStringCases}
+    Q_UNREACHABLE();
+    *ok = false;
+    return QString();
 }
 
 bool ${datamodel}::evaluateToBool(QScxmlExecutableContent::EvaluatorId id, bool *ok)
 {
     *ok = true;
-    switch (id) {
-${evaluateToBoolCases}    default:
-        Q_UNREACHABLE();
-        *ok = false;
-        return false;
-    }
+${evaluateToBoolCases}
+    Q_UNREACHABLE();
+    *ok = false;
+    return false;
 }
 
 QVariant ${datamodel}::evaluateToVariant(QScxmlExecutableContent::EvaluatorId id, bool *ok)
 {
     *ok = true;
-    switch (id) {
-${evaluateToVariantCases}    default:
-        Q_UNREACHABLE();
-        *ok = false;
-        return QVariant();
-    }
+${evaluateToVariantCases}
+    Q_UNREACHABLE();
+    *ok = false;
+    return QVariant();
 }
 
 void ${datamodel}::evaluateToVoid(QScxmlExecutableContent::EvaluatorId id, bool *ok)
 {
     *ok = true;
-    switch (id) {
-${evaluateToVoidCases}    default:
-        Q_UNREACHABLE();
-        *ok = false;
-    }
+${evaluateToVoidCases}
+    Q_UNREACHABLE();
+    *ok = false;
 }
diff --git a/tools/qscxmlc/scxmlcppdumper.cpp b/tools/qscxmlc/scxmlcppdumper.cpp
index 4d0e795..f4e6f8a 100644
--- a/tools/qscxmlc/scxmlcppdumper.cpp
+++ b/tools/qscxmlc/scxmlcppdumper.cpp
@@ -311,49 +311,68 @@ void generateTables(const GeneratedTableData &td, Replacements &replacements)
 void generateCppDataModelEvaluators(const GeneratedTableData::DataModelInfo &info,
                                     Replacements &replacements)
 {
-    {
-        QString evals;
+    const QString switchStart = QStringLiteral("    switch (id) {\n");
+    const QString switchEnd = QStringLiteral("    default: break;\n    }");
+    const QString unusedId = QStringLiteral("    Q_UNUSED(id);");
+    QString stringEvals;
+    if (!info.stringEvaluators.isEmpty()) {
+        stringEvals += switchStart;
         for (auto it = info.stringEvaluators.constBegin(), eit = info.stringEvaluators.constEnd();
              it != eit; ++it) {
-            evals += QStringLiteral("    case %1:\n").arg(it.key());
-            evals += QStringLiteral("        return [this]()->QString{ return %1; }();\n")
+            stringEvals += QStringLiteral("    case %1:\n").arg(it.key());
+            stringEvals += QStringLiteral("        return [this]()->QString{ return %1; }();\n")
                     .arg(it.value());
         }
-        replacements[QStringLiteral("evaluateToStringCases")] = evals;
+        stringEvals += switchEnd;
+    } else {
+        stringEvals += unusedId;
     }
+    replacements[QStringLiteral("evaluateToStringCases")] = stringEvals;
 
-    {
-        QString evals;
+    QString boolEvals;
+    if (!info.boolEvaluators.isEmpty()) {
+        boolEvals += switchStart;
         for (auto it = info.boolEvaluators.constBegin(), eit = info.boolEvaluators.constEnd();
              it != eit; ++it) {
-            evals += QStringLiteral("    case %1:\n").arg(it.key());
-            evals += QStringLiteral("        return [this]()->bool{ return %1; }();\n")
+            boolEvals += QStringLiteral("    case %1:\n").arg(it.key());
+            boolEvals += QStringLiteral("        return [this]()->bool{ return %1; }();\n")
                     .arg(it.value());
         }
-        replacements[QStringLiteral("evaluateToBoolCases")] = evals;
+        boolEvals += switchEnd;
+    } else {
+        boolEvals += unusedId;
     }
+    replacements[QStringLiteral("evaluateToBoolCases")] = boolEvals;
 
-    {
-        QString evals;
+    QString variantEvals;
+    if (!info.variantEvaluators.isEmpty()) {
+        variantEvals += switchStart;
         for (auto it = info.variantEvaluators.constBegin(), eit = info.variantEvaluators.constEnd();
              it != eit; ++it) {
-            evals += QStringLiteral("    case %1:\n").arg(it.key());
-            evals += QStringLiteral("        return [this]()->QVariant{ return %1; }();\n")
+            variantEvals += QStringLiteral("    case %1:\n").arg(it.key());
+            variantEvals += QStringLiteral("        return [this]()->QVariant{ return %1; }();\n")
                     .arg(it.value());
         }
-        replacements[QStringLiteral("evaluateToVariantCases")] = evals;
+        variantEvals += switchEnd;
+    } else {
+        variantEvals += unusedId;
     }
+    replacements[QStringLiteral("evaluateToVariantCases")] = variantEvals;
 
-    {
-        QString evals;
+    QString voidEvals;
+    if (!info.voidEvaluators.isEmpty()) {
+        voidEvals = switchStart;
         for (auto it = info.voidEvaluators.constBegin(), eit = info.voidEvaluators.constEnd();
              it != eit; ++it) {
-            evals += QStringLiteral("    case %1:\n").arg(it.key());
-            evals += QStringLiteral("        [this]()->void{ %1 }();\n").arg(it.value());
-            evals += QStringLiteral("        break;\n");
+            voidEvals += QStringLiteral("    case %1:\n").arg(it.key());
+            voidEvals += QStringLiteral("        [this]()->void{ %1 }();\n").arg(it.value());
+            voidEvals += QStringLiteral("        return;\n");
         }
-        replacements[QStringLiteral("evaluateToVoidCases")] = evals;
+        voidEvals += switchEnd;
+    } else {
+        voidEvals += unusedId;
     }
+    replacements[QStringLiteral("evaluateToVoidCases")] = voidEvals;
 }
 
 int createFactoryId(QStringList &factories, const QString &className,