/[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 462 by ph10, Sat Oct 17 19:55:02 2009 UTC revision 500 by ph10, Sat Mar 6 19:00:29 2010 UTC
# Line 6  Line 6 
6  and semantics are as close as possible to those of the Perl 5 language.  and semantics are as close as possible to those of the Perl 5 language.
7    
8                         Written by Philip Hazel                         Written by Philip Hazel
9             Copyright (c) 1997-2009 University of Cambridge             Copyright (c) 1997-2010 University of Cambridge
10    
11  -----------------------------------------------------------------------------  -----------------------------------------------------------------------------
12  Redistribution and use in source and binary forms, with or without  Redistribution and use in source and binary forms, with or without
# Line 89  static const char rep_max[] = { 0, 0, 0, Line 89  static const char rep_max[] = { 0, 0, 0,
89    
90    
91    
92  #ifdef DEBUG  #ifdef PCRE_DEBUG
93  /*************************************************  /*************************************************
94  *        Debugging function to print chars       *  *        Debugging function to print chars       *
95  *************************************************/  *************************************************/
# Line 141  match_ref(int offset, register USPTR ept Line 141  match_ref(int offset, register USPTR ept
141  {  {
142  USPTR p = md->start_subject + md->offset_vector[offset];  USPTR p = md->start_subject + md->offset_vector[offset];
143    
144  #ifdef DEBUG  #ifdef PCRE_DEBUG
145  if (eptr >= md->end_subject)  if (eptr >= md->end_subject)
146    printf("matching subject <null>");    printf("matching subject <null>");
147  else  else
# Line 254  actuall used in this definition. */ Line 254  actuall used in this definition. */
254  #ifndef NO_RECURSE  #ifndef NO_RECURSE
255  #define REGISTER register  #define REGISTER register
256    
257  #ifdef DEBUG  #ifdef PCRE_DEBUG
258  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \
259    { \    { \
260    printf("match() called in line %d\n", __LINE__); \    printf("match() called in line %d\n", __LINE__); \
# Line 622  TAIL_RECURSE: Line 622  TAIL_RECURSE:
622  /* OK, now we can get on with the real code of the function. Recursive calls  /* OK, now we can get on with the real code of the function. Recursive calls
623  are specified by the macro RMATCH and RRETURN is used to return. When  are specified by the macro RMATCH and RRETURN is used to return. When
624  NO_RECURSE is *not* defined, these just turn into a recursive call to match()  NO_RECURSE is *not* defined, these just turn into a recursive call to match()
625  and a "return", respectively (possibly with some debugging if DEBUG is  and a "return", respectively (possibly with some debugging if PCRE_DEBUG is
626  defined). However, RMATCH isn't like a function call because it's quite a  defined). However, RMATCH isn't like a function call because it's quite a
627  complicated macro. It has to be used in one particular way. This shouldn't,  complicated macro. It has to be used in one particular way. This shouldn't,
628  however, impact performance when true recursion is being used. */  however, impact performance when true recursion is being used. */
# Line 713  for (;;) Line 713  for (;;)
713      number = GET2(ecode, 1+LINK_SIZE);      number = GET2(ecode, 1+LINK_SIZE);
714      offset = number << 1;      offset = number << 1;
715    
716  #ifdef DEBUG  #ifdef PCRE_DEBUG
717      printf("start bracket %d\n", number);      printf("start bracket %d\n", number);
718      printf("subject=");      printf("subject=");
719      pchars(eptr, 16, TRUE, md);      pchars(eptr, 16, TRUE, md);
# Line 1039  for (;;) Line 1039  for (;;)
1039      number = GET2(ecode, 1);      number = GET2(ecode, 1);
1040      offset = number << 1;      offset = number << 1;
1041    
1042  #ifdef DEBUG  #ifdef PCRE_DEBUG
1043        printf("end bracket %d at *ACCEPT", number);        printf("end bracket %d at *ACCEPT", number);
1044        printf("\n");        printf("\n");
1045  #endif  #endif
# Line 1070  for (;;) Line 1070  for (;;)
1070        memmove(md->offset_vector, rec->offset_save,        memmove(md->offset_vector, rec->offset_save,
1071          rec->saved_max * sizeof(int));          rec->saved_max * sizeof(int));
1072        offset_top = rec->save_offset_top;        offset_top = rec->save_offset_top;
       mstart = rec->save_start;  
1073        ims = original_ims;        ims = original_ims;
1074        ecode = rec->after_call;        ecode = rec->after_call;
1075        break;        break;
# Line 1114  for (;;) Line 1113  for (;;)
1113        {        {
1114        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,
1115          RM4);          RM4);
1116        if (rrc == MATCH_MATCH) break;        if (rrc == MATCH_MATCH)
1117            {
1118            mstart = md->start_match_ptr;   /* In case \K reset it */
1119            break;
1120            }
1121        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
1122        ecode += GET(ecode, 1);        ecode += GET(ecode, 1);
1123        }        }
# Line 1133  for (;;) Line 1136  for (;;)
1136      offset_top = md->end_offset_top;      offset_top = md->end_offset_top;
1137      continue;      continue;
1138    
1139      /* Negative assertion: all branches must fail to match */      /* Negative assertion: all branches must fail to match. Encountering SKIP,
1140        PRUNE, or COMMIT means we must assume failure without checking subsequent
1141        branches. */
1142    
1143      case OP_ASSERT_NOT:      case OP_ASSERT_NOT:
1144      case OP_ASSERTBACK_NOT:      case OP_ASSERTBACK_NOT:
# Line 1142  for (;;) Line 1147  for (;;)
1147        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,
1148          RM5);          RM5);
1149        if (rrc == MATCH_MATCH) RRETURN(MATCH_NOMATCH);        if (rrc == MATCH_MATCH) RRETURN(MATCH_NOMATCH);
1150          if (rrc == MATCH_SKIP || rrc == MATCH_PRUNE || rrc == MATCH_COMMIT)
1151            {
1152            do ecode += GET(ecode,1); while (*ecode == OP_ALT);
1153            break;
1154            }
1155        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
1156        ecode += GET(ecode,1);        ecode += GET(ecode,1);
1157        }        }
# Line 1260  for (;;) Line 1270  for (;;)
1270    
1271        memcpy(new_recursive.offset_save, md->offset_vector,        memcpy(new_recursive.offset_save, md->offset_vector,
1272              new_recursive.saved_max * sizeof(int));              new_recursive.saved_max * sizeof(int));
       new_recursive.save_start = mstart;  
1273        new_recursive.save_offset_top = offset_top;        new_recursive.save_offset_top = offset_top;
       mstart = eptr;  
1274    
1275        /* OK, now we can do the recursion. For each top-level alternative we        /* OK, now we can do the recursion. For each top-level alternative we
1276        restore the offset and recursion data. */        restore the offset and recursion data. */
# Line 1309  for (;;) Line 1317  for (;;)
1317      a move back into the brackets. Friedl calls these "atomic" subpatterns.      a move back into the brackets. Friedl calls these "atomic" subpatterns.
1318      Check the alternative branches in turn - the matching won't pass the KET      Check the alternative branches in turn - the matching won't pass the KET
1319      for this kind of subpattern. If any one branch matches, we carry on as at      for this kind of subpattern. If any one branch matches, we carry on as at
1320      the end of a normal bracket, leaving the subject pointer. */      the end of a normal bracket, leaving the subject pointer, but resetting
1321        the start-of-match value in case it was changed by \K. */
1322    
1323      case OP_ONCE:      case OP_ONCE:
1324      prev = ecode;      prev = ecode;
# Line 1318  for (;;) Line 1327  for (;;)
1327      do      do
1328        {        {
1329        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0, RM7);        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0, RM7);
1330        if (rrc == MATCH_MATCH) break;        if (rrc == MATCH_MATCH)
1331            {
1332            mstart = md->start_match_ptr;
1333            break;
1334            }
1335        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
1336        ecode += GET(ecode,1);        ecode += GET(ecode,1);
1337        }        }
# Line 1437  for (;;) Line 1450  for (;;)
1450        }        }
1451      else saved_eptr = NULL;      else saved_eptr = NULL;
1452    
1453      /* If we are at the end of an assertion group, stop matching and return      /* If we are at the end of an assertion group or an atomic group, stop
1454      MATCH_MATCH, but record the current high water mark for use by positive      matching and return MATCH_MATCH, but record the current high water mark for
1455      assertions. Do this also for the "once" (atomic) groups. */      use by positive assertions. We also need to record the match start in case
1456        it was changed by \K. */
1457    
1458      if (*prev == OP_ASSERT || *prev == OP_ASSERT_NOT ||      if (*prev == OP_ASSERT || *prev == OP_ASSERT_NOT ||
1459          *prev == OP_ASSERTBACK || *prev == OP_ASSERTBACK_NOT ||          *prev == OP_ASSERTBACK || *prev == OP_ASSERTBACK_NOT ||
# Line 1447  for (;;) Line 1461  for (;;)
1461        {        {
1462        md->end_match_ptr = eptr;      /* For ONCE */        md->end_match_ptr = eptr;      /* For ONCE */
1463        md->end_offset_top = offset_top;        md->end_offset_top = offset_top;
1464          md->start_match_ptr = mstart;
1465        RRETURN(MATCH_MATCH);        RRETURN(MATCH_MATCH);
1466        }        }
1467    
# Line 1461  for (;;) Line 1476  for (;;)
1476        number = GET2(prev, 1+LINK_SIZE);        number = GET2(prev, 1+LINK_SIZE);
1477        offset = number << 1;        offset = number << 1;
1478    
1479  #ifdef DEBUG  #ifdef PCRE_DEBUG
1480        printf("end bracket %d", number);        printf("end bracket %d", number);
1481        printf("\n");        printf("\n");
1482  #endif  #endif
# Line 1483  for (;;) Line 1498  for (;;)
1498          recursion_info *rec = md->recursive;          recursion_info *rec = md->recursive;
1499          DPRINTF(("Recursion (%d) succeeded - continuing\n", number));          DPRINTF(("Recursion (%d) succeeded - continuing\n", number));
1500          md->recursive = rec->prevrec;          md->recursive = rec->prevrec;
         mstart = rec->save_start;  
1501          memcpy(md->offset_vector, rec->offset_save,          memcpy(md->offset_vector, rec->offset_save,
1502            rec->saved_max * sizeof(int));            rec->saved_max * sizeof(int));
1503          offset_top = rec->save_offset_top;          offset_top = rec->save_offset_top;
# Line 2146  for (;;) Line 2160  for (;;)
2160          pp = eptr;          pp = eptr;
2161          for (i = min; i < max; i++)          for (i = min; i < max; i++)
2162            {            {
2163            if (!match_ref(offset, eptr, length, md, ims))            if (!match_ref(offset, eptr, length, md, ims))
2164              {              {
2165              CHECK_PARTIAL();              CHECK_PARTIAL();
2166              break;              break;
2167              }              }
2168            eptr += length;            eptr += length;
2169            }            }
2170          while (eptr >= pp)          while (eptr >= pp)
# Line 2319  for (;;) Line 2333  for (;;)
2333            for (i = min; i < max; i++)            for (i = min; i < max; i++)
2334              {              {
2335              int len = 1;              int len = 1;
2336              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
2337                {                {
2338                SCHECK_PARTIAL();                SCHECK_PARTIAL();
2339                break;                break;
2340                }                }
2341              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
2342              if (c > 255)              if (c > 255)
2343                {                {
# Line 2349  for (;;) Line 2363  for (;;)
2363            {            {
2364            for (i = min; i < max; i++)            for (i = min; i < max; i++)
2365              {              {
2366              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
2367                {                {
2368                SCHECK_PARTIAL();                SCHECK_PARTIAL();
2369                break;                break;
2370                }                }
2371              c = *eptr;              c = *eptr;
2372              if ((data[c/8] & (1 << (c&7))) == 0) break;              if ((data[c/8] & (1 << (c&7))) == 0) break;
2373              eptr++;              eptr++;
# Line 2458  for (;;) Line 2472  for (;;)
2472          for (i = min; i < max; i++)          for (i = min; i < max; i++)
2473            {            {
2474            int len = 1;            int len = 1;
2475            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2476              {              {
2477              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2478              break;              break;
2479              }              }
2480            GETCHARLENTEST(c, eptr, len);            GETCHARLENTEST(c, eptr, len);
2481            if (!_pcre_xclass(c, data)) break;            if (!_pcre_xclass(c, data)) break;
2482            eptr += len;            eptr += len;
# Line 2701  for (;;) Line 2715  for (;;)
2715                       eptr <= md->end_subject - oclength &&                       eptr <= md->end_subject - oclength &&
2716                       memcmp(eptr, occhars, oclength) == 0) eptr += oclength;                       memcmp(eptr, occhars, oclength) == 0) eptr += oclength;
2717  #endif  /* SUPPORT_UCP */  #endif  /* SUPPORT_UCP */
2718              else              else
2719                {                {
2720                CHECK_PARTIAL();                CHECK_PARTIAL();
2721                break;                break;
2722                }                }
2723              }              }
2724    
2725            if (possessive) continue;            if (possessive) continue;
# Line 2783  for (;;) Line 2797  for (;;)
2797          pp = eptr;          pp = eptr;
2798          for (i = min; i < max; i++)          for (i = min; i < max; i++)
2799            {            {
2800            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2801              {              {
2802              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2803              break;              break;
2804              }              }
2805            if (fc != md->lcc[*eptr]) break;            if (fc != md->lcc[*eptr]) break;
2806            eptr++;            eptr++;
2807            }            }
# Line 2842  for (;;) Line 2856  for (;;)
2856          pp = eptr;          pp = eptr;
2857          for (i = min; i < max; i++)          for (i = min; i < max; i++)
2858            {            {
2859            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2860              {              {
2861              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2862              break;              break;
2863              }              }
2864            if (fc != *eptr) break;            if (fc != *eptr) break;
2865            eptr++;            eptr++;
2866            }            }
# Line 3059  for (;;) Line 3073  for (;;)
3073            for (i = min; i < max; i++)            for (i = min; i < max; i++)
3074              {              {
3075              int len = 1;              int len = 1;
3076              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3077                {                {
3078                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3079                break;                break;
3080                }                }
3081              GETCHARLEN(d, eptr, len);              GETCHARLEN(d, eptr, len);
3082              if (d < 256) d = md->lcc[d];              if (d < 256) d = md->lcc[d];
3083              if (fc == d) break;              if (fc == d) break;
# Line 3084  for (;;) Line 3098  for (;;)
3098            {            {
3099            for (i = min; i < max; i++)            for (i = min; i < max; i++)
3100              {              {
3101              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3102                {                {
3103                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3104                break;                break;
3105                }                }
3106              if (fc == md->lcc[*eptr]) break;              if (fc == md->lcc[*eptr]) break;
3107              eptr++;              eptr++;
3108              }              }
# Line 3198  for (;;) Line 3212  for (;;)
3212            for (i = min; i < max; i++)            for (i = min; i < max; i++)
3213              {              {
3214              int len = 1;              int len = 1;
3215              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3216                {                {
3217                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3218                break;                break;
3219                }                }
3220              GETCHARLEN(d, eptr, len);              GETCHARLEN(d, eptr, len);
3221              if (fc == d) break;              if (fc == d) break;
3222              eptr += len;              eptr += len;
# Line 3222  for (;;) Line 3236  for (;;)
3236            {            {
3237            for (i = min; i < max; i++)            for (i = min; i < max; i++)
3238              {              {
3239              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3240                {                {
3241                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3242                break;                break;
3243                }                }
3244              if (fc == *eptr) break;              if (fc == *eptr) break;
3245              eptr++;              eptr++;
3246              }              }
# Line 3688  for (;;) Line 3702  for (;;)
3702          case OP_NOT_WORDCHAR:          case OP_NOT_WORDCHAR:
3703          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3704            {            {
3705            if (eptr >= md->end_subject ||            if (eptr >= md->end_subject)
3706               (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0))              {
3707                SCHECK_PARTIAL();
3708                RRETURN(MATCH_NOMATCH);
3709                }
3710              if (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0)
3711              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3712            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
3713            }            }
# Line 4383  for (;;) Line 4401  for (;;)
4401            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4402              {              {
4403              int len = 1;              int len = 1;
4404              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4405                {                {
4406                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4407                break;                break;
4408                }                }
4409              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4410              if (prop_fail_result) break;              if (prop_fail_result) break;
4411              eptr+= len;              eptr+= len;
# Line 4398  for (;;) Line 4416  for (;;)
4416            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4417              {              {
4418              int len = 1;              int len = 1;
4419              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4420                {                {
4421                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4422                break;                break;
4423                }                }
4424              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4425              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
4426              if ((prop_chartype == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
# Line 4417  for (;;) Line 4435  for (;;)
4435            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4436              {              {
4437              int len = 1;              int len = 1;
4438              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4439                {                {
4440                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4441                break;                break;
4442                }                }
4443              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4444              prop_category = UCD_CATEGORY(c);              prop_category = UCD_CATEGORY(c);
4445              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
# Line 4434  for (;;) Line 4452  for (;;)
4452            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4453              {              {
4454              int len = 1;              int len = 1;
4455              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4456                {                {
4457                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4458                break;                break;
4459                }                }
4460              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4461              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
4462              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
# Line 4451  for (;;) Line 4469  for (;;)
4469            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4470              {              {
4471              int len = 1;              int len = 1;
4472              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4473                {                {
4474                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4475                break;                break;
4476                }                }
4477              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4478              prop_script = UCD_SCRIPT(c);              prop_script = UCD_SCRIPT(c);
4479              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
# Line 4484  for (;;) Line 4502  for (;;)
4502          {          {
4503          for (i = min; i < max; i++)          for (i = min; i < max; i++)
4504            {            {
4505            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4506              {              {
4507              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4508              break;              break;
4509              }              }
4510            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
4511            prop_category = UCD_CATEGORY(c);            prop_category = UCD_CATEGORY(c);
4512            if (prop_category == ucp_M) break;            if (prop_category == ucp_M) break;
# Line 4544  for (;;) Line 4562  for (;;)
4562              {              {
4563              for (i = min; i < max; i++)              for (i = min; i < max; i++)
4564                {                {
4565                if (eptr >= md->end_subject)                if (eptr >= md->end_subject)
4566                  {                  {
4567                  SCHECK_PARTIAL();                  SCHECK_PARTIAL();
4568                  break;                  break;
4569                  }                  }
4570                if (IS_NEWLINE(eptr)) break;                if (IS_NEWLINE(eptr)) break;
4571                eptr++;                eptr++;
4572                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
# Line 4561  for (;;) Line 4579  for (;;)
4579              {              {
4580              for (i = min; i < max; i++)              for (i = min; i < max; i++)
4581                {                {
4582                if (eptr >= md->end_subject)                if (eptr >= md->end_subject)
4583                  {                  {
4584                  SCHECK_PARTIAL();                  SCHECK_PARTIAL();
4585                  break;                  break;
4586                  }                  }
4587                if (IS_NEWLINE(eptr)) break;                if (IS_NEWLINE(eptr)) break;
4588                eptr++;                eptr++;
4589                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
# Line 4578  for (;;) Line 4596  for (;;)
4596              {              {
4597              for (i = min; i < max; i++)              for (i = min; i < max; i++)
4598                {                {
4599                if (eptr >= md->end_subject)                if (eptr >= md->end_subject)
4600                  {                  {
4601                  SCHECK_PARTIAL();                  SCHECK_PARTIAL();
4602                  break;                  break;
4603                  }                  }
4604                eptr++;                eptr++;
4605                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
4606                }                }
# Line 4598  for (;;) Line 4616  for (;;)
4616              {              {
4617              eptr = md->end_subject;              eptr = md->end_subject;
4618              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4619              }              }
4620            else eptr += c;            else eptr += c;
4621            break;            break;
4622    
# Line 4606  for (;;) Line 4624  for (;;)
4624            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4625              {              {
4626              int len = 1;              int len = 1;
4627              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4628                {                {
4629                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4630                break;                break;
4631                }                }
4632              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4633              if (c == 0x000d)              if (c == 0x000d)
4634                {                {
# Line 4635  for (;;) Line 4653  for (;;)
4653              {              {
4654              BOOL gotspace;              BOOL gotspace;
4655              int len = 1;              int len = 1;
4656              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4657                {                {
4658                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4659                break;                break;
4660                }                }
4661              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4662              switch(c)              switch(c)
4663                {                {
# Line 4677  for (;;) Line 4695  for (;;)
4695              {              {
4696              BOOL gotspace;              BOOL gotspace;
4697              int len = 1;              int len = 1;
4698              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4699                {                {
4700                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4701                break;                break;
4702                }                }
4703              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4704              switch(c)              switch(c)
4705                {                {
# Line 4705  for (;;) Line 4723  for (;;)
4723            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4724              {              {
4725              int len = 1;              int len = 1;
4726              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4727                {                {
4728                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4729                break;                break;
4730                }                }
4731              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4732              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0) break;              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0) break;
4733              eptr+= len;              eptr+= len;
# Line 4720  for (;;) Line 4738  for (;;)
4738            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4739              {              {
4740              int len = 1;              int len = 1;
4741              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4742                {                {
4743                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4744                break;                break;
4745                }                }
4746              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4747              if (c >= 256 ||(md->ctypes[c] & ctype_digit) == 0) break;              if (c >= 256 ||(md->ctypes[c] & ctype_digit) == 0) break;
4748              eptr+= len;              eptr+= len;
# Line 4735  for (;;) Line 4753  for (;;)
4753            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4754              {              {
4755              int len = 1;              int len = 1;
4756              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4757                {                {
4758                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4759                break;                break;
4760                }                }
4761              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4762              if (c < 256 && (md->ctypes[c] & ctype_space) != 0) break;              if (c < 256 && (md->ctypes[c] & ctype_space) != 0) break;
4763              eptr+= len;              eptr+= len;
# Line 4750  for (;;) Line 4768  for (;;)
4768            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4769              {              {
4770              int len = 1;              int len = 1;
4771              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4772                {                {
4773                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4774                break;                break;
4775                }                }
4776              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4777              if (c >= 256 ||(md->ctypes[c] & ctype_space) == 0) break;              if (c >= 256 ||(md->ctypes[c] & ctype_space) == 0) break;
4778              eptr+= len;              eptr+= len;
# Line 4765  for (;;) Line 4783  for (;;)
4783            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4784              {              {
4785              int len = 1;              int len = 1;
4786              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4787                {                {
4788                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4789                break;                break;
4790                }                }
4791              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4792              if (c < 256 && (md->ctypes[c] & ctype_word) != 0) break;              if (c < 256 && (md->ctypes[c] & ctype_word) != 0) break;
4793              eptr+= len;              eptr+= len;
# Line 4780  for (;;) Line 4798  for (;;)
4798            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4799              {              {
4800              int len = 1;              int len = 1;
4801              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4802                {                {
4803                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4804                break;                break;
4805                }                }
4806              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4807              if (c >= 256 || (md->ctypes[c] & ctype_word) == 0) break;              if (c >= 256 || (md->ctypes[c] & ctype_word) == 0) break;
4808              eptr+= len;              eptr+= len;
# Line 4816  for (;;) Line 4834  for (;;)
4834            case OP_ANY:            case OP_ANY:
4835            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4836              {              {
4837              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4838                {                {
4839                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4840                break;                break;
4841                }                }
4842              if (IS_NEWLINE(eptr)) break;              if (IS_NEWLINE(eptr)) break;
4843              eptr++;              eptr++;
4844              }              }
# Line 4833  for (;;) Line 4851  for (;;)
4851              {              {
4852              eptr = md->end_subject;              eptr = md->end_subject;
4853              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4854              }              }
4855            else eptr += c;            else eptr += c;
4856            break;            break;
4857    
4858            case OP_ANYNL:            case OP_ANYNL:
4859            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4860              {              {
4861              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4862                {                {
4863                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4864                break;                break;
4865                }                }
4866              c = *eptr;              c = *eptr;
4867              if (c == 0x000d)              if (c == 0x000d)
4868                {                {
# Line 4865  for (;;) Line 4883  for (;;)
4883            case OP_NOT_HSPACE:            case OP_NOT_HSPACE:
4884            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4885              {              {
4886              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4887                {                {
4888                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4889                break;                break;
4890                }                }
4891              c = *eptr;              c = *eptr;
4892              if (c == 0x09 || c == 0x20 || c == 0xa0) break;              if (c == 0x09 || c == 0x20 || c == 0xa0) break;
4893              eptr++;              eptr++;
# Line 4879  for (;;) Line 4897  for (;;)
4897            case OP_HSPACE:            case OP_HSPACE:
4898            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4899              {              {
4900              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4901                {                {
4902                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4903                break;                break;
4904                }                }
4905              c = *eptr;              c = *eptr;
4906              if (c != 0x09 && c != 0x20 && c != 0xa0) break;              if (c != 0x09 && c != 0x20 && c != 0xa0) break;
4907              eptr++;              eptr++;
# Line 4893  for (;;) Line 4911  for (;;)
4911            case OP_NOT_VSPACE:            case OP_NOT_VSPACE:
4912            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4913              {              {
4914              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4915                {                {
4916                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4917                break;                break;
4918                }                }
4919              c = *eptr;              c = *eptr;
4920              if (c == 0x0a || c == 0x0b || c == 0x0c || c == 0x0d || c == 0x85)              if (c == 0x0a || c == 0x0b || c == 0x0c || c == 0x0d || c == 0x85)
4921                break;                break;
# Line 4908  for (;;) Line 4926  for (;;)
4926            case OP_VSPACE:            case OP_VSPACE:
4927            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4928              {              {
4929              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4930                {                {
4931                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4932                break;                break;
4933                }                }
4934              c = *eptr;              c = *eptr;
4935              if (c != 0x0a && c != 0x0b && c != 0x0c && c != 0x0d && c != 0x85)              if (c != 0x0a && c != 0x0b && c != 0x0c && c != 0x0d && c != 0x85)
4936                break;                break;
# Line 4923  for (;;) Line 4941  for (;;)
4941            case OP_NOT_DIGIT:            case OP_NOT_DIGIT:
4942            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4943              {              {
4944              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4945                {                {
4946                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4947                break;                break;
4948                }                }
4949              if ((md->ctypes[*eptr] & ctype_digit) != 0) break;              if ((md->ctypes[*eptr] & ctype_digit) != 0) break;
4950              eptr++;              eptr++;
4951              }              }
# Line 4936  for (;;) Line 4954  for (;;)
4954            case OP_DIGIT:            case OP_DIGIT:
4955            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4956              {              {
4957              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4958                {                {
4959                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4960                break;                break;
4961                }                }
4962              if ((md->ctypes[*eptr] & ctype_digit) == 0) break;              if ((md->ctypes[*eptr] & ctype_digit) == 0) break;
4963              eptr++;              eptr++;
4964              }              }
# Line 4949  for (;;) Line 4967  for (;;)
4967            case OP_NOT_WHITESPACE:            case OP_NOT_WHITESPACE:
4968            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4969              {              {
4970              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4971                {                {
4972                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4973                break;                break;
4974                }                }
4975              if ((md->ctypes[*eptr] & ctype_space) != 0) break;              if ((md->ctypes[*eptr] & ctype_space) != 0) break;
4976              eptr++;              eptr++;
4977              }              }
# Line 4962  for (;;) Line 4980  for (;;)
4980            case OP_WHITESPACE:            case OP_WHITESPACE:
4981            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4982              {              {
4983              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4984                {                {
4985                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4986                break;                break;
4987                }                }
4988              if ((md->ctypes[*eptr] & ctype_space) == 0) break;              if ((md->ctypes[*eptr] & ctype_space) == 0) break;
4989              eptr++;              eptr++;
4990              }              }
# Line 4975  for (;;) Line 4993  for (;;)
4993            case OP_NOT_WORDCHAR:            case OP_NOT_WORDCHAR:
4994            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4995              {              {
4996              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4997                {                {
4998                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4999                break;                break;
5000                }                }
5001              if ((md->ctypes[*eptr] & ctype_word) != 0) break;              if ((md->ctypes[*eptr] & ctype_word) != 0) break;
5002              eptr++;              eptr++;
5003              }              }
# Line 4988  for (;;) Line 5006  for (;;)
5006            case OP_WORDCHAR:            case OP_WORDCHAR:
5007            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5008              {              {
5009              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
5010                {                {
5011                SCHECK_PARTIAL();                SCHECK_PARTIAL();
5012                break;                break;
5013                }                }
5014              if ((md->ctypes[*eptr] & ctype_word) == 0) break;              if ((md->ctypes[*eptr] & ctype_word) == 0) break;
5015              eptr++;              eptr++;
5016              }              }
# Line 5565  for(;;) Line 5583  for(;;)
5583      bytes to avoid spending too much time in this optimization. */      bytes to avoid spending too much time in this optimization. */
5584    
5585      if (study != NULL && (study->flags & PCRE_STUDY_MINLEN) != 0 &&      if (study != NULL && (study->flags & PCRE_STUDY_MINLEN) != 0 &&
5586          end_subject - start_match < study->minlength)          (pcre_uint32)(end_subject - start_match) < study->minlength)
5587        {        {
5588        rc = MATCH_NOMATCH;        rc = MATCH_NOMATCH;
5589        break;        break;
# Line 5628  for(;;) Line 5646  for(;;)
5646        }        }
5647      }      }
5648    
5649  #ifdef DEBUG  /* Sigh. Some compilers never learn. */  #ifdef PCRE_DEBUG  /* Sigh. Some compilers never learn. */
5650    printf(">>>> Match against: ");    printf(">>>> Match against: ");
5651    pchars(start_match, end_subject - start_match, TRUE, md);    pchars(start_match, end_subject - start_match, TRUE, md);
5652    printf("\n");    printf("\n");

Legend:
Removed from v.462  
changed lines
  Added in v.500

  ViewVC Help
Powered by ViewVC 1.1.5