/[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 1361 by ph10, Fri Sep 6 17:47:32 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 1274  for (;;) Line 1274  for (;;)
1274    
1275      /* Control never reaches here. */      /* Control never reaches here. */
1276    
1277      /* Conditional group: compilation checked that there are no more than      /* Conditional group: compilation checked that there are no more than two
1278      two branches. If the condition is false, skipping the first branch takes us      branches. If the condition is false, skipping the first branch takes us
1279      past the end if there is only one branch, but that's OK because that is      past the end of the item if there is only one branch, but that's exactly
1280      exactly what going to the ket would do. */      what we want. */
1281    
1282      case OP_COND:      case OP_COND:
1283      case OP_SCOND:      case OP_SCOND:
1284      codelink = GET(ecode, 1);  
1285        /* 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
1287        or KET, then incrementing ecode achieves this effect. We now have ecode
1288        pointing to the condition or callout. */
1289    
1290        codelink = GET(ecode, 1);   /* Offset to the second branch */
1291        ecode += 1 + LINK_SIZE;     /* From this opcode */
1292    
1293      /* Because of the way auto-callout works during compile, a callout item is      /* Because of the way auto-callout works during compile, a callout item is
1294      inserted between OP_COND and an assertion condition. */      inserted between OP_COND and an assertion condition. */
1295    
1296      if (ecode[LINK_SIZE+1] == OP_CALLOUT)      if (*ecode == OP_CALLOUT)
1297        {        {
1298        if (PUBL(callout) != NULL)        if (PUBL(callout) != NULL)
1299          {          {
1300          PUBL(callout_block) cb;          PUBL(callout_block) cb;
1301          cb.version          = 2;   /* Version 1 of the callout block */          cb.version          = 2;   /* Version 1 of the callout block */
1302          cb.callout_number   = ecode[LINK_SIZE+2];          cb.callout_number   = ecode[1];
1303          cb.offset_vector    = md->offset_vector;          cb.offset_vector    = md->offset_vector;
1304  #if defined COMPILE_PCRE8  #if defined COMPILE_PCRE8
1305          cb.subject          = (PCRE_SPTR)md->start_subject;          cb.subject          = (PCRE_SPTR)md->start_subject;
# Line 1304  for (;;) Line 1311  for (;;)
1311          cb.subject_length   = (int)(md->end_subject - md->start_subject);          cb.subject_length   = (int)(md->end_subject - md->start_subject);
1312          cb.start_match      = (int)(mstart - md->start_subject);          cb.start_match      = (int)(mstart - md->start_subject);
1313          cb.current_position = (int)(eptr - md->start_subject);          cb.current_position = (int)(eptr - md->start_subject);
1314          cb.pattern_position = GET(ecode, LINK_SIZE + 3);          cb.pattern_position = GET(ecode, 2);
1315          cb.next_item_length = GET(ecode, 3 + 2*LINK_SIZE);          cb.next_item_length = GET(ecode, 2 + LINK_SIZE);
1316          cb.capture_top      = offset_top/2;          cb.capture_top      = offset_top/2;
1317          cb.capture_last     = md->capture_last & CAPLMASK;          cb.capture_last     = md->capture_last & CAPLMASK;
1318          /* Internal change requires this for API compatibility. */          /* Internal change requires this for API compatibility. */
# Line 1315  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
1327          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        }        }
1332    
1333      condcode = ecode[LINK_SIZE+1];      /* Test the various possible conditions */
1334    
1335      /* Now see what the actual condition is */      condition = FALSE;
1336        switch(condcode = *ecode)
     if (condcode == OP_RREF || condcode == OP_NRREF)    /* Recursion test */  
1337        {        {
1338        if (md->recursive == NULL)                /* Not recursing => FALSE */        case OP_RREF:         /* Numbered group recursion test */
1339          {        if (md->recursive != NULL)     /* Not recursing => FALSE */
         condition = FALSE;  
         ecode += GET(ecode, 1);  
         }  
       else  
1340          {          {
1341          unsigned int recno = GET2(ecode, LINK_SIZE + 2);   /* Recursion group number*/          unsigned int recno = GET2(ecode, 1);   /* Recursion group number*/
1342          condition = (recno == RREF_ANY || recno == md->recursive->group_num);          condition = (recno == RREF_ANY || recno == md->recursive->group_num);
1343            }
1344          break;
1345    
1346          /* If the test is for recursion into a specific subpattern, and it is        case OP_DNRREF:       /* Duplicate named group recursion test */
1347          false, but the test was set up by name, scan the table to see if the        if (md->recursive != NULL)
1348          name refers to any other numbers, and test them. The condition is true          {
1349          if any one is set. */          int count = GET2(ecode, 1 + IMM2_SIZE);
1350            pcre_uchar *slot = md->name_table + GET2(ecode, 1) * md->name_entry_size;
1351          if (!condition && condcode == OP_NRREF)          while (count-- > 0)
1352            {            {
1353            pcre_uchar *slotA = md->name_table;            unsigned int recno = GET2(slot, 0);
1354            for (i = 0; i < md->name_count; i++)            condition = recno == md->recursive->group_num;
1355              {            if (condition) break;
1356              if (GET2(slotA, 0) == recno) break;            slot += md->name_entry_size;
             slotA += md->name_entry_size;  
             }  
   
           /* Found a name for the number - there can be only one; duplicate  
           names for different numbers are allowed, but not vice versa. First  
           scan down for duplicates. */  
   
           if (i < md->name_count)  
             {  
             pcre_uchar *slotB = slotA;  
             while (slotB > md->name_table)  
               {  
               slotB -= md->name_entry_size;  
               if (STRCMP_UC_UC(slotA + IMM2_SIZE, slotB + IMM2_SIZE) == 0)  
                 {  
                 condition = GET2(slotB, 0) == md->recursive->group_num;  
                 if (condition) break;  
                 }  
               else break;  
               }  
   
             /* Scan up for duplicates */  
   
             if (!condition)  
               {  
               slotB = slotA;  
               for (i++; i < md->name_count; i++)  
                 {  
                 slotB += md->name_entry_size;  
                 if (STRCMP_UC_UC(slotA + IMM2_SIZE, slotB + IMM2_SIZE) == 0)  
                   {  
                   condition = GET2(slotB, 0) == md->recursive->group_num;  
                   if (condition) break;  
                   }  
                 else break;  
                 }  
               }  
             }  
1357            }            }
   
         /* Chose branch according to the condition */  
   
         ecode += condition? 1 + IMM2_SIZE : GET(ecode, 1);  
1358          }          }
1359        }        break;
1360    
1361      else if (condcode == OP_CREF || condcode == OP_NCREF)  /* Group used test */        case OP_CREF:         /* Numbered group used test */
1362        {        offset = GET2(ecode, 1) << 1;  /* Doubled ref number */
       offset = GET2(ecode, LINK_SIZE+2) << 1;  /* Doubled ref number */  
1363        condition = offset < offset_top && md->offset_vector[offset] >= 0;        condition = offset < offset_top && md->offset_vector[offset] >= 0;
1364          break;
1365    
1366        /* If the numbered capture is unset, but the reference was by name,        case OP_DNCREF:      /* Duplicate named group used test */
       scan the table to see if the name refers to any other numbers, and test  
       them. The condition is true if any one is set. This is tediously similar  
       to the code above, but not close enough to try to amalgamate. */  
   
       if (!condition && condcode == OP_NCREF)  
1367          {          {
1368          unsigned int refno = offset >> 1;          int count = GET2(ecode, 1 + IMM2_SIZE);
1369          pcre_uchar *slotA = md->name_table;          pcre_uchar *slot = md->name_table + GET2(ecode, 1) * md->name_entry_size;
1370            while (count-- > 0)
1371          for (i = 0; i < md->name_count; i++)            {
1372            {            offset = GET2(slot, 0) << 1;
1373            if (GET2(slotA, 0) == refno) break;            condition = offset < offset_top && md->offset_vector[offset] >= 0;
1374            slotA += md->name_entry_size;            if (condition) break;
1375            }            slot += md->name_entry_size;
   
         /* Found a name for the number - there can be only one; duplicate names  
         for different numbers are allowed, but not vice versa. First scan down  
         for duplicates. */  
   
         if (i < md->name_count)  
           {  
           pcre_uchar *slotB = slotA;  
           while (slotB > md->name_table)  
             {  
             slotB -= md->name_entry_size;  
             if (STRCMP_UC_UC(slotA + IMM2_SIZE, slotB + IMM2_SIZE) == 0)  
               {  
               offset = GET2(slotB, 0) << 1;  
               condition = offset < offset_top &&  
                 md->offset_vector[offset] >= 0;  
               if (condition) break;  
               }  
             else break;  
             }  
   
           /* Scan up for duplicates */  
   
           if (!condition)  
             {  
             slotB = slotA;  
             for (i++; i < md->name_count; i++)  
               {  
               slotB += md->name_entry_size;  
               if (STRCMP_UC_UC(slotA + IMM2_SIZE, slotB + IMM2_SIZE) == 0)  
                 {  
                 offset = GET2(slotB, 0) << 1;  
                 condition = offset < offset_top &&  
                   md->offset_vector[offset] >= 0;  
                 if (condition) break;  
                 }  
               else break;  
               }  
             }  
1376            }            }
1377          }          }
1378          break;
1379    
1380        /* Chose branch according to the condition */        case OP_DEF:     /* DEFINE - always false */
1381          break;
       ecode += condition? 1 + IMM2_SIZE : GET(ecode, 1);  
       }  
   
     else if (condcode == OP_DEF)     /* DEFINE - always false */  
       {  
       condition = FALSE;  
       ecode += GET(ecode, 1);  
       }  
1382    
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 of        md->match_function_type to MATCH_CONDASSERT causes it to stop at the end
1385      an assertion. */        of an assertion. */
1386    
1387      else        default:
       {  
1388        md->match_function_type = MATCH_CONDASSERT;        md->match_function_type = MATCH_CONDASSERT;
1389        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, NULL, RM3);        RMATCH(eptr, ecode, offset_top, md, NULL, RM3);
1390        if (rrc == MATCH_MATCH)        if (rrc == MATCH_MATCH)
1391          {          {
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          ecode += 1 + LINK_SIZE + GET(ecode, LINK_SIZE + 2);  
1396            /* Advance ecode past the assertion to the start of the first branch,
1397            but adjust it so that the general choosing code below works. */
1398    
1399            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];
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. */        assertion; it is therefore treated as NOMATCH. Any other return is an
1406          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        else        break;
         {  
         condition = FALSE;  
         ecode += codelink;  
         }  
1413        }        }
1414    
1415      /* We are now at the branch that is to be obeyed. As there is only one, can      /* Choose branch according to the condition */
     use tail recursion to avoid using another stack frame, except when there is  
     unlimited repeat of a possibly empty group. In the latter case, a recursive  
     call to match() is always required, unless the second alternative doesn't  
     exist, in which case we can just plough on. Note that, for compatibility  
     with Perl, the | in a conditional group is NOT treated as creating two  
     alternatives. If a THEN is encountered in the branch, it propagates out to  
     the enclosing alternative (unless nested in a deeper set of alternatives,  
     of course). */  
1416    
1417      if (condition || *ecode == OP_ALT)      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
1420        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
1422        recursive call to match() is always required, unless the second alternative
1423        doesn't exist, in which case we can just plough on. Note that, for
1424        compatibility with Perl, the | in a conditional group is NOT treated as
1425        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
1427        of alternatives, of course). */
1428    
1429        if (condition || ecode[-(1+LINK_SIZE)] == OP_ALT)
1430        {        {
1431        if (op != OP_SCOND)        if (op != OP_SCOND)
1432          {          {
         ecode += 1 + LINK_SIZE;  
1433          goto TAIL_RECURSE;          goto TAIL_RECURSE;
1434          }          }
1435    
1436        md->match_function_type = MATCH_CBEGROUP;        md->match_function_type = MATCH_CBEGROUP;
1437        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM49);        RMATCH(eptr, ecode, offset_top, md, eptrb, RM49);
1438        RRETURN(rrc);        RRETURN(rrc);
1439        }        }
1440    
# Line 1523  for (;;) Line 1442  for (;;)
1442    
1443      else      else
1444        {        {
       ecode += 1 + LINK_SIZE;  
1445        }        }
1446      break;      break;
1447    
# Line 2089  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 2656  for (;;) Line 2575  for (;;)
2575            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2576          break;          break;
2577    
2578          case PT_SPACE:    /* Perl space */          /* Perl space used to exclude VT, but from Perl 5.18 it is included,
2579          if ((PRIV(ucp_gentype)[prop->chartype] == ucp_Z ||          which means that Perl space and POSIX space are now identical. PCRE
2580               c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR)          was changed at release 8.34. */
                == (op == OP_NOTPROP))  
           RRETURN(MATCH_NOMATCH);  
         break;  
2581    
2582            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 2753  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 2785  for (;;) Line 2709  for (;;)
2709      caseless = op == OP_REFI;      caseless = op == OP_REFI;
2710      offset = GET2(ecode, 1) << 1;               /* Doubled ref number */      offset = GET2(ecode, 1) << 1;               /* Doubled ref number */
2711      ecode += 1 + IMM2_SIZE;      ecode += 1 + IMM2_SIZE;
   
   
2712      if (offset >= offset_top || md->offset_vector[offset] < 0)      if (offset >= offset_top || md->offset_vector[offset] < 0)
2713        length = (md->jscript_compat)? 0 : -1;        length = (md->jscript_compat)? 0 : -1;
2714      else      else
# Line 2943  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 2952  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 3094  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 3124  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 3139  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 3157  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 3166  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 3238  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 4283  for (;;) Line 4227  for (;;)
4227              }              }
4228            break;            break;
4229    
4230              /* 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
4232              was changed at release 8.34. */
4233    
4234            case PT_SPACE:    /* Perl space */            case PT_SPACE:    /* Perl space */
4235              case PT_PXSPACE:  /* POSIX space */
4236            for (i = 1; i <= min; i++)            for (i = 1; i <= min; i++)
4237              {              {
4238              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
# Line 4292  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)
                  c == CHAR_FF || c == CHAR_CR)  
                    == prop_fail_result)  
               RRETURN(MATCH_NOMATCH);  
             }  
           break;  
   
           case PT_PXSPACE:  /* POSIX space */  
           for (i = 1; i <= min; i++)  
             {  
             if (eptr >= md->end_subject)  
4245                {                {
4246                SCHECK_PARTIAL();                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                }                }
             GETCHARINCTEST(c, eptr);  
             if ((UCD_CATEGORY(c) == ucp_Z || c == CHAR_HT || c == CHAR_NL ||  
                  c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)  
                    == prop_fail_result)  
               RRETURN(MATCH_NOMATCH);  
4256              }              }
4257            break;            break;
4258    
# Line 5031  for (;;) Line 4972  for (;;)
4972              }              }
4973            /* Control never gets here */            /* Control never gets here */
4974    
4975            case PT_SPACE:    /* Perl space */            /* Perl space used to exclude VT, but from Perl 5.18 it is included,
4976            for (fi = min;; fi++)            which means that Perl space and POSIX space are now identical. PCRE
4977              {            was changed at release 8.34. */
             RMATCH(eptr, ecode, offset_top, md, eptrb, RM60);  
             if (rrc != MATCH_NOMATCH) RRETURN(rrc);  
             if (fi >= max) RRETURN(MATCH_NOMATCH);  
             if (eptr >= md->end_subject)  
               {  
               SCHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
             GETCHARINCTEST(c, eptr);  
             if ((UCD_CATEGORY(c) == ucp_Z || c == CHAR_HT || c == CHAR_NL ||  
                  c == CHAR_FF || c == CHAR_CR)  
                    == prop_fail_result)  
               RRETURN(MATCH_NOMATCH);  
             }  
           /* Control never gets here */  
4978    
4979              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++)
4982              {              {
# Line 5062  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 5118  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 5549  for (;;) Line 5484  for (;;)
5484              }              }
5485            break;            break;
5486    
5487              /* 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
5489              was changed at release 8.34. */
5490    
5491            case PT_SPACE:    /* Perl space */            case PT_SPACE:    /* Perl space */
5492              case PT_PXSPACE:  /* POSIX space */
5493            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5494              {              {
5495              int len = 1;              int len = 1;
# Line 5559  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_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;
             eptr+= len;  
             }  
           break;  
5508    
5509            case PT_PXSPACE:  /* POSIX space */                default:
5510            for (i = min; i < max; i++)                if ((UCD_CATEGORY(c) == ucp_Z) == prop_fail_result)
5511              {                  goto ENDLOOP99;   /* Break the loop */
             int len = 1;  
             if (eptr >= md->end_subject)  
               {  
               SCHECK_PARTIAL();  
5512                break;                break;
5513                }                }
             GETCHARLENTEST(c, eptr, len);  
             if ((UCD_CATEGORY(c) == ucp_Z || c == CHAR_HT || c == CHAR_NL ||  
                  c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)  
                  == prop_fail_result)  
               break;  
5514              eptr+= len;              eptr+= len;
5515              }              }
5516              ENDLOOP99:
5517            break;            break;
5518    
5519            case PT_WORD:            case PT_WORD:
# Line 5696  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 5709  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 5727  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 6251  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 6287  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.1361  
changed lines
  Added in v.1411

  ViewVC Help
Powered by ViewVC 1.1.5