QWaylandScanner: tidy up

This change

- standardizes on using boolean needsXy to handle join-style omissions
  of commas or newlines instead of inspecting the index of the element
  in various forms, which enables

- standardize on C++11 ranged for loops instead of indexed loops

- use braced initialization for structs, with designators, which are
  strictly a C++20 feature but are being used in QtWayland already, so
  should be safe (they originally come from C99).

Together, they make the code easier to understand, because the
variation of patterns used in the program is reduced.

Change-Id: Ib96620a9ecbe4ee47e59290ed758f0ec1bffcfd6
Reviewed-by: Johan Helsing <johan.helsing@qt.io>

1 files changed, 79 insertions, 81 deletions

diff --git a/src/qtwaylandscanner/qtwaylandscanner.cpp b/src/qtwaylandscanner/qtwaylandscanner.cpp
index 272c6abd2..da58fc567 100644
--- a/src/qtwaylandscanner/qtwaylandscanner.cpp
+++ b/src/qtwaylandscanner/qtwaylandscanner.cpp
@@ -189,18 +189,21 @@ bool Scanner::boolValue(const QXmlStreamReader &xml, const char *name)
 
 Scanner::WaylandEvent Scanner::readEvent(QXmlStreamReader &xml, bool request)
 {
-    WaylandEvent event;
-    event.request = request;
-    event.name = byteArrayValue(xml, "name");
-    event.type = byteArrayValue(xml, "type");
+    WaylandEvent event = {
+        .request = request,
+        .name = byteArrayValue(xml, "name"),
+        .type = byteArrayValue(xml, "type"),
+        .arguments = {},
+    };
     while (xml.readNextStartElement()) {
         if (xml.name() == "arg") {
-            WaylandArgument argument;
-            argument.name = byteArrayValue(xml, "name");
-            argument.type = byteArrayValue(xml, "type");
-            argument.interface = byteArrayValue(xml, "interface");
-            argument.summary = byteArrayValue(xml, "summary");
-            argument.allowNull = boolValue(xml, "allowNull");
+            WaylandArgument argument = {
+                .name      = byteArrayValue(xml, "name"),
+                .type      = byteArrayValue(xml, "type"),
+                .interface = byteArrayValue(xml, "interface"),
+                .summary   = byteArrayValue(xml, "summary"),
+                .allowNull = boolValue(xml, "allowNull"),
+            };
             event.arguments << argument;
         }
 
@@ -211,15 +214,18 @@ Scanner::WaylandEvent Scanner::readEvent(QXmlStreamReader &xml, bool request)
 
 Scanner::WaylandEnum Scanner::readEnum(QXmlStreamReader &xml)
 {
-    WaylandEnum result;
-    result.name = byteArrayValue(xml, "name");
+    WaylandEnum result = {
+        .name = byteArrayValue(xml, "name"),
+        .entries = {},
+    };
 
     while (xml.readNextStartElement()) {
         if (xml.name() == "entry") {
-            WaylandEnumEntry entry;
-            entry.name = byteArrayValue(xml, "name");
-            entry.value = byteArrayValue(xml, "value");
-            entry.summary = byteArrayValue(xml, "summary");
+            WaylandEnumEntry entry = {
+                .name    = byteArrayValue(xml, "name"),
+                .value   = byteArrayValue(xml, "value"),
+                .summary = byteArrayValue(xml, "summary"),
+            };
             result.entries << entry;
         }
 
@@ -231,9 +237,13 @@ Scanner::WaylandEnum Scanner::readEnum(QXmlStreamReader &xml)
 
 Scanner::WaylandInterface Scanner::readInterface(QXmlStreamReader &xml)
 {
-    WaylandInterface interface;
-    interface.name = byteArrayValue(xml, "name");
-    interface.version = intValue(xml, "version", 1);
+    WaylandInterface interface = {
+        .name = byteArrayValue(xml, "name"),
+        .version = intValue(xml, "version", 1),
+        .enums = {},
+        .events = {},
+        .requests = {},
+    };
 
     while (xml.readNextStartElement()) {
         if (xml.name() == "event")
@@ -285,9 +295,9 @@ QByteArray Scanner::waylandToQtType(const QByteArray &waylandType, const QByteAr
 
 const Scanner::WaylandArgument *Scanner::newIdArgument(const QList<WaylandArgument> &arguments)
 {
-    for (int i = 0; i < arguments.size(); ++i) {
-        if (arguments.at(i).type == "new_id")
-            return &arguments.at(i);
+    for (const WaylandArgument &a : arguments) {
+        if (a.type == "new_id")
+            return &a;
     }
     return nullptr;
 }
@@ -305,8 +315,7 @@ void Scanner::printEvent(const WaylandEvent &e, bool omitNames, bool withResourc
             needsComma = true;
         }
     }
-    for (int i = 0; i < e.arguments.size(); ++i) {
-        const WaylandArgument &a = e.arguments.at(i);
+    for (const WaylandArgument &a : e.arguments) {
         bool isNewId = a.type == "new_id";
         if (isNewId && !isServerSide() && (a.interface.isEmpty() != e.request))
             continue;
@@ -346,9 +355,8 @@ void Scanner::printEventHandlerSignature(const WaylandEvent &e, const char *inte
         printf("        %svoid *data,\n", indent);
         printf("        %sstruct ::%s *object", indent, interfaceName);
     }
-    for (int i = 0; i < e.arguments.size(); ++i) {
+    for (const WaylandArgument &a : e.arguments) {
         printf(",\n");
-        const WaylandArgument &a = e.arguments.at(i);
         bool isNewId = a.type == "new_id";
         if (isServerSide() && isNewId) {
             printf("        %suint32_t %s", indent, a.name.constData());
@@ -362,12 +370,10 @@ void Scanner::printEventHandlerSignature(const WaylandEvent &e, const char *inte
 
 void Scanner::printEnums(const QList<WaylandEnum> &enums)
 {
-    for (int i = 0; i < enums.size(); ++i) {
+    for (const WaylandEnum &e : enums) {
         printf("\n");
-        const WaylandEnum &e = enums.at(i);
         printf("        enum %s {\n", e.name.constData());
-        for (int i = 0; i < e.entries.size(); ++i) {
-            const WaylandEnumEntry &entry = e.entries.at(i);
+        for (const WaylandEnumEntry &entry : e.entries) {
             printf("            %s_%s = %s,", e.name.constData(), entry.name.constData(), entry.value.constData());
             if (!entry.summary.isNull())
                 printf(" // %s", entry.summary.constData());
@@ -476,12 +482,16 @@ bool Scanner::process()
         printf("\n");
         printf("namespace QtWaylandServer {\n");
 
-        for (int j = 0; j < interfaces.size(); ++j) {
-            const WaylandInterface &interface = interfaces.at(j);
+        bool needsNewLine = false;
+        for (const WaylandInterface &interface : interfaces) {
 
             if (ignoreInterface(interface.name))
                 continue;
 
+            if (needsNewLine)
+                printf("\n");
+            needsNewLine = true;
+
             const char *interfaceName = interface.name.constData();
 
             QByteArray stripped = stripInterfaceName(interface.name);
@@ -582,8 +592,7 @@ bool Scanner::process()
                 printf("        static const struct ::%s_interface m_%s_interface;\n", interfaceName, interfaceName);
 
                 printf("\n");
-                for (int i = 0; i < interface.requests.size(); ++i) {
-                    const WaylandEvent &e = interface.requests.at(i);
+                for (const WaylandEvent &e : interface.requests) {
                     printf("        static void ");
 
                     printEventHandlerSignature(e, interfaceName);
@@ -601,9 +610,6 @@ bool Scanner::process()
             printf("        };\n");
             printf("        DisplayDestroyedListener m_displayDestroyedListener;\n");
             printf("    };\n");
-
-            if (j < interfaces.size() - 1)
-                printf("\n");
         }
 
         printf("}\n");
@@ -627,8 +633,7 @@ bool Scanner::process()
         printf("namespace QtWaylandServer {\n");
 
         bool needsNewLine = false;
-        for (int j = 0; j < interfaces.size(); ++j) {
-            const WaylandInterface &interface = interfaces.at(j);
+        for (const WaylandInterface &interface : interfaces) {
 
             if (ignoreInterface(interface.name))
                 continue;
@@ -814,11 +819,12 @@ bool Scanner::process()
             if (hasRequests) {
                 printf("\n");
                 printf("    const struct ::%s_interface %s::m_%s_interface = {", interfaceName, interfaceName, interfaceName);
-                for (int i = 0; i < interface.requests.size(); ++i) {
-                    if (i > 0)
+                bool needsComma = false;
+                for (const WaylandEvent &e : interface.requests) {
+                    if (needsComma)
                         printf(",");
+                    needsComma = true;
                     printf("\n");
-                    const WaylandEvent &e = interface.requests.at(i);
                     printf("        %s::handle_%s", interfaceName, e.name.constData());
                 }
                 printf("\n");
@@ -834,11 +840,10 @@ bool Scanner::process()
                 }
                 printf("\n");
 
-                for (int i = 0; i < interface.requests.size(); ++i) {
+                for (const WaylandEvent &e : interface.requests) {
                     printf("\n");
                     printf("    void %s::", interfaceName);
 
-                    const WaylandEvent &e = interface.requests.at(i);
                     printEventHandlerSignature(e, interfaceName, false);
 
                     printf("\n");
@@ -847,9 +852,8 @@ bool Scanner::process()
                     printf("        Resource *r = Resource::fromResource(resource);\n");
                     printf("        static_cast<%s *>(r->%s_object)->%s_%s(\n", interfaceName, interfaceNameStripped, interfaceNameStripped, e.name.constData());
                     printf("            r");
-                    for (int i = 0; i < e.arguments.size(); ++i) {
+                    for (const WaylandArgument &a : e.arguments) {
                         printf(",\n");
-                        const WaylandArgument &a = e.arguments.at(i);
                         QByteArray cType = waylandToCType(a.type, a.interface);
                         QByteArray qtType = waylandToQtType(a.type, a.interface, e.request);
                         const char *argumentName = a.name.constData();
@@ -863,17 +867,15 @@ bool Scanner::process()
                 }
             }
 
-            for (int i = 0; i < interface.events.size(); ++i) {
+            for (const WaylandEvent &e : interface.events) {
                 printf("\n");
-                const WaylandEvent &e = interface.events.at(i);
                 printf("    void %s::send_", interfaceName);
                 printEvent(e);
                 printf("\n");
                 printf("    {\n");
                 printf("        send_%s(\n", e.name.constData());
                 printf("            m_resource->handle");
-                for (int i = 0; i < e.arguments.size(); ++i) {
-                    const WaylandArgument &a = e.arguments.at(i);
+                for (const WaylandArgument &a : e.arguments) {
                     printf(",\n");
                     printf("            %s", a.name.constData());
                 }
@@ -886,8 +888,7 @@ bool Scanner::process()
                 printf("\n");
                 printf("    {\n");
 
-                for (int i = 0; i < e.arguments.size(); ++i) {
-                    const WaylandArgument &a = e.arguments.at(i);
+                for (const WaylandArgument &a : e.arguments) {
                     if (a.type != "array")
                         continue;
                     QByteArray array = a.name + "_data";
@@ -903,8 +904,7 @@ bool Scanner::process()
                 printf("        %s_send_%s(\n", interfaceName, e.name.constData());
                 printf("            resource");
 
-                for (int i = 0; i < e.arguments.size(); ++i) {
-                    const WaylandArgument &a = e.arguments.at(i);
+                for (const WaylandArgument &a : e.arguments) {
                     printf(",\n");
                     QByteArray cType = waylandToCType(a.type, a.interface);
                     QByteArray qtType = waylandToQtType(a.type, a.interface, e.request);
@@ -960,12 +960,17 @@ bool Scanner::process()
         }
         printf("\n");
         printf("namespace QtWayland {\n");
-        for (int j = 0; j < interfaces.size(); ++j) {
-            const WaylandInterface &interface = interfaces.at(j);
+
+        bool needsNewLine = false;
+        for (const WaylandInterface &interface : interfaces) {
 
             if (ignoreInterface(interface.name))
                 continue;
 
+            if (needsNewLine)
+                printf("\n");
+            needsNewLine = true;
+
             const char *interfaceName = interface.name.constData();
 
             QByteArray stripped = stripInterfaceName(interface.name);
@@ -1026,8 +1031,7 @@ bool Scanner::process()
             if (hasEvents) {
                 printf("        void init_listener();\n");
                 printf("        static const struct %s_listener m_%s_listener;\n", interfaceName, interfaceName);
-                for (int i = 0; i < interface.events.size(); ++i) {
-                    const WaylandEvent &e = interface.events.at(i);
+                for (const WaylandEvent &e : interface.events) {
                     printf("        static void ");
 
                     printEventHandlerSignature(e, interfaceName);
@@ -1036,9 +1040,6 @@ bool Scanner::process()
             }
             printf("        struct ::%s *m_%s;\n", interfaceName, interfaceName);
             printf("    };\n");
-
-            if (j < interfaces.size() - 1)
-                printf("\n");
         }
         printf("}\n");
         printf("\n");
@@ -1075,12 +1076,17 @@ bool Scanner::process()
         printf("#endif\n");
         printf("}\n");
         printf("\n");
-        for (int j = 0; j < interfaces.size(); ++j) {
-            const WaylandInterface &interface = interfaces.at(j);
+
+        bool needsNewLine = false;
+        for (const WaylandInterface &interface : interfaces) {
 
             if (ignoreInterface(interface.name))
                 continue;
 
+            if (needsNewLine)
+                printf("\n");
+            needsNewLine = true;
+
             const char *interfaceName = interface.name.constData();
 
             QByteArray stripped = stripInterfaceName(interface.name);
@@ -1150,9 +1156,8 @@ bool Scanner::process()
             printf("        return &::%s_interface;\n", interfaceName);
             printf("    }\n");
 
-            for (int i = 0; i < interface.requests.size(); ++i) {
+            for (const WaylandEvent &e : interface.requests) {
                 printf("\n");
-                const WaylandEvent &e = interface.requests.at(i);
                 const WaylandArgument *new_id = newIdArgument(e.arguments);
                 QByteArray new_id_str = "void ";
                 if (new_id) {
@@ -1165,8 +1170,7 @@ bool Scanner::process()
                 printEvent(e);
                 printf("\n");
                 printf("    {\n");
-                for (int i = 0; i < e.arguments.size(); ++i) {
-                    const WaylandArgument &a = e.arguments.at(i);
+                for (const WaylandArgument &a : e.arguments) {
                     if (a.type != "array")
                         continue;
                     QByteArray array = a.name + "_data";
@@ -1182,8 +1186,7 @@ bool Scanner::process()
                 printf("        %s%s_%s(\n", new_id ? "return " : "", interfaceName, e.name.constData());
                 printf("            m_%s%s", interfaceName, actualArgumentCount > 0 ? "," : "");
                 bool needsComma = false;
-                for (int i = 0; i < e.arguments.size(); ++i) {
-                    const WaylandArgument &a = e.arguments.at(i);
+                for (const WaylandArgument &a : e.arguments) {
                     bool isNewId = a.type == "new_id";
                     if (isNewId && !a.interface.isEmpty())
                         continue;
@@ -1213,8 +1216,7 @@ bool Scanner::process()
 
             if (hasEvents) {
                 printf("\n");
-                for (int i = 0; i < interface.events.size(); ++i) {
-                    const WaylandEvent &e = interface.events.at(i);
+                for (const WaylandEvent &e : interface.events) {
                     printf("    void %s::%s_", interfaceName, interfaceNameStripped);
                     printEvent(e, true);
                     printf("\n");
@@ -1227,17 +1229,17 @@ bool Scanner::process()
                     printf("    {\n");
                     printf("        Q_UNUSED(object);\n");
                     printf("        static_cast<%s *>(data)->%s_%s(", interfaceName, interfaceNameStripped, e.name.constData());
-                    for (int i = 0; i < e.arguments.size(); ++i) {
+                    bool needsComma = false;
+                    for (const WaylandArgument &a : e.arguments) {
+                        if (needsComma)
+                            printf(",");
+                        needsComma = true;
                         printf("\n");
-                        const WaylandArgument &a = e.arguments.at(i);
                         const char *argumentName = a.name.constData();
                         if (a.type == "string")
                             printf("            QString::fromUtf8(%s)", argumentName);
                         else
                             printf("            %s", argumentName);
-
-                        if (i < e.arguments.size() - 1)
-                            printf(",");
                     }
                     printf(");\n");
 
@@ -1245,8 +1247,7 @@ bool Scanner::process()
                     printf("\n");
                 }
                 printf("    const struct %s_listener %s::m_%s_listener = {\n", interfaceName, interfaceName, interfaceName);
-                for (int i = 0; i < interface.events.size(); ++i) {
-                    const WaylandEvent &e = interface.events.at(i);
+                for (const WaylandEvent &e : interface.events) {
                     printf("        %s::handle_%s,\n", interfaceName, e.name.constData());
                 }
                 printf("    };\n");
@@ -1257,9 +1258,6 @@ bool Scanner::process()
                 printf("        %s_add_listener(m_%s, &m_%s_listener, this);\n", interfaceName, interfaceName, interfaceName);
                 printf("    }\n");
             }
-
-            if (j < interfaces.size() - 1)
-                printf("\n");
         }
         printf("}\n");
         printf("\n");