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

Diff of /code/trunk/pcre_jit_compile.c

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

revision 1440 by zherczeg, Sat Jan 11 21:54:20 2014 UTC revision 1452 by zherczeg, Tue Jan 28 16:07:52 2014 UTC
# Line 398  typedef struct compiler_common { Line 398  typedef struct compiler_common {
398    struct sljit_label *quit_label;    struct sljit_label *quit_label;
399    struct sljit_label *forced_quit_label;    struct sljit_label *forced_quit_label;
400    struct sljit_label *accept_label;    struct sljit_label *accept_label;
401      struct sljit_label *ff_newline_shortcut;
402    stub_list *stubs;    stub_list *stubs;
403    label_addr_list *label_addrs;    label_addr_list *label_addrs;
404    recurse_entry *entries;    recurse_entry *entries;
# Line 3149  if (newlinecheck) Line 3150  if (newlinecheck)
3150  return mainloop;  return mainloop;
3151  }  }
3152    
3153  static int scan_prefix(compiler_common *common, pcre_uchar *cc, pcre_uint32 *chars, int max_chars)  #define MAX_N_CHARS 16
3154    #define MAX_N_BYTES 8
3155    
3156    static SLJIT_INLINE void add_prefix_byte(pcre_uint8 byte, pcre_uint8 *bytes)
3157    {
3158    pcre_uint8 len = bytes[0];
3159    int i;
3160    
3161    if (len == 255)
3162      return;
3163    
3164    if (len == 0)
3165      {
3166      bytes[0] = 1;
3167      bytes[1] = byte;
3168      return;
3169      }
3170    
3171    for (i = len; i > 0; i--)
3172      if (bytes[i] == byte)
3173        return;
3174    
3175    if (len >= MAX_N_BYTES - 1)
3176      {
3177      bytes[0] = 255;
3178      return;
3179      }
3180    
3181    len++;
3182    bytes[len] = byte;
3183    bytes[0] = len;
3184    }
3185    
3186    static int scan_prefix(compiler_common *common, pcre_uchar *cc, pcre_uint32 *chars, pcre_uint8 *bytes, int max_chars)
3187  {  {
3188  /* Recursive function, which scans prefix literals. */  /* Recursive function, which scans prefix literals. */
3189    BOOL last, any, caseless;
3190  int len, repeat, len_save, consumed = 0;  int len, repeat, len_save, consumed = 0;
3191  pcre_uint32 caseless, chr, mask;  pcre_uint32 chr, mask;
3192  pcre_uchar *alternative, *cc_save;  pcre_uchar *alternative, *cc_save, *oc;
3193  BOOL last, any;  #if defined SUPPORT_UTF && defined COMPILE_PCRE8
3194    pcre_uchar othercase[8];
3195    #elif defined SUPPORT_UTF && defined COMPILE_PCRE16
3196    pcre_uchar othercase[2];
3197    #else
3198    pcre_uchar othercase[1];
3199    #endif
3200    
3201  repeat = 1;  repeat = 1;
3202  while (TRUE)  while (TRUE)
3203    {    {
3204    last = TRUE;    last = TRUE;
3205    any = FALSE;    any = FALSE;
3206    caseless = 0;    caseless = FALSE;
3207    switch (*cc)    switch (*cc)
3208      {      {
3209      case OP_CHARI:      case OP_CHARI:
3210      caseless = 1;      caseless = TRUE;
3211      case OP_CHAR:      case OP_CHAR:
3212      last = FALSE;      last = FALSE;
3213      cc++;      cc++;
# Line 3194  while (TRUE) Line 3235  while (TRUE)
3235      cc = bracketend(cc);      cc = bracketend(cc);
3236      continue;      continue;
3237    
3238        case OP_PLUSI:
3239        case OP_MINPLUSI:
3240        case OP_POSPLUSI:
3241        caseless = TRUE;
3242      case OP_PLUS:      case OP_PLUS:
3243      case OP_MINPLUS:      case OP_MINPLUS:
3244      case OP_POSPLUS:      case OP_POSPLUS:
# Line 3201  while (TRUE) Line 3246  while (TRUE)
3246      break;      break;
3247    
3248      case OP_EXACTI:      case OP_EXACTI:
3249      caseless = 1;      caseless = TRUE;
3250      case OP_EXACT:      case OP_EXACT:
3251      repeat = GET2(cc, 1);      repeat = GET2(cc, 1);
3252      last = FALSE;      last = FALSE;
3253      cc += 1 + IMM2_SIZE;      cc += 1 + IMM2_SIZE;
3254      break;      break;
3255    
3256      case OP_PLUSI:      case OP_QUERYI:
3257      case OP_MINPLUSI:      case OP_MINQUERYI:
3258      case OP_POSPLUSI:      case OP_POSQUERYI:
3259      caseless = 1;      caseless = TRUE;
3260        case OP_QUERY:
3261        case OP_MINQUERY:
3262        case OP_POSQUERY:
3263        len = 1;
3264      cc++;      cc++;
3265    #ifdef SUPPORT_UTF
3266        if (common->utf && HAS_EXTRALEN(*cc)) len += GET_EXTRALEN(*cc);
3267    #endif
3268        max_chars = scan_prefix(common, cc + len, chars, bytes, max_chars);
3269        if (max_chars == 0)
3270          return consumed;
3271        last = FALSE;
3272      break;      break;
3273    
3274      case OP_KET:      case OP_KET:
# Line 3232  while (TRUE) Line 3288  while (TRUE)
3288      alternative = cc + GET(cc, 1);      alternative = cc + GET(cc, 1);
3289      while (*alternative == OP_ALT)      while (*alternative == OP_ALT)
3290        {        {
3291        max_chars = scan_prefix(common, alternative + 1 + LINK_SIZE, chars, max_chars);        max_chars = scan_prefix(common, alternative + 1 + LINK_SIZE, chars, bytes, max_chars);
3292        if (max_chars == 0)        if (max_chars == 0)
3293          return consumed;          return consumed;
3294        alternative += GET(alternative, 1);        alternative += GET(alternative, 1);
# Line 3296  while (TRUE) Line 3352  while (TRUE)
3352      cc++;      cc++;
3353      break;      break;
3354    
3355        case OP_NOT:
3356        case OP_NOTI:
3357        cc++;
3358        /* Fall through. */
3359      case OP_NOT_DIGIT:      case OP_NOT_DIGIT:
3360      case OP_NOT_WHITESPACE:      case OP_NOT_WHITESPACE:
3361      case OP_NOT_WORDCHAR:      case OP_NOT_WORDCHAR:
# Line 3324  while (TRUE) Line 3384  while (TRUE)
3384      cc += 1 + IMM2_SIZE;      cc += 1 + IMM2_SIZE;
3385      continue;      continue;
3386    
3387        case OP_NOTEXACT:
3388        case OP_NOTEXACTI:
3389    #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
3390        if (common->utf) return consumed;
3391    #endif
3392        any = TRUE;
3393        repeat = GET2(cc, 1);
3394        cc += 1 + IMM2_SIZE + 1;
3395        break;
3396    
3397      default:      default:
3398      return consumed;      return consumed;
3399      }      }
# Line 3344  while (TRUE) Line 3414  while (TRUE)
3414        {        {
3415        chars[0] = mask;        chars[0] = mask;
3416        chars[1] = mask;        chars[1] = mask;
3417          bytes[0] = 255;
3418    
3419        consumed++;        consumed++;
3420        if (--max_chars == 0)        if (--max_chars == 0)
3421          return consumed;          return consumed;
3422        chars += 2;        chars += 2;
3423          bytes += MAX_N_BYTES;
3424        }        }
3425      while (--repeat > 0);      while (--repeat > 0);
3426    
# Line 3361  while (TRUE) Line 3433  while (TRUE)
3433    if (common->utf && HAS_EXTRALEN(*cc)) len += GET_EXTRALEN(*cc);    if (common->utf && HAS_EXTRALEN(*cc)) len += GET_EXTRALEN(*cc);
3434  #endif  #endif
3435    
3436    if (caseless != 0 && char_has_othercase(common, cc))    if (caseless && char_has_othercase(common, cc))
3437      {      {
3438      caseless = char_get_othercase_bit(common, cc);  #ifdef SUPPORT_UTF
3439      if (caseless == 0)      if (common->utf)
3440        return consumed;        {
3441  #ifdef COMPILE_PCRE8        GETCHAR(chr, cc);
3442      caseless = ((caseless & 0xff) << 8) | (len - (caseless >> 8));        if ((int)PRIV(ord2utf)(char_othercase(common, chr), othercase) != len)
3443  #else          return consumed;
3444      if ((caseless & 0x100) != 0)        }
       caseless = ((caseless & 0xff) << 16) | (len - (caseless >> 9));  
3445      else      else
       caseless = ((caseless & 0xff) << 8) | (len - (caseless >> 9));  
3446  #endif  #endif
3447          {
3448          chr = *cc;
3449          othercase[0] = TABLE_GET(chr, common->fcc, chr);
3450          }
3451      }      }
3452    else    else
3453      caseless = 0;      caseless = FALSE;
3454    
3455    len_save = len;    len_save = len;
3456    cc_save = cc;    cc_save = cc;
3457    while (TRUE)    while (TRUE)
3458      {      {
3459        oc = othercase;
3460      do      do
3461        {        {
3462        chr = *cc;        chr = *cc;
# Line 3389  while (TRUE) Line 3464  while (TRUE)
3464        if (SLJIT_UNLIKELY(chr == NOTACHAR))        if (SLJIT_UNLIKELY(chr == NOTACHAR))
3465          return consumed;          return consumed;
3466  #endif  #endif
3467          add_prefix_byte((pcre_uint8)chr, bytes);
3468    
3469        mask = 0;        mask = 0;
3470        if ((pcre_uint32)len == (caseless & 0xff))        if (caseless)
3471          {          {
3472          mask = caseless >> 8;          add_prefix_byte((pcre_uint8)*oc, bytes);
3473            mask = *cc ^ *oc;
3474          chr |= mask;          chr |= mask;
3475          }          }
3476    
# Line 3418  while (TRUE) Line 3496  while (TRUE)
3496        if (--max_chars == 0)        if (--max_chars == 0)
3497          return consumed;          return consumed;
3498        chars += 2;        chars += 2;
3499          bytes += MAX_N_BYTES;
3500        cc++;        cc++;
3501          oc++;
3502        }        }
3503      while (len > 0);      while (len > 0);
3504    
# Line 3435  while (TRUE) Line 3515  while (TRUE)
3515    }    }
3516  }  }
3517    
 #define MAX_N_CHARS 16  
 #define MIN_RANGE_SIZE 4  
   
3518  static SLJIT_INLINE BOOL fast_forward_first_n_chars(compiler_common *common, BOOL firstline)  static SLJIT_INLINE BOOL fast_forward_first_n_chars(compiler_common *common, BOOL firstline)
3519  {  {
3520  DEFINE_COMPILER;  DEFINE_COMPILER;
3521  struct sljit_label *start;  struct sljit_label *start;
3522  struct sljit_jump *quit;  struct sljit_jump *quit;
3523  pcre_uint32 chars[MAX_N_CHARS * 2];  pcre_uint32 chars[MAX_N_CHARS * 2];
3524    pcre_uint8 bytes[MAX_N_CHARS * MAX_N_BYTES];
3525  pcre_uint8 ones[MAX_N_CHARS];  pcre_uint8 ones[MAX_N_CHARS];
3526  int offsets[3];  int offsets[3];
3527  pcre_uint32 mask, byte;  pcre_uint32 mask;
3528    pcre_uint8 *byte_set, *byte_set_end;
3529  int i, max, from;  int i, max, from;
3530  int range_right = -1, range_len = -1;  int range_right = -1, range_len = 3 - 1;
3531  sljit_ub *update_table = NULL;  sljit_ub *update_table = NULL;
3532  BOOL in_range;  BOOL in_range;
3533    
# Line 3459  for (i = 0; i < MAX_N_CHARS; i++) Line 3538  for (i = 0; i < MAX_N_CHARS; i++)
3538    {    {
3539    chars[i << 1] = NOTACHAR;    chars[i << 1] = NOTACHAR;
3540    chars[(i << 1) + 1] = 0;    chars[(i << 1) + 1] = 0;
3541      bytes[i * MAX_N_BYTES] = 0;
3542    }    }
3543    
3544  max = scan_prefix(common, common->start, chars, MAX_N_CHARS);  max = scan_prefix(common, common->start, chars, bytes, MAX_N_CHARS);
3545    
3546  if (max <= 1)  if (max <= 1)
3547    return FALSE;    return FALSE;
# Line 3481  for (i = 0; i < max; i++) Line 3561  for (i = 0; i < max; i++)
3561  in_range = FALSE;  in_range = FALSE;
3562  for (i = 0; i <= max; i++)  for (i = 0; i <= max; i++)
3563    {    {
3564    if (i < max && ones[i] <= 1)    if (in_range && (i - from) > range_len && (bytes[(i - 1) * MAX_N_BYTES] <= 4))
3565        {
3566        range_len = i - from;
3567        range_right = i - 1;
3568        }
3569    
3570      if (i < max && bytes[i * MAX_N_BYTES] < 255)
3571      {      {
3572      if (!in_range)      if (!in_range)
3573        {        {
# Line 3490  for (i = 0; i <= max; i++) Line 3576  for (i = 0; i <= max; i++)
3576        }        }
3577      }      }
3578    else if (in_range)    else if (in_range)
     {  
     if (range_len == -1 || (i - from) > range_len)  
       {  
       range_len = i - from;  
       range_right = i - 1;  
       }  
3579      in_range = FALSE;      in_range = FALSE;
     }  
3580    }    }
3581    
3582  if (range_len >= MIN_RANGE_SIZE)  if (range_right >= 0)
3583    {    {
3584    /* Since no data is consumed (see the assert in the beginning    /* Since no data is consumed (see the assert in the beginning
3585    of this function), this space can be reallocated. */    of this function), this space can be reallocated. */
# Line 3518  if (range_len >= MIN_RANGE_SIZE) Line 3597  if (range_len >= MIN_RANGE_SIZE)
3597    
3598    for (i = 0; i < range_len; i++)    for (i = 0; i < range_len; i++)
3599      {      {
3600      byte = chars[(range_right - i) << 1] & 0xff;      byte_set = bytes + ((range_right - i) * MAX_N_BYTES);
3601      if (update_table[byte] > IN_UCHARS(i))      SLJIT_ASSERT(byte_set[0] > 0 && byte_set[0] < 255);
3602        update_table[byte] = IN_UCHARS(i);      byte_set_end = byte_set + byte_set[0];
3603      mask = chars[((range_right - i) << 1) + 1] & 0xff;      byte_set++;
3604      if (mask != 0)      while (byte_set <= byte_set_end)
3605        {        {
3606        byte ^= mask;        if (update_table[*byte_set] > IN_UCHARS(i))
3607        if (update_table[byte] > IN_UCHARS(i))          update_table[*byte_set] = IN_UCHARS(i);
3608          update_table[byte] = IN_UCHARS(i);        byte_set++;
3609        }        }
3610      }      }
3611    }    }
# Line 3539  for (i = 0; i < max; i++) Line 3618  for (i = 0; i < max; i++)
3618      break;      break;
3619    }    }
3620    
3621  if (offsets[0] == -1)  if (offsets[0] < 0 && range_right < 0)
   return FALSE;  
   
 /* Scan backward. */  
 offsets[1] = -1;  
 for (i = max - 1; i > offsets[0]; i--)  
   if (ones[i] <= 2 && i != range_right)  
     {  
     offsets[1] = i;  
     break;  
     }  
   
 /* This case is handled better by fast_forward_first_char. */  
 if (offsets[1] == -1 && offsets[0] == 0)  
3622    return FALSE;    return FALSE;
3623    
3624  offsets[2] = -1;  if (offsets[0] >= 0)
 if (offsets[1] >= 0 && range_right == -1)  
3625    {    {
3626    /* Scan from middle. */    /* Scan backward. */
3627    for (i = (offsets[0] + offsets[1]) / 2 + 1; i < offsets[1]; i++)    offsets[1] = -1;
3628      if (ones[i] <= 2)    for (i = max - 1; i > offsets[0]; i--)
3629        if (ones[i] <= 2 && i != range_right)
3630        {        {
3631        offsets[2] = i;        offsets[1] = i;
3632        break;        break;
3633        }        }
3634    
3635    if (offsets[2] == -1)    /* This case is handled better by fast_forward_first_char. */
3636      if (offsets[1] == -1 && offsets[0] == 0 && range_right < 0)
3637        return FALSE;
3638    
3639      offsets[2] = -1;
3640      /* We only search for a middle character if there is no range check. */
3641      if (offsets[1] >= 0 && range_right == -1)
3642      {      {
3643      for (i = (offsets[0] + offsets[1]) / 2; i > offsets[0]; i--)      /* Scan from middle. */
3644        for (i = (offsets[0] + offsets[1]) / 2 + 1; i < offsets[1]; i++)
3645        if (ones[i] <= 2)        if (ones[i] <= 2)
3646          {          {
3647          offsets[2] = i;          offsets[2] = i;
3648          break;          break;
3649          }          }
3650    
3651        if (offsets[2] == -1)
3652          {
3653          for (i = (offsets[0] + offsets[1]) / 2; i > offsets[0]; i--)
3654            if (ones[i] <= 2)
3655              {
3656              offsets[2] = i;
3657              break;
3658              }
3659          }
3660      }      }
   }  
3661    
3662  SLJIT_ASSERT(offsets[1] == -1 || (offsets[0] < offsets[1]));    SLJIT_ASSERT(offsets[1] == -1 || (offsets[0] < offsets[1]));
3663  SLJIT_ASSERT(offsets[2] == -1 || (offsets[0] < offsets[2] && offsets[1] > offsets[2]));    SLJIT_ASSERT(offsets[2] == -1 || (offsets[0] < offsets[2] && offsets[1] > offsets[2]));
3664    
3665  chars[0] = chars[offsets[0] << 1];    chars[0] = chars[offsets[0] << 1];
3666  chars[1] = chars[(offsets[0] << 1) + 1];    chars[1] = chars[(offsets[0] << 1) + 1];
3667  if (offsets[2] >= 0)    if (offsets[2] >= 0)
3668    {      {
3669    chars[2] = chars[offsets[2] << 1];      chars[2] = chars[offsets[2] << 1];
3670    chars[3] = chars[(offsets[2] << 1) + 1];      chars[3] = chars[(offsets[2] << 1) + 1];
3671    }      }
3672  if (offsets[1] >= 0)    if (offsets[1] >= 0)
3673    {      {
3674    chars[4] = chars[offsets[1] << 1];      chars[4] = chars[offsets[1] << 1];
3675    chars[5] = chars[(offsets[1] << 1) + 1];      chars[5] = chars[(offsets[1] << 1) + 1];
3676        }
3677    }    }
3678    
3679  max -= 1;  max -= 1;
# Line 3608  else Line 3691  else
3691    OP2(SLJIT_SUB, STR_END, 0, STR_END, 0, SLJIT_IMM, IN_UCHARS(max));    OP2(SLJIT_SUB, STR_END, 0, STR_END, 0, SLJIT_IMM, IN_UCHARS(max));
3692    
3693  #if !(defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)  #if !(defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
3694  if (range_len >= MIN_RANGE_SIZE)  if (range_right >= 0)
3695    OP1(SLJIT_MOV, RETURN_ADDR, 0, SLJIT_IMM, (sljit_sw)update_table);    OP1(SLJIT_MOV, RETURN_ADDR, 0, SLJIT_IMM, (sljit_sw)update_table);
3696  #endif  #endif
3697    
3698  start = LABEL();  start = LABEL();
3699  quit = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);  quit = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
3700    
3701  if (range_len >= MIN_RANGE_SIZE)  SLJIT_ASSERT(range_right >= 0 || offsets[0] >= 0);
3702    
3703    if (range_right >= 0)
3704    {    {
3705  #if defined COMPILE_PCRE8 || (defined SLJIT_LITTLE_ENDIAN && SLJIT_LITTLE_ENDIAN)  #if defined COMPILE_PCRE8 || (defined SLJIT_LITTLE_ENDIAN && SLJIT_LITTLE_ENDIAN)
3706    OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(range_right));    OP1(SLJIT_MOV_UB, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(range_right));
# Line 3632  if (range_len >= MIN_RANGE_SIZE) Line 3717  if (range_len >= MIN_RANGE_SIZE)
3717    CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, 0, start);    CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, 0, start);
3718    }    }
3719    
3720  OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(offsets[0]));  if (offsets[0] >= 0)
3721  if (offsets[1] >= 0)    {
3722    OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(offsets[1]));    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(offsets[0]));
3723  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));    if (offsets[1] >= 0)
3724        OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(offsets[1]));
3725      OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
3726    
3727  if (chars[1] != 0)    if (chars[1] != 0)
3728    OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, chars[1]);      OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, chars[1]);
3729  CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[0], start);    CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[0], start);
3730  if (offsets[2] >= 0)    if (offsets[2] >= 0)
3731    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(offsets[2] - 1));      OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(offsets[2] - 1));
3732    
3733  if (offsets[1] >= 0)    if (offsets[1] >= 0)
3734    {      {
3735    if (chars[5] != 0)      if (chars[5] != 0)
3736      OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, chars[5]);        OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, chars[5]);
3737    CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, chars[4], start);      CMPTO(SLJIT_C_NOT_EQUAL, TMP2, 0, SLJIT_IMM, chars[4], start);
3738    }      }
3739    
3740  if (offsets[2] >= 0)    if (offsets[2] >= 0)
3741    {      {
3742    if (chars[3] != 0)      if (chars[3] != 0)
3743      OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, chars[3]);        OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, chars[3]);
3744    CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[2], start);      CMPTO(SLJIT_C_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[2], start);
3745        }
3746      OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
3747    }    }
 OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));  
3748    
3749  JUMPHERE(quit);  JUMPHERE(quit);
3750    
3751  if (firstline)  if (firstline)
3752    {    {
3753    if (range_len >= MIN_RANGE_SIZE)    if (range_right >= 0)
3754      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end);      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), common->first_line_end);
3755    OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);    OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);
3756    if (range_len >= MIN_RANGE_SIZE)    if (range_right >= 0)
3757      {      {
3758      quit = CMP(SLJIT_C_LESS_EQUAL, STR_PTR, 0, TMP1, 0);      quit = CMP(SLJIT_C_LESS_EQUAL, STR_PTR, 0, TMP1, 0);
3759      OP1(SLJIT_MOV, STR_PTR, 0, TMP1, 0);      OP1(SLJIT_MOV, STR_PTR, 0, TMP1, 0);
# Line 3678  return TRUE; Line 3766  return TRUE;
3766  }  }
3767    
3768  #undef MAX_N_CHARS  #undef MAX_N_CHARS
3769  #undef MIN_RANGE_SIZE  #undef MAX_N_BYTES
3770    
3771  static SLJIT_INLINE void fast_forward_first_char(compiler_common *common, pcre_uchar first_char, BOOL caseless, BOOL firstline)  static SLJIT_INLINE void fast_forward_first_char(compiler_common *common, pcre_uchar first_char, BOOL caseless, BOOL firstline)
3772  {  {
# Line 3784  if (common->nltype == NLTYPE_FIXED && co Line 3872  if (common->nltype == NLTYPE_FIXED && co
3872    JUMPHERE(lastchar);    JUMPHERE(lastchar);
3873    
3874    if (firstline)    if (firstline)
3875      OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), POSSESSIVE0);      OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);
3876    return;    return;
3877    }    }
3878    
# Line 3794  firstchar = CMP(SLJIT_C_LESS_EQUAL, STR_ Line 3882  firstchar = CMP(SLJIT_C_LESS_EQUAL, STR_
3882  skip_char_back(common);  skip_char_back(common);
3883    
3884  loop = LABEL();  loop = LABEL();
3885    common->ff_newline_shortcut = loop;
3886    
3887  read_char_range(common, common->nlmin, common->nlmax, TRUE);  read_char_range(common, common->nlmin, common->nlmax, TRUE);
3888  lastchar = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);  lastchar = CMP(SLJIT_C_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
3889  if (common->nltype == NLTYPE_ANY || common->nltype == NLTYPE_ANYCRLF)  if (common->nltype == NLTYPE_ANY || common->nltype == NLTYPE_ANYCRLF)
# Line 10046  OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SL Line 10136  OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SL
10136    
10137  if ((re->options & PCRE_ANCHORED) == 0)  if ((re->options & PCRE_ANCHORED) == 0)
10138    {    {
10139    if ((re->options & PCRE_FIRSTLINE) == 0)    if (common->ff_newline_shortcut != NULL)
10140      CMPTO(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0, mainloop_label);      {
10141        if ((re->options & PCRE_FIRSTLINE) == 0)
10142          CMPTO(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0, common->ff_newline_shortcut);
10143        /* There cannot be more newlines here. */
10144        }
10145    else    else
10146      CMPTO(SLJIT_C_LESS, STR_PTR, 0, TMP1, 0, mainloop_label);      {
10147        if ((re->options & PCRE_FIRSTLINE) == 0)
10148          CMPTO(SLJIT_C_LESS, STR_PTR, 0, STR_END, 0, mainloop_label);
10149        else
10150          CMPTO(SLJIT_C_LESS, STR_PTR, 0, TMP1, 0, mainloop_label);
10151        }
10152    }    }
10153    
10154  /* No more remaining characters. */  /* No more remaining characters. */

Legend:
Removed from v.1440  
changed lines
  Added in v.1452

  ViewVC Help
Powered by ViewVC 1.1.5