VirtualBox

Changeset 93996 in vbox


Ignore:
Timestamp:
Feb 28, 2022 10:04:49 PM (3 years ago)
Author:
vboxsync
Message:

FE/Qt: qt6: Regular expressions. bugref:9898

  • QString::remove, QString::replace and other does not accept QRegExp any more, must use QRegularExpression (qt4 debt).
  • Some uses of QRegExp was not converted, opting instead to include QRegExp from Core5Compat.
  • QRegExpValidator (removed) -> QRegularExpressionValidator (5.1) for setValidator.
Location:
trunk/src/VBox/Frontends/VirtualBox/src
Files:
42 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Frontends/VirtualBox/src/cloud/consolemanager/UICloudConsoleManager.cpp

    r93990 r93996  
    2323#include <QLineEdit>
    2424#include <QPushButton>
     25#include <QRegularExpression>
    2526#include <QUuid>
    2627#include <QVBoxLayout>
    … …  
    551552        if (pDialog->exec() == QDialog::Accepted)
    552553        {
    553             strId = QUuid::createUuid().toString().remove(QRegExp("[{}]"));
     554            strId = QUuid::createUuid().toString().remove(QRegularExpression("[{}]"));
    554555            strApplicationName = pDialog->name();
    555556            strApplicationPath = pDialog->path();
    … …  
    629630        if (pDialog->exec() == QDialog::Accepted)
    630631        {
    631             strId = QUuid::createUuid().toString().remove(QRegExp("[{}]"));
     632            strId = QUuid::createUuid().toString().remove(QRegularExpression("[{}]"));
    632633            strProfileName = pDialog->name();
    633634            strProfileArgument = pDialog->argument();

  • trunk/src/VBox/Frontends/VirtualBox/src/converter/UIConverterBackendGlobal.cpp

    r93988 r93996  
    1919#include <QApplication>
    2020#include <QHash>
     21#include <QRegExp>
    2122#include <QRegularExpression>
    2223

  • trunk/src/VBox/Frontends/VirtualBox/src/extensionpackmanager/UIExtensionPackManager.cpp

    r93990 r93996  
    132132
    133133    /* Version, Revision, Edition: */
    134     const QString strVersion(m_strVersion.section(QRegExp("[-_]"), 0, 0));
     134    const QString strVersion(m_strVersion.section(QRegularExpression("[-_]"), 0, 0));
    135135    // WORKAROUND:
    136136    // for http://qt.gitorious.org/qt/qt/commit/7fc63dd0ff368a637dcd17e692b9d6b26278b538
    137137    QString strAppend;
    138     if (m_strVersion.contains(QRegExp("[-_]")))
    139         strAppend = m_strVersion.section(QRegExp("[-_]"), 1, -1, QString::SectionIncludeLeadingSep);
     138    if (m_strVersion.contains(QRegularExpression("[-_]")))
     139        strAppend = m_strVersion.section(QRegularExpression("[-_]"), 1, -1, QString::SectionIncludeLeadingSep);
    140140    setText(ExtensionPackColumn_Version, QString("%1r%2%3").arg(strVersion).arg(m_uRevision).arg(strAppend));
    141141

  • trunk/src/VBox/Frontends/VirtualBox/src/extensions/QILabel.cpp

    r93115 r93996  
    4040
    4141/* static */
    42 const QRegExp QILabel::s_regExpCopy = QRegExp("<[^>]*>");
     42const QRegularExpression QILabel::s_regExpCopy = QRegularExpression("<[^>]*>");
    4343QRegExp QILabel::s_regExpElide = QRegExp("(<compact\\s+elipsis=\"(start|middle|end)\"?>([^<]*)</compact>)");
    4444
    … …  
    310310    QFontMetrics fm = fontMetrics();
    311311    /* Split up any multi-line text: */
    312     foreach (QString strLine, strText.split(QRegExp("<br */?>")))
     312    foreach (QString strLine, strText.split(QRegularExpression("<br */?>")))
    313313    {
    314314        /* Search for the compact tag: */

  • trunk/src/VBox/Frontends/VirtualBox/src/extensions/QILabel.h

    r93115 r93996  
    2828/* Qt includes: */
    2929#include <QLabel>
     30#include <QRegularExpression>
     31#include <QRegExp>
    3032
    3133/* GUI includes: */
    … …  
    128130
    129131    /** Holds text-copy reg-exp. */
    130     static const QRegExp s_regExpCopy;
     132    static const QRegularExpression s_regExpCopy;
    131133    /** Holds text-elide reg-exp. */
    132     static QRegExp       s_regExpElide;
     134    static QRegExp                  s_regExpElide;
    133135};
    134136

  • trunk/src/VBox/Frontends/VirtualBox/src/extensions/QIMessageBox.cpp

    r93982 r93996  
    2323#include <QMimeData>
    2424#include <QPushButton>
     25#include <QRegExp>
     26#include <QRegularExpression>
    2527#include <QStyle>
    2628#include <QVBoxLayout>
    … …  
    164166        strError += pair.first + pair.second + "<br>";
    165167    strError += "</body></html>";
    166     strError.remove(QRegExp("</+qt>"));
    167     strError = strError.replace(QRegExp("&nbsp;"), " ");
     168    strError.remove(QRegularExpression("</+qt>"));
     169    strError = strError.replace(QRegularExpression("&nbsp;"), " ");
    168170    /* Create a new mime data object holding both the html and the plain text version. */
    169171    QMimeData *pMimeData = new QMimeData();
    170172    pMimeData->setHtml(strError);
    171173    /* Replace all the html entities. */
    172     strError = strError.replace(QRegExp("<br>|</tr>"), "\n");
    173     strError = strError.replace(QRegExp("</p>"), "\n\n");
    174     strError = strError.remove(QRegExp("<[^>]*>"));
     174    strError = strError.replace(QRegularExpression("<br>|</tr>"), "\n");
     175    strError = strError.replace(QRegularExpression("</p>"), "\n\n");
     176    strError = strError.remove(QRegularExpression("<[^>]*>"));
    175177    pMimeData->setText(strError);
    176178    /* Add the mime data to the global clipboard. */

  • trunk/src/VBox/Frontends/VirtualBox/src/extradata/UIExtraDataManager.cpp

    r93990 r93996  
    2020#include <QMetaEnum>
    2121#include <QMutex>
     22#include <QRegExp>
    2223#include <QRegularExpression>
     24#include <QRegularExpressionValidator>
    2325#ifdef VBOX_GUI_WITH_EXTRADATA_MANAGER_UI
    2426# include <QComboBox>
    … …  
    10191021                    }
    10201022                    /* Create key-editor validator: */
    1021                     QObjectValidator *pKeyValidator = new QObjectValidator(new QRegExpValidator(QRegExp("[\\s\\S]+"), this));
     1023                    QObjectValidator *pKeyValidator
     1024                        = new QObjectValidator(new QRegularExpressionValidator(QRegularExpression("[\\s\\S]+"), this));
    10221025                    AssertPtrReturnVoid(pKeyValidator);
    10231026                    {
    … …  
    10531056                    }
    10541057                    /* Create value-editor validator: */
    1055                     QObjectValidator *pValueValidator = new QObjectValidator(new QRegExpValidator(QRegExp("[\\s\\S]+"), this));
     1058                    QObjectValidator *pValueValidator
     1059                        = new QObjectValidator(new QRegularExpressionValidator(QRegularExpression("[\\s\\S]+"), this));
    10561060                    AssertPtrReturnVoid(pValueValidator);
    10571061                    {
    … …  
    21852189     * All new separated by 'comma'. We have to take that into account. */
    21862190#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
    2187     return strValue.split(QRegExp("[;,]"), Qt::SkipEmptyParts);
     2191    return strValue.split(QRegularExpression("[;,]"), Qt::SkipEmptyParts);
    21882192#else
    2189     return strValue.split(QRegExp("[;,]"), QString::SkipEmptyParts);
     2193    return strValue.split(QRegularExpression("[;,]"), QString::SkipEmptyParts);
    21902194#endif
    21912195}

  • trunk/src/VBox/Frontends/VirtualBox/src/globals/UIDetailsGenerator.cpp

    r93115 r93996  
    671671        /* Gather adapter information: */
    672672        const KNetworkAttachmentType enmAttachmentType = comAdapter.GetAttachmentType();
    673         const QString strAttachmentTemplate = gpConverter->toString(comAdapter.GetAdapterType()).replace(QRegExp("\\s\\(.+\\)"), " (<a href=#%1,%2;%3;%4>%5</a>)");
     673        const QString strAttachmentTemplate = gpConverter->toString(comAdapter.GetAdapterType()).replace(QRegularExpression("\\s\\(.+\\)"),
     674                                                                                                         " (<a href=#%1,%2;%3;%4>%5</a>)");
    674675        QString strAttachmentType;
    675676        switch (enmAttachmentType)

  • trunk/src/VBox/Frontends/VirtualBox/src/globals/UITranslator.cpp

    r93115 r93996  
    2323# include <QLibraryInfo>
    2424#endif
     25#include <QRegularExpression>
     26#include <QRegExp>
    2527
    2628/* GUI includes: */
    … …  
    582584}
    583585
     586/* Regular expressions used by both highlight and emphasize.  They use the
     587   same prefix and suffix expression.  Unfortunately, QRegularExpression isn't
     588   thread safe, so we only store the string contstants here. */
     589/** @todo qt6: Both these had bogus suffix sets '[:.-!);]', I've changed them to '[-:.!);]', hope that's correct. */
     590static char const g_szRxSingleQuotes[] = "((?:^|\\s)[(]?)"
     591                                         "'([^']*)'"
     592                                         "(?=[-:.!);]?(?:\\s|$))";
     593static const char g_szRxUuid[]         = "((?:^|\\s)[(]?)"
     594                                         "(\\{[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{12}\\})"
     595                                         "(?=[-:.!);]?(?:\\s|$))";
     596
    584597/* static */
    585598QString UITranslator::highlight(QString strText, bool fToolTip /* = false */)
    … …  
    615628
    616629    /* Mark strings in single quotes with color: */
    617     QRegExp rx = QRegExp("((?:^|\\s)[(]?)'([^']*)'(?=[:.-!);]?(?:\\s|$))");
    618     rx.setMinimal(true);
    619     strText.replace(rx, QString("\\1%1<nobr>'\\2'</nobr>%2").arg(strFont).arg(endFont));
     630    strText.replace(QRegularExpression(g_szRxSingleQuotes), QString("\\1%1<nobr>'\\2'</nobr>%2").arg(strFont).arg(endFont));
    620631
    621632    /* Mark UUIDs with color: */
    622     strText.replace(QRegExp(
    623         "((?:^|\\s)[(]?)"
    624         "(\\{[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{12}\\})"
    625         "(?=[:.-!);]?(?:\\s|$))"),
    626         QString("\\1%1<nobr>\\2</nobr>%2").arg(uuidFont).arg(endFont));
     633    strText.replace(QRegularExpression(g_szRxUuid), QString("\\1%1<nobr>\\2</nobr>%2").arg(uuidFont).arg(endFont));
    627634
    628635    /* Split to paragraphs at \n chars: */
    … …  
    660667
    661668    /* Mark strings in single quotes with bold style: */
    662     QRegExp rx = QRegExp("((?:^|\\s)[(]?)'([^']*)'(?=[:.-!);]?(?:\\s|$))");
    663     rx.setMinimal(true);
    664     strText.replace(rx, QString("\\1%1<nobr>'\\2'</nobr>%2").arg(strEmphStart).arg(strEmphEnd));
     669    strText.replace(QRegularExpression(g_szRxSingleQuotes), QString("\\1%1<nobr>'\\2'</nobr>%2").arg(strEmphStart).arg(strEmphEnd));
    665670
    666671    /* Mark UUIDs with italic style: */
    667     strText.replace(QRegExp(
    668         "((?:^|\\s)[(]?)"
    669         "(\\{[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{12}\\})"
    670         "(?=[:.-!);]?(?:\\s|$))"),
    671         QString("\\1%1<nobr>\\2</nobr>%2").arg(uuidEmphStart).arg(uuidEmphEnd));
     672    strText.replace(QRegularExpression(g_szRxUuid), QString("\\1%1<nobr>\\2</nobr>%2").arg(uuidEmphStart).arg(uuidEmphEnd));
    672673
    673674    /* Split to paragraphs at \n chars: */

  • trunk/src/VBox/Frontends/VirtualBox/src/logviewer/UIVMLogViewerFilterPanel.cpp

    r93990 r93996  
    2727#include <QLineEdit>
    2828#include <QPlainTextEdit>
     29#include <QRegularExpression>
    2930#include <QTextCursor>
    3031#include <QRadioButton>
    … …  
    346347        iterator != m_filterTermSet.end(); ++iterator)
    347348    {
     349        /* Disregard empty and invalid filter terms: */
    348350        const QString& filterTerm = *iterator;
    349         const QRegExp rxFilterExp(filterTerm, Qt::CaseInsensitive);
    350         /* Disregard empty and invalid filter terms: */
    351         if (rxFilterExp.isEmpty() || !rxFilterExp.isValid())
     351        if (filterTerm.isEmpty())
     352            continue;
     353        const QRegularExpression rxFilterExp(filterTerm, QRegularExpression::CaseInsensitiveOption);
     354        if (!rxFilterExp.isValid())
    352355            continue;
    353356

  • trunk/src/VBox/Frontends/VirtualBox/src/manager/chooser/UIChooserAbstractModel.cpp

    r93990 r93996  
    1717
    1818/* Qt includes: */
     19#include <QRegExp>
     20#include <QRegularExpression>
    1921#include <QThread>
    2022
    … …  
    542544QString UIChooserAbstractModel::toOldStyleUuid(const QUuid &uId)
    543545{
    544     return uId.toString().remove(QRegExp("[{}]"));
     546    return uId.toString().remove(QRegularExpression("[{}]"));
    545547}
    546548

  • trunk/src/VBox/Frontends/VirtualBox/src/manager/chooser/UIChooserItemGroup.cpp

    r93115 r93996  
    2424#include <QLineEdit>
    2525#include <QPainter>
     26#include <QRegularExpression>
    2627#include <QStyleOptionGraphicsItem>
    2728#include <QWindow>
    … …  
    983984    /* We should replace forbidden symbols
    984985     * with ... well, probably underscores: */
    985     strNewName.replace(QRegExp("[\\\\/:*?\"<>]"), "_");
     986    strNewName.replace(QRegularExpression("[\\\\/:*?\"<>]"), "_");
    986987
    987988    /* Set new name, save settings: */

  • trunk/src/VBox/Frontends/VirtualBox/src/manager/chooser/UIChooserNodeMachine.cpp

    r93115 r93996  
    1515 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
    1616 */
     17
     18/* Qt includes: */
     19#include <qglobal.h>
     20#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
     21# include <QRegularExpression>
     22#else
     23# include <QRegExp>
     24#endif
    1725
    1826/* GUI includes: */
    … …  
    223231        else
    224232        {
     233#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0) /* fromWildcard is 6.0+ */
     234            QRegularExpression searchRegEx = QRegularExpression::fromWildcard(strSearchTerm, Qt::CaseInsensitive);
     235#else
    225236            QRegExp searchRegEx(strSearchTerm, Qt::CaseInsensitive, QRegExp::WildcardUnix);
     237#endif
    226238            if (name().contains(searchRegEx))
    227239                matchedItems << this;

  • trunk/src/VBox/Frontends/VirtualBox/src/manager/tools/UIToolsModel.cpp

    r93115 r93996  
    2323#include <QPropertyAnimation>
    2424#include <QScrollBar>
    25 #include <QRegExp>
    2625#include <QTimer>
    2726

  • trunk/src/VBox/Frontends/VirtualBox/src/networking/UIDownloaderExtensionPack.cpp

    r93982 r93996  
    1919#include <QDir>
    2020#include <QFile>
     21#include <QRegularExpression>
    2122#include <QVariant>
    2223
    … …  
    9596        foreach (const QString &strRecord, dictionary)
    9697        {
    97             QRegExp separator(" \\*|  ");
     98            QRegularExpression separator(" \\*|  ");
    9899            const QString strFileName = strRecord.section(separator, 1);
    99100            const QString strDownloadedSumm = strRecord.section(separator, 0, 0);

  • trunk/src/VBox/Frontends/VirtualBox/src/networking/UIDownloaderGuestAdditions.cpp

    r93982 r93996  
    1919#include <QDir>
    2020#include <QFile>
     21#include <QRegularExpression>
    2122#include <QVariant>
    2223
    … …  
    143144     * of tries to let user choose the place to save file to. */
    144145    QString strNetTarget = target();
    145     strNetTarget.remove(QRegExp("\\.tmp$"));
     146    strNetTarget.remove(QRegularExpression("\\.tmp$"));
    146147    setTarget(strNetTarget);
    147148    while (true)

  • trunk/src/VBox/Frontends/VirtualBox/src/networking/UINetworkReply.cpp

    r93982 r93996  
    2020#include <QFile>
    2121#include <QThread>
    22 #include <QRegExp>
    2322#include <QVector>
    2423#include <QVariant>

  • trunk/src/VBox/Frontends/VirtualBox/src/networking/UINewVersionChecker.cpp

    r93982 r93996  
    1717
    1818/* Qt includes: */
     19#include <QRegularExpression>
    1920#include <QUrlQuery>
    2021
    … …  
    103104#endif
    104105    /* Newer version of necessary package found: */
    105     if (strResponseData.indexOf(QRegExp("^\\d+\\.\\d+\\.\\d+(_[0-9A-Z]+)? \\S+$")) == 0)
     106    if (strResponseData.indexOf(QRegularExpression("^\\d+\\.\\d+\\.\\d+(_[0-9A-Z]+)? \\S+$")) == 0)
    106107    {
    107108#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)

  • trunk/src/VBox/Frontends/VirtualBox/src/networkmanager/UIDetailsWidgetCloudNetwork.cpp

    r93328 r93996  
    2323#include <QPushButton>
    2424#include <QRadioButton>
    25 #include <QRegExpValidator>
    2625#include <QStyleOption>
    2726#include <QVBoxLayout>

  • trunk/src/VBox/Frontends/VirtualBox/src/networkmanager/UIDetailsWidgetHostNetwork.cpp

    r93115 r93996  
    2121#include <QPushButton>
    2222#include <QRadioButton>
    23 #include <QRegExpValidator>
    2423#include <QStyleOption>
    2524#include <QVBoxLayout>

  • trunk/src/VBox/Frontends/VirtualBox/src/networkmanager/UINetworkManager.cpp

    r93871 r93996  
    2020#include <QMenuBar>
    2121#include <QPushButton>
     22#include <QRegExp>
    2223#include <QVBoxLayout>
    2324

  • trunk/src/VBox/Frontends/VirtualBox/src/objects/UIRichTextString.cpp

    r93115 r93996  
    1919#include <QApplication>
    2020#include <QPalette>
     21#include <QRegExp>
    2122
    2223/* GUI includes: */

  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachineLogic.cpp

    r93890 r93996  
    2222#include <QImageWriter>
    2323#include <QPainter>
     24#include <QRegExp>
    2425#include <QTimer>
    2526#ifdef VBOX_WS_MAC
    … …  
    19871988        const QString &s = formats.at(i) + " (*." + formats.at(i).toLower() + ")";
    19881989        /* Check there isn't an entry already (even if it just uses another capitalization) */
    1989         if (filters.indexOf(QRegExp(QRegExp::escape(s), Qt::CaseInsensitive)) == -1)
     1990        if (filters.indexOf(QRegularExpression(QRegularExpression::escape(s), QRegularExpression::CaseInsensitiveOption)) == -1)
    19901991            filters << s;
    19911992    }
    19921993    /* Try to select some common defaults: */
    19931994    QString strFilter;
    1994     int i = filters.indexOf(QRegExp(".*png.*", Qt::CaseInsensitive));
     1995    int i = filters.indexOf(QRegularExpression(".*png.*", QRegularExpression::CaseInsensitiveOption));
    19951996    if (i == -1)
    19961997    {
    1997         i = filters.indexOf(QRegExp(".*jpe+g.*", Qt::CaseInsensitive));
     1998        i = filters.indexOf(QRegularExpression(".*jpe+g.*", QRegularExpression::CaseInsensitiveOption));
    19981999        if (i == -1)
    1999             i = filters.indexOf(QRegExp(".*bmp.*", Qt::CaseInsensitive));
     2000            i = filters.indexOf(QRegularExpression(".*bmp.*", QRegularExpression::CaseInsensitiveOption));
    20002001    }
    20012002    if (i != -1)

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/editors/UIBootOrderEditor.cpp

    r93990 r93996  
    1919#include <QGridLayout>
    2020#include <QLabel>
     21#include <QRegularExpression>
    2122#include <QScrollBar>
    2223
    … …  
    404405        UIBootItemData data;
    405406        data.m_fEnabled = strArgument.startsWith('+');
    406         strArgument.remove(QRegExp("[+-]"));
     407        strArgument.remove(QRegularExpression("[+-]"));
    407408        data.m_enmType = static_cast<KDeviceType>(strArgument.toInt());
    408409        list << data;

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/editors/UILanguageSettingsEditor.cpp

    r93938 r93996  
    2020#include <QHeaderView>
    2121#include <QPainter>
     22#include <QRegExp>
    2223#include <QTranslator>
    2324#include <QVBoxLayout>

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/editors/UINameAndSystemEditor.cpp

    r93822 r93996  
    2020#include <QGridLayout>
    2121#include <QLabel>
     22#include <QRegularExpressionValidator>
    2223#include <QVBoxLayout>
    2324
    … …  
    267268    if (!m_pNameLineEdit)
    268269        return;
    269     m_pNameLineEdit->setValidator(new QRegExpValidator(QRegExp(strValidator), this));
     270    m_pNameLineEdit->setValidator(new QRegularExpressionValidator(QRegularExpression(strValidator), this));
    270271}
    271272

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/global/UIGlobalSettingsProxy.cpp

    r93818 r93996  
    2121#include <QLabel>
    2222#include <QRadioButton>
    23 #include <QRegExpValidator>
     23#include <QRegularExpressionValidator>
    2424
    2525/* GUI includes: */
    … …  
    305305                    if (m_pLabelHost)
    306306                        m_pLabelHost->setBuddy(m_pEditorHost);
    307                     m_pEditorHost->setValidator(new QRegExpValidator(QRegExp("\\S+"), m_pEditorHost));
     307                    m_pEditorHost->setValidator(new QRegularExpressionValidator(QRegularExpression("\\S+"), m_pEditorHost));
    308308
    309309                    pLayoutSettings->addWidget(m_pEditorHost);

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsDisplay.cpp

    r93829 r93996  
    2323#include <QLabel>
    2424#include <QLineEdit>
     25#include <QRegularExpressionValidator>
    2526#include <QSpinBox>
    2627#include <QStackedLayout>
    … …  
    12781279                        if (m_pLabelRemoteDisplayPort)
    12791280                            m_pLabelRemoteDisplayPort->setBuddy(m_pEditorRemoteDisplayPort);
    1280                         m_pEditorRemoteDisplayPort->setValidator(new QRegExpValidator(
    1281                             QRegExp("(([0-9]{1,5}(\\-[0-9]{1,5}){0,1}),)*([0-9]{1,5}(\\-[0-9]{1,5}){0,1})"), this));
     1281                        m_pEditorRemoteDisplayPort->setValidator(new QRegularExpressionValidator(
     1282                            QRegularExpression("(([0-9]{1,5}(\\-[0-9]{1,5}){0,1}),)*([0-9]{1,5}(\\-[0-9]{1,5}){0,1})"), this));
    12821283
    12831284                        pLayoutRemoteDisplaySettings->addWidget(m_pEditorRemoteDisplayPort, 0, 1);

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsNetwork.cpp

    r93829 r93996  
    2121#include <QGridLayout>
    2222#include <QLabel>
     23#include <QRegExp>
     24#include <QRegularExpressionValidator>
    2325#include <QPushButton>
    2426#include <QTextEdit>
    … …  
    935937            m_pLabelMAC->setBuddy(m_pEditorMAC);
    936938        m_pEditorMAC->setAllowToCopyContentsWhenDisabled(true);
    937         m_pEditorMAC->setValidator(new QRegExpValidator(QRegExp("[0-9A-Fa-f]{12}"), this));
     939        m_pEditorMAC->setValidator(new QRegularExpressionValidator(QRegularExpression("[0-9A-Fa-f]{12}"), this));
    938940        m_pEditorMAC->setMinimumWidthByText(QString().fill('0', 12));
    939941

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsSF.cpp

    r93990 r93996  
    1919#include <QHeaderView>
    2020#include <QMenu>
     21#include <QRegExp>
    2122#include <QTimer>
    2223#include <QVBoxLayout>

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsSerial.cpp

    r93829 r93996  
    2323#include <QLabel>
    2424#include <QLineEdit>
     25#include <QRegularExpressionValidator>
    2526
    2627/* GUI includes: */
    … …  
    484485                    if (m_pLabelPath)
    485486                        m_pLabelPath->setBuddy(m_pEditorPath);
    486                     m_pEditorPath->setValidator(new QRegExpValidator(QRegExp(".+"), this));
     487                    m_pEditorPath->setValidator(new QRegularExpressionValidator(QRegularExpression(".+"), this));
    487488                    pLayoutPortSettings->addWidget(m_pEditorPath, 3, 1, 1, 6);
    488489                }

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsUSB.cpp

    r93990 r93996  
    2424#include <QMenu>
    2525#include <QRadioButton>
     26#include <QRegExp>
    2627#include <QSpacerItem>
    2728#include <QToolTip>

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsUSBFilterDetails.cpp

    r93829 r93996  
    2121#include <QLabel>
    2222#include <QLineEdit>
     23#include <QRegularExpressionValidator>
    2324
    2425/* GUI includes: */
    … …  
    129130            if (m_pLabelName)
    130131                m_pLabelName->setBuddy(m_pEditorName);
    131             m_pEditorName->setValidator(new QRegExpValidator(QRegExp(".+"), this));
     132            m_pEditorName->setValidator(new QRegularExpressionValidator(QRegularExpression(".+"), this));
    132133
    133134            pLayoutMain->addWidget(m_pEditorName, 0, 1);
    … …  
    147148            if (m_pLabelVendorID)
    148149                m_pLabelVendorID->setBuddy(m_pEditorVendorID);
    149             m_pEditorVendorID->setValidator(new QRegExpValidator(QRegExp("[0-9a-fA-F]{0,4}"), this));
     150            m_pEditorVendorID->setValidator(new QRegularExpressionValidator(QRegularExpression("[0-9a-fA-F]{0,4}"), this));
    150151
    151152            pLayoutMain->addWidget(m_pEditorVendorID, 1, 1);
    … …  
    165166            if (m_pLabelProductID)
    166167                m_pLabelProductID->setBuddy(m_pEditorProductID);
    167             m_pEditorProductID->setValidator(new QRegExpValidator(QRegExp("[0-9a-fA-F]{0,4}"), this));
     168            m_pEditorProductID->setValidator(new QRegularExpressionValidator(QRegularExpression("[0-9a-fA-F]{0,4}"), this));
    168169
    169170            pLayoutMain->addWidget(m_pEditorProductID, 2, 1);
    … …  
    183184            if (m_pLabelRevision)
    184185                m_pLabelRevision->setBuddy(m_pEditorRevision);
    185             m_pEditorRevision->setValidator(new QRegExpValidator(QRegExp("[0-9a-fA-F]{0,4}"), this));
     186            m_pEditorRevision->setValidator(new QRegularExpressionValidator(QRegularExpression("[0-9a-fA-F]{0,4}"), this));
    186187
    187188            pLayoutMain->addWidget(m_pEditorRevision, 3, 1);
    … …  
    249250            if (m_pLabelPort)
    250251                m_pLabelPort->setBuddy(m_pEditorPort);
    251             m_pEditorPort->setValidator(new QRegExpValidator(QRegExp("[0-9]*"), this));
     252            m_pEditorPort->setValidator(new QRegularExpressionValidator(QRegularExpression("[0-9]*"), this));
    252253
    253254            pLayoutMain->addWidget(m_pEditorPort, 7, 1);

  • trunk/src/VBox/Frontends/VirtualBox/src/snapshots/UISnapshotDetailsWidget.cpp

    r93990 r93996  
    2525#include <QPainter>
    2626#include <QPushButton>
     27#include <QRegularExpression>
    2728#include <QScrollArea>
    2829#include <QTabWidget>
    … …  
    18541855        {
    18551856            /* Use adapter type string as template: */
    1856             QString strInfo = gpConverter->toString(comAdapter.GetAdapterType()).replace(QRegExp("\\s\\(.+\\)"), " (%1)");
     1857            QString strInfo = gpConverter->toString(comAdapter.GetAdapterType()).replace(QRegularExpression("\\s\\(.+\\)"), " (%1)");
    18571858            /* Don't use the adapter type string for types that have an additional
    18581859             * symbolic network/interface name field, use this name instead: */
    … …  
    19701971QString UISnapshotDetailsWidget::wipeHtmlStuff(const QString &strString)
    19711972{
    1972     return QString(strString).remove(QRegExp("<i>|</i>|<b>|</b>"));
     1973    return QString(strString).remove(QRegularExpression("<i>|</i>|<b>|</b>"));
    19731974}
    19741975

  • trunk/src/VBox/Frontends/VirtualBox/src/snapshots/UISnapshotPane.cpp

    r93115 r93996  
    2525#include <QPointer>
    2626#include <QReadWriteLock>
     27#include <QRegExp>
    2728#include <QScrollBar>
    2829#include <QTimer>

  • trunk/src/VBox/Frontends/VirtualBox/src/widgets/UIApplianceEditorWidget.cpp

    r93990 r93996  
    2323#include <QLabel>
    2424#include <QLineEdit>
     25#include <QRegExp>
    2526#include <QSpinBox>
    2627#include <QTextEdit>

  • trunk/src/VBox/Frontends/VirtualBox/src/widgets/UIEmptyFilePathSelector.cpp

    r93115 r93996  
    247247        return;
    248248
    249     path.remove (QRegExp ("[\\\\/]$"));
     249    path.remove(QRegularExpression("[\\\\/]$"));
    250250    setPath (path);
    251251}

  • trunk/src/VBox/Frontends/VirtualBox/src/widgets/UIFilePathSelector.cpp

    r93115 r93996  
    2727# include <QListView>
    2828#endif
     29#include <QRegExp>
    2930
    3031/* GUI includes: */
    … …  
    455456
    456457    /* Wipe out excessive slashes: */
    457     strSelPath.remove(QRegExp("[\\\\/]$"));
     458    strSelPath.remove(QRegularExpression("[\\\\/]$"));
    458459
    459460    /* Apply chosen path: */

  • trunk/src/VBox/Frontends/VirtualBox/src/widgets/UIMediumSizeEditor.cpp

    r93115 r93996  
    1919#include <QGridLayout>
    2020#include <QLabel>
    21 #include <QRegExpValidator>
     21#include <QRegularExpressionValidator>
    2222#include <QSlider>
    2323
    … …  
    189189            m_pEditor->setFixedWidthByText("88888.88 MB");
    190190            m_pEditor->setAlignment(Qt::AlignRight);
    191             m_pEditor->setValidator(new QRegExpValidator(QRegExp(UITranslator::sizeRegexp()), this));
     191            m_pEditor->setValidator(new QRegularExpressionValidator(QRegularExpression(UITranslator::sizeRegexp()), this));
    192192            connect(m_pEditor, &QILineEdit::textChanged,
    193193                    this, &UIMediumSizeEditor::sltSizeEditorTextChanged);

  • trunk/src/VBox/Frontends/VirtualBox/src/widgets/UIPortForwardingTable.cpp

    r93990 r93996  
    2424#include <QLineEdit>
    2525#include <QMenu>
     26#include <QRegExp>
    2627#include <QSpinBox>
    2728#include <QStyledItemDelegate>
    … …  
    6869        setFrame(false);
    6970        setAlignment(Qt::AlignLeft | Qt::AlignVCenter);
    70         setValidator(new QRegExpValidator(QRegExp("[^,:]*"), this));
     71        setValidator(new QRegularExpressionValidator(QRegularExpression("[^,:]*"), this));
    7172    }
    7273

  • trunk/src/VBox/Frontends/VirtualBox/src/widgets/graphics/UIGraphicsTextPane.cpp

    r93990 r93996  
    2323#include <QFontMetrics>
    2424#include <QGraphicsSceneHoverEvent>
     25#include <QRegularExpression>
    2526
    2627/* GUI includes: */
    … …  
    153154        {
    154155            /* Parse the 1st one to sub-lines: */
    155             QStringList subLines = strLeftLine.split(QRegExp("\\n"));
     156            QStringList subLines = strLeftLine.split(QRegularExpression("\\n"));
    156157            foreach (const QString &strSubLine, subLines)
    157158                m_text << UITextTableLine(strSubLine, QString(), parentWidget());

  • trunk/src/VBox/Frontends/VirtualBox/src/wizards/newvm/UIWizardNewVMNameOSTypePage.cpp

    r93643 r93996  
    1919#include <QCheckBox>
    2020#include <QDir>
     21#include <QRegularExpression>
    2122#include <QVBoxLayout>
    2223
    … …  
    3334#include "CUnattended.h"
    3435
    35 
    3636/* Defines some patterns to guess the right OS type. Should be in sync with
    3737 * VirtualBox-settings-common.xsd in Main. The list is sorted by priority. The
    … …  
    3939struct osTypePattern
    4040{
    41     QRegExp pattern;
     41    QRegularExpression pattern;
    4242    const char *pcstId;
    4343};
    … …  
    4646{
    4747    /* DOS: */
    48     { QRegExp("DOS", Qt::CaseInsensitive), "DOS" },
     48    { QRegularExpression("DOS", QRegularExpression::CaseInsensitiveOption), "DOS" },
    4949
    5050    /* Windows: */
    51     { QRegExp(  "Wi.*98",                         Qt::CaseInsensitive), "Windows98" },
    52     { QRegExp(  "Wi.*95",                         Qt::CaseInsensitive), "Windows95" },
    53     { QRegExp(  "Wi.*Me",                         Qt::CaseInsensitive), "WindowsMe" },
    54     { QRegExp( "(Wi.*NT)|(NT[-._v]*4)",           Qt::CaseInsensitive), "WindowsNT4" },
    55     { QRegExp( "NT[-._v]*3[.,]*[51x]",            Qt::CaseInsensitive), "WindowsNT3x" },
     51    { QRegularExpression(  "Wi.*98",                         QRegularExpression::CaseInsensitiveOption), "Windows98" },
     52    { QRegularExpression(  "Wi.*95",                         QRegularExpression::CaseInsensitiveOption), "Windows95" },
     53    { QRegularExpression(  "Wi.*Me",                         QRegularExpression::CaseInsensitiveOption), "WindowsMe" },
     54    { QRegularExpression( "(Wi.*NT)|(NT[-._v]*4)",           QRegularExpression::CaseInsensitiveOption), "WindowsNT4" },
     55    { QRegularExpression( "NT[-._v]*3[.,]*[51x]",            QRegularExpression::CaseInsensitiveOption), "WindowsNT3x" },
    5656    /* Note: Do not automatically set WindowsXP_64 on 64-bit hosts, as Windows XP 64-bit
    5757     *       is extremely rare -- most users never heard of it even. So always default to 32-bit. */
    58     { QRegExp("((Wi.*XP)|(XP)).*",                Qt::CaseInsensitive), "WindowsXP" },
    59     { QRegExp("((Wi.*2003)|(W2K3)|(Win2K3)).*64", Qt::CaseInsensitive), "Windows2003_64" },
    60     { QRegExp("((Wi.*2003)|(W2K3)|(Win2K3)).*32", Qt::CaseInsensitive), "Windows2003" },
    61     { QRegExp("((Wi.*Vis)|(Vista)).*64",          Qt::CaseInsensitive), "WindowsVista_64" },
    62     { QRegExp("((Wi.*Vis)|(Vista)).*32",          Qt::CaseInsensitive), "WindowsVista" },
    63     { QRegExp( "(Wi.*2016)|(W2K16)|(Win2K16)",    Qt::CaseInsensitive), "Windows2016_64" },
    64     { QRegExp( "(Wi.*2012)|(W2K12)|(Win2K12)",    Qt::CaseInsensitive), "Windows2012_64" },
    65     { QRegExp("((Wi.*2008)|(W2K8)|(Win2k8)).*64", Qt::CaseInsensitive), "Windows2008_64" },
    66     { QRegExp("((Wi.*2008)|(W2K8)|(Win2K8)).*32", Qt::CaseInsensitive), "Windows2008" },
    67     { QRegExp( "(Wi.*2000)|(W2K)|(Win2K)",        Qt::CaseInsensitive), "Windows2000" },
    68     { QRegExp( "(Wi.*7.*64)|(W7.*64)",            Qt::CaseInsensitive), "Windows7_64" },
    69     { QRegExp( "(Wi.*7.*32)|(W7.*32)",            Qt::CaseInsensitive), "Windows7" },
    70     { QRegExp( "(Wi.*8.*1.*64)|(W8.*64)",         Qt::CaseInsensitive), "Windows81_64" },
    71     { QRegExp( "(Wi.*8.*1.*32)|(W8.*32)",         Qt::CaseInsensitive), "Windows81" },
    72     { QRegExp( "(Wi.*8.*64)|(W8.*64)",            Qt::CaseInsensitive), "Windows8_64" },
    73     { QRegExp( "(Wi.*8.*32)|(W8.*32)",            Qt::CaseInsensitive), "Windows8" },
    74     { QRegExp( "(Wi.*10.*64)|(W10.*64)",          Qt::CaseInsensitive), "Windows10_64" },
    75     { QRegExp( "(Wi.*10.*32)|(W10.*32)",          Qt::CaseInsensitive), "Windows10" },
    76     { QRegExp( "(Wi.*11)|(W11)",                  Qt::CaseInsensitive), "Windows11_64" },
    77     { QRegExp(  "Wi.*3.*1",                       Qt::CaseInsensitive), "Windows31" },
     58    { QRegularExpression("((Wi.*XP)|(XP)).*",                QRegularExpression::CaseInsensitiveOption), "WindowsXP" },
     59    { QRegularExpression("((Wi.*2003)|(W2K3)|(Win2K3)).*64", QRegularExpression::CaseInsensitiveOption), "Windows2003_64" },
     60    { QRegularExpression("((Wi.*2003)|(W2K3)|(Win2K3)).*32", QRegularExpression::CaseInsensitiveOption), "Windows2003" },
     61    { QRegularExpression("((Wi.*Vis)|(Vista)).*64",          QRegularExpression::CaseInsensitiveOption), "WindowsVista_64" },
     62    { QRegularExpression("((Wi.*Vis)|(Vista)).*32",          QRegularExpression::CaseInsensitiveOption), "WindowsVista" },
     63    { QRegularExpression( "(Wi.*2016)|(W2K16)|(Win2K16)",    QRegularExpression::CaseInsensitiveOption), "Windows2016_64" },
     64    { QRegularExpression( "(Wi.*2012)|(W2K12)|(Win2K12)",    QRegularExpression::CaseInsensitiveOption), "Windows2012_64" },
     65    { QRegularExpression("((Wi.*2008)|(W2K8)|(Win2k8)).*64", QRegularExpression::CaseInsensitiveOption), "Windows2008_64" },
     66    { QRegularExpression("((Wi.*2008)|(W2K8)|(Win2K8)).*32", QRegularExpression::CaseInsensitiveOption), "Windows2008" },
     67    { QRegularExpression( "(Wi.*2000)|(W2K)|(Win2K)",        QRegularExpression::CaseInsensitiveOption), "Windows2000" },
     68    { QRegularExpression( "(Wi.*7.*64)|(W7.*64)",            QRegularExpression::CaseInsensitiveOption), "Windows7_64" },
     69    { QRegularExpression( "(Wi.*7.*32)|(W7.*32)",            QRegularExpression::CaseInsensitiveOption), "Windows7" },
     70    { QRegularExpression( "(Wi.*8.*1.*64)|(W8.*64)",         QRegularExpression::CaseInsensitiveOption), "Windows81_64" },
     71    { QRegularExpression( "(Wi.*8.*1.*32)|(W8.*32)",         QRegularExpression::CaseInsensitiveOption), "Windows81" },
     72    { QRegularExpression( "(Wi.*8.*64)|(W8.*64)",            QRegularExpression::CaseInsensitiveOption), "Windows8_64" },
     73    { QRegularExpression( "(Wi.*8.*32)|(W8.*32)",            QRegularExpression::CaseInsensitiveOption), "Windows8" },
     74    { QRegularExpression( "(Wi.*10.*64)|(W10.*64)",          QRegularExpression::CaseInsensitiveOption), "Windows10_64" },
     75    { QRegularExpression( "(Wi.*10.*32)|(W10.*32)",          QRegularExpression::CaseInsensitiveOption), "Windows10" },
     76    { QRegularExpression( "(Wi.*11)|(W11)",                  QRegularExpression::CaseInsensitiveOption), "Windows11_64" },
     77    { QRegularExpression(  "Wi.*3.*1",                       QRegularExpression::CaseInsensitiveOption), "Windows31" },
    7878    /* Set Windows 10 as default for "Windows". */
    79     { QRegExp(  "Wi.*64",                         Qt::CaseInsensitive), "Windows10_64" },
    80     { QRegExp(  "Wi.*32",                         Qt::CaseInsensitive), "Windows10" },
     79    { QRegularExpression(  "Wi.*64",                         QRegularExpression::CaseInsensitiveOption), "Windows10_64" },
     80    { QRegularExpression(  "Wi.*32",                         QRegularExpression::CaseInsensitiveOption), "Windows10" },
    8181    /* ReactOS wants to be considered as Windows 2003 */
    82     { QRegExp(  "Reac.*",                         Qt::CaseInsensitive), "Windows2003" },
     82    { QRegularExpression(  "Reac.*",                         QRegularExpression::CaseInsensitiveOption), "Windows2003" },
    8383
    8484    /* Solaris: */
    85     { QRegExp("Sol.*11",                                                  Qt::CaseInsensitive), "Solaris11_64" },
    86     { QRegExp("((Op.*Sol)|(os20[01][0-9])|(Sol.*10)|(India)|(Neva)).*64", Qt::CaseInsensitive), "OpenSolaris_64" },
    87     { QRegExp("((Op.*Sol)|(os20[01][0-9])|(Sol.*10)|(India)|(Neva)).*32", Qt::CaseInsensitive), "OpenSolaris" },
    88     { QRegExp("Sol.*64",                                                  Qt::CaseInsensitive), "Solaris_64" },
    89     { QRegExp("Sol.*32",                                                  Qt::CaseInsensitive), "Solaris" },
     85    { QRegularExpression("Sol.*11",                                                  QRegularExpression::CaseInsensitiveOption), "Solaris11_64" },
     86    { QRegularExpression("((Op.*Sol)|(os20[01][0-9])|(Sol.*10)|(India)|(Neva)).*64", QRegularExpression::CaseInsensitiveOption), "OpenSolaris_64" },
     87    { QRegularExpression("((Op.*Sol)|(os20[01][0-9])|(Sol.*10)|(India)|(Neva)).*32", QRegularExpression::CaseInsensitiveOption), "OpenSolaris" },
     88    { QRegularExpression("Sol.*64",                                                  QRegularExpression::CaseInsensitiveOption), "Solaris_64" },
     89    { QRegularExpression("Sol.*32",                                                  QRegularExpression::CaseInsensitiveOption), "Solaris" },
    9090
    9191    /* OS/2: */
    92     { QRegExp("OS[/|!-]{,1}2.*W.*4.?5", Qt::CaseInsensitive), "OS2Warp45" },
    93     { QRegExp("OS[/|!-]{,1}2.*W.*4",    Qt::CaseInsensitive), "OS2Warp4" },
    94     { QRegExp("OS[/|!-]{,1}2.*W",       Qt::CaseInsensitive), "OS2Warp3" },
    95     { QRegExp("OS[/|!-]{,1}2.*e",       Qt::CaseInsensitive), "OS2eCS" },
    96     { QRegExp("OS[/|!-]{,1}2.*Ar.*",    Qt::CaseInsensitive), "OS2ArcaOS" },
    97     { QRegExp("OS[/|!-]{,1}2",          Qt::CaseInsensitive), "OS2" },
    98     { QRegExp("(eComS.*|eCS.*)",        Qt::CaseInsensitive), "OS2eCS" },
    99     { QRegExp("Arca.*",                 Qt::CaseInsensitive), "OS2ArcaOS" },
     92    { QRegularExpression("OS[/|!-]{,1}2.*W.*4.?5", QRegularExpression::CaseInsensitiveOption), "OS2Warp45" },
     93    { QRegularExpression("OS[/|!-]{,1}2.*W.*4",    QRegularExpression::CaseInsensitiveOption), "OS2Warp4" },
     94    { QRegularExpression("OS[/|!-]{,1}2.*W",       QRegularExpression::CaseInsensitiveOption), "OS2Warp3" },
     95    { QRegularExpression("OS[/|!-]{,1}2.*e",       QRegularExpression::CaseInsensitiveOption), "OS2eCS" },
     96    { QRegularExpression("OS[/|!-]{,1}2.*Ar.*",    QRegularExpression::CaseInsensitiveOption), "OS2ArcaOS" },
     97    { QRegularExpression("OS[/|!-]{,1}2",          QRegularExpression::CaseInsensitiveOption), "OS2" },
     98    { QRegularExpression("(eComS.*|eCS.*)",        QRegularExpression::CaseInsensitiveOption), "OS2eCS" },
     99    { QRegularExpression("Arca.*",                 QRegularExpression::CaseInsensitiveOption), "OS2ArcaOS" },
    100100
    101101    /* Other: Must come before Ubuntu/Maverick and before Linux??? */
    102     { QRegExp("QN", Qt::CaseInsensitive), "QNX" },
     102    { QRegularExpression("QN", QRegularExpression::CaseInsensitiveOption), "QNX" },
    103103
    104104    /* Mac OS X: Must come before Ubuntu/Maverick and before Linux: */
    105     { QRegExp("((mac.*10[.,]{0,1}4)|(os.*x.*10[.,]{0,1}4)|(mac.*ti)|(os.*x.*ti)|(Tig)).64",     Qt::CaseInsensitive), "MacOS_64" },
    106     { QRegExp("((mac.*10[.,]{0,1}4)|(os.*x.*10[.,]{0,1}4)|(mac.*ti)|(os.*x.*ti)|(Tig)).32",     Qt::CaseInsensitive), "MacOS" },
    107     { QRegExp("((mac.*10[.,]{0,1}5)|(os.*x.*10[.,]{0,1}5)|(mac.*leo)|(os.*x.*leo)|(Leop)).*64", Qt::CaseInsensitive), "MacOS_64" },
    108     { QRegExp("((mac.*10[.,]{0,1}5)|(os.*x.*10[.,]{0,1}5)|(mac.*leo)|(os.*x.*leo)|(Leop)).*32", Qt::CaseInsensitive), "MacOS" },
    109     { QRegExp("((mac.*10[.,]{0,1}6)|(os.*x.*10[.,]{0,1}6)|(mac.*SL)|(os.*x.*SL)|(Snow L)).*64", Qt::CaseInsensitive), "MacOS106_64" },
    110     { QRegExp("((mac.*10[.,]{0,1}6)|(os.*x.*10[.,]{0,1}6)|(mac.*SL)|(os.*x.*SL)|(Snow L)).*32", Qt::CaseInsensitive), "MacOS106" },
    111     { QRegExp( "(mac.*10[.,]{0,1}7)|(os.*x.*10[.,]{0,1}7)|(mac.*ML)|(os.*x.*ML)|(Mount)",       Qt::CaseInsensitive), "MacOS108_64" },
    112     { QRegExp( "(mac.*10[.,]{0,1}8)|(os.*x.*10[.,]{0,1}8)|(Lion)",                              Qt::CaseInsensitive), "MacOS107_64" },
    113     { QRegExp( "(mac.*10[.,]{0,1}9)|(os.*x.*10[.,]{0,1}9)|(mac.*mav)|(os.*x.*mav)|(Mavericks)", Qt::CaseInsensitive), "MacOS109_64" },
    114     { QRegExp( "(mac.*yos)|(os.*x.*yos)|(Yosemite)",                                            Qt::CaseInsensitive), "MacOS1010_64" },
    115     { QRegExp( "(mac.*cap)|(os.*x.*capit)|(Capitan)",                                           Qt::CaseInsensitive), "MacOS1011_64" },
    116     { QRegExp( "(mac.*hig)|(os.*x.*high.*sierr)|(High Sierra)",                                 Qt::CaseInsensitive), "MacOS1013_64" },
    117     { QRegExp( "(mac.*sie)|(os.*x.*sierr)|(Sierra)",                                            Qt::CaseInsensitive), "MacOS1012_64" },
    118     { QRegExp("((Mac)|(Tig)|(Leop)|(Yose)|(os[ ]*x)).*64",                                      Qt::CaseInsensitive), "MacOS_64" },
    119     { QRegExp("((Mac)|(Tig)|(Leop)|(Yose)|(os[ ]*x)).*32",                                      Qt::CaseInsensitive), "MacOS" },
     105    { QRegularExpression("((mac.*10[.,]{0,1}4)|(os.*x.*10[.,]{0,1}4)|(mac.*ti)|(os.*x.*ti)|(Tig)).64",     QRegularExpression::CaseInsensitiveOption), "MacOS_64" },
     106    { QRegularExpression("((mac.*10[.,]{0,1}4)|(os.*x.*10[.,]{0,1}4)|(mac.*ti)|(os.*x.*ti)|(Tig)).32",     QRegularExpression::CaseInsensitiveOption), "MacOS" },
     107    { QRegularExpression("((mac.*10[.,]{0,1}5)|(os.*x.*10[.,]{0,1}5)|(mac.*leo)|(os.*x.*leo)|(Leop)).*64", QRegularExpression::CaseInsensitiveOption), "MacOS_64" },
     108    { QRegularExpression("((mac.*10[.,]{0,1}5)|(os.*x.*10[.,]{0,1}5)|(mac.*leo)|(os.*x.*leo)|(Leop)).*32", QRegularExpression::CaseInsensitiveOption), "MacOS" },
     109    { QRegularExpression("((mac.*10[.,]{0,1}6)|(os.*x.*10[.,]{0,1}6)|(mac.*SL)|(os.*x.*SL)|(Snow L)).*64", QRegularExpression::CaseInsensitiveOption), "MacOS106_64" },
     110    { QRegularExpression("((mac.*10[.,]{0,1}6)|(os.*x.*10[.,]{0,1}6)|(mac.*SL)|(os.*x.*SL)|(Snow L)).*32", QRegularExpression::CaseInsensitiveOption), "MacOS106" },
     111    { QRegularExpression( "(mac.*10[.,]{0,1}7)|(os.*x.*10[.,]{0,1}7)|(mac.*ML)|(os.*x.*ML)|(Mount)",       QRegularExpression::CaseInsensitiveOption), "MacOS108_64" },
     112    { QRegularExpression( "(mac.*10[.,]{0,1}8)|(os.*x.*10[.,]{0,1}8)|(Lion)",                              QRegularExpression::CaseInsensitiveOption), "MacOS107_64" },
     113    { QRegularExpression( "(mac.*10[.,]{0,1}9)|(os.*x.*10[.,]{0,1}9)|(mac.*mav)|(os.*x.*mav)|(Mavericks)", QRegularExpression::CaseInsensitiveOption), "MacOS109_64" },
     114    { QRegularExpression( "(mac.*yos)|(os.*x.*yos)|(Yosemite)",                                            QRegularExpression::CaseInsensitiveOption), "MacOS1010_64" },
     115    { QRegularExpression( "(mac.*cap)|(os.*x.*capit)|(Capitan)",                                           QRegularExpression::CaseInsensitiveOption), "MacOS1011_64" },
     116    { QRegularExpression( "(mac.*hig)|(os.*x.*high.*sierr)|(High Sierra)",                                 QRegularExpression::CaseInsensitiveOption), "MacOS1013_64" },
     117    { QRegularExpression( "(mac.*sie)|(os.*x.*sierr)|(Sierra)",                                            QRegularExpression::CaseInsensitiveOption), "MacOS1012_64" },
     118    { QRegularExpression("((Mac)|(Tig)|(Leop)|(Yose)|(os[ ]*x)).*64",                                      QRegularExpression::CaseInsensitiveOption), "MacOS_64" },
     119    { QRegularExpression("((Mac)|(Tig)|(Leop)|(Yose)|(os[ ]*x)).*32",                                      QRegularExpression::CaseInsensitiveOption), "MacOS" },
    120120
    121121    /* Code names for Linux distributions: */
    122     { QRegExp("((bianca)|(cassandra)|(celena)|(daryna)|(elyssa)|(felicia)|(gloria)|(helena)|(isadora)|(julia)|(katya)|(lisa)|(maya)|(nadia)|(olivia)|(petra)|(qiana)|(rebecca)|(rafaela)|(rosa)).*64", Qt::CaseInsensitive), "Ubuntu_64" },
    123     { QRegExp("((bianca)|(cassandra)|(celena)|(daryna)|(elyssa)|(felicia)|(gloria)|(helena)|(isadora)|(julia)|(katya)|(lisa)|(maya)|(nadia)|(olivia)|(petra)|(qiana)|(rebecca)|(rafaela)|(rosa)).*32", Qt::CaseInsensitive), "Ubuntu" },
    124     { QRegExp("((edgy)|(feisty)|(gutsy)|(hardy)|(intrepid)|(jaunty)|(karmic)|(lucid)|(maverick)|(natty)|(oneiric)|(precise)|(quantal)|(raring)|(saucy)|(trusty)|(utopic)|(vivid)|(wily)|(xenial)|(yakkety)|(zesty)).*64", Qt::CaseInsensitive), "Ubuntu_64" },
    125     { QRegExp("((edgy)|(feisty)|(gutsy)|(hardy)|(intrepid)|(jaunty)|(karmic)|(lucid)|(maverick)|(natty)|(oneiric)|(precise)|(quantal)|(raring)|(saucy)|(trusty)|(utopic)|(vivid)|(wily)|(xenial)|(yakkety)|(zesty)).*32", Qt::CaseInsensitive), "Ubuntu" },
    126     { QRegExp("((sarge)|(etch)|(lenny)|(squeeze)|(wheezy)|(jessie)|(stretch)|(buster)|(sid)).*64", Qt::CaseInsensitive), "Debian_64" },
    127     { QRegExp("((sarge)|(etch)|(lenny)|(squeeze)|(wheezy)|(jessie)|(stretch)|(buster)|(sid)).*32", Qt::CaseInsensitive), "Debian" },
    128     { QRegExp("((moonshine)|(werewolf)|(sulphur)|(cambridge)|(leonidas)|(constantine)|(goddard)|(laughlin)|(lovelock)|(verne)|(beefy)|(spherical)).*64", Qt::CaseInsensitive), "Fedora_64" },
    129     { QRegExp("((moonshine)|(werewolf)|(sulphur)|(cambridge)|(leonidas)|(constantine)|(goddard)|(laughlin)|(lovelock)|(verne)|(beefy)|(spherical)).*32", Qt::CaseInsensitive), "Fedora" },
     122    { QRegularExpression("((bianca)|(cassandra)|(celena)|(daryna)|(elyssa)|(felicia)|(gloria)|(helena)|(isadora)|(julia)|(katya)|(lisa)|(maya)|(nadia)|(olivia)|(petra)|(qiana)|(rebecca)|(rafaela)|(rosa)).*64", QRegularExpression::CaseInsensitiveOption), "Ubuntu_64" },
     123    { QRegularExpression("((bianca)|(cassandra)|(celena)|(daryna)|(elyssa)|(felicia)|(gloria)|(helena)|(isadora)|(julia)|(katya)|(lisa)|(maya)|(nadia)|(olivia)|(petra)|(qiana)|(rebecca)|(rafaela)|(rosa)).*32", QRegularExpression::CaseInsensitiveOption), "Ubuntu" },
     124    { QRegularExpression("((edgy)|(feisty)|(gutsy)|(hardy)|(intrepid)|(jaunty)|(karmic)|(lucid)|(maverick)|(natty)|(oneiric)|(precise)|(quantal)|(raring)|(saucy)|(trusty)|(utopic)|(vivid)|(wily)|(xenial)|(yakkety)|(zesty)).*64", QRegularExpression::CaseInsensitiveOption), "Ubuntu_64" },
     125    { QRegularExpression("((edgy)|(feisty)|(gutsy)|(hardy)|(intrepid)|(jaunty)|(karmic)|(lucid)|(maverick)|(natty)|(oneiric)|(precise)|(quantal)|(raring)|(saucy)|(trusty)|(utopic)|(vivid)|(wily)|(xenial)|(yakkety)|(zesty)).*32", QRegularExpression::CaseInsensitiveOption), "Ubuntu" },
     126    { QRegularExpression("((sarge)|(etch)|(lenny)|(squeeze)|(wheezy)|(jessie)|(stretch)|(buster)|(sid)).*64", QRegularExpression::CaseInsensitiveOption), "Debian_64" },
     127    { QRegularExpression("((sarge)|(etch)|(lenny)|(squeeze)|(wheezy)|(jessie)|(stretch)|(buster)|(sid)).*32", QRegularExpression::CaseInsensitiveOption), "Debian" },
     128    { QRegularExpression("((moonshine)|(werewolf)|(sulphur)|(cambridge)|(leonidas)|(constantine)|(goddard)|(laughlin)|(lovelock)|(verne)|(beefy)|(spherical)).*64", QRegularExpression::CaseInsensitiveOption), "Fedora_64" },
     129    { QRegularExpression("((moonshine)|(werewolf)|(sulphur)|(cambridge)|(leonidas)|(constantine)|(goddard)|(laughlin)|(lovelock)|(verne)|(beefy)|(spherical)).*32", QRegularExpression::CaseInsensitiveOption), "Fedora" },
    130130
    131131    /* Regular names of Linux distributions: */
    132     { QRegExp("Arc.*64",                           Qt::CaseInsensitive), "ArchLinux_64" },
    133     { QRegExp("Arc.*32",                           Qt::CaseInsensitive), "ArchLinux" },
    134     { QRegExp("Deb.*64",                           Qt::CaseInsensitive), "Debian_64" },
    135     { QRegExp("Deb.*32",                           Qt::CaseInsensitive), "Debian" },
    136     { QRegExp("((SU)|(Nov)|(SLE)).*64",            Qt::CaseInsensitive), "OpenSUSE_64" },
    137     { QRegExp("((SU)|(Nov)|(SLE)).*32",            Qt::CaseInsensitive), "OpenSUSE" },
    138     { QRegExp("Fe.*64",                            Qt::CaseInsensitive), "Fedora_64" },
    139     { QRegExp("Fe.*32",                            Qt::CaseInsensitive), "Fedora" },
    140     { QRegExp("((Gen)|(Sab)).*64",                 Qt::CaseInsensitive), "Gentoo_64" },
    141     { QRegExp("((Gen)|(Sab)).*32",                 Qt::CaseInsensitive), "Gentoo" },
    142     { QRegExp("((Man)|(Mag)).*64",                 Qt::CaseInsensitive), "Mandriva_64" },
    143     { QRegExp("((Man)|(Mag)).*32",                 Qt::CaseInsensitive), "Mandriva" },
    144     { QRegExp("((Red)|(rhel)|(cen)).*64",          Qt::CaseInsensitive), "RedHat_64" },
    145     { QRegExp("((Red)|(rhel)|(cen)).*32",          Qt::CaseInsensitive), "RedHat" },
    146     { QRegExp("Tur.*64",                           Qt::CaseInsensitive), "Turbolinux_64" },
    147     { QRegExp("Tur.*32",                           Qt::CaseInsensitive), "Turbolinux" },
    148     { QRegExp("((Ub)|(Mint)).*64",                 Qt::CaseInsensitive), "Ubuntu_64" },
    149     { QRegExp("((Ub)|(Mint)).*32",                 Qt::CaseInsensitive), "Ubuntu" },
    150     { QRegExp("Xa.*64",                            Qt::CaseInsensitive), "Xandros_64" },
    151     { QRegExp("Xa.*32",                            Qt::CaseInsensitive), "Xandros" },
    152     { QRegExp("((Or)|(oel)|(ol)).*64",             Qt::CaseInsensitive), "Oracle_64" },
    153     { QRegExp("((Or)|(oel)|(ol)).*32",             Qt::CaseInsensitive), "Oracle" },
    154     { QRegExp("Knoppix",                           Qt::CaseInsensitive), "Linux26" },
    155     { QRegExp("Dsl",                               Qt::CaseInsensitive), "Linux24" },
    156     { QRegExp("((Lin)|(lnx)).*2.?2",               Qt::CaseInsensitive), "Linux22" },
    157     { QRegExp("((Lin)|(lnx)).*2.?4.*64",           Qt::CaseInsensitive), "Linux24_64" },
    158     { QRegExp("((Lin)|(lnx)).*2.?4.*32",           Qt::CaseInsensitive), "Linux24" },
    159     { QRegExp("((((Lin)|(lnx)).*2.?6)|(LFS)).*64", Qt::CaseInsensitive), "Linux26_64" },
    160     { QRegExp("((((Lin)|(lnx)).*2.?6)|(LFS)).*32", Qt::CaseInsensitive), "Linux26" },
    161     { QRegExp("((Lin)|(lnx)).*64",                 Qt::CaseInsensitive), "Linux26_64" },
    162     { QRegExp("((Lin)|(lnx)).*32",                 Qt::CaseInsensitive), "Linux26" },
     132    { QRegularExpression("Arc.*64",                           QRegularExpression::CaseInsensitiveOption), "ArchLinux_64" },
     133    { QRegularExpression("Arc.*32",                           QRegularExpression::CaseInsensitiveOption), "ArchLinux" },
     134    { QRegularExpression("Deb.*64",                           QRegularExpression::CaseInsensitiveOption), "Debian_64" },
     135    { QRegularExpression("Deb.*32",                           QRegularExpression::CaseInsensitiveOption), "Debian" },
     136    { QRegularExpression("((SU)|(Nov)|(SLE)).*64",            QRegularExpression::CaseInsensitiveOption), "OpenSUSE_64" },
     137    { QRegularExpression("((SU)|(Nov)|(SLE)).*32",            QRegularExpression::CaseInsensitiveOption), "OpenSUSE" },
     138    { QRegularExpression("Fe.*64",                            QRegularExpression::CaseInsensitiveOption), "Fedora_64" },
     139    { QRegularExpression("Fe.*32",                            QRegularExpression::CaseInsensitiveOption), "Fedora" },
     140    { QRegularExpression("((Gen)|(Sab)).*64",                 QRegularExpression::CaseInsensitiveOption), "Gentoo_64" },
     141    { QRegularExpression("((Gen)|(Sab)).*32",                 QRegularExpression::CaseInsensitiveOption), "Gentoo" },
     142    { QRegularExpression("((Man)|(Mag)).*64",                 QRegularExpression::CaseInsensitiveOption), "Mandriva_64" },
     143    { QRegularExpression("((Man)|(Mag)).*32",                 QRegularExpression::CaseInsensitiveOption), "Mandriva" },
     144    { QRegularExpression("((Red)|(rhel)|(cen)).*64",          QRegularExpression::CaseInsensitiveOption), "RedHat_64" },
     145    { QRegularExpression("((Red)|(rhel)|(cen)).*32",          QRegularExpression::CaseInsensitiveOption), "RedHat" },
     146    { QRegularExpression("Tur.*64",                           QRegularExpression::CaseInsensitiveOption), "Turbolinux_64" },
     147    { QRegularExpression("Tur.*32",                           QRegularExpression::CaseInsensitiveOption), "Turbolinux" },
     148    { QRegularExpression("((Ub)|(Mint)).*64",                 QRegularExpression::CaseInsensitiveOption), "Ubuntu_64" },
     149    { QRegularExpression("((Ub)|(Mint)).*32",                 QRegularExpression::CaseInsensitiveOption), "Ubuntu" },
     150    { QRegularExpression("Xa.*64",                            QRegularExpression::CaseInsensitiveOption), "Xandros_64" },
     151    { QRegularExpression("Xa.*32",                            QRegularExpression::CaseInsensitiveOption), "Xandros" },
     152    { QRegularExpression("((Or)|(oel)|(ol)).*64",             QRegularExpression::CaseInsensitiveOption), "Oracle_64" },
     153    { QRegularExpression("((Or)|(oel)|(ol)).*32",             QRegularExpression::CaseInsensitiveOption), "Oracle" },
     154    { QRegularExpression("Knoppix",                           QRegularExpression::CaseInsensitiveOption), "Linux26" },
     155    { QRegularExpression("Dsl",                               QRegularExpression::CaseInsensitiveOption), "Linux24" },
     156    { QRegularExpression("((Lin)|(lnx)).*2.?2",               QRegularExpression::CaseInsensitiveOption), "Linux22" },
     157    { QRegularExpression("((Lin)|(lnx)).*2.?4.*64",           QRegularExpression::CaseInsensitiveOption), "Linux24_64" },
     158    { QRegularExpression("((Lin)|(lnx)).*2.?4.*32",           QRegularExpression::CaseInsensitiveOption), "Linux24" },
     159    { QRegularExpression("((((Lin)|(lnx)).*2.?6)|(LFS)).*64", QRegularExpression::CaseInsensitiveOption), "Linux26_64" },
     160    { QRegularExpression("((((Lin)|(lnx)).*2.?6)|(LFS)).*32", QRegularExpression::CaseInsensitiveOption), "Linux26" },
     161    { QRegularExpression("((Lin)|(lnx)).*64",                 QRegularExpression::CaseInsensitiveOption), "Linux26_64" },
     162    { QRegularExpression("((Lin)|(lnx)).*32",                 QRegularExpression::CaseInsensitiveOption), "Linux26" },
    163163
    164164    /* Other: */
    165     { QRegExp("L4",                   Qt::CaseInsensitive), "L4" },
    166     { QRegExp("((Fr.*B)|(fbsd)).*64", Qt::CaseInsensitive), "FreeBSD_64" },
    167     { QRegExp("((Fr.*B)|(fbsd)).*32", Qt::CaseInsensitive), "FreeBSD" },
    168     { QRegExp("Op.*B.*64",            Qt::CaseInsensitive), "OpenBSD_64" },
    169     { QRegExp("Op.*B.*32",            Qt::CaseInsensitive), "OpenBSD" },
    170     { QRegExp("Ne.*B.*64",            Qt::CaseInsensitive), "NetBSD_64" },
    171     { QRegExp("Ne.*B.*32",            Qt::CaseInsensitive), "NetBSD" },
    172     { QRegExp("Net",                  Qt::CaseInsensitive), "Netware" },
    173     { QRegExp("Rocki",                Qt::CaseInsensitive), "JRockitVE" },
    174     { QRegExp("bs[23]{0,1}-",         Qt::CaseInsensitive), "VBoxBS_64" }, /* bootsector tests */
    175     { QRegExp("Ot",                   Qt::CaseInsensitive), "Other" },
     165    { QRegularExpression("L4",                   QRegularExpression::CaseInsensitiveOption), "L4" },
     166    { QRegularExpression("((Fr.*B)|(fbsd)).*64", QRegularExpression::CaseInsensitiveOption), "FreeBSD_64" },
     167    { QRegularExpression("((Fr.*B)|(fbsd)).*32", QRegularExpression::CaseInsensitiveOption), "FreeBSD" },
     168    { QRegularExpression("Op.*B.*64",            QRegularExpression::CaseInsensitiveOption), "OpenBSD_64" },
     169    { QRegularExpression("Op.*B.*32",            QRegularExpression::CaseInsensitiveOption), "OpenBSD" },
     170    { QRegularExpression("Ne.*B.*64",            QRegularExpression::CaseInsensitiveOption), "NetBSD_64" },
     171    { QRegularExpression("Ne.*B.*32",            QRegularExpression::CaseInsensitiveOption), "NetBSD" },
     172    { QRegularExpression("Net",                  QRegularExpression::CaseInsensitiveOption), "Netware" },
     173    { QRegularExpression("Rocki",                QRegularExpression::CaseInsensitiveOption), "JRockitVE" },
     174    { QRegularExpression("bs[23]{0,1}-",         QRegularExpression::CaseInsensitiveOption), "VBoxBS_64" }, /* bootsector tests */
     175    { QRegularExpression("Ot",                   QRegularExpression::CaseInsensitiveOption), "Other" },
    176176};
    177177
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette