/[pcre]/code/trunk/pcre_dfa_exec.c
ViewVC logotype

Diff of /code/trunk/pcre_dfa_exec.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 602 by ph10, Wed May 25 08:29:03 2011 UTC revision 604 by ph10, Thu Jun 2 19:04:54 2011 UTC
# Line 158  static const uschar coptable[] = { Line 158  static const uschar coptable[] = {
158    0,                             /* Ket                                    */    0,                             /* Ket                                    */
159    0,                             /* KetRmax                                */    0,                             /* KetRmax                                */
160    0,                             /* KetRmin                                */    0,                             /* KetRmin                                */
161      0,                             /* KetRpos                                */
162    0,                             /* Assert                                 */    0,                             /* Assert                                 */
163    0,                             /* Assert not                             */    0,                             /* Assert not                             */
164    0,                             /* Assert behind                          */    0,                             /* Assert behind                          */
165    0,                             /* Assert behind not                      */    0,                             /* Assert behind not                      */
166    0,                             /* Reverse                                */    0,                             /* Reverse                                */
167    0, 0, 0, 0,                    /* ONCE, BRA, CBRA, COND                  */    0, 0, 0, 0, 0, 0,              /* ONCE, BRA, BRAPOS, CBRA, CBRAPOS, COND */
168    0, 0, 0,                       /* SBRA, SCBRA, SCOND                     */    0, 0, 0, 0, 0,                 /* SBRA, SBRAPOS, SCBRA, SCBRAPOS, SCOND  */
169    0, 0,                          /* CREF, NCREF                            */    0, 0,                          /* CREF, NCREF                            */
170    0, 0,                          /* RREF, NRREF                            */    0, 0,                          /* RREF, NRREF                            */
171    0,                             /* DEF                                    */    0,                             /* DEF                                    */
172    0, 0,                          /* BRAZERO, BRAMINZERO                    */    0, 0, 0,                       /* BRAZERO, BRAMINZERO, BRAPOSZERO        */
173    0, 0, 0,                       /* MARK, PRUNE, PRUNE_ARG,                */    0, 0, 0,                       /* MARK, PRUNE, PRUNE_ARG,                */
174    0, 0, 0, 0,                    /* SKIP, SKIP_ARG, THEN, THEN_ARG,        */    0, 0, 0, 0,                    /* SKIP, SKIP_ARG, THEN, THEN_ARG,        */
175    0, 0, 0, 0, 0                  /* COMMIT, FAIL, ACCEPT, CLOSE, SKIPZERO  */    0, 0, 0, 0, 0                  /* COMMIT, FAIL, ACCEPT, CLOSE, SKIPZERO  */
# Line 224  static const uschar poptable[] = { Line 225  static const uschar poptable[] = {
225    0,                             /* Ket                                    */    0,                             /* Ket                                    */
226    0,                             /* KetRmax                                */    0,                             /* KetRmax                                */
227    0,                             /* KetRmin                                */    0,                             /* KetRmin                                */
228      0,                             /* KetRpos                                */
229    0,                             /* Assert                                 */    0,                             /* Assert                                 */
230    0,                             /* Assert not                             */    0,                             /* Assert not                             */
231    0,                             /* Assert behind                          */    0,                             /* Assert behind                          */
232    0,                             /* Assert behind not                      */    0,                             /* Assert behind not                      */
233    0,                             /* Reverse                                */    0,                             /* Reverse                                */
234    0, 0, 0, 0,                    /* ONCE, BRA, CBRA, COND                  */    0, 0, 0, 0, 0, 0,              /* ONCE, BRA, BRAPOS, CBRA, CBRAPOS, COND */
235    0, 0, 0,                       /* SBRA, SCBRA, SCOND                     */    0, 0, 0, 0, 0,                 /* SBRA, SBRAPOS, SCBRA, SCBRAPOS, SCOND  */
236    0, 0,                          /* CREF, NCREF                            */    0, 0,                          /* CREF, NCREF                            */
237    0, 0,                          /* RREF, NRREF                            */    0, 0,                          /* RREF, NRREF                            */
238    0,                             /* DEF                                    */    0,                             /* DEF                                    */
239    0, 0,                          /* BRAZERO, BRAMINZERO                    */    0, 0, 0,                       /* BRAZERO, BRAMINZERO, BRAPOSZERO        */
240    0, 0, 0,                       /* MARK, PRUNE, PRUNE_ARG,                */    0, 0, 0,                       /* MARK, PRUNE, PRUNE_ARG,                */
241    0, 0, 0, 0,                    /* SKIP, SKIP_ARG, THEN, THEN_ARG,        */    0, 0, 0, 0,                    /* SKIP, SKIP_ARG, THEN, THEN_ARG,        */
242    0, 0, 0, 0, 0                  /* COMMIT, FAIL, ACCEPT, CLOSE, SKIPZERO  */    0, 0, 0, 0, 0                  /* COMMIT, FAIL, ACCEPT, CLOSE, SKIPZERO  */
# Line 435  next_new_state = new_states = active_sta Line 437  next_new_state = new_states = active_sta
437  new_count = 0;  new_count = 0;
438    
439  first_op = this_start_code + 1 + LINK_SIZE +  first_op = this_start_code + 1 + LINK_SIZE +
440    ((*this_start_code == OP_CBRA || *this_start_code == OP_SCBRA)? 2:0);    ((*this_start_code == OP_CBRA || *this_start_code == OP_SCBRA ||
441        *this_start_code == OP_CBRAPOS || *this_start_code == OP_SCBRAPOS)? 2:0);
442    
443  /* The first thing in any (sub) pattern is a bracket of some sort. Push all  /* The first thing in any (sub) pattern is a bracket of some sort. Push all
444  the alternative states onto the list, and find out where the end is. This  the alternative states onto the list, and find out where the end is. This
# Line 534  else Line 537  else
537    else    else
538      {      {
539      int length = 1 + LINK_SIZE +      int length = 1 + LINK_SIZE +
540        ((*this_start_code == OP_CBRA || *this_start_code == OP_SCBRA)? 2:0);        ((*this_start_code == OP_CBRA || *this_start_code == OP_SCBRA ||
541            *this_start_code == OP_CBRAPOS || *this_start_code == OP_SCBRAPOS)?
542            2:0);
543      do      do
544        {        {
545        ADD_NEW((int)(end_code - start_code + length), 0);        ADD_NEW((int)(end_code - start_code + length), 0);
# Line 731  for (;;) Line 736  for (;;)
736    
737  /* ========================================================================== */  /* ========================================================================== */
738        /* Reached a closing bracket. If not at the end of the pattern, carry        /* Reached a closing bracket. If not at the end of the pattern, carry
739        on with the next opcode. Otherwise, unless we have an empty string and        on with the next opcode. For repeating opcodes, also add the repeat
740          state. Note that KETRPOS will always be encountered at the end of the
741          subpattern, because the possessive subpattern repeats are always handled
742          using recursive calls. Thus, it never adds any new states.
743    
744          At the end of the (sub)pattern, unless we have an empty string and
745        PCRE_NOTEMPTY is set, or PCRE_NOTEMPTY_ATSTART is set and we are at the        PCRE_NOTEMPTY is set, or PCRE_NOTEMPTY_ATSTART is set and we are at the
746        start of the subject, save the match data, shifting up all previous        start of the subject, save the match data, shifting up all previous
747        matches so we always have the longest first. */        matches so we always have the longest first. */
# Line 739  for (;;) Line 749  for (;;)
749        case OP_KET:        case OP_KET:
750        case OP_KETRMIN:        case OP_KETRMIN:
751        case OP_KETRMAX:        case OP_KETRMAX:
752          case OP_KETRPOS:
753        if (code != end_code)        if (code != end_code)
754          {          {
755          ADD_ACTIVE(state_offset + 1 + LINK_SIZE, 0);          ADD_ACTIVE(state_offset + 1 + LINK_SIZE, 0);
# Line 2667  for (;;) Line 2678  for (;;)
2678        break;        break;
2679    
2680        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
2681          case OP_BRAPOS:
2682          case OP_SBRAPOS:
2683          case OP_CBRAPOS:
2684          case OP_SCBRAPOS:
2685          case OP_BRAPOSZERO:
2686            {
2687            int charcount, matched_count;
2688            const uschar *local_ptr = ptr;
2689            BOOL allow_zero;
2690    
2691            if (codevalue == OP_BRAPOSZERO)
2692              {
2693              allow_zero = TRUE;
2694              codevalue = *(++code);  /* Codevalue will be one of above BRAs */
2695              }
2696            else allow_zero = FALSE;
2697    
2698            /* Loop to match the subpattern as many times as possible as if it were
2699            a complete pattern. */
2700    
2701            for (matched_count = 0;; matched_count++)
2702              {
2703              int local_offsets[2];
2704              int local_workspace[1000];
2705    
2706              int rc = internal_dfa_exec(
2707                md,                                   /* fixed match data */
2708                code,                                 /* this subexpression's code */
2709                local_ptr,                            /* where we currently are */
2710                (int)(ptr - start_subject),           /* start offset */
2711                local_offsets,                        /* offset vector */
2712                sizeof(local_offsets)/sizeof(int),    /* size of same */
2713                local_workspace,                      /* workspace vector */
2714                sizeof(local_workspace)/sizeof(int),  /* size of same */
2715                rlevel,                               /* function recursion level */
2716                recursing);                           /* pass on regex recursion */
2717    
2718              /* Failed to match */
2719    
2720              if (rc < 0)
2721                {
2722                if (rc != PCRE_ERROR_NOMATCH) return rc;
2723                break;
2724                }
2725    
2726              /* Matched: break the loop if zero characters matched. */
2727    
2728              charcount = local_offsets[1] - local_offsets[0];
2729              if (charcount == 0) break;
2730              local_ptr += charcount;    /* Advance temporary position ptr */
2731              }
2732    
2733            /* At this point we have matched the subpattern matched_count
2734            times, and local_ptr is pointing to the character after the end of the
2735            last match. */
2736    
2737            if (matched_count > 0 || allow_zero)
2738              {
2739              const uschar *end_subpattern = code;
2740              int next_state_offset;
2741    
2742              do { end_subpattern += GET(end_subpattern, 1); }
2743                while (*end_subpattern == OP_ALT);
2744              next_state_offset =
2745                (int)(end_subpattern - start_code + LINK_SIZE + 1);
2746    
2747              /* Optimization: if there are no more active states, and there
2748              are no new states yet set up, then skip over the subject string
2749              right here, to save looping. Otherwise, set up the new state to swing
2750              into action when the end of the matched substring is reached. */
2751    
2752              if (i + 1 >= active_count && new_count == 0)
2753                {
2754                ptr = local_ptr;
2755                clen = 0;
2756                ADD_NEW(next_state_offset, 0);
2757                }
2758              else
2759                {
2760                const uschar *p = ptr;
2761                const uschar *pp = local_ptr;
2762                charcount = pp - p;
2763                while (p < pp) if ((*p++ & 0xc0) == 0x80) charcount--;
2764                ADD_NEW_DATA(-next_state_offset, 0, (charcount - 1));
2765                }
2766              }
2767            }
2768          break;
2769    
2770          /*-----------------------------------------------------------------*/
2771        case OP_ONCE:        case OP_ONCE:
2772          {          {
2773          int local_offsets[2];          int local_offsets[2];
# Line 2716  for (;;) Line 2817  for (;;)
2817            /* Optimization: if there are no more active states, and there            /* Optimization: if there are no more active states, and there
2818            are no new states yet set up, then skip over the subject string            are no new states yet set up, then skip over the subject string
2819            right here, to save looping. Otherwise, set up the new state to swing            right here, to save looping. Otherwise, set up the new state to swing
2820            into action when the end of the substring is reached. */            into action when the end of the matched substring is reached. */
2821    
2822            else if (i + 1 >= active_count && new_count == 0)            else if (i + 1 >= active_count && new_count == 0)
2823              {              {
# Line 2746  for (;;) Line 2847  for (;;)
2847              if (repeat_state_offset >= 0)              if (repeat_state_offset >= 0)
2848                { ADD_NEW_DATA(-repeat_state_offset, 0, (charcount - 1)); }                { ADD_NEW_DATA(-repeat_state_offset, 0, (charcount - 1)); }
2849              }              }
   
2850            }            }
2851          else if (rc != PCRE_ERROR_NOMATCH) return rc;          else if (rc != PCRE_ERROR_NOMATCH) return rc;
2852          }          }

Legend:
Removed from v.602  
changed lines
  Added in v.604

  ViewVC Help
Powered by ViewVC 1.1.5