feat: add Konsole recipe source and patches

2026-05-07 07:54:52 +01:00
parent 171a96c6af
commit ab85eb7b3d
632 changed files with 713138 additions and 3 deletions
@@ -0,0 +1,402 @@
+/*
+    This file is part of Konsole, a terminal emulator for KDE.
+
+    SPDX-FileCopyrightText: 2018 Mariusz Glebocki <mglb@arccos-1.net>
+
+    SPDX-License-Identifier: GPL-2.0-or-later
+*/
+
+#include "template.h"
+#include <QDebug>
+#include <QRegularExpression>
+
+static const QString unescape(const QStringRef &str)
+{
+    QString result;
+    result.reserve(str.length());
+    for (int i = 0; i < str.length(); ++i) {
+        if (i < str.length() - 1 && str[i] == QLatin1Char('\\'))
+            result += str[++i];
+        else
+            result += str[i];
+    }
+    return result;
+}
+
+//
+// Template::Element
+//
+const QString Template::Element::findFmt(Var::DataType type) const
+{
+    const Template::Element *element;
+    for (element = this; element != nullptr; element = element->parent) {
+        if (!element->fmt.isEmpty() && isValidFmt(element->fmt, type)) {
+            return element->fmt;
+        }
+    }
+    return defaultFmt(type);
+}
+
+QString Template::Element::path() const
+{
+    QStringList namesList;
+    const Template::Element *element;
+    for (element = this; element != nullptr; element = element->parent) {
+        if (!element->hasName() && element->parent != nullptr) {
+            QString anonName = QStringLiteral("[anon]");
+            for (int i = 0; i < element->parent->children.size(); ++i) {
+                if (&element->parent->children[i] == element) {
+                    anonName = QStringLiteral("[%1]").arg(i);
+                    break;
+                }
+            }
+            namesList.prepend(anonName);
+        } else {
+            namesList.prepend(element->name);
+        }
+    }
+    return namesList.join(QLatin1Char('.'));
+}
+
+const QString Template::Element::defaultFmt(Var::DataType type)
+{
+    switch (type) {
+    case Var::DataType::Number:
+        return QStringLiteral("%d");
+    case Var::DataType::String:
+        return QStringLiteral("%s");
+    default:
+        Q_UNREACHABLE();
+    }
+}
+
+bool Template::Element::isValidFmt(const QString &fmt, Var::DataType type)
+{
+    switch (type) {
+    case Var::DataType::String:
+        return fmt.endsWith(QLatin1Char('s'));
+    case Var::DataType::Number:
+        return true; // regexp in parser takes care of it
+    default:
+        return false;
+    }
+}
+
+//
+// Template
+//
+
+Template::Template(const QString &text)
+    : _text(text)
+{
+    _root.name = QStringLiteral("[root]");
+    _root.outer = QStringRef(&_text);
+    _root.inner = QStringRef(&_text);
+    _root.parent = nullptr;
+    _root.line = 1;
+    _root.column = 1;
+}
+
+void Template::parse()
+{
+    _root.children.clear();
+    _root.outer = QStringRef(&_text);
+    _root.inner = QStringRef(&_text);
+    parseRecursively(_root);
+    //    dbgDumpTree(_root);
+}
+
+QString Template::generate(const Var &data)
+{
+    QString result;
+    result.reserve(_text.size());
+    generateRecursively(result, _root, data);
+    return result;
+}
+
+static inline void warn(const Template::Element &element, const QString &id, const QString &msg)
+{
+    const QString path = id.isEmpty() ? element.path() : Template::Element(&element, id).path();
+    qWarning() << QStringLiteral("Warning: %1:%2: %3: %4").arg(element.line).arg(element.column).arg(path, msg);
+}
+static inline void warn(const Template::Element &element, const QString &msg)
+{
+    warn(element, QString(), msg);
+}
+
+void Template::executeCommand(Element &element, const Template::Element &childStub, const QStringList &argv)
+{
+    // Insert content N times
+    if (argv[0] == QStringLiteral("repeat")) {
+        bool ok;
+        unsigned count = argv.value(1).toInt(&ok);
+        if (!ok || count < 1) {
+            warn(element, QStringLiteral("!") + argv[0], QStringLiteral("invalid repeat count (%1), assuming 0.").arg(argv[1]));
+            return;
+        }
+
+        element.children.append(childStub);
+        Template::Element &cmdElement = element.children.last();
+        if (!cmdElement.inner.isEmpty()) {
+            // Parse children
+            parseRecursively(cmdElement);
+            // Remember how many children was there before replication
+            int originalChildrenCount = cmdElement.children.size();
+            // Replicate children
+            for (unsigned i = 1; i < count; ++i) {
+                for (int chId = 0; chId < originalChildrenCount; ++chId) {
+                    cmdElement.children.append(cmdElement.children[chId]);
+                }
+            }
+        }
+        // Set printf-like format (with leading %) applied for strings and numbers
+        // inside the group
+    } else if (argv[0] == QStringLiteral("fmt")) {
+        static const QRegularExpression FMT_RE(QStringLiteral(R":(^%[-0 +#]?(?:[1-9][0-9]*)?\.?[0-9]*[diouxXs]$):"));
+        const auto match = FMT_RE.match(argv.value(1));
+        QString fmt = QStringLiteral("");
+        if (!match.hasMatch())
+            warn(element, QStringLiteral("!") + argv[0], QStringLiteral("invalid format (%1), assuming default").arg(argv[1]));
+        else
+            fmt = match.captured();
+
+        element.children.append(childStub);
+        Template::Element &cmdElement = element.children.last();
+        cmdElement.fmt = fmt;
+        parseRecursively(cmdElement);
+    }
+}
+
+void Template::parseRecursively(Element &element)
+{
+    static const QRegularExpression RE(QStringLiteral(R":((?'comment'«\*(([^:]*):)?.*?(?(-2):\g{-1})\*»)|):"
+                                                      R":(«(?:(?'name'[-_a-zA-Z0-9]*)|(?:!(?'cmd'[-_a-zA-Z0-9]+(?: +(?:[^\\:]+|(?:\\.)+)+)?)))):"
+                                                      R":((?::(?:~[ \t]*\n)?(?'inner'(?:[^«]*?|(?R))*))?(?:\n[ \t]*~)?»):"),
+                                       QRegularExpression::DotMatchesEverythingOption | QRegularExpression::MultilineOption);
+    static const QRegularExpression CMD_SPLIT_RE(QStringLiteral(R":((?:"((?:(?:\\.)*|[^"]*)*)"|(?:[^\\ "]+|(?:\\.)+)+)):"),
+                                                 QRegularExpression::DotMatchesEverythingOption | QRegularExpression::MultilineOption);
+    static const QRegularExpression UNESCAPE_RE(QStringLiteral(R":(\\(.)):"),
+                                                QRegularExpression::DotMatchesEverythingOption | QRegularExpression::MultilineOption);
+    static const QString nameGroupName = QStringLiteral("name");
+    static const QString innerGroupName = QStringLiteral("inner");
+    static const QString cmdGroupName = QStringLiteral("cmd");
+    static const QString commentGroupName = QStringLiteral("comment");
+
+    int posOffset = element.outer.position();
+    uint posLine = element.line;
+    uint posColumn = element.column;
+
+    auto matchIter = RE.globalMatch(element.inner);
+    while (matchIter.hasNext()) {
+        auto match = matchIter.next();
+        auto cmd = match.captured(cmdGroupName);
+        auto comment = match.captured(commentGroupName);
+
+        const auto localOuterRef = match.capturedRef(0);
+        const auto localInnerRef = match.capturedRef(innerGroupName);
+
+        auto outerRef = QStringRef(&_text, localOuterRef.position(), localOuterRef.length());
+        auto innerRef = QStringRef(&_text, localInnerRef.position(), localInnerRef.length());
+
+        while (posOffset < outerRef.position() && posOffset < _text.size()) {
+            if (_text[posOffset++] == QLatin1Char('\n')) {
+                ++posLine;
+                posColumn = 1;
+            } else {
+                ++posColumn;
+            }
+        }
+
+        if (!cmd.isEmpty()) {
+            QStringList cmdArgv;
+            auto cmdArgIter = CMD_SPLIT_RE.globalMatch(cmd);
+            while (cmdArgIter.hasNext()) {
+                auto cmdArg = cmdArgIter.next();
+                cmdArgv += cmdArg.captured(cmdArg.captured(1).isEmpty() ? 0 : 1);
+                cmdArgv.last().replace(UNESCAPE_RE, QStringLiteral("\1"));
+            }
+
+            Template::Element childStub = Template::Element(&element);
+            childStub.outer = outerRef;
+            childStub.name = QLatin1Char('!') + cmd;
+            childStub.inner = innerRef;
+            childStub.line = posLine;
+            childStub.column = posColumn;
+            executeCommand(element, childStub, cmdArgv);
+        } else if (!comment.isEmpty()) {
+            element.children.append(Element(&element));
+            Template::Element &child = element.children.last();
+            child.outer = outerRef;
+            child.name = QString();
+            child.inner = QStringRef();
+            child.line = posLine;
+            child.column = posColumn;
+            child.isComment = true;
+        } else {
+            element.children.append(Element(&element));
+            Template::Element &child = element.children.last();
+            child.outer = outerRef;
+            child.name = match.captured(nameGroupName);
+            child.inner = innerRef;
+            child.line = posLine;
+            child.column = posColumn;
+            if (!child.inner.isEmpty())
+                parseRecursively(child);
+        }
+    }
+}
+
+int Template::generateRecursively(QString &result, const Template::Element &element, const Var &data, int consumed)
+{
+    int consumedDataItems = consumed;
+
+    if (!element.children.isEmpty()) {
+        int totalDataItems;
+        switch (data.dataType()) {
+        case Var::DataType::Number:
+        case Var::DataType::String:
+        case Var::DataType::Map:
+            totalDataItems = 1;
+            break;
+        case Var::DataType::Vector:
+            totalDataItems = data.vec.size();
+            break;
+        case Var::DataType::Invalid:
+        default:
+            Q_UNREACHABLE();
+        }
+
+        while (consumedDataItems < totalDataItems) {
+            int prevChildEndPosition = element.inner.position();
+            for (const auto &child : element.children) {
+                const int characterCountBetweenChildren = child.outer.position() - prevChildEndPosition;
+                if (characterCountBetweenChildren > 0) {
+                    // Add text between previous child (or inner beginning) and this child.
+                    result += unescape(_text.midRef(prevChildEndPosition, characterCountBetweenChildren));
+                } else if (characterCountBetweenChildren < 0) {
+                    // Repeated item; they overlap and end1 > start2
+                    result += unescape(element.inner.mid(prevChildEndPosition - element.inner.position()));
+                    result += unescape(element.inner.left(child.outer.position() - element.inner.position()));
+                }
+
+                switch (data.dataType()) {
+                case Var::DataType::Number:
+                case Var::DataType::String:
+                    generateRecursively(result, child, data);
+                    consumedDataItems = 1; // Deepest child always consumes number/string
+                    break;
+                case Var::DataType::Vector:
+                    if (!data.vec.isEmpty()) {
+                        if (!child.hasName() && !child.isCommand() && consumedDataItems < data.vec.size()) {
+                            consumedDataItems += generateRecursively(result, child, data[consumedDataItems]);
+                        } else {
+                            consumedDataItems += generateRecursively(result, child, data.vec.mid(consumedDataItems));
+                        }
+                    } else {
+                        warn(child, QStringLiteral("no more items available in parent's list."));
+                    }
+                    break;
+                case Var::DataType::Map:
+                    if (!child.hasName()) {
+                        consumedDataItems = generateRecursively(result, child, data);
+                    } else if (data.map.contains(child.name)) {
+                        generateRecursively(result, child, data.map[child.name]);
+                        // Always consume, repeating doesn't change anything
+                        consumedDataItems = 1;
+                    } else {
+                        warn(child, QStringLiteral("missing value for the element in parent's map."));
+                    }
+                    break;
+                default:
+                    break;
+                }
+                prevChildEndPosition = child.outer.position() + child.outer.length();
+            }
+
+            result += unescape(element.inner.mid(prevChildEndPosition - element.inner.position(), -1));
+
+            if (element.isCommand()) {
+                break;
+            }
+
+            const bool isLast = consumedDataItems >= totalDataItems;
+            if (!isLast) {
+                // Collapse empty lines between elements
+                int nlNum = 0;
+                for (int i = 0; i < element.inner.size() / 2; ++i) {
+                    if (element.inner.at(i) == QLatin1Char('\n') && element.inner.at(i) == element.inner.at(element.inner.size() - i - 1))
+                        nlNum++;
+                    else
+                        break;
+                }
+                if (nlNum > 0)
+                    result.chop(nlNum);
+            }
+        }
+    } else if (!element.isComment) {
+        // Handle leaf element
+        switch (data.dataType()) {
+        case Var::DataType::Number: {
+            const QString fmt = element.findFmt(Var::DataType::Number);
+            result += QString::asprintf(qUtf8Printable(fmt), data.num);
+            break;
+        }
+        case Var::DataType::String: {
+            const QString fmt = element.findFmt(Var::DataType::String);
+            result += QString::asprintf(qUtf8Printable(fmt), qUtf8Printable(data.str));
+            break;
+        }
+        case Var::DataType::Vector:
+            if (data.vec.isEmpty()) {
+                warn(element, QStringLiteral("got empty list."));
+            } else if (data.vec.at(0).dataType() == Var::DataType::Number) {
+                const QString fmt = element.findFmt(Var::DataType::Number);
+                result += QString::asprintf(qUtf8Printable(fmt), data.num);
+            } else if (data.vec.at(0).dataType() == Var::DataType::String) {
+                const QString fmt = element.findFmt(Var::DataType::String);
+                result += QString::asprintf(qUtf8Printable(fmt), qUtf8Printable(data.str));
+            } else {
+                warn(element,
+                     QStringLiteral("the list entry data type (%1) is not supported in childrenless elements.").arg(data.vec.at(0).dataTypeAsString()));
+            }
+            break;
+        case Var::DataType::Map:
+            warn(element, QStringLiteral("map type is not supported in childrenless elements."));
+            break;
+        case Var::DataType::Invalid:
+            break;
+        }
+        consumedDataItems = 1;
+    }
+
+    return consumedDataItems;
+}
+
+/*
+void dbgDumpTree(const Template::Element &element) {
+    static int indent = 0;
+    QString type;
+    if(element.isCommand())
+        type = QStringLiteral("command");
+    else if(element.isComment)
+        type = QStringLiteral("comment");
+    else if(element.hasName() && element.inner.isEmpty())
+        type = QStringLiteral("empty named");
+    else if(element.hasName())
+        type = QStringLiteral("named");
+    else if(element.inner.isEmpty())
+        type = QStringLiteral("empty anonymous");
+    else
+        type = QStringLiteral("anonymous");
+
+    qDebug().noquote() << QStringLiteral("%1[%2] \"%3\" %4:%5")
+                          .arg(QStringLiteral("·   ").repeated(indent), type, element.name)
+                          .arg(element.line)
+                          .arg(element.column);
+    indent++;
+    for(const auto &child: element.children) {
+        dbgDumpTree(child);
+    }
+    indent--;
+}
+*/