Changeset 34560 in webkit for trunk/JavaScriptCore/pcre/pcre_exec.cpp

Timestamp:

Jun 14, 2008, 11:23:50 PM (17 years ago)

Author:

Darin Adler

Message:

2008-06-14 Darin Adler <Darin Adler>

Rubber stamped by Sam.

• rename a bunch of local symbols within the regular expression code to follow our usual coding style, and do a few other name tweaks

• pcre/pcre_compile.cpp: (CompileData::CompileData): (checkEscape): (readRepeatCounts): (compileBranch): (compileBracket): (calculateCompiledPatternLength): (returnError): (jsRegExpCompile):
• pcre/pcre_exec.cpp: (MatchStack::MatchStack): (MatchStack::canUseStackBufferForNextFrame): (MatchStack::popCurrentFrame): (match): (tryFirstByteOptimization): (tryRequiredByteOptimization): (jsRegExpExecute):
• pcre/pcre_internal.h:

File:

• trunk/JavaScriptCore/pcre/pcre_exec.cpp (modified) (28 diffs)

trunk/JavaScriptCore/pcre/pcre_exec.cpp

@@ -133 +133 @@
 
 /* The maximum remaining length of subject we are prepared to search for a
-req_byte match. */
+reqByte match. */
 
 #define REQ_BYTE_MAX 1000
@@ -262 +262 @@
     } while (0)
 
-#define RECURSIVE_MATCH_STARTNG_NEW_GROUP(num, ra, rb) \
+#define RECURSIVE_MATCH_NEW_GROUP(num, ra, rb) \
     do { \
         stack.pushNewFrame((ra), (rb), RMATCH_WHERE(num)); \
@@ -296 +296 @@
 */
 
-static const unsigned FRAMES_ON_STACK = 16;
+static const unsigned numFramesOnStack = 16;
 
 struct MatchStack {
     MatchStack()
-        : framesEnd(frames + FRAMES_ON_STACK)
+        : framesEnd(frames + numFramesOnStack)
         , currentFrame(frames)
         , size(1) // match() creates accesses the first frame w/o calling pushNewFrame
     {
-        ASSERT((sizeof(frames) / sizeof(frames[0])) == FRAMES_ON_STACK);
+        ASSERT((sizeof(frames) / sizeof(frames[0])) == numFramesOnStack);
     }
     
-    MatchFrame frames[FRAMES_ON_STACK];
+    MatchFrame frames[numFramesOnStack];
     MatchFrame* framesEnd;
     MatchFrame* currentFrame;
@@ -314 +314 @@
     inline bool canUseStackBufferForNextFrame()
     {
-        return size < FRAMES_ON_STACK;
+        return size < numFramesOnStack;
     }
     
@@ -343 +343 @@
         MatchFrame* oldFrame = currentFrame;
         currentFrame = currentFrame->previousFrame;
-        if (size > FRAMES_ON_STACK)
+        if (size > numFramesOnStack)
             delete oldFrame;
         size--;
@@ -474 +474 @@
                 DPRINTF(("start bracket 0\n"));
                 do {
-                    RECURSIVE_MATCH_STARTNG_NEW_GROUP(2, stack.currentFrame->args.instructionPtr + 1 + LINK_SIZE, stack.currentFrame->args.bracketChain);
+                    RECURSIVE_MATCH_NEW_GROUP(2, stack.currentFrame->args.instructionPtr + 1 + LINK_SIZE, stack.currentFrame->args.bracketChain);
                     if (isMatch)
                         RRETURN;
@@ -504 +504 @@
             BEGIN_OPCODE(ASSERT):
                 do {
-                    RECURSIVE_MATCH_STARTNG_NEW_GROUP(6, stack.currentFrame->args.instructionPtr + 1 + LINK_SIZE, NULL);
+                    RECURSIVE_MATCH_NEW_GROUP(6, stack.currentFrame->args.instructionPtr + 1 + LINK_SIZE, NULL);
                     if (isMatch)
                         break;
@@ -524 +524 @@
             BEGIN_OPCODE(ASSERT_NOT):
                 do {
-                    RECURSIVE_MATCH_STARTNG_NEW_GROUP(7, stack.currentFrame->args.instructionPtr + 1 + LINK_SIZE, NULL);
+                    RECURSIVE_MATCH_NEW_GROUP(7, stack.currentFrame->args.instructionPtr + 1 + LINK_SIZE, NULL);
                     if (isMatch)
                         RRETURN_NO_MATCH;
@@ -548 +548 @@
             BEGIN_OPCODE(BRAZERO): {
                 stack.currentFrame->locals.startOfRepeatingBracket = stack.currentFrame->args.instructionPtr + 1;
-                RECURSIVE_MATCH_STARTNG_NEW_GROUP(14, stack.currentFrame->locals.startOfRepeatingBracket, stack.currentFrame->args.bracketChain);
+                RECURSIVE_MATCH_NEW_GROUP(14, stack.currentFrame->locals.startOfRepeatingBracket, stack.currentFrame->args.bracketChain);
                 if (isMatch)
                     RRETURN;
@@ -559 +559 @@
                 stack.currentFrame->locals.startOfRepeatingBracket = stack.currentFrame->args.instructionPtr + 1;
                 advanceToEndOfBracket(stack.currentFrame->locals.startOfRepeatingBracket);
-                RECURSIVE_MATCH_STARTNG_NEW_GROUP(15, stack.currentFrame->locals.startOfRepeatingBracket + 1 + LINK_SIZE, stack.currentFrame->args.bracketChain);
+                RECURSIVE_MATCH_NEW_GROUP(15, stack.currentFrame->locals.startOfRepeatingBracket + 1 + LINK_SIZE, stack.currentFrame->args.bracketChain);
                 if (isMatch)
                     RRETURN;
@@ -640 +640 @@
                     if (isMatch)
                         RRETURN;
-                    RECURSIVE_MATCH_STARTNG_NEW_GROUP(17, stack.currentFrame->locals.instructionPtrAtStartOfOnce, stack.currentFrame->args.bracketChain);
+                    RECURSIVE_MATCH_NEW_GROUP(17, stack.currentFrame->locals.instructionPtrAtStartOfOnce, stack.currentFrame->args.bracketChain);
                     if (isMatch)
                         RRETURN;
                 } else { /* OP_KETRMAX */
-                    RECURSIVE_MATCH_STARTNG_NEW_GROUP(18, stack.currentFrame->locals.instructionPtrAtStartOfOnce, stack.currentFrame->args.bracketChain);
+                    RECURSIVE_MATCH_NEW_GROUP(18, stack.currentFrame->locals.instructionPtrAtStartOfOnce, stack.currentFrame->args.bracketChain);
                     if (isMatch)
                         RRETURN;
@@ -1736 +1736 @@
                     
                     do {
-                        RECURSIVE_MATCH_STARTNG_NEW_GROUP(1, stack.currentFrame->args.instructionPtr + 1 + LINK_SIZE, stack.currentFrame->args.bracketChain);
+                        RECURSIVE_MATCH_NEW_GROUP(1, stack.currentFrame->args.instructionPtr + 1 + LINK_SIZE, stack.currentFrame->args.bracketChain);
                         if (isMatch)
                             RRETURN;
@@ -1823 +1823 @@
   options         option bits
   offsets         points to a vector of ints to be filled in with offsets
-  offsetcount     the number of elements in the vector
+  offsetCount     the number of elements in the vector
 
 Returns:          > 0 => success; value is the number of elements filled in
@@ -1831 +1831 @@
 */
 
-static void tryFirstByteOptimization(const UChar*& subjectPtr, const UChar* endSubject, int first_byte, bool first_byte_caseless, bool useMultiLineFirstCharOptimization, const UChar* originalSubjectStart)
+static void tryFirstByteOptimization(const UChar*& subjectPtr, const UChar* endSubject, int firstByte, bool firstByteIsCaseless, bool useMultiLineFirstCharOptimization, const UChar* originalSubjectStart)
 {
-    // If first_byte is set, try scanning to the first instance of that byte
+    // If firstByte is set, try scanning to the first instance of that byte
     // no need to try and match against any earlier part of the subject string.
-    if (first_byte >= 0) {
-        UChar first_char = first_byte;
-        if (first_byte_caseless)
+    if (firstByte >= 0) {
+        UChar firstChar = firstByte;
+        if (firstByteIsCaseless)
             while (subjectPtr < endSubject) {
                 int c = *subjectPtr;
                 if (c > 127)
                     break;
-                if (toLowerCase(c) == first_char)
+                if (toLowerCase(c) == firstChar)
                     break;
                 subjectPtr++;
             }
         else {
-            while (subjectPtr < endSubject && *subjectPtr != first_char)
+            while (subjectPtr < endSubject && *subjectPtr != firstChar)
                 subjectPtr++;
         }
@@ -1860 +1860 @@
 }
 
-static bool tryRequiredByteOptimization(const UChar*& subjectPtr, const UChar* endSubject, int req_byte, int req_byte2, bool req_byte_caseless, bool hasFirstByte, const UChar*& reqBytePtr)
+static bool tryRequiredByteOptimization(const UChar*& subjectPtr, const UChar* endSubject, int reqByte, int reqByte2, bool reqByteIsCaseless, bool hasFirstByte, const UChar*& reqBytePtr)
 {
-    /* If req_byte is set, we know that that character must appear in the subject
-     for the match to succeed. If the first character is set, req_byte must be
+    /* If reqByte is set, we know that that character must appear in the subject
+     for the match to succeed. If the first character is set, reqByte must be
      later in the subject; otherwise the test starts at the match point. This
      optimization can save a huge amount of backtracking in patterns with nested
@@ -1876 +1876 @@
     */
 
-    if (req_byte >= 0 && endSubject - subjectPtr < REQ_BYTE_MAX) {
+    if (reqByte >= 0 && endSubject - subjectPtr < REQ_BYTE_MAX) {
         const UChar* p = subjectPtr + (hasFirstByte ? 1 : 0);
 
@@ -1883 +1883 @@
 
         if (p > reqBytePtr) {
-            if (req_byte_caseless) {
+            if (reqByteIsCaseless) {
                 while (p < endSubject) {
                     int pp = *p++;
-                    if (pp == req_byte || pp == req_byte2) {
+                    if (pp == reqByte || pp == reqByte2) {
                         p--;
                         break;
@@ -1893 +1893 @@
             } else {
                 while (p < endSubject) {
-                    if (*p++ == req_byte) {
+                    if (*p++ == reqByte) {
                         p--;
                         break;
@@ -1917 +1917 @@
 int jsRegExpExecute(const JSRegExp* re,
                     const UChar* subject, int length, int start_offset, int* offsets,
-                    int offsetcount)
+                    int offsetCount)
 {
     ASSERT(re);
     ASSERT(subject);
-    ASSERT(offsetcount >= 0);
-    ASSERT(offsets || offsetcount == 0);
+    ASSERT(offsetCount >= 0);
+    ASSERT(offsets || offsetCount == 0);
     
     MatchData matchBlock;
@@ -1937 +1937 @@
      of 3. */
     
-    int ocount = offsetcount - (offsetcount % 3);
+    int ocount = offsetCount - (offsetCount % 3);
     
     // FIXME: This is lame that we have to second-guess our caller here.
     // The API should change to either fail-hard when we don't have enough offset space
     // or that we shouldn't ask our callers to pre-allocate in the first place.
-    bool using_temporary_offsets = false;
-    if (re->top_backref > 0 && re->top_backref >= ocount/3) {
-        ocount = re->top_backref * 3 + 3;
+    bool usingTemporaryOffsets = false;
+    if (re->topBackref > 0 && re->topBackref >= ocount/3) {
+        ocount = re->topBackref * 3 + 3;
         matchBlock.offsetVector = new int[ocount];
         if (!matchBlock.offsetVector)
             return JSRegExpErrorNoMemory;
-        using_temporary_offsets = true;
+        usingTemporaryOffsets = true;
     } else
         matchBlock.offsetVector = offsets;
@@ -1960 +1960 @@
      in the pattern. */
     
-    int resetcount = 2 + re->top_bracket * 2;
-    if (resetcount > offsetcount)
-        resetcount = ocount;
+    int resetCount = 2 + re->topBracket * 2;
+    if (resetCount > offsetCount)
+        resetCount = ocount;
     
     /* Reset the working variable associated with each extraction. These should
@@ -1970 +1970 @@
     if (matchBlock.offsetVector) {
         int* iptr = matchBlock.offsetVector + ocount;
-        int* iend = iptr - resetcount/2 + 1;
+        int* iend = iptr - resetCount/2 + 1;
         while (--iptr >= iend)
             *iptr = -1;
     }
     
-    /* Set up the first character to match, if available. The first_byte value is
+    /* Set up the first character to match, if available. The firstByte value is
      never set for an anchored regular expression, but the anchoring may be forced
      at run time, so we have to test for anchoring. The first char may be unset for
@@ -1981 +1981 @@
      studied, there may be a bitmap of possible first characters. */
     
-    bool first_byte_caseless = false;
-    int first_byte = -1;
+    bool firstByteIsCaseless = false;
+    int firstByte = -1;
     if (re->options & UseFirstByteOptimizationOption) {
-        first_byte = re->first_byte & 255;
-        if ((first_byte_caseless = (re->first_byte & REQ_IGNORE_CASE)))
-            first_byte = toLowerCase(first_byte);
+        firstByte = re->firstByte & 255;
+        if ((firstByteIsCaseless = (re->firstByte & REQ_IGNORE_CASE)))
+            firstByte = toLowerCase(firstByte);
     }
     
@@ -1992 +1992 @@
      character" set. */
     
-    bool req_byte_caseless = false;
-    int req_byte = -1;
-    int req_byte2 = -1;
+    bool reqByteIsCaseless = false;
+    int reqByte = -1;
+    int reqByte2 = -1;
     if (re->options & UseRequiredByteOptimizationOption) {
-        req_byte = re->req_byte & 255; // FIXME: This optimization could be made to work for UTF16 chars as well...
-        req_byte_caseless = (re->req_byte & REQ_IGNORE_CASE);
-        req_byte2 = flipCase(req_byte);
+        reqByte = re->reqByte & 255; // FIXME: This optimization could be made to work for UTF16 chars as well...
+        reqByteIsCaseless = (re->reqByte & REQ_IGNORE_CASE);
+        reqByte2 = flipCase(reqByte);
     }
     
@@ -2012 +2012 @@
         if (matchBlock.offsetVector) {
             int* iptr = matchBlock.offsetVector;
-            int* iend = iptr + resetcount;
+            int* iend = iptr + resetCount;
             while (iptr < iend)
                 *iptr++ = -1;
         }
         
-        tryFirstByteOptimization(startMatch, endSubject, first_byte, first_byte_caseless, useMultiLineFirstCharOptimization, matchBlock.startSubject + start_offset);
-        if (tryRequiredByteOptimization(startMatch, endSubject, req_byte, req_byte2, req_byte_caseless, first_byte >= 0, reqBytePtr))
+        tryFirstByteOptimization(startMatch, endSubject, firstByte, firstByteIsCaseless, useMultiLineFirstCharOptimization, matchBlock.startSubject + start_offset);
+        if (tryRequiredByteOptimization(startMatch, endSubject, reqByte, reqByte2, reqByteIsCaseless, firstByte >= 0, reqBytePtr))
             break;
                 
@@ -2049 +2049 @@
          necessary */
         
-        if (using_temporary_offsets) {
-            if (offsetcount >= 4) {
-                memcpy(offsets + 2, matchBlock.offsetVector + 2, (offsetcount - 2) * sizeof(int));
+        if (usingTemporaryOffsets) {
+            if (offsetCount >= 4) {
+                memcpy(offsets + 2, matchBlock.offsetVector + 2, (offsetCount - 2) * sizeof(int));
                 DPRINTF(("Copied offsets from temporary memory\n"));
             }
-            if (matchBlock.endOffsetTop > offsetcount)
+            if (matchBlock.endOffsetTop > offsetCount)
                 matchBlock.offsetOverflow = true;
             
@@ -2063 +2063 @@
         returnCode = matchBlock.offsetOverflow ? 0 : matchBlock.endOffsetTop / 2;
         
-        if (offsetcount < 2)
+        if (offsetCount < 2)
             returnCode = 0;
         else {
@@ -2074 +2074 @@
     } while (!(re->options & IsAnchoredOption) && startMatch <= endSubject);
     
-    if (using_temporary_offsets) {
+    if (usingTemporaryOffsets) {
         DPRINTF(("Freeing temporary memory\n"));
         delete [] matchBlock.offsetVector;