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

Diff of /code/trunk/pcre_exec.c

Parent Directory | Revision Log | View Patch Patch

-revision 91 by nigel,
Sat Feb 24 21:41:34 2007 UTC
+revision 115 by ph10,
Fri Mar  9 12:23:37 2007 UTC
 Line 42 
 POSSIBILITY OF SUCH DAMAGE.
  pattern matching using an NFA algorithm, trying to mimic Perl as closely as
  possible. There are also some static supporting functions. */
- #define NLBLOCK md           /* The block containing newline information */
+ #define NLBLOCK md             /* Block containing newline information */
+ #define PSSTART start_subject  /* Field containing processed string start */
+ #define PSEND   end_subject    /* Field containing processed string end */
  #include "pcre_internal.h"
+ /* The chain of eptrblocks for tail recursions uses memory in stack workspace,
+ obtained at top level, the size of which is defined by EPTR_WORK_SIZE. */
- /* Structure for building a chain of data that actually lives on the
+ #define EPTR_WORK_SIZE (1000)
- stack, for holding the values of the subject pointer at the start of each
- subpattern, so as to detect when an empty string has been matched by a
- subpattern - to break infinite loops. When NO_RECURSE is set, these blocks
- are on the heap, not on the stack. */
- typedef struct eptrblock {
-   struct eptrblock *epb_prev;
-   USPTR epb_saved_eptr;
- } eptrblock;
  /* Flag bits for the match() function */
- #define match_condassert   0x01    /* Called to check a condition assertion */
+ #define match_condassert     0x01  /* Called to check a condition assertion */
- #define match_isgroup      0x02    /* Set if start of bracketed group */
+ #define match_cbegroup       0x02  /* Could-be-empty unlimited repeat group */
+ #define match_tail_recursed  0x04  /* Tail recursive call */
  /* Non-error returns from the match() function. Error returns are externally
  defined PCRE_ERROR_xxx codes, which are all negative. */
-Line 101 
 Returns:     nothing
+Line 98 
 Returns:     nothing
  static void
  pchars(const uschar *p, int length, BOOL is_subject, match_data *md)
  {
- int c;
+ unsigned int c;
  if (is_subject && length > md->end_subject - p) length = md->end_subject - p;
  while (length-- > 0)
    if (isprint(c = *(p++))) printf("%c", c); else printf("\\x%02x", c);
-Line 291 
 typedef struct heapframe {
+Line 288 
 typedef struct heapframe {
    BOOL Xcur_is_word;
    BOOL Xcondition;
-   BOOL Xminimize;
    BOOL Xprev_is_word;
    unsigned long int Xoriginal_ims;
-Line 303 
 typedef struct heapframe {
+Line 299 
 typedef struct heapframe {
    int Xprop_category;
    int Xprop_chartype;
    int Xprop_script;
-   int *Xprop_test_variable;
+   int Xoclength;
+   uschar Xocchars[8];
  #endif
    int Xctype;
-   int Xfc;
+   unsigned int Xfc;
    int Xfi;
    int Xlength;
    int Xmax;
-Line 340 
 typedef struct heapframe {
+Line 337 
 typedef struct heapframe {
  *         Match from current position            *
  *************************************************/
- /* On entry ecode points to the first opcode, and eptr to the first character
+ /* This function is called recursively in many circumstances. Whenever it
- in the subject string, while eptrb holds the value of eptr at the start of the
- last bracketed group - used for breaking infinite loops matching zero-length
- strings. This function is called recursively in many circumstances. Whenever it
  returns a negative (error) response, the outer incarnation must also return the
  same response.
-Line 353 
 performance. Tests using gcc on a SPARC
+Line 347 
 performance. Tests using gcc on a SPARC
  made performance worse.
  Arguments:
-    eptr        pointer in subject
+    eptr        pointer to current character in subject
-    ecode       position in code
+    ecode       pointer to current position in compiled code
     offset_top  current top pointer
     md          pointer to "static" info for the match
     ims         current /i, /m, and /s options
-Line 362 
 Arguments:
+Line 356 
 Arguments:
                   brackets - for testing for empty matches
     flags       can contain
                   match_condassert - this is an assertion condition
-                  match_isgroup - this is the start of a bracketed group
+                  match_cbegroup - this is the start of an unlimited repeat
+                    group that can match an empty string
+                  match_tail_recursed - this is a tail_recursed group
     rdepth      the recursion depth
  Returns:       MATCH_MATCH if matched            )  these values are >= 0
-Line 377 
 match(REGISTER USPTR eptr, REGISTER cons
+Line 373 
 match(REGISTER USPTR eptr, REGISTER cons
    int flags, unsigned int rdepth)
  {
  /* These variables do not need to be preserved over recursion in this function,
- so they can be ordinary variables in all cases. Mark them with "register"
+ so they can be ordinary variables in all cases. Mark some of them with
- because they are used a lot in loops. */
+ "register" because they are used a lot in loops. */
  register int  rrc;         /* Returns from recursive calls */
  register int  i;           /* Used for loops not involving calls to RMATCH() */
- register unsigned int  c;  /* Character values not kept over RMATCH() calls */
+ register unsigned int c;   /* Character values not kept over RMATCH() calls */
  register BOOL utf8;        /* Local copy of UTF-8 flag for speed */
+ BOOL minimize, possessive; /* Quantifier options */
  /* When recursion is not being used, all "local" variables that have to be
  preserved over calls to RMATCH() are part of a "frame" which is obtained from
  heap storage. Set up the top-level frame here; others are obtained from the
-Line 434 
 HEAP_RECURSE:
+Line 432 
 HEAP_RECURSE:
  #define cur_is_word        frame->Xcur_is_word
  #define condition          frame->Xcondition
- #define minimize           frame->Xminimize
  #define prev_is_word       frame->Xprev_is_word
  #define original_ims       frame->Xoriginal_ims
-Line 446 
 HEAP_RECURSE:
+Line 443 
 HEAP_RECURSE:
  #define prop_category      frame->Xprop_category
  #define prop_chartype      frame->Xprop_chartype
  #define prop_script        frame->Xprop_script
- #define prop_test_variable frame->Xprop_test_variable
+ #define oclength           frame->Xoclength
+ #define occhars            frame->Xocchars
  #endif
  #define ctype              frame->Xctype
-Line 470 
 HEAP_RECURSE:
+Line 468 
 HEAP_RECURSE:
  get preserved during recursion in the normal way. In this environment, fi and
  i, and fc and c, can be the same variables. */
- #else
+ #else         /* NO_RECURSE not defined */
  #define fi i
  #define fc c
-Line 489 
 recursion_info new_recursive;      /* wi
+Line 487 
 recursion_info new_recursive;      /* wi
                                     /* that do not have to be preserved over  */
  BOOL cur_is_word;                  /* a recursive call to RMATCH().          */
  BOOL condition;
- BOOL minimize;
  BOOL prev_is_word;
  unsigned long int original_ims;
-Line 501 
 int prop_fail_result;
+Line 498 
 int prop_fail_result;
  int prop_category;
  int prop_chartype;
  int prop_script;
- int *prop_test_variable;
+ int oclength;
+ uschar occhars[8];
  #endif
  int ctype;
-Line 516 
 int save_offset1, save_offset2, save_off
+Line 514 
 int save_offset1, save_offset2, save_off
  int stacksave[REC_STACK_SAVE_MAX];
  eptrblock newptrb;
- #endif
+ #endif     /* NO_RECURSE */
  /* These statements are here to stop the compiler complaining about unitialized
  variables. */
-Line 524 
 variables. */
+Line 522 
 variables. */
  #ifdef SUPPORT_UCP
  prop_value = 0;
  prop_fail_result = 0;
- prop_test_variable = NULL;
  #endif
  /* This label is used for tail recursion, which is used in a few cases even
  when NO_RECURSE is not defined, in order to reduce the amount of stack that is
  used. Thanks to Ian Taylor for noticing this possibility and sending the
-Line 556 
 utf8 = md->utf8;       /* Local copy of
+Line 554 
 utf8 = md->utf8;       /* Local copy of
  utf8 = FALSE;
  #endif
- /* At the start of a bracketed group, add the current subject pointer to the
+ /* At the start of a group with an unlimited repeat that may match an empty
- stack of such pointers, to be re-instated at the end of the group when we hit
+ string, the match_cbegroup flag is set. When this is the case, add the current
- the closing ket. When match() is called in other circumstances, we don't add to
+ subject pointer to the chain of such remembered pointers, to be checked when we
- this stack. */
+ hit the closing ket, in order to break infinite loops that match no characters.
+ When match() is called in other circumstances, don't add to the chain. If this
+ is a tail recursion, use a block from the workspace, as the one on the stack is
+ already used. */
- if ((flags & match_isgroup) != 0)
+ if ((flags & match_cbegroup) != 0)
    {
-   newptrb.epb_prev = eptrb;
+   eptrblock *p;
-   newptrb.epb_saved_eptr = eptr;
+   if ((flags & match_tail_recursed) != 0)
-   eptrb = &newptrb;
+     {
+     if (md->eptrn >= EPTR_WORK_SIZE) RRETURN(PCRE_ERROR_NULLWSLIMIT);
+     p = md->eptrchain + md->eptrn++;
+     }
+   else p = &newptrb;
+   p->epb_saved_eptr = eptr;
+   p->epb_prev = eptrb;
+   eptrb = p;
    }
- /* Now start processing the operations. */
+ /* Now start processing the opcodes. */
  for (;;)
    {
+   minimize = possessive = FALSE;
    op = *ecode;
-   minimize = FALSE;
    /* For partial matching, remember if we ever hit the end of the subject after
    matching at least one subject character. */
-Line 583 
 for (;;)
+Line 591 
 for (;;)
        eptr > md->start_match)
      md->hitend = TRUE;
-   /* Opening capturing bracket. If there is space in the offset vector, save
+   switch(op)
-   the current subject position in the working slot at the top of the vector. We
-   mustn't change the current values of the data slot, because they may be set
-   from a previous iteration of this group, and be referred to by a reference
-   inside the group.
-   If the bracket fails to match, we need to restore this value and also the
-   values of the final offsets, in case they were set by a previous iteration of
-   the same bracket.
-   If there isn't enough space in the offset vector, treat this as if it were a
-   non-capturing bracket. Don't worry about setting the flag for the error case
-   here; that is handled in the code for KET. */
-   if (op > OP_BRA)
      {
-     number = op - OP_BRA;
+     /* Handle a capturing bracket. If there is space in the offset vector, save
+     the current subject position in the working slot at the top of the vector.
-     /* For extended extraction brackets (large number), we have to fish out the
+     We mustn't change the current values of the data slot, because they may be
-     number from a dummy opcode at the start. */
+     set from a previous iteration of this group, and be referred to by a
+     reference inside the group.
-     if (number > EXTRACT_BASIC_MAX)
-       number = GET2(ecode, 2+LINK_SIZE);
+     If the bracket fails to match, we need to restore this value and also the
+     values of the final offsets, in case they were set by a previous iteration
+     of the same bracket.
+     If there isn't enough space in the offset vector, treat this as if it were
+     a non-capturing bracket. Don't worry about setting the flag for the error
+     case here; that is handled in the code for KET. */
+     case OP_CBRA:
+     case OP_SCBRA:
+     number = GET2(ecode, 1+LINK_SIZE);
      offset = number << 1;
  #ifdef DEBUG
-     printf("start bracket %d subject=", number);
+     printf("start bracket %d\n", number);
+     printf("subject=");
      pchars(eptr, 16, TRUE, md);
      printf("\n");
  #endif
-Line 624 
 for (;;)
+Line 629 
 for (;;)
        DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));
        md->offset_vector[md->offset_end - number] = eptr - md->start_subject;
+       flags = (op == OP_SCBRA)? match_cbegroup : 0;
        do
          {
-         RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb,
+         RMATCH(rrc, eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
-           match_isgroup);
+           ims, eptrb, flags);
          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
          md->capture_last = save_capture_last;
          ecode += GET(ecode, 1);
-Line 643 
 for (;;)
+Line 649 
 for (;;)
        RRETURN(MATCH_NOMATCH);
        }
-     /* Insufficient room for saving captured contents */
+     /* Insufficient room for saving captured contents. Treat as a non-capturing
+     bracket. */
-     else op = OP_BRA;
-     }
-   /* Other types of node can be handled by a switch */
-   switch(op)
+     DPRINTF(("insufficient capture room: treat as non-capturing\n"));
-     {
-     case OP_BRA:     /* Non-capturing bracket: optimized */
-     DPRINTF(("start bracket 0\n"));
-     /* Loop for all the alternatives */
+     /* Non-capturing bracket. Loop for all the alternatives. When we get to the
+     final alternative within the brackets, we would return the result of a
+     recursive call to match() whatever happened. We can reduce stack usage by
+     turning this into a tail recursion. */
+     case OP_BRA:
+     case OP_SBRA:
+     DPRINTF(("start non-capturing bracket\n"));
+     flags = (op >= OP_SBRA)? match_cbegroup : 0;
      for (;;)
        {
-       /* When we get to the final alternative within the brackets, we would
-       return the result of a recursive call to match() whatever happened. We
-       can reduce stack usage by turning this into a tail recursion. */
        if (ecode[GET(ecode, 1)] != OP_ALT)
-        {
+         {
-        ecode += 1 + LINK_SIZE;
+         ecode += _pcre_OP_lengths[*ecode];
-        flags = match_isgroup;
+         flags |= match_tail_recursed;
-        DPRINTF(("bracket 0 tail recursion\n"));
+         DPRINTF(("bracket 0 tail recursion\n"));
-        goto TAIL_RECURSE;
+         goto TAIL_RECURSE;
-        }
+         }
        /* For non-final alternatives, continue the loop for a NOMATCH result;
        otherwise return. */
-       RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb,
+       RMATCH(rrc, eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,
-         match_isgroup);
+         eptrb, flags);
        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
        ecode += GET(ecode, 1);
        }
-Line 688 
 for (;;)
+Line 690 
 for (;;)
      obeyed, we can use tail recursion to avoid using another stack frame. */
      case OP_COND:
-     if (ecode[LINK_SIZE+1] == OP_CREF) /* Condition extract or recurse test */
+     case OP_SCOND:
+     if (ecode[LINK_SIZE+1] == OP_RREF)         /* Recursion test */
+       {
+       offset = GET2(ecode, LINK_SIZE + 2);     /* Recursion group number*/
+       condition = md->recursive != NULL &&
+         (offset == RREF_ANY || offset == md->recursive->group_num);
+       ecode += condition? 3 : GET(ecode, 1);
+       }
+     else if (ecode[LINK_SIZE+1] == OP_CREF)    /* Group used test */
        {
        offset = GET2(ecode, LINK_SIZE+2) << 1;  /* Doubled ref number */
-       condition = (offset == CREF_RECURSE * 2)?
+       condition = offset < offset_top && md->offset_vector[offset] >= 0;
-         (md->recursive != NULL) :
+       ecode += condition? 3 : GET(ecode, 1);
-         (offset < offset_top && md->offset_vector[offset] >= 0);
+       }
-       ecode += condition? (LINK_SIZE + 4) : (LINK_SIZE + 1 + GET(ecode, 1));
-       flags = match_isgroup;
+     else if (ecode[LINK_SIZE+1] == OP_DEF)     /* DEFINE - always false */
-       goto TAIL_RECURSE;
+       {
+       condition = FALSE;
+       ecode += GET(ecode, 1);
        }
      /* The condition is an assertion. Call match() to evaluate it - setting
-     the final argument TRUE causes it to stop at the end of an assertion. */
+     the final argument match_condassert causes it to stop at the end of an
+     assertion. */
      else
        {
        RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL,
-           match_condassert | match_isgroup);
+           match_condassert);
        if (rrc == MATCH_MATCH)
          {
-         ecode += 1 + LINK_SIZE + GET(ecode, LINK_SIZE+2);
+         condition = TRUE;
+         ecode += 1 + LINK_SIZE + GET(ecode, LINK_SIZE + 2);
          while (*ecode == OP_ALT) ecode += GET(ecode, 1);
          }
        else if (rrc != MATCH_NOMATCH)
          {
          RRETURN(rrc);         /* Need braces because of following else */
          }
-       else ecode += GET(ecode, 1);
+       else
+         {
+         condition = FALSE;
+         ecode += GET(ecode, 1);
+         }
+       }
-       /* We are now at the branch that is to be obeyed. As there is only one,
+     /* We are now at the branch that is to be obeyed. As there is only one,
-       we can use tail recursion to avoid using another stack frame. */
+     we can use tail recursion to avoid using another stack frame. If the second
+     alternative doesn't exist, we can just plough on. */
+     if (condition || *ecode == OP_ALT)
+       {
        ecode += 1 + LINK_SIZE;
-       flags = match_isgroup;
+       flags = match_tail_recursed | ((op == OP_SCOND)? match_cbegroup : 0);
        goto TAIL_RECURSE;
        }
-     /* Control never reaches here */
+     else
+       {
-     /* Skip over conditional reference or large extraction number data if
+       ecode += 1 + LINK_SIZE;
-     encountered. */
+       }
-     case OP_CREF:
-     case OP_BRANUMBER:
-     ecode += 3;
      break;
-     /* End of the pattern. If we are in a recursion, we should restore the
-     offsets appropriately and continue from after the call. */
+     /* End of the pattern. If we are in a top-level recursion, we should
+     restore the offsets appropriately and continue from after the call. */
      case OP_END:
      if (md->recursive != NULL && md->recursive->group_num == 0)
-Line 777 
 for (;;)
+Line 797 
 for (;;)
      case OP_ASSERTBACK:
      do
        {
-       RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL,
+       RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0);
-         match_isgroup);
        if (rrc == MATCH_MATCH) break;
        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
        ecode += GET(ecode, 1);
-Line 804 
 for (;;)
+Line 823 
 for (;;)
      case OP_ASSERTBACK_NOT:
      do
        {
-       RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL,
+       RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0);
-         match_isgroup);
        if (rrc == MATCH_MATCH) RRETURN(MATCH_NOMATCH);
        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
        ecode += GET(ecode,1);
-Line 826 
 for (;;)
+Line 844 
 for (;;)
  #ifdef SUPPORT_UTF8
      if (utf8)
        {
-       c = GET(ecode,1);
+       i = GET(ecode, 1);
-       for (i = 0; i < c; i++)
+       while (i-- > 0)
          {
          eptr--;
          if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);
-Line 840 
 for (;;)
+Line 858 
 for (;;)
      /* No UTF-8 support, or not in UTF-8 mode: count is byte count */
        {
-       eptr -= GET(ecode,1);
+       eptr -= GET(ecode, 1);
        if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);
        }
-Line 897 
 for (;;)
+Line 915 
 for (;;)
      case OP_RECURSE:
        {
        callpat = md->start_code + GET(ecode, 1);
-       new_recursive.group_num = *callpat - OP_BRA;
+       new_recursive.group_num = (callpat == md->start_code)? 0 :
+         GET2(callpat, 1 + LINK_SIZE);
-       /* For extended extraction brackets (large number), we have to fish out
-       the number from a dummy opcode at the start. */
-       if (new_recursive.group_num > EXTRACT_BASIC_MAX)
-         new_recursive.group_num = GET2(callpat, 2+LINK_SIZE);
        /* Add to "recursing stack" */
-Line 936 
 for (;;)
+Line 949 
 for (;;)
        restore the offset and recursion data. */
        DPRINTF(("Recursing into group %d\n", new_recursive.group_num));
+       flags = (*callpat >= OP_SBRA)? match_cbegroup : 0;
        do
          {
-         RMATCH(rrc, eptr, callpat + 1 + LINK_SIZE, offset_top, md, ims,
+         RMATCH(rrc, eptr, callpat + _pcre_OP_lengths[*callpat], offset_top,
-             eptrb, match_isgroup);
+           md, ims, eptrb, flags);
          if (rrc == MATCH_MATCH)
            {
            DPRINTF(("Recursion matched\n"));
-Line 983 
 for (;;)
+Line 997 
 for (;;)
      do
        {
        RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims,
-         eptrb, match_isgroup);
+         eptrb, 0);
        if (rrc == MATCH_MATCH) break;
        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
        ecode += GET(ecode,1);
-Line 997 
 for (;;)
+Line 1011 
 for (;;)
      /* Continue as from after the assertion, updating the offsets high water
      mark, since extracts may have been taken. */
-     do ecode += GET(ecode,1); while (*ecode == OP_ALT);
+     do ecode += GET(ecode, 1); while (*ecode == OP_ALT);
      offset_top = md->end_offset_top;
      eptr = md->end_match_ptr;
-Line 1031 
 for (;;)
+Line 1045 
 for (;;)
        RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0);
        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
        ecode = prev;
-       flags = match_isgroup;
+       flags = match_tail_recursed;
        goto TAIL_RECURSE;
        }
      else  /* OP_KETRMAX */
        {
-       RMATCH(rrc, eptr, prev, offset_top, md, ims, eptrb, match_isgroup);
+       RMATCH(rrc, eptr, prev, offset_top, md, ims, eptrb, match_cbegroup);
        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
        ecode += 1 + LINK_SIZE;
-       flags = 0;
+       flags = match_tail_recursed;
        goto TAIL_RECURSE;
        }
      /* Control never gets here */
-Line 1060 
 for (;;)
+Line 1074 
 for (;;)
      case OP_BRAZERO:
        {
        next = ecode+1;
-       RMATCH(rrc, eptr, next, offset_top, md, ims, eptrb, match_isgroup);
+       RMATCH(rrc, eptr, next, offset_top, md, ims, eptrb, 0);
        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
        do next += GET(next,1); while (*next == OP_ALT);
-       ecode = next + 1+LINK_SIZE;
+       ecode = next + 1 + LINK_SIZE;
        }
      break;
      case OP_BRAMINZERO:
        {
        next = ecode+1;
-       do next += GET(next,1); while (*next == OP_ALT);
+       do next += GET(next, 1); while (*next == OP_ALT);
-       RMATCH(rrc, eptr, next + 1+LINK_SIZE, offset_top, md, ims, eptrb,
+       RMATCH(rrc, eptr, next + 1+LINK_SIZE, offset_top, md, ims, eptrb, 0);
-         match_isgroup);
        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
        ecode++;
        }
      break;
-     /* End of a group, repeated or non-repeating. If we are at the end of
+     /* End of a group, repeated or non-repeating. */
-     an assertion "group", stop matching and return MATCH_MATCH, but record the
-     current high water mark for use by positive assertions. Do this also
-     for the "once" (not-backup up) groups. */
      case OP_KET:
      case OP_KETRMIN:
      case OP_KETRMAX:
      prev = ecode - GET(ecode, 1);
-     saved_eptr = eptrb->epb_saved_eptr;
-     /* Back up the stack of bracket start pointers. */
+     /* If this was a group that remembered the subject start, in order to break
+     infinite repeats of empty string matches, retrieve the subject start from
+     the chain. Otherwise, set it NULL. */
+     if (*prev >= OP_SBRA)
+       {
+       saved_eptr = eptrb->epb_saved_eptr;   /* Value at start of group */
+       eptrb = eptrb->epb_prev;              /* Backup to previous group */
+       }
+     else saved_eptr = NULL;
-     eptrb = eptrb->epb_prev;
+     /* If we are at the end of an assertion group, stop matching and return
+     MATCH_MATCH, but record the current high water mark for use by positive
+     assertions. Do this also for the "once" (atomic) groups. */
      if (*prev == OP_ASSERT || *prev == OP_ASSERT_NOT ||
          *prev == OP_ASSERTBACK || *prev == OP_ASSERTBACK_NOT ||
-Line 1102 
 for (;;)
+Line 1122 
 for (;;)
        RRETURN(MATCH_MATCH);
        }
-     /* In all other cases except a conditional group we have to check the
+     /* For capturing groups we have to check the group number back at the start
-     group number back at the start and if necessary complete handling an
+     and if necessary complete handling an extraction by setting the offsets and
-     extraction by setting the offsets and bumping the high water mark. */
+     bumping the high water mark. Note that whole-pattern recursion is coded as
+     a recurse into group 0, so it won't be picked up here. Instead, we catch it
+     when the OP_END is reached. Other recursion is handled here. */
-     if (*prev != OP_COND)
+     if (*prev == OP_CBRA || *prev == OP_SCBRA)
        {
-       number = *prev - OP_BRA;
+       number = GET2(prev, 1+LINK_SIZE);
-       /* For extended extraction brackets (large number), we have to fish out
-       the number from a dummy opcode at the start. */
-       if (number > EXTRACT_BASIC_MAX) number = GET2(prev, 2+LINK_SIZE);
        offset = number << 1;
  #ifdef DEBUG
-Line 1121 
 for (;;)
+Line 1138 
 for (;;)
        printf("\n");
  #endif
-       /* Test for a numbered group. This includes groups called as a result
+       md->capture_last = number;
-       of recursion. Note that whole-pattern recursion is coded as a recurse
+       if (offset >= md->offset_max) md->offset_overflow = TRUE; else
-       into group 0, so it won't be picked up here. Instead, we catch it when
-       the OP_END is reached. */
-       if (number > 0)
          {
-         md->capture_last = number;
+         md->offset_vector[offset] =
-         if (offset >= md->offset_max) md->offset_overflow = TRUE; else
+           md->offset_vector[md->offset_end - number];
-           {
+         md->offset_vector[offset+1] = eptr - md->start_subject;
-           md->offset_vector[offset] =
+         if (offset_top <= offset) offset_top = offset + 2;
-             md->offset_vector[md->offset_end - number];
+         }
-           md->offset_vector[offset+1] = eptr - md->start_subject;
-           if (offset_top <= offset) offset_top = offset + 2;
+       /* Handle a recursively called group. Restore the offsets
-           }
+       appropriately and continue from after the call. */
-         /* Handle a recursively called group. Restore the offsets
+       if (md->recursive != NULL && md->recursive->group_num == number)
-         appropriately and continue from after the call. */
+         {
+         recursion_info *rec = md->recursive;
-         if (md->recursive != NULL && md->recursive->group_num == number)
+         DPRINTF(("Recursion (%d) succeeded - continuing\n", number));
-           {
+         md->recursive = rec->prevrec;
-           recursion_info *rec = md->recursive;
+         md->start_match = rec->save_start;
-           DPRINTF(("Recursion (%d) succeeded - continuing\n", number));
+         memcpy(md->offset_vector, rec->offset_save,
-           md->recursive = rec->prevrec;
+           rec->saved_max * sizeof(int));
-           md->start_match = rec->save_start;
+         ecode = rec->after_call;
-           memcpy(md->offset_vector, rec->offset_save,
+         ims = original_ims;
-             rec->saved_max * sizeof(int));
+         break;
-           ecode = rec->after_call;
-           ims = original_ims;
-           break;
-           }
          }
        }
-     /* Reset the value of the ims flags, in case they got changed during
+     /* For both capturing and non-capturing groups, reset the value of the ims
-     the group. */
+     flags, in case they got changed during the group. */
      ims = original_ims;
      DPRINTF(("ims reset to %02lx\n", ims));
-Line 1177 
 for (;;)
+Line 1186 
 for (;;)
      preceding bracket, in the appropriate order. In the second case, we can use
      tail recursion to avoid using another stack frame. */
+     flags = (*prev >= OP_SBRA)? match_cbegroup : 0;
      if (*ecode == OP_KETRMIN)
        {
        RMATCH(rrc, eptr, ecode + 1+LINK_SIZE, offset_top, md, ims, eptrb, 0);
        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
        ecode = prev;
-       flags = match_isgroup;
+       flags |= match_tail_recursed;
        goto TAIL_RECURSE;
        }
      else  /* OP_KETRMAX */
        {
-       RMATCH(rrc, eptr, prev, offset_top, md, ims, eptrb, match_isgroup);
+       RMATCH(rrc, eptr, prev, offset_top, md, ims, eptrb, flags);
        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
        ecode += 1 + LINK_SIZE;
-       flags = 0;
+       flags = match_tail_recursed;
        goto TAIL_RECURSE;
        }
      /* Control never gets here */
-Line 1202 
 for (;;)
+Line 1213 
 for (;;)
      if ((ims & PCRE_MULTILINE) != 0)
        {
        if (eptr != md->start_subject &&
-           (eptr == md->end_subject ||
+           (eptr == md->end_subject || !WAS_NEWLINE(eptr)))
-            eptr < md->start_subject + md->nllen ||
-            !IS_NEWLINE(eptr - md->nllen)))
          RRETURN(MATCH_NOMATCH);
        ecode++;
        break;
-Line 1244 
 for (;;)
+Line 1253 
 for (;;)
        if (!md->endonly)
          {
          if (eptr != md->end_subject &&
-             (eptr != md->end_subject - md->nllen || !IS_NEWLINE(eptr)))
+             (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
            RRETURN(MATCH_NOMATCH);
          ecode++;
          break;
-Line 1263 
 for (;;)
+Line 1272 
 for (;;)
      case OP_EODN:
      if (eptr != md->end_subject &&
-         (eptr != md->end_subject - md->nllen || !IS_NEWLINE(eptr)))
+         (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
        RRETURN(MATCH_NOMATCH);
      ecode++;
      break;
-Line 1319 
 for (;;)
+Line 1328 
 for (;;)
      case OP_ANY:
      if ((ims & PCRE_DOTALL) == 0)
        {
-       if (eptr <= md->end_subject - md->nllen && IS_NEWLINE(eptr))
+       if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
-         RRETURN(MATCH_NOMATCH);
        }
      if (eptr++ >= md->end_subject) RRETURN(MATCH_NOMATCH);
      if (utf8)
-Line 1414 
 for (;;)
+Line 1422 
 for (;;)
      ecode++;
      break;
+     case OP_ANYNL:
+     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+     GETCHARINCTEST(c, eptr);
+     switch(c)
+       {
+       default: RRETURN(MATCH_NOMATCH);
+       case 0x000d:
+       if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
+       break;
+       case 0x000a:
+       case 0x000b:
+       case 0x000c:
+       case 0x0085:
+       case 0x2028:
+       case 0x2029:
+       break;
+       }
+     ecode++;
+     break;
  #ifdef SUPPORT_UCP
      /* Check the next character by Unicode property. We will get here only
      if the support is in the binary; otherwise a compile-time error occurs. */
-Line 1456 
 for (;;)
+Line 1484 
 for (;;)
          default:
          RRETURN(PCRE_ERROR_INTERNAL);
-         break;
          }
        ecode += 3;
-Line 1926 
 for (;;)
+Line 1953 
 for (;;)
        else
          {
-         int dc;
+         unsigned int dc;
          GETCHARINC(dc, eptr);
          ecode += length;
-Line 1953 
 for (;;)
+Line 1980 
 for (;;)
        }
      break;
-     /* Match a single character repeatedly; different opcodes share code. */
+     /* Match a single character repeatedly. */
      case OP_EXACT:
      min = max = GET2(ecode, 1);
      ecode += 3;
      goto REPEATCHAR;
+     case OP_POSUPTO:
+     possessive = TRUE;
+     /* Fall through */
      case OP_UPTO:
      case OP_MINUPTO:
      min = 0;
-Line 1968 
 for (;;)
+Line 1999 
 for (;;)
      ecode += 3;
      goto REPEATCHAR;
+     case OP_POSSTAR:
+     possessive = TRUE;
+     min = 0;
+     max = INT_MAX;
+     ecode++;
+     goto REPEATCHAR;
+     case OP_POSPLUS:
+     possessive = TRUE;
+     min = 1;
+     max = INT_MAX;
+     ecode++;
+     goto REPEATCHAR;
+     case OP_POSQUERY:
+     possessive = TRUE;
+     min = 0;
+     max = 1;
+     ecode++;
+     goto REPEATCHAR;
      case OP_STAR:
      case OP_MINSTAR:
      case OP_PLUS:
-Line 1999 
 for (;;)
+Line 2051 
 for (;;)
        if (length > 1)
          {
-         int oclength = 0;
-         uschar occhars[8];
  #ifdef SUPPORT_UCP
-         int othercase;
+         unsigned int othercase;
          if ((ims & PCRE_CASELESS) != 0 &&
-             (othercase = _pcre_ucp_othercase(fc)) >= 0 &&
+             (othercase = _pcre_ucp_othercase(fc)) != NOTACHAR)
-              othercase >= 0)
            oclength = _pcre_ord2utf8(othercase, occhars);
+         else oclength = 0;
  #endif  /* SUPPORT_UCP */
          for (i = 1; i <= min; i++)
            {
            if (memcmp(eptr, charptr, length) == 0) eptr += length;
+ #ifdef SUPPORT_UCP
            /* Need braces because of following else */
            else if (oclength == 0) { RRETURN(MATCH_NOMATCH); }
            else
-Line 2020 
 for (;;)
+Line 2070 
 for (;;)
              if (memcmp(eptr, occhars, oclength) != 0) RRETURN(MATCH_NOMATCH);
              eptr += oclength;
              }
+ #else   /* without SUPPORT_UCP */
+           else { RRETURN(MATCH_NOMATCH); }
+ #endif  /* SUPPORT_UCP */
            }
          if (min == max) continue;
-Line 2032 
 for (;;)
+Line 2085 
 for (;;)
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
              if (memcmp(eptr, charptr, length) == 0) eptr += length;
+ #ifdef SUPPORT_UCP
              /* Need braces because of following else */
              else if (oclength == 0) { RRETURN(MATCH_NOMATCH); }
              else
-Line 2039 
 for (;;)
+Line 2093 
 for (;;)
                if (memcmp(eptr, occhars, oclength) != 0) RRETURN(MATCH_NOMATCH);
                eptr += oclength;
                }
+ #else   /* without SUPPORT_UCP */
+             else { RRETURN (MATCH_NOMATCH); }
+ #endif  /* SUPPORT_UCP */
              }
            /* Control never gets here */
            }
-         else
+         else  /* Maximize */
            {
            pp = eptr;
            for (i = min; i < max; i++)
              {
              if (eptr > md->end_subject - length) break;
              if (memcmp(eptr, charptr, length) == 0) eptr += length;
+ #ifdef SUPPORT_UCP
              else if (oclength == 0) break;
              else
                {
                if (memcmp(eptr, occhars, oclength) != 0) break;
                eptr += oclength;
                }
+ #else   /* without SUPPORT_UCP */
+             else break;
+ #endif  /* SUPPORT_UCP */
              }
+           if (possessive) continue;
            while (eptr >= pp)
             {
             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+ #ifdef SUPPORT_UCP
+            eptr--;
+            BACKCHAR(eptr);
+ #else   /* without SUPPORT_UCP */
             eptr -= length;
+ #endif  /* SUPPORT_UCP */
             }
            RRETURN(MATCH_NOMATCH);
            }
-Line 2110 
 for (;;)
+Line 2179 
 for (;;)
            }
          /* Control never gets here */
          }
-       else
+       else  /* Maximize */
          {
          pp = eptr;
          for (i = min; i < max; i++)
-Line 2118 
 for (;;)
+Line 2187 
 for (;;)
            if (eptr >= md->end_subject || fc != md->lcc[*eptr]) break;
            eptr++;
            }
+         if (possessive) continue;
          while (eptr >= pp)
            {
            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
-Line 2146 
 for (;;)
+Line 2216 
 for (;;)
            }
          /* Control never gets here */
          }
-       else
+       else  /* Maximize */
          {
          pp = eptr;
          for (i = min; i < max; i++)
-Line 2154 
 for (;;)
+Line 2224 
 for (;;)
            if (eptr >= md->end_subject || fc != *eptr) break;
            eptr++;
            }
+         if (possessive) continue;
          while (eptr >= pp)
            {
            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
-Line 2206 
 for (;;)
+Line 2277 
 for (;;)
      ecode += 3;
      goto REPEATNOTCHAR;
+     case OP_NOTPOSSTAR:
+     possessive = TRUE;
+     min = 0;
+     max = INT_MAX;
+     ecode++;
+     goto REPEATNOTCHAR;
+     case OP_NOTPOSPLUS:
+     possessive = TRUE;
+     min = 1;
+     max = INT_MAX;
+     ecode++;
+     goto REPEATNOTCHAR;
+     case OP_NOTPOSQUERY:
+     possessive = TRUE;
+     min = 0;
+     max = 1;
+     ecode++;
+     goto REPEATNOTCHAR;
+     case OP_NOTPOSUPTO:
+     possessive = TRUE;
+     min = 0;
+     max = GET2(ecode, 1);
+     ecode += 3;
+     goto REPEATNOTCHAR;
      case OP_NOTSTAR:
      case OP_NOTMINSTAR:
      case OP_NOTPLUS:
-Line 2245 
 for (;;)
+Line 2344 
 for (;;)
        /* UTF-8 mode */
        if (utf8)
          {
-         register int d;
+         register unsigned int d;
          for (i = 1; i <= min; i++)
            {
            GETCHARINC(d, eptr);
-Line 2270 
 for (;;)
+Line 2369 
 for (;;)
          /* UTF-8 mode */
          if (utf8)
            {
-           register int d;
+           register unsigned int d;
            for (fi = min;; fi++)
              {
              RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
-Line 2306 
 for (;;)
+Line 2405 
 for (;;)
          /* UTF-8 mode */
          if (utf8)
            {
-           register int d;
+           register unsigned int d;
            for (i = min; i < max; i++)
              {
              int len = 1;
-Line 2316 
 for (;;)
+Line 2415 
 for (;;)
              if (fc == d) break;
              eptr += len;
              }
-           for(;;)
+         if (possessive) continue;
+         for(;;)
              {
              RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-Line 2333 
 for (;;)
+Line 2433 
 for (;;)
              if (eptr >= md->end_subject || fc == md->lcc[*eptr]) break;
              eptr++;
              }
+           if (possessive) continue;
            while (eptr >= pp)
              {
              RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
-Line 2354 
 for (;;)
+Line 2455 
 for (;;)
        /* UTF-8 mode */
        if (utf8)
          {
-         register int d;
+         register unsigned int d;
          for (i = 1; i <= min; i++)
            {
            GETCHARINC(d, eptr);
-Line 2377 
 for (;;)
+Line 2478 
 for (;;)
          /* UTF-8 mode */
          if (utf8)
            {
-           register int d;
+           register unsigned int d;
            for (fi = min;; fi++)
              {
              RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
-Line 2412 
 for (;;)
+Line 2513 
 for (;;)
          /* UTF-8 mode */
          if (utf8)
            {
-           register int d;
+           register unsigned int d;
            for (i = min; i < max; i++)
              {
              int len = 1;
-Line 2421 
 for (;;)
+Line 2522 
 for (;;)
              if (fc == d) break;
              eptr += len;
              }
+           if (possessive) continue;
            for(;;)
              {
              RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
-Line 2438 
 for (;;)
+Line 2540 
 for (;;)
              if (eptr >= md->end_subject || fc == *eptr) break;
              eptr++;
              }
+           if (possessive) continue;
            while (eptr >= pp)
              {
              RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
-Line 2469 
 for (;;)
+Line 2572 
 for (;;)
      ecode += 3;
      goto REPEATTYPE;
+     case OP_TYPEPOSSTAR:
+     possessive = TRUE;
+     min = 0;
+     max = INT_MAX;
+     ecode++;
+     goto REPEATTYPE;
+     case OP_TYPEPOSPLUS:
+     possessive = TRUE;
+     min = 1;
+     max = INT_MAX;
+     ecode++;
+     goto REPEATTYPE;
+     case OP_TYPEPOSQUERY:
+     possessive = TRUE;
+     min = 0;
+     max = 1;
+     ecode++;
+     goto REPEATTYPE;
+     case OP_TYPEPOSUPTO:
+     possessive = TRUE;
+     min = 0;
+     max = GET2(ecode, 1);
+     ecode += 3;
+     goto REPEATTYPE;
      case OP_TYPESTAR:
      case OP_TYPEMINSTAR:
      case OP_TYPEPLUS:
-Line 2571 
 for (;;)
+Line 2702 
 for (;;)
            default:
            RRETURN(PCRE_ERROR_INTERNAL);
-           break;
            }
          }
-Line 2611 
 for (;;)
+Line 2741 
 for (;;)
          for (i = 1; i <= min; i++)
            {
            if (eptr >= md->end_subject ||
-                ((ims & PCRE_DOTALL) == 0 &&
+                ((ims & PCRE_DOTALL) == 0 && IS_NEWLINE(eptr)))
-                  eptr <= md->end_subject - md->nllen &&
-                  IS_NEWLINE(eptr)))
              RRETURN(MATCH_NOMATCH);
            eptr++;
            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
-Line 2624 
 for (;;)
+Line 2752 
 for (;;)
          eptr += min;
          break;
+         case OP_ANYNL:
+         for (i = 1; i <= min; i++)
+           {
+           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           GETCHARINC(c, eptr);
+           switch(c)
+             {
+             default: RRETURN(MATCH_NOMATCH);
+             case 0x000d:
+             if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
+             break;
+             case 0x000a:
+             case 0x000b:
+             case 0x000c:
+             case 0x0085:
+             case 0x2028:
+             case 0x2029:
+             break;
+             }
+           }
+         break;
          case OP_NOT_DIGIT:
          for (i = 1; i <= min; i++)
            {
-Line 2692 
 for (;;)
+Line 2842 
 for (;;)
  #endif     /* SUPPORT_UTF8 */
        /* Code for the non-UTF-8 case for minimum matching of operators other
-       than OP_PROP and OP_NOTPROP. */
+       than OP_PROP and OP_NOTPROP. We can assume that there are the minimum
+       number of bytes present, as this was tested above. */
        switch(ctype)
          {
-Line 2701 
 for (;;)
+Line 2852 
 for (;;)
            {
            for (i = 1; i <= min; i++)
              {
-             if (eptr <= md->end_subject - md->nllen && IS_NEWLINE(eptr))
+             if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
-               RRETURN(MATCH_NOMATCH);
              eptr++;
              }
            }
-Line 2713 
 for (;;)
+Line 2863 
 for (;;)
          eptr += min;
          break;
+         /* Because of the CRLF case, we can't assume the minimum number of
+         bytes are present in this case. */
+         case OP_ANYNL:
+         for (i = 1; i <= min; i++)
+           {
+           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           switch(*eptr++)
+             {
+             default: RRETURN(MATCH_NOMATCH);
+             case 0x000d:
+             if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
+             break;
+             case 0x000a:
+             case 0x000b:
+             case 0x000c:
+             case 0x0085:
+             break;
+             }
+           }
+         break;
          case OP_NOT_DIGIT:
          for (i = 1; i <= min; i++)
            if ((md->ctypes[*eptr++] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);
-Line 2774 
 for (;;)
+Line 2946 
 for (;;)
              GETCHARINC(c, eptr);
              if (prop_fail_result) RRETURN(MATCH_NOMATCH);
              }
-           break;
+           /* Control never gets here */
            case PT_LAMP:
            for (fi = min;; fi++)
-Line 2789 
 for (;;)
+Line 2961 
 for (;;)
                   prop_chartype == ucp_Lt) == prop_fail_result)
                RRETURN(MATCH_NOMATCH);
              }
-           break;
+           /* Control never gets here */
            case PT_GC:
            for (fi = min;; fi++)
-Line 2802 
 for (;;)
+Line 2974 
 for (;;)
              if ((prop_category == prop_value) == prop_fail_result)
                RRETURN(MATCH_NOMATCH);
              }
-           break;
+           /* Control never gets here */
            case PT_PC:
            for (fi = min;; fi++)
-Line 2815 
 for (;;)
+Line 2987 
 for (;;)
              if ((prop_chartype == prop_value) == prop_fail_result)
                RRETURN(MATCH_NOMATCH);
              }
-           break;
+           /* Control never gets here */
            case PT_SC:
            for (fi = min;; fi++)
-Line 2828 
 for (;;)
+Line 3000 
 for (;;)
              if ((prop_script == prop_value) == prop_fail_result)
                RRETURN(MATCH_NOMATCH);
              }
-           break;
+           /* Control never gets here */
            default:
            RRETURN(PCRE_ERROR_INTERNAL);
-           break;
            }
          }
-Line 2876 
 for (;;)
+Line 3047 
 for (;;)
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (fi >= max || eptr >= md->end_subject ||
                 (ctype == OP_ANY && (ims & PCRE_DOTALL) == 0 &&
-                 eptr <= md->end_subject - md->nllen && IS_NEWLINE(eptr)))
+                 IS_NEWLINE(eptr)))
              RRETURN(MATCH_NOMATCH);
            GETCHARINC(c, eptr);
-Line 2888 
 for (;;)
+Line 3059 
 for (;;)
              case OP_ANYBYTE:
              break;
+             case OP_ANYNL:
+             switch(c)
+               {
+               default: RRETURN(MATCH_NOMATCH);
+               case 0x000d:
+               if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
+               break;
+               case 0x000a:
+               case 0x000b:
+               case 0x000c:
+               case 0x0085:
+               case 0x2028:
+               case 0x2029:
+               break;
+               }
+             break;
              case OP_NOT_DIGIT:
              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0)
                RRETURN(MATCH_NOMATCH);
-Line 2932 
 for (;;)
+Line 3120 
 for (;;)
            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (fi >= max || eptr >= md->end_subject ||
-                ((ims & PCRE_DOTALL) == 0 &&
+                ((ims & PCRE_DOTALL) == 0 && IS_NEWLINE(eptr)))
-                  eptr <= md->end_subject - md->nllen && IS_NEWLINE(eptr)))
              RRETURN(MATCH_NOMATCH);
            c = *eptr++;
-Line 2945 
 for (;;)
+Line 3132 
 for (;;)
              case OP_ANYBYTE:
              break;
+             case OP_ANYNL:
+             switch(c)
+               {
+               default: RRETURN(MATCH_NOMATCH);
+               case 0x000d:
+               if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
+               break;
+               case 0x000a:
+               case 0x000b:
+               case 0x000c:
+               case 0x0085:
+               break;
+               }
+             break;
              case OP_NOT_DIGIT:
              if ((md->ctypes[c] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);
              break;
-Line 2977 
 for (;;)
+Line 3179 
 for (;;)
        /* Control never gets here */
        }
-     /* If maximizing it is worth using inline code for speed, doing the type
+     /* If maximizing, it is worth using inline code for speed, doing the type
      test once at the start (i.e. keep it out of the loop). Again, keep the
      UTF-8 and UCP stuff separate. */
-Line 3058 
 for (;;)
+Line 3260 
 for (;;)
          /* eptr is now past the end of the maximum run */
+         if (possessive) continue;
          for(;;)
            {
            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
-Line 3093 
 for (;;)
+Line 3296 
 for (;;)
          /* eptr is now past the end of the maximum run */
+         if (possessive) continue;
          for(;;)
            {
            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
-Line 3135 
 for (;;)
+Line 3339 
 for (;;)
                {
                for (i = min; i < max; i++)
                  {
-                 if (eptr >= md->end_subject ||
+                 if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;
-                     (eptr <= md->end_subject - md->nllen && IS_NEWLINE(eptr)))
-                   break;
                  eptr++;
                  while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
                  }
-Line 3161 
 for (;;)
+Line 3363 
 for (;;)
                {
                for (i = min; i < max; i++)
                  {
-                 if (eptr >= md->end_subject ||
+                 if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;
-                     (eptr <= md->end_subject - md->nllen && IS_NEWLINE(eptr)))
-                   break;
                  eptr++;
                  }
                break;
-Line 3171 
 for (;;)
+Line 3371 
 for (;;)
              else
                {
                c = max - min;
-               if (c > md->end_subject - eptr) c = md->end_subject - eptr;
+               if (c > (unsigned int)(md->end_subject - eptr))
+                 c = md->end_subject - eptr;
                eptr += c;
                }
              }
-Line 3181 
 for (;;)
+Line 3382 
 for (;;)
            case OP_ANYBYTE:
            c = max - min;
-           if (c > md->end_subject - eptr) c = md->end_subject - eptr;
+           if (c > (unsigned int)(md->end_subject - eptr))
+             c = md->end_subject - eptr;
            eptr += c;
            break;
+           case OP_ANYNL:
+           for (i = min; i < max; i++)
+             {
+             int len = 1;
+             if (eptr >= md->end_subject) break;
+             GETCHARLEN(c, eptr, len);
+             if (c == 0x000d)
+               {
+               if (++eptr >= md->end_subject) break;
+               if (*eptr == 0x000a) eptr++;
+               }
+             else
+               {
+               if (c != 0x000a && c != 0x000b && c != 0x000c &&
+                   c != 0x0085 && c != 0x2028 && c != 0x2029)
+                 break;
+               eptr += len;
+               }
+             }
+           break;
            case OP_NOT_DIGIT:
            for (i = min; i < max; i++)
              {
-Line 3257 
 for (;;)
+Line 3480 
 for (;;)
          /* eptr is now past the end of the maximum run */
+         if (possessive) continue;
          for(;;)
            {
            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
-Line 3277 
 for (;;)
+Line 3501 
 for (;;)
              {
              for (i = min; i < max; i++)
                {
-               if (eptr >= md->end_subject ||
+               if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;
-                   (eptr <= md->end_subject - md->nllen && IS_NEWLINE(eptr)))
-                 break;
                eptr++;
                }
              break;
-Line 3288 
 for (;;)
+Line 3510 
 for (;;)
            case OP_ANYBYTE:
            c = max - min;
-           if (c > md->end_subject - eptr) c = md->end_subject - eptr;
+           if (c > (unsigned int)(md->end_subject - eptr))
+             c = md->end_subject - eptr;
            eptr += c;
            break;
+           case OP_ANYNL:
+           for (i = min; i < max; i++)
+             {
+             if (eptr >= md->end_subject) break;
+             c = *eptr;
+             if (c == 0x000d)
+               {
+               if (++eptr >= md->end_subject) break;
+               if (*eptr == 0x000a) eptr++;
+               }
+             else
+               {
+               if (c != 0x000a && c != 0x000b && c != 0x000c && c != 0x0085)
+                 break;
+               eptr++;
+               }
+             }
+           break;
            case OP_NOT_DIGIT:
            for (i = min; i < max; i++)
              {
-Line 3352 
 for (;;)
+Line 3594 
 for (;;)
          /* eptr is now past the end of the maximum run */
+         if (possessive) continue;
          while (eptr >= pp)
            {
            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
-Line 3366 
 for (;;)
+Line 3609 
 for (;;)
        }
      /* Control never gets here */
-     /* There's been some horrible disaster. Since all codes > OP_BRA are
+     /* There's been some horrible disaster. Arrival here can only mean there is
-     for capturing brackets, and there shouldn't be any gaps between 0 and
+     something seriously wrong in the code above or the OP_xxx definitions. */
-     OP_BRA, arrival here can only mean there is something seriously wrong
-     in the code above or the OP_xxx definitions. */
      default:
      DPRINTF(("Unknown opcode %d\n", *ecode));
-     RRETURN(PCRE_ERROR_UNKNOWN_NODE);
+     RRETURN(PCRE_ERROR_UNKNOWN_OPCODE);
      }
    /* Do not stick any code in here without much thought; it is assumed
-Line 3411 
 Undefine all the macros that were define
+Line 3652 
 Undefine all the macros that were define
  #undef cur_is_word
  #undef condition
- #undef minimize
  #undef prev_is_word
  #undef original_ims
-Line 3484 
 BOOL startline;
+Line 3724 
 BOOL startline;
  BOOL firstline;
  BOOL first_byte_caseless = FALSE;
  BOOL req_byte_caseless = FALSE;
+ BOOL utf8;
  match_data match_block;
  match_data *md = &match_block;
  const uschar *tables;
-Line 3491 
 const uschar *start_bits = NULL;
+Line 3732 
 const uschar *start_bits = NULL;
  USPTR start_match = (USPTR)subject + start_offset;
  USPTR end_subject;
  USPTR req_byte_ptr = start_match - 1;
+ eptrblock eptrchain[EPTR_WORK_SIZE];
  pcre_study_data internal_study;
  const pcre_study_data *study;
-Line 3567 
 md->end_subject = md->start_subject + le
+Line 3809 
 md->end_subject = md->start_subject + le
  end_subject = md->end_subject;
  md->endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;
- md->utf8 = (re->options & PCRE_UTF8) != 0;
+ utf8 = md->utf8 = (re->options & PCRE_UTF8) != 0;
  md->notbol = (options & PCRE_NOTBOL) != 0;
  md->noteol = (options & PCRE_NOTEOL) != 0;
-Line 3576 
 md->partial = (options & PCRE_PARTIAL) !
+Line 3818 
 md->partial = (options & PCRE_PARTIAL) !
  md->hitend = FALSE;
  md->recursive = NULL;                   /* No recursion at top level */
+ md->eptrchain = eptrchain;              /* Make workspace generally available */
  md->lcc = tables + lcc_offset;
  md->ctypes = tables + ctypes_offset;
- /* Handle different types of newline. The two bits give four cases. If nothing
+ /* Handle different types of newline. The three bits give eight cases. If
- is set at run time, whatever was used at compile time applies. */
+ nothing is set at run time, whatever was used at compile time applies. */
- switch ((((options & PCRE_NEWLINE_CRLF) == 0)? re->options : options) &
+ switch ((((options & PCRE_NEWLINE_BITS) == 0)? re->options : options) &
-          PCRE_NEWLINE_CRLF)
+        PCRE_NEWLINE_BITS)
    {
-   default:              newline = NEWLINE; break;   /* Compile-time default */
+   case 0: newline = NEWLINE; break;   /* Compile-time default */
    case PCRE_NEWLINE_CR: newline = '\r'; break;
    case PCRE_NEWLINE_LF: newline = '\n'; break;
    case PCRE_NEWLINE_CR+
         PCRE_NEWLINE_LF: newline = ('\r' << 8) | '\n'; break;
+   case PCRE_NEWLINE_ANY: newline = -1; break;
+   default: return PCRE_ERROR_BADNEWLINE;
    }
- if (newline > 255)
+ if (newline < 0)
    {
-   md->nllen = 2;
+   md->nltype = NLTYPE_ANY;
-   md->nl[0] = (newline >> 8) & 255;
-   md->nl[1] = newline & 255;
    }
  else
    {
-   md->nllen = 1;
+   md->nltype = NLTYPE_FIXED;
-   md->nl[0] = newline;
+   if (newline > 255)
+     {
+     md->nllen = 2;
+     md->nl[0] = (newline >> 8) & 255;
+     md->nl[1] = newline & 255;
+     }
+   else
+     {
+     md->nllen = 1;
+     md->nl[0] = newline;
+     }
    }
  /* Partial matching is supported only for a restricted set of regexes at the
-Line 3615 
 if (md->partial && (re->options & PCRE_N
+Line 3868 
 if (md->partial && (re->options & PCRE_N
  back the character offset. */
  #ifdef SUPPORT_UTF8
- if (md->utf8 && (options & PCRE_NO_UTF8_CHECK) == 0)
+ if (utf8 && (options & PCRE_NO_UTF8_CHECK) == 0)
    {
    if (_pcre_valid_utf8((uschar *)subject, length) >= 0)
      return PCRE_ERROR_BADUTF8;
-Line 3707 
 if ((re->options & PCRE_REQCHSET) != 0)
+Line 3960 
 if ((re->options & PCRE_REQCHSET) != 0)
    req_byte2 = (tables + fcc_offset)[req_byte];  /* case flipped */
    }
+ /* ==========================================================================*/
  /* Loop for handling unanchored repeated matching attempts; for anchored regexs
  the loop runs just once. */
- do
+ for(;;)
    {
    USPTR save_end_subject = end_subject;
-Line 3725 
 do
+Line 3981 
 do
    /* Advance to a unique first char if possible. If firstline is TRUE, the
    start of the match is constrained to the first line of a multiline string.
-   Implement this by temporarily adjusting end_subject so that we stop scanning
+   That is, the match must be before or at the first newline. Implement this by
-   at a newline. If the match fails at the newline, later code breaks this loop.
+   temporarily adjusting end_subject so that we stop scanning at a newline. If
-   */
+   the match fails at the newline, later code breaks this loop. */
    if (firstline)
      {
      USPTR t = start_match;
-     while (t <= save_end_subject - md->nllen && !IS_NEWLINE(t)) t++;
+     while (t < md->end_subject && !IS_NEWLINE(t)) t++;
      end_subject = t;
      }
-Line 3753 
 do
+Line 4009 
 do
    else if (startline)
      {
-     if (start_match >= md->start_subject + md->nllen +
+     if (start_match > md->start_subject + start_offset)
-           start_offset)
        {
-       while (start_match <= end_subject &&
+       while (start_match <= end_subject && !WAS_NEWLINE(start_match))
-              !IS_NEWLINE(start_match - md->nllen))
          start_match++;
        }
      }
-Line 3793 
 do
+Line 4047 
 do
    HOWEVER: when the subject string is very, very long, searching to its end can
    take a long time, and give bad performance on quite ordinary patterns. This
-   showed up when somebody was matching /^C/ on a 32-megabyte string... so we
+   showed up when somebody was matching something like /^\d+C/ on a 32-megabyte
-   don't do this when the string is sufficiently long.
+   string... so we don't do this when the string is sufficiently long.
    ALSO: this processing is disabled when partial matching is requested.
    */
-Line 3826 
 do
+Line 4080 
 do
            }
          }
-       /* If we can't find the required character, break the matching loop */
+       /* If we can't find the required character, break the matching loop,
+       forcing a match failure. */
-       if (p >= end_subject) break;
+       if (p >= end_subject)
+         {
+         rc = MATCH_NOMATCH;
+         break;
+         }
        /* If we have found the required character, save the point where we
        found it, so that we don't search again next time round the loop if
-Line 3838 
 do
+Line 4097 
 do
        }
      }
-   /* When a match occurs, substrings will be set for all internal extractions;
+   /* OK, we can now run the match. */
-   we just need to set up the whole thing as substring 0 before returning. If
-   there were too many extractions, set the return code to zero. In the case
-   where we had to get some local store to hold offsets for backreferences, copy
-   those back references that we can. In this case there need not be overflow
-   if certain parts of the pattern were not used. */
    md->start_match = start_match;
    md->match_call_count = 0;
+   md->eptrn = 0;                          /* Next free eptrchain slot */
+   rc = match(start_match, md->start_code, 2, md, ims, NULL, 0, 0);
-   rc = match(start_match, md->start_code, 2, md, ims, NULL, match_isgroup, 0);
+   /* Any return other than MATCH_NOMATCH breaks the loop. */
-   /* When the result is no match, if the subject's first character was a
+   if (rc != MATCH_NOMATCH) break;
-   newline and the PCRE_FIRSTLINE option is set, break (which will return
-   PCRE_ERROR_NOMATCH). The option requests that a match occur before the first
-   newline in the subject. Otherwise, advance the pointer to the next character
-   and continue - but the continuation will actually happen only when the
-   pattern is not anchored. */
-   if (rc == MATCH_NOMATCH)
+   /* If PCRE_FIRSTLINE is set, the match must happen before or at the first
-     {
+   newline in the subject (though it may continue over the newline). Therefore,
-     if (firstline &&
+   if we have just failed to match, starting at a newline, do not continue. */
-         start_match <= md->end_subject - md->nllen &&
-         IS_NEWLINE(start_match))
+   if (firstline && IS_NEWLINE(start_match)) break;
-       break;
-     start_match++;
+   /* Advance the match position by one character. */
+   start_match++;
  #ifdef SUPPORT_UTF8
-     if (md->utf8)
+   if (utf8)
-       while(start_match < end_subject && (*start_match & 0xc0) == 0x80)
+     while(start_match < end_subject && (*start_match & 0xc0) == 0x80)
-         start_match++;
+       start_match++;
  #endif
-     continue;
-     }
-   if (rc != MATCH_MATCH)
+   /* Break the loop if the pattern is anchored or if we have passed the end of
-     {
+   the subject. */
-     DPRINTF((">>>> error: returning %d\n", rc));
-     return rc;
+   if (anchored || start_match > end_subject) break;
-     }
+   /* If we have just passed a CR and the newline option is CRLF or ANY, and we
+   are now at a LF, advance the match position by one more character. */
+   if (start_match[-1] == '\r' &&
+        (md->nltype == NLTYPE_ANY || md->nllen == 2) &&
+        start_match < end_subject &&
+        *start_match == '\n')
+     start_match++;
+   }   /* End of for(;;) "bumpalong" loop */
+ /* ==========================================================================*/
+ /* We reach here when rc is not MATCH_NOMATCH, or if one of the stopping
+ conditions is true:
-   /* We have a match! Copy the offset information from temporary store if
+ (1) The pattern is anchored;
-   necessary */
+ (2) We are past the end of the subject;
+ (3) PCRE_FIRSTLINE is set and we have failed to match at a newline, because
+     this option requests that a match occur at or before the first newline in
+     the subject.
+ When we have a match and the offset vector is big enough to deal with any
+ backreferences, captured substring offsets will already be set up. In the case
+ where we had to get some local store to hold offsets for backreference
+ processing, copy those that we can. In this case there need not be overflow if
+ certain parts of the pattern were not used, even though there are more
+ capturing parentheses than vector slots. */
+ if (rc == MATCH_MATCH)
+   {
    if (using_temporary_offsets)
      {
      if (offsetcount >= 4)
-Line 3889 
 do
+Line 4169 
 do
          (offsetcount - 2) * sizeof(int));
        DPRINTF(("Copied offsets from temporary memory\n"));
        }
-     if (md->end_offset_top > offsetcount)
+     if (md->end_offset_top > offsetcount) md->offset_overflow = TRUE;
-       md->offset_overflow = TRUE;
      DPRINTF(("Freeing temporary memory\n"));
      (pcre_free)(md->offset_vector);
      }
+   /* Set the return code to the number of captured strings, or 0 if there are
+   too many to fit into the vector. */
    rc = md->offset_overflow? 0 : md->end_offset_top/2;
+   /* If there is space, set up the whole thing as substring 0. */
    if (offsetcount < 2) rc = 0; else
      {
      offsets[0] = start_match - md->start_subject;
-Line 3908 
 do
+Line 4191 
 do
    return rc;
    }
- /* This "while" is the end of the "do" above */
+ /* Control gets here if there has been an error, or if the overall match
+ attempt has failed at all permitted starting positions. */
- while (!anchored && start_match <= end_subject);
  if (using_temporary_offsets)
    {
-Line 3918 
 if (using_temporary_offsets)
+Line 4200 
 if (using_temporary_offsets)
    (pcre_free)(md->offset_vector);
    }
- if (md->partial && md->hitend)
+ if (rc != MATCH_NOMATCH)
+   {
+   DPRINTF((">>>> error: returning %d\n", rc));
+   return rc;
+   }
+ else if (md->partial && md->hitend)
    {
    DPRINTF((">>>> returning PCRE_ERROR_PARTIAL\n"));
    return PCRE_ERROR_PARTIAL;

 Legend:



Removed from v.91
 


changed lines


 
Added in v.115
 Legend:



Removed from v.91
 


changed lines


 
Added in v.115
-Removed from v.91
+Added in v.115

webmaster@exim.org	ViewVC Help
Powered by ViewVC 1.1.12