Changeset 27807 in webkit for trunk/JavaScriptCore/pcre/pcre_compile.cpp

Timestamp:

Nov 14, 2007, 6:40:31 PM (18 years ago)

Author:

[email protected]

Message:

2007-11-14 Eric Seidel <​[email protected]>

Reviewed by Oliver.

More PCRE style cleanup.

• pcre/pcre_compile.cpp: (compile_regex):

File:

• trunk/JavaScriptCore/pcre/pcre_compile.cpp (modified) (1 diff)

trunk/JavaScriptCore/pcre/pcre_compile.cpp

@@ -2085 +2085 @@
 
 static BOOL
-compile_regex(int options, int *brackets, uschar **codeptr,
-  const pcre_uchar **ptrptr, const pcre_uchar *patternEnd, ErrorCode* errorcodeptr, int skipbytes,
-  int *firstbyteptr, int *reqbyteptr, compile_data *cd)
+compile_regex(int options, int* brackets, uschar** codeptr,
+              const pcre_uchar** ptrptr, const pcre_uchar* patternEnd, ErrorCode* errorcodeptr, int skipbytes,
+              int* firstbyteptr, int* reqbyteptr, compile_data* cd)
 {
-const pcre_uchar *ptr = *ptrptr;
-uschar *code = *codeptr;
-uschar *last_branch = code;
-uschar *start_bracket = code;
-int firstbyte, reqbyte;
-int branchfirstbyte, branchreqbyte;
-
-firstbyte = reqbyte = REQ_UNSET;
-
-/* Offset is set zero to mark that this bracket is still open */
-
-PUT(code, 1, 0);
-code += 1 + LINK_SIZE + skipbytes;
-
-/* Loop for each alternative branch */
-
-for (;;)
-  {
-  /* Now compile the branch */
-
-  if (!compile_branch(options, brackets, &code, &ptr, patternEnd, errorcodeptr,
-        &branchfirstbyte, &branchreqbyte, cd))
-    {
-    *ptrptr = ptr;
-    return false;
+    const pcre_uchar* ptr = *ptrptr;
+    uschar* code = *codeptr;
+    uschar* last_branch = code;
+    uschar* start_bracket = code;
+    int firstbyte, reqbyte;
+    int branchfirstbyte, branchreqbyte;
+    
+    firstbyte = reqbyte = REQ_UNSET;
+    
+    /* Offset is set zero to mark that this bracket is still open */
+    
+    PUT(code, 1, 0);
+    code += 1 + LINK_SIZE + skipbytes;
+    
+    /* Loop for each alternative branch */
+    
+    while (true) {
+        /* Now compile the branch */
+        
+        if (!compile_branch(options, brackets, &code, &ptr, patternEnd, errorcodeptr,
+                            &branchfirstbyte, &branchreqbyte, cd)) {
+            *ptrptr = ptr;
+            return false;
+        }
+        
+        /* If this is the first branch, the firstbyte and reqbyte values for the
+         branch become the values for the regex. */
+        
+        if (*last_branch != OP_ALT) {
+            firstbyte = branchfirstbyte;
+            reqbyte = branchreqbyte;
+        }
+        
+        /* If this is not the first branch, the first char and reqbyte have to
+         match the values from all the previous branches, except that if the previous
+         value for reqbyte didn't have REQ_VARY set, it can still match, and we set
+         REQ_VARY for the regex. */
+        
+        else {
+            /* If we previously had a firstbyte, but it doesn't match the new branch,
+             we have to abandon the firstbyte for the regex, but if there was previously
+             no reqbyte, it takes on the value of the old firstbyte. */
+            
+            if (firstbyte >= 0 && firstbyte != branchfirstbyte) {
+                if (reqbyte < 0)
+                    reqbyte = firstbyte;
+                firstbyte = REQ_NONE;
+            }
+            
+            /* If we (now or from before) have no firstbyte, a firstbyte from the
+             branch becomes a reqbyte if there isn't a branch reqbyte. */
+            
+            if (firstbyte < 0 && branchfirstbyte >= 0 && branchreqbyte < 0)
+                branchreqbyte = branchfirstbyte;
+            
+            /* Now ensure that the reqbytes match */
+            
+            if ((reqbyte & ~REQ_VARY) != (branchreqbyte & ~REQ_VARY))
+                reqbyte = REQ_NONE;
+            else
+                reqbyte |= branchreqbyte;   /* To "or" REQ_VARY */
+        }
+        
+        /* Reached end of expression, either ')' or end of pattern. Go back through
+         the alternative branches and reverse the chain of offsets, with the field in
+         the BRA item now becoming an offset to the first alternative. If there are
+         no alternatives, it points to the end of the group. The length in the
+         terminating ket is always the length of the whole bracketed item. If any of
+         the ims options were changed inside the group, compile a resetting op-code
+         following, except at the very end of the pattern. Return leaving the pointer
+         at the terminating char. */
+        
+        if (ptr >= patternEnd || *ptr != '|') {
+            int length = code - last_branch;
+            do {
+                int prev_length = GET(last_branch, 1);
+                PUT(last_branch, 1, length);
+                length = prev_length;
+                last_branch -= length;
+            } while (length > 0);
+            
+            /* Fill in the ket */
+            
+            *code = OP_KET;
+            PUT(code, 1, code - start_bracket);
+            code += 1 + LINK_SIZE;
+            
+            /* Set values to pass back */
+            
+            *codeptr = code;
+            *ptrptr = ptr;
+            *firstbyteptr = firstbyte;
+            *reqbyteptr = reqbyte;
+            return true;
+        }
+        
+        /* Another branch follows; insert an "or" node. Its length field points back
+         to the previous branch while the bracket remains open. At the end the chain
+         is reversed. It's done like this so that the start of the bracket has a
+         zero offset until it is closed, making it possible to detect recursion. */
+        
+        *code = OP_ALT;
+        PUT(code, 1, code - last_branch);
+        last_branch = code;
+        code += 1 + LINK_SIZE;
+        ptr++;
     }
-
-  /* If this is the first branch, the firstbyte and reqbyte values for the
-  branch become the values for the regex. */
-
-  if (*last_branch != OP_ALT)
-    {
-    firstbyte = branchfirstbyte;
-    reqbyte = branchreqbyte;
-    }
-
-  /* If this is not the first branch, the first char and reqbyte have to
-  match the values from all the previous branches, except that if the previous
-  value for reqbyte didn't have REQ_VARY set, it can still match, and we set
-  REQ_VARY for the regex. */
-
-  else
-    {
-    /* If we previously had a firstbyte, but it doesn't match the new branch,
-    we have to abandon the firstbyte for the regex, but if there was previously
-    no reqbyte, it takes on the value of the old firstbyte. */
-
-    if (firstbyte >= 0 && firstbyte != branchfirstbyte)
-      {
-      if (reqbyte < 0) reqbyte = firstbyte;
-      firstbyte = REQ_NONE;
-      }
-
-    /* If we (now or from before) have no firstbyte, a firstbyte from the
-    branch becomes a reqbyte if there isn't a branch reqbyte. */
-
-    if (firstbyte < 0 && branchfirstbyte >= 0 && branchreqbyte < 0)
-        branchreqbyte = branchfirstbyte;
-
-    /* Now ensure that the reqbytes match */
-
-    if ((reqbyte & ~REQ_VARY) != (branchreqbyte & ~REQ_VARY))
-      reqbyte = REQ_NONE;
-    else reqbyte |= branchreqbyte;   /* To "or" REQ_VARY */
-    }
-
-  /* Reached end of expression, either ')' or end of pattern. Go back through
-  the alternative branches and reverse the chain of offsets, with the field in
-  the BRA item now becoming an offset to the first alternative. If there are
-  no alternatives, it points to the end of the group. The length in the
-  terminating ket is always the length of the whole bracketed item. If any of
-  the ims options were changed inside the group, compile a resetting op-code
-  following, except at the very end of the pattern. Return leaving the pointer
-  at the terminating char. */
-
-  if (ptr >= patternEnd || *ptr != '|')
-    {
-    int length = code - last_branch;
-    do
-      {
-      int prev_length = GET(last_branch, 1);
-      PUT(last_branch, 1, length);
-      length = prev_length;
-      last_branch -= length;
-      }
-    while (length > 0);
-
-    /* Fill in the ket */
-
-    *code = OP_KET;
-    PUT(code, 1, code - start_bracket);
-    code += 1 + LINK_SIZE;
-
-    /* Set values to pass back */
-
-    *codeptr = code;
-    *ptrptr = ptr;
-    *firstbyteptr = firstbyte;
-    *reqbyteptr = reqbyte;
-    return true;
-    }
-
-  /* Another branch follows; insert an "or" node. Its length field points back
-  to the previous branch while the bracket remains open. At the end the chain
-  is reversed. It's done like this so that the start of the bracket has a
-  zero offset until it is closed, making it possible to detect recursion. */
-
-  *code = OP_ALT;
-  PUT(code, 1, code - last_branch);
-  last_branch = code;
-  code += 1 + LINK_SIZE;
-  ptr++;
-  }
-/* Control never reaches here */
+    ASSERT_NOT_REACHED();
 }
-
-