Use QRegularExpression instead of deprecated QRegExp

Now it follows closely the definition of wildcard for glob patterns.
The backslash (\) character is not an escape char in this context.
In order to match one of the special characters, place it in square
brackets (for example, [?]).

src/app/qtlocalpeer/qtlocalpeer.cpp

@@ -79,6 +79,7 @@
 #include <QDir>
 #include <QLocalServer>
 #include <QLocalSocket>
+#include <QRegularExpression>
 
 #include "base/utils/misc.h"
 
@@ -108,7 +109,7 @@ QtLocalPeer::QtLocalPeer(QObject* parent, const QString &appId)
 #endif
         prefix = id.section(QLatin1Char('/'), -1);
     }
-    prefix.remove(QRegExp("[^a-zA-Z]"));
+    prefix.remove(QRegularExpression("[^a-zA-Z]"));
     prefix.truncate(6);
 
     QByteArray idc = id.toUtf8();

src/base/rss/rss_autodownloadrule.cpp

@@ -213,10 +213,8 @@ QRegularExpression AutoDownloadRule::cachedRegex(const QString &expression, cons
     QRegularExpression &regex = m_dataPtr->cachedRegexes[expression];
     if (regex.pattern().isEmpty())
     {
-        regex = QRegularExpression
-        {
-                (isRegex ? expression : Utils::String::wildcardToRegex(expression))
-                , QRegularExpression::CaseInsensitiveOption};
+        const QString pattern = (isRegex ? expression : Utils::String::wildcardToRegexPattern(expression));
+        regex = QRegularExpression {pattern, QRegularExpression::CaseInsensitiveOption};
     }
 
     return regex;

src/base/rss/rss_parser.cpp

@@ -34,7 +34,7 @@
 #include <QGlobalStatic>
 #include <QHash>
 #include <QMetaObject>
-#include <QRegExp>
+#include <QRegularExpression>
 #include <QStringList>
 #include <QVariant>
 #include <QXmlStreamEntityResolver>
@@ -391,12 +391,13 @@ namespace
         int nmin   = 8;
         int nsec   = 9;
         // Also accept obsolete form "Weekday, DD-Mon-YY HH:MM:SS ±hhmm"
-        QRegExp rx("^(?:([A-Z][a-z]+),\\s*)?(\\d{1,2})(\\s+|-)([^-\\s]+)(\\s+|-)(\\d{2,4})\\s+(\\d\\d):(\\d\\d)(?::(\\d\\d))?\\s+(\\S+)$");
+        QRegularExpression rx {"^(?:([A-Z][a-z]+),\\s*)?(\\d{1,2})(\\s+|-)([^-\\s]+)(\\s+|-)(\\d{2,4})\\s+(\\d\\d):(\\d\\d)(?::(\\d\\d))?\\s+(\\S+)$"};
+        QRegularExpressionMatch rxMatch;
         QStringList parts;
-        if (!str.indexOf(rx))
+        if (str.indexOf(rx, 0, &rxMatch) == 0)
         {
             // Check that if date has '-' separators, both separators are '-'.
-            parts = rx.capturedTexts();
+            parts = rxMatch.capturedTexts();
             const bool h1 = (parts[3] == QLatin1String("-"));
             const bool h2 = (parts[5] == QLatin1String("-"));
             if (h1 != h2)
@@ -405,9 +406,10 @@ namespace
         else
         {
             // Check for the obsolete form "Wdy Mon DD HH:MM:SS YYYY"
-            rx = QRegExp("^([A-Z][a-z]+)\\s+(\\S+)\\s+(\\d\\d)\\s+(\\d\\d):(\\d\\d):(\\d\\d)\\s+(\\d\\d\\d\\d)$");
-            if (str.indexOf(rx))
+            rx = QRegularExpression {"^([A-Z][a-z]+)\\s+(\\S+)\\s+(\\d\\d)\\s+(\\d\\d):(\\d\\d):(\\d\\d)\\s+(\\d\\d\\d\\d)$"};
+            if (str.indexOf(rx, 0, &rxMatch) != 0)
                 return QDateTime::currentDateTime();
+
             nyear  = 7;
             nmonth = 2;
             nday   = 3;
@@ -415,7 +417,7 @@ namespace
             nhour  = 4;
             nmin   = 5;
             nsec   = 6;
-            parts = rx.capturedTexts();
+            parts = rxMatch.capturedTexts();
         }
 
         bool ok[4];
@@ -463,11 +465,11 @@ namespace
         bool negOffset = false;
         if (parts.count() > 10)
         {
-            rx = QRegExp("^([+-])(\\d\\d)(\\d\\d)$");
-            if (!parts[10].indexOf(rx))
+            rx = QRegularExpression {"^([+-])(\\d\\d)(\\d\\d)$"};
+            if (parts[10].indexOf(rx, 0, &rxMatch) == 0)
             {
                 // It's a UTC offset ±hhmm
-                parts = rx.capturedTexts();
+                parts = rxMatch.capturedTexts();
                 offset = parts[2].toInt(&ok[0]) * 3600;
                 const int offsetMin = parts[3].toInt(&ok[1]);
                 if (!ok[0] || !ok[1] || offsetMin > 59)

src/base/utils/string.cpp

@@ -33,10 +33,15 @@
 
 #include <QCollator>
 #include <QLocale>
-#include <QRegExp>
 #include <QtGlobal>
 #include <QVector>
 
+#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
+#include <QRegularExpression>
+#else
+#include <QRegExp>
+#endif
+
 #if defined(Q_OS_MACOS) || defined(__MINGW32__)
 #define QBT_USES_QTHREADSTORAGE
 #include <QThreadStorage>
@@ -181,14 +186,21 @@ QString Utils::String::fromDouble(const double n, const int precision)
     return QLocale::system().toString(std::floor(n * prec) / prec, 'f', precision);
 }
 
+#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
+QString Utils::String::wildcardToRegexPattern(const QString &pattern)
+{
+    return QRegularExpression::wildcardToRegularExpression(pattern, QRegularExpression::UnanchoredWildcardConversion);
+}
+#else
 // This is marked as internal in QRegExp.cpp, but is exported. The alternative would be to
 // copy the code from QRegExp::wc2rx().
 QString qt_regexp_toCanonical(const QString &pattern, QRegExp::PatternSyntax patternSyntax);
 
-QString Utils::String::wildcardToRegex(const QString &pattern)
+QString Utils::String::wildcardToRegexPattern(const QString &pattern)
 {
     return qt_regexp_toCanonical(pattern, QRegExp::Wildcard);
 }
+#endif
 
 std::optional<bool> Utils::String::parseBool(const QString &string)
 {

src/base/utils/string.h

@@ -50,7 +50,7 @@ namespace Utils::String
         return (naturalCompare(left, right, caseSensitivity) < 0);
     }
 
-    QString wildcardToRegex(const QString &pattern);
+    QString wildcardToRegexPattern(const QString &pattern);
 
     template <typename T>
     T unquote(const T &str, const QString &quotes = QChar('"'))

src/gui/properties/propertieswidget.cpp

@@ -825,7 +825,8 @@ void PropertiesWidget::filteredFilesChanged()
 
 void PropertiesWidget::filterText(const QString &filter)
 {
-    m_propListModel->setFilterRegExp(QRegExp(filter, Qt::CaseInsensitive, QRegExp::WildcardUnix));
+    const QString pattern = Utils::String::wildcardToRegexPattern(filter);
+    m_propListModel->setFilterRegularExpression(QRegularExpression(pattern, QRegularExpression::CaseInsensitiveOption));
     if (filter.isEmpty())
     {
         m_ui->filesList->collapseAll();

src/gui/rss/automatedrssdownloader.cpp

@@ -719,10 +719,14 @@ void AutomatedRssDownloader::updateMustLineValidity()
     {
         QStringList tokens;
         if (isRegex)
+        {
             tokens << text;
+        }
         else
+        {
             for (const QString &token : asConst(text.split('|')))
-                tokens << Utils::String::wildcardToRegex(token);
+                tokens << Utils::String::wildcardToRegexPattern(token);
+        }
 
         for (const QString &token : asConst(tokens))
         {
@@ -762,10 +766,14 @@ void AutomatedRssDownloader::updateMustNotLineValidity()
     {
         QStringList tokens;
         if (isRegex)
+        {
             tokens << text;
+        }
         else
+        {
             for (const QString &token : asConst(text.split('|')))
-                tokens << Utils::String::wildcardToRegex(token);
+                tokens << Utils::String::wildcardToRegexPattern(token);
+        }
 
         for (const QString &token : asConst(tokens))
         {

src/gui/search/searchjobwidget.cpp

@@ -365,9 +365,9 @@ void SearchJobWidget::fillFilterComboBoxes()
 
 void SearchJobWidget::filterSearchResults(const QString &name)
 {
-    const QRegExp::PatternSyntax patternSyntax = Preferences::instance()->getRegexAsFilteringPatternForSearchJob()
-                    ? QRegExp::RegExp : QRegExp::WildcardUnix;
-    m_proxyModel->setFilterRegExp(QRegExp(name, Qt::CaseInsensitive, patternSyntax));
+    const QString pattern = (Preferences::instance()->getRegexAsFilteringPatternForSearchJob()
+                    ? name : Utils::String::wildcardToRegexPattern(name));
+    m_proxyModel->setFilterRegularExpression(QRegularExpression(pattern, QRegularExpression::CaseInsensitiveOption));
     updateResultsCount();
 }
 

src/gui/torrentcontentfiltermodel.cpp

@@ -129,7 +129,7 @@ bool TorrentContentFilterModel::hasFiltered(const QModelIndex &folder) const
     // this should be called only with folders
     // check if the folder name itself matches the filter string
     QString name = folder.data().toString();
-    if (name.contains(filterRegExp()))
+    if (name.contains(filterRegularExpression()))
         return true;
     for (int child = 0; child < m_model->rowCount(folder); ++child)
     {
@@ -141,7 +141,7 @@ bool TorrentContentFilterModel::hasFiltered(const QModelIndex &folder) const
             continue;
         }
         name = childIndex.data().toString();
-        if (name.contains(filterRegExp()))
+        if (name.contains(filterRegularExpression()))
             return true;
     }
 

src/gui/transferlistwidget.cpp

@@ -36,7 +36,6 @@
 #include <QHeaderView>
 #include <QMenu>
 #include <QMessageBox>
-#include <QRegExp>
 #include <QRegularExpression>
 #include <QSet>
 #include <QShortcut>
@@ -1131,9 +1130,9 @@ void TransferListWidget::applyTrackerFilter(const QSet<BitTorrent::TorrentID> &t
 
 void TransferListWidget::applyNameFilter(const QString &name)
 {
-    const QRegExp::PatternSyntax patternSyntax = Preferences::instance()->getRegexAsFilteringPatternForTransferList()
-                ? QRegExp::RegExp : QRegExp::WildcardUnix;
-    m_sortFilterModel->setFilterRegExp(QRegExp(name, Qt::CaseInsensitive, patternSyntax));
+    const QString pattern = (Preferences::instance()->getRegexAsFilteringPatternForTransferList()
+                ? name : Utils::String::wildcardToRegexPattern(name));
+    m_sortFilterModel->setFilterRegularExpression(QRegularExpression(pattern, QRegularExpression::CaseInsensitiveOption));
 }
 
 void TransferListWidget::applyStatusFilter(int f)

src/webui/webapplication.cpp

@@ -38,7 +38,7 @@
 #include <QMimeDatabase>
 #include <QMimeType>
 #include <QNetworkCookie>
-#include <QRegExp>
+#include <QRegularExpression>
 #include <QUrl>
 
 #include "base/algorithm.h"
@@ -693,7 +693,7 @@ bool WebApplication::validateHostHeader(const QStringList &domains) const
     // try matching host header with domain list
     for (const auto &domain : domains)
     {
-        QRegExp domainRegex(domain, Qt::CaseInsensitive, QRegExp::Wildcard);
+        const QRegularExpression domainRegex {Utils::String::wildcardToRegexPattern(domain), QRegularExpression::CaseInsensitiveOption};
         if (requestHost.contains(domainRegex))
             return true;
     }