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

Diff of /code/trunk/pcre_exec.c

Parent Directory | Revision Log | View Patch Patch

-revision 602 by ph10,
Wed May 25 08:29:03 2011 UTC
+revision 619 by ph10,
Sun Jul 17 13:23:14 2011 UTC
 Line 57 
 possible. There are also some static sup
  #undef min
  #undef max
- /* Flag bits for the match() function */
+ /* Values for setting in md->match_function_type to indicate two special types
+ of call to match(). We do it this way to save on using another stack variable,
+ as stack usage is to be discouraged. */
- #define match_condassert     0x01  /* Called to check a condition assertion */
+ #define MATCH_CONDASSERT     1  /* Called to check a condition assertion */
- #define match_cbegroup       0x02  /* Could-be-empty unlimited repeat group */
+ #define MATCH_CBEGROUP       2  /* Could-be-empty unlimited repeat group */
  /* Non-error returns from the match() function. Error returns are externally
  defined PCRE_ERROR_xxx codes, which are all negative. */
-Line 73 
 negative to avoid the external error cod
+Line 75 
 negative to avoid the external error cod
  #define MATCH_ACCEPT       (-999)
  #define MATCH_COMMIT       (-998)
- #define MATCH_PRUNE        (-997)
+ #define MATCH_KETRPOS      (-997)
- #define MATCH_SKIP         (-996)
+ #define MATCH_ONCE         (-996)
- #define MATCH_SKIP_ARG     (-995)
+ #define MATCH_PRUNE        (-995)
- #define MATCH_THEN         (-994)
+ #define MATCH_SKIP         (-994)
+ #define MATCH_SKIP_ARG     (-993)
+ #define MATCH_THEN         (-992)
  /* This is a convenience macro for code that occurs many times. */
-Line 273 
 enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM
+Line 277 
 enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM
         RM31,  RM32, RM33, RM34, RM35, RM36, RM37, RM38, RM39, RM40,
         RM41,  RM42, RM43, RM44, RM45, RM46, RM47, RM48, RM49, RM50,
         RM51,  RM52, RM53, RM54, RM55, RM56, RM57, RM58, RM59, RM60,
-        RM61,  RM62 };
+        RM61,  RM62, RM63, RM64, RM65, RM66 };
  /* These versions of the macros use the stack, as normal. There are debugging
  versions and production versions. Note that the "rw" argument of RMATCH isn't
-Line 283 
 actually used in this definition. */
+Line 287 
 actually used in this definition. */
  #define REGISTER register
  #ifdef PCRE_DEBUG
- #define RMATCH(ra,rb,rc,rd,re,rf,rw) \
+ #define RMATCH(ra,rb,rc,rd,re,rw) \
    { \
    printf("match() called in line %d\n", __LINE__); \
-   rrc = match(ra,rb,mstart,markptr,rc,rd,re,rf,rdepth+1); \
+   rrc = match(ra,rb,mstart,markptr,rc,rd,re,rdepth+1); \
    printf("to line %d\n", __LINE__); \
    }
  #define RRETURN(ra) \
-Line 295 
 actually used in this definition. */
+Line 299 
 actually used in this definition. */
    return ra; \
    }
  #else
- #define RMATCH(ra,rb,rc,rd,re,rf,rw) \
+ #define RMATCH(ra,rb,rc,rd,re,rw) \
-   rrc = match(ra,rb,mstart,markptr,rc,rd,re,rf,rdepth+1)
+   rrc = match(ra,rb,mstart,markptr,rc,rd,re,rdepth+1)
  #define RRETURN(ra) return ra
  #endif
-Line 309 
 argument of match(), which never changes
+Line 313 
 argument of match(), which never changes
  #define REGISTER
- #define RMATCH(ra,rb,rc,rd,re,rf,rw)\
+ #define RMATCH(ra,rb,rc,rd,re,rw)\
    {\
    heapframe *newframe = (heapframe *)(pcre_stack_malloc)(sizeof(heapframe));\
    if (newframe == NULL) RRETURN(PCRE_ERROR_NOMEMORY);\
-Line 320 
 argument of match(), which never changes
+Line 324 
 argument of match(), which never changes
    newframe->Xmarkptr = markptr;\
    newframe->Xoffset_top = rc;\
    newframe->Xeptrb = re;\
-   newframe->Xflags = rf;\
    newframe->Xrdepth = frame->Xrdepth + 1;\
    newframe->Xprevframe = frame;\
    frame = newframe;\
-Line 357 
 typedef struct heapframe {
+Line 360 
 typedef struct heapframe {
    USPTR Xmarkptr;
    int Xoffset_top;
    eptrblock *Xeptrb;
-   int Xflags;
    unsigned int Xrdepth;
    /* Function local variables */
-Line 465 
 Arguments:
+Line 467 
 Arguments:
     md          pointer to "static" info for the match
     eptrb       pointer to chain of blocks containing eptr at start of
                   brackets - for testing for empty matches
-    flags       can contain
-                  match_condassert - this is an assertion condition
-                  match_cbegroup - this is the start of an unlimited repeat
-                    group that can match an empty string
     rdepth      the recursion depth
  Returns:       MATCH_MATCH if matched            )  these values are >= 0
-Line 481 
 Returns:       MATCH_MATCH if matched
+Line 479 
 Returns:       MATCH_MATCH if matched
  static int
  match(REGISTER USPTR eptr, REGISTER const uschar *ecode, USPTR mstart,
    const uschar *markptr, int offset_top, match_data *md, eptrblock *eptrb,
-   int flags, unsigned int rdepth)
+   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 some of them with
-Line 514 
 frame->Xmstart = mstart;
+Line 512 
 frame->Xmstart = mstart;
  frame->Xmarkptr = markptr;
  frame->Xoffset_top = offset_top;
  frame->Xeptrb = eptrb;
- frame->Xflags = flags;
  frame->Xrdepth = rdepth;
  /* This is where control jumps back to to effect "recursion" */
-Line 529 
 HEAP_RECURSE:
+Line 526 
 HEAP_RECURSE:
  #define markptr            frame->Xmarkptr
  #define offset_top         frame->Xoffset_top
  #define eptrb              frame->Xeptrb
- #define flags              frame->Xflags
  #define rdepth             frame->Xrdepth
  /* Ditto for the local variables */
-Line 587 
 i, and fc and c, can be the same variabl
+Line 583 
 i, and fc and c, can be the same variabl
  #define fi i
  #define fc c
+ /* Many of the following variables are used only in small blocks of the code.
- #ifdef SUPPORT_UTF8                /* Many of these variables are used only  */
+ My normal style of coding would have declared them within each of those blocks.
- const uschar *charptr;             /* in small blocks of the code. My normal */
+ However, in order to accommodate the version of this code that uses an external
- #endif                             /* style of coding would have declared    */
+ "stack" implemented on the heap, it is easier to declare them all here, so the
- const uschar *callpat;             /* them within each of those blocks.      */
+ declarations can be cut out in a block. The only declarations within blocks
- const uschar *data;                /* However, in order to accommodate the   */
+ below are for variables that do not have to be preserved over a recursive call
- const uschar *next;                /* version of this code that uses an      */
+ to RMATCH(). */
- USPTR         pp;                  /* external "stack" implemented on the    */
- const uschar *prev;                /* heap, it is easier to declare them all */
+ #ifdef SUPPORT_UTF8
- USPTR         saved_eptr;          /* here, so the declarations can be cut   */
+ const uschar *charptr;
-                                    /* out in a block. The only declarations  */
+ #endif
- recursion_info new_recursive;      /* within blocks below are for variables  */
+ const uschar *callpat;
-                                    /* that do not have to be preserved over  */
+ const uschar *data;
- BOOL cur_is_word;                  /* a recursive call to RMATCH().          */
+ const uschar *next;
+ USPTR         pp;
+ const uschar *prev;
+ USPTR         saved_eptr;
+ recursion_info new_recursive;
+ BOOL cur_is_word;
  BOOL condition;
  BOOL prev_is_word;
-Line 630 
 int stacksave[REC_STACK_SAVE_MAX];
+Line 633 
 int stacksave[REC_STACK_SAVE_MAX];
  eptrblock newptrb;
  #endif     /* NO_RECURSE */
+ /* To save space on the stack and in the heap frame, I have doubled up on some
+ of the local variables that are used only in localised parts of the code, but
+ still need to be preserved over recursive calls of match(). These macros define
+ the alternative names that are used. */
+ #define allow_zero    cur_is_word
+ #define cbegroup      condition
+ #define code_offset   codelink
+ #define condassert    condition
+ #define matched_once  prev_is_word
  /* These statements are here to stop the compiler complaining about unitialized
  variables. */
-Line 667 
 if (md->match_call_count++ >= md->match_
+Line 681 
 if (md->match_call_count++ >= md->match_
  if (rdepth >= md->match_limit_recursion) RRETURN(PCRE_ERROR_RECURSIONLIMIT);
  /* At the start of a group with an unlimited repeat that may match an empty
- string, the match_cbegroup flag is set. When this is the case, add the current
+ string, the variable md->match_function_type is set to MATCH_CBEGROUP. It is
- subject pointer to the chain of such remembered pointers, to be checked when we
+ done this way to save having to use another function argument, which would take
- hit the closing ket, in order to break infinite loops that match no characters.
+ up space on the stack. See also MATCH_CONDASSERT below.
- When match() is called in other circumstances, don't add to the chain. The
- match_cbegroup flag must NOT be used with tail recursion, because the memory
+ When MATCH_CBEGROUP is set, add the current subject pointer to the chain of
- block that is used is on the stack, so a new one may be required for each
+ such remembered pointers, to be checked when we hit the closing ket, in order
- match(). */
+ to break infinite loops that match no characters. When match() is called in
+ other circumstances, don't add to the chain. The MATCH_CBEGROUP feature must
+ NOT be used with tail recursion, because the memory block that is used is on
+ the stack, so a new one may be required for each match(). */
- if ((flags & match_cbegroup) != 0)
+ if (md->match_function_type == MATCH_CBEGROUP)
    {
    newptrb.epb_saved_eptr = eptr;
    newptrb.epb_prev = eptrb;
    eptrb = &newptrb;
+   md->match_function_type = 0;
    }
  /* Now start processing the opcodes. */
-Line 688 
 for (;;)
+Line 706 
 for (;;)
    {
    minimize = possessive = FALSE;
    op = *ecode;
    switch(op)
      {
      case OP_MARK:
      markptr = ecode + 2;
      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
-       eptrb, flags, RM55);
+       eptrb, RM55);
      /* A return of MATCH_SKIP_ARG means that matching failed at SKIP with an
      argument, and we must check whether that argument matches this MARK's
-Line 720 
 for (;;)
+Line 738 
 for (;;)
      case OP_COMMIT:
      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
-       eptrb, flags, RM52);
+       eptrb, RM52);
      if (rrc != MATCH_NOMATCH && rrc != MATCH_PRUNE &&
          rrc != MATCH_SKIP && rrc != MATCH_SKIP_ARG &&
          rrc != MATCH_THEN)
-Line 731 
 for (;;)
+Line 749 
 for (;;)
      case OP_PRUNE:
      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
-       eptrb, flags, RM51);
+       eptrb, RM51);
      if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
      MRRETURN(MATCH_PRUNE);
      case OP_PRUNE_ARG:
      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
-       eptrb, flags, RM56);
+       eptrb, RM56);
      if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
      md->mark = ecode + 2;
      RRETURN(MATCH_PRUNE);
-Line 746 
 for (;;)
+Line 764 
 for (;;)
      case OP_SKIP:
      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
-       eptrb, flags, RM53);
+       eptrb, RM53);
      if (rrc != MATCH_NOMATCH && rrc != MATCH_PRUNE && rrc != MATCH_THEN)
        RRETURN(rrc);
      md->start_match_ptr = eptr;   /* Pass back current position */
-Line 754 
 for (;;)
+Line 772 
 for (;;)
      case OP_SKIP_ARG:
      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
-       eptrb, flags, RM57);
+       eptrb, RM57);
      if (rrc != MATCH_NOMATCH && rrc != MATCH_PRUNE && rrc != MATCH_THEN)
        RRETURN(rrc);
-Line 773 
 for (;;)
+Line 791 
 for (;;)
      case OP_THEN:
      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
-       eptrb, flags, RM54);
+       eptrb, RM54);
      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
      md->start_match_ptr = ecode - GET(ecode, 1);
      MRRETURN(MATCH_THEN);
      case OP_THEN_ARG:
      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1+LINK_SIZE],
-       offset_top, md, eptrb, flags, RM58);
+       offset_top, md, eptrb, RM58);
      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
      md->start_match_ptr = ecode - GET(ecode, 1);
      md->mark = ecode + LINK_SIZE + 2;
      RRETURN(MATCH_THEN);
-     /* Handle a capturing bracket. If there is space in the offset vector, save
+     /* Handle a capturing bracket, other than those that are possessive with an
-     the current subject position in the working slot at the top of the vector.
+     unlimited repeat. If there is space in the offset vector, save the current
-     We mustn't change the current values of the data slot, because they may be
+     subject position in the working slot at the top of the vector. We mustn't
-     set from a previous iteration of this group, and be referred to by a
+     change the current values of the data slot, because they may be set from a
-     reference inside the group.
+     previous iteration of this group, and be referred to by a reference inside
+     the group. A failure to match might occur after the group has succeeded,
-     If the bracket fails to match, we need to restore this value and also the
+     if something later on doesn't match. For this reason, we need to restore
-     values of the final offsets, in case they were set by a previous iteration
+     the working value and also the values of the final offsets, in case they
-     of the same bracket.
+     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
-Line 804 
 for (;;)
+Line 822 
 for (;;)
      case OP_SCBRA:
      number = GET2(ecode, 1+LINK_SIZE);
      offset = number << 1;
  #ifdef PCRE_DEBUG
      printf("start bracket %d\n", number);
      printf("subject=");
-Line 823 
 for (;;)
+Line 841 
 for (;;)
        md->offset_vector[md->offset_end - number] =
          (int)(eptr - md->start_subject);
-       flags = (op == OP_SCBRA)? match_cbegroup : 0;
+       for (;;)
-       do
          {
-         RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
+         if (op >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;
-           eptrb, flags, RM1);
+         RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
+           eptrb, RM1);
+         if (rrc == MATCH_ONCE) break;  /* Backing up through an atomic group */
          if (rrc != MATCH_NOMATCH &&
              (rrc != MATCH_THEN || md->start_match_ptr != ecode))
            RRETURN(rrc);
          md->capture_last = save_capture_last;
          ecode += GET(ecode, 1);
+         if (*ecode != OP_ALT) break;
          }
-       while (*ecode == OP_ALT);
        DPRINTF(("bracket %d failed\n", number));
        md->offset_vector[offset] = save_offset1;
        md->offset_vector[offset+1] = save_offset2;
        md->offset_vector[md->offset_end - number] = save_offset3;
+       /* At this point, rrc will be one of MATCH_ONCE, MATCH_NOMATCH, or
+       MATCH_THEN. */
-       if (rrc != MATCH_THEN) md->mark = markptr;
+       if (rrc != MATCH_THEN && md->mark == NULL) md->mark = markptr;
-       RRETURN(MATCH_NOMATCH);
+       RRETURN(((rrc == MATCH_ONCE)? MATCH_ONCE:MATCH_NOMATCH));
        }
      /* FALL THROUGH ... Insufficient room for saving captured contents. Treat
-Line 857 
 for (;;)
+Line 878 
 for (;;)
      /* VVVVVVVVVVVVVVVVVVVVVVVVV */
      /* VVVVVVVVVVVVVVVVVVVVVVVVV */
-     /* Non-capturing bracket. Loop for all the alternatives. When we get to the
+     /* Non-capturing or atomic group, except for possessive with unlimited
-     final alternative within the brackets, we would return the result of a
+     repeat. Loop for all the alternatives. When we get to the final alternative
-     recursive call to match() whatever happened. We can reduce stack usage by
+     within the brackets, we used to return the result of a recursive call to
-     turning this into a tail recursion, except in the case when match_cbegroup
+     match() whatever happened so it was possible to reduce stack usage by
-     is set.*/
+     turning this into a tail recursion, except in the case of a possibly empty
+     group. However, now that there is the possiblity of (*THEN) occurring in
+     the final alternative, this optimization is no longer possible.
+     MATCH_ONCE is returned when the end of an atomic group is successfully
+     reached, but subsequent matching fails. It passes back up the tree (causing
+     captured values to be reset) until the original atomic group level is
+     reached. This is tested by comparing md->once_target with the start of the
+     group. At this point, the return is converted into MATCH_NOMATCH so that
+     previous backup points can be taken. */
+     case OP_ONCE:
      case OP_BRA:
      case OP_SBRA:
      DPRINTF(("start non-capturing bracket\n"));
-     flags = (op >= OP_SBRA)? match_cbegroup : 0;
      for (;;)
        {
-       if (ecode[GET(ecode, 1)] != OP_ALT)   /* Final alternative */
+       if (op >= OP_SBRA || op == OP_ONCE) md->match_function_type = MATCH_CBEGROUP;
-         {
+       RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, eptrb,
-         if (flags == 0)    /* Not a possibly empty group */
+         RM2);
+       if (rrc != MATCH_NOMATCH &&
+           (rrc != MATCH_THEN || md->start_match_ptr != ecode))
+         {
+         if (rrc == MATCH_ONCE)
            {
-           ecode += _pcre_OP_lengths[*ecode];
+           const uschar *scode = ecode;
-           DPRINTF(("bracket 0 tail recursion\n"));
+           if (*scode != OP_ONCE)           /* If not at start, find it */
-           goto TAIL_RECURSE;
+             {
-           }
+             while (*scode == OP_ALT) scode += GET(scode, 1);
+             scode -= GET(scode, 1);
+             }
+           if (md->once_target == scode) rrc = MATCH_NOMATCH;
+           }
+         RRETURN(rrc);
+         }
+       ecode += GET(ecode, 1);
+       if (*ecode != OP_ALT) break;
+       }
+     if (rrc != MATCH_THEN && md->mark == NULL) md->mark = markptr;
+     RRETURN(MATCH_NOMATCH);
-         /* Possibly empty group; can't use tail recursion. */
+     /* Handle possessive capturing brackets with an unlimited repeat. We come
+     here from BRAZERO with allow_zero set TRUE. The offset_vector values are
+     handled similarly to the normal case above. However, the matching is
+     different. The end of these brackets will always be OP_KETRPOS, which
+     returns MATCH_KETRPOS without going further in the pattern. By this means
+     we can handle the group by iteration rather than recursion, thereby
+     reducing the amount of stack needed. */
+     case OP_CBRAPOS:
+     case OP_SCBRAPOS:
+     allow_zero = FALSE;
+     POSSESSIVE_CAPTURE:
+     number = GET2(ecode, 1+LINK_SIZE);
+     offset = number << 1;
-         RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, eptrb,
+ #ifdef PCRE_DEBUG
-           flags, RM48);
+     printf("start possessive bracket %d\n", number);
-         if (rrc == MATCH_NOMATCH) md->mark = markptr;
+     printf("subject=");
-         RRETURN(rrc);
+     pchars(eptr, 16, TRUE, md);
+     printf("\n");
+ #endif
+     if (offset < md->offset_max)
+       {
+       matched_once = FALSE;
+       code_offset = ecode - md->start_code;
+       save_offset1 = md->offset_vector[offset];
+       save_offset2 = md->offset_vector[offset+1];
+       save_offset3 = md->offset_vector[md->offset_end - number];
+       save_capture_last = md->capture_last;
+       DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));
+       /* Each time round the loop, save the current subject position for use
+       when the group matches. For MATCH_MATCH, the group has matched, so we
+       restart it with a new subject starting position, remembering that we had
+       at least one match. For MATCH_NOMATCH, carry on with the alternatives, as
+       usual. If we haven't matched any alternatives in any iteration, check to
+       see if a previous iteration matched. If so, the group has matched;
+       continue from afterwards. Otherwise it has failed; restore the previous
+       capture values before returning NOMATCH. */
+       for (;;)
+         {
+         md->offset_vector[md->offset_end - number] =
+           (int)(eptr - md->start_subject);
+         if (op >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;
+         RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
+           eptrb, RM63);
+         if (rrc == MATCH_KETRPOS)
+           {
+           offset_top = md->end_offset_top;
+           eptr = md->end_match_ptr;
+           ecode = md->start_code + code_offset;
+           save_capture_last = md->capture_last;
+           matched_once = TRUE;
+           continue;
+           }
+         if (rrc != MATCH_NOMATCH &&
+             (rrc != MATCH_THEN || md->start_match_ptr != ecode))
+           RRETURN(rrc);
+         md->capture_last = save_capture_last;
+         ecode += GET(ecode, 1);
+         if (*ecode != OP_ALT) break;
          }
-       /* For non-final alternatives, continue the loop for a NOMATCH result;
+       if (!matched_once)
-       otherwise return. */
+         {
+         md->offset_vector[offset] = save_offset1;
+         md->offset_vector[offset+1] = save_offset2;
+         md->offset_vector[md->offset_end - number] = save_offset3;
+         }
+       if (rrc != MATCH_THEN && md->mark == NULL) md->mark = markptr;
+       if (allow_zero || matched_once)
+         {
+         ecode += 1 + LINK_SIZE;
+         break;
+         }
+       RRETURN(MATCH_NOMATCH);
+       }
+     /* FALL THROUGH ... Insufficient room for saving captured contents. Treat
+     as a non-capturing bracket. */
-       RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, eptrb,
+     /* VVVVVVVVVVVVVVVVVVVVVVVVV */
-         flags, RM2);
+     /* VVVVVVVVVVVVVVVVVVVVVVVVV */
+     DPRINTF(("insufficient capture room: treat as non-capturing\n"));
+     /* VVVVVVVVVVVVVVVVVVVVVVVVV */
+     /* VVVVVVVVVVVVVVVVVVVVVVVVV */
+     /* Non-capturing possessive bracket with unlimited repeat. We come here
+     from BRAZERO with allow_zero = TRUE. The code is similar to the above,
+     without the capturing complication. It is written out separately for speed
+     and cleanliness. */
+     case OP_BRAPOS:
+     case OP_SBRAPOS:
+     allow_zero = FALSE;
+     POSSESSIVE_NON_CAPTURE:
+     matched_once = FALSE;
+     code_offset = ecode - md->start_code;
+     for (;;)
+       {
+       if (op >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;
+       RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
+         eptrb, RM48);
+       if (rrc == MATCH_KETRPOS)
+         {
+         offset_top = md->end_offset_top;
+         eptr = md->end_match_ptr;
+         ecode = md->start_code + code_offset;
+         matched_once = TRUE;
+         continue;
+         }
        if (rrc != MATCH_NOMATCH &&
            (rrc != MATCH_THEN || md->start_match_ptr != ecode))
          RRETURN(rrc);
        ecode += GET(ecode, 1);
+       if (*ecode != OP_ALT) break;
        }
+     if (matched_once || allow_zero)
+       {
+       ecode += 1 + LINK_SIZE;
+       break;
+       }
+     RRETURN(MATCH_NOMATCH);
      /* Control never reaches here. */
      /* Conditional group: compilation checked that there are no more than
      two branches. If the condition is false, skipping the first branch takes us
      past the end if there is only one branch, but that's OK because that is
-     exactly what going to the ket would do. As there is only one branch to be
+     exactly what going to the ket would do. */
-     obeyed, we can use tail recursion to avoid using another stack frame. */
      case OP_COND:
      case OP_SCOND:
-     codelink= GET(ecode, 1);
+     codelink = GET(ecode, 1);
      /* Because of the way auto-callout works during compile, a callout item is
      inserted between OP_COND and an assertion condition. */
-Line 1081 
 for (;;)
+Line 1244 
 for (;;)
        }
      /* The condition is an assertion. Call match() to evaluate it - setting
-     the final argument match_condassert causes it to stop at the end of an
+     md->match_function_type to MATCH_CONDASSERT causes it to stop at the end of
-     assertion. */
+     an assertion. */
      else
        {
-       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, NULL,
+       md->match_function_type = MATCH_CONDASSERT;
-           match_condassert, RM3);
+       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, NULL, RM3);
        if (rrc == MATCH_MATCH)
          {
+         if (md->end_offset_top > offset_top)
+           offset_top = md->end_offset_top;  /* Captures may have happened */
          condition = TRUE;
          ecode += 1 + LINK_SIZE + GET(ecode, LINK_SIZE + 2);
          while (*ecode == OP_ALT) ecode += GET(ecode, 1);
-Line 1107 
 for (;;)
+Line 1272 
 for (;;)
        }
      /* 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, except when
+     we used to use tail recursion to avoid using another stack frame, except
-     match_cbegroup is required for an unlimited repeat of a possibly empty
+     when there was unlimited repeat of a possibly empty group. However, that
-     group. If the second alternative doesn't exist, we can just plough on. */
+     strategy no longer works because of the possibilty of (*THEN) being
+     encountered in the branch. A recursive call to match() is always required,
+     unless the second alternative doesn't exist, in which case we can just
+     plough on. */
      if (condition || *ecode == OP_ALT)
        {
-       ecode += 1 + LINK_SIZE;
+       if (op == OP_SCOND) md->match_function_type = MATCH_CBEGROUP;
-       if (op == OP_SCOND)        /* Possibly empty group */
+       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM49);
-         {
+       if (rrc == MATCH_THEN && md->start_match_ptr == ecode)
-         RMATCH(eptr, ecode, offset_top, md, eptrb, match_cbegroup, RM49);
+         rrc = MATCH_NOMATCH;
-         RRETURN(rrc);
+       RRETURN(rrc);
-         }
-       else                       /* Group must match something */
-         {
-         flags = 0;
-         goto TAIL_RECURSE;
-         }
        }
      else                         /* Condition false & no alternative */
        {
-Line 1156 
 for (;;)
+Line 1318 
 for (;;)
      break;
-     /* End of the pattern, either real or forced. If we are in a top-level
+     /* End of the pattern, either real or forced. */
-     recursion, we should restore the offsets appropriately and continue from
-     after the call. */
-     case OP_ACCEPT:
      case OP_END:
-     if (md->recursive != NULL && md->recursive->group_num == 0)
+     case OP_ACCEPT:
-       {
+     case OP_ASSERT_ACCEPT:
-       recursion_info *rec = md->recursive;
-       DPRINTF(("End of pattern in a (?0) recursion\n"));
+     /* If we have matched an empty string, fail if not in an assertion and not
-       md->recursive = rec->prevrec;
+     in a recursion if either PCRE_NOTEMPTY is set, or if PCRE_NOTEMPTY_ATSTART
-       memmove(md->offset_vector, rec->offset_save,
+     is set and we have matched at the start of the subject. In both cases,
-         rec->saved_max * sizeof(int));
+     backtracking will then try other alternatives, if any. */
-       offset_top = rec->save_offset_top;
-       ecode = rec->after_call;
+     if (eptr == mstart && op != OP_ASSERT_ACCEPT &&
-       break;
+          md->recursive == NULL &&
-       }
+          (md->notempty ||
+            (md->notempty_atstart &&
-     /* Otherwise, if we have matched an empty string, fail if PCRE_NOTEMPTY is
+              mstart == md->start_subject + md->start_offset)))
-     set, or if PCRE_NOTEMPTY_ATSTART is set and we have matched at the start of
-     the subject. In both cases, backtracking will then try other alternatives,
-     if any. */
-     if (eptr == mstart &&
-         (md->notempty ||
-           (md->notempty_atstart &&
-             mstart == md->start_subject + md->start_offset)))
        MRRETURN(MATCH_NOMATCH);
      /* Otherwise, we have a match. */
      md->end_match_ptr = eptr;           /* Record where we ended */
      md->end_offset_top = offset_top;    /* and how many extracts were taken */
      md->start_match_ptr = mstart;       /* and the start (\K can modify) */
-Line 1201 
 for (;;)
+Line 1352 
 for (;;)
      matching won't pass the KET for an assertion. If any one branch matches,
      the assertion is true. Lookbehind assertions have an OP_REVERSE item at the
      start of each branch to move the current point backwards, so the code at
-     this level is identical to the lookahead case. */
+     this level is identical to the lookahead case. When the assertion is part
+     of a condition, we want to return immediately afterwards. The caller of
+     this incarnation of the match() function will have set MATCH_CONDASSERT in
+     md->match_function type, and one of these opcodes will be the first opcode
+     that is processed. We use a local variable that is preserved over calls to
+     match() to remember this case. */
      case OP_ASSERT:
      case OP_ASSERTBACK:
+     if (md->match_function_type == MATCH_CONDASSERT)
+       {
+       condassert = TRUE;
+       md->match_function_type = 0;
+       }
+     else condassert = FALSE;
      do
        {
-       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, NULL, 0,
+       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, NULL, RM4);
-         RM4);
        if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
          {
          mstart = md->start_match_ptr;   /* In case \K reset it */
-Line 1220 
 for (;;)
+Line 1382 
 for (;;)
        ecode += GET(ecode, 1);
        }
      while (*ecode == OP_ALT);
      if (*ecode == OP_KET) MRRETURN(MATCH_NOMATCH);
      /* If checking an assertion for a condition, return MATCH_MATCH. */
-     if ((flags & match_condassert) != 0) RRETURN(MATCH_MATCH);
+     if (condassert) RRETURN(MATCH_MATCH);
      /* Continue from after the assertion, updating the offsets high water
      mark, since extracts may have been taken during the assertion. */
-Line 1240 
 for (;;)
+Line 1403 
 for (;;)
      case OP_ASSERT_NOT:
      case OP_ASSERTBACK_NOT:
+     if (md->match_function_type == MATCH_CONDASSERT)
+       {
+       condassert = TRUE;
+       md->match_function_type = 0;
+       }
+     else condassert = FALSE;
      do
        {
-       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, NULL, 0,
+       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, NULL, RM5);
-         RM5);
        if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) MRRETURN(MATCH_NOMATCH);
        if (rrc == MATCH_SKIP || rrc == MATCH_PRUNE || rrc == MATCH_COMMIT)
          {
-Line 1257 
 for (;;)
+Line 1426 
 for (;;)
        }
      while (*ecode == OP_ALT);
-     if ((flags & match_condassert) != 0) RRETURN(MATCH_MATCH);
+     if (condassert) RRETURN(MATCH_MATCH);  /* Condition assertion */
      ecode += 1 + LINK_SIZE;
      continue;
-Line 1324 
 for (;;)
+Line 1493 
 for (;;)
      /* Recursion either matches the current regex, or some subexpression. The
      offset data is the offset to the starting bracket from the start of the
      whole pattern. (This is so that it works from duplicated subpatterns.)
-     If there are any capturing brackets started but not finished, we have to
+     The state of the capturing groups is preserved over recursion, and
-     save their starting points and reinstate them after the recursion. However,
+     re-instated afterwards. We don't know how many are started and not yet
-     we don't know how many such there are (offset_top records the completed
+     finished (offset_top records the completed total) so we just have to save
-     total) so we just have to save all the potential data. There may be up to
+     all the potential data. There may be up to 65535 such values, which is too
-such values, which is too large to put on the stack, but using malloc
+     large to put on the stack, but using malloc for small numbers seems
-     for small numbers seems expensive. As a compromise, the stack is used when
+     expensive. As a compromise, the stack is used when there are no more than
-     there are no more than REC_STACK_SAVE_MAX values to store; otherwise malloc
+     REC_STACK_SAVE_MAX values to store; otherwise malloc is used.
-     is used. A problem is what to do if the malloc fails ... there is no way of
-     returning to the top level with an error. Save the top REC_STACK_SAVE_MAX
-     values on the stack, and accept that the rest may be wrong.
      There are also other values that have to be saved. We use a chained
      sequence of blocks that actually live on the stack. Thanks to Robin Houston
-     for the original version of this logic. */
+     for the original version of this logic. It has, however, been hacked around
+     a lot, so he is not to blame for the current way it works. */
      case OP_RECURSE:
        {
-Line 1351 
 for (;;)
+Line 1518 
 for (;;)
        new_recursive.prevrec = md->recursive;
        md->recursive = &new_recursive;
-       /* Find where to continue from afterwards */
+       /* Where to continue from afterwards */
        ecode += 1 + LINK_SIZE;
-       new_recursive.after_call = ecode;
-       /* Now save the offset data. */
+       /* Now save the offset data */
        new_recursive.saved_max = md->offset_end;
        if (new_recursive.saved_max <= REC_STACK_SAVE_MAX)
-Line 1367 
 for (;;)
+Line 1533 
 for (;;)
            (int *)(pcre_malloc)(new_recursive.saved_max * sizeof(int));
          if (new_recursive.offset_save == NULL) RRETURN(PCRE_ERROR_NOMEMORY);
          }
        memcpy(new_recursive.offset_save, md->offset_vector,
              new_recursive.saved_max * sizeof(int));
-       new_recursive.save_offset_top = offset_top;
+       /* OK, now we can do the recursion. After processing each alternative,
-       /* OK, now we can do the recursion. For each top-level alternative we
+       restore the offset data. If there were nested recursions, md->recursive
-       restore the offset and recursion data. */
+       might be changed, so reset it before looping. */
        DPRINTF(("Recursing into group %d\n", new_recursive.group_num));
-       flags = (*callpat >= OP_SBRA)? match_cbegroup : 0;
+       cbegroup = (*callpat >= OP_SBRA);
        do
          {
+         if (cbegroup) md->match_function_type = MATCH_CBEGROUP;
          RMATCH(eptr, callpat + _pcre_OP_lengths[*callpat], offset_top,
-           md, eptrb, flags, RM6);
+           md, eptrb, RM6);
+         memcpy(md->offset_vector, new_recursive.offset_save,
+             new_recursive.saved_max * sizeof(int));
          if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
            {
            DPRINTF(("Recursion matched\n"));
            md->recursive = new_recursive.prevrec;
            if (new_recursive.offset_save != stacksave)
              (pcre_free)(new_recursive.offset_save);
-           MRRETURN(MATCH_MATCH);
+           /* Set where we got to in the subject, and reset the start in case
+           it was changed by \K. This *is* propagated back out of a recursion,
+           for Perl compatibility. */
+           eptr = md->end_match_ptr;
+           mstart = md->start_match_ptr;
+           goto RECURSION_MATCHED;        /* Exit loop; end processing */
            }
          else if (rrc != MATCH_NOMATCH &&
                  (rrc != MATCH_THEN || md->start_match_ptr != ecode))
-Line 1399 
 for (;;)
+Line 1574 
 for (;;)
            }
          md->recursive = &new_recursive;
-         memcpy(md->offset_vector, new_recursive.offset_save,
-             new_recursive.saved_max * sizeof(int));
          callpat += GET(callpat, 1);
          }
        while (*callpat == OP_ALT);
-Line 1411 
 for (;;)
+Line 1584 
 for (;;)
          (pcre_free)(new_recursive.offset_save);
        MRRETURN(MATCH_NOMATCH);
        }
-     /* Control never reaches here */
+     RECURSION_MATCHED:
-     /* "Once" brackets are like assertion brackets except that after a match,
+     break;
-     the point in the subject string is not moved back. Thus there can never be
-     a move back into the brackets. Friedl calls these "atomic" subpatterns.
-     Check the alternative branches in turn - the matching won't pass the KET
-     for this kind of subpattern. If any one branch matches, we carry on as at
-     the end of a normal bracket, leaving the subject pointer, but resetting
-     the start-of-match value in case it was changed by \K. */
-     case OP_ONCE:
-     prev = ecode;
-     saved_eptr = eptr;
-     do
-       {
-       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, 0, RM7);
-       if (rrc == MATCH_MATCH)  /* Note: _not_ MATCH_ACCEPT */
-         {
-         mstart = md->start_match_ptr;
-         break;
-         }
-       if (rrc != MATCH_NOMATCH &&
-           (rrc != MATCH_THEN || md->start_match_ptr != ecode))
-         RRETURN(rrc);
-       ecode += GET(ecode,1);
-       }
-     while (*ecode == OP_ALT);
-     /* If hit the end of the group (which could be repeated), fail */
-     if (*ecode != OP_ONCE && *ecode != OP_ALT) RRETURN(MATCH_NOMATCH);
-     /* 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);
-     offset_top = md->end_offset_top;
-     eptr = md->end_match_ptr;
-     /* For a non-repeating ket, just continue at this level. This also
-     happens for a repeating ket if no characters were matched in the group.
-     This is the forcible breaking of infinite loops as implemented in Perl
-.005. If there is an options reset, it will get obeyed in the normal
-     course of events. */
-     if (*ecode == OP_KET || eptr == saved_eptr)
-       {
-       ecode += 1+LINK_SIZE;
-       break;
-       }
-     /* The repeating kets try the rest of the pattern or restart from the
-     preceding bracket, in the appropriate order. The second "call" of match()
-     uses tail recursion, to avoid using another stack frame. */
-     if (*ecode == OP_KETRMIN)
-       {
-       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, 0, RM8);
-       if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-       ecode = prev;
-       flags = 0;
-       goto TAIL_RECURSE;
-       }
-     else  /* OP_KETRMAX */
-       {
-       RMATCH(eptr, prev, offset_top, md, eptrb, match_cbegroup, RM9);
-       if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-       ecode += 1 + LINK_SIZE;
-       flags = 0;
-       goto TAIL_RECURSE;
-       }
-     /* Control never gets here */
      /* An alternation is the end of a branch; scan along to find the end of the
      bracketed group and go to there. */
-Line 1498 
 for (;;)
+Line 1600 
 for (;;)
      at all - i.e. it could be ()* or ()? or even (){0} in the pattern. Brackets
      with fixed upper repeat limits are compiled as a number of copies, with the
      optional ones preceded by BRAZERO or BRAMINZERO. */
      case OP_BRAZERO:
-       {
+     next = ecode + 1;
-       next = ecode+1;
+     RMATCH(eptr, next, offset_top, md, eptrb, RM10);
-       RMATCH(eptr, next, offset_top, md, eptrb, 0, RM10);
+     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-       if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+     do next += GET(next, 1); while (*next == OP_ALT);
-       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;
-       next = ecode+1;
+     do next += GET(next, 1); while (*next == OP_ALT);
-       do next += GET(next, 1); while (*next == OP_ALT);
+     RMATCH(eptr, next + 1+LINK_SIZE, offset_top, md, eptrb, RM11);
-       RMATCH(eptr, next + 1+LINK_SIZE, offset_top, md, eptrb, 0, RM11);
+     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-       if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+     ecode++;
-       ecode++;
-       }
      break;
      case OP_SKIPZERO:
-       {
+     next = ecode+1;
-       next = ecode+1;
+     do next += GET(next,1); while (*next == OP_ALT);
-       do next += GET(next,1); while (*next == OP_ALT);
+     ecode = next + 1 + LINK_SIZE;
-       ecode = next + 1 + LINK_SIZE;
-       }
      break;
+     /* BRAPOSZERO occurs before a possessive bracket group. Don't do anything
+     here; just jump to the group, with allow_zero set TRUE. */
+     case OP_BRAPOSZERO:
+     op = *(++ecode);
+     allow_zero = TRUE;
+     if (op == OP_CBRAPOS || op == OP_SCBRAPOS) goto POSSESSIVE_CAPTURE;
+       goto POSSESSIVE_NON_CAPTURE;
      /* End of a group, repeated or non-repeating. */
      case OP_KET:
      case OP_KETRMIN:
      case OP_KETRMAX:
+     case OP_KETRPOS:
      prev = ecode - GET(ecode, 1);
      /* 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)
+     if (*prev >= OP_SBRA || *prev == OP_ONCE)
        {
        saved_eptr = eptrb->epb_saved_eptr;   /* Value at start of group */
        eptrb = eptrb->epb_prev;              /* Backup to previous group */
        }
      else saved_eptr = NULL;
-     /* If we are at the end of an assertion group or an atomic group, stop
+     /* If we are at the end of an assertion group, stop matching and return
-     matching and return MATCH_MATCH, but record the current high water mark for
+     MATCH_MATCH, but record the current high water mark for use by positive
-     use by positive assertions. We also need to record the match start in case
+     assertions. We also need to record the match start in case it was changed
-     it was changed by \K. */
+     by \K. */
      if (*prev == OP_ASSERT || *prev == OP_ASSERT_NOT ||
-         *prev == OP_ASSERTBACK || *prev == OP_ASSERTBACK_NOT ||
+         *prev == OP_ASSERTBACK || *prev == OP_ASSERTBACK_NOT)
-         *prev == OP_ONCE)
        {
        md->end_match_ptr = eptr;      /* For ONCE */
        md->end_offset_top = offset_top;
-Line 1562 
 for (;;)
+Line 1667 
 for (;;)
      /* For capturing groups we have to check the group number back at the start
      and if necessary complete handling an extraction by setting the offsets and
-     bumping the high water mark. Note that whole-pattern recursion is coded as
+     bumping the high water mark. Whole-pattern recursion is coded as a recurse
-     a recurse into group 0, so it won't be picked up here. Instead, we catch it
+     into group 0, so it won't be picked up here. Instead, we catch it when the
-     when the OP_END is reached. Other recursion is handled here. */
+     OP_END is reached. Other recursion is handled here. We just have to record
+     the current subject position and start match pointer and give a MATCH
+     return. */
-     if (*prev == OP_CBRA || *prev == OP_SCBRA)
+     if (*prev == OP_CBRA || *prev == OP_SCBRA ||
+         *prev == OP_CBRAPOS || *prev == OP_SCBRAPOS)
        {
        number = GET2(prev, 1+LINK_SIZE);
        offset = number << 1;
-Line 1576 
 for (;;)
+Line 1684 
 for (;;)
        printf("\n");
  #endif
+       /* Handle a recursively called group. */
+       if (md->recursive != NULL && md->recursive->group_num == number)
+         {
+         md->end_match_ptr = eptr;
+         md->start_match_ptr = mstart;
+         RRETURN(MATCH_MATCH);
+         }
+       /* Deal with capturing */
        md->capture_last = number;
        if (offset >= md->offset_max) md->offset_overflow = TRUE; else
          {
+         /* If offset is greater than offset_top, it means that we are
+         "skipping" a capturing group, and that group's offsets must be marked
+         unset. In earlier versions of PCRE, all the offsets were unset at the
+         start of matching, but this doesn't work because atomic groups and
+         assertions can cause a value to be set that should later be unset.
+         Example: matching /(?>(a))b|(a)c/ against "ac". This sets group 1 as
+         part of the atomic group, but this is not on the final matching path,
+         so must be unset when 2 is set. (If there is no group 2, there is no
+         problem, because offset_top will then be 2, indicating no capture.) */
+         if (offset > offset_top)
+           {
+           register int *iptr = md->offset_vector + offset_top;
+           register int *iend = md->offset_vector + offset;
+           while (iptr < iend) *iptr++ = -1;
+           }
+         /* Now make the extraction */
          md->offset_vector[offset] =
            md->offset_vector[md->offset_end - number];
          md->offset_vector[offset+1] = (int)(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. */
-       if (md->recursive != NULL && md->recursive->group_num == number)
-         {
-         recursion_info *rec = md->recursive;
-         DPRINTF(("Recursion (%d) succeeded - continuing\n", number));
-         md->recursive = rec->prevrec;
-         memcpy(md->offset_vector, rec->offset_save,
-           rec->saved_max * sizeof(int));
-         offset_top = rec->save_offset_top;
-         ecode = rec->after_call;
-         break;
-         }
        }
-     /* For a non-repeating ket, just continue at this level. This also
+     /* For an ordinary non-repeating ket, just continue at this level. This
-     happens for a repeating ket if no characters were matched in the group.
+     also happens for a repeating ket if no characters were matched in the
-     This is the forcible breaking of infinite loops as implemented in Perl
+     group. This is the forcible breaking of infinite loops as implemented in
-.005. If there is an options reset, it will get obeyed in the normal
+     Perl 5.005. For a non-repeating atomic group, establish a backup point by
-     course of events. */
+     processing the rest of the pattern at a lower level. If this results in a
+     NOMATCH return, pass MATCH_ONCE back to the original OP_ONCE level, thereby
+     bypassing intermediate backup points, but resetting any captures that
+     happened along the way. */
      if (*ecode == OP_KET || eptr == saved_eptr)
        {
-       ecode += 1 + LINK_SIZE;
+       if (*prev == OP_ONCE)
+         {
+         RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM12);
+         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+         md->once_target = prev;  /* Level at which to change to MATCH_NOMATCH */
+         RRETURN(MATCH_ONCE);
+         }
+       ecode += 1 + LINK_SIZE;    /* Carry on at this level */
        break;
        }
-     /* The repeating kets try the rest of the pattern or restart from the
+     /* OP_KETRPOS is a possessive repeating ket. Remember the current position,
-     preceding bracket, in the appropriate order. In the second case, we can use
+     and return the MATCH_KETRPOS. This makes it possible to do the repeats one
-     tail recursion to avoid using another stack frame, unless we have an
+     at a time from the outer level, thus saving stack. */
-     unlimited repeat of a group that can match an empty string. */
+     if (*ecode == OP_KETRPOS)
-     flags = (*prev >= OP_SBRA)? match_cbegroup : 0;
+       {
+       md->end_match_ptr = eptr;
+       md->end_offset_top = offset_top;
+       RRETURN(MATCH_KETRPOS);
+       }
+     /* The normal repeating kets try the rest of the pattern or restart from
+     the preceding bracket, in the appropriate order. In the second case, we can
+     use tail recursion to avoid using another stack frame, unless we have an
+     an atomic group or an unlimited repeat of a group that can match an empty
+     string. */
      if (*ecode == OP_KETRMIN)
        {
-       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, 0, RM12);
+       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM64);
        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-       if (flags != 0)    /* Could match an empty string */
+       if (*prev == OP_ONCE)
          {
-         RMATCH(eptr, prev, offset_top, md, eptrb, flags, RM50);
+         RMATCH(eptr, prev, offset_top, md, eptrb, RM66);
+         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+         md->once_target = prev;  /* Level at which to change to MATCH_NOMATCH */
+         RRETURN(MATCH_ONCE);
+         }
+       if (*prev >= OP_SBRA)    /* Could match an empty string */
+         {
+         md->match_function_type = MATCH_CBEGROUP;
+         RMATCH(eptr, prev, offset_top, md, eptrb, RM50);
          RRETURN(rrc);
          }
        ecode = prev;
-Line 1634 
 for (;;)
+Line 1785 
 for (;;)
        }
      else  /* OP_KETRMAX */
        {
-       RMATCH(eptr, prev, offset_top, md, eptrb, flags, RM13);
+       if (*prev >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;
+       RMATCH(eptr, prev, offset_top, md, eptrb, RM13);
+       if (rrc == MATCH_ONCE && md->once_target == prev) rrc = MATCH_NOMATCH;
        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+       if (*prev == OP_ONCE)
+         {
+         RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM65);
+         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+         md->once_target = prev;
+         RRETURN(MATCH_ONCE);
+         }
        ecode += 1 + LINK_SIZE;
-       flags = 0;
        goto TAIL_RECURSE;
        }
      /* Control never gets here */
-Line 2324 
 for (;;)
+Line 2483 
 for (;;)
        for (fi = min;; fi++)
          {
          int slength;
-         RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM14);
+         RMATCH(eptr, ecode, offset_top, md, eptrb, RM14);
          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
          if (fi >= max) MRRETURN(MATCH_NOMATCH);
          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
-Line 2354 
 for (;;)
+Line 2513 
 for (;;)
          }
        while (eptr >= pp)
          {
-         RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM15);
+         RMATCH(eptr, ecode, offset_top, md, eptrb, RM15);
          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
          eptr -= length;
          }
-Line 2464 
 for (;;)
+Line 2623 
 for (;;)
            {
            for (fi = min;; fi++)
              {
-             RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM16);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, RM16);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (fi >= max) MRRETURN(MATCH_NOMATCH);
              if (eptr >= md->end_subject)
-Line 2489 
 for (;;)
+Line 2648 
 for (;;)
            {
            for (fi = min;; fi++)
              {
-             RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM17);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, RM17);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (fi >= max) MRRETURN(MATCH_NOMATCH);
              if (eptr >= md->end_subject)
-Line 2535 
 for (;;)
+Line 2694 
 for (;;)
              }
            for (;;)
              {
-             RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM18);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, RM18);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (eptr-- == pp) break;        /* Stop if tried at original pos */
              BACKCHAR(eptr);
-Line 2558 
 for (;;)
+Line 2717 
 for (;;)
              }
            while (eptr >= pp)
              {
-             RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM19);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, RM19);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              eptr--;
              }
-Line 2634 
 for (;;)
+Line 2793 
 for (;;)
          {
          for (fi = min;; fi++)
            {
-           RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM20);
+           RMATCH(eptr, ecode, offset_top, md, eptrb, RM20);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (fi >= max) MRRETURN(MATCH_NOMATCH);
            if (eptr >= md->end_subject)
-Line 2667 
 for (;;)
+Line 2826 
 for (;;)
            }
          for(;;)
            {
-           RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM21);
+           RMATCH(eptr, ecode, offset_top, md, eptrb, RM21);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (eptr-- == pp) break;        /* Stop if tried at original pos */
            if (utf8) BACKCHAR(eptr);
-Line 2880 
 for (;;)
+Line 3039 
 for (;;)
            {
            for (fi = min;; fi++)
              {
-             RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM22);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, RM22);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (fi >= max) MRRETURN(MATCH_NOMATCH);
              if (eptr <= md->end_subject - length &&
-Line 2922 
 for (;;)
+Line 3081 
 for (;;)
            for(;;)
              {
-             RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM23);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, RM23);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (eptr == pp) { MRRETURN(MATCH_NOMATCH); }
  #ifdef SUPPORT_UCP
-Line 2976 
 for (;;)
+Line 3135 
 for (;;)
          {
          for (fi = min;; fi++)
            {
-           RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM24);
+           RMATCH(eptr, ecode, offset_top, md, eptrb, RM24);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (fi >= max) MRRETURN(MATCH_NOMATCH);
            if (eptr >= md->end_subject)
-Line 3006 
 for (;;)
+Line 3165 
 for (;;)
          while (eptr >= pp)
            {
-           RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM25);
+           RMATCH(eptr, ecode, offset_top, md, eptrb, RM25);
            eptr--;
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            }
-Line 3035 
 for (;;)
+Line 3194 
 for (;;)
          {
          for (fi = min;; fi++)
            {
-           RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM26);
+           RMATCH(eptr, ecode, offset_top, md, eptrb, RM26);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (fi >= max) MRRETURN(MATCH_NOMATCH);
            if (eptr >= md->end_subject)
-Line 3064 
 for (;;)
+Line 3223 
 for (;;)
          while (eptr >= pp)
            {
-           RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM27);
+           RMATCH(eptr, ecode, offset_top, md, eptrb, RM27);
            eptr--;
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            }
-Line 3236 
 for (;;)
+Line 3395 
 for (;;)
            register unsigned int d;
            for (fi = min;; fi++)
              {
-             RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM28);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, RM28);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (fi >= max) MRRETURN(MATCH_NOMATCH);
              if (eptr >= md->end_subject)
-Line 3255 
 for (;;)
+Line 3414 
 for (;;)
            {
            for (fi = min;; fi++)
              {
-             RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM29);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, RM29);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (fi >= max) MRRETURN(MATCH_NOMATCH);
              if (eptr >= md->end_subject)
-Line 3296 
 for (;;)
+Line 3455 
 for (;;)
          if (possessive) continue;
          for(;;)
              {
-             RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM30);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, RM30);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (eptr-- == pp) break;        /* Stop if tried at original pos */
              BACKCHAR(eptr);
-Line 3319 
 for (;;)
+Line 3478 
 for (;;)
            if (possessive) continue;
            while (eptr >= pp)
              {
-             RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM31);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, RM31);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              eptr--;
              }
-Line 3376 
 for (;;)
+Line 3535 
 for (;;)
            register unsigned int d;
            for (fi = min;; fi++)
              {
-             RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM32);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, RM32);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (fi >= max) MRRETURN(MATCH_NOMATCH);
              if (eptr >= md->end_subject)
-Line 3394 
 for (;;)
+Line 3553 
 for (;;)
            {
            for (fi = min;; fi++)
              {
-             RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM33);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, RM33);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (fi >= max) MRRETURN(MATCH_NOMATCH);
              if (eptr >= md->end_subject)
-Line 3434 
 for (;;)
+Line 3593 
 for (;;)
            if (possessive) continue;
            for(;;)
              {
-             RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM34);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, RM34);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (eptr-- == pp) break;        /* Stop if tried at original pos */
              BACKCHAR(eptr);
-Line 3457 
 for (;;)
+Line 3616 
 for (;;)
            if (possessive) continue;
            while (eptr >= pp)
              {
-             RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM35);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, RM35);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              eptr--;
              }
-Line 4255 
 for (;;)
+Line 4414 
 for (;;)
            case PT_ANY:
            for (fi = min;; fi++)
              {
-             RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM36);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, RM36);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (fi >= max) MRRETURN(MATCH_NOMATCH);
              if (eptr >= md->end_subject)
-Line 4271 
 for (;;)
+Line 4430 
 for (;;)
            case PT_LAMP:
            for (fi = min;; fi++)
              {
-             RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM37);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, RM37);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (fi >= max) MRRETURN(MATCH_NOMATCH);
              if (eptr >= md->end_subject)
-Line 4291 
 for (;;)
+Line 4450 
 for (;;)
            case PT_GC:
            for (fi = min;; fi++)
              {
-             RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM38);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, RM38);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (fi >= max) MRRETURN(MATCH_NOMATCH);
              if (eptr >= md->end_subject)
-Line 4309 
 for (;;)
+Line 4468 
 for (;;)
            case PT_PC:
            for (fi = min;; fi++)
              {
-             RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM39);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, RM39);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (fi >= max) MRRETURN(MATCH_NOMATCH);
              if (eptr >= md->end_subject)
-Line 4327 
 for (;;)
+Line 4486 
 for (;;)
            case PT_SC:
            for (fi = min;; fi++)
              {
-             RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM40);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, RM40);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (fi >= max) MRRETURN(MATCH_NOMATCH);
              if (eptr >= md->end_subject)
-Line 4345 
 for (;;)
+Line 4504 
 for (;;)
            case PT_ALNUM:
            for (fi = min;; fi++)
              {
-             RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM59);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, RM59);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (fi >= max) MRRETURN(MATCH_NOMATCH);
              if (eptr >= md->end_subject)
-Line 4364 
 for (;;)
+Line 4523 
 for (;;)
            case PT_SPACE:    /* Perl space */
            for (fi = min;; fi++)
              {
-             RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM60);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, RM60);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (fi >= max) MRRETURN(MATCH_NOMATCH);
              if (eptr >= md->end_subject)
-Line 4384 
 for (;;)
+Line 4543 
 for (;;)
            case PT_PXSPACE:  /* POSIX space */
            for (fi = min;; fi++)
              {
-             RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM61);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, RM61);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (fi >= max) MRRETURN(MATCH_NOMATCH);
              if (eptr >= md->end_subject)
-Line 4404 
 for (;;)
+Line 4563 
 for (;;)
            case PT_WORD:
            for (fi = min;; fi++)
              {
-             RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM62);
+             RMATCH(eptr, ecode, offset_top, md, eptrb, RM62);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (fi >= max) MRRETURN(MATCH_NOMATCH);
              if (eptr >= md->end_subject)
-Line 4436 
 for (;;)
+Line 4595 
 for (;;)
          {
          for (fi = min;; fi++)
            {
-           RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM41);
+           RMATCH(eptr, ecode, offset_top, md, eptrb, RM41);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (fi >= max) MRRETURN(MATCH_NOMATCH);
            if (eptr >= md->end_subject)
-Line 4468 
 for (;;)
+Line 4627 
 for (;;)
          {
          for (fi = min;; fi++)
            {
-           RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM42);
+           RMATCH(eptr, ecode, offset_top, md, eptrb, RM42);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (fi >= max) MRRETURN(MATCH_NOMATCH);
            if (eptr >= md->end_subject)
-Line 4631 
 for (;;)
+Line 4790 
 for (;;)
          {
          for (fi = min;; fi++)
            {
-           RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM43);
+           RMATCH(eptr, ecode, offset_top, md, eptrb, RM43);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (fi >= max) MRRETURN(MATCH_NOMATCH);
            if (eptr >= md->end_subject)
-Line 4929 
 for (;;)
+Line 5088 
 for (;;)
          if (possessive) continue;
          for(;;)
            {
-           RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM44);
+           RMATCH(eptr, ecode, offset_top, md, eptrb, RM44);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (eptr-- == pp) break;        /* Stop if tried at original pos */
            if (utf8) BACKCHAR(eptr);
-Line 4970 
 for (;;)
+Line 5129 
 for (;;)
          for(;;)
            {
-           RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM45);
+           RMATCH(eptr, ecode, offset_top, md, eptrb, RM45);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (eptr-- == pp) break;        /* Stop if tried at original pos */
            for (;;)                        /* Move back over one extended */
-Line 5263 
 for (;;)
+Line 5422 
 for (;;)
          if (possessive) continue;
          for(;;)
            {
-           RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM46);
+           RMATCH(eptr, ecode, offset_top, md, eptrb, RM46);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (eptr-- == pp) break;        /* Stop if tried at original pos */
            BACKCHAR(eptr);
-Line 5476 
 for (;;)
+Line 5635 
 for (;;)
          if (possessive) continue;
          while (eptr >= pp)
            {
-           RMATCH(eptr, ecode, offset_top, md, eptrb, 0, RM47);
+           RMATCH(eptr, ecode, offset_top, md, eptrb, RM47);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            eptr--;
            if (ctype == OP_ANYNL && eptr > pp  && *eptr == '\n' &&
-Line 5519 
 switch (frame->Xwhere)
+Line 5678 
 switch (frame->Xwhere)
    LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
    LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
    LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
-   LBL(53) LBL(54) LBL(55) LBL(56) LBL(57) LBL(58)
+   LBL(53) LBL(54) LBL(55) LBL(56) LBL(57) LBL(58) LBL(63) LBL(64)
+   LBL(65) LBL(66)
  #ifdef SUPPORT_UTF8
    LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
    LBL(32) LBL(34) LBL(42) LBL(46)
-Line 5621 
 pcre_exec(const pcre *argument_re, const
+Line 5781 
 pcre_exec(const pcre *argument_re, const
    PCRE_SPTR subject, int length, int start_offset, int options, int *offsets,
    int offsetcount)
  {
- int rc, resetcount, ocount;
+ int rc, ocount;
  int first_byte = -1;
  int req_byte = -1;
  int req_byte2 = -1;
-Line 5729 
 utf8 = md->utf8 = (re->options & PCRE_UT
+Line 5889 
 utf8 = md->utf8 = (re->options & PCRE_UT
  md->use_ucp = (re->options & PCRE_UCP) != 0;
  md->jscript_compat = (re->options & PCRE_JAVASCRIPT_COMPAT) != 0;
+ /* Some options are unpacked into BOOL variables in the hope that testing
+ them will be faster than individual option bits. */
  md->notbol = (options & PCRE_NOTBOL) != 0;
  md->noteol = (options & PCRE_NOTEOL) != 0;
  md->notempty = (options & PCRE_NOTEMPTY) != 0;
  md->notempty_atstart = (options & PCRE_NOTEMPTY_ATSTART) != 0;
  md->partial = ((options & PCRE_PARTIAL_HARD) != 0)? 2 :
                ((options & PCRE_PARTIAL_SOFT) != 0)? 1 : 0;
  md->hitend = FALSE;
  md->mark = NULL;                        /* In case never set */
-Line 5817 
 if (md->partial && (re->flags & PCRE_NOP
+Line 5982 
 if (md->partial && (re->flags & PCRE_NOP
    return PCRE_ERROR_BADPARTIAL;
  /* Check a UTF-8 string if required. Pass back the character offset and error
- code if a results vector is available. */
+ code for an invalid string if a results vector is available. */
  #ifdef SUPPORT_UTF8
  if (utf8 && (options & PCRE_NO_UTF8_CHECK) == 0)
    {
-   int errorcode;
+   int erroroffset;
-   int tb = _pcre_valid_utf8((USPTR)subject, length, &errorcode);
+   int errorcode = _pcre_valid_utf8((USPTR)subject, length, &erroroffset);
-   if (tb >= 0)
+   if (errorcode != 0)
      {
      if (offsetcount >= 2)
        {
-       offsets[0] = tb;
+       offsets[0] = erroroffset;
        offsets[1] = errorcode;
        }
      return (errorcode <= PCRE_UTF8_ERR5 && md->partial > 1)?
        PCRE_ERROR_SHORTUTF8 : PCRE_ERROR_BADUTF8;
      }
-   if (start_offset > 0 && start_offset < length)
-     {
+   /* Check that a start_offset points to the start of a UTF-8 character. */
-     tb = ((USPTR)subject)[start_offset] & 0xc0;
-     if (tb == 0x80) return PCRE_ERROR_BADUTF8_OFFSET;
+   if (start_offset > 0 && start_offset < length &&
-     }
+       (((USPTR)subject)[start_offset] & 0xc0) == 0x80)
+     return PCRE_ERROR_BADUTF8_OFFSET;
    }
  #endif
-Line 5864 
 md->offset_max = (2*ocount)/3;
+Line 6030 
 md->offset_max = (2*ocount)/3;
  md->offset_overflow = FALSE;
  md->capture_last = -1;
- /* Compute the minimum number of offsets that we need to reset each time. Doing
- this makes a huge difference to execution time when there aren't many brackets
- in the pattern. */
- resetcount = 2 + re->top_bracket * 2;
- if (resetcount > offsetcount) resetcount = ocount;
  /* Reset the working variable associated with each extraction. These should
  never be used unless previously set, but they get saved and restored, and so we
- initialize them to avoid reading uninitialized locations. */
+ initialize them to avoid reading uninitialized locations. Also, unset the
+ offsets for the matched string. This is really just for tidiness with callouts,
+ in case they inspect these fields. */
  if (md->offset_vector != NULL)
    {
    register int *iptr = md->offset_vector + ocount;
-   register int *iend = iptr - resetcount/2 + 1;
+   register int *iend = iptr - re->top_bracket;
+   if (iend < md->offset_vector + 2) iend = md->offset_vector + 2;
    while (--iptr >= iend) *iptr = -1;
+   md->offset_vector[0] = md->offset_vector[1] = -1;
    }
  /* Set up the first character to match, if available. The first_byte value is
-Line 5913 
 if ((re->flags & PCRE_REQCHSET) != 0)
+Line 6076 
 if ((re->flags & PCRE_REQCHSET) != 0)
    }
  /* ==========================================================================*/
  /* Loop for handling unanchored repeated matching attempts; for anchored regexs
-Line 5923 
 for(;;)
+Line 6088 
 for(;;)
    USPTR save_end_subject = end_subject;
    USPTR new_start_match;
-   /* Reset the maximum number of extractions we might see. */
-   if (md->offset_vector != NULL)
-     {
-     register int *iptr = md->offset_vector;
-     register int *iend = iptr + resetcount;
-     while (iptr < iend) *iptr++ = -1;
-     }
    /* If firstline is TRUE, the start of the match is constrained to the first
    line of a multiline string. That is, the match must be before or at the first
    newline. Implement this by temporarily adjusting end_subject so that we stop
-Line 6120 
 for(;;)
+Line 6276 
 for(;;)
    md->start_match_ptr = start_match;
    md->start_used_ptr = start_match;
    md->match_call_count = 0;
-   rc = match(start_match, md->start_code, start_match, NULL, 2, md, NULL,
+   md->match_function_type = 0;
-, 0);
+   md->end_offset_top = 0;
+   rc = match(start_match, md->start_code, start_match, NULL, 2, md, NULL, 0);
    if (md->hitend && start_partial == NULL) start_partial = md->start_used_ptr;
    switch(rc)
-Line 6244 
 if (rc == MATCH_MATCH || rc == MATCH_ACC
+Line 6401 
 if (rc == MATCH_MATCH || rc == MATCH_ACC
    /* 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. The value of

 Legend:



Removed from v.602
 


changed lines


 
Added in v.619
 Legend:



Removed from v.602
 


changed lines


 
Added in v.619
-Removed from v.602
+Added in v.619

webmaster@exim.org	ViewVC Help
Powered by ViewVC 1.1.12