code/trunk/pcre_xclass.c

/*************************************************
*      Perl-Compatible Regular Expressions       *
*************************************************/

/* PCRE is a library of functions to support regular expressions whose syntax
and semantics are as close as possible to those of the Perl 5 language.

                       Written by Philip Hazel
           Copyright (c) 1997-2012 University of Cambridge

-----------------------------------------------------------------------------
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

    * Neither the name of the University of Cambridge nor the names of its
      contributors may be used to endorse or promote products derived from
      this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
-----------------------------------------------------------------------------
*/


/* This module contains an internal function that is used to match an extended
class. It is used by both pcre_exec() and pcre_def_exec(). */


#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "pcre_internal.h"


/*************************************************
*       Match character against an XCLASS        *
*************************************************/

/* This function is called to match a character against an extended class that
might contain values > 255 and/or Unicode properties.

Arguments:
  c           the character
  data        points to the flag byte of the XCLASS data

Returns:      TRUE if character matches, else FALSE
*/

BOOL
PRIV(xclass)(int c, const pcre_uchar *data, BOOL utf)
{
int t;
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
not, we still carry on, because there may be ranges that start below 256 in the
additional data. */

if (c < 256)
  {
  if ((*data & XCL_MAP) != 0 &&
    (((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
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. */

if ((*data++ & XCL_MAP) != 0) data += 32 / sizeof(pcre_uchar);

while ((t = *data++) != XCL_END)
  {
  int x, y;
  if (t == XCL_SINGLE)
    {
#ifdef SUPPORT_UTF
    if (utf)
      {
      GETCHARINC(x, data); /* macro generates multiple statements */
      }
    else
#endif
      x = *data++;
    if (c == x) return !negated;
    }
  else if (t == XCL_RANGE)
    {
#ifdef SUPPORT_UTF
    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;
    }

#ifdef SUPPORT_UCP
  else  /* XCL_PROP & XCL_NOTPROP */
    {
    const ucd_record *prop = GET_UCD(c);

    switch(*data)
      {
      case PT_ANY:
      if (t == XCL_PROP) return !negated;
      break;

      case PT_LAMP:
      if ((prop->chartype == ucp_Lu || prop->chartype == ucp_Ll ||
           prop->chartype == ucp_Lt) == (t == XCL_PROP)) return !negated;
      break;

      case PT_GC:
      if ((data[1] == PRIV(ucp_gentype)[prop->chartype]) == (t == XCL_PROP))
        return !negated;
      break;

      case PT_PC:
      if ((data[1] == prop->chartype) == (t == XCL_PROP)) return !negated;
      break;

      case PT_SC:
      if ((data[1] == prop->script) == (t == XCL_PROP)) return !negated;
      break;

      case PT_ALNUM:
      if ((PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
           PRIV(ucp_gentype)[prop->chartype] == ucp_N) == (t == XCL_PROP))
        return !negated;
      break;

      case PT_SPACE:    /* Perl space */
      if ((PRIV(ucp_gentype)[prop->chartype] == ucp_Z ||
           c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR)
             == (t == XCL_PROP))
        return !negated;
      break;

      case PT_PXSPACE:  /* POSIX space */
      if ((PRIV(ucp_gentype)[prop->chartype] == ucp_Z ||
           c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
           c == CHAR_FF || c == CHAR_CR) == (t == XCL_PROP))
        return !negated;
      break;

      case PT_WORD:
      if ((PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
           PRIV(ucp_gentype)[prop->chartype] == ucp_N || c == CHAR_UNDERSCORE)
             == (t == XCL_PROP))
        return !negated;
      break;

      /* This should never occur, but compilers may mutter if there is no
      default. */

      default:
      return FALSE;
      }

    data += 2;
    }
#endif  /* SUPPORT_UCP */
  }

return negated;   /* char did not match */
}

/* End of pcre_xclass.c */
1	nigel	77	/*************************************************
2			* Perl-Compatible Regular Expressions *
3			*************************************************/
4
5			/* PCRE is a library of functions to support regular expressions whose syntax
6			and semantics are as close as possible to those of the Perl 5 language.
7
8			Written by Philip Hazel
9	ph10	836	Copyright (c) 1997-2012 University of Cambridge
10	nigel	77
11			-----------------------------------------------------------------------------
12			Redistribution and use in source and binary forms, with or without
13			modification, are permitted provided that the following conditions are met:
14
15			* Redistributions of source code must retain the above copyright notice,
16			this list of conditions and the following disclaimer.
17
18			* Redistributions in binary form must reproduce the above copyright
19			notice, this list of conditions and the following disclaimer in the
20			documentation and/or other materials provided with the distribution.
21
22			* Neither the name of the University of Cambridge nor the names of its
23			contributors may be used to endorse or promote products derived from
24			this software without specific prior written permission.
25
26			THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
27			AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28			IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29			ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
30			LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
31			CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
32			SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
33			INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
34			CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
35			ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36			POSSIBILITY OF SUCH DAMAGE.
37			-----------------------------------------------------------------------------
38			*/
39
40
41			/* This module contains an internal function that is used to match an extended
42	ph10	384	class. It is used by both pcre_exec() and pcre_def_exec(). */
43	nigel	77
44
45	ph10	200	#ifdef HAVE_CONFIG_H
46	ph10	236	#include "config.h"
47	ph10	200	#endif
48	ph10	199
49	nigel	77	#include "pcre_internal.h"
50
51
52			/*************************************************
53			* Match character against an XCLASS *
54			*************************************************/
55
56			/* This function is called to match a character against an extended class that
57	ph10	384	might contain values > 255 and/or Unicode properties.
58	nigel	77
59			Arguments:
60			c the character
61			data points to the flag byte of the XCLASS data
62
63			Returns: TRUE if character matches, else FALSE
64			*/
65
66	nigel	87	BOOL
67	ph10	836	PRIV(xclass)(int c, const pcre_uchar *data, BOOL utf)
68	nigel	77	{
69			int t;
70			BOOL negated = (*data & XCL_NOT) != 0;
71
72	ph10	836	(void)utf;
73			#ifdef COMPILE_PCRE8
74			/* In 8 bit mode, this must always be TRUE. Help the compiler to know that. */
75			utf = TRUE;
76			#endif
77
78	nigel	77	/* Character values < 256 are matched against a bitmap, if one is present. If
79			not, we still carry on, because there may be ranges that start below 256 in the
80			additional data. */
81
82			if (c < 256)
83			{
84	ph10	836	if ((*data & XCL_MAP) != 0 &&
85			(((pcre_uint8 *)(data + 1))[c/8] & (1 << (c&7))) != 0)
86			return !negated; /* char found */
87	nigel	77	}
88
89			/* First skip the bit map if present. Then match against the list of Unicode
90			properties or large chars or ranges that end with a large char. We won't ever
91			encounter XCL_PROP or XCL_NOTPROP when UCP support is not compiled. */
92
93	ph10	836	if ((*data++ & XCL_MAP) != 0) data += 32 / sizeof(pcre_uchar);
94	nigel	77
95			while ((t = *data++) != XCL_END)
96			{
97			int x, y;
98			if (t == XCL_SINGLE)
99			{
100	ph10	836	#ifdef SUPPORT_UTF
101			if (utf)
102			{
103			GETCHARINC(x, data); /* macro generates multiple statements */
104			}
105			else
106			#endif
107			x = *data++;
108	nigel	77	if (c == x) return !negated;
109			}
110			else if (t == XCL_RANGE)
111			{
112	ph10	836	#ifdef SUPPORT_UTF
113			if (utf)
114			{
115			GETCHARINC(x, data); /* macro generates multiple statements */
116			GETCHARINC(y, data); /* macro generates multiple statements */
117			}
118			else
119			#endif
120			{
121			x = *data++;
122			y = *data++;
123			}
124	nigel	77	if (c >= x && c <= y) return !negated;
125			}
126
127			#ifdef SUPPORT_UCP
128			else /* XCL_PROP & XCL_NOTPROP */
129			{
130	ph10	384	const ucd_record *prop = GET_UCD(c);
131	nigel	87
132			switch(*data)
133	nigel	77	{
134	nigel	87	case PT_ANY:
135			if (t == XCL_PROP) return !negated;
136			break;
137
138			case PT_LAMP:
139	ph10	535	if ((prop->chartype == ucp_Lu \|\| prop->chartype == ucp_Ll \|\|
140	ph10	517	prop->chartype == ucp_Lt) == (t == XCL_PROP)) return !negated;
141	nigel	87	break;
142
143			case PT_GC:
144	ph10	836	if ((data[1] == PRIV(ucp_gentype)[prop->chartype]) == (t == XCL_PROP))
145	ph10	517	return !negated;
146	nigel	87	break;
147
148			case PT_PC:
149	ph10	349	if ((data[1] == prop->chartype) == (t == XCL_PROP)) return !negated;
150	nigel	87	break;
151
152			case PT_SC:
153	ph10	349	if ((data[1] == prop->script) == (t == XCL_PROP)) return !negated;
154	nigel	87	break;
155	ph10	535
156	ph10	517	case PT_ALNUM:
157	ph10	836	if ((PRIV(ucp_gentype)[prop->chartype] == ucp_L \|\|
158			PRIV(ucp_gentype)[prop->chartype] == ucp_N) == (t == XCL_PROP))
159	ph10	517	return !negated;
160	ph10	535	break;
161
162	ph10	517	case PT_SPACE: /* Perl space */
163	ph10	836	if ((PRIV(ucp_gentype)[prop->chartype] == ucp_Z \|\|
164	ph10	535	c == CHAR_HT \|\| c == CHAR_NL \|\| c == CHAR_FF \|\| c == CHAR_CR)
165	ph10	517	== (t == XCL_PROP))
166			return !negated;
167	ph10	535	break;
168	nigel	87
169	ph10	517	case PT_PXSPACE: /* POSIX space */
170	ph10	836	if ((PRIV(ucp_gentype)[prop->chartype] == ucp_Z \|\|
171	ph10	517	c == CHAR_HT \|\| c == CHAR_NL \|\| c == CHAR_VT \|\|
172			c == CHAR_FF \|\| c == CHAR_CR) == (t == XCL_PROP))
173			return !negated;
174	ph10	535	break;
175	ph10	517
176	ph10	535	case PT_WORD:
177	ph10	836	if ((PRIV(ucp_gentype)[prop->chartype] == ucp_L \|\|
178			PRIV(ucp_gentype)[prop->chartype] == ucp_N \|\| c == CHAR_UNDERSCORE)
179	ph10	517	== (t == XCL_PROP))
180			return !negated;
181	ph10	535	break;
182	ph10	517
183	nigel	87	/* This should never occur, but compilers may mutter if there is no
184			default. */
185
186			default:
187			return FALSE;
188	nigel	77	}
189	nigel	87
190			data += 2;
191	nigel	77	}
192			#endif /* SUPPORT_UCP */
193			}
194
195			return negated; /* char did not match */
196			}
197
198			/* End of pcre_xclass.c */
Name	Value
svn:eol-style	native
svn:keywords	"Author Date Id Revision Url"