Changeset 561 for trunk/src/corelib/tools/qregexp.cpp

Timestamp:

Feb 11, 2010, 11:19:06 PM (15 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.6.1 sources.

Location:

trunk

Files:

• . (modified) (1 prop)
• src/corelib/tools/qregexp.cpp (modified) (29 diffs)

trunk/src/corelib/tools/qregexp.cpp

@@ -2 +2 @@
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Qt Software Information ([email protected])
+** All rights reserved.
+** Contact: Nokia Corporation ([email protected])
 **
 ** This file is part of the QtCore module of the Qt Toolkit.
@@ -21 +22 @@
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
-** In addition, as a special exception, Nokia gives you certain
-** additional rights. These rights are described in the Nokia Qt LGPL
-** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
-** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
@@ -34 +34 @@
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
-** If you are unsure which license is appropriate for your use, please
-** contact the sales department at qt-sales@nokia.com.
+** If you 
+** @nokia.com.
 ** $QT_END_LICENSE$
 **
@@ -53 +53 @@
 #include "qstringmatcher.h"
 #include "qvector.h"
+
 
 #include <limits.h>
@@ -71 +72 @@
 #define RXERR_END        QT_TRANSLATE_NOOP("QRegExp", "unexpected end")
 #define RXERR_LIMIT      QT_TRANSLATE_NOOP("QRegExp", "met internal limit")
+
+
 
 /*
@@ -82 +85 @@
 
     \ingroup tools
-    \ingroup misc
     \ingroup shared
-    \mainclass
+
     \keyword regular expression
 
@@ -521 +523 @@
     \endtable
 
+
+
+
+
     For example if we are in wildcard mode and have strings which
     contain filenames we could identify HTML files with \bold{*.html}.
@@ -686 +692 @@
         {tools/regexp}{Regular Expression Example}
 */
+
+
+
+
 
 const int NumBadChars = 64;
@@ -746 +756 @@
   Translates a wildcard pattern to an equivalent regular expression
   pattern (e.g., *.cpp to .*\.cpp).
-*/
-static QString wc2rx(const QString &wc_str)
-{
-    int wclen = wc_str.length();
+
+  If enableEscaping is true, it is possible to escape the wildcard
+  characters with \
+*/
+static QString wc2rx(const QString &wc_str, const bool enableEscaping)
+{
+    const int wclen = wc_str.length();
     QString rx;
     int i = 0;
+
     const QChar *wc = wc_str.unicode();
+
     while (i < wclen) {
-        QChar c = wc[i++];
+        QChar c = wc[i++];
         switch (c.unicode()) {
+
+
+
+
+
+
+
+
+
+
+
+
+
         case '*':
-            rx += QLatin1String(".*");
+            if (isEscaping) {
+                rx += QLatin1String("\\*");
+                isEscaping = false;
+            } else {
+                rx += QLatin1String(".*");
+            }
             break;
         case '?':
-            rx += QLatin1Char('.');
+            if (isEscaping) {
+                rx += QLatin1String("\\?");
+                isEscaping = false;
+            } else {
+                rx += QLatin1Char('.');
+            }
+
             break;
         case '$':
@@ -767 +806 @@
         case '+':
         case '.':
-        case '\\':
         case '^':
         case '{':
         case '|':
         case '}':
+
+
+
+
             rx += QLatin1Char('\\');
             rx += c;
             break;
-        case '[':
-            rx += c;
-            if (wc[i] == QLatin1Char('^'))
-                rx += wc[i++];
-            if (i < wclen) {
-                if (rx[i] == QLatin1Char(']'))
+         case '[':
+            if (isEscaping) {
+                isEscaping = false;
+                rx += QLatin1String("\\[");
+            } else {
+                rx += c;
+                if (wc[i] == QLatin1Char('^'))
                     rx += wc[i++];
-                while (i < wclen && wc[i] != QLatin1Char(']')) {
-                    if (wc[i] == QLatin1Char('\\'))
-                        rx += QLatin1Char('\\');
-                    rx += wc[i++];
+                if (i < wclen) {
+                    if (rx[i] == QLatin1Char(']'))
+                        rx += wc[i++];
+                    while (i < wclen && wc[i] != QLatin1Char(']')) {
+                        if (wc[i] == QLatin1Char('\\'))
+                            rx += QLatin1Char('\\');
+                        rx += wc[i++];
+                    }
                 }
             }
+
+
+
+
+
+
+
+
             break;
+
         default:
+
+
+
+
             rx += c;
         }
@@ -828 +888 @@
 };
 
-bool operator==(const QRegExpEngineKey &key1, const QRegExpEngineKey &key2)
+bool operator==(const QRegExpEngineKey &key1, const QRegExpEngineKey &key2)
 {
     return key1.pattern == key2.pattern && key1.patternSyntax == key2.patternSyntax
@@ -1024 +1084 @@
     bool isValid() const { return valid; }
     const QString &errorString() const { return yyError; }
-    int numCaptures() const { return officialncap; }
+    int () const { return officialncap; }
 
     int createState(QChar ch);
@@ -1117 +1177 @@
     Qt::CaseSensitivity cs; // case sensitive?
     bool greedyQuantifiers; // RegExp2?
+
 #ifndef QT_NO_REGEXP_BACKREF
     int nbrefs; // number of back-references
@@ -1193 +1254 @@
 
     friend class Box;
+
+
 
     /*
@@ -1217 +1280 @@
     int yyLen; // the length of yyIn
     int yyCh; // the last character read
-    QRegExpCharClass *yyCharClass; // attribute for Tok_CharClass tokens
+    QyyCharClass; // attribute for Tok_CharClass tokens
     int yyMinRep; // attribute for Tok_Quantifier
     int yyMaxRep; // ditto
@@ -1233 +1296 @@
     int yyTok; // the last token read
     bool yyMayCapture; // set this to false to disable capturing
+
 
     friend struct QRegExpMatchState;
@@ -1253 +1317 @@
 #endif
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 QRegExpEngine::QRegExpEngine(const QRegExpEngineKey &key)
-    : cs(key.cs), greedyQuantifiers(key.patternSyntax == QRegExp::RegExp2)
+    : cs(key.cs), greedyQuantifiers(key.patternSyntax == QRegExp::RegExp2),
+      xmlSchemaExtensions(key.patternSyntax == QRegExp::W3CXmlSchema11)
 {
     setup();
 
-    QString rx;
-
-    switch (key.patternSyntax) {
-    case QRegExp::Wildcard:
-#ifndef QT_NO_REGEXP_WILDCARD
-        rx = wc2rx(key.pattern);
-#endif
-        break;
-    case QRegExp::FixedString:
-        rx = QRegExp::escape(key.pattern);
-        break;
-    default:
-        rx = key.pattern;
-    }
+    QString rx = qt_regexp_toCanonical(key.pattern, key.patternSyntax);
 
     valid = (parse(rx.unicode(), rx.length()) == rx.length());
@@ -1298 +1375 @@
     int ncap = eng->ncap;
 #ifndef QT_NO_REGEXP_OPTIM
-    slideTabSize = qMax(eng->minl + 1, 16);
+    lideTabSize = qMax(eng->minl + 1, 16);
 #else
-    slideTabSize = 0;
-#endif
-    int numCaptures = eng->numCaptures();
-    capturedSize = 2 + 2 * numCaptures;
-    bigArray = (int *)realloc(bigArray, ((3 + 4 * ncap) * ns + 4 * ncap + slideTabSize + capturedSize)*sizeof(int));
-
+    int newSlideTabSize = 0;
+#endif
+    int numCaptures = eng->captureCount();
+    int newCapturedSize = 2 + 2 * numCaptures;
+    bigArray = q_check_ptr((int *)realloc(bigArray, ((3 + 4 * ncap) * ns + 4 * ncap + newSlideTabSize + newCapturedSize)*sizeof(int)));
+
+    // set all internal variables only _after_ bigArray is realloc'ed
+    // to prevent a broken regexp in oom case
+
+    slideTabSize = newSlideTabSize;
+    capturedSize = newCapturedSize;
     inNextStack = bigArray;
     memset(inNextStack, -1, ns * sizeof(int));
@@ -1480 +1562 @@
 #endif
 
-    aa.resize(n + 1);
-    aa[n].a = a;
-    aa[n].b = b;
+    QRegExpAnchorAlternation element = {a, b};
+    aa.append(element);
     return Anchor_Alternation | n;
 }
@@ -2622 +2703 @@
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 int QRegExpEngine::getChar()
 {
@@ -2714 +2941 @@
         yyCharClass->addSingleton(0x005f); // '_'
         return Tok_CharClass;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 #endif
 #ifndef QT_NO_REGEXP_ESCAPE
@@ -2790 +3188 @@
     yyLen = len;
     yyCh = getChar();
-    yyCharClass = new QRegExpCharClass;
+    yyCharClass;
     yyMinRep = 0;
     yyMaxRep = 0;
@@ -2935 +3333 @@
         }
         if (yyMaxRep < yyMinRep)
-            qSwap(yyMinRep, yyMaxRep);
+            );
         if (yyCh != '}')
             error(RXERR_REPETITION);
@@ -2984 +3382 @@
     box.cat(middleBox);
     box.cat(rightBox);
-    delete yyCharClass;
-    yyCharClass = 0;
+    yyCharClass.reset(0);
 
 #ifndef QT_NO_REGEXP_CAPTURE
@@ -3282 +3679 @@
         if (globalEngineCache()) {
             QMutexLocker locker(mutex());
-            globalEngineCache()->insert(key, eng, 4 + key.pattern.length() / 4);
-        }
-        else
+            QT_TRY {
+                globalEngineCache()->insert(key, eng, 4 + key.pattern.length() / 4);
+            } QT_CATCH(const std::bad_alloc &) {
+                // in case of an exception (e.g. oom), just delete the engine
+                delete eng;
+            }
+        } else {
             delete eng;
+
 #else
         Q_UNUSED(key);
@@ -3297 +3699 @@
     bool initMatchState = !priv->eng;
 #if !defined(QT_NO_REGEXP_OPTIM)
-    if (!priv->eng) {
+    if (!priv->eng) {
         QMutexLocker locker(mutex());
         priv->eng = globalEngineCache()->take(priv->engineKey);
@@ -3371 +3773 @@
     globbing". See \l{Wildcard Matching}.
 
+
+
+
+
     \value FixedString The pattern is a fixed string. This is
     equivalent to using the RegExp pattern on a string in
     which all metacharacters are escaped using escape().
+
+
+
 
     \sa setPatternSyntax()
@@ -3760 +4169 @@
 #ifndef QT_NO_REGEXP_CAPTURE
 /*!
+
+
+
+
+
+
+
+
+
+
+
+
   Returns the number of captures contained in the regular expression.
  */
-int QRegExp::numCaptures() const
+int QRegExp::() const
 {
     prepareEngine(priv);
-    return priv->eng->numCaptures();
+    return priv->eng->();
 }
 
@@ -4066 +4487 @@
     return in;
 }
-#endif
+#endif
 
 QT_END_NAMESPACE