]> git.vpit.fr Git - perl/modules/re-engine-Hooks.git/blob - regcomp.c
4a37b6ad98cbe8b9c1eb3df0417fd44263d5bcd8
[perl/modules/re-engine-Hooks.git] / regcomp.c
1 /*    regcomp.c
2  */
3
4 /*
5  * 'A fair jaw-cracker dwarf-language must be.'            --Samwise Gamgee
6  *
7  *     [p.285 of _The Lord of the Rings_, II/iii: "The Ring Goes South"]
8  */
9
10 /* This file contains functions for compiling a regular expression.  See
11  * also regexec.c which funnily enough, contains functions for executing
12  * a regular expression.
13  *
14  * This file is also copied at build time to ext/re/re_comp.c, where
15  * it's built with -DPERL_EXT_RE_BUILD -DPERL_EXT_RE_DEBUG -DPERL_EXT.
16  * This causes the main functions to be compiled under new names and with
17  * debugging support added, which makes "use re 'debug'" work.
18  */
19
20 /* NOTE: this is derived from Henry Spencer's regexp code, and should not
21  * confused with the original package (see point 3 below).  Thanks, Henry!
22  */
23
24 /* Additional note: this code is very heavily munged from Henry's version
25  * in places.  In some spots I've traded clarity for efficiency, so don't
26  * blame Henry for some of the lack of readability.
27  */
28
29 /* The names of the functions have been changed from regcomp and
30  * regexec to pregcomp and pregexec in order to avoid conflicts
31  * with the POSIX routines of the same names.
32 */
33
34 #ifdef PERL_EXT_RE_BUILD
35 #include "re_top.h"
36 #endif
37
38 /*
39  * pregcomp and pregexec -- regsub and regerror are not used in perl
40  *
41  *      Copyright (c) 1986 by University of Toronto.
42  *      Written by Henry Spencer.  Not derived from licensed software.
43  *
44  *      Permission is granted to anyone to use this software for any
45  *      purpose on any computer system, and to redistribute it freely,
46  *      subject to the following restrictions:
47  *
48  *      1. The author is not responsible for the consequences of use of
49  *              this software, no matter how awful, even if they arise
50  *              from defects in it.
51  *
52  *      2. The origin of this software must not be misrepresented, either
53  *              by explicit claim or by omission.
54  *
55  *      3. Altered versions must be plainly marked as such, and must not
56  *              be misrepresented as being the original software.
57  *
58  *
59  ****    Alterations to Henry's code are...
60  ****
61  ****    Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
62  ****    2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
63  ****    by Larry Wall and others
64  ****
65  ****    You may distribute under the terms of either the GNU General Public
66  ****    License or the Artistic License, as specified in the README file.
67
68  *
69  * Beware that some of this code is subtly aware of the way operator
70  * precedence is structured in regular expressions.  Serious changes in
71  * regular-expression syntax might require a total rethink.
72  */
73 #include "EXTERN.h"
74 #define PERL_IN_REGCOMP_C
75 #include "perl.h"
76
77 #ifndef PERL_IN_XSUB_RE
78 #  include "INTERN.h"
79 #endif
80
81 #define REG_COMP_C
82 #ifdef PERL_IN_XSUB_RE
83 #  include "re_comp.h"
84 EXTERN_C const struct regexp_engine my_reg_engine;
85 #else
86 #  include "regcomp.h"
87 #endif
88
89 #include "dquote_static.c"
90 #include "inline_invlist.c"
91 #include "unicode_constants.h"
92
93 #define HAS_NONLATIN1_FOLD_CLOSURE(i) \
94  _HAS_NONLATIN1_FOLD_CLOSURE_ONLY_FOR_USE_BY_REGCOMP_DOT_C_AND_REGEXEC_DOT_C(i)
95 #define HAS_NONLATIN1_SIMPLE_FOLD_CLOSURE(i) \
96  _HAS_NONLATIN1_SIMPLE_FOLD_CLOSURE_ONLY_FOR_USE_BY_REGCOMP_DOT_C_AND_REGEXEC_DOT_C(i)
97 #define IS_NON_FINAL_FOLD(c) _IS_NON_FINAL_FOLD_ONLY_FOR_USE_BY_REGCOMP_DOT_C(c)
98 #define IS_IN_SOME_FOLD_L1(c) _IS_IN_SOME_FOLD_ONLY_FOR_USE_BY_REGCOMP_DOT_C(c)
99
100 #ifndef STATIC
101 #define STATIC  static
102 #endif
103
104 #ifndef MIN
105 #define MIN(a,b) ((a) < (b) ? (a) : (b))
106 #endif
107
108 /* this is a chain of data about sub patterns we are processing that
109    need to be handled separately/specially in study_chunk. Its so
110    we can simulate recursion without losing state.  */
111 struct scan_frame;
112 typedef struct scan_frame {
113     regnode *last_regnode;      /* last node to process in this frame */
114     regnode *next_regnode;      /* next node to process when last is reached */
115     U32 prev_recursed_depth;
116     I32 stopparen;              /* what stopparen do we use */
117     U32 is_top_frame;           /* what flags do we use? */
118
119     struct scan_frame *this_prev_frame; /* this previous frame */
120     struct scan_frame *prev_frame;      /* previous frame */
121     struct scan_frame *next_frame;      /* next frame */
122 } scan_frame;
123
124 /* Certain characters are output as a sequence with the first being a
125  * backslash. */
126 #define isBACKSLASHED_PUNCT(c)                                              \
127                     ((c) == '-' || (c) == ']' || (c) == '\\' || (c) == '^')
128
129
130 struct RExC_state_t {
131     U32         flags;                  /* RXf_* are we folding, multilining? */
132     U32         pm_flags;               /* PMf_* stuff from the calling PMOP */
133     char        *precomp;               /* uncompiled string. */
134     REGEXP      *rx_sv;                 /* The SV that is the regexp. */
135     regexp      *rx;                    /* perl core regexp structure */
136     regexp_internal     *rxi;           /* internal data for regexp object
137                                            pprivate field */
138     char        *start;                 /* Start of input for compile */
139     char        *end;                   /* End of input for compile */
140     char        *parse;                 /* Input-scan pointer. */
141     SSize_t     whilem_seen;            /* number of WHILEM in this expr */
142     regnode     *emit_start;            /* Start of emitted-code area */
143     regnode     *emit_bound;            /* First regnode outside of the
144                                            allocated space */
145     regnode     *emit;                  /* Code-emit pointer; if = &emit_dummy,
146                                            implies compiling, so don't emit */
147     regnode_ssc emit_dummy;             /* placeholder for emit to point to;
148                                            large enough for the largest
149                                            non-EXACTish node, so can use it as
150                                            scratch in pass1 */
151     I32         naughty;                /* How bad is this pattern? */
152     I32         sawback;                /* Did we see \1, ...? */
153     U32         seen;
154     SSize_t     size;                   /* Code size. */
155     I32                npar;            /* Capture buffer count, (OPEN) plus
156                                            one. ("par" 0 is the whole
157                                            pattern)*/
158     I32         nestroot;               /* root parens we are in - used by
159                                            accept */
160     I32         extralen;
161     I32         seen_zerolen;
162     regnode     **open_parens;          /* pointers to open parens */
163     regnode     **close_parens;         /* pointers to close parens */
164     regnode     *opend;                 /* END node in program */
165     I32         utf8;           /* whether the pattern is utf8 or not */
166     I32         orig_utf8;      /* whether the pattern was originally in utf8 */
167                                 /* XXX use this for future optimisation of case
168                                  * where pattern must be upgraded to utf8. */
169     I32         uni_semantics;  /* If a d charset modifier should use unicode
170                                    rules, even if the pattern is not in
171                                    utf8 */
172     HV          *paren_names;           /* Paren names */
173
174     regnode     **recurse;              /* Recurse regops */
175     I32         recurse_count;          /* Number of recurse regops */
176     U8          *study_chunk_recursed;  /* bitmap of which subs we have moved
177                                            through */
178     U32         study_chunk_recursed_bytes;  /* bytes in bitmap */
179     I32         in_lookbehind;
180     I32         contains_locale;
181     I32         contains_i;
182     I32         override_recoding;
183 #ifdef EBCDIC
184     I32         recode_x_to_native;
185 #endif
186     I32         in_multi_char_class;
187     struct reg_code_block *code_blocks; /* positions of literal (?{})
188                                             within pattern */
189     int         num_code_blocks;        /* size of code_blocks[] */
190     int         code_index;             /* next code_blocks[] slot */
191     SSize_t     maxlen;                        /* mininum possible number of chars in string to match */
192     scan_frame *frame_head;
193     scan_frame *frame_last;
194     U32         frame_count;
195     U32         strict;
196 #ifdef ADD_TO_REGEXEC
197     char        *starttry;              /* -Dr: where regtry was called. */
198 #define RExC_starttry   (pRExC_state->starttry)
199 #endif
200     SV          *runtime_code_qr;       /* qr with the runtime code blocks */
201 #ifdef DEBUGGING
202     const char  *lastparse;
203     I32         lastnum;
204     AV          *paren_name_list;       /* idx -> name */
205     U32         study_chunk_recursed_count;
206     SV          *mysv1;
207     SV          *mysv2;
208 #define RExC_lastparse  (pRExC_state->lastparse)
209 #define RExC_lastnum    (pRExC_state->lastnum)
210 #define RExC_paren_name_list    (pRExC_state->paren_name_list)
211 #define RExC_study_chunk_recursed_count    (pRExC_state->study_chunk_recursed_count)
212 #define RExC_mysv       (pRExC_state->mysv1)
213 #define RExC_mysv1      (pRExC_state->mysv1)
214 #define RExC_mysv2      (pRExC_state->mysv2)
215
216 #endif
217 };
218
219 #define RExC_flags      (pRExC_state->flags)
220 #define RExC_pm_flags   (pRExC_state->pm_flags)
221 #define RExC_precomp    (pRExC_state->precomp)
222 #define RExC_rx_sv      (pRExC_state->rx_sv)
223 #define RExC_rx         (pRExC_state->rx)
224 #define RExC_rxi        (pRExC_state->rxi)
225 #define RExC_start      (pRExC_state->start)
226 #define RExC_end        (pRExC_state->end)
227 #define RExC_parse      (pRExC_state->parse)
228 #define RExC_whilem_seen        (pRExC_state->whilem_seen)
229 #ifdef RE_TRACK_PATTERN_OFFSETS
230 #define RExC_offsets    (pRExC_state->rxi->u.offsets) /* I am not like the
231                                                          others */
232 #endif
233 #define RExC_emit       (pRExC_state->emit)
234 #define RExC_emit_dummy (pRExC_state->emit_dummy)
235 #define RExC_emit_start (pRExC_state->emit_start)
236 #define RExC_emit_bound (pRExC_state->emit_bound)
237 #define RExC_sawback    (pRExC_state->sawback)
238 #define RExC_seen       (pRExC_state->seen)
239 #define RExC_size       (pRExC_state->size)
240 #define RExC_maxlen        (pRExC_state->maxlen)
241 #define RExC_npar       (pRExC_state->npar)
242 #define RExC_nestroot   (pRExC_state->nestroot)
243 #define RExC_extralen   (pRExC_state->extralen)
244 #define RExC_seen_zerolen       (pRExC_state->seen_zerolen)
245 #define RExC_utf8       (pRExC_state->utf8)
246 #define RExC_uni_semantics      (pRExC_state->uni_semantics)
247 #define RExC_orig_utf8  (pRExC_state->orig_utf8)
248 #define RExC_open_parens        (pRExC_state->open_parens)
249 #define RExC_close_parens       (pRExC_state->close_parens)
250 #define RExC_opend      (pRExC_state->opend)
251 #define RExC_paren_names        (pRExC_state->paren_names)
252 #define RExC_recurse    (pRExC_state->recurse)
253 #define RExC_recurse_count      (pRExC_state->recurse_count)
254 #define RExC_study_chunk_recursed        (pRExC_state->study_chunk_recursed)
255 #define RExC_study_chunk_recursed_bytes  \
256                                    (pRExC_state->study_chunk_recursed_bytes)
257 #define RExC_in_lookbehind      (pRExC_state->in_lookbehind)
258 #define RExC_contains_locale    (pRExC_state->contains_locale)
259 #define RExC_contains_i (pRExC_state->contains_i)
260 #define RExC_override_recoding (pRExC_state->override_recoding)
261 #ifdef EBCDIC
262 #   define RExC_recode_x_to_native (pRExC_state->recode_x_to_native)
263 #endif
264 #define RExC_in_multi_char_class (pRExC_state->in_multi_char_class)
265 #define RExC_frame_head (pRExC_state->frame_head)
266 #define RExC_frame_last (pRExC_state->frame_last)
267 #define RExC_frame_count (pRExC_state->frame_count)
268 #define RExC_strict (pRExC_state->strict)
269
270 /* Heuristic check on the complexity of the pattern: if TOO_NAUGHTY, we set
271  * a flag to disable back-off on the fixed/floating substrings - if it's
272  * a high complexity pattern we assume the benefit of avoiding a full match
273  * is worth the cost of checking for the substrings even if they rarely help.
274  */
275 #define RExC_naughty    (pRExC_state->naughty)
276 #define TOO_NAUGHTY (10)
277 #define MARK_NAUGHTY(add) \
278     if (RExC_naughty < TOO_NAUGHTY) \
279         RExC_naughty += (add)
280 #define MARK_NAUGHTY_EXP(exp, add) \
281     if (RExC_naughty < TOO_NAUGHTY) \
282         RExC_naughty += RExC_naughty / (exp) + (add)
283
284 #define ISMULT1(c)      ((c) == '*' || (c) == '+' || (c) == '?')
285 #define ISMULT2(s)      ((*s) == '*' || (*s) == '+' || (*s) == '?' || \
286         ((*s) == '{' && regcurly(s)))
287
288 /*
289  * Flags to be passed up and down.
290  */
291 #define WORST           0       /* Worst case. */
292 #define HASWIDTH        0x01    /* Known to match non-null strings. */
293
294 /* Simple enough to be STAR/PLUS operand; in an EXACTish node must be a single
295  * character.  (There needs to be a case: in the switch statement in regexec.c
296  * for any node marked SIMPLE.)  Note that this is not the same thing as
297  * REGNODE_SIMPLE */
298 #define SIMPLE          0x02
299 #define SPSTART         0x04    /* Starts with * or + */
300 #define POSTPONED       0x08    /* (?1),(?&name), (??{...}) or similar */
301 #define TRYAGAIN        0x10    /* Weeded out a declaration. */
302 #define RESTART_UTF8    0x20    /* Restart, need to calcuate sizes as UTF-8 */
303
304 #define REG_NODE_NUM(x) ((x) ? (int)((x)-RExC_emit_start) : -1)
305
306 /* whether trie related optimizations are enabled */
307 #if PERL_ENABLE_EXTENDED_TRIE_OPTIMISATION
308 #define TRIE_STUDY_OPT
309 #define FULL_TRIE_STUDY
310 #define TRIE_STCLASS
311 #endif
312
313
314
315 #define PBYTE(u8str,paren) ((U8*)(u8str))[(paren) >> 3]
316 #define PBITVAL(paren) (1 << ((paren) & 7))
317 #define PAREN_TEST(u8str,paren) ( PBYTE(u8str,paren) & PBITVAL(paren))
318 #define PAREN_SET(u8str,paren) PBYTE(u8str,paren) |= PBITVAL(paren)
319 #define PAREN_UNSET(u8str,paren) PBYTE(u8str,paren) &= (~PBITVAL(paren))
320
321 #define REQUIRE_UTF8    STMT_START {                                       \
322                                      if (!UTF) {                           \
323                                          *flagp = RESTART_UTF8;            \
324                                          return NULL;                      \
325                                      }                                     \
326                         } STMT_END
327
328 /* This converts the named class defined in regcomp.h to its equivalent class
329  * number defined in handy.h. */
330 #define namedclass_to_classnum(class)  ((int) ((class) / 2))
331 #define classnum_to_namedclass(classnum)  ((classnum) * 2)
332
333 #define _invlist_union_complement_2nd(a, b, output) \
334                         _invlist_union_maybe_complement_2nd(a, b, TRUE, output)
335 #define _invlist_intersection_complement_2nd(a, b, output) \
336                  _invlist_intersection_maybe_complement_2nd(a, b, TRUE, output)
337
338 /* About scan_data_t.
339
340   During optimisation we recurse through the regexp program performing
341   various inplace (keyhole style) optimisations. In addition study_chunk
342   and scan_commit populate this data structure with information about
343   what strings MUST appear in the pattern. We look for the longest
344   string that must appear at a fixed location, and we look for the
345   longest string that may appear at a floating location. So for instance
346   in the pattern:
347
348     /FOO[xX]A.*B[xX]BAR/
349
350   Both 'FOO' and 'A' are fixed strings. Both 'B' and 'BAR' are floating
351   strings (because they follow a .* construct). study_chunk will identify
352   both FOO and BAR as being the longest fixed and floating strings respectively.
353
354   The strings can be composites, for instance
355
356      /(f)(o)(o)/
357
358   will result in a composite fixed substring 'foo'.
359
360   For each string some basic information is maintained:
361
362   - offset or min_offset
363     This is the position the string must appear at, or not before.
364     It also implicitly (when combined with minlenp) tells us how many
365     characters must match before the string we are searching for.
366     Likewise when combined with minlenp and the length of the string it
367     tells us how many characters must appear after the string we have
368     found.
369
370   - max_offset
371     Only used for floating strings. This is the rightmost point that
372     the string can appear at. If set to SSize_t_MAX it indicates that the
373     string can occur infinitely far to the right.
374
375   - minlenp
376     A pointer to the minimum number of characters of the pattern that the
377     string was found inside. This is important as in the case of positive
378     lookahead or positive lookbehind we can have multiple patterns
379     involved. Consider
380
381     /(?=FOO).*F/
382
383     The minimum length of the pattern overall is 3, the minimum length
384     of the lookahead part is 3, but the minimum length of the part that
385     will actually match is 1. So 'FOO's minimum length is 3, but the
386     minimum length for the F is 1. This is important as the minimum length
387     is used to determine offsets in front of and behind the string being
388     looked for.  Since strings can be composites this is the length of the
389     pattern at the time it was committed with a scan_commit. Note that
390     the length is calculated by study_chunk, so that the minimum lengths
391     are not known until the full pattern has been compiled, thus the
392     pointer to the value.
393
394   - lookbehind
395
396     In the case of lookbehind the string being searched for can be
397     offset past the start point of the final matching string.
398     If this value was just blithely removed from the min_offset it would
399     invalidate some of the calculations for how many chars must match
400     before or after (as they are derived from min_offset and minlen and
401     the length of the string being searched for).
402     When the final pattern is compiled and the data is moved from the
403     scan_data_t structure into the regexp structure the information
404     about lookbehind is factored in, with the information that would
405     have been lost precalculated in the end_shift field for the
406     associated string.
407
408   The fields pos_min and pos_delta are used to store the minimum offset
409   and the delta to the maximum offset at the current point in the pattern.
410
411 */
412
413 typedef struct scan_data_t {
414     /*I32 len_min;      unused */
415     /*I32 len_delta;    unused */
416     SSize_t pos_min;
417     SSize_t pos_delta;
418     SV *last_found;
419     SSize_t last_end;       /* min value, <0 unless valid. */
420     SSize_t last_start_min;
421     SSize_t last_start_max;
422     SV **longest;           /* Either &l_fixed, or &l_float. */
423     SV *longest_fixed;      /* longest fixed string found in pattern */
424     SSize_t offset_fixed;   /* offset where it starts */
425     SSize_t *minlen_fixed;  /* pointer to the minlen relevant to the string */
426     I32 lookbehind_fixed;   /* is the position of the string modfied by LB */
427     SV *longest_float;      /* longest floating string found in pattern */
428     SSize_t offset_float_min; /* earliest point in string it can appear */
429     SSize_t offset_float_max; /* latest point in string it can appear */
430     SSize_t *minlen_float;  /* pointer to the minlen relevant to the string */
431     SSize_t lookbehind_float; /* is the pos of the string modified by LB */
432     I32 flags;
433     I32 whilem_c;
434     SSize_t *last_closep;
435     regnode_ssc *start_class;
436 } scan_data_t;
437
438 /*
439  * Forward declarations for pregcomp()'s friends.
440  */
441
442 static const scan_data_t zero_scan_data =
443   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ,0};
444
445 #define SF_BEFORE_EOL           (SF_BEFORE_SEOL|SF_BEFORE_MEOL)
446 #define SF_BEFORE_SEOL          0x0001
447 #define SF_BEFORE_MEOL          0x0002
448 #define SF_FIX_BEFORE_EOL       (SF_FIX_BEFORE_SEOL|SF_FIX_BEFORE_MEOL)
449 #define SF_FL_BEFORE_EOL        (SF_FL_BEFORE_SEOL|SF_FL_BEFORE_MEOL)
450
451 #define SF_FIX_SHIFT_EOL        (+2)
452 #define SF_FL_SHIFT_EOL         (+4)
453
454 #define SF_FIX_BEFORE_SEOL      (SF_BEFORE_SEOL << SF_FIX_SHIFT_EOL)
455 #define SF_FIX_BEFORE_MEOL      (SF_BEFORE_MEOL << SF_FIX_SHIFT_EOL)
456
457 #define SF_FL_BEFORE_SEOL       (SF_BEFORE_SEOL << SF_FL_SHIFT_EOL)
458 #define SF_FL_BEFORE_MEOL       (SF_BEFORE_MEOL << SF_FL_SHIFT_EOL) /* 0x20 */
459 #define SF_IS_INF               0x0040
460 #define SF_HAS_PAR              0x0080
461 #define SF_IN_PAR               0x0100
462 #define SF_HAS_EVAL             0x0200
463 #define SCF_DO_SUBSTR           0x0400
464 #define SCF_DO_STCLASS_AND      0x0800
465 #define SCF_DO_STCLASS_OR       0x1000
466 #define SCF_DO_STCLASS          (SCF_DO_STCLASS_AND|SCF_DO_STCLASS_OR)
467 #define SCF_WHILEM_VISITED_POS  0x2000
468
469 #define SCF_TRIE_RESTUDY        0x4000 /* Do restudy? */
470 #define SCF_SEEN_ACCEPT         0x8000
471 #define SCF_TRIE_DOING_RESTUDY 0x10000
472 #define SCF_IN_DEFINE          0x20000
473
474
475
476
477 #define UTF cBOOL(RExC_utf8)
478
479 /* The enums for all these are ordered so things work out correctly */
480 #define LOC (get_regex_charset(RExC_flags) == REGEX_LOCALE_CHARSET)
481 #define DEPENDS_SEMANTICS (get_regex_charset(RExC_flags)                    \
482                                                      == REGEX_DEPENDS_CHARSET)
483 #define UNI_SEMANTICS (get_regex_charset(RExC_flags) == REGEX_UNICODE_CHARSET)
484 #define AT_LEAST_UNI_SEMANTICS (get_regex_charset(RExC_flags)                \
485                                                      >= REGEX_UNICODE_CHARSET)
486 #define ASCII_RESTRICTED (get_regex_charset(RExC_flags)                      \
487                                             == REGEX_ASCII_RESTRICTED_CHARSET)
488 #define AT_LEAST_ASCII_RESTRICTED (get_regex_charset(RExC_flags)             \
489                                             >= REGEX_ASCII_RESTRICTED_CHARSET)
490 #define ASCII_FOLD_RESTRICTED (get_regex_charset(RExC_flags)                 \
491                                         == REGEX_ASCII_MORE_RESTRICTED_CHARSET)
492
493 #define FOLD cBOOL(RExC_flags & RXf_PMf_FOLD)
494
495 /* For programs that want to be strictly Unicode compatible by dying if any
496  * attempt is made to match a non-Unicode code point against a Unicode
497  * property.  */
498 #define ALWAYS_WARN_SUPER  ckDEAD(packWARN(WARN_NON_UNICODE))
499
500 #define OOB_NAMEDCLASS          -1
501
502 /* There is no code point that is out-of-bounds, so this is problematic.  But
503  * its only current use is to initialize a variable that is always set before
504  * looked at. */
505 #define OOB_UNICODE             0xDEADBEEF
506
507 #define CHR_SVLEN(sv) (UTF ? sv_len_utf8(sv) : SvCUR(sv))
508 #define CHR_DIST(a,b) (UTF ? utf8_distance(a,b) : a - b)
509
510
511 /* length of regex to show in messages that don't mark a position within */
512 #define RegexLengthToShowInErrorMessages 127
513
514 /*
515  * If MARKER[12] are adjusted, be sure to adjust the constants at the top
516  * of t/op/regmesg.t, the tests in t/op/re_tests, and those in
517  * op/pragma/warn/regcomp.
518  */
519 #define MARKER1 "<-- HERE"    /* marker as it appears in the description */
520 #define MARKER2 " <-- HERE "  /* marker as it appears within the regex */
521
522 #define REPORT_LOCATION " in regex; marked by " MARKER1    \
523                         " in m/%"UTF8f MARKER2 "%"UTF8f"/"
524
525 #define REPORT_LOCATION_ARGS(offset)            \
526                 UTF8fARG(UTF, offset, RExC_precomp), \
527                 UTF8fARG(UTF, RExC_end - RExC_precomp - offset, RExC_precomp + offset)
528
529 /* Used to point after bad bytes for an error message, but avoid skipping
530  * past a nul byte. */
531 #define SKIP_IF_CHAR(s) (!*(s) ? 0 : UTF ? UTF8SKIP(s) : 1)
532
533 /*
534  * Calls SAVEDESTRUCTOR_X if needed, then calls Perl_croak with the given
535  * arg. Show regex, up to a maximum length. If it's too long, chop and add
536  * "...".
537  */
538 #define _FAIL(code) STMT_START {                                        \
539     const char *ellipses = "";                                          \
540     IV len = RExC_end - RExC_precomp;                                   \
541                                                                         \
542     if (!SIZE_ONLY)                                                     \
543         SAVEFREESV(RExC_rx_sv);                                         \
544     if (len > RegexLengthToShowInErrorMessages) {                       \
545         /* chop 10 shorter than the max, to ensure meaning of "..." */  \
546         len = RegexLengthToShowInErrorMessages - 10;                    \
547         ellipses = "...";                                               \
548     }                                                                   \
549     code;                                                               \
550 } STMT_END
551
552 #define FAIL(msg) _FAIL(                            \
553     Perl_croak(aTHX_ "%s in regex m/%"UTF8f"%s/",           \
554             msg, UTF8fARG(UTF, len, RExC_precomp), ellipses))
555
556 #define FAIL2(msg,arg) _FAIL(                       \
557     Perl_croak(aTHX_ msg " in regex m/%"UTF8f"%s/",         \
558             arg, UTF8fARG(UTF, len, RExC_precomp), ellipses))
559
560 /*
561  * Simple_vFAIL -- like FAIL, but marks the current location in the scan
562  */
563 #define Simple_vFAIL(m) STMT_START {                                    \
564     const IV offset =                                                   \
565         (RExC_parse > RExC_end ? RExC_end : RExC_parse) - RExC_precomp; \
566     Perl_croak(aTHX_ "%s" REPORT_LOCATION,                              \
567             m, REPORT_LOCATION_ARGS(offset));   \
568 } STMT_END
569
570 /*
571  * Calls SAVEDESTRUCTOR_X if needed, then Simple_vFAIL()
572  */
573 #define vFAIL(m) STMT_START {                           \
574     if (!SIZE_ONLY)                                     \
575         SAVEFREESV(RExC_rx_sv);                         \
576     Simple_vFAIL(m);                                    \
577 } STMT_END
578
579 /*
580  * Like Simple_vFAIL(), but accepts two arguments.
581  */
582 #define Simple_vFAIL2(m,a1) STMT_START {                        \
583     const IV offset = RExC_parse - RExC_precomp;                        \
584     S_re_croak2(aTHX_ UTF, m, REPORT_LOCATION, a1,                      \
585                       REPORT_LOCATION_ARGS(offset));    \
586 } STMT_END
587
588 /*
589  * Calls SAVEDESTRUCTOR_X if needed, then Simple_vFAIL2().
590  */
591 #define vFAIL2(m,a1) STMT_START {                       \
592     if (!SIZE_ONLY)                                     \
593         SAVEFREESV(RExC_rx_sv);                         \
594     Simple_vFAIL2(m, a1);                               \
595 } STMT_END
596
597
598 /*
599  * Like Simple_vFAIL(), but accepts three arguments.
600  */
601 #define Simple_vFAIL3(m, a1, a2) STMT_START {                   \
602     const IV offset = RExC_parse - RExC_precomp;                \
603     S_re_croak2(aTHX_ UTF, m, REPORT_LOCATION, a1, a2,          \
604             REPORT_LOCATION_ARGS(offset));      \
605 } STMT_END
606
607 /*
608  * Calls SAVEDESTRUCTOR_X if needed, then Simple_vFAIL3().
609  */
610 #define vFAIL3(m,a1,a2) STMT_START {                    \
611     if (!SIZE_ONLY)                                     \
612         SAVEFREESV(RExC_rx_sv);                         \
613     Simple_vFAIL3(m, a1, a2);                           \
614 } STMT_END
615
616 /*
617  * Like Simple_vFAIL(), but accepts four arguments.
618  */
619 #define Simple_vFAIL4(m, a1, a2, a3) STMT_START {               \
620     const IV offset = RExC_parse - RExC_precomp;                \
621     S_re_croak2(aTHX_ UTF, m, REPORT_LOCATION, a1, a2, a3,              \
622             REPORT_LOCATION_ARGS(offset));      \
623 } STMT_END
624
625 #define vFAIL4(m,a1,a2,a3) STMT_START {                 \
626     if (!SIZE_ONLY)                                     \
627         SAVEFREESV(RExC_rx_sv);                         \
628     Simple_vFAIL4(m, a1, a2, a3);                       \
629 } STMT_END
630
631 /* A specialized version of vFAIL2 that works with UTF8f */
632 #define vFAIL2utf8f(m, a1) STMT_START { \
633     const IV offset = RExC_parse - RExC_precomp;   \
634     if (!SIZE_ONLY)                                \
635         SAVEFREESV(RExC_rx_sv);                    \
636     S_re_croak2(aTHX_ UTF, m, REPORT_LOCATION, a1, \
637             REPORT_LOCATION_ARGS(offset));         \
638 } STMT_END
639
640 /* These have asserts in them because of [perl #122671] Many warnings in
641  * regcomp.c can occur twice.  If they get output in pass1 and later in that
642  * pass, the pattern has to be converted to UTF-8 and the pass restarted, they
643  * would get output again.  So they should be output in pass2, and these
644  * asserts make sure new warnings follow that paradigm. */
645
646 /* m is not necessarily a "literal string", in this macro */
647 #define reg_warn_non_literal_string(loc, m) STMT_START {                \
648     const IV offset = loc - RExC_precomp;                               \
649     __ASSERT_(PASS2) Perl_warner(aTHX_ packWARN(WARN_REGEXP), "%s" REPORT_LOCATION,      \
650             m, REPORT_LOCATION_ARGS(offset));       \
651 } STMT_END
652
653 #define ckWARNreg(loc,m) STMT_START {                                   \
654     const IV offset = loc - RExC_precomp;                               \
655     __ASSERT_(PASS2) Perl_ck_warner(aTHX_ packWARN(WARN_REGEXP), m REPORT_LOCATION,     \
656             REPORT_LOCATION_ARGS(offset));              \
657 } STMT_END
658
659 #define vWARN(loc, m) STMT_START {                                      \
660     const IV offset = loc - RExC_precomp;                               \
661     __ASSERT_(PASS2) Perl_warner(aTHX_ packWARN(WARN_REGEXP), m REPORT_LOCATION,        \
662             REPORT_LOCATION_ARGS(offset));              \
663 } STMT_END
664
665 #define vWARN_dep(loc, m) STMT_START {                                  \
666     const IV offset = loc - RExC_precomp;                               \
667     __ASSERT_(PASS2) Perl_warner(aTHX_ packWARN(WARN_DEPRECATED), m REPORT_LOCATION,    \
668             REPORT_LOCATION_ARGS(offset));              \
669 } STMT_END
670
671 #define ckWARNdep(loc,m) STMT_START {                                   \
672     const IV offset = loc - RExC_precomp;                               \
673     __ASSERT_(PASS2) Perl_ck_warner_d(aTHX_ packWARN(WARN_DEPRECATED),                  \
674             m REPORT_LOCATION,                                          \
675             REPORT_LOCATION_ARGS(offset));              \
676 } STMT_END
677
678 #define ckWARNregdep(loc,m) STMT_START {                                \
679     const IV offset = loc - RExC_precomp;                               \
680     __ASSERT_(PASS2) Perl_ck_warner_d(aTHX_ packWARN2(WARN_DEPRECATED, WARN_REGEXP),    \
681             m REPORT_LOCATION,                                          \
682             REPORT_LOCATION_ARGS(offset));              \
683 } STMT_END
684
685 #define ckWARN2reg_d(loc,m, a1) STMT_START {                            \
686     const IV offset = loc - RExC_precomp;                               \
687     __ASSERT_(PASS2) Perl_ck_warner_d(aTHX_ packWARN(WARN_REGEXP),                      \
688             m REPORT_LOCATION,                                          \
689             a1, REPORT_LOCATION_ARGS(offset));  \
690 } STMT_END
691
692 #define ckWARN2reg(loc, m, a1) STMT_START {                             \
693     const IV offset = loc - RExC_precomp;                               \
694     __ASSERT_(PASS2) Perl_ck_warner(aTHX_ packWARN(WARN_REGEXP), m REPORT_LOCATION,     \
695             a1, REPORT_LOCATION_ARGS(offset));  \
696 } STMT_END
697
698 #define vWARN3(loc, m, a1, a2) STMT_START {                             \
699     const IV offset = loc - RExC_precomp;                               \
700     __ASSERT_(PASS2) Perl_warner(aTHX_ packWARN(WARN_REGEXP), m REPORT_LOCATION,                \
701             a1, a2, REPORT_LOCATION_ARGS(offset));      \
702 } STMT_END
703
704 #define ckWARN3reg(loc, m, a1, a2) STMT_START {                         \
705     const IV offset = loc - RExC_precomp;                               \
706     __ASSERT_(PASS2) Perl_ck_warner(aTHX_ packWARN(WARN_REGEXP), m REPORT_LOCATION,     \
707             a1, a2, REPORT_LOCATION_ARGS(offset));      \
708 } STMT_END
709
710 #define vWARN4(loc, m, a1, a2, a3) STMT_START {                         \
711     const IV offset = loc - RExC_precomp;                               \
712     __ASSERT_(PASS2) Perl_warner(aTHX_ packWARN(WARN_REGEXP), m REPORT_LOCATION,                \
713             a1, a2, a3, REPORT_LOCATION_ARGS(offset)); \
714 } STMT_END
715
716 #define ckWARN4reg(loc, m, a1, a2, a3) STMT_START {                     \
717     const IV offset = loc - RExC_precomp;                               \
718     __ASSERT_(PASS2) Perl_ck_warner(aTHX_ packWARN(WARN_REGEXP), m REPORT_LOCATION,     \
719             a1, a2, a3, REPORT_LOCATION_ARGS(offset)); \
720 } STMT_END
721
722 #define vWARN5(loc, m, a1, a2, a3, a4) STMT_START {                     \
723     const IV offset = loc - RExC_precomp;                               \
724     __ASSERT_(PASS2) Perl_warner(aTHX_ packWARN(WARN_REGEXP), m REPORT_LOCATION,                \
725             a1, a2, a3, a4, REPORT_LOCATION_ARGS(offset)); \
726 } STMT_END
727
728 /* Macros for recording node offsets.   20001227 mjd@plover.com
729  * Nodes are numbered 1, 2, 3, 4.  Node #n's position is recorded in
730  * element 2*n-1 of the array.  Element #2n holds the byte length node #n.
731  * Element 0 holds the number n.
732  * Position is 1 indexed.
733  */
734 #ifndef RE_TRACK_PATTERN_OFFSETS
735 #define Set_Node_Offset_To_R(node,byte)
736 #define Set_Node_Offset(node,byte)
737 #define Set_Cur_Node_Offset
738 #define Set_Node_Length_To_R(node,len)
739 #define Set_Node_Length(node,len)
740 #define Set_Node_Cur_Length(node,start)
741 #define Node_Offset(n)
742 #define Node_Length(n)
743 #define Set_Node_Offset_Length(node,offset,len)
744 #define ProgLen(ri) ri->u.proglen
745 #define SetProgLen(ri,x) ri->u.proglen = x
746 #else
747 #define ProgLen(ri) ri->u.offsets[0]
748 #define SetProgLen(ri,x) ri->u.offsets[0] = x
749 #define Set_Node_Offset_To_R(node,byte) STMT_START {                    \
750     if (! SIZE_ONLY) {                                                  \
751         MJD_OFFSET_DEBUG(("** (%d) offset of node %d is %d.\n",         \
752                     __LINE__, (int)(node), (int)(byte)));               \
753         if((node) < 0) {                                                \
754             Perl_croak(aTHX_ "value of node is %d in Offset macro",     \
755                                          (int)(node));                  \
756         } else {                                                        \
757             RExC_offsets[2*(node)-1] = (byte);                          \
758         }                                                               \
759     }                                                                   \
760 } STMT_END
761
762 #define Set_Node_Offset(node,byte) \
763     Set_Node_Offset_To_R((node)-RExC_emit_start, (byte)-RExC_start)
764 #define Set_Cur_Node_Offset Set_Node_Offset(RExC_emit, RExC_parse)
765
766 #define Set_Node_Length_To_R(node,len) STMT_START {                     \
767     if (! SIZE_ONLY) {                                                  \
768         MJD_OFFSET_DEBUG(("** (%d) size of node %d is %d.\n",           \
769                 __LINE__, (int)(node), (int)(len)));                    \
770         if((node) < 0) {                                                \
771             Perl_croak(aTHX_ "value of node is %d in Length macro",     \
772                                          (int)(node));                  \
773         } else {                                                        \
774             RExC_offsets[2*(node)] = (len);                             \
775         }                                                               \
776     }                                                                   \
777 } STMT_END
778
779 #define Set_Node_Length(node,len) \
780     Set_Node_Length_To_R((node)-RExC_emit_start, len)
781 #define Set_Node_Cur_Length(node, start)                \
782     Set_Node_Length(node, RExC_parse - start)
783
784 /* Get offsets and lengths */
785 #define Node_Offset(n) (RExC_offsets[2*((n)-RExC_emit_start)-1])
786 #define Node_Length(n) (RExC_offsets[2*((n)-RExC_emit_start)])
787
788 #define Set_Node_Offset_Length(node,offset,len) STMT_START {    \
789     Set_Node_Offset_To_R((node)-RExC_emit_start, (offset));     \
790     Set_Node_Length_To_R((node)-RExC_emit_start, (len));        \
791 } STMT_END
792 #endif
793
794 #if PERL_ENABLE_EXPERIMENTAL_REGEX_OPTIMISATIONS
795 #define EXPERIMENTAL_INPLACESCAN
796 #endif /*PERL_ENABLE_EXPERIMENTAL_REGEX_OPTIMISATIONS*/
797
798 #define DEBUG_RExC_seen() \
799         DEBUG_OPTIMISE_MORE_r({                                             \
800             PerlIO_printf(Perl_debug_log,"RExC_seen: ");                    \
801                                                                             \
802             if (RExC_seen & REG_ZERO_LEN_SEEN)                              \
803                 PerlIO_printf(Perl_debug_log,"REG_ZERO_LEN_SEEN ");         \
804                                                                             \
805             if (RExC_seen & REG_LOOKBEHIND_SEEN)                            \
806                 PerlIO_printf(Perl_debug_log,"REG_LOOKBEHIND_SEEN ");       \
807                                                                             \
808             if (RExC_seen & REG_GPOS_SEEN)                                  \
809                 PerlIO_printf(Perl_debug_log,"REG_GPOS_SEEN ");             \
810                                                                             \
811             if (RExC_seen & REG_RECURSE_SEEN)                               \
812                 PerlIO_printf(Perl_debug_log,"REG_RECURSE_SEEN ");          \
813                                                                             \
814             if (RExC_seen & REG_TOP_LEVEL_BRANCHES_SEEN)                         \
815                 PerlIO_printf(Perl_debug_log,"REG_TOP_LEVEL_BRANCHES_SEEN ");    \
816                                                                             \
817             if (RExC_seen & REG_VERBARG_SEEN)                               \
818                 PerlIO_printf(Perl_debug_log,"REG_VERBARG_SEEN ");          \
819                                                                             \
820             if (RExC_seen & REG_CUTGROUP_SEEN)                              \
821                 PerlIO_printf(Perl_debug_log,"REG_CUTGROUP_SEEN ");         \
822                                                                             \
823             if (RExC_seen & REG_RUN_ON_COMMENT_SEEN)                        \
824                 PerlIO_printf(Perl_debug_log,"REG_RUN_ON_COMMENT_SEEN ");   \
825                                                                             \
826             if (RExC_seen & REG_UNFOLDED_MULTI_SEEN)                        \
827                 PerlIO_printf(Perl_debug_log,"REG_UNFOLDED_MULTI_SEEN ");   \
828                                                                             \
829             if (RExC_seen & REG_GOSTART_SEEN)                               \
830                 PerlIO_printf(Perl_debug_log,"REG_GOSTART_SEEN ");          \
831                                                                             \
832             if (RExC_seen & REG_UNBOUNDED_QUANTIFIER_SEEN)                               \
833                 PerlIO_printf(Perl_debug_log,"REG_UNBOUNDED_QUANTIFIER_SEEN ");          \
834                                                                             \
835             PerlIO_printf(Perl_debug_log,"\n");                             \
836         });
837
838 #define DEBUG_SHOW_STUDY_FLAG(flags,flag) \
839   if ((flags) & flag) PerlIO_printf(Perl_debug_log, "%s ", #flag)
840
841 #define DEBUG_SHOW_STUDY_FLAGS(flags,open_str,close_str)                    \
842     if ( ( flags ) ) {                                                      \
843         PerlIO_printf(Perl_debug_log, "%s", open_str);                      \
844         DEBUG_SHOW_STUDY_FLAG(flags,SF_FL_BEFORE_SEOL);                     \
845         DEBUG_SHOW_STUDY_FLAG(flags,SF_FL_BEFORE_MEOL);                     \
846         DEBUG_SHOW_STUDY_FLAG(flags,SF_IS_INF);                             \
847         DEBUG_SHOW_STUDY_FLAG(flags,SF_HAS_PAR);                            \
848         DEBUG_SHOW_STUDY_FLAG(flags,SF_IN_PAR);                             \
849         DEBUG_SHOW_STUDY_FLAG(flags,SF_HAS_EVAL);                           \
850         DEBUG_SHOW_STUDY_FLAG(flags,SCF_DO_SUBSTR);                         \
851         DEBUG_SHOW_STUDY_FLAG(flags,SCF_DO_STCLASS_AND);                    \
852         DEBUG_SHOW_STUDY_FLAG(flags,SCF_DO_STCLASS_OR);                     \
853         DEBUG_SHOW_STUDY_FLAG(flags,SCF_DO_STCLASS);                        \
854         DEBUG_SHOW_STUDY_FLAG(flags,SCF_WHILEM_VISITED_POS);                \
855         DEBUG_SHOW_STUDY_FLAG(flags,SCF_TRIE_RESTUDY);                      \
856         DEBUG_SHOW_STUDY_FLAG(flags,SCF_SEEN_ACCEPT);                       \
857         DEBUG_SHOW_STUDY_FLAG(flags,SCF_TRIE_DOING_RESTUDY);                \
858         DEBUG_SHOW_STUDY_FLAG(flags,SCF_IN_DEFINE);                         \
859         PerlIO_printf(Perl_debug_log, "%s", close_str);                     \
860     }
861
862
863 #define DEBUG_STUDYDATA(str,data,depth)                              \
864 DEBUG_OPTIMISE_MORE_r(if(data){                                      \
865     PerlIO_printf(Perl_debug_log,                                    \
866         "%*s" str "Pos:%"IVdf"/%"IVdf                                \
867         " Flags: 0x%"UVXf,                                           \
868         (int)(depth)*2, "",                                          \
869         (IV)((data)->pos_min),                                       \
870         (IV)((data)->pos_delta),                                     \
871         (UV)((data)->flags)                                          \
872     );                                                               \
873     DEBUG_SHOW_STUDY_FLAGS((data)->flags," [ ","]");                 \
874     PerlIO_printf(Perl_debug_log,                                    \
875         " Whilem_c: %"IVdf" Lcp: %"IVdf" %s",                        \
876         (IV)((data)->whilem_c),                                      \
877         (IV)((data)->last_closep ? *((data)->last_closep) : -1),     \
878         is_inf ? "INF " : ""                                         \
879     );                                                               \
880     if ((data)->last_found)                                          \
881         PerlIO_printf(Perl_debug_log,                                \
882             "Last:'%s' %"IVdf":%"IVdf"/%"IVdf" %sFixed:'%s' @ %"IVdf \
883             " %sFloat: '%s' @ %"IVdf"/%"IVdf"",                      \
884             SvPVX_const((data)->last_found),                         \
885             (IV)((data)->last_end),                                  \
886             (IV)((data)->last_start_min),                            \
887             (IV)((data)->last_start_max),                            \
888             ((data)->longest &&                                      \
889              (data)->longest==&((data)->longest_fixed)) ? "*" : "",  \
890             SvPVX_const((data)->longest_fixed),                      \
891             (IV)((data)->offset_fixed),                              \
892             ((data)->longest &&                                      \
893              (data)->longest==&((data)->longest_float)) ? "*" : "",  \
894             SvPVX_const((data)->longest_float),                      \
895             (IV)((data)->offset_float_min),                          \
896             (IV)((data)->offset_float_max)                           \
897         );                                                           \
898     PerlIO_printf(Perl_debug_log,"\n");                              \
899 });
900
901 /* is c a control character for which we have a mnemonic? */
902 #define isMNEMONIC_CNTRL(c) _IS_MNEMONIC_CNTRL_ONLY_FOR_USE_BY_REGCOMP_DOT_C(c)
903
904 STATIC const char *
905 S_cntrl_to_mnemonic(const U8 c)
906 {
907     /* Returns the mnemonic string that represents character 'c', if one
908      * exists; NULL otherwise.  The only ones that exist for the purposes of
909      * this routine are a few control characters */
910
911     switch (c) {
912         case '\a':       return "\\a";
913         case '\b':       return "\\b";
914         case ESC_NATIVE: return "\\e";
915         case '\f':       return "\\f";
916         case '\n':       return "\\n";
917         case '\r':       return "\\r";
918         case '\t':       return "\\t";
919     }
920
921     return NULL;
922 }
923
924 /* Mark that we cannot extend a found fixed substring at this point.
925    Update the longest found anchored substring and the longest found
926    floating substrings if needed. */
927
928 STATIC void
929 S_scan_commit(pTHX_ const RExC_state_t *pRExC_state, scan_data_t *data,
930                     SSize_t *minlenp, int is_inf)
931 {
932     const STRLEN l = CHR_SVLEN(data->last_found);
933     const STRLEN old_l = CHR_SVLEN(*data->longest);
934     GET_RE_DEBUG_FLAGS_DECL;
935
936     PERL_ARGS_ASSERT_SCAN_COMMIT;
937
938     if ((l >= old_l) && ((l > old_l) || (data->flags & SF_BEFORE_EOL))) {
939         SvSetMagicSV(*data->longest, data->last_found);
940         if (*data->longest == data->longest_fixed) {
941             data->offset_fixed = l ? data->last_start_min : data->pos_min;
942             if (data->flags & SF_BEFORE_EOL)
943                 data->flags
944                     |= ((data->flags & SF_BEFORE_EOL) << SF_FIX_SHIFT_EOL);
945             else
946                 data->flags &= ~SF_FIX_BEFORE_EOL;
947             data->minlen_fixed=minlenp;
948             data->lookbehind_fixed=0;
949         }
950         else { /* *data->longest == data->longest_float */
951             data->offset_float_min = l ? data->last_start_min : data->pos_min;
952             data->offset_float_max = (l
953                           ? data->last_start_max
954                           : (data->pos_delta > SSize_t_MAX - data->pos_min
955                                          ? SSize_t_MAX
956                                          : data->pos_min + data->pos_delta));
957             if (is_inf
958                  || (STRLEN)data->offset_float_max > (STRLEN)SSize_t_MAX)
959                 data->offset_float_max = SSize_t_MAX;
960             if (data->flags & SF_BEFORE_EOL)
961                 data->flags
962                     |= ((data->flags & SF_BEFORE_EOL) << SF_FL_SHIFT_EOL);
963             else
964                 data->flags &= ~SF_FL_BEFORE_EOL;
965             data->minlen_float=minlenp;
966             data->lookbehind_float=0;
967         }
968     }
969     SvCUR_set(data->last_found, 0);
970     {
971         SV * const sv = data->last_found;
972         if (SvUTF8(sv) && SvMAGICAL(sv)) {
973             MAGIC * const mg = mg_find(sv, PERL_MAGIC_utf8);
974             if (mg)
975                 mg->mg_len = 0;
976         }
977     }
978     data->last_end = -1;
979     data->flags &= ~SF_BEFORE_EOL;
980     DEBUG_STUDYDATA("commit: ",data,0);
981 }
982
983 /* An SSC is just a regnode_charclass_posix with an extra field: the inversion
984  * list that describes which code points it matches */
985
986 STATIC void
987 S_ssc_anything(pTHX_ regnode_ssc *ssc)
988 {
989     /* Set the SSC 'ssc' to match an empty string or any code point */
990
991     PERL_ARGS_ASSERT_SSC_ANYTHING;
992
993     assert(is_ANYOF_SYNTHETIC(ssc));
994
995     ssc->invlist = sv_2mortal(_new_invlist(2)); /* mortalize so won't leak */
996     _append_range_to_invlist(ssc->invlist, 0, UV_MAX);
997     ANYOF_FLAGS(ssc) |= SSC_MATCHES_EMPTY_STRING;  /* Plus matches empty */
998 }
999
1000 STATIC int
1001 S_ssc_is_anything(const regnode_ssc *ssc)
1002 {
1003     /* Returns TRUE if the SSC 'ssc' can match the empty string and any code
1004      * point; FALSE otherwise.  Thus, this is used to see if using 'ssc' buys
1005      * us anything: if the function returns TRUE, 'ssc' hasn't been restricted
1006      * in any way, so there's no point in using it */
1007
1008     UV start, end;
1009     bool ret;
1010
1011     PERL_ARGS_ASSERT_SSC_IS_ANYTHING;
1012
1013     assert(is_ANYOF_SYNTHETIC(ssc));
1014
1015     if (! (ANYOF_FLAGS(ssc) & SSC_MATCHES_EMPTY_STRING)) {
1016         return FALSE;
1017     }
1018
1019     /* See if the list consists solely of the range 0 - Infinity */
1020     invlist_iterinit(ssc->invlist);
1021     ret = invlist_iternext(ssc->invlist, &start, &end)
1022           && start == 0
1023           && end == UV_MAX;
1024
1025     invlist_iterfinish(ssc->invlist);
1026
1027     if (ret) {
1028         return TRUE;
1029     }
1030
1031     /* If e.g., both \w and \W are set, matches everything */
1032     if (ANYOF_POSIXL_SSC_TEST_ANY_SET(ssc)) {
1033         int i;
1034         for (i = 0; i < ANYOF_POSIXL_MAX; i += 2) {
1035             if (ANYOF_POSIXL_TEST(ssc, i) && ANYOF_POSIXL_TEST(ssc, i+1)) {
1036                 return TRUE;
1037             }
1038         }
1039     }
1040
1041     return FALSE;
1042 }
1043
1044 STATIC void
1045 S_ssc_init(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc)
1046 {
1047     /* Initializes the SSC 'ssc'.  This includes setting it to match an empty
1048      * string, any code point, or any posix class under locale */
1049
1050     PERL_ARGS_ASSERT_SSC_INIT;
1051
1052     Zero(ssc, 1, regnode_ssc);
1053     set_ANYOF_SYNTHETIC(ssc);
1054     ARG_SET(ssc, ANYOF_ONLY_HAS_BITMAP);
1055     ssc_anything(ssc);
1056
1057     /* If any portion of the regex is to operate under locale rules that aren't
1058      * fully known at compile time, initialization includes it.  The reason
1059      * this isn't done for all regexes is that the optimizer was written under
1060      * the assumption that locale was all-or-nothing.  Given the complexity and
1061      * lack of documentation in the optimizer, and that there are inadequate
1062      * test cases for locale, many parts of it may not work properly, it is
1063      * safest to avoid locale unless necessary. */
1064     if (RExC_contains_locale) {
1065         ANYOF_POSIXL_SETALL(ssc);
1066     }
1067     else {
1068         ANYOF_POSIXL_ZERO(ssc);
1069     }
1070 }
1071
1072 STATIC int
1073 S_ssc_is_cp_posixl_init(const RExC_state_t *pRExC_state,
1074                         const regnode_ssc *ssc)
1075 {
1076     /* Returns TRUE if the SSC 'ssc' is in its initial state with regard only
1077      * to the list of code points matched, and locale posix classes; hence does
1078      * not check its flags) */
1079
1080     UV start, end;
1081     bool ret;
1082
1083     PERL_ARGS_ASSERT_SSC_IS_CP_POSIXL_INIT;
1084
1085     assert(is_ANYOF_SYNTHETIC(ssc));
1086
1087     invlist_iterinit(ssc->invlist);
1088     ret = invlist_iternext(ssc->invlist, &start, &end)
1089           && start == 0
1090           && end == UV_MAX;
1091
1092     invlist_iterfinish(ssc->invlist);
1093
1094     if (! ret) {
1095         return FALSE;
1096     }
1097
1098     if (RExC_contains_locale && ! ANYOF_POSIXL_SSC_TEST_ALL_SET(ssc)) {
1099         return FALSE;
1100     }
1101
1102     return TRUE;
1103 }
1104
1105 STATIC SV*
1106 S_get_ANYOF_cp_list_for_ssc(pTHX_ const RExC_state_t *pRExC_state,
1107                                const regnode_charclass* const node)
1108 {
1109     /* Returns a mortal inversion list defining which code points are matched
1110      * by 'node', which is of type ANYOF.  Handles complementing the result if
1111      * appropriate.  If some code points aren't knowable at this time, the
1112      * returned list must, and will, contain every code point that is a
1113      * possibility. */
1114
1115     SV* invlist = sv_2mortal(_new_invlist(0));
1116     SV* only_utf8_locale_invlist = NULL;
1117     unsigned int i;
1118     const U32 n = ARG(node);
1119     bool new_node_has_latin1 = FALSE;
1120
1121     PERL_ARGS_ASSERT_GET_ANYOF_CP_LIST_FOR_SSC;
1122
1123     /* Look at the data structure created by S_set_ANYOF_arg() */
1124     if (n != ANYOF_ONLY_HAS_BITMAP) {
1125         SV * const rv = MUTABLE_SV(RExC_rxi->data->data[n]);
1126         AV * const av = MUTABLE_AV(SvRV(rv));
1127         SV **const ary = AvARRAY(av);
1128         assert(RExC_rxi->data->what[n] == 's');
1129
1130         if (ary[1] && ary[1] != &PL_sv_undef) { /* Has compile-time swash */
1131             invlist = sv_2mortal(invlist_clone(_get_swash_invlist(ary[1])));
1132         }
1133         else if (ary[0] && ary[0] != &PL_sv_undef) {
1134
1135             /* Here, no compile-time swash, and there are things that won't be
1136              * known until runtime -- we have to assume it could be anything */
1137             return _add_range_to_invlist(invlist, 0, UV_MAX);
1138         }
1139         else if (ary[3] && ary[3] != &PL_sv_undef) {
1140
1141             /* Here no compile-time swash, and no run-time only data.  Use the
1142              * node's inversion list */
1143             invlist = sv_2mortal(invlist_clone(ary[3]));
1144         }
1145
1146         /* Get the code points valid only under UTF-8 locales */
1147         if ((ANYOF_FLAGS(node) & ANYOF_LOC_FOLD)
1148             && ary[2] && ary[2] != &PL_sv_undef)
1149         {
1150             only_utf8_locale_invlist = ary[2];
1151         }
1152     }
1153
1154     /* An ANYOF node contains a bitmap for the first NUM_ANYOF_CODE_POINTS
1155      * code points, and an inversion list for the others, but if there are code
1156      * points that should match only conditionally on the target string being
1157      * UTF-8, those are placed in the inversion list, and not the bitmap.
1158      * Since there are circumstances under which they could match, they are
1159      * included in the SSC.  But if the ANYOF node is to be inverted, we have
1160      * to exclude them here, so that when we invert below, the end result
1161      * actually does include them.  (Think about "\xe0" =~ /[^\xc0]/di;).  We
1162      * have to do this here before we add the unconditionally matched code
1163      * points */
1164     if (ANYOF_FLAGS(node) & ANYOF_INVERT) {
1165         _invlist_intersection_complement_2nd(invlist,
1166                                              PL_UpperLatin1,
1167                                              &invlist);
1168     }
1169
1170     /* Add in the points from the bit map */
1171     for (i = 0; i < NUM_ANYOF_CODE_POINTS; i++) {
1172         if (ANYOF_BITMAP_TEST(node, i)) {
1173             invlist = add_cp_to_invlist(invlist, i);
1174             new_node_has_latin1 = TRUE;
1175         }
1176     }
1177
1178     /* If this can match all upper Latin1 code points, have to add them
1179      * as well */
1180     if (ANYOF_FLAGS(node) & ANYOF_MATCHES_ALL_NON_UTF8_NON_ASCII) {
1181         _invlist_union(invlist, PL_UpperLatin1, &invlist);
1182     }
1183
1184     /* Similarly for these */
1185     if (ANYOF_FLAGS(node) & ANYOF_MATCHES_ALL_ABOVE_BITMAP) {
1186         _invlist_union_complement_2nd(invlist, PL_InBitmap, &invlist);
1187     }
1188
1189     if (ANYOF_FLAGS(node) & ANYOF_INVERT) {
1190         _invlist_invert(invlist);
1191     }
1192     else if (new_node_has_latin1 && ANYOF_FLAGS(node) & ANYOF_LOC_FOLD) {
1193
1194         /* Under /li, any 0-255 could fold to any other 0-255, depending on the
1195          * locale.  We can skip this if there are no 0-255 at all. */
1196         _invlist_union(invlist, PL_Latin1, &invlist);
1197     }
1198
1199     /* Similarly add the UTF-8 locale possible matches.  These have to be
1200      * deferred until after the non-UTF-8 locale ones are taken care of just
1201      * above, or it leads to wrong results under ANYOF_INVERT */
1202     if (only_utf8_locale_invlist) {
1203         _invlist_union_maybe_complement_2nd(invlist,
1204                                             only_utf8_locale_invlist,
1205                                             ANYOF_FLAGS(node) & ANYOF_INVERT,
1206                                             &invlist);
1207     }
1208
1209     return invlist;
1210 }
1211
1212 /* These two functions currently do the exact same thing */
1213 #define ssc_init_zero           ssc_init
1214
1215 #define ssc_add_cp(ssc, cp)   ssc_add_range((ssc), (cp), (cp))
1216 #define ssc_match_all_cp(ssc) ssc_add_range(ssc, 0, UV_MAX)
1217
1218 /* 'AND' a given class with another one.  Can create false positives.  'ssc'
1219  * should not be inverted.  'and_with->flags & ANYOF_MATCHES_POSIXL' should be
1220  * 0 if 'and_with' is a regnode_charclass instead of a regnode_ssc. */
1221
1222 STATIC void
1223 S_ssc_and(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc,
1224                 const regnode_charclass *and_with)
1225 {
1226     /* Accumulate into SSC 'ssc' its 'AND' with 'and_with', which is either
1227      * another SSC or a regular ANYOF class.  Can create false positives. */
1228
1229     SV* anded_cp_list;
1230     U8  anded_flags;
1231
1232     PERL_ARGS_ASSERT_SSC_AND;
1233
1234     assert(is_ANYOF_SYNTHETIC(ssc));
1235
1236     /* 'and_with' is used as-is if it too is an SSC; otherwise have to extract
1237      * the code point inversion list and just the relevant flags */
1238     if (is_ANYOF_SYNTHETIC(and_with)) {
1239         anded_cp_list = ((regnode_ssc *)and_with)->invlist;
1240         anded_flags = ANYOF_FLAGS(and_with);
1241
1242         /* XXX This is a kludge around what appears to be deficiencies in the
1243          * optimizer.  If we make S_ssc_anything() add in the WARN_SUPER flag,
1244          * there are paths through the optimizer where it doesn't get weeded
1245          * out when it should.  And if we don't make some extra provision for
1246          * it like the code just below, it doesn't get added when it should.
1247          * This solution is to add it only when AND'ing, which is here, and
1248          * only when what is being AND'ed is the pristine, original node
1249          * matching anything.  Thus it is like adding it to ssc_anything() but
1250          * only when the result is to be AND'ed.  Probably the same solution
1251          * could be adopted for the same problem we have with /l matching,
1252          * which is solved differently in S_ssc_init(), and that would lead to
1253          * fewer false positives than that solution has.  But if this solution
1254          * creates bugs, the consequences are only that a warning isn't raised
1255          * that should be; while the consequences for having /l bugs is
1256          * incorrect matches */
1257         if (ssc_is_anything((regnode_ssc *)and_with)) {
1258             anded_flags |= ANYOF_WARN_SUPER;
1259         }
1260     }
1261     else {
1262         anded_cp_list = get_ANYOF_cp_list_for_ssc(pRExC_state, and_with);
1263         anded_flags = ANYOF_FLAGS(and_with) & ANYOF_COMMON_FLAGS;
1264     }
1265
1266     ANYOF_FLAGS(ssc) &= anded_flags;
1267
1268     /* Below, C1 is the list of code points in 'ssc'; P1, its posix classes.
1269      * C2 is the list of code points in 'and-with'; P2, its posix classes.
1270      * 'and_with' may be inverted.  When not inverted, we have the situation of
1271      * computing:
1272      *  (C1 | P1) & (C2 | P2)
1273      *                     =  (C1 & (C2 | P2)) | (P1 & (C2 | P2))
1274      *                     =  ((C1 & C2) | (C1 & P2)) | ((P1 & C2) | (P1 & P2))
1275      *                    <=  ((C1 & C2) |       P2)) | ( P1       | (P1 & P2))
1276      *                    <=  ((C1 & C2) | P1 | P2)
1277      * Alternatively, the last few steps could be:
1278      *                     =  ((C1 & C2) | (C1 & P2)) | ((P1 & C2) | (P1 & P2))
1279      *                    <=  ((C1 & C2) |  C1      ) | (      C2  | (P1 & P2))
1280      *                    <=  (C1 | C2 | (P1 & P2))
1281      * We favor the second approach if either P1 or P2 is non-empty.  This is
1282      * because these components are a barrier to doing optimizations, as what
1283      * they match cannot be known until the moment of matching as they are
1284      * dependent on the current locale, 'AND"ing them likely will reduce or
1285      * eliminate them.
1286      * But we can do better if we know that C1,P1 are in their initial state (a
1287      * frequent occurrence), each matching everything:
1288      *  (<everything>) & (C2 | P2) =  C2 | P2
1289      * Similarly, if C2,P2 are in their initial state (again a frequent
1290      * occurrence), the result is a no-op
1291      *  (C1 | P1) & (<everything>) =  C1 | P1
1292      *
1293      * Inverted, we have
1294      *  (C1 | P1) & ~(C2 | P2)  =  (C1 | P1) & (~C2 & ~P2)
1295      *                          =  (C1 & (~C2 & ~P2)) | (P1 & (~C2 & ~P2))
1296      *                         <=  (C1 & ~C2) | (P1 & ~P2)
1297      * */
1298
1299     if ((ANYOF_FLAGS(and_with) & ANYOF_INVERT)
1300         && ! is_ANYOF_SYNTHETIC(and_with))
1301     {
1302         unsigned int i;
1303
1304         ssc_intersection(ssc,
1305                          anded_cp_list,
1306                          FALSE /* Has already been inverted */
1307                          );
1308
1309         /* If either P1 or P2 is empty, the intersection will be also; can skip
1310          * the loop */
1311         if (! (ANYOF_FLAGS(and_with) & ANYOF_MATCHES_POSIXL)) {
1312             ANYOF_POSIXL_ZERO(ssc);
1313         }
1314         else if (ANYOF_POSIXL_SSC_TEST_ANY_SET(ssc)) {
1315
1316             /* Note that the Posix class component P from 'and_with' actually
1317              * looks like:
1318              *      P = Pa | Pb | ... | Pn
1319              * where each component is one posix class, such as in [\w\s].
1320              * Thus
1321              *      ~P = ~(Pa | Pb | ... | Pn)
1322              *         = ~Pa & ~Pb & ... & ~Pn
1323              *        <= ~Pa | ~Pb | ... | ~Pn
1324              * The last is something we can easily calculate, but unfortunately
1325              * is likely to have many false positives.  We could do better
1326              * in some (but certainly not all) instances if two classes in
1327              * P have known relationships.  For example
1328              *      :lower: <= :alpha: <= :alnum: <= \w <= :graph: <= :print:
1329              * So
1330              *      :lower: & :print: = :lower:
1331              * And similarly for classes that must be disjoint.  For example,
1332              * since \s and \w can have no elements in common based on rules in
1333              * the POSIX standard,
1334              *      \w & ^\S = nothing
1335              * Unfortunately, some vendor locales do not meet the Posix
1336              * standard, in particular almost everything by Microsoft.
1337              * The loop below just changes e.g., \w into \W and vice versa */
1338
1339             regnode_charclass_posixl temp;
1340             int add = 1;    /* To calculate the index of the complement */
1341
1342             ANYOF_POSIXL_ZERO(&temp);
1343             for (i = 0; i < ANYOF_MAX; i++) {
1344                 assert(i % 2 != 0
1345                        || ! ANYOF_POSIXL_TEST((regnode_charclass_posixl*) and_with, i)
1346                        || ! ANYOF_POSIXL_TEST((regnode_charclass_posixl*) and_with, i + 1));
1347
1348                 if (ANYOF_POSIXL_TEST((regnode_charclass_posixl*) and_with, i)) {
1349                     ANYOF_POSIXL_SET(&temp, i + add);
1350                 }
1351                 add = 0 - add; /* 1 goes to -1; -1 goes to 1 */
1352             }
1353             ANYOF_POSIXL_AND(&temp, ssc);
1354
1355         } /* else ssc already has no posixes */
1356     } /* else: Not inverted.  This routine is a no-op if 'and_with' is an SSC
1357          in its initial state */
1358     else if (! is_ANYOF_SYNTHETIC(and_with)
1359              || ! ssc_is_cp_posixl_init(pRExC_state, (regnode_ssc *)and_with))
1360     {
1361         /* But if 'ssc' is in its initial state, the result is just 'and_with';
1362          * copy it over 'ssc' */
1363         if (ssc_is_cp_posixl_init(pRExC_state, ssc)) {
1364             if (is_ANYOF_SYNTHETIC(and_with)) {
1365                 StructCopy(and_with, ssc, regnode_ssc);
1366             }
1367             else {
1368                 ssc->invlist = anded_cp_list;
1369                 ANYOF_POSIXL_ZERO(ssc);
1370                 if (ANYOF_FLAGS(and_with) & ANYOF_MATCHES_POSIXL) {
1371                     ANYOF_POSIXL_OR((regnode_charclass_posixl*) and_with, ssc);
1372                 }
1373             }
1374         }
1375         else if (ANYOF_POSIXL_SSC_TEST_ANY_SET(ssc)
1376                  || (ANYOF_FLAGS(and_with) & ANYOF_MATCHES_POSIXL))
1377         {
1378             /* One or the other of P1, P2 is non-empty. */
1379             if (ANYOF_FLAGS(and_with) & ANYOF_MATCHES_POSIXL) {
1380                 ANYOF_POSIXL_AND((regnode_charclass_posixl*) and_with, ssc);
1381             }
1382             ssc_union(ssc, anded_cp_list, FALSE);
1383         }
1384         else { /* P1 = P2 = empty */
1385             ssc_intersection(ssc, anded_cp_list, FALSE);
1386         }
1387     }
1388 }
1389
1390 STATIC void
1391 S_ssc_or(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc,
1392                const regnode_charclass *or_with)
1393 {
1394     /* Accumulate into SSC 'ssc' its 'OR' with 'or_with', which is either
1395      * another SSC or a regular ANYOF class.  Can create false positives if
1396      * 'or_with' is to be inverted. */
1397
1398     SV* ored_cp_list;
1399     U8 ored_flags;
1400
1401     PERL_ARGS_ASSERT_SSC_OR;
1402
1403     assert(is_ANYOF_SYNTHETIC(ssc));
1404
1405     /* 'or_with' is used as-is if it too is an SSC; otherwise have to extract
1406      * the code point inversion list and just the relevant flags */
1407     if (is_ANYOF_SYNTHETIC(or_with)) {
1408         ored_cp_list = ((regnode_ssc*) or_with)->invlist;
1409         ored_flags = ANYOF_FLAGS(or_with);
1410     }
1411     else {
1412         ored_cp_list = get_ANYOF_cp_list_for_ssc(pRExC_state, or_with);
1413         ored_flags = ANYOF_FLAGS(or_with) & ANYOF_COMMON_FLAGS;
1414     }
1415
1416     ANYOF_FLAGS(ssc) |= ored_flags;
1417
1418     /* Below, C1 is the list of code points in 'ssc'; P1, its posix classes.
1419      * C2 is the list of code points in 'or-with'; P2, its posix classes.
1420      * 'or_with' may be inverted.  When not inverted, we have the simple
1421      * situation of computing:
1422      *  (C1 | P1) | (C2 | P2)  =  (C1 | C2) | (P1 | P2)
1423      * If P1|P2 yields a situation with both a class and its complement are
1424      * set, like having both \w and \W, this matches all code points, and we
1425      * can delete these from the P component of the ssc going forward.  XXX We
1426      * might be able to delete all the P components, but I (khw) am not certain
1427      * about this, and it is better to be safe.
1428      *
1429      * Inverted, we have
1430      *  (C1 | P1) | ~(C2 | P2)  =  (C1 | P1) | (~C2 & ~P2)
1431      *                         <=  (C1 | P1) | ~C2
1432      *                         <=  (C1 | ~C2) | P1
1433      * (which results in actually simpler code than the non-inverted case)
1434      * */
1435
1436     if ((ANYOF_FLAGS(or_with) & ANYOF_INVERT)
1437         && ! is_ANYOF_SYNTHETIC(or_with))
1438     {
1439         /* We ignore P2, leaving P1 going forward */
1440     }   /* else  Not inverted */
1441     else if (ANYOF_FLAGS(or_with) & ANYOF_MATCHES_POSIXL) {
1442         ANYOF_POSIXL_OR((regnode_charclass_posixl*)or_with, ssc);
1443         if (ANYOF_POSIXL_SSC_TEST_ANY_SET(ssc)) {
1444             unsigned int i;
1445             for (i = 0; i < ANYOF_MAX; i += 2) {
1446                 if (ANYOF_POSIXL_TEST(ssc, i) && ANYOF_POSIXL_TEST(ssc, i + 1))
1447                 {
1448                     ssc_match_all_cp(ssc);
1449                     ANYOF_POSIXL_CLEAR(ssc, i);
1450                     ANYOF_POSIXL_CLEAR(ssc, i+1);
1451                 }
1452             }
1453         }
1454     }
1455
1456     ssc_union(ssc,
1457               ored_cp_list,
1458               FALSE /* Already has been inverted */
1459               );
1460 }
1461
1462 PERL_STATIC_INLINE void
1463 S_ssc_union(pTHX_ regnode_ssc *ssc, SV* const invlist, const bool invert2nd)
1464 {
1465     PERL_ARGS_ASSERT_SSC_UNION;
1466
1467     assert(is_ANYOF_SYNTHETIC(ssc));
1468
1469     _invlist_union_maybe_complement_2nd(ssc->invlist,
1470                                         invlist,
1471                                         invert2nd,
1472                                         &ssc->invlist);
1473 }
1474
1475 PERL_STATIC_INLINE void
1476 S_ssc_intersection(pTHX_ regnode_ssc *ssc,
1477                          SV* const invlist,
1478                          const bool invert2nd)
1479 {
1480     PERL_ARGS_ASSERT_SSC_INTERSECTION;
1481
1482     assert(is_ANYOF_SYNTHETIC(ssc));
1483
1484     _invlist_intersection_maybe_complement_2nd(ssc->invlist,
1485                                                invlist,
1486                                                invert2nd,
1487                                                &ssc->invlist);
1488 }
1489
1490 PERL_STATIC_INLINE void
1491 S_ssc_add_range(pTHX_ regnode_ssc *ssc, const UV start, const UV end)
1492 {
1493     PERL_ARGS_ASSERT_SSC_ADD_RANGE;
1494
1495     assert(is_ANYOF_SYNTHETIC(ssc));
1496
1497     ssc->invlist = _add_range_to_invlist(ssc->invlist, start, end);
1498 }
1499
1500 PERL_STATIC_INLINE void
1501 S_ssc_cp_and(pTHX_ regnode_ssc *ssc, const UV cp)
1502 {
1503     /* AND just the single code point 'cp' into the SSC 'ssc' */
1504
1505     SV* cp_list = _new_invlist(2);
1506
1507     PERL_ARGS_ASSERT_SSC_CP_AND;
1508
1509     assert(is_ANYOF_SYNTHETIC(ssc));
1510
1511     cp_list = add_cp_to_invlist(cp_list, cp);
1512     ssc_intersection(ssc, cp_list,
1513                      FALSE /* Not inverted */
1514                      );
1515     SvREFCNT_dec_NN(cp_list);
1516 }
1517
1518 PERL_STATIC_INLINE void
1519 S_ssc_clear_locale(regnode_ssc *ssc)
1520 {
1521     /* Set the SSC 'ssc' to not match any locale things */
1522     PERL_ARGS_ASSERT_SSC_CLEAR_LOCALE;
1523
1524     assert(is_ANYOF_SYNTHETIC(ssc));
1525
1526     ANYOF_POSIXL_ZERO(ssc);
1527     ANYOF_FLAGS(ssc) &= ~ANYOF_LOCALE_FLAGS;
1528 }
1529
1530 #define NON_OTHER_COUNT   NON_OTHER_COUNT_FOR_USE_ONLY_BY_REGCOMP_DOT_C
1531
1532 STATIC bool
1533 S_is_ssc_worth_it(const RExC_state_t * pRExC_state, const regnode_ssc * ssc)
1534 {
1535     /* The synthetic start class is used to hopefully quickly winnow down
1536      * places where a pattern could start a match in the target string.  If it
1537      * doesn't really narrow things down that much, there isn't much point to
1538      * having the overhead of using it.  This function uses some very crude
1539      * heuristics to decide if to use the ssc or not.
1540      *
1541      * It returns TRUE if 'ssc' rules out more than half what it considers to
1542      * be the "likely" possible matches, but of course it doesn't know what the
1543      * actual things being matched are going to be; these are only guesses
1544      *
1545      * For /l matches, it assumes that the only likely matches are going to be
1546      *      in the 0-255 range, uniformly distributed, so half of that is 127
1547      * For /a and /d matches, it assumes that the likely matches will be just
1548      *      the ASCII range, so half of that is 63
1549      * For /u and there isn't anything matching above the Latin1 range, it
1550      *      assumes that that is the only range likely to be matched, and uses
1551      *      half that as the cut-off: 127.  If anything matches above Latin1,
1552      *      it assumes that all of Unicode could match (uniformly), except for
1553      *      non-Unicode code points and things in the General Category "Other"
1554      *      (unassigned, private use, surrogates, controls and formats).  This
1555      *      is a much large number. */
1556
1557     const U32 max_match = (LOC)
1558                           ? 127
1559                           : (! UNI_SEMANTICS)
1560                             ? 63
1561                             : (invlist_highest(ssc->invlist) < 256)
1562                               ? 127
1563                               : ((NON_OTHER_COUNT + 1) / 2) - 1;
1564     U32 count = 0;      /* Running total of number of code points matched by
1565                            'ssc' */
1566     UV start, end;      /* Start and end points of current range in inversion
1567                            list */
1568
1569     PERL_ARGS_ASSERT_IS_SSC_WORTH_IT;
1570
1571     invlist_iterinit(ssc->invlist);
1572     while (invlist_iternext(ssc->invlist, &start, &end)) {
1573
1574         /* /u is the only thing that we expect to match above 255; so if not /u
1575          * and even if there are matches above 255, ignore them.  This catches
1576          * things like \d under /d which does match the digits above 255, but
1577          * since the pattern is /d, it is not likely to be expecting them */
1578         if (! UNI_SEMANTICS) {
1579             if (start > 255) {
1580                 break;
1581             }
1582             end = MIN(end, 255);
1583         }
1584         count += end - start + 1;
1585         if (count > max_match) {
1586             invlist_iterfinish(ssc->invlist);
1587             return FALSE;
1588         }
1589     }
1590
1591     return TRUE;
1592 }
1593
1594
1595 STATIC void
1596 S_ssc_finalize(pTHX_ RExC_state_t *pRExC_state, regnode_ssc *ssc)
1597 {
1598     /* The inversion list in the SSC is marked mortal; now we need a more
1599      * permanent copy, which is stored the same way that is done in a regular
1600      * ANYOF node, with the first NUM_ANYOF_CODE_POINTS code points in a bit
1601      * map */
1602
1603     SV* invlist = invlist_clone(ssc->invlist);
1604
1605     PERL_ARGS_ASSERT_SSC_FINALIZE;
1606
1607     assert(is_ANYOF_SYNTHETIC(ssc));
1608
1609     /* The code in this file assumes that all but these flags aren't relevant
1610      * to the SSC, except SSC_MATCHES_EMPTY_STRING, which should be cleared
1611      * by the time we reach here */
1612     assert(! (ANYOF_FLAGS(ssc) & ~ANYOF_COMMON_FLAGS));
1613
1614     populate_ANYOF_from_invlist( (regnode *) ssc, &invlist);
1615
1616     set_ANYOF_arg(pRExC_state, (regnode *) ssc, invlist,
1617                                 NULL, NULL, NULL, FALSE);
1618
1619     /* Make sure is clone-safe */
1620     ssc->invlist = NULL;
1621
1622     if (ANYOF_POSIXL_SSC_TEST_ANY_SET(ssc)) {
1623         ANYOF_FLAGS(ssc) |= ANYOF_MATCHES_POSIXL;
1624     }
1625
1626     assert(! (ANYOF_FLAGS(ssc) & ANYOF_LOCALE_FLAGS) || RExC_contains_locale);
1627 }
1628
1629 #define TRIE_LIST_ITEM(state,idx) (trie->states[state].trans.list)[ idx ]
1630 #define TRIE_LIST_CUR(state)  ( TRIE_LIST_ITEM( state, 0 ).forid )
1631 #define TRIE_LIST_LEN(state) ( TRIE_LIST_ITEM( state, 0 ).newstate )
1632 #define TRIE_LIST_USED(idx)  ( trie->states[state].trans.list         \
1633                                ? (TRIE_LIST_CUR( idx ) - 1)           \
1634                                : 0 )
1635
1636
1637 #ifdef DEBUGGING
1638 /*
1639    dump_trie(trie,widecharmap,revcharmap)
1640    dump_trie_interim_list(trie,widecharmap,revcharmap,next_alloc)
1641    dump_trie_interim_table(trie,widecharmap,revcharmap,next_alloc)
1642
1643    These routines dump out a trie in a somewhat readable format.
1644    The _interim_ variants are used for debugging the interim
1645    tables that are used to generate the final compressed
1646    representation which is what dump_trie expects.
1647
1648    Part of the reason for their existence is to provide a form
1649    of documentation as to how the different representations function.
1650
1651 */
1652
1653 /*
1654   Dumps the final compressed table form of the trie to Perl_debug_log.
1655   Used for debugging make_trie().
1656 */
1657
1658 STATIC void
1659 S_dump_trie(pTHX_ const struct _reg_trie_data *trie, HV *widecharmap,
1660             AV *revcharmap, U32 depth)
1661 {
1662     U32 state;
1663     SV *sv=sv_newmortal();
1664     int colwidth= widecharmap ? 6 : 4;
1665     U16 word;
1666     GET_RE_DEBUG_FLAGS_DECL;
1667
1668     PERL_ARGS_ASSERT_DUMP_TRIE;
1669
1670     PerlIO_printf( Perl_debug_log, "%*sChar : %-6s%-6s%-4s ",
1671         (int)depth * 2 + 2,"",
1672         "Match","Base","Ofs" );
1673
1674     for( state = 0 ; state < trie->uniquecharcount ; state++ ) {
1675         SV ** const tmp = av_fetch( revcharmap, state, 0);
1676         if ( tmp ) {
1677             PerlIO_printf( Perl_debug_log, "%*s",
1678                 colwidth,
1679                 pv_pretty(sv, SvPV_nolen_const(*tmp), SvCUR(*tmp), colwidth,
1680                             PL_colors[0], PL_colors[1],
1681                             (SvUTF8(*tmp) ? PERL_PV_ESCAPE_UNI : 0) |
1682                             PERL_PV_ESCAPE_FIRSTCHAR
1683                 )
1684             );
1685         }
1686     }
1687     PerlIO_printf( Perl_debug_log, "\n%*sState|-----------------------",
1688         (int)depth * 2 + 2,"");
1689
1690     for( state = 0 ; state < trie->uniquecharcount ; state++ )
1691         PerlIO_printf( Perl_debug_log, "%.*s", colwidth, "--------");
1692     PerlIO_printf( Perl_debug_log, "\n");
1693
1694     for( state = 1 ; state < trie->statecount ; state++ ) {
1695         const U32 base = trie->states[ state ].trans.base;
1696
1697         PerlIO_printf( Perl_debug_log, "%*s#%4"UVXf"|",
1698                                        (int)depth * 2 + 2,"", (UV)state);
1699
1700         if ( trie->states[ state ].wordnum ) {
1701             PerlIO_printf( Perl_debug_log, " W%4X",
1702                                            trie->states[ state ].wordnum );
1703         } else {
1704             PerlIO_printf( Perl_debug_log, "%6s", "" );
1705         }
1706
1707         PerlIO_printf( Perl_debug_log, " @%4"UVXf" ", (UV)base );
1708
1709         if ( base ) {
1710             U32 ofs = 0;
1711
1712             while( ( base + ofs  < trie->uniquecharcount ) ||
1713                    ( base + ofs - trie->uniquecharcount < trie->lasttrans
1714                      && trie->trans[ base + ofs - trie->uniquecharcount ].check
1715                                                                     != state))
1716                     ofs++;
1717
1718             PerlIO_printf( Perl_debug_log, "+%2"UVXf"[ ", (UV)ofs);
1719
1720             for ( ofs = 0 ; ofs < trie->uniquecharcount ; ofs++ ) {
1721                 if ( ( base + ofs >= trie->uniquecharcount )
1722                         && ( base + ofs - trie->uniquecharcount
1723                                                         < trie->lasttrans )
1724                         && trie->trans[ base + ofs
1725                                     - trie->uniquecharcount ].check == state )
1726                 {
1727                    PerlIO_printf( Perl_debug_log, "%*"UVXf,
1728                     colwidth,
1729                     (UV)trie->trans[ base + ofs
1730                                              - trie->uniquecharcount ].next );
1731                 } else {
1732                     PerlIO_printf( Perl_debug_log, "%*s",colwidth,"   ." );
1733                 }
1734             }
1735
1736             PerlIO_printf( Perl_debug_log, "]");
1737
1738         }
1739         PerlIO_printf( Perl_debug_log, "\n" );
1740     }
1741     PerlIO_printf(Perl_debug_log, "%*sword_info N:(prev,len)=",
1742                                 (int)depth*2, "");
1743     for (word=1; word <= trie->wordcount; word++) {
1744         PerlIO_printf(Perl_debug_log, " %d:(%d,%d)",
1745             (int)word, (int)(trie->wordinfo[word].prev),
1746             (int)(trie->wordinfo[word].len));
1747     }
1748     PerlIO_printf(Perl_debug_log, "\n" );
1749 }
1750 /*
1751   Dumps a fully constructed but uncompressed trie in list form.
1752   List tries normally only are used for construction when the number of
1753   possible chars (trie->uniquecharcount) is very high.
1754   Used for debugging make_trie().
1755 */
1756 STATIC void
1757 S_dump_trie_interim_list(pTHX_ const struct _reg_trie_data *trie,
1758                          HV *widecharmap, AV *revcharmap, U32 next_alloc,
1759                          U32 depth)
1760 {
1761     U32 state;
1762     SV *sv=sv_newmortal();
1763     int colwidth= widecharmap ? 6 : 4;
1764     GET_RE_DEBUG_FLAGS_DECL;
1765
1766     PERL_ARGS_ASSERT_DUMP_TRIE_INTERIM_LIST;
1767
1768     /* print out the table precompression.  */
1769     PerlIO_printf( Perl_debug_log, "%*sState :Word | Transition Data\n%*s%s",
1770         (int)depth * 2 + 2,"", (int)depth * 2 + 2,"",
1771         "------:-----+-----------------\n" );
1772
1773     for( state=1 ; state < next_alloc ; state ++ ) {
1774         U16 charid;
1775
1776         PerlIO_printf( Perl_debug_log, "%*s %4"UVXf" :",
1777             (int)depth * 2 + 2,"", (UV)state  );
1778         if ( ! trie->states[ state ].wordnum ) {
1779             PerlIO_printf( Perl_debug_log, "%5s| ","");
1780         } else {
1781             PerlIO_printf( Perl_debug_log, "W%4x| ",
1782                 trie->states[ state ].wordnum
1783             );
1784         }
1785         for( charid = 1 ; charid <= TRIE_LIST_USED( state ) ; charid++ ) {
1786             SV ** const tmp = av_fetch( revcharmap,
1787                                         TRIE_LIST_ITEM(state,charid).forid, 0);
1788             if ( tmp ) {
1789                 PerlIO_printf( Perl_debug_log, "%*s:%3X=%4"UVXf" | ",
1790                     colwidth,
1791                     pv_pretty(sv, SvPV_nolen_const(*tmp), SvCUR(*tmp),
1792                               colwidth,
1793                               PL_colors[0], PL_colors[1],
1794                               (SvUTF8(*tmp) ? PERL_PV_ESCAPE_UNI : 0)
1795                               | PERL_PV_ESCAPE_FIRSTCHAR
1796                     ) ,
1797                     TRIE_LIST_ITEM(state,charid).forid,
1798                     (UV)TRIE_LIST_ITEM(state,charid).newstate
1799                 );
1800                 if (!(charid % 10))
1801                     PerlIO_printf(Perl_debug_log, "\n%*s| ",
1802                         (int)((depth * 2) + 14), "");
1803             }
1804         }
1805         PerlIO_printf( Perl_debug_log, "\n");
1806     }
1807 }
1808
1809 /*
1810   Dumps a fully constructed but uncompressed trie in table form.
1811   This is the normal DFA style state transition table, with a few
1812   twists to facilitate compression later.
1813   Used for debugging make_trie().
1814 */
1815 STATIC void
1816 S_dump_trie_interim_table(pTHX_ const struct _reg_trie_data *trie,
1817                           HV *widecharmap, AV *revcharmap, U32 next_alloc,
1818                           U32 depth)
1819 {
1820     U32 state;
1821     U16 charid;
1822     SV *sv=sv_newmortal();
1823     int colwidth= widecharmap ? 6 : 4;
1824     GET_RE_DEBUG_FLAGS_DECL;
1825
1826     PERL_ARGS_ASSERT_DUMP_TRIE_INTERIM_TABLE;
1827
1828     /*
1829        print out the table precompression so that we can do a visual check
1830        that they are identical.
1831      */
1832
1833     PerlIO_printf( Perl_debug_log, "%*sChar : ",(int)depth * 2 + 2,"" );
1834
1835     for( charid = 0 ; charid < trie->uniquecharcount ; charid++ ) {
1836         SV ** const tmp = av_fetch( revcharmap, charid, 0);
1837         if ( tmp ) {
1838             PerlIO_printf( Perl_debug_log, "%*s",
1839                 colwidth,
1840                 pv_pretty(sv, SvPV_nolen_const(*tmp), SvCUR(*tmp), colwidth,
1841                             PL_colors[0], PL_colors[1],
1842                             (SvUTF8(*tmp) ? PERL_PV_ESCAPE_UNI : 0) |
1843                             PERL_PV_ESCAPE_FIRSTCHAR
1844                 )
1845             );
1846         }
1847     }
1848
1849     PerlIO_printf( Perl_debug_log, "\n%*sState+-",(int)depth * 2 + 2,"" );
1850
1851     for( charid=0 ; charid < trie->uniquecharcount ; charid++ ) {
1852         PerlIO_printf( Perl_debug_log, "%.*s", colwidth,"--------");
1853     }
1854
1855     PerlIO_printf( Perl_debug_log, "\n" );
1856
1857     for( state=1 ; state < next_alloc ; state += trie->uniquecharcount ) {
1858
1859         PerlIO_printf( Perl_debug_log, "%*s%4"UVXf" : ",
1860             (int)depth * 2 + 2,"",
1861             (UV)TRIE_NODENUM( state ) );
1862
1863         for( charid = 0 ; charid < trie->uniquecharcount ; charid++ ) {
1864             UV v=(UV)SAFE_TRIE_NODENUM( trie->trans[ state + charid ].next );
1865             if (v)
1866                 PerlIO_printf( Perl_debug_log, "%*"UVXf, colwidth, v );
1867             else
1868                 PerlIO_printf( Perl_debug_log, "%*s", colwidth, "." );
1869         }
1870         if ( ! trie->states[ TRIE_NODENUM( state ) ].wordnum ) {
1871             PerlIO_printf( Perl_debug_log, " (%4"UVXf")\n",
1872                                             (UV)trie->trans[ state ].check );
1873         } else {
1874             PerlIO_printf( Perl_debug_log, " (%4"UVXf") W%4X\n",
1875                                             (UV)trie->trans[ state ].check,
1876             trie->states[ TRIE_NODENUM( state ) ].wordnum );
1877         }
1878     }
1879 }
1880
1881 #endif
1882
1883
1884 /* make_trie(startbranch,first,last,tail,word_count,flags,depth)
1885   startbranch: the first branch in the whole branch sequence
1886   first      : start branch of sequence of branch-exact nodes.
1887                May be the same as startbranch
1888   last       : Thing following the last branch.
1889                May be the same as tail.
1890   tail       : item following the branch sequence
1891   count      : words in the sequence
1892   flags      : currently the OP() type we will be building one of /EXACT(|F|FA|FU|FU_SS|L|FLU8)/
1893   depth      : indent depth
1894
1895 Inplace optimizes a sequence of 2 or more Branch-Exact nodes into a TRIE node.
1896
1897 A trie is an N'ary tree where the branches are determined by digital
1898 decomposition of the key. IE, at the root node you look up the 1st character and
1899 follow that branch repeat until you find the end of the branches. Nodes can be
1900 marked as "accepting" meaning they represent a complete word. Eg:
1901
1902   /he|she|his|hers/
1903
1904 would convert into the following structure. Numbers represent states, letters
1905 following numbers represent valid transitions on the letter from that state, if
1906 the number is in square brackets it represents an accepting state, otherwise it
1907 will be in parenthesis.
1908
1909       +-h->+-e->[3]-+-r->(8)-+-s->[9]
1910       |    |
1911       |   (2)
1912       |    |
1913      (1)   +-i->(6)-+-s->[7]
1914       |
1915       +-s->(3)-+-h->(4)-+-e->[5]
1916
1917       Accept Word Mapping: 3=>1 (he),5=>2 (she), 7=>3 (his), 9=>4 (hers)
1918
1919 This shows that when matching against the string 'hers' we will begin at state 1
1920 read 'h' and move to state 2, read 'e' and move to state 3 which is accepting,
1921 then read 'r' and go to state 8 followed by 's' which takes us to state 9 which
1922 is also accepting. Thus we know that we can match both 'he' and 'hers' with a
1923 single traverse. We store a mapping from accepting to state to which word was
1924 matched, and then when we have multiple possibilities we try to complete the
1925 rest of the regex in the order in which they occurred in the alternation.
1926
1927 The only prior NFA like behaviour that would be changed by the TRIE support is
1928 the silent ignoring of duplicate alternations which are of the form:
1929
1930  / (DUPE|DUPE) X? (?{ ... }) Y /x
1931
1932 Thus EVAL blocks following a trie may be called a different number of times with
1933 and without the optimisation. With the optimisations dupes will be silently
1934 ignored. This inconsistent behaviour of EVAL type nodes is well established as
1935 the following demonstrates:
1936
1937  'words'=~/(word|word|word)(?{ print $1 })[xyz]/
1938
1939 which prints out 'word' three times, but
1940
1941  'words'=~/(word|word|word)(?{ print $1 })S/
1942
1943 which doesnt print it out at all. This is due to other optimisations kicking in.
1944
1945 Example of what happens on a structural level:
1946
1947 The regexp /(ac|ad|ab)+/ will produce the following debug output:
1948
1949    1: CURLYM[1] {1,32767}(18)
1950    5:   BRANCH(8)
1951    6:     EXACT <ac>(16)
1952    8:   BRANCH(11)
1953    9:     EXACT <ad>(16)
1954   11:   BRANCH(14)
1955   12:     EXACT <ab>(16)
1956   16:   SUCCEED(0)
1957   17:   NOTHING(18)
1958   18: END(0)
1959
1960 This would be optimizable with startbranch=5, first=5, last=16, tail=16
1961 and should turn into:
1962
1963    1: CURLYM[1] {1,32767}(18)
1964    5:   TRIE(16)
1965         [Words:3 Chars Stored:6 Unique Chars:4 States:5 NCP:1]
1966           <ac>
1967           <ad>
1968           <ab>
1969   16:   SUCCEED(0)
1970   17:   NOTHING(18)
1971   18: END(0)
1972
1973 Cases where tail != last would be like /(?foo|bar)baz/:
1974
1975    1: BRANCH(4)
1976    2:   EXACT <foo>(8)
1977    4: BRANCH(7)
1978    5:   EXACT <bar>(8)
1979    7: TAIL(8)
1980    8: EXACT <baz>(10)
1981   10: END(0)
1982
1983 which would be optimizable with startbranch=1, first=1, last=7, tail=8
1984 and would end up looking like:
1985
1986     1: TRIE(8)
1987       [Words:2 Chars Stored:6 Unique Chars:5 States:7 NCP:1]
1988         <foo>
1989         <bar>
1990    7: TAIL(8)
1991    8: EXACT <baz>(10)
1992   10: END(0)
1993
1994     d = uvchr_to_utf8_flags(d, uv, 0);
1995
1996 is the recommended Unicode-aware way of saying
1997
1998     *(d++) = uv;
1999 */
2000
2001 #define TRIE_STORE_REVCHAR(val)                                            \
2002     STMT_START {                                                           \
2003         if (UTF) {                                                         \
2004             SV *zlopp = newSV(7); /* XXX: optimize me */                   \
2005             unsigned char *flrbbbbb = (unsigned char *) SvPVX(zlopp);      \
2006             unsigned const char *const kapow = uvchr_to_utf8(flrbbbbb, val); \
2007             SvCUR_set(zlopp, kapow - flrbbbbb);                            \
2008             SvPOK_on(zlopp);                                               \
2009             SvUTF8_on(zlopp);                                              \
2010             av_push(revcharmap, zlopp);                                    \
2011         } else {                                                           \
2012             char ooooff = (char)val;                                           \
2013             av_push(revcharmap, newSVpvn(&ooooff, 1));                     \
2014         }                                                                  \
2015         } STMT_END
2016
2017 /* This gets the next character from the input, folding it if not already
2018  * folded. */
2019 #define TRIE_READ_CHAR STMT_START {                                           \
2020     wordlen++;                                                                \
2021     if ( UTF ) {                                                              \
2022         /* if it is UTF then it is either already folded, or does not need    \
2023          * folding */                                                         \
2024         uvc = valid_utf8_to_uvchr( (const U8*) uc, &len);                     \
2025     }                                                                         \
2026     else if (folder == PL_fold_latin1) {                                      \
2027         /* This folder implies Unicode rules, which in the range expressible  \
2028          *  by not UTF is the lower case, with the two exceptions, one of     \
2029          *  which should have been taken care of before calling this */       \
2030         assert(*uc != LATIN_SMALL_LETTER_SHARP_S);                            \
2031         uvc = toLOWER_L1(*uc);                                                \
2032         if (UNLIKELY(uvc == MICRO_SIGN)) uvc = GREEK_SMALL_LETTER_MU;         \
2033         len = 1;                                                              \
2034     } else {                                                                  \
2035         /* raw data, will be folded later if needed */                        \
2036         uvc = (U32)*uc;                                                       \
2037         len = 1;                                                              \
2038     }                                                                         \
2039 } STMT_END
2040
2041
2042
2043 #define TRIE_LIST_PUSH(state,fid,ns) STMT_START {               \
2044     if ( TRIE_LIST_CUR( state ) >=TRIE_LIST_LEN( state ) ) {    \
2045         U32 ging = TRIE_LIST_LEN( state ) *= 2;                 \
2046         Renew( trie->states[ state ].trans.list, ging, reg_trie_trans_le ); \
2047     }                                                           \
2048     TRIE_LIST_ITEM( state, TRIE_LIST_CUR( state ) ).forid = fid;     \
2049     TRIE_LIST_ITEM( state, TRIE_LIST_CUR( state ) ).newstate = ns;   \
2050     TRIE_LIST_CUR( state )++;                                   \
2051 } STMT_END
2052
2053 #define TRIE_LIST_NEW(state) STMT_START {                       \
2054     Newxz( trie->states[ state ].trans.list,               \
2055         4, reg_trie_trans_le );                                 \
2056      TRIE_LIST_CUR( state ) = 1;                                \
2057      TRIE_LIST_LEN( state ) = 4;                                \
2058 } STMT_END
2059
2060 #define TRIE_HANDLE_WORD(state) STMT_START {                    \
2061     U16 dupe= trie->states[ state ].wordnum;                    \
2062     regnode * const noper_next = regnext( noper );              \
2063                                                                 \
2064     DEBUG_r({                                                   \
2065         /* store the word for dumping */                        \
2066         SV* tmp;                                                \
2067         if (OP(noper) != NOTHING)                               \
2068             tmp = newSVpvn_utf8(STRING(noper), STR_LEN(noper), UTF);    \
2069         else                                                    \
2070             tmp = newSVpvn_utf8( "", 0, UTF );                  \
2071         av_push( trie_words, tmp );                             \
2072     });                                                         \
2073                                                                 \
2074     curword++;                                                  \
2075     trie->wordinfo[curword].prev   = 0;                         \
2076     trie->wordinfo[curword].len    = wordlen;                   \
2077     trie->wordinfo[curword].accept = state;                     \
2078                                                                 \
2079     if ( noper_next < tail ) {                                  \
2080         if (!trie->jump)                                        \
2081             trie->jump = (U16 *) PerlMemShared_calloc( word_count + 1, \
2082                                                  sizeof(U16) ); \
2083         trie->jump[curword] = (U16)(noper_next - convert);      \
2084         if (!jumper)                                            \
2085             jumper = noper_next;                                \
2086         if (!nextbranch)                                        \
2087             nextbranch= regnext(cur);                           \
2088     }                                                           \
2089                                                                 \
2090     if ( dupe ) {                                               \
2091         /* It's a dupe. Pre-insert into the wordinfo[].prev   */\
2092         /* chain, so that when the bits of chain are later    */\
2093         /* linked together, the dups appear in the chain      */\
2094         trie->wordinfo[curword].prev = trie->wordinfo[dupe].prev; \
2095         trie->wordinfo[dupe].prev = curword;                    \
2096     } else {                                                    \
2097         /* we haven't inserted this word yet.                */ \
2098         trie->states[ state ].wordnum = curword;                \
2099     }                                                           \
2100 } STMT_END
2101
2102
2103 #define TRIE_TRANS_STATE(state,base,ucharcount,charid,special)          \
2104      ( ( base + charid >=  ucharcount                                   \
2105          && base + charid < ubound                                      \
2106          && state == trie->trans[ base - ucharcount + charid ].check    \
2107          && trie->trans[ base - ucharcount + charid ].next )            \
2108            ? trie->trans[ base - ucharcount + charid ].next             \
2109            : ( state==1 ? special : 0 )                                 \
2110       )
2111
2112 #define MADE_TRIE       1
2113 #define MADE_JUMP_TRIE  2
2114 #define MADE_EXACT_TRIE 4
2115
2116 STATIC I32
2117 S_make_trie(pTHX_ RExC_state_t *pRExC_state, regnode *startbranch,
2118                   regnode *first, regnode *last, regnode *tail,
2119                   U32 word_count, U32 flags, U32 depth)
2120 {
2121     /* first pass, loop through and scan words */
2122     reg_trie_data *trie;
2123     HV *widecharmap = NULL;
2124     AV *revcharmap = newAV();
2125     regnode *cur;
2126     STRLEN len = 0;
2127     UV uvc = 0;
2128     U16 curword = 0;
2129     U32 next_alloc = 0;
2130     regnode *jumper = NULL;
2131     regnode *nextbranch = NULL;
2132     regnode *convert = NULL;
2133     U32 *prev_states; /* temp array mapping each state to previous one */
2134     /* we just use folder as a flag in utf8 */
2135     const U8 * folder = NULL;
2136
2137 #ifdef DEBUGGING
2138     const U32 data_slot = add_data( pRExC_state, STR_WITH_LEN("tuuu"));
2139     AV *trie_words = NULL;
2140     /* along with revcharmap, this only used during construction but both are
2141      * useful during debugging so we store them in the struct when debugging.
2142      */
2143 #else
2144     const U32 data_slot = add_data( pRExC_state, STR_WITH_LEN("tu"));
2145     STRLEN trie_charcount=0;
2146 #endif
2147     SV *re_trie_maxbuff;
2148     GET_RE_DEBUG_FLAGS_DECL;
2149
2150     PERL_ARGS_ASSERT_MAKE_TRIE;
2151 #ifndef DEBUGGING
2152     PERL_UNUSED_ARG(depth);
2153 #endif
2154
2155     switch (flags) {
2156         case EXACT: case EXACTL: break;
2157         case EXACTFA:
2158         case EXACTFU_SS:
2159         case EXACTFU:
2160         case EXACTFLU8: folder = PL_fold_latin1; break;
2161         case EXACTF:  folder = PL_fold; break;
2162         default: Perl_croak( aTHX_ "panic! In trie construction, unknown node type %u %s", (unsigned) flags, PL_reg_name[flags] );
2163     }
2164
2165     trie = (reg_trie_data *) PerlMemShared_calloc( 1, sizeof(reg_trie_data) );
2166     trie->refcount = 1;
2167     trie->startstate = 1;
2168     trie->wordcount = word_count;
2169     RExC_rxi->data->data[ data_slot ] = (void*)trie;
2170     trie->charmap = (U16 *) PerlMemShared_calloc( 256, sizeof(U16) );
2171     if (flags == EXACT || flags == EXACTL)
2172         trie->bitmap = (char *) PerlMemShared_calloc( ANYOF_BITMAP_SIZE, 1 );
2173     trie->wordinfo = (reg_trie_wordinfo *) PerlMemShared_calloc(
2174                        trie->wordcount+1, sizeof(reg_trie_wordinfo));
2175
2176     DEBUG_r({
2177         trie_words = newAV();
2178     });
2179
2180     re_trie_maxbuff = get_sv(RE_TRIE_MAXBUF_NAME, 1);
2181     assert(re_trie_maxbuff);
2182     if (!SvIOK(re_trie_maxbuff)) {
2183         sv_setiv(re_trie_maxbuff, RE_TRIE_MAXBUF_INIT);
2184     }
2185     DEBUG_TRIE_COMPILE_r({
2186         PerlIO_printf( Perl_debug_log,
2187           "%*smake_trie start==%d, first==%d, last==%d, tail==%d depth=%d\n",
2188           (int)depth * 2 + 2, "",
2189           REG_NODE_NUM(startbranch),REG_NODE_NUM(first),
2190           REG_NODE_NUM(last), REG_NODE_NUM(tail), (int)depth);
2191     });
2192
2193    /* Find the node we are going to overwrite */
2194     if ( first == startbranch && OP( last ) != BRANCH ) {
2195         /* whole branch chain */
2196         convert = first;
2197     } else {
2198         /* branch sub-chain */
2199         convert = NEXTOPER( first );
2200     }
2201
2202     /*  -- First loop and Setup --
2203
2204        We first traverse the branches and scan each word to determine if it
2205        contains widechars, and how many unique chars there are, this is
2206        important as we have to build a table with at least as many columns as we
2207        have unique chars.
2208
2209        We use an array of integers to represent the character codes 0..255
2210        (trie->charmap) and we use a an HV* to store Unicode characters. We use
2211        the native representation of the character value as the key and IV's for
2212        the coded index.
2213
2214        *TODO* If we keep track of how many times each character is used we can
2215        remap the columns so that the table compression later on is more
2216        efficient in terms of memory by ensuring the most common value is in the
2217        middle and the least common are on the outside.  IMO this would be better
2218        than a most to least common mapping as theres a decent chance the most
2219        common letter will share a node with the least common, meaning the node
2220        will not be compressible. With a middle is most common approach the worst
2221        case is when we have the least common nodes twice.
2222
2223      */
2224
2225     for ( cur = first ; cur < last ; cur = regnext( cur ) ) {
2226         regnode *noper = NEXTOPER( cur );
2227         const U8 *uc = (U8*)STRING( noper );
2228         const U8 *e  = uc + STR_LEN( noper );
2229         int foldlen = 0;
2230         U32 wordlen      = 0;         /* required init */
2231         STRLEN minchars = 0;
2232         STRLEN maxchars = 0;
2233         bool set_bit = trie->bitmap ? 1 : 0; /*store the first char in the
2234                                                bitmap?*/
2235
2236         if (OP(noper) == NOTHING) {
2237             regnode *noper_next= regnext(noper);
2238             if (noper_next != tail && OP(noper_next) == flags) {
2239                 noper = noper_next;
2240                 uc= (U8*)STRING(noper);
2241                 e= uc + STR_LEN(noper);
2242                 trie->minlen= STR_LEN(noper);
2243             } else {
2244                 trie->minlen= 0;
2245                 continue;
2246             }
2247         }
2248
2249         if ( set_bit ) { /* bitmap only alloced when !(UTF&&Folding) */
2250             TRIE_BITMAP_SET(trie,*uc); /* store the raw first byte
2251                                           regardless of encoding */
2252             if (OP( noper ) == EXACTFU_SS) {
2253                 /* false positives are ok, so just set this */
2254                 TRIE_BITMAP_SET(trie, LATIN_SMALL_LETTER_SHARP_S);
2255             }
2256         }
2257         for ( ; uc < e ; uc += len ) {  /* Look at each char in the current
2258                                            branch */
2259             TRIE_CHARCOUNT(trie)++;
2260             TRIE_READ_CHAR;
2261
2262             /* TRIE_READ_CHAR returns the current character, or its fold if /i
2263              * is in effect.  Under /i, this character can match itself, or
2264              * anything that folds to it.  If not under /i, it can match just
2265              * itself.  Most folds are 1-1, for example k, K, and KELVIN SIGN
2266              * all fold to k, and all are single characters.   But some folds
2267              * expand to more than one character, so for example LATIN SMALL
2268              * LIGATURE FFI folds to the three character sequence 'ffi'.  If
2269              * the string beginning at 'uc' is 'ffi', it could be matched by
2270              * three characters, or just by the one ligature character. (It
2271              * could also be matched by two characters: LATIN SMALL LIGATURE FF
2272              * followed by 'i', or by 'f' followed by LATIN SMALL LIGATURE FI).
2273              * (Of course 'I' and/or 'F' instead of 'i' and 'f' can also
2274              * match.)  The trie needs to know the minimum and maximum number
2275              * of characters that could match so that it can use size alone to
2276              * quickly reject many match attempts.  The max is simple: it is
2277              * the number of folded characters in this branch (since a fold is
2278              * never shorter than what folds to it. */
2279
2280             maxchars++;
2281
2282             /* And the min is equal to the max if not under /i (indicated by
2283              * 'folder' being NULL), or there are no multi-character folds.  If
2284              * there is a multi-character fold, the min is incremented just
2285              * once, for the character that folds to the sequence.  Each
2286              * character in the sequence needs to be added to the list below of
2287              * characters in the trie, but we count only the first towards the
2288              * min number of characters needed.  This is done through the
2289              * variable 'foldlen', which is returned by the macros that look
2290              * for these sequences as the number of bytes the sequence
2291              * occupies.  Each time through the loop, we decrement 'foldlen' by
2292              * how many bytes the current char occupies.  Only when it reaches
2293              * 0 do we increment 'minchars' or look for another multi-character
2294              * sequence. */
2295             if (folder == NULL) {
2296                 minchars++;
2297             }
2298             else if (foldlen > 0) {
2299                 foldlen -= (UTF) ? UTF8SKIP(uc) : 1;
2300             }
2301             else {
2302                 minchars++;
2303
2304                 /* See if *uc is the beginning of a multi-character fold.  If
2305                  * so, we decrement the length remaining to look at, to account
2306                  * for the current character this iteration.  (We can use 'uc'
2307                  * instead of the fold returned by TRIE_READ_CHAR because for
2308                  * non-UTF, the latin1_safe macro is smart enough to account
2309                  * for all the unfolded characters, and because for UTF, the
2310                  * string will already have been folded earlier in the
2311                  * compilation process */
2312                 if (UTF) {
2313                     if ((foldlen = is_MULTI_CHAR_FOLD_utf8_safe(uc, e))) {
2314                         foldlen -= UTF8SKIP(uc);
2315                     }
2316                 }
2317                 else if ((foldlen = is_MULTI_CHAR_FOLD_latin1_safe(uc, e))) {
2318                     foldlen--;
2319                 }
2320             }
2321
2322             /* The current character (and any potential folds) should be added
2323              * to the possible matching characters for this position in this
2324              * branch */
2325             if ( uvc < 256 ) {
2326                 if ( folder ) {
2327                     U8 folded= folder[ (U8) uvc ];
2328                     if ( !trie->charmap[ folded ] ) {
2329                         trie->charmap[ folded ]=( ++trie->uniquecharcount );
2330                         TRIE_STORE_REVCHAR( folded );
2331                     }
2332                 }
2333                 if ( !trie->charmap[ uvc ] ) {
2334                     trie->charmap[ uvc ]=( ++trie->uniquecharcount );
2335                     TRIE_STORE_REVCHAR( uvc );
2336                 }
2337                 if ( set_bit ) {
2338                     /* store the codepoint in the bitmap, and its folded
2339                      * equivalent. */
2340                     TRIE_BITMAP_SET(trie, uvc);
2341
2342                     /* store the folded codepoint */
2343                     if ( folder ) TRIE_BITMAP_SET(trie, folder[(U8) uvc ]);
2344
2345                     if ( !UTF ) {
2346                         /* store first byte of utf8 representation of
2347                            variant codepoints */
2348                         if (! UVCHR_IS_INVARIANT(uvc)) {
2349                             TRIE_BITMAP_SET(trie, UTF8_TWO_BYTE_HI(uvc));
2350                         }
2351                     }
2352                     set_bit = 0; /* We've done our bit :-) */
2353                 }
2354             } else {
2355
2356                 /* XXX We could come up with the list of code points that fold
2357                  * to this using PL_utf8_foldclosures, except not for
2358                  * multi-char folds, as there may be multiple combinations
2359                  * there that could work, which needs to wait until runtime to
2360                  * resolve (The comment about LIGATURE FFI above is such an
2361                  * example */
2362
2363                 SV** svpp;
2364                 if ( !widecharmap )
2365                     widecharmap = newHV();
2366
2367                 svpp = hv_fetch( widecharmap, (char*)&uvc, sizeof( UV ), 1 );
2368
2369                 if ( !svpp )
2370                     Perl_croak( aTHX_ "error creating/fetching widecharmap entry for 0x%"UVXf, uvc );
2371
2372                 if ( !SvTRUE( *svpp ) ) {
2373                     sv_setiv( *svpp, ++trie->uniquecharcount );
2374                     TRIE_STORE_REVCHAR(uvc);
2375                 }
2376             }
2377         } /* end loop through characters in this branch of the trie */
2378
2379         /* We take the min and max for this branch and combine to find the min
2380          * and max for all branches processed so far */
2381         if( cur == first ) {
2382             trie->minlen = minchars;
2383             trie->maxlen = maxchars;
2384         } else if (minchars < trie->minlen) {
2385             trie->minlen = minchars;
2386         } else if (maxchars > trie->maxlen) {
2387             trie->maxlen = maxchars;
2388         }
2389     } /* end first pass */
2390     DEBUG_TRIE_COMPILE_r(
2391         PerlIO_printf( Perl_debug_log,
2392                 "%*sTRIE(%s): W:%d C:%d Uq:%d Min:%d Max:%d\n",
2393                 (int)depth * 2 + 2,"",
2394                 ( widecharmap ? "UTF8" : "NATIVE" ), (int)word_count,
2395                 (int)TRIE_CHARCOUNT(trie), trie->uniquecharcount,
2396                 (int)trie->minlen, (int)trie->maxlen )
2397     );
2398
2399     /*
2400         We now know what we are dealing with in terms of unique chars and
2401         string sizes so we can calculate how much memory a naive
2402         representation using a flat table  will take. If it's over a reasonable
2403         limit (as specified by ${^RE_TRIE_MAXBUF}) we use a more memory
2404         conservative but potentially much slower representation using an array
2405         of lists.
2406
2407         At the end we convert both representations into the same compressed
2408         form that will be used in regexec.c for matching with. The latter
2409         is a form that cannot be used to construct with but has memory
2410         properties similar to the list form and access properties similar
2411         to the table form making it both suitable for fast searches and
2412         small enough that its feasable to store for the duration of a program.
2413
2414         See the comment in the code where the compressed table is produced
2415         inplace from the flat tabe representation for an explanation of how
2416         the compression works.
2417
2418     */
2419
2420
2421     Newx(prev_states, TRIE_CHARCOUNT(trie) + 2, U32);
2422     prev_states[1] = 0;
2423
2424     if ( (IV)( ( TRIE_CHARCOUNT(trie) + 1 ) * trie->uniquecharcount + 1)
2425                                                     > SvIV(re_trie_maxbuff) )
2426     {
2427         /*
2428             Second Pass -- Array Of Lists Representation
2429
2430             Each state will be represented by a list of charid:state records
2431             (reg_trie_trans_le) the first such element holds the CUR and LEN
2432             points of the allocated array. (See defines above).
2433
2434             We build the initial structure using the lists, and then convert
2435             it into the compressed table form which allows faster lookups
2436             (but cant be modified once converted).
2437         */
2438
2439         STRLEN transcount = 1;
2440
2441         DEBUG_TRIE_COMPILE_MORE_r( PerlIO_printf( Perl_debug_log,
2442             "%*sCompiling trie using list compiler\n",
2443             (int)depth * 2 + 2, ""));
2444
2445         trie->states = (reg_trie_state *)
2446             PerlMemShared_calloc( TRIE_CHARCOUNT(trie) + 2,
2447                                   sizeof(reg_trie_state) );
2448         TRIE_LIST_NEW(1);
2449         next_alloc = 2;
2450
2451         for ( cur = first ; cur < last ; cur = regnext( cur ) ) {
2452
2453             regnode *noper   = NEXTOPER( cur );
2454             U8 *uc           = (U8*)STRING( noper );
2455             const U8 *e      = uc + STR_LEN( noper );
2456             U32 state        = 1;         /* required init */
2457             U16 charid       = 0;         /* sanity init */
2458             U32 wordlen      = 0;         /* required init */
2459
2460             if (OP(noper) == NOTHING) {
2461                 regnode *noper_next= regnext(noper);
2462                 if (noper_next != tail && OP(noper_next) == flags) {
2463                     noper = noper_next;
2464                     uc= (U8*)STRING(noper);
2465                     e= uc + STR_LEN(noper);
2466                 }
2467             }
2468
2469             if (OP(noper) != NOTHING) {
2470                 for ( ; uc < e ; uc += len ) {
2471
2472                     TRIE_READ_CHAR;
2473
2474                     if ( uvc < 256 ) {
2475                         charid = trie->charmap[ uvc ];
2476                     } else {
2477                         SV** const svpp = hv_fetch( widecharmap,
2478                                                     (char*)&uvc,
2479                                                     sizeof( UV ),
2480                                                     0);
2481                         if ( !svpp ) {
2482                             charid = 0;
2483                         } else {
2484                             charid=(U16)SvIV( *svpp );
2485                         }
2486                     }
2487                     /* charid is now 0 if we dont know the char read, or
2488                      * nonzero if we do */
2489                     if ( charid ) {
2490
2491                         U16 check;
2492                         U32 newstate = 0;
2493
2494                         charid--;
2495                         if ( !trie->states[ state ].trans.list ) {
2496                             TRIE_LIST_NEW( state );
2497                         }
2498                         for ( check = 1;
2499                               check <= TRIE_LIST_USED( state );
2500                               check++ )
2501                         {
2502                             if ( TRIE_LIST_ITEM( state, check ).forid
2503                                                                     == charid )
2504                             {
2505                                 newstate = TRIE_LIST_ITEM( state, check ).newstate;
2506                                 break;
2507                             }
2508                         }
2509                         if ( ! newstate ) {
2510                             newstate = next_alloc++;
2511                             prev_states[newstate] = state;
2512                             TRIE_LIST_PUSH( state, charid, newstate );
2513                             transcount++;
2514                         }
2515                         state = newstate;
2516                     } else {
2517                         Perl_croak( aTHX_ "panic! In trie construction, no char mapping for %"IVdf, uvc );
2518                     }
2519                 }
2520             }
2521             TRIE_HANDLE_WORD(state);
2522
2523         } /* end second pass */
2524
2525         /* next alloc is the NEXT state to be allocated */
2526         trie->statecount = next_alloc;
2527         trie->states = (reg_trie_state *)
2528             PerlMemShared_realloc( trie->states,
2529                                    next_alloc
2530                                    * sizeof(reg_trie_state) );
2531
2532         /* and now dump it out before we compress it */
2533         DEBUG_TRIE_COMPILE_MORE_r(dump_trie_interim_list(trie, widecharmap,
2534                                                          revcharmap, next_alloc,
2535                                                          depth+1)
2536         );
2537
2538         trie->trans = (reg_trie_trans *)
2539             PerlMemShared_calloc( transcount, sizeof(reg_trie_trans) );
2540         {
2541             U32 state;
2542             U32 tp = 0;
2543             U32 zp = 0;
2544
2545
2546             for( state=1 ; state < next_alloc ; state ++ ) {
2547                 U32 base=0;
2548
2549                 /*
2550                 DEBUG_TRIE_COMPILE_MORE_r(
2551                     PerlIO_printf( Perl_debug_log, "tp: %d zp: %d ",tp,zp)
2552                 );
2553                 */
2554
2555                 if (trie->states[state].trans.list) {
2556                     U16 minid=TRIE_LIST_ITEM( state, 1).forid;
2557                     U16 maxid=minid;
2558                     U16 idx;
2559
2560                     for( idx = 2 ; idx <= TRIE_LIST_USED( state ) ; idx++ ) {
2561                         const U16 forid = TRIE_LIST_ITEM( state, idx).forid;
2562                         if ( forid < minid ) {
2563                             minid=forid;
2564                         } else if ( forid > maxid ) {
2565                             maxid=forid;
2566                         }
2567                     }
2568                     if ( transcount < tp + maxid - minid + 1) {
2569                         transcount *= 2;
2570                         trie->trans = (reg_trie_trans *)
2571                             PerlMemShared_realloc( trie->trans,
2572                                                      transcount
2573                                                      * sizeof(reg_trie_trans) );
2574                         Zero( trie->trans + (transcount / 2),
2575                               transcount / 2,
2576                               reg_trie_trans );
2577                     }
2578                     base = trie->uniquecharcount + tp - minid;
2579                     if ( maxid == minid ) {
2580                         U32 set = 0;
2581                         for ( ; zp < tp ; zp++ ) {
2582                             if ( ! trie->trans[ zp ].next ) {
2583                                 base = trie->uniquecharcount + zp - minid;
2584                                 trie->trans[ zp ].next = TRIE_LIST_ITEM( state,
2585                                                                    1).newstate;
2586                                 trie->trans[ zp ].check = state;
2587                                 set = 1;
2588                                 break;
2589                             }
2590                         }
2591                         if ( !set ) {
2592                             trie->trans[ tp ].next = TRIE_LIST_ITEM( state,
2593                                                                    1).newstate;
2594                             trie->trans[ tp ].check = state;
2595                             tp++;
2596                             zp = tp;
2597                         }
2598                     } else {
2599                         for ( idx=1; idx <= TRIE_LIST_USED( state ) ; idx++ ) {
2600                             const U32 tid = base
2601                                            - trie->uniquecharcount
2602                                            + TRIE_LIST_ITEM( state, idx ).forid;
2603                             trie->trans[ tid ].next = TRIE_LIST_ITEM( state,
2604                                                                 idx ).newstate;
2605                             trie->trans[ tid ].check = state;
2606                         }
2607                         tp += ( maxid - minid + 1 );
2608                     }
2609                     Safefree(trie->states[ state ].trans.list);
2610                 }
2611                 /*
2612                 DEBUG_TRIE_COMPILE_MORE_r(
2613                     PerlIO_printf( Perl_debug_log, " base: %d\n",base);
2614                 );
2615                 */
2616                 trie->states[ state ].trans.base=base;
2617             }
2618             trie->lasttrans = tp + 1;
2619         }
2620     } else {
2621         /*
2622            Second Pass -- Flat Table Representation.
2623
2624            we dont use the 0 slot of either trans[] or states[] so we add 1 to
2625            each.  We know that we will need Charcount+1 trans at most to store
2626            the data (one row per char at worst case) So we preallocate both
2627            structures assuming worst case.
2628
2629            We then construct the trie using only the .next slots of the entry
2630            structs.
2631
2632            We use the .check field of the first entry of the node temporarily
2633            to make compression both faster and easier by keeping track of how
2634            many non zero fields are in the node.
2635
2636            Since trans are numbered from 1 any 0 pointer in the table is a FAIL
2637            transition.
2638
2639            There are two terms at use here: state as a TRIE_NODEIDX() which is
2640            a number representing the first entry of the node, and state as a
2641            TRIE_NODENUM() which is the trans number. state 1 is TRIE_NODEIDX(1)
2642            and TRIE_NODENUM(1), state 2 is TRIE_NODEIDX(2) and TRIE_NODENUM(3)
2643            if there are 2 entrys per node. eg:
2644
2645              A B       A B
2646           1. 2 4    1. 3 7
2647           2. 0 3    3. 0 5
2648           3. 0 0    5. 0 0
2649           4. 0 0    7. 0 0
2650
2651            The table is internally in the right hand, idx form. However as we
2652            also have to deal with the states array which is indexed by nodenum
2653            we have to use TRIE_NODENUM() to convert.
2654
2655         */
2656         DEBUG_TRIE_COMPILE_MORE_r( PerlIO_printf( Perl_debug_log,
2657             "%*sCompiling trie using table compiler\n",
2658             (int)depth * 2 + 2, ""));
2659
2660         trie->trans = (reg_trie_trans *)
2661             PerlMemShared_calloc( ( TRIE_CHARCOUNT(trie) + 1 )
2662                                   * trie->uniquecharcount + 1,
2663                                   sizeof(reg_trie_trans) );
2664         trie->states = (reg_trie_state *)
2665             PerlMemShared_calloc( TRIE_CHARCOUNT(trie) + 2,
2666                                   sizeof(reg_trie_state) );
2667         next_alloc = trie->uniquecharcount + 1;
2668
2669
2670         for ( cur = first ; cur < last ; cur = regnext( cur ) ) {
2671
2672             regnode *noper   = NEXTOPER( cur );
2673             const U8 *uc     = (U8*)STRING( noper );
2674             const U8 *e      = uc + STR_LEN( noper );
2675
2676             U32 state        = 1;         /* required init */
2677
2678             U16 charid       = 0;         /* sanity init */
2679             U32 accept_state = 0;         /* sanity init */
2680
2681             U32 wordlen      = 0;         /* required init */
2682
2683             if (OP(noper) == NOTHING) {
2684                 regnode *noper_next= regnext(noper);
2685                 if (noper_next != tail && OP(noper_next) == flags) {
2686                     noper = noper_next;
2687                     uc= (U8*)STRING(noper);
2688                     e= uc + STR_LEN(noper);
2689                 }
2690             }
2691
2692             if ( OP(noper) != NOTHING ) {
2693                 for ( ; uc < e ; uc += len ) {
2694
2695                     TRIE_READ_CHAR;
2696
2697                     if ( uvc < 256 ) {
2698                         charid = trie->charmap[ uvc ];
2699                     } else {
2700                         SV* const * const svpp = hv_fetch( widecharmap,
2701                                                            (char*)&uvc,
2702                                                            sizeof( UV ),
2703                                                            0);
2704                         charid = svpp ? (U16)SvIV(*svpp) : 0;
2705                     }
2706                     if ( charid ) {
2707                         charid--;
2708                         if ( !trie->trans[ state + charid ].next ) {
2709                             trie->trans[ state + charid ].next = next_alloc;
2710                             trie->trans[ state ].check++;
2711                             prev_states[TRIE_NODENUM(next_alloc)]
2712                                     = TRIE_NODENUM(state);
2713                             next_alloc += trie->uniquecharcount;
2714                         }
2715                         state = trie->trans[ state + charid ].next;
2716                     } else {
2717                         Perl_croak( aTHX_ "panic! In trie construction, no char mapping for %"IVdf, uvc );
2718                     }
2719                     /* charid is now 0 if we dont know the char read, or
2720                      * nonzero if we do */
2721                 }
2722             }
2723             accept_state = TRIE_NODENUM( state );
2724             TRIE_HANDLE_WORD(accept_state);
2725
2726         } /* end second pass */
2727
2728         /* and now dump it out before we compress it */
2729         DEBUG_TRIE_COMPILE_MORE_r(dump_trie_interim_table(trie, widecharmap,
2730                                                           revcharmap,
2731                                                           next_alloc, depth+1));
2732
2733         {
2734         /*
2735            * Inplace compress the table.*
2736
2737            For sparse data sets the table constructed by the trie algorithm will
2738            be mostly 0/FAIL transitions or to put it another way mostly empty.
2739            (Note that leaf nodes will not contain any transitions.)
2740
2741            This algorithm compresses the tables by eliminating most such
2742            transitions, at the cost of a modest bit of extra work during lookup:
2743
2744            - Each states[] entry contains a .base field which indicates the
2745            index in the state[] array wheres its transition data is stored.
2746
2747            - If .base is 0 there are no valid transitions from that node.
2748
2749            - If .base is nonzero then charid is added to it to find an entry in
2750            the trans array.
2751
2752            -If trans[states[state].base+charid].check!=state then the
2753            transition is taken to be a 0/Fail transition. Thus if there are fail
2754            transitions at the front of the node then the .base offset will point
2755            somewhere inside the previous nodes data (or maybe even into a node
2756            even earlier), but the .check field determines if the transition is
2757            valid.
2758
2759            XXX - wrong maybe?
2760            The following process inplace converts the table to the compressed
2761            table: We first do not compress the root node 1,and mark all its
2762            .check pointers as 1 and set its .base pointer as 1 as well. This
2763            allows us to do a DFA construction from the compressed table later,
2764            and ensures that any .base pointers we calculate later are greater
2765            than 0.
2766
2767            - We set 'pos' to indicate the first entry of the second node.
2768
2769            - We then iterate over the columns of the node, finding the first and
2770            last used entry at l and m. We then copy l..m into pos..(pos+m-l),
2771            and set the .check pointers accordingly, and advance pos
2772            appropriately and repreat for the next node. Note that when we copy
2773            the next pointers we have to convert them from the original
2774            NODEIDX form to NODENUM form as the former is not valid post
2775            compression.
2776
2777            - If a node has no transitions used we mark its base as 0 and do not
2778            advance the pos pointer.
2779
2780            - If a node only has one transition we use a second pointer into the
2781            structure to fill in allocated fail transitions from other states.
2782            This pointer is independent of the main pointer and scans forward
2783            looking for null transitions that are allocated to a state. When it
2784            finds one it writes the single transition into the "hole".  If the
2785            pointer doesnt find one the single transition is appended as normal.
2786
2787            - Once compressed we can Renew/realloc the structures to release the
2788            excess space.
2789
2790            See "Table-Compression Methods" in sec 3.9 of the Red Dragon,
2791            specifically Fig 3.47 and the associated pseudocode.
2792
2793            demq
2794         */
2795         const U32 laststate = TRIE_NODENUM( next_alloc );
2796         U32 state, charid;
2797         U32 pos = 0, zp=0;
2798         trie->statecount = laststate;
2799
2800         for ( state = 1 ; state < laststate ; state++ ) {
2801             U8 flag = 0;
2802             const U32 stateidx = TRIE_NODEIDX( state );
2803             const U32 o_used = trie->trans[ stateidx ].check;
2804             U32 used = trie->trans[ stateidx ].check;
2805             trie->trans[ stateidx ].check = 0;
2806
2807             for ( charid = 0;
2808                   used && charid < trie->uniquecharcount;
2809                   charid++ )
2810             {
2811                 if ( flag || trie->trans[ stateidx + charid ].next ) {
2812                     if ( trie->trans[ stateidx + charid ].next ) {
2813                         if (o_used == 1) {
2814                             for ( ; zp < pos ; zp++ ) {
2815                                 if ( ! trie->trans[ zp ].next ) {
2816                                     break;
2817                                 }
2818                             }
2819                             trie->states[ state ].trans.base
2820                                                     = zp
2821                                                       + trie->uniquecharcount
2822                                                       - charid ;
2823                             trie->trans[ zp ].next
2824                                 = SAFE_TRIE_NODENUM( trie->trans[ stateidx
2825                                                              + charid ].next );
2826                             trie->trans[ zp ].check = state;
2827                             if ( ++zp > pos ) pos = zp;
2828                             break;
2829                         }
2830                         used--;
2831                     }
2832                     if ( !flag ) {
2833                         flag = 1;
2834                         trie->states[ state ].trans.base
2835                                        = pos + trie->uniquecharcount - charid ;
2836                     }
2837                     trie->trans[ pos ].next
2838                         = SAFE_TRIE_NODENUM(
2839                                        trie->trans[ stateidx + charid ].next );
2840                     trie->trans[ pos ].check = state;
2841                     pos++;
2842                 }
2843             }
2844         }
2845         trie->lasttrans = pos + 1;
2846         trie->states = (reg_trie_state *)
2847             PerlMemShared_realloc( trie->states, laststate
2848                                    * sizeof(reg_trie_state) );
2849         DEBUG_TRIE_COMPILE_MORE_r(
2850             PerlIO_printf( Perl_debug_log,
2851                 "%*sAlloc: %d Orig: %"IVdf" elements, Final:%"IVdf". Savings of %%%5.2f\n",
2852                 (int)depth * 2 + 2,"",
2853                 (int)( ( TRIE_CHARCOUNT(trie) + 1 ) * trie->uniquecharcount
2854                        + 1 ),
2855                 (IV)next_alloc,
2856                 (IV)pos,
2857                 ( ( next_alloc - pos ) * 100 ) / (double)next_alloc );
2858             );
2859
2860         } /* end table compress */
2861     }
2862     DEBUG_TRIE_COMPILE_MORE_r(
2863             PerlIO_printf(Perl_debug_log,
2864                 "%*sStatecount:%"UVxf" Lasttrans:%"UVxf"\n",
2865                 (int)depth * 2 + 2, "",
2866                 (UV)trie->statecount,
2867                 (UV)trie->lasttrans)
2868     );
2869     /* resize the trans array to remove unused space */
2870     trie->trans = (reg_trie_trans *)
2871         PerlMemShared_realloc( trie->trans, trie->lasttrans
2872                                * sizeof(reg_trie_trans) );
2873
2874     {   /* Modify the program and insert the new TRIE node */
2875         U8 nodetype =(U8)(flags & 0xFF);
2876         char *str=NULL;
2877
2878 #ifdef DEBUGGING
2879         regnode *optimize = NULL;
2880 #ifdef RE_TRACK_PATTERN_OFFSETS
2881
2882         U32 mjd_offset = 0;
2883         U32 mjd_nodelen = 0;
2884 #endif /* RE_TRACK_PATTERN_OFFSETS */
2885 #endif /* DEBUGGING */
2886         /*
2887            This means we convert either the first branch or the first Exact,
2888            depending on whether the thing following (in 'last') is a branch
2889            or not and whther first is the startbranch (ie is it a sub part of
2890            the alternation or is it the whole thing.)
2891            Assuming its a sub part we convert the EXACT otherwise we convert
2892            the whole branch sequence, including the first.
2893          */
2894         /* Find the node we are going to overwrite */
2895         if ( first != startbranch || OP( last ) == BRANCH ) {
2896             /* branch sub-chain */
2897             NEXT_OFF( first ) = (U16)(last - first);
2898 #ifdef RE_TRACK_PATTERN_OFFSETS
2899             DEBUG_r({
2900                 mjd_offset= Node_Offset((convert));
2901                 mjd_nodelen= Node_Length((convert));
2902             });
2903 #endif
2904             /* whole branch chain */
2905         }
2906 #ifdef RE_TRACK_PATTERN_OFFSETS
2907         else {
2908             DEBUG_r({
2909                 const  regnode *nop = NEXTOPER( convert );
2910                 mjd_offset= Node_Offset((nop));
2911                 mjd_nodelen= Node_Length((nop));
2912             });
2913         }
2914         DEBUG_OPTIMISE_r(
2915             PerlIO_printf(Perl_debug_log,
2916                 "%*sMJD offset:%"UVuf" MJD length:%"UVuf"\n",
2917                 (int)depth * 2 + 2, "",
2918                 (UV)mjd_offset, (UV)mjd_nodelen)
2919         );
2920 #endif
2921         /* But first we check to see if there is a common prefix we can
2922            split out as an EXACT and put in front of the TRIE node.  */
2923         trie->startstate= 1;
2924         if ( trie->bitmap && !widecharmap && !trie->jump  ) {
2925             U32 state;
2926             for ( state = 1 ; state < trie->statecount-1 ; state++ ) {
2927                 U32 ofs = 0;
2928                 I32 idx = -1;
2929                 U32 count = 0;
2930                 const U32 base = trie->states[ state ].trans.base;
2931
2932                 if ( trie->states[state].wordnum )
2933                         count = 1;
2934
2935                 for ( ofs = 0 ; ofs < trie->uniquecharcount ; ofs++ ) {
2936                     if ( ( base + ofs >= trie->uniquecharcount ) &&
2937                          ( base + ofs - trie->uniquecharcount < trie->lasttrans ) &&
2938                          trie->trans[ base + ofs - trie->uniquecharcount ].check == state )
2939                     {
2940                         if ( ++count > 1 ) {
2941                             SV **tmp = av_fetch( revcharmap, ofs, 0);
2942                             const U8 *ch = (U8*)SvPV_nolen_const( *tmp );
2943                             if ( state == 1 ) break;
2944                             if ( count == 2 ) {
2945                                 Zero(trie->bitmap, ANYOF_BITMAP_SIZE, char);
2946                                 DEBUG_OPTIMISE_r(
2947                                     PerlIO_printf(Perl_debug_log,
2948                                         "%*sNew Start State=%"UVuf" Class: [",
2949                                         (int)depth * 2 + 2, "",
2950                                         (UV)state));
2951                                 if (idx >= 0) {
2952                                     SV ** const tmp = av_fetch( revcharmap, idx, 0);
2953                                     const U8 * const ch = (U8*)SvPV_nolen_const( *tmp );
2954
2955                                     TRIE_BITMAP_SET(trie,*ch);
2956                                     if ( folder )
2957                                         TRIE_BITMAP_SET(trie, folder[ *ch ]);
2958                                     DEBUG_OPTIMISE_r(
2959                                         PerlIO_printf(Perl_debug_log, "%s", (char*)ch)
2960                                     );
2961                                 }
2962                             }
2963                             TRIE_BITMAP_SET(trie,*ch);
2964                             if ( folder )
2965                                 TRIE_BITMAP_SET(trie,folder[ *ch ]);
2966                             DEBUG_OPTIMISE_r(PerlIO_printf( Perl_debug_log,"%s", ch));
2967                         }
2968                         idx = ofs;
2969                     }
2970                 }
2971                 if ( count == 1 ) {
2972                     SV **tmp = av_fetch( revcharmap, idx, 0);
2973                     STRLEN len;
2974                     char *ch = SvPV( *tmp, len );
2975                     DEBUG_OPTIMISE_r({
2976                         SV *sv=sv_newmortal();
2977                         PerlIO_printf( Perl_debug_log,
2978                             "%*sPrefix State: %"UVuf" Idx:%"UVuf" Char='%s'\n",
2979                             (int)depth * 2 + 2, "",
2980                             (UV)state, (UV)idx,
2981                             pv_pretty(sv, SvPV_nolen_const(*tmp), SvCUR(*tmp), 6,
2982                                 PL_colors[0], PL_colors[1],
2983                                 (SvUTF8(*tmp) ? PERL_PV_ESCAPE_UNI : 0) |
2984                                 PERL_PV_ESCAPE_FIRSTCHAR
2985                             )
2986                         );
2987                     });
2988                     if ( state==1 ) {
2989                         OP( convert ) = nodetype;
2990                         str=STRING(convert);
2991                         STR_LEN(convert)=0;
2992                     }
2993                     STR_LEN(convert) += len;
2994                     while (len--)
2995                         *str++ = *ch++;
2996                 } else {
2997 #ifdef DEBUGGING
2998                     if (state>1)
2999                         DEBUG_OPTIMISE_r(PerlIO_printf( Perl_debug_log,"]\n"));
3000 #endif
3001                     break;
3002                 }
3003             }
3004             trie->prefixlen = (state-1);
3005             if (str) {
3006                 regnode *n = convert+NODE_SZ_STR(convert);
3007                 NEXT_OFF(convert) = NODE_SZ_STR(convert);
3008                 trie->startstate = state;
3009                 trie->minlen -= (state - 1);
3010                 trie->maxlen -= (state - 1);
3011 #ifdef DEBUGGING
3012                /* At least the UNICOS C compiler choked on this
3013                 * being argument to DEBUG_r(), so let's just have
3014                 * it right here. */
3015                if (
3016 #ifdef PERL_EXT_RE_BUILD
3017                    1
3018 #else
3019                    DEBUG_r_TEST
3020 #endif
3021                    ) {
3022                    regnode *fix = convert;
3023                    U32 word = trie->wordcount;
3024                    mjd_nodelen++;
3025                    Set_Node_Offset_Length(convert, mjd_offset, state - 1);
3026                    while( ++fix < n ) {
3027                        Set_Node_Offset_Length(fix, 0, 0);
3028                    }
3029                    while (word--) {
3030                        SV ** const tmp = av_fetch( trie_words, word, 0 );
3031                        if (tmp) {
3032                            if ( STR_LEN(convert) <= SvCUR(*tmp) )
3033                                sv_chop(*tmp, SvPV_nolen(*tmp) + STR_LEN(convert));
3034                            else
3035                                sv_chop(*tmp, SvPV_nolen(*tmp) + SvCUR(*tmp));
3036                        }
3037                    }
3038                }
3039 #endif
3040                 if (trie->maxlen) {
3041                     convert = n;
3042                 } else {
3043                     NEXT_OFF(convert) = (U16)(tail - convert);
3044                     DEBUG_r(optimize= n);
3045                 }
3046             }
3047         }
3048         if (!jumper)
3049             jumper = last;
3050         if ( trie->maxlen ) {
3051             NEXT_OFF( convert ) = (U16)(tail - convert);
3052             ARG_SET( convert, data_slot );
3053             /* Store the offset to the first unabsorbed branch in
3054                jump[0], which is otherwise unused by the jump logic.
3055                We use this when dumping a trie and during optimisation. */
3056             if (trie->jump)
3057                 trie->jump[0] = (U16)(nextbranch - convert);
3058
3059             /* If the start state is not accepting (meaning there is no empty string/NOTHING)
3060              *   and there is a bitmap
3061              *   and the first "jump target" node we found leaves enough room
3062              * then convert the TRIE node into a TRIEC node, with the bitmap
3063              * embedded inline in the opcode - this is hypothetically faster.
3064              */
3065             if ( !trie->states[trie->startstate].wordnum
3066                  && trie->bitmap
3067                  && ( (char *)jumper - (char *)convert) >= (int)sizeof(struct regnode_charclass) )
3068             {
3069                 OP( convert ) = TRIEC;
3070                 Copy(trie->bitmap, ((struct regnode_charclass *)convert)->bitmap, ANYOF_BITMAP_SIZE, char);
3071                 PerlMemShared_free(trie->bitmap);
3072                 trie->bitmap= NULL;
3073             } else
3074                 OP( convert ) = TRIE;
3075
3076             /* store the type in the flags */
3077             convert->flags = nodetype;
3078             DEBUG_r({
3079             optimize = convert
3080                       + NODE_STEP_REGNODE
3081                       + regarglen[ OP( convert ) ];
3082             });
3083             /* XXX We really should free up the resource in trie now,
3084                    as we won't use them - (which resources?) dmq */
3085         }
3086         /* needed for dumping*/
3087         DEBUG_r(if (optimize) {
3088             regnode *opt = convert;
3089
3090             while ( ++opt < optimize) {
3091                 Set_Node_Offset_Length(opt,0,0);
3092             }
3093             /*
3094                 Try to clean up some of the debris left after the
3095                 optimisation.
3096              */
3097             while( optimize < jumper ) {
3098                 mjd_nodelen += Node_Length((optimize));
3099                 OP( optimize ) = OPTIMIZED;
3100                 Set_Node_Offset_Length(optimize,0,0);
3101                 optimize++;
3102             }
3103             Set_Node_Offset_Length(convert,mjd_offset,mjd_nodelen);
3104         });
3105     } /* end node insert */
3106
3107     /*  Finish populating the prev field of the wordinfo array.  Walk back
3108      *  from each accept state until we find another accept state, and if
3109      *  so, point the first word's .prev field at the second word. If the
3110      *  second already has a .prev field set, stop now. This will be the
3111      *  case either if we've already processed that word's accept state,
3112      *  or that state had multiple words, and the overspill words were
3113      *  already linked up earlier.
3114      */
3115     {
3116         U16 word;
3117         U32 state;
3118         U16 prev;
3119
3120         for (word=1; word <= trie->wordcount; word++) {
3121             prev = 0;
3122             if (trie->wordinfo[word].prev)
3123                 continue;
3124             state = trie->wordinfo[word].accept;
3125             while (state) {
3126                 state = prev_states[state];
3127                 if (!state)
3128                     break;
3129                 prev = trie->states[state].wordnum;
3130                 if (prev)
3131                     break;
3132             }
3133             trie->wordinfo[word].prev = prev;
3134         }
3135         Safefree(prev_states);
3136     }
3137
3138
3139     /* and now dump out the compressed format */
3140     DEBUG_TRIE_COMPILE_r(dump_trie(trie, widecharmap, revcharmap, depth+1));
3141
3142     RExC_rxi->data->data[ data_slot + 1 ] = (void*)widecharmap;
3143 #ifdef DEBUGGING
3144     RExC_rxi->data->data[ data_slot + TRIE_WORDS_OFFSET ] = (void*)trie_words;
3145     RExC_rxi->data->data[ data_slot + 3 ] = (void*)revcharmap;
3146 #else
3147     SvREFCNT_dec_NN(revcharmap);
3148 #endif
3149     return trie->jump
3150            ? MADE_JUMP_TRIE
3151            : trie->startstate>1
3152              ? MADE_EXACT_TRIE
3153              : MADE_TRIE;
3154 }
3155
3156 STATIC regnode *
3157 S_construct_ahocorasick_from_trie(pTHX_ RExC_state_t *pRExC_state, regnode *source, U32 depth)
3158 {
3159 /* The Trie is constructed and compressed now so we can build a fail array if
3160  * it's needed
3161
3162    This is basically the Aho-Corasick algorithm. Its from exercise 3.31 and
3163    3.32 in the
3164    "Red Dragon" -- Compilers, principles, techniques, and tools. Aho, Sethi,
3165    Ullman 1985/88
3166    ISBN 0-201-10088-6
3167
3168    We find the fail state for each state in the trie, this state is the longest
3169    proper suffix of the current state's 'word' that is also a proper prefix of
3170    another word in our trie. State 1 represents the word '' and is thus the
3171    default fail state. This allows the DFA not to have to restart after its
3172    tried and failed a word at a given point, it simply continues as though it
3173    had been matching the other word in the first place.
3174    Consider
3175       'abcdgu'=~/abcdefg|cdgu/
3176    When we get to 'd' we are still matching the first word, we would encounter
3177    'g' which would fail, which would bring us to the state representing 'd' in
3178    the second word where we would try 'g' and succeed, proceeding to match
3179    'cdgu'.
3180  */
3181  /* add a fail transition */
3182     const U32 trie_offset = ARG(source);
3183     reg_trie_data *trie=(reg_trie_data *)RExC_rxi->data->data[trie_offset];
3184     U32 *q;
3185     const U32 ucharcount = trie->uniquecharcount;
3186     const U32 numstates = trie->statecount;
3187     const U32 ubound = trie->lasttrans + ucharcount;
3188     U32 q_read = 0;
3189     U32 q_write = 0;
3190     U32 charid;
3191     U32 base = trie->states[ 1 ].trans.base;
3192     U32 *fail;
3193     reg_ac_data *aho;
3194     const U32 data_slot = add_data( pRExC_state, STR_WITH_LEN("T"));
3195     regnode *stclass;
3196     GET_RE_DEBUG_FLAGS_DECL;
3197
3198     PERL_ARGS_ASSERT_CONSTRUCT_AHOCORASICK_FROM_TRIE;
3199     PERL_UNUSED_CONTEXT;
3200 #ifndef DEBUGGING
3201     PERL_UNUSED_ARG(depth);
3202 #endif
3203
3204     if ( OP(source) == TRIE ) {
3205         struct regnode_1 *op = (struct regnode_1 *)
3206             PerlMemShared_calloc(1, sizeof(struct regnode_1));
3207         StructCopy(source,op,struct regnode_1);
3208         stclass = (regnode *)op;
3209     } else {
3210         struct regnode_charclass *op = (struct regnode_charclass *)
3211             PerlMemShared_calloc(1, sizeof(struct regnode_charclass));
3212         StructCopy(source,op,struct regnode_charclass);
3213         stclass = (regnode *)op;
3214     }
3215     OP(stclass)+=2; /* convert the TRIE type to its AHO-CORASICK equivalent */
3216
3217     ARG_SET( stclass, data_slot );
3218     aho = (reg_ac_data *) PerlMemShared_calloc( 1, sizeof(reg_ac_data) );
3219     RExC_rxi->data->data[ data_slot ] = (void*)aho;
3220     aho->trie=trie_offset;
3221     aho->states=(reg_trie_state *)PerlMemShared_malloc( numstates * sizeof(reg_trie_state) );
3222     Copy( trie->states, aho->states, numstates, reg_trie_state );
3223     Newxz( q, numstates, U32);
3224     aho->fail = (U32 *) PerlMemShared_calloc( numstates, sizeof(U32) );
3225     aho->refcount = 1;
3226     fail = aho->fail;
3227     /* initialize fail[0..1] to be 1 so that we always have
3228        a valid final fail state */
3229     fail[ 0 ] = fail[ 1 ] = 1;
3230
3231     for ( charid = 0; charid < ucharcount ; charid++ ) {
3232         const U32 newstate = TRIE_TRANS_STATE( 1, base, ucharcount, charid, 0 );
3233         if ( newstate ) {
3234             q[ q_write ] = newstate;
3235             /* set to point at the root */
3236             fail[ q[ q_write++ ] ]=1;
3237         }
3238     }
3239     while ( q_read < q_write) {
3240         const U32 cur = q[ q_read++ % numstates ];
3241         base = trie->states[ cur ].trans.base;
3242
3243         for ( charid = 0 ; charid < ucharcount ; charid++ ) {
3244             const U32 ch_state = TRIE_TRANS_STATE( cur, base, ucharcount, charid, 1 );
3245             if (ch_state) {
3246                 U32 fail_state = cur;
3247                 U32 fail_base;
3248                 do {
3249                     fail_state = fail[ fail_state ];
3250                     fail_base = aho->states[ fail_state ].trans.base;
3251                 } while ( !TRIE_TRANS_STATE( fail_state, fail_base, ucharcount, charid, 1 ) );
3252
3253                 fail_state = TRIE_TRANS_STATE( fail_state, fail_base, ucharcount, charid, 1 );
3254                 fail[ ch_state ] = fail_state;
3255                 if ( !aho->states[ ch_state ].wordnum && aho->states[ fail_state ].wordnum )
3256                 {
3257                         aho->states[ ch_state ].wordnum =  aho->states[ fail_state ].wordnum;
3258                 }
3259                 q[ q_write++ % numstates] = ch_state;
3260             }
3261         }
3262     }
3263     /* restore fail[0..1] to 0 so that we "fall out" of the AC loop
3264        when we fail in state 1, this allows us to use the
3265        charclass scan to find a valid start char. This is based on the principle
3266        that theres a good chance the string being searched contains lots of stuff
3267        that cant be a start char.
3268      */
3269     fail[ 0 ] = fail[ 1 ] = 0;
3270     DEBUG_TRIE_COMPILE_r({
3271         PerlIO_printf(Perl_debug_log,
3272                       "%*sStclass Failtable (%"UVuf" states): 0",
3273                       (int)(depth * 2), "", (UV)numstates
3274         );
3275         for( q_read=1; q_read<numstates; q_read++ ) {
3276             PerlIO_printf(Perl_debug_log, ", %"UVuf, (UV)fail[q_read]);
3277         }
3278         PerlIO_printf(Perl_debug_log, "\n");
3279     });
3280     Safefree(q);
3281     /*RExC_seen |= REG_TRIEDFA_SEEN;*/
3282     return stclass;
3283 }
3284
3285
3286 #define DEBUG_PEEP(str,scan,depth) \
3287     DEBUG_OPTIMISE_r({if (scan){ \
3288        regnode *Next = regnext(scan); \
3289        regprop(RExC_rx, RExC_mysv, scan, NULL, pRExC_state); \
3290        PerlIO_printf(Perl_debug_log, "%*s" str ">%3d: %s (%d)", \
3291            (int)depth*2, "", REG_NODE_NUM(scan), SvPV_nolen_const(RExC_mysv),\
3292            Next ? (REG_NODE_NUM(Next)) : 0 ); \
3293        DEBUG_SHOW_STUDY_FLAGS(flags," [ ","]");\
3294        PerlIO_printf(Perl_debug_log, "\n"); \
3295    }});
3296
3297 /* The below joins as many adjacent EXACTish nodes as possible into a single
3298  * one.  The regop may be changed if the node(s) contain certain sequences that
3299  * require special handling.  The joining is only done if:
3300  * 1) there is room in the current conglomerated node to entirely contain the
3301  *    next one.
3302  * 2) they are the exact same node type
3303  *
3304  * The adjacent nodes actually may be separated by NOTHING-kind nodes, and
3305  * these get optimized out
3306  *
3307  * If a node is to match under /i (folded), the number of characters it matches
3308  * can be different than its character length if it contains a multi-character
3309  * fold.  *min_subtract is set to the total delta number of characters of the
3310  * input nodes.
3311  *
3312  * And *unfolded_multi_char is set to indicate whether or not the node contains
3313  * an unfolded multi-char fold.  This happens when whether the fold is valid or
3314  * not won't be known until runtime; namely for EXACTF nodes that contain LATIN
3315  * SMALL LETTER SHARP S, as only if the target string being matched against
3316  * turns out to be UTF-8 is that fold valid; and also for EXACTFL nodes whose
3317  * folding rules depend on the locale in force at runtime.  (Multi-char folds
3318  * whose components are all above the Latin1 range are not run-time locale
3319  * dependent, and have already been folded by the time this function is
3320  * called.)
3321  *
3322  * This is as good a place as any to discuss the design of handling these
3323  * multi-character fold sequences.  It's been wrong in Perl for a very long
3324  * time.  There are three code points in Unicode whose multi-character folds
3325  * were long ago discovered to mess things up.  The previous designs for
3326  * dealing with these involved assigning a special node for them.  This
3327  * approach doesn't always work, as evidenced by this example:
3328  *      "\xDFs" =~ /s\xDF/ui    # Used to fail before these patches
3329  * Both sides fold to "sss", but if the pattern is parsed to create a node that
3330  * would match just the \xDF, it won't be able to handle the case where a
3331  * successful match would have to cross the node's boundary.  The new approach
3332  * that hopefully generally solves the problem generates an EXACTFU_SS node
3333  * that is "sss" in this case.
3334  *
3335  * It turns out that there are problems with all multi-character folds, and not
3336  * just these three.  Now the code is general, for all such cases.  The
3337  * approach taken is:
3338  * 1)   This routine examines each EXACTFish node that could contain multi-
3339  *      character folded sequences.  Since a single character can fold into
3340  *      such a sequence, the minimum match length for this node is less than
3341  *      the number of characters in the node.  This routine returns in
3342  *      *min_subtract how many characters to subtract from the the actual
3343  *      length of the string to get a real minimum match length; it is 0 if
3344  *      there are no multi-char foldeds.  This delta is used by the caller to
3345  *      adjust the min length of the match, and the delta between min and max,
3346  *      so that the optimizer doesn't reject these possibilities based on size
3347  *      constraints.
3348  * 2)   For the sequence involving the Sharp s (\xDF), the node type EXACTFU_SS
3349  *      is used for an EXACTFU node that contains at least one "ss" sequence in
3350  *      it.  For non-UTF-8 patterns and strings, this is the only case where
3351  *      there is a possible fold length change.  That means that a regular
3352  *      EXACTFU node without UTF-8 involvement doesn't have to concern itself
3353  *      with length changes, and so can be processed faster.  regexec.c takes
3354  *      advantage of this.  Generally, an EXACTFish node that is in UTF-8 is
3355  *      pre-folded by regcomp.c (except EXACTFL, some of whose folds aren't
3356  *      known until runtime).  This saves effort in regex matching.  However,
3357  *      the pre-folding isn't done for non-UTF8 patterns because the fold of
3358  *      the MICRO SIGN requires UTF-8, and we don't want to slow things down by
3359  *      forcing the pattern into UTF8 unless necessary.  Also what EXACTF (and,
3360  *      again, EXACTFL) nodes fold to isn't known until runtime.  The fold
3361  *      possibilities for the non-UTF8 patterns are quite simple, except for
3362  *      the sharp s.  All the ones that don't involve a UTF-8 target string are
3363  *      members of a fold-pair, and arrays are set up for all of them so that
3364  *      the other member of the pair can be found quickly.  Code elsewhere in
3365  *      this file makes sure that in EXACTFU nodes, the sharp s gets folded to
3366  *      'ss', even if the pattern isn't UTF-8.  This avoids the issues
3367  *      described in the next item.
3368  * 3)   A problem remains for unfolded multi-char folds. (These occur when the
3369  *      validity of the fold won't be known until runtime, and so must remain
3370  *      unfolded for now.  This happens for the sharp s in EXACTF and EXACTFA
3371  *      nodes when the pattern isn't in UTF-8.  (Note, BTW, that there cannot
3372  *      be an EXACTF node with a UTF-8 pattern.)  They also occur for various
3373  *      folds in EXACTFL nodes, regardless of the UTF-ness of the pattern.)
3374  *      The reason this is a problem is that the optimizer part of regexec.c
3375  *      (probably unwittingly, in Perl_regexec_flags()) makes an assumption
3376  *      that a character in the pattern corresponds to at most a single
3377  *      character in the target string.  (And I do mean character, and not byte
3378  *      here, unlike other parts of the documentation that have never been
3379  *      updated to account for multibyte Unicode.)  sharp s in EXACTF and
3380  *      EXACTFL nodes can match the two character string 'ss'; in EXACTFA nodes
3381  *      it can match "\x{17F}\x{17F}".  These, along with other ones in EXACTFL
3382  *      nodes, violate the assumption, and they are the only instances where it
3383  *      is violated.  I'm reluctant to try to change the assumption, as the
3384  *      code involved is impenetrable to me (khw), so instead the code here
3385  *      punts.  This routine examines EXACTFL nodes, and (when the pattern
3386  *      isn't UTF-8) EXACTF and EXACTFA for such unfolded folds, and returns a
3387  *      boolean indicating whether or not the node contains such a fold.  When
3388  *      it is true, the caller sets a flag that later causes the optimizer in
3389  *      this file to not set values for the floating and fixed string lengths,
3390  *      and thus avoids the optimizer code in regexec.c that makes the invalid
3391  *      assumption.  Thus, there is no optimization based on string lengths for
3392  *      EXACTFL nodes that contain these few folds, nor for non-UTF8-pattern
3393  *      EXACTF and EXACTFA nodes that contain the sharp s.  (The reason the
3394  *      assumption is wrong only in these cases is that all other non-UTF-8
3395  *      folds are 1-1; and, for UTF-8 patterns, we pre-fold all other folds to
3396  *      their expanded versions.  (Again, we can't prefold sharp s to 'ss' in
3397  *      EXACTF nodes because we don't know at compile time if it actually
3398  *      matches 'ss' or not.  For EXACTF nodes it will match iff the target
3399  *      string is in UTF-8.  This is in contrast to EXACTFU nodes, where it
3400  *      always matches; and EXACTFA where it never does.  In an EXACTFA node in
3401  *      a UTF-8 pattern, sharp s is folded to "\x{17F}\x{17F}, avoiding the
3402  *      problem; but in a non-UTF8 pattern, folding it to that above-Latin1
3403  *      string would require the pattern to be forced into UTF-8, the overhead
3404  *      of which we want to avoid.  Similarly the unfolded multi-char folds in
3405  *      EXACTFL nodes will match iff the locale at the time of match is a UTF-8
3406  *      locale.)
3407  *
3408  *      Similarly, the code that generates tries doesn't currently handle
3409  *      not-already-folded multi-char folds, and it looks like a pain to change
3410  *      that.  Therefore, trie generation of EXACTFA nodes with the sharp s
3411  *      doesn't work.  Instead, such an EXACTFA is turned into a new regnode,
3412  *      EXACTFA_NO_TRIE, which the trie code knows not to handle.  Most people
3413  *      using /iaa matching will be doing so almost entirely with ASCII
3414  *      strings, so this should rarely be encountered in practice */
3415
3416 #define JOIN_EXACT(scan,min_subtract,unfolded_multi_char, flags) \
3417     if (PL_regkind[OP(scan)] == EXACT) \
3418         join_exact(pRExC_state,(scan),(min_subtract),unfolded_multi_char, (flags),NULL,depth+1)
3419
3420 STATIC U32
3421 S_join_exact(pTHX_ RExC_state_t *pRExC_state, regnode *scan,
3422                    UV *min_subtract, bool *unfolded_multi_char,
3423                    U32 flags,regnode *val, U32 depth)
3424 {
3425     /* Merge several consecutive EXACTish nodes into one. */
3426     regnode *n = regnext(scan);
3427     U32 stringok = 1;
3428     regnode *next = scan + NODE_SZ_STR(scan);
3429     U32 merged = 0;
3430     U32 stopnow = 0;
3431 #ifdef DEBUGGING
3432     regnode *stop = scan;
3433     GET_RE_DEBUG_FLAGS_DECL;
3434 #else
3435     PERL_UNUSED_ARG(depth);
3436 #endif
3437
3438     PERL_ARGS_ASSERT_JOIN_EXACT;
3439 #ifndef EXPERIMENTAL_INPLACESCAN
3440     PERL_UNUSED_ARG(flags);
3441     PERL_UNUSED_ARG(val);
3442 #endif
3443     DEBUG_PEEP("join",scan,depth);
3444
3445     /* Look through the subsequent nodes in the chain.  Skip NOTHING, merge
3446      * EXACT ones that are mergeable to the current one. */
3447     while (n
3448            && (PL_regkind[OP(n)] == NOTHING
3449                || (stringok && OP(n) == OP(scan)))
3450            && NEXT_OFF(n)
3451            && NEXT_OFF(scan) + NEXT_OFF(n) < I16_MAX)
3452     {
3453
3454         if (OP(n) == TAIL || n > next)
3455             stringok = 0;
3456         if (PL_regkind[OP(n)] == NOTHING) {
3457             DEBUG_PEEP("skip:",n,depth);
3458             NEXT_OFF(scan) += NEXT_OFF(n);
3459             next = n + NODE_STEP_REGNODE;
3460 #ifdef DEBUGGING
3461             if (stringok)
3462                 stop = n;
3463 #endif
3464             n = regnext(n);
3465         }
3466         else if (stringok) {
3467             const unsigned int oldl = STR_LEN(scan);
3468             regnode * const nnext = regnext(n);
3469
3470             /* XXX I (khw) kind of doubt that this works on platforms (should
3471              * Perl ever run on one) where U8_MAX is above 255 because of lots
3472              * of other assumptions */
3473             /* Don't join if the sum can't fit into a single node */
3474             if (oldl + STR_LEN(n) > U8_MAX)
3475                 break;
3476
3477             DEBUG_PEEP("merg",n,depth);
3478             merged++;
3479
3480             NEXT_OFF(scan) += NEXT_OFF(n);
3481             STR_LEN(scan) += STR_LEN(n);
3482             next = n + NODE_SZ_STR(n);
3483             /* Now we can overwrite *n : */
3484             Move(STRING(n), STRING(scan) + oldl, STR_LEN(n), char);
3485 #ifdef DEBUGGING
3486             stop = next - 1;
3487 #endif
3488             n = nnext;
3489             if (stopnow) break;
3490         }
3491
3492 #ifdef EXPERIMENTAL_INPLACESCAN
3493         if (flags && !NEXT_OFF(n)) {
3494             DEBUG_PEEP("atch", val, depth);
3495             if (reg_off_by_arg[OP(n)]) {
3496                 ARG_SET(n, val - n);
3497             }
3498             else {
3499                 NEXT_OFF(n) = val - n;
3500             }
3501             stopnow = 1;
3502         }
3503 #endif
3504     }
3505
3506     *min_subtract = 0;
3507     *unfolded_multi_char = FALSE;
3508
3509     /* Here, all the adjacent mergeable EXACTish nodes have been merged.  We
3510      * can now analyze for sequences of problematic code points.  (Prior to
3511      * this final joining, sequences could have been split over boundaries, and
3512      * hence missed).  The sequences only happen in folding, hence for any
3513      * non-EXACT EXACTish node */
3514     if (OP(scan) != EXACT && OP(scan) != EXACTL) {
3515         U8* s0 = (U8*) STRING(scan);
3516         U8* s = s0;
3517         U8* s_end = s0 + STR_LEN(scan);
3518
3519         int total_count_delta = 0;  /* Total delta number of characters that
3520                                        multi-char folds expand to */
3521
3522         /* One pass is made over the node's string looking for all the
3523          * possibilities.  To avoid some tests in the loop, there are two main
3524          * cases, for UTF-8 patterns (which can't have EXACTF nodes) and
3525          * non-UTF-8 */
3526         if (UTF) {
3527             U8* folded = NULL;
3528
3529             if (OP(scan) == EXACTFL) {
3530                 U8 *d;
3531
3532                 /* An EXACTFL node would already have been changed to another
3533                  * node type unless there is at least one character in it that
3534                  * is problematic; likely a character whose fold definition
3535                  * won't be known until runtime, and so has yet to be folded.
3536                  * For all but the UTF-8 locale, folds are 1-1 in length, but
3537                  * to handle the UTF-8 case, we need to create a temporary
3538                  * folded copy using UTF-8 locale rules in order to analyze it.
3539                  * This is because our macros that look to see if a sequence is
3540                  * a multi-char fold assume everything is folded (otherwise the
3541                  * tests in those macros would be too complicated and slow).
3542                  * Note that here, the non-problematic folds will have already
3543                  * been done, so we can just copy such characters.  We actually
3544                  * don't completely fold the EXACTFL string.  We skip the
3545                  * unfolded multi-char folds, as that would just create work
3546                  * below to figure out the size they already are */
3547
3548                 Newx(folded, UTF8_MAX_FOLD_CHAR_EXPAND * STR_LEN(scan) + 1, U8);
3549                 d = folded;
3550                 while (s < s_end) {
3551                     STRLEN s_len = UTF8SKIP(s);
3552                     if (! is_PROBLEMATIC_LOCALE_FOLD_utf8(s)) {
3553                         Copy(s, d, s_len, U8);
3554                         d += s_len;
3555                     }
3556                     else if (is_FOLDS_TO_MULTI_utf8(s)) {
3557                         *unfolded_multi_char = TRUE;
3558                         Copy(s, d, s_len, U8);
3559                         d += s_len;
3560                     }
3561                     else if (isASCII(*s)) {
3562                         *(d++) = toFOLD(*s);
3563                     }
3564                     else {
3565                         STRLEN len;
3566                         _to_utf8_fold_flags(s, d, &len, FOLD_FLAGS_FULL);
3567                         d += len;
3568                     }
3569                     s += s_len;
3570                 }
3571
3572                 /* Point the remainder of the routine to look at our temporary
3573                  * folded copy */
3574                 s = folded;
3575                 s_end = d;
3576             } /* End of creating folded copy of EXACTFL string */
3577
3578             /* Examine the string for a multi-character fold sequence.  UTF-8
3579              * patterns have all characters pre-folded by the time this code is
3580              * executed */
3581             while (s < s_end - 1) /* Can stop 1 before the end, as minimum
3582                                      length sequence we are looking for is 2 */
3583             {
3584                 int count = 0;  /* How many characters in a multi-char fold */
3585                 int len = is_MULTI_CHAR_FOLD_utf8_safe(s, s_end);
3586                 if (! len) {    /* Not a multi-char fold: get next char */
3587                     s += UTF8SKIP(s);
3588                     continue;
3589                 }
3590
3591                 /* Nodes with 'ss' require special handling, except for
3592                  * EXACTFA-ish for which there is no multi-char fold to this */
3593                 if (len == 2 && *s == 's' && *(s+1) == 's'
3594                     && OP(scan) != EXACTFA
3595                     && OP(scan) != EXACTFA_NO_TRIE)
3596                 {
3597                     count = 2;
3598                     if (OP(scan) != EXACTFL) {
3599                         OP(scan) = EXACTFU_SS;
3600                     }
3601                     s += 2;
3602                 }
3603                 else { /* Here is a generic multi-char fold. */
3604                     U8* multi_end  = s + len;
3605
3606                     /* Count how many characters are in it.  In the case of
3607                      * /aa, no folds which contain ASCII code points are
3608                      * allowed, so check for those, and skip if found. */
3609                     if (OP(scan) != EXACTFA && OP(scan) != EXACTFA_NO_TRIE) {
3610                         count = utf8_length(s, multi_end);
3611                         s = multi_end;
3612                     }
3613                     else {
3614                         while (s < multi_end) {
3615                             if (isASCII(*s)) {
3616                                 s++;
3617                                 goto next_iteration;
3618                             }
3619                             else {
3620                                 s += UTF8SKIP(s);
3621                             }
3622                             count++;
3623                         }
3624                     }
3625                 }
3626
3627                 /* The delta is how long the sequence is minus 1 (1 is how long
3628                  * the character that folds to the sequence is) */
3629                 total_count_delta += count - 1;
3630               next_iteration: ;
3631             }
3632
3633             /* We created a temporary folded copy of the string in EXACTFL
3634              * nodes.  Therefore we need to be sure it doesn't go below zero,
3635              * as the real string could be shorter */
3636             if (OP(scan) == EXACTFL) {
3637                 int total_chars = utf8_length((U8*) STRING(scan),
3638                                            (U8*) STRING(scan) + STR_LEN(scan));
3639                 if (total_count_delta > total_chars) {
3640                     total_count_delta = total_chars;
3641                 }
3642             }
3643
3644             *min_subtract += total_count_delta;
3645             Safefree(folded);
3646         }
3647         else if (OP(scan) == EXACTFA) {
3648
3649             /* Non-UTF-8 pattern, EXACTFA node.  There can't be a multi-char
3650              * fold to the ASCII range (and there are no existing ones in the
3651              * upper latin1 range).  But, as outlined in the comments preceding
3652              * this function, we need to flag any occurrences of the sharp s.
3653              * This character forbids trie formation (because of added
3654              * complexity) */
3655             while (s < s_end) {
3656                 if (*s == LATIN_SMALL_LETTER_SHARP_S) {
3657                     OP(scan) = EXACTFA_NO_TRIE;
3658                     *unfolded_multi_char = TRUE;
3659                     break;
3660                 }
3661                 s++;
3662                 continue;
3663             }
3664         }
3665         else {
3666
3667             /* Non-UTF-8 pattern, not EXACTFA node.  Look for the multi-char
3668              * folds that are all Latin1.  As explained in the comments
3669              * preceding this function, we look also for the sharp s in EXACTF
3670              * and EXACTFL nodes; it can be in the final position.  Otherwise
3671              * we can stop looking 1 byte earlier because have to find at least
3672              * two characters for a multi-fold */
3673             const U8* upper = (OP(scan) == EXACTF || OP(scan) == EXACTFL)
3674                               ? s_end
3675                               : s_end -1;
3676
3677             while (s < upper) {
3678                 int len = is_MULTI_CHAR_FOLD_latin1_safe(s, s_end);
3679                 if (! len) {    /* Not a multi-char fold. */
3680                     if (*s == LATIN_SMALL_LETTER_SHARP_S
3681                         && (OP(scan) == EXACTF || OP(scan) == EXACTFL))
3682                     {
3683                         *unfolded_multi_char = TRUE;
3684                     }
3685                     s++;
3686                     continue;
3687                 }
3688
3689                 if (len == 2
3690                     && isALPHA_FOLD_EQ(*s, 's')
3691                     && isALPHA_FOLD_EQ(*(s+1), 's'))
3692                 {
3693
3694                     /* EXACTF nodes need to know that the minimum length
3695                      * changed so that a sharp s in the string can match this
3696                      * ss in the pattern, but they remain EXACTF nodes, as they
3697                      * won't match this unless the target string is is UTF-8,
3698                      * which we don't know until runtime.  EXACTFL nodes can't
3699                      * transform into EXACTFU nodes */
3700                     if (OP(scan) != EXACTF && OP(scan) != EXACTFL) {
3701                         OP(scan) = EXACTFU_SS;
3702                     }
3703                 }
3704
3705                 *min_subtract += len - 1;
3706                 s += len;
3707             }
3708         }
3709     }
3710
3711 #ifdef DEBUGGING
3712     /* Allow dumping but overwriting the collection of skipped
3713      * ops and/or strings with fake optimized ops */
3714     n = scan + NODE_SZ_STR(scan);
3715     while (n <= stop) {
3716         OP(n) = OPTIMIZED;
3717         FLAGS(n) = 0;
3718         NEXT_OFF(n) = 0;
3719         n++;
3720     }
3721 #endif
3722     DEBUG_OPTIMISE_r(if (merged){DEBUG_PEEP("finl",scan,depth)});
3723     return stopnow;
3724 }
3725
3726 /* REx optimizer.  Converts nodes into quicker variants "in place".
3727    Finds fixed substrings.  */
3728
3729 /* Stops at toplevel WHILEM as well as at "last". At end *scanp is set
3730    to the position after last scanned or to NULL. */
3731
3732 #define INIT_AND_WITHP \
3733     assert(!and_withp); \
3734     Newx(and_withp,1, regnode_ssc); \
3735     SAVEFREEPV(and_withp)
3736
3737
3738 static void
3739 S_unwind_scan_frames(pTHX_ const void *p)
3740 {
3741     scan_frame *f= (scan_frame *)p;
3742     do {
3743         scan_frame *n= f->next_frame;
3744         Safefree(f);
3745         f= n;
3746     } while (f);
3747 }
3748
3749
3750 STATIC SSize_t
3751 S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp,
3752                         SSize_t *minlenp, SSize_t *deltap,
3753                         regnode *last,
3754                         scan_data_t *data,
3755                         I32 stopparen,
3756                         U32 recursed_depth,
3757                         regnode_ssc *and_withp,
3758                         U32 flags, U32 depth)
3759                         /* scanp: Start here (read-write). */
3760                         /* deltap: Write maxlen-minlen here. */
3761                         /* last: Stop before this one. */
3762                         /* data: string data about the pattern */
3763                         /* stopparen: treat close N as END */
3764                         /* recursed: which subroutines have we recursed into */
3765                         /* and_withp: Valid if flags & SCF_DO_STCLASS_OR */
3766 {
3767     /* There must be at least this number of characters to match */
3768     SSize_t min = 0;
3769     I32 pars = 0, code;
3770     regnode *scan = *scanp, *next;
3771     SSize_t delta = 0;
3772     int is_inf = (flags & SCF_DO_SUBSTR) && (data->flags & SF_IS_INF);
3773     int is_inf_internal = 0;            /* The studied chunk is infinite */
3774     I32 is_par = OP(scan) == OPEN ? ARG(scan) : 0;
3775     scan_data_t data_fake;
3776     SV *re_trie_maxbuff = NULL;
3777     regnode *first_non_open = scan;
3778     SSize_t stopmin = SSize_t_MAX;
3779     scan_frame *frame = NULL;
3780     GET_RE_DEBUG_FLAGS_DECL;
3781
3782     PERL_ARGS_ASSERT_STUDY_CHUNK;
3783
3784
3785     if ( depth == 0 ) {
3786         while (first_non_open && OP(first_non_open) == OPEN)
3787             first_non_open=regnext(first_non_open);
3788     }
3789
3790
3791   fake_study_recurse:
3792     DEBUG_r(
3793         RExC_study_chunk_recursed_count++;
3794     );
3795     DEBUG_OPTIMISE_MORE_r(
3796     {
3797         PerlIO_printf(Perl_debug_log,
3798             "%*sstudy_chunk stopparen=%ld recursed_count=%lu depth=%lu recursed_depth=%lu scan=%p last=%p",
3799             (int)(depth*2), "", (long)stopparen,
3800             (unsigned long)RExC_study_chunk_recursed_count,
3801             (unsigned long)depth, (unsigned long)recursed_depth,
3802             scan,
3803             last);
3804         if (recursed_depth) {
3805             U32 i;
3806             U32 j;
3807             for ( j = 0 ; j < recursed_depth ; j++ ) {
3808                 for ( i = 0 ; i < (U32)RExC_npar ; i++ ) {
3809                     if (
3810                         PAREN_TEST(RExC_study_chunk_recursed +
3811                                    ( j * RExC_study_chunk_recursed_bytes), i )
3812                         && (
3813                             !j ||
3814                             !PAREN_TEST(RExC_study_chunk_recursed +
3815                                    (( j - 1 ) * RExC_study_chunk_recursed_bytes), i)
3816                         )
3817                     ) {
3818                         PerlIO_printf(Perl_debug_log," %d",(int)i);
3819                         break;
3820                     }
3821                 }
3822                 if ( j + 1 < recursed_depth ) {
3823                     PerlIO_printf(Perl_debug_log, ",");
3824                 }
3825             }
3826         }
3827         PerlIO_printf(Perl_debug_log,"\n");
3828     }
3829     );
3830     while ( scan && OP(scan) != END && scan < last ){
3831         UV min_subtract = 0;    /* How mmany chars to subtract from the minimum
3832                                    node length to get a real minimum (because
3833                                    the folded version may be shorter) */
3834         bool unfolded_multi_char = FALSE;
3835         /* Peephole optimizer: */
3836         DEBUG_STUDYDATA("Peep:", data, depth);
3837         DEBUG_PEEP("Peep", scan, depth);
3838
3839
3840         /* The reason we do this here we need to deal with things like /(?:f)(?:o)(?:o)/
3841          * which cant be dealt with by the normal EXACT parsing code, as each (?:..) is handled
3842          * by a different invocation of reg() -- Yves
3843          */
3844         JOIN_EXACT(scan,&min_subtract, &unfolded_multi_char, 0);
3845
3846         /* Follow the next-chain of the current node and optimize
3847            away all the NOTHINGs from it.  */
3848         if (OP(scan) != CURLYX) {
3849             const int max = (reg_off_by_arg[OP(scan)]
3850                        ? I32_MAX
3851                        /* I32 may be smaller than U16 on CRAYs! */
3852                        : (I32_MAX < U16_MAX ? I32_MAX : U16_MAX));
3853             int off = (reg_off_by_arg[OP(scan)] ? ARG(scan) : NEXT_OFF(scan));
3854             int noff;
3855             regnode *n = scan;
3856
3857             /* Skip NOTHING and LONGJMP. */
3858             while ((n = regnext(n))
3859                    && ((PL_regkind[OP(n)] == NOTHING && (noff = NEXT_OFF(n)))
3860                        || ((OP(n) == LONGJMP) && (noff = ARG(n))))
3861                    && off + noff < max)
3862                 off += noff;
3863             if (reg_off_by_arg[OP(scan)])
3864                 ARG(scan) = off;
3865             else
3866                 NEXT_OFF(scan) = off;
3867         }
3868
3869         /* The principal pseudo-switch.  Cannot be a switch, since we
3870            look into several different things.  */
3871         if ( OP(scan) == DEFINEP ) {
3872             SSize_t minlen = 0;
3873             SSize_t deltanext = 0;
3874             SSize_t fake_last_close = 0;
3875             I32 f = SCF_IN_DEFINE;
3876
3877             StructCopy(&zero_scan_data, &data_fake, scan_data_t);
3878             scan = regnext(scan);
3879             assert( OP(scan) == IFTHEN );
3880             DEBUG_PEEP("expect IFTHEN", scan, depth);
3881
3882             data_fake.last_closep= &fake_last_close;
3883             minlen = *minlenp;
3884             next = regnext(scan);
3885             scan = NEXTOPER(NEXTOPER(scan));
3886             DEBUG_PEEP("scan", scan, depth);
3887             DEBUG_PEEP("next", next, depth);
3888
3889             /* we suppose the run is continuous, last=next...
3890              * NOTE we dont use the return here! */
3891             (void)study_chunk(pRExC_state, &scan, &minlen,
3892                               &deltanext, next, &data_fake, stopparen,
3893                               recursed_depth, NULL, f, depth+1);
3894
3895             scan = next;
3896         } else
3897         if (
3898             OP(scan) == BRANCH  ||
3899             OP(scan) == BRANCHJ ||
3900             OP(scan) == IFTHEN
3901         ) {
3902             next = regnext(scan);
3903             code = OP(scan);
3904
3905             /* The op(next)==code check below is to see if we
3906              * have "BRANCH-BRANCH", "BRANCHJ-BRANCHJ", "IFTHEN-IFTHEN"
3907              * IFTHEN is special as it might not appear in pairs.
3908              * Not sure whether BRANCH-BRANCHJ is possible, regardless
3909              * we dont handle it cleanly. */
3910             if (OP(next) == code || code == IFTHEN) {
3911                 /* NOTE - There is similar code to this block below for
3912                  * handling TRIE nodes on a re-study.  If you change stuff here
3913                  * check there too. */
3914                 SSize_t max1 = 0, min1 = SSize_t_MAX, num = 0;
3915                 regnode_ssc accum;
3916                 regnode * const startbranch=scan;
3917
3918                 if (flags & SCF_DO_SUBSTR) {
3919                     /* Cannot merge strings after this. */
3920                     scan_commit(pRExC_state, data, minlenp, is_inf);
3921                 }
3922
3923                 if (flags & SCF_DO_STCLASS)
3924                     ssc_init_zero(pRExC_state, &accum);
3925
3926                 while (OP(scan) == code) {
3927                     SSize_t deltanext, minnext, fake;
3928                     I32 f = 0;
3929                     regnode_ssc this_class;
3930
3931                     DEBUG_PEEP("Branch", scan, depth);
3932
3933                     num++;
3934                     StructCopy(&zero_scan_data, &data_fake, scan_data_t);
3935                     if (data) {
3936                         data_fake.whilem_c = data->whilem_c;
3937                         data_fake.last_closep = data->last_closep;
3938                     }
3939                     else
3940                         data_fake.last_closep = &fake;
3941
3942                     data_fake.pos_delta = delta;
3943                     next = regnext(scan);
3944
3945                     scan = NEXTOPER(scan); /* everything */
3946                     if (code != BRANCH)    /* everything but BRANCH */
3947                         scan = NEXTOPER(scan);
3948
3949                     if (flags & SCF_DO_STCLASS) {
3950                         ssc_init(pRExC_state, &this_class);
3951                         data_fake.start_class = &this_class;
3952                         f = SCF_DO_STCLASS_AND;
3953                     }
3954                     if (flags & SCF_WHILEM_VISITED_POS)
3955                         f |= SCF_WHILEM_VISITED_POS;
3956
3957                     /* we suppose the run is continuous, last=next...*/
3958                     minnext = study_chunk(pRExC_state, &scan, minlenp,
3959                                       &deltanext, next, &data_fake, stopparen,
3960                                       recursed_depth, NULL, f,depth+1);
3961
3962                     if (min1 > minnext)
3963                         min1 = minnext;
3964                     if (deltanext == SSize_t_MAX) {
3965                         is_inf = is_inf_internal = 1;
3966                         max1 = SSize_t_MAX;
3967                     } else if (max1 < minnext + deltanext)
3968                         max1 = minnext + deltanext;
3969                     scan = next;
3970                     if (data_fake.flags & (SF_HAS_PAR|SF_IN_PAR))
3971                         pars++;
3972                     if (data_fake.flags & SCF_SEEN_ACCEPT) {
3973                         if ( stopmin > minnext)
3974                             stopmin = min + min1;
3975                         flags &= ~SCF_DO_SUBSTR;
3976                         if (data)
3977                             data->flags |= SCF_SEEN_ACCEPT;
3978                     }
3979                     if (data) {
3980                         if (data_fake.flags & SF_HAS_EVAL)
3981                             data->flags |= SF_HAS_EVAL;
3982                         data->whilem_c = data_fake.whilem_c;
3983                     }
3984                     if (flags & SCF_DO_STCLASS)
3985                         ssc_or(pRExC_state, &accum, (regnode_charclass*)&this_class);
3986                 }
3987                 if (code == IFTHEN && num < 2) /* Empty ELSE branch */
3988                     min1 = 0;
3989                 if (flags & SCF_DO_SUBSTR) {
3990                     data->pos_min += min1;
3991                     if (data->pos_delta >= SSize_t_MAX - (max1 - min1))
3992                         data->pos_delta = SSize_t_MAX;
3993                     else
3994                         data->pos_delta += max1 - min1;
3995                     if (max1 != min1 || is_inf)
3996                         data->longest = &(data->longest_float);
3997                 }
3998                 min += min1;
3999                 if (delta == SSize_t_MAX
4000                  || SSize_t_MAX - delta - (max1 - min1) < 0)
4001                     delta = SSize_t_MAX;
4002                 else
4003                     delta += max1 - min1;
4004                 if (flags & SCF_DO_STCLASS_OR) {
4005                     ssc_or(pRExC_state, data->start_class, (regnode_charclass*) &accum);
4006                     if (min1) {
4007                         ssc_and(pRExC_state, data->start_class, (regnode_charclass *) and_withp);
4008                         flags &= ~SCF_DO_STCLASS;
4009                     }
4010                 }
4011                 else if (flags & SCF_DO_STCLASS_AND) {
4012                     if (min1) {
4013                         ssc_and(pRExC_state, data->start_class, (regnode_charclass *) &accum);
4014                         flags &= ~SCF_DO_STCLASS;
4015                     }
4016                     else {
4017                         /* Switch to OR mode: cache the old value of
4018                          * data->start_class */
4019                         INIT_AND_WITHP;
4020                         StructCopy(data->start_class, and_withp, regnode_ssc);
4021                         flags &= ~SCF_DO_STCLASS_AND;
4022                         StructCopy(&accum, data->start_class, regnode_ssc);
4023                         flags |= SCF_DO_STCLASS_OR;
4024                     }
4025                 }
4026
4027                 if (PERL_ENABLE_TRIE_OPTIMISATION &&
4028                         OP( startbranch ) == BRANCH )
4029                 {
4030                 /* demq.
4031
4032                    Assuming this was/is a branch we are dealing with: 'scan'
4033                    now points at the item that follows the branch sequence,
4034                    whatever it is. We now start at the beginning of the
4035                    sequence and look for subsequences of
4036
4037                    BRANCH->EXACT=>x1
4038                    BRANCH->EXACT=>x2
4039                    tail
4040
4041                    which would be constructed from a pattern like
4042                    /A|LIST|OF|WORDS/
4043
4044                    If we can find such a subsequence we need to turn the first
4045                    element into a trie and then add the subsequent branch exact
4046                    strings to the trie.
4047
4048                    We have two cases
4049
4050                      1. patterns where the whole set of branches can be
4051                         converted.
4052
4053                      2. patterns where only a subset can be converted.
4054
4055                    In case 1 we can replace the whole set with a single regop
4056                    for the trie. In case 2 we need to keep the start and end
4057                    branches so
4058
4059                      'BRANCH EXACT; BRANCH EXACT; BRANCH X'
4060                      becomes BRANCH TRIE; BRANCH X;
4061
4062                   There is an additional case, that being where there is a
4063                   common prefix, which gets split out into an EXACT like node
4064                   preceding the TRIE node.
4065
4066                   If x(1..n)==tail then we can do a simple trie, if not we make
4067                   a "jump" trie, such that when we match the appropriate word
4068                   we "jump" to the appropriate tail node. Essentially we turn
4069                   a nested if into a case structure of sorts.
4070
4071                 */
4072
4073                     int made=0;
4074                     if (!re_trie_maxbuff) {
4075                         re_trie_maxbuff = get_sv(RE_TRIE_MAXBUF_NAME, 1);
4076                         if (!SvIOK(re_trie_maxbuff))
4077                             sv_setiv(re_trie_maxbuff, RE_TRIE_MAXBUF_INIT);
4078                     }
4079                     if ( SvIV(re_trie_maxbuff)>=0  ) {
4080                         regnode *cur;
4081                         regnode *first = (regnode *)NULL;
4082                         regnode *last = (regnode *)NULL;
4083                         regnode *tail = scan;
4084                         U8 trietype = 0;
4085                         U32 count=0;
4086
4087                         /* var tail is used because there may be a TAIL
4088                            regop in the way. Ie, the exacts will point to the
4089                            thing following the TAIL, but the last branch will
4090                            point at the TAIL. So we advance tail. If we
4091                            have nested (?:) we may have to move through several
4092                            tails.
4093                          */
4094
4095                         while ( OP( tail ) == TAIL ) {
4096                             /* this is the TAIL generated by (?:) */
4097                             tail = regnext( tail );
4098                         }
4099
4100
4101                         DEBUG_TRIE_COMPILE_r({
4102                             regprop(RExC_rx, RExC_mysv, tail, NULL, pRExC_state);
4103                             PerlIO_printf( Perl_debug_log, "%*s%s%s\n",
4104                               (int)depth * 2 + 2, "",
4105                               "Looking for TRIE'able sequences. Tail node is: ",
4106                               SvPV_nolen_const( RExC_mysv )
4107                             );
4108                         });
4109
4110                         /*
4111
4112                             Step through the branches
4113                                 cur represents each branch,
4114                                 noper is the first thing to be matched as part
4115                                       of that branch
4116                                 noper_next is the regnext() of that node.
4117
4118                             We normally handle a case like this
4119                             /FOO[xyz]|BAR[pqr]/ via a "jump trie" but we also
4120                             support building with NOJUMPTRIE, which restricts
4121                             the trie logic to structures like /FOO|BAR/.
4122
4123                             If noper is a trieable nodetype then the branch is
4124                             a possible optimization target. If we are building
4125                             under NOJUMPTRIE then we require that noper_next is
4126                             the same as scan (our current position in the regex
4127                             program).
4128
4129                             Once we have two or more consecutive such branches
4130                             we can create a trie of the EXACT's contents and
4131                             stitch it in place into the program.
4132
4133                             If the sequence represents all of the branches in
4134                             the alternation we replace the entire thing with a
4135                             single TRIE node.
4136
4137                             Otherwise when it is a subsequence we need to
4138                             stitch it in place and replace only the relevant
4139                             branches. This means the first branch has to remain
4140                             as it is used by the alternation logic, and its
4141                             next pointer, and needs to be repointed at the item
4142                             on the branch chain following the last branch we
4143                             have optimized away.
4144
4145                             This could be either a BRANCH, in which case the
4146                             subsequence is internal, or it could be the item
4147                             following the branch sequence in which case the
4148                             subsequence is at the end (which does not
4149                             necessarily mean the first node is the start of the
4150                             alternation).
4151
4152                             TRIE_TYPE(X) is a define which maps the optype to a
4153                             trietype.
4154
4155                                 optype          |  trietype
4156                                 ----------------+-----------
4157                                 NOTHING         | NOTHING
4158                                 EXACT           | EXACT
4159                                 EXACTFU         | EXACTFU
4160                                 EXACTFU_SS      | EXACTFU
4161                                 EXACTFA         | EXACTFA
4162                                 EXACTL          | EXACTL
4163                                 EXACTFLU8       | EXACTFLU8
4164
4165
4166                         */
4167 #define TRIE_TYPE(X) ( ( NOTHING == (X) )                                   \
4168                        ? NOTHING                                            \
4169                        : ( EXACT == (X) )                                   \
4170                          ? EXACT                                            \
4171                          : ( EXACTFU == (X) || EXACTFU_SS == (X) )          \
4172                            ? EXACTFU                                        \
4173                            : ( EXACTFA == (X) )                             \
4174                              ? EXACTFA                                      \
4175                              : ( EXACTL == (X) )                            \
4176                                ? EXACTL                                     \
4177                                : ( EXACTFLU8 == (X) )                        \
4178                                  ? EXACTFLU8                                 \
4179                                  : 0 )
4180
4181                         /* dont use tail as the end marker for this traverse */
4182                         for ( cur = startbranch ; cur != scan ; cur = regnext( cur ) ) {
4183                             regnode * const noper = NEXTOPER( cur );
4184                             U8 noper_type = OP( noper );
4185                             U8 noper_trietype = TRIE_TYPE( noper_type );
4186 #if defined(DEBUGGING) || defined(NOJUMPTRIE)
4187                             regnode * const noper_next = regnext( noper );
4188                             U8 noper_next_type = (noper_next && noper_next != tail) ? OP(noper_next) : 0;
4189                             U8 noper_next_trietype = (noper_next && noper_next != tail) ? TRIE_TYPE( noper_next_type ) :0;
4190 #endif
4191
4192                             DEBUG_TRIE_COMPILE_r({
4193                                 regprop(RExC_rx, RExC_mysv, cur, NULL, pRExC_state);
4194                                 PerlIO_printf( Perl_debug_log, "%*s- %s (%d)",
4195                                    (int)depth * 2 + 2,"", SvPV_nolen_const( RExC_mysv ), REG_NODE_NUM(cur) );
4196
4197                                 regprop(RExC_rx, RExC_mysv, noper, NULL, pRExC_state);
4198                                 PerlIO_printf( Perl_debug_log, " -> %s",
4199                                     SvPV_nolen_const(RExC_mysv));
4200
4201                                 if ( noper_next ) {
4202                                   regprop(RExC_rx, RExC_mysv, noper_next, NULL, pRExC_state);
4203                                   PerlIO_printf( Perl_debug_log,"\t=> %s\t",
4204                                     SvPV_nolen_const(RExC_mysv));
4205                                 }
4206                                 PerlIO_printf( Perl_debug_log, "(First==%d,Last==%d,Cur==%d,tt==%s,nt==%s,nnt==%s)\n",
4207                                    REG_NODE_NUM(first), REG_NODE_NUM(last), REG_NODE_NUM(cur),
4208                                    PL_reg_name[trietype], PL_reg_name[noper_trietype], PL_reg_name[noper_next_trietype]
4209                                 );
4210                             });
4211
4212                             /* Is noper a trieable nodetype that can be merged
4213                              * with the current trie (if there is one)? */
4214                             if ( noper_trietype
4215                                   &&
4216                                   (
4217                                         ( noper_trietype == NOTHING)
4218                                         || ( trietype == NOTHING )
4219                                         || ( trietype == noper_trietype )
4220                                   )
4221 #ifdef NOJUMPTRIE
4222                                   && noper_next == tail
4223 #endif
4224                                   && count < U16_MAX)
4225                             {
4226                                 /* Handle mergable triable node Either we are
4227                                  * the first node in a new trieable sequence,
4228                                  * in which case we do some bookkeeping,
4229                                  * otherwise we update the end pointer. */
4230                                 if ( !first ) {
4231                                     first = cur;
4232                                     if ( noper_trietype == NOTHING ) {
4233 #if !defined(DEBUGGING) && !defined(NOJUMPTRIE)
4234                                         regnode * const noper_next = regnext( noper );
4235                                         U8 noper_next_type = (noper_next && noper_next!=tail) ? OP(noper_next) : 0;
4236                                         U8 noper_next_trietype = noper_next_type ? TRIE_TYPE( noper_next_type ) :0;
4237 #endif
4238
4239                                         if ( noper_next_trietype ) {
4240                                             trietype = noper_next_trietype;
4241                                         } else if (noper_next_type)  {
4242                                             /* a NOTHING regop is 1 regop wide.
4243                                              * We need at least two for a trie
4244                                              * so we can't merge this in */
4245                                             first = NULL;
4246                                         }
4247                                     } else {
4248                                         trietype = noper_trietype;
4249                                     }
4250                                 } else {
4251                                     if ( trietype == NOTHING )
4252                                         trietype = noper_trietype;
4253                                     last = cur;
4254                                 }
4255                                 if (first)
4256                                     count++;
4257                             } /* end handle mergable triable node */
4258                             else {
4259                                 /* handle unmergable node -
4260                                  * noper may either be a triable node which can
4261                                  * not be tried together with the current trie,
4262                                  * or a non triable node */
4263                                 if ( last ) {
4264                                     /* If last is set and trietype is not
4265                                      * NOTHING then we have found at least two
4266                                      * triable branch sequences in a row of a
4267                                      * similar trietype so we can turn them
4268                                      * into a trie. If/when we allow NOTHING to
4269                                      * start a trie sequence this condition
4270                                      * will be required, and it isn't expensive
4271                                      * so we leave it in for now. */
4272                                     if ( trietype && trietype != NOTHING )
4273                                         make_trie( pRExC_state,
4274                                                 startbranch, first, cur, tail,
4275                                                 count, trietype, depth+1 );
4276                                     last = NULL; /* note: we clear/update
4277                                                     first, trietype etc below,
4278                                                     so we dont do it here */
4279                                 }
4280                                 if ( noper_trietype
4281 #ifdef NOJUMPTRIE
4282                                      && noper_next == tail
4283 #endif
4284                                 ){
4285                                     /* noper is triable, so we can start a new
4286                                      * trie sequence */
4287                                     count = 1;
4288                                     first = cur;
4289                                     trietype = noper_trietype;
4290                                 } else if (first) {
4291                                     /* if we already saw a first but the
4292                                      * current node is not triable then we have
4293                                      * to reset the first information. */
4294                                     count = 0;
4295                                     first = NULL;
4296                                     trietype = 0;
4297                                 }
4298                             } /* end handle unmergable node */
4299                         } /* loop over branches */
4300                         DEBUG_TRIE_COMPILE_r({
4301                             regprop(RExC_rx, RExC_mysv, cur, NULL, pRExC_state);
4302                             PerlIO_printf( Perl_debug_log,
4303                               "%*s- %s (%d) <SCAN FINISHED>\n",
4304                               (int)depth * 2 + 2,
4305                               "", SvPV_nolen_const( RExC_mysv ),REG_NODE_NUM(cur));
4306
4307                         });
4308                         if ( last && trietype ) {
4309                             if ( trietype != NOTHING ) {
4310                                 /* the last branch of the sequence was part of
4311                                  * a trie, so we have to construct it here
4312                                  * outside of the loop */
4313                                 made= make_trie( pRExC_state, startbranch,
4314                                                  first, scan, tail, count,
4315                                                  trietype, depth+1 );
4316 #ifdef TRIE_STUDY_OPT
4317                                 if ( ((made == MADE_EXACT_TRIE &&
4318                                      startbranch == first)
4319                                      || ( first_non_open == first )) &&
4320                                      depth==0 ) {
4321                                     flags |= SCF_TRIE_RESTUDY;
4322                                     if ( startbranch == first
4323                                          && scan == tail )
4324                                     {
4325                                         RExC_seen &=~REG_TOP_LEVEL_BRANCHES_SEEN;
4326                                     }
4327                                 }
4328 #endif
4329                             } else {
4330                                 /* at this point we know whatever we have is a
4331                                  * NOTHING sequence/branch AND if 'startbranch'
4332                                  * is 'first' then we can turn the whole thing
4333                                  * into a NOTHING
4334                                  */
4335                                 if ( startbranch == first ) {
4336                                     regnode *opt;
4337                                     /* the entire thing is a NOTHING sequence,
4338                                      * something like this: (?:|) So we can
4339                                      * turn it into a plain NOTHING op. */
4340                                     DEBUG_TRIE_COMPILE_r({
4341                                         regprop(RExC_rx, RExC_mysv, cur, NULL, pRExC_state);
4342                                         PerlIO_printf( Perl_debug_log,
4343                                           "%*s- %s (%d) <NOTHING BRANCH SEQUENCE>\n", (int)depth * 2 + 2,
4344                                           "", SvPV_nolen_const( RExC_mysv ),REG_NODE_NUM(cur));
4345
4346                                     });
4347                                     OP(startbranch)= NOTHING;
4348                                     NEXT_OFF(startbranch)= tail - startbranch;
4349                                     for ( opt= startbranch + 1; opt < tail ; opt++ )
4350                                         OP(opt)= OPTIMIZED;
4351                                 }
4352                             }
4353                         } /* end if ( last) */
4354                     } /* TRIE_MAXBUF is non zero */
4355
4356                 } /* do trie */
4357
4358             }
4359             else if ( code == BRANCHJ ) {  /* single branch is optimized. */
4360                 scan = NEXTOPER(NEXTOPER(scan));
4361             } else                      /* single branch is optimized. */
4362                 scan = NEXTOPER(scan);
4363             continue;
4364         } else if (OP(scan) == SUSPEND || OP(scan) == GOSUB || OP(scan) == GOSTART) {
4365             I32 paren = 0;
4366             regnode *start = NULL;
4367             regnode *end = NULL;
4368             U32 my_recursed_depth= recursed_depth;
4369
4370
4371             if (OP(scan) != SUSPEND) { /* GOSUB/GOSTART */
4372                 /* Do setup, note this code has side effects beyond
4373                  * the rest of this block. Specifically setting
4374                  * RExC_recurse[] must happen at least once during
4375                  * study_chunk(). */
4376                 if (OP(scan) == GOSUB) {
4377                     paren = ARG(scan);
4378                     RExC_recurse[ARG2L(scan)] = scan;
4379                     start = RExC_open_parens[paren-1];
4380                     end   = RExC_close_parens[paren-1];
4381                 } else {
4382                     start = RExC_rxi->program + 1;
4383                     end   = RExC_opend;
4384                 }
4385                 /* NOTE we MUST always execute the above code, even
4386                  * if we do nothing with a GOSUB/GOSTART */
4387                 if (
4388                     ( flags & SCF_IN_DEFINE )
4389                     ||
4390                     (
4391                         (is_inf_internal || is_inf || (data && data->flags & SF_IS_INF))
4392                         &&
4393                         ( (flags & (SCF_DO_STCLASS | SCF_DO_SUBSTR)) == 0 )
4394                     )
4395                 ) {
4396                     /* no need to do anything here if we are in a define. */
4397                     /* or we are after some kind of infinite construct
4398                      * so we can skip recursing into this item.
4399                      * Since it is infinite we will not change the maxlen
4400                      * or delta, and if we miss something that might raise
4401                      * the minlen it will merely pessimise a little.
4402                      *
4403                      * Iow /(?(DEFINE)(?<foo>foo|food))a+(?&foo)/
4404                      * might result in a minlen of 1 and not of 4,
4405                      * but this doesn't make us mismatch, just try a bit
4406                      * harder than we should.
4407                      * */
4408                     scan= regnext(scan);
4409                     continue;
4410                 }
4411
4412                 if (
4413                     !recursed_depth
4414                     ||
4415                     !PAREN_TEST(RExC_study_chunk_recursed + ((recursed_depth-1) * RExC_study_chunk_recursed_bytes), paren)
4416                 ) {
4417                     /* it is quite possible that there are more efficient ways
4418                      * to do this. We maintain a bitmap per level of recursion
4419                      * of which patterns we have entered so we can detect if a
4420                      * pattern creates a possible infinite loop. When we
4421                      * recurse down a level we copy the previous levels bitmap
4422                      * down. When we are at recursion level 0 we zero the top
4423                      * level bitmap. It would be nice to implement a different
4424                      * more efficient way of doing this. In particular the top
4425                      * level bitmap may be unnecessary.
4426                      */
4427                     if (!recursed_depth) {
4428                         Zero(RExC_study_chunk_recursed, RExC_study_chunk_recursed_bytes, U8);
4429                     } else {
4430                         Copy(RExC_study_chunk_recursed + ((recursed_depth-1) * RExC_study_chunk_recursed_bytes),
4431                              RExC_study_chunk_recursed + (recursed_depth * RExC_study_chunk_recursed_bytes),
4432                              RExC_study_chunk_recursed_bytes, U8);
4433                     }
4434                     /* we havent recursed into this paren yet, so recurse into it */
4435                     DEBUG_STUDYDATA("set:", data,depth);
4436                     PAREN_SET(RExC_study_chunk_recursed + (recursed_depth * RExC_study_chunk_recursed_bytes), paren);
4437                     my_recursed_depth= recursed_depth + 1;
4438                 } else {
4439                     DEBUG_STUDYDATA("inf:", data,depth);
4440                     /* some form of infinite recursion, assume infinite length
4441                      * */
4442                     if (flags & SCF_DO_SUBSTR) {
4443                         scan_commit(pRExC_state, data, minlenp, is_inf);
4444                         data->longest = &(data->longest_float);
4445                     }
4446                     is_inf = is_inf_internal = 1;
4447                     if (flags & SCF_DO_STCLASS_OR) /* Allow everything */
4448                         ssc_anything(data->start_class);
4449                     flags &= ~SCF_DO_STCLASS;
4450
4451                     start= NULL; /* reset start so we dont recurse later on. */
4452                 }
4453             } else {
4454                 paren = stopparen;
4455                 start = scan + 2;
4456                 end = regnext(scan);
4457             }
4458             if (start) {
4459                 scan_frame *newframe;
4460                 assert(end);
4461                 if (!RExC_frame_last) {
4462                     Newxz(newframe, 1, scan_frame);
4463                     SAVEDESTRUCTOR_X(S_unwind_scan_frames, newframe);
4464                     RExC_frame_head= newframe;
4465                     RExC_frame_count++;
4466                 } else if (!RExC_frame_last->next_frame) {
4467                     Newxz(newframe,1,scan_frame);
4468                     RExC_frame_last->next_frame= newframe;
4469                     newframe->prev_frame= RExC_frame_last;
4470                     RExC_frame_count++;
4471                 } else {
4472                     newframe= RExC_frame_last->next_frame;
4473                 }
4474                 RExC_frame_last= newframe;
4475
4476                 newframe->next_regnode = regnext(scan);
4477                 newframe->last_regnode = last;
4478                 newframe->stopparen = stopparen;
4479                 newframe->prev_recursed_depth = recursed_depth;
4480                 newframe->this_prev_frame= frame;
4481
4482                 DEBUG_STUDYDATA("frame-new:",data,depth);
4483                 DEBUG_PEEP("fnew", scan, depth);
4484
4485                 frame = newframe;
4486                 scan =  start;
4487                 stopparen = paren;
4488                 last = end;
4489                 depth = depth + 1;
4490                 recursed_depth= my_recursed_depth;
4491
4492                 continue;
4493             }
4494         }
4495         else if (OP(scan) == EXACT || OP(scan) == EXACTL) {
4496             SSize_t l = STR_LEN(scan);
4497             UV uc;
4498             if (UTF) {
4499                 const U8 * const s = (U8*)STRING(scan);
4500                 uc = utf8_to_uvchr_buf(s, s + l, NULL);
4501                 l = utf8_length(s, s + l);
4502             } else {
4503                 uc = *((U8*)STRING(scan));
4504             }
4505             min += l;
4506             if (flags & SCF_DO_SUBSTR) { /* Update longest substr. */
4507                 /* The code below prefers earlier match for fixed
4508                    offset, later match for variable offset.  */
4509                 if (data->last_end == -1) { /* Update the start info. */
4510                     data->last_start_min = data->pos_min;
4511                     data->last_start_max = is_inf
4512                         ? SSize_t_MAX : data->pos_min + data->pos_delta;
4513                 }
4514                 sv_catpvn(data->last_found, STRING(scan), STR_LEN(scan));
4515                 if (UTF)
4516                     SvUTF8_on(data->last_found);
4517                 {
4518                     SV * const sv = data->last_found;
4519                     MAGIC * const mg = SvUTF8(sv) && SvMAGICAL(sv) ?
4520                         mg_find(sv, PERL_MAGIC_utf8) : NULL;
4521                     if (mg && mg->mg_len >= 0)
4522                         mg->mg_len += utf8_length((U8*)STRING(scan),
4523                                               (U8*)STRING(scan)+STR_LEN(scan));
4524                 }
4525                 data->last_end = data->pos_min + l;
4526                 data->pos_min += l; /* As in the first entry. */
4527                 data->flags &= ~SF_BEFORE_EOL;
4528             }
4529
4530             /* ANDing the code point leaves at most it, and not in locale, and
4531              * can't match null string */
4532             if (flags & SCF_DO_STCLASS_AND) {
4533                 ssc_cp_and(data->start_class, uc);
4534                 ANYOF_FLAGS(data->start_class) &= ~SSC_MATCHES_EMPTY_STRING;
4535                 ssc_clear_locale(data->start_class);
4536             }
4537             else if (flags & SCF_DO_STCLASS_OR) {
4538                 ssc_add_cp(data->start_class, uc);
4539                 ssc_and(pRExC_state, data->start_class, (regnode_charclass *) and_withp);
4540
4541                 /* See commit msg 749e076fceedeb708a624933726e7989f2302f6a */
4542                 ANYOF_FLAGS(data->start_class) &= ~SSC_MATCHES_EMPTY_STRING;
4543             }
4544             flags &= ~SCF_DO_STCLASS;
4545         }
4546         else if (PL_regkind[OP(scan)] == EXACT) {
4547             /* But OP != EXACT!, so is EXACTFish */
4548             SSize_t l = STR_LEN(scan);
4549             const U8 * s = (U8*)STRING(scan);
4550
4551             /* Search for fixed substrings supports EXACT only. */
4552             if (flags & SCF_DO_SUBSTR) {
4553                 assert(data);
4554                 scan_commit(pRExC_state, data, minlenp, is_inf);
4555             }
4556             if (UTF) {
4557                 l = utf8_length(s, s + l);
4558             }
4559             if (unfolded_multi_char) {
4560                 RExC_seen |= REG_UNFOLDED_MULTI_SEEN;
4561             }
4562             min += l - min_subtract;
4563             assert (min >= 0);
4564             delta += min_subtract;
4565             if (flags & SCF_DO_SUBSTR) {
4566                 data->pos_min += l - min_subtract;
4567                 if (data->pos_min < 0) {
4568                     data->pos_min = 0;
4569                 }
4570                 data->pos_delta += min_subtract;
4571                 if (min_subtract) {
4572                     data->longest = &(data->longest_float);
4573                 }
4574             }
4575
4576             if (flags & SCF_DO_STCLASS) {
4577                 SV* EXACTF_invlist = _make_exactf_invlist(pRExC_state, scan);
4578
4579                 assert(EXACTF_invlist);
4580                 if (flags & SCF_DO_STCLASS_AND) {
4581                     if (OP(scan) != EXACTFL)
4582                         ssc_clear_locale(data->start_class);
4583                     ANYOF_FLAGS(data->start_class) &= ~SSC_MATCHES_EMPTY_STRING;
4584                     ANYOF_POSIXL_ZERO(data->start_class);
4585                     ssc_intersection(data->start_class, EXACTF_invlist, FALSE);
4586                 }
4587                 else {  /* SCF_DO_STCLASS_OR */
4588                     ssc_union(data->start_class, EXACTF_invlist, FALSE);
4589                     ssc_and(pRExC_state, data->start_class, (regnode_charclass *) and_withp);
4590
4591                     /* See commit msg 749e076fceedeb708a624933726e7989f2302f6a */
4592                     ANYOF_FLAGS(data->start_class) &= ~SSC_MATCHES_EMPTY_STRING;
4593                 }
4594                 flags &= ~SCF_DO_STCLASS;
4595                 SvREFCNT_dec(EXACTF_invlist);
4596             }
4597         }
4598         else if (REGNODE_VARIES(OP(scan))) {
4599             SSize_t mincount, maxcount, minnext, deltanext, pos_before = 0;
4600             I32 fl = 0, f = flags;
4601             regnode * const oscan = scan;
4602             regnode_ssc this_class;
4603             regnode_ssc *oclass = NULL;
4604             I32 next_is_eval = 0;
4605
4606             switch (PL_regkind[OP(scan)]) {
4607             case WHILEM:                /* End of (?:...)* . */
4608                 scan = NEXTOPER(scan);
4609                 goto finish;
4610             case PLUS:
4611                 if (flags & (SCF_DO_SUBSTR | SCF_DO_STCLASS)) {
4612                     next = NEXTOPER(scan);
4613                     if (OP(next) == EXACT
4614                         || OP(next) == EXACTL
4615                         || (flags & SCF_DO_STCLASS))
4616                     {
4617                         mincount = 1;
4618                         maxcount = REG_INFTY;
4619                         next = regnext(scan);
4620                         scan = NEXTOPER(scan);
4621                         goto do_curly;
4622                     }
4623                 }
4624                 if (flags & SCF_DO_SUBSTR)
4625                     data->pos_min++;
4626                 min++;
4627                 /* FALLTHROUGH */
4628             case STAR:
4629                 if (flags & SCF_DO_STCLASS) {
4630                     mincount = 0;
4631                     maxcount = REG_INFTY;
4632                     next = regnext(scan);
4633                     scan = NEXTOPER(scan);
4634                     goto do_curly;
4635                 }
4636                 if (flags & SCF_DO_SUBSTR) {
4637                     scan_commit(pRExC_state, data, minlenp, is_inf);
4638                     /* Cannot extend fixed substrings */
4639                     data->longest = &(data->longest_float);
4640                 }
4641                 is_inf = is_inf_internal = 1;
4642                 scan = regnext(scan);
4643                 goto optimize_curly_tail;
4644             case CURLY:
4645                 if (stopparen>0 && (OP(scan)==CURLYN || OP(scan)==CURLYM)
4646                     && (scan->flags == stopparen))
4647                 {
4648                     mincount = 1;
4649                     maxcount = 1;
4650                 } else {
4651                     mincount = ARG1(scan);
4652                     maxcount = ARG2(scan);
4653                 }
4654                 next = regnext(scan);
4655                 if (OP(scan) == CURLYX) {
4656                     I32 lp = (data ? *(data->last_closep) : 0);
4657                     scan->flags = ((lp <= (I32)U8_MAX) ? (U8)lp : U8_MAX);
4658                 }
4659                 scan = NEXTOPER(scan) + EXTRA_STEP_2ARGS;
4660                 next_is_eval = (OP(scan) == EVAL);
4661               do_curly:
4662                 if (flags & SCF_DO_SUBSTR) {
4663                     if (mincount == 0)
4664                         scan_commit(pRExC_state, data, minlenp, is_inf);
4665                     /* Cannot extend fixed substrings */
4666                     pos_before = data->pos_min;
4667                 }
4668                 if (data) {
4669                     fl = data->flags;
4670                     data->flags &= ~(SF_HAS_PAR|SF_IN_PAR|SF_HAS_EVAL);
4671                     if (is_inf)
4672                         data->flags |= SF_IS_INF;
4673                 }
4674                 if (flags & SCF_DO_STCLASS) {
4675                     ssc_init(pRExC_state, &this_class);
4676                     oclass = data->start_class;
4677                     data->start_class = &this_class;
4678                     f |= SCF_DO_STCLASS_AND;
4679                     f &= ~SCF_DO_STCLASS_OR;
4680                 }
4681                 /* Exclude from super-linear cache processing any {n,m}
4682                    regops for which the combination of input pos and regex
4683                    pos is not enough information to determine if a match
4684                    will be possible.
4685
4686                    For example, in the regex /foo(bar\s*){4,8}baz/ with the
4687                    regex pos at the \s*, the prospects for a match depend not
4688                    only on the input position but also on how many (bar\s*)
4689                    repeats into the {4,8} we are. */
4690                if ((mincount > 1) || (maxcount > 1 && maxcount != REG_INFTY))
4691                     f &= ~SCF_WHILEM_VISITED_POS;
4692
4693                 /* This will finish on WHILEM, setting scan, or on NULL: */
4694                 minnext = study_chunk(pRExC_state, &scan, minlenp, &deltanext,
4695                                   last, data, stopparen, recursed_depth, NULL,
4696                                   (mincount == 0
4697                                    ? (f & ~SCF_DO_SUBSTR)
4698                                    : f)
4699                                   ,depth+1);
4700
4701                 if (flags & SCF_DO_STCLASS)
4702                     data->start_class = oclass;
4703                 if (mincount == 0 || minnext == 0) {
4704                     if (flags & SCF_DO_STCLASS_OR) {
4705                         ssc_or(pRExC_state, data->start_class, (regnode_charclass *) &this_class);
4706                     }
4707                     else if (flags & SCF_DO_STCLASS_AND) {
4708                         /* Switch to OR mode: cache the old value of
4709                          * data->start_class */
4710                         INIT_AND_WITHP;
4711                         StructCopy(data->start_class, and_withp, regnode_ssc);
4712                         flags &= ~SCF_DO_STCLASS_AND;
4713                         StructCopy(&this_class, data->start_class, regnode_ssc);
4714                         flags |= SCF_DO_STCLASS_OR;
4715                         ANYOF_FLAGS(data->start_class)
4716                                                 |= SSC_MATCHES_EMPTY_STRING;
4717                     }
4718                 } else {                /* Non-zero len */
4719                     if (flags & SCF_DO_STCLASS_OR) {
4720                         ssc_or(pRExC_state, data->start_class, (regnode_charclass *) &this_class);
4721                         ssc_and(pRExC_state, data->start_class, (regnode_charclass *) and_withp);
4722                     }
4723                     else if (flags & SCF_DO_STCLASS_AND)
4724                         ssc_and(pRExC_state, data->start_class, (regnode_charclass *) &this_class);
4725                     flags &= ~SCF_DO_STCLASS;
4726                 }
4727                 if (!scan)              /* It was not CURLYX, but CURLY. */
4728                     scan = next;
4729                 if (!(flags & SCF_TRIE_DOING_RESTUDY)
4730                     /* ? quantifier ok, except for (?{ ... }) */
4731                     && (next_is_eval || !(mincount == 0 && maxcount == 1))
4732                     && (minnext == 0) && (deltanext == 0)
4733                     && data && !(data->flags & (SF_HAS_PAR|SF_IN_PAR))
4734                     && maxcount <= REG_INFTY/3) /* Complement check for big
4735                                                    count */
4736                 {
4737                     /* Fatal warnings may leak the regexp without this: */
4738                     SAVEFREESV(RExC_rx_sv);
4739                     Perl_ck_warner(aTHX_ packWARN(WARN_REGEXP),
4740                         "Quantifier unexpected on zero-length expression "
4741                         "in regex m/%"UTF8f"/",
4742                          UTF8fARG(UTF, RExC_end - RExC_precomp,
4743                                   RExC_precomp));
4744                     (void)ReREFCNT_inc(RExC_rx_sv);
4745                 }
4746
4747                 min += minnext * mincount;
4748                 is_inf_internal |= deltanext == SSize_t_MAX
4749                          || (maxcount == REG_INFTY && minnext + deltanext > 0);
4750                 is_inf |= is_inf_internal;
4751                 if (is_inf) {
4752                     delta = SSize_t_MAX;
4753                 } else {
4754                     delta += (minnext + deltanext) * maxcount
4755                              - minnext * mincount;
4756                 }
4757                 /* Try powerful optimization CURLYX => CURLYN. */
4758                 if (  OP(oscan) == CURLYX && data
4759                       && data->flags & SF_IN_PAR
4760                       && !(data->flags & SF_HAS_EVAL)
4761                       && !deltanext && minnext == 1 ) {
4762                     /* Try to optimize to CURLYN.  */
4763                     regnode *nxt = NEXTOPER(oscan) + EXTRA_STEP_2ARGS;
4764                     regnode * const nxt1 = nxt;
4765 #ifdef DEBUGGING
4766                     regnode *nxt2;
4767 #endif
4768
4769                     /* Skip open. */
4770                     nxt = regnext(nxt);
4771                     if (!REGNODE_SIMPLE(OP(nxt))
4772                         && !(PL_regkind[OP(nxt)] == EXACT
4773                              && STR_LEN(nxt) == 1))
4774                         goto nogo;
4775 #ifdef DEBUGGING
4776                     nxt2 = nxt;
4777 #endif
4778                     nxt = regnext(nxt);
4779                     if (OP(nxt) != CLOSE)
4780                         goto nogo;
4781                     if (RExC_open_parens) {
4782                         RExC_open_parens[ARG(nxt1)-1]=oscan; /*open->CURLYM*/
4783                         RExC_close_parens[ARG(nxt1)-1]=nxt+2; /*close->while*/
4784                     }
4785                     /* Now we know that nxt2 is the only contents: */
4786                     oscan->flags = (U8)ARG(nxt);
4787                     OP(oscan) = CURLYN;
4788                     OP(nxt1) = NOTHING; /* was OPEN. */
4789
4790 #ifdef DEBUGGING
4791                     OP(nxt1 + 1) = OPTIMIZED; /* was count. */
4792                     NEXT_OFF(nxt1+ 1) = 0; /* just for consistency. */
4793                     NEXT_OFF(nxt2) = 0; /* just for consistency with CURLY. */
4794                     OP(nxt) = OPTIMIZED;        /* was CLOSE. */
4795                     OP(nxt + 1) = OPTIMIZED; /* was count. */
4796                     NEXT_OFF(nxt+ 1) = 0; /* just for consistency. */
4797 #endif
4798                 }
4799               nogo:
4800
4801                 /* Try optimization CURLYX => CURLYM. */
4802                 if (  OP(oscan) == CURLYX && data
4803                       && !(data->flags & SF_HAS_PAR)
4804                       && !(data->flags & SF_HAS_EVAL)
4805                       && !deltanext     /* atom is fixed width */
4806                       && minnext != 0   /* CURLYM can't handle zero width */
4807
4808                          /* Nor characters whose fold at run-time may be
4809                           * multi-character */
4810                       && ! (RExC_seen & REG_UNFOLDED_MULTI_SEEN)
4811                 ) {
4812                     /* XXXX How to optimize if data == 0? */
4813                     /* Optimize to a simpler form.  */
4814                     regnode *nxt = NEXTOPER(oscan) + EXTRA_STEP_2ARGS; /* OPEN */
4815                     regnode *nxt2;
4816
4817                     OP(oscan) = CURLYM;
4818                     while ( (nxt2 = regnext(nxt)) /* skip over embedded stuff*/
4819                             && (OP(nxt2) != WHILEM))
4820                         nxt = nxt2;
4821                     OP(nxt2)  = SUCCEED; /* Whas WHILEM */
4822                     /* Need to optimize away parenths. */
4823                     if ((data->flags & SF_IN_PAR) && OP(nxt) == CLOSE) {
4824                         /* Set the parenth number.  */
4825                         regnode *nxt1 = NEXTOPER(oscan) + EXTRA_STEP_2ARGS; /* OPEN*/
4826
4827                         oscan->flags = (U8)ARG(nxt);
4828                         if (RExC_open_parens) {
4829                             RExC_open_parens[ARG(nxt1)-1]=oscan; /*open->CURLYM*/
4830                             RExC_close_parens[ARG(nxt1)-1]=nxt2+1; /*close->NOTHING*/
4831                         }
4832                         OP(nxt1) = OPTIMIZED;   /* was OPEN. */
4833                         OP(nxt) = OPTIMIZED;    /* was CLOSE. */
4834
4835 #ifdef DEBUGGING
4836                         OP(nxt1 + 1) = OPTIMIZED; /* was count. */
4837                         OP(nxt + 1) = OPTIMIZED; /* was count. */
4838                         NEXT_OFF(nxt1 + 1) = 0; /* just for consistency. */
4839                         NEXT_OFF(nxt + 1) = 0; /* just for consistency. */
4840 #endif
4841 #if 0
4842                         while ( nxt1 && (OP(nxt1) != WHILEM)) {
4843                             regnode *nnxt = regnext(nxt1);
4844                             if (nnxt == nxt) {
4845                                 if (reg_off_by_arg[OP(nxt1)])
4846                                     ARG_SET(nxt1, nxt2 - nxt1);
4847                                 else if (nxt2 - nxt1 < U16_MAX)
4848                                     NEXT_OFF(nxt1) = nxt2 - nxt1;
4849                                 else
4850                                     OP(nxt) = NOTHING;  /* Cannot beautify */
4851                             }
4852                             nxt1 = nnxt;
4853                         }
4854 #endif
4855                         /* Optimize again: */
4856                         study_chunk(pRExC_state, &nxt1, minlenp, &deltanext, nxt,
4857                                     NULL, stopparen, recursed_depth, NULL, 0,depth+1);
4858                     }
4859                     else
4860                         oscan->flags = 0;
4861                 }
4862                 else if ((OP(oscan) == CURLYX)
4863                          && (flags & SCF_WHILEM_VISITED_POS)
4864                          /* See the comment on a similar expression above.
4865                             However, this time it's not a subexpression
4866                             we care about, but the expression itself. */
4867                          && (maxcount == REG_INFTY)
4868                          && data && ++data->whilem_c < 16) {
4869                     /* This stays as CURLYX, we can put the count/of pair. */
4870                     /* Find WHILEM (as in regexec.c) */
4871                     regnode *nxt = oscan + NEXT_OFF(oscan);
4872
4873                     if (OP(PREVOPER(nxt)) == NOTHING) /* LONGJMP */
4874                         nxt += ARG(nxt);
4875                     PREVOPER(nxt)->flags = (U8)(data->whilem_c
4876                         | (RExC_whilem_seen << 4)); /* On WHILEM */
4877                 }
4878                 if (data && fl & (SF_HAS_PAR|SF_IN_PAR))
4879                     pars++;
4880                 if (flags & SCF_DO_SUBSTR) {
4881                     SV *last_str = NULL;
4882                     STRLEN last_chrs = 0;
4883                     int counted = mincount != 0;
4884
4885                     if (data->last_end > 0 && mincount != 0) { /* Ends with a
4886                                                                   string. */
4887                         SSize_t b = pos_before >= data->last_start_min
4888                             ? pos_before : data->last_start_min;
4889                         STRLEN l;
4890                         const char * const s = SvPV_const(data->last_found, l);
4891                         SSize_t old = b - data->last_start_min;
4892
4893                         if (UTF)
4894                             old = utf8_hop((U8*)s, old) - (U8*)s;
4895                         l -= old;
4896                         /* Get the added string: */
4897                         last_str = newSVpvn_utf8(s  + old, l, UTF);
4898                         last_chrs = UTF ? utf8_length((U8*)(s + old),
4899                                             (U8*)(s + old + l)) : l;
4900                         if (deltanext == 0 && pos_before == b) {
4901                             /* What was added is a constant string */
4902                             if (mincount > 1) {
4903
4904                                 SvGROW(last_str, (mincount * l) + 1);
4905                                 repeatcpy(SvPVX(last_str) + l,
4906                                           SvPVX_const(last_str), l,
4907                                           mincount - 1);
4908                                 SvCUR_set(last_str, SvCUR(last_str) * mincount);
4909                                 /* Add additional parts. */
4910                                 SvCUR_set(data->last_found,
4911                                           SvCUR(data->last_found) - l);
4912                                 sv_catsv(data->last_found, last_str);
4913                                 {
4914                                     SV * sv = data->last_found;
4915                                     MAGIC *mg =
4916                                         SvUTF8(sv) && SvMAGICAL(sv) ?
4917                                         mg_find(sv, PERL_MAGIC_utf8) : NULL;
4918                                     if (mg && mg->mg_len >= 0)
4919                                         mg->mg_len += last_chrs * (mincount-1);
4920                                 }
4921                                 last_chrs *= mincount;
4922                                 data->last_end += l * (mincount - 1);
4923                             }
4924                         } else {
4925                             /* start offset must point into the last copy */
4926                             data->last_start_min += minnext * (mincount - 1);
4927                             data->last_start_max =
4928                               is_inf
4929                                ? SSize_t_MAX
4930                                : data->last_start_max +
4931                                  (maxcount - 1) * (minnext + data->pos_delta);
4932                         }
4933                     }
4934                     /* It is counted once already... */
4935                     data->pos_min += minnext * (mincount - counted);
4936 #if 0
4937 PerlIO_printf(Perl_debug_log, "counted=%"UVuf" deltanext=%"UVuf
4938                               " SSize_t_MAX=%"UVuf" minnext=%"UVuf
4939                               " maxcount=%"UVuf" mincount=%"UVuf"\n",
4940     (UV)counted, (UV)deltanext, (UV)SSize_t_MAX, (UV)minnext, (UV)maxcount,
4941     (UV)mincount);
4942 if (deltanext != SSize_t_MAX)
4943 PerlIO_printf(Perl_debug_log, "LHS=%"UVuf" RHS=%"UVuf"\n",
4944     (UV)(-counted * deltanext + (minnext + deltanext) * maxcount
4945           - minnext * mincount), (UV)(SSize_t_MAX - data->pos_delta));
4946 #endif
4947                     if (deltanext == SSize_t_MAX
4948                         || -counted * deltanext + (minnext + deltanext) * maxcount - minnext * mincount >= SSize_t_MAX - data->pos_delta)
4949                         data->pos_delta = SSize_t_MAX;
4950                     else
4951                         data->pos_delta += - counted * deltanext +
4952                         (minnext + deltanext) * maxcount - minnext * mincount;
4953                     if (mincount != maxcount) {
4954                          /* Cannot extend fixed substrings found inside
4955                             the group.  */
4956                         scan_commit(pRExC_state, data, minlenp, is_inf);
4957                         if (mincount && last_str) {
4958                             SV * const sv = data->last_found;
4959                             MAGIC * const mg = SvUTF8(sv) && SvMAGICAL(sv) ?
4960                                 mg_find(sv, PERL_MAGIC_utf8) : NULL;
4961
4962                             if (mg)
4963                                 mg->mg_len = -1;
4964                             sv_setsv(sv, last_str);
4965                             data->last_end = data->pos_min;
4966                             data->last_start_min = data->pos_min - last_chrs;
4967                             data->last_start_max = is_inf
4968                                 ? SSize_t_MAX
4969                                 : data->pos_min + data->pos_delta - last_chrs;
4970                         }
4971                         data->longest = &(data->longest_float);
4972                     }
4973                     SvREFCNT_dec(last_str);
4974                 }
4975                 if (data && (fl & SF_HAS_EVAL))
4976                     data->flags |= SF_HAS_EVAL;
4977               optimize_curly_tail:
4978                 if (OP(oscan) != CURLYX) {
4979                     while (PL_regkind[OP(next = regnext(oscan))] == NOTHING
4980                            && NEXT_OFF(next))
4981                         NEXT_OFF(oscan) += NEXT_OFF(next);
4982                 }
4983                 continue;
4984
4985             default:
4986 #ifdef DEBUGGING
4987                 Perl_croak(aTHX_ "panic: unexpected varying REx opcode %d",
4988                                                                     OP(scan));
4989 #endif
4990             case REF:
4991             case CLUMP:
4992                 if (flags & SCF_DO_SUBSTR) {
4993                     /* Cannot expect anything... */
4994                     scan_commit(pRExC_state, data, minlenp, is_inf);
4995                     data->longest = &(data->longest_float);
4996                 }
4997                 is_inf = is_inf_internal = 1;
4998                 if (flags & SCF_DO_STCLASS_OR) {
4999                     if (OP(scan) == CLUMP) {
5000                         /* Actually is any start char, but very few code points
5001                          * aren't start characters */
5002                         ssc_match_all_cp(data->start_class);
5003                     }
5004                     else {
5005                         ssc_anything(data->start_class);
5006                     }
5007                 }
5008                 flags &= ~SCF_DO_STCLASS;
5009                 break;
5010             }
5011         }
5012         else if (OP(scan) == LNBREAK) {
5013             if (flags & SCF_DO_STCLASS) {
5014                 if (flags & SCF_DO_STCLASS_AND) {
5015                     ssc_intersection(data->start_class,
5016                                     PL_XPosix_ptrs[_CC_VERTSPACE], FALSE);
5017                     ssc_clear_locale(data->start_class);
5018                     ANYOF_FLAGS(data->start_class)
5019                                                 &= ~SSC_MATCHES_EMPTY_STRING;
5020                 }
5021                 else if (flags & SCF_DO_STCLASS_OR) {
5022                     ssc_union(data->start_class,
5023                               PL_XPosix_ptrs[_CC_VERTSPACE],
5024                               FALSE);
5025                     ssc_and(pRExC_state, data->start_class, (regnode_charclass *) and_withp);
5026
5027                     /* See commit msg for
5028                      * 749e076fceedeb708a624933726e7989f2302f6a */
5029                     ANYOF_FLAGS(data->start_class)
5030                                                 &= ~SSC_MATCHES_EMPTY_STRING;
5031                 }
5032                 flags &= ~SCF_DO_STCLASS;
5033             }
5034             min++;
5035             if (delta != SSize_t_MAX)
5036                 delta++;    /* Because of the 2 char string cr-lf */
5037             if (flags & SCF_DO_SUBSTR) {
5038                 /* Cannot expect anything... */
5039                 scan_commit(pRExC_state, data, minlenp, is_inf);
5040                 data->pos_min += 1;
5041                 data->pos_delta += 1;
5042                 data->longest = &(data->longest_float);
5043             }
5044         }
5045         else if (REGNODE_SIMPLE(OP(scan))) {
5046
5047             if (flags & SCF_DO_SUBSTR) {
5048                 scan_commit(pRExC_state, data, minlenp, is_inf);
5049                 data->pos_min++;
5050             }
5051             min++;
5052             if (flags & SCF_DO_STCLASS) {
5053                 bool invert = 0;
5054                 SV* my_invlist = NULL;
5055                 U8 namedclass;
5056
5057                 /* See commit msg 749e076fceedeb708a624933726e7989f2302f6a */
5058                 ANYOF_FLAGS(data->start_class) &= ~SSC_MATCHES_EMPTY_STRING;
5059
5060                 /* Some of the logic below assumes that switching
5061                    locale on will only add false positives. */
5062                 switch (OP(scan)) {
5063
5064                 default:
5065 #ifdef DEBUGGING
5066                    Perl_croak(aTHX_ "panic: unexpected simple REx opcode %d",
5067                                                                      OP(scan));
5068 #endif
5069                 case SANY:
5070                     if (flags & SCF_DO_STCLASS_OR) /* Allow everything */
5071                         ssc_match_all_cp(data->start_class);
5072                     break;
5073
5074                 case REG_ANY:
5075                     {
5076                         SV* REG_ANY_invlist = _new_invlist(2);
5077                         REG_ANY_invlist = add_cp_to_invlist(REG_ANY_invlist,
5078                                                             '\n');
5079                         if (flags & SCF_DO_STCLASS_OR) {
5080                             ssc_union(data->start_class,
5081                                       REG_ANY_invlist,
5082                                       TRUE /* TRUE => invert, hence all but \n
5083                                             */
5084                                       );
5085                         }
5086                         else if (flags & SCF_DO_STCLASS_AND) {
5087                             ssc_intersection(data->start_class,
5088                                              REG_ANY_invlist,
5089                                              TRUE  /* TRUE => invert */
5090                                              );
5091                             ssc_clear_locale(data->start_class);
5092                         }
5093                         SvREFCNT_dec_NN(REG_ANY_invlist);
5094                     }
5095                     break;
5096
5097                 case ANYOFL:
5098                 case ANYOF:
5099                     if (flags & SCF_DO_STCLASS_AND)
5100                         ssc_and(pRExC_state, data->start_class,
5101                                 (regnode_charclass *) scan);
5102                     else
5103                         ssc_or(pRExC_state, data->start_class,
5104                                                           (regnode_charclass *) scan);
5105                     break;
5106
5107                 case NPOSIXL:
5108                     invert = 1;
5109                     /* FALLTHROUGH */
5110
5111                 case POSIXL:
5112                     namedclass = classnum_to_namedclass(FLAGS(scan)) + invert;
5113                     if (flags & SCF_DO_STCLASS_AND) {
5114                         bool was_there = cBOOL(
5115                                           ANYOF_POSIXL_TEST(data->start_class,
5116                                                                  namedclass));
5117                         ANYOF_POSIXL_ZERO(data->start_class);
5118                         if (was_there) {    /* Do an AND */
5119                             ANYOF_POSIXL_SET(data->start_class, namedclass);
5120                         }
5121                         /* No individual code points can now match */
5122                         data->start_class->invlist
5123                                                 = sv_2mortal(_new_invlist(0));
5124                     }
5125                     else {
5126                         int complement = namedclass + ((invert) ? -1 : 1);
5127
5128                         assert(flags & SCF_DO_STCLASS_OR);
5129
5130                         /* If the complement of this class was already there,
5131                          * the result is that they match all code points,
5132                          * (\d + \D == everything).  Remove the classes from
5133                          * future consideration.  Locale is not relevant in
5134                          * this case */
5135                         if (ANYOF_POSIXL_TEST(data->start_class, complement)) {
5136                             ssc_match_all_cp(data->start_class);
5137                             ANYOF_POSIXL_CLEAR(data->start_class, namedclass);
5138                             ANYOF_POSIXL_CLEAR(data->start_class, complement);
5139                         }
5140                         else {  /* The usual case; just add this class to the
5141                                    existing set */
5142                             ANYOF_POSIXL_SET(data->start_class, namedclass);
5143                         }
5144                     }
5145                     break;
5146
5147                 case NPOSIXA:   /* For these, we always know the exact set of
5148                                    what's matched */
5149                     invert = 1;
5150                     /* FALLTHROUGH */
5151                 case POSIXA:
5152                     if (FLAGS(scan) == _CC_ASCII) {
5153                         my_invlist = invlist_clone(PL_XPosix_ptrs[_CC_ASCII]);
5154                     }
5155                     else {
5156                         _invlist_intersection(PL_XPosix_ptrs[FLAGS(scan)],
5157                                               PL_XPosix_ptrs[_CC_ASCII],
5158                                               &my_invlist);
5159                     }
5160                     goto join_posix;
5161
5162                 case NPOSIXD:
5163                 case NPOSIXU:
5164                     invert = 1;
5165                     /* FALLTHROUGH */
5166                 case POSIXD:
5167                 case POSIXU:
5168                     my_invlist = invlist_clone(PL_XPosix_ptrs[FLAGS(scan)]);
5169
5170                     /* NPOSIXD matches all upper Latin1 code points unless the
5171                      * target string being matched is UTF-8, which is
5172                      * unknowable until match time.  Since we are going to
5173                      * invert, we want to get rid of all of them so that the
5174                      * inversion will match all */
5175                     if (OP(scan) == NPOSIXD) {
5176                         _invlist_subtract(my_invlist, PL_UpperLatin1,
5177                                           &my_invlist);
5178                     }
5179
5180                   join_posix:
5181
5182                     if (flags & SCF_DO_STCLASS_AND) {
5183                         ssc_intersection(data->start_class, my_invlist, invert);
5184                         ssc_clear_locale(data->start_class);
5185                     }
5186                     else {
5187                         assert(flags & SCF_DO_STCLASS_OR);
5188                         ssc_union(data->start_class, my_invlist, invert);
5189                     }
5190                     SvREFCNT_dec(my_invlist);
5191                 }
5192                 if (flags & SCF_DO_STCLASS_OR)
5193                     ssc_and(pRExC_state, data->start_class, (regnode_charclass *) and_withp);
5194                 flags &= ~SCF_DO_STCLASS;
5195             }
5196         }
5197         else if (PL_regkind[OP(scan)] == EOL && flags & SCF_DO_SUBSTR) {
5198             data->flags |= (OP(scan) == MEOL
5199                             ? SF_BEFORE_MEOL
5200                             : SF_BEFORE_SEOL);
5201             scan_commit(pRExC_state, data, minlenp, is_inf);
5202
5203         }
5204         else if (  PL_regkind[OP(scan)] == BRANCHJ
5205                  /* Lookbehind, or need to calculate parens/evals/stclass: */
5206                    && (scan->flags || data || (flags & SCF_DO_STCLASS))
5207                    && (OP(scan) == IFMATCH || OP(scan) == UNLESSM))
5208         {
5209             if ( !PERL_ENABLE_POSITIVE_ASSERTION_STUDY
5210                 || OP(scan) == UNLESSM )
5211             {
5212                 /* Negative Lookahead/lookbehind
5213                    In this case we can't do fixed string optimisation.
5214                 */
5215
5216                 SSize_t deltanext, minnext, fake = 0;
5217                 regnode *nscan;
5218                 regnode_ssc intrnl;
5219                 int f = 0;
5220
5221                 StructCopy(&zero_scan_data, &data_fake, scan_data_t);
5222                 if (data) {
5223                     data_fake.whilem_c = data->whilem_c;
5224                     data_fake.last_closep = data->last_closep;
5225                 }
5226                 else
5227                     data_fake.last_closep = &fake;
5228                 data_fake.pos_delta = delta;
5229                 if ( flags & SCF_DO_STCLASS && !scan->flags
5230                      && OP(scan) == IFMATCH ) { /* Lookahead */
5231                     ssc_init(pRExC_state, &intrnl);
5232                     data_fake.start_class = &intrnl;
5233                     f |= SCF_DO_STCLASS_AND;
5234                 }
5235                 if (flags & SCF_WHILEM_VISITED_POS)
5236                     f |= SCF_WHILEM_VISITED_POS;
5237                 next = regnext(scan);
5238                 nscan = NEXTOPER(NEXTOPER(scan));
5239                 minnext = study_chunk(pRExC_state, &nscan, minlenp, &deltanext,
5240                                       last, &data_fake, stopparen,
5241                                       recursed_depth, NULL, f, depth+1);
5242                 if (scan->flags) {
5243                     if (deltanext) {
5244                         FAIL("Variable length lookbehind not implemented");
5245                     }
5246                     else if (minnext > (I32)U8_MAX) {
5247                         FAIL2("Lookbehind longer than %"UVuf" not implemented",
5248                               (UV)U8_MAX);
5249                     }
5250                     scan->flags = (U8)minnext;
5251                 }
5252                 if (data) {
5253                     if (data_fake.flags & (SF_HAS_PAR|SF_IN_PAR))
5254                         pars++;
5255                     if (data_fake.flags & SF_HAS_EVAL)
5256                         data->flags |= SF_HAS_EVAL;
5257                     data->whilem_c = data_fake.whilem_c;
5258                 }
5259                 if (f & SCF_DO_STCLASS_AND) {
5260                     if (flags & SCF_DO_STCLASS_OR) {
5261                         /* OR before, AND after: ideally we would recurse with
5262                          * data_fake to get the AND applied by study of the
5263                          * remainder of the pattern, and then derecurse;
5264                          * *** HACK *** for now just treat as "no information".
5265                          * See [perl #56690].
5266                          */
5267                         ssc_init(pRExC_state, data->start_class);
5268                     }  else {
5269                         /* AND before and after: combine and continue.  These
5270                          * assertions are zero-length, so can match an EMPTY
5271                          * string */
5272                         ssc_and(pRExC_state, data->start_class, (regnode_charclass *) &intrnl);
5273                         ANYOF_FLAGS(data->start_class)
5274                                                    |= SSC_MATCHES_EMPTY_STRING;
5275                     }
5276                 }
5277             }
5278 #if PERL_ENABLE_POSITIVE_ASSERTION_STUDY
5279             else {
5280                 /* Positive Lookahead/lookbehind
5281                    In this case we can do fixed string optimisation,
5282                    but we must be careful about it. Note in the case of
5283                    lookbehind the positions will be offset by the minimum
5284                    length of the pattern, something we won't know about
5285                    until after the recurse.
5286                 */
5287                 SSize_t deltanext, fake = 0;
5288                 regnode *nscan;
5289                 regnode_ssc intrnl;
5290                 int f = 0;
5291                 /* We use SAVEFREEPV so that when the full compile
5292                     is finished perl will clean up the allocated
5293                     minlens when it's all done. This way we don't
5294                     have to worry about freeing them when we know
5295                     they wont be used, which would be a pain.
5296                  */
5297                 SSize_t *minnextp;
5298                 Newx( minnextp, 1, SSize_t );
5299                 SAVEFREEPV(minnextp);
5300
5301                 if (data) {
5302                     StructCopy(data, &data_fake, scan_data_t);
5303                     if ((flags & SCF_DO_SUBSTR) && data->last_found) {
5304                         f |= SCF_DO_SUBSTR;
5305                         if (scan->flags)
5306                             scan_commit(pRExC_state, &data_fake, minlenp, is_inf);
5307                         data_fake.last_found=newSVsv(data->last_found);
5308                     }
5309                 }
5310                 else
5311                     data_fake.last_closep = &fake;
5312                 data_fake.flags = 0;
5313                 data_fake.pos_delta = delta;
5314                 if (is_inf)
5315                     data_fake.flags |= SF_IS_INF;
5316                 if ( flags & SCF_DO_STCLASS && !scan->flags
5317                      && OP(scan) == IFMATCH ) { /* Lookahead */
5318                     ssc_init(pRExC_state, &intrnl);
5319                     data_fake.start_class = &intrnl;
5320                     f |= SCF_DO_STCLASS_AND;
5321                 }
5322                 if (flags & SCF_WHILEM_VISITED_POS)
5323                     f |= SCF_WHILEM_VISITED_POS;
5324                 next = regnext(scan);
5325                 nscan = NEXTOPER(NEXTOPER(scan));
5326
5327                 *minnextp = study_chunk(pRExC_state, &nscan, minnextp,
5328                                         &deltanext, last, &data_fake,
5329                                         stopparen, recursed_depth, NULL,
5330                                         f,depth+1);
5331                 if (scan->flags) {
5332                     if (deltanext) {
5333                         FAIL("Variable length lookbehind not implemented");
5334                     }
5335                     else if (*minnextp > (I32)U8_MAX) {
5336                         FAIL2("Lookbehind longer than %"UVuf" not implemented",
5337                               (UV)U8_MAX);
5338                     }
5339                     scan->flags = (U8)*minnextp;
5340                 }
5341
5342                 *minnextp += min;
5343
5344                 if (f & SCF_DO_STCLASS_AND) {
5345                     ssc_and(pRExC_state, data->start_class, (regnode_charclass *) &intrnl);
5346                     ANYOF_FLAGS(data->start_class) |= SSC_MATCHES_EMPTY_STRING;
5347                 }
5348                 if (data) {
5349                     if (data_fake.flags & (SF_HAS_PAR|SF_IN_PAR))
5350                         pars++;
5351                     if (data_fake.flags & SF_HAS_EVAL)
5352                         data->flags |= SF_HAS_EVAL;
5353                     data->whilem_c = data_fake.whilem_c;
5354                     if ((flags & SCF_DO_SUBSTR) && data_fake.last_found) {
5355                         if (RExC_rx->minlen<*minnextp)
5356                             RExC_rx->minlen=*minnextp;
5357                         scan_commit(pRExC_state, &data_fake, minnextp, is_inf);
5358                         SvREFCNT_dec_NN(data_fake.last_found);
5359
5360                         if ( data_fake.minlen_fixed != minlenp )
5361                         {
5362                             data->offset_fixed= data_fake.offset_fixed;
5363                             data->minlen_fixed= data_fake.minlen_fixed;
5364                             data->lookbehind_fixed+= scan->flags;
5365                         }
5366                         if ( data_fake.minlen_float != minlenp )
5367                         {
5368                             data->minlen_float= data_fake.minlen_float;
5369                             data->offset_float_min=data_fake.offset_float_min;
5370                             data->offset_float_max=data_fake.offset_float_max;
5371                             data->lookbehind_float+= scan->flags;
5372                         }
5373                     }
5374                 }
5375             }
5376 #endif
5377         }
5378         else if (OP(scan) == OPEN) {
5379             if (stopparen != (I32)ARG(scan))
5380                 pars++;
5381         }
5382         else if (OP(scan) == CLOSE) {
5383             if (stopparen == (I32)ARG(scan)) {
5384                 break;
5385             }
5386             if ((I32)ARG(scan) == is_par) {
5387                 next = regnext(scan);
5388
5389                 if ( next && (OP(next) != WHILEM) && next < last)
5390                     is_par = 0;         /* Disable optimization */
5391             }
5392             if (data)
5393                 *(data->last_closep) = ARG(scan);
5394         }
5395         else if (OP(scan) == EVAL) {
5396                 if (data)
5397                     data->flags |= SF_HAS_EVAL;
5398         }
5399         else if ( PL_regkind[OP(scan)] == ENDLIKE ) {
5400             if (flags & SCF_DO_SUBSTR) {
5401                 scan_commit(pRExC_state, data, minlenp, is_inf);
5402                 flags &= ~SCF_DO_SUBSTR;
5403             }
5404             if (data && OP(scan)==ACCEPT) {
5405                 data->flags |= SCF_SEEN_ACCEPT;
5406                 if (stopmin > min)
5407                     stopmin = min;
5408             }
5409         }
5410         else if (OP(scan) == LOGICAL && scan->flags == 2) /* Embedded follows */
5411         {
5412                 if (flags & SCF_DO_SUBSTR) {
5413                     scan_commit(pRExC_state, data, minlenp, is_inf);
5414                     data->longest = &(data->longest_float);
5415                 }
5416                 is_inf = is_inf_internal = 1;
5417                 if (flags & SCF_DO_STCLASS_OR) /* Allow everything */
5418                     ssc_anything(data->start_class);
5419                 flags &= ~SCF_DO_STCLASS;
5420         }
5421         else if (OP(scan) == GPOS) {
5422             if (!(RExC_rx->intflags & PREGf_GPOS_FLOAT) &&
5423                 !(delta || is_inf || (data && data->pos_delta)))
5424             {
5425                 if (!(RExC_rx->intflags & PREGf_ANCH) && (flags & SCF_DO_SUBSTR))
5426                     RExC_rx->intflags |= PREGf_ANCH_GPOS;
5427                 if (RExC_rx->gofs < (STRLEN)min)
5428                     RExC_rx->gofs = min;
5429             } else {
5430                 RExC_rx->intflags |= PREGf_GPOS_FLOAT;
5431                 RExC_rx->gofs = 0;
5432             }
5433         }
5434 #ifdef TRIE_STUDY_OPT
5435 #ifdef FULL_TRIE_STUDY
5436         else if (PL_regkind[OP(scan)] == TRIE) {
5437             /* NOTE - There is similar code to this block above for handling
5438                BRANCH nodes on the initial study.  If you change stuff here
5439                check there too. */
5440             regnode *trie_node= scan;
5441             regnode *tail= regnext(scan);
5442             reg_trie_data *trie = (reg_trie_data*)RExC_rxi->data->data[ ARG(scan) ];
5443             SSize_t max1 = 0, min1 = SSize_t_MAX;
5444             regnode_ssc accum;
5445
5446             if (flags & SCF_DO_SUBSTR) { /* XXXX Add !SUSPEND? */
5447                 /* Cannot merge strings after this. */
5448                 scan_commit(pRExC_state, data, minlenp, is_inf);
5449             }
5450             if (flags & SCF_DO_STCLASS)
5451                 ssc_init_zero(pRExC_state, &accum);
5452
5453             if (!trie->jump) {
5454                 min1= trie->minlen;
5455                 max1= trie->maxlen;
5456             } else {
5457                 const regnode *nextbranch= NULL;
5458                 U32 word;
5459
5460                 for ( word=1 ; word <= trie->wordcount ; word++)
5461                 {
5462                     SSize_t deltanext=0, minnext=0, f = 0, fake;
5463                     regnode_ssc this_class;
5464
5465                     StructCopy(&zero_scan_data, &data_fake, scan_data_t);
5466                     if (data) {
5467                         data_fake.whilem_c = data->whilem_c;
5468                         data_fake.last_closep = data->last_closep;
5469                     }
5470                     else
5471                         data_fake.last_closep = &fake;
5472                     data_fake.pos_delta = delta;
5473                     if (flags & SCF_DO_STCLASS) {
5474                         ssc_init(pRExC_state, &this_class);
5475                         data_fake.start_class = &this_class;
5476                         f = SCF_DO_STCLASS_AND;
5477                     }
5478                     if (flags & SCF_WHILEM_VISITED_POS)
5479                         f |= SCF_WHILEM_VISITED_POS;
5480
5481                     if (trie->jump[word]) {
5482                         if (!nextbranch)
5483                             nextbranch = trie_node + trie->jump[0];
5484                         scan= trie_node + trie->jump[word];
5485                         /* We go from the jump point to the branch that follows
5486                            it. Note this means we need the vestigal unused
5487                            branches even though they arent otherwise used. */
5488                         minnext = study_chunk(pRExC_state, &scan, minlenp,
5489                             &deltanext, (regnode *)nextbranch, &data_fake,
5490                             stopparen, recursed_depth, NULL, f,depth+1);
5491                     }
5492                     if (nextbranch && PL_regkind[OP(nextbranch)]==BRANCH)
5493                         nextbranch= regnext((regnode*)nextbranch);
5494
5495                     if (min1 > (SSize_t)(minnext + trie->minlen))
5496                         min1 = minnext + trie->minlen;
5497                     if (deltanext == SSize_t_MAX) {
5498                         is_inf = is_inf_internal = 1;
5499                         max1 = SSize_t_MAX;
5500                     } else if (max1 < (SSize_t)(minnext + deltanext + trie->maxlen))
5501                         max1 = minnext + deltanext + trie->maxlen;
5502
5503                     if (data_fake.flags & (SF_HAS_PAR|SF_IN_PAR))
5504                         pars++;
5505                     if (data_fake.flags & SCF_SEEN_ACCEPT) {
5506                         if ( stopmin > min + min1)
5507                             stopmin = min + min1;
5508                         flags &= ~SCF_DO_SUBSTR;
5509                         if (data)
5510                             data->flags |= SCF_SEEN_ACCEPT;
5511                     }
5512                     if (data) {
5513                         if (data_fake.flags & SF_HAS_EVAL)
5514                             data->flags |= SF_HAS_EVAL;
5515                         data->whilem_c = data_fake.whilem_c;
5516                     }
5517                     if (flags & SCF_DO_STCLASS)
5518                         ssc_or(pRExC_state, &accum, (regnode_charclass *) &this_class);
5519                 }
5520             }
5521             if (flags & SCF_DO_SUBSTR) {
5522                 data->pos_min += min1;
5523                 data->pos_delta += max1 - min1;
5524                 if (max1 != min1 || is_inf)
5525                     data->longest = &(data->longest_float);
5526             }
5527             min += min1;
5528             if (delta != SSize_t_MAX)
5529                 delta += max1 - min1;
5530             if (flags & SCF_DO_STCLASS_OR) {
5531                 ssc_or(pRExC_state, data->start_class, (regnode_charclass *) &accum);
5532                 if (min1) {
5533                     ssc_and(pRExC_state, data->start_class, (regnode_charclass *) and_withp);
5534                     flags &= ~SCF_DO_STCLASS;
5535                 }
5536             }
5537             else if (flags & SCF_DO_STCLASS_AND) {
5538                 if (min1) {
5539                     ssc_and(pRExC_state, data->start_class, (regnode_charclass *) &accum);
5540                     flags &= ~SCF_DO_STCLASS;
5541                 }
5542                 else {
5543                     /* Switch to OR mode: cache the old value of
5544                      * data->start_class */
5545                     INIT_AND_WITHP;
5546                     StructCopy(data->start_class, and_withp, regnode_ssc);
5547                     flags &= ~SCF_DO_STCLASS_AND;
5548                     StructCopy(&accum, data->start_class, regnode_ssc);
5549                     flags |= SCF_DO_STCLASS_OR;
5550                 }
5551             }
5552             scan= tail;
5553             continue;
5554         }
5555 #else
5556         else if (PL_regkind[OP(scan)] == TRIE) {
5557             reg_trie_data *trie = (reg_trie_data*)RExC_rxi->data->data[ ARG(scan) ];
5558             U8*bang=NULL;
5559
5560             min += trie->minlen;
5561             delta += (trie->maxlen - trie->minlen);
5562             flags &= ~SCF_DO_STCLASS; /* xxx */
5563             if (flags & SCF_DO_SUBSTR) {
5564                 /* Cannot expect anything... */
5565                 scan_commit(pRExC_state, data, minlenp, is_inf);
5566                 data->pos_min += trie->minlen;
5567                 data->pos_delta += (trie->maxlen - trie->minlen);
5568                 if (trie->maxlen != trie->minlen)
5569                     data->longest = &(data->longest_float);
5570             }
5571             if (trie->jump) /* no more substrings -- for now /grr*/
5572                flags &= ~SCF_DO_SUBSTR;
5573         }
5574 #endif /* old or new */
5575 #endif /* TRIE_STUDY_OPT */
5576
5577         /* Else: zero-length, ignore. */
5578         scan = regnext(scan);
5579     }
5580     /* If we are exiting a recursion we can unset its recursed bit
5581      * and allow ourselves to enter it again - no danger of an
5582      * infinite loop there.
5583     if (stopparen > -1 && recursed) {
5584         DEBUG_STUDYDATA("unset:", data,depth);
5585         PAREN_UNSET( recursed, stopparen);
5586     }
5587     */
5588     if (frame) {
5589         depth = depth - 1;
5590
5591         DEBUG_STUDYDATA("frame-end:",data,depth);
5592         DEBUG_PEEP("fend", scan, depth);
5593
5594         /* restore previous context */
5595         last = frame->last_regnode;
5596         scan = frame->next_regnode;
5597         stopparen = frame->stopparen;
5598         recursed_depth = frame->prev_recursed_depth;
5599
5600         RExC_frame_last = frame->prev_frame;
5601         frame = frame->this_prev_frame;
5602         goto fake_study_recurse;
5603     }
5604
5605   finish:
5606     assert(!frame);
5607     DEBUG_STUDYDATA("pre-fin:",data,depth);
5608
5609     *scanp = scan;
5610     *deltap = is_inf_internal ? SSize_t_MAX : delta;
5611
5612     if (flags & SCF_DO_SUBSTR && is_inf)
5613         data->pos_delta = SSize_t_MAX - data->pos_min;
5614     if (is_par > (I32)U8_MAX)
5615         is_par = 0;
5616     if (is_par && pars==1 && data) {
5617         data->flags |= SF_IN_PAR;
5618         data->flags &= ~SF_HAS_PAR;
5619     }
5620     else if (pars && data) {
5621         data->flags |= SF_HAS_PAR;
5622         data->flags &= ~SF_IN_PAR;
5623     }
5624     if (flags & SCF_DO_STCLASS_OR)
5625         ssc_and(pRExC_state, data->start_class, (regnode_charclass *) and_withp);
5626     if (flags & SCF_TRIE_RESTUDY)
5627         data->flags |=  SCF_TRIE_RESTUDY;
5628
5629     DEBUG_STUDYDATA("post-fin:",data,depth);
5630
5631     {
5632         SSize_t final_minlen= min < stopmin ? min : stopmin;
5633
5634         if (!(RExC_seen & REG_UNBOUNDED_QUANTIFIER_SEEN)) {
5635             if (final_minlen > SSize_t_MAX - delta)
5636                 RExC_maxlen = SSize_t_MAX;
5637             else if (RExC_maxlen < final_minlen + delta)
5638                 RExC_maxlen = final_minlen + delta;
5639         }
5640         return final_minlen;
5641     }
5642     NOT_REACHED; /* NOTREACHED */
5643 }
5644
5645 STATIC U32
5646 S_add_data(RExC_state_t* const pRExC_state, const char* const s, const U32 n)
5647 {
5648     U32 count = RExC_rxi->data ? RExC_rxi->data->count : 0;
5649
5650     PERL_ARGS_ASSERT_ADD_DATA;
5651
5652     Renewc(RExC_rxi->data,
5653            sizeof(*RExC_rxi->data) + sizeof(void*) * (count + n - 1),
5654            char, struct reg_data);
5655     if(count)
5656         Renew(RExC_rxi->data->what, count + n, U8);
5657     else
5658         Newx(RExC_rxi->data->what, n, U8);
5659     RExC_rxi->data->count = count + n;
5660     Copy(s, RExC_rxi->data->what + count, n, U8);
5661     return count;
5662 }
5663
5664 /*XXX: todo make this not included in a non debugging perl, but appears to be
5665  * used anyway there, in 'use re' */
5666 #ifndef PERL_IN_XSUB_RE
5667 void
5668 Perl_reginitcolors(pTHX)
5669 {
5670     const char * const s = PerlEnv_getenv("PERL_RE_COLORS");
5671     if (s) {
5672         char *t = savepv(s);
5673         int i = 0;
5674         PL_colors[0] = t;
5675         while (++i < 6) {
5676             t = strchr(t, '\t');
5677             if (t) {
5678                 *t = '\0';
5679                 PL_colors[i] = ++t;
5680             }
5681             else
5682                 PL_colors[i] = t = (char *)"";
5683         }
5684     } else {
5685         int i = 0;
5686         while (i < 6)
5687             PL_colors[i++] = (char *)"";
5688     }
5689     PL_colorset = 1;
5690 }
5691 #endif
5692
5693
5694 #ifdef TRIE_STUDY_OPT
5695 #define CHECK_RESTUDY_GOTO_butfirst(dOsomething)            \
5696     STMT_START {                                            \
5697         if (                                                \
5698               (data.flags & SCF_TRIE_RESTUDY)               \
5699               && ! restudied++                              \
5700         ) {                                                 \
5701             dOsomething;                                    \
5702             goto reStudy;                                   \
5703         }                                                   \
5704     } STMT_END
5705 #else
5706 #define CHECK_RESTUDY_GOTO_butfirst
5707 #endif
5708
5709 /*
5710  * pregcomp - compile a regular expression into internal code
5711  *
5712  * Decides which engine's compiler to call based on the hint currently in
5713  * scope
5714  */
5715
5716 #ifndef PERL_IN_XSUB_RE
5717
5718 /* return the currently in-scope regex engine (or the default if none)  */
5719
5720 regexp_engine const *
5721 Perl_current_re_engine(pTHX)
5722 {
5723     if (IN_PERL_COMPILETIME) {
5724         HV * const table = GvHV(PL_hintgv);
5725         SV **ptr;
5726
5727         if (!table || !(PL_hints & HINT_LOCALIZE_HH))
5728             return &PL_core_reg_engine;
5729         ptr = hv_fetchs(table, "regcomp", FALSE);
5730         if ( !(ptr && SvIOK(*ptr) && SvIV(*ptr)))
5731             return &PL_core_reg_engine;
5732         return INT2PTR(regexp_engine*,SvIV(*ptr));
5733     }
5734     else {
5735         SV *ptr;
5736         if (!PL_curcop->cop_hints_hash)
5737             return &PL_core_reg_engine;
5738         ptr = cop_hints_fetch_pvs(PL_curcop, "regcomp", 0);
5739         if ( !(ptr && SvIOK(ptr) && SvIV(ptr)))
5740             return &PL_core_reg_engine;
5741         return INT2PTR(regexp_engine*,SvIV(ptr));
5742     }
5743 }
5744
5745
5746 REGEXP *
5747 Perl_pregcomp(pTHX_ SV * const pattern, const U32 flags)
5748 {
5749     regexp_engine const *eng = current_re_engine();
5750     GET_RE_DEBUG_FLAGS_DECL;
5751
5752     PERL_ARGS_ASSERT_PREGCOMP;
5753
5754     /* Dispatch a request to compile a regexp to correct regexp engine. */
5755     DEBUG_COMPILE_r({
5756         PerlIO_printf(Perl_debug_log, "Using engine %"UVxf"\n",
5757                         PTR2UV(eng));
5758     });
5759     return CALLREGCOMP_ENG(eng, pattern, flags);
5760 }
5761 #endif
5762
5763 /* public(ish) entry point for the perl core's own regex compiling code.
5764  * It's actually a wrapper for Perl_re_op_compile that only takes an SV
5765  * pattern rather than a list of OPs, and uses the internal engine rather
5766  * than the current one */
5767
5768 REGEXP *
5769 Perl_re_compile(pTHX_ SV * const pattern, U32 rx_flags)
5770 {
5771     SV *pat = pattern; /* defeat constness! */
5772     PERL_ARGS_ASSERT_RE_COMPILE;
5773     return Perl_re_op_compile(aTHX_ &pat, 1, NULL,
5774 #ifdef PERL_IN_XSUB_RE
5775                                 &my_reg_engine,
5776 #else
5777                                 &PL_core_reg_engine,
5778 #endif
5779                                 NULL, NULL, rx_flags, 0);
5780 }
5781
5782
5783 /* upgrade pattern pat_p of length plen_p to UTF8, and if there are code
5784  * blocks, recalculate the indices. Update pat_p and plen_p in-place to
5785  * point to the realloced string and length.
5786  *
5787  * This is essentially a copy of Perl_bytes_to_utf8() with the code index
5788  * stuff added */
5789
5790 static void
5791 S_pat_upgrade_to_utf8(pTHX_ RExC_state_t * const pRExC_state,
5792                     char **pat_p, STRLEN *plen_p, int num_code_blocks)
5793 {
5794     U8 *const src = (U8*)*pat_p;
5795     U8 *dst, *d;
5796     int n=0;
5797     STRLEN s = 0;
5798     bool do_end = 0;
5799     GET_RE_DEBUG_FLAGS_DECL;
5800
5801     DEBUG_PARSE_r(PerlIO_printf(Perl_debug_log,
5802         "UTF8 mismatch! Converting to utf8 for resizing and compile\n"));
5803
5804     Newx(dst, *plen_p * 2 + 1, U8);
5805     d = dst;
5806
5807     while (s < *plen_p) {
5808         append_utf8_from_native_byte(src[s], &d);
5809         if (n < num_code_blocks) {
5810             if (!do_end && pRExC_state->code_blocks[n].start == s) {
5811                 pRExC_state->code_blocks[n].start = d - dst - 1;
5812                 assert(*(d - 1) == '(');
5813                 do_end = 1;
5814             }
5815             else if (do_end && pRExC_state->code_blocks[n].end == s) {
5816                 pRExC_state->code_blocks[n].end = d - dst - 1;
5817                 assert(*(d - 1) == ')');
5818                 do_end = 0;
5819                 n++;
5820             }
5821         }
5822         s++;
5823     }
5824     *d = '\0';
5825     *plen_p = d - dst;
5826     *pat_p = (char*) dst;
5827     SAVEFREEPV(*pat_p);
5828     RExC_orig_utf8 = RExC_utf8 = 1;
5829 }
5830
5831
5832
5833 /* S_concat_pat(): concatenate a list of args to the pattern string pat,
5834  * while recording any code block indices, and handling overloading,
5835  * nested qr// objects etc.  If pat is null, it will allocate a new
5836  * string, or just return the first arg, if there's only one.
5837  *
5838  * Returns the malloced/updated pat.
5839  * patternp and pat_count is the array of SVs to be concatted;
5840  * oplist is the optional list of ops that generated the SVs;
5841  * recompile_p is a pointer to a boolean that will be set if
5842  *   the regex will need to be recompiled.
5843  * delim, if non-null is an SV that will be inserted between each element
5844  */
5845
5846 static SV*
5847 S_concat_pat(pTHX_ RExC_state_t * const pRExC_state,
5848                 SV *pat, SV ** const patternp, int pat_count,
5849                 OP *oplist, bool *recompile_p, SV *delim)
5850 {
5851     SV **svp;
5852     int n = 0;
5853     bool use_delim = FALSE;
5854     bool alloced = FALSE;
5855
5856     /* if we know we have at least two args, create an empty string,
5857      * then concatenate args to that. For no args, return an empty string */
5858     if (!pat && pat_count != 1) {
5859         pat = newSVpvs("");
5860         SAVEFREESV(pat);
5861         alloced = TRUE;
5862     }
5863
5864     for (svp = patternp; svp < patternp + pat_count; svp++) {
5865         SV *sv;
5866         SV *rx  = NULL;
5867         STRLEN orig_patlen = 0;
5868         bool code = 0;
5869         SV *msv = use_delim ? delim : *svp;
5870         if (!msv) msv = &PL_sv_undef;
5871
5872         /* if we've got a delimiter, we go round the loop twice for each
5873          * svp slot (except the last), using the delimiter the second
5874          * time round */
5875         if (use_delim) {
5876             svp--;
5877             use_delim = FALSE;
5878         }
5879         else if (delim)
5880             use_delim = TRUE;
5881
5882         if (SvTYPE(msv) == SVt_PVAV) {
5883             /* we've encountered an interpolated array within
5884              * the pattern, e.g. /...@a..../. Expand the list of elements,
5885              * then recursively append elements.
5886              * The code in this block is based on S_pushav() */
5887
5888             AV *const av = (AV*)msv;
5889             const SSize_t maxarg = AvFILL(av) + 1;
5890             SV **array;
5891
5892             if (oplist) {
5893                 assert(oplist->op_type == OP_PADAV
5894                     || oplist->op_type == OP_RV2AV);
5895                 oplist = OpSIBLING(oplist);
5896             }
5897
5898             if (SvRMAGICAL(av)) {
5899                 SSize_t i;
5900
5901                 Newx(array, maxarg, SV*);
5902                 SAVEFREEPV(array);
5903                 for (i=0; i < maxarg; i++) {
5904                     SV ** const svp = av_fetch(av, i, FALSE);
5905                     array[i] = svp ? *svp : &PL_sv_undef;
5906                 }
5907             }
5908             else
5909                 array = AvARRAY(av);
5910
5911             pat = S_concat_pat(aTHX_ pRExC_state, pat,
5912                                 array, maxarg, NULL, recompile_p,
5913                                 /* $" */
5914                                 GvSV((gv_fetchpvs("\"", GV_ADDMULTI, SVt_PV))));
5915
5916             continue;
5917         }
5918
5919
5920         /* we make the assumption here that each op in the list of
5921          * op_siblings maps to one SV pushed onto the stack,
5922          * except for code blocks, with have both an OP_NULL and
5923          * and OP_CONST.
5924          * This allows us to match up the list of SVs against the
5925          * list of OPs to find the next code block.
5926          *
5927          * Note that       PUSHMARK PADSV PADSV ..
5928          * is optimised to
5929          *                 PADRANGE PADSV  PADSV  ..
5930          * so the alignment still works. */
5931
5932         if (oplist) {
5933             if (oplist->op_type == OP_NULL
5934                 && (oplist->op_flags & OPf_SPECIAL))
5935             {
5936                 assert(n < pRExC_state->num_code_blocks);
5937                 pRExC_state->code_blocks[n].start = pat ? SvCUR(pat) : 0;
5938                 pRExC_state->code_blocks[n].block = oplist;
5939                 pRExC_state->code_blocks[n].src_regex = NULL;
5940                 n++;
5941                 code = 1;
5942                 oplist = OpSIBLING(oplist); /* skip CONST */
5943                 assert(oplist);
5944             }
5945             oplist = OpSIBLING(oplist);;
5946         }
5947
5948         /* apply magic and QR overloading to arg */
5949
5950         SvGETMAGIC(msv);
5951         if (SvROK(msv) && SvAMAGIC(msv)) {
5952             SV *sv = AMG_CALLunary(msv, regexp_amg);
5953             if (sv) {
5954                 if (SvROK(sv))
5955                     sv = SvRV(sv);
5956                 if (SvTYPE(sv) != SVt_REGEXP)
5957                     Perl_croak(aTHX_ "Overloaded qr did not return a REGEXP");
5958                 msv = sv;
5959             }
5960         }
5961
5962         /* try concatenation overload ... */
5963         if (pat && (SvAMAGIC(pat) || SvAMAGIC(msv)) &&
5964                 (sv = amagic_call(pat, msv, concat_amg, AMGf_assign)))
5965         {
5966             sv_setsv(pat, sv);
5967             /* overloading involved: all bets are off over literal
5968              * code. Pretend we haven't seen it */
5969             pRExC_state->num_code_blocks -= n;
5970             n = 0;
5971         }
5972         else  {
5973             /* ... or failing that, try "" overload */
5974             while (SvAMAGIC(msv)
5975                     && (sv = AMG_CALLunary(msv, string_amg))
5976                     && sv != msv
5977                     &&  !(   SvROK(msv)
5978                           && SvROK(sv)
5979                           && SvRV(msv) == SvRV(sv))
5980             ) {
5981                 msv = sv;
5982                 SvGETMAGIC(msv);
5983             }
5984             if (SvROK(msv) && SvTYPE(SvRV(msv)) == SVt_REGEXP)
5985                 msv = SvRV(msv);
5986
5987             if (pat) {
5988                 /* this is a partially unrolled
5989                  *     sv_catsv_nomg(pat, msv);
5990                  * that allows us to adjust code block indices if
5991                  * needed */
5992                 STRLEN dlen;
5993                 char *dst = SvPV_force_nomg(pat, dlen);
5994                 orig_patlen = dlen;
5995                 if (SvUTF8(msv) && !SvUTF8(pat)) {
5996                     S_pat_upgrade_to_utf8(aTHX_ pRExC_state, &dst, &dlen, n);
5997                     sv_setpvn(pat, dst, dlen);
5998                     SvUTF8_on(pat);
5999                 }
6000                 sv_catsv_nomg(pat, msv);
6001                 rx = msv;
6002             }
6003             else
6004                 pat = msv;
6005
6006             if (code)
6007                 pRExC_state->code_blocks[n-1].end = SvCUR(pat)-1;
6008         }
6009
6010         /* extract any code blocks within any embedded qr//'s */
6011         if (rx && SvTYPE(rx) == SVt_REGEXP
6012             && RX_ENGINE((REGEXP*)rx)->op_comp)
6013         {
6014
6015             RXi_GET_DECL(ReANY((REGEXP *)rx), ri);
6016             if (ri->num_code_blocks) {
6017                 int i;
6018                 /* the presence of an embedded qr// with code means
6019                  * we should always recompile: the text of the
6020                  * qr// may not have changed, but it may be a
6021                  * different closure than last time */
6022                 *recompile_p = 1;
6023                 Renew(pRExC_state->code_blocks,
6024                     pRExC_state->num_code_blocks + ri->num_code_blocks,
6025                     struct reg_code_block);
6026                 pRExC_state->num_code_blocks += ri->num_code_blocks;
6027
6028                 for (i=0; i < ri->num_code_blocks; i++) {
6029                     struct reg_code_block *src, *dst;
6030                     STRLEN offset =  orig_patlen
6031                         + ReANY((REGEXP *)rx)->pre_prefix;
6032                     assert(n < pRExC_state->num_code_blocks);
6033                     src = &ri->code_blocks[i];
6034                     dst = &pRExC_state->code_blocks[n];
6035                     dst->start      = src->start + offset;
6036                     dst->end        = src->end   + offset;
6037                     dst->block      = src->block;
6038                     dst->src_regex  = (REGEXP*) SvREFCNT_inc( (SV*)
6039                                             src->src_regex
6040                                                 ? src->src_regex
6041                                                 : (REGEXP*)rx);
6042                     n++;
6043                 }
6044             }
6045         }
6046     }
6047     /* avoid calling magic multiple times on a single element e.g. =~ $qr */
6048     if (alloced)
6049         SvSETMAGIC(pat);
6050
6051     return pat;
6052 }
6053
6054
6055
6056 /* see if there are any run-time code blocks in the pattern.
6057  * False positives are allowed */
6058
6059 static bool
6060 S_has_runtime_code(pTHX_ RExC_state_t * const pRExC_state,
6061                     char *pat, STRLEN plen)
6062 {
6063     int n = 0;
6064     STRLEN s;
6065     
6066     PERL_UNUSED_CONTEXT;
6067
6068     for (s = 0; s < plen; s++) {
6069         if (n < pRExC_state->num_code_blocks
6070             && s == pRExC_state->code_blocks[n].start)
6071         {
6072             s = pRExC_state->code_blocks[n].end;
6073             n++;
6074             continue;
6075         }
6076         /* TODO ideally should handle [..], (#..), /#.../x to reduce false
6077          * positives here */
6078         if (pat[s] == '(' && s+2 <= plen && pat[s+1] == '?' &&
6079             (pat[s+2] == '{'
6080                 || (s + 2 <= plen && pat[s+2] == '?' && pat[s+3] == '{'))
6081         )
6082             return 1;
6083     }
6084     return 0;
6085 }
6086
6087 /* Handle run-time code blocks. We will already have compiled any direct
6088  * or indirect literal code blocks. Now, take the pattern 'pat' and make a
6089  * copy of it, but with any literal code blocks blanked out and
6090  * appropriate chars escaped; then feed it into
6091  *
6092  *    eval "qr'modified_pattern'"
6093  *
6094  * For example,
6095  *
6096  *       a\bc(?{"this was literal"})def'ghi\\jkl(?{"this is runtime"})mno
6097  *
6098  * becomes
6099  *
6100  *    qr'a\\bc_______________________def\'ghi\\\\jkl(?{"this is runtime"})mno'
6101  *
6102  * After eval_sv()-ing that, grab any new code blocks from the returned qr
6103  * and merge them with any code blocks of the original regexp.
6104  *
6105  * If the pat is non-UTF8, while the evalled qr is UTF8, don't merge;
6106  * instead, just save the qr and return FALSE; this tells our caller that
6107  * the original pattern needs upgrading to utf8.
6108  */
6109
6110 static bool
6111 S_compile_runtime_code(pTHX_ RExC_state_t * const pRExC_state,
6112     char *pat, STRLEN plen)
6113 {
6114     SV *qr;
6115
6116     GET_RE_DEBUG_FLAGS_DECL;
6117
6118     if (pRExC_state->runtime_code_qr) {
6119         /* this is the second time we've been called; this should
6120          * only happen if the main pattern got upgraded to utf8
6121          * during compilation; re-use the qr we compiled first time
6122          * round (which should be utf8 too)
6123          */
6124         qr = pRExC_state->runtime_code_qr;
6125         pRExC_state->runtime_code_qr = NULL;
6126         assert(RExC_utf8 && SvUTF8(qr));
6127     }
6128     else {
6129         int n = 0;
6130         STRLEN s;
6131         char *p, *newpat;
6132         int newlen = plen + 6; /* allow for "qr''x\0" extra chars */
6133         SV *sv, *qr_ref;
6134         dSP;
6135
6136         /* determine how many extra chars we need for ' and \ escaping */
6137         for (s = 0; s < plen; s++) {
6138             if (pat[s] == '\'' || pat[s] == '\\')
6139                 newlen++;
6140         }
6141
6142         Newx(newpat, newlen, char);
6143         p = newpat;
6144         *p++ = 'q'; *p++ = 'r'; *p++ = '\'';
6145
6146         for (s = 0; s < plen; s++) {
6147             if (n < pRExC_state->num_code_blocks
6148                 && s == pRExC_state->code_blocks[n].start)
6149             {
6150                 /* blank out literal code block */
6151                 assert(pat[s] == '(');
6152                 while (s <= pRExC_state->code_blocks[n].end) {
6153                     *p++ = '_';
6154                     s++;
6155                 }
6156                 s--;
6157                 n++;
6158                 continue;
6159             }
6160             if (pat[s] == '\'' || pat[s] == '\\')
6161                 *p++ = '\\';
6162             *p++ = pat[s];
6163         }
6164         *p++ = '\'';
6165         if (pRExC_state->pm_flags & RXf_PMf_EXTENDED)
6166             *p++ = 'x';
6167         *p++ = '\0';
6168         DEBUG_COMPILE_r({
6169             PerlIO_printf(Perl_debug_log,
6170                 "%sre-parsing pattern for runtime code:%s %s\n",
6171                 PL_colors[4],PL_colors[5],newpat);
6172         });
6173
6174         sv = newSVpvn_flags(newpat, p-newpat-1, RExC_utf8 ? SVf_UTF8 : 0);
6175         Safefree(newpat);
6176
6177         ENTER;
6178         SAVETMPS;
6179         save_re_context();
6180         PUSHSTACKi(PERLSI_REQUIRE);
6181         /* G_RE_REPARSING causes the toker to collapse \\ into \ when
6182          * parsing qr''; normally only q'' does this. It also alters
6183          * hints handling */
6184         eval_sv(sv, G_SCALAR|G_RE_REPARSING);
6185         SvREFCNT_dec_NN(sv);
6186         SPAGAIN;
6187         qr_ref = POPs;
6188         PUTBACK;
6189         {
6190             SV * const errsv = ERRSV;
6191             if (SvTRUE_NN(errsv))
6192             {
6193                 Safefree(pRExC_state->code_blocks);
6194                 /* use croak_sv ? */
6195                 Perl_croak_nocontext("%"SVf, SVfARG(errsv));
6196             }
6197         }
6198         assert(SvROK(qr_ref));
6199         qr = SvRV(qr_ref);
6200         assert(SvTYPE(qr) == SVt_REGEXP && RX_ENGINE((REGEXP*)qr)->op_comp);
6201         /* the leaving below frees the tmp qr_ref.
6202          * Give qr a life of its own */
6203         SvREFCNT_inc(qr);
6204         POPSTACK;
6205         FREETMPS;
6206         LEAVE;
6207
6208     }
6209
6210     if (!RExC_utf8 && SvUTF8(qr)) {
6211         /* first time through; the pattern got upgraded; save the
6212          * qr for the next time through */
6213         assert(!pRExC_state->runtime_code_qr);
6214         pRExC_state->runtime_code_qr = qr;
6215         return 0;
6216     }
6217
6218
6219     /* extract any code blocks within the returned qr//  */
6220
6221
6222     /* merge the main (r1) and run-time (r2) code blocks into one */
6223     {
6224         RXi_GET_DECL(ReANY((REGEXP *)qr), r2);
6225         struct reg_code_block *new_block, *dst;
6226         RExC_state_t * const r1 = pRExC_state; /* convenient alias */
6227         int i1 = 0, i2 = 0;
6228
6229         if (!r2->num_code_blocks) /* we guessed wrong */
6230         {
6231             SvREFCNT_dec_NN(qr);
6232             return 1;
6233         }
6234
6235         Newx(new_block,
6236             r1->num_code_blocks + r2->num_code_blocks,
6237             struct reg_code_block);
6238         dst = new_block;
6239
6240         while (    i1 < r1->num_code_blocks
6241                 || i2 < r2->num_code_blocks)
6242         {
6243             struct reg_code_block *src;
6244             bool is_qr = 0;
6245
6246             if (i1 == r1->num_code_blocks) {
6247                 src = &r2->code_blocks[i2++];
6248                 is_qr = 1;
6249             }
6250             else if (i2 == r2->num_code_blocks)
6251                 src = &r1->code_blocks[i1++];
6252             else if (  r1->code_blocks[i1].start
6253                      < r2->code_blocks[i2].start)
6254             {
6255                 src = &r1->code_blocks[i1++];
6256                 assert(src->end < r2->code_blocks[i2].start);
6257             }
6258             else {
6259                 assert(  r1->code_blocks[i1].start
6260                        > r2->code_blocks[i2].start);
6261                 src = &r2->code_blocks[i2++];
6262                 is_qr = 1;
6263                 assert(src->end < r1->code_blocks[i1].start);
6264             }
6265
6266             assert(pat[src->start] == '(');
6267             assert(pat[src->end]   == ')');
6268             dst->start      = src->start;
6269             dst->end        = src->end;
6270             dst->block      = src->block;
6271             dst->src_regex  = is_qr ? (REGEXP*) SvREFCNT_inc( (SV*) qr)
6272                                     : src->src_regex;
6273             dst++;
6274         }
6275         r1->num_code_blocks += r2->num_code_blocks;
6276         Safefree(r1->code_blocks);
6277         r1->code_blocks = new_block;
6278     }
6279
6280     SvREFCNT_dec_NN(qr);
6281     return 1;
6282 }
6283
6284
6285 STATIC bool
6286 S_setup_longest(pTHX_ RExC_state_t *pRExC_state, SV* sv_longest,
6287                       SV** rx_utf8, SV** rx_substr, SSize_t* rx_end_shift,
6288                       SSize_t lookbehind, SSize_t offset, SSize_t *minlen,
6289                       STRLEN longest_length, bool eol, bool meol)
6290 {
6291     /* This is the common code for setting up the floating and fixed length
6292      * string data extracted from Perl_re_op_compile() below.  Returns a boolean
6293      * as to whether succeeded or not */
6294
6295     I32 t;
6296     SSize_t ml;
6297
6298     if (! (longest_length
6299            || (eol /* Can't have SEOL and MULTI */
6300                && (! meol || (RExC_flags & RXf_PMf_MULTILINE)))
6301           )
6302             /* See comments for join_exact for why REG_UNFOLDED_MULTI_SEEN */
6303         || (RExC_seen & REG_UNFOLDED_MULTI_SEEN))
6304     {
6305         return FALSE;
6306     }
6307
6308     /* copy the information about the longest from the reg_scan_data
6309         over to the program. */
6310     if (SvUTF8(sv_longest)) {
6311         *rx_utf8 = sv_longest;
6312         *rx_substr = NULL;
6313     } else {
6314         *rx_substr = sv_longest;
6315         *rx_utf8 = NULL;
6316     }
6317     /* end_shift is how many chars that must be matched that
6318         follow this item. We calculate it ahead of time as once the
6319         lookbehind offset is added in we lose the ability to correctly
6320         calculate it.*/
6321     ml = minlen ? *(minlen) : (SSize_t)longest_length;
6322     *rx_end_shift = ml - offset
6323         - longest_length + (SvTAIL(sv_longest) != 0)
6324         + lookbehind;
6325
6326     t = (eol/* Can't have SEOL and MULTI */
6327          && (! meol || (RExC_flags & RXf_PMf_MULTILINE)));
6328     fbm_compile(sv_longest, t ? FBMcf_TAIL : 0);
6329
6330     return TRUE;
6331 }
6332
6333 /*
6334  * Perl_re_op_compile - the perl internal RE engine's function to compile a
6335  * regular expression into internal code.
6336  * The pattern may be passed either as:
6337  *    a list of SVs (patternp plus pat_count)
6338  *    a list of OPs (expr)
6339  * If both are passed, the SV list is used, but the OP list indicates
6340  * which SVs are actually pre-compiled code blocks
6341  *
6342  * The SVs in the list have magic and qr overloading applied to them (and
6343  * the list may be modified in-place with replacement SVs in the latter
6344  * case).
6345  *
6346  * If the pattern hasn't changed from old_re, then old_re will be
6347  * returned.
6348  *
6349  * eng is the current engine. If that engine has an op_comp method, then
6350  * handle directly (i.e. we assume that op_comp was us); otherwise, just
6351  * do the initial concatenation of arguments and pass on to the external
6352  * engine.
6353  *
6354  * If is_bare_re is not null, set it to a boolean indicating whether the
6355  * arg list reduced (after overloading) to a single bare regex which has
6356  * been returned (i.e. /$qr/).
6357  *
6358  * orig_rx_flags contains RXf_* flags. See perlreapi.pod for more details.
6359  *
6360  * pm_flags contains the PMf_* flags, typically based on those from the
6361  * pm_flags field of the related PMOP. Currently we're only interested in
6362  * PMf_HAS_CV, PMf_IS_QR, PMf_USE_RE_EVAL.
6363  *
6364  * We can't allocate space until we know how big the compiled form will be,
6365  * but we can't compile it (and thus know how big it is) until we've got a
6366  * place to put the code.  So we cheat:  we compile it twice, once with code
6367  * generation turned off and size counting turned on, and once "for real".
6368  * This also means that we don't allocate space until we are sure that the
6369  * thing really will compile successfully, and we never have to move the
6370  * code and thus invalidate pointers into it.  (Note that it has to be in
6371  * one piece because free() must be able to free it all.) [NB: not true in perl]
6372  *
6373  * Beware that the optimization-preparation code in here knows about some
6374  * of the structure of the compiled regexp.  [I'll say.]
6375  */
6376
6377 REGEXP *
6378 Perl_re_op_compile(pTHX_ SV ** const patternp, int pat_count,
6379                     OP *expr, const regexp_engine* eng, REGEXP *old_re,
6380                      bool *is_bare_re, U32 orig_rx_flags, U32 pm_flags)
6381 {
6382     REGEXP *rx;
6383     struct regexp *r;
6384     regexp_internal *ri;
6385     STRLEN plen;
6386     char *exp;
6387     regnode *scan;
6388     I32 flags;
6389     SSize_t minlen = 0;
6390     U32 rx_flags;
6391     SV *pat;
6392     SV *code_blocksv = NULL;
6393     SV** new_patternp = patternp;
6394
6395     /* these are all flags - maybe they should be turned
6396      * into a single int with different bit masks */
6397     I32 sawlookahead = 0;
6398     I32 sawplus = 0;
6399     I32 sawopen = 0;
6400     I32 sawminmod = 0;
6401
6402     regex_charset initial_charset = get_regex_charset(orig_rx_flags);
6403     bool recompile = 0;
6404     bool runtime_code = 0;
6405     scan_data_t data;
6406     RExC_state_t RExC_state;
6407     RExC_state_t * const pRExC_state = &RExC_state;
6408 #ifdef TRIE_STUDY_OPT
6409     int restudied = 0;
6410     RExC_state_t copyRExC_state;
6411 #endif
6412     GET_RE_DEBUG_FLAGS_DECL;
6413
6414     PERL_ARGS_ASSERT_RE_OP_COMPILE;
6415
6416     DEBUG_r(if (!PL_colorset) reginitcolors());
6417
6418     /* Initialize these here instead of as-needed, as is quick and avoids
6419      * having to test them each time otherwise */
6420     if (! PL_AboveLatin1) {
6421         PL_AboveLatin1 = _new_invlist_C_array(AboveLatin1_invlist);
6422         PL_Latin1 = _new_invlist_C_array(Latin1_invlist);
6423         PL_UpperLatin1 = _new_invlist_C_array(UpperLatin1_invlist);
6424         PL_utf8_foldable = _new_invlist_C_array(_Perl_Any_Folds_invlist);
6425         PL_HasMultiCharFold =
6426                        _new_invlist_C_array(_Perl_Folds_To_Multi_Char_invlist);
6427
6428         /* This is calculated here, because the Perl program that generates the
6429          * static global ones doesn't currently have access to
6430          * NUM_ANYOF_CODE_POINTS */
6431         PL_InBitmap = _new_invlist(2);
6432         PL_InBitmap = _add_range_to_invlist(PL_InBitmap, 0,
6433                                                     NUM_ANYOF_CODE_POINTS - 1);
6434     }
6435
6436     pRExC_state->code_blocks = NULL;
6437     pRExC_state->num_code_blocks = 0;
6438
6439     if (is_bare_re)
6440         *is_bare_re = FALSE;
6441
6442     if (expr && (expr->op_type == OP_LIST ||
6443                 (expr->op_type == OP_NULL && expr->op_targ == OP_LIST))) {
6444         /* allocate code_blocks if needed */
6445         OP *o;
6446         int ncode = 0;
6447
6448         for (o = cLISTOPx(expr)->op_first; o; o = OpSIBLING(o))
6449             if (o->op_type == OP_NULL && (o->op_flags & OPf_SPECIAL))
6450                 ncode++; /* count of DO blocks */
6451         if (ncode) {
6452             pRExC_state->num_code_blocks = ncode;
6453             Newx(pRExC_state->code_blocks, ncode, struct reg_code_block);
6454         }
6455     }
6456
6457     if (!pat_count) {
6458         /* compile-time pattern with just OP_CONSTs and DO blocks */
6459
6460         int n;
6461         OP *o;
6462
6463         /* find how many CONSTs there are */
6464         assert(expr);
6465         n = 0;
6466         if (expr->op_type == OP_CONST)
6467             n = 1;
6468         else
6469             for (o = cLISTOPx(expr)->op_first; o; o = OpSIBLING(o)) {
6470                 if (o->op_type == OP_CONST)
6471                     n++;
6472             }
6473
6474         /* fake up an SV array */
6475
6476         assert(!new_patternp);
6477         Newx(new_patternp, n, SV*);
6478         SAVEFREEPV(new_patternp);
6479         pat_count = n;
6480
6481         n = 0;
6482         if (expr->op_type == OP_CONST)
6483             new_patternp[n] = cSVOPx_sv(expr);
6484         else
6485             for (o = cLISTOPx(expr)->op_first; o; o = OpSIBLING(o)) {
6486                 if (o->op_type == OP_CONST)
6487                     new_patternp[n++] = cSVOPo_sv;
6488             }
6489
6490     }
6491
6492     DEBUG_PARSE_r(PerlIO_printf(Perl_debug_log,
6493         "Assembling pattern from %d elements%s\n", pat_count,
6494             orig_rx_flags & RXf_SPLIT ? " for split" : ""));
6495
6496     /* set expr to the first arg op */
6497
6498     if (pRExC_state->num_code_blocks
6499          && expr->op_type != OP_CONST)
6500     {
6501             expr = cLISTOPx(expr)->op_first;
6502             assert(   expr->op_type == OP_PUSHMARK
6503                    || (expr->op_type == OP_NULL && expr->op_targ == OP_PUSHMARK)
6504                    || expr->op_type == OP_PADRANGE);
6505             expr = OpSIBLING(expr);
6506     }
6507
6508     pat = S_concat_pat(aTHX_ pRExC_state, NULL, new_patternp, pat_count,
6509                         expr, &recompile, NULL);
6510
6511     /* handle bare (possibly after overloading) regex: foo =~ $re */
6512     {
6513         SV *re = pat;
6514         if (SvROK(re))
6515             re = SvRV(re);
6516         if (SvTYPE(re) == SVt_REGEXP) {
6517             if (is_bare_re)
6518                 *is_bare_re = TRUE;
6519             SvREFCNT_inc(re);
6520             Safefree(pRExC_state->code_blocks);
6521             DEBUG_PARSE_r(PerlIO_printf(Perl_debug_log,
6522                 "Precompiled pattern%s\n",
6523                     orig_rx_flags & RXf_SPLIT ? " for split" : ""));
6524
6525             return (REGEXP*)re;
6526         }
6527     }
6528
6529     exp = SvPV_nomg(pat, plen);
6530
6531     if (!eng->op_comp) {
6532         if ((SvUTF8(pat) && IN_BYTES)
6533                 || SvGMAGICAL(pat) || SvAMAGIC(pat))
6534         {
6535             /* make a temporary copy; either to convert to bytes,
6536              * or to avoid repeating get-magic / overloaded stringify */
6537             pat = newSVpvn_flags(exp, plen, SVs_TEMP |
6538                                         (IN_BYTES ? 0 : SvUTF8(pat)));
6539         }
6540         Safefree(pRExC_state->code_blocks);
6541         return CALLREGCOMP_ENG(eng, pat, orig_rx_flags);
6542     }
6543
6544     /* ignore the utf8ness if the pattern is 0 length */
6545     RExC_utf8 = RExC_orig_utf8 = (plen == 0 || IN_BYTES) ? 0 : SvUTF8(pat);
6546     RExC_uni_semantics = 0;
6547     RExC_contains_locale = 0;
6548     RExC_contains_i = 0;
6549     RExC_strict = cBOOL(pm_flags & RXf_PMf_STRICT);
6550     pRExC_state->runtime_code_qr = NULL;
6551     RExC_frame_head= NULL;
6552     RExC_frame_last= NULL;
6553     RExC_frame_count= 0;
6554
6555     DEBUG_r({
6556         RExC_mysv1= sv_newmortal();
6557         RExC_mysv2= sv_newmortal();
6558     });
6559     DEBUG_COMPILE_r({
6560             SV *dsv= sv_newmortal();
6561             RE_PV_QUOTED_DECL(s, RExC_utf8, dsv, exp, plen, 60);
6562             PerlIO_printf(Perl_debug_log, "%sCompiling REx%s %s\n",
6563                           PL_colors[4],PL_colors[5],s);
6564         });
6565
6566   redo_first_pass:
6567     /* we jump here if we upgrade the pattern to utf8 and have to
6568      * recompile */
6569
6570     if ((pm_flags & PMf_USE_RE_EVAL)
6571                 /* this second condition covers the non-regex literal case,
6572                  * i.e.  $foo =~ '(?{})'. */
6573                 || (IN_PERL_COMPILETIME && (PL_hints & HINT_RE_EVAL))
6574     )
6575         runtime_code = S_has_runtime_code(aTHX_ pRExC_state, exp, plen);
6576
6577     /* return old regex if pattern hasn't changed */
6578     /* XXX: note in the below we have to check the flags as well as the
6579      * pattern.
6580      *
6581      * Things get a touch tricky as we have to compare the utf8 flag
6582      * independently from the compile flags.  */
6583
6584     if (   old_re
6585         && !recompile
6586         && !!RX_UTF8(old_re) == !!RExC_utf8
6587         && ( RX_COMPFLAGS(old_re) == ( orig_rx_flags & RXf_PMf_FLAGCOPYMASK ) )
6588         && RX_PRECOMP(old_re)
6589         && RX_PRELEN(old_re) == plen
6590         && memEQ(RX_PRECOMP(old_re), exp, plen)
6591         && !runtime_code /* with runtime code, always recompile */ )
6592     {
6593         Safefree(pRExC_state->code_blocks);
6594         return old_re;
6595     }
6596
6597     rx_flags = orig_rx_flags;
6598
6599     if (rx_flags & PMf_FOLD) {
6600         RExC_contains_i = 1;
6601     }
6602     if (RExC_utf8 && initial_charset == REGEX_DEPENDS_CHARSET) {
6603
6604         /* Set to use unicode semantics if the pattern is in utf8 and has the
6605          * 'depends' charset specified, as it means unicode when utf8  */
6606         set_regex_charset(&rx_flags, REGEX_UNICODE_CHARSET);
6607     }
6608
6609     RExC_precomp = exp;
6610     RExC_flags = rx_flags;
6611     RExC_pm_flags = pm_flags;
6612
6613     if (runtime_code) {
6614         if (TAINTING_get && TAINT_get)
6615             Perl_croak(aTHX_ "Eval-group in insecure regular expression");
6616
6617         if (!S_compile_runtime_code(aTHX_ pRExC_state, exp, plen)) {
6618             /* whoops, we have a non-utf8 pattern, whilst run-time code
6619              * got compiled as utf8. Try again with a utf8 pattern */
6620             S_pat_upgrade_to_utf8(aTHX_ pRExC_state, &exp, &plen,
6621                                     pRExC_state->num_code_blocks);
6622             goto redo_first_pass;
6623         }
6624     }
6625     assert(!pRExC_state->runtime_code_qr);
6626
6627     RExC_sawback = 0;
6628
6629     RExC_seen = 0;
6630     RExC_maxlen = 0;
6631     RExC_in_lookbehind = 0;
6632     RExC_seen_zerolen = *exp == '^' ? -1 : 0;
6633     RExC_extralen = 0;
6634     RExC_override_recoding = 0;
6635 #ifdef EBCDIC
6636     RExC_recode_x_to_native = 0;
6637 #endif
6638     RExC_in_multi_char_class = 0;
6639
6640     /* First pass: determine size, legality. */
6641     RExC_parse = exp;
6642     RExC_start = exp;
6643     RExC_end = exp + plen;
6644     RExC_naughty = 0;
6645     RExC_npar = 1;
6646     RExC_nestroot = 0;
6647     RExC_size = 0L;
6648     RExC_emit = (regnode *) &RExC_emit_dummy;
6649     RExC_whilem_seen = 0;
6650     RExC_open_parens = NULL;
6651     RExC_close_parens = NULL;
6652     RExC_opend = NULL;
6653     RExC_paren_names = NULL;
6654 #ifdef DEBUGGING
6655     RExC_paren_name_list = NULL;
6656 #endif
6657     RExC_recurse = NULL;
6658     RExC_study_chunk_recursed = NULL;
6659     RExC_study_chunk_recursed_bytes= 0;
6660     RExC_recurse_count = 0;
6661     pRExC_state->code_index = 0;
6662
6663     DEBUG_PARSE_r(
6664         PerlIO_printf(Perl_debug_log, "Starting first pass (sizing)\n");
6665         RExC_lastnum=0;
6666         RExC_lastparse=NULL;
6667     );
6668     /* reg may croak on us, not giving us a chance to free
6669        pRExC_state->code_blocks.  We cannot SAVEFREEPV it now, as we may
6670        need it to survive as long as the regexp (qr/(?{})/).
6671        We must check that code_blocksv is not already set, because we may
6672        have jumped back to restart the sizing pass. */
6673     if (pRExC_state->code_blocks && !code_blocksv) {
6674         code_blocksv = newSV_type(SVt_PV);
6675         SAVEFREESV(code_blocksv);
6676         SvPV_set(code_blocksv, (char *)pRExC_state->code_blocks);
6677         SvLEN_set(code_blocksv, 1); /*sufficient to make sv_clear free it*/
6678     }
6679     if (reg(pRExC_state, 0, &flags,1) == NULL) {
6680         /* It's possible to write a regexp in ascii that represents Unicode
6681         codepoints outside of the byte range, such as via \x{100}. If we
6682         detect such a sequence we have to convert the entire pattern to utf8
6683         and then recompile, as our sizing calculation will have been based
6684         on 1 byte == 1 character, but we will need to use utf8 to encode
6685         at least some part of the pattern, and therefore must convert the whole
6686         thing.
6687         -- dmq */
6688         if (flags & RESTART_UTF8) {
6689             S_pat_upgrade_to_utf8(aTHX_ pRExC_state, &exp, &plen,
6690                                     pRExC_state->num_code_blocks);
6691             goto redo_first_pass;
6692         }
6693         Perl_croak(aTHX_ "panic: reg returned NULL to re_op_compile for sizing pass, flags=%#"UVxf"", (UV) flags);
6694     }
6695     if (code_blocksv)
6696         SvLEN_set(code_blocksv,0); /* no you can't have it, sv_clear */
6697
6698     DEBUG_PARSE_r({
6699         PerlIO_printf(Perl_debug_log,
6700             "Required size %"IVdf" nodes\n"
6701             "Starting second pass (creation)\n",
6702             (IV)RExC_size);
6703         RExC_lastnum=0;
6704         RExC_lastparse=NULL;
6705     });
6706
6707     /* The first pass could have found things that force Unicode semantics */
6708     if ((RExC_utf8 || RExC_uni_semantics)
6709          && get_regex_charset(rx_flags) == REGEX_DEPENDS_CHARSET)
6710     {
6711         set_regex_charset(&rx_flags, REGEX_UNICODE_CHARSET);
6712     }
6713
6714     /* Small enough for pointer-storage convention?
6715        If extralen==0, this means that we will not need long jumps. */
6716     if (RExC_size >= 0x10000L && RExC_extralen)
6717         RExC_size += RExC_extralen;
6718     else
6719         RExC_extralen = 0;
6720     if (RExC_whilem_seen > 15)
6721         RExC_whilem_seen = 15;
6722
6723     /* Allocate space and zero-initialize. Note, the two step process
6724        of zeroing when in debug mode, thus anything assigned has to
6725        happen after that */
6726     rx = (REGEXP*) newSV_type(SVt_REGEXP);
6727     r = ReANY(rx);
6728     Newxc(ri, sizeof(regexp_internal) + (unsigned)RExC_size * sizeof(regnode),
6729          char, regexp_internal);
6730     if ( r == NULL || ri == NULL )
6731         FAIL("Regexp out of space");
6732 #ifdef DEBUGGING
6733     /* avoid reading uninitialized memory in DEBUGGING code in study_chunk() */
6734     Zero(ri, sizeof(regexp_internal) + (unsigned)RExC_size * sizeof(regnode),
6735          char);
6736 #else
6737     /* bulk initialize base fields with 0. */
6738     Zero(ri, sizeof(regexp_internal), char);
6739 #endif
6740
6741     /* non-zero initialization begins here */
6742     RXi_SET( r, ri );
6743     r->engine= eng;
6744     r->extflags = rx_flags;
6745     RXp_COMPFLAGS(r) = orig_rx_flags & RXf_PMf_FLAGCOPYMASK;
6746
6747     if (pm_flags & PMf_IS_QR) {
6748         ri->code_blocks = pRExC_state->code_blocks;
6749         ri->num_code_blocks = pRExC_state->num_code_blocks;
6750     }
6751     else
6752     {
6753         int n;
6754         for (n = 0; n < pRExC_state->num_code_blocks; n++)
6755             if (pRExC_state->code_blocks[n].src_regex)
6756                 SAVEFREESV(pRExC_state->code_blocks[n].src_regex);
6757         SAVEFREEPV(pRExC_state->code_blocks);
6758     }
6759
6760     {
6761         bool has_p     = ((r->extflags & RXf_PMf_KEEPCOPY) == RXf_PMf_KEEPCOPY);
6762         bool has_charset = (get_regex_charset(r->extflags)
6763                                                     != REGEX_DEPENDS_CHARSET);
6764
6765         /* The caret is output if there are any defaults: if not all the STD
6766          * flags are set, or if no character set specifier is needed */
6767         bool has_default =
6768                     (((r->extflags & RXf_PMf_STD_PMMOD) != RXf_PMf_STD_PMMOD)
6769                     || ! has_charset);
6770         bool has_runon = ((RExC_seen & REG_RUN_ON_COMMENT_SEEN)
6771                                                    == REG_RUN_ON_COMMENT_SEEN);
6772         U16 reganch = (U16)((r->extflags & RXf_PMf_STD_PMMOD)
6773                             >> RXf_PMf_STD_PMMOD_SHIFT);
6774         const char *fptr = STD_PAT_MODS;        /*"msixn"*/
6775         char *p;
6776         /* Allocate for the worst case, which is all the std flags are turned
6777          * on.  If more precision is desired, we could do a population count of
6778          * the flags set.  This could be done with a small lookup table, or by
6779          * shifting, masking and adding, or even, when available, assembly
6780          * language for a machine-language population count.
6781          * We never output a minus, as all those are defaults, so are
6782          * covered by the caret */
6783         const STRLEN wraplen = plen + has_p + has_runon
6784             + has_default       /* If needs a caret */
6785
6786                 /* If needs a character set specifier */
6787             + ((has_charset) ? MAX_CHARSET_NAME_LENGTH : 0)
6788             + (sizeof(STD_PAT_MODS) - 1)
6789             + (sizeof("(?:)") - 1);
6790
6791         Newx(p, wraplen + 1, char); /* +1 for the ending NUL */
6792         r->xpv_len_u.xpvlenu_pv = p;
6793         if (RExC_utf8)
6794             SvFLAGS(rx) |= SVf_UTF8;
6795         *p++='('; *p++='?';
6796
6797         /* If a default, cover it using the caret */
6798         if (has_default) {
6799             *p++= DEFAULT_PAT_MOD;
6800         }
6801         if (has_charset) {
6802             STRLEN len;
6803             const char* const name = get_regex_charset_name(r->extflags, &len);
6804             Copy(name, p, len, char);
6805             p += len;
6806         }
6807         if (has_p)
6808             *p++ = KEEPCOPY_PAT_MOD; /*'p'*/
6809         {
6810             char ch;
6811             while((ch = *fptr++)) {
6812                 if(reganch & 1)
6813                     *p++ = ch;
6814                 reganch >>= 1;
6815             }
6816         }
6817
6818         *p++ = ':';
6819         Copy(RExC_precomp, p, plen, char);
6820         assert ((RX_WRAPPED(rx) - p) < 16);
6821         r->pre_prefix = p - RX_WRAPPED(rx);
6822         p += plen;
6823         if (has_runon)
6824             *p++ = '\n';
6825         *p++ = ')';
6826         *p = 0;
6827         SvCUR_set(rx, p - RX_WRAPPED(rx));
6828     }
6829
6830     r->intflags = 0;
6831     r->nparens = RExC_npar - 1; /* set early to validate backrefs */
6832
6833     /* setup various meta data about recursion, this all requires
6834      * RExC_npar to be correctly set, and a bit later on we clear it */
6835     if (RExC_seen & REG_RECURSE_SEEN) {
6836         Newxz(RExC_open_parens, RExC_npar,regnode *);
6837         SAVEFREEPV(RExC_open_parens);
6838         Newxz(RExC_close_parens,RExC_npar,regnode *);
6839         SAVEFREEPV(RExC_close_parens);
6840     }
6841     if (RExC_seen & (REG_RECURSE_SEEN | REG_GOSTART_SEEN)) {
6842         /* Note, RExC_npar is 1 + the number of parens in a pattern.
6843          * So its 1 if there are no parens. */
6844         RExC_study_chunk_recursed_bytes= (RExC_npar >> 3) +
6845                                          ((RExC_npar & 0x07) != 0);
6846         Newx(RExC_study_chunk_recursed,
6847              RExC_study_chunk_recursed_bytes * RExC_npar, U8);
6848         SAVEFREEPV(RExC_study_chunk_recursed);
6849     }
6850
6851     /* Useful during FAIL. */
6852 #ifdef RE_TRACK_PATTERN_OFFSETS
6853     Newxz(ri->u.offsets, 2*RExC_size+1, U32); /* MJD 20001228 */
6854     DEBUG_OFFSETS_r(PerlIO_printf(Perl_debug_log,
6855                           "%s %"UVuf" bytes for offset annotations.\n",
6856                           ri->u.offsets ? "Got" : "Couldn't get",
6857                           (UV)((2*RExC_size+1) * sizeof(U32))));
6858 #endif
6859     SetProgLen(ri,RExC_size);
6860     RExC_rx_sv = rx;
6861     RExC_rx = r;
6862     RExC_rxi = ri;
6863
6864     /* Second pass: emit code. */
6865     RExC_flags = rx_flags;      /* don't let top level (?i) bleed */
6866     RExC_pm_flags = pm_flags;
6867     RExC_parse = exp;
6868     RExC_end = exp + plen;
6869     RExC_naughty = 0;
6870     RExC_npar = 1;
6871     RExC_emit_start = ri->program;
6872     RExC_emit = ri->program;
6873     RExC_emit_bound = ri->program + RExC_size + 1;
6874     pRExC_state->code_index = 0;
6875
6876     *((char*) RExC_emit++) = (char) REG_MAGIC;
6877     if (reg(pRExC_state, 0, &flags,1) == NULL) {
6878         ReREFCNT_dec(rx);
6879         Perl_croak(aTHX_ "panic: reg returned NULL to re_op_compile for generation pass, flags=%#"UVxf"", (UV) flags);
6880     }
6881     /* XXXX To minimize changes to RE engine we always allocate
6882        3-units-long substrs field. */
6883     Newx(r->substrs, 1, struct reg_substr_data);
6884     if (RExC_recurse_count) {
6885         Newxz(RExC_recurse,RExC_recurse_count,regnode *);
6886         SAVEFREEPV(RExC_recurse);
6887     }
6888
6889   reStudy:
6890     r->minlen = minlen = sawlookahead = sawplus = sawopen = sawminmod = 0;
6891     DEBUG_r(
6892         RExC_study_chunk_recursed_count= 0;
6893     );
6894     Zero(r->substrs, 1, struct reg_substr_data);
6895     if (RExC_study_chunk_recursed) {
6896         Zero(RExC_study_chunk_recursed,
6897              RExC_study_chunk_recursed_bytes * RExC_npar, U8);
6898     }
6899
6900
6901 #ifdef TRIE_STUDY_OPT
6902     if (!restudied) {
6903         StructCopy(&zero_scan_data, &data, scan_data_t);
6904         copyRExC_state = RExC_state;
6905     } else {
6906         U32 seen=RExC_seen;
6907         DEBUG_OPTIMISE_r(PerlIO_printf(Perl_debug_log,"Restudying\n"));
6908
6909         RExC_state = copyRExC_state;
6910         if (seen & REG_TOP_LEVEL_BRANCHES_SEEN)
6911             RExC_seen |= REG_TOP_LEVEL_BRANCHES_SEEN;
6912         else
6913             RExC_seen &= ~REG_TOP_LEVEL_BRANCHES_SEEN;
6914         StructCopy(&zero_scan_data, &data, scan_data_t);
6915     }
6916 #else
6917     StructCopy(&zero_scan_data, &data, scan_data_t);
6918 #endif
6919
6920     /* Dig out information for optimizations. */
6921     r->extflags = RExC_flags; /* was pm_op */
6922     /*dmq: removed as part of de-PMOP: pm->op_pmflags = RExC_flags; */
6923
6924     if (UTF)
6925         SvUTF8_on(rx);  /* Unicode in it? */
6926     ri->regstclass = NULL;
6927     if (RExC_naughty >= TOO_NAUGHTY)    /* Probably an expensive pattern. */
6928         r->intflags |= PREGf_NAUGHTY;
6929     scan = ri->program + 1;             /* First BRANCH. */
6930
6931     /* testing for BRANCH here tells us whether there is "must appear"
6932        data in the pattern. If there is then we can use it for optimisations */
6933     if (!(RExC_seen & REG_TOP_LEVEL_BRANCHES_SEEN)) { /*  Only one top-level choice.
6934                                                   */
6935         SSize_t fake;
6936         STRLEN longest_float_length, longest_fixed_length;
6937         regnode_ssc ch_class; /* pointed to by data */
6938         int stclass_flag;
6939         SSize_t last_close = 0; /* pointed to by data */
6940         regnode *first= scan;
6941         regnode *first_next= regnext(first);
6942         /*
6943          * Skip introductions and multiplicators >= 1
6944          * so that we can extract the 'meat' of the pattern that must
6945          * match in the large if() sequence following.
6946          * NOTE that EXACT is NOT covered here, as it is normally
6947          * picked up by the optimiser separately.
6948          *
6949          * This is unfortunate as the optimiser isnt handling lookahead
6950          * properly currently.
6951          *
6952          */
6953         while ((OP(first) == OPEN && (sawopen = 1)) ||
6954                /* An OR of *one* alternative - should not happen now. */
6955             (OP(first) == BRANCH && OP(first_next) != BRANCH) ||
6956             /* for now we can't handle lookbehind IFMATCH*/
6957             (OP(first) == IFMATCH && !first->flags && (sawlookahead = 1)) ||
6958             (OP(first) == PLUS) ||
6959             (OP(first) == MINMOD) ||
6960                /* An {n,m} with n>0 */
6961             (PL_regkind[OP(first)] == CURLY && ARG1(first) > 0) ||
6962             (OP(first) == NOTHING && PL_regkind[OP(first_next)] != END ))
6963         {
6964                 /*
6965                  * the only op that could be a regnode is PLUS, all the rest
6966                  * will be regnode_1 or regnode_2.
6967                  *
6968                  * (yves doesn't think this is true)
6969                  */
6970                 if (OP(first) == PLUS)
6971                     sawplus = 1;
6972                 else {
6973                     if (OP(first) == MINMOD)
6974                         sawminmod = 1;
6975                     first += regarglen[OP(first)];
6976                 }
6977                 first = NEXTOPER(first);
6978                 first_next= regnext(first);
6979         }
6980
6981         /* Starting-point info. */
6982       again:
6983         DEBUG_PEEP("first:",first,0);
6984         /* Ignore EXACT as we deal with it later. */
6985         if (PL_regkind[OP(first)] == EXACT) {
6986             if (OP(first) == EXACT || OP(first) == EXACTL)
6987                 NOOP;   /* Empty, get anchored substr later. */
6988             else
6989                 ri->regstclass = first;
6990         }
6991 #ifdef TRIE_STCLASS
6992         else if (PL_regkind[OP(first)] == TRIE &&
6993                 ((reg_trie_data *)ri->data->data[ ARG(first) ])->minlen>0)
6994         {
6995             /* this can happen only on restudy */
6996             ri->regstclass = construct_ahocorasick_from_trie(pRExC_state, (regnode *)first, 0);
6997         }
6998 #endif
6999         else if (REGNODE_SIMPLE(OP(first)))
7000             ri->regstclass = first;
7001         else if (PL_regkind[OP(first)] == BOUND ||
7002                  PL_regkind[OP(first)] == NBOUND)
7003             ri->regstclass = first;
7004         else if (PL_regkind[OP(first)] == BOL) {
7005             r->intflags |= (OP(first) == MBOL
7006                            ? PREGf_ANCH_MBOL
7007                            : PREGf_ANCH_SBOL);
7008             first = NEXTOPER(first);
7009             goto again;
7010         }
7011         else if (OP(first) == GPOS) {
7012             r->intflags |= PREGf_ANCH_GPOS;
7013             first = NEXTOPER(first);
7014             goto again;
7015         }
7016         else if ((!sawopen || !RExC_sawback) &&
7017             !sawlookahead &&
7018             (OP(first) == STAR &&
7019             PL_regkind[OP(NEXTOPER(first))] == REG_ANY) &&
7020             !(r->intflags & PREGf_ANCH) && !pRExC_state->num_code_blocks)
7021         {
7022             /* turn .* into ^.* with an implied $*=1 */
7023             const int type =
7024                 (OP(NEXTOPER(first)) == REG_ANY)
7025                     ? PREGf_ANCH_MBOL
7026                     : PREGf_ANCH_SBOL;
7027             r->intflags |= (type | PREGf_IMPLICIT);
7028             first = NEXTOPER(first);
7029             goto again;
7030         }
7031         if (sawplus && !sawminmod && !sawlookahead
7032             && (!sawopen || !RExC_sawback)
7033             && !pRExC_state->num_code_blocks) /* May examine pos and $& */
7034             /* x+ must match at the 1st pos of run of x's */
7035             r->intflags |= PREGf_SKIP;
7036
7037         /* Scan is after the zeroth branch, first is atomic matcher. */
7038 #ifdef TRIE_STUDY_OPT
7039         DEBUG_PARSE_r(
7040             if (!restudied)
7041                 PerlIO_printf(Perl_debug_log, "first at %"IVdf"\n",
7042                               (IV)(first - scan + 1))
7043         );
7044 #else
7045         DEBUG_PARSE_r(
7046             PerlIO_printf(Perl_debug_log, "first at %"IVdf"\n",
7047                 (IV)(first - scan + 1))
7048         );
7049 #endif
7050
7051
7052         /*
7053         * If there's something expensive in the r.e., find the
7054         * longest literal string that must appear and make it the
7055         * regmust.  Resolve ties in favor of later strings, since
7056         * the regstart check works with the beginning of the r.e.
7057         * and avoiding duplication strengthens checking.  Not a
7058         * strong reason, but sufficient in the absence of others.
7059         * [Now we resolve ties in favor of the earlier string if
7060         * it happens that c_offset_min has been invalidated, since the
7061         * earlier string may buy us something the later one won't.]
7062         */
7063
7064         data.longest_fixed = newSVpvs("");
7065         data.longest_float = newSVpvs("");
7066         data.last_found = newSVpvs("");
7067         data.longest = &(data.longest_fixed);
7068         ENTER_with_name("study_chunk");
7069         SAVEFREESV(data.longest_fixed);
7070         SAVEFREESV(data.longest_float);
7071         SAVEFREESV(data.last_found);
7072         first = scan;
7073         if (!ri->regstclass) {
7074             ssc_init(pRExC_state, &ch_class);
7075             data.start_class = &ch_class;
7076             stclass_flag = SCF_DO_STCLASS_AND;
7077         } else                          /* XXXX Check for BOUND? */
7078             stclass_flag = 0;
7079         data.last_closep = &last_close;
7080
7081         DEBUG_RExC_seen();
7082         minlen = study_chunk(pRExC_state, &first, &minlen, &fake,
7083                              scan + RExC_size, /* Up to end */
7084             &data, -1, 0, NULL,
7085             SCF_DO_SUBSTR | SCF_WHILEM_VISITED_POS | stclass_flag
7086                           | (restudied ? SCF_TRIE_DOING_RESTUDY : 0),
7087             0);
7088
7089
7090         CHECK_RESTUDY_GOTO_butfirst(LEAVE_with_name("study_chunk"));
7091
7092
7093         if ( RExC_npar == 1 && data.longest == &(data.longest_fixed)
7094              && data.last_start_min == 0 && data.last_end > 0
7095              && !RExC_seen_zerolen
7096              && !(RExC_seen & REG_VERBARG_SEEN)
7097              && !(RExC_seen & REG_GPOS_SEEN)
7098         ){
7099             r->extflags |= RXf_CHECK_ALL;
7100         }
7101         scan_commit(pRExC_state, &data,&minlen,0);
7102
7103         longest_float_length = CHR_SVLEN(data.longest_float);
7104
7105         if (! ((SvCUR(data.longest_fixed)  /* ok to leave SvCUR */
7106                    && data.offset_fixed == data.offset_float_min
7107                    && SvCUR(data.longest_fixed) == SvCUR(data.longest_float)))
7108             && S_setup_longest (aTHX_ pRExC_state,
7109                                     data.longest_float,
7110                                     &(r->float_utf8),
7111                                     &(r->float_substr),
7112                                     &(r->float_end_shift),
7113                                     data.lookbehind_float,
7114                                     data.offset_float_min,
7115                                     data.minlen_float,
7116                                     longest_float_length,
7117                                     cBOOL(data.flags & SF_FL_BEFORE_EOL),
7118                                     cBOOL(data.flags & SF_FL_BEFORE_MEOL)))
7119         {
7120             r->float_min_offset = data.offset_float_min - data.lookbehind_float;
7121             r->float_max_offset = data.offset_float_max;
7122             if (data.offset_float_max < SSize_t_MAX) /* Don't offset infinity */
7123                 r->float_max_offset -= data.lookbehind_float;
7124             SvREFCNT_inc_simple_void_NN(data.longest_float);
7125         }
7126         else {
7127             r->float_substr = r->float_utf8 = NULL;
7128             longest_float_length = 0;
7129         }
7130
7131         longest_fixed_length = CHR_SVLEN(data.longest_fixed);
7132
7133         if (S_setup_longest (aTHX_ pRExC_state,
7134                                 data.longest_fixed,
7135                                 &(r->anchored_utf8),
7136                                 &(r->anchored_substr),
7137                                 &(r->anchored_end_shift),
7138                                 data.lookbehind_fixed,
7139                                 data.offset_fixed,
7140                                 data.minlen_fixed,
7141                                 longest_fixed_length,
7142                                 cBOOL(data.flags & SF_FIX_BEFORE_EOL),
7143                                 cBOOL(data.flags & SF_FIX_BEFORE_MEOL)))
7144         {
7145             r->anchored_offset = data.offset_fixed - data.lookbehind_fixed;
7146             SvREFCNT_inc_simple_void_NN(data.longest_fixed);
7147         }
7148         else {
7149             r->anchored_substr = r->anchored_utf8 = NULL;
7150             longest_fixed_length = 0;
7151         }
7152         LEAVE_with_name("study_chunk");
7153
7154         if (ri->regstclass
7155             && (OP(ri->regstclass) == REG_ANY || OP(ri->regstclass) == SANY))
7156             ri->regstclass = NULL;
7157
7158         if ((!(r->anchored_substr || r->anchored_utf8) || r->anchored_offset)
7159             && stclass_flag
7160             && ! (ANYOF_FLAGS(data.start_class) & SSC_MATCHES_EMPTY_STRING)
7161             && is_ssc_worth_it(pRExC_state, data.start_class))
7162         {
7163             const U32 n = add_data(pRExC_state, STR_WITH_LEN("f"));
7164
7165             ssc_finalize(pRExC_state, data.start_class);
7166
7167             Newx(RExC_rxi->data->data[n], 1, regnode_ssc);
7168             StructCopy(data.start_class,
7169                        (regnode_ssc*)RExC_rxi->data->data[n],
7170                        regnode_ssc);
7171             ri->regstclass = (regnode*)RExC_rxi->data->data[n];
7172             r->intflags &= ~PREGf_SKIP; /* Used in find_byclass(). */
7173             DEBUG_COMPILE_r({ SV *sv = sv_newmortal();
7174                       regprop(r, sv, (regnode*)data.start_class, NULL, pRExC_state);
7175                       PerlIO_printf(Perl_debug_log,
7176                                     "synthetic stclass \"%s\".\n",
7177                                     SvPVX_const(sv));});
7178             data.start_class = NULL;
7179         }
7180
7181         /* A temporary algorithm prefers floated substr to fixed one to dig
7182          * more info. */
7183         if (longest_fixed_length > longest_float_length) {
7184             r->substrs->check_ix = 0;
7185             r->check_end_shift = r->anchored_end_shift;
7186             r->check_substr = r->anchored_substr;
7187             r->check_utf8 = r->anchored_utf8;
7188             r->check_offset_min = r->check_offset_max = r->anchored_offset;
7189             if (r->intflags & (PREGf_ANCH_SBOL|PREGf_ANCH_GPOS))
7190                 r->intflags |= PREGf_NOSCAN;
7191         }
7192         else {
7193             r->substrs->check_ix = 1;
7194             r->check_end_shift = r->float_end_shift;
7195             r->check_substr = r->float_substr;
7196             r->check_utf8 = r->float_utf8;
7197             r->check_offset_min = r->float_min_offset;
7198             r->check_offset_max = r->float_max_offset;
7199         }
7200         if ((r->check_substr || r->check_utf8) ) {
7201             r->extflags |= RXf_USE_INTUIT;
7202             if (SvTAIL(r->check_substr ? r->check_substr : r->check_utf8))
7203                 r->extflags |= RXf_INTUIT_TAIL;
7204         }
7205         r->substrs->data[0].max_offset = r->substrs->data[0].min_offset;
7206
7207         /* XXX Unneeded? dmq (shouldn't as this is handled elsewhere)
7208         if ( (STRLEN)minlen < longest_float_length )
7209             minlen= longest_float_length;
7210         if ( (STRLEN)minlen < longest_fixed_length )
7211             minlen= longest_fixed_length;
7212         */
7213     }
7214     else {
7215         /* Several toplevels. Best we can is to set minlen. */
7216         SSize_t fake;
7217         regnode_ssc ch_class;
7218         SSize_t last_close = 0;
7219
7220         DEBUG_PARSE_r(PerlIO_printf(Perl_debug_log, "\nMulti Top Level\n"));
7221
7222         scan = ri->program + 1;
7223         ssc_init(pRExC_state, &ch_class);
7224         data.start_class = &ch_class;
7225         data.last_closep = &last_close;
7226
7227         DEBUG_RExC_seen();
7228         minlen = study_chunk(pRExC_state,
7229             &scan, &minlen, &fake, scan + RExC_size, &data, -1, 0, NULL,
7230             SCF_DO_STCLASS_AND|SCF_WHILEM_VISITED_POS|(restudied
7231                                                       ? SCF_TRIE_DOING_RESTUDY
7232                                                       : 0),
7233             0);
7234
7235         CHECK_RESTUDY_GOTO_butfirst(NOOP);
7236
7237         r->check_substr = r->check_utf8 = r->anchored_substr = r->anchored_utf8
7238                 = r->float_substr = r->float_utf8 = NULL;
7239
7240         if (! (ANYOF_FLAGS(data.start_class) & SSC_MATCHES_EMPTY_STRING)
7241             && is_ssc_worth_it(pRExC_state, data.start_class))
7242         {
7243             const U32 n = add_data(pRExC_state, STR_WITH_LEN("f"));
7244
7245             ssc_finalize(pRExC_state, data.start_class);
7246
7247             Newx(RExC_rxi->data->data[n], 1, regnode_ssc);
7248             StructCopy(data.start_class,
7249                        (regnode_ssc*)RExC_rxi->data->data[n],
7250                        regnode_ssc);
7251             ri->regstclass = (regnode*)RExC_rxi->data->data[n];
7252             r->intflags &= ~PREGf_SKIP; /* Used in find_byclass(). */
7253             DEBUG_COMPILE_r({ SV* sv = sv_newmortal();
7254                       regprop(r, sv, (regnode*)data.start_class, NULL, pRExC_state);
7255                       PerlIO_printf(Perl_debug_log,
7256                                     "synthetic stclass \"%s\".\n",
7257                                     SvPVX_const(sv));});
7258             data.start_class = NULL;
7259         }
7260     }
7261
7262     if (RExC_seen & REG_UNBOUNDED_QUANTIFIER_SEEN) {
7263         r->extflags |= RXf_UNBOUNDED_QUANTIFIER_SEEN;
7264         r->maxlen = REG_INFTY;
7265     }
7266     else {
7267         r->maxlen = RExC_maxlen;
7268     }
7269
7270     /* Guard against an embedded (?=) or (?<=) with a longer minlen than
7271        the "real" pattern. */
7272     DEBUG_OPTIMISE_r({
7273         PerlIO_printf(Perl_debug_log,"minlen: %"IVdf" r->minlen:%"IVdf" maxlen:%"IVdf"\n",
7274                       (IV)minlen, (IV)r->minlen, (IV)RExC_maxlen);
7275     });
7276     r->minlenret = minlen;
7277     if (r->minlen < minlen)
7278         r->minlen = minlen;
7279
7280     if (RExC_seen & REG_GPOS_SEEN)
7281         r->intflags |= PREGf_GPOS_SEEN;
7282     if (RExC_seen & REG_LOOKBEHIND_SEEN)
7283         r->extflags |= RXf_NO_INPLACE_SUBST; /* inplace might break the
7284                                                 lookbehind */
7285     if (pRExC_state->num_code_blocks)
7286         r->extflags |= RXf_EVAL_SEEN;
7287     if (RExC_seen & REG_VERBARG_SEEN)
7288     {
7289         r->intflags |= PREGf_VERBARG_SEEN;
7290         r->extflags |= RXf_NO_INPLACE_SUBST; /* don't understand this! Yves */
7291     }
7292     if (RExC_seen & REG_CUTGROUP_SEEN)
7293         r->intflags |= PREGf_CUTGROUP_SEEN;
7294     if (pm_flags & PMf_USE_RE_EVAL)
7295         r->intflags |= PREGf_USE_RE_EVAL;
7296     if (RExC_paren_names)
7297         RXp_PAREN_NAMES(r) = MUTABLE_HV(SvREFCNT_inc(RExC_paren_names));
7298     else
7299         RXp_PAREN_NAMES(r) = NULL;
7300
7301     /* If we have seen an anchor in our pattern then we set the extflag RXf_IS_ANCHORED
7302      * so it can be used in pp.c */
7303     if (r->intflags & PREGf_ANCH)
7304         r->extflags |= RXf_IS_ANCHORED;
7305
7306
7307     {
7308         /* this is used to identify "special" patterns that might result
7309          * in Perl NOT calling the regex engine and instead doing the match "itself",
7310          * particularly special cases in split//. By having the regex compiler
7311          * do this pattern matching at a regop level (instead of by inspecting the pattern)
7312          * we avoid weird issues with equivalent patterns resulting in different behavior,
7313          * AND we allow non Perl engines to get the same optimizations by the setting the
7314          * flags appropriately - Yves */
7315         regnode *first = ri->program + 1;
7316         U8 fop = OP(first);
7317         regnode *next = regnext(first);
7318         U8 nop = OP(next);
7319
7320         if (PL_regkind[fop] == NOTHING && nop == END)
7321             r->extflags |= RXf_NULL;
7322         else if ((fop == MBOL || (fop == SBOL && !first->flags)) && nop == END)
7323             /* when fop is SBOL first->flags will be true only when it was
7324              * produced by parsing /\A/, and not when parsing /^/. This is
7325              * very important for the split code as there we want to
7326              * treat /^/ as /^/m, but we do not want to treat /\A/ as /^/m.
7327              * See rt #122761 for more details. -- Yves */
7328             r->extflags |= RXf_START_ONLY;
7329         else if (fop == PLUS
7330                  && PL_regkind[nop] == POSIXD && FLAGS(next) == _CC_SPACE
7331                  && nop == END)
7332             r->extflags |= RXf_WHITE;
7333         else if ( r->extflags & RXf_SPLIT
7334                   && (fop == EXACT || fop == EXACTL)
7335                   && STR_LEN(first) == 1
7336                   && *(STRING(first)) == ' '
7337                   && nop == END )
7338             r->extflags |= (RXf_SKIPWHITE|RXf_WHITE);
7339
7340     }
7341
7342     if (RExC_contains_locale) {
7343         RXp_EXTFLAGS(r) |= RXf_TAINTED;
7344     }
7345
7346 #ifdef DEBUGGING
7347     if (RExC_paren_names) {
7348         ri->name_list_idx = add_data( pRExC_state, STR_WITH_LEN("a"));
7349         ri->data->data[ri->name_list_idx]
7350                                    = (void*)SvREFCNT_inc(RExC_paren_name_list);
7351     } else
7352 #endif
7353         ri->name_list_idx = 0;
7354
7355     if (RExC_recurse_count) {
7356         for ( ; RExC_recurse_count ; RExC_recurse_count-- ) {
7357             const regnode *scan = RExC_recurse[RExC_recurse_count-1];
7358             ARG2L_SET( scan, RExC_open_parens[ARG(scan)-1] - scan );
7359         }
7360     }
7361     Newxz(r->offs, RExC_npar, regexp_paren_pair);
7362     /* assume we don't need to swap parens around before we match */
7363     DEBUG_TEST_r({
7364         PerlIO_printf(Perl_debug_log,"study_chunk_recursed_count: %lu\n",
7365             (unsigned long)RExC_study_chunk_recursed_count);
7366     });
7367     DEBUG_DUMP_r({
7368         DEBUG_RExC_seen();
7369         PerlIO_printf(Perl_debug_log,"Final program:\n");
7370         regdump(r);
7371     });
7372 #ifdef RE_TRACK_PATTERN_OFFSETS
7373     DEBUG_OFFSETS_r(if (ri->u.offsets) {
7374         const STRLEN len = ri->u.offsets[0];
7375         STRLEN i;
7376         GET_RE_DEBUG_FLAGS_DECL;
7377         PerlIO_printf(Perl_debug_log,
7378                       "Offsets: [%"UVuf"]\n\t", (UV)ri->u.offsets[0]);
7379         for (i = 1; i <= len; i++) {
7380             if (ri->u.offsets[i*2-1] || ri->u.offsets[i*2])
7381                 PerlIO_printf(Perl_debug_log, "%"UVuf":%"UVuf"[%"UVuf"] ",
7382                 (UV)i, (UV)ri->u.offsets[i*2-1], (UV)ri->u.offsets[i*2]);
7383             }
7384         PerlIO_printf(Perl_debug_log, "\n");
7385     });
7386 #endif
7387
7388 #ifdef USE_ITHREADS
7389     /* under ithreads the ?pat? PMf_USED flag on the pmop is simulated
7390      * by setting the regexp SV to readonly-only instead. If the
7391      * pattern's been recompiled, the USEDness should remain. */
7392     if (old_re && SvREADONLY(old_re))
7393         SvREADONLY_on(rx);
7394 #endif
7395     return rx;
7396 }
7397
7398
7399 SV*
7400 Perl_reg_named_buff(pTHX_ REGEXP * const rx, SV * const key, SV * const value,
7401                     const U32 flags)
7402 {
7403     PERL_ARGS_ASSERT_REG_NAMED_BUFF;
7404
7405     PERL_UNUSED_ARG(value);
7406
7407     if (flags & RXapif_FETCH) {
7408         return reg_named_buff_fetch(rx, key, flags);
7409     } else if (flags & (RXapif_STORE | RXapif_DELETE | RXapif_CLEAR)) {
7410         Perl_croak_no_modify();
7411         return NULL;
7412     } else if (flags & RXapif_EXISTS) {
7413         return reg_named_buff_exists(rx, key, flags)
7414             ? &PL_sv_yes
7415             : &PL_sv_no;
7416     } else if (flags & RXapif_REGNAMES) {
7417         return reg_named_buff_all(rx, flags);
7418     } else if (flags & (RXapif_SCALAR | RXapif_REGNAMES_COUNT)) {
7419         return reg_named_buff_scalar(rx, flags);
7420     } else {
7421         Perl_croak(aTHX_ "panic: Unknown flags %d in named_buff", (int)flags);
7422         return NULL;
7423     }
7424 }
7425
7426 SV*
7427 Perl_reg_named_buff_iter(pTHX_ REGEXP * const rx, const SV * const lastkey,
7428                          const U32 flags)
7429 {
7430     PERL_ARGS_ASSERT_REG_NAMED_BUFF_ITER;
7431     PERL_UNUSED_ARG(lastkey);
7432
7433     if (flags & RXapif_FIRSTKEY)
7434         return reg_named_buff_firstkey(rx, flags);
7435     else if (flags & RXapif_NEXTKEY)
7436         return reg_named_buff_nextkey(rx, flags);
7437     else {
7438         Perl_croak(aTHX_ "panic: Unknown flags %d in named_buff_iter",
7439                                             (int)flags);
7440         return NULL;
7441     }
7442 }
7443
7444 SV*
7445 Perl_reg_named_buff_fetch(pTHX_ REGEXP * const r, SV * const namesv,
7446                           const U32 flags)
7447 {
7448     AV *retarray = NULL;
7449     SV *ret;
7450     struct regexp *const rx = ReANY(r);
7451
7452     PERL_ARGS_ASSERT_REG_NAMED_BUFF_FETCH;
7453
7454     if (flags & RXapif_ALL)
7455         retarray=newAV();
7456
7457     if (rx && RXp_PAREN_NAMES(rx)) {
7458         HE *he_str = hv_fetch_ent( RXp_PAREN_NAMES(rx), namesv, 0, 0 );
7459         if (he_str) {
7460             IV i;
7461             SV* sv_dat=HeVAL(he_str);
7462             I32 *nums=(I32*)SvPVX(sv_dat);
7463             for ( i=0; i<SvIVX(sv_dat); i++ ) {
7464                 if ((I32)(rx->nparens) >= nums[i]
7465                     && rx->offs[nums[i]].start != -1
7466                     && rx->offs[nums[i]].end != -1)
7467                 {
7468                     ret = newSVpvs("");
7469                     CALLREG_NUMBUF_FETCH(r,nums[i],ret);
7470                     if (!retarray)
7471                         return ret;
7472                 } else {
7473                     if (retarray)
7474                         ret = newSVsv(&PL_sv_undef);
7475                 }
7476                 if (retarray)
7477                     av_push(retarray, ret);
7478             }
7479             if (retarray)
7480                 return newRV_noinc(MUTABLE_SV(retarray));
7481         }
7482     }
7483     return NULL;
7484 }
7485
7486 bool
7487 Perl_reg_named_buff_exists(pTHX_ REGEXP * const r, SV * const key,
7488                            const U32 flags)
7489 {
7490     struct regexp *const rx = ReANY(r);
7491
7492     PERL_ARGS_ASSERT_REG_NAMED_BUFF_EXISTS;
7493
7494     if (rx && RXp_PAREN_NAMES(rx)) {
7495         if (flags & RXapif_ALL) {
7496             return hv_exists_ent(RXp_PAREN_NAMES(rx), key, 0);
7497         } else {
7498             SV *sv = CALLREG_NAMED_BUFF_FETCH(r, key, flags);
7499             if (sv) {
7500                 SvREFCNT_dec_NN(sv);
7501                 return TRUE;
7502             } else {
7503                 return FALSE;
7504             }
7505         }
7506     } else {
7507         return FALSE;
7508     }
7509 }
7510
7511 SV*
7512 Perl_reg_named_buff_firstkey(pTHX_ REGEXP * const r, const U32 flags)
7513 {
7514     struct regexp *const rx = ReANY(r);
7515
7516     PERL_ARGS_ASSERT_REG_NAMED_BUFF_FIRSTKEY;
7517
7518     if ( rx && RXp_PAREN_NAMES(rx) ) {
7519         (void)hv_iterinit(RXp_PAREN_NAMES(rx));
7520
7521         return CALLREG_NAMED_BUFF_NEXTKEY(r, NULL, flags & ~RXapif_FIRSTKEY);
7522     } else {
7523         return FALSE;
7524     }
7525 }
7526
7527 SV*
7528 Perl_reg_named_buff_nextkey(pTHX_ REGEXP * const r, const U32 flags)
7529 {
7530     struct regexp *const rx = ReANY(r);
7531     GET_RE_DEBUG_FLAGS_DECL;
7532
7533     PERL_ARGS_ASSERT_REG_NAMED_BUFF_NEXTKEY;
7534
7535     if (rx && RXp_PAREN_NAMES(rx)) {
7536         HV *hv = RXp_PAREN_NAMES(rx);
7537         HE *temphe;
7538         while ( (temphe = hv_iternext_flags(hv,0)) ) {
7539             IV i;
7540             IV parno = 0;
7541             SV* sv_dat = HeVAL(temphe);
7542             I32 *nums = (I32*)SvPVX(sv_dat);
7543             for ( i = 0; i < SvIVX(sv_dat); i++ ) {
7544                 if ((I32)(rx->lastparen) >= nums[i] &&
7545                     rx->offs[nums[i]].start != -1 &&
7546                     rx->offs[nums[i]].end != -1)
7547                 {
7548                     parno = nums[i];
7549                     break;
7550                 }
7551             }
7552             if (parno || flags & RXapif_ALL) {
7553                 return newSVhek(HeKEY_hek(temphe));
7554             }
7555         }
7556     }
7557     return NULL;
7558 }
7559
7560 SV*
7561 Perl_reg_named_buff_scalar(pTHX_ REGEXP * const r, const U32 flags)
7562 {
7563     SV *ret;
7564     AV *av;
7565     SSize_t length;
7566     struct regexp *const rx = ReANY(r);
7567
7568     PERL_ARGS_ASSERT_REG_NAMED_BUFF_SCALAR;
7569
7570     if (rx && RXp_PAREN_NAMES(rx)) {
7571         if (flags & (RXapif_ALL | RXapif_REGNAMES_COUNT)) {
7572             return newSViv(HvTOTALKEYS(RXp_PAREN_NAMES(rx)));
7573         } else if (flags & RXapif_ONE) {
7574             ret = CALLREG_NAMED_BUFF_ALL(r, (flags | RXapif_REGNAMES));
7575             av = MUTABLE_AV(SvRV(ret));
7576             length = av_tindex(av);
7577             SvREFCNT_dec_NN(ret);
7578             return newSViv(length + 1);
7579         } else {
7580             Perl_croak(aTHX_ "panic: Unknown flags %d in named_buff_scalar",
7581                                                 (int)flags);
7582             return NULL;
7583         }
7584     }
7585     return &PL_sv_undef;
7586 }
7587
7588 SV*
7589 Perl_reg_named_buff_all(pTHX_ REGEXP * const r, const U32 flags)
7590 {
7591     struct regexp *const rx = ReANY(r);
7592     AV *av = newAV();
7593
7594     PERL_ARGS_ASSERT_REG_NAMED_BUFF_ALL;
7595
7596     if (rx && RXp_PAREN_NAMES(rx)) {
7597         HV *hv= RXp_PAREN_NAMES(rx);
7598         HE *temphe;
7599         (void)hv_iterinit(hv);
7600         while ( (temphe = hv_iternext_flags(hv,0)) ) {
7601             IV i;
7602             IV parno = 0;
7603             SV* sv_dat = HeVAL(temphe);
7604             I32 *nums = (I32*)SvPVX(sv_dat);
7605             for ( i = 0; i < SvIVX(sv_dat); i++ ) {
7606                 if ((I32)(rx->lastparen) >= nums[i] &&
7607                     rx->offs[nums[i]].start != -1 &&
7608                     rx->offs[nums[i]].end != -1)
7609                 {
7610                     parno = nums[i];
7611                     break;
7612                 }
7613             }
7614             if (parno || flags & RXapif_ALL) {
7615                 av_push(av, newSVhek(HeKEY_hek(temphe)));
7616             }
7617         }
7618     }
7619
7620     return newRV_noinc(MUTABLE_SV(av));
7621 }
7622
7623 void
7624 Perl_reg_numbered_buff_fetch(pTHX_ REGEXP * const r, const I32 paren,
7625                              SV * const sv)
7626 {
7627     struct regexp *const rx = ReANY(r);
7628     char *s = NULL;
7629     SSize_t i = 0;
7630     SSize_t s1, t1;
7631     I32 n = paren;
7632
7633     PERL_ARGS_ASSERT_REG_NUMBERED_BUFF_FETCH;
7634
7635     if (      n == RX_BUFF_IDX_CARET_PREMATCH
7636            || n == RX_BUFF_IDX_CARET_FULLMATCH
7637            || n == RX_BUFF_IDX_CARET_POSTMATCH
7638        )
7639     {
7640         bool keepcopy = cBOOL(rx->extflags & RXf_PMf_KEEPCOPY);
7641         if (!keepcopy) {
7642             /* on something like
7643              *    $r = qr/.../;
7644              *    /$qr/p;
7645              * the KEEPCOPY is set on the PMOP rather than the regex */
7646             if (PL_curpm && r == PM_GETRE(PL_curpm))
7647                  keepcopy = cBOOL(PL_curpm->op_pmflags & PMf_KEEPCOPY);
7648         }
7649         if (!keepcopy)
7650             goto ret_undef;
7651     }
7652
7653     if (!rx->subbeg)
7654         goto ret_undef;
7655
7656     if (n == RX_BUFF_IDX_CARET_FULLMATCH)
7657         /* no need to distinguish between them any more */
7658         n = RX_BUFF_IDX_FULLMATCH;
7659
7660     if ((n == RX_BUFF_IDX_PREMATCH || n == RX_BUFF_IDX_CARET_PREMATCH)
7661         && rx->offs[0].start != -1)
7662     {
7663         /* $`, ${^PREMATCH} */
7664         i = rx->offs[0].start;
7665         s = rx->subbeg;
7666     }
7667     else
7668     if ((n == RX_BUFF_IDX_POSTMATCH || n == RX_BUFF_IDX_CARET_POSTMATCH)
7669         && rx->offs[0].end != -1)
7670     {
7671         /* $', ${^POSTMATCH} */
7672         s = rx->subbeg - rx->suboffset + rx->offs[0].end;
7673         i = rx->sublen + rx->suboffset - rx->offs[0].end;
7674     }
7675     else
7676     if ( 0 <= n && n <= (I32)rx->nparens &&
7677         (s1 = rx->offs[n].start) != -1 &&
7678         (t1 = rx->offs[n].end) != -1)
7679     {
7680         /* $&, ${^MATCH},  $1 ... */
7681         i = t1 - s1;
7682         s = rx->subbeg + s1 - rx->suboffset;
7683     } else {
7684         goto ret_undef;
7685     }
7686
7687     assert(s >= rx->subbeg);
7688     assert((STRLEN)rx->sublen >= (STRLEN)((s - rx->subbeg) + i) );
7689     if (i >= 0) {
7690 #ifdef NO_TAINT_SUPPORT
7691         sv_setpvn(sv, s, i);
7692 #else
7693         const int oldtainted = TAINT_get;
7694         TAINT_NOT;
7695         sv_setpvn(sv, s, i);
7696         TAINT_set(oldtainted);
7697 #endif
7698         if (RXp_MATCH_UTF8(rx))
7699             SvUTF8_on(sv);
7700         else
7701             SvUTF8_off(sv);
7702         if (TAINTING_get) {
7703             if (RXp_MATCH_TAINTED(rx)) {
7704                 if (SvTYPE(sv) >= SVt_PVMG) {
7705                     MAGIC* const mg = SvMAGIC(sv);
7706                     MAGIC* mgt;
7707                     TAINT;
7708                     SvMAGIC_set(sv, mg->mg_moremagic);
7709                     SvTAINT(sv);
7710                     if ((mgt = SvMAGIC(sv))) {
7711                         mg->mg_moremagic = mgt;
7712                         SvMAGIC_set(sv, mg);
7713                     }
7714                 } else {
7715                     TAINT;
7716                     SvTAINT(sv);
7717                 }
7718             } else
7719                 SvTAINTED_off(sv);
7720         }
7721     } else {
7722       ret_undef:
7723         sv_setsv(sv,&PL_sv_undef);
7724         return;
7725     }
7726 }
7727
7728 void
7729 Perl_reg_numbered_buff_store(pTHX_ REGEXP * const rx, const I32 paren,
7730                                                          SV const * const value)
7731 {
7732     PERL_ARGS_ASSERT_REG_NUMBERED_BUFF_STORE;
7733
7734     PERL_UNUSED_ARG(rx);
7735     PERL_UNUSED_ARG(paren);
7736     PERL_UNUSED_ARG(value);
7737
7738     if (!PL_localizing)
7739         Perl_croak_no_modify();
7740 }
7741
7742 I32
7743 Perl_reg_numbered_buff_length(pTHX_ REGEXP * const r, const SV * const sv,
7744                               const I32 paren)
7745 {
7746     struct regexp *const rx = ReANY(r);
7747     I32 i;
7748     I32 s1, t1;
7749
7750     PERL_ARGS_ASSERT_REG_NUMBERED_BUFF_LENGTH;
7751
7752     if (   paren == RX_BUFF_IDX_CARET_PREMATCH
7753         || paren == RX_BUFF_IDX_CARET_FULLMATCH
7754         || paren == RX_BUFF_IDX_CARET_POSTMATCH
7755     )
7756     {
7757         bool keepcopy = cBOOL(rx->extflags & RXf_PMf_KEEPCOPY);
7758         if (!keepcopy) {
7759             /* on something like
7760              *    $r = qr/.../;
7761              *    /$qr/p;
7762              * the KEEPCOPY is set on the PMOP rather than the regex */
7763             if (PL_curpm && r == PM_GETRE(PL_curpm))
7764                  keepcopy = cBOOL(PL_curpm->op_pmflags & PMf_KEEPCOPY);
7765         }
7766         if (!keepcopy)
7767             goto warn_undef;
7768     }
7769
7770     /* Some of this code was originally in C<Perl_magic_len> in F<mg.c> */
7771     switch (paren) {
7772       case RX_BUFF_IDX_CARET_PREMATCH: /* ${^PREMATCH} */
7773       case RX_BUFF_IDX_PREMATCH:       /* $` */
7774         if (rx->offs[0].start != -1) {
7775                         i = rx->offs[0].start;
7776                         if (i > 0) {
7777                                 s1 = 0;
7778                                 t1 = i;
7779                                 goto getlen;
7780                         }
7781             }
7782         return 0;
7783
7784       case RX_BUFF_IDX_CARET_POSTMATCH: /* ${^POSTMATCH} */
7785       case RX_BUFF_IDX_POSTMATCH:       /* $' */
7786             if (rx->offs[0].end != -1) {
7787                         i = rx->sublen - rx->offs[0].end;
7788                         if (i > 0) {
7789                                 s1 = rx->offs[0].end;
7790                                 t1 = rx->sublen;
7791                                 goto getlen;
7792                         }
7793             }
7794         return 0;
7795
7796       default: /* $& / ${^MATCH}, $1, $2, ... */
7797             if (paren <= (I32)rx->nparens &&
7798             (s1 = rx->offs[paren].start) != -1 &&
7799             (t1 = rx->offs[paren].end) != -1)
7800             {
7801             i = t1 - s1;
7802             goto getlen;
7803         } else {
7804           warn_undef:
7805             if (ckWARN(WARN_UNINITIALIZED))
7806                 report_uninit((const SV *)sv);
7807             return 0;
7808         }
7809     }
7810   getlen:
7811     if (i > 0 && RXp_MATCH_UTF8(rx)) {
7812         const char * const s = rx->subbeg - rx->suboffset + s1;
7813         const U8 *ep;
7814         STRLEN el;
7815
7816         i = t1 - s1;
7817         if (is_utf8_string_loclen((U8*)s, i, &ep, &el))
7818                         i = el;
7819     }
7820     return i;
7821 }
7822
7823 SV*
7824 Perl_reg_qr_package(pTHX_ REGEXP * const rx)
7825 {
7826     PERL_ARGS_ASSERT_REG_QR_PACKAGE;
7827         PERL_UNUSED_ARG(rx);
7828         if (0)
7829             return NULL;
7830         else
7831             return newSVpvs("Regexp");
7832 }
7833
7834 /* Scans the name of a named buffer from the pattern.
7835  * If flags is REG_RSN_RETURN_NULL returns null.
7836  * If flags is REG_RSN_RETURN_NAME returns an SV* containing the name
7837  * If flags is REG_RSN_RETURN_DATA returns the data SV* corresponding
7838  * to the parsed name as looked up in the RExC_paren_names hash.
7839  * If there is an error throws a vFAIL().. type exception.
7840  */
7841
7842 #define REG_RSN_RETURN_NULL    0
7843 #define REG_RSN_RETURN_NAME    1
7844 #define REG_RSN_RETURN_DATA    2
7845
7846 STATIC SV*
7847 S_reg_scan_name(pTHX_ RExC_state_t *pRExC_state, U32 flags)
7848 {
7849     char *name_start = RExC_parse;
7850
7851     PERL_ARGS_ASSERT_REG_SCAN_NAME;
7852
7853     assert (RExC_parse <= RExC_end);
7854     if (RExC_parse == RExC_end) NOOP;
7855     else if (isIDFIRST_lazy_if(RExC_parse, UTF)) {
7856          /* skip IDFIRST by using do...while */
7857         if (UTF)
7858             do {
7859                 RExC_parse += UTF8SKIP(RExC_parse);
7860             } while (isWORDCHAR_utf8((U8*)RExC_parse));
7861         else
7862             do {
7863                 RExC_parse++;
7864             } while (isWORDCHAR(*RExC_parse));
7865     } else {
7866         RExC_parse++; /* so the <- from the vFAIL is after the offending
7867                          character */
7868         vFAIL("Group name must start with a non-digit word character");
7869     }
7870     if ( flags ) {
7871         SV* sv_name
7872             = newSVpvn_flags(name_start, (int)(RExC_parse - name_start),
7873                              SVs_TEMP | (UTF ? SVf_UTF8 : 0));
7874         if ( flags == REG_RSN_RETURN_NAME)
7875             return sv_name;
7876         else if (flags==REG_RSN_RETURN_DATA) {
7877             HE *he_str = NULL;
7878             SV *sv_dat = NULL;
7879             if ( ! sv_name )      /* should not happen*/
7880                 Perl_croak(aTHX_ "panic: no svname in reg_scan_name");
7881             if (RExC_paren_names)
7882                 he_str = hv_fetch_ent( RExC_paren_names, sv_name, 0, 0 );
7883             if ( he_str )
7884                 sv_dat = HeVAL(he_str);
7885             if ( ! sv_dat )
7886                 vFAIL("Reference to nonexistent named group");
7887             return sv_dat;
7888         }
7889         else {
7890             Perl_croak(aTHX_ "panic: bad flag %lx in reg_scan_name",
7891                        (unsigned long) flags);
7892         }
7893         NOT_REACHED; /* NOTREACHED */
7894     }
7895     return NULL;
7896 }
7897
7898 #define DEBUG_PARSE_MSG(funcname)     DEBUG_PARSE_r({           \
7899     int num;                                                    \
7900     if (RExC_lastparse!=RExC_parse) {                           \
7901         PerlIO_printf(Perl_debug_log, "%s",                     \
7902             Perl_pv_pretty(aTHX_ RExC_mysv1, RExC_parse,        \
7903                 RExC_end - RExC_parse, 16,                      \
7904                 "", "",                                         \
7905                 PERL_PV_ESCAPE_UNI_DETECT |                     \
7906                 PERL_PV_PRETTY_ELLIPSES   |                     \
7907                 PERL_PV_PRETTY_LTGT       |                     \
7908                 PERL_PV_ESCAPE_RE         |                     \
7909                 PERL_PV_PRETTY_EXACTSIZE                        \
7910             )                                                   \
7911         );                                                      \
7912     } else                                                      \
7913         PerlIO_printf(Perl_debug_log,"%16s","");                \
7914                                                                 \
7915     if (SIZE_ONLY)                                              \
7916        num = RExC_size + 1;                                     \
7917     else                                                        \
7918        num=REG_NODE_NUM(RExC_emit);                             \
7919     if (RExC_lastnum!=num)                                      \
7920        PerlIO_printf(Perl_debug_log,"|%4d",num);                \
7921     else                                                        \
7922        PerlIO_printf(Perl_debug_log,"|%4s","");                 \
7923     PerlIO_printf(Perl_debug_log,"|%*s%-4s",                    \
7924         (int)((depth*2)), "",                                   \
7925         (funcname)                                              \
7926     );                                                          \
7927     RExC_lastnum=num;                                           \
7928     RExC_lastparse=RExC_parse;                                  \
7929 })
7930
7931
7932
7933 #define DEBUG_PARSE(funcname)     DEBUG_PARSE_r({           \
7934     DEBUG_PARSE_MSG((funcname));                            \
7935     PerlIO_printf(Perl_debug_log,"%4s","\n");               \
7936 })
7937 #define DEBUG_PARSE_FMT(funcname,fmt,args)     DEBUG_PARSE_r({           \
7938     DEBUG_PARSE_MSG((funcname));                            \
7939     PerlIO_printf(Perl_debug_log,fmt "\n",args);               \
7940 })
7941
7942 /* This section of code defines the inversion list object and its methods.  The
7943  * interfaces are highly subject to change, so as much as possible is static to
7944  * this file.  An inversion list is here implemented as a malloc'd C UV array
7945  * as an SVt_INVLIST scalar.
7946  *
7947  * An inversion list for Unicode is an array of code points, sorted by ordinal
7948  * number.  The zeroth element is the first code point in the list.  The 1th
7949  * element is the first element beyond that not in the list.  In other words,
7950  * the first range is
7951  *  invlist[0]..(invlist[1]-1)
7952  * The other ranges follow.  Thus every element whose index is divisible by two
7953  * marks the beginning of a range that is in the list, and every element not
7954  * divisible by two marks the beginning of a range not in the list.  A single
7955  * element inversion list that contains the single code point N generally
7956  * consists of two elements
7957  *  invlist[0] == N
7958  *  invlist[1] == N+1
7959  * (The exception is when N is the highest representable value on the
7960  * machine, in which case the list containing just it would be a single
7961  * element, itself.  By extension, if the last range in the list extends to
7962  * infinity, then the first element of that range will be in the inversion list
7963  * at a position that is divisible by two, and is the final element in the
7964  * list.)
7965  * Taking the complement (inverting) an inversion list is quite simple, if the
7966  * first element is 0, remove it; otherwise add a 0 element at the beginning.
7967  * This implementation reserves an element at the beginning of each inversion
7968  * list to always contain 0; there is an additional flag in the header which
7969  * indicates if the list begins at the 0, or is offset to begin at the next
7970  * element.
7971  *
7972  * More about inversion lists can be found in "Unicode Demystified"
7973  * Chapter 13 by Richard Gillam, published by Addison-Wesley.
7974  * More will be coming when functionality is added later.
7975  *
7976  * The inversion list data structure is currently implemented as an SV pointing
7977  * to an array of UVs that the SV thinks are bytes.  This allows us to have an
7978  * array of UV whose memory management is automatically handled by the existing
7979  * facilities for SV's.
7980  *
7981  * Some of the methods should always be private to the implementation, and some
7982  * should eventually be made public */
7983
7984 /* The header definitions are in F<inline_invlist.c> */
7985
7986 PERL_STATIC_INLINE UV*
7987 S__invlist_array_init(SV* const invlist, const bool will_have_0)
7988 {
7989     /* Returns a pointer to the first element in the inversion list's array.
7990      * This is called upon initialization of an inversion list.  Where the
7991      * array begins depends on whether the list has the code point U+0000 in it
7992      * or not.  The other parameter tells it whether the code that follows this
7993      * call is about to put a 0 in the inversion list or not.  The first
7994      * element is either the element reserved for 0, if TRUE, or the element
7995      * after it, if FALSE */
7996
7997     bool* offset = get_invlist_offset_addr(invlist);
7998     UV* zero_addr = (UV *) SvPVX(invlist);
7999
8000     PERL_ARGS_ASSERT__INVLIST_ARRAY_INIT;
8001
8002     /* Must be empty */
8003     assert(! _invlist_len(invlist));
8004
8005     *zero_addr = 0;
8006
8007     /* 1^1 = 0; 1^0 = 1 */
8008     *offset = 1 ^ will_have_0;
8009     return zero_addr + *offset;
8010 }
8011
8012 PERL_STATIC_INLINE void
8013 S_invlist_set_len(pTHX_ SV* const invlist, const UV len, const bool offset)
8014 {
8015     /* Sets the current number of elements stored in the inversion list.
8016      * Updates SvCUR correspondingly */
8017     PERL_UNUSED_CONTEXT;
8018     PERL_ARGS_ASSERT_INVLIST_SET_LEN;
8019
8020     assert(SvTYPE(invlist) == SVt_INVLIST);
8021
8022     SvCUR_set(invlist,
8023               (len == 0)
8024                ? 0
8025                : TO_INTERNAL_SIZE(len + offset));
8026     assert(SvLEN(invlist) == 0 || SvCUR(invlist) <= SvLEN(invlist));
8027 }
8028
8029 #ifndef PERL_IN_XSUB_RE
8030
8031 PERL_STATIC_INLINE IV*
8032 S_get_invlist_previous_index_addr(SV* invlist)
8033 {
8034     /* Return the address of the IV that is reserved to hold the cached index
8035      * */
8036     PERL_ARGS_ASSERT_GET_INVLIST_PREVIOUS_INDEX_ADDR;
8037
8038     assert(SvTYPE(invlist) == SVt_INVLIST);
8039
8040     return &(((XINVLIST*) SvANY(invlist))->prev_index);
8041 }
8042
8043 PERL_STATIC_INLINE IV
8044 S_invlist_previous_index(SV* const invlist)
8045 {
8046     /* Returns cached index of previous search */
8047
8048     PERL_ARGS_ASSERT_INVLIST_PREVIOUS_INDEX;
8049
8050     return *get_invlist_previous_index_addr(invlist);
8051 }
8052
8053 PERL_STATIC_INLINE void
8054 S_invlist_set_previous_index(SV* const invlist, const IV index)
8055 {
8056     /* Caches <index> for later retrieval */
8057
8058     PERL_ARGS_ASSERT_INVLIST_SET_PREVIOUS_INDEX;
8059
8060     assert(index == 0 || index < (int) _invlist_len(invlist));
8061
8062     *get_invlist_previous_index_addr(invlist) = index;
8063 }
8064
8065 PERL_STATIC_INLINE void
8066 S_invlist_trim(SV* const invlist)
8067 {
8068     PERL_ARGS_ASSERT_INVLIST_TRIM;
8069
8070     assert(SvTYPE(invlist) == SVt_INVLIST);
8071
8072     /* Change the length of the inversion list to how many entries it currently
8073      * has */
8074     SvPV_shrink_to_cur((SV *) invlist);
8075 }
8076
8077 PERL_STATIC_INLINE bool
8078 S_invlist_is_iterating(SV* const invlist)
8079 {
8080     PERL_ARGS_ASSERT_INVLIST_IS_ITERATING;
8081
8082     return *(get_invlist_iter_addr(invlist)) < (STRLEN) UV_MAX;
8083 }
8084
8085 #endif /* ifndef PERL_IN_XSUB_RE */
8086
8087 PERL_STATIC_INLINE UV
8088 S_invlist_max(SV* const invlist)
8089 {
8090     /* Returns the maximum number of elements storable in the inversion list's
8091      * array, without having to realloc() */
8092
8093     PERL_ARGS_ASSERT_INVLIST_MAX;
8094
8095     assert(SvTYPE(invlist) == SVt_INVLIST);
8096
8097     /* Assumes worst case, in which the 0 element is not counted in the
8098      * inversion list, so subtracts 1 for that */
8099     return SvLEN(invlist) == 0  /* This happens under _new_invlist_C_array */
8100            ? FROM_INTERNAL_SIZE(SvCUR(invlist)) - 1
8101            : FROM_INTERNAL_SIZE(SvLEN(invlist)) - 1;
8102 }
8103
8104 #ifndef PERL_IN_XSUB_RE
8105 SV*
8106 Perl__new_invlist(pTHX_ IV initial_size)
8107 {
8108
8109     /* Return a pointer to a newly constructed inversion list, with enough
8110      * space to store 'initial_size' elements.  If that number is negative, a
8111      * system default is used instead */
8112
8113     SV* new_list;
8114
8115     if (initial_size < 0) {
8116         initial_size = 10;
8117     }
8118
8119     /* Allocate the initial space */
8120     new_list = newSV_type(SVt_INVLIST);
8121
8122     /* First 1 is in case the zero element isn't in the list; second 1 is for
8123      * trailing NUL */
8124     SvGROW(new_list, TO_INTERNAL_SIZE(initial_size + 1) + 1);
8125     invlist_set_len(new_list, 0, 0);
8126
8127     /* Force iterinit() to be used to get iteration to work */
8128     *get_invlist_iter_addr(new_list) = (STRLEN) UV_MAX;
8129
8130     *get_invlist_previous_index_addr(new_list) = 0;
8131
8132     return new_list;
8133 }
8134
8135 SV*
8136 Perl__new_invlist_C_array(pTHX_ const UV* const list)
8137 {
8138     /* Return a pointer to a newly constructed inversion list, initialized to
8139      * point to <list>, which has to be in the exact correct inversion list
8140      * form, including internal fields.  Thus this is a dangerous routine that
8141      * should not be used in the wrong hands.  The passed in 'list' contains
8142      * several header fields at the beginning that are not part of the
8143      * inversion list body proper */
8144
8145     const STRLEN length = (STRLEN) list[0];
8146     const UV version_id =          list[1];
8147     const bool offset   =    cBOOL(list[2]);
8148 #define HEADER_LENGTH 3
8149     /* If any of the above changes in any way, you must change HEADER_LENGTH
8150      * (if appropriate) and regenerate INVLIST_VERSION_ID by running
8151      *      perl -E 'say int(rand 2**31-1)'
8152      */
8153 #define INVLIST_VERSION_ID 148565664 /* This is a combination of a version and
8154                                         data structure type, so that one being
8155                                         passed in can be validated to be an
8156                                         inversion list of the correct vintage.
8157                                        */
8158
8159     SV* invlist = newSV_type(SVt_INVLIST);
8160
8161     PERL_ARGS_ASSERT__NEW_INVLIST_C_ARRAY;
8162
8163     if (version_id != INVLIST_VERSION_ID) {
8164         Perl_croak(aTHX_ "panic: Incorrect version for previously generated inversion list");
8165     }
8166
8167     /* The generated array passed in includes header elements that aren't part
8168      * of the list proper, so start it just after them */
8169     SvPV_set(invlist, (char *) (list + HEADER_LENGTH));
8170
8171     SvLEN_set(invlist, 0);  /* Means we own the contents, and the system
8172                                shouldn't touch it */
8173
8174     *(get_invlist_offset_addr(invlist)) = offset;
8175
8176     /* The 'length' passed to us is the physical number of elements in the
8177      * inversion list.  But if there is an offset the logical number is one
8178      * less than that */
8179     invlist_set_len(invlist, length  - offset, offset);
8180
8181     invlist_set_previous_index(invlist, 0);
8182
8183     /* Initialize the iteration pointer. */
8184     invlist_iterfinish(invlist);
8185
8186     SvREADONLY_on(invlist);
8187
8188     return invlist;
8189 }
8190 #endif /* ifndef PERL_IN_XSUB_RE */
8191
8192 STATIC void
8193 S_invlist_extend(pTHX_ SV* const invlist, const UV new_max)
8194 {
8195     /* Grow the maximum size of an inversion list */
8196
8197     PERL_ARGS_ASSERT_INVLIST_EXTEND;
8198
8199     assert(SvTYPE(invlist) == SVt_INVLIST);
8200
8201     /* Add one to account for the zero element at the beginning which may not
8202      * be counted by the calling parameters */
8203     SvGROW((SV *)invlist, TO_INTERNAL_SIZE(new_max + 1));
8204 }
8205
8206 STATIC void
8207 S__append_range_to_invlist(pTHX_ SV* const invlist,
8208                                  const UV start, const UV end)
8209 {
8210    /* Subject to change or removal.  Append the range from 'start' to 'end' at
8211     * the end of the inversion list.  The range must be above any existing
8212     * ones. */
8213
8214     UV* array;
8215     UV max = invlist_max(invlist);
8216     UV len = _invlist_len(invlist);
8217     bool offset;
8218
8219     PERL_ARGS_ASSERT__APPEND_RANGE_TO_INVLIST;
8220
8221     if (len == 0) { /* Empty lists must be initialized */
8222         offset = start != 0;
8223         array = _invlist_array_init(invlist, ! offset);
8224     }
8225     else {
8226         /* Here, the existing list is non-empty. The current max entry in the
8227          * list is generally the first value not in the set, except when the
8228          * set extends to the end of permissible values, in which case it is
8229          * the first entry in that final set, and so this call is an attempt to
8230          * append out-of-order */
8231
8232         UV final_element = len - 1;
8233         array = invlist_array(invlist);
8234         if (array[final_element] > start
8235             || ELEMENT_RANGE_MATCHES_INVLIST(final_element))
8236         {
8237             Perl_croak(aTHX_ "panic: attempting to append to an inversion list, but wasn't at the end of the list, final=%"UVuf", start=%"UVuf", match=%c",
8238                      array[final_element], start,
8239                      ELEMENT_RANGE_MATCHES_INVLIST(final_element) ? 't' : 'f');
8240         }
8241
8242         /* Here, it is a legal append.  If the new range begins with the first
8243          * value not in the set, it is extending the set, so the new first
8244          * value not in the set is one greater than the newly extended range.
8245          * */
8246         offset = *get_invlist_offset_addr(invlist);
8247         if (array[final_element] == start) {
8248             if (end != UV_MAX) {
8249                 array[final_element] = end + 1;
8250             }
8251             else {
8252                 /* But if the end is the maximum representable on the machine,
8253                  * just let the range that this would extend to have no end */
8254                 invlist_set_len(invlist, len - 1, offset);
8255             }
8256             return;
8257         }
8258     }
8259
8260     /* Here the new range doesn't extend any existing set.  Add it */
8261
8262     len += 2;   /* Includes an element each for the start and end of range */
8263
8264     /* If wll overflow the existing space, extend, which may cause the array to
8265      * be moved */
8266     if (max < len) {
8267         invlist_extend(invlist, len);
8268
8269         /* Have to set len here to avoid assert failure in invlist_array() */
8270         invlist_set_len(invlist, len, offset);
8271
8272         array = invlist_array(invlist);
8273     }
8274     else {
8275         invlist_set_len(invlist, len, offset);
8276     }
8277
8278     /* The next item on the list starts the range, the one after that is
8279      * one past the new range.  */
8280     array[len - 2] = start;
8281     if (end != UV_MAX) {
8282         array[len - 1] = end + 1;
8283     }
8284     else {
8285         /* But if the end is the maximum representable on the machine, just let
8286          * the range have no end */
8287         invlist_set_len(invlist, len - 1, offset);
8288     }
8289 }
8290
8291 #ifndef PERL_IN_XSUB_RE
8292
8293 IV
8294 Perl__invlist_search(SV* const invlist, const UV cp)
8295 {
8296     /* Searches the inversion list for the entry that contains the input code
8297      * point <cp>.  If <cp> is not in the list, -1 is returned.  Otherwise, the
8298      * return value is the index into the list's array of the range that
8299      * contains <cp> */
8300
8301     IV low = 0;
8302     IV mid;
8303     IV high = _invlist_len(invlist);
8304     const IV highest_element = high - 1;
8305     const UV* array;
8306
8307     PERL_ARGS_ASSERT__INVLIST_SEARCH;
8308
8309     /* If list is empty, return failure. */
8310     if (high == 0) {
8311         return -1;
8312     }
8313
8314     /* (We can't get the array unless we know the list is non-empty) */
8315     array = invlist_array(invlist);
8316
8317     mid = invlist_previous_index(invlist);
8318     assert(mid >=0 && mid <= highest_element);
8319
8320     /* <mid> contains the cache of the result of the previous call to this
8321      * function (0 the first time).  See if this call is for the same result,
8322      * or if it is for mid-1.  This is under the theory that calls to this
8323      * function will often be for related code points that are near each other.
8324      * And benchmarks show that caching gives better results.  We also test
8325      * here if the code point is within the bounds of the list.  These tests
8326      * replace others that would have had to be made anyway to make sure that
8327      * the array bounds were not exceeded, and these give us extra information
8328      * at the same time */
8329     if (cp >= array[mid]) {
8330         if (cp >= array[highest_element]) {
8331             return highest_element;
8332         }
8333
8334         /* Here, array[mid] <= cp < array[highest_element].  This means that
8335          * the final element is not the answer, so can exclude it; it also
8336          * means that <mid> is not the final element, so can refer to 'mid + 1'
8337          * safely */
8338         if (cp < array[mid + 1]) {
8339             return mid;
8340         }
8341         high--;
8342         low = mid + 1;
8343     }
8344     else { /* cp < aray[mid] */
8345         if (cp < array[0]) { /* Fail if outside the array */
8346             return -1;
8347         }
8348         high = mid;
8349         if (cp >= array[mid - 1]) {
8350             goto found_entry;
8351         }
8352     }
8353
8354     /* Binary search.  What we are looking for is <i> such that
8355      *  array[i] <= cp < array[i+1]
8356      * The loop below converges on the i+1.  Note that there may not be an
8357      * (i+1)th element in the array, and things work nonetheless */
8358     while (low < high) {
8359         mid = (low + high) / 2;
8360         assert(mid <= highest_element);
8361         if (array[mid] <= cp) { /* cp >= array[mid] */
8362             low = mid + 1;
8363
8364             /* We could do this extra test to exit the loop early.
8365             if (cp < array[low]) {
8366                 return mid;
8367             }
8368             */
8369         }
8370         else { /* cp < array[mid] */
8371             high = mid;
8372         }
8373     }
8374
8375   found_entry:
8376     high--;
8377     invlist_set_previous_index(invlist, high);
8378     return high;
8379 }
8380
8381 void
8382 Perl__invlist_populate_swatch(SV* const invlist,
8383                               const UV start, const UV end, U8* swatch)
8384 {
8385     /* populates a swatch of a swash the same way swatch_get() does in utf8.c,
8386      * but is used when the swash has an inversion list.  This makes this much
8387      * faster, as it uses a binary search instead of a linear one.  This is
8388      * intimately tied to that function, and perhaps should be in utf8.c,
8389      * except it is intimately tied to inversion lists as well.  It assumes
8390      * that <swatch> is all 0's on input */
8391
8392     UV current = start;
8393     const IV len = _invlist_len(invlist);
8394     IV i;
8395     const UV * array;
8396
8397     PERL_ARGS_ASSERT__INVLIST_POPULATE_SWATCH;
8398
8399     if (len == 0) { /* Empty inversion list */
8400         return;
8401     }
8402
8403     array = invlist_array(invlist);
8404
8405     /* Find which element it is */
8406     i = _invlist_search(invlist, start);
8407
8408     /* We populate from <start> to <end> */
8409     while (current < end) {
8410         UV upper;
8411
8412         /* The inversion list gives the results for every possible code point
8413          * after the first one in the list.  Only those ranges whose index is
8414          * even are ones that the inversion list matches.  For the odd ones,
8415          * and if the initial code point is not in the list, we have to skip
8416          * forward to the next element */
8417         if (i == -1 || ! ELEMENT_RANGE_MATCHES_INVLIST(i)) {
8418             i++;
8419             if (i >= len) { /* Finished if beyond the end of the array */
8420                 return;
8421             }
8422             current = array[i];
8423             if (current >= end) {   /* Finished if beyond the end of what we
8424                                        are populating */
8425                 if (LIKELY(end < UV_MAX)) {
8426                     return;
8427                 }
8428
8429                 /* We get here when the upper bound is the maximum
8430                  * representable on the machine, and we are looking for just
8431                  * that code point.  Have to special case it */
8432                 i = len;
8433                 goto join_end_of_list;
8434             }
8435         }
8436         assert(current >= start);
8437
8438         /* The current range ends one below the next one, except don't go past
8439          * <end> */
8440         i++;
8441         upper = (i < len && array[i] < end) ? array[i] : end;
8442
8443         /* Here we are in a range that matches.  Populate a bit in the 3-bit U8
8444          * for each code point in it */
8445         for (; current < upper; current++) {
8446             const STRLEN offset = (STRLEN)(current - start);
8447             swatch[offset >> 3] |= 1 << (offset & 7);
8448         }
8449
8450       join_end_of_list:
8451
8452         /* Quit if at the end of the list */
8453         if (i >= len) {
8454
8455             /* But first, have to deal with the highest possible code point on
8456              * the platform.  The previous code assumes that <end> is one
8457              * beyond where we want to populate, but that is impossible at the
8458              * platform's infinity, so have to handle it specially */
8459             if (UNLIKELY(end == UV_MAX && ELEMENT_RANGE_MATCHES_INVLIST(len-1)))
8460             {
8461                 const STRLEN offset = (STRLEN)(end - start);
8462                 swatch[offset >> 3] |= 1 << (offset & 7);
8463             }
8464             return;
8465         }
8466
8467         /* Advance to the next range, which will be for code points not in the
8468          * inversion list */
8469         current = array[i];
8470     }
8471
8472     return;
8473 }
8474
8475 void
8476 Perl__invlist_union_maybe_complement_2nd(pTHX_ SV* const a, SV* const b,
8477                                          const bool complement_b, SV** output)
8478 {
8479     /* Take the union of two inversion lists and point <output> to it.  *output
8480      * SHOULD BE DEFINED upon input, and if it points to one of the two lists,
8481      * the reference count to that list will be decremented if not already a
8482      * temporary (mortal); otherwise *output will be made correspondingly
8483      * mortal.  The first list, <a>, may be NULL, in which case a copy of the
8484      * second list is returned.  If <complement_b> is TRUE, the union is taken
8485      * of the complement (inversion) of <b> instead of b itself.
8486      *
8487      * The basis for this comes from "Unicode Demystified" Chapter 13 by
8488      * Richard Gillam, published by Addison-Wesley, and explained at some
8489      * length there.  The preface says to incorporate its examples into your
8490      * code at your own risk.
8491      *
8492      * The algorithm is like a merge sort.
8493      *
8494      * XXX A potential performance improvement is to keep track as we go along
8495      * if only one of the inputs contributes to the result, meaning the other
8496      * is a subset of that one.  In that case, we can skip the final copy and
8497      * return the larger of the input lists, but then outside code might need
8498      * to keep track of whether to free the input list or not */
8499
8500     const UV* array_a;    /* a's array */
8501     const UV* array_b;
8502     UV len_a;       /* length of a's array */
8503     UV len_b;
8504
8505     SV* u;                      /* the resulting union */
8506     UV* array_u;
8507     UV len_u;
8508
8509     UV i_a = 0;             /* current index into a's array */
8510     UV i_b = 0;
8511     UV i_u = 0;
8512
8513     /* running count, as explained in the algorithm source book; items are
8514      * stopped accumulating and are output when the count changes to/from 0.
8515      * The count is incremented when we start a range that's in the set, and
8516      * decremented when we start a range that's not in the set.  So its range
8517      * is 0 to 2.  Only when the count is zero is something not in the set.
8518      */
8519     UV count = 0;
8520
8521     PERL_ARGS_ASSERT__INVLIST_UNION_MAYBE_COMPLEMENT_2ND;
8522     assert(a != b);
8523
8524     /* If either one is empty, the union is the other one */
8525     if (a == NULL || ((len_a = _invlist_len(a)) == 0)) {
8526         bool make_temp = FALSE; /* Should we mortalize the result? */
8527
8528         if (*output == a) {
8529             if (a != NULL) {
8530                 if (! (make_temp = cBOOL(SvTEMP(a)))) {
8531                     SvREFCNT_dec_NN(a);
8532                 }
8533             }
8534         }
8535         if (*output != b) {
8536             *output = invlist_clone(b);
8537             if (complement_b) {
8538                 _invlist_invert(*output);
8539             }
8540         } /* else *output already = b; */
8541
8542         if (make_temp) {
8543             sv_2mortal(*output);
8544         }
8545         return;
8546     }
8547     else if ((len_b = _invlist_len(b)) == 0) {
8548         bool make_temp = FALSE;
8549         if (*output == b) {
8550             if (! (make_temp = cBOOL(SvTEMP(b)))) {
8551                 SvREFCNT_dec_NN(b);
8552             }
8553         }
8554
8555         /* The complement of an empty list is a list that has everything in it,
8556          * so the union with <a> includes everything too */
8557         if (complement_b) {
8558             if (a == *output) {
8559                 if (! (make_temp = cBOOL(SvTEMP(a)))) {
8560                     SvREFCNT_dec_NN(a);
8561                 }
8562             }
8563             *output = _new_invlist(1);
8564             _append_range_to_invlist(*output, 0, UV_MAX);
8565         }
8566         else if (*output != a) {
8567             *output = invlist_clone(a);
8568         }
8569         /* else *output already = a; */
8570
8571         if (make_temp) {
8572             sv_2mortal(*output);
8573         }
8574         return;
8575     }
8576
8577     /* Here both lists exist and are non-empty */
8578     array_a = invlist_array(a);
8579     array_b = invlist_array(b);
8580
8581     /* If are to take the union of 'a' with the complement of b, set it
8582      * up so are looking at b's complement. */
8583     if (complement_b) {
8584
8585         /* To complement, we invert: if the first element is 0, remove it.  To
8586          * do this, we just pretend the array starts one later */
8587         if (array_b[0] == 0) {
8588             array_b++;
8589             len_b--;
8590         }
8591         else {
8592
8593             /* But if the first element is not zero, we pretend the list starts
8594              * at the 0 that is always stored immediately before the array. */
8595             array_b--;
8596             len_b++;
8597         }
8598     }
8599
8600     /* Size the union for the worst case: that the sets are completely
8601      * disjoint */
8602     u = _new_invlist(len_a + len_b);
8603
8604     /* Will contain U+0000 if either component does */
8605     array_u = _invlist_array_init(u, (len_a > 0 && array_a[0] == 0)
8606                                       || (len_b > 0 && array_b[0] == 0));
8607
8608     /* Go through each list item by item, stopping when exhausted one of
8609      * them */
8610     while (i_a < len_a && i_b < len_b) {
8611         UV cp;      /* The element to potentially add to the union's array */
8612         bool cp_in_set;   /* is it in the the input list's set or not */
8613
8614         /* We need to take one or the other of the two inputs for the union.
8615          * Since we are merging two sorted lists, we take the smaller of the
8616          * next items.  In case of a tie, we take the one that is in its set
8617          * first.  If we took one not in the set first, it would decrement the
8618          * count, possibly to 0 which would cause it to be output as ending the
8619          * range, and the next time through we would take the same number, and
8620          * output it again as beginning the next range.  By doing it the
8621          * opposite way, there is no possibility that the count will be
8622          * momentarily decremented to 0, and thus the two adjoining ranges will
8623          * be seamlessly merged.  (In a tie and both are in the set or both not
8624          * in the set, it doesn't matter which we take first.) */
8625         if (array_a[i_a] < array_b[i_b]
8626             || (array_a[i_a] == array_b[i_b]
8627                 && ELEMENT_RANGE_MATCHES_INVLIST(i_a)))
8628         {
8629             cp_in_set = ELEMENT_RANGE_MATCHES_INVLIST(i_a);
8630             cp= array_a[i_a++];
8631         }
8632         else {
8633             cp_in_set = ELEMENT_RANGE_MATCHES_INVLIST(i_b);
8634             cp = array_b[i_b++];
8635         }
8636
8637         /* Here, have chosen which of the two inputs to look at.  Only output
8638          * if the running count changes to/from 0, which marks the
8639          * beginning/end of a range in that's in the set */
8640         if (cp_in_set) {
8641             if (count == 0) {
8642                 array_u[i_u++] = cp;
8643             }
8644             count++;
8645         }
8646         else {
8647             count--;
8648             if (count == 0) {
8649                 array_u[i_u++] = cp;
8650             }
8651         }
8652     }
8653
8654     /* Here, we are finished going through at least one of the lists, which
8655      * means there is something remaining in at most one.  We check if the list
8656      * that hasn't been exhausted is positioned such that we are in the middle
8657      * of a range in its set or not.  (i_a and i_b point to the element beyond
8658      * the one we care about.) If in the set, we decrement 'count'; if 0, there
8659      * is potentially more to output.
8660      * There are four cases:
8661      *  1) Both weren't in their sets, count is 0, and remains 0.  What's left
8662      *     in the union is entirely from the non-exhausted set.
8663      *  2) Both were in their sets, count is 2.  Nothing further should
8664      *     be output, as everything that remains will be in the exhausted
8665      *     list's set, hence in the union; decrementing to 1 but not 0 insures
8666      *     that
8667      *  3) the exhausted was in its set, non-exhausted isn't, count is 1.
8668      *     Nothing further should be output because the union includes
8669      *     everything from the exhausted set.  Not decrementing ensures that.
8670      *  4) the exhausted wasn't in its set, non-exhausted is, count is 1;
8671      *     decrementing to 0 insures that we look at the remainder of the
8672      *     non-exhausted set */
8673     if ((i_a != len_a && PREV_RANGE_MATCHES_INVLIST(i_a))
8674         || (i_b != len_b && PREV_RANGE_MATCHES_INVLIST(i_b)))
8675     {
8676         count--;
8677     }
8678
8679     /* The final length is what we've output so far, plus what else is about to
8680      * be output.  (If 'count' is non-zero, then the input list we exhausted
8681      * has everything remaining up to the machine's limit in its set, and hence
8682      * in the union, so there will be no further output. */
8683     len_u = i_u;
8684     if (count == 0) {
8685         /* At most one of the subexpressions will be non-zero */
8686         len_u += (len_a - i_a) + (len_b - i_b);
8687     }
8688
8689     /* Set result to final length, which can change the pointer to array_u, so
8690      * re-find it */
8691     if (len_u != _invlist_len(u)) {
8692         invlist_set_len(u, len_u, *get_invlist_offset_addr(u));
8693         invlist_trim(u);
8694         array_u = invlist_array(u);
8695     }
8696
8697     /* When 'count' is 0, the list that was exhausted (if one was shorter than
8698      * the other) ended with everything above it not in its set.  That means
8699      * that the remaining part of the union is precisely the same as the
8700      * non-exhausted list, so can just copy it unchanged.  (If both list were
8701      * exhausted at the same time, then the operations below will be both 0.)
8702      */
8703     if (count == 0) {
8704         IV copy_count; /* At most one will have a non-zero copy count */
8705         if ((copy_count = len_a - i_a) > 0) {
8706             Copy(array_a + i_a, array_u + i_u, copy_count, UV);
8707         }
8708         else if ((copy_count = len_b - i_b) > 0) {
8709             Copy(array_b + i_b, array_u + i_u, copy_count, UV);
8710         }
8711     }
8712
8713     /*  We may be removing a reference to one of the inputs.  If so, the output
8714      *  is made mortal if the input was.  (Mortal SVs shouldn't have their ref
8715      *  count decremented) */
8716     if (a == *output || b == *output) {
8717         assert(! invlist_is_iterating(*output));
8718         if ((SvTEMP(*output))) {
8719             sv_2mortal(u);
8720         }
8721         else {
8722             SvREFCNT_dec_NN(*output);
8723         }
8724     }
8725
8726     *output = u;
8727
8728     return;
8729 }
8730
8731 void
8732 Perl__invlist_intersection_maybe_complement_2nd(pTHX_ SV* const a, SV* const b,
8733                                                const bool complement_b, SV** i)
8734 {
8735     /* Take the intersection of two inversion lists and point <i> to it.  *i
8736      * SHOULD BE DEFINED upon input, and if it points to one of the two lists,
8737      * the reference count to that list will be decremented if not already a
8738      * temporary (mortal); otherwise *i will be made correspondingly mortal.
8739      * The first list, <a>, may be NULL, in which case an empty list is
8740      * returned.  If <complement_b> is TRUE, the result will be the
8741      * intersection of <a> and the complement (or inversion) of <b> instead of
8742      * <b> directly.
8743      *
8744      * The basis for this comes from "Unicode Demystified" Chapter 13 by
8745      * Richard Gillam, published by Addison-Wesley, and explained at some
8746      * length there.  The preface says to incorporate its examples into your
8747      * code at your own risk.  In fact, it had bugs
8748      *
8749      * The algorithm is like a merge sort, and is essentially the same as the
8750      * union above
8751      */
8752
8753     const UV* array_a;          /* a's array */
8754     const UV* array_b;
8755     UV len_a;   /* length of a's array */
8756     UV len_b;
8757
8758     SV* r;                   /* the resulting intersection */
8759     UV* array_r;
8760     UV len_r;
8761
8762     UV i_a = 0;             /* current index into a's array */
8763     UV i_b = 0;
8764     UV i_r = 0;
8765
8766     /* running count, as explained in the algorithm source book; items are
8767      * stopped accumulating and are output when the count changes to/from 2.
8768      * The count is incremented when we start a range that's in the set, and
8769      * decremented when we start a range that's not in the set.  So its range
8770      * is 0 to 2.  Only when the count is 2 is something in the intersection.
8771      */
8772     UV count = 0;
8773
8774     PERL_ARGS_ASSERT__INVLIST_INTERSECTION_MAYBE_COMPLEMENT_2ND;
8775     assert(a != b);
8776
8777     /* Special case if either one is empty */
8778     len_a = (a == NULL) ? 0 : _invlist_len(a);
8779     if ((len_a == 0) || ((len_b = _invlist_len(b)) == 0)) {
8780         bool make_temp = FALSE;
8781
8782         if (len_a != 0 && complement_b) {
8783
8784             /* Here, 'a' is not empty, therefore from the above 'if', 'b' must
8785              * be empty.  Here, also we are using 'b's complement, which hence
8786              * must be every possible code point.  Thus the intersection is
8787              * simply 'a'. */
8788             if (*i != a) {
8789                 if (*i == b) {
8790                     if (! (make_temp = cBOOL(SvTEMP(b)))) {
8791                         SvREFCNT_dec_NN(b);
8792                     }
8793                 }
8794
8795                 *i = invlist_clone(a);
8796             }
8797             /* else *i is already 'a' */
8798
8799             if (make_temp) {
8800                 sv_2mortal(*i);
8801             }
8802             return;
8803         }
8804
8805         /* Here, 'a' or 'b' is empty and not using the complement of 'b'.  The
8806          * intersection must be empty */
8807         if (*i == a) {
8808             if (! (make_temp = cBOOL(SvTEMP(a)))) {
8809                 SvREFCNT_dec_NN(a);
8810             }
8811         }
8812         else if (*i == b) {
8813             if (! (make_temp = cBOOL(SvTEMP(b)))) {
8814                 SvREFCNT_dec_NN(b);
8815             }
8816         }
8817         *i = _new_invlist(0);
8818         if (make_temp) {
8819             sv_2mortal(*i);
8820         }
8821
8822         return;
8823     }
8824
8825     /* Here both lists exist and are non-empty */
8826     array_a = invlist_array(a);
8827     array_b = invlist_array(b);
8828
8829     /* If are to take the intersection of 'a' with the complement of b, set it
8830      * up so are looking at b's complement. */
8831     if (complement_b) {
8832
8833         /* To complement, we invert: if the first element is 0, remove it.  To
8834          * do this, we just pretend the array starts one later */
8835         if (array_b[0] == 0) {
8836             array_b++;
8837             len_b--;
8838         }
8839         else {
8840
8841             /* But if the first element is not zero, we pretend the list starts
8842              * at the 0 that is always stored immediately before the array. */
8843             array_b--;
8844             len_b++;
8845         }
8846     }
8847
8848     /* Size the intersection for the worst case: that the intersection ends up
8849      * fragmenting everything to be completely disjoint */
8850     r= _new_invlist(len_a + len_b);
8851
8852     /* Will contain U+0000 iff both components do */
8853     array_r = _invlist_array_init(r, len_a > 0 && array_a[0] == 0
8854                                      && len_b > 0 && array_b[0] == 0);
8855
8856     /* Go through each list item by item, stopping when exhausted one of
8857      * them */
8858     while (i_a < len_a && i_b < len_b) {
8859         UV cp;      /* The element to potentially add to the intersection's
8860                        array */
8861         bool cp_in_set; /* Is it in the input list's set or not */
8862
8863         /* We need to take one or the other of the two inputs for the
8864          * intersection.  Since we are merging two sorted lists, we take the
8865          * smaller of the next items.  In case of a tie, we take the one that
8866          * is not in its set first (a difference from the union algorithm).  If
8867          * we took one in the set first, it would increment the count, possibly
8868          * to 2 which would cause it to be output as starting a range in the
8869          * intersection, and the next time through we would take that same
8870          * number, and output it again as ending the set.  By doing it the
8871          * opposite of this, there is no possibility that the count will be
8872          * momentarily incremented to 2.  (In a tie and both are in the set or
8873          * both not in the set, it doesn't matter which we take first.) */
8874         if (array_a[i_a] < array_b[i_b]
8875             || (array_a[i_a] == array_b[i_b]
8876                 && ! ELEMENT_RANGE_MATCHES_INVLIST(i_a)))
8877         {
8878             cp_in_set = ELEMENT_RANGE_MATCHES_INVLIST(i_a);
8879             cp= array_a[i_a++];
8880         }
8881         else {
8882             cp_in_set = ELEMENT_RANGE_MATCHES_INVLIST(i_b);
8883             cp= array_b[i_b++];
8884         }
8885
8886         /* Here, have chosen which of the two inputs to look at.  Only output
8887          * if the running count changes to/from 2, which marks the
8888          * beginning/end of a range that's in the intersection */
8889         if (cp_in_set) {
8890             count++;
8891             if (count == 2) {
8892                 array_r[i_r++] = cp;
8893             }
8894         }
8895         else {
8896             if (count == 2) {
8897                 array_r[i_r++] = cp;
8898             }
8899             count--;
8900         }
8901     }
8902
8903     /* Here, we are finished going through at least one of the lists, which
8904      * means there is something remaining in at most one.  We check if the list
8905      * that has been exhausted is positioned such that we are in the middle
8906      * of a range in its set or not.  (i_a and i_b point to elements 1 beyond
8907      * the ones we care about.)  There are four cases:
8908      *  1) Both weren't in their sets, count is 0, and remains 0.  There's
8909      *     nothing left in the intersection.
8910      *  2) Both were in their sets, count is 2 and perhaps is incremented to
8911      *     above 2.  What should be output is exactly that which is in the
8912      *     non-exhausted set, as everything it has is also in the intersection
8913      *     set, and everything it doesn't have can't be in the intersection
8914      *  3) The exhausted was in its set, non-exhausted isn't, count is 1, and
8915      *     gets incremented to 2.  Like the previous case, the intersection is
8916      *     everything that remains in the non-exhausted set.
8917      *  4) the exhausted wasn't in its set, non-exhausted is, count is 1, and
8918      *     remains 1.  And the intersection has nothing more. */
8919     if ((i_a == len_a && PREV_RANGE_MATCHES_INVLIST(i_a))
8920         || (i_b == len_b && PREV_RANGE_MATCHES_INVLIST(i_b)))
8921     {
8922         count++;
8923     }
8924
8925     /* The final length is what we've output so far plus what else is in the
8926      * intersection.  At most one of the subexpressions below will be non-zero
8927      * */
8928     len_r = i_r;
8929     if (count >= 2) {
8930         len_r += (len_a - i_a) + (len_b - i_b);
8931     }
8932
8933     /* Set result to final length, which can change the pointer to array_r, so
8934      * re-find it */
8935     if (len_r != _invlist_len(r)) {
8936         invlist_set_len(r, len_r, *get_invlist_offset_addr(r));
8937         invlist_trim(r);
8938         array_r = invlist_array(r);
8939     }
8940
8941     /* Finish outputting any remaining */
8942     if (count >= 2) { /* At most one will have a non-zero copy count */
8943         IV copy_count;
8944         if ((copy_count = len_a - i_a) > 0) {
8945             Copy(array_a + i_a, array_r + i_r, copy_count, UV);
8946         }
8947         else if ((copy_count = len_b - i_b) > 0) {
8948             Copy(array_b + i_b, array_r + i_r, copy_count, UV);
8949         }
8950     }
8951
8952     /*  We may be removing a reference to one of the inputs.  If so, the output
8953      *  is made mortal if the input was.  (Mortal SVs shouldn't have their ref
8954      *  count decremented) */
8955     if (a == *i || b == *i) {
8956         assert(! invlist_is_iterating(*i));
8957         if (SvTEMP(*i)) {
8958             sv_2mortal(r);
8959         }
8960         else {
8961             SvREFCNT_dec_NN(*i);
8962         }
8963     }
8964
8965     *i = r;
8966
8967     return;
8968 }
8969
8970 SV*
8971 Perl__add_range_to_invlist(pTHX_ SV* invlist, const UV start, const UV end)
8972 {
8973     /* Add the range from 'start' to 'end' inclusive to the inversion list's
8974      * set.  A pointer to the inversion list is returned.  This may actually be
8975      * a new list, in which case the passed in one has been destroyed.  The
8976      * passed-in inversion list can be NULL, in which case a new one is created
8977      * with just the one range in it */
8978
8979     SV* range_invlist;
8980     UV len;
8981
8982     if (invlist == NULL) {
8983         invlist = _new_invlist(2);
8984         len = 0;
8985     }
8986     else {
8987         len = _invlist_len(invlist);
8988     }
8989
8990     /* If comes after the final entry actually in the list, can just append it
8991      * to the end, */
8992     if (len == 0
8993         || (! ELEMENT_RANGE_MATCHES_INVLIST(len - 1)
8994             && start >= invlist_array(invlist)[len - 1]))
8995     {
8996         _append_range_to_invlist(invlist, start, end);
8997         return invlist;
8998     }
8999
9000     /* Here, can't just append things, create and return a new inversion list
9001      * which is the union of this range and the existing inversion list */
9002     range_invlist = _new_invlist(2);
9003     _append_range_to_invlist(range_invlist, start, end);
9004
9005     _invlist_union(invlist, range_invlist, &invlist);
9006
9007     /* The temporary can be freed */
9008     SvREFCNT_dec_NN(range_invlist);
9009
9010     return invlist;
9011 }
9012
9013 SV*
9014 Perl__setup_canned_invlist(pTHX_ const STRLEN size, const UV element0,
9015                                  UV** other_elements_ptr)
9016 {
9017     /* Create and return an inversion list whose contents are to be populated
9018      * by the caller.  The caller gives the number of elements (in 'size') and
9019      * the very first element ('element0').  This function will set
9020      * '*other_elements_ptr' to an array of UVs, where the remaining elements
9021      * are to be placed.
9022      *
9023      * Obviously there is some trust involved that the caller will properly
9024      * fill in the other elements of the array.
9025      *
9026      * (The first element needs to be passed in, as the underlying code does
9027      * things differently depending on whether it is zero or non-zero) */
9028
9029     SV* invlist = _new_invlist(size);
9030     bool offset;
9031
9032     PERL_ARGS_ASSERT__SETUP_CANNED_INVLIST;
9033
9034     _append_range_to_invlist(invlist, element0, element0);
9035     offset = *get_invlist_offset_addr(invlist);
9036
9037     invlist_set_len(invlist, size, offset);
9038     *other_elements_ptr = invlist_array(invlist) + 1;
9039     return invlist;
9040 }
9041
9042 #endif
9043
9044 PERL_STATIC_INLINE SV*
9045 S_add_cp_to_invlist(pTHX_ SV* invlist, const UV cp) {
9046     return _add_range_to_invlist(invlist, cp, cp);
9047 }
9048
9049 #ifndef PERL_IN_XSUB_RE
9050 void
9051 Perl__invlist_invert(pTHX_ SV* const invlist)
9052 {
9053     /* Complement the input inversion list.  This adds a 0 if the list didn't
9054      * have a zero; removes it otherwise.  As described above, the data
9055      * structure is set up so that this is very efficient */
9056
9057     PERL_ARGS_ASSERT__INVLIST_INVERT;
9058
9059     assert(! invlist_is_iterating(invlist));
9060
9061     /* The inverse of matching nothing is matching everything */
9062     if (_invlist_len(invlist) == 0) {
9063         _append_range_to_invlist(invlist, 0, UV_MAX);
9064         return;
9065     }
9066
9067     *get_invlist_offset_addr(invlist) = ! *get_invlist_offset_addr(invlist);
9068 }
9069
9070 #endif
9071
9072 PERL_STATIC_INLINE SV*
9073 S_invlist_clone(pTHX_ SV* const invlist)
9074 {
9075
9076     /* Return a new inversion list that is a copy of the input one, which is
9077      * unchanged.  The new list will not be mortal even if the old one was. */
9078
9079     /* Need to allocate extra space to accommodate Perl's addition of a
9080      * trailing NUL to SvPV's, since it thinks they are always strings */
9081     SV* new_invlist = _new_invlist(_invlist_len(invlist) + 1);
9082     STRLEN physical_length = SvCUR(invlist);
9083     bool offset = *(get_invlist_offset_addr(invlist));
9084
9085     PERL_ARGS_ASSERT_INVLIST_CLONE;
9086
9087     *(get_invlist_offset_addr(new_invlist)) = offset;
9088     invlist_set_len(new_invlist, _invlist_len(invlist), offset);
9089     Copy(SvPVX(invlist), SvPVX(new_invlist), physical_length, char);
9090
9091     return new_invlist;
9092 }
9093
9094 PERL_STATIC_INLINE STRLEN*
9095 S_get_invlist_iter_addr(SV* invlist)
9096 {
9097     /* Return the address of the UV that contains the current iteration
9098      * position */
9099
9100     PERL_ARGS_ASSERT_GET_INVLIST_ITER_ADDR;
9101
9102     assert(SvTYPE(invlist) == SVt_INVLIST);
9103
9104     return &(((XINVLIST*) SvANY(invlist))->iterator);
9105 }
9106
9107 PERL_STATIC_INLINE void
9108 S_invlist_iterinit(SV* invlist) /* Initialize iterator for invlist */
9109 {
9110     PERL_ARGS_ASSERT_INVLIST_ITERINIT;
9111
9112     *get_invlist_iter_addr(invlist) = 0;
9113 }
9114
9115 PERL_STATIC_INLINE void
9116 S_invlist_iterfinish(SV* invlist)
9117 {
9118     /* Terminate iterator for invlist.  This is to catch development errors.
9119      * Any iteration that is interrupted before completed should call this
9120      * function.  Functions that add code points anywhere else but to the end
9121      * of an inversion list assert that they are not in the middle of an
9122      * iteration.  If they were, the addition would make the iteration
9123      * problematical: if the iteration hadn't reached the place where things
9124      * were being added, it would be ok */
9125
9126     PERL_ARGS_ASSERT_INVLIST_ITERFINISH;
9127
9128     *get_invlist_iter_addr(invlist) = (STRLEN) UV_MAX;
9129 }
9130
9131 STATIC bool
9132 S_invlist_iternext(SV* invlist, UV* start, UV* end)
9133 {
9134     /* An C<invlist_iterinit> call on <invlist> must be used to set this up.
9135      * This call sets in <*start> and <*end>, the next range in <invlist>.
9136      * Returns <TRUE> if successful and the next call will return the next
9137      * range; <FALSE> if was already at the end of the list.  If the latter,
9138      * <*start> and <*end> are unchanged, and the next call to this function
9139      * will start over at the beginning of the list */
9140
9141     STRLEN* pos = get_invlist_iter_addr(invlist);
9142     UV len = _invlist_len(invlist);
9143     UV *array;
9144
9145     PERL_ARGS_ASSERT_INVLIST_ITERNEXT;
9146
9147     if (*pos >= len) {
9148         *pos = (STRLEN) UV_MAX; /* Force iterinit() to be required next time */
9149         return FALSE;
9150     }
9151
9152     array = invlist_array(invlist);
9153
9154     *start = array[(*pos)++];
9155
9156     if (*pos >= len) {
9157         *end = UV_MAX;
9158     }
9159     else {
9160         *end = array[(*pos)++] - 1;
9161     }
9162
9163     return TRUE;
9164 }
9165
9166 PERL_STATIC_INLINE UV
9167 S_invlist_highest(SV* const invlist)
9168 {
9169     /* Returns the highest code point that matches an inversion list.  This API
9170      * has an ambiguity, as it returns 0 under either the highest is actually
9171      * 0, or if the list is empty.  If this distinction matters to you, check
9172      * for emptiness before calling this function */
9173
9174     UV len = _invlist_len(invlist);
9175     UV *array;
9176
9177     PERL_ARGS_ASSERT_INVLIST_HIGHEST;
9178
9179     if (len == 0) {
9180         return 0;
9181     }
9182
9183     array = invlist_array(invlist);
9184
9185     /* The last element in the array in the inversion list always starts a
9186      * range that goes to infinity.  That range may be for code points that are
9187      * matched in the inversion list, or it may be for ones that aren't
9188      * matched.  In the latter case, the highest code point in the set is one
9189      * less than the beginning of this range; otherwise it is the final element
9190      * of this range: infinity */
9191     return (ELEMENT_RANGE_MATCHES_INVLIST(len - 1))
9192            ? UV_MAX
9193            : array[len - 1] - 1;
9194 }
9195
9196 #ifndef PERL_IN_XSUB_RE
9197 SV *
9198 Perl__invlist_contents(pTHX_ SV* const invlist)
9199 {
9200     /* Get the contents of an inversion list into a string SV so that they can
9201      * be printed out.  It uses the format traditionally done for debug tracing
9202      */
9203
9204     UV start, end;
9205     SV* output = newSVpvs("\n");
9206
9207     PERL_ARGS_ASSERT__INVLIST_CONTENTS;
9208
9209     assert(! invlist_is_iterating(invlist));
9210
9211     invlist_iterinit(invlist);
9212     while (invlist_iternext(invlist, &start, &end)) {
9213         if (end == UV_MAX) {
9214             Perl_sv_catpvf(aTHX_ output, "%04"UVXf"\tINFINITY\n", start);
9215         }
9216         else if (end != start) {
9217             Perl_sv_catpvf(aTHX_ output, "%04"UVXf"\t%04"UVXf"\n",
9218                     start,       end);
9219         }
9220         else {
9221             Perl_sv_catpvf(aTHX_ output, "%04"UVXf"\n", start);
9222         }
9223     }
9224
9225     return output;
9226 }
9227 #endif
9228
9229 #ifndef PERL_IN_XSUB_RE
9230 void
9231 Perl__invlist_dump(pTHX_ PerlIO *file, I32 level,
9232                          const char * const indent, SV* const invlist)
9233 {
9234     /* Designed to be called only by do_sv_dump().  Dumps out the ranges of the
9235      * inversion list 'invlist' to 'file' at 'level'  Each line is prefixed by
9236      * the string 'indent'.  The output looks like this:
9237          [0] 0x000A .. 0x000D
9238          [2] 0x0085
9239          [4] 0x2028 .. 0x2029
9240          [6] 0x3104 .. INFINITY
9241      * This means that the first range of code points matched by the list are
9242      * 0xA through 0xD; the second range contains only the single code point
9243      * 0x85, etc.  An inversion list is an array of UVs.  Two array elements
9244      * are used to define each range (except if the final range extends to
9245      * infinity, only a single element is needed).  The array index of the
9246      * first element for the corresponding range is given in brackets. */
9247
9248     UV start, end;
9249     STRLEN count = 0;
9250
9251     PERL_ARGS_ASSERT__INVLIST_DUMP;
9252
9253     if (invlist_is_iterating(invlist)) {
9254         Perl_dump_indent(aTHX_ level, file,
9255              "%sCan't dump inversion list because is in middle of iterating\n",
9256              indent);
9257         return;
9258     }
9259
9260     invlist_iterinit(invlist);
9261     while (invlist_iternext(invlist, &start, &end)) {
9262         if (end == UV_MAX) {
9263             Perl_dump_indent(aTHX_ level, file,
9264                                        "%s[%"UVuf"] 0x%04"UVXf" .. INFINITY\n",
9265                                    indent, (UV)count, start);
9266         }
9267         else if (end != start) {
9268             Perl_dump_indent(aTHX_ level, file,
9269                                     "%s[%"UVuf"] 0x%04"UVXf" .. 0x%04"UVXf"\n",
9270                                 indent, (UV)count, start,         end);
9271         }
9272         else {
9273             Perl_dump_indent(aTHX_ level, file, "%s[%"UVuf"] 0x%04"UVXf"\n",
9274                                             indent, (UV)count, start);
9275         }
9276         count += 2;
9277     }
9278 }
9279
9280 void
9281 Perl__load_PL_utf8_foldclosures (pTHX)
9282 {
9283     assert(! PL_utf8_foldclosures);
9284
9285     /* If the folds haven't been read in, call a fold function
9286      * to force that */
9287     if (! PL_utf8_tofold) {
9288         U8 dummy[UTF8_MAXBYTES_CASE+1];
9289
9290         /* This string is just a short named one above \xff */
9291         to_utf8_fold((U8*) HYPHEN_UTF8, dummy, NULL);
9292         assert(PL_utf8_tofold); /* Verify that worked */
9293     }
9294     PL_utf8_foldclosures = _swash_inversion_hash(PL_utf8_tofold);
9295 }
9296 #endif
9297
9298 #ifdef PERL_ARGS_ASSERT__INVLISTEQ
9299 bool
9300 S__invlistEQ(pTHX_ SV* const a, SV* const b, const bool complement_b)
9301 {
9302     /* Return a boolean as to if the two passed in inversion lists are
9303      * identical.  The final argument, if TRUE, says to take the complement of
9304      * the second inversion list before doing the comparison */
9305
9306     const UV* array_a = invlist_array(a);
9307     const UV* array_b = invlist_array(b);
9308     UV len_a = _invlist_len(a);
9309     UV len_b = _invlist_len(b);
9310
9311     UV i = 0;               /* current index into the arrays */
9312     bool retval = TRUE;     /* Assume are identical until proven otherwise */
9313
9314     PERL_ARGS_ASSERT__INVLISTEQ;
9315
9316     /* If are to compare 'a' with the complement of b, set it
9317      * up so are looking at b's complement. */
9318     if (complement_b) {
9319
9320         /* The complement of nothing is everything, so <a> would have to have
9321          * just one element, starting at zero (ending at infinity) */
9322         if (len_b == 0) {
9323             return (len_a == 1 && array_a[0] == 0);
9324         }
9325         else if (array_b[0] == 0) {
9326
9327             /* Otherwise, to complement, we invert.  Here, the first element is
9328              * 0, just remove it.  To do this, we just pretend the array starts
9329              * one later */
9330
9331             array_b++;
9332             len_b--;
9333         }
9334         else {
9335
9336             /* But if the first element is not zero, we pretend the list starts
9337              * at the 0 that is always stored immediately before the array. */
9338             array_b--;
9339             len_b++;
9340         }
9341     }
9342
9343     /* Make sure that the lengths are the same, as well as the final element
9344      * before looping through the remainder.  (Thus we test the length, final,
9345      * and first elements right off the bat) */
9346     if (len_a != len_b || array_a[len_a-1] != array_b[len_a-1]) {
9347         retval = FALSE;
9348     }
9349     else for (i = 0; i < len_a - 1; i++) {
9350         if (array_a[i] != array_b[i]) {
9351             retval = FALSE;
9352             break;
9353         }
9354     }
9355
9356     return retval;
9357 }
9358 #endif
9359
9360 /*
9361  * As best we can, determine the characters that can match the start of
9362  * the given EXACTF-ish node.
9363  *
9364  * Returns the invlist as a new SV*; it is the caller's responsibility to
9365  * call SvREFCNT_dec() when done with it.
9366  */
9367 STATIC SV*
9368 S__make_exactf_invlist(pTHX_ RExC_state_t *pRExC_state, regnode *node)
9369 {
9370     const U8 * s = (U8*)STRING(node);
9371     SSize_t bytelen = STR_LEN(node);
9372     UV uc;
9373     /* Start out big enough for 2 separate code points */
9374     SV* invlist = _new_invlist(4);
9375
9376     PERL_ARGS_ASSERT__MAKE_EXACTF_INVLIST;
9377
9378     if (! UTF) {
9379         uc = *s;
9380
9381         /* We punt and assume can match anything if the node begins
9382          * with a multi-character fold.  Things are complicated.  For
9383          * example, /ffi/i could match any of:
9384          *  "\N{LATIN SMALL LIGATURE FFI}"
9385          *  "\N{LATIN SMALL LIGATURE FF}I"
9386          *  "F\N{LATIN SMALL LIGATURE FI}"
9387          *  plus several other things; and making sure we have all the
9388          *  possibilities is hard. */
9389         if (is_MULTI_CHAR_FOLD_latin1_safe(s, s + bytelen)) {
9390             invlist = _add_range_to_invlist(invlist, 0, UV_MAX);
9391         }
9392         else {
9393             /* Any Latin1 range character can potentially match any
9394              * other depending on the locale */
9395             if (OP(node) == EXACTFL) {
9396                 _invlist_union(invlist, PL_Latin1, &invlist);
9397             }
9398             else {
9399                 /* But otherwise, it matches at least itself.  We can
9400                  * quickly tell if it has a distinct fold, and if so,
9401                  * it matches that as well */
9402                 invlist = add_cp_to_invlist(invlist, uc);
9403                 if (IS_IN_SOME_FOLD_L1(uc))
9404                     invlist = add_cp_to_invlist(invlist, PL_fold_latin1[uc]);
9405             }
9406
9407             /* Some characters match above-Latin1 ones under /i.  This
9408              * is true of EXACTFL ones when the locale is UTF-8 */
9409             if (HAS_NONLATIN1_SIMPLE_FOLD_CLOSURE(uc)
9410                 && (! isASCII(uc) || (OP(node) != EXACTFA
9411                                     && OP(node) != EXACTFA_NO_TRIE)))
9412             {
9413                 add_above_Latin1_folds(pRExC_state, (U8) uc, &invlist);
9414             }
9415         }
9416     }
9417     else {  /* Pattern is UTF-8 */
9418         U8 folded[UTF8_MAX_FOLD_CHAR_EXPAND * UTF8_MAXBYTES_CASE + 1] = { '\0' };
9419         STRLEN foldlen = UTF8SKIP(s);
9420         const U8* e = s + bytelen;
9421         SV** listp;
9422
9423         uc = utf8_to_uvchr_buf(s, s + bytelen, NULL);
9424
9425         /* The only code points that aren't folded in a UTF EXACTFish
9426          * node are are the problematic ones in EXACTFL nodes */
9427         if (OP(node) == EXACTFL && is_PROBLEMATIC_LOCALE_FOLDEDS_START_cp(uc)) {
9428             /* We need to check for the possibility that this EXACTFL
9429              * node begins with a multi-char fold.  Therefore we fold
9430              * the first few characters of it so that we can make that
9431              * check */
9432             U8 *d = folded;
9433             int i;
9434
9435             for (i = 0; i < UTF8_MAX_FOLD_CHAR_EXPAND && s < e; i++) {
9436                 if (isASCII(*s)) {
9437                     *(d++) = (U8) toFOLD(*s);
9438                     s++;
9439                 }
9440                 else {
9441                     STRLEN len;
9442                     to_utf8_fold(s, d, &len);
9443                     d += len;
9444                     s += UTF8SKIP(s);
9445                 }
9446             }
9447
9448             /* And set up so the code below that looks in this folded
9449              * buffer instead of the node's string */
9450             e = d;
9451             foldlen = UTF8SKIP(folded);
9452             s = folded;
9453         }
9454
9455         /* When we reach here 's' points to the fold of the first
9456          * character(s) of the node; and 'e' points to far enough along
9457          * the folded string to be just past any possible multi-char
9458          * fold. 'foldlen' is the length in bytes of the first
9459          * character in 's'
9460          *
9461          * Unlike the non-UTF-8 case, the macro for determining if a
9462          * string is a multi-char fold requires all the characters to
9463          * already be folded.  This is because of all the complications
9464          * if not.  Note that they are folded anyway, except in EXACTFL
9465          * nodes.  Like the non-UTF case above, we punt if the node
9466          * begins with a multi-char fold  */
9467
9468         if (is_MULTI_CHAR_FOLD_utf8_safe(s, e)) {
9469             invlist = _add_range_to_invlist(invlist, 0, UV_MAX);
9470         }
9471         else {  /* Single char fold */
9472
9473             /* It matches all the things that fold to it, which are
9474              * found in PL_utf8_foldclosures (including itself) */
9475             invlist = add_cp_to_invlist(invlist, uc);
9476             if (! PL_utf8_foldclosures)
9477                 _load_PL_utf8_foldclosures();
9478             if ((listp = hv_fetch(PL_utf8_foldclosures,
9479                                 (char *) s, foldlen, FALSE)))
9480             {
9481                 AV* list = (AV*) *listp;
9482                 IV k;
9483                 for (k = 0; k <= av_tindex(list); k++) {
9484                     SV** c_p = av_fetch(list, k, FALSE);
9485                     UV c;
9486                     assert(c_p);
9487
9488                     c = SvUV(*c_p);
9489
9490                     /* /aa doesn't allow folds between ASCII and non- */
9491                     if ((OP(node) == EXACTFA || OP(node) == EXACTFA_NO_TRIE)
9492                         && isASCII(c) != isASCII(uc))
9493                     {
9494                         continue;
9495                     }
9496
9497                     invlist = add_cp_to_invlist(invlist, c);
9498                 }
9499             }
9500         }
9501     }
9502
9503     return invlist;
9504 }
9505
9506 #undef HEADER_LENGTH
9507 #undef TO_INTERNAL_SIZE
9508 #undef FROM_INTERNAL_SIZE
9509 #undef INVLIST_VERSION_ID
9510
9511 /* End of inversion list object */
9512
9513 STATIC void
9514 S_parse_lparen_question_flags(pTHX_ RExC_state_t *pRExC_state)
9515 {
9516     /* This parses the flags that are in either the '(?foo)' or '(?foo:bar)'
9517      * constructs, and updates RExC_flags with them.  On input, RExC_parse
9518      * should point to the first flag; it is updated on output to point to the
9519      * final ')' or ':'.  There needs to be at least one flag, or this will
9520      * abort */
9521
9522     /* for (?g), (?gc), and (?o) warnings; warning
9523        about (?c) will warn about (?g) -- japhy    */
9524
9525 #define WASTED_O  0x01
9526 #define WASTED_G  0x02
9527 #define WASTED_C  0x04
9528 #define WASTED_GC (WASTED_G|WASTED_C)
9529     I32 wastedflags = 0x00;
9530     U32 posflags = 0, negflags = 0;
9531     U32 *flagsp = &posflags;
9532     char has_charset_modifier = '\0';
9533     regex_charset cs;
9534     bool has_use_defaults = FALSE;
9535     const char* const seqstart = RExC_parse - 1; /* Point to the '?' */
9536     int x_mod_count = 0;
9537
9538     PERL_ARGS_ASSERT_PARSE_LPAREN_QUESTION_FLAGS;
9539
9540     /* '^' as an initial flag sets certain defaults */
9541     if (UCHARAT(RExC_parse) == '^') {
9542         RExC_parse++;
9543         has_use_defaults = TRUE;
9544         STD_PMMOD_FLAGS_CLEAR(&RExC_flags);
9545         set_regex_charset(&RExC_flags, (RExC_utf8 || RExC_uni_semantics)
9546                                         ? REGEX_UNICODE_CHARSET
9547                                         : REGEX_DEPENDS_CHARSET);
9548     }
9549
9550     cs = get_regex_charset(RExC_flags);
9551     if (cs == REGEX_DEPENDS_CHARSET
9552         && (RExC_utf8 || RExC_uni_semantics))
9553     {
9554         cs = REGEX_UNICODE_CHARSET;
9555     }
9556
9557     while (*RExC_parse) {
9558         /* && strchr("iogcmsx", *RExC_parse) */
9559         /* (?g), (?gc) and (?o) are useless here
9560            and must be globally applied -- japhy */
9561         switch (*RExC_parse) {
9562
9563             /* Code for the imsxn flags */
9564             CASE_STD_PMMOD_FLAGS_PARSE_SET(flagsp, x_mod_count);
9565
9566             case LOCALE_PAT_MOD:
9567                 if (has_charset_modifier) {
9568                     goto excess_modifier;
9569                 }
9570                 else if (flagsp == &negflags) {
9571                     goto neg_modifier;
9572                 }
9573                 cs = REGEX_LOCALE_CHARSET;
9574                 has_charset_modifier = LOCALE_PAT_MOD;
9575                 break;
9576             case UNICODE_PAT_MOD:
9577                 if (has_charset_modifier) {
9578                     goto excess_modifier;
9579                 }
9580                 else if (flagsp == &negflags) {
9581                     goto neg_modifier;
9582                 }
9583                 cs = REGEX_UNICODE_CHARSET;
9584                 has_charset_modifier = UNICODE_PAT_MOD;
9585                 break;
9586             case ASCII_RESTRICT_PAT_MOD:
9587                 if (flagsp == &negflags) {
9588                     goto neg_modifier;
9589                 }
9590                 if (has_charset_modifier) {
9591                     if (cs != REGEX_ASCII_RESTRICTED_CHARSET) {
9592                         goto excess_modifier;
9593                     }
9594                     /* Doubled modifier implies more restricted */
9595                     cs = REGEX_ASCII_MORE_RESTRICTED_CHARSET;
9596                 }
9597                 else {
9598                     cs = REGEX_ASCII_RESTRICTED_CHARSET;
9599                 }
9600                 has_charset_modifier = ASCII_RESTRICT_PAT_MOD;
9601                 break;
9602             case DEPENDS_PAT_MOD:
9603                 if (has_use_defaults) {
9604                     goto fail_modifiers;
9605                 }
9606                 else if (flagsp == &negflags) {
9607                     goto neg_modifier;
9608                 }
9609                 else if (has_charset_modifier) {
9610                     goto excess_modifier;
9611                 }
9612
9613                 /* The dual charset means unicode semantics if the
9614                  * pattern (or target, not known until runtime) are
9615                  * utf8, or something in the pattern indicates unicode
9616                  * semantics */
9617                 cs = (RExC_utf8 || RExC_uni_semantics)
9618                      ? REGEX_UNICODE_CHARSET
9619                      : REGEX_DEPENDS_CHARSET;
9620                 has_charset_modifier = DEPENDS_PAT_MOD;
9621                 break;
9622               excess_modifier:
9623                 RExC_parse++;
9624                 if (has_charset_modifier == ASCII_RESTRICT_PAT_MOD) {
9625                     vFAIL2("Regexp modifier \"%c\" may appear a maximum of twice", ASCII_RESTRICT_PAT_MOD);
9626                 }
9627                 else if (has_charset_modifier == *(RExC_parse - 1)) {
9628                     vFAIL2("Regexp modifier \"%c\" may not appear twice",
9629                                         *(RExC_parse - 1));
9630                 }
9631                 else {
9632                     vFAIL3("Regexp modifiers \"%c\" and \"%c\" are mutually exclusive", has_charset_modifier, *(RExC_parse - 1));
9633                 }
9634                 NOT_REACHED; /*NOTREACHED*/
9635               neg_modifier:
9636                 RExC_parse++;
9637                 vFAIL2("Regexp modifier \"%c\" may not appear after the \"-\"",
9638                                     *(RExC_parse - 1));
9639                 NOT_REACHED; /*NOTREACHED*/
9640             case ONCE_PAT_MOD: /* 'o' */
9641             case GLOBAL_PAT_MOD: /* 'g' */
9642                 if (PASS2 && ckWARN(WARN_REGEXP)) {
9643                     const I32 wflagbit = *RExC_parse == 'o'
9644                                          ? WASTED_O
9645                                          : WASTED_G;
9646                     if (! (wastedflags & wflagbit) ) {
9647                         wastedflags |= wflagbit;
9648                         /* diag_listed_as: Useless (?-%s) - don't use /%s modifier in regex; marked by <-- HERE in m/%s/ */
9649                         vWARN5(
9650                             RExC_parse + 1,
9651                             "Useless (%s%c) - %suse /%c modifier",
9652                             flagsp == &negflags ? "?-" : "?",
9653                             *RExC_parse,
9654                             flagsp == &negflags ? "don't " : "",
9655                             *RExC_parse
9656                         );
9657                     }
9658                 }
9659                 break;
9660
9661             case CONTINUE_PAT_MOD: /* 'c' */
9662                 if (PASS2 && ckWARN(WARN_REGEXP)) {
9663                     if (! (wastedflags & WASTED_C) ) {
9664                         wastedflags |= WASTED_GC;
9665                         /* diag_listed_as: Useless (?-%s) - don't use /%s modifier in regex; marked by <-- HERE in m/%s/ */
9666                         vWARN3(
9667                             RExC_parse + 1,
9668                             "Useless (%sc) - %suse /gc modifier",
9669                             flagsp == &negflags ? "?-" : "?",
9670                             flagsp == &negflags ? "don't " : ""
9671                         );
9672                     }
9673                 }
9674                 break;
9675             case KEEPCOPY_PAT_MOD: /* 'p' */
9676                 if (flagsp == &negflags) {
9677                     if (PASS2)
9678                         ckWARNreg(RExC_parse + 1,"Useless use of (?-p)");
9679                 } else {
9680                     *flagsp |= RXf_PMf_KEEPCOPY;
9681                 }
9682                 break;
9683             case '-':
9684                 /* A flag is a default iff it is following a minus, so
9685                  * if there is a minus, it means will be trying to
9686                  * re-specify a default which is an error */
9687                 if (has_use_defaults || flagsp == &negflags) {
9688                     goto fail_modifiers;
9689                 }
9690                 flagsp = &negflags;
9691                 wastedflags = 0;  /* reset so (?g-c) warns twice */
9692                 break;
9693             case ':':
9694             case ')':
9695                 RExC_flags |= posflags;
9696                 RExC_flags &= ~negflags;
9697                 set_regex_charset(&RExC_flags, cs);
9698                 if (RExC_flags & RXf_PMf_FOLD) {
9699                     RExC_contains_i = 1;
9700                 }
9701                 if (PASS2) {
9702                     STD_PMMOD_FLAGS_PARSE_X_WARN(x_mod_count);
9703                 }
9704                 return;
9705                 /*NOTREACHED*/
9706             default:
9707               fail_modifiers:
9708                 RExC_parse += SKIP_IF_CHAR(RExC_parse);
9709                 /* diag_listed_as: Sequence (?%s...) not recognized in regex; marked by <-- HERE in m/%s/ */
9710                 vFAIL2utf8f("Sequence (%"UTF8f"...) not recognized",
9711                       UTF8fARG(UTF, RExC_parse-seqstart, seqstart));
9712                 NOT_REACHED; /*NOTREACHED*/
9713         }
9714
9715         ++RExC_parse;
9716     }
9717
9718     if (PASS2) {
9719         STD_PMMOD_FLAGS_PARSE_X_WARN(x_mod_count);
9720     }
9721 }
9722
9723 /*
9724  - reg - regular expression, i.e. main body or parenthesized thing
9725  *
9726  * Caller must absorb opening parenthesis.
9727  *
9728  * Combining parenthesis handling with the base level of regular expression
9729  * is a trifle forced, but the need to tie the tails of the branches to what
9730  * follows makes it hard to avoid.
9731  */
9732 #define REGTAIL(x,y,z) regtail((x),(y),(z),depth+1)
9733 #ifdef DEBUGGING
9734 #define REGTAIL_STUDY(x,y,z) regtail_study((x),(y),(z),depth+1)
9735 #else
9736 #define REGTAIL_STUDY(x,y,z) regtail((x),(y),(z),depth+1)
9737 #endif
9738
9739 /* Returns NULL, setting *flagp to TRYAGAIN at the end of (?) that only sets
9740    flags. Returns NULL, setting *flagp to RESTART_UTF8 if the sizing scan
9741    needs to be restarted.
9742    Otherwise would only return NULL if regbranch() returns NULL, which
9743    cannot happen.  */
9744 STATIC regnode *
9745 S_reg(pTHX_ RExC_state_t *pRExC_state, I32 paren, I32 *flagp,U32 depth)
9746     /* paren: Parenthesized? 0=top; 1,2=inside '(': changed to letter.
9747      * 2 is like 1, but indicates that nextchar() has been called to advance
9748      * RExC_parse beyond the '('.  Things like '(?' are indivisible tokens, and
9749      * this flag alerts us to the need to check for that */
9750 {
9751     regnode *ret;               /* Will be the head of the group. */
9752     regnode *br;
9753     regnode *lastbr;
9754     regnode *ender = NULL;
9755     I32 parno = 0;
9756     I32 flags;
9757     U32 oregflags = RExC_flags;
9758     bool have_branch = 0;
9759     bool is_open = 0;
9760     I32 freeze_paren = 0;
9761     I32 after_freeze = 0;
9762     I32 num; /* numeric backreferences */
9763
9764     char * parse_start = RExC_parse; /* MJD */
9765     char * const oregcomp_parse = RExC_parse;
9766
9767     GET_RE_DEBUG_FLAGS_DECL;
9768
9769     PERL_ARGS_ASSERT_REG;
9770     DEBUG_PARSE("reg ");
9771
9772     *flagp = 0;                         /* Tentatively. */
9773
9774
9775     /* Make an OPEN node, if parenthesized. */
9776     if (paren) {
9777
9778         /* Under /x, space and comments can be gobbled up between the '(' and
9779          * here (if paren ==2).  The forms '(*VERB' and '(?...' disallow such
9780          * intervening space, as the sequence is a token, and a token should be
9781          * indivisible */
9782         bool has_intervening_patws = paren == 2 && *(RExC_parse - 1) != '(';
9783
9784         if ( *RExC_parse == '*') { /* (*VERB:ARG) */
9785             char *start_verb = RExC_parse;
9786             STRLEN verb_len = 0;
9787             char *start_arg = NULL;
9788             unsigned char op = 0;
9789             int argok = 1;
9790             int internal_argval = 0; /* internal_argval is only useful if
9791                                         !argok */
9792
9793             if (has_intervening_patws) {
9794                 RExC_parse++;
9795                 vFAIL("In '(*VERB...)', the '(' and '*' must be adjacent");
9796             }
9797             while ( *RExC_parse && *RExC_parse != ')' ) {
9798                 if ( *RExC_parse == ':' ) {
9799                     start_arg = RExC_parse + 1;
9800                     break;
9801                 }
9802                 RExC_parse++;
9803             }
9804             ++start_verb;
9805             verb_len = RExC_parse - start_verb;
9806             if ( start_arg ) {
9807                 RExC_parse++;
9808                 while ( *RExC_parse && *RExC_parse != ')' )
9809                     RExC_parse++;
9810                 if ( *RExC_parse != ')' )
9811                     vFAIL("Unterminated verb pattern argument");
9812                 if ( RExC_parse == start_arg )
9813                     start_arg = NULL;
9814             } else {
9815                 if ( *RExC_parse != ')' )
9816                     vFAIL("Unterminated verb pattern");
9817             }
9818
9819             switch ( *start_verb ) {
9820             case 'A':  /* (*ACCEPT) */
9821                 if ( memEQs(start_verb,verb_len,"ACCEPT") ) {
9822                     op = ACCEPT;
9823                     internal_argval = RExC_nestroot;
9824                 }
9825                 break;
9826             case 'C':  /* (*COMMIT) */
9827                 if ( memEQs(start_verb,verb_len,"COMMIT") )
9828                     op = COMMIT;
9829                 break;
9830             case 'F':  /* (*FAIL) */
9831                 if ( verb_len==1 || memEQs(start_verb,verb_len,"FAIL") ) {
9832                     op = OPFAIL;
9833                     argok = 0;
9834                 }
9835                 break;
9836             case ':':  /* (*:NAME) */
9837             case 'M':  /* (*MARK:NAME) */
9838                 if ( verb_len==0 || memEQs(start_verb,verb_len,"MARK") ) {
9839                     op = MARKPOINT;
9840                     argok = -1;
9841                 }
9842                 break;
9843             case 'P':  /* (*PRUNE) */
9844                 if ( memEQs(start_verb,verb_len,"PRUNE") )
9845                     op = PRUNE;
9846                 break;
9847             case 'S':   /* (*SKIP) */
9848                 if ( memEQs(start_verb,verb_len,"SKIP") )
9849                     op = SKIP;
9850                 break;
9851             case 'T':  /* (*THEN) */
9852                 /* [19:06] <TimToady> :: is then */
9853                 if ( memEQs(start_verb,verb_len,"THEN") ) {
9854                     op = CUTGROUP;
9855                     RExC_seen |= REG_CUTGROUP_SEEN;
9856                 }
9857                 break;
9858             }
9859             if ( ! op ) {
9860                 RExC_parse += UTF ? UTF8SKIP(RExC_parse) : 1;
9861                 vFAIL2utf8f(
9862                     "Unknown verb pattern '%"UTF8f"'",
9863                     UTF8fARG(UTF, verb_len, start_verb));
9864             }
9865             if ( argok ) {
9866                 if ( start_arg && internal_argval ) {
9867                     vFAIL3("Verb pattern '%.*s' may not have an argument",
9868                         verb_len, start_verb);
9869                 } else if ( argok < 0 && !start_arg ) {
9870                     vFAIL3("Verb pattern '%.*s' has a mandatory argument",
9871                         verb_len, start_verb);
9872                 } else {
9873                     ret = reganode(pRExC_state, op, internal_argval);
9874                     if ( ! internal_argval && ! SIZE_ONLY ) {
9875                         if (start_arg) {
9876                             SV *sv = newSVpvn( start_arg,
9877                                                RExC_parse - start_arg);
9878                             ARG(ret) = add_data( pRExC_state,
9879                                                  STR_WITH_LEN("S"));
9880                             RExC_rxi->data->data[ARG(ret)]=(void*)sv;
9881                             ret->flags = 0;
9882                         } else {
9883                             ret->flags = 1;
9884                         }
9885                     }
9886                 }
9887                 if (!internal_argval)
9888                     RExC_seen |= REG_VERBARG_SEEN;
9889             } else if ( start_arg ) {
9890                 vFAIL3("Verb pattern '%.*s' may not have an argument",
9891                         verb_len, start_verb);
9892             } else {
9893                 ret = reg_node(pRExC_state, op);
9894             }
9895             nextchar(pRExC_state);
9896             return ret;
9897         }
9898         else if (*RExC_parse == '?') { /* (?...) */
9899             bool is_logical = 0;
9900             const char * const seqstart = RExC_parse;
9901             const char * endptr;
9902             if (has_intervening_patws) {
9903                 RExC_parse++;
9904                 vFAIL("In '(?...)', the '(' and '?' must be adjacent");
9905             }
9906
9907             RExC_parse++;
9908             paren = *RExC_parse++;
9909             ret = NULL;                 /* For look-ahead/behind. */
9910             switch (paren) {
9911
9912             case 'P':   /* (?P...) variants for those used to PCRE/Python */
9913                 paren = *RExC_parse++;
9914                 if ( paren == '<')         /* (?P<...>) named capture */
9915                     goto named_capture;
9916                 else if (paren == '>') {   /* (?P>name) named recursion */
9917                     goto named_recursion;
9918                 }
9919                 else if (paren == '=') {   /* (?P=...)  named backref */
9920                     /* this pretty much dupes the code for \k<NAME> in
9921                      * regatom(), if you change this make sure you change that
9922                      * */
9923                     char* name_start = RExC_parse;
9924                     U32 num = 0;
9925                     SV *sv_dat = reg_scan_name(pRExC_state,
9926                         SIZE_ONLY ? REG_RSN_RETURN_NULL : REG_RSN_RETURN_DATA);
9927                     if (RExC_parse == name_start || *RExC_parse != ')')
9928                         /* diag_listed_as: Sequence ?P=... not terminated in regex; marked by <-- HERE in m/%s/ */
9929                         vFAIL2("Sequence %.3s... not terminated",parse_start);
9930
9931                     if (!SIZE_ONLY) {
9932                         num = add_data( pRExC_state, STR_WITH_LEN("S"));
9933                         RExC_rxi->data->data[num]=(void*)sv_dat;
9934                         SvREFCNT_inc_simple_void(sv_dat);
9935                     }
9936                     RExC_sawback = 1;
9937                     ret = reganode(pRExC_state,
9938                                    ((! FOLD)
9939                                      ? NREF
9940                                      : (ASCII_FOLD_RESTRICTED)
9941                                        ? NREFFA
9942                                        : (AT_LEAST_UNI_SEMANTICS)
9943                                          ? NREFFU
9944                                          : (LOC)
9945                                            ? NREFFL
9946                                            : NREFF),
9947                                     num);
9948                     *flagp |= HASWIDTH;
9949
9950                     Set_Node_Offset(ret, parse_start+1);
9951                     Set_Node_Cur_Length(ret, parse_start);
9952
9953                     nextchar(pRExC_state);
9954                     return ret;
9955                 }
9956                 --RExC_parse;
9957                 RExC_parse += SKIP_IF_CHAR(RExC_parse);
9958                 /* diag_listed_as: Sequence (?%s...) not recognized in regex; marked by <-- HERE in m/%s/ */
9959                 vFAIL3("Sequence (%.*s...) not recognized",
9960                                 RExC_parse-seqstart, seqstart);
9961                 NOT_REACHED; /*NOTREACHED*/
9962             case '<':           /* (?<...) */
9963                 if (*RExC_parse == '!')
9964                     paren = ',';
9965                 else if (*RExC_parse != '=')
9966               named_capture:
9967                 {               /* (?<...>) */
9968                     char *name_start;
9969                     SV *svname;
9970                     paren= '>';
9971             case '\'':          /* (?'...') */
9972                     name_start= RExC_parse;
9973                     svname = reg_scan_name(pRExC_state,
9974                         SIZE_ONLY    /* reverse test from the others */
9975                         ? REG_RSN_RETURN_NAME
9976                         : REG_RSN_RETURN_NULL);
9977                     if (RExC_parse == name_start || *RExC_parse != paren)
9978                         vFAIL2("Sequence (?%c... not terminated",
9979                             paren=='>' ? '<' : paren);
9980                     if (SIZE_ONLY) {
9981                         HE *he_str;
9982                         SV *sv_dat = NULL;
9983                         if (!svname) /* shouldn't happen */
9984                             Perl_croak(aTHX_
9985                                 "panic: reg_scan_name returned NULL");
9986                         if (!RExC_paren_names) {
9987                             RExC_paren_names= newHV();
9988                             sv_2mortal(MUTABLE_SV(RExC_paren_names));
9989 #ifdef DEBUGGING
9990                             RExC_paren_name_list= newAV();
9991                             sv_2mortal(MUTABLE_SV(RExC_paren_name_list));
9992 #endif
9993                         }
9994                         he_str = hv_fetch_ent( RExC_paren_names, svname, 1, 0 );
9995                         if ( he_str )
9996                             sv_dat = HeVAL(he_str);
9997                         if ( ! sv_dat ) {
9998                             /* croak baby croak */
9999                             Perl_croak(aTHX_
10000                                 "panic: paren_name hash element allocation failed");
10001                         } else if ( SvPOK(sv_dat) ) {
10002                             /* (?|...) can mean we have dupes so scan to check
10003                                its already been stored. Maybe a flag indicating
10004                                we are inside such a construct would be useful,
10005                                but the arrays are likely to be quite small, so
10006                                for now we punt -- dmq */
10007                             IV count = SvIV(sv_dat);
10008                             I32 *pv = (I32*)SvPVX(sv_dat);
10009                             IV i;
10010                             for ( i = 0 ; i < count ; i++ ) {
10011                                 if ( pv[i] == RExC_npar ) {
10012                                     count = 0;
10013                                     break;
10014                                 }
10015                             }
10016                             if ( count ) {
10017                                 pv = (I32*)SvGROW(sv_dat,
10018                                                 SvCUR(sv_dat) + sizeof(I32)+1);
10019                                 SvCUR_set(sv_dat, SvCUR(sv_dat) + sizeof(I32));
10020                                 pv[count] = RExC_npar;
10021                                 SvIV_set(sv_dat, SvIVX(sv_dat) + 1);
10022                             }
10023                         } else {
10024                             (void)SvUPGRADE(sv_dat,SVt_PVNV);
10025                             sv_setpvn(sv_dat, (char *)&(RExC_npar),
10026                                                                 sizeof(I32));
10027                             SvIOK_on(sv_dat);
10028                             SvIV_set(sv_dat, 1);
10029                         }
10030 #ifdef DEBUGGING
10031                         /* Yes this does cause a memory leak in debugging Perls
10032                          * */
10033                         if (!av_store(RExC_paren_name_list,
10034                                       RExC_npar, SvREFCNT_inc(svname)))
10035                             SvREFCNT_dec_NN(svname);
10036 #endif
10037
10038                         /*sv_dump(sv_dat);*/
10039                     }
10040                     nextchar(pRExC_state);
10041                     paren = 1;
10042                     goto capturing_parens;
10043                 }
10044                 RExC_seen |= REG_LOOKBEHIND_SEEN;
10045                 RExC_in_lookbehind++;
10046                 RExC_parse++;
10047                 /* FALLTHROUGH */
10048             case '=':           /* (?=...) */
10049                 RExC_seen_zerolen++;
10050                 break;
10051             case '!':           /* (?!...) */
10052                 RExC_seen_zerolen++;
10053                 /* check if we're really just a "FAIL" assertion */
10054                 --RExC_parse;
10055                 nextchar(pRExC_state);
10056                 if (*RExC_parse == ')') {
10057                     ret=reg_node(pRExC_state, OPFAIL);
10058                     nextchar(pRExC_state);
10059                     return ret;
10060                 }
10061                 break;
10062             case '|':           /* (?|...) */
10063                 /* branch reset, behave like a (?:...) except that
10064                    buffers in alternations share the same numbers */
10065                 paren = ':';
10066                 after_freeze = freeze_paren = RExC_npar;
10067                 break;
10068             case ':':           /* (?:...) */
10069             case '>':           /* (?>...) */
10070                 break;
10071             case '$':           /* (?$...) */
10072             case '@':           /* (?@...) */
10073                 vFAIL2("Sequence (?%c...) not implemented", (int)paren);
10074                 break;
10075             case '0' :           /* (?0) */
10076             case 'R' :           /* (?R) */
10077                 if (*RExC_parse != ')')
10078                     FAIL("Sequence (?R) not terminated");
10079                 ret = reg_node(pRExC_state, GOSTART);
10080                     RExC_seen |= REG_GOSTART_SEEN;
10081                 *flagp |= POSTPONED;
10082                 nextchar(pRExC_state);
10083                 return ret;
10084                 /*notreached*/
10085             /* named and numeric backreferences */
10086             case '&':            /* (?&NAME) */
10087                 parse_start = RExC_parse - 1;
10088               named_recursion:
10089                 {
10090                     SV *sv_dat = reg_scan_name(pRExC_state,
10091                         SIZE_ONLY ? REG_RSN_RETURN_NULL : REG_RSN_RETURN_DATA);
10092                      num = sv_dat ? *((I32 *)SvPVX(sv_dat)) : 0;
10093                 }
10094                 if (RExC_parse == RExC_end || *RExC_parse != ')')
10095                     vFAIL("Sequence (?&... not terminated");
10096                 goto gen_recurse_regop;
10097                 /* NOTREACHED */
10098             case '+':
10099                 if (!(RExC_parse[0] >= '1' && RExC_parse[0] <= '9')) {
10100                     RExC_parse++;
10101                     vFAIL("Illegal pattern");
10102                 }
10103                 goto parse_recursion;
10104                 /* NOTREACHED*/
10105             case '-': /* (?-1) */
10106                 if (!(RExC_parse[0] >= '1' && RExC_parse[0] <= '9')) {
10107                     RExC_parse--; /* rewind to let it be handled later */
10108                     goto parse_flags;
10109                 }
10110                 /* FALLTHROUGH */
10111             case '1': case '2': case '3': case '4': /* (?1) */
10112             case '5': case '6': case '7': case '8': case '9':
10113                 RExC_parse--;
10114               parse_recursion:
10115                 {
10116                     bool is_neg = FALSE;
10117                     UV unum;
10118                     parse_start = RExC_parse - 1; /* MJD */
10119                     if (*RExC_parse == '-') {
10120                         RExC_parse++;
10121                         is_neg = TRUE;
10122                     }
10123                     if (grok_atoUV(RExC_parse, &unum, &endptr)
10124                         && unum <= I32_MAX
10125                     ) {
10126                         num = (I32)unum;
10127                         RExC_parse = (char*)endptr;
10128                     } else
10129                         num = I32_MAX;
10130                     if (is_neg) {
10131                         /* Some limit for num? */
10132                         num = -num;
10133                     }
10134                 }
10135                 if (*RExC_parse!=')')
10136                     vFAIL("Expecting close bracket");
10137
10138               gen_recurse_regop:
10139                 if ( paren == '-' ) {
10140                     /*
10141                     Diagram of capture buffer numbering.
10142                     Top line is the normal capture buffer numbers
10143                     Bottom line is the negative indexing as from
10144                     the X (the (?-2))
10145
10146                     +   1 2    3 4 5 X          6 7
10147                        /(a(x)y)(a(b(c(?-2)d)e)f)(g(h))/
10148                     -   5 4    3 2 1 X          x x
10149
10150                     */
10151                     num = RExC_npar + num;
10152                     if (num < 1)  {
10153                         RExC_parse++;
10154                         vFAIL("Reference to nonexistent group");
10155                     }
10156                 } else if ( paren == '+' ) {
10157                     num = RExC_npar + num - 1;
10158                 }
10159
10160                 ret = reg2Lanode(pRExC_state, GOSUB, num, RExC_recurse_count);
10161                 if (!SIZE_ONLY) {
10162                     if (num > (I32)RExC_rx->nparens) {
10163                         RExC_parse++;
10164                         vFAIL("Reference to nonexistent group");
10165                     }
10166                     RExC_recurse_count++;
10167                     DEBUG_OPTIMISE_MORE_r(PerlIO_printf(Perl_debug_log,
10168                         "%*s%*s Recurse #%"UVuf" to %"IVdf"\n",
10169                               22, "|    |", (int)(depth * 2 + 1), "",
10170                               (UV)ARG(ret), (IV)ARG2L(ret)));
10171                 }
10172                 RExC_seen |= REG_RECURSE_SEEN;
10173                 Set_Node_Length(ret, 1 + regarglen[OP(ret)]); /* MJD */
10174                 Set_Node_Offset(ret, parse_start); /* MJD */
10175
10176                 *flagp |= POSTPONED;
10177                 nextchar(pRExC_state);
10178                 return ret;
10179
10180             /* NOTREACHED */
10181
10182             case '?':           /* (??...) */
10183                 is_logical = 1;
10184                 if (*RExC_parse != '{') {
10185                     RExC_parse += SKIP_IF_CHAR(RExC_parse);
10186                     /* diag_listed_as: Sequence (?%s...) not recognized in regex; marked by <-- HERE in m/%s/ */
10187                     vFAIL2utf8f(
10188                         "Sequence (%"UTF8f"...) not recognized",
10189                         UTF8fARG(UTF, RExC_parse-seqstart, seqstart));
10190                     NOT_REACHED; /*NOTREACHED*/
10191                 }
10192                 *flagp |= POSTPONED;
10193                 paren = *RExC_parse++;
10194                 /* FALLTHROUGH */
10195             case '{':           /* (?{...}) */
10196             {
10197                 U32 n = 0;
10198                 struct reg_code_block *cb;
10199
10200                 RExC_seen_zerolen++;
10201
10202                 if (   !pRExC_state->num_code_blocks
10203                     || pRExC_state->code_index >= pRExC_state->num_code_blocks
10204                     || pRExC_state->code_blocks[pRExC_state->code_index].start
10205                         != (STRLEN)((RExC_parse -3 - (is_logical ? 1 : 0))
10206                             - RExC_start)
10207                 ) {
10208                     if (RExC_pm_flags & PMf_USE_RE_EVAL)
10209                         FAIL("panic: Sequence (?{...}): no code block found\n");
10210                     FAIL("Eval-group not allowed at runtime, use re 'eval'");
10211                 }
10212                 /* this is a pre-compiled code block (?{...}) */
10213                 cb = &pRExC_state->code_blocks[pRExC_state->code_index];
10214                 RExC_parse = RExC_start + cb->end;
10215                 if (!SIZE_ONLY) {
10216                     OP *o = cb->block;
10217                     if (cb->src_regex) {
10218                         n = add_data(pRExC_state, STR_WITH_LEN("rl"));
10219                         RExC_rxi->data->data[n] =
10220                             (void*)SvREFCNT_inc((SV*)cb->src_regex);
10221                         RExC_rxi->data->data[n+1] = (void*)o;
10222                     }
10223                     else {
10224                         n = add_data(pRExC_state,
10225                                (RExC_pm_flags & PMf_HAS_CV) ? "L" : "l", 1);
10226                         RExC_rxi->data->data[n] = (void*)o;
10227                     }
10228                 }
10229                 pRExC_state->code_index++;
10230                 nextchar(pRExC_state);
10231
10232                 if (is_logical) {
10233                     regnode *eval;
10234                     ret = reg_node(pRExC_state, LOGICAL);
10235
10236                     eval = reg2Lanode(pRExC_state, EVAL,
10237                                        n,
10238
10239                                        /* for later propagation into (??{})
10240                                         * return value */
10241                                        RExC_flags & RXf_PMf_COMPILETIME
10242                                       );
10243                     if (!SIZE_ONLY) {
10244                         ret->flags = 2;
10245                     }
10246                     REGTAIL(pRExC_state, ret, eval);
10247                     /* deal with the length of this later - MJD */
10248                     return ret;
10249                 }
10250                 ret = reg2Lanode(pRExC_state, EVAL, n, 0);
10251                 Set_Node_Length(ret, RExC_parse - parse_start + 1);
10252                 Set_Node_Offset(ret, parse_start);
10253                 return ret;
10254             }
10255             case '(':           /* (?(?{...})...) and (?(?=...)...) */
10256             {
10257                 int is_define= 0;
10258                 const int DEFINE_len = sizeof("DEFINE") - 1;
10259                 if (RExC_parse[0] == '?') {        /* (?(?...)) */
10260                     if (RExC_parse[1] == '=' || RExC_parse[1] == '!'
10261                         || RExC_parse[1] == '<'
10262                         || RExC_parse[1] == '{') { /* Lookahead or eval. */
10263                         I32 flag;
10264                         regnode *tail;
10265
10266                         ret = reg_node(pRExC_state, LOGICAL);
10267                         if (!SIZE_ONLY)
10268                             ret->flags = 1;
10269
10270                         tail = reg(pRExC_state, 1, &flag, depth+1);
10271                         if (flag & RESTART_UTF8) {
10272                             *flagp = RESTART_UTF8;
10273                             return NULL;
10274                         }
10275                         REGTAIL(pRExC_state, ret, tail);
10276                         goto insert_if;
10277                     }
10278                     /* Fall through to ‘Unknown switch condition’ at the
10279                        end of the if/else chain. */
10280                 }
10281                 else if ( RExC_parse[0] == '<'     /* (?(<NAME>)...) */
10282                          || RExC_parse[0] == '\'' ) /* (?('NAME')...) */
10283                 {
10284                     char ch = RExC_parse[0] == '<' ? '>' : '\'';
10285                     char *name_start= RExC_parse++;
10286                     U32 num = 0;
10287                     SV *sv_dat=reg_scan_name(pRExC_state,
10288                         SIZE_ONLY ? REG_RSN_RETURN_NULL : REG_RSN_RETURN_DATA);
10289                     if (RExC_parse == name_start || *RExC_parse != ch)
10290                         vFAIL2("Sequence (?(%c... not terminated",
10291                             (ch == '>' ? '<' : ch));
10292                     RExC_parse++;
10293                     if (!SIZE_ONLY) {
10294                         num = add_data( pRExC_state, STR_WITH_LEN("S"));
10295                         RExC_rxi->data->data[num]=(void*)sv_dat;
10296                         SvREFCNT_inc_simple_void(sv_dat);
10297                     }
10298                     ret = reganode(pRExC_state,NGROUPP,num);
10299                     goto insert_if_check_paren;
10300                 }
10301                 else if (RExC_end - RExC_parse >= DEFINE_len
10302                         && strnEQ(RExC_parse, "DEFINE", DEFINE_len))
10303                 {
10304                     ret = reganode(pRExC_state,DEFINEP,0);
10305                     RExC_parse += DEFINE_len;
10306                     is_define = 1;
10307                     goto insert_if_check_paren;
10308                 }
10309                 else if (RExC_parse[0] == 'R') {
10310                     RExC_parse++;
10311                     parno = 0;
10312                     if (RExC_parse[0] >= '1' && RExC_parse[0] <= '9' ) {
10313                         UV uv;
10314                         if (grok_atoUV(RExC_parse, &uv, &endptr)
10315                             && uv <= I32_MAX
10316                         ) {
10317                             parno = (I32)uv;
10318                             RExC_parse = (char*)endptr;
10319                         }
10320                         /* else "Switch condition not recognized" below */
10321                     } else if (RExC_parse[0] == '&') {
10322                         SV *sv_dat;
10323                         RExC_parse++;
10324                         sv_dat = reg_scan_name(pRExC_state,
10325                             SIZE_ONLY
10326                             ? REG_RSN_RETURN_NULL
10327                             : REG_RSN_RETURN_DATA);
10328                         parno = sv_dat ? *((I32 *)SvPVX(sv_dat)) : 0;
10329                     }
10330                     ret = reganode(pRExC_state,INSUBP,parno);
10331                     goto insert_if_check_paren;
10332                 }
10333                 else if (RExC_parse[0] >= '1' && RExC_parse[0] <= '9' ) {
10334                     /* (?(1)...) */
10335                     char c;
10336                     char *tmp;
10337                     UV uv;
10338                     if (grok_atoUV(RExC_parse, &uv, &endptr)
10339                         && uv <= I32_MAX
10340                     ) {
10341                         parno = (I32)uv;
10342                         RExC_parse = (char*)endptr;
10343                     }
10344                     /* XXX else what? */
10345                     ret = reganode(pRExC_state, GROUPP, parno);
10346
10347                  insert_if_check_paren:
10348                     if (*(tmp = nextchar(pRExC_state)) != ')') {
10349                         /* nextchar also skips comments, so undo its work
10350                          * and skip over the the next character.
10351                          */
10352                         RExC_parse = tmp;
10353                         RExC_parse += UTF ? UTF8SKIP(RExC_parse) : 1;
10354                         vFAIL("Switch condition not recognized");
10355                     }
10356                   insert_if:
10357                     REGTAIL(pRExC_state, ret, reganode(pRExC_state, IFTHEN, 0));
10358                     br = regbranch(pRExC_state, &flags, 1,depth+1);
10359                     if (br == NULL) {
10360                         if (flags & RESTART_UTF8) {
10361                             *flagp = RESTART_UTF8;
10362                             return NULL;
10363                         }
10364                         FAIL2("panic: regbranch returned NULL, flags=%#"UVxf"",
10365                               (UV) flags);
10366                     } else
10367                         REGTAIL(pRExC_state, br, reganode(pRExC_state,
10368                                                           LONGJMP, 0));
10369                     c = *nextchar(pRExC_state);
10370                     if (flags&HASWIDTH)
10371                         *flagp |= HASWIDTH;
10372                     if (c == '|') {
10373                         if (is_define)
10374                             vFAIL("(?(DEFINE)....) does not allow branches");
10375
10376                         /* Fake one for optimizer.  */
10377                         lastbr = reganode(pRExC_state, IFTHEN, 0);
10378
10379                         if (!regbranch(pRExC_state, &flags, 1,depth+1)) {
10380                             if (flags & RESTART_UTF8) {
10381                                 *flagp = RESTART_UTF8;
10382                                 return NULL;
10383                             }
10384                             FAIL2("panic: regbranch returned NULL, flags=%#"UVxf"",
10385                                   (UV) flags);
10386                         }
10387                         REGTAIL(pRExC_state, ret, lastbr);
10388                         if (flags&HASWIDTH)
10389                             *flagp |= HASWIDTH;
10390                         c = *nextchar(pRExC_state);
10391                     }
10392                     else
10393                         lastbr = NULL;
10394                     if (c != ')') {
10395                         if (RExC_parse>RExC_end)
10396                             vFAIL("Switch (?(condition)... not terminated");
10397                         else
10398                             vFAIL("Switch (?(condition)... contains too many branches");
10399                     }
10400                     ender = reg_node(pRExC_state, TAIL);
10401                     REGTAIL(pRExC_state, br, ender);
10402                     if (lastbr) {
10403                         REGTAIL(pRExC_state, lastbr, ender);
10404                         REGTAIL(pRExC_state, NEXTOPER(NEXTOPER(lastbr)), ender);
10405                     }
10406                     else
10407                         REGTAIL(pRExC_state, ret, ender);
10408                     RExC_size++; /* XXX WHY do we need this?!!
10409                                     For large programs it seems to be required
10410                                     but I can't figure out why. -- dmq*/
10411                     return ret;
10412                 }
10413                 RExC_parse += UTF ? UTF8SKIP(RExC_parse) : 1;
10414                 vFAIL("Unknown switch condition (?(...))");
10415             }
10416             case '[':           /* (?[ ... ]) */
10417                 return handle_regex_sets(pRExC_state, NULL, flagp, depth,
10418                                          oregcomp_parse);
10419             case 0:
10420                 RExC_parse--; /* for vFAIL to print correctly */
10421                 vFAIL("Sequence (? incomplete");
10422                 break;
10423             default: /* e.g., (?i) */
10424                 --RExC_parse;
10425               parse_flags:
10426                 parse_lparen_question_flags(pRExC_state);
10427                 if (UCHARAT(RExC_parse) != ':') {
10428                     if (*RExC_parse)
10429                         nextchar(pRExC_state);
10430                     *flagp = TRYAGAIN;
10431                     return NULL;
10432                 }
10433                 paren = ':';
10434                 nextchar(pRExC_state);
10435                 ret = NULL;
10436                 goto parse_rest;
10437             } /* end switch */
10438         }
10439         else if (!(RExC_flags & RXf_PMf_NOCAPTURE)) {   /* (...) */
10440           capturing_parens:
10441             parno = RExC_npar;
10442             RExC_npar++;
10443
10444             ret = reganode(pRExC_state, OPEN, parno);
10445             if (!SIZE_ONLY ){
10446                 if (!RExC_nestroot)
10447                     RExC_nestroot = parno;
10448                 if (RExC_seen & REG_RECURSE_SEEN
10449                     && !RExC_open_parens[parno-1])
10450                 {
10451                     DEBUG_OPTIMISE_MORE_r(PerlIO_printf(Perl_debug_log,
10452                         "%*s%*s Setting open paren #%"IVdf" to %d\n",
10453                         22, "|    |", (int)(depth * 2 + 1), "",
10454                         (IV)parno, REG_NODE_NUM(ret)));
10455                     RExC_open_parens[parno-1]= ret;
10456                 }
10457             }
10458             Set_Node_Length(ret, 1); /* MJD */
10459             Set_Node_Offset(ret, RExC_parse); /* MJD */
10460             is_open = 1;
10461         } else {
10462             /* with RXf_PMf_NOCAPTURE treat (...) as (?:...) */
10463             paren = ':';
10464             ret = NULL;
10465         }
10466     }
10467     else                        /* ! paren */
10468         ret = NULL;
10469
10470    parse_rest:
10471     /* Pick up the branches, linking them together. */
10472     parse_start = RExC_parse;   /* MJD */
10473     br = regbranch(pRExC_state, &flags, 1,depth+1);
10474
10475     /*     branch_len = (paren != 0); */
10476
10477     if (br == NULL) {
10478         if (flags & RESTART_UTF8) {
10479             *flagp = RESTART_UTF8;
10480             return NULL;
10481         }
10482         FAIL2("panic: regbranch returned NULL, flags=%#"UVxf"", (UV) flags);
10483     }
10484     if (*RExC_parse == '|') {
10485         if (!SIZE_ONLY && RExC_extralen) {
10486             reginsert(pRExC_state, BRANCHJ, br, depth+1);
10487         }
10488         else {                  /* MJD */
10489             reginsert(pRExC_state, BRANCH, br, depth+1);
10490             Set_Node_Length(br, paren != 0);
10491             Set_Node_Offset_To_R(br-RExC_emit_start, parse_start-RExC_start);
10492         }
10493         have_branch = 1;
10494         if (SIZE_ONLY)
10495             RExC_extralen += 1;         /* For BRANCHJ-BRANCH. */
10496     }
10497     else if (paren == ':') {
10498         *flagp |= flags&SIMPLE;
10499     }
10500     if (is_open) {                              /* Starts with OPEN. */
10501         REGTAIL(pRExC_state, ret, br);          /* OPEN -> first. */
10502     }
10503     else if (paren != '?')              /* Not Conditional */
10504         ret = br;
10505     *flagp |= flags & (SPSTART | HASWIDTH | POSTPONED);
10506     lastbr = br;
10507     while (*RExC_parse == '|') {
10508         if (!SIZE_ONLY && RExC_extralen) {
10509             ender = reganode(pRExC_state, LONGJMP,0);
10510
10511             /* Append to the previous. */
10512             REGTAIL(pRExC_state, NEXTOPER(NEXTOPER(lastbr)), ender);
10513         }
10514         if (SIZE_ONLY)
10515             RExC_extralen += 2;         /* Account for LONGJMP. */
10516         nextchar(pRExC_state);
10517         if (freeze_paren) {
10518             if (RExC_npar > after_freeze)
10519                 after_freeze = RExC_npar;
10520             RExC_npar = freeze_paren;
10521         }
10522         br = regbranch(pRExC_state, &flags, 0, depth+1);
10523
10524         if (br == NULL) {
10525             if (flags & RESTART_UTF8) {
10526                 *flagp = RESTART_UTF8;
10527                 return NULL;
10528             }
10529             FAIL2("panic: regbranch returned NULL, flags=%#"UVxf"", (UV) flags);
10530         }
10531         REGTAIL(pRExC_state, lastbr, br);               /* BRANCH -> BRANCH. */
10532         lastbr = br;
10533         *flagp |= flags & (SPSTART | HASWIDTH | POSTPONED);
10534     }
10535
10536     if (have_branch || paren != ':') {
10537         /* Make a closing node, and hook it on the end. */
10538         switch (paren) {
10539         case ':':
10540             ender = reg_node(pRExC_state, TAIL);
10541             break;
10542         case 1: case 2:
10543             ender = reganode(pRExC_state, CLOSE, parno);
10544             if (!SIZE_ONLY && RExC_seen & REG_RECURSE_SEEN) {
10545                 DEBUG_OPTIMISE_MORE_r(PerlIO_printf(Perl_debug_log,
10546                         "%*s%*s Setting close paren #%"IVdf" to %d\n",
10547                         22, "|    |", (int)(depth * 2 + 1), "", (IV)parno, REG_NODE_NUM(ender)));
10548                 RExC_close_parens[parno-1]= ender;
10549                 if (RExC_nestroot == parno)
10550                     RExC_nestroot = 0;
10551             }
10552             Set_Node_Offset(ender,RExC_parse+1); /* MJD */
10553             Set_Node_Length(ender,1); /* MJD */
10554             break;
10555         case '<':
10556         case ',':
10557         case '=':
10558         case '!':
10559             *flagp &= ~HASWIDTH;
10560             /* FALLTHROUGH */
10561         case '>':
10562             ender = reg_node(pRExC_state, SUCCEED);
10563             break;
10564         case 0:
10565             ender = reg_node(pRExC_state, END);
10566             if (!SIZE_ONLY) {
10567                 assert(!RExC_opend); /* there can only be one! */
10568                 RExC_opend = ender;
10569             }
10570             break;
10571         }
10572         DEBUG_PARSE_r(if (!SIZE_ONLY) {
10573             DEBUG_PARSE_MSG("lsbr");
10574             regprop(RExC_rx, RExC_mysv1, lastbr, NULL, pRExC_state);
10575             regprop(RExC_rx, RExC_mysv2, ender, NULL, pRExC_state);
10576             PerlIO_printf(Perl_debug_log, "~ tying lastbr %s (%"IVdf") to ender %s (%"IVdf") offset %"IVdf"\n",
10577                           SvPV_nolen_const(RExC_mysv1),
10578                           (IV)REG_NODE_NUM(lastbr),
10579                           SvPV_nolen_const(RExC_mysv2),
10580                           (IV)REG_NODE_NUM(ender),
10581                           (IV)(ender - lastbr)
10582             );
10583         });
10584         REGTAIL(pRExC_state, lastbr, ender);
10585
10586         if (have_branch && !SIZE_ONLY) {
10587             char is_nothing= 1;
10588             if (depth==1)
10589                 RExC_seen |= REG_TOP_LEVEL_BRANCHES_SEEN;
10590
10591             /* Hook the tails of the branches to the closing node. */
10592             for (br = ret; br; br = regnext(br)) {
10593                 const U8 op = PL_regkind[OP(br)];
10594                 if (op == BRANCH) {
10595                     REGTAIL_STUDY(pRExC_state, NEXTOPER(br), ender);
10596                     if ( OP(NEXTOPER(br)) != NOTHING
10597                          || regnext(NEXTOPER(br)) != ender)
10598                         is_nothing= 0;
10599                 }
10600                 else if (op == BRANCHJ) {
10601                     REGTAIL_STUDY(pRExC_state, NEXTOPER(NEXTOPER(br)), ender);
10602                     /* for now we always disable this optimisation * /
10603                     if ( OP(NEXTOPER(NEXTOPER(br))) != NOTHING
10604                          || regnext(NEXTOPER(NEXTOPER(br))) != ender)
10605                     */
10606                         is_nothing= 0;
10607                 }
10608             }
10609             if (is_nothing) {
10610                 br= PL_regkind[OP(ret)] != BRANCH ? regnext(ret) : ret;
10611                 DEBUG_PARSE_r(if (!SIZE_ONLY) {
10612                     DEBUG_PARSE_MSG("NADA");
10613                     regprop(RExC_rx, RExC_mysv1, ret, NULL, pRExC_state);
10614                     regprop(RExC_rx, RExC_mysv2, ender, NULL, pRExC_state);
10615                     PerlIO_printf(Perl_debug_log, "~ converting ret %s (%"IVdf") to ender %s (%"IVdf") offset %"IVdf"\n",
10616                                   SvPV_nolen_const(RExC_mysv1),
10617                                   (IV)REG_NODE_NUM(ret),
10618                                   SvPV_nolen_const(RExC_mysv2),
10619                                   (IV)REG_NODE_NUM(ender),
10620                                   (IV)(ender - ret)
10621                     );
10622                 });
10623                 OP(br)= NOTHING;
10624                 if (OP(ender) == TAIL) {
10625                     NEXT_OFF(br)= 0;
10626                     RExC_emit= br + 1;
10627                 } else {
10628                     regnode *opt;
10629                     for ( opt= br + 1; opt < ender ; opt++ )
10630                         OP(opt)= OPTIMIZED;
10631                     NEXT_OFF(br)= ender - br;
10632                 }
10633             }
10634         }
10635     }
10636
10637     {
10638         const char *p;
10639         static const char parens[] = "=!<,>";
10640
10641         if (paren && (p = strchr(parens, paren))) {
10642             U8 node = ((p - parens) % 2) ? UNLESSM : IFMATCH;
10643             int flag = (p - parens) > 1;
10644
10645             if (paren == '>')
10646                 node = SUSPEND, flag = 0;
10647             reginsert(pRExC_state, node,ret, depth+1);
10648             Set_Node_Cur_Length(ret, parse_start);
10649             Set_Node_Offset(ret, parse_start + 1);
10650             ret->flags = flag;
10651             REGTAIL_STUDY(pRExC_state, ret, reg_node(pRExC_state, TAIL));
10652         }
10653     }
10654
10655     /* Check for proper termination. */
10656     if (paren) {
10657         /* restore original flags, but keep (?p) */
10658         RExC_flags = oregflags | (RExC_flags & RXf_PMf_KEEPCOPY);
10659         if (RExC_parse >= RExC_end || *nextchar(pRExC_state) != ')') {
10660             RExC_parse = oregcomp_parse;
10661             vFAIL("Unmatched (");
10662         }
10663     }
10664     else if (!paren && RExC_parse < RExC_end) {
10665         if (*RExC_parse == ')') {
10666             RExC_parse++;
10667             vFAIL("Unmatched )");
10668         }
10669         else
10670             FAIL("Junk on end of regexp");      /* "Can't happen". */
10671         NOT_REACHED; /* NOTREACHED */
10672     }
10673
10674     if (RExC_in_lookbehind) {
10675         RExC_in_lookbehind--;
10676     }
10677     if (after_freeze > RExC_npar)
10678         RExC_npar = after_freeze;
10679     return(ret);
10680 }
10681
10682 /*
10683  - regbranch - one alternative of an | operator
10684  *
10685  * Implements the concatenation operator.
10686  *
10687  * Returns NULL, setting *flagp to RESTART_UTF8 if the sizing scan needs to be
10688  * restarted.
10689  */
10690 STATIC regnode *
10691 S_regbranch(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, I32 first, U32 depth)
10692 {
10693     regnode *ret;
10694     regnode *chain = NULL;
10695     regnode *latest;
10696     I32 flags = 0, c = 0;
10697     GET_RE_DEBUG_FLAGS_DECL;
10698
10699     PERL_ARGS_ASSERT_REGBRANCH;
10700
10701     DEBUG_PARSE("brnc");
10702
10703     if (first)
10704         ret = NULL;
10705     else {
10706         if (!SIZE_ONLY && RExC_extralen)
10707             ret = reganode(pRExC_state, BRANCHJ,0);
10708         else {
10709             ret = reg_node(pRExC_state, BRANCH);
10710             Set_Node_Length(ret, 1);
10711         }
10712     }
10713
10714     if (!first && SIZE_ONLY)
10715         RExC_extralen += 1;                     /* BRANCHJ */
10716
10717     *flagp = WORST;                     /* Tentatively. */
10718
10719     RExC_parse--;
10720     nextchar(pRExC_state);
10721     while (RExC_parse < RExC_end && *RExC_parse != '|' && *RExC_parse != ')') {
10722         flags &= ~TRYAGAIN;
10723         latest = regpiece(pRExC_state, &flags,depth+1);
10724         if (latest == NULL) {
10725             if (flags & TRYAGAIN)
10726                 continue;
10727             if (flags & RESTART_UTF8) {
10728                 *flagp = RESTART_UTF8;
10729                 return NULL;
10730             }
10731             FAIL2("panic: regpiece returned NULL, flags=%#"UVxf"", (UV) flags);
10732         }
10733         else if (ret == NULL)
10734             ret = latest;
10735         *flagp |= flags&(HASWIDTH|POSTPONED);
10736         if (chain == NULL)      /* First piece. */
10737             *flagp |= flags&SPSTART;
10738         else {
10739             /* FIXME adding one for every branch after the first is probably
10740              * excessive now we have TRIE support. (hv) */
10741             MARK_NAUGHTY(1);
10742             REGTAIL(pRExC_state, chain, latest);
10743         }
10744         chain = latest;
10745         c++;
10746     }
10747     if (chain == NULL) {        /* Loop ran zero times. */
10748         chain = reg_node(pRExC_state, NOTHING);
10749         if (ret == NULL)
10750             ret = chain;
10751     }
10752     if (c == 1) {
10753         *flagp |= flags&SIMPLE;
10754     }
10755
10756     return ret;
10757 }
10758
10759 /*
10760  - regpiece - something followed by possible [*+?]
10761  *
10762  * Note that the branching code sequences used for ? and the general cases
10763  * of * and + are somewhat optimized:  they use the same NOTHING node as
10764  * both the endmarker for their branch list and the body of the last branch.
10765  * It might seem that this node could be dispensed with entirely, but the
10766  * endmarker role is not redundant.
10767  *
10768  * Returns NULL, setting *flagp to TRYAGAIN if regatom() returns NULL with
10769  * TRYAGAIN.
10770  * Returns NULL, setting *flagp to RESTART_UTF8 if the sizing scan needs to be
10771  * restarted.
10772  */
10773 STATIC regnode *
10774 S_regpiece(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth)
10775 {
10776     regnode *ret;
10777     char op;
10778     char *next;
10779     I32 flags;
10780     const char * const origparse = RExC_parse;
10781     I32 min;
10782     I32 max = REG_INFTY;
10783 #ifdef RE_TRACK_PATTERN_OFFSETS
10784     char *parse_start;
10785 #endif
10786     const char *maxpos = NULL;
10787     UV uv;
10788
10789     /* Save the original in case we change the emitted regop to a FAIL. */
10790     regnode * const orig_emit = RExC_emit;
10791
10792     GET_RE_DEBUG_FLAGS_DECL;
10793
10794     PERL_ARGS_ASSERT_REGPIECE;
10795
10796     DEBUG_PARSE("piec");
10797
10798     ret = regatom(pRExC_state, &flags,depth+1);
10799     if (ret == NULL) {
10800         if (flags & (TRYAGAIN|RESTART_UTF8))
10801             *flagp |= flags & (TRYAGAIN|RESTART_UTF8);
10802         else
10803             FAIL2("panic: regatom returned NULL, flags=%#"UVxf"", (UV) flags);
10804         return(NULL);
10805     }
10806
10807     op = *RExC_parse;
10808
10809     if (op == '{' && regcurly(RExC_parse)) {
10810         maxpos = NULL;
10811 #ifdef RE_TRACK_PATTERN_OFFSETS
10812         parse_start = RExC_parse; /* MJD */
10813 #endif
10814         next = RExC_parse + 1;
10815         while (isDIGIT(*next) || *next == ',') {
10816             if (*next == ',') {
10817                 if (maxpos)
10818                     break;
10819                 else
10820                     maxpos = next;
10821             }
10822             next++;
10823         }
10824         if (*next == '}') {             /* got one */
10825             const char* endptr;
10826             if (!maxpos)
10827                 maxpos = next;
10828             RExC_parse++;
10829             if (isDIGIT(*RExC_parse)) {
10830                 if (!grok_atoUV(RExC_parse, &uv, &endptr))
10831                     vFAIL("Invalid quantifier in {,}");
10832                 if (uv >= REG_INFTY)
10833                     vFAIL2("Quantifier in {,} bigger than %d", REG_INFTY - 1);
10834                 min = (I32)uv;
10835             } else {
10836                 min = 0;
10837             }
10838             if (*maxpos == ',')
10839                 maxpos++;
10840             else
10841                 maxpos = RExC_parse;
10842             if (isDIGIT(*maxpos)) {
10843                 if (!grok_atoUV(maxpos, &uv, &endptr))
10844                     vFAIL("Invalid quantifier in {,}");
10845                 if (uv >= REG_INFTY)
10846                     vFAIL2("Quantifier in {,} bigger than %d", REG_INFTY - 1);
10847                 max = (I32)uv;
10848             } else {
10849                 max = REG_INFTY;                /* meaning "infinity" */
10850             }
10851             RExC_parse = next;
10852             nextchar(pRExC_state);
10853             if (max < min) {    /* If can't match, warn and optimize to fail
10854                                    unconditionally */
10855                 if (SIZE_ONLY) {
10856
10857                     /* We can't back off the size because we have to reserve
10858                      * enough space for all the things we are about to throw
10859                      * away, but we can shrink it by the ammount we are about
10860                      * to re-use here */
10861                     RExC_size = PREVOPER(RExC_size) - regarglen[(U8)OPFAIL];
10862                 }
10863                 else {
10864                     ckWARNreg(RExC_parse, "Quantifier {n,m} with n > m can't match");
10865                     RExC_emit = orig_emit;
10866                 }
10867                 ret = reg_node(pRExC_state, OPFAIL);
10868                 return ret;
10869             }
10870             else if (min == max
10871                      && RExC_parse < RExC_end
10872                      && (*RExC_parse == '?' || *RExC_parse == '+'))
10873             {
10874                 if (PASS2) {
10875                     ckWARN2reg(RExC_parse + 1,
10876                                "Useless use of greediness modifier '%c'",
10877                                *RExC_parse);
10878                 }
10879                 /* Absorb the modifier, so later code doesn't see nor use
10880                     * it */
10881                 nextchar(pRExC_state);
10882             }
10883
10884           do_curly:
10885             if ((flags&SIMPLE)) {
10886                 MARK_NAUGHTY_EXP(2, 2);
10887                 reginsert(pRExC_state, CURLY, ret, depth+1);
10888                 Set_Node_Offset(ret, parse_start+1); /* MJD */
10889                 Set_Node_Cur_Length(ret, parse_start);
10890             }
10891             else {
10892                 regnode * const w = reg_node(pRExC_state, WHILEM);
10893
10894                 w->flags = 0;
10895                 REGTAIL(pRExC_state, ret, w);
10896                 if (!SIZE_ONLY && RExC_extralen) {
10897                     reginsert(pRExC_state, LONGJMP,ret, depth+1);
10898                     reginsert(pRExC_state, NOTHING,ret, depth+1);
10899                     NEXT_OFF(ret) = 3;  /* Go over LONGJMP. */
10900                 }
10901                 reginsert(pRExC_state, CURLYX,ret, depth+1);
10902                                 /* MJD hk */
10903                 Set_Node_Offset(ret, parse_start+1);
10904                 Set_Node_Length(ret,
10905                                 op == '{' ? (RExC_parse - parse_start) : 1);
10906
10907                 if (!SIZE_ONLY && RExC_extralen)
10908                     NEXT_OFF(ret) = 3;  /* Go over NOTHING to LONGJMP. */
10909                 REGTAIL(pRExC_state, ret, reg_node(pRExC_state, NOTHING));
10910                 if (SIZE_ONLY)
10911                     RExC_whilem_seen++, RExC_extralen += 3;
10912                 MARK_NAUGHTY_EXP(1, 4);     /* compound interest */
10913             }
10914             ret->flags = 0;
10915
10916             if (min > 0)
10917                 *flagp = WORST;
10918             if (max > 0)
10919                 *flagp |= HASWIDTH;
10920             if (!SIZE_ONLY) {
10921                 ARG1_SET(ret, (U16)min);
10922                 ARG2_SET(ret, (U16)max);
10923             }
10924             if (max == REG_INFTY)
10925                 RExC_seen |= REG_UNBOUNDED_QUANTIFIER_SEEN;
10926
10927             goto nest_check;
10928         }
10929     }
10930
10931     if (!ISMULT1(op)) {
10932         *flagp = flags;
10933         return(ret);
10934     }
10935
10936 #if 0                           /* Now runtime fix should be reliable. */
10937
10938     /* if this is reinstated, don't forget to put this back into perldiag:
10939
10940             =item Regexp *+ operand could be empty at {#} in regex m/%s/
10941
10942            (F) The part of the regexp subject to either the * or + quantifier
10943            could match an empty string. The {#} shows in the regular
10944            expression about where the problem was discovered.
10945
10946     */
10947
10948     if (!(flags&HASWIDTH) && op != '?')
10949       vFAIL("Regexp *+ operand could be empty");
10950 #endif
10951
10952 #ifdef RE_TRACK_PATTERN_OFFSETS
10953     parse_start = RExC_parse;
10954 #endif
10955     nextchar(pRExC_state);
10956
10957     *flagp = (op != '+') ? (WORST|SPSTART|HASWIDTH) : (WORST|HASWIDTH);
10958
10959     if (op == '*' && (flags&SIMPLE)) {
10960         reginsert(pRExC_state, STAR, ret, depth+1);
10961         ret->flags = 0;
10962         MARK_NAUGHTY(4);
10963         RExC_seen |= REG_UNBOUNDED_QUANTIFIER_SEEN;
10964     }
10965     else if (op == '*') {
10966         min = 0;
10967         goto do_curly;
10968     }
10969     else if (op == '+' && (flags&SIMPLE)) {
10970         reginsert(pRExC_state, PLUS, ret, depth+1);
10971         ret->flags = 0;
10972         MARK_NAUGHTY(3);
10973         RExC_seen |= REG_UNBOUNDED_QUANTIFIER_SEEN;
10974     }
10975     else if (op == '+') {
10976         min = 1;
10977         goto do_curly;
10978     }
10979     else if (op == '?') {
10980         min = 0; max = 1;
10981         goto do_curly;
10982     }
10983   nest_check:
10984     if (!SIZE_ONLY && !(flags&(HASWIDTH|POSTPONED)) && max > REG_INFTY/3) {
10985         SAVEFREESV(RExC_rx_sv); /* in case of fatal warnings */
10986         ckWARN2reg(RExC_parse,
10987                    "%"UTF8f" matches null string many times",
10988                    UTF8fARG(UTF, (RExC_parse >= origparse
10989                                  ? RExC_parse - origparse
10990                                  : 0),
10991                    origparse));
10992         (void)ReREFCNT_inc(RExC_rx_sv);
10993     }
10994
10995     if (RExC_parse < RExC_end && *RExC_parse == '?') {
10996         nextchar(pRExC_state);
10997         reginsert(pRExC_state, MINMOD, ret, depth+1);
10998         REGTAIL(pRExC_state, ret, ret + NODE_STEP_REGNODE);
10999     }
11000     else
11001     if (RExC_parse < RExC_end && *RExC_parse == '+') {
11002         regnode *ender;
11003         nextchar(pRExC_state);
11004         ender = reg_node(pRExC_state, SUCCEED);
11005         REGTAIL(pRExC_state, ret, ender);
11006         reginsert(pRExC_state, SUSPEND, ret, depth+1);
11007         ret->flags = 0;
11008         ender = reg_node(pRExC_state, TAIL);
11009         REGTAIL(pRExC_state, ret, ender);
11010     }
11011
11012     if (RExC_parse < RExC_end && ISMULT2(RExC_parse)) {
11013         RExC_parse++;
11014         vFAIL("Nested quantifiers");
11015     }
11016
11017     return(ret);
11018 }
11019
11020 STATIC bool
11021 S_grok_bslash_N(pTHX_ RExC_state_t *pRExC_state,
11022                 regnode ** node_p,
11023                 UV * code_point_p,
11024                 int * cp_count,
11025                 I32 * flagp,
11026                 const U32 depth
11027     )
11028 {
11029  /* This routine teases apart the various meanings of \N and returns
11030   * accordingly.  The input parameters constrain which meaning(s) is/are valid
11031   * in the current context.
11032   *
11033   * Exactly one of <node_p> and <code_point_p> must be non-NULL.
11034   *
11035   * If <code_point_p> is not NULL, the context is expecting the result to be a
11036   * single code point.  If this \N instance turns out to a single code point,
11037   * the function returns TRUE and sets *code_point_p to that code point.
11038   *
11039   * If <node_p> is not NULL, the context is expecting the result to be one of
11040   * the things representable by a regnode.  If this \N instance turns out to be
11041   * one such, the function generates the regnode, returns TRUE and sets *node_p
11042   * to point to that regnode.
11043   *
11044   * If this instance of \N isn't legal in any context, this function will
11045   * generate a fatal error and not return.
11046   *
11047   * On input, RExC_parse should point to the first char following the \N at the
11048   * time of the call.  On successful return, RExC_parse will have been updated
11049   * to point to just after the sequence identified by this routine.  Also
11050   * *flagp has been updated as needed.
11051   *
11052   * When there is some problem with the current context and this \N instance,
11053   * the function returns FALSE, without advancing RExC_parse, nor setting
11054   * *node_p, nor *code_point_p, nor *flagp.
11055   *
11056   * If <cp_count> is not NULL, the caller wants to know the length (in code
11057   * points) that this \N sequence matches.  This is set even if the function
11058   * returns FALSE, as detailed below.
11059   *
11060   * There are 5 possibilities here, as detailed in the next 5 paragraphs.
11061   *
11062   * Probably the most common case is for the \N to specify a single code point.
11063   * *cp_count will be set to 1, and *code_point_p will be set to that code
11064   * point.
11065   *
11066   * Another possibility is for the input to be an empty \N{}, which for
11067   * backwards compatibility we accept.  *cp_count will be set to 0. *node_p
11068   * will be set to a generated NOTHING node.
11069   *
11070   * Still another possibility is for the \N to mean [^\n]. *cp_count will be
11071   * set to 0. *node_p will be set to a generated REG_ANY node.
11072   *
11073   * The fourth possibility is that \N resolves to a sequence of more than one
11074   * code points.  *cp_count will be set to the number of code points in the
11075   * sequence. *node_p * will be set to a generated node returned by this
11076   * function calling S_reg().
11077   *
11078   * The final possibility, which happens only when the fourth one would
11079   * otherwise be in effect, is that one of those code points requires the
11080   * pattern to be recompiled as UTF-8.  The function returns FALSE, and sets
11081   * the RESTART_UTF8 flag in *flagp.  When this happens, the caller needs to
11082   * desist from continuing parsing, and return this information to its caller.
11083   * This is not set for when there is only one code point, as this can be
11084   * called as part of an ANYOF node, and they can store above-Latin1 code
11085   * points without the pattern having to be in UTF-8.
11086   *
11087   * For non-single-quoted regexes, the tokenizer has resolved character and
11088   * sequence names inside \N{...} into their Unicode values, normalizing the
11089   * result into what we should see here: '\N{U+c1.c2...}', where c1... are the
11090   * hex-represented code points in the sequence.  This is done there because
11091   * the names can vary based on what charnames pragma is in scope at the time,
11092   * so we need a way to take a snapshot of what they resolve to at the time of
11093   * the original parse. [perl #56444].
11094   *
11095   * That parsing is skipped for single-quoted regexes, so we may here get
11096   * '\N{NAME}'.  This is a fatal error.  These names have to be resolved by the
11097   * parser.  But if the single-quoted regex is something like '\N{U+41}', that
11098   * is legal and handled here.  The code point is Unicode, and has to be
11099   * translated into the native character set for non-ASCII platforms.
11100   * the tokenizer passes the \N sequence through unchanged; this code will not
11101   * attempt to determine this nor expand those, instead raising a syntax error.
11102   */
11103
11104     char * endbrace;    /* points to '}' following the name */
11105     char *endchar;      /* Points to '.' or '}' ending cur char in the input
11106                            stream */
11107     char* p;            /* Temporary */
11108
11109     GET_RE_DEBUG_FLAGS_DECL;
11110
11111     PERL_ARGS_ASSERT_GROK_BSLASH_N;
11112
11113     GET_RE_DEBUG_FLAGS;
11114
11115     assert(cBOOL(node_p) ^ cBOOL(code_point_p));  /* Exactly one should be set */
11116     assert(! (node_p && cp_count));               /* At most 1 should be set */
11117
11118     if (cp_count) {     /* Initialize return for the most common case */
11119         *cp_count = 1;
11120     }
11121
11122     /* The [^\n] meaning of \N ignores spaces and comments under the /x
11123      * modifier.  The other meanings do not, so use a temporary until we find
11124      * out which we are being called with */
11125     p = (RExC_flags & RXf_PMf_EXTENDED)
11126         ? regpatws(pRExC_state, RExC_parse,
11127                                 TRUE) /* means recognize comments */
11128         : RExC_parse;
11129
11130     /* Disambiguate between \N meaning a named character versus \N meaning
11131      * [^\n].  The latter is assumed when the {...} following the \N is a legal
11132      * quantifier, or there is no a '{' at all */
11133     if (*p != '{' || regcurly(p)) {
11134         RExC_parse = p;
11135         if (cp_count) {
11136             *cp_count = -1;
11137         }
11138
11139         if (! node_p) {
11140             return FALSE;
11141         }
11142         RExC_parse--;   /* Need to back off so nextchar() doesn't skip the
11143                            current char */
11144         nextchar(pRExC_state);
11145         *node_p = reg_node(pRExC_state, REG_ANY);
11146         *flagp |= HASWIDTH|SIMPLE;
11147         MARK_NAUGHTY(1);
11148         Set_Node_Length(*node_p, 1); /* MJD */
11149         return TRUE;
11150     }
11151
11152     /* Here, we have decided it should be a named character or sequence */
11153
11154     /* The test above made sure that the next real character is a '{', but
11155      * under the /x modifier, it could be separated by space (or a comment and
11156      * \n) and this is not allowed (for consistency with \x{...} and the
11157      * tokenizer handling of \N{NAME}). */
11158     if (*RExC_parse != '{') {
11159         vFAIL("Missing braces on \\N{}");
11160     }
11161
11162     RExC_parse++;       /* Skip past the '{' */
11163
11164     if (! (endbrace = strchr(RExC_parse, '}'))  /* no trailing brace */
11165         || ! (endbrace == RExC_parse            /* nothing between the {} */
11166               || (endbrace - RExC_parse >= 2    /* U+ (bad hex is checked... */
11167                   && strnEQ(RExC_parse, "U+", 2)))) /* ... below for a better
11168                                                        error msg) */
11169     {
11170         if (endbrace) RExC_parse = endbrace;    /* position msg's '<--HERE' */
11171         vFAIL("\\N{NAME} must be resolved by the lexer");
11172     }
11173
11174     RExC_uni_semantics = 1; /* Unicode named chars imply Unicode semantics */
11175
11176     if (endbrace == RExC_parse) {   /* empty: \N{} */
11177         if (cp_count) {
11178             *cp_count = 0;
11179         }
11180         nextchar(pRExC_state);
11181         if (! node_p) {
11182             return FALSE;
11183         }
11184
11185         *node_p = reg_node(pRExC_state,NOTHING);
11186         return TRUE;
11187     }
11188
11189     RExC_parse += 2;    /* Skip past the 'U+' */
11190
11191     endchar = RExC_parse + strcspn(RExC_parse, ".}");
11192
11193     /* Code points are separated by dots.  If none, there is only one code
11194      * point, and is terminated by the brace */
11195
11196     if (endchar >= endbrace) {
11197         STRLEN length_of_hex;
11198         I32 grok_hex_flags;
11199
11200         /* Here, exactly one code point.  If that isn't what is wanted, fail */
11201         if (! code_point_p) {
11202             RExC_parse = p;
11203             return FALSE;
11204         }
11205
11206         /* Convert code point from hex */
11207         length_of_hex = (STRLEN)(endchar - RExC_parse);
11208         grok_hex_flags = PERL_SCAN_ALLOW_UNDERSCORES
11209                            | PERL_SCAN_DISALLOW_PREFIX
11210
11211                              /* No errors in the first pass (See [perl
11212                               * #122671].)  We let the code below find the
11213                               * errors when there are multiple chars. */
11214                            | ((SIZE_ONLY)
11215                               ? PERL_SCAN_SILENT_ILLDIGIT
11216                               : 0);
11217
11218         /* This routine is the one place where both single- and double-quotish
11219          * \N{U+xxxx} are evaluated.  The value is a Unicode code point which
11220          * must be converted to native. */
11221         *code_point_p = UNI_TO_NATIVE(grok_hex(RExC_parse,
11222                                          &length_of_hex,
11223                                          &grok_hex_flags,
11224                                          NULL));
11225
11226         /* The tokenizer should have guaranteed validity, but it's possible to
11227          * bypass it by using single quoting, so check.  Don't do the check
11228          * here when there are multiple chars; we do it below anyway. */
11229         if (length_of_hex == 0
11230             || length_of_hex != (STRLEN)(endchar - RExC_parse) )
11231         {
11232             RExC_parse += length_of_hex;        /* Includes all the valid */
11233             RExC_parse += (RExC_orig_utf8)      /* point to after 1st invalid */
11234                             ? UTF8SKIP(RExC_parse)
11235                             : 1;
11236             /* Guard against malformed utf8 */
11237             if (RExC_parse >= endchar) {
11238                 RExC_parse = endchar;
11239             }
11240             vFAIL("Invalid hexadecimal number in \\N{U+...}");
11241         }
11242
11243         RExC_parse = endbrace + 1;
11244         return TRUE;
11245     }
11246     else {  /* Is a multiple character sequence */
11247         SV * substitute_parse;
11248         STRLEN len;
11249         char *orig_end = RExC_end;
11250         I32 flags;
11251
11252         /* Count the code points, if desired, in the sequence */
11253         if (cp_count) {
11254             *cp_count = 0;
11255             while (RExC_parse < endbrace) {
11256                 /* Point to the beginning of the next character in the sequence. */
11257                 RExC_parse = endchar + 1;
11258                 endchar = RExC_parse + strcspn(RExC_parse, ".}");
11259                 (*cp_count)++;
11260             }
11261         }
11262
11263         /* Fail if caller doesn't want to handle a multi-code-point sequence.
11264          * But don't backup up the pointer if the caller want to know how many
11265          * code points there are (they can then handle things) */
11266         if (! node_p) {
11267             if (! cp_count) {
11268                 RExC_parse = p;
11269             }
11270             return FALSE;
11271         }
11272
11273         /* What is done here is to convert this to a sub-pattern of the form
11274          * \x{char1}\x{char2}...  and then call reg recursively to parse it
11275          * (enclosing in "(?: ... )" ).  That way, it retains its atomicness,
11276          * while not having to worry about special handling that some code
11277          * points may have. */
11278
11279         substitute_parse = newSVpvs("?:");
11280
11281         while (RExC_parse < endbrace) {
11282
11283             /* Convert to notation the rest of the code understands */
11284             sv_catpv(substitute_parse, "\\x{");
11285             sv_catpvn(substitute_parse, RExC_parse, endchar - RExC_parse);
11286             sv_catpv(substitute_parse, "}");
11287
11288             /* Point to the beginning of the next character in the sequence. */
11289             RExC_parse = endchar + 1;
11290             endchar = RExC_parse + strcspn(RExC_parse, ".}");
11291
11292         }
11293         sv_catpv(substitute_parse, ")");
11294
11295         RExC_parse = SvPV(substitute_parse, len);
11296
11297         /* Don't allow empty number */
11298         if (len < (STRLEN) 8) {
11299             RExC_parse = endbrace;
11300             vFAIL("Invalid hexadecimal number in \\N{U+...}");
11301         }
11302         RExC_end = RExC_parse + len;
11303
11304         /* The values are Unicode, and therefore not subject to recoding, but
11305          * have to be converted to native on a non-Unicode (meaning non-ASCII)
11306          * platform. */
11307         RExC_override_recoding = 1;
11308 #ifdef EBCDIC
11309         RExC_recode_x_to_native = 1;
11310 #endif
11311
11312         if (node_p) {
11313             if (!(*node_p = reg(pRExC_state, 1, &flags, depth+1))) {
11314                 if (flags & RESTART_UTF8) {
11315                     *flagp = RESTART_UTF8;
11316                     return FALSE;
11317                 }
11318                 FAIL2("panic: reg returned NULL to grok_bslash_N, flags=%#"UVxf"",
11319                     (UV) flags);
11320             }
11321             *flagp |= flags&(HASWIDTH|SPSTART|SIMPLE|POSTPONED);
11322         }
11323
11324         /* Restore the saved values */
11325         RExC_parse = endbrace;
11326         RExC_end = orig_end;
11327         RExC_override_recoding = 0;
11328 #ifdef EBCDIC
11329         RExC_recode_x_to_native = 0;
11330 #endif
11331
11332         SvREFCNT_dec_NN(substitute_parse);
11333         nextchar(pRExC_state);
11334
11335         return TRUE;
11336     }
11337 }
11338
11339
11340 /*
11341  * reg_recode
11342  *
11343  * It returns the code point in utf8 for the value in *encp.
11344  *    value: a code value in the source encoding
11345  *    encp:  a pointer to an Encode object
11346  *
11347  * If the result from Encode is not a single character,
11348  * it returns U+FFFD (Replacement character) and sets *encp to NULL.
11349  */
11350 STATIC UV
11351 S_reg_recode(pTHX_ const char value, SV **encp)
11352 {
11353     STRLEN numlen = 1;
11354     SV * const sv = newSVpvn_flags(&value, numlen, SVs_TEMP);
11355     const char * const s = *encp ? sv_recode_to_utf8(sv, *encp) : SvPVX(sv);
11356     const STRLEN newlen = SvCUR(sv);
11357     UV uv = UNICODE_REPLACEMENT;
11358
11359     PERL_ARGS_ASSERT_REG_RECODE;
11360
11361     if (newlen)
11362         uv = SvUTF8(sv)
11363              ? utf8n_to_uvchr((U8*)s, newlen, &numlen, UTF8_ALLOW_DEFAULT)
11364              : *(U8*)s;
11365
11366     if (!newlen || numlen != newlen) {
11367         uv = UNICODE_REPLACEMENT;
11368         *encp = NULL;
11369     }
11370     return uv;
11371 }
11372
11373 PERL_STATIC_INLINE U8
11374 S_compute_EXACTish(RExC_state_t *pRExC_state)
11375 {
11376     U8 op;
11377
11378     PERL_ARGS_ASSERT_COMPUTE_EXACTISH;
11379
11380     if (! FOLD) {
11381         return (LOC)
11382                 ? EXACTL
11383                 : EXACT;
11384     }
11385
11386     op = get_regex_charset(RExC_flags);
11387     if (op >= REGEX_ASCII_RESTRICTED_CHARSET) {
11388         op--; /* /a is same as /u, and map /aa's offset to what /a's would have
11389                  been, so there is no hole */
11390     }
11391
11392     return op + EXACTF;
11393 }
11394
11395 PERL_STATIC_INLINE void
11396 S_alloc_maybe_populate_EXACT(pTHX_ RExC_state_t *pRExC_state,
11397                          regnode *node, I32* flagp, STRLEN len, UV code_point,
11398                          bool downgradable)
11399 {
11400     /* This knows the details about sizing an EXACTish node, setting flags for
11401      * it (by setting <*flagp>, and potentially populating it with a single
11402      * character.
11403      *
11404      * If <len> (the length in bytes) is non-zero, this function assumes that
11405      * the node has already been populated, and just does the sizing.  In this
11406      * case <code_point> should be the final code point that has already been
11407      * placed into the node.  This value will be ignored except that under some
11408      * circumstances <*flagp> is set based on it.
11409      *
11410      * If <len> is zero, the function assumes that the node is to contain only
11411      * the single character given by <code_point> and calculates what <len>
11412      * should be.  In pass 1, it sizes the node appropriately.  In pass 2, it
11413      * additionally will populate the node's STRING with <code_point> or its
11414      * fold if folding.
11415      *
11416      * In both cases <*flagp> is appropriately set
11417      *
11418      * It knows that under FOLD, the Latin Sharp S and UTF characters above
11419      * 255, must be folded (the former only when the rules indicate it can
11420      * match 'ss')
11421      *
11422      * When it does the populating, it looks at the flag 'downgradable'.  If
11423      * true with a node that folds, it checks if the single code point
11424      * participates in a fold, and if not downgrades the node to an EXACT.
11425      * This helps the optimizer */
11426
11427     bool len_passed_in = cBOOL(len != 0);
11428     U8 character[UTF8_MAXBYTES_CASE+1];
11429
11430     PERL_ARGS_ASSERT_ALLOC_MAYBE_POPULATE_EXACT;
11431
11432     /* Don't bother to check for downgrading in PASS1, as it doesn't make any
11433      * sizing difference, and is extra work that is thrown away */
11434     if (downgradable && ! PASS2) {
11435         downgradable = FALSE;
11436     }
11437
11438     if (! len_passed_in) {
11439         if (UTF) {
11440             if (UVCHR_IS_INVARIANT(code_point)) {
11441                 if (LOC || ! FOLD) {    /* /l defers folding until runtime */
11442                     *character = (U8) code_point;
11443                 }
11444                 else { /* Here is /i and not /l. (toFOLD() is defined on just
11445                           ASCII, which isn't the same thing as INVARIANT on
11446                           EBCDIC, but it works there, as the extra invariants
11447                           fold to themselves) */
11448                     *character = toFOLD((U8) code_point);
11449
11450                     /* We can downgrade to an EXACT node if this character
11451                      * isn't a folding one.  Note that this assumes that
11452                      * nothing above Latin1 folds to some other invariant than
11453                      * one of these alphabetics; otherwise we would also have
11454                      * to check:
11455                      *  && (! HAS_NONLATIN1_FOLD_CLOSURE(code_point)
11456                      *      || ASCII_FOLD_RESTRICTED))
11457                      */
11458                     if (downgradable && PL_fold[code_point] == code_point) {
11459                         OP(node) = EXACT;
11460                     }
11461                 }
11462                 len = 1;
11463             }
11464             else if (FOLD && (! LOC
11465                               || ! is_PROBLEMATIC_LOCALE_FOLD_cp(code_point)))
11466             {   /* Folding, and ok to do so now */
11467                 UV folded = _to_uni_fold_flags(
11468                                    code_point,
11469                                    character,
11470                                    &len,
11471                                    FOLD_FLAGS_FULL | ((ASCII_FOLD_RESTRICTED)
11472                                                       ? FOLD_FLAGS_NOMIX_ASCII
11473                                                       : 0));
11474                 if (downgradable
11475                     && folded == code_point /* This quickly rules out many
11476                                                cases, avoiding the
11477                                                _invlist_contains_cp() overhead
11478                                                for those.  */
11479                     && ! _invlist_contains_cp(PL_utf8_foldable, code_point))
11480                 {
11481                     OP(node) = (LOC)
11482                                ? EXACTL
11483                                : EXACT;
11484                 }
11485             }
11486             else if (code_point <= MAX_UTF8_TWO_BYTE) {
11487
11488                 /* Not folding this cp, and can output it directly */
11489                 *character = UTF8_TWO_BYTE_HI(code_point);
11490                 *(character + 1) = UTF8_TWO_BYTE_LO(code_point);
11491                 len = 2;
11492             }
11493             else {
11494                 uvchr_to_utf8( character, code_point);
11495                 len = UTF8SKIP(character);
11496             }
11497         } /* Else pattern isn't UTF8.  */
11498         else if (! FOLD) {
11499             *character = (U8) code_point;
11500             len = 1;
11501         } /* Else is folded non-UTF8 */
11502         else if (LIKELY(code_point != LATIN_SMALL_LETTER_SHARP_S)) {
11503
11504             /* We don't fold any non-UTF8 except possibly the Sharp s  (see
11505              * comments at join_exact()); */
11506             *character = (U8) code_point;
11507             len = 1;
11508
11509             /* Can turn into an EXACT node if we know the fold at compile time,
11510              * and it folds to itself and doesn't particpate in other folds */
11511             if (downgradable
11512                 && ! LOC
11513                 && PL_fold_latin1[code_point] == code_point
11514                 && (! HAS_NONLATIN1_FOLD_CLOSURE(code_point)
11515                     || (isASCII(code_point) && ASCII_FOLD_RESTRICTED)))
11516             {
11517                 OP(node) = EXACT;
11518             }
11519         } /* else is Sharp s.  May need to fold it */
11520         else if (AT_LEAST_UNI_SEMANTICS && ! ASCII_FOLD_RESTRICTED) {
11521             *character = 's';
11522             *(character + 1) = 's';
11523             len = 2;
11524         }
11525         else {
11526             *character = LATIN_SMALL_LETTER_SHARP_S;
11527             len = 1;
11528         }
11529     }
11530
11531     if (SIZE_ONLY) {
11532         RExC_size += STR_SZ(len);
11533     }
11534     else {
11535         RExC_emit += STR_SZ(len);
11536         STR_LEN(node) = len;
11537         if (! len_passed_in) {
11538             Copy((char *) character, STRING(node), len, char);
11539         }
11540     }
11541
11542     *flagp |= HASWIDTH;
11543
11544     /* A single character node is SIMPLE, except for the special-cased SHARP S
11545      * under /di. */
11546     if ((len == 1 || (UTF && len == UNISKIP(code_point)))
11547         && (code_point != LATIN_SMALL_LETTER_SHARP_S
11548             || ! FOLD || ! DEPENDS_SEMANTICS))
11549     {
11550         *flagp |= SIMPLE;
11551     }
11552
11553     /* The OP may not be well defined in PASS1 */
11554     if (PASS2 && OP(node) == EXACTFL) {
11555         RExC_contains_locale = 1;
11556     }
11557 }
11558
11559
11560 /* Parse backref decimal value, unless it's too big to sensibly be a backref,
11561  * in which case return I32_MAX (rather than possibly 32-bit wrapping) */
11562
11563 static I32
11564 S_backref_value(char *p)
11565 {
11566     const char* endptr;
11567     UV val;
11568     if (grok_atoUV(p, &val, &endptr) && val <= I32_MAX)
11569         return (I32)val;
11570     return I32_MAX;
11571 }
11572
11573
11574 /*
11575  - regatom - the lowest level
11576
11577    Try to identify anything special at the start of the pattern. If there
11578    is, then handle it as required. This may involve generating a single regop,
11579    such as for an assertion; or it may involve recursing, such as to
11580    handle a () structure.
11581
11582    If the string doesn't start with something special then we gobble up
11583    as much literal text as we can.
11584
11585    Once we have been able to handle whatever type of thing started the
11586    sequence, we return.
11587
11588    Note: we have to be careful with escapes, as they can be both literal
11589    and special, and in the case of \10 and friends, context determines which.
11590
11591    A summary of the code structure is:
11592
11593    switch (first_byte) {
11594         cases for each special:
11595             handle this special;
11596             break;
11597         case '\\':
11598             switch (2nd byte) {
11599                 cases for each unambiguous special:
11600                     handle this special;
11601                     break;
11602                 cases for each ambigous special/literal:
11603                     disambiguate;
11604                     if (special)  handle here
11605                     else goto defchar;
11606                 default: // unambiguously literal:
11607                     goto defchar;
11608             }
11609         default:  // is a literal char
11610             // FALL THROUGH
11611         defchar:
11612             create EXACTish node for literal;
11613             while (more input and node isn't full) {
11614                 switch (input_byte) {
11615                    cases for each special;
11616                        make sure parse pointer is set so that the next call to
11617                            regatom will see this special first
11618                        goto loopdone; // EXACTish node terminated by prev. char
11619                    default:
11620                        append char to EXACTISH node;
11621                 }
11622                 get next input byte;
11623             }
11624         loopdone:
11625    }
11626    return the generated node;
11627
11628    Specifically there are two separate switches for handling
11629    escape sequences, with the one for handling literal escapes requiring
11630    a dummy entry for all of the special escapes that are actually handled
11631    by the other.
11632
11633    Returns NULL, setting *flagp to TRYAGAIN if reg() returns NULL with
11634    TRYAGAIN.
11635    Returns NULL, setting *flagp to RESTART_UTF8 if the sizing scan needs to be
11636    restarted.
11637    Otherwise does not return NULL.
11638 */
11639
11640 STATIC regnode *
11641 S_regatom(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth)
11642 {
11643     regnode *ret = NULL;
11644     I32 flags = 0;
11645     char *parse_start = RExC_parse;
11646     U8 op;
11647     int invert = 0;
11648     U8 arg;
11649
11650     GET_RE_DEBUG_FLAGS_DECL;
11651
11652     *flagp = WORST;             /* Tentatively. */
11653
11654     DEBUG_PARSE("atom");
11655
11656     PERL_ARGS_ASSERT_REGATOM;
11657
11658   tryagain:
11659     switch ((U8)*RExC_parse) {
11660     case '^':
11661         RExC_seen_zerolen++;
11662         nextchar(pRExC_state);
11663         if (RExC_flags & RXf_PMf_MULTILINE)
11664             ret = reg_node(pRExC_state, MBOL);
11665         else
11666             ret = reg_node(pRExC_state, SBOL);
11667         Set_Node_Length(ret, 1); /* MJD */
11668         break;
11669     case '$':
11670         nextchar(pRExC_state);
11671         if (*RExC_parse)
11672             RExC_seen_zerolen++;
11673         if (RExC_flags & RXf_PMf_MULTILINE)
11674             ret = reg_node(pRExC_state, MEOL);
11675         else
11676             ret = reg_node(pRExC_state, SEOL);
11677         Set_Node_Length(ret, 1); /* MJD */
11678         break;
11679     case '.':
11680         nextchar(pRExC_state);
11681         if (RExC_flags & RXf_PMf_SINGLELINE)
11682             ret = reg_node(pRExC_state, SANY);
11683         else
11684             ret = reg_node(pRExC_state, REG_ANY);
11685         *flagp |= HASWIDTH|SIMPLE;
11686         MARK_NAUGHTY(1);
11687         Set_Node_Length(ret, 1); /* MJD */
11688         break;
11689     case '[':
11690     {
11691         char * const oregcomp_parse = ++RExC_parse;
11692         ret = regclass(pRExC_state, flagp,depth+1,
11693                        FALSE, /* means parse the whole char class */
11694                        TRUE, /* allow multi-char folds */
11695                        FALSE, /* don't silence non-portable warnings. */
11696                        (bool) RExC_strict,
11697                        NULL);
11698         if (*RExC_parse != ']') {
11699             RExC_parse = oregcomp_parse;
11700             vFAIL("Unmatched [");
11701         }
11702         if (ret == NULL) {
11703             if (*flagp & RESTART_UTF8)
11704                 return NULL;
11705             FAIL2("panic: regclass returned NULL to regatom, flags=%#"UVxf"",
11706                   (UV) *flagp);
11707         }
11708         nextchar(pRExC_state);
11709         Set_Node_Length(ret, RExC_parse - oregcomp_parse + 1); /* MJD */
11710         break;
11711     }
11712     case '(':
11713         nextchar(pRExC_state);
11714         ret = reg(pRExC_state, 2, &flags,depth+1);
11715         if (ret == NULL) {
11716                 if (flags & TRYAGAIN) {
11717                     if (RExC_parse == RExC_end) {
11718                          /* Make parent create an empty node if needed. */
11719                         *flagp |= TRYAGAIN;
11720                         return(NULL);
11721                     }
11722                     goto tryagain;
11723                 }
11724                 if (flags & RESTART_UTF8) {
11725                     *flagp = RESTART_UTF8;
11726                     return NULL;
11727                 }
11728                 FAIL2("panic: reg returned NULL to regatom, flags=%#"UVxf"",
11729                                                                  (UV) flags);
11730         }
11731         *flagp |= flags&(HASWIDTH|SPSTART|SIMPLE|POSTPONED);
11732         break;
11733     case '|':
11734     case ')':
11735         if (flags & TRYAGAIN) {
11736             *flagp |= TRYAGAIN;
11737             return NULL;
11738         }
11739         vFAIL("Internal urp");
11740                                 /* Supposed to be caught earlier. */
11741         break;
11742     case '?':
11743     case '+':
11744     case '*':
11745         RExC_parse++;
11746         vFAIL("Quantifier follows nothing");
11747         break;
11748     case '\\':
11749         /* Special Escapes
11750
11751            This switch handles escape sequences that resolve to some kind
11752            of special regop and not to literal text. Escape sequnces that
11753            resolve to literal text are handled below in the switch marked
11754            "Literal Escapes".
11755
11756            Every entry in this switch *must* have a corresponding entry
11757            in the literal escape switch. However, the opposite is not
11758            required, as the default for this switch is to jump to the
11759            literal text handling code.
11760         */
11761         switch ((U8)*++RExC_parse) {
11762         /* Special Escapes */
11763         case 'A':
11764             RExC_seen_zerolen++;
11765             ret = reg_node(pRExC_state, SBOL);
11766             /* SBOL is shared with /^/ so we set the flags so we can tell
11767              * /\A/ from /^/ in split. We check ret because first pass we
11768              * have no regop struct to set the flags on. */
11769             if (PASS2)
11770                 ret->flags = 1;
11771             *flagp |= SIMPLE;
11772             goto finish_meta_pat;
11773         case 'G':
11774             ret = reg_node(pRExC_state, GPOS);
11775             RExC_seen |= REG_GPOS_SEEN;
11776             *flagp |= SIMPLE;
11777             goto finish_meta_pat;
11778         case 'K':
11779             RExC_seen_zerolen++;
11780             ret = reg_node(pRExC_state, KEEPS);
11781             *flagp |= SIMPLE;
11782             /* XXX:dmq : disabling in-place substitution seems to
11783              * be necessary here to avoid cases of memory corruption, as
11784              * with: C<$_="x" x 80; s/x\K/y/> -- rgs
11785              */
11786             RExC_seen |= REG_LOOKBEHIND_SEEN;
11787             goto finish_meta_pat;
11788         case 'Z':
11789             ret = reg_node(pRExC_state, SEOL);
11790             *flagp |= SIMPLE;
11791             RExC_seen_zerolen++;                /* Do not optimize RE away */
11792             goto finish_meta_pat;
11793         case 'z':
11794             ret = reg_node(pRExC_state, EOS);
11795             *flagp |= SIMPLE;
11796             RExC_seen_zerolen++;                /* Do not optimize RE away */
11797             goto finish_meta_pat;
11798         case 'C':
11799             vFAIL("\\C no longer supported");
11800         case 'X':
11801             ret = reg_node(pRExC_state, CLUMP);
11802             *flagp |= HASWIDTH;
11803             goto finish_meta_pat;
11804
11805         case 'W':
11806             invert = 1;
11807             /* FALLTHROUGH */
11808         case 'w':
11809             arg = ANYOF_WORDCHAR;
11810             goto join_posix;
11811
11812         case 'B':
11813             invert = 1;
11814             /* FALLTHROUGH */
11815         case 'b':
11816           {
11817             regex_charset charset = get_regex_charset(RExC_flags);
11818
11819             RExC_seen_zerolen++;
11820             RExC_seen |= REG_LOOKBEHIND_SEEN;
11821             op = BOUND + charset;
11822
11823             if (op == BOUNDL) {
11824                 RExC_contains_locale = 1;
11825             }
11826
11827             ret = reg_node(pRExC_state, op);
11828             *flagp |= SIMPLE;
11829             if (*(RExC_parse + 1) != '{') {
11830                 FLAGS(ret) = TRADITIONAL_BOUND;
11831                 if (PASS2 && op > BOUNDA) {  /* /aa is same as /a */
11832                     OP(ret) = BOUNDA;
11833                 }
11834             }
11835             else {
11836                 STRLEN length;
11837                 char name = *RExC_parse;
11838                 char * endbrace;
11839                 RExC_parse += 2;
11840                 endbrace = strchr(RExC_parse, '}');
11841
11842                 if (! endbrace) {
11843                     vFAIL2("Missing right brace on \\%c{}", name);
11844                 }
11845                 /* XXX Need to decide whether to take spaces or not.  Should be
11846                  * consistent with \p{}, but that currently is SPACE, which
11847                  * means vertical too, which seems wrong
11848                  * while (isBLANK(*RExC_parse)) {
11849                     RExC_parse++;
11850                 }*/
11851                 if (endbrace == RExC_parse) {
11852                     RExC_parse++;  /* After the '}' */
11853                     vFAIL2("Empty \\%c{}", name);
11854                 }
11855                 length = endbrace - RExC_parse;
11856                 /*while (isBLANK(*(RExC_parse + length - 1))) {
11857                     length--;
11858                 }*/
11859                 switch (*RExC_parse) {
11860                     case 'g':
11861                         if (length != 1
11862                             && (length != 3 || strnNE(RExC_parse + 1, "cb", 2)))
11863                         {
11864                             goto bad_bound_type;
11865                         }
11866                         FLAGS(ret) = GCB_BOUND;
11867                         break;
11868                     case 's':
11869                         if (length != 2 || *(RExC_parse + 1) != 'b') {
11870                             goto bad_bound_type;
11871                         }
11872                         FLAGS(ret) = SB_BOUND;
11873                         break;
11874                     case 'w':
11875                         if (length != 2 || *(RExC_parse + 1) != 'b') {
11876                             goto bad_bound_type;
11877                         }
11878                         FLAGS(ret) = WB_BOUND;
11879                         break;
11880                     default:
11881                       bad_bound_type:
11882                         RExC_parse = endbrace;
11883                         vFAIL2utf8f(
11884                             "'%"UTF8f"' is an unknown bound type",
11885                             UTF8fARG(UTF, length, endbrace - length));
11886                         NOT_REACHED; /*NOTREACHED*/
11887                 }
11888                 RExC_parse = endbrace;
11889                 RExC_uni_semantics = 1;
11890
11891                 if (PASS2 && op >= BOUNDA) {  /* /aa is same as /a */
11892                     OP(ret) = BOUNDU;
11893                     length += 4;
11894
11895                     /* Don't have to worry about UTF-8, in this message because
11896                      * to get here the contents of the \b must be ASCII */
11897                     ckWARN4reg(RExC_parse + 1,  /* Include the '}' in msg */
11898                               "Using /u for '%.*s' instead of /%s",
11899                               (unsigned) length,
11900                               endbrace - length + 1,
11901                               (charset == REGEX_ASCII_RESTRICTED_CHARSET)
11902                               ? ASCII_RESTRICT_PAT_MODS
11903                               : ASCII_MORE_RESTRICT_PAT_MODS);
11904                 }
11905             }
11906
11907             if (PASS2 && invert) {
11908                 OP(ret) += NBOUND - BOUND;
11909             }
11910             goto finish_meta_pat;
11911           }
11912
11913         case 'D':
11914             invert = 1;
11915             /* FALLTHROUGH */
11916         case 'd':
11917             arg = ANYOF_DIGIT;
11918             if (! DEPENDS_SEMANTICS) {
11919                 goto join_posix;
11920             }
11921
11922             /* \d doesn't have any matches in the upper Latin1 range, hence /d
11923              * is equivalent to /u.  Changing to /u saves some branches at
11924              * runtime */
11925             op = POSIXU;
11926             goto join_posix_op_known;
11927
11928         case 'R':
11929             ret = reg_node(pRExC_state, LNBREAK);
11930             *flagp |= HASWIDTH|SIMPLE;
11931             goto finish_meta_pat;
11932
11933         case 'H':
11934             invert = 1;
11935             /* FALLTHROUGH */
11936         case 'h':
11937             arg = ANYOF_BLANK;
11938             op = POSIXU;
11939             goto join_posix_op_known;
11940
11941         case 'V':
11942             invert = 1;
11943             /* FALLTHROUGH */
11944         case 'v':
11945             arg = ANYOF_VERTWS;
11946             op = POSIXU;
11947             goto join_posix_op_known;
11948
11949         case 'S':
11950             invert = 1;
11951             /* FALLTHROUGH */
11952         case 's':
11953             arg = ANYOF_SPACE;
11954
11955           join_posix:
11956
11957             op = POSIXD + get_regex_charset(RExC_flags);
11958             if (op > POSIXA) {  /* /aa is same as /a */
11959                 op = POSIXA;
11960             }
11961             else if (op == POSIXL) {
11962                 RExC_contains_locale = 1;
11963             }
11964
11965           join_posix_op_known:
11966
11967             if (invert) {
11968                 op += NPOSIXD - POSIXD;
11969             }
11970
11971             ret = reg_node(pRExC_state, op);
11972             if (! SIZE_ONLY) {
11973                 FLAGS(ret) = namedclass_to_classnum(arg);
11974             }
11975
11976             *flagp |= HASWIDTH|SIMPLE;
11977             /* FALLTHROUGH */
11978
11979           finish_meta_pat:
11980             nextchar(pRExC_state);
11981             Set_Node_Length(ret, 2); /* MJD */
11982             break;
11983         case 'p':
11984         case 'P':
11985             {
11986 #ifdef DEBUGGING
11987                 char* parse_start = RExC_parse - 2;
11988 #endif
11989
11990                 RExC_parse--;
11991
11992                 ret = regclass(pRExC_state, flagp,depth+1,
11993                                TRUE, /* means just parse this element */
11994                                FALSE, /* don't allow multi-char folds */
11995                                FALSE, /* don't silence non-portable warnings.
11996                                          It would be a bug if these returned
11997                                          non-portables */
11998                                (bool) RExC_strict,
11999                                NULL);
12000                 /* regclass() can only return RESTART_UTF8 if multi-char folds
12001                    are allowed.  */
12002                 if (!ret)
12003                     FAIL2("panic: regclass returned NULL to regatom, flags=%#"UVxf"",
12004                           (UV) *flagp);
12005
12006                 RExC_parse--;
12007
12008                 Set_Node_Offset(ret, parse_start + 2);
12009                 Set_Node_Cur_Length(ret, parse_start);
12010                 nextchar(pRExC_state);
12011             }
12012             break;
12013         case 'N':
12014             /* Handle \N, \N{} and \N{NAMED SEQUENCE} (the latter meaning the
12015              * \N{...} evaluates to a sequence of more than one code points).
12016              * The function call below returns a regnode, which is our result.
12017              * The parameters cause it to fail if the \N{} evaluates to a
12018              * single code point; we handle those like any other literal.  The
12019              * reason that the multicharacter case is handled here and not as
12020              * part of the EXACtish code is because of quantifiers.  In
12021              * /\N{BLAH}+/, the '+' applies to the whole thing, and doing it
12022              * this way makes that Just Happen. dmq.
12023              * join_exact() will join this up with adjacent EXACTish nodes
12024              * later on, if appropriate. */
12025             ++RExC_parse;
12026             if (grok_bslash_N(pRExC_state,
12027                               &ret,     /* Want a regnode returned */
12028                               NULL,     /* Fail if evaluates to a single code
12029                                            point */
12030                               NULL,     /* Don't need a count of how many code
12031                                            points */
12032                               flagp,
12033                               depth)
12034             ) {
12035                 break;
12036             }
12037
12038             if (*flagp & RESTART_UTF8)
12039                 return NULL;
12040             RExC_parse--;
12041             goto defchar;
12042
12043         case 'k':    /* Handle \k<NAME> and \k'NAME' */
12044       parse_named_seq:
12045         {
12046             char ch= RExC_parse[1];
12047             if (ch != '<' && ch != '\'' && ch != '{') {
12048                 RExC_parse++;
12049                 /* diag_listed_as: Sequence \%s... not terminated in regex; marked by <-- HERE in m/%s/ */
12050                 vFAIL2("Sequence %.2s... not terminated",parse_start);
12051             } else {
12052                 /* this pretty much dupes the code for (?P=...) in reg(), if
12053                    you change this make sure you change that */
12054                 char* name_start = (RExC_parse += 2);
12055                 U32 num = 0;
12056                 SV *sv_dat = reg_scan_name(pRExC_state,
12057                     SIZE_ONLY ? REG_RSN_RETURN_NULL : REG_RSN_RETURN_DATA);
12058                 ch= (ch == '<') ? '>' : (ch == '{') ? '}' : '\'';
12059                 if (RExC_parse == name_start || *RExC_parse != ch)
12060                     /* diag_listed_as: Sequence \%s... not terminated in regex; marked by <-- HERE in m/%s/ */
12061                     vFAIL2("Sequence %.3s... not terminated",parse_start);
12062
12063                 if (!SIZE_ONLY) {
12064                     num = add_data( pRExC_state, STR_WITH_LEN("S"));
12065                     RExC_rxi->data->data[num]=(void*)sv_dat;
12066                     SvREFCNT_inc_simple_void(sv_dat);
12067                 }
12068
12069                 RExC_sawback = 1;
12070                 ret = reganode(pRExC_state,
12071                                ((! FOLD)
12072                                  ? NREF
12073                                  : (ASCII_FOLD_RESTRICTED)
12074                                    ? NREFFA
12075                                    : (AT_LEAST_UNI_SEMANTICS)
12076                                      ? NREFFU
12077                                      : (LOC)
12078                                        ? NREFFL
12079                                        : NREFF),
12080                                 num);
12081                 *flagp |= HASWIDTH;
12082
12083                 /* override incorrect value set in reganode MJD */
12084                 Set_Node_Offset(ret, parse_start+1);
12085                 Set_Node_Cur_Length(ret, parse_start);
12086                 nextchar(pRExC_state);
12087
12088             }
12089             break;
12090         }
12091         case 'g':
12092         case '1': case '2': case '3': case '4':
12093         case '5': case '6': case '7': case '8': case '9':
12094             {
12095                 I32 num;
12096                 bool hasbrace = 0;
12097
12098                 if (*RExC_parse == 'g') {
12099                     bool isrel = 0;
12100
12101                     RExC_parse++;
12102                     if (*RExC_parse == '{') {
12103                         RExC_parse++;
12104                         hasbrace = 1;
12105                     }
12106                     if (*RExC_parse == '-') {
12107                         RExC_parse++;
12108                         isrel = 1;
12109                     }
12110                     if (hasbrace && !isDIGIT(*RExC_parse)) {
12111                         if (isrel) RExC_parse--;
12112                         RExC_parse -= 2;
12113                         goto parse_named_seq;
12114                     }
12115
12116                     num = S_backref_value(RExC_parse);
12117                     if (num == 0)
12118                         vFAIL("Reference to invalid group 0");
12119                     else if (num == I32_MAX) {
12120                          if (isDIGIT(*RExC_parse))
12121                             vFAIL("Reference to nonexistent group");
12122                         else
12123                             vFAIL("Unterminated \\g... pattern");
12124                     }
12125
12126                     if (isrel) {
12127                         num = RExC_npar - num;
12128                         if (num < 1)
12129                             vFAIL("Reference to nonexistent or unclosed group");
12130                     }
12131                 }
12132                 else {
12133                     num = S_backref_value(RExC_parse);
12134                     /* bare \NNN might be backref or octal - if it is larger
12135                      * than or equal RExC_npar then it is assumed to be an
12136                      * octal escape. Note RExC_npar is +1 from the actual
12137                      * number of parens. */
12138                     /* Note we do NOT check if num == I32_MAX here, as that is
12139                      * handled by the RExC_npar check */
12140
12141                     if (
12142                         /* any numeric escape < 10 is always a backref */
12143                         num > 9
12144                         /* any numeric escape < RExC_npar is a backref */
12145                         && num >= RExC_npar
12146                         /* cannot be an octal escape if it starts with 8 */
12147                         && *RExC_parse != '8'
12148                         /* cannot be an octal escape it it starts with 9 */
12149                         && *RExC_parse != '9'
12150                     )
12151                     {
12152                         /* Probably not a backref, instead likely to be an
12153                          * octal character escape, e.g. \35 or \777.
12154                          * The above logic should make it obvious why using
12155                          * octal escapes in patterns is problematic. - Yves */
12156                         goto defchar;
12157                     }
12158                 }
12159
12160                 /* At this point RExC_parse points at a numeric escape like
12161                  * \12 or \88 or something similar, which we should NOT treat
12162                  * as an octal escape. It may or may not be a valid backref
12163                  * escape. For instance \88888888 is unlikely to be a valid
12164                  * backref. */
12165                 {
12166 #ifdef RE_TRACK_PATTERN_OFFSETS
12167                     char * const parse_start = RExC_parse - 1; /* MJD */
12168 #endif
12169                     while (isDIGIT(*RExC_parse))
12170                         RExC_parse++;
12171                     if (hasbrace) {
12172                         if (*RExC_parse != '}')
12173                             vFAIL("Unterminated \\g{...} pattern");
12174                         RExC_parse++;
12175                     }
12176                     if (!SIZE_ONLY) {
12177                         if (num > (I32)RExC_rx->nparens)
12178                             vFAIL("Reference to nonexistent group");
12179                     }
12180                     RExC_sawback = 1;
12181                     ret = reganode(pRExC_state,
12182                                    ((! FOLD)
12183                                      ? REF
12184                                      : (ASCII_FOLD_RESTRICTED)
12185                                        ? REFFA
12186                                        : (AT_LEAST_UNI_SEMANTICS)
12187                                          ? REFFU
12188                                          : (LOC)
12189                                            ? REFFL
12190                                            : REFF),
12191                                     num);
12192                     *flagp |= HASWIDTH;
12193
12194                     /* override incorrect value set in reganode MJD */
12195                     Set_Node_Offset(ret, parse_start+1);
12196                     Set_Node_Cur_Length(ret, parse_start);
12197                     RExC_parse--;
12198                     nextchar(pRExC_state);
12199                 }
12200             }
12201             break;
12202         case '\0':
12203             if (RExC_parse >= RExC_end)
12204                 FAIL("Trailing \\");
12205             /* FALLTHROUGH */
12206         default:
12207             /* Do not generate "unrecognized" warnings here, we fall
12208                back into the quick-grab loop below */
12209             parse_start--;
12210             goto defchar;
12211         }
12212         break;
12213
12214     case '#':
12215         if (RExC_flags & RXf_PMf_EXTENDED) {
12216             RExC_parse = reg_skipcomment( pRExC_state, RExC_parse );
12217             if (RExC_parse < RExC_end)
12218                 goto tryagain;
12219         }
12220         /* FALLTHROUGH */
12221
12222     default:
12223
12224             parse_start = RExC_parse - 1;
12225
12226             RExC_parse++;
12227
12228           defchar: {
12229             STRLEN len = 0;
12230             UV ender = 0;
12231             char *p;
12232             char *s;
12233 #define MAX_NODE_STRING_SIZE 127
12234             char foldbuf[MAX_NODE_STRING_SIZE+UTF8_MAXBYTES_CASE];
12235             char *s0;
12236             U8 upper_parse = MAX_NODE_STRING_SIZE;
12237             U8 node_type = compute_EXACTish(pRExC_state);
12238             bool next_is_quantifier;
12239             char * oldp = NULL;
12240
12241             /* We can convert EXACTF nodes to EXACTFU if they contain only
12242              * characters that match identically regardless of the target
12243              * string's UTF8ness.  The reason to do this is that EXACTF is not
12244              * trie-able, EXACTFU is.
12245              *
12246              * Similarly, we can convert EXACTFL nodes to EXACTFU if they
12247              * contain only above-Latin1 characters (hence must be in UTF8),
12248              * which don't participate in folds with Latin1-range characters,
12249              * as the latter's folds aren't known until runtime.  (We don't
12250              * need to figure this out until pass 2) */
12251             bool maybe_exactfu = PASS2
12252                                && (node_type == EXACTF || node_type == EXACTFL);
12253
12254             /* If a folding node contains only code points that don't
12255              * participate in folds, it can be changed into an EXACT node,
12256              * which allows the optimizer more things to look for */
12257             bool maybe_exact;
12258
12259             ret = reg_node(pRExC_state, node_type);
12260
12261             /* In pass1, folded, we use a temporary buffer instead of the
12262              * actual node, as the node doesn't exist yet */
12263             s = (SIZE_ONLY && FOLD) ? foldbuf : STRING(ret);
12264
12265             s0 = s;
12266
12267           reparse:
12268
12269             /* We do the EXACTFish to EXACT node only if folding.  (And we
12270              * don't need to figure this out until pass 2) */
12271             maybe_exact = FOLD && PASS2;
12272
12273             /* XXX The node can hold up to 255 bytes, yet this only goes to
12274              * 127.  I (khw) do not know why.  Keeping it somewhat less than
12275              * 255 allows us to not have to worry about overflow due to
12276              * converting to utf8 and fold expansion, but that value is
12277              * 255-UTF8_MAXBYTES_CASE.  join_exact() may join adjacent nodes
12278              * split up by this limit into a single one using the real max of
12279              * 255.  Even at 127, this breaks under rare circumstances.  If
12280              * folding, we do not want to split a node at a character that is a
12281              * non-final in a multi-char fold, as an input string could just
12282              * happen to want to match across the node boundary.  The join
12283              * would solve that problem if the join actually happens.  But a
12284              * series of more than two nodes in a row each of 127 would cause
12285              * the first join to succeed to get to 254, but then there wouldn't
12286              * be room for the next one, which could at be one of those split
12287              * multi-char folds.  I don't know of any fool-proof solution.  One
12288              * could back off to end with only a code point that isn't such a
12289              * non-final, but it is possible for there not to be any in the
12290              * entire node. */
12291             for (p = RExC_parse - 1;
12292                  len < upper_parse && p < RExC_end;
12293                  len++)
12294             {
12295                 oldp = p;
12296
12297                 if (RExC_flags & RXf_PMf_EXTENDED)
12298                     p = regpatws(pRExC_state, p,
12299                                           TRUE); /* means recognize comments */
12300                 switch ((U8)*p) {
12301                 case '^':
12302                 case '$':
12303                 case '.':
12304                 case '[':
12305                 case '(':
12306                 case ')':
12307                 case '|':
12308                     goto loopdone;
12309                 case '\\':
12310                     /* Literal Escapes Switch
12311
12312                        This switch is meant to handle escape sequences that
12313                        resolve to a literal character.
12314
12315                        Every escape sequence that represents something
12316                        else, like an assertion or a char class, is handled
12317                        in the switch marked 'Special Escapes' above in this
12318                        routine, but also has an entry here as anything that
12319                        isn't explicitly mentioned here will be treated as
12320                        an unescaped equivalent literal.
12321                     */
12322
12323                     switch ((U8)*++p) {
12324                     /* These are all the special escapes. */
12325                     case 'A':             /* Start assertion */
12326                     case 'b': case 'B':   /* Word-boundary assertion*/
12327                     case 'C':             /* Single char !DANGEROUS! */
12328                     case 'd': case 'D':   /* digit class */
12329                     case 'g': case 'G':   /* generic-backref, pos assertion */
12330                     case 'h': case 'H':   /* HORIZWS */
12331                     case 'k': case 'K':   /* named backref, keep marker */
12332                     case 'p': case 'P':   /* Unicode property */
12333                               case 'R':   /* LNBREAK */
12334                     case 's': case 'S':   /* space class */
12335                     case 'v': case 'V':   /* VERTWS */
12336                     case 'w': case 'W':   /* word class */
12337                     case 'X':             /* eXtended Unicode "combining
12338                                              character sequence" */
12339                     case 'z': case 'Z':   /* End of line/string assertion */
12340                         --p;
12341                         goto loopdone;
12342
12343                     /* Anything after here is an escape that resolves to a
12344                        literal. (Except digits, which may or may not)
12345                      */
12346                     case 'n':
12347                         ender = '\n';
12348                         p++;
12349                         break;
12350                     case 'N': /* Handle a single-code point named character. */
12351                         RExC_parse = p + 1;
12352                         if (! grok_bslash_N(pRExC_state,
12353                                             NULL,   /* Fail if evaluates to
12354                                                        anything other than a
12355                                                        single code point */
12356                                             &ender, /* The returned single code
12357                                                        point */
12358                                             NULL,   /* Don't need a count of
12359                                                        how many code points */
12360                                             flagp,
12361                                             depth)
12362                         ) {
12363                             if (*flagp & RESTART_UTF8)
12364                                 FAIL("panic: grok_bslash_N set RESTART_UTF8");
12365
12366                             /* Here, it wasn't a single code point.  Go close
12367                              * up this EXACTish node.  The switch() prior to
12368                              * this switch handles the other cases */
12369                             RExC_parse = p = oldp;
12370                             goto loopdone;
12371                         }
12372                         p = RExC_parse;
12373                         if (ender > 0xff) {
12374                             REQUIRE_UTF8;
12375                         }
12376                         break;
12377                     case 'r':
12378                         ender = '\r';
12379                         p++;
12380                         break;
12381                     case 't':
12382                         ender = '\t';
12383                         p++;
12384                         break;
12385                     case 'f':
12386                         ender = '\f';
12387                         p++;
12388                         break;
12389                     case 'e':
12390                         ender = ESC_NATIVE;
12391                         p++;
12392                         break;
12393                     case 'a':
12394                         ender = '\a';
12395                         p++;
12396                         break;
12397                     case 'o':
12398                         {
12399                             UV result;
12400                             const char* error_msg;
12401
12402                             bool valid = grok_bslash_o(&p,
12403                                                        &result,
12404                                                        &error_msg,
12405                                                        PASS2, /* out warnings */
12406                                                        (bool) RExC_strict,
12407                                                        TRUE, /* Output warnings
12408                                                                 for non-
12409                                                                 portables */
12410                                                        UTF);
12411                             if (! valid) {
12412                                 RExC_parse = p; /* going to die anyway; point
12413                                                    to exact spot of failure */
12414                                 vFAIL(error_msg);
12415                             }
12416                             ender = result;
12417                             if (IN_ENCODING && ender < 0x100) {
12418                                 goto recode_encoding;
12419                             }
12420                             if (ender > 0xff) {
12421                                 REQUIRE_UTF8;
12422                             }
12423                             break;
12424                         }
12425                     case 'x':
12426                         {
12427                             UV result = UV_MAX; /* initialize to erroneous
12428                                                    value */
12429                             const char* error_msg;
12430
12431                             bool valid = grok_bslash_x(&p,
12432                                                        &result,
12433                                                        &error_msg,
12434                                                        PASS2, /* out warnings */
12435                                                        (bool) RExC_strict,
12436                                                        TRUE, /* Silence warnings
12437                                                                 for non-
12438                                                                 portables */
12439                                                        UTF);
12440                             if (! valid) {
12441                                 RExC_parse = p; /* going to die anyway; point
12442                                                    to exact spot of failure */
12443                                 vFAIL(error_msg);
12444                             }
12445                             ender = result;
12446
12447                             if (ender < 0x100) {
12448 #ifdef EBCDIC
12449                                 if (RExC_recode_x_to_native) {
12450                                     ender = LATIN1_TO_NATIVE(ender);
12451                                 }
12452                                 else
12453 #endif
12454                                 if (IN_ENCODING) {
12455                                     goto recode_encoding;
12456                                 }
12457                             }
12458                             else {
12459                                 REQUIRE_UTF8;
12460                             }
12461                             break;
12462                         }
12463                     case 'c':
12464                         p++;
12465                         ender = grok_bslash_c(*p++, PASS2);
12466                         break;
12467                     case '8': case '9': /* must be a backreference */
12468                         --p;
12469                         /* we have an escape like \8 which cannot be an octal escape
12470                          * so we exit the loop, and let the outer loop handle this
12471                          * escape which may or may not be a legitimate backref. */
12472                         goto loopdone;
12473                     case '1': case '2': case '3':case '4':
12474                     case '5': case '6': case '7':
12475                         /* When we parse backslash escapes there is ambiguity
12476                          * between backreferences and octal escapes. Any escape
12477                          * from \1 - \9 is a backreference, any multi-digit
12478                          * escape which does not start with 0 and which when
12479                          * evaluated as decimal could refer to an already
12480                          * parsed capture buffer is a back reference. Anything
12481                          * else is octal.
12482                          *
12483                          * Note this implies that \118 could be interpreted as
12484                          * 118 OR as "\11" . "8" depending on whether there
12485                          * were 118 capture buffers defined already in the
12486                          * pattern.  */
12487
12488                         /* NOTE, RExC_npar is 1 more than the actual number of
12489                          * parens we have seen so far, hence the < RExC_npar below. */
12490
12491                         if ( !isDIGIT(p[1]) || S_backref_value(p) < RExC_npar)
12492                         {  /* Not to be treated as an octal constant, go
12493                                    find backref */
12494                             --p;
12495                             goto loopdone;
12496                         }
12497                         /* FALLTHROUGH */
12498                     case '0':
12499                         {
12500                             I32 flags = PERL_SCAN_SILENT_ILLDIGIT;
12501                             STRLEN numlen = 3;
12502                             ender = grok_oct(p, &numlen, &flags, NULL);
12503                             if (ender > 0xff) {
12504                                 REQUIRE_UTF8;
12505                             }
12506                             p += numlen;
12507                             if (PASS2   /* like \08, \178 */
12508                                 && numlen < 3
12509                                 && p < RExC_end
12510                                 && isDIGIT(*p) && ckWARN(WARN_REGEXP))
12511                             {
12512                                 reg_warn_non_literal_string(
12513                                          p + 1,
12514                                          form_short_octal_warning(p, numlen));
12515                             }
12516                         }
12517                         if (IN_ENCODING && ender < 0x100)
12518                             goto recode_encoding;
12519                         break;
12520                       recode_encoding:
12521                         if (! RExC_override_recoding) {
12522                             SV* enc = _get_encoding();
12523                             ender = reg_recode((const char)(U8)ender, &enc);
12524                             if (!enc && PASS2)
12525                                 ckWARNreg(p, "Invalid escape in the specified encoding");
12526                             REQUIRE_UTF8;
12527                         }
12528                         break;
12529                     case '\0':
12530                         if (p >= RExC_end)
12531                             FAIL("Trailing \\");
12532                         /* FALLTHROUGH */
12533                     default:
12534                         if (!SIZE_ONLY&& isALPHANUMERIC(*p)) {
12535                             /* Include any { following the alpha to emphasize
12536                              * that it could be part of an escape at some point
12537                              * in the future */
12538                             int len = (isALPHA(*p) && *(p + 1) == '{') ? 2 : 1;
12539                             ckWARN3reg(p + len, "Unrecognized escape \\%.*s passed through", len, p);
12540                         }
12541                         goto normal_default;
12542                     } /* End of switch on '\' */
12543                     break;
12544                 case '{':
12545                     /* Currently we don't warn when the lbrace is at the start
12546                      * of a construct.  This catches it in the middle of a
12547                      * literal string, or when its the first thing after
12548                      * something like "\b" */
12549                     if (! SIZE_ONLY
12550                         && (len || (p > RExC_start && isALPHA_A(*(p -1)))))
12551                     {
12552                         ckWARNregdep(p + 1, "Unescaped left brace in regex is deprecated, passed through");
12553                     }
12554                     /*FALLTHROUGH*/
12555                 default:    /* A literal character */
12556                   normal_default:
12557                     if (UTF8_IS_START(*p) && UTF) {
12558                         STRLEN numlen;
12559                         ender = utf8n_to_uvchr((U8*)p, RExC_end - p,
12560                                                &numlen, UTF8_ALLOW_DEFAULT);
12561                         p += numlen;
12562                     }
12563                     else
12564                         ender = (U8) *p++;
12565                     break;
12566                 } /* End of switch on the literal */
12567
12568                 /* Here, have looked at the literal character and <ender>
12569                  * contains its ordinal, <p> points to the character after it
12570                  */
12571
12572                 if ( RExC_flags & RXf_PMf_EXTENDED)
12573                     p = regpatws(pRExC_state, p,
12574                                           TRUE); /* means recognize comments */
12575
12576                 /* If the next thing is a quantifier, it applies to this
12577                  * character only, which means that this character has to be in
12578                  * its own node and can't just be appended to the string in an
12579                  * existing node, so if there are already other characters in
12580                  * the node, close the node with just them, and set up to do
12581                  * this character again next time through, when it will be the
12582                  * only thing in its new node */
12583                 if ((next_is_quantifier = (p < RExC_end && ISMULT2(p))) && len)
12584                 {
12585                     p = oldp;
12586                     goto loopdone;
12587                 }
12588
12589                 if (! FOLD) {  /* The simple case, just append the literal */
12590
12591                     /* In the sizing pass, we need only the size of the
12592                      * character we are appending, hence we can delay getting
12593                      * its representation until PASS2. */
12594                     if (SIZE_ONLY) {
12595                         if (UTF) {
12596                             const STRLEN unilen = UNISKIP(ender);
12597                             s += unilen;
12598
12599                             /* We have to subtract 1 just below (and again in
12600                              * the corresponding PASS2 code) because the loop
12601                              * increments <len> each time, as all but this path
12602                              * (and one other) through it add a single byte to
12603                              * the EXACTish node.  But these paths would change
12604                              * len to be the correct final value, so cancel out
12605                              * the increment that follows */
12606                             len += unilen - 1;
12607                         }
12608                         else {
12609                             s++;
12610                         }
12611                     } else { /* PASS2 */
12612                       not_fold_common:
12613                         if (UTF) {
12614                             U8 * new_s = uvchr_to_utf8((U8*)s, ender);
12615                             len += (char *) new_s - s - 1;
12616                             s = (char *) new_s;
12617                         }
12618                         else {
12619                             *(s++) = (char) ender;
12620                         }
12621                     }
12622                 }
12623                 else if (LOC && is_PROBLEMATIC_LOCALE_FOLD_cp(ender)) {
12624
12625                     /* Here are folding under /l, and the code point is
12626                      * problematic.  First, we know we can't simplify things */
12627                     maybe_exact = FALSE;
12628                     maybe_exactfu = FALSE;
12629
12630                     /* A problematic code point in this context means that its
12631                      * fold isn't known until runtime, so we can't fold it now.
12632                      * (The non-problematic code points are the above-Latin1
12633                      * ones that fold to also all above-Latin1.  Their folds
12634                      * don't vary no matter what the locale is.) But here we
12635                      * have characters whose fold depends on the locale.
12636                      * Unlike the non-folding case above, we have to keep track
12637                      * of these in the sizing pass, so that we can make sure we
12638                      * don't split too-long nodes in the middle of a potential
12639                      * multi-char fold.  And unlike the regular fold case
12640                      * handled in the else clauses below, we don't actually
12641                      * fold and don't have special cases to consider.  What we
12642                      * do for both passes is the PASS2 code for non-folding */
12643                     goto not_fold_common;
12644                 }
12645                 else /* A regular FOLD code point */
12646                     if (! ( UTF
12647                         /* See comments for join_exact() as to why we fold this
12648                          * non-UTF at compile time */
12649                         || (node_type == EXACTFU
12650                             && ender == LATIN_SMALL_LETTER_SHARP_S)))
12651                 {
12652                     /* Here, are folding and are not UTF-8 encoded; therefore
12653                      * the character must be in the range 0-255, and is not /l
12654                      * (Not /l because we already handled these under /l in
12655                      * is_PROBLEMATIC_LOCALE_FOLD_cp) */
12656                     if (IS_IN_SOME_FOLD_L1(ender)) {
12657                         maybe_exact = FALSE;
12658
12659                         /* See if the character's fold differs between /d and
12660                          * /u.  This includes the multi-char fold SHARP S to
12661                          * 'ss' */
12662                         if (maybe_exactfu
12663                             && (PL_fold[ender] != PL_fold_latin1[ender]
12664                                 || ender == LATIN_SMALL_LETTER_SHARP_S
12665                                 || (len > 0
12666                                    && isALPHA_FOLD_EQ(ender, 's')
12667                                    && isALPHA_FOLD_EQ(*(s-1), 's'))))
12668                         {
12669                             maybe_exactfu = FALSE;
12670                         }
12671                     }
12672
12673                     /* Even when folding, we store just the input character, as
12674                      * we have an array that finds its fold quickly */
12675                     *(s++) = (char) ender;
12676                 }
12677                 else {  /* FOLD and UTF */
12678                     /* Unlike the non-fold case, we do actually have to
12679                      * calculate the results here in pass 1.  This is for two
12680                      * reasons, the folded length may be longer than the
12681                      * unfolded, and we have to calculate how many EXACTish
12682                      * nodes it will take; and we may run out of room in a node
12683                      * in the middle of a potential multi-char fold, and have
12684                      * to back off accordingly.  */
12685
12686                     UV folded;
12687                     if (isASCII_uni(ender)) {
12688                         folded = toFOLD(ender);
12689                         *(s)++ = (U8) folded;
12690                     }
12691                     else {
12692                         STRLEN foldlen;
12693
12694                         folded = _to_uni_fold_flags(
12695                                      ender,
12696                                      (U8 *) s,
12697                                      &foldlen,
12698                                      FOLD_FLAGS_FULL | ((ASCII_FOLD_RESTRICTED)
12699                                                         ? FOLD_FLAGS_NOMIX_ASCII
12700                                                         : 0));
12701                         s += foldlen;
12702
12703                         /* The loop increments <len> each time, as all but this
12704                          * path (and one other) through it add a single byte to
12705                          * the EXACTish node.  But this one has changed len to
12706                          * be the correct final value, so subtract one to
12707                          * cancel out the increment that follows */
12708                         len += foldlen - 1;
12709                     }
12710                     /* If this node only contains non-folding code points so
12711                      * far, see if this new one is also non-folding */
12712                     if (maybe_exact) {
12713                         if (folded != ender) {
12714                             maybe_exact = FALSE;
12715                         }
12716                         else {
12717                             /* Here the fold is the original; we have to check
12718                              * further to see if anything folds to it */
12719                             if (_invlist_contains_cp(PL_utf8_foldable,
12720                                                         ender))
12721                             {
12722                                 maybe_exact = FALSE;
12723                             }
12724                         }
12725                     }
12726                     ender = folded;
12727                 }
12728
12729                 if (next_is_quantifier) {
12730
12731                     /* Here, the next input is a quantifier, and to get here,
12732                      * the current character is the only one in the node.
12733                      * Also, here <len> doesn't include the final byte for this
12734                      * character */
12735                     len++;
12736                     goto loopdone;
12737                 }
12738
12739             } /* End of loop through literal characters */
12740
12741             /* Here we have either exhausted the input or ran out of room in
12742              * the node.  (If we encountered a character that can't be in the
12743              * node, transfer is made directly to <loopdone>, and so we
12744              * wouldn't have fallen off the end of the loop.)  In the latter
12745              * case, we artificially have to split the node into two, because
12746              * we just don't have enough space to hold everything.  This
12747              * creates a problem if the final character participates in a
12748              * multi-character fold in the non-final position, as a match that
12749              * should have occurred won't, due to the way nodes are matched,
12750              * and our artificial boundary.  So back off until we find a non-
12751              * problematic character -- one that isn't at the beginning or
12752              * middle of such a fold.  (Either it doesn't participate in any
12753              * folds, or appears only in the final position of all the folds it
12754              * does participate in.)  A better solution with far fewer false
12755              * positives, and that would fill the nodes more completely, would
12756              * be to actually have available all the multi-character folds to
12757              * test against, and to back-off only far enough to be sure that
12758              * this node isn't ending with a partial one.  <upper_parse> is set
12759              * further below (if we need to reparse the node) to include just
12760              * up through that final non-problematic character that this code
12761              * identifies, so when it is set to less than the full node, we can
12762              * skip the rest of this */
12763             if (FOLD && p < RExC_end && upper_parse == MAX_NODE_STRING_SIZE) {
12764
12765                 const STRLEN full_len = len;
12766
12767                 assert(len >= MAX_NODE_STRING_SIZE);
12768
12769                 /* Here, <s> points to the final byte of the final character.
12770                  * Look backwards through the string until find a non-
12771                  * problematic character */
12772
12773                 if (! UTF) {
12774
12775                     /* This has no multi-char folds to non-UTF characters */
12776                     if (ASCII_FOLD_RESTRICTED) {
12777                         goto loopdone;
12778                     }
12779
12780                     while (--s >= s0 && IS_NON_FINAL_FOLD(*s)) { }
12781                     len = s - s0 + 1;
12782                 }
12783                 else {
12784                     if (!  PL_NonL1NonFinalFold) {
12785                         PL_NonL1NonFinalFold = _new_invlist_C_array(
12786                                         NonL1_Perl_Non_Final_Folds_invlist);
12787                     }
12788
12789                     /* Point to the first byte of the final character */
12790                     s = (char *) utf8_hop((U8 *) s, -1);
12791
12792                     while (s >= s0) {   /* Search backwards until find
12793                                            non-problematic char */
12794                         if (UTF8_IS_INVARIANT(*s)) {
12795
12796                             /* There are no ascii characters that participate
12797                              * in multi-char folds under /aa.  In EBCDIC, the
12798                              * non-ascii invariants are all control characters,
12799                              * so don't ever participate in any folds. */
12800                             if (ASCII_FOLD_RESTRICTED
12801                                 || ! IS_NON_FINAL_FOLD(*s))
12802                             {
12803                                 break;
12804                             }
12805                         }
12806                         else if (UTF8_IS_DOWNGRADEABLE_START(*s)) {
12807                             if (! IS_NON_FINAL_FOLD(TWO_BYTE_UTF8_TO_NATIVE(
12808                                                                   *s, *(s+1))))
12809                             {
12810                                 break;
12811                             }
12812                         }
12813                         else if (! _invlist_contains_cp(
12814                                         PL_NonL1NonFinalFold,
12815                                         valid_utf8_to_uvchr((U8 *) s, NULL)))
12816                         {
12817                             break;
12818                         }
12819
12820                         /* Here, the current character is problematic in that
12821                          * it does occur in the non-final position of some
12822                          * fold, so try the character before it, but have to
12823                          * special case the very first byte in the string, so
12824                          * we don't read outside the string */
12825                         s = (s == s0) ? s -1 : (char *) utf8_hop((U8 *) s, -1);
12826                     } /* End of loop backwards through the string */
12827
12828                     /* If there were only problematic characters in the string,
12829                      * <s> will point to before s0, in which case the length
12830                      * should be 0, otherwise include the length of the
12831                      * non-problematic character just found */
12832                     len = (s < s0) ? 0 : s - s0 + UTF8SKIP(s);
12833                 }
12834
12835                 /* Here, have found the final character, if any, that is
12836                  * non-problematic as far as ending the node without splitting
12837                  * it across a potential multi-char fold.  <len> contains the
12838                  * number of bytes in the node up-to and including that
12839                  * character, or is 0 if there is no such character, meaning
12840                  * the whole node contains only problematic characters.  In
12841                  * this case, give up and just take the node as-is.  We can't
12842                  * do any better */
12843                 if (len == 0) {
12844                     len = full_len;
12845
12846                     /* If the node ends in an 's' we make sure it stays EXACTF,
12847                      * as if it turns into an EXACTFU, it could later get
12848                      * joined with another 's' that would then wrongly match
12849                      * the sharp s */
12850                     if (maybe_exactfu && isALPHA_FOLD_EQ(ender, 's'))
12851                     {
12852                         maybe_exactfu = FALSE;
12853                     }
12854                 } else {
12855
12856                     /* Here, the node does contain some characters that aren't
12857                      * problematic.  If one such is the final character in the
12858                      * node, we are done */
12859                     if (len == full_len) {
12860                         goto loopdone;
12861                     }
12862                     else if (len + ((UTF) ? UTF8SKIP(s) : 1) == full_len) {
12863
12864                         /* If the final character is problematic, but the
12865                          * penultimate is not, back-off that last character to
12866                          * later start a new node with it */
12867                         p = oldp;
12868                         goto loopdone;
12869                     }
12870
12871                     /* Here, the final non-problematic character is earlier
12872                      * in the input than the penultimate character.  What we do
12873                      * is reparse from the beginning, going up only as far as
12874                      * this final ok one, thus guaranteeing that the node ends
12875                      * in an acceptable character.  The reason we reparse is
12876                      * that we know how far in the character is, but we don't
12877                      * know how to correlate its position with the input parse.
12878                      * An alternate implementation would be to build that
12879                      * correlation as we go along during the original parse,
12880                      * but that would entail extra work for every node, whereas
12881                      * this code gets executed only when the string is too
12882                      * large for the node, and the final two characters are
12883                      * problematic, an infrequent occurrence.  Yet another
12884                      * possible strategy would be to save the tail of the
12885                      * string, and the next time regatom is called, initialize
12886                      * with that.  The problem with this is that unless you
12887                      * back off one more character, you won't be guaranteed
12888                      * regatom will get called again, unless regbranch,
12889                      * regpiece ... are also changed.  If you do back off that
12890                      * extra character, so that there is input guaranteed to
12891                      * force calling regatom, you can't handle the case where
12892                      * just the first character in the node is acceptable.  I
12893                      * (khw) decided to try this method which doesn't have that
12894                      * pitfall; if performance issues are found, we can do a
12895                      * combination of the current approach plus that one */
12896                     upper_parse = len;
12897                     len = 0;
12898                     s = s0;
12899                     goto reparse;
12900                 }
12901             }   /* End of verifying node ends with an appropriate char */
12902
12903           loopdone:   /* Jumped to when encounters something that shouldn't be
12904                          in the node */
12905
12906             /* I (khw) don't know if you can get here with zero length, but the
12907              * old code handled this situation by creating a zero-length EXACT
12908              * node.  Might as well be NOTHING instead */
12909             if (len == 0) {
12910                 OP(ret) = NOTHING;
12911             }
12912             else {
12913                 if (FOLD) {
12914                     /* If 'maybe_exact' is still set here, means there are no
12915                      * code points in the node that participate in folds;
12916                      * similarly for 'maybe_exactfu' and code points that match
12917                      * differently depending on UTF8ness of the target string
12918                      * (for /u), or depending on locale for /l */
12919                     if (maybe_exact) {
12920                         OP(ret) = (LOC)
12921                                   ? EXACTL
12922                                   : EXACT;
12923                     }
12924                     else if (maybe_exactfu) {
12925                         OP(ret) = (LOC)
12926                                   ? EXACTFLU8
12927                                   : EXACTFU;
12928                     }
12929                 }
12930                 alloc_maybe_populate_EXACT(pRExC_state, ret, flagp, len, ender,
12931                                            FALSE /* Don't look to see if could
12932                                                     be turned into an EXACT
12933                                                     node, as we have already
12934                                                     computed that */
12935                                           );
12936             }
12937
12938             RExC_parse = p - 1;
12939             Set_Node_Cur_Length(ret, parse_start);
12940             nextchar(pRExC_state);
12941             {
12942                 /* len is STRLEN which is unsigned, need to copy to signed */
12943                 IV iv = len;
12944                 if (iv < 0)
12945                     vFAIL("Internal disaster");
12946             }
12947
12948         } /* End of label 'defchar:' */
12949         break;
12950     } /* End of giant switch on input character */
12951
12952     return(ret);
12953 }
12954
12955 STATIC char *
12956 S_regpatws(RExC_state_t *pRExC_state, char *p , const bool recognize_comment )
12957 {
12958     /* Returns the next non-pattern-white space, non-comment character (the
12959      * latter only if 'recognize_comment is true) in the string p, which is
12960      * ended by RExC_end.  See also reg_skipcomment */
12961     const char *e = RExC_end;
12962
12963     PERL_ARGS_ASSERT_REGPATWS;
12964
12965     while (p < e) {
12966         STRLEN len;
12967         if ((len = is_PATWS_safe(p, e, UTF))) {
12968             p += len;
12969         }
12970         else if (recognize_comment && *p == '#') {
12971             p = reg_skipcomment(pRExC_state, p);
12972         }
12973         else
12974             break;
12975     }
12976     return p;
12977 }
12978
12979 STATIC void
12980 S_populate_ANYOF_from_invlist(pTHX_ regnode *node, SV** invlist_ptr)
12981 {
12982     /* Uses the inversion list '*invlist_ptr' to populate the ANYOF 'node'.  It
12983      * sets up the bitmap and any flags, removing those code points from the
12984      * inversion list, setting it to NULL should it become completely empty */
12985
12986     PERL_ARGS_ASSERT_POPULATE_ANYOF_FROM_INVLIST;
12987     assert(PL_regkind[OP(node)] == ANYOF);
12988
12989     ANYOF_BITMAP_ZERO(node);
12990     if (*invlist_ptr) {
12991
12992         /* This gets set if we actually need to modify things */
12993         bool change_invlist = FALSE;
12994
12995         UV start, end;
12996
12997         /* Start looking through *invlist_ptr */
12998         invlist_iterinit(*invlist_ptr);
12999         while (invlist_iternext(*invlist_ptr, &start, &end)) {
13000             UV high;
13001             int i;
13002
13003             if (end == UV_MAX && start <= NUM_ANYOF_CODE_POINTS) {
13004                 ANYOF_FLAGS(node) |= ANYOF_MATCHES_ALL_ABOVE_BITMAP;
13005             }
13006             else if (end >= NUM_ANYOF_CODE_POINTS) {
13007                 ANYOF_FLAGS(node) |= ANYOF_HAS_UTF8_NONBITMAP_MATCHES;
13008             }
13009
13010             /* Quit if are above what we should change */
13011             if (start >= NUM_ANYOF_CODE_POINTS) {
13012                 break;
13013             }
13014
13015             change_invlist = TRUE;
13016
13017             /* Set all the bits in the range, up to the max that we are doing */
13018             high = (end < NUM_ANYOF_CODE_POINTS - 1)
13019                    ? end
13020                    : NUM_ANYOF_CODE_POINTS - 1;
13021             for (i = start; i <= (int) high; i++) {
13022                 if (! ANYOF_BITMAP_TEST(node, i)) {
13023                     ANYOF_BITMAP_SET(node, i);
13024                 }
13025             }
13026         }
13027         invlist_iterfinish(*invlist_ptr);
13028
13029         /* Done with loop; remove any code points that are in the bitmap from
13030          * *invlist_ptr; similarly for code points above the bitmap if we have
13031          * a flag to match all of them anyways */
13032         if (change_invlist) {
13033             _invlist_subtract(*invlist_ptr, PL_InBitmap, invlist_ptr);
13034         }
13035         if (ANYOF_FLAGS(node) & ANYOF_MATCHES_ALL_ABOVE_BITMAP) {
13036             _invlist_intersection(*invlist_ptr, PL_InBitmap, invlist_ptr);
13037         }
13038
13039         /* If have completely emptied it, remove it completely */
13040         if (_invlist_len(*invlist_ptr) == 0) {
13041             SvREFCNT_dec_NN(*invlist_ptr);
13042             *invlist_ptr = NULL;
13043         }
13044     }
13045 }
13046
13047 /* Parse POSIX character classes: [[:foo:]], [[=foo=]], [[.foo.]].
13048    Character classes ([:foo:]) can also be negated ([:^foo:]).
13049    Returns a named class id (ANYOF_XXX) if successful, -1 otherwise.
13050    Equivalence classes ([=foo=]) and composites ([.foo.]) are parsed,
13051    but trigger failures because they are currently unimplemented. */
13052
13053 #define POSIXCC_DONE(c)   ((c) == ':')
13054 #define POSIXCC_NOTYET(c) ((c) == '=' || (c) == '.')
13055 #define POSIXCC(c) (POSIXCC_DONE(c) || POSIXCC_NOTYET(c))
13056
13057 PERL_STATIC_INLINE I32
13058 S_regpposixcc(pTHX_ RExC_state_t *pRExC_state, I32 value, const bool strict)
13059 {
13060     I32 namedclass = OOB_NAMEDCLASS;
13061
13062     PERL_ARGS_ASSERT_REGPPOSIXCC;
13063
13064     if (value == '[' && RExC_parse + 1 < RExC_end &&
13065         /* I smell either [: or [= or [. -- POSIX has been here, right? */
13066         POSIXCC(UCHARAT(RExC_parse)))
13067     {
13068         const char c = UCHARAT(RExC_parse);
13069         char* const s = RExC_parse++;
13070
13071         while (RExC_parse < RExC_end && UCHARAT(RExC_parse) != c)
13072             RExC_parse++;
13073         if (RExC_parse == RExC_end) {
13074             if (strict) {
13075
13076                 /* Try to give a better location for the error (than the end of
13077                  * the string) by looking for the matching ']' */
13078                 RExC_parse = s;
13079                 while (RExC_parse < RExC_end && UCHARAT(RExC_parse) != ']') {
13080                     RExC_parse++;
13081                 }
13082                 vFAIL2("Unmatched '%c' in POSIX class", c);
13083             }
13084             /* Grandfather lone [:, [=, [. */
13085             RExC_parse = s;
13086         }
13087         else {
13088             const char* const t = RExC_parse++; /* skip over the c */
13089             assert(*t == c);
13090
13091             if (UCHARAT(RExC_parse) == ']') {
13092                 const char *posixcc = s + 1;
13093                 RExC_parse++; /* skip over the ending ] */
13094
13095                 if (*s == ':') {
13096                     const I32 complement = *posixcc == '^' ? *posixcc++ : 0;
13097                     const I32 skip = t - posixcc;
13098
13099                     /* Initially switch on the length of the name.  */
13100                     switch (skip) {
13101                     case 4:
13102                         if (memEQ(posixcc, "word", 4)) /* this is not POSIX,
13103                                                           this is the Perl \w
13104                                                         */
13105                             namedclass = ANYOF_WORDCHAR;
13106                         break;
13107                     case 5:
13108                         /* Names all of length 5.  */
13109                         /* alnum alpha ascii blank cntrl digit graph lower
13110                            print punct space upper  */
13111                         /* Offset 4 gives the best switch position.  */
13112                         switch (posixcc[4]) {
13113                         case 'a':
13114                             if (memEQ(posixcc, "alph", 4)) /* alpha */
13115                                 namedclass = ANYOF_ALPHA;
13116                             break;
13117                         case 'e':
13118                             if (memEQ(posixcc, "spac", 4)) /* space */
13119                                 namedclass = ANYOF_SPACE;
13120                             break;
13121                         case 'h':
13122                             if (memEQ(posixcc, "grap", 4)) /* graph */
13123                                 namedclass = ANYOF_GRAPH;
13124                             break;
13125                         case 'i':
13126                             if (memEQ(posixcc, "asci", 4)) /* ascii */
13127                                 namedclass = ANYOF_ASCII;
13128                             break;
13129                         case 'k':
13130                             if (memEQ(posixcc, "blan", 4)) /* blank */
13131                                 namedclass = ANYOF_BLANK;
13132                             break;
13133                         case 'l':
13134                             if (memEQ(posixcc, "cntr", 4)) /* cntrl */
13135                                 namedclass = ANYOF_CNTRL;
13136                             break;
13137                         case 'm':
13138                             if (memEQ(posixcc, "alnu", 4)) /* alnum */
13139                                 namedclass = ANYOF_ALPHANUMERIC;
13140                             break;
13141                         case 'r':
13142                             if (memEQ(posixcc, "lowe", 4)) /* lower */
13143                                 namedclass = (FOLD) ? ANYOF_CASED : ANYOF_LOWER;
13144                             else if (memEQ(posixcc, "uppe", 4)) /* upper */
13145                                 namedclass = (FOLD) ? ANYOF_CASED : ANYOF_UPPER;
13146                             break;
13147                         case 't':
13148                             if (memEQ(posixcc, "digi", 4)) /* digit */
13149                                 namedclass = ANYOF_DIGIT;
13150                             else if (memEQ(posixcc, "prin", 4)) /* print */
13151                                 namedclass = ANYOF_PRINT;
13152                             else if (memEQ(posixcc, "punc", 4)) /* punct */
13153                                 namedclass = ANYOF_PUNCT;
13154                             break;
13155                         }
13156                         break;
13157                     case 6:
13158                         if (memEQ(posixcc, "xdigit", 6))
13159                             namedclass = ANYOF_XDIGIT;
13160                         break;
13161                     }
13162
13163                     if (namedclass == OOB_NAMEDCLASS)
13164                         vFAIL2utf8f(
13165                             "POSIX class [:%"UTF8f":] unknown",
13166                             UTF8fARG(UTF, t - s - 1, s + 1));
13167
13168                     /* The #defines are structured so each complement is +1 to
13169                      * the normal one */
13170                     if (complement) {
13171                         namedclass++;
13172                     }
13173                     assert (posixcc[skip] == ':');
13174                     assert (posixcc[skip+1] == ']');
13175                 } else if (!SIZE_ONLY) {
13176                     /* [[=foo=]] and [[.foo.]] are still future. */
13177
13178                     /* adjust RExC_parse so the warning shows after
13179                        the class closes */
13180                     while (UCHARAT(RExC_parse) && UCHARAT(RExC_parse) != ']')
13181                         RExC_parse++;
13182                     vFAIL3("POSIX syntax [%c %c] is reserved for future extensions", c, c);
13183                 }
13184             } else {
13185                 /* Maternal grandfather:
13186                  * "[:" ending in ":" but not in ":]" */
13187                 if (strict) {
13188                     vFAIL("Unmatched '[' in POSIX class");
13189                 }
13190
13191                 /* Grandfather lone [:, [=, [. */
13192                 RExC_parse = s;
13193             }
13194         }
13195     }
13196
13197     return namedclass;
13198 }
13199
13200 STATIC bool
13201 S_could_it_be_a_POSIX_class(RExC_state_t *pRExC_state)
13202 {
13203     /* This applies some heuristics at the current parse position (which should
13204      * be at a '[') to see if what follows might be intended to be a [:posix:]
13205      * class.  It returns true if it really is a posix class, of course, but it
13206      * also can return true if it thinks that what was intended was a posix
13207      * class that didn't quite make it.
13208      *
13209      * It will return true for
13210      *      [:alphanumerics:
13211      *      [:alphanumerics]  (as long as the ] isn't followed immediately by a
13212      *                         ')' indicating the end of the (?[
13213      *      [:any garbage including %^&$ punctuation:]
13214      *
13215      * This is designed to be called only from S_handle_regex_sets; it could be
13216      * easily adapted to be called from the spot at the beginning of regclass()
13217      * that checks to see in a normal bracketed class if the surrounding []
13218      * have been omitted ([:word:] instead of [[:word:]]).  But doing so would
13219      * change long-standing behavior, so I (khw) didn't do that */
13220     char* p = RExC_parse + 1;
13221     char first_char = *p;
13222
13223     PERL_ARGS_ASSERT_COULD_IT_BE_A_POSIX_CLASS;
13224
13225     assert(*(p - 1) == '[');
13226
13227     if (! POSIXCC(first_char)) {
13228         return FALSE;
13229     }
13230
13231     p++;
13232     while (p < RExC_end && isWORDCHAR(*p)) p++;
13233
13234     if (p >= RExC_end) {
13235         return FALSE;
13236     }
13237
13238     if (p - RExC_parse > 2    /* Got at least 1 word character */
13239         && (*p == first_char
13240             || (*p == ']' && p + 1 < RExC_end && *(p + 1) != ')')))
13241     {
13242         return TRUE;
13243     }
13244
13245     p = (char *) memchr(RExC_parse, ']', RExC_end - RExC_parse);
13246
13247     return (p
13248             && p - RExC_parse > 2 /* [:] evaluates to colon;
13249                                       [::] is a bad posix class. */
13250             && first_char == *(p - 1));
13251 }
13252
13253 STATIC unsigned  int
13254 S_regex_set_precedence(const U8 my_operator) {
13255
13256     /* Returns the precedence in the (?[...]) construct of the input operator,
13257      * specified by its character representation.  The precedence follows
13258      * general Perl rules, but it extends this so that ')' and ']' have (low)
13259      * precedence even though they aren't really operators */
13260
13261     switch (my_operator) {
13262         case '!':
13263             return 5;
13264         case '&':
13265             return 4;
13266         case '^':
13267         case '|':
13268         case '+':
13269         case '-':
13270             return 3;
13271         case ')':
13272             return 2;
13273         case ']':
13274             return 1;
13275     }
13276
13277     NOT_REACHED; /* NOTREACHED */
13278     return 0;   /* Silence compiler warning */
13279 }
13280
13281 STATIC regnode *
13282 S_handle_regex_sets(pTHX_ RExC_state_t *pRExC_state, SV** return_invlist,
13283                     I32 *flagp, U32 depth,
13284                     char * const oregcomp_parse)
13285 {
13286     /* Handle the (?[...]) construct to do set operations */
13287
13288     U8 curchar;                     /* Current character being parsed */
13289     UV start, end;                  /* End points of code point ranges */
13290     SV* final = NULL;               /* The end result inversion list */
13291     SV* result_string;              /* 'final' stringified */
13292     AV* stack;                      /* stack of operators and operands not yet
13293                                        resolved */
13294     AV* fence_stack = NULL;         /* A stack containing the positions in
13295                                        'stack' of where the undealt-with left
13296                                        parens would be if they were actually
13297                                        put there */
13298     IV fence = 0;                   /* Position of where most recent undealt-
13299                                        with left paren in stack is; -1 if none.
13300                                      */
13301     STRLEN len;                     /* Temporary */
13302     regnode* node;                  /* Temporary, and final regnode returned by
13303                                        this function */
13304     const bool save_fold = FOLD;    /* Temporary */
13305     char *save_end, *save_parse;    /* Temporaries */
13306
13307     GET_RE_DEBUG_FLAGS_DECL;
13308
13309     PERL_ARGS_ASSERT_HANDLE_REGEX_SETS;
13310
13311     if (LOC) {  /* XXX could make valid in UTF-8 locales */
13312         vFAIL("(?[...]) not valid in locale");
13313     }
13314     RExC_uni_semantics = 1;     /* The use of this operator implies /u.  This
13315                                    is required so that the compile time values
13316                                    are valid in all runtime cases */
13317
13318     /* This will return only an ANYOF regnode, or (unlikely) something smaller
13319      * (such as EXACT).  Thus we can skip most everything if just sizing.  We
13320      * call regclass to handle '[]' so as to not have to reinvent its parsing
13321      * rules here (throwing away the size it computes each time).  And, we exit
13322      * upon an unescaped ']' that isn't one ending a regclass.  To do both
13323      * these things, we need to realize that something preceded by a backslash
13324      * is escaped, so we have to keep track of backslashes */
13325     if (SIZE_ONLY) {
13326         UV depth = 0; /* how many nested (?[...]) constructs */
13327
13328         while (RExC_parse < RExC_end) {
13329             SV* current = NULL;
13330             RExC_parse = regpatws(pRExC_state, RExC_parse,
13331                                           TRUE); /* means recognize comments */
13332             switch (*RExC_parse) {
13333                 case '?':
13334                     if (RExC_parse[1] == '[') depth++, RExC_parse++;
13335                     /* FALLTHROUGH */
13336                 default:
13337                     break;
13338                 case '\\':
13339                     /* Skip the next byte (which could cause us to end up in
13340                      * the middle of a UTF-8 character, but since none of those
13341                      * are confusable with anything we currently handle in this
13342                      * switch (invariants all), it's safe.  We'll just hit the
13343                      * default: case next time and keep on incrementing until
13344                      * we find one of the invariants we do handle. */
13345                     RExC_parse++;
13346                     break;
13347                 case '[':
13348                 {
13349                     /* If this looks like it is a [:posix:] class, leave the
13350                      * parse pointer at the '[' to fool regclass() into
13351                      * thinking it is part of a '[[:posix:]]'.  That function
13352                      * will use strict checking to force a syntax error if it
13353                      * doesn't work out to a legitimate class */
13354                     bool is_posix_class
13355                                     = could_it_be_a_POSIX_class(pRExC_state);
13356                     if (! is_posix_class) {
13357                         RExC_parse++;
13358                     }
13359
13360                     /* regclass() can only return RESTART_UTF8 if multi-char
13361                        folds are allowed.  */
13362                     if (!regclass(pRExC_state, flagp,depth+1,
13363                                   is_posix_class, /* parse the whole char
13364                                                      class only if not a
13365                                                      posix class */
13366                                   FALSE, /* don't allow multi-char folds */
13367                                   TRUE, /* silence non-portable warnings. */
13368                                   TRUE, /* strict */
13369                                   &current
13370                                  ))
13371                         FAIL2("panic: regclass returned NULL to handle_sets, "
13372                               "flags=%#"UVxf"", (UV) *flagp);
13373
13374                     /* function call leaves parse pointing to the ']', except
13375                      * if we faked it */
13376                     if (is_posix_class) {
13377                         RExC_parse--;
13378                     }
13379
13380                     SvREFCNT_dec(current);   /* In case it returned something */
13381                     break;
13382                 }
13383
13384                 case ']':
13385                     if (depth--) break;
13386                     RExC_parse++;
13387                     if (RExC_parse < RExC_end
13388                         && *RExC_parse == ')')
13389                     {
13390                         node = reganode(pRExC_state, ANYOF, 0);
13391                         RExC_size += ANYOF_SKIP;
13392                         nextchar(pRExC_state);
13393                         Set_Node_Length(node,
13394                                 RExC_parse - oregcomp_parse + 1); /* MJD */
13395                         return node;
13396                     }
13397                     goto no_close;
13398             }
13399             RExC_parse++;
13400         }
13401
13402       no_close:
13403         FAIL("Syntax error in (?[...])");
13404     }
13405
13406     /* Pass 2 only after this. */
13407     Perl_ck_warner_d(aTHX_
13408         packWARN(WARN_EXPERIMENTAL__REGEX_SETS),
13409         "The regex_sets feature is experimental" REPORT_LOCATION,
13410             UTF8fARG(UTF, (RExC_parse - RExC_precomp), RExC_precomp),
13411             UTF8fARG(UTF,
13412                      RExC_end - RExC_start - (RExC_parse - RExC_precomp),
13413                      RExC_precomp + (RExC_parse - RExC_precomp)));
13414
13415     /* Everything in this construct is a metacharacter.  Operands begin with
13416      * either a '\' (for an escape sequence), or a '[' for a bracketed
13417      * character class.  Any other character should be an operator, or
13418      * parenthesis for grouping.  Both types of operands are handled by calling
13419      * regclass() to parse them.  It is called with a parameter to indicate to
13420      * return the computed inversion list.  The parsing here is implemented via
13421      * a stack.  Each entry on the stack is a single character representing one
13422      * of the operators; or else a pointer to an operand inversion list. */
13423
13424 #define IS_OPERAND(a)  (! SvIOK(a))
13425
13426     /* The stack is kept in Łukasiewicz order.  (That's pronounced similar
13427      * to luke-a-shave-itch (or -itz), but people who didn't want to bother
13428      * with prounouncing it called it Reverse Polish instead, but now that YOU
13429      * know how to prounounce it you can use the correct term, thus giving due
13430      * credit to the person who invented it, and impressing your geek friends.
13431      * Wikipedia says that the pronounciation of "Ł" has been changing so that
13432      * it is now more like an English initial W (as in wonk) than an L.)
13433      *
13434      * This means that, for example, 'a | b & c' is stored on the stack as
13435      *
13436      * c  [4]
13437      * b  [3]
13438      * &  [2]
13439      * a  [1]
13440      * |  [0]
13441      *
13442      * where the numbers in brackets give the stack [array] element number.
13443      * In this implementation, parentheses are not stored on the stack.
13444      * Instead a '(' creates a "fence" so that the part of the stack below the
13445      * fence is invisible except to the corresponding ')' (this allows us to
13446      * replace testing for parens, by using instead subtraction of the fence
13447      * position).  As new operands are processed they are pushed onto the stack
13448      * (except as noted in the next paragraph).  New operators of higher
13449      * precedence than the current final one are inserted on the stack before
13450      * the lhs operand (so that when the rhs is pushed next, everything will be
13451      * in the correct positions shown above.  When an operator of equal or
13452      * lower precedence is encountered in parsing, all the stacked operations
13453      * of equal or higher precedence are evaluated, leaving the result as the
13454      * top entry on the stack.  This makes higher precedence operations
13455      * evaluate before lower precedence ones, and causes operations of equal
13456      * precedence to left associate.
13457      *
13458      * The only unary operator '!' is immediately pushed onto the stack when
13459      * encountered.  When an operand is encountered, if the top of the stack is
13460      * a '!", the complement is immediately performed, and the '!' popped.  The
13461      * resulting value is treated as a new operand, and the logic in the
13462      * previous paragraph is executed.  Thus in the expression
13463      *      [a] + ! [b]
13464      * the stack looks like
13465      *
13466      * !
13467      * a
13468      * +
13469      *
13470      * as 'b' gets parsed, the latter gets evaluated to '!b', and the stack
13471      * becomes
13472      *
13473      * !b
13474      * a
13475      * +
13476      *
13477      * A ')' is treated as an operator with lower precedence than all the
13478      * aforementioned ones, which causes all operations on the stack above the
13479      * corresponding '(' to be evaluated down to a single resultant operand.
13480      * Then the fence for the '(' is removed, and the operand goes through the
13481      * algorithm above, without the fence.
13482      *
13483      * A separate stack is kept of the fence positions, so that the position of
13484      * the latest so-far unbalanced '(' is at the top of it.
13485      *
13486      * The ']' ending the construct is treated as the lowest operator of all,
13487      * so that everything gets evaluated down to a single operand, which is the
13488      * result */
13489
13490     sv_2mortal((SV *)(stack = newAV()));
13491     sv_2mortal((SV *)(fence_stack = newAV()));
13492
13493     while (RExC_parse < RExC_end) {
13494         I32 top_index;              /* Index of top-most element in 'stack' */
13495         SV** top_ptr;               /* Pointer to top 'stack' element */
13496         SV* current = NULL;         /* To contain the current inversion list
13497                                        operand */
13498         SV* only_to_avoid_leaks;
13499
13500         /* Skip white space */
13501         RExC_parse = regpatws(pRExC_state, RExC_parse,
13502                 TRUE /* means recognize comments */ );
13503         if (RExC_parse >= RExC_end) {
13504             Perl_croak(aTHX_ "panic: Read past end of '(?[ ])'");
13505         }
13506
13507         curchar = UCHARAT(RExC_parse);
13508
13509 redo_curchar:
13510
13511         top_index = av_tindex(stack);
13512
13513         switch (curchar) {
13514             SV** stacked_ptr;       /* Ptr to something already on 'stack' */
13515             char stacked_operator;  /* The topmost operator on the 'stack'. */
13516             SV* lhs;                /* Operand to the left of the operator */
13517             SV* rhs;                /* Operand to the right of the operator */
13518             SV* fence_ptr;          /* Pointer to top element of the fence
13519                                        stack */
13520
13521             case '(':
13522
13523                 if (RExC_parse < RExC_end && (UCHARAT(RExC_parse + 1) == '?'))
13524                 {
13525                     /* If is a '(?', could be an embedded '(?flags:(?[...])'.
13526                      * This happens when we have some thing like
13527                      *
13528                      *   my $thai_or_lao = qr/(?[ \p{Thai} + \p{Lao} ])/;
13529                      *   ...
13530                      *   qr/(?[ \p{Digit} & $thai_or_lao ])/;
13531                      *
13532                      * Here we would be handling the interpolated
13533                      * '$thai_or_lao'.  We handle this by a recursive call to
13534                      * ourselves which returns the inversion list the
13535                      * interpolated expression evaluates to.  We use the flags
13536                      * from the interpolated pattern. */
13537                     U32 save_flags = RExC_flags;
13538                     const char * save_parse;
13539
13540                     RExC_parse += 2;        /* Skip past the '(?' */
13541                     save_parse = RExC_parse;
13542
13543                     /* Parse any flags for the '(?' */
13544                     parse_lparen_question_flags(pRExC_state);
13545
13546                     if (RExC_parse == save_parse  /* Makes sure there was at
13547                                                      least one flag (or else
13548                                                      this embedding wasn't
13549                                                      compiled) */
13550                         || RExC_parse >= RExC_end - 4
13551                         || UCHARAT(RExC_parse) != ':'
13552                         || UCHARAT(++RExC_parse) != '('
13553                         || UCHARAT(++RExC_parse) != '?'
13554                         || UCHARAT(++RExC_parse) != '[')
13555                     {
13556
13557                         /* In combination with the above, this moves the
13558                          * pointer to the point just after the first erroneous
13559                          * character (or if there are no flags, to where they
13560                          * should have been) */
13561                         if (RExC_parse >= RExC_end - 4) {
13562                             RExC_parse = RExC_end;
13563                         }
13564                         else if (RExC_parse != save_parse) {
13565                             RExC_parse += (UTF) ? UTF8SKIP(RExC_parse) : 1;
13566                         }
13567                         vFAIL("Expecting '(?flags:(?[...'");
13568                     }
13569
13570                     /* Recurse, with the meat of the embedded expression */
13571                     RExC_parse++;
13572                     (void) handle_regex_sets(pRExC_state, &current, flagp,
13573                                                     depth+1, oregcomp_parse);
13574
13575                     /* Here, 'current' contains the embedded expression's
13576                      * inversion list, and RExC_parse points to the trailing
13577                      * ']'; the next character should be the ')' */
13578                     RExC_parse++;
13579                     assert(RExC_parse < RExC_end && UCHARAT(RExC_parse) == ')');
13580
13581                     /* Then the ')' matching the original '(' handled by this
13582                      * case: statement */
13583                     RExC_parse++;
13584                     assert(RExC_parse < RExC_end && UCHARAT(RExC_parse) == ')');
13585
13586                     RExC_parse++;
13587                     RExC_flags = save_flags;
13588                     goto handle_operand;
13589                 }
13590
13591                 /* A regular '('.  Look behind for illegal syntax */
13592                 if (top_index - fence >= 0) {
13593                     /* If the top entry on the stack is an operator, it had
13594                      * better be a '!', otherwise the entry below the top
13595                      * operand should be an operator */
13596                     if ( ! (top_ptr = av_fetch(stack, top_index, FALSE))
13597                         || (! IS_OPERAND(*top_ptr) && SvUV(*top_ptr) != '!')
13598                         || top_index - fence < 1
13599                         || ! (stacked_ptr = av_fetch(stack,
13600                                                      top_index - 1,
13601                                                      FALSE))
13602                         || IS_OPERAND(*stacked_ptr))
13603                     {
13604                         RExC_parse++;
13605                         vFAIL("Unexpected '(' with no preceding operator");
13606                     }
13607                 }
13608
13609                 /* Stack the position of this undealt-with left paren */
13610                 fence = top_index + 1;
13611                 av_push(fence_stack, newSViv(fence));
13612                 break;
13613
13614             case '\\':
13615                 /* regclass() can only return RESTART_UTF8 if multi-char
13616                    folds are allowed.  */
13617                 if (!regclass(pRExC_state, flagp,depth+1,
13618                               TRUE, /* means parse just the next thing */
13619                               FALSE, /* don't allow multi-char folds */
13620                               FALSE, /* don't silence non-portable warnings.  */
13621                               TRUE,  /* strict */
13622                               &current))
13623                 {
13624                     FAIL2("panic: regclass returned NULL to handle_sets, "
13625                           "flags=%#"UVxf"", (UV) *flagp);
13626                 }
13627
13628                 /* regclass() will return with parsing just the \ sequence,
13629                  * leaving the parse pointer at the next thing to parse */
13630                 RExC_parse--;
13631                 goto handle_operand;
13632
13633             case '[':   /* Is a bracketed character class */
13634             {
13635                 bool is_posix_class = could_it_be_a_POSIX_class(pRExC_state);
13636
13637                 if (! is_posix_class) {
13638                     RExC_parse++;
13639                 }
13640
13641                 /* regclass() can only return RESTART_UTF8 if multi-char
13642                    folds are allowed.  */
13643                 if(!regclass(pRExC_state, flagp,depth+1,
13644                              is_posix_class, /* parse the whole char class
13645                                                 only if not a posix class */
13646                              FALSE, /* don't allow multi-char folds */
13647                              FALSE, /* don't silence non-portable warnings.  */
13648                              TRUE,   /* strict */
13649                              &current
13650                             ))
13651                 {
13652                     FAIL2("panic: regclass returned NULL to handle_sets, "
13653                           "flags=%#"UVxf"", (UV) *flagp);
13654                 }
13655
13656                 /* function call leaves parse pointing to the ']', except if we
13657                  * faked it */
13658                 if (is_posix_class) {
13659                     RExC_parse--;
13660                 }
13661
13662                 goto handle_operand;
13663             }
13664
13665             case ']':
13666                 if (top_index >= 1) {
13667                     goto join_operators;
13668                 }
13669
13670                 /* Only a single operand on the stack: are done */
13671                 goto done;
13672
13673             case ')':
13674                 if (av_tindex(fence_stack) < 0) {
13675                     RExC_parse++;
13676                     vFAIL("Unexpected ')'");
13677                 }
13678
13679                  /* If at least two thing on the stack, treat this as an
13680                   * operator */
13681                 if (top_index - fence >= 1) {
13682                     goto join_operators;
13683                 }
13684
13685                 /* Here only a single thing on the fenced stack, and there is a
13686                  * fence.  Get rid of it */
13687                 fence_ptr = av_pop(fence_stack);
13688                 assert(fence_ptr);
13689                 fence = SvIV(fence_ptr) - 1;
13690                 SvREFCNT_dec_NN(fence_ptr);
13691                 fence_ptr = NULL;
13692
13693                 if (fence < 0) {
13694                     fence = 0;
13695                 }
13696
13697                 /* Having gotten rid of the fence, we pop the operand at the
13698                  * stack top and process it as a newly encountered operand */
13699                 current = av_pop(stack);
13700                 assert(IS_OPERAND(current));
13701                 goto handle_operand;
13702
13703             case '&':
13704             case '|':
13705             case '+':
13706             case '-':
13707             case '^':
13708
13709                 /* These binary operators should have a left operand already
13710                  * parsed */
13711                 if (   top_index - fence < 0
13712                     || top_index - fence == 1
13713                     || ( ! (top_ptr = av_fetch(stack, top_index, FALSE)))
13714                     || ! IS_OPERAND(*top_ptr))
13715                 {
13716                     goto unexpected_binary;
13717                 }
13718
13719                 /* If only the one operand is on the part of the stack visible
13720                  * to us, we just place this operator in the proper position */
13721                 if (top_index - fence < 2) {
13722
13723                     /* Place the operator before the operand */
13724
13725                     SV* lhs = av_pop(stack);
13726                     av_push(stack, newSVuv(curchar));
13727                     av_push(stack, lhs);
13728                     break;
13729                 }
13730
13731                 /* But if there is something else on the stack, we need to
13732                  * process it before this new operator if and only if the
13733                  * stacked operation has equal or higher precedence than the
13734                  * new one */
13735
13736              join_operators:
13737
13738                 /* The operator on the stack is supposed to be below both its
13739                  * operands */
13740                 if (   ! (stacked_ptr = av_fetch(stack, top_index - 2, FALSE))
13741                     || IS_OPERAND(*stacked_ptr))
13742                 {
13743                     /* But if not, it's legal and indicates we are completely
13744                      * done if and only if we're currently processing a ']',
13745                      * which should be the final thing in the expression */
13746                     if (curchar == ']') {
13747                         goto done;
13748                     }
13749
13750                   unexpected_binary:
13751                     RExC_parse++;
13752                     vFAIL2("Unexpected binary operator '%c' with no "
13753                            "preceding operand", curchar);
13754                 }
13755                 stacked_operator = (char) SvUV(*stacked_ptr);
13756
13757                 if (regex_set_precedence(curchar)
13758                     > regex_set_precedence(stacked_operator))
13759                 {
13760                     /* Here, the new operator has higher precedence than the
13761                      * stacked one.  This means we need to add the new one to
13762                      * the stack to await its rhs operand (and maybe more
13763                      * stuff).  We put it before the lhs operand, leaving
13764                      * untouched the stacked operator and everything below it
13765                      * */
13766                     lhs = av_pop(stack);
13767                     assert(IS_OPERAND(lhs));
13768
13769                     av_push(stack, newSVuv(curchar));
13770                     av_push(stack, lhs);
13771                     break;
13772                 }
13773
13774                 /* Here, the new operator has equal or lower precedence than
13775                  * what's already there.  This means the operation already
13776                  * there should be performed now, before the new one. */
13777                 rhs = av_pop(stack);
13778                 lhs = av_pop(stack);
13779
13780                 assert(IS_OPERAND(rhs));
13781                 assert(IS_OPERAND(lhs));
13782
13783                 switch (stacked_operator) {
13784                     case '&':
13785                         _invlist_intersection(lhs, rhs, &rhs);
13786                         break;
13787
13788                     case '|':
13789                     case '+':
13790                         _invlist_union(lhs, rhs, &rhs);
13791                         break;
13792
13793                     case '-':
13794                         _invlist_subtract(lhs, rhs, &rhs);
13795                         break;
13796
13797                     case '^':   /* The union minus the intersection */
13798                     {
13799                         SV* i = NULL;
13800                         SV* u = NULL;
13801                         SV* element;
13802
13803                         _invlist_union(lhs, rhs, &u);
13804                         _invlist_intersection(lhs, rhs, &i);
13805                         /* _invlist_subtract will overwrite rhs
13806                             without freeing what it already contains */
13807                         element = rhs;
13808                         _invlist_subtract(u, i, &rhs);
13809                         SvREFCNT_dec_NN(i);
13810                         SvREFCNT_dec_NN(u);
13811                         SvREFCNT_dec_NN(element);
13812                         break;
13813                     }
13814                 }
13815                 SvREFCNT_dec(lhs);
13816
13817                 /* Here, the higher precedence operation has been done, and the
13818                  * result is in 'rhs'.  We overwrite the stacked operator with
13819                  * the result.  Then we redo this code to either push the new
13820                  * operator onto the stack or perform any higher precedence
13821                  * stacked operation */
13822                 only_to_avoid_leaks = av_pop(stack);
13823                 SvREFCNT_dec(only_to_avoid_leaks);
13824                 av_push(stack, rhs);
13825                 goto redo_curchar;
13826
13827             case '!':   /* Highest priority, right associative, so just push
13828                            onto stack */
13829                 av_push(stack, newSVuv(curchar));
13830                 break;
13831
13832             default:
13833                 RExC_parse += (UTF) ? UTF8SKIP(RExC_parse) : 1;
13834                 vFAIL("Unexpected character");
13835
13836           handle_operand:
13837
13838             /* Here 'current' is the operand.  If something is already on the
13839              * stack, we have to check if it is a !. */
13840             top_index = av_tindex(stack);   /* Code above may have altered the
13841                                              * stack in the time since we
13842                                              * earlier set 'top_index'. */
13843             if (top_index - fence >= 0) {
13844                 /* If the top entry on the stack is an operator, it had better
13845                  * be a '!', otherwise the entry below the top operand should
13846                  * be an operator */
13847                 top_ptr = av_fetch(stack, top_index, FALSE);
13848                 assert(top_ptr);
13849                 if (! IS_OPERAND(*top_ptr)) {
13850
13851                     /* The only permissible operator at the top of the stack is
13852                      * '!', which is applied immediately to this operand. */
13853                     curchar = (char) SvUV(*top_ptr);
13854                     if (curchar != '!') {
13855                         SvREFCNT_dec(current);
13856                         vFAIL2("Unexpected binary operator '%c' with no "
13857                                 "preceding operand", curchar);
13858                     }
13859
13860                     _invlist_invert(current);
13861
13862                     only_to_avoid_leaks = av_pop(stack);
13863                     SvREFCNT_dec(only_to_avoid_leaks);
13864                     top_index = av_tindex(stack);
13865
13866                     /* And we redo with the inverted operand.  This allows
13867                      * handling multiple ! in a row */
13868                     goto handle_operand;
13869                 }
13870                           /* Single operand is ok only for the non-binary ')'
13871                            * operator */
13872                 else if ((top_index - fence == 0 && curchar != ')')
13873                          || (top_index - fence > 0
13874                              && (! (stacked_ptr = av_fetch(stack,
13875                                                            top_index - 1,
13876                                                            FALSE))
13877                                  || IS_OPERAND(*stacked_ptr))))
13878                 {
13879                     SvREFCNT_dec(current);
13880                     vFAIL("Operand with no preceding operator");
13881                 }
13882             }
13883
13884             /* Here there was nothing on the stack or the top element was
13885              * another operand.  Just add this new one */
13886             av_push(stack, current);
13887
13888         } /* End of switch on next parse token */
13889
13890         RExC_parse += (UTF) ? UTF8SKIP(RExC_parse) : 1;
13891     } /* End of loop parsing through the construct */
13892
13893   done:
13894     if (av_tindex(fence_stack) >= 0) {
13895         vFAIL("Unmatched (");
13896     }
13897
13898     if (av_tindex(stack) < 0   /* Was empty */
13899         || ((final = av_pop(stack)) == NULL)
13900         || ! IS_OPERAND(final)
13901         || av_tindex(stack) >= 0)  /* More left on stack */
13902     {
13903         SvREFCNT_dec(final);
13904         vFAIL("Incomplete expression within '(?[ ])'");
13905     }
13906
13907     /* Here, 'final' is the resultant inversion list from evaluating the
13908      * expression.  Return it if so requested */
13909     if (return_invlist) {
13910         *return_invlist = final;
13911         return END;
13912     }
13913
13914     /* Otherwise generate a resultant node, based on 'final'.  regclass() is
13915      * expecting a string of ranges and individual code points */
13916     invlist_iterinit(final);
13917     result_string = newSVpvs("");
13918     while (invlist_iternext(final, &start, &end)) {
13919         if (start == end) {
13920             Perl_sv_catpvf(aTHX_ result_string, "\\x{%"UVXf"}", start);
13921         }
13922         else {
13923             Perl_sv_catpvf(aTHX_ result_string, "\\x{%"UVXf"}-\\x{%"UVXf"}",
13924                                                      start,          end);
13925         }
13926     }
13927
13928     /* About to generate an ANYOF (or similar) node from the inversion list we
13929      * have calculated */
13930     save_parse = RExC_parse;
13931     RExC_parse = SvPV(result_string, len);
13932     save_end = RExC_end;
13933     RExC_end = RExC_parse + len;
13934
13935     /* We turn off folding around the call, as the class we have constructed
13936      * already has all folding taken into consideration, and we don't want
13937      * regclass() to add to that */
13938     RExC_flags &= ~RXf_PMf_FOLD;
13939     /* regclass() can only return RESTART_UTF8 if multi-char folds are allowed.
13940      */
13941     node = regclass(pRExC_state, flagp,depth+1,
13942                     FALSE, /* means parse the whole char class */
13943                     FALSE, /* don't allow multi-char folds */
13944                     TRUE, /* silence non-portable warnings.  The above may very
13945                              well have generated non-portable code points, but
13946                              they're valid on this machine */
13947                     FALSE, /* similarly, no need for strict */
13948                     NULL
13949                 );
13950     if (!node)
13951         FAIL2("panic: regclass returned NULL to handle_sets, flags=%#"UVxf,
13952                     PTR2UV(flagp));
13953     if (save_fold) {
13954         RExC_flags |= RXf_PMf_FOLD;
13955     }
13956     RExC_parse = save_parse + 1;
13957     RExC_end = save_end;
13958     SvREFCNT_dec_NN(final);
13959     SvREFCNT_dec_NN(result_string);
13960
13961     nextchar(pRExC_state);
13962     Set_Node_Length(node, RExC_parse - oregcomp_parse + 1); /* MJD */
13963     return node;
13964 }
13965 #undef IS_OPERAND
13966
13967 STATIC void
13968 S_add_above_Latin1_folds(pTHX_ RExC_state_t *pRExC_state, const U8 cp, SV** invlist)
13969 {
13970     /* This hard-codes the Latin1/above-Latin1 folding rules, so that an
13971      * innocent-looking character class, like /[ks]/i won't have to go out to
13972      * disk to find the possible matches.
13973      *
13974      * This should be called only for a Latin1-range code points, cp, which is
13975      * known to be involved in a simple fold with other code points above
13976      * Latin1.  It would give false results if /aa has been specified.
13977      * Multi-char folds are outside the scope of this, and must be handled
13978      * specially.
13979      *
13980      * XXX It would be better to generate these via regen, in case a new
13981      * version of the Unicode standard adds new mappings, though that is not
13982      * really likely, and may be caught by the default: case of the switch
13983      * below. */
13984
13985     PERL_ARGS_ASSERT_ADD_ABOVE_LATIN1_FOLDS;
13986
13987     assert(HAS_NONLATIN1_SIMPLE_FOLD_CLOSURE(cp));
13988
13989     switch (cp) {
13990         case 'k':
13991         case 'K':
13992           *invlist =
13993              add_cp_to_invlist(*invlist, KELVIN_SIGN);
13994             break;
13995         case 's':
13996         case 'S':
13997           *invlist = add_cp_to_invlist(*invlist, LATIN_SMALL_LETTER_LONG_S);
13998             break;
13999         case MICRO_SIGN:
14000           *invlist = add_cp_to_invlist(*invlist, GREEK_CAPITAL_LETTER_MU);
14001           *invlist = add_cp_to_invlist(*invlist, GREEK_SMALL_LETTER_MU);
14002             break;
14003         case LATIN_CAPITAL_LETTER_A_WITH_RING_ABOVE:
14004         case LATIN_SMALL_LETTER_A_WITH_RING_ABOVE:
14005           *invlist = add_cp_to_invlist(*invlist, ANGSTROM_SIGN);
14006             break;
14007         case LATIN_SMALL_LETTER_Y_WITH_DIAERESIS:
14008           *invlist = add_cp_to_invlist(*invlist,
14009                                         LATIN_CAPITAL_LETTER_Y_WITH_DIAERESIS);
14010             break;
14011         case LATIN_SMALL_LETTER_SHARP_S:
14012           *invlist = add_cp_to_invlist(*invlist, LATIN_CAPITAL_LETTER_SHARP_S);
14013             break;
14014         default:
14015             /* Use deprecated warning to increase the chances of this being
14016              * output */
14017             if (PASS2) {
14018                 ckWARN2reg_d(RExC_parse, "Perl folding rules are not up-to-date for 0x%02X; please use the perlbug utility to report;", cp);
14019             }
14020             break;
14021     }
14022 }
14023
14024 STATIC AV *
14025 S_add_multi_match(pTHX_ AV* multi_char_matches, SV* multi_string, const STRLEN cp_count)
14026 {
14027     /* This adds the string scalar <multi_string> to the array
14028      * <multi_char_matches>.  <multi_string> is known to have exactly
14029      * <cp_count> code points in it.  This is used when constructing a
14030      * bracketed character class and we find something that needs to match more
14031      * than a single character.
14032      *
14033      * <multi_char_matches> is actually an array of arrays.  Each top-level
14034      * element is an array that contains all the strings known so far that are
14035      * the same length.  And that length (in number of code points) is the same
14036      * as the index of the top-level array.  Hence, the [2] element is an
14037      * array, each element thereof is a string containing TWO code points;
14038      * while element [3] is for strings of THREE characters, and so on.  Since
14039      * this is for multi-char strings there can never be a [0] nor [1] element.
14040      *
14041      * When we rewrite the character class below, we will do so such that the
14042      * longest strings are written first, so that it prefers the longest
14043      * matching strings first.  This is done even if it turns out that any
14044      * quantifier is non-greedy, out of this programmer's (khw) laziness.  Tom
14045      * Christiansen has agreed that this is ok.  This makes the test for the
14046      * ligature 'ffi' come before the test for 'ff', for example */
14047
14048     AV* this_array;
14049     AV** this_array_ptr;
14050
14051     PERL_ARGS_ASSERT_ADD_MULTI_MATCH;
14052
14053     if (! multi_char_matches) {
14054         multi_char_matches = newAV();
14055     }
14056
14057     if (av_exists(multi_char_matches, cp_count)) {
14058         this_array_ptr = (AV**) av_fetch(multi_char_matches, cp_count, FALSE);
14059         this_array = *this_array_ptr;
14060     }
14061     else {
14062         this_array = newAV();
14063         av_store(multi_char_matches, cp_count,
14064                  (SV*) this_array);
14065     }
14066     av_push(this_array, multi_string);
14067
14068     return multi_char_matches;
14069 }
14070
14071 /* The names of properties whose definitions are not known at compile time are
14072  * stored in this SV, after a constant heading.  So if the length has been
14073  * changed since initialization, then there is a run-time definition. */
14074 #define HAS_NONLOCALE_RUNTIME_PROPERTY_DEFINITION                            \
14075                                         (SvCUR(listsv) != initial_listsv_len)
14076
14077 STATIC regnode *
14078 S_regclass(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth,
14079                  const bool stop_at_1,  /* Just parse the next thing, don't
14080                                            look for a full character class */
14081                  bool allow_multi_folds,
14082                  const bool silence_non_portable,   /* Don't output warnings
14083                                                        about too large
14084                                                        characters */
14085                  const bool strict,
14086                  SV** ret_invlist  /* Return an inversion list, not a node */
14087           )
14088 {
14089     /* parse a bracketed class specification.  Most of these will produce an
14090      * ANYOF node; but something like [a] will produce an EXACT node; [aA], an
14091      * EXACTFish node; [[:ascii:]], a POSIXA node; etc.  It is more complex
14092      * under /i with multi-character folds: it will be rewritten following the
14093      * paradigm of this example, where the <multi-fold>s are characters which
14094      * fold to multiple character sequences:
14095      *      /[abc\x{multi-fold1}def\x{multi-fold2}ghi]/i
14096      * gets effectively rewritten as:
14097      *      /(?:\x{multi-fold1}|\x{multi-fold2}|[abcdefghi]/i
14098      * reg() gets called (recursively) on the rewritten version, and this
14099      * function will return what it constructs.  (Actually the <multi-fold>s
14100      * aren't physically removed from the [abcdefghi], it's just that they are
14101      * ignored in the recursion by means of a flag:
14102      * <RExC_in_multi_char_class>.)
14103      *
14104      * ANYOF nodes contain a bit map for the first NUM_ANYOF_CODE_POINTS
14105      * characters, with the corresponding bit set if that character is in the
14106      * list.  For characters above this, a range list or swash is used.  There
14107      * are extra bits for \w, etc. in locale ANYOFs, as what these match is not
14108      * determinable at compile time
14109      *
14110      * Returns NULL, setting *flagp to RESTART_UTF8 if the sizing scan needs
14111      * to be restarted.  This can only happen if ret_invlist is non-NULL.
14112      */
14113
14114     UV prevvalue = OOB_UNICODE, save_prevvalue = OOB_UNICODE;
14115     IV range = 0;
14116     UV value = OOB_UNICODE, save_value = OOB_UNICODE;
14117     regnode *ret;
14118     STRLEN numlen;
14119     IV namedclass = OOB_NAMEDCLASS;
14120     char *rangebegin = NULL;
14121     bool need_class = 0;
14122     SV *listsv = NULL;
14123     STRLEN initial_listsv_len = 0; /* Kind of a kludge to see if it is more
14124                                       than just initialized.  */
14125     SV* properties = NULL;    /* Code points that match \p{} \P{} */
14126     SV* posixes = NULL;     /* Code points that match classes like [:word:],
14127                                extended beyond the Latin1 range.  These have to
14128                                be kept separate from other code points for much
14129                                of this function because their handling  is
14130                                different under /i, and for most classes under
14131                                /d as well */
14132     SV* nposixes = NULL;    /* Similarly for [:^word:].  These are kept
14133                                separate for a while from the non-complemented
14134                                versions because of complications with /d
14135                                matching */
14136     SV* simple_posixes = NULL; /* But under some conditions, the classes can be
14137                                   treated more simply than the general case,
14138                                   leading to less compilation and execution
14139                                   work */
14140     UV element_count = 0;   /* Number of distinct elements in the class.
14141                                Optimizations may be possible if this is tiny */
14142     AV * multi_char_matches = NULL; /* Code points that fold to more than one
14143                                        character; used under /i */
14144     UV n;
14145     char * stop_ptr = RExC_end;    /* where to stop parsing */
14146     const bool skip_white = cBOOL(ret_invlist); /* ignore unescaped white
14147                                                    space? */
14148
14149     /* Unicode properties are stored in a swash; this holds the current one
14150      * being parsed.  If this swash is the only above-latin1 component of the
14151      * character class, an optimization is to pass it directly on to the
14152      * execution engine.  Otherwise, it is set to NULL to indicate that there
14153      * are other things in the class that have to be dealt with at execution
14154      * time */
14155     SV* swash = NULL;           /* Code points that match \p{} \P{} */
14156
14157     /* Set if a component of this character class is user-defined; just passed
14158      * on to the engine */
14159     bool has_user_defined_property = FALSE;
14160
14161     /* inversion list of code points this node matches only when the target
14162      * string is in UTF-8.  (Because is under /d) */
14163     SV* depends_list = NULL;
14164
14165     /* Inversion list of code points this node matches regardless of things
14166      * like locale, folding, utf8ness of the target string */
14167     SV* cp_list = NULL;
14168
14169     /* Like cp_list, but code points on this list need to be checked for things
14170      * that fold to/from them under /i */
14171     SV* cp_foldable_list = NULL;
14172
14173     /* Like cp_list, but code points on this list are valid only when the
14174      * runtime locale is UTF-8 */
14175     SV* only_utf8_locale_list = NULL;
14176
14177     /* In a range, if one of the endpoints is non-character-set portable,
14178      * meaning that it hard-codes a code point that may mean a different
14179      * charactger in ASCII vs. EBCDIC, as opposed to, say, a literal 'A' or a
14180      * mnemonic '\t' which each mean the same character no matter which
14181      * character set the platform is on. */
14182     unsigned int non_portable_endpoint = 0;
14183
14184     /* Is the range unicode? which means on a platform that isn't 1-1 native
14185      * to Unicode (i.e. non-ASCII), each code point in it should be considered
14186      * to be a Unicode value.  */
14187     bool unicode_range = FALSE;
14188     bool invert = FALSE;    /* Is this class to be complemented */
14189
14190     bool warn_super = ALWAYS_WARN_SUPER;
14191
14192     regnode * const orig_emit = RExC_emit; /* Save the original RExC_emit in
14193         case we need to change the emitted regop to an EXACT. */
14194     const char * orig_parse = RExC_parse;
14195     const SSize_t orig_size = RExC_size;
14196     bool posixl_matches_all = FALSE; /* Does /l class have both e.g. \W,\w ? */
14197     GET_RE_DEBUG_FLAGS_DECL;
14198
14199     PERL_ARGS_ASSERT_REGCLASS;
14200 #ifndef DEBUGGING
14201     PERL_UNUSED_ARG(depth);
14202 #endif
14203
14204     DEBUG_PARSE("clas");
14205
14206     /* Assume we are going to generate an ANYOF node. */
14207     ret = reganode(pRExC_state,
14208                    (LOC)
14209                     ? ANYOFL
14210                     : ANYOF,
14211                    0);
14212
14213     if (SIZE_ONLY) {
14214         RExC_size += ANYOF_SKIP;
14215         listsv = &PL_sv_undef; /* For code scanners: listsv always non-NULL. */
14216     }
14217     else {
14218         ANYOF_FLAGS(ret) = 0;
14219
14220         RExC_emit += ANYOF_SKIP;
14221         listsv = newSVpvs_flags("# comment\n", SVs_TEMP);
14222         initial_listsv_len = SvCUR(listsv);
14223         SvTEMP_off(listsv); /* Grr, TEMPs and mortals are conflated.  */
14224     }
14225
14226     if (skip_white) {
14227         RExC_parse = regpatws(pRExC_state, RExC_parse,
14228                               FALSE /* means don't recognize comments */ );
14229     }
14230
14231     if (UCHARAT(RExC_parse) == '^') {   /* Complement of range. */
14232         RExC_parse++;
14233         invert = TRUE;
14234         allow_multi_folds = FALSE;
14235         MARK_NAUGHTY(1);
14236         if (skip_white) {
14237             RExC_parse = regpatws(pRExC_state, RExC_parse,
14238                                   FALSE /* means don't recognize comments */ );
14239         }
14240     }
14241
14242     /* Check that they didn't say [:posix:] instead of [[:posix:]] */
14243     if (!SIZE_ONLY && RExC_parse < RExC_end && POSIXCC(UCHARAT(RExC_parse))) {
14244         const char *s = RExC_parse;
14245         const char  c = *s++;
14246
14247         if (*s == '^') {
14248             s++;
14249         }
14250         while (isWORDCHAR(*s))
14251             s++;
14252         if (*s && c == *s && s[1] == ']') {
14253             SAVEFREESV(RExC_rx_sv);
14254             ckWARN3reg(s+2,
14255                        "POSIX syntax [%c %c] belongs inside character classes",
14256                        c, c);
14257             (void)ReREFCNT_inc(RExC_rx_sv);
14258         }
14259     }
14260
14261     /* If the caller wants us to just parse a single element, accomplish this
14262      * by faking the loop ending condition */
14263     if (stop_at_1 && RExC_end > RExC_parse) {
14264         stop_ptr = RExC_parse + 1;
14265     }
14266
14267     /* allow 1st char to be ']' (allowing it to be '-' is dealt with later) */
14268     if (UCHARAT(RExC_parse) == ']')
14269         goto charclassloop;
14270
14271     while (1) {
14272         if  (RExC_parse >= stop_ptr) {
14273             break;
14274         }
14275
14276         if (skip_white) {
14277             RExC_parse = regpatws(pRExC_state, RExC_parse,
14278                                   FALSE /* means don't recognize comments */ );
14279         }
14280
14281         if  (UCHARAT(RExC_parse) == ']') {
14282             break;
14283         }
14284
14285       charclassloop:
14286
14287         namedclass = OOB_NAMEDCLASS; /* initialize as illegal */
14288         save_value = value;
14289         save_prevvalue = prevvalue;
14290
14291         if (!range) {
14292             rangebegin = RExC_parse;
14293             element_count++;
14294             non_portable_endpoint = 0;
14295         }
14296         if (UTF) {
14297             value = utf8n_to_uvchr((U8*)RExC_parse,
14298                                    RExC_end - RExC_parse,
14299                                    &numlen, UTF8_ALLOW_DEFAULT);
14300             RExC_parse += numlen;
14301         }
14302         else
14303             value = UCHARAT(RExC_parse++);
14304
14305         if (value == '['
14306             && RExC_parse < RExC_end
14307             && POSIXCC(UCHARAT(RExC_parse)))
14308         {
14309             namedclass = regpposixcc(pRExC_state, value, strict);
14310         }
14311         else if (value == '\\') {
14312             /* Is a backslash; get the code point of the char after it */
14313             if (UTF && ! UTF8_IS_INVARIANT(UCHARAT(RExC_parse))) {
14314                 value = utf8n_to_uvchr((U8*)RExC_parse,
14315                                    RExC_end - RExC_parse,
14316                                    &numlen, UTF8_ALLOW_DEFAULT);
14317                 RExC_parse += numlen;
14318             }
14319             else
14320                 value = UCHARAT(RExC_parse++);
14321
14322             /* Some compilers cannot handle switching on 64-bit integer
14323              * values, therefore value cannot be an UV.  Yes, this will
14324              * be a problem later if we want switch on Unicode.
14325              * A similar issue a little bit later when switching on
14326              * namedclass. --jhi */
14327
14328             /* If the \ is escaping white space when white space is being
14329              * skipped, it means that that white space is wanted literally, and
14330              * is already in 'value'.  Otherwise, need to translate the escape
14331              * into what it signifies. */
14332             if (! skip_white || ! is_PATWS_cp(value)) switch ((I32)value) {
14333
14334             case 'w':   namedclass = ANYOF_WORDCHAR;    break;
14335             case 'W':   namedclass = ANYOF_NWORDCHAR;   break;
14336             case 's':   namedclass = ANYOF_SPACE;       break;
14337             case 'S':   namedclass = ANYOF_NSPACE;      break;
14338             case 'd':   namedclass = ANYOF_DIGIT;       break;
14339             case 'D':   namedclass = ANYOF_NDIGIT;      break;
14340             case 'v':   namedclass = ANYOF_VERTWS;      break;
14341             case 'V':   namedclass = ANYOF_NVERTWS;     break;
14342             case 'h':   namedclass = ANYOF_HORIZWS;     break;
14343             case 'H':   namedclass = ANYOF_NHORIZWS;    break;
14344             case 'N':  /* Handle \N{NAME} in class */
14345                 {
14346                     const char * const backslash_N_beg = RExC_parse - 2;
14347                     int cp_count;
14348
14349                     if (! grok_bslash_N(pRExC_state,
14350                                         NULL,      /* No regnode */
14351                                         &value,    /* Yes single value */
14352                                         &cp_count, /* Multiple code pt count */
14353                                         flagp,
14354                                         depth)
14355                     ) {
14356
14357                         if (*flagp & RESTART_UTF8)
14358                             FAIL("panic: grok_bslash_N set RESTART_UTF8");
14359
14360                         if (cp_count < 0) {
14361                             vFAIL("\\N in a character class must be a named character: \\N{...}");
14362                         }
14363                         else if (cp_count == 0) {
14364                             if (strict) {
14365                                 RExC_parse++;   /* Position after the "}" */
14366                                 vFAIL("Zero length \\N{}");
14367                             }
14368                             else if (PASS2) {
14369                                 ckWARNreg(RExC_parse,
14370                                         "Ignoring zero length \\N{} in character class");
14371                             }
14372                         }
14373                         else { /* cp_count > 1 */
14374                             if (! RExC_in_multi_char_class) {
14375                                 if (invert || range || *RExC_parse == '-') {
14376                                     if (strict) {
14377                                         RExC_parse--;
14378                                         vFAIL("\\N{} in inverted character class or as a range end-point is restricted to one character");
14379                                     }
14380                                     else if (PASS2) {
14381                                         ckWARNreg(RExC_parse, "Using just the first character returned by \\N{} in character class");
14382                                     }
14383                                     break; /* <value> contains the first code
14384                                               point. Drop out of the switch to
14385                                               process it */
14386                                 }
14387                                 else {
14388                                     SV * multi_char_N = newSVpvn(backslash_N_beg,
14389                                                  RExC_parse - backslash_N_beg);
14390                                     multi_char_matches
14391                                         = add_multi_match(multi_char_matches,
14392                                                           multi_char_N,
14393                                                           cp_count);
14394                                 }
14395                             }
14396                         } /* End of cp_count != 1 */
14397
14398                         /* This element should not be processed further in this
14399                          * class */
14400                         element_count--;
14401                         value = save_value;
14402                         prevvalue = save_prevvalue;
14403                         continue;   /* Back to top of loop to get next char */
14404                     }
14405
14406                     /* Here, is a single code point, and <value> contains it */
14407                     unicode_range = TRUE;   /* \N{} are Unicode */
14408                 }
14409                 break;
14410             case 'p':
14411             case 'P':
14412                 {
14413                 char *e;
14414
14415                 /* We will handle any undefined properties ourselves */
14416                 U8 swash_init_flags = _CORE_SWASH_INIT_RETURN_IF_UNDEF
14417                                        /* And we actually would prefer to get
14418                                         * the straight inversion list of the
14419                                         * swash, since we will be accessing it
14420                                         * anyway, to save a little time */
14421                                       |_CORE_SWASH_INIT_ACCEPT_INVLIST;
14422
14423                 if (RExC_parse >= RExC_end)
14424                     vFAIL2("Empty \\%c{}", (U8)value);
14425                 if (*RExC_parse == '{') {
14426                     const U8 c = (U8)value;
14427                     e = strchr(RExC_parse++, '}');
14428                     if (!e)
14429                         vFAIL2("Missing right brace on \\%c{}", c);
14430                     while (isSPACE(*RExC_parse))
14431                         RExC_parse++;
14432                     if (e == RExC_parse)
14433                         vFAIL2("Empty \\%c{}", c);
14434                     n = e - RExC_parse;
14435                     while (isSPACE(*(RExC_parse + n - 1)))
14436                         n--;
14437                 }
14438                 else {
14439                     e = RExC_parse;
14440                     n = 1;
14441                 }
14442                 if (!SIZE_ONLY) {
14443                     SV* invlist;
14444                     char* name;
14445
14446                     if (UCHARAT(RExC_parse) == '^') {
14447                          RExC_parse++;
14448                          n--;
14449                          /* toggle.  (The rhs xor gets the single bit that
14450                           * differs between P and p; the other xor inverts just
14451                           * that bit) */
14452                          value ^= 'P' ^ 'p';
14453
14454                          while (isSPACE(*RExC_parse)) {
14455                               RExC_parse++;
14456                               n--;
14457                          }
14458                     }
14459                     /* Try to get the definition of the property into
14460                      * <invlist>.  If /i is in effect, the effective property
14461                      * will have its name be <__NAME_i>.  The design is
14462                      * discussed in commit
14463                      * 2f833f5208e26b208886e51e09e2c072b5eabb46 */
14464                     name = savepv(Perl_form(aTHX_
14465                                           "%s%.*s%s\n",
14466                                           (FOLD) ? "__" : "",
14467                                           (int)n,
14468                                           RExC_parse,
14469                                           (FOLD) ? "_i" : ""
14470                                 ));
14471
14472                     /* Look up the property name, and get its swash and
14473                      * inversion list, if the property is found  */
14474                     if (swash) {
14475                         SvREFCNT_dec_NN(swash);
14476                     }
14477                     swash = _core_swash_init("utf8", name, &PL_sv_undef,
14478                                              1, /* binary */
14479                                              0, /* not tr/// */
14480                                              NULL, /* No inversion list */
14481                                              &swash_init_flags
14482                                             );
14483                     if (! swash || ! (invlist = _get_swash_invlist(swash))) {
14484                         HV* curpkg = (IN_PERL_COMPILETIME)
14485                                       ? PL_curstash
14486                                       : CopSTASH(PL_curcop);
14487                         if (swash) {
14488                             SvREFCNT_dec_NN(swash);
14489                             swash = NULL;
14490                         }
14491
14492                         /* Here didn't find it.  It could be a user-defined
14493                          * property that will be available at run-time.  If we
14494                          * accept only compile-time properties, is an error;
14495                          * otherwise add it to the list for run-time look up */
14496                         if (ret_invlist) {
14497                             RExC_parse = e + 1;
14498                             vFAIL2utf8f(
14499                                 "Property '%"UTF8f"' is unknown",
14500                                 UTF8fARG(UTF, n, name));
14501                         }
14502
14503                         /* If the property name doesn't already have a package
14504                          * name, add the current one to it so that it can be
14505                          * referred to outside it. [perl #121777] */
14506                         if (curpkg && ! instr(name, "::")) {
14507                             char* pkgname = HvNAME(curpkg);
14508                             if (strNE(pkgname, "main")) {
14509                                 char* full_name = Perl_form(aTHX_
14510                                                             "%s::%s",
14511                                                             pkgname,
14512                                                             name);
14513                                 n = strlen(full_name);
14514                                 Safefree(name);
14515                                 name = savepvn(full_name, n);
14516                             }
14517                         }
14518                         Perl_sv_catpvf(aTHX_ listsv, "%cutf8::%"UTF8f"\n",
14519                                         (value == 'p' ? '+' : '!'),
14520                                         UTF8fARG(UTF, n, name));
14521                         has_user_defined_property = TRUE;
14522
14523                         /* We don't know yet, so have to assume that the
14524                          * property could match something in the Latin1 range,
14525                          * hence something that isn't utf8.  Note that this
14526                          * would cause things in <depends_list> to match
14527                          * inappropriately, except that any \p{}, including
14528                          * this one forces Unicode semantics, which means there
14529                          * is no <depends_list> */
14530                         ANYOF_FLAGS(ret)
14531                                       |= ANYOF_HAS_NONBITMAP_NON_UTF8_MATCHES;
14532                     }
14533                     else {
14534
14535                         /* Here, did get the swash and its inversion list.  If
14536                          * the swash is from a user-defined property, then this
14537                          * whole character class should be regarded as such */
14538                         if (swash_init_flags
14539                             & _CORE_SWASH_INIT_USER_DEFINED_PROPERTY)
14540                         {
14541                             has_user_defined_property = TRUE;
14542                         }
14543                         else if
14544                             /* We warn on matching an above-Unicode code point
14545                              * if the match would return true, except don't
14546                              * warn for \p{All}, which has exactly one element
14547                              * = 0 */
14548                             (_invlist_contains_cp(invlist, 0x110000)
14549                                 && (! (_invlist_len(invlist) == 1
14550                                        && *invlist_array(invlist) == 0)))
14551                         {
14552                             warn_super = TRUE;
14553                         }
14554
14555
14556                         /* Invert if asking for the complement */
14557                         if (value == 'P') {
14558                             _invlist_union_complement_2nd(properties,
14559                                                           invlist,
14560                                                           &properties);
14561
14562                             /* The swash can't be used as-is, because we've
14563                              * inverted things; delay removing it to here after
14564                              * have copied its invlist above */
14565                             SvREFCNT_dec_NN(swash);
14566                             swash = NULL;
14567                         }
14568                         else {
14569                             _invlist_union(properties, invlist, &properties);
14570                         }
14571                     }
14572                     Safefree(name);
14573                 }
14574                 RExC_parse = e + 1;
14575                 namedclass = ANYOF_UNIPROP;  /* no official name, but it's
14576                                                 named */
14577
14578                 /* \p means they want Unicode semantics */
14579                 RExC_uni_semantics = 1;
14580                 }
14581                 break;
14582             case 'n':   value = '\n';                   break;
14583             case 'r':   value = '\r';                   break;
14584             case 't':   value = '\t';                   break;
14585             case 'f':   value = '\f';                   break;
14586             case 'b':   value = '\b';                   break;
14587             case 'e':   value = ESC_NATIVE;             break;
14588             case 'a':   value = '\a';                   break;
14589             case 'o':
14590                 RExC_parse--;   /* function expects to be pointed at the 'o' */
14591                 {
14592                     const char* error_msg;
14593                     bool valid = grok_bslash_o(&RExC_parse,
14594                                                &value,
14595                                                &error_msg,
14596                                                PASS2,   /* warnings only in
14597                                                            pass 2 */
14598                                                strict,
14599                                                silence_non_portable,
14600                                                UTF);
14601                     if (! valid) {
14602                         vFAIL(error_msg);
14603                     }
14604                 }
14605                 non_portable_endpoint++;
14606                 if (IN_ENCODING && value < 0x100) {
14607                     goto recode_encoding;
14608                 }
14609                 break;
14610             case 'x':
14611                 RExC_parse--;   /* function expects to be pointed at the 'x' */
14612                 {
14613                     const char* error_msg;
14614                     bool valid = grok_bslash_x(&RExC_parse,
14615                                                &value,
14616                                                &error_msg,
14617                                                PASS2, /* Output warnings */
14618                                                strict,
14619                                                silence_non_portable,
14620                                                UTF);
14621                     if (! valid) {
14622                         vFAIL(error_msg);
14623                     }
14624                 }
14625                 non_portable_endpoint++;
14626                 if (IN_ENCODING && value < 0x100)
14627                     goto recode_encoding;
14628                 break;
14629             case 'c':
14630                 value = grok_bslash_c(*RExC_parse++, PASS2);
14631                 non_portable_endpoint++;
14632                 break;
14633             case '0': case '1': case '2': case '3': case '4':
14634             case '5': case '6': case '7':
14635                 {
14636                     /* Take 1-3 octal digits */
14637                     I32 flags = PERL_SCAN_SILENT_ILLDIGIT;
14638                     numlen = (strict) ? 4 : 3;
14639                     value = grok_oct(--RExC_parse, &numlen, &flags, NULL);
14640                     RExC_parse += numlen;
14641                     if (numlen != 3) {
14642                         if (strict) {
14643                             RExC_parse += (UTF) ? UTF8SKIP(RExC_parse) : 1;
14644                             vFAIL("Need exactly 3 octal digits");
14645                         }
14646                         else if (! SIZE_ONLY /* like \08, \178 */
14647                                  && numlen < 3
14648                                  && RExC_parse < RExC_end
14649                                  && isDIGIT(*RExC_parse)
14650                                  && ckWARN(WARN_REGEXP))
14651                         {
14652                             SAVEFREESV(RExC_rx_sv);
14653                             reg_warn_non_literal_string(
14654                                  RExC_parse + 1,
14655                                  form_short_octal_warning(RExC_parse, numlen));
14656                             (void)ReREFCNT_inc(RExC_rx_sv);
14657                         }
14658                     }
14659                     non_portable_endpoint++;
14660                     if (IN_ENCODING && value < 0x100)
14661                         goto recode_encoding;
14662                     break;
14663                 }
14664               recode_encoding:
14665                 if (! RExC_override_recoding) {
14666                     SV* enc = _get_encoding();
14667                     value = reg_recode((const char)(U8)value, &enc);
14668                     if (!enc) {
14669                         if (strict) {
14670                             vFAIL("Invalid escape in the specified encoding");
14671                         }
14672                         else if (PASS2) {
14673                             ckWARNreg(RExC_parse,
14674                                   "Invalid escape in the specified encoding");
14675                         }
14676                     }
14677                     break;
14678                 }
14679             default:
14680                 /* Allow \_ to not give an error */
14681                 if (!SIZE_ONLY && isWORDCHAR(value) && value != '_') {
14682                     if (strict) {
14683                         vFAIL2("Unrecognized escape \\%c in character class",
14684                                (int)value);
14685                     }
14686                     else {
14687                         SAVEFREESV(RExC_rx_sv);
14688                         ckWARN2reg(RExC_parse,
14689                             "Unrecognized escape \\%c in character class passed through",
14690                             (int)value);
14691                         (void)ReREFCNT_inc(RExC_rx_sv);
14692                     }
14693                 }
14694                 break;
14695             }   /* End of switch on char following backslash */
14696         } /* end of handling backslash escape sequences */
14697
14698         /* Here, we have the current token in 'value' */
14699
14700         if (namedclass > OOB_NAMEDCLASS) { /* this is a named class \blah */
14701             U8 classnum;
14702
14703             /* a bad range like a-\d, a-[:digit:].  The '-' is taken as a
14704              * literal, as is the character that began the false range, i.e.
14705              * the 'a' in the examples */
14706             if (range) {
14707                 if (!SIZE_ONLY) {
14708                     const int w = (RExC_parse >= rangebegin)
14709                                   ? RExC_parse - rangebegin
14710                                   : 0;
14711                     if (strict) {
14712                         vFAIL2utf8f(
14713                             "False [] range \"%"UTF8f"\"",
14714                             UTF8fARG(UTF, w, rangebegin));
14715                     }
14716                     else {
14717                         SAVEFREESV(RExC_rx_sv); /* in case of fatal warnings */
14718                         ckWARN2reg(RExC_parse,
14719                             "False [] range \"%"UTF8f"\"",
14720                             UTF8fARG(UTF, w, rangebegin));
14721                         (void)ReREFCNT_inc(RExC_rx_sv);
14722                         cp_list = add_cp_to_invlist(cp_list, '-');
14723                         cp_foldable_list = add_cp_to_invlist(cp_foldable_list,
14724                                                              prevvalue);
14725                     }
14726                 }
14727
14728                 range = 0; /* this was not a true range */
14729                 element_count += 2; /* So counts for three values */
14730             }
14731
14732             classnum = namedclass_to_classnum(namedclass);
14733
14734             if (LOC && namedclass < ANYOF_POSIXL_MAX
14735 #ifndef HAS_ISASCII
14736                 && classnum != _CC_ASCII
14737 #endif
14738             ) {
14739                 /* What the Posix classes (like \w, [:space:]) match in locale
14740                  * isn't knowable under locale until actual match time.  Room
14741                  * must be reserved (one time per outer bracketed class) to
14742                  * store such classes.  The space will contain a bit for each
14743                  * named class that is to be matched against.  This isn't
14744                  * needed for \p{} and pseudo-classes, as they are not affected
14745                  * by locale, and hence are dealt with separately */
14746                 if (! need_class) {
14747                     need_class = 1;
14748                     if (SIZE_ONLY) {
14749                         RExC_size += ANYOF_POSIXL_SKIP - ANYOF_SKIP;
14750                     }
14751                     else {
14752                         RExC_emit += ANYOF_POSIXL_SKIP - ANYOF_SKIP;
14753                     }
14754                     ANYOF_FLAGS(ret) |= ANYOF_MATCHES_POSIXL;
14755                     ANYOF_POSIXL_ZERO(ret);
14756                 }
14757
14758                 /* Coverity thinks it is possible for this to be negative; both
14759                  * jhi and khw think it's not, but be safer */
14760                 assert(! (ANYOF_FLAGS(ret) & ANYOF_MATCHES_POSIXL)
14761                        || (namedclass + ((namedclass % 2) ? -1 : 1)) >= 0);
14762
14763                 /* See if it already matches the complement of this POSIX
14764                  * class */
14765                 if ((ANYOF_FLAGS(ret) & ANYOF_MATCHES_POSIXL)
14766                     && ANYOF_POSIXL_TEST(ret, namedclass + ((namedclass % 2)
14767                                                             ? -1
14768                                                             : 1)))
14769                 {
14770                     posixl_matches_all = TRUE;
14771                     break;  /* No need to continue.  Since it matches both
14772                                e.g., \w and \W, it matches everything, and the
14773                                bracketed class can be optimized into qr/./s */
14774                 }
14775
14776                 /* Add this class to those that should be checked at runtime */
14777                 ANYOF_POSIXL_SET(ret, namedclass);
14778
14779                 /* The above-Latin1 characters are not subject to locale rules.
14780                  * Just add them, in the second pass, to the
14781                  * unconditionally-matched list */
14782                 if (! SIZE_ONLY) {
14783                     SV* scratch_list = NULL;
14784
14785                     /* Get the list of the above-Latin1 code points this
14786                      * matches */
14787                     _invlist_intersection_maybe_complement_2nd(PL_AboveLatin1,
14788                                           PL_XPosix_ptrs[classnum],
14789
14790                                           /* Odd numbers are complements, like
14791                                            * NDIGIT, NASCII, ... */
14792                                           namedclass % 2 != 0,
14793                                           &scratch_list);
14794                     /* Checking if 'cp_list' is NULL first saves an extra
14795                      * clone.  Its reference count will be decremented at the
14796                      * next union, etc, or if this is the only instance, at the
14797                      * end of the routine */
14798                     if (! cp_list) {
14799                         cp_list = scratch_list;
14800                     }
14801                     else {
14802                         _invlist_union(cp_list, scratch_list, &cp_list);
14803                         SvREFCNT_dec_NN(scratch_list);
14804                     }
14805                     continue;   /* Go get next character */
14806                 }
14807             }
14808             else if (! SIZE_ONLY) {
14809
14810                 /* Here, not in pass1 (in that pass we skip calculating the
14811                  * contents of this class), and is /l, or is a POSIX class for
14812                  * which /l doesn't matter (or is a Unicode property, which is
14813                  * skipped here). */
14814                 if (namedclass >= ANYOF_POSIXL_MAX) {  /* If a special class */
14815                     if (namedclass != ANYOF_UNIPROP) { /* UNIPROP = \p and \P */
14816
14817                         /* Here, should be \h, \H, \v, or \V.  None of /d, /i
14818                          * nor /l make a difference in what these match,
14819                          * therefore we just add what they match to cp_list. */
14820                         if (classnum != _CC_VERTSPACE) {
14821                             assert(   namedclass == ANYOF_HORIZWS
14822                                    || namedclass == ANYOF_NHORIZWS);
14823
14824                             /* It turns out that \h is just a synonym for
14825                              * XPosixBlank */
14826                             classnum = _CC_BLANK;
14827                         }
14828
14829                         _invlist_union_maybe_complement_2nd(
14830                                 cp_list,
14831                                 PL_XPosix_ptrs[classnum],
14832                                 namedclass % 2 != 0,    /* Complement if odd
14833                                                           (NHORIZWS, NVERTWS)
14834                                                         */
14835                                 &cp_list);
14836                     }
14837                 }
14838                 else if (UNI_SEMANTICS
14839                         || classnum == _CC_ASCII
14840                         || (DEPENDS_SEMANTICS && (classnum == _CC_DIGIT
14841                                                   || classnum == _CC_XDIGIT)))
14842                 {
14843                     /* We usually have to worry about /d and /a affecting what
14844                      * POSIX classes match, with special code needed for /d
14845                      * because we won't know until runtime what all matches.
14846                      * But there is no extra work needed under /u, and
14847                      * [:ascii:] is unaffected by /a and /d; and :digit: and
14848                      * :xdigit: don't have runtime differences under /d.  So we
14849                      * can special case these, and avoid some extra work below,
14850                      * and at runtime. */
14851                     _invlist_union_maybe_complement_2nd(
14852                                                      simple_posixes,
14853                                                      PL_XPosix_ptrs[classnum],
14854                                                      namedclass % 2 != 0,
14855                                                      &simple_posixes);
14856                 }
14857                 else {  /* Garden variety class.  If is NUPPER, NALPHA, ...
14858                            complement and use nposixes */
14859                     SV** posixes_ptr = namedclass % 2 == 0
14860                                        ? &posixes
14861                                        : &nposixes;
14862                     _invlist_union_maybe_complement_2nd(
14863                                                      *posixes_ptr,
14864                                                      PL_XPosix_ptrs[classnum],
14865                                                      namedclass % 2 != 0,
14866                                                      posixes_ptr);
14867                 }
14868             }
14869         } /* end of namedclass \blah */
14870
14871         if (skip_white) {
14872             RExC_parse = regpatws(pRExC_state, RExC_parse,
14873                                 FALSE /* means don't recognize comments */ );
14874         }
14875
14876         /* If 'range' is set, 'value' is the ending of a range--check its
14877          * validity.  (If value isn't a single code point in the case of a
14878          * range, we should have figured that out above in the code that
14879          * catches false ranges).  Later, we will handle each individual code
14880          * point in the range.  If 'range' isn't set, this could be the
14881          * beginning of a range, so check for that by looking ahead to see if
14882          * the next real character to be processed is the range indicator--the
14883          * minus sign */
14884
14885         if (range) {
14886 #ifdef EBCDIC
14887             /* For unicode ranges, we have to test that the Unicode as opposed
14888              * to the native values are not decreasing.  (Above 255, there is
14889              * no difference between native and Unicode) */
14890             if (unicode_range && prevvalue < 255 && value < 255) {
14891                 if (NATIVE_TO_LATIN1(prevvalue) > NATIVE_TO_LATIN1(value)) {
14892                     goto backwards_range;
14893                 }
14894             }
14895             else
14896 #endif
14897             if (prevvalue > value) /* b-a */ {
14898                 int w;
14899 #ifdef EBCDIC
14900               backwards_range:
14901 #endif
14902                 w = RExC_parse - rangebegin;
14903                 vFAIL2utf8f(
14904                     "Invalid [] range \"%"UTF8f"\"",
14905                     UTF8fARG(UTF, w, rangebegin));
14906                 NOT_REACHED; /* NOTREACHED */
14907             }
14908         }
14909         else {
14910             prevvalue = value; /* save the beginning of the potential range */
14911             if (! stop_at_1     /* Can't be a range if parsing just one thing */
14912                 && *RExC_parse == '-')
14913             {
14914                 char* next_char_ptr = RExC_parse + 1;
14915                 if (skip_white) {   /* Get the next real char after the '-' */
14916                     next_char_ptr = regpatws(pRExC_state,
14917                                              RExC_parse + 1,
14918                                              FALSE); /* means don't recognize
14919                                                         comments */
14920                 }
14921
14922                 /* If the '-' is at the end of the class (just before the ']',
14923                  * it is a literal minus; otherwise it is a range */
14924                 if (next_char_ptr < RExC_end && *next_char_ptr != ']') {
14925                     RExC_parse = next_char_ptr;
14926
14927                     /* a bad range like \w-, [:word:]- ? */
14928                     if (namedclass > OOB_NAMEDCLASS) {
14929                         if (strict || (PASS2 && ckWARN(WARN_REGEXP))) {
14930                             const int w = RExC_parse >= rangebegin
14931                                           ?  RExC_parse - rangebegin
14932                                           : 0;
14933                             if (strict) {
14934                                 vFAIL4("False [] range \"%*.*s\"",
14935                                     w, w, rangebegin);
14936                             }
14937                             else if (PASS2) {
14938                                 vWARN4(RExC_parse,
14939                                     "False [] range \"%*.*s\"",
14940                                     w, w, rangebegin);
14941                             }
14942                         }
14943                         if (!SIZE_ONLY) {
14944                             cp_list = add_cp_to_invlist(cp_list, '-');
14945                         }
14946                         element_count++;
14947                     } else
14948                         range = 1;      /* yeah, it's a range! */
14949                     continue;   /* but do it the next time */
14950                 }
14951             }
14952         }
14953
14954         if (namedclass > OOB_NAMEDCLASS) {
14955             continue;
14956         }
14957
14958         /* Here, we have a single value this time through the loop, and
14959          * <prevvalue> is the beginning of the range, if any; or <value> if
14960          * not. */
14961
14962         /* non-Latin1 code point implies unicode semantics.  Must be set in
14963          * pass1 so is there for the whole of pass 2 */
14964         if (value > 255) {
14965             RExC_uni_semantics = 1;
14966         }
14967
14968         /* Ready to process either the single value, or the completed range.
14969          * For single-valued non-inverted ranges, we consider the possibility
14970          * of multi-char folds.  (We made a conscious decision to not do this
14971          * for the other cases because it can often lead to non-intuitive
14972          * results.  For example, you have the peculiar case that:
14973          *  "s s" =~ /^[^\xDF]+$/i => Y
14974          *  "ss"  =~ /^[^\xDF]+$/i => N
14975          *
14976          * See [perl #89750] */
14977         if (FOLD && allow_multi_folds && value == prevvalue) {
14978             if (value == LATIN_SMALL_LETTER_SHARP_S
14979                 || (value > 255 && _invlist_contains_cp(PL_HasMultiCharFold,
14980                                                         value)))
14981             {
14982                 /* Here <value> is indeed a multi-char fold.  Get what it is */
14983
14984                 U8 foldbuf[UTF8_MAXBYTES_CASE];
14985                 STRLEN foldlen;
14986
14987                 UV folded = _to_uni_fold_flags(
14988                                 value,
14989                                 foldbuf,
14990                                 &foldlen,
14991                                 FOLD_FLAGS_FULL | (ASCII_FOLD_RESTRICTED
14992                                                    ? FOLD_FLAGS_NOMIX_ASCII
14993                                                    : 0)
14994                                 );
14995
14996                 /* Here, <folded> should be the first character of the
14997                  * multi-char fold of <value>, with <foldbuf> containing the
14998                  * whole thing.  But, if this fold is not allowed (because of
14999                  * the flags), <fold> will be the same as <value>, and should
15000                  * be processed like any other character, so skip the special
15001                  * handling */
15002                 if (folded != value) {
15003
15004                     /* Skip if we are recursed, currently parsing the class
15005                      * again.  Otherwise add this character to the list of
15006                      * multi-char folds. */
15007                     if (! RExC_in_multi_char_class) {
15008                         STRLEN cp_count = utf8_length(foldbuf,
15009                                                       foldbuf + foldlen);
15010                         SV* multi_fold = sv_2mortal(newSVpvs(""));
15011
15012                         Perl_sv_catpvf(aTHX_ multi_fold, "\\x{%"UVXf"}", value);
15013
15014                         multi_char_matches
15015                                         = add_multi_match(multi_char_matches,
15016                                                           multi_fold,
15017                                                           cp_count);
15018
15019                     }
15020
15021                     /* This element should not be processed further in this
15022                      * class */
15023                     element_count--;
15024                     value = save_value;
15025                     prevvalue = save_prevvalue;
15026                     continue;
15027                 }
15028             }
15029         }
15030
15031         if (strict && PASS2 && ckWARN(WARN_REGEXP)) {
15032             if (range) {
15033
15034                 /* If the range starts above 255, everything is portable and
15035                  * likely to be so for any forseeable character set, so don't
15036                  * warn. */
15037                 if (unicode_range && non_portable_endpoint && prevvalue < 256) {
15038                     vWARN(RExC_parse, "Both or neither range ends should be Unicode");
15039                 }
15040                 else if (prevvalue != value) {
15041
15042                     /* Under strict, ranges that stop and/or end in an ASCII
15043                      * printable should have each end point be a portable value
15044                      * for it (preferably like 'A', but we don't warn if it is
15045                      * a (portable) Unicode name or code point), and the range
15046                      * must be be all digits or all letters of the same case.
15047                      * Otherwise, the range is non-portable and unclear as to
15048                      * what it contains */
15049                     if ((isPRINT_A(prevvalue) || isPRINT_A(value))
15050                         && (non_portable_endpoint
15051                             || ! ((isDIGIT_A(prevvalue) && isDIGIT_A(value))
15052                                    || (isLOWER_A(prevvalue) && isLOWER_A(value))
15053                                    || (isUPPER_A(prevvalue) && isUPPER_A(value)))))
15054                     {
15055                         vWARN(RExC_parse, "Ranges of ASCII printables should be some subset of \"0-9\", \"A-Z\", or \"a-z\"");
15056                     }
15057                     else if (prevvalue >= 0x660) { /* ARABIC_INDIC_DIGIT_ZERO */
15058
15059                         /* But the nature of Unicode and languages mean we
15060                          * can't do the same checks for above-ASCII ranges,
15061                          * except in the case of digit ones.  These should
15062                          * contain only digits from the same group of 10.  The
15063                          * ASCII case is handled just above.  0x660 is the
15064                          * first digit character beyond ASCII.  Hence here, the
15065                          * range could be a range of digits.  Find out.  */
15066                         IV index_start = _invlist_search(PL_XPosix_ptrs[_CC_DIGIT],
15067                                                          prevvalue);
15068                         IV index_final = _invlist_search(PL_XPosix_ptrs[_CC_DIGIT],
15069                                                          value);
15070
15071                         /* If the range start and final points are in the same
15072                          * inversion list element, it means that either both
15073                          * are not digits, or both are digits in a consecutive
15074                          * sequence of digits.  (So far, Unicode has kept all
15075                          * such sequences as distinct groups of 10, but assert
15076                          * to make sure).  If the end points are not in the
15077                          * same element, neither should be a digit. */
15078                         if (index_start == index_final) {
15079                             assert(! ELEMENT_RANGE_MATCHES_INVLIST(index_start)
15080                             || (invlist_array(PL_XPosix_ptrs[_CC_DIGIT])[index_start+1]
15081                                - invlist_array(PL_XPosix_ptrs[_CC_DIGIT])[index_start]
15082                                == 10)
15083                                /* But actually Unicode did have one group of 11
15084                                 * 'digits' in 5.2, so in case we are operating
15085                                 * on that version, let that pass */
15086                             || (invlist_array(PL_XPosix_ptrs[_CC_DIGIT])[index_start+1]
15087                                - invlist_array(PL_XPosix_ptrs[_CC_DIGIT])[index_start]
15088                                 == 11
15089                                && invlist_array(PL_XPosix_ptrs[_CC_DIGIT])[index_start]
15090                                 == 0x19D0)
15091                             );
15092                         }
15093                         else if ((index_start >= 0
15094                                   && ELEMENT_RANGE_MATCHES_INVLIST(index_start))
15095                                  || (index_final >= 0
15096                                      && ELEMENT_RANGE_MATCHES_INVLIST(index_final)))
15097                         {
15098                             vWARN(RExC_parse, "Ranges of digits should be from the same group of 10");
15099                         }
15100                     }
15101                 }
15102             }
15103             if ((! range || prevvalue == value) && non_portable_endpoint) {
15104                 if (isPRINT_A(value)) {
15105                     char literal[3];
15106                     unsigned d = 0;
15107                     if (isBACKSLASHED_PUNCT(value)) {
15108                         literal[d++] = '\\';
15109                     }
15110                     literal[d++] = (char) value;
15111                     literal[d++] = '\0';
15112
15113                     vWARN4(RExC_parse,
15114                            "\"%.*s\" is more clearly written simply as \"%s\"",
15115                            (int) (RExC_parse - rangebegin),
15116                            rangebegin,
15117                            literal
15118                         );
15119                 }
15120                 else if isMNEMONIC_CNTRL(value) {
15121                     vWARN4(RExC_parse,
15122                            "\"%.*s\" is more clearly written simply as \"%s\"",
15123                            (int) (RExC_parse - rangebegin),
15124                            rangebegin,
15125                            cntrl_to_mnemonic((char) value)
15126                         );
15127                 }
15128             }
15129         }
15130
15131         /* Deal with this element of the class */
15132         if (! SIZE_ONLY) {
15133
15134 #ifndef EBCDIC
15135             cp_foldable_list = _add_range_to_invlist(cp_foldable_list,
15136                                                      prevvalue, value);
15137 #else
15138             /* On non-ASCII platforms, for ranges that span all of 0..255, and
15139              * ones that don't require special handling, we can just add the
15140              * range like we do for ASCII platforms */
15141             if ((UNLIKELY(prevvalue == 0) && value >= 255)
15142                 || ! (prevvalue < 256
15143                       && (unicode_range
15144                           || (! non_portable_endpoint
15145                               && ((isLOWER_A(prevvalue) && isLOWER_A(value))
15146                                   || (isUPPER_A(prevvalue)
15147                                       && isUPPER_A(value)))))))
15148             {
15149                 cp_foldable_list = _add_range_to_invlist(cp_foldable_list,
15150                                                          prevvalue, value);
15151             }
15152             else {
15153                 /* Here, requires special handling.  This can be because it is
15154                  * a range whose code points are considered to be Unicode, and
15155                  * so must be individually translated into native, or because
15156                  * its a subrange of 'A-Z' or 'a-z' which each aren't
15157                  * contiguous in EBCDIC, but we have defined them to include
15158                  * only the "expected" upper or lower case ASCII alphabetics.
15159                  * Subranges above 255 are the same in native and Unicode, so
15160                  * can be added as a range */
15161                 U8 start = NATIVE_TO_LATIN1(prevvalue);
15162                 unsigned j;
15163                 U8 end = (value < 256) ? NATIVE_TO_LATIN1(value) : 255;
15164                 for (j = start; j <= end; j++) {
15165                     cp_foldable_list = add_cp_to_invlist(cp_foldable_list, LATIN1_TO_NATIVE(j));
15166                 }
15167                 if (value > 255) {
15168                     cp_foldable_list = _add_range_to_invlist(cp_foldable_list,
15169                                                              256, value);
15170                 }
15171             }
15172 #endif
15173         }
15174
15175         range = 0; /* this range (if it was one) is done now */
15176     } /* End of loop through all the text within the brackets */
15177
15178     /* If anything in the class expands to more than one character, we have to
15179      * deal with them by building up a substitute parse string, and recursively
15180      * calling reg() on it, instead of proceeding */
15181     if (multi_char_matches) {
15182         SV * substitute_parse = newSVpvn_flags("?:", 2, SVs_TEMP);
15183         I32 cp_count;
15184         STRLEN len;
15185         char *save_end = RExC_end;
15186         char *save_parse = RExC_parse;
15187         bool first_time = TRUE;     /* First multi-char occurrence doesn't get
15188                                        a "|" */
15189         I32 reg_flags;
15190
15191         assert(! invert);
15192 #if 0   /* Have decided not to deal with multi-char folds in inverted classes,
15193            because too confusing */
15194         if (invert) {
15195             sv_catpv(substitute_parse, "(?:");
15196         }
15197 #endif
15198
15199         /* Look at the longest folds first */
15200         for (cp_count = av_tindex(multi_char_matches); cp_count > 0; cp_count--) {
15201
15202             if (av_exists(multi_char_matches, cp_count)) {
15203                 AV** this_array_ptr;
15204                 SV* this_sequence;
15205
15206                 this_array_ptr = (AV**) av_fetch(multi_char_matches,
15207                                                  cp_count, FALSE);
15208                 while ((this_sequence = av_pop(*this_array_ptr)) !=
15209                                                                 &PL_sv_undef)
15210                 {
15211                     if (! first_time) {
15212                         sv_catpv(substitute_parse, "|");
15213                     }
15214                     first_time = FALSE;
15215
15216                     sv_catpv(substitute_parse, SvPVX(this_sequence));
15217                 }
15218             }
15219         }
15220
15221         /* If the character class contains anything else besides these
15222          * multi-character folds, have to include it in recursive parsing */
15223         if (element_count) {
15224             sv_catpv(substitute_parse, "|[");
15225             sv_catpvn(substitute_parse, orig_parse, RExC_parse - orig_parse);
15226             sv_catpv(substitute_parse, "]");
15227         }
15228
15229         sv_catpv(substitute_parse, ")");
15230 #if 0
15231         if (invert) {
15232             /* This is a way to get the parse to skip forward a whole named
15233              * sequence instead of matching the 2nd character when it fails the
15234              * first */
15235             sv_catpv(substitute_parse, "(*THEN)(*SKIP)(*FAIL)|.)");
15236         }
15237 #endif
15238
15239         RExC_parse = SvPV(substitute_parse, len);
15240         RExC_end = RExC_parse + len;
15241         RExC_in_multi_char_class = 1;
15242         RExC_override_recoding = 1;
15243         RExC_emit = (regnode *)orig_emit;
15244
15245         ret = reg(pRExC_state, 1, &reg_flags, depth+1);
15246
15247         *flagp |= reg_flags&(HASWIDTH|SIMPLE|SPSTART|POSTPONED|RESTART_UTF8);
15248
15249         RExC_parse = save_parse;
15250         RExC_end = save_end;
15251         RExC_in_multi_char_class = 0;
15252         RExC_override_recoding = 0;
15253         SvREFCNT_dec_NN(multi_char_matches);
15254         return ret;
15255     }
15256
15257     /* Here, we've gone through the entire class and dealt with multi-char
15258      * folds.  We are now in a position that we can do some checks to see if we
15259      * can optimize this ANYOF node into a simpler one, even in Pass 1.
15260      * Currently we only do two checks:
15261      * 1) is in the unlikely event that the user has specified both, eg. \w and
15262      *    \W under /l, then the class matches everything.  (This optimization
15263      *    is done only to make the optimizer code run later work.)
15264      * 2) if the character class contains only a single element (including a
15265      *    single range), we see if there is an equivalent node for it.
15266      * Other checks are possible */
15267     if (! ret_invlist   /* Can't optimize if returning the constructed
15268                            inversion list */
15269         && (UNLIKELY(posixl_matches_all) || element_count == 1))
15270     {
15271         U8 op = END;
15272         U8 arg = 0;
15273
15274         if (UNLIKELY(posixl_matches_all)) {
15275             op = SANY;
15276         }
15277         else if (namedclass > OOB_NAMEDCLASS) { /* this is a named class, like
15278                                                    \w or [:digit:] or \p{foo}
15279                                                  */
15280
15281             /* All named classes are mapped into POSIXish nodes, with its FLAG
15282              * argument giving which class it is */
15283             switch ((I32)namedclass) {
15284                 case ANYOF_UNIPROP:
15285                     break;
15286
15287                 /* These don't depend on the charset modifiers.  They always
15288                  * match under /u rules */
15289                 case ANYOF_NHORIZWS:
15290                 case ANYOF_HORIZWS:
15291                     namedclass = ANYOF_BLANK + namedclass - ANYOF_HORIZWS;
15292                     /* FALLTHROUGH */
15293
15294                 case ANYOF_NVERTWS:
15295                 case ANYOF_VERTWS:
15296                     op = POSIXU;
15297                     goto join_posix;
15298
15299                 /* The actual POSIXish node for all the rest depends on the
15300                  * charset modifier.  The ones in the first set depend only on
15301                  * ASCII or, if available on this platform, also locale */
15302                 case ANYOF_ASCII:
15303                 case ANYOF_NASCII:
15304 #ifdef HAS_ISASCII
15305                     op = (LOC) ? POSIXL : POSIXA;
15306 #else
15307                     op = POSIXA;
15308 #endif
15309                     goto join_posix;
15310
15311                 /* The following don't have any matches in the upper Latin1
15312                  * range, hence /d is equivalent to /u for them.  Making it /u
15313                  * saves some branches at runtime */
15314                 case ANYOF_DIGIT:
15315                 case ANYOF_NDIGIT:
15316                 case ANYOF_XDIGIT:
15317                 case ANYOF_NXDIGIT:
15318                     if (! DEPENDS_SEMANTICS) {
15319                         goto treat_as_default;
15320                     }
15321
15322                     op = POSIXU;
15323                     goto join_posix;
15324
15325                 /* The following change to CASED under /i */
15326                 case ANYOF_LOWER:
15327                 case ANYOF_NLOWER:
15328                 case ANYOF_UPPER:
15329                 case ANYOF_NUPPER:
15330                     if (FOLD) {
15331                         namedclass = ANYOF_CASED + (namedclass % 2);
15332                     }
15333                     /* FALLTHROUGH */
15334
15335                 /* The rest have more possibilities depending on the charset.
15336                  * We take advantage of the enum ordering of the charset
15337                  * modifiers to get the exact node type, */
15338                 default:
15339                   treat_as_default:
15340                     op = POSIXD + get_regex_charset(RExC_flags);
15341                     if (op > POSIXA) { /* /aa is same as /a */
15342                         op = POSIXA;
15343                     }
15344
15345                   join_posix:
15346                     /* The odd numbered ones are the complements of the
15347                      * next-lower even number one */
15348                     if (namedclass % 2 == 1) {
15349                         invert = ! invert;
15350                         namedclass--;
15351                     }
15352                     arg = namedclass_to_classnum(namedclass);
15353                     break;
15354             }
15355         }
15356         else if (value == prevvalue) {
15357
15358             /* Here, the class consists of just a single code point */
15359
15360             if (invert) {
15361                 if (! LOC && value == '\n') {
15362                     op = REG_ANY; /* Optimize [^\n] */
15363                     *flagp |= HASWIDTH|SIMPLE;
15364                     MARK_NAUGHTY(1);
15365                 }
15366             }
15367             else if (value < 256 || UTF) {
15368
15369                 /* Optimize a single value into an EXACTish node, but not if it
15370                  * would require converting the pattern to UTF-8. */
15371                 op = compute_EXACTish(pRExC_state);
15372             }
15373         } /* Otherwise is a range */
15374         else if (! LOC) {   /* locale could vary these */
15375             if (prevvalue == '0') {
15376                 if (value == '9') {
15377                     arg = _CC_DIGIT;
15378                     op = POSIXA;
15379                 }
15380             }
15381             else if (! FOLD || ASCII_FOLD_RESTRICTED) {
15382                 /* We can optimize A-Z or a-z, but not if they could match
15383                  * something like the KELVIN SIGN under /i. */
15384                 if (prevvalue == 'A') {
15385                     if (value == 'Z'
15386 #ifdef EBCDIC
15387                         && ! non_portable_endpoint
15388 #endif
15389                     ) {
15390                         arg = (FOLD) ? _CC_ALPHA : _CC_UPPER;
15391                         op = POSIXA;
15392                     }
15393                 }
15394                 else if (prevvalue == 'a') {
15395                     if (value == 'z'
15396 #ifdef EBCDIC
15397                         && ! non_portable_endpoint
15398 #endif
15399                     ) {
15400                         arg = (FOLD) ? _CC_ALPHA : _CC_LOWER;
15401                         op = POSIXA;
15402                     }
15403                 }
15404             }
15405         }
15406
15407         /* Here, we have changed <op> away from its initial value iff we found
15408          * an optimization */
15409         if (op != END) {
15410
15411             /* Throw away this ANYOF regnode, and emit the calculated one,
15412              * which should correspond to the beginning, not current, state of
15413              * the parse */
15414             const char * cur_parse = RExC_parse;
15415             RExC_parse = (char *)orig_parse;
15416             if ( SIZE_ONLY) {
15417                 if (! LOC) {
15418
15419                     /* To get locale nodes to not use the full ANYOF size would
15420                      * require moving the code above that writes the portions
15421                      * of it that aren't in other nodes to after this point.
15422                      * e.g.  ANYOF_POSIXL_SET */
15423                     RExC_size = orig_size;
15424                 }
15425             }
15426             else {
15427                 RExC_emit = (regnode *)orig_emit;
15428                 if (PL_regkind[op] == POSIXD) {
15429                     if (op == POSIXL) {
15430                         RExC_contains_locale = 1;
15431                     }
15432                     if (invert) {
15433                         op += NPOSIXD - POSIXD;
15434                     }
15435                 }
15436             }
15437
15438             ret = reg_node(pRExC_state, op);
15439
15440             if (PL_regkind[op] == POSIXD || PL_regkind[op] == NPOSIXD) {
15441                 if (! SIZE_ONLY) {
15442                     FLAGS(ret) = arg;
15443                 }
15444                 *flagp |= HASWIDTH|SIMPLE;
15445             }
15446             else if (PL_regkind[op] == EXACT) {
15447                 alloc_maybe_populate_EXACT(pRExC_state, ret, flagp, 0, value,
15448                                            TRUE /* downgradable to EXACT */
15449                                            );
15450             }
15451
15452             RExC_parse = (char *) cur_parse;
15453
15454             SvREFCNT_dec(posixes);
15455             SvREFCNT_dec(nposixes);
15456             SvREFCNT_dec(simple_posixes);
15457             SvREFCNT_dec(cp_list);
15458             SvREFCNT_dec(cp_foldable_list);
15459             return ret;
15460         }
15461     }
15462
15463     if (SIZE_ONLY)
15464         return ret;
15465     /****** !SIZE_ONLY (Pass 2) AFTER HERE *********/
15466
15467     /* If folding, we calculate all characters that could fold to or from the
15468      * ones already on the list */
15469     if (cp_foldable_list) {
15470         if (FOLD) {
15471             UV start, end;      /* End points of code point ranges */
15472
15473             SV* fold_intersection = NULL;
15474             SV** use_list;
15475
15476             /* Our calculated list will be for Unicode rules.  For locale
15477              * matching, we have to keep a separate list that is consulted at
15478              * runtime only when the locale indicates Unicode rules.  For
15479              * non-locale, we just use to the general list */
15480             if (LOC) {
15481                 use_list = &only_utf8_locale_list;
15482             }
15483             else {
15484                 use_list = &cp_list;
15485             }
15486
15487             /* Only the characters in this class that participate in folds need
15488              * be checked.  Get the intersection of this class and all the
15489              * possible characters that are foldable.  This can quickly narrow
15490              * down a large class */
15491             _invlist_intersection(PL_utf8_foldable, cp_foldable_list,
15492                                   &fold_intersection);
15493
15494             /* The folds for all the Latin1 characters are hard-coded into this
15495              * program, but we have to go out to disk to get the others. */
15496             if (invlist_highest(cp_foldable_list) >= 256) {
15497
15498                 /* This is a hash that for a particular fold gives all
15499                  * characters that are involved in it */
15500                 if (! PL_utf8_foldclosures) {
15501                     _load_PL_utf8_foldclosures();
15502                 }
15503             }
15504
15505             /* Now look at the foldable characters in this class individually */
15506             invlist_iterinit(fold_intersection);
15507             while (invlist_iternext(fold_intersection, &start, &end)) {
15508                 UV j;
15509
15510                 /* Look at every character in the range */
15511                 for (j = start; j <= end; j++) {
15512                     U8 foldbuf[UTF8_MAXBYTES_CASE+1];
15513                     STRLEN foldlen;
15514                     SV** listp;
15515
15516                     if (j < 256) {
15517
15518                         if (IS_IN_SOME_FOLD_L1(j)) {
15519
15520                             /* ASCII is always matched; non-ASCII is matched
15521                              * only under Unicode rules (which could happen
15522                              * under /l if the locale is a UTF-8 one */
15523                             if (isASCII(j) || ! DEPENDS_SEMANTICS) {
15524                                 *use_list = add_cp_to_invlist(*use_list,
15525                                                             PL_fold_latin1[j]);
15526                             }
15527                             else {
15528                                 depends_list =
15529                                  add_cp_to_invlist(depends_list,
15530                                                    PL_fold_latin1[j]);
15531                             }
15532                         }
15533
15534                         if (HAS_NONLATIN1_SIMPLE_FOLD_CLOSURE(j)
15535                             && (! isASCII(j) || ! ASCII_FOLD_RESTRICTED))
15536                         {
15537                             add_above_Latin1_folds(pRExC_state,
15538                                                    (U8) j,
15539                                                    use_list);
15540                         }
15541                         continue;
15542                     }
15543
15544                     /* Here is an above Latin1 character.  We don't have the
15545                      * rules hard-coded for it.  First, get its fold.  This is
15546                      * the simple fold, as the multi-character folds have been
15547                      * handled earlier and separated out */
15548                     _to_uni_fold_flags(j, foldbuf, &foldlen,
15549                                                         (ASCII_FOLD_RESTRICTED)
15550                                                         ? FOLD_FLAGS_NOMIX_ASCII
15551                                                         : 0);
15552
15553                     /* Single character fold of above Latin1.  Add everything in
15554                     * its fold closure to the list that this node should match.
15555                     * The fold closures data structure is a hash with the keys
15556                     * being the UTF-8 of every character that is folded to, like
15557                     * 'k', and the values each an array of all code points that
15558                     * fold to its key.  e.g. [ 'k', 'K', KELVIN_SIGN ].
15559                     * Multi-character folds are not included */
15560                     if ((listp = hv_fetch(PL_utf8_foldclosures,
15561                                         (char *) foldbuf, foldlen, FALSE)))
15562                     {
15563                         AV* list = (AV*) *listp;
15564                         IV k;
15565                         for (k = 0; k <= av_tindex(list); k++) {
15566                             SV** c_p = av_fetch(list, k, FALSE);
15567                             UV c;
15568                             assert(c_p);
15569
15570                             c = SvUV(*c_p);
15571
15572                             /* /aa doesn't allow folds between ASCII and non- */
15573                             if ((ASCII_FOLD_RESTRICTED
15574                                 && (isASCII(c) != isASCII(j))))
15575                             {
15576                                 continue;
15577                             }
15578
15579                             /* Folds under /l which cross the 255/256 boundary
15580                              * are added to a separate list.  (These are valid
15581                              * only when the locale is UTF-8.) */
15582                             if (c < 256 && LOC) {
15583                                 *use_list = add_cp_to_invlist(*use_list, c);
15584                                 continue;
15585                             }
15586
15587                             if (isASCII(c) || c > 255 || AT_LEAST_UNI_SEMANTICS)
15588                             {
15589                                 cp_list = add_cp_to_invlist(cp_list, c);
15590                             }
15591                             else {
15592                                 /* Similarly folds involving non-ascii Latin1
15593                                 * characters under /d are added to their list */
15594                                 depends_list = add_cp_to_invlist(depends_list,
15595                                                                  c);
15596                             }
15597                         }
15598                     }
15599                 }
15600             }
15601             SvREFCNT_dec_NN(fold_intersection);
15602         }
15603
15604         /* Now that we have finished adding all the folds, there is no reason
15605          * to keep the foldable list separate */
15606         _invlist_union(cp_list, cp_foldable_list, &cp_list);
15607         SvREFCNT_dec_NN(cp_foldable_list);
15608     }
15609
15610     /* And combine the result (if any) with any inversion list from posix
15611      * classes.  The lists are kept separate up to now because we don't want to
15612      * fold the classes (folding of those is automatically handled by the swash
15613      * fetching code) */
15614     if (simple_posixes) {
15615         _invlist_union(cp_list, simple_posixes, &cp_list);
15616         SvREFCNT_dec_NN(simple_posixes);
15617     }
15618     if (posixes || nposixes) {
15619         if (posixes && AT_LEAST_ASCII_RESTRICTED) {
15620             /* Under /a and /aa, nothing above ASCII matches these */
15621             _invlist_intersection(posixes,
15622                                   PL_XPosix_ptrs[_CC_ASCII],
15623                                   &posixes);
15624         }
15625         if (nposixes) {
15626             if (DEPENDS_SEMANTICS) {
15627                 /* Under /d, everything in the upper half of the Latin1 range
15628                  * matches these complements */
15629                 ANYOF_FLAGS(ret) |= ANYOF_MATCHES_ALL_NON_UTF8_NON_ASCII;
15630             }
15631             else if (AT_LEAST_ASCII_RESTRICTED) {
15632                 /* Under /a and /aa, everything above ASCII matches these
15633                  * complements */
15634                 _invlist_union_complement_2nd(nposixes,
15635                                               PL_XPosix_ptrs[_CC_ASCII],
15636                                               &nposixes);
15637             }
15638             if (posixes) {
15639                 _invlist_union(posixes, nposixes, &posixes);
15640                 SvREFCNT_dec_NN(nposixes);
15641             }
15642             else {
15643                 posixes = nposixes;
15644             }
15645         }
15646         if (! DEPENDS_SEMANTICS) {
15647             if (cp_list) {
15648                 _invlist_union(cp_list, posixes, &cp_list);
15649                 SvREFCNT_dec_NN(posixes);
15650             }
15651             else {
15652                 cp_list = posixes;
15653             }
15654         }
15655         else {
15656             /* Under /d, we put into a separate list the Latin1 things that
15657              * match only when the target string is utf8 */
15658             SV* nonascii_but_latin1_properties = NULL;
15659             _invlist_intersection(posixes, PL_UpperLatin1,
15660                                   &nonascii_but_latin1_properties);
15661             _invlist_subtract(posixes, nonascii_but_latin1_properties,
15662                               &posixes);
15663             if (cp_list) {
15664                 _invlist_union(cp_list, posixes, &cp_list);
15665                 SvREFCNT_dec_NN(posixes);
15666             }
15667             else {
15668                 cp_list = posixes;
15669             }
15670
15671             if (depends_list) {
15672                 _invlist_union(depends_list, nonascii_but_latin1_properties,
15673                                &depends_list);
15674                 SvREFCNT_dec_NN(nonascii_but_latin1_properties);
15675             }
15676             else {
15677                 depends_list = nonascii_but_latin1_properties;
15678             }
15679         }
15680     }
15681
15682     /* And combine the result (if any) with any inversion list from properties.
15683      * The lists are kept separate up to now so that we can distinguish the two
15684      * in regards to matching above-Unicode.  A run-time warning is generated
15685      * if a Unicode property is matched against a non-Unicode code point. But,
15686      * we allow user-defined properties to match anything, without any warning,
15687      * and we also suppress the warning if there is a portion of the character
15688      * class that isn't a Unicode property, and which matches above Unicode, \W
15689      * or [\x{110000}] for example.
15690      * (Note that in this case, unlike the Posix one above, there is no
15691      * <depends_list>, because having a Unicode property forces Unicode
15692      * semantics */
15693     if (properties) {
15694         if (cp_list) {
15695
15696             /* If it matters to the final outcome, see if a non-property
15697              * component of the class matches above Unicode.  If so, the
15698              * warning gets suppressed.  This is true even if just a single
15699              * such code point is specified, as though not strictly correct if
15700              * another such code point is matched against, the fact that they
15701              * are using above-Unicode code points indicates they should know
15702              * the issues involved */
15703             if (warn_super) {
15704                 warn_super = ! (invert
15705                                ^ (invlist_highest(cp_list) > PERL_UNICODE_MAX));
15706             }
15707
15708             _invlist_union(properties, cp_list, &cp_list);
15709             SvREFCNT_dec_NN(properties);
15710         }
15711         else {
15712             cp_list = properties;
15713         }
15714
15715         if (warn_super) {
15716             ANYOF_FLAGS(ret) |= ANYOF_WARN_SUPER;
15717         }
15718     }
15719
15720     /* Here, we have calculated what code points should be in the character
15721      * class.
15722      *
15723      * Now we can see about various optimizations.  Fold calculation (which we
15724      * did above) needs to take place before inversion.  Otherwise /[^k]/i
15725      * would invert to include K, which under /i would match k, which it
15726      * shouldn't.  Therefore we can't invert folded locale now, as it won't be
15727      * folded until runtime */
15728
15729     /* If we didn't do folding, it's because some information isn't available
15730      * until runtime; set the run-time fold flag for these.  (We don't have to
15731      * worry about properties folding, as that is taken care of by the swash
15732      * fetching).  We know to set the flag if we have a non-NULL list for UTF-8
15733      * locales, or the class matches at least one 0-255 range code point */
15734     if (LOC && FOLD) {
15735         if (only_utf8_locale_list) {
15736             ANYOF_FLAGS(ret) |= ANYOF_LOC_FOLD;
15737         }
15738         else if (cp_list) { /* Look to see if there a 0-255 code point is in
15739                                the list */
15740             UV start, end;
15741             invlist_iterinit(cp_list);
15742             if (invlist_iternext(cp_list, &start, &end) && start < 256) {
15743                 ANYOF_FLAGS(ret) |= ANYOF_LOC_FOLD;
15744             }
15745             invlist_iterfinish(cp_list);
15746         }
15747     }
15748
15749     /* Optimize inverted simple patterns (e.g. [^a-z]) when everything is known
15750      * at compile time.  Besides not inverting folded locale now, we can't
15751      * invert if there are things such as \w, which aren't known until runtime
15752      * */
15753     if (cp_list
15754         && invert
15755         && ! (ANYOF_FLAGS(ret) & (ANYOF_LOCALE_FLAGS))
15756         && ! depends_list
15757         && ! HAS_NONLOCALE_RUNTIME_PROPERTY_DEFINITION)
15758     {
15759         _invlist_invert(cp_list);
15760
15761         /* Any swash can't be used as-is, because we've inverted things */
15762         if (swash) {
15763             SvREFCNT_dec_NN(swash);
15764             swash = NULL;
15765         }
15766
15767         /* Clear the invert flag since have just done it here */
15768         invert = FALSE;
15769     }
15770
15771     if (ret_invlist) {
15772         assert(cp_list);
15773
15774         *ret_invlist = cp_list;
15775         SvREFCNT_dec(swash);
15776
15777         /* Discard the generated node */
15778         if (SIZE_ONLY) {
15779             RExC_size = orig_size;
15780         }
15781         else {
15782             RExC_emit = orig_emit;
15783         }
15784         return orig_emit;
15785     }
15786
15787     /* Some character classes are equivalent to other nodes.  Such nodes take
15788      * up less room and generally fewer operations to execute than ANYOF nodes.
15789      * Above, we checked for and optimized into some such equivalents for
15790      * certain common classes that are easy to test.  Getting to this point in
15791      * the code means that the class didn't get optimized there.  Since this
15792      * code is only executed in Pass 2, it is too late to save space--it has
15793      * been allocated in Pass 1, and currently isn't given back.  But turning
15794      * things into an EXACTish node can allow the optimizer to join it to any
15795      * adjacent such nodes.  And if the class is equivalent to things like /./,
15796      * expensive run-time swashes can be avoided.  Now that we have more
15797      * complete information, we can find things necessarily missed by the
15798      * earlier code.  I (khw) am not sure how much to look for here.  It would
15799      * be easy, but perhaps too slow, to check any candidates against all the
15800      * node types they could possibly match using _invlistEQ(). */
15801
15802     if (cp_list
15803         && ! invert
15804         && ! depends_list
15805         && ! (ANYOF_FLAGS(ret) & (ANYOF_LOCALE_FLAGS))
15806         && ! HAS_NONLOCALE_RUNTIME_PROPERTY_DEFINITION
15807
15808            /* We don't optimize if we are supposed to make sure all non-Unicode
15809             * code points raise a warning, as only ANYOF nodes have this check.
15810             * */
15811         && ! ((ANYOF_FLAGS(ret) & ANYOF_WARN_SUPER) && ALWAYS_WARN_SUPER))
15812     {
15813         UV start, end;
15814         U8 op = END;  /* The optimzation node-type */
15815         const char * cur_parse= RExC_parse;
15816
15817         invlist_iterinit(cp_list);
15818         if (! invlist_iternext(cp_list, &start, &end)) {
15819
15820             /* Here, the list is empty.  This happens, for example, when a
15821              * Unicode property is the only thing in the character class, and
15822              * it doesn't match anything.  (perluniprops.pod notes such
15823              * properties) */
15824             op = OPFAIL;
15825             *flagp |= HASWIDTH|SIMPLE;
15826         }
15827         else if (start == end) {    /* The range is a single code point */
15828             if (! invlist_iternext(cp_list, &start, &end)
15829
15830                     /* Don't do this optimization if it would require changing
15831                      * the pattern to UTF-8 */
15832                 && (start < 256 || UTF))
15833             {
15834                 /* Here, the list contains a single code point.  Can optimize
15835                  * into an EXACTish node */
15836
15837                 value = start;
15838
15839                 if (! FOLD) {
15840                     op = (LOC)
15841                          ? EXACTL
15842                          : EXACT;
15843                 }
15844                 else if (LOC) {
15845
15846                     /* A locale node under folding with one code point can be
15847                      * an EXACTFL, as its fold won't be calculated until
15848                      * runtime */
15849                     op = EXACTFL;
15850                 }
15851                 else {
15852
15853                     /* Here, we are generally folding, but there is only one
15854                      * code point to match.  If we have to, we use an EXACT
15855                      * node, but it would be better for joining with adjacent
15856                      * nodes in the optimization pass if we used the same
15857                      * EXACTFish node that any such are likely to be.  We can
15858                      * do this iff the code point doesn't participate in any
15859                      * folds.  For example, an EXACTF of a colon is the same as
15860                      * an EXACT one, since nothing folds to or from a colon. */
15861                     if (value < 256) {
15862                         if (IS_IN_SOME_FOLD_L1(value)) {
15863                             op = EXACT;
15864                         }
15865                     }
15866                     else {
15867                         if (_invlist_contains_cp(PL_utf8_foldable, value)) {
15868                             op = EXACT;
15869                         }
15870                     }
15871
15872                     /* If we haven't found the node type, above, it means we
15873                      * can use the prevailing one */
15874                     if (op == END) {
15875                         op = compute_EXACTish(pRExC_state);
15876                     }
15877                 }
15878             }
15879         }
15880         else if (start == 0) {
15881             if (end == UV_MAX) {
15882                 op = SANY;
15883                 *flagp |= HASWIDTH|SIMPLE;
15884                 MARK_NAUGHTY(1);
15885             }
15886             else if (end == '\n' - 1
15887                     && invlist_iternext(cp_list, &start, &end)
15888                     && start == '\n' + 1 && end == UV_MAX)
15889             {
15890                 op = REG_ANY;
15891                 *flagp |= HASWIDTH|SIMPLE;
15892                 MARK_NAUGHTY(1);
15893             }
15894         }
15895         invlist_iterfinish(cp_list);
15896
15897         if (op != END) {
15898             RExC_parse = (char *)orig_parse;
15899             RExC_emit = (regnode *)orig_emit;
15900
15901             ret = reg_node(pRExC_state, op);
15902
15903             RExC_parse = (char *)cur_parse;
15904
15905             if (PL_regkind[op] == EXACT) {
15906                 alloc_maybe_populate_EXACT(pRExC_state, ret, flagp, 0, value,
15907                                            TRUE /* downgradable to EXACT */
15908                                           );
15909             }
15910
15911             SvREFCNT_dec_NN(cp_list);
15912             return ret;
15913         }
15914     }
15915
15916     /* Here, <cp_list> contains all the code points we can determine at
15917      * compile time that match under all conditions.  Go through it, and
15918      * for things that belong in the bitmap, put them there, and delete from
15919      * <cp_list>.  While we are at it, see if everything above 255 is in the
15920      * list, and if so, set a flag to speed up execution */
15921
15922     populate_ANYOF_from_invlist(ret, &cp_list);
15923
15924     if (invert) {
15925         ANYOF_FLAGS(ret) |= ANYOF_INVERT;
15926     }
15927
15928     /* Here, the bitmap has been populated with all the Latin1 code points that
15929      * always match.  Can now add to the overall list those that match only
15930      * when the target string is UTF-8 (<depends_list>). */
15931     if (depends_list) {
15932         if (cp_list) {
15933             _invlist_union(cp_list, depends_list, &cp_list);
15934             SvREFCNT_dec_NN(depends_list);
15935         }
15936         else {
15937             cp_list = depends_list;
15938         }
15939         ANYOF_FLAGS(ret) |= ANYOF_HAS_UTF8_NONBITMAP_MATCHES;
15940     }
15941
15942     /* If there is a swash and more than one element, we can't use the swash in
15943      * the optimization below. */
15944     if (swash && element_count > 1) {
15945         SvREFCNT_dec_NN(swash);
15946         swash = NULL;
15947     }
15948
15949     /* Note that the optimization of using 'swash' if it is the only thing in
15950      * the class doesn't have us change swash at all, so it can include things
15951      * that are also in the bitmap; otherwise we have purposely deleted that
15952      * duplicate information */
15953     set_ANYOF_arg(pRExC_state, ret, cp_list,
15954                   (HAS_NONLOCALE_RUNTIME_PROPERTY_DEFINITION)
15955                    ? listsv : NULL,
15956                   only_utf8_locale_list,
15957                   swash, has_user_defined_property);
15958
15959     *flagp |= HASWIDTH|SIMPLE;
15960
15961     if (ANYOF_FLAGS(ret) & ANYOF_LOCALE_FLAGS) {
15962         RExC_contains_locale = 1;
15963     }
15964
15965     return ret;
15966 }
15967
15968 #undef HAS_NONLOCALE_RUNTIME_PROPERTY_DEFINITION
15969
15970 STATIC void
15971 S_set_ANYOF_arg(pTHX_ RExC_state_t* const pRExC_state,
15972                 regnode* const node,
15973                 SV* const cp_list,
15974                 SV* const runtime_defns,
15975                 SV* const only_utf8_locale_list,
15976                 SV* const swash,
15977                 const bool has_user_defined_property)
15978 {
15979     /* Sets the arg field of an ANYOF-type node 'node', using information about
15980      * the node passed-in.  If there is nothing outside the node's bitmap, the
15981      * arg is set to ANYOF_ONLY_HAS_BITMAP.  Otherwise, it sets the argument to
15982      * the count returned by add_data(), having allocated and stored an array,
15983      * av, that that count references, as follows:
15984      *  av[0] stores the character class description in its textual form.
15985      *        This is used later (regexec.c:Perl_regclass_swash()) to
15986      *        initialize the appropriate swash, and is also useful for dumping
15987      *        the regnode.  This is set to &PL_sv_undef if the textual
15988      *        description is not needed at run-time (as happens if the other
15989      *        elements completely define the class)
15990      *  av[1] if &PL_sv_undef, is a placeholder to later contain the swash
15991      *        computed from av[0].  But if no further computation need be done,
15992      *        the swash is stored here now (and av[0] is &PL_sv_undef).
15993      *  av[2] stores the inversion list of code points that match only if the
15994      *        current locale is UTF-8
15995      *  av[3] stores the cp_list inversion list for use in addition or instead
15996      *        of av[0]; used only if cp_list exists and av[1] is &PL_sv_undef.
15997      *        (Otherwise everything needed is already in av[0] and av[1])
15998      *  av[4] is set if any component of the class is from a user-defined
15999      *        property; used only if av[3] exists */
16000
16001     UV n;
16002
16003     PERL_ARGS_ASSERT_SET_ANYOF_ARG;
16004
16005     if (! cp_list && ! runtime_defns && ! only_utf8_locale_list) {
16006         assert(! (ANYOF_FLAGS(node)
16007                   & (ANYOF_HAS_UTF8_NONBITMAP_MATCHES
16008                      |ANYOF_HAS_NONBITMAP_NON_UTF8_MATCHES)));
16009         ARG_SET(node, ANYOF_ONLY_HAS_BITMAP);
16010     }
16011     else {
16012         AV * const av = newAV();
16013         SV *rv;
16014
16015         assert(ANYOF_FLAGS(node)
16016                & (ANYOF_HAS_UTF8_NONBITMAP_MATCHES
16017                   |ANYOF_HAS_NONBITMAP_NON_UTF8_MATCHES|ANYOF_LOC_FOLD));
16018
16019         av_store(av, 0, (runtime_defns)
16020                         ? SvREFCNT_inc(runtime_defns) : &PL_sv_undef);
16021         if (swash) {
16022             assert(cp_list);
16023             av_store(av, 1, swash);
16024             SvREFCNT_dec_NN(cp_list);
16025         }
16026         else {
16027             av_store(av, 1, &PL_sv_undef);
16028             if (cp_list) {
16029                 av_store(av, 3, cp_list);
16030                 av_store(av, 4, newSVuv(has_user_defined_property));
16031             }
16032         }
16033
16034         if (only_utf8_locale_list) {
16035             av_store(av, 2, only_utf8_locale_list);
16036         }
16037         else {
16038             av_store(av, 2, &PL_sv_undef);
16039         }
16040
16041         rv = newRV_noinc(MUTABLE_SV(av));
16042         n = add_data(pRExC_state, STR_WITH_LEN("s"));
16043         RExC_rxi->data->data[n] = (void*)rv;
16044         ARG_SET(node, n);
16045     }
16046 }
16047
16048 #if !defined(PERL_IN_XSUB_RE) || defined(PLUGGABLE_RE_EXTENSION)
16049 SV *
16050 Perl__get_regclass_nonbitmap_data(pTHX_ const regexp *prog,
16051                                         const regnode* node,
16052                                         bool doinit,
16053                                         SV** listsvp,
16054                                         SV** only_utf8_locale_ptr,
16055                                         SV*  exclude_list)
16056
16057 {
16058     /* For internal core use only.
16059      * Returns the swash for the input 'node' in the regex 'prog'.
16060      * If <doinit> is 'true', will attempt to create the swash if not already
16061      *    done.
16062      * If <listsvp> is non-null, will return the printable contents of the
16063      *    swash.  This can be used to get debugging information even before the
16064      *    swash exists, by calling this function with 'doinit' set to false, in
16065      *    which case the components that will be used to eventually create the
16066      *    swash are returned  (in a printable form).
16067      * If <exclude_list> is not NULL, it is an inversion list of things to
16068      *    exclude from what's returned in <listsvp>.
16069      * Tied intimately to how S_set_ANYOF_arg sets up the data structure.  Note
16070      * that, in spite of this function's name, the swash it returns may include
16071      * the bitmap data as well */
16072
16073     SV *sw  = NULL;
16074     SV *si  = NULL;         /* Input swash initialization string */
16075     SV*  invlist = NULL;
16076
16077     RXi_GET_DECL(prog,progi);
16078     const struct reg_data * const data = prog ? progi->data : NULL;
16079
16080     PERL_ARGS_ASSERT__GET_REGCLASS_NONBITMAP_DATA;
16081
16082     assert(ANYOF_FLAGS(node)
16083         & (ANYOF_HAS_UTF8_NONBITMAP_MATCHES
16084            |ANYOF_HAS_NONBITMAP_NON_UTF8_MATCHES|ANYOF_LOC_FOLD));
16085
16086     if (data && data->count) {
16087         const U32 n = ARG(node);
16088
16089         if (data->what[n] == 's') {
16090             SV * const rv = MUTABLE_SV(data->data[n]);
16091             AV * const av = MUTABLE_AV(SvRV(rv));
16092             SV **const ary = AvARRAY(av);
16093             U8 swash_init_flags = _CORE_SWASH_INIT_ACCEPT_INVLIST;
16094
16095             si = *ary;  /* ary[0] = the string to initialize the swash with */
16096
16097             /* Elements 3 and 4 are either both present or both absent. [3] is
16098              * any inversion list generated at compile time; [4] indicates if
16099              * that inversion list has any user-defined properties in it. */
16100             if (av_tindex(av) >= 2) {
16101                 if (only_utf8_locale_ptr
16102                     && ary[2]
16103                     && ary[2] != &PL_sv_undef)
16104                 {
16105                     *only_utf8_locale_ptr = ary[2];
16106                 }
16107                 else {
16108                     assert(only_utf8_locale_ptr);
16109                     *only_utf8_locale_ptr = NULL;
16110                 }
16111
16112                 if (av_tindex(av) >= 3) {
16113                     invlist = ary[3];
16114                     if (SvUV(ary[4])) {
16115                         swash_init_flags |= _CORE_SWASH_INIT_USER_DEFINED_PROPERTY;
16116                     }
16117                 }
16118                 else {
16119                     invlist = NULL;
16120                 }
16121             }
16122
16123             /* Element [1] is reserved for the set-up swash.  If already there,
16124              * return it; if not, create it and store it there */
16125             if (ary[1] && SvROK(ary[1])) {
16126                 sw = ary[1];
16127             }
16128             else if (doinit && ((si && si != &PL_sv_undef)
16129                                  || (invlist && invlist != &PL_sv_undef))) {
16130                 assert(si);
16131                 sw = _core_swash_init("utf8", /* the utf8 package */
16132                                       "", /* nameless */
16133                                       si,
16134                                       1, /* binary */
16135                                       0, /* not from tr/// */
16136                                       invlist,
16137                                       &swash_init_flags);
16138                 (void)av_store(av, 1, sw);
16139             }
16140         }
16141     }
16142
16143     /* If requested, return a printable version of what this swash matches */
16144     if (listsvp) {
16145         SV* matches_string = newSVpvs("");
16146
16147         /* The swash should be used, if possible, to get the data, as it
16148          * contains the resolved data.  But this function can be called at
16149          * compile-time, before everything gets resolved, in which case we
16150          * return the currently best available information, which is the string
16151          * that will eventually be used to do that resolving, 'si' */
16152         if ((! sw || (invlist = _get_swash_invlist(sw)) == NULL)
16153             && (si && si != &PL_sv_undef))
16154         {
16155             sv_catsv(matches_string, si);
16156         }
16157
16158         /* Add the inversion list to whatever we have.  This may have come from
16159          * the swash, or from an input parameter */
16160         if (invlist) {
16161             if (exclude_list) {
16162                 SV* clone = invlist_clone(invlist);
16163                 _invlist_subtract(clone, exclude_list, &clone);
16164                 sv_catsv(matches_string, _invlist_contents(clone));
16165                 SvREFCNT_dec_NN(clone);
16166             }
16167             else {
16168                 sv_catsv(matches_string, _invlist_contents(invlist));
16169             }
16170         }
16171         *listsvp = matches_string;
16172     }
16173
16174     return sw;
16175 }
16176 #endif /* !defined(PERL_IN_XSUB_RE) || defined(PLUGGABLE_RE_EXTENSION) */
16177
16178 /* reg_skipcomment()
16179
16180    Absorbs an /x style # comment from the input stream,
16181    returning a pointer to the first character beyond the comment, or if the
16182    comment terminates the pattern without anything following it, this returns
16183    one past the final character of the pattern (in other words, RExC_end) and
16184    sets the REG_RUN_ON_COMMENT_SEEN flag.
16185
16186    Note it's the callers responsibility to ensure that we are
16187    actually in /x mode
16188
16189 */
16190
16191 PERL_STATIC_INLINE char*
16192 S_reg_skipcomment(RExC_state_t *pRExC_state, char* p)
16193 {
16194     PERL_ARGS_ASSERT_REG_SKIPCOMMENT;
16195
16196     assert(*p == '#');
16197
16198     while (p < RExC_end) {
16199         if (*(++p) == '\n') {
16200             return p+1;
16201         }
16202     }
16203
16204     /* we ran off the end of the pattern without ending the comment, so we have
16205      * to add an \n when wrapping */
16206     RExC_seen |= REG_RUN_ON_COMMENT_SEEN;
16207     return p;
16208 }
16209
16210 /* nextchar()
16211
16212    Advances the parse position, and optionally absorbs
16213    "whitespace" from the inputstream.
16214
16215    Without /x "whitespace" means (?#...) style comments only,
16216    with /x this means (?#...) and # comments and whitespace proper.
16217
16218    Returns the RExC_parse point from BEFORE the scan occurs.
16219
16220    This is the /x friendly way of saying RExC_parse++.
16221 */
16222
16223 STATIC char*
16224 S_nextchar(pTHX_ RExC_state_t *pRExC_state)
16225 {
16226     char* const retval = RExC_parse++;
16227
16228     PERL_ARGS_ASSERT_NEXTCHAR;
16229
16230     for (;;) {
16231         if (RExC_end - RExC_parse >= 3
16232             && *RExC_parse == '('
16233             && RExC_parse[1] == '?'
16234             && RExC_parse[2] == '#')
16235         {
16236             while (*RExC_parse != ')') {
16237                 if (RExC_parse == RExC_end)
16238                     FAIL("Sequence (?#... not terminated");
16239                 RExC_parse++;
16240             }
16241             RExC_parse++;
16242             continue;
16243         }
16244         if (RExC_flags & RXf_PMf_EXTENDED) {
16245             char * p = regpatws(pRExC_state, RExC_parse,
16246                                           TRUE); /* means recognize comments */
16247             if (p != RExC_parse) {
16248                 RExC_parse = p;
16249                 continue;
16250             }
16251         }
16252         return retval;
16253     }
16254 }
16255
16256 STATIC regnode *
16257 S_regnode_guts(pTHX_ RExC_state_t *pRExC_state, const U8 op, const STRLEN extra_size, const char* const name)
16258 {
16259     /* Allocate a regnode for 'op' and returns it, with 'extra_size' extra
16260      * space.  In pass1, it aligns and increments RExC_size; in pass2,
16261      * RExC_emit */
16262
16263     regnode * const ret = RExC_emit;
16264     GET_RE_DEBUG_FLAGS_DECL;
16265
16266     PERL_ARGS_ASSERT_REGNODE_GUTS;
16267
16268     assert(extra_size >= regarglen[op]);
16269
16270     if (SIZE_ONLY) {
16271         SIZE_ALIGN(RExC_size);
16272         RExC_size += 1 + extra_size;
16273         return(ret);
16274     }
16275     if (RExC_emit >= RExC_emit_bound)
16276         Perl_croak(aTHX_ "panic: reg_node overrun trying to emit %d, %p>=%p",
16277                    op, (void*)RExC_emit, (void*)RExC_emit_bound);
16278
16279     NODE_ALIGN_FILL(ret);
16280 #ifndef RE_TRACK_PATTERN_OFFSETS
16281     PERL_UNUSED_ARG(name);
16282 #else
16283     if (RExC_offsets) {         /* MJD */
16284         MJD_OFFSET_DEBUG(
16285               ("%s:%d: (op %s) %s %"UVuf" (len %"UVuf") (max %"UVuf").\n",
16286               name, __LINE__,
16287               PL_reg_name[op],
16288               (UV)(RExC_emit - RExC_emit_start) > RExC_offsets[0]
16289                 ? "Overwriting end of array!\n" : "OK",
16290               (UV)(RExC_emit - RExC_emit_start),
16291               (UV)(RExC_parse - RExC_start),
16292               (UV)RExC_offsets[0]));
16293         Set_Node_Offset(RExC_emit, RExC_parse + (op == END));
16294     }
16295 #endif
16296     return(ret);
16297 }
16298
16299 /*
16300 - reg_node - emit a node
16301 */
16302 STATIC regnode *                        /* Location. */
16303 S_reg_node(pTHX_ RExC_state_t *pRExC_state, U8 op)
16304 {
16305     regnode * const ret = regnode_guts(pRExC_state, op, regarglen[op], "reg_node");
16306
16307     PERL_ARGS_ASSERT_REG_NODE;
16308
16309     assert(regarglen[op] == 0);
16310
16311     if (PASS2) {
16312         regnode *ptr = ret;
16313         FILL_ADVANCE_NODE(ptr, op);
16314         RExC_emit = ptr;
16315     }
16316     return(ret);
16317 }
16318
16319 /*
16320 - reganode - emit a node with an argument
16321 */
16322 STATIC regnode *                        /* Location. */
16323 S_reganode(pTHX_ RExC_state_t *pRExC_state, U8 op, U32 arg)
16324 {
16325     regnode * const ret = regnode_guts(pRExC_state, op, regarglen[op], "reganode");
16326
16327     PERL_ARGS_ASSERT_REGANODE;
16328
16329     assert(regarglen[op] == 1);
16330
16331     if (PASS2) {
16332         regnode *ptr = ret;
16333         FILL_ADVANCE_NODE_ARG(ptr, op, arg);
16334         RExC_emit = ptr;
16335     }
16336     return(ret);
16337 }
16338
16339 STATIC regnode *
16340 S_reg2Lanode(pTHX_ RExC_state_t *pRExC_state, const U8 op, const U32 arg1, const I32 arg2)
16341 {
16342     /* emit a node with U32 and I32 arguments */
16343
16344     regnode * const ret = regnode_guts(pRExC_state, op, regarglen[op], "reg2Lanode");
16345
16346     PERL_ARGS_ASSERT_REG2LANODE;
16347
16348     assert(regarglen[op] == 2);
16349
16350     if (PASS2) {
16351         regnode *ptr = ret;
16352         FILL_ADVANCE_NODE_2L_ARG(ptr, op, arg1, arg2);
16353         RExC_emit = ptr;
16354     }
16355     return(ret);
16356 }
16357
16358 /*
16359 - reginsert - insert an operator in front of already-emitted operand
16360 *
16361 * Means relocating the operand.
16362 */
16363 STATIC void
16364 S_reginsert(pTHX_ RExC_state_t *pRExC_state, U8 op, regnode *opnd, U32 depth)
16365 {
16366     regnode *src;
16367     regnode *dst;
16368     regnode *place;
16369     const int offset = regarglen[(U8)op];
16370     const int size = NODE_STEP_REGNODE + offset;
16371     GET_RE_DEBUG_FLAGS_DECL;
16372
16373     PERL_ARGS_ASSERT_REGINSERT;
16374     PERL_UNUSED_CONTEXT;
16375     PERL_UNUSED_ARG(depth);
16376 /* (PL_regkind[(U8)op] == CURLY ? EXTRA_STEP_2ARGS : 0); */
16377     DEBUG_PARSE_FMT("inst"," - %s",PL_reg_name[op]);
16378     if (SIZE_ONLY) {
16379         RExC_size += size;
16380         return;
16381     }
16382
16383     src = RExC_emit;
16384     RExC_emit += size;
16385     dst = RExC_emit;
16386     if (RExC_open_parens) {
16387         int paren;
16388         /*DEBUG_PARSE_FMT("inst"," - %"IVdf, (IV)RExC_npar);*/
16389         for ( paren=0 ; paren < RExC_npar ; paren++ ) {
16390             if ( RExC_open_parens[paren] >= opnd ) {
16391                 /*DEBUG_PARSE_FMT("open"," - %d",size);*/
16392                 RExC_open_parens[paren] += size;
16393             } else {
16394                 /*DEBUG_PARSE_FMT("open"," - %s","ok");*/
16395             }
16396             if ( RExC_close_parens[paren] >= opnd ) {
16397                 /*DEBUG_PARSE_FMT("close"," - %d",size);*/
16398                 RExC_close_parens[paren] += size;
16399             } else {
16400                 /*DEBUG_PARSE_FMT("close"," - %s","ok");*/
16401             }
16402         }
16403     }
16404
16405     while (src > opnd) {
16406         StructCopy(--src, --dst, regnode);
16407 #ifdef RE_TRACK_PATTERN_OFFSETS
16408         if (RExC_offsets) {     /* MJD 20010112 */
16409             MJD_OFFSET_DEBUG(
16410                  ("%s(%d): (op %s) %s copy %"UVuf" -> %"UVuf" (max %"UVuf").\n",
16411                   "reg_insert",
16412                   __LINE__,
16413                   PL_reg_name[op],
16414                   (UV)(dst - RExC_emit_start) > RExC_offsets[0]
16415                     ? "Overwriting end of array!\n" : "OK",
16416                   (UV)(src - RExC_emit_start),
16417                   (UV)(dst - RExC_emit_start),
16418                   (UV)RExC_offsets[0]));
16419             Set_Node_Offset_To_R(dst-RExC_emit_start, Node_Offset(src));
16420             Set_Node_Length_To_R(dst-RExC_emit_start, Node_Length(src));
16421         }
16422 #endif
16423     }
16424
16425
16426     place = opnd;               /* Op node, where operand used to be. */
16427 #ifdef RE_TRACK_PATTERN_OFFSETS
16428     if (RExC_offsets) {         /* MJD */
16429         MJD_OFFSET_DEBUG(
16430               ("%s(%d): (op %s) %s %"UVuf" <- %"UVuf" (max %"UVuf").\n",
16431               "reginsert",
16432               __LINE__,
16433               PL_reg_name[op],
16434               (UV)(place - RExC_emit_start) > RExC_offsets[0]
16435               ? "Overwriting end of array!\n" : "OK",
16436               (UV)(place - RExC_emit_start),
16437               (UV)(RExC_parse - RExC_start),
16438               (UV)RExC_offsets[0]));
16439         Set_Node_Offset(place, RExC_parse);
16440         Set_Node_Length(place, 1);
16441     }
16442 #endif
16443     src = NEXTOPER(place);
16444     FILL_ADVANCE_NODE(place, op);
16445     Zero(src, offset, regnode);
16446 }
16447
16448 /*
16449 - regtail - set the next-pointer at the end of a node chain of p to val.
16450 - SEE ALSO: regtail_study
16451 */
16452 /* TODO: All three parms should be const */
16453 STATIC void
16454 S_regtail(pTHX_ RExC_state_t *pRExC_state, regnode *p,
16455                 const regnode *val,U32 depth)
16456 {
16457     regnode *scan;
16458     GET_RE_DEBUG_FLAGS_DECL;
16459
16460     PERL_ARGS_ASSERT_REGTAIL;
16461 #ifndef DEBUGGING
16462     PERL_UNUSED_ARG(depth);
16463 #endif
16464
16465     if (SIZE_ONLY)
16466         return;
16467
16468     /* Find last node. */
16469     scan = p;
16470     for (;;) {
16471         regnode * const temp = regnext(scan);
16472         DEBUG_PARSE_r({
16473             DEBUG_PARSE_MSG((scan==p ? "tail" : ""));
16474             regprop(RExC_rx, RExC_mysv, scan, NULL, pRExC_state);
16475             PerlIO_printf(Perl_debug_log, "~ %s (%d) %s %s\n",
16476                 SvPV_nolen_const(RExC_mysv), REG_NODE_NUM(scan),
16477                     (temp == NULL ? "->" : ""),
16478                     (temp == NULL ? PL_reg_name[OP(val)] : "")
16479             );
16480         });
16481         if (temp == NULL)
16482             break;
16483         scan = temp;
16484     }
16485
16486     if (reg_off_by_arg[OP(scan)]) {
16487         ARG_SET(scan, val - scan);
16488     }
16489     else {
16490         NEXT_OFF(scan) = val - scan;
16491     }
16492 }
16493
16494 #ifdef DEBUGGING
16495 /*
16496 - regtail_study - set the next-pointer at the end of a node chain of p to val.
16497 - Look for optimizable sequences at the same time.
16498 - currently only looks for EXACT chains.
16499
16500 This is experimental code. The idea is to use this routine to perform
16501 in place optimizations on branches and groups as they are constructed,
16502 with the long term intention of removing optimization from study_chunk so
16503 that it is purely analytical.
16504
16505 Currently only used when in DEBUG mode. The macro REGTAIL_STUDY() is used
16506 to control which is which.
16507
16508 */
16509 /* TODO: All four parms should be const */
16510
16511 STATIC U8
16512 S_regtail_study(pTHX_ RExC_state_t *pRExC_state, regnode *p,
16513                       const regnode *val,U32 depth)
16514 {
16515     regnode *scan;
16516     U8 exact = PSEUDO;
16517 #ifdef EXPERIMENTAL_INPLACESCAN
16518     I32 min = 0;
16519 #endif
16520     GET_RE_DEBUG_FLAGS_DECL;
16521
16522     PERL_ARGS_ASSERT_REGTAIL_STUDY;
16523
16524
16525     if (SIZE_ONLY)
16526         return exact;
16527
16528     /* Find last node. */
16529
16530     scan = p;
16531     for (;;) {
16532         regnode * const temp = regnext(scan);
16533 #ifdef EXPERIMENTAL_INPLACESCAN
16534         if (PL_regkind[OP(scan)] == EXACT) {
16535             bool unfolded_multi_char;   /* Unexamined in this routine */
16536             if (join_exact(pRExC_state, scan, &min,
16537                            &unfolded_multi_char, 1, val, depth+1))
16538                 return EXACT;
16539         }
16540 #endif
16541         if ( exact ) {
16542             switch (OP(scan)) {
16543                 case EXACT:
16544                 case EXACTL:
16545                 case EXACTF:
16546                 case EXACTFA_NO_TRIE:
16547                 case EXACTFA:
16548                 case EXACTFU:
16549                 case EXACTFLU8:
16550                 case EXACTFU_SS:
16551                 case EXACTFL:
16552                         if( exact == PSEUDO )
16553                             exact= OP(scan);
16554                         else if ( exact != OP(scan) )
16555                             exact= 0;
16556                 case NOTHING:
16557                     break;
16558                 default:
16559                     exact= 0;
16560             }
16561         }
16562         DEBUG_PARSE_r({
16563             DEBUG_PARSE_MSG((scan==p ? "tsdy" : ""));
16564             regprop(RExC_rx, RExC_mysv, scan, NULL, pRExC_state);
16565             PerlIO_printf(Perl_debug_log, "~ %s (%d) -> %s\n",
16566                 SvPV_nolen_const(RExC_mysv),
16567                 REG_NODE_NUM(scan),
16568                 PL_reg_name[exact]);
16569         });
16570         if (temp == NULL)
16571             break;
16572         scan = temp;
16573     }
16574     DEBUG_PARSE_r({
16575         DEBUG_PARSE_MSG("");
16576         regprop(RExC_rx, RExC_mysv, val, NULL, pRExC_state);
16577         PerlIO_printf(Perl_debug_log,
16578                       "~ attach to %s (%"IVdf") offset to %"IVdf"\n",
16579                       SvPV_nolen_const(RExC_mysv),
16580                       (IV)REG_NODE_NUM(val),
16581                       (IV)(val - scan)
16582         );
16583     });
16584     if (reg_off_by_arg[OP(scan)]) {
16585         ARG_SET(scan, val - scan);
16586     }
16587     else {
16588         NEXT_OFF(scan) = val - scan;
16589     }
16590
16591     return exact;
16592 }
16593 #endif
16594
16595 /*
16596  - regdump - dump a regexp onto Perl_debug_log in vaguely comprehensible form
16597  */
16598 #ifdef DEBUGGING
16599
16600 static void
16601 S_regdump_intflags(pTHX_ const char *lead, const U32 flags)
16602 {
16603     int bit;
16604     int set=0;
16605
16606     ASSUME(REG_INTFLAGS_NAME_SIZE <= sizeof(flags)*8);
16607
16608     for (bit=0; bit<REG_INTFLAGS_NAME_SIZE; bit++) {
16609         if (flags & (1<<bit)) {
16610             if (!set++ && lead)
16611                 PerlIO_printf(Perl_debug_log, "%s",lead);
16612             PerlIO_printf(Perl_debug_log, "%s ",PL_reg_intflags_name[bit]);
16613         }
16614     }
16615     if (lead)  {
16616         if (set)
16617             PerlIO_printf(Perl_debug_log, "\n");
16618         else
16619             PerlIO_printf(Perl_debug_log, "%s[none-set]\n",lead);
16620     }
16621 }
16622
16623 static void
16624 S_regdump_extflags(pTHX_ const char *lead, const U32 flags)
16625 {
16626     int bit;
16627     int set=0;
16628     regex_charset cs;
16629
16630     ASSUME(REG_EXTFLAGS_NAME_SIZE <= sizeof(flags)*8);
16631
16632     for (bit=0; bit<REG_EXTFLAGS_NAME_SIZE; bit++) {
16633         if (flags & (1<<bit)) {
16634             if ((1<<bit) & RXf_PMf_CHARSET) {   /* Output separately, below */
16635                 continue;
16636             }
16637             if (!set++ && lead)
16638                 PerlIO_printf(Perl_debug_log, "%s",lead);
16639             PerlIO_printf(Perl_debug_log, "%s ",PL_reg_extflags_name[bit]);
16640         }
16641     }
16642     if ((cs = get_regex_charset(flags)) != REGEX_DEPENDS_CHARSET) {
16643             if (!set++ && lead) {
16644                 PerlIO_printf(Perl_debug_log, "%s",lead);
16645             }
16646             switch (cs) {
16647                 case REGEX_UNICODE_CHARSET:
16648                     PerlIO_printf(Perl_debug_log, "UNICODE");
16649                     break;
16650                 case REGEX_LOCALE_CHARSET:
16651                     PerlIO_printf(Perl_debug_log, "LOCALE");
16652                     break;
16653                 case REGEX_ASCII_RESTRICTED_CHARSET:
16654                     PerlIO_printf(Perl_debug_log, "ASCII-RESTRICTED");
16655                     break;
16656                 case REGEX_ASCII_MORE_RESTRICTED_CHARSET:
16657                     PerlIO_printf(Perl_debug_log, "ASCII-MORE_RESTRICTED");
16658                     break;
16659                 default:
16660                     PerlIO_printf(Perl_debug_log, "UNKNOWN CHARACTER SET");
16661                     break;
16662             }
16663     }
16664     if (lead)  {
16665         if (set)
16666             PerlIO_printf(Perl_debug_log, "\n");
16667         else
16668             PerlIO_printf(Perl_debug_log, "%s[none-set]\n",lead);
16669     }
16670 }
16671 #endif
16672
16673 void
16674 Perl_regdump(pTHX_ const regexp *r)
16675 {
16676 #ifdef DEBUGGING
16677     SV * const sv = sv_newmortal();
16678     SV *dsv= sv_newmortal();
16679     RXi_GET_DECL(r,ri);
16680     GET_RE_DEBUG_FLAGS_DECL;
16681
16682     PERL_ARGS_ASSERT_REGDUMP;
16683
16684     (void)dumpuntil(r, ri->program, ri->program + 1, NULL, NULL, sv, 0, 0);
16685
16686     /* Header fields of interest. */
16687     if (r->anchored_substr) {
16688         RE_PV_QUOTED_DECL(s, 0, dsv, SvPVX_const(r->anchored_substr),
16689             RE_SV_DUMPLEN(r->anchored_substr), 30);
16690         PerlIO_printf(Perl_debug_log,
16691                       "anchored %s%s at %"IVdf" ",
16692                       s, RE_SV_TAIL(r->anchored_substr),
16693                       (IV)r->anchored_offset);
16694     } else if (r->anchored_utf8) {
16695         RE_PV_QUOTED_DECL(s, 1, dsv, SvPVX_const(r->anchored_utf8),
16696             RE_SV_DUMPLEN(r->anchored_utf8), 30);
16697         PerlIO_printf(Perl_debug_log,
16698                       "anchored utf8 %s%s at %"IVdf" ",
16699                       s, RE_SV_TAIL(r->anchored_utf8),
16700                       (IV)r->anchored_offset);
16701     }
16702     if (r->float_substr) {
16703         RE_PV_QUOTED_DECL(s, 0, dsv, SvPVX_const(r->float_substr),
16704             RE_SV_DUMPLEN(r->float_substr), 30);
16705         PerlIO_printf(Perl_debug_log,
16706                       "floating %s%s at %"IVdf"..%"UVuf" ",
16707                       s, RE_SV_TAIL(r->float_substr),
16708                       (IV)r->float_min_offset, (UV)r->float_max_offset);
16709     } else if (r->float_utf8) {
16710         RE_PV_QUOTED_DECL(s, 1, dsv, SvPVX_const(r->float_utf8),
16711             RE_SV_DUMPLEN(r->float_utf8), 30);
16712         PerlIO_printf(Perl_debug_log,
16713                       "floating utf8 %s%s at %"IVdf"..%"UVuf" ",
16714                       s, RE_SV_TAIL(r->float_utf8),
16715                       (IV)r->float_min_offset, (UV)r->float_max_offset);
16716     }
16717     if (r->check_substr || r->check_utf8)
16718         PerlIO_printf(Perl_debug_log,
16719                       (const char *)
16720                       (r->check_substr == r->float_substr
16721                        && r->check_utf8 == r->float_utf8
16722                        ? "(checking floating" : "(checking anchored"));
16723     if (r->intflags & PREGf_NOSCAN)
16724         PerlIO_printf(Perl_debug_log, " noscan");
16725     if (r->extflags & RXf_CHECK_ALL)
16726         PerlIO_printf(Perl_debug_log, " isall");
16727     if (r->check_substr || r->check_utf8)
16728         PerlIO_printf(Perl_debug_log, ") ");
16729
16730     if (ri->regstclass) {
16731         regprop(r, sv, ri->regstclass, NULL, NULL);
16732         PerlIO_printf(Perl_debug_log, "stclass %s ", SvPVX_const(sv));
16733     }
16734     if (r->intflags & PREGf_ANCH) {
16735         PerlIO_printf(Perl_debug_log, "anchored");
16736         if (r->intflags & PREGf_ANCH_MBOL)
16737             PerlIO_printf(Perl_debug_log, "(MBOL)");
16738         if (r->intflags & PREGf_ANCH_SBOL)
16739             PerlIO_printf(Perl_debug_log, "(SBOL)");
16740         if (r->intflags & PREGf_ANCH_GPOS)
16741             PerlIO_printf(Perl_debug_log, "(GPOS)");
16742         PerlIO_putc(Perl_debug_log, ' ');
16743     }
16744     if (r->intflags & PREGf_GPOS_SEEN)
16745         PerlIO_printf(Perl_debug_log, "GPOS:%"UVuf" ", (UV)r->gofs);
16746     if (r->intflags & PREGf_SKIP)
16747         PerlIO_printf(Perl_debug_log, "plus ");
16748     if (r->intflags & PREGf_IMPLICIT)
16749         PerlIO_printf(Perl_debug_log, "implicit ");
16750     PerlIO_printf(Perl_debug_log, "minlen %"IVdf" ", (IV)r->minlen);
16751     if (r->extflags & RXf_EVAL_SEEN)
16752         PerlIO_printf(Perl_debug_log, "with eval ");
16753     PerlIO_printf(Perl_debug_log, "\n");
16754     DEBUG_FLAGS_r({
16755         regdump_extflags("r->extflags: ",r->extflags);
16756         regdump_intflags("r->intflags: ",r->intflags);
16757     });
16758 #else
16759     PERL_ARGS_ASSERT_REGDUMP;
16760     PERL_UNUSED_CONTEXT;
16761     PERL_UNUSED_ARG(r);
16762 #endif  /* DEBUGGING */
16763 }
16764
16765 /*
16766 - regprop - printable representation of opcode, with run time support
16767 */
16768
16769 void
16770 Perl_regprop(pTHX_ const regexp *prog, SV *sv, const regnode *o, const regmatch_info *reginfo, const RExC_state_t *pRExC_state)
16771 {
16772 #ifdef DEBUGGING
16773     int k;
16774
16775     /* Should be synchronized with * ANYOF_ #xdefines in regcomp.h */
16776     static const char * const anyofs[] = {
16777 #if _CC_WORDCHAR != 0 || _CC_DIGIT != 1 || _CC_ALPHA != 2 || _CC_LOWER != 3 \
16778     || _CC_UPPER != 4 || _CC_PUNCT != 5 || _CC_PRINT != 6                   \
16779     || _CC_ALPHANUMERIC != 7 || _CC_GRAPH != 8 || _CC_CASED != 9            \
16780     || _CC_SPACE != 10 || _CC_BLANK != 11 || _CC_XDIGIT != 12               \
16781     || _CC_CNTRL != 13 || _CC_ASCII != 14 || _CC_VERTSPACE != 15
16782   #error Need to adjust order of anyofs[]
16783 #endif
16784         "\\w",
16785         "\\W",
16786         "\\d",
16787         "\\D",
16788         "[:alpha:]",
16789         "[:^alpha:]",
16790         "[:lower:]",
16791         "[:^lower:]",
16792         "[:upper:]",
16793         "[:^upper:]",
16794         "[:punct:]",
16795         "[:^punct:]",
16796         "[:print:]",
16797         "[:^print:]",
16798         "[:alnum:]",
16799         "[:^alnum:]",
16800         "[:graph:]",
16801         "[:^graph:]",
16802         "[:cased:]",
16803         "[:^cased:]",
16804         "\\s",
16805         "\\S",
16806         "[:blank:]",
16807         "[:^blank:]",
16808         "[:xdigit:]",
16809         "[:^xdigit:]",
16810         "[:cntrl:]",
16811         "[:^cntrl:]",
16812         "[:ascii:]",
16813         "[:^ascii:]",
16814         "\\v",
16815         "\\V"
16816     };
16817     RXi_GET_DECL(prog,progi);
16818     GET_RE_DEBUG_FLAGS_DECL;
16819
16820     PERL_ARGS_ASSERT_REGPROP;
16821
16822     sv_setpvn(sv, "", 0);
16823
16824     if (OP(o) > REGNODE_MAX)            /* regnode.type is unsigned */
16825         /* It would be nice to FAIL() here, but this may be called from
16826            regexec.c, and it would be hard to supply pRExC_state. */
16827         Perl_croak(aTHX_ "Corrupted regexp opcode %d > %d",
16828                                               (int)OP(o), (int)REGNODE_MAX);
16829     sv_catpv(sv, PL_reg_name[OP(o)]); /* Take off const! */
16830
16831     k = PL_regkind[OP(o)];
16832
16833     if (k == EXACT) {
16834         sv_catpvs(sv, " ");
16835         /* Using is_utf8_string() (via PERL_PV_UNI_DETECT)
16836          * is a crude hack but it may be the best for now since
16837          * we have no flag "this EXACTish node was UTF-8"
16838          * --jhi */
16839         pv_pretty(sv, STRING(o), STR_LEN(o), 60, PL_colors[0], PL_colors[1],
16840                   PERL_PV_ESCAPE_UNI_DETECT |
16841                   PERL_PV_ESCAPE_NONASCII   |
16842                   PERL_PV_PRETTY_ELLIPSES   |
16843                   PERL_PV_PRETTY_LTGT       |
16844                   PERL_PV_PRETTY_NOCLEAR
16845                   );
16846     } else if (k == TRIE) {
16847         /* print the details of the trie in dumpuntil instead, as
16848          * progi->data isn't available here */
16849         const char op = OP(o);
16850         const U32 n = ARG(o);
16851         const reg_ac_data * const ac = IS_TRIE_AC(op) ?
16852                (reg_ac_data *)progi->data->data[n] :
16853                NULL;
16854         const reg_trie_data * const trie
16855             = (reg_trie_data*)progi->data->data[!IS_TRIE_AC(op) ? n : ac->trie];
16856
16857         Perl_sv_catpvf(aTHX_ sv, "-%s",PL_reg_name[o->flags]);
16858         DEBUG_TRIE_COMPILE_r(
16859           Perl_sv_catpvf(aTHX_ sv,
16860             "<S:%"UVuf"/%"IVdf" W:%"UVuf" L:%"UVuf"/%"UVuf" C:%"UVuf"/%"UVuf">",
16861             (UV)trie->startstate,
16862             (IV)trie->statecount-1, /* -1 because of the unused 0 element */
16863             (UV)trie->wordcount,
16864             (UV)trie->minlen,
16865             (UV)trie->maxlen,
16866             (UV)TRIE_CHARCOUNT(trie),
16867             (UV)trie->uniquecharcount
16868           );
16869         );
16870         if ( IS_ANYOF_TRIE(op) || trie->bitmap ) {
16871             sv_catpvs(sv, "[");
16872             (void) put_charclass_bitmap_innards(sv,
16873                                                 (IS_ANYOF_TRIE(op))
16874                                                  ? ANYOF_BITMAP(o)
16875                                                  : TRIE_BITMAP(trie),
16876                                                 NULL);
16877             sv_catpvs(sv, "]");
16878         }
16879
16880     } else if (k == CURLY) {
16881         if (OP(o) == CURLYM || OP(o) == CURLYN || OP(o) == CURLYX)
16882             Perl_sv_catpvf(aTHX_ sv, "[%d]", o->flags); /* Parenth number */
16883         Perl_sv_catpvf(aTHX_ sv, " {%d,%d}", ARG1(o), ARG2(o));
16884     }
16885     else if (k == WHILEM && o->flags)                   /* Ordinal/of */
16886         Perl_sv_catpvf(aTHX_ sv, "[%d/%d]", o->flags & 0xf, o->flags>>4);
16887     else if (k == REF || k == OPEN || k == CLOSE
16888              || k == GROUPP || OP(o)==ACCEPT)
16889     {
16890         AV *name_list= NULL;
16891         Perl_sv_catpvf(aTHX_ sv, "%d", (int)ARG(o));    /* Parenth number */
16892         if ( RXp_PAREN_NAMES(prog) ) {
16893             name_list= MUTABLE_AV(progi->data->data[progi->name_list_idx]);
16894         } else if ( pRExC_state ) {
16895             name_list= RExC_paren_name_list;
16896         }
16897         if (name_list) {
16898             if ( k != REF || (OP(o) < NREF)) {
16899                 SV **name= av_fetch(name_list, ARG(o), 0 );
16900                 if (name)
16901                     Perl_sv_catpvf(aTHX_ sv, " '%"SVf"'", SVfARG(*name));
16902             }
16903             else {
16904                 SV *sv_dat= MUTABLE_SV(progi->data->data[ ARG( o ) ]);
16905                 I32 *nums=(I32*)SvPVX(sv_dat);
16906                 SV **name= av_fetch(name_list, nums[0], 0 );
16907                 I32 n;
16908                 if (name) {
16909                     for ( n=0; n<SvIVX(sv_dat); n++ ) {
16910                         Perl_sv_catpvf(aTHX_ sv, "%s%"IVdf,
16911                                     (n ? "," : ""), (IV)nums[n]);
16912                     }
16913                     Perl_sv_catpvf(aTHX_ sv, " '%"SVf"'", SVfARG(*name));
16914                 }
16915             }
16916         }
16917         if ( k == REF && reginfo) {
16918             U32 n = ARG(o);  /* which paren pair */
16919             I32 ln = prog->offs[n].start;
16920             if (prog->lastparen < n || ln == -1)
16921                 Perl_sv_catpvf(aTHX_ sv, ": FAIL");
16922             else if (ln == prog->offs[n].end)
16923                 Perl_sv_catpvf(aTHX_ sv, ": ACCEPT - EMPTY STRING");
16924             else {
16925                 const char *s = reginfo->strbeg + ln;
16926                 Perl_sv_catpvf(aTHX_ sv, ": ");
16927                 Perl_pv_pretty( aTHX_ sv, s, prog->offs[n].end - prog->offs[n].start, 32, 0, 0,
16928                     PERL_PV_ESCAPE_UNI_DETECT|PERL_PV_PRETTY_NOCLEAR|PERL_PV_PRETTY_ELLIPSES|PERL_PV_PRETTY_QUOTE );
16929             }
16930         }
16931     } else if (k == GOSUB) {
16932         AV *name_list= NULL;
16933         if ( RXp_PAREN_NAMES(prog) ) {
16934             name_list= MUTABLE_AV(progi->data->data[progi->name_list_idx]);
16935         } else if ( pRExC_state ) {
16936             name_list= RExC_paren_name_list;
16937         }
16938
16939         /* Paren and offset */
16940         Perl_sv_catpvf(aTHX_ sv, "%d[%+d]", (int)ARG(o),(int)ARG2L(o));
16941         if (name_list) {
16942             SV **name= av_fetch(name_list, ARG(o), 0 );
16943             if (name)
16944                 Perl_sv_catpvf(aTHX_ sv, " '%"SVf"'", SVfARG(*name));
16945         }
16946     }
16947     else if (k == VERB) {
16948         if (!o->flags)
16949             Perl_sv_catpvf(aTHX_ sv, ":%"SVf,
16950                            SVfARG((MUTABLE_SV(progi->data->data[ ARG( o ) ]))));
16951     } else if (k == LOGICAL)
16952         /* 2: embedded, otherwise 1 */
16953         Perl_sv_catpvf(aTHX_ sv, "[%d]", o->flags);
16954     else if (k == ANYOF) {
16955         const U8 flags = ANYOF_FLAGS(o);
16956         int do_sep = 0;
16957         SV* bitmap_invlist;  /* Will hold what the bit map contains */
16958
16959
16960         if (OP(o) == ANYOFL)
16961             sv_catpvs(sv, "{loc}");
16962         if (flags & ANYOF_LOC_FOLD)
16963             sv_catpvs(sv, "{i}");
16964         Perl_sv_catpvf(aTHX_ sv, "[%s", PL_colors[0]);
16965         if (flags & ANYOF_INVERT)
16966             sv_catpvs(sv, "^");
16967
16968         /* output what the standard cp 0-NUM_ANYOF_CODE_POINTS-1 bitmap matches
16969          * */
16970         do_sep = put_charclass_bitmap_innards(sv, ANYOF_BITMAP(o),
16971                                                             &bitmap_invlist);
16972
16973         /* output any special charclass tests (used entirely under use
16974          * locale) * */
16975         if (ANYOF_POSIXL_TEST_ANY_SET(o)) {
16976             int i;
16977             for (i = 0; i < ANYOF_POSIXL_MAX; i++) {
16978                 if (ANYOF_POSIXL_TEST(o,i)) {
16979                     sv_catpv(sv, anyofs[i]);
16980                     do_sep = 1;
16981                 }
16982             }
16983         }
16984
16985         if ((flags & (ANYOF_MATCHES_ALL_ABOVE_BITMAP
16986                       |ANYOF_HAS_UTF8_NONBITMAP_MATCHES
16987                       |ANYOF_HAS_NONBITMAP_NON_UTF8_MATCHES
16988                       |ANYOF_LOC_FOLD)))
16989         {
16990             if (do_sep) {
16991                 Perl_sv_catpvf(aTHX_ sv,"%s][%s",PL_colors[1],PL_colors[0]);
16992                 if (flags & ANYOF_INVERT)
16993                     /*make sure the invert info is in each */
16994                     sv_catpvs(sv, "^");
16995             }
16996
16997             if (flags & ANYOF_MATCHES_ALL_NON_UTF8_NON_ASCII) {
16998                 sv_catpvs(sv, "{non-utf8-latin1-all}");
16999             }
17000
17001             if (flags & ANYOF_MATCHES_ALL_ABOVE_BITMAP)
17002                 sv_catpvs(sv, "{above_bitmap_all}");
17003
17004             if (ARG(o) != ANYOF_ONLY_HAS_BITMAP) {
17005                 SV *lv; /* Set if there is something outside the bit map. */
17006                 bool byte_output = FALSE;   /* If something has been output */
17007                 SV *only_utf8_locale;
17008
17009                 /* Get the stuff that wasn't in the bitmap.  'bitmap_invlist'
17010                  * is used to guarantee that nothing in the bitmap gets
17011                  * returned */
17012                 (void) _get_regclass_nonbitmap_data(prog, o, FALSE,
17013                                                     &lv, &only_utf8_locale,
17014                                                     bitmap_invlist);
17015                 if (lv && lv != &PL_sv_undef) {
17016                     char *s = savesvpv(lv);
17017                     char * const origs = s;
17018
17019                     while (*s && *s != '\n')
17020                         s++;
17021
17022                     if (*s == '\n') {
17023                         const char * const t = ++s;
17024
17025                         if (flags & ANYOF_HAS_NONBITMAP_NON_UTF8_MATCHES) {
17026                             sv_catpvs(sv, "{outside bitmap}");
17027                         }
17028                         else {
17029                             sv_catpvs(sv, "{utf8}");
17030                         }
17031
17032                         if (byte_output) {
17033                             sv_catpvs(sv, " ");
17034                         }
17035
17036                         while (*s) {
17037                             if (*s == '\n') {
17038
17039                                 /* Truncate very long output */
17040                                 if (s - origs > 256) {
17041                                     Perl_sv_catpvf(aTHX_ sv,
17042                                                 "%.*s...",
17043                                                 (int) (s - origs - 1),
17044                                                 t);
17045                                     goto out_dump;
17046                                 }
17047                                 *s = ' ';
17048                             }
17049                             else if (*s == '\t') {
17050                                 *s = '-';
17051                             }
17052                             s++;
17053                         }
17054                         if (s[-1] == ' ')
17055                             s[-1] = 0;
17056
17057                         sv_catpv(sv, t);
17058                     }
17059
17060                   out_dump:
17061
17062                     Safefree(origs);
17063                     SvREFCNT_dec_NN(lv);
17064                 }
17065
17066                 if ((flags & ANYOF_LOC_FOLD)
17067                      && only_utf8_locale
17068                      && only_utf8_locale != &PL_sv_undef)
17069                 {
17070                     UV start, end;
17071                     int max_entries = 256;
17072
17073                     sv_catpvs(sv, "{utf8 locale}");
17074                     invlist_iterinit(only_utf8_locale);
17075                     while (invlist_iternext(only_utf8_locale,
17076                                             &start, &end)) {
17077                         put_range(sv, start, end, FALSE);
17078                         max_entries --;
17079                         if (max_entries < 0) {
17080                             sv_catpvs(sv, "...");
17081                             break;
17082                         }
17083                     }
17084                     invlist_iterfinish(only_utf8_locale);
17085                 }
17086             }
17087         }
17088         SvREFCNT_dec(bitmap_invlist);
17089
17090
17091         Perl_sv_catpvf(aTHX_ sv, "%s]", PL_colors[1]);
17092     }
17093     else if (k == POSIXD || k == NPOSIXD) {
17094         U8 index = FLAGS(o) * 2;
17095         if (index < C_ARRAY_LENGTH(anyofs)) {
17096             if (*anyofs[index] != '[')  {
17097                 sv_catpv(sv, "[");
17098             }
17099             sv_catpv(sv, anyofs[index]);
17100             if (*anyofs[index] != '[')  {
17101                 sv_catpv(sv, "]");
17102             }
17103         }
17104         else {
17105             Perl_sv_catpvf(aTHX_ sv, "[illegal type=%d])", index);
17106         }
17107     }
17108     else if (k == BOUND || k == NBOUND) {
17109         /* Must be synced with order of 'bound_type' in regcomp.h */
17110         const char * const bounds[] = {
17111             "",      /* Traditional */
17112             "{gcb}",
17113             "{sb}",
17114             "{wb}"
17115         };
17116         sv_catpv(sv, bounds[FLAGS(o)]);
17117     }
17118     else if (k == BRANCHJ && (OP(o) == UNLESSM || OP(o) == IFMATCH))
17119         Perl_sv_catpvf(aTHX_ sv, "[%d]", -(o->flags));
17120     else if (OP(o) == SBOL)
17121         Perl_sv_catpvf(aTHX_ sv, " /%s/", o->flags ? "\\A" : "^");
17122 #else
17123     PERL_UNUSED_CONTEXT;
17124     PERL_UNUSED_ARG(sv);
17125     PERL_UNUSED_ARG(o);
17126     PERL_UNUSED_ARG(prog);
17127     PERL_UNUSED_ARG(reginfo);
17128     PERL_UNUSED_ARG(pRExC_state);
17129 #endif  /* DEBUGGING */
17130 }
17131
17132
17133
17134 SV *
17135 Perl_re_intuit_string(pTHX_ REGEXP * const r)
17136 {                               /* Assume that RE_INTUIT is set */
17137     struct regexp *const prog = ReANY(r);
17138     GET_RE_DEBUG_FLAGS_DECL;
17139
17140     PERL_ARGS_ASSERT_RE_INTUIT_STRING;
17141     PERL_UNUSED_CONTEXT;
17142
17143     DEBUG_COMPILE_r(
17144         {
17145             const char * const s = SvPV_nolen_const(RX_UTF8(r)
17146                       ? prog->check_utf8 : prog->check_substr);
17147
17148             if (!PL_colorset) reginitcolors();
17149             PerlIO_printf(Perl_debug_log,
17150                       "%sUsing REx %ssubstr:%s \"%s%.60s%s%s\"\n",
17151                       PL_colors[4],
17152                       RX_UTF8(r) ? "utf8 " : "",
17153                       PL_colors[5],PL_colors[0],
17154                       s,
17155                       PL_colors[1],
17156                       (strlen(s) > 60 ? "..." : ""));
17157         } );
17158
17159     /* use UTF8 check substring if regexp pattern itself is in UTF8 */
17160     return RX_UTF8(r) ? prog->check_utf8 : prog->check_substr;
17161 }
17162
17163 /*
17164    pregfree()
17165
17166    handles refcounting and freeing the perl core regexp structure. When
17167    it is necessary to actually free the structure the first thing it
17168    does is call the 'free' method of the regexp_engine associated to
17169    the regexp, allowing the handling of the void *pprivate; member
17170    first. (This routine is not overridable by extensions, which is why
17171    the extensions free is called first.)
17172
17173    See regdupe and regdupe_internal if you change anything here.
17174 */
17175 #ifndef PERL_IN_XSUB_RE
17176 void
17177 Perl_pregfree(pTHX_ REGEXP *r)
17178 {
17179     SvREFCNT_dec(r);
17180 }
17181
17182 void
17183 Perl_pregfree2(pTHX_ REGEXP *rx)
17184 {
17185     struct regexp *const r = ReANY(rx);
17186     GET_RE_DEBUG_FLAGS_DECL;
17187
17188     PERL_ARGS_ASSERT_PREGFREE2;
17189
17190     if (r->mother_re) {
17191         ReREFCNT_dec(r->mother_re);
17192     } else {
17193         CALLREGFREE_PVT(rx); /* free the private data */
17194         SvREFCNT_dec(RXp_PAREN_NAMES(r));
17195         Safefree(r->xpv_len_u.xpvlenu_pv);
17196     }
17197     if (r->substrs) {
17198         SvREFCNT_dec(r->anchored_substr);
17199         SvREFCNT_dec(r->anchored_utf8);
17200         SvREFCNT_dec(r->float_substr);
17201         SvREFCNT_dec(r->float_utf8);
17202         Safefree(r->substrs);
17203     }
17204     RX_MATCH_COPY_FREE(rx);
17205 #ifdef PERL_ANY_COW
17206     SvREFCNT_dec(r->saved_copy);
17207 #endif
17208     Safefree(r->offs);
17209     SvREFCNT_dec(r->qr_anoncv);
17210     rx->sv_u.svu_rx = 0;
17211 }
17212
17213 /*  reg_temp_copy()
17214
17215     This is a hacky workaround to the structural issue of match results
17216     being stored in the regexp structure which is in turn stored in
17217     PL_curpm/PL_reg_curpm. The problem is that due to qr// the pattern
17218     could be PL_curpm in multiple contexts, and could require multiple
17219     result sets being associated with the pattern simultaneously, such
17220     as when doing a recursive match with (??{$qr})
17221
17222     The solution is to make a lightweight copy of the regexp structure
17223     when a qr// is returned from the code executed by (??{$qr}) this
17224     lightweight copy doesn't actually own any of its data except for
17225     the starp/end and the actual regexp structure itself.
17226
17227 */
17228
17229
17230 REGEXP *
17231 Perl_reg_temp_copy (pTHX_ REGEXP *ret_x, REGEXP *rx)
17232 {
17233     struct regexp *ret;
17234     struct regexp *const r = ReANY(rx);
17235     const bool islv = ret_x && SvTYPE(ret_x) == SVt_PVLV;
17236
17237     PERL_ARGS_ASSERT_REG_TEMP_COPY;
17238
17239     if (!ret_x)
17240         ret_x = (REGEXP*) newSV_type(SVt_REGEXP);
17241     else {
17242         SvOK_off((SV *)ret_x);
17243         if (islv) {
17244             /* For PVLVs, SvANY points to the xpvlv body while sv_u points
17245                to the regexp.  (For SVt_REGEXPs, sv_upgrade has already
17246                made both spots point to the same regexp body.) */
17247             REGEXP *temp = (REGEXP *)newSV_type(SVt_REGEXP);
17248             assert(!SvPVX(ret_x));
17249             ret_x->sv_u.svu_rx = temp->sv_any;
17250             temp->sv_any = NULL;
17251             SvFLAGS(temp) = (SvFLAGS(temp) & ~SVTYPEMASK) | SVt_NULL;
17252             SvREFCNT_dec_NN(temp);
17253             /* SvCUR still resides in the xpvlv struct, so the regexp copy-
17254                ing below will not set it. */
17255             SvCUR_set(ret_x, SvCUR(rx));
17256         }
17257     }
17258     /* This ensures that SvTHINKFIRST(sv) is true, and hence that
17259        sv_force_normal(sv) is called.  */
17260     SvFAKE_on(ret_x);
17261     ret = ReANY(ret_x);
17262
17263     SvFLAGS(ret_x) |= SvUTF8(rx);
17264     /* We share the same string buffer as the original regexp, on which we
17265        hold a reference count, incremented when mother_re is set below.
17266        The string pointer is copied here, being part of the regexp struct.
17267      */
17268     memcpy(&(ret->xpv_cur), &(r->xpv_cur),
17269            sizeof(regexp) - STRUCT_OFFSET(regexp, xpv_cur));
17270     if (r->offs) {
17271         const I32 npar = r->nparens+1;
17272         Newx(ret->offs, npar, regexp_paren_pair);
17273         Copy(r->offs, ret->offs, npar, regexp_paren_pair);
17274     }
17275     if (r->substrs) {
17276         Newx(ret->substrs, 1, struct reg_substr_data);
17277         StructCopy(r->substrs, ret->substrs, struct reg_substr_data);
17278
17279         SvREFCNT_inc_void(ret->anchored_substr);
17280         SvREFCNT_inc_void(ret->anchored_utf8);
17281         SvREFCNT_inc_void(ret->float_substr);
17282         SvREFCNT_inc_void(ret->float_utf8);
17283
17284         /* check_substr and check_utf8, if non-NULL, point to either their
17285            anchored or float namesakes, and don't hold a second reference.  */
17286     }
17287     RX_MATCH_COPIED_off(ret_x);
17288 #ifdef PERL_ANY_COW
17289     ret->saved_copy = NULL;
17290 #endif
17291     ret->mother_re = ReREFCNT_inc(r->mother_re ? r->mother_re : rx);
17292     SvREFCNT_inc_void(ret->qr_anoncv);
17293
17294     return ret_x;
17295 }
17296 #endif
17297
17298 /* regfree_internal()
17299
17300    Free the private data in a regexp. This is overloadable by
17301    extensions. Perl takes care of the regexp structure in pregfree(),
17302    this covers the *pprivate pointer which technically perl doesn't
17303    know about, however of course we have to handle the
17304    regexp_internal structure when no extension is in use.
17305
17306    Note this is called before freeing anything in the regexp
17307    structure.
17308  */
17309
17310 void
17311 Perl_regfree_internal(pTHX_ REGEXP * const rx)
17312 {
17313     struct regexp *const r = ReANY(rx);
17314     RXi_GET_DECL(r,ri);
17315     GET_RE_DEBUG_FLAGS_DECL;
17316
17317     PERL_ARGS_ASSERT_REGFREE_INTERNAL;
17318
17319     DEBUG_COMPILE_r({
17320         if (!PL_colorset)
17321             reginitcolors();
17322         {
17323             SV *dsv= sv_newmortal();
17324             RE_PV_QUOTED_DECL(s, RX_UTF8(rx),
17325                 dsv, RX_PRECOMP(rx), RX_PRELEN(rx), 60);
17326             PerlIO_printf(Perl_debug_log,"%sFreeing REx:%s %s\n",
17327                 PL_colors[4],PL_colors[5],s);
17328         }
17329     });
17330 #ifdef RE_TRACK_PATTERN_OFFSETS
17331     if (ri->u.offsets)
17332         Safefree(ri->u.offsets);             /* 20010421 MJD */
17333 #endif
17334     if (ri->code_blocks) {
17335         int n;
17336         for (n = 0; n < ri->num_code_blocks; n++)
17337             SvREFCNT_dec(ri->code_blocks[n].src_regex);
17338         Safefree(ri->code_blocks);
17339     }
17340
17341     if (ri->data) {
17342         int n = ri->data->count;
17343
17344         while (--n >= 0) {
17345           /* If you add a ->what type here, update the comment in regcomp.h */
17346             switch (ri->data->what[n]) {
17347             case 'a':
17348             case 'r':
17349             case 's':
17350             case 'S':
17351             case 'u':
17352                 SvREFCNT_dec(MUTABLE_SV(ri->data->data[n]));
17353                 break;
17354             case 'f':
17355                 Safefree(ri->data->data[n]);
17356                 break;
17357             case 'l':
17358             case 'L':
17359                 break;
17360             case 'T':
17361                 { /* Aho Corasick add-on structure for a trie node.
17362                      Used in stclass optimization only */
17363                     U32 refcount;
17364                     reg_ac_data *aho=(reg_ac_data*)ri->data->data[n];
17365 #ifdef USE_ITHREADS
17366                     dVAR;
17367 #endif
17368                     OP_REFCNT_LOCK;
17369                     refcount = --aho->refcount;
17370                     OP_REFCNT_UNLOCK;
17371                     if ( !refcount ) {
17372                         PerlMemShared_free(aho->states);
17373                         PerlMemShared_free(aho->fail);
17374                          /* do this last!!!! */
17375                         PerlMemShared_free(ri->data->data[n]);
17376                         /* we should only ever get called once, so
17377                          * assert as much, and also guard the free
17378                          * which /might/ happen twice. At the least
17379                          * it will make code anlyzers happy and it
17380                          * doesn't cost much. - Yves */
17381                         assert(ri->regstclass);
17382                         if (ri->regstclass) {
17383                             PerlMemShared_free(ri->regstclass);
17384                             ri->regstclass = 0;
17385                         }
17386                     }
17387                 }
17388                 break;
17389             case 't':
17390                 {
17391                     /* trie structure. */
17392                     U32 refcount;
17393                     reg_trie_data *trie=(reg_trie_data*)ri->data->data[n];
17394 #ifdef USE_ITHREADS
17395                     dVAR;
17396 #endif
17397                     OP_REFCNT_LOCK;
17398                     refcount = --trie->refcount;
17399                     OP_REFCNT_UNLOCK;
17400                     if ( !refcount ) {
17401                         PerlMemShared_free(trie->charmap);
17402                         PerlMemShared_free(trie->states);
17403                         PerlMemShared_free(trie->trans);
17404                         if (trie->bitmap)
17405                             PerlMemShared_free(trie->bitmap);
17406                         if (trie->jump)
17407                             PerlMemShared_free(trie->jump);
17408                         PerlMemShared_free(trie->wordinfo);
17409                         /* do this last!!!! */
17410                         PerlMemShared_free(ri->data->data[n]);
17411                     }
17412                 }
17413                 break;
17414             default:
17415                 Perl_croak(aTHX_ "panic: regfree data code '%c'",
17416                                                     ri->data->what[n]);
17417             }
17418         }
17419         Safefree(ri->data->what);
17420         Safefree(ri->data);
17421     }
17422
17423     Safefree(ri);
17424 }
17425
17426 #define av_dup_inc(s,t) MUTABLE_AV(sv_dup_inc((const SV *)s,t))
17427 #define hv_dup_inc(s,t) MUTABLE_HV(sv_dup_inc((const SV *)s,t))
17428 #define SAVEPVN(p,n)    ((p) ? savepvn(p,n) : NULL)
17429
17430 /*
17431    re_dup - duplicate a regexp.
17432
17433    This routine is expected to clone a given regexp structure. It is only
17434    compiled under USE_ITHREADS.
17435
17436    After all of the core data stored in struct regexp is duplicated
17437    the regexp_engine.dupe method is used to copy any private data
17438    stored in the *pprivate pointer. This allows extensions to handle
17439    any duplication it needs to do.
17440
17441    See pregfree() and regfree_internal() if you change anything here.
17442 */
17443 #if defined(USE_ITHREADS)
17444 #ifndef PERL_IN_XSUB_RE
17445 void
17446 Perl_re_dup_guts(pTHX_ const REGEXP *sstr, REGEXP *dstr, CLONE_PARAMS *param)
17447 {
17448     dVAR;
17449     I32 npar;
17450     const struct regexp *r = ReANY(sstr);
17451     struct regexp *ret = ReANY(dstr);
17452
17453     PERL_ARGS_ASSERT_RE_DUP_GUTS;
17454
17455     npar = r->nparens+1;
17456     Newx(ret->offs, npar, regexp_paren_pair);
17457     Copy(r->offs, ret->offs, npar, regexp_paren_pair);
17458
17459     if (ret->substrs) {
17460         /* Do it this way to avoid reading from *r after the StructCopy().
17461            That way, if any of the sv_dup_inc()s dislodge *r from the L1
17462            cache, it doesn't matter.  */
17463         const bool anchored = r->check_substr
17464             ? r->check_substr == r->anchored_substr
17465             : r->check_utf8 == r->anchored_utf8;
17466         Newx(ret->substrs, 1, struct reg_substr_data);
17467         StructCopy(r->substrs, ret->substrs, struct reg_substr_data);
17468
17469         ret->anchored_substr = sv_dup_inc(ret->anchored_substr, param);
17470         ret->anchored_utf8 = sv_dup_inc(ret->anchored_utf8, param);
17471         ret->float_substr = sv_dup_inc(ret->float_substr, param);
17472         ret->float_utf8 = sv_dup_inc(ret->float_utf8, param);
17473
17474         /* check_substr and check_utf8, if non-NULL, point to either their
17475            anchored or float namesakes, and don't hold a second reference.  */
17476
17477         if (ret->check_substr) {
17478             if (anchored) {
17479                 assert(r->check_utf8 == r->anchored_utf8);
17480                 ret->check_substr = ret->anchored_substr;
17481                 ret->check_utf8 = ret->anchored_utf8;
17482             } else {
17483                 assert(r->check_substr == r->float_substr);
17484                 assert(r->check_utf8 == r->float_utf8);
17485                 ret->check_substr = ret->float_substr;
17486                 ret->check_utf8 = ret->float_utf8;
17487             }
17488         } else if (ret->check_utf8) {
17489             if (anchored) {
17490                 ret->check_utf8 = ret->anchored_utf8;
17491             } else {
17492                 ret->check_utf8 = ret->float_utf8;
17493             }
17494         }
17495     }
17496
17497     RXp_PAREN_NAMES(ret) = hv_dup_inc(RXp_PAREN_NAMES(ret), param);
17498     ret->qr_anoncv = MUTABLE_CV(sv_dup_inc((const SV *)ret->qr_anoncv, param));
17499
17500     if (ret->pprivate)
17501         RXi_SET(ret,CALLREGDUPE_PVT(dstr,param));
17502
17503     if (RX_MATCH_COPIED(dstr))
17504         ret->subbeg  = SAVEPVN(ret->subbeg, ret->sublen);
17505     else
17506         ret->subbeg = NULL;
17507 #ifdef PERL_ANY_COW
17508     ret->saved_copy = NULL;
17509 #endif
17510
17511     /* Whether mother_re be set or no, we need to copy the string.  We
17512        cannot refrain from copying it when the storage points directly to
17513        our mother regexp, because that's
17514                1: a buffer in a different thread
17515                2: something we no longer hold a reference on
17516                so we need to copy it locally.  */
17517     RX_WRAPPED(dstr) = SAVEPVN(RX_WRAPPED(sstr), SvCUR(sstr)+1);
17518     ret->mother_re   = NULL;
17519 }
17520 #endif /* PERL_IN_XSUB_RE */
17521
17522 /*
17523    regdupe_internal()
17524
17525    This is the internal complement to regdupe() which is used to copy
17526    the structure pointed to by the *pprivate pointer in the regexp.
17527    This is the core version of the extension overridable cloning hook.
17528    The regexp structure being duplicated will be copied by perl prior
17529    to this and will be provided as the regexp *r argument, however
17530    with the /old/ structures pprivate pointer value. Thus this routine
17531    may override any copying normally done by perl.
17532
17533    It returns a pointer to the new regexp_internal structure.
17534 */
17535
17536 void *
17537 Perl_regdupe_internal(pTHX_ REGEXP * const rx, CLONE_PARAMS *param)
17538 {
17539     dVAR;
17540     struct regexp *const r = ReANY(rx);
17541     regexp_internal *reti;
17542     int len;
17543     RXi_GET_DECL(r,ri);
17544
17545     PERL_ARGS_ASSERT_REGDUPE_INTERNAL;
17546
17547     len = ProgLen(ri);
17548
17549     Newxc(reti, sizeof(regexp_internal) + len*sizeof(regnode),
17550           char, regexp_internal);
17551     Copy(ri->program, reti->program, len+1, regnode);
17552
17553     reti->num_code_blocks = ri->num_code_blocks;
17554     if (ri->code_blocks) {
17555         int n;
17556         Newxc(reti->code_blocks, ri->num_code_blocks, struct reg_code_block,
17557                 struct reg_code_block);
17558         Copy(ri->code_blocks, reti->code_blocks, ri->num_code_blocks,
17559                 struct reg_code_block);
17560         for (n = 0; n < ri->num_code_blocks; n++)
17561              reti->code_blocks[n].src_regex = (REGEXP*)
17562                     sv_dup_inc((SV*)(ri->code_blocks[n].src_regex), param);
17563     }
17564     else
17565         reti->code_blocks = NULL;
17566
17567     reti->regstclass = NULL;
17568
17569     if (ri->data) {
17570         struct reg_data *d;
17571         const int count = ri->data->count;
17572         int i;
17573
17574         Newxc(d, sizeof(struct reg_data) + count*sizeof(void *),
17575                 char, struct reg_data);
17576         Newx(d->what, count, U8);
17577
17578         d->count = count;
17579         for (i = 0; i < count; i++) {
17580             d->what[i] = ri->data->what[i];
17581             switch (d->what[i]) {
17582                 /* see also regcomp.h and regfree_internal() */
17583             case 'a': /* actually an AV, but the dup function is identical.  */
17584             case 'r':
17585             case 's':
17586             case 'S':
17587             case 'u': /* actually an HV, but the dup function is identical.  */
17588                 d->data[i] = sv_dup_inc((const SV *)ri->data->data[i], param);
17589                 break;
17590             case 'f':
17591                 /* This is cheating. */
17592                 Newx(d->data[i], 1, regnode_ssc);
17593                 StructCopy(ri->data->data[i], d->data[i], regnode_ssc);
17594                 reti->regstclass = (regnode*)d->data[i];
17595                 break;
17596             case 'T':
17597                 /* Trie stclasses are readonly and can thus be shared
17598                  * without duplication. We free the stclass in pregfree
17599                  * when the corresponding reg_ac_data struct is freed.
17600                  */
17601                 reti->regstclass= ri->regstclass;
17602                 /* FALLTHROUGH */
17603             case 't':
17604                 OP_REFCNT_LOCK;
17605                 ((reg_trie_data*)ri->data->data[i])->refcount++;
17606                 OP_REFCNT_UNLOCK;
17607                 /* FALLTHROUGH */
17608             case 'l':
17609             case 'L':
17610                 d->data[i] = ri->data->data[i];
17611                 break;
17612             default:
17613                 Perl_croak(aTHX_ "panic: re_dup unknown data code '%c'",
17614                                                            ri->data->what[i]);
17615             }
17616         }
17617
17618         reti->data = d;
17619     }
17620     else
17621         reti->data = NULL;
17622
17623     reti->name_list_idx = ri->name_list_idx;
17624
17625 #ifdef RE_TRACK_PATTERN_OFFSETS
17626     if (ri->u.offsets) {
17627         Newx(reti->u.offsets, 2*len+1, U32);
17628         Copy(ri->u.offsets, reti->u.offsets, 2*len+1, U32);
17629     }
17630 #else
17631     SetProgLen(reti,len);
17632 #endif
17633
17634     return (void*)reti;
17635 }
17636
17637 #endif    /* USE_ITHREADS */
17638
17639 #ifndef PERL_IN_XSUB_RE
17640
17641 /*
17642  - regnext - dig the "next" pointer out of a node
17643  */
17644 regnode *
17645 Perl_regnext(pTHX_ regnode *p)
17646 {
17647     I32 offset;
17648
17649     if (!p)
17650         return(NULL);
17651
17652     if (OP(p) > REGNODE_MAX) {          /* regnode.type is unsigned */
17653         Perl_croak(aTHX_ "Corrupted regexp opcode %d > %d",
17654                                                 (int)OP(p), (int)REGNODE_MAX);
17655     }
17656
17657     offset = (reg_off_by_arg[OP(p)] ? ARG(p) : NEXT_OFF(p));
17658     if (offset == 0)
17659         return(NULL);
17660
17661     return(p+offset);
17662 }
17663 #endif
17664
17665 STATIC void
17666 S_re_croak2(pTHX_ bool utf8, const char* pat1,const char* pat2,...)
17667 {
17668     va_list args;
17669     STRLEN l1 = strlen(pat1);
17670     STRLEN l2 = strlen(pat2);
17671     char buf[512];
17672     SV *msv;
17673     const char *message;
17674
17675     PERL_ARGS_ASSERT_RE_CROAK2;
17676
17677     if (l1 > 510)
17678         l1 = 510;
17679     if (l1 + l2 > 510)
17680         l2 = 510 - l1;
17681     Copy(pat1, buf, l1 , char);
17682     Copy(pat2, buf + l1, l2 , char);
17683     buf[l1 + l2] = '\n';
17684     buf[l1 + l2 + 1] = '\0';
17685     va_start(args, pat2);
17686     msv = vmess(buf, &args);
17687     va_end(args);
17688     message = SvPV_const(msv,l1);
17689     if (l1 > 512)
17690         l1 = 512;
17691     Copy(message, buf, l1 , char);
17692     /* l1-1 to avoid \n */
17693     Perl_croak(aTHX_ "%"UTF8f, UTF8fARG(utf8, l1-1, buf));
17694 }
17695
17696 /* XXX Here's a total kludge.  But we need to re-enter for swash routines. */
17697
17698 #ifndef PERL_IN_XSUB_RE
17699 void
17700 Perl_save_re_context(pTHX)
17701 {
17702     I32 nparens = -1;
17703     I32 i;
17704
17705     /* Save $1..$n (#18107: UTF-8 s/(\w+)/uc($1)/e); AMS 20021106. */
17706
17707     if (PL_curpm) {
17708         const REGEXP * const rx = PM_GETRE(PL_curpm);
17709         if (rx)
17710             nparens = RX_NPARENS(rx);
17711     }
17712
17713     /* RT #124109. This is a complete hack; in the SWASHNEW case we know
17714      * that PL_curpm will be null, but that utf8.pm and the modules it
17715      * loads will only use $1..$3.
17716      * The t/porting/re_context.t test file checks this assumption.
17717      */
17718     if (nparens == -1)
17719         nparens = 3;
17720
17721     for (i = 1; i <= nparens; i++) {
17722         char digits[TYPE_CHARS(long)];
17723         const STRLEN len = my_snprintf(digits, sizeof(digits),
17724                                        "%lu", (long)i);
17725         GV *const *const gvp
17726             = (GV**)hv_fetch(PL_defstash, digits, len, 0);
17727
17728         if (gvp) {
17729             GV * const gv = *gvp;
17730             if (SvTYPE(gv) == SVt_PVGV && GvSV(gv))
17731                 save_scalar(gv);
17732         }
17733     }
17734 }
17735 #endif
17736
17737 #ifdef DEBUGGING
17738
17739 STATIC void
17740 S_put_code_point(pTHX_ SV *sv, UV c)
17741 {
17742     PERL_ARGS_ASSERT_PUT_CODE_POINT;
17743
17744     if (c > 255) {
17745         Perl_sv_catpvf(aTHX_ sv, "\\x{%04"UVXf"}", c);
17746     }
17747     else if (isPRINT(c)) {
17748         const char string = (char) c;
17749         if (isBACKSLASHED_PUNCT(c))
17750             sv_catpvs(sv, "\\");
17751         sv_catpvn(sv, &string, 1);
17752     }
17753     else {
17754         const char * const mnemonic = cntrl_to_mnemonic((char) c);
17755         if (mnemonic) {
17756             Perl_sv_catpvf(aTHX_ sv, "%s", mnemonic);
17757         }
17758         else {
17759             Perl_sv_catpvf(aTHX_ sv, "\\x{%02X}", (U8) c);
17760         }
17761     }
17762 }
17763
17764 #define MAX_PRINT_A MAX_PRINT_A_FOR_USE_ONLY_BY_REGCOMP_DOT_C
17765
17766 STATIC void
17767 S_put_range(pTHX_ SV *sv, UV start, const UV end, const bool allow_literals)
17768 {
17769     /* Appends to 'sv' a displayable version of the range of code points from
17770      * 'start' to 'end'.  It assumes that only ASCII printables are displayable
17771      * as-is (though some of these will be escaped by put_code_point()). */
17772
17773     const unsigned int min_range_count = 3;
17774
17775     assert(start <= end);
17776
17777     PERL_ARGS_ASSERT_PUT_RANGE;
17778
17779     while (start <= end) {
17780         UV this_end;
17781         const char * format;
17782
17783         if (end - start < min_range_count) {
17784
17785             /* Individual chars in short ranges */
17786             for (; start <= end; start++) {
17787                 put_code_point(sv, start);
17788             }
17789             break;
17790         }
17791
17792         /* If permitted by the input options, and there is a possibility that
17793          * this range contains a printable literal, look to see if there is
17794          * one.  */
17795         if (allow_literals && start <= MAX_PRINT_A) {
17796
17797             /* If the range begin isn't an ASCII printable, effectively split
17798              * the range into two parts:
17799              *  1) the portion before the first such printable,
17800              *  2) the rest
17801              * and output them separately. */
17802             if (! isPRINT_A(start)) {
17803                 UV temp_end = start + 1;
17804
17805                 /* There is no point looking beyond the final possible
17806                  * printable, in MAX_PRINT_A */
17807                 UV max = MIN(end, MAX_PRINT_A);
17808
17809                 while (temp_end <= max && ! isPRINT_A(temp_end)) {
17810                     temp_end++;
17811                 }
17812
17813                 /* Here, temp_end points to one beyond the first printable if
17814                  * found, or to one beyond 'max' if not.  If none found, make
17815                  * sure that we use the entire range */
17816                 if (temp_end > MAX_PRINT_A) {
17817                     temp_end = end + 1;
17818                 }
17819
17820                 /* Output the first part of the split range, the part that
17821                  * doesn't have printables, with no looking for literals
17822                  * (otherwise we would infinitely recurse) */
17823                 put_range(sv, start, temp_end - 1, FALSE);
17824
17825                 /* The 2nd part of the range (if any) starts here. */
17826                 start = temp_end;
17827
17828                 /* We continue instead of dropping down because even if the 2nd
17829                  * part is non-empty, it could be so short that we want to
17830                  * output it specially, as tested for at the top of this loop.
17831                  * */
17832                 continue;
17833             }
17834
17835             /* Here, 'start' is a printable ASCII.  If it is an alphanumeric,
17836              * output a sub-range of just the digits or letters, then process
17837              * the remaining portion as usual. */
17838             if (isALPHANUMERIC_A(start)) {
17839                 UV mask = (isDIGIT_A(start))
17840                            ? _CC_DIGIT
17841                              : isUPPER_A(start)
17842                                ? _CC_UPPER
17843                                : _CC_LOWER;
17844                 UV temp_end = start + 1;
17845
17846                 /* Find the end of the sub-range that includes just the
17847                  * characters in the same class as the first character in it */
17848                 while (temp_end <= end && _generic_isCC_A(temp_end, mask)) {
17849                     temp_end++;
17850                 }
17851                 temp_end--;
17852
17853                 /* For short ranges, don't duplicate the code above to output
17854                  * them; just call recursively */
17855                 if (temp_end - start < min_range_count) {
17856                     put_range(sv, start, temp_end, FALSE);
17857                 }
17858                 else {  /* Output as a range */
17859                     put_code_point(sv, start);
17860                     sv_catpvs(sv, "-");
17861                     put_code_point(sv, temp_end);
17862                 }
17863                 start = temp_end + 1;
17864                 continue;
17865             }
17866
17867             /* We output any other printables as individual characters */
17868             if (isPUNCT_A(start) || isSPACE_A(start)) {
17869                 while (start <= end && (isPUNCT_A(start)
17870                                         || isSPACE_A(start)))
17871                 {
17872                     put_code_point(sv, start);
17873                     start++;
17874                 }
17875                 continue;
17876             }
17877         } /* End of looking for literals */
17878
17879         /* Here is not to output as a literal.  Some control characters have
17880          * mnemonic names.  Split off any of those at the beginning and end of
17881          * the range to print mnemonically.  It isn't possible for many of
17882          * these to be in a row, so this won't overwhelm with output */
17883         while (isMNEMONIC_CNTRL(start) && start <= end) {
17884             put_code_point(sv, start);
17885             start++;
17886         }
17887         if (start < end && isMNEMONIC_CNTRL(end)) {
17888
17889             /* Here, the final character in the range has a mnemonic name.
17890              * Work backwards from the end to find the final non-mnemonic */
17891             UV temp_end = end - 1;
17892             while (isMNEMONIC_CNTRL(temp_end)) {
17893                 temp_end--;
17894             }
17895
17896             /* And separately output the range that doesn't have mnemonics */
17897             put_range(sv, start, temp_end, FALSE);
17898
17899             /* Then output the mnemonic trailing controls */
17900             start = temp_end + 1;
17901             while (start <= end) {
17902                 put_code_point(sv, start);
17903                 start++;
17904             }
17905             break;
17906         }
17907
17908         /* As a final resort, output the range or subrange as hex. */
17909
17910         this_end = (end < NUM_ANYOF_CODE_POINTS)
17911                     ? end
17912                     : NUM_ANYOF_CODE_POINTS - 1;
17913         format = (this_end < 256)
17914                  ? "\\x{%02"UVXf"}-\\x{%02"UVXf"}"
17915                  : "\\x{%04"UVXf"}-\\x{%04"UVXf"}";
17916         GCC_DIAG_IGNORE(-Wformat-nonliteral);
17917         Perl_sv_catpvf(aTHX_ sv, format, start, this_end);
17918         GCC_DIAG_RESTORE;
17919         break;
17920     }
17921 }
17922
17923 STATIC bool
17924 S_put_charclass_bitmap_innards(pTHX_ SV *sv, char *bitmap, SV** bitmap_invlist)
17925 {
17926     /* Appends to 'sv' a displayable version of the innards of the bracketed
17927      * character class whose bitmap is 'bitmap';  Returns 'TRUE' if it actually
17928      * output anything, and bitmap_invlist, if not NULL, will point to an
17929      * inversion list of what is in the bit map */
17930
17931     int i;
17932     UV start, end;
17933     unsigned int punct_count = 0;
17934     SV* invlist = NULL;
17935     SV** invlist_ptr;   /* Temporary, in case bitmap_invlist is NULL */
17936     bool allow_literals = TRUE;
17937
17938     PERL_ARGS_ASSERT_PUT_CHARCLASS_BITMAP_INNARDS;
17939
17940     invlist_ptr = (bitmap_invlist) ? bitmap_invlist : &invlist;
17941
17942     /* Worst case is exactly every-other code point is in the list */
17943     *invlist_ptr = _new_invlist(NUM_ANYOF_CODE_POINTS / 2);
17944
17945     /* Convert the bit map to an inversion list, keeping track of how many
17946      * ASCII puncts are set, including an extra amount for the backslashed
17947      * ones.  */
17948     for (i = 0; i < NUM_ANYOF_CODE_POINTS; i++) {
17949         if (BITMAP_TEST(bitmap, i)) {
17950             *invlist_ptr = add_cp_to_invlist(*invlist_ptr, i);
17951             if (isPUNCT_A(i)) {
17952                 punct_count++;
17953                 if isBACKSLASHED_PUNCT(i) {
17954                     punct_count++;
17955                 }
17956             }
17957         }
17958     }
17959
17960     /* Nothing to output */
17961     if (_invlist_len(*invlist_ptr) == 0) {
17962         SvREFCNT_dec(invlist);
17963         return FALSE;
17964     }
17965
17966     /* Generally, it is more readable if printable characters are output as
17967      * literals, but if a range (nearly) spans all of them, it's best to output
17968      * it as a single range.  This code will use a single range if all but 2
17969      * printables are in it */
17970     invlist_iterinit(*invlist_ptr);
17971     while (invlist_iternext(*invlist_ptr, &start, &end)) {
17972
17973         /* If range starts beyond final printable, it doesn't have any in it */
17974         if (start > MAX_PRINT_A) {
17975             break;
17976         }
17977
17978         /* In both ASCII and EBCDIC, a SPACE is the lowest printable.  To span
17979          * all but two, the range must start and end no later than 2 from
17980          * either end */
17981         if (start < ' ' + 2 && end > MAX_PRINT_A - 2) {
17982             if (end > MAX_PRINT_A) {
17983                 end = MAX_PRINT_A;
17984             }
17985             if (start < ' ') {
17986                 start = ' ';
17987             }
17988             if (end - start >= MAX_PRINT_A - ' ' - 2) {
17989                 allow_literals = FALSE;
17990             }
17991             break;
17992         }
17993     }
17994     invlist_iterfinish(*invlist_ptr);
17995
17996     /* The legibility of the output depends mostly on how many punctuation
17997      * characters are output.  There are 32 possible ASCII ones, and some have
17998      * an additional backslash, bringing it to currently 36, so if any more
17999      * than 18 are to be output, we can instead output it as its complement,
18000      * yielding fewer puncts, and making it more legible.  But give some weight
18001      * to the fact that outputting it as a complement is less legible than a
18002      * straight output, so don't complement unless we are somewhat over the 18
18003      * mark */
18004     if (allow_literals && punct_count > 22) {
18005         sv_catpvs(sv, "^");
18006
18007         /* Add everything remaining to the list, so when we invert it just
18008          * below, it will be excluded */
18009         _invlist_union_complement_2nd(*invlist_ptr, PL_InBitmap, invlist_ptr);
18010         _invlist_invert(*invlist_ptr);
18011     }
18012
18013     /* Here we have figured things out.  Output each range */
18014     invlist_iterinit(*invlist_ptr);
18015     while (invlist_iternext(*invlist_ptr, &start, &end)) {
18016         if (start >= NUM_ANYOF_CODE_POINTS) {
18017             break;
18018         }
18019         put_range(sv, start, end, allow_literals);
18020     }
18021     invlist_iterfinish(*invlist_ptr);
18022
18023     return TRUE;
18024 }
18025
18026 #define CLEAR_OPTSTART \
18027     if (optstart) STMT_START {                                               \
18028         DEBUG_OPTIMISE_r(PerlIO_printf(Perl_debug_log,                       \
18029                               " (%"IVdf" nodes)\n", (IV)(node - optstart))); \
18030         optstart=NULL;                                                       \
18031     } STMT_END
18032
18033 #define DUMPUNTIL(b,e)                                                       \
18034                     CLEAR_OPTSTART;                                          \
18035                     node=dumpuntil(r,start,(b),(e),last,sv,indent+1,depth+1);
18036
18037 STATIC const regnode *
18038 S_dumpuntil(pTHX_ const regexp *r, const regnode *start, const regnode *node,
18039             const regnode *last, const regnode *plast,
18040             SV* sv, I32 indent, U32 depth)
18041 {
18042     U8 op = PSEUDO;     /* Arbitrary non-END op. */
18043     const regnode *next;
18044     const regnode *optstart= NULL;
18045
18046     RXi_GET_DECL(r,ri);
18047     GET_RE_DEBUG_FLAGS_DECL;
18048
18049     PERL_ARGS_ASSERT_DUMPUNTIL;
18050
18051 #ifdef DEBUG_DUMPUNTIL
18052     PerlIO_printf(Perl_debug_log, "--- %d : %d - %d - %d\n",indent,node-start,
18053         last ? last-start : 0,plast ? plast-start : 0);
18054 #endif
18055
18056     if (plast && plast < last)
18057         last= plast;
18058
18059     while (PL_regkind[op] != END && (!last || node < last)) {
18060         assert(node);
18061         /* While that wasn't END last time... */
18062         NODE_ALIGN(node);
18063         op = OP(node);
18064         if (op == CLOSE || op == WHILEM)
18065             indent--;
18066         next = regnext((regnode *)node);
18067
18068         /* Where, what. */
18069         if (OP(node) == OPTIMIZED) {
18070             if (!optstart && RE_DEBUG_FLAG(RE_DEBUG_COMPILE_OPTIMISE))
18071                 optstart = node;
18072             else
18073                 goto after_print;
18074         } else
18075             CLEAR_OPTSTART;
18076
18077         regprop(r, sv, node, NULL, NULL);
18078         PerlIO_printf(Perl_debug_log, "%4"IVdf":%*s%s", (IV)(node - start),
18079                       (int)(2*indent + 1), "", SvPVX_const(sv));
18080
18081         if (OP(node) != OPTIMIZED) {
18082             if (next == NULL)           /* Next ptr. */
18083                 PerlIO_printf(Perl_debug_log, " (0)");
18084             else if (PL_regkind[(U8)op] == BRANCH
18085                      && PL_regkind[OP(next)] != BRANCH )
18086                 PerlIO_printf(Perl_debug_log, " (FAIL)");
18087             else
18088                 PerlIO_printf(Perl_debug_log, " (%"IVdf")", (IV)(next - start));
18089             (void)PerlIO_putc(Perl_debug_log, '\n');
18090         }
18091
18092       after_print:
18093         if (PL_regkind[(U8)op] == BRANCHJ) {
18094             assert(next);
18095             {
18096                 const regnode *nnode = (OP(next) == LONGJMP
18097                                        ? regnext((regnode *)next)
18098                                        : next);
18099                 if (last && nnode > last)
18100                     nnode = last;
18101                 DUMPUNTIL(NEXTOPER(NEXTOPER(node)), nnode);
18102             }
18103         }
18104         else if (PL_regkind[(U8)op] == BRANCH) {
18105             assert(next);
18106             DUMPUNTIL(NEXTOPER(node), next);
18107         }
18108         else if ( PL_regkind[(U8)op]  == TRIE ) {
18109             const regnode *this_trie = node;
18110             const char op = OP(node);
18111             const U32 n = ARG(node);
18112             const reg_ac_data * const ac = op>=AHOCORASICK ?
18113                (reg_ac_data *)ri->data->data[n] :
18114                NULL;
18115             const reg_trie_data * const trie =
18116                 (reg_trie_data*)ri->data->data[op<AHOCORASICK ? n : ac->trie];
18117 #ifdef DEBUGGING
18118             AV *const trie_words
18119                            = MUTABLE_AV(ri->data->data[n + TRIE_WORDS_OFFSET]);
18120 #endif
18121             const regnode *nextbranch= NULL;
18122             I32 word_idx;
18123             sv_setpvs(sv, "");
18124             for (word_idx= 0; word_idx < (I32)trie->wordcount; word_idx++) {
18125                 SV ** const elem_ptr = av_fetch(trie_words,word_idx,0);
18126
18127                 PerlIO_printf(Perl_debug_log, "%*s%s ",
18128                    (int)(2*(indent+3)), "",
18129                     elem_ptr
18130                     ? pv_pretty(sv, SvPV_nolen_const(*elem_ptr),
18131                                 SvCUR(*elem_ptr), 60,
18132                                 PL_colors[0], PL_colors[1],
18133                                 (SvUTF8(*elem_ptr)
18134                                  ? PERL_PV_ESCAPE_UNI
18135                                  : 0)
18136                                 | PERL_PV_PRETTY_ELLIPSES
18137                                 | PERL_PV_PRETTY_LTGT
18138                             )
18139                     : "???"
18140                 );
18141                 if (trie->jump) {
18142                     U16 dist= trie->jump[word_idx+1];
18143                     PerlIO_printf(Perl_debug_log, "(%"UVuf")\n",
18144                                (UV)((dist ? this_trie + dist : next) - start));
18145                     if (dist) {
18146                         if (!nextbranch)
18147                             nextbranch= this_trie + trie->jump[0];
18148                         DUMPUNTIL(this_trie + dist, nextbranch);
18149                     }
18150                     if (nextbranch && PL_regkind[OP(nextbranch)]==BRANCH)
18151                         nextbranch= regnext((regnode *)nextbranch);
18152                 } else {
18153                     PerlIO_printf(Perl_debug_log, "\n");
18154                 }
18155             }
18156             if (last && next > last)
18157                 node= last;
18158             else
18159                 node= next;
18160         }
18161         else if ( op == CURLY ) {   /* "next" might be very big: optimizer */
18162             DUMPUNTIL(NEXTOPER(node) + EXTRA_STEP_2ARGS,
18163                     NEXTOPER(node) + EXTRA_STEP_2ARGS + 1);
18164         }
18165         else if (PL_regkind[(U8)op] == CURLY && op != CURLYX) {
18166             assert(next);
18167             DUMPUNTIL(NEXTOPER(node) + EXTRA_STEP_2ARGS, next);
18168         }
18169         else if ( op == PLUS || op == STAR) {
18170             DUMPUNTIL(NEXTOPER(node), NEXTOPER(node) + 1);
18171         }
18172         else if (PL_regkind[(U8)op] == ANYOF) {
18173             /* arglen 1 + class block */
18174             node += 1 + ((ANYOF_FLAGS(node) & ANYOF_MATCHES_POSIXL)
18175                           ? ANYOF_POSIXL_SKIP
18176                           : ANYOF_SKIP);
18177             node = NEXTOPER(node);
18178         }
18179         else if (PL_regkind[(U8)op] == EXACT) {
18180             /* Literal string, where present. */
18181             node += NODE_SZ_STR(node) - 1;
18182             node = NEXTOPER(node);
18183         }
18184         else {
18185             node = NEXTOPER(node);
18186             node += regarglen[(U8)op];
18187         }
18188         if (op == CURLYX || op == OPEN)
18189             indent++;
18190     }
18191     CLEAR_OPTSTART;
18192 #ifdef DEBUG_DUMPUNTIL
18193     PerlIO_printf(Perl_debug_log, "--- %d\n", (int)indent);
18194 #endif
18195     return node;
18196 }
18197
18198 #endif  /* DEBUGGING */
18199
18200 /*
18201  * ex: set ts=8 sts=4 sw=4 et:
18202  */