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

Diff of /code/trunk/pcre_exec.c

Parent Directory | Revision Log | View Patch Patch

-revision 728 by ph10,
Mon Oct 10 16:01:03 2011 UTC
+revision 733 by ph10,
Tue Oct 11 10:29:36 2011 UTC
 Line 787 
 for (;;)
      MRRETURN(MATCH_THEN);
      case OP_THEN_ARG:
      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top,
        md, eptrb, RM58);
      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
      md->start_match_ptr = ecode;
      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
 Line 821 
 for (;;)
        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);
        }
 Line 867 
 for (;;)
        }
      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;
 Line 918 
 for (;;)
          RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
            eptrb, RM1);
          if (rrc == MATCH_ONCE) break;  /* Backing up through an atomic group */
          /* If we backed up to a THEN, check whether it is within the current
          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);
 Line 1011 
 for (;;)
        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, eptrb,
          RM2);
        /* 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)
            {
 Line 1040 
 for (;;)
        ecode += GET(ecode, 1);
        if (*ecode != OP_ALT) break;
        }
      if (md->mark == NULL) md->mark = markptr;
      RRETURN(MATCH_NOMATCH);
 Line 1104 
 for (;;)
            matched_once = TRUE;
            continue;
            }
          /* 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) RRETURN(rrc);
          md->capture_last = save_capture_last;
 Line 1176 
 for (;;)
          matched_once = TRUE;
          continue;
          }
        /* 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) RRETURN(rrc);
        ecode += GET(ecode, 1);
 Line 1400 
 for (;;)
          ecode += 1 + LINK_SIZE + GET(ecode, LINK_SIZE + 2);
          while (*ecode == OP_ALT) ecode += GET(ecode, 1);
          }
        /* 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 1432 
 for (;;)
          ecode += 1 + LINK_SIZE;
          goto TAIL_RECURSE;
          }
        md->match_function_type = MATCH_CBEGROUP;
        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM49);
        RRETURN(rrc);
 Line 1530 
 for (;;)
          markptr = md->mark;
          break;
          }
        /* PCRE does not allow THEN to escape beyond an assertion; it is treated
        as NOMATCH. */
        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
        ecode += GET(ecode, 1);
        }
 Line 1576 
 for (;;)
          break;
          }
        /* PCRE does not allow THEN to escape beyond an assertion; it is treated
        as NOMATCH. */
        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
 Line 1740 
 for (;;)
          /* 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 1826 
 for (;;)
        }
      else saved_eptr = NULL;
      /* If we are at the end of an assertion group or a non-capturing atomic
      group, stop matching and return MATCH_MATCH, but record the current high
      water mark for use by positive assertions. We also need to record the match
      start in case it was changed by \K. */
      if ((*prev >= OP_ASSERT && *prev <= OP_ASSERTBACK_NOT) ||
           *prev == OP_ONCE_NC)
        {
        md->end_match_ptr = eptr;      /* For ONCE_NC */
        md->end_offset_top = offset_top;
 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)

 Legend:



Removed from v.728
 


changed lines


 
Added in v.733
 Legend:



Removed from v.728
 


changed lines


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

webmaster@exim.org	ViewVC Help
Powered by ViewVC 1.1.12