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

Diff of /code/trunk/pcre.c

Parent Directory | Revision Log | View Patch Patch

-revision 3 by nigel,
Sat Feb 24 21:38:01 2007 UTC
+revision 17 by nigel,
Sat Feb 24 21:38:29 2007 UTC
 Line 9 
 the file Tech.Notes for some information
  Written by: Philip Hazel <ph10@cam.ac.uk>
-            Copyright (c) 1997 University of Cambridge
+            Copyright (c) 1998 University of Cambridge
  -----------------------------------------------------------------------------
  Permission is granted to anyone to use this software for any purpose on any
 Line 33 
 restrictions:
  /* #define DEBUG */
+ /* Use a macro for debugging printing, 'cause that eliminates the the use
+ of #ifdef inline, and there are *still* stupid compilers about that don't like
+ indented pre-processor statements. I suppose it's only been 10 years... */
+ #ifdef DEBUG
+ #define DPRINTF(p) printf p
+ #else
+ #define DPRINTF(p) /*nothing*/
+ #endif
  /* Include the internals header, which itself includes Standard C headers plus
  the external pcre header. */
-Line 40 
 the external pcre header. */
+Line 49 
 the external pcre header. */
  #include "internal.h"
+ /* Allow compilation as C++ source code, should anybody want to do that. */
+ #ifdef __cplusplus
+ #define class pcre_class
+ #endif
  /* Min and max values for the common repeats; for the maxima, 0 => infinity */
- static char rep_min[] = { 0, 0, 1, 1, 0, 0 };
+ static const char rep_min[] = { 0, 0, 1, 1, 0, 0 };
- static char rep_max[] = { 0, 0, 0, 0, 1, 1 };
+ static const char rep_max[] = { 0, 0, 0, 0, 1, 1 };
- /* Text forms of OP_ values and things, for debugging */
+ /* Text forms of OP_ values and things, for debugging (not all used) */
  #ifdef DEBUG
- static char *OP_names[] = { "End", "\\A", "\\B", "\\b", "\\D", "\\d",
+ static const char *OP_names[] = {
+   "End", "\\A", "\\B", "\\b", "\\D", "\\d",
    "\\S", "\\s", "\\W", "\\w", "Cut", "\\Z", "^", "$", "Any", "chars",
    "not",
    "*", "*?", "+", "+?", "?", "??", "{", "{", "{",
    "*", "*?", "+", "+?", "?", "??", "{", "{", "{",
    "*", "*?", "+", "+?", "?", "??", "{", "{", "{",
    "*", "*?", "+", "+?", "?", "??", "{", "{",
-   "class", "Ref",
+   "class", "negclass", "Ref",
    "Alt", "Ket", "KetRmax", "KetRmin", "Assert", "Assert not", "Once",
    "Brazero", "Braminzero", "Bra"
  };
-Line 66 
 are simple data values; negative values
+Line 83 
 are simple data values; negative values
  on. Zero means further processing is needed (for things like \x), or the escape
  is invalid. */
- static short int escapes[] = {
+ static const short int escapes[] = {
 ,      0,      0,      0,      0,      0,      0,      0,   /* 0 - 7 */
 ,      0,    ':',    ';',    '<',    '=',    '>',    '?',   /* 8 - ? */
    '@', -ESC_A, -ESC_B,      0, -ESC_D,      0,      0,      0,   /* @ - G */
-Line 81 
 static short int escapes[] = {
+Line 98 
 static short int escapes[] = {
  /* Definition to allow mutual recursion */
- static BOOL compile_regex(int, int *,uschar **,uschar **,char **);
+ static BOOL
+   compile_regex(int, int *, uschar **, const uschar **, const char **);
  /* Structure for passing "static" information around between the functions
  doing the matching, so that they are thread-safe. */
-Line 98 
 typedef struct match_data {
+Line 116 
 typedef struct match_data {
    BOOL   noteol;                /* NOTEOL flag */
    BOOL   dotall;                /* Dot matches any char */
    BOOL   endonly;               /* Dollar not before final \n */
-   uschar *start_subject;        /* Start of the subject string */
+   const uschar *start_subject;  /* Start of the subject string */
-   uschar *end_subject;          /* End of the subject string */
+   const uschar *end_subject;    /* End of the subject string */
    jmp_buf fail_env;             /* Environment for longjump() break out */
-   uschar *end_match_ptr;        /* Subject position at end match */
+   const uschar *end_match_ptr;  /* Subject position at end match */
    int     end_offset_top;       /* Highwater mark at end of match */
  } match_data;
-Line 126 
 void  (*pcre_free)(void *) = free;
+Line 144 
 void  (*pcre_free)(void *) = free;
  *          Return version string                 *
  *************************************************/
- char *
+ const char *
  pcre_version(void)
  {
  return PCRE_VERSION;
-Line 156 
 Returns:        number of identifying ex
+Line 174 
 Returns:        number of identifying ex
  int
  pcre_info(const pcre *external_re, int *optptr, int *first_char)
  {
- real_pcre *re = (real_pcre *)external_re;
+ const real_pcre *re = (const real_pcre *)external_re;
  if (re == NULL) return PCRE_ERROR_NULL;
  if (re->magic_number != MAGIC_NUMBER) return PCRE_ERROR_BADMAGIC;
  if (optptr != NULL) *optptr = (re->options & PUBLIC_OPTIONS);
-Line 186 
 Arguments:
+Line 204 
 Arguments:
  Returns:     nothing
  */
- static pchars(uschar *p, int length, BOOL is_subject, match_data *md)
+ static void
+ pchars(const uschar *p, int length, BOOL is_subject, match_data *md)
  {
  int c;
  if (is_subject && length > md->end_subject - p) length = md->end_subject - p;
-Line 228 
 do {
+Line 247 
 do {
      /* Test an embedded subpattern; if it could not be empty, break the
      loop. Otherwise carry on in the branch. */
-     if ((int)(*cc) >= OP_BRA)
+     if ((int)(*cc) >= OP_BRA || (int)(*cc) == OP_ONCE)
        {
        if (!could_be_empty(cc)) break;
        do cc += (cc[1] << 8) + cc[2]; while (*cc == OP_ALT);
-Line 245 
 do {
+Line 264 
 do {
        case OP_KETRMIN:
        return TRUE;
+       /* Skip over entire bracket groups with zero lower bound */
+       case OP_BRAZERO:
+       case OP_BRAMINZERO:
+       cc++;
+       /* Fall through */
        /* Skip over assertive subpatterns */
        case OP_ASSERT:
-Line 259 
 do {
+Line 285 
 do {
        case OP_EOD:
        case OP_CIRC:
        case OP_DOLL:
-       case OP_BRAZERO:
-       case OP_BRAMINZERO:
        case OP_NOT_WORD_BOUNDARY:
        case OP_WORD_BOUNDARY:
        cc++;
-Line 272 
 do {
+Line 296 
 do {
        case OP_MINSTAR:
        case OP_QUERY:
        case OP_MINQUERY:
+       case OP_NOTSTAR:
+       case OP_NOTMINSTAR:
+       case OP_NOTQUERY:
+       case OP_NOTMINQUERY:
        case OP_TYPESTAR:
        case OP_TYPEMINSTAR:
        case OP_TYPEQUERY:
-Line 291 
 do {
+Line 319 
 do {
        /* Check a class or a back reference for a zero minimum */
        case OP_CLASS:
+       case OP_NEGCLASS:
        case OP_REF:
-       cc += (*cc == OP_REF)? 2 : 4 + 2 * cc[2] + cc[3];
+       cc += (*cc == OP_REF)? 2 : 33;
        switch (*cc)
          {
-Line 356 
 Returns:     zero or positive => a data
+Line 385 
 Returns:     zero or positive => a data
  */
  static int
- check_escape(uschar **ptrptr, char **errorptr, int bracount, int options,
+ check_escape(const uschar **ptrptr, const char **errorptr, int bracount,
-   BOOL isclass)
+   int options, BOOL isclass)
  {
- uschar *ptr = *ptrptr;
+ const uschar *ptr = *ptrptr;
  int c = *(++ptr) & 255;   /* Ensure > 0 on signed-char systems */
  int i;
-Line 378 
 else if ((i = escapes[c - '0']) != 0) c
+Line 407 
 else if ((i = escapes[c - '0']) != 0) c
  else
    {
-   uschar *oldptr;
+   const uschar *oldptr;
    switch (c)
      {
      /* The handling of escape sequences consisting of a string of digits
-Line 498 
 Returns:    TRUE or FALSE
+Line 527 
 Returns:    TRUE or FALSE
  */
  static BOOL
- is_counted_repeat(uschar *p)
+ is_counted_repeat(const uschar *p)
  {
  if ((pcre_ctypes[*p++] & ctype_digit) == 0) return FALSE;
  while ((pcre_ctypes[*p] & ctype_digit) != 0) p++;
-Line 533 
 Returns:     pointer to '}' on success;
+Line 562 
 Returns:     pointer to '}' on success;
               current ptr on error, with errorptr set
  */
- static uschar *
+ static const uschar *
- read_repeat_counts(uschar *p, int *minp, int *maxp, char **errorptr)
+ read_repeat_counts(const uschar *p, int *minp, int *maxp, const char **errorptr)
  {
  int min = 0;
  int max = -1;
-Line 588 
 Returns:     TRUE on success
+Line 617 
 Returns:     TRUE on success
  */
  static BOOL
- compile_branch(int options, int *brackets, uschar **codeptr, uschar **ptrptr,
+ compile_branch(int options, int *brackets, uschar **codeptr,
-   char **errorptr)
+   const uschar **ptrptr, const char **errorptr)
  {
  int repeat_type, op_type;
  int repeat_min, repeat_max;
  int bravalue, length;
  register int c;
  register uschar *code = *codeptr;
- uschar *ptr = *ptrptr;
+ const uschar *ptr = *ptrptr;
+ const uschar *oldptr;
  uschar *previous = NULL;
- uschar *oldptr;
  uschar class[32];
  /* Switch on next character until the end of the branch */
-Line 655 
 for (;; ptr++)
+Line 684 
 for (;; ptr++)
      case '[':
      previous = code;
-     *code++ = OP_CLASS;
-     /* If the first character is '^', set the negation flag */
+     /* If the first character is '^', set the negation flag, and use a
+     different opcode. This only matters if caseless matching is specified at
+     runtime. */
      if ((c = *(++ptr)) == '^')
        {
        negate_class = TRUE;
+       *code++ = OP_NEGCLASS;
        c = *(++ptr);
        }
-     else negate_class = FALSE;
+     else
+       {
+       negate_class = FALSE;
+       *code++ = OP_CLASS;
+       }
      /* Keep a count of chars so that we can optimize the case of just a single
      character. */
-Line 693 
 for (;; ptr++)
+Line 728 
 for (;; 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.
-       Inside a class (and only there) it is treated as backslash. Elsewhere
+       Inside a class (and only there) it is treated as backspace. Elsewhere
        it marks a word boundary. Other escapes have preset maps ready to
        or into the one we are building. We assume they have more than one
        character in them, so set class_count bigger than one. */
-Line 972 
 for (;; ptr++)
+Line 1007 
 for (;; ptr++)
            if (code == previous) code += 2; else previous[1]++;
            }
-         /* Insert an UPTO if the max is greater than the min. */
+         /* If the maximum is unlimited, insert an OP_STAR. */
+         if (repeat_max < 0)
+           {
+           *code++ = c;
+           *code++ = OP_STAR + repeat_type;
+           }
+         /* Else insert an UPTO if the max is greater than the min. */
-         if (repeat_max != repeat_min)
+         else if (repeat_max != repeat_min)
            {
            *code++ = c;
            repeat_max -= repeat_min;
-Line 992 
 for (;; ptr++)
+Line 1035 
 for (;; ptr++)
      /* If previous was a character class or a back reference, we put the repeat
      stuff after it. */
-     else if (*previous == OP_CLASS || *previous == OP_REF)
+     else if (*previous == OP_CLASS || *previous == OP_NEGCLASS ||
+              *previous == OP_REF)
        {
        if (repeat_min == 0 && repeat_max == -1)
          *code++ = OP_CRSTAR + repeat_type;
-Line 1018 
 for (;; ptr++)
+Line 1062 
 for (;; ptr++)
      else if ((int)*previous >= OP_BRA)
        {
        int i;
-       int length = code - previous;
+       int len = code - previous;
        if (repeat_max == -1 && could_be_empty(previous))
          {
-Line 1035 
 for (;; ptr++)
+Line 1079 
 for (;; ptr++)
          {
          for (i = 1; i < repeat_min; i++)
            {
-           memcpy(code, previous, length);
+           memcpy(code, previous, len);
-           code += length;
+           code += len;
            }
          }
-Line 1048 
 for (;; ptr++)
+Line 1092 
 for (;; ptr++)
          {
          if (repeat_min == 0)
            {
-           memmove(previous+1, previous, length);
+           memmove(previous+1, previous, len);
            code++;
            *previous++ = OP_BRAZERO + repeat_type;
            }
          for (i = 1; i < repeat_min; i++)
            {
-           memcpy(code, previous, length);
+           memcpy(code, previous, len);
-           code += length;
+           code += len;
            }
          for (i = (repeat_min > 0)? repeat_min : 1; i < repeat_max; i++)
            {
            *code++ = OP_BRAZERO + repeat_type;
-           memcpy(code, previous, length);
+           memcpy(code, previous, len);
-           code += length;
+           code += len;
            }
          }
-Line 1210 
 for (;; ptr++)
+Line 1254 
 for (;; ptr++)
        continue;
        }
-     /* Reset and fall through */
+     /* Data character: reset and fall through */
      ptr = oldptr;
      c = '\\';
-Line 1264 
 for (;; ptr++)
+Line 1308 
 for (;; ptr++)
      the next state. */
      previous[1] = length;
-     ptr--;
+     if (length < 255) ptr--;
      break;
      }
    }                   /* end of big loop */
-Line 1301 
 Returns:    TRUE on success
+Line 1345 
 Returns:    TRUE on success
  */
  static BOOL
- compile_regex(int options, int *brackets, uschar **codeptr, uschar **ptrptr,
+ compile_regex(int options, int *brackets, uschar **codeptr,
-   char **errorptr)
+   const uschar **ptrptr, const char **errorptr)
  {
- uschar *ptr = *ptrptr;
+ const uschar *ptr = *ptrptr;
  uschar *code = *codeptr;
  uschar *start_bracket = code;
-Line 1370 
 Returns:   TRUE or FALSE
+Line 1414 
 Returns:   TRUE or FALSE
  */
  static BOOL
- is_anchored(register uschar *code, BOOL multiline)
+ is_anchored(register const uschar *code, BOOL multiline)
  {
  do {
     int op = (int)code[3];
-Line 1399 
 Returns:   TRUE or FALSE
+Line 1443 
 Returns:   TRUE or FALSE
  */
  static BOOL
- is_startline(uschar *code)
+ is_startline(const uschar *code)
  {
  do {
     if ((int)code[3] >= OP_BRA || code[3] == OP_ASSERT)
-Line 1484 
 Returns:       pointer to compiled data
+Line 1528 
 Returns:       pointer to compiled data
  */
  pcre *
- pcre_compile(const char *pattern, int options, char **errorptr,
+ pcre_compile(const char *pattern, int options, const char **errorptr,
    int *erroroffset)
  {
  real_pcre *re;
-Line 1494 
 int runlength;
+Line 1538 
 int runlength;
  int c, size;
  int bracount = 0;
  int brastack[200];
- int brastackptr = 0;
  int top_backref = 0;
- uschar *code, *ptr;
+ unsigned int brastackptr = 0;
+ uschar *code;
+ const uschar *ptr;
  #ifdef DEBUG
  uschar *code_base, *code_end;
-Line 1523 
 if ((options & ~PUBLIC_OPTIONS) != 0)
+Line 1568 
 if ((options & ~PUBLIC_OPTIONS) != 0)
    return NULL;
    }
- #ifdef DEBUG
+ DPRINTF(("------------------------------------------------------------------\n"));
- printf("------------------------------------------------------------------\n");
+ DPRINTF(("%s\n", pattern));
- printf("%s\n", pattern);
- #endif
  /* The first thing to do is to make a pass over the pattern to compute the
  amount of store required to hold the compiled code. This does not have to be
-Line 1535 
 internal flag settings. Make an attempt
+Line 1578 
 internal flag settings. Make an attempt
  if an "extended" flag setting appears late in the pattern. We can't be so
  clever for #-comments. */
- ptr = (uschar *)(pattern - 1);
+ ptr = (const uschar *)(pattern - 1);
  while ((c = *(++ptr)) != 0)
    {
    int min, max;
-Line 1562 
 while ((c = *(++ptr)) != 0)
+Line 1605 
 while ((c = *(++ptr)) != 0)
      case '\\':
        {
-       uschar *save_ptr = ptr;
+       const uschar *save_ptr = ptr;
        c = check_escape(&ptr, errorptr, bracount, options, FALSE);
        if (*errorptr != NULL) goto PCRE_ERROR_RETURN;
        if (c >= 0)
-Line 1641 
 while ((c = *(++ptr)) != 0)
+Line 1684 
 while ((c = *(++ptr)) != 0)
        {
        if (*ptr == '\\')
          {
-         int c = check_escape(&ptr, errorptr, bracount, options, TRUE);
+         int ch = check_escape(&ptr, errorptr, bracount, options, TRUE);
          if (*errorptr != NULL) goto PCRE_ERROR_RETURN;
-         if (-c == ESC_b) class_charcount++; else class_charcount = 10;
+         if (-ch == ESC_b) class_charcount++; else class_charcount = 10;
          }
        else class_charcount++;
        ptr++;
-Line 1658 
 while ((c = *(++ptr)) != 0)
+Line 1701 
 while ((c = *(++ptr)) != 0)
        /* A repeat needs either 1 or 5 bytes. */
-       if (ptr[1] == '{' && is_counted_repeat(ptr+2))
+       if (*ptr != 0 && ptr[1] == '{' && is_counted_repeat(ptr+2))
          {
          ptr = read_repeat_counts(ptr+2, &min, &max, errorptr);
          if (*errorptr != NULL) goto PCRE_ERROR_RETURN;
-Line 1766 
 while ((c = *(++ptr)) != 0)
+Line 1809 
 while ((c = *(++ptr)) != 0)
      continue;
      /* Handle ket. Look for subsequent max/min; for certain sets of values we
-     have to replicate this bracket up to that many times. */
+     have to replicate this bracket up to that many times. If brastackptr is
+this is an unmatched bracket which will generate an error, but take care
+     not to try to access brastack[-1]. */
      case ')':
      length += 3;
        {
-       int min = 1;
+       int minval = 1;
-       int max = 1;
+       int maxval = 1;
-       int duplength = length - brastack[--brastackptr];
+       int duplength = (brastackptr > 0)? length - brastack[--brastackptr] : 0;
        /* Leave ptr at the final char; for read_repeat_counts this happens
        automatically; for the others we need an increment. */
        if ((c = ptr[1]) == '{' && is_counted_repeat(ptr+2))
          {
-         ptr = read_repeat_counts(ptr+2, &min, &max, errorptr);
+         ptr = read_repeat_counts(ptr+2, &minval, &maxval, errorptr);
          if (*errorptr != NULL) goto PCRE_ERROR_RETURN;
          }
-       else if (c == '*') { min = 0; max = -1; ptr++; }
+       else if (c == '*') { minval = 0; maxval = -1; ptr++; }
-       else if (c == '+') { max = -1; ptr++; }
+       else if (c == '+') { maxval = -1; ptr++; }
-       else if (c == '?') { min = 0; ptr++; }
+       else if (c == '?') { minval = 0; ptr++; }
-       /* If there is a minimum > 1 we have to replicate up to min-1 times; if
+       /* If there is a minimum > 1 we have to replicate up to minval-1 times;
-       there is a limited maximum we have to replicate up to max-1 times and
+       if there is a limited maximum we have to replicate up to maxval-1 times
-       allow for a BRAZERO item before each optional copy, as we also have to
+       and allow for a BRAZERO item before each optional copy, as we also have
-       do before the first copy if the minimum is zero. */
+       to do before the first copy if the minimum is zero. */
-       if (min == 0) length++;
+       if (minval == 0) length++;
-         else if (min > 1) length += (min - 1) * duplength;
+         else if (minval > 1) length += (minval - 1) * duplength;
-       if (max > min) length += (max - min) * (duplength + 1);
+       if (maxval > minval) length += (maxval - minval) * (duplength + 1);
        }
      continue;
      /* Non-special character. For a run of such characters the length required
-Line 1827 
 while ((c = *(++ptr)) != 0)
+Line 1871 
 while ((c = *(++ptr)) != 0)
        if (c == '\\')
          {
-         uschar *saveptr = ptr;
+         const uschar *saveptr = ptr;
          c = check_escape(&ptr, errorptr, bracount, options, FALSE);
          if (*errorptr != NULL) goto PCRE_ERROR_RETURN;
          if (c < 0) { ptr = saveptr; break; }
-Line 1857 
 if (length > 65539)
+Line 1901 
 if (length > 65539)
    }
  /* Compute the size of data block needed and get it, either from malloc or
- externally provided function. Put in the magic number and the options. */
+ externally provided function. We specify "code[0]" in the offsetof() expression
+ rather than just "code", because it has been reported that one broken compiler
+ fails on "code" because it is also an independent variable. It should make no
+ difference to the value of the offsetof(). */
- size = length + offsetof(real_pcre, code);
+ size = length + offsetof(real_pcre, code[0]);
  re = (real_pcre *)(pcre_malloc)(size);
  if (re == NULL)
-Line 1868 
 if (re == NULL)
+Line 1915 
 if (re == NULL)
    return NULL;
    }
+ /* Put in the magic number and the options. */
  re->magic_number = MAGIC_NUMBER;
  re->options = options;
-Line 1875 
 re->options = options;
+Line 1924 
 re->options = options;
  error, *errorptr will be set non-NULL, so we don't need to look at the result
  of the function here. */
- ptr = (uschar *)pattern;
+ ptr = (const uschar *)pattern;
  code = re->code;
  *code = OP_BRA;
  bracount = 0;
-Line 1902 
 if (*errorptr != NULL)
+Line 1951 
 if (*errorptr != NULL)
    {
    (pcre_free)(re);
    PCRE_ERROR_RETURN:
-   *erroroffset = ptr - (uschar *)pattern;
+   *erroroffset = ptr - (const uschar *)pattern;
    return NULL;
    }
-Line 1918 
 if ((options & PCRE_ANCHORED) == 0)
+Line 1967 
 if ((options & PCRE_ANCHORED) == 0)
      re->options |= PCRE_ANCHORED;
    else
      {
-     int c = find_firstchar(re->code);
+     int ch = find_firstchar(re->code);
-     if (c >= 0)
+     if (ch >= 0)
        {
-       re->first_char = c;
+       re->first_char = ch;
        re->options |= PCRE_FIRSTSET;
        }
      else if (is_startline(re->code))
-Line 2013 
 while (code < code_end)
+Line 2062 
 while (code < code_end)
      case OP_MINUPTO:
      if (isprint(c = code[3])) printf("    %c{", c);
        else printf("    \\x%02x{", c);
-     if (*code != OP_EXACT) printf(",");
+     if (*code != OP_EXACT) printf("0,");
      printf("%d}", (code[1] << 8) + code[2]);
      if (*code == OP_MINUPTO) printf("?");
      code += 3;
-Line 2058 
 while (code < code_end)
+Line 2107 
 while (code < code_end)
      case OP_REF:
      printf("    \\%d", *(++code));
-     break;
+     code ++;
+     goto CLASS_REF_REPEAT;
      case OP_CLASS:
+     case OP_NEGCLASS:
        {
        int i, min, max;
-       code++;
+       if (*code++ == OP_CLASS) printf("    [");
-       printf("    [");
+         else printf("   ^[");
        for (i = 0; i < 256; i++)
          {
-Line 2088 
 while (code < code_end)
+Line 2139 
 while (code < code_end)
        printf("]");
        code += 32;
+       CLASS_REF_REPEAT:
        switch(*code)
          {
          case OP_CRSTAR:
-Line 2200 
 Returns:      TRUE if matched
+Line 2253 
 Returns:      TRUE if matched
  */
  static BOOL
- match_ref(int number, register uschar *eptr, int length, match_data *md)
+ match_ref(int number, register const uschar *eptr, int length, match_data *md)
  {
- uschar *p = md->start_subject + md->offset_vector[number];
+ const uschar *p = md->start_subject + md->offset_vector[number];
  #ifdef DEBUG
  if (eptr >= md->end_subject)
-Line 2249 
 Returns:       TRUE if matched
+Line 2302 
 Returns:       TRUE if matched
  */
  static BOOL
- match(register uschar *eptr, register uschar *ecode, int offset_top,
+ match(register const uschar *eptr, register const uschar *ecode, int offset_top,
    match_data *md)
  {
  for (;;)
-Line 2257 
 for (;;)
+Line 2310 
 for (;;)
    int min, max, ctype;
    register int i;
    register int c;
-   BOOL minimize;
+   BOOL minimize = FALSE;
    /* Opening bracket. Check the alternative branches in turn, failing if none
    match. We have to set the start offset if required and there is space
-Line 2270 
 for (;;)
+Line 2323 
 for (;;)
    if ((int)*ecode >= OP_BRA)
      {
      int number = (*ecode - OP_BRA) << 1;
-     int save_offset1, save_offset2;
+     int save_offset1 = 0, save_offset2 = 0;
-     #ifdef DEBUG
+     DPRINTF(("start bracket %d\n", number/2));
-     printf("start bracket %d\n", number/2);
-     #endif
      if (number > 0 && number < md->offset_end)
        {
-Line 2282 
 for (;;)
+Line 2333 
 for (;;)
        save_offset2 = md->offset_vector[number+1];
        md->offset_vector[number] = eptr - md->start_subject;
-       #ifdef DEBUG
+       DPRINTF(("saving %d %d\n", save_offset1, save_offset2));
-       printf("saving %d %d\n", save_offset1, save_offset2);
-       #endif
        }
      /* Recurse for all the alternatives. */
-Line 2296 
 for (;;)
+Line 2345 
 for (;;)
        }
      while (*ecode == OP_ALT);
-     #ifdef DEBUG
+     DPRINTF(("bracket %d failed\n", number/2));
-     printf("bracket %d failed\n", number/2);
-     #endif
      if (number > 0 && number < md->offset_end)
        {
-Line 2360 
 for (;;)
+Line 2407 
 for (;;)
      /* "Once" brackets are like assertion brackets except that after a match,
      the point in the subject string is not moved back. Thus there can never be
-     a back into the brackets. Check the alternative branches in turn - the
+     a move back into the brackets. Check the alternative branches in turn - the
      matching won't pass the KET for this kind of subpattern. If any one branch
      matches, we carry on, leaving the subject pointer. */
-Line 2397 
 for (;;)
+Line 2444 
 for (;;)
      case OP_BRAZERO:
        {
-       uschar *next = ecode+1;
+       const uschar *next = ecode+1;
        if (match(eptr, next, offset_top, md)) return TRUE;
        do next += (next[1] << 8) + next[2]; while (*next == OP_ALT);
        ecode = next + 3;
-Line 2406 
 for (;;)
+Line 2453 
 for (;;)
      case OP_BRAMINZERO:
        {
-       uschar *next = ecode+1;
+       const uschar *next = ecode+1;
        do next += (next[1] << 8) + next[2]; while (*next == OP_ALT);
        if (match(eptr, next+3, offset_top, md)) return TRUE;
        ecode++;
-Line 2422 
 for (;;)
+Line 2469 
 for (;;)
      case OP_KETRMAX:
        {
        int number;
-       uschar *prev = ecode - (ecode[1] << 8) - ecode[2];
+       const uschar *prev = ecode - (ecode[1] << 8) - ecode[2];
        if (*prev == OP_ASSERT || *prev == OP_ASSERT_NOT || *prev == OP_ONCE)
          {
-Line 2437 
 for (;;)
+Line 2484 
 for (;;)
        number = (*prev - OP_BRA) << 1;
-       #ifdef DEBUG
+       DPRINTF(("end bracket %d\n", number/2));
-       printf("end bracket %d\n", number/2);
-       #endif
        if (number > 0)
          {
-Line 2671 
 for (;;)
+Line 2716 
 for (;;)
        else
          {
-         uschar *pp = eptr;
+         const uschar *pp = eptr;
          for (i = min; i < max; i++)
            {
            if (!match_ref(number, eptr, length, md)) break;
-Line 2691 
 for (;;)
+Line 2736 
 for (;;)
      item to see if there is repeat information following. Then obey similar
      code to character type repeats - written out again for speed. If caseless
      matching was set at runtime but not at compile time, we have to check both
-     versions of a character. */
+     versions of a character, and we have to behave differently for positive and
+     negative classes. This is the only time where OP_CLASS and OP_NEGCLASS are
+     treated differently. */
      case OP_CLASS:
+     case OP_NEGCLASS:
        {
-       uschar *data = ecode + 1;  /* Save for matching */
+       BOOL nasty_case = *ecode == OP_NEGCLASS && md->runtime_caseless;
-       ecode += 33;               /* Advance past the item */
+       const uschar *data = ecode + 1;  /* Save for matching */
+       ecode += 33;                     /* Advance past the item */
        switch (*ecode)
          {
-Line 2723 
 for (;;)
+Line 2772 
 for (;;)
          break;
          default:               /* No repeat follows */
-         if (eptr >= md->end_subject) return FALSE;
+         min = max = 1;
-         c = *eptr++;
+         break;
-         if ((data[c/8] & (1 << (c&7))) != 0) continue;    /* With main loop */
-         if (md->runtime_caseless)
-           {
-           c = pcre_fcc[c];
-           if ((data[c/8] & (1 << (c&7))) != 0) continue;  /* With main loop */
-           }
-         return FALSE;
          }
        /* First, ensure the minimum number of matches are present. */
-Line 2740 
 for (;;)
+Line 2782 
 for (;;)
          {
          if (eptr >= md->end_subject) return FALSE;
          c = *eptr++;
-         if ((data[c/8] & (1 << (c&7))) != 0) continue;
-         if (md->runtime_caseless)
+         /* Either not runtime caseless, or it was a positive class. For
+         runtime caseless, continue if either case is in the map. */
+         if (!nasty_case)
            {
+           if ((data[c/8] & (1 << (c&7))) != 0) continue;
+           if (md->runtime_caseless)
+             {
+             c = pcre_fcc[c];
+             if ((data[c/8] & (1 << (c&7))) != 0) continue;
+             }
+           }
+         /* Runtime caseless and it was a negative class. Continue only if
+         both cases are in the map. */
+         else
+           {
+           if ((data[c/8] & (1 << (c&7))) == 0) return FALSE;
            c = pcre_fcc[c];
            if ((data[c/8] & (1 << (c&7))) != 0) continue;
            }
          return FALSE;
          }
-Line 2764 
 for (;;)
+Line 2824 
 for (;;)
            if (match(eptr, ecode, offset_top, md)) return TRUE;
            if (i >= max || eptr >= md->end_subject) return FALSE;
            c = *eptr++;
-           if ((data[c/8] & (1 << (c&7))) != 0) continue;
-           if (md->runtime_caseless)
+           /* Either not runtime caseless, or it was a positive class. For
+           runtime caseless, continue if either case is in the map. */
+           if (!nasty_case)
              {
+             if ((data[c/8] & (1 << (c&7))) != 0) continue;
+             if (md->runtime_caseless)
+               {
+               c = pcre_fcc[c];
+               if ((data[c/8] & (1 << (c&7))) != 0) continue;
+               }
+             }
+           /* Runtime caseless and it was a negative class. Continue only if
+           both cases are in the map. */
+           else
+             {
+             if ((data[c/8] & (1 << (c&7))) == 0) return FALSE;
              c = pcre_fcc[c];
              if ((data[c/8] & (1 << (c&7))) != 0) continue;
              }
            return FALSE;
            }
          /* Control never gets here */
-Line 2779 
 for (;;)
+Line 2857 
 for (;;)
        else
          {
-         uschar *pp = eptr;
+         const uschar *pp = eptr;
          for (i = min; i < max; eptr++, i++)
            {
            if (eptr >= md->end_subject) break;
            c = *eptr;
-           if ((data[c/8] & (1 << (c&7))) != 0) continue;
-           if (md->runtime_caseless)
+           /* Either not runtime caseless, or it was a positive class. For
+           runtime caseless, continue if either case is in the map. */
+           if (!nasty_case)
+             {
+             if ((data[c/8] & (1 << (c&7))) != 0) continue;
+             if (md->runtime_caseless)
+               {
+               c = pcre_fcc[c];
+               if ((data[c/8] & (1 << (c&7))) != 0) continue;
+               }
+             }
+           /* Runtime caseless and it was a negative class. Continue only if
+           both cases are in the map. */
+           else
              {
+             if ((data[c/8] & (1 << (c&7))) == 0) break;
              c = pcre_fcc[c];
              if ((data[c/8] & (1 << (c&7))) != 0) continue;
              }
            break;
            }
-Line 2807 
 for (;;)
+Line 2903 
 for (;;)
        register int length = ecode[1];
        ecode += 2;
-       #ifdef DEBUG
+ #ifdef DEBUG    /* Sigh. Some compilers never learn. */
        if (eptr >= md->end_subject)
          printf("matching subject <null> against pattern ");
        else
-Line 2818 
 for (;;)
+Line 2914 
 for (;;)
          }
        pchars(ecode, length, FALSE, md);
        printf("\n");
-       #endif
+ #endif
        if (length > md->end_subject - eptr) return FALSE;
        if (md->caseless)
-Line 2875 
 for (;;)
+Line 2971 
 for (;;)
      maximum. Alternatively, if maximizing, find the maximum number of
      characters and work backwards. */
-     #ifdef DEBUG
+     DPRINTF(("matching %c{%d,%d} against subject %.*s\n", c, min, max,
-     printf("matching %c{%d,%d} against subject %.*s\n", c, min, max,
+       max, eptr));
-       max, eptr);
-     #endif
      if (md->caseless)
        {
-Line 2897 
 for (;;)
+Line 2991 
 for (;;)
          }
        else
          {
-         uschar *pp = eptr;
+         const uschar *pp = eptr;
          for (i = min; i < max; i++)
            {
            if (eptr >= md->end_subject || c != pcre_lcc[*eptr]) break;
-Line 2927 
 for (;;)
+Line 3021 
 for (;;)
          }
        else
          {
-         uschar *pp = eptr;
+         const uschar *pp = eptr;
          for (i = min; i < max; i++)
            {
            if (eptr >= md->end_subject || c != *eptr) break;
-Line 2943 
 for (;;)
+Line 3037 
 for (;;)
      /* Match a negated single character */
      case OP_NOT:
-     if (eptr > md->end_subject) return FALSE;
+     if (eptr >= md->end_subject) return FALSE;
      ecode++;
      if (md->caseless)
        {
-Line 3002 
 for (;;)
+Line 3096 
 for (;;)
      maximum. Alternatively, if maximizing, find the maximum number of
      characters and work backwards. */
-     #ifdef DEBUG
+     DPRINTF(("negative matching %c{%d,%d} against subject %.*s\n", c, min, max,
-     printf("negative matching %c{%d,%d} against subject %.*s\n", c, min, max,
+       max, eptr));
-       max, eptr);
-     #endif
      if (md->caseless)
        {
-Line 3024 
 for (;;)
+Line 3116 
 for (;;)
          }
        else
          {
-         uschar *pp = eptr;
+         const uschar *pp = eptr;
          for (i = min; i < max; i++)
            {
            if (eptr >= md->end_subject || c == pcre_lcc[*eptr]) break;
-Line 3054 
 for (;;)
+Line 3146 
 for (;;)
          }
        else
          {
-         uschar *pp = eptr;
+         const uschar *pp = eptr;
          for (i = min; i < max; i++)
            {
            if (eptr >= md->end_subject || c == *eptr) break;
-Line 3171 
 for (;;)
+Line 3263 
 for (;;)
      else
        {
-       uschar *pp = eptr;
+       const uschar *pp = eptr;
        switch(ctype)
          {
          case OP_ANY:
-Line 3255 
 for (;;)
+Line 3347 
 for (;;)
      /* There's been some horrible disaster. */
      default:
-     #ifdef DEBUG
+     DPRINTF(("Unknown opcode %d\n", *ecode));
-     printf("Unknown opcode %d\n", *ecode);
-     #endif
      md->errorcode = PCRE_ERROR_UNKNOWN_NODE;
      return FALSE;
      }
-Line 3273 
 for (;;)
+Line 3363 
 for (;;)
  /*************************************************
+ *         Segregate setjmp()                     *
+ *************************************************/
+ /* The -Wall option of gcc gives warnings for all local variables when setjmp()
+ is used, even if the coding conforms to the rules of ANSI C. To avoid this, we
+ hide it in a separate function. This is called only when PCRE_EXTRA is set,
+ since it's needed only for the extension \X option, and with any luck, a good
+ compiler will spot the tail recursion and compile it efficiently.
+ Arguments:
+    eptr        pointer in subject
+    ecode       position in code
+    offset_top  current top pointer
+    md          pointer to "static" info for the match
+ Returns:       TRUE if matched
+ */
+ static BOOL
+ match_with_setjmp(const uschar *eptr, const uschar *ecode, int offset_top,
+   match_data *match_block)
+ {
+ return setjmp(match_block->fail_env) == 0 &&
+       match(eptr, ecode, offset_top, match_block);
+ }
+ /*************************************************
  *         Execute a Regular Expression           *
  *************************************************/
-Line 3299 
 int
+Line 3418 
 int
  pcre_exec(const pcre *external_re, const pcre_extra *external_extra,
    const char *subject, int length, int options, int *offsets, int offsetcount)
  {
- int resetcount;
+ int resetcount, ocount;
- int ocount = offsetcount;
  int first_char = -1;
  match_data match_block;
- uschar *start_bits = NULL;
+ const uschar *start_bits = NULL;
- uschar *start_match = (uschar *)subject;
+ const uschar *start_match = (const uschar *)subject;
- uschar *end_subject;
+ const uschar *end_subject;
- real_pcre *re = (real_pcre *)external_re;
+ const real_pcre *re = (const real_pcre *)external_re;
- real_pcre_extra *extra = (real_pcre_extra *)external_extra;
+ const real_pcre_extra *extra = (const real_pcre_extra *)external_extra;
+ BOOL using_temporary_offsets = FALSE;
  BOOL anchored = ((re->options | options) & PCRE_ANCHORED) != 0;
  BOOL startline = (re->options & PCRE_STARTLINE) != 0;
-Line 3317 
 if (re == NULL || subject == NULL ||
+Line 3436 
 if (re == NULL || subject == NULL ||
     (offsets == NULL && offsetcount > 0)) return PCRE_ERROR_NULL;
  if (re->magic_number != MAGIC_NUMBER) return PCRE_ERROR_BADMAGIC;
- match_block.start_subject = (uschar *)subject;
+ match_block.start_subject = (const uschar *)subject;
  match_block.end_subject = match_block.start_subject + length;
  end_subject = match_block.end_subject;
-Line 3336 
 match_block.errorcode = PCRE_ERROR_NOMAT
+Line 3455 
 match_block.errorcode = PCRE_ERROR_NOMAT
  /* If the expression has got more back references than the offsets supplied can
  hold, we get a temporary bit of working store to use during the matching.
- Otherwise, we can use the vector supplied, rounding down the size of it to a
+ Otherwise, we can use the vector supplied, rounding down its size to a multiple
- multiple of 2. */
+ of 2. */
- ocount &= (-2);
+ ocount = offsetcount & (-2);
- if (re->top_backref > 0 && re->top_backref + 1 >= ocount/2)
+ if (re->top_backref > 0 && re->top_backref >= ocount/2)
    {
    ocount = re->top_backref * 2 + 2;
-   match_block.offset_vector = (pcre_malloc)(ocount * sizeof(int));
+   match_block.offset_vector = (int *)(pcre_malloc)(ocount * sizeof(int));
    if (match_block.offset_vector == NULL) return PCRE_ERROR_NOMEMORY;
-   #ifdef DEBUG
+   using_temporary_offsets = TRUE;
-   printf("Got memory to hold back references\n");
+   DPRINTF(("Got memory to hold back references\n"));
-   #endif
    }
  else match_block.offset_vector = offsets;
-Line 3400 
 if (!anchored)
+Line 3518 
 if (!anchored)
  do
    {
+   int rc;
    register int *iptr = match_block.offset_vector;
    register int *iend = iptr + resetcount;
-Line 3441 
 do
+Line 3560 
 do
        }
      }
-   #ifdef DEBUG
+ #ifdef DEBUG  /* Sigh. Some compilers never learn. */
    printf(">>>> Match against: ");
    pchars(start_match, end_subject - start_match, TRUE, &match_block);
    printf("\n");
-   #endif
+ #endif
    /* When a match occurs, substrings will be set for all internal extractions;
    we just need to set up the whole thing as substring 0 before returning. If
-Line 3455 
 do
+Line 3574 
 do
    if certain parts of the pattern were not used.
    Before starting the match, we have to set up a longjmp() target to enable
-   the "cut" operation to fail a match completely without backtracking. */
+   the "cut" operation to fail a match completely without backtracking. This
+   is done in a separate function to avoid compiler warnings. We need not do
+   it unless PCRE_EXTRA is set, since only in that case is the "cut" operation
+   enabled. */
-   if (setjmp(match_block.fail_env) == 0 &&
+   if ((re->options & PCRE_EXTRA) != 0)
-       match(start_match, re->code, 2, &match_block))
      {
-     int rc;
+     if (!match_with_setjmp(start_match, re->code, 2, &match_block))
+       continue;
-     if (ocount != offsetcount)
+     }
-       {
+   else if (!match(start_match, re->code, 2, &match_block)) continue;
-       if (offsetcount >= 4)
-         {
-         memcpy(offsets + 2, match_block.offset_vector + 2,
-           (offsetcount - 2) * sizeof(int));
-         #ifdef DEBUG
-         printf("Copied offsets; freeing temporary memory\n");
-         #endif
-         }
-       if (match_block.end_offset_top > offsetcount)
-         match_block.offset_overflow = TRUE;
-       #ifdef DEBUG
+   /* Copy the offset information from temporary store if necessary */
-       printf("Freeing temporary memory\n");
-       #endif
-       (pcre_free)(match_block.offset_vector);
+   if (using_temporary_offsets)
+     {
+     if (offsetcount >= 4)
+       {
+       memcpy(offsets + 2, match_block.offset_vector + 2,
+         (offsetcount - 2) * sizeof(int));
+       DPRINTF(("Copied offsets from temporary memory\n"));
        }
+     if (match_block.end_offset_top > offsetcount)
+       match_block.offset_overflow = TRUE;
-     rc = match_block.offset_overflow? 0 : match_block.end_offset_top/2;
+     DPRINTF(("Freeing temporary memory\n"));
+     (pcre_free)(match_block.offset_vector);
+     }
-     if (match_block.offset_end < 2) rc = 0; else
+   rc = match_block.offset_overflow? 0 : match_block.end_offset_top/2;
-       {
-       offsets[0] = start_match - match_block.start_subject;
-       offsets[1] = match_block.end_match_ptr - match_block.start_subject;
-       }
-     #ifdef DEBUG
+   if (match_block.offset_end < 2) rc = 0; else
-     printf(">>>> returning %d\n", rc);
+     {
-     #endif
+     offsets[0] = start_match - match_block.start_subject;
-     return rc;
+     offsets[1] = match_block.end_match_ptr - match_block.start_subject;
      }
+   DPRINTF((">>>> returning %d\n", rc));
+   return rc;
    }
  while (!anchored &&
         match_block.errorcode == PCRE_ERROR_NOMATCH &&
         start_match++ < end_subject);
- #ifdef DEBUG
+ if (using_temporary_offsets)
- printf(">>>> returning %d\n", match_block.errorcode);
+   {
- #endif
+   DPRINTF(("Freeing temporary memory\n"));
+   (pcre_free)(match_block.offset_vector);
+   }
+ DPRINTF((">>>> returning %d\n", match_block.errorcode));
  return match_block.errorcode;
  }

 Legend:



Removed from v.3
 


changed lines


 
Added in v.17
 Legend:



Removed from v.3
 


changed lines


 
Added in v.17
-Removed from v.3
+Added in v.17

	ViewVC Help
Powered by ViewVC 1.1.5