/[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 893 by ph10, Thu Jan 19 17:15:11 2012 UTC revision 916 by ph10, Wed Feb 15 09:50:53 2012 UTC
# Line 140  Arguments: Line 140  Arguments:
140    md          points to match data block    md          points to match data block
141    caseless    TRUE if caseless    caseless    TRUE if caseless
142    
143  Returns:      < 0 if not matched, otherwise the number of subject bytes matched  Returns:      >= 0 the number of subject bytes matched
144                  -1 no match
145                  -2 partial match; always given if at end subject
146  */  */
147    
148  static int  static int
# Line 163  pchars(p, length, FALSE, md); Line 165  pchars(p, length, FALSE, md);
165  printf("\n");  printf("\n");
166  #endif  #endif
167    
168  /* Always fail if reference not set (and not JavaScript compatible). */  /* Always fail if reference not set (and not JavaScript compatible - in that
169    case the length is passed as zero). */
170    
171  if (length < 0) return -1;  if (length < 0) return -1;
172    
# Line 189  if (caseless) Line 192  if (caseless)
192      while (p < endptr)      while (p < endptr)
193        {        {
194        int c, d;        int c, d;
195        if (eptr >= md->end_subject) return -1;        if (eptr >= md->end_subject) return -2;   /* Partial match */
196        GETCHARINC(c, eptr);        GETCHARINC(c, eptr);
197        GETCHARINC(d, p);        GETCHARINC(d, p);
198        if (c != d && c != UCD_OTHERCASE(d)) return -1;        if (c != d && c != UCD_OTHERCASE(d)) return -1;
# Line 202  if (caseless) Line 205  if (caseless)
205    /* 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
206    is no UCP support. */    is no UCP support. */
207      {      {
     if (eptr + length > md->end_subject) return -1;  
208      while (length-- > 0)      while (length-- > 0)
209        {        {
210          if (eptr >= md->end_subject) return -2;   /* Partial match */
211        if (TABLE_GET(*p, md->lcc, *p) != TABLE_GET(*eptr, md->lcc, *eptr)) return -1;        if (TABLE_GET(*p, md->lcc, *p) != TABLE_GET(*eptr, md->lcc, *eptr)) return -1;
212        p++;        p++;
213        eptr++;        eptr++;
# Line 217  are in UTF-8 mode. */ Line 220  are in UTF-8 mode. */
220    
221  else  else
222    {    {
223    if (eptr + length > md->end_subject) return -1;    while (length-- > 0)
224    while (length-- > 0) if (*p++ != *eptr++) return -1;      {
225        if (eptr >= md->end_subject) return -2;   /* Partial match */
226        if (*p++ != *eptr++) return -1;
227        }
228    }    }
229    
230  return (int)(eptr - eptr_start);  return (int)(eptr - eptr_start);
# Line 487  int condcode; Line 493  int condcode;
493  /* When recursion is not being used, all "local" variables that have to be  /* When recursion is not being used, all "local" variables that have to be
494  preserved over calls to RMATCH() are part of a "frame". We set up the top-level  preserved over calls to RMATCH() are part of a "frame". We set up the top-level
495  frame on the stack here; subsequent instantiations are obtained from the heap  frame on the stack here; subsequent instantiations are obtained from the heap
496  whenever RMATCH() does a "recursion". See the macro definitions above. Putting  whenever RMATCH() does a "recursion". See the macro definitions above. Putting
497  the top-level on the stack rather than malloc-ing them all gives a performance  the top-level on the stack rather than malloc-ing them all gives a performance
498  boost in many cases where there is not much "recursion". */  boost in many cases where there is not much "recursion". */
499    
500  #ifdef NO_RECURSE  #ifdef NO_RECURSE
501  heapframe frame_zero;  heapframe frame_zero;
502  heapframe *frame = &frame_zero;  heapframe *frame = &frame_zero;
503  frame->Xprevframe = NULL;            /* Marks the top level */  frame->Xprevframe = NULL;            /* Marks the top level */
504    
505  /* Copy in the original argument variables */  /* Copy in the original argument variables */
# Line 616  int stacksave[REC_STACK_SAVE_MAX]; Line 622  int stacksave[REC_STACK_SAVE_MAX];
622    
623  eptrblock newptrb;  eptrblock newptrb;
624    
625  /* There is a special fudge for calling match() in a way that causes it to  /* There is a special fudge for calling match() in a way that causes it to
626  measure the size of its basic stack frame when the stack is being used for  measure the size of its basic stack frame when the stack is being used for
627  recursion. The first argument (eptr) points to a pointer that is used  recursion. The second argument (ecode) being NULL triggers this behaviour. It
628  "statically" for doing the calculation. The second argument (ecode) being NULL  cannot normally ever be NULL. The return is the negated value of the frame
629  triggers this behaviour. It cannot normally every be NULL. The return is the  size. */
 negated value of the frame size. */  
630    
631  if (ecode == NULL)  if (ecode == NULL)
632    {    {
   char **aptr = (char **)eptr;  
633    if (rdepth == 0)    if (rdepth == 0)
634      {      return match((PCRE_PUCHAR)&rdepth, NULL, NULL, 0, NULL, NULL, 1);
     *aptr = (char *)&rdepth;  
     return match(eptr, NULL, NULL, 0, NULL, NULL, 1);  
     }  
635    else    else
636      {      {
637      int len = (char *)&rdepth - *aptr;      int len = (char *)&rdepth - (char *)eptr;
638      return (len > 0)? -len : len;      return (len > 0)? -len : len;
639      }      }
640    }    }
641  #endif     /* NO_RECURSE */  #endif     /* NO_RECURSE */
642    
643  /* To save space on the stack and in the heap frame, I have doubled up on some  /* To save space on the stack and in the heap frame, I have doubled up on some
# Line 843  for (;;) Line 844  for (;;)
844      case OP_ONCE_NC:      case OP_ONCE_NC:
845      prev = ecode;      prev = ecode;
846      saved_eptr = eptr;      saved_eptr = eptr;
847      save_mark = md->mark;      save_mark = md->mark;
848      do      do
849        {        {
850        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM64);        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM64);
# Line 862  for (;;) Line 863  for (;;)
863    
864        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
865        ecode += GET(ecode,1);        ecode += GET(ecode,1);
866        md->mark = save_mark;        md->mark = save_mark;
867        }        }
868      while (*ecode == OP_ALT);      while (*ecode == OP_ALT);
869    
# Line 942  for (;;) Line 943  for (;;)
943        save_offset2 = md->offset_vector[offset+1];        save_offset2 = md->offset_vector[offset+1];
944        save_offset3 = md->offset_vector[md->offset_end - number];        save_offset3 = md->offset_vector[md->offset_end - number];
945        save_capture_last = md->capture_last;        save_capture_last = md->capture_last;
946        save_mark = md->mark;        save_mark = md->mark;
947    
948        DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));        DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));
949        md->offset_vector[md->offset_end - number] =        md->offset_vector[md->offset_end - number] =
# Line 1048  for (;;) Line 1049  for (;;)
1049        save_mark = md->mark;        save_mark = md->mark;
1050        RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md, eptrb,        RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md, eptrb,
1051          RM2);          RM2);
1052    
1053        /* See comment in the code for capturing groups above about handling        /* See comment in the code for capturing groups above about handling
1054        THEN. */        THEN. */
1055    
# Line 1075  for (;;) Line 1076  for (;;)
1076          RRETURN(rrc);          RRETURN(rrc);
1077          }          }
1078        ecode += GET(ecode, 1);        ecode += GET(ecode, 1);
1079        md->mark = save_mark;        md->mark = save_mark;
1080        if (*ecode != OP_ALT) break;        if (*ecode != OP_ALT) break;
1081        }        }
1082    
# Line 1554  for (;;) Line 1555  for (;;)
1555    
1556      case OP_ASSERT:      case OP_ASSERT:
1557      case OP_ASSERTBACK:      case OP_ASSERTBACK:
1558      save_mark = md->mark;      save_mark = md->mark;
1559      if (md->match_function_type == MATCH_CONDASSERT)      if (md->match_function_type == MATCH_CONDASSERT)
1560        {        {
1561        condassert = TRUE;        condassert = TRUE;
# Line 1576  for (;;) Line 1577  for (;;)
1577    
1578        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
1579        ecode += GET(ecode, 1);        ecode += GET(ecode, 1);
1580        md->mark = save_mark;        md->mark = save_mark;
1581        }        }
1582      while (*ecode == OP_ALT);      while (*ecode == OP_ALT);
1583    
# Line 1600  for (;;) Line 1601  for (;;)
1601    
1602      case OP_ASSERT_NOT:      case OP_ASSERT_NOT:
1603      case OP_ASSERTBACK_NOT:      case OP_ASSERTBACK_NOT:
1604      save_mark = md->mark;      save_mark = md->mark;
1605      if (md->match_function_type == MATCH_CONDASSERT)      if (md->match_function_type == MATCH_CONDASSERT)
1606        {        {
1607        condassert = TRUE;        condassert = TRUE;
# Line 1611  for (;;) Line 1612  for (;;)
1612      do      do
1613        {        {
1614        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, NULL, RM5);        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, NULL, RM5);
1615        md->mark = save_mark;        md->mark = save_mark;
1616        if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) RRETURN(MATCH_NOMATCH);        if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) RRETURN(MATCH_NOMATCH);
1617        if (rrc == MATCH_SKIP || rrc == MATCH_PRUNE || rrc == MATCH_COMMIT)        if (rrc == MATCH_SKIP || rrc == MATCH_PRUNE || rrc == MATCH_COMMIT)
1618          {          {
# Line 2064  for (;;) Line 2065  for (;;)
2065    
2066      case OP_DOLLM:      case OP_DOLLM:
2067      if (eptr < md->end_subject)      if (eptr < md->end_subject)
2068        { if (!IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH); }        {
2069          if (!IS_NEWLINE(eptr))
2070            {
2071            if (eptr + 1 >= md->end_subject &&
2072                md->partial != 0 &&
2073                NLBLOCK->nltype == NLTYPE_FIXED &&
2074                NLBLOCK->nllen == 2 &&
2075                *eptr == NLBLOCK->nl[0])
2076              {
2077              md->hitend = TRUE;
2078              if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2079              }
2080            RRETURN(MATCH_NOMATCH);
2081            }
2082          }
2083      else      else
2084        {        {
2085        if (md->noteol) RRETURN(MATCH_NOMATCH);        if (md->noteol) RRETURN(MATCH_NOMATCH);
# Line 2096  for (;;) Line 2111  for (;;)
2111      ASSERT_NL_OR_EOS:      ASSERT_NL_OR_EOS:
2112      if (eptr < md->end_subject &&      if (eptr < md->end_subject &&
2113          (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))          (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
2114          {
2115          if (eptr + 1 >= md->end_subject &&
2116              md->partial != 0 &&
2117              NLBLOCK->nltype == NLTYPE_FIXED &&
2118              NLBLOCK->nllen == 2 &&
2119              *eptr == NLBLOCK->nl[0])
2120            {
2121            md->hitend = TRUE;
2122            if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2123            }
2124        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2125          }
2126    
2127      /* Either at end of string or \n before end. */      /* Either at end of string or \n before end. */
2128    
# Line 2370  for (;;) Line 2396  for (;;)
2396        default: RRETURN(MATCH_NOMATCH);        default: RRETURN(MATCH_NOMATCH);
2397    
2398        case 0x000d:        case 0x000d:
2399        if (eptr < md->end_subject && *eptr == 0x0a) eptr++;        if (eptr >= md->end_subject)
2400            {
2401            SCHECK_PARTIAL();
2402            }
2403          else if (*eptr == 0x0a) eptr++;
2404        break;        break;
2405    
2406        case 0x000a:        case 0x000a:
# Line 2600  for (;;) Line 2630  for (;;)
2630        if (UCD_CATEGORY(c) != ucp_M) break;        if (UCD_CATEGORY(c) != ucp_M) break;
2631        eptr += len;        eptr += len;
2632        }        }
2633        CHECK_PARTIAL();
2634      ecode++;      ecode++;
2635      break;      break;
2636  #endif  #endif
# Line 2665  for (;;) Line 2696  for (;;)
2696        default:               /* No repeat follows */        default:               /* No repeat follows */
2697        if ((length = match_ref(offset, eptr, length, md, caseless)) < 0)        if ((length = match_ref(offset, eptr, length, md, caseless)) < 0)
2698          {          {
2699            if (length == -2) eptr = md->end_subject;   /* Partial match */
2700          CHECK_PARTIAL();          CHECK_PARTIAL();
2701          RRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
2702          }          }
# Line 2690  for (;;) Line 2722  for (;;)
2722        int slength;        int slength;
2723        if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)        if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2724          {          {
2725            if (slength == -2) eptr = md->end_subject;   /* Partial match */
2726          CHECK_PARTIAL();          CHECK_PARTIAL();
2727          RRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
2728          }          }
# Line 2713  for (;;) Line 2746  for (;;)
2746          if (fi >= max) RRETURN(MATCH_NOMATCH);          if (fi >= max) RRETURN(MATCH_NOMATCH);
2747          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2748            {            {
2749              if (slength == -2) eptr = md->end_subject;   /* Partial match */
2750            CHECK_PARTIAL();            CHECK_PARTIAL();
2751            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2752            }            }
# Line 2731  for (;;) Line 2765  for (;;)
2765          int slength;          int slength;
2766          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2767            {            {
2768            CHECK_PARTIAL();            /* Can't use CHECK_PARTIAL because we don't want to update eptr in
2769              the soft partial matching case. */
2770    
2771              if (slength == -2 && md->partial != 0 &&
2772                  md->end_subject > md->start_used_ptr)
2773                {
2774                md->hitend = TRUE;
2775                if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2776                }
2777            break;            break;
2778            }            }
2779          eptr += slength;          eptr += slength;
2780          }          }
2781    
2782        while (eptr >= pp)        while (eptr >= pp)
2783          {          {
2784          RMATCH(eptr, ecode, offset_top, md, eptrb, RM15);          RMATCH(eptr, ecode, offset_top, md, eptrb, RM15);
# Line 3513  for (;;) Line 3556  for (;;)
3556      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
3557      if (op == OP_NOTI)         /* The caseless case */      if (op == OP_NOTI)         /* The caseless case */
3558        {        {
3559        register int ch, och;        register unsigned int ch, och;
3560        ch = *ecode++;        ch = *ecode++;
3561  #ifdef COMPILE_PCRE8  #ifdef COMPILE_PCRE8
3562        /* ch must be < 128 if UTF is enabled. */        /* ch must be < 128 if UTF is enabled. */
# Line 3659  for (;;) Line 3702  for (;;)
3702              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3703              }              }
3704            GETCHARINC(d, eptr);            GETCHARINC(d, eptr);
3705            if (fc == d || foc == d) RRETURN(MATCH_NOMATCH);            if (fc == d || (unsigned int) foc == d) RRETURN(MATCH_NOMATCH);
3706            }            }
3707          }          }
3708        else        else
# Line 3697  for (;;) Line 3740  for (;;)
3740                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3741                }                }
3742              GETCHARINC(d, eptr);              GETCHARINC(d, eptr);
3743              if (fc == d || foc == d) RRETURN(MATCH_NOMATCH);              if (fc == d || (unsigned int)foc == d) RRETURN(MATCH_NOMATCH);
3744              }              }
3745            }            }
3746          else          else
# Line 3740  for (;;) Line 3783  for (;;)
3783                break;                break;
3784                }                }
3785              GETCHARLEN(d, eptr, len);              GETCHARLEN(d, eptr, len);
3786              if (fc == d || foc == d) break;              if (fc == d || (unsigned int)foc == d) break;
3787              eptr += len;              eptr += len;
3788              }              }
3789            if (possessive) continue;            if (possessive) continue;
# Line 4169  for (;;) Line 4212  for (;;)
4212              if (UCD_CATEGORY(c) != ucp_M) break;              if (UCD_CATEGORY(c) != ucp_M) break;
4213              eptr += len;              eptr += len;
4214              }              }
4215              CHECK_PARTIAL();
4216            }            }
4217          }          }
4218    
# Line 4953  for (;;) Line 4997  for (;;)
4997              if (UCD_CATEGORY(c) != ucp_M) break;              if (UCD_CATEGORY(c) != ucp_M) break;
4998              eptr += len;              eptr += len;
4999              }              }
5000              CHECK_PARTIAL();
5001            }            }
5002          }          }
5003        else        else
# Line 5496  for (;;) Line 5541  for (;;)
5541              if (UCD_CATEGORY(c) != ucp_M) break;              if (UCD_CATEGORY(c) != ucp_M) break;
5542              eptr += len;              eptr += len;
5543              }              }
5544              CHECK_PARTIAL();
5545            }            }
5546    
5547          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
# Line 6212  PCRE_PUCHAR req_char_ptr = start_match - Line 6258  PCRE_PUCHAR req_char_ptr = start_match -
6258  const pcre_study_data *study;  const pcre_study_data *study;
6259  const REAL_PCRE *re = (const REAL_PCRE *)argument_re;  const REAL_PCRE *re = (const REAL_PCRE *)argument_re;
6260    
6261  /* Check for the special magic call that measures the size of the stack used  /* Check for the special magic call that measures the size of the stack used
6262  per recursive call of match(). */  per recursive call of match(). Without the funny casting for sizeof, a Windows
6263    compiler gave this error: "unary minus operator applied to unsigned type,
6264    result still unsigned". Hopefully the cast fixes that. */
6265    
6266  if (re == NULL && extra_data == NULL && subject == NULL && length == -1)  if (re == NULL && extra_data == NULL && subject == NULL && length == -999 &&
6267        start_offset == -999)
6268  #ifdef NO_RECURSE  #ifdef NO_RECURSE
6269    return -sizeof(heapframe);    return -((int)sizeof(heapframe));
6270  #else  #else
6271    return match((PCRE_PUCHAR)&start_partial, NULL, NULL, 0, NULL, NULL, 0);    return match(NULL, NULL, NULL, 0, NULL, NULL, 0);
6272  #endif  #endif
6273    
6274  /* Plausibility checks */  /* Plausibility checks */
6275    
6276  if ((options & ~PUBLIC_EXEC_OPTIONS) != 0) return PCRE_ERROR_BADOPTION;  if ((options & ~PUBLIC_EXEC_OPTIONS) != 0) return PCRE_ERROR_BADOPTION;
6277  if (re == NULL || subject == NULL || (offsets == NULL && offsetcount > 0))  if (re == NULL || subject == NULL || (offsets == NULL && offsetcount > 0))
6278    return PCRE_ERROR_NULL;    return PCRE_ERROR_NULL;
6279  if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;  if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;
6280  if (start_offset < 0 || start_offset > length) return PCRE_ERROR_BADOFFSET;  if (start_offset < 0 || start_offset > length) return PCRE_ERROR_BADOFFSET;
# Line 6284  if (utf && (options & PCRE_NO_UTF8_CHECK Line 6333  if (utf && (options & PCRE_NO_UTF8_CHECK
6333  /* If the pattern was successfully studied with JIT support, run the JIT  /* If the pattern was successfully studied with JIT support, run the JIT
6334  executable instead of the rest of this function. Most options must be set at  executable instead of the rest of this function. Most options must be set at
6335  compile time for the JIT code to be usable. Fallback to the normal code path if  compile time for the JIT code to be usable. Fallback to the normal code path if
6336  an unsupported flag is set. In particular, JIT does not support partial  an unsupported flag is set. */
 matching. */  
6337    
6338  #ifdef SUPPORT_JIT  #ifdef SUPPORT_JIT
6339  if (extra_data != NULL  if (extra_data != NULL
6340      && (extra_data->flags & PCRE_EXTRA_EXECUTABLE_JIT) != 0      && (extra_data->flags & (PCRE_EXTRA_EXECUTABLE_JIT |
6341                                 PCRE_EXTRA_TABLES)) == PCRE_EXTRA_EXECUTABLE_JIT
6342      && extra_data->executable_jit != NULL      && extra_data->executable_jit != NULL
     && (extra_data->flags & PCRE_EXTRA_TABLES) == 0  
6343      && (options & ~(PCRE_NO_UTF8_CHECK | PCRE_NOTBOL | PCRE_NOTEOL |      && (options & ~(PCRE_NO_UTF8_CHECK | PCRE_NOTBOL | PCRE_NOTEOL |
6344                      PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART)) == 0)                      PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART |
6345    return PRIV(jit_exec)(re, extra_data->executable_jit,                      PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD)) == 0)
6346      {
6347      rc = PRIV(jit_exec)(re, extra_data->executable_jit,
6348      (const pcre_uchar *)subject, length, start_offset, options,      (const pcre_uchar *)subject, length, start_offset, options,
6349      ((extra_data->flags & PCRE_EXTRA_MATCH_LIMIT) == 0)      ((extra_data->flags & PCRE_EXTRA_MATCH_LIMIT) == 0)
6350      ? MATCH_LIMIT : extra_data->match_limit, offsets, offsetcount);      ? MATCH_LIMIT : extra_data->match_limit, offsets, offsetcount);
6351    
6352      /* PCRE_ERROR_NULL means that the selected normal or partial matching
6353      mode is not compiled. In this case we simply fallback to interpreter. */
6354    
6355      if (rc != PCRE_ERROR_NULL) return rc;
6356      }
6357  #endif  #endif
6358    
6359  /* Carry on with non-JIT matching. This information is for finding all the  /* Carry on with non-JIT matching. This information is for finding all the
# Line 6500  if (!anchored) Line 6556  if (!anchored)
6556    if ((re->flags & PCRE_FIRSTSET) != 0)    if ((re->flags & PCRE_FIRSTSET) != 0)
6557      {      {
6558      has_first_char = TRUE;      has_first_char = TRUE;
6559      first_char = first_char2 = re->first_char;      first_char = first_char2 = (pcre_uchar)(re->first_char);
6560      if ((re->flags & PCRE_FCH_CASELESS) != 0)      if ((re->flags & PCRE_FCH_CASELESS) != 0)
6561        {        {
6562        first_char2 = TABLE_GET(first_char, md->fcc, first_char);        first_char2 = TABLE_GET(first_char, md->fcc, first_char);
# Line 6522  character" set. */ Line 6578  character" set. */
6578  if ((re->flags & PCRE_REQCHSET) != 0)  if ((re->flags & PCRE_REQCHSET) != 0)
6579    {    {
6580    has_req_char = TRUE;    has_req_char = TRUE;
6581    req_char = req_char2 = re->req_char;    req_char = req_char2 = (pcre_uchar)(re->req_char);
6582    if ((re->flags & PCRE_RCH_CASELESS) != 0)    if ((re->flags & PCRE_RCH_CASELESS) != 0)
6583      {      {
6584      req_char2 = TABLE_GET(req_char, md->fcc, req_char);      req_char2 = TABLE_GET(req_char, md->fcc, req_char);

Legend:
Removed from v.893  
changed lines
  Added in v.916

  ViewVC Help
Powered by ViewVC 1.1.5