This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
in re_op_compile(), keep code_blocks for qr//
[perl5.git] / regexp.h
1 /*    regexp.h
2  *
3  *    Copyright (C) 1993, 1994, 1996, 1997, 1999, 2000, 2001, 2003,
4  *    2005, 2006, 2007, 2008 by Larry Wall and others
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  *
9  */
10
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  */
17 #ifndef PLUGGABLE_RE_EXTENSION
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'*/
20
21 struct regnode {
22     U8  flags;
23     U8  type;
24     U16 next_off;
25 };
26
27 typedef struct regnode regnode;
28
29 struct reg_substr_data;
30
31 struct reg_data;
32
33 struct regexp_engine;
34 struct regexp;
35
36 struct reg_substr_datum {
37     I32 min_offset;
38     I32 max_offset;
39     SV *substr;         /* non-utf8 variant */
40     SV *utf8_substr;    /* utf8 variant */
41     I32 end_shift;
42 };
43 struct reg_substr_data {
44     struct reg_substr_datum data[3];    /* Actual array */
45 };
46
47 #ifdef PERL_OLD_COPY_ON_WRITE
48 #define SV_SAVED_COPY   SV *saved_copy; /* If non-NULL, SV which is COW from original */
49 #else
50 #define SV_SAVED_COPY
51 #endif
52
53 typedef struct regexp_paren_pair {
54     I32 start;
55     I32 end;
56 } regexp_paren_pair;
57
58 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_UTF8_C)
59 #define _invlist_union(a, b, output) _invlist_union_maybe_complement_2nd(a, b, FALSE, output)
60 #define _invlist_intersection(a, b, output) _invlist_intersection_maybe_complement_2nd(a, b, FALSE, output)
61
62 /* Subtracting b from a leaves in a everything that was there that isn't in b,
63  * that is the intersection of a with b's complement */
64 #define _invlist_subtract(a, b, output) _invlist_intersection_maybe_complement_2nd(a, b, TRUE, output)
65 #endif
66
67 /* record the position of a (?{...}) within a pattern */
68
69 struct reg_code_block {
70     STRLEN start;
71     STRLEN end;
72     OP     *block;
73 };
74
75
76 /*
77   The regexp/REGEXP struct, see L<perlreapi> for further documentation
78   on the individual fields. The struct is ordered so that the most
79   commonly used fields are placed at the start.
80
81   Any patch that adds items to this struct will need to include
82   changes to F<sv.c> (C<Perl_re_dup()>) and F<regcomp.c>
83   (C<pregfree()>). This involves freeing or cloning items in the
84   regexp's data array based on the data item's type.
85 */
86
87 #define _REGEXP_COMMON                                                  \
88         /* what engine created this regexp? */                          \
89         const struct regexp_engine* engine;                             \
90         REGEXP *mother_re; /* what re is this a lightweight copy of? */ \
91         HV *paren_names;   /* Optional hash of paren names */           \
92         /* Information about the match that the perl core uses to */    \
93         /* manage things */                                             \
94         U32 extflags;   /* Flags used both externally and internally */ \
95         I32 minlen;     /* mininum possible length of string to match */\
96         I32 minlenret;  /* mininum possible length of $& */             \
97         U32 gofs;       /* chars left of pos that we search from */     \
98         /* substring data about strings that must appear in the */      \
99         /* final match, used for optimisations */                       \
100         struct reg_substr_data *substrs;                                \
101         U32 nparens;    /* number of capture buffers */                 \
102         /* private engine specific data */                              \
103         U32 intflags;   /* Engine Specific Internal flags */            \
104         void *pprivate; /* Data private to the regex engine which */    \
105                         /* created this object. */                      \
106         /* Data about the last/current match. These are modified */     \
107         /* during matching */                                           \
108         U32 lastparen;                  /* last open paren matched */   \
109         U32 lastcloseparen;             /* last close paren matched */  \
110         regexp_paren_pair *swap;        /* Unused: 5.10.1 and later */  \
111         /* Array of offsets for (@-) and (@+) */                        \
112         regexp_paren_pair *offs;                                        \
113         /* saved or original string so \digit works forever. */         \
114         char *subbeg;                                                   \
115         SV_SAVED_COPY   /* If non-NULL, SV which is COW from original */\
116         I32 sublen;     /* Length of string pointed by subbeg */        \
117         /* Information about the match that isn't often used */         \
118         /* offset from wrapped to the start of precomp */               \
119         PERL_BITFIELD32 pre_prefix:4;                                   \
120         /* number of eval groups in the pattern - for security checks */\
121         PERL_BITFIELD32 seen_evals:28;                                  \
122         CV *qr_anoncv;  /* the anon sub wrapped round qr/(?{..})/ */    \
123
124 typedef struct regexp {
125         _XPV_HEAD;
126         _REGEXP_COMMON;
127 } regexp;
128
129 #define RXp_PAREN_NAMES(rx)     ((rx)->paren_names)
130
131 /* used for high speed searches */
132 typedef struct re_scream_pos_data_s
133 {
134     char **scream_olds;         /* match pos */
135     I32 *scream_pos;            /* Internal iterator of scream. */
136 } re_scream_pos_data;
137
138 /* regexp_engine structure. This is the dispatch table for regexes.
139  * Any regex engine implementation must be able to build one of these.
140  */
141 typedef struct regexp_engine {
142     REGEXP* (*comp) (pTHX_ SV * const pattern, U32 flags);
143     I32     (*exec) (pTHX_ REGEXP * const rx, char* stringarg, char* strend,
144                      char* strbeg, I32 minend, SV* screamer,
145                      void* data, U32 flags);
146     char*   (*intuit) (pTHX_ REGEXP * const rx, SV *sv, char *strpos,
147                        char *strend, const U32 flags,
148                        re_scream_pos_data *data);
149     SV*     (*checkstr) (pTHX_ REGEXP * const rx);
150     void    (*free) (pTHX_ REGEXP * const rx);
151     void    (*numbered_buff_FETCH) (pTHX_ REGEXP * const rx, const I32 paren,
152                                     SV * const sv);
153     void    (*numbered_buff_STORE) (pTHX_ REGEXP * const rx, const I32 paren,
154                                    SV const * const value);
155     I32     (*numbered_buff_LENGTH) (pTHX_ REGEXP * const rx, const SV * const sv,
156                                     const I32 paren);
157     SV*     (*named_buff) (pTHX_ REGEXP * const rx, SV * const key,
158                            SV * const value, const U32 flags);
159     SV*     (*named_buff_iter) (pTHX_ REGEXP * const rx, const SV * const lastkey,
160                                 const U32 flags);
161     SV*     (*qr_package)(pTHX_ REGEXP * const rx);
162 #ifdef USE_ITHREADS
163     void*   (*dupe) (pTHX_ REGEXP * const rx, CLONE_PARAMS *param);
164 #endif
165 } regexp_engine;
166
167 /*
168   These are passed to the numbered capture variable callbacks as the
169   paren name. >= 1 is reserved for actual numbered captures, i.e. $1,
170   $2 etc.
171 */
172 #define RX_BUFF_IDX_PREMATCH  -2 /* $` / ${^PREMATCH}  */
173 #define RX_BUFF_IDX_POSTMATCH -1 /* $' / ${^POSTMATCH} */
174 #define RX_BUFF_IDX_FULLMATCH      0 /* $& / ${^MATCH}     */
175
176 /*
177   Flags that are passed to the named_buff and named_buff_iter
178   callbacks above. Those routines are called from universal.c via the
179   Tie::Hash::NamedCapture interface for %+ and %- and the re::
180   functions in the same file.
181 */
182
183 /* The Tie::Hash::NamedCapture operation this is part of, if any */
184 #define RXapif_FETCH     0x0001
185 #define RXapif_STORE     0x0002
186 #define RXapif_DELETE    0x0004
187 #define RXapif_CLEAR     0x0008
188 #define RXapif_EXISTS    0x0010
189 #define RXapif_SCALAR    0x0020
190 #define RXapif_FIRSTKEY  0x0040
191 #define RXapif_NEXTKEY   0x0080
192
193 /* Whether %+ or %- is being operated on */
194 #define RXapif_ONE       0x0100 /* %+ */
195 #define RXapif_ALL       0x0200 /* %- */
196
197 /* Whether this is being called from a re:: function */
198 #define RXapif_REGNAME         0x0400
199 #define RXapif_REGNAMES        0x0800
200 #define RXapif_REGNAMES_COUNT  0x1000
201
202 /*
203 =head1 REGEXP Functions
204
205 =for apidoc Am|REGEXP *|SvRX|SV *sv
206
207 Convenience macro to get the REGEXP from a SV. This is approximately
208 equivalent to the following snippet:
209
210     if (SvMAGICAL(sv))
211         mg_get(sv);
212     if (SvROK(sv))
213         sv = MUTABLE_SV(SvRV(sv));
214     if (SvTYPE(sv) == SVt_REGEXP)
215         return (REGEXP*) sv;
216
217 NULL will be returned if a REGEXP* is not found.
218
219 =for apidoc Am|bool|SvRXOK|SV* sv
220
221 Returns a boolean indicating whether the SV (or the one it references)
222 is a REGEXP.
223
224 If you want to do something with the REGEXP* later use SvRX instead
225 and check for NULL.
226
227 =cut
228 */
229
230 #define SvRX(sv)   (Perl_get_re_arg(aTHX_ sv))
231 #define SvRXOK(sv) (Perl_get_re_arg(aTHX_ sv) ? TRUE : FALSE)
232
233
234 /* Flags stored in regexp->extflags
235  * These are used by code external to the regexp engine
236  *
237  * Note that the flags whose names start with RXf_PMf_ are defined in
238  * op_reg_common.h, being copied from the parallel flags of op_pmflags
239  *
240  * NOTE: if you modify any RXf flags you should run regen.pl or
241  * regen/regcomp.pl so that regnodes.h is updated with the changes.
242  *
243  */
244
245 #include "op_reg_common.h"
246
247 #define RXf_PMf_STD_PMMOD       (RXf_PMf_MULTILINE|RXf_PMf_SINGLELINE|RXf_PMf_FOLD|RXf_PMf_EXTENDED)
248
249 #define CASE_STD_PMMOD_FLAGS_PARSE_SET(pmfl)                        \
250     case IGNORE_PAT_MOD:    *(pmfl) |= RXf_PMf_FOLD;       break;   \
251     case MULTILINE_PAT_MOD: *(pmfl) |= RXf_PMf_MULTILINE;  break;   \
252     case SINGLE_PAT_MOD:    *(pmfl) |= RXf_PMf_SINGLELINE; break;   \
253     case XTENDED_PAT_MOD:   *(pmfl) |= RXf_PMf_EXTENDED;   break
254
255 /* Note, includes charset ones, assumes 0 is the default for them */
256 #define STD_PMMOD_FLAGS_CLEAR(pmfl)                        \
257     *(pmfl) &= ~(RXf_PMf_FOLD|RXf_PMf_MULTILINE|RXf_PMf_SINGLELINE|RXf_PMf_EXTENDED|RXf_PMf_CHARSET)
258
259 /* chars and strings used as regex pattern modifiers
260  * Singular is a 'c'har, plural is a "string"
261  *
262  * NOTE, KEEPCOPY was originally 'k', but was changed to 'p' for preserve
263  * for compatibility reasons with Regexp::Common which highjacked (?k:...)
264  * for its own uses. So 'k' is out as well.
265  */
266 #define DEFAULT_PAT_MOD      '^'    /* Short for all the default modifiers */
267 #define EXEC_PAT_MOD         'e'
268 #define KEEPCOPY_PAT_MOD     'p'
269 #define ONCE_PAT_MOD         'o'
270 #define GLOBAL_PAT_MOD       'g'
271 #define CONTINUE_PAT_MOD     'c'
272 #define MULTILINE_PAT_MOD    'm'
273 #define SINGLE_PAT_MOD       's'
274 #define IGNORE_PAT_MOD       'i'
275 #define XTENDED_PAT_MOD      'x'
276 #define NONDESTRUCT_PAT_MOD  'r'
277 #define LOCALE_PAT_MOD       'l'
278 #define UNICODE_PAT_MOD      'u'
279 #define DEPENDS_PAT_MOD      'd'
280 #define ASCII_RESTRICT_PAT_MOD 'a'
281
282 #define ONCE_PAT_MODS        "o"
283 #define KEEPCOPY_PAT_MODS    "p"
284 #define EXEC_PAT_MODS        "e"
285 #define LOOP_PAT_MODS        "gc"
286 #define NONDESTRUCT_PAT_MODS "r"
287 #define LOCALE_PAT_MODS      "l"
288 #define UNICODE_PAT_MODS     "u"
289 #define DEPENDS_PAT_MODS     "d"
290 #define ASCII_RESTRICT_PAT_MODS "a"
291 #define ASCII_MORE_RESTRICT_PAT_MODS "aa"
292
293 /* This string is expected by regcomp.c to be ordered so that the first
294  * character is the flag in bit RXf_PMf_STD_PMMOD_SHIFT of extflags; the next
295  * character is bit +1, etc. */
296 #define STD_PAT_MODS        "msix"
297
298 #define CHARSET_PAT_MODS    ASCII_RESTRICT_PAT_MODS DEPENDS_PAT_MODS LOCALE_PAT_MODS UNICODE_PAT_MODS
299
300 /* This string is expected by XS_re_regexp_pattern() in universal.c to be ordered
301  * so that the first character is the flag in bit RXf_PMf_STD_PMMOD_SHIFT of
302  * extflags; the next character is in bit +1, etc. */
303 #define INT_PAT_MODS    STD_PAT_MODS    KEEPCOPY_PAT_MODS
304
305 #define EXT_PAT_MODS    ONCE_PAT_MODS   KEEPCOPY_PAT_MODS
306 #define QR_PAT_MODS     STD_PAT_MODS    EXT_PAT_MODS       CHARSET_PAT_MODS
307 #define M_PAT_MODS      QR_PAT_MODS     LOOP_PAT_MODS
308 #define S_PAT_MODS      M_PAT_MODS      EXEC_PAT_MODS      NONDESTRUCT_PAT_MODS
309
310 /*
311  * NOTE: if you modify any RXf flags you should run regen.pl or
312  * regen/regcomp.pl so that regnodes.h is updated with the changes.
313  *
314  */
315
316 /* Leave some space, so future bit allocations can go either in the shared or
317  * unshared area without affecting binary compatibility */
318 #define RXf_BASE_SHIFT (_RXf_PMf_SHIFT_NEXT+1)
319
320 /* Manually decorate this function with gcc-style attributes just to
321  * avoid having to restructure the header files and their called order,
322  * as proto.h would have to be included before this file, and isn't */
323
324 PERL_STATIC_INLINE const char *
325 get_regex_charset_name(const U32 flags, STRLEN* const lenp)
326     __attribute__warn_unused_result__;
327
328 #define MAX_CHARSET_NAME_LENGTH 2
329
330 PERL_STATIC_INLINE const char *
331 get_regex_charset_name(const U32 flags, STRLEN* const lenp)
332 {
333     /* Returns a string that corresponds to the name of the regex character set
334      * given by 'flags', and *lenp is set the length of that string, which
335      * cannot exceed MAX_CHARSET_NAME_LENGTH characters */
336
337     *lenp = 1;
338     switch (get_regex_charset(flags)) {
339         case REGEX_DEPENDS_CHARSET: return DEPENDS_PAT_MODS;
340         case REGEX_LOCALE_CHARSET:  return LOCALE_PAT_MODS;
341         case REGEX_UNICODE_CHARSET: return UNICODE_PAT_MODS;
342         case REGEX_ASCII_RESTRICTED_CHARSET: return ASCII_RESTRICT_PAT_MODS;
343         case REGEX_ASCII_MORE_RESTRICTED_CHARSET:
344             *lenp = 2;
345             return ASCII_MORE_RESTRICT_PAT_MODS;
346         default:
347             return "?";     /* Unknown */
348     }
349 }
350
351 /* Anchor and GPOS related stuff */
352 #define RXf_ANCH_BOL            (1<<(RXf_BASE_SHIFT+0))
353 #define RXf_ANCH_MBOL           (1<<(RXf_BASE_SHIFT+1))
354 #define RXf_ANCH_SBOL           (1<<(RXf_BASE_SHIFT+2))
355 #define RXf_ANCH_GPOS           (1<<(RXf_BASE_SHIFT+3))
356 #define RXf_GPOS_SEEN           (1<<(RXf_BASE_SHIFT+4))
357 #define RXf_GPOS_FLOAT          (1<<(RXf_BASE_SHIFT+5))
358 /* two bits here */
359 #define RXf_ANCH                (RXf_ANCH_BOL|RXf_ANCH_MBOL|RXf_ANCH_GPOS|RXf_ANCH_SBOL)
360 #define RXf_GPOS_CHECK          (RXf_GPOS_SEEN|RXf_ANCH_GPOS)
361 #define RXf_ANCH_SINGLE         (RXf_ANCH_SBOL|RXf_ANCH_GPOS)
362
363 /* What we have seen */
364 #define RXf_LOOKBEHIND_SEEN     (1<<(RXf_BASE_SHIFT+6))
365 #define RXf_EVAL_SEEN           (1<<(RXf_BASE_SHIFT+7))
366 #define RXf_CANY_SEEN           (1<<(RXf_BASE_SHIFT+8))
367
368 /* Special */
369 #define RXf_NOSCAN              (1<<(RXf_BASE_SHIFT+9))
370 #define RXf_CHECK_ALL           (1<<(RXf_BASE_SHIFT+10))
371
372 /* UTF8 related */
373 #define RXf_MATCH_UTF8          (1<<(RXf_BASE_SHIFT+11))
374
375 /* Intuit related */
376 #define RXf_USE_INTUIT_NOML     (1<<(RXf_BASE_SHIFT+12))
377 #define RXf_USE_INTUIT_ML       (1<<(RXf_BASE_SHIFT+13))
378 #define RXf_INTUIT_TAIL         (1<<(RXf_BASE_SHIFT+14))
379
380 /*
381   Set in Perl_pmruntime if op_flags & OPf_SPECIAL, i.e. split. Will
382   be used by regex engines to check whether they should set
383   RXf_SKIPWHITE
384 */
385 #define RXf_SPLIT               (1<<(RXf_BASE_SHIFT+15))
386
387 #define RXf_USE_INTUIT          (RXf_USE_INTUIT_NOML|RXf_USE_INTUIT_ML)
388
389 /* Copy and tainted info */
390 #define RXf_COPY_DONE           (1<<(RXf_BASE_SHIFT+16))
391
392 /* during execution: pattern temporarily tainted by executing locale ops;
393  * post-execution: $1 et al are tainted */
394 #define RXf_TAINTED_SEEN        (1<<(RXf_BASE_SHIFT+17))
395 /* this pattern was tainted during compilation */
396 #define RXf_TAINTED             (1<<(RXf_BASE_SHIFT+18))
397
398 /* Flags indicating special patterns */
399 #define RXf_START_ONLY          (1<<(RXf_BASE_SHIFT+19)) /* Pattern is /^/ */
400 #define RXf_SKIPWHITE           (1<<(RXf_BASE_SHIFT+20)) /* Pattern is for a split / / */
401 #define RXf_WHITE               (1<<(RXf_BASE_SHIFT+21)) /* Pattern is /\s+/ */
402 #define RXf_NULL                (1U<<(RXf_BASE_SHIFT+22)) /* Pattern is // */
403 #if RXf_BASE_SHIFT+22 > 31
404 #   error Too many RXf_PMf bits used.  See regnodes.h for any spare in middle
405 #endif
406
407 /*
408  * NOTE: if you modify any RXf flags you should run regen.pl or
409  * regen/regcomp.pl so that regnodes.h is updated with the changes.
410  *
411  */
412
413 #define RX_HAS_CUTGROUP(prog) ((prog)->intflags & PREGf_CUTGROUP_SEEN)
414 #define RXp_MATCH_TAINTED(prog) (RXp_EXTFLAGS(prog) & RXf_TAINTED_SEEN)
415 #define RX_MATCH_TAINTED(prog)  (RX_EXTFLAGS(prog) & RXf_TAINTED_SEEN)
416 #define RX_MATCH_TAINTED_on(prog) (RX_EXTFLAGS(prog) |= RXf_TAINTED_SEEN)
417 #define RX_MATCH_TAINTED_off(prog) (RX_EXTFLAGS(prog) &= ~RXf_TAINTED_SEEN)
418 #define RX_MATCH_TAINTED_set(prog, t) ((t) \
419                                        ? RX_MATCH_TAINTED_on(prog) \
420                                        : RX_MATCH_TAINTED_off(prog))
421
422 #define RXp_MATCH_COPIED(prog)          (RXp_EXTFLAGS(prog) & RXf_COPY_DONE)
423 #define RX_MATCH_COPIED(prog)           (RX_EXTFLAGS(prog) & RXf_COPY_DONE)
424 #define RXp_MATCH_COPIED_on(prog)       (RXp_EXTFLAGS(prog) |= RXf_COPY_DONE)
425 #define RX_MATCH_COPIED_on(prog)        (RX_EXTFLAGS(prog) |= RXf_COPY_DONE)
426 #define RXp_MATCH_COPIED_off(prog)      (RXp_EXTFLAGS(prog) &= ~RXf_COPY_DONE)
427 #define RX_MATCH_COPIED_off(prog)       (RX_EXTFLAGS(prog) &= ~RXf_COPY_DONE)
428 #define RX_MATCH_COPIED_set(prog,t)     ((t) \
429                                          ? RX_MATCH_COPIED_on(prog) \
430                                          : RX_MATCH_COPIED_off(prog))
431
432 #define RXp_EXTFLAGS(rx)        ((rx)->extflags)
433
434 /* For source compatibility. We used to store these explicitly.  */
435 #define RX_PRECOMP(prog)        (RX_WRAPPED(prog) + ((struct regexp *)SvANY(prog))->pre_prefix)
436 #define RX_PRECOMP_const(prog)  (RX_WRAPPED_const(prog) + ((struct regexp *)SvANY(prog))->pre_prefix)
437 /* FIXME? Are we hardcoding too much here and constraining plugin extension
438    writers? Specifically, the value 1 assumes that the wrapped version always
439    has exactly one character at the end, a ')'. Will that always be true?  */
440 #define RX_PRELEN(prog)         (RX_WRAPLEN(prog) - ((struct regexp *)SvANY(prog))->pre_prefix - 1)
441 #define RX_WRAPPED(prog)        SvPVX(prog)
442 #define RX_WRAPPED_const(prog)  SvPVX_const(prog)
443 #define RX_WRAPLEN(prog)        SvCUR(prog)
444 #define RX_CHECK_SUBSTR(prog)   (((struct regexp *)SvANY(prog))->check_substr)
445 #define RX_REFCNT(prog)         SvREFCNT(prog)
446 #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
447 #  define RX_EXTFLAGS(prog)                                             \
448     (*({                                                                \
449         const REGEXP *const _rx_extflags = (prog);                      \
450         assert(SvTYPE(_rx_extflags) == SVt_REGEXP);                     \
451         &RXp_EXTFLAGS(SvANY(_rx_extflags));                             \
452     }))
453 #  define RX_ENGINE(prog)                                               \
454     (*({                                                                \
455         const REGEXP *const _rx_engine = (prog);                        \
456         assert(SvTYPE(_rx_engine) == SVt_REGEXP);                       \
457         &SvANY(_rx_engine)->engine;                                     \
458     }))
459 #  define RX_SUBBEG(prog)                                               \
460     (*({                                                                \
461         const REGEXP *const _rx_subbeg = (prog);                        \
462         assert(SvTYPE(_rx_subbeg) == SVt_REGEXP);                       \
463         &SvANY(_rx_subbeg)->subbeg;                                     \
464     }))
465 #  define RX_OFFS(prog)                                                 \
466     (*({                                                                \
467         const REGEXP *const _rx_offs = (prog);                          \
468         assert(SvTYPE(_rx_offs) == SVt_REGEXP);                         \
469         &SvANY(_rx_offs)->offs;                                         \
470     }))
471 #  define RX_NPARENS(prog)                                              \
472     (*({                                                                \
473         const REGEXP *const _rx_nparens = (prog);                       \
474         assert(SvTYPE(_rx_nparens) == SVt_REGEXP);                      \
475         &SvANY(_rx_nparens)->nparens;                                   \
476     }))
477 #else
478 #  define RX_EXTFLAGS(prog)     RXp_EXTFLAGS((struct regexp *)SvANY(prog))
479 #  define RX_ENGINE(prog)       (((struct regexp *)SvANY(prog))->engine)
480 #  define RX_SUBBEG(prog)       (((struct regexp *)SvANY(prog))->subbeg)
481 #  define RX_OFFS(prog)         (((struct regexp *)SvANY(prog))->offs)
482 #  define RX_NPARENS(prog)      (((struct regexp *)SvANY(prog))->nparens)
483 #endif
484 #define RX_SUBLEN(prog)         (((struct regexp *)SvANY(prog))->sublen)
485 #define RX_MINLEN(prog)         (((struct regexp *)SvANY(prog))->minlen)
486 #define RX_MINLENRET(prog)      (((struct regexp *)SvANY(prog))->minlenret)
487 #define RX_GOFS(prog)           (((struct regexp *)SvANY(prog))->gofs)
488 #define RX_LASTPAREN(prog)      (((struct regexp *)SvANY(prog))->lastparen)
489 #define RX_LASTCLOSEPAREN(prog) (((struct regexp *)SvANY(prog))->lastcloseparen)
490 #define RX_SEEN_EVALS(prog)     (((struct regexp *)SvANY(prog))->seen_evals)
491 #define RX_SAVED_COPY(prog)     (((struct regexp *)SvANY(prog))->saved_copy)
492
493 #endif /* PLUGGABLE_RE_EXTENSION */
494
495 /* Stuff that needs to be included in the pluggable extension goes below here */
496
497 #ifdef PERL_OLD_COPY_ON_WRITE
498 #define RX_MATCH_COPY_FREE(rx) \
499         STMT_START {if (RX_SAVED_COPY(rx)) { \
500             SV_CHECK_THINKFIRST_COW_DROP(RX_SAVED_COPY(rx)); \
501         } \
502         if (RX_MATCH_COPIED(rx)) { \
503             Safefree(RX_SUBBEG(rx)); \
504             RX_MATCH_COPIED_off(rx); \
505         }} STMT_END
506 #else
507 #define RX_MATCH_COPY_FREE(rx) \
508         STMT_START {if (RX_MATCH_COPIED(rx)) { \
509             Safefree(RX_SUBBEG(rx)); \
510             RX_MATCH_COPIED_off(rx); \
511         }} STMT_END
512 #endif
513
514 #define RXp_MATCH_UTF8(prog)            (RXp_EXTFLAGS(prog) & RXf_MATCH_UTF8)
515 #define RX_MATCH_UTF8(prog)             (RX_EXTFLAGS(prog) & RXf_MATCH_UTF8)
516 #define RX_MATCH_UTF8_on(prog)          (RX_EXTFLAGS(prog) |= RXf_MATCH_UTF8)
517 #define RX_MATCH_UTF8_off(prog)         (RX_EXTFLAGS(prog) &= ~RXf_MATCH_UTF8)
518 #define RX_MATCH_UTF8_set(prog, t)      ((t) \
519                         ? (RX_MATCH_UTF8_on(prog), (PL_reg_match_utf8 = 1)) \
520                         : (RX_MATCH_UTF8_off(prog), (PL_reg_match_utf8 = 0)))
521
522 /* Whether the pattern stored at RX_WRAPPED is in UTF-8  */
523 #define RX_UTF8(prog)                   SvUTF8(prog)
524
525 #define REXEC_COPY_STR  0x01            /* Need to copy the string. */
526 #define REXEC_CHECKED   0x02            /* check_substr already checked. */
527 #define REXEC_SCREAM    0x04            /* use scream table. */
528 #define REXEC_IGNOREPOS 0x08            /* \G matches at start. */
529 #define REXEC_NOT_FIRST 0x10            /* This is another iteration of //g. */
530
531 #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
532 #  define ReREFCNT_inc(re)                                              \
533     ({                                                                  \
534         /* This is here to generate a casting warning if incorrect.  */ \
535         REGEXP *const _rerefcnt_inc = (re);                             \
536         assert(SvTYPE(_rerefcnt_inc) == SVt_REGEXP);                    \
537         SvREFCNT_inc(_rerefcnt_inc);                                    \
538         _rerefcnt_inc;                                                  \
539     })
540 #  define ReREFCNT_dec(re)                                              \
541     ({                                                                  \
542         /* This is here to generate a casting warning if incorrect.  */ \
543         REGEXP *const _rerefcnt_dec = (re);                             \
544         SvREFCNT_dec(_rerefcnt_dec);                                    \
545     })
546 #else
547 #  define ReREFCNT_dec(re)      SvREFCNT_dec(re)
548 #  define ReREFCNT_inc(re)      ((REGEXP *) SvREFCNT_inc(re))
549 #endif
550
551 /* FIXME for plugins. */
552
553 #define FBMcf_TAIL_DOLLAR       1
554 #define FBMcf_TAIL_DOLLARM      2
555 #define FBMcf_TAIL_Z            4
556 #define FBMcf_TAIL_z            8
557 #define FBMcf_TAIL              (FBMcf_TAIL_DOLLAR|FBMcf_TAIL_DOLLARM|FBMcf_TAIL_Z|FBMcf_TAIL_z)
558
559 #define FBMrf_MULTILINE 1
560
561 /* some basic information about the current match that is created by
562  * Perl_regexec_flags and then passed to regtry(), regmatch() etc */
563
564 typedef struct {
565     REGEXP *prog;
566     char *bol;
567     char *till;
568     SV *sv;
569     char *ganch;
570     char *cutpoint;
571 } regmatch_info;
572  
573
574 /* structures for holding and saving the state maintained by regmatch() */
575
576 #ifndef MAX_RECURSE_EVAL_NOCHANGE_DEPTH
577 #define MAX_RECURSE_EVAL_NOCHANGE_DEPTH 1000
578 #endif
579
580 typedef I32 CHECKPOINT;
581
582 typedef struct regmatch_state {
583     int resume_state;           /* where to jump to on return */
584     char *locinput;             /* where to backtrack in string on failure */
585
586     union {
587
588         /* this is a fake union member that matches the first element
589          * of each member that needs to store positive backtrack
590          * information */
591         struct {
592             struct regmatch_state *prev_yes_state;
593         } yes;
594
595         /* branchlike members */
596         /* this is a fake union member that matches the first elements
597          * of each member that needs to behave like a branch */
598         struct {
599             /* this first element must match u.yes */
600             struct regmatch_state *prev_yes_state;
601             U32 lastparen;
602             CHECKPOINT cp;
603             
604         } branchlike;
605                     
606         struct {
607             /* the first elements must match u.branchlike */
608             struct regmatch_state *prev_yes_state;
609             U32 lastparen;
610             CHECKPOINT cp;
611             
612             regnode *next_branch; /* next branch node */
613         } branch;
614
615         struct {
616             /* the first elements must match u.branchlike */
617             struct regmatch_state *prev_yes_state;
618             U32 lastparen;
619             CHECKPOINT cp;
620
621             U32         accepted; /* how many accepting states left */
622             U16         *jump;  /* positive offsets from me */
623             regnode     *B;     /* node following the trie */
624             regnode     *me;    /* Which node am I - needed for jump tries*/
625             U8          *firstpos;/* pos in string of first trie match */
626             U32         firstchars;/* len in chars of firstpos from start */
627             U16         nextword;/* next word to try */
628             U16         topword; /* longest accepted word */
629             bool        longfold;/* saw a fold with a 1->n char mapping */
630         } trie;
631
632         /* special types - these members are used to store state for special
633            regops like eval, if/then, lookaround and the markpoint state */
634         struct {
635             /* this first element must match u.yes */
636             struct regmatch_state *prev_yes_state;
637             struct regmatch_state *prev_eval;
638             struct regmatch_state *prev_curlyx;
639             REGEXP      *prev_rex;
640             U32         toggle_reg_flags; /* what bits in PL_reg_flags to
641                                             flip when transitioning between
642                                             inner and outer rexen */
643             CHECKPOINT  cp;     /* remember current savestack indexes */
644             CHECKPOINT  lastcp;
645             U32        close_paren; /* which close bracket is our end */
646             regnode     *B;     /* the node following us  */
647         } eval;
648
649         struct {
650             /* this first element must match u.yes */
651             struct regmatch_state *prev_yes_state;
652             I32 wanted;
653             I32 logical;        /* saved copy of 'logical' var */
654             regnode  *me; /* the IFMATCH/SUSPEND/UNLESSM node  */
655         } ifmatch; /* and SUSPEND/UNLESSM */
656         
657         struct {
658             /* this first element must match u.yes */
659             struct regmatch_state *prev_yes_state;
660             struct regmatch_state *prev_mark;
661             SV* mark_name;
662             char *mark_loc;
663         } mark;
664         
665         struct {
666             int val;
667         } keeper;
668
669         /* quantifiers - these members are used for storing state for
670            for the regops used to implement quantifiers */
671         struct {
672             /* this first element must match u.yes */
673             struct regmatch_state *prev_yes_state;
674             struct regmatch_state *prev_curlyx; /* previous cur_curlyx */
675             regnode     *me;    /* the CURLYX node  */
676             regnode     *B;     /* the B node in /A*B/  */
677             CHECKPOINT  cp;     /* remember current savestack index */
678             bool        minmod;
679             int         parenfloor;/* how far back to strip paren data */
680
681             /* these two are modified by WHILEM */
682             int         count;  /* how many instances of A we've matched */
683             char        *lastloc;/* where previous A matched (0-len detect) */
684         } curlyx;
685
686         struct {
687             /* this first element must match u.yes */
688             struct regmatch_state *prev_yes_state;
689             struct regmatch_state *save_curlyx;
690             CHECKPOINT  cp;     /* remember current savestack indexes */
691             CHECKPOINT  lastcp;
692             char        *save_lastloc;  /* previous curlyx.lastloc */
693             I32         cache_offset;
694             I32         cache_mask;
695         } whilem;
696
697         struct {
698             /* this first element must match u.yes */
699             struct regmatch_state *prev_yes_state;
700             I32 c1, c2;         /* case fold search */
701             CHECKPOINT cp;
702             I32 alen;           /* length of first-matched A string */
703             I32 count;
704             bool minmod;
705             regnode *A, *B;     /* the nodes corresponding to /A*B/  */
706             regnode *me;        /* the curlym node */
707         } curlym;
708
709         struct {
710             U32 paren;
711             CHECKPOINT cp;
712             I32 c1, c2;         /* case fold search */
713             char *maxpos;       /* highest possible point in string to match */
714             char *oldloc;       /* the previous locinput */
715             int count;
716             int min, max;       /* {m,n} */
717             regnode *A, *B;     /* the nodes corresponding to /A*B/  */
718         } curly; /* and CURLYN/PLUS/STAR */
719
720     } u;
721 } regmatch_state;
722
723 /* how many regmatch_state structs to allocate as a single slab.
724  * We do it in 4K blocks for efficiency. The "3" is 2 for the next/prev
725  * pointers, plus 1 for any mythical malloc overhead. */
726  
727 #define PERL_REGMATCH_SLAB_SLOTS \
728     ((4096 - 3 * sizeof (void*)) / sizeof(regmatch_state))
729
730 typedef struct regmatch_slab {
731     regmatch_state states[PERL_REGMATCH_SLAB_SLOTS];
732     struct regmatch_slab *prev, *next;
733 } regmatch_slab;
734
735 #define PL_reg_flags            PL_reg_state.re_state_reg_flags
736 #define PL_bostr                PL_reg_state.re_state_bostr
737 #define PL_reginput             PL_reg_state.re_state_reginput
738 #define PL_regeol               PL_reg_state.re_state_regeol
739 #define PL_regoffs              PL_reg_state.re_state_regoffs
740 #define PL_reglastparen         PL_reg_state.re_state_reglastparen
741 #define PL_reglastcloseparen    PL_reg_state.re_state_reglastcloseparen
742 #define PL_reg_start_tmp        PL_reg_state.re_state_reg_start_tmp
743 #define PL_reg_start_tmpl       PL_reg_state.re_state_reg_start_tmpl
744 #define PL_reg_eval_set         PL_reg_state.re_state_reg_eval_set
745 #define PL_reg_match_utf8       PL_reg_state.re_state_reg_match_utf8
746 #define PL_reg_magic            PL_reg_state.re_state_reg_magic
747 #define PL_reg_oldpos           PL_reg_state.re_state_reg_oldpos
748 #define PL_reg_oldcurpm         PL_reg_state.re_state_reg_oldcurpm
749 #define PL_reg_curpm            PL_reg_state.re_state_reg_curpm
750 #define PL_reg_oldsaved         PL_reg_state.re_state_reg_oldsaved
751 #define PL_reg_oldsavedlen      PL_reg_state.re_state_reg_oldsavedlen
752 #define PL_reg_maxiter          PL_reg_state.re_state_reg_maxiter
753 #define PL_reg_leftiter         PL_reg_state.re_state_reg_leftiter
754 #define PL_reg_poscache         PL_reg_state.re_state_reg_poscache
755 #define PL_reg_poscache_size    PL_reg_state.re_state_reg_poscache_size
756 #define PL_regsize              PL_reg_state.re_state_regsize
757 #define PL_reg_starttry         PL_reg_state.re_state_reg_starttry
758 #define PL_nrs                  PL_reg_state.re_state_nrs
759
760 struct re_save_state {
761     U32 re_state_reg_flags;             /* from regexec.c */
762     U32 re_state_reg_start_tmpl;        /* from regexec.c */
763     I32 re_state_reg_eval_set;          /* from regexec.c */
764     bool re_state_reg_match_utf8;       /* from regexec.c */
765     char *re_state_bostr;
766     char *re_state_reginput;            /* String-input pointer. */
767     char *re_state_regeol;              /* End of input, for $ check. */
768     regexp_paren_pair *re_state_regoffs;  /* Pointer to start/end pairs */
769     U32 *re_state_reglastparen;         /* Similarly for lastparen. */
770     U32 *re_state_reglastcloseparen;    /* Similarly for lastcloseparen. */
771     char **re_state_reg_start_tmp;      /* from regexec.c */
772     MAGIC *re_state_reg_magic;          /* from regexec.c */
773     PMOP *re_state_reg_oldcurpm;        /* from regexec.c */
774     PMOP *re_state_reg_curpm;           /* from regexec.c */
775     char *re_state_reg_oldsaved;        /* old saved substr during match */
776     STRLEN re_state_reg_oldsavedlen;    /* old length of saved substr during match */
777     STRLEN re_state_reg_poscache_size;  /* size of pos cache of WHILEM */
778     I32 re_state_reg_oldpos;            /* from regexec.c */
779     I32 re_state_reg_maxiter;           /* max wait until caching pos */
780     I32 re_state_reg_leftiter;          /* wait until caching pos */
781     U32 re_state_regsize;               /* from regexec.c */
782     char *re_state_reg_poscache;        /* cache of pos of WHILEM */
783     char *re_state_reg_starttry;        /* from regexec.c */
784 #ifdef PERL_OLD_COPY_ON_WRITE
785     SV *re_state_nrs;                   /* was placeholder: unused since 5.8.0 (5.7.2 patch #12027 for bug ID 20010815.012). Used to save rx->saved_copy */
786 #endif
787 };
788
789 #define SAVESTACK_ALLOC_FOR_RE_SAVE_STATE \
790         (1 + ((sizeof(struct re_save_state) - 1) / sizeof(*PL_savestack)))
791
792 /*
793  * Local variables:
794  * c-indentation-style: bsd
795  * c-basic-offset: 4
796  * indent-tabs-mode: nil
797  * End:
798  *
799  * ex: set ts=8 sts=4 sw=4 et:
800  */