This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
perlapi: Remove per-thread section; move to real scns
[perl5.git] / regexp.h
CommitLineData
a0d0e21e 1/* regexp.h
d6376244 2 *
4bb101f2 3 * Copyright (C) 1993, 1994, 1996, 1997, 1999, 2000, 2001, 2003,
1129b882 4 * 2005, 2006, 2007, 2008 by Larry Wall and others
d6376244
JH
5 *
6 * You may distribute under the terms of either the GNU General Public
7 * License or the Artistic License, as specified in the README file.
8 *
a0d0e21e
LW
9 */
10
378cc40b
LW
11/*
12 * Definitions etc. for regexp(3) routines.
13 *
14 * Caveat: this is V8 regexp(3) [actually, a reimplementation thereof],
15 * not the System V one.
16 */
be8e71aa 17#ifndef PLUGGABLE_RE_EXTENSION
785a26d5
YO
18/* we don't want to include this stuff if we are inside of
19 an external regex engine based on the core one - like re 'debug'*/
378cc40b 20
6c5474e8 21# include "utf8.h"
79a2a0e8 22
f55b7b26
KW
23typedef SSize_t regnode_offset;
24
c277df42
IZ
25struct regnode {
26 U8 flags;
27 U8 type;
28 U16 next_off;
29};
30
31typedef struct regnode regnode;
32
cad2e5aa 33struct reg_substr_data;
2779dcf1 34
0ee3c8d0
JH
35struct reg_data;
36
f9f4320a 37struct regexp_engine;
28d8d7f4 38struct regexp;
bbe252da 39
785a26d5 40struct reg_substr_datum {
c4828ca0
DM
41 SSize_t min_offset; /* min pos (in chars) that substr must appear */
42 SSize_t max_offset /* max pos (in chars) that substr must appear */;
785a26d5
YO
43 SV *substr; /* non-utf8 variant */
44 SV *utf8_substr; /* utf8 variant */
c4828ca0 45 SSize_t end_shift; /* how many fixed chars must end the string */
785a26d5
YO
46};
47struct reg_substr_data {
6480a6c4 48 U8 check_ix; /* index into data[] of check substr */
785a26d5
YO
49 struct reg_substr_datum data[3]; /* Actual array */
50};
f9f4320a 51
6c5474e8
KW
52# ifdef PERL_ANY_COW
53# define SV_SAVED_COPY SV *saved_copy; /* If non-NULL, SV which is COW from original */
54# else
55# define SV_SAVED_COPY
56# endif
28d8d7f4 57
b3fd53f3
DM
58/* offsets within a string of a particular /(.)/ capture */
59
f0ab9afb 60typedef struct regexp_paren_pair {
99a90e59
FC
61 SSize_t start;
62 SSize_t end;
b3fd53f3
DM
63 /* 'start_tmp' records a new opening position before the matching end
64 * has been found, so that the old start and end values are still
65 * valid, e.g.
66 * "abc" =~ /(.(?{print "[$1]"}))+/
67 *outputs [][a][b]
68 * This field is not part of the API. */
ea3daa5d 69 SSize_t start_tmp;
f0ab9afb 70} regexp_paren_pair;
28d8d7f4 71
6c5474e8
KW
72# if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_UTF8_C)
73# define _invlist_union(a, b, output) _invlist_union_maybe_complement_2nd(a, b, FALSE, output)
74# define _invlist_intersection(a, b, output) _invlist_intersection_maybe_complement_2nd(a, b, FALSE, output)
3f80b571
KW
75
76/* Subtracting b from a leaves in a everything that was there that isn't in b,
77 * that is the intersection of a with b's complement */
6c5474e8
KW
78# define _invlist_subtract(a, b, output) _invlist_intersection_maybe_complement_2nd(a, b, TRUE, output)
79# endif
52ae8f7e 80
3d2bd50a
DM
81/* record the position of a (?{...}) within a pattern */
82
83struct reg_code_block {
84 STRLEN start;
85 STRLEN end;
86 OP *block;
b30fcab9 87 REGEXP *src_regex;
3d2bd50a
DM
88};
89
1acab4c5
DM
90/* array of reg_code_block's plus header info */
91
92struct reg_code_blocks {
f8def6c7 93 int refcnt; /* we may be pointed to from a regex and from the savestack */
1acab4c5
DM
94 int count; /* how many code blocks */
95 struct reg_code_block *cb; /* array of reg_code_block's */
96};
97
3d2bd50a 98
882227b7
AB
99/*
100 The regexp/REGEXP struct, see L<perlreapi> for further documentation
101 on the individual fields. The struct is ordered so that the most
102 commonly used fields are placed at the start.
103
104 Any patch that adds items to this struct will need to include
105 changes to F<sv.c> (C<Perl_re_dup()>) and F<regcomp.c>
106 (C<pregfree()>). This involves freeing or cloning items in the
107 regexp's data array based on the data item's type.
108*/
109
bbe252da 110typedef struct regexp {
e1168c11
DM
111 _XPV_HEAD;
112 const struct regexp_engine* engine; /* what engine created this regexp? */
113 REGEXP *mother_re; /* what re is this a lightweight copy of? */
114 HV *paren_names; /* Optional hash of paren names */
115
116 /*----------------------------------------------------------------------
117 * Information about the match that the perl core uses to manage things
118 */
119
120 U32 extflags; /* Flags used both externally and internally */
2bb68ff1 121 U32 nparens; /* number of capture buffers */
e1168c11
DM
122 SSize_t minlen; /* minimum possible number of chars in string to match */
123 SSize_t minlenret; /* mininum possible number of chars in $& */
124 STRLEN gofs; /* chars left of pos that we search from */
125 /* substring data about strings that must appear in
126 * the final match, used for optimisations */
127 struct reg_substr_data *substrs;
e1168c11
DM
128
129 /* private engine specific data */
130
e1168c11
DM
131 void *pprivate; /* Data private to the regex engine which
132 * created this object. */
2bb68ff1 133 U32 intflags; /* Engine Specific Internal flags */
e1168c11
DM
134
135 /*----------------------------------------------------------------------
136 * Data about the last/current match. These are modified during matching
137 */
138
0b9dad94 139 U32 lastparen; /* highest close paren matched ($+) */
e1168c11
DM
140 regexp_paren_pair *offs; /* Array of offsets for (@-) and (@+) */
141 char **recurse_locinput; /* used to detect infinite recursion, XXX: move to internal */
2bb68ff1 142 U32 lastcloseparen; /* last close paren matched ($^N) */
e1168c11
DM
143
144 /*---------------------------------------------------------------------- */
145
146 /* offset from wrapped to the start of precomp */
147 PERL_BITFIELD32 pre_prefix:4;
148
149 /* original flags used to compile the pattern, may differ from
150 * extflags in various ways */
151 PERL_BITFIELD32 compflags:9;
152
153 /*---------------------------------------------------------------------- */
154
da35f4ca 155 char *subbeg; /* saved or original string so \digit works forever. */
2bb68ff1
RL
156 SV_SAVED_COPY /* If non-NULL, SV which is COW from original */
157 SSize_t sublen; /* Length of string pointed by subbeg */
158 SSize_t suboffset; /* byte offset of subbeg from logical start of str */
159 SSize_t subcoffset; /* suboffset equiv, but in chars (for @-/@+) */
160 SSize_t maxlen; /* minimum possible number of chars in string to match */
2bb68ff1
RL
161
162 /*---------------------------------------------------------------------- */
163
164
e1168c11 165 CV *qr_anoncv; /* the anon sub wrapped round qr/(?{..})/ */
f8fc2ecf
YO
166} regexp;
167
e1168c11 168
6c5474e8 169# define RXp_PAREN_NAMES(rx) ((rx)->paren_names)
5daac39c 170
785a26d5 171/* used for high speed searches */
f9f4320a
YO
172typedef struct re_scream_pos_data_s
173{
174 char **scream_olds; /* match pos */
ea3daa5d 175 SSize_t *scream_pos; /* Internal iterator of scream. */
f9f4320a
YO
176} re_scream_pos_data;
177
785a26d5
YO
178/* regexp_engine structure. This is the dispatch table for regexes.
179 * Any regex engine implementation must be able to build one of these.
180 */
f9f4320a 181typedef struct regexp_engine {
1593ad57 182 REGEXP* (*comp) (pTHX_ SV * const pattern, U32 flags);
49d7dfbc 183 I32 (*exec) (pTHX_ REGEXP * const rx, char* stringarg, char* strend,
ea3daa5d 184 char* strbeg, SSize_t minend, SV* sv,
49d7dfbc 185 void* data, U32 flags);
52a21eb3
DM
186 char* (*intuit) (pTHX_
187 REGEXP * const rx,
188 SV *sv,
189 const char * const strbeg,
190 char *strpos,
191 char *strend,
192 const U32 flags,
9f61653a 193 re_scream_pos_data *data);
49d7dfbc 194 SV* (*checkstr) (pTHX_ REGEXP * const rx);
fc6bde6f 195 void (*rxfree) (pTHX_ REGEXP * const rx);
2fdbfb4d 196 void (*numbered_buff_FETCH) (pTHX_ REGEXP * const rx, const I32 paren,
192b9cd1 197 SV * const sv);
2fdbfb4d
AB
198 void (*numbered_buff_STORE) (pTHX_ REGEXP * const rx, const I32 paren,
199 SV const * const value);
200 I32 (*numbered_buff_LENGTH) (pTHX_ REGEXP * const rx, const SV * const sv,
201 const I32 paren);
192b9cd1
AB
202 SV* (*named_buff) (pTHX_ REGEXP * const rx, SV * const key,
203 SV * const value, const U32 flags);
204 SV* (*named_buff_iter) (pTHX_ REGEXP * const rx, const SV * const lastkey,
205 const U32 flags);
49d7dfbc 206 SV* (*qr_package)(pTHX_ REGEXP * const rx);
6c5474e8 207# ifdef USE_ITHREADS
49d7dfbc 208 void* (*dupe) (pTHX_ REGEXP * const rx, CLONE_PARAMS *param);
6c5474e8 209# endif
3c13cae6
DM
210 REGEXP* (*op_comp) (pTHX_ SV ** const patternp, int pat_count,
211 OP *expr, const struct regexp_engine* eng,
7984ae89 212 REGEXP *old_re,
76ac488f 213 bool *is_bare_re, U32 orig_rx_flags, U32 pm_flags);
f9f4320a
YO
214} regexp_engine;
215
192b9cd1
AB
216/*
217 These are passed to the numbered capture variable callbacks as the
218 paren name. >= 1 is reserved for actual numbered captures, i.e. $1,
219 $2 etc.
220*/
6c5474e8
KW
221# define RX_BUFF_IDX_CARET_PREMATCH -5 /* ${^PREMATCH} */
222# define RX_BUFF_IDX_CARET_POSTMATCH -4 /* ${^POSTMATCH} */
223# define RX_BUFF_IDX_CARET_FULLMATCH -3 /* ${^MATCH} */
224# define RX_BUFF_IDX_PREMATCH -2 /* $` */
225# define RX_BUFF_IDX_POSTMATCH -1 /* $' */
226# define RX_BUFF_IDX_FULLMATCH 0 /* $& */
192b9cd1
AB
227
228/*
229 Flags that are passed to the named_buff and named_buff_iter
230 callbacks above. Those routines are called from universal.c via the
231 Tie::Hash::NamedCapture interface for %+ and %- and the re::
232 functions in the same file.
233*/
234
235/* The Tie::Hash::NamedCapture operation this is part of, if any */
6c5474e8
KW
236# define RXapif_FETCH 0x0001
237# define RXapif_STORE 0x0002
238# define RXapif_DELETE 0x0004
239# define RXapif_CLEAR 0x0008
240# define RXapif_EXISTS 0x0010
241# define RXapif_SCALAR 0x0020
242# define RXapif_FIRSTKEY 0x0040
243# define RXapif_NEXTKEY 0x0080
192b9cd1
AB
244
245/* Whether %+ or %- is being operated on */
6c5474e8
KW
246# define RXapif_ONE 0x0100 /* %+ */
247# define RXapif_ALL 0x0200 /* %- */
192b9cd1
AB
248
249/* Whether this is being called from a re:: function */
6c5474e8
KW
250# define RXapif_REGNAME 0x0400
251# define RXapif_REGNAMES 0x0800
252# define RXapif_REGNAMES_COUNT 0x1000
192b9cd1 253
f7e71195 254/*
f7e71195
AB
255=for apidoc Am|REGEXP *|SvRX|SV *sv
256
72d33970 257Convenience macro to get the REGEXP from a SV. This is approximately
f7e71195
AB
258equivalent to the following snippet:
259
260 if (SvMAGICAL(sv))
261 mg_get(sv);
1af910ea
DL
262 if (SvROK(sv))
263 sv = MUTABLE_SV(SvRV(sv));
264 if (SvTYPE(sv) == SVt_REGEXP)
265 return (REGEXP*) sv;
f7e71195 266
796b6530 267C<NULL> will be returned if a REGEXP* is not found.
f7e71195
AB
268
269=for apidoc Am|bool|SvRXOK|SV* sv
270
1af910ea
DL
271Returns a boolean indicating whether the SV (or the one it references)
272is a REGEXP.
f7e71195
AB
273
274If you want to do something with the REGEXP* later use SvRX instead
275and check for NULL.
276
277=cut
278*/
279
6c5474e8
KW
280# define SvRX(sv) (Perl_get_re_arg(aTHX_ sv))
281# define SvRXOK(sv) cBOOL(Perl_get_re_arg(aTHX_ sv))
f7e71195
AB
282
283
7948fc08 284/* Flags stored in regexp->extflags
bbe252da 285 * These are used by code external to the regexp engine
e357fc67 286 *
5b126c84
KW
287 * Note that the flags whose names start with RXf_PMf_ are defined in
288 * op_reg_common.h, being copied from the parallel flags of op_pmflags
cb5027f2 289 *
eb2624c9
FC
290 * NOTE: if you modify any RXf flags you should run regen.pl or
291 * regen/regcomp.pl so that regnodes.h is updated with the changes.
cb5027f2 292 *
bbe252da
YO
293 */
294
6c5474e8 295# include "op_reg_common.h"
5b126c84 296
6c5474e8 297# define RXf_PMf_STD_PMMOD (RXf_PMf_MULTILINE|RXf_PMf_SINGLELINE|RXf_PMf_FOLD|RXf_PMf_EXTENDED|RXf_PMf_EXTENDED_MORE|RXf_PMf_NOCAPTURE)
cde0cee5 298
6c5474e8 299# define CASE_STD_PMMOD_FLAGS_PARSE_SET(pmfl, x_count) \
cc4d09e1
KW
300 case IGNORE_PAT_MOD: *(pmfl) |= RXf_PMf_FOLD; break; \
301 case MULTILINE_PAT_MOD: *(pmfl) |= RXf_PMf_MULTILINE; break; \
302 case SINGLE_PAT_MOD: *(pmfl) |= RXf_PMf_SINGLELINE; break; \
77c8f263
KW
303 case XTENDED_PAT_MOD: if (x_count == 0) { \
304 *(pmfl) |= RXf_PMf_EXTENDED; \
305 *(pmfl) &= ~RXf_PMf_EXTENDED_MORE; \
306 } \
307 else { \
308 *(pmfl) |= RXf_PMf_EXTENDED \
309 |RXf_PMf_EXTENDED_MORE; \
310 } \
311 (x_count)++; break; \
41d7c59e 312 case NOCAPTURE_PAT_MOD: *(pmfl) |= RXf_PMf_NOCAPTURE; break;
cc4d09e1 313
94b03d7d 314/* Note, includes charset ones, assumes 0 is the default for them */
6c5474e8 315# define STD_PMMOD_FLAGS_CLEAR(pmfl) \
77c8f263 316 *(pmfl) &= ~(RXf_PMf_FOLD|RXf_PMf_MULTILINE|RXf_PMf_SINGLELINE|RXf_PMf_EXTENDED|RXf_PMf_EXTENDED_MORE|RXf_PMf_CHARSET|RXf_PMf_NOCAPTURE)
fb85c044 317
bcdf7404 318/* chars and strings used as regex pattern modifiers
486ec47a 319 * Singular is a 'c'har, plural is a "string"
87e95b7f
YO
320 *
321 * NOTE, KEEPCOPY was originally 'k', but was changed to 'p' for preserve
322 * for compatibility reasons with Regexp::Common which highjacked (?k:...)
323 * for its own uses. So 'k' is out as well.
bcdf7404 324 */
6c5474e8
KW
325# define DEFAULT_PAT_MOD '^' /* Short for all the default modifiers */
326# define EXEC_PAT_MOD 'e'
327# define KEEPCOPY_PAT_MOD 'p'
328# define NOCAPTURE_PAT_MOD 'n'
329# define ONCE_PAT_MOD 'o'
330# define GLOBAL_PAT_MOD 'g'
331# define CONTINUE_PAT_MOD 'c'
332# define MULTILINE_PAT_MOD 'm'
333# define SINGLE_PAT_MOD 's'
334# define IGNORE_PAT_MOD 'i'
335# define XTENDED_PAT_MOD 'x'
336# define NONDESTRUCT_PAT_MOD 'r'
337# define LOCALE_PAT_MOD 'l'
338# define UNICODE_PAT_MOD 'u'
339# define DEPENDS_PAT_MOD 'd'
340# define ASCII_RESTRICT_PAT_MOD 'a'
341
342# define ONCE_PAT_MODS "o"
343# define KEEPCOPY_PAT_MODS "p"
344# define NOCAPTURE_PAT_MODS "n"
345# define EXEC_PAT_MODS "e"
346# define LOOP_PAT_MODS "gc"
347# define NONDESTRUCT_PAT_MODS "r"
348# define LOCALE_PAT_MODS "l"
349# define UNICODE_PAT_MODS "u"
350# define DEPENDS_PAT_MODS "d"
351# define ASCII_RESTRICT_PAT_MODS "a"
352# define ASCII_MORE_RESTRICT_PAT_MODS "aa"
bcdf7404 353
78fecfc8 354/* This string is expected by regcomp.c to be ordered so that the first
c18d5d15
KW
355 * character is the flag in bit RXf_PMf_STD_PMMOD_SHIFT of extflags; the next
356 * character is bit +1, etc. */
6c5474e8 357# define STD_PAT_MODS "msixxn"
bcdf7404 358
6c5474e8 359# define CHARSET_PAT_MODS ASCII_RESTRICT_PAT_MODS DEPENDS_PAT_MODS LOCALE_PAT_MODS UNICODE_PAT_MODS
94b03d7d 360
78fecfc8 361/* This string is expected by XS_re_regexp_pattern() in universal.c to be ordered
c18d5d15
KW
362 * so that the first character is the flag in bit RXf_PMf_STD_PMMOD_SHIFT of
363 * extflags; the next character is in bit +1, etc. */
6c5474e8 364# define INT_PAT_MODS STD_PAT_MODS KEEPCOPY_PAT_MODS
bcdf7404 365
6c5474e8
KW
366# define EXT_PAT_MODS ONCE_PAT_MODS KEEPCOPY_PAT_MODS NOCAPTURE_PAT_MODS
367# define QR_PAT_MODS STD_PAT_MODS EXT_PAT_MODS CHARSET_PAT_MODS
368# define M_PAT_MODS QR_PAT_MODS LOOP_PAT_MODS
369# define S_PAT_MODS M_PAT_MODS EXEC_PAT_MODS NONDESTRUCT_PAT_MODS
bcdf7404 370
cb5027f2 371/*
eb2624c9
FC
372 * NOTE: if you modify any RXf flags you should run regen.pl or
373 * regen/regcomp.pl so that regnodes.h is updated with the changes.
cb5027f2
YO
374 *
375 */
bcdf7404 376
dbc200c5 377/*
5012eebe
DM
378 Set in Perl_pmruntime for a split. Will be used by regex engines to
379 check whether they should set RXf_SKIPWHITE
dbc200c5 380*/
6c5474e8 381# define RXf_SPLIT RXf_PMf_SPLIT
32f62247 382
0bd51918
KW
383/* Currently the regex flags occupy a single 32-bit word. Not all bits are
384 * currently used. The lower bits are shared with their corresponding PMf flag
385 * bits, up to but not including _RXf_PMf_SHIFT_NEXT. The unused bits
386 * immediately follow; finally the used RXf-only (unshared) bits, so that the
387 * highest bit in the word is used. This gathers all the unused bits as a pool
388 * in the middle, like so: 11111111111111110000001111111111
389 * where the '1's represent used bits, and the '0's unused. This design allows
390 * us to allocate off one end of the pool if we need to add a shared bit, and
391 * off the other end if we need a non-shared bit, without disturbing the other
392 * bits. This maximizes the likelihood of being able to change things without
393 * breaking binary compatibility.
394 *
395 * To add shared bits, do so in op_reg_common.h. This should change
396 * _RXf_PMf_SHIFT_NEXT so that things won't compile. Then come to regexp.h and
397 * op.h and adjust the constant adders in the definitions of RXf_BASE_SHIFT and
398 * Pmf_BASE_SHIFT down by the number of shared bits you added. That's it.
399 * Things should be binary compatible. But if either of these gets to having
400 * to subtract rather than add, leave at 0 and instead adjust all the entries
401 * that are in terms of it. But if the first one of those is already
402 * RXf_BASE_SHIFT+0, there are no bits left, and a redesign is in order.
403 *
404 * To remove unshared bits, just delete its entry. If you're where breaking
405 * binary compatibility is ok to do, you might want to adjust things to move
406 * the newly opened space so that it gets absorbed into the common pool.
407 *
408 * To add unshared bits, first use up any gaps in the middle. Otherwise,
409 * allocate off the low end until you get to RXf_BASE_SHIFT+0. If that isn't
410 * enough, move RXf_BASE_SHIFT down (if possible) and add the new bit at the
411 * other end instead; this preserves binary compatibility.
412 *
413 * For the regexp bits, PL_reg_extflags_name[] in regnodes.h has a comment
414 * giving which bits are used/unused */
415
6c5474e8 416# define RXf_BASE_SHIFT (_RXf_PMf_SHIFT_NEXT + 2)
52d81aa8 417
bbe252da 418/* What we have seen */
6c5474e8
KW
419# define RXf_NO_INPLACE_SUBST (1U<<(RXf_BASE_SHIFT+2))
420# define RXf_EVAL_SEEN (1U<<(RXf_BASE_SHIFT+3))
bbe252da
YO
421
422/* Special */
6c5474e8
KW
423# define RXf_UNBOUNDED_QUANTIFIER_SEEN (1U<<(RXf_BASE_SHIFT+4))
424# define RXf_CHECK_ALL (1U<<(RXf_BASE_SHIFT+5))
bbe252da
YO
425
426/* UTF8 related */
6c5474e8 427# define RXf_MATCH_UTF8 (1U<<(RXf_BASE_SHIFT+6)) /* $1 etc are utf8 */
bbe252da
YO
428
429/* Intuit related */
6c5474e8
KW
430# define RXf_USE_INTUIT_NOML (1U<<(RXf_BASE_SHIFT+7))
431# define RXf_USE_INTUIT_ML (1U<<(RXf_BASE_SHIFT+8))
432# define RXf_INTUIT_TAIL (1U<<(RXf_BASE_SHIFT+9))
433# define RXf_USE_INTUIT (RXf_USE_INTUIT_NOML|RXf_USE_INTUIT_ML)
bbe252da 434
a3b51d37 435/* Do we have some sort of anchor? */
6c5474e8 436# define RXf_IS_ANCHORED (1U<<(RXf_BASE_SHIFT+10))
a3b51d37 437
bbe252da 438/* Copy and tainted info */
6c5474e8 439# define RXf_COPY_DONE (1U<<(RXf_BASE_SHIFT+11))
ef07e810 440
1738e041 441/* post-execution: $1 et al are tainted */
6c5474e8 442# define RXf_TAINTED_SEEN (1U<<(RXf_BASE_SHIFT+12))
ef07e810 443/* this pattern was tainted during compilation */
6c5474e8 444# define RXf_TAINTED (1U<<(RXf_BASE_SHIFT+13))
52d81aa8
NC
445
446/* Flags indicating special patterns */
6c5474e8
KW
447# define RXf_START_ONLY (1U<<(RXf_BASE_SHIFT+14)) /* Pattern is /^/ */
448# define RXf_SKIPWHITE (1U<<(RXf_BASE_SHIFT+15)) /* Pattern is for a */
9cba692b 449 /* split " " */
6c5474e8
KW
450# define RXf_WHITE (1U<<(RXf_BASE_SHIFT+16)) /* Pattern is /\s+/ */
451# define RXf_NULL (1U<<(RXf_BASE_SHIFT+17)) /* Pattern is // */
0bd51918
KW
452
453/* See comments at the beginning of these defines about adding bits. The
454 * highest bit position should be used, so that if RXf_BASE_SHIFT gets
455 * increased, the #error below will be triggered so that you will be reminded
456 * to adjust things at the other end to keep the bit positions unchanged */
6c5474e8
KW
457# if RXf_BASE_SHIFT+17 > 31
458# error Too many RXf_PMf bits used. See comments at beginning of these for what to do
459# endif
c737faaf 460
cb5027f2 461/*
eb2624c9
FC
462 * NOTE: if you modify any RXf flags you should run regen.pl or
463 * regen/regcomp.pl so that regnodes.h is updated with the changes.
cb5027f2
YO
464 *
465 */
bbe252da 466
6c5474e8
KW
467# ifdef NO_TAINT_SUPPORT
468# define RX_ISTAINTED(rx_sv) 0
469# define RXp_ISTAINTED(prog) 0
470# define RX_TAINT_on(rx_sv) NOOP
471# define RXp_MATCH_TAINTED(prog) 0
472# define RX_MATCH_TAINTED(rx_sv) 0
473# define RXp_MATCH_TAINTED_on(prog) NOOP
474# define RX_MATCH_TAINTED_on(rx_sv) NOOP
475# define RXp_MATCH_TAINTED_off(prog) NOOP
476# define RX_MATCH_TAINTED_off(rx_sv) NOOP
477# else
478# define RX_ISTAINTED(rx_sv) (RX_EXTFLAGS(rx_sv) & RXf_TAINTED)
479# define RXp_ISTAINTED(prog) (RXp_EXTFLAGS(prog) & RXf_TAINTED)
480# define RX_TAINT_on(rx_sv) (RX_EXTFLAGS(rx_sv) |= RXf_TAINTED)
481# define RXp_MATCH_TAINTED(prog) (RXp_EXTFLAGS(prog) & RXf_TAINTED_SEEN)
482# define RX_MATCH_TAINTED(rx_sv) (RX_EXTFLAGS(rx_sv) & RXf_TAINTED_SEEN)
483# define RXp_MATCH_TAINTED_on(prog) (RXp_EXTFLAGS(prog) |= RXf_TAINTED_SEEN)
484# define RX_MATCH_TAINTED_on(rx_sv) (RX_EXTFLAGS(rx_sv) |= RXf_TAINTED_SEEN)
485# define RXp_MATCH_TAINTED_off(prog) (RXp_EXTFLAGS(prog) &= ~RXf_TAINTED_SEEN)
486# define RX_MATCH_TAINTED_off(rx_sv) (RX_EXTFLAGS(rx_sv) &= ~RXf_TAINTED_SEEN)
487# endif
488
489# define RXp_HAS_CUTGROUP(prog) ((prog)->intflags & PREGf_CUTGROUP_SEEN)
490
491# define RX_MATCH_TAINTED_set(rx_sv, t) ((t) \
a885a8e0
DM
492 ? RX_MATCH_TAINTED_on(rx_sv) \
493 : RX_MATCH_TAINTED_off(rx_sv))
494
6c5474e8
KW
495# define RXp_MATCH_COPIED(prog) (RXp_EXTFLAGS(prog) & RXf_COPY_DONE)
496# define RX_MATCH_COPIED(rx_sv) (RX_EXTFLAGS(rx_sv) & RXf_COPY_DONE)
497# define RXp_MATCH_COPIED_on(prog) (RXp_EXTFLAGS(prog) |= RXf_COPY_DONE)
498# define RX_MATCH_COPIED_on(rx_sv) (RX_EXTFLAGS(rx_sv) |= RXf_COPY_DONE)
499# define RXp_MATCH_COPIED_off(prog) (RXp_EXTFLAGS(prog) &= ~RXf_COPY_DONE)
500# define RX_MATCH_COPIED_off(rx_sv) (RX_EXTFLAGS(rx_sv) &= ~RXf_COPY_DONE)
501# define RX_MATCH_COPIED_set(rx_sv,t) ((t) \
a885a8e0
DM
502 ? RX_MATCH_COPIED_on(rx_sv) \
503 : RX_MATCH_COPIED_off(rx_sv))
504
6c5474e8
KW
505# define RXp_EXTFLAGS(rx) ((rx)->extflags)
506# define RXp_COMPFLAGS(rx) ((rx)->compflags)
866c78d1 507
07bc277f 508/* For source compatibility. We used to store these explicitly. */
6c5474e8 509# define RX_PRECOMP(rx_sv) (RX_WRAPPED(rx_sv) \
a885a8e0 510 + ReANY(rx_sv)->pre_prefix)
6c5474e8 511# define RX_PRECOMP_const(rx_sv) (RX_WRAPPED_const(rx_sv) \
a885a8e0 512 + ReANY(rx_sv)->pre_prefix)
5509d87a
NC
513/* FIXME? Are we hardcoding too much here and constraining plugin extension
514 writers? Specifically, the value 1 assumes that the wrapped version always
515 has exactly one character at the end, a ')'. Will that always be true? */
6c5474e8 516# define RX_PRELEN(rx_sv) (RX_WRAPLEN(rx_sv) \
a885a8e0
DM
517 - ReANY(rx_sv)->pre_prefix - 1)
518
6c5474e8
KW
519# define RX_WRAPPED(rx_sv) SvPVX(rx_sv)
520# define RX_WRAPPED_const(rx_sv) SvPVX_const(rx_sv)
521# define RX_WRAPLEN(rx_sv) SvCUR(rx_sv)
522# define RX_CHECK_SUBSTR(rx_sv) (ReANY(rx_sv)->check_substr)
523# define RX_REFCNT(rx_sv) SvREFCNT(rx_sv)
524# define RX_EXTFLAGS(rx_sv) RXp_EXTFLAGS(ReANY(rx_sv))
525# define RX_COMPFLAGS(rx_sv) RXp_COMPFLAGS(ReANY(rx_sv))
526# define RXp_ENGINE(prog) ((prog)->engine)
527# define RX_ENGINE(rx_sv) (RXp_ENGINE(ReANY(rx_sv)))
528# define RXp_SUBBEG(prog) (prog->subbeg)
529# define RX_SUBBEG(rx_sv) (RXp_SUBBEG(ReANY(rx_sv)))
530# define RXp_SUBOFFSET(prog) (prog->suboffset)
531# define RX_SUBOFFSET(rx_sv) (RXp_SUBOFFSET(ReANY(rx_sv)))
532# define RX_SUBCOFFSET(rx_sv) (ReANY(rx_sv)->subcoffset)
533# define RXp_OFFS(prog) (prog->offs)
534# define RX_OFFS(rx_sv) (RXp_OFFS(ReANY(rx_sv)))
535# define RXp_NPARENS(prog) (prog->nparens)
536# define RX_NPARENS(rx_sv) (RXp_NPARENS(ReANY(rx_sv)))
537# define RX_SUBLEN(rx_sv) (ReANY(rx_sv)->sublen)
538# define RXp_MINLEN(prog) (prog->minlen)
539# define RX_MINLEN(rx_sv) (RXp_MINLEN(ReANY(rx_sv)))
540# define RXp_MINLENRET(prog) (prog->minlenret)
541# define RX_MINLENRET(rx_sv) (RXp_MINLENRET(ReANY(rx_sv)))
542# define RXp_GOFS(prog) (prog->gofs)
543# define RX_GOFS(rx_sv) (RXp_GOFS(ReANY(rx_sv)))
544# define RX_LASTPAREN(rx_sv) (ReANY(rx_sv)->lastparen)
545# define RX_LASTCLOSEPAREN(rx_sv) (ReANY(rx_sv)->lastcloseparen)
546# define RXp_SAVED_COPY(prog) (prog->saved_copy)
547# define RX_SAVED_COPY(rx_sv) (RXp_SAVED_COPY(ReANY(rx_sv)))
03c83e26 548/* last match was zero-length */
6c5474e8 549# define RXp_ZERO_LEN(prog) \
196a02af
DM
550 (RXp_OFFS(prog)[0].start + (SSize_t)RXp_GOFS(prog) \
551 == RXp_OFFS(prog)[0].end)
6c5474e8 552# define RX_ZERO_LEN(rx_sv) (RXp_ZERO_LEN(ReANY(rx_sv)))
220fc49f 553
be8e71aa
YO
554#endif /* PLUGGABLE_RE_EXTENSION */
555
486ec47a 556/* Stuff that needs to be included in the pluggable extension goes below here */
be8e71aa 557
db2c6cb3 558#ifdef PERL_ANY_COW
6c5474e8 559# define RXp_MATCH_COPY_FREE(prog) \
196a02af
DM
560 STMT_START {if (RXp_SAVED_COPY(prog)) { \
561 SV_CHECK_THINKFIRST_COW_DROP(RXp_SAVED_COPY(prog)); \
ed252734 562 } \
196a02af
DM
563 if (RXp_MATCH_COPIED(prog)) { \
564 Safefree(RXp_SUBBEG(prog)); \
565 RXp_MATCH_COPIED_off(prog); \
ed252734
NC
566 }} STMT_END
567#else
6c5474e8 568# define RXp_MATCH_COPY_FREE(prog) \
196a02af
DM
569 STMT_START {if (RXp_MATCH_COPIED(prog)) { \
570 Safefree(RXp_SUBBEG(prog)); \
571 RXp_MATCH_COPIED_off(prog); \
ed252734
NC
572 }} STMT_END
573#endif
a8cb1947 574#define RX_MATCH_COPY_FREE(rx_sv) RXp_MATCH_COPY_FREE(ReANY(rx_sv))
ed252734 575
a885a8e0
DM
576#define RXp_MATCH_UTF8(prog) (RXp_EXTFLAGS(prog) & RXf_MATCH_UTF8)
577#define RX_MATCH_UTF8(rx_sv) (RX_EXTFLAGS(rx_sv) & RXf_MATCH_UTF8)
196a02af 578#define RXp_MATCH_UTF8_on(prog) (RXp_EXTFLAGS(prog) |= RXf_MATCH_UTF8)
97f6857b 579#define RX_MATCH_UTF8_on(rx_sv) (RXp_MATCH_UTF8_on(ReANY(rx_sv)))
196a02af
DM
580#define RXp_MATCH_UTF8_off(prog) (RXp_EXTFLAGS(prog) &= ~RXf_MATCH_UTF8)
581#define RX_MATCH_UTF8_off(rx_sv) (RXp_MATCH_UTF8_off(ReANY(rx_sv))
582#define RXp_MATCH_UTF8_set(prog, t) ((t) \
583 ? RXp_MATCH_UTF8_on(prog) \
584 : RXp_MATCH_UTF8_off(prog))
585#define RX_MATCH_UTF8_set(rx_sv, t) (RXp_MATCH_UTF8_set(ReANY(rx_sv), t))
efd26800
NC
586
587/* Whether the pattern stored at RX_WRAPPED is in UTF-8 */
a885a8e0 588#define RX_UTF8(rx_sv) SvUTF8(rx_sv)
7948fc08 589
a340edde
DM
590
591/* bits in flags arg of Perl_regexec_flags() */
592
593#define REXEC_COPY_STR 0x01 /* Need to copy the string for captures. */
594#define REXEC_CHECKED 0x02 /* re_intuit_start() already called. */
595#define REXEC_SCREAM 0x04 /* currently unused. */
596#define REXEC_IGNOREPOS 0x08 /* use stringarg, not pos(), for \G match */
597#define REXEC_NOT_FIRST 0x10 /* This is another iteration of //g:
598 no need to copy string again */
599
600 /* under REXEC_COPY_STR, it's ok for the
601 engine (modulo PL_sawamperand etc)
602 to skip copying: ... */
603#define REXEC_COPY_SKIP_PRE 0x20 /* ...the $` part of the string, or */
604#define REXEC_COPY_SKIP_POST 0x40 /* ...the $' part of the string */
d5e7783a
DM
605#define REXEC_FAIL_ON_UNDERFLOW 0x80 /* fail the match if $& would start before
606 the start pos (so s/.\G// would fail
607 on second iteration */
c277df42 608
041c1a23 609#if defined(PERL_USE_GCC_BRACE_GROUPS)
288b8c02
NC
610# define ReREFCNT_inc(re) \
611 ({ \
612 /* This is here to generate a casting warning if incorrect. */ \
7948fc08
RU
613 REGEXP *const _rerefcnt_inc = (re); \
614 assert(SvTYPE(_rerefcnt_inc) == SVt_REGEXP); \
615 SvREFCNT_inc(_rerefcnt_inc); \
616 _rerefcnt_inc; \
288b8c02
NC
617 })
618# define ReREFCNT_dec(re) \
619 ({ \
620 /* This is here to generate a casting warning if incorrect. */ \
7948fc08
RU
621 REGEXP *const _rerefcnt_dec = (re); \
622 SvREFCNT_dec(_rerefcnt_dec); \
288b8c02
NC
623 })
624#else
625# define ReREFCNT_dec(re) SvREFCNT_dec(re)
b7e0bd9e 626# define ReREFCNT_inc(re) ((REGEXP *) SvREFCNT_inc(re))
288b8c02 627#endif
c9182d9c 628#define ReANY(re) Perl_ReANY((const REGEXP *)(re))
288b8c02
NC
629
630/* FIXME for plugins. */
cf93c79d
IZ
631
632#define FBMcf_TAIL_DOLLAR 1
cad2e5aa
JH
633#define FBMcf_TAIL_DOLLARM 2
634#define FBMcf_TAIL_Z 4
635#define FBMcf_TAIL_z 8
636#define FBMcf_TAIL (FBMcf_TAIL_DOLLAR|FBMcf_TAIL_DOLLARM|FBMcf_TAIL_Z|FBMcf_TAIL_z)
cf93c79d
IZ
637
638#define FBMrf_MULTILINE 1
cad2e5aa 639
331b2dcc
DM
640struct regmatch_state;
641struct regmatch_slab;
8adc0f72 642
bf2039a9
DM
643/* like regmatch_info_aux, but contains extra fields only needed if the
644 * pattern contains (?{}). If used, is snuck into the second slot in the
645 * regmatch_state stack at the start of execution */
8adc0f72
DM
646
647typedef struct {
648 regexp *rex;
649 PMOP *curpm; /* saved PL_curpm */
650#ifdef PERL_ANY_COW
651 SV *saved_copy; /* saved saved_copy field from rex */
652#endif
653 char *subbeg; /* saved subbeg field from rex */
654 STRLEN sublen; /* saved sublen field from rex */
655 STRLEN suboffset; /* saved suboffset field from rex */
656 STRLEN subcoffset; /* saved subcoffset field from rex */
1d48e83d 657 SV *sv; /* $_ during (?{}) */
8adc0f72 658 MAGIC *pos_magic; /* pos() magic attached to $_ */
ea3daa5d 659 SSize_t pos; /* the original value of pos() in pos_magic */
25fdce4a 660 U8 pos_flags; /* flags to be restored; currently only MGf_BYTES*/
bf2039a9
DM
661} regmatch_info_aux_eval;
662
663
664/* fields that logically live in regmatch_info, but which need cleaning
665 * up on croak(), and so are instead are snuck into the first slot in
666 * the regmatch_state stack at the start of execution */
667
668typedef struct {
669 regmatch_info_aux_eval *info_aux_eval;
331b2dcc
DM
670 struct regmatch_state *old_regmatch_state; /* saved PL_regmatch_state */
671 struct regmatch_slab *old_regmatch_slab; /* saved PL_regmatch_slab */
2ac8ff4b 672 char *poscache; /* S-L cache of fail positions of WHILEMs */
bf2039a9
DM
673} regmatch_info_aux;
674
8adc0f72 675
3b0527fe 676/* some basic information about the current match that is created by
bf2039a9
DM
677 * Perl_regexec_flags and then passed to regtry(), regmatch() etc.
678 * It is allocated as a local var on the stack, so nothing should be
679 * stored in it that needs preserving or clearing up on croak().
680 * For that, see the aux_info and aux_info_eval members of the
681 * regmatch_state union. */
3b0527fe
DM
682
683typedef struct {
28d03b21 684 REGEXP *prog; /* the regex being executed */
9d9163fb 685 const char * strbeg; /* real start of string */
28d03b21
DM
686 char *strend; /* one byte beyond last char of match string */
687 char *till; /* matches shorter than this fail (see minlen arg) */
688 SV *sv; /* the SV string currently being matched */
689 char *ganch; /* position of \G anchor */
690 char *cutpoint; /* (*COMMIT) position (if any) */
bf2039a9
DM
691 regmatch_info_aux *info_aux; /* extra fields that need cleanup */
692 regmatch_info_aux_eval *info_aux_eval; /* extra saved state for (?{}) */
1cb48e53
DM
693 I32 poscache_maxiter; /* how many whilems todo before S-L cache kicks in */
694 I32 poscache_iter; /* current countdown from _maxiter to zero */
2ac8ff4b 695 STRLEN poscache_size; /* size of regmatch_info_aux.poscache */
02d5137b 696 bool intuit; /* re_intuit_start() is the top-level caller */
ba44c216
DM
697 bool is_utf8_pat; /* regex is utf8 */
698 bool is_utf8_target; /* string being matched is utf8 */
39819bd9 699 bool warned; /* we have issued a recursion warning; no need for more */
3b0527fe
DM
700} regmatch_info;
701
5d9a96ca
DM
702
703/* structures for holding and saving the state maintained by regmatch() */
704
d56b3014 705#ifndef MAX_RECURSE_EVAL_NOCHANGE_DEPTH
6c5474e8 706# define MAX_RECURSE_EVAL_NOCHANGE_DEPTH 10
d56b3014 707#endif
6bda09f9 708
5d9a96ca
DM
709typedef I32 CHECKPOINT;
710
a0374537 711typedef struct regmatch_state {
40a82448 712 int resume_state; /* where to jump to on return */
24d3c4a9 713 char *locinput; /* where to backtrack in string on failure */
fd1dd2eb 714 char *loceol;
8e9f3eef 715 U8 *sr0; /* position of start of script run, or NULL */
e822a8b4
DM
716
717 union {
77cb431f 718
bf2039a9
DM
719 /* the 'info_aux' and 'info_aux_eval' union members are cuckoos in
720 * the nest. They aren't saved backtrack state; rather they
721 * represent one or two extra chunks of data that need allocating
722 * at the start of a match. These fields would logically live in
723 * the regmatch_info struct, except that is allocated on the
724 * C stack, and these fields are all things that require cleanup
725 * after a croak(), when the stack is lost.
726 * As a convenience, we just use the first 1 or 2 regmatch_state
727 * slots to store this info, as we will be allocating a slab of
728 * these anyway. Otherwise we'd have to malloc and then free them,
729 * or allocate them on the save stack (where they will get
730 * realloced if the save stack grows).
731 * info_aux contains the extra fields that are always needed;
732 * info_aux_eval contains extra fields that only needed if
733 * the pattern contains code blocks
734 * We split them into two separate structs to avoid increasing
735 * the size of the union.
736 */
737
738 regmatch_info_aux info_aux;
739
740 regmatch_info_aux_eval info_aux_eval;
741
77cb431f
DM
742 /* this is a fake union member that matches the first element
743 * of each member that needs to store positive backtrack
744 * information */
745 struct {
746 struct regmatch_state *prev_yes_state;
747 } yes;
748
fae667d5
YO
749 /* branchlike members */
750 /* this is a fake union member that matches the first elements
751 * of each member that needs to behave like a branch */
752 struct {
5d458dd8
YO
753 /* this first element must match u.yes */
754 struct regmatch_state *prev_yes_state;
fae667d5 755 U32 lastparen;
f6033a9d 756 U32 lastcloseparen;
fae667d5
YO
757 CHECKPOINT cp;
758
759 } branchlike;
760
761 struct {
762 /* the first elements must match u.branchlike */
763 struct regmatch_state *prev_yes_state;
764 U32 lastparen;
f6033a9d 765 U32 lastcloseparen;
fae667d5
YO
766 CHECKPOINT cp;
767
768 regnode *next_branch; /* next branch node */
769 } branch;
770
771 struct {
772 /* the first elements must match u.branchlike */
773 struct regmatch_state *prev_yes_state;
774 U32 lastparen;
f6033a9d 775 U32 lastcloseparen;
fae667d5
YO
776 CHECKPOINT cp;
777
2e64971a 778 U32 accepted; /* how many accepting states left */
6603fe3e 779 bool longfold;/* saw a fold with a 1->n char mapping */
7f69552c 780 U16 *jump; /* positive offsets from me */
7f69552c 781 regnode *me; /* Which node am I - needed for jump tries*/
2e64971a
DM
782 U8 *firstpos;/* pos in string of first trie match */
783 U32 firstchars;/* len in chars of firstpos from start */
784 U16 nextword;/* next word to try */
785 U16 topword; /* longest accepted word */
e822a8b4
DM
786 } trie;
787
fae667d5
YO
788 /* special types - these members are used to store state for special
789 regops like eval, if/then, lookaround and the markpoint state */
e822a8b4 790 struct {
77cb431f
DM
791 /* this first element must match u.yes */
792 struct regmatch_state *prev_yes_state;
faec1544 793 struct regmatch_state *prev_curlyx;
d1c49ad5 794 struct regmatch_state *prev_eval;
288b8c02 795 REGEXP *prev_rex;
aa283a38
DM
796 CHECKPOINT cp; /* remember current savestack indexes */
797 CHECKPOINT lastcp;
24be3102 798 U32 close_paren; /* which close bracket is our end (+1) */
1b5c067c 799 regnode *B; /* the node following us */
ba6840fb 800 char *prev_recurse_locinput;
e822a8b4
DM
801 } eval;
802
803 struct {
c476f425 804 /* this first element must match u.yes */
262b90c4 805 struct regmatch_state *prev_yes_state;
fae667d5
YO
806 I32 wanted;
807 I32 logical; /* saved copy of 'logical' var */
2abbd513
KW
808 U8 count; /* number of beginning positions */
809 char *start;
810 char *end;
fae667d5
YO
811 regnode *me; /* the IFMATCH/SUSPEND/UNLESSM node */
812 } ifmatch; /* and SUSPEND/UNLESSM */
813
814 struct {
815 /* this first element must match u.yes */
816 struct regmatch_state *prev_yes_state;
817 struct regmatch_state *prev_mark;
818 SV* mark_name;
819 char *mark_loc;
820 } mark;
821
822 struct {
823 int val;
824 } keeper;
825
826 /* quantifiers - these members are used for storing state for
a3815e44 827 the regops used to implement quantifiers */
fae667d5
YO
828 struct {
829 /* this first element must match u.yes */
830 struct regmatch_state *prev_yes_state;
c476f425 831 struct regmatch_state *prev_curlyx; /* previous cur_curlyx */
d02d6d97
DM
832 regnode *me; /* the CURLYX node */
833 regnode *B; /* the B node in /A*B/ */
c476f425
DM
834 CHECKPOINT cp; /* remember current savestack index */
835 bool minmod;
a0374537 836 int parenfloor;/* how far back to strip paren data */
c476f425
DM
837
838 /* these two are modified by WHILEM */
839 int count; /* how many instances of A we've matched */
840 char *lastloc;/* where previous A matched (0-len detect) */
e822a8b4
DM
841 } curlyx;
842
843 struct {
c476f425 844 /* this first element must match u.yes */
262b90c4 845 struct regmatch_state *prev_yes_state;
c476f425
DM
846 struct regmatch_state *save_curlyx;
847 CHECKPOINT cp; /* remember current savestack indexes */
848 CHECKPOINT lastcp;
849 char *save_lastloc; /* previous curlyx.lastloc */
850 I32 cache_offset;
851 I32 cache_mask;
e822a8b4
DM
852 } whilem;
853
854 struct {
5d458dd8
YO
855 /* this first element must match u.yes */
856 struct regmatch_state *prev_yes_state;
79a2a0e8 857 int c1, c2; /* case fold search */
40a82448 858 CHECKPOINT cp;
f6033a9d
DM
859 U32 lastparen;
860 U32 lastcloseparen;
40a82448
DM
861 I32 alen; /* length of first-matched A string */
862 I32 count;
0cadcf80 863 bool minmod;
40a82448
DM
864 regnode *A, *B; /* the nodes corresponding to /A*B/ */
865 regnode *me; /* the curlym node */
79a2a0e8
KW
866 U8 c1_utf8[UTF8_MAXBYTES+1]; /* */
867 U8 c2_utf8[UTF8_MAXBYTES+1];
e822a8b4
DM
868 } curlym;
869
870 struct {
3b6647e0 871 U32 paren;
c255a977 872 CHECKPOINT cp;
f6033a9d
DM
873 U32 lastparen;
874 U32 lastcloseparen;
79a2a0e8 875 int c1, c2; /* case fold search */
c255a977
DM
876 char *maxpos; /* highest possible point in string to match */
877 char *oldloc; /* the previous locinput */
e822a8b4 878 int count;
c255a977
DM
879 int min, max; /* {m,n} */
880 regnode *A, *B; /* the nodes corresponding to /A*B/ */
79a2a0e8
KW
881 U8 c1_utf8[UTF8_MAXBYTES+1]; /* */
882 U8 c2_utf8[UTF8_MAXBYTES+1];
c255a977 883 } curly; /* and CURLYN/PLUS/STAR */
dad79028 884
d8319b27 885 } u;
5d9a96ca
DM
886} regmatch_state;
887
ce12e254 888
d5a00e4a 889
5d9a96ca
DM
890/* how many regmatch_state structs to allocate as a single slab.
891 * We do it in 4K blocks for efficiency. The "3" is 2 for the next/prev
892 * pointers, plus 1 for any mythical malloc overhead. */
893
894#define PERL_REGMATCH_SLAB_SLOTS \
895 ((4096 - 3 * sizeof (void*)) / sizeof(regmatch_state))
896
897typedef struct regmatch_slab {
898 regmatch_state states[PERL_REGMATCH_SLAB_SLOTS];
899 struct regmatch_slab *prev, *next;
900} regmatch_slab;
1ade1aa1 901
46ab3289 902
cde0cee5 903
1ade1aa1 904/*
14d04a33 905 * ex: set ts=8 sts=4 sw=4 et:
1ade1aa1 906 */