2007-11-26 Eric Seidel <eric@webkit.org>
authoreric@webkit.org <eric@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 29 Nov 2007 11:38:26 +0000 (11:38 +0000)
committereric@webkit.org <eric@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 29 Nov 2007 11:38:26 +0000 (11:38 +0000)
        Reviewed by Sam.

        Give consistent naming to the RegExp options/compile flags

        * pcre/pcre_compile.cpp:
        (compile_branch):
        (is_anchored):
        (find_firstassertedchar):
        (printCompiledRegExp):
        (jsRegExpCompile):
        * pcre/pcre_exec.cpp:
        (jsRegExpExecute):
        * pcre/pcre_internal.h:

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@28182 268f45cc-cd09-0410-ab3c-d52691b4dbfc

JavaScriptCore/ChangeLog
JavaScriptCore/pcre/pcre_compile.cpp
JavaScriptCore/pcre/pcre_exec.cpp
JavaScriptCore/pcre/pcre_internal.h

index 3c5d2cc695bcfd77a3178de362783601f6500d93..0807fcc0ab65444032f1ae9db377489135fe5d77 100644 (file)
         * pcre/pcre_exec.cpp:
         (match):
 
+2007-11-26  Eric Seidel  <eric@webkit.org>
+
+        Reviewed by Sam.
+
+        Give consistent naming to the RegExp options/compile flags
+
+        * pcre/pcre_compile.cpp:
+        (compile_branch):
+        (is_anchored):
+        (find_firstassertedchar):
+        (printCompiledRegExp):
+        (jsRegExpCompile):
+        * pcre/pcre_exec.cpp:
+        (jsRegExpExecute):
+        * pcre/pcre_internal.h:
+
 2007-11-26  Eric Seidel  <eric@webkit.org>
 
         Reviewed by Sam.
index 90c01803fde9361e76c4721b09df75dd50509751..e6a268c3ddd925ebffb853050a0ad7655dfb1142 100644 (file)
@@ -770,7 +770,7 @@ compile_branch(int options, int* brackets, uschar** codeptr,
      value > 255. It is added into the firstbyte or reqbyte variables to record the
      case status of the value. This is used only for ASCII characters. */
     
-    int req_caseopt = (options & OptionIgnoreCase) ? REQ_IGNORE_CASE : 0;
+    int req_caseopt = (options & IgnoreCaseOption) ? REQ_IGNORE_CASE : 0;
     
     /* Switch on next character until the end of the branch */
     
@@ -819,7 +819,7 @@ compile_branch(int options, int* brackets, uschar** codeptr,
                  the setting of any following char as a first character. */
                 
             case '^':
-                if (options & OptionMatchAcrossMultipleLines) {
+                if (options & MatchAcrossMultipleLinesOption) {
                     if (firstbyte == REQ_UNSET)
                         firstbyte = REQ_NONE;
                 }
@@ -1003,14 +1003,14 @@ compile_branch(int options, int* brackets, uschar** codeptr,
                          matching for characters > 127 is available only if UCP support is
                          available. */
                         
-                        if ((d > 255 || ((options & OptionIgnoreCase) && d > 127))) {
+                        if ((d > 255 || ((options & IgnoreCaseOption) && d > 127))) {
                             class_utf8 = true;
                             
                             /* With UCP support, we can find the other case equivalents of
                              the relevant characters. There may be several ranges. Optimize how
                              they fit with the basic range. */
                             
-                            if (options & OptionIgnoreCase) {
+                            if (options & IgnoreCaseOption) {
                                 int occ, ocd;
                                 int cc = c;
                                 int origd = d;
@@ -1059,7 +1059,7 @@ compile_branch(int options, int* brackets, uschar** codeptr,
                         
                         for (; c <= d; c++) {
                             classbits[c/8] |= (1 << (c&7));
-                            if (options & OptionIgnoreCase) {
+                            if (options & IgnoreCaseOption) {
                                 int uc = flipCase(c);
                                 classbits[uc/8] |= (1 << (uc&7));
                             }
@@ -1078,12 +1078,12 @@ compile_branch(int options, int* brackets, uschar** codeptr,
                     
                     /* Handle a character that cannot go in the bit map */
                     
-                    if ((c > 255 || ((options & OptionIgnoreCase) && c > 127))) {
+                    if ((c > 255 || ((options & IgnoreCaseOption) && c > 127))) {
                         class_utf8 = true;
                         *class_utf8data++ = XCL_SINGLE;
                         class_utf8data += _pcre_ord2utf8(c, class_utf8data);
                         
-                        if (options & OptionIgnoreCase) {
+                        if (options & IgnoreCaseOption) {
                             int othercase;
                             if ((othercase = _pcre_ucp_othercase(c)) >= 0) {
                                 *class_utf8data++ = XCL_SINGLE;
@@ -1096,7 +1096,7 @@ compile_branch(int options, int* brackets, uschar** codeptr,
                     /* Handle a single-byte character */
                     {
                         classbits[c/8] |= (1 << (c&7));
-                        if (options & OptionIgnoreCase) {
+                        if (options & IgnoreCaseOption) {
                             c = flipCase(c);
                             classbits[c/8] |= (1 << (c&7));
                         }
@@ -1811,7 +1811,7 @@ compile_branch(int options, int* brackets, uschar** codeptr,
                     mclength = 1;
                     mcbuffer[0] = c;
                     
-                    if ((options & OptionIgnoreCase) && (c | 0x20) >= 'a' && (c | 0x20) <= 'z') {
+                    if ((options & IgnoreCaseOption) && (c | 0x20) >= 'a' && (c | 0x20) <= 'z') {
                         *code++ = OP_ASCII_LETTER_IGNORING_CASE;
                         *code++ = c | 0x20;
                     } else {
@@ -1821,7 +1821,7 @@ compile_branch(int options, int* brackets, uschar** codeptr,
                 } else {
                     mclength = _pcre_ord2utf8(c, mcbuffer);
                     
-                    *code++ = (options & OptionIgnoreCase) ? OP_CHAR_IGNORING_CASE : OP_CHAR;
+                    *code++ = (options & IgnoreCaseOption) ? OP_CHAR_IGNORING_CASE : OP_CHAR;
                     for (c = 0; c < mclength; c++)
                         *code++ = mcbuffer[c];
                 }
@@ -2077,7 +2077,7 @@ static bool is_anchored(const uschar* code, int options, unsigned int bracket_ma
         
         /* Check for explicit anchoring */
         
-        else if ((options & OptionMatchAcrossMultipleLines) || op != OP_CIRC)
+        else if ((options & MatchAcrossMultipleLinesOption) || op != OP_CIRC)
             return false;
         code += getOpcodeValueAtOffset(code, 1);
     } while (*code == OP_ALT);   /* Loop for each alternative */
@@ -2202,7 +2202,7 @@ static int find_firstassertedchar(const uschar* code, int options, bool inassert
                 return -1;
             if (c < 0) {
                 c = scode[1];
-                if (options & OptionIgnoreCase)
+                if (options & IgnoreCaseOption)
                     c |= REQ_IGNORE_CASE;
             }
             else if (c != scode[1])
@@ -2716,12 +2716,12 @@ static void printCompiledRegExp(JSRegExp* re, int length)
     
     if (re->options) {
         printf("%s%s%s\n",
-               ((re->options & PCRE_ANCHORED) != 0)? "anchored " : "",
-               ((re->options & OptionIgnoreCase) != 0)? "ignores case " : "",
-               ((re->options & OptionMatchAcrossMultipleLines) != 0)? "multiline " : "");
+               ((re->options & IsAnchoredOption) != 0)? "anchored " : "",
+               ((re->options & IgnoreCaseOption) != 0)? "ignores case " : "",
+               ((re->options & MatchAcrossMultipleLinesOption) != 0)? "multiline " : "");
     }
     
-    if (re->options & PCRE_FIRSTSET) {
+    if (re->options & UseFirstByteOptimizationOption) {
         char ch = re->first_byte & 255;
         const char* caseless = (re->first_byte & REQ_IGNORE_CASE) ? " (ignores case)" : "";
         if (isASCIIAlphanumeric(ch))
@@ -2730,7 +2730,7 @@ static void printCompiledRegExp(JSRegExp* re, int length)
             printf("First char = \\x%02x%s\n", ch, caseless);
     }
     
-    if (re->options & PCRE_REQCHSET) {
+    if (re->options & UseRequiredByteOptimizationOption) {
         char ch = re->req_byte & 255;
         const char* caseless = (re->req_byte & REQ_IGNORE_CASE) ? " (ignores case)" : "";
         if (isASCIIAlphanumeric(ch))
@@ -2804,7 +2804,7 @@ JSRegExp* jsRegExpCompile(const UChar* pattern, int patternLength,
      4-byte pointers is run on another with 8-byte pointers. */
     
     re->size = (pcre_uint32)size;
-    re->options = (ignoreCase ? OptionIgnoreCase : 0) | (multiline ? OptionMatchAcrossMultipleLines : 0);
+    re->options = (ignoreCase ? IgnoreCaseOption : 0) | (multiline ? MatchAcrossMultipleLinesOption : 0);
     
     /* The starting points of the name/number translation table and of the code are
      passed around in the compile data block. */
@@ -2863,12 +2863,12 @@ JSRegExp* jsRegExpCompile(const UChar* pattern, int patternLength,
      
      Otherwise, if we know what the first character has to be, save it, because that
      speeds up unanchored matches no end. If not, see if we can set the
-     OptionUseMultiLineFirstCharOptimization flag. This is helpful for multiline matches when all branches
+     UseMultiLineFirstByteOptimizationOption flag. This is helpful for multiline matches when all branches
      start with ^. and also when all branches start with .* for non-DOTALL matches.
      */
     
     if (is_anchored(codestart, re->options, 0, compile_block.backref_map))
-        re->options |= PCRE_ANCHORED;
+        re->options |= IsAnchoredOption;
     else {
         if (firstbyte < 0)
             firstbyte = find_firstassertedchar(codestart, re->options, false);
@@ -2877,22 +2877,22 @@ JSRegExp* jsRegExpCompile(const UChar* pattern, int patternLength,
             int ch = firstbyte & 255;
             if (ch < 127) {
                 re->first_byte = ((firstbyte & REQ_IGNORE_CASE) && flipCase(ch) == ch) ? ch : firstbyte;
-                re->options |= PCRE_FIRSTSET;
+                re->options |= UseFirstByteOptimizationOption;
             }
         }
         else if (canApplyFirstCharOptimization(codestart, 0, compile_block.backref_map))
-            re->options |= OptionUseMultiLineFirstCharOptimization;
+            re->options |= UseMultiLineFirstByteOptimizationOption;
     }
     
     /* For an anchored pattern, we use the "required byte" only if it follows a
      variable length item in the regex. Remove the caseless flag for non-caseable
      bytes. */
     
-    if (reqbyte >= 0 && (!(re->options & PCRE_ANCHORED) || (reqbyte & REQ_VARY))) {
+    if (reqbyte >= 0 && (!(re->options & IsAnchoredOption) || (reqbyte & REQ_VARY))) {
         int ch = reqbyte & 255;
         if (ch < 127) {
             re->req_byte = ((reqbyte & REQ_IGNORE_CASE) && flipCase(ch) == ch) ? (reqbyte & ~REQ_IGNORE_CASE) : reqbyte;
-            re->options |= PCRE_REQCHSET;
+            re->options |= UseRequiredByteOptimizationOption;
         }
     }
     
index 8072de98b1768ac6e76133967adea52097f6e09b..e7572aed958209c34281fabba5007065fb87e2f3 100644 (file)
@@ -2069,8 +2069,8 @@ int jsRegExpExecute(const JSRegExp* re,
     match_block.end_subject = match_block.start_subject + length;
     const UChar* end_subject = match_block.end_subject;
     
-    match_block.multiline = (re->options & OptionMatchAcrossMultipleLines);
-    match_block.ignoreCase = (re->options & OptionIgnoreCase);
+    match_block.multiline = (re->options & MatchAcrossMultipleLinesOption);
+    match_block.ignoreCase = (re->options & IgnoreCaseOption);
     
     /* If the expression has got more back references than the offsets supplied can
      hold, we get a temporary chunk of working store to use during the matching.
@@ -2124,7 +2124,7 @@ int jsRegExpExecute(const JSRegExp* re,
     
     bool first_byte_caseless = false;
     int first_byte = -1;
-    if (re->options & PCRE_FIRSTSET) {
+    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);
@@ -2136,7 +2136,7 @@ int jsRegExpExecute(const JSRegExp* re,
     bool req_byte_caseless = false;
     int req_byte = -1;
     int req_byte2 = -1;
-    if (re->options & PCRE_REQCHSET) {
+    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);
@@ -2147,7 +2147,7 @@ int jsRegExpExecute(const JSRegExp* re,
     
     const UChar* start_match = subject + start_offset;
     const UChar* req_byte_ptr = start_match - 1;
-    bool useMultiLineFirstCharOptimization = re->options & OptionUseMultiLineFirstCharOptimization;
+    bool useMultiLineFirstCharOptimization = re->options & UseMultiLineFirstByteOptimizationOption;
     
     do {
         /* Reset the maximum number of extractions we might see. */
index 45e497d2bd68c9853d748d56f462b216a4933485..5f16d1f5def45832b7caf9ac34ea96e14b86adc7 100644 (file)
@@ -341,14 +341,14 @@ static inline void movePtrToStartOfCurrentChar(const UChar*& subjectPtr)
         subjectPtr--;
 }
 
-// FIXME: These are really more of a "regexp state" than "regexp options"
-enum PCREOptions {
-    PCRE_FIRSTSET = 0x40000000,  /* first_byte is set */
-    PCRE_REQCHSET = 0x20000000,  /* req_byte is set */
-    OptionUseMultiLineFirstCharOptimization = 0x10000000,  /* start after \n for multiline */
-    PCRE_ANCHORED = 0x02000000,  /* can't use partial with this regex */
-    OptionIgnoreCase = 0x00000001,
-    OptionMatchAcrossMultipleLines = 0x00000002
+// FIXME: These are really more of a "compiled regexp state" than "regexp options"
+enum RegExpOptions {
+    UseFirstByteOptimizationOption = 0x40000000,  /* first_byte is set */
+    UseRequiredByteOptimizationOption = 0x20000000,  /* req_byte is set */
+    UseMultiLineFirstByteOptimizationOption = 0x10000000,  /* start after \n for multiline */
+    IsAnchoredOption = 0x02000000,  /* can't use partial with this regex */
+    IgnoreCaseOption = 0x00000001,
+    MatchAcrossMultipleLinesOption = 0x00000002
 };
 
 /* Negative values for the firstchar and reqchar variables */