Commit | Line | Data |
a0d0e21e |
1 | /* regcomp.h |
a687059c |
2 | */ |
3 | |
c277df42 |
4 | typedef OP OP_4tree; /* Will be redefined later. */ |
5 | |
a687059c |
6 | /* |
7 | * The "internal use only" fields in regexp.h are present to pass info from |
8 | * compile to execute that permits the execute phase to run lots faster on |
9 | * simple cases. They are: |
10 | * |
79072805 |
11 | * regstart sv that must begin a match; Nullch if none obvious |
a687059c |
12 | * reganch is the match anchored (at beginning-of-line only)? |
13 | * regmust string (pointer into program) that match must include, or NULL |
79072805 |
14 | * [regmust changed to SV* for bminstr()--law] |
a687059c |
15 | * regmlen length of regmust string |
16 | * [regmlen not used currently] |
17 | * |
18 | * Regstart and reganch permit very fast decisions on suitable starting points |
19 | * for a match, cutting down the work a lot. Regmust permits fast rejection |
20 | * of lines that cannot possibly match. The regmust tests are costly enough |
e50aee73 |
21 | * that pregcomp() supplies a regmust only if the r.e. contains something |
a687059c |
22 | * potentially expensive (at present, the only such thing detected is * or + |
23 | * at the start of the r.e., which can involve a lot of backup). Regmlen is |
e50aee73 |
24 | * supplied because the test in pregexec() needs it and pregcomp() is computing |
a687059c |
25 | * it anyway. |
26 | * [regmust is now supplied always. The tests that use regmust have a |
27 | * heuristic that disables the test if it usually matches.] |
28 | * |
29 | * [In fact, we now use regmust in many cases to locate where the search |
30 | * starts in the string, so if regback is >= 0, the regmust search is never |
31 | * wasted effort. The regback variable says how many characters back from |
32 | * where regmust matched is the earliest possible start of the match. |
33 | * For instance, /[a-z].foo/ has a regmust of 'foo' and a regback of 2.] |
34 | */ |
35 | |
36 | /* |
37 | * Structure for regexp "program". This is essentially a linear encoding |
38 | * of a nondeterministic finite-state machine (aka syntax charts or |
39 | * "railroad normal form" in parsing technology). Each node is an opcode |
40 | * plus a "next" pointer, possibly plus an operand. "Next" pointers of |
41 | * all nodes except BRANCH implement concatenation; a "next" pointer with |
42 | * a BRANCH on both ends of it is connecting two alternatives. (Here we |
43 | * have one of the subtle syntax dependencies: an individual BRANCH (as |
44 | * opposed to a collection of them) is never concatenated with anything |
45 | * because of operator precedence.) The operand of some types of node is |
46 | * a literal string; for others, it is a node leading into a sub-FSM. In |
47 | * particular, the operand of a BRANCH node is the first node of the branch. |
48 | * (NB this is *not* a tree structure: the tail of the branch connects |
49 | * to the thing following the set of BRANCHes.) The opcodes are: |
50 | */ |
51 | |
a687059c |
52 | /* |
53 | * A node is one char of opcode followed by two chars of "next" pointer. |
54 | * "Next" pointers are stored as two 8-bit pieces, high order first. The |
55 | * value is a positive offset from the opcode of the node containing it. |
56 | * An operand, if any, simply follows the node. (Note that much of the |
57 | * code generation knows about this implicit relationship.) |
58 | * |
59 | * Using two bytes for the "next" pointer is vast overkill for most things, |
60 | * but allows patterns to get big without disasters. |
61 | * |
e91177ed |
62 | * [The "next" pointer is always aligned on an even |
a687059c |
63 | * boundary, and reads the offset directly as a short. Also, there is no |
64 | * special test to reverse the sign of BACK pointers since the offset is |
65 | * stored negative.] |
66 | */ |
67 | |
c277df42 |
68 | struct regnode_string { |
69 | U8 flags; |
70 | U8 type; |
71 | U16 next_off; |
72 | U8 string[1]; |
73 | }; |
a687059c |
74 | |
c277df42 |
75 | struct regnode_1 { |
76 | U8 flags; |
77 | U8 type; |
78 | U16 next_off; |
79 | U32 arg1; |
80 | }; |
81 | |
82 | struct regnode_2 { |
83 | U8 flags; |
84 | U8 type; |
85 | U16 next_off; |
86 | U16 arg1; |
87 | U16 arg2; |
88 | }; |
89 | |
9c7e81e8 |
90 | /* XXX fix this description. |
91 | Impose a limit of REG_INFTY on various pattern matching operations |
92 | to limit stack growth and to avoid "infinite" recursions. |
93 | */ |
94 | /* The default size for REG_INFTY is I16_MAX, which is the same as |
95 | SHORT_MAX (see perl.h). Unfortunately I16 isn't necessarily 16 bits |
96 | (see handy.h). On the Cray C90, sizeof(short)==4 and hence I16_MAX is |
97 | ((1<<31)-1), while on the Cray T90, sizeof(short)==8 and I16_MAX is |
98 | ((1<<63)-1). To limit stack growth to reasonable sizes, supply a |
99 | smaller default. |
100 | --Andy Dougherty 11 June 1998 |
101 | */ |
102 | #if SHORTSIZE > 2 |
103 | # ifndef REG_INFTY |
104 | # define REG_INFTY ((1<<15)-1) |
105 | # endif |
106 | #endif |
107 | |
108 | #ifndef REG_INFTY |
83cfe48c |
109 | # define REG_INFTY I16_MAX |
110 | #endif |
a687059c |
111 | |
e91177ed |
112 | #define ARG_VALUE(arg) (arg) |
113 | #define ARG__SET(arg,val) ((arg) = (val)) |
c277df42 |
114 | |
115 | #define ARG(p) ARG_VALUE(ARG_LOC(p)) |
116 | #define ARG1(p) ARG_VALUE(ARG1_LOC(p)) |
117 | #define ARG2(p) ARG_VALUE(ARG2_LOC(p)) |
118 | #define ARG_SET(p, val) ARG__SET(ARG_LOC(p), (val)) |
119 | #define ARG1_SET(p, val) ARG__SET(ARG1_LOC(p), (val)) |
120 | #define ARG2_SET(p, val) ARG__SET(ARG2_LOC(p), (val)) |
121 | |
122 | #ifndef lint |
e91177ed |
123 | # define NEXT_OFF(p) ((p)->next_off) |
124 | # define NODE_ALIGN(node) |
125 | # define NODE_ALIGN_FILL(node) ((node)->flags = 0xde) /* deadbeef */ |
a687059c |
126 | #else /* lint */ |
c277df42 |
127 | # define NEXT_OFF(p) 0 |
e91177ed |
128 | # define NODE_ALIGN(node) |
129 | # define NODE_ALIGN_FILL(node) |
a687059c |
130 | #endif /* lint */ |
131 | |
c277df42 |
132 | #define SIZE_ALIGN NODE_ALIGN |
133 | |
e91177ed |
134 | #define OP(p) ((p)->type) |
135 | #define OPERAND(p) (((struct regnode_string *)p)->string) |
136 | #define NODE_ALIGN(node) |
137 | #define ARG_LOC(p) (((struct regnode_1 *)p)->arg1) |
138 | #define ARG1_LOC(p) (((struct regnode_2 *)p)->arg1) |
139 | #define ARG2_LOC(p) (((struct regnode_2 *)p)->arg2) |
140 | #define NODE_STEP_REGNODE 1 /* sizeof(regnode)/sizeof(regnode) */ |
141 | #define EXTRA_STEP_2ARGS EXTRA_SIZE(struct regnode_2) |
142 | |
143 | #define NODE_STEP_B 4 |
c277df42 |
144 | |
145 | #define NEXTOPER(p) ((p) + NODE_STEP_REGNODE) |
146 | #define PREVOPER(p) ((p) - NODE_STEP_REGNODE) |
147 | |
e91177ed |
148 | #define FILL_ADVANCE_NODE(ptr, op) STMT_START { \ |
c277df42 |
149 | (ptr)->type = op; (ptr)->next_off = 0; (ptr)++; } STMT_END |
e91177ed |
150 | #define FILL_ADVANCE_NODE_ARG(ptr, op, arg) STMT_START { \ |
c277df42 |
151 | ARG_SET(ptr, arg); FILL_ADVANCE_NODE(ptr, op); (ptr) += 1; } STMT_END |
a687059c |
152 | |
22c35a8c |
153 | #define REG_MAGIC 0234 |
a687059c |
154 | |
3280af22 |
155 | #define SIZE_ONLY (PL_regcode == &PL_regdummy) |
c277df42 |
156 | |
b8c5462f |
157 | /* Flags for first parameter byte [0] of ANYOF */ |
158 | |
159 | #define ANYOF_CLASS 0x08 |
160 | #define ANYOF_INVERT 0x04 |
161 | #define ANYOF_FOLD 0x02 |
162 | #define ANYOF_LOCALE 0x01 |
163 | |
164 | /* Character classes for bytes [1..4] of ANYOF */ |
165 | |
166 | #define ANYOF_ALNUM 0 /* \w, utf8::IsWord, isALNUM() */ |
167 | #define ANYOF_NALNUM 1 |
168 | #define ANYOF_SPACE 2 |
169 | #define ANYOF_NSPACE 3 |
170 | #define ANYOF_DIGIT 4 |
171 | #define ANYOF_NDIGIT 5 |
172 | #define ANYOF_ALNUMC 6 /* isalnum(3), utf8::IsAlnum, isALNUMC() */ |
173 | #define ANYOF_NALNUMC 7 |
174 | #define ANYOF_ALPHA 8 |
175 | #define ANYOF_NALPHA 9 |
176 | #define ANYOF_ASCII 10 |
177 | #define ANYOF_NASCII 11 |
178 | #define ANYOF_CNTRL 12 |
179 | #define ANYOF_NCNTRL 13 |
180 | #define ANYOF_GRAPH 14 |
181 | #define ANYOF_NGRAPH 15 |
182 | #define ANYOF_LOWER 16 |
183 | #define ANYOF_NLOWER 17 |
184 | #define ANYOF_PRINT 18 |
185 | #define ANYOF_NPRINT 19 |
186 | #define ANYOF_PUNCT 20 |
187 | #define ANYOF_NPUNCT 21 |
188 | #define ANYOF_UPPER 22 |
189 | #define ANYOF_NUPPER 23 |
190 | #define ANYOF_XDIGIT 24 |
191 | #define ANYOF_NXDIGIT 25 |
192 | |
193 | #define ANYOF_MAX 31 |
194 | |
195 | /* Backward source code compatibility. */ |
196 | |
197 | #define ANYOF_ALNUML ANYOF_ALNUM |
198 | #define ANYOF_NALNUML ANYOF_NALNUM |
199 | #define ANYOF_SPACEL ANYOF_SPACE |
200 | #define ANYOF_NSPACEL ANYOF_NSPACE |
201 | |
202 | /* Utility macros for the bitmap and classes of ANYOF */ |
203 | |
204 | #define ANYOF_OPND_SIZE 1 |
205 | #define ANYOF_CLASS_SIZE 4 |
206 | #define ANYOF_BITMAP_SIZE 32 /* 256 b/(8 b/B) */ |
207 | #define ANYOF_SIZE (ANYOF_OPND_SIZE+ANYOF_CLASS_SIZE+ANYOF_BITMAP_SIZE) |
208 | |
209 | #define ANYOF_FLAGS(p) ((p)[0]) |
210 | #define ANYOF_FLAGS_ALL 0xff |
211 | |
212 | #define ANYOF_BIT(c) (1 << ((c) & 7)) |
213 | |
214 | #define ANYOF_CLASS_OFFSET ANYOF_OPND_SIZE |
215 | #define ANYOF_CLASS_BYTE(p, c) ((p)[ANYOF_CLASS_OFFSET + (((c) >> 3) & 3)]) |
216 | #define ANYOF_CLASS_SET(p, c) (ANYOF_CLASS_BYTE(p, c) |= ANYOF_BIT(c)) |
217 | #define ANYOF_CLASS_CLEAR(p, c) (ANYOF_CLASS_BYTE(p, c) &= ~ANYOF_BIT(c)) |
218 | #define ANYOF_CLASS_TEST(p, c) (ANYOF_CLASS_BYTE(p, c) & ANYOF_BIT(c)) |
219 | |
220 | #define ANYOF_BITMAP_OFFSET (ANYOF_CLASS_OFFSET+ANYOF_CLASS_SIZE) |
221 | #define ANYOF_BITMAP_BYTE(p, c) ((p)[ANYOF_BITMAP_OFFSET + (((c) >> 3) & 31)]) |
222 | #define ANYOF_BITMAP_SET(p, c) (ANYOF_BITMAP_BYTE(p, c) |= ANYOF_BIT(c)) |
223 | #define ANYOF_BITMAP_CLEAR(p,c) (ANYOF_BITMAP_BYTE(p, c) &= ~ANYOF_BIT(c)) |
224 | #define ANYOF_BITMAP_TEST(p, c) (ANYOF_BITMAP_BYTE(p, c) & ANYOF_BIT(c)) |
225 | |
226 | #define ANY_SKIP ((ANYOF_SIZE - 1)/sizeof(regnode) + 1) |
c277df42 |
227 | |
a687059c |
228 | /* |
229 | * Utility definitions. |
230 | */ |
231 | #ifndef lint |
2304df62 |
232 | #ifndef CHARMASK |
4d61ec05 |
233 | #define UCHARAT(p) ((int)*(U8*)(p)) |
a687059c |
234 | #else |
2304df62 |
235 | #define UCHARAT(p) ((int)*(p)&CHARMASK) |
a687059c |
236 | #endif |
237 | #else /* lint */ |
6b88bc9c |
238 | #define UCHARAT(p) PL_regdummy |
a687059c |
239 | #endif /* lint */ |
240 | |
34184a49 |
241 | #define FAIL(m) \ |
cea2e8a9 |
242 | STMT_START { \ |
243 | if (!SIZE_ONLY) \ |
51371543 |
244 | SAVEDESTRUCTOR(clear_re,(void*)PL_regcomp_rx); \ |
cea2e8a9 |
245 | Perl_croak(aTHX_ "/%.127s/: %s", PL_regprecomp,m); \ |
34184a49 |
246 | } STMT_END |
247 | |
248 | #define FAIL2(pat,m) \ |
cea2e8a9 |
249 | STMT_START { \ |
250 | if (!SIZE_ONLY) \ |
51371543 |
251 | SAVEDESTRUCTOR(clear_re,(void*)PL_regcomp_rx); \ |
cea2e8a9 |
252 | S_re_croak2(aTHX_ "/%.127s/: ",pat,PL_regprecomp,m); \ |
34184a49 |
253 | } STMT_END |
c277df42 |
254 | |
255 | #define EXTRA_SIZE(guy) ((sizeof(guy)-1)/sizeof(struct regnode)) |
256 | |
d09b2d29 |
257 | #define REG_SEEN_ZERO_LEN 1 |
258 | #define REG_SEEN_LOOKBEHIND 2 |
259 | #define REG_SEEN_GPOS 4 |
260 | #define REG_SEEN_EVAL 8 |
261 | |
73c4f7a1 |
262 | START_EXTERN_C |
263 | |
d09b2d29 |
264 | #include "regnodes.h" |
265 | |
4d61ec05 |
266 | /* The following have no fixed length. U8 so we can do strchr() on it. */ |
d09b2d29 |
267 | #ifndef DOINIT |
4d61ec05 |
268 | EXTCONST U8 PL_varies[]; |
d09b2d29 |
269 | #else |
4d61ec05 |
270 | EXTCONST U8 PL_varies[] = { |
d09b2d29 |
271 | BRANCH, BACK, STAR, PLUS, CURLY, CURLYX, REF, REFF, REFFL, |
a0ed51b3 |
272 | WHILEM, CURLYM, CURLYN, BRANCHJ, IFTHEN, SUSPEND, CLUMP, 0 |
c277df42 |
273 | }; |
d09b2d29 |
274 | #endif |
c277df42 |
275 | |
4d61ec05 |
276 | /* The following always have a length of 1. U8 we can do strchr() on it. */ |
277 | /* (Note that length 1 means "one character" under UTF8, not "one octet".) */ |
d09b2d29 |
278 | #ifndef DOINIT |
4d61ec05 |
279 | EXTCONST U8 PL_simple[]; |
d09b2d29 |
280 | #else |
4d61ec05 |
281 | EXTCONST U8 PL_simple[] = { |
22c35a8c |
282 | REG_ANY, ANYUTF8, SANY, SANYUTF8, ANYOF, ANYOFUTF8, |
a0ed51b3 |
283 | ALNUM, ALNUMUTF8, ALNUML, ALNUMLUTF8, |
284 | NALNUM, NALNUMUTF8, NALNUML, NALNUMLUTF8, |
285 | SPACE, SPACEUTF8, SPACEL, SPACELUTF8, |
286 | NSPACE, NSPACEUTF8, NSPACEL, NSPACELUTF8, |
287 | DIGIT, DIGITUTF8, NDIGIT, NDIGITUTF8, 0 |
c277df42 |
288 | }; |
289 | #endif |
290 | |
73c4f7a1 |
291 | END_EXTERN_C |
cad2e5aa |
292 | |
293 | typedef struct re_scream_pos_data_s |
294 | { |
295 | char **scream_olds; /* match pos */ |
296 | I32 *scream_pos; /* Internal iterator of scream. */ |
297 | } re_scream_pos_data; |
298 | |
299 | struct reg_data { |
300 | U32 count; |
301 | U8 *what; |
302 | void* data[1]; |
303 | }; |
304 | |
305 | struct reg_substr_datum { |
306 | I32 min_offset; |
307 | I32 max_offset; |
308 | SV *substr; |
309 | }; |
310 | |
311 | struct reg_substr_data { |
312 | struct reg_substr_datum data[3]; /* Actual array */ |
313 | }; |
314 | |
315 | #define anchored_substr substrs->data[0].substr |
316 | #define anchored_offset substrs->data[0].min_offset |
317 | #define float_substr substrs->data[1].substr |
318 | #define float_min_offset substrs->data[1].min_offset |
319 | #define float_max_offset substrs->data[1].max_offset |
320 | #define check_substr substrs->data[2].substr |
321 | #define check_offset_min substrs->data[2].min_offset |
322 | #define check_offset_max substrs->data[2].max_offset |