JavaScriptCore:
[WebKit-https.git] / JavaScriptCore / pcre / pcre_compile.cpp
index be8fd211b74b8e4f55102551c5d3e45166aa7476..99bdbf4a52e424a83d98dbfc4a7117c51b5b9293 100644 (file)
@@ -562,7 +562,7 @@ static int find_fixedlength(uschar* code, int options)
             case OP_WHITESPACE:
             case OP_NOT_WORDCHAR:
             case OP_WORDCHAR:
-            case OP_ANY_CHAR:
+            case OP_NOT_NEWLINE:
                 branchlength++;
                 cc++;
                 break;
@@ -800,8 +800,8 @@ compile_branch(int options, int* brackets, uschar** codeptr,
             previous_callout = NULL;
         }
         
-        switch(c) {
-                /* The branch terminates at end of string, |, or ). */
+        switch (c) {
+            /* The branch terminates at end of string, |, or ). */
                 
             case 0:
                 if (ptr < patternEnd)
@@ -815,8 +815,8 @@ compile_branch(int options, int* brackets, uschar** codeptr,
                 *ptrptr = ptr;
                 return true;
                 
-                /* Handle single-character metacharacters. In multiline mode, ^ disables
-                 the setting of any following char as a first character. */
+            /* Handle single-character metacharacters. In multiline mode, ^ disables
+             the setting of any following char as a first character. */
                 
             case '^':
                 if (options & MatchAcrossMultipleLinesOption) {
@@ -832,8 +832,8 @@ compile_branch(int options, int* brackets, uschar** codeptr,
                 *code++ = OP_DOLL;
                 break;
                 
-                /* There can never be a first char if '.' is first, whatever happens about
-                 repeats. The value of reqbyte doesn't change either. */
+            /* There can never be a first char if '.' is first, whatever happens about
+             repeats. The value of reqbyte doesn't change either. */
                 
             case '.':
                 if (firstbyte == REQ_UNSET)
@@ -841,23 +841,22 @@ compile_branch(int options, int* brackets, uschar** codeptr,
                 zerofirstbyte = firstbyte;
                 zeroreqbyte = reqbyte;
                 previous = code;
-                *code++ = OP_ANY_CHAR;
+                *code++ = OP_NOT_NEWLINE;
                 break;
                 
-                /* Character classes. If the included characters are all < 256, we build a
-                 32-byte bitmap of the permitted characters, except in the special case
-                 where there is only one such character. For negated classes, we build the
-                 map as usual, then invert it at the end. However, we use a different opcode
-                 so that data characters > 255 can be handled correctly.
-                 
-                 If the class contains characters outside the 0-255 range, a different
-                 opcode is compiled. It may optionally have a bit map for characters < 256,
-                 but those above are are explicitly listed afterwards. A flag byte tells
-                 whether the bitmap is present, and whether this is a negated class or not.
-                 */
-                
-            case '[':
-            {
+            /* Character classes. If the included characters are all < 256, we build a
+             32-byte bitmap of the permitted characters, except in the special case
+             where there is only one such character. For negated classes, we build the
+             map as usual, then invert it at the end. However, we use a different opcode
+             so that data characters > 255 can be handled correctly.
+             
+             If the class contains characters outside the 0-255 range, a different
+             opcode is compiled. It may optionally have a bit map for characters < 256,
+             but those above are are explicitly listed afterwards. A flag byte tells
+             whether the bitmap is present, and whether this is a negated class or not.
+             */
+                
+            case '[': {
                 previous = code;
                 should_flip_negation = false;
                 
@@ -894,9 +893,6 @@ compile_branch(int options, int* brackets, uschar** codeptr,
                  strict here. At the start of the loop, c contains the first byte of the
                  character. */
                 while ((c = *(++ptr)) != ']') {
-                    if (c > 127)
-                        c = getCharAndAdvanceIfSurrogate(ptr);
-                    
                     /* Backslash may introduce a single character, or it may introduce one
                      of the specials, which just set a flag. Escaped items are checked for
                      validity in the pre-compiling pass. The sequence \b is a special case.
@@ -969,7 +965,7 @@ compile_branch(int options, int* brackets, uschar** codeptr,
                     if (ptr[1] == '-' && ptr[2] != ']') {
                         ptr += 2;
                         
-                        int d = getCharAndAdvanceIfSurrogate(ptr);
+                        int d = *ptr;
                         
                         /* The second part of a range can be a single-character escape, but
                          not any of the other escapes. Perl 5.6 treats a hyphen as a literal
@@ -1195,10 +1191,11 @@ compile_branch(int options, int* brackets, uschar** codeptr,
                     memcpy(code, classbits, 32);
                 code += 32;
                 break;
-                
-                /* Various kinds of repeat; '{' is not necessarily a quantifier, but this
-                 has been tested above. */
             }
+                
+            /* Various kinds of repeat; '{' is not necessarily a quantifier, but this
+             has been tested above. */
+
             case '{':
                 if (!is_quantifier)
                     goto NORMAL_CHAR;
@@ -1306,7 +1303,7 @@ compile_branch(int options, int* brackets, uschar** codeptr,
                  create a suitable repeat item. The code is shared with single-character
                  repeats by setting op_type to add a suitable offset into repeat_type. */
                 
-                else if (*previous <= OP_ANY_CHAR) {
+                else if (*previous <= OP_NOT_NEWLINE) {
                     op_type = OP_TYPESTAR - OP_STAR;  /* Use type opcodes */
                     c = *previous;
                     
@@ -1607,13 +1604,12 @@ compile_branch(int options, int* brackets, uschar** codeptr,
                 cd.req_varyopt |= reqvary;
                 break;
                 
-                
-                /* Start of nested bracket sub-expression, or comment or lookahead or
-                 lookbehind or option setting or condition. First deal with special things
-                 that can come after a bracket; all are introduced by ?, and the appearance
-                 of any of them means that this is not a referencing group. They were
-                 checked for validity in the first pass over the string, so we don't have to
-                 check for syntax errors here.  */
+            /* Start of nested bracket sub-expression, or comment or lookahead or
+             lookbehind or option setting or condition. First deal with special things
+             that can come after a bracket; all are introduced by ?, and the appearance
+             of any of them means that this is not a referencing group. They were
+             checked for validity in the first pass over the string, so we don't have to
+             check for syntax errors here.  */
                 
             case '(':
                 skipbytes = 0;
@@ -1750,9 +1746,9 @@ compile_branch(int options, int* brackets, uschar** codeptr,
                 }
                 break;
                 
-                /* Check \ for being a real metacharacter; if not, fall through and handle
-                 it as a data character at the start of a string. Escape items are checked
-                 for validity in the pre-compiling pass. */
+            /* Check \ for being a real metacharacter; if not, fall through and handle
+             it as a data character at the start of a string. Escape items are checked
+             for validity in the pre-compiling pass. */
                 
             case '\\':
                 tempptr = ptr;
@@ -2129,7 +2125,7 @@ static bool canApplyFirstCharOptimization(const uschar* code, unsigned bracket_m
          may be referenced. */
         
         } else if (op == OP_TYPESTAR || op == OP_TYPEMINSTAR) {
-            if (scode[1] != OP_ANY_CHAR || (bracket_map & backref_map))
+            if (scode[1] != OP_NOT_NEWLINE || (bracket_map & backref_map))
                 return false;
         } else if (op != OP_CIRC) /* Check for explicit circumflex */
             return false;
@@ -2172,43 +2168,45 @@ static int find_firstassertedchar(const uschar* code, int options, bool inassert
         if (op >= OP_BRA)
             op = OP_BRA;
         
-        switch(op) {
-        default:
-            return -1;
-            
-        case OP_BRA:
-        case OP_ASSERT:
-        case OP_ONCE: {
-            int d;
-            if ((d = find_firstassertedchar(scode, options, op == OP_ASSERT)) < 0)
-                return -1;
-            if (c < 0)
-                c = d;
-            else if (c != d)
-                return -1;
-            break;
-        }
-        case OP_EXACT:       /* Fall through */
-            scode += 2;
-            
-        case OP_CHAR:
-        case OP_CHAR_IGNORING_CASE:
-        case OP_ASCII_CHAR:
-        case OP_ASCII_LETTER_IGNORING_CASE:
-        case OP_PLUS:
-        case OP_MINPLUS:
-            if (!inassert)
+        switch (op) {
+            default:
                 return -1;
-            if (c < 0) {
-                c = scode[1];
-                if (options & IgnoreCaseOption)
-                    c |= REQ_IGNORE_CASE;
+                
+            case OP_BRA:
+            case OP_ASSERT:
+            case OP_ONCE: {
+                int d;
+                if ((d = find_firstassertedchar(scode, options, op == OP_ASSERT)) < 0)
+                    return -1;
+                if (c < 0)
+                    c = d;
+                else if (c != d)
+                    return -1;
+                break;
             }
-            else if (c != scode[1])
-                return -1;
-            break;
+
+            case OP_EXACT:
+                scode += 2;
+                /* Fall through */
+
+            case OP_CHAR:
+            case OP_CHAR_IGNORING_CASE:
+            case OP_ASCII_CHAR:
+            case OP_ASCII_LETTER_IGNORING_CASE:
+            case OP_PLUS:
+            case OP_MINPLUS:
+                if (!inassert)
+                    return -1;
+                if (c < 0) {
+                    c = scode[1];
+                    if (options & IgnoreCaseOption)
+                        c |= REQ_IGNORE_CASE;
+                }
+                else if (c != scode[1])
+                    return -1;
+                break;
         }
-        
+
         code += getOpcodeValueAtOffset(code, 1);
     } while (*code == OP_ALT);
     return c;
@@ -2241,9 +2239,9 @@ static int calculateCompiledPatternLengthAndFlags(const UChar* pattern, int patt
         
         item_count++;    /* Is zero for the first non-comment item */
         
-        switch(c) {
-                /* A backslashed item may be an escaped data character or it may be a
-                 character type. */
+        switch (c) {
+            /* A backslashed item may be an escaped data character or it may be a
+             character type. */
                 
             case '\\':
                 c = check_escape(&ptr, patternEnd, &errorcode, bracount, false);
@@ -2295,23 +2293,23 @@ static int calculateCompiledPatternLengthAndFlags(const UChar* pattern, int patt
                 }
                 continue;
                 
-                case '^':     /* Single-byte metacharacters */
-                case '.':
-                case '$':
+            case '^':     /* Single-byte metacharacters */
+            case '.':
+            case '$':
                 length++;
                 lastitemlength = 1;
                 continue;
                 
-                case '*':            /* These repeats won't be after brackets; */
-                case '+':            /* those are handled separately */
-                case '?':
+            case '*':            /* These repeats won't be after brackets; */
+            case '+':            /* those are handled separately */
+            case '?':
                 length++;
-                goto POSESSIVE;      /* A few lines below */
+                goto POSSESSIVE;
                 
-                /* This covers the cases of braced repeats after a single char, metachar,
-                 class, or back reference. */
-                
-                case '{':
+            /* This covers the cases of braced repeats after a single char, metachar,
+             class, or back reference. */
+            
+            case '{':
                 if (!is_counted_repeat(ptr+1, patternEnd))
                     goto NORMAL_CHAR;
                 ptr = read_repeat_counts(ptr+1, &minRepeats, &maxRepeats, &errorcode);
@@ -2338,32 +2336,31 @@ static int calculateCompiledPatternLengthAndFlags(const UChar* pattern, int patt
                 if (ptr[1] == '?')
                     ptr++;      /* Needs no extra length */
                 
-            POSESSIVE:                     /* Test for possessive quantifier */
+            POSSESSIVE:                     /* Test for possessive quantifier */
                 if (ptr[1] == '+') {
                     ptr++;
                     length += 2 + 2 * LINK_SIZE;   /* Allow for atomic brackets */
                 }
                 continue;
                 
-                /* An alternation contains an offset to the next branch or ket. If any ims
-                 options changed in the previous branch(es), and/or if we are in a
-                 lookbehind assertion, extra space will be needed at the start of the
-                 branch. This is handled by branch_extra. */
+            /* An alternation contains an offset to the next branch or ket. If any ims
+             options changed in the previous branch(es), and/or if we are in a
+             lookbehind assertion, extra space will be needed at the start of the
+             branch. This is handled by branch_extra. */
                 
             case '|':
                 length += 1 + LINK_SIZE + branch_extra;
                 continue;
                 
-                /* A character class uses 33 characters provided that all the character
-                 values are less than 256. Otherwise, it uses a bit map for low valued
-                 characters, and individual items for others. Don't worry about character
-                 types that aren't allowed in classes - they'll get picked up during the
-                 compile. A character class that contains only one single-byte character
-                 uses 2 or 3 bytes, depending on whether it is negated or not. Notice this
-                 where we can. (In UTF-8 mode we can do this only for chars < 128.) */
+            /* A character class uses 33 characters provided that all the character
+             values are less than 256. Otherwise, it uses a bit map for low valued
+             characters, and individual items for others. Don't worry about character
+             types that aren't allowed in classes - they'll get picked up during the
+             compile. A character class that contains only one single-byte character
+             uses 2 or 3 bytes, depending on whether it is negated or not. Notice this
+             where we can. (In UTF-8 mode we can do this only for chars < 128.) */
                 
-            case '[':
-            {
+            case '[': {
                 int class_optcount;
                 if (*(++ptr) == '^') {
                     class_optcount = 10;  /* Greater than one */
@@ -2406,7 +2403,7 @@ static int calculateCompiledPatternLengthAndFlags(const UChar* pattern, int patt
                      characters. */
                     
                     else {
-                        c = getCharAndAdvanceIfSurrogate(ptr, patternEnd);
+                        c = *ptr;
                         
                         /* Come here from handling \ above when it escapes to a char value */
                         
@@ -2424,10 +2421,8 @@ static int calculateCompiledPatternLengthAndFlags(const UChar* pattern, int patt
                                 if (-d == ESC_b)
                                     d = '\b';        /* backspace */
                             }
-                            else if (ptr + 1 < patternEnd && ptr[1] != ']') {
-                                ptr++;
-                                d = getCharAndAdvanceIfSurrogate(ptr, patternEnd);
-                            }
+                            else if (ptr + 1 < patternEnd && ptr[1] != ']')
+                                d = *++ptr;
                             if (d < 0)
                                 ptr = hyptr;      /* go back to hyphen as data */
                         }
@@ -2544,10 +2539,10 @@ static int calculateCompiledPatternLengthAndFlags(const UChar* pattern, int patt
                 }
                 continue;
             }
-                /* Brackets may be genuine groups or special things */
+
+            /* Brackets may be genuine groups or special things */
                 
-            case '(':
-            {
+            case '(': {
                 int branch_newextra = 0;
                 int bracket_length = 1 + LINK_SIZE;
                 bool capturing = false;
@@ -2606,13 +2601,14 @@ static int calculateCompiledPatternLengthAndFlags(const UChar* pattern, int patt
                 length += bracket_length;
                 continue;
             }
-                /* Handle ket. Look for subsequent maxRepeats/minRepeats; for certain sets of values we
-                 have to replicate this bracket up to that many times. If brastackptr is
-                 0 this is an unmatched bracket which will generate an error, but take care
-                 not to try to access brastack[-1] when computing the length and restoring
-                 the branch_extra value. */
-            case ')':
-            {
+
+            /* Handle ket. Look for subsequent maxRepeats/minRepeats; for certain sets of values we
+             have to replicate this bracket up to that many times. If brastackptr is
+             0 this is an unmatched bracket which will generate an error, but take care
+             not to try to access brastack[-1] when computing the length and restoring
+             the branch_extra value. */
+
+            case ')': {
                 int duplength;
                 length += 1 + LINK_SIZE;
                 if (brastackptr > 0) {
@@ -2677,28 +2673,23 @@ static int calculateCompiledPatternLengthAndFlags(const UChar* pattern, int patt
                 }
                 continue;
             }
-                /* Non-special character. It won't be space or # in extended mode, so it is
-                 always a genuine character. If we are in a \Q...\E sequence, check for the
-                 end; if not, we have a literal. */
+
+            /* Non-special character. It won't be space or # in extended mode, so it is
+             always a genuine character. If we are in a \Q...\E sequence, check for the
+             end; if not, we have a literal. */
                 
             default:
             NORMAL_CHAR:
-                
                 length += 2;          /* For a one-byte character */
                 lastitemlength = 1;   /* Default length of last item for repeats */
-                
-                /* In UTF-8 mode, check for additional bytes. */
-                
+
                 if (c > 127) {
-                    c = getCharAndAdvanceIfSurrogate(ptr, patternEnd);
-                    {
-                        int i;
-                        for (i = 0; i < _pcre_utf8_table1_size; i++)
-                            if (c <= _pcre_utf8_table1[i])
-                                break;
-                        length += i;
-                        lastitemlength += i;
-                    }
+                    int i;
+                    for (i = 0; i < _pcre_utf8_table1_size; i++)
+                        if (c <= _pcre_utf8_table1[i])
+                            break;
+                    length += i;
+                    lastitemlength += i;
                 }
                 
                 continue;