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

Diff of /code/trunk/pcre_dfa_exec.c

Parent Directory | Revision Log | View Patch Patch

-revision 391 by ph10,
Tue Mar 17 21:16:01 2009 UTC
+revision 398 by ph10,
Fri Mar 20 20:41:29 2009 UTC
 Line 3
  *************************************************/
  /* PCRE is a library of functions to support regular expressions whose syntax
  and semantics are as close as possible to those of the Perl 5 language (but see
  below for why this module is different).
                         Written by Philip Hazel
 Line 61 
 applications. */
  #define SP "                   "
  /*************************************************
  *      Code parameters and static tables         *
  *************************************************/
-Line 512 
 for (;;)
+Line 511 
 for (;;)
      stateblock *current_state = active_states + i;
      const uschar *code;
      int state_offset = current_state->offset;
-     int count, codevalue;
+     int count, codevalue, rrc;
  #ifdef DEBUG
      printf ("%.*sProcessing state %d c=", rlevel*2-2, SP, state_offset);
-Line 2201 
 for (;;)
+Line 2200 
 for (;;)
          {
          int local_offsets[1000];
          int local_workspace[1000];
-         int condcode = code[LINK_SIZE+1];
+         int codelink = GET(code, 1);
+         int condcode;
+         /* Because of the way auto-callout works during compile, a callout item
+         is inserted between OP_COND and an assertion condition. This does not
+         happen for the other conditions. */
+         if (code[LINK_SIZE+1] == OP_CALLOUT)
+           {
+           rrc = 0;
+           if (pcre_callout != NULL)
+             {
+             pcre_callout_block cb;
+             cb.version          = 1;   /* Version 1 of the callout block */
+             cb.callout_number   = code[LINK_SIZE+2];
+             cb.offset_vector    = offsets;
+             cb.subject          = (PCRE_SPTR)start_subject;
+             cb.subject_length   = end_subject - start_subject;
+             cb.start_match      = current_subject - start_subject;
+             cb.current_position = ptr - start_subject;
+             cb.pattern_position = GET(code, LINK_SIZE + 3);
+             cb.next_item_length = GET(code, 3 + 2*LINK_SIZE);
+             cb.capture_top      = 1;
+             cb.capture_last     = -1;
+             cb.callout_data     = md->callout_data;
+             if ((rrc = (*pcre_callout)(&cb)) < 0) return rrc;   /* Abandon */
+             }
+           if (rrc > 0) break;                      /* Fail this thread */
+           code += _pcre_OP_lengths[OP_CALLOUT];    /* Skip callout data */
+           }
+         condcode = code[LINK_SIZE+1];
          /* Back reference conditions are not supported */
          if (condcode == OP_CREF) return PCRE_ERROR_DFA_UCOND;
-Line 2210 
 for (;;)
+Line 2240 
 for (;;)
          /* The DEFINE condition is always false */
          if (condcode == OP_DEF)
-           {
+           { ADD_ACTIVE(state_offset + codelink + LINK_SIZE + 1, 0); }
-           ADD_ACTIVE(state_offset + GET(code, 1) + LINK_SIZE + 1, 0);
-           }
          /* The only supported version of OP_RREF is for the value RREF_ANY,
          which means "test if in any recursion". We can't test for specifically
-Line 2222 
 for (;;)
+Line 2250 
 for (;;)
            {
            int value = GET2(code, LINK_SIZE+2);
            if (value != RREF_ANY) return PCRE_ERROR_DFA_UCOND;
-           if (recursing > 0) { ADD_ACTIVE(state_offset + LINK_SIZE + 4, 0); }
+           if (recursing > 0)
-             else { ADD_ACTIVE(state_offset + GET(code, 1) + LINK_SIZE + 1, 0); }
+             { ADD_ACTIVE(state_offset + LINK_SIZE + 4, 0); }
+           else { ADD_ACTIVE(state_offset + codelink + LINK_SIZE + 1, 0); }
            }
          /* Otherwise, the condition is an assertion */
-Line 2253 
 for (;;)
+Line 2282 
 for (;;)
                  (condcode == OP_ASSERT || condcode == OP_ASSERTBACK))
              { ADD_ACTIVE(endasscode + LINK_SIZE + 1 - start_code, 0); }
            else
-             { ADD_ACTIVE(state_offset + GET(code, 1) + LINK_SIZE + 1, 0); }
+             { ADD_ACTIVE(state_offset + codelink + LINK_SIZE + 1, 0); }
            }
          }
        break;
-Line 2405 
 for (;;)
+Line 2434 
 for (;;)
        /* Handle callouts */
        case OP_CALLOUT:
+       rrc = 0;
        if (pcre_callout != NULL)
          {
-         int rrc;
          pcre_callout_block cb;
          cb.version          = 1;   /* Version 1 of the callout block */
          cb.callout_number   = code[1];
-Line 2422 
 for (;;)
+Line 2451 
 for (;;)
          cb.capture_last     = -1;
          cb.callout_data     = md->callout_data;
          if ((rrc = (*pcre_callout)(&cb)) < 0) return rrc;   /* Abandon */
-         if (rrc == 0) { ADD_ACTIVE(state_offset + 2 + 2*LINK_SIZE, 0); }
+         }
-         }
+       if (rrc == 0)
+         { ADD_ACTIVE(state_offset + _pcre_OP_lengths[OP_CALLOUT], 0); }
        break;
-Line 2747 
 for (;;)
+Line 2777 
 for (;;)
        while (t < md->end_subject && !IS_NEWLINE(t)) t++;
        end_subject = t;
        }
      /* There are some optimizations that avoid running the match if a known
      starting point is not found, or if a known later character is not present.
      However, there is an option that disables these, for testing and for
      ensuring that all callouts do actually occur. */
      if ((options & PCRE_NO_START_OPTIMIZE) == 0)
        {
        /* Advance to a known first byte. */
        if (first_byte >= 0)
          {
          if (first_byte_caseless)
-Line 2765 
 for (;;)
+Line 2795 
 for (;;)
                   lcc[*current_subject] != first_byte)
              current_subject++;
          else
            while (current_subject < end_subject &&
                   *current_subject != first_byte)
              current_subject++;
          }
        /* Or to just after a linebreak for a multiline match if possible */
        else if (startline)
          {
          if (current_subject > md->start_subject + start_offset)
-Line 2779 
 for (;;)
+Line 2809 
 for (;;)
  #ifdef SUPPORT_UTF8
            if (utf8)
              {
              while (current_subject < end_subject &&
                     !WAS_NEWLINE(current_subject))
                {
                current_subject++;
-Line 2792 
 for (;;)
+Line 2822 
 for (;;)
  #endif
            while (current_subject < end_subject && !WAS_NEWLINE(current_subject))
              current_subject++;
            /* If we have just passed a CR and the newline option is ANY or
            ANYCRLF, and we are now at a LF, advance the match position by one
            more character. */
            if (current_subject[-1] == CHAR_CR &&
                 (md->nltype == NLTYPE_ANY || md->nltype == NLTYPE_ANYCRLF) &&
                 current_subject < end_subject &&
-Line 2804 
 for (;;)
+Line 2834 
 for (;;)
              current_subject++;
            }
          }
        /* Or to a non-unique first char after study */
        else if (start_bits != NULL)
          {
          while (current_subject < end_subject)
-Line 2816 
 for (;;)
+Line 2846 
 for (;;)
              else break;
            }
          }
        }
      /* Restore fudged end_subject */
-Line 2836 
 for (;;)
+Line 2866 
 for (;;)
    showed up when somebody was matching /^C/ on a 32-megabyte string... so we
    don't do this when the string is sufficiently long.
    ALSO: this processing is disabled when partial matching is requested, and can
    also be explicitly deactivated. */
    if ((options & PCRE_NO_START_OPTIMIZE) == 0 &&

 Legend:



Removed from v.391
 


changed lines


 
Added in v.398
 Legend:



Removed from v.391
 


changed lines


 
Added in v.398
-Removed from v.391
+Added in v.398

	ViewVC Help
Powered by ViewVC 1.1.5