[BACK]Return to pcre_xclass.c CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / pcre

Diff for /embedaddon/pcre/pcre_xclass.c between versions 1.1.1.1 and 1.1.1.3

version 1.1.1.1, 2012/02/21 23:05:51 version 1.1.1.3, 2013/07/22 08:25:55
Line 6 Line 6
 and semantics are as close as possible to those of the Perl 5 language.  and semantics are as close as possible to those of the Perl 5 language.
   
                        Written by Philip Hazel                         Written by Philip Hazel
           Copyright (c) 1997-2010 University of Cambridge           Copyright (c) 1997-2013 University of Cambridge
   
 -----------------------------------------------------------------------------  -----------------------------------------------------------------------------
 Redistribution and use in source and binary forms, with or without  Redistribution and use in source and binary forms, with or without
Line 64  Returns:      TRUE if character matches, else FALSE Line 64  Returns:      TRUE if character matches, else FALSE
 */  */
   
 BOOL  BOOL
_pcre_xclass(int c, const uschar *data)PRIV(xclass)(pcre_uint32 c, const pcre_uchar *data, BOOL utf)
 {  {
int t;pcre_uchar t;
 BOOL negated = (*data & XCL_NOT) != 0;  BOOL negated = (*data & XCL_NOT) != 0;
   
   (void)utf;
   #ifdef COMPILE_PCRE8
   /* In 8 bit mode, this must always be TRUE. Help the compiler to know that. */
   utf = TRUE;
   #endif
   
 /* Character values < 256 are matched against a bitmap, if one is present. If  /* Character values < 256 are matched against a bitmap, if one is present. If
 not, we still carry on, because there may be ranges that start below 256 in the  not, we still carry on, because there may be ranges that start below 256 in the
 additional data. */  additional data. */
   
 if (c < 256)  if (c < 256)
   {    {
  if ((*data & XCL_MAP) != 0 && (data[1 + c/8] & (1 << (c&7))) != 0)  if ((*data & XCL_MAP) != 0 &&
    return !negated;   /* char found */    (((pcre_uint8 *)(data + 1))[c/8] & (1 << (c&7))) != 0)
     return !negated; /* char found */
   }    }
   
 /* First skip the bit map if present. Then match against the list of Unicode  /* First skip the bit map if present. Then match against the list of Unicode
 properties or large chars or ranges that end with a large char. We won't ever  properties or large chars or ranges that end with a large char. We won't ever
 encounter XCL_PROP or XCL_NOTPROP when UCP support is not compiled. */  encounter XCL_PROP or XCL_NOTPROP when UCP support is not compiled. */
   
if ((*data++ & XCL_MAP) != 0) data += 32;if ((*data++ & XCL_MAP) != 0) data += 32 / sizeof(pcre_uchar);
   
 while ((t = *data++) != XCL_END)  while ((t = *data++) != XCL_END)
   {    {
  int x, y;  pcre_uint32 x, y;
   if (t == XCL_SINGLE)    if (t == XCL_SINGLE)
     {      {
    GETCHARINC(x, data);#ifdef SUPPORT_UTF
     if (utf)
       {
       GETCHARINC(x, data); /* macro generates multiple statements */
       }
     else
 #endif
       x = *data++;
     if (c == x) return !negated;      if (c == x) return !negated;
     }      }
   else if (t == XCL_RANGE)    else if (t == XCL_RANGE)
     {      {
    GETCHARINC(x, data);#ifdef SUPPORT_UTF
    GETCHARINC(y, data);    if (utf)
       {
       GETCHARINC(x, data); /* macro generates multiple statements */
       GETCHARINC(y, data); /* macro generates multiple statements */
       }
     else
 #endif
       {
       x = *data++;
       y = *data++;
       }
     if (c >= x && c <= y) return !negated;      if (c >= x && c <= y) return !negated;
     }      }
   
Line 117  while ((t = *data++) != XCL_END) Line 141  while ((t = *data++) != XCL_END)
       break;        break;
   
       case PT_GC:        case PT_GC:
      if ((data[1] == _pcre_ucp_gentype[prop->chartype]) == (t == XCL_PROP))      if ((data[1] == PRIV(ucp_gentype)[prop->chartype]) == (t == XCL_PROP))
         return !negated;          return !negated;
       break;        break;
   
Line 130  while ((t = *data++) != XCL_END) Line 154  while ((t = *data++) != XCL_END)
       break;        break;
   
       case PT_ALNUM:        case PT_ALNUM:
      if ((_pcre_ucp_gentype[prop->chartype] == ucp_L ||      if ((PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
           _pcre_ucp_gentype[prop->chartype] == ucp_N) == (t == XCL_PROP))           PRIV(ucp_gentype)[prop->chartype] == ucp_N) == (t == XCL_PROP))
         return !negated;          return !negated;
       break;        break;
   
       case PT_SPACE:    /* Perl space */        case PT_SPACE:    /* Perl space */
      if ((_pcre_ucp_gentype[prop->chartype] == ucp_Z ||      if ((PRIV(ucp_gentype)[prop->chartype] == ucp_Z ||
            c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR)             c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR)
              == (t == XCL_PROP))               == (t == XCL_PROP))
         return !negated;          return !negated;
       break;        break;
   
       case PT_PXSPACE:  /* POSIX space */        case PT_PXSPACE:  /* POSIX space */
      if ((_pcre_ucp_gentype[prop->chartype] == ucp_Z ||      if ((PRIV(ucp_gentype)[prop->chartype] == ucp_Z ||
            c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||             c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
            c == CHAR_FF || c == CHAR_CR) == (t == XCL_PROP))             c == CHAR_FF || c == CHAR_CR) == (t == XCL_PROP))
         return !negated;          return !negated;
       break;        break;
   
       case PT_WORD:        case PT_WORD:
      if ((_pcre_ucp_gentype[prop->chartype] == ucp_L ||      if ((PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
           _pcre_ucp_gentype[prop->chartype] == ucp_N || c == CHAR_UNDERSCORE)           PRIV(ucp_gentype)[prop->chartype] == ucp_N || c == CHAR_UNDERSCORE)
              == (t == XCL_PROP))               == (t == XCL_PROP))
         return !negated;          return !negated;
         break;
   
         case PT_UCNC:
         if (c < 0xa0)
           {
           if ((c == CHAR_DOLLAR_SIGN || c == CHAR_COMMERCIAL_AT ||
                c == CHAR_GRAVE_ACCENT) == (t == XCL_PROP))
             return !negated;
           }
         else
           {
           if ((c < 0xd800 || c > 0xdfff) == (t == XCL_PROP))
             return !negated;
           }
       break;        break;
   
       /* This should never occur, but compilers may mutter if there is no        /* This should never occur, but compilers may mutter if there is no
Removed from v.1.1.1.1  
changed lines
  Added in v.1.1.1.3

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>