/[pcre]/code/trunk/pcre_compile.c

Diff of /code/trunk/pcre_compile.c

Parent Directory | Revision Log | View Patch Patch

-revision 171 by ph10,
Mon Jun  4 14:28:58 2007 UTC
+revision 172 by ph10,
Tue Jun  5 10:40:13 2007 UTC
 Line 243 
 static const char *error_texts[] = {
    "repeating a DEFINE group is not allowed",
    "inconsistent NEWLINE options",
    "\\g is not followed by a braced name or an optionally braced non-zero number",
    "(?+ or (?- or (?(+ or (?(- must be followed by a non-zero number"
  };
 Line 453 
 else
      /* \g must be followed by a number, either plain or braced. If positive, it
      is an absolute backreference. If negative, it is a relative backreference.
      This is a Perl 5.10 feature. Perl 5.10 also supports \g{name} as a
      reference to a named group. This is part of Perl's movement towards a
      unified syntax for back references. As this is synonymous with \k{name}, we
      fudge it up by pretending it really was \k. */
      case 'g':
 Line 464 
 else
        const uschar *p;
        for (p = ptr+2; *p != 0 && *p != '}'; p++)
          if (*p != '-' && (digitab[*p] & ctype_digit) == 0) break;
        if (*p != 0 && *p != '}')
          {
          c = -ESC_k;
          break;
          }
        braced = TRUE;
        ptr++;
        }
 Line 1381 
 for (code = first_significant_code(code
    const uschar *ccode;
    c = *code;
    /* Groups with zero repeats can of course be empty; skip them. */
    if (c == OP_BRAZERO || c == OP_BRAMINZERO)
      {
+     code += _pcre_OP_lengths[c];
      do code += GET(code, 1); while (*code == OP_ALT);
      c = *code;
      continue;
      }
    /* For other groups, scan the branches. */
    if (c == OP_BRA || c == OP_CBRA || c == OP_ONCE)
      {
      BOOL empty_branch;
-Line 1409 
 for (code = first_significant_code(code
+Line 1410 
 for (code = first_significant_code(code
        }
      while (*code == OP_ALT);
      if (!empty_branch) return FALSE;   /* All branches are non-empty */
      c = *code;
      continue;
      }
-Line 2113 
 for (;; ptr++)
+Line 2114 
 for (;; ptr++)
    int class_lastchar;
    int newoptions;
    int recno;
    int refsign;
    int skipbytes;
    int subreqbyte;
    int subfirstbyte;
-Line 3640 
 for (;; ptr++)
+Line 3641 
 for (;; ptr++)
          code[1+LINK_SIZE] = OP_CREF;
          skipbytes = 3;
          refsign = -1;
          /* Check for a test for recursion in a named group. */
-Line 3664 
 for (;; ptr++)
+Line 3665 
 for (;; ptr++)
            terminator = '\'';
            ptr++;
            }
          else
            {
            terminator = 0;
            if (ptr[1] == '-' || ptr[1] == '+') refsign = *(++ptr);
            }
          /* We now expect to read a name; any thing else is an error */
-Line 3706 
 for (;; ptr++)
+Line 3707 
 for (;; ptr++)
          /* In the real compile we do the work of looking for the actual
          reference. If the string started with "+" or "-" we require the rest to
          be digits, in which case recno will be set. */
          if (refsign > 0)
            {
            if (recno <= 0)
              {
              *errorcodeptr = ERR58;
              goto FAILED;
              }
            if (refsign == '-')
              {
              recno = cd->bracount - recno + 1;
              if (recno <= 0)
                {
                *errorcodeptr = ERR15;
                goto FAILED;
                }
              }
            else recno += cd->bracount;
            PUT2(code, 2+LINK_SIZE, recno);
            break;
            }
          /* Otherwise (did not start with "+" or "-"), start by looking for the
          name. */
          slot = cd->name_table;
          for (i = 0; i < cd->names_found; i++)
            {
-Line 4055 
 for (;; ptr++)
+Line 4056 
 for (;; ptr++)
            const uschar *called;
            if ((refsign = *ptr) == '+') ptr++;
            else if (refsign == '-')
              {
              if ((digitab[ptr[1]] & ctype_digit) == 0)
                goto OTHER_CHAR_AFTER_QUERY;
              ptr++;
              }
            recno = 0;
            while((digitab[*ptr] & ctype_digit) != 0)
              recno = recno * 10 + *ptr++ - '0';
-Line 4071 
 for (;; ptr++)
+Line 4072 
 for (;; ptr++)
              *errorcodeptr = ERR29;
              goto FAILED;
              }
            if (refsign == '-')
              {
              if (recno == 0)
                {
                *errorcodeptr = ERR58;
                goto FAILED;
                }
              recno = cd->bracount - recno + 1;
              if (recno <= 0)
                {
                *errorcodeptr = ERR15;
                goto FAILED;
                }
              }
            else if (refsign == '+')
              {
-Line 4092 
 for (;; ptr++)
+Line 4093 
 for (;; ptr++)
                {
                *errorcodeptr = ERR58;
                goto FAILED;
                }
              recno += cd->bracount;
              }
            /* Come here from code above that handles a named recursion */
-Line 4168 
 for (;; ptr++)
+Line 4169 
 for (;; ptr++)
          /* ------------------------------------------------------------ */
          default:              /* Other characters: check option setting */
          OTHER_CHAR_AFTER_QUERY:
          set = unset = 0;
          optset = &set;
-Line 4319 
 for (;; ptr++)
+Line 4320 
 for (;; ptr++)
      is on the bracket. */
      /* If this is a conditional bracket, check that there are no more than
-     two branches in the group, or just one if it's a DEFINE group. */
+     two branches in the group, or just one if it's a DEFINE group. We do this
+     in the real compile phase, not in the pre-pass, where the whole group may
+     not be available. */
-     if (bravalue == OP_COND)
+     if (bravalue == OP_COND && lengthptr == NULL)
        {
        uschar *tc = code;
        int condcount = 0;
-Line 4653 
 This function is used during the pre-com
+Line 4656 
 This function is used during the pre-com
  out the amount of memory needed, as well as during the real compile phase. The
  value of lengthptr distinguishes the two phases.
- Argument:
+ Arguments:
    options        option bits, including any changes for this subpattern
    oldims         previous settings of ims option bits
    codeptr        -> the address of the current code pointer
-Line 4806 
 for (;;)
+Line 4809 
 for (;;)
        }
      }
-   /* Reached end of expression, either ')' or end of pattern. Go back through
+   /* Reached end of expression, either ')' or end of pattern. In the real
-   the alternative branches and reverse the chain of offsets, with the field in
+   compile phase, go back through the alternative branches and reverse the chain
-   the BRA item now becoming an offset to the first alternative. If there are
+   of offsets, with the field in the BRA item now becoming an offset to the
-   no alternatives, it points to the end of the group. The length in the
+   first alternative. If there are no alternatives, it points to the end of the
-   terminating ket is always the length of the whole bracketed item. If any of
+   group. The length in the terminating ket is always the length of the whole
-   the ims options were changed inside the group, compile a resetting op-code
+   bracketed item. If any of the ims options were changed inside the group,
-   following, except at the very end of the pattern. Return leaving the pointer
+   compile a resetting op-code following, except at the very end of the pattern.
-   at the terminating char. */
+   Return leaving the pointer at the terminating char. */
    if (*ptr != '|')
      {
-     int branch_length = code - last_branch;
+     if (lengthptr == NULL)
-     do
        {
-       int prev_length = GET(last_branch, 1);
+       int branch_length = code - last_branch;
-       PUT(last_branch, 1, branch_length);
+       do
-       branch_length = prev_length;
+         {
-       last_branch -= branch_length;
+         int prev_length = GET(last_branch, 1);
+         PUT(last_branch, 1, branch_length);
+         branch_length = prev_length;
+         last_branch -= branch_length;
+         }
+       while (branch_length > 0);
        }
-     while (branch_length > 0);
      /* Fill in the ket */
-Line 4852 
 for (;;)
+Line 4858 
 for (;;)
      return TRUE;
      }
-   /* Another branch follows; insert an "or" node. Its length field points back
+   /* Another branch follows. In the pre-compile phase, we can move the code
+   pointer back to where it was for the start of the first branch. (That is,
+   pretend that each branch is the only one.)
+   In the real compile phase, insert an ALT 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;
+   if (lengthptr != NULL)
-   PUT(code, 1, code - last_branch);
+     {
-   bc.current = last_branch = code;
+     code = *codeptr + 1 + LINK_SIZE + skipbytes;
-   code += 1 + LINK_SIZE;
+     length += 1 + LINK_SIZE;
+     }
+   else
+     {
+     *code = OP_ALT;
+     PUT(code, 1, code - last_branch);
+     bc.current = last_branch = code;
+     code += 1 + LINK_SIZE;
+     }
    ptr++;
-   length += 1 + LINK_SIZE;
    }
  /* Control never reaches here */
  }

 Legend:



Removed from v.171
 


changed lines


 
Added in v.172
 Legend:



Removed from v.171
 


changed lines


 
Added in v.172
-Removed from v.171
+Added in v.172

	ViewVC Help
Powered by ViewVC 1.1.5