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

Diff of /code/trunk/pcre_exec.c

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

revision 1046 by ph10, Tue Sep 25 16:27:58 2012 UTC revision 1102 by chpe, Tue Oct 16 15:56:34 2012 UTC
# Line 92  because the offset vector is always a mu Line 92  because the offset vector is always a mu
92  static const char rep_min[] = { 0, 0, 1, 1, 0, 0 };  static const char rep_min[] = { 0, 0, 1, 1, 0, 0 };
93  static const char rep_max[] = { 0, 0, 0, 0, 1, 1 };  static const char rep_max[] = { 0, 0, 0, 0, 1, 1 };
94    
   
   
95  #ifdef PCRE_DEBUG  #ifdef PCRE_DEBUG
96  /*************************************************  /*************************************************
97  *        Debugging function to print chars       *  *        Debugging function to print chars       *
# Line 114  Returns:     nothing Line 112  Returns:     nothing
112  static void  static void
113  pchars(const pcre_uchar *p, int length, BOOL is_subject, match_data *md)  pchars(const pcre_uchar *p, int length, BOOL is_subject, match_data *md)
114  {  {
115  unsigned int c;  pcre_uint32 c;
116    BOOL utf = md->utf;
117  if (is_subject && length > md->end_subject - p) length = md->end_subject - p;  if (is_subject && length > md->end_subject - p) length = md->end_subject - p;
118  while (length-- > 0)  while (length-- > 0)
119    if (isprint(c = *(p++))) printf("%c", c); else printf("\\x%02x", c);    if (isprint(c = RAWUCHARINCTEST(p))) printf("%c", (char)c); else printf("\\x{%02x}", c);
120  }  }
121  #endif  #endif
122    
# Line 150  match_ref(int offset, register PCRE_PUCH Line 149  match_ref(int offset, register PCRE_PUCH
149  {  {
150  PCRE_PUCHAR eptr_start = eptr;  PCRE_PUCHAR eptr_start = eptr;
151  register PCRE_PUCHAR p = md->start_subject + md->offset_vector[offset];  register PCRE_PUCHAR p = md->start_subject + md->offset_vector[offset];
152    BOOL utf = md->utf;
153    
154  #ifdef PCRE_DEBUG  #ifdef PCRE_DEBUG
155  if (eptr >= md->end_subject)  if (eptr >= md->end_subject)
# Line 177  if (caseless) Line 177  if (caseless)
177    {    {
178  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
179  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
180    if (md->utf)    if (utf)
181      {      {
182      /* Match characters up to the end of the reference. NOTE: the number of      /* Match characters up to the end of the reference. NOTE: the number of
183      data units matched may differ, because in UTF-8 there are some characters      data units matched may differ, because in UTF-8 there are some characters
# Line 191  if (caseless) Line 191  if (caseless)
191      PCRE_PUCHAR endptr = p + length;      PCRE_PUCHAR endptr = p + length;
192      while (p < endptr)      while (p < endptr)
193        {        {
194        unsigned int c, d;        pcre_uint32 c, d;
195        const ucd_record *ur;        const ucd_record *ur;
196        if (eptr >= md->end_subject) return -2;   /* Partial match */        if (eptr >= md->end_subject) return -2;   /* Partial match */
197        GETCHARINC(c, eptr);        GETCHARINC(c, eptr);
# Line 200  if (caseless) Line 200  if (caseless)
200        if (c != d && c != d + ur->other_case)        if (c != d && c != d + ur->other_case)
201          {          {
202          const pcre_uint32 *pp = PRIV(ucd_caseless_sets) + ur->caseset;          const pcre_uint32 *pp = PRIV(ucd_caseless_sets) + ur->caseset;
203          for (;;)          for (;;)
204            {            {
205            if (c < *pp) return -1;            if (c < *pp) return -1;
206            if (c == *pp++) break;            if (c == *pp++) break;
207            }            }
208          }          }
209        }        }
210      }      }
211    else    else
# Line 217  if (caseless) Line 217  if (caseless)
217      {      {
218      while (length-- > 0)      while (length-- > 0)
219        {        {
220          pcre_uchar cc, cp;
221        if (eptr >= md->end_subject) return -2;   /* Partial match */        if (eptr >= md->end_subject) return -2;   /* Partial match */
222        if (TABLE_GET(*p, md->lcc, *p) != TABLE_GET(*eptr, md->lcc, *eptr)) return -1;        cc = RAWUCHARTEST(eptr);
223          cp = RAWUCHARTEST(p);
224          if (TABLE_GET(cp, md->lcc, cp) != TABLE_GET(cc, md->lcc, cc)) return -1;
225        p++;        p++;
226        eptr++;        eptr++;
227        }        }
# Line 233  else Line 236  else
236    while (length-- > 0)    while (length-- > 0)
237      {      {
238      if (eptr >= md->end_subject) return -2;   /* Partial match */      if (eptr >= md->end_subject) return -2;   /* Partial match */
239      if (*p++ != *eptr++) return -1;      if (RAWUCHARINCTEST(p) != RAWUCHARINCTEST(eptr)) return -1;
240      }      }
241    }    }
242    
# Line 307  actually used in this definition. */ Line 310  actually used in this definition. */
310    }    }
311  #define RRETURN(ra) \  #define RRETURN(ra) \
312    { \    { \
313    printf("match() returned %d from line %d ", ra, __LINE__); \    printf("match() returned %d from line %d\n", ra, __LINE__); \
314    return ra; \    return ra; \
315    }    }
316  #else  #else
# Line 499  so they can be ordinary variables in all Line 502  so they can be ordinary variables in all
502    
503  register int  rrc;         /* Returns from recursive calls */  register int  rrc;         /* Returns from recursive calls */
504  register int  i;           /* Used for loops not involving calls to RMATCH() */  register int  i;           /* Used for loops not involving calls to RMATCH() */
505  register unsigned int c;   /* Character values not kept over RMATCH() calls */  register pcre_uint32 c;    /* Character values not kept over RMATCH() calls */
506  register BOOL utf;         /* Local copy of UTF flag for speed */  register BOOL utf;         /* Local copy of UTF flag for speed */
507    
508  BOOL minimize, possessive; /* Quantifier options */  BOOL minimize, possessive; /* Quantifier options */
# Line 629  int max; Line 632  int max;
632  int min;  int min;
633  int number;  int number;
634  int offset;  int offset;
635  int op;  pcre_uchar op;
636  int save_capture_last;  int save_capture_last;
637  int save_offset1, save_offset2, save_offset3;  int save_offset1, save_offset2, save_offset3;
638  int stacksave[REC_STACK_SAVE_MAX];  int stacksave[REC_STACK_SAVE_MAX];
# Line 748  for (;;) Line 751  for (;;)
751      unaltered. */      unaltered. */
752    
753      else if (rrc == MATCH_SKIP_ARG &&      else if (rrc == MATCH_SKIP_ARG &&
754          STRCMP_UC_UC(ecode + 2, md->start_match_ptr) == 0)          STRCMP_UC_UC_TEST(ecode + 2, md->start_match_ptr) == 0)
755        {        {
756        md->start_match_ptr = eptr;        md->start_match_ptr = eptr;
757        RRETURN(MATCH_SKIP);        RRETURN(MATCH_SKIP);
# Line 1273  for (;;) Line 1276  for (;;)
1276          cb.version          = 2;   /* Version 1 of the callout block */          cb.version          = 2;   /* Version 1 of the callout block */
1277          cb.callout_number   = ecode[LINK_SIZE+2];          cb.callout_number   = ecode[LINK_SIZE+2];
1278          cb.offset_vector    = md->offset_vector;          cb.offset_vector    = md->offset_vector;
1279  #ifdef COMPILE_PCRE8  #if defined COMPILE_PCRE8
1280          cb.subject          = (PCRE_SPTR)md->start_subject;          cb.subject          = (PCRE_SPTR)md->start_subject;
1281  #else  #elif defined COMPILE_PCRE16
1282          cb.subject          = (PCRE_SPTR16)md->start_subject;          cb.subject          = (PCRE_SPTR16)md->start_subject;
1283    #elif defined COMPILE_PCRE32
1284            cb.subject          = (PCRE_SPTR32)md->start_subject;
1285  #endif  #endif
1286          cb.subject_length   = (int)(md->end_subject - md->start_subject);          cb.subject_length   = (int)(md->end_subject - md->start_subject);
1287          cb.start_match      = (int)(mstart - md->start_subject);          cb.start_match      = (int)(mstart - md->start_subject);
# Line 1696  for (;;) Line 1701  for (;;)
1701        cb.version          = 2;   /* Version 1 of the callout block */        cb.version          = 2;   /* Version 1 of the callout block */
1702        cb.callout_number   = ecode[1];        cb.callout_number   = ecode[1];
1703        cb.offset_vector    = md->offset_vector;        cb.offset_vector    = md->offset_vector;
1704  #ifdef COMPILE_PCRE8  #if defined COMPILE_PCRE8
1705        cb.subject          = (PCRE_SPTR)md->start_subject;        cb.subject          = (PCRE_SPTR)md->start_subject;
1706  #else  #elif defined COMPILE_PCRE16
1707        cb.subject          = (PCRE_SPTR16)md->start_subject;        cb.subject          = (PCRE_SPTR16)md->start_subject;
1708    #elif defined COMPILE_PCRE32
1709          cb.subject          = (PCRE_SPTR32)md->start_subject;
1710  #endif  #endif
1711        cb.subject_length   = (int)(md->end_subject - md->start_subject);        cb.subject_length   = (int)(md->end_subject - md->start_subject);
1712        cb.start_match      = (int)(mstart - md->start_subject);        cb.start_match      = (int)(mstart - md->start_subject);
# Line 2090  for (;;) Line 2097  for (;;)
2097              eptr + 1 >= md->end_subject &&              eptr + 1 >= md->end_subject &&
2098              NLBLOCK->nltype == NLTYPE_FIXED &&              NLBLOCK->nltype == NLTYPE_FIXED &&
2099              NLBLOCK->nllen == 2 &&              NLBLOCK->nllen == 2 &&
2100              *eptr == NLBLOCK->nl[0])              RAWUCHARTEST(eptr) == NLBLOCK->nl[0])
2101            {            {
2102            md->hitend = TRUE;            md->hitend = TRUE;
2103            if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);            if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
# Line 2134  for (;;) Line 2141  for (;;)
2141            eptr + 1 >= md->end_subject &&            eptr + 1 >= md->end_subject &&
2142            NLBLOCK->nltype == NLTYPE_FIXED &&            NLBLOCK->nltype == NLTYPE_FIXED &&
2143            NLBLOCK->nllen == 2 &&            NLBLOCK->nllen == 2 &&
2144            *eptr == NLBLOCK->nl[0])            RAWUCHARTEST(eptr) == NLBLOCK->nl[0])
2145          {          {
2146          md->hitend = TRUE;          md->hitend = TRUE;
2147          if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);          if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
# Line 2277  for (;;) Line 2284  for (;;)
2284          eptr + 1 >= md->end_subject &&          eptr + 1 >= md->end_subject &&
2285          NLBLOCK->nltype == NLTYPE_FIXED &&          NLBLOCK->nltype == NLTYPE_FIXED &&
2286          NLBLOCK->nllen == 2 &&          NLBLOCK->nllen == 2 &&
2287          *eptr == NLBLOCK->nl[0])          RAWUCHARTEST(eptr) == NLBLOCK->nl[0])
2288        {        {
2289        md->hitend = TRUE;        md->hitend = TRUE;
2290        if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);        if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
# Line 2431  for (;;) Line 2438  for (;;)
2438          {          {
2439          SCHECK_PARTIAL();          SCHECK_PARTIAL();
2440          }          }
2441        else if (*eptr == CHAR_LF) eptr++;        else if (RAWUCHARTEST(eptr) == CHAR_LF) eptr++;
2442        break;        break;
2443    
2444        case CHAR_LF:        case CHAR_LF:
# Line 2583  for (;;) Line 2590  for (;;)
2590               c == CHAR_UNDERSCORE) == (op == OP_NOTPROP))               c == CHAR_UNDERSCORE) == (op == OP_NOTPROP))
2591            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2592          break;          break;
2593    
2594          case PT_CLIST:          case PT_CLIST:
2595          cp = PRIV(ucd_caseless_sets) + prop->caseset;          cp = PRIV(ucd_caseless_sets) + prop->caseset;
2596          for (;;)          for (;;)
2597            {            {
2598            if (c < *cp)            if (c < *cp)
2599              { if (op == OP_PROP) RRETURN(MATCH_NOMATCH); else break; }              { if (op == OP_PROP) { RRETURN(MATCH_NOMATCH); } else break; }
2600            if (c == *cp++)            if (c == *cp++)
2601              { if (op == OP_PROP) break; else RRETURN(MATCH_NOMATCH); }              { if (op == OP_PROP) break; else { RRETURN(MATCH_NOMATCH); } }
2602            }            }
2603          break;          break;
2604    
2605          /* This should never occur */          /* This should never occur */
2606    
# Line 3141  for (;;) Line 3148  for (;;)
3148          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */
3149          RRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
3150          }          }
3151        while (length-- > 0) if (*ecode++ != *eptr++) RRETURN(MATCH_NOMATCH);        while (length-- > 0) if (*ecode++ != RAWUCHARINC(eptr)) RRETURN(MATCH_NOMATCH);
3152        }        }
3153      else      else
3154  #endif  #endif
# Line 3181  for (;;) Line 3188  for (;;)
3188    
3189        if (fc < 128)        if (fc < 128)
3190          {          {
3191          if (md->lcc[fc]          pcre_uchar cc = RAWUCHAR(eptr);
3192              != TABLE_GET(*eptr, md->lcc, *eptr)) RRETURN(MATCH_NOMATCH);          if (md->lcc[fc] != TABLE_GET(cc, md->lcc, cc)) RRETURN(MATCH_NOMATCH);
3193          ecode++;          ecode++;
3194          eptr++;          eptr++;
3195          }          }
# Line 3193  for (;;) Line 3200  for (;;)
3200    
3201        else        else
3202          {          {
3203          unsigned int dc;          pcre_uint32 dc;
3204          GETCHARINC(dc, eptr);          GETCHARINC(dc, eptr);
3205          ecode += length;          ecode += length;
3206    
# Line 3303  for (;;) Line 3310  for (;;)
3310        if (length > 1)        if (length > 1)
3311          {          {
3312  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
3313          unsigned int othercase;          pcre_uint32 othercase;
3314          if (op >= OP_STARI &&     /* Caseless */          if (op >= OP_STARI &&     /* Caseless */
3315              (othercase = UCD_OTHERCASE(fc)) != fc)              (othercase = UCD_OTHERCASE(fc)) != fc)
3316            oclength = PRIV(ord2utf)(othercase, occhars);            oclength = PRIV(ord2utf)(othercase, occhars);
# Line 3430  for (;;) Line 3437  for (;;)
3437    
3438        for (i = 1; i <= min; i++)        for (i = 1; i <= min; i++)
3439          {          {
3440            pcre_uchar cc;
3441    
3442          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
3443            {            {
3444            SCHECK_PARTIAL();            SCHECK_PARTIAL();
3445            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
3446            }            }
3447          if (fc != *eptr && foc != *eptr) RRETURN(MATCH_NOMATCH);          cc = RAWUCHARTEST(eptr);
3448            if (fc != cc && foc != cc) RRETURN(MATCH_NOMATCH);
3449          eptr++;          eptr++;
3450          }          }
3451        if (min == max) continue;        if (min == max) continue;
# Line 3443  for (;;) Line 3453  for (;;)
3453          {          {
3454          for (fi = min;; fi++)          for (fi = min;; fi++)
3455            {            {
3456              pcre_uchar cc;
3457    
3458            RMATCH(eptr, ecode, offset_top, md, eptrb, RM24);            RMATCH(eptr, ecode, offset_top, md, eptrb, RM24);
3459            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3460            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) RRETURN(MATCH_NOMATCH);
# Line 3451  for (;;) Line 3463  for (;;)
3463              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3464              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3465              }              }
3466            if (fc != *eptr && foc != *eptr) RRETURN(MATCH_NOMATCH);            cc = RAWUCHARTEST(eptr);
3467              if (fc != cc && foc != cc) RRETURN(MATCH_NOMATCH);
3468            eptr++;            eptr++;
3469            }            }
3470          /* Control never gets here */          /* Control never gets here */
# Line 3461  for (;;) Line 3474  for (;;)
3474          pp = eptr;          pp = eptr;
3475          for (i = min; i < max; i++)          for (i = min; i < max; i++)
3476            {            {
3477              pcre_uchar cc;
3478    
3479            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3480              {              {
3481              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3482              break;              break;
3483              }              }
3484            if (fc != *eptr && foc != *eptr) break;            cc = RAWUCHARTEST(eptr);
3485              if (fc != cc && foc != cc) break;
3486            eptr++;            eptr++;
3487            }            }
3488    
# Line 3494  for (;;) Line 3510  for (;;)
3510            SCHECK_PARTIAL();            SCHECK_PARTIAL();
3511            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
3512            }            }
3513          if (fc != *eptr++) RRETURN(MATCH_NOMATCH);          if (fc != RAWUCHARINCTEST(eptr)) RRETURN(MATCH_NOMATCH);
3514          }          }
3515    
3516        if (min == max) continue;        if (min == max) continue;
# Line 3511  for (;;) Line 3527  for (;;)
3527              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3528              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3529              }              }
3530            if (fc != *eptr++) RRETURN(MATCH_NOMATCH);            if (fc != RAWUCHARINCTEST(eptr)) RRETURN(MATCH_NOMATCH);
3531            }            }
3532          /* Control never gets here */          /* Control never gets here */
3533          }          }
# Line 3525  for (;;) Line 3541  for (;;)
3541              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3542              break;              break;
3543              }              }
3544            if (fc != *eptr) break;            if (fc != RAWUCHARTEST(eptr)) break;
3545            eptr++;            eptr++;
3546            }            }
3547          if (possessive) continue;          if (possessive) continue;
# Line 3554  for (;;) Line 3570  for (;;)
3570  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
3571      if (utf)      if (utf)
3572        {        {
3573        register unsigned int ch, och;        register pcre_uint32 ch, och;
3574    
3575        ecode++;        ecode++;
3576        GETCHARINC(ch, ecode);        GETCHARINC(ch, ecode);
# Line 3581  for (;;) Line 3597  for (;;)
3597      else      else
3598  #endif  #endif
3599        {        {
3600        register unsigned int ch = ecode[1];        register pcre_uint32 ch = ecode[1];
3601        c = *eptr++;        c = *eptr++;
3602        if (ch == c || (op == OP_NOTI && TABLE_GET(ch, md->fcc, ch) == c))        if (ch == c || (op == OP_NOTI && TABLE_GET(ch, md->fcc, ch) == c))
3603          RRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
# Line 3695  for (;;) Line 3711  for (;;)
3711  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
3712        if (utf)        if (utf)
3713          {          {
3714          register unsigned int d;          register pcre_uint32 d;
3715          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3716            {            {
3717            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
# Line 3730  for (;;) Line 3746  for (;;)
3746  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
3747          if (utf)          if (utf)
3748            {            {
3749            register unsigned int d;            register pcre_uint32 d;
3750            for (fi = min;; fi++)            for (fi = min;; fi++)
3751              {              {
3752              RMATCH(eptr, ecode, offset_top, md, eptrb, RM28);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM28);
# Line 3775  for (;;) Line 3791  for (;;)
3791  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
3792          if (utf)          if (utf)
3793            {            {
3794            register unsigned int d;            register pcre_uint32 d;
3795            for (i = min; i < max; i++)            for (i = min; i < max; i++)
3796              {              {
3797              int len = 1;              int len = 1;
# Line 3832  for (;;) Line 3848  for (;;)
3848  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
3849        if (utf)        if (utf)
3850          {          {
3851          register unsigned int d;          register pcre_uint32 d;
3852          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3853            {            {
3854            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
# Line 3866  for (;;) Line 3882  for (;;)
3882  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
3883          if (utf)          if (utf)
3884            {            {
3885            register unsigned int d;            register pcre_uint32 d;
3886            for (fi = min;; fi++)            for (fi = min;; fi++)
3887              {              {
3888              RMATCH(eptr, ecode, offset_top, md, eptrb, RM32);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM32);
# Line 3910  for (;;) Line 3926  for (;;)
3926  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
3927          if (utf)          if (utf)
3928            {            {
3929            register unsigned int d;            register pcre_uint32 d;
3930            for (i = min; i < max; i++)            for (i = min; i < max; i++)
3931              {              {
3932              int len = 1;              int len = 1;
# Line 4200  for (;;) Line 4216  for (;;)
4216              for (;;)              for (;;)
4217                {                {
4218                if (c < *cp)                if (c < *cp)
4219                  { if (prop_fail_result) break; else RRETURN(MATCH_NOMATCH); }                  { if (prop_fail_result) break; else { RRETURN(MATCH_NOMATCH); } }
4220                if (c == *cp++)                if (c == *cp++)
4221                  { if (prop_fail_result) RRETURN(MATCH_NOMATCH); else break; }                  { if (prop_fail_result) { RRETURN(MATCH_NOMATCH); } else break; }
4222                }                }
4223              }              }
4224            break;            break;
4225    
4226            /* This should not occur */            /* This should not occur */
4227    
# Line 4266  for (;;) Line 4282  for (;;)
4282                eptr + 1 >= md->end_subject &&                eptr + 1 >= md->end_subject &&
4283                NLBLOCK->nltype == NLTYPE_FIXED &&                NLBLOCK->nltype == NLTYPE_FIXED &&
4284                NLBLOCK->nllen == 2 &&                NLBLOCK->nllen == 2 &&
4285                *eptr == NLBLOCK->nl[0])                RAWUCHAR(eptr) == NLBLOCK->nl[0])
4286              {              {
4287              md->hitend = TRUE;              md->hitend = TRUE;
4288              if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);              if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
# Line 4308  for (;;) Line 4324  for (;;)
4324              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4325    
4326              case CHAR_CR:              case CHAR_CR:
4327              if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;              if (eptr < md->end_subject && RAWUCHAR(eptr) == CHAR_LF) eptr++;
4328              break;              break;
4329    
4330              case CHAR_LF:              case CHAR_LF:
# Line 4412  for (;;) Line 4428  for (;;)
4428          case OP_DIGIT:          case OP_DIGIT:
4429          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
4430            {            {
4431              pcre_uchar cc;
4432    
4433            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4434              {              {
4435              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4436              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4437              }              }
4438            if (*eptr >= 128 || (md->ctypes[*eptr] & ctype_digit) == 0)            cc = RAWUCHAR(eptr);
4439              if (cc >= 128 || (md->ctypes[cc] & ctype_digit) == 0)
4440              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4441            eptr++;            eptr++;
4442            /* No need to skip more bytes - we know it's a 1-byte character */            /* No need to skip more bytes - we know it's a 1-byte character */
# Line 4427  for (;;) Line 4446  for (;;)
4446          case OP_NOT_WHITESPACE:          case OP_NOT_WHITESPACE:
4447          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
4448            {            {
4449              pcre_uchar cc;
4450    
4451            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4452              {              {
4453              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4454              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4455              }              }
4456            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0)            cc = RAWUCHAR(eptr);
4457              if (cc < 128 && (md->ctypes[cc] & ctype_space) != 0)
4458              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4459            eptr++;            eptr++;
4460            ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);            ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
# Line 4442  for (;;) Line 4464  for (;;)
4464          case OP_WHITESPACE:          case OP_WHITESPACE:
4465          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
4466            {            {
4467              pcre_uchar cc;
4468    
4469            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4470              {              {
4471              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4472              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4473              }              }
4474            if (*eptr >= 128 || (md->ctypes[*eptr] & ctype_space) == 0)            cc = RAWUCHAR(eptr);
4475              if (cc >= 128 || (md->ctypes[cc] & ctype_space) == 0)
4476              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4477            eptr++;            eptr++;
4478            /* No need to skip more bytes - we know it's a 1-byte character */            /* No need to skip more bytes - we know it's a 1-byte character */
# Line 4457  for (;;) Line 4482  for (;;)
4482          case OP_NOT_WORDCHAR:          case OP_NOT_WORDCHAR:
4483          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
4484            {            {
4485              pcre_uchar cc;
4486    
4487            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4488              {              {
4489              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4490              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4491              }              }
4492            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0)            cc = RAWUCHAR(eptr);
4493              if (cc < 128 && (md->ctypes[cc] & ctype_word) != 0)
4494              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4495            eptr++;            eptr++;
4496            ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);            ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
# Line 4472  for (;;) Line 4500  for (;;)
4500          case OP_WORDCHAR:          case OP_WORDCHAR:
4501          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
4502            {            {
4503              pcre_uchar cc;
4504    
4505            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4506              {              {
4507              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4508              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4509              }              }
4510            if (*eptr >= 128 || (md->ctypes[*eptr] & ctype_word) == 0)            cc = RAWUCHAR(eptr);
4511              if (cc >= 128 || (md->ctypes[cc] & ctype_word) == 0)
4512              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4513            eptr++;            eptr++;
4514            /* No need to skip more bytes - we know it's a 1-byte character */            /* No need to skip more bytes - we know it's a 1-byte character */
# Line 4558  for (;;) Line 4589  for (;;)
4589              case CHAR_VT:              case CHAR_VT:
4590              case CHAR_FF:              case CHAR_FF:
4591              case CHAR_NEL:              case CHAR_NEL:
4592  #ifdef COMPILE_PCRE16  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
4593              case 0x2028:              case 0x2028:
4594              case 0x2029:              case 0x2029:
4595  #endif  #endif
# Line 4580  for (;;) Line 4611  for (;;)
4611              {              {
4612              default: break;              default: break;
4613              HSPACE_BYTE_CASES:              HSPACE_BYTE_CASES:
4614  #ifdef COMPILE_PCRE16  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
4615              HSPACE_MULTIBYTE_CASES:              HSPACE_MULTIBYTE_CASES:
4616  #endif  #endif
4617              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
# Line 4600  for (;;) Line 4631  for (;;)
4631              {              {
4632              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4633              HSPACE_BYTE_CASES:              HSPACE_BYTE_CASES:
4634  #ifdef COMPILE_PCRE16  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
4635              HSPACE_MULTIBYTE_CASES:              HSPACE_MULTIBYTE_CASES:
4636  #endif  #endif
4637              break;              break;
# Line 4619  for (;;) Line 4650  for (;;)
4650            switch(*eptr++)            switch(*eptr++)
4651              {              {
4652              VSPACE_BYTE_CASES:              VSPACE_BYTE_CASES:
4653  #ifdef COMPILE_PCRE16  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
4654              VSPACE_MULTIBYTE_CASES:              VSPACE_MULTIBYTE_CASES:
4655  #endif  #endif
4656              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
# Line 4640  for (;;) Line 4671  for (;;)
4671              {              {
4672              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4673              VSPACE_BYTE_CASES:              VSPACE_BYTE_CASES:
4674  #ifdef COMPILE_PCRE16  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
4675              VSPACE_MULTIBYTE_CASES:              VSPACE_MULTIBYTE_CASES:
4676  #endif  #endif
4677              break;              break;
# Line 4935  for (;;) Line 4966  for (;;)
4966              cp = PRIV(ucd_caseless_sets) + UCD_CASESET(c);              cp = PRIV(ucd_caseless_sets) + UCD_CASESET(c);
4967              for (;;)              for (;;)
4968                {                {
4969                if (c < *cp)                if (c < *cp)
4970                  { if (prop_fail_result) break; else RRETURN(MATCH_NOMATCH); }                  { if (prop_fail_result) break; else { RRETURN(MATCH_NOMATCH); } }
4971                if (c == *cp++)                if (c == *cp++)
4972                  { if (prop_fail_result) RRETURN(MATCH_NOMATCH); else break; }                  { if (prop_fail_result) { RRETURN(MATCH_NOMATCH); } else break; }
4973                }                }
4974              }              }
4975            /* Control never gets here */            /* Control never gets here */
4976    
# Line 5024  for (;;) Line 5055  for (;;)
5055                {                {
5056                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5057                case CHAR_CR:                case CHAR_CR:
5058                if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;                if (eptr < md->end_subject && RAWUCHAR(eptr) == CHAR_LF) eptr++;
5059                break;                break;
5060    
5061                case CHAR_LF:                case CHAR_LF:
# Line 5158  for (;;) Line 5189  for (;;)
5189                case CHAR_VT:                case CHAR_VT:
5190                case CHAR_FF:                case CHAR_FF:
5191                case CHAR_NEL:                case CHAR_NEL:
5192  #ifdef COMPILE_PCRE16  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5193                case 0x2028:                case 0x2028:
5194                case 0x2029:                case 0x2029:
5195  #endif  #endif
# Line 5172  for (;;) Line 5203  for (;;)
5203                {                {
5204                default: break;                default: break;
5205                HSPACE_BYTE_CASES:                HSPACE_BYTE_CASES:
5206  #ifdef COMPILE_PCRE16  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5207                HSPACE_MULTIBYTE_CASES:                HSPACE_MULTIBYTE_CASES:
5208  #endif  #endif
5209                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
# Line 5184  for (;;) Line 5215  for (;;)
5215                {                {
5216                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5217                HSPACE_BYTE_CASES:                HSPACE_BYTE_CASES:
5218  #ifdef COMPILE_PCRE16  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5219                HSPACE_MULTIBYTE_CASES:                HSPACE_MULTIBYTE_CASES:
5220  #endif  #endif
5221                break;                break;
# Line 5196  for (;;) Line 5227  for (;;)
5227                {                {
5228                default: break;                default: break;
5229                VSPACE_BYTE_CASES:                VSPACE_BYTE_CASES:
5230  #ifdef COMPILE_PCRE16  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5231                VSPACE_MULTIBYTE_CASES:                VSPACE_MULTIBYTE_CASES:
5232  #endif  #endif
5233                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
# Line 5208  for (;;) Line 5239  for (;;)
5239                {                {
5240                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5241                VSPACE_BYTE_CASES:                VSPACE_BYTE_CASES:
5242  #ifdef COMPILE_PCRE16  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5243                VSPACE_MULTIBYTE_CASES:                VSPACE_MULTIBYTE_CASES:
5244  #endif  #endif
5245                break;                break;
# Line 5528  for (;;) Line 5559  for (;;)
5559                    eptr + 1 >= md->end_subject &&                    eptr + 1 >= md->end_subject &&
5560                    NLBLOCK->nltype == NLTYPE_FIXED &&                    NLBLOCK->nltype == NLTYPE_FIXED &&
5561                    NLBLOCK->nllen == 2 &&                    NLBLOCK->nllen == 2 &&
5562                    *eptr == NLBLOCK->nl[0])                    RAWUCHAR(eptr) == NLBLOCK->nl[0])
5563                  {                  {
5564                  md->hitend = TRUE;                  md->hitend = TRUE;
5565                  if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);                  if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
# Line 5554  for (;;) Line 5585  for (;;)
5585                    eptr + 1 >= md->end_subject &&                    eptr + 1 >= md->end_subject &&
5586                    NLBLOCK->nltype == NLTYPE_FIXED &&                    NLBLOCK->nltype == NLTYPE_FIXED &&
5587                    NLBLOCK->nllen == 2 &&                    NLBLOCK->nllen == 2 &&
5588                    *eptr == NLBLOCK->nl[0])                    RAWUCHAR(eptr) == NLBLOCK->nl[0])
5589                  {                  {
5590                  md->hitend = TRUE;                  md->hitend = TRUE;
5591                  if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);                  if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
# Line 5611  for (;;) Line 5642  for (;;)
5642              if (c == CHAR_CR)              if (c == CHAR_CR)
5643                {                {
5644                if (++eptr >= md->end_subject) break;                if (++eptr >= md->end_subject) break;
5645                if (*eptr == CHAR_LF) eptr++;                if (RAWUCHAR(eptr) == CHAR_LF) eptr++;
5646                }                }
5647              else              else
5648                {                {
# Line 5779  for (;;) Line 5810  for (;;)
5810            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
5811            if (eptr-- == pp) break;        /* Stop if tried at original pos */            if (eptr-- == pp) break;        /* Stop if tried at original pos */
5812            BACKCHAR(eptr);            BACKCHAR(eptr);
5813            if (ctype == OP_ANYNL && eptr > pp  && *eptr == CHAR_NL &&            if (ctype == OP_ANYNL && eptr > pp  && RAWUCHAR(eptr) == CHAR_NL &&
5814                eptr[-1] == CHAR_CR) eptr--;                RAWUCHAR(eptr - 1) == CHAR_CR) eptr--;
5815            }            }
5816          }          }
5817        else        else
# Line 5840  for (;;) Line 5871  for (;;)
5871                {                {
5872                if (c != CHAR_LF && (md->bsr_anycrlf ||                if (c != CHAR_LF && (md->bsr_anycrlf ||
5873                   (c != CHAR_VT && c != CHAR_FF && c != CHAR_NEL                   (c != CHAR_VT && c != CHAR_FF && c != CHAR_NEL
5874  #ifdef COMPILE_PCRE16  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5875                   && c != 0x2028 && c != 0x2029                   && c != 0x2028 && c != 0x2029
5876  #endif  #endif
5877                   ))) break;                   ))) break;
# Line 5861  for (;;) Line 5892  for (;;)
5892                {                {
5893                default: eptr++; break;                default: eptr++; break;
5894                HSPACE_BYTE_CASES:                HSPACE_BYTE_CASES:
5895  #ifdef COMPILE_PCRE16  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5896                HSPACE_MULTIBYTE_CASES:                HSPACE_MULTIBYTE_CASES:
5897  #endif  #endif
5898                goto ENDLOOP00;                goto ENDLOOP00;
# Line 5882  for (;;) Line 5913  for (;;)
5913                {                {
5914                default: goto ENDLOOP01;                default: goto ENDLOOP01;
5915                HSPACE_BYTE_CASES:                HSPACE_BYTE_CASES:
5916  #ifdef COMPILE_PCRE16  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5917                HSPACE_MULTIBYTE_CASES:                HSPACE_MULTIBYTE_CASES:
5918  #endif  #endif
5919                eptr++; break;                eptr++; break;
# Line 5903  for (;;) Line 5934  for (;;)
5934                {                {
5935                default: eptr++; break;                default: eptr++; break;
5936                VSPACE_BYTE_CASES:                VSPACE_BYTE_CASES:
5937  #ifdef COMPILE_PCRE16  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5938                VSPACE_MULTIBYTE_CASES:                VSPACE_MULTIBYTE_CASES:
5939  #endif  #endif
5940                goto ENDLOOP02;                goto ENDLOOP02;
# Line 5924  for (;;) Line 5955  for (;;)
5955                {                {
5956                default: goto ENDLOOP03;                default: goto ENDLOOP03;
5957                VSPACE_BYTE_CASES:                VSPACE_BYTE_CASES:
5958  #ifdef COMPILE_PCRE16  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5959                VSPACE_MULTIBYTE_CASES:                VSPACE_MULTIBYTE_CASES:
5960  #endif  #endif
5961                eptr++; break;                eptr++; break;
# Line 6197  Returns:          > 0 => success; value Line 6228  Returns:          > 0 => success; value
6228                   < -1 => some kind of unexpected problem                   < -1 => some kind of unexpected problem
6229  */  */
6230    
6231  #ifdef COMPILE_PCRE8  #if defined COMPILE_PCRE8
6232  PCRE_EXP_DEFN int PCRE_CALL_CONVENTION  PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
6233  pcre_exec(const pcre *argument_re, const pcre_extra *extra_data,  pcre_exec(const pcre *argument_re, const pcre_extra *extra_data,
6234    PCRE_SPTR subject, int length, int start_offset, int options, int *offsets,    PCRE_SPTR subject, int length, int start_offset, int options, int *offsets,
6235    int offsetcount)    int offsetcount)
6236  #else  #elif defined COMPILE_PCRE16
6237  PCRE_EXP_DEFN int PCRE_CALL_CONVENTION  PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
6238  pcre16_exec(const pcre16 *argument_re, const pcre16_extra *extra_data,  pcre16_exec(const pcre16 *argument_re, const pcre16_extra *extra_data,
6239    PCRE_SPTR16 subject, int length, int start_offset, int options, int *offsets,    PCRE_SPTR16 subject, int length, int start_offset, int options, int *offsets,
6240    int offsetcount)    int offsetcount)
6241    #elif defined COMPILE_PCRE32
6242    PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
6243    pcre32_exec(const pcre32 *argument_re, const pcre32_extra *extra_data,
6244      PCRE_SPTR32 subject, int length, int start_offset, int options, int *offsets,
6245      int offsetcount)
6246  #endif  #endif
6247  {  {
6248  int rc, ocount, arg_offset_max;  int rc, ocount, arg_offset_max;
# Line 6297  if (utf && (options & PCRE_NO_UTF8_CHECK Line 6333  if (utf && (options & PCRE_NO_UTF8_CHECK
6333        offsets[0] = erroroffset;        offsets[0] = erroroffset;
6334        offsets[1] = errorcode;        offsets[1] = errorcode;
6335        }        }
6336  #ifdef COMPILE_PCRE16  #if defined COMPILE_PCRE8
     return (errorcode <= PCRE_UTF16_ERR1 && md->partial > 1)?  
       PCRE_ERROR_SHORTUTF16 : PCRE_ERROR_BADUTF16;  
 #else  
6337      return (errorcode <= PCRE_UTF8_ERR5 && md->partial > 1)?      return (errorcode <= PCRE_UTF8_ERR5 && md->partial > 1)?
6338        PCRE_ERROR_SHORTUTF8 : PCRE_ERROR_BADUTF8;        PCRE_ERROR_SHORTUTF8 : PCRE_ERROR_BADUTF8;
6339    #elif defined COMPILE_PCRE16
6340        return (errorcode <= PCRE_UTF16_ERR1 && md->partial > 1)?
6341          PCRE_ERROR_SHORTUTF16 : PCRE_ERROR_BADUTF16;
6342    #elif defined COMPILE_PCRE32
6343        return PCRE_ERROR_BADUTF32;
6344  #endif  #endif
6345      }      }
6346    #if defined COMPILE_PCRE8 || defined COMPILE_PCRE16
6347    /* Check that a start_offset points to the start of a UTF character. */    /* Check that a start_offset points to the start of a UTF character. */
6348    if (start_offset > 0 && start_offset < length &&    if (start_offset > 0 && start_offset < length &&
6349        NOT_FIRSTCHAR(((PCRE_PUCHAR)subject)[start_offset]))        NOT_FIRSTCHAR(((PCRE_PUCHAR)subject)[start_offset]))
6350      return PCRE_ERROR_BADUTF8_OFFSET;      return PCRE_ERROR_BADUTF8_OFFSET;
6351    #endif
6352    }    }
6353  #endif  #endif
6354    
# Line 6617  for(;;) Line 6656  for(;;)
6656    
6657      if (has_first_char)      if (has_first_char)
6658        {        {
6659          pcre_uchar smc;
6660    
6661        if (first_char != first_char2)        if (first_char != first_char2)
6662          while (start_match < end_subject &&          while (start_match < end_subject &&
6663              *start_match != first_char && *start_match != first_char2)            (smc = RAWUCHARTEST(start_match)) != first_char && smc != first_char2)
6664            start_match++;            start_match++;
6665        else        else
6666          while (start_match < end_subject && *start_match != first_char)          while (start_match < end_subject && RAWUCHARTEST(start_match) != first_char)
6667            start_match++;            start_match++;
6668        }        }
6669    
# Line 6654  for(;;) Line 6695  for(;;)
6695          if (start_match[-1] == CHAR_CR &&          if (start_match[-1] == CHAR_CR &&
6696               (md->nltype == NLTYPE_ANY || md->nltype == NLTYPE_ANYCRLF) &&               (md->nltype == NLTYPE_ANY || md->nltype == NLTYPE_ANYCRLF) &&
6697               start_match < end_subject &&               start_match < end_subject &&
6698               *start_match == CHAR_NL)               RAWUCHARTEST(start_match) == CHAR_NL)
6699            start_match++;            start_match++;
6700          }          }
6701        }        }
# Line 6665  for(;;) Line 6706  for(;;)
6706        {        {
6707        while (start_match < end_subject)        while (start_match < end_subject)
6708          {          {
6709          register unsigned int c = *start_match;          register pcre_uint32 c = RAWUCHARTEST(start_match);
6710  #ifndef COMPILE_PCRE8  #ifndef COMPILE_PCRE8
6711          if (c > 255) c = 255;          if (c > 255) c = 255;
6712  #endif  #endif
# Line 6733  for(;;) Line 6774  for(;;)
6774            {            {
6775            while (p < end_subject)            while (p < end_subject)
6776              {              {
6777              register int pp = *p++;              register pcre_uint32 pp = RAWUCHARINCTEST(p);
6778              if (pp == req_char || pp == req_char2) { p--; break; }              if (pp == req_char || pp == req_char2) { p--; break; }
6779              }              }
6780            }            }
# Line 6741  for(;;) Line 6782  for(;;)
6782            {            {
6783            while (p < end_subject)            while (p < end_subject)
6784              {              {
6785              if (*p++ == req_char) { p--; break; }              if (RAWUCHARINCTEST(p) == req_char) { p--; break; }
6786              }              }
6787            }            }
6788    

Legend:
Removed from v.1046  
changed lines
  Added in v.1102

  ViewVC Help
Powered by ViewVC 1.1.5