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

Diff of /code/trunk/pcre_exec.c

Parent Directory | Revision Log | View Patch Patch

-revision 361 by ph10,
Thu Jul 10 16:03:28 2008 UTC
+revision 435 by ph10,
Sat Sep  5 10:20:44 2009 UTC
 Line 6
  and semantics are as close as possible to those of the Perl 5 language.
                         Written by Philip Hazel
-            Copyright (c) 1997-2008 University of Cambridge
+            Copyright (c) 1997-2009 University of Cambridge
  -----------------------------------------------------------------------------
  Redistribution and use in source and binary forms, with or without
 Line 322 
 typedef struct heapframe {
    /* Function arguments that may change */
-   const uschar *Xeptr;
+   USPTR Xeptr;
    const uschar *Xecode;
-   const uschar *Xmstart;
+   USPTR Xmstart;
    int Xoffset_top;
    long int Xims;
    eptrblock *Xeptrb;
 Line 333 
 typedef struct heapframe {
    /* Function local variables */
-   const uschar *Xcallpat;
+   USPTR Xcallpat;
-   const uschar *Xcharptr;
+ #ifdef SUPPORT_UTF8
-   const uschar *Xdata;
+   USPTR Xcharptr;
-   const uschar *Xnext;
+ #endif
-   const uschar *Xpp;
+   USPTR Xdata;
-   const uschar *Xprev;
+   USPTR Xnext;
-   const uschar *Xsaved_eptr;
+   USPTR Xpp;
+   USPTR Xprev;
+   USPTR Xsaved_eptr;
    recursion_info Xnew_recursive;
-Line 360 
 typedef struct heapframe {
+Line 362 
 typedef struct heapframe {
    uschar Xocchars[8];
  #endif
+   int Xcodelink;
    int Xctype;
    unsigned int Xfc;
    int Xfi;
-Line 395 
 typedef struct heapframe {
+Line 398 
 typedef struct heapframe {
  /* This function is called recursively in many circumstances. Whenever it
  returns a negative (error) response, the outer incarnation must also return the
- same response.
+ same response. */
+ /* These macros pack up tests that are used for partial matching, and which
+ appears several times in the code. We set the "hit end" flag if the pointer is
+ at the end of the subject and also past the start of the subject (i.e.
+ something has been matched). For hard partial matching, we then return
+ immediately. The second one is used when we already know we are past the end of
+ the subject. */
+ #define CHECK_PARTIAL()\
+   if (md->partial != 0 && eptr >= md->end_subject && eptr > mstart)\
+     {\
+     md->hitend = TRUE;\
+     if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);\
+     }
- Performance note: It might be tempting to extract commonly used fields from the
+ #define SCHECK_PARTIAL()\
- md structure (e.g. utf8, end_subject) into individual variables to improve
+   if (md->partial && eptr > mstart)\
+     {\
+     md->hitend = TRUE;\
+     if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);\
+     }
+ /* Performance note: It might be tempting to extract commonly used fields from
+ the md structure (e.g. utf8, end_subject) into individual variables to improve
  performance. Tests using gcc on a SPARC disproved this; in the first case, it
  made performance worse.
-Line 425 
 Returns:       MATCH_MATCH if matched
+Line 450 
 Returns:       MATCH_MATCH if matched
  */
  static int
- match(REGISTER USPTR eptr, REGISTER const uschar *ecode, const uschar *mstart,
+ match(REGISTER USPTR eptr, REGISTER const uschar *ecode, USPTR mstart,
    int offset_top, match_data *md, unsigned long int ims, eptrblock *eptrb,
    int flags, unsigned int rdepth)
  {
-Line 439 
 register unsigned int c;   /* Character
+Line 464 
 register unsigned int c;   /* Character
  register BOOL utf8;        /* Local copy of UTF-8 flag for speed */
  BOOL minimize, possessive; /* Quantifier options */
+ int condcode;
  /* When recursion is not being used, all "local" variables that have to be
  preserved over calls to RMATCH() are part of a "frame" which is obtained from
-Line 481 
 HEAP_RECURSE:
+Line 507 
 HEAP_RECURSE:
  #define charptr            frame->Xcharptr
  #endif
  #define callpat            frame->Xcallpat
+ #define codelink           frame->Xcodelink
  #define data               frame->Xdata
  #define next               frame->Xnext
  #define pp                 frame->Xpp
-Line 561 
 int oclength;
+Line 588 
 int oclength;
  uschar occhars[8];
  #endif
+ int codelink;
  int ctype;
  int length;
  int max;
-Line 635 
 for (;;)
+Line 663 
 for (;;)
    {
    minimize = possessive = FALSE;
    op = *ecode;
-   /* For partial matching, remember if we ever hit the end of the subject after
-   matching at least one subject character. */
-   if (md->partial &&
-       eptr >= md->end_subject &&
-       eptr > mstart)
-     md->hitend = TRUE;
    switch(op)
      {
      case OP_FAIL:
-Line 787 
 for (;;)
+Line 807 
 for (;;)
      case OP_COND:
      case OP_SCOND:
-     if (ecode[LINK_SIZE+1] == OP_RREF)         /* Recursion test */
+     codelink= GET(ecode, 1);
+     /* Because of the way auto-callout works during compile, a callout item is
+     inserted between OP_COND and an assertion condition. */
+     if (ecode[LINK_SIZE+1] == OP_CALLOUT)
+       {
+       if (pcre_callout != NULL)
+         {
+         pcre_callout_block cb;
+         cb.version          = 1;   /* 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;
+         cb.subject_length   = md->end_subject - md->start_subject;
+         cb.start_match      = mstart - md->start_subject;
+         cb.current_position = eptr - md->start_subject;
+         cb.pattern_position = GET(ecode, LINK_SIZE + 3);
+         cb.next_item_length = GET(ecode, 3 + 2*LINK_SIZE);
+         cb.capture_top      = offset_top/2;
+         cb.capture_last     = md->capture_last;
+         cb.callout_data     = md->callout_data;
+         if ((rrc = (*pcre_callout)(&cb)) > 0) RRETURN(MATCH_NOMATCH);
+         if (rrc < 0) RRETURN(rrc);
+         }
+       ecode += _pcre_OP_lengths[OP_CALLOUT];
+       }
+     condcode = ecode[LINK_SIZE+1];
+     /* Now see what the actual condition is */
+     if (condcode == OP_RREF)         /* Recursion test */
        {
        offset = GET2(ecode, LINK_SIZE + 2);     /* Recursion group number*/
        condition = md->recursive != NULL &&
-Line 795 
 for (;;)
+Line 847 
 for (;;)
        ecode += condition? 3 : GET(ecode, 1);
        }
-     else if (ecode[LINK_SIZE+1] == OP_CREF)    /* Group used test */
+     else if (condcode == OP_CREF)    /* Group used test */
        {
        offset = GET2(ecode, LINK_SIZE+2) << 1;  /* Doubled ref number */
        condition = offset < offset_top && md->offset_vector[offset] >= 0;
        ecode += condition? 3 : GET(ecode, 1);
        }
-     else if (ecode[LINK_SIZE+1] == OP_DEF)     /* DEFINE - always false */
+     else if (condcode == OP_DEF)     /* DEFINE - always false */
        {
        condition = FALSE;
        ecode += GET(ecode, 1);
-Line 829 
 for (;;)
+Line 881 
 for (;;)
        else
          {
          condition = FALSE;
-         ecode += GET(ecode, 1);
+         ecode += codelink;
          }
        }
-Line 852 
 for (;;)
+Line 904 
 for (;;)
          goto TAIL_RECURSE;
          }
        }
-     else                         /* Condition false & no 2nd alternative */
+     else                         /* Condition false & no alternative */
        {
        ecode += 1 + LINK_SIZE;
        }
-Line 972 
 for (;;)
+Line 1024 
 for (;;)
        if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);
        }
-     /* Skip to next op code */
+     /* Save the earliest consulted character, then skip to next op code */
+     if (eptr < md->start_used_ptr) md->start_used_ptr = eptr;
      ecode += 1 + LINK_SIZE;
      break;
-Line 1075 
 for (;;)
+Line 1128 
 for (;;)
          else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)
            {
            DPRINTF(("Recursion gave error %d\n", rrc));
+           if (new_recursive.offset_save != stacksave)
+             (pcre_free)(new_recursive.offset_save);
            RRETURN(rrc);
            }
-Line 1414 
 for (;;)
+Line 1469 
 for (;;)
        /* Find out if the previous and current characters are "word" characters.
        It takes a bit more work in UTF-8 mode. Characters > 255 are assumed to
-       be "non-word" characters. */
+       be "non-word" characters. Remember the earliest consulted character for
+       partial matching. */
  #ifdef SUPPORT_UTF8
        if (utf8)
          {
          if (eptr == md->start_subject) prev_is_word = FALSE; else
            {
-           const uschar *lastptr = eptr - 1;
+           USPTR lastptr = eptr - 1;
            while((*lastptr & 0xc0) == 0x80) lastptr--;
+           if (lastptr < md->start_used_ptr) md->start_used_ptr = lastptr;
            GETCHAR(c, lastptr);
            prev_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;
            }
-         if (eptr >= md->end_subject) cur_is_word = FALSE; else
+         if (eptr >= md->end_subject)
+           {
+           SCHECK_PARTIAL();
+           cur_is_word = FALSE;
+           }
+         else
            {
            GETCHAR(c, eptr);
            cur_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;
-Line 1435 
 for (;;)
+Line 1497 
 for (;;)
        else
  #endif
-       /* More streamlined when not in UTF-8 mode */
+       /* Not in UTF-8 mode */
          {
-         prev_is_word = (eptr != md->start_subject) &&
+         if (eptr == md->start_subject) prev_is_word = FALSE; else
-           ((md->ctypes[eptr[-1]] & ctype_word) != 0);
+           {
-         cur_is_word = (eptr < md->end_subject) &&
+           if (eptr <= md->start_used_ptr) md->start_used_ptr = eptr - 1;
-           ((md->ctypes[*eptr] & ctype_word) != 0);
+           prev_is_word = ((md->ctypes[eptr[-1]] & ctype_word) != 0);
+           }
+         if (eptr >= md->end_subject)
+           {
+           SCHECK_PARTIAL();
+           cur_is_word = FALSE;
+           }
+         else cur_is_word = ((md->ctypes[*eptr] & ctype_word) != 0);
          }
        /* Now see if the situation is what we want */
-Line 1459 
 for (;;)
+Line 1528 
 for (;;)
      /* Fall through */
      case OP_ALLANY:
-     if (eptr++ >= md->end_subject) RRETURN(MATCH_NOMATCH);
+     if (eptr++ >= md->end_subject)
+       {
+       SCHECK_PARTIAL();
+       RRETURN(MATCH_NOMATCH);
+       }
      if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
      ecode++;
      break;
-Line 1468 
 for (;;)
+Line 1541 
 for (;;)
      any byte, even newline, independent of the setting of PCRE_DOTALL. */
      case OP_ANYBYTE:
-     if (eptr++ >= md->end_subject) RRETURN(MATCH_NOMATCH);
+     if (eptr++ >= md->end_subject)
+       {
+       SCHECK_PARTIAL();
+       RRETURN(MATCH_NOMATCH);
+       }
      ecode++;
      break;
      case OP_NOT_DIGIT:
-     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+     if (eptr >= md->end_subject)
+       {
+       SCHECK_PARTIAL();
+       RRETURN(MATCH_NOMATCH);
+       }
      GETCHARINCTEST(c, eptr);
      if (
  #ifdef SUPPORT_UTF8
-Line 1486 
 for (;;)
+Line 1567 
 for (;;)
      break;
      case OP_DIGIT:
-     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+     if (eptr >= md->end_subject)
+       {
+       SCHECK_PARTIAL();
+       RRETURN(MATCH_NOMATCH);
+       }
      GETCHARINCTEST(c, eptr);
      if (
  #ifdef SUPPORT_UTF8
-Line 1499 
 for (;;)
+Line 1584 
 for (;;)
      break;
      case OP_NOT_WHITESPACE:
-     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+     if (eptr >= md->end_subject)
+       {
+       SCHECK_PARTIAL();
+       RRETURN(MATCH_NOMATCH);
+       }
      GETCHARINCTEST(c, eptr);
      if (
  #ifdef SUPPORT_UTF8
-Line 1512 
 for (;;)
+Line 1601 
 for (;;)
      break;
      case OP_WHITESPACE:
-     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+     if (eptr >= md->end_subject)
+       {
+       SCHECK_PARTIAL();
+       RRETURN(MATCH_NOMATCH);
+       }
      GETCHARINCTEST(c, eptr);
      if (
  #ifdef SUPPORT_UTF8
-Line 1525 
 for (;;)
+Line 1618 
 for (;;)
      break;
      case OP_NOT_WORDCHAR:
-     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+     if (eptr >= md->end_subject)
+       {
+       SCHECK_PARTIAL();
+       RRETURN(MATCH_NOMATCH);
+       }
      GETCHARINCTEST(c, eptr);
      if (
  #ifdef SUPPORT_UTF8
-Line 1538 
 for (;;)
+Line 1635 
 for (;;)
      break;
      case OP_WORDCHAR:
-     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+     if (eptr >= md->end_subject)
+       {
+       SCHECK_PARTIAL();
+       RRETURN(MATCH_NOMATCH);
+       }
      GETCHARINCTEST(c, eptr);
      if (
  #ifdef SUPPORT_UTF8
-Line 1551 
 for (;;)
+Line 1652 
 for (;;)
      break;
      case OP_ANYNL:
-     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+     if (eptr >= md->end_subject)
+       {
+       SCHECK_PARTIAL();
+       RRETURN(MATCH_NOMATCH);
+       }
      GETCHARINCTEST(c, eptr);
      switch(c)
        {
-Line 1575 
 for (;;)
+Line 1680 
 for (;;)
      break;
      case OP_NOT_HSPACE:
-     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+     if (eptr >= md->end_subject)
+       {
+       SCHECK_PARTIAL();
+       RRETURN(MATCH_NOMATCH);
+       }
      GETCHARINCTEST(c, eptr);
      switch(c)
        {
-Line 1605 
 for (;;)
+Line 1714 
 for (;;)
      break;
      case OP_HSPACE:
-     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+     if (eptr >= md->end_subject)
+       {
+       SCHECK_PARTIAL();
+       RRETURN(MATCH_NOMATCH);
+       }
      GETCHARINCTEST(c, eptr);
      switch(c)
        {
-Line 1635 
 for (;;)
+Line 1748 
 for (;;)
      break;
      case OP_NOT_VSPACE:
-     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+     if (eptr >= md->end_subject)
+       {
+       SCHECK_PARTIAL();
+       RRETURN(MATCH_NOMATCH);
+       }
      GETCHARINCTEST(c, eptr);
      switch(c)
        {
-Line 1653 
 for (;;)
+Line 1770 
 for (;;)
      break;
      case OP_VSPACE:
-     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+     if (eptr >= md->end_subject)
+       {
+       SCHECK_PARTIAL();
+       RRETURN(MATCH_NOMATCH);
+       }
      GETCHARINCTEST(c, eptr);
      switch(c)
        {
-Line 1676 
 for (;;)
+Line 1797 
 for (;;)
      case OP_PROP:
      case OP_NOTPROP:
-     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+     if (eptr >= md->end_subject)
+       {
+       SCHECK_PARTIAL();
+       RRETURN(MATCH_NOMATCH);
+       }
      GETCHARINCTEST(c, eptr);
        {
-       const ucd_record * prop = GET_UCD(c);
+       const ucd_record *prop = GET_UCD(c);
        switch(ecode[1])
          {
-Line 1721 
 for (;;)
+Line 1846 
 for (;;)
      is in the binary; otherwise a compile-time error occurs. */
      case OP_EXTUNI:
-     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+     if (eptr >= md->end_subject)
+       {
+       SCHECK_PARTIAL();
+       RRETURN(MATCH_NOMATCH);
+       }
      GETCHARINCTEST(c, eptr);
        {
        int category = UCD_CATEGORY(c);
-Line 1801 
 for (;;)
+Line 1930 
 for (;;)
          break;
          default:               /* No repeat follows */
-         if (!match_ref(offset, eptr, length, md, ims)) RRETURN(MATCH_NOMATCH);
+         if (!match_ref(offset, eptr, length, md, ims))
+           {
+           CHECK_PARTIAL();
+           RRETURN(MATCH_NOMATCH);
+           }
          eptr += length;
          continue;              /* With the main loop */
          }
        /* If the length of the reference is zero, just continue with the
        main loop. */
        if (length == 0) continue;
        /* First, ensure the minimum number of matches are present. We get back
-Line 1817 
 for (;;)
+Line 1950 
 for (;;)
        for (i = 1; i <= min; i++)
          {
-         if (!match_ref(offset, eptr, length, md, ims)) RRETURN(MATCH_NOMATCH);
+         if (!match_ref(offset, eptr, length, md, ims))
+           {
+           CHECK_PARTIAL();
+           RRETURN(MATCH_NOMATCH);
+           }
          eptr += length;
          }
-Line 1834 
 for (;;)
+Line 1971 
 for (;;)
            {
            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM14);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-           if (fi >= max || !match_ref(offset, eptr, length, md, ims))
+           if (fi >= max) RRETURN(MATCH_NOMATCH);
+           if (!match_ref(offset, eptr, length, md, ims))
+             {
+             CHECK_PARTIAL();
              RRETURN(MATCH_NOMATCH);
+             }
            eptr += length;
            }
          /* Control never gets here */
-Line 1862 
 for (;;)
+Line 2003 
 for (;;)
        }
      /* Control never gets here */
      /* Match a bit-mapped character class, possibly repeatedly. This op code is
      used when all the characters in the class have values in the range 0-255,
      and either the matching is caseful, or the characters are in the range
-Line 1918 
 for (;;)
+Line 2057 
 for (;;)
          {
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             RRETURN(MATCH_NOMATCH);
+             }
            GETCHARINC(c, eptr);
            if (c > 255)
              {
-Line 1936 
 for (;;)
+Line 2079 
 for (;;)
          {
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             RRETURN(MATCH_NOMATCH);
+             }
            c = *eptr++;
            if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
            }
-Line 1960 
 for (;;)
+Line 2107 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM16);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+             if (fi >= max) RRETURN(MATCH_NOMATCH);
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               RRETURN(MATCH_NOMATCH);
+               }
              GETCHARINC(c, eptr);
              if (c > 255)
                {
-Line 1980 
 for (;;)
+Line 2132 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM17);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+             if (fi >= max) RRETURN(MATCH_NOMATCH);
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               RRETURN(MATCH_NOMATCH);
+               }
              c = *eptr++;
              if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
              }
-Line 2047 
 for (;;)
+Line 2204 
 for (;;)
      /* Match an extended character class. This opcode is encountered only
-     in UTF-8 mode, because that's the only time it is compiled. */
+     when UTF-8 mode mode is supported. Nevertheless, we may not be in UTF-8
+     mode, because Unicode properties are supported in non-UTF-8 mode. */
  #ifdef SUPPORT_UTF8
      case OP_XCLASS:
-Line 2088 
 for (;;)
+Line 2246 
 for (;;)
        for (i = 1; i <= min; i++)
          {
-         if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+         if (eptr >= md->end_subject)
-         GETCHARINC(c, eptr);
+           {
+           SCHECK_PARTIAL();
+           RRETURN(MATCH_NOMATCH);
+           }
+         GETCHARINCTEST(c, eptr);
          if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);
          }
-Line 2107 
 for (;;)
+Line 2269 
 for (;;)
            {
            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM20);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-           if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           if (fi >= max) RRETURN(MATCH_NOMATCH);
-           GETCHARINC(c, eptr);
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             RRETURN(MATCH_NOMATCH);
+             }
+           GETCHARINCTEST(c, eptr);
            if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);
            }
          /* Control never gets here */
-Line 2123 
 for (;;)
+Line 2290 
 for (;;)
            {
            int len = 1;
            if (eptr >= md->end_subject) break;
-           GETCHARLEN(c, eptr, len);
+           GETCHARLENTEST(c, eptr, len);
            if (!_pcre_xclass(c, data)) break;
            eptr += len;
            }
-Line 2150 
 for (;;)
+Line 2317 
 for (;;)
        length = 1;
        ecode++;
        GETCHARLEN(fc, ecode, length);
-       if (length > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);
+       if (length > md->end_subject - eptr)
+         {
+         CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */
+         RRETURN(MATCH_NOMATCH);
+         }
        while (length-- > 0) if (*ecode++ != *eptr++) RRETURN(MATCH_NOMATCH);
        }
      else
-Line 2158 
 for (;;)
+Line 2329 
 for (;;)
      /* Non-UTF-8 mode */
        {
-       if (md->end_subject - eptr < 1) RRETURN(MATCH_NOMATCH);
+       if (md->end_subject - eptr < 1)
+         {
+         SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */
+         RRETURN(MATCH_NOMATCH);
+         }
        if (ecode[1] != *eptr++) RRETURN(MATCH_NOMATCH);
        ecode += 2;
        }
-Line 2174 
 for (;;)
+Line 2349 
 for (;;)
        ecode++;
        GETCHARLEN(fc, ecode, length);
-       if (length > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);
+       if (length > md->end_subject - eptr)
+         {
+         CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */
+         RRETURN(MATCH_NOMATCH);
+         }
        /* If the pattern character's value is < 128, we have only one byte, and
        can use the fast lookup table. */
-Line 2209 
 for (;;)
+Line 2388 
 for (;;)
      /* Non-UTF-8 mode */
        {
-       if (md->end_subject - eptr < 1) RRETURN(MATCH_NOMATCH);
+       if (md->end_subject - eptr < 1)
+         {
+         SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */
+         RRETURN(MATCH_NOMATCH);
+         }
        if (md->lcc[ecode[1]] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
        ecode += 2;
        }
-Line 2263 
 for (;;)
+Line 2446 
 for (;;)
      case OP_MINQUERY:
      c = *ecode++ - OP_STAR;
      minimize = (c & 1) != 0;
      min = rep_min[c];                 /* Pick up values from tables; */
      max = rep_max[c];                 /* zero for max => infinity */
      if (max == 0) max = INT_MAX;
-     /* Common code for all repeated single-character matches. We can give
+     /* Common code for all repeated single-character matches. */
-     up quickly if there are fewer than the minimum number of characters left in
-     the subject. */
      REPEATCHAR:
  #ifdef SUPPORT_UTF8
-Line 2278 
 for (;;)
+Line 2460 
 for (;;)
        length = 1;
        charptr = ecode;
        GETCHARLEN(fc, ecode, length);
-       if (min * length > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);
        ecode += length;
        /* Handle multibyte character matching specially here. There is
-Line 2296 
 for (;;)
+Line 2477 
 for (;;)
          for (i = 1; i <= min; i++)
            {
-           if (memcmp(eptr, charptr, length) == 0) eptr += length;
+           if (eptr <= md->end_subject - length &&
+             memcmp(eptr, charptr, length) == 0) eptr += length;
  #ifdef SUPPORT_UCP
-           /* Need braces because of following else */
+           else if (oclength > 0 &&
-           else if (oclength == 0) { RRETURN(MATCH_NOMATCH); }
+                    eptr <= md->end_subject - oclength &&
+                    memcmp(eptr, occhars, oclength) == 0) eptr += oclength;
+ #endif  /* SUPPORT_UCP */
            else
              {
-             if (memcmp(eptr, occhars, oclength) != 0) RRETURN(MATCH_NOMATCH);
+             CHECK_PARTIAL();
-             eptr += oclength;
+             RRETURN(MATCH_NOMATCH);
              }
- #else   /* without SUPPORT_UCP */
-           else { RRETURN(MATCH_NOMATCH); }
- #endif  /* SUPPORT_UCP */
            }
          if (min == max) continue;
-Line 2318 
 for (;;)
+Line 2499 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM22);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+             if (fi >= max) RRETURN(MATCH_NOMATCH);
-             if (memcmp(eptr, charptr, length) == 0) eptr += length;
+             if (eptr <= md->end_subject - length &&
+               memcmp(eptr, charptr, length) == 0) eptr += length;
  #ifdef SUPPORT_UCP
-             /* Need braces because of following else */
+             else if (oclength > 0 &&
-             else if (oclength == 0) { RRETURN(MATCH_NOMATCH); }
+                      eptr <= md->end_subject - oclength &&
+                      memcmp(eptr, occhars, oclength) == 0) eptr += oclength;
+ #endif  /* SUPPORT_UCP */
              else
                {
-               if (memcmp(eptr, occhars, oclength) != 0) RRETURN(MATCH_NOMATCH);
+               CHECK_PARTIAL();
-               eptr += oclength;
+               RRETURN(MATCH_NOMATCH);
                }
- #else   /* without SUPPORT_UCP */
-             else { RRETURN (MATCH_NOMATCH); }
- #endif  /* SUPPORT_UCP */
              }
            /* Control never gets here */
            }
-Line 2340 
 for (;;)
+Line 2521 
 for (;;)
            pp = eptr;
            for (i = min; i < max; i++)
              {
-             if (eptr > md->end_subject - length) break;
+             if (eptr <= md->end_subject - length &&
-             if (memcmp(eptr, charptr, length) == 0) eptr += length;
+                 memcmp(eptr, charptr, length) == 0) eptr += length;
  #ifdef SUPPORT_UCP
-             else if (oclength == 0) break;
+             else if (oclength > 0 &&
-             else
+                      eptr <= md->end_subject - oclength &&
-               {
+                      memcmp(eptr, occhars, oclength) == 0) eptr += oclength;
-               if (memcmp(eptr, occhars, oclength) != 0) break;
-               eptr += oclength;
-               }
- #else   /* without SUPPORT_UCP */
-             else break;
  #endif  /* SUPPORT_UCP */
+             else break;
              }
            if (possessive) continue;
            for(;;)
-            {
+             {
-            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM23);
+             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM23);
-            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-            if (eptr == pp) RRETURN(MATCH_NOMATCH);
+             if (eptr == pp) { RRETURN(MATCH_NOMATCH); }
  #ifdef SUPPORT_UCP
-            eptr--;
+             eptr--;
-            BACKCHAR(eptr);
+             BACKCHAR(eptr);
  #else   /* without SUPPORT_UCP */
-            eptr -= length;
+             eptr -= length;
  #endif  /* SUPPORT_UCP */
-            }
+             }
            }
          /* Control never gets here */
          }
-Line 2379 
 for (;;)
+Line 2557 
 for (;;)
  #endif  /* SUPPORT_UTF8 */
      /* When not in UTF-8 mode, load a single-byte character. */
-       {
-       if (min > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);
-       fc = *ecode++;
-       }
+     fc = *ecode++;
      /* The value of fc at this point is always less than 256, though we may or
      may not be in UTF-8 mode. The code is duplicated for the caseless and
      caseful cases, for speed, since matching characters is likely to be quite
-Line 2400 
 for (;;)
+Line 2576 
 for (;;)
        {
        fc = md->lcc[fc];
        for (i = 1; i <= min; i++)
+         {
+         if (eptr >= md->end_subject)
+           {
+           SCHECK_PARTIAL();
+           RRETURN(MATCH_NOMATCH);
+           }
          if (fc != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
+         }
        if (min == max) continue;
        if (minimize)
          {
-Line 2408 
 for (;;)
+Line 2591 
 for (;;)
            {
            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM24);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-           if (fi >= max || eptr >= md->end_subject ||
+           if (fi >= max) RRETURN(MATCH_NOMATCH);
-               fc != md->lcc[*eptr++])
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
              RRETURN(MATCH_NOMATCH);
+             }
+           if (fc != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
            }
          /* Control never gets here */
          }
-Line 2422 
 for (;;)
+Line 2609 
 for (;;)
            if (eptr >= md->end_subject || fc != md->lcc[*eptr]) break;
            eptr++;
            }
          if (possessive) continue;
          while (eptr >= pp)
            {
            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM25);
-Line 2438 
 for (;;)
+Line 2627 
 for (;;)
      else
        {
-       for (i = 1; i <= min; i++) if (fc != *eptr++) RRETURN(MATCH_NOMATCH);
+       for (i = 1; i <= min; i++)
+         {
+         if (eptr >= md->end_subject)
+           {
+           SCHECK_PARTIAL();
+           RRETURN(MATCH_NOMATCH);
+           }
+         if (fc != *eptr++) RRETURN(MATCH_NOMATCH);
+         }
        if (min == max) continue;
        if (minimize)
          {
          for (fi = min;; fi++)
            {
            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM26);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-           if (fi >= max || eptr >= md->end_subject || fc != *eptr++)
+           if (fi >= max) RRETURN(MATCH_NOMATCH);
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
              RRETURN(MATCH_NOMATCH);
+             }
+           if (fc != *eptr++) RRETURN(MATCH_NOMATCH);
            }
          /* Control never gets here */
          }
-Line 2460 
 for (;;)
+Line 2664 
 for (;;)
            eptr++;
            }
          if (possessive) continue;
          while (eptr >= pp)
            {
            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM27);
-Line 2475 
 for (;;)
+Line 2680 
 for (;;)
      checking can be multibyte. */
      case OP_NOT:
-     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+     if (eptr >= md->end_subject)
+       {
+       SCHECK_PARTIAL();
+       RRETURN(MATCH_NOMATCH);
+       }
      ecode++;
      GETCHARINCTEST(c, eptr);
      if ((ims & PCRE_CASELESS) != 0)
-Line 2552 
 for (;;)
+Line 2761 
 for (;;)
      max = rep_max[c];                 /* zero for max => infinity */
      if (max == 0) max = INT_MAX;
-     /* Common code for all repeated single-byte matches. We can give up quickly
+     /* Common code for all repeated single-byte matches. */
-     if there are fewer than the minimum number of bytes left in the
-     subject. */
      REPEATNOTCHAR:
-     if (min > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);
      fc = *ecode++;
      /* The code is duplicated for the caseless and caseful cases, for speed,
-Line 2582 
 for (;;)
+Line 2788 
 for (;;)
          register unsigned int d;
          for (i = 1; i <= min; i++)
            {
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             RRETURN(MATCH_NOMATCH);
+             }
            GETCHARINC(d, eptr);
            if (d < 256) d = md->lcc[d];
            if (fc == d) RRETURN(MATCH_NOMATCH);
-Line 2593 
 for (;;)
+Line 2804 
 for (;;)
        /* Not UTF-8 mode */
          {
          for (i = 1; i <= min; i++)
+           {
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             RRETURN(MATCH_NOMATCH);
+             }
            if (fc == md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
+           }
          }
        if (min == max) continue;
-Line 2609 
 for (;;)
+Line 2827 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM28);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+             if (fi >= max) RRETURN(MATCH_NOMATCH);
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               RRETURN(MATCH_NOMATCH);
+               }
              GETCHARINC(d, eptr);
              if (d < 256) d = md->lcc[d];
-             if (fi >= max || eptr >= md->end_subject || fc == d)
+             if (fc == d) RRETURN(MATCH_NOMATCH);
-               RRETURN(MATCH_NOMATCH);
              }
            }
          else
-Line 2623 
 for (;;)
+Line 2846 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM29);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max || eptr >= md->end_subject || fc == md->lcc[*eptr++])
+             if (fi >= max) RRETURN(MATCH_NOMATCH);
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
                RRETURN(MATCH_NOMATCH);
+               }
+             if (fc == md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
              }
            }
          /* Control never gets here */
-Line 2693 
 for (;;)
+Line 2921 
 for (;;)
          register unsigned int d;
          for (i = 1; i <= min; i++)
            {
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             RRETURN(MATCH_NOMATCH);
+             }
            GETCHARINC(d, eptr);
            if (fc == d) RRETURN(MATCH_NOMATCH);
            }
-Line 2702 
 for (;;)
+Line 2935 
 for (;;)
        /* Not UTF-8 mode */
          {
          for (i = 1; i <= min; i++)
+           {
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             RRETURN(MATCH_NOMATCH);
+             }
            if (fc == *eptr++) RRETURN(MATCH_NOMATCH);
+           }
          }
        if (min == max) continue;
-Line 2718 
 for (;;)
+Line 2958 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM32);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             GETCHARINC(d, eptr);
+             if (fi >= max) RRETURN(MATCH_NOMATCH);
-             if (fi >= max || eptr >= md->end_subject || fc == d)
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
                RRETURN(MATCH_NOMATCH);
+               }
+             GETCHARINC(d, eptr);
+             if (fc == d) RRETURN(MATCH_NOMATCH);
              }
            }
          else
-Line 2731 
 for (;;)
+Line 2976 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM33);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max || eptr >= md->end_subject || fc == *eptr++)
+             if (fi >= max) RRETURN(MATCH_NOMATCH);
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
                RRETURN(MATCH_NOMATCH);
+               }
+             if (fc == *eptr++) RRETURN(MATCH_NOMATCH);
              }
            }
          /* Control never gets here */
-Line 2866 
 for (;;)
+Line 3116 
 for (;;)
      /* First, ensure the minimum number of matches are present. Use inline
      code for maximizing the speed, and do the type test once at the start
-     (i.e. keep it out of the loop). Also we can test that there are at least
+     (i.e. keep it out of the loop). Separate the UTF-8 code completely as that
-     the minimum number of bytes before we start. This isn't as effective in
-     UTF-8 mode, but it does no harm. Separate the UTF-8 code completely as that
      is tidier. Also separate the UCP code, which can be the same for both UTF-8
      and single-bytes. */
-     if (min > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);
      if (min > 0)
        {
  #ifdef SUPPORT_UCP
-Line 2884 
 for (;;)
+Line 3131 
 for (;;)
            if (prop_fail_result) RRETURN(MATCH_NOMATCH);
            for (i = 1; i <= min; i++)
              {
-             if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               RRETURN(MATCH_NOMATCH);
+               }
              GETCHARINCTEST(c, eptr);
              }
            break;
-Line 2892 
 for (;;)
+Line 3143 
 for (;;)
            case PT_LAMP:
            for (i = 1; i <= min; i++)
              {
-             if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               RRETURN(MATCH_NOMATCH);
+               }
              GETCHARINCTEST(c, eptr);
              prop_chartype = UCD_CHARTYPE(c);
              if ((prop_chartype == ucp_Lu ||
-Line 2905 
 for (;;)
+Line 3160 
 for (;;)
            case PT_GC:
            for (i = 1; i <= min; i++)
              {
-             if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               RRETURN(MATCH_NOMATCH);
+               }
              GETCHARINCTEST(c, eptr);
              prop_category = UCD_CATEGORY(c);
              if ((prop_category == prop_value) == prop_fail_result)
-Line 2916 
 for (;;)
+Line 3175 
 for (;;)
            case PT_PC:
            for (i = 1; i <= min; i++)
              {
-             if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               RRETURN(MATCH_NOMATCH);
+               }
              GETCHARINCTEST(c, eptr);
              prop_chartype = UCD_CHARTYPE(c);
              if ((prop_chartype == prop_value) == prop_fail_result)
-Line 2927 
 for (;;)
+Line 3190 
 for (;;)
            case PT_SC:
            for (i = 1; i <= min; i++)
              {
-             if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               RRETURN(MATCH_NOMATCH);
+               }
              GETCHARINCTEST(c, eptr);
              prop_script = UCD_SCRIPT(c);
              if ((prop_script == prop_value) == prop_fail_result)
-Line 2947 
 for (;;)
+Line 3214 
 for (;;)
          {
          for (i = 1; i <= min; i++)
            {
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             RRETURN(MATCH_NOMATCH);
+             }
            GETCHARINCTEST(c, eptr);
            prop_category = UCD_CATEGORY(c);
            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);
            while (eptr < md->end_subject)
              {
              int len = 1;
-             if (!utf8) c = *eptr; else
+             if (!utf8) c = *eptr;
-               {
+               else { GETCHARLEN(c, eptr, len); }
-               GETCHARLEN(c, eptr, len);
-               }
              prop_category = UCD_CATEGORY(c);
              if (prop_category != ucp_M) break;
              eptr += len;
-Line 2975 
 for (;;)
+Line 3245 
 for (;;)
          case OP_ANY:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject || IS_NEWLINE(eptr))
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
              RRETURN(MATCH_NOMATCH);
+             }
+           if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
            eptr++;
            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
            }
-Line 2985 
 for (;;)
+Line 3259 
 for (;;)
          case OP_ALLANY:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             RRETURN(MATCH_NOMATCH);
+             }
            eptr++;
            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
            }
          break;
          case OP_ANYBYTE:
+         if (eptr > md->end_subject - min) RRETURN(MATCH_NOMATCH);
          eptr += min;
          break;
          case OP_ANYNL:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             RRETURN(MATCH_NOMATCH);
+             }
            GETCHARINC(c, eptr);
            switch(c)
              {
-Line 3024 
 for (;;)
+Line 3307 
 for (;;)
          case OP_NOT_HSPACE:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             RRETURN(MATCH_NOMATCH);
+             }
            GETCHARINC(c, eptr);
            switch(c)
              {
-Line 3056 
 for (;;)
+Line 3343 
 for (;;)
          case OP_HSPACE:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             RRETURN(MATCH_NOMATCH);
+             }
            GETCHARINC(c, eptr);
            switch(c)
              {
-Line 3088 
 for (;;)
+Line 3379 
 for (;;)
          case OP_NOT_VSPACE:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             RRETURN(MATCH_NOMATCH);
+             }
            GETCHARINC(c, eptr);
            switch(c)
              {
-Line 3108 
 for (;;)
+Line 3403 
 for (;;)
          case OP_VSPACE:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             RRETURN(MATCH_NOMATCH);
+             }
            GETCHARINC(c, eptr);
            switch(c)
              {
-Line 3128 
 for (;;)
+Line 3427 
 for (;;)
          case OP_NOT_DIGIT:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             RRETURN(MATCH_NOMATCH);
+             }
            GETCHARINC(c, eptr);
            if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)
              RRETURN(MATCH_NOMATCH);
-Line 3138 
 for (;;)
+Line 3441 
 for (;;)
          case OP_DIGIT:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject ||
+           if (eptr >= md->end_subject)
-              *eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)
+             {
+             SCHECK_PARTIAL();
+             RRETURN(MATCH_NOMATCH);
+             }
+           if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)
              RRETURN(MATCH_NOMATCH);
            /* No need to skip more bytes - we know it's a 1-byte character */
            }
-Line 3148 
 for (;;)
+Line 3455 
 for (;;)
          case OP_NOT_WHITESPACE:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject ||
+           if (eptr >= md->end_subject)
-              (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0))
+             {
+             SCHECK_PARTIAL();
+             RRETURN(MATCH_NOMATCH);
+             }
+           if (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0)
              RRETURN(MATCH_NOMATCH);
            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
            }
-Line 3158 
 for (;;)
+Line 3469 
 for (;;)
          case OP_WHITESPACE:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject ||
+           if (eptr >= md->end_subject)
-              *eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)
+             {
+             SCHECK_PARTIAL();
+             RRETURN(MATCH_NOMATCH);
+             }
+           if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)
              RRETURN(MATCH_NOMATCH);
            /* No need to skip more bytes - we know it's a 1-byte character */
            }
-Line 3178 
 for (;;)
+Line 3493 
 for (;;)
          case OP_WORDCHAR:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject ||
+           if (eptr >= md->end_subject)
-              *eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)
+             {
+             SCHECK_PARTIAL();
+             RRETURN(MATCH_NOMATCH);
+             }
+           if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)
              RRETURN(MATCH_NOMATCH);
            /* No need to skip more bytes - we know it's a 1-byte character */
            }
-Line 3193 
 for (;;)
+Line 3512 
 for (;;)
  #endif     /* SUPPORT_UTF8 */
        /* Code for the non-UTF-8 case for minimum matching of operators other
-       than OP_PROP and OP_NOTPROP. We can assume that there are the minimum
+       than OP_PROP and OP_NOTPROP. */
-       number of bytes present, as this was tested above. */
        switch(ctype)
          {
          case OP_ANY:
          for (i = 1; i <= min; i++)
            {
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             RRETURN(MATCH_NOMATCH);
+             }
            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
            eptr++;
            }
          break;
          case OP_ALLANY:
+         if (eptr > md->end_subject - min)
+           {
+           SCHECK_PARTIAL();
+           RRETURN(MATCH_NOMATCH);
+           }
          eptr += min;
          break;
          case OP_ANYBYTE:
+         if (eptr > md->end_subject - min)
+           {
+           SCHECK_PARTIAL();
+           RRETURN(MATCH_NOMATCH);
+           }
          eptr += min;
          break;
-         /* Because of the CRLF case, we can't assume the minimum number of
-         bytes are present in this case. */
          case OP_ANYNL:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             RRETURN(MATCH_NOMATCH);
+             }
            switch(*eptr++)
              {
              default: RRETURN(MATCH_NOMATCH);
-Line 3242 
 for (;;)
+Line 3576 
 for (;;)
          case OP_NOT_HSPACE:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             RRETURN(MATCH_NOMATCH);
+             }
            switch(*eptr++)
              {
              default: break;
-Line 3257 
 for (;;)
+Line 3595 
 for (;;)
          case OP_HSPACE:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             RRETURN(MATCH_NOMATCH);
+             }
            switch(*eptr++)
              {
              default: RRETURN(MATCH_NOMATCH);
-Line 3272 
 for (;;)
+Line 3614 
 for (;;)
          case OP_NOT_VSPACE:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             RRETURN(MATCH_NOMATCH);
+             }
            switch(*eptr++)
              {
              default: break;
-Line 3289 
 for (;;)
+Line 3635 
 for (;;)
          case OP_VSPACE:
          for (i = 1; i <= min; i++)
            {
-           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             RRETURN(MATCH_NOMATCH);
+             }
            switch(*eptr++)
              {
              default: RRETURN(MATCH_NOMATCH);
-Line 3305 
 for (;;)
+Line 3655 
 for (;;)
          case OP_NOT_DIGIT:
          for (i = 1; i <= min; i++)
+           {
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             RRETURN(MATCH_NOMATCH);
+             }
            if ((md->ctypes[*eptr++] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);
+           }
          break;
          case OP_DIGIT:
          for (i = 1; i <= min; i++)
+           {
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             RRETURN(MATCH_NOMATCH);
+             }
            if ((md->ctypes[*eptr++] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);
+           }
          break;
          case OP_NOT_WHITESPACE:
          for (i = 1; i <= min; i++)
+           {
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             RRETURN(MATCH_NOMATCH);
+             }
            if ((md->ctypes[*eptr++] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);
+           }
          break;
          case OP_WHITESPACE:
          for (i = 1; i <= min; i++)
+           {
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             RRETURN(MATCH_NOMATCH);
+             }
            if ((md->ctypes[*eptr++] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);
+           }
          break;
          case OP_NOT_WORDCHAR:
          for (i = 1; i <= min; i++)
+           {
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             RRETURN(MATCH_NOMATCH);
+             }
            if ((md->ctypes[*eptr++] & ctype_word) != 0)
              RRETURN(MATCH_NOMATCH);
+           }
          break;
          case OP_WORDCHAR:
          for (i = 1; i <= min; i++)
+           {
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             RRETURN(MATCH_NOMATCH);
+             }
            if ((md->ctypes[*eptr++] & ctype_word) == 0)
              RRETURN(MATCH_NOMATCH);
+           }
          break;
          default:
-Line 3360 
 for (;;)
+Line 3752 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM36);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+             if (fi >= max) RRETURN(MATCH_NOMATCH);
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               RRETURN(MATCH_NOMATCH);
+               }
              GETCHARINC(c, eptr);
              if (prop_fail_result) RRETURN(MATCH_NOMATCH);
              }
-Line 3371 
 for (;;)
+Line 3768 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM37);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+             if (fi >= max) RRETURN(MATCH_NOMATCH);
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               RRETURN(MATCH_NOMATCH);
+               }
              GETCHARINC(c, eptr);
              prop_chartype = UCD_CHARTYPE(c);
              if ((prop_chartype == ucp_Lu ||
-Line 3386 
 for (;;)
+Line 3788 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM38);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+             if (fi >= max) RRETURN(MATCH_NOMATCH);
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               RRETURN(MATCH_NOMATCH);
+               }
              GETCHARINC(c, eptr);
              prop_category = UCD_CATEGORY(c);
              if ((prop_category == prop_value) == prop_fail_result)
-Line 3399 
 for (;;)
+Line 3806 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+             if (fi >= max) RRETURN(MATCH_NOMATCH);
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               RRETURN(MATCH_NOMATCH);
+               }
              GETCHARINC(c, eptr);
              prop_chartype = UCD_CHARTYPE(c);
              if ((prop_chartype == prop_value) == prop_fail_result)
-Line 3412 
 for (;;)
+Line 3824 
 for (;;)
              {
              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM40);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-             if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+             if (fi >= max) RRETURN(MATCH_NOMATCH);
+             if (eptr >= md->end_subject)
+               {
+               SCHECK_PARTIAL();
+               RRETURN(MATCH_NOMATCH);
+               }
              GETCHARINC(c, eptr);
              prop_script = UCD_SCRIPT(c);
              if ((prop_script == prop_value) == prop_fail_result)
-Line 3434 
 for (;;)
+Line 3851 
 for (;;)
            {
            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM41);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-           if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           if (fi >= max) RRETURN(MATCH_NOMATCH);
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             RRETURN(MATCH_NOMATCH);
+             }
            GETCHARINCTEST(c, eptr);
            prop_category = UCD_CATEGORY(c);
            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);
            while (eptr < md->end_subject)
              {
              int len = 1;
-             if (!utf8) c = *eptr; else
+             if (!utf8) c = *eptr;
-               {
+               else { GETCHARLEN(c, eptr, len); }
-               GETCHARLEN(c, eptr, len);
-               }
              prop_category = UCD_CATEGORY(c);
              if (prop_category != ucp_M) break;
              eptr += len;
-Line 3463 
 for (;;)
+Line 3883 
 for (;;)
            {
            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-           if (fi >= max || eptr >= md->end_subject ||
+           if (fi >= max) RRETURN(MATCH_NOMATCH);
-                (ctype == OP_ANY && IS_NEWLINE(eptr)))
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             RRETURN(MATCH_NOMATCH);
+             }
+           if (ctype == OP_ANY && IS_NEWLINE(eptr))
              RRETURN(MATCH_NOMATCH);
            GETCHARINC(c, eptr);
            switch(ctype)
              {
-Line 3622 
 for (;;)
+Line 4046 
 for (;;)
            {
            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
-           if (fi >= max || eptr >= md->end_subject ||
+           if (fi >= max) RRETURN(MATCH_NOMATCH);
-                (ctype == OP_ANY && IS_NEWLINE(eptr)))
+           if (eptr >= md->end_subject)
+             {
+             SCHECK_PARTIAL();
+             RRETURN(MATCH_NOMATCH);
+             }
+           if (ctype == OP_ANY && IS_NEWLINE(eptr))
              RRETURN(MATCH_NOMATCH);
            c = *eptr++;
            switch(ctype)
              {
-Line 4408 
 const uschar *tables;
+Line 4836 
 const uschar *tables;
  const uschar *start_bits = NULL;
  USPTR start_match = (USPTR)subject + start_offset;
  USPTR end_subject;
+ USPTR start_partial = NULL;
  USPTR req_byte_ptr = start_match - 1;
  pcre_study_data internal_study;
-Line 4491 
 md->jscript_compat = (re->options & PCRE
+Line 4920 
 md->jscript_compat = (re->options & PCRE
  md->notbol = (options & PCRE_NOTBOL) != 0;
  md->noteol = (options & PCRE_NOTEOL) != 0;
  md->notempty = (options & PCRE_NOTEMPTY) != 0;
- md->partial = (options & PCRE_PARTIAL) != 0;
+ md->partial = ((options & PCRE_PARTIAL_HARD) != 0)? 2 :
+               ((options & PCRE_PARTIAL_SOFT) != 0)? 1 : 0;
  md->hitend = FALSE;
  md->recursive = NULL;                   /* No recursion at top level */
-Line 4532 
 switch ((((options & PCRE_NEWLINE_BITS)
+Line 4962 
 switch ((((options & PCRE_NEWLINE_BITS)
          (pcre_uint32)options) & PCRE_NEWLINE_BITS)
    {
    case 0: newline = NEWLINE; break;   /* Compile-time default */
-   case PCRE_NEWLINE_CR: newline = '\r'; break;
+   case PCRE_NEWLINE_CR: newline = CHAR_CR; break;
-   case PCRE_NEWLINE_LF: newline = '\n'; break;
+   case PCRE_NEWLINE_LF: newline = CHAR_NL; break;
    case PCRE_NEWLINE_CR+
-        PCRE_NEWLINE_LF: newline = ('\r' << 8) | '\n'; break;
+        PCRE_NEWLINE_LF: newline = (CHAR_CR << 8) | CHAR_NL; break;
    case PCRE_NEWLINE_ANY: newline = -1; break;
    case PCRE_NEWLINE_ANYCRLF: newline = -2; break;
    default: return PCRE_ERROR_BADNEWLINE;
-Line 4565 
 else
+Line 4995 
 else
      }
    }
- /* Partial matching is supported only for a restricted set of regexes at the
+ /* Partial matching was originally supported only for a restricted set of
- moment. */
+ regexes; from release 8.00 there are no restrictions, but the bits are still
+ defined (though never set). So there's no harm in leaving this code. */
  if (md->partial && (re->flags & PCRE_NOPARTIAL) != 0)
    return PCRE_ERROR_BADPARTIAL;
-Line 4577 
 back the character offset. */
+Line 5008 
 back the character offset. */
  #ifdef SUPPORT_UTF8
  if (utf8 && (options & PCRE_NO_UTF8_CHECK) == 0)
    {
-   if (_pcre_valid_utf8((uschar *)subject, length) >= 0)
+   if (_pcre_valid_utf8((USPTR)subject, length) >= 0)
      return PCRE_ERROR_BADUTF8;
    if (start_offset > 0 && start_offset < length)
      {
-     int tb = ((uschar *)subject)[start_offset];
+     int tb = ((USPTR)subject)[start_offset];
      if (tb > 127)
        {
        tb &= 0xc0;
-Line 4687 
 for(;;)
+Line 5118 
 for(;;)
      while (iptr < iend) *iptr++ = -1;
      }
-   /* Advance to a unique first char if possible. If firstline is TRUE, the
+   /* If firstline is TRUE, the start of the match is constrained to the first
-   start of the match is constrained to the first line of a multiline string.
+   line of a multiline string. That is, the match must be before or at the first
-   That is, the match must be before or at the first newline. Implement this by
+   newline. Implement this by temporarily adjusting end_subject so that we stop
-   temporarily adjusting end_subject so that we stop scanning at a newline. If
+   scanning at a newline. If the match fails at the newline, later code breaks
-   the match fails at the newline, later code breaks this loop. */
+   this loop. */
    if (firstline)
      {
      USPTR t = start_match;
+ #ifdef SUPPORT_UTF8
+     if (utf8)
+       {
+       while (t < md->end_subject && !IS_NEWLINE(t))
+         {
+         t++;
+         while (t < end_subject && (*t & 0xc0) == 0x80) t++;
+         }
+       }
+     else
+ #endif
      while (t < md->end_subject && !IS_NEWLINE(t)) t++;
      end_subject = t;
      }
-   /* Now test for a unique first byte */
+   /* 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 (first_byte >= 0)
+   if ((options & PCRE_NO_START_OPTIMIZE) == 0)
      {
-     if (first_byte_caseless)
+     /* Advance to a unique first byte if there is one. */
-       while (start_match < end_subject &&
-              md->lcc[*start_match] != first_byte)
-         { NEXTCHAR(start_match); }
-     else
-       while (start_match < end_subject && *start_match != first_byte)
-         { NEXTCHAR(start_match); }
-     }
-   /* Or to just after a linebreak for a multiline match if possible */
+     if (first_byte >= 0)
+       {
+       if (first_byte_caseless)
+         while (start_match < end_subject && md->lcc[*start_match] != first_byte)
+           start_match++;
+       else
+         while (start_match < end_subject && *start_match != first_byte)
+           start_match++;
+       }
-   else if (startline)
+     /* Or to just after a linebreak for a multiline match */
-     {
-     if (start_match > md->start_subject + start_offset)
+     else if (startline)
        {
-       while (start_match < end_subject && !WAS_NEWLINE(start_match))
+       if (start_match > md->start_subject + start_offset)
-         { NEXTCHAR(start_match); }
+         {
+ #ifdef SUPPORT_UTF8
-       /* If we have just passed a CR and the newline option is ANY or ANYCRLF,
+         if (utf8)
-       and we are now at a LF, advance the match position by one more character.
+           {
-       */
+           while (start_match < end_subject && !WAS_NEWLINE(start_match))
+             {
-       if (start_match[-1] == '\r' &&
+             start_match++;
-            (md->nltype == NLTYPE_ANY || md->nltype == NLTYPE_ANYCRLF) &&
+             while(start_match < end_subject && (*start_match & 0xc0) == 0x80)
-            start_match < end_subject &&
+               start_match++;
-            *start_match == '\n')
+             }
-         start_match++;
+           }
+         else
+ #endif
+         while (start_match < end_subject && !WAS_NEWLINE(start_match))
+           start_match++;
+         /* 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 (start_match[-1] == CHAR_CR &&
+              (md->nltype == NLTYPE_ANY || md->nltype == NLTYPE_ANYCRLF) &&
+              start_match < end_subject &&
+              *start_match == CHAR_NL)
+           start_match++;
+         }
        }
-     }
-   /* Or to a non-unique first char after study */
+     /* Or to a non-unique first byte after study */
-   else if (start_bits != NULL)
+     else if (start_bits != NULL)
-     {
-     while (start_match < end_subject)
        {
-       register unsigned int c = *start_match;
+       while (start_match < end_subject)
-       if ((start_bits[c/8] & (1 << (c&7))) == 0)
+         {
-         { NEXTCHAR(start_match); }
+         register unsigned int c = *start_match;
-       else break;
+         if ((start_bits[c/8] & (1 << (c&7))) == 0) start_match++;
+           else break;
+         }
        }
-     }
+     }   /* Starting optimizations */
    /* Restore fudged end_subject */
-Line 4757 
 for(;;)
+Line 5217 
 for(;;)
    printf("\n");
  #endif
-   /* If req_byte is set, we know that that character must appear in the subject
+   /* If req_byte is set, we know that that character must appear in the
-   for the match to succeed. If the first character is set, req_byte must be
+   subject for the match to succeed. If the first character is set, req_byte
-   later in the subject; otherwise the test starts at the match point. This
+   must be later in the subject; otherwise the test starts at the match point.
-   optimization can save a huge amount of backtracking in patterns with nested
+   This optimization can save a huge amount of backtracking in patterns with
-   unlimited repeats that aren't going to match. Writing separate code for
+   nested unlimited repeats that aren't going to match. Writing separate code
-   cased/caseless versions makes it go faster, as does using an autoincrement
+   for cased/caseless versions makes it go faster, as does using an
-   and backing off on a match.
+   autoincrement and backing off on a match.
-   HOWEVER: when the subject string is very, very long, searching to its end can
+   HOWEVER: when the subject string is very, very long, searching to its end
-   take a long time, and give bad performance on quite ordinary patterns. This
+   can take a long time, and give bad performance on quite ordinary patterns.
-   showed up when somebody was matching something like /^\d+C/ on a 32-megabyte
+   This showed up when somebody was matching something like /^\d+C/ on a
-   string... so we don't do this when the string is sufficiently long.
+-megabyte string... so we don't do this when the string is sufficiently
+   long.
-   ALSO: this processing is disabled when partial matching is requested.
+   ALSO: this processing is disabled when partial matching is requested, or if
-   */
+   disabling is explicitly requested. */
-   if (req_byte >= 0 &&
+   if ((options & PCRE_NO_START_OPTIMIZE) == 0 &&
+       req_byte >= 0 &&
        end_subject - start_match < REQ_BYTE_MAX &&
        !md->partial)
      {
-Line 4817 
 for(;;)
+Line 5279 
 for(;;)
        }
      }
-   /* OK, we can now run the match. */
+   /* OK, we can now run the match. If "hitend" is set afterwards, remember the
+   first starting point for which a partial match was found. */
    md->start_match_ptr = start_match;
+   md->start_used_ptr = start_match;
    md->match_call_count = 0;
    rc = match(start_match, md->start_code, start_match, 2, md, ims, NULL, 0, 0);
+   if (md->hitend && start_partial == NULL) start_partial = md->start_used_ptr;
    switch(rc)
      {
-Line 4881 
 for(;;)
+Line 5346 
 for(;;)
    not contain any explicit matches for \r or \n, and the newline option is CRLF
    or ANY or ANYCRLF, advance the match position by one more character. */
-   if (start_match[-1] == '\r' &&
+   if (start_match[-1] == CHAR_CR &&
        start_match < end_subject &&
-       *start_match == '\n' &&
+       *start_match == CHAR_NL &&
        (re->flags & PCRE_HASCRORLF) == 0 &&
          (md->nltype == NLTYPE_ANY ||
           md->nltype == NLTYPE_ANYCRLF ||
-Line 4957 
 if (using_temporary_offsets)
+Line 5422 
 if (using_temporary_offsets)
    (pcre_free)(md->offset_vector);
    }
- if (rc != MATCH_NOMATCH)
+ if (rc != MATCH_NOMATCH && rc != PCRE_ERROR_PARTIAL)
    {
    DPRINTF((">>>> error: returning %d\n", rc));
    return rc;
    }
- else if (md->partial && md->hitend)
+ else if (start_partial != NULL)
    {
    DPRINTF((">>>> returning PCRE_ERROR_PARTIAL\n"));
+   if (offsetcount > 1)
+     {
+     offsets[0] = start_partial - (USPTR)subject;
+     offsets[1] = end_subject - (USPTR)subject;
+     }
    return PCRE_ERROR_PARTIAL;
    }
  else

 Legend:



Removed from v.361
 


changed lines


 
Added in v.435
 Legend:



Removed from v.361
 


changed lines


 
Added in v.435
-Removed from v.361
+Added in v.435

webmaster@exim.org	ViewVC Help
Powered by ViewVC 1.1.12