1 //
2 // regexst.h
3 //
4 // Copyright (C) 2004-2007, International Business Machines Corporation and others.
5 // All Rights Reserved.
6 //
7 // This file contains class RegexStaticSets
8 //
9 // This class is internal to the regular expression implementation.
10 // For the public Regular Expression API, see the file "unicode/regex.h"
11 //
12 // RegexStaticSets groups together the common UnicodeSets that are needed
13 // for compiling or executing RegularExpressions. This grouping simplifies
14 // the thread safe lazy creation and sharing of these sets across
15 // all instances of regular expressions.
16 //
17 #include "unicode/utypes.h"
18
19 #if !UCONFIG_NO_REGULAR_EXPRESSIONS
20
21 #include "unicode/unistr.h"
22 #include "unicode/uniset.h"
23 #include "unicode/uchar.h"
24 #include "unicode/regex.h"
25 #include "uprops.h"
26 #include "cmemory.h"
27 #include "cstring.h"
28 #include "uassert.h"
29 #include "ucln_in.h"
30 #include "umutex.h"
31
32 #include "regexcst.h" // Contains state table for the regex pattern parser.
33 // generated by a Perl script.
34 #include "regexst.h"
35
36
37
38 U_NAMESPACE_BEGIN
39
40
41 //------------------------------------------------------------------------------
42 //
43 // Unicode Set pattern strings for all of the required constant sets.
44 // Initialized with hex values for portability to EBCDIC based machines.
45 // Really ugly, but there's no good way to avoid it.
46 //
47 //------------------------------------------------------------------------------
48
49 // "Rule Char" Characters are those with no special meaning, and therefore do not
50 // need to be escaped to appear as literals in a regexp. Expressed
51 // as the inverse of those needing escaping -- [^\*\?\+\[\(\)\{\}\^\$\|\\\.]
52 static const UChar gRuleSet_rule_char_pattern[] = {
53 // [ ^ \ * \ ? \ + \ [ \ ( / )
54 0x5b, 0x5e, 0x5c, 0x2a, 0x5c, 0x3f, 0x5c, 0x2b, 0x5c, 0x5b, 0x5c, 0x28, 0x5c, 0x29,
55 // \ { \ } \ ^ \ $ \ | \ \ \ . ]
56 0x5c, 0x7b,0x5c, 0x7d, 0x5c, 0x5e, 0x5c, 0x24, 0x5c, 0x7c, 0x5c, 0x5c, 0x5c, 0x2e, 0x5d, 0};
57
58
59 static const UChar gRuleSet_digit_char_pattern[] = {
60 // [ 0 - 9 ]
61 0x5b, 0x30, 0x2d, 0x39, 0x5d, 0};
62
63 //
64 // Here are the backslash escape characters that ICU's unescape() function
65 // will handle.
66 //
67 static const UChar gUnescapeCharPattern[] = {
68 // [ a c e f n r t u U x ]
69 0x5b, 0x61, 0x63, 0x65, 0x66, 0x6e, 0x72, 0x74, 0x75, 0x55, 0x78, 0x5d, 0};
70
71
72 //
73 // Unicode Set Definitions for Regular Expression \w
74 //
75 static const UChar gIsWordPattern[] = {
76 // [ \ p { A l p h a b e t i c }
77 0x5b, 0x5c, 0x70, 0x7b, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x62, 0x65, 0x74, 0x69, 0x63, 0x7d,
78 // \ p { M } Mark
79 0x5c, 0x70, 0x7b, 0x4d, 0x7d,
80 // \ p { N d } Digit_Numeric
81 0x5c, 0x70, 0x7b, 0x4e, 0x64, 0x7d,
82 // \ p { P c } ] Connector_Punctuation
83 0x5c, 0x70, 0x7b, 0x50, 0x63, 0x7d, 0x5d, 0};
84
85
86 //
87 // Unicode Set Definitions for Regular Expression \s
88 //
89 static const UChar gIsSpacePattern[] = {
90 // [ \ p { W h i t e S p a c e } ]
91 0x5b, 0x5c, 0x70, 0x7b, 0x57, 0x68, 0x69, 0x74, 0x65, 0x53, 0x70, 0x61, 0x63, 0x65, 0x7d, 0x5d, 0};
92
93
94 //
95 // UnicodeSets used in implementation of Grapheme Cluster detection, \X
96 //
97 static const UChar gGC_ControlPattern[] = {
98 // [ [ : Z l : ] [ : Z p : ]
99 0x5b, 0x5b, 0x3a, 0x5A, 0x6c, 0x3a, 0x5d, 0x5b, 0x3a, 0x5A, 0x70, 0x3a, 0x5d,
100 // [ : C c : ] [ : C f : ] -
101 0x5b, 0x3a, 0x43, 0x63, 0x3a, 0x5d, 0x5b, 0x3a, 0x43, 0x66, 0x3a, 0x5d, 0x2d,
102 // [ : G r a p h e m e _
103 0x5b, 0x3a, 0x47, 0x72, 0x61, 0x70, 0x68, 0x65, 0x6d, 0x65, 0x5f,
104 // E x t e n d : ] ]
105 0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x3a, 0x5d, 0x5d, 0};
106
107 static const UChar gGC_ExtendPattern[] = {
108 // [ \ p { G r a p h e m e _
109 0x5b, 0x5c, 0x70, 0x7b, 0x47, 0x72, 0x61, 0x70, 0x68, 0x65, 0x6d, 0x65, 0x5f,
110 // E x t e n d } ]
111 0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x7d, 0x5d, 0};
112
113 static const UChar gGC_LPattern[] = {
114 // [ \ p { H a n g u l _ S y l
115 0x5b, 0x5c, 0x70, 0x7b, 0x48, 0x61, 0x6e, 0x67, 0x75, 0x6c, 0x5f, 0x53, 0x79, 0x6c,
116 // l a b l e _ T y p e = L } ]
117 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x54, 0x79, 0x70, 0x65, 0x3d, 0x4c, 0x7d, 0x5d, 0};
118
119 static const UChar gGC_VPattern[] = {
120 // [ \ p { H a n g u l _ S y l
121 0x5b, 0x5c, 0x70, 0x7b, 0x48, 0x61, 0x6e, 0x67, 0x75, 0x6c, 0x5f, 0x53, 0x79, 0x6c,
122 // l a b l e _ T y p e = V } ]
123 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x54, 0x79, 0x70, 0x65, 0x3d, 0x56, 0x7d, 0x5d, 0};
124
125 static const UChar gGC_TPattern[] = {
126 // [ \ p { H a n g u l _ S y l
127 0x5b, 0x5c, 0x70, 0x7b, 0x48, 0x61, 0x6e, 0x67, 0x75, 0x6c, 0x5f, 0x53, 0x79, 0x6c,
128 // l a b l e _ T y p e = T } ]
129 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x54, 0x79, 0x70, 0x65, 0x3d, 0x54, 0x7d, 0x5d, 0};
130
131 static const UChar gGC_LVPattern[] = {
132 // [ \ p { H a n g u l _ S y l
133 0x5b, 0x5c, 0x70, 0x7b, 0x48, 0x61, 0x6e, 0x67, 0x75, 0x6c, 0x5f, 0x53, 0x79, 0x6c,
134 // l a b l e _ T y p e = L V } ]
135 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x54, 0x79, 0x70, 0x65, 0x3d, 0x4c, 0x56, 0x7d, 0x5d, 0};
136
137 static const UChar gGC_LVTPattern[] = {
138 // [ \ p { H a n g u l _ S y l
139 0x5b, 0x5c, 0x70, 0x7b, 0x48, 0x61, 0x6e, 0x67, 0x75, 0x6c, 0x5f, 0x53, 0x79, 0x6c,
140 // l a b l e _ T y p e = L V T } ]
141 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x54, 0x79, 0x70, 0x65, 0x3d, 0x4c, 0x56, 0x54, 0x7d, 0x5d, 0};
142
143
144 RegexStaticSets *RegexStaticSets::gStaticSets = NULL;
145
RegexStaticSets(UErrorCode * status)146 RegexStaticSets::RegexStaticSets(UErrorCode *status)
147 :
148 fUnescapeCharSet(UnicodeString(TRUE, gUnescapeCharPattern, -1), *status),
149 fRuleDigitsAlias(NULL)
150 {
151 // First zero out everything
152 int i;
153 for (i=0; i<URX_LAST_SET; i++) {
154 fPropSets[i] = NULL;
155 }
156 for (i=0; i<(int32_t)(sizeof(fRuleSets)/sizeof(fRuleSets[0])); i++) {
157 fRuleSets[i] = NULL;
158 }
159
160 // Then init the sets to their correct values.
161 fPropSets[URX_ISWORD_SET] = new UnicodeSet(UnicodeString(TRUE, gIsWordPattern, -1), *status);
162 fPropSets[URX_ISSPACE_SET] = new UnicodeSet(UnicodeString(TRUE, gIsSpacePattern, -1), *status);
163 fPropSets[URX_GC_EXTEND] = new UnicodeSet(UnicodeString(TRUE, gGC_ExtendPattern, -1), *status);
164 fPropSets[URX_GC_CONTROL] = new UnicodeSet(UnicodeString(TRUE, gGC_ControlPattern, -1), *status);
165 fPropSets[URX_GC_L] = new UnicodeSet(UnicodeString(TRUE, gGC_LPattern, -1), *status);
166 fPropSets[URX_GC_V] = new UnicodeSet(UnicodeString(TRUE, gGC_VPattern, -1), *status);
167 fPropSets[URX_GC_T] = new UnicodeSet(UnicodeString(TRUE, gGC_TPattern, -1), *status);
168 fPropSets[URX_GC_LV] = new UnicodeSet(UnicodeString(TRUE, gGC_LVPattern, -1), *status);
169 fPropSets[URX_GC_LVT] = new UnicodeSet(UnicodeString(TRUE, gGC_LVTPattern, -1), *status);
170 if (U_FAILURE(*status)) {
171 // Bail out if we were unable to create the above sets.
172 // The rest of the initialization needs them, so we cannot proceed.
173 return;
174 }
175
176
177 //
178 // The following sets are dynamically constructed, because their
179 // initialization strings would be unreasonable.
180 //
181
182
183 //
184 // "Normal" is the set of characters that don't need special handling
185 // when finding grapheme cluster boundaries.
186 //
187 fPropSets[URX_GC_NORMAL] = new UnicodeSet(0, UnicodeSet::MAX_VALUE);
188 fPropSets[URX_GC_NORMAL]->remove(0xac00, 0xd7a4);
189 fPropSets[URX_GC_NORMAL]->removeAll(*fPropSets[URX_GC_CONTROL]);
190 fPropSets[URX_GC_NORMAL]->removeAll(*fPropSets[URX_GC_L]);
191 fPropSets[URX_GC_NORMAL]->removeAll(*fPropSets[URX_GC_V]);
192 fPropSets[URX_GC_NORMAL]->removeAll(*fPropSets[URX_GC_T]);
193
194 // Initialize the 8-bit fast bit sets from the parallel full
195 // UnicodeSets.
196 for (i=0; i<URX_LAST_SET; i++) {
197 if (fPropSets[i]) {
198 fPropSets[i]->compact();
199 fPropSets8[i].init(fPropSets[i]);
200 }
201 }
202
203 // Sets used while parsing rules, but not referenced from the parse state table
204 fRuleSets[kRuleSet_rule_char-128] = new UnicodeSet(UnicodeString(TRUE, gRuleSet_rule_char_pattern, -1), *status);
205 fRuleSets[kRuleSet_digit_char-128] = new UnicodeSet(UnicodeString(TRUE, gRuleSet_digit_char_pattern, -1), *status);
206 fRuleDigitsAlias = fRuleSets[kRuleSet_digit_char-128];
207 for (i=0; i<(int32_t)(sizeof(fRuleSets)/sizeof(fRuleSets[0])); i++) {
208 if (fRuleSets[i]) {
209 fRuleSets[i]->compact();
210 }
211 }
212 }
213
214
~RegexStaticSets()215 RegexStaticSets::~RegexStaticSets() {
216 int32_t i;
217
218 for (i=0; i<URX_LAST_SET; i++) {
219 delete fPropSets[i];
220 fPropSets[i] = NULL;
221 }
222 for (i=0; i<(int32_t)(sizeof(fRuleSets)/sizeof(fRuleSets[0])); i++) {
223 delete fRuleSets[i];
224 fRuleSets[i] = NULL;
225 }
226 fRuleDigitsAlias = NULL;
227 }
228
229
230 //------------------------------------------------------------------------------
231 //
232 // regex_cleanup Memory cleanup function, free/delete all
233 // cached memory. Called by ICU's u_cleanup() function.
234 //
235 //------------------------------------------------------------------------------
236 UBool
cleanup(void)237 RegexStaticSets::cleanup(void) {
238 delete RegexStaticSets::gStaticSets;
239 RegexStaticSets::gStaticSets = NULL;
240 return TRUE;
241 }
242
243 U_CDECL_BEGIN
244 static UBool U_CALLCONV
regex_cleanup(void)245 regex_cleanup(void) {
246 return RegexStaticSets::cleanup();
247 }
248 U_CDECL_END
249
initGlobals(UErrorCode * status)250 void RegexStaticSets::initGlobals(UErrorCode *status) {
251 RegexStaticSets *p;
252 UMTX_CHECK(NULL, gStaticSets, p);
253 if (p == NULL) {
254 p = new RegexStaticSets(status);
255 if (U_FAILURE(*status)) {
256 delete p;
257 return;
258 }
259 umtx_lock(NULL);
260 if (gStaticSets == NULL) {
261 gStaticSets = p;
262 p = NULL;
263 }
264 umtx_unlock(NULL);
265 if (p) {
266 delete p;
267 }
268 ucln_i18n_registerCleanup(UCLN_I18N_REGEX, regex_cleanup);
269 }
270 }
271
272
273 U_NAMESPACE_END
274 #endif // !UCONFIG_NO_REGULAR_EXPRESSIONS
275