]>
Commit | Line | Data |
---|---|---|
1 | enum { | |
2 | _NL_COLLATE_NRULES = ((( | |
3 | 3) << 16) | (0)), | |
4 | _NL_COLLATE_TABLEMB, | |
5 | _NL_CTYPE_TOLOWER, | |
6 | _NL_CTYPE_CODESET_NAME, | |
7 | _NL_CTYPE_MAP_TO_NONASCII, | |
8 | }; | |
9 | struct locale_data { | |
10 | unsigned int nstrings; | |
11 | union locale_data_value { | |
12 | const char *string; | |
13 | unsigned int word; | |
14 | } | |
15 | values []; | |
16 | }; | |
17 | extern __thread struct locale_data *const *_nl_current_LC_COLLATE __attribute__ ((tls_model ("initial-exec"))); | |
18 | extern __thread struct locale_data *const *_nl_current_LC_CTYPE __attribute__ ((tls_model ("initial-exec"))); | |
19 | typedef unsigned long int reg_syntax_t; | |
20 | extern reg_syntax_t re_syntax_options; | |
21 | typedef enum { | |
22 | REG_ENOSYS = -1, REG_NOERROR = 0, REG_NOMATCH, REG_BADPAT, REG_ECOLLATE, REG_ECTYPE, REG_EESCAPE, REG_ESUBREG, REG_EBRACK, REG_EPAREN, REG_EBRACE, REG_BADBR, REG_ERANGE, REG_ESPACE, REG_BADRPT, REG_EEND, REG_ESIZE, REG_ERPAREN } | |
23 | reg_errcode_t; | |
24 | struct re_pattern_buffer { | |
25 | unsigned char *buffer; | |
26 | reg_syntax_t syntax; | |
27 | char *fastmap; | |
28 | unsigned char * translate; | |
29 | unsigned int re_nsub; | |
30 | unsigned can_be_null : 1; | |
31 | unsigned regs_allocated : 2; | |
32 | unsigned fastmap_accurate : 1; | |
33 | unsigned not_bol : 1; | |
34 | unsigned not_eol : 1; | |
35 | }; | |
36 | typedef struct re_pattern_buffer regex_t; | |
37 | extern __thread void *__libc_tsd_CTYPE_TOLOWER __attribute__ ((tls_model ("initial-exec"))); | |
38 | extern inline const int ** __attribute__ ((const)) __ctype_tolower_loc (void) { | |
39 | union { | |
40 | void **ptr; | |
41 | const int **tablep; | |
42 | } | |
43 | u; | |
44 | u.ptr = (&__libc_tsd_CTYPE_TOLOWER); | |
45 | if (__builtin_expect (*u.tablep == ((void *)0), 0)) *u.tablep = ((int *) ((*_nl_current_LC_CTYPE)->values[((int) (_NL_CTYPE_TOLOWER) & 0xffff)].string) + 128); | |
46 | return u.tablep; | |
47 | } | |
48 | extern __inline int __attribute__ ((__nothrow__)) tolower (int __c) { | |
49 | return __c >= -128 && __c < 256 ? (*__ctype_tolower_loc ())[__c] : __c; | |
50 | } | |
51 | typedef struct { | |
52 | } | |
53 | __mbstate_t; | |
54 | typedef __mbstate_t mbstate_t; | |
55 | typedef unsigned long int bitset_word_t; | |
56 | typedef bitset_word_t bitset_t[(256 / (sizeof (bitset_word_t) * 8))]; | |
57 | typedef bitset_word_t *re_bitset_ptr_t; | |
58 | typedef enum { | |
59 | INSIDE_WORD = 0x0001 | 0x0004, WORD_FIRST = 0x0002 | 0x0004, WORD_LAST = 0x0001 | 0x0008, INSIDE_NOTWORD = 0x0002 | 0x0008, LINE_FIRST = 0x0010, LINE_LAST = 0x0020, BUF_FIRST = 0x0040, BUF_LAST = 0x0080, WORD_DELIM = 0x0100, NOT_WORD_DELIM = 0x0200 } | |
60 | re_context_type; | |
61 | typedef struct { | |
62 | int nelem; | |
63 | int *elems; | |
64 | } | |
65 | re_node_set; | |
66 | typedef enum { | |
67 | NON_TYPE = 0, CHARACTER = 1, END_OF_RE = 2, SIMPLE_BRACKET = 3, OP_BACK_REF = 4, OP_PERIOD = 5, COMPLEX_BRACKET = 6, OP_UTF8_PERIOD = 7, OP_OPEN_SUBEXP = 8 | 0, OP_CLOSE_SUBEXP = 8 | 1, OP_ALT = 8 | 2, OP_DUP_ASTERISK = 8 | 3, ANCHOR = 8 | 4, CONCAT = 16, SUBEXP = 17, OP_DUP_PLUS = 18, OP_DUP_QUESTION, OP_OPEN_BRACKET, OP_CLOSE_BRACKET, OP_CHARSET_RANGE, OP_OPEN_DUP_NUM, OP_CLOSE_DUP_NUM, OP_NON_MATCH_LIST, OP_OPEN_COLL_ELEM, OP_CLOSE_COLL_ELEM, OP_OPEN_EQUIV_CLASS, OP_CLOSE_EQUIV_CLASS, OP_OPEN_CHAR_CLASS, OP_CLOSE_CHAR_CLASS, OP_WORD, OP_NOTWORD, OP_SPACE, OP_NOTSPACE, BACK_SLASH } | |
68 | re_token_type_t; | |
69 | typedef struct { | |
70 | long int *mbchars; | |
71 | unsigned int non_match : 1; | |
72 | int nmbchars; | |
73 | int ncoll_syms; | |
74 | int nequiv_classes; | |
75 | int nranges; | |
76 | int nchar_classes; | |
77 | } | |
78 | re_charset_t; | |
79 | typedef struct { | |
80 | union { | |
81 | unsigned char c; | |
82 | re_bitset_ptr_t sbcset; | |
83 | re_charset_t *mbcset; | |
84 | int idx; | |
85 | } | |
86 | opr; | |
87 | re_token_type_t type : 8; | |
88 | } | |
89 | re_token_t; | |
90 | struct re_string_t { | |
91 | }; | |
92 | typedef struct re_string_t re_string_t; | |
93 | typedef struct re_dfa_t re_dfa_t; | |
94 | struct bin_tree_t { | |
95 | }; | |
96 | typedef struct bin_tree_t bin_tree_t; | |
97 | struct re_dfastate_t { | |
98 | re_node_set nodes; | |
99 | }; | |
100 | typedef struct re_dfastate_t re_dfastate_t; | |
101 | struct re_dfa_t { | |
102 | re_token_t *nodes; | |
103 | unsigned int nodes_alloc; | |
104 | unsigned int nodes_len; | |
105 | int *nexts; | |
106 | int *org_indices; | |
107 | re_node_set *edests; | |
108 | re_node_set *eclosures; | |
109 | struct re_state_table_entry *state_table; | |
110 | re_dfastate_t *init_state; | |
111 | bin_tree_t *str_tree; | |
112 | re_bitset_ptr_t sb_char; | |
113 | int str_tree_storage_idx; | |
114 | int nbackref; | |
115 | unsigned int has_mb_node : 1; | |
116 | unsigned int is_utf8 : 1; | |
117 | unsigned int map_notascii : 1; | |
118 | int mb_cur_max; | |
119 | int *subexp_map; | |
120 | }; | |
121 | static reg_errcode_t re_compile_internal (regex_t *preg, const char * pattern, unsigned int length, reg_syntax_t syntax); | |
122 | static void re_compile_fastmap_iter (regex_t *bufp, const re_dfastate_t *init_state, char *fastmap); | |
123 | static reg_errcode_t init_dfa (re_dfa_t *dfa, unsigned int pat_len); | |
124 | static void optimize_utf8 (re_dfa_t *dfa); | |
125 | static reg_errcode_t analyze (regex_t *preg); | |
126 | static reg_errcode_t optimize_subexps (void *extra, bin_tree_t *node); | |
127 | const unsigned int __re_error_msgid_idx[] = { | |
128 | 0, (0 + sizeof "Success"), ((0 + sizeof "Success") + sizeof "No match"), (((0 + sizeof "Success") + sizeof "No match") + sizeof "Invalid regular expression"), ((((0 + sizeof "Success") + sizeof "No match") + sizeof "Invalid regular expression") + sizeof "Invalid collation character"), (((((0 + sizeof "Success") + sizeof "No match") + sizeof "Invalid regular expression") + sizeof "Invalid collation character") + sizeof "Invalid character class name"), ((((((0 + sizeof "Success") + sizeof "No match") + sizeof "Invalid regular expression") + sizeof "Invalid collation character") + sizeof "Invalid character class name") + sizeof "Trailing backslash"), (((((((0 + sizeof "Success") + sizeof "No match") + sizeof "Invalid regular expression") + sizeof "Invalid collation character") + sizeof "Invalid character class name") + sizeof "Trailing backslash") + sizeof "Invalid back reference"), ((((((((0 + sizeof "Success") + sizeof "No match") + sizeof "Invalid regular expression") + sizeof "Invalid collation character") + sizeof "Invalid character class name") + sizeof "Trailing backslash") + sizeof "Invalid back reference") + sizeof "Unmatched [ or [^"), (((((((((0 + sizeof "Success") + sizeof "No match") + sizeof "Invalid regular expression") + sizeof "Invalid collation character") + sizeof "Invalid character class name") + sizeof "Trailing backslash") + sizeof "Invalid back reference") + sizeof "Unmatched [ or [^") + sizeof "Unmatched ( or \\("), ((((((((((0 + sizeof "Success") + sizeof "No match") + sizeof "Invalid regular expression") + sizeof "Invalid collation character") + sizeof "Invalid character class name") + sizeof "Trailing backslash") + sizeof "Invalid back reference") + sizeof "Unmatched [ or [^") + sizeof "Unmatched ( or \\(") + sizeof "Unmatched \\{"), (((((((((((0 + sizeof "Success") + sizeof "No match") + sizeof "Invalid regular expression") + sizeof "Invalid collation character") + sizeof "Invalid character class name") + sizeof "Trailing backslash") + sizeof "Invalid back reference") + sizeof "Unmatched [ or [^") + sizeof "Unmatched ( or \\(") + sizeof "Unmatched \\{") + sizeof "Invalid content of \\{\\}"), ((((((((((((0 + sizeof "Success") + sizeof "No match") + sizeof "Invalid regular expression") + sizeof "Invalid collation character") + sizeof "Invalid character class name") + sizeof "Trailing backslash") + sizeof "Invalid back reference") + sizeof "Unmatched [ or [^") + sizeof "Unmatched ( or \\(") + sizeof "Unmatched \\{") + sizeof "Invalid content of \\{\\}") + sizeof "Invalid range end"), (((((((((((((0 + sizeof "Success") + sizeof "No match") + sizeof "Invalid regular expression") + sizeof "Invalid collation character") + sizeof "Invalid character class name") + sizeof "Trailing backslash") + sizeof "Invalid back reference") + sizeof "Unmatched [ or [^") + sizeof "Unmatched ( or \\(") + sizeof "Unmatched \\{") + sizeof "Invalid content of \\{\\}") + sizeof "Invalid range end") + sizeof "Memory exhausted"), ((((((((((((((0 + sizeof "Success") + sizeof "No match") + sizeof "Invalid regular expression") + sizeof "Invalid collation character") + sizeof "Invalid character class name") + sizeof "Trailing backslash") + sizeof "Invalid back reference") + sizeof "Unmatched [ or [^") + sizeof "Unmatched ( or \\(") + sizeof "Unmatched \\{") + sizeof "Invalid content of \\{\\}") + sizeof "Invalid range end") + sizeof "Memory exhausted") + sizeof "Invalid preceding regular expression"), (((((((((((((((0 + sizeof "Success") + sizeof "No match") + sizeof "Invalid regular expression") + sizeof "Invalid collation character") + sizeof "Invalid character class name") + sizeof "Trailing backslash") + sizeof "Invalid back reference") + sizeof "Unmatched [ or [^") + sizeof "Unmatched ( or \\(") + sizeof "Unmatched \\{") + sizeof "Invalid content of \\{\\}") + sizeof "Invalid range end") + sizeof "Memory exhausted") + sizeof "Invalid preceding regular expression") + sizeof "Premature end of regular expression"), ((((((((((((((((0 + sizeof "Success") + sizeof "No match") + sizeof "Invalid regular expression") + sizeof "Invalid collation character") + sizeof "Invalid character class name") + sizeof "Trailing backslash") + sizeof "Invalid back reference") + sizeof "Unmatched [ or [^") + sizeof "Unmatched ( or \\(") + sizeof "Unmatched \\{") + sizeof "Invalid content of \\{\\}") + sizeof "Invalid range end") + sizeof "Memory exhausted") + sizeof "Invalid preceding regular expression") + sizeof "Premature end of regular expression") + sizeof "Regular expression too big") }; | |
129 | const char * __re_compile_pattern (pattern, length, bufp) const char *pattern; | |
130 | { | |
131 | reg_errcode_t ret; | |
132 | ret = re_compile_internal (bufp, pattern, length, re_syntax_options); | |
133 | } | |
134 | int __re_compile_fastmap (bufp) struct re_pattern_buffer *bufp; | |
135 | { | |
136 | re_dfa_t *dfa = (re_dfa_t *) bufp->buffer; | |
137 | char *fastmap = bufp->fastmap; | |
138 | re_compile_fastmap_iter (bufp, dfa->init_state, fastmap); | |
139 | } | |
140 | static inline void __attribute__ ((always_inline)) re_set_fastmap (char *fastmap, int icase, int ch) { | |
141 | if (icase) fastmap[(__extension__ ({ | |
142 | int __res; | |
143 | if (sizeof (ch) > 1) { | |
144 | if (__builtin_constant_p (ch)) { | |
145 | } | |
146 | else __res = tolower (ch); | |
147 | } | |
148 | __res; | |
149 | } | |
150 | ))] = 1; | |
151 | } | |
152 | static void re_compile_fastmap_iter (regex_t *bufp, const re_dfastate_t *init_state, char *fastmap) { | |
153 | re_dfa_t *dfa = (re_dfa_t *) bufp->buffer; | |
154 | int node_cnt; | |
155 | int icase = (dfa->mb_cur_max == 1 && (bufp->syntax & ((((((((((((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1))); | |
156 | for (node_cnt = 0; | |
157 | node_cnt < init_state->nodes.nelem; | |
158 | ++node_cnt) { | |
159 | int node = init_state->nodes.elems[node_cnt]; | |
160 | re_token_type_t type = dfa->nodes[node].type; | |
161 | if (type == CHARACTER) { | |
162 | if ((bufp->syntax & ((((((((((((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1)) && dfa->mb_cur_max > 1) { | |
163 | unsigned char *buf = __builtin_alloca (dfa->mb_cur_max), *p; | |
164 | } | |
165 | int i, ch; | |
166 | for (i = 0, ch = 0; | |
167 | i < (256 / (sizeof (bitset_word_t) * 8)); | |
168 | ++i) { | |
169 | int j; | |
170 | bitset_word_t w = dfa->nodes[node].opr.sbcset[i]; | |
171 | for (j = 0; | |
172 | j < (sizeof (bitset_word_t) * 8); | |
173 | ++j, ++ch) if (w & ((bitset_word_t) 1 << j)) re_set_fastmap (fastmap, icase, ch); | |
174 | } | |
175 | } | |
176 | else if (type == COMPLEX_BRACKET) { | |
177 | int i; | |
178 | re_charset_t *cset = dfa->nodes[node].opr.mbcset; | |
179 | if (cset->non_match || cset->ncoll_syms || cset->nequiv_classes || cset->nranges || cset->nchar_classes) { | |
180 | if (((unsigned int) (*_nl_current_LC_COLLATE)->values[((int) (_NL_COLLATE_NRULES) & 0xffff)].word) != 0) { | |
181 | const int *table = (const int *) ((*_nl_current_LC_COLLATE)->values[((int) (_NL_COLLATE_TABLEMB) & 0xffff)].string); | |
182 | for (i = 0; | |
183 | i < 256; | |
184 | ++i) if (table[i] < 0) re_set_fastmap (fastmap, icase, i); | |
185 | } | |
186 | } | |
187 | for (i = 0; | |
188 | i < cset->nmbchars; | |
189 | ++i) { | |
190 | char buf[256]; | |
191 | mbstate_t state; | |
192 | if (__wcrtomb (buf, cset->mbchars[i], &state) != (unsigned int) -1) re_set_fastmap (fastmap, icase, *(unsigned char *) buf); | |
193 | if ((bufp->syntax & ((((((((((((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1)) && dfa->mb_cur_max > 1) { | |
194 | if (__wcrtomb (buf, towlower (cset->mbchars[i]), &state) != (unsigned int) -1) re_set_fastmap (fastmap, 0, *(unsigned char *) buf); | |
195 | } | |
196 | } | |
197 | } | |
198 | else if (type == OP_PERIOD || type == OP_UTF8_PERIOD || type == END_OF_RE) { | |
199 | memset (fastmap, '\1', sizeof (char) * 256); | |
200 | if (type == END_OF_RE) bufp->can_be_null = 1; | |
201 | return; | |
202 | } | |
203 | } | |
204 | } | |
205 | static const bitset_t utf8_sb_map = { | |
206 | [0 ... 0x80 / (sizeof (bitset_word_t) * 8) - 1] = (2147483647L * 2UL + 1UL) }; | |
207 | static reg_errcode_t re_compile_internal (regex_t *preg, const char * pattern, unsigned int length, reg_syntax_t syntax) { | |
208 | reg_errcode_t err = REG_NOERROR; | |
209 | re_dfa_t *dfa; | |
210 | re_string_t regexp; | |
211 | preg->fastmap_accurate = 0; | |
212 | preg->not_bol = preg->not_eol = 0; | |
213 | preg->can_be_null = 0; | |
214 | preg->regs_allocated = 0; | |
215 | err = init_dfa (dfa, length); | |
216 | err = re_string_construct (®exp, pattern, length, preg->translate, syntax & ((((((((((((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1), dfa); | |
217 | dfa->str_tree = parse (®exp, preg, syntax, &err); | |
218 | err = analyze (preg); | |
219 | if (dfa->is_utf8 && !(syntax & ((((((((((((((((((((((((unsigned long int) 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1) << 1)) && preg->translate == ((void *)0)) optimize_utf8 (dfa); | |
220 | } | |
221 | static reg_errcode_t init_dfa (re_dfa_t *dfa, unsigned int pat_len) { | |
222 | memset (dfa, '\0', sizeof (re_dfa_t)); | |
223 | dfa->str_tree_storage_idx = ((1024 - sizeof (void *)) / sizeof (bin_tree_t)); | |
224 | if (pat_len == (4294967295U)) return REG_ESPACE; | |
225 | if (dfa->mb_cur_max == 6 && __extension__ ({ | |
226 | unsigned int __s1_len, __s2_len; | |
227 | (__builtin_constant_p (((*_nl_current_LC_CTYPE)->values[((int) (_NL_CTYPE_CODESET_NAME) & 0xffff)].string)) && __builtin_constant_p ("UTF-8") && (__s1_len = strlen (((*_nl_current_LC_CTYPE)->values[((int) (_NL_CTYPE_CODESET_NAME) & 0xffff)].string)), __s2_len = strlen ("UTF-8"), (!((unsigned int)(const void *)((((*_nl_current_LC_CTYPE)->values[((int) (_NL_CTYPE_CODESET_NAME) & 0xffff)].string)) + 1) - (unsigned int)(const void *)(((*_nl_current_LC_CTYPE)->values[((int) (_NL_CTYPE_CODESET_NAME) & 0xffff)].string)) == 1) || __s1_len >= 4) && (!((unsigned int)(const void *)(("UTF-8") + 1) - (unsigned int)(const void *)("UTF-8") == 1) || __s2_len >= 4)) ? __builtin_strcmp (((*_nl_current_LC_CTYPE)->values[((int) (_NL_CTYPE_CODESET_NAME) & 0xffff)].string), "UTF-8") : (__builtin_constant_p (((*_nl_current_LC_CTYPE)->values[((int) (_NL_CTYPE_CODESET_NAME) & 0xffff)].string)) && ((unsigned int)(const void *)((((*_nl_current_LC_CTYPE)->values[((int) (_NL_CTYPE_CODESET_NAME) & 0xffff)].string)) + 1) - (unsigned int)(const void *)(((*_nl_current_LC_CTYPE)->values[((int) (_NL_CTYPE_CODESET_NAME) & 0xffff)].string)) == 1) && (__s1_len = strlen (((*_nl_current_LC_CTYPE)->values[((int) (_NL_CTYPE_CODESET_NAME) & 0xffff)].string)), __s1_len < 4) ? (__builtin_constant_p ("UTF-8") && ((unsigned int)(const void *)(("UTF-8") + 1) - (unsigned int)(const void *)("UTF-8") == 1) ? __builtin_strcmp (((*_nl_current_LC_CTYPE)->values[((int) (_NL_CTYPE_CODESET_NAME) & 0xffff)].string), "UTF-8") : (__extension__ ({ | |
228 | __const unsigned char *__s2 = (__const unsigned char *) (__const char *) ("UTF-8"); | |
229 | register int __result = (((__const unsigned char *) (__const char *) (((*_nl_current_LC_CTYPE)->values[((int) (_NL_CTYPE_CODESET_NAME) & 0xffff)].string)))[0] - __s2[0]); | |
230 | __result; | |
231 | } | |
232 | ))) : (__builtin_constant_p ("UTF-8") && ((unsigned int)(const void *)(("UTF-8") + 1) - (unsigned int)(const void *)("UTF-8") == 1) && (__s2_len = strlen ("UTF-8"), __s2_len < 4) ? (__builtin_constant_p (((*_nl_current_LC_CTYPE)->values[((int) (_NL_CTYPE_CODESET_NAME) & 0xffff)].string)) && ((unsigned int)(const void *)((((*_nl_current_LC_CTYPE)->values[((int) (_NL_CTYPE_CODESET_NAME) & 0xffff)].string)) + 1) - (unsigned int)(const void *)(((*_nl_current_LC_CTYPE)->values[((int) (_NL_CTYPE_CODESET_NAME) & 0xffff)].string)) == 1) ? __builtin_strcmp (((*_nl_current_LC_CTYPE)->values[((int) (_NL_CTYPE_CODESET_NAME) & 0xffff)].string), "UTF-8") : (__extension__ ({ | |
233 | __const unsigned char *__s1 = (__const unsigned char *) (__const char *) (((*_nl_current_LC_CTYPE)->values[((int) (_NL_CTYPE_CODESET_NAME) & 0xffff)].string)); | |
234 | register int __result = __s1[0] - ((__const unsigned char *) (__const char *) ("UTF-8"))[0]; | |
235 | if (__s2_len > 0 && __result == 0) { | |
236 | if (__s2_len > 1 && __result == 0) { | |
237 | } | |
238 | } | |
239 | __result; | |
240 | } | |
241 | ))) : __builtin_strcmp (((*_nl_current_LC_CTYPE)->values[((int) (_NL_CTYPE_CODESET_NAME) & 0xffff)].string), "UTF-8")))); | |
242 | } | |
243 | ) == 0) dfa->is_utf8 = 1; | |
244 | dfa->map_notascii = (((unsigned int) (*_nl_current_LC_CTYPE)->values[((int) (_NL_CTYPE_MAP_TO_NONASCII) & 0xffff)].word) != 0); | |
245 | if (dfa->mb_cur_max > 1) { | |
246 | if (dfa->is_utf8) dfa->sb_char = (re_bitset_ptr_t) utf8_sb_map; | |
247 | else { | |
248 | int i, j, ch; | |
249 | dfa->sb_char = (re_bitset_ptr_t) calloc (sizeof (bitset_t), 1); | |
250 | if (__builtin_expect (dfa->sb_char == ((void *)0), 0)) return REG_ESPACE; | |
251 | for (i = 0, ch = 0; | |
252 | i < (256 / (sizeof (bitset_word_t) * 8)); | |
253 | ++i) for (j = 0; | |
254 | j < (sizeof (bitset_word_t) * 8); | |
255 | ++j, ++ch) { | |
256 | unsigned int wch = __btowc (ch); | |
257 | if (wch != (0xffffffffu)) dfa->sb_char[i] |= (bitset_word_t) 1 << j; | |
258 | } | |
259 | } | |
260 | } | |
261 | if (__builtin_expect (dfa->nodes == ((void *)0) || dfa->state_table == ((void *)0), 0)) return REG_ESPACE; | |
262 | return REG_NOERROR; | |
263 | } | |
264 | static void optimize_utf8 (re_dfa_t *dfa) { | |
265 | int node, i, mb_chars = 0, has_period = 0; | |
266 | for (node = 0; | |
267 | node < dfa->nodes_len; | |
268 | ++node) switch (dfa->nodes[node].type) { | |
269 | case CHARACTER: if (dfa->nodes[node].opr.c >= 0x80) mb_chars = 1; | |
270 | case ANCHOR: switch (dfa->nodes[node].opr.idx) { | |
271 | case LINE_FIRST: case LINE_LAST: case BUF_FIRST: case BUF_LAST: break; | |
272 | default: return; | |
273 | } | |
274 | case OP_PERIOD: has_period = 1; | |
275 | case SIMPLE_BRACKET: ((0x80 % (sizeof (bitset_word_t) * 8) == 0) ? (void) (0) : (__assert_fail ("0x80 % (sizeof (bitset_word_t) * 8) == 0", "regcomp.c", 1059, __PRETTY_FUNCTION__), (void) (0))); | |
276 | for (i = 0x80 / (sizeof (bitset_word_t) * 8); | |
277 | i < (256 / (sizeof (bitset_word_t) * 8)); | |
278 | ++i) if (dfa->nodes[node].opr.sbcset[i]) return; | |
279 | } | |
280 | dfa->has_mb_node = dfa->nbackref > 0 || has_period; | |
281 | } | |
282 | static reg_errcode_t analyze (regex_t *preg) { | |
283 | re_dfa_t *dfa = (re_dfa_t *) preg->buffer; | |
284 | dfa->nexts = ((int *) malloc ((dfa->nodes_alloc) * sizeof (int))); | |
285 | dfa->org_indices = ((int *) malloc ((dfa->nodes_alloc) * sizeof (int))); | |
286 | dfa->edests = ((re_node_set *) malloc ((dfa->nodes_alloc) * sizeof (re_node_set))); | |
287 | dfa->eclosures = ((re_node_set *) malloc ((dfa->nodes_alloc) * sizeof (re_node_set))); | |
288 | if (__builtin_expect (dfa->nexts == ((void *)0) || dfa->org_indices == ((void *)0) || dfa->edests == ((void *)0) || dfa->eclosures == ((void *)0), 0)) return REG_ESPACE; | |
289 | if (dfa->subexp_map != ((void *)0)) { | |
290 | int i; | |
291 | for (i = 0; | |
292 | i < preg->re_nsub; | |
293 | i++) dfa->subexp_map[i] = i; | |
294 | preorder (dfa->str_tree, optimize_subexps, dfa); | |
295 | for (i = 0; | |
296 | i < preg->re_nsub; | |
297 | i++) if (dfa->subexp_map[i] != i) break; | |
298 | } | |
299 | } |