Revert "Port away from QRegExp to QRegularExpression."

This reverts commit bb2de6cd56.

This was causing a crash when restoring partitions.

src/core/partition.cpp

@@ -28,7 +28,6 @@
 #include "util/report.h"
 
 #include <QDebug>
-#include <QRegularExpression>
 #include <QString>
 #include <QStringList>
 
@@ -215,7 +214,7 @@ void Partition::adjustLogicalNumbers(qint32 deletedNumber, qint32 insertedNumber
 
     foreach(Partition * p, children()) {
         QString path = p->partitionPath();
-        path.remove(QRegularExpression(QStringLiteral("(\\d+$)")));
+        path.remove(QRegExp(QStringLiteral("([0-9]+$)")));
         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,12 +109,11 @@ qint64 btrfs::readUsedCapacity(const QString& deviceNode) const
     ExternalCommand cmd(QStringLiteral("btrfs"),
                         { QStringLiteral("filesystem"), QStringLiteral("show"), QStringLiteral("--raw"), deviceNode });
 
-    if (cmd.run(-1) && cmd.exitCode() == 0) {
+    if (cmd.run()) {
-        QRegularExpression re(QStringLiteral(" used (\\d+) path ") + deviceNode);
+        QRegExp rxBytesUsed(QStringLiteral(" used (\\d+) path ") + deviceNode);
-        QRegularExpressionMatch reBytesUsed = re.match(cmd.output());
 
-        if (reBytesUsed.hasMatch())
+        if (rxBytesUsed.indexIn(cmd.output()) != -1)
-            return reBytesUsed.captured(1).toLongLong();
+            return rxBytesUsed.cap(1).toLongLong();
     }
 
     return -1;

src/fs/exfat.cpp

@@ -22,6 +22,7 @@
 #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,25 +98,22 @@ qint64 ext2::readUsedCapacity(const QString& deviceNode) const
 
     if (cmd.run()) {
         qint64 blockCount = -1;
-        QRegularExpression re(QStringLiteral("Block count:\\s+(\\w+)"));
+        QRegExp rxBlockCount(QStringLiteral("Block count:\\s*(\\d+)"));
-        QRegularExpressionMatch reBlockCount = re.match(cmd.output());
 
-        if (reBlockCount.hasMatch())
+        if (rxBlockCount.indexIn(cmd.output()) != -1)
-            blockCount = reBlockCount.captured(1).toLongLong();
+            blockCount = rxBlockCount.cap(1).toLongLong();
 
         qint64 freeBlocks = -1;
-        re.setPattern(QStringLiteral("Free blocks:\\s+(\\d+)"));
+        QRegExp rxFreeBlocks(QStringLiteral("Free blocks:\\s*(\\d+)"));
-        QRegularExpressionMatch reFreeBlocks = re.match(cmd.output());
 
-        if (reFreeBlocks.hasMatch())
+        if (rxFreeBlocks.indexIn(cmd.output()) != -1)
-            freeBlocks = reFreeBlocks.captured(1).toLongLong();
+            freeBlocks = rxFreeBlocks.cap(1).toLongLong();
 
         qint64 blockSize = -1;
-        re.setPattern(QStringLiteral("Block size:\\s+(\\d+)"));
+        QRegExp rxBlockSize(QStringLiteral("Block size:\\s*(\\d+)"));
-        QRegularExpressionMatch reBlockSize = re.match(cmd.output());
 
-        if (reBlockSize.hasMatch())
+        if (rxBlockSize.indexIn(cmd.output()) != -1)
-            blockSize = reBlockSize.captured(1).toLongLong();
+            blockSize = rxBlockSize.cap(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,21 +106,19 @@ qint64 fat16::readUsedCapacity(const QString& deviceNode) const
 {
     ExternalCommand cmd(QStringLiteral("fsck.msdos"), { QStringLiteral("-n"), QStringLiteral("-v"), deviceNode });
 
-    if (cmd.run(-1) && cmd.exitCode() == 0) {
+    if (cmd.run()) {
         qint64 usedClusters = -1;
-        QRegularExpression re(QStringLiteral("files, (\\d+)/\\d+ "));
+        QRegExp rxClusters(QStringLiteral("files, (\\d+)/\\d+ "));
-        QRegularExpressionMatch reClusters = re.match(cmd.output());
 
-        if (reClusters.hasMatch())
+        if (rxClusters.indexIn(cmd.output()) != -1)
-            usedClusters = reClusters.captured(1).toLongLong();
+            usedClusters = rxClusters.cap(1).toLongLong();
 
         qint64 clusterSize = -1;
 
-        re.setPattern(QStringLiteral("(\\d+) bytes per cluster"));
+        QRegExp rxClusterSize(QStringLiteral("(\\d+) bytes per cluster"));
-        QRegularExpressionMatch reClusterSize = re.match(cmd.output());
 
-        if (reClusterSize.hasMatch())
+        if (rxClusterSize.indexIn(cmd.output()) != -1)
-            clusterSize = reClusterSize.captured(1).toLongLong();
+            clusterSize = rxClusterSize.cap(1).toLongLong();
 
         if (usedClusters > -1 && clusterSize > -1)
             return usedClusters * clusterSize;

src/fs/hfs.cpp

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

src/fs/luks.cpp

@@ -28,7 +28,6 @@
 #include <QDebug>
 #include <QDialog>
 #include <QPointer>
-#include <QRegularExpression>
 #include <QString>
 #include <QUuid>
 
@@ -495,7 +494,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", "Resize encrypted file system on partition <filename>%1</filename>.", deviceNode);
+        report.line() << xi18nc("@info/plain", "Resizing encrypted file system on partition <filename>%1</filename>.", deviceNode);
         if (cryptResizeCmd.run(-1) && cryptResizeCmd.exitCode() == 0)
         {
             return true;
@@ -523,7 +522,7 @@ QString luks::readOuterUUID(const QString &deviceNode) const
 
 bool luks::updateUUID(Report& report, const QString& deviceNode) const
 {
-    const QString uuid = QUuid::createUuid().toString().remove(QRegularExpression(QStringLiteral("\\{|\\}")));
+    const QString uuid = QUuid::createUuid().toString().remove(QRegExp(QStringLiteral("\\{|\\}")));
 
     ExternalCommand cmd(report,
                         QStringLiteral("cryptsetup"),
@@ -555,11 +554,10 @@ QString luks::getCipherName(const QString& deviceNode)
 {
     ExternalCommand cmd(QStringLiteral("cryptsetup"),
                         { QStringLiteral("luksDump"), deviceNode });
-    if (cmd.run(-1) && cmd.exitCode() == 0) {
+    if (cmd.run()) {
-        QRegularExpression re(QStringLiteral("Cipher name:\\s+(\\w+)"));
+        QRegExp rxCipherName(QStringLiteral("(?:Cipher name:\\s+)([A-Za-z0-9-]+)"));
-        QRegularExpressionMatch reCipherName = re.match(cmd.output());
+        if (rxCipherName.indexIn(cmd.output()) > -1)
-        if (reCipherName.hasMatch())
+            return rxCipherName.cap(1);
-            return reCipherName.captured(1);
     }
     return QStringLiteral("---");
 }
@@ -568,11 +566,10 @@ QString luks::getCipherMode(const QString& deviceNode)
 {
     ExternalCommand cmd(QStringLiteral("cryptsetup"),
                         { QStringLiteral("luksDump"), deviceNode });
-    if (cmd.run(-1) && cmd.exitCode() == 0) {
+    if (cmd.run()) {
-        QRegularExpression re(QStringLiteral("Cipher mode:\\s+(\\w+)"));
+        QRegExp rxCipherMode(QStringLiteral("(?:Cipher mode:\\s+)([A-Za-z0-9-]+)"));
-        QRegularExpressionMatch reCipherMode = re.match(cmd.output());
+        if (rxCipherMode.indexIn(cmd.output()) > -1)
-        if (reCipherMode.hasMatch())
+            return rxCipherMode.cap(1);
-            return reCipherMode.captured(1);
     }
     return QStringLiteral("---");
 }
@@ -581,11 +578,10 @@ QString luks::getHashName(const QString& deviceNode)
 {
     ExternalCommand cmd(QStringLiteral("cryptsetup"),
                         { QStringLiteral("luksDump"), deviceNode });
-    if (cmd.run(-1) && cmd.exitCode() == 0) {
+    if (cmd.run()) {
-        QRegularExpression re(QStringLiteral("Hash spec:\\s+(\\w+)"));
+        QRegExp rxHash(QStringLiteral("(?:Hash spec:\\s+)([A-Za-z0-9-]+)"));
-        QRegularExpressionMatch reHash = re.match(cmd.output());
+        if (rxHash.indexIn(cmd.output()) > -1)
-        if (reHash.hasMatch())
+            return rxHash.cap(1);
-            return reHash.captured(1);
     }
     return QStringLiteral("---");
 }
@@ -594,11 +590,10 @@ QString luks::getKeySize(const QString& deviceNode)
 {
     ExternalCommand cmd(QStringLiteral("cryptsetup"),
                         { QStringLiteral("luksDump"), deviceNode });
-    if (cmd.run(-1) && cmd.exitCode() == 0) {
+    if (cmd.run()) {
-        QRegularExpression re(QStringLiteral("MK bits:\\s+(\\d+)"));
+        QRegExp rxKeySize(QStringLiteral("(?:MK bits:\\s+)(\\d+)"));
-        QRegularExpressionMatch reKeySize = re.match(cmd.output());
+        if (rxKeySize.indexIn(cmd.output()) > -1)
-        if (reKeySize.hasMatch())
+            return rxKeySize.cap(1);
-            return reKeySize.captured(1);
     }
     return QStringLiteral("---");
 }
@@ -607,11 +602,10 @@ QString luks::getPayloadOffset(const QString& deviceNode)
 {
     ExternalCommand cmd(QStringLiteral("cryptsetup"),
                         { QStringLiteral("luksDump"), deviceNode });
-    if (cmd.run(-1) && cmd.exitCode() == 0) {
+    if (cmd.run()) {
-        QRegularExpression re(QStringLiteral("Payload offset:\\s+(\\d+)"));
+        QRegExp rxPayloadOffset(QStringLiteral("(?:Payload offset:\\s+)(\\d+)"));
-        QRegularExpressionMatch rePayloadOffset = re.match(cmd.output());
+        if (rxPayloadOffset.indexIn(cmd.output()) > -1)
-        if (rePayloadOffset.hasMatch())
+            return rxPayloadOffset.cap(1);
-            return rePayloadOffset.captured(1);
     }
     return QStringLiteral("---");
 }

src/fs/nilfs2.cpp

@@ -24,7 +24,6 @@
 
 #include <cmath>
 
-#include <QRegularExpression>
 #include <QString>
 #include <QTemporaryDir>
 #include <QUuid>
@@ -125,15 +124,12 @@ qint64 nilfs2::readUsedCapacity(const QString& deviceNode) const
 {
     ExternalCommand cmd(QStringLiteral("nilfs-tune"), { QStringLiteral("-l"), deviceNode });
 
-    if (cmd.run(-1) && cmd.exitCode() == 0) {
+    if (cmd.run()) {
-        QRegularExpression re(QStringLiteral("Block size:\\s+(\\d+)"));
+        QRegExp rxBlockSize(QStringLiteral("(?:Block size:\\s+)(\\d+)"));
-        QRegularExpressionMatch reBlockSize = re.match(cmd.output());
+        QRegExp rxDeviceSize(QStringLiteral("(?:Device size:\\s+)(\\d+)"));
-        re.setPattern(QStringLiteral("Device size:\\s+(\\d+)"));
+        QRegExp rxFreeBlocks(QStringLiteral("(?:Free blocks count:\\s+)(\\d+)"));
-        QRegularExpressionMatch reDeviceSize = re.match(cmd.output());
+        if (rxBlockSize.indexIn(cmd.output()) != -1 && rxDeviceSize.indexIn(cmd.output()) != -1 && rxFreeBlocks.indexIn(cmd.output()) != -1)
-        re.setPattern(QStringLiteral("Free blocks count:\\s+(\\d+)"));
+            return rxDeviceSize.cap(1).toLongLong() - rxBlockSize.cap(1).toLongLong() * rxFreeBlocks.cap(1).toLongLong();
-        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,14 +25,13 @@
 
 #include <KLocalizedString>
 
-#include <QRegularExpression>
 #include <QString>
 #include <QStringList>
 #include <QFile>
 #include <QUuid>
 
-#include <algorithm>
 #include <ctime>
+#include <algorithm>
 
 namespace FS
 {
@@ -108,13 +107,12 @@ qint64 ntfs::readUsedCapacity(const QString& deviceNode) const
 {
     ExternalCommand cmd(QStringLiteral("ntfsresize"), { QStringLiteral("--info"), QStringLiteral("--force"), QStringLiteral("--no-progress-bar"), deviceNode });
 
-    if (cmd.run(-1) && cmd.exitCode() == 0) {
+    if (cmd.run()) {
         qint64 usedBytes = -1;
-        QRegularExpression re(QStringLiteral("resize at (\\d+) bytes"));
+        QRegExp rxUsedBytes(QStringLiteral("resize at (\\d+) bytes"));
-        QRegularExpressionMatch reUsedBytes = re.match(cmd.output());
 
-        if (reUsedBytes.hasMatch())
+        if (rxUsedBytes.indexIn(cmd.output()) != -1)
-            usedBytes = reUsedBytes.captured(1).toLongLong();
+            usedBytes = rxUsedBytes.cap(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,12 +129,11 @@ 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(-1) && cmdBlockSize.exitCode() == 0) {
+    if (cmdBlockSize.run()) {
-        QRegularExpression re(QStringLiteral("Block Size Bits: (\\d+)"));
+        QRegExp rxBlockSizeBits(QStringLiteral("Block Size Bits: (\\d+)"));
-        QRegularExpressionMatch reBlockSizeBits = re.match(cmdBlockSize.output());
 
-        if (reBlockSizeBits.hasMatch())
+        if (rxBlockSizeBits.indexIn(cmdBlockSize.output()) != -1)
-            blockSize = 1 << reBlockSizeBits.captured(1).toInt();
+            blockSize = 1 << rxBlockSizeBits.cap(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,27 +87,24 @@ qint64 reiser4::readUsedCapacity(const QString& deviceNode) const
 {
     ExternalCommand cmd(QStringLiteral("debugfs.reiser4"), { deviceNode });
 
-    if (cmd.run(-1) && cmd.exitCode() == 16) {
+    if (cmd.run()) {
         qint64 blocks = -1;
-        QRegularExpression re(QStringLiteral("blocks:\\s+(\\d+)"));
+        QRegExp rxBlocks(QStringLiteral("blocks:\\s+(\\d+)"));
-        QRegularExpressionMatch reBlocks = re.match(cmd.output());
 
-        if (reBlocks.hasMatch())
+        if (rxBlocks.indexIn(cmd.output()) != -1)
-            blocks = reBlocks.captured(1).toLongLong();
+            blocks = rxBlocks.cap(1).toLongLong();
 
         qint64 blockSize = -1;
-        re.setPattern(QStringLiteral("blksize:\\s+(\\d+)"));
+        QRegExp rxBlockSize(QStringLiteral("blksize:\\s+(\\d+)"));
-        QRegularExpressionMatch reBlockSize = re.match(cmd.output());
 
-        if (reBlockSize.hasMatch())
+        if (rxBlockSize.indexIn(cmd.output()) != -1)
-            blockSize = reBlockSize.captured(1).toLongLong();
+            blockSize = rxBlockSize.cap(1).toLongLong();
 
         qint64 freeBlocks = -1;
-        re.setPattern(QStringLiteral("free blocks:\\s+(\\d+)"));
+        QRegExp rxFreeBlocks(QStringLiteral("free blocks:\\s+(\\d+)"));
-        QRegularExpressionMatch reFreeBlocks = re.match(cmd.output());
 
-        if (reFreeBlocks.hasMatch())
+        if (rxFreeBlocks.indexIn(cmd.output()) != -1)
-            freeBlocks = reFreeBlocks.captured(1).toLongLong();
+            freeBlocks = rxFreeBlocks.cap(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,27 +102,24 @@ qint64 reiserfs::readUsedCapacity(const QString& deviceNode) const
 {
     ExternalCommand cmd(QStringLiteral("debugreiserfs"), { deviceNode });
 
-    if (cmd.run(-1) && cmd.exitCode() == 16) {
+    if (cmd.run()) {
         qint64 blockCount = -1;
-        QRegularExpression re(QStringLiteral("Count of blocks[^:]+: (\\d+)"));
+        QRegExp rxBlockCount(QStringLiteral("Count of blocks[^:]+: (\\d+)"));
-        QRegularExpressionMatch reBlockCount = re.match(cmd.output());
 
-        if (reBlockCount.hasMatch())
+        if (rxBlockCount.indexIn(cmd.output()) != -1)
-            blockCount = reBlockCount.captured(1).toLongLong();
+            blockCount = rxBlockCount.cap(1).toLongLong();
 
         qint64 blockSize = -1;
-        re.setPattern(QStringLiteral("Blocksize: (\\d+)"));
+        QRegExp rxBlockSize(QStringLiteral("Blocksize: (\\d+)"));
-        QRegularExpressionMatch reBlockSize = re.match(cmd.output());
 
-        if (reBlockSize.hasMatch())
+        if (rxBlockSize.indexIn(cmd.output()) != -1)
-            blockSize = reBlockSize.captured(1).toLongLong();
+            blockSize = rxBlockSize.cap(1).toLongLong();
 
         qint64 freeBlocks = -1;
-        re.setPattern(QStringLiteral("Free blocks[^:]+: (\\d+)"));
+        QRegExp rxFreeBlocks(QStringLiteral("Free blocks[^:]+: (\\d+)"));
-        QRegularExpressionMatch reFreeBlocks = re.match(cmd.output());
 
-        if (reFreeBlocks.hasMatch())
+        if (rxFreeBlocks.indexIn(cmd.output()) != -1)
-            freeBlocks = reFreeBlocks.captured(1).toLongLong();
+            freeBlocks = rxFreeBlocks.cap(1).toLongLong();
 
         if (blockCount > -1 && blockSize > -1 && freeBlocks > -1)
             return (blockCount - freeBlocks) * blockSize;
@@ -169,7 +166,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(QRegularExpression(QStringLiteral("\\{|\\}")));
+    const QString uuid = QUuid::createUuid().toString().remove(QRegExp(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,27 +102,24 @@ 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(-1) && cmd.exitCode() == 0) {
+    if (cmd.run()) {
         qint64 dBlocks = -1;
-        QRegularExpression re(QStringLiteral("dblocks = (\\d+)"));
+        QRegExp rxDBlocks(QStringLiteral("dblocks = (\\d+)"));
-        QRegularExpressionMatch reDBlocks = re.match(cmd.output());
 
-        if (reDBlocks.hasMatch())
+        if (rxDBlocks.indexIn(cmd.output()) != -1)
-            dBlocks = reDBlocks.captured(1).toLongLong();
+            dBlocks = rxDBlocks.cap(1).toLongLong();
 
         qint64 blockSize = -1;
-        re.setPattern(QStringLiteral("blocksize = (\\d+)"));
+        QRegExp rxBlockSize(QStringLiteral("blocksize = (\\d+)"));
-        QRegularExpressionMatch reBlockSize = re.match(cmd.output());
 
-        if (reBlockSize.hasMatch())
+        if (rxBlockSize.indexIn(cmd.output()) != -1)
-            blockSize = reBlockSize.captured(1).toLongLong();
+            blockSize = rxBlockSize.cap(1).toLongLong();
 
         qint64 fdBlocks = -1;
-        re.setPattern(QStringLiteral("fdblocks = (\\d+)"));
+        QRegExp rxFdBlocks(QStringLiteral("fdblocks = (\\d+)"));
-        QRegularExpressionMatch reFdBlocks = re.match(cmd.output());
 
-        if (reFdBlocks.hasMatch())
+        if (rxFdBlocks.indexIn(cmd.output()) != -1)
-            fdBlocks = reFdBlocks.captured(1).toLongLong();
+            fdBlocks = rxFdBlocks.cap(1).toLongLong();
 
         if (dBlocks > -1 && blockSize > -1 && fdBlocks > -1)
             return (dBlocks - fdBlocks) * blockSize;