File indexing completed on 2024-05-05 05:54:13

 /*
     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--;
 }
 */