Add github actions

Author: wengxt

.clang-format

@@ -0,0 +1,58 @@
+---
+Language:        Cpp
+# BasedOnStyle:  LLVM
+AccessModifierOffset: -4
+ConstructorInitializerIndentWidth: 4
+AlignEscapedNewlinesLeft: false
+AlignTrailingComments: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortBlocksOnASingleLine: false
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: All
+AlwaysBreakTemplateDeclarations: true
+AlwaysBreakBeforeMultilineStrings: false
+BreakBeforeBinaryOperators: false
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+BinPackParameters: true
+ColumnLimit:     80
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+DerivePointerAlignment: false
+ExperimentalAutoDetectBinPacking: false
+IndentCaseLabels: false
+IndentWrappedFunctionNames: false
+IndentFunctionDeclarationAfterType: false
+MaxEmptyLinesToKeep: 1
+KeepEmptyLinesAtTheStartOfBlocks: true
+NamespaceIndentation: None
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakComment: 300
+PenaltyBreakString: 1000
+PenaltyBreakFirstLessLess: 120
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 60
+PointerAlignment: Right
+SpacesBeforeTrailingComments: 1
+Cpp11BracedListStyle: true
+Standard:        Cpp11
+IndentWidth:     4
+TabWidth:        4
+UseTab:          Never
+BreakBeforeBraces: Attach
+SpacesInParentheses: false
+SpacesInAngles:  false
+SpaceInEmptyParentheses: false
+SpacesInCStyleCastParentheses: false
+SpacesInContainerLiterals: true
+SpaceBeforeAssignmentOperators: true
+ContinuationIndentWidth: 4
+CommentPragmas:  '^ IWYU pragma:'
+ForEachMacros:   [ Q_FOREACH, BOOST_FOREACH ]
+SpaceBeforeParens: ControlStatements
+DisableFormat:   false
+SortIncludes: true
+...
+

.github/workflows/check.yml

@@ -0,0 +1,46 @@
+name: CI
+on:
+  push:
+    branches:
+     - main
+  pull_request:
+    branches:
+      - main
+jobs:
+  clang-format:
+    name: Check clang-format
+    runs-on: ubuntu-latest
+    container: archlinux:latest
+    steps:
+      - name: Install dependencies
+        run: |
+          pacman -Syu --noconfirm git clang diffutils
+          git config --global --add safe.directory $GITHUB_WORKSPACE
+      - uses: actions/checkout@v4
+      - uses: fcitx/github-actions@clang-format
+  check:
+    name: Build and test
+    needs: clang-format
+    runs-on: ubuntu-latest
+    container: archlinux:latest
+    strategy:
+      fail-fast: false
+      matrix:
+        compiler: [gcc, clang]
+        include:
+          - compiler: gcc
+            cxx_compiler: g++
+          - compiler: clang
+            cxx_compiler: clang++
+    env:
+      CC: ${{ matrix.compiler }}
+      CXX: ${{ matrix.cxx_compiler }}
+    steps:
+      - name: Install dependencies
+        run: |
+          pacman -Syu --noconfirm base-devel clang cmake ninja extra-cmake-modules qt6-base ktexttemplate
+      - uses: actions/checkout@v4
+      - name: Build and Install fcitx5-configtool
+        uses: fcitx/github-actions@cmake
+        with:
+          path: .

src/main.cpp

@@ -5,62 +5,63 @@
  *
  */
 
-#include <cstdlib>
+#include "protocol.h"
 #include <QCommandLineOption>
 #include <QCommandLineParser>
 #include <QCoreApplication>
 #include <QLatin1String>
 #include <QLoggingCategory>
 #include <QtLogging>
+#include <cstdlib>
 #include <ktexttemplate/metatype.h>
 #include <qcontainerfwd.h>
-#include "protocol.h"
 
 Q_LOGGING_CATEGORY(generator, "generator");
 
 QtMessageHandler defaultHandler = nullptr;
 
 void logHandler(const QtMsgType type, const QMessageLogContext &context,
-           const QString &msg) {
-  defaultHandler(type, context, msg);
-  if (context.category == QLatin1String("generator") && type == QtCriticalMsg) {
-    ::exit(1);
-  }
+                const QString &msg) {
+    defaultHandler(type, context, msg);
+    if (context.category == QLatin1String("generator") &&
+        type == QtCriticalMsg) {
+        ::exit(1);
+    }
 }
 
 int main(int argc, char *argv[]) {
-  defaultHandler = qInstallMessageHandler(logHandler);
-  QCoreApplication app(argc, argv);
-  QCommandLineParser parser;
+    defaultHandler = qInstallMessageHandler(logHandler);
+    QCoreApplication app(argc, argv);
+    QCommandLineParser parser;
 
-  parser.addOption(QCommandLineOption(
-      "includes", "Comma-separated list of extra includes.", "includes"));
-  parser.addOption(QCommandLineOption(
-      "namespace", "Namespace for the generated code.", "namespace"));
-  parser.addOption(
-      QCommandLineOption("directory", "Output directory.", "directory", "."));
-  parser.addHelpOption();
-  parser.addPositionalArgument("files", "Input files.",
-                               "[deps_protocol_file] main_protocol_file");
-  parser.process(app);
+    parser.addOption(QCommandLineOption(
+        "includes", "Comma-separated list of extra includes.", "includes"));
+    parser.addOption(QCommandLineOption(
+        "namespace", "Namespace for the generated code.", "namespace"));
+    parser.addOption(
+        QCommandLineOption("directory", "Output directory.", "directory", "."));
+    parser.addHelpOption();
+    parser.addPositionalArgument("files", "Input files.",
+                                 "[deps_protocol_file] main_protocol_file");
+    parser.process(app);
 
-  EmitOptions options;
-  if (parser.isSet("includes")) {
-    options.extraIncludes_ = parser.values("includes");
-  }
-  if (parser.isSet("namespace")) {
-    options.namespaces_ = parser.value("namespace").split("::");
-  }
-  options.directory_ = parser.value("directory");
+    EmitOptions options;
+    if (parser.isSet("includes")) {
+        options.extraIncludes_ = parser.values("includes");
+    }
+    if (parser.isSet("namespace")) {
+        options.namespaces_ = parser.value("namespace").split("::");
+    }
+    options.directory_ = parser.value("directory");
 
-  const auto filenames = parser.positionalArguments();
+    const auto filenames = parser.positionalArguments();
 
-  KTextTemplate::registerMetaType<Message>();
-  KTextTemplate::registerMetaType<Message *>();
-  KTextTemplate::registerMetaType<Argument>();
+    KTextTemplate::registerMetaType<Message>();
+    KTextTemplate::registerMetaType<Message *>();
+    KTextTemplate::registerMetaType<Argument>();
 
-  Protocol protocol(filenames);
-  protocol.generate(options);
+    Protocol protocol(filenames);
+    protocol.generate(options);
 
-  return 0;
+    return 0;
 }

src/parser.cpp

@@ -18,18 +18,18 @@
  */
 
 #include "parser.h"
-#include <list>
-#include <memory>
-#include <utility>
+#include "protocol.h"
 #include <QDebug>
 #include <QFile>
+#include <QLoggingCategory>
+#include <QStringView>
 #include <QXmlStreamReader>
 #include <QtLogging>
+#include <list>
+#include <memory>
 #include <qdebug.h>
 #include <qlogging.h>
-#include <QStringView>
-#include <QLoggingCategory>
-#include "protocol.h"
+#include <utility>
 
 Q_DECLARE_LOGGING_CATEGORY(generator);
 
@@ -78,7 +78,8 @@ void ParseContext::startElement(QStringView element_name,
             bool ok = false;
             version = att.value().toUInt(&ok);
             if (!ok) {
-                qCCritical(generator) << "wrong version (" << att.value() << ")";
+                qCCritical(generator)
+                    << "wrong version (" << att.value() << ")";
             }
         }
         if (att.name() == "type") {
@@ -151,8 +152,9 @@ void ParseContext::startElement(QStringView element_name,
             if (!ok) {
                 qCCritical(generator) << "invalid integer (" << since << ")";
             } else if (version > interface_->version_) {
-                qCCritical(generator) << "since (" << version << ") larger than version ("
-                         << interface_->version_ << ")";
+                qCCritical(generator)
+                    << "since (" << version << ") larger than version ("
+                    << interface_->version_ << ")";
             }
         } else {
             version = 1;
@@ -165,7 +167,8 @@ void ParseContext::startElement(QStringView element_name,
         message_->since_ = version;
 
         if (name == "destroy" && !message_->destructor_) {
-            qCCritical(generator) << "destroy request should be destructor type";
+            qCCritical(generator)
+                << "destroy request should be destructor type";
         }
     } else if (element_name == "arg") {
         if (name.isEmpty()) {
@@ -187,7 +190,8 @@ void ParseContext::startElement(QStringView element_name,
             break;
         default:
             if (!interface_name.isEmpty()) {
-                qCCritical(generator) << "interface attribute not allowed for type " << type;
+                qCCritical(generator)
+                    << "interface attribute not allowed for type " << type;
             }
             break;
         }
@@ -198,13 +202,15 @@ void ParseContext::startElement(QStringView element_name,
             } else if (allow_null == "false") {
                 arg->nullable_ = false;
             } else {
-                qCCritical(generator) << "invalid value for allow-null attribute ("
-                         << allow_null << ")";
+                qCCritical(generator)
+                    << "invalid value for allow-null attribute (" << allow_null
+                    << ")";
             }
 
             if (!arg->isNullableType()) {
-                qCCritical(generator) << "allow-null is only valid for objects, strings, "
-                            "and arrays";
+                qCCritical(generator)
+                    << "allow-null is only valid for objects, strings, "
+                       "and arrays";
             }
         }
 
@@ -223,9 +229,10 @@ void ParseContext::startElement(QStringView element_name,
         } else if (bitfield == "true") {
             enumeration_->bitfield_ = true;
         } else {
-            qCCritical(generator) << "invalid value (" << bitfield
-                     << ") for bitfield attribute (only true/false "
-                        "are accepted)";
+            qCCritical(generator)
+                << "invalid value (" << bitfield
+                << ") for bitfield attribute (only true/false "
+                   "are accepted)";
         }
     } else if (element_name == "entry") {
         if (name.isEmpty()) {
@@ -239,33 +246,37 @@ void ParseContext::startElement(QStringView element_name,
     }
 }
 
-void ParseContext::verifyArguments(Interface *interface,
-                                   std::list<Message> *messages,
-                                   std::list<Enumeration> * /*enumerations*/) const {
+void ParseContext::verifyArguments(
+    Interface *interface, std::list<Message> *messages,
+    std::list<Enumeration> * /*enumerations*/) const {
     for (auto &m : *messages) {
         for (auto &a : m.argList_) {
 
             if (a.enumerationName_.isEmpty()) {
                 continue;
             }
 
-            const auto *e = protocol_->findEnumeration(interface, a.enumerationName_);
+            const auto *e =
+                protocol_->findEnumeration(interface, a.enumerationName_);
 
             if (!e) {
-                qCCritical(generator) << "could not find enumeration " << a.enumerationName_;
+                qCCritical(generator)
+                    << "could not find enumeration " << a.enumerationName_;
             }
 
             switch (a.type_) {
             case INT:
                 if (e->bitfield_) {
-                    qCCritical(generator) << "bitfield-style enum must only be referenced "
-                                "by uint";
+                    qCCritical(generator)
+                        << "bitfield-style enum must only be referenced "
+                           "by uint";
                 }
                 break;
             case UNSIGNED:
                 break;
             default:
-                qCCritical(generator) << "enumeration-style argument has wrong type";
+                qCCritical(generator)
+                    << "enumeration-style argument has wrong type";
             }
         }
     }
@@ -290,7 +301,8 @@ void ParseContext::endElement(QStringView name) {
         message_ = nullptr;
     } else if (name == "enum") {
         if (enumeration_->entryList_.empty()) {
-            qCCritical(generator) << "enumeration " << enumeration_->name_ << " was empty";
+            qCCritical(generator)
+                << "enumeration " << enumeration_->name_ << " was empty";
         }
         enumeration_ = nullptr;
     } else if (name == "protocol") {

src/parser.h

@@ -7,12 +7,12 @@
 #ifndef _GENERATOR_PARSER_H_
 #define _GENERATOR_PARSER_H_
 
-#include <list>
 #include "protocol.h"
 #include "utils.h"
-#include <QXmlStreamReader>
 #include <QFile>
 #include <QStringView>
+#include <QXmlStreamReader>
+#include <list>
 
 struct Protocol;
 struct Message;
@@ -27,19 +27,16 @@ struct ParseContext {
 
     void parse();
 
-    void verifyArguments(Interface *interface, std::list<Message> *messages, std::list<Enumeration> *enumerations) const;
+    void verifyArguments(Interface *interface, std::list<Message> *messages,
+                         std::list<Enumeration> *enumerations) const;
 
     void startElement(QStringView name, const QXmlStreamAttributes &atts);
     void endElement(QStringView name);
     void characterData(QStringView text);
 
-    void setLineNumber(int lineNumber) {
-        loc_.lineNumber_ = lineNumber;
-    }
+    void setLineNumber(int lineNumber) { loc_.lineNumber_ = lineNumber; }
 
-    const Location &location() const {
-        return loc_;
-    }
+    const Location &location() const { return loc_; }
 
     bool main_;
     QXmlStreamReader reader_;

src/protocol.cpp

@@ -6,11 +6,8 @@
  */
 
 #include "protocol.h"
-#include <algorithm>
-#include <iostream>
-#include <list>
-#include <set>
-#include <vector>
+#include "parser.h"
+#include "utils.h"
 #include <KTextTemplate/Context>
 #include <KTextTemplate/Engine>
 #include <KTextTemplate/FileSystemTemplateLoader>
@@ -26,9 +23,12 @@
 #include <QVariant>
 #include <QVariantHash>
 #include <QtLogging>
+#include <algorithm>
+#include <iostream>
+#include <list>
 #include <qbytearrayview.h>
-#include "parser.h"
-#include "utils.h"
+#include <set>
+#include <vector>
 
 using namespace Qt::Literals::StringLiterals;
 

src/protocol.h

@@ -7,18 +7,18 @@
 #ifndef _GENERATOR_PROTOCOL_H_
 #define _GENERATOR_PROTOCOL_H_
 
-#include <list>
-#include <memory>
-#include <optional>
-#include <set>
-#include <utility>
+#include "utils.h"
 #include <KTextTemplate/MetaType>
 #include <KTextTemplate/TypeAccessor>
 #include <QMetaType>
 #include <QString>
 #include <QStringList>
 #include <QStringView>
-#include "utils.h"
+#include <list>
+#include <memory>
+#include <optional>
+#include <set>
+#include <utility>
 
 struct Message;
 struct Enumeration;

src/utils.h

@@ -7,10 +7,10 @@
 #ifndef _GENERATOR_UTILS_H_
 #define _GENERATOR_UTILS_H_
 
+#include <QString>
 #include <cctype>
 #include <climits>
 #include <cstdarg>
-#include <QString>
 #include <qtypes.h>
 
 struct Location {