/[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 1365 by ph10, Sun Oct 6 18:33:56 2013 UTC revision 1411 by ph10, Fri Dec 6 17:11:44 2013 UTC
# Line 107  because the offset vector is always a mu Line 107  because the offset vector is always a mu
107    
108  /* Min and max values for the common repeats; for the maxima, 0 => infinity */  /* Min and max values for the common repeats; for the maxima, 0 => infinity */
109    
110  static const char rep_min[] = { 0, 0, 1, 1, 0, 0 };  static const char rep_min[] = { 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, };
111  static const char rep_max[] = { 0, 0, 0, 0, 1, 1 };  static const char rep_max[] = { 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, };
112    
113  #ifdef PCRE_DEBUG  #ifdef PCRE_DEBUG
114  /*************************************************  /*************************************************
# Line 167  match_ref(int offset, register PCRE_PUCH Line 167  match_ref(int offset, register PCRE_PUCH
167  {  {
168  PCRE_PUCHAR eptr_start = eptr;  PCRE_PUCHAR eptr_start = eptr;
169  register PCRE_PUCHAR p = md->start_subject + md->offset_vector[offset];  register PCRE_PUCHAR p = md->start_subject + md->offset_vector[offset];
170  #ifdef SUPPORT_UTF  #if defined SUPPORT_UTF && defined SUPPORT_UCP
171  BOOL utf = md->utf;  BOOL utf = md->utf;
172  #endif  #endif
173    
# Line 195  ASCII characters. */ Line 195  ASCII characters. */
195    
196  if (caseless)  if (caseless)
197    {    {
198  #ifdef SUPPORT_UTF  #if defined SUPPORT_UTF && defined SUPPORT_UCP
 #ifdef SUPPORT_UCP  
199    if (utf)    if (utf)
200      {      {
201      /* 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
# Line 230  if (caseless) Line 229  if (caseless)
229      }      }
230    else    else
231  #endif  #endif
 #endif  
232    
233    /* The same code works when not in UTF-8 mode and in UTF-8 mode when there    /* The same code works when not in UTF-8 mode and in UTF-8 mode when there
234    is no UCP support. */    is no UCP support. */
# Line 312  enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM Line 310  enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM
310         RM31,  RM32, RM33, RM34, RM35, RM36, RM37, RM38, RM39, RM40,         RM31,  RM32, RM33, RM34, RM35, RM36, RM37, RM38, RM39, RM40,
311         RM41,  RM42, RM43, RM44, RM45, RM46, RM47, RM48, RM49, RM50,         RM41,  RM42, RM43, RM44, RM45, RM46, RM47, RM48, RM49, RM50,
312         RM51,  RM52, RM53, RM54, RM55, RM56, RM57, RM58, RM59, RM60,         RM51,  RM52, RM53, RM54, RM55, RM56, RM57, RM58, RM59, RM60,
313         RM61,  RM62, RM63, RM64, RM65, RM66, RM67, RM68 };         RM61,  RM62, RM63, RM64, RM65, RM66, RM67 };
314    
315  /* These versions of the macros use the stack, as normal. There are debugging  /* These versions of the macros use the stack, as normal. There are debugging
316  versions and production versions. Note that the "rw" argument of RMATCH isn't  versions and production versions. Note that the "rw" argument of RMATCH isn't
# Line 1173  for (;;) Line 1171  for (;;)
1171            ecode = md->start_code + code_offset;            ecode = md->start_code + code_offset;
1172            save_capture_last = md->capture_last;            save_capture_last = md->capture_last;
1173            matched_once = TRUE;            matched_once = TRUE;
1174              mstart = md->start_match_ptr;    /* In case \K changed it */
1175            continue;            continue;
1176            }            }
1177    
# Line 1245  for (;;) Line 1244  for (;;)
1244          eptr = md->end_match_ptr;          eptr = md->end_match_ptr;
1245          ecode = md->start_code + code_offset;          ecode = md->start_code + code_offset;
1246          matched_once = TRUE;          matched_once = TRUE;
1247            mstart = md->start_match_ptr;   /* In case \K reset it */
1248          continue;          continue;
1249          }          }
1250    
# Line 1281  for (;;) Line 1281  for (;;)
1281    
1282      case OP_COND:      case OP_COND:
1283      case OP_SCOND:      case OP_SCOND:
1284    
1285      /* The variable codelink will be added to ecode when the condition is      /* The variable codelink will be added to ecode when the condition is
1286      false, to get to the second branch. Setting it to the offset to the ALT      false, to get to the second branch. Setting it to the offset to the ALT
1287      or KET, then incrementing ecode achieves this effect. We now have ecode      or KET, then incrementing ecode achieves this effect. We now have ecode
1288      pointing to the condition or callout. */      pointing to the condition or callout. */
1289    
1290      codelink = GET(ecode, 1);   /* Offset to the second branch */      codelink = GET(ecode, 1);   /* Offset to the second branch */
1291      ecode += 1 + LINK_SIZE;     /* From this opcode */      ecode += 1 + LINK_SIZE;     /* From this opcode */
1292    
# Line 1322  for (;;) Line 1322  for (;;)
1322          if ((rrc = (*PUBL(callout))(&cb)) > 0) RRETURN(MATCH_NOMATCH);          if ((rrc = (*PUBL(callout))(&cb)) > 0) RRETURN(MATCH_NOMATCH);
1323          if (rrc < 0) RRETURN(rrc);          if (rrc < 0) RRETURN(rrc);
1324          }          }
1325    
1326        /* Advance ecode past the callout, so it now points to the condition. We        /* Advance ecode past the callout, so it now points to the condition. We
1327        must adjust codelink so that the value of ecode+codelink is unchanged. */        must adjust codelink so that the value of ecode+codelink is unchanged. */
1328    
1329        ecode += PRIV(OP_lengths)[OP_CALLOUT];        ecode += PRIV(OP_lengths)[OP_CALLOUT];
1330        codelink -= PRIV(OP_lengths)[OP_CALLOUT];        codelink -= PRIV(OP_lengths)[OP_CALLOUT];
1331        }        }
# Line 1334  for (;;) Line 1334  for (;;)
1334    
1335      condition = FALSE;      condition = FALSE;
1336      switch(condcode = *ecode)      switch(condcode = *ecode)
1337        {        {
1338        case OP_RREF:         /* Numbered group recursion test */        case OP_RREF:         /* Numbered group recursion test */
1339        if (md->recursive != NULL)     /* Not recursing => FALSE */        if (md->recursive != NULL)     /* Not recursing => FALSE */
1340          {          {
# Line 1345  for (;;) Line 1345  for (;;)
1345    
1346        case OP_DNRREF:       /* Duplicate named group recursion test */        case OP_DNRREF:       /* Duplicate named group recursion test */
1347        if (md->recursive != NULL)        if (md->recursive != NULL)
1348          {          {
1349          int count = GET2(ecode, 1 + IMM2_SIZE);          int count = GET2(ecode, 1 + IMM2_SIZE);
1350          pcre_uchar *slot = md->name_table + GET2(ecode, 1) * md->name_entry_size;          pcre_uchar *slot = md->name_table + GET2(ecode, 1) * md->name_entry_size;
1351          while (count-- > 0)          while (count-- > 0)
1352            {            {
# Line 1355  for (;;) Line 1355  for (;;)
1355            if (condition) break;            if (condition) break;
1356            slot += md->name_entry_size;            slot += md->name_entry_size;
1357            }            }
1358          }          }
1359        break;        break;
1360    
1361        case OP_CREF:         /* Numbered group used test */        case OP_CREF:         /* Numbered group used test */
# Line 1365  for (;;) Line 1365  for (;;)
1365    
1366        case OP_DNCREF:      /* Duplicate named group used test */        case OP_DNCREF:      /* Duplicate named group used test */
1367          {          {
1368          int count = GET2(ecode, 1 + IMM2_SIZE);          int count = GET2(ecode, 1 + IMM2_SIZE);
1369          pcre_uchar *slot = md->name_table + GET2(ecode, 1) * md->name_entry_size;          pcre_uchar *slot = md->name_table + GET2(ecode, 1) * md->name_entry_size;
1370          while (count-- > 0)          while (count-- > 0)
1371            {            {
# Line 1375  for (;;) Line 1375  for (;;)
1375            slot += md->name_entry_size;            slot += md->name_entry_size;
1376            }            }
1377          }          }
1378        break;        break;
1379    
1380        case OP_DEF:     /* DEFINE - always false */        case OP_DEF:     /* DEFINE - always false */
1381        break;        break;
# Line 1383  for (;;) Line 1383  for (;;)
1383        /* The condition is an assertion. Call match() to evaluate it - setting        /* The condition is an assertion. Call match() to evaluate it - setting
1384        md->match_function_type to MATCH_CONDASSERT causes it to stop at the end        md->match_function_type to MATCH_CONDASSERT causes it to stop at the end
1385        of an assertion. */        of an assertion. */
1386    
1387        default:        default:
1388        md->match_function_type = MATCH_CONDASSERT;        md->match_function_type = MATCH_CONDASSERT;
1389        RMATCH(eptr, ecode, offset_top, md, NULL, RM3);        RMATCH(eptr, ecode, offset_top, md, NULL, RM3);
1390        if (rrc == MATCH_MATCH)        if (rrc == MATCH_MATCH)
# Line 1392  for (;;) Line 1392  for (;;)
1392          if (md->end_offset_top > offset_top)          if (md->end_offset_top > offset_top)
1393            offset_top = md->end_offset_top;  /* Captures may have happened */            offset_top = md->end_offset_top;  /* Captures may have happened */
1394          condition = TRUE;          condition = TRUE;
1395    
1396          /* Advance ecode past the assertion to the start of the first branch,          /* Advance ecode past the assertion to the start of the first branch,
1397          but adjust it so that the general choosing code below works. */          but adjust it so that the general choosing code below works. */
1398    
1399          ecode += GET(ecode, 1);          ecode += GET(ecode, 1);
1400          while (*ecode == OP_ALT) ecode += GET(ecode, 1);          while (*ecode == OP_ALT) ecode += GET(ecode, 1);
1401          ecode += 1 + LINK_SIZE - PRIV(OP_lengths)[condcode];          ecode += 1 + LINK_SIZE - PRIV(OP_lengths)[condcode];
1402          }          }
1403    
1404        /* PCRE doesn't allow the effect of (*THEN) to escape beyond an        /* PCRE doesn't allow the effect of (*THEN) to escape beyond an
1405        assertion; it is therefore treated as NOMATCH. Any other return is an        assertion; it is therefore treated as NOMATCH. Any other return is an
1406        error. */        error. */
1407    
1408        else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)        else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)
1409          {          {
1410          RRETURN(rrc);         /* Need braces because of following else */          RRETURN(rrc);         /* Need braces because of following else */
1411          }          }
1412        break;        break;
1413        }        }
1414    
1415      /* Choose branch according to the condition */      /* Choose branch according to the condition */
1416    
1417      ecode += condition? PRIV(OP_lengths)[condcode] : codelink;      ecode += condition? PRIV(OP_lengths)[condcode] : codelink;
1418    
1419      /* We are now at the branch that is to be obeyed. As there is only one, we      /* We are now at the branch that is to be obeyed. As there is only one, we
1420      can use tail recursion to avoid using another stack frame, except when      can use tail recursion to avoid using another stack frame, except when
1421      there is unlimited repeat of a possibly empty group. In the latter case, a      there is unlimited repeat of a possibly empty group. In the latter case, a
# Line 1425  for (;;) Line 1425  for (;;)
1425      creating two alternatives. If a THEN is encountered in the branch, it      creating two alternatives. If a THEN is encountered in the branch, it
1426      propagates out to the enclosing alternative (unless nested in a deeper set      propagates out to the enclosing alternative (unless nested in a deeper set
1427      of alternatives, of course). */      of alternatives, of course). */
1428    
1429      if (condition || ecode[-(1+LINK_SIZE)] == OP_ALT)      if (condition || ecode[-(1+LINK_SIZE)] == OP_ALT)
1430        {        {
1431        if (op != OP_SCOND)        if (op != OP_SCOND)
# Line 2007  for (;;) Line 2007  for (;;)
2007    
2008      if (*ecode == OP_KETRPOS)      if (*ecode == OP_KETRPOS)
2009        {        {
2010          md->start_match_ptr = mstart;    /* In case \K reset it */
2011        md->end_match_ptr = eptr;        md->end_match_ptr = eptr;
2012        md->end_offset_top = offset_top;        md->end_offset_top = offset_top;
2013        RRETURN(MATCH_KETRPOS);        RRETURN(MATCH_KETRPOS);
# Line 2577  for (;;) Line 2578  for (;;)
2578          /* Perl space used to exclude VT, but from Perl 5.18 it is included,          /* Perl space used to exclude VT, but from Perl 5.18 it is included,
2579          which means that Perl space and POSIX space are now identical. PCRE          which means that Perl space and POSIX space are now identical. PCRE
2580          was changed at release 8.34. */          was changed at release 8.34. */
2581    
2582          case PT_SPACE:    /* Perl space */          case PT_SPACE:    /* Perl space */
2583          case PT_PXSPACE:  /* POSIX space */          case PT_PXSPACE:  /* POSIX space */
2584          if ((PRIV(ucp_gentype)[prop->chartype] == ucp_Z ||          switch(c)
2585               c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||            {
2586               c == CHAR_FF || c == CHAR_CR)            HSPACE_CASES:
2587                 == (op == OP_NOTPROP))            VSPACE_CASES:
2588            RRETURN(MATCH_NOMATCH);            if (op == OP_NOTPROP) RRETURN(MATCH_NOMATCH);
2589              break;
2590    
2591              default:
2592              if ((PRIV(ucp_gentype)[prop->chartype] == ucp_Z) ==
2593                (op == OP_NOTPROP)) RRETURN(MATCH_NOMATCH);
2594              break;
2595              }
2596          break;          break;
2597    
2598          case PT_WORD:          case PT_WORD:
# Line 2669  for (;;) Line 2677  for (;;)
2677    
2678      Otherwise, set the length to the length of what was matched by the      Otherwise, set the length to the length of what was matched by the
2679      referenced subpattern.      referenced subpattern.
2680    
2681      The OP_REF and OP_REFI opcodes are used for a reference to a numbered group      The OP_REF and OP_REFI opcodes are used for a reference to a numbered group
2682      or to a non-duplicated named group. For a duplicated named group, OP_DNREF      or to a non-duplicated named group. For a duplicated named group, OP_DNREF
2683      and OP_DNREFI are used. In this case we must scan the list of groups to      and OP_DNREFI are used. In this case we must scan the list of groups to
2684      which the name refers, and use the first one that is set. */      which the name refers, and use the first one that is set. */
2685    
2686      case OP_DNREF:      case OP_DNREF:
2687      case OP_DNREFI:      case OP_DNREFI:
2688      caseless = op == OP_DNREFI;      caseless = op == OP_DNREFI;
2689        {        {
2690        int count = GET2(ecode, 1+IMM2_SIZE);        int count = GET2(ecode, 1+IMM2_SIZE);
2691        pcre_uchar *slot = md->name_table + GET2(ecode, 1) * md->name_entry_size;        pcre_uchar *slot = md->name_table + GET2(ecode, 1) * md->name_entry_size;
2692        ecode += 1 + 2*IMM2_SIZE;        ecode += 1 + 2*IMM2_SIZE;
2693    
2694        while (count-- > 0)        while (count-- > 0)
2695          {          {
2696          offset = GET2(slot, 0) << 1;          offset = GET2(slot, 0) << 1;
2697          if (offset < offset_top && md->offset_vector[offset] >= 0) break;          if (offset < offset_top && md->offset_vector[offset] >= 0) break;
2698          slot += md->name_entry_size;          slot += md->name_entry_size;
2699          }          }
2700        if (count < 0)        if (count < 0)
2701          length = (md->jscript_compat)? 0 : -1;          length = (md->jscript_compat)? 0 : -1;
2702        else        else
2703          length = md->offset_vector[offset+1] - md->offset_vector[offset];          length = md->offset_vector[offset+1] - md->offset_vector[offset];
# Line 2857  for (;;) Line 2865  for (;;)
2865          case OP_CRMINPLUS:          case OP_CRMINPLUS:
2866          case OP_CRQUERY:          case OP_CRQUERY:
2867          case OP_CRMINQUERY:          case OP_CRMINQUERY:
2868            case OP_CRPOSSTAR:
2869            case OP_CRPOSPLUS:
2870            case OP_CRPOSQUERY:
2871          c = *ecode++ - OP_CRSTAR;          c = *ecode++ - OP_CRSTAR;
2872          minimize = (c & 1) != 0;          if (c < OP_CRPOSSTAR - OP_CRSTAR) minimize = (c & 1) != 0;
2873            else possessive = TRUE;
2874          min = rep_min[c];                 /* Pick up values from tables; */          min = rep_min[c];                 /* Pick up values from tables; */
2875          max = rep_max[c];                 /* zero for max => infinity */          max = rep_max[c];                 /* zero for max => infinity */
2876          if (max == 0) max = INT_MAX;          if (max == 0) max = INT_MAX;
# Line 2866  for (;;) Line 2878  for (;;)
2878    
2879          case OP_CRRANGE:          case OP_CRRANGE:
2880          case OP_CRMINRANGE:          case OP_CRMINRANGE:
2881            case OP_CRPOSRANGE:
2882          minimize = (*ecode == OP_CRMINRANGE);          minimize = (*ecode == OP_CRMINRANGE);
2883            possessive = (*ecode == OP_CRPOSRANGE);
2884          min = GET2(ecode, 1);          min = GET2(ecode, 1);
2885          max = GET2(ecode, 1 + IMM2_SIZE);          max = GET2(ecode, 1 + IMM2_SIZE);
2886          if (max == 0) max = INT_MAX;          if (max == 0) max = INT_MAX;
# Line 3008  for (;;) Line 3022  for (;;)
3022                if ((BYTE_MAP[c/8] & (1 << (c&7))) == 0) break;                if ((BYTE_MAP[c/8] & (1 << (c&7))) == 0) break;
3023              eptr += len;              eptr += len;
3024              }              }
3025    
3026              if (possessive) continue;    /* No backtracking */
3027    
3028            for (;;)            for (;;)
3029              {              {
3030              RMATCH(eptr, ecode, offset_top, md, eptrb, RM18);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM18);
# Line 3038  for (;;) Line 3055  for (;;)
3055                if ((BYTE_MAP[c/8] & (1 << (c&7))) == 0) break;                if ((BYTE_MAP[c/8] & (1 << (c&7))) == 0) break;
3056              eptr++;              eptr++;
3057              }              }
3058    
3059              if (possessive) continue;    /* No backtracking */
3060    
3061            while (eptr >= pp)            while (eptr >= pp)
3062              {              {
3063              RMATCH(eptr, ecode, offset_top, md, eptrb, RM19);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM19);
# Line 3053  for (;;) Line 3073  for (;;)
3073      /* Control never gets here */      /* Control never gets here */
3074    
3075    
3076      /* Match an extended character class. This opcode is encountered only      /* Match an extended character class. In the 8-bit library, this opcode is
3077      when UTF-8 mode mode is supported. Nevertheless, we may not be in UTF-8      encountered only when UTF-8 mode mode is supported. In the 16-bit and
3078      mode, because Unicode properties are supported in non-UTF-8 mode. */      32-bit libraries, codepoints greater than 255 may be encountered even when
3079        UTF is not supported. */
3080    
3081  #if defined SUPPORT_UTF || !defined COMPILE_PCRE8  #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
3082      case OP_XCLASS:      case OP_XCLASS:
# Line 3071  for (;;) Line 3092  for (;;)
3092          case OP_CRMINPLUS:          case OP_CRMINPLUS:
3093          case OP_CRQUERY:          case OP_CRQUERY:
3094          case OP_CRMINQUERY:          case OP_CRMINQUERY:
3095            case OP_CRPOSSTAR:
3096            case OP_CRPOSPLUS:
3097            case OP_CRPOSQUERY:
3098          c = *ecode++ - OP_CRSTAR;          c = *ecode++ - OP_CRSTAR;
3099          minimize = (c & 1) != 0;          if (c < OP_CRPOSSTAR - OP_CRSTAR) minimize = (c & 1) != 0;
3100            else possessive = TRUE;
3101          min = rep_min[c];                 /* Pick up values from tables; */          min = rep_min[c];                 /* Pick up values from tables; */
3102          max = rep_max[c];                 /* zero for max => infinity */          max = rep_max[c];                 /* zero for max => infinity */
3103          if (max == 0) max = INT_MAX;          if (max == 0) max = INT_MAX;
# Line 3080  for (;;) Line 3105  for (;;)
3105    
3106          case OP_CRRANGE:          case OP_CRRANGE:
3107          case OP_CRMINRANGE:          case OP_CRMINRANGE:
3108            case OP_CRPOSRANGE:
3109          minimize = (*ecode == OP_CRMINRANGE);          minimize = (*ecode == OP_CRMINRANGE);
3110            possessive = (*ecode == OP_CRPOSRANGE);
3111          min = GET2(ecode, 1);          min = GET2(ecode, 1);
3112          max = GET2(ecode, 1 + IMM2_SIZE);          max = GET2(ecode, 1 + IMM2_SIZE);
3113          if (max == 0) max = INT_MAX;          if (max == 0) max = INT_MAX;
# Line 3152  for (;;) Line 3179  for (;;)
3179            if (!PRIV(xclass)(c, data, utf)) break;            if (!PRIV(xclass)(c, data, utf)) break;
3180            eptr += len;            eptr += len;
3181            }            }
3182    
3183            if (possessive) continue;    /* No backtracking */
3184    
3185          for(;;)          for(;;)
3186            {            {
3187            RMATCH(eptr, ecode, offset_top, md, eptrb, RM21);            RMATCH(eptr, ecode, offset_top, md, eptrb, RM21);
# Line 4200  for (;;) Line 4230  for (;;)
4230            /* Perl space used to exclude VT, but from Perl 5.18 it is included,            /* Perl space used to exclude VT, but from Perl 5.18 it is included,
4231            which means that Perl space and POSIX space are now identical. PCRE            which means that Perl space and POSIX space are now identical. PCRE
4232            was changed at release 8.34. */            was changed at release 8.34. */
4233    
4234            case PT_SPACE:    /* Perl space */            case PT_SPACE:    /* Perl space */
4235            case PT_PXSPACE:  /* POSIX space */            case PT_PXSPACE:  /* POSIX space */
4236            for (i = 1; i <= min; i++)            for (i = 1; i <= min; i++)
# Line 4211  for (;;) Line 4241  for (;;)
4241                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4242                }                }
4243              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
4244              if ((UCD_CATEGORY(c) == ucp_Z || c == CHAR_HT || c == CHAR_NL ||              switch(c)
4245                   c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)                {
4246                     == prop_fail_result)                HSPACE_CASES:
4247                RRETURN(MATCH_NOMATCH);                VSPACE_CASES:
4248                  if (prop_fail_result) RRETURN(MATCH_NOMATCH);
4249                  break;
4250    
4251                  default:
4252                  if ((UCD_CATEGORY(c) == ucp_Z) == prop_fail_result)
4253                    RRETURN(MATCH_NOMATCH);
4254                  break;
4255                  }
4256              }              }
4257            break;            break;
4258    
# Line 4937  for (;;) Line 4975  for (;;)
4975            /* Perl space used to exclude VT, but from Perl 5.18 it is included,            /* Perl space used to exclude VT, but from Perl 5.18 it is included,
4976            which means that Perl space and POSIX space are now identical. PCRE            which means that Perl space and POSIX space are now identical. PCRE
4977            was changed at release 8.34. */            was changed at release 8.34. */
4978    
4979            case PT_SPACE:    /* Perl space */            case PT_SPACE:    /* Perl space */
4980            case PT_PXSPACE:  /* POSIX space */            case PT_PXSPACE:  /* POSIX space */
4981            for (fi = min;; fi++)            for (fi = min;; fi++)
# Line 4951  for (;;) Line 4989  for (;;)
4989                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4990                }                }
4991              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
4992              if ((UCD_CATEGORY(c) == ucp_Z || c == CHAR_HT || c == CHAR_NL ||              switch(c)
4993                   c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)                {
4994                     == prop_fail_result)                HSPACE_CASES:
4995                RRETURN(MATCH_NOMATCH);                VSPACE_CASES:
4996                  if (prop_fail_result) RRETURN(MATCH_NOMATCH);
4997                  break;
4998    
4999                  default:
5000                  if ((UCD_CATEGORY(c) == ucp_Z) == prop_fail_result)
5001                    RRETURN(MATCH_NOMATCH);
5002                  break;
5003                  }
5004              }              }
5005            /* Control never gets here */            /* Control never gets here */
5006    
# Line 5007  for (;;) Line 5053  for (;;)
5053            case PT_UCNC:            case PT_UCNC:
5054            for (fi = min;; fi++)            for (fi = min;; fi++)
5055              {              {
5056              RMATCH(eptr, ecode, offset_top, md, eptrb, RM68);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM60);
5057              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
5058              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) RRETURN(MATCH_NOMATCH);
5059              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
# Line 5441  for (;;) Line 5487  for (;;)
5487            /* Perl space used to exclude VT, but from Perl 5.18 it is included,            /* Perl space used to exclude VT, but from Perl 5.18 it is included,
5488            which means that Perl space and POSIX space are now identical. PCRE            which means that Perl space and POSIX space are now identical. PCRE
5489            was changed at release 8.34. */            was changed at release 8.34. */
5490    
5491            case PT_SPACE:    /* Perl space */            case PT_SPACE:    /* Perl space */
5492            case PT_PXSPACE:  /* POSIX space */            case PT_PXSPACE:  /* POSIX space */
5493            for (i = min; i < max; i++)            for (i = min; i < max; i++)
# Line 5453  for (;;) Line 5499  for (;;)
5499                break;                break;
5500                }                }
5501              GETCHARLENTEST(c, eptr, len);              GETCHARLENTEST(c, eptr, len);
5502              if ((UCD_CATEGORY(c) == ucp_Z || c == CHAR_HT || c == CHAR_NL ||              switch(c)
5503                   c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)                {
5504                   == prop_fail_result)                HSPACE_CASES:
5505                  VSPACE_CASES:
5506                  if (prop_fail_result) goto ENDLOOP99;  /* Break the loop */
5507                break;                break;
5508    
5509                  default:
5510                  if ((UCD_CATEGORY(c) == ucp_Z) == prop_fail_result)
5511                    goto ENDLOOP99;   /* Break the loop */
5512                  break;
5513                  }
5514              eptr+= len;              eptr+= len;
5515              }              }
5516              ENDLOOP99:
5517            break;            break;
5518    
5519            case PT_WORD:            case PT_WORD:
# Line 5572  for (;;) Line 5627  for (;;)
5627          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
5628    
5629          if (possessive) continue;    /* No backtracking */          if (possessive) continue;    /* No backtracking */
5630    
5631          for(;;)          for(;;)
5632            {            {
5633            int lgb, rgb;            int lgb, rgb;
5634            PCRE_PUCHAR fptr;            PCRE_PUCHAR fptr;
5635    
5636            if (eptr == pp) goto TAIL_RECURSE;   /* At start of char run */            if (eptr == pp) goto TAIL_RECURSE;   /* At start of char run */
5637            RMATCH(eptr, ecode, offset_top, md, eptrb, RM45);            RMATCH(eptr, ecode, offset_top, md, eptrb, RM45);
5638            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
# Line 5585  for (;;) Line 5640  for (;;)
5640            /* Backtracking over an extended grapheme cluster involves inspecting            /* Backtracking over an extended grapheme cluster involves inspecting
5641            the previous two characters (if present) to see if a break is            the previous two characters (if present) to see if a break is
5642            permitted between them. */            permitted between them. */
5643    
5644            eptr--;            eptr--;
5645            if (!utf) c = *eptr; else            if (!utf) c = *eptr; else
5646              {              {
# Line 5603  for (;;) Line 5658  for (;;)
5658                BACKCHAR(fptr);                BACKCHAR(fptr);
5659                GETCHAR(c, fptr);                GETCHAR(c, fptr);
5660                }                }
5661              lgb = UCD_GRAPHBREAK(c);              lgb = UCD_GRAPHBREAK(c);
5662              if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;              if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
5663              eptr = fptr;              eptr = fptr;
5664              rgb = lgb;              rgb = lgb;
# Line 6127  for (;;) Line 6182  for (;;)
6182                eptr[-1] == CHAR_CR) eptr--;                eptr[-1] == CHAR_CR) eptr--;
6183            }            }
6184          }          }
6185    
6186        /* Control never gets here */        /* Control never gets here */
6187        }        }
6188    
# Line 6163  switch (frame->Xwhere) Line 6218  switch (frame->Xwhere)
6218    LBL(53) LBL(54) LBL(55) LBL(56) LBL(57) LBL(58) LBL(63) LBL(64)    LBL(53) LBL(54) LBL(55) LBL(56) LBL(57) LBL(58) LBL(63) LBL(64)
6219    LBL(65) LBL(66)    LBL(65) LBL(66)
6220  #if defined SUPPORT_UTF || !defined COMPILE_PCRE8  #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
6221    LBL(21)    LBL(20) LBL(21)
6222  #endif  #endif
6223  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
6224    LBL(16) LBL(18) LBL(20)    LBL(16) LBL(18)
6225    LBL(22) LBL(23) LBL(28) LBL(30)    LBL(22) LBL(23) LBL(28) LBL(30)
6226    LBL(32) LBL(34) LBL(42) LBL(46)    LBL(32) LBL(34) LBL(42) LBL(46)
6227  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
6228    LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)    LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
6229    LBL(59) LBL(60) LBL(61) LBL(62) LBL(67) LBL(68)    LBL(59) LBL(60) LBL(61) LBL(62) LBL(67)
6230  #endif  /* SUPPORT_UCP */  #endif  /* SUPPORT_UCP */
6231  #endif  /* SUPPORT_UTF */  #endif  /* SUPPORT_UTF */
6232    default:    default:

Legend:
Removed from v.1365  
changed lines
  Added in v.1411

  ViewVC Help
Powered by ViewVC 1.1.5