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

Diff of /code/trunk/pcre_exec.c

Parent Directory | Revision Log | View Patch Patch

-revision 618 by ph10,
Sat Jul 16 17:24:16 2011 UTC
+revision 733 by ph10,
Tue Oct 11 10:29:36 2011 UTC
 Line 57 
 possible. There are also some static sup
  #undef min
  #undef max
  /* 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     1  /* Called to check a condition assertion */
 Line 138 
 while (length-- > 0)
  /* Normally, if a back reference hasn't been set, the length that is passed is
  negative, so the match always fails. However, in JavaScript compatibility mode,
  the length passed is zero. Note that in caseless UTF-8 mode, the number of
  subject bytes matched may be different to the number of reference bytes.
  Arguments:
 Line 185 
 if (caseless)
  #ifdef SUPPORT_UCP
    if (md->utf8)
      {
      /* Match characters up to the end of the reference. NOTE: the number of
      bytes matched may differ, because there are some characters whose upper and
      lower case versions code as different numbers of bytes. For example, U+023A
      (2 bytes in UTF-8) is the upper case version of U+2C65 (3 bytes in UTF-8);
      a sequence of 3 of the former uses 6 bytes, as does a sequence of two of
      the latter. It is important, therefore, to check the length along the
      reference, not along the subject (earlier code did this wrong). */
      USPTR endptr = p + length;
      while (p < endptr)
        {
 Line 210 
 if (caseless)
    /* The same code works when not in UTF-8 mode and in UTF-8 mode when there
    is no UCP support. */
      {
      if (eptr + length > md->end_subject) return -1;
      while (length-- > 0)
        { if (md->lcc[*p++] != md->lcc[*eptr++]) return -1; }
      }
    }
  /* In the caseful case, we can just compare the bytes, whether or not we
  are in UTF-8 mode. */
  else
    {
    if (eptr + length > md->end_subject) return -1;
    while (length-- > 0) if (*p++ != *eptr++) return -1;
    }
  return eptr - eptr_start;
 Line 384 
 typedef struct heapframe {
    int Xprop_type;
    int Xprop_value;
    int Xprop_fail_result;
-   int Xprop_category;
-   int Xprop_chartype;
-   int Xprop_script;
    int Xoclength;
    uschar Xocchars[8];
  #endif
-Line 478 
 Returns:       MATCH_MATCH if matched
+Line 475 
 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,
    unsigned int rdepth)
  {
  /* These variables do not need to be preserved over recursion in this function,
-Line 551 
 HEAP_RECURSE:
+Line 548 
 HEAP_RECURSE:
  #define prop_type          frame->Xprop_type
  #define prop_value         frame->Xprop_value
  #define prop_fail_result   frame->Xprop_fail_result
- #define prop_category      frame->Xprop_category
- #define prop_chartype      frame->Xprop_chartype
- #define prop_script        frame->Xprop_script
  #define oclength           frame->Xoclength
  #define occhars            frame->Xocchars
  #endif
-Line 591 
 declarations can be cut out in a block.
+Line 585 
 declarations can be cut out in a block.
  below are for variables that do not have to be preserved over a recursive call
  to RMATCH(). */
  #ifdef SUPPORT_UTF8
  const uschar *charptr;
  #endif
  const uschar *callpat;
  const uschar *data;
  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 611 
 BOOL prev_is_word;
+Line 605 
 BOOL prev_is_word;
  int prop_type;
  int prop_value;
  int prop_fail_result;
- int prop_category;
- int prop_chartype;
- int prop_script;
  int oclength;
  uschar occhars[8];
  #endif
-Line 633 
 int stacksave[REC_STACK_SAVE_MAX];
+Line 624 
 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
-Line 681 
 if (md->match_call_count++ >= md->match_
+Line 672 
 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 variable md->match_function_type is set to MATCH_CBEGROUP. It is
  done this way to save having to use another function argument, which would take
  up space on the stack. See also MATCH_CONDASSERT below.
  When MATCH_CBEGROUP is set, add the current subject pointer to the chain of
-Line 706 
 for (;;)
+Line 697 
 for (;;)
    {
    minimize = possessive = FALSE;
    op = *ecode;
    switch(op)
      {
      case OP_MARK:
-Line 784 
 for (;;)
+Line 775 
 for (;;)
      md->start_match_ptr = ecode + 2;
      RRETURN(MATCH_SKIP_ARG);
-     /* For THEN (and THEN_ARG) we pass back the address of the bracket or
+     /* For THEN (and THEN_ARG) we pass back the address of the opcode, so that
-     the alt that is at the start of the current branch. This makes it possible
+     the branch in which it occurs can be determined. Overload the start of
-     to skip back past alternatives that precede the THEN within the current
+     match pointer to do this. */
-     branch. */
      case OP_THEN:
      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
        eptrb, RM54);
      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-     md->start_match_ptr = ecode - GET(ecode, 1);
+     md->start_match_ptr = ecode;
      MRRETURN(MATCH_THEN);
      case OP_THEN_ARG:
-     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1+LINK_SIZE],
+     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top,
-       offset_top, md, eptrb, RM58);
+       md, eptrb, RM58);
      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-     md->start_match_ptr = ecode - GET(ecode, 1);
+     md->start_match_ptr = ecode;
-     md->mark = ecode + LINK_SIZE + 2;
+     md->mark = ecode + 2;
      RRETURN(MATCH_THEN);
+     /* Handle an atomic group that does not contain any capturing parentheses.
+     This can be handled like an assertion. Prior to 8.13, all atomic groups
+     were handled this way. In 8.13, the code was changed as below for ONCE, so
+     that backups pass through the group and thereby reset captured values.
+     However, this uses a lot more stack, so in 8.20, atomic groups that do not
+     contain any captures generate OP_ONCE_NC, which can be handled in the old,
+     less stack intensive way.
+     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_NC:
+     prev = ecode;
+     saved_eptr = eptr;
+     do
+       {
+       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM64);
+       if (rrc == MATCH_MATCH)  /* Note: _not_ MATCH_ACCEPT */
+         {
+         mstart = md->start_match_ptr;
+         break;
+         }
+       if (rrc == MATCH_THEN)
+         {
+         next = ecode + GET(ecode,1);
+         if (md->start_match_ptr < next &&
+             (*ecode == OP_ALT || *next == OP_ALT))
+           rrc = MATCH_NOMATCH;
+         }
+       if (rrc != MATCH_NOMATCH) 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_NC && *ecode != OP_ALT) RRETURN(MATCH_NOMATCH);
+     /* Continue as from after the group, 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 (*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, RM65);
+       if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+       ecode = prev;
+       goto TAIL_RECURSE;
+       }
+     else  /* OP_KETRMAX */
+       {
+       md->match_function_type = MATCH_CBEGROUP;
+       RMATCH(eptr, prev, offset_top, md, eptrb, RM66);
+       if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+       ecode += 1 + LINK_SIZE;
+       goto TAIL_RECURSE;
+       }
+     /* Control never gets here */
      /* Handle a capturing bracket, other than those that are possessive with an
      unlimited repeat. If there is space in the offset vector, save 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. A failure to match might occur after the group has succeeded,
      if something later on doesn't match. For this reason, we need to restore
      the working value and also the values of the final offsets, in case they
      were set by a previous iteration of the same bracket.
-Line 822 
 for (;;)
+Line 893 
 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 843 
 for (;;)
+Line 914 
 for (;;)
        for (;;)
          {
          if (op >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;
          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))
+         /* If we backed up to a THEN, check whether it is within the current
-           RRETURN(rrc);
+         branch by comparing the address of the THEN that is passed back with
+         the end of the branch. If it is within the current branch, and the
+         branch is one of two or more alternatives (it either starts or ends
+         with OP_ALT), we have reached the limit of THEN's action, so convert
+         the return code to NOMATCH, which will cause normal backtracking to
+         happen from now on. Otherwise, THEN is passed back to an outer
+         alternative. This implements Perl's treatment of parenthesized groups,
+         where a group not containing | does not affect the current alternative,
+         that is, (X) is NOT the same as (X|(*F)). */
+         if (rrc == MATCH_THEN)
+           {
+           next = ecode + GET(ecode,1);
+           if (md->start_match_ptr < next &&
+               (*ecode == OP_ALT || *next == OP_ALT))
+             rrc = MATCH_NOMATCH;
+           }
+         /* Anything other than NOMATCH is passed back. */
+         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
          md->capture_last = save_capture_last;
          ecode += GET(ecode, 1);
          if (*ecode != OP_ALT) break;
          }
        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 == NULL) md->mark = markptr;
+       /* At this point, rrc will be one of MATCH_ONCE or MATCH_NOMATCH. */
-       RRETURN(((rrc == MATCH_ONCE)? MATCH_ONCE:MATCH_NOMATCH));
+       if (md->mark == NULL) md->mark = markptr;
+       RRETURN(rrc);
        }
      /* FALL THROUGH ... Insufficient room for saving captured contents. Treat
-Line 879 
 for (;;)
+Line 969 
 for (;;)
      /* VVVVVVVVVVVVVVVVVVVVVVVVV */
      /* Non-capturing or atomic group, except for possessive with unlimited
-     repeat. Loop for all the alternatives. When we get to the final alternative
+     repeat and ONCE group with no captures. Loop for all the alternatives.
-     within the brackets, we used to return the result of a recursive call to
-     match() whatever happened so it was possible to reduce stack usage by
+     When we get to the final alternative within the brackets, we used to return
-     turning this into a tail recursion, except in the case of a possibly empty
+     the result of a recursive call to match() whatever happened so it was
-     group. However, now that there is the possiblity of (*THEN) occurring in
+     possible to reduce stack usage by turning this into a tail recursion,
-     the final alternative, this optimization is no longer possible.
+     except in the case of a possibly empty group. However, now that there is
+     the possiblity of (*THEN) occurring in the final alternative, this
-     MATCH_ONCE is returned when the end of an atomic group is successfully
+     optimization is no longer always possible.
-     reached, but subsequent matching fails. It passes back up the tree (causing
-     captured values to be reset) until the original atomic group level is
+     We can optimize if we know there are no (*THEN)s in the pattern; at present
+     this is the best that can be done.
+     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. */
-Line 901 
 for (;;)
+Line 996 
 for (;;)
      for (;;)
        {
        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 this is not a possibly empty group, and there are no (*THEN)s in
+       the pattern, and this is the final alternative, optimize as described
+       above. */
+       else if (!md->hasthen && ecode[GET(ecode, 1)] != OP_ALT)
+         {
+         ecode += _pcre_OP_lengths[*ecode];
+         goto TAIL_RECURSE;
+         }
+       /* In all other cases, we have to make another call to match(). */
+       RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, eptrb,
          RM2);
-       if (rrc != MATCH_NOMATCH &&
-           (rrc != MATCH_THEN || md->start_match_ptr != ecode))
+       /* See comment in the code for capturing groups above about handling
-         {
+       THEN. */
+       if (rrc == MATCH_THEN)
+         {
+         next = ecode + GET(ecode,1);
+         if (md->start_match_ptr < next &&
+             (*ecode == OP_ALT || *next == OP_ALT))
+           rrc = MATCH_NOMATCH;
+         }
+       if (rrc != MATCH_NOMATCH)
+         {
          if (rrc == MATCH_ONCE)
            {
            const uschar *scode = ecode;
-Line 913 
 for (;;)
+Line 1032 
 for (;;)
              {
              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;
+     if (md->mark == NULL) md->mark = markptr;
      RRETURN(MATCH_NOMATCH);
      /* 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;
-Line 950 
 for (;;)
+Line 1070 
 for (;;)
      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];
-Line 958 
 for (;;)
+Line 1078 
 for (;;)
        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))
+         /* See comment in the code for capturing groups above about handling
-           RRETURN(rrc);
+         THEN. */
+         if (rrc == MATCH_THEN)
+           {
+           next = ecode + GET(ecode,1);
+           if (md->start_match_ptr < next &&
+               (*ecode == OP_ALT || *next == OP_ALT))
+             rrc = MATCH_NOMATCH;
+           }
+         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
          md->capture_last = save_capture_last;
          ecode += GET(ecode, 1);
          if (*ecode != OP_ALT) break;
          }
        if (!matched_once)
          {
          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 (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. */
-Line 1020 
 for (;;)
+Line 1150 
 for (;;)
      /* 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))
+       /* See comment in the code for capturing groups above about handling
-         RRETURN(rrc);
+       THEN. */
+       if (rrc == MATCH_THEN)
+         {
+         next = ecode + GET(ecode,1);
+         if (md->start_match_ptr < next &&
+             (*ecode == OP_ALT || *next == OP_ALT))
+           rrc = MATCH_NOMATCH;
+         }
+       if (rrc != MATCH_NOMATCH) 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. */
-Line 1079 
 for (;;)
+Line 1219 
 for (;;)
        if (pcre_callout != NULL)
          {
          pcre_callout_block cb;
-         cb.version          = 1;   /* Version 1 of the callout block */
+         cb.version          = 2;   /* Version 1 of the callout block */
          cb.callout_number   = ecode[LINK_SIZE+2];
          cb.offset_vector    = md->offset_vector;
          cb.subject          = (PCRE_SPTR)md->start_subject;
-Line 1091 
 for (;;)
+Line 1231 
 for (;;)
          cb.capture_top      = offset_top/2;
          cb.capture_last     = md->capture_last;
          cb.callout_data     = md->callout_data;
+         cb.mark             = markptr;
          if ((rrc = (*pcre_callout)(&cb)) > 0) MRRETURN(MATCH_NOMATCH);
          if (rrc < 0) RRETURN(rrc);
          }
-Line 1249 
 for (;;)
+Line 1390 
 for (;;)
      else
        {
        md->match_function_type = MATCH_CONDASSERT;
        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);
          }
-       else if (rrc != MATCH_NOMATCH &&
-               (rrc != MATCH_THEN || md->start_match_ptr != ecode))
+       /* PCRE doesn't allow the effect of (*THEN) to escape beyond an
+       assertion; it is therefore treated as NOMATCH. */
+       else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)
          {
          RRETURN(rrc);         /* Need braces because of following else */
          }
-Line 1269 
 for (;;)
+Line 1415 
 for (;;)
          }
        }
-     /* 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, can
-     we used to use tail recursion to avoid using another stack frame, except
+     use tail recursion to avoid using another stack frame, except when there is
-     when there was unlimited repeat of a possibly empty group. However, that
+     unlimited repeat of a possibly empty group. In the latter case, a recursive
-     strategy no longer works because of the possibilty of (*THEN) being
+     call to match() is always required, unless the second alternative doesn't
-     encountered in the branch. A recursive call to match() is always required,
+     exist, in which case we can just plough on. Note that, for compatibility
-     unless the second alternative doesn't exist, in which case we can just
+     with Perl, the | in a conditional group is NOT treated as creating two
-     plough on. */
+     alternatives. If a THEN is encountered in the branch, it propagates out to
+     the enclosing alternative (unless nested in a deeper set of alternatives,
+     of course). */
      if (condition || *ecode == OP_ALT)
        {
-       if (op == OP_SCOND) md->match_function_type = MATCH_CBEGROUP;
+       if (op != OP_SCOND)
+         {
+         ecode += 1 + LINK_SIZE;
+         goto TAIL_RECURSE;
+         }
+       md->match_function_type = MATCH_CBEGROUP;
        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM49);
-       if (rrc == MATCH_THEN && md->start_match_ptr == ecode)
-         rrc = MATCH_NOMATCH;
        RRETURN(rrc);
        }
-     else                         /* Condition false & no alternative */
+      /* Condition false & no alternative; continue after the group. */
+     else
        {
        ecode += 1 + LINK_SIZE;
        }
-Line 1316 
 for (;;)
+Line 1471 
 for (;;)
      break;
-     /* End of the pattern, either real or forced. If we are in a recursion, we
+     /* End of the pattern, either real or forced. */
-     should restore the offsets appropriately, and if it's a top-level
-     recursion, continue from after the call. */
-     case OP_ACCEPT:
-     case OP_ASSERT_ACCEPT:
      case OP_END:
+     case OP_ACCEPT:
- /*
+     case OP_ASSERT_ACCEPT:
-     if (md->recursive != NULL)
-       {
-       recursion_info *rec = md->recursive;
-       md->recursive = rec->prevrec;
-       memmove(md->offset_vector, rec->offset_save,
+     /* If we have matched an empty string, fail if not in an assertion and not
-         rec->saved_max * sizeof(int));
+     in a recursion if either PCRE_NOTEMPTY is set, or if PCRE_NOTEMPTY_ATSTART
-       offset_top = rec->save_offset_top;
-       if (rec->group_num == 0)
-         {
-         ecode = rec->after_call;
-         break;
-         }
-       }
- */
-     /* Otherwise, if we have matched an empty string, fail if not in an
-     assertion and if either PCRE_NOTEMPTY is 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. */
- /*    else */ if (eptr == mstart && op != OP_ASSERT_ACCEPT &&
+     if (eptr == mstart && op != OP_ASSERT_ACCEPT &&
           md->recursive == NULL &&
+          (md->notempty ||
-         (md->notempty ||
+            (md->notempty_atstart &&
-           (md->notempty_atstart &&
+              mstart == md->start_subject + md->start_offset)))
-             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 1371 
 for (;;)
+Line 1505 
 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. 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:
-Line 1385 
 for (;;)
+Line 1519 
 for (;;)
        condassert = TRUE;
        md->match_function_type = 0;
        }
      else condassert = FALSE;
      do
        {
        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, NULL, RM4);
        if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
          {
          mstart = md->start_match_ptr;   /* In case \K reset it */
+         markptr = md->mark;
          break;
          }
-       if (rrc != MATCH_NOMATCH &&
-           (rrc != MATCH_THEN || md->start_match_ptr != ecode))
+       /* PCRE does not allow THEN to escape beyond an assertion; it is treated
-         RRETURN(rrc);
+       as NOMATCH. */
+       if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
        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. */
-Line 1427 
 for (;;)
+Line 1564 
 for (;;)
        condassert = TRUE;
        md->match_function_type = 0;
        }
      else condassert = FALSE;
      do
        {
-Line 1438 
 for (;;)
+Line 1575 
 for (;;)
          do ecode += GET(ecode,1); while (*ecode == OP_ALT);
          break;
          }
-       if (rrc != MATCH_NOMATCH &&
-           (rrc != MATCH_THEN || md->start_match_ptr != ecode))
+       /* PCRE does not allow THEN to escape beyond an assertion; it is treated
-         RRETURN(rrc);
+       as NOMATCH. */
+       if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
        ecode += GET(ecode,1);
        }
      while (*ecode == OP_ALT);
      if (condassert) RRETURN(MATCH_MATCH);  /* Condition assertion */
      ecode += 1 + LINK_SIZE;
      continue;
-Line 1491 
 for (;;)
+Line 1630 
 for (;;)
      if (pcre_callout != NULL)
        {
        pcre_callout_block cb;
-       cb.version          = 1;   /* Version 1 of the callout block */
+       cb.version          = 2;   /* Version 1 of the callout block */
        cb.callout_number   = ecode[1];
        cb.offset_vector    = md->offset_vector;
        cb.subject          = (PCRE_SPTR)md->start_subject;
-Line 1503 
 for (;;)
+Line 1642 
 for (;;)
        cb.capture_top      = offset_top/2;
        cb.capture_last     = md->capture_last;
        cb.callout_data     = md->callout_data;
+       cb.mark             = markptr;
        if ((rrc = (*pcre_callout)(&cb)) > 0) MRRETURN(MATCH_NOMATCH);
        if (rrc < 0) RRETURN(rrc);
        }
-Line 1512 
 for (;;)
+Line 1652 
 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.)
      The state of the capturing groups is preserved over recursion, and
      re-instated afterwards. We don't know how many are started and not yet
      finished (offset_top records the completed total) so we just have to save
      all the potential data. There may be up to 65535 such values, which is too
      large to put on the stack, but using malloc for small numbers seems
-Line 1523 
 for (;;)
+Line 1663 
 for (;;)
      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. It has, however, been hacked around
      a lot, so he is not to blame for the current way it works. */
      case OP_RECURSE:
        {
+       recursion_info *ri;
+       int recno;
        callpat = md->start_code + GET(ecode, 1);
-       new_recursive.group_num = (callpat == md->start_code)? 0 :
+       recno = (callpat == md->start_code)? 0 :
          GET2(callpat, 1 + LINK_SIZE);
+       /* Check for repeating a recursion without advancing the subject pointer.
+       This should catch convoluted mutual recursions. (Some simple cases are
+       caught at compile time.) */
+       for (ri = md->recursive; ri != NULL; ri = ri->prevrec)
+         if (recno == ri->group_num && eptr == ri->subject_position)
+           RRETURN(PCRE_ERROR_RECURSELOOP);
        /* Add to "recursing stack" */
+       new_recursive.group_num = recno;
+       new_recursive.subject_position = eptr;
        new_recursive.prevrec = md->recursive;
        md->recursive = &new_recursive;
-Line 1554 
 for (;;)
+Line 1707 
 for (;;)
          }
        memcpy(new_recursive.offset_save, md->offset_vector,
              new_recursive.saved_max * sizeof(int));
        /* OK, now we can do the recursion. After processing each alternative,
        restore the offset data. If there were nested recursions, md->recursive
        might be changed, so reset it before looping. */
        DPRINTF(("Recursing into group %d\n", new_recursive.group_num));
-Line 1568 
 for (;;)
+Line 1721 
 for (;;)
            md, eptrb, RM6);
          memcpy(md->offset_vector, new_recursive.offset_save,
              new_recursive.saved_max * sizeof(int));
+         md->recursive = new_recursive.prevrec;
          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);
            /* 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))
+         /* PCRE does not allow THEN to escape beyond a recursion; it is treated
+         as NOMATCH. */
+         else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)
            {
            DPRINTF(("Recursion gave error %d\n", rrc));
            if (new_recursive.offset_save != stacksave)
-Line 1603 
 for (;;)
+Line 1759 
 for (;;)
          (pcre_free)(new_recursive.offset_save);
        MRRETURN(MATCH_NOMATCH);
        }
      RECURSION_MATCHED:
      break;
-Line 1619 
 for (;;)
+Line 1775 
 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;
      RMATCH(eptr, next, offset_top, md, eptrb, RM10);
-Line 1627 
 for (;;)
+Line 1783 
 for (;;)
      do next += GET(next, 1); while (*next == OP_ALT);
      ecode = next + 1 + LINK_SIZE;
      break;
      case OP_BRAMINZERO:
      next = ecode + 1;
      do next += GET(next, 1); while (*next == OP_ALT);
-Line 1641 
 for (;;)
+Line 1797 
 for (;;)
      do next += GET(next,1); while (*next == OP_ALT);
      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;
-Line 1656 
 for (;;)
+Line 1812 
 for (;;)
      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. */
-Line 1670 
 for (;;)
+Line 1826 
 for (;;)
        }
      else saved_eptr = NULL;
-     /* If we are at the end of an assertion group, stop matching and return
+     /* If we are at the end of an assertion group or a non-capturing atomic
-     MATCH_MATCH, but record the current high water mark for use by positive
+     group, stop matching and return MATCH_MATCH, but record the current high
-     assertions. We also need to record the match start in case it was changed
+     water mark for use by positive assertions. We also need to record the match
-     by \K. */
+     start in case it was changed by \K. */
-     if (*prev == OP_ASSERT || *prev == OP_ASSERT_NOT ||
+     if ((*prev >= OP_ASSERT && *prev <= OP_ASSERTBACK_NOT) ||
-         *prev == OP_ASSERTBACK || *prev == OP_ASSERTBACK_NOT)
+          *prev == OP_ONCE_NC)
        {
-       md->end_match_ptr = eptr;      /* For ONCE */
+       md->end_match_ptr = eptr;      /* For ONCE_NC */
        md->end_offset_top = offset_top;
        md->start_match_ptr = mstart;
-       MRRETURN(MATCH_MATCH);
+       MRRETURN(MATCH_MATCH);         /* Sets md->mark */
        }
      /* For capturing groups we have to check the group number back at the start
-Line 1717 
 for (;;)
+Line 1873 
 for (;;)
        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] =
-Line 1746 
 for (;;)
+Line 1902 
 for (;;)
      /* For an ordinary 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 5.005. For a non-repeating atomic group, establish a backup point by
+     Perl 5.005. For a non-repeating atomic group that includes captures,
-     processing the rest of the pattern at a lower level. If this results in a
+     establish a backup point by processing the rest of the pattern at a lower
-     NOMATCH return, pass MATCH_ONCE back to the original OP_ONCE level, thereby
+     level. If this results in a NOMATCH return, pass MATCH_ONCE back to the
-     bypassing intermediate backup points, but resetting any captures that
+     original OP_ONCE level, thereby bypassing intermediate backup points, but
-     happened along the way. */
+     resetting any captures that happened along the way. */
      if (*ecode == OP_KET || eptr == saved_eptr)
        {
-Line 1759 
 for (;;)
+Line 1915 
 for (;;)
          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;
        }
      /* OP_KETRPOS is a possessive repeating ket. Remember the current position,
      and return the MATCH_KETRPOS. This makes it possible to do the repeats one
      at a time from the outer level, thus saving stack. */
      if (*ecode == OP_KETRPOS)
        {
        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
-Line 1784 
 for (;;)
+Line 1940 
 for (;;)
      if (*ecode == OP_KETRMIN)
        {
-       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM64);
+       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM7);
        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
        if (*prev == OP_ONCE)
          {
-         RMATCH(eptr, prev, offset_top, md, eptrb, RM66);
+         RMATCH(eptr, prev, offset_top, md, eptrb, RM8);
          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);
          }
-Line 1804 
 for (;;)
+Line 1960 
 for (;;)
        }
      else  /* OP_KETRMAX */
        {
        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);
+         RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM9);
          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
          md->once_target = prev;
          RRETURN(MATCH_ONCE);
          }
        ecode += 1 + LINK_SIZE;
        goto TAIL_RECURSE;
        }
-Line 1824 
 for (;;)
+Line 1980 
 for (;;)
      case OP_CIRC:
      if (md->notbol && eptr == md->start_subject) MRRETURN(MATCH_NOMATCH);
      /* Start of subject assertion */
      case OP_SOD:
      if (eptr != md->start_subject) MRRETURN(MATCH_NOMATCH);
      ecode++;
      break;
      /* Multiline mode: start of subject unless notbol, or after any newline. */
      case OP_CIRCM:
-Line 1870 
 for (;;)
+Line 2026 
 for (;;)
      ecode++;
      break;
      /* Not multiline mode: assert before a terminating newline or before end of
      subject unless noteol is set. */
      case OP_DOLL:
-Line 2026 
 for (;;)
+Line 2182 
 for (;;)
      /* Fall through */
      case OP_ALLANY:
-     if (eptr++ >= md->end_subject)
+     if (eptr >= md->end_subject)   /* DO NOT merge the eptr++ here; it must */
-       {
+       {                            /* not be updated before SCHECK_PARTIAL. */
        SCHECK_PARTIAL();
        MRRETURN(MATCH_NOMATCH);
        }
+     eptr++;
      if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
      ecode++;
      break;
-Line 2039 
 for (;;)
+Line 2196 
 for (;;)
      any byte, even newline, independent of the setting of PCRE_DOTALL. */
      case OP_ANYBYTE:
-     if (eptr++ >= md->end_subject)
+     if (eptr >= md->end_subject)   /* DO NOT merge the eptr++ here; it must */
-       {
+       {                            /* not be updated before SCHECK_PARTIAL. */
        SCHECK_PARTIAL();
        MRRETURN(MATCH_NOMATCH);
        }
+     eptr++;
      ecode++;
      break;
-Line 2159 
 for (;;)
+Line 2317 
 for (;;)
      switch(c)
        {
        default: MRRETURN(MATCH_NOMATCH);
        case 0x000d:
        if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
        break;
-Line 2383 
 for (;;)
+Line 2541 
 for (;;)
        MRRETURN(MATCH_NOMATCH);
        }
      GETCHARINCTEST(c, eptr);
+     if (UCD_CATEGORY(c) == ucp_M) MRRETURN(MATCH_NOMATCH);
+     while (eptr < md->end_subject)
        {
-       int category = UCD_CATEGORY(c);
+       int len = 1;
-       if (category == ucp_M) MRRETURN(MATCH_NOMATCH);
+       if (!utf8) c = *eptr; else { GETCHARLEN(c, eptr, len); }
-       while (eptr < md->end_subject)
+       if (UCD_CATEGORY(c) != ucp_M) break;
-         {
+       eptr += len;
-         int len = 1;
-         if (!utf8) c = *eptr; else
-           {
-           GETCHARLEN(c, eptr, len);
-           }
-         category = UCD_CATEGORY(c);
-         if (category != ucp_M) break;
-         eptr += len;
-         }
        }
      ecode++;
      break;
-Line 2412 
 for (;;)
+Line 2563 
 for (;;)
      loops). */
      case OP_REF:
      case OP_REFI:
      caseless = op == OP_REFI;
      offset = GET2(ecode, 1) << 1;               /* Doubled ref number */
      ecode += 3;
-Line 2481 
 for (;;)
+Line 2632 
 for (;;)
      for (i = 1; i <= min; i++)
        {
        int slength;
        if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
          {
          CHECK_PARTIAL();
-Line 2501 
 for (;;)
+Line 2652 
 for (;;)
        {
        for (fi = min;; fi++)
          {
          int slength;
          RMATCH(eptr, ecode, offset_top, md, eptrb, RM14);
          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
          if (fi >= max) MRRETURN(MATCH_NOMATCH);
-Line 2522 
 for (;;)
+Line 2673 
 for (;;)
        pp = eptr;
        for (i = min; i < max; i++)
          {
          int slength;
          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
            {
            CHECK_PARTIAL();
-Line 3255 
 for (;;)
+Line 3406 
 for (;;)
      checking can be multibyte. */
      case OP_NOT:
      case OP_NOTI:
      if (eptr >= md->end_subject)
        {
        SCHECK_PARTIAL();
-Line 3750 
 for (;;)
+Line 3901 
 for (;;)
            case PT_LAMP:
            for (i = 1; i <= min; i++)
              {
+             int chartype;
              if (eptr >= md->end_subject)
                {
                SCHECK_PARTIAL();
                MRRETURN(MATCH_NOMATCH);
                }
              GETCHARINCTEST(c, eptr);
-             prop_chartype = UCD_CHARTYPE(c);
+             chartype = UCD_CHARTYPE(c);
-             if ((prop_chartype == ucp_Lu ||
+             if ((chartype == ucp_Lu ||
-                  prop_chartype == ucp_Ll ||
+                  chartype == ucp_Ll ||
-                  prop_chartype == ucp_Lt) == prop_fail_result)
+                  chartype == ucp_Lt) == prop_fail_result)
                MRRETURN(MATCH_NOMATCH);
              }
            break;
-Line 3773 
 for (;;)
+Line 3925 
 for (;;)
                MRRETURN(MATCH_NOMATCH);
                }
              GETCHARINCTEST(c, eptr);
-             prop_category = UCD_CATEGORY(c);
+             if ((UCD_CATEGORY(c) == prop_value) == prop_fail_result)
-             if ((prop_category == prop_value) == prop_fail_result)
                MRRETURN(MATCH_NOMATCH);
              }
            break;
-Line 3788 
 for (;;)
+Line 3939 
 for (;;)
                MRRETURN(MATCH_NOMATCH);
                }
              GETCHARINCTEST(c, eptr);
-             prop_chartype = UCD_CHARTYPE(c);
+             if ((UCD_CHARTYPE(c) == prop_value) == prop_fail_result)
-             if ((prop_chartype == prop_value) == prop_fail_result)
                MRRETURN(MATCH_NOMATCH);
              }
            break;
-Line 3803 
 for (;;)
+Line 3953 
 for (;;)
                MRRETURN(MATCH_NOMATCH);
                }
              GETCHARINCTEST(c, eptr);
-             prop_script = UCD_SCRIPT(c);
+             if ((UCD_SCRIPT(c) == prop_value) == prop_fail_result)
-             if ((prop_script == prop_value) == prop_fail_result)
                MRRETURN(MATCH_NOMATCH);
              }
            break;
-Line 3812 
 for (;;)
+Line 3961 
 for (;;)
            case PT_ALNUM:
            for (i = 1; i <= min; i++)
              {
+             int category;
              if (eptr >= md->end_subject)
                {
                SCHECK_PARTIAL();
                MRRETURN(MATCH_NOMATCH);
                }
              GETCHARINCTEST(c, eptr);
-             prop_category = UCD_CATEGORY(c);
+             category = UCD_CATEGORY(c);
-             if ((prop_category == ucp_L || prop_category == ucp_N)
+             if ((category == ucp_L || category == ucp_N) == prop_fail_result)
-                    == prop_fail_result)
                MRRETURN(MATCH_NOMATCH);
              }
            break;
-Line 3834 
 for (;;)
+Line 3983 
 for (;;)
                MRRETURN(MATCH_NOMATCH);
                }
              GETCHARINCTEST(c, eptr);
-             prop_category = UCD_CATEGORY(c);
+             if ((UCD_CATEGORY(c) == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
-             if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
                   c == CHAR_FF || c == CHAR_CR)
                     == prop_fail_result)
                MRRETURN(MATCH_NOMATCH);
-Line 3851 
 for (;;)
+Line 3999 
 for (;;)
                MRRETURN(MATCH_NOMATCH);
                }
              GETCHARINCTEST(c, eptr);
-             prop_category = UCD_CATEGORY(c);
+             if ((UCD_CATEGORY(c) == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
-             if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
                   c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)
                     == prop_fail_result)
                MRRETURN(MATCH_NOMATCH);
-Line 3862 
 for (;;)
+Line 4009 
 for (;;)
            case PT_WORD:
            for (i = 1; i <= min; i++)
              {
+             int category;
              if (eptr >= md->end_subject)
                {
                SCHECK_PARTIAL();
                MRRETURN(MATCH_NOMATCH);
                }
              GETCHARINCTEST(c, eptr);
-             prop_category = UCD_CATEGORY(c);
+             category = UCD_CATEGORY(c);
-             if ((prop_category == ucp_L || prop_category == ucp_N ||
+             if ((category == ucp_L || category == ucp_N || c == CHAR_UNDERSCORE)
-                  c == CHAR_UNDERSCORE)
                     == prop_fail_result)
                MRRETURN(MATCH_NOMATCH);
              }
-Line 3896 
 for (;;)
+Line 4043 
 for (;;)
              MRRETURN(MATCH_NOMATCH);
              }
            GETCHARINCTEST(c, eptr);
-           prop_category = UCD_CATEGORY(c);
+           if (UCD_CATEGORY(c) == ucp_M) MRRETURN(MATCH_NOMATCH);
-           if (prop_category == ucp_M) MRRETURN(MATCH_NOMATCH);
            while (eptr < md->end_subject)
              {
              int len = 1;
-             if (!utf8) c = *eptr;
+             if (!utf8) c = *eptr; else { GETCHARLEN(c, eptr, len); }
-               else { GETCHARLEN(c, eptr, len); }
+             if (UCD_CATEGORY(c) != ucp_M) break;
-             prop_category = UCD_CATEGORY(c);
-             if (prop_category != ucp_M) break;
              eptr += len;
              }
            }
-Line 3962 
 for (;;)
+Line 4106 
 for (;;)
            switch(c)
              {
              default: MRRETURN(MATCH_NOMATCH);
              case 0x000d:
              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
              break;
-Line 4239 
 for (;;)
+Line 4383 
 for (;;)
            switch(*eptr++)
              {
              default: MRRETURN(MATCH_NOMATCH);
              case 0x000d:
              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
              break;
              case 0x000a:
              break;
-Line 4449 
 for (;;)
+Line 4593 
 for (;;)
            case PT_LAMP:
            for (fi = min;; fi++)
              {
+             int chartype;
              RMATCH(eptr, ecode, offset_top, md, eptrb, RM37);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (fi >= max) MRRETURN(MATCH_NOMATCH);
-Line 4458 
 for (;;)
+Line 4603 
 for (;;)
                MRRETURN(MATCH_NOMATCH);
                }
              GETCHARINCTEST(c, eptr);
-             prop_chartype = UCD_CHARTYPE(c);
+             chartype = UCD_CHARTYPE(c);
-             if ((prop_chartype == ucp_Lu ||
+             if ((chartype == ucp_Lu ||
-                  prop_chartype == ucp_Ll ||
+                  chartype == ucp_Ll ||
-                  prop_chartype == ucp_Lt) == prop_fail_result)
+                  chartype == ucp_Lt) == prop_fail_result)
                MRRETURN(MATCH_NOMATCH);
              }
            /* Control never gets here */
-Line 4478 
 for (;;)
+Line 4623 
 for (;;)
                MRRETURN(MATCH_NOMATCH);
                }
              GETCHARINCTEST(c, eptr);
-             prop_category = UCD_CATEGORY(c);
+             if ((UCD_CATEGORY(c) == prop_value) == prop_fail_result)
-             if ((prop_category == prop_value) == prop_fail_result)
                MRRETURN(MATCH_NOMATCH);
              }
            /* Control never gets here */
-Line 4496 
 for (;;)
+Line 4640 
 for (;;)
                MRRETURN(MATCH_NOMATCH);
                }
              GETCHARINCTEST(c, eptr);
-             prop_chartype = UCD_CHARTYPE(c);
+             if ((UCD_CHARTYPE(c) == prop_value) == prop_fail_result)
-             if ((prop_chartype == prop_value) == prop_fail_result)
                MRRETURN(MATCH_NOMATCH);
              }
            /* Control never gets here */
-Line 4514 
 for (;;)
+Line 4657 
 for (;;)
                MRRETURN(MATCH_NOMATCH);
                }
              GETCHARINCTEST(c, eptr);
-             prop_script = UCD_SCRIPT(c);
+             if ((UCD_SCRIPT(c) == prop_value) == prop_fail_result)
-             if ((prop_script == prop_value) == prop_fail_result)
                MRRETURN(MATCH_NOMATCH);
              }
            /* Control never gets here */
-Line 4523 
 for (;;)
+Line 4665 
 for (;;)
            case PT_ALNUM:
            for (fi = min;; fi++)
              {
+             int category;
              RMATCH(eptr, ecode, offset_top, md, eptrb, RM59);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (fi >= max) MRRETURN(MATCH_NOMATCH);
-Line 4532 
 for (;;)
+Line 4675 
 for (;;)
                MRRETURN(MATCH_NOMATCH);
                }
              GETCHARINCTEST(c, eptr);
-             prop_category = UCD_CATEGORY(c);
+             category = UCD_CATEGORY(c);
-             if ((prop_category == ucp_L || prop_category == ucp_N)
+             if ((category == ucp_L || category == ucp_N) == prop_fail_result)
-                    == prop_fail_result)
                MRRETURN(MATCH_NOMATCH);
              }
            /* Control never gets here */
-Line 4551 
 for (;;)
+Line 4693 
 for (;;)
                MRRETURN(MATCH_NOMATCH);
                }
              GETCHARINCTEST(c, eptr);
-             prop_category = UCD_CATEGORY(c);
+             if ((UCD_CATEGORY(c) == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
-             if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
                   c == CHAR_FF || c == CHAR_CR)
                     == prop_fail_result)
                MRRETURN(MATCH_NOMATCH);
-Line 4571 
 for (;;)
+Line 4712 
 for (;;)
                MRRETURN(MATCH_NOMATCH);
                }
              GETCHARINCTEST(c, eptr);
-             prop_category = UCD_CATEGORY(c);
+             if ((UCD_CATEGORY(c) == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
-             if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
                   c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)
                     == prop_fail_result)
                MRRETURN(MATCH_NOMATCH);
-Line 4582 
 for (;;)
+Line 4722 
 for (;;)
            case PT_WORD:
            for (fi = min;; fi++)
              {
+             int category;
              RMATCH(eptr, ecode, offset_top, md, eptrb, RM62);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (fi >= max) MRRETURN(MATCH_NOMATCH);
-Line 4591 
 for (;;)
+Line 4732 
 for (;;)
                MRRETURN(MATCH_NOMATCH);
                }
              GETCHARINCTEST(c, eptr);
-             prop_category = UCD_CATEGORY(c);
+             category = UCD_CATEGORY(c);
-             if ((prop_category == ucp_L ||
+             if ((category == ucp_L ||
-                  prop_category == ucp_N ||
+                  category == ucp_N ||
                   c == CHAR_UNDERSCORE)
                     == prop_fail_result)
                MRRETURN(MATCH_NOMATCH);
-Line 4623 
 for (;;)
+Line 4764 
 for (;;)
              MRRETURN(MATCH_NOMATCH);
              }
            GETCHARINCTEST(c, eptr);
-           prop_category = UCD_CATEGORY(c);
+           if (UCD_CATEGORY(c) == ucp_M) MRRETURN(MATCH_NOMATCH);
-           if (prop_category == ucp_M) MRRETURN(MATCH_NOMATCH);
            while (eptr < md->end_subject)
              {
              int len = 1;
-             if (!utf8) c = *eptr;
+             if (!utf8) c = *eptr; else { GETCHARLEN(c, eptr, len); }
-               else { GETCHARLEN(c, eptr, len); }
+             if (UCD_CATEGORY(c) != ucp_M) break;
-             prop_category = UCD_CATEGORY(c);
-             if (prop_category != ucp_M) break;
              eptr += len;
              }
            }
          }
        else
  #endif     /* SUPPORT_UCP */
-Line 4957 
 for (;;)
+Line 5094 
 for (;;)
            case PT_LAMP:
            for (i = min; i < max; i++)
              {
+             int chartype;
              int len = 1;
              if (eptr >= md->end_subject)
                {
-Line 4964 
 for (;;)
+Line 5102 
 for (;;)
                break;
                }
              GETCHARLENTEST(c, eptr, len);
-             prop_chartype = UCD_CHARTYPE(c);
+             chartype = UCD_CHARTYPE(c);
-             if ((prop_chartype == ucp_Lu ||
+             if ((chartype == ucp_Lu ||
-                  prop_chartype == ucp_Ll ||
+                  chartype == ucp_Ll ||
-                  prop_chartype == ucp_Lt) == prop_fail_result)
+                  chartype == ucp_Lt) == prop_fail_result)
                break;
              eptr+= len;
              }
-Line 4983 
 for (;;)
+Line 5121 
 for (;;)
                break;
                }
              GETCHARLENTEST(c, eptr, len);
-             prop_category = UCD_CATEGORY(c);
+             if ((UCD_CATEGORY(c) == prop_value) == prop_fail_result) break;
-             if ((prop_category == prop_value) == prop_fail_result)
-               break;
              eptr+= len;
              }
            break;
-Line 5000 
 for (;;)
+Line 5136 
 for (;;)
                break;
                }
              GETCHARLENTEST(c, eptr, len);
-             prop_chartype = UCD_CHARTYPE(c);
+             if ((UCD_CHARTYPE(c) == prop_value) == prop_fail_result) break;
-             if ((prop_chartype == prop_value) == prop_fail_result)
-               break;
              eptr+= len;
              }
            break;
-Line 5017 
 for (;;)
+Line 5151 
 for (;;)
                break;
                }
              GETCHARLENTEST(c, eptr, len);
-             prop_script = UCD_SCRIPT(c);
+             if ((UCD_SCRIPT(c) == prop_value) == prop_fail_result) break;
-             if ((prop_script == prop_value) == prop_fail_result)
-               break;
              eptr+= len;
              }
            break;
-Line 5027 
 for (;;)
+Line 5159 
 for (;;)
            case PT_ALNUM:
            for (i = min; i < max; i++)
              {
+             int category;
              int len = 1;
              if (eptr >= md->end_subject)
                {
-Line 5034 
 for (;;)
+Line 5167 
 for (;;)
                break;
                }
              GETCHARLENTEST(c, eptr, len);
-             prop_category = UCD_CATEGORY(c);
+             category = UCD_CATEGORY(c);
-             if ((prop_category == ucp_L || prop_category == ucp_N)
+             if ((category == ucp_L || category == ucp_N) == prop_fail_result)
-                  == prop_fail_result)
                break;
              eptr+= len;
              }
-Line 5052 
 for (;;)
+Line 5184 
 for (;;)
                break;
                }
              GETCHARLENTEST(c, eptr, len);
-             prop_category = UCD_CATEGORY(c);
+             if ((UCD_CATEGORY(c) == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
-             if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
                   c == CHAR_FF || c == CHAR_CR)
                   == prop_fail_result)
                break;
-Line 5071 
 for (;;)
+Line 5202 
 for (;;)
                break;
                }
              GETCHARLENTEST(c, eptr, len);
-             prop_category = UCD_CATEGORY(c);
+             if ((UCD_CATEGORY(c) == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
-             if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
                   c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)
                   == prop_fail_result)
                break;
-Line 5083 
 for (;;)
+Line 5213 
 for (;;)
            case PT_WORD:
            for (i = min; i < max; i++)
              {
+             int category;
              int len = 1;
              if (eptr >= md->end_subject)
                {
-Line 5090 
 for (;;)
+Line 5221 
 for (;;)
                break;
                }
              GETCHARLENTEST(c, eptr, len);
-             prop_category = UCD_CATEGORY(c);
+             category = UCD_CATEGORY(c);
-             if ((prop_category == ucp_L || prop_category == ucp_N ||
+             if ((category == ucp_L || category == ucp_N ||
                   c == CHAR_UNDERSCORE) == prop_fail_result)
                break;
              eptr+= len;
-Line 5121 
 for (;;)
+Line 5252 
 for (;;)
          {
          for (i = min; i < max; i++)
            {
+           int len = 1;
            if (eptr >= md->end_subject)
              {
              SCHECK_PARTIAL();
              break;
              }
-           GETCHARINCTEST(c, eptr);
+           if (!utf8) c = *eptr; else { GETCHARLEN(c, eptr, len); }
-           prop_category = UCD_CATEGORY(c);
+           if (UCD_CATEGORY(c) == ucp_M) break;
-           if (prop_category == ucp_M) break;
+           eptr += len;
            while (eptr < md->end_subject)
              {
-             int len = 1;
+             len = 1;
-             if (!utf8) c = *eptr; else
+             if (!utf8) c = *eptr; else { GETCHARLEN(c, eptr, len); }
-               {
+             if (UCD_CATEGORY(c) != ucp_M) break;
-               GETCHARLEN(c, eptr, len);
-               }
-             prop_category = UCD_CATEGORY(c);
-             if (prop_category != ucp_M) break;
              eptr += len;
              }
            }
-Line 5153 
 for (;;)
+Line 5281 
 for (;;)
            if (eptr-- == pp) break;        /* Stop if tried at original pos */
            for (;;)                        /* Move back over one extended */
              {
-             int len = 1;
              if (!utf8) c = *eptr; else
                {
                BACKCHAR(eptr);
-               GETCHARLEN(c, eptr, len);
+               GETCHAR(c, eptr);
                }
-             prop_category = UCD_CATEGORY(c);
+             if (UCD_CATEGORY(c) != ucp_M) break;
-             if (prop_category != ucp_M) break;
              eptr--;
              }
            }
-Line 5224 
 for (;;)
+Line 5350 
 for (;;)
                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
                }
              }
-           else eptr = md->end_subject;   /* Unlimited UTF-8 repeat */
+           else
+             {
+             eptr = md->end_subject;   /* Unlimited UTF-8 repeat */
+             SCHECK_PARTIAL();
+             }
            break;
            /* The byte case is the same as non-UTF8 */
-Line 5445 
 for (;;)
+Line 5575 
 for (;;)
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (eptr-- == pp) break;        /* Stop if tried at original pos */
            BACKCHAR(eptr);
            if (ctype == OP_ANYNL && eptr > pp  && *eptr == '\n' &&
                eptr[-1] == '\r') eptr--;
            }
          }
-Line 5657 
 for (;;)
+Line 5787 
 for (;;)
            RMATCH(eptr, ecode, offset_top, md, eptrb, RM47);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            eptr--;
            if (ctype == OP_ANYNL && eptr > pp  && *eptr == '\n' &&
                eptr[-1] == '\r') eptr--;
            }
          }
-Line 5698 
 switch (frame->Xwhere)
+Line 5828 
 switch (frame->Xwhere)
    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(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 5800 
 pcre_exec(const pcre *argument_re, const
+Line 5930 
 pcre_exec(const pcre *argument_re, const
    PCRE_SPTR subject, int length, int start_offset, int options, int *offsets,
    int offsetcount)
  {
- int rc, ocount;
+ int rc, ocount, arg_offset_max;
  int first_byte = -1;
  int req_byte = -1;
  int req_byte2 = -1;
-Line 5836 
 if (re == NULL || subject == NULL ||
+Line 5966 
 if (re == NULL || subject == NULL ||
  if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;
  if (start_offset < 0 || start_offset > length) return PCRE_ERROR_BADOFFSET;
- /* This information is for finding all the numbers associated with a given
+ /* These two settings are used in the code for checking a UTF-8 string that
- name, for condition testing. */
+ follows immediately afterwards. Other values in the md block are used only
+ during "normal" pcre_exec() processing, not when the JIT support is in use,
+ so they are set up later. */
+ utf8 = md->utf8 = (re->options & PCRE_UTF8) != 0;
+ md->partial = ((options & PCRE_PARTIAL_HARD) != 0)? 2 :
+               ((options & PCRE_PARTIAL_SOFT) != 0)? 1 : 0;
+ /* Check a UTF-8 string if required. Pass back the character offset and error
+ code for an invalid string if a results vector is available. */
+ #ifdef SUPPORT_UTF8
+ if (utf8 && (options & PCRE_NO_UTF8_CHECK) == 0)
+   {
+   int erroroffset;
+   int errorcode = _pcre_valid_utf8((USPTR)subject, length, &erroroffset);
+   if (errorcode != 0)
+     {
+     if (offsetcount >= 2)
+       {
+       offsets[0] = erroroffset;
+       offsets[1] = errorcode;
+       }
+     return (errorcode <= PCRE_UTF8_ERR5 && md->partial > 1)?
+       PCRE_ERROR_SHORTUTF8 : PCRE_ERROR_BADUTF8;
+     }
+   /* Check that a start_offset points to the start of a UTF-8 character. */
+   if (start_offset > 0 && start_offset < length &&
+       (((USPTR)subject)[start_offset] & 0xc0) == 0x80)
+     return PCRE_ERROR_BADUTF8_OFFSET;
+   }
+ #endif
+ /* If the pattern was successfully studied with JIT support, run the JIT
+ executable instead of the rest of this function. Most options must be set at
+ compile time for the JIT code to be usable. Fallback to the normal code path if
+ an unsupported flag is set. In particular, JIT does not support partial
+ matching. */
+ #ifdef SUPPORT_JIT
+ if (extra_data != NULL
+     && (extra_data->flags & PCRE_EXTRA_EXECUTABLE_JIT) != 0
+     && extra_data->executable_jit != NULL
+     && (options & ~(PCRE_NO_UTF8_CHECK | PCRE_NOTBOL | PCRE_NOTEOL |
+                     PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART)) == 0)
+   return _pcre_jit_exec(re, extra_data->executable_jit, subject, length,
+     start_offset, options, ((extra_data->flags & PCRE_EXTRA_MATCH_LIMIT) == 0)
+     ? MATCH_LIMIT : extra_data->match_limit, offsets, offsetcount);
+ #endif
+ /* Carry on with non-JIT matching. This information is for finding all the
+ numbers associated with a given name, for condition testing. */
  md->name_table = (uschar *)re + re->name_table_offset;
  md->name_count = re->name_count;
-Line 5904 
 md->end_subject = md->start_subject + le
+Line 6086 
 md->end_subject = md->start_subject + le
  end_subject = md->end_subject;
  md->endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;
- utf8 = md->utf8 = (re->options & PCRE_UTF8) != 0;
  md->use_ucp = (re->options & PCRE_UCP) != 0;
  md->jscript_compat = (re->options & PCRE_JAVASCRIPT_COMPAT) != 0;
-Line 5915 
 md->notbol = (options & PCRE_NOTBOL) !=
+Line 6096 
 md->notbol = (options & PCRE_NOTBOL) !=
  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 */
  md->recursive = NULL;                   /* No recursion at top level */
+ md->hasthen = (re->flags & PCRE_HASTHEN) != 0;
  md->lcc = tables + lcc_offset;
  md->ctypes = tables + ctypes_offset;
-Line 6000 
 defined (though never set). So there's n
+Line 6179 
 defined (though never set). So there's n
  if (md->partial && (re->flags & PCRE_NOPARTIAL) != 0)
    return PCRE_ERROR_BADPARTIAL;
- /* Check a UTF-8 string if required. Pass back the character offset and error
- code for an invalid string if a results vector is available. */
- #ifdef SUPPORT_UTF8
- if (utf8 && (options & PCRE_NO_UTF8_CHECK) == 0)
-   {
-   int erroroffset;
-   int errorcode = _pcre_valid_utf8((USPTR)subject, length, &erroroffset);
-   if (errorcode != 0)
-     {
-     if (offsetcount >= 2)
-       {
-       offsets[0] = erroroffset;
-       offsets[1] = errorcode;
-       }
-     return (errorcode <= PCRE_UTF8_ERR5 && md->partial > 1)?
-       PCRE_ERROR_SHORTUTF8 : PCRE_ERROR_BADUTF8;
-     }
-   /* Check that a start_offset points to the start of a UTF-8 character. */
-   if (start_offset > 0 && start_offset < length &&
-       (((USPTR)subject)[start_offset] & 0xc0) == 0x80)
-     return PCRE_ERROR_BADUTF8_OFFSET;
-   }
- #endif
  /* If the expression has got more back references than the offsets supplied can
  hold, we get a temporary chunk of working store to use during the matching.
  Otherwise, we can use the vector supplied, rounding down its size to a multiple
  of 3. */
  ocount = offsetcount - (offsetcount % 3);
+ arg_offset_max = (2*ocount)/3;
  if (re->top_backref > 0 && re->top_backref >= ocount/3)
    {
-Line 6212 
 for(;;)
+Line 6365 
 for(;;)
    /* The following two optimizations are disabled for partial matching or if
    disabling is explicitly requested. */
-   if ((options & PCRE_NO_START_OPTIMIZE) == 0 && !md->partial)
+   if (((options | re->options) & PCRE_NO_START_OPTIMIZE) == 0 && !md->partial)
      {
      /* If the pattern was studied, a minimum subject length may be set. This is
      a lower bound; no actual string of that length may actually match the
-Line 6295 
 for(;;)
+Line 6448 
 for(;;)
    md->start_match_ptr = start_match;
    md->start_used_ptr = start_match;
    md->match_call_count = 0;
    md->match_function_type = 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;
-Line 6407 
 if (rc == MATCH_MATCH || rc == MATCH_ACC
+Line 6560 
 if (rc == MATCH_MATCH || rc == MATCH_ACC
    {
    if (using_temporary_offsets)
      {
-     if (offsetcount >= 4)
+     if (arg_offset_max >= 4)
        {
        memcpy(offsets + 2, md->offset_vector + 2,
-         (offsetcount - 2) * sizeof(int));
+         (arg_offset_max - 2) * sizeof(int));
        DPRINTF(("Copied offsets from temporary memory\n"));
        }
-     if (md->end_offset_top > offsetcount) md->offset_overflow = TRUE;
+     if (md->end_offset_top > arg_offset_max) 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
+   /* Set the return code to the number of captured strings, or 0 if there were
    too many to fit into the vector. */
-   rc = md->offset_overflow? 0 : md->end_offset_top/2;
+   rc = (md->offset_overflow && md->end_offset_top >= arg_offset_max)?
+: md->end_offset_top/2;
+   /* If there is space in the offset vector, set any unused pairs at the end of
+   the pattern to -1 for backwards compatibility. It is documented that this
+   happens. In earlier versions, the whole set of potential capturing offsets
+   was set to -1 each time round the loop, but this is handled differently now.
+   "Gaps" are set to -1 dynamically instead (this fixes a bug). Thus, it is only
+   those at the end that need unsetting here. We can't just unset them all at
+   the start of the whole thing because they may get set in one branch that is
+   not the final matching branch. */
+   if (md->end_offset_top/2 <= re->top_bracket && offsets != NULL)
+     {
+     register int *iptr, *iend;
+     int resetcount = 2 + re->top_bracket * 2;
+     if (resetcount > offsetcount) resetcount = ocount;
+     iptr = offsets + md->end_offset_top;
+     iend = offsets + resetcount;
+     while (iptr < iend) *iptr++ = -1;
+     }
    /* If there is space, set up the whole thing as substring 0. The value of
    md->start_match_ptr might be modified if \K was encountered on the success

 Legend:



Removed from v.618
 


changed lines


 
Added in v.733
 Legend:



Removed from v.618
 


changed lines


 
Added in v.733
-Removed from v.618
+Added in v.733

webmaster@exim.org	ViewVC Help
Powered by ViewVC 1.1.12