/[pcre]/code/tags/pcre-2.02/pcre.c

Diff of /code/tags/pcre-2.02/pcre.c

Parent Directory | Revision Log | View Patch Patch

-revision 5 by nigel,
Sat Feb 24 21:38:05 2007 UTC
+revision 9 by nigel,
Sat Feb 24 21:38:13 2007 UTC
 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 48 
 static char rep_max[] = { 0, 0, 0, 0, 1,
+Line 57 
 static char rep_max[] = { 0, 0, 0, 0, 1,
  /* Text forms of OP_ values and things, for debugging */
  #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",
    "*", "*?", "+", "+?", "?", "??", "{", "{", "{",
-Line 81 
 static short int escapes[] = {
+Line 91 
 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 108 
 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 136 
 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 166 
 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 196 
 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 360 
 Returns:     zero or positive => a data
+Line 371 
 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 382 
 else if ((i = escapes[c - '0']) != 0) c
+Line 393 
 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 502 
 Returns:    TRUE or FALSE
+Line 513 
 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 537 
 Returns:     pointer to '}' on success;
+Line 548 
 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 592 
 Returns:     TRUE on success
+Line 603 
 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 697 
 for (;; ptr++)
+Line 708 
 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 976 
 for (;; ptr++)
+Line 987 
 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 1022 
 for (;; ptr++)
+Line 1041 
 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 1039 
 for (;; ptr++)
+Line 1058 
 for (;; ptr++)
          {
          for (i = 1; i < repeat_min; i++)
            {
-           memcpy(code, previous, length);
+           memcpy(code, previous, len);
-           code += length;
+           code += len;
            }
          }
-Line 1052 
 for (;; ptr++)
+Line 1071 
 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 1214 
 for (;; ptr++)
+Line 1233 
 for (;; ptr++)
        continue;
        }
-     /* Reset and fall through */
+     /* Data character: reset and fall through */
      ptr = oldptr;
      c = '\\';
-Line 1305 
 Returns:    TRUE on success
+Line 1324 
 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 1374 
 Returns:   TRUE or FALSE
+Line 1393 
 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 1403 
 Returns:   TRUE or FALSE
+Line 1422 
 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 1488 
 Returns:       pointer to compiled data
+Line 1507 
 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 1498 
 int runlength;
+Line 1517 
 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 1527 
 if ((options & ~PUBLIC_OPTIONS) != 0)
+Line 1547 
 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 1539 
 internal flag settings. Make an attempt
+Line 1557 
 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 1566 
 while ((c = *(++ptr)) != 0)
+Line 1584 
 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 1645 
 while ((c = *(++ptr)) != 0)
+Line 1663 
 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 1662 
 while ((c = *(++ptr)) != 0)
+Line 1680 
 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 1770 
 while ((c = *(++ptr)) != 0)
+Line 1788 
 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 1831 
 while ((c = *(++ptr)) != 0)
+Line 1850 
 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 1861 
 if (length > 65539)
+Line 1880 
 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 1872 
 if (re == NULL)
+Line 1894 
 if (re == NULL)
    return NULL;
    }
+ /* Put in the magic number and the options. */
  re->magic_number = MAGIC_NUMBER;
  re->options = options;
-Line 1879 
 re->options = options;
+Line 1903 
 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 1906 
 if (*errorptr != NULL)
+Line 1930 
 if (*errorptr != NULL)
    {
    (pcre_free)(re);
    PCRE_ERROR_RETURN:
-   *erroroffset = ptr - (uschar *)pattern;
+   *erroroffset = ptr - (const uschar *)pattern;
    return NULL;
    }
-Line 1922 
 if ((options & PCRE_ANCHORED) == 0)
+Line 1946 
 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 2062 
 while (code < code_end)
+Line 2086 
 while (code < code_end)
      case OP_REF:
      printf("    \\%d", *(++code));
-     break;
+     code ++;
+     goto CLASS_REF_REPEAT;
      case OP_CLASS:
        {
-Line 2092 
 while (code < code_end)
+Line 2117 
 while (code < code_end)
        printf("]");
        code += 32;
+       CLASS_REF_REPEAT:
        switch(*code)
          {
          case OP_CRSTAR:
-Line 2204 
 Returns:      TRUE if matched
+Line 2231 
 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 2253 
 Returns:       TRUE if matched
+Line 2280 
 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 2261 
 for (;;)
+Line 2288 
 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 2274 
 for (;;)
+Line 2301 
 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 2286 
 for (;;)
+Line 2311 
 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 2300 
 for (;;)
+Line 2323 
 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 2401 
 for (;;)
+Line 2422 
 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 2410 
 for (;;)
+Line 2431 
 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 2426 
 for (;;)
+Line 2447 
 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 2441 
 for (;;)
+Line 2462 
 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 2675 
 for (;;)
+Line 2694 
 for (;;)
        else
          {
-         uschar *pp = eptr;
+         const uschar *pp = eptr;
          for (i = min; i < max; i++)
            {
            if (!match_ref(number, eptr, length, md)) break;
-Line 2699 
 for (;;)
+Line 2718 
 for (;;)
      case OP_CLASS:
        {
-       uschar *data = ecode + 1;  /* Save for matching */
+       const uschar *data = ecode + 1;  /* Save for matching */
-       ecode += 33;               /* Advance past the item */
+       ecode += 33;                     /* Advance past the item */
        switch (*ecode)
          {
-Line 2783 
 for (;;)
+Line 2802 
 for (;;)
        else
          {
-         uschar *pp = eptr;
+         const uschar *pp = eptr;
          for (i = min; i < max; eptr++, i++)
            {
            if (eptr >= md->end_subject) break;
-Line 2811 
 for (;;)
+Line 2830 
 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 2822 
 for (;;)
+Line 2841 
 for (;;)
          }
        pchars(ecode, length, FALSE, md);
        printf("\n");
-       #endif
+ #endif
        if (length > md->end_subject - eptr) return FALSE;
        if (md->caseless)
-Line 2879 
 for (;;)
+Line 2898 
 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 2901 
 for (;;)
+Line 2918 
 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 2931 
 for (;;)
+Line 2948 
 for (;;)
          }
        else
          {
-         uschar *pp = eptr;
+         const uschar *pp = eptr;
          for (i = min; i < max; i++)
            {
            if (eptr >= md->end_subject || c != *eptr) break;
-Line 2947 
 for (;;)
+Line 2964 
 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 3006 
 for (;;)
+Line 3023 
 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 3028 
 for (;;)
+Line 3043 
 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 3058 
 for (;;)
+Line 3073 
 for (;;)
          }
        else
          {
-         uschar *pp = eptr;
+         const uschar *pp = eptr;
          for (i = min; i < max; i++)
            {
            if (eptr >= md->end_subject || c == *eptr) break;
-Line 3175 
 for (;;)
+Line 3190 
 for (;;)
      else
        {
-       uschar *pp = eptr;
+       const uschar *pp = eptr;
        switch(ctype)
          {
          case OP_ANY:
-Line 3259 
 for (;;)
+Line 3274 
 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 3277 
 for (;;)
+Line 3290 
 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:    The block containing the match data
+ Returns:      The return from setjump()
+ */
+ static int
+ my_setjmp(match_data *match_block)
+ {
+ return setjmp(match_block->fail_env);
+ }
+ /*************************************************
  *         Execute a Regular Expression           *
  *************************************************/
-Line 3307 
 int resetcount;
+Line 3342 
 int resetcount;
  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 anchored = ((re->options | options) & PCRE_ANCHORED) != 0;
  BOOL startline = (re->options & PCRE_STARTLINE) != 0;
-Line 3321 
 if (re == NULL || subject == NULL ||
+Line 3356 
 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 3349 
 if (re->top_backref > 0 && re->top_backr
+Line 3384 
 if (re->top_backref > 0 && re->top_backr
    ocount = re->top_backref * 2 + 2;
    match_block.offset_vector = (pcre_malloc)(ocount * sizeof(int));
    if (match_block.offset_vector == NULL) return PCRE_ERROR_NOMEMORY;
-   #ifdef DEBUG
+   DPRINTF(("Got memory to hold back references\n"));
-   printf("Got memory to hold back references\n");
-   #endif
    }
  else match_block.offset_vector = offsets;
-Line 3404 
 if (!anchored)
+Line 3437 
 if (!anchored)
  do
    {
+   int rc;
    register int *iptr = match_block.offset_vector;
    register int *iend = iptr + resetcount;
-Line 3445 
 do
+Line 3479 
 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 3459 
 do
+Line 3493 
 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
-   if (setjmp(match_block.fail_env) == 0 &&
+   it unless PCRE_EXTRA is set, since only in that case is the "cut" operation
-       match(start_match, re->code, 2, &match_block))
+   enabled. */
-     {
-     int rc;
-     if (ocount != offsetcount)
+   if (((re->options & PCRE_EXTRA) != 0 && my_setjmp(&match_block) != 0) ||
-       {
+       !match(start_match, re->code, 2, &match_block))
-       if (offsetcount >= 4)
+     continue;
-         {
-         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 (ocount != offsetcount)
+     {
+     if (offsetcount >= 4)
+       {
+       memcpy(offsets + 2, match_block.offset_vector + 2,
+         (offsetcount - 2) * sizeof(int));
+       DPRINTF(("Copied offsets; freeing 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
+ DPRINTF((">>>> returning %d\n", match_block.errorcode));
- printf(">>>> returning %d\n", match_block.errorcode);
- #endif
  return match_block.errorcode;
  }

 Legend:



Removed from v.5
 


changed lines


 
Added in v.9
 Legend:



Removed from v.5
 


changed lines


 
Added in v.9
-Removed from v.5
+Added in v.9

	ViewVC Help
Powered by ViewVC 1.1.5