Revert "Revert "Port away from QRegExp to QRegularExpression.""

This reverts commit c291af2c83.

src/core/partition.cpp

@@ -28,6 +28,7 @@
 #include "util/report.h"
 
 #include <QDebug>
+#include <QRegularExpression>
 #include <QString>
 #include <QStringList>
 
@@ -214,7 +215,7 @@ void Partition::adjustLogicalNumbers(qint32 deletedNumber, qint32 insertedNumber
 
     foreach(Partition * p, children()) {
         QString path = p->partitionPath();
-        path.remove(QRegExp(QStringLiteral("([0-9]+$)")));
+        path.remove(QRegularExpression(QStringLiteral("(\\d+$)")));
         if (deletedNumber > 4 && p->number() > deletedNumber)
             p->setPartitionPath(path + QString::number(p->number() - 1));
         else if (insertedNumber > 4 && p->number() >= insertedNumber)

src/fs/btrfs.cpp

@@ -22,8 +22,8 @@
 #include "util/capacity.h"
 #include "util/report.h"
 
+#include <QRegularExpression>
 #include <QString>
-#include <QRegExp>
 #include <QTemporaryDir>
 
 #include <KLocalizedString>
@@ -109,11 +109,12 @@ qint64 btrfs::readUsedCapacity(const QString& deviceNode) const
     ExternalCommand cmd(QStringLiteral("btrfs"),
                         { QStringLiteral("filesystem"), QStringLiteral("show"), QStringLiteral("--raw"), deviceNode });
 
-    if (cmd.run()) {
+    if (cmd.run(-1) && cmd.exitCode() == 0) {
-        QRegExp rxBytesUsed(QStringLiteral(" used (\\d+) path ") + deviceNode);
+        QRegularExpression re(QStringLiteral(" used (\\d+) path ") + deviceNode);
+        QRegularExpressionMatch reBytesUsed = re.match(cmd.output());
 
-        if (rxBytesUsed.indexIn(cmd.output()) != -1)
+        if (reBytesUsed.hasMatch())
-            return rxBytesUsed.cap(1).toLongLong();
+            return reBytesUsed.captured(1).toLongLong();
     }
 
     return -1;

src/fs/exfat.cpp

@@ -22,7 +22,6 @@
 #include "util/capacity.h"
 
 #include <QString>
-#include <QRegExp>
 
 namespace FS
 {

src/fs/ext2.cpp

@@ -21,8 +21,8 @@
 #include "util/externalcommand.h"
 #include "util/capacity.h"
 
+#include <QRegularExpression>
 #include <QString>
-#include <QRegExp>
 
 namespace FS
 {
@@ -98,22 +98,25 @@ qint64 ext2::readUsedCapacity(const QString& deviceNode) const
 
     if (cmd.run()) {
         qint64 blockCount = -1;
-        QRegExp rxBlockCount(QStringLiteral("Block count:\\s*(\\d+)"));
+        QRegularExpression re(QStringLiteral("Block count:\\s+(\\d+)"));
+        QRegularExpressionMatch reBlockCount = re.match(cmd.output());
 
-        if (rxBlockCount.indexIn(cmd.output()) != -1)
+        if (reBlockCount.hasMatch())
-            blockCount = rxBlockCount.cap(1).toLongLong();
+            blockCount = reBlockCount.captured(1).toLongLong();
 
         qint64 freeBlocks = -1;
-        QRegExp rxFreeBlocks(QStringLiteral("Free blocks:\\s*(\\d+)"));
+        re.setPattern(QStringLiteral("Free blocks:\\s+(\\d+)"));
+        QRegularExpressionMatch reFreeBlocks = re.match(cmd.output());
 
-        if (rxFreeBlocks.indexIn(cmd.output()) != -1)
+        if (reFreeBlocks.hasMatch())
-            freeBlocks = rxFreeBlocks.cap(1).toLongLong();
+            freeBlocks = reFreeBlocks.captured(1).toLongLong();
 
         qint64 blockSize = -1;
-        QRegExp rxBlockSize(QStringLiteral("Block size:\\s*(\\d+)"));
+        re.setPattern(QStringLiteral("Block size:\\s+(\\d+)"));
+        QRegularExpressionMatch reBlockSize = re.match(cmd.output());
 
-        if (rxBlockSize.indexIn(cmd.output()) != -1)
+        if (reBlockSize.hasMatch())
-            blockSize = rxBlockSize.cap(1).toLongLong();
+            blockSize = reBlockSize.captured(1).toLongLong();
 
         if (blockCount > -1 && freeBlocks > -1 && blockSize > -1)
             return (blockCount - freeBlocks) * blockSize;

src/fs/fat16.cpp

@@ -24,9 +24,9 @@
 
 #include <KLocalizedString>
 
+#include <QRegularExpression>
 #include <QString>
 #include <QStringList>
-#include <QRegExp>
 
 #include <ctime>
 
@@ -106,19 +106,21 @@ qint64 fat16::readUsedCapacity(const QString& deviceNode) const
 {
     ExternalCommand cmd(QStringLiteral("fsck.msdos"), { QStringLiteral("-n"), QStringLiteral("-v"), deviceNode });
 
-    if (cmd.run()) {
+    if (cmd.run(-1) && cmd.exitCode() == 0) {
         qint64 usedClusters = -1;
-        QRegExp rxClusters(QStringLiteral("files, (\\d+)/\\d+ "));
+        QRegularExpression re(QStringLiteral("files, (\\d+)/\\d+ "));
+        QRegularExpressionMatch reClusters = re.match(cmd.output());
 
-        if (rxClusters.indexIn(cmd.output()) != -1)
+        if (reClusters.hasMatch())
-            usedClusters = rxClusters.cap(1).toLongLong();
+            usedClusters = reClusters.captured(1).toLongLong();
 
         qint64 clusterSize = -1;
 
-        QRegExp rxClusterSize(QStringLiteral("(\\d+) bytes per cluster"));
+        re.setPattern(QStringLiteral("(\\d+) bytes per cluster"));
+        QRegularExpressionMatch reClusterSize = re.match(cmd.output());
 
-        if (rxClusterSize.indexIn(cmd.output()) != -1)
+        if (reClusterSize.hasMatch())
-            clusterSize = rxClusterSize.cap(1).toLongLong();
+            clusterSize = reClusterSize.captured(1).toLongLong();
 
         if (usedClusters > -1 && clusterSize > -1)
             return usedClusters * clusterSize;

src/fs/hfs.cpp

@@ -22,7 +22,6 @@
 #include "util/capacity.h"
 
 #include <QStringList>
-#include <QRegExp>
 
 namespace FS
 {

src/fs/jfs.cpp

@@ -21,8 +21,8 @@
 #include "util/report.h"
 #include "util/capacity.h"
 
+#include <QRegularExpression>
 #include <QStringList>
-#include <QRegExp>
 #include <QTemporaryDir>
 
 #include <KLocalizedString>
@@ -100,26 +100,29 @@ qint64 jfs::readUsedCapacity(const QString& deviceNode) const
 
     if (cmd.start() && cmd.write("dm") == 2 && cmd.waitFor()) {
         qint64 blockSize = -1;
-        QRegExp rxBlockSize(QStringLiteral("Block Size: (\\d+)"));
+        QRegularExpression re(QStringLiteral("Block Size: (\\d+)"));
+        QRegularExpressionMatch reBlockSize = re.match(cmd.output());
 
-        if (rxBlockSize.indexIn(cmd.output()) != -1)
+        if (reBlockSize.hasMatch())
-            blockSize = rxBlockSize.cap(1).toLongLong();
+            blockSize = reBlockSize.captured(1).toLongLong();
 
         qint64 nBlocks = -1;
-        QRegExp rxnBlocks(QStringLiteral("dn_mapsize:\\s+0x([0-9a-f]+)"));
+        re.setPattern(QStringLiteral("dn_mapsize:\\s+0x(\\x+)"));
+        QRegularExpressionMatch renBlocks = re.match(cmd.output());
 
         bool ok = false;
-        if (rxnBlocks.indexIn(cmd.output()) != -1) {
+        if (renBlocks.hasMatch()) {
-            nBlocks = rxnBlocks.cap(1).toLongLong(&ok, 16);
+            nBlocks = renBlocks.captured(1).toLongLong(&ok, 16);
             if (!ok)
                 nBlocks = -1;
         }
 
         qint64 nFree = -1;
-        QRegExp rxnFree(QStringLiteral("dn_nfree:\\s+0x([0-9a-f]+)"));
+        re.setPattern(QStringLiteral("dn_nfree:\\s+0x(\\x+)"));
+        QRegularExpressionMatch renFree = re.match(cmd.output());
 
-        if (rxnFree.indexIn(cmd.output()) != -1) {
+        if (renFree.hasMatch()) {
-            nFree = rxnFree.cap(1).toLongLong(&ok, 16);
+            nFree = renFree.captured(1).toLongLong(&ok, 16);
             if (!ok)
                 nFree = -1;
         }

src/fs/luks.cpp

@@ -28,6 +28,7 @@
 #include <QDebug>
 #include <QDialog>
 #include <QPointer>
+#include <QRegularExpression>
 #include <QString>
 #include <QUuid>
 
@@ -494,7 +495,7 @@ bool luks::resize(Report& report, const QString& deviceNode, qint64 newLength) c
     else if (m_innerFs->resize(report, mapperNode, payloadLength))
     {
         ExternalCommand cryptResizeCmd(report, QStringLiteral("cryptsetup"), { QStringLiteral("--size"), QString::number(payloadLength / m_logicalSectorSize), QStringLiteral("resize"), mapperNode });
-        report.line() << xi18nc("@info/plain", "Resizing encrypted file system on partition <filename>%1</filename>.", deviceNode);
+        report.line() << xi18nc("@info/plain", "Resizing LUKS crypt on partition <filename>%1</filename>.", deviceNode);
         if (cryptResizeCmd.run(-1) && cryptResizeCmd.exitCode() == 0)
         {
             return true;
@@ -522,7 +523,7 @@ QString luks::readOuterUUID(const QString &deviceNode) const
 
 bool luks::updateUUID(Report& report, const QString& deviceNode) const
 {
-    const QString uuid = QUuid::createUuid().toString().remove(QRegExp(QStringLiteral("\\{|\\}")));
+    const QString uuid = QUuid::createUuid().toString().remove(QRegularExpression(QStringLiteral("\\{|\\}")));
 
     ExternalCommand cmd(report,
                         QStringLiteral("cryptsetup"),
@@ -535,18 +536,20 @@ bool luks::updateUUID(Report& report, const QString& deviceNode) const
 
 QString luks::mapperName(const QString& deviceNode)
 {
-    ExternalCommand cmd(QStringLiteral("lsblk"),
+    ExternalCommand cmd(QStringLiteral("find"),
-                        { QStringLiteral("--raw"),
+                        { QStringLiteral("/dev/mapper/"),
-                          QStringLiteral("--noheadings"),
+                          QStringLiteral("-exec"),
-                          QStringLiteral("--output"),
+                          QStringLiteral("cryptsetup"),
-                          QStringLiteral("name"),
+                          QStringLiteral("status"),
-                          deviceNode });
+                          QStringLiteral("{}"),
-    if (cmd.run(-1) && cmd.exitCode() == 0) {
+                          QStringLiteral(";") });
-        QStringList output=cmd.output().split(QStringLiteral("\n"));
+    if (cmd.run()) {
-        output.removeFirst();
+        QRegExp rxDeviceName(QStringLiteral("(/dev/mapper/[A-Za-z0-9-/]+) is "
-        if (!output.first().isEmpty())
+                                            "active[A-Za-z0-9- \\.\n]+[A-Za-z0-9-: \n]+") + deviceNode);
-            return QStringLiteral("/dev/mapper/") + output.first();
+        if (rxDeviceName.indexIn(cmd.output()) > -1)
+            return rxDeviceName.cap(1);
     }
+
     return QString();
 }
 
@@ -554,10 +557,11 @@ QString luks::getCipherName(const QString& deviceNode)
 {
     ExternalCommand cmd(QStringLiteral("cryptsetup"),
                         { QStringLiteral("luksDump"), deviceNode });
-    if (cmd.run()) {
+    if (cmd.run(-1) && cmd.exitCode() == 0) {
-        QRegExp rxCipherName(QStringLiteral("(?:Cipher name:\\s+)([A-Za-z0-9-]+)"));
+        QRegularExpression re(QStringLiteral("Cipher name:\\s+(\\w+)"));
-        if (rxCipherName.indexIn(cmd.output()) > -1)
+        QRegularExpressionMatch reCipherName = re.match(cmd.output());
-            return rxCipherName.cap(1);
+        if (reCipherName.hasMatch())
+            return reCipherName.captured(1);
     }
     return QStringLiteral("---");
 }
@@ -566,10 +570,11 @@ QString luks::getCipherMode(const QString& deviceNode)
 {
     ExternalCommand cmd(QStringLiteral("cryptsetup"),
                         { QStringLiteral("luksDump"), deviceNode });
-    if (cmd.run()) {
+    if (cmd.run(-1) && cmd.exitCode() == 0) {
-        QRegExp rxCipherMode(QStringLiteral("(?:Cipher mode:\\s+)([A-Za-z0-9-]+)"));
+        QRegularExpression re(QStringLiteral("Cipher mode:\\s+(\\w+)"));
-        if (rxCipherMode.indexIn(cmd.output()) > -1)
+        QRegularExpressionMatch reCipherMode = re.match(cmd.output());
-            return rxCipherMode.cap(1);
+        if (reCipherMode.hasMatch())
+            return reCipherMode.captured(1);
     }
     return QStringLiteral("---");
 }
@@ -578,10 +583,11 @@ QString luks::getHashName(const QString& deviceNode)
 {
     ExternalCommand cmd(QStringLiteral("cryptsetup"),
                         { QStringLiteral("luksDump"), deviceNode });
-    if (cmd.run()) {
+    if (cmd.run(-1) && cmd.exitCode() == 0) {
-        QRegExp rxHash(QStringLiteral("(?:Hash spec:\\s+)([A-Za-z0-9-]+)"));
+        QRegularExpression re(QStringLiteral("Hash spec:\\s+(\\w+)"));
-        if (rxHash.indexIn(cmd.output()) > -1)
+        QRegularExpressionMatch reHash = re.match(cmd.output());
-            return rxHash.cap(1);
+        if (reHash.hasMatch())
+            return reHash.captured(1);
     }
     return QStringLiteral("---");
 }
@@ -590,10 +596,11 @@ QString luks::getKeySize(const QString& deviceNode)
 {
     ExternalCommand cmd(QStringLiteral("cryptsetup"),
                         { QStringLiteral("luksDump"), deviceNode });
-    if (cmd.run()) {
+    if (cmd.run(-1) && cmd.exitCode() == 0) {
-        QRegExp rxKeySize(QStringLiteral("(?:MK bits:\\s+)(\\d+)"));
+        QRegularExpression re(QStringLiteral("MK bits:\\s+(\\d+)"));
-        if (rxKeySize.indexIn(cmd.output()) > -1)
+        QRegularExpressionMatch reKeySize = re.match(cmd.output());
-            return rxKeySize.cap(1);
+        if (reKeySize.hasMatch())
+            return reKeySize.captured(1);
     }
     return QStringLiteral("---");
 }
@@ -602,10 +609,11 @@ QString luks::getPayloadOffset(const QString& deviceNode)
 {
     ExternalCommand cmd(QStringLiteral("cryptsetup"),
                         { QStringLiteral("luksDump"), deviceNode });
-    if (cmd.run()) {
+    if (cmd.run(-1) && cmd.exitCode() == 0) {
-        QRegExp rxPayloadOffset(QStringLiteral("(?:Payload offset:\\s+)(\\d+)"));
+        QRegularExpression re(QStringLiteral("Payload offset:\\s+(\\d+)"));
-        if (rxPayloadOffset.indexIn(cmd.output()) > -1)
+        QRegularExpressionMatch rePayloadOffset = re.match(cmd.output());
-            return rxPayloadOffset.cap(1);
+        if (rePayloadOffset.hasMatch())
+            return rePayloadOffset.captured(1);
     }
     return QStringLiteral("---");
 }

src/fs/nilfs2.cpp

@@ -24,6 +24,7 @@
 
 #include <cmath>
 
+#include <QRegularExpression>
 #include <QString>
 #include <QTemporaryDir>
 #include <QUuid>
@@ -124,12 +125,15 @@ qint64 nilfs2::readUsedCapacity(const QString& deviceNode) const
 {
     ExternalCommand cmd(QStringLiteral("nilfs-tune"), { QStringLiteral("-l"), deviceNode });
 
-    if (cmd.run()) {
+    if (cmd.run(-1) && cmd.exitCode() == 0) {
-        QRegExp rxBlockSize(QStringLiteral("(?:Block size:\\s+)(\\d+)"));
+        QRegularExpression re(QStringLiteral("Block size:\\s+(\\d+)"));
-        QRegExp rxDeviceSize(QStringLiteral("(?:Device size:\\s+)(\\d+)"));
+        QRegularExpressionMatch reBlockSize = re.match(cmd.output());
-        QRegExp rxFreeBlocks(QStringLiteral("(?:Free blocks count:\\s+)(\\d+)"));
+        re.setPattern(QStringLiteral("Device size:\\s+(\\d+)"));
-        if (rxBlockSize.indexIn(cmd.output()) != -1 && rxDeviceSize.indexIn(cmd.output()) != -1 && rxFreeBlocks.indexIn(cmd.output()) != -1)
+        QRegularExpressionMatch reDeviceSize = re.match(cmd.output());
-            return rxDeviceSize.cap(1).toLongLong() - rxBlockSize.cap(1).toLongLong() * rxFreeBlocks.cap(1).toLongLong();
+        re.setPattern(QStringLiteral("Free blocks count:\\s+(\\d+)"));
+        QRegularExpressionMatch reFreeBlocks = re.match(cmd.output());
+        if (reBlockSize.hasMatch() && reDeviceSize.hasMatch() && reFreeBlocks.hasMatch())
+            return reDeviceSize.captured(1).toLongLong() - reBlockSize.captured(1).toLongLong() * reFreeBlocks.captured(1).toLongLong();
     }
 
     return -1;

src/fs/ntfs.cpp

@@ -25,13 +25,14 @@
 
 #include <KLocalizedString>
 
+#include <QRegularExpression>
 #include <QString>
 #include <QStringList>
 #include <QFile>
 #include <QUuid>
 
-#include <ctime>
 #include <algorithm>
+#include <ctime>
 
 namespace FS
 {
@@ -107,12 +108,13 @@ qint64 ntfs::readUsedCapacity(const QString& deviceNode) const
 {
     ExternalCommand cmd(QStringLiteral("ntfsresize"), { QStringLiteral("--info"), QStringLiteral("--force"), QStringLiteral("--no-progress-bar"), deviceNode });
 
-    if (cmd.run()) {
+    if (cmd.run(-1) && cmd.exitCode() == 0) {
         qint64 usedBytes = -1;
-        QRegExp rxUsedBytes(QStringLiteral("resize at (\\d+) bytes"));
+        QRegularExpression re(QStringLiteral("resize at (\\d+) bytes"));
+        QRegularExpressionMatch reUsedBytes = re.match(cmd.output());
 
-        if (rxUsedBytes.indexIn(cmd.output()) != -1)
+        if (reUsedBytes.hasMatch())
-            usedBytes = rxUsedBytes.cap(1).toLongLong();
+            usedBytes = reUsedBytes.captured(1).toLongLong();
 
         if (usedBytes > -1)
             return usedBytes;

src/fs/ocfs2.cpp

@@ -21,8 +21,8 @@
 #include "util/externalcommand.h"
 #include "util/capacity.h"
 
+#include <QRegularExpression>
 #include <QString>
-#include <QRegExp>
 
 namespace FS
 {
@@ -129,11 +129,12 @@ bool ocfs2::resize(Report& report, const QString& deviceNode, qint64 length) con
     ExternalCommand cmdBlockSize(QStringLiteral("debugfs.ocfs2"), { QStringLiteral("--request"), QStringLiteral("stats"), deviceNode });
 
     qint32 blockSize = -1;
-    if (cmdBlockSize.run()) {
+    if (cmdBlockSize.run(-1) && cmdBlockSize.exitCode() == 0) {
-        QRegExp rxBlockSizeBits(QStringLiteral("Block Size Bits: (\\d+)"));
+        QRegularExpression re(QStringLiteral("Block Size Bits: (\\d+)"));
+        QRegularExpressionMatch reBlockSizeBits = re.match(cmdBlockSize.output());
 
-        if (rxBlockSizeBits.indexIn(cmdBlockSize.output()) != -1)
+        if (reBlockSizeBits.hasMatch())
-            blockSize = 1 << rxBlockSizeBits.cap(1).toInt();
+            blockSize = 1 << reBlockSizeBits.captured(1).toInt();
     }
 
     if (blockSize == -1)

src/fs/reiser4.cpp

@@ -21,8 +21,8 @@
 #include "util/capacity.h"
 #include "util/externalcommand.h"
 
+#include <QRegularExpression>
 #include <QStringList>
-#include <QRegExp>
 
 namespace FS
 {
@@ -87,24 +87,27 @@ qint64 reiser4::readUsedCapacity(const QString& deviceNode) const
 {
     ExternalCommand cmd(QStringLiteral("debugfs.reiser4"), { deviceNode });
 
-    if (cmd.run()) {
+    if (cmd.run(-1) && cmd.exitCode() == 16) {
         qint64 blocks = -1;
-        QRegExp rxBlocks(QStringLiteral("blocks:\\s+(\\d+)"));
+        QRegularExpression re(QStringLiteral("blocks:\\s+(\\d+)"));
+        QRegularExpressionMatch reBlocks = re.match(cmd.output());
 
-        if (rxBlocks.indexIn(cmd.output()) != -1)
+        if (reBlocks.hasMatch())
-            blocks = rxBlocks.cap(1).toLongLong();
+            blocks = reBlocks.captured(1).toLongLong();
 
         qint64 blockSize = -1;
-        QRegExp rxBlockSize(QStringLiteral("blksize:\\s+(\\d+)"));
+        re.setPattern(QStringLiteral("blksize:\\s+(\\d+)"));
+        QRegularExpressionMatch reBlockSize = re.match(cmd.output());
 
-        if (rxBlockSize.indexIn(cmd.output()) != -1)
+        if (reBlockSize.hasMatch())
-            blockSize = rxBlockSize.cap(1).toLongLong();
+            blockSize = reBlockSize.captured(1).toLongLong();
 
         qint64 freeBlocks = -1;
-        QRegExp rxFreeBlocks(QStringLiteral("free blocks:\\s+(\\d+)"));
+        re.setPattern(QStringLiteral("free blocks:\\s+(\\d+)"));
+        QRegularExpressionMatch reFreeBlocks = re.match(cmd.output());
 
-        if (rxFreeBlocks.indexIn(cmd.output()) != -1)
+        if (reFreeBlocks.hasMatch())
-            freeBlocks = rxFreeBlocks.cap(1).toLongLong();
+            freeBlocks = reFreeBlocks.captured(1).toLongLong();
 
         if (blocks > - 1 && blockSize > -1 && freeBlocks > -1)
             return (blocks - freeBlocks) * blockSize;

src/fs/reiserfs.cpp

@@ -21,9 +21,9 @@
 #include "util/externalcommand.h"
 #include "util/capacity.h"
 
+#include <QRegularExpression>
 #include <QString>
 #include <QStringList>
-#include <QRegExp>
 #include <QUuid>
 
 namespace FS
@@ -102,24 +102,27 @@ qint64 reiserfs::readUsedCapacity(const QString& deviceNode) const
 {
     ExternalCommand cmd(QStringLiteral("debugreiserfs"), { deviceNode });
 
-    if (cmd.run()) {
+    if (cmd.run(-1) && cmd.exitCode() == 16) {
         qint64 blockCount = -1;
-        QRegExp rxBlockCount(QStringLiteral("Count of blocks[^:]+: (\\d+)"));
+        QRegularExpression re(QStringLiteral("Count of blocks[^:]+: (\\d+)"));
+        QRegularExpressionMatch reBlockCount = re.match(cmd.output());
 
-        if (rxBlockCount.indexIn(cmd.output()) != -1)
+        if (reBlockCount.hasMatch())
-            blockCount = rxBlockCount.cap(1).toLongLong();
+            blockCount = reBlockCount.captured(1).toLongLong();
 
         qint64 blockSize = -1;
-        QRegExp rxBlockSize(QStringLiteral("Blocksize: (\\d+)"));
+        re.setPattern(QStringLiteral("Blocksize: (\\d+)"));
+        QRegularExpressionMatch reBlockSize = re.match(cmd.output());
 
-        if (rxBlockSize.indexIn(cmd.output()) != -1)
+        if (reBlockSize.hasMatch())
-            blockSize = rxBlockSize.cap(1).toLongLong();
+            blockSize = reBlockSize.captured(1).toLongLong();
 
         qint64 freeBlocks = -1;
-        QRegExp rxFreeBlocks(QStringLiteral("Free blocks[^:]+: (\\d+)"));
+        re.setPattern(QStringLiteral("Free blocks[^:]+: (\\d+)"));
+        QRegularExpressionMatch reFreeBlocks = re.match(cmd.output());
 
-        if (rxFreeBlocks.indexIn(cmd.output()) != -1)
+        if (reFreeBlocks.hasMatch())
-            freeBlocks = rxFreeBlocks.cap(1).toLongLong();
+            freeBlocks = reFreeBlocks.captured(1).toLongLong();
 
         if (blockCount > -1 && blockSize > -1 && freeBlocks > -1)
             return (blockCount - freeBlocks) * blockSize;
@@ -164,7 +167,7 @@ bool reiserfs::resize(Report& report, const QString& deviceNode, qint64 length)
 
 bool reiserfs::updateUUID(Report& report, const QString& deviceNode) const
 {
-    const QString uuid = QUuid::createUuid().toString().remove(QRegExp(QStringLiteral("\\{|\\}")));
+    const QString uuid = QUuid::createUuid().toString().remove(QRegularExpression(QStringLiteral("\\{|\\}")));
     ExternalCommand cmd(report, QStringLiteral("reiserfstune"), { QStringLiteral("--uuid"), uuid, deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }

src/fs/xfs.cpp

@@ -22,9 +22,9 @@
 #include "util/capacity.h"
 #include "util/report.h"
 
+#include <QRegularExpression>
 #include <QString>
 #include <QStringList>
-#include <QRegExp>
 #include <QTemporaryDir>
 
 #include <KLocalizedString>
@@ -102,24 +102,27 @@ qint64 xfs::readUsedCapacity(const QString& deviceNode) const
 {
     ExternalCommand cmd(QStringLiteral("xfs_db"), { QStringLiteral("-c"), QStringLiteral("sb 0"), QStringLiteral("-c"), QStringLiteral("print"), deviceNode });
 
-    if (cmd.run()) {
+    if (cmd.run(-1) && cmd.exitCode() == 0) {
         qint64 dBlocks = -1;
-        QRegExp rxDBlocks(QStringLiteral("dblocks = (\\d+)"));
+        QRegularExpression re(QStringLiteral("dblocks = (\\d+)"));
+        QRegularExpressionMatch reDBlocks = re.match(cmd.output());
 
-        if (rxDBlocks.indexIn(cmd.output()) != -1)
+        if (reDBlocks.hasMatch())
-            dBlocks = rxDBlocks.cap(1).toLongLong();
+            dBlocks = reDBlocks.captured(1).toLongLong();
 
         qint64 blockSize = -1;
-        QRegExp rxBlockSize(QStringLiteral("blocksize = (\\d+)"));
+        re.setPattern(QStringLiteral("blocksize = (\\d+)"));
+        QRegularExpressionMatch reBlockSize = re.match(cmd.output());
 
-        if (rxBlockSize.indexIn(cmd.output()) != -1)
+        if (reBlockSize.hasMatch())
-            blockSize = rxBlockSize.cap(1).toLongLong();
+            blockSize = reBlockSize.captured(1).toLongLong();
 
         qint64 fdBlocks = -1;
-        QRegExp rxFdBlocks(QStringLiteral("fdblocks = (\\d+)"));
+        re.setPattern(QStringLiteral("fdblocks = (\\d+)"));
+        QRegularExpressionMatch reFdBlocks = re.match(cmd.output());
 
-        if (rxFdBlocks.indexIn(cmd.output()) != -1)
+        if (reFdBlocks.hasMatch())
-            fdBlocks = rxFdBlocks.cap(1).toLongLong();
+            fdBlocks = reFdBlocks.captured(1).toLongLong();
 
         if (dBlocks > -1 && blockSize > -1 && fdBlocks > -1)
             return (dBlocks - fdBlocks) * blockSize;